Raspberry PI multifunzione

Come dicevo in questo post nelle prossime settimane io, Serena ed Emiliano saremo abbastanza impegnati: dovremo fare 7 lezioni di programmazione con Scratch a più di 300 bambini e ragazzi a Granarolo.

Saremo all'interno della scuola primaria e faremo ad ogni incontro due sessioni parallele, una nell'aula computer e l'altra in un'aula normale, quindi i bambini che non saranno in aula computer dovranno portare il proprio pc.
Prima di iniziare la lezione dovremo assicurarci che tutti abbiano installato Scratch e nel caso installarlo. A questo punto però si apre un tema legato alla sicurezza: potremmo mettere a disposizione di tutti delle chiavette, ma così facendo corriamo il rischio di far circolare dei virus se anche solo uno dei pc è infetto.

La soluzione che ho trovato a mio parere è molto carina, assolutamente sovradimensionata rispetto al problema, ma poi mi servirà anche per altre cose quindi ho approfittato per implementarla: un Raspberry PI configurato per fare da access point e da server web.
Lo so, sarebbe bastato fare dei cd o delle chiavette in sola lettura ma se mi fossi accontentato non avrei potuto documentare il fatto che "si può fare" :) e soprattutto che si può fare con software open source.

Ma procediamo con ordine.

Domanda 1: cos'è un Raspberry PI? è un computer molto piccolo e a basso costo, tutto condensato in un'unica schedina elettronica grande come un pacchetto di sfazzoletti, ma con prestazioni decenti. Ha un processore quad core da 1,2Ghz, 1Gb di RAM e un alloggiamento per metterci una microSD. Ha integrati Wi-Fi, Bluetooth e ethernet.

Non sto a dilungarmi troppo su dettagli tecnici, questo è il link al sito ufficiale per i curiosi.
Ci sono vari sistemi operativi che possono essere installati sul Raspberry, io ovviamente installo Raspbian, una derivata di Debian (una versione di Linux) fatta apposta per quella tipologia di computer.
Un'altra caratteristica molto importante è il fatto di poter aggiungere componenti elettronici (come led, sensori, motorini ecc) direttamente sulla scheda e programmarli a piacere. Cercando in giro per la rete si trovano un sacco di progetti didattici legati al Raspberry e molti negozi online vendono anche kit con dentro tutto il necessario per iniziare ad usarlo e fare esperimenti di elettronica. Consiglio vivamente di fare qualche ricerca, partendo proprio dal sito ufficiale.

Domanda 2: cos'è un access point? Un access point è un apparato che consente ad altri dispositivi di connettersi ad una rete tramite Wi-Fi.
Ormai tutti i router che vengono consegnati dai vari fornitori di connettività internet fanno anche da access point. In questo modo tutti i dispositivi di casa (telefoni, tablet, computer ecc..) possono connettersi ad internet tramite Wi-Fi.

Domanda 3: cos'è un web server? Contro domanda: avete mai visitato un sito web? Se state leggendo queste righe sicuramente sì. Un sito web è un insieme di pagine che non sono altro che files di testo salvati su un computer connesso in rete.
Un web server è un programma installato su questo computer che aspetta di essere contattato da altri dispositivi sulla rete. In quel momento fornisce loro le pagine del sito richieste. In pratica quando andate su un sito il browser del vostro pc chiede al server web che lo contiene di passargli la pagina che avete chiesto e poi ve la mostra.
In realtà il discorso è molto più complesso e articolato di così ma a me interessa spiegare a grandi linee a chi non è addetto ai lavori come funzionano queste cose, poi fornire link per approfondimenti ai più curiosi.

A questo punto il discorso si fa un po' più chiaro:

• installo Raspbian sul mio Raspberry
• lo configuro in modo da farlo diventare un access point
• installo un server web
• scarico dal sito di Scratch tutti i files necessari per installarlo sui pc
• creo una paginetta con i link per fare in modo che tutti prendano i files dal Raspberry

Nel prossimo post vedremo come fare tutto questo.

Continua a leggere...

