Arduino (Esperimento) – Calcolo del tempo di scarica di un condensatore
Un condensatore è componente in grado di accumulare e conservare la carica elettrica. Per rallentare il processo di carica, essa può avvenire attraverso un resistore (vedi circuito RC); il tempo necessario per la carica e quello necessario per la scarica, sono legati ad una costante di tempo che dipende dalle resistenze e dalle capacità in gioco. Nell’esperimento che vado ad illustrare, voglio che arduino mi dica la durata del processo di scarica di un condensatore.
La carica avviene attraverso un resistore, collegato al PIN 13, abilitato dalla pressione di un pulsante. Per tutto il tempo che il pulsante viene tenuto premuto, il condensatore si carica. Al rilascio del pulsante il condensatore si scarica attraverso un secondo resistore, collegato al PIN 11 e da esso abilitato. Inoltre, sull PIN 0 (INPUT ANALOGICO, dal lato dell’alimentazione) si potrà leggere il valore della carica. La situazione è quella rappresentata in figura.
I componenti necessari per questo esperimento sono:
- un pulsante a quattro piedini (vedi Articolo)
- 3 resistori da 10KOhm
- 1 condensatore da 100uF (nel mio caso elettrolitoco 25Vdc
Una parte del circuito che andiamo a costruire è stato descritto nell’articolo precedente; l’altra parte deve invece realizzare in concreto quello che è rappresentato nella figura precedente.
Premendo il pulsante, invece di accendere un led, come nell’articolo citato, carichiamo il condensatore, rendendo l’uscita sul PIN 13 alta. Quando il pulsante viene rilasciato, il PIN 13 non eroga più corrente (viene messo a basso) e viene attivato il PIN 11 e impostato al valore logico basso, comportando la scarica del condensatore.
Di seguito lo sketch relativo all’esperimento:
unsigned long pulsante_t0;
unsigned long pulsante_t;
unsigned long condensatore_t0;
unsigned long condensatore_t;
int value = 0;
boolean pushed = false;
void setup(){
pinMode(11, INPUT);
pinMode(13, OUTPUT);
pinMode(9, INPUT);
digitalWrite(13, LOW);
Serial.begin(9600);
Serial.println("START");
}
void loop(){
if (digitalRead(9))
{
//carica
if (!pushed)
{
pulsante_t0 = millis();
pushed = true;
digitalWrite(13, HIGH);
}
}
else if (pushed)
{
//scarica
digitalWrite(13, LOW);
pulsante_t = millis() - pulsante_t0;
value = analogRead(0);
pinMode(11, OUTPUT);
//tempo di scarica
condensatore_t0 = millis();
digitalWrite(11, LOW);
while(analogRead(0) > 0){}
condensatore_t = millis() - condensatore_t0;
pinMode(11, INPUT);
//stampo dati
Serial.print("[V=");Serial.print(value);Serial.print("]");
Serial.print("[Tp=");Serial.print(pulsante_t);Serial.print("]");
Serial.print("[Tc=");Serial.print(condensatore_t);Serial.print("]");
Serial.println("");
value = 0;
pulsante_t = 0;
condensatore_t = 0;
pushed = false;
}
}
Nella funzione setup() notiamo la linea Serial.begin(9600) , che inizializza la comunicazione seriale con il computer (attraverso il cavo USB, nel nostro caso). L’invio di un messaggio da parte di Arduino, avviene attraverso le funzioni Serial.print() e Serial.println() (la seconda manda automaticamente il carattere di andata a capo) e noi possiamo leggere questi messaggi attraverso il “Serial Monitor” dell’ambiente di sviluppo.
Nella parte bassa della finestra, potremo leggere i messaggi inviatici da Arduino.
Altre due funzioni interessanti sono:
- millis() : permette di ricavare il tempo dall’avvio di Arduino in millisecondi (attenzione!!! va in overflow dopo 50 giorni di attività… sostanzialmente torna a zero…)
- analogRead() : legge un valore da un ingresso analogico (uno dei 6 vicini al microcontrollore), restituendo un valore compreso tra ‘0′ e ‘1023′
Dopo l’invio del programma ad Arduino, avviando il “Serial Monitor” e premendo il pulsante per periodi di tempo variabile, si ottengono i seguenti risultati:
Se cambiamo il resistore attraverso il quale il condensatore si scarica, con uno di 220Ohm, notiamo che il tempo di scarica diminuisce (dualmente per la carica – vedi τ del circuito RC):
LEGENDA:
- V = valore letto al rilascio del tasto
- Tp = tempo di pressione del tasto
- Tc = tempo di scarica del condensatore
Arduino (3) – Accendiamo e spegnamo la luce
Nell’ultimo articolo abbiamo descritto come far lampeggiare un led, utilizzando la scheda Arduino come un “costoso interruttore”. Adesso proviamo ad aggiungere un interruttore per accendere e spegnere il led. Per realizzare un interruttore basta tagliare il filo che chiude un circuito: quando i fili sono separati, la corrente non passa; quando i fili sono messi in contatto, il circuito si chiude, la corrente passa e circola nel circuito. Ci sono interruttori in svariate forme, noi utilizzaremo l’interruttore incluso nel kit:
Con un interruttore possiamo realizzare un input digitale, ovvero sul PIN in ingresso possiamo leggere un valore logico basso oppure alto, a seconda dello stato dell’interruttore. Come si può immaginare, quando l’interruttore è aperto, ovvero non c’è una connessione, si leggerà il valore logico basso; quando l’interruttore viene chiuso, si leggerà il valore logico alto.
Lo schema qui riportato è quello da applicare al PIN dal quale verrà letto il valore logico, e il resistore inserito nel circuito, serve a portare al valore logico basso l’ingresso quando l’interruttore è aperto, evitando di avere valori flottanti. Il PIN dovrà essere settato come INPUT, mediante pinMode(), e la lettura deve avvenire con digitalRead(), poichè siamo in presenza di un input digitale. Mentre l’interruttore rimane chiuso, l’uscita su cui è collegato il led deve diventare alta.
Il circuito sarà costituito da due parti: la parte relativa al led, facilmente riproducibile; la parte relativa al pulsante, dove bisogna andare a replicare lo schema della precedente figura.
L’interruttore ha due piedini sempre connessi e altri due da connettere mediante la pressione del pulsante. Come si vede uno di questi ultimi è collegato all’alimentazione e l’altro è collegato a terra tramite il resistore. Tra il resistore e l’interruttore viene collegato il PIN2, ovvero quello da cui il nostro microcontrollore andrà a leggere l’ingresso digitale.
Lo sketch per questo esperimento è il seguente:
int led_pin = 8;
int btn_pin = 2;
void setup() {
pinMode(led_pin, OUTPUT);
pinMode(btn_pin, INPUT);
}
void loop()
{
int in = digitalRead(btn_pin);
if (in == LOW)
{
digitalWrite(led_pin, LOW);
}
else
{
digitalWrite(led_pin, HIGH);
}
}
In questo sketch incontriamo il costrutto decisionale if … else … il quale permette di scegliere tra due o più alternative (mediante “else if“), a seconda se è verificata o meno la condizione logica espressa tra parentesi. Se l’input letto è alto, spegne il led, altrimenti se è alto (l’unica altra alternativa), accende il led, proprio come fatto nel precedente articolo. Alla luce di quanto detto: cosa fa il seguente sketch?
int led_pin = 8;
int btn_pin = 2;
int stato = LOW;
void setup() {
pinMode(led_pin, OUTPUT);
pinMode(btn_pin, INPUT);
}
void loop()
{
int in = digitalRead(btn_pin);
if (in == HIGH)
{
if (stato == LOW)
{
stato = HIGH;
}
else
{
stato = LOW;
}
}
digitalWrite(led_pin, stato);
}
Risposta: premuto il tasto, il led cambia da acceso a spento e viceversa, restando in quello stato fino alla successiva pressione.
Arduino (2) – Un led tutto nostro
Nel precedente articolo abbiamo colleagato un led alla scheda Arduino, facendolo lampeggiare. Se il led prima lo abbiamo “brutalmente” inserito sulla scheda, adesso vogliamo spostarlo in un circuito separato, utilizzando una breadboard, in modo da gettare le basi per la realizzazione di circuiti più complessi.
Quando colleghiamo una batteria ad una lampadina, la lampadina si accende. Se mettiamo un’interruttore tra la lampadina e la batteria, la lampadina può essere accesa, quando il circuito è chiuso (interruttore abbassato, mette in contatto i fili a cui è collegato), o spenta, se il circuito è aperto (interruttore alzato, scollega i fili a cui è collegato).
Quello che succede, lo possiamo guardare in analogia al sistema circolatorio: il cuore pompa il sangue che scorre nelle vene e arriva dove c’è bisogno. Per noi, il voltaggio (la differenza di potenziale) è il cuore, la corrente è il sangue. Quindi, la differenza di potenziale tra i due morsetti della batteria mette in moto gli elettroni, che circolano nel filo; gli elettroni passano nel filamento della lampadina, rendendolo incandescente; ecco la luce. Se l’interruttore è OFF, la corrente non circola (non è pompata dalla differenza di potenziale) e la lampadina non si accende.
Per il nostro primo esempio, la scheda Arduino rappresenta uno costoso interruttore (n.b. costoso solo rispetto agli interruttori): è il software che decide se il flusso di elettroni c’è o non c’è.
Cosa ci serve per questo esperimento?
- un resistore da 220 Ohm (rosso, rosso, marrone)*
- un led
Utilizzeremo una breadboard, ovvero una scheda fatta di tanti buchi dove andare ad infilare i nostri componenti e connettori. Una breadboard, vista in verticale, è una matrice di fori, etichettati da lettere (colonne) e numeri (righe), con due linee comuni + e – disposte sui due lati.
- I due insiemi di colonne “abcde” e” fghij”, sono separati e indipendenti tra di loro (non collegati).
- Le righe sono indipendenti tra loro.
- Le colonne di una stessa riga sono collegate tra loro.
- Per le colonne + e – (di alimentazione) le righe sono collegate tra loro e indipendenti dal resto della scheda.
Le breadboard sono ottime per la prototipazione, poiché solderless, ovvero non hanno bisogno di saldature, ma funzionano ad incastro; per problemi di dissipazione della potenza, oltre che di costo, non è consigliabile usarle altrimenti.
Ricordiamo di seguito lo sketch utilizzato nel precedente esperimento.
int intervallo = 1000;
int pin_led = 13;
void setup()
{
pinMode(pin_led, OUTPUT);
}
void loop()
{
digitalWrite(pin_led, HIGH);
delay(intervallo);
digitalWrite(pin_led, LOW);
delay(intervallo);
}
Stavolta il pin del led può essere qualunque, poichè la corrente passerà attraverso un resistore (io per comodità utilizzo ancora il PIN 13). Dobbiamo utilizzare un resistore: un resistore è un qualcosa che limita il passaggio della corrente, è come se ci fosse un secchio con un buco sul fondo, che fa passare una quantità d’acqua minore di quella che fluisce dall’alto, e serve per non far bruciare il nostro led. Un led, altro non è che un diodo, ovvero un qualcosa in cui la corrente è costretta ad andare in un senso solo e non può tornare indietro. Maggiore sarà la resistenza del resistore, più piccolo sarà il buco del secchio, minore sarà l’intensità della luce.
Nelle due foto che seguono, prima e dopo il montaggio.
Se insieme alla breadboard ci sono fili già tagliati (come nello starter kit), siamo pronti, altrimenti armiamoci di tronchesino e prepariamo i fili, tagliandone pezzettini di qualche centimetro (quanto basta per stare comodi) e togliamo l’involucro di plastica dalle estremità.
Colleghiamo, aiutandoci eventualmente con una pinzetta, un filo dal PIN13 ad un foro della breadboard, ad esempio J4 (colonna J, riga 4 – non all’alimentazione); prendiamo poi il nostro resistore e colleghiamo il piedino I4 (quello accanto) con, ad esempio, per comodità, D5. Sulla stessa riga mettiamo il led, collegato a B5 (ad esempio) e alla colonna -. A questo punto colleghiamo la colonna – a GND con un filo.
Queto schema può essere replicato per tutte le uscite digitali e se usiamo uscite “analogiche” si può creare un effetto di fading (basta inserire un ciclo for con valori di intensità che vanno da 0 a 255). Di seguito la rappresentazione schematica:
Replicando lo schema, possiamo avere tre led di colore differente che si accendono uno dopo l’altro.
Per creare questo schema, ho utilizzato un programmino fatto a posta che si chiama Fritzing. Ecco lo sketch relativo al caso dei tre led:
void setup()
{
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
}
void loop()
{
led(8,500);
led(9,500);
led(10,500);
}
void led(int num, int t)
{
digitalWrite(num, HIGH);
delay(t);
digitalWrite(num, LOW);
//delay(t);
}
La funzione led() non fa altro che accendere il led sul piedino num per un tempo t, espresso in millisecondi.
* La resistenza di un resistore è espressa tramite colori. Vedi Wikipedia.
Programmazione Object Oriented in JavaScript
Socrate diceva: “Più so, più so di non sapere“. Ed è vero… Man mano che si impara (e nella vita si impara sempre), più dubbi ci vengono sulle nostre conoscenze ed io, sebbene sapessi che con JavaScript si potesse “programmare ad oggetti” (in senso lato) e me ne fossi fatto un’idea (per tentativi tanto tempo fa ho modificato una classe di YahooUI), non mi ero mai posto il problema di scoprire come in realtà si facesse. E ora che mi sono trovato davanti allo script dell’articolo precedente, ho deciso di colmare questa mia lacuna e ora riporto i miei appunti qui…
Chiunque viene dal mondo della programmazione ad oggetti ha familiarità con i concetti di tipo, tipo di dati astratto, classe, ereditarietà tra classi e così via. In JavaScript ci sono diversi modi di programmare ad oggetti; uno di questi modi fa uso del “prototype pattern” e con un esempio (per chi conosce la OOP) è bello che spiegato
function Persona() {
this.nome= "";
this.eta= 15;
}
Persona.prototype.setNome = function(_nome) {
this.nome= _nome;
}
Persona..prototype.setEta = function(_eta) {
this.eta = _eta;
}
var nicola = new Persona();
nicola .setNome ("nicola ");
nicola .setEta (25);
alert(nicola.nome + " - " + nicola.eta);
per ereditare la classe Persona
function Maschio() {
this.sesso= 'M';
}
Maschio.prototype = new Persona();
function Femmina() {
this.sesso= 'F';
}
Femmina.prototype = new Persona();
questa modalità di implementazione delle classi è quella consigliata quando si lavora con AJAX. Da notare è che si può scrivere anche:
function Persona() {
this.nome= "";
this.eta= 15;
Persona.prototype.setNome = function(_nome) {
this.nome= _nome;
};
Persona..prototype.setEta = function(_eta) {
this.eta = _eta;
};
}
ovvero tutto all’interno della function. Un altro modo per scrivere la stessa cosa è:
function Persona() {
this.nome= "";
this.eta= 15;
this.setNome = function(_nome) {
this.nome= _nome;
};
this.setEta = function(_eta) {
this.eta = _eta;
};
}
in questo caso, però, il trucchetto dell’ereditarietà non funziona.
L’altro modo per scrivere una classe è quello che ho trovato utilizzato in YahooUI e in jQuery (e nello spezzone di codice dell’articolo precedente) e di cui allego un esempio che dovrebbe essere abbastanza chiarificatore:
<html>
<head>
<script>
p = {
pippo : "ciao",
prova_var: 1,
prova: function()
{
alert(this.pippo + ' - ' + this.prova_var);
}
};
</script>
</head>
<body>
<input type="button" value="bottone" onclick="p.prova()" />
</body>
</html>
è una notazione cha sa di JSON e infatti è basata su quella JSON; definisce l’oggetto già come singola instanza: infatti, come si vede, lo utilizzo tranquillamente nel codice HTML.
Questo è solo qualche appunto, ma per approfondimenti contattate il vostro motore di ricerca di fiducia…
P.S.: Recentemente ho trovato questo link che sipega tutte le notazioni: http://www.phpied.com/3-ways-to-define-a-javascript-class/
Un altro uso per JavaScript
Su Hacker Journal n°173 compare un articolo interessante intitolato “La potenza del Browser”, il quale ha particolarmente attirato la mia attenzione. L’idea è di usare JavaScript nel Distributed Computing, ovvero utilizzare un piccolo script che, ciclicamente, richieda al server la sua parte di lavoro, la elabori e invii la risposta al server, il tutto durante la normale navigazione, senza influire sulla QoS percepita dall’utente (il che significa calibrare opportunamente i timeout). Come esempio l’articolo propone il sito http://jsdc.appspot.com/ di cui vado ad analizzare brevemente il codice sorgente.
_d = {
eh: “http://jsdc.appspot.com/Q?”, indirizzo della pagina del server che distribuisce il carico di lavoro e le risposte
iv:150, timeout iniziale (di default)
f:hex_md5, funzione da richiamare
o:9, “cap interval”
z:150, timeout corrente
n:0,
w: function(){ ritorna semplicemente la data
return(new Date()).getTime()
},
u:function() { elabora il pacchetto di lavoro
var x = _d.w(),
e= _d.e +_d.d[_d.n], _d.d sono le parole da convertire in MD5 (passate dal server)
i=0;
if(x-_d.y-_d.z<_d.o) adatta il carico di lavoro al client
_d.z=_d.iv
else
_d.z=x-_d.y;
if(_d.n<_d.d.length)
{
for(;i<_d.d.length;i++) scorro l’array del carico di lavoro
{
if(_d.f(e+_d.d[i])==_d.h) elaboro le singole parole e confronto con l’hash passato dal server
{
_d.v=e+_d.d[i];
_d.b(); inoltro la richiesta con l’apposita funzione b()
return;
}
};
_d.n++;
_d.y=_d.w();
_d.x=setTimeout(_d.u,_d.z) prossimo ciclo
}
else
_d.b() effettuo la richiesta del primo carico di lavoro
},
g:function(u){ funzione che effettua la richiesta
alert(u);
_d.q = document.createElement(“script”) creo un elemento script
_d.q.src=_d.eh + u; imposto come src dell’elemento script la pagina del server che fa il dispatch delle richieste e accumula le risposte
document.body.appendChild(_d.q) aggiungo al body il nuovo tag
},
b:function(){ funzione che compone la richiesta
_d.cs() fermo il timer
_d.g(“e=”+_d.e+”&h=”+_d.h+”&r=”+_d.v+”&”+_d.w()) compongo per la funzione che effettua la richiesta i parametri del GET
},
cs:function(){ ferma il timer e dunque sospende l’elaborazione
clearTimeout(_d.x);_d.x=null;_d.n=0
}
}
setTimeout(_d.g,2000);inizializza l’elaborazione senza parametri (prima richiesta del carico di lavoro)
Cosa manca? Qualche variabile che viene generata dal server e messa nello script relativo al tag “script” generato dinamicamente. Se puntiamo il nostro browser alla pagina “http://jsdc.appspot.com/Q?”, avremo una risposta del genere:
_d.q.parentNode.removeChild(_d.q); eliminiamo il tag script appena creato, in modo da non averne tanti
_d.i=3200;
_d.d=’ole ala apo 123 ddd ff ttt rot oleole’.split(”); il carico di lavoro: le stringhe di cui provare l’hash md5
_d.d.push(”);
_d.h=’b52f753aa106a9df6a51248744fc464f’; l’hash md5 di riferimento
_d.e=’l d’;
_d.y=_d.w()-_d.z; parametri necessari per la temporizzazione
_d.u(); richiamo la funzione dove elabora il pacchetto di lavoro
_d.v=undefined;
Un’ultima osservazione la faccoamo sulla risposta inviata al server dove la variabile “h” del GET contiene il codice hex che si sta esaminando, la variabile “r” l’eventuale risultato (che sta in _d.v).
In sostanza, se tutto il codice non è proprio chiaro, il meccanismo è chiaro e naturale; inoltre non fa uso di AJAX, ma utilizza solo DOM (Domain Object Model). Sperando di avervi aiutato nella comprensione e ispirato qualche bella idea di utilizzo vi lascio l’avvertimento che si può trovare sul sito: questo codice è un proof of concept, instabile e vulnerabile ad attacchi XSS.
Arduino (1) – Per prima cosa, la programmazione
Descrivo brevemente i passi per installare il software su Windows:
- Scarichiamo l’archivio aggiornato da Google Code
- Scompattiamo l’archivio in una cartella a piacere (ad esempio sul Desktop)
- Colleghiamo attraverso il cavo USB la scheda al PC
- Nella cartella estratta ci saranno i driver relativi (nella cartella “driver”)*
- Una volta installati i driver tutto è pronto
Il primo test di funzionamento da fare, è collegare un led** al pin 13 dal lato delle uscite digiatali (dove c’è la porta USB) e al GND (ovvero Ground): il pin 13 è dotato di un’opportuna resistenza, tale da non far “distruggere” il nostro led. Il programma caricato “in frabbrica” nel microcontrollore, varierà da alta a bassa e viceversa l’uscita del pin, in modo da far accendere e spegnere il led, ovvero da farlo lampeggiare.
Un programma per Arduino o Sketch, viene scritto in un linguaggio molto simile al C (semplificato) e nella sua forma più semplice, è costituito da due funzioni obbligatorie:
- “void setup()“: serve a configurare la piattaforma, ovvero a dire al microcontrollore “di che tipo sono i pin”: di ingresso, di uscita, analogici, digitali…
- “void loop()“: costituisce il ciclo principale del programma, ovvero il codice eseguito dal microcontrollore e che mi specifica il comportamento
Come per il C il corpo della funzione deve essere racchiuso tra parentesi graffe, al cui interno le istruzioni devono essere delimitate da punto e virgola. I costrutti sono quelli del C, inoltre si hanno a disposizione funzioni apposite:
- pinMode() : setta un pin in ingresso o in uscita
- digitalWrite() : setta l’uscita digitale di un pin alta o bassa (high/low)
- digitalRead() : legge lo stato di un pin (alto/basso)
- analogRead() : legge da un ingresso “analogico”***
- analogWrite() : scrive un valore “analogico”*** su un pin
- delay() : sospende l’elaborazione per il tempo specificato
- millis() : ottiene l’istante di esecuzione corrente
inoltre ci sono molte librerie disponibili sul sito e liberamente utilizzabili, anche per i più svariati dispositivi (display, tastiere, mouse, …).
Come si immagina, si possono scrivere funzioni (o librerie di funzioni) di supporto ed eventuali variabili globali possono essere dichiarate all’esterno di tutti i blocchi relativi alle funzioni.
Quello che manca adesso è un bell’esempio; per non cominciare subito con la parte elettronica, proviamo a ripetere il test, scrivendo noi il programma.
A questo punto dobbiamo selezionare dal menu “Tools” la board (nel mio caso “Arduino DuemilaNove con ATMega 328″) e la porta COM* a cui è collegato dallo stesso menù. Possiamo verificare la correttezza del nostro codice, premendo il tasto “Verify” (quello con l’icona play). Infine possiamo premere il tasto “Upload To I/O Board” (penultimo a destra) oppure richiamare il comando dal menù “File”.
NOTE:
* Arduino non è collegata al pc con una connessione USB vera e propria, ma attraverso la più semplice porta COM; è come se avessimo un adattatore usb-seriale che ci collega ad Arduino.
** Il led, come si può notare, è già collegato sulla scheda al pin 13, vicino a quelli di trasmissione (TX) e ricezione (RX) ed è etichettato con la lettera L. Non c’è dunque un vero e proprio bisogno di montare un led per esegure questo test.
*** “Analogico” in realtà quello che si ha è un segnale analogico digitalizzato su ‘n’ livelli, ovvero su un certo numero di bit.
Arduino
Arduino è una piattaforma di prototipazione elettronica che ho conosciuto leggendo “Wired Italia“. La piattaforma è “open source”, ovvero gli schemi sono liberamete disponibili e scaricabili dal sito “http://arduino.cc/“
Come si vede in foto c’è un microcontrollore (nel mio caso un ATMEGA 328 della Atmel), montato su una basetta, per cui facilmente sostituibile; una connessione USB (utilizzabile per programmazione e alimentazione); un’ingresso per l’alimentazione esterna (se non si vuole utilizzare quella USB); un insieme di connettori per ingressi, uscite analogiche e digitali; una serie di connettori per l’alimentazione; connettori ad un bus ICSP.
Io ho ordinato il “KIT Worksop – Base Level” comprendente Arduino DuemilaNove, una BreadBoard con fili già tagliati di differente lunghezza, un cavo USB, e un insieme di componenti elettronici (transitor, led, resistori, diodi, condensatori, sensori di vario tipo, …)
Il software per la scrittura dei programmi e la programmazione sul microcontrollore, è open source e disponibile su Google Code; esso permette di scrivere programmi, in un linguaggio simile al C, caricarli e testarli.
Arduino dunque è un insieme di:
- hardware, ovvero il circuito stampato con su saldati tutti insieme i componenti, disponibile in varie forme e dimensioni;
- software, un’ambiente di programmazione semplice ed intuitivo per la programmazione del microcontrollore;
- la comunità e la filosofia che c’è dietro; il fatto che l’hardware sia open source, permette a tutti di proporre miglioramenti e modifiche, scrivere software e proporre utilizzi sempre innovativi per ogni progetto.
In questa serie di articoli, che io vedo come una specie di diario di bordo, spero di poter condividere con la comunità di internet quanto appreso durante i miei primi passi nel mondo dell’elettronica.
Alla prossima, Nix
