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