Cosa ci occorre

Per questa esperienza vogliamo realizzare un circuito con due bottoni che accendono e spengono un buzzer. Fate attenzione se il buzzer sia o no attivo perché cambia il codice che dobbiamo andare a realizzare. In alternativa al buzzer si può pensare ad un analogo attuatore quale un semplice led o un coppia di led di due colori verde/rosso ad esempio per indicare lo stato dei bottoni. Le resistenze applicate ai bottoni di solito sono molto alte, anche 10 K ohm.

La logica

Primo elemento che vediamo sempre nei nostri esercizi è la dichiarazione dei pin. Ci siamo abituati dalle prime esperienze magari a comprendere i due stati INPUT e OUTPUT ma ce n’è un terzo INPUT_PULLUP che intuitivamente si comporta come input ma aggiunge una resistenza standard interna del pin che agisce in modo un po’ controintuitivo: se il segnale è HIGH il circuito del bottone non è premuto e passa la corrente, viceversa premendo il bottone il circuito si apre e lo stato diventa LOW. Un po’ al contrario, in pratica.

Veniamo agli stati. Ci sono solo due situazioni accettabili: uno dei due bottoni è acceso e l’altro spento. Altri stati sono anomalie e non vanno considerati o se lo si desidera, vanno esplicitamente trovati modi di fornire un feedback di errore (seriale, led ecc).

Altre idee

I bottoni ci permettono di creare una infinità di applicazioni. Già semplicemente sostituendo l’attuatore possiamo fare esperienze diverse con led o servomotori. I bottoni possono essere semplicemente essere utilizzati per abilitare o meno un circuito più complesso accendendo e spegnendo una funzionalità.

I buzzer attivi sono molto interessanti per i più piccoli che possono esercitarsi a cambiare frequenza e realizzare musichette. Molte sono già in rete scritte da appassionati. Una sfida per i più piccoli potrebbe essere quella di realizzare una tastiera ad una ottava con otto bottoni, ognuno che emette una nota.

Listato completo

int BUZZER = 13;
int PULSANTESTART = 11;
int PULSANTESTOP = 10;
int start = 1;
int stop = 1;
int stato_start = 0;
int stato_stop = 0;

void setup()
{
  pinMode(PULSANTESTART, INPUT_PULLUP);
  pinMode(PULSANTESTOP, INPUT_PULLUP);  
  pinMode(BUZZER, OUTPUT);
  start = 0;
  stop = 0;
}

void controllaStato()
{
  if (start == HIGH && stop == LOW)
  {
  	stato_start = 0;
        stato_stop = 1;
  }  
  
  if (start == LOW && stop == HIGH)
  {
  	stato_start = 1;
        stato_stop = 0;  
  }  
}  

// se il buzzer è passivo
//void sistemaSpento(){digitalWrite(BUZZER, LOW); }
//void sistemaAcceso(){digitalWrite(BUZZER, HIGH ); }

// se il buzzer è attivo
void sistemaAcceso(){tone(BUZZER, 700);}
void sistemaSpento(){noTone(BUZZER); }

void loop()
{
  // legge il valore dell'input e lo conserva 
  start = digitalRead(PULSANTESTART);  
  stop = digitalRead(PULSANTESTOP);  
  controllaStato();
  if (stato_start == 0 && stato_stop == 1)
    sistemaSpento();
  
  if (stato_start == 1 && stato_stop == 0)
    sistemaAcceso();
     

}

Il file di progetto Fritzing

L'articolo Bottoni con antirimbalzo proviene da alfredocentinaro.it.

Introduzione

Vediamo una applicazione interessante che permette di parlare anche di due tecnologie per applicazioni smart magari meno note. La prime più semplice è il servo motore. Un servomotore è un particolare tipo di motore, generalmente di piccola potenza, che si differenzia dai motori tradizionali in quanto le sue condizioni operative sono soggette ad ampie e, spesso, repentine variazioni sia di velocità che coppia motrice, variazioni con picchi e sollecitazioni di potenza. Il servomotore si deve adattare a queste variazioni con la massima rapidità e precisione. Anche in condizioni di arresto, ai servomotori è richiesta precisione ed affidabilità nel mantenere la posizione raggiunta, anche sotto sforzo.

Nei nostri applicativi da maker sono motori elettrici, ma possono essere anche pneumatici ed idraulici in complesse applicazioni industriali. Caratteristiche viste rendono questi motori ottimi nei controlli di posizione, nelle macchine a controllo numerico, nei sistemi automatici di regolazione e nelle periferiche di sistema, come stampanti e plotter.

La simulazione

Lo RFID è invece una tecnologia wireless, già affrontata in queste pagine (link).

L’esperienza che facciamo va ad utilizzare un lettore RFID che nasce più come elemento Smart che per essere collegato ad una MCU simil Arduino. L’idea è quella di collegare il sistema RFID ad un server di registrazione o un home gateway che, magari, mostreremo in altra esercitazione. Ecco perché ci occorrono un paio di passaggi per rendere questo lettore adatto ai nostri scopi. Analoghi passaggi possono essere replicati per tanti altri oggetti IoT simili.

Per prima cosa quindi dobbiamo modificare il codice che gestisce il lettore RFID. Doppio click sul lettore RFID, quindi tasto Advanced in basso a destra, tab Programming, ancora click sul progetto RFID in Java Script, quindi doppio click sul main.js. Ci possiamo posizionare alla riga 63 mandando in basso il codice che rimane della funzione principale. L’idea è quello di inserire un codice che forzi il nostro lettore ad attivarsi con luce verde a fronte di un codice rfid prefissato e rifiuti gli altri segnalando in rosso l’errore, mentre se non ci sono rfid nelle vicinanze con un qualsiasi codice rimanga in attesa con lo status dei led verde/rosso entrambi spenti.

Invece nel tab I/O Config, dobbiamo aumentare il numero di interfacce analogiche e portiamo quindi a 2 la voce Analog Slots. Questo ci crearà la porta A0 e A1 usata poi nel codice di default. Dobbiamo collegare la porta A1 del lettore alla porta A1 di Arduino, almeno per rispettare  il codice predefinito.

 Il frammento di codice da inserire alla fine della funzione loop sul lettore RFID:

	/*
		Codice per simulare il riconoscimento di una rfid con id 1001
	*/
	if (cardID == 1001)
	{
		state = 0;
	}
	
	if (cardID > 0 && cardID != 1001)
	{
		state = 1;
	}

	setState(state);
	analogWrite(A1, state);	
	sendReport();
	/*
		FINE Codice per simulare il riconoscimento di una rfid con id 1001
	*/	

Non ci resta che provare il codice scritto e verificare con due RFID il comportamento. Per modifica il codice RFID, cliccare sul nostro RFID blu, tab Attributes, CardID in fondo. Di default, in genere, è sempre 1001 e possiamo lasciarne uno così, l’altro modificarlo a piacere, ad esempio 2000 come in foto.

Ok, il nostro RFID adesso deve essere interfacciato con Arduino per fornirgli l’esito del login con RFID. In questo caso il codice da mandare ad arduino non è un semplice vero/falso o 1/0. Se analizziamo la documentazione o il codice js del lettore, vediamo che manda il codice.

