RFID Scanner – WeMos, RC522, Homie MQTT & Node-RED

Posted by: Olva , September 7, 2016

RFID Scanner – WeMos, RC522, Homie MQTT & Node-RED

 

Overview

RFID tags provide a simple and cost effective way to trigger an action. By either using a credit card sized tag or keychain fob, the Internet of LEGO city can respond in a number of ways. For instance, a card ID can unlock a door, grant access to the train system or record an identity.

As a side bonus, my two year old loves playing with these RFID tags! So, I built a fun project that makes sounds, flashes lights and enables various functions within the IoL City. I built a LEGO box to contain the components, used an ESP8266 dev board for the electronics and send the messages over WiFi using MQTT. Node-RED then acts as the orchestrator to verify the card and trigger an action.

Components

• Microcontroller w/ WiFi
  • WeMos D1-mini
    • The D1 mini is a mini WiFi board based on ESP-8266EX.
      • Buy it
      • 11 digital input/output pins, all pins have interrupt/pwm/I2C/one-wire supported(except D0)
      • 1 analog input(3.2V max input)
      • a Micro USB connection
      • Compatible with Arduino
      • Compatible with nodemcu
      • lots of shields
        
• RFID
  • MF-RC522
    • “The MFRC522 is a highly integrated reader/writer IC for contactless communication at 13.56 MHz. The MFRC522 reader supports ISO/IEC 14443 A/MIFARE and NTAG.”
  • More Info
    • Arduino Example
    • Adafruit RFID Guide

• MQTT Client
  • Homie
    • “Homie for ESP8266 is an ESP8266 for Arduino implementation ofHomie, a thin and simple MQTT convention for the IoT. More than that, it’s also a full-featured framework to get started with your IoT project very quickly. Simply put, you don’t have to manage yourself the connection/reconnection to the Wi-Fi/MQTT. You don’t even have to hard-code credentials in your sketch: this can be done using a simple JSON API. Everything is handled internally, by Homie for ESP8266.”
• MQTT Broker
  • Mosquitto
    • “Eclipse Mosquitto™ is an open source (EPL/EDL licensed) message broker that implements the MQTT protocol versions 3.1 and 3.1.1. MQTT provides a lightweight method of carrying out messaging using a publish/subscribe model. This makes it suitable for “Internet of Things” messaging such as with low power sensors or mobile devices such as phones, embedded computers or microcontrollers like the Arduino.”
• Server
  • Raspberry Pi
    • “The Raspberry Pi is a tiny and affordable computer that you can use to learn programming through fun, practical projects.”

• IoT programming environment
  • Node-RED
    • “Node-RED is a tool for wiring together hardware devices, APIs and online services in new and interesting ways.”

Construction

Circuit

This wiring diagram and sample Arduino code was the basis for the circuit. I then added a reset button, speaker and two LEDs to the ports specified in the code.

More info

LEGO Box

The LEGO box was constructed with solid base plate and long technic bricks for strength. A panel opens up to expose the WeMos D1 connections. The RFID tag was held in place with a little bit of Blu Tack.

 

MQTT w/ Homie

Many IoT projects use MQTT as a Publish/Subscription way of communicating. This can easily be implemented on an Arduino compatible system using a simplepubsublclient library developed by Nick o’Leary.

This project hopes to expand beyond simply using MQTT, by appreciating some sense of standard for scalability and maintenance. This is how I discovered theHomie convention, developed by Marvin Roger. What’s nice about this implementation is that it handles many of the tedious admin tasks for managing the connection, sending updates, storing state, OTA, and initializing the device with the network specific configurations.

Getting started with Homie

• A device Arduino library built for the ESP8266 at marvinroger/homie-esp8266
• An opinionated Web UI built with Node.js at marvinroger/homie-server
• Some Node-RED nodes for automation at marvinroger/node-red-contrib-homie
• Configuration assistant at https://github.com/marvinroger/homie-esp8266/tree/gh-pages

This project uses a WeMos D1-Mini, which will support the ESP8266 version. By including this library in the code, the device will boot up in a special configuration mode. It will then advertise its own WiFi SSID, which you must first join to configured. At that point, you can either use the API, web page or Android App to push the network and device settings. These configurations include the name of the device, MQTT broker, base topic, and WiFi settings.

