Oggi vediamo come accendere e spegnere un led con arduino.

Per prima cosa vi consiglio di leggere anche l’articolo introduttivo all’input/output di Arduino. Questi concetti base sono estendibili anche ad altri micronontrollori più o meno evoluti.

Il codice di base:

/*
LED Lampeggiante (Author: Matteo Dalle Feste - matteo@dallefeste.com - info@ciaobit.com - https://ciaobit.com )
Libero utilizzo a fini non commerciali e mantenendo i crediti dell'autore
You can use this script for free. Not for commercial use. Keep author credits
*/

// Dichiaro la variabile LED un numero intero che corrisponde al pin digitale di Arduino/Genuino
int LED = 7;

// definisco il Pin LED come OUTPUT
void setup() {
  pinMode(LED, OUTPUT);
}

// Ripeti queste istruzioni all'infinito:
void loop() {
  digitalWrite(LED, HIGH);   // Accendo led
  delay(1000);               // Aspetto 1000ms = 1secondo
  digitalWrite(LED, LOW);    // Spengo il led
  delay(1000);               // Aspetto 1000ms
}

Arduino e i LED pilotati direttamente

Per capire se Arduino può alimentare direttamente un led, bisogna verificare le specifiche tecniche del modello di Arduino in uso e le specifiche tecniche del led.

In base al modello di Arduino possiamo definire la corrente massima che possiamo prelevare da un pin di output:

Solitamente i piccoli led colorati, quelli da 3mm, 5mm per intenderci, possono essere alimentati direttamente da Arduino.

Come precedentemente accennato, i valori vanno sempre verificati al momento dell’acquisto leggendo le specifiche tecniche del componente (chiamate anche datasheet in inglese).

Segue una tabella di riferimento dei led più comuni con i relativi valori indicativi.

Un esempio di collegamento con Arduino UNO potrebbe essere questo:

Arduino e i mosfet per pilotare le LED strip

Le strisce a LED, chiamate anche LED strip, sono dei led messi in serie solitamente a gruppi di 3 elementi. I led, per funzionare correttamente, dovrebbero essere alimentati in corrente e non in tensione. Tuttavia queste strisce a led sono limentate in tensione. Per questo motivo, ad ogni gruppo di led ha una resistenza che ne limita il passaggio di corrente. La striscia ha dei punti dove è possibile tagliarla, questo permette di sceglierne la lunghezza.

Esistono diverse tipologie di strsce a LED. Le principali differenze sono:

• la marca/modello del LED
• la densità di led per metro lineare
• l’eventuale resina di rivestimento che la rende più o meno resistente alle intemperie

Le strisce a led sono solitamente alimentate a 12VDC, ovvero 12 volt in corrente continua (non alternata!). Serve quindi un alimentatore Switching che deve essere dimensionato in base alla striscia a led e alla sua lunghezza.

In questo esempio prendiamo un metro di striscia a led SMD5630. il circuito è simile a quello visto in questo progetto di domotica, con qualche lieve differenza.

Se ti piace l’articolo condividilo sui social! Iscriviti alla pagina facebook e alla newsletter per restare sempre aggiornato sulle novità di Ciaobit.com

L'articolo Arduino Genuino e i LED, Accendere un led con Arduino proviene da ciaobit.com.

In questo articolo vedremo come regolare la luminosità di un led con Arduino.
Come spiegato nell’articolo precedente “Arduino: GPIO, gestire gli Input e Output” che descrive per l’appunto le funzionalità delle porte GPIO dell’Arduino/Genuino, è possibile usufruire della funzionalità PWM gestita a livello hardware per controllare la luminosità di un led.

Un altro articolo che spiega come collegare un led ad Arduino è disponibile qui: Arduino Genuino e i LED, Accendere un led con Arduino.
Vediamo qualche esempio pratico:

Led effetto “fade-in” e “fade-out” con Arduino Genuino

Un semplice esempio per capire come usare il PWM di Arduino per gestire l’intensità luminosa (dimmer) di un led.

/*
Fade-in e Fade-out LED con Arduino (Author: Matteo Dalle Feste - matteo@dallefeste.com - info@ciaobit.com - https://ciaobit.com )
Libero utilizzo a fini non commerciali e mantenendo i crediti dell'autore
You can use this script for free. Not for commercial use. Keep author credits
*/

// Dichiaro la variabile LED e associo un numero intero che corrisponde al pin digitale di Arduino/Genuino
int LED = 9; 
// espresso in millisecondi
int ritardo = 5; 

// definisco il Pin LED come OUTPUT 
void setup() { 
   pinMode(LED, OUTPUT); 
} 

// Ripeti queste istruzioni all'infinito: 
void loop() {

   // Imposto il PWM da 0 a 255 per qualche millisecondo
   for(int ValorePWM = 0; ValorePWM <= 255; ValorePWM++){ 
      analogWrite(LED, ValorePWM);
      delay(ritardo);
   }
   
   // Imposto il PWM da 255 a 0 per qualche millisecondo 
   for(int ValorePWM = 255; ValorePWM >= 0; ValorePWM--){
      analogWrite(LED, ValorePWM);  
      delay(ritardo); 
   }
} 

Il codice qui sopra riportato definisce il pin 9 come pin di output usato per collegare il led. La scelta di questa porta non è casuale, infatti, va verificato sui datasheet e sui manuali quali sono i pin che gestiscono nativamente questa funzione.

Impostiamo anche una variabile “ritardo” che useremo per provare a cambiare i tempi di transizione da un valore all’altro del PWM.

il codice che è racchiuso nel loop,  esegue per l’appunto un ciclo infinito che trova al suo interno due cicli for.

