Arduino.
Dal primo LED
al progetto solido.

01 / Base

Il primo programma: dal PC al LED

Caricare un programma e riconoscere le sue due parti.

Uno sketch è il programma di Arduino. setup() viene eseguito una volta dopo accensione o reset; loop() viene richiamato continuamente. Le parentesi graffe delimitano un blocco, il punto e virgola chiude molte istruzioni. Il testo dopo // è un commento. Per cominciare usa soltanto il LED già sulla scheda: non serve costruire un circuito.

Fai così

1. Su un PC Windows, macOS o Linux installa Arduino IDE 2 dalla pagina ufficiale. Usa un cavo USB che trasmetta anche dati.
2. Nel gestore schede installa Arduino AVR Boards; seleziona Arduino Uno e la porta della tua UNO R3. Conserva nel quaderno la versione del core.
3. Crea uno sketch, sostituisci il contenuto con il programma qui sotto e premi Verifica. Poi premi Carica e osserva il LED L.

Programma commentato

#include <Arduino.h>
// Atlante: esempio originale per UNO R3.
// Verificare core, cablaggio e hardware prima dell’uso.
void setup() {
  pinMode(LED_BUILTIN, OUTPUT); // LED L: uscita
}
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(400); // millisecondi acceso
  digitalWrite(LED_BUILTIN, LOW);
  delay(800); // millisecondi spento
}

pinMode sceglie il ruolo del pin. digitalWrite imposta HIGH o LOW. delay ferma il normale avanzamento del programma: per questo primo esempio va bene; più avanti lo elimineremo.

Approfondimento ufficiale ↗

02 / Base

Variabili, costanti e LED esterno

Dare un nome ai pin e separare configurazione e comportamento.

Una costante descrive qualcosa che non deve cambiare durante il programma, come il numero di un pin. Una variabile conserva un valore che può cambiare. byte è utile per piccoli numeri non negativi; bool contiene true o false. Scegli nomi che spieghino il compito: ledSegnale è più chiaro di x. Una breadboard collega alcuni fori al suo interno: controlla i gruppi di contatti, non affidarti alla sola vicinanza.

Fai così

1. Scollega USB prima di spostare i fili. Inserisci LED e resistenza in serie.
2. Collega il pin D9 alla resistenza, poi all’anodo del LED. Collega il catodo a GND.
3. Carica lo sketch e modifica soltanto intervalloMs.

Programma commentato

#include <Arduino.h>
// Atlante: esempio originale per UNO R3.
// Verificare core, cablaggio e hardware prima dell’uso.
const byte ledSegnale = 9;
const unsigned long intervalloMs = 500;
bool acceso = false;
void setup() { pinMode(ledSegnale, OUTPUT); }
void loop() {
  acceso = !acceso; // inverte true e false
  digitalWrite(ledSegnale, acceso ? HIGH : LOW);
  delay(intervalloMs);
}

const protegge il nome da assegnazioni successive. ! inverte un valore logico. L’espressione condizione ? valore1 : valore2 sceglie il valore da scrivere.

Approfondimento ufficiale ↗

03 / Base

Pulsante: ingresso e decisioni

Leggere un ingresso e comandare un’uscita con if.

Con INPUT_PULLUP il pin ha uno stato definito quando il pulsante è aperto. Premendo, il collegamento a GND porta la lettura a LOW. La variabile premuto traduce questo livello elettrico in un significato: true vuol dire premuto. In C++, = assegna un valore; == confronta due valori. if esegue un blocco quando la condizione è vera.

Fai così

1. Collega un contatto del pulsante a D2 e l’altro a GND. Per pulsanti a quattro piedini identifica prima i contatti già uniti.
2. Carica il codice. Premi e rilascia: il LED integrato segue il contatto.
3. Nel simulatore aggiungi un pulsante e un LED, poi osserva i nomi delle variabili nel codice generato.

Programma commentato

#include <Arduino.h>
// Atlante: esempio originale per UNO R3.
// Verificare core, cablaggio e hardware prima dell’uso.
const byte pulsante = 2;
void setup() {
  pinMode(pulsante, INPUT_PULLUP);
  pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
  bool premuto = (digitalRead(pulsante) == LOW);
  if (premuto) digitalWrite(LED_BUILTIN, HIGH);
  else digitalWrite(LED_BUILTIN, LOW);
}

