Progetto realizzato da Serena Carmine
Il periodo natalizio è caratterizzato da giorni di festa, strade illuminate, vetrine decorate e tantissime luci colorate che rendono l’atmosfera più calda e accogliente. Spesso, osservando tutte queste decorazioni, ci viene spontaneo pensare: “Anche io vorrei accendere delle lucine di Natale personalizzate, perché quelle che compro non mi soddisfano”. Tuttavia, subito dopo, ci diamo sempre la stessa risposta: “Non so come farlo, quindi mi adeguerò a quelle già pronte”.
In realtà, creare delle luci di Natale personalizzate è molto più semplice di quanto si possa immaginare, soprattutto grazie all’utilizzo di Arduino Uno R3 e dei LED NeoPixel, che permettono di ottenere effetti luminosi colorati e animati in modo creativo e divertente. Questo tipo di progetto dimostra come la tecnologia possa essere utilizzata non solo per scopi tecnici, ma anche per realizzare oggetti decorativi capaci di creare atmosfera e trasmettere emozioni. Le luci, infatti, rappresentano uno degli elementi più importanti del periodo natalizio e, grazie alla programmazione, possono essere completamente personalizzate in base alle proprie idee.
Prima di iniziare a realizzare il progetto, è utile spiegare brevemente quali siano i componenti principali utilizzati e perché siano stati scelti.
Arduino Uno R3 è una scheda elettronica basata sul microcontrollore ATmega328P, che può essere paragonato a un piccolo “cervello” elettronico. Questo è responsabile dell’esecuzione di tutte le istruzioni programmate sulla scheda e permette di controllare i vari componenti collegati. Arduino Uno R3 è molto diffuso, soprattutto in ambito scolastico e didattico, perché consente di avvicinarsi all’elettronica e alla programmazione in modo semplice e intuitivo, senza la necessità di possedere conoscenze avanzate. Grazie ad Arduino è possibile collegare facilmente sensori, LED, motori, pulsanti e molti altri dispositivi, rendendo possibile la realizzazione di progetti interattivi, piccoli esperimenti, giochi elettronici e installazioni luminose.
Il NeoPixel, invece, è un LED RGB particolare che contiene al suo interno un piccolo chip di controllo. Questa caratteristica rende ogni singolo LED indipendente dagli altri, permettendo di controllarne individualmente colore e luminosità. Inoltre, tutti i LED possono essere gestiti tramite un unico filo di segnale, semplificando notevolmente i collegamenti e rendendo il circuito più ordinato. I NeoPixel esistono in diverse forme e dimensioni, come strisce, anelli e matrici. Per comodità e praticità abbiamo deciso di utilizzare una matrice 8×8, composta da 64 LED, perché più facile da collegare, programmare e integrare all’interno di strutture stampate in 3D.
Per rendere il lavoro più ordinato e sicuro è stata utilizzata anche una breadboard, che permette di realizzare i circuiti senza dover saldare i componenti e consente di modificare facilmente i collegamenti.
Utilizzando Arduino e NeoPixel siamo riusciti a realizzare decorazioni natalizie personalizzate e animate. Seguendo il progetto passo dopo passo, ci siamo resi conto che, nonostante inizialmente possa sembrare complesso, il procedimento risulta in realtà piuttosto semplice, soprattutto se affrontato con metodo e attenzione. Questo ha reso il lavoro non solo istruttivo, ma anche molto stimolante dal punto di vista creativo.
Le Stelle Luminose
All’interno di questo progetto sono stati sviluppati due esempi pratici che dimostrano in modo concreto le potenzialità di Arduino e dei LED NeoPixel. Il primo esempio riguarda la realizzazione di tre stelle luminose, una grande, una media e una piccola. Le stelle sono state stampate in 3D in dimensioni tali da ottenere forme precise e uno spessore adeguato per ospitare l’illuminazione interna. La stampa 3D ha permesso di personalizzare completamente dimensioni e forma delle stelle, adattandole al numero di LED utilizzati.
Per l’illuminazione delle stelle è stata utilizzata una striscia NeoPixel da 50 LED, inserita nello spessore delle strutture e fissata con del semplice nastro adesivo, una soluzione pratica ed efficace che ha consentito di mantenere i LED in posizione senza danneggiare i componenti. Dal punto di vista dei collegamenti elettrici, la striscia LED è stata collegata ad Arduino tramite il pin digitale D6 per il segnale, mentre gli altri due fili sono stati collegati rispettivamente al pin 5V e al GND della scheda. Questo collegamento ha permesso di alimentare correttamente i LED e di controllarli tramite software.
Il codice associato alle stelle consente di suddividere la striscia LED in tre zone differenti, una per ciascuna stella. A ogni zona è stato assegnato un colore specifico: rosso per la stella grande, verde per quella media e bianco per quella piccola. Attraverso una variabile di stato e una struttura di controllo, il programma gestisce diverse modalità di funzionamento, come l’accensione di una singola stella alla volta, l’accensione simultanea di tutte le stelle e una serie di effetti animati a tema natalizio. Tra questi effetti sono presenti il movimento di una cometa luminosa, il luccichio casuale dei LED e la pulsazione graduale della luminosità, che rende l’illuminazione più morbida ed elegante. In questo modo le stelle risultano dinamiche, ben visibili e coordinate tra loro, creando un effetto visivo armonioso.
Listato Stelle
#include
#define LED_PIN 6
#define NUMPIXELS 64
Adafruit_NeoPixel strip(NUMPIXELS, LED_PIN, NEO_GRB + NEO_KHZ800);
int stato = 0; // 0-4 = effetti base, 5-8 = effetti natalizi
int casett = 64;
uint32_t rosso, verde, bianco;
void setup() {
strip.begin();
strip.setBrightness(255);
strip.show();
rosso = strip.Color(255, 0, 0);
verde = strip.Color(0, 255, 0);
bianco = strip.Color(255, 255, 255);
}
void loop() {
stato++;
if (stato > 8) stato = 0;
switch (stato) {
case 0:
strip.clear();
strip.show();
delay(1000);
break;
case 1:
mostraStella(stella1_start, stella1_end, rosso);
delay(1000);
break;
case 2:
mostraStella(stella2_start, stella2_end, verde);
delay(1000);
break;
case 3:
mostraStella(stella3_start, stella3_end, bianco);
delay(1000);
break;
case 4:
accendiTutto();
delay(1000);
break;
case 5:
effettoCometa();
break;
case 6:
effettoArcobalenoNatalizio();
break;
case 7:
effettoLuccichio();
break;
case 8:
effettoPulsazioneTutte();
break;
}
}
void mostraStella(int start, int end, uint32_t col) {
strip.clear();
for (int i = start; i <= end; i++)
strip.setPixelColor(i, col);
strip.show();
}
void accendiTutto() {
for (int i = stella1_start; i <= stella1_end; i++)
strip.setPixelColor(i, rosso);
for (int i = stella2_start; i <= stella2_end; i++)
strip.setPixelColor(i, verde);
for (int i = stella3_start; i <= stella3_end; i++)
strip.setPixelColor(i, bianco);
strip.show();
}
void effettoCometa() {
strip.clear();
for (int i = 0; i < NUMPIXELS; i++) { strip.clear(); strip.setPixelColor(i, rosso); if (i > 0) strip.setPixelColor(i - 1, strip.Color(0, 255, 0));
if (i > 1) strip.setPixelColor(i - 2, strip.Color(255, 255, 255));
strip.show();
delay(40);
}
}
void effettoArcobalenoNatalizio() {
for (int j = 0; j < 256; j++) {
for (int i = 0; i < NUMPIXELS; i++) {
if (i % 3 == 0)
strip.setPixelColor(i, strip.Color((j + 150) % 255, 0, 0)); // rosso
else if (i % 3 == 1)
strip.setPixelColor(i, strip.Color(0, (j + 150) % 255, 0)); // verde
else
strip.setPixelColor(i, strip.Color(j, j, j)); // bianco
}
strip.show();
delay(15);
}
}
void effettoLuccichio() {
strip.clear();
for (int t = 0; t < 80; t++) {
int px = random(NUMPIXELS);
uint32_t colori[3] = {
rosso,
verde,
bianco
};
strip.setPixelColor(px, colori[random(3)]);
strip.show();
delay(50);
strip.setPixelColor(px, 0);
}
}
void effettoPulsazioneTutte() {
for (int b = 10; b < 255; b += 5) {
strip.setBrightness(b);
for (int i = stella1_start; i <= stella1_end; i++) strip.setPixelColor(i, rosso); strip.show(); delay(15); } for (int b = 255; b > 10; b -= 5) {
strip.setBrightness(b);
for (int i = stella1_start; i <= stella1_end; i++)
strip.setPixelColor(i, rosso);
strip.show();
delay(15);
}
for (int b = 10; b < 255; b += 5) {
strip.setBrightness(b);
for (int i = stella2_start; i <= stella2_end; i++) strip.setPixelColor(i, verde); strip.show(); delay(15); } for (int b = 255; b > 10; b -= 5) {
strip.setBrightness(b);
for (int i = stella2_start; i <= stella2_end; i++)
strip.setPixelColor(i, verde);
strip.show();
delay(15);
}
for (int b = 10; b < 255; b += 5) {
strip.setBrightness(b);
for (int i = stella3_start; i <= stella3_end; i++) strip.setPixelColor(i, bianco); strip.show(); delay(15); } for (int b = 255; b > 10; b -= 5) {
strip.setBrightness(b);
for (int i = stella3_start; i <= stella3_end; i++)
strip.setPixelColor(i, bianco);
strip.show();
delay(15);
}
strip.setBrightness(255); // reset luminosità
}
La Casetta di Babbo Natale
Il secondo esempio riguarda l’illuminazione di una casetta di Babbo Natale. Anche in questo caso la struttura è stata stampata in 3D, ma realizzata su misura per essere posizionata direttamente sopra una matrice NeoPixel 8×8 da 64 LED. La casetta è stata appoggiata sopra i LED, permettendo alla luce di diffondersi dal basso verso l’alto e illuminare in modo uniforme tutta la struttura. Questo accorgimento ha reso l’effetto finale particolarmente realistico e suggestivo, soprattutto in condizioni di scarsa illuminazione.
I collegamenti elettrici sono simili a quelli del progetto delle stelle: il filo del segnale è collegato al pin D6 di Arduino, mentre l’alimentazione è fornita tramite i pin 5V e GND. Il codice dedicato alla casetta gestisce l’intera matrice come un unico insieme di LED, creando un’illuminazione continua e animata. I LED alternano i colori rosso e verde, tipici del Natale, mentre un’onda luminosa in movimento dà l’impressione di una luce viva e in continuo cambiamento. Inoltre, piccoli scintillii casuali di colore bianco o dorato arricchiscono ulteriormente l’effetto visivo, simulando le luci decorative degli alberi di Natale.
Listato Casetta
#include
#define PIN_LED 6
#define N 64
Adafruit_NeoPixel m(N, PIN_LED, NEO_GRB + NEO_KHZ800);
float t = 0; // tempo per animazione
void setup() {
m.begin();
m.show();
randomSeed(analogRead(0)); // per scintillii casuali
}
void loop() {
t += 0.05; // velocità dell'onda
for (int i = 0; i < N; i++) {
// Creiamo una base rosso/verde alternata come un vero albero di Natale
int r = 0;
int g = 0;
int b = 0;
if (i % 2 == 0) {
r = 255; // rosso
g = 0;
} else {
r = 0;
g = 255; // verde
}
// Aggiungiamo un'onda di luce che scorre lungo la striscia
float wave = (sin(t + i * 0.3) * 0.5 + 0.5); // valore tra 0 e 1
r = int(r * wave);
g = int(g * wave);
// Piccoli scintillii dorati/bianco
if (random(0, 100) < 10) { // 10% di probabilità
r = 255;
g = 255;
b = 200; // dorato/bianco caldo
}
m.setPixelColor(i, m.Color(r, g, b));
}
m.show();
delay(50);
}
In conclusione, entrambi i progetti dimostrano come sia possibile combinare Arduino, LED NeoPixel e stampa 3D per creare decorazioni natalizie personalizzate, originali e completamente controllabili tramite software. Grazie a una struttura modulare e a un codice facilmente modificabile, il progetto risulta adattabile a molte altre idee creative e rappresenta un ottimo esempio di applicazione pratica dell’elettronica e della programmazione in ambito creativo e didattico.
Quelli descritti sono progetti che potete ricreare anche voi.
Buon divertimento e buone feste!
