Comandi Arduino in russo. Programmazione di Arduino in C in AVR Studio

Il linguaggio di programmazione Arduino per principianti è presentato in dettaglio nella tabella seguente. Microcontrollore Arduino programmabile su linguaggio speciale programmazione basata su C/C++. Il linguaggio di programmazione Arduino è una variante del C++, in altre parole non esiste un linguaggio di programmazione separato per Arduino. Scaricamento libro PDF possibile alla fine della pagina.

IN IDE di Arduino tutti gli schizzi scritti vengono compilati in un programma in C/C++ con modifiche minime. Il compilatore IDE di Arduino semplifica notevolmente la scrittura di programmi per questa piattaforma e la creazione di dispositivi su Arduino diventa molto più accessibile a persone che non hanno una conoscenza approfondita del linguaggio C/C++. Diamo oltre una piccola informazione con la descrizione delle principali funzioni Linguaggio Arduino con esempi.

Riferimento dettagliato al linguaggio Arduino

Il linguaggio può essere diviso in quattro sezioni: istruzioni, dati, funzioni e librerie.

Nella vita di uno sviluppatore Arduino, prima o poi arriva il momento in cui l’ambiente di sviluppo standard diventa affollato. Se gli schizzi non hanno più memoria sufficiente, avete bisogno di tempo reale e lavorate con interruzioni, o volete semplicemente essere più vicini all'hardware, allora è il momento di passare a C. Gli ingegneri elettronici esperti aggrotteranno le sopracciglia con disprezzo alla menzione di Arduino e invieranno il principiante in un negozio di radio per un saldatore. Questo potrebbe non essere il peggior consiglio, ma non lo seguiremo per ora. Se scartiamo l'IDE di Arduino e il linguaggio di cablaggio/elaborazione, ci ritroviamo con un'ottima scheda di debug, già dotata di tutto il necessario per il funzionamento del microcontrollore. E, cosa più importante, un bootloader è già cablato nella memoria del controller, consentendoti di caricare il firmware senza utilizzare un programmatore.

Per programmare in C, abbiamo bisogno di AVR GCC Toolchain.

Avremo bisogno anche dell'IDE Arduino installato, perché... contiene l'utilità avrdude, necessaria per scaricare il firmware sul controller. CrossPack contiene anche avrdude, ma la versione fornita con esso non funziona con Arduino.

Dopo aver installato tutto, creiamo il nostro primo progetto. Per cominciare, scriviamo Makefile. Ci consentirà di evitare di inserire manualmente lunghi comandi ogni volta che compiliamo e carichiamo il firmware.

#Controller installato sulla scheda. Potrebbe essere diverso, ad esempio atmega328 DEVICE = atmega168 #Frequenza clock 16 MHz CLOCK = 16000000 #Avrdude comando di avvio. Deve essere copiato dall'IDE di Arduino. AVRDUDE = /Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/avrdude -C/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/etc/avrdude.conf -carduino -P/dev/tty.usbserial-A600dAAQ -b19200 -D -p atmega168 OBJECTS = main.o COMPILE = avr-gcc -Wall -Os -DF_CPU=$(CLOCK) -mmcu=$(DISPOSITIVO) all: main .hex .c.o: $(COMPILE) -c $< -o $@ .S.o: $(COMPILE) -x assembler-with-cpp -c $< -o $@ .c.s: $(COMPILE) -S $< -o $@ flash: all $(AVRDUDE) -U flash:w:main.hex:i clean: rm -f main.hex main.elf $(OBJECTS) main.elf: $(OBJECTS) $(COMPILE) -o main.elf $(OBJECTS) main.hex: main.elf rm -f main.hex avr-objcopy -j .text -j .data -O ihex main.elf main.hex avr-size --format=avr --mcu=$(DEVICE) main.elf

In questo file dobbiamo inserire il nostro comando per avviare avrdude. Avrà un aspetto diverso su sistemi diversi. Per scoprire la tua opzione, avvia l'IDE Arduino e seleziona la casella "Mostra output dettagliato durante il caricamento" nelle impostazioni.

Ora carichiamo qualsiasi schizzo in Arduino e guardiamo i messaggi visualizzati nella parte inferiore della finestra. Troviamo lì la chiamata avrdude, copiamo tutto tranne il parametro -Uflash e lo incolliamo nel Makefile dopo “AVRDUDE = “.

Una breve nota: tutti i rientri nel Makefile vengono eseguiti con caratteri di tabulazione (tasto Tab). Se il tuo editor di testo sostituisce questi caratteri con spazi, il comando make rifiuterà di compilare il progetto.

Ora creiamo un file principale.c- il testo vero e proprio del nostro programma, in cui tradizionalmente facciamo lampeggiare il LED.

