[31] Arduino - Układ RFID RC522, sterowanie przekaźnikami

W tym poście chciałbym opisać projekt sterowania układem przekaźnikami za pomocą kart Mifare odczytywanych przez moduł z układem RC522. Pozwala on na odczytywanie jak i zapisywanie danych na kartę na częstotliwości 13,56 MHz. Komunikacja z nim odbywa się przez interfejs SPI. Układ zasilany jest napięciem 3.3V. Nie ma problemów z podłączeniem go do Arduino Uno, zasilanego z 5V.

Podłączenie:

Układ został podłączony do płytki w następujący sposób:

Przekaźniki:

• Przekaźnik 1 - pin 7 Arduino
• Przekaźnik 2 - pin 8 Arduino

Moduł MF RC522:

• SPI MOSI - pin 11 Arduino
• SPI MISO - pin 12 Arduino
• SPI SCK - pin 13 Arduino
• RST - pin 9 Arduino
• SPI SS PIN(SDA)  - pin 10 Arduino

Program:

Na początku w programie można ustawić tryb pracy (zmienna workMode). Pierwszy z nich pozwala przy pierwszym przyłożeniu na załączenie jednego przekaźnika. Ponowne przyłożenia karty powoduje odłączenie przekaźnika.

Drugi tryb pracy załącza przekaźnik i po około 10 sekundach następuje jego odłączenie. Obliczenia są wykonywane za pomocą zwykłej funkcji opóźniające, wobec tego może występować pewne odchylenie od zakładanej wartości. Może on być dynamicznie zmieniany za pomocą komend poprzez interfejs UART. W celu ulepszenia programu można dołożyć zapis tego parametru do pamięci nieulotnej. 

Do obsługi układu RC522 wykorzystuje bibliotekę MFRC522 stworzoną przez GithubCommunity w wersji 1.3.6. Można ją w bardzo łatwy sposób pobrać poprzez Menedżer bibliotek.

