Latest revision as of 23:14, 19 March 2026

Introduzione

Neopixel è un marchio registrato di Adafruit Industries.
I NeoPixel sono strisce o moduli LED RGB indirizzabili individualmente, basati su chip come il WS2812B, che permettono di controllare il colore e la luminosità di ogni singolo LED tramite un solo pin dati da microcontrollori come Arduino. Ogni LED integra un driver, consentendo effetti luminosi complessi e animazioni personalizzate.
In dettaglio, i singoli elementi sono in formato SMD (componenti montati direttamente sulla scheda del circuito stampato), la forma è rettangolare e contengono tre LED ad alta intensità (rosso, verde e blu). Questo rettangolo contiene un chip, ad es. il WS2812B, che nella forma più semplice ha quattro pin: alimentazione + (da 3.5V a 5.3V max), terra (GND) e D_in (data in, segnale in ingresso) e D_out (data aout, segnale in uscita al prossimo LED).
Punti chiave:

Indirizzabilità Indipendente: a differenza delle strisce LED RGB tradizionali, dove l'intera striscia mostra lo stesso colore, con i NeoPixel puoi impostare un colore diverso per ogni pixel.
Facilità di cablaggio: richiedono solo tre connessioni: alimentazione (5V), massa (GND) e un pin dati (D_ⁱⁿ).
Concatenazione: è possibile collegare in serie più moduli (strisce, anelli, matrici) usando il pin di uscita dati (D_out) per creare display complessi.
Librerie Software: si controllano facilmente tramite la libreria Adafruit NeoPixel o FastLED, definendo i colori tramite valori RGB.
Applicazioni: ideali per progetti di illuminazione creativa, wearable, segnapunti, display a matrice e spade laser.

Ogni LED consuma 60 mA, il problema di un consumo eccessivo potrebbe sorgere in funzione di quanti LED accendere contemporaneamente pertanto occorre leggere le caratteristiche del modello di Arduino per fare un eventuale adeguamento aggiungendo alimentazioni seprate.

Risorse

Ispirazione e materiale da Paolo Aliverti, video:

Altro

NTP, integrazione NTP connessione WiFi, link interno [qui]
Implementazione di Mauro Alfieri NeoClock

I colori associabili ai singoli LED sono forniti mediante la combinazione di tre valori R(ed), G(reen) e B(lue) associati ai colori fondamentali, mediante la variazione di questi, in combinazioni, è possibile riprodurre i colori a piacimento. Per l'esatta valorizzazione di questi parametri si può usare il sito: Color generator.
Tuttavia ecco alcuni valori fondamentali:

Implementazione

Da video di Paolo Aliverti, servono:

Materiale:

3 anelli Neopixel.
3 condensatori (capacitor) elettrolitico da 1000 μF (microfarad) da 5/10V. Da collegare sull'alimentazione dell'anello.
3 resistenze da 470 Ω da collegare tra i pin Ardiono e la connessione dati all'anello.

Considerazioni:
1. le resistenze
La resistenza da 470 Ohm è consigliata anche con l'Arduino Nano 33 IoT, ma per un motivo diverso dal livellamento della tensione, parliamo del pin del segnale digitale di comunicazione tra Arduino e l'anello.
Ecco perché usarla:

Protezione dai picchi: la funzione principale della resistenza è proteggere il primo LED della catena da eventuali picchi di corrente (spikes) sulla linea dati che potrebbero bruciarlo all'accensione.
Integrità del segnale: aiuta a ridurre i riflessi di segnale e le interferenze ("ringing") lungo il cavo, garantendo che i colori dei Neopixel rimangano stabili e senza sfarfallii.
Tensione logica: anche se il Nano 33 IoT lavora a 3.3V e i Neopixel preferirebbero 5V per i dati, solitamente riescono a leggere il segnale a 3.3V senza problemi. La resistenza non ostacola questa comunicazione, ma aggiunge uno strato di sicurezza elettrica.

