Programmare con Arduino

Passo dopopasso per imparare il linguaggio di

programmazione Arduino
2021

terza edizione

Di John Bach
mEmlnc.com
"La programmazione non riguarda ciò che sai, ma ciò
che puoi capire . " - Chris Pine
Questo libro ti aiuterà a sviluppare un codice sorgente funzionante per il
microcontrollore Arduino. In queste pagine, ci occuperemo principalmente
dell'aspetto software dell'informatica fisica, progettando codice per lavorare
con oggetti fisici che mostrano comportamento o interattività attraverso il
software. A partire dal contesto di base diPiattaforma Arduino per essere
operativi con il nostro primo codice, discuteremo la struttura e la sintassi del
linguaggio di programmazione basato su C di Arduino, esaminando variabili,
strutture di controllo, array e memoria. Questo libro esaminerà quindi molte
delle funzioni esclusive dello sviluppo di Arduino per il controllo di ingressi
e uscite digitali e analogici, temporizzazione, casualità, funzioni di scrittura e
utilizzo di molte delle librerie Arduino per lavorare con diversi tipi di
hardware e protocolli di comunicazione. Arduino, come Processing prima di
esso, adottò l'idea di uno sketchbook di codice. Continueremo questa
metafora mentre parliamo del processo di abbozzo nel codice come metodo
intuitivo per testare rapidamente nuove idee nel codice. La maggior parte di
questo libro è scritta intorno all'idea di sviluppare abilità di programmazione
attraverso lo sketch. Forniremo anche alcuni suggerimenti per nuovi progetti
e hardware, nuovi linguaggi da provare e modi per contribuire alla comunità.
Questo libro intenzionalmente non si sofferma troppo a lungo sulla teoria
dell'elettronica, sulla progettazione dei circuiti, sull'hacking o su altre pratiche
specificamente basate sull'hardware, anche se nel nostro ultimo capitolo
rivisiteremo il lato hardware delle cose per fornire una piccola base per il
calcolo fisico. Questo libro in molti modi riprende da dove si era interrotto il
Notebook di programmazione Arduino, con discussioni ancora più
approfondite sull'ambiente Arduino; esempi di codice semplici e senza
fronzoli; e schemi chiari e di facile lettura eIl Notebook, un piccolo opuscolo
in PDF, è stata la mia prima esperienza di scrittura su Arduino e non è mai
stato concepito come una breve guida per i miei studenti quando ho
introdotto per la prima volta su Arduino una classe di 15 studenti universitari
di arte e design nel 2007 I migliori progetti e tutto il resto, questo piccolo
libretto è stato ora tradotto in spagnolo, russo e olandese (che io sappia), è
ospitato in così tanti luoghi diversi di cui è impossibile tenerne traccia ed è
stato utilizzato nei laboratori e classi in tutto il mondo. Non ho aggiornato il
taccuino negli ultimi anni e, in tutta onestà, non sono del tutto sicuro di cosa
farne ora, quindi spero che questo nuovo libro riempirà un vuoto e troverà
un'adozione simile e diffusa che il piccolo opuscolo ha goduto tutti questi
anni.
introduzione
Ambiente di codifica Arduino e strumenti di base
Che lingua è Arduino?
IDE Arduino
Capitolo primo
Transazioni in linguaggio Arduino
Transazioni aritmetiche in Arduino
Bilancio delle transazioni in Arduino
Transazioni booleane in Arduino
Indice delle transazioni di accesso in Arduino
Coefficienti di numeri binari in Arduino
Transazioni composte in Arduino
Capitolo II
Tipi di dati
L'oggetto String in Arduino
Struttura generale
Valori restituiti
Minion
Transazioni
Array in Arduino
Crea un array
Accesso alla matrice
Digita bool in Arduino
byte in Arduino
Digita char in Arduino
Digita double in Arduino
Digita float in Arduino
Struttura generale
Digita int in Arduino
Stringhe in Arduino
Struttura generale
Carattere di terminazione nullo
Avvolgimento di stringhe lunghe
Matrici di stringhe di testo
Digita la parola in Arduino
La parola chiave void in Arduino
Capitolo III
Costanti e variabili
Sistema decimale (base 10)
Sistema binario (Base 2)
Note e avvertenze
Costanti in Arduino
Ambito e qualificazioni variabili
La parola chiave const in Arduino
Il campo delle variabili in Arduino
La parola chiave statica in Arduino
Esempi
Parola chiave volatile in Arduino
Interi volatili o lunghi volatili?
Capitolo IV
Strutture di controllo
Interruzione di parole chiave in Arduino
Continua la parola chiave in Arduino
Loop do ... mentre iterativo in Arduino
Altre parole chiave in Arduino
Vai alla parola chiave in arduino
Espressione se condizionale in Arduino
Note e avvertenze
Restituzione di parole chiave in Arduino
Esempi
Interruttore di espressione ... case in Arduino
Transazioni
Mentre l'episodio iterativo in Arduino
Capitolo V
Funzioni
La funzione digitalRead () in Arduino
digitalRead (pin)
La funzione digitalWrite () in Arduino
La funzione pinMode () in Arduino
Funzioni del tempo in Arduino
La funzione delay () in Arduino
Funzione Arduino delayMicroseconds ()
Funzione Arduino micros ()
Funzione Arduino millis ()
Funzioni matematiche in Arduino
Gestione e verifica dei caratteri tipografici in Arduino
Funzioni di conversione di Arduino
Funzioni di controllo provinciale in Arduino

introduzione
Dal lancio della piattaforma open source Arduino, il marchio si è affermato al
centro di un'ampia comunità open source. L'ecosistema Arduino è composto
da una diversa combinazione di hardware e software. La versatilità di
Arduino e la sua semplice interfaccia lo rendono una scelta leader per una
vasta gamma di utenti in tutto il mondo, da hobbisti, designer e artisti ai
prototipi di prodotti.
La scheda Arduino è collegata a un computer tramite USB, dove si connette
con l'ambiente di sviluppo Arduino (IDE). L'utente scrive il codice Arduino
nell'IDE, quindi lo carica sul microcontrollore che esegue il codice,
interagendo con ingressi e uscite come sensori, motori e luci.

Sia i principianti che gli esperti hanno accesso a una vasta gamma di risorse e
materiali gratuiti per supportarli. Gli utenti possono cercare informazioni su
come configurare la propria scheda o anche su come codificare su Arduino.
L'open source dietro Arduino lo ha reso particolarmente amichevole per gli
utenti nuovi ed esperti. Ci sono migliaia di esempi di codice Arduino
disponibili online. In questo libro, noi spiegheremo tutti i principi di base che
ha bisogno un programmatore alle prime armi per entrare nel mondo genio,
Arduino
 Ambiente di codifica Arduino e strumenti di base

Che lingua è Arduino?

Il codice Arduino è scritto in C ++ con l'aggiunta di metodi
e funzioni speciali, che menzioneremo più avanti. C ++ è
un linguaggio di programmazione leggibile dall'uomo.
Quando crei uno "schizzo" (il nome dato ai file di codice
Arduino), viene elaborato e compilato in linguaggio
macchina.
IDE Arduino
Arduino Integrated Development Environment (IDE) è il
principale programma di modifica del testo utilizzato per la
programmazione Arduino. È qui che digiterai il tuo codice
prima di caricarlo sulla scheda che desideri programmare.
Il codice Arduino è indicato come schizzi.

Arduino è una piattaforma open source utilizzata per creare progetti

elettronici (che vanno da progetti semplici come termometri a progetti
complessi come robot, stampanti 3D e applicazioni IoT). L'obiettivo
principale della creazione della piattaforma Arduino è fornire una piattaforma
user-friendly per aiutare le persone senza una conoscenza preliminare
dell'elettronica e della programmazione. La piattaforma Arduino è composta
da due sezioni principali: la sezione hardware e la sezione software. La
sezione hardware è costituita da una scheda Arduino e relativi componenti
elettronici e altri componenti hardware, mentre la sezione software è
costituita dall'Arduino Development Environment (Arduino IDE), che
rappresenta l'ambiente host per la scrittura del codice in linguaggio Arduino e
il caricamento su Schede Arduino per il controllo della sezione hardware.

Arduino è solo un insieme di funzioni C / C ++, che derivano principalmente

da C e C ++ e dai framework di cablaggio ed elaborazione e sono open
source. Il linguaggio Arduino viene utilizzato per programmare schede
Arduino di vario tipo. Arduino è diverso dal linguaggio derivato dal C,
essendo un linguaggio orientato agli oggetti, contenente molte classi e oggetti
come String e Stream. Inoltre, Arduino è ricco di molte librerie che
forniscono più funzionalità come lavorare con qualsiasi pezzo o elemento
elettronico aggiuntivo, modificare dati, ecc. Arduino non è solo richiesto per
essere utilizzato con l'IDE di Arduino, ma può anche essere utilizzato con -
ambienti di sviluppo di parti come Eclipse.

Capitolo primo
Transazioni in linguaggio Arduino

Transazioni aritmetiche in Arduino

Operatori aritmetici eseguono le quattro operazioni di base (addizione,

sottrazione, moltiplicazione e divisione) in aggiunta ad altre operazioni come
calcolare il resto della divisione e assegnazione di valori di variabili.
Modulo%
Calcola il resto dividendo due numeri l'uno per l'altro.

Laboratori *
Calcola il prodotto della moltiplicazione di due numeri insieme.

OPERAZIONE +
Calcola il risultato della somma di due numeri insieme.

-
Calcola il risultato della sottrazione di due numeri l'uno dall'altro.

Laboratori /
Calcola il risultato della divisione di due numeri per uno.

Parametro =
Il coefficiente di attribuzione dice al controller di valutare l'espressione o il
valore sul lato destro del coefficiente = qualunque e memorizzarlo nella
variabile sul lato sinistro di quel coefficiente.

Bilancio delle transazioni in Arduino

Gli operatori di confronto eseguono un processo di bilanciamento, come

viene chiamato, tra due valori, due variabili, una variabile e un determinato
valore, quindi restituiscono un valore logico che rappresenta lo stato di un
operatore (maggiore, minore, uguale, ecc.) Relativo all'altro.
Parametro! =
Bilanciare due valori o due variabili e restituire il valore vero se non sono
uguali.

parametro <
Bilanciare due valori o due variabili e restituire il valore vero se il
coefficiente sul lato sinistro è completamente minore del coefficiente sul lato
destro.

Parametro <=
Saldi due o due valori e ritorna vero se il coefficiente sul lato sinistro è
minore o uguale al coefficiente sul lato destro.

Parametro ==
Bilancia due o due variabili e restituisce vero se il coefficiente sul lato
sinistro è uguale al coefficiente sul lato destro.

Parametro>
Bilanciare due valori o due variabili e restituire il valore vero se il
coefficiente sul lato sinistro è esattamente maggiore del coefficiente sul lato
destro.

Parametro> =
Bilanciare due o due valori e restituisce true se il coefficiente sul lato sinistro
è maggiore o uguale al coefficiente sul lato destro.
Transazioni booleane in Arduino

Gli operatori booleani eseguono operatori booleani (operazione AND,

operazione OR o operazione NOT) su valori o espressioni logiche e
restituiscono il valore booleano risultante.

!
La logica riflette il valore o l'espressione logica che la precede applicandovi
l'operazione logica NOT;

&&
Applica l'operazione logica AND a due espressioni o valori logici e
restituisce il valore logico risultante

||
Applica l'operazione OR logico a due espressioni o valori logici e restituisce
il valore logico risultante

Indice delle transazioni di accesso in Arduino

Pointer Accesso Operatori (Pointer Accesso Operatori) sono operazioni che

vengono utilizzati con i cursori per fornire l'accesso cursore e riferimenti a
indirizzi di memoria delle variabili, e le variabili ai valori di accesso
contenuti in indirizzi di memoria a cui fa riferimento cursori.
&
Viene utilizzato per fornire un riferimento all'indirizzo di memoria di
riferimento di una variabile. Un riferimento è una caratteristica importante
utilizzata con i puntatori.

*
Viene utilizzato per fornire l'accesso a un valore memorizzato in uno
specifico indirizzo di memoria (Dereferencing) di un indicatore. L'accesso ai
dati archiviati negli indirizzi di memoria è una caratteristica importante
utilizzata con i puntatori.

Coefficienti di numeri binari in Arduino

Operatori bitwise esegue tutte le operazioni logiche sui bit e offset numerici e
valori binari e restituisce il valore risultante.

&
In C ++, l'operazione AND viene eseguita su ciascuno dei due bit
corrispondenti dei numeri dati in modo indipendente e fornisce il valore
numerico risultante.

>>
I bit alla sua sinistra verso sinistra spostano un numero specificato di cifre
uguale al valore a destra.

<<
I bit a sinistra di esso a destra spostano un numero specificato di cifre uguale
al valore a destra.

^
In C ++, l'operazione XOR viene eseguita su ciascuno dei due bit
corrispondenti dei numeri dati in modo indipendente e fornisce il valore
numerico risultante.

|
In C ++, l'OR opera su ciascuno dei due bit corrispondenti dei due numeri
dati in modo indipendente e fornisce il valore numerico risultante.