Il confronto == LOW produce un bool. Il programma legge e aggiorna continuamente: non conserva l’accensione dopo il rilascio.

Approfondimento ufficiale ↗

04 / Base

Leggere un valore analogico

Osservare misure nel monitor seriale e distinguere numero e unità.

analogRead su UNO R3 restituisce un conteggio a 10 bit, da 0 a 1023. Non è automaticamente una temperatura o una tensione precisa. Per trasformarlo in una grandezza servono riferimento, scala e caratteristiche del sensore. Inizia con un potenziometro da 10 kΩ: il cursore fornisce una tensione regolabile. Serial invia informazioni al PC; monitor e programma devono usare la stessa velocità.

Fai così

1. Collega i due terminali esterni del potenziometro a 5 V e GND; il cursore centrale va ad A0.
2. Carica e apri Monitor seriale a 115200 baud.
3. Ruota lentamente e annota minimo, centro e massimo.

Programma commentato

#include <Arduino.h>
// Atlante: esempio originale per UNO R3.
// Verificare core, cablaggio e hardware prima dell’uso.
void setup() { Serial.begin(115200); }
void loop() {
  int conteggio = analogRead(A0);
  Serial.print("ADC=");
  Serial.println(conteggio);
  delay(100);
}

int contiene il conteggio. print continua sulla stessa riga; println aggiunge un fine riga. Il ritardo rende leggibile l’uscita seriale.

Approfondimento ufficiale ↗

05 / Intermedio

PWM: regolare la luminosità

Trasformare una lettura in un comando di uscita.

PWM alterna velocemente acceso e spento. Cambia il rapporto fra tempo acceso e periodo, detto duty cycle. Su UNO R3 analogWrite usa normalmente valori da 0 a 255 sui pin PWM: non è un’uscita analogica continua. Qui usiamo D9 e convertiamo il conteggio 0–1023 in 0–255. Non alimentare motori o carichi di potenza direttamente da un pin.

Fai così

1. Mantieni il potenziometro su A0. Aggiungi il LED esterno con resistenza come nella lezione 2.
2. Carica il codice; ruota il potenziometro e osserva la luce.
3. Confronta valori minimi, centrali e massimi. La percezione della luminosità non è lineare.

Programma commentato

#include <Arduino.h>
// Atlante: esempio originale per UNO R3.
// Verificare core, cablaggio e hardware prima dell’uso.
const byte ledPwm = 9;
void setup() { pinMode(ledPwm, OUTPUT); }
void loop() {
  int lettura = analogRead(A0);
  int comando = lettura / 4; // 0..1023 diventa 0..255
  analogWrite(ledPwm, comando);
}

La divisione intera scarta la parte frazionaria. analogWrite mantiene il PWM mentre loop continua. D9 è una scelta specifica per UNO R3.

Approfondimento ufficiale ↗

06 / Intermedio

Funzioni, cicli e array

Ridurre le ripetizioni senza perdere chiarezza.

Una funzione raccoglie un compito. Un parametro è un valore che le passi; return restituisce il risultato. Un array conserva più elementi dello stesso tipo. Gli indici partono da zero: per tre elementi sono 0, 1 e 2. Un ciclo for è comodo per elaborare una piccola quantità di dati; non deve però bloccare per molto tempo il resto del programma.

Fai così

1. Usa solo la scheda USB. Leggi la funzione media prima di setup.
2. Prevedi il valore calcolato dai tre numeri nell’array.
3. Apri il monitor a 115200 e confronta previsione e risultato.

Programma commentato

#include <Arduino.h>
// Atlante: esempio originale per UNO R3.
// Verificare core, cablaggio e hardware prima dell’uso.
int media(const int valori[], byte quanti) {
  if (quanti == 0) return 0;
  long somma = 0;
  for (byte i = 0; i < quanti; i++) somma += valori[i];
  return somma / quanti;
}
void setup() {
  Serial.begin(115200);
  const int campioni[] = {100, 200, 300};
  Serial.println(media(campioni, 3));
}
void loop() {}