Il codice per muovere il servo è semplice. Basta usar la funzione customWrite passandogli il pin digitale a cui è collegato il servo, 0 per noi, e l’angolo di movimento espresso in gradi, positivo o negativo a secondo che un oggetto collegato, ad esempio una porta o un braccio robotico, si sposti e torni nella posizione di sicurezza.

Il codice completo

Il codice da scrivere sulla basetta Arduino MCU

var pin = 0;
function setup() 
{
	pinMode(pin, OUTPUT);
	pinMode(A1, INPUT);
	Serial.println("Servo");
}

var angolo;
var rfid;

function loop() 
{
	rfid = analogRead(A1);
	Serial.println(rfid);
	if (rfid === 0)
	{
		customWrite(pin,40);
		delay(1000);
				
	}
	else
	{
		customWrite(pin,-40);
	}
	delay(2000);
}

L'articolo IoT: Servo motore su Arduino attivato con RFID proviene da alfredocentinaro.it.

Per questo esperimento non ci occorre particolare materiale da maker. Ci affidiamo all’ottimo kit all-in-one Arduino Explore IoT Kit, realizzato da Arduino e distribuito da Campustore, il noto negozio online fornitissimo per quanto concerne la didattica STEAM. Lo trovate qui.  Il pezzo forte del kit è lo shield dotato di diversi sensori, batteria di alimentazione e dei versatilissimi led. Come nell’intro di questo articolo, vogliamo creare un piccolo web server sul nostro Arduino MKR 1010, una versione molto sofisticata di ESP32, già trattato sulle pagine di questo sito. Il kit ha a disposizione un account sul cloud di Arduino ma per questo esperimento evitiamo di utilizzarlo e ricorriamo al buon vecchio fidato IDE offline. Mentre scriviamo siamo alla versione 1.8.12 (scarica qui) sperimentata su Linux Ubuntu 20.

Procuriamoci però tutte le librerie necessarie alla nostra applicazione. Assicuriamoci di andare nella voce di menù [Strumenti]->[Gestione Librerie]. Nella voce di ricerca, cerchiamo ed installiamo Wifinina, SD, MCHPTouch, MKRIoTCarrier. Le due librerie SD ed MCHPTouch, in realtà, non ci servono esattamente per questa lezione. Servono più che altro a consentire la compilazione del codice sorgente.

Il codice completo lo trovate qui ed in allegato.

#include <SPI.h>
#include <WiFiNINA.h>

#include <Arduino_MCHPTouch.h>
#include <Arduino_MKRIoTCarrier.h>

char ssid[] = "********";   // SSID della tua rete WiFi domestica
char pass[] = "********";   // la password del tuo  WiFi

int status = WL_IDLE_STATUS;

MKRIoTCarrier carrier;
WiFiClient client;
WiFiServer server(80);


//Colori
uint32_t colorRed = carrier.leds.Color(0, 255, 0);   //RED
uint32_t colorGreen = carrier.leds.Color(255, 0, 0);  //GREEN
uint32_t colorBlue = carrier.leds.Color(0, 0, 255);  //BLUE

void setup() {

  status = WiFi.begin(ssid, pass);
  if ( status != WL_CONNECTED) 
  {
    Serial.println("Errore nella connessione WiFi");
    while(true);
  }
  else 
  {
    Serial.println("Connesso al wifi");
  }
  
  IPAddress ip(192, 168, 1, 200); 
  IPAddress gateway(192, 168, 1, 1); 
  IPAddress subnet(255, 255, 255, 0); 
  
  WiFi.config(ip, gateway, subnet);

  carrier.begin();
  server.begin();
}

void loop() {
  String req;
  //Serial.println("Server online");

  //gestiamo le azione passate col GET nell'url
  WiFiClient client = server.available();
  if (client.connected() && client.available()) 
  {
      // creo una pagina standard
      client.println("HTTP/1.1 200 OK");
      client.println("Content-Type: text/html");
      client.println("Connection: close");  // the connection will be closed after completion of the response
      client.println("Refresh: 5");  // refresh the page automatically every 5 sec
      client.println();
      client.println("<!DOCTYPE HTML>");
      client.println("<html>");
      client.println("<head>");
      client.println("<style>");
      client.println(".button {");
      client.println(" background-color: #4CAF50;");
      client.println(" border: none;");
      client.println(" color: white;");
      client.println(" padding: 15px 32px;");
      client.println(" text-align: center;");
      client.println(" text-decoration: none;");
      client.println(" display: inline-block;");
      client.println(" font-size: 16px;");
      client.println(" margin: 4px 2px;");
      client.println("  cursor: pointer;");
      client.println("  width: 10em;");
      client.println("}");
      client.println(".button1 {background-color: green;} ");
      client.println(".button2 {background-color: red;} ");     
      client.println("</style>   ");
      client.println("</head>  ");
      client.println("<body>  ");
      client.println("<h1>WiFi Server con Arduino MKR 1010 e MKR IoT Carrier</h1>");
      client.println("<h3>#arduinoexploreiotkit #arduinoeducation #campustore</h3>");
      client.println("<button class=\"button button1\" onclick=\"location.href='/ledon';\" >Accendi</button><br>");
      client.println("<button class=\"button button2\" onclick=\"location.href='/ledoff';\" >Spegni</button>");
      client.println("</body>  ");
      client.println("</html>");


      req = client.readStringUntil('\r');  //torna nella forma "GET /ledon http 1.1"
  
      if (req.indexOf("/ledoff") != -1) 
      {
        Serial.println("Spegni");
        carrier.leds.setPixelColor(0, 0);
        carrier.leds.show();   
      } 
      
      if (req.indexOf("/ledon") != -1) 
      {
        Serial.println("Accendi");
        carrier.leds.setPixelColor(0, colorRed);
        carrier.leds.show();    
      }           
    }


    delay(200);

    client.stop();
    //Serial.println("client disconnesso");

}

L'articolo Pilotare un led con Arduino MKR 1010 su IoT Carrier via pagina web proviene da alfredocentinaro.it.

Nelle pagine di questo sito ci sono numerose esercitazioni con l’Home Gatway e la possibilità di collegare dei componenti smart da programmare con la classica interfaccia se/azione. Ma il simulatore va anche oltre con la possibilità di creare piccoli esperimenti utilizzando i simulatori di arduino e raspberry per interagire con sensoristica varia. Quello che non abbiamo contemplato è come invece integrare dispositivi non smart con alexa, creando una interfaccia su arduino che permetta quindi di esporre le funzionalità di questi componenti. 

Procediamo a realizzare la nostra simulazione piazzando gli elementi di interesse. Per l’ Home Gateway si trova in [Network Devices]-> [Wireless Device]mentre per il tablet o un qualsiasi analogo dispositivo come uno smartphone [End Devices] ->[End Devices]. Il nostro simulatore di Arduino si trova in [Components] ed è la basetta con nome MCU Board mentre il led lo trovate sempre in [Components] -> [Actuators]

