Il mondo di Arduino



Scaricare 74.78 Kb.
01.06.2018
Dimensione del file74.78 Kb.

Il mondo di Arduino
Arduino è una piattaforma low-cost hardware e software programmabile, con cui è possibile creare circuiti per molte applicazioni, soprattutto in ambito di robotica ed automazione. Si basa su un Microcontrollore della ATMEL: per esempio Arduino Uno monta un ATMega328.

Nasce a Ivrea, nel 2005, da un'idea di un professore universitario, un Ingegnere Elettronico, Massimo Banzi, che decise di creare una piattaforma per i propri studenti, così da facilitarli nello studio dell'Interaction Design.

Dal punto di vista Hardware, la scheda di Arduino (prendiamo come esempio Arduino UNO) è pronta all’uso: ha tutto quello che ci serve per programmare il microcontrollore collegando la scheda semplicemente alla porta USB del PC.

Contiene al suo interno un connettore di alimentazione, una porta usb, un integrato che fa da convertitore USB/Seriale, un LED di accensione, un LED di controllo collegato al PIN 13, due led di segnalazione TX/RX, i connettori femmina per il collegamento degli ingressi/uscite tramite cavetti per breadboard e ovviamente il nostro microcontrollore Atmega328 con bootloader Arduino già caricato.


La parte Software invece è rappresentata dal citato bootloader, dalle librerie e dall’IDE, ovvero l’ambiente di sviluppo, l’interfaccia che permette di programmare la nostra scheda Arduino.
Il bootloader precaricato sull’Atmega è quello che permette la comunicazione seriale con il nostro PC. Senza il bootloader, per caricare gli sketch (i nostri “programmi”), avremmo bisogno di un programmatore esterno più costoso, un po’ più macchinoso da utilizzare e più lento nel caricare gli sketch. Il bootloader è quindi un piccolo programma(0.5 kB), residente nella flash memory del microcontrollore, il cui compito è praticamente quello di caricare i nostri sketch compilati, all’interno della memoria flash del microcontrollore tramite comunicazione seriale/usb, facendo si che tale programmazione non vada a sovrascrivere la zona di memoria dove è presente il bootloader. Quindi quando facciamo l’upload di uno sketch andiamo a scrivere in una zona di memoria libera e il bootloader non viene toccato e rimane integro.

In questo modo aprendo l’IDE e selezionando la porta seriale del PC possiamo caricare i nostri sketch con un semplice tasto ed in pochi secondi. L’upload avviene tramite la porta seriale emulata dall’USB, che va a collegarsi ai PIN TX e RX dell’Atmega (piedini rispettivamente 3 e 2).


L’altra parte che riguarda il software sono le librerie. Tali librerie, da importare secondo necessità, aggiungono svariate funzioni che permettono di semplificare enormemente il codice che andiamo a scrivere rendendolo molto più fruibile rispetto a quello standard del microcontrollore. Il tutto viene gestito tramite l’IDE, l’ambiente di sviluppo, il software di gestione vero e proprio,che è l’interfaccia di Arduino con cui noi scriviamo gli sketch nel nostro PC, li salviamo, i compiliamo e li carichiamo nella memoria di Arduino ( save, verify, upload).
Il grande lavoro di semplificazione del progetto Arduino, sia a livello software, sia a livello hardware, ha reso veramente minimali i requisiti per utilizzare il sistema.
Ovviamente serve un personal com­puter che sia in grado di far fun­zionare applicazioni in Java, quindi vanno bene i computer con sistema operativo:

Windows Xp, Vista e Seven (Win­dows 2000 ha dei problemi di dri­ver);

Mac, purché abbiano Mac OS X 10.3.9 o superiore;
Linux con Ubuntu, Debian, Gen­too e molte altre distribuzioni, ricordando che con Linux c'è da faticare un pochino per predisporre tutti i programmi e le librerie richieste.
Il sito di Arduino di­spone di un'area dedicata all'in­stallazione su Linux (arduino.cc/ playground/Learning/Linux) e ti consigliamo di partire da lì se hai intenzione di usare questo siste­ma operativo.