const impedisce alla funzione di modificare i valori ricevuti. long rende la somma più ampia di int su UNO R3. La dimensione passata deve corrispondere agli elementi disponibili.

Approfondimento ufficiale ↗

07 / Intermedio

Fare due cose insieme con millis

Eliminare le attese bloccanti dal ciclo principale.

Non serve un secondo processore per alternare attività brevi. loop legge un pulsante continuamente e controlla se è passato abbastanza tempo per cambiare il LED. millis fornisce un contatore di millisecondi. Su UNO R3 si riavvolge dopo circa 49,7 giorni: il confronto mediante sottrazione unsigned gestisce il passaggio, purché il controllo sia eseguito regolarmente e l’intervallo sia appropriato.

Fai così

1. Collega il pulsante D2–GND.
2. Carica: premendo il pulsante il lampeggio diventa più rapido.
3. Cerca nel codice tutte le chiamate a delay: non ce ne sono.

Programma commentato

#include <Arduino.h>
// Atlante: esempio originale per UNO R3.
// Verificare core, cablaggio e hardware prima dell’uso.
const byte pulsante = 2;
unsigned long ultimo = 0;
bool acceso = false;
void setup() {
  pinMode(pulsante, INPUT_PULLUP);
  pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
  unsigned long ora = millis();
  unsigned long periodo = digitalRead(pulsante) == LOW ? 120UL : 700UL;
  if (ora - ultimo >= periodo) {
    ultimo = ora;
    acceso = !acceso;
    digitalWrite(LED_BUILTIN, acceso ? HIGH : LOW);
  }
}

ultimo conserva quando è avvenuto l’ultimo cambio. UL indica una costante unsigned long. Ogni passaggio di loop resta breve; questo non è parallelismo hardware.

Approfondimento ufficiale ↗

08 / Intermedio

Una pressione, un evento: antirimbalzo

Cambiare stato una sola volta per pressione.

Un pulsante reale può aprire e chiudere il contatto più volte in pochi millisecondi. Il programma mantiene una lettura grezza e uno stato stabile: accetta la nuova lettura solo dopo 30 ms senza variazioni. Il cambio del LED avviene sul fronte che porta lo stato stabile a premuto, non mentre il pulsante rimane tenuto.

Fai così

1. Riutilizza D2 e il LED integrato.
2. Premi lentamente dieci volte: ogni pressione deve invertire il LED una sola volta.
3. Tieni il pulsante premuto due secondi; il LED non deve continuare a cambiare.

Programma commentato

#include <Arduino.h>
// Atlante: esempio originale per UNO R3.
// Verificare core, cablaggio e hardware prima dell’uso.
const byte pulsante = 2;
bool grezzo = HIGH, stabile = HIGH, acceso = false;
unsigned long cambiato = 0;
void setup() {
  pinMode(pulsante, INPUT_PULLUP);
  pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
  unsigned long ora = millis();
  bool lettura = digitalRead(pulsante);
  if (lettura != grezzo) { grezzo = lettura; cambiato = ora; }
  if (ora - cambiato >= 30 && stabile != grezzo) {
    stabile = grezzo;
    if (stabile == LOW) acceso = !acceso;
  }
  digitalWrite(LED_BUILTIN, acceso ? HIGH : LOW);
}

!= significa diverso. cambiato viene aggiornato a ogni variazione grezza, facendo ripartire il tempo di stabilizzazione.

Approfondimento ufficiale ↗

09 / Intermedio

Sensori: filtro, isteresi e calibrazione

Evitare che un’uscita oscilli vicino a una soglia.

Un filtro riduce le variazioni rapide ma introduce ritardo. L’isteresi usa due soglie: si accende sopra 650 e si spegne sotto 550; nella fascia intermedia conserva lo stato. Sono compiti diversi. La calibrazione richiede un riferimento noto e più punti: un valore ADC non diventa una misura affidabile soltanto perché è stato mediato.

Fai così

1. Collega il potenziometro ad A0.
2. Apri Monitor seriale a 115200; osserva valore grezzo, filtrato e stato.
3. Muovi attorno a 600, poi oltre 650 e sotto 550.

Programma commentato

