Internet of Lego

Computers + Electronics + Lego

[internetoflego-blog]

Some friends of mine love playing the arcade game called “Pop-a-Shot”. The object is to make as many baskets in a set amount of time as possible. You then get tickets or bragging rights based on your score. They asked if I could build one using the technologies I’ve been using for the Internet of Lego city. So I put together a protoype with LEGO to see what it would take to build a full scale version.

presenting…

Pop o Shop

    Overview

Build an electronic score keeper system using an Arduino microcontroller, some lights, sensors and Legos.

Game Play

Press start button to begin game.

Make as many baskets as possible in 30 seconds.

If 30 points have been scored, extend game time an additional 30 seconds.

A top score will be recorded and displayed and light show will activate.

Gallery

This slideshow requires JavaScript.

Build It

Supplies

Arduino (I used an Arduino Nano)

Ultrasonic Sensor – HC-SR04

7 Segment Display x 2

RGB LED (pre-built with resistors)

LEGO bricks, jumper wires

Arduino

Download Source Code

Code Highlights

I won’t go into every line of the project code, but I did want to highlight some core functions of the system.

Code Flow

Wait in loop until start button is pressed. An ambient light cycle will run on the RGB while waiting.

Start button will set gameActive variable to true, which runs the game functions and begins the timer.

The ultrasonic sensor will read the distance within each loop iteration to detect a ball within 10 cm.

If a ball is present, the score is incremented, the LED changes to green and the display is updated.

If 30 points have been reached in this session, an additional 30 seconds will be added to the game time. It will repeat the cycle if an additional 30 points has been scored in the extended time.

A session counter will be updated and displayed.

When the game ends, the score will be compared against the existing high score. If it is exceeded, the top score will be updated and celebration function will run to update the lights and displays.

Main Setup

Initialize the displays, serial console and reset the game variables.

// Run ONCE void setup() { Serial.begin(57600); pinMode(ledRedPin, OUTPUT); pinMode(ledGreenPin, OUTPUT); pinMode(ledBluePin, OUTPUT); pinMode(startButtonPin, INPUT); // LED 7 Segment logic lc.shutdown(0,false); lc2.shutdown(0,false); /* Set the brightness to a medium values */ lc.setIntensity(0,8); lc2.setIntensity(0,8); /* and clear the display */ lc.clearDisplay(0); lc2.clearDisplay(0); resetGame(); }

Main Loop

This is where we listen for the start button to be pressed and set the game status using the ‘gameActive’ variable.

// MAIN LOOP void loop() { // Start Game Button if(digitalRead(startButtonPin)){ Serial.print("Game Started"); // reset score resetGame(); // Clear last messages lc2.clearDisplay(0); // set game state gameActive = true; } // Run Game if (gameActive){ runGame(); if (statsMillis > 500) { statsMillis = 0; // reset the counter to 0 so the counting starts over... stats(); } }else{ standbyRoutine(); } }

Detecting Ball

Ultrasonic distance detection

#include <Ultrasonic.h> void runGame(){ // Determine remaining game time remaining = (countdown - sinceStart) / 1000; // Display Countdown Clock displays(btmLeftDisplay,remaining); // Check for ball, with delay to avoid duplicates unsigned long currentMillis = millis(); if (currentMillis - previousMillis >= goalDelay) { int distance = ultrasonic.distanceRead(); Serial.print("distance "); Serial.println(distance); ledRedState = HIGH; ledGreenState = LOW; ledBlueState = HIGH; digitalWrite(ledGreenPin, ledGreenState); digitalWrite(ledRedPin, ledRedState); digitalWrite(ledBluePin, ledBlueState); // Detect Ball if (distance < 10 && deDuplicate){ deDuplicate = false; // save the last time a goal happened previousMillis = currentMillis; Serial.print("Ball Detected!"); score += 2; Serial.print("Score: "); Serial.println(score); ledGreenState = HIGH; ledRedState = LOW; ledBlueState = LOW; // set the LED with the ledState of the variable: digitalWrite(ledGreenPin, ledGreenState); digitalWrite(ledRedPin, ledRedState); digitalWrite(ledBluePin, ledBlueState); }else{ deDuplicate = true; } // End game loop if(remaining < 1){ // Check if bonus time is added if(score-lastScore >= bonus){ bonusCount++; displays(btmRightDisplay,bonusCount); lastScore = score; // add extended bonus time by resetting start counter sinceStart = 0; }else{ // End Game if (score > topScore){ topScore = score; finishTopScore(); } else{ finishLowScore(); } resetGame(); gameActive = false; } } // write score to 7 Segment displays(topRightDisplay,score); } }

  Seven Segment Displays