Lezioni di programmazione con scratch a Granarolo

E passato più di un anno da dalla mia ultima lezione di programmazione ma non sono stato con le mani in mano: ho fatto una macchinina programmabile con Arduino e mi sono finalmente buttato sulla stampa 3d, ma questo discorso merita uno (o più) post a parte.
Serena invece si è data da fare parecchio sia al Fisiclab che al Centec, ma anche questo sarà argomento di post successivi.

Ma torniamo al presente.
Qualche tempo fa sono stato contattato di nuovo da Giuliana Bertagnoni, assessore alla cultura di Granarolo dell'Emilia, e da Lucia Mastroiacovo.
Con loro ho fatto due lezioni di programmazione con Scratch nella biblioteca di Granarolo.

L'idea iniziale era di non fare una lezione sola in biblioteca ma di fare qualcosa di più strutturato in modo da dare la possibilità a più ragazzi possibile di partecipare.

Dopo esserci confrontati abbiamo deciso di tentare un progetto ambizioso: fare una lezione di programmazione a tutti i bambini e ragazzi delle scuole primarie (dalla terza in su) e secondarie di Granarolo. In più chiedere al Liceo Copernico e al liceo Sabin qualche studente per affiancarci.

Abbiamo mandato la comunicazione a tutti i genitori degli alunni dell'istituto comprensivo per capire quanti erano interessati a questo progetto e la risposta è stata impressionante: 307 iscrizioni tra primaria e secondaria.

Alcuni studenti del Sabin e del Copernico parteciperanno e le loro ore saranno inserite all'interno del progetto scuola lavoro.

Adesso comincia la parte operativa: da sabato prossimo 4 febbraio io, Serena ed Emiliano faremo sette incontri con due lezioni parallele ognuno.

Come sempre i lavori che faremo verranno inseriti nella sezione documenti di questo sito in modo da dare la possibilità di scaricarlo sia a chi non è riuscito a terminarlo sia a tutti quelli che capitano qui e vogliono vedere, provare e modificare il nostro lavoro.

Come si dice di solito: hai voluto la bicicletta...

Continua a leggere...

Una macchina programmabile - prime prove

Eccoci al quarto post relativo al mio progetto con Arduino: una macchina programmabile.
Questi sono i link del primo, secondo e terzo post

Il telaio è pronto, la pulsantiera anche. Tutti i componenti sono montati.
Questo è il risultato finale:

Si può vedere anche il dettaglio della posizione della batteria da 9V.
In questa foto invece si vede come il led si incastri perfettamente all'interno del buco del Lego.

Ho fatto anche uno schema con Fritzing per far capire meglio come ho collegato il tutto. A questo però bisogna aggiungere lo schema della pulsantiera che ho inserito nel terzo post.

Questo è il programma che ho scritto:

/* Software per la macchina programmabile */
/* Simone Bacciglieri */

#include <Servo.h>

Servo servoleft;
Servo servoright;

//Array contenente tutte le istruzioni da eseguire.
//Nessuna istruzione = 0
//AVANTI = 1
//INDIETRO = 2
//DESTRA = 3
//SINISTRA = 4
int instructions[100];

int sLeft = 9;
int sRight = 8;

//Front left led
int flLed = 10;
//Front right led
int frLed = 11;
//Rear left led
int rlLed = 12;
//Rear right led
int rrLed = 13;

//Push button panel led
int bPanelLed = 7;

//Flag per sapere se sono in modalità inserimento comandi
int insertMode = 0;
//Posizione dell'ultima istruzione nell'array
int currentPosition = 0;