Cominciamo con la configurazione. Il nostro Home Gateway, rinominato per simpatia con Alexa e il tablet non hanno particolari difficoltà. Possiamo inserire una configurazione semplice inserendo SSID e password WPA2 – PSK a piacere e AES Encryption per far sincronizzare i due dispositivi. Questa configurazione è ampiamente trattata nelle pagine di questo sito. Per collegare Arduino ad Alexa dobbiamo dotarlo di una scheda di rete. In genere, Arduino rev3 infatti non ha scheda di rete se non nelle versioni Yun e altre più specifiche. Per la nostra simulazione, spegniamo il dispositivo col bottoncino ed inseriamo una scheda CGE o 1W.

Di default, Alexa elargisce DHCP così l’unico flag da inserire è solo questo se non ci sono particolari esigenze specifiche. Ricordiamoci però di contrassegnare il nostro MCU Arduino come elemento smart per farlo rilevare all’home gateway.

Per quanto riguarda il collegamento tra Arduino e e il LED, dobbiamo andare nella sezione dei cavi col fulmine e andare a cercare sulla destra il cavo custom IoT, che corrisponde ad un cavo dupont del mondo reale senza tener conto di plug maschio/femmina o +/- che preferiate.

 Ultimate le configurazioni per connettere, possiamo passare al codice per esporre il nostro led. Clicchiamo sulla MCU e andiamo nel tab Programming. Qui ci si apre una schermata divisa in due: i progetti che abbiamo salvato sul lato sinistro e una schermata bianca a destra. Qui possiamo crearci il nostro progetto con un nome a piacere cliccando il bottone New.  Scegliamo nome e nella finestrella Template scegliamo il codice Empty – JavaScript.  Scorrendo la tendina possiamo notare che esistono altri frammenti di codice/progetti preconfezionati che possiamo usare per sbirciare nuove funzionalità o idee per altri nostre simulazioni. Cliccando Create, ci riappare una finestra del tutto analoga ma a destra compare il nostro ide di sviluppo per scrivere il codice e a sinistra i file che possiamo aggiungere al nostro progetto. Nel nostro caso ci serve solo il file main.js già presente che sarà quello utilizzato per il programma principale. Vediamo il codice.

Come per gli sketch, i programmi di Arduino, anche qui il nostro simulatore in js richiede due funzioni principali; una di setup per impostare tutto quello che c’è di configurare una tantum e una i loop che esegue la logica principale ad oltranza. La parte di setup comprende l’inizializzazione del pin digitale a cui è collegato il led, che va configurato come OUTPUT, un semplice messaggio all’interfaccia seriale per le classiche operazioni di debug e, finalmente, la nostra API per esporre il led. Le funzioni da utilizzare, e tutte le funzioni in generale, le trovate comodamente nel comodissimo Help in alto a destra, con le funzioni base e quelle IoE, che in realtà sono davvero poche e semplici, corredate di esempi oche può essere copiato e modificato su misura. Seguendo la sintassi dell’esempio è facile costruire la struttura dati per il led che ha solo due stati acceso/spento, traducibile con una variabile booleana e la possibilità di essere controllato, ovvero acceso e spento, dall’Home Gateway.

function setup() 
{
	pinMode(0, OUTPUT);
	Serial.println("Accenditi");
	
	IoEClient.setup({
		type: "Led",
	 	states: [{
			name: "Acceso",
			type: "bool",
			controllable: true
		}]
	});
}

Il loop deve contenere due cose:

– una funzione che rapporta lo status del led, se cceso o spendo all’Home Gateway

– una funzione che recepisce l’evento sul bottone di controllo e di conseguenza agisce sullo stato fisico del led

Anche qui, dall’Help possiamo trovare un esempio preconfezionato che ci mostra l’utilizzo semplice delle due funzioni che ci occorrono. La onInputReceive è forse un po’ più complessa comportandosi un po’ come una funzione JQuery. Basti sapere per l’utente meno esperto che input sarà la variabile di buffer dove l’Home Gateway inserisce il valore del bottone vero/falso. A noi non resta che una semplice if per intercettare tale valore e accendere /spegnere il led

function loop() 
{
	IoEClient.reportStates(stato);
	IoEClient.onInputReceive = function(input) {
		Serial.println(input);
		if (input == 1)
			digitalWrite(0, HIGH);
		else 
			digitalWrite(0, LOW);
		stato = input;
	};
}

Qui la funzione è semplice, il bottone è singolo. L’alunno più smart potrebbe  personalizzare questo esercizio aggiungendo uno o più bottoni che vanno ad eseguire sul led dei programmi con accensioni diverse del led, con temporizzazioni simili alle decorazioni di natale.

Il codice completo:

var stato = 0;
function setup() 
{
	pinMode(0, OUTPUT);
	Serial.println("Accenditi");
	
	IoEClient.setup({
		type: "Led",
	 	states: [{
			name: "Acceso",
			type: "bool",
			controllable: true
		}]
		
	});
}

function loop() 
{
	IoEClient.reportStates(stato);
	IoEClient.onInputReceive = function(input) {
		Serial.println(input);
		if (input == 1)
			digitalWrite(0, HIGH);
		else 
			digitalWrite(0, LOW);
		stato = input;
	};
}

L'articolo IoT: esporre una componente non smart attraverso Arduino ad Alexa con JavaScript proviene da alfredocentinaro.it.

L’idea è quella di usare il nostro ESP8266 come lettore di sensori. Ovviamente l’esempio è puramente didattico e generico, ma con poco sforzo può essere replicato per altri sensori.

Cosa ci occorre

• una basetta ESP8266
• un cavetto micro-usb
• un sensore di umidità FC-28
• due cavetti dupont femmina-maschio (colore a piacere) per collegare da sonda a sensore
• quattro cavetti dupont femmina-maschio per collegare da sensore a ESP8266
• software Arduino (scarica qui la versione del nostro test 1.8.12)

Prepariamo l’IDE

Prepariamo prima l’ambiente di sviluppo ovvero il nostro IDE Arduino per riconoscere la scheda. Se non lo abbiamo fatto in altre esercitazioni, ci occorre aggiungere al nostro IDE la il software della scheda. Andiamo in File->Impostazioni->URL Aggiuntive per il gestore Schede e incolliamoci questo URL ufficiale e sempre aggiornato:

https://arduino.esp8266.com/stable/package_esp8266com_index.json

Selezioniamo la porta. Su linux la porta di default è la /dev/ttyUSB0. Su Windows, a second della versione che usate, potrebbe essere una tra le COM1, COM2 o la più probabile COM3. Selezionatela nella voce di menù Strumenti->Porta avendo cura di provare anche le altre se lo sketch desse errore in fasi di upload. In genere, su Windows, la porta viene riconosciuta automaticamente o compare una voce di fianco nella tendina che indica il nome del dispositivo.

Selezioniamo il dispositivo, ovvero scheda, corretto. Qui ci sono due possibilità: o usiamo la versione ESP8266 nuda e creda che fa uso di una architettura GPIO per la numerazione dei pin oppure ricorriamo ad una semplificazione con scheda NodeMCU 1.0 (ESP12E-Module) che nomina i pin con le lettere che sono stampate direttamente sulla basetta. Lasciamo ad altri post la spiegazione, vantaggi e svantaggi dei due approcci.

