Arduino - Guida rapida

Arduino è una piattaforma prototipo (open-source) basata su hardware e software di facile utilizzo. Consiste in un circuito stampato, che può essere programmato (indicato come microcontrollore) e un software già pronto chiamato Arduino IDE (Integrated Development Environment), che viene utilizzato per scrivere e caricare il codice del computer sulla scheda fisica.

Le caratteristiche principali sono:

• Le schede Arduino sono in grado di leggere segnali di ingresso analogici o digitali da diversi sensori e trasformarli in un'uscita come l'attivazione di un motore, l'accensione / spegnimento del LED, la connessione al cloud e molte altre azioni.

• È possibile controllare le funzioni della scheda inviando una serie di istruzioni al microcontrollore sulla scheda tramite l'IDE di Arduino (denominato software di caricamento).

• A differenza della maggior parte dei circuiti programmabili precedenti, Arduino non necessita di un componente hardware aggiuntivo (chiamato programmatore) per caricare un nuovo codice sulla scheda. Puoi semplicemente usare un cavo USB.

• Inoltre, l'IDE di Arduino utilizza una versione semplificata di C ++, rendendo più facile imparare a programmare.

• Infine, Arduino fornisce un fattore di forma standard che suddivide le funzioni del microcontrollore in un pacchetto più accessibile.

Tipi di schede

Sono disponibili vari tipi di schede Arduino a seconda dei diversi microcontrollori utilizzati. Tuttavia, tutte le schede Arduino hanno una cosa in comune: sono programmate tramite l'IDE di Arduino.

Le differenze si basano sul numero di ingressi e uscite (il numero di sensori, LED e pulsanti che è possibile utilizzare su una singola scheda), velocità, tensione di esercizio, fattore di forma ecc. interfaccia (hardware), che dovresti acquistare separatamente. Alcuni possono funzionare direttamente da una batteria da 3,7 V, altri richiedono almeno 5 V.

Ecco un elenco delle diverse schede Arduino disponibili.

Arduino boards based on ATMEGA328 microcontroller

Nome scheda	Volt di funzionamento	Velocità di clock	I / o digitale	Ingressi analogici	PWM	UART	Interfaccia di programmazione
Arduino Uno R3	5V	16 MHz	14	6	6	1	USB tramite ATMega16U2
Arduino Uno R3 SMD	5V	16 MHz	14	6	6	1	USB tramite ATMega16U2
Tabellone rosso	5V	16 MHz	14	6	6	1	USB tramite FTDI
Arduino Pro 3.3v / 8 MHz	3,3V	8 MHz	14	6	6	1	Intestazione compatibile con FTDI
Arduino Pro 5V / 16MHz	5V	16 MHz	14	6	6	1	Intestazione compatibile con FTDI
Arduino mini 05	5V	16 MHz	14	8	6	1	Intestazione compatibile con FTDI
Arduino Pro mini 3.3v / 8mhz	3,3V	8 MHz	14	8	6	1	Intestazione compatibile con FTDI
Arduino Pro mini 5v / 16mhz	5V	16 MHz	14	8	6	1	Intestazione compatibile con FTDI
Arduino Ethernet	5V	16 MHz	14	6	6	1	Intestazione compatibile con FTDI
Arduino Fio	3,3V	8 MHz	14	8	6	1	Intestazione compatibile con FTDI
Scheda principale di LilyPad Arduino 328	3,3V	8 MHz	14	6	6	1	Intestazione compatibile con FTDI
LilyPad Arduino semplice scheda	3,3V	8 MHz	9	4	5	0	Intestazione compatibile con FTDI

Arduino boards based on ATMEGA32u4 microcontroller

Nome scheda	Volt di funzionamento	Velocità di clock	I / o digitale	Ingressi analogici	PWM	UART	Interfaccia di programmazione
Arduino Leonardo	5V	16 MHz	20	12	7	1	USB nativo
Pro micro 5V / 16MHz	5V	16 MHz	14	6	6	1	USB nativo
Pro micro 3,3 V / 8 MHz	5V	16 MHz	14	6	6	1	USB nativo
LilyPad Arduino USB	3,3V	8 MHz	14	6	6	1	USB nativo

Arduino boards based on ATMEGA2560 microcontroller

Nome scheda	Volt di funzionamento	Velocità di clock	I / o digitale	Ingressi analogici	PWM	UART	Interfaccia di programmazione
Arduino Mega 2560 R3	5V	16 MHz	54	16	14	4	USB tramite ATMega16U2B
Mega Pro 3.3V	3,3V	8 MHz	54	16	14	4	Intestazione compatibile con FTDI
Mega Pro 5V	5V	16 MHz	54	16	14	4	Intestazione compatibile con FTDI
Mega Pro Mini 3.3V	3,3V	8 MHz	54	16	14	4	Intestazione compatibile con FTDI

Arduino boards based on AT91SAM3X8E microcontroller

Nome scheda	Volt di funzionamento	Velocità di clock	I / o digitale	Ingressi analogici	PWM	UART	Interfaccia di programmazione
Arduino Mega 2560 R3	3,3V	84 MHz	54	12	12	4	USB nativo

In questo capitolo impareremo i diversi componenti sulla scheda Arduino. Studieremo la scheda Arduino UNO perché è la scheda più popolare nella famiglia di schede Arduino. Inoltre, è la migliore scheda per iniziare con l'elettronica e la codifica. Alcune schede hanno un aspetto leggermente diverso da quello indicato di seguito, ma la maggior parte degli Arduino ha la maggior parte di questi componenti in comune.

	Power USB La scheda Arduino può essere alimentata utilizzando il cavo USB dal tuo computer. Tutto quello che devi fare è collegare il cavo USB alla connessione USB (1).
	Power (Barrel Jack) Le schede Arduino possono essere alimentate direttamente dalla rete di alimentazione CA collegandola al Barrel Jack (2).
	Voltage Regulator La funzione del regolatore di tensione è quella di controllare la tensione fornita alla scheda Arduino e stabilizzare le tensioni CC utilizzate dal processore e da altri elementi.
	Crystal Oscillator L'oscillatore a cristallo aiuta Arduino ad affrontare i problemi di tempo. In che modo Arduino calcola il tempo? La risposta è, usando l'oscillatore a cristallo. Il numero stampato sulla parte superiore del cristallo di Arduino è 16.000H9H. Ci dice che la frequenza è di 16.000.000 Hertz o 16 MHz.
	Arduino Reset Puoi resettare la tua scheda Arduino, cioè avviare il programma dall'inizio. Puoi resettare la scheda UNO in due modi. In primo luogo, utilizzando il pulsante di ripristino (17) sulla scheda. In secondo luogo, puoi collegare un pulsante di ripristino esterno al pin di Arduino etichettato RESET (5).
	Pins (3.3, 5, GND, Vin) 3,3 V (6) - Fornisce 3,3 volt di uscita 5V (7) - Fornisce 5 volt di uscita La maggior parte dei componenti utilizzati con la scheda Arduino funziona bene con 3,3 volt e 5 volt. GND (8) (Ground) - Ci sono diversi pin GND su Arduino, ognuno dei quali può essere utilizzato per mettere a terra il circuito. Vin (9) - Questo pin può essere utilizzato anche per alimentare la scheda Arduino da una fonte di alimentazione esterna, come l'alimentazione di rete CA.
	Analog pins La scheda Arduino UNO ha sei pin di ingresso analogico da A0 a A5. Questi pin possono leggere il segnale da un sensore analogico come il sensore di umidità o il sensore di temperatura e convertirlo in un valore digitale che può essere letto dal microprocessore.
	Main microcontroller Ogni scheda Arduino ha il proprio microcontrollore (11). Puoi assumerlo come il cervello della tua tavola. L'IC principale (circuito integrato) su Arduino è leggermente diverso da scheda a scheda. I microcontrollori sono generalmente della società ATMEL. Devi sapere quale IC ha la tua scheda prima di caricare un nuovo programma dall'IDE di Arduino. Queste informazioni sono disponibili nella parte superiore dell'IC. Per maggiori dettagli sulla costruzione e le funzioni dell'IC, fare riferimento alla scheda tecnica.
	ICSP pin Per lo più, ICSP (12) è un AVR, una piccola intestazione di programmazione per Arduino composta da MOSI, MISO, SCK, RESET, VCC e GND. Viene spesso definito SPI (Serial Peripheral Interface), che potrebbe essere considerato come una "espansione" dell'output. In realtà, stai asservendo il dispositivo di output al master del bus SPI.
	Power LED indicator Questo LED dovrebbe accendersi quando colleghi il tuo Arduino a una fonte di alimentazione per indicare che la tua scheda è alimentata correttamente. Se questa luce non si accende, significa che c'è qualcosa che non va nella connessione.
	TX and RX LEDs Sulla tua scheda troverai due etichette: TX (trasmissione) e RX (ricezione). Appaiono in due punti sulla scheda Arduino UNO. Innanzitutto, ai pin digitali 0 e 1, per indicare i pin responsabili della comunicazione seriale. In secondo luogo, i led TX e RX (13). Il led TX lampeggia con velocità diversa durante l'invio dei dati seriali. La velocità di lampeggiamento dipende dal baud rate utilizzato dalla scheda. RX lampeggia durante il processo di ricezione.
	Digital I/O La scheda Arduino UNO ha 14 pin I / O digitali (15) (di cui 6 forniscono l'uscita PWM (Pulse Width Modulation). Questi pin possono essere configurati per funzionare come pin digitali di ingresso per leggere valori logici (0 o 1) o come digitali pin di uscita per pilotare diversi moduli come LED, relè, ecc. I pin etichettati "~" possono essere utilizzati per generare PWM.
	AREF AREF sta per riferimento analogico. A volte viene utilizzato per impostare una tensione di riferimento esterno (tra 0 e 5 Volt) come limite superiore per i pin di ingresso analogico.

Dopo aver appreso le parti principali della scheda Arduino UNO, siamo pronti per imparare come configurare l'IDE di Arduino. Una volta appreso questo, saremo pronti per caricare il nostro programma sulla scheda Arduino.

In questa sezione impareremo in semplici passaggi come configurare l'IDE di Arduino sul nostro computer e preparare la scheda per ricevere il programma tramite cavo USB.

Step 1- Per prima cosa devi avere la tua scheda Arduino (puoi scegliere la tua scheda preferita) e un cavo USB. Nel caso in cui utilizzi Arduino UNO, Arduino Duemilanove, Nano, Arduino Mega 2560 o Diecimila, avrai bisogno di un cavo USB standard (spina A a spina B), del tipo che collegheresti a una stampante USB come mostrato nell'immagine seguente.

Nel caso in cui utilizzi Arduino Nano, avrai bisogno di un cavo da A a Mini-B invece come mostrato nell'immagine seguente.

Step 2 − Download Arduino IDE Software.

È possibile ottenere diverse versioni di Arduino IDE dalla pagina di download sul sito Web ufficiale di Arduino. Devi selezionare il tuo software, che è compatibile con il tuo sistema operativo (Windows, IOS o Linux). Una volta completato il download del file, decomprimilo.

Step 3 − Power up your board.

Arduino Uno, Mega, Duemilanove e Arduino Nano traggono automaticamente energia dalla connessione USB al computer o da un alimentatore esterno. Se stai usando un Arduino Diecimila, devi assicurarti che la scheda sia configurata per trarre alimentazione dalla connessione USB. La fonte di alimentazione viene selezionata con un ponticello, un piccolo pezzo di plastica che si inserisce su due dei tre pin tra l'USB e le prese di alimentazione. Verificare che sia sui due pin più vicini alla porta USB.

Collega la scheda Arduino al tuo computer utilizzando il cavo USB. Il LED di alimentazione verde (etichettato PWR) dovrebbe accendersi.

Step 4 − Launch Arduino IDE.

Dopo aver scaricato il software IDE Arduino, è necessario decomprimere la cartella. All'interno della cartella, puoi trovare l'icona dell'applicazione con un'etichetta infinita (application.exe). Fare doppio clic sull'icona per avviare l'IDE.

Step 5 − Open your first project.

Una volta avviato il software, hai due opzioni:

• Crea un nuovo progetto.
• Apri un esempio di progetto esistente.

Per creare un nuovo progetto, seleziona File → New.

Per aprire un esempio di progetto esistente, selezionare File → Esempio → Basics → Blink.

Qui stiamo selezionando solo uno degli esempi con il nome Blink. Accende e spegne il LED con un certo ritardo. È possibile selezionare qualsiasi altro esempio dall'elenco.

Step 6 − Select your Arduino board.

Per evitare errori durante il caricamento del programma sulla scheda, è necessario selezionare il nome della scheda Arduino corretto, che corrisponde alla scheda collegata al computer.

Vai su Strumenti → Bacheca e seleziona la tua bacheca.

Qui, abbiamo selezionato la scheda Arduino Uno secondo il nostro tutorial, ma devi selezionare il nome corrispondente alla scheda che stai utilizzando.

Step 7 − Select your serial port.

Seleziona il dispositivo seriale della scheda Arduino. Vai aTools → Serial Portmenù. È probabile che sia COM3 o superiore (COM1 e COM2 sono solitamente riservati alle porte seriali hardware). Per scoprirlo puoi scollegare la tua scheda Arduino e riaprire il menu, la voce che scompare dovrebbe essere della scheda Arduino. Ricollegare la scheda e selezionare quella porta seriale.

Step 8 − Upload the program to your board.

Prima di spiegare come possiamo caricare il nostro programma sulla scheda, dobbiamo dimostrare la funzione di ogni simbolo che appare nella barra degli strumenti IDE di Arduino.

A - Utilizzato per verificare se sono presenti errori di compilazione.

B - Utilizzato per caricare un programma sulla scheda Arduino.

C - Collegamento utilizzato per creare un nuovo schizzo.

D - Utilizzato per aprire direttamente uno degli schizzi di esempio.

E - Usato per salvare il tuo schizzo.

F - Monitor seriale utilizzato per ricevere dati seriali dalla scheda e inviare i dati seriali alla scheda.

Ora, fai semplicemente clic sul pulsante "Carica" ​​nell'ambiente. Attendi qualche secondo; vedrai lampeggiare i LED RX e TX sulla scheda. Se il caricamento ha esito positivo, nella barra di stato verrà visualizzato il messaggio "Caricamento completato".

Note - Se hai una scheda Arduino Mini, NG o altra scheda, devi premere fisicamente il pulsante di ripristino sulla scheda, immediatamente prima di fare clic sul pulsante di caricamento sul software Arduino.

In questo capitolo, studieremo in profondità la struttura del programma Arduino e apprenderemo ulteriori nuove terminologie utilizzate nel mondo Arduino. Il software Arduino è open source. Il codice sorgente per l'ambiente Java è rilasciato sotto GPL e le librerie di microcontrollori C / C ++ sono sotto LGPL.

Sketch - La prima nuova terminologia è il programma Arduino chiamato "sketch".

Struttura

I programmi Arduino possono essere suddivisi in tre parti principali: Structure, Values (variabili e costanti) e Functions. In questo tutorial, impareremo il programma software Arduino, passo dopo passo, e come possiamo scrivere il programma senza alcun errore di sintassi o di compilazione.

Cominciamo con il Structure. La struttura del software è composta da due funzioni principali:

• Funzione Setup ()
• Funzione Loop ()

Void setup ( ) {

}

• PURPOSE - Il setup()viene chiamata quando inizia uno schizzo. Usalo per inizializzare le variabili, le modalità pin, iniziare a usare le librerie, ecc. La funzione di configurazione verrà eseguita solo una volta, dopo ogni accensione o ripristino della scheda Arduino.

• INPUT - -

• OUTPUT - -

• RETURN - -

Void Loop ( ) {

}

• PURPOSE - Dopo aver creato un file setup() funzione, che inizializza e imposta i valori iniziali, la loop()funzione fa esattamente ciò che suggerisce il nome e si ripete consecutivamente, consentendo al programma di cambiare e rispondere. Usalo per controllare attivamente la scheda Arduino.

• INPUT - -

• OUTPUT - -

• RETURN - -

I tipi di dati in C si riferiscono a un sistema esteso utilizzato per dichiarare variabili o funzioni di diversi tipi. Il tipo di variabile determina quanto spazio occupa nella memoria e come viene interpretata la sequenza di bit memorizzata.

La tabella seguente fornisce tutti i tipi di dati che utilizzerai durante la programmazione di Arduino.

vuoto	Booleano	char	Carattere non firmato	byte	int	Int. Senza segno	parola
lungo	Non firmato a lungo	corto	galleggiante	Doppio	Vettore	Matrice di caratteri stringa	Oggetto stringa

vuoto

La parola chiave void viene utilizzata solo nelle dichiarazioni di funzione. Indica che la funzione non dovrebbe restituire alcuna informazione alla funzione da cui è stata chiamata.

Esempio

Void Loop ( ) {
   // rest of the code
}

Booleano

Un booleano contiene uno dei due valori, vero o falso. Ogni variabile booleana occupa un byte di memoria.

Esempio

boolean val = false ; // declaration of variable with type boolean and initialize it with false
boolean state = true ; // declaration of variable with type boolean and initialize it with true

Char

Un tipo di dati che occupa un byte di memoria che memorizza un valore di carattere. I caratteri letterali sono scritti tra virgolette singole in questo modo: "A" e per più caratteri, le stringhe utilizzano virgolette doppie: "ABC".

Tuttavia, i caratteri vengono memorizzati come numeri. Puoi vedere la codifica specifica nel grafico ASCII . Ciò significa che è possibile eseguire operazioni aritmetiche sui caratteri, in cui viene utilizzato il valore ASCII del carattere. Ad esempio, "A" + 1 ha il valore 66, poiché il valore ASCII della lettera maiuscola A è 65.

Esempio

Char chr_a = ‘a’ ;//declaration of variable with type char and initialize it with character a
Char chr_c = 97 ;//declaration of variable with type char and initialize it with character 97

carattere non firmato

Unsigned charè un tipo di dati senza segno che occupa un byte di memoria. Il tipo di dati char senza segno codifica i numeri da 0 a 255.

Esempio

Unsigned Char chr_y = 121 ; // declaration of variable with type Unsigned char and initialize it with character y

byte

Un byte memorizza un numero senza segno a 8 bit, da 0 a 255.

Esempio

byte m = 25 ;//declaration of variable with type byte and initialize it with 25

int

I numeri interi sono il tipo di dati principale per l'archiviazione dei numeri. int memorizza un valore a 16 bit (2 byte). Questo produce un intervallo compreso tra -32.768 e 32.767 (valore minimo di -2 ^ 15 e valore massimo di (2 ^ 15) - 1).

Il intle dimensioni variano da tavola a tavola. Su Arduino Due, ad esempio, un fileintmemorizza un valore a 32 bit (4 byte). Ciò produce un intervallo compreso tra -2.147.483.648 e 2.147.483.647 (valore minimo di -2 ^ 31 e valore massimo di (2 ^ 31) - 1).

Esempio

int counter = 32 ;// declaration of variable with type int and initialize it with 32

Int. Senza segno

Gli int senza segno (interi senza segno) sono uguali a int nel modo in cui memorizzano un valore di 2 byte. Invece di memorizzare numeri negativi, tuttavia, memorizzano solo valori positivi, producendo un intervallo utile da 0 a 65.535 (2 ^ 16) - 1). Due memorizza un valore di 4 byte (32 bit), compreso tra 0 e 4.294.967.295 (2 ^ 32 - 1).

Esempio

Unsigned int counter = 60 ; // declaration of variable with 
   type unsigned int and initialize it with 60

parola

Sulle schede Uno e altre basate su ATMEGA, una parola memorizza un numero senza segno a 16 bit. Su Due e Zero, memorizza un numero senza segno a 32 bit.

Esempio

word w = 1000 ;//declaration of variable with type word and initialize it with 1000

Lungo

Le variabili lunghe sono variabili di dimensioni estese per l'archiviazione di numeri e memorizzano 32 bit (4 byte), da -2.147.483.648 a 2.147.483.647.

Esempio

Long velocity = 102346 ;//declaration of variable with type Long and initialize it with 102346

non firmato a lungo

Le variabili lunghe senza segno sono variabili di dimensione estesa per l'archiviazione di numeri e memorizzano 32 bit (4 byte). A differenza dei long standard, i long senza segno non memorizzano i numeri negativi, rendendo il loro intervallo da 0 a 4.294.967.295 (2 ^ 32 - 1).

Esempio

Unsigned Long velocity = 101006 ;// declaration of variable with 
   type Unsigned Long and initialize it with 101006

corto

Uno short è un tipo di dati a 16 bit. Su tutti gli Arduino (basati su ATMega e ARM), uno short memorizza un valore a 16 bit (2 byte). Questo produce un intervallo compreso tra -32.768 e 32.767 (valore minimo di -2 ^ 15 e valore massimo di (2 ^ 15) - 1).

Esempio

short val = 13 ;//declaration of variable with type short and initialize it with 13

galleggiante

Il tipo di dati per il numero in virgola mobile è un numero con virgola decimale. I numeri in virgola mobile sono spesso usati per approssimare i valori analogici e continui perché hanno una risoluzione maggiore degli interi.

I numeri in virgola mobile possono essere grandi come 3.4028235E + 38 e bassi come -3.4028235E + 38. Sono memorizzati come 32 bit (4 byte) di informazioni.

Esempio

float num = 1.352;//declaration of variable with type float and initialize it with 1.352

Doppio

Sulle schede Uno e altre basate su ATMEGA, il numero in virgola mobile a doppia precisione occupa quattro byte. Cioè, la doppia implementazione è esattamente la stessa del float, senza guadagno di precisione. Su Arduino Due, i double hanno una precisione di 8 byte (64 bit).

Esempio

double num = 45.352 ;// declaration of variable with type double and initialize it with 45.352

Prima di iniziare a spiegare i tipi di variabili, un argomento molto importante di cui dobbiamo assicurarci che tu abbia compreso appieno è chiamato variable scope.

Cos'è l'ambito variabile?

Le variabili nel linguaggio di programmazione C, utilizzato da Arduino, hanno una proprietà chiamata scope. Uno scope è una regione del programma e ci sono tre posti in cui le variabili possono essere dichiarate. Sono -

• All'interno di una funzione o di un blocco, che viene chiamato local variables.
• Nella definizione dei parametri della funzione, che viene chiamato formal parameters.
• Al di fuori di tutte le funzioni, che viene chiamato global variables.

Variabili locali

Le variabili dichiarate all'interno di una funzione o di un blocco sono variabili locali. Possono essere utilizzati solo dalle istruzioni che si trovano all'interno di quella funzione o blocco di codice. Non è noto che le variabili locali funzionino al di fuori della propria. Di seguito è riportato l'esempio che utilizza le variabili locali:

Void setup () {

}

Void loop () {
   int x , y ;
   int z ; Local variable declaration
   x = 0;
   y = 0; actual initialization
   z = 10;
}

Variabili globali

Le variabili globali sono definite al di fuori di tutte le funzioni, di solito all'inizio del programma. Le variabili globali manterranno il loro valore per tutta la durata del programma.

È possibile accedere a una variabile globale da qualsiasi funzione. Cioè, una variabile globale è disponibile per l'uso in tutto il programma dopo la sua dichiarazione.

L'esempio seguente utilizza variabili globali e locali:

Int T , S ;
float c = 0 ; Global variable declaration

Void setup () {

}

Void loop () {
   int x , y ;
   int z ; Local variable declaration
   x = 0;
   y = 0; actual initialization
   z = 10;
}

Un operatore è un simbolo che dice al compilatore di eseguire specifiche funzioni matematiche o logiche. Il linguaggio C è ricco di operatori incorporati e fornisce i seguenti tipi di operatori:

• Operatori aritmetici
• Operatori di confronto
• Operatori booleani
• Operatori bit per bit
• Operatori composti

Operatori aritmetici

Supponiamo che la variabile A contenga 10 e la variabile B ne contenga 20, quindi -

Mostra esempio

Nome dell'operatore	Operatore semplice	Descrizione	Esempio
operatore di assegnazione	=	Memorizza il valore a destra del segno di uguale nella variabile a sinistra del segno di uguale.	A = B
aggiunta	+	Aggiunge due operandi	A + B darà 30
sottrazione	-	Sottrae il secondo operando dal primo	A - B darà -10
moltiplicazione	*	Moltiplica entrambi gli operandi	A * B darà 200
divisione	/	Dividi il numeratore per denominatore	B / A darà 2
modulo	%	Operatore modulo e resto di dopo una divisione intera	B% A darà 0

Operatori di confronto

Supponiamo che la variabile A contenga 10 e la variabile B ne contenga 20, quindi -

Mostra esempio