#includere #includere #define LED_PIN 5 int main() ( DDRB |= 1<< LED_PIN; while(1) { PORTB |= 1 << LED_PIN; _delay_ms(1000); PORTB &= ~(1 << LED_PIN); _delay_ms(1000); } return 0; }

Il nostro progetto è pronto. Apriamo la console nella directory del nostro progetto e inseriamo il comando "make":

Come puoi vedere, la dimensione del firmware risultante è di soli 180 byte. Uno schizzo simile di Arduino occupa 1116 byte nella memoria del controller.

Ora torniamo alla console e inseriamo "make flash" per caricare il file compilato nel controller:

Se il download è stato completato senza errori, il LED collegato al pin 13 della scheda lampeggerà allegramente. A volte avrdude non riesce a trovare la scheda o cade a causa di un timeout: in questo caso, torcere il cavo USB può aiutare. Inoltre, per evitare conflitti di accesso alla scheda, non dimenticare di chiudere l'IDE di Arduino prima del comando “make flash”.

Forse molte delle cose descritte in questo articolo sembreranno ovvie agli sviluppatori esperti. Ho cercato di descrivere il processo in un linguaggio il più comprensibile possibile per un utente Arduino alle prime armi e di raccogliere in un unico posto le informazioni che sono riuscito a ottenere da varie fonti e verificare empiricamente. Forse questo articolo farà risparmiare a qualcuno un paio d'ore di tempo.

Buona fortuna nel padroneggiare i microcontrollori!

Arduino è una scheda di sviluppo pronta all'uso e un linguaggio di programmazione molto semplice che semplifica l'avvio con i microcontrollori a discapito delle dimensioni e della velocità del programma. Recentemente Atmel ha aggiunto in AVR Studio il supporto per il bootloader Arduino, ovvero puoi scrivere e caricare programmi scritti in C, C++ o Assembler senza programmatore. Inoltre, puoi scrivere codice nel linguaggio di elaborazione/cablaggio in AVR Studio.
Consiglio di iniziare a leggere l'articolo con l'aggiornamento alla fine!
In questo articolo forniamo istruzioni dettagliate per l'installazione del software di programmazione Arduino utilizzando AVR Studio. Abbiamo preso come base una recensione delle estensioni AVR Studio dal sito easyelectronics.ru. Eseguiremo tutti gli esempi sulla nostra scheda.

Installazione dell'IDE di Arduino

Stiamo utilizzando la versione 1.5.2 di Arduino. Puoi scaricarlo sul sito ufficiale. L'ultima versione (1.6.2-r2 al momento in cui scrivo) per qualche motivo non funziona con il microcontrollore Atmega8.
Scaricherai un archivio zip con l'ambiente già distribuito. Non resta che decomprimerlo nella directory del programma.

Installazione di AtmelStudio

AGGIORNAMENTO

Vedo che l'argomento è popolare e voglio chiarire alcuni punti.
Ci sono tre modi in cui ho provato a programmare una scheda compatibile con Arduino in C:

1. Scrivi direttamente nell'IDE di Arduino in C. Devi capire che Processing/Wiring non è un linguaggio, ma semplicemente un insieme di macro e librerie. Quando ci scrivi, guarda nelle sue intestazioni, converte il tuo codice leggibile dall'uomo in C e poi compila con il compilatore AVR GCC standard. Se scrivi codice in C, non accederà alle sue librerie e compilerà immediatamente tutto come dovrebbe, MA!... allo stesso tempo, il linker aggiungerà al tuo progetto quello che vuole. Il vantaggio è che non hai bisogno di altro che dell’IDE ​​Arduino. Lo svantaggio è la magia, che è nascosta allo sviluppatore. Questo metodo viene spesso utilizzato nei casi in cui è necessario implementare una funzione che i nostri amici italiani non prevedevano nella loro lingua.
2. Il metodo proposto in questo articolo (in effetti, il più strano, perché unisce tutte le carenze). Ideologicamente, questa estensione è necessaria per programmare in Processing/Wiring e utilizzare Atmel Studio come interfaccia. Esiste anche una funzionalità a pagamento che consente di eseguire il debug del codice, ma non l'ho provata. Quindi, in sostanza, durante la programmazione, tutto avviene come nella prima opzione, ma lavori in un IDE diverso. Allo stesso tempo, dal punto di vista del risultato, ottieni la stessa cosa. Se hai programmato Arduino e hai deciso di farlo in C, sentiti libero di scrivere direttamente all'IDE di Arduino. Se non ti piace l'interfaccia, puoi utilizzare un normale editor (ti consiglio Sublime Text). Se lavori in Atnel Studio e desideri eseguire il flashing della tua scheda direttamente dalla sua interfaccia o scriverci Elaborazione/Cablaggio (all'improvviso!), allora questo componente aggiuntivo fa per te. A proposito, lo studio funziona solo su Windows, cioè il metodo non è per tutti. Ho scritto questo articolo solo perché ho trovato un nuovo metodo per me stesso, ma non mi piace.
3. Il terzo metodo, mi sembra, è il migliore per un utente avanzato. All'inizio tutto avviene come al solito: scrivi il codice, lo compili e ottieni un file esadecimale. Quindi, ricordando che hai una normale scheda di debug con un bootloader tra le mani, scarica un'utilità in grado di accedere a questo bootloader e trasferire il tuo codice in memoria. Abbiamo già pubblicato le istruzioni passo passo. In questo caso, lo sviluppatore riceve il massimo controllo su tutte le funzioni, ma potrebbero sorgere problemi dovuti all'utilizzo di un bootloader di terze parti.