void setup() {
  Serial.begin(9600);

  pinMode(sLeft, OUTPUT);
  pinMode(sRight, OUTPUT);

  // Nei servo normali l'argomento del metodo write è la posizione angolare.
  // In quelli a rotazione continua invece
  // 0 vuol dire ruota avanti alla massima velocità
  // 180 vuol dire ruota indietro alla massima velocità
  // 90 vuol dire fermo
  servoleft.attach(sLeft);
  servoleft.write(90);
  servoright.attach(sRight);
  servoright.write(90);
 
  pinMode(flLed, OUTPUT);
  pinMode(frLed, OUTPUT);
  pinMode(rlLed, OUTPUT);
  pinMode(rrLed, OUTPUT);

  pinMode(bPanelLed, OUTPUT);

  //Abilito la resistenza interna di pullup sul pin A0
  pinMode(A0, INPUT_PULLUP);
  //Tutti i led spenti
  digitalWrite(flLed, LOW);
  digitalWrite(frLed, LOW);
  digitalWrite(rlLed, LOW); 
  digitalWrite(rrLed, LOW);

  digitalWrite(bPanelLed, LOW);
 
  Serial.println("Inizio");
}

void loop() {
  // Leggo il valore che mi arriva dalla pulsantiera
  int buttonsPanel = analogRead(A0);
  // Un po' di debug
  Serial.println(buttonsPanel);
  // Se il flag insertMode è a 0 eseguo immediatamente l'istruzione relativa al tasto premuto
  // Altrimenti la inserisco nell'array delle istruzioni
  switch (buttonsPanel) {
    case 15 ... 30:
      Serial.println("Bottone AVANTI premuto");
      delay(500);
      insertMode ? carSet(1) : fw();
      break;

    case 122 ... 142:
      Serial.println("Bottone INDIETRO spremuto");
      delay(500);
      insertMode ? carSet(2) : back();
      break;

    case 166 ... 175:
      Serial.println("Bottone SX spremuto");
      delay(500);
      insertMode ? carSet(4) : left();
      break;

    case 72 ... 82:
      Serial.println("Bottone DX spremuto");
      delay(500);
      insertMode ? carSet(3) : right();
      break;

    case 277 ... 284:
      Serial.println("Bottone STOP spremuto");
      delay(500);
      carStop();
      insertMode = 0;
      break;

    case 243 ... 251:
      //Hanno premuto SET quindi devo iniziare ad immagazzinare le istruzioni
      Serial.println("Bottone SET spremuto");
      delay(500);
      //Azzero l'array
      for (int i = 0; i < 100; i++) {
        instructions[i] = 0;
      }
      insertMode = 1;
      currentPosition = 0;
      break;

    case 207 ... 214:
      //Hanno premuto GO quindi devo eseguire tutte le istruzioni dell'array
      Serial.println("Bottone GO spremuto");
      delay(500);
      carGo();
      insertMode = 0;
      break;

    default:
      Serial.println("Nessun tasto spremuto");
      break;
  }
}

void ledBlink() {
  digitalWrite(bPanelLed,HIGH);
  delay(150);
  digitalWrite(bPanelLed,LOW);
  delay(150);
}

void fw() {
  Serial.println("Avanti");
  //Accendo i led anteriori e spengo quelli posteriori
  digitalWrite(flLed, HIGH);
  digitalWrite(frLed, HIGH);
  digitalWrite(rlLed, LOW);
  digitalWrite(rrLed, LOW);
  //I servo devono girare  in direzioni opposte per andare nello stesso verso
  //Sono montati in direzioni opposte
  servoleft.write(0);
  servoright.write(116);

  for(int i=0;i<8;i++) {
    ledBlink();
  }
  carStop();
}

void back() {
  Serial.println("Indietro");
 
  digitalWrite(flLed, LOW);
  digitalWrite(frLed, LOW);
  digitalWrite(rlLed, HIGH);
  digitalWrite(rrLed, HIGH);

  servoleft.write(180);
  servoright.write(60);

  for(int i=0;i<8;i++) {
    ledBlink();
  }
  carStop();
}

void left() {
  Serial.println("Sinistra");
 
  digitalWrite(flLed, HIGH);
  digitalWrite(frLed, LOW);
  digitalWrite(rlLed, HIGH);
  digitalWrite(rrLed, LOW);
  // Il servo sinistro è fermo mentre quello destro gira
  servoleft.write(90);
  servoright.write(180);

  for(int i=0;i<3;i++) {
    ledBlink();
  }
  carStop();
}