1. /*
2.  * Relay control test program
3.  * Communication from UART to open or close
4.  * two relays
5.  * control HIGH state - turn off relay
6.  * control LOW state - turn on relay
7.  *  Connection:
8.  *  * RST/Reset   RST          9            
9.  *    SPI SS      SDA(SS)      10            
10.  *    SPI MOSI    MOSI         11 / ICSP-4  
11.  *    SPI MISO    MISO         12 / ICSP-1  
12.  *    SPI SCK     SCK          13 / ICSP-3
13.  */
14. #include <SPI.h>
15. #include <MFRC522.h>
16. //--------------------------------------------------------------------------------------------
17. #define RST_PIN         9   /* Rst pin for RC522 */
18. #define SS_PIN          10  /* SS pin for RC522 */      
19. //--------------------------------------------------------------------------------------------
20. #define RELAY1          7 /* Relay 1 connect to pin 10 */
21. #define RELAY2          8 /* Relay 2 connect to pin 11 */
22. //--------------------------------------------------------------------------------------------
23. /* Number from my tags */
24. /* Card data, small tag: UID: 46, 75, D5, 8F */
25. /* Card data, small tag: UID: 91, B8, E8, 09 */
26. //--------------------------------------------------------------------------------------------
27. /* Variables for relay control */
28. String receiveData = "";
29. bool relayState1 = true; /* State for relay one */
30. bool relayState2 = true; /* State for relay one */
31. //--------------------------------------------------------------------------------------------
32. /* Variables for RC522 */
33. byte serialNumberFromTag[4];
34. byte decodeFlag = 0;
35. /* table variable that keeps my card numbers, to read other card you just need to put your to
36.     rfid module, that will be print on serial port*/
37. byte tagSerialNumber[2][4] = {{0x46, 0x73, 0xD5, 0x8F},
38.                               {0x91, 0xB8, 0xE8, 0x09}} ;
39. //--------------------------------------------------------------------------------------------
40. byte workMode=2;  /* Work mode can be set before compilation or using UART */
41. //--------------------------------------------------------------------------------------------
42. MFRC522 mfrc522(SS_PIN, RST_PIN);  /* Create instance for MFRC522 */
43. //--------------------------------------------------------------------------------------------
44. /* Functions */
45. void comPortInit(void);
46. void initPins(void);
47. void relayControl(String msg);
48. void relayControlCardNumber(byte cardNumber[4]);
49. uint8_t getCardNumber();
50. void checkRelaysWorkMode2();
51. //--------------------------------------------------------------------------------------------
52. void setup() {
53.   /* Set comPort */
54.   comPortInit();
55.   initPins();
56. }
58. void loop() {
59.   if(Serial.available() > 0){
60.     receiveData = Serial.readStringUntil('\n');     /* if data receive by uart */
61.     relayControl(receiveData);
62.    
63.     /* Clear data buffer */
64.     receiveData = "";
66.     if ( ! mfrc522.PICC_IsNewCardPresent()) {
67.       return;
68.     }
70.     /* Select one of the cards */
71.     if ( ! mfrc522.PICC_ReadCardSerial()) {
72.       return;
73.     }
74.   }
76.   getCardNumber();
78.   if(workMode == 2){
79.     checkRelaysWorkMode2();
80.   }
81. }
82. //--------------------------------------------------------------------------------------------
83. void comPortInit(void){
84.   Serial.begin(115200, SERIAL_8N1);
85.   while (!Serial);
86.   Serial.println("Com Port ON");
87. }
88. //--------------------------------------------------------------------------------------------
89. void initPins(void){
90.   /* Set relay pins as output */
91.   pinMode(RELAY1, OUTPUT);
92.   pinMode(RELAY2, OUTPUT);
93.   /* Set default state */
94.   digitalWrite(RELAY1, HIGH);
95.   digitalWrite(RELAY2, HIGH);
97.   SPI.begin();  
98.   mfrc522.PCD_Init();
99.   /* Read firmvare version */
100.   byte firmwareVersion = mfrc522.PCD_ReadRegister(mfrc522.VersionReg);
102.   if(firmwareVersion == 0){
103.     Serial.println("Error while checking RC522 module, check connection");
104.   }
105.   else{
106.     Serial.print("Module find succesfully. Firmware version 0x");
107.     Serial.print(firmwareVersion, HEX);
108.    
109.     if(firmwareVersion == 0x91){
110.       Serial.println(" - Version 1.0");
111.     }
112.     else if(firmwareVersion == 0x92){
113.       Serial.println(" - Version 1.0");
114.     }
115.     else{
116.       Serial.println(" - Version ????");
117.     }
118.   }
120.   Serial.println("Set pins, spi finish! You can enter data now");
121. }
122. //--------------------------------------------------------------------------------------------
123. void relayControl(String msg){
124.     if(msg == "relay1") /* open or close relay 1 */
125.     {
126.       /* Turn on/off relay 1*/
127.        relayState1=!relayState1;
128.        digitalWrite(RELAY1, relayState1);
129.        if(relayState1 == true){
130.           Serial.println("Realy 1 OFF");
131.        }
132.        else{
133.           Serial.println("Realy 1 ON");
134.        }
135.     }
136.     else if(msg == "relay2") /* open or close relay 2 */
137.     {
138.         /* Turn on/off relay 2*/
139.         relayState2=!relayState2;
140.         digitalWrite(RELAY2, relayState2);
141.         if(relayState2 == true){
142.            Serial.println("Realy 2 OFF");
143.         }
144.         else{
145.            Serial.println("Realy 2 ON");
146.         }
147.     }
148.     else if(msg == "workmode_1")  /* set workmode as 1 */
149.     {
150.         /* Set work mode to 1 */
151.         if(workMode == 1){
152.           Serial.println("Work mode already set to 1");
153.         }
154.         else{
155.           workMode = 1;
156.           Serial.println("Work mode set to 1");
157.         }
158.     }
159.     else if(msg == "workmode_2")  /* set workmode as 2 */
160.     {
161.         /* Set work mode to 2 */
162.         if(workMode == 2){
163.           Serial.println("Work mode already set to 2");
164.         }
165.         else{
166.           workMode = 2;
167.           Serial.println("Work mode set to 2");
168.         }
169.     }
170.     else if(msg == "workmode_?")  /* check workmode */
171.     {
172.         /* Check workMode value*/
173.         Serial.print("Work mode value: ");
174.         Serial.println(workMode);
175.     }
176.     else
177.     {
178.         Serial.println("Wrong message to Arduino!");
179.     }
180. }
181. //--------------------------------------------------------------------------------------------
182. void relayControlCardNumber(byte cardNumber[4])
183. {
184.   if((cardNumber[0] == tagSerialNumber[1][0]) && (cardNumber[1] == tagSerialNumber[1][1]) &&
185.       (cardNumber[2] == tagSerialNumber[1][2]) && (cardNumber[3] == tagSerialNumber[1][3]))
186.   {
187.     decodeFlag = 1;
188.     if((workMode == 1) || ((workMode == 2) && relayState1 == true)){
189.       relayControl("relay1");
190.     }
191.   }
192.   else if((cardNumber[0] == tagSerialNumber[0][0]) && (cardNumber[1] == tagSerialNumber[0][1]) &&
193.      (cardNumber[2] == tagSerialNumber[0][2]) && (cardNumber[3] == tagSerialNumber[0][3]))
194.   {
195.     decodeFlag = 2;
196.     if((workMode == 1) || ((workMode == 2) && relayState2 == true)){
197.       relayControl("relay2");
198.     }
199.   }
200.   else
201.   {
202.       Serial.println("Wrong card number!");
203.   }
204. }
205. //--------------------------------------------------------------------------------------------
206. uint8_t getCardNumber() {
207.   // Getting ready for Reading PICCs
208.   if ( ! mfrc522.PICC_IsNewCardPresent()) { /* If a new PICC placed to RFID reader continue */
209.     return 0;
210.   }
211.   if ( ! mfrc522.PICC_ReadCardSerial()) {   /* Since a PICC placed get Serial and continue */
212.     return 0;
213.   }
214.   /* Write card number into variable, and print it on the screen */
215.   for (uint8_t i = 0; i < 4; i++)
216.   {
217.     serialNumberFromTag[i] = mfrc522.uid.uidByte[i];
218.     Serial.print(serialNumberFromTag[i], HEX);
219.   }
221.   Serial.println("");
222.   mfrc522.PICC_HaltA();
224.   /* Go to relay control function */
225.   relayControlCardNumber(serialNumberFromTag);
227.   return 1;
228. }
229. //--------------------------------------------------------------------------------------------
230. void checkRelaysWorkMode2()
231. {
232.   static uint16_t relayOneCount;
233.   static uint16_t relayTwoCount;
235.   /* If relay 1 is open */
236.   if(decodeFlag==1){
237.     relayOneCount+=1;
238.     if(relayOneCount == 300){
239.       relayOneCount=0;
240.       decodeFlag = 0;
241.       relayControl("relay1");
242.     }
243.     delay(10);
244.   }
245.   /* If relay 2 is open */
246.   if(decodeFlag==2){
247.     relayTwoCount+=1;
248.     if(relayTwoCount == 300){
249.       relayTwoCount=0;
250.       decodeFlag = 0;
251.       relayControl("relay2");
252.     }
253.     delay(10);
254.   }
255. }
256. //--------------------------------------------------------------------------------------------

Jako dodatkowe usprawnienie można dołożyć zapamiętywanie wcześniejszego nr karty i wykonać brak reakcji na ponowne przyłożenie tej samej karty do czytnika, zanim zostanie przyłożona inna karta. Taki mechanizm jest często stosowany w systemach kontroli dostępu. Można go wykonać poprzez dodanie dodatkowej zmiennej w formacie byte lub dodatkowego wiersza w zmiennej tagSerialNumber.