Vorrei rivelare un'altra cosa che succede in Arduino. Qualunque cosa tu faccia, l'IDE di Arduino accenderà sicuramente le periferiche stesse. Ad esempio, avvierà i timer. E se vuoi lavorarci in C, potresti scoprire che non funzionano come ti aspettavi. E questo può diventare un vero problema. E ci sono molti di questi esempi, cioè ci sono molti potenziali rastrelli, stampelle e insetti.
Se carichi semplicemente un file esadecimale, i problemi possono sorgere solo a causa del bootloader. Finora ne ho trovato solo uno: una volta completato il bootloader, l'UART rimane abilitato. Se scrivi tramite l'IDE di Arduino, verrà inserito nel tuo codice per disabilitarlo e chissà cos'altro. Se vuoi solo eseguire il tuo esagono, non avrai il controllo sulle gambe UART. Dovrai aggiungere manualmente una disabilitazione UART al tuo progetto. Questo artefatto e gli esempi di codice sono descritti in dettaglio in .
Bene, in conclusione. La maggior parte delle schede compatibili con Arduino dispongono di un connettore per un programmatore ISP. Se acquisti questo programmatore dai cinesi per 3-4 dollari, dimenticherai presto tutti questi problemi.

Saremo molto lieti se sosterrai la nostra risorsa e visiterai il nostro negozio di prodotti.

Ciao! Sono Alikin Alexander Sergeevich, insegnante di istruzione aggiuntiva, dirigo i club "Robotica" e "Ingegneria radiofonica" presso il Centro per la gioventù e la tecnologia giovanile di Labinsk. Vorrei parlare un po' di un metodo semplificato per programmare Arduino utilizzando il programma ArduBlock.

Ho introdotto questo programma nel processo educativo e sono soddisfatto del risultato, è molto richiesto dai bambini, soprattutto quando si scrivono programmi semplici o si creano alcune fasi iniziali di programmi complessi. ArduBlock è un ambiente di programmazione grafico, ovvero tutte le azioni vengono eseguite con immagini disegnate con azioni firmate in russo, il che semplifica notevolmente l'apprendimento della piattaforma Arduino. Grazie a questo programma i bambini a partire dalla seconda elementare potranno facilmente padroneggiare il lavoro con Arduino.

Sì, qualcuno potrebbe dire che Scratch esiste ancora ed è anche un ambiente grafico molto semplice per programmare Arduino. Ma Scratch non esegue il flashing di Arduino, ma lo controlla solo tramite un cavo USB. Arduino dipende dal computer e non può funzionare in modo autonomo. Quando crei i tuoi progetti, l'autonomia è la cosa principale per Arduino, soprattutto quando crei dispositivi robotici.

Anche i famosi robot LEGO, come NXT o EV3, non sono più così interessanti per i nostri studenti con l'avvento del programma ArduBlock nella programmazione Arduino. Arduino è anche molto più economico di qualsiasi kit di costruzione LEGO e molti componenti possono essere semplicemente presi dai vecchi elettrodomestici. Il programma ArduBlock aiuterà non solo i principianti, ma anche gli utenti attivi della piattaforma Arduino.

Allora, cos'è ArduBlock? Come ho già detto, questo è un ambiente di programmazione grafica. Quasi completamente tradotto in russo. Ma il punto forte di ArduBlock non è solo questo, ma anche il fatto che il programma ArduBlock che abbiamo scritto si converte in codice IDE Arduino. Questo programma è integrato nell'ambiente di programmazione IDE di Arduino, ovvero è un plug-in.

Di seguito è riportato un esempio di un LED lampeggiante e di un programma convertito nell'IDE Arduino. Tutto il lavoro con il programma è molto semplice e qualsiasi studente può capirlo.

Come risultato del lavoro con il programma, non solo puoi programmare Arduino, ma anche studiare comandi che non comprendiamo nel formato testo dell'IDE di Arduino, ma se sei troppo pigro per scrivere comandi standard, puoi utilizzare rapidamente il mouse per abbozzare un semplice programma in ArduBlok ed eseguirne il debug nell'IDE di Arduino.