Dato che il sistema di sviluppo è scritto in Java. L’IDE di Arduino UNO richiede una versone di Java correttamente installata e funzio­nante. AI proposito vale la pena fare un giro sul sito www.java.com e uti­lizzare il collegamento "lo ho Java?" per verificare lo stato del computer. La pagina verifica la situazione del software e fornisce le indicazioni, che possono essere una richiesta di installazione, l'aggiornamento o un "tutto OK".





Ti suggeriamo questa soluzione in quanto è molto probabile che tu già abbia sul computer qualche versio­ne dell'ambiente runtime di Java, quindi il suo aggiornamento fatto con le procedure dal sito risultano le più pratiche e veloci.
Scarichiamo e installiamo l'IDE

Nella confezione di Arduino UNO non hai trovato alcun dischetto o memoria contenente il software. Devi obbligatoriamente andare onli­ne su internet e scaricarlo dalla pa­gina "arduino.cc/en/Main/Softwa­re". Qui si trovano le varie versioni disponibili per le relative piattaforme supportate.

AI termine del download avrai un ar­chivio compresso che non contiene uno specifico programma di installa­zione, ma una struttura di cartelle e file da espandere così com'è sul disco rigido del computer, in una car­tella per te comoda. Windows supporta le cartelle compresse in modo nativo da Vista in poi e quindi non è richiesto alcun software accessorio per l'estrazione dei file. Basta fare clic sul file "arduino-1.0.1-windows. zip" - nel caso di Windows - con il tasto destro e scegliere di estrarre i file in una cartella. AI termine dell'estrazione avrai sul tuo computer una struttura di file e cartelle.

L’unico eseguibile nella cartella prin­cipale è "arduino.exe" e determina il lancio dell'ambiente integrato di sviluppo (IDE) scritto in Java. Se creiamo un collegamento di questo eseguibile sul desktop, sulla barra delle applicazioni o nel menu Start, potremo avviare l'IDE con facilità.

Per farlo basta usare il tasto destro del mouse sull'eseguibile e scegliere una delle opzioni corrispondenti nel menù a tendina.
Colleghiamo l’hardware

Questa fase, con il primo collegamento, richiede un pò di attenzione in quanto in quanto il computer deve installare il driver da usb a seriale indispensabile per per far pilotare la scheda dall’IDE.

Se il tuo computer non è stato utiliz­zato in precedenza con schede Ar­duino, dispone di Windows XP e ha avuto una "intensa vita" di collega­menti a periferiche e dispositivi vari, potrebbe avere qualche difficoltà a riconoscere la scheda nel modo corretto. Si tratta di una possibilità remota, ma con Windows XP e i dri­ver USB, le sorprese sono sempre dietro l'angolo. Con Vista e Seven, l'installazione non presenta diffi­coltà specifiche purché si rispetti la procedura indicata. Innanzitutto procurati il cavetto di collegamento fra scheda Arduino UNO e personal computer. Si tratta di un cavetto che da una parte ha un maschio USB di Tipo A - da collegare al computer - e dall'altra un maschio USB Tipo B da collega­re alla scheda. Dato che il connettore Tipo B non è più molto diffuso, potrebbe essere diffi­cile trovare il cavetto necessario nel negozio d'informatica sotto casa.

Con Seven e Vista l'installazione automatica non va buon fine e si ot­tiene un dispositivo sconosciuto fra quelli elencati fra le risorse. Nessun problema perché da questo punto è semplice sistemare le cose. Con il tasto destro sul "Dispositi­vo sconosciuto” scegli “Aggiorna Driver” per cercare il driver giusto che si trova nella cartella Drivers ; dai OK e lascia la scheda collegata alla porta USB. Se durante l’installazione ti appare qualche finestra relativa alla mancanza della firma del driver ect, non farci caso e fai click su continua.

Finita l’installazione , da ora in poi, ogni volta che collegherai Arduino Uno al tuo PC questo lo riconoscerà come una periferica di tipo seriale da COM1 in poi.

Per collaudare l’installazione puoi terminare la sessione del sistema operativo e riavviare il PC senza collegare la scheda , quindi collegarla e vedere se viene riconosciuta correttamente.