LEDControl Library

Setup the segment displays.

#include "LedControl.h" // Define Hardware /* Seven Segment Display Pin 8-4 is connected to the DataIn Pin 9-5 is connected to the CLK Pin 7-6 is connected to LOAD */ LedControl lc=LedControl(8,9,7,1); LedControl lc2=LedControl(4,5,6,1); // Segement selector (helper function used to create sections) int topRightDisplay = 0; int topLeftDisplay = 1; int btmRightDisplay = 2; int btmLeftDisplay = 3;

  Printing Words

This brings me to the name of the game “Pop o Shop”. Why “Shop“? Because there was no “t” in the LedControl.h library! and I couldn’t be bothered with a hack for this prototype 🙂

// Spell "P0P.Sh0P" btmRightDislay lc2.setChar(0,7,'P',false); lc2.setChar(0,6,'0',false); lc2.setChar(0,5,'P',false); lc2.setChar(0,4,false,true); lc2.setChar(0,3,'5',false); lc2.setChar(0,2,'h',false); lc2.setChar(0,1,0,false); lc2.setChar(0,0,'P',true);

 Printing Numbers

I have a function to leverage two 7-segment displays and format the numbers properly.

// Formats and prints to Seven Segment displays consitently void displays(int section,int number){ uint8_t ones,tens,hundreds,thousands; thousands=number/1000; hundreds=number%1000/100; tens=number%100/10; ones=number%10; // set digits on 7 segment. Some digits are disabled (' ') for aesthetic reasons if(section == 0){ // Top Right lc.setDigit(0,0,ones,false); lc.setDigit(0,1,tens,false); lc.setDigit(0,2,hundreds,false); //lc.setDigit(0,3,thousands,false); lc.setChar(0,3,' ',false); }else if(section == 1){ // Top Left lc.setChar(0,4,' ',false); lc.setDigit(0,5,ones,false); lc.setDigit(0,6,tens,false); lc.setDigit(0,7,hundreds,false); //lc.setDigit(0,7,thousands,false); }else if(section == 2){ // Bottom Right lc2.setDigit(0,0,ones,false); lc2.setDigit(0,1,tens,false); //lc2.setDigit(0,2,hundreds,false); //lc2.setDigit(0,3,thousands,false); lc2.setChar(0,2,' ',false); lc2.setChar(0,3,' ',false); } else if(section == 3){ // Bottom Left lc2.setDigit(0,4,ones,false); lc2.setDigit(0,5,tens,false); //lc2.setDigit(0,6,false,false); //lc2.setDigit(0,7,false,false); lc2.setChar(0,6,' ',false); lc2.setChar(0,7,' ',false); } }

  RGB LED

First define the output pins.

This is a function that cycles through a range of numbers to change the colors of the lights when a new Top Score has been reached.

// RGB LED const int ledRedPin = 2; // PIN 2 const int ledGreenPin = 3; // PIN 3 const int ledBluePin = 11; // PIN 11 // Top Score Celebration Routing void finishTopScore(){ Serial.print("NEW TOP SCORE !"); displays(topLeftDisplay,topScore); int y = false; for (int x = 0; x < 1024; x = x + 20){ for (int y = 100; y < 1024; y++){ analogWrite(ledGreenPin, x); analogWrite(ledRedPin, y); } // Spell "P0P" lc2.setChar(0,3,' ',false); lc2.setChar(0,2,'P',false); lc2.setChar(0,1,0,false); lc2.setChar(0,0,'P',true); delay(50); lc2.clearDisplay(0); } }

  Circuit