Nome dell'operatore	Operatore semplice	Descrizione	Esempio
uguale a	==	Controlla se il valore di due operandi è uguale o meno, in caso affermativo la condizione diventa vera.	(A == B) non è vero
non uguale a	! =	Controlla se il valore di due operandi è uguale o meno, se i valori non sono uguali la condizione diventa vera.	(A! = B) è vero
meno di	<	Controlla se il valore dell'operando sinistro è inferiore al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A <B) è vero
più grande di	>	Controlla se il valore dell'operando sinistro è maggiore del valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A> B) non è vero
minore o uguale a	<=	Controlla se il valore dell'operando sinistro è minore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A <= B) è vero
maggiore o uguale a	> =	Controlla se il valore dell'operando sinistro è maggiore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A> = B) non è vero

Operatori booleani

Supponiamo che la variabile A contenga 10 e la variabile B ne contenga 20, quindi -

Mostra esempio

Nome dell'operatore	Operatore semplice	Descrizione	Esempio
e	&&	Chiamato operatore AND logico. Se entrambi gli operandi sono diversi da zero, la condizione diventa vera.	(A && B) è vero
o	||	Chiamato Operatore OR logico. Se uno dei due operandi è diverso da zero, la condizione diventa vera.	(A || B) è vero
non	!	Chiamato operatore NOT logico. Utilizzare per invertire lo stato logico del suo operando. Se una condizione è vera, l'operatore NOT logico la renderà falsa.	! (A && B) è falso

Operatori bit per bit

Supponiamo che la variabile A contenga 60 e la variabile B ne contenga 13, quindi -

Mostra esempio

Nome dell'operatore	Operatore semplice	Descrizione	Esempio
e	&	L'operatore AND binario copia un po 'nel risultato se esiste in entrambi gli operandi.	(A e B) darà 12 che è 0000 1100
o	|	L'operatore OR binario copia un bit se esiste in uno degli operandi	(A | B) darà 61 che è 0011 1101
xor	^	L'operatore XOR binario copia il bit se è impostato in un operando ma non in entrambi.	(A ^ B) darà 49 che è 0011 0001
non	~	Binary Ones Complement Operator è unario e ha l'effetto di "ribaltare" i bit.	(~ A) darà -60 che è 1100 0011
sposta a sinistra	<<	Operatore binario di spostamento sinistro. Il valore degli operandi di sinistra viene spostato a sinistra del numero di bit specificato dall'operando di destra.	Un << 2 darà 240 che è 1111 0000
sposta a destra	>>	Operatore binario di spostamento a destra. Il valore dell'operando di sinistra viene spostato a destra del numero di bit specificato dall'operando di destra.	Un >> 2 darà 15 che è 0000 1111

Operatori composti

Supponiamo che la variabile A contenga 10 e la variabile B ne contenga 20, quindi -

Mostra esempio

Nome dell'operatore	Operatore semplice	Descrizione	Esempio
incremento	++	Operatore di incremento, aumenta il valore intero di uno	A ++ darà 11
decremento	-	Operatore di decremento, riduce il valore intero di uno	A-- darà 9
aggiunta di composto	+ =	Aggiungi operatore di assegnazione AND. Aggiunge l'operando destro all'operando sinistro e assegna il risultato all'operando sinistro	B + = A è equivalente a B = B + A
sottrazione composta	- =	Sottrai AND operatore di assegnazione. Sottrae l'operando destro dall'operando sinistro e assegna il risultato all'operando sinistro	B - = A è equivalente a B = B - A
moltiplicazione composta	* =	Moltiplica AND operatore di assegnazione. Moltiplica l'operando destro con l'operando sinistro e assegna il risultato all'operando sinistro	B * = A è equivalente a B = B * A
divisione composta	/ =	Divide AND operatore di assegnazione. Divide l'operando sinistro con l'operando destro e assegna il risultato all'operando sinistro	B / = A è equivalente a B = B / A
composto modulo	% =	Modulo AND operatore di assegnazione. Richiede il modulo utilizzando due operandi e assegna il risultato all'operando sinistro	B% = A è equivalente a B = B% A
composto bit per bit o	| =	OR bit per bit inclusivo e operatore di assegnazione	A | = 2 è uguale a A = A | 2
composto bit per bit e	& =	Operatore di assegnazione AND bit per bit	A & = 2 è uguale a A = A & 2

Le strutture decisionali richiedono che il programmatore specifichi una o più condizioni che devono essere valutate o testate dal programma. Dovrebbe essere insieme a una o più istruzioni da eseguire se la condizione è determinata essere vera e, facoltativamente, altre istruzioni da eseguire se la condizione è determinata essere falsa.

Di seguito è riportata la forma generale di una tipica struttura decisionale presente nella maggior parte dei linguaggi di programmazione:

Le istruzioni di controllo sono elementi nel codice sorgente che controllano il flusso di esecuzione del programma. Sono -

S.NO.	Dichiarazione di controllo e descrizione
1	If dichiarazione Richiede un'espressione tra parentesi e un'istruzione o un blocco di istruzioni. Se l'espressione è vera, l'istruzione o il blocco di istruzioni viene eseguito altrimenti queste istruzioni vengono ignorate.
2	If ... else dichiarazione Un if può essere seguita da un'istruzione else opzionale, che viene eseguita quando l'espressione è falsa.
3	If ... else if ... else dichiarazione Il if L'istruzione può essere seguita da un opzionale else if...else istruzione, che è molto utile per testare varie condizioni usando l'istruzione if ... else if.
4	istruzione switch case Simile alle istruzioni if, switch...case controlla il flusso dei programmi consentendo ai programmatori di specificare diversi codici che dovrebbero essere eseguiti in varie condizioni.
5	Operatore condizionale? : L'operatore condizionale? : è l'unico operatore ternario in C.

I linguaggi di programmazione forniscono varie strutture di controllo che consentono percorsi di esecuzione più complicati.

Un'istruzione loop ci consente di eseguire un'istruzione o un gruppo di istruzioni più volte e la seguente è la forma generale di un'istruzione loop nella maggior parte dei linguaggi di programmazione:

Il linguaggio di programmazione C fornisce i seguenti tipi di loop per gestire i requisiti di loop.

S.NO.	Loop e descrizione
1	while loop while i cicli verranno ripetuti continuamente e all'infinito finché l'espressione tra parentesi, () non diventa falsa. Qualcosa deve cambiare la variabile testata, altrimenti il ​​ciclo while non uscirà mai.
2	fare ... while loop Il do…whileè simile al ciclo while. Nel ciclo while, la condizione di continuazione del ciclo viene testata all'inizio del ciclo prima di eseguire il corpo del ciclo.
3	per loop UN for loopesegue le istruzioni un numero di volte predeterminato. L'espressione di controllo per il ciclo viene inizializzata, testata e manipolata interamente all'interno delle parentesi del ciclo for.
4	Ciclo annidato Il linguaggio C consente di utilizzare un ciclo all'interno di un altro ciclo. L'esempio seguente illustra il concetto.
5	Ciclo infinito È il ciclo che non ha condizioni di terminazione, quindi il ciclo diventa infinito.

Le funzioni consentono di strutturare i programmi in segmenti di codice per eseguire singole attività. Il caso tipico per la creazione di una funzione è quando è necessario eseguire la stessa azione più volte in un programma.

La standardizzazione dei frammenti di codice in funzioni presenta diversi vantaggi:

• Le funzioni aiutano il programmatore a rimanere organizzato. Spesso questo aiuta a concettualizzare il programma.

• Le funzioni codificano un'azione in un unico punto in modo che la funzione debba essere pensata e debug solo una volta.

• Ciò riduce anche le possibilità di errori nella modifica, se il codice deve essere modificato.

• Le funzioni rendono l'intero schizzo più piccolo e più compatto perché le sezioni di codice vengono riutilizzate molte volte.

• Rendono più facile riutilizzare il codice in altri programmi rendendolo modulare e l'uso delle funzioni spesso rende il codice più leggibile.

Ci sono due funzioni richieste in uno sketch di Arduino o in un programma, ovvero setup () e loop (). Altre funzioni devono essere create al di fuori delle parentesi di queste due funzioni.

La sintassi più comune per definire una funzione è:

Dichiarazione di funzione

Una funzione è dichiarata al di fuori di qualsiasi altra funzione, sopra o sotto la funzione loop.

Possiamo dichiarare la funzione in due modi diversi:

Il primo modo è semplicemente scrivere la parte della funzione chiamata a function prototype sopra la funzione loop, che consiste in -

• Tipo restituito dalla funzione
• Nome della funzione
• Tipo di argomento della funzione, non è necessario scrivere il nome dell'argomento

Il prototipo della funzione deve essere seguito da un punto e virgola (;).

L'esempio seguente mostra la dimostrazione della dichiarazione di funzione utilizzando il primo metodo.

Esempio

int sum_func (int x, int y) // function declaration {
   int z = 0;
   z = x+y ;
   return z; // return the value
}

void setup () {
   Statements // group of statements
}

Void loop () {
   int result = 0 ;
   result = Sum_func (5,6) ; // function call
}

La seconda parte, che è chiamata definizione o dichiarazione della funzione, deve essere dichiarata sotto la funzione loop, che consiste in:

• Tipo restituito dalla funzione
• Nome della funzione
• Tipo di argomento della funzione, qui è necessario aggiungere il nome dell'argomento
• Il corpo della funzione (istruzioni all'interno della funzione in esecuzione quando la funzione viene chiamata)

L'esempio seguente mostra la dichiarazione di funzione utilizzando il secondo metodo.

Esempio

int sum_func (int , int ) ; // function prototype

void setup () {
   Statements // group of statements
}

Void loop () {
   int result = 0 ;
   result = Sum_func (5,6) ; // function call
}

int sum_func (int x, int y) // function declaration {
   int z = 0;
   z = x+y ;
   return z; // return the value
}

Il secondo metodo dichiara solo la funzione sopra la funzione loop.

Le stringhe vengono utilizzate per memorizzare il testo. Possono essere utilizzati per visualizzare il testo su un LCD o nella finestra del monitor seriale IDE di Arduino. Le stringhe sono utili anche per memorizzare l'input dell'utente. Ad esempio, i caratteri che un utente digita su una tastiera collegata ad Arduino.

Esistono due tipi di stringhe nella programmazione Arduino:

• Matrici di caratteri, che sono le stesse delle stringhe utilizzate nella programmazione C.
• La stringa Arduino, che ci consente di utilizzare un oggetto stringa in uno schizzo.

In questo capitolo impareremo le stringhe, gli oggetti e l'uso delle stringhe negli schizzi di Arduino. Alla fine del capitolo imparerai quale tipo di stringa usare in uno schizzo.

Matrici di caratteri stringa

Il primo tipo di stringa che impareremo è la stringa che è una serie di caratteri del tipo char. Nel capitolo precedente abbiamo appreso cos'è un array; una serie consecutiva dello stesso tipo di variabile immagazzinata in memoria. Una stringa è un array di variabili char.

Una stringa è un array speciale che ha un elemento in più alla fine della stringa, che ha sempre il valore 0 (zero). Questo è noto come "stringa con terminazione null".

Esempio di matrice di caratteri stringa

Questo esempio mostrerà come creare una stringa e stamparla sulla finestra del monitor seriale.

Example

void setup() {
   char my_str[6]; // an array big enough for a 5 character string
   Serial.begin(9600);
   my_str[0] = 'H'; // the string consists of 5 characters
   my_str[1] = 'e';
   my_str[2] = 'l';
   my_str[3] = 'l';
   my_str[4] = 'o';
   my_str[5] = 0; // 6th array element is a null terminator
   Serial.println(my_str);
}

void loop() { 

}

L'esempio seguente mostra di cosa è composta una stringa; un array di caratteri con caratteri stampabili e 0 come ultimo elemento dell'array per mostrare che questo è dove finisce la stringa. La stringa può essere stampata nella finestra del monitor seriale IDE di Arduino utilizzandoSerial.println() e passando il nome della stringa.

Questo stesso esempio può essere scritto in un modo più conveniente come mostrato di seguito -

Example

void setup() {
   char my_str[] = "Hello";
   Serial.begin(9600);
   Serial.println(my_str);
}

void loop() {

}

In questo schizzo, il compilatore calcola la dimensione della matrice di stringhe e inoltre automaticamente null termina la stringa con uno zero. Un array di sei elementi e composto da cinque caratteri seguiti da uno zero viene creato esattamente nello stesso modo dello schizzo precedente.

Manipolazione di array di stringhe

Possiamo modificare un array di stringhe all'interno di uno schizzo come mostrato nello schizzo seguente.

Esempio

void setup() {
   char like[] = "I like coffee and cake"; // create a string
   Serial.begin(9600);
   // (1) print the string
   Serial.println(like);
   // (2) delete part of the string
   like[13] = 0;
   Serial.println(like);
   // (3) substitute a word into the string
   like[13] = ' '; // replace the null terminator with a space
   like[18] = 't'; // insert the new word
   like[19] = 'e';
   like[20] = 'a';
   like[21] = 0; // terminate the string
   Serial.println(like);
}

void loop() {

}

Risultato

I like coffee and cake
I like coffee
I like coffee and tea

Lo schizzo funziona nel modo seguente.

Creazione e stampa della stringa

Nello schizzo sopra riportato, viene creata una nuova stringa e quindi stampata per la visualizzazione nella finestra Monitor seriale.

Accorciare la stringa

La stringa viene accorciata sostituendo il quattordicesimo carattere nella stringa con uno zero di terminazione null (2). Questo è l'elemento numero 13 nell'array di stringhe che conta da 0.

Quando la stringa viene stampata, tutti i caratteri vengono stampati fino al nuovo zero che termina con lo zero. Gli altri personaggi non scompaiono; esistono ancora nella memoria e l'array di stringhe ha ancora le stesse dimensioni. L'unica differenza è che qualsiasi funzione che funziona con le stringhe vedrà solo la stringa fino al primo terminatore null.

Cambiare una parola nella stringa

Infine, lo schizzo sostituisce la parola "torta" con "tè" (3). Per prima cosa deve sostituire il terminatore null in like [13] con uno spazio in modo che la stringa venga ripristinata nel formato originariamente creato.

Nuovi caratteri sovrascrivono "cak" della parola "torta" con la parola "tè". Questo viene fatto sovrascrivendo i singoli caratteri. La "e" di "cake" viene sostituita con un nuovo carattere di terminazione null. Il risultato è che la stringa è effettivamente terminata con due caratteri nulli, quello originale alla fine della stringa e quello nuovo che sostituisce la "e" in "torta". Ciò non fa differenza quando viene stampata la nuova stringa perché la funzione che stampa la stringa smette di stampare i caratteri della stringa quando incontra il primo terminatore nullo.

Functions to Manipulate String Arrays

The previous sketch manipulated the string in a manual way by accessing individual characters in the string. To make it easier to manipulate string arrays, you can write your own functions to do so, or use some of the string functions from the C language library.

Given below is the list Functions to Manipulate String Arrays

S.No.	Functions & Description
1	String() The String class, part of the core as of version 0019, allows you to use and manipulate strings of text in more complex ways than character arrays do. You can concatenate Strings, append to them, search for and replace substrings, and more. It takes more memory than a simple character array, but it is also more useful. For reference, character arrays are referred to as strings with a small ‘s’, and instances of the String class are referred to as Strings with a capital S. Note that constant strings, specified in "double quotes" are treated as char arrays, not instances of the String class
2	charAt() Access a particular character of the String.
3	compareTo() Compares two Strings, testing whether one comes before or after the other, or whether they are equal. The strings are compared character by character, using the ASCII values of the characters. That means, for example, 'a' comes before 'b' but after 'A'. Numbers come before letters.
4	concat() Appends the parameter to a String.
5	c_str() Converts the contents of a string as a C-style, null-terminated string. Note that this gives direct access to the internal String buffer and should be used with care. In particular, you should never modify the string through the pointer returned. When you modify the String object, or when it is destroyed, any pointer previously returned by c_str() becomes invalid and should not be used any longer.
6	endsWith() Tests whether or not a String ends with the characters of another String.
7	equals() Compares two strings for equality. The comparison is case-sensitive, meaning the String "hello" is not equal to the String "HELLO".
8	equalsIgnoreCase() Compares two strings for equality. The comparison is not case-sensitive, meaning the String("hello") is equal to the String("HELLO").
9	getBytes() Copies the string's characters to the supplied buffer.
10	indexOf() Locates a character or String within another String. By default, it searches from the beginning of the String, but can also start from a given index, allowing to locate all instances of the character or String.
11	lastIndexOf() Locates a character or String within another String. By default, it searches from the end of the String, but can also work backwards from a given index, allowing to locate all instances of the character or String.
12	length() Returns the length of the String, in characters. (Note that this does not include a trailing null character.)
13	remove() Modify in place, a string removing chars from the provided index to the end of the string or from the provided index to index plus count.
14	replace() The String replace() function allows you to replace all instances of a given character with another character. You can also use replace to replace substrings of a string with a different substring.
15	reserve() The String reserve() function allows you to allocate a buffer in memory for manipulating strings.
16	setCharAt() Sets a character of the String. Has no effect on indices outside the existing length of the String.
17	startsWith() Tests whether or not a String starts with the characters of another String.
18	toCharArray() Copies the string's characters to the supplied buffer.
19	substring() Get a substring of a String. The starting index is inclusive (the corresponding character is included in the substring), but the optional ending index is exclusive (the corresponding character is not included in the substring). If the ending index is omitted, the substring continues to the end of the String.
20	toInt() Converts a valid String to an integer. The input string should start with an integer number. If the string contains non-integer numbers, the function will stop performing the conversion.
21	toFloat() Converts a valid String to a float. The input string should start with a digit. If the string contains non-digit characters, the function will stop performing the conversion. For example, the strings "123.45", "123", and "123fish" are converted to 123.45, 123.00, and 123.00 respectively. Note that "123.456" is approximated with 123.46. Note too that floats have only 6-7 decimal digits of precision and that longer strings might be truncated.
22	toLowerCase() Get a lower-case version of a String. As of 1.0, toLowerCase() modifies the string in place rather than returning a new.
23	toUpperCase() Get an upper-case version of a String. As of 1.0, toUpperCase() modifies the string in place rather than returning a new one.
24	trim() Get a version of the String with any leading and trailing whitespace removed. As of 1.0, trim() modifies the string in place rather than returning a new one.

Il prossimo schizzo utilizza alcune funzioni di stringa C.

Esempio

void setup() {
   char str[] = "This is my string"; // create a string
   char out_str[40]; // output from string functions placed here
   int num; // general purpose integer
   Serial.begin(9600);

   // (1) print the string
   Serial.println(str);

   // (2) get the length of the string (excludes null terminator)
   num = strlen(str);
   Serial.print("String length is: ");
   Serial.println(num);

   // (3) get the length of the array (includes null terminator)
   num = sizeof(str); // sizeof() is not a C string function
   Serial.print("Size of the array: ");
   Serial.println(num);

   // (4) copy a string
   strcpy(out_str, str);
   Serial.println(out_str);

   // (5) add a string to the end of a string (append)
   strcat(out_str, " sketch.");
   Serial.println(out_str);
   num = strlen(out_str);
   Serial.print("String length is: ");
   Serial.println(num);
   num = sizeof(out_str);
   Serial.print("Size of the array out_str[]: ");
   Serial.println(num);
}

void loop() {

}

Risultato

This is my string
String length is: 17
Size of the array: 18
This is my string
This is my string sketch.
String length is: 25
Size of the array out_str[]: 40

Lo schizzo funziona nel modo seguente.

Stampa la stringa

La stringa appena creata viene stampata nella finestra Serial Monitor come fatto negli schizzi precedenti.

Ottieni la lunghezza della stringa

La funzione strlen () viene utilizzata per ottenere la lunghezza della stringa. La lunghezza della stringa è solo per i caratteri stampabili e non include il terminatore null.

La stringa contiene 17 caratteri, quindi ne vediamo 17 stampati nella finestra Serial Monitor.

Ottieni la lunghezza dell'array

L'operatore sizeof () viene utilizzato per ottenere la lunghezza dell'array che contiene la stringa. La lunghezza include il terminatore nullo, quindi la lunghezza è uno in più rispetto alla lunghezza della stringa.

sizeof () sembra una funzione, ma tecnicamente è un operatore. Non fa parte della libreria di stringhe C, ma è stato utilizzato nello schizzo per mostrare la differenza tra la dimensione dell'array e la dimensione della stringa (o lunghezza della stringa).

Copia una stringa

La funzione strcpy () viene utilizzata per copiare la stringa str [] nell'array out_num []. La funzione strcpy () copia la seconda stringa che le è stata passata nella prima stringa. Una copia della stringa ora esiste nell'array out_num [], ma occupa solo 18 elementi dell'array, quindi abbiamo ancora 22 elementi char liberi nell'array. Questi elementi liberi si trovano dopo la stringa in memoria.

La stringa è stata copiata nell'array in modo da avere dello spazio extra nell'array da utilizzare nella parte successiva dello schizzo, che consiste nell'aggiungere una stringa alla fine di una stringa.

Aggiungi una stringa a una stringa (concatenare)

Lo schizzo unisce una stringa a un'altra, nota come concatenazione. Questo viene fatto usando la funzione strcat (). La funzione strcat () mette la seconda stringa passatale alla fine della prima stringa passatale.

Dopo la concatenazione, la lunghezza della stringa viene stampata per mostrare la nuova lunghezza della stringa. La lunghezza dell'array viene quindi stampata per mostrare che abbiamo una stringa di 25 caratteri in un array di 40 elementi.

Ricorda che la stringa lunga 25 caratteri occupa effettivamente 26 caratteri dell'array a causa dello zero che termina con zero.

Array Bounds

Quando si lavora con stringhe e array, è molto importante lavorare entro i limiti di stringhe o array. Nello schizzo di esempio, è stato creato un array, lungo 40 caratteri, per allocare la memoria che potrebbe essere utilizzata per manipolare le stringhe.

Se l'array è stato reso troppo piccolo e abbiamo provato a copiare una stringa più grande dell'array, la stringa verrebbe copiata alla fine dell'array. La memoria oltre la fine dell'array potrebbe contenere altri dati importanti usati nello sketch, che verrebbero poi sovrascritti dalla nostra stringa. Se la memoria oltre la fine della stringa viene sovraccaricata, lo sketch potrebbe bloccarsi o causare un comportamento imprevisto.

Il secondo tipo di stringa utilizzato nella programmazione di Arduino è l'oggetto String.

Cos'è un oggetto?

Un oggetto è un costrutto che contiene sia dati che funzioni. Un oggetto String può essere creato proprio come una variabile e assegnato un valore o una stringa. L'oggetto String contiene funzioni (chiamate "metodi" nella programmazione orientata agli oggetti (OOP)) che operano sui dati stringa contenuti nell'oggetto String.

Lo schizzo e la spiegazione seguenti chiariranno cos'è un oggetto e come viene utilizzato l'oggetto String.

Esempio

void setup() { 
   String my_str = "This is my string.";
   Serial.begin(9600);

   // (1) print the string
   Serial.println(my_str);

   // (2) change the string to upper-case
   my_str.toUpperCase();
   Serial.println(my_str);

   // (3) overwrite the string
   my_str = "My new string.";
   Serial.println(my_str);

   // (4) replace a word in the string
   my_str.replace("string", "Arduino sketch");
   Serial.println(my_str);

   // (5) get the length of the string
   Serial.print("String length is: ");
   Serial.println(my_str.length());
}

void loop() { 

}

Risultato

This is my string.
THIS IS MY STRING.
My new string.
My new Arduino sketch.
String length is: 22

Viene creato un oggetto stringa e viene assegnato un valore (o stringa) nella parte superiore dello schizzo.

String my_str = "This is my string." ;

Questo crea un oggetto String con il nome my_str e gli dà un valore di "Questa è la mia stringa.".

Questo può essere paragonato alla creazione di una variabile e all'assegnazione di un valore come un numero intero -

int my_var = 102;

Lo schizzo funziona nel modo seguente.

Stampa della stringa

La stringa può essere stampata nella finestra Serial Monitor proprio come una stringa di matrice di caratteri.

Converti la stringa in lettere maiuscole

L'oggetto stringa my_str che è stato creato ha un numero di funzioni o metodi che possono essere utilizzati su di esso. Questi metodi vengono richiamati utilizzando il nome degli oggetti seguito dall'operatore punto (.) E quindi il nome della funzione da utilizzare.

my_str.toUpperCase();

Il toUpperCase() la funzione opera sulla stringa contenuta nel file my_stroggetto che è di tipo String e converte i dati stringa (o testo) contenuti nell'oggetto in caratteri maiuscoli. Un elenco delle funzioni contenute nella classe String può essere trovato nel riferimento Arduino String. Tecnicamente, String è chiamata classe e viene utilizzata per creare oggetti String.

Sovrascrivi una stringa

L'operatore di assegnazione viene utilizzato per assegnare una nuova stringa al file my_str oggetto che sostituisce la vecchia stringa

my_str = "My new string." ;

L'operatore di assegnazione non può essere utilizzato su stringhe di array di caratteri, ma funziona solo su oggetti String.

Sostituzione di una parola nella stringa

La funzione replace () viene utilizzata per sostituire la prima stringa passatagli dalla seconda stringa passatale. replace () è un'altra funzione incorporata nella classe String e quindi è disponibile per l'uso sull'oggetto String my_str.