La seconda manovra di collaudo consiste nel caricare uno sketch di esempio, compilandolo e scaricandolo sulla scheda di Arduino UNO.

Per far questo, lancia l’IDE e dal menù File scegli Examples> Basic> Blink; si aprirà una finestra completa di IDE con il codice dello sketch caricato e pronto all’uso.

Premi il tasto VERIFY e nella barra in basso appare la scritta compiling… e dopo qualche istante la conferma della creazione del codice oggetto pronto per essere caricato; premi il pulsante upload e osserva il lampeggio dei led TX ed RX della scheda di Arduino in varie ondate che conferma l’avvenuto caricamento del programma.

Al termine avrai come effetto che il LED collegato al pin 13 e contrassegnato dalla scritta Led sulla scheda lampeggerà lentamente con la cadenza di un secondo acceso e un secondo spento. Adesso prova tu qualche piccola modifica al programma……….(per esempio accelera la velocità di lampeggio).




Arduino Uno Rev3 è una scheda elettronica con le seguenti caratteristiche:

 

  • Microcontrollore: ATmega328

  • Tensione di funzionamento: 5 V

  • Tensione di alimentazione (raccomandata): da 7 a 12 V

  • Tensione di alimentazione (limiti): 6-20V

  • Ingressi/uscite Digitali: 14 (di cui 6 possono essere utilizzate come uscite PWM)

  • Ingressi analogici: 6

  • Corrente Dc per pin I/O: 40 mA

  • Corrente DC per pin 3,3 V: 50 mA

  • Memoria Flash: 32 kB (di cui 0,5 kB utilizzati dal bootloader)

  • SRAM: 2 kB

  • EEPROM: 1 kB

  • Velocità di Clock : 16 MHz

La soluzione realizzata per programmare la scheda di Arduino UNO nasconde tutta una serie di passaggi, di configurazione e di programmi che altrimenti avrebbero richiesto capacità e preparazione per essere messi a punto e utilizzati.

Il grande lavoro svolto dal team di Arduino è stato quindi in gran parte creare l’ambiente di sviluppo (IDE) grazie al quale sembra tutto molto più semplice e lineare, mentre dietro all’interfaccia scritta in linguaggio Java si trovano migliaia di file che permettono al tuo computer di trasformare il programma nel modo opportuno e riducendo al minimo l’insorgere di problemi di compilazione( il processo che trasforma il programma scritto con il linguaggio ad alto livello in codice macchine adatto al microcontrollore presente sulla scheda) .

Oltre a creare il codice e a scaricarlo sul microcontrollore della scheda (upload), l’IDE permette anche di raccogliere informazioni di ritorno dalla scheda stessa.

Con la sua schiera di porte e di pin di ingresso e di uscita, Arduino è in grado di acquisire informazioni da una miriade di sensori e dispositivi elettronici, potendo allo stesso tempo accendere luci, pilotare motori, emettere suoni , attivare dispositivi.

Una volta ultimato il processo creativo e di programmazione, Arduino UNO potrà anche operare senza PC,autonomamente, eseguendo le istruzioni inserite al suo interno.

I programmi di Arduino(il linguaggio usato è una versione semplificata del C/C++, arricchito da una serie di funzioni specifiche della scheda) si chiamano sketch cioè bozzetti, gli schizzi che gli artisti fanno per mettere su carta le proprie idee con dettagli sempre maggiori; senza idee non ci sono neanche i bozzetti: il foglio resta bianco.

Anche il tuo Arduino resta un mucchietto di elettronica se non aggiungi le tue idee e la tua creatività. La tua creatività e le tue capacità di ideare progetti per Arduino UNO vanno quindi stimolate sperimentando un po’ in tutti i vari campi applicativi.

Ma come strutturare le idee affinché possano diventare un programma? Basta trasformarle in piccoli passi logici che descrivono funzionalmente quello che deve succedere. Il primo passo è la creazione di un diagramma di flusso(flow chart); i diagrammi di flusso sono di per sé una forma di programmazione e sono ad un livello tale di astrazione da essere da un lato comprensibili a tutti e dall’altro sufficienti a descrivere un programma nella sua totalità. Con un programma di flusso ben fatto, un “programmatore” è in grado di scrivere il codice, mentre l’autore è in grado di dettagliare ciascuna funzione senza conoscere le caratteristiche specifiche del linguaggio di programmazione che verrà utilizzato.