Il primo ciclo for aumenta progressivamente il valore del pwm, che va da 0 a 255.
Di conseguenza il led passerà da un valore di luminosità uguale a zero a un valore di 100%.
Questa accensione graduale crea ad esempio un’effetto “accensione luci soft”, un effetto molto piacevole.

Se il promo ciclo faceva l’effetto “Fade-in”, il secondo ciclo for invece esegue l’effetto contrario, ovvero il “Fade-out”, quindi le luci si spengono gradualmente.

Di seguito un esempio di collegamento di Arduino a una striscia a LED da 12v attraverso un MOSFET pilotato dal PWM.

Se ti è piaciuto l’articolo condividi il link di questa pagina!

L'articolo Regolare la luminosità di un LED con il PWM e Arduino Genuino proviene da ciaobit.com.

Controllo della luminosità (Dimmer) Led con Arduino Genuino via seriale

Possiamo pilotare il valore del PWM di Arduino, e quindi la luminosità del led, in diversi modi.
Un esempio, perlopiù accademico che realmente utile, è quello di scrivere il valore direttamente da pc, via porta seriale inviando dei comandi specifici che Arduin dovrà interpretare come “Accendi”, “Spegni”, “Aumenta luminosità” o “Diminuisci luminosità”.

Iniziamo con la partlist e lo schema elettrico:

Partlist

• Arduino UNO
• Breadboard
• Filo rigido (va bene del doppino telefonico o un vecchio cavo di rete di recupero, purchè sia rigido)
• 1 resistore da 220Ohm, codice colore Rosso, Rosso, Marrone (Cos’è un resistore)
• 1 LED rosso

Schema elettrico

Lo schema è molto semplice, accostiamo arduino UNO non alimentato alla breadboard e posizioniamo i fili, il led e la resistenza come in figura.

Attenzione: i LED sono dei diodi luminosi e i diodi hanno una polarità, ciò significa che a differenza di una comune/vecchia lampadina a incandescenza, esiste un polo positivo e un polo negativo da rispettare. Se si inverte la polarità si rischia di danneggiare il componente.
Inoltre Arduino UNO lavora a 5V mentre il led rosso, come da specifiche, può essere alimentato al massimo a 1,8V poi rischia di bruciarlo. Per questo nel circuito si introduce un resistore. Il resistore infatti limita il passaggio di corrente e previene che il led subisca danni.

una volta verificato che il circuito sia correttamete montato possiamo alimentare Arduino UNO collegandolo al computer per eseguire la programmazione.

Programmare Arduino

Come precedentemente accennato, questo esercizio è utile per imparare a prendere dimestichezza sia con la componentistica che con le basi di programmazione di Arduino in linguaggio Wiring.

Iniziamo con l’introduzione delle variabili. Dobbiamo spiegare ad Arduino come deve comportarsi in certe condizioni, per fare ciò dobbiamo definire delle variabili che “rispecchiano il mondo esterno”

// Dichiaro la variabile LED un numero intero che corrisponde al pin digitale di Arduino/Genuino
int LED = 9;

// Imposto valore iniziale del PWM
int ValorePWM = 0;

// dichiaro variabile per carattere che arriva dalla seriale
char Carattere;

In questo pezzo di codice abbiamo detto ad Arduino che andremoad operare sul pin 9 della board. l’etichetta “LED” associata alla variabile serve solo a oi per comodità e semplicità di lettura del codice.
Abbiamo dichiarato che useremo una variabile di tipo intero per gestire il valore di luminosità. Questo numero andrà da 0 a 255.
Per cocludere abbiamo dichiarato una variabile di tipo carattere che verrà usata dalla porta seriale per ricevere i comandi di accensione, spegnimento e modifica luminosità.

Terminata la fase di dichiarazione variabili, passiamo alla funzione di setup.

void setup() {
    // imposto la velocità di comunicazione che arduino utilizzerà per comunicare con il PC
    Serial.begin(9600);

    // dico ad Arduino che il pin 9 dell'omonima scheda sarà usato come OUTPUT
    pinMode(LED, OUTPUT);
}

Nel setup definisco la velocità di comunicazione che Arduino utilizzerà per comunicare. Questa velocità dovrà essere adottata anche dal PC per poter comunicare correttamente.
Definisco inoltre che il pin9 della scheda Arduino sarà usato come OUTPUT

Arrivo quindi alla funzione di loop. La funzione di Loop verrà richiamata all’infinito da Arduino. Il loop viene eseguito finchè c’è tensione e finchè non si manifesta un errore o un eventomparticolare che ne sospende, blocca l’esecuzione. Nel nostro caso il loop sarà infinito.

// Ripeti queste istruzioni all'infinito:
void loop() {

    // Se riceve comandi validi da seriale allora aggiorna ValorePWM
    if (Serial.available() > 0) {
    Carattere = Serial.read();

    // se trovo '+' allora incrementa di 15 il valore PWM
    if(Carattere=='+' && ValorePWM<255){
        ValorePWM = ValorePWM+15;
    }

    // se trovo '-' allora decrementa di 15 il valore PWM
    if(Carattere=='-' && ValorePWM>0){
        ValorePWM = ValorePWM-15;
    }

    // se trovo '1' allora porta a 255 (massimo) il valore PWM
    if(Carattere=='1'){
        ValorePWM = 255;
    }

    // se trovo '0' allora porta a 0 (minimo) il valore PWM
    if(Carattere=='0'){
        ValorePWM = 0;
    }

    Serial.print('Ricevuto:');
    Serial.println(ValorePWM);
    analogWrite(LED, ValorePWM);
    }
}