~
In C ++, l'operazione NOT viene eseguita su ciascuno dei bit dati
indipendentemente, a differenza del coefficiente & & | - e fornisce il valore
numerico risultante.

Transazioni composte in Arduino

Gli operatori composti vengono spesso utilizzati per scrivere codici Arduino
a zero, ottimizzare e invertito alcuni bit in valori binari ed altri importanti
processi che semplificano notevolmente e scrittura codice di semplificazione.

Parametro = &
Di solito viene utilizzato con una variabile costante per azzerare un valore di
bit specifico (ad esempio, impostare un valore 0 o LOW).

Modulo = *
È una scorciatoia per moltiplicare il valore corrente di una variabile per una
costante o per un'altra variabile e quindi memorizzare il risultato nella stessa
variabile.

OPERAZIONE ++
Aumenta il valore della variabile utilizzata di 1.

Parametro = +
Una scorciatoia è il processo di combinazione del valore corrente di una
variabile con una costante o un'altra variabile e quindi di memorizzare il
risultato nella stessa variabile.

-
Diminuisce il valore della variabile utilizzata di 1.

Modulo = -
Una scorciatoia per una costante o un'altra variabile viene sottratta dal valore
corrente di una variabile e il risultato viene memorizzato nella variabile
stessa.

Modulo = /
Una scorciatoia è un processo di divisione del valore corrente di una variabile
per una costante o un'altra variabile e quindi di memorizzare il risultato nella
stessa variabile.

Modulo = ^
Solitamente utilizzato con una variabile costante per invertire (invertire) un
valore di bit specifico.

Parametro = |
Di solito viene utilizzato con una variabile di costante per impostare un
valore di bit specifico (impostato su 1 o ALTO).
 Capitolo II
Tipi di dati
L'oggetto String in Arduino

La funzione String () crea una copia della classe String. Esistono diversi modi
per creare stringhe di testo di diversi tipi di dati: chiamare la funzione String
() con:

Stringa di testo statica di caratteri tra virgolette doppie (ovvero un array di

caratteri) o
Un singolo carattere costante tra virgolette singole o
Un'altra copia dell'oggetto String, o
Costante intero o numero costante lungo, o
Un numero intero fisso o un numero fisso lungo utilizzando una base
specificata o
Numero intero o variabile lunga, o
Variabile numero intero o lungo utilizzando una base specificata o
Un numero decimale o doppio decimale utilizzando posizioni decimali
specificate.

Se chiamate la funzione String () con un numero, viene creata una stringa di

testo contenente una rappresentazione dei numeri di quel numero tramite
caratteri ASCII. La base predefinita utilizzata in questo caso è 10. Viene
fornito il seguente esempio:
String thisString = String (13);

Stringa di testo "13". È possibile utilizzare una base diversa come:

String thisString = String (13, HEX);

Fornirai la stringa di testo "D" che è la rappresentazione esadecimale del

valore decimale di 13. Se preferisci il binario, prova questo esempio:

String thisString = String (13, BIN);

Che darà la stringa di testo "1101" che è la rappresentazione binaria del

valore decimale di 13.

Struttura generale

Stringa ( val )
Stringa ( val , base)
String ( val , decimalPlaces )
Transazioni
val
La variabile o il valore da formattare come stringa di testo. I tipi di dati
consentiti sono : stringa di testo, carattere tipografico, byte, numero intero,
numero intero inutile, numero lungo inutile, numero decimale e
moltiplicatore decimale.

base
Il coefficiente opzionale determina la base del sistema numerico in cui verrà
formattato il valore numerico. Il valore predefinito è: DEC.

decimali
Limita il numero di posizioni decimali (numeri dopo la virgola) al decimale o
al multiplo del decimale.

Valori restituiti
Viene restituita una copia della classe String contenente il valore val .

Esempi
Tutti i seguenti sono validi esempi di utilizzo della funzione String ():
String stringOne = "Hello String"; // Usa una stringa di testo fissa
String stringOne = String ('a'); // Converte un carattere tipografico fisso in
una stringa di testo
String stringTwo = String ("Questa è una stringa"); // String Converte una
stringa di testo statica in un oggetto di tipo
String stringOne = String ( stringTwo + "con più"); // Combina due stringhe
di testo insieme
String stringOne = String (13); // Usa un numero intero costante
String stringOne = String ( analogRead (0), DEC); // Utilizzando un numero
intero che specifica la base utilizzata
String stringOne = String (45, HEX); // "Usa numero intero con base
impostata su" esadecimale
String stringOne = String (255, BIN); // "Utilizza un numero intero con la
linea di base impostata su" binary
String stringOne = String ( millis (), DEC); // Utilizza un numero lungo e
specifica la base utilizzata
String stringOne = String (5.698, 3); // Utilizza un numero decimale e
specifica il numero di posizioni decimali
Minion

charAt ()
La funzione preleva un carattere con un indice specifico dalla stringa di testo
chiamata con esso.

compareTo ()
La funzione bilancia due stringhe di testo e determina quale è maggiore
dell'altra o se sono uguali.

concat ()
La funzione aggiunge il parametro passato alla stringa di testo che viene
chiamata con essa.

c_str ()
La funzione converte il contenuto della stringa di testo con cui viene
chiamata nello stile di stringa di testo ideale in C (la stringa di testo che
termina con null).

finisce con ()
La funzione verifica se la stringa di testo chiamata con essa termina con gli
stessi caratteri che le sono stati passati.

equivale ()
La funzione verifica se la stringa di testo che stai chiamando è uguale alla
stringa di testo che hai passato.
equalsIgnoreCase ()
La funzione verifica se la stringa che stai chiamando è uguale alla stringa a
cui hai passato, non tenendo conto del caso.

getBytes ()
La funzione recupera un numero specificato di byte della stringa di testo che
viene chiamata con essa e la inserisce in un repository specifico.

indexOf ()
L'indice figlio restituisce la prima apparizione di un particolare carattere o
stringa di testo all'interno della stringa di testo che viene chiamata con esso.

lastIndexOf ()
L'indice figlio restituisce l'ultima apparizione di un particolare carattere o
stringa di testo all'interno della stringa di testo che è stata chiamata con esso.

lunghezza ()
La funzione restituisce il numero di caratteri della stringa che viene chiamata
con essa.

rimuovere ()
La funzione cancella un determinato numero di caratteri della stringa di testo
con cui viene chiamata.

sostituire ()
Il figlio sostituisce un carattere tipografico o una sottostringa in cui esiste un
carattere tipografico o una sottostringa specifica nella stringa che viene
chiamata con esso.

Riserva ()
Lo slave riserva parte della memoria e la alloca per manipolare e modificare
la stringa di testo che viene chiamata con essa.

setCharAt ()
La funzione assegna il valore di un carattere che viene posizionato nella
stringa di testo con cui viene chiamato.

inizia con ()
La funzione verifica se la stringa di testo chiamata con essa inizia con gli
stessi caratteri che le sono stati passati.

sottostringa ()
Il bambino recupera una parte specifica della stringa di testo che viene
chiamata con essa.

toCharArray ()
La funzione converte l'intera o parte della stringa di testo che viene chiamata
con essa in una stringa di caratteri.

toInt ()
La funzione converte la stringa di testo con cui viene chiamata in un numero
intero.

toFloat ()
La funzione converte la stringa di testo con la quale viene chiamata in un
decimale.

toLowerCase ()
La funzione converte tutti i caratteri della stringa di testo con cui viene
chiamata in lettere minuscole.

toUpperCase ()
La funzione converte in maiuscolo tutti i caratteri della stringa di testo con
cui è chiamata.

trim ()
La funzione rimuove tutti gli spazi bianchi dall'inizio e dalla fine della stringa
di testo chiamata con essa.

Transazioni
[]
L'operatore fornisce l'accesso e restituisce un carattere specifico della stringa
utilizzata.

+
L'operatore combina (unisce) due stringhe di testo in una nuova stringa di
testo e quindi le restituisce.

=+
L'operando aggiunge qualsiasi tipo di dati alla fine di una particolare stringa
di testo.

==
Il coefficiente verifica che due stringhe di testo siano uguali tra loro.

<
L'operando controlla se la stringa di testo a sinistra è esattamente più grande
della stringa di testo a destra.

=<
L'operando controlla se la stringa di testo a sinistra è maggiore o uguale alla
stringa di testo a destra.

>
L'operando controlla se la stringa di testo a sinistra è più piccola della stringa
di testo a destra.

=>
L'operando controlla se la stringa di testo a sinistra è minore o uguale alla
stringa di testo a destra.

=!
Il parametro controlla se la stringa di testo a sinistra è diversa dalla stringa di
testo a destra.
Array in Arduino

Un array è un insieme di variabili collocate in un singolo contenitore a cui è

possibile accedere tramite il loro numero di indice. Le matrici in C, su cui si
basa Ardonyo , possono essere un po 'complicate, ma usarle nella forma più
semplice è facile.

Crea un array

Esistono diversi modi per creare un array:

int myInts [6];

int myPins [] = {2, 4, 8, 3, 6};
int mySensVals [6] = {2, 4, -8, 3, 2};
messaggio di carattere [6] = "ciao";

È possibile dichiarare un array senza inizializzandolo e l'immissione dei

valori in esso come in myInts . Un array può essere dichiarato senza
specificarne esplicitamente la dimensione, come myInts ; in questo caso, la
banca conterà gli elementi e darà alla matrice una dimensione appropriata.
Tuttavia, è possibile configurare un array e specificarne le dimensioni come
nel caso dell'array mySensVals . Notare che quando si dichiara un array di
caratteri, è necessario aumentare la dimensione dell'array alla dimensione
richiesta per accogliere solo un elemento aggiuntivo, il null, che si trova alla
fine dei caratteri; vedere, ad esempio, la dimensione dell'array di messaggi
nell'esempio precedente e il numero di caratteri in esso memorizzati.
Accesso alla matrice

L'indicizzazione degli elementi nell'array inizia con un valore di 0; l'indice

dell'elemento 2 nella matrice mySensVals - nell'esempio precedente - è 0,
l'indice dell'elemento 4 (secondo elemento) è 1 e così via. Ciò significa anche
che l'indice dell'ultimo elemento di un array di 10 elementi è 9, non 10! Ecco
un esempio:

int myArray [10] = {9,3,2,4,3,2,7,8,9,11};

// Il valore 11 contiene l' elemento myArray [9]
// Funziona al di fuori dell'array e ha myArray [10]
// Restituisce un valore casuale dalla memoria

Per questo motivo, dovresti fare attenzione a non commettere questo errore
quando accedi a qualsiasi elemento di un array. L'accesso a un elemento che
ricade dopo l'ultimo elemento (indicizzato maggiore della dimensione
dell'array con un valore di 1), o generalmente all'esterno dell'array, porta alla
lettura da una porzione di memoria destinata ad altri scopi. Leggendo questa
parte non restituisce valori validi o dati. Al contrario, scrivere su un pezzo di
memoria al di fuori della parte riservata di un array, quando si assegna un
valore a uno dei suoi elementi, è dannoso e più pericoloso della lettura di
quella parte, poiché può portare a risultati disastrosi e inaspettati come crash
del programma e tempi di inattività. Questo errore può essere difficile da
monitorare e perfezionare.
La spesa per il linguaggio C non verifica l'accesso agli array definiti nel
programma, sebbene un accesso superi i limiti di uno, a differenza di BASIC
o JAVA, per verificarlo.

Assegna un valore a un elemento dell'array

Qualsiasi valore può essere assegnato a un elemento della matrice utilizzando
l'operatore di attribuzione = e l'indice dell'elemento in questione
Assegnargli il valore come segue:

mySensVals [0] = 10;

Porta valore dalla matrice

Il valore di qualsiasi elemento dell'array può essere recuperato dall'indice di

quell'elemento come segue:

x = mySensVals [4];

Array e loop

Array vengono spesso utilizzati all'interno di cicli di modificare o recuperare

i valori dei loro elementi. Il contatore del ciclo viene utilizzato come indice di
ogni elemento dell'array. Ad esempio, per stampare tutti gli elementi
dell'array su un'interfaccia seriale, è possibile utilizzare qualcosa di simile al
seguente esempio:

int i ;
for ( i = 0; i <5, i = i + 1) {
Serial.println ( myPins [ i ]);
}
Digita bool in Arduino

La variabile bool dichiarata memorizza uno dei seguenti due valori logici:
true o false, riservando un solo byte di memoria.

Struttura generale
bool var = val ;
Var rappresenta il nome della variabile da dichiarare e val è il valore da
assegnare a questa variabile, che può essere vero o falso.
Esempi
Il seguente esempio illustra come utilizzare il tipo bool per far lampeggiare la
luce attaccata alla gamba 5 ogni volta che viene premuto il cutter collegato
alla gamba 13:

int LEDpin = 5; // LED light connected to leg 5

int switchPin = 13; // An instantaneous cutter connected to the 13th leg,
and the other leg connected to the ground

bool running = false;