Per installare ArduBlok, devi prima scaricare e installare l'IDE Arduino dal sito Web ufficiale di Arduino e comprendere le impostazioni quando lavori con la scheda Arduino UNO. Come farlo è descritto sullo stesso sito web o su Amperka, oppure guardalo su YouTube. Bene, una volta capito tutto questo, devi scaricare ArduBlok dal sito ufficiale, qui. Non consiglio di scaricare le versioni più recenti, sono molto complicate per i principianti, ma la versione del 12-07-2013 è la migliore, questo file è il più popolare lì.

Quindi, rinomina il file scaricato in ardublock-all e nella cartella "documenti". Creiamo le seguenti cartelle: Arduino > tools > ArduBlockTool > tool e in quest'ultima gettiamo il file scaricato e rinominato. ArduBlok funziona su tutti i sistemi operativi, anche su Linux, l'ho testato personalmente su XP, Win7, Win8, tutti gli esempi sono per Win7. L'installazione del programma è la stessa per tutti i sistemi.

Bene, per dirla semplicemente, ho preparato un archivio sul disco 7z Mail, spacchettandolo troverai 2 cartelle. In una c'è già un programma IDE Arduino funzionante, e nell'altra cartella il contenuto deve essere inviato alla cartella documenti.

Per lavorare in ArduBlok, è necessario eseguire l'IDE Arduino. Quindi andiamo alla scheda Strumenti e lì troviamo l'elemento ArduBlok, facciamo clic su di esso - ed eccolo qui, il nostro obiettivo.

Ora diamo un'occhiata all'interfaccia del programma. Come già capisci, non ci sono impostazioni, ma ci sono molte icone per la programmazione e ognuna di esse porta un comando in formato testo IDE Arduino. Le nuove versioni hanno ancora più icone, quindi comprendere l'ultima versione di ArduBlok è difficile e alcune icone non sono tradotte in russo.

Nella sezione "Gestione" troveremo una varietà di cicli.

Nella sezione “Porte” possiamo gestire i valori delle porte, nonché l'emettitore sonoro, il servo o il sensore di prossimità a ultrasuoni ad esse collegati.

Nella sezione “Numeri/Costanti” possiamo selezionare valori digitali o creare una variabile, ma difficilmente utilizzerai quanto riportato di seguito.

Nella sezione “Operatori” troveremo tutti gli operatori di confronto e calcolo necessari.

La sezione Utilità utilizza principalmente icone temporizzate.

"TinkerKit Bloks" è la sezione per i sensori TinkerKit acquistati. Noi ovviamente non abbiamo un set del genere, ma questo non significa che le icone non siano adatte ad altri set, al contrario, è molto comodo per i ragazzi usare icone come accendere un LED o un pulsante. Questi segni sono utilizzati in quasi tutti i programmi. Ma hanno una particolarità: quando li selezioni, ci sono icone errate che indicano le porte, quindi devi rimuoverle e sostituire l'icona dalla sezione "numeri/costanti" in alto nell'elenco.

"DF Robot": questa sezione viene utilizzata se sono presenti i sensori specificati in essa, a volte vengono trovati. E il nostro esempio di oggi non fa eccezione, abbiamo un “Interruttore IR regolabile” e un “Sensore di linea”. Il “sensore di linea” è diverso da quello in foto, poiché è della ditta Amperka. Le loro azioni sono identiche, ma il sensore Ampere è molto migliore, poiché ha un regolatore di sensibilità.

“Seedstudio Grove” - Non ho mai utilizzato i sensori in questa sezione, anche se sono presenti solo joystick. Nelle nuove versioni questa sezione è stata ampliata.

E l'ultima sezione è il "Linker Kit". Non mi sono imbattuto nei sensori presentati in esso.

Vorrei mostrare un esempio di programma su un robot che si muove lungo una striscia. Il robot è molto semplice, sia da montare che da acquistare, ma andiamo con ordine. Cominciamo con la sua acquisizione e assemblaggio.

Ecco l'insieme dei pezzi stessi, tutto è stato acquistato sul sito Amperka.

1. AMP-B001 Protezione motore (2 canali, 2 A) RUB 1.890
2. AMP-B017 Scudo Troyka RUB 1.690
3. AMP-X053 Vano batteria 3×2 AA 1 60 RUR
4. AMP-B018 Sensore di linea digitale RUB 2.580
5. ROB0049 Piattaforma a due ruote MiniQ RUB 1,1890
6. SEN0019 Sensore di ostacoli a infrarossi RUB 1.390
7. FIT0032 Supporto per sensore di ostacoli a infrarossi RUB 1,90
8. A000066 Arduino Uno 1 1150 RUR