Considerando che tutto quello che è contenuto dentro la funzione loop viene continuamente eseguita, possiamo dire che per prima cosa il programma va a verificare continuamente se Arduino ha ricevuto un carattere dal PC. Se non c’è un carattere allora cotinua a riverificare finchè non arriva qualcosa.
Se viene rilevato un carattere allora lo script fa una serie di controlli del tipo: se è il carattere “+” allora attivo la parte di codice che aumenta il valore della luminosità di “15 punti” fino a un massimo di 255.
Se incontra il carattere “-” allora abbassa la luminosità di “15 punti” fino ad arrivare al minimo che è 0.
Se viene invece rilevo il carattere “1” allora Arduino porta subito la luminosità al massimo, ovvero 255 e al contrario se rileva il carattere 0 porta la luminosità a “0”.

Ecco il codice completo:

/*
Dimmer LED Seriale (Author: Matteo Dalle Feste - matteo@dallefeste.com - info@ciaobit.com - https://ciaobit.com )
Libero utilizzo a fini non commerciali e mantenendo i crediti dell'autore
You can use this script for free. Not for commercial use. Keep author credits
*/

// Dichiaro la variabile LED un numero intero che corrisponde al pin digitale di Arduino/Genuino
int LED = 9; 

// Imposto valore iniziale del PWM
int ValorePWM = 0; 

// dichiaro variabile per carattere che arriva dalla seriale
char Carattere;

void setup() {
   // imposto la velocità di comunicazione che arduino utilizzerà per comunicare con il PC
   Serial.begin(9600);
   // dico ad Arduino che il pin 9 dell'omonima scheda sarà usato come OUTPUT
   pinMode(LED, OUTPUT); 
} 

// Ripeti queste istruzioni all'infinito: 
void loop() {

  // Se riceve comandi validi da seriale allora aggiorna ValorePWM
  if (Serial.available() > 0) {
    Carattere = Serial.read();
    
    // se trovo '+' allora incrementa di 15 il valore PWM
    if(Carattere=='+' && ValorePWM<255){ ValorePWM = ValorePWM+15; } // se trovo '-' allora decrementa di 15 il valore PWM if(Carattere=='-' && ValorePWM>0){
      ValorePWM = ValorePWM-15;
    }

    // se trovo '1' allora porta a 255 (massimo) il valore PWM
    if(Carattere=='1'){
      ValorePWM = 255;
    }

    // se trovo '0' allora porta a 0 (minimo) il valore PWM
    if(Carattere=='0'){
      ValorePWM = 0;
    }
    
    Serial.print('Ricevuto:');
    Serial.println(ValorePWM);
    analogWrite(LED, ValorePWM); 
  }

} 

Un articolo simile che tratta sempre la luminosità di un led controllata con Arduino lo trovi qui: Regolare la luminosità di un LED con il PWM e Arduino Genuino

Se ti è piaciuto l’articolo condividilo! Grazie

L'articolo Arduino: Controllo della luminosità (Dimmer) Led via seriale proviene da ciaobit.com.

In questo tutorial vedremo come preparare un ambiente di sviluppo per l’esp8266 utilizzando il famoso Arduino IDE.
Il tutorial è utile anche per programmare il NodeMCU, una board basata sempre sul chip esp8266.

Arduino IDE: Cos’è, come funziona, dove si scarica.

Arduino IDE è un ambiente di sviluppo appositamente progettato per le board della famiglia Arduino. Il compito dell’IDE è quello di semplificare il più possibile il caricamento di un programma in un microcontrollore.

Nello specifico, l’Arduino IDE permette di editare e salvare i nostri programmi scritti nel linguaggio wiring.
Per semplificare la lettura del codice, l’editor di testo colora in modo diverso alcune parole chiave del linguaggio, alcui caratteri speciali e  porzioni di testo. Questa funzionalità permette di semplifica anche la ricerca di eventuali errori.

Quando si procede al caricamento del programma nel microcontrollore, l’IDE esegue una serie di operazioni, come ad esempio la verifica di assenza di errori di sintassi. Se non ci sono errori, allora Arduino IDE procede alla compilazione del codice, ovvero traduce il programma dal linguaggio Wiring al codice macchina. Se la compilazione è andata a buon fine, allora l’IDE procede al caricamento del codice macchina (detto anche Firmware) nel microcontrollore (ad esempio l’atmega328p contenuto nella scheda Ardino UNO).

Se non l’abbiamo già fatto, dobbiamo prima di tutto scaricare ed installare il programma Arduino IDE da questo indirizzo: https://www.arduino.cc/en/main/software

Naturalmente va scaricata la versione compatibile con il proprio sistema operativo.
Per Windows è possibile ad esempio scaricare la versione Windows Installer e la versione Zip (quest’ultima solitamente usata per le installazioni portable o per chi non ha i diritti di amministratore sul proprio pc.)

Usare Arduino IDE per programmare l’esp8266

Arduino IDE, oltre che gestire le board dell’omonima famiglia, da anche la possibilità di supportare e programmare schede di terze parti, come per l’appunto l’esp8266.
Questo supporto viene realizzato molto semplicemente aggiungendo delle url elle impostazioni di Arduino IDE.
Le url puntano ad un file in formato Json che contiene le istruzioni che Arduino IDE dovrà eseguire per scaricare i componenti aggiuntivi che serviranno per riconoscere e programmare l’esp8266. Vediamo nello specifico come operare:

1) Per prima cosa va aperto Arduino IDE che abbiamo appena installato, poi, entrando nel menu File, selezionare Impostazioni.

2) Nella finestra Impostazioni che si sarà aperta, individuare il campo con scritto “URL aggiuntive per il Gestore schede:” e incollare nel campo di testo adiacente la seguente url: http://arduino.esp8266.com/stable/package_esp8266com_index.json
Quindi premere OK per confermare

