Arduino tutorial; primi passi

[Edgardo_Rosatti]

ARDUINO TUTORIAL, PRIMI PASSI.

Premessa:
Questo tutorial è dedicato a chi di elettronica non ne capisce un tubo.

Benvenuti !
In questo tutorial cercheremo di apprendere il funzionamento di Arduino per iniziare ad usarlo in maniera semplice.
La conoscenza dell’elettronica non è necessaria, ma è fortemente consigliato apprenderne i fondamenti per poter utilizzare al meglio la piattaforma Arduino.

In questo tutorial non si parla nello specifico dei tecnicismi dei singoli microcontrollori intesi come circuiti integrati, ma delle schede a microcontrollore di tipo Arduino/Genuino e del suo ambiente di sviluppo IDE che è bassato sul linguaggio C++.

In particolare, con questo tutorial, si vuole fornire a coloro che non conoscono l’elettronica, ma che vogliono conoscerne i principi fndamentali di funzionamento, alcune informazioni di base per l’uso della piattaforma Arduino.

Sovente mi è capitato di senitre di persone che hanno acquistato un kit Arduino primi passi o semplicemente una scheda Arduino, ma poi, scoraggiati, vedere che non hanno mai messo in pratica nessun esperimento o prova in tal merito.

Ecco, questo tutorial è rivolto proprio a voi; ora non avete più scuse!

Scherzi a parte, partiamo subito a descrivere brevemente cosa è Arduino.
Arduino è una piattaforma basata su microcontrollore e per il suo funzionamento è necessario un PC con il suo software IDE o ambiente di sviluppo.

Per “piattaforma”, si intende una scheda elettronica contenente tutti i componenti in grado di funzionare come un sistema operativo semplice.
Esistono diversi modelli di Arduino per venire inconrto alle esigenze delle applicazioni più disparate.
La più nota è Arduino UNO (chiamata ultimamente Genuino).
Tra le altre versioni disponibili vi sono: Arduino NANO; Arduino MICRO; Arduino MEGA e Arduino LILYPAD.
Le differenze tra una versione e l’altra sono le dimensioni della scheda, la capacità di gestione delle porte di I/O e l’ambiente di utilizzo.

In questo tutorial, parleremo prevalentemente di Arduino UNO o di Arduino NANO.

IDE:
L’IDE è l’ambiente di sviluppo (in inglese Itregrated Development Enviroment), oppure ambiente integrato di progettazione, cioè il software di gestione/programmazione delle schede Arduino.

Tale software non è compreso nei kit in vendita di Arduino.
Maggiori informazioni sull'ambiente di sviluppo possono essere scaricate qui dal sito ufficiale:
https://www.arduino.cc/
Da qui cliccare su “software/downloads”
https://www.arduino.cc/en/Main/Software
e scaricare la versione dell’IDE relativa al vostro sistema operativo.

Ora che abbiamo l’IDE possiamo collegare la nostra scheda Arduino ad una porta libera USB e lanciare il software IDE.

Al suo primo avvio, l’IDE apparirà così:

In basso a destra è visualizzata la porta COM utilizzata nel collegamento USB Arduino PC.

In alto è visualizzato il nome dello sketch assegnato di default al programma; nel mio caso è sketch_nov11.
Nella parte bianca è visibile il codice sorgente.
Questa zona è un editor di testo dove viene scritto il software vero e proprio (programma).

Uno sketch, in gergo è un programma che verrà caricato nella scheda per poter essere eseguito sempre, cioè anche quando Arduino non è collegato al PC ma è alimentato da corrente elettrica.
La parte nera sottostante è un’area di informazione dell’ambiente di sviluppo verso il programmatore. Cioè è una zona dove vegono visualizzati eventuali messaggi di errore o informazione dell’IDE.

Se trovate qualche incongruenza, riavviate il sistema o postate i vostri quesiti qui per cercare di risolverli. Vi risponderemo nel limite del possibile.

Come verificare che Arduino sia collegato correttamente ad una porta USB del PC.
In Windows 10 aprire le impostazioni (ingranaggio) e nel campo di ricerca srivere “hardware”.
Successivamente, nei risultati della ricerca scegliere “Gestione dispositivi”.

Nel mio caso, Arduino è collegato alla porta COM3 ed usa un driver CH340. Va bene!

Ora apriamo l’IDE e carichiamo il programma dimostrativo “Blink”; lo trovate in “File/Esempi/01.Basics”.
Nota, in questo menù trovere molti esempi pronti all’uso per usare e testare diversi dispositivi.
Quello che faremo adesso è gestire semplicemente l’accensione e lo spegnimento di un led.
Per ora non collegheremo nessun led ad Arduino, in quanto per questo esperimento sfrutteremo un led presente a bordo della scheda. Tale led è collegato alla porta digitale di I/O numero 13.

Una porta di I/O è un pin in grado di gestire un segnale elettrico in entrata (IN) o in uscita (OUT).
In caso di uscita (OUT), se la porta è di tipo digitale avremo due soli possibili stati logici; HIGHT e LOW, oppure 1 e 0, oppure alto e basso.
In Arduino, ma anche in molti altri dispositivi, lo stato logico HIGHT corrisponde a una tensione elettrica di 5 Volt in CC. Mentre uno stato logico LOW corrisponde ad un livello di tensione pari a 0 Volt.
In caso di porta di entrata (IN), abbiamo la possibilità di leggere lo stato logico della porta quando sulla stessa vengno o meno applicati 5 Volt per avere un valore HIGHT o 0 volt per un valore LOW. In pratica, una porta IN di entrata digitale legge la condizione vero o falso di un interruttore.

Ora vedremo solo il funzionamento della porta 13 in modalità OUT.
Il comando o istruzione del programma per definire la modalità di funzionamento della porta è:
“pinMode”(numeroporta,tipo)
che nel nostro caso sarà:

pinMode(LED_BUILTIN, OUTPUT);

pinMode è il comando,

LED_BUILTIN è la porta 13 che è collegata al led a bordo di Arduino,

OUTPUT è la modalità di funzionamento della porta.

Questo comando è inserito in una procedura chiamata “setup”, la quale viene eseguita una sola volta all’avvio del programma od ogni qualvolta viene resettata la scheda Arduino.

Nel listato abbiamo anche dei commenti indicati da una doppia slash, cioè “//” per i commenti brevi.
Oppure “/*” commento “*/” per i commenti lunghi.

Questo è un commento lungo:
/*
Blink

Turns an LED on for one second, then off for one second, repeatedly.

Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO
it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to
the correct LED pin independent of which board is used.
If you want to know what pin the on-board LED is connected to on your Arduino
model, check the Technical Specs of your board at:
https://www.arduino.cc/en/Main/Products

modified 8 May 2014
by Scott Fitzgerald
modified 2 Sep 2016
by Arturo Guadalupi
modified 8 Sep 2016
by Colby Newman

This example code is in the public domain.

http://www.arduino.cc/en/Tutorial/Blink
*/

Questo è un commento breve:
// the setup function runs once when you press reset or power the board

Questa è la procedura di setup:
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
}

I commenti servono al programmatore per tenere memoria del proprio lavoro e per avere dei riferimenti durante la scrittura di un programma.
Saper gestire bene i commenti sarà sicuramente utile nel lavoro di programmazione ed aiuterà altri programmatori a capire bene il nostro programma.

Le procedure:
Una procedura viene sempre avviata con il comando “void”, la cui sintassi è:
void nomeprocedura() {
linee di codice….
linee di codice….
linee di codice….
}

Ogni procedura è raggruppata tra due parentesi graffe al cui interno vi sono i comandi relativi alla procedura stessa.

“nomeprocedura” è il nome assegnato alla procedura. Esso può essere di default (setup e loop) oppure arbitrario quando intendiamo scrivere una routine che funzioni in modo indipendete se evocata.

Per ora vediamo le due procedure più importanti che sono “setup” e “loop”.
“setup” l’abbiamo vista poco sopra e ci consente di definire eventi di impostazione, come l’uso elle porte o altro.
“loop” invece è una procedura che verrà ripetuta all’infinito fino a quando non spegneremo Arduino.
Il pulsantino di reset presente sulla scheda interromperà il funzionamento della scheda, così come un eventuale comando di uscita presente nella procedura di “loop”.
Comprendere bene queste caratteristiche è importante per poter gestire al meglio la nostra scheda Arduino.

Andiamo avanti quindi con il programma “Blink”.
// the loop function runs over and over again forever
void loop() {
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
Queste linee di codice introducono due nuovi comandi:

“digitalWrite” e “delay”

“digitalWrite” invia un comando di srittura sulla porta di I/O LED_BUILTIN di tipo HIGHT, cioè accende il led presente sulla scheda.

“delay(1000);) attende mille millisecondi, cioè un secondo.

Arduino è molto preciso con i tempi!!!

Il secondo comando “digitalWrite” invia un comando di srittura sulla porta di I/O LED_BUILTIN di tipo LOW per spegnere il led.

“delay(1000);) attende mille millisecondi, cioè un secondo come sopra.

A questo punto il loop (void) si ripeterà all’infinito.

Il risultato sarà che il led presente sulla scheda Arduino lampeggierà con una frequenza di un secondo.

OK, fino ad ora abbiamo visto come funziona un programma molto semplice, ma non abbiamo ancora programmato Arduino veramente.

Per farlo non dobbiamo fare altro che premere il pulsantino con la freccia destra in alto nell’IDE:

InkedProg_LI.jpg (13.11 KiB) Visto 7302 volte

Prima però modifichiamo il tempo di lampeggio all’interno del comando “delay” e sostituiamo 1000 con 100:

delay(100);

In questo modo, la frequenza di lampeggio sarà di un decimo di secondo.
Come noterete, ora il led presente sulla scheda Arduio lampeggerà molto più velocemente.