The circuit is pretty strait forward. Simply connect the Ultrasonic sensor, button and LED pins to the pin variables defined in the application. I made the button connection extendable so I could move the start button closer to the player if I built a proper basketball goal for this.

What’s in 2.0?!

This was just an idea at this stage. I actually play the game all the time so I think I will take it to the next level. I want to use IoT technologies to store the scores in the cloud. I also have a huge 32×64 LED matrix board and a doorbell that could add some great arcade effects.

Stay tuned..

"Pop o Shop" - Basketball Arcade Game using @arduino and LEGO Some friends of mine love playing the arcade game called "Pop-a-Shot". The object is to make as many baskets in a set amount of time as possible.

[internetoflego-blog]

Meraki Location - Updated Node-RED CMX/Scanning node!

The Cisco Meraki location services have been updated to support Bluetooth beacon detection. This makes it a great solution for asset tracking, way-finding and location aware services. As a result, I have updated the custom Node-RED Meraki CMX node to consume this enhanced telemetry data. What’s new? Bluetooth detection and filtering, using a new “Radio Type” selector. Created two outputs, Data…

View On WordPress

[internetoflego-blog]

Meraki Dashboard API - Create Admin Form with Node-RED

#Meraki Dashboard API - Create Admin Form with Node-RED

Overview This project provides a demonstration of using the Meraki Dashboard API with Node-RED. It will display a simple web form to create a new admin account and send the details to Meraki using the API. This concept can also be used for many of the other API calls available, such as updating a WiFi passcode, provisioning a network, etc. Flow The web form is available at…

View On WordPress

[internetoflego-blog]

Billboard - ESPEasy & OLED Display - Internet of LEGO

The IoL City has a local weather station but how do you broadcast the information for everybody to see? A digital billboard! This project uses a Raspberry Pi running Node-RED to collect weather data from my previous Weather Station project and... Continue Reading →

[internetoflego-blog]

  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 of Homie, 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 simple pubsublclient 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 the Homie 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.

Download the web UI

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.

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.

    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.

void setup() { Homie.setFirmware("rfid", "1.0.0"); Homie.registerNode(rfidNode); Homie.setSetupFunction(setupHandler); Homie.setLoopFunction(loopHandler); rfidNode.subscribe("validate", verifyHandler); Homie.setup(); } void loop() { Homie.loop(); }

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.

// Select one of the cards if ( ! mfrc522.PICC_ReadCardSerial()) { Serial.print("found card..."); delay(50); return; }

// Process card Serial.print(F("Card UID:")); dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size); }

// RFID: dump a byte array as hex values to Serial, then send to validation routine. void dump_byte_array(byte *buffer, byte bufferSize) { String uid; const long interval = 1000; for (byte i = 0; i < bufferSize; i++) { Serial.print(buffer[i] < 0x10 ? " 0" : " "); Serial.print(buffer[i], HEX); uid = uid + String(buffer[i], HEX); } if(uid){ validate(uid); } }

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).

