RFID and NRF24L01 Wireless Network Coding Issues
-
I am currently working on a project where I am interfacing an RFID-RC522 with a NRF24L01 transceiver on a single Arduino. Ultimately what I would like to have is one RFID-RC522 and NRF24L01 on one arduino, where the RFID can read the UID off of PICC cards, and the connected NRF24L01 can send the UID data to a master NRF24L01 on a different Arduino controller. Currently I am having issues with debugging and coding.
Here is what I have achieved so far:
For the wiring, I used @BartE Garage Door example for the hardware. Here is what he did: garage door example. The pins are set up as follows:
The NRF24L01+ is connect as suggested on the MySensors site:
pin 2 IRQ (I did not have this one connected as I do not believe it is needed in this project. Correct me if this is wrong).
pin 9 CE
pin 10 CSN/CS
pin 11 MOSI
pin 12 MISO
pin 13 SCKThe RC522 module shares pins: (these I connected together on the same row on a prototype board)
pin 11 MOSI
pin 12 MISO
pin 13 SCKand uses
pin 3.3 V (also shared with the NRF24L01) connected together on prototype board
GND (for ground)
pin 7 (iso 9) for CE
pin 8 (iso 10) for CSN/CS.That is the hardware portion of it. Here is the code I have cut and figured out thus far using the garage door example and own research from the mysenors website. I started off adding line by line of code until I ran into problems. Main issue right now is the gw.begin(); not sure if using this function correctly. One main thing I noticed was I had an error with radio inti begin when I first began. I had to go into config.h and change the data rate on the RF24 to 1MPBS rather than the default 250KBPS. That is involved in this gw.begin() instance, and I put that in but it did not solve the problem.
But there may also be other things I am missing as well. Any help would be greatly appreciated.
The following is the code I have made thus far. Ultimately I would like to scan a UID on the RFID and have it sent to the NRF24L01 module to be read out on the serial monitor AND to send it to a NRF24L01 master module (to be set up on a different arduino.)
#include <SPI.h> //used for SPI bus #include <MFRC522.h> //used for RFID reader #include <MySensor.h> //library that uses SPI #define RST_PIN 7 // MFRC RST is used in pin 7 #define SS_PIN 8 // MFRC SS is used in pin 8 MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance #define RFID 1 //construct instance of NRF24 MyTransportNRF24 transport(9, 10); MySensor gw; //create MySensor instance MyMessage msg(RFID, V_VAR1); //create MyMessage instance; this holds message data //and has helpers for setting payload void setup() { Serial.begin(115200); // Initialize serial communications with the PC // Make sure MFRC will be disabled on the SPI bus pinMode(RST_PIN, OUTPUT); //set the RST pin as output digitalWrite(RST_PIN, LOW); //set RST pin off pinMode(SS_PIN, OUTPUT); //set SS pin as output digitalWrite(SS_PIN, LOW); //set SS pin off //initialize radio and start library gw.begin(incomingMessage, RFID, RF24_1MBPS); gw.sendSketchInfo("RFID Radio", "1.0"); //must present sensors before reporting data to controller gw.present(RFID, S_CUSTOM); gw.wait(125); SPI.begin(); // Init SPI bus mfrc522.PCD_Init(); // Init MFRC522 mfrc522.PCD_DumpVersionToSerial(); // Show details of PCD - MFRC522 Card Reader details*/ Serial.println(F("Scan PICC to see UID, type, and data blocks...")); } void loop() { //main issue area here; wasn't sure what to do delay(10000); // Wait 10 seconds gw.process(); } void incomingMessage(const MyMessage &message) { // Look for new cards if ( ! mfrc522.PICC_IsNewCardPresent()) { return; } // Select one of the cards if ( ! mfrc522.PICC_ReadCardSerial()) { return; } // Dump debug info about the card; PICC_HaltA() is automatically called mfrc522.PICC_DumpToSerial(&(mfrc522.uid)); Serial.println(F("Scan PICC to see UID, type, and data blocks...")); }HereHere are the two coding programs for the RFID and NRF24L01 that I am using to base code off of and also what I tested the hardware with initially:
For the RFID: MCRF522 class from Git Hub; Dump Info Example: (I tested this on the RFID separately before interfacing with the NRF24L01 on one arduino):
#include <SPI.h> #include <MFRC522.h> #define RST_PIN 9 // Configurable, see typical pin layout above #define SS_PIN 10 // Configurable, see typical pin layout above MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance void setup() { Serial.begin(9600); // Initialize serial communications with the PC while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4) SPI.begin(); // Init SPI bus mfrc522.PCD_Init(); // Init MFRC522 mfrc522.PCD_DumpVersionToSerial(); // Show details of PCD - MFRC522 Card Reader details Serial.println(F("Scan PICC to see UID, type, and data blocks...")); } void loop() { // Look for new cards if ( ! mfrc522.PICC_IsNewCardPresent()) { return; } // Select one of the cards if ( ! mfrc522.PICC_ReadCardSerial()) { return; } // Dump debug info about the card; PICC_HaltA() is automatically called mfrc522.PICC_DumpToSerial(&(mfrc522.uid)); }For the NRF24L01 transceiver, I originally did hardware testing there were two modules--one for receiving and one for transmitting. So two NRF24L01 modules in all. Each was connected to its own Arduino and then connected to the same laptop with two separate USB cables. I ran two separate Arduino environments on two different serial monitors. I used the GettingStarted Example from the RF24 class off of Git Hub. There is one code for one module below. For the other module, I just switched bool radioNumber = 0 to = 1. This website was helpful for this.
/* * Getting Started example sketch for nRF24L01+ radios * This is a very basic example of how to send data from one node to another * Updated: Dec 2014 by TMRh20 */ #include <SPI.h> #include "RF24.h" /****************** User Config ***************************/ /*** Set this radio as radio number 0 or 1 ***/ bool radioNumber = 0; /* Hardware configuration: Set up nRF24L01 radio on SPI bus plus pins 7 & 8 */ RF24 radio(7,8); /**********************************************************/ byte addresses[][6] = {"1Node","2Node"}; // Used to control whether this node is sending or receiving bool role = 0; void setup() { Serial.begin(115200); Serial.println(F("RF24/examples/GettingStarted")); Serial.println(F("*** PRESS 'T' to begin transmitting to the other node")); radio.begin(); // Set the PA Level low to prevent power supply related issues since this is a // getting_started sketch, and the likelihood of close proximity of the devices. RF24_PA_MAX is default. radio.setPALevel(RF24_PA_LOW); // Open a writing and reading pipe on each radio, with opposite addresses if(radioNumber){ radio.openWritingPipe(addresses[1]); radio.openReadingPipe(1,addresses[0]); }else{ radio.openWritingPipe(addresses[0]); radio.openReadingPipe(1,addresses[1]); } // Start the radio listening for data radio.startListening(); } void loop() { /****************** Ping Out Role ***************************/ if (role == 1) { radio.stopListening(); // First, stop listening so we can talk. Serial.println(F("Now sending")); unsigned long start_time = micros(); // Take the time, and send it. This will block until complete if (!radio.write( &start_time, sizeof(unsigned long) )){ Serial.println(F("failed")); } radio.startListening(); // Now, continue listening unsigned long started_waiting_at = micros(); // Set up a timeout period, get the current microseconds boolean timeout = false; // Set up a variable to indicate if a response was received or not while ( ! radio.available() ){ // While nothing is received if (micros() - started_waiting_at > 200000 ){ // If waited longer than 200ms, indicate timeout and exit while loop timeout = true; break; } } if ( timeout ){ // Describe the results Serial.println(F("Failed, response timed out.")); }else{ unsigned long got_time; // Grab the response, compare, and send to debugging spew radio.read( &got_time, sizeof(unsigned long) ); unsigned long end_time = micros(); // Spew it Serial.print(F("Sent ")); Serial.print(start_time); Serial.print(F(", Got response ")); Serial.print(got_time); Serial.print(F(", Round-trip delay ")); Serial.print(end_time-start_time); Serial.println(F(" microseconds")); } // Try again 1s later delay(1000); } /****************** Pong Back Role ***************************/ if ( role == 0 ) { unsigned long got_time; if( radio.available()){ // Variable for the received timestamp while (radio.available()) { // While there is data ready radio.read( &got_time, sizeof(unsigned long) ); // Get the payload } radio.stopListening(); // First, stop listening so we can talk radio.write( &got_time, sizeof(unsigned long) ); // Send the final one back. radio.startListening(); // Now, resume listening so we catch the next packets. Serial.print(F("Sent response ")); Serial.println(got_time); } } /****************** Change Roles via Serial Commands ***************************/ if ( Serial.available() ) { char c = toupper(Serial.read()); if ( c == 'T' && role == 0 ){ Serial.println(F("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK")); role = 1; // Become the primary transmitter (ping out) }else if ( c == 'R' && role == 1 ){ Serial.println(F("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK")); role = 0; // Become the primary receiver (pong back) radio.startListening(); } } } // Loop```Any help figuring this out would be greatly appreciated!
-
did you figure out how to make it work?
-
Sit with the same scenario. Separately both function. As soon as you share miso, mosi and sck it fails to initialize the radio. Anybody knows whether you can share this ?
Thanks
-
Found the solution in this thread:
https://forum.mysensors.org/topic/2439/rfid-garage-door-opener/35
void before() {
// Make sure MFRC is disabled from the SPI bus
pinMode(RST_PIN, OUTPUT);
digitalWrite(RST_PIN, LOW);
pinMode(SS_PIN, OUTPUT);
digitalWrite(SS_PIN, LOW);
}
-
At least in some first test I got a second SPI device (MCP4131) on the same wires working using the before() instruction.
int CS1 = 10; //MCP4131 void before() { pinMode (CS1, OUTPUT); digitalWrite(CS1, HIGH); }Another option may be to use SoftSPI for thenRF (see Network-Gateway-sketch).
-
@martins
Is it working for you?
-
@gohan Yes
-
I can't figure out what is wrong with mine
-
@gohan What is the serial output or error that you get ?
-
just look at the garage door opener link you posted, there is log and code. If I unplug the radio and use some demo code to read the rfid tag I can read it, but I can't find where it conflicts with the radio
-
@gohan This is the code that works for me on my pro mini. Try it out.
Here is my pins used:
MOSI: Pin 11
MISO: Pin 12
SCK : Pin 13
SS : Pin 8 (Configurable)
RST : Pin 6 (Configurable)/* Arduino RFID Access Control Security ! To keep it simple we are going to use Tag's Unique IDs as only method of Authenticity. It's simple and not hacker proof. If you need security, don't use it unless you modify the code Copyright (C) 2015 Omer Siar Baysal This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #define MY_DEBUG #define MY_RADIO_NRF24 //#define MY_RF24_PA_LEVEL RF24_PA_LOW //#define MY_RADIO_RFM69 //#define MY_RFM69_FREQUENCY RF69_433MHZ //#define MY_IS_RFM69HW #if F_CPU == 8000000L #define MY_BAUD_RATE 38400 #endif #define CHILD_ID 8 #define MAX_CARDS 18 #include <EEPROM.h> // We are going to read and write PICC's UIDs from/to EEPROM #include <SPI.h> // RC522 Module uses SPI protocol #include <MFRC522.h> // Library for Mifare RC522 Devices #include <MySensors.h> /* For visualizing whats going on hardware we need some leds and to control door lock a relay and a wipe button (or some other hardware) Used common anode led,digitalWriting HIGH turns OFF led Mind that if you are going to use common cathode led or just seperate leds, simply comment out #define COMMON_ANODE, */ int value=0; boolean match = false; // initialize card match to false boolean programMode = false; // initialize programming mode to false boolean replaceMaster = false; int successRead; // Variable integer to keep if we have Successful Read from Reader byte storedCard[4]; // Stores an ID read from EEPROM byte readCard[4]; // Stores scanned ID read from RFID Module byte masterCard[4]; // Stores master card's ID read from EEPROM byte countValidCards = 0; /* We need to define MFRC522's pins and create instance Pin layout should be as follows (on Arduino Uno): MOSI: Pin 11 / ICSP-4 MISO: Pin 12 / ICSP-1 SCK : Pin 13 / ICSP-3 SS : Pin 10 (8)(Configurable) RST : Pin 9 (6)(Configurable) look MFRC522 Library for other Arduinos' pin configuration */ // bool lockStatus; #define SS_PIN 8 #define RST_PIN 6 MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance. // MFRC522::Uid validCards[MAX_CARDS]; //MyMessage lockMsg(CHILD_ID, V_LOCK_STATUS); MyMessage msg(CHILD_ID,V_TRIPPED); // MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance. ///////////////////////////////////////// Setup /////////////////////////////////// void setup() { //Protocol Configuration //Serial.begin(9600); // Initialize serial communications with PC pinMode(RST_PIN, OUTPUT); digitalWrite(RST_PIN, LOW); pinMode(SS_PIN, OUTPUT); digitalWrite(SS_PIN, LOW); SPI.begin(); // MFRC522 Hardware uses SPI protocol mfrc522.PCD_Init(); // Initialize MFRC522 Hardware //If you set Antenna Gain to Max it will increase reading distance //mfrc522.PCD_SetAntennaGain(mfrc522.RxGain_max); Serial.println(F("Access Control v3.4")); // For debugging purposes ShowReaderDetails(); // Show details of PCD - MFRC522 Card Reader details if (EEPROM.read(500) != 143) { Serial.println(F("No Master Card Defined")); Serial.println(F("Scan A PICC to Define as Master Card")); do { successRead = getID(); // sets successRead to 1 when we get read from reader otherwise 0 } while (!successRead); // Program will not go further while you not get a successful read // printHex(mfrc522.uid.uidByte, mfrc522.uid.size); for ( int j = 0; j < 4; j++ ) { // Loop 4 times EEPROM.write( 2 + j, readCard[j] ); // Write scanned PICC's UID to EEPROM, start from address 3 } EEPROM.write(500, 143); // Write to EEPROM we defined Master Card. delay(500); Serial.println(F("Master Card Defined")); // storeEeprom(); } Serial.println(F("-------------------")); Serial.println(F("Master Card's UID")); for ( int i = 0; i < 4; i++ ) { // Read Master Card's UID from EEPROM masterCard[i] = EEPROM.read(2 + i); // Write it to masterCard Serial.print(masterCard[i], HEX); } Serial.println(""); Serial.println(F("-------------------")); Serial.println(F("Everything Ready")); Serial.println(F("Waiting PICCs to be scanned")); Serial.println(EEPROM.read(500)); } void presentation() { // Register binary input sensor to gw (they will be created as child devices) // You can use S_DOOR, S_MOTION or S_LIGHT here depending on your usage. // If S_LIGHT is used, remember to update variable type you send in. See "msg" above. sendSketchInfo("RFID Gate", "1.0"); present(CHILD_ID, S_DOOR); } ///////////////////////////////////////// Main Loop /////////////////////////////////// void loop () { send(msg.set(value==HIGH ? 1 : 0)); do { successRead = getID(); // sets successRead to 1 when we get read from reader otherwise 0 } while (!successRead); //the program will not go further while you not get a successful read if (programMode) { if ( isMaster(readCard) ) { //If master card scanned again exit program mode Serial.println(F("Master Card Scanned")); Serial.println(F("Exiting Program Mode")); Serial.println(F("-----------------------------")); programMode = false; return; } else { if ( findID(readCard) ) { // If scanned card is known delete it Serial.println(F("I know this PICC, removing...")); deleteID(readCard); Serial.println("-----------------------------"); Serial.println(F("Scan a PICC to ADD or REMOVE to EEPROM")); } else { // If scanned card is not known add it Serial.println(F("I do not know this PICC, adding...")); writeID(readCard); Serial.println(F("-----------------------------")); Serial.println(F("Scan a PICC to ADD or REMOVE to EEPROM")); } } } else { if ( isMaster(readCard)) { // If scanned card's ID matches Master Card's ID enter program mode programMode = true; Serial.println(F("Hello Master - Entered Program Mode")); int count = EEPROM.read(0); // Read the first Byte of EEPROM that Serial.print(F("I have ")); // stores the number of ID's in EEPROM Serial.print(count); Serial.print(F(" record(s) on EEPROM")); Serial.println(""); Serial.println(F("Scan a PICC to ADD or REMOVE to EEPROM")); Serial.println(F("Scan Master Card again to Exit Program Mode")); Serial.println(F("-----------------------------")); } else { if ( findID(readCard) ) { // If not, see if the card is in the EEPROM Serial.println(F("Welcome, You shall pass")); granted(300); // Open the door lock for 300 ms } else { // If not, show that the ID was not valid Serial.println(F("You shall not pass")); denied(); } } } } ///////////////////////////////////////// Access Granted /////////////////////////////////// void granted (int setDelay) { // setLockState(!lockStatus, true); value = 1; send(msg.set(value==HIGH ? 1 : 0)); smartSleep(5000); value = 0; send(msg.set(value==HIGH ? 1 : 0)); } ///////////////////////////////////////// Access Denied /////////////////////////////////// void denied() { } ///////////////////////////////////////// Get PICC's UID /////////////////////////////////// int getID() { // Getting ready for Reading PICCs if ( ! mfrc522.PICC_IsNewCardPresent()) return 0; // Verify if the NUID has been readed if ( ! mfrc522.PICC_ReadCardSerial()) return 0; Serial.print(F("PICC type: ")); MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak); Serial.println(mfrc522.PICC_GetTypeName(piccType)); // Check is the PICC of Classic MIFARE type if (piccType != MFRC522::PICC_TYPE_MIFARE_MINI && piccType != MFRC522::PICC_TYPE_MIFARE_1K && piccType != MFRC522::PICC_TYPE_MIFARE_4K) { Serial.println(F("Your tag is not of type MIFARE Classic.")); return; } Serial.println(F("Scanned PICC's UID:")); for (int i = 0; i < 4; i++) { // readCard[i] = mfrc522.uid.uidByte[i]; Serial.print(readCard[i], HEX); } Serial.println(""); mfrc522.PICC_HaltA(); return 1; /* while (! mfrc522.PICC_IsNewCardPresent()) {;} if ( ! mfrc522.PICC_IsNewCardPresent()) { //If a new PICC placed to RFID reader continue Serial.println("No NCP"); return 0; } if ( ! mfrc522.PICC_ReadCardSerial()) { //Since a PICC placed get Serial and continue Serial.println("RCS"); return 0; } // There are Mifare PICCs which have 4 byte or 7 byte UID care if you use 7 byte PICC // I think we should assume every PICC as they have 4 byte UID // Until we support 7 byte PICCs Serial.println(F("Scanned PICC's UID:")); for (int i = 0; i < 4; i++) { // readCard[i] = mfrc522.uid.uidByte[i]; Serial.print(readCard[i], HEX); } Serial.println(""); mfrc522.PICC_HaltA(); // Stop reading return 1; */ } void ShowReaderDetails() { // Get the MFRC522 software version byte v = mfrc522.PCD_ReadRegister(mfrc522.VersionReg); Serial.print(F("MFRC522 Software Version: 0x")); Serial.print(v, HEX); if (v == 0x91) Serial.print(F(" = v1.0")); else if (v == 0x92) Serial.print(F(" = v2.0")); else Serial.print(F(" (unknown),probably a chinese clone?")); Serial.println(""); // When 0x00 or 0xFF is returned, communication probably failed if ((v == 0x00) || (v == 0xFF)) { Serial.println(F("WARNING: Communication failure, is the MFRC522 properly connected?")); Serial.println(F("SYSTEM HALTED: Check connections.")); while (true); // do not go further } } ///////////////////////////////////////// Cycle Leds (Program Mode) /////////////////////////////////// void cycleLeds() { } //////////////////////////////////////// Normal Mode Led /////////////////////////////////// void normalModeOn () { } //////////////////////////////////////// Read an ID from EEPROM ////////////////////////////// void readID( int number ) { int start = (number * 4 ) + 2; // Figure out starting position for ( int i = 0; i < 4; i++ ) { // Loop 4 times to get the 4 Bytes storedCard[i] = EEPROM.read(start + i); // Assign values read from EEPROM to array } } ///////////////////////////////////////// Add ID to EEPROM /////////////////////////////////// void writeID( byte a[] ) { if ( !findID( a ) ) { // Before we write to the EEPROM, check to see if we have seen this card before! int num = EEPROM.read(0); // Get the numer of used spaces, position 0 stores the number of ID cards int start = ( num * 4 ) + 6; // Figure out where the next slot starts num++; // Increment the counter by one EEPROM.write( 0, num ); // Write the new count to the counter for ( int j = 0; j < 4; j++ ) { // Loop 4 times EEPROM.write( start + j, a[j] ); // Write the array values to EEPROM in the right position } successWrite(); Serial.println(F("Succesfully added ID record to EEPROM")); } else { failedWrite(); Serial.println(F("Failed! There is something wrong with ID or bad EEPROM")); } } ///////////////////////////////////////// Remove ID from EEPROM /////////////////////////////////// void deleteID( byte a[] ) { if ( !findID( a ) ) { // Before we delete from the EEPROM, check to see if we have this card! failedWrite(); // If not Serial.println(F("Failed! There is something wrong with ID or bad EEPROM")); } else { int num = EEPROM.read(0); // Get the numer of used spaces, position 0 stores the number of ID cards int slot; // Figure out the slot number of the card int start; // = ( num * 4 ) + 6; // Figure out where the next slot starts int looping; // The number of times the loop repeats int j; int count = EEPROM.read(0); // Read the first Byte of EEPROM that stores number of cards slot = findIDSLOT( a ); // Figure out the slot number of the card to delete start = (slot * 4) + 2; looping = ((num - slot) * 4); num--; // Decrement the counter by one EEPROM.write( 0, num ); // Write the new count to the counter for ( j = 0; j < looping; j++ ) { // Loop the card shift times EEPROM.write( start + j, EEPROM.read(start + 4 + j)); // Shift the array values to 4 places earlier in the EEPROM } for ( int k = 0; k < 4; k++ ) { // Shifting loop EEPROM.write( start + j + k, 0); } successDelete(); Serial.println(F("Succesfully removed ID record from EEPROM")); } } ///////////////////////////////////////// Check Bytes /////////////////////////////////// boolean checkTwo ( byte a[], byte b[] ) { if ( a[0] != NULL ) // Make sure there is something in the array first match = true; // Assume they match at first for ( int k = 0; k < 4; k++ ) { // Loop 4 times if ( a[k] != b[k] ) // IF a != b then set match = false, one fails, all fail match = false; } if ( match ) { // Check to see if if match is still true return true; // Return true } else { return false; // Return false } } ///////////////////////////////////////// Find Slot /////////////////////////////////// int findIDSLOT( byte find[] ) { int count = EEPROM.read(0); // Read the first Byte of EEPROM that for ( int i = 1; i <= count; i++ ) { // Loop once for each EEPROM entry readID(i); // Read an ID from EEPROM, it is stored in storedCard[4] if ( checkTwo( find, storedCard ) ) { // Check to see if the storedCard read from EEPROM // is the same as the find[] ID card passed return i; // The slot number of the card break; // Stop looking we found it } } } ///////////////////////////////////////// Find ID From EEPROM /////////////////////////////////// boolean findID( byte find[] ) { int count = EEPROM.read(0); // Read the first Byte of EEPROM that for ( int i = 1; i <= count; i++ ) { // Loop once for each EEPROM entry readID(i); // Read an ID from EEPROM, it is stored in storedCard[4] if ( checkTwo( find, storedCard ) ) { // Check to see if the storedCard read from EEPROM return true; break; // Stop looking we found it } else { // If not, return false } } return false; } ///////////////////////////////////////// Write Success to EEPROM /////////////////////////////////// // Flashes the green LED 3 times to indicate a successful write to EEPROM void successWrite() { } ///////////////////////////////////////// Write Failed to EEPROM /////////////////////////////////// // Flashes the red LED 3 times to indicate a failed write to EEPROM void failedWrite() { } ///////////////////////////////////////// Success Remove UID From EEPROM /////////////////////////////////// // Flashes the blue LED 3 times to indicate a success delete to EEPROM void successDelete() { } ////////////////////// Check readCard IF is masterCard /////////////////////////////////// // Check to see if the ID passed is the master programing card boolean isMaster( byte test[] ) { if ( checkTwo( test, masterCard ) ) return true; else return false; } /** * Helper routine to dump a byte array as hex values to Serial. */ void printHex(byte *buffer, byte bufferSize) { for (byte i = 0; i < bufferSize; i++) { Serial.print(buffer[i] < 0x10 ? " 0" : " "); Serial.print(buffer[i], HEX); } } //void presentation() { // sendSketchInfo("RFID Lock", "1.0"); // present(CHILD_ID, S_LOCK); //} void before() { // Make sure MFRC is disabled from the SPI bus pinMode(RST_PIN, OUTPUT); digitalWrite(RST_PIN, LOW); pinMode(SS_PIN, OUTPUT); digitalWrite(SS_PIN, LOW); }
-
Tnx, I'll try in the next days.
Ps I edited your post with the correct tag for the code
-
Help!
I have a RFID RC522 module I'm trying to use instead of the PN532 NFC RFID Reader/Writer Module used in the RFID Lock Sensor example (https://www.mysensors.org/build/rfid).
I thought I could use the sketch above posted by @martins but I get the following error message. I'm a newbie so I don't really know what I'm doing wrong?
Arduino: 1.8.1 (Windows 10), Board: "Arduino Pro or Pro Mini, ATmega328 (5V, 16 MHz)" Build options changed, rebuilding all C:\Users\arons\Documents\Arduino\Vera_RFID-RC522\Vera_RFID-RC522.ino: In function 'int getID()': Vera_RFID-RC522:259: error: return-statement with no value, in function returning 'int' [-fpermissive] return; ^ exit status 1 return-statement with no value, in function returning 'int' [-fpermissive]
-
@Aron-Sjöberg said in RFID and NRF24L01 Wireless Network Coding Issues:
int getID()
Change that line in the getID() function to return 0;
-
Could You please explain what do You mean by "Change that line in the getID() function to return 0;"
I am trying to run the sketch but I have the same problem as @Aron-Sjöberg.
Could You let me know which MFC library version I should use ?
-
Hi everyone,
I have problem on RFID sketch, when i scan the card its unlock the door but when i switch from openhab its not unlock.the sketch is
/* -------------------------------------------------------------------------------------------------------------------- Example sketch/program showing An Arduino Door Access Control featuring RFID, EEPROM, Relay -------------------------------------------------------------------------------------------------------------------- This is a MFRC522 library example; for further details and other examples see: https://github.com/miguelbalboa/rfid This example showing a complete Door Access Control System Simple Work Flow (not limited to) : +---------+ +----------------------------------->READ TAGS+^------------------------------------------+ | +--------------------+ | | | | | | | | | | +----v-----+ +-----v----+ | | |MASTER TAG| |OTHER TAGS| | | +--+-------+ ++-------------+ | | | | | | | | | | | | +-----v---+ +----v----+ +----v------+ | | +------------+READ TAGS+---+ |KNOWN TAG| |UNKNOWN TAG| | | | +-+-------+ | +-----------+ +------------------+ | | | | | | | | | +----v-----+ +----v----+ +--v--------+ +-v----------+ +------v----+ | | |MASTER TAG| |KNOWN TAG| |UNKNOWN TAG| |GRANT ACCESS| |DENY ACCESS| | | +----------+ +---+-----+ +-----+-----+ +-----+------+ +-----+-----+ | | | | | | | | +----+ +----v------+ +--v---+ | +---------------> +-------+EXIT| |DELETE FROM| |ADD TO| | | +----+ | EEPROM | |EEPROM| | | +-----------+ +------+ +-------------------------------+ Use a Master Card which is act as Programmer then you can able to choose card holders who will granted access or not * **Easy User Interface** Just one RFID tag needed whether Delete or Add Tags. You can choose to use Leds for output or Serial LCD module to inform users. * **Stores Information on EEPROM** Information stored on non volatile Arduino's EEPROM memory to preserve Users' tag and Master Card. No Information lost if power lost. EEPROM has unlimited Read cycle but roughly 100,000 limited Write cycle. * **Security** To keep it simple we are going to use Tag's Unique IDs. It's simple and not hacker proof. @license Released into the public domain. Typical pin layout used: ----------------------------------------------------------------------------------------- MFRC522 Arduino Arduino Arduino Arduino Arduino Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro Signal Pin Pin Pin Pin Pin Pin ----------------------------------------------------------------------------------------- RST/Reset RST 9 5 D9 RESET/ICSP-5 RST SPI SS SDA(SS) 10 53 D10 10 10 SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16 SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14 SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15 */ #define MY_DEBUG #define MY_RADIO_RF24 #define MY_NODE_ID 50 #include <SPI.h> // RC522 Module uses SPI protocol #include <MFRC522.h> // Library for Mifare RC522 Devices #include <MySensors.h> /* Instead of a Relay you may want to use a servo. Servos can lock and unlock door locks too Relay will be used by default */ #define RFID 1 // #include <Servo.h> /* For visualizing whats going on hardware we need some leds and to control door lock a relay and a wipe button (or some other hardware) Used common anode led,digitalWriting HIGH turns OFF led Mind that if you are going to use common cathode led or just seperate leds, simply comment out #define COMMON_ANODE, */ //#define COMMON_ANODE #ifdef COMMON_ANODE #define LED_ON LOW #define LED_OFF HIGH #else #define LED_ON HIGH #define LED_OFF LOW #endif #define redLed 4 // Set Led Pins #define greenLed 5 #define blueLed 6 #define relay 2 // Set Relay Pin #define wipeB 3 // Button pin for WipeMode bool programMode = false; // initialize programming mode to false uint8_t successRead; // Variable integer to keep if we have Successful Read from Reader byte storedCard[4]; // Stores an ID read from EEPROM byte readCard[4]; // Stores scanned ID read from RFID Module byte masterCard[4]; // Stores master card's ID read from EEPROM byte dumpedCard[4]; static const uint8_t MAGIC = 168; // Create MFRC522 instance. #define SS_PIN 8 #define RST_PIN 7 MFRC522 mfrc522(SS_PIN, RST_PIN); void before() { // Make sure MFRC is disabled from the SPI bus pinMode(RST_PIN, OUTPUT); digitalWrite(RST_PIN, LOW); pinMode(SS_PIN, OUTPUT); digitalWrite(SS_PIN, LOW); } ///////////////////////////////////////// Setup /////////////////////////////////// void setup() { //Arduino Pin Configuration pinMode(redLed, OUTPUT); pinMode(greenLed, OUTPUT); pinMode(blueLed, OUTPUT); pinMode(wipeB, INPUT_PULLUP); // Enable pin's pull up resistor pinMode(relay, OUTPUT); //Be careful how relay circuit behave on while resetting or power-cycling your Arduino digitalWrite(relay, HIGH); // Make sure door is locked digitalWrite(redLed, LED_OFF); // Make sure led is off digitalWrite(greenLed, LED_OFF); // Make sure led is off digitalWrite(blueLed, LED_OFF); // Make sure led is off //Protocol Configuration Serial.begin(115200); // Initialize serial communications with PC SPI.begin(); // MFRC522 Hardware uses SPI protocol mfrc522.PCD_Init(); // Initialize MFRC522 Hardware //If you set Antenna Gain to Max it will increase reading distance //mfrc522.PCD_SetAntennaGain(mfrc522.RxGain_max); Serial.println(F("Access Control v2.0")); // For debugging purposes ShowReaderDetails(); // Show details of PCD - MFRC522 Card Reader details checkWipe(); // Check if master card defined, if not let user choose a master card // This also useful to just redefine the Master Card // You can keep other EEPROM records just write other than MAGIC to EEPROM address 1 // EEPROM address 1 should hold magical number which is 'MAGIC' if (loadState(1) != MAGIC) { Serial.println(F("No Master Card Defined")); Serial.println(F("Scan A PICC to Define as Master Card")); do { successRead = getID(); // sets successRead to 1 when we get read from reader otherwise 0 digitalWrite(blueLed, LED_ON); // Visualize Master Card need to be defined delay(200); digitalWrite(blueLed, LED_OFF); delay(200); } while (!successRead); // Program will not go further while you not get a successful read for ( uint8_t j = 0; j < 4; j++ ) { // Loop 4 times saveState( 2 + j, readCard[j] ); // Write scanned PICC's UID to EEPROM, start from address 3 } saveState(1, MAGIC); // Write to EEPROM we defined Master Card. Serial.println(F("Master Card Defined")); } Serial.println(F("-------------------")); Serial.println(F("Master Card's UID")); for ( uint8_t i = 0; i < 4; i++ ) { // Read Master Card's UID from EEPROM masterCard[i] = loadState(2 + i); // Write it to masterCard Serial.print(masterCard[i], HEX); } Serial.println(""); Serial.println(F("-------------------")); Serial.println(F("Everything is ready")); Serial.println(F("Waiting PICCs to be scanned")); cycleLeds(); // Everything ready lets give user some feedback by cycling leds } //////////////////////////////////////// MySensors Presentation /////////////////////////////// MyMessage lockMsg(RFID, V_LOCK_STATUS); void presentation() { // Register binary input sensor to gw (they will be created as child devices) // You can use S_DOOR, S_MOTION or S_LIGHT here depending on your usage. // If S_LIGHT is used, remember to update variable type you send in. See "msg" above. sendSketchInfo("RFID PintuBesi", "1.0"); present(RFID, S_LOCK); } ///////////////////////////////////////// Main Loop /////////////////////////////////// void loop () { do { successRead = getID(); // sets successRead to 1 when we get read from reader otherwise 0 checkWipe(); if (programMode) { cycleLeds(); // Program Mode cycles through Red Green Blue waiting to read a new card } else { normalModeOn(); // Normal mode, blue Power LED is on, all others are off } } while (!successRead); //the program will not go further while you are not getting a successful read if (programMode) { if ( isMaster(readCard) ) { //When in program mode check First If master card scanned again to exit program mode Serial.println(F("Master Card Scanned")); Serial.println(F("Exiting Program Mode")); Serial.println(F("-----------------------------")); programMode = false; return; } else { if ( findID(readCard) ) { // If scanned card is known delete it Serial.println(F("I know this PICC, removing...")); deleteID(readCard); Serial.println("-----------------------------"); Serial.println(F("Scan a PICC to ADD or REMOVE to EEPROM")); } else { // If scanned card is not known add it Serial.println(F("I do not know this PICC, adding...")); writeID(readCard); Serial.println(F("-----------------------------")); Serial.println(F("Scan a PICC to ADD or REMOVE to EEPROM")); } } } else { if ( isMaster(readCard)) { // If scanned card's ID matches Master Card's ID - enter program mode programMode = true; Serial.println(F("Hello Master - Entered Program Mode")); uint8_t count = loadState(0); // Read the first Byte of EEPROM that Serial.print(F("I have ")); // stores the number of ID's in EEPROM Serial.print(count); Serial.print(F(" record(s) on EEPROM")); Serial.println(""); Serial.println(F("Scan a PICC to ADD or REMOVE to EEPROM")); Serial.println(F("Scan Master Card again to Exit Program Mode")); Serial.println(F("-----------------------------")); } else { if ( findID(readCard) ) { // If not, see if the card is in the EEPROM Serial.println(F("Welcome, You shall pass")); granted(300); // Open the door lock for 300 ms } else { // If not, show that the ID was not valid Serial.println(F("You shall not pass")); denied(); } } } } ///////////////////////////////////////// Access Granted /////////////////////////////////// void granted ( uint16_t setDelay) { digitalWrite(blueLed, LED_OFF); // Turn off blue LED digitalWrite(redLed, LED_OFF); // Turn off red LED digitalWrite(greenLed, LED_ON); // Turn on green LED digitalWrite(relay, LOW); // Unlock door! send(lockMsg.set(false)); delay(setDelay); // Hold door lock open for given seconds digitalWrite(relay, HIGH); // Relock door send(lockMsg.set(true)); delay(1000); // Hold green LED on for a second } ///////////////////////////////////////// Access Denied /////////////////////////////////// void denied() { digitalWrite(greenLed, LED_OFF); // Make sure green LED is off digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off digitalWrite(redLed, LED_ON); // Turn on red LED delay(1000); } ///////////////////////////////////////// Get PICC's UID /////////////////////////////////// uint8_t getID() { // Getting ready for Reading PICCs if ( ! mfrc522.PICC_IsNewCardPresent()) { //If a new PICC placed to RFID reader continue return 0; } if ( ! mfrc522.PICC_ReadCardSerial()) { //Since a PICC placed get Serial and continue return 0; } // There are Mifare PICCs which have 4 byte or 7 byte UID care if you use 7 byte PICC // I think we should assume every PICC as they have 4 byte UID // Until we support 7 byte PICCs Serial.println(F("Scanned PICC's UID:")); for ( uint8_t i = 0; i < 4; i++) { // readCard[i] = mfrc522.uid.uidByte[i]; Serial.print(readCard[i], HEX); } Serial.println(""); mfrc522.PICC_HaltA(); // Stop reading return 1; } void ShowReaderDetails() { // Get the MFRC522 software version byte v = mfrc522.PCD_ReadRegister(mfrc522.VersionReg); Serial.print(F("MFRC522 Software Version: 0x")); Serial.print(v, HEX); if (v == 0x91) Serial.print(F(" = v1.0")); else if (v == 0x92) Serial.print(F(" = v2.0")); else Serial.print(F(" (unknown),probably a chinese clone?")); Serial.println(""); // When 0x00 or 0xFF is returned, communication probably failed if ((v == 0x00) || (v == 0xFF)) { Serial.println(F("WARNING: Communication failure, is the MFRC522 properly connected?")); Serial.println(F("SYSTEM HALTED: Check connections.")); // Visualize system is halted digitalWrite(greenLed, LED_OFF); // Make sure green LED is off digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off digitalWrite(redLed, LED_ON); // Turn on red LED while (true); // do not go further } } ///////////////////////////////////////// Cycle Leds (Program Mode) /////////////////////////////////// void cycleLeds() { digitalWrite(redLed, LED_OFF); // Make sure red LED is off digitalWrite(greenLed, LED_ON); // Make sure green LED is on digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off delay(200); digitalWrite(redLed, LED_OFF); // Make sure red LED is off digitalWrite(greenLed, LED_OFF); // Make sure green LED is off digitalWrite(blueLed, LED_ON); // Make sure blue LED is on delay(200); digitalWrite(redLed, LED_ON); // Make sure red LED is on digitalWrite(greenLed, LED_OFF); // Make sure green LED is off digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off delay(200); } //////////////////////////////////////// Normal Mode Led /////////////////////////////////// void normalModeOn () { digitalWrite(blueLed, LED_ON); // Blue LED ON and ready to read card digitalWrite(redLed, LED_OFF); // Make sure Red LED is off digitalWrite(greenLed, LED_OFF); // Make sure Green LED is off digitalWrite(relay, HIGH); // Make sure Door is Locked } //////////////////////////////////////// Read an ID from EEPROM ////////////////////////////// void readID( uint8_t number ) { uint8_t start = (number * 4 ) + 2; // Figure out starting position loadCard(start, storedCard); } ///////////////////////////////////////// Add ID to EEPROM /////////////////////////////////// void writeID( byte a[] ) { if ( !findID( a ) ) { // Before we write to the EEPROM, check to see if we have seen this card before! uint8_t num = loadState(0); // Get the numer of used spaces, position 0 stores the number of ID cards uint8_t start = ( num * 4 ) + 6; // Figure out where the next slot starts num++; // Increment the counter by one saveState( 0, num ); // Write the new count to the counter //for ( uint8_t j = 0; j < 4; j++ ) { // Loop 4 times // saveState( start + j, a[j] ); // Write the array values to EEPROM in the right position //} saveCard(start, a); successWrite(); Serial.println(F("Succesfully added ID record to EEPROM")); } else { failedWrite(); Serial.println(F("Failed! There is something wrong with ID or bad EEPROM")); } } ///////////////////////////////////////// Remove ID from EEPROM /////////////////////////////////// void deleteID( byte a[] ) { if ( !findID( a ) ) { // Before we delete from the EEPROM, check to see if we have this card! failedWrite(); // If not Serial.println(F("Failed! There is something wrong with ID or bad EEPROM")); } else { uint8_t num = loadState(0); // Get the numer of used spaces, position 0 stores the number of ID cards uint8_t slot; // Figure out the slot number of the card uint8_t start; // = ( num * 4 ) + 6; // Figure out where the next slot starts uint8_t looping; // The number of times the loop repeats uint8_t j; uint8_t count = loadState(0); // Read the first Byte of EEPROM that stores number of cards slot = findIDSLOT( a ); // Figure out the slot number of the card to delete start = (slot * 4) + 2; looping = ((num - slot) * 4); num--; // Decrement the counter by one saveState( 0, num ); // Write the new count to the counter for ( j = 0; j < looping; j++ ) { // Loop the card shift times saveState( start + j, loadState(start + 4 + j)); // Shift the array values to 4 places earlier in the EEPROM } for ( uint8_t k = 0; k < 4; k++ ) { // Shifting loop saveState( start + j + k, 0); } successDelete(); Serial.println(F("Succesfully removed ID record from EEPROM")); } } ///////////////////////////////////////// Check Bytes /////////////////////////////////// bool checkTwo ( byte a[], byte b[] ) { for ( uint8_t k = 0; k < 4; k++ ) { // Loop 4 times if ( a[k] != b[k] ) { // IF a != b then false, because: one fails, all fail return false; } } return true; } ///////////////////////////////////////// Find Slot /////////////////////////////////// uint8_t findIDSLOT( byte find[] ) { uint8_t count = loadState(0); // Read the first Byte of EEPROM that for ( uint8_t i = 1; i <= count; i++ ) { // Loop once for each EEPROM entry readID(i); // Read an ID from EEPROM, it is stored in storedCard[4] if ( checkTwo( find, storedCard ) ) { // Check to see if the storedCard read from EEPROM // is the same as the find[] ID card passed return i; // The slot number of the card } } } ///////////////////////////////////////// Find ID From EEPROM /////////////////////////////////// bool findID( byte find[] ) { uint8_t count = loadState(0); // Read the first Byte of EEPROM that for ( uint8_t i = 1; i <= count; i++ ) { // Loop once for each EEPROM entry readID(i); // Read an ID from EEPROM, it is stored in storedCard[4] if ( checkTwo( find, storedCard ) ) // Check to see if the storedCard read from EEPROM return true; } return false; } ///////////////////////////////////////// Write Success to EEPROM /////////////////////////////////// // Flashes the green LED 3 times to indicate a successful write to EEPROM void successWrite() { digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off digitalWrite(redLed, LED_OFF); // Make sure red LED is off digitalWrite(greenLed, LED_OFF); // Make sure green LED is on delay(200); digitalWrite(greenLed, LED_ON); // Make sure green LED is on delay(200); digitalWrite(greenLed, LED_OFF); // Make sure green LED is off delay(200); digitalWrite(greenLed, LED_ON); // Make sure green LED is on delay(200); digitalWrite(greenLed, LED_OFF); // Make sure green LED is off delay(200); digitalWrite(greenLed, LED_ON); // Make sure green LED is on delay(200); } ///////////////////////////////////////// Write Failed to EEPROM /////////////////////////////////// // Flashes the red LED 3 times to indicate a failed write to EEPROM void failedWrite() { digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off digitalWrite(redLed, LED_OFF); // Make sure red LED is off digitalWrite(greenLed, LED_OFF); // Make sure green LED is off delay(200); digitalWrite(redLed, LED_ON); // Make sure red LED is on delay(200); digitalWrite(redLed, LED_OFF); // Make sure red LED is off delay(200); digitalWrite(redLed, LED_ON); // Make sure red LED is on delay(200); digitalWrite(redLed, LED_OFF); // Make sure red LED is off delay(200); digitalWrite(redLed, LED_ON); // Make sure red LED is on delay(200); } ///////////////////////////////////////// Success Remove UID From EEPROM /////////////////////////////////// // Flashes the blue LED 3 times to indicate a success delete to EEPROM void successDelete() { digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off digitalWrite(redLed, LED_OFF); // Make sure red LED is off digitalWrite(greenLed, LED_OFF); // Make sure green LED is off delay(200); digitalWrite(blueLed, LED_ON); // Make sure blue LED is on delay(200); digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off delay(200); digitalWrite(blueLed, LED_ON); // Make sure blue LED is on delay(200); digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off delay(200); digitalWrite(blueLed, LED_ON); // Make sure blue LED is on delay(200); } ////////////////////// Check readCard IF is masterCard /////////////////////////////////// // Check to see if the ID passed is the master programing card bool isMaster( byte test[] ) { return checkTwo(test, masterCard); } bool monitorWipeButton(uint32_t interval) { uint32_t now = (uint32_t)millis(); while ((uint32_t)millis() - now < interval) { // check on every half a second if (((uint32_t)millis() % 500) == 0) { if (digitalRead(wipeB) != LOW) return false; } } return true; } void saveCard(uint8_t startPos, byte *card) { for ( uint8_t j = 0; j < 4; j++ ) { // Loop 4 times saveState( startPos + j, card[j] ); // Write scanned PICC's UID to EEPROM, start from address 3 } } void loadCard(uint8_t startPos, byte *card) { for ( uint8_t i = 0; i < 4; i++ ) // Read Card's UID from EEPROM card[i] = loadState(startPos + i); // Write it to the card } void checkWipe() { //Wipe Code - If the Button (wipeB) Pressed while setup run (powered on) it wipes EEPROM if (digitalRead(wipeB) == LOW) { // when button pressed pin should get low, button connected to ground digitalWrite(redLed, LED_ON); // Red Led stays on to inform user we are going to wipe Serial.println(F("Wipe Button Pressed")); Serial.println(F("You have 10 seconds to Cancel")); Serial.println(F("This will be remove all records and cannot be undone")); bool buttonState = monitorWipeButton(10000); // Give user enough time to cancel operation if (buttonState == true && digitalRead(wipeB) == LOW) { // If button still be pressed, wipe EEPROM Serial.println(F("Starting Wiping EEPROM")); Serial.println(F("Starting Wiping")); saveState(0, 0 ); // light wipe. only erase number saveState(1, 0); // light wipe. only erase magic number Serial.println(F("EEPROM Successfully Wiped")); digitalWrite(redLed, LED_OFF); // visualize a successful wipe delay(200); digitalWrite(redLed, LED_ON); delay(200); digitalWrite(redLed, LED_OFF); delay(200); digitalWrite(redLed, LED_ON); delay(200); digitalWrite(redLed, LED_OFF); } else { Serial.println(F("Wiping Cancelled")); // Show some feedback that the wipe button did not pressed for 15 seconds digitalWrite(redLed, LED_OFF); } } } void receive(const MyMessage &message) { if (message.type == V_LOCK_STATUS) { // Change relay state if (!message.getBool()) { granted(300); } } }need advise, thanks
regards
-
@mfalkvidd, should this not be better receive it's own topic?
@Ispandy, does your node receives the message from openhab?
Change the code in the receive method to be able to serial print debug messages. Maybe openhab is not using the correction message type...
-
@evb, thank you for the reply
In that sketch above the node doesn't receive message from openhab, but the other node using same message type "message.type == V_LOCK_STATUS" it does receive message from openhab.
-
@Ispandy are you now speaking about 2 nodes?
In that sketch above the node doesn't receive message from openhab
Did you add serial prints to be sure you don't receive anything. May you receive messages but not of the type V_LOCK_STATUS.You should explain more in detail how your setup is done, because for me it isn't clear
-
@evb yes i have 2 nodes (node 3 and node 50) all with MRFC522 right now, the node 3 is working perfectly but i dont like add and remove card system, I just want to change the part of the RFID sketch on node 3 using the sketch above, so i make one node for test (node 50) and put the code
send(lockMsg.set(false));and
send(lockMsg.set(true));to this
void granted ( uint16_t setDelay) { digitalWrite(blueLed, LED_OFF); // Turn off blue LED digitalWrite(redLed, LED_OFF); // Turn off red LED digitalWrite(greenLed, LED_ON); // Turn on green LED digitalWrite(relay, LOW); // Unlock door! send(lockMsg.set(false)); delay(setDelay); // Hold door lock open for given seconds digitalWrite(relay, HIGH); // Relock door send(lockMsg.set(true)); delay(1000); // Hold green LED on for a second }and i add this to node 50
if (message.type == V_LOCK_STATUS) { // Change relay state if (!message.getBool()) { granted(300); } // Write some debug info Serial.print(F("Lock status: ")); Serial.println(message.getBool()); } else { // Write some debug info Serial.print(F("Incoming msg type: ")); Serial.print(message.type); Serial.print(F(" id: ")); Serial.print(message.sensor); Serial.print(F(" content: ")); Serial.println(message.getInt()); }nothing happen...
sketch Node 3
/ // Enable debug prints #define MY_DEBUG #define MY_NODE_ID 3 // Enable and select radio type attached #define MY_RADIO_RF24 //#define MY_RF24_CHANNEL 10 #include <MySensors.h> #include <SPI.h> #include <MFRC522.h> #include <Bounce2.h> #define RF_INIT_DELAY 125 #define ONE_SEC 1000 #define MAX_CARDS 18 #define PROG_WAIT 10 #define HEARTBEAT 10 #define BAUD 115200 /*Pin definitions*/ #define LED_PIN 4 #define GARAGEPIN 2 #define SWITCH_PIN 3 #define RST_PIN 7 // MFRC #define SS_PIN 8 // MFRC MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance MFRC522::Uid olduid; MFRC522::Uid masterkey = { 4,{ 0xEF,0xDB,0x8E,0x79 },0 }; byte countValidCards = 0; MFRC522::Uid validCards[MAX_CARDS]; void ShowCardData(MFRC522::Uid* uid); bool sameUid(MFRC522::Uid* old, MFRC522::Uid* check); void copyUid(MFRC522::Uid* src, MFRC522::Uid* dest); bool isValidCard(MFRC522::Uid* uid); int releasecnt = 0; //#define CHILD_ID_ALARM 2 #define CHILD_ID_LOCK 1 Bounce debouncer = Bounce(); int oldSwitchValue = -1; int switchValue = 0; long timer = -1; bool programmode = false; bool ledon; int programTimer = 0; bool armed = true; unsigned long lastTime = 0; MyMessage lockMsg(CHILD_ID_LOCK, V_LOCK_STATUS); //MyMessage lockArmMsg(CHILD_ID_ALARM, V_ARMED); //MyMessage wrongMsg(CHILD_ID_ALARM, V_TRIPPED); void before() { // Make sure MFRC is disabled from the SPI bus pinMode(RST_PIN, OUTPUT); digitalWrite(RST_PIN, LOW); pinMode(SS_PIN, OUTPUT); digitalWrite(SS_PIN, LOW); } void presentation() { sendSketchInfo("RFID Garage", "1.1"); delay(RF_INIT_DELAY); // Register all sensors to gw (they will be created as child devices) present(CHILD_ID_LOCK, S_LOCK); delay(RF_INIT_DELAY); //present(CHILD_ID_ALARM, S_MOTION); delay(RF_INIT_DELAY); } void setup() { Serial.begin(BAUD); // Initialize serial communications with the PC pinMode(GARAGEPIN, OUTPUT); // Initialise in/output ports // Make sure MFRC will be disabled on the SPI bus /*pinMode(RST_PIN, OUTPUT); digitalWrite(RST_PIN, LOW); pinMode(SS_PIN, OUTPUT); digitalWrite(SS_PIN, LOW);*/ pinMode(LED_PIN, OUTPUT); digitalWrite(LED_PIN, LOW); // Setup the button pinMode(SWITCH_PIN, INPUT); // Activate internal pull-up digitalWrite(SWITCH_PIN, HIGH); // After setting up the button, setup debouncer debouncer.attach(SWITCH_PIN); debouncer.interval(5); // Init mysensors library /*sendSketchInfo("RFID Garage", "1.1"); delay(RF_INIT_DELAY); // Register all sensors to gw (they will be created as child devices) present(CHILD_ID_LOCK, S_LOCK); delay(RF_INIT_DELAY); present(CHILD_ID_ALARM, S_MOTION); delay(RF_INIT_DELAY);*/ recallEeprom(); // Init MFRC RFID sensor SPI.begin(); // Init SPI bus mfrc522.PCD_Init(); // Init MFRC522 ShowReaderDetails(); // Show details of PCD - MFRC522 Card Reader details //send(lockArmMsg.set(armed)); Serial.println(F("Init done...")); } void loop() { timer++; delay(HEARTBEAT); debouncer.update(); // Get the update value int switchValue = debouncer.read(); if (switchValue != oldSwitchValue) { // Send in the new value Serial.print(F("Switch ")); Serial.println(switchValue); if (switchValue && programmode) { lastTime = millis() / 1000; } if (!switchValue && programmode && lastTime > 0) { if ((millis() / 1000) - lastTime > 3) { Serial.println(F("Reset all cards")); countValidCards = 0; blinkFast(50); } else { Serial.println(F("Program off")); digitalWrite(LED_PIN, LOW); programmode = false; storeEeprom(); } } if (!switchValue) { programTimer = 0; } oldSwitchValue = switchValue; } if (programmode && ((timer % (ONE_SEC / HEARTBEAT)) == 0)) { ledon = !ledon; digitalWrite(LED_PIN, ledon); programTimer++; // Stop program mode after 20 sec inactivity if (programTimer > PROG_WAIT) { programmode = false; digitalWrite(LED_PIN, false); Serial.println(F("Program expired")); } } if ((timer % (200 / HEARTBEAT)) == 0) { // Look for new cards if (!mfrc522.PICC_IsNewCardPresent()) { if (releasecnt > 0) { releasecnt--; if (!releasecnt) { olduid.size = 0; Serial.println(F("release")); } } return; } releasecnt = 5; // Select one of the cards if (!mfrc522.PICC_ReadCardSerial()) { return; } // Dump debug info about the card; PICC_HaltA() is automatically called //mfrc522.PICC_DumpToSerial(&(mfrc522.uid)); if (!olduid.size || !sameUid(&(mfrc522.uid), &olduid)) { ShowCardData(&(mfrc522.uid)); copyUid(&(mfrc522.uid), &olduid); if (isValidCard(&olduid)) { OpenDoor(false); } else { if (sameUid(&(mfrc522.uid), &masterkey)) { // Only switch in program mode when mastercard is found AND the program button is pressed if (switchValue) { Serial.println(F("Program mode")); programmode = true; programTimer = 0; lastTime = 0; } } else { if (programmode) { Serial.println(F("new card")); programTimer = 0; if (countValidCards < MAX_CARDS) { // Add card to list... copyUid(&(mfrc522.uid), &validCards[countValidCards]); countValidCards++; blinkFast(15); } } else { Serial.println(F("Invalid card")); //if (armed) { // send(wrongMsg.set(1)); // delay(2000); //send(wrongMsg.set(0)); //} } } } } } } void ShowCardData(MFRC522::Uid* uid) { Serial.print(F("Card UID:")); for (byte i = 0; i < uid->size; i++) { if (uid->uidByte[i] < 0x10) { Serial.print(F(" 0")); } else { Serial.print(F(" ")); } Serial.print(uid->uidByte[i], HEX); } Serial.println(); } void copyUid(MFRC522::Uid* src, MFRC522::Uid* dest) { dest->size = src->size; dest->sak = src->sak; for (byte i = 0; i < src->size; i++) { dest->uidByte[i] = src->uidByte[i]; } } bool sameUid(MFRC522::Uid* old, MFRC522::Uid* check) { if (old->size != check->size) { return false; } for (byte i = 0; i < old->size; i++) { if (old->uidByte[i] != check->uidByte[i]) { return false; } } return true; } bool isValidCard(MFRC522::Uid* uid) { for (byte i = 0; i < countValidCards; i++) { if (validCards[i].size != uid->size) { break; } for (int j = 0; j < uid->size; j++) { if (validCards[i].uidByte[j] != uid->uidByte[j]) { break; } if (j == (uid->size - 1)) { return true; } } } return false; } void storeEeprom() { byte address = 0; saveState(address++, countValidCards); for (byte i = 0; i < countValidCards; i++) { saveState(address++, validCards[i].size); for (byte j = 0; j < 10; j++) { saveState(address++, validCards[i].uidByte[j]); } } } void recallEeprom() { byte address = 0; countValidCards = loadState(address++); if (countValidCards > MAX_CARDS) { Serial.println(F("Not a valid EEPROM reading set to default")); countValidCards = 0; storeEeprom(); return; } for (byte i = 0; i < countValidCards; i++) { validCards[i].size = loadState(address++); for (byte j = 0; j < 10; j++) { validCards[i].uidByte[j] = loadState(address++); } } } void blinkFast(int times) { for (int i = 0; i < times; i++) { ledon = !ledon; digitalWrite(LED_PIN, ledon); delay(100); } } void OpenDoor(bool fakeOpen) { Serial.println(F("Open door!")); send(lockMsg.set(false)); if (!fakeOpen) { digitalWrite(LED_PIN, HIGH); digitalWrite(GARAGEPIN, HIGH); } delay(1000); if (!fakeOpen) { digitalWrite(GARAGEPIN, LOW); digitalWrite(LED_PIN, LOW); } send(lockMsg.set(true)); } void ShowReaderDetails() { // Get the MFRC522 software version byte v = mfrc522.PCD_ReadRegister(mfrc522.VersionReg); Serial.print(F("MFRC522 Software Version: 0x")); Serial.print(v, HEX); if (v == 0x91) { Serial.print(F(" = v1.0")); } else if (v == 0x92) { Serial.print(F(" = v2.0")); } else { Serial.print(F(" (unknown)")); } Serial.println(""); // When 0x00 or 0xFF is returned, communication probably failed if ((v == 0x00) || (v == 0xFF)) { Serial.println(F("WARNING: Communication failure, is the MFRC522 properly connected?")); } } void receive(const MyMessage &message) { if (message.type == V_LOCK_STATUS) { // Change relay state if (!message.getBool()) { OpenDoor(false); } // Write some debug info Serial.print(F("Lock status: ")); Serial.println(message.getBool()); } /*else { if (message.type == V_ARMED) { // Change relay state armed = message.getBool(); // Write some debug info Serial.print(F("Arm status: ")); Serial.println(message.getBool()); }*/ else { // Write some debug info Serial.print(F("Incoming msg type: ")); Serial.print(message.type); Serial.print(F(" id: ")); Serial.print(message.sensor); Serial.print(F(" content: ")); Serial.println(message.getInt()); } } //}I'm not good at programming that's why I'm asking for help
-
@Ispandy what happens if you download the same sketch from the working node 3 tot your new node 50?
Adapt of course the node-id!If it works we can exclude a hardware problem, then it must be a software problem.
In that last case, we can check your sketch more deeply.
-
@evb thank you for the response, and sorry for late reply.
As I mentioned above, that node 3 is running as it should, and I've copied it to node 50 and it's also running normally. The problem is on sketch node 50 when i click the switch in openhab the relay doesn't respond but when i scan the card on rfid, the relay responds. Unlike node 3, the relay responds to both card scans and openhab.
Regards,
-
@Ispandy, let resume some things because I'm lost
You copied the sketch code from node 3 (= correctly running node with cardscans and remote control from openhab) to node 50 and you adapted the node id.
This same sketch on node 50 is running correctly with cardscans but not with openhab? Correct?If above is correct: somewhere your openhab configuration for this node 50 is not correct. You say that node 50 is never receiving the openhab command, so there is a problem with your openhab configuration for node 50.
