WiFi
Arduino Cloud consente apertura, chiusura, stop, reset e monitoraggio remoto.
Quarto Michelangelo – 5ª AMS
Prototipo didattico di cancello scorrevole automatico controllato da Arduino UNO R4 WiFi, con gestione da Arduino Cloud, finecorsa, doppia fotocellula di sicurezza e chiusura automatica.
Arduino Cloud consente apertura, chiusura, stop, reset e monitoraggio remoto.
Due finecorsa e due fotocellule analogiche controllano i limiti di corsa e la presenza di ostacoli durante la chiusura.
Dopo 30 secondi dall'apertura completa, il sistema esegue la chiusura automatica solo in assenza di ostacoli.
Dashboard con comandi APRI, CHIUDI, STOP, RESET e stato del cancello.
Architettura generale
Il sistema rappresenta un prototipo didattico funzionante di automazione per cancello scorrevole, realizzato per spiegare in modo chiaro il rapporto tra meccanica, elettronica, programmazione, alimentazione e IoT.
Il prototipo utilizza un cancello scorrevole azionato da un motore DC a 12V. Arduino UNO R4 WiFi riceve comandi da Arduino Cloud, legge finecorsa e fotocellule analogiche e invia segnali al driver BTS7960 IBT-2.
Il lavoro ha finalità didattiche e non sostituisce un cancello automatico certificato, installato secondo le norme vigenti.
Mostrare come un microcontrollore possa coordinare apertura, chiusura, stop, reset, sicurezza tramite fotocellule e chiusura automatica dopo 30 secondi.
Il lavoro mette in evidenza il flusso logico: comando, controllo preventivo, attuazione, sicurezza e aggiornamento dello stato.
Il sistema è composto da controllo logico, driver di potenza, motore DC, finecorsa, doppia fotocellula analogica, LED e interfaccia Cloud.
Arduino UNO R4 WiFi integra la connessione alla rete; il BTS7960 è adatto a pilotare motori DC in modo bidirezionale.
Microcontrollore, PWM, driver H-bridge, ingressi digitali, letture analogiche, alimentazione separata e Arduino Cloud.
Il progetto ha scopo didattico: serve a dimostrare la capacità di integrare meccanica, automazione, elettronica, programmazione e IoT in un unico sistema.
Distinta funzionale
Ogni elemento ha un ruolo preciso nella catena di controllo: acquisizione del comando, elaborazione, potenza, movimento, sicurezza e monitoraggio.
Ruolo: unità centrale di controllo.
Funzione: legge comandi Cloud, controlla driver, finecorsa, fotocellule e LED.
Scelta: integra connettività Wi-Fi e mantiene la semplicità dell'ambiente Arduino.
Ruolo: ponte di potenza per il motore DC.
Funzione: consente rotazione avanti e indietro tramite RPWM e LPWM.
Scelta: supporta correnti maggiori rispetto ai piccoli driver didattici.
Ruolo: attuatore del cancello.
Funzione: trasforma energia elettrica in movimento lineare tramite pignone e cremagliera.
Scelta: il riduttore rende il movimento più controllabile e adatto al prototipo.
Ruolo: alimentazione della parte di potenza.
Funzione: fornisce energia al motore attraverso il BTS7960.
Scelta: separa la corrente motore dalla scheda Arduino.
Ruolo: sensore di limite in apertura.
Funzione: segnala ad Arduino che il cancello è aperto.
Scelta: evita che il motore continui oltre il limite.
Ruolo: sensore di limite in chiusura.
Funzione: interrompe il movimento quando il cancello è chiuso.
Scelta: protegge struttura, motore e driver.
Ruolo: rilevamento ostacoli.
Funzione: controlla l'area di passaggio durante la chiusura.
Logica: se la lettura supera la soglia impostata, Arduino ferma il motore e avvia la riapertura.
Scelta: doppio controllo per aumentare l'affidabilità del prototipo.
Ruolo: rilevamento ostacoli.
Funzione: controlla l'area di passaggio durante la chiusura.
Logica: se la lettura supera la soglia impostata, Arduino ferma il motore e avvia la riapertura.
Scelta: doppio controllo per aumentare l'affidabilità del prototipo.
Ruolo: segnalazione visiva.
Funzione: lampeggia durante apertura o chiusura.
Scelta: rende lo stato del sistema immediatamente comprensibile.
Ruolo: connessione elettrica tra moduli.
Funzione: portano segnali, alimentazione e riferimento GND comune.
Scelta: permettono cablaggi rapidi e modificabili.
Ruolo: interfaccia IoT.
Funzione: ospita variabili condivise e dashboard.
Scelta: semplifica controllo remoto e monitoraggio.
Schema ufficiale
Arduino UNO R4 WiFi – Driver BTS7960 – Motore DC 12V – Finecorsa – Doppia fotocellula
| Gruppo | Collegamento | Destinazione |
|---|---|---|
| Arduino UNO R4 WiFi → BTS7960 | D5 | RPWM |
| Arduino UNO R4 WiFi → BTS7960 | D6 | LPWM |
| Arduino UNO R4 WiFi → BTS7960 | 5V | VCC, R_EN e L_EN |
| Arduino UNO R4 WiFi → BTS7960 | GND | GND |
| Batteria/alimentatore 12V → BTS7960 | Positivo 12V | B+ |
| Batteria/alimentatore 12V → BTS7960 | Negativo 12V | B- |
| Motore DC 12V → BTS7960 | Motore | M+ e M- |
| Fotocellula analogica 1 | Segnale | A1 |
| Fotocellula analogica 2 | Segnale | A2 |
| Finecorsa | Finecorsa apertura | D8 + GND |
| Finecorsa | Finecorsa chiusura | D9 + GND |
| LED lampeggiante | D10 | Resistenza 220/330Ω → LED → GND |
Logica operativa
Il ciclo segue una sequenza controllata: comando remoto, verifica di finecorsa e fotocellule, pilotaggio del motore, sicurezza e aggiornamento dashboard.
L'utente preme APRI, CHIUDI, STOP oppure RESET dalla dashboard.
Arduino UNO R4 WiFi riceve il comando e aggiorna le variabili Cloud.
La scheda verifica finecorsa e fotocellule prima di avviare il movimento.
Arduino pilota D5 o D6 per scegliere la direzione del motore.
Il driver alimenta il motore DC con la potenza fornita dalla batteria a 12V.
Il LED lampeggia durante il movimento e le fotocellule controllano il passaggio in chiusura.
Sequenza operativa completa
La timeline mostra il percorso del comando dalla dashboard fino all'arresto del motore, al controllo degli ostacoli e all'eventuale chiusura automatica.
L'utente invia APRI, CHIUDI, STOP o RESET dalla dashboard.
Arduino UNO R4 WiFi sincronizza le variabili e riconosce la richiesta.
Il prototipo verifica lo stato dei limiti e dell'area di passaggio.
La scheda usa D5 o D6 per scegliere apertura o chiusura.
Il driver gestisce la potenza del motore DC mantenendo separata la logica Arduino.
La segnalazione luminosa rende visibile che il cancello è in movimento.
Il finecorsa di apertura o chiusura blocca il movimento quando viene raggiunto il punto finale.
Le letture analogiche su A1 e A2 monitorano l'area di passaggio.
Se almeno una lettura supera la soglia, Arduino ferma il motore, attende brevemente e riapre.
Dopo l'apertura completa parte la chiusura automatica solo se il passaggio è libero.
Pannello di controllo del prototipo
Una dashboard tecnica raccoglie gli stati principali del prototipo durante apertura, chiusura, arresto, controllo ostacoli e chiusura automatica.
Stato operativo inviato alla dashboard.
Arduino Cloud sincronizzato.
Ingresso analogico A1.
Ingresso analogico A2.
Ingresso D8 in attesa del limite.
Ingresso D9 in attesa del limite.
Autochiusura: 30 s
MICHELANGELO SMART GATE
Dall'idea iniziale alla realizzazione del prototipo didattico di cancello automatico controllato tramite Arduino UNO R4 WiFi e Arduino Cloud.