void setup ()
{
pinMode (LEDpin, OUTPUT);
pinMode (switchPin, INPUT);
digitalWrite (switchPin, HIGH); // Activating the internal lifting
resistance
}

void loop ()
{
if (digitalRead (switchPin) == LOW)
{// Was the cutter pressed? Patches resistance keeps voltage always high
delay (100); // Delay in order to neglect the cutter bounce
running =! running; // Switch the value of the variable
digitalWrite (LEDpin, running); // Indicating the state of the variable
through light
}
}
byte in Arduino

Byte memorizza un numero a 8 bit senza segno, cioè da 0 a 255.

Struttura generale

byte var_name;
byte var_name = Number; // 0 - 255

Esempi
Esempio di definizione di una variabile byte:

byte myNumber = 125;

byte result = myNuber / 5;

Si noti che i numeri dopo la virgola nel secondo caso verranno trascurati se la
divisione (o qualsiasi calcolo) restituisce un decimale.
Digita char in Arduino

Il tipo char riserva un byte di memoria e memorizza un valore di carattere

tipografico. I caratteri sono scritti tra virgolette singole come "A" (per diversi
caratteri [[[Arduino / string | stringa di testo]]], utilizzare virgolette pari come
"ABC").

I numeri vengono memorizzati nei byte riservati al tipo char che rappresenta
il valore del carattere corrispondente. Questi numeri sono indicati come
codifica e la codifica utilizzata qui è la codifica ASCII. Vai alla
documentazione della documentazione ASCII per vedere tutti i caratteri e il
valore numerico corrispondente per ciascuno. Ciò significa che è possibile
eseguire dei calcoli sui caratteri in cui viene utilizzato il valore ASCII (come
eseguire l'operazione A '+ 1' che darà il valore 66 corrispondente alla lettera
'B', poiché il valore numerico della lettera 'A' nel simbolo ASCII è 65). Dai
un'occhiata alla documentazione della funzione Serial.println () per maggiori
informazioni su come cambiare i caratteri e il loro valore numerico.

Char è un tipo con un segnale; Ciò significa che i valori numerici esso può
assumere range compreso tra 128 e 127. Se si desidera un byte senza un
segnale per memorizzare i dati in esso, usa il tipo byte.

Struttura generale

cahr var = 'carattere';

char var = Number;
Var rappresenta il nome della variabile da dichiarare e il carattere rappresenta
il carattere da attribuire a quella variabile. Il numero di carattere
corrispondente può essere utilizzato nella codifica ASCII invece dello stesso
carattere.

Esempi

Esempio di definizione di un tipo char:

char myChar = 'A';
char myChar = 65; // Both represent the same typeface

Digita double in Arduino

Double è un numero decimale con doppia precisione. Su Arduino e altre
schede basate su ATMEGA, questo tipo riserva solo 4 byte (32 bit) di
memoria. Ciò significa che il tipo doppio in questi pannelli mostra il
comportamento del tipo galleggiante stesso senza alcuna differenza e senza
alcun aumento di precisione.

Nei pannelli Due, la dimensione del tipo double è di 8 byte (64 bit), che è il
doppio del float.

Struttura generale

double var;
double var = val;

Var rappresenta il nome della variabile da dichiarare e val rappresenta il

valore decimale da assegnare a questa variabile.

Esempi
Un esempio di definizione di una doppia variabile:

double myNumber = 12.123456789;

double result = myNumber / 2;

Note e avvertenze
Gli utenti che portano codici che contengono variabili di tipo doppio da altre
fonti devono provare a testare il codice per assicurarsi che la precisione
desiderata non differisca a causa delle diverse schede che verranno
implementate su di esso (in particolare le schede che si basano sui controller
ATmega ).

Digita float in Arduino

Il tipo float viene utilizzato con i numeri decimali, che sono numeri frazionari
utilizzati come separatori decimali. I numeri decimali sono spesso utilizzati
per approssimare valori continui simili perché hanno una maggiore precisione
di numeri interi. I numeri decimali possono essere grandi con il numero
38.028235E + 38 e piccoli con il numero 38-4282835E +. Il tipo float riserva
quattro byte (32 bit) di memoria per memorizzare un float.

I numeri decimali in virgola mobile hanno una piccola precisione di 6-7 cifre
decimali dopo la virgola. In Arduino Uno e altre schede di controllo
ATMEGA, non c'è una risoluzione maggiore di questa usando double (double
float), poiché la dimensione di questo tipo è esattamente la stessa di float. Nei
pannelli Due, il tipo doppio fornisce una doppia precisione.

Fare operazioni matematiche sui numeri decimali è molto più lento che
eseguire le stesse operazioni sugli interi, quindi i numeri decimali dovrebbero
essere evitati se il tempo è critico per alcune funzioni e la funzione iterativa è
richiesta per ripetere le operazioni alla massima velocità e nel minor tempo
possibile . I programmatori di solito evitano di eseguire operazioni
aritmetiche sui numeri decimali e convertono e manipolano queste operazioni
per eseguirle solo su numeri interi al fine di aumentare la velocità del
programma.

Se il programma esegue operazioni matematiche sui numeri decimali, è

necessario aggiungere a tutti i numeri fissi utilizzati in queste operazioni le
posizioni decimali dopo la virgola se non le hanno (come 12.0); se non lo fai
(cioè usi solo il numero 12), questi numeri saranno trattati come numeri
interi. Vedere la pagina del numero fisso del punto decimale per ulteriori
informazioni.

Struttura generale
float var;
float var = val ;

Var rappresenta il nome della variabile da dichiarare e val rappresenta il

valore decimale da assegnare a questa variabile.

Esempi
Un esempio di definizione di una variabile float ed esecuzione di un calcolo
su di essa:

float myfloat ;
galleggiante sensorCalbrate = 1.117;

int x;
int y;
float z;

x = 1;
y = x / 2; // il valore 0, poiché non può memorizzare le parti decimali y
conterrà la variabile
z = (float) x / 2.0; // (il valore 0.5) presta attenzione al numero 2.0 e non
usare 2 solo z conterrà la variabile

Digita int in Arduino

I numeri interi sono il tipo di dati principale utilizzato per memorizzare i
numeri.

Sulle schede Arduino Uno (e sulle schede basate su ATMega ), il tipo int
riserva una dimensione di memoria di 16 bit (2 byte) in cui possono essere
memorizzati numeri compresi tra 32768- (il valore più piccolo uguale a 15 ^
2) e 32767 (il valore più grande e uguale 1 - 15 ^ 2). Nelle schede Arduino e
basate su SAMD (come MKR1000 e Zero), il tipo riserva una quantità di
memoria a 32 bit (4 byte) per memorizzare numeri da 2.147.483.648- (31 ^ 2-
) a 2.147.483.647 (1-31) ^ 2).

Questo tipo memorizza i numeri negativi con una tecnica chiamata

"complemento di due". Il bit superiore più importante (MSB) determina se un
numero è negativo o positivo ed è spesso chiamato "bit di segno". Quando il
suo valore è 1, il valore di tutti i bit rimanenti viene invertito e aggiunto 1.

Arduino ha il compito di trattare i numeri negativi, quindi i calcoli vengono

eseguiti su di essi in modo trasparente e nel modo previsto. Tuttavia,
potrebbe esserci una certa complessità nel trattare il coefficiente di
spostamento <<.

Struttura generale

int var = val ;

Var rappresenta il nome della variabile da dichiarare e val rappresenta il

valore numerico corretto da assegnare a quella variabile.

Esempi
Il seguente esempio creerà una variabile chiamata countUp e le assegnerà un
valore iniziale; questa variabile verrà utilizzata come contatore crescente, in
quanto il suo valore verrà incrementato durante il loop e apparirà
sull'interfaccia di comunicazione seriale:
int countUp = 0; // Dichiara una variabile con numeri interi

void setup () {
Serial.begin (9600); // Configura e avvia la porta seriale
}

void loop () {
countUp ++; // countUp Aggiunge il valore 1 alla variabile
Serial.println ( countUp ); // Stampa il valore della variabile corrente sulla porta
seriale
ritardo (1000);
}

Note e avvertenze

Se le variabili di segnale superano il valore massimo o minimo del tipo in cui

sono definite, avranno raggiunto uno stato di "overflow" e il loro valore non
può essere previsto in quel momento. Di conseguenza, è necessario prestare
attenzione affinché una variabile raggiunga la condizione di eruzione cutanea
(a meno che ciò non sia desiderabile). Uno degli indicatori dell'arrivo della
variabile allo stato di eruzione cutanea è il trasferimento della variabile dal
suo valore massimo al suo valore minimo o viceversa. Nota che abbiamo
detto "uno degli indicatori" e non l'unica prova che si è verificata un'eruzione
cutanea, quindi fai attenzione. Se si definisce una variabile e non si intende
utilizzarla per memorizzare un valore negativo in essa, è necessario utilizzare
un unsigned int di questo tipo, che è un unsigned int, per ridurre la possibilità
di raggiungere l'overflow.

Stringhe in Arduino
Le stringhe possono essere rappresentate in due modi. O le stringhe di testo
sono usate come uno dei tipi di dati in Arduino che è diventato parte del
kernel a partire dalla versione 0019, oppure una stringa di testo può essere
creata da un array di caratteri con il carattere nullo alla fine; il secondo
metodo verrà spiegato in questa pagina, poiché il primo metodo è spiegato in
dettaglio nella documentazione. L'oggetto stringa fornisce molte funzioni e
strumenti per manipolare le stringhe di testo, ma a spese della memoria.

Struttura generale
Tutti i seguenti esempi sono stringhe valide per le dichiarazioni:

char Str1 [15];

char Str2 [8] = {'a', 'r', 'd', 'u', ' i ', 'n', 'o'};
char Str3 [8] = {'a', 'r', 'd', 'u', ' i ', 'n', 'o', '\ 0'};
char Str4 [] = " arduino ";
char Str5 [8] = " arduino ";
char Str6 [15] = " arduino ";

Sono disponibili diverse possibilità per dichiarare le stringhe:

Dichiarare una matrice senza formattazione come in Matrix Str1.
Dichiarando una matrice di caratteri (aumentando la dimensione per
accogliere un carattere aggiuntivo) e il compilatore aggiungerà
automaticamente il valore null richiesto come Str2.
Questo caso è proprio come il caso precedente tranne per l'aggiunta esplicita
di null all'array come Str3.
Configurare l'array con una stringa di testo fissa tra virgolette; durante la
decodifica del codice, l'array sceglierà una dimensione appropriata per l'array
che si adatta alla stringa di testo fissa con un terminatore nullo. Guarda la
matrice Str4 per questo caso.
Inizializza l'array e lo specifica in modo esplicito, ad esempio Str5.
Configurare la matrice con un'opzione oversize per fornire funzionalità future
per le stringhe di testo; vedere Str6 per esempio.

Carattere di terminazione nullo

In genere, le stringhe terminano con null (ASCII 0). Ciò consente alle
funzioni (come la funzione Serial.print ()) di conoscere la fine di una stringa
di testo quando viene letta o recuperata dalla memoria. Se il carattere di
terminazione non è presente, la funzione completerà la lettura o il recupero
dei byte successivi in memoria che potrebbero non essere parte della stringa
di testo stessa.

Ciò significa che qualsiasi stringa di testo deve avere spazio aggiuntivo per
un carattere aggiuntivo oltre al contenuto che si desidera memorizzare nella
stringa. Questo è il motivo per cui Str2 e Str5 richiedono una dimensione di
8, anche se la frase " arduino " è solo 7, perché nell'ultima posizione
disponibile il carattere verrà aggiunto automaticamente nullo. Per Str4, la sua
dimensione verrà impostata automaticamente su 8 caratteri, tenendo conto del
carattere di terminazione. Nella matrice Str3, abbiamo aggiunto manualmente
il null null dell'espressione ('0 \').

Notare che è possibile che ci sia una stringa di testo che non ha un carattere di
terminazione (come impostare Str2 su 7 invece di 8). Ciò non funzionerà
correttamente nella maggior parte delle funzioni che trattano le stringhe,
quindi dovresti evitare di farlo inavvertitamente. Se noti che il
comportamento del programma è diventato un po 'strano (specialmente
quando si tratta di caratteri e non di stringhe), è probabile che il carattere di
terminazione sia la causa del problema.

Virgolette singole e doppie

Le stringhe sono sempre definite tra virgolette doppie come "ABC" e i
caratteri sono sempre definiti tra virgolette singole come "A".
Avvolgimento di stringhe lunghe
Le stringhe lunghe possono andare a capo e spostarsi sulla riga seguente
come:
char myString [] = "Questa è la prima riga"
"E questa seconda riga"
" E così via";

Matrici di stringhe di testo

Spesso è appropriato quando si ha a che fare con una grande quantità di testo,
come lavorare su un progetto con uno schermo LCD, creando una serie di
stringhe di testo. Poiché le stringhe sono esse stesse matrici, in questo caso
utilizzeremo una matrice bidimensionale.

Nell'esempio seguente, la presenza del parametro * dopo aver definito il tipo

