Qual è il linguaggio di programmazione di Arduino?

Introduzione - Storia di Arduino e del suo IDE

L'Ambiente di Sviluppo Integrato (IDE) di Arduino è uno strumento potente plasmato da Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino e David Mellis. Ha origine da Wiring, un progetto incluso nella tesi di laurea del 2003 di Hernando Barragán presso l'Interaction Design Institute Ivrea (IDII).

Massimo Banzi ha supervisionato e Casey Reas (di Processing) ha influenzato, mentre Hernando sviluppava la piattaforma Wiring, ponendo le basi per lo sviluppo di microcontrollori. Nel 2005, Massimo Banzi, collaborando con David Mellis, un altro studente dell'IDII, e David Cuartielles, ha ampliato Wiring aggiungendo il supporto per il conveniente microcontrollore ATmega8. Questo sviluppo ha dato vita a un nuovo progetto, Arduino, che è emerso come un ramo di Wiring. Ha segnato l'inizio di un percorso trasformativo originato in Italia.

Arduino, ispirato ai principi user-friendly dell'IDE processing, mirava a democratizzare la creazione di progetti digitali. Il linguaggio di programmazione di Arduino, essenziale per la piattaforma, ha svolto un ruolo cruciale nell'ampliare l'accesso alla tecnologia dei microcontrollori. Questo impegno per la semplicità e la disponibilità ha definito l'eredità di Arduino, un lascito nato nel paesaggio innovativo dell'Italia.

Ora sorge una domanda affascinante: "Quale linguaggio di programmazione è la forza trainante dietro alla magia di Arduino?"

La magia di Arduino nasce da una variante semplificata di C++, un linguaggio reso accessibile a tutti. Questo linguaggio funge da ponte, collegando principianti ed esperti. È facile per i principianti ma conserva comunque le caratteristiche robuste necessarie agli esperti. Aiuta le persone appassionate di elettronica a trasformare facilmente e senza intoppi le loro idee in progetti reali.

Benefici della variante C++ di Arduino

Fattori Chiave del Linguaggio di Programmazione Arduino

Struttura intuitiva con le funzioni setup() e loop()

Nello standard C++, la funzione main() è essenziale per avviare l'esecuzione del programma. Arduino rimuove questa parte, semplificando il processo di avvio. Gli utenti possono concentrarsi sulla logica del loro codice senza la necessità di una funzione main dedicata, riducendo la complessità.

Arduino semplifica la struttura dei programmi introducendo due funzioni fondamentali: setup() e loop(). La funzione setup() viene eseguita una sola volta all'inizio, mentre loop() viene eseguita continuamente. Questa struttura chiara migliora la leggibilità e guida gli utenti nell'organizzazione del loro codice.

void setup() {
  // put your setup code here, to run once:

}

void loop() {
  // put your main code here, to run repeatedly:

}

Curioso di vedere com'è strutturata la funzione main in Arduino? Ecco un esempio del codice main.cpp per la scheda Arduino Uno, nascosto nella cartella cores installata dall'IDE.

/*
  main.cpp - Main loop for Arduino sketches
  Copyright (c) 2005-2013 Arduino Team.  All right reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include <Arduino.h>

// Declared weak in Arduino.h to allow user redefinitions.
int atexit(void (* /*func*/ )()) { return 0; }

// Weak empty variant initialization function.
// May be redefined by variant files.
void initVariant() __attribute__((weak));
void initVariant() { }

void setupUSB() __attribute__((weak));
void setupUSB() { }

int main(void)
{
	init();

	initVariant();

#if defined(USBCON)
	USBDevice.attach();
#endif
	
	setup();
    
	for (;;) {
		loop();
		if (serialEventRun) serialEventRun();
	}
        
	return 0;
}

Alla riga 44, la funzione main chiama la funzione setup() solo una volta. Ecco perché il codice all'interno della funzione setup() viene eseguito solo una volta.

Alla riga 47, la funzione main chiama la funzione loop(), situata all'interno di un ciclo for alla riga 46 che è sempre verificato. Questa struttura garantisce che il codice all'interno della funzione loop() venga eseguito ripetutamente.

Per trovare i file principali delle schede nella IDE di Arduino, guarda nella cartella "Arduino15".

• • Windows: C:\Users\{username}\AppData\Local\Arduino15
  • macOS: /Users/{username}/Library/Arduino15
  • Linux: home/{username}/.arduino15

Vai alla cartella Arduino15, quindi apri packages › arduino › hardware › avr › 1.8.6 › cores › arduino › main.cpp.

Per informazioni aggiuntive, consulta il sito Arduino.

Gestione automatica dei prototipi di funzione

Il linguaggio di Arduino elimina l'obbligo per gli utenti di dichiarare esplicitamente i prototipi delle funzioni. Questo consente ai principianti di iniziare a programmare più facilmente, senza la necessità di dichiarazioni intricate.

Nel C++ tradizionale, è necessario dichiarare il prototipo all'inizio del programma. Ad esempio:

// Explicit function prototype
void myFunction(int x);

void setup() {
  // Function call
  myFunction(10);
}