Dopo aver premuto il tasto evidenziato nella figura sopra, l’ambiene di sviluppo ha compilato il programma per inviarlo alla scheda Arduino collegata al PC. Se tutto è andato bene, deve aver inoltrato un messaggio nell’area nera nella parte sottostante della finestra tipo:

Lo sketch usa 928 byte (2%) dello spazio disponibile per i programmi. Il massimo è 32256 byte.
Le variabili globali usano 9 byte (0%) di memoria dinamica, lasciando altri 2039 byte liberi per le variabili locali. Il massimo è 2048 byte.

Tale area è chiamata anche “area di debug” e serve per capire se la compilazione del codice è andata a buon fine.

Prima di terminare questo tutorial introduttivo sull’uso di Arduino, vorrei parlare delle variabili. Le variabili, in programmazione sono molto importanti, perchè ci permettono di gestire I dati del programma in modo pratico.

Esistono diversi tipi di variabili; esse possono essere definite prima della procedura di “setup” scrivendo semplicemente il tipo e la sua etichetta. L’etichetta è definita dall’utente.

Per esempio, nel programma “Blink”, potremmo sostituire il numero fisso tra parentesi tonde dopo ilcomando “delay” con una variabile numerica intera che chiameremo “millisecondi” in questo modo:

Prima di “setup” inseriamo:

int millisecondi=1000; //periodo di lampeggio

In questo modo abbiamo creato una variabile numerica inera con assegnato il valore 1000.

Ora useremo questa variabile all’interno del comando “delay” nel seguente modo:
delay(millisecondi);

Qui sotto il listato aggiornato con l’inserimento della variabile intera numerica “millisecondi”.

Ora lascio a voi il compito di sperimentare l’inserimento di diversi dati e/o variabili.

Ovviamente, questo primo tutorial non ci permetterà di sfruttare al meglio tutte le potenzialità di Arduino, però spero tanto che abbia stimolato opportunamente le vostre sinapsi per poter proseguire con questo lavoro.

Fatemi sapere se questo tutorial vi piace o meno.
Io confido anche nella collaborazione di iscritti a questo forum che conoscono Arduino, I quali potranno solo essere di un aiuto prezioso e che sicuramente correggeranno I miei immancabili errori

Grazie a tutti per la pazienza.

[MrPatato76]

Ottimo tutorial.
Spero sia la prima puntata di tante!

[liftman]

mi accodo a Roberto, Un tutorial su Arduino è il benvenuto, ci ho pensato tante volte a prenderne uno per pasticciare, ma non ho mai avuto il tempo/coraggio per farlo. Grazie a te per l'impegno, noi a metterci la pazienza ci mettiamo un attimo

[Edgardo_Rosatti]

Grazie, comunque si, è mia intenzione fare diversi interventi mantenendo però una certa semplicità nella descrizione degli argomenti che verranno trattati e che saranno via via sempre meno banali.

[piepand]

Grazie anche da parte mia per questo tutorial molto interessante.

[dynahshow]

Finalmente qualcosa di rapido ed efficace. Ero uno di quelli che aveva rinunciato...ora ricomincerò. Ti seguo con molta attenzione.

[v200]

Grazie Ed per questo lavoro, oltre al neofita torna utile anche a chi qualcosina sa per un ripasso in vista di futuri lavori

[Edgardo_Rosatti]

Molto bene, grazie ancora a tutti per l'incoraggiamento.
Proseguiamo con il tutorial inserendo nuovi argomenti.

FRITZING:

Fritzing è un software open source che integra un editor grafico per la creazione di progetti con Arduino o PICAXE. Inoltre contiene un editor di schemi elettrici, uno di circuiti stampati e un IDE per la programmazione del codice.
Per scaricarlo andare qui: http://fritzing.org/home/

Sito web di Fritzing

Al suo avvio avremo una finestra come questa cliccando su "Breadboard":

Breadboard

Ho introdotto questo software, perchè è molto pratico per mostrare schemi elettrici che fanno uso della piattaforma Arduino ed è quello che userò per realizzare i disegni che man mano verrano proposti in questo tutorial.

Accendiamo un LED RGB:
Un LED RGB è un diodo LED in grado di riprodurre tutto lo spettro dei colori disponibili in natura e per gestirlo con Arduino è necessario utilizzare le porte di uscita analogiche PWM.
In realtà, le uscite PWM non sono delle vere e proprie porte di uscita analogiche, ma si avvicinano molto come risultato di funzionamento.
PWM sta per Pulse With Modulation, cioè modulazione con impulsi.

Arduino UNO contiene al suo inteno sei porte di uscita PWM (3,5,6,9,10 e 11) e per gestire un LED RGB ne servono tre; una per il colore rosso, una per il verde ed una per il blu.

In questo disegno è mostrato come collegare il led RGB ad Arduino:

LED_RGB

Nel mio caso ho utilizzato un LED a catodo comune, cioè con il polo negativo in comune che qui è collegato al pin GND (ground).
Gli anodi R, G e B sono visibili con I fili di colore rosso, verde e blu e sono collegati rispettivamente con i pin PWM 11, 10 e 9 di Arduino. Come potete notare, i pin PWM su Arduino sono contrassegnati da una S ruotata di 90°.

Nello schema sono presenti 3 resistenze da 220 OHM necessarie all’alimentazione corretta del LED. Il loro valore andrebbe rivisto, in quanto ogni anodo colore del led RGB ha una caduta di tensione diversa. Tuttavia, in questo esperimento possiamo ignorare questo dettaglio.

Vediamo ora come funziona una uscita PWM.
In una uscita PWM, abbiamo un treno di impulsi di tensione che si susseguono molto velocemente tra loro. Volendo rappresentare questi impulsi su un grafico avremo una cosa del genere:

Onda quadra con duty cycle del 50%

Onda_quadra.png (10.64 KiB) Visto 7224 volte

La larghezza di questi impulsi è pari al 50% della lunghezza d’onda ed in questo caso si dice che il segnale PWM ha un “Duty Cycle” del 50%.

In questa immagine è possibile vedere lo stesso segnale con Duty Cycle diversi:

Variazione del duty cycle (PWM)

pwm1.gif (2.33 KiB) Visto 7224 volte

In pratica abbiamo che con un Duty Cycle dello 0% sull’uscita PWM vi saranno 0 Volt.
Con un Duty Cycle del 50% ci saranno 2,5 Volt e con un Duty Cycle del 100% 5 volt.

In pratica, la tensione in uscita di una porta PWM è direttamente proporzionale alla percentuale del Duty Cycle e così anche la luminosità dei led.
Nota:
In Arduino, tutti i segnali elettrici variano da 0 a 5 Volt sia in ingresso che in uscita.
Possono avere valori inferiori inserendo una tensione di riferimento sul pin AREF, ma solo per gli ingressi analogici compresi tra A0 ed A5.

Quando si vogliono usare le uscite PWM, si devono impostare le porte con il comando “pinMode(pin,OUTPUT)”:
Dove “pin” è il numero del pin PWM e “OUTPUT” è la modalità di funzionamento della porta.
Per scrivere un valore di uscita in una porta PWM utilizzare il comando “analogWrite(pin,valore)”.
Dove “pin” è il numero della porta e “valore” è un numero compreso tra 0 e 255.
In pratica abbiamo una suddivisione della tensione in uscita in 256 parti che corrisponde ad una definizione di 8 bit.
Questo vuol dire che ogni frazione di tensione tra un bit e l’altro è pari a 0,0196078431372549 Volt (5 Volt diviso 255). Le parti sono 256 perchè in informatica lo zero conta e si somma al 255.
Quindi se scriviamo “analogWrite(9,100); avremo in uscita dal pin 9 PWM di Arduino circa 1,96 Volt.

Nota:
Per avere una guida di riferimento dei comandi di Arduino online (in inglese), utilizzare il menù “Aiuto/Guida di riferimento” nell’IDE.
In programmazione come in elettronica, la lingua di riferimento è l’inglese.

Nota:
Le uscite PWM possono essere utilizzate anche per variare la velocità dei motori elettrici o la posizione di un servomeccanismo angolare o lineare.

Il programma LED_RGB:

Codice: Seleziona tutto

/*
LED RGB
14/11/2019
Questo pogramma è scritto da Edgardo Rosatti per il tutorial "Primi passi" del GAS TT
*/

int pinrosso=11; int pinverde=10; int pinblu=9; //definizione delle variabili per assegnare i pin PWM ai colori del led
int rosso=0; int verde=0; int blu=0; //definizione dei valori dei singoli colori RGB "tutto spento"

// la procedura di setup verrà eseguita una volta soltano quando Arduino verrà alimentato o quando verrà premuto il pulsante RESET sulla scheda
void setup() {
  // initializzazione porte PWM 9, 10 e 11 come output.
  pinMode(rosso, OUTPUT);
  pinMode(verde, OUTPUT);
  pinMode(blu, OUTPUT);
}

// la procedura di loop verrà eseguita all'infinito
void loop() {
  // accendiamo il colore rosso
  rosso=255; verde=0; blu=0; // imposta le variabili colore per il rosso
  analogWrite(pinrosso,rosso);
  analogWrite(pinverde,verde);
  analogWrite(pinblu,blu);
  delay(1000); // attendi un secondo
  // accendiamo il colore verde
  rosso=0; verde=255; blu=0; // imposta le variabili colore per il verde
  analogWrite(pinrosso,rosso);
  analogWrite(pinverde,verde);
  analogWrite(pinblu,blu);
  delay(1000); // attendi un secondo
  // accendiamo il colore blu
  rosso=0; verde=0; blu=255; // imposta le variabili colore per il blu
  analogWrite(pinrosso,rosso);
  analogWrite(pinverde,verde);
  analogWrite(pinblu,blu);
  delay(1000); // attendi un secondo
  // accendiamo il colore bianco
  rosso=255; verde=255; blu=255; // imposta le variabili colore per il bianco
  analogWrite(pinrosso,rosso);
  analogWrite(pinverde,verde);
  analogWrite(pinblu,blu);
  delay(1000); // attendi un secondo
  // accendiamo il colore giallo
  rosso=255; verde=255; blu=0; // imposta le variabili colore per il giallo
  analogWrite(pinrosso,rosso);
  analogWrite(pinverde,verde);
  analogWrite(pinblu,blu);
  delay(1000); // attendi un secondo
  // accendiamo il colore viola
  rosso=255; verde=0; blu=255; // imposta le variabili colore per il viola
  analogWrite(pinrosso,rosso);
  analogWrite(pinverde,verde);
  analogWrite(pinblu,blu);
  delay(1000); // attendi un secondo
}