Per prima cosa assembliamo la piattaforma con ruote e saldiamo i cavi ai motori.

Successivamente installeremo dei rack per montare la scheda Arduino UNO, presi da una vecchia scheda madre o altri supporti simili.

Quindi colleghiamo la scheda Arduino UNO a questi rack, ma non possiamo fissare un bullone: ​​i connettori sono d'intralcio. Ovviamente puoi dissaldarli, ma questo è a tua discrezione.

Successivamente colleghiamo il sensore di ostacoli a infrarossi al suo supporto speciale. Si prega di notare che il regolatore di sensibilità si trova nella parte superiore, questo serve per facilitare la regolazione.

Ora installiamo i sensori di linea digitali, qui dovrai cercare un paio di bulloni e 4 dadi, installiamo due dadi tra la piattaforma stessa e il sensore di linea e fissiamo i sensori con il resto.

Successivamente installiamo Motor Shield, o altrimenti puoi chiamarlo driver del motore. Nel nostro caso, presta attenzione al ponticello. Non utilizzeremo un'alimentazione separata per i motori, quindi verrà installata in questa posizione. La parte inferiore è sigillata con nastro isolante in modo che non si verifichino cortocircuiti accidentali dal connettore USB Arduino UNO, per ogni evenienza.

Installiamo Troyka Shield sopra il Motor Shield. È necessario per la comodità di collegare i sensori. Tutti i sensori che utilizziamo sono digitali, quindi i sensori di linea sono collegati alle porte 8 e 9, come vengono anche chiamati pin, e il sensore di ostacoli a infrarossi è collegato alla porta 12. Tieni presente che non puoi utilizzare le porte 4, 5, 6, 7 poiché vengono utilizzate da Motor Shield per controllare i motori. Ho anche dipinto appositamente queste porte con un pennarello rosso in modo che gli studenti potessero capirlo.

Se l'hai già notato, ho aggiunto una boccola nera, per ogni evenienza, in modo che il vano batteria che abbiamo installato non volasse via. E infine, fissiamo l'intera struttura con un normale elastico.

Esistono 2 tipi di collegamenti del vano batteria. Primo collegamento dei cavi a Troyka Shield. È anche possibile saldare la spina di alimentazione e collegarla alla stessa scheda Arduino UNO.

Il nostro robot è pronto. Prima di iniziare a programmare, dovrai imparare come funziona il tutto, vale a dire:
- Motori:
Le porte 4 e 5 vengono utilizzate per controllare un motore e 6 e 7 l'altro;
Regoliamo la velocità di rotazione dei motori utilizzando PWM sulle porte 5 e 6;
Avanti o indietro inviando segnali alle porte 4 e 7.
- Sensori:
Siamo tutti digitali, quindi danno segnali logici sotto forma di 1 o 0;
E per regolarli hanno appositi regolatori e con l'aiuto di un apposito cacciavite si possono calibrare.

I dettagli possono essere trovati su Amperke. Perché qui? Perché ci sono molte informazioni su come lavorare con Arduino.

Bene, probabilmente abbiamo guardato tutto superficialmente, studiato e, ovviamente, assemblato il robot. Ora deve essere programmato, eccolo: il programma tanto atteso!

E il programma è stato convertito in IDE Arduino:

Void setup() ( pinMode(8, INPUT); pinMode(12, INPUT); pinMode(9, INPUT); pinMode(4, OUTPUT); pinMode(7, OUTPUT); pinMode(5, OUTPUT); pinMode(6 , OUTPUT); ) void loop() ( if (digitalRead(12)) ( if (digitalRead(8)) ( if (digitalRead(9)) ( digitalWrite(4, HIGH); analogWrite(5, 255); analogWrite( 6, 255); digitalWrite(7, HIGH); ) altro ( digitalWrite(4, LOW); analogWrite(5, 255); analogWrite(6, 50); digitalWrite(7, LOW); ) ) altro ( if (digitalRead (9)) ( digitalWrite(4, BASSO); analogWrite(5, 50); analogWrite(6, 255); digitalWrite(7, ALTO); ) altro ( digitalWrite(4, ALTO); analogWrite(5, 255); analogWrite(6, 255); digitalWrite(7, ALTA); ) ) ) altro ( digitalWrite(4, ALTA); analogWrite(5, 0); analogWrite(6, 0); digitalWrite(7, ALTA); ) )

In conclusione, voglio dire che questo programma è semplicemente una manna dal cielo per l'istruzione; anche per lo studio autonomo, ti aiuterà ad apprendere i comandi dell'IDE di Arduino. Il punto forte è che ci sono più di 50 icone di installazione, inizia a "problemi". Sì, in effetti, questo è il momento clou, dal momento che programmare sempre solo su ArduBlok non ti insegnerà a programmare nell'IDE di Arduino. Il cosiddetto "glitch" ti dà l'opportunità di pensare e provare a ricordare i comandi per un debug preciso dei programmi.

