Sintassi e struttura del codice.
Microcontrollore - può eseguire solo istruzioni specifiche dal programma. La comunicazione con MCU avviene per iscritto in un linguaggio di programmazione, questo linguaggio è molto chiaro, rigoroso e ha una propria sintassi e alcuni standard di progettazione. E se un errore di sintassi porta a un errore di compilazione del codice o a un funzionamento non corretto del dispositivo, il design del codice serve a facilitarne la lettura da parte del programmatore.
Sintassi.
- I corpi delle funzioni sono racchiusi tra parentesi graffe {}. Il codice racchiuso tra parentesi graffe è talvolta chiamato blocco di codice.
- Ogni comando termina con un punto e virgola;
- Il metodo viene applicato all'oggetto tramite un punto. Esempio: Serial.begin();
- Una funzione o una chiamata al metodo termina sempre con parentesi, anche se la funzione non accetta parametri. Esempio: loop().
- Il separatore decimale è un punto. Esempio: 3.14 La virgola ha un uso diverso qui.
- Gli argomenti di funzioni e metodi, i membri dell'array sono elencati con virgole e diverse azioni possono essere eseguite in una riga separate da virgole. Esempio: digitalWrite(5, HIGH); array - int myArray[] = {1, 2, 3 ,4};
- Un singolo carattere è racchiuso tra virgolette singole 'a'.
- Stringa e array di caratteri racchiusi tra virgolette "stringa".
- I nomi delle variabili possono contenere lettere latine maiuscole e minuscole, numeri e trattini bassi. Esempio: myVal_32 .
- I nomi delle variabili non possono iniziare con un numero. Solo lettere o trattini bassi.
- Il registro conta, ad es. la lettera grande è diversa da quella piccola. Esempio: i nomi val e Val non corrispondono.
La sintassi includere commenti, perché? Si distinguono in modo diverso nelle diverse lingue. Un commento è un testo normale che viene ignorato in fase di compilazione e non finisce nel programma finale di MCU. I commenti sono necessari per spiegare il codice, sia a te stesso che ad altri possibili lettori. In C++ abbiamo due tipi di commenti:
- // commento a riga singola.
- /* Commento su più righe */
Formalizzazione.
Esiste una cosa come la formattazione (allineamento) del codice, ovvero l'osservazione di spazi e intervalli. Solo per un esempio, confronta questi due pezzi di codice. Quale sembra più chiaro?
Tutti gli ambienti di sviluppo seri hanno la formattazione automatica del codice, funziona sia in fase di scrittura che "sul pulsante". IDE Arduino non fa eccezione:
- Tra operazioni matematiche, segni di confronto, assegnazioni e tutto il resto viene inserito uno spazio.
- Come nel testo normale, uno spazio viene posizionato dopo e non prima di una virgola, due punti, punto e virgola.
- Il rientro dal bordo sinistro dello schermo è un carattere di tabulazione, il codice viene spostato a destra e i comandi di un blocco di codice vengono formati alla stessa distanza. Nel IDE di Arduino, una tabulazione equivale a due spazi. Puoi usare il tasto Tab.
- Ogni azione viene eseguita da una nuova riga (la formattazione automatica non risolve questo).
- I nomi delle funzioni e delle variabili sono generalmente chiamati con una lettera minuscola. Esempio: value.
- Se il nome è composto da due o più parole, è consuetudine separarle. Ci sono due modi: camelCase (stile cammello): la prima lettera è minuscola, ogni prima lettera della parola successiva è maiuscola, under_score (sottolineare): tutte le lettere sono minuscole, il separatore è un trattino basso.
- È consuetudine mettere in maiuscolo i nomi dei tipi di dati e delle classi. Esempio: Signal, Servo.
- I nomi delle costanti sono generalmente scritti in maiuscolo, la separazione è sottolineata. Esempio: MOTOR_SPEED.
- Quando si scrivono librerie e classi, è consuetudine scrivere i nomi delle variabili interne (private) che iniziano con un trattino basso. Esempio: _position.
Alcune abbreviazioni comuni per i nomi delle variabili, le vedrai spesso nel firmware e nelle librerie di altre persone:
- button - btn, pulsante
- index - idx, indice
- buffer - buf, buffer
- value - val, valore
- variable - var, variabile
- pointer - ptr, puntatore
È consuetudine iniziare i nomi delle funzioni e dei metodi con un verbo che descrive brevemente l'azione della funzione. Ecco quelli che vedrai sempre:
- get - ottieni valore (getValue).
- set - valore impostato (setTime)
- print, show - mostra qualcosa
- read - leggi.
- write - scrive.
- change - cambia.
- clear - clear.
- begin, start - inizia.
- end, stop - fine, stop.
Domanda: La lunghezza del nome della variabile influisce sulla memoria occupata dal firmware? Il peso del file con il programma sul computer ne risente. Non influisce sul peso del firmware caricato nel microcontrollore, perché il codice viene convertito in codice macchina, in cui non ci sono nomi.
Struttura del codice.
Prima di passare alla struttura e all'ordine delle parti del codice, ci sono alcune cose da ricordare:
- Una variabile di qualsiasi tipo dovrebbe essere chiamata solo dopo che è stata dichiarata. Altrimenti ci sarà un errore.
- La dichiarazione e l'utilizzo di classi o tipi di dati da una libreria/file deve avvenire dopo aver incluso la libreria/file.
- La funzione può essere chiamata sia prima che dopo la dichiarazione, perché il C++ è un linguaggio compilato, la compilazione avviene in più fasi e le funzioni sono "evidenziate" separatamente, quindi possono essere richiamate ovunque nel programma.
Quando si avvia IDE Arduino, ci dà uno spazio vuoto sotto forma di due funzioni richieste: setup() e loop().
Il codice nel blocco setup() viene eseguito una volta ogni volta che viene avviata la MCU. Il codice nel blocco loop() viene eseguito "in un cerchio" in tutto il programma, a partire dal momento in cui setup() viene completato. Per i curiosi: se hai già dimestichezza con il linguaggio C++, probabilmente ti chiederai "dov'è int main() e in generale il file main.cpp?". Tutto è molto semplice: int main() è già stato scritto per te all'interno del file main.cpp, che si trova in profondità nei file CPU, e setup() e loop() sono integrati come segue:
// main.cpp
// da qualche parte nelle profondità del CPU di Arduino
int main()
{
setup();
for (;;)
{
loop();
}
return 0;
}
Nel corso di diversi anni di lavoro con Arduino, mi sono formato la seguente struttura di sketch:
- Descrizione del firmware, collegamenti, note.
- Costanti di configurazione (definite e regolari).
- Costanti di servizio (che dovrebbero essere modificate solo con la piena conoscenza della materia).
- Librerie collegate e file esterni, dichiarazione dei tipi di dati e classi ad essi corrispondenti.
- Variabili globali.
- setup().
- loop().
- Le funzioni.
Questa è una struttura conveniente per lo "schizzo", non è consigliabile scrivere grandi progetti e dovresti abituarti ad approcci più adulti, descritti negli argomenti sullo sviluppo di grandi progetti, leggi qui.
Collegamento di librerie e file.
Nel lavoro reale, utilizzerai molto spesso librerie o file esterni, sono inclusi nel file principale (file del firmware) usando la direttiva #include. Questo comando dice al compilatore di trovare e aggiungere il file specificato al programma. Questo file può contenere i propri #include e trascinarli lungo altri file, in modo che il programma possa essere suddiviso in molti file indipendenti. Considera un esempio:
#include <Servo.h> // include la libreria Servo.h
#include "Servo.h" // include la libreria Servo.h
Qual è la differenza tra <> e ""? Quando specifichiamo il nome "tra virgolette", il compilatore cerca prima il file nella cartella dello schizzo, quindi nella cartella delle librerie. Quando si usa <segni di spunta>, il compilatore cerca il file solo nella cartella delle librerie! A proposito di cartelle con librerie: ce ne sono due, in entrambe verranno cercate le librerie.
- Cartella utente: Documenti/Arduino/libraries. Le librerie arrivano qui quando vengono aggiunte tramite "include libreria .zip" e quando installate dal gestore librerie.
- Cartella del programma: C:/Program Files (x86)/Arduino/libraries (o C:/Program Files/Arduino/libraries per Windows a 32 bit). È qui che vengono archiviate le librerie standard integrate.