Per fare qualche esempio, un dia­gramma di flusso può essere visto come una serie di frasi che descri­vono passo a passo quello che suc­cede, utilizzando delle strutture gra­fiche predefinite per evidenziare gli elementi tipici della programmazio­ne quali i salti condizionali, i loop (la ripetizione di una serie di istruzioni), l'ingresso e l'uscita di informazioni. Un flusso può quindi essere basato su una "storia" come quella di una luce temporizzata sulle scale(vedi flow chart): pre­dispongo tutto, leggo se un tasto è chiuso (premuto) o aperto (rila­sciato), se è chiuso passo alla fase successiva, altrimenti aspetto. Se l'interruttore è chiuso allora cambio stato alla lampadina aspettando un minuto, quindi torno a controllare se l'interruttore è premuto ricomin­ciando da capo.


Guardando questo schema, si capisce sia cosa si deve fare per realizzare il programma, sia cosa il programma stesso faccia nel suo complesso.
Due risultati molto importanti che dimostrano quanto l'ideazione del programma non sia nella scrittura del codice, ma nella creazione di un diagramma di flusso dettagliato e logicamente completo.
Non possiamo dire "funzionante" per un diagramma di flusso, ma è chiaro che la completezza dal punto di vista logico presuppone che chi lo ha ideato si sia posto una serie di domande alle quali ha dato una risposta esaustiva.
Piedinatura del Microcontrollore ATMega328



Spiegazione dell'Atmega328:

Atmega328 è la sigla di questo microcontrollore. All'interno di questo componente viene salvato il programma scritto dall'utente e tutta la configurazione di base che permette ad Arduino un funzionamento corretto. Quando acquisterete Arduino Uno riceverete uno di questi microcontrollori con solamente il Bootloader all'interno dell'ATMega328. Questo "file" è una configurazione di base che permette l'utilizzo del software dedicato.


Questo setting puo' essere modificato per utilizzare un software differente e per modificare la posizione e configurazione dei PIN.

 






























Istruzioni standard di Arduino.


Qui di seguito sono riportate le istruzioni standard supportate dal linguaggio di programmazione di Arduino (derivato dal C e C++).

 
STRUTTURA

Il codice di qualsiasi programma per Arduino è composto essenzialmente di due parti:

void setup() - Questo è il posto dove mettiamo il codice di inizializzazione. Inizializza tutte le impostazioni e le istruzioni della

scheda (gli INPUT e OUTPUT) prima che il ciclo principale del programma si avvii.



void loop() - E' il contenitore del codice principale del programma. Contiene una serie di istruzioni che possono essere ripetute

una dopo l'altra fino a quando non spegniamo la scheda Arduino.

 

COSTANTI

Nella scheda Arduino è inserita una serie predefinita di parole chiave con valori speciali. High e Low sono usati per esempio quando si vuole accendere o spegnere un Pin di Arduino. INPUT e OUTPUT sono usate per definire se uno specifico Pin deve essere un dato di entrata o un dato di uscita. True e False indicano il rispettivo significato italiano: se abbiamo un'istruzione, la condizione può essere vera o falsa.

 
VARIABILI

Sono aree della memoria di Arduino dove si possono registrare dati e intervenire all’interno del programma. Come dice il nome stesso, le variabili possono essere cambiate tutte le volte che vogliamo. Quando si dichiara una variabile bisogna dichiararne anche il tipo. Questo significa dire al processore le dimensioni del valore che si vuole memorizzare. Ne esistono di diversi tipi:
 

boolean - Può assumere solamente due valori: vero o falso.

char - Contiene un singolo carattere. L'Arduino lo registra come un numero (ma noi vediamo il testo). Quando i caratteri  sono

usati per registrare un numero, possono contenere un valore compreso tra -128 e 127.



byte - Può contenere un numero tra 0 e 255. Come un carattere usa solamente un byte di memoria.

int - Contiene un numero compreso tra -32'768 e 32'767. E' il tipo di variabile più usata e usa 2 byte di memoria.