Per la nostra esperienza ci basta configurare al meglio il tutto in modo semplice. Usate la voce di menù sull’IDE Strumenti->Scheda e cercate nella tendina la voce indicata NodeMCU 1.0 (ESP12E-Module). Notiamo che alcune librererie aggiuntive sono spesso scritte per ragionare con la scheda ESP8266, altre volte con la NodeMCU: il discrimine si evidenzia in fase di compilazione poiché avremo un errore sul nome utilizzato per pilotare i pin. Se tra le schede non compare il nome indicato, niente paura, dobbiamo aggiungerlo da libreria. Andate quindi  Strumenti->Scheda->Gestore Schede e nella finestrella in alto a destra cercate ESP8266, vi comparirà un risultato ESP8266 by ESP8266 Community che, mentre scriviamo, è arrivata alla versione 2.6.3.

In Strumenti->Gestione librerie assicuriamoci che sia installata la libreria che ci fornisce funzioni e strumenti vari per gestire le connessioni senza fili. Scorrete la lista fino a trovare WiFi built-in Arduino, giunto alla versione 1.2.7. Stessa cosa, cercate ed installate Arduino Uno WiFi Dev ed by Arduino.

Assemblaggio

L’assemblaggio è molto semplice, non richiede particolari abilità manuali o in campo elettronico. La maggior parte dei sensori in commercio hanno quattro pin: due son oda collegare all’alimentazione VCC 3.3 ed uno al G/GND per l’alimentazione. I dati possono poi essere mandati in formato analogico mentre il pin digitale serve semplicemente a rilevare se la misurazione è o no al di sopra del valore di “threshold”, il valore limite di soglia che può essere regolato con il potenziometro, ovvero la vitarella sul sensore. Dati dei sensori è sempre bene acquisirli in modo analogico, quindi assicuriamoci di collegare il pin A0 sul sensore al pin A0 o simile sul nostro ESP8266. Collegarne tre o quattro, sia lettura analogica che digitale, non pregiudica la misurazione.

Il codice

Il codice per la gestione del sensore è piuttosto banale. Eseguiamo una lettura analogica con la funzione standard dedicata. Il valore senza umidità tornato è 1024,00, mentre mano a mano che si inumidisce la sonda, ad esempio con una spugna o immergendo in un terriccio umido, il valore letto diminuisce. Le letture possono quindi essere ripetute periodicamente scegliendo un intervallo di ritardo. Stampiamo sull’interfaccia seriale il valore letto. Manteniamo semplice il nostro esercizio con un solo sensore, ma facciamo mente locale alle potenzialità degli 8 pin digitali e 1 analogico. L’analogico è dotato di un convertitore ADC a 10bit con valori a decimali a due cifre e parte intera compresa tra 0 e 1023 che può essere multiplexato per ricevere segnali da svariati sensori (ne accendo/invio uno alla volta, per capirci)

float value = 0;

void setup() {
pinMode(A0, INPUT); 

Serial.begin(9600);
}

void loop() {
value = analogRead(A0);
Serial.print("Umidità rilevata= ");
Serial.println(value);  
delay(5000); //ogni 5 secondi fai una misurazione
}

Le funzionalità di rete

Siamo pronti ora a vedere come scrivere questi dati catturati su un database. ESP8266 non scrive pagine PHP, ma può sempre collegarsi ad una pagina PHP esistente su qualche dominio esterno e mandargli dei dati col GET nell’URL o POST. I dati possono essere sotto forma di semplici parametri, o addirittura stringhe JSON, molto utili se alla ESP ci fossero collegati sensori multipli.

Sensore -> ESP8266 -> Access Point/Router -> Sito in Hosting con Apache -> pagina  in PHP raccogli dati GET/POST -> Database MySQL -> esposizione dati JSON con PHP

Per questo esercizio predispongo gli script PHP e il database qui sul dominio che ospita questo sito web. Potete trovare in rete numerosi servizi gratuiti che mettono a disposizione un server Apache con PHP e un db MySQL. Su quest’ultimo creiamo una tabella dove andremo a raccogliere i dati del sensore. La struttura, al momento semplice e autodescrittiva, potrebbe essere simile a questa:

CREATE TABLE IF NOT EXISTS `Sensore` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `nome` varchar(60) NOT NULL,
  `valore` float NOT NULL,
  `lettura` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Nel campo nome inseriremo un identificativo del sensore, il valore che ha inviato ed in automatico stacchiamo un valore progressivo come chiave della tabella e la data/ora automatica in cui è stato inserito il record.

Occupiamoci ora del nostro codice sulla basetta ESP8266. Creiamo un nuovo scketch nel nostro Arduino IDE. Ci servono prima un po’ di librerie e qui andiamo ad utilizzare quelle standard ESP8266 con i primi include. Come in tutte le esperienze  con funzionalità di rete/WiFi, ci andiamo ad impostare due stringhe con SSID e password del nostro Access Point o modem di casa. Ci serviranno poi una variabile reale per gestire i valori del sensore e una variabile stringa dove possiamo inserire un nome identificativo del sensore.

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>

float value = 0;

String ssid     = "SSIDdellaTUArete";
String password = "PASSWORDdellaTUArete";
String nomesensore = "FC28"; 

Il secondo frammento è quello del setup dove andiamo a predisporre il sensore e il suo pin seria, la console seriale per la stampa dei messaggi di debug (che vi ricordo si apre col menu Strumenti->Monitor seriale e si imposta la medesima velocità/banda in fondo del valore del codice qui sotto). Segue quindi la connessione effettiva alla rete Wi-Fi con tanto di configurazione/IP fisso. Se usate il DHCP, potete eliminare o commentare le righe IPAddress* e WiFi.config.

void setup() 
{
  //GESTIONE PIN
  pinMode(A0, INPUT); 

  //GESTIONE MONITOR SERIALE
  Serial.begin(115200);

  //GESTIONE WI-FI
  IPAddress ip(192, 168, 1, 108); 
  IPAddress gateway(192, 168, 1, 1); 
  IPAddress subnet(255, 255, 255, 0); 
  WiFi.config(ip, gateway, subnet);

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println("Sei collegato alla rete LAN");
  Serial.println(WiFi.localIP());
}

Non ci rimane che creare il nostro codice principale che a loop leggerà il sensore e predisporrà un URL per raggiungere una pagina PHP e consegnargli quindi i dati letti. Nel nostro caso la pagina si trova su questo dominio e la chiameremo soilmoisture.php. Inserite l’url del dominio che ospita il file. Il codice per inviare l’URL è piuttosto semplici ed intuitivo, utilizzando le funzioni messeci a disposizione dalle librerie. Ci colleghiamo ad una pagina, gli inviamo un header che sia un GET, un POST o JSON, qui un POST da form simulato e quindi  si preparano i dati da inviare come un URL con GET

  HTTPClient http;
  http.begin("https://www.unsito.it/soilmoisture.php"); //l'URL HTTP a cui ci collegheremo
  http.addHeader("Content-Type", "application/x-www-form-urlencoded"); 
  String httpPost = "sensore=" + nomesensore
                  + "&valore=" + String(value)

 Inviare i dati appena costruiti allo script è semplicissimo e la stessa chiamata restituisce una risposta con il classico valore 200 se positivo, o uno della serie 300, 400, 500 per errori vari  o -1 se la connessione non si innesca.

  int httpResponse = http.POST(httpPost);