/* * RFID Scanner with audio and lights * * Communication via WiFi & MQTT using Homie.h * The ID will be sent to the MQTT topic. * When a success verification occurs, the lights and speaker will be activated * depending on the value. * * * Written by Cory Guynn * www.InternetOfLEGO.com * 2016 * */ // Networking - MQTT using Homie // https://github.com/marvinroger/homie/tree/master #include <Homie.h> HomieNode rfidNode("RFID-1", "sensor"); // Audio #include "pitches.h" // RFID #include "MFRC522.h" #define RST_PIN 15 // RST-PIN for RC522 - RFID - SPI - Modul GPIO15 #define SS_PIN 2 // SDA-PIN for RC522 - RFID - SPI - Modul GPIO2 MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance // LEDs and Speaker const int PIN_RESET = 0; //D3 WeMos ~ This pin will flash WeMos when held low 5s const int PIN_RED = 16; //D0 WeMos const int PIN_GREEN = 15; //D8 WeMos const int PIN_SPEAKER = 5; //D1 WeMos // Standard Functions void setup() { Homie.setFirmware("rfid", "1.0.0"); Homie.registerNode(rfidNode); Homie.setSetupFunction(setupHandler); Homie.setLoopFunction(loopHandler); rfidNode.subscribe("validate", verifyHandler); Homie.setup(); } void loop() { // all loop activity is handled by Homie, to ensure connectivity and prevent blocking activity that could disrupt communication Homie.loop(); } void setupHandler() { // this replaces the traditional "setup()" to ensure connecitvity and handle OTA // RFID and Console Serial.begin(9600); // Initialize serial communications SPI.begin(); // Init SPI bus mfrc522.PCD_Init(); // Init MFRC522 // sound beep tone(PIN_SPEAKER,NOTE_C1,250); delay(50); tone(PIN_SPEAKER,NOTE_E1,250); delay(50); tone(PIN_SPEAKER,NOTE_C1,250); delay(50); noTone(PIN_SPEAKER); // initialize LEDs pinMode(PIN_RED, OUTPUT); pinMode(PIN_GREEN, OUTPUT); digitalWrite(PIN_RED, HIGH); digitalWrite(PIN_GREEN, HIGH); delay(1000); digitalWrite(PIN_GREEN, LOW); } // Global Timer unsigned long previousMillis = 0; int interval = 2000; void loopHandler() { // Look for new RFID cards if ( ! mfrc522.PICC_IsNewCardPresent()) { //Serial.print("scanning"); delay(50); return; } // scan the cards. Put in a non-blocking delay to avoid duplicate readings unsigned long currentMillis = millis(); if (currentMillis - previousMillis >= interval) { previousMillis = currentMillis; // do non-blocking thing here // Select one of the cards if ( ! mfrc522.PICC_ReadCardSerial()) { Serial.print("found card..."); delay(50); return; } // Process card Serial.print(F("Card UID:")); dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size); } } // RFID: dump a byte array as hex values to Serial, then send to validation routine. void dump_byte_array(byte *buffer, byte bufferSize) { String uid; const long interval = 1000; for (byte i = 0; i < bufferSize; i++) { Serial.print(buffer[i] < 0x10 ? " 0" : " "); Serial.print(buffer[i], HEX); uid = uid + String(buffer[i], HEX); } if(uid){ validate(uid); } } // validate card UID by sending to server via MQTT void validate(String uid){ Serial.print("validating card: "); Serial.println(uid); // set RFID uid property to be sent via MQTT Homie.setNodeProperty(rfidNode, "uid", uid, true); // Turn both LEDs on digitalWrite(PIN_RED, HIGH); digitalWrite(PIN_GREEN, HIGH); // play sounds tone(PIN_SPEAKER,NOTE_D1,50); delay(20); tone(PIN_SPEAKER,NOTE_D1,50); noTone(PIN_SPEAKER); digitalWrite(PIN_GREEN, LOW); } // Receive response from server via MQTT bool verifyHandler(String response) { Serial.print("verifyHandler "); Serial.println(response); tone(PIN_SPEAKER,NOTE_C3,100); digitalWrite(PIN_RED, LOW); digitalWrite(PIN_GREEN, LOW); delay(250); if (response == "granted") { Serial.println("card accepted"); Homie.setNodeProperty(rfidNode, "validate", "granted", true); digitalWrite(PIN_GREEN, HIGH); tone(PIN_SPEAKER,NOTE_C3,250); delay(250); tone(PIN_SPEAKER,NOTE_C4,500); noTone(PIN_SPEAKER); delay(1000); digitalWrite(PIN_GREEN, LOW); } else if (response == "denied") { Serial.print("card denied"); Homie.setNodeProperty(rfidNode, "validate", "denied", true); digitalWrite(PIN_RED, HIGH); tone(PIN_SPEAKER,NOTE_C3,250); delay(250); digitalWrite(PIN_RED, LOW); tone(PIN_SPEAKER,NOTE_G2,500); delay(250); noTone(PIN_SPEAKER); digitalWrite(PIN_RED, HIGH); delay(1000); } else { digitalWrite(PIN_RED, HIGH); Serial.println("unexpected response: "); Homie.setNodeProperty(rfidNode, "validate", "unexpected", true); Serial.print(response); tone(PIN_SPEAKER,NOTE_A2,500); delay(250); digitalWrite(PIN_RED, LOW); tone(PIN_SPEAKER,NOTE_A2,500); return false; } digitalWrite(PIN_RED, HIGH); return true; }

  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“. The msg.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-dashboard UI, 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 a UI 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).

  Video

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.

