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);
  }
}