Vi auguro il successo.

introduzione

Freeduino/Arduino è programmato in uno speciale linguaggio di programmazione: è basato su C/C++ e ti consente di utilizzare qualsiasi delle sue funzioni. A rigor di termini, non esiste un linguaggio Arduino separato, così come non esiste un compilatore Arduino: i programmi scritti vengono convertiti (con modifiche minime) in un programma in C/C++ e quindi compilati dal compilatore AVR-GCC. Quindi, di fatto, viene utilizzata una variante di C/C++ specializzata per i microcontrollori AVR.

La differenza è che ottieni un ambiente di sviluppo semplice e un insieme di librerie di base che semplificano l'accesso alle periferiche situate “a bordo” del microcontrollore.

D'accordo, è molto comodo iniziare a lavorare con una porta seriale a una velocità di 9600 bit al secondo, effettuando una chiamata su una riga:

Serial.begin(9600);

E quando usi C/C++ “nudo”, dovresti occuparti della documentazione per il microcontrollore e chiamare qualcosa del genere:

UBRR0H = ((F_CPU / 16 + 9600 / 2) / 9600 - 1) >> 8;
UBRR0L = ((F_CPU / 16 + 9600 / 2) / 9600 - 1);
sbi(UCSR0B, RXEN0);
sbi(UCSR0B, TXEN0);
sbi(UCSR0B, RXCIE0);

Ecco una breve panoramica delle principali funzioni e caratteristiche della programmazione Arduino. Se non hai familiarità con la sintassi dei linguaggi C/C++, ti consigliamo di fare riferimento alla eventuale letteratura in merito questa edizione o fonti Internet.

D'altronde tutti gli esempi presentati sono molto semplici, e molto probabilmente non avrai alcuna difficoltà a comprenderli testi di origine e scrittura propri programmi anche senza leggere letteratura aggiuntiva.

Documentazione più completa (at lingua inglese) è presentato sul sito ufficiale del progetto - http://www.arduino.cc. C'è anche un forum lì, link a librerie aggiuntive e la loro descrizione.

Simile alla descrizione sul sito ufficiale Progetto Arduino, "porta" indica un contatto del microcontrollore collegato al connettore con il numero corrispondente. Inoltre, è presente una porta di comunicazione seriale (porta COM).

Struttura del programma

Nel tuo programma devi dichiarare due funzioni principali: setup() e loop().

La funzione setup() viene chiamata una volta, dopo ogni accensione o reset della scheda Freeduino. Usalo per inizializzare variabili, impostare modalità operative delle porte digitali, ecc.

La funzione loop() esegue in sequenza i comandi descritti nel suo corpo più e più volte. Quelli. Una volta completata la funzione, verrà richiamata nuovamente.

Diamo un'occhiata a un semplice esempio:

impostazione vuota() // impostazioni iniziali
{
inizioSeriale(9600); // imposta la velocità operativa porta seriale a 9600bps
pinModalità(3, INPUT); // imposta la terza porta per l'input dei dati
}

// Il programma controlla la presenza di un segnale sulla terza porta e invia una risposta a
// visualizzazione messaggio testuale alla porta seriale del computer
void loop() // corpo del programma
{
if (digitalRead(3) == HIGH) // condizione per interrogare la terza porta
serialWrite("H"); // invia un messaggio sotto forma di lettera "H" alla porta COM
altro
serialWrite("L"); // invia un messaggio sotto forma di lettera "L" alla porta COM
ritardo(1000); // ritardo di 1 secondo.
}

pinMode(porta, modalità);

Descrizione:

Configura la porta specificata per l'ingresso o l'uscita di un segnale.

Opzioni:

port – il numero della porta di cui si desidera impostare la modalità (un valore intero compreso tra 0 e 13).

modalità: INPUT (ingresso) o OUTPUT (uscita).

pinModalità(13, USCITA); //Il tredicesimo pin sarà l'output
pinModalità(12, INPUT); //e il 12 è l'input

Nota:

Gli ingressi analogici possono essere utilizzati come ingressi/uscite digitali accedendovi tramite numeri che iniziano con 14 ( Ingresso analogico 0) a 19 (ingresso analogico 5)

digitalWrite(porta, valore);

Descrizione:

Imposta il livello di tensione su alto (HIGH) o basso (LOW) sulla porta specificata.

Opzioni:

porto: numero della porta

valore: ALTO o BASSO

scrittura digitale(13, ALTA); // imposta il pin 13 sullo stato "alto".

valore = digitalRead(porta);

Descrizione:

Legge il valore sulla porta specificata

Opzioni:

porta: numero della porta interrogata

Valore restituito: restituisce il valore corrente sulla porta (ALTO o BASSO) digitare int

