Untitled

/*
  Reading multiple RFID tags, simultaneously!
  By: Nathan Seidle @ SparkFun Electronics
  Date: October 3rd, 2016
  https://github.com/sparkfun/Simultaneous_RFID_Tag_Reader

  Constantly reads and outputs any tags heard

  If using the Simultaneous RFID Tag Reader (SRTR) shield, make sure the serial slide
  switch is in the 'SW-UART' position
*/
//#include <esp_task_wdt.h>
#include <Esp.h>
#include <SoftwareSerial.h> //Used for transmitting to the device

SoftwareSerial softSerial(D3, D1); //RX, TX

#include "SparkFun_UHF_RFID_Reader.h" //Library for controlling the M6E Nano module
RFID nano; //Create instance

void setup()
{
//  esp_task_wdt_init(30, false);

  Serial.begin(115200);
  ESP.wdtDisable();
  Serial.print("test 1");
  while (!Serial) { yield(); } //Wait for the serial port to come online
  Serial.println("Twest 9");
  if (setupNano(38400) == false) //Configure nano to run at 38400bps
  {
//    Serial.println("test 10");
    Serial.println(F("Module failed to respond. Please check wiring."));
    while (1) { yield(); } //Freeze!
  }
  Serial.print("test 2");

  nano.setRegion(REGION_NORTHAMERICA); //Set to North America

  nano.setReadPower(500); //5.00 dBm. Higher values may caues USB port to brown out
  //Max Read TX Power is 27.00 dBm and may cause temperature-limit throttling

  Serial.println(F("Press a key to begin scanning for tags."));
  while (!Serial.available()) { yield(); }; //Wait for user to send a character
  Serial.read(); //Throw away the user's character

  nano.startReading(); //Begin scanning for tags
  Serial.print("test 3");
}

void loop()
{
//  esp_task_wdt_init(10, false);
  Serial.print("test 4");
  if (nano.check() == true) //Check to see if any new data has come in from module
  {
    byte responseType = nano.parseResponse(); //Break response into tag ID, RSSI, frequency, and timestamp

    if (responseType == RESPONSE_IS_KEEPALIVE)
    {
      Serial.println(F("Scanning"));
    }
    else if (responseType == RESPONSE_IS_TAGFOUND)
    {
      //If we have a full record we can pull out the fun bits
      int rssi = nano.getTagRSSI(); //Get the RSSI for this tag read

      long freq = nano.getTagFreq(); //Get the frequency this tag was detected at

      long timeStamp = nano.getTagTimestamp(); //Get the time this was read, (ms) since last keep-alive message

      byte tagEPCBytes = nano.getTagEPCBytes(); //Get the number of bytes of EPC from response

      Serial.print(F(" rssi["));
      Serial.print(rssi);
      Serial.print(F("]"));

      Serial.print(F(" freq["));
      Serial.print(freq);
      Serial.print(F("]"));

      Serial.print(F(" time["));
      Serial.print(timeStamp);
      Serial.print(F("]"));

      //Print EPC bytes, this is a subsection of bytes from the response/msg array
      Serial.print(F(" epc["));
      for (byte x = 0 ; x < tagEPCBytes ; x++)
      {
        if (nano.msg[31 + x] < 0x10) Serial.print(F("0")); //Pretty print
        Serial.print(nano.msg[31 + x], HEX);
        Serial.print(F(" "));
        yield();
      }
      Serial.print(F("]"));

      Serial.println();
    }
    else if (responseType == ERROR_CORRUPT_RESPONSE)
    {
      Serial.println("Bad CRC");
    }
    else
    {
      //Unknown response
      Serial.print("Unknown error");
    }
  }
}

//Gracefully handles a reader that is already configured and already reading continuously
//Because Stream does not have a .begin() we have to do this outside the library
boolean setupNano(long baudRate)
{
  Serial.println("test a");
  ESP.wdtFeed();
  nano.begin(softSerial); //Tell the library to communicate over software serial port
  Serial.println("test b");

  //Test to see if we are already connected to a module
  //This would be the case if the Arduino has been reprogrammed and the module has stayed powered
  yield();
  ESP.wdtFeed();
  softSerial.begin(baudRate); //For this test, assume module is already at our desired baud rate
  Serial.println("test c");
  while (softSerial.isListening() == false) { ESP.wdtFeed(); } //Wait for port to open
  Serial.println("test d");
  //About 200ms from power on the module will send its firmware version at 115200. We need to ignore this.
  while (softSerial.available()) {
    softSerial.read();
    ESP.wdtFeed();
  }
  Serial.println("test e");

  yield();
//  nano.getVersion();
  Serial.println("test f");


  if (nano.msg[0] == ERROR_WRONG_OPCODE_RESPONSE)
  {
    Serial.println("test aa");
    //This happens if the baud rate is correct but the module is doing a ccontinuous read
    nano.stopReading();

    Serial.println(F("Module continuously reading. Asking it to stop..."));

    delay(1500);
  }
  else
  {
    //The module did not respond so assume it's just been powered on and communicating at 115200bps
    Serial.println("test ab");
    softSerial.begin(115200); //Start software serial at 115200
    Serial.println("test ac");
    yield();
    nano.setBaud(baudRate); //Tell the module to go to the chosen baud rate. Ignore the response msg
    Serial.println("test ad");

    softSerial.begin(baudRate); //Start the software serial port, this time at user's chosen baud rate
    Serial.println("test ae");

    delay(250);
    Serial.println("test af");
  }
  Serial.println("test g");
  //Test the connection
  nano.getVersion();
  if (nano.msg[0] != ALL_GOOD) return (false); //Something is not right

  //The M6E has these settings no matter what
  nano.setTagProtocol(); //Set protocol to GEN2

  nano.setAntennaPort(); //Set TX/RX antenna ports to 1
  Serial.print("test 7");
  return (true); //We are ready to rock
}