I’ve used web based configuration assistant to get started.

1. Download the web UI
2. Turn on the Arduino/ESP device, and connect to its SSID “Homie-aabbccdd”, where the password and specific name are that of the MAC address. So, I would use “aabbccdd” as the password in this example.
3. Once connected to the SSID, open the index.html file that is contained in the web UI download. This will run a local web application to scan for the Homie device and provide a setup guide.

 

 

Local webpage

 

Firmware

Download Code from GitHub (includes pitches.h)

This firmware implements Homie to deliver RFID scan results via MQTT. Two LEDs and a speaker are attached to the WeMos D1-mini, for user feedback.

One unique style of this code is that the setup() and loop() functions are used to begin the setupHandler() and loopHandler() functions, for Homie. The reason for this is that Homie will keep track of the connection state and manage the state of the various properties. Its been advised to avoid any sort of blocking activity (i.e.delay(1000)) within the standard loop() function to avoid disrupting the network mechanics.

1. void setup() {
2. Homie.setFirmware(“rfid”, “1.0.0”);
3. Homie.registerNode(rfidNode);
4. Homie.setSetupFunction(setupHandler);
5. Homie.setLoopFunction(loopHandler);
6. rfidNode.subscribe(“validate”, verifyHandler);
7. Homie.setup();
8. }
10. void loop() {
11. Homie.loop();
12. }

The actual scanning of the RFID card is handled by three functions. Within each loop iteration, the RFID scanner looks for a card then prints the UID from its buffer to a byte array.

1. // Select one of the cards
2. if ( ! mfrc522.PICC_ReadCardSerial()) {
3. Serial.print(“found card…”);
4. delay(50);
5. return;
6. }

1. // Process card
2. Serial.print(F(“Card UID:”));
3. dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size);
4. }

1. // RFID: dump a byte array as hex values to Serial, then send to validation routine.
2. void dump_byte_array(byte *buffer, byte bufferSize) {
3. String uid;
4. const long interval = 1000;
6. for (byte i = 0; i < bufferSize; i++) {
7. Serial.print(buffer[i] < 0x10 ? ” 0″ : ” “);
8. Serial.print(buffer[i], HEX);
9. uid = uid + String(buffer[i], HEX);
10. }
11. if(uid){
12. validate(uid);
13. }
14. }

The Full Code will pull in the Homie library and a pitches.h library. The pitches file simply maps western musical tones (i.e. a piano range) to frequencies for easy incorporation into projects with sound.

The code is heavily commented and the functions are typically in the order of execution, where possible. Much of the code is cluttered with turning on lights and sounds (which could be endlessly tweaked and I’m guilty of wasting too much time on that).