3) Ora si deve andare sempre nella barra dei menu e selezionare “Strumenti“, quindi “Scheda: …” (dovrebbe essere la settima voce) e selezionare la prima voce del menu, chiamata “Gestore schede…“. Si aprorà la finestra di gestione schede.

4) Nella finestra di gestione schede, scrivere nel campo di testo “esp8266”, questo servirà a filtrare i risultati, lasciando solo un risultato disponibile. Selezionare il risultato cliccando con il mouse (o con il touch), apparirà quindi la possibilità di installare la scheda Esp8266. Selezionando la versione più recente, in questo caso era la v2.3.0 e premere “Installa”

5) Terminata l’operazione di installazione è possibile chiudere la finestra del gestore schede. Se tutto è andato a buon fine, troveremo le schede compatibili con equipaggiato il chip esp8266 sotto il menu “Strumenti“, quindi “Scheda: …” come nell’esempio a seguire, sarà sufficiente selezionare il modulo giusto.

Ora siamo in grado di usare Arduino IDE per programmare anche i chip esp8266!

Ricordati di condividere questo tutorial!

L'articolo Come programmare l’esp8266 con Arduino IDE proviene da ciaobit.com.

Cos’è RFLink Gateway

RFLink Gatrway è un progetto gratuito che implementa la comunicazione via radio tra dispositivi, anche in modo bidirezionale.
Il progetto è sviluppato da Stuntteam che ha fondato il sito http://www.rflink.nl dalla quale è possibile scaricare un firmware già pronto per essere caricato su una scheda Arduino Mega 2560.

Gli sviluppatori di Stuntteam sono molto attivi, grazie anche ai continui feedback da parte della community che sono riusciti a costruire attorno al loro progetto. Questa combinazione vincente fa in modo che il team riesca a rilasciare versioni nuove del firmware quasi mensilmente, arricchendo il software di funzionalità ed espadendo la compatibilità dei protocolli gestiti. Per scaricare l’ultima versione del firmware bisogna accedere al loro sito http://www.rflink.nl

Come funziona RFLink Gateway?

RFLink Gateway è un firmware pronto all’uso che va caricato su una scheda Arduino Mega 2560. Gli sviluppatori di Stuntteam hanno deciso probabilmente di usare una scheda di prototipizzazione più evoluta del classico Arduino UNO perchè cosi ci sono più risorse hardware disponibili e quindi più libertà di implementazioni future.
Entriamo più sullo specifico.

Ricevere e trasmettere segnali modulati a 433.92Mhz

Il Firmware ha il compito di ricevere e trasmettere i segnali radio provenienti da diversi dispositivi che possiamo trovare in casa come ad esempio un telecomando apri cancello, spine intelligenti, sistemi di condizionamento,i sensori della nostra mini stazione meteo o sensori di sicurezza come rilevatori di gas e intrusione.
I dispositivi che scambiano dati via radio, hanno frequenze e potenze di trasmissione ben definite dalle autorità.
Normalmente le frequenze utilizzate dai radiocomandi europei sono “frequenze libere” a 433Mhz, ma si trovano radiocomandi a 315Mhz e 868Mhz.
Ad ogni modo, prima di usare o acquistare dispositivi radiotrasmittenti, consiglio sempre di consultare il Piano nazionale di ripartizione delle frequenze per evitare di infrangere la legge e/o interferire con altri dispositivi o enti come ad esempio aerei e aereoporti.
La frequenza ci spiega “in che canale” avviene la trasmissione radio, ma il modo con la quale trasmetto l’informazione è detta modulazione.
Nelle trasmissioni digitali, la modulazione più semplice e meno costosa è la ASK (Amplitude-shift keying) in italiano “modulazione d’ampiezza”. Un esempio pratico di modulazione d’ampiezza digtale che credo essere più comunemente conosciuto è la trasmissione di un messaggio via codice morse.
Altri principali tipi di modulazione radio digitate sono la FSK (Frequency-shift keying) e la PSK (Phase-shift keying) che non tratteremo in questo articolo.

Protocolli di comunicazione

Oltre alla frequenza, va individuato il protocollo con la quale trasmettitore e ricevitore dialogano. Il protocollo infatti definisce le regole con la quale un dispositivo può comunicare con un altro dispositivo. Non esiste purtroppo un linguaggio comune  tutti i costruttori di radiocomandi, quindi il firmware RFLink ha il compito di raccogliere questi frammenti di informazioni radio e cercare un pattern che gli permetta di riconoscere il protocollo con la quale un dispositivo sta trasmettendo. Se il protocollo è stato riconosciuto allora il Firmware può presentare in output una serie di informazioni decodificate.
Al contrario, quando si vuole trasmettere un messaggio a un dispositivo radio, dobbiamo codificare l’iformazione secondo il protocollo di quel determinato dispositivo e trasmetterlo con la frequenza e modulazione corretta.

Quale hardware è necessario?

RFLink Gateway ha bisogno di:

• Una scheda Arduino Mega2560 (o compatibile)
• Un ricevitore RF ASK della frequenza con la quale vogliamo lavorare. In questo tutorial useremo il modulo RXB6 a 433Mhz
• Un trasmettitore RF ASK della frequenza con la quale vogliamo lavorare. In questo tutorial useremo il modulo FS1000A a 433Mhz

Questa configurazioe hardware è una delle possibili suggerite da Stuntteam, per maggiori info suggerisco di visitare la loro pagina dedicata Wiring.

Collegare Arduino Mega2560, ricevitore e trasmettitore

Cominciamo collegando il ricevitore RXB6  alla board Arduno Mega2560 nel seguente modo:

• RXB6 GND -> GND Arduino Mega2560
• RXB6 DATA -> PIN19 (RX1) Arduino Mega2560
• RXB6 5V ->PIN16 (TX2) Arduino Mega2560
• RXB6 ANT -> spezzone di filo lungo 17,3cm che fa da antenna ricevente