#include <Arduino.h>
// Atlante: esempio originale per UNO R3.
// Verificare core, cablaggio e hardware prima dell’uso.
float filtrato = 0;
bool acceso = false;
unsigned long ultimo = 0;
void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(115200);
  filtrato = analogRead(A0);
}
void loop() {
  unsigned long ora = millis();
  if (ora - ultimo < 100) return;
  ultimo = ora;
  int grezzo = analogRead(A0);
  filtrato += 0.2f * (grezzo - filtrato);
  if (filtrato >= 650) acceso = true;
  else if (filtrato <= 550) acceso = false;
  digitalWrite(LED_BUILTIN, acceso ? HIGH : LOW);
  Serial.print(grezzo); Serial.print(',');
  Serial.print(filtrato); Serial.print(','); Serial.println(acceso);
}

Il nuovo valore si avvicina del 20% alla lettura a ogni campione. return interrompe questa chiamata di loop, non ferma Arduino.

Approfondimento ufficiale ↗

10 / Avanzato

Comandi seriali e gestione degli errori

Definire un piccolo protocollo controllabile e non bloccante.

Un protocollo chiarisce i comandi accettati e le risposte. Questo esempio accetta un carattere alla volta: 1 accende, 0 spegne, ? legge lo stato. Non serve attendere un’intera frase o accumulare testo senza limite. I terminatori di riga vengono ignorati. Ogni altro carattere produce un errore esplicito; l’uscita mantiene il suo stato.

Fai così

1. Collega solo USB e apri Monitor seriale a 115200.
2. Invia 1, ?, 0 e infine X.
3. Controlla che un comando sconosciuto non cambi il LED.

Programma commentato

#include <Arduino.h>
// Atlante: esempio originale per UNO R3.
// Verificare core, cablaggio e hardware prima dell’uso.
bool acceso = false;
void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
  if (Serial.available() <= 0) return;
  char comando = Serial.read();
  if (comando == '\r' || comando == '\n') return;
  if (comando == '1') acceso = true;
  else if (comando == '0') acceso = false;
  else if (comando != '?') { Serial.println("ERR comando"); return; }
  digitalWrite(LED_BUILTIN, acceso ? HIGH : LOW);
  Serial.println(acceso ? "ON" : "OFF");
}

Le virgolette singole indicano un carattere; quelle doppie una stringa. available controlla i dati già presenti: loop non aspetta una risposta.

Approfondimento ufficiale ↗

11 / Avanzato

I²C: trovare un dispositivo e usare una libreria

Separare collegamento elettrico, indirizzo e interpretazione dei dati.

I²C usa SDA e SCL con indirizzi. Su UNO R3 SDA corrisponde ad A4 e SCL ad A5. Uno scanner può rilevare una risposta ma non identifica con certezza modello o significato dei registri. Per un sensore serve la libreria corretta per la variante e un esempio del produttore. Pull-up e livelli devono essere compatibili: un chip a 3,3 V non è automaticamente compatibile con il bus a 5 V.

Fai così

1. Prima prova senza sensori: devono comparire zero risposte.
2. Scegli un breakout esplicitamente compatibile con UNO R3 e controlla alimentazione e pull-up nel suo manuale. Scollega USB durante il montaggio.
3. Collega SDA, SCL e GND; alimenta come da manuale. Poi rileva l’indirizzo e confrontalo con quello documentato.

Programma commentato

#include <Arduino.h>
// Atlante: esempio originale per UNO R3.
// Verificare core, cablaggio e hardware prima dell’uso.
#include <Wire.h>
void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.setWireTimeout(25000, true); // core AVR con timeout Wire
  byte trovati = 0;
  for (byte indirizzo = 8; indirizzo < 120; indirizzo++) {
    Wire.beginTransmission(indirizzo);
    byte esito = Wire.endTransmission();
    if (esito == 0) {
      Serial.print("Risposta 0x"); Serial.println(indirizzo, HEX);
      trovati++;
    }
    if (Wire.getWireTimeoutFlag()) {
      Serial.println("Timeout bus: controllare i collegamenti");
      Wire.clearWireTimeoutFlag();
      break;
    }
  }
  Serial.print("Totale: "); Serial.println(trovati);
}
void loop() {}