La risposta e il payload può essere usata per debug. Sicuramente se httpResponse dovesse essere -1, allora ci troviamo davanti ad un bel problema che la nostra basetta non raggiunge la pagina per problemi di rete o un link sballalo.

Il codice completo:

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>

float value = 0;

String ssid     = "SSIDdellaTUArete";
String password = "PASSWORDdellaTUArete";
String nomesensore = "FC28"; 

void setup() 
{
  //GESTIONE PIN
  pinMode(A0, INPUT); 

  //GESTIONE MONITOR SERIALE
  Serial.begin(115200);

  //GESTIONE WI-FI
  IPAddress ip(192, 168, 1, 108); 
  IPAddress gateway(192, 168, 1, 1); 
  IPAddress subnet(255, 255, 255, 0); 
  WiFi.config(ip, gateway, subnet);

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println("Sei collegato alla rete LAN");
  Serial.println(WiFi.localIP());
}

void loop() 
{
  //LETTURA SENSORE
  value = analogRead(A0);
  Serial.print("Umidità rilevata= ");
  Serial.println(value);  

  //PREPRAZIONE URL
  HTTPClient http;
  
  //l'URL HTTP a cui ci collegheremo
  http.begin("https://www.unsito.it/soilmoisture.php"); 
  http.addHeader("Content-Type", "application/x-www-form-urlencoded"); 
    
  //Aggiungo le variabili da passare col POST
  String httpPost = "sensore=" + nomesensore
               + "&valore=" + String(value)
               +"";
  Serial.print("HTTP Post: ");
  Serial.println(httpPost);
  

  // Invia richiesta HTTP POST
  int httpResponse = http.POST(httpPost);

  //Feedback del server per debug
  String payload = http.getString();  
  Serial.print("Risposta Server: ");
  Serial.println(httpResponse);
  Serial.print("Payload: ");
  Serial.println(payload);  

  delay(1000 * 60); //ogni minuto fai una misurazione
}

La pagina PHP

Lo script PHP in realtà non ha nulla di particolare per il lettore appassionato di queste pagine. Si tratta di uno script che riceve i dati $_POST e li elabora per inserirli con una query su db. Vediamo qui sotto un esempio. Il file config.php contiene le variabili da inizializzare e passare al db per la connessione.

<?php
require_once("config.php");

if (isset($_POST['sensore']) && isset($_POST['valore']))
{
	$sensore     = $_POST['sensore'];
	$valore      = $_POST['valore']; 
	$connessione = mysqli_connect($mysql_host,$mysql_user,$mysql_pass,$mysql_db);
	if (mysqli_connect_errno())
	die("Connessione non riuscita: " . mysqli_error($connessione));
  
  	$query = "INSERT INTO Sensore (id, nome, valore, lettura) VALUES (null, $sensore, $valore,CURRENT_TIMESTAMP)";
	$res = mysqli_query($connessione,$query) or die("Errore nella query: " . mysqli_error($connessione));
	mysqli_close($connessione); 

}
else
	echo "Script invocato senza parametri POST";

?>

Come migliorare il nostro applicativo

• Scritti i dati su un database, il lettore può graficarli con la più classica delle pagine PHP/HTML/CSS, oppure semplicemente esporli in formato JSON per renderli disponibili per altri applicativi web o app mobile.
• Un dettaglio di cui non abbiamo tenuto conto in questa guida è l’uso del protocollo HTTPS basato su TLS. Questa considerazione ci obbliga a modificare il codice per aggiungere un certificato una impronta del sito a cui ci colleghiamo per permettere alla basetta di creare una connessione sicura.
• Abbiamo scartato l’invio dei dati col GET ma applicazione più interessante potrebbe essere quella di mandare alla pagina PHP i dati sono forma di JSON, decisamente utile nel caso si debbano inviare oggetti complessi e multipli e soprattutto se dobbiamo inviare dati a sistemi strutturati di cui abbiamo delle specifiche API in tal senso.

L'articolo Inviare dati da un sensore di umidità del suolo ad un db con ESP8266 proviene da alfredocentinaro.it.

Requisiti

Non occorrono particolari requisiti, se non rudimenti di coding o Scratch, un po’ di manualità e praticità che ci servirà per assemblare dei semplici circuiti di esempio.

Preparazione Software

– Scaricare ed installare Arduino IDE. Mentre scriviamo, il software ha raggiunto la versione 1.8.10 ed è disponibile per i sistemi operativi Windows, Linux, Linux ARM, Mac OS X ed una versione online via browser. Il link di riferimento è qui

– Scaricare ed installare Snap4Arduino. Giunto alla versione 5.1.0, decisamente matura, è il nostro IDE simile a Scratch che ci permetterà di pilotare il nostro Arduino in modo “grafico”. E’ disponibile per Window, Linux, Mac OS e una versione per il browser Chrome/Chromium come estensione, molto comoda. Esiste una alternativa molto promettente che si chiama Mind+ come editor offline di Scratch e annessi ma non è ancora supportato su piattaforme Mac e Linux. Lo trovate qui.

 I test e le immagini di questo articolo sono condotti su Linux Ubuntu 19.04,

Preparazione Hardware

 – Dotiamoci di una basetta Arduino. In commercio ne esistono di diverse tipologie e versioni. Quelle Arduino Originali le potete acquistare dal sito ufficiale qui. Prezzi modici e prestazioni assolutamente certificate, con cura dei particolari come la basetta in plastica che isola il wafer di silicio verde. Per questo laboratorio, ci basta Arduino Uno (Rev. 3). Essendo le specifiche di Arduino open, esistono versioni compatibili perfettamente funzionanti ed adeguate anche alle nostre esigenze didattiche. In questo esempio usiamo una versione Arduino Leonardo compatibile, stesso chip, stesse risorse hardware ma ad un costo leggermente inferiore. Alcune marche compatibili, però spesso hanno costi talmente ridotti da avere anche hardware non all’altezza, ad esempio con i pin non ben isolati. Quindi occhio a quello che acquistate: l’originale sta intorno ai 20 euro, le compatibili possono costare anche una manciata di euro attualmente.

– Una breadboard o volgarmente detta “mille fori”. Ne esistono due versioni una lunga con circa 800 buchi ed una più piccola (in foto) con circa 400 fori. Costano circa 3 euro la piccola, 6/7 euro la grande. Indifferente per noi la dimensione.

– 7 cavetti con inserti metallici, detti  Dupont o jumper wire, maschio/maschio. Ne esistono di lunghezze e colori differenti, non hanno particolari differenze se non aiutarci a vedere meglio e allontanare la basetta.

– 3 resistenze da 220 ohm

– 3 diodi led

– Un cavetto USB simile a quello della stampante o a quello del caricatore smartphone, dipende dalla versione di Arduino che avete.

Esperienza 1: il semaforo

1. Assemblaggio