Quindi colleghiamo il trasmettitore FS1000A alla board Arduno Mega2560 nel seguente modo:

• FS1000A DATA -> PIN14 (TX3) Arduino Mega2560
• FS1000A VCC -> PIN15 (RX3) Arduino Mega2560
• FS1000A GND ->GND Arduino Mega2560
• FS1000A ANT -> spezzone di filo lungo 17,3cm che fa da antenna trasmittente

Caricare il firmware RFLink Gateway su Arduino Mega2560

La procedura per caricare il firmware RFLink Gateway è davvero molto semplice.
Per prima cosa va scaricato il firmware dal sito del progetto. Clicca qui per: RFLink Latest Firmware Version

Una volta scaricato il file, nel nostro caso il file si chiama: RFLink_v1.1_r48.zip lo decomprimiamo in una cartella.
Per semplificare lo decomprimo in C:\RFLink o nel desktop.

Notiamo subito che all’interno dell’archivio zip troviamo diversi file. Di regola, se c’è un file Readme, è buona cosa per l’appunto leggerlo.

Ad ogni modo dentro a Readme_RFLink.txt troviamo il changelog, ovvero le varie modifiche che si sono susseguite nel tempo durante le release. Qui troviamo quali dispositivi sono stati resi compatibili con la nuova release.
Il file Supported_Device_List.txt definisce tutti i dispositivi compatibili in questa versione.
Il file Readme_Loader.txt spiega come caricare il firmware nella board Arduino.

Non serve Arduino IDE

Per caricare il firmware è necessario:

Collegare Arduino Mega2560 ad un PC Windows ed eseguire il programma RFLinkLoader.exe
Dal programma selezionare il file RFLink.cpp.hex e verificare che Arduino sia correttamente riconosciuto dal programma, quindi lanciare la scrittura.

Al termine della scrittura del firmware verremo informati dal messaggio “programming successful”
Durante le prove sono stati riscontrati dei problemi col caricamento del firmware perchè RFLink Loader esegue un altro file exe chiamato avrdude.exe Per ovviare a questo problema è stato eseguito il programma RFLink Loader come amministratore.

Ricevere i messaggi radio

Una volta caricato il firmware, se abbiamo collegato bene il ricevitore, il trasmettitore e Arduino al PC, possiamo usare sempre il programma RFLink Loader per vedere i primi messaggi dai nostri dispositivi.

E qui si apre un mondo!

Per concludere

Il progetto RFLink è gratuito ma come abbiamo visto richiede molto impegno. Va considerata anche solo una piccola donazione al team di sviluppo in modo da sostenerli.

Se vi è piaciuto l’articolo non esitate a condividerlo sui social! Iscrivetevi alla pagina facebook e twitter di Ciaobit.com!

L'articolo RFLink Gateway e Arduino Mega2560: trasmettere e ricevere a 433Mhz proviene da ciaobit.com.

Cos’è il Bitcoin?

Il Bitcoin è una criptovaluta, ovvero una moneta digitale/virtuale/elettronica che permette lo scambio di beni e servizi attraverso la rete.
Il simbolo associato a questa moneta virtuale è ₿ mentre nei siti di cambio valuta è conosciuto con il codice BTC.

Cos’è una criptovaluta?

Una criptovaluta è composta da una serie di algoritmi (programmi informatici) basati sulla crittografia che permettono di validare e gestire in maniera sicura le transazioni tra individui.
Gli algoritmi prevedono sistemi anti contraffazione e anti DDOS (attacchi volti a negare il normale servizio).
La gestione delle transazioni si basa su reti di computer distribuite e decentralizzate (Peer 2 Peer), ciò significa che non esiste un server centrale che gestisce tutto (e che può essere spento).
Ogni nodo della rete P2P contribuisce a mantenere e validare la catena e le transazioni della moneta virtuale

Quali sono le differenze e le analogie tra una criptovaluta e una moneta tradizionale?

Come per le monete tradizionali, le criptovalute devono essere in grado di assolvere tre requisiti tipici:

• riserva di valore: ovvero è possibile risparmiare parte del reddito oggi e usarlo in un secondo momento futuro
• unità di conto: la moneta deve essere uno strumento di misura delle transazioni economiche
• mezzo di scambio: la moneta viene usata per acquisti di beni e servizi

Una delle più grandi differenze tra una moneta tradizionale e una criptovaluta è quella di essere decentralizzata, ovvero non gestita da una banca centrale o da uno stato.

Dove mettere i bitcoin? Il wallet/portafoglio virtuale

I bitcoin, come le altre criptomonete, hanno bisogno di un portafoglio (detto anche in inglese wallet) dove vengono mantenute le chiavi per trasferire denaro virtuale.
Più precisamente il portafoglio non è altro che un software che colleziona e tiene al sicuro delle chiavi crittografiche pubbliche e private.
Le chiavi pubbliche servono per dimostrare la legittima proprietà del bitcoin al momento della transazione.
Le chiavi private invece (che devono essere custodite gelosamente) servono per firmare/autorizzare i pagamenti.
Perdere queste chiavi significa perdere la possibilità di eseguire transazioni, quindi di fatto si perdono i bitcoin associati a questo portafoglio (un pò come perdere il portafoglio per strada).
Farsi rubare queste chiavi significa dare la possibilità a terzi di fare acquisti con il nostro portafoglio (l’equivalente di un furto o uno scippo).

Come proteggere il proprio wallet bitcoin