Studio dell'idea progettuale e definizione dell'architettura generale del sistema: controllo Arduino, motore DC, finecorsa di sicurezza, doppia fotocellula e dashboard di monitoraggio.

Analisi e selezione dei componenti necessari alla realizzazione del progetto: Arduino UNO R4 WiFi, driver BTS7960, motore DC 12V, finecorsa, fotocellule analogiche, batteria, cremagliera, pignone e materiale strutturale.

Progettazione CAD della struttura del cancello tramite Fusion 360 per definire dimensioni, supporti e posizionamento dei componenti.

Produzione tramite stampa 3D dei componenti progettati: supporti motore, supporti finecorsa, parti strutturali ed elementi di fissaggio.

Realizzazione del sistema meccanico che permette il movimento del cancello tramite trasmissione del moto e assemblaggio della parte mobile.

Sviluppo del software di controllo per apertura, chiusura, stop, reset, gestione finecorsa, controllo fotocellule e monitoraggio dello stato del sistema.

Configurazione della connessione WiFi e della dashboard cloud per comandi remoti di apertura, chiusura, stop e monitoraggio dello stato.

Durante i test sono state verificate la risposta dei finecorsa, il controllo tramite Arduino Cloud, il lampeggio del LED, la gestione delle due fotocellule e la chiusura automatica dopo 30 secondi.

