I’m relatively new to arduinos. I have a M6E-Nano attached to an arduino and am using the test programs and modifying Example 1 to read continuously.
I’ve gotten rid of all the extra outputs as I only want to output the ECP and only if it’s different from the last one. So I’m trying to find the right variable to compare against and the best way to set it up.
I thought the tagEPCBytes was a good one but it just reads the first tag and then stops. So I may have multiple mistakes going on.
Here’s my code. Thank you.
/*
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 <SoftwareSerial.h> //Used for transmitting to the device
SoftwareSerial softSerial(2, 3); //RX, TX
#include "SparkFun_UHF_RFID_Reader.h" //Library for controlling the M6E Nano module
RFID nano; //Create instance
byte responseType;
byte lastTagEPCBytes; //sets value for last read ID to filter repeats to cut down on data posted to file
#define BUZZER1 9
//#define BUZZER1 0 //For testing quietly
#define BUZZER2 10
void setup()
{
pinMode(BUZZER1, OUTPUT);
pinMode(BUZZER2, OUTPUT);
digitalWrite(BUZZER2, LOW); //Pull half the buzzer to ground and drive the other half.
Serial.begin(115200);
while (!Serial); //Wait for the serial port to come online
if (setupNano(38400) == false) //Configure nano to run at 38400bps
{
Serial.println(F("Module failed to respond. Please check wiring."));
while (1); //Freeze!
}
nano.setRegion(REGION_NORTHAMERICA); //Set to North America
nano.setReadPower(1500); //5.00 dBm(500 default). Higher values may caues USB port to brown out
//Max Read TX Power is 27.00 dBm and may cause temperature-limit throttling
//Got rid of start up pause to start reading, no input required from user
//Serial.println(F("Press a key to begin scanning for tags."));
//while (!Serial.available()); //Wait for user to send a character
//Serial.read(); //Throw away the user's character
nano.startReading(); //Begin scanning for tags
}
void loop()
{
if (nano.check() == true) //Check to see if any new data has come in from module
{
responseType = nano.parseResponse(); //Break response into tag ID, RSSI, frequency, and timestamp
if (responseType == RESPONSE_IS_KEEPALIVE)
{
//Serial.println(F("Scanning")); //commented out to keep from scrolling continuously
}
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
if (tagEPCBytes != lastTagEPCBytes)//trying to filter repeat reads to limit output to only new reads
{
//Do nothing, keep looking
// removed printing extra info
// 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("]"));
//Beep! Piano keys to frequencies: http://www.sengpielaudio.com/KeyboardAndFrequencies.gif
tone(BUZZER1, 2093, 150); //C
delay(150);
tone(BUZZER1, 2349, 150); //D
delay(150);
tone(BUZZER1, 2637, 150); //E
delay(150);
lastTagEPCBytes = tagEPCBytes; //sets value for last read ID to filter repeats
//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(" "));
}
//Serial.print(F("]"));
Serial.println();
}
}
else if (responseType == ERROR_CORRUPT_RESPONSE)
{
//Serial.println("Bad CRC"); //commented out to clean up output for file read
}
else
{
//Unknown response
//Serial.print("Unknown error"); //commented out to clean up output for file read
}
}
}
//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)
{
nano.begin(softSerial); //Tell the library to communicate over software serial port
//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
softSerial.begin(baudRate); //For this test, assume module is already at our desired baud rate
while (softSerial.isListening() == false); //Wait for port to open
//About 200ms from power on the module will send its firmware version at 115200. We need to ignore this.
while (softSerial.available()) softSerial.read();
nano.getVersion();
if (nano.msg[0] == ERROR_WRONG_OPCODE_RESPONSE)
{
//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
softSerial.begin(115200); //Start software serial at 115200
nano.setBaud(baudRate); //Tell the module to go to the chosen baud rate. Ignore the response msg
softSerial.begin(baudRate); //Start the software serial port, this time at user's chosen baud rate
delay(250);
}
//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
return (true); //We are ready to rock
}