Lo schema in foto dovrebbe guidarci ad assemblare la nostra basetta mille fori. Cominciamo magari prima assemblando solo gli elementi che fanno riferimento al led rosso, così da prendere confidenza inizialmente col tutto. L’aggiunta successiva dei ledi gialli e verde è una ripetizione. Notiamo che i led hanno un verso, senza scendere in dettagli elettronici che non ci competono, è un po’ come dire il verso + e – delle batterie. Solitamente il terminale più lungo di un led  è l’anodo (+) e quello più corto è il catodo (-). Colleghiamo gli anodi alle porte digitali del nostro Arduino o simil Arduino. Qui abbiamo scelto le porte 13,12,11 ma una qualsiasi di quelle nel lato “digital” è perfettamente uguale, l’importante è ricordarsi il numero o tenerlo presente per poi pilotare l’accensione del led. Alla gambetta più lunga associamo le nostre resistenze, qui da 220 ohm. In realtà il nostro assemblaggio funzionerebbe anche senza ma le resistenze, servono ad attenuare la tensione sul led senza farlo danneggiare prematuramente. A chi non ha confidenza con la breadboard, ricordo che lungo le file laterali la corrente scorre nel senso della lunghezza della tavoletta, proprio come le righe rosse e blu, dall’inizio alla fine, lato a lato senza interruzioni. Nella parte centrale, le linee scorrono in modo trasversale alla basetta interrotte però dallo spacco centrale. I cavetti e i led sono di colore esemplificativo per simulare l’effetto di un semaforo tradizionale. Il cavetto nero va verso un pin GND, ce ne sono tre ed è indifferente quale. Il cavetto nero potete collegarlo in qualsiasi punto del canale – dove arrivano i piedi, stando solo attenti a scavalcare il solco centrale che interrompe il flusso.

2. Cambiamo il firmware del nostro Arduino.

 Snap4Arduino, ha bisogno di un piccolo software che dobbiamo installare su Arduino per far si che riconosca il codice generato dai nostri blocchi Scratch. Si chiama Firmware ed in particolare il Firmware piuttosto famoso per applicazioni di coding: StandardFirmata. In realtà è semplicissimo: basta aprire l’IDE Arduino, scegliere File->Esempi->Firmata->StandardFirmata. Una volta che ci si è aperto lo sketch, premiamo i bottoni V verifica e -> Carica in alto a sinistra. Verificate che Scheda e Porta sotto la voce strumenti siano adeguati. Questa operazione va eseguita una tantum.

3. Colleghiamo il nostro Arduino a Snap4Arduino

Perfetto colleghiamo ora il nostro Arduino al software. Basta Schiacciare il bottone “Collega Arduino” nella sezione azzurra Arduino. Nell’esempio sotto, c’è anche un esempio di come potremmo eseguire in sicurezza uno script se Arduino è collegato o, se scollegato, far comparire un messaggio di errore.

4. Scriviamo il nostro programmino

A questo punto scrivere il nostro programmino è semplice ed una implementazione è la seguente. Una volta pronto usate le bandierine verdi e rossa sulla destra in alto per avviare e spegnere il software caricato in corsa sul nostro Arduino.

Esperienza 2: un campanello di allarme

1. Assemblaggio

L’esperienza è molto semplice. Assembliamo un campanello, attivo o passivo. Ha due soli poli, in genere quello + è contraddistinto da un simboletto analogo. Il polo positivo lo colleghiamo ad un pin digitale, ad esempio il 7. L’altro ad una terra GND. Sotto l’immagine con le istruzioni realizzata con il software per farlo suonare.

Al lettore, la fantasia di far creare un ritmo particolare o jingle famoso alternando le pause. Trovate anche in rete colonne sonore di film come Star Wars o classici della musica riadattati per coinvolgere soprattutto i più piccoli.

L'articolo Snap4Arduino – Lo Scratch su Arduino proviene da alfredocentinaro.it.

Cerchiamo di essere brevi, semplificando il più possibile. Mi perdoneranno gli elettronici o i “maker” esperti se banalizzo alcuni concetti per dare poche e semplici nozioni scolastiche.

Arduino

Arduino è una basetta programmabile della famiglia delle MCU, Micro Controller Unit. Grande più o meno come uno smartphone, contiene un micro-controllore, ovvero un processore molto semplificato in genere della famiglia ATmega o ATmel, con prestazioni decisamente basse rispetto a quello a cui siamo abituati a leggere sui nostri pc o smartphone: parliamo di frequenze del processore intorno ai 100MHz e memorie intorno ai 128/512 KByte. Ma è inutilizzabile, penserete ma queste caratteristiche sono assolutamente adeguate per controllare un braccio robotico, un macchinario industriale tipo pressa o qualche altro genere di movimento ripetitivo, una stampante 3D o stampante serigrafica, piuttosto che qualche tornio o persino le spazzole rotanti della lavastoviglie con i suoi semplici programmi di lavaggio. Aggiungiamo che il sistema Apollo 11 di atterraggio sulla Luna vantava una cpu a 2 MHz e appena 72 KB di memoria RAM, non vi fa certamente effetto avere tra le mani questo bolide!

Applicazioni di Arduino

Le applicazioni sono pressoché infinite. La basetta infatti può essere usata per sperimentare svariate soluzioni. Assieme al cpu e ram, abbiamo una porta USB e una porta Ethernet. A seconda delle versioni, ci possono essere prese usb o microusb, schede ethernet o Fastethernet. Un hardware semplice ma dal consumo energetico ridicolo: la basetta si può alimentare con una semplice pila AA da 1,5Volt! In alternativa col cavo usb o la presa di alimentazione. Esistono versioni di Arduino molto piccole o con prestazioni leggermente diversificate o superiori, alcune anche indossabili. Con una stampate 3D si può stampare anche un piccolo case di plastica per tenerlo all’aperto.

Quello in foto è un Arduino originale, ideato e sviluppato in Italia (sito ufficiale) ma ne esistono “compatibili”, quelle che al bar chiameremmo “le versioni cinesi”. Essendo, infatti, il progetto opensource, qualsiasi azienda può vedere le specifiche tecniche e creare una basetta con un hardware simile o superiore, produrlo e rivenderlo ad un prezzo diverso se non inferiore. Per avere un’idea, Arduino originale costa intorno ai 18 euro, versioni compatibili come Elegoo o altre possono costare anche 3/5 euro! Su Arduino, possiamo caricare i nostri software scritti in un ambiente IDE simile a quelli del C/C++. Questo sw è scaricabile dal sito ufficiale ed è compatibile con tutti gli Arduino originali e non. Ma cosa ci possiamo programmare ovvero fare con questa basetta e il relativo software?

I sensori

Esistono una varietà enorme di sensori che possono essere collegati ad Arduino con dei pin che si trovano al lato, alcuni pilotano un segnale digitale, altri pilotano un segnale per applicazioni analogiche. Se ai pin digitali colleghiamo ad esempio con cavetti e resistenze dei led, possiamo far accendere e spegnere questo led con un programmino semplice che poi carichiamo sulla basetta. Se colleghiamo più led visto che i pin sono molti possiamo creare giochi di luci led addirittura, una serie di semafori sincronizzati e così via.