La scansione avviene una volta in setup. endTransmission restituisce un codice: zero indica un ACK. Le API di timeout sono specifiche del core: controlla che la tua versione le supporti.

Approfondimento ufficiale ↗

12 / Avanzato

Interrupt e dati condivisi

Contare eventi brevi mantenendo la routine di interrupt minima.

Un interrupt richiama una funzione quando accade un evento. Su UNO R3 D2 e D3 supportano gli interrupt esterni tramite digitalPinToInterrupt. La routine deve durare poco: aggiorna un contatore e torna. volatile indica che il valore può cambiare fuori dal flusso normale, ma non rende atomica una lettura a più byte su un processore a 8 bit.

Fai così

1. Usa un generatore di impulsi compatibile 0–5 V su D2 con GND comune; non collegare tensioni negative o superiori ai limiti.
2. In alternativa simula impulsi software nei test: un pulsante non filtrato produce conteggi da rimbalzo.
3. Osserva il conteggio a intervalli di un secondo sul monitor.

Programma commentato

#include <Arduino.h>
// Atlante: esempio originale per UNO R3.
// Verificare core, cablaggio e hardware prima dell’uso.
volatile unsigned long impulsi = 0;
unsigned long ultimo = 0;
void contaImpulso() { impulsi++; }
void setup() {
  Serial.begin(115200);
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), contaImpulso, FALLING);
}
void loop() {
  unsigned long ora = millis();
  if (ora - ultimo < 1000) return;
  ultimo = ora;
  noInterrupts();
  unsigned long copia = impulsi;
  interrupts();
  Serial.println(copia);
}

La sezione critica copia il contatore in poche istruzioni. La stampa avviene dopo aver riabilitato gli interrupt. Questo schema si usa qui nel normale loop, con interrupt inizialmente abilitati.

Approfondimento ufficiale ↗

13 / Avanzato

Progetto completo: monitor con stati

Integrare ingresso, soglie, stato iniziale e ripristino manuale.

Una macchina a stati assegna significato alle situazioni. Questo monitor didattico parte disarmato. Il pulsante deve essere rilasciato, poi premuto stabilmente per armare. Una lettura almeno 700 porta in allarme; l’allarme resta memorizzato. Una pressione, con lettura non superiore a 600, riconosce l’allarme e torna disarmato. Il LED lampeggia quando armato e resta acceso in allarme. Non è un sistema di protezione.

Fai così

1. Monta potenziometro A0 e pulsante D2–GND. Usa il LED integrato.
2. Esegui le prove in ordine: avvio, rilascio/pressione, superamento soglia, diminuzione della lettura, riconoscimento.
3. Prova anche a tenere premuto il pulsante mentre riavvii: non deve armarsi da solo.

Programma commentato

#include <Arduino.h>
// Atlante: esempio originale per UNO R3.
// Verificare core, cablaggio e hardware prima dell’uso.
enum Stato { DISARMATO, ARMATO, ALLARME };
Stato stato = DISARMATO;
bool grezzo = HIGH, stabile = HIGH, rilascioVisto = false;
unsigned long cambiato = 0;
void setup() {
  pinMode(2, INPUT_PULLUP);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);
}
void loop() {
  unsigned long ora = millis();
  bool letturaPulsante = digitalRead(2);
  bool pressione = false;
  if (letturaPulsante != grezzo) { grezzo = letturaPulsante; cambiato = ora; }
  if (ora - cambiato >= 30) {
    if (grezzo == HIGH) rilascioVisto = true;
    if (stabile != grezzo) {
      stabile = grezzo;
      pressione = (stabile == LOW && rilascioVisto);
    }
  }
  int misura = analogRead(A0);
  switch (stato) {
    case DISARMATO: if (pressione) stato = ARMATO; break;
    case ARMATO: if (misura >= 700) stato = ALLARME; break;
    case ALLARME: if (pressione && misura <= 600) stato = DISARMATO; break;
  }
  bool led = stato == ALLARME || (stato == ARMATO && (ora / 300) % 2 == 0);
  digitalWrite(LED_BUILTIN, led ? HIGH : LOW);
}

enum assegna nomi agli stati. switch rende esplicite le transizioni consentite. Nessun comando deve avere effetti non descritti dalla tabella di stato.

