Easy methods to Management NeoPixel Installations through Wi-Fi Utilizing Fishino and NodeMCU with Python – Open Electronics

We create NeoPixel mild installations with Fishino and NodeMCU managed through Wi-Fi from a PC or Raspberry Pi utilizing a Python library.

Just a few years in the past, the American firm Adafruit Industries remodeled the LED market by introducing NeoPixels, RGB LEDs that incorporate their very own controller in a single package deal.

Adafruit aimed to simplify LED administration for the Arduino group by combining the controller and RGB LED in a single unit.

Since then, NeoPixels have turn into extremely common, due to the power to chain them collectively and tackle them individually, controlling every LED’s coloration and brightness. Inside every NeoPixel is an RGB SMD LED (often a 5050 kind emitting about 20 lumens) together with a WS2811 or WS2812 driver.

A microcontroller (e.g., an Arduino) sends an array of bytes with exact timing throughout all linked LEDs, permitting the creation of vibrant, luminous animations.

NeoPixels can be found in varied types and compositions: particular person LEDs, strips, rings, arcs, and matrices.

Their widespread availability has spurred quite a few initiatives showcasing their versatility, from indoor and outside lighting to wearable tech, LED partitions, and extra.

In lots of initiatives, the microcontroller controlling NeoPixels comprises predefined impact sequences that it loops by. Or it’s linked through USB to a PC to obtain instructions, which makes distant set up difficult with out in depth wiring or sketch updates each time animations want altering.

Our Mission

On this article, we current a system for controlling a number of NeoPixel installations round the home through Wi-Fi, without having to switch the sketch on the microcontrollers every time. We’ll join a Fishino Guppy to a NeoPixel star and a NodeMCU to a 150-LED NeoPixel strip (each outfitted with the ESP8266 chip for Wi-Fi connectivity), utilizing a Python program because the software program controller. This program, which leverages a specifically developed library, can run on both a Home windows PC or Raspberry Pi and can ship the varied results to all linked NeoPixel gadgets over Wi-Fi.

To finish this mission, we’d like the next elements, obtainable from www.futurashop.it:

A 5-meter NeoPixel strip (half quantity: STRIP300LED);
A NeoPixel star with 56 LEDs (half quantity: FT1300M);
A 5V DC energy provide with acceptable wattage (half quantity: MW05005);
A 470-ohm resistor;
Two 1,000 µF capacitors (6V or larger);
A Fishino Guppy board (half quantity: GUPPY);
A NodeMCU board (half quantity: NODEMCUESP);
A 3.3 to 5V logic stage converter (half quantity: LLCTTL);
Wiring and jumper cables;
A Raspberry Pi with a microSD card and energy provide.

When working with NeoPixels, it’s important to pick an influence provide with the suitable score. A NeoPixel LED can draw as much as 60 milliamps when totally vivid and white. For the 150 LEDs within the 5-meter strip, meaning a present draw of 9 amps.

Different obligatory precautions embody utilizing capacitors and resistors: the capacitor is linked to the ability cables with appropriate polarity to easy the preliminary voltage spike from the ability provide that might injury the LEDs, whereas the resistor is linked between the microcontroller pin and the information line (DIN) of the NeoPixel strip (a resistor shouldn’t be required for the star, as it’s already constructed into the PCB).

When you use a NodeMCU, you’ll want a logic stage converter since this board operates at 3.3V logic, whereas NeoPixels require 5V (you possibly can theoretically use 3.3V if the NeoPixel energy provide is between 3.3 and three.8 volts, however we’ve a 5V energy provide).