Ottenere la lunghezza della stringa

Ottenere la lunghezza della stringa è facile usando length (). Nello schizzo di esempio, il risultato restituito da length () viene passato direttamente a Serial.println () senza utilizzare una variabile intermedia.

Quando utilizzare un oggetto stringa

Un oggetto String è molto più facile da usare rispetto a un array di caratteri stringa. L'oggetto dispone di funzioni incorporate che possono eseguire una serie di operazioni sulle stringhe.

Lo svantaggio principale dell'utilizzo dell'oggetto String è che utilizza molta memoria e può utilizzare rapidamente la memoria RAM di Arduino, il che potrebbe causare il blocco, il crash o il comportamento imprevisto di Arduino. Se uno schizzo su un Arduino è piccolo e limita l'uso di oggetti, non dovrebbero esserci problemi.

Le stringhe di array di caratteri sono più difficili da usare e potrebbe essere necessario scrivere le proprie funzioni per operare su questi tipi di stringhe. Il vantaggio è che hai il controllo sulla dimensione degli array di stringhe che crei, quindi puoi mantenere gli array piccoli per risparmiare memoria.

È necessario assicurarsi di non scrivere oltre la fine dei limiti dell'array con array di stringhe. L'oggetto String non ha questo problema e si prenderà cura dei limiti delle stringhe per te, a condizione che ci sia abbastanza memoria su cui operare. L'oggetto String può provare a scrivere in una memoria che non esiste quando esaurisce la memoria, ma non scriverà mai oltre la fine della stringa su cui sta operando.

Dove vengono usate le stringhe

In questo capitolo abbiamo studiato le stringhe, come si comportano in memoria e le loro operazioni.

Gli usi pratici delle stringhe saranno trattati nella parte successiva di questo corso quando studieremo come ottenere l'input dell'utente dalla finestra Serial Monitor e salvare l'input in una stringa.

Arduino fornisce quattro diverse funzioni di manipolazione del tempo. Sono -

S.No.	Descrizione della funzione
1	funzione delay () Il modo in cui il delay()la funzione funziona è piuttosto semplice. Accetta un singolo argomento intero (o numero). Questo numero rappresenta il tempo (misurato in millisecondi).
2	funzione delayMicroseconds () Il delayMicroseconds()la funzione accetta un singolo argomento intero (o numero). Ci sono mille microsecondi in un millisecondo e un milione di microsecondi in un secondo.
3	funzione millis () Questa funzione viene utilizzata per restituire il numero di millisecondi nel momento in cui la scheda Arduino inizia a eseguire il programma corrente.
4	funzione micros () La funzione micros () restituisce il numero di microsecondi dal momento in cui la scheda Arduino inizia a eseguire il programma corrente. Questo numero va in overflow, cioè torna a zero dopo circa 70 minuti.

Un array è un gruppo consecutivo di posizioni di memoria dello stesso tipo. Per fare riferimento a una posizione o un elemento particolare nell'array, specifichiamo il nome dell'array e il numero di posizione del particolare elemento nell'array.

L'illustrazione riportata di seguito mostra un array di numeri interi chiamato C che contiene 11 elementi. Si fa riferimento a uno qualsiasi di questi elementi fornendo il nome dell'array seguito dal numero di posizione dell'elemento particolare tra parentesi quadre ([]). Il numero di posizione è più formalmente chiamato pedice o indice (questo numero specifica il numero di elementi dall'inizio della matrice). Il primo elemento ha pedice 0 (zero) ed è talvolta chiamato elemento zeri.

Pertanto, gli elementi dell'array C sono C [0] (pronunciato "C sotto zero"), C [1], C [2] e così via. Il pedice più alto nell'array C è 10, che è 1 in meno del numero di elementi nell'array (11). I nomi degli array seguono le stesse convenzioni degli altri nomi di variabili.

Un pedice deve essere un'espressione intera o intera (utilizzando qualsiasi tipo integrale). Se un programma utilizza un'espressione come pedice, il programma valuta l'espressione per determinare il pedice. Ad esempio, se assumiamo che la variabile a sia uguale a 5 e che la variabile b sia uguale a 6, l'istruzione aggiunge 2 all'elemento dell'array C [11].

Il nome di un array con indice è un lvalue, può essere usato sul lato sinistro di un assegnamento, proprio come possono fare i nomi di variabili non array.

Esaminiamo l'array C nella figura data, più da vicino. Il nome dell'intero array è C. I suoi 11 elementi sono indicati come da C [0] a C [10]. Il valore di C [0] è -45, il valore di C [1] è 6, il valore di C [2] è 0, il valore di C [7] è 62 e il valore di C [10] è 78.

Per stampare la somma dei valori contenuti nei primi tre elementi dell'array C, scriveremmo -

Serial.print (C[ 0 ] + C[ 1 ] + C[ 2 ] );

Per dividere il valore di C [6] per 2 e assegnare il risultato alla variabile x, scriveremmo -

x = C[ 6 ] / 2;

Dichiarazione di array

Gli array occupano spazio in memoria. Per specificare il tipo di elementi e il numero di elementi richiesti da un array, utilizzare una dichiarazione del modulo -

type arrayName [ arraySize ] ;

Il compilatore riserva la quantità di memoria appropriata. (Ricorda che una dichiarazione, che riserva la memoria, è più propriamente nota come definizione). ArraySize deve essere una costante intera maggiore di zero. Ad esempio, per dire al compilatore di riservare 11 elementi per l'array intero C, utilizzare la dichiarazione -

int C[ 12 ]; // C is an array of 12 integers

Gli array possono essere dichiarati per contenere valori di qualsiasi tipo di dati non di riferimento. Ad esempio, un array di tipo stringa può essere utilizzato per memorizzare stringhe di caratteri.

Esempi di utilizzo di array

Questa sezione fornisce molti esempi che dimostrano come dichiarare, inizializzare e manipolare gli array.

Esempio 1: dichiarazione di un array e utilizzo di un ciclo per inizializzare gli elementi dell'array

Il programma dichiara un array intero di 10 elementi n. Le righe a – b usano aForistruzione per inizializzare gli elementi dell'array su zeri. Come altre variabili automatiche, gli array automatici non vengono inizializzati implicitamente a zero. La prima istruzione di output (riga c) mostra le intestazioni di colonna per le colonne stampate nella successiva istruzione for (righe d – e), che stampa l'array in formato tabulare.

Example

int n[ 10 ] ; // n is an array of 10 integers

void setup () {

}

void loop () {
   for ( int i = 0; i < 10; ++i ) // initialize elements of array n to 0 {
      n[ i ] = 0; // set element at location i to 0
      Serial.print (i) ;
      Serial.print (‘\r’) ;
   }
   for ( int j = 0; j < 10; ++j ) // output each array element's value {
      Serial.print (n[j]) ;
      Serial.print (‘\r’) ;
   } 
}

Result - Produrrà il seguente risultato -

 
       

        
 
         
Element
 
         
Value
 
        
 
        
 
         
 
0
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
 
         
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
 
        
 
       
      

Esempio 2: inizializzazione di un array in una dichiarazione con un elenco di inizializzatori

Gli elementi di un array possono anche essere inizializzati nella dichiarazione dell'array seguendo il nome dell'array con un segno di uguale a e un elenco di inizializzatori delimitato da virgole delimitato da parentesi graffe. Il programma utilizza un elenco di inizializzatori per inizializzare un array intero con 10 valori (riga a) e stampa l'array in formato tabulare (righe b – c).

Example

// n is an array of 10 integers
int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 } ;

void setup () {

}

void loop () {
   for ( int i = 0; i < 10; ++i ) {
      Serial.print (i) ;
      Serial.print (‘\r’) ;
   }
   for ( int j = 0; j < 10; ++j ) // output each array element's value {
      Serial.print (n[j]) ;
      Serial.print (‘\r’) ;
   } 
}

Result - Produrrà il seguente risultato -

 
       

        
 
         
Element
 
         
Value
 
        
 
        
 
         
 
0
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
 
         
 
32
 
27
 
64
 
18
 
95
 
14
 
90
 
70
 
60
 
37
 
 
        
 
       
      

Esempio 3: somma degli elementi di un array

Spesso, gli elementi di un array rappresentano una serie di valori da utilizzare in un calcolo. Ad esempio, se gli elementi di una matrice rappresentano i voti di un esame, un professore potrebbe voler calcolare il totale degli elementi della matrice e utilizzare tale somma per calcolare la media della classe per l'esame. Il programma somma i valori contenuti nell'array di numeri interi a 10 elementia.

Example

const int arraySize = 10; // constant variable indicating size of array
int a[ arraySize ] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
int total = 0;

void setup () {

}
void loop () {
   // sum contents of array a
   for ( int i = 0; i < arraySize; ++i )
      total += a[ i ];
   Serial.print (“Total of array elements : ”) ;
   Serial.print(total) ;
}

Result - Produrrà il seguente risultato -

Total of array elements: 849

Gli array sono importanti per Arduino e dovrebbero richiedere molta più attenzione. I seguenti importanti concetti relativi all'array dovrebbero essere chiari a un Arduino:

S.NO.	Concetto e descrizione
1	Passaggio di matrici a funzioni Per passare un argomento di matrice a una funzione, specificare il nome della matrice senza parentesi.
2	Array multidimensionali Le matrici con due dimensioni (ossia, pedici) spesso rappresentano tabelle di valori costituite da informazioni disposte in righe e colonne.

I pin sulla scheda Arduino possono essere configurati come ingressi o uscite. Spiegheremo il funzionamento dei pin in quelle modalità. È importante notare che la maggior parte dei pin analogici Arduino può essere configurata e utilizzata esattamente allo stesso modo dei pin digitali.

Pin configurati come INPUT

I pin Arduino sono configurati di default come input, quindi non è necessario dichiararli esplicitamente come input con pinMode()quando li usi come input. Si dice che i pin configurati in questo modo siano in uno stato di alta impedenza. I pin di ingresso richiedono al circuito che stanno campionando richieste estremamente ridotte, equivalenti a un resistore in serie di 100 megaohm davanti al pin.

Ciò significa che ci vuole pochissima corrente per cambiare il pin di ingresso da uno stato all'altro. Ciò rende i pin utili per attività come l'implementazione di un sensore tattile capacitivo o la lettura di un LED come un fotodiodo.

I pin configurati come pinMode (pin, INPUT) a cui non è collegato nulla, o con fili ad essi collegati che non sono collegati ad altri circuiti, segnalano cambiamenti apparentemente casuali nello stato del pin, captano rumore elettrico dall'ambiente o accoppiano capacitivamente lo stato di un pin vicino.

Resistori di pull-up

I resistori di pull-up sono spesso utili per portare un pin di ingresso a uno stato noto se non è presente alcun ingresso. Questo può essere fatto aggiungendo un resistore pull-up (a + 5V) o un resistore pull-down (resistore a terra) sull'ingresso. Un resistore da 10K è un buon valore per un resistore pull-up o pull-down.

Utilizzo del resistore pull-up integrato con pin configurati come ingresso

Ci sono 20.000 resistori di pull-up integrati nel chip Atmega a cui è possibile accedere dal software. Si accede a questi resistori di pull-up integrati impostando ilpinMode()come INPUT_PULLUP. Questo effettivamente inverte il comportamento della modalità INPUT, dove HIGH significa che il sensore è OFF e LOW significa che il sensore è ON. Il valore di questo pull-up dipende dal microcontrollore utilizzato. Sulla maggior parte delle schede basate su AVR, il valore è garantito tra 20kΩ e 50kΩ. Su Arduino Due, è compreso tra 50kΩ e 150kΩ. Per il valore esatto, consultare la scheda tecnica del microcontrollore sulla scheda.

Quando si collega un sensore a un pin configurato con INPUT_PULLUP, l'altra estremità deve essere collegata a terra. In caso di un interruttore semplice, questo fa sì che il pin legga HIGH quando l'interruttore è aperto e LOW quando viene premuto l'interruttore. Le resistenze pull-up forniscono corrente sufficiente per illuminare un LED debolmente collegato a un pin configurato come ingresso. Se i LED in un progetto sembrano funzionare, ma in modo molto debole, è probabile che questo sia ciò che sta accadendo.

Gli stessi registri (posizioni di memoria del chip interno) che controllano se un pin è ALTO o BASSO controllano le resistenze di pull-up. Di conseguenza, un pin configurato per avere resistori pull-up attivati ​​quando il pin è in modalità INPUT, avrà il pin configurato come HIGH se il pin viene quindi commutato in una modalità OUTPUT con pinMode (). Funziona anche nell'altra direzione, e un pin di uscita lasciato in uno stato HIGH avrà la resistenza di pull-up impostata se commutato su un ingresso con pinMode ().

Example

pinMode(3,INPUT) ; // set pin to input without using built in pull up resistor
pinMode(5,INPUT_PULLUP) ; // set pin to input using built in pull up resistor

Pin configurati come OUTPUT

Si dice che i pin configurati come OUTPUT con pinMode () siano in uno stato di bassa impedenza. Ciò significa che possono fornire una notevole quantità di corrente ad altri circuiti. I pin Atmega possono generare (fornire corrente positiva) o assorbire (fornire corrente negativa) fino a 40 mA (milliampere) di corrente ad altri dispositivi / circuiti. Questa è una corrente sufficiente per illuminare intensamente un LED (non dimenticare il resistore in serie), o per far funzionare molti sensori ma non abbastanza corrente per far funzionare relè, solenoidi o motori.

Il tentativo di far funzionare dispositivi ad alta corrente dai pin di uscita, può danneggiare o distruggere i transistor di uscita nel pin o danneggiare l'intero chip Atmega. Spesso, questo si traduce in un pin "morto" nel microcontrollore ma i chip rimanenti funzionano ancora adeguatamente. Per questo motivo, è una buona idea collegare i pin OUTPUT ad altri dispositivi tramite resistori da 470Ω o 1k, a meno che non sia richiesta la massima corrente assorbita dai pin per una particolare applicazione.

Funzione pinMode ()

La funzione pinMode () viene utilizzata per configurare un pin specifico in modo che si comporti sia come input che come output. È possibile abilitare le resistenze interne di pull-up con la modalità INPUT_PULLUP. Inoltre, la modalità INPUT disabilita esplicitamente i pull-up interni.

sintassi della funzione pinMode ()

Void setup () {
   pinMode (pin , mode);
}

• pin - il numero del pin di cui si desidera impostare la modalità

• mode - INPUT, OUTPUT o INPUT_PULLUP.

Example

int button = 5 ; // button connected to pin 5
int LED = 6; // LED connected to pin 6

void setup () {
   pinMode(button , INPUT_PULLUP); 
   // set the digital pin as input with pull-up resistor
   pinMode(button , OUTPUT); // set the digital pin as output
}

void setup () {
   If (digitalRead(button ) == LOW) // if button pressed {
      digitalWrite(LED,HIGH); // turn on led
      delay(500); // delay for 500 ms
      digitalWrite(LED,LOW); // turn off led
      delay(500); // delay for 500 ms
   }
}

Funzione digitalWrite ()

Il digitalWrite()viene utilizzata per scrivere un valore HIGH o LOW su un pin digitale. Se il pin è stato configurato come OUTPUT con pinMode () , la sua tensione sarà impostata al valore corrispondente: 5V (o 3.3V su schede 3.3V) per HIGH, 0V (ground) per LOW. Se il pin è configurato come INPUT, digitalWrite () abiliterà (HIGH) o disabiliterà (LOW) il pullup interno sul pin di ingresso. Si consiglia di impostare pinMode () su INPUT_PULLUP per abilitare la resistenza di pull-up interna.

Se non si imposta pinMode () su OUTPUT e si collega un LED a un pin, quando si chiama digitalWrite (HIGH), il LED potrebbe apparire scuro. Senza impostare esplicitamente pinMode (), digitalWrite () avrà abilitato il resistore di pull-up interno, che si comporta come un grande resistore di limitazione della corrente.

Sintassi della funzione digitalWrite ()

Void loop() {
   digitalWrite (pin ,value);
}

• pin - il numero del pin di cui si desidera impostare la modalità

• value - ALTO o BASSO.

Example

int LED = 6; // LED connected to pin 6

void setup () {
   pinMode(LED, OUTPUT); // set the digital pin as output
}

void setup () { 
   digitalWrite(LED,HIGH); // turn on led
   delay(500); // delay for 500 ms
   digitalWrite(LED,LOW); // turn off led
   delay(500); // delay for 500 ms
}

funzione analogRead ()

Arduino è in grado di rilevare se c'è una tensione applicata a uno dei suoi pin e segnalarlo tramite la funzione digitalRead (). C'è una differenza tra un sensore on / off (che rileva la presenza di un oggetto) e un sensore analogico, il cui valore cambia continuamente. Per leggere questo tipo di sensore, abbiamo bisogno di un diverso tipo di pin.

Nella parte in basso a destra della scheda Arduino, vedrai sei pin contrassegnati come "Analog In". Questi pin speciali non solo dicono se c'è una tensione applicata a loro, ma anche il suo valore. Utilizzando ilanalogRead() funzione, possiamo leggere la tensione applicata a uno dei pin.

Questa funzione restituisce un numero compreso tra 0 e 1023, che rappresenta tensioni comprese tra 0 e 5 volt. Ad esempio, se è presente una tensione di 2,5 V applicata al pin numero 0, analogRead (0) restituisce 512.

Sintassi della funzione analogRead ()

analogRead(pin);

• pin - il numero del pin di ingresso analogico da cui leggere (da 0 a 5 sulla maggior parte delle schede, da 0 a 7 su Mini e Nano, da 0 a 15 su Mega)

Example

int analogPin = 3;//potentiometer wiper (middle terminal) 
   // connected to analog pin 3 
int val = 0; // variable to store the value read

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

void loop() {
   val = analogRead(analogPin); // read the input pin
   Serial.println(val); // debug value
}

In questo capitolo apprenderemo alcune funzioni avanzate di input e output.

Funzione analogReference ()

Configura la tensione di riferimento utilizzata per l'ingresso analogico (ovvero il valore utilizzato come il massimo dell'intervallo di ingresso). Le opzioni sono:

• DEFAULT - Il riferimento analogico predefinito di 5 volt (su schede Arduino 5V) o 3,3 volt (su schede Arduino 3,3V)

• INTERNAL - Un riferimento integrato, pari a 1,1 volt su ATmega168 o ATmega328 e 2,56 volt su ATmega8 (non disponibile su Arduino Mega)

• INTERNAL1V1 - Un riferimento 1.1V integrato (solo Arduino Mega)

• INTERNAL2V56 - Un riferimento 2,56 V integrato (solo Arduino Mega)

• EXTERNAL - La tensione applicata al pin AREF (solo da 0 a 5 V) viene utilizzata come riferimento

Sintassi della funzione analogReference ()

analogReference (type);

type - può utilizzare qualsiasi tipo di seguito (DEFAULT, INTERNAL, INTERNAL1V1, INTERNAL2V56, EXTERNAL)

Non utilizzare valori inferiori a 0 V o superiori a 5 V per la tensione di riferimento esterna sul pin AREF. Se si utilizza un riferimento esterno sul pin AREF, è necessario impostare il riferimento analogico su EXTERNAL prima di chiamare ilanalogRead()funzione. Altrimenti, cortocircuiterai la tensione di riferimento attiva (generata internamente) e il pin AREF, danneggiando probabilmente il microcontrollore sulla tua scheda Arduino.

In alternativa, è possibile collegare la tensione di riferimento esterna al pin AREF tramite un resistore 5K, consentendo di passare dalla tensione di riferimento esterna a quella interna.

Si noti che il resistore altererà la tensione utilizzata come riferimento perché è presente una resistenza interna da 32K sul pin AREF. I due fungono da partitore di tensione. Ad esempio, 2,5 V applicato attraverso il resistore produrrà 2,5 * 32 / (32 + 5) = ~ 2,2 V al pin AREF.

Example

int analogPin = 3;// potentiometer wiper (middle terminal) connected to analog pin 3 
int val = 0; // variable to store the read value

void setup() {
   Serial.begin(9600); // setup serial
   analogReference(EXTERNAL); // the voltage applied to the AREF pin (0 to 5V only) 
      // is used as the reference.
}

void loop() {
   val = analogRead(analogPin); // read the input pin
   Serial.println(val); // debug value
}

Tutti i dati vengono inseriti nei computer come caratteri, che includono lettere, cifre e vari simboli speciali. In questa sezione, discuteremo le capacità di C ++ per esaminare e manipolare i singoli caratteri.

La libreria per la gestione dei caratteri include diverse funzioni che eseguono test utili e manipolazioni dei dati dei personaggi. Ogni funzione riceve un carattere, rappresentato come int o EOF come argomento. I caratteri vengono spesso manipolati come numeri interi.

Ricordare che EOF normalmente ha il valore –1 e che alcune architetture hardware non consentono la memorizzazione di valori negativi nelle variabili char. Pertanto, le funzioni di gestione dei caratteri manipolano i caratteri come numeri interi.

La tabella seguente riassume le funzioni della libreria per la gestione dei caratteri. Quando si utilizzano funzioni dalla libreria per la gestione dei caratteri, includere l'estensione<cctype> intestazione.

S.No.	Prototipo e descrizione
1	int isdigit( int c ) Restituisce 1 se c è una cifra e 0 in caso contrario.
2	int isalpha( int c ) Restituisce 1 se c è una lettera e 0 in caso contrario.
3	int isalnum( int c ) Restituisce 1 se c è una cifra o una lettera e 0 in caso contrario.
4	int isxdigit( int c ) Restituisce 1 se c è un carattere cifra esadecimale e 0 in caso contrario. (Vedere Appendice D, Sistemi numerici, per una spiegazione dettagliata dei numeri binari, ottali, decimali ed esadecimali.)
5	int islower( int c ) Restituisce 1 se c è una lettera minuscola e 0 in caso contrario.
6	int isupper( int c ) Restituisce 1 se c è una lettera maiuscola; 0 altrimenti.
7	int isspace( int c ) Restituisce 1 se c è uno spazio vuoto: nuova riga ('\ n'), spazio (''), avanzamento modulo ('\ f'), ritorno a capo ('\ r'), tabulazione orizzontale ('\ t') o tabulazione verticale ('\ v') - e 0 altrimenti.
8	int iscntrl( int c ) Restituisce 1 se c è un carattere di controllo, ad esempio nuova riga ('\ n'), avanzamento modulo ('\ f'), ritorno a capo ('\ r'), tabulazione orizzontale ('\ t'), tabulazione verticale (' \ v '), alert (' \ a ') o backspace (' \ b ') - e 0 altrimenti.
9	int ispunct( int c ) Restituisce 1 se c è un carattere di stampa diverso da uno spazio, una cifra o una lettera e 0 in caso contrario.
10	int isprint( int c ) Restituisce 1 se c è un carattere di stampa che include spazio ('') e 0 in caso contrario.
11	int isgraph( int c ) Restituisce 1 se c è un carattere di stampa diverso dallo spazio ('') e 0 in caso contrario.

Esempi

L'esempio seguente mostra l'uso delle funzioni isdigit, isalpha, isalnum e isxdigit. Funzioneisdigitdetermina se il suo argomento è una cifra (0-9). La funzioneisalphadetermina se il suo argomento è una lettera maiuscola (AZ) o una lettera minuscola (a – z). La funzioneisalnumdetermina se il suo argomento è una lettera maiuscola, minuscola o una cifra. Funzioneisxdigit determina se il suo argomento è una cifra esadecimale (A – F, a – f, 0–9).

Esempio 1

void setup () {
   Serial.begin (9600);
   Serial.print ("According to isdigit:\r");
   Serial.print (isdigit( '8' ) ? "8 is a": "8 is not a");
   Serial.print (" digit\r" );
   Serial.print (isdigit( '8' ) ?"# is a": "# is not a") ;
   Serial.print (" digit\r");
   Serial.print ("\rAccording to isalpha:\r" );
   Serial.print (isalpha('A' ) ?"A is a": "A is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A' ) ?"b is a": "b is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A') ?"& is a": "& is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha( 'A' ) ?"4 is a":"4 is not a");
   Serial.print (" letter\r");
   Serial.print ("\rAccording to isalnum:\r");
   Serial.print (isalnum( 'A' ) ?"A is a" : "A is not a" );

   Serial.print (" digit or a letter\r" );
   Serial.print (isalnum( '8' ) ?"8 is a" : "8 is not a" ) ;
   Serial.print (" digit or a letter\r");
   Serial.print (isalnum( '#' ) ?"# is a" : "# is not a" );
   Serial.print (" digit or a letter\r");
   Serial.print ("\rAccording to isxdigit:\r");
   Serial.print (isxdigit( 'F' ) ?"F is a" : "F is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'J' ) ?"J is a" : "J is not a" ) ;
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '7' ) ?"7 is a" : "7 is not a" ) ;

   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '$' ) ? "$ is a" : "$ is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'f' ) ? “f is a" : "f is not a");
   
}