Extra:
Se si nota che i LED non si accendono o i colori "impazziscono", il problema potrebbe essere proprio la logica a 3.3V che è troppo bassa per i 5V dei Neopixel. In quel caso, oltre alla resistenza, avresti bisogno di un Logic Level Shifter (come il 74AHCT125) per alzare il segnale a 5V.

2. condensatori elettrolitici
Il condensatore elettrolitico da 1000 µF (o comunque tra 500 e 1000 µF) serve come serbatoio di energia locale per proteggere e stabilizzare i Neopixel.
Ecco i motivi principali per cui viene inserito:

Protezione dai picchi di accensione: quando colleghi l'alimentatore, può verificarsi un picco di tensione improvviso che rischierebbe di danneggiare i microcontrollori integrati in ogni LED Neopixel. Il condensatore assorbe questo sbalzo iniziale.
Compensazione dei cali di tensione (Brownout): i Neopixel possono assorbire molta corrente in modo repentino (ad esempio quando passano dal nero al bianco brillante). Se l'alimentatore non è abbastanza veloce a reagire, la tensione cala e i LED possono resettarsi o mostrare colori errati (glitch). Il condensatore fornisce l'energia necessaria in quei microsecondi di picco.
Stabilizzazione del segnale: evita che i disturbi sulla linea di alimentazione "sporchino" il segnale dati, prevenendo sfarfallii indesiderati.

Specifiche tecniche per il progetto:

Tensione: condensatore per almeno 6.3V o superiore (ad esempio 10V o 16V vanno benissimo).
Polarità: essendo un condensatore elettrolitico, ha un verso: il terminale negativo (solitamente indicato da una banda chiara sul fianco) deve andare al GND, mentre quello positivo al 5V.
Posizionamento: Va messo il più vicino possibile all'ingresso dell'alimentazione dei cerchi LED.

NOTA considerare che tre cerchi LED possono consumare parecchia corrente.

Semplice esempio

Preso da Paolo Aliverti [1]

Si usano le librerie:

FastLed di Daniel Garcia.
RTClib di Adafruit, per pilotare l'orologio RTC.

SUGGERIMENTO usare l' HSV ??? colore proprorzionale.

#include <Arduino.h>
#include <FastLED.h>
#include "RTClib.h"
 
byte const c_pinHours = 3;
byte const c_pinMinutes = 4;
byte const c_pinSeconds = 2;
byte const c_nrLEDHours = 24;
byte const c_nrLEDMinutes = 16;
byte const c_nrLEDSeconds = 8;
 
RTC_DS1307 m_rtc;
 
//Array per pilotare i singoli elementi delle strisce LED
CRGB m_hLed[c_nrLEDHours];	//Per le ore
CRGB m_mLed[c_nrLEDMinutes];	//Per i minuti
CRGB m_sLed[c_nrLEDSeconds];		//Per i secondi
 
//Prototipi di funzioni
void ClearLeds();
void ShowHour(byte hour);
void ShowMinute(byte minute);
void ShowSecond(byte second);
void PickColor(byte n, int *r, int *g, int *b);
//---------------------------
 
void setup() {
	Serial.begin(9600);
	ClearLeds();
	if (!m_rtc.begin()) {
		Serial.println("Errore inizializzaazione RTC, verifica il clock.");
		return;
	}
	if (!m_rtc.isrunning()) { //Prima assegnazione RTC con l'orario di compilazione
		m_rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
	}
}
 
void loop() {
  DateTime now = m_rtc.now();
  ShowHour(now.hour());
  ShowMinute(now.minute());
  ShowSeconds(now.second());
 
  FastLED.show();
  delay(500);
}
 
void ClearLeds() {
	//Definisco 3 controllori per le strisce LED per il chipset WS2812 dei Neopixel:
	FastLED.addLeds<WS2812, c_pinSeconds, GRB>(m_sLed, 8);
	FastLED.addLeds<WS2812, c_pinMinutes, GRB>(m_mLed, 16);
	FastLED.addLeds<WS2812, c_pinHours, GRB>(m_hLed, 24);
 
	//Azzero il colore delle tre strisce LED
	for (int i=0; i<c_nrLEDSeconds; i++) {
		m_sLed[i] = CRGB(0,0,0);			//Colore spento
	}
	for (int i=0; i<c_nrLEDMinutes; i++) {
		m_mLed[i] = CRGB(0,0,0);		
	}
	for (int i=0; i<c_nrLEDHours; i++) {
		m_hLed[i] = CRGB(0,0,0);		
	}
	FastLED.show(); //In base al colore assegnato in qs caso spegnerà TUTTI i LED
}
 