1. /*
2. * RFID Scanner with audio and lights
3. *
4. * Communication via WiFi & MQTT using Homie.h
5. * The ID will be sent to the MQTT topic.
6. * When a success verification occurs, the lights and speaker will be activated
7. * depending on the value.
8. *
9. *
10. * Written by Cory Guynn
11. * www.InternetOfLEGO.com
12. * 2016
13. *
14. */
16. // Networking – MQTT using Homie
17. // https://github.com/marvinroger/homie/tree/master
18. #include <Homie.h>
19. HomieNode rfidNode(“RFID-1”, “sensor”);
21. // Audio
22. #include “pitches.h”
24. // RFID
25. #include “MFRC522.h”
26. #define RST_PIN 15 // RST-PIN for RC522 – RFID – SPI – Modul GPIO15
27. #define SS_PIN 2 // SDA-PIN for RC522 – RFID – SPI – Modul GPIO2
28. MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance
30. // LEDs and Speaker
31. const int PIN_RESET = 0; //D3 WeMos ~ This pin will flash WeMos when held low 5s
32. const int PIN_RED = 16; //D0 WeMos
33. const int PIN_GREEN = 15; //D8 WeMos
34. const int PIN_SPEAKER = 5; //D1 WeMos
36. // Standard Functions
38. void setup() {
39. Homie.setFirmware(“rfid”, “1.0.0”);
40. Homie.registerNode(rfidNode);
41. Homie.setSetupFunction(setupHandler);
42. Homie.setLoopFunction(loopHandler);
43. rfidNode.subscribe(“validate”, verifyHandler);
44. Homie.setup();
45. }
47. void loop() {
48. // all loop activity is handled by Homie, to ensure connectivity and prevent blocking activity that could disrupt communication
49. Homie.loop();
50. }
52. void setupHandler() {
53. // this replaces the traditional “setup()” to ensure connecitvity and handle OTA
55. // RFID and Console
56. Serial.begin(9600); // Initialize serial communications
57. SPI.begin(); // Init SPI bus
58. mfrc522.PCD_Init(); // Init MFRC522
60. // sound beep
61. tone(PIN_SPEAKER,NOTE_C1,250);
62. delay(50);
63. tone(PIN_SPEAKER,NOTE_E1,250);
64. delay(50);
65. tone(PIN_SPEAKER,NOTE_C1,250);
66. delay(50);
67. noTone(PIN_SPEAKER);
69. // initialize LEDs
70. pinMode(PIN_RED, OUTPUT);
71. pinMode(PIN_GREEN, OUTPUT);
72. digitalWrite(PIN_RED, HIGH);
73. digitalWrite(PIN_GREEN, HIGH);
74. delay(1000);
75. digitalWrite(PIN_GREEN, LOW);
78. }
81. // Global Timer
82. unsigned long previousMillis = 0;
83. int interval = 2000;
85. void loopHandler() {
86. // Look for new RFID cards
87. if ( ! mfrc522.PICC_IsNewCardPresent()) {
88. //Serial.print(“scanning”);
89. delay(50);
90. return;
91. }
93. // scan the cards. Put in a non-blocking delay to avoid duplicate readings
94. unsigned long currentMillis = millis();
95. if (currentMillis – previousMillis >= interval) {
96. previousMillis = currentMillis;
97. // do non-blocking thing here
99. // Select one of the cards
100. if ( ! mfrc522.PICC_ReadCardSerial()) {
101. Serial.print(“found card…”);
102. delay(50);
103. return;
104. }
106. // Process card
107. Serial.print(F(“Card UID:”));
108. dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size);
109. }
111. }
114. // RFID: dump a byte array as hex values to Serial, then send to validation routine.
115. void dump_byte_array(byte *buffer, byte bufferSize) {
116. String uid;
117. const long interval = 1000;
119. for (byte i = 0; i < bufferSize; i++) {
120. Serial.print(buffer[i] < 0x10 ? ” 0″ : ” “);
121. Serial.print(buffer[i], HEX);
122. uid = uid + String(buffer[i], HEX);
123. }
124. if(uid){
125. validate(uid);
126. }
127. }
129. // validate card UID by sending to server via MQTT
130. void validate(String uid){
131. Serial.print(“validating card: “);
132. Serial.println(uid);
134. // set RFID uid property to be sent via MQTT
135. Homie.setNodeProperty(rfidNode, “uid”, uid, true);
137. // Turn both LEDs on
138. digitalWrite(PIN_RED, HIGH);
139. digitalWrite(PIN_GREEN, HIGH);
141. // play sounds
142. tone(PIN_SPEAKER,NOTE_D1,50);
143. delay(20);
144. tone(PIN_SPEAKER,NOTE_D1,50);
145. noTone(PIN_SPEAKER);
146. digitalWrite(PIN_GREEN, LOW);
148. }
150. // Receive response from server via MQTT
151. bool verifyHandler(String response) {
152. Serial.print(“verifyHandler “);
153. Serial.println(response);
154. tone(PIN_SPEAKER,NOTE_C3,100);
155. digitalWrite(PIN_RED, LOW);
156. digitalWrite(PIN_GREEN, LOW);
157. delay(250);
158. if (response == “granted”) {
159. Serial.println(“card accepted”);
160. Homie.setNodeProperty(rfidNode, “validate”, “granted”, true);
161. digitalWrite(PIN_GREEN, HIGH);
162. tone(PIN_SPEAKER,NOTE_C3,250);
163. delay(250);
164. tone(PIN_SPEAKER,NOTE_C4,500);
165. noTone(PIN_SPEAKER);
166. delay(1000);
167. digitalWrite(PIN_GREEN, LOW);
168. } else if (response == “denied”) {
169. Serial.print(“card denied”);
170. Homie.setNodeProperty(rfidNode, “validate”, “denied”, true);
171. digitalWrite(PIN_RED, HIGH);
172. tone(PIN_SPEAKER,NOTE_C3,250);
173. delay(250);
174. digitalWrite(PIN_RED, LOW);
175. tone(PIN_SPEAKER,NOTE_G2,500);
176. delay(250);
177. noTone(PIN_SPEAKER);
178. digitalWrite(PIN_RED, HIGH);
179. delay(1000);
180. } else {
181. digitalWrite(PIN_RED, HIGH);
182. Serial.println(“unexpected response: “);
183. Homie.setNodeProperty(rfidNode, “validate”, “unexpected”, true);
184. Serial.print(response);
185. tone(PIN_SPEAKER,NOTE_A2,500);
186. delay(250);
187. digitalWrite(PIN_RED, LOW);
188. tone(PIN_SPEAKER,NOTE_A2,500);
189. return false;
190. }
191. digitalWrite(PIN_RED, HIGH);
192. return true;
193. }

 