In questo programma definiamo sei variabili numeriche intere:
- pinrosso;
- pinverde;
- pinblu.
Per assegnare il numero delle porte PWM di Arduino.
Poi abbiamo le variabili numeriche intere:
- rosso;
- verde;
- blu.
Per assegnare il valore di intensità colore al LED nei rispettivi anodi rosso, verde e blu.

Tutto questo avviene all’inizio del programma e prima della procedura di setup.

Nella procedura di setup viene definita la modalità di utilizzo delle porte.

Nella procedura di loop vi sono una serie di comandi diretti per definire le variabili rosso, verde e blu, così da impostare un colore attraverso i comandi “analogWrite” per inviare i dati al LED.
I colori selezionati sono: rosso, verde, blu, bianco, giallo e viola.
Tra il cambio di un colore e l’altro vi sarà sempre una pausa di un secondo; “delay(1000); // attendi un secondo”


Il monitor seriale di Arduino.

Arduino è in grado di inviare i dati del progamma al PC, attraverso la porta di collegamento USB.
Tali dati possono essere visualizzati su di un monitor seriale che è possibile invocare dall’IDE.

Il comando per fare questa operazione è: “Strumetnti/Monitor seriale”.
Esiste anche il “Plotter seriale”, ma lo vedremo in seguito.
Monitor seriale e plotter seriale non possono coesistere contemporaneamente; o si utilizza uno o l’altro.

La finestra del monitor seriale è la seguente:

Serial monitor Arduino

Monitor_seriale.PNG (9.4 KiB) Visto 7224 volte

Ora vediamo, tramite lo stesso programma LED_RGB, come utilizzarlo.

Prima di tutto dobbiamo inizializzare la porta seriale con il comando:
“Serial.begin(9600);” all’interno della procedura di setup.

Poi per utilizzare il monitor seriale dobbiamo avvalerci del comando:
“Serial.println();” all’interno della procedura di loop ogni qualvolta vogliamo scrivere qualcosa.

“Serial.println();” stamperà quello che vogliamo all’interno della finestra del monitor seriale.
L’argomento da stampare dovrà essere incluso tra le parentesi tonde.

Il comando “Serial.print();” stampa semplicemente I dati in linea, mentre il comando “Serial.println();” aggiunge un “a capo” al testo stampato nel monitor seriale.

In questa immagine l’output del monitor seriale:

RGB data

Monitor_seriale_RGB.PNG (11.42 KiB) Visto 7224 volte

Ed il listato aggiornato LED_RGB_serial:

Codice: Seleziona tutto

/*
LED RGB_serial
14/11/2019
Questo pogramma è scritto da Edgardo Rosatti per il tutorial "Primi passi" del GAS TT
*/

int pinrosso=11; int pinverde=10; int pinblu=9; //definizione delle variabili per assegnare i pin PWM ai colori del led
int rosso=0; int verde=0; int blu=0; //definizione dei valori dei singoli colori RGB "tutto spento"

// la procedura di setup verrà eseguita una volta soltano quando Arduino verrà alimentato o quando verrà premuto il pulsante RESET sulla scheda
void setup() {
  // initializzazione porte PWM 9, 10 e 11 come output.
  pinMode(rosso, OUTPUT);
  pinMode(verde, OUTPUT);
  pinMode(blu, OUTPUT);
  // inizializzo la porta seriale:
  Serial.begin(9600);
}

// la procedura di loop verrà eseguita all'infinito
void loop() {
  // accendiamo il colore rosso
  rosso=255; verde=0; blu=0; // imposta le variabili colore per il rosso
  analogWrite(pinrosso,rosso);
  analogWrite(pinverde,verde);
  analogWrite(pinblu,blu);
  Serial.print("Rosso: "); // stampa i valori sul monitor seriale
  Serial.println(rosso);
  Serial.print("Verde: ");
  Serial.println(verde);
  Serial.print("Blu: ");
  Serial.println(blu);
  delay(1000); // attendi un secondo
  // accendiamo il colore verde
  rosso=0; verde=255; blu=0; // imposta le variabili colore per il verde
  analogWrite(pinrosso,rosso);
  analogWrite(pinverde,verde);
  analogWrite(pinblu,blu);
  Serial.print("Rosso: "); // stampa i valori sul monitor seriale
  Serial.println(rosso);
  Serial.print("Verde: ");
  Serial.println(verde);
  Serial.print("Blu: ");
  Serial.println(blu);
  delay(1000); // attendi un secondo
  // accendiamo il colore blu
  rosso=0; verde=0; blu=255; // imposta le variabili colore per il blu
  analogWrite(pinrosso,rosso);
  analogWrite(pinverde,verde);
  analogWrite(pinblu,blu);
  Serial.print("Rosso: "); // stampa i valori sul monitor seriale
  Serial.println(rosso);
  Serial.print("Verde: ");
  Serial.println(verde);
  Serial.print("Blu: ");
  Serial.println(blu);
  delay(1000); // attendi un secondo
  // accendiamo il colore bianco
  rosso=255; verde=255; blu=255; // imposta le variabili colore per il bianco
  analogWrite(pinrosso,rosso);
  analogWrite(pinverde,verde);
  analogWrite(pinblu,blu);
  Serial.print("Rosso: "); // stampa i valori sul monitor seriale
  Serial.println(rosso);
  Serial.print("Verde: ");
  Serial.println(verde);
  Serial.print("Blu: ");
  Serial.println(blu);
  delay(1000); // attendi un secondo
  // accendiamo il colore giallo
  rosso=255; verde=255; blu=0; // imposta le variabili colore per il giallo
  analogWrite(pinrosso,rosso);
  analogWrite(pinverde,verde);
  analogWrite(pinblu,blu);
  Serial.print("Rosso: "); // stampa i valori sul monitor seriale
  Serial.println(rosso);
  Serial.print("Verde: ");
  Serial.println(verde);
  Serial.print("Blu: ");
  Serial.println(blu);
  delay(1000); // attendi un secondo
  // accendiamo il colore viola
  rosso=255; verde=0; blu=255; // imposta le variabili colore per il viola
  analogWrite(pinrosso,rosso);
  analogWrite(pinverde,verde);
  analogWrite(pinblu,blu);
  Serial.print("Rosso: "); // stampa i valori sul monitor seriale
  Serial.println(rosso);
  Serial.print("Verde: ");
  Serial.println(verde);
  Serial.print("Blu: ");
  Serial.println(blu);
  delay(1000); // attendi un secondo
}

Infine vediamo come effettuare dissolvenze di colore utilizzando I cicli “for”.

Un ciclo “for” ci consente di incrementare o decrementare a nostro piacimento il valore di una variabile numerica.
Se all’interno di un ciclo “for” inseriamo i comandi di accensione del led e come argomento utilizziamo la variabile del ciclo, otteniamo una dissolvenza.
Un ciclo for è così strutturato:

Codice: Seleziona tutto

for (int x=0; x<256; x++) {
	println(x); // stampa i numeri da 0 a 255
}

I parametri del ciclo vengono definiti dopo il comado “for” tra parentesi tonde ed hanno il seguente significato:
- intx=0; è la definizione opzionale della variabile del ciclo che partirà da zero.

- x<256 ; è il limite massimo della variabile, o meglio è il numero che non dovrà mai essere raggiunto (x minore di 256).

- x++ è il fattore di incremento della variabile x, cioè ad ogni ciclo viene sommato uno ad x.

Infine, il contenuto tra le parentesi graffe sono i comandi che vengono ripetuti ad ogni ciclo, che nel nostro caso sono la stampa di una serie di numeri compresi tra 0 e 255.

Alla fine del ciclo il programma procede eseguendo i comandi successivi.

Nota sulle variabili:
Se una variabile viene definita prima delle procedure “setup” e “loop”, viene considerata variabile globale e può essere usata in tutte le procedure del programma.
Se una variabile viene definita all’interno di una procedura qualsiasi, viene considerata variabile locale e potrà essere usata solo all’interno della procedura relativa.

Le variabili numeriche possono essere di diverse categorie. Qui ne citiamo 3:
- numeriche intere corte (INT) o lunghe (LONG);
- numeriche in virgola mobile (FLOAT);
- tabelle di numeri (ARRAY).

Fare riferimento alla guida in linea per vedere i tipi di variabil e di costanti disponibili.

In questo programma possiamo vedere il LED RGB accendersi eseguendo diverse dissolvenze di colore:

LED_RGB_fade

Codice: Seleziona tutto

/*
LED RGB
14/11/2019
Questo pogramma è scritto da Edgardo Rosatti per il tutorial "Primi passi" del GAS TT
*/

int pinrosso=11; int pinverde=10; int pinblu=9; //definizione delle variabili per assegnare i pin PWM ai colori del led
int rosso=0; int verde=0; int blu=0; //definizione dei valori dei singoli colori RGB "tutto spento"

// la procedura di setup verrà eseguita una volta soltano quando Arduino verrà alimentato o quando verrà premuto il pulsante RESET sulla scheda
void setup() {
  // initializzazione porte PWM 9, 10 e 11 come output.
  pinMode(rosso, OUTPUT);
  pinMode(verde, OUTPUT);
  pinMode(blu, OUTPUT);
}