[internetoflego-blog]

Node-RED MQTT Dashboard Console

Node-RED MQTT Dashboard Console #MQTT #NodeRed

The Internet of LEGO city is generating a ton of MQTT messages! By using the MQTT Dashboard Console with Node-RED, I can now easily view all of these messages and publish new ones! Flow Download The “Store and shift msg” function node will store the recent MQTT msg objects in a local “context” object. This will then build an array of objects to be shifted and displayed in the Dashboard UI…

View On WordPress

[internetoflego-blog]

WiFi Location Fun with Cisco Meraki CMX & Node-RED

The IoL City would like to use their metropolitan free WiFi to better understand how the citizens move about the city. With this information, they can build smarter public areas, provide analytics for local services and trigger other forms of IoT automation. How does Cisco Meraki CMX work? All WiFi clients discover a wireless network (SSID) by sending a “probe request“. This is effectively a…

View On WordPress

[internetoflego-blog]

Web Form with Node-RED, CSS/JS/HTML

Web Form with #NodeRED, #CSS #JS #HTML. An InternetOfLEGO.com post

Many of the Internet of LEGO projects rely on Node-RED for orchestration and client interactions. I found that building the backend services were pretty natural with the platform, but building a simple web page was a little more challenging. This article is just a simple example of my own tips & tricks to help other Node-RED enthusiasts. Overview Since a typical front-end web page consists of…

View On WordPress

[internetoflego-blog]

Palace Cinema - Wio Link, Addressable LEDs & Node-RED - Internet of LEGO

Movie Night! The Palace Cinema has just opened up in IoL City! It needs spectacular lights for its grand premiere. Goal Use a Wio Link board to remotely control addressable LEDs for the cinema roof and marquee. Technologies Wio Link... Continue Reading →

[internetoflego-blog]

The infrared remote controlled LEGO train is out of view, but it needs to be stopped! How can we control a train if you can’t see it?

WiFi

Goal

Build a WiFi controlled LEGO Power Functions train.

Technologies

NodeMCU

ESP8266 WiFi dev board

Arduino IDE

Used to program NodeMCU

Node-RED

A platform to connect the Internet of Things

Raspberry-Pi

Single board Linux computer to run Node-RED

LEGO Power Functions & Train

LiPo battery powered motors

Overview

The ESP8266 is the greatest thing since sliced bread, for IoT projects. It’s basically an 802.11n WiFi chip with a microcontroller that provides GPIOs. The only issue with this is that it can be a pain to get going. The chip only supports 3.3v and requires some additional circuitry to program and connect to a USB interface. It’s doable, but the small chip expands into a larger circuit which increases overall install size (in development environments). The NodeMCU attempts to solve these problems by placing the ESP8266 on a dev board, that includes GPIO breakouts, a USB interface and power management.

By writing some minimal code on the chip, I can control a motor via a simple REST interface. Basically, I can just go to a web URL and something happens. :)

To provide a front-end and connect it to the Internet of Things, I will use Node-RED hosted on a Raspberry Pi. Like many of the other Internet of LEGO projects, Node-RED is used to send commands, collect data and build a simple UI to interact with the network.

A previous IoL article, Lego Train Automation – IR Power Functions, used the standard infrared receiver and a Raspberry Pi based transmitter to control the train. It worked really well and didn’t require any modifications to the train or controller for it to work. The problems started surfacing as I tried to control the trains when they were behind buildings or in a tunnel. Since there is a subway station and track intersections, I need to be able to control the train at all times.

Hardware

NodeMCU

http://nodemcu.com/index_en.html

The NodeMCU consists of a firmware and ESP8266 12-E development board. The system can be programmed using Lua script, but it can also be programmed using the Arduino IDE. Since many of my projects have been based on the classic Arduino dev boards, I will stick with what I know.

  NodeMCU Motor Shield