void loop() {
  // Code here
}

// Function definition
void myFunction(int x) {
  // Function implementation
}

Nel C++ semplificato di Arduino, è possibile definire e utilizzare le funzioni direttamente, senza la necessità di esplicitare i prototipi di funzione:

void setup() {
  // Function call
  myFunction(10);
}

void loop() {
  // Code here
}

// Function definition
void myFunction(int x) {
  // Function implementation
}

Organizzazione Intuitiva degli Sketch (files .ino)

L'uso dei file .ino è una caratteristica distintiva che contribuisce alla semplicità della programmazione di Arduino. Ogni file .ino include una porzione dello sketch, rendendolo un'unità di codice intuitiva e user-friendly. Questo approccio consente agli sviluppatori di concentrarsi su funzionalità specifiche all'interno di file separati, promuovendo una struttura di progetto modulare e organizzata.

Nei progetti Arduino con più file .ino nella stessa cartella, l'IDE di Arduino li gestisce collettivamente durante la compilazione. L'IDE segue un processo specifico per concatenare questi file prima della compilazione e dell'upload sulla scheda Arduino.

Questo approccio offre un'alternativa semplificata rispetto agli IDE C++ standard, che spesso si basano su file .h e .cpp.

Nel C++ standard, i file di intestazione gestiscono i prototipi delle funzioni, mentre le implementazioni delle funzioni risiedono nei file .cpp, richiedendo una gestione attenta delle dichiarazioni di inclusione.

Guarda l'esempio qui sotto.

Immagina un progetto semplice scritto in un singolo file .ino: un Arduino legge un valore da un potenziometro e regola l'intervallo di lampeggio del LED.

BlinkingLED.ino : 

int ledPin = 13;
int potentiometerPin = A0;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int potValue = analogRead(potentiometerPin);
  int blinkInterval = map(potValue, 0, 1023, 100, 2000);  // Map potentiometer value to blink interval
  digitalWrite(ledPin, HIGH);
  delay(blinkInterval);
  digitalWrite(ledPin, LOW);
  delay(blinkInterval);
}

Ora, riorganizziamo il progetto. Una funzione di lettura (readPotentiometer) in un file e la funzione di impostazione del LED (blinkLED) in un altro. Questo suddivide il progetto in tre file:

1. BlinkingLED.ino

// BlinkingLED.ino

int ledPin = 13;
int potentiometerPin = A0;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  readPotentiometer();
  blinkLED();
}

2. ReadData.ino

// ReadData.ino


int blinkInterval = 0;

void readPotentiometer() {
  int potValue = analogRead(potentiometerPin);
  blinkInterval = map(potValue, 0, 1023, 100, 2000);  // Map potentiometer value to blink interval
}

3. WriteData.ino

// WriteData.ino

void blinkLED() {
  digitalWrite(ledPin, HIGH);
  delay(blinkInterval);
  digitalWrite(ledPin, LOW);
  delay(blinkInterval);
}

L'IDE di Arduino concatena tutti i file .ino a partire dal file principale del progetto (BlinkingLED).

Quindi, ReadData.ino e WriteData.ino saranno concatenati in ordine alfabetico come segue.

Concatenazione eseguita dal preprocessore dell'IDE di Arduino durante la fase di compilazione:

int ledPin = 13;
int potentiometerPin = A0;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  readPotentiometer();
  blinkLED();
}


int blinkInterval = 0;

void readPotentiometer() {
  int potValue = analogRead(potentiometerPin);
  blinkInterval = map(potValue, 0, 1023, 100, 2000);  // Map potentiometer value to blink interval

void blinkLED() {
  digitalWrite(ledPin, HIGH);
  delay(blinkInterval);
  digitalWrite(ledPin, LOW);
  delay(blinkInterval);
}

Vantaggi di questa funzionalità:

1. 1. Non è necessario utilizzare file di intestazione aggiuntivi per gestire le connessioni tra le funzioni.
   2. Non è necessario gestire i prototipi di funzione in file multipli.

Punti di attenzione:

1. 1. Pur essendo in file diversi, le funzioni non sono completamente indipendenti come nei file .h e .cpp.

   2. Fai attenzione quando si gestiscono variabili globali istanziate in un file specifico (ad esempio blinkInterval):

      • saranno visibili in altri file causando potenziali conflitti.

      • dichiara le variabili globali prima di utilizzarle in altri file consecutivi per evitare conflitti durante la concatenazione.

Per un maggiore controllo sulla concatenazione, prendi in considerazione quello di nominare i file con un prefisso numerico, ad esempio '01_ReadData.ino' e '02_WriteData.ino'. Questo ti farà capire quale sarà l'ordine di concatenazione dei file durante la fase di compilazione.

Conclusione

Il linguaggio di Arduino semplifica l'esperienza di programmazione, consentendo a persone di tutti i livelli, dai principianti agli sviluppatori esperti, di interagire con l'elettronica. Questo linguaggio unisce tutti, abbattendo barriere e creando uno spazio collaborativo per l'innovazione. Con radici in Italia, il lascito di Arduino continua a ispirare e plasmare il mondo dell'elettronica.