// la procedura di loop verrà eseguita all'infinito
void loop() {
  for (int x=0; x<256; x++) {
    analogWrite(pinrosso,x);    // accendiamo il colore rosso
    delay(10); // attende 10 millisecondi (ritardo)
  }
  for (int x=0; x<256; x++) {
    analogWrite(pinverde,x);    // accendiamo il colore verde
    delay(10); // attende 10 millisecondi (ritardo)
  }
  for (int x=0; x<256; x++) {
    analogWrite(pinblu,x);    // accendiamo il colore blu
    delay(10); // attende 10 millisecondi (ritardo)
  }
  for (int x=0; x<256; x++) {
    analogWrite(pinrosso,255-x);    // spegnamo il colore rosso
    delay(10); // attende 10 millisecondi (ritardo)
  }
  for (int x=0; x<256; x++) {
    analogWrite(pinblu,255-x);    // spegnamo il colore blu
    delay(10); // attende 10 millisecondi (ritardo)
  }
  for (int x=0; x<256; x++) {
    analogWrite(pinverde,255-x);    // spegnamo il colore verde
    delay(10); // attende 10 millisecondi (ritardo)
  }
}

In questa seconda parte del tutorial ho inserito i listati LED_RGB utilizzando la formattazione CODE /CODE offerta dal forum.
Per copiarli all'interno dell'IDE dovete aprirlo e cancellere l'eventuale listato presente. Poi selezionate "Seleziona tutto" qui sul forum nella parte alta della finestra del listato e incollatelo (ctrl v) all'interno dell'editor dell'IDE.

[v200]

Attenderò con ansia il paragrafo sui servi.

[Edgardo_Rosatti]

Attenderò con ansia il paragrafo sui servi.

L'uso dei servi con Arduino è legato alle librerie e verrà trattato sicuramente in un tutorial apposito.

Colgo l'occasione per chiedere a tutti coloro che conosco o hanno usato Arduino di intervenire senza paura sugli argomenti trattati.

Grazie

[Edgardo_Rosatti]

Sensori e porte di ingresso digitali.

In questa terza parte del nostro tutorial, introduciamo l’uso dei sensori digitali e delle porte di ingresso digitali di Arduino.

Tutti i pin digitali compresi tra D0 e D13 (14 in totale) oltre che essere utilizzati come uscite digitali o PWM, possono essere usati anche come ingressi digitali.

Nota:
I pin D0 e D1 gestiscono rispettivamente RX e TX della porta seriale di comunicazione tra il PC ed Arduino e non verranno presi in considerazione. Utilizzeremo quindi i pin compresi tra D2 e D13 che sono 12.

Un ingresso digitale funziona all’opposto di una uscita digitale, cioè quando si immette una tensione di 5 Volt CC viene restituito HIGH, 1 oppure “true”, cioè vero. Quando non si immette nulla viene restituito LOW, 0 oppure “false”, cioè falso.

Un sensore digitale può essere un comune pulsante, oppure un contatto di un relè, oppure l’uscita digitale di un sensore di fine corsa ecc.

Vediamo ora come leggere lo stato di un pulsante utilizzando un led, 2 resistenze e un pulsante normalmente aperto.

Breadboard pulsante NA e LED

In questo schema non si capisce benissimo come sono collegati I componenti, quindi inserisco anche uno schema più chiaro realizzato con EAGLE.

Schema elettrico pulsante e LED

L’uscita digitale D4 è collegata al pulsante (pin 3 e 4) ed alla resistenza R2 da 10000 OHM che a sua volta è collegata a GND.
L’altro contatto del pulsante (pin 1 e 2) è collegato all’alimentazione di Arduino di 5 Volt CC.

Per visualizzare lo stato del pulsante utilizzeremo un led tramite l’uscita digitale D2 e la resistenza R1 da 330 OHM collegata all’anodo. Il catodo del LED sarà collegato a GND.

Il programma di gestione di questo esperimento introduce il comando “if” che corrisponde a “se”, cioè come in una condizione decisionale.

Codice: Seleziona tutto

/* Pulsante Arduino
 *  16/11/2019
 *  Scritto da Edgardo Rosatti per il GAS TT
*/
int LED = 2;                 // il led è collegato al pin digitale 2 
int BUTTON = 4;              // il pin di input è il 4 dove è collegato il pulsante  
int stato = 0;               // creiamo la variabile stato per memorizzare lo stato del pin di input  
  
void setup() {  
  pinMode(LED, OUTPUT);       // imposta il pin digitale come output  
  pinMode(BUTTON, INPUT);     // imposta il pin digitale come input
  Serial.begin(9600);         // inizializzo la porta seriale s 9600 baud  
}  
  
void loop() {  
  stato = digitalRead(BUTTON);        // legge il valore dell'input e lo memorizza nella variabile stato
  if (stato == HIGH) {                // controlla che l'input sia HIGH (pulsante premuto)
    digitalWrite(LED, HIGH);          // se il pulsante è premuto accende il led
    Serial.println ("Tasto premuto"); //output sul monitor seriale
  }  
  else {  
    digitalWrite(LED, LOW);              // altrimenti spegne il led
    Serial.println ("Tasto rilasciato"); //output sul monitor seriale  
  }  
}

Il comando “if” usa la seguente sintassi:

if (condizione) {
azione
}

Cioè, se la condizione è vera allora viene eseguita una azione, altrimenti non succede nulla.

Nel nostro programma vi è anche il comando “else” che significa “altrimenti“ in modo generico.
Se introdotto, “else” esegue un’altra azione come nel nostro caso.

Infine esiste anche il comando “else if”, cioè “altrimenti se” che qui non è implementato.
In questo caso viene eseguita una azione se la condizione è diversa da quella iniziale.

É possibile inserire più comandi “else if” in questo modo:

if (condizione 1) {
azione
}
else if (condizione 2) {
azione
}
else if (condizione 3) {
azione
}
else if (condizione 4) {
azione
}
else {
azione
}

Nota:
É bene non inserire troppe condizioni “else if” in un programma, perchè potrebbe risultare poco comprensibile.
In caso di necessità utilizzare i comandi “case” e “switch” che meglio si adattano quando devono essere prese molte decisioni. Utilizzare la guida di riferimento per maggiori informazioni.

Tornando al programma vediamo che sono state definite 3 variabili numeriche intere:
int LED = 2
int BUTTON = 4
int stato = 0

LED indica ad Arduino che il led è collegato all’uscita digitale D2.
BUTTON indica che la porta di ingresso digitale deve essere la D4.
Infine “stato” conterrà lo stato del pulsante: HIGH se premuto e LOW quando rilasciato.

In “setup” definiamo con “pinMode” D2 come OUTPUT e D4 come INPUT digitali.
Inoltre invochiamo il solito monitor seriale a 9600 baud.

In “loop” assegnamo alla variabile “stato” la condizione della porta di ingresso D4 tramite il comando “digitalRead”.
Se D4 è HIGH allora accendiamo il LED, altrimenti lo spegnamo.
Vengono inviate al monitor seriale anche le stringhe di testo: “Tasto rilasciato” o “Tasto premuto” in base alla condiszione del pulsante.

Al posto del pulsante normalmente aperto, possiamo inserire una ampollina reed come quella utilizzata sul nostro fantasmagorico plastico modulare e tramite un magnete accendere il led.

Esistono dei piccoli modulini che fanno uso di led a raggi infrarossi/fototrasistor. Quando vengono avvicinati da un ostacolo inviano un impulso digitale leggibile da Arduino.
Anche questi dispositivi possono essere utilizzati al posto del pulsante normalmente aperto presente in questo schema.
Per esempio, il circuito qui presentato potrebbe essere utilizzato in una stazione nascosta per indicare la presenza di un treno su di un determinato binario tramite un led sulla plancia di comando.

SEnsore IR

Questo sensore IR ha 3 contatti: +5VCC, GND e OUT digitale da collegare ad Arduino. Inoltre tramite il trimmer presente sulla schedina è possibile regolarne la sensibilità.

Prossimamente vedremo come utilizzare le porte di ingresso analogiche (A0… A5) per la misurazione di eventi di vario tipo.

[MrPatato76]

Eventualmente Ed dove si possono reperire tutti questi componenti?

[sal727]

Su Ebay digiti arduino e trovi tutto, io mi fornisco da:
http://www.ebmstore.it/
https://www.tancredi.it/
il sensore ad infrarosso lo trovi alla voce sensori

s-l300.jpg (12.38 KiB) Visto 7170 volte

questo ha quattro piedini, svolge la stessa funzione con il particolare che può essere usato anche in analogico oltre che digitale

[v200]

Io mi servo qui da elettronica futura, https://www.futurashop.it/chi_siamo
oltre allo shop ha il forum dove trovi molte info è dei prodotti arduino trovi le schede tecniche con piccolo programma accluso da scaricare in pdf
https://forum.futurashop.it/index.php

[sal727]

Da Futurashop mi rifornivo anche io, sono abbastanza forniti, ma sono alti con i prezzi, per esempio il sensore infrarosso costa il doppio, se lo cerchi su amazon e ne compri 10 pezzi costa anche molto meno
https://www.amazon.it/infrarossi-preven ... B07M7GY7ZD

[v200]

Vero Sal, ma non ho avuto sorprese con il materiale. Sovente i prodotti clone che arrivano dalla Cina non funzionano per i primi passi meglio affidarsi ad un negozio on line valido

[Edgardo_Rosatti]

Le porte di ingresso analogiche.

Le porte di ingresso analogiche in Arduino UNO sono sei; A0, A1, A2, A3, A4 e A5. In alcune versioni possono essere anche otto includendo A6 e A7.

Una porta di ingresso analogica è in grado di leggere un valore di tensione compreso tra 0 Volt e 5 Volt in corrente continua.
É possibile impostare una soglia di lettura inferiore ai 5 Volt applicando un valore di tensione di riferimento più basso di 5 Volt sul pin AREF.