Come anticipato precedentemente, i problemi più comuni sono la perdita dei dati, dovuti ad esempio dalla rottura del dispositivo che contiene il portafoglio (hard disk, chiavetta usb, cellulare..) e al furto delle chiavi.
Per ovviare a questi problemi è possibile creare dei backup del portafoglio e cifrare a sua volta il portafoglio (un pò come metterlo in cassaforte).

Portafoglio bitcoin cartaceo

Può suonare strano ma è possibile creare dei portafogli cartacei per monete virtuali. Esistono dei software che generano delle chiavi private e pubbliche stampabili. Essendo chiavi composte da stringhe di lettere e numeri molto lunghe, viene fornita una versione QRCode dei codici, che si scannerizzano con il cellulare in pochi attimi.

Comprare bitcoin

E’ possibile entrare in possesso di bitcoin vendendo dei beni o servizi in cambio di criptovaluta oppure attraverso dei siti che effettuano cambio Euro/bitcoin e viceversa.
Questi siti di scambio si chiamano per l’appunto Exchange.
Il valore del bitcoin rispetto all’euro è dato dalla domanda e dall’offerta che muta in continuazione.
Attualmente il valore del bitcoin è molto altalenante, entrano in gioco variabili come ad esempio:

• le moderazioni degli stati come l’America, Cina, Russia..
• Il numero e la mole dei venditori che accettano questo metodo di pagamento
• le dichiarazioni dei media o più in generale la percezione che hanno gli internauti titolari della criptovaluta.

Ma questo articolo vuole incentrarsi su come funzionano a livello informatico i bitcoin e più generalmente le criptovalute. Non è certo nostra intenzione entrare in argomenti di finanza e politica che per quanto affascinanti non ci competono.

Quali sono le alternative al bitcoin?

Di criptovalute se ne ipotizzava già l’uso nel 1998, tuttavia il bitcoin è stato teorizzato nel 2008 e lanciato nel 2009 ed è stata la prima criptovaluta con un successo a livello globale. Da allora sono nati diverse criptovalute ispirate più o meno al bitcoin. Ad esempio troviamo:

• l’Ethereum
• Litecoin
• Ripple

L'articolo Bitcoin: cos’è e come funziona una criptovaluta proviene da ciaobit.com.

L'articolo ublox 6 proviene da ciaobit.com.

Il Protocollo NMEA 2000

Il protocollo NMEA 2000, conosciuto anche con le abbreviazioni NMEA2k o N2K permette di definire uno standard per la comunicazione seriale, plug and play e bidirezionale tra dispositivi di tipo marino che sfruttano lo stesso protocollo come ad esempio alcuni sensori di temperatura, rilevatori di intensità e direzione del vento, ma anche motori, plotter cartografici, display e cosi via.

Principali caratteristiche elettriche del protocollo NMEA 2000

Dal punto di vista elettrico, il protocollo NMEA 2000, è compatibile con il bus CAN (chiamato “CAN bus”). Il CAN bus è utilizzato anche negli autoveicoli comuni. Le auto infatti hanno un sistema di autodiagnostica chiamato OBD-II (On-Board Diagnostic 2) o EOBD (European On-Board Diagnostics) che permette al motore,alle centraline e i dispositivi compatibili di scambiarsi informazioni.

Grazie all’adozione del CAN bus, il nuovo protocollo NMEA 2000 permette una connessione multi-trasmettitore e multi-ricevitore. Con il vecchio protocollo NMEA 0183 invece la rete di dispositivi poteva essere composta da un solo talker (trasmettitore di messaggi) e diversi listeners (ricevitori). Per ampliare questa rete bisognava passare attraverso dei multiplexer che si occupavano di instradare in modo corretto i pacchetti, evitando che più di un talker trasmettesse contemporaneamente creando una “collisione” di messaggi.

Anche il protocollo NMEA 2000, come il precedente 0183, si avvale di una comunicazione seriale di tipo differenziale, questa tecnica permette di ottenere un’alta immunità alle interferenze e questo si traduce non solo in affidabilità ma anche nell’opportunità di aumentare la lunghezza massima del bus di comunicazione pur mantenendo una discreta velocità di trasmissione.

Infatti, il protocollo NMEA 2000, ha una velocità di comunicazione seriale fissa a 250Kbps (50 volte più veloce del protocollo NMEA 0183). La lunghezza massima del bus si attesta a 200 metri.

Nomi e connettori diversi

Diverse case costruttrici hanno creato degli standard proprietari che sono compatibili con il protocollo NMEA 2000 in quanto sono praticamente la stessa cosa ma con un nome e connettore diverso. Qualche esempio trovato in rete: Simrad Simnet, Raymarine SeaTalk 2 e SeaTalkNG, Furuno CAN.

Il connettore “originale” adottato per i collegamenti NMEA 2000 è il DeviceNet Micro-C M12 5-pin

Il Pinout NNEA 2000

Il connettore ha 5 pin:

• Due sono riservati alla linea dati seriale NET-H (o CAN-H) e NET-L (o CAN-L)
• Due sono utilizzati per l’alimentazione VCC (12V) e GND
• Uno è la calza che avvolge gli altri fili.

Come precedentemente accennato la dorsale mette a disposizione due fili per l’alimentazione e quindi può alimentare direttamente i dispositivi. Un pò come la POE in una rete ethernet cablata. Ci sono due versioni di spessore del cavo, quella fina () supporta una corrente masima di 3A, mentre quella con i fili più spessi () supporta 8A

La Backbone

Tutti i dispositivi certificati NMEA2000 sono collegati assieme attraverso una backbone (dorsale).

I resistori di terminazione

Ai capi della backbone, vanno messi dei terminatori. I terminatori contengono al loro interno una resistenza da 120Ω.

Messaggi