The motor shield will provide a simple way to power the LEGO train motor. Since the microcontroller is not intended for higher voltages and current, a shield will be used to switch on the heavier loads. This version supports two motors and provides access to the remaining GPIO pins.

  Both the NodeMCU and the motor shield were purchased on eBay for around $10.

Raspberry Pi

https://www.raspberrypi.org/

The Raspberry Pi will be used to host Node-RED and run a Mosquitto MQTT broker/bridge. It’s a small, inexpensive, single board computer that runs Linux. I have a Pi at the center of my IoL city, and use it for most of the high-level logic. Although it does have its own GPIOs, I find it better to use a microcontroller like an Arduino/ESP8266 for embedded projects and use the Pi for orchestration.

LEGO Power Functions

The LEGO Group have released various versions of LEGO train electronics over the years. The latest version uses a LiPo battery, infrared controller and 7.4v motor. This project will effectively replace the infrared controller with a NodeMCU WiFi controller.

    Wiring

Cut a LEGO power cable in half.

Connect the first LEGO half to the LiPo battery and connect the 9v and GND wires to the VIN and GND of the NodeMCU motor shield, respectively.

Connect the second LEGO half to the train motor and connect the C1 & C2 wires to the motor shield’s A+/A- connectors.

The B+/B- motor connectors will be used to power the cabin lights, but could be used in the future for a motorized decoupler or something else cool.

Installation

Build a LEGO train, then cram the components into it!

This is the high speed rail, Horizon Express, that I just acquired for the task. The train is hard to find, but is one of the few “expert” train sets released so I was happy to find one out of Hungary on Brick Owl!

    Software

Here is the general flow for this entire system.

The Master Dashboard is the complete IoL City project, that will be able to leverage the WiFi controlled train. It will speak to the Local Dashboard using MQTT.

The Local Dashboard will be hosted on a Raspberry Pi and provide a simple UI. This will provide a fast and easy way to control the train.

The Controller is the NodeMCU which will provide a REST interface to allow the GPIOs to be manipulated.

The Horizon Express is the LEGO train with a motor and lights.

  Programming the NodeMCU

Let’s start from the bottom up with the NodeMCU, which will control the train and define the API for the dashboard access.

To program the NodeMCU with the Arduino IDE, first install the extra support for the development board.

By using the Boards Manager in the Arduino IDE, search for ESP8266 and select install.

Now you can select “NodeMCU 1.0” from the Tools –> Board menu.

Controller Logic

The aREST library provides an easy way to create a REST interface for exposed functions and variables.

The ESP8266WiFi library takes care of all the WiFi connection mechanics.

This program starts by including our libraries and setting global settings.

It then defines the GPIO pins for the motor & lights and exposes variables & functions.

The system is then given an identity and connected to WiFi.

It then sits in a loop(), waiting for a REST command.