unsigned int - Ha la stessa funzione di int, solo che non può contenere numeri negativi, ma numeri tra 0 e 65.535.

long - E' il doppio delle dimensioni di un int e contiene i numeri da -2'147'483'648 a 2'147'483'647.

unsigned long - Versione senza segno di long va da 0 a 4'294'967''295.

float - Può memorizzare numeri con la virgola. Occupa 4 bytes della RAM.

double - A doppia precisione in virgola mobile con valore massimo di 1'7976931348623157x10^308.

string - Un set di caratteri ASCII utilizzati per memorizzare informazioni di testo. Per la memoria, usa un byte per ogni carattere

della stringa, più un carattere NULL che indica ad Arduino la fine della stringa. Esempio:

    char string1[] = "Hello"; // 5 caratteri+carattere NULL   
char string2[6]="Hello" 
 // La stessa cosa di sopra

N.B. ogni istruzione deve sempre terminare con ";" in tale linguaggio. Inoltre "//" è usato per inserire commenti che aiutano a comprenderlo.



array - un elenco di variabili accessibili tramite un indice. Vengono utilizzate per creare tabelle di valori facilmente accessibili. Come

esempio se si vuole memorizzare diversi livelli di luminosità di un LED possiamo creare 4 variabili, una per ogni livello di luminosità.

Si può utilizzare una semplice array come:

    int Luce[5]={0,25,50,100};

Nel tipo della variabile la parola "array" non si dichiara, ma si usano i simboli [] e {}.

 
STRUTTURE DI CONTROLLO

Il linguaggio di Arduino include parole chiave per controllare il progetto logico del nostro codice.

If…else - Permette di prendere delle decisioni all’interno del programma, ma deve essere seguito da una domanda sotto forma di

espressione tra parentesi. Se la domanda è vera tutto ciò che segue verrà eseguito. Se falso verrà eseguito tutto il codice che

segue else. If  è possibile usarlo senza usare necessariamente else. Esempio:

    if (val=1){digitalWrite(LED, HIGH);} // (val=1) è la domanda se è vera esegue ciò che è fra parentesi




For - Ripete il codice per un numero predefinito di volte.

    for(int i=0;i<10;i++){Serial.print(“Ciao”);}  //stampa 10 volte “Ciao”



Switch - E’ come un interruttore nel corso del programma. Fa prendere al programma diverse direzioni in base al valore della

variabile (il suo nome deve essere messo tra parentesi dopo switch). E’ utile perché può sostituire lunghe serie di if.

       switch(valore sensore){
case 38:
digitalwrite(12, High);break;
case 55:
digitalwrite(3, High);break;
default:
 // si usa per

       indicare tutti i casi in cui non è ne 38 ne 55
digitalwrite(12, Low);
digitalwrite(13, Low);}


While - Esegue un blocco di codice fino a quando una certa condizione posta tra le parentesi è vera.

    while(valore sensore<500){


digitalWrite(13, HIGH);
delay(100);
digitalWrite (13, HIGH);


    
delay(100);
Valoresensore=analogRead(1);


Do…While - E’ uguale a while solo che il codice è avviato prima che la condizione sia verificata. Si usa quando si vuole eseguire il

codice almeno una volta prima che la condizione sia valutata. Esempio:

 

    do {


digitalWrite(13,HIGH);
delay(100);
digitalWrite(13,HIGH);
DELAY (100);


   
valore sensore=analogread(1);
}


Break - Questo termine consente di bloccare il ciclo e continuare ad eseguire il codice fuori dal ciclo. Viene utilizzato anche per

separare le varie condizioni nella funzione Switch.



Continue - Questo comando fa saltare il resto del codice all’interno del ciclo, e riavvia il ciclo. Esempio:

    for(luminosità=0; luminosità<200; luminosità++)


f((x>120) && (x<180)) continue;

   
analogWrite(PWMPin, luminosità);
delay(20);
}


Return - Ferma una funzione che si sta eseguendo e restituisce un risultato. E’ possibile infatti usarlo per restituire un valore da