valore intero;
val = digitalRead(12); // interroga il 12° pin

Nota:

Se non c'è nulla collegato alla porta da leggere, la funzione digitalRead() potrebbe restituire valori ALTI o BASSI in modo irregolare.

Ingresso/uscita segnale analogico

valore = analogRead(porta);

Descrizione:

Legge un valore dalla porta analogica specificata. Freeduino contiene 6 canali, convertitore analogico-digitale 10 bit ciascuno. Ciò significa che la tensione di ingresso da 0 a 5 V viene convertita in un valore intero da 0 a 1023. La risoluzione di lettura è: 5 V/1024 valori = 0,004883 V/valore (4,883 mV). Sono quindi necessari circa 100 nS (0,0001 C) per leggere il valore dell'ingresso analogico velocità massima letture - circa 10.000 volte al secondo.

Opzioni:

Valore restituito: restituisce un numero intero compreso tra 0 e 1023 letto dalla porta specificata.

valore intero;
val = analogRead(0); // legge il valore sullo 0° ingresso analogico

Nota:

Le porte analogiche sono definite come ingresso di segnale per impostazione predefinita e, a differenza delle porte digitali, non necessitano di essere configurate chiamando la funzione pinMode.

analogWrite(porta, valore);

Descrizione:

Emette un valore analogico sulla porta. Questa funzione funziona su: 3, 5, 6, 9, 10 e 11 porte digitali Freeduino.

Può essere utilizzato per modificare la luminosità di un LED, controllare un motore, ecc. Dopo aver chiamato la funzione analogWrite, la porta corrispondente inizia a funzionare in modalità di modulazione dell'ampiezza dell'impulso di tensione finché non viene richiamata un'altra funzione analogWrite (o le funzioni digitalRead / digitalWrite sulla stessa porta).

Opzioni:

porta: numero dell'ingresso analogico interrogato

valore: un numero intero compreso tra 0 e 255. Un valore pari a 0 genera 0 V sulla porta specificata; un valore di 255 genera +5V sulla porta specificata. Per valori compresi tra 0 e 255, la porta inizia ad alternare rapidamente tra i livelli di tensione 0 e +5 V: maggiore è il valore, più spesso la porta genera il livello ALTO (5 V).

analogWrite(9, 128); // imposta il pin 9 su un valore equivalente a 2,5 V

Nota:

Non è necessario chiamare pinMode per impostare la porta sui segnali di uscita prima di chiamare analogWrite.

La frequenza di generazione del segnale è di circa 490 Hz.

tempo = milli();

Descrizione:

Restituisce il numero di millisecondi trascorsi dall'esecuzione di Freeduino programma attuale. Il contatore andrà in overflow e si azzererà dopo circa 9 ore.

Valore restituito: restituisce un valore lungo senza segno

non firmato da molto tempo; // dichiarazione di una variabile temporale di tipo unsigned long
tempo = milli(); // trasferisce il numero di millisecondi

ritardo(tempo_ms);

Descrizione:

Mette in pausa il programma per il numero di millisecondi specificato.

Opzioni:

time_ms – tempo di ritardo del programma in millisecondi

ritardo(1000); //pausa 1 secondo

ritardoMicrosecondi

ritardoMicrosecondi(tempo_μs);

Descrizione:

Mette in pausa il programma per il numero di microsecondi specificato.

Opzioni:

time_μs – tempo di ritardo del programma in microsecondi

ritardoMicrosecondi(500); //pausa 500 microsecondi

impulsoIn(porta, valore);

Descrizione:

Legge un impulso (alto o basso) da una porta digitale e restituisce la durata dell'impulso in microsecondi.

Ad esempio, se il parametro "value" è impostato su HIGH quando si chiama la funzione, allora pulsaIn() attende l'arrivo di un livello di segnale alto sulla porta. Dal momento in cui arriva, inizia il conto alla rovescia finché il porto non riceve basso livello segnale. La funzione restituisce la durata dell'impulso ( alto livello) in microsecondi. Funziona con impulsi da 10 microsecondi a 3 minuti. Si noti che questa funzione non restituirà un risultato finché non viene rilevato un impulso.

Opzioni:

port: numero della porta da cui leggiamo l'impulso

valore: tipo impulso ALTO o BASSO

Valore di ritorno: restituisce la durata dell'impulso in microsecondi (tipo int)

durata intera; // dichiarazione di una variabile di durata di tipo int
durata = impulsoIn(pin, ALTO); // misura la durata dell'impulso

Trasmissione dati seriale

Freeduino ha un controller integrato per la trasmissione seriale dei dati, che può essere utilizzato sia per la comunicazione tra dispositivi Freeduino/Arduino sia per la comunicazione con un computer. Su un computer, la connessione corrispondente è rappresentata da una porta COM USB.

