ESP32 Neopixel

Turn on Neopixels by ESP32

05-04-22 2007

NeoPixels, also known as WS2812B LEDs, can be used in conjunction with an ESP32 microcontroller to create colorful and customizable lighting effects. The ESP32 can control the NeoPixels via its digital output pins, using the NeoPixel library for the ESP32.

To use NeoPixels with the ESP32, you will first need to connect the NeoPixels to the ESP32‘s digital output pin. This can be done by connecting the data input pin of the first NeoPixel to the ESP32‘s digital output pin and connecting the data output pin of the last NeoPixel to the data input pin of the first one creating a chain of NeoPixels.

Once the NeoPixels are connected, you can use the NeoPixel library to control the color and brightness of each individual NeoPixel. The library provides various functions such as setting the color, brightness, and animation of the NeoPixels. With the library and the ESP32‘s capabilities, you can create a wide range of lighting effects, such as fading, scrolling text, and even creating custom animations.

It’s important to note that NeoPixels require a high amount of current to operate, therefore, you should use a separate power supply for the NeoPixels, and also, you should use a level shifter or a voltage divider circuit to avoid damaging the ESP32.

Purpose of this tutorial:

In this tutorial we will turn on Neopixels using ESP32.

Necessary components

ESP32

An ESP32 card is a type of development board that is based on the ESP32 microcontroller. The ESP32 is a powerful, low-cost microcontroller with built-in WiFi and Bluetooth capabilities. It is commonly used for IoT projects, home automation, and other applications that require wireless connectivity.

An ESP32 card typically includes the ESP32 microcontroller, flash memory, a USB interface for programming and power, and various other components, such as voltage regulators, oscillators, and headers for connecting external devices.

The ESP32 card can be programmed using the Arduino IDE, which supports C and C++ programming languages and has a simple and user-friendly interface. There are also several libraries available for the ESP32, which provide additional functionality and ease of use.

ESP32 cards are available from various manufacturers, with different features and capabilities depending on the specific model. Some ESP32 cards include additional components such as a display, sensors, or a battery management system.

By using an ESP32 card, you can easily create wireless connected devices that can be controlled remotely, and the ESP32‘s low power consumption makes it ideal for battery-powered applications.

Neopixels of 8 LEDs

NeoPixels, also known as WS2812B LEDs, are individually addressable RGB LEDs that can be controlled to create various lighting effects. Each NeoPixel consists of a red, green, and blue LED, and a tiny microcontroller that controls the brightness and color of the LED. A string of 8 NeoPixels can be controlled using a microcontroller, such as an ESP32, to create a variety of lighting effects.

Test plate

A test plate for Arduino is a type of test plate that can be used in conjunction with an Arduino microcontroller to automate experiments or tests. The test plate typically contains multiple wells or compartments that can hold samples or test solutions, and is designed to interface with the Arduino’s digital inputs and outputs.

Connecting wires

Wires in a robotic system are used to connect and transmit electrical signals between different components of the robot. These components can include sensors, actuators, motors, and the microcontroller, such as an Arduino. The wires in a robotic system are typically made of copper and are insulated to prevent electrical interference and short circuits.

The type of wires used in a robotic system depends on the specific application and requirements of the robot. For example, a robot that requires high-current power transmission may use thicker, high-gauge wires, while a robot that requires a high degree of flexibility and movement may use thinner, more flexible wires.

Wires in a robotic system can be used to transmit power, control signals, and data between the different components of the robot. They can also be used to connect the robot to external devices, such as a computer or a power source. The proper use of wires is crucial for the robot to function properly, and a bad wiring can cause malfunction, safety hazards, and even damage to the equipment.

It is important to use the right type of wire for the right application, and it is also important to keep the wires organized and secure to prevent them from getting tangled, damaged, or disconnected.

Assembly

To carry out the assembly, you can connect:

Neopixels GND pin to GND pin of ESP32
the 5V pin of Neopixels to the 3.3V pin of ESP32
Neopixels DI pin to pin 5 of ESP32

Micropython Programs

Here are programs that allow Neopixels to be turned on by ESP32.

boot.py

import machine, neopixel
import time
n = 8
p = 5

np = neopixel.NeoPixel(machine.Pin(p), n)