Once a command is received, the respective GPIO is adjusted and/or a status message is returned.

  /* This program provides a WiFi connected REST interface for a LEGO Power Functions motor and lights. Written in 2016 by Cory Guynn under a GPL license. www.InternetOfLEGO.com */ // Import required libraries #include <ESP8266WiFi.h> #include <aREST.h> // Create aREST instance aREST rest = aREST(); // WiFi parameters const char* ssid = "yourssid"; const char* password = "yourpassword"; // The port to listen for incoming TCP connections #define LISTEN_PORT 80 // Create an instance of the server WiFiServer server(LISTEN_PORT); // Variables to be exposed to the API int speed = 0; //stopped int direction = 1; //forward int lights = 1; //lights on int motor = 5; int led = 4; void setup(void) { // Start Serial Serial.begin(115200); // 4 pins control the motor shield. // Pins 4 and 5 control the speed of the motors with PWM in a default range of 0..1023 // while pins 0 and 2 define the direction the motors will turn. // The second motor power source will be used for the cabin lights. pinMode(motor, OUTPUT); pinMode(0, OUTPUT); pinMode(led, OUTPUT); pinMode(2, OUTPUT); // initialize motor and set direction digitalWrite(motor, speed); digitalWrite(0, direction); // initialize lights digitalWrite(led, lights); digitalWrite(2, 1); // forward polarity through motor driver for LEDs // expose variables to REST API rest.variable("speed", &speed); rest.variable("lights", &lights); rest.variable("direction", &direction); // Function to be exposed to REST API rest.function("motor",motorControl); rest.function("lights",lightControl); // Give name and ID to device rest.set_id("1"); rest.set_name("Horizon Express"); // Connect to WiFi WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.println("WiFi connected"); // Start the server server.begin(); Serial.println("Server started"); // Print the IP address Serial.println(WiFi.localIP()); } void loop() { // Handle REST calls WiFiClient client = server.available(); if (!client) { return; } while(!client.available()){ delay(1); } rest.handle(client); } // Custom function accessible by the API int lightControl(String command) { // Get new state from command lights = command.toInt(); digitalWrite(led,lights); return 1; } int motorControl(String command){ // set motor direction if (command.toInt() < 0) { // reveresed motor direction = 1; //forward } else { direction = 0; //reverse } speed = abs(command.toInt()); analogWrite(motor, speed); digitalWrite(0, direction); }

Once the code has been configured with your settings and uploaded to the NodeMCU, the serial monitor will show that it is connected and the IP address you can use to contact it.

Local Dashboard with Node-RED

http://nodered.org/

Node-RED is “a visual tool for wiring the Internet of Things”, which is built on NodeJS. It is also now included with the default Raspberry Pi image, Raspbian “Jessie”.

The basic concept is to create input nodes (buttons, PubNub, MQTT, Tweet, etc) and pass along the msg object. Function nodes (JavaScript function, JSON converter, switches) will then manipulate the object so that it can be formatted or be used to make decisions for the next flow step. HTTP request nodes will be used to send the GET requests to the NodeMCU. There are various green debug nodes, that will display the state of the msg object in the debug console.

  Flow Overview

Download Source

Copy and paste the flow source code using the Import –> Clipboard option within Node-RED and paste in the JSON flow.

This Node-RED “flow” is pretty straight-forward. Since we built a REST interface for the train, we just need to send a command by hitting a web URL. The input nodes will inject a “topic” and “payload” corresponding to the device and command.

There are also MQTT inputs and outputs so that this system can be managed from a cloud Pub/Sub model. This allows the Raspberry Pi to run in a private network with a random IP address and still be accessible from a dashboard server or other system in a different network.

HTTP Request

The http request node is how the command gets sent to the train.

The topic will indicate the device (i.e. motor or lights) and the payload will indicate the command.

  http://yourserver/{{{topic}}}?params={{{payload}}}

Example Commands

Motor Forward: http://yourserver/motor?params=1023

Motor Reverse: http://yourserver/motor?params=-1023

Motor Stop: http://yourserver/motor?params=0

Lights On: http://yourserver/lights?params=1023

Lights Off: http://yourserver/lights?params=0

UI

There are several blue inject buttons, to control the direction, throttle and brake directly from Node-RED. This is handy for testing.

By using the “node-red-contrib-ui” UI nodes, I can create a simple and attractive AngularJS interface to send these commands.

  Button Row

This node will create a group of buttons using AngularJS material icons.

    Status

In order to update the light switch and speed gauge, the current status needs to be known.

To pull the status, we just need to go to the root URL.

http://yourNodeMCU-IP/

  This status info will be used to update the state of the UI.

Function nodes are used to extract the status variables I am concerned with and forward them on to the next node.

// update trainStatus indicator if(msg.payload.variables.speed !== undefined){ if(msg.payload.variables.speed !== 0){ node.status({fill:"green",shape:"ring",text:"moving "+ msg.payload.variables.speed+":"+msg.payload.variables.direction}); }else{ node.status({fill:"red",shape:"ring",text:"stopped"}); } }else{ node.status({fill:"yellow",shape:"ring",text:"unknown"}); } return msg;

  // format UI msg.payload = msg.payload.variables.lights || 0; return msg;

  I also update the throttle gauge by scaling it first.