Altri sensori utili sono ad esempio i rilevatori di fumo, i sensori di movimento, i sensori di distanza, i sensori di luminosità, i sensori di umidità, i sensori di urto, i sensori di variazione magnetica e molti altri.

Gli attuatori

In base ai dati raccolti dai sensori collegati al nostro Arduino, il programma che scriviamo può gestire queste informazioni per eseguire azioni in cascata. Ad esempio, se il rilevatore di fumo manda un segnale di presenza fumo alla nostra basetta, la basetta a sua volta potrebbe pilotare un motore detto “servo” per spalancare una finestra o la porta, accendere un “buzzer” di allarme e dei led rossi di emergenza.

Tutti i dispositivi pilotabili dal nostro Arduino che compiono un’azione attraverso un meccanismo possiamo indicarli come attuatori.

I “servo motori”, i principali attuatori forse, sono i classici motorini dei bracci robotici: capaci di effettuare un movimento in un range/angolo particolare e restare fermi e saldi nella posizione che raggiungono fornendo un feedback della loro posizione. Sono molto particolari perché possono essere pilotati fornendo loro l’angolo che devono formare.

Esistono altri motorini detti passo passo, questi sono i classici motorini da mettere ad esempio su un veicolo perché hanno la capacità di regolare la velocità, aumentandola o diminuendola, secondo il software che li gestisce al contrario dei servo che hanno una velocità preimpostata. Esistono in commercio anche kit con più pezzi molto economici con cui sperimentare diverse applicazioni.

RFID

Uno dei sensori più interessanti e di attualità sono gli RFID che vale la pena approfondire con qualche riga in più. Sono piccole e sottili spirali metalliche che possiamo vedere ad esempio negli indumenti che acquistiamo al Decathlon o che possono essere facilmente attaccate sui pacchi con dei semplici adesivi. Sono dei ricetrasmettitori radio e comunicano delle brevi informazioni ad una stazione ricevente. In genere è possibile associare ad un tag rfid, ovvero un identificatore univoco di un articolo. Nelle casse automatiche dove gettano l’articolo, il ricetrasmettitore legge l’identificatore e segnala quindi alla cassa che articolo abbiamo inserito in modo che la cassa stessa possa recuperare le informazioni di prezzo e gestire in cascata, scontrino, l’approvvigionamento del negozio, la fatturazione in modo automatizzato.

RFID ormai li troviamo negli armadietti della palestra, nelle tessere che ci danno come chiave negli alberghi, nella accensione delle auto moderne dove si preme start senza di fatto girare una chiave fisica.

E’ una tecnologia interessante che abbiamo già nei nostri cellulari: il famoso NFC altro non è che un particolare sistema di sicurezza basato sulla tecnologia RFID. Del resto funziona avvicinando il nostro smartphone entro 10 cm dal lettore del negozio. E’ un pochino più complesso, senza scendere nei dettagli, crea una comunicazione bidirezionale rispetto allo RFID tradizionale permettendo quindi delle misure di sicurezza e di prestazioni differenti per emulare la nostra carta di credito con i lettori POS abilitati.

Relé

Altro elemento di interesse che possiamo collegare con una basetta Arduino sono i famosi relè. In realtà, li troviamo già da tempo nelle nostre case. Vi siete chiesti come sia possibile che in una stanza con due interruttori uno accenda e l’altro in automatico spenga la luce? Beh è proprio grazie a questo congegno. L’idea di applicare dei relè collegati ad Arduino diventa vincente nella casa domotica del futuro. Con un Arduino opportunamente collegato alla rete con una scheda di rete Ethernet o WiFi (ci sono degli shield su misura), potremmo comandare Arduino che attiva o disattiva un relè a cui possiamo collegare di tutto: una luce, una lampada, una macchinetta del caffè, possiamo azionare un qualsiasi circuito elettrico che accenda o spenga un elettrodomestico o controllare da remoto, magari con uno smartphone o un pc, se abbiamo lasciato accesa la lavatrice o il forno e quindi spegnerlo!

 Il lettore potrà immaginare come la combinazione di tecnologie come RFID possano pilotare attraverso Arduino attuatori per aprire porte, relè per accendere luci, eseguire operazioni meccaniche che spostano oggetti o inviano comunicazioni ad altri congegni o sistemi tra server, database o software realizzati su misura. Applicazione infinite che si possono approfondire studiando i temi concernenti la domotica.

RaspBerry

Ce ne siamo già occupati in questa categoria del nostro sito dove pubblicheremo anche delle esercitazioni. Fa parte della categoria SCU, Single Computer Unit o SBC, single board computer. Ha dimensioni e consumi leggermente superiori ad un Arduino, ma un sistema di pin detti GPIO praticamente uguali a cui possiamo collegare gli stessi sensori.

La differenza fondamentale: Arduino ha una cpu, o meglio, microcontrollore dalle prestazioni esigue, RaspBerry ha una CPU “general purpose” come quella dei nostri pc di casa (meglio dei nostri smartphone visto che è una tecnologia ARM). Quindi RaspBerry è a tutti gli effetti un mini pc.

La vecchia versione che ha decretato il successo del nostro SBC, Single Board Computer, è il RaspBerry 3 B+. Vanta un processore a 1.4GHz 64-bit quad-core, dual-band wireless LAN, Bluetooth 4.2/BLE, Gigabit Ethernet, Power-over-Ethernet, 5 porte USB, 1 GB di RAM DDR2, scheda audio, sensore infrarosso per telecomando, slot per webcam, una uscita HDMI video e alloggiamento per microSD dove caricare un sistema operativo a scelta tra svariate distribuzioni Linux o Windows IoT o Android. Prestazioni non da urlo, sentenzierà il lettore, ma collegato ad una tv con la sua porta HDMI non farà rimpiangere nessun utente anche per le normali funzioni desktop. Consumi ridicoli: si alimenta con un alimentatore 5V 2.5A, come un tablet insomma!

Applicazioni del Raspberry

Le applicazioni viste con Arduino sono fattibili anche qui, ma con più capacità e risorse di calcolo per eseguire anche funzioni complesse direttamente sulla basetta. In più può tranquillamente essere amministrata da remoto con una connessione SSH per svariate funzioni. Ad esempio:

• un server per scaricare e condividere i file, torrent, streaming
• caricarci su un player per guardare le IPTV
• utilizzarlo con un joypad per giocare con i vecchi emulatori di console
• crearci un server di stampa in rete per stampanti USB
• un NAS casalingo con hard disk che diventano “di rete”
• metterci su un piccolo host Apache o NGinx per i nostri siti web php o python!!!

Come per Arduino, un mondo di applicazioni che si aprono qualora cominciassimo ad aggiungere i sensori/attuatori collegabili in modo analogo al fratello minore Arduino.

Altre versioni di Raspberry

Esistono svariate versioni di RaspBerry con prestazioni e consumi differenti. Se è vero che ci sono le generazioni 3, 4 e attualmente la 5, di ogni generazioni vengono poi rilasciate versioni più o meno compatte. A variare sono le caratteristiche più esigue per avere consumi migliori, ad esempio la Zero Wireless o la versione A+ che hanno meno caratteristiche e porte, meno ram ma magari un’autonomia a batteria superiore ed una occupazione di spazio del pcb inferiore.