void right() {
  Serial.println("Destra");
  // Il servo sinistro gira mentre quello destro è fermo
  digitalWrite(flLed, LOW);
  digitalWrite(frLed, HIGH);
  digitalWrite(rlLed, LOW);
  digitalWrite(rrLed, HIGH);

  servoleft.write(0);
  servoright.write(90);

  for(int i=0;i<3;i++) {
    ledBlink();
  }
  carStop();
}

void carStop() {
  //Fermo la macchina e spengo tutto
  Serial.println("Ferma");
 
  digitalWrite(flLed, LOW);
  digitalWrite(frLed, LOW);
  digitalWrite(rlLed, LOW);
  digitalWrite(rrLed, LOW);

  servoleft.write(90);
  servoright.write(90);
}

void carGo() {
  Serial.println("Via");
  //Quando incontro il valore 0 vuol dire che sono finite le istruzioni
  for (int i = 0; i < 100; i++) {
   
    switch (instructions[i]) {
      case 0:
        //Fine istruzioni
        carStop();   
        break;
      case 1:
        //Avanti
        fw();
        break;
      case 2:
        //Indietro
        back();
        break;
      case 3:
        //Destra
        right();
        break;
      case 4:
        //Sinistra
        left();
        break;
    }
  }
}

void carSet(int instruction) {
  Serial.println("Set");
  // Inserisco nell'array l'istruzione relativa al pulsante premuto.
  // Se arrivo all'ultima istruzione segnalo facendo blinkare il led.
  if (currentPosition > 98) {
    Serial.println("Raggiunto il limite massimo di istruzioni");
    for(int i=0;i<14;i++) {
      ledBlink();
    }
  }
  instructions[currentPosition] = instruction;
  currentPosition++;
}


Ho iniziato a fare un po' di prove e ho notato subito un problema: i due servo motori non vanno alla stessa velocità. Ho provato a variare il parametro che passo alla funzione write ma, anche se la situazione è migliorata, non sono riuscito a farla andare perfettamente dritta.
Una volta risolto questo problema posso dire di aver raggiunto l'obiettivo che mi sono dato nel primo post e posso iniziare ad estendere il progetto: per prima cosa voglio mettere il sensore ad ultrasuoni perchè ho visto che i miei figli quando la usano la fanno sbattere da tutte le parti, quindi è bene che sappia fermarsi in tempo da sola. :)

Continua a leggere...

Una macchina programmabile - la pulsantiera

Questo è il terzo post che dedico al mio progettino: costruire una macchina programmabile utilizzando Arduino e Lego.
Nel primo post ho spiegato a grandi linee cosa volevo fare, mentre nel secondo ho iniziato ad elencare i componenti e ho descritto come voglio realizzare il telaio.

Adesso è ora di parlare della pulsantiera, forse la parte più difficile di questo progetto.
Come dicevo deve avere 7 pulsanti e un led e deve utilizzare meno pin possibile.

Cercando un po' in rete ho visto che si puo' utilizzare un solo pin analogico  dell'Arduino in modalità pull-up, collegando pulsanti e resistenze in modo che diventi un partitore resistivo.

Per maggiore chiarezza ho fatto lo schema con Fritzing, un programma open source per creare schemi elettronici.

Le resistenze sono collegate tra loro in serie e dopo ogni resitenza c'è il piedino di un pulsante: l'ultima resitenza è collegata a massa.
L'altro piedino di ogni pulsante è collegato al pin analog0 dell'Arduino configurato, come detto prima, in modalità pull-up. In questa configurazione il pin è connesso ai 5V dell'Arduino tramite una resistenza interna detta di pull-up.

Quando nessun pulsante è premuto il circuito è aperto e il pin analog0 segna i 5V a cui è attaccato; quando invece premiamo un pulsante il circuito si chiude ma prima di arrivare alla massa deve passare attraverso le resistenze successive al tasto premuto.
In questo modo abbiamo creato un partitore resistivo tra la resistenza di pull-up e tutte le altre in serie.

I pin analogici in realtà non sono analogici, ma restituiscono un valore tra 0 e 1024 a seconda della tensione in ingresso.

