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 dellinformatica
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 danimo estremamente controversi
sicuro che mi procurerò lira dei colleghi del liceo
ma poco importa.
Come genitore ci si interroga continuamente e si cercano strategie che possano favorire laccensione 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, luso 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 lora 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 lalbero 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 è lultima 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 allAlbero 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);
}
}