Controllo finale dell'allineamento meccanico, della risposta dei finecorsa e della stabilità del movimento prima della versione conclusiva.

Prototipo didattico composto da Arduino UNO R4 WiFi, driver BTS7960, motore DC 12V, finecorsa, due fotocellule analogiche, dashboard Arduino Cloud, monitoraggio remoto e sito tecnico Michelangelo Smart Gate.
Logica Arduino del prototipo
Il blocco riassume la logica reale usata nel progetto: comandi Cloud, lettura delle fotocellule analogiche, finecorsa, driver BTS7960, LED e chiusura automatica.
#include "thingProperties.h"
const int pinRPWM = 5;
const int pinLPWM = 6;
const int pinFotocellula1 = A1;
const int pinFotocellula2 = A2;
const int pinFinecorsaApertura = 8;
const int pinFinecorsaChiusura = 9;
const int pinLed = 10;
const int sogliaFotocellula = 600;
const unsigned long tempoAutochiusura = 30000;
unsigned long istanteAperturaCompleta = 0;
bool autochiusuraAttiva = false;
void setup() {
pinMode(pinRPWM, OUTPUT);
pinMode(pinLPWM, OUTPUT);
pinMode(pinLed, OUTPUT);
pinMode(pinFinecorsaApertura, INPUT_PULLUP);
pinMode(pinFinecorsaChiusura, INPUT_PULLUP);
initProperties();
ArduinoCloud.begin(ArduinoIoTPreferredConnection);
fermaMotore();
}
void loop() {
ArduinoCloud.update();
if (stopMotore) {
fermaMotore();
autochiusuraAttiva = false;
apri = false;
chiudi = false;
stopMotore = false;
}
if (resetCancello) {
aggiornaStatoDaFinecorsa();
resetCancello = false;
}
if (apri) apriCancello();
if (chiudi) chiudiCancello();
if (autochiusuraAttiva && millis() - istanteAperturaCompleta >= tempoAutochiusura) {
if (!ostacoloPresente()) chiudiCancello();
}
aggiornaLampeggiante();
}
void apriCancello() {
if (digitalRead(pinFinecorsaApertura) == LOW) {
fermaMotore();
statoCancello = "Aperto";
istanteAperturaCompleta = millis();
autochiusuraAttiva = true;
apri = false;
return;
}
analogWrite(pinRPWM, 180);
analogWrite(pinLPWM, 0);
statoCancello = "In apertura";
}
void chiudiCancello() {
if (ostacoloPresente()) {
fermaMotore();
delay(500);
apriCancello();
return;
}
if (digitalRead(pinFinecorsaChiusura) == LOW) {
fermaMotore();
statoCancello = "Chiuso";
chiudi = false;
return;
}
analogWrite(pinRPWM, 0);
analogWrite(pinLPWM, 180);
statoCancello = "In chiusura";
}
bool ostacoloPresente() {
return analogRead(pinFotocellula1) > sogliaFotocellula ||
analogRead(pinFotocellula2) > sogliaFotocellula;
}
void fermaMotore() {
analogWrite(pinRPWM, 0);
analogWrite(pinLPWM, 0);
digitalWrite(pinLed, LOW);
statoCancello = "Fermo";
}
void aggiornaStatoDaFinecorsa() {
if (digitalRead(pinFinecorsaApertura) == LOW) statoCancello = "Aperto";
else if (digitalRead(pinFinecorsaChiusura) == LOW) statoCancello = "Chiuso";
else statoCancello = "Fermo";
}
void aggiornaLampeggiante() {
static unsigned long ultimoCambio = 0;
static bool acceso = false;
if (statoCancello == "In apertura" || statoCancello == "In chiusura") {
if (millis() - ultimoCambio >= 400) {
ultimoCambio = millis();
acceso = !acceso;
digitalWrite(pinLed, acceso);
}
}
}
La logica usa ArduinoCloud.update(), letture analogiche su A1 e A2, soglia fotocellule, finecorsa D8 e D9 con INPUT_PULLUP, driver BTS7960 su D5/D6, LED su D10, stop con riapertura in presenza di ostacolo e autochiusura dopo 30 secondi.
Controlli e limiti
Nel prototipo la sicurezza è gestita con finecorsa, stop immediato, controllo ostacoli e chiusura automatica solo con passaggio libero.
Ferma il motore quando il cancello è completamente aperto.
Interrompe la chiusura al punto finale.
Durante la chiusura, le due fotocellule monitorano il passaggio. Se almeno una rileva un ostacolo oltre la soglia impostata, Arduino interrompe il movimento e riapre il cancello.
Dopo 30 secondi dall'apertura completa, il sistema avvia la chiusura soltanto quando le fotocellule rilevano un'area libera.
Ha priorità e porta subito le uscite PWM a zero.
Evita apertura e chiusura contemporanee.
Motore a 12V separato dalla logica Arduino.
Le masse devono avere lo stesso riferimento elettrico.
Un sistema reale richiede protezioni dimensionate.
Il prototipo ha finalità didattiche e non sostituisce un cancello automatico certificato, installato secondo le norme vigenti.
Interfaccia IoT
Arduino Cloud permette di creare una Thing, definire variabili condivise e costruire una dashboard per controllare e monitorare il prototipo da remoto.
Una piattaforma online per sincronizzare dati e comandi con una scheda compatibile.
Si associa Arduino UNO R4 WiFi, si configurano rete e credenziali, poi si aggiungono le variabili Cloud.
| Variabile | Tipo | Permesso | Uso |
|---|---|---|---|
| apri | Boolean | Read & Write | Comando di apertura |
| chiudi | Boolean | Read & Write | Comando di chiusura |
| stopMotore | Boolean | Read & Write | Arresto immediato del motore |
| resetCancello | Boolean | Read & Write | Reimpostazione e lettura dello stato iniziale |
| statoCancello | String | Read Only | Stato operativo del sistema |
Controllo remoto, monitoraggio, aggiornamento dello stato e separazione tra interfaccia utente e logica embedded.
Documentazione visiva
Le immagini raccolgono parti del prototipo, componenti e schermate utili alla presentazione tecnica del progetto.
Vista del cancello scorrevole con motore laterale e finecorsa.
Scheda di controllo con connettività integrata.
Modulo di potenza per comandare il motore DC.
Attuatore collegato al pignone e alla cremagliera.
Rappresentazione dei segnali tra Arduino, driver, fotocellule e motore.
Interfaccia con pulsanti APRI, CHIUDI, STOP, RESET e stato.
Scenario di prova per controllare logica, sicurezza e autochiusura.
Sintesi finale
Il progetto Michelangelo Smart Gate riassume il valore formativo dell'integrazione tra discipline tecniche e prototipo reale.
Questo progetto dimostra come meccanica, sistemi automatici, elettronica e informatica possano integrarsi per creare un sistema intelligente controllabile da remoto.
Il cancello automatico con Arduino UNO R4 WiFi è un esempio concreto di sistema embedded: riceve input, elabora condizioni, attiva un attuatore, legge sensori e comunica con una piattaforma Cloud.
Durante lo sviluppo sono state applicate competenze di progettazione meccanica, modellazione 3D, stampa 3D, elettronica, programmazione e monitoraggio remoto, dimostrando come discipline diverse possano collaborare nella realizzazione di un unico sistema automatizzato.
Durante i test sono state verificate la risposta dei finecorsa, il controllo tramite Arduino Cloud, il lampeggio del LED, la gestione delle due fotocellule e la chiusura automatica dopo 30 secondi.
Il progetto Michelangelo Smart Gate rappresenta un modello didattico completo che unisce innovazione, automazione e tecnologie IoT, evidenziando le potenzialità dell'integrazione tra hardware, software e servizi Cloud.
Quarto Michelangelo – 5ª AMS
Torna alla HomeScarica la relazione tecnica completa del progetto Michelangelo Smart Gate in formato PDF.
Progetto realizzato da:
Quarto Michelangelo – 5ª AMS
Anno scolastico 2025/2026