Tali porte sono utili per leggere valori provenienti da sensori di vario tipo, come:
- temperatura,
- umidità,
- pressione,
- illuminazione.

Il campionamento del valore letto dalle porte analogiche è a 10 bit, cioè viene restituito un numero decimale compreso tra 0 e 1023.

Il comando da usare per leggere una porta di ingresso analogica è:
analogRead(numeroporta);

Passiamo subito ad un esempio pratico utilizzando il programma “AnalogInput” presente nell’IDE.
Caricare il programma con: “File/Esempi/03.analog/AnalogInput” e collegare ad Arduino un potenziometro come in figura:

Potenziometro

In questa immagine utilizziamo Arduino Nano che dispone degli stessi pin di Arduino UNO ma essendo più piccolo può essere montato direttamente su una breadboard.

Colleghiamo un filo verde tra il pin A0 (ingresso analogico) e il polo centrale di un potenziometro.
Un filo rosso tra il pin 5V e il polo di sinistra del potenziometro e un filo nero tra il pin GND e il polo di destra del potenziometro.

In questo schema, inviamo una tensione variabile tra 0 e 5 VCC sull’ingresso A0 tramite il potenziometro per leggerne il suo valore.
Il valore del potenziometro non è critico e possiamo utilizzare quello presente in molti kit per esperimenti disponibili in rete. Nel mio caso ho utilizzato un potenziometro da 50000 OHM.

Il programma legge il valore di tensione in uscita dal potenziometro e lo utilizza per far lampeggiare ad una determinata frequenza il LED a bordo della scheda collegato all’uscita D13.
Essendo ben commentato non dovrebbe essere difficile interpretarlo.
Se vogliamo aggiungere la visualizzazione dei dati sulla porta seriale, inseriamo le linee:

Serial.begin (9600);

nel “setup” e

Serial.print(“Valore ingresso A0 = “);
Serial.println(sensorValue);

in “loop”.

Codice: Seleziona tutto

/*
  Analog Input

  Demonstrates analog input by reading an analog sensor on analog pin 0 and
  turning on and off a light emitting diode(LED) connected to digital pin 13.
  The amount of time the LED will be on and off depends on the value obtained
  by analogRead().

  The circuit:
  - potentiometer
    center pin of the potentiometer to the analog input 0
    one side pin (either one) to ground
    the other side pin to +5V
  - LED
    anode (long leg) attached to digital output 13
    cathode (short leg) attached to ground

  - Note: because most Arduinos have a built-in LED attached to pin 13 on the
    board, the LED is optional.

  created by David Cuartielles
  modified 30 Aug 2011
  By Tom Igoe

  This example code is in the public domain.

  http://www.arduino.cc/en/Tutorial/AnalogInput
*/

int sensorPin = A0;    // select the input pin for the potentiometer
int ledPin = 13;      // select the pin for the LED
int sensorValue = 0;  // variable to store the value coming from the sensor

void setup() {
  // declare the ledPin as an OUTPUT:
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  // read the value from the sensor:
  sensorValue = analogRead(sensorPin);
  // turn the ledPin on
  digitalWrite(ledPin, HIGH);
  // stop the program for <sensorValue> milliseconds:
  delay(sensorValue);
  // turn the ledPin off:
  digitalWrite(ledPin, LOW);
  // stop the program for for <sensorValue> milliseconds:
  delay(sensorValue);
  Serial.print("Valore ingresso A0 = ");
  Serial.println(sensorValue);
}

Ruotando il cursore del potenziometro da sinistra a destra e viceversa, dovremmo leggere dei valori numerici compresi tra 0 e 1023 sul monitor seriale.

Fotoresistenza:
In molti kit per Arduino sono presenti delle fotoresistenze che possono essere utilizzate con le porte di ingresso analogiche.
Una fotoresistenza è un resistenza elettrica il cui valore varia da qualche milione di OHM quando al buio, a pochi OHM se colpita dalla luce.

Fotoresistenza

Per usare una fotoresistenza con Arduino utilizzare lo stesso programma visto sopra ma realizzando il seguente schema elettrico:

Arduino Nano con fotoresistenza

In pratica sostituiamo il potenziometro con una fotoresistena e aggiungiamo una comune resistenza da 10000 OHM.
Il led su D13 lampeggierà velocemente quando la fotoresistenza sarà al buio e lentamente quando sarà esposta alla luce.

Chiudere il monitor seriale ed aprire il plotter seriale per visualizzare un grafico dei dati provenienti dalla fotoresistenza.

Plotter seriale

I valori rappresentati si riferiscono all’ingresso A0 visualizzato sulle ordinate ed il tempo sulle ascisse.

Un’altro esperimento che possiamo fare con le porte analogiche di ingresso, sono l’uso di più pulsanti collegati ad un partitore resistivo. Questo è molto comodo quando abbiamo la necessità di risparmiare porte di ingresso digitali.
Per esempio, potrebbero servirci quattro pulsanti per gestire una mini tastiera di controllo per un display LCD come in figura.

Pulsantiera e display LCD

In questo caso, anzichè collegare i 4 pulsanti a 4 porte di ingresso digitali, li collegheremo ad una sola porta analogica in questo modo:

Partitore resistivo

Partitore_sch.png (8.55 KiB) Visto 7136 volte

Componenti: R1=2200, R2=330, R3=680, R4=1000, S1-S4,= pulsanti normalmente aperti.
Vi sono 4 pulsanti collegati ad altrettante resistenze in modo da formare un partitore resistivo multiplo.
Premendo i pulsanti, avremo sull’uscita contrassegnata A0 quattro livelli di tensione differenti.

É come avere un potenziometro che anzichè scorrere in modo lineare , ha solo 4 posizioni come un commutatore rotativo.
Nell’esempio sopra riportato, avremo che il pin A0 di Arduino, alla pressione dei tasti restituirà i valori seguenti:

- Nessun tasto premuto = valore decimale 1023;
- Tasto S1 = valore decimale 0;
- Tasto S2 = valore decimale 132;
- Tasto S3 = valore decimale 155;
- Tasto S4 = valore decimale 399.

Nota
La somma di R2 + R3 +R4 deve essere pari a R1:
I valori decimali restituiti da A0 possono variare in base alla tolleranza delle resistenze.

Schema su breadboard:

Partitore su breadboard

Ora non ci resta che andare a leggere il valore in uscita dalla porta A0 quando premiamo I vari tasti:

Codice: Seleziona tutto

/*
  Partitore Resistivo su A0
  Edgardo Rosatti 2019 per il GAS TT
*/
int sensorPin = A0;    // selezione del pin A0 per l'ingresso del partitore
int sensorValue = 0;   // variabile che memorizza i valori letti da A0
int LED = 13;          // variabile del led 13 presente a bordo di Arduino
void setup() {
  pinMode(LED,OUTPUT); // La modalità del pin "LED" è "OUTPUT"
  Serial.begin(9600);  // inizializzo la porta seriale ad una velocità di 9600 baud
}
void loop() {
  sensorValue = analogRead(sensorPin); // leggo il valore su A0 e lo memorizzo in "sensorValue"
  Serial.print("Valore ingresso A0 = "); // stampo sul monitor seriale il virgolettato in blu senza andare a capo
  Serial.println(sensorValue); // stampo di seguito il valore decimale di "sensorValue" e vado a capo
  switch (sensorValue) { // leggiamo il valore di "sensorValue" e...
    case 0: // se è uguale a 0
      Pulsante1(); // richiamiamo la procedura "Pulsante1"
     break; // uscita da "case"
    case 28: // se è uguale a 28
      Pulsante2(); // richiamiamo la procedura "Pulsante2"
     break; // uscita da "case"
    case 56: // se è uguale a 56
      Pulsante3(); // richiamiamo la procedura "Pulsante3"
     break; // uscita da "case"
    case 133: // se è uguale a 133
      Pulsante4(); // richiamiamo la procedura "Pulsante4"
     break; // uscita da "case"
  } 
}
// Procedure da avviare per le operazioni decisionali di "switch" e "Case"
// Verrà fatto lampeggiare il led interno di Arduino da 1 a 4 volte di seguito in base al tasto premuto
void Pulsante1() {
  digitalWrite(LED,HIGH);
  delay(250);
  digitalWrite(LED,LOW);
  delay(250);
}
void Pulsante2() {
  digitalWrite(LED,HIGH);
  delay(250);
  digitalWrite(LED,LOW);
  delay(250);
  digitalWrite(LED,HIGH);
  delay(250);
  digitalWrite(LED,LOW);
  delay(250);
}
void Pulsante3() {
  digitalWrite(LED,HIGH);
  delay(250);
  digitalWrite(LED,LOW);
  delay(250);
  digitalWrite(LED,HIGH);
  delay(250);
  digitalWrite(LED,LOW);
  delay(250);
  digitalWrite(LED,HIGH);
  delay(250);
  digitalWrite(LED,LOW);
  delay(250);
}
void Pulsante4() {
  digitalWrite(LED,HIGH);
  delay(250);
  digitalWrite(LED,LOW);
  delay(250);
  digitalWrite(LED,HIGH);
  delay(250);
  digitalWrite(LED,LOW);
  delay(250);
  digitalWrite(LED,HIGH);
  delay(250);
  digitalWrite(LED,LOW);
  delay(250);
  digitalWrite(LED,HIGH);
  delay(250);
  digitalWrite(LED,LOW);
  delay(250);
}

Aprire monitor seriale e/o plotter seriale per legere I valori ddella porta A0.

Nota:
I valori in uscita di A0 in questo programma sono lievemente diversi da quelli indicati sopra, in quanto per questo esperimento ho usato resistenze di valore diverso. Tuttavia, all’atto pratico non cambia nulla.

Premendo i 4 pulsanti, il led interno di Arduino lampeggerà da 1 a 4 volte in base al pulsante premuto.