Quelle più interessanti sono le versioni ispirate dall’originale ma realizzate da altre case. Ad esempio la Orange, RockPI, NanoPi, BananaPi e la Asus Tinker, tutte con costi inferiori o caratteristiche superiori tra RAM, CPU (Cortex A9 octacore ad es), memorie MMC integrate ecc. Non vi faranno per niente rimpiangere l’originale.

L'articolo Appunti su Arduino e Raspberry proviene da alfredocentinaro.it.

Occorrente

• Un Arduino o analogo con cavetto USB per alimentarlo e programmarlo
• Un led rosso (o del colore che ci piace)
• Tre cavetti con gli inserti metallici, detti jumper wire o dupont, maschio/maschio(consiglio due lunghi ed uno corto, colori a piacere)
• Una resistenza da 220 ohm (rosso rosso marrone oro)
• Una breadboard (o versione ridotta)

Se non vi è già capitato di metter mano ad un Arduino, guardate i due lati dove sono presenti le barre nere. Sui lati, sulla schedina sono riportati dei nomi e numeri come quelli in figura. Usateli come riferimento.

Per chi è a digiuno di breadboard, due considerazioni base: 

Sono basette di prototipazione in cui la corrente scorre con delle direzioni assegnate. Nei canali laterali dove compare spesso anche il simbolo + o – con delle linee rosse e blu, la corrente scorre nel verso della lunghezza della basetta. Sono presenti dei tratti non bucherellati ma non costituiscono una interruzione al circuito che è dentro la basetta. Nella parte centrale, la corrente scorre nel verso più corto, con lo zoccolo centrale che interrompe di fatto il circuito interno, per poi ricominciare analogamente nell’altro lato. Il senso interrompe sulle pareti interne. Le linee centrali sono spesso identificate da una lettera alfabetica a,b,c ecc

Se vi state chiedendo perché ci sia lo zoccolo centrale è perché risulta più comodo usarlo come riferimento per i test sui chip operazionali o simili come quello in figura sotto, costruiti con questa forma di ragnetto, per non far arrivare lo stesso segnale ai piedini differenti. In genere la “pancia” del chip è pari pari alla larghezza della scalanatura della nostra breadbord.

Istruzioni

– se non è già piegato, il piedino del led più lungo va piegato leggermente per facilitare l’inserimento, formando una specie di R. Le due zampette rappresentano il nostro meno (corta) e più (lunga piegata)

– colleghiamo un cavo di quelli più lunghi alla porta con scritto POWER → GND. Ce ne sono due, uno vale l’altro.

– lo stesso cavo lo colleghiamo dall’altra parte della breadboard dove c’è il simbolo – meno

– mettiamo la resistenza come un ponte in mezzo allo zoccolo/pista centrale. Non è importante scegliere i fori, cerchiamo di metterla però dritta.

– al lato in basso della resistenza mettiamo un cavetto corto che va verso il – meno

– dall’altro lato della resistenza mettiamo il led

– il lato più corto è in corrispondenza del piede della resistenza

– sotto la zampetta piegata del led, mettiamo un cavetto lungo  che portiamo alla porta DIGITAL → 13 (o una qualsiasi pin di quel lato, a patto di segnarsi il numero!)

Programma

Trovo particolarmente utile, soprattutto per i più giovani, usare un linguaggio a blocchi per programmare il nostro Arduino. Le scelte sono tante. Ne suggerisco due: Snap4Arduino e mBlock. Entrambe le soluzioni mettono a disposizione una sorta di ambiente grafico simile a Scratch con blocchi colorati da installare stand-alone, oppure installando una estensione detta mLink di Chrome, possiamo usare le medesime funzionalità direttamente da browser. Qui a voi la scelta, sono molto validi entrambi. Snap4Arduino è leggermente più generico, mentre mBlock è un po’ più scarno di comandi ma non se ne avverte la differenza. Nella figura sotto, ho usato mBlock con estensione per browser su piattaforma Linux con Firefox per giunta. Abbiate cura di seguire le istruzioni della parte download. Una volta nell’area ONLINE CREATE bisogna cliccare su uno dei bottoni con il più in basso a sinistra. L’IDE parte con la connessione ad un robottino CODEY mentre a noi serve aggiungere Arduino UNO che ovviamente sarà compatibile con qualsiasi versione originale o cinese voi abbiate. Premete il bottone azzurro collega e siamo pronti a programmare. Su linux, dopo aver scaricato il tool/demone mLink ed attivato con il comando da shell mblock-mlink start, se non abilita la connessione, controllate che le /dev/ttyAM0 o /dev/ttyUSB0 abbiano i permessi di scrittura/lettura col comando sudo chmod a+rw /dev/ttyACM0. In alcune vecchie versioni di Windows, potrebbe esserci qualche noia con il driver di Arduino. Per velocità, vi consiglio di installare l’IDE di Arduino che potete reperire qui. Tra le spunte di installazione c’è proprio il driver che cerchiamo.
Possiamo passare a piazzare i nostri blocchi. Per questo esercizio, peschiamo blocchi dalle sezioni SITUAZIONI, CONTROLLO, PIN. Una volta ultimato, non ci resta che schiacciare la bandierina verde sulla sinistra e verificare il comportamento del nostro led! In figura sotto è riportato un esempio dove il led è collegato al pin, sempre digitale, 13

Sul bordo destro, c’è una piccola linguetta dove potete mostrare ai vostri alunni, magari i più grandi, il corrispondete codice C. Nel nostro caso:

// generated by mBlock5 for <your product>
// codes make you happy

#include <Arduino.h>
#include <Wire.h>
#include <SoftwareSerial.h>

void _delay(float seconds) {
  long endTime = millis() + seconds * 1000;
  while(millis() < endTime) _loop();
}

void setup() {
  pinMode(13,OUTPUT);

}

void _loop() {
}

void loop() {
  digitalWrite(13,1);
  _delay(1);
  digitalWrite(13,0);
  _delay(1);

  _loop();
}

Solitamente possiamo semplifica il codice proposto se usiamo direttamente l’IDE Arduino, senza scomodare interfacce a blocchi. In questo caso suggerisco di usare il seguente codice per uno “sketch”, un progettino semplice:

int led = 13; //o il pin digitale scelto
 
void setup() {                
  //inizializziamo il PIN come OUPUT, ovvero "non cattura" dati
  pinMode(led, OUTPUT);     
}
 

void loop() {
  digitalWrite(led, HIGH);   // accende il LED (HIGH è il voltaggio +5V)
  delay(1000);               // aspetta un secondo
  digitalWrite(led, LOW);    // spegne il LED 
  delay(1000);               
}

Potete proporre come ulteriore esercizio di replicare tre collegamenti ad altrettanti led collegati ad altre porte digitali e programmare un piccolo semaforo rosso, giallo, verde. 

L'articolo Accendiamo un Led con Arduino e Scratch/MBlock proviene da alfredocentinaro.it.