First, obtain the mission information from GitHub (https://github.com/open-electronics/NeoPy), which embody sketches for each boards in addition to the Python library supply and pattern animations.

Put together the Arduino IDE improvement setting to program each boards. For Fishino, obtain the libraries from www.fishino.it and test that the firmware model matches the library model (go to the “Firmware Replace” web page within the “Documentation” part of the positioning for particulars).

To arrange NodeMCU programming, open the IDE settings from the “File” menu, click on the suitable icon of “Further URLs for Board Supervisor,” and paste this string into the window that opens: http://arduino.esp8266.com/steady/package_esp8266com_index.json.

Subsequent, set up the board by deciding on “Instruments->Board->Board Supervisor…” and looking for “esp8266.” Set up the newest model of “esp8266 by ESP8266 Neighborhood.”

Now, beneath Instruments -> Board, it is best to see “NodeMCU 1.0” within the “ESP8266 Modules” part: choose it and set the “Add pace” to 115,200.

The ultimate setup step (wanted for each boards) is downloading the NeoPixel library from Adafruit.

Obtain the zip, unzip it into Arduino’s “libraries” folder, and restart the IDE to import the brand new library. Open the “NeoPy_Fishino” sketch (choose “Arduino Nano” within the Instruments menu), modify the MY_SSID and MY_PASS values to your Wi-Fi community and the variety of LEDs you wish to hook up with the board. Go away the PORT and PIN values as they’re; uncomment and modify the IPADDR line to set a static IP, then add the sketch to Fishino.

Join the NodeMCU to the PC and open the “NeoPy_NodeMCU” sketch (choose “NodeMCU 1.0” within the Instruments menu), modify solely the values within the “SETUP” part, and depart the PORT and PIN values unchanged, then add the sketch to NodeMCU.

The system’s operation is illustrated in Fig. 1: the Python “NeoPy” library creates an object representing our NeoPixel set up, then we set the LEDs by updating solely the array throughout the object itself with the “Set()” or “SetAll()” strategies; the “Present()” technique packages the array with the knowledge for all LEDs and sends it through UDP to the desired endpoint (IP and port).

Fig. 1 NeoPy object and sketch operation

In Itemizing 1 (Fishino Guppy sketch) and Itemizing 2 (NodeMCU code), the sketches are very comparable: within the “setup” operate, the Wi-Fi connection is initialized with the beforehand configured parameters, then a UDP server is created to hear on the desired port.

Within the “loop” operate, the UDP packet is obtained, and its size is validated: an accurate packet size is 3 times the variety of specified LEDs since every LED’s coloration is represented by an RGB array of three bytes; for instance, a packet for 2 LEDs could be RGBRGB.

Itemizing 1

/*
Identify: NeoPy - Fishino
Description: NeoPixels UDP controller
Creator: Luca Bellan
Model: 1.3
*/

#embody <Fishino.h>
#embody <SPI.h>
#embody <Adafruit_NeoPixel.h>

 // BEGIN SETUP
#outline MY_SSID“ mio_ssid”
#outline MY_PASS“ mia_password”
#outline LEDS 56
//#outline IPADDR 192, 168, 1, 19
#outline GATE 192, 168, 1, 1
#outline SUB 255, 255, 255, 0
#outline PORT 4242
#outline PIN 3
// END SETUP

FishinoUDP Udp;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LEDS, _ PIN, NEO_GRB + NEO_KHZ800);
#ifdef IPADDR
IPAddress ip(IPADDR);
IPAddress gateway(GATE);
IPAddress subnet(SUB);
#endif
lengthy unsigned int packetSize;
unsigned int len;
int r, g, b;

void setup() {
  whereas (!Fishino.reset()) {
    delay(500);
  }
  Fishino.setMode(STATION_MODE);
  whereas (!Fishino.start(MY_SSID, MY_PASS)) {
    delay(500);
  }
  #ifdef IPADDR
  Fishino.config(ip, gateway, subnet);
  #else
  Fishino.staStartDHCP();
  #endif
  whereas (Fishino.standing() != STATION_GOT_IP) {
    delay(500);
  }
  Udp.start(PORT);
  strip.start();
  strip.present();
}

void loop() {
  packetSize = Udp.parsePacket();
  if (packetSize == LEDS * 3) {
    char packetBuffer[packetSize];
    len = Udp.learn(packetBuffer, packetSize);
    if (len > 0) {
      packetBuffer[len] = 0;
    }
    for (int i = 0; i < LEDS * 3; i += 3) {
      r = (int)(byte * )(packetBuffer)[i];
      g = (int)(byte * )(packetBuffer)[i + 1];
      b = (int)(byte * )(packetBuffer)[i + 2];
      strip.setPixelColor(i / 3, r, g, b);
    }
    strip.present();
  }
}

Itemizing 2

/*
Identify: NeoPy - NodeMCU
Description: NeoPixels UDP controller
Creator: Luca Bellan
Model: 1.3
*/
#embody <Adafruit_NeoPixel.h>
#embody <ESP8266WiFi.h>
#embody <WiFiUdp.h>
 // BEGIN SETUP
#outline MY_SSID“ mio_ssid”
#outline MY_PASS“ mia_password”
#outline LEDS 150
//#outline IPADDR 192, 168, 1, 32
#outline GATE 192, 168, 1, 1
#outline SUB 255, 255, 255, 0
#outline PORT 4242
#outline PIN D3
// END SETUP