una funzione. Esempio chiama una funzione “calcolaumidità” e ritorna il valore dell’umidità.

    Int calcolaumidità() {
Int umidità=0;
umidità0(analogread(0)+45/100)/100;
return umidità;
}

 

OPERAZIONI ARITMETICHE



Si può usare Arduino per compiere operazioni matematiche complesse con una semplice sintassi: + e – indicano addizione e

sottrazione, * indica la moltiplicazione, e / la divisione.


C’è un operatore in più in questo linguaggio chiamato “Modulo” che è un comando che restituisce il resto di una divisione. Esempio:

    a=3+3; luminosità=((12*valore sensore)/4);

 
OPERATORI DI COMPARAZIONE

Quando si specificano delle condizioni ci sono vari operatori che tu puoi usare:

== Uguale a

> maggiore di

< minore di

!= diverso da



<= minore o uguale

>= maggiore o uguale

 
OPERATORI BOOLEANI

Sono usati quando si vogliono combinare più condizioni, ad esempio se vogliamo verificare se il valore di un sensore è tra 1 e 5

basta scrivere:

     if(sensore=>1) && (sensore=<=5);

Esistono tre tipi di operazioni booleane:    &&(And),   ||(Or),    !(Not).

 
OPERATORI COMPUTAZIONALI

Servono a ridurre la mole di un codice e a renderlo più semplice e chiaro per operazioni semplici come incrementare o

decrementare una variabile.

Esempio: val=val+1; è come dire val++

incremento (++) e decremento (--)

++ e -- incrementano/decrementano una variabile di 1; lo stesso è applicabile a +=, -=, *=, /= .

Esempio: le seguenti espressioni sono equivalenti:

val=val+5;

Val+=5;


 
FUNZIONI INPUT E OUTPUT

Arduino include funzioni per la gestione degli Input e degli Output.


 

pinMode(pin,mode) - Riconfigura un pin digitale a comportarsi come uscita o come entrata.

pinMode(13,INPUT) - imposta il pin 13 come Input.

digitalWrite(pin,value) - imposta un pin digitale ad ON o a OFF.

digitalWrite(7,HIGH) - imposta come digitale il pin 7.

int digitalRead(pin) - Legge lo stato di un input Pin, ritorna HIGH se il Pin riceve della tensione oppure LOW se non c’è tensione

applicata.

    Val=digitalRead(7); // legge il pin 7 dentro a val

Int analogRead(pin) - Legge la tensione applicata a un ingresso analogico e ritorna un numero tra 0 e 1023 che rappresenta le

tensioni tra 0 e 5 V.

     val=AnalogRead(0); // legge l’ingresso analogico 0 dentro a val

analogWrite(pin,value) - Cambia la frequenza PWM su uno dei pin segnati PWM, nella voce pin si può mettere 11 10 9 6 5 3,

value invece può essere un valore da 0 a 255 che rappresenta la scala da 0 a 5 V.

     analogWrite(9,128);

shiftOut(dataPin, clock, Pin, bit, Order, value) - Invia i dati ad un registro. Questo protocollo usa un pin per i dati e uno per il

clock. bitOrder indica l'ordine dei bytes (least significant byte=LSB, most significant byte=LMB) e value è il byte da inviare. Esempio:

          shiftOut(dataPin, Clock Pin, LSBFIRST, 255);

insigned long pulseIn(pin, value) - misura la durata degli impulsi in arrivo su uno degli ingressi digitali. E’ utile ad esempio per

leggere alcuni sensori a infrarossi o alcuni accelerometri che emettono impulsi di diversa durata.

           Tempo=pulsin(8,HIGH);

 
FUNZIONI DI TEMPO

Arduino include alcune funzioni per misurare il tempo trascorso e anche per mettere in pausa il nostro programma.

Insigned long millis() - Ritorna il numero in millisecondi trascorsi dall’inizio del programma, esempio:

     durata=millis()-tempo // calcola il tempo trascorso prima di “tempo”



delay(ms) - Mette in pausa il programma per un numero di millisecondi specificato.

     delay(1000); //stoppa il programma per 1 secondo



delayMicroseconds(us) - Come delay mette in pausa il programma ma l’unità di misura è molto più piccola, parliamo di microsecondi.

     delayMicroseconds(2000); // aspetta per 2 millisecondi (1000us=1ms)

 