Nel programma sono stati inseriti i comandi decisionali “switch” “case”, inoltre viene mostrato come inserire nuove procedure e come richiamarle:

- Pulsante 1;
- Pulsante 2;
- Pulsante 3;
- Pulsante 4;

Questi sono i nomi delle quattro procedure che fanno lampeggiare il LED.

Con questa quarta parte del tutorial, abbiamo visto come utilizzare tutte le porte di ingresso e di uscita classiche in modalità “input” e “output”, in modo digitale ed analogico.

Nel prossimo capitolo parleremo dei dispositivi che utilizzano il protocollo di comunicazione seriale I2C e come gestirli con Arduino.
Giusto per la storia: https://it.wikipedia.org/wiki/I%C2%B2C

[Edgardo_Rosatti]

Il protocollo di comunicazione seriale I2C.

Il protocollo d comunicazione seriale I2C è un sistema nato per collegare apparecchiature tra loro (fino a 128) e in questo caso ad Arduino tramite 2 soli fili chiamati SDA (pin A4) e SCL (pin A5). Tali apparechiarure possono essere sia dispositivi di ingresso che dispositivi di uscita oppure anche altre schede Arduino. Lo schema di collegamento prevede che vi sia una unità detta MASTER e tutte le altre dette SLAVE (capo-suddito o sudditi).

In Arduino, il protocollo di comunicazione I2C utilizza la liberia “WIRE”.
Una libreria è un software aggiuntivo che estende il set di comandi standard dell’IDE e serve per gestire con praticità routine complesse o dispositivi il cui uso richiederebbe una programmazione molto impegnativa.
In pratica, una librerira facilita molto la vita del programmatore.

Abbiamo detto che l’I2C utilizza due soli fili chiamati SDA (Serial DAta); è il filo su cui transitano le informazioni ed SCL (Serial CLock); è il filo su cui viaggia un segnale di sincronizzazione chiamato CLOCK.
Infine, per permettere ai dati di transitare correttamente tra i vari dispositivi, bisogna collegare tra loro tutti i pin GND (negativo o GrouND) dei dispositivi stessi.

Facciamo un esperimento e colleghiamo tra loro due Arduino NANO:

Collegamento I2C tra due Arduino NANO

+5V e GND in questo caso sono collegati tra i due Arduino così come A4 (SDA) ed A5 (SCL); Arduino”master” alimenta anche Arduino “slave”.

Alimentare con un cavo USB l’Arduino “master” e caricare il seguente programma:

Codice: Seleziona tutto

/*
 * Questo programma sul protocollo di comunicazione seriale I2C è basato sul tutorial presente sul sito
 * OVERVOLT BLOG https://overvolt.tech/arduino/14
 */

#include <Wire.h> //include la libreria "Wire" nel programma

void setup() {
  Wire.begin(); // inizializza la comunicazione I2C e identificami come Arduino "master" dalla rete
  Serial.begin(9600); // inizializza una comunicazione seriale ad una velocità di 9600 baud
}

void loop() {
  Wire.requestFrom(3,4); // richiedi 4 byte di dati all'indirizzo 3
  Serial.print("Arduino slave ha scritto: "); // stampa una stringa
  while (Wire.available()) { // fino a quando Arduino "slave" invia dei dati
    char a = Wire.read(); // leggi i caratteri e meorizzali nella variabile "a"
    Serial.print(a); // stampa il contenuto della variabile "a"
  }
  Serial.println(); // vai a capo
  delay(1000); // aspetta un secondo: in questo modo il master invierà richieste di dati ad intervalli di un secondo
}

Ora alimentare l’Arduino “slave” e caricare il seguente proggramma:

Codice: Seleziona tutto

/*
 * Questo programma sul protocollo di comunicazione seriale I2C è basato sul tutorial presente sul sito
 * OVERVOLT BLOG https://overvolt.tech/arduino/14
 */
#include <Wire.h> //include la libreria "Wire" nel programma

void setup() {
  Wire.begin(3); //richiedi 4 byte di dati all'indirizzo 3
  Wire.onRequest(manda); // non appena arriva una richiesta dal master esegui la funzione “manda"
}

void loop() {
  delay(100);
}

void manda() {
  Wire.write("Ciao"); // invia al master la stringa “ciao”
}

Ora ricollegare l’Arduino “master” al PC ed aprire il monitor seriale per verificae che l’Arduino “slave” invii correttamente il messaggio ”Ciao” all’Arduino “master.

Se stacchiamo temporaneamente uno dei due fili SDA o SCL, vedremo che il messaggio “Ciao” scomparirà.

In pratica, l’Arduino “master” dice all’Arduino “slave” che può inviare un messaggio da stampare sul monitor seriale dell’Arduino ”master".

Per approfondire meglio la comunicazione tra “master” e “slave” andare sul sito ufficiale qui:
https://www.arduino.cc/en/Reference/Wire

In ultima analisi, se vogliamo utilizzare delle preriferiche come i sensori che fanno uso del protocollo I2C è necessario conoscere l’indirizzo associato al dispositivo tramite questo programma:
Arduino I2C Scanner:
https://playground.arduino.cc/Main/I2cScanner/

Per concludere questa parte dedicata alla comunicazione dati tra Arduino e dispositivi esterni o tra più moduli Arduino collegati tra loro, possiamo dire che vi sono altri due protocolli.
Quello utilizzato normalmente quando colleghiamo Arduino alla porta USB del PC che fa capo anche ai pin D0 (RX) e D1 (TX) e rispettivi led sulla scheda, cioè la porta seriale.
Quello citato poco sopra come I2C che fa capo ai pin A4 (SDA) e A5 (SCL).
Ed infile il protocollo SPI (Serial Peripheral Interface) che vedremo in seguito.

Pubblico qui una mappa dettagliata di tutti i pin di collegamento di Arduino UNO:

Collegamenti Arduino UNO

e di Arduino NANO:

Collegamenti Arduino NANO

[Edgardo_Rosatti]

Come usare i servocomandi con Arduino.

Un servocomando è un dispositivo elettromeccanico in grado di azionare una leva con movimento angolare o lineare. Sullo stesso principio esistono anche i verricelli in grado di far uotare una puleggia in senso orario e antiorario per un diverso numero di giri.

Per approfondire il principio di funzionamento di un servocomando consultare questo wiki:
https://it.wikipedia.org/wiki/Servomeccanismo
qui invece per la spiegazione di un servocomando per modellismo:
https://www.settorezero.com/wordpress/c ... vocomando/

Vediamo ora come pilotare un servocomando tramite un potenziometro e Arduino.

Schema servo con potenziometro

Tutti i servocomandi sono muniti di tre fili:
- rosso = +5VCC;
- nero = GND;
- giallo (o altro colore) = segnale PWM di controllo.

Colleghiamo GND di Arduino al filo nero del servo e ad uno dei poli esterni del potenziometro.
Colleghiamo +5V di Arduino al filo rosso del servo ed all’altro polo esterno del potenziometro.
Colleghiamo il polo centrale del potenziometro alla porta analogica di ingresso A0 di Arduino (filo azzurro) e il filo giallo (o altro colore) del servo al pin PWM D9 sempre di Arduino.

Ora carichiamo il seguente software su Arduino e vedremo che ruotando il cursore del potenziometro, la squadretta si muoverà di un angolo compre tra 0° e 180°.

Codice: Seleziona tutto

#include <Servo.h>

Servo Servo1;        // il nostro motore è Servo1

int Pot = 0;       // il cursore del potenziometro sul pin A0
int Posizione;     // la posizione del cursore del potenziometro
int Gradi;         // la posizione in gradi del servomotore
void setup()
{
  Servo1.attach(9);          // colleghiamo virtualmente il motore al pin 9
  Serial.begin(9600);        // configu\ro la porta seriale a 9600 baud
}
void loop()
{
  Posizione=analogRead(Pot);                    // legge il potenziometro
  Gradi=map(Posizione,0,1023,0,179);            // da una scala all'altra
  Servo1.write(Gradi);                          // sposta la leva del servo nei gradi specificati dalla variabile Gradi
  Serial.print("Gradi: ");                      // stampa sul monitor seriale la parola GRADI con uno spazio a destra
  Serial.println(Gradi);                        // stampa sul monitor seriale i gradi di rotazione del servo dopo la parola stampata precedentemente
  delay(15);                                    // aspetta 15 millisecondi prima di ricominciare il loop
}

Nota:
Durante la stesura di questo tutorial è andato accidentalmente perso il sofrware scritto per questa applicazione del servo con potenziometro.
Qui sopra ne ho inserito uno molto simile che restituisce gli stessi risultati, ma i nomi delle variabili sono diversi.

Il software invia i dati di posizione del potenziometro e del servo sulla porta seriale così da essere viasualizzati in forma testuale e grafica.
Aprire il monitor seriale e/o il plotter seriale per visualizzare i dati.

Monitor seriale

Plotterr seriale

Nel monitor seriale possiamo leggere i valori numerici della porta di ingresso analogica A0 e l’angolo in gradi assunto dalla squadretta del servo.
Nel plotter seriale vediamo gli stessi valori sottoforma di grafico; in blu i valori di A0 e in rosso quelli dell’angolo del servo.

Analizziamo il programma.

Il comando:
“#include <Servo.h>”
ci permette di usare la libreria “Servo” nel nostro programma, aggiungendo così ulteriori comandi all’IDE.

“Servo servoGASTT;”
crea un oggetto chiamato “servoGASTT” che il programma userà come riferimento del nostro servocomando.
In “setup” abbiamo “servoGASTT.attach(9);”
questo comando associa l’oggetto “servoGASTT” appena creato alla porta di uscita PWM numero 9 (D9).

Un po’ di calcoli.
In “loop”, dopo aver letto il valore in uscita dal potenziometro tramite:
“val = analogRead(potpin);”
otterremo un numero compreso tra 0 e 1023 sulla porta A0 che verrà assegnato alla variabile “val”.