Quando abbiamo controllato i valori con Arduino ci siamo resi conto che non erano stabili quindi per ogni tasto abbiamo dovuto identificare un range di ingresso.
Questo è il codice utilizzato:

  int buttonsPanel = analogRead(A0);
  Serial.println(buttonsPanel);

  switch (buttonsPanel) {
    case 15 ... 30:
      Serial.println("Bottone AVANTI premuto");
      delay(500);
      break;

    case 122 ... 142:
      Serial.println("Bottone INDIETRO premuto");
      delay(500);
      break;

    case 166 ... 175:
      Serial.println("Bottone SX premuto");
      delay(500);
      break;

    case 72 ... 82:
      Serial.println("Bottone DX premuto");
      delay(500);
      break;

    case 277 ... 284:
      Serial.println("Bottone STOP premuto");
      delay(500);
      break;

    case 243 ... 251:
      Serial.println("Bottone SET premuto");
      delay(500);
      break;

    case 207 ... 214:
      Serial.println("Bottone GO premuto");
      delay(500);
      break;


Questo è il lavoro finito:

Il led al centro condivide solo la massa con il resto del circuito. L'altro piedino va direttamente ad un altro pin dell' Arduino e viene usato come di consueto.

Il telaio ha subito una modifica: non ha più due ruote davanti ma una sola girevole.

Per oggi è tutto, vediamo se riuscirò a farla funzionare :)

Continua a leggere...

Progetto per bambini con Arduino

Sono parecchi mesi che non scrivo più nulla su questo blog, soprattutto non scrivo più nulla sulle lezioni di programmazione per bambini. Questo perchè alcune cose sono cambiate e io e Serena stiamo cercando di capire come dare seguito a questa attività.

Durante questo periodo di "pausa", se così lo possiamo chiamare, mi sto cimentando in un progetto con Arduino.

Nulla di nuovo, ho visto in rete che varie persone hanno già fatto la stessa cosa, però volevo provare lo stesso.



Sto facendo una macchinina

programmabile, cioè una macchinina che prende in input una sequenza di comandi e poi li esegue una volta dato il via.
Il gioco da fare con i bambini a questo punto è creare un percorso e programmare la macchinina in modo che riesca a seguirlo tutto da sola.
A loro sembra un gioco ma in realtà questo serve per dargli le prime informazioni su come creare un programma, cos'è un'istruzione e cosa succede se si eseguono istruzioni sbagliate.
Inoltre imparano a pianificare le azioni che la macchina dovrà eseguire e prevederne gli errori.

Se viene bene può essere una bella idea utilizzarla anche durante le lezioni di programmazione.

Finita la premessa passiamo ai requisiti che mi sono dato:

• Deve essere il più possibile autocostruita. Non voglio comprare uno di quei kit completi che si trovano nei siti di elettronica.
• Deve essere indipendente (cioè deve andare a batterie, non voglio cavi di collegamento al pc)
• Non deve essere telecomandata: tutto risiede nella macchina e quando si avvia non deve esserci possibilità di cambiare i comandi
• Deve andare nelle quattro direzioni: avanti, indietro, destra e sinistra
• Deve accettare input sulle direzioni attraverso una pulsantiera
• Deve essere espandibile. Visto che sicuramente  mi verrà voglia di aggiungerci di tutto dovrò usare i pin dell' Arduino e la breadboard con parsimonia.
• Deve essere bella!

In questi post cercherò di documentare tutto quello che sto facendo, in modo da condividere con tutti la mia esperienza ma anche di dare la possibilità a chi ne sa più di me di dirmi cosa ho sbagliato o cosa posso migliorare.
Spero che questi ultimi commentino le mie pagine così anche gli altri potranno leggere quali sono stati i miei errori e non replicarli :)

Una macchina programmabile

Continua a leggere...

Una macchina programmabile

Come dicevo in questo post ho iniziato a costruire una macchina programmabile con Arduino.
I componenti che mi servono per realizzarla sono:

• un Arduino uno
• due led ad alta luminosità rossi
• due led ad alta luminosità blu
• un led verde
• cinque resistenze da 220 Ohm
• sei resistenze da 2200 Ohm
• due servomotori a rotazione continua
• una batteria da 9V
• una breadboard
• sette pulsanti
• cavi di collegamento per la breadboard

Il telaio ho pensato di costruirlo con i Lego Technics, visto che ne ho già in abbondanza.
Nella foto si può vedere la prima prova. I due servomotori sono già posizionati e hanno già le ruote fissate; sulla parte blu voglio metterci l'Arduino, sopra i servomotori metterò la breadboard e sulla parte anteriore metterò la pulsantiera.

I quattro led ad alta luminosità mi servono per i fari mentre quello verde mi serve per la pulsantiera. Darà un minimo di feedback durante l'immissione dei comandi.
I led dei fari si illumineranno a seconda della direzione.

La pulsantiera merita un discorso a parte: devo prevedere 4 pulsanti direzione più il pulsante per iniziare l'immissione dati (set), quello per far partire la macchina e il pulsante stop. Vorrei creare qualcosa di definitivo in modo da poterla riutilizzare anche in futuro senza ricominciare sempre tutto da capo.
In più vorrei che utilizzasse meno pin possibile, visto che voglio sette pulsanti non vorrei dover occupare sette pin dell'Arduino.

Se riesco a fare tutto vorrei aggiungere un sensore di prossimità ad ultrasuoni in modo che si fermi da sola se arriva troppo vicino ad un ostacolo.

Continua a leggere...

Weekend da registi

In casa siamo tutti amanti dei film in stopmotion, adoriamo Shaun the sheep, Timmy e amici. Dico adoriamo perchè anche gli "adulti" di Casa Bacciglieri sono in prima fila quando c'è a guardare quel genere di film.

Tempo fa feci un mini video con un paio di Lego utilizzando questa tecnica per far ridere i miei ragazzi ma dopo l'entusiasmo iniziale non hanno più fatto domande.
Ieri pomeriggio invece Matteo (7 anni) mi ha detto che gli sarebbe piaciuto fare un video con i Lego. Ho subito specificato che non è una cosa che si fa in 10 minuti, ma lui è rimasto della stessa idea: facciamo un film tutti insieme.
Non me lo sono fatto ripetere due volte. Ho preso il mio pc e una vecchia videocamera che ormai funziona solo se attaccata al computer (rovina tutti i nastri che le vengono inseriti e non ha più batteria); Matteo e Martina hanno creato la scenografia mettendo sul tavolo un tappeto con le strade disegnate e riempiendolo di Lego. Abbiamo aggiunto un po' di luci e ci siamo messi subito all'opera.
Siccome in casa Bacciglieri si usa quasi solo software libero nel mio pc è installato Linux come sistema operativo e per catturare le foto abbiamo usato stopmotion.

Abbiamo diviso il film in 3 parti: la prima parte dove io facevo il "tecnico" e loro pensavano a muovere i personaggi; la seconda ambientata nel castello dove Matteo ha fatto tutto da solo e la terza curata esclusivamente da Martina con le sue Lego Friends.
Alla fine dopo circa 3 ore di lavoro è venuto fuori un filmatino muto di un minuto e 30 secondi. Entrambi sono rimasti sbalorditi di quanto tempo ci voglia per creare un film del genere e, per capire meglio, abbiamo guardato un po' di backstage del film di Shawn the Sheep.

Il lavoro non è finito, adesso devono capire cosa vuol dire fare il montaggio, aggiungere l'audio e i titoli, ma sembrano motivati ad andare fino in fondo.
Per il montaggio useremo kdenlive, visto che Martina lo ha già utilizzato per un lavoro che ha dovuto fare per la scuola, mentre per l'audio registreremo le nostre voci con audacity (non oso pensare cosa ne uscirà :) ).

Qualsiasi cosa verrà fuori da questo esperimento per me è già stato un successone: i ragazzi hanno capito bene quanto lavoro si debba fare per far muovere i loro personaggi preferiti e, nondimeno, nel farlo si sono divertiti un sacco! Sono certo che da oggi apprezzeranno ancor di più i cartoni animati e di certo li guarderanno con occhi diversi.

