Questo � il post delle piccole ansie di un pap�� 
Il consueto appuntamento mensile dal barbiere Luigi per il taglio di capelli. Incontro Albino, entrambi abbiamo i figli della stessa et� che frequentano il medesimo Liceo. Inevitabile i discorsi di scuola e problemi adolescenziali, primo tra tutti la difficolt� nel trovare una passione o ampliare le proprie relazioni al di fuori della scuola.
Un’adolescente in casa insegna molte cose. Osservavo in queste serate, guardando mio figlio che studia, la modalit� con cui al liceo vengono propinate le materie scientifiche: fisica, chimica, biologia… tutte categoricamente su carta, esercizi sui moti uniformemente accelerati, studio di molecole e composti organici� solo�su carta mannaggia… il laboratorio e luogo sconosciuto, per non parlare dell�informatica� lasciamo perdere.
Non voglio incominciare il solito discorso disfattista e lamentoso su taglio delle ore dei laboratori e mancanza di denaro e se pur impegnato a scuola nel trovare soluzioni, incominciano a stancarmi i ragionamenti sui massimi sistemi e sulla funzione docente, sono pi� concentrato sulle soluzioni e dare possibilit�, nel limite delle mie forze, ai ragazzi che mostrano interesse.
Il carico di studio elevatissimo (che noto al liceo) e la quasi assenza di materie svolte in laboratorio fanno perdere nei ragazzi la percezione del senso degli argomenti che stanno studiando provocando disagio, a ci� si aggiunge il periodo di �scombussolamento ormonale� che provoca stati d�animo estremamente controversi� sicuro che mi procurer� l�ira dei colleghi del liceo� ma poco importa.
Come genitore ci si interroga continuamente e si cercano strategie che possano favorire l�accensione di quella �fiammella� di passione nei propri figli, attivando, si spera, il volano che porta al desiderio di scoperta� insomma ansie da genitori.
Tutto ci� per dire, che siano esperimenti di elettronica, osservazioni astronomiche con un telescopio, l�uso di un microscopio, � importante insegnare a dare forma fisica ai propri progetti, potranno nascere da un copia ed incolla visto su internet, ma � cos� che si impara , se non ci si ferma al copia ed incolla ovviamente, comprendere, rielaborare.
Nella mente di mio figlio, ora piena di poemi Omerici, Epica Latina e tra poco anche dei Promessi Sposi, sto cercando di inserire anche la materia �progetta e costruisci�.
Con stampante 3D e tanta elettronica che gira per casa da qualche tempo abbiamo incominciato con Arduino, robotica ed automazione in genere e come per i miei studenti anche per questo, �particolare studente� Arduino svolge egregiamente la funzione di �facilitatore� e mi sta rendendo la vita da padre un po� pi� serena.
Corsi su Arduino ovunque online a scuola e nei FabLab� ora � giunta l�ora di farli anche alla famiglia la figlia pi� piccola costruisce piccolo alberi di Natale con LED, il grande programmazione ed elettronica.
Con il liceale�siamo giunti in queste serate alla realizzazione di un semplice controllo di una striscia RGB che abbiamo utilizzato per adornare la zona in cui � collocato l�albero di Natale, poich� lo sketch � di interesse per alcuni miei allievi di 5�, pubblico e lascio a chi vorr� la possibilit� di migliorarlo.
La spiegazione nei commenti dello sketch.
Nello sketch che � l�ultima versione sviluppata dal giovane studente, trovate commentate alcune parti di codice che potrete attivare e che svolgono funzioni diverse.
1. Cambio colore graduale (in accensione ed in spegnimento) casuale nella scelta del colore:
- solo bianco
- solo rosso
- solo verde
- solo blu
- variazione continua di tutti i colori
2. Variazione di una sola delle modalit� del punto 1
Compiti per Natale:
3. inserimento di un sensore ad ultrasuoni che percepisce il passaggio di persone davanti all�Albero di Natale emettendo una luce intensa bianca
4. Controllo remoto con telecomando
5. Controllo remoto con cellulare (per questo per� credo che ci penser� il pap�)
materiale sufficiente per fare qualcosa di creativo durante le prossime vacanze di Natale
Lista componenti:
- Arduino UNO R3
- N. 3 transistor BD 709 (quelli che avevo a disposizione)
- N.3 resistori da 220 Ohm
Striscia LED alimentata a 12V.
Si � utilizzato un alimentatore esterno a 12V per l’alimentazione della scheda e della striscia LED.
L’alimentazione a 12V della striscia LED � presa direttamente dalla Vin della scheda.
/* Pilotaggio striscia LED
Mattia Maffucci
...con lo zampino di suo pap� Michele
20.12.14
*/
// pin a cui � collegata la striscia LED
#define pinRosso 5
#define pinVerde 6
#define pinBlu 3
// velocit� tra un'intensit� luminosa e la successiva.
// Per rallentare il fade aumentare il valore
int velocitaFadeBianco = 60;
// velocit� tra un'intensit� luminosa e la successiva.
// Per rallentare il fade aumentare il valore
int velocitaFadeRosso = 60;
// velocit� tra un'intensit� luminosa e la successiva.
// Per rallentare il fade aumentare il valore
int velocitaFadeVerde = 60;
// velocit� tra un'intensit� luminosa e la successiva.
// Per rallentare il fade aumentare il valore
int velocitaFadeBlu = 60;
// velocit� tra un'intensit� luminosa e la successiva.
// Per rallentare il fade aumentare il valore
int velocitaFadeContinuo = 60;
// attesa prima della partenza della successiva accensione
int attesaFinaleBianco = 2000;
int attesaFinaleRosso = 2000;
int attesaFinaleVerde = 2000;
int attesaFinaleBlu = 2000;
int attesaFinaleContinuo = 2000;
// intensit� massima di bianco. Per
// rallentare il fade aumentare il valore
int limiteBianco = 30;
// intensit� massima di rosso. Per
// rallentare il fade aumentare il valore
int limiteRosso = 30;
// intensit� massima di verde. Per
// rallentare il fade aumentare il valore
int limiteVerde = 30;
// intensit� massima di blu. Per
// rallentare il fade aumentare il valore
int limiteBlu = 30;
// intensit� massima dei colori. Per
// rallentare il fade aumentare il valore
// massimo 255
int limiteContinuo = 100;
// per rallentare il fade aumentare il valore
int limiteFadeRandom = 120;
// numero massimo di colori scelto in
// maniera casuale
int randomColor = 5;
void setup() {
pinMode(pinRosso, OUTPUT);
pinMode(pinVerde, OUTPUT);
pinMode(pinBlu, OUTPUT);
}
void loop() {
// --- accensione solo bianco alla massima luminosit� ---
/*
analogWrite(pinRosso, 255);
analogWrite(pinRossoDue, 255);
analogWrite(pinVerde, 255);
analogWrite(pinVerdeDue, 255);
analogWrite(pinBlu, 255);
analogWrite(pinBluDue, 255);
*/
// ------------------------------------------------------
/*
// --- variazione luminosit� bianco ---
variazioneBianco();
// ------------------------------------------------------
*/
// --- casuale nella scelta del colore ---
casuale();
// ------------------------------------------------------
/*
// --- variazione continua colori incluso il bianco ---
variazioneContinua();
// ------------------------------------------------------
*/
}
// funzioni esterne per la variazione continua del colore
// -- casuale
void casuale() {
int sceltaSequenza=random(randomColor);
switch (sceltaSequenza) {
case 0:
variazioneBianco(limiteBianco, velocitaFadeBianco, attesaFinaleBianco);
break;
case 1:
variazioneRosso(limiteRosso, velocitaFadeRosso, attesaFinaleRosso);
break;
case 2:
variazioneVerde(limiteVerde, velocitaFadeVerde, attesaFinaleVerde);
break;
case 3:
variazioneBlu(limiteBlu, velocitaFadeBlu, attesaFinaleBlu);
break;
case 4:
variazioneContinua(limiteContinuo, velocitaFadeContinuo, attesaFinaleContinuo);
break;
default:
{
// nulla
}
}
}
// --- variazione contina del colore
void variazioneContinua(int limiteContinuo, int velocitaFadeContinuo, int attesaFinaleContinuo) {
int rosso, verde, blu;
// fade da blu a viola
for (rosso = 0; rosso < limiteContinuo; rosso++) { analogWrite(pinRosso, rosso); delay(velocitaFadeContinuo); } // fade da viola a rosso for (blu = limiteContinuo; blu > 0; blu--) {
analogWrite(pinBlu, blu);
delay(velocitaFadeContinuo);
}
// fade da rosso a giallo
for (verde = 0; verde < limiteContinuo; verde++) { analogWrite(pinVerde, verde); delay(velocitaFadeContinuo); } // fade da giallo a verde for (rosso = limiteContinuo; rosso > 0; rosso--) {
analogWrite(pinRosso, rosso);
delay(velocitaFadeContinuo);
}
// fade da verde a bianco
for (blu = 0; blu < limiteContinuo; blu++) { analogWrite(pinBlu, blu); delay(velocitaFadeContinuo); } // fade da bianco a blu for (verde = limiteContinuo; verde > 0; verde--) {
analogWrite(pinVerde, verde);
delay(velocitaFadeContinuo);
}
}
// --- variazione intensit� luminosa del bianco ---
void variazioneBianco(int limiteBianco, int velocitaFadeBianco, int attesaFinaleBianco) {
for (int fade = 0; fade < limiteBianco; fade++) { analogWrite(pinRosso, fade); analogWrite(pinVerde, fade); analogWrite(pinBlu, fade); delay(velocitaFadeBianco); } for (int fade = limiteRosso; fade >= 0; fade--) {
analogWrite(pinRosso, fade);
analogWrite(pinVerde, fade);
analogWrite(pinBlu, fade);
delay(velocitaFadeBianco);
delay(attesaFinaleBianco);
}
}
// --- variazione luminosit� del rosso
void variazioneRosso(int limiteRosso, int velocitaFadeRosso, int attesaFinaleRosso) {
analogWrite(pinVerde, 0);
analogWrite(pinBlu, 0);
for (int fade = 0; fade < limiteRosso; fade++) { analogWrite(pinRosso, fade); delay(velocitaFadeRosso); } for (int fade = limiteRosso; fade >= 0; fade--) {
analogWrite(pinRosso, fade);
delay(velocitaFadeRosso);
delay(attesaFinaleRosso);
}
}
// --- variazione luminosit� del verde
void variazioneVerde(int limiteVerde, int velocitaFadeVerde, int attesaFinaleVerde) {
analogWrite(pinRosso, 0);
analogWrite(pinBlu, 0);
for (int fade = 0; fade < limiteVerde; fade++) { analogWrite(pinVerde, fade); delay(velocitaFadeVerde); } for (int fade = limiteVerde; fade >= 0; fade--) {
analogWrite(pinVerde, fade);
delay(velocitaFadeVerde);
delay(attesaFinaleVerde);
}
}
// --- variazione luminosit� del blu
void variazioneBlu(int limiteBlu, int velocitaBlu, int attesaFinaleBlu) {
analogWrite(pinRosso, 0);
analogWrite(pinVerde, 0);
for (int fade = 0; fade < limiteBlu; fade++) { analogWrite(pinBlu, fade); delay(velocitaFadeBlu); } for (int fade = limiteBlu; fade >= 0; fade--) {
analogWrite(pinBlu, fade);
delay(velocitaFadeBlu);
delay(attesaFinaleBlu);
}
}