Node-RED

Flow

Download Flow

This Node-RED flow demonstrates various ways of using the RFID uid to trigger workflows and to send access messages back to the RFID scanner.

Workflow

The basis for this flow starts with subscribing to the MQTT topic for the RFID tag. In my scenario, the topic happened to be “sensors/e1b47aeo/RFID-1/uid“. Themsg.payload will contain the uid for the scanned tag. A switch node will then provide several outputs based on a condition, which happens to be the uid.

 

Access

I’ve decided to send all known uid’s to a function, which sets the msg.payload to “granted”.  This in turn, will display a pop-up message on the node-red-dashboardUI, which displays the uid and whether or not the card was “granted”.

Disco & Cinema

All uid‘s that were granted will be sent to a link node, which allows me to connect it to various other flows. For example, I have sent a link to my IoL City version of a “Hello World”, which triggers disco lights in the local IoL City club and turns on a rainbow of marquee lights at the LEGO Palace Cinema.

Train Routine

A specific uid will trigger a flow to run a LEGO Horizon Express train for 5 seconds. This works because I hacked the train with a NodeMCU to control it via MQTT. See this article for all the details.

UI

The UI is provided by a handy Node-RED node, node-red-dashboard, which uses AngularJS to quickly build UI widgets. The dashboard will represent the RFID data in three ways.

• RFID Status
  • Listen for any MQTT messages emitted by Homie. These are built-in with the Homie library and will periodically send messages relating to the state of the Homie node. This includes the device ID, IP, signal strength, defined properties, etc.
  • The MQTT messages are stored in a context object, which is then sent to the UI node when the states change.
• RFID Event Log
  • This UI widget will listen for any MQTT message emitted from the RFID scanner and shift register it into a context array, which is then delivered to aUI template node leveraging the ng-repeat AngularJS directive to simulate a console screen.
• RFID Notification
  • A notification UI node is used to instantly create a pop-up or “toast” message on the UI dashboard with the recently scanned uid and if it was granted or denied.

Success!

This was a fun project with plenty of options to expand upon. The primary goal was to understand how an RFID scanner can be used with a EPS8266 and Node-RED. Using Homie was a great way to formalize a MQTT strategy. And finally, the newly embraced node-red-dashboard, demonstrates how you can quickly build a dashboard to start visualizing your data.

Final Thoughts

It’s common to use an RFID for security purposes. It would be expected to use MQTT with authentication and SSL or some secured transmission. This RFID scanner could also work really well in a more traditional REST framework. I almost wrote this project using the aREST Arduino library, but I was curious how to implement Homie… so this was a personal goal above all.

What’s also really interesting about this project and many other Internet of LEGO projects, is the reality that: Input + function = Output. I happened to use an RFID scanner for this project, but it could be any button, temperature sensor, web API or basic schedule that schedules a workflow. There are various ways to abstract this, like Zapier or IFTTT, web server/client paradigm or machine to machine communication. Once you understand the basic concept of IoT, the possibilities are endless (if you have enough LEGOs and electronics in my case).