di dati che è char come "* char" indica che la matrice da dichiarare è un array
di puntatori. In realtà, tutti gli array sono puntatori, quindi usare questo
parametro * in questo modo è importante per creare un array di array. Gli
indicatori in C sono un po 'complicati e non compresi da molti
programmatori alle prime armi, ma è sufficiente capire gli indicatori solo
superficialmente per affrontarli nel nostro caso.

Esempi
Un esempio di definizione di un array utilizzando un parametro * e
stampando il contenuto di questo array sull'interfaccia seriale:
char * myStrings [] = {"This is string 1", "This is string 2", "This is string 3",
"This is string 4", "This is string 5", "This is string 6"};

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

void loop () {
for (int i = 0; i <6; i ++) {
Serial.println (myStrings [i]);
delay (500);
}
}

Digita la parola in Arduino

Le variabili di tipo parola memorizzano un numero non di segnale di 16 bit (2

byte), con un valore compreso tra 0 e 65.535 max. Questo tipo è simile al tipo
int senza segno.

Struttura generale

word var = val;

Var rappresenta il nome della variabile da dichiarare e val rappresenta il

valore da attribuire a quella variabile.

Esempi

Esempio di definizione di una variabile di tipo word e assegnazione di un

valore:

word w = 10000;
La parola chiave void in Arduino

La parola chiave void viene utilizzata con le funzioni definite dal

programmatore nel codice per indicare che questa funzione non dovrebbe
restituire alcun dato a chi l'ha chiamata dopo la sua esecuzione. In base a
questa definizione, non si presume che la parola chiave return venga
utilizzata all'interno della funzione dichiarata con la parola chiave void.

Struttura generale

void function ()
{
// Il blocco di codice che verrà eseguito dal codice
}

Esempi

Il codice seguente spiega come utilizzare void con la funzione setup () e loop
() per indicare che non restituiranno nulla al termine della loro
implementazione:
// Ma "loop" e "setup" non verranno eseguiti per tutti i task all'interno delle due
funzioni
// Nessuno dei due restituisce alcun dato al programma superiore che li ha chiamati

void setup ()
{
// ...
}

void loop ()
{
// ...
}
 Capitolo III
Costanti e variabili

Numero intero fisso in Arduino

Gli interi fissi sono numeri utilizzati direttamente nel codice come 123. Per
impostazione predefinita, questi numeri vengono trattati come numeri interi
ma possono essere convertiti in altri tipi di numeri utilizzando un
modificatore come U o L.

I numeri interi vengono trattati come numeri interi basati sempre sul numero
10 ( ovvero rappresentato da decimali per impostazione predefinita).
Tuttavia, altre formule possono essere utilizzate per scrivere numeri, poiché
la base del numero varierà.

Sistema decimale (base 10)

Questo sistema è il sistema di conteggio comune tra gli umani che usano
sempre nei calcoli. I numeri scritti nel codice che non sono preceduti da alcun
coordinatore (prefisso che determina la formula numerica) sono considerati
numeri scritti in decimale (base 10).

n = 101; // ((1 * 10 ^ 2) + (0 * 10 ^ 1) + 1) == 101

Sistema binario (Base 2)

I valori di questo sistema sono rappresentati da numeri 0 e 1 solo.

n = B101; // ((1 * 2 ^ 2) + (0 * 2 ^ 1) + 1 * 2 ^ 0) == 5 in decimale

La formula binaria è valida solo per valori di byte (8 bit); tra 0 (B0) e 255
(B11111111). Se si desidera utilizzare la formula binario con valori più
grandi - come ad esempio con numeri interi (16 bit) - è possibile farlo
effettuando un semplice processo in due fasi come segue:
myInt = (B11001100 * 256) + B10101010; // è il valore del byte superiore
B11001100

Otto (Base 8)
I numeri utilizzati per rappresentare i valori di questo sistema sono da 0 a 7. I
valori da scrivere e rappresentati in questo sistema cominciare con il
coordinatore 0 (zero).
n = 0101; // ((1 * 8 ^ 2) + (0 * 8 ^ 1) + 1) == 65 in decimale
È probabile che un errore logico difficile da trovare nel codice derivi da una
costante zero non intenzionale; questo porta l'interprete a interpretare questa
costante come un valore di otto durante la scarica del codice.

Sistema esadecimale (base 16)

I numeri e caratteri utilizzati per rappresentare i valori di questo sistema sono
0 a 9 e da A a F. Infatti, il valore decimale della lettera A è 10, la lettera B è
11, e così via fino alla lettera F è 15. I valori di essere rappresentati e scritti
nel sistema esadecimale con prefisso 0x. Notare che le lettere AF possono
essere usate in maiuscolo o minuscolo (af).
n = 0x101; // ((1 * 16 ^ 2) + (0 * 16 ^ 1) + 1) == 257 in decimale
Note e avvertenze

Gli interruttori U e L.

Per impostazione predefinita, un numero intero costante viene considerato

come un tipo di numero intero con una dimensione limitata che in alcuni casi
è insufficiente. Per modificare questo tipo in un altro tipo di dati, puoi
utilizzare uno degli interruttori U o L come segue:

'u' o 'U': questa opzione viene utilizzata alla fine della costante numerica per
convertirla in un tipo senza segno come 33u.
'l' o 'L': questo interruttore viene utilizzato alla fine della costante numerica
per convertirla in un tipo di 'numero lungo' come 100000L.
'ul' o 'UL': i due interruttori vengono utilizzati insieme alla fine della costante
numerica per convertirla in un tipo di 'numero lungo senza segnale' come
32767ul.
Costanti in Arduino

Le costanti sono espressioni predefinite nel linguaggio Arduino. Utilizzato

per rendere più facile per i programmatori lavorare mentre scrivono il codice,
nonché per rendere il codice più leggibile. Le costanti sono raggruppate per
funzione.

Definizione dei livelli logici (costanti logiche)

In Arduino, ci sono due costanti usate per rappresentare verità e falsità: vero e
falso.

La costante è falsa
Il valore logico falso è un valore di errore ed è definito come numericamente
zero (0).

La costante è vera
Un vero booleano è un valore vero ed è definito come uno (1)
numericamente. Infatti, vero rappresenta una più ampia gamma di valori
numerici che solo 1. Qualsiasi valore diverso da zero viene logicamente
indicato come vero. Di conseguenza, i valori 1, 2, e 200 indicano tutti
logicamente vera.

Tieni presente che true e false sono minuscole, a differenza di altre costanti
come HIGH, LOW, INPUT, ecc.
Definizione dello stato delle gambe (livello di tensione)
Durante la lettura o la scrittura del valore delle gambe digitali, troviamo che
si tratta di due valori che non sono terzo; una delle gambe digitali può essere
presa o impostata su ALTO o BASSO.

Difficile ALTO
Il significato del valore fisso ALTO, quando si ha a che fare con le gambe
della scheda Arduino, varia a seconda della posizione dell'uomo; cioè, l'uomo
è un INGRESSO o un'USCITA. Se man è impostato su un uomo che è
entrato passando il valore INPUT alla funzione pinMode () e viene letto
utilizzando la funzione digitalRead (), il controller ATmega riporterà il valore
HIGH se:

La tensione applicata alla gamba è maggiore di 3,0 V sui pannelli con una
tensione di 5 V o
La tensione applicata alla gamba è maggiore di 2,0 V nei pannelli da 3,3 V.
L'uomo può anche essere impostato su un input man passando la costante
INPUT alla funzione pinMode () e quindi digitando il valore HIGH su di essa
utilizzando la funzione digitalWrite (). Questo attiverà la resistenza di
sollevamento interna associata a quell'uomo. L'attivazione di questa
resistenza aumenterà lo sforzo dell'uomo ad ALTO a meno che non venga
ridotto a BASSO collegandolo a un circuito esterno. Questo è molto simile a
quello che fa la costante INPUT_PULLUP quando viene passata alla
funzione pinMode (), di cui parleremo più avanti.

Quando un uomo è impostato su un uomo di uscita passando la costante

OUTPUT alla funzione pinMode (), e quindi digitando il valore ALTO su di
essa utilizzando la funzione digitalWrite (), lo sforzo di quell'uomo sarà:

5 volt a 5V, o
3,3 V nei pannelli 3,3 V.
Quando un uomo si trova in questo stato, è possibile prelevare corrente per
accendere una luce LED, ad esempio collegandovi uno dei suoi poli e
collegando l'altro polo con resistenza in sequenza al polo di terra.

Difficile BASSO
Il significato del valore LOW fisso varia anche a seconda della posizione
dell'uomo; Se man è impostato su un input man passando il valore INPUT
alla funzione pinMode () e viene letto utilizzando la funzione digitalRead (),
il controller ATmega riporterà il valore LOW se:

La tensione applicata alla gamba è inferiore a 1,5 V nei pannelli con una
tensione di 5 V o
La tensione applicata alla gamba è inferiore a circa 1,0 V nei pannelli da 3,3
V.
Quando la posizione di un uomo è impostata su un'uscita man passando la
costante OUTPUT alla funzione pinMode (), e quindi digitando il valore
LOW su di essa utilizzando la funzione digitalWrite (), la tensione di
quell'uomo è 0 volt (sia a 5V che a 3,3V pannelli). Quando l'uomo si trova in
questa situazione, è possibile scaricare una corrente, come ad esempio un
palo della luce ad esso collegato e l'altro polo con resistenza sulla sequenza
con un polo 5V + (o 3.3V +) per accenderlo.

Definizione della posizione delle gambe (input o output)

I segmenti digitali possono essere utilizzati come segmenti di input o
segmenti di output utilizzando una delle costanti INPUT, INPUT_PULLUP o
OUTPUT con la funzione pinMode (). Quando un uomo è così preparato, il
suo comportamento elettrico è completamente cambiato internamente.

INPUT difficile
Le gambe della scheda Arduino impostate come gambe di ingresso
utilizzando la costante INPUT con la funzione pinMode () si dice che siano in
stato di alta impedenza. Le gambe impostate sulle gambe INPUT rendono i
carichi sul circuito che stai esaminando molto piccoli, equivalenti a una
resistenza di sequenza di 100 ohm davanti all'uomo. Ciò rende le gambe
molto utili nella lettura dei valori del sensore.

Se una delle gambe è impostata come input man e viene utilizzata per leggere
un interruttore, la condizione dell'uomo sarà "fluttuante" quando il cutter è
aperto; questo produrrà risultati inaspettati. Per garantire che le condizioni
della gamba siano lette correttamente quando il cutter è aperto, utilizzare una
resistenza esterna di sollevamento o abbassamento con questa gamba.
L'obiettivo di collegare la resistenza a quest'uomo è di regolare il suo sforzo a
uno stato noto quando il cutter è aperto. Una resistenza di 10 k rum‫ أ‬di solito
viene utilizzato, che è abbastanza piccolo da evitare che la gamba di ingresso
fluttui e abbastanza grande da non tirare una grande quantità di corrente
quando il cutter è chiuso. Vedi questo tutorial per maggiori informazioni.

Se viene utilizzata una resistenza di pull-down esterna, la tensione della

gamba di ingresso sarà bassa quando la taglierina è aperta e ALTA quando la
taglierina è chiusa.

Se viene utilizzata una resistenza di pull-up esterna, la tensione della gamba

di ingresso sarà ALTA quando il cutter è aperto e LOW quando il cutter è
chiuso.

La costante INPUT_PULLUP
Il controller ATmega nella scheda Arduino ha una resistenza di sollevamento
interna collegata a ciascuna gamba delle gambe di ingresso e uscita che
possono essere controllate. Se si preferisce utilizzare questa resistenza invece
di aggiungere una resistenza di sollevamento esterna, è possibile farlo
passando la costante INPUT_PULLUP alla funzione pinMode () durante la
configurazione della gamba. Dai un'occhiata a questo tutorial, che contiene
un esempio pratico di ciò che abbiamo menzionato.

AVVERTENZA: le gambe impostate come gambe di ingresso utilizzando

INPUT o INPUT_PULLUP possono essere danneggiate o distrutte se sono
collegate con una tensione inferiore alla tensione di terra (tensione negativa)
o superiore alla tensione positiva (5 V o 3,3 V).

OUTPUT difficile
Si dice che le gambe della scheda Arduino impostate come gambe di uscita
utilizzando la costante OUTPUT con la funzione pinMode () siano in uno
stato di alta impedenza. Ciò significa che possono fornire corrente sufficiente
ad altri dispositivi e circuiti ad essi collegati. Qualsiasi uomo con le gambe
ATmega può dare o scaricare altri dispositivi e circuiti fino a 40 mA. Il
superamento di questo valore di corrente danneggia il controller, quindi è
necessario utilizzare resistori o elementi elettronici simili per determinare la
corrente quando si collegano parti elettroniche che richiedono grandi quantità
di corrente come i motori.

AVVERTENZA: le gambe impostate come gambe di uscita usando

OUTPUT possono essere danneggiate o vandalizzate se collegate alla
tensione di terra o alla tensione positiva della sorgente di corrente utilizzata
direttamente.

Definisci gli elementi incorporati nel pannello

