ESP32 Neopixel

Allumer Neopixels par la carte ESP32

04-04-22 2205

But de ce tutoriel:

Dans ce tutoriel on va allumer Neopixels par la carte ESP32.

Composants nécessaires

carte ESP32

ESP32 est une carte de développement électronique basée sur le microcontrôleur ESP32 de la société Espressif. Il s’agit d’un microcontrôleur à double cœur avec un processeur principal Xtensa LX6 et un processeur secondaire dedié au traitement du signal. La carte ESP32 est conçue pour être utilisée dans les applications IoT (Internet des objets) et comprend une variété de fonctionnalités pour faciliter la communication avec d’autres dispositifs et l’accès à Internet.

Voici quelques-unes des principales caractéristiques de la carte ESP32 :

Bluetooth et WiFi : La carte ESP32 inclut un module WiFi et Bluetooth pour faciliter la communication sans fil avec d’autres dispositifs.
Connectivité : La carte ESP32 est équipée de plusieurs ports de communication, tels que USB, UART, I2C et SPI, ce qui la rend idéale pour la communication avec d’autres composants électroniques.
Mémoire : La carte ESP32 dispose de 512 Ko de mémoire flash et de 8 Mo de RAM.
Energie : La carte ESP32 est alimentée par une tension de 3,3 V et est dotée d’un circuit de gestion de l’alimentation pour gérer les périodes de veille et d’arrêt.
Logiciels : La carte ESP32 est compatible avec un large éventail de logiciels de développement, tels que Arduino, ESP-IDF et MicroPython. Cela permet aux développeurs de choisir le logiciel de développement qui leur convient le mieux.

Neopixels

Les Neopixels sont des LED programmables fabriquées par la société Adafruit Industries. Elles sont souvent utilisées pour créer des projets de décoration d’intérieur et de robotique qui nécessitent une grande flexibilité de couleur et de luminosité.

Les Neopixels sont des LED RGB (rouge, vert, bleu) qui peuvent être contrôlées individuellement en utilisant un microcontrôleur ou un ordinateur. Elles sont connectées en série et partagent un bus de données commun, ce qui permet de contrôler plusieurs LED en envoyant simplement une séquence de données.

plaque d’essai

Une plaque d’essai est un type de carte de développement électronique qui permet aux développeurs de tester et de prototyper facilement des circuits électroniques. Elles sont souvent utilisées par les développeurs pour tester rapidement des idées et des conceptions avant de les intégrer à un projet plus important ou de les intégrer dans une carte de développement plus permanente.

Les plaques d’essai sont généralement basées sur un microcontrôleur, qui est un processeur facile à utiliser et à programmer qui peut être utilisé pour contrôler une variété de circuits électroniques. Les plaques d’essai incluent généralement des broches d’extension qui permettent de connecter facilement des composants électroniques tels que des capteurs, des afficheurs, des moteurs et d’autres composants.

fils de connexion

Les fils de connexion sont des fils électriques utilisés pour connecter des composants électroniques à une carte de développement ESP32. Ils sont généralement utilisés pour connecter des capteurs, des actionneurs, des afficheurs et d’autres composants à la carte ESP32 afin de créer des circuits électroniques.

Il existe deux types de fils de connexion: les fils de connexion mâle-mâle et les fils de connexion mâle-femelle. Les fils de connexion mâle-mâle sont utilisés pour connecter des composants qui ont tous deux des broches mâles, tandis que les fils de connexion mâle-femelle sont utilisés pour connecter des composants avec une broche mâle et une broche femelle.

Les fils de connexion sont généralement fabriqués en cuivre ou en alliage de cuivre et sont revêtus d’un isolant en plastique pour protéger les fils électriques et empêcher les courts-circuits. Ils sont disponibles dans une variété de couleurs pour aider à identifier et organiser les différents fils dans un circuit.

Montage

Pour réaliser le montage, on peut connecter:

la broche GND de Neopixels à la broche GND de la carte ESP32
la broche 5V de Neopixels à la broche 3.3V de la carte ESP32
la broche DI de Neopixels à la broche D5 de la carte ESP32

Programmes micropython

Voici les programmes qui permettent d’allumer Neopixels par la carte 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)
  np[1] = (30+i*5, 24, 153)
  np[2] = (5*i, 20*i, 22+i*5)
  np[3] = (17*i, 20, 100)
  np[4] = (12*i, 20*i, 0)
  np[5] = (25, 10*i, 15)
  np[6] = (12*i, 50, i*15)
  np[7] = (10*i, 15*i, i*20)
  np.write()
  i=i+1
  time.sleep(1)
 else:
  i=1

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)

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

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

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

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

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

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

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

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)

# NeoPixel driver for MicroPython

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

Vous pouvez voir aussi

Afficher les données de localisation envoyées par le GPS NEO-M6 en utilisant la carte ESP32

22-02-23

Construction d’un robot commandé par la carte ESP32 qui détecte et évite les obstacles

07-02-23

Allumer Neopixels par la carte ESP32

But de ce tutoriel:

Composants nécessaires

carte ESP32

plaque d’essai

fils de connexion

Montage

Programmes micropython

Vous pouvez voir aussi

Afficher les données de localisation envoyées par le GPS NEO-M6 en utilisant la carte ESP32

Construction d’un robot commandé par la carte ESP32 qui détecte et évite les obstacles

0 commentaire

Laisser un commentaire

Annuler la réponse

Tutoriels récents

Capteur ultrason Arduino

Réalisation d’un robot suiveur de ligne avec Micro:bit

Utilisation de la caméra OV7670 avec la carte Arduino UNO

Serveur Web de diffusion vidéo avec ESP32-CAM

Tutos les plus vus

Système d’arrosage automatique avec Arduino

Allumer une LED par Arduino

Réalisation d’une barrière de parking automatique avec Arduino

Utilisation du capteur Ultrason HC-SR04 avec l’Arduino

Tutos les plus commentés

Commander un moteur par Arduino et le module L298N

Système de mesure du niveau d’eau contrôlé par Arduino

Système d’arrosage automatique avec Arduino

Commander un moteur à courant continu avec Micro:bit