Continua a leggere...

WEEKEND DELLA LUCE

Il 2015 è l'Anno Internazionale della Luce e non potevo non organizzare qualcosa!
Il caso ha voluto che per me sia stato veramente un anno dedicato alla luce! Se solo lo sapesse l'UNESCO...
Ho conosciuto un signore che ha dedicato la sua vita alla microscopia e ha fatto tra le tantissime cose dei bellissimi kit didattici per riprodurre i più famosi esperimenti sulla luce e ha deciso di darmeli in comodato d'uso.
Abbiamo passato intere giornate al laboratorio a guardare i kit da lui costruiti e a provarli perché poi io devo saperli usare e trattare con con cura. Forse qualcuno mi capisce quando dico che per me valgono più dell'oro, anche se sono fatti con materiali di recupero.
Il signore in questione ama descriversi come un pignolo e un bastian contrario, in realtà è davvero una gradevolissima compagnia e per me è diventato un punto di riferimento sia per il modo in cui lavora sia per certi aspetti dell'esistenza, ma soprattutto è diventato un amico.

Con queste premesse organizzare qualcosa sulla luce è diventato ancor più doveroso e stimolante, così è da un po' di tempo che penso a questo evento.
Il programma è densissimo: si comincia venerdì 9 ottobre alle 21 al planetario con la conferenza di Giuseppe Pupillo (proprietario dal planetario gonfiabile, nonché ricercatore radioastronomo) sulle radiazioni non ottiche provenienti dall'universo. Sabato 10 ottobre sarà la giornata più intensa: al FisicLab dalle 10 alle 22 faremo due percorsi paralleli con attività per i bambini e approfondimenti per gli adulti. Tra gli approfondimenti ce n'è uno anche sul risparmio energetico e l'illuminazione di casa tenuto dal comproprietario di questo blog che fa il timido...
Domenica mattina ci riposiamo perché al pomeriggio dalle 15:30 al planetario si riparte con un sacco di "Esperimenti luminosi" dedicati ai bambini e alle loro famiglie, dulcis in fundo alle 17:30 il Comandante Paolo Sini, pilota di aerei di linea, ci parlerà dei fenomeni ottici che ha visto e fotografato durante le sue ore di volo.

Insomma ci vediamo al laboratorio e al planetario, vi aspettiamo!

Continua a leggere...

Fisiclab e programmazione

Come preannunciato in questo post sabato 13 giugno abbiamo fatto l'ultima lezione della stagione al Fisiclab.
Eravamo in pochi ovviamente, come ho già detto in uno dei post precedenti ormai è arrivata l'estate e i ragazzi è giusto che stiano a giocare nei parchi o al mare. Abbiamo avuto però un ospite speciale: una delle speaker della redazione di San Giovanni di Radio Immaginaria, che qualche tempo fa, insieme ai suoi colleghi ci ha ospitati per un' intervista. Da quello che ho capito le è piaciuto molto, così come è piaciuto anche agli altri.
Alcuni erano "vecchie" conoscenze, altri nuovi. Un bimbo addirittura è stato avvistato anche il giorno dopo dai ragazzi di CoderDojo Bologna, quindi ha fatto un weekend intero di programmazione!
Ora è tempo di riposarsi anche se sicuramente io non lo farò: ho in mente un sacco di progetti e in questi 3 mesi sicuramente mi preparerò per ricominciare a settembre con moltissime novità.

Buone vacanze ragazzi!

Continua a leggere...

Ultima lezione di programmazione prima dell'estate

Ecco la locandina che pubblicizza l'ultima lezione che faremo io e Serena prima della pausa estiva.
Come sempre parleremo di programmazione, software libero e anche un po' di Fisica.
L'appuntamento è sabato 13 giugno 2015 presso il Fisiclab, in via Guardia Nazionale 15 a San Giovanni in Persiceto.
Vi aspettiamo!

Continua a leggere...