void ShowHour(byte hour) {
	int r, g, b;
	PickColor(hour, &r, &g, &b); //Passo il valore degli indirizzi per passaggio x referenza
	m_hLed[hour] = CRGB(r, g, b); //Assegna il colore all'ora corrente da impostare
	//Si spegne il LED dell'ora precedente
	if (hour > 0)  //Non mezzanotte
		m_hLed[hour-1] = CRGB(0, 0, 0);
	else
		m_hLed[c_nrLEDHours-1] = CRGB(0, 0, 0);
}
 
void ShowMinute(byte minute) {	
	int r, g, b;
	int newIdx = map(minute, 0, 60, 0, c_nrLEDMinutes);
 
	PickColor(newIdx, &r, &g, &b);
	m_mLed[newIdx] = CRGB(r, g, b); //Assegna il colore al minuto corrente da impostare
	//Si spegne il LED dell'ora precedente
	if (newIdx > 0) 
	    m_mLed[newIdx-1] = CRGB(0, 0, 0);
	else
	    m_mLed[c_nrLEDMinutes-1] = CRGB(0, 0, 0);
}
 
void ShowSeconds(byte second) {
	int r, g, b;
	int newIdx = map(second, 0, 60, 0, c_nrLEDSeconds);
 
	PickColor(newIdx, &r, &g, &b);
	m_sLed[newIdx] = CRGB(r, g, b); //Assegna il colore al secondo corrente da impostare
	//Si spegne il LED dell'ora precedente
	if (newIdx > 0)  
	    m_sLed[newIdx-1] = CRGB(0, 0, 0);
	else
	    m_sLed[c_nrLEDSeconds-1] = CRGB(0, 0, 0);
}
 
void PickColor(byte n, int *r, int *g, int *b) { //Con * mi riferisco al valore puntato
	byte nrColors = 5; //Uso solo 5 colori
 
	//SUGGERIMENTO usare l' HSV ???  colore proprorzionale
 
	switch (n%nrColors) { //Uso il modulo usando il resto della divisione
		case 0:
		    *r = 255;
		break;
		case 1:
		    *b = 255;
		break;
		case 2:
		    *g = 255;
		break;
		case 3:
		    *r = 127;
		    *g = 127;
		break;
		case 4:
		*r = 127;
		*g = 127;
		break;
	}
}

bhò?

// NeoPixel Ring 
#include <Adafruit_NeoPixel.h>
 
#ifdef __AVR__
  #include <avr/power.h>
#endif
 
//pin a cui sono connessi 
#define PIN 6
//numero pixel
#define PIX      16
 
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(PIX, PIN, NEO_GRB + NEO_KHZ800);
 
void setup() {
  pixels.begin(); 
 
  pixels.setPixelColor(0, pixels.Color(0,150,0));
  pixels.show();
  delay(1000); 
 
  //spengo tutto
}
 
void loop() {
  //BLINK
  for (int i = 0; i < PIX; i++) {
    pixels.setPixelColor(i, pixels.Color(255,0,0));
    pixels.show();
  }
  delay(1000);
  for (int i = 0; i < PIX; i++) {
    pixels.setPixelColor(i, pixels.Color(0,0,0));
    pixels.show();
  }
  delay(1000);
}

Etc

(Mappa e Link)

Arduino Progetti | Arduino indice | Arduino | Arduino Integrazioni tipiche

C++ Info fondamentali | Dizionario Elettronica | Elettronica | Elettronica Appunti

Parole chiave:

Navigation

Help

Tools

WIDGETS

Widgets

Recent changes

Wanted articles

Who is online?

Article tools

Difference between revisions of "Arduino Orologio NeoPixel"

From Aino Wiki