WiFiUDP Udp;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LEDS, PIN,
  NEO_GRB + NEO_KHZ800);
#ifdef IPADDR
IPAddress ip(IPADDR);
IPAddress gateway(GATE);
IPAddress subnet(SUB);
#endif
lengthy unsigned int packetSize;
unsigned int len;
int r, g, b;

void setup() {
  WiFi.mode(WIFI_STA);
  #ifdef IPADDR
  WiFi.config(ip, gateway, subnet);
  #endif
  WiFi.start(MY_SSID, MY_PASS);
  whereas (WiFi.standing() != WL_CONNECTED) {
    delay(500);
  }
  Udp.start(PORT);
  strip.start();
  strip.present();
}

void loop() {
  packetSize = Udp.parsePacket();
  if (packetSize == LEDS * 3) {
    char packetBuffer[packetSize];
    len = Udp.learn(packetBuffer, packetSize);
    if (len > 0) {
      packetBuffer[len] = 0;
    }
    for (int i = 0; i < LEDS * 3; i += 3) {
      r = (int)(byte * )(packetBuffer)[i];
      g = (int)(byte * )(packetBuffer)[i + 1];
      b = (int)(byte * )(packetBuffer)[i + 2];
      strip.setPixelColor(i / 3, r, g, b);
    }
    strip.present();
  }
}

}}

The UDP packet is then unpacked, and every LED is about; lastly, the “strip.present()” technique updates all of the LEDs.

We selected UDP for this technique as a result of it transmits packets extra shortly than TCP, which is essential for results requiring fast coloration modifications. Nevertheless, UDP doesn’t deal with packet loss, particularly with sluggish networks or excessive transmission speeds.

To create our results, we’ll add small delays to keep away from packet overlap on Fishino or NodeMCU. After programming each boards, join pin 3 of Fishino to the NeoPixel strip information line (IN pin) through jumpers, together with the 470-ohm resistor as in Fig. 2.

Energy the star through the 5V and GND pins from the ability provide, and energy Fishino utilizing the identical 5V and GND pins. For NodeMCU, comply with Fig. 3 to attach pin D3 to the three.3V facet of the logic stage converter, then join from the 5V facet by a 470-ohm resistor to the information line of the NeoPixel strip (white wire).

Energy the converter’s low-voltage facet with the three.3V and GND pins of NodeMCU; use the 5V provide for the excessive facet, NodeMCU (VIN and GND), and the NeoPixel strip.

Energy each NeoPixel installations and ensure their Wi-Fi connection (e.g., through the router configuration web page or with free software program like Superior IP Scanner); obtain and set up the newest Python 3.x model in your PC.

Fig. 2 Fishino Guppy and NeoPixel strip wiring diagram

Fig. 3 NodeMCU and NeoPixel strip wiring diagram

Python Growth

We selected Python to develop the Wi-Fi controller as a result of it’s a contemporary, versatile, intuitive, and easy-to-learn language. Moreover, it’s cross-platform, permitting our code to run on Home windows, Apple, and Linux (in our case, on Raspberry Pi).

The official web site additionally supplies a full Python tutorial.

Open IDLE, this system simply put in, which can seem like a easy textual content editor however lets you write and run Python applications. Save the empty file in the identical folder as neopy.py.

The NeoPy library supplies the next instructions:

object.Set(N, (R, G, B)): Set LED quantity N (e.g., from 0 to 55 in our instance) to the colour represented by R, G, B (every can vary from 0 to 255); for instance, to set the fifth LED to inexperienced, use object.Set(4, (0, 255, 0)).

object.SetAll((R, G, B)): Much like the earlier command, however units all LEDs to the identical coloration (use double parentheses); for instance, to set all LEDs to blue, use object.SetAll((0, 0, 255)).

object.SetBrightness(L): Units all LEDs to brightness proportion L (0 to 100), defaulting to 80. For 50% brightness, use object.SetBrightness(50).

object.Wheel(V): Returns an (R, G, B) worth primarily based on the handed parameter V (starting from 0 to 255, biking by all colours); for instance, to set all LEDs to a random coloration, use object.SetAll(object.Wheel(RANDOM_NUMBER)).

object.Present(): Sends the UDP command through Wi-Fi to replace all LEDs bodily.

Now that we all know the instructions, let’s write a brief program:

from neopy import NeoPy
import time
stella= NeoPy(56, “192.168.1.3”)
stella.SetBrightness(30)
for i in vary(56):
  stella.Set(i, (255, 0, 0))
  stella.Present()
  time. Sleep(0.5)

The primary line imports the NeoPy library, whereas the second imports the time library, which we’ll use to time the animation. Subsequent, we create a NeoPy object named “star,” indicating 56 LEDs and IP tackle 192.168.1.3 (port 4242 is the default and will match the sketch).

We then set the general brightness to 30% and create a for loop the place, at every step, variable “i” takes values from 0 to 55. At every step, we set one LED to pink utilizing the “Set()” technique, replace the LEDs with “Present()” and wait half a second with the “time” object.

Ensure that to align the three instructions contained in the for loop with a tab, or Python will throw a compilation error. Save and press F5 to run this system: if all settings are appropriate, the NeoPixels on the star will animate.

You may instantiate as many objects as you want; as an example, with the next code, we instantiate each the star and the NeoPixel strip, coloring one white and the opposite pink:

from neopy import NeoPy
stella= NeoPy(56, “192.168.1.3”)
striscia= NeoPy(150, “192.168.1.19”)
stella.SetAll((255, 255, 255))
stella.Present()
striscia.SetAll((255, 0, 0))
striscia.Present()

Within the mission repository on GitHub, you’ll additionally discover the “examples_star.py” and “examples_strip.py” information, which embody examples that can assist you perceive the varied scripts for creating animations.

Now, let’s change to Raspberry Pi to run the identical Python scripts we created on the PC. Obtain a brand new Raspbian picture from the official web site, write it to the MicroSD with Win32DiskImager, insert the MicroSD into the Raspberry Pi, energy it on, and join it to the identical community as our NeoPixels.

Utilizing an SSH terminal (like Putty or MobaXTerm), hook up with Raspberry Pi (username “pi,” password “raspberry”) and navigate to the “pi” listing: cd /residence/pi/. Set up Git with the command (press Y and Enter when prompted): sudo apt-get set up git. Subsequent, obtain the mission information from GitHub and enter the listing with the next instructions:

 git clone https://github.com/open-electronics/NeoPy cd NeoPy/

Be sure that you’re in the identical listing as “neopy.py” by typing ls -l and create a brand new file “take a look at.py”:

 nano take a look at.py

Copy the code for the small program that activates one LED at a time on the star and shut the file by saving it with CTRL+X, then Y, and Enter.

Run this system with:

 python3 take a look at.py

The NeoPixel star will mild up simply because it did once we ran the identical program on the PC. This lets us keep away from leaving a PC on because the Wi-Fi controller for all NeoPixel installations—as a substitute, we’ll depart the far more compact and energy-efficient Raspberry Pi working.

Think about creating a number of Python applications on our Raspberry Pi, every executing completely different results on our NeoPixel installations at varied instances of the day.

Manually launching these every time may very well be inconvenient, so we are able to use “crontab,” a scheduler in Raspbian, to set particular instances to launch every program. The syntax could appear difficult at first, however we’ll undergo it intimately.

Kind the command:

 crontab -e

The primary time, you’ll be prompted to decide on an editor to edit the schedule file; kind:

 2 (Nano) and press Enter.

This opens the enhancing window the place you’ll insert job traces, with every line representing a program to be executed, and containing six parameters separated by areas: MI H D MO DW COMMAND.

Let’s break down the parameters:

MI: Minutes (0-59, or * for “each minute”);
H: Hours (0-23, or * for “each hour”);
D: Day of the month (1-31, or * for “day by day”);
MO: Month (1-12, or * for “each month”);
DW: Day of the week (0-6, the place 0 is Sunday and 6 is Saturday, or * for “day by day”);
COMMAND: The command to execute (all the time specify the total path to the Python file).
Scroll to the tip of the file and enter this line:

 0 * * * * python3 /residence/pi/NeoPy/take a look at.py

This schedules take a look at.py to run at minute zero, each hour, day by day, each month, day by day of the week. Save and shut the file with CTRL+X, then Y and Enter, then await the subsequent hour to begin, which is able to set off the script, and confirm that the star lights up simply as if we launched the script manually. You may program all of the scripts you need by including new traces in crontab.

Conclusions

With Wi-Fi-controlled NeoPixels and the Raspberry Pi scheduling system, you possibly can place an LED strip in a bed room to simulate dawn at a selected time as a wake-up mild or create enjoyable backyard lighting results after sundown.

Moreover, by putting LEDs in varied rooms, you possibly can have them mild up at set or random intervals to simulate your presence at residence. Or, join sensors to Raspberry Pi and management lighting primarily based on sensor information.