// format throttle for UI gauge // convert the speed from an absolute value with direction // to a negative/positive number var speed = msg.payload.variables.speed; var direction = msg.payload.variables.direction; if (direction === 1){ msg.payload = -1*speed; }else{ msg.payload = speed; } return msg;

Master Dashboard

Download Source

I added MQTT flows to send commands and receive updates for the wider IoL City project. This allows me to control the train from anywhere in the world. I have a much larger Ubuntu machine that runs the Node-RED “IoL Dashboard” and currently runs a Mosquitto MQTT broker. With this dashboard, I can tie all of the city sensors and functions together. I also run PubNub on this dashboard which communicates with several IoT devices that can be used to trigger events.

  Now I can really do some fun IoT stuff, such as linking the train routine to a schedule or run two trains on a shared track. I can also get notifications when the status of the train changes or have it run when a BLE beacon is detected. Stay tuned for future enhancements!

Success!

Now I can easily control the Horizon Express train using WiFi!

Gallery

Using NodeMCU (ESP8266 dev board)Node-RED

Posted by Internet of Lego on Friday, April 8, 2016

LEGO Train Automation - WiFi controlled with NodeMCU (ESP8266) The infrared remote controlled LEGO train is out of view, but it needs to be stopped! How can we control a train if you can't see it?

[internetoflego-blog]

New Internet of LEGO blog post! Using Cisco Meraki and NodeJS to create a WiFi hotspot with social logins

(via WiFi Hotspot with Social OAuth - passport, mongodb)

[internetoflego-blog]

Train Automation – Transport for London API

Now that I have a train schedule system and a way to remotely control the track switch, it's time for automation! Goal Use schedule data to automatically switch train track Think Safety and “Do Not Disturb" Technologies & Components Raspberry Pi NodeJS host Arduino Uno Servo control (ideal for PWM…

LEGO Train Track automation with Raspberry Pi, Arduino and IoT technology!

[internetoflego-blog]

IoT Security and Privacy - Overview

    The Internet of Things is certainly making the lives of the citizens of IoL City easier, but at what cost?     Painting a Picture   The Internet of Things (IoT) allows IoL to collect tiny amounts of data in the form of various sensory states. Much like individual image pixels, when viewed in a vacuum, each of these micro data points has very little value. However, when many of those pixels,…

View On WordPress

[internetoflego-blog]

When and where is the next train going?! The IoL City citizens have things to do and places to be! Goal Pull in Transport For London API data to get schedule information for a local train stop Display next trains and time to arrival on an OLED screen Technologies &…

[internetoflego-blog]

Train Schedule - Display

Train Schedule – Display

Train Schedule – OLED Display When and where is the next train going?! The IoL City citizens have things to do and places to be! Goal Pull in Transport For London API data to get schedule information for a local train stop Display next trains and time to arrival on an OLED screen Technologies & Components Cactus Micro rev2 Arduino LillyPad USB w/ ESP8266 compatible OLED screen 128×64 i2c…

View On WordPress

[internetoflego-blog]

Train Track Switch - Servos, LEDs, PubNub and Johnny-five.io

LEGO Train Track Switch - Servos, LEDs, PubNub and Johnny-five.io

LEGO Train Track Switch The 8:45 express train is coming and we need somebody to switch the tracks quickly! If only we had a way of doing this remotely. Goal: – Remotely switch the train track and use lights to indicate the direction. Challenges: – Construct the traffic signals with micro LEDs to fit in my LEGO lights. – Construct the mechanics to switch the track. This switch is very tough, so…

View On WordPress

[internetoflego-blog]

Weather Station - DHT11, MQTT, Node-RED, Google Chart, Oh My!

Weather Station – DHT11, MQTT, Node-RED, Google Chart, Oh My!

  Is it hot in here or is it just me? The IoL citizens need to know the weather, so let’s build a weather station! In this article, I am going to cover several technologies that are common to the Internet of Things such as messaging, sensors, embedded code and data analysis. There are tons of similar examples on the web, but I’m using this to walk through the full IoT concepts with a familiar…

View On WordPress