FUNZIONI MATEMATICHE

Arduino include molte funzioni matematiche comuni. Servono, per esempio, per trovare il numero max o il numero min.


 

min (x,y) - Ritorna il più piccolo fra x e y. Esempio:

     Val= min(5,20);  // val adesso è 5



max(x,y) - Ritorna il più grande  fra x e y.

abs(x) - Ritorna il valore assoluto di x, ossia trasforma i numeri negativi in numeri positivi. Se x fosse 5 ritorna 5, ma anche se x

fosse -5 ritorna sempre 5. Esempio:

     Val= abs(-5) // val vale 5

constrain(x,a,b) - Ritorna il valore "x" costretta tra "a" e "b". Ciò vuol dire che se "x" è minore di "a" ritornerà semplicemente

"a" e se x è maggiore di "b" restituirà semplicemente il valore di "b".



map(value, fromLow, fromHigh, toHigh) - Associa un valore che sta nel range fromLow e maxlow in un nuovo range che va

da toLow a toHigh. E’ molto utile per processare valori provenienti da sensori analogici. Esempio:

     val=map(analogRead(0),0,1023,100,200);  // associa il valore analogico 0 ad un valore tra 100 e 200

double pow(base,exponent) - Restituisce come risultato la potenza di un numero. Si deve indicare la base e l’esponente.

Double sqrt(x) -  Restituisce la radice quadrata di un numero x.

Double sin(rad) - Restituisce il seno dell’angolo specificato in radianti. Esempio:

     Double sine= sine(2); // circa 0.909297370



Double cos(rad) - Restituisce il coseno dell’ angolo specificato in radianti.

Double tan(rad) - Restituisce il valore della tangente di un angolo specificato in radianti.

 

FUNZIONI NUMERI RANDOM

Se si ha bisogno di generare numeri random (a caso), Arduino ci viene incontro con alcuni comandi standard per generarli.

randomSeed(seed) - Anche se la distribuzione di numeri  restituita dal comando random() è essenzialmente casuale, la sequenza

è prevedibile. randomSeed(seed) inizializza il generatore di numeri pseudo-casuali, facendola partire da un punto arbitrario nella sua

sequenza casuale.

Long random(min,max) - Restituisce un valore long intero di valore compreso fra min e max -1. Se min non è specificato il suo

valore minimo è 0. Esempio:

     long random= random(13); // numero compreso fra 0 e 12

 

COMUNICAZIONE SERIALE

Queste sono le funzione seriali cioè quelle funzioni che Arduino usa per comunicare tramite la porta Usb del nostro Pc.

Serial.begin(speed) - Prepara Arduino a mandare e a ricevere dati tramite porta seriale. Possiamo usare generalmente 9600 bits

per secondo con la porta seriale dell’Arduino, ma sono disponibili anche altre velocità, di solito non si supera i 115.200 bps.

     Serial.print(data)Serial.begin(9600);

Serial.print(data,codifica) - Invia alcuni dati alla porta seriale. La codifica è opzionale.

     Serial.print(32);  // stampa 32

     Serial.Print(32, DEC);   // stampa 32 come sopra

     Serial.Print(32, OCT);  // 40  (stampa10 in ottale)

     Serial.Print(32 , BIN);  // 100000 (stampa 10 in binario)

     Serial.Print(32 , BYTE);  // “Space” valore associato nella tabella ASCII



Int Serial.available() - Ritorna quanti bytes non ancora letti sono disponibili sulla porta Serial per leggerli tramite la funzione

read(). Dopo aver read() tutti i bytes disponibili Serial.Available restituisce 0 fino a quando nuovi dati non giungono sulla Porta.

 

Int.Serial.read() - Recupera un byte di dati in entrata sulla porta Seriale.

     int data= Serial.read();

Poichè i dati possono giungere nella porta seriale prima che il programma li possa leggere(per la velocità), Arduino salva tutti i dati

in un buffer. Se è necessario ripulire il buffer e aggiornarlo con i dati aggiornati, usiamo la funzione flush().



     Serial.flush();




©astratto.info 2017
invia messaggio

    Pagina principale