void loop () {

}

Risultato

According to isdigit:
8 is a digit
# is not a digit
According to isalpha:
A is a letter
b is a letter
& is not a letter
4 is not a letter
According to isalnum:
A is a digit or a letter

8 is a digit or a letter
# is not a digit or a letter
According to isxdigit:
F is a hexadecimal digit
J is not a hexadecimal digit
7 is a hexadecimal digit

$ is not a hexadecimal digit
f is a hexadecimal digit

Usiamo l'operatore condizionale (?:)con ciascuna funzione per determinare se la stringa "è un" o la stringa "non è un" deve essere stampata nell'output per ogni carattere testato. Ad esempio, linea indica che se "8" è una cifra, ovvero se isdigitrestituisce un valore vero (diverso da zero): viene stampata la stringa "8 è un". Se "8" non è una cifra (cioè, seisdigit restituisce 0), viene stampata la stringa "8 non è un".

Esempio 2

L'esempio seguente mostra l'uso delle funzioni islower e isupper. La funzioneislowerdetermina se il suo argomento è una lettera minuscola (a – z). Funzioneisupper determina se il suo argomento è una lettera maiuscola (A – Z).

int thisChar = 0xA0;

void setup () {
   Serial.begin (9600);
   Serial.print ("According to islower:\r") ;
   Serial.print (islower( 'p' ) ? "p is a" : "p is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( 'P') ? "P is a" : "P is not a") ;
   Serial.print ("lowercase letter\r");
   Serial.print (islower( '5' ) ? "5 is a" : "5 is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( '!' )? "! is a" : "! is not a") ;
   Serial.print ("lowercase letter\r");

   Serial.print ("\rAccording to isupper:\r") ;
   Serial.print (isupper ( 'D' ) ? "D is a" : "D is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( isupper ( 'd' )? "d is a" : "d is not an") ;
   Serial.print ( " uppercase letter\r" );
   Serial.print (isupper ( '8' ) ? "8 is a" : "8 is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( islower( '$' )? "$ is a" : "$ is not an") ;
   Serial.print ("uppercase letter\r ");
}

void setup () {

}

Risultato

According to islower:
p is a lowercase letter
P is not a lowercase letter
5 is not a lowercase letter
! is not a lowercase letter

According to isupper:
D is an uppercase letter
d is not an uppercase letter
8 is not an uppercase letter
$ is not an uppercase letter

Esempio 3

L'esempio seguente mostra l'uso delle funzioni isspace, iscntrl, ispunct, isprint e isgraph.

• La funzione isspace determina se il suo argomento è uno spazio vuoto, come spazio (''), avanzamento modulo ('\ f'), nuova riga ('\ n'), ritorno a capo ('\ r'), tabulazione orizzontale ('\ t ') o tabulazione verticale (' \ v ').

• La funzione iscntrl determina se il suo argomento è un carattere di controllo come tabulazione orizzontale ('\ t'), tabulazione verticale ('\ v'), avanzamento modulo ('\ f'), avviso ('\ a'), backspace ('\ b '), ritorno a capo (' \ r ') o nuova riga (' \ n ').

• La funzione ispunct determina se il suo argomento è un carattere di stampa diverso da uno spazio, una cifra o una lettera, come $, #, (,), [,], {,},;,: o%.

• La funzione isprint determina se il suo argomento è un carattere che può essere visualizzato sullo schermo (incluso il carattere spazio).

• La funzione isgraph verifica gli stessi caratteri di isprint, ma il carattere spazio non è incluso.

void setup () {
   Serial.begin (9600);
   Serial.print ( " According to isspace:\rNewline ") ;
   Serial.print (isspace( '\n' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\rHorizontal tab") ;
   Serial.print (isspace( '\t' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\n") ;
   Serial.print (isspace('%')? " % is a" : " % is not a" );
   
   Serial.print ( " \rAccording to iscntrl:\rNewline") ;
   Serial.print ( iscntrl( '\n' )?"is a" : " is not a" ) ;
   Serial.print (" control character\r");
   Serial.print (iscntrl( '$' ) ? " $ is a" : " $ is not a" );
   Serial.print (" control character\r");
   Serial.print ("\rAccording to ispunct:\r");
   Serial.print (ispunct(';' ) ?"; is a" : "; is not a" ) ;
   Serial.print (" punctuation character\r");
   Serial.print (ispunct('Y' ) ?"Y is a" : "Y is not a" ) ;
   Serial.print ("punctuation character\r");
   Serial.print (ispunct('#' ) ?"# is a" : "# is not a" ) ;
   Serial.print ("punctuation character\r");

   Serial.print ( "\r According to isprint:\r");
   Serial.print (isprint('$' ) ?"$ is a" : "$ is not a" );
   Serial.print (" printing character\rAlert ");
   Serial.print (isprint('\a' ) ?" is a" : " is not a" );
   Serial.print (" printing character\rSpace ");
   Serial.print (isprint(' ' ) ?" is a" : " is not a" );
   Serial.print (" printing character\r");
   
   Serial.print ("\r According to isgraph:\r");
   Serial.print (isgraph ('Q' ) ?"Q is a" : "Q is not a" );
   Serial.print ("printing character other than a space\rSpace ");
   Serial.print (isgraph (' ') ?" is a" : " is not a" );
   Serial.print ("printing character other than a space ");
}

void loop () {

}

Risultato

According to isspace:
Newline is a whitespace character
Horizontal tab is a whitespace character
% is not a whitespace character
According to iscntrl:
Newline is a control character
$ is not a control character
According to ispunct:
; is a punctuation character
Y is not a punctuation character
# is a punctuation character
According to isprint:
$ is a printing character
Alert is not a printing character
Space is a printing character
According to isgraph:
Q is a printing character other than a space
Space is not a printing character other than a space

La libreria Arduino Math (math.h) include una serie di utili funzioni matematiche per la manipolazione dei numeri in virgola mobile.

Macro di libreria

Di seguito sono riportate le macro definite nell'intestazione math.h -

Di seguito è riportato l'elenco delle macro definite nell'intestazione math.h

Macro	Valore	Descrizione
ME	2.7182818284590452354	La costante e.
M_LOG2E	1.4426950408889634074 / * log_2 e * /	Il logaritmo della e in base 2
M_1_PI	0,31830988618379067154 / * 1 / pi * /	La costante 1 / pi
M_2_PI	0.63661977236758134308 / * 2 / pi * /	La costante 2 / pi
M_2_SQRTPI	1.12837916709551257390 / * 2 / sqrt (pi) * /	La costante 2 / sqrt (pi)
M_LN10	2.30258509299404568402 / * log_e 10 * /	Il logaritmo naturale del 10
M_LN2	0.69314718055994530942 / * log_e 2 * /	Il logaritmo naturale di 2
M_LOG10E	0.43429448190325182765 / * log_10 e * /	Il logaritmo della e in base 10
M_PI	3.14159265358979323846 / * pi * /	La costante pi greco
M_PI_2	3.3V1.57079632679489661923 / * pi / 2 * /	La costante pi / 2
M_PI_4	0.78539816339744830962 / * pi / 4 * /	La costante pi / 4
M_SQRT1_2	0.70710678118654752440 / * 1 / sqrt (2) * /	La costante 1 / sqrt (2)
M_SQRT2	1.41421356237309504880 / * sqrt (2) * /	La radice quadrata di 2
acosf	-	L'alias per la funzione acos ()
asinf	-	L'alias per la funzione asin ()
atan2f	-	L'alias per la funzione atan2 ()
cbrtf	-	L'alias per la funzione cbrt ()
ceilf	-	L'alias per la funzione ceil ()
copysignf	-	L'alias per la funzione copysign ()
coshf	-	L'alias per la funzione cosh ()
expf	-	L'alias per la funzione exp ()
fabsf	-	L'alias per la funzione fabs ()
fdimf	-	L'alias per la funzione fdim ()
floorf	-	L'alias per la funzione floor ()
fmaxf	-	L'alias per la funzione fmax ()
fminf	-	L'alias per la funzione fmin ()
fmodf	-	L'alias per la funzione fmod ()
frexpf	-	L'alias per la funzione frexp ()
ipotf	-	L'alias per la funzione hypot ()
INFINITO	-	Costante INFINITY
isfinitef	-	L'alias per la funzione isfinite ()
isinff	-	L'alias per la funzione isinf ()
isnanf	-	L'alias per la funzione isnan ()
ldexpf	-	L'alias per la funzione ldexp ()
log10f	-	L'alias per la funzione log10 ()
logf	-	L'alias per la funzione log ()
lrintf	-	L'alias per la funzione lrint ()
lroundf	-	L'alias per la funzione lround ()

Funzioni di libreria

Le seguenti funzioni sono definite nell'intestazione math.h -

Di seguito è riportato l'elenco delle funzioni definite nell'intestazione math.h

S.No.	Funzione e descrizione della libreria
1	double acos (double __x) La funzione acos () calcola il valore principale dell'arcocoseno di __x. Il valore restituito è compreso nell'intervallo [0, pi] radianti. Si verifica un errore di dominio per argomenti non compresi nell'intervallo [-1, +1].
2	double asin (double __x) La funzione asin () calcola il valore principale dell'arco seno di __x. Il valore restituito è compreso nell'intervallo [-pi / 2, pi / 2] radianti. Si verifica un errore di dominio per argomenti non compresi nell'intervallo [-1, +1].
3	double atan (double __x) La funzione atan () calcola il valore principale dell'arco tangente di __x. Il valore restituito è compreso nell'intervallo [-pi / 2, pi / 2] radianti.
4	double atan2 (double __y, double __x) La funzione atan2 () calcola il valore principale dell'arco tangente di __y / __x, utilizzando i segni di entrambi gli argomenti per determinare il quadrante del valore restituito. Il valore restituito è compreso nell'intervallo [-pi, + pi] radianti.
5	double cbrt (double __x) La funzione cbrt () restituisce la radice cubica di __x.
6	double ceil (double __x) La funzione ceil () restituisce il valore integrale più piccolo maggiore o uguale a __x, espresso come numero a virgola mobile.
7	static double copysign (double __x, double __y) La funzione copysign () restituisce __x ma con il segno __y. Funzionano anche se __x o __y sono NaN o zero.
8	double cos(double __x) La funzione cos () restituisce il coseno di __x, misurato in radianti.
9	double cosh (double __x) La funzione cosh () restituisce il coseno iperbolico di __x.
10	double exp (double __x) La funzione exp () restituisce il valore esponenziale di __x.
11	double fabs (double __x) La funzione fabs () calcola il valore assoluto di un numero a virgola mobile __x.
12	double fdim (double __x, double __y) La funzione fdim () restituisce max (__ x - __y, 0). Se __x o __y o entrambi sono NaN, viene restituito NaN.
13	double floor (double __x) La funzione floor () restituisce il valore integrale più grande minore o uguale a __x, espresso come numero in virgola mobile.
14	double fma (double __x, double __y, double __z) La funzione fma () esegue la moltiplicazione-addizione in virgola mobile. Questa è l'operazione (__x * __y) + __z, ma il risultato intermedio non viene arrotondato al tipo di destinazione. Questo a volte può migliorare la precisione di un calcolo.
15	double fmax (double __x, double __y) La funzione fmax () restituisce il maggiore dei due valori __x e __y. Se un argomento è NaN, viene restituito l'altro argomento. Se entrambi gli argomenti sono NaN, viene restituito NaN.
16	double fmin (double __x, double __y) La funzione fmin () restituisce il minore dei due valori __x e __y. Se un argomento è NaN, viene restituito l'altro argomento. Se entrambi gli argomenti sono NaN, viene restituito NaN.
17	double fmod (double __x, double__y) La funzione fmod () restituisce il resto in virgola mobile di __x / __y.
18	double frexp (double __x, int * __pexp) La funzione frexp () spezza un numero in virgola mobile in una frazione normalizzata e una potenza integrale di 2. Memorizza il numero intero nell'oggetto int puntato da __pexp. Se __x è un normale numero in virgola mobile, la funzione frexp () restituisce il valore v, in modo tale che v abbia una grandezza nell'intervallo [1/2, 1) o zero, e __x è uguale a v volte 2 elevato alla potenza __pexp. Se __x è zero, entrambe le parti del risultato sono zero. Se __x non è un numero finito, frexp () restituisce __x così com'è e memorizza 0 per __pexp. Note - Questa implementazione consente un puntatore zero come direttiva per saltare la memorizzazione dell'esponente.
19	double hypot (double __x, double__y) La funzione hypot () restituisce sqrt (__ x * __ x + __y * __ y). Questa è la lunghezza dell'ipotenusa di un triangolo rettangolo con lati di lunghezza __x e __y, o la distanza del punto (__x, __y) dall'origine. Usare questa funzione al posto della formula diretta è saggio, poiché l'errore è molto più piccolo. Nessun underflow con __x e __y piccoli. Nessun overflow se il risultato è compreso nell'intervallo.
20	static int isfinite (double __x) La funzione isfinite () restituisce un valore diverso da zero se __x è finito: non più o meno infinito e non NaN.
21	int isinf (double __x) La funzione isinf () restituisce 1 se l'argomento __x è infinito positivo, -1 se __x è infinito negativo e 0 altrimenti. Note - GCC 4.3 può sostituire questa funzione con codice inline che restituisce il valore 1 per entrambi gli infiniti (gcc bug # 35509).
22	int isnan (double __x) La funzione isnan () restituisce 1 se l'argomento __x rappresenta un "non-numero" (NaN) oggetto, altrimenti 0.
23	double ldexp (double __x, int __exp ) La funzione ldexp () moltiplica un numero in virgola mobile per una potenza integrale di 2. Restituisce il valore di __x per 2 elevato alla potenza __exp.
24	double log (double __x) La funzione log () restituisce il logaritmo naturale dell'argomento __x.
25	double log10(double __x) La funzione log10 () restituisce il logaritmo dell'argomento __x in base 10.
26	long lrint (double __x) La funzione lrint () arrotonda __x all'intero più vicino, arrotondando i casi a metà alla direzione dell'intero pari. (Questo significa che i valori 1,5 e 2,5 vengono arrotondati a 2). Questa funzione è simile alla funzione rint (), ma differisce nel tipo di valore restituito e in quanto è possibile un overflow. Returns Il valore intero lungo arrotondato. Se __x non è un numero finito o un overflow, questa realizzazione restituisce il valore LONG_MIN (0x80000000).
27	long lround (double __x) La funzione lround () arrotonda __x all'intero più vicino, ma arrotonda i casi a metà allontanandosi da zero (invece che all'intero pari più vicino). Questa funzione è simile alla funzione round (), ma differisce nel tipo di valore restituito e in quanto è possibile un overflow. Returns Il valore intero lungo arrotondato. Se __x non è un numero finito o lo era un overflow, questa realizzazione restituisce il valore LONG_MIN (0x80000000).
28	double modf (double __x, double * __iptr ) La funzione modf () spezza l'argomento __x in parti integrali e frazionarie, ciascuna delle quali ha lo stesso segno dell'argomento. Memorizza la parte integrale come double nell'oggetto puntato da __iptr. La funzione modf () restituisce la parte frazionaria con segno di __x. Note- Questa implementazione salta la scrittura con puntatore zero. Tuttavia, GCC 4.3 può sostituire questa funzione con codice inline che non consente di utilizzare l'indirizzo NULL per evitare la memorizzazione.
29	float modff (float __x, float * __iptr) L'alias di modf ().
30	double pow (double __x, double __y) La funzione pow () restituisce il valore di __x all'esponente __y.
31	double round (double __x) La funzione round () arrotonda __x all'intero più vicino, ma arrotonda i casi a metà distanza da zero (invece che all'intero pari più vicino). L'overflow è impossibile. Returns Il valore arrotondato. Se __x è un integrale o infinito, viene restituito __x stesso. Se __x èNaN, poi NaN viene restituito.
32	int signbit (double __x) La funzione signbit () restituisce un valore diverso da zero se il valore di __x ha il bit di segno impostato. Non è la stessa cosa di `__x <0.0 ', perché la virgola mobile IEEE 754 consente il segno dello zero. Il confronto "-0.0 <0.0" è falso, ma "signbit (-0.0)" restituirà un valore diverso da zero.
33	double sin (double __x) La funzione sin () restituisce il seno di __x, misurato in radianti.
34	double sinh (double __x) La funzione sinh () restituisce il seno iperbolico di __x.
35	double sqrt (double __x) La funzione sqrt () restituisce la radice quadrata non negativa di __x.
36	double square (double __x) La funzione square () restituisce __x * __x. Note - Questa funzione non appartiene alla definizione dello standard C.
37	double tan (double __x) La funzione tan () restituisce la tangente di __x, misurata in radianti.
38	double tanh ( double __x) La funzione tanh () restituisce la tangente iperbolica di __x.
39	double trunc (double __x) La funzione trunc () arrotonda __x al numero intero più vicino non maggiore in valore assoluto.

Esempio

L'esempio seguente mostra come utilizzare le funzioni di libreria math.h più comuni:

double double__x = 45.45 ;
double double__y = 30.20 ;

void setup() {
   Serial.begin(9600);
   Serial.print("cos num = ");
   Serial.println (cos (double__x) ); // returns cosine of x
   Serial.print("absolute value of num = ");
   Serial.println (fabs (double__x) ); // absolute value of a float
   Serial.print("floating point modulo = ");
   Serial.println (fmod (double__x, double__y)); // floating point modulo
   Serial.print("sine of num = ");
   Serial.println (sin (double__x) ) ;// returns sine of x
   Serial.print("square root of num : ");
   Serial.println ( sqrt (double__x) );// returns square root of x
   Serial.print("tangent of num : ");
   Serial.println ( tan (double__x) ); // returns tangent of x
   Serial.print("exponential value of num : ");
   Serial.println ( exp (double__x) ); // function returns the exponential value of x.
   Serial.print("cos num : ");

   Serial.println (atan (double__x) ); // arc tangent of x
   Serial.print("tangent of num : ");
   Serial.println (atan2 (double__y, double__x) );// arc tangent of y/x
   Serial.print("arc tangent of num : ");
   Serial.println (log (double__x) ) ; // natural logarithm of x
   Serial.print("cos num : ");
   Serial.println ( log10 (double__x)); // logarithm of x to base 10.
   Serial.print("logarithm of num to base 10 : ");
   Serial.println (pow (double__x, double__y) );// x to power of y
   Serial.print("power of num : ");
   Serial.println (square (double__x)); // square of x
}

void loop() {

}

Risultato

cos num = 0.10
absolute value of num = 45.45
floating point modulo =15.25
sine of num = 0.99
square root of num : 6.74
tangent of num : 9.67
exponential value of num : ovf
cos num : 1.55
tangent of num : 0.59
arc tangent of num : 3.82
cos num : 1.66
logarithm of num to base 10 : inf
power of num : 2065.70

È necessario utilizzare la trigonometria praticamente come calcolare la distanza per l'oggetto in movimento o la velocità angolare. Arduino fornisce le tradizionali funzioni trigonometriche (sin, cos, tan, asin, acos, atan) che possono essere riassunte scrivendo i loro prototipi. Math.h contiene il prototipo della funzione trigonometrica.

Sintassi trigonometrica esatta

double sin(double x); //returns sine of x radians
double cos(double y); //returns cosine of y radians
double tan(double x); //returns the tangent of x radians
double acos(double x); //returns A, the angle corresponding to cos (A) = x
double asin(double x); //returns A, the angle corresponding to sin (A) = x
double atan(double x); //returns A, the angle corresponding to tan (A) = x

Esempio

double sine = sin(2); // approximately 0.90929737091
double cosine = cos(2); // approximately -0.41614685058
double tangent = tan(2); // approximately -2.18503975868

Arduino Due è una scheda microcontrollore basata sulla CPU Atmel SAM3X8E ARM Cortex-M3. È la prima scheda Arduino basata su un microcontrollore ARM core a 32 bit.

Caratteristiche importanti -

• Dispone di 54 pin di ingresso / uscita digitali (di cui 12 possono essere utilizzati come uscite PWM)
• 12 ingressi analogici
• 4 UART (porte seriali hardware)
• Orologio da 84 MHz, connessione compatibile con USB OTG
• 2 DAC (da digitale ad analogico), 2 TWI, un jack di alimentazione, un'intestazione SPI, un'intestazione JTAG
• Pulsante di ripristino e un pulsante di cancellazione

Caratteristiche della scheda Arduino Due

Volt di funzionamento	Velocità della CPU	Ingresso / uscita analogico	IO / PWM digitale	EEPROM [KB]	SRAM [KB]	Flash [KB]	USB	UART
3,3 Volt	84 Mhz	12/2	54/12	-	96	512	2 micro	4

Comunicazione

• 4 UART hardware
• 2 I2C
• 1 interfaccia CAN (protocollo di comunicazione automobilistico)
• 1 SPI
• 1 interfaccia JTAG (10 pin)
• 1 host USB (come Leonardo)
• 1 porta di programmazione

A differenza della maggior parte delle schede Arduino, la scheda Arduino Due funziona a 3,3 V. La tensione massima che i pin I / O possono tollerare è 3,3 V. L'applicazione di tensioni superiori a 3,3 V a qualsiasi pin I / O potrebbe danneggiare la scheda.

La scheda contiene tutto il necessario per supportare il microcontrollore. Puoi semplicemente collegarlo a un computer con un cavo micro-USB o alimentarlo con un adattatore AC-DC o una batteria per iniziare. Il Due è compatibile con tutti gli shield Arduino che funzionano a 3.3V.

Arduino Zero

Lo Zero è una semplice e potente estensione a 32 bit della piattaforma stabilita dall'ONU. La scheda Zero espande la famiglia fornendo maggiori prestazioni, consentendo una varietà di opportunità di progetto per i dispositivi e funge da ottimo strumento educativo per apprendere lo sviluppo di applicazioni a 32 bit.

Le caratteristiche importanti sono:

• Le applicazioni Zero spaziano dai dispositivi IoT intelligenti, alla tecnologia indossabile, all'automazione high-tech, alla robotica folle.

• La scheda è alimentata dall'MCU SAMD21 di Atmel, che presenta un core ARM Cortex® M0 + a 32 bit.

• Una delle sue caratteristiche più importanti è Embedded Debugger (EDBG) di Atmel, che fornisce un'interfaccia di debug completa senza la necessità di hardware aggiuntivo, aumentando in modo significativo la facilità d'uso per il debug del software.

• EDBG supporta anche una porta COM virtuale che può essere utilizzata per la programmazione di dispositivi e bootloader.

Caratteristiche della scheda Arduino Zero

Volt di funzionamento	Velocità della CPU	Ingresso / uscita analogico	IO / PWM digitale	EEPROM [KB]	SRAM [KB]	Flash [KB]	USB	UART
3,3 Volt	48 Mhz	6/1	14/10	-	32	256	2 micro	2

A differenza della maggior parte delle schede Arduino e Genuino, Zero funziona a 3,3 V. La tensione massima che i pin I / O possono tollerare è 3,3 V. L'applicazione di tensioni superiori a 3,3 V a qualsiasi pin I / O potrebbe danneggiare la scheda.

La scheda contiene tutto il necessario per supportare il microcontrollore. Puoi semplicemente collegarlo a un computer con un cavo micro-USB o alimentarlo con un adattatore CA-CC o una batteria per iniziare. Lo Zero è compatibile con tutti gli schermi che funzionano a 3,3 V.

La modulazione di larghezza di impulso o PWM è una tecnica comune utilizzata per variare l'ampiezza degli impulsi in un treno di impulsi. PWM ha molte applicazioni come il controllo di servocomandi e regolatori di velocità, limitando la potenza effettiva di motori e LED.

Principio di base del PWM

La modulazione della larghezza di impulso è fondamentalmente un'onda quadra con un tempo alto e basso variabile. Un segnale PWM di base è mostrato nella figura seguente.

Esistono vari termini associati a PWM:

• On-Time - La durata del segnale orario è alta.

• Off-Time - La durata del segnale orario è bassa.

• Period - È rappresentato come la somma del tempo di accensione e del tempo di spegnimento del segnale PWM.

• Duty Cycle - È rappresentato come la percentuale del segnale orario che rimane acceso durante il periodo del segnale PWM.

Periodo

Come mostrato nella figura, T _on indica l'ora di attivazione e T _off indica l'ora di disattivazione del segnale. Il periodo è la somma dei tempi di accensione e spegnimento ed è calcolato come mostrato nella seguente equazione:

Ciclo di lavoro

Il ciclo di lavoro è calcolato come il tempo di attivazione del periodo di tempo. Utilizzando il periodo calcolato sopra, il ciclo di lavoro viene calcolato come:

Funzione analogWrite ()

Il analogWrite()la funzione scrive un valore analogico (onda PWM) su un pin. Può essere utilizzato per accendere un LED a luminosità variabile o azionare un motore a varie velocità. Dopo una chiamata alla funzione analogWrite (), il pin genererà un'onda quadra costante del duty cycle specificato fino alla chiamata successiva ad analogWrite () o una chiamata a digitalRead () o digitalWrite () sullo stesso pin. La frequenza del segnale PWM sulla maggior parte dei pin è di circa 490 Hz. Sulle schede Uno e simili, i pin 5 e 6 hanno una frequenza di circa 980 Hz. Anche i pin 3 e 11 del Leonardo funzionano a 980 Hz.

Sulla maggior parte delle schede Arduino (quelle con ATmega168 o ATmega328), questa funzione funziona sui pin 3, 5, 6, 9, 10 e 11. Su Arduino Mega, funziona sui pin 2 - 13 e 44 - 46. Arduino precedente schede con supporto solo ATmega8 analogWrite() sui pin 9, 10 e 11.

L'Arduino Due supporta analogWrite()sui pin da 2 a 13 e sui pin DAC0 e DAC1. A differenza dei pin PWM, DAC0 e DAC1 sono convertitori da digitale ad analogico e agiscono come vere uscite analogiche.

Non è necessario chiamare pinMode () per impostare il pin come output prima di chiamare analogWrite ().

Sintassi della funzione analogWrite ()

analogWrite ( pin , value ) ;

value - il duty cycle: compreso tra 0 (sempre spento) e 255 (sempre acceso).

Example

int ledPin = 9; // LED connected to digital pin 9
int analogPin = 3; // potentiometer connected to analog pin 3
int val = 0; // variable to store the read value

void setup() {
   pinMode(ledPin, OUTPUT); // sets the pin as output
}

void loop() {
   val = analogRead(analogPin); // read the input pin
   analogWrite(ledPin, (val / 4)); // analogRead values go from 0 to 1023, 
      // analogWrite values from 0 to 255
}

Per generare numeri casuali, puoi utilizzare le funzioni di numeri casuali di Arduino. Abbiamo due funzioni:

• randomSeed(seed)
• random()

randomSeed (seme)

La funzione randomSeed (seed) ripristina il generatore di numeri pseudocasuali di Arduino. Sebbene la distribuzione dei numeri restituiti da random () sia essenzialmente casuale, la sequenza è prevedibile. Dovresti ripristinare il generatore su un valore casuale. Se si dispone di un pin analogico non collegato, potrebbe captare rumore casuale dall'ambiente circostante. Possono essere onde radio, raggi cosmici, interferenze elettromagnetiche da telefoni cellulari, luci fluorescenti e così via.

Esempio

randomSeed(analogRead(5)); // randomize using noise from analog pin 5

casuale( )

La funzione casuale genera numeri pseudo-casuali. Di seguito è riportata la sintassi.

Sintassi delle istruzioni random ()

long random(max) // it generate random numbers from 0 to max
long random(min, max) // it generate random numbers from min to max

Esempio

long randNumber;

void setup() {
   Serial.begin(9600);
   // if analog input pin 0 is unconnected, random analog
   // noise will cause the call to randomSeed() to generate
   // different seed numbers each time the sketch runs.
   // randomSeed() will then shuffle the random function.
   randomSeed(analogRead(0));
}

void loop() {
   // print a random number from 0 to 299
   Serial.print("random1=");
   randNumber = random(300);
   Serial.println(randNumber); // print a random number from 0to 299
   Serial.print("random2=");
   randNumber = random(10, 20);// print a random number from 10 to 19
   Serial.println (randNumber);
   delay(50);
}

Cerchiamo ora di aggiornare la nostra conoscenza su alcuni dei concetti di base come bit e byte.

Bit

Un po 'è solo una cifra binaria.

• Il sistema binario utilizza due cifre, 0 e 1.

• Simile al sistema dei numeri decimali, in cui le cifre di un numero non hanno lo stesso valore, il "significato" di un bit dipende dalla sua posizione nel numero binario. Ad esempio, le cifre nel numero decimale 666 sono le stesse, ma hanno valori diversi.

Byte

Un byte è composto da otto bit.

• Se un bit è una cifra, è logico che i byte rappresentino i numeri.

• Tutte le operazioni matematiche possono essere eseguite su di essi.

• Neanche le cifre in un byte hanno lo stesso significato.

• Il bit più a sinistra ha il valore massimo chiamato bit più significativo (MSB).

• Il bit più a destra ha il valore minimo ed è quindi chiamato il bit meno significativo (LSB).

• Poiché otto zeri e uno di un byte possono essere combinati in 256 modi diversi, il numero decimale più grande che può essere rappresentato da un byte è 255 (una combinazione rappresenta uno zero).

Gli interrupt interrompono il lavoro corrente di Arduino in modo che sia possibile eseguire altri lavori.

Supponi di essere seduto a casa a chattare con qualcuno. All'improvviso squilla il telefono. Smetti di chattare e alzi il telefono per parlare con il chiamante. Quando hai finito la tua conversazione telefonica, torni a chattare con la persona prima che squilli il telefono.

Allo stesso modo, puoi pensare alla routine principale come chattare con qualcuno, lo squillo del telefono ti fa smettere di chattare. La routine di interruzione del servizio è il processo di conversazione al telefono. Quando la conversazione telefonica finisce, torni alla tua routine principale di chat. Questo esempio spiega esattamente come un interrupt fa agire un processore.

Il programma principale è in esecuzione ed esegue alcune funzioni in un circuito. Tuttavia, quando si verifica un'interruzione, il programma principale si interrompe mentre viene eseguita un'altra routine. Al termine di questa routine, il processore torna di nuovo alla routine principale.

Caratteristiche importanti

Ecco alcune caratteristiche importanti sugli interrupt:

• Gli interrupt possono provenire da varie fonti. In questo caso, stiamo usando un interrupt hardware che viene attivato da un cambiamento di stato su uno dei pin digitali.

• La maggior parte dei progetti Arduino ha due interrupt hardware (denominati "interrupt0" e "interrupt1") collegati rispettivamente ai pin di I / O digitali 2 e 3.

• Arduino Mega ha sei interrupt hardware inclusi gli interrupt aggiuntivi (da "interrupt2" a "interrupt5") sui pin 21, 20, 19 e 18.

• È possibile definire una routine utilizzando una funzione speciale chiamata "Interrupt Service Routine" (generalmente nota come ISR).

• È possibile definire la routine e specificare le condizioni sul fronte di salita, sul fronte di discesa o su entrambi. A queste condizioni specifiche, l'interrupt sarebbe servito.

• È possibile che tale funzione venga eseguita automaticamente ogni volta che si verifica un evento su un pin di ingresso.

Tipi di interruzioni

Esistono due tipi di interruzioni:

• Hardware Interrupts - Si verificano in risposta a un evento esterno, come un pin di interrupt esterno che va alto o basso.

• Software Interrupts- Si verificano in risposta a un'istruzione inviata nel software. L'unico tipo di interrupt supportato dal "linguaggio Arduino" è la funzione attachInterrupt ().

Utilizzo degli interrupt in Arduino

Gli interrupt sono molto utili nei programmi Arduino in quanto aiutano a risolvere i problemi di temporizzazione. Una buona applicazione di un interrupt è leggere un codificatore rotante o osservare un input dell'utente. In generale, un ISR dovrebbe essere il più breve e veloce possibile. Se il tuo schizzo utilizza più ISR, solo uno alla volta può essere eseguito. Altri interrupt verranno eseguiti al termine di quello corrente in un ordine che dipende dalla priorità che hanno.

In genere, le variabili globali vengono utilizzate per trasferire i dati tra un ISR e il programma principale. Per assicurarsi che le variabili condivise tra un ISR e il programma principale siano aggiornate correttamente, dichiararle come volatili.

sintassi dell'istruzione attachInterrupt

attachInterrupt(digitalPinToInterrupt(pin),ISR,mode);//recommended for arduino board
attachInterrupt(pin, ISR, mode) ; //recommended Arduino Due, Zero only
//argument pin: the pin number
//argument ISR: the ISR to call when the interrupt occurs; 
   //this function must take no parameters and return nothing. 
   //This function is sometimes referred to as an interrupt service routine.
//argument mode: defines when the interrupt should be triggered.

Le seguenti tre costanti sono predefinite come valori validi:

• LOW per attivare l'interrupt ogni volta che il pin è basso.

• CHANGE per attivare l'interrupt ogni volta che il pin cambia valore.

• FALLING ogni volta che il pin va dall'alto verso il basso.

Example

int pin = 2; //define interrupt pin to 2
volatile int state = LOW; // To make sure variables shared between an ISR
//the main program are updated correctly,declare them as volatile.

void setup() {
   pinMode(13, OUTPUT); //set pin 13 as output
   attachInterrupt(digitalPinToInterrupt(pin), blink, CHANGE);
   //interrupt at pin 2 blink ISR when pin to change the value
} 
void loop() { 
   digitalWrite(13, state); //pin 13 equal the state value
} 

void blink() { 
   //ISR function
   state = !state; //toggle the state when the interrupt occurs
}

Per ottenere questo scambio di dati sono stati definiti centinaia di protocolli di comunicazione. Ogni protocollo può essere classificato in una delle due categorie: parallelo o seriale.

Comunicazione parallela

Il collegamento in parallelo tra Arduino e periferiche tramite porte di ingresso / uscita è la soluzione ideale per distanze più brevi fino a diversi metri. Tuttavia, in altri casi, quando è necessario stabilire la comunicazione tra due dispositivi per distanze maggiori, non è possibile utilizzare la connessione parallela. Le interfacce parallele trasferiscono più bit contemporaneamente. Di solito richiedono bus di dati - trasmissione su otto, sedici o più cavi. I dati vengono trasferiti in enormi ondate di 1 e 0.

Vantaggi e svantaggi della comunicazione parallela

La comunicazione parallela ha sicuramente i suoi vantaggi. È più veloce del seriale, semplice e relativamente facile da implementare. Tuttavia, richiede molte porte e linee di input / output (I / O). Se hai mai dovuto spostare un progetto da un Arduino Uno di base a un Mega, sai che le linee di I / O su un microprocessore possono essere preziose e poche. Pertanto, preferiamo la comunicazione seriale, sacrificando la velocità potenziale per la proprietà dei pin.

Moduli di comunicazione seriale

Oggi, la maggior parte delle schede Arduino sono costruite con diversi sistemi per la comunicazione seriale come dotazione standard.

Quale di questi sistemi viene utilizzato dipende dai seguenti fattori:

• Con quanti dispositivi deve scambiare dati il ​​microcontrollore?
• Quanto deve essere veloce lo scambio di dati?
• Qual è la distanza tra questi dispositivi?
• È necessario inviare e ricevere dati contemporaneamente?

Una delle cose più importanti riguardo alla comunicazione seriale è il Protocol, che dovrebbe essere rigorosamente osservato. È un insieme di regole, che devono essere applicate in modo che i dispositivi possano interpretare correttamente i dati che si scambiano reciprocamente. Fortunatamente Arduino se ne occupa automaticamente, così che il lavoro del programmatore / utente si riduce alla semplice scrittura (dati da inviare) e lettura (dati ricevuti).

Tipi di comunicazioni seriali

La comunicazione seriale può essere ulteriormente classificata come:

• Synchronous - I dispositivi sincronizzati utilizzano lo stesso orologio e la loro temporizzazione è sincronizzata tra loro.

• Asynchronous - I dispositivi asincroni hanno i propri clock e vengono attivati ​​dall'uscita dello stato precedente.

È facile scoprire se un dispositivo è sincrono o meno. Se viene fornito lo stesso clock a tutti i dispositivi collegati, allora sono sincroni. Se non è presente una linea di clock, è asincrona.

Ad esempio, il modulo UART (Universal Asynchronous Receiver Transmitter) è asincrono.

Il protocollo seriale asincrono ha una serie di regole integrate. Queste regole non sono altro che meccanismi che aiutano a garantire trasferimenti di dati robusti e privi di errori. Questi meccanismi, che otteniamo per evitare il segnale di clock esterno, sono:

• Bit di sincronizzazione
• Bit di dati
• Bit di parità
• Velocità in baud

Bit di sincronizzazione

I bit di sincronizzazione sono due o tre bit speciali trasferiti con ciascun pacchetto di dati. Sono il bit di inizio e il bit di stop. Fedeli al loro nome, questi bit segnano rispettivamente l'inizio e la fine di un pacchetto.

C'è sempre un solo bit di inizio, ma il numero di bit di stop è configurabile su uno o due (sebbene normalmente sia lasciato a uno).

Il bit di inizio è sempre indicato da una linea dati inattiva che va da 1 a 0, mentre i bit di stop torneranno allo stato di inattività mantenendo la linea su 1.

Bit di dati

La quantità di dati in ogni pacchetto può essere impostata su qualsiasi dimensione da 5 a 9 bit. Certamente, la dimensione dei dati standard è il byte di base a 8 bit, ma altre dimensioni hanno i loro usi. Un pacchetto di dati a 7 bit può essere più efficiente di 8, soprattutto se stai trasferendo solo caratteri ASCII a 7 bit.

Bit di parità

L'utente può selezionare se deve esserci o meno un bit di parità e, in caso affermativo, se la parità deve essere pari o dispari. Il bit di parità è 0 se il numero di 1 tra i bit di dati è pari. La parità dispari è esattamente l'opposto.

Velocità in baud

Il termine baud rate viene utilizzato per indicare il numero di bit trasferiti al secondo [bps]. Notare che si riferisce a bit, non a byte. Di solito è richiesto dal protocollo che ogni byte venga trasferito insieme a diversi bit di controllo. Significa che un byte nel flusso di dati seriale può essere costituito da 11 bit. Ad esempio, se la velocità di trasmissione è di 300 bps, è possibile trasferire un massimo di 37 e un minimo di 27 byte al secondo.

Arduino UART

Il codice seguente farà sì che Arduino invii ciao mondo all'avvio.

void setup() {
   Serial.begin(9600); //set up serial library baud rate to 9600
   Serial.println("hello world"); //print hello world
}

void loop() {

}

Dopo che lo schizzo di Arduino è stato caricato su Arduino, apri il monitor seriale

nella sezione in alto a destra dell'IDE di Arduino.

Digita qualsiasi cosa nella casella in alto del monitor seriale e premi invio o invio sulla tastiera. Questo invierà una serie di byte ad Arduino.

Il codice seguente restituisce tutto ciò che riceve come input.

Il codice seguente farà in modo che Arduino fornisca l'output a seconda dell'input fornito.

void setup() {
   Serial.begin(9600); //set up serial library baud rate to 9600
}

void loop() {
   if(Serial.available()) //if number of bytes (characters) available for reading from { 
      serial port
      Serial.print("I received:"); //print I received
      Serial.write(Serial.read()); //send what you read
   }
}

Notare che Serial.print e Serial.println restituirà il codice ASCII effettivo, mentre Serial.writerestituirà il testo effettivo. Vedere Codici ASCII per ulteriori informazioni.

Il circuito inter-integrato (I2C) è un sistema per lo scambio seriale di dati tra i microcontrollori e circuiti integrati specializzati di nuova generazione. Viene utilizzato quando la distanza tra loro è breve (il ricevitore e il trasmettitore si trovano solitamente sulla stessa scheda stampata). La connessione viene stabilita tramite due conduttori. Uno è utilizzato per il trasferimento dei dati e l'altro è utilizzato per la sincronizzazione (segnale di clock).

Come si vede nella figura seguente, un dispositivo è sempre un master. Esegue l'indirizzamento di un chip slave prima dell'inizio della comunicazione. In questo modo, un microcontrollore può comunicare con 112 dispositivi diversi. La velocità di trasmissione è generalmente di 100 Kb / sec (modalità standard) o 10 Kb / sec (modalità di velocità di trasmissione lenta). Recentemente sono apparsi sistemi con una velocità di trasmissione di 3,4 Mb / sec. La distanza tra i dispositivi che comunicano su un bus I2C è limitata a diversi metri.

Pin I2C della scheda

Il bus I2C è costituito da due segnali: SCL e SDA. SCL è il segnale di clock e SDA è il segnale di dati. L'attuale bus master genera sempre il segnale di clock. Alcuni dispositivi slave possono forzare il clock basso a volte per ritardare l'invio di più dati da parte del master (o per richiedere più tempo per preparare i dati prima che il master tenti di sincronizzarli). Questo è noto come "allungamento dell'orologio".

Di seguito sono riportati i pin per diverse schede Arduino:

• Uno, Pro Mini A4 (SDA), A5 (SCL)
• Mega, Due 20 (SDA), 21 (SCL)
• Leonardo, Yun 2 (SDA), 3 (SCL)

Arduino I2C

Abbiamo due modalità - codice master e codice slave - per collegare due schede Arduino utilizzando I2C. Sono -

• Trasmettitore Master / Ricevitore Slave
• Ricevitore Master / Trasmettitore Slave

Trasmettitore Master / Ricevitore Slave

Vediamo ora cosa sono il trasmettitore master e il ricevitore slave.

Trasmettitore principale

Le seguenti funzioni vengono utilizzate per inizializzare la libreria Wire e unire il bus I2C come master o slave. Normalmente viene chiamato solo una volta.

• Wire.begin(address) - L'indirizzo è l'indirizzo slave a 7 bit nel nostro caso in quanto il master non è specificato e si unirà al bus come master.

• Wire.beginTransmission(address) - Inizia una trasmissione al dispositivo I2C slave con l'indirizzo dato.

• Wire.write(value) - Accoda i byte per la trasmissione da un dispositivo master a uno slave (chiamate intermedie a beginTransmission () e endTransmission ()).

• Wire.endTransmission() - Termina una trasmissione a un dispositivo slave che è stata iniziata da beginTransmission () e trasmette i byte che sono stati accodati da wire.write ().

Example

#include <Wire.h> //include wire library

void setup() //this will run only once { 
   Wire.begin(); // join i2c bus as master
} 

short age = 0; 

void loop() {   
   Wire.beginTransmission(2); 
   // transmit to device #2
   Wire.write("age is = ");
   Wire.write(age); // sends one byte
   Wire.endTransmission(); // stop transmitting
   delay(1000); 
}

Ricevitore slave

Vengono utilizzate le seguenti funzioni:

• Wire.begin(address) - L'indirizzo è l'indirizzo dello slave a 7 bit.

• Wire.onReceive(received data handler) - Funzione da richiamare quando un dispositivo slave riceve dati dal master.

• Wire.available() - Restituisce il numero di byte disponibili per il recupero con Wire.read (). Dovrebbe essere chiamato all'interno del gestore Wire.onReceive ().

Example

#include <Wire.h> //include wire library

void setup() {  //this will run only once
   Wire.begin(2); // join i2c bus with address #2
   Wire.onReceive(receiveEvent); // call receiveEvent when the master send any thing 
   Serial.begin(9600); // start serial for output to print what we receive 
}

void loop() {   
   delay(250); 
}

//-----this function will execute whenever data is received from master-----//

void receiveEvent(int howMany) { 
   while (Wire.available()>1) // loop through all but the last {
      char c = Wire.read(); // receive byte as a character
      Serial.print(c); // print the character
   }
}

Ricevitore Master / Trasmettitore Slave

Vediamo ora cosa sono il ricevitore master e il trasmettitore slave.

Ricevitore principale

Il Master è programmato per richiedere e quindi leggere byte di dati inviati dallo Slave Arduino con indirizzo univoco.

Viene utilizzata la seguente funzione:

Wire.requestFrom(address,number of bytes)- Utilizzato dal master per richiedere byte da un dispositivo slave. I byte possono quindi essere recuperati con le funzioni wire.available () e wire.read ().

Example

#include <Wire.h> //include wire library void setup() { 
   Wire.begin(); // join i2c bus (address optional for master) 
   Serial.begin(9600); // start serial for output
} 

void loop() { 
   Wire.requestFrom(2, 1); // request 1 bytes from slave device #2
   while (Wire.available()) // slave may send less than requested {
      char c = Wire.read(); // receive a byte as character
      Serial.print(c); // print the character
   } 
   delay(500); 
}

Trasmettitore slave

Viene utilizzata la seguente funzione.

Wire.onRequest(handler) - Una funzione viene chiamata quando un master richiede dati da questo dispositivo slave.

Example

#include <Wire.h> 

void setup() { 
   Wire.begin(2); // join i2c bus with address #2
   Wire.onRequest(requestEvent); // register event
} 

Byte x = 0;

void loop() { 
   delay(100); 
} 

// function that executes whenever data is requested by master
// this function is registered as an event, see setup()

void requestEvent() { 
   Wire.write(x); // respond with message of 1 bytes as expected by master
   x++; 
}

Un bus SPI (Serial Peripheral Interface) è un sistema per la comunicazione seriale, che utilizza fino a quattro conduttori, comunemente tre. Un conduttore viene utilizzato per la ricezione dei dati, uno per l'invio dei dati, uno per la sincronizzazione e uno in alternativa per la selezione di un dispositivo con cui comunicare. È una connessione full duplex, il che significa che i dati vengono inviati e ricevuti simultaneamente. La velocità di trasmissione massima è superiore a quella del sistema di comunicazione I2C.

Pin di bordo SPI

SPI utilizza i seguenti quattro fili:

• SCK - Questo è l'orologio seriale pilotato dal master.

• MOSI - Questa è l'uscita master / ingresso slave pilotato dal master.

• MISO - Questo è l'ingresso master / uscita slave pilotato dal master.

• SS - Questo è il cavo di selezione degli schiavi.

Vengono utilizzate le seguenti funzioni. Devi includere SPI.h.

• SPI.begin() - Inizializza il bus SPI impostando SCK, MOSI e SS sulle uscite, portando SCK e MOSI bassi e SS alti.

• SPI.setClockDivider(divider)- Per impostare il divisore dell'orologio SPI relativo all'orologio di sistema. Sulle schede basate su AVR, i divisori disponibili sono 2, 4, 8, 16, 32, 64 o 128. L'impostazione predefinita è SPI_CLOCK_DIV4, che imposta l'orologio SPI a un quarto della frequenza dell'orologio di sistema (5 Mhz per schede a 20 MHz).

• Divider - Potrebbe essere (SPI_CLOCK_DIV2, SPI_CLOCK_DIV4, SPI_CLOCK_DIV8, SPI_CLOCK_DIV16, SPI_CLOCK_DIV32, SPI_CLOCK_DIV64, SPI_CLOCK_DIV128).

• SPI.transfer(val) - Il trasferimento SPI si basa su un invio e una ricezione simultanei: i dati ricevuti vengono restituiti in receiveVal.

• SPI.beginTransaction(SPISettings(speedMaximum, dataOrder, dataMode)) - speedMaximum è l'orologio, dataOrder (MSBFIRST o LSBFIRST), dataMode (SPI_MODE0, SPI_MODE1, SPI_MODE2 o SPI_MODE3).

Abbiamo quattro modalità di funzionamento in SPI come segue:

• Mode 0 (the default) - Il clock è normalmente basso (CPOL = 0) ei dati vengono campionati sulla transizione da basso ad alto (fronte di salita) (CPHA = 0).

• Mode 1 - Il clock è normalmente basso (CPOL = 0) ei dati vengono campionati sulla transizione da alto a basso (fronte di discesa) (CPHA = 1).

• Mode 2 - Il clock è normalmente alto (CPOL = 1) e i dati vengono campionati sulla transizione da alto a basso (fronte di salita) (CPHA = 0).

• Mode 3 - Il clock è normalmente alto (CPOL = 1) e i dati vengono campionati nella transizione da basso ad alto (fronte di discesa) (CPHA = 1).

• SPI.attachInterrupt(handler) - Funzione da richiamare quando un dispositivo slave riceve dati dal master.

Ora collegheremo insieme due schede Arduino UNO; uno come padrone e l'altro come schiavo.

• (SS): pin 10
• (MOSI): pin 11
• (MISO): pin 12
• (SCK): pin 13

Il terreno è comune. Di seguito è riportata la rappresentazione schematica della connessione tra le due schede:

Vediamo esempi di SPI come Master e SPI come Slave.

SPI come MASTER

Esempio

#include <SPI.h>

void setup (void) {
   Serial.begin(115200); //set baud rate to 115200 for usart
   digitalWrite(SS, HIGH); // disable Slave Select
   SPI.begin ();
   SPI.setClockDivider(SPI_CLOCK_DIV8);//divide the clock by 8
}

void loop (void) {
   char c;
   digitalWrite(SS, LOW); // enable Slave Select
   // send test string
   for (const char * p = "Hello, world!\r" ; c = *p; p++) {
      SPI.transfer (c);
      Serial.print(c);
   }
   digitalWrite(SS, HIGH); // disable Slave Select
   delay(2000);
}

SPI come SLAVE

Esempio

#include <SPI.h>
char buff [50];
volatile byte indx;
volatile boolean process;

void setup (void) {
   Serial.begin (115200);
   pinMode(MISO, OUTPUT); // have to send on master in so it set as output
   SPCR |= _BV(SPE); // turn on SPI in slave mode
   indx = 0; // buffer empty
   process = false;
   SPI.attachInterrupt(); // turn on interrupt
}
ISR (SPI_STC_vect) // SPI interrupt routine { 
   byte c = SPDR; // read byte from SPI Data Register
   if (indx < sizeof buff) {
      buff [indx++] = c; // save data in the next index in the array buff
      if (c == '\r') //check for the end of the word
      process = true;
   }
}

void loop (void) {
   if (process) {
      process = false; //reset the process
      Serial.println (buff); //print the array on serial monitor
      indx= 0; //reset button to zero
   }
}

I LED sono luci piccole e potenti che vengono utilizzate in molte applicazioni diverse. Per iniziare, lavoreremo sul lampeggiare di un LED, il Hello World dei microcontrollori. È semplice come accendere e spegnere una luce. Stabilire questa importante linea di base ti darà una solida base mentre lavoriamo verso esperimenti più complessi.

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × Breadboard
• 1 × Arduino Uno R3
• 1 × LED
• Resistore 1 × 330Ω
• 2 × Ponticello

Procedura

Seguire lo schema del circuito e collegare i componenti sulla breadboard come mostrato nell'immagine sotto.

Note- Per scoprire la polarità di un LED, guardalo attentamente. La più corta delle due gambe, verso il bordo piatto del bulbo, indica il terminale negativo.

Componenti come i resistori devono avere i terminali piegati ad angoli di 90 ° per adattarsi correttamente alle prese della breadboard. Puoi anche tagliare i terminali più corti.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire il nuovo file di schizzo facendo clic su Nuovo.

Codice Arduino

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

// the setup function runs once when you press reset or power the board

void setup() {  // initialize digital pin 13 as an output.
   pinMode(2, OUTPUT);
}

// the loop function runs over and over again forever

void loop() {
   digitalWrite(2, HIGH); // turn the LED on (HIGH is the voltage level)
   delay(1000); // wait for a second
   digitalWrite(2, LOW); // turn the LED off by making the voltage LOW
   delay(1000); // wait for a second
}

Codice da notare

pinMode(2, OUTPUT)- Prima di poter usare uno dei pin di Arduino, devi dire ad Arduino Uno R3 se si tratta di un INPUT o di OUTPUT. Usiamo una "funzione" incorporata chiamata pinMode () per fare questo.

digitalWrite(2, HIGH) - Quando si utilizza un pin come USCITA, è possibile comandare che sia ALTO (uscita 5 volt) o BASSO (uscita 0 volt).

Risultato

Dovresti vedere il tuo LED accendersi e spegnersi. Se l'output richiesto non viene visualizzato, assicurati di aver assemblato correttamente il circuito, verificato e caricato il codice sulla tua scheda.

Questo esempio dimostra l'uso della funzione analogWrite () per la dissolvenza di un LED spento. AnalogWrite utilizza la modulazione di larghezza di impulso (PWM), attivando e disattivando un pin digitale molto rapidamente con diversi rapporti tra on e off, per creare un effetto di dissolvenza.

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × Breadboard
• 1 × Arduino Uno R3
• 1 × LED
• Resistore 1 × 330Ω
• 2 × Ponticello

Procedura

Seguire lo schema del circuito e collegare i componenti sulla breadboard come mostrato nell'immagine sotto.

Note- Per scoprire la polarità di un LED, guardalo attentamente. La più corta delle due gambe, verso il bordo piatto del bulbo, indica il terminale negativo.

Componenti come i resistori devono avere i terminali piegati ad angoli di 90 ° per adattarsi correttamente alle prese della breadboard. Puoi anche tagliare i terminali più corti.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire il nuovo file di schizzo facendo clic su Nuovo.

Codice Arduino

/*
   Fade
   This example shows how to fade an LED on pin 9 using the analogWrite() function.

   The analogWrite() function uses PWM, so if you want to change the pin you're using, be
   sure to use another PWM capable pin. On most Arduino, the PWM pins are identified with
   a "~" sign, like ~3, ~5, ~6, ~9, ~10 and ~11.
*/

int led = 9; // the PWM pin the LED is attached to
int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by
// the setup routine runs once when you press reset:

void setup() {
   // declare pin 9 to be an output:
   pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:

void loop() {
   // set the brightness of pin 9:
   analogWrite(led, brightness);
   // change the brightness for next time through the loop:
   brightness = brightness + fadeAmount;
   // reverse the direction of the fading at the ends of the fade:
   if (brightness == 0 || brightness == 255) {
      fadeAmount = -fadeAmount ;
   }
   // wait for 30 milliseconds to see the dimming effect
   delay(300);
}

Codice da notare

Dopo aver dichiarato il pin 9 come pin LED, non c'è nulla da fare nella funzione setup () del codice. La funzione analogWrite () che utilizzerai nel ciclo principale del tuo codice richiede due argomenti: uno, che dice alla funzione su quale pin scrivere e l'altro che indica quale valore PWM scrivere.

Per spegnere e riaccendere il LED, aumentare gradualmente i valori PWM da 0 (tutto spento) a 255 (tutto acceso), quindi di nuovo a 0, per completare il ciclo. Nello schizzo sopra riportato, il valore PWM viene impostato utilizzando una variabile chiamata luminosità. Ogni volta che si esegue il ciclo, aumenta del valore della variabilefadeAmount.

Se la luminosità è all'estremo del suo valore (0 o 255), fadeAmount viene modificato in negativo. In altre parole, se fadeAmount è 5, allora è impostato su -5. Se è -5, allora è impostato su 5. La prossima volta che si esegue il ciclo, questa modifica fa sì che anche la luminosità cambi direzione.

analogWrite()può cambiare il valore PWM molto velocemente, quindi il ritardo alla fine dello schizzo controlla la velocità della dissolvenza. Prova a cambiare il valore del ritardo e guarda come cambia l'effetto di dissolvenza.

Risultato

Dovresti vedere la luminosità del LED cambiare gradualmente.

Questo esempio ti mostrerà come leggere un ingresso analogico sul pin analogico 0. L'ingresso viene convertito da analogRead () in tensione e stampato sul monitor seriale del software Arduino (IDE).

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × Breadboard
• 1 × Arduino Uno R3
• Resistore variabile 1 × 5K (potenziometro)
• 2 × Ponticello

Procedura

Seguire lo schema del circuito e collegare i componenti sulla breadboard come mostrato nell'immagine sotto.

Potenziometro

Un potenziometro (o potenziometro) è un semplice trasduttore elettromeccanico. Converte il movimento rotatorio o lineare dall'operatore di input in un cambiamento di resistenza. Questa modifica è (o può essere) utilizzata per controllare qualsiasi cosa, dal volume di un sistema hi-fi alla direzione di un'enorme nave portacontainer.

Il vaso come lo conosciamo era originariamente noto come reostato (essenzialmente un resistore a filo avvolto variabile). La varietà di pentole disponibili è ora piuttosto sorprendente e può essere molto difficile per il principiante (in particolare) capire quale tipo è adatto per un determinato compito. Alcuni tipi di pentola diversi, che possono essere utilizzati per lo stesso compito, rendono il lavoro più difficile.

L'immagine a sinistra mostra il simbolo schematico standard di una pentola. L'immagine a destra è il potenziometro.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Codice Arduino

/*
   ReadAnalogVoltage
   Reads an analog input on pin 0, converts it to voltage, 
   and prints the result to the serial monitor.
   Graphical representation is available using serial plotter (Tools > Serial Plotter menu)
   Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.
*/

// the setup routine runs once when you press reset:

void setup() {
   // initialize serial communication at 9600 bits per second:
   Serial.begin(9600);
}

// the loop routine runs over and over again forever:

void loop() {
   // read the input on analog pin 0:
   int sensorValue = analogRead(A0);
   // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
   float voltage = sensorValue * (5.0 / 1023.0);
   // print out the value you read:
   Serial.println(voltage);
}

Codice da notare

Nel programma o schizzo fornito di seguito, la prima cosa da fare nella funzione di configurazione è iniziare le comunicazioni seriali, a 9600 bit al secondo, tra la scheda e il computer con la linea -

Serial.begin(9600);

Nel ciclo principale del tuo codice, devi stabilire una variabile per memorizzare il valore di resistenza (che sarà compreso tra 0 e 1023, perfetto per un tipo di dati int) proveniente dal tuo potenziometro -

int sensorValue = analogRead(A0);

Per modificare i valori da 0-1023 a un intervallo che corrisponde alla tensione, il pin sta leggendo, è necessario creare un'altra variabile, un float, e fare un piccolo calcolo. Per scalare i numeri tra 0,0 e 5,0, dividere 5,0 per 1023,0 e moltiplicarlo per sensorValue -

float voltage= sensorValue * (5.0 / 1023.0);

Infine, è necessario stampare queste informazioni sulla finestra seriale. Puoi farlo con il comando Serial.println () nell'ultima riga di codice -

Serial.println(voltage)

Ora, apri Serial Monitor nell'IDE Arduino facendo clic sull'icona a destra della barra verde in alto o premendo Ctrl + Maiusc + M.

Risultato

Vedrai un flusso costante di numeri che vanno da 0,0 a 5,0. Girando la pentola, i valori cambieranno, corrispondenti alla tensione sul pin A0.

Questo esempio mostra come leggere un ingresso analogico sul pin 0 analogico, convertire i valori da analogRead () in tensione e stamparli sul monitor seriale del software Arduino (IDE).

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × Breadboard
• 1 × Arduino Uno R3
• 1 resistore variabile da 5k ohm (potenziometro)
• 2 × Ponticello
• 8 × LED o è possibile utilizzare (display grafico a barre LED come mostrato nell'immagine sotto)

Procedura

Seguire lo schema del circuito e collegare i componenti sulla breadboard come mostrato nell'immagine sotto.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Grafico a barre a LED a 10 segmenti

Questi LED con grafico a barre a 10 segmenti hanno molti usi. Con un ingombro compatto e un collegamento semplice, sono facili per prototipi o prodotti finiti. Essenzialmente, sono 10 singoli LED blu alloggiati insieme, ciascuno con un anodo individuale e una connessione catodica.

Sono disponibili anche nei colori giallo, rosso e verde.

Note- Il pin out su questi grafici a barre può variare da quanto elencato nella scheda tecnica. La rotazione del dispositivo di 180 gradi correggerà la modifica, rendendo il pin 11 il primo pin in linea.

Codice Arduino

/*
   LED bar graph
   Turns on a series of LEDs based on the value of an analog sensor. 
   This is a simple way to make a bar graph display. 
   Though this graph uses 8LEDs, you can use any number by
      changing the LED count and the pins in the array.
   This method can be used to control any series of digital
      outputs that depends on an analog input.
*/

// these constants won't change:
const int analogPin = A0; // the pin that the potentiometer is attached to
const int ledCount = 8; // the number of LEDs in the bar graph
int ledPins[] = {2, 3, 4, 5, 6, 7, 8, 9}; // an array of pin numbers to which LEDs are attached

void setup() {
   // loop over the pin array and set them all to output:
   for (int thisLed = 0; thisLed < ledCount; thisLed++) {
      pinMode(ledPins[thisLed], OUTPUT);
   }
}

void loop() {
   // read the potentiometer:
   int sensorReading = analogRead(analogPin);
   // map the result to a range from 0 to the number of LEDs:
   int ledLevel = map(sensorReading, 0, 1023, 0, ledCount);
   // loop over the LED array:
   for (int thisLed = 0; thisLed < ledCount; thisLed++) {
      // if the array element's index is less than ledLevel,
      // turn the pin for this element on:
      if (thisLed < ledLevel) {
         digitalWrite(ledPins[thisLed], HIGH);
      }else { // turn off all pins higher than the ledLevel:
         digitalWrite(ledPins[thisLed], LOW);
      }
   }
}

Codice da notare

Lo schizzo funziona in questo modo: prima leggi l'input. Si mappa il valore di ingresso sulla gamma di uscita, in questo caso dieci LED. Quindi imposti un filefor-loopper iterare sugli output. Se il numero di output nella serie è inferiore all'intervallo di input mappato, attivarlo. In caso contrario, spegnilo.

Risultato

Vedrai i LED accendersi uno ad uno quando il valore della lettura analogica aumenta e spegnersi uno ad uno mentre la lettura sta diminuendo.

Questo esempio utilizza la libreria Keyboard per disconnetterti dalla sessione utente sul tuo computer quando il pin 2 di ARDUINO UNO viene portato a terra. Lo schizzo simula la pressione dei tasti in sequenza di due o tre tasti contemporaneamente e dopo un breve ritardo li rilascia.

Warning - Quando usi il file Keyboard.print()comando, Arduino prende il controllo della tastiera del tuo computer. Per assicurarti di non perdere il controllo del tuo computer mentre esegui uno schizzo con questa funzione, imposta un sistema di controllo affidabile prima di chiamare Keyboard.print (). Questo schizzo è progettato per inviare un comando da tastiera solo dopo che un perno è stato tirato a terra.

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × Breadboard
• 1 × scheda Arduino Leonardo, Micro o Due
• 1 × pulsante
• 1 × Ponticello

Procedura

Seguire lo schema del circuito e collegare i componenti sulla breadboard come mostrato nell'immagine sotto.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Per questo esempio, è necessario utilizzare Arduino IDE 1.6.7

Note- È necessario includere la libreria della tastiera nel file della libreria Arduino. Copiare e incollare il file della libreria della tastiera all'interno del file con le librerie dei nomi (evidenziate) come mostrato nello screenshot seguente.

Codice Arduino

/*
   Keyboard logout
   This sketch demonstrates the Keyboard library.
   When you connect pin 2 to ground, it performs a logout.
   It uses keyboard combinations to do this, as follows:
   On Windows, CTRL-ALT-DEL followed by ALT-l
   On Ubuntu, CTRL-ALT-DEL, and ENTER
   On OSX, CMD-SHIFT-q
   To wake: Spacebar.
   Circuit:
   * Arduino Leonardo or Micro
   * wire to connect D2 to ground.
*/

#define OSX 0
#define WINDOWS 1
#define UBUNTU 2

#include "Keyboard.h"

// change this to match your platform:
int platform = WINDOWS;

void setup() {
   // make pin 2 an input and turn on the
   // pullup resistor so it goes high unless
   // connected to ground:
   
   pinMode(2, INPUT_PULLUP);
   Keyboard.begin();
}

void loop() {
   while (digitalRead(2) == HIGH) {
      // do nothing until pin 2 goes low
      delay(500);
   }
   
   delay(1000);
   
   switch (platform) {
      case OSX:
      Keyboard.press(KEY_LEFT_GUI);
	  
      // Shift-Q logs out:
      Keyboard.press(KEY_LEFT_SHIFT);
      Keyboard.press('Q');
      delay(100);
	  
      // enter:
      Keyboard.write(KEY_RETURN);
      break;
	  
      case WINDOWS:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(100);
      Keyboard.releaseAll();
	  
      //ALT-l:
      delay(2000);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press('l');
      Keyboard.releaseAll();
      break;
	  
      case UBUNTU:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
	  
      delay(1000);
      Keyboard.releaseAll();
	  
      // Enter to confirm logout:
      Keyboard.write(KEY_RETURN);
      break;
   }
   
   // do nothing:
   while (true);
}

Keyboard.releaseAll();

   // enter:
      Keyboard.write(KEY_RETURN);
      break;
      case WINDOWS:
	  
   // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(100);
      Keyboard.releaseAll();
	  
   //ALT-l:
      delay(2000);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press('l');
      Keyboard.releaseAll();
      break;
	  
   case UBUNTU:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(1000);
      Keyboard.releaseAll();
	  
      // Enter to confirm logout:
      Keyboard.write(KEY_RETURN);
      break;
   }
   
// do nothing:
   while (true);
}

Codice da notare

Prima di caricare il programma sulla tua scheda, assicurati di assegnare il sistema operativo corretto che stai attualmente utilizzando alla variabile della piattaforma.

Mentre lo sketch è in esecuzione, premendo il pulsante si collegherà il pin 2 a terra e la scheda invierà la sequenza di logout al PC collegato tramite USB.

Risultato

Quando si collega il pin 2 a terra, esegue un'operazione di logout.

Utilizza le seguenti combinazioni di tasti per disconnettersi:

• Sopra Windows, CTRL-ALT-CANC seguito da ALT-l

• Sopra Ubuntu, CTRL-ALT-CANC e INVIO

• Sopra OSX, CMD-SHIFT-q

In questo esempio, quando si preme il pulsante, una stringa di testo viene inviata al computer come input da tastiera. La stringa riporta il numero di volte che il pulsante viene premuto. Dopo aver programmato e cablato il Leonardo, apri il tuo editor di testo preferito per vedere i risultati.

Warning - Quando usi il file Keyboard.print()comando, Arduino prende il controllo della tastiera del tuo computer. Per assicurarti di non perdere il controllo del tuo computer mentre esegui uno schizzo con questa funzione, imposta un sistema di controllo affidabile prima di chiamareKeyboard.print(). Questo schizzo include un pulsante per attivare / disattivare la tastiera, in modo che venga eseguito solo dopo aver premuto il pulsante.

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × Breadboard
• 1 × scheda Arduino Leonardo, Micro o Due
• 1 × pulsante momentaneo
• 1 resistenza da 10k ohm

Procedura

Seguire lo schema del circuito e collegare i componenti sulla breadboard come mostrato nell'immagine sotto.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Codice Arduino

/*
   Keyboard Message test For the Arduino Leonardo and Micro,
      Sends a text string when a button is pressed.
   The circuit:
   * pushbutton attached from pin 4 to +5V
   * 10-kilohm resistor attached from pin 4 to ground
*/

#include "Keyboard.h"
const int buttonPin = 4; // input pin for pushbutton
int previousButtonState = HIGH; // for checking the state of a pushButton
int counter = 0; // button push counter

void setup() {
   pinMode(buttonPin, INPUT); // make the pushButton pin an input:
   Keyboard.begin(); // initialize control over the keyboard:
}

void loop() {
   int buttonState = digitalRead(buttonPin); // read the pushbutton:
   if ((buttonState != previousButtonState)&& (buttonState == HIGH)) // and it's currently pressed: {
      // increment the button counter
      counter++;
      // type out a message
      Keyboard.print("You pressed the button ");
      Keyboard.print(counter);
      Keyboard.println(" times.");
   }
   // save the current button state for comparison next time:
   previousButtonState = buttonState;
}

Codice da notare

Collega un terminale del pulsante al pin 4 su Arduino. Attacca l'altro pin a 5V. Utilizzare il resistore come un pull-down, fornendo un riferimento a terra, collegandolo dal pin 4 a terra.

Una volta programmata la scheda, scollegare il cavo USB, aprire un editor di testo e posizionare il cursore del testo nell'area di digitazione. Collega nuovamente la scheda al tuo computer tramite USB e premi il pulsante per scrivere nel documento.

Risultato

Utilizzando un qualsiasi editor di testo, verrà visualizzato il testo inviato tramite Arduino.

Utilizzando la libreria del mouse, puoi controllare il cursore su schermo di un computer con un Arduino Leonardo, Micro o Due.

Questo particolare esempio utilizza cinque pulsanti per spostare il cursore sullo schermo. Quattro dei pulsanti sono direzionali (su, giù, sinistra, destra) e uno è per il clic sinistro del mouse. Il movimento del cursore da Arduino è sempre relativo. Ogni volta che viene letto un input, la posizione del cursore viene aggiornata rispetto alla sua posizione corrente.

Ogni volta che uno dei pulsanti direzionali viene premuto, Arduino muoverà il mouse, mappando un ingresso ALTO su un intervallo di 5 nella direzione appropriata.

Il quinto pulsante serve per controllare un clic sinistro del mouse. Quando il pulsante viene rilasciato, il computer riconoscerà l'evento.

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × Breadboard
• 1 × scheda Arduino Leonardo, Micro o Due
• Resistenza 5 × 10k ohm
• 5 × pulsanti momentanei

Procedura

Seguire lo schema del circuito e collegare i componenti sulla breadboard come mostrato nell'immagine sotto.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Per questo esempio, è necessario utilizzare Arduino IDE 1.6.7

Codice Arduino

/*
   Button Mouse Control
   For Leonardo and Due boards only .Controls the mouse from 
   five pushbuttons on an Arduino Leonardo, Micro or Due.
   Hardware:
   * 5 pushbuttons attached to D2, D3, D4, D5, D6
   The mouse movement is always relative. This sketch reads
   four pushbuttons, and uses them to set the movement of the mouse.
   WARNING: When you use the Mouse.move() command, the Arduino takes
   over your mouse! Make sure you have control before you use the mouse commands.
*/

#include "Mouse.h"
// set pin numbers for the five buttons:
const int upButton = 2;
const int downButton = 3;
const int leftButton = 4;
const int rightButton = 5;
const int mouseButton = 6;
int range = 5; // output range of X or Y movement; affects movement speed
int responseDelay = 10; // response delay of the mouse, in ms

void setup() {
   // initialize the buttons' inputs:
   pinMode(upButton, INPUT);
   pinMode(downButton, INPUT);
   pinMode(leftButton, INPUT);
   pinMode(rightButton, INPUT);
   pinMode(mouseButton, INPUT);
   // initialize mouse control:
   Mouse.begin();
}

void loop() {
   // read the buttons:
   int upState = digitalRead(upButton);
   int downState = digitalRead(downButton);
   int rightState = digitalRead(rightButton);
   int leftState = digitalRead(leftButton);
   int clickState = digitalRead(mouseButton);
   // calculate the movement distance based on the button states:
   int xDistance = (leftState - rightState) * range;
   int yDistance = (upState - downState) * range;
   // if X or Y is non-zero, move:
   if ((xDistance != 0) || (yDistance != 0)) {
      Mouse.move(xDistance, yDistance, 0);
   }

   // if the mouse button is pressed:
   if (clickState == HIGH) {
      // if the mouse is not pressed, press it:
      if (!Mouse.isPressed(MOUSE_LEFT)) {
         Mouse.press(MOUSE_LEFT);
      }
   } else {                           // else the mouse button is not pressed:
      // if the mouse is pressed, release it:
      if (Mouse.isPressed(MOUSE_LEFT)) {
         Mouse.release(MOUSE_LEFT);
      }
   }
   // a delay so the mouse does not move too fast:
   delay(responseDelay);
}

Codice da notare

Collega la tua scheda al computer con un cavo micro-USB. I pulsanti sono collegati agli ingressi digitali dai pin da 2 a 6. Assicurarsi di utilizzare resistenze pull-down da 10k.

Questo esempio ascolta un byte proveniente dalla porta seriale. Quando viene ricevuto, la scheda invia una sequenza di tasti al computer. La sequenza di tasti inviata è superiore di una a quella ricevuta, quindi se invii una "a" dal monitor seriale, riceverai una "b" dalla scheda collegata al computer. Un "1" restituirà un "2" e così via.

Warning - Quando usi il file Keyboard.print()comando, la scheda Leonardo, Micro o Due prende il controllo della tastiera del tuo computer. Per assicurarti di non perdere il controllo del tuo computer mentre esegui uno schizzo con questa funzione, imposta un sistema di controllo affidabile prima di chiamare Keyboard.print (). Questo schizzo è progettato per inviare un comando da tastiera solo dopo che la scheda ha ricevuto un byte sulla porta seriale.

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × scheda Arduino Leonardo, Micro o Due

Procedura

Basta collegare la tua scheda al computer utilizzando il cavo USB.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Notes- È necessario includere la libreria della tastiera nel file della libreria Arduino. Copiare e incollare il file della libreria della tastiera all'interno del file con il nome "librerie" evidenziato in giallo.

Codice Arduino

/*
   Keyboard test
   For the Arduino Leonardo, Micro or Due Reads
      a byte from the serial port, sends a keystroke back. 
   The sent keystroke is one higher than what's received, e.g. if you send a, you get b, send
      A you get B, and so forth.
   The circuit:
   * none
*/

#include "Keyboard.h"

void setup() {
   // open the serial port:
   Serial.begin(9600);
   // initialize control over the keyboard:
   Keyboard.begin();
}

void loop() {
   // check for incoming serial data:
   if (Serial.available() > 0) {
      // read incoming serial data:
      char inChar = Serial.read();
      // Type the next ASCII value from what you received:
      Keyboard.write(inChar + 1);
   }
}

Codice da notare

Una volta programmato, apri il tuo monitor seriale e invia un byte. La scheda risponderà premendo un tasto, cioè un numero più alto.

Risultato

La scheda risponderà con una sequenza di tasti superiore di un numero sul monitor seriale IDE di Arduino quando si invia un byte.

In questa sezione impareremo come interfacciare la nostra scheda Arduino con diversi sensori. Discuteremo i seguenti sensori:

• Sensore di umidità (DHT22)
• Sensore di temperatura (LM35)
• Sensore rilevatore d'acqua (Simple Water Trigger)
• SENSORE PIR
• SENSORE ULTRASONICO
• GPS

Sensore di umidità (DHT22)

Il DHT-22 (denominato anche AM2302) è un sensore di uscita digitale, umidità relativa e temperatura. Utilizza un sensore di umidità capacitivo e un termistore per misurare l'aria circostante e invia un segnale digitale sul pin dati.

In questo esempio imparerai come utilizzare questo sensore con Arduino UNO. La temperatura e l'umidità della stanza verranno stampate sul monitor seriale.

Il sensore DHT-22

Le connessioni sono semplici. Il primo pin a sinistra a 3-5 V di alimentazione, il secondo pin al pin di ingresso dati e il pin più a destra a terra.

Dettagli tecnici

• Power - 3-5V

• Max Current - 2,5 mA

• Humidity - 0-100%, 2-5% di precisione

• Temperature - da 40 a 80 ° C, precisione ± 0,5 ° C

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × Breadboard
• 1 × Arduino Uno R3
• 1 × DHT22
• Resistenza 1 × 10K ohm

Procedura

Seguire lo schema del circuito e collegare i componenti sulla breadboard come mostrato nell'immagine sotto.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Codice Arduino

// Example testing sketch for various DHT humidity/temperature sensors

#include "DHT.h"
#define DHTPIN 2 // what digital pin we're connected to
// Uncomment whatever type you're using!
//#define DHTTYPE DHT11 // DHT 11
#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor
// Initialize DHT sensor.
// Note that older versions of this library took an optional third parameter to
// tweak the timings for faster processors. This parameter is no longer needed
// as the current DHT reading algorithm adjusts itself to work on faster procs.
DHT dht(DHTPIN, DHTTYPE);

void setup() {
   Serial.begin(9600);
   Serial.println("DHTxx test!");
   dht.begin();
}

void loop() {
   delay(2000); // Wait a few seconds between measurements
   float h = dht.readHumidity();
   // Reading temperature or humidity takes about 250 milliseconds!
   float t = dht.readTemperature();
   // Read temperature as Celsius (the default)
   float f = dht.readTemperature(true);
   // Read temperature as Fahrenheit (isFahrenheit = true)
   // Check if any reads failed and exit early (to try again).
   if (isnan(h) || isnan(t) || isnan(f)) {
      Serial.println("Failed to read from DHT sensor!");
      return;
   }
   
   // Compute heat index in Fahrenheit (the default)
   float hif = dht.computeHeatIndex(f, h);
   // Compute heat index in Celsius (isFahreheit = false)
   float hic = dht.computeHeatIndex(t, h, false);
   Serial.print ("Humidity: ");
   Serial.print (h);
   Serial.print (" %\t");
   Serial.print ("Temperature: ");
   Serial.print (t);
   Serial.print (" *C ");
   Serial.print (f);
   Serial.print (" *F\t");
   Serial.print ("Heat index: ");
   Serial.print (hic);
   Serial.print (" *C ");
   Serial.print (hif);
   Serial.println (" *F");
}

Codice da notare

Il sensore DHT22 ha quattro terminali (V _cc , DATA, NC, GND), che sono collegati alla scheda come segue:

• Pin DATA al pin numero 2 di Arduino
• V _cc pin a 5 volt della scheda Arduino
• Pin GND alla massa della scheda Arduino
• Dobbiamo collegare una resistenza da 10k ohm (resistenza di pull up) tra il DATA e il pin V _cc

Una volta terminate le connessioni hardware, è necessario aggiungere la libreria DHT22 al file della libreria Arduino come descritto in precedenza.

Risultato

Vedrai la visualizzazione della temperatura e dell'umidità sul monitor della porta seriale che viene aggiornata ogni 2 secondi.

I sensori di temperatura serie LM35 sono dispositivi di temperatura di precisione a circuito integrato con una tensione di uscita linearmente proporzionale alla temperatura centigrado.

Il dispositivo LM35 presenta un vantaggio rispetto ai sensori di temperatura lineari calibrati in Kelvin, poiché all'utente non è richiesto di sottrarre una grande tensione costante dall'uscita per ottenere una comoda scala centigrado. Il dispositivo LM35 non richiede alcuna calibrazione o regolazione esterna per fornire precisioni tipiche di ± ¼ ° C a temperatura ambiente e ± ¾ ° C su un intervallo di temperatura da −55 ° C a 150 ° C.

Specifiche tecniche

• Calibrato direttamente in Celsius (Centigrade)
• Fattore di scala lineare + 10-mV / ° C
• Precisione garantita di 0,5 ° C (a 25 ° C)
• Valutato per una gamma completa da −55 ° C a 150 ° C
• Adatto per applicazioni remote

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × Breadboard
• 1 × Arduino Uno R3
• 1 × sensore LM35

Procedura

Seguire lo schema del circuito e collegare i componenti sulla breadboard come mostrato nell'immagine sotto.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Codice Arduino

float temp;
int tempPin = 0;

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

void loop() {
   temp = analogRead(tempPin);
   // read analog volt from sensor and save to variable temp
   temp = temp * 0.48828125;
   // convert the analog volt to its temperature equivalent
   Serial.print("TEMPERATURE = ");
   Serial.print(temp); // display temperature value
   Serial.print("*C");
   Serial.println();
   delay(1000); // update sensor reading each one second
}

Codice da notare

Il sensore LM35 ha tre terminali: V _s , V _out e GND. Collegheremo il sensore come segue:

• Collegare il + V _s a + 5v sulla vostra scheda Arduino.
• Collega l' _uscita V ad Analog0 o A0 sulla scheda Arduino.
• Collega GND con GND su Arduino.

Il convertitore analogico / digitale (ADC) converte i valori analogici in un'approssimazione digitale basata sulla formula Valore ADC = campione * 1024 / tensione di riferimento (+ 5v). Quindi con un riferimento di +5 volt, l'approssimazione digitale sarà uguale alla tensione di ingresso * 205.

Risultato

Vedrai la visualizzazione della temperatura sul monitor della porta seriale che viene aggiornata ogni secondo.

Il mattone del sensore dell'acqua è progettato per il rilevamento dell'acqua, che può essere ampiamente utilizzato per rilevare la pioggia, il livello dell'acqua e persino le perdite di liquidi.

Il collegamento di un sensore di acqua a un Arduino è un ottimo modo per rilevare una perdita, uno sversamento, un allagamento, una pioggia, ecc. Può essere utilizzato per rilevare la presenza, il livello, il volume e / o l'assenza di acqua. Anche se questo potrebbe essere usato per ricordarti di innaffiare le tue piante, c'è un sensore Grove migliore per questo. Il sensore ha una serie di tracce esposte, che leggono BASSO quando viene rilevata l'acqua.

In questo capitolo, collegheremo il sensore dell'acqua al pin digitale 8 su Arduino e inseriremo il LED molto utile per identificare quando il sensore dell'acqua entra in contatto con una fonte d'acqua.

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × Breadboard
• 1 × Arduino Uno R3
• 1 × sensore dell'acqua
• 1 × led
• 1 resistenza da 330 ohm

Procedura

Seguire lo schema del circuito e collegare i componenti sulla breadboard come mostrato nell'immagine sotto.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Codice Arduino

#define Grove_Water_Sensor 8 // Attach Water sensor to Arduino Digital Pin 8
#define LED 9 // Attach an LED to Digital Pin 9 (or use onboard LED)

void setup() {
   pinMode(Grove_Water_Sensor, INPUT); // The Water Sensor is an Input
   pinMode(LED, OUTPUT); // The LED is an Output
}

void loop() {
   /* The water sensor will switch LOW when water is detected.
   Get the Arduino to illuminate the LED and activate the buzzer
   when water is detected, and switch both off when no water is present */
   if( digitalRead(Grove_Water_Sensor) == LOW) {
      digitalWrite(LED,HIGH);
   }else {
      digitalWrite(LED,LOW);
   }
}

Codice da notare

Il sensore dell'acqua ha tre terminali: S, V _out (+) e GND (-). Collegare il sensore come segue:

• Collegare il + V _s a + 5v sulla vostra scheda Arduino.
• Collega S al pin digitale numero 8 sulla scheda Arduino.
• Collega GND con GND su Arduino.
• Collega il LED al pin digitale numero 9 nella scheda Arduino.

Quando il sensore rileva l'acqua, il pin 8 su Arduino diventa BASSO e quindi il LED su Arduino si accende.

Risultato

Vedrai il LED di indicazione che si accende quando il sensore rileva l'acqua.

I sensori PIR ti consentono di rilevare il movimento. Sono utilizzati per rilevare se un essere umano si è spostato all'interno o all'esterno della portata del sensore. Si trovano comunemente in elettrodomestici e gadget utilizzati a casa o per le aziende. Sono spesso indicati come sensori PIR, "Infrarossi Passivi", "Piroelettrici" o "Movimento IR".

Di seguito sono riportati i vantaggi dei sensori PIR:

• Di piccole dimensioni
• Ampia gamma di lenti
• Facile da interfacciare
• Inexpensive
• Low-power
• Facile da usare
• Non consumare

I PIR sono costituiti da sensori piroelettrici, un barattolo di metallo rotondo con un cristallo rettangolare al centro, in grado di rilevare i livelli di radiazione infrarossa. Tutto emette radiazioni di basso livello e più qualcosa è caldo, più radiazioni vengono emesse. Il sensore in un rilevatore di movimento è diviso in due metà. Questo serve per rilevare il movimento (cambiamento) e non i livelli IR medi. Le due metà sono collegate in modo da annullarsi a vicenda. Se una metà vede più o meno radiazioni IR rispetto all'altra, l'uscita oscillerà alta o bassa.

I PIR hanno impostazioni regolabili e hanno un'intestazione installata nei pad di terra / uscita / alimentazione a 3 pin.

Per molti progetti o prodotti di base che devono rilevare quando una persona è uscita o è entrata nell'area, i sensori PIR sono ottimi. Nota che i PIR non ti dicono il numero di persone intorno o la loro vicinanza al sensore. L'obiettivo è spesso fissato a una certa distanza a distanza e talvolta vengono attivati ​​dagli animali domestici in casa.

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × Breadboard
• 1 × Arduino Uno R3
• 1 × sensore PIR (MQ3)

Procedura

Seguire lo schema del circuito ed effettuare i collegamenti come mostrato nell'immagine sottostante.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Codice Arduino

#define pirPin 2
int calibrationTime = 30;
long unsigned int lowIn;
long unsigned int pause = 5000;
boolean lockLow = true;
boolean takeLowTime;
int PIRValue = 0;

void setup() {
   Serial.begin(9600);
   pinMode(pirPin, INPUT);
}

void loop() {
   PIRSensor();
}

void PIRSensor() {
   if(digitalRead(pirPin) == HIGH) {
      if(lockLow) {
         PIRValue = 1;
         lockLow = false;
         Serial.println("Motion detected.");
         delay(50);
      }
      takeLowTime = true;
   }
   if(digitalRead(pirPin) == LOW) {
      if(takeLowTime){
         lowIn = millis();takeLowTime = false;
      }
      if(!lockLow && millis() - lowIn > pause) {
         PIRValue = 0;
         lockLow = true;
         Serial.println("Motion ended.");
         delay(50);
      }
   }
}

Codice da notare

Il sensore PIR ha tre terminali: V _cc , OUT e GND. Collegare il sensore come segue:

• Collega il + V _cc a + 5v sulla scheda Arduino.
• Collega OUT al pin digitale 2 sulla scheda Arduino.
• Collega GND con GND su Arduino.

È possibile regolare la sensibilità del sensore e il tempo di ritardo tramite due resistori variabili situati nella parte inferiore della scheda del sensore.

Una volta che il sensore rileva un movimento, Arduino invierà un messaggio tramite la porta seriale per dire che è stato rilevato un movimento. Il movimento di rilevamento PIR ritarderà di un certo tempo per verificare se c'è un nuovo movimento. Se non viene rilevato alcun movimento, Arduino invierà un nuovo messaggio dicendo che il movimento è terminato.

Risultato

Verrà visualizzato un messaggio sulla porta seriale se viene rilevato un movimento e un altro messaggio quando il movimento si interrompe.

Il sensore a ultrasuoni HC-SR04 utilizza SONAR per determinare la distanza di un oggetto proprio come fanno i pipistrelli. Offre un eccellente rilevamento della portata senza contatto con un'elevata precisione e letture stabili in un pacchetto facile da usare da 2 cm a 400 cm o da 1 "a 13 piedi.

L'operazione non è influenzata dalla luce solare o dal materiale nero, sebbene acusticamente, i materiali morbidi come i tessuti possono essere difficili da rilevare. Viene fornito completo di trasmettitore ad ultrasuoni e modulo ricevitore.

Specifiche tecniche

• Alimentazione - + 5V DC
• Corrente di riposo - <2mA
• Corrente di lavoro: 15 mA
• Angolo effettivo - <15 °
• Distanza di raggio: 2 cm - 400 cm / 1 ″ - 13 piedi
• Risoluzione - 0,3 cm
• Angolo di misurazione - 30 gradi

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × Breadboard
• 1 × Arduino Uno R3
• 1 × sensore ULTRASONIC (HC-SR04)

Procedura

Seguire lo schema elettrico ed effettuare i collegamenti come mostrato nell'immagine sotto riportata.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Codice Arduino

const int pingPin = 7; // Trigger Pin of Ultrasonic Sensor
const int echoPin = 6; // Echo Pin of Ultrasonic Sensor

void setup() {
   Serial.begin(9600); // Starting Serial Terminal
}

void loop() {
   long duration, inches, cm;
   pinMode(pingPin, OUTPUT);
   digitalWrite(pingPin, LOW);
   delayMicroseconds(2);
   digitalWrite(pingPin, HIGH);
   delayMicroseconds(10);
   digitalWrite(pingPin, LOW);
   pinMode(echoPin, INPUT);
   duration = pulseIn(echoPin, HIGH);
   inches = microsecondsToInches(duration);
   cm = microsecondsToCentimeters(duration);
   Serial.print(inches);
   Serial.print("in, ");
   Serial.print(cm);
   Serial.print("cm");
   Serial.println();
   delay(100);
}

long microsecondsToInches(long microseconds) {
   return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds) {
   return microseconds / 29 / 2;
}

Codice da notare

Il sensore a ultrasuoni ha quattro terminali - + 5V, Trigger, Echo e GND collegati come segue -

• Collega il pin + 5V a + 5v sulla tua scheda Arduino.
• Collega Trigger al pin digitale 7 sulla tua scheda Arduino.
• Collega Echo al pin digitale 6 sulla tua scheda Arduino.
• Collega GND con GND su Arduino.

Nel nostro programma abbiamo visualizzato la distanza misurata dal sensore in pollici e cm tramite la porta seriale.

Risultato

Vedrai la distanza misurata dal sensore in pollici e cm sul monitor seriale di Arduino.

I pulsanti o gli interruttori collegano due terminali aperti in un circuito. Questo esempio accende il LED sul pin 2 quando si preme l'interruttore a pulsante collegato al pin 8.

Resistenza pull-down

Le resistenze pull-down vengono utilizzate nei circuiti logici elettronici per garantire che gli ingressi ad Arduino si stabilizzino ai livelli logici previsti se i dispositivi esterni sono scollegati o sono ad alta impedenza. Poiché nulla è collegato a un pin di ingresso, non significa che sia uno zero logico. Le resistenze di pull down sono collegate tra la massa e il pin appropriato sul dispositivo.

Un esempio di una resistenza pull-down in un circuito digitale è mostrato nella figura seguente. Un interruttore a pulsante è collegato tra la tensione di alimentazione e un pin del microcontrollore. In tale circuito, quando l'interruttore è chiuso, l'ingresso del microcontrollore è a un valore logico alto, ma quando l'interruttore è aperto, il resistore di pull-down abbassa la tensione di ingresso a terra (valore logico zero), impedendo uno stato indefinito all'ingresso.

Il resistore di pull-down deve avere una resistenza maggiore dell'impedenza del circuito logico, altrimenti potrebbe abbassare troppo la tensione e la tensione di ingresso sul pin rimarrebbe a un valore logico basso costante, indipendentemente dalla posizione dell'interruttore.

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × scheda Arduino UNO
• 1 resistenza da 330 ohm
• 1 × 4.7K ohm resistore (pull down)
• 1 × LED

Procedura

Seguire lo schema elettrico ed effettuare i collegamenti come mostrato nell'immagine sotto riportata.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Codice Arduino

// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 8; // the number of the pushbutton pin
const int ledPin = 2; // the number of the LED pin
// variables will change:
int buttonState = 0; // variable for reading the pushbutton status

void setup() {
   // initialize the LED pin as an output:
   pinMode(ledPin, OUTPUT);
   // initialize the pushbutton pin as an input:
   pinMode(buttonPin, INPUT);
}

void loop() {
   // read the state of the pushbutton value:
   buttonState = digitalRead(buttonPin);
   // check if the pushbutton is pressed.
   // if it is, the buttonState is HIGH:
   if (buttonState == HIGH) {
      // turn LED on:
      digitalWrite(ledPin, HIGH);
   } else {
      // turn LED off:
      digitalWrite(ledPin, LOW);
   }
}

Codice da notare

Quando l'interruttore è aperto, (pulsante non premuto), non c'è collegamento tra i due terminali del pulsante, quindi il pin è collegato a massa (tramite la resistenza di pull-down) e si legge un LOW. Quando l'interruttore è chiuso (pulsante premuto), fa un collegamento tra i suoi due terminali, collegando il pin a 5 volt, in modo che leggiamo un ALTO.

Risultato

Il LED si accende quando si preme il pulsante e si spegne quando viene rilasciato.

In questo capitolo, interfacciamo diversi tipi di motori con la scheda Arduino (UNO) e ti mostreremo come collegare il motore e guidarlo dalla tua scheda.

Esistono tre diversi tipi di motori:

• motore a corrente continua
• Servomotore
• Motore passo-passo

Un motore CC (motore a corrente continua) è il tipo più comune di motore. I motori CC normalmente hanno solo due conduttori, uno positivo e uno negativo. Se colleghi questi due cavi direttamente a una batteria, il motore ruoterà. Se si cambiano i cavi, il motore ruoterà nella direzione opposta.

Warning- Non guidare il motore direttamente dai pin della scheda Arduino. Ciò potrebbe danneggiare la scheda. Usa un circuito driver o un circuito integrato.

Divideremo questo capitolo in tre parti:

• Basta far girare il motore
• Controllare la velocità del motore
• Controlla la direzione della rotazione del motore CC

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1x scheda Arduino UNO
• 1x transistor PN2222
• 1x piccolo motore da 6 V CC
• 1x diodo 1N4001
• 1x resistore da 270 Ω

Procedura

Seguire lo schema elettrico ed effettuare i collegamenti come mostrato nell'immagine sotto riportata.

Precauzioni

Adottare le seguenti precauzioni durante i collegamenti.

• Innanzitutto, assicurati che il transistor sia collegato nel modo giusto. Il lato piatto del transistor dovrebbe essere rivolto verso la scheda Arduino come mostrato nella disposizione.

• In secondo luogo, l'estremità a strisce del diodo dovrebbe essere verso la linea di alimentazione + 5V secondo la disposizione mostrata nell'immagine.

Spin Control Codice Arduino

int motorPin = 3;

void setup() {

}

void loop() {
   digitalWrite(motorPin, HIGH);
}

Codice da notare

Il transistor agisce come un interruttore, controllando l'alimentazione al motore. Il pin 3 di Arduino viene utilizzato per accendere e spegnere il transistor e nello schizzo viene assegnato il nome "motorPin".

Risultato

Il motore girerà a piena velocità quando il pin numero 3 di Arduino diventa alto.

Controllo della velocità del motore

Di seguito è riportato il diagramma schematico di un motore CC, collegato alla scheda Arduino.

Codice Arduino

int motorPin = 9;

void setup() {
   pinMode(motorPin, OUTPUT);
   Serial.begin(9600);
   while (! Serial);
   Serial.println("Speed 0 to 255");
}

void loop() {
   if (Serial.available()) {
      int speed = Serial.parseInt();
      if (speed >= 0 && speed <= 255) {
         analogWrite(motorPin, speed);
      }
   }
}

Codice da notare

Il transistor agisce come un interruttore, controllando la potenza del motore. Il pin 3 di Arduino viene utilizzato per accendere e spegnere il transistor e nello schizzo viene assegnato il nome "motorPin".

All'avvio del programma, viene richiesto di fornire i valori per controllare la velocità del motore. È necessario immettere un valore compreso tra 0 e 255 in Serial Monitor.

Nella funzione "loop", il comando "Serial.parseInt" viene utilizzato per leggere il numero inserito come testo nel monitor seriale e convertirlo in un "int". Puoi digitare qualsiasi numero qui. L'istruzione "if" nella riga successiva esegue semplicemente una scrittura analogica con questo numero, se il numero è compreso tra 0 e 255.

Risultato

Il motore CC girerà con velocità diverse in base al valore (da 0 a 250) ricevuto tramite la porta seriale.

Controllo della direzione di rotazione

Per controllare la direzione della rotazione del motore CC, senza scambiare i cavi, è possibile utilizzare un circuito chiamato H-Bridge. Un ponte ad H è un circuito elettronico che può guidare il motore in entrambe le direzioni. I ponti H sono utilizzati in molte applicazioni diverse. Una delle applicazioni più comuni è il controllo dei motori nei robot. Si chiama ponte H perché utilizza quattro transistor collegati in modo tale che il diagramma schematico assomigli a un "H."

Qui utilizzeremo il circuito integrato H-Bridge L298. L'L298 può controllare la velocità e la direzione dei motori CC e dei motori passo-passo e può controllare due motori contemporaneamente. La sua corrente nominale è di 2 A per ogni motore. A queste correnti, tuttavia, sarà necessario utilizzare dissipatori di calore.

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × L298 ponte IC
• 1 × motore CC
• 1 × Arduino UNO
• 1 × breadboard
• 10 × cavi jumper

Procedura

Di seguito è riportato il diagramma schematico dell'interfaccia del motore CC alla scheda Arduino Uno.

Il diagramma sopra mostra come collegare l'IC L298 per controllare due motori. Sono presenti tre pin di ingresso per ogni motore, Input1 (IN1), Input2 (IN2) e Enable1 (EN1) per Motor1 e Input3, Input4 e Enable2 per Motor2.

Poiché in questo esempio controlleremo solo un motore, collegheremo Arduino a IN1 (pin 5), IN2 (pin 7) e Enable1 (pin 6) dell'IC L298. I pin 5 e 7 sono digitali, ovvero ingressi ON o OFF, mentre il pin 6 necessita di un segnale modulato a larghezza di impulso (PWM) per controllare la velocità del motore.

La tabella seguente mostra in quale direzione girerà il motore in base ai valori digitali di IN1 e IN2.

IN 1	IN 2	Comportamento motorio
		FRENO
1		INOLTRARE
	1	INDIETRO
1	1	FRENO

Il pin IN1 dell'IC L298 è collegato al pin 8 di Arduino mentre IN2 è collegato al pin 9. Questi due pin digitali di Arduino controllano la direzione del motore. Il pin EN A di IC è collegato al pin PWM 2 di Arduino. Questo controllerà la velocità del motore.

Per impostare i valori dei pin 8 e 9 di Arduino, abbiamo utilizzato la funzione digitalWrite (), e per impostare il valore del pin 2 dobbiamo utilizzare la funzione analogWrite ().

Passaggi di connessione

• Collega 5 V e la massa dell'IC rispettivamente a 5 V e alla massa di Arduino.
• Collegare il motore ai pin 2 e 3 dell'IC.
• Collega IN1 dell'IC al pin 8 di Arduino.
• Collega IN2 dell'IC al pin 9 di Arduino.
• Collega EN1 di IC al pin 2 di Arduino.
• Collegare il pin SENS A dell'IC a terra.
• Collega Arduino utilizzando il cavo USB Arduino e carica il programma su Arduino utilizzando il software IDE Arduino.
• Fornisce alimentazione alla scheda Arduino tramite alimentatore, batteria o cavo USB.

Codice Arduino

const int pwm = 2 ; //initializing pin 2 as pwm
const int in_1 = 8 ;
const int in_2 = 9 ;
//For providing logic to L298 IC to choose the direction of the DC motor

void setup() {
   pinMode(pwm,OUTPUT) ; //we have to set PWM pin as output
   pinMode(in_1,OUTPUT) ; //Logic pins are also set as output
   pinMode(in_2,OUTPUT) ;
}

void loop() {
   //For Clock wise motion , in_1 = High , in_2 = Low
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,LOW) ;
   analogWrite(pwm,255) ;
   /* setting pwm of the motor to 255 we can change the speed of rotation
   by changing pwm input but we are only using arduino so we are using highest
   value to driver the motor */
   //Clockwise for 3 secs
   delay(3000) ;
   //For brake
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,HIGH) ;
   delay(1000) ;
   //For Anti Clock-wise motion - IN_1 = LOW , IN_2 = HIGH
   digitalWrite(in_1,LOW) ;
   digitalWrite(in_2,HIGH) ;
   delay(3000) ;
   //For brake
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,HIGH) ;
   delay(1000) ;
}

Risultato

Il motore funzionerà prima in senso orario (CW) per 3 secondi e poi in senso antiorario (CCW) per 3 secondi.

Un servomotore è un piccolo dispositivo che ha un albero di uscita. Questo albero può essere posizionato in posizioni angolari specifiche inviando al servo un segnale codificato. Finché il segnale codificato esiste sulla linea di ingresso, il servo manterrà la posizione angolare dell'albero. Se il segnale codificato cambia, la posizione angolare dell'albero cambia. In pratica, i servi vengono utilizzati negli aeroplani radiocomandati per posizionare le superfici di controllo come gli ascensori e i timoni. Sono anche usati in auto radiocomandate, pupazzi e, naturalmente, robot.

I servo sono estremamente utili nella robotica. I motori sono piccoli, hanno circuiti di controllo incorporati e sono estremamente potenti per le loro dimensioni. Un servo standard come il Futaba S-148 ha una coppia di 42 once / pollici, che è forte per le sue dimensioni. Assorbe anche potenza proporzionale al carico meccanico. Un servo leggermente caricato, quindi, non consuma molta energia.

Le viscere di un servomotore sono mostrate nella figura seguente. Puoi vedere i circuiti di controllo, il motore, un set di ingranaggi e il case. Puoi anche vedere i 3 fili che si collegano al mondo esterno. Uno è per alimentazione (+ 5 volt), terra e il filo bianco è il filo di controllo.

Funzionamento di un servomotore

Il servomotore ha alcuni circuiti di controllo e un potenziometro (un resistore variabile, noto anche come pot) collegato all'albero di uscita. Nella foto sopra, il vaso può essere visto sul lato destro del circuito. Questo potenziometro consente al circuito di controllo di monitorare l'angolo di corrente del servomotore.

Se l'albero è all'angolo corretto, il motore si spegne. Se il circuito rileva che l'angolo non è corretto, farà girare il motore fino a raggiungere l'angolo desiderato. L'albero di uscita del servo è in grado di viaggiare da qualche parte intorno a 180 gradi. Di solito, è da qualche parte nell'intervallo di 210 gradi, tuttavia, varia a seconda del produttore. Un servo normale viene utilizzato per controllare un movimento angolare da 0 a 180 gradi. Non è meccanicamente in grado di ruotare ulteriormente a causa di un arresto meccanico costruito sull'ingranaggio di uscita principale.

La potenza applicata al motore è proporzionale alla distanza che deve percorrere. Quindi, se l'albero deve ruotare per una grande distanza, il motore funzionerà a piena velocità. Se deve girare solo una piccola quantità, il motore funzionerà a una velocità inferiore. Questo è chiamatoproportional control.

Come si comunica l'angolo di rotazione del servo?

Il cavo di controllo viene utilizzato per comunicare l'angolo. L'angolo è determinato dalla durata di un impulso applicato al cavo di controllo. Questo è chiamatoPulse Coded Modulation. Il servo si aspetta di vedere un impulso ogni 20 millisecondi (0,02 secondi). La lunghezza dell'impulso determinerà di quanto gira il motore. Un impulso di 1,5 millisecondi, ad esempio, farà girare il motore nella posizione di 90 gradi (spesso chiamata posizione neutra). Se l'impulso è inferiore a 1,5 millisecondi, il motore ruoterà l'albero più vicino a 0 gradi. Se l'impulso è più lungo di 1,5 millisecondi, l'albero ruota più vicino a 180 gradi.

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × scheda Arduino UNO
• 1 × servomotore
• 1 × ULN2003 pilotaggio IC
• Resistore 1 × 10 KΩ

Procedura

Seguire lo schema elettrico ed effettuare i collegamenti come mostrato nell'immagine sotto riportata.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Codice Arduino

/* Controlling a servo position using a potentiometer (variable resistor) */

#include <Servo.h>
   Servo myservo; // create servo object to control a servo
   int potpin = 0; // analog pin used to connect the potentiometer
   int val; // variable to read the value from the analog pin

void setup() {
   myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
   val = analogRead(potpin);
   // reads the value of the potentiometer (value between 0 and 1023)
   val = map(val, 0, 1023, 0, 180);
   // scale it to use it with the servo (value between 0 and 180)
   myservo.write(val); // sets the servo position according to the scaled value
   delay(15);
}

Codice da notare

I servomotori hanno tre terminali: alimentazione, massa e segnale. Il cavo di alimentazione è tipicamente rosso e dovrebbe essere collegato al pin 5V su Arduino. Il filo di terra è generalmente nero o marrone e deve essere collegato a un terminale dell'IC ULN2003 (10-16). Per proteggere la tua scheda Arduino da eventuali danni, avrai bisogno di un driver IC per farlo. Qui abbiamo utilizzato l'IC ULN2003 per azionare il servomotore. Il pin del segnale è in genere giallo o arancione e deve essere collegato al pin numero 9 di Arduino.

Collegamento del potenziometro

Un partitore di tensione / divisore di potenziale sono resistori in un circuito in serie che ridimensionano la tensione di uscita a un particolare rapporto della tensione di ingresso applicata. Di seguito è riportato lo schema del circuito:

$$ V_ {out} = (V_ {in} \ times R_ {2}) / (R_ {1} + R_ {2}) $$

V _out è il potenziale di uscita, che dipende dalla tensione di ingresso applicata (V _in ) e dai resistori (R ₁ e R ₂ ) nella serie. Significa che la corrente che scorre attraverso R ₁ fluirà anche attraverso R ₂ senza essere divisa. Nell'equazione precedente, al variare del valore di R ₂ , V _{out si} ridimensiona di conseguenza rispetto alla tensione di ingresso, V _in .

Tipicamente, un potenziometro è un potenziale divisore, che può scalare la tensione di uscita del circuito in base al valore del resistore variabile, che viene scalato utilizzando la manopola. Ha tre pin: GND, Segnale e + 5V come mostrato nello schema seguente -

Risultato

Modificando la posizione NOP della pentola, il servomotore cambierà il suo angolo.

Un motore passo-passo o un motore passo-passo è un motore sincrono senza spazzole, che divide una rotazione completa in un numero di passaggi. A differenza di un motore CC senza spazzole, che ruota continuamente quando viene applicata una tensione CC fissa, un motore passo-passo ruota con angoli di passo discreti.

I motori passo-passo sono quindi prodotti con passi per giro di 12, 24, 72, 144, 180 e 200, con angoli di passo di 30, 15, 5, 2,5, 2 e 1,8 gradi per passo. Il motore passo-passo può essere controllato con o senza feedback.

Immagina un motore su un aeroplano RC. Il motore gira molto velocemente in una direzione o nell'altra. È possibile variare la velocità con la quantità di potenza fornita al motore, ma non è possibile dire all'elica di fermarsi in una posizione specifica.

Ora immagina una stampante. Ci sono molte parti mobili all'interno di una stampante, inclusi i motori. Uno di questi motori funge da alimentazione della carta, ruotando i rulli che muovono il pezzo di carta mentre l'inchiostro viene stampato su di esso. Questo motore deve essere in grado di spostare la carta di una distanza esatta per poter stampare la riga di testo successiva o la riga successiva di un'immagine.

C'è un altro motore collegato a un'asta filettata che sposta la testina di stampa avanti e indietro. Ancora una volta, quella barra filettata deve essere spostata di una quantità esatta per stampare una lettera dopo l'altra. È qui che tornano utili i motori passo-passo.

Come funziona un motore passo-passo?

Un normale motore a corrente continua gira nella sola direzione mentre un motore passo-passo può ruotare con incrementi precisi.

I motori passo-passo possono ruotare di una quantità esatta di gradi (o passi) come desiderato. Questo ti dà il controllo totale sul motore, permettendoti di spostarlo in una posizione esatta e mantenere quella posizione. Lo fa alimentando le bobine all'interno del motore per periodi di tempo molto brevi. Lo svantaggio è che devi alimentare il motore tutto il tempo per mantenerlo nella posizione che desideri.

Tutto quello che devi sapere per ora è che, per muovere un motore passo-passo, gli dici di muovere un certo numero di passi in una direzione o nell'altra e gli dici la velocità alla quale camminare in quella direzione. Esistono numerose varietà di motori passo-passo. I metodi qui descritti possono essere utilizzati per dedurre come utilizzare altri motori e driver non menzionati in questo tutorial. Tuttavia, è sempre consigliabile consultare le schede tecniche e le guide dei motori e dei driver specifici per i modelli che possiedi.

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × scheda Arduino UNO
• 1 × piccolo motore passo-passo bipolare come mostrato nell'immagine sotto
• 1 × LM298 guida IC

Procedura

Seguire lo schema elettrico ed effettuare i collegamenti come mostrato nell'immagine sotto riportata.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Codice Arduino

/* Stepper Motor Control */

#include <Stepper.h>
const int stepsPerRevolution = 90;
// change this to fit the number of steps per revolution
// for your motor
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

void setup() {
   // set the speed at 60 rpm:
   myStepper.setSpeed(5);
   // initialize the serial port:
   Serial.begin(9600);
}

void loop() {
   // step one revolution in one direction:
   Serial.println("clockwise");
   myStepper.step(stepsPerRevolution);
   delay(500);
   // step one revolution in the other direction:
   Serial.println("counterclockwise");
   myStepper.step(-stepsPerRevolution);
   delay(500);
}

Codice da notare

Questo programma aziona un motore passo-passo unipolare o bipolare. Il motore è collegato ai pin digitali 8-11 di Arduino.

Risultato

Il motore farà un giro in una direzione, poi un giro nell'altra direzione.

In questo capitolo useremo la libreria Arduino Tone. Non è altro che una libreria Arduino, che produce un'onda quadra di una frequenza specificata (e un ciclo di lavoro del 50%) su qualsiasi pin Arduino. Opzionalmente è possibile specificare una durata, altrimenti l'onda continua finché non viene chiamata la funzione stop (). Il pin può essere collegato a un cicalino piezo o un altoparlante per riprodurre i toni.

Warning- Non collegare il pin direttamente a nessun ingresso audio. La tensione è notevolmente superiore alle tensioni a livello di linea standard e può danneggiare gli ingressi della scheda audio, ecc. È possibile utilizzare un partitore di tensione per abbassare la tensione.

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 altoparlante da 8 ohm
• Resistenza 1 × 1k
• 1 × scheda Arduino UNO

Procedura

Seguire lo schema elettrico ed effettuare i collegamenti come mostrato nell'immagine sotto riportata.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Per creare il file pitches.h, fai clic sul pulsante appena sotto l'icona del monitor seriale e scegli "Nuova scheda", oppure usa Ctrl + Maiusc + N.

Quindi incolla il seguente codice:

/*************************************************
* Public Constants
*************************************************/

#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978

Salva il codice sopra indicato come pitches.h

Codice Arduino

#include "pitches.h"
// notes in the melody:
int melody[] = {
NOTE_C4, NOTE_G3,NOTE_G3, NOTE_GS3, NOTE_G3,0, NOTE_B3, NOTE_C4};
// note durations: 4 = quarter note, 8 = eighth note, etc.:

int noteDurations[] = {
   4, 8, 8, 4,4,4,4,4 
};

void setup() {
   // iterate over the notes of the melody:
   for (int thisNote = 0; thisNote < 8; thisNote++) {
      // to calculate the note duration, take one second
      // divided by the note type.
      //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
      int noteDuration = 1000/noteDurations[thisNote];
      tone(8, melody[thisNote],noteDuration);
      //pause for the note's duration plus 30 ms:
      delay(noteDuration +30);
   }
}

void loop() {
   // no need to repeat the melody.
}

Codice da notare

Il codice utilizza un file aggiuntivo, pitches.h. Questo file contiene tutti i valori di altezza per le note tipiche. Ad esempio, NOTE_C4 è il Do centrale NOTE_FS4 è il fa diesis e così via. Questa tabella delle note è stata originariamente scritta da Brett Hagman, sul cui lavoro è stato basato il comando tone (). Potresti trovarlo utile ogni volta che desideri creare note musicali.

Risultato

Ascolterai le note musicali salvate nelle piazzole. H. file.

I moduli trasmettitore e ricevitore wireless funzionano a 315 Mhz. Possono facilmente adattarsi a una breadboard e funzionare bene con i microcontrollori per creare un collegamento dati wireless molto semplice. Con una coppia di trasmettitore e ricevitore, i moduli funzioneranno solo comunicando dati unidirezionali, tuttavia, sarebbero necessarie due coppie (di frequenze diverse) per fungere da coppia trasmettitore / ricevitore.

Note- Questi moduli sono indiscriminati e ricevono una discreta quantità di rumore. Sia il trasmettitore che il ricevitore funzionano a frequenze comuni e non hanno ID.

Specifiche del modulo ricevitore

• Modello prodotto - MX-05V
• Tensione di esercizio - DC5V
• Corrente di riposo: 4 mA
• Frequenza di ricezione - 315 Mhz
• Sensibilità del ricevitore: -105 dB
• Dimensioni: 30 x 14 x 7 mm

Specifiche del modulo trasmettitore

• Modello prodotto - MX-FS-03V
• Distanza di lancio: 20-200 metri (tensione diversa, risultati diversi)
• Tensione di esercizio: 3,5-12 V.
• Dimensioni: 19 x 19 mm
• Modalità operativa - AM
• Velocità di trasferimento - 4KB / S
• Potenza di trasmissione: 10 mW
• Frequenza di trasmissione - 315 Mhz
• Un'antenna esterna: linea multi-core o single-core da 25 cm
• Pinout da sinistra a destra - (DATA; V _CC ; GND)

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• Scheda 2 × Arduino UNO
• 1 × trasmettitore di collegamento Rf
• 1 × ricevitore di collegamento Rf

Procedura

Seguire lo schema elettrico ed effettuare i collegamenti come mostrato nell'immagine sotto riportata.

Schizzo

Apri il software IDE Arduino sul tuo computer. La codifica nella lingua Arduino controllerà il tuo circuito. Aprire un nuovo file di schizzo facendo clic su Nuovo.

Note- È necessario includere la libreria della tastiera nel file della libreria Arduino. Copia e incolla il file VirtualWire.lib nella cartella delle librerie come evidenziato nello screenshot riportato di seguito.

Codice Arduino per trasmettitore

//simple Tx on pin D12
#include <VirtualWire.h>
char *controller;

void setup() {
   pinMode(13,OUTPUT);
   vw_set_ptt_inverted(true);
   vw_set_tx_pin(12);
   vw_setup(4000);// speed of data transfer Kbps
}

void loop() {
   controller="1" ;
   vw_send((uint8_t *)controller, strlen(controller));
   vw_wait_tx(); // Wait until the whole message is gone
   digitalWrite(13,1);
   delay(2000);
   controller="0" ;
   vw_send((uint8_t *)controller, strlen(controller));
   vw_wait_tx(); // Wait until the whole message is gone
   digitalWrite(13,0);
   delay(2000);
}

Codice da notare

Questo è un codice semplice. In primo luogo, invierà il carattere "1" e dopo due secondi invierà il carattere "0" e così via.

Codice Arduino per ricevitore

//simple Rx on pin D12
#include <VirtualWire.h>

void setup() {
   vw_set_ptt_inverted(true); // Required for DR3100
   vw_set_rx_pin(12);
   vw_setup(4000); // Bits per sec
   pinMode(5, OUTPUT);
   vw_rx_start(); // Start the receiver PLL running
}

void loop() {
   uint8_t buf[VW_MAX_MESSAGE_LEN];
   uint8_t buflen = VW_MAX_MESSAGE_LEN;
   if (vw_get_message(buf, &buflen)) // Non-blocking {
      if(buf[0]=='1') {
         digitalWrite(5,1);
      }
      if(buf[0]=='0') {
         digitalWrite(5,0);
      }
   }
}

Codice da notare

Il LED collegato al pin numero 5 sulla scheda Arduino si accende quando viene ricevuto il carattere "1" e si spegne quando viene ricevuto il carattere "0".

Il modulo WiFi CC3000 di Texas Instruments è un piccolo pacchetto argento, che finalmente offre funzionalità WiFi facili da usare e convenienti ai tuoi progetti Arduino.

Utilizza SPI per la comunicazione (non UART!) In modo da poter inviare i dati alla velocità che vuoi o lentamente come vuoi. Ha un corretto sistema di interruzione con pin IRQ in modo da poter avere connessioni asincrone. Supporta 802.11b / g, sicurezza aperta / WEP / WPA / WPA2, TKIP e AES. Uno stack TCP / IP integrato con un'interfaccia "socket BSD" supporta TCP e UDP sia in modalità client che in modalità server.

Componenti richiesti

Avrai bisogno dei seguenti componenti:

• 1 × Arduino Uno
• 1 × scheda breakout Adafruit CC3000
• Relè 1 × 5V
• 1 × diodo raddrizzatore
• 1 × LED
• 1 resistenza da 220 Ohm
• 1 × Breadboard e alcuni cavi jumper

Per questo progetto, hai solo bisogno del solito IDE Arduino, della libreria CC3000 di Adafruit e della libreria MDNS CC3000. Utilizzeremo anche la libreria aREST per inviare comandi al relè tramite WiFi.

Procedura

Seguire lo schema elettrico ed effettuare i collegamenti come mostrato nell'immagine sotto riportata.

La configurazione hardware per questo progetto è molto semplice.

• Collega il pin IRQ della scheda CC3000 al pin numero 3 della scheda Arduino.
• VBAT al pin 5 e CS al pin 10.
• Collega i pin SPI alla scheda Arduino: MOSI, MISO e CLK rispettivamente ai pin 11, 12 e 13.
• V _in è collegato ad Arduino 5V e GND a GND.

Colleghiamo ora il relè.

Dopo aver posizionato il relè sulla breadboard, puoi iniziare a identificare le due parti importanti del tuo relè: la parte della bobina che comanda il relè e la parte dell'interruttore a cui collegheremo il LED.

• Innanzitutto, collega il pin numero 8 della scheda Arduino a un pin della bobina.
• Collega l'altro pin alla massa della scheda Arduino.

È inoltre necessario posizionare il diodo raddrizzatore (anodo collegato al pin di terra) sui pin della bobina per proteggere il circuito quando il relè sta commutando.

• Collega il + 5V della scheda Arduino al pin comune dell'interruttore del relè.

• Infine, collega uno degli altri pin dell'interruttore (solitamente, quello che non è collegato quando il relè è spento) al LED in serie con la resistenza da 220 Ohm, e collega l'altro lato del LED alla massa di Arduino tavola.

Testare i singoli componenti

Puoi testare il relè con il seguente schizzo:

const int relay_pin = 8; // Relay pin

void setup() {
   Serial.begin(9600);
   pinMode(relay_pin,OUTPUT);
}

void loop() {
   // Activate relay
   digitalWrite(relay_pin, HIGH);
   // Wait for 1 second
   delay(1000);
   // Deactivate relay
   digitalWrite(relay_pin, LOW);
   // Wait for 1 second
   delay(1000);
}

Codice da notare

Il codice è autoesplicativo. Puoi semplicemente caricarlo sulla scheda e il relè cambierà stato ogni secondo e il LED si accenderà e spegnerà di conseguenza.

Aggiunta di connettività WiFi

Controlliamo ora il relè in modalità wireless utilizzando il chip WiFi CC3000. Il software per questo progetto si basa sul protocollo TCP. Tuttavia, per questo progetto, la scheda Arduino eseguirà un piccolo server web, quindi possiamo "ascoltare" i comandi provenienti dal computer. Ci occuperemo prima dello sketch di Arduino, poi vedremo come scrivere il codice lato server e creare una bella interfaccia.

Innanzitutto, lo schizzo di Arduino. L'obiettivo qui è connettersi alla rete WiFi, creare un server Web, verificare se ci sono connessioni TCP in entrata e quindi modificare di conseguenza lo stato del relè.

Parti importanti del codice

#include <Adafruit_CC3000.h>
#include <SPI.h>
#include <CC3000_MDNS.h>
#include <Ethernet.h>
#include <aREST.h>

Devi definire all'interno del codice cosa è specifico della tua configurazione, cioè nome e password Wi-Fi, e la porta per le comunicazioni TCP (abbiamo usato 80 qui).

// WiFi network (change with your settings!)
   #define WLAN_SSID "yourNetwork" // cannot be longer than 32 characters!
   #define WLAN_PASS "yourPassword"
   #define WLAN_SECURITY WLAN_SEC_WPA2 // This can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, 
   // WLAN_SEC_WPA or WLAN_SEC_WPA2

// The port to listen for incoming TCP connections
   #define LISTEN_PORT 80

Possiamo quindi creare l'istanza CC3000, il server e un'istanza REST -

// Server instance
   Adafruit_CC3000_Server restServer(LISTEN_PORT); // DNS responder instance
   MDNSResponder mdns; // Create aREST instance
   aREST rest = aREST();

Nella parte setup () dello schizzo, ora possiamo collegare il chip CC3000 alla rete -

cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY);

Come farà il computer a sapere dove inviare i dati? Un modo sarebbe eseguire lo schizzo una volta, quindi ottenere l'indirizzo IP della scheda CC3000 e modificare nuovamente il codice del server. Tuttavia, possiamo fare di meglio, ed è qui che entra in gioco la libreria MDNS CC3000. Assegneremo un nome fisso alla nostra scheda CC3000 con questa libreria, così possiamo annotare questo nome direttamente nel codice del server.

Questo viene fatto con il seguente pezzo di codice:

if (!mdns.begin("arduino", cc3000)) {
   while(1);
}

Dobbiamo anche ascoltare le connessioni in entrata.

restServer.begin();

Successivamente, codificheremo la funzione loop () dello schizzo che verrà eseguito continuamente. Per prima cosa dobbiamo aggiornare il server mDNS.

mdns.update();

Il server in esecuzione sulla scheda Arduino attenderà le connessioni in entrata e gestirà le richieste.

Adafruit_CC3000_ClientRef client = restServer.available();
rest.handle(client);

Ora è abbastanza facile testare i progetti tramite WiFi. Assicurati di aver aggiornato lo schizzo con il tuo nome WiFi e password e carica lo schizzo sulla tua scheda Arduino. Apri il tuo monitor seriale IDE Arduino e cerca l'indirizzo IP della tua scheda.

Supponiamo per il resto che sia qualcosa come 192.168.1.103.

Quindi, vai semplicemente al tuo browser web preferito e digita -

192.168.1.103/digital/8/1

Dovresti vedere che il tuo relè si attiva automaticamente.

Costruzione dell'interfaccia di inoltro

Ora codificheremo l'interfaccia del progetto. Ci saranno due parti qui: un file HTML contenente l'interfaccia e un file Javascript lato client per gestire i clic sull'interfaccia. L'interfaccia qui è basata suaREST.js progetto, che è stato creato per controllare facilmente i dispositivi WiFi dal tuo computer.

Vediamo prima il file HTML, chiamato interface.html. La prima parte consiste nell'importare tutte le librerie richieste per l'interfaccia -

<head>
   <meta charset = utf-8 />
   <title> Relay Control </title>
   <link rel = "stylesheet" type = "text/css" 
      href = "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css">
   <link rel="stylesheet" type = "text/css" href = "style.css">
   <script type = "text/javascript" 
      src = "https://code.jquery.com/jquery-2.1.4.min.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/Foliotek/AjaxQ/master/ajaxq.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/marcoschwartz/aREST.js/master/aREST.js"></script>
   <script type = "text/javascript" 
      src = "script.js"></script>
</head>

Quindi, definiamo due pulsanti all'interno dell'interfaccia, uno per accendere il relè e l'altro per spegnerlo di nuovo.

<div class = 'container'>
   <h1>Relay Control</h1>
   <div class = 'row'>
      <div class = "col-md-1">Relay</div>
      <div class = "col-md-2">
         <button id = 'on' class = 'btn btn-block btn-success'>On</button>
      </div>
      <div class = "col-md-2">
         <button id = 'off' class = 'btn btn-block btn-danger'>On</button>
      </div>
   </div>
</div>

Ora, abbiamo anche bisogno di un file Javascript lato client per gestire i clic sui pulsanti. Creeremo anche un dispositivo che collegheremo al nome mDNS del nostro dispositivo Arduino. Se lo hai modificato nel codice Arduino, dovrai modificarlo anche qui.

// Create device
var device = new Device("arduino.local");
// Button

$('#on').click(function() {
   device.digitalWrite(8, 1);
});

$('#off').click(function() {
   device.digitalWrite(8, 0);
});

Il codice completo per questo progetto può essere trovato su GitHubrepository. Vai nella cartella dell'interfaccia e apri semplicemente il file HTML con il tuo browser preferito. Dovresti vedere qualcosa di simile all'interno del tuo browser -

Prova a fare clic su un pulsante nell'interfaccia web; dovrebbe cambiare lo stato del relè quasi istantaneamente.

Se sei riuscito a farlo funzionare, bravo! Hai appena costruito un interruttore della luce controllato tramite Wi-Fi. Certo, puoi controllare molto di più delle luci con questo progetto. Assicurati solo che il tuo relè supporti la potenza richiesta per il dispositivo che desideri controllare e sei a posto.