LED_BUILTIN fisso
La maggior parte delle schede Arduino ha una luce LED integrata nella
scheda e collegata a una gamba con resistenza sulla sequenza. La costante
LED_BUILTIN rappresenta il numero dell'uomo collegato a questo pannello
luminoso. Quest'uomo è il tredicesimo uomo nella maggior parte dei dipinti
di Arduino che hanno una luce incorporata su di loro.
Ambito e qualificazioni variabili

La parola chiave const in Arduino

La parola chiave const è un'abbreviazione della parola costante, che è

vincolata dalle variabili che vengono utilizzate con essa. Ciò significa che
una variabile può essere utilizzata come rappresentante di variabili dello
stesso tipo, ad eccezione dell'impossibilità di modificare il valore che le era
stato assegnato al momento della creazione. Incontrerai un errore del
banchiere se provi ad assegnare un valore a una variabile con la quale viene
utilizzata la parola chiave const.

Le costanti definite utilizzando la parola chiave const sono conformi alle

regole di ambito delle variabili che impostano il resto delle variabili.
Prendendo in considerazione i rischi di define #, questo rende la parola
chiave const il modo migliore per definire le costanti e preferibilmente usarle
invece di definire #.

Struttura generale

const dataType var = val ;

Il dataType rappresenta il tipo di variabile da definire, var il nome della

variabile, e val il valore da assegnare a questa variabile costante. Notare che
una volta che val è assegnato a una variabile, non può più essere modificata e
la variabile sarà di sola lettura.
Esempi

Usa la parola const per definire la costante π usata nelle operazioni

matematiche:
const float pi = 3.14;
float x;

// ....

x = pi * 2; // Constants are frequently used in mathematical operations

pi = 7; // This will generate an error, as a constant variable cannot be overwritten

Note e avvertenze
L'espressione definisce # o la parola chiave const?
È possibile utilizzare la parola chiave const o #define per creare costanti
numeriche o di testo. Per gli array, devi solo usare const con essi. In generale,
l'uso della parola chiave const è preferibile all'uso dell'espressione define #.

Il campo delle variabili in Arduino

Le variabili nel linguaggio C, da cui deriva Arduino, hanno una proprietà

chiamata scope che determina l'ambito di utilizzo di tali variabili e chi può
accedervi . Questo è diverso da versioni recenti di lingue , come base in cui la
variabile è sempre globale.
Le variabili generali possono essere viste da tutte le funzioni del programma.
D'altra parte, le variabili locali sono visibili solo nella funzione all'interno
della quale sono definite e non sono disponibili per altre funzioni.
Nell'ambiente IDE, qualsiasi variabile dichiarata all'esterno di una funzione
(come setup (), loop (), ecc.) È una variabile globale.

Quando un programma diventa più grande e più complesso, le variabili locali

sono più utili di quelle generali per garantire che solo una funzione raggiunga
le variabili definite al loro interno. Ciò impedisce agli errori di una funzione
di modificare le variabili che un'altra funzione utilizza inavvertitamente.

È utile dichiarare le variabili e assegnare loro un valore all'interno di cicli

iterativi come for. Ciò impedisce a qualsiasi cosa al di fuori del ciclo di
accedere e modificare questa variabile.

Esempi
int gPWMval; // Any function can see and access this variable

void setup ()
{
// ...
}