Salendo a livello di messaggistica, sappiamo che l’NMEA 2000 si basa a sua volta sul protocollo SAE J1939 e ISO 11783 che descrivono la sintassi dei messaggi. Ancora una volta abbiamo uno standard in comune con il comparto automobilistico.

L'articolo NMEA 2000: Cos’é e come funziona proviene da ciaobit.com.

Il Protocollo NMEA 0183

Il protocollo NMEA 0183 è uno standard di comunicazione usato dai GPS per comunicare i dati di posizione e tempo, ma anche in applicazioni nautiche per condividere con vari strumenti le informazioni come ad esempio la velocità dell’imbarcazione, la profondità del fondale o la posizione e il nome delle imbarcazioni limitrofe.
Lo standard è stato sviluppato dal National Marine Electronics Association, una associazione fondata nel 1957 da costruttori di dispositivi elettroci in ambito navale. La prima versione del protocollo risale a marzo 1983, successivamente è stata migliorata ed ampliata negli anni.
Attualmente l’ultima versione è la 4.1 che ha introdotto ad esempio, le sentence (stringhe propriamente codificate) per il sistema di posizionamento Galileo e l’AIS (Automatic Identification System) ovvero il sistema di identificazione automatica comunemente conosciuto come transponder.

Un solo talker, uno o più listners

Il protocollo NMEA 0183 prevede che un solo dispositivo, detto talker, possa trasmettere dati, tutti gli altri dispositivi invece, detti listeners, possono esclusivamente riceverli. Per combinare più talkers assieme, come ad esempio un GPS, un anemometro, un ricevitore AIS, è necessario collegare questi dispositivi a un Multiplexer (o combinatore) che gestisce in input queste informazioni e le serializza in modo che non vi siano conflitti di trasmissione simultanea.

Il multiplexer può fare solo da “tramite” dei messaggi oppure li può filtrare o definirne una priorità maggiore. Un altra funzionalità di alcuni modelli è quella di convertire i segnali Nmea 0183 in segnali a velocità maggiore (es. NMEA 0183-HS che introdurremo più avanti) o cambiare proprio mezzo e protocollo passando a segnali come ad esempio NMEA 2000, Wifi, Ethernet,Bluetooth, Usb.

Principali caratteristiche elettriche del protocollo NMEA 0183

A livello elettrico, la comunicazione è di tipo seriale asincrona monodirezionale. La velocità di trasmissione è definita a 4800bps (bit al secondo), 8 bit di dati, un bit di stop e nessun bit ne di parità ne di handshaking. (comunemente conosciuto come 8N1)

Prima della versione 2.0 dello standard (rilasciata nel 1992) l’interfacciamento è stato di tipo “single ended” e richiede due fili:

• Una linea di trasmissione (TX)
• Un riferimento a massa (GND)

I dispositivi costruiti prima della versione 2.0 del protocollo rilevano gli uni e gli zeri in riferimento alla differenza di tensione che c’è tra il filo TX e il GND

Dalla versione 2.0 in poi invece il protocollo passa da una connessione “single ended” RS232, più sensibile ai disturbi, ad una connessione “double ended” basata sullo standard RS422.

Lo standard RS422 utilizza tre fili (A, B e GND). Due fili (A e B) sono adibiti alla trasmissione e uno (GND) fa da riferimento comune a massa. La trasmissione mediante una coppia di fili permette di implementare un invio differenziale dei segnali elettrici. Questa modalità di trasmissione permette di ottenere una alta immunità ai disturbi permettendo collegamenti a 1200m di distanza ad una velocità di 100Kbps.

Interfacciamento a 3 fili.

• TxD (B) +
• TxD (A) –
• Un riferimento a massa (GND)

Dalle informazioni reperite sul web, sembra possibile collegare dispositivi con segnali TTL a due fili “single ended” con dispositivi a tre fili “double ended” collegando il TX alla linea RxD B +

NMEA 0183 e NMEA 0183-HS

Dalla terza versione, definita nel 2001, è stata introdotta una variante del protocollo ad alta velocità, chiamata NMEA 0183-HS (dove “HS” stà per “high speed”). La sostanziale differenza rispetto alla versione Nmea 0183 è la velocità di comunicazione che passa da 4800bps a 38400bps.

La sintassi delle frasi (sentence)

I dispositivi comunicano attraverso delle frasi (dette sentence).
Le frasi sono limitate a 80 caratteri e hanno i rispettivi caratteri di inizio e fine messaggio.
I parametri del messaggio sono delimitati dal carattere virgola e l’ultimo parametro è un codice di verifica della trasmissione preceduto da un asterisco “*”.

Riassumendo abbiamo:

• Inizio messaggio: $
• Delimitatore: carattere virgola “,”
• Delimitatore Checksum “*”
• Fine messaggio: CR LF

L’indirizzo della frase

Il primo parametro racchiuso tra l’inizio messaggio e la prima virgola è l’indirizzo della frase e specifica la natura del talker.
L’indirizzo è a sua volta composto da due elementi:

• due lettere che identificano il talker (Es. Gps, Bussola..)
• tre lettere che identificano il messaggio specifico del talker.

Il controllo d’errore (checksum)

L’ultimo parametro è il checksum e serve per verificare che il messaggio sia privo da errori. Il checksum è racchiuso tra un carattere asterisco “*” e il  CR LF (ovvero il ritorno di carrello e nuova linea).
Il checksum è composto da due caratteri alfanumerici ed è calcolato tramite l’algoritmo Exclusive OR a 8 bit

Seguono alcuni esempi di messaggi catturati dal GPS del telefonino:

$GLGSV,2,2,07,84,16,144,14,85,71,153,31,71,45,229,25*5A
Descrive il numero di satelliti GLONASS e la loro posizione