La comunicazione avviene tramite le porte digitali 0 e 1 e pertanto non sarà possibile utilizzarle per l'I/O digitale se si utilizzano le funzioni seriali.

Serial.begin(velocità_baud);

Descrizione:

Imposta la velocità di trasferimento delle informazioni della porta COM in bit al secondo per la trasmissione dei dati seriali. Per comunicare con un computer, utilizzare una di queste velocità standard: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200. È inoltre possibile definire altre velocità quando si comunica con un altro microcontrollore tramite porte 0 e 1.

Opzioni:

baud_rate: velocità del flusso di dati in bit al secondo.

Serial.begin(9600); //imposta la velocità su 9600 bps

Seriale.disponibile

conteggio = Serial.disponibile();

Descrizione:

Accettato da porta seriale i byte finiscono nel buffer del microcontrollore, da dove il tuo programma può leggerli. La funzione restituisce il numero di byte accumulati nel buffer. Il buffer seriale può memorizzare fino a 128 byte.

Valore di ritorno:

Restituisce un valore int: il numero di byte disponibili per la lettura nel buffer seriale o 0 se non è disponibile nulla.

if (Serial.available() > 0) ( // Se sono presenti dati nel buffer
// qui dovrebbero esserci la ricezione e l'elaborazione dei dati
}

char = Serial.read();

Descrizione:

Legge il byte successivo dal buffer porta seriale.

Valore di ritorno:

Il primo byte disponibile di dati in entrata dalla porta seriale o -1 se non ci sono dati in entrata.

byte in arrivo = Serial.read(); // legge il byte

Descrizione:

Cancella il buffer di input della porta seriale. I dati nel buffer vengono persi e ulteriori chiamate a Serial.read() o Serial.available() avranno senso per i dati ricevuti dopo la chiamata Serial.flush().

Serial.flush(); // Cancella il buffer: inizia a ricevere i dati “da zero”

Descrizione:

Dati in uscita sulla porta seriale.

Opzioni:

La funzione dispone di diversi moduli di chiamata a seconda del tipo e del formato dei dati di output.

Serial.print(b, DEC) stampa una stringa ASCII - la rappresentazione decimale del numero b.

intero b = 79;

Serial.print(b, HEX) stampa una stringa ASCII - la rappresentazione esadecimale del numero b.

intero b = 79;

Serial.print(b, OCT) stampa una stringa ASCII - la rappresentazione ottale del numero b.

intero b = 79;
Serial.print(b, OCT); //invierà la stringa "117" alla porta

Serial.print(b, BIN) stampa una stringa ASCII - rappresentazione binaria numeri b.

intero b = 79;
Serial.print(b, BIN); //invierà la stringa "1001111" alla porta

Serial.print(b, BYTE) stampa il byte basso di b.

intero b = 79;
Stampa.seriale(b, BYTE); //visualizzerà il numero 79 (un byte). Nel monitor
//dalla porta seriale otteniamo il simbolo "O" - its
//il codice è 79

Serial.print(str) se str è una stringa o un array di caratteri, trasferisce str alla porta COM byte byte.

caratteri byte = (79, 80, 81); //array di 3 byte con valori 79,80,81
Serial.print("Ecco i nostri byte:"); // restituisce la riga "Qui i nostri byte:"
Serial.print(byte); //emette 3 caratteri con i codici 79,80,81 –
//questi sono i caratteri "OPQ"

Serial.print(b) se b è di tipo byte o carattere, stampa il numero b stesso sulla porta.

carattere b = 79;
Stampa.seriale(b); // trasmetterà il carattere "O" alla porta

Serial.print(b) se b ha tipo intero, invia alla porta la rappresentazione decimale del numero b.

intero b = 79;
Stampa.seriale(b); //invierà la stringa "79" alla porta

Descrizione:

La funzione Serial.println è simile alla funzione Serial.print e presenta le stesse opzioni di chiamata. L'unica differenza è che dopo i dati vengono emessi due caratteri aggiuntivi: un carattere di ritorno a capo (ASCII 13 o "\r") e un carattere di nuova riga (ASCII 10 o "\n").

L'esempio 1 e l'esempio 2 restituiranno la stessa cosa alla porta:

intero b = 79;
Serial.print(b, DEC); //invierà la stringa "79" alla porta
Serial.print("\r\n"); //visualizzerà i caratteri "\r\n" – avanzamento riga
Serial.print(b, HEX); //invierà la stringa "4F" alla porta
Serial.print("\r\n");//stamperà i caratteri "\r\n" – avanzamento riga

intero b = 79;
Serial.println(b, DEC); //invierà la stringa "79\r\n" alla porta
Serial.println(b, HEX); //invierà la stringa "4F\r\n" alla porta

Nel monitor della porta seriale otteniamo.