void loop ()
{
int i; // loop is only visible within the variable "i" loop
float f; // Only the loop is also visible within the variable "f" loop
// ...
 for (int j = 0; j <100; j ++) {
// only for available within the variable j
}

La parola chiave statica in Arduino

La parola chiave statica viene utilizzata quando si creano variabili visive per
una sola funzione al fine di preservarne il contenuto dopo l'esecuzione di
quella funzione invocata e fino alla successiva chiamata ad essa, a differenza
delle variabili locali che vengono create e distrutte ogni volta che la funzione
viene chiamata.

Le variabili statiche dichiarate all'interno della funzione verranno create e

inizializzate con la parola chiave static solo la prima volta che quella
funzione viene chiamata.

Struttura generale

dataType statico var = val ;

Il dataType rappresenta il tipo di variabile da definire, var il nome della
variabile, e val il valore da assegnare a questa variabile statica. Tieni presente
che una volta che la variabile var viene creata quando la funzione viene
chiamata per la prima volta, non verrà distrutta quando la funzione viene
eseguita e il valore memorizzato al suo interno verrà conservato fino alla
successiva chiamata alla funzione.

Esempi

Il seguente programma genera passaggi casuali limitati a un dominio

specifico e limita anche la dimensione dei passaggi tramite la variabile
stepsize passata alla funzione randomWalk ():
/ * RandomWalk
* Paul Badger 2007
* RandomWalk vaga su e giù a caso tra due
* Endpoint. La mossa massima in un ciclo è governata da
* il parametro " stepsize ".
* Una variabile statica viene spostata su e giù di una quantità casuale.
* Questa tecnica è anche conosciuta come "rumore rosa" e "passeggiata
ubriaca".
#define randomWalkLowRange -20
#define randomWalkHighRange 20
int stepsize;

int thisTime;
int total;

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

void loop ()
{// randomWalk test function
stepsize = 5;
thisTime = randomWalk (stepsize);
Serial.println (thisTime);
delay (10);
}

int randomWalk (int moveSize) {

static int place; // is defined as static so it stores values randomWalk is
a variable that stores a value in the function
// Between function calls with this variable remaining local
and only accessed by this function

place = place + (random (-moveSize, moveSize + 1));

 if (place <randomWalkLowRange) {// Check the upper and lower limits
place = randomWalkLowRange + (randomWalkLowRange - place); //
Reverses the number in the opposite direction to the positive direction
}
else if (place> randomWalkHighRange) {
place = randomWalkHighRange - (place - randomWalkHighRange); //
Reverses the number in the opposite direction to the negative direction
}

return place;
}

Parola chiave volatile in Arduino

La parola chiave volatile è classificata sotto "qualificatore di variabile" e

viene solitamente utilizzata prima del tipo di variabile quando viene definita
per modificare il modo in cui il banchiere e il programma successivo trattano
questa variabile.

La parola chiave volatile, quando usata per definire una variabile, è una
direttiva per il banchiere stesso. Il banchiere è un programma che converte il
codice C / C ++ in un codice eseguibile comprensibile dall'hardware; questo
codice contiene i comandi effettivi per il controller sulla scheda Arduino che
gli dicono cosa fare.

Ciò che la parola chiave volatile fa con la variabile è indirizzare il banchiere a

caricare la variabile dalla RAM e non dai record della memoria flash in cui
sono memorizzate tutte le variabili del programma. In alcuni casi, il valore
memorizzato nei registratori per una variabile potrebbe essere impreciso.

La variabile deve essere definita con la parola chiave volatile ogni volta che il
suo valore può essere modificato da qualcosa al di fuori del controllo del
frammento di codice all'interno del quale appare questa variabile (come
l'esecuzione simultanea di una stringa). In Arduino, l'unico luogo in cui è
probabile che ciò accada sono i frammenti di codice relativi al distretto
chiamati programmi ISR.

Interi volatili o lunghi volatili?

Se si utilizza la parola volatile con una variabile più grande di un byte (2 byte
come numero intero, 4 byte come numero lungo, ecc.), Il controller non sarà
in grado di leggerlo in un passaggio perché l'architettura del controller è
spesso 8 bit (assicurati che l'architettura sia Pannello di controllo). Ciò
significa che mentre i primi otto bit della variabile vengono letti in una parte
del codice (come il ciclo), l'interrupt potrebbe aver già modificato gli altri
otto bit (se la dimensione della variabile è di 16 bit). Questo otterrà un valore
casuale per la variabile.

La soluzione a questo problema è quello di interrupt disabilitare durante la

lettura di valori variabili, in modo che i valori dei bit variabile non cambiano
come sono letti. Ci sono diversi modi per farlo:

Utilizzare la funzione noInterrupts () per disabilitare gli interrupt, o

L'uso del blocco ATOMIC_BLOCK, dove le operazioni atomiche sono
operazioni singole eseguite dal controller (MCU) e rappresenta l'unità più
piccola possibile.
Esempi

Cambia lo stato del piede connesso con la luce LED quando si verifica
un'interruzione sul piede 2:

int pin = 13;

volatile byte state = LOW;

void setup ()
{
pinMode (pin, OUTPUT);
attachInterrupt (digitalPinToInterrupt (2), blink, CHANGE);
}

void loop ()
{
digitalWrite (pin, state);
}

void blink ()
{
state =! state;
}
 Capitolo IV
Strutture di controllo
Interruzione di parole chiave in Arduino

La parola chiave break viene utilizzata per uscire dai cicli for, while o do ...
durante l'iterazione, bypassando il codice successivo e le condizioni di ciclo
specificate e uscendo da esse. Utilizzato anche per uscire dall'interruttore
programmatico ... espressione case.

Struttura generale

rompere;

Esempi

Nel codice seguente, il controller esce dal ciclo for quando il valore del
sensore misurato supera una certa soglia:
for (x = 0; x <255; x ++)
{
analogWrite (PWMpin, x);
sens = analogRead (sensorPin);
if (sens> threshold) {// Ensure that the measured value does not exceed
the threshold
x = 0;
break;
}
delay (50);
}
Continua la parola chiave in Arduino

Il tasto continue passa il codice successivo nel ciclo di iterazione (come for,
while o do ... while iterations) per controllare l'espressione condizionale di
quel ciclo e quindi il ciclo del ciclo viene ripreso normalmente. Fare questa
istruzione è simile a fare un salto nel ciclo per saltare l'esecuzione quando
viene soddisfatta una certa condizione.

Struttura generale

Continua;

Esempi
Nel seguente codice, il valore da 0 a 255 sarà scritto sul piede PWMpin con
saltando i valori del campo di misura 41 a 119:

for (x = 0; x <= 255; x ++)

{
if (x> 40 && x <120) {// Causes a jump in values
continue;
}

analogWrite (PWMpin, x);

delay (50);
}

Loop do ... mentre iterativo in Arduino

Il ciclo iterativo do ... while funziona allo stesso modo del ciclo while tranne
per il fatto che la condizione viene verificata alla fine del ciclo, non all'inizio.
Ciò significa che il ciclo verrà eseguito almeno una volta.

Struttura generale

do
{
// The code block to be executed
} while (condition);

Una condizione è un'espressione logica e verrà valutata come vera o falsa.

Esempi

Un esempio di utilizzo del ciclo do ... while per leggere un valore da un

sensore e attendere che raggiunga un certo limite:
do
{
delay (50); // Wait for the sensor value to stabilize
x = readSensors (); // Read the value of the sensor

} while (x <100);

Altre parole chiave in Arduino

L'espressione condizionale if ... else consente un maggiore controllo sulla
sequenza di convalida di diverse condizioni specifiche durante l'esecuzione
del codice piuttosto che verificare una singola condizione quando si utilizza
l'espressione if. L'istruzione else (se presente) verrà eseguita se la condizione
data nell'istruzione if non viene soddisfatta. È inoltre possibile utilizzare
l'istruzione else con l'istruzione if come else if per aggiungere un'altra
condizione da verificare, in modo che possano essere eseguiti più controlli
consecutivi contemporaneamente.

Se ci sono più condizioni da verificare, sarà soddisfatta dalla prima

condizione e poi dalla condizione successiva se restituisce false e così via
fino a quando una delle condizioni non è soddisfatta ( cioè restituisce true).
Quando la condizione è soddisfatta, il blocco associato verrà eseguito e il
programma salterà l'intera struttura if / else alla riga successiva. Se nessuna
condizione viene soddisfatta, il blocco else predefinito verrà eseguito se alla
fine si verifica.

Notare che il blocco else if può essere utilizzato con o senza il blocco else
alla fine e viceversa. Il numero di volte in cui l'uso del blocco else if in
qualsiasi espressione condizionale è illimitato.

Struttura generale

if (temperature> = 70)
{
// Danger! Stop the system
}
else if (temperature> = 60 && temperature <70)
{
// Warning! You must send signals to alert the user
}
else
{
// Safety! Complete the normal tasks
}
Episodio per iterativo in Arduino

Il ciclo for viene utilizzato per duplicare un blocco di codice specifico un

numero di volte specificato. In questo ciclo, un contatore viene solitamente
utilizzato per tenere traccia del numero di volte in cui il codice viene
duplicato e interrotto quando viene raggiunto un numero specificato. Il ciclo
for può essere utilizzato con qualsiasi iterazione e viene spesso utilizzato con
gli array per eseguire una particolare operazione su elementi che possono
essere dati normali o segmenti specifici.

Struttura generale

for (step; condition; initial configuration) {

// code block to be replicated;
}

L'inizializzazione viene eseguita solo una volta all'inizio dell'esecuzione del

ciclo. La condizione viene verificata ogni volta che il ciclo viene ripetuto; se
vero, verrà eseguito il blocco che rientra nel ciclo, quindi verrà eseguito il
passaggio e la condizione verrà ricontrollata. Quando la condizione non è
soddisfatta (ovvero il valore diventa falso), il ciclo smette di funzionare.
Esempi

Il codice seguente fa parte del codice del sistema di rilevamento della

temperatura:

int PWMpin = 10; // LED light connected to sequence with 10 ohm

impedance of 10 foot

void setup ()
{
// This example does not require any configuration
}

void loop ()
{
for (int i = 0; i <= 255; i ++) {
analogWrite (PWMpin, i);
delay (10);
}
}

Note e avvertenze

Il ciclo for in C è più flessibile di cicli for in alcune lingue come il BASIC.
Uno o tutti e tre gli elementi principali possono essere rimossi dal ciclo,
mantenendo intatto il punto e virgola. Inoltre, le espressioni di
inizializzazione, condizione e passo possono essere qualsiasi espressione in
linguaggio C valida con variabili non correlate e possono utilizzare qualsiasi
tipo di dati in C, inclusi i decimali. L'utilizzo di questi tipi insoliti di
espressioni con il ciclo for fornisce una soluzione ad alcuni rari problemi
software.

Ad esempio, l'utilizzo della moltiplicazione nel passaggio dell'espressione

genererà una progressione logaritmica come:
for (int x = 2; x <100; x = x * 1.5) {
println (x);
}

Questo codice genererà i seguenti passaggi:

2,3,4,6,9,13,19,28,42,63,94

Un altro esempio di accensione e spegnimento graduale della luce LED con

un solo anello:
void loop ()
{
int x = 1;
for (int i = 0; i> -1; i = i + x) {
analogWrite (PWMpin, i);
if (i == 255) x = -1; // Switch the direction of the step when the peak is reached
delay (10);
}
}

Vai alla parola chiave in arduino

La parola chiave goto sposta il programma in una posizione specifica
all'interno del codice.

etichetta goto ; // Invia il programma per eseguire il blocco di codice

// etichetta trovata sull'etichetta

Esempi

Example of using goto:

for (byte r = 0; r <255; r ++) {
for (byte g = 255; g> 0, g -) {
for (byte b = 0; b <255; b ++) {
if (analogRead (0)> 250) {goto bailout;}
// Something can be added here
}
}
}

salvataggio:

Note e avvertenze

L' istruzione goto non è più utilizzata in C, e in alcuni libri di testo di

programmazione in C si afferma che l' istruzione goto non è più necessaria
ma può essere utilizzata per semplificare alcuni programmi. Il motivo per cui
i programmatori sono riluttanti a usare l' istruzione goto è che quando
vengono trascurati, verrà creato un programma con un percorso di esecuzione
sconosciuto, rendendo quasi impossibile tracciare e correggere gli errori.

D'altra parte, ci sono situazioni in cui l'uso della parola goto è utile e
semplifica notevolmente il codice. Uno di questi casi è una frammentazione
del loop fork o un blocco if condizionale a determinate condizioni.

Espressione se condizionale in Arduino

L'espressione condizionale if verifica una data condizione ed esegue il blocco

di codice scritto al suo interno se è vera ( cioè il suo valore è vero).

Struttura generale

if (condition)
{
// The block of code to execute when the condition is met
}

Una condizione è un'espressione logica il cui valore è vero o falso.

Esempi

Un esempio di utilizzo dell'espressione condizionale if in più formati:

if (x> 120) digitalWrite (LEDpin, HIGH);

if (x> 120)
digitalWrite (LEDpin, HIGH);

if (x> 120) {digitalWrite (LEDpin, HIGH); }

if (x> 120) {
digitalWrite (LEDpin1, HIGH);
digitalWrite (LEDpin2, HIGH);
}

Note e avvertenze

I termini indicati possono richiedere l'uso di uno dei seguenti parametri.

Transazioni di budget

x == y (y è uguale a x)
X! = y (y non è uguale a x)
x <y (y è esattamente minore di x)
x> y (y è esattamente maggiore di x)
x <= y (y è minore o uguale a x)
x> = y (y è maggiore o uguale a x)

Fare attenzione a non utilizzare un solo segno di uguale (ad esempio if (x =

10)). Uguale a (come if (x == 10)), che in questo caso è un coefficiente di
equilibrio e controlla se il valore della variabile x è uguale o meno. Il valore
dell'ultima espressione sarà vero se il valore della variabile x è 10, mentre il
valore della precedente espressione di riferimento è sempre vero.
La spiegazione di come C valuta l'espressione se (x = 10) con vero è sempre
che C assegna il valore 10 alla variabile x (ricorda che un singolo segno di
uguale è un operatore di attribuzione ed è stato utilizzato per errore).
L'espressione if condizionale quindi valuta il valore 10 - che diventa il valore
della variabile x - come sempre vero perché la valutazione logica di qualsiasi
numero diverso da zero è sempre vera. Di conseguenza, l'espressione
condizionale if (x = 10) sarà valutata come verificata e il risultato sarà
contrario alle aspettative attese in quel momento. Inoltre, la variabile x sarà
impostata su 10, anche questo non è desiderabile

Restituzione di parole chiave in Arduino

La parola chiave return interseca l'esecuzione di qualsiasi funzione e

restituisce un valore dalla funzione a colui che l'ha chiamata se specificato.

Struttura generale

ritorno;

valore di ritorno; // valore In questo formato, verrà restituito il valore

Il valore restituito può essere qualsiasi tipo di variabile o costanti da restituire

a colui che ha chiamato la funzione.
Esempi

L'esempio seguente mostra come creare una funzione per bilanciare il valore
misurato di un sensore con una soglia specifica:

int checkSensor () {
if (analogRead (0)> 400) {
return 1;
}
else {
return 0;
}
}

L'esempio seguente mostra come utilizzare la parola chiave return per

esaminare una parte del codice senza ricorrere al metodo comment:

void loop () {

// This part of the code is checked

return;

// The part here which will not be implemented

// The error is probably within it
}

Interruttore di espressione ... case in Arduino

Il caso switch ..., come in if, verifica un valore specificato in un modo che
consente al programmatore di specificare diversi codici, uno dei quali viene
eseguito in base a quel valore. Più in dettaglio, l'interruttore ... caso bilancia il
valore di una variabile con i valori specificati all'interno di esso; quando il
valore di tale variabile corrisponde ad uno dei valori o espressioni all'interno
di esso, verrà eseguito il blocco associato con quel valore o espressione.

La parola chiave break viene solitamente utilizzata alla fine di ogni stato del
caso switch ... per uscirne dopo aver trovato lo stato e aver eseguito il blocco
associato. Se l'interruzione chiave non viene utilizzata in quel caso, il caso
switch ... continuerà ad esaminare le condizioni ed eseguire i blocchi associati
fino al raggiungimento dell'interruzione o alla fine.

Struttura generale

switch (var) {
case label1:
// The first code that will be executed when the first case is matched
break;
case label2:
// The second code will be executed when the second case is matched
break;
default:
// The default code that will be executed when no case matches
// This case is optional
}

Transazioni

var
La variabile di bilanciare il valore con valori multipli (stati). I tipi di dati
consentiti sono: intero, carattere tipografico.

lable1
La prima costante che verrà bilanciata con var. I tipi di dati consentiti sono:
intero, carattere tipografico.

lable2
La seconda costante che verrà bilanciata con var. I tipi di dati consentiti sono:
intero, carattere tipografico.

Esempi

Un esempio di utilizzo dell'espressione switch ... case per bilanciare un valore

variabile ed eseguire un codice appropriato:
switch (var) {
case 1:
// Value 1 var Do something when it equals
break;
case 2:
// Value 2 var Do something when it equals
break;
default:
// with any of the previous values var do something if it doesn't match
break;
}
Mentre l'episodio iterativo in Arduino
Il ciclo si ripete durante l'esecuzione del blocco di codice al suo interno continuamente e
all'infinito fino a quando il valore della condizione logica tra parentesi è vero (vedere
l'evidenza generale); una volta che il valore della condizione logica diventa falso, il ciclo si
interrompe ed esce. Qualsiasi cambiamento nel valore della condizione deve avvenire
altrimenti il ciclo non uscirà mai, quindi il valore della variabile che viene controllato
all'interno della condizione logica deve essere aumentato o diminuito, o una condizione
esterna come il controllo di un valore sensibile o simili deve essere usato.

Struttura generale

while (condition) {
// blocco da duplicare
}

Transazioni

condizione
Un'espressione logica il cui valore è vero o falso.

Esempi

Un esempio di utilizzo dell'espressione while per ripetere l'esecuzione di un codice un certo

numero di volte:

var = 0;
while (var <200) {
// The code written here will be repeated 200 times
var ++;
}
 Capitolo V
Funzioni

Funzioni di controllo a pedale digitale in Arduino

La funzione digitalRead () in Arduino

La funzione digitalRead () legge il valore di un piede numerico che è HIGH o
LOW.

Struttura generale

digitalRead (pin)

Transazioni
pin
Un numero che indica l'uomo digitale il cui valore deve essere letto.

Valori restituiti
Restituisce il valore ALTO o BASSO che rappresenta il valore numerico del
piedino del piedino.

Esempi
Imposta il valore del piede 13 sullo stesso valore del piede 7 definito come
input foot:

int ledPin = 13; // There is a LED light connected to the 13 foot digital
int inPin = 7; // Push button connected to 7 digital foot
int val = 0; // Changer to store the read value

void setup ()
{
 pinMode (ledPin, OUTPUT); // 13 digital foot set as the output foot
pinMode (inPin, INPUT); // Set the 7 foot digital as the entered foot
}

void loop ()
{
val = digitalRead (inPin); // Read the income blood
digitalWrite (ledPin, val); // Adjust the light status to the value of the button
}

Note e avvertenze

Se non colleghi il piede a nulla, la funzione digitalRead () può restituire

HIGH o LOW (questo può cambiare in modo casuale).
Piedi di ingresso simili possono anche essere usati come piedi digitali, quindi
indicati come A0, A1, ecc.

La funzione digitalWrite () in Arduino

La funzione digitalWrite () scrive il valore HIGH o il valore LOW su un

segmento numerico specifico.

Se l'uomo è configurato come un'uscita ( cioè , USCITA) tramite la funzione

pinMode (), la tensione di quell'uomo è impostata sul valore corrispondente:
5 V (o 3,3 V nei pannelli 3,3 V) per ALTO o 0 V (terra) per BASSO .

Se l'uomo è configurato come INPUT, attiverà (con HIGH) o disabiliterà

(con LOW) la funzione digitalWrite (resistenza di pullup interna) associata a
quell'ingresso man. Si consiglia di utilizzare il valore INPUT_PULLUP con
la funzione pinMode () per attivare direttamente la resistenza di sollevamento
interna. Vedere il "Tutorial Digital Legs" per ulteriori informazioni.

Se non configuri un uomo su OUTPUT tramite la funzione pinMode () e

colleghi una luce LED con essa, la luce LED potrebbe apparire debole
quando chiami digitalWrite (HIGH) con questo ragazzo. Senza configurare
esplicitamente l'uomo tramite la funzione pinMode (), digitalWrite () attiverà
la resistenza di sollevamento interna che regolerà la grande corrente che
scorre in quel momento.

Struttura generale

digitalWrite (pin, valore)

Transazioni
pin
Un numero che indica l'uomo numerico su cui scrivere il valore.

valore
Il valore HIGH o LOW da scrivere nel pin man.

Valori restituiti

Non viene restituito nulla.

Esempi
Impostare la modalità digitale 13 man sull'uscita man e quindi invertirne il
valore da HIGH a LOW e viceversa ogni secondo:

void setup ()
{
pinMode (13, OUTPUT); // 13 digital man set it as a man came out
}

void loop ()
{
digitalWrite (13, HIGH); // HIGH Adjust the value of 13 digital man to
delay (1000); // Waiting for one second to pass
digitalWrite (13, LOW); // LOW Adjust the value of the 13 digital man
to
delay (1000); // Waiting for one second to pass
}

Note e avvertenze
Le gambe di ingresso simili possono essere utilizzate anche come gambe
digitali, quindi denominate A0, A1, ecc.

La funzione pinMode () in Arduino

La funzione pinMode () prepara una gamba specifica per eseguire un

comportamento di input o output. Vedere il "Tutorial Digital Legs" per
ulteriori informazioni sulle funzioni delle gambe.

A partire dalla versione 1.0.1 di Arduino, è diventato possibile attivare la

resistenza di sollevamento interna utilizzando la modalità INPUT_PULLUP.
Inoltre, la modalità INPUT disabilita automaticamente le resistenze di
sollevamento interne.

Struttura generale
pinMode (pin, modalità)
Transazioni
pin
Un numero che indica l'uomo digitale da configurare in modalità.

modalità
La modalità che determina il comportamento del pin è INPUT, OUTPUT o
INPUT_PULLUP. Una spiegazione completa del comportamento e delle
funzioni delle gambe digitali può essere trovata in questa pagina.

Valori restituiti
Non viene restituito nulla.

Esempi
Impostare la modalità digitale 13 man sull'uscita man e quindi invertirne il
valore da HIGH a LOW e viceversa ogni secondo:
void setup ()
{
pinMode (13, OUTPUT); // 13 digital man set it as a man came out
}

void loop ()
{
digitalWrite (13, HIGH); // HIGH Adjust the value of 13 digital man to
delay (1000); // Waiting for one second to pass
digitalWrite (13, LOW); // LOW Adjust the value of the 13 digital man to
delay (1000); // Waiting for one second to pass
}
Note e avvertenze
Le gambe di ingresso simili possono essere utilizzate anche come gambe
digitali, quindi denominate A0, A1, ecc.

Funzioni del tempo in Arduino

Le funzioni in questa sezione si occupano di tempi e tempi, ad esempio, per

creare ritardi di tempo con un certo valore richiesto da alcune attività, o per
eseguire un processo specifico quando è trascorso un periodo di tempo
specifico dall'inizio della scheda.

La funzione delay () in Arduino

La funzione delay () sospende l'esecuzione del programma per un periodo di

tempo specificato (in millisecondi).

Struttura generale

ritardo ( ms )
Transazioni

SM

Un numero lungo senza segno rappresenta il tempo in millisecondi durante il

quale il programma viene sospeso.

Promemoria: sono disponibili 1.000 millisecondi al secondo.

Valori restituiti
Non viene restituito nulla.

Esempi
Utilizzare la funzione delay () per mettere in pausa il programma dal lavoro
per un secondo prima di invertire il caso di uscita collegato alla luce LED:
int ledPin = 13; // Luce LED collegata all'uomo 13

void setup ()
{
pinMode (ledPin, OUTPUT); // As a man led out ledPin initialize the
man
}

void loop ()
{
digitalWrite (ledPin, HIGH); // turning the light on
 delay (1000); // Wait for one second
digitalWrite (ledPin, LOW); // Turn off the light
delay (1000); // Wait for one second
}

Note e avvertenze

Sebbene sia molto facile creare una luce LED lampeggiante con la funzione
delay () e molti codici utilizzano questa funzione per creare ritardi di tempo
richiesti da alcune attività, come il loro utilizzo per evitare il problema del
rimbalzo del pulsante quando viene premuto (debouncing del pulsante) - ma
l'uso della funzione delay () nel codice è accompagnato da molti svantaggi.
Durante l'esecuzione del processo di ritardo al richiamo della funzione, i
valori dei sensori non verranno letti, i calcoli non verranno eseguiti, e la
condizione di uno non saranno modificati o controllati ... ecc, così chiamata
questa funzione interromperà il resto delle attività e delle operazioni e le
interromperà per un certo periodo di tempo. Invece, guarda la funzione millis
() e l'esempio sotto per gestire i ritardi e controllare i tempi in modo efficace.
I programmatori esperti e competenti di solito evitano di usare la funzione
delay () per ritardare gli eventi e controllare la loro temporizzazione quando il
periodo di ritardo supera alcune decine di millisecondi a meno che il codice
scritto non sia molto semplice.

Alcune cose continuano a funzionare durante il controllo delay () di Atmega ,

come le interruzioni, poiché ciò non lo interrompe. Comunicazione seriale del
ricevitore RX viene registrato, i valori PWM ( scritte utilizzando analogWrite
()) e la condizione gamba sono conservati, e gli interrupt continuano a
funzionare come desiderato.
Funzione Arduino delayMicroseconds ()

La funzione delayMicroseconds () sospende l'esecuzione del programma per

un periodo di tempo specificato (in secondi). Attualmente, il valore più
grande che fornisce un ritardo temporale preciso è 16383. Questo valore può
cambiare nelle future versioni di Arduino. La funzione delay () dovrebbe
essere usata al posto di questa funzione per ritardi superiori a qualche
migliaio di microsecondi.

Struttura generale

delayMicroseconds (us)

Transazioni
noi
Un intero senza segno rappresenta il tempo nel microsecondo in cui il
programma è in pausa.

Promemoria: sono disponibili 1.000 microsecondi per millisecondi e

1.000.000 di microsecondi ogni 1 secondo.

Valori restituiti
Non viene restituito nulla.

Esempi
Il codice seguente prepara l'ottavo uomo ad agire come un uomo in uscita.
L'uomo trasmette quindi una serie di impulsi di circa 100 microsecondi di
lunghezza. Dovresti concentrarti sulla parola "quasi" perché l'ora è
assolutamente imprecisa e questo è dovuto alla perdita di tempo
nell'implementazione di altri comandi e istruzioni nel codice:

int outPin = 8; // Label Man 8

void setup ()
{
pinMode (outPin, OUTPUT); // As a man came out outPin create the man
}

void loop ()
{
digitalWrite (outPin, HIGH); // Make the man's condition high
delayMicroseconds (50); // Pause for 50 microseconds
digitalWrite (outPin, LOW); // Make the man's condition low
delayMicroseconds (50); // Pause for 50 microseconds
}
Note e avvertenze

Questa funzione opera con assoluta precisione nell'intervallo tra 3

microsecondi e oltre. I delayMicroseconds funzione () non può essere
garantita per funzionare in modo accurato per ritardi inferiori a tale valore.

A partire dalla versione 0018, la funzione delayMicroseconds () non

disabilita più gli interrupt.

Funzione Arduino micros ()

La funzione micros () restituisce il runtime della scheda Arduino del

programma corrente in microsecondi.

Il valore calcolato da questa funzione raggiungerà lo stato di eruzione cutanea

(cioè tornerà a zero) dopo che saranno trascorsi circa 70 minuti. Sulle schede
Arduino 16MHz (come Duemilanove e Nano), la precisione di questa
funzione è di 4 microsecondi (ovvero, il valore restituito dalla funzione è
sempre un multiplo di 4). Sulle schede Arduino che funzionano a 8 MHz
(come LilyPad ), la precisione di questa funzione è di 8 microsecondi.

Struttura generale
time = micros ()
Valori restituiti
Restituisce un numero lungo senza segno che rappresenta il tempo di avvio
della scheda Arduino del programma corrente al momento in cui viene
chiamata la funzione micros ().
Esempi
Usa la funzione micros () per scoprire da quanto tempo è iniziata la scheda
Arduino:
tempo non firmato;

void setup () {
Serial.begin (9600);
}
void loop () {
Serial.print ("Time:");
time = micros ();

Serial.println (time); // Print the duration of the program since it started

working
delay (1000); // Wait for one second not to send a huge amount of data
}

Note e avvertenze
Ricorda: ci sono 1.000 microsecondi in ogni millisecondo e 1.000.000 di
microsecondi in ogni singolo secondo.
Funzione Arduino millis ()

La funzione millis () restituisce il runtime della scheda Arduino per il

programma corrente in millisecondi.

Il valore calcolato da questa funzione raggiungerà lo stato di overflow

(ovvero tornerà a zero) dopo circa 50 giorni.

Struttura generale
time = millis ()
Valori restituiti
Un numero lungo senza segno che rappresenta l'ora di inizio della scheda
Arduino del programma corrente viene restituito al momento in cui la
funzione millis () viene chiamata in millisecondi.

Esempi
Usa la funzione millis () per scoprire da quando la scheda Arduino ha iniziato
a funzionare:
tempo non firmato;

void setup () {
Serial.begin (9600);
}
void loop () {
Serial.print ("Time:");
time = millis ();

Serial.println (time); // Print the duration of the program since it

started working
delay (1000); // Wait for one second not to send a huge amount of data
}

Note e avvertenze

Si noti che il tipo di valore restituito dalla funzione millis () è un numero

lungo senza segno, quindi potrebbero verificarsi errori logici se il
programmatore tenta di eseguire operazioni matematiche con tipi di numeri
più piccoli, come int. Anche i calcoli con un numero lungo con segno
possono causare errori perché la sua capacità massima è la metà di quella del
numero non di riferimento corrispondente.
Funzioni matematiche in Arduino

Le funzioni matematiche generalmente si occupano dei numeri, poiché

eseguono varie operazioni matematiche su di essi, come il calcolo di un
valore assoluto, la radice del numero, il seno o la generazione di numeri
casuali.

() Addominali
La funzione abs () calcola il valore assoluto del numero passato ad essa.

Vincola ()
La funzione constrain () limita un numero all'interno di un campo specificato.

() Cos
La funzione cos () calcola l'angolo passato ad essa.

() Carta geografica
La funzione map () riposiziona un numero dal dominio in cui si trova a un
altro dominio.

() Max
La funzione max () restituisce il valore più grande passato ad essa.
() Min
Min () restituisce il valore più piccolo passato ad esso.

() Pow
La funzione pow () calcola il valore yx , che si solleva la base Y alla potenza
x dei due valori che vengono passati a esso.

Casuale ()
La funzione random () genera e restituisce un numero pseudo-casuale.

() Seme casuale
La funzione randomSeed () crea il seme che il generatore di numeri pseudo-
casuali utilizza nel processo di generazione.

() Peccato
La funzione sin () calcola il seno dell'angolo a cui è passato.

() Mq
La funzione sq () calcola il numero di quadrati (moltiplicato per il numero
stesso) e lo restituisce.

Sqrt ()
La funzione sqrt () calcola la radice quadrata del numero passato ad essa.

() Tan
La funzione tan () calcola la tangente dell'angolo passato a.
Gestione e verifica dei caratteri tipografici in Arduino

Queste funzioni generalmente funzionano con i caratteri, verificando che un

particolare carattere appartenga a un particolare insieme di caratteri.

isAlpha ()
La funzione isAlpha () controlla se il carattere passato è un carattere
alfabetico.

isAlphaNumeric ()
La funzione isAlphaNumeric () controlla se il carattere che le viene passato è
un carattere alfabetico o un numero.

isAscii ()
La funzione isAscii () controlla se il carattere passato ad essa è uno dei
caratteri Ascii.

isControl ()
La funzione isControl () controlla se il carattere passato è un carattere di
controllo.

isDigit ()
La funzione isDigit () controlla se il carattere passato è un numero.

isGraph ()
La funzione isGraph () verifica se il carattere tipografico passato ad essa è
stampabile e contiene del contenuto visibile (lo spazio è stampabile ma non
ha contenuto visivo).

isHexadecimalDigit ()
IsHexadecimalDigit () verifica se il carattere passato è una cifra esadecimale
(cifra esadecimale); cioè è tra AF o 9-0.

isLowerCase ()
La funzione isLowerCase () controlla se al carattere passato ad essa viene
passato un carattere alfabetico minuscolo .

isPrintable ()
IsPrintable () controlla se il carattere passato è stampabile (cioè uno dei
caratteri che produce un output anche se è vuoto).

isPunct ()
La funzione isPunct () controlla se il carattere tipografico passato ad essa è un
segno di punteggiatura (cioè il carattere tipografico è virgola, punto e virgola,
punto esclamativo, ecc.)?

isSpace ()
La funzione isSpace () controlla se il carattere che le viene passato è uno
spazio.

isUpperCase ()
La funzione isUpperCase () controlla se il carattere passato ad essa è un
carattere alfabetico minuscolo .

isWhitespace ()
La funzione isWhitespace () controlla se il carattere che le viene passato è
uno spazio bianco.
Funzioni di conversione di Arduino

Le funzioni di conversione convertono tra diversi tipi di dati in Arduino.

byte ()
La funzione byte () converte il valore passato ad essa tipo byte.

char ()
La funzione char () converte il valore passato nel tipo char.

galleggiante ()
La funzione float () converte il valore passato (float).

int ()
La funzione int () converte il valore passato nel tipo intero.

lungo ()
La funzione long () converte il valore passato nel tipo "long".

parola ()
La funzione word () converte il valore passato nel tipo di parola.
Funzioni di controllo provinciale in Arduino

Le funzioni in questa sezione controllano i distretti in Arduino, attivando o

disabilitando una specifica interruzione su una gamba, o attivando o
disabilitando tutte le interruzioni.

Attachinterrupt ()
La funzione attachInterrupt () attiva uno specifico interrupt esterno su una
delle gambe nella scheda arduino .

() Scollegainterrupt
La funzione detachInterrupt () disabilita una specifica interruzione esterna
associata a una delle gambe della scheda Arduino.

() Interrompe
La funzione interrupts () disattiva gli interrupt dopo averla interrotta
chiamando la funzione nointerrupts ().

() Nointerrupts
La funzione noInterrupts () disabilita tutti gli interrupt nella scheda Arduino.

Capitolo VI
 Strumenti aggiuntivi

La parola chiave programm in Arduino

La parola chiave PROGMEM viene utilizzata con le variabili quando i suoi

dati devono essere memorizzati nella memoria del programma (memoria
flash) piuttosto che nella SRAM. Per ulteriori informazioni sui tipi di
memoria disponibili in Arduino, vedere questa pagina.

La parola chiave PROGMEM è classificata in "qualificatore variabile" e deve

essere utilizzata solo con i tipi di dati definiti nella libreria pgmspace.h .
Questa parola dice al banchiere di posizionare i dati variabili che hai usato
con esso in flash invece che in SRAM dove dovrebbero essere memorizzati
nello stato normale.

La parola chiave PROGMEM fa parte della libreria pgmspace.h . Questo

disco è incluso automaticamente nelle versioni recenti dell'IDE di Arduino.
Tuttavia, se si utilizza una versione precedente alla 1.0 (2011), la libreria
deve essere inclusa manualmente all'inizio del codice utilizzando include #:

#include < avr / pgmspace.h >

Struttura generale

const dataType variableName [] PROGMEM = {data0, data1, data3…};

DataType rappresenta qualsiasi tipo di dati e variableName è il nome della

matrice di dati da archiviare nella memoria flash. Tieni presente che, poiché
la parola chiave PROGMEM è vincolata a una variabile, non esiste alcuna
regola che richieda che sia in un luogo specifico durante la dichiarazione di
una variabile; Tuttavia, alcuni test hanno suggerito che PROGMEM, in
diverse versioni di Arduino (che utilizza il banchiere del Golfo), può
funzionare in una posizione specifica solo quando si dichiara una variabile. Il
secondo esempio è provato nella sezione degli esempi nella versione Arduino
13; l'esempio potrebbe funzionare meglio nelle versioni precedenti se
PROGMEM viene posizionato dopo il nome della variabile.

const dataType variableName [] PROGMEM = {};

const PROGMEM dataType variabileName [] = {};
const dataType PROGMEM variableName [] = {};

Poiché è possibile utilizzare la parola chiave PROGMEM con una variabile, è

meglio usarla con un array (o una struttura simile in C per memorizzare i dati,
menzionati in questa documentazione o meno) per contenere i dati da
memorizzare in flash memoria se questi dati sono grandi.
L'utilizzo di PROGMEM richiede una procedura in due fasi. Dopo aver
memorizzato i dati nella memoria flash (il primo passo), è necessario
utilizzare funzioni speciali (funzioni) definite nella libreria pgmspace.h per
leggere questi dati dalla memoria del programma e metterli nella SRAM,
quindi possiamo prendere approfittare di questi dati e usarli.
Esempi

Il codice seguente mostra come scrivere i dati nella memoria flash e poi
leggerli di nuovo:
// Memorize some integerless numbers
const PROGMEM uint16_t charSet [] = {65000, 32796, 16843, 10, 11234};

// Save some characters

const char signMessage [] PROGMEM = {"I AM PREDATOR, UNSEEN
COMBATANT. CREATED BY THE UNITED STATES DEPART"};

unsigned int displayInt;

int k; // counter variable
char myChar;

void setup () {
Serial.begin (9600);
while (! Serial); // Waiting for serial port connection

// Type here anything you want to configure and execute it once

// Re-read whole numbers
for (k = 0; k <5; k ++)
{
displayInt = pgm_read_word_near (charSet + k);
Serial.println (displayInt);
}
 Serial.println ();

// Re-read the characters

for (k = 0; k <strlen_P (signMessage); k ++)
{
myChar = pgm_read_byte_near (signMessage + k);
Serial.print (myChar);
}

Serial.println ();
}

void loop () {
// Write here your program to execute it frequently

}
Quando si lavora con una grande quantità di testo, come avere un progetto sul
display LCD, è una buona idea creare e configurare un array di stringhe di
testo per memorizzarle. Poiché le stringhe di testo stesse sono array, è
necessario utilizzare una matrice 2D. L'esempio seguente illustra l'idea di
collocare grandi quantità di dati in memoria di programma:
/*
PROGMEM stringa demo
Come memorizzare una tabella di stringhe nella memoria del programma
(flash),
e recuperarli.
Informazioni riassunte da:
http://www.nongnu.org/avr-libc/user-manual/pgmspace.html

L'impostazione di una tabella (array) di stringhe nella memoria del

programma è leggermente complicata, ma
ecco un buon modello da seguire.

L'impostazione delle stringhe è un processo in due fasi. Definisci prima le

stringhe.
*/
#include <avr / pgmspace.h>
const char string_0 [] PROGMEM = "String 0"; // is the string to store.
Others to suit your "String 0" series
const char string_1 [] PROGMEM = "String 1";
const char string_2 [] PROGMEM = "String 2";
const char string_3 [] PROGMEM = "String 3";
const char string_4 [] PROGMEM = "String 4";
const char string_5 [] PROGMEM = "String 5";

// Then create a table that points to these strings

const char * const string_table [] PROGMEM = {string_0, string_1, string_2,

string_3, string_4, string_5};

char buffer [30]; // Make sure that this matrix is large enough to
accommodate the largest text string
void setup ()
{
Serial.begin (9600);
while (! Serial); // Wait for the serial port to connect
Serial.println ("OK");
}

void loop ()
{
/ * Requires the use of a strings table in memory
Use special functions to retrieve data
A text string from the strcpy_P program memory copies the function
(In our case buffer is the variable memory)
Big enough RAM Make sure that the portion is reserved in memory
To recover data from program memory
*/

for (int i = 0; i <6, i ++)

{
strcpy_P (buffer, (char *) pgm_read_word (& (string_table [i]))); //
Necessary casts and dereferencing, just copy.
Serial.println (buffer);
delay (500);
 }
}

Note e avvertenze
Si noti che le variabili devono essere variabili generali o variabili locali
statiche (definite utilizzando la parola chiave static) per poter utilizzare la
parola PROGMEM con esse.

Il seguente esempio non funzionerà se inserito in una variabile:

const char long_str [] PROGMEM = "Ciao, vorrei parlarti un po 'di me. \ n";

Mentre la seguente dichiarazione funzionerà per una variabile se è definita

localmente all'interno di una funzione:

const static char long_str [] PROGMEM = "Ciao, vorrei parlarti un po 'di me.
\ n"

Chiamata estesa F ()

Quando qualcosa come:

Serial.print ("Scrivi qualcosa sul monitor seriale");

La stringa di testo da stampare normalmente memorizzata nella RAM. Se il

tuo codice stampa molti script sulla porta seriale, riempirà la memoria. Se
disponi di spazio flash, puoi investirlo facilmente memorizzando questi testi
al suo interno utilizzando la seguente formula:

Serial.print (F ("Scrivi qualcosa sul monitor seriale che è memorizzato in

FLASH"));

Capitolo VII
Proteus

In questo capitolo, eseguiremo il primo esperimento, che consiste

nell'accendere e spegnere ripetutamente il LED. Per fare in modo che tutti i
concetti e i passaggi siano collegati tra loro, spiegheremo tutti i passaggi
partendo da come creare un progetto su Proteus fino all'estrazione di un file
Hex che verrà utilizzato per programmare Arduino oltre a eseguire
l'esperimento e osservare i risultati . Inoltre, verrà trattata la spiegazione
passo passo.
Disegno del cerchio su proteas

1. Apri Proteus 8 e scegli un nuovo progetto.

2. Digitare il nome del progetto e il percorso di archiviazione, quindi fare clic

su Avanti.

3. Scegliere Crea schema da modelli, quindi scegliere modello (predefinito).

. Scegliere non creare pcb come mostrato, quindi scegliere Avanti.

5. Sebbene su Proteus esista una piattaforma per scrivere e implementare i

codici Arduino, preferisco utilizzare il programma principale di Arduino,
quindi scegli l'opzione specificata nel modo seguente.

6. Questo è il riepilogo del progetto , creeremo solo lo schema. Dopo aver

premuto Fine saremo pronti per posizionare i dispositivi e collegarli tra loro.
7. Sceglieremo tre dispositivi, vale a dire

Arduino UNO
Resistenza da 220 ohm
LED ROSSO

I passaggi seguenti spiegano come scegliere UNO e posizionarlo nell'elenco

dei dispositivi che verranno utilizzati nel progetto. Allo stesso modo, scegli
LED ROSSO e resistenza da 220ohm.

9. L'esempio seguente mostra come posizionare Arduino nello spazio dello

schema. Allo stesso modo, segui i seguenti passaggi e inserisci la resistenza e
il LED.

10. Dopo aver posizionato tutti i dispositivi sull'asmatico e aver collegato le

estremità, avremo la seguente forma.

. Cosa manca ora finché il cerchio non è completo? Non c'è dubbio che sia il
suolo. Per scegliere il terreno, seguire i passaggi illustrati di seguito. Pertanto,
abbiamo completato le impostazioni di connessione per il circuito sul
programma della proteina.

Nota:

La scheda Arduino non ha bisogno di essere collegata all'alimentazione o

addirittura a terra, perché Proteus fa questo processo implicitamente per te.
Scrivere il codice sul programma Arduino

1. Apri il programma Arduino, apri un nuovo progetto, scrivi il seguente

codice, quindi salva il progetto con il nome E1_LED_Blinking

const int LED_Pin = 13;

void setup () {
// put your setup code here, to run once:
pinMode (LED_Pin, OUTPUT);
}

void loop () {
// put your main code here, to run repeatedly:
digitalWrite (LED_Pin, HIGH);
delay (1000);
digitalWrite (LED_Pin, LOW);
delay (1000);
}

Spiegazione del codice:

Il codice inizia annunciando le variabili utilizzate in più di un ambito del

programma. L '"ambito" è il termine racchiuso tra parentesi di tipo {}. Quindi
abbiamo iniziato annunciando la variabile LED_Pin che è stata utilizzata
all'interno del setup e del loop. Il comando const viene utilizzato per garantire
che il valore della variabile non venga nuovamente modificato e poiché la
variabile LED_Pin conserva il valore del numero di porta, non deve essere
modificata di nuovo. Notiamo che il valore 13 è stato assegnato alla variabile
LED_Pin , perché abbiamo collegato il LED alla porta numero 13. All'interno
del setup verrà definito il tipo di porta (port) se è in uscita o in ingresso
tramite la funzione PinMode . All'interno del ciclo, il codice che viene
ripetuto continuamente verrà scritto senza interruzioni. Il codice all'interno
inizia ciclo con la linea ( digitalWrite ( LED_Pin , HIGH), il che significa che
l'uscita 5 volt alla porta denominata LED_Pin , dopo che notiamo il ritardo
(1000) linea, il che significa che il codice rimarrà lo stesso per un periodo di
1 secondo, poi notiamo la presenza della linea ( digitalWrite ) LED_Pin ,
LOW attraverso cui 5 volt sarà impedito di passare alla porta 13 e per
assicurare la continuità del LED smette di illuminazione per un periodo di
almeno 1 secondo dovuto mettere (ritardo) anche alla fine del loop 1000. Se
tramite il codice all'interno del loop si accenderà il led per un secondo e si
spegnerà per un secondo e quindi proseguirà senza fermarsi.

2. Effettuare una verifica del codice premendo il pulsante mostrato in figura

per assicurarsi che il codice non contenga errori.

3. Se il codice è corretto, vedrai un messaggio simile al seguente messaggio

sotto il programma Arduino.

4. Dopo esserti assicurato che il codice sia privo di errori, vai al menu di
disegno e scegli Esporta binario compilato. Questo serve per estrarre il file
esadecimale. Che viene utilizzato per programmare i microcontrollori.

. Andando nella cartella in cui è stato salvato il progetto, troverai un file .hx .
Con lo stesso nome del progetto.
6. Tornare al cerchio in Proteus, premere Arduino per aggiungere il file di
script come mostrato nei passaggi seguenti.

7. Accendere il circuito e notare come il LED si accende e poi si spegne

ripetutamente.

8. Provare a modificare il tempo di ritardo su 500 anziché su 1000, eseguire i

passaggi da 2 a 7 e notare la differenza.

Discussione

Supponiamo che si scrive il codice nell'immagine seguente e ignorare il

ritardo ritardo dopo la digitalWrite ( LED_Pin , LOW). Cosa ti aspetti che
accada in questo caso?

const int LED_Pin = 13;

void setup () {
// put your setup code here, to run once:
pinMode (LED_Pin, OUTPUT);
}

void loop () {
// put your main code here, to run repeatedly:
digitalWrite (LED_Pin, HIGH);
 delay (1000);
digitalWrite (LED_Pin, LOW);
}

Quindi facciamo il processo di implementazione, inizieremo dal loop e poi

metteremo 5 volt sulla porta chiamata LED_Pin che originariamente è la
porta numero 13. Quindi andremo alla seconda riga per implementarla e
troviamo un ritardo di 1000 e poiché le offerte funzione di ritardo con i valori
in millisecondi allora questo questo significa che il ritardo continuerà per un
periodo di 1 secondo, e questo ritardo rimarrà sul ultimo stato micro era
acceso, in modo che il LED si accende per un periodo di 1 secondo, cioè fino
al termine del comando di ritardo. Ora stiamo per eseguire la terza riga che
contiene il comando ( digitalWrite ( LED_Pin , LOW) in cui il LED si
spegne. Bene il LED si è spento oggi, ma allora che cosa? Concentrarsi su di
me bene qui siamo all'interno del ciclo funzione e quindi il codice
ricomincerà ad essere eseguito dalla prima riga A all'interno del loop in cui il
comando che emetterà 5 volt al LED e si illuminerà di nuovo! Qui sta il
problema dove verrà eseguita l'ultima riga e subito dopo di essa verrà
eseguita la prima riga e su di essa l'occhio non potrà accorgersi che il LED si
è spento perché l'implementazione del codice è calcolata in microsecondi per
questo Il ritardo doveva essere messo dopo il comando che richiedeva che il
LED fosse spento.