$GPGSA,A,3,01,03,08,10,11,14,17,22,23,27,28,32,1.0,0.7,0.7*34
Descrive i satelliti usati oer il punto, se quest’ultimo è 2D o 3D e la relativa accuratezza

$GPVTG,,T,,M,0.0,N,0.0,K,A*23
Descrive velocità e direzione

$GPRMC,155902,A,4501.502642,N,01434.102644,E,0.0,,150817,1.2,E,A*36
Fornisce l’ora UTC, in questo caso sono le ore 15:59:02. la “A” indica che il fix è valido e la posizione espressa in DD mm.mmmm è  45°01.502642N e 14°34.102644E. é presente la velocità e la direzione, la data (in questo caso 15/08/2017) e la variazione magnetica.

$GPGGA,155902,4501.502642,N,01434.102644,E,1,12,0.7,15.0,M,44.0,M,,*78
Anche questa frase fornisce informazioni sull’ora e la posizione, ma a differenza del messaggio precedente qui abbiamo informazioni sull’altezza e un calcolo del possibile errore della posizione

L'articolo NMEA 0183: Cos’è e come funziona proviene da ciaobit.com.

In questo articolo vedremo come installare in pochi semplici passaggi OpenHab 2 su RaspberryPi2 oppure RaspberryPi 3.
In rete, è possibile scaricare l’immagine openHABianPi.  openHABian è un’ immagine basata sul sistema operativo linux Debian e incorpora OpenHab 2 preinstallato.

Funzionalità incorporate nell’immagine openHABianPi

Oltre ad incorporare l’ultima versione di OpenHab2, nell’immagine openHABian troviamo preinstallato:

• OpenJDK Java8
• Un tool di aggiornamento chiamato openHABian Configuration Tool
• Diversi pacchetti come ad esempio vim, htop, nano.
• Un tool per analizzare i log (chiamato openHAB Log Viewer)
• Samba per condividere file e cartelle con Windows
• Mosquitto, per collegare alcuni dispositivi che usano questo protocollo per comunicare il proprio stato o azione.

Mosquitto infatti, gestisce il protocollo di comunicazione MQTT, usato per esempio dallo script CiaobitHome per comunicare bidirezionalmente con OpenHab2 i cambiamenti di temperatura, umidità, luminosità, presenza, ecc..

Scaricare e installare openHABianPi su Raspberry Pi3

L’installazione è semplicissima, per prima cosa va scaricata l’ultima immagine disponibile seguendo questo link di GitHub:

https://github.com/openhab/openhabian/releases

1) Scrolliamo la pagina fino ad arrivare alla sezione Downloads dove troviamo diverse immagini scaricabili con estensione .xz. Va scelta quella per il RaspBerryPi3 come in figura.

2) Una volta scaricato il file in formato .xz, che è un formato compresso, deve essere scompattato in una cartella, ad esempio c:\immagine\

NOTA: Per scompattare un archivio con estensione xz è possibile usare programmi come WinRar, WinZip PeaZip o 7-Zip

3) Otterremo quindi un file tipo: openhabianpi-raspbian-201706161358-git7ff273e-crc00389b9f.img

4) Per caricare l’immagine nella schedina MicroSD, abbiamo bisogno di scaricare ed installare un tool chiamato Win32 Disk Imager, scaricabile gratuitamente. Avviamo quindi Win32 Disk Imager e inseriamo la MicroSD nel pc.
Verifichiamo bene quale sia la lettera dell’unità che Windows associa alla MicroSD. Avviando la scrittura, ogni dato all’interno della schedina verrà cancellato!

Dal programma WIn32 Disk Imager, selezioniamo l’immagine, selezioniamo la lettera dell’unità che vogliamo scrivere (La MicroSD!) e avviamo la scrittura cliccando sul bottone “Scrivi”.

5) Terminata l’operazione di scrittura, scolleghiamo la schedina MicroSD dal computer per inserirla nel RaspBerryPi3

6) Colleghiamo al RaspBerryPi3 anche il cavo di rete, una tastiera e un monitor, cosi una volta acceso, potremo seguire lo scaricamento e l”installazione dei pacchetti aggiornati.

7) Alimentiamo il RaspBerryPi3 e seguiamo la procedura d’installazione che durerà tra i 15 e 45 minuti.

Al termine dell’installazione vedremo una schermata che suggerisce l’inserimento delle credenziali d’accesso a OpenHABianPi

Le credenziali di default sono:

USERNAME: openhabian
PASSWORD: openhabian

Una volta entrati si vedrà una schermata con diverse info di riepilogo, come ad esempio l’ip della board.

Consiglio vivamente di cambiare subito la password per questo utente, specialmente se intendiamo rendere accessibile il nostro RaspBerry dall’esterno della rete domestica. Per quanto riguarda invece l’ip, sarebbe meglio impostarlo statico a livello di modem (o dove risiede l’eventuale server DHCP), questo perchè così facendo è possibile aprire le porte verso la rete esterna e quindi accedere ad OpenHab da remoto.

8) ora è possibile accedere all’interfaccia web di OpenHab attraverso l’indirizzo locale http://openhabianpi:8080 oppure più genericamente via ip.

Attraverso questo indirizzo http://openhabianpi:9001 invece è possibile accedere ai log di OpenHAB.

Se si vuole accedere alla condivisione di rete windows (Samba), è possibile farlo da questo indirizzo: \\openhabianpi\

Ora che il sistema è installato non resta che passare alla configurazione, che sarà argomento di un altro articolo.

Ciaobit.com è un progetto gratuito, se ti è piaciuto l’articolo, aiutaci condividendolo con tutti i mezzi come ad esempio Facebook , Twitter, Email! Grazie!

L'articolo Installare OpenHab 2 su RaspberryPi 3 con openHABianPi proviene da ciaobit.com.