Approfondimento ufficiale ↗

14 / Professionale

Test automatici, memoria e struttura del progetto

Dimostrare cosa funziona e conoscere i limiti della verifica.

Prima definisci i requisiti osservabili, poi separa la logica pura dall’hardware. La funzione decide non legge pin: riceve dati e restituisce una scelta. È più facile provarla con valori di confine. Un test che stampa OK non prova alimentazione, cablaggio o comportamento temporale. Su UNO R3 la memoria è limitata: controlla il rapporto di compilazione e evita allocazioni dinamiche ripetute in applicazioni lunghe.

Fai così

1. Compila ed esegui lo sketch di test: il monitor deve riportare OK.
2. Cambia volontariamente >= in > e verifica che venga segnalato KO. Poi correggi.
3. Nel progetto finale separa configurazione pin, acquisizione, logica e uscita in funzioni; conserva una versione funzionante prima di modificare.

Programma commentato

#include <Arduino.h>
// Atlante: esempio originale per UNO R3.
// Verificare core, cablaggio e hardware prima dell’uso.
bool decide(bool precedente, int valore) {
  if (valore >= 650) return true;
  if (valore <= 550) return false;
  return precedente;
}
void setup() {
  Serial.begin(115200);
  bool ok = !decide(false, 550) && decide(false, 650)
    && decide(true, 600) && !decide(false, 600);
  Serial.println(ok ? "OK" : "KO");
}
void loop() {}

I quattro casi verificano soglia inferiore, superiore e memoria nella fascia intermedia. Il test di mutazione volontaria controlla che la prova sia capace di trovare un errore.

Approfondimento ufficiale ↗

15 / Professionale

Bus, librerie e portabilità: il passo successivo

Portare un progetto su un altro dispositivo senza ipotesi nascoste.

UART, I²C e SPI risolvono esigenze diverse. UART scambia flussi di byte; I²C indirizza periferiche su due segnali; SPI usa clock, dati e selezione del dispositivo. Il protocollo non garantisce compatibilità di tensione. Una libreria nasconde registri e sequenze, ma va scelta per chip e scheda esatti. Il porting da UNO R3 a ESP32 o UNO R4 richiede verifiche: numerazione pin, tensioni, ADC, PWM, timer, dimensioni dei tipi e API possono cambiare.

Fai così

1. Scegli un solo modulo con datasheet, scheda breakout identificabile e libreria mantenuta. Registra versione, dipendenze e licenza.
2. Compila prima l’esempio minimo del produttore per la scheda esatta. Controlla errori di inizializzazione e assenza del modulo.
3. Integra una funzione alla volta nel progetto. Misura durata delle chiamate e comportamento quando il bus non risponde.

Per un driver robusto definisci almeno begin, acquisisci e statoErrore. Non riavviare indefinitamente senza una scadenza e un messaggio diagnostico.

Approfondimento ufficiale ↗

16 / Professionale

Consegna professionale: progetto riproducibile

Trasformare il prototipo in una consegna verificabile.

Un progetto professionale comprende requisiti, codice, schema elettrico, distinta materiali, versioni, piano di prova e limiti. Il fatto che un prototipo funzioni una volta non ne dimostra affidabilità. Definisci comportamento all’avvio, perdita alimentazione, ingresso fuori intervallo, comunicazione assente e ripristino. La breadboard è utile per imparare ma non equivale a un assemblaggio qualificato per esercizio continuo.

Fai così

1. Usa il monitor della lezione 13 come progetto finale. Scrivi cinque requisiti misurabili e una tabella delle transizioni.
2. Archivia sketch, schema e distinta con revisione. Registra scheda, core, IDE e strumenti di misura. Conserva il progetto in Git o in copie versionate.
3. Esegui il piano di prova con risultati attesi/osservati. Usa il quaderno Academy per relazione e dati; documenta anche gli esiti negativi.
4. Per impiego reale fai valutare alimentazione, driver, protezioni, EMC, ambiente e requisiti applicabili da competenze adeguate al prodotto.

La competenza professionale si dimostra con progetti e prove. La percentuale del corso indica soltanto le tappe che hai segnato come completate; non è una certificazione.

Approfondimento ufficiale ↗