Con il comando “map();” effettueremo una equivalenza necessaria al funzionamento del comando “servoGASTT.write();” n questo modo:
“val = map(val, 0, 1023, 0, 180);”

La posizione zero del potenziometro sta a 0° del servo, come la posizione 1023 del potenziometro sta a 180° del servo.

Il nuovo valore della variabile “val” restituito dal comando “map()”, ora verrà usato nel comando di scrittura del servo con:
“servoGASTT.write(val);”

Questo primo approccio con l’uso dei servi va bene se volgliamo utilizzare potenziometri o joystick. Ma se a noi interessa semplicemente usare dei semplici pulsanti o interruttori allora dobbiamo cambiare sistema.

Realizziamo un motore per deviatoio con un servo ed un interruttore.

Motore per deviatoio

Lo schema è molto simile a quello col potenziometro, che qui è sostituito da un pulsante ed una resistenza da 10000 OHM.
Premendo il pulsante, il servo ruota di 90°. Premendolo una seconda volta torna a 0°.

Codice: Seleziona tutto

/*  Azionamento di un servo tramite pulsante
 *  Edgardo Rosatti per GAS TT
*/
#include <Servo.h>
#define PULSANTE 2
Servo servoGASTT;  // creazione di un oggetto chiamato servoGASTT
byte stato=0;
boolean eseguito=true;
void setup() { 
  pinMode(PULSANTE, INPUT);
  servoGASTT.attach(9);  // connettiamo servoGASTT al pin PWM 9
  servoGASTT.write(0);   // posiziona la squadretta del servo a 0°
  Serial.begin(9600);    // inizializza la porta seriale a 9600 baud
}
void loop() {
  if(digitalRead(PULSANTE)){
       if(stato==0){
           stato=1;
           eseguito=false;
       }
       else{      
           stato=0;
           eseguito=false;
       }
  }
  if(stato==1 && eseguito==false){
       servoGASTT.write(90);
       delay(500);
       Serial.println ("Rotazione a 90°");
       eseguito=true;  // esegue una sola volta       
  }
  else if(stato==0 && eseguito==false){
       servoGASTT.write(0);
       delay(500);
       Serial.println ("Rotazione a 0°");
       eseguito=true; // esegue una sola volta
  }                           
}

Aprire il monitor seriale per leggere le posizioni del servo.

Il programma utilizza due variabili; una di tipo “byte” ed una di tipo “boolean” per memorizzare l’ultimo stato del servo.
In questo modo, tramite una serie di condizioni “if” “else” “else if”, riusciamo a utilizzare un solo pulsante.

Nel primo “if”, viene eseguito un “if” “else” interno se il pulsante viene premuto, questo per impostare la variabile “stato “a 1 se prima era 0 e 0 se prima era 1.

Le variabili di tipo “byte” possono memorizzare numeri interi compresi tra 0 e 255.
Le variabili di tipo “boolean” vengono usate con “true” (vero) e “false” (falso) per l’interpretazione logica di una condizione.
Le due e commerciali “&&” nel secondo “if” sono anch’esse operatori booleani e significano “e”, cioè “and”:

if(stato==1 && eseguito==false){

se la variabile “stato” è uguale a 1 e (&& “and”) la variabile “eseguito” è falsa, allora muovi il servo di 90°.
Nelle istruzioni seguenti viene impostato un ritardo di 0,5 secondi, viene stampato sul monitor seriale un messaggio e viene impostata la variabile “eseguito” su vero.

else if(stato==0 && eseguito==false){

altrimenti se la variabile “stato” è uguale a 0 e (&& “and”) la variabile “eseguito” è falsa, allora riporta il servo a 0°.

Tutto questo meccanismo serve per filtrare i rimbalzi prodotti dal pulsante che farebbero inevitabilmente muovere continuamente il servo avanti e indietro.
In pratica si tratta di memorizzare nella variabile “stato” la posizione del servo per eseguire correttamente l’azionamento dello stesso.

Se vogliamo sfruttare al massimo le porte di Arduino possiamo usare 6 servi e 6 pulsanti.
L’importante in questo caso è alimentare i +5V dei servi con un alimentatore esterno, in quanto Arduino verrebbe sovraccaricato.

Utilizzare due pulsatnti è molto più semplice, ma occuperemo una porta di ingresso in più per ogni servo.
In alternativa, possiamo sfruttare il metodo del partitore resistivo su un ingresso analogico descritto all’inizio di questo tutorial e usare le uscite digitali libere per accendere dei led che indichino la posizione dei servi.

[Edgardo_Rosatti]

Misuriamo il tempo con Arduino.

Esistono diversi modi per misurare il tempo con Arduino.
Il primo è quello di utilizzare il contatore hardware presente all’interno del microcontrollore AT mega di Arduino.

Tale contatore può essere richiamato con il comando “millis()”, il quale restituisce un numero espresso in millisecondi (1 secondo diviso 1000) contato da quando il programma che lo invoca viene eseguito.
“millis()” viene azzerato dopo 50 giorni di funzionamento ininterrotto di Arduino.

Un’altro comando simile a “millis()” è “micros()”, il quale restituisce un numero di tempo in microsecondi (1 secondo diviso un milione) da quando il programma è stato avviato.
Tale contatore si azzera dopo circa 70 minuti di funzionamento ininterrotto di Arduino.
“micros()” ha una tolleranza di 4 microsecondi sui modelli di Arduino che hanno un oscillatore di clock di 16 Mhz (UNO ,Nano), 8 microsecondi sui modelli con clock di 8 Mhz (LilyPad).

Altre funzioni che lavorano con il tempo in Arduino sono “delay()” e “delayMicroseconds()”.

“delay(numero di millisecondi)”;
ferma temporaneamente un programma per il tempo indicato tra parentesi espresso in millisecondi.

“delayMicroseconds(numero di microsecondi)”;
ferma temporaneamente un programma per il tempo indicato tra parentesi espresso in microsecondi.

In questi due esempi pratici non dobbiamo collegare nulla ad Arduino, in quanto usiamo i componenti interni del microcontrollore e le informazioni verranno visualizzare sul monitor seriale.

Programma “millis()”

Codice: Seleziona tutto

unsigned long time; // definiamo una variabile lunga senza segno chiamata "time"

void setup(){
  Serial.begin(9600); // invochiamo la porta seriale con velocità di 9600 baud
}
void loop(){
  Serial.print("Time: "); // stampa il testo "Time: " sul monitor seriale
  time = millis(); // assegna alla variabile "time" il numero di millisecondi restituito dal comando "millis()"
  Serial.println(time); //stampa il numero di millisecondi da quando è stato avviato il programma di fianco alla stampa trecedente e torna a capo
  delay(1000); // attende un secondo per evitare di inviare troppi dati alla porta seriale
}

Programma “micros()”

Codice: Seleziona tutto

unsigned long time; // creiamo una variabile lunga senza segno chiamata "time"

void setup(){
  Serial.begin(9600); // invochiamo la porta seriale con velocità di 9600 baud
}
void loop(){
  Serial.print("Time: "); // stampa il testo "Time: " sul monitor seriale
  time = micros(); // assegna il tempo letto da "micros()" alla variabile "time"
  Serial.println(time); // stampa il contenuto della variabile "time" di fianco al testo stampato precedentemente e torna a capo
  delay(1000); // attende un secondo
}

I dati letti e memorizzati nella variabile “time”, possono essere utilizzati per creare orologi, timer e contatori se processati opportunamente, ma come avrete già intuito, si resetteranno ogni qualvolta Arduino verrà spento.

Per avere un conteggio del tempo che ci consenta di aggiornare Arduino tutte le volte che viene avviato, dobbiamo utilizzare un modulo esterno chiamato RTC (Real Time Clock, orologio in tempo reale).
In pratica, l’RTC è un orologio e calendario in tutto e per tutto che viene alimentato da una comune pila a bottone la cui durata è di circa 2 anni.

Oppure possiamo collegare Arduino ad internet tramite una scheda ethernet o wifi per leggere l’ora e la data da u webserver.
Per ora, in questo tutorial non tratteremo questo argomento.

Modulo RTC:

Modulo Real Time Clock SPI

Esistono diversi tipi di moduli RTC; in questo tutorial prenderemo in esame quello basato sul chip 1302 con comunicazione seriale SPI (Serial Peripherial Inteface).
Per la cronaca esiste anche il modello 1307 con comunicazione seriale I2C.

Quando abbiamo visto il protocollo di comunicazione I2C, abbiamo introdotto anche altri sistemi di comunicazione seriale come l’SPI; ecco, ora vediamo quella di tipo SPI.

Collegamenti di un modulo orologio RTC 1302 con interfaccia seriale SPI ad Arduino:

- collegare GND del modulo co GND di Arduino (alimentazione modulo);
- collegare +5V del modulo con +5V di Arduino (alimentazione modulo);
- collegare MISO (I/O) del modulo al pin D6 di Arduino (Input/Output);
- collegare SCK (SCKL) del modulo al pin D7 di Arduino (Serial Clock);
- collegare CS (CE) del modulo al pin D5 di Arduino (Chip Enable).

Modulo RTC 1302

Il software di gestione di un modulo RTC fa uso di due librerie chiamate: “stdio.h” e “DS1302.h” che servono per la gestione del modulo orologio 1302 e del protocollo di comunicazione seriale SPI.

Codice: Seleziona tutto

// Example sketch for interfacing with the DS1302 timekeeping chip.
//
// Copyright (c) 2009, Matt Sparks
// All rights reserved.
//
// http://quadpoint.org/projects/arduino-ds1302
#include <stdio.h>
#include <DS1302.h>

namespace {

// Set the appropriate digital I/O pin connections. These are the pin
// assignments for the Arduino as well for as the DS1302 chip. See the DS1302
// datasheet:
//
//   http://datasheets.maximintegrated.com/en/ds/DS1302.pdf
const int kCePin   = 5;  // Chip Enable
const int kIoPin   = 6;  // Input/Output
const int kSclkPin = 7;  // Serial Clock

// Create a DS1302 object.
DS1302 rtc(kCePin, kIoPin, kSclkPin);

String dayAsString(const Time::Day day) {
  switch (day) {
    case Time::kSunday: return "Sunday";
    case Time::kMonday: return "Monday";
    case Time::kTuesday: return "Tuesday";
    case Time::kWednesday: return "Wednesday";
    case Time::kThursday: return "Thursday";
    case Time::kFriday: return "Friday";
    case Time::kSaturday: return "Saturday";
  }
  return "(unknown day)";
}

void printTime() {
  // Get the current time and date from the chip.
  Time t = rtc.time();

  // Name the day of the week.
  const String day = dayAsString(t.day);

  // Format the time and date and insert into the temporary buffer.
  char buf[50];
  snprintf(buf, sizeof(buf), "%s %04d-%02d-%02d %02d:%02d:%02d",
           day.c_str(),
           t.yr, t.mon, t.date,
           t.hr, t.min, t.sec);

  // Print the formatted string to serial so we can see the time.
  Serial.println(buf);
}

}  // namespace

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

  // Initialize a new chip by turning off write protection and clearing the
  // clock halt flag. These methods needn't always be called. See the DS1302
  // datasheet for details.
  rtc.writeProtect(false);
  rtc.halt(false);

  // Make a new time object to set the date and time.
  // Sunday, September 22, 2013 at 01:38:50.
  Time t(2019, 11, 27, 1, 4, 0, Time::kWednesday);

  // Set the time and date on the chip.
  rtc.time(t);
}

// Loop and print the time every second.
void loop() {
  printTime();
  delay(1000);
}

L’output in monitor seriale sarà:

Orario RTC

[Edgardo_Rosatti]

Colleghiamo ad Arduino un display a cristalli liquidi retroilluminato.

In commercio esistono diversi tipi di display a cristalli liquidi che Arduino può gestire con facilità. Uno di questi è il tipo compatibile con il driver Hitachi HD44780.
In questo esempio ne useremo uno in grado di visualizzare 16 caratteri su due linee come in figura.

Collegamento display LCD HD44780 ad Arduino

I pin di collegamento del display partendo da sinistra sono i seguenti:

- 1 VSS +5V;
- 2 VDD GND;
- 3 V0 Potenziometro 10000 OHM (polo centrale) contrasto display;
- 4 RS D12 Arduino;
- 5 RW GND;
- 6 ENABLE D11 Arduino;
- 11 D4 D5 Arduino;
- 12 D5 D4 Arduino;
- 13 D6 D3 Arduino;
- 14 D7 D2 Arduino;
- 15 A Resistenza 220 OHM LED retroilluminazione interna (anodo);
- 16 K GND LED retroilluminazione interna (catodo).

Nota:
In alcuni casi, i pin 15 (A) e 16 (K) del display risultano essere invertiti; dipende dal costruttore. Fare riferimento al datasheet del modello utilizzato.

Regolando il potenziometro sul pin V0, possiamo variare il contrasto dul display LCD.
Un valore più basso della resistenza collegata sul pin A (15) farà diminuire la retroilluminazione del display.

Il software di test:

Codice: Seleziona tutto

/*
  LiquidCrystal Library - Hello World GAS TT

 Dimostrazione dell'uso di un display a cristalli liquidi da 16x2 caratteri.  La libreria LiquidCrystal
 lavora con i display a cristalli liquidi (LCD) compatibili con il driver Hitachi HD44780.
 Questo driver è facie da usare e sfrutta un collegameto a 16 fili.

 Il programma stampa "Ciao neh!!!" sul display LCD e visualizza un contatore temporale.

  Il circuito e colleamenti:
 * LCD RS pin to digital pin 12
 * LCD Enable pin to digital pin 11
 * LCD D4 pin to digital pin 5
 * LCD D5 pin to digital pin 4
 * LCD D6 pin to digital pin 3
 * LCD D7 pin to digital pin 2
 * LCD R/W pin to ground
 * LCD VSS pin to ground
 * LCD VCC pin to 5V
 * 220 OHM resistore per led interno retroilluminazione (A, K):
 * 10K potenziometro contrasto ends to +5V and ground (LCD VO pin (pin 3)
*/

// includiamo la libreria di gestione del display LCD:
#include <LiquidCrystal.h>

// inizializziamo il display associando i pin richiesti di seguito
// e li colleghiamo come segue
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup() {
  // impostiamo il numero di righe e colonne del display LCD:
  lcd.begin(16, 2);
  // stampiamo il messaggio di benvenuto sul display LCD.
  lcd.print("Ciao neh!!!");
}

void loop() {
  // posizioniamo il cursore alla colonna 0, linea 1
  // (nota: linea 1 è la seconda riga, il conteggio parte da 0):
  lcd.setCursor(0, 1);
  // stampa il numero di secondi dopo RESET
  lcd.print("Secondi:");
  lcd.print(millis() / 1000);
}

Il programma fa uso della libreria “LiquidCrystal.h”.

Il comando : const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
assegna i numeri dei pin di collegamento a delle costanti intere.

Il comando: LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
inizializza il display con nome “lcd” dicendo ad Arduino dove sono collegati i pin tramite le costanti impostate sopra.

In “setup()” impostiamo il numero di colonne (16) e di righe (2) del display e stampiamo il messaggio: “Ciao neh!!!”.

In “loop()” spostiamo il cursore sulla seconda riga e stampiamo il messaggio “Secondi: “ seguito dal valore restituito dalla funzione “millis()” diviso 1000, cioè il numero di secondi trascorsi dall’avvio di Arduino.

Il programma è abbastanza autoesplicativo e facile da interpretare.

Foto collegamenti display e Arduino Nano

Nella foto viene usato un display 16x2 con caratteri bianchi su sfondo blu ed un Arduino Nano.

[v200]

Ed se ti riesce potresti più avanti far vedere come posizioni una scheda arduino su un plastico per gestire l'elettronica ?
Attacchi al telaio, saldatura cavetteria , molto spesso questa parte non si vede mai. Ti ringrazio in anticipo

[Edgardo_Rosatti]

Ed se ti riesce potresti più avanti far vedere come posizioni una scheda arduino su un plastico per gestire l'elettronica ?
Attacchi al telaio, saldatura cavetteria , molto spesso questa parte non si vede mai. Ti ringrazio in anticipo

Grazie a te Roby per il suggerimento.

Di solito, nei tutorial vengono mostrati schemi elettrici fatti con il programma Fritzing che usano una breadboard e fili volanti; questo tutorial non fa eccezione.
Il fatto è che in questo modo diventa subito chiaro come collegare Arduino ai vari dispositivi, in quanto quasi tutti coloro che si avvicinano al mondo Arduino posseggono un kit "primi passi".
Inoltre, solo in questo modo è facile fare esperimenti collegando e scollegando semplicemente i fili dalla breadboard. Fare prove usando il saldatore e schede varie tipo le millefori, sarebbe troppo complicato e poco produttivo. La struttura di Arduino UNO è fatta apposta per essere usata con componenti che non necessitano l'uso del saldatore. L'esperto di elettronica e microcontrollori, spesso storce il naso quando sente parlare di Arduino, perchè è un sistema che si rivolge a chi non ha competenze in merito. Un ingegnere fa l'ingegnere, un hobbista no.
Se si pensa che il progetto Arduino nasce da persone che hanno abbracciato le ideolgie di Olivetti in quel di Ivrea nel bar Arduino, da un certo punto di vista entriamo nel mondo dei visionari o meglio dei lungimiranti. Questo, in sostanza è il motivo del successo di Arduino.

La struttura delle schede Arduino dipende dal modello che utilizziamo.
Se prendiamo Arduino UNO e Arduino MEGA, vediamo che l'impostazione dei pin è molto simile.
Possiamo dire che Arduino UNO ha gli stessi pin di Arduino Mega e che Arduino MEGA è l'estensine di Arduino UNO.

Il concetto di "shield":
https://www.arduino.cc/en/Main/arduinoShields

Uno Shield è una scheda elettronica che ha la stessa forma e gli stessi pin di Arduino UNO e che è in grado di collegarsi fisicamente ad esso.

Motor Shield

Questa scheda si chiama "Motor shield" e serve per gestire il funzionamento di piccoli motori in CC.

Il sistema degli shield è un modo pratico per collegare Arduino ad interfacce elettroniche di vario tipo che possono essere montate l'una sull'altra:

Arduino Uno + RGB + Carnate Shield

I morsetti presenti sugli shield ci permetteranno di collegare i fili di gestione verso il nostro impianto.

Shield cablati

Nei modelli Nano e Micro, i pin sono disposti come in un circuito integrato ed è necessario realizzare una basetta in grado di ospitare la scheda.
https://www.amazon.it/Arduino-Nano-Shie ... ano+Shield

Arduino Lilypad è una eccezione, in quanto ha una struttura flessibile in grado di essere cucita su stoffa tramite fili conduttivi.
https://www.meccanismocomplesso.org/lil ... echnology/

É facile trovare in rete degli shield che contengono crcuiti in grado di soddisfare le nostre esigenze, tuttavia, non sempre questo è possibile e a volte dobbiamo crearceli da zero.

[Edgardo_Rosatti]

Chiudo il tutorial.

Edgardo

[Nick8526]

Ciao, molto interessante, non lo sai, ma te sei stato quello che mi spinse a gestire il mio plastico con Arduino ben 2 anni fa.
Senza dubbio meno elegante del tuo, ho fatto il cablaggio usando le pin strip


ad esse poi saldo i fili che vanno ai device

Successivamente poi ho provato anche il dcc++ sempre fatto con arduino, che sono riuscito a far andare e che mi riprometto di affinare a plastico completato.

Grazie per la tua condivisione