i=1
while True:
 if (i<10) :
  np[0] = (25*i, 10*i, i*10) #led 1
  np[1] = (30+i*5, 24, 153)  #led 2
  np[2] = (5*i, 20*i, 22+i*5) #led 3 
  np[3] = (17*i, 20, 100) #led 4
  np[4] = (12*i, 20*i, 0) #led 5
  np[5] = (25, 10*i, 15) #led 6
  np[6] = (12*i, 50, i*15) #led 7
  np[7] = (10*i, 15*i, i*20) #led 8
  np.write()
  i=i+1
  time.sleep(1)
 else:
  i=1

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

import machine, neopixel

import time

n = 8

p = 5

np = neopixel.NeoPixel(machine.Pin(p), n)

i=1

while True:

if (i<10) :

np[0] = (25*i, 10*i, i*10) #led 1

np[1] = (30+i*5, 24, 153) #led 2

np[2] = (5*i, 20*i, 22+i*5) #led 3

np[3] = (17*i, 20, 100) #led 4

np[4] = (12*i, 20*i, 0) #led 5

np[5] = (25, 10*i, 15) #led 6

np[6] = (12*i, 50, i*15) #led 7

np[7] = (10*i, 15*i, i*20) #led 8

np.write()

i=i+1

time.sleep(1)

else:

i=1

neopixel.py

# NeoPixel driver for MicroPython
# MIT license; Copyright (c) 2016 Damien P. George, 2021 Jim Mussared

#from machine import bitstream

class NeoPixel:
    # G R B W
    ORDER = (1, 0, 2, 3)

    def __init__(self, pin, n, bpp=3, timing=1):
        self.pin = pin
        self.n = n
        self.bpp = bpp
        self.buf = bytearray(n * bpp)
        self.pin.init(pin.OUT)
        # Timing arg can either be 1 for 800kHz or 0 for 400kHz,
        # or a user-specified timing ns tuple (high_0, low_0, high_1, low_1).
        self.timing = (
            ((400, 850, 800, 450) if timing else (800, 1700, 1600, 900))
            if isinstance(timing, int)
            else timing
        )

    def __len__(self):
        return self.n

    def __setitem__(self, i, v):
        offset = i * self.bpp
        for i in range(self.bpp):
            self.buf[offset + self.ORDER[i]] = v[i]

    def __getitem__(self, i):
        offset = i * self.bpp
        return tuple(self.buf[offset + self.ORDER[i]] for i in range(self.bpp))

    def fill(self, v):
        b = self.buf
        l = len(self.buf)
        bpp = self.bpp
        for i in range(bpp):
            c = v[i]
            j = self.ORDER[i]
            while j < l:
                b[j] = c
                j += bpp

    def write(self):
        # BITSTREAM_TYPE_HIGH_LOW = 0
        bitstream(self.pin, 0, self.timing, self.buf)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

# NeoPixel driver for MicroPython

# MIT license; Copyright (c) 2016 Damien P. George, 2021 Jim Mussared

#from machine import bitstream

class NeoPixel:

# G R B W

ORDER = (1, 0, 2, 3)

def __init__(self, pin, n, bpp=3, timing=1):

self.pin = pin

self.n = n

self.bpp = bpp

self.buf = bytearray(n * bpp)

self.pin.init(pin.OUT)

# Timing arg can either be 1 for 800kHz or 0 for 400kHz,

# or a user-specified timing ns tuple (high_0, low_0, high_1, low_1).

self.timing = (

((400, 850, 800, 450) if timing else (800, 1700, 1600, 900))

if isinstance(timing, int)

else timing

)

def __len__(self):

return self.n

def __setitem__(self, i, v):

offset = i * self.bpp

for i in range(self.bpp):

self.buf[offset + self.ORDER[i]] = v[i]

def __getitem__(self, i):

offset = i * self.bpp

return tuple(self.buf[offset + self.ORDER[i]] for i in range(self.bpp))

def fill(self, v):

b = self.buf

l = len(self.buf)

bpp = self.bpp

for i in range(bpp):

c = v[i]

j = self.ORDER[i]

while j < l:

b[j] = c

j += bpp

def write(self):

# BITSTREAM_TYPE_HIGH_LOW = 0

bitstream(self.pin, 0, self.timing, self.buf)

You can also see

View location data sent by NEO-M6 GPS using ESP32 board

22-02-23

Obstacle avoiding robot using ESP32

10-02-23

0 commentaire

Leave a comment

Annuler la réponse

Scroll to Top