WiFi
La scheda comunica con Arduino Cloud attraverso la rete, rendendo possibile una dashboard teorica di comando e monitoraggio.
Quarto Michelangelo - 5ª AMS
Studio teorico di un sistema di automazione per l'apertura e la chiusura di un cancello scorrevole controllato da Arduino e gestibile tramite rete WiFi con Arduino Cloud.
La scheda comunica con Arduino Cloud attraverso la rete, rendendo possibile una dashboard teorica di comando e monitoraggio.
Finecorsa, stop di emergenza e blocco dei comandi simultanei evitano movimenti incoerenti nel modello didattico.
Il motore DC viene pilotato da un driver di potenza che separa la logica di controllo dalla parte di alimentazione.
Variabili condivise e dashboard permettono di simulare apertura, chiusura, stop e stato del cancello.
Architettura generale
Il sistema rappresenta un modello teorico di automazione per cancello scorrevole, pensato per spiegare in modo chiaro il rapporto tra elettronica, programmazione, alimentazione e IoT.
Il progetto immagina un cancello scorrevole azionato da un motore DC a 12V. Arduino UNO R4 WiFi riceve comandi da Arduino Cloud, interpreta sensori e finecorsa e invia segnali al driver BTS7960 IBT-2.
Non si tratta di un impianto reale certificato, ma di un modello espositivo utile per comprendere il funzionamento di un sistema automatico.
Descrivere come un microcontrollore possa coordinare apertura e chiusura di un cancello, controllando direzione del motore, finecorsa, encoder e segnalazione luminosa.
Il lavoro mette in evidenza il flusso logico: comando, elaborazione, attuazione, controllo di sicurezza e aggiornamento dello stato.
Il sistema e composto da controllo logico, driver di potenza, motore DC, finecorsa, encoder, LED e interfaccia Cloud.
Arduino UNO R4 WiFi integra la connessione alla rete; il BTS7960 e adatto a pilotare motori DC in modo bidirezionale.
Microcontrollore, PWM, driver H-bridge, ingressi digitali, encoder incrementale, alimentazione separata e Arduino Cloud.
Il progetto ha scopo didattico: serve a dimostrare la capacita di integrare 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: unita centrale di controllo.
Funzione: legge comandi Cloud, controlla driver, finecorsa, encoder e LED.
Scelta: integra connettivita WiFi e mantiene la semplicita 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.
Scelta: l'encoder permette una lettura teorica di velocita e posizione.
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 e aperto.
Scelta: evita che il motore continui oltre il limite.
Ruolo: sensore di limite in chiusura.
Funzione: interrompe il movimento quando il cancello e chiuso.
Scelta: protegge struttura, motore e driver.
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 con Encoder
| Gruppo | Collegamento | Destinazione |
|---|---|---|
| Arduino UNO R4 WiFi → BTS7960 | D5 | RPWM |
| Arduino UNO R4 WiFi → BTS7960 | D6 | LPWM |
| Arduino UNO R4 WiFi → BTS7960 | 5V | VCC |
| Arduino UNO R4 WiFi → BTS7960 | GND | GND |
| Batteria 12V → BTS7960 | +12V | B+ |
| Batteria 12V → BTS7960 | GND | B- |
| Motore DC 12V → BTS7960 | Filo motore 1 | M+ |
| Motore DC 12V → BTS7960 | Filo motore 2 | M- |
| Encoder motore → Arduino | VCC | 5V |
| Encoder motore → Arduino | GND | GND |
| Encoder motore → Arduino | Encoder A | D2 |
| Encoder motore → Arduino | Encoder B | D3 |
| Finecorsa | Finecorsa apertura | D8 + GND |
| Finecorsa | Finecorsa chiusura | D9 + GND |
| LED lampeggiante | D10 | Resistenza 220Ω → LED → GND |
Logica operativa
Il ciclo segue una sequenza controllata: comando remoto, verifica dello stato, pilotaggio del motore, lettura sensori e aggiornamento dashboard.
L'utente preme APRI, CHIUDI oppure STOP.
Arduino sincronizza le variabili Cloud e rileva il comando.
Arduino invia PWM su RPWM o LPWM.
Il driver fornisce energia al motore DC nella direzione richiesta.
Il finecorsa apertura o chiusura ferma il motore.
L'encoder legge impulsi e il LED lampeggia durante il movimento.
Sequenza operativa completa
La timeline mostra il percorso del comando dalla dashboard fino all'arresto del motore e all'aggiornamento dello stato su Arduino Cloud.
Il comando viene inviato dalla dashboard teorica tramite una variabile Cloud di tipo booleano.
Arduino UNO R4 WiFi sincronizza le variabili e riconosce la richiesta di apertura.
La scheda invia il segnale PWM al pin RPWM o LPWM in base alla direzione richiesta.
Il driver gestisce la corrente del motore separando la parte di potenza dalla logica Arduino.
La rotazione del motore viene trasformata nel movimento lineare del cancello scorrevole.
Gli impulsi dell'encoder permettono di stimare lo spostamento e controllare il movimento.
La segnalazione luminosa rende visibile che il sistema e in apertura o chiusura.
Quando viene premuto, il finecorsa porta il segnale a LOW e informa Arduino del limite raggiunto.
Le uscite PWM vengono portate a zero e il driver interrompe l'alimentazione del motore.
La variabile statoCancello comunica alla dashboard se il cancello e aperto, chiuso o fermo.
Pannello di controllo simulato
Una dashboard tecnica raccoglie valori simulati per mostrare lo stato logico del prototipo durante apertura, chiusura e arresto.
Stato operativo inviato alla dashboard.
Arduino Cloud sincronizzato.
Lettura teorica di velocita e posizione.
Ingresso D8 in attesa del limite.
Ingresso D9 in attesa del limite.
MICHELANGELO SMART GATE
Dall'idea iniziale alla realizzazione del modello teorico 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 con encoder, finecorsa di sicurezza e dashboard di monitoraggio.

Analisi e selezione dei componenti necessari alla realizzazione del progetto: Arduino UNO R4 WiFi, driver BTS7960, motore DC con encoder, finecorsa, 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, gestione encoder, gestione finecorsa 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.

Verifica completa di apertura, chiusura, encoder, finecorsa, dashboard cloud e logiche di sicurezza.

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

Sistema teorico completo composto da Arduino UNO R4 WiFi, driver BTS7960, motore DC con encoder, finecorsa, dashboard Arduino Cloud, monitoraggio remoto e sito tecnico Michelangelo Smart Gate.
Sketch Arduino teorico
Il codice e pensato come esempio didattico per pin, motore, finecorsa, encoder e Arduino Cloud.
#include "thingProperties.h"
const int pinRPWM = 5;
const int pinLPWM = 6;
const int pinEncoderA = 2;
const int pinEncoderB = 3;
const int pinFinecorsaApertura = 8;
const int pinFinecorsaChiusura = 9;
const int pinLed = 10;
volatile long encoderCount = 0;
int velocitaMotore = 180;
void setup() {
pinMode(pinRPWM, OUTPUT);
pinMode(pinLPWM, OUTPUT);
pinMode(pinLed, OUTPUT);
pinMode(pinFinecorsaApertura, INPUT_PULLUP);
pinMode(pinFinecorsaChiusura, INPUT_PULLUP);
pinMode(pinEncoderA, INPUT_PULLUP);
pinMode(pinEncoderB, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(pinEncoderA), leggiEncoder, CHANGE);
initProperties();
ArduinoCloud.begin(ArduinoIoTPreferredConnection);
fermaMotore();
}
void loop() {
ArduinoCloud.update();
if (stopMotore) {
fermaMotore();
apri = false;
chiudi = false;
stopMotore = false;
}
if (apri && !chiudi) apriCancello();
if (chiudi && !apri) chiudiCancello();
if (apri && chiudi) fermaMotore();
aggiornaLampeggiante();
}
void apriCancello() {
if (digitalRead(pinFinecorsaApertura) == LOW) {
fermaMotore();
statoCancello = "Aperto";
apri = false;
return;
}
analogWrite(pinRPWM, velocitaMotore);
analogWrite(pinLPWM, 0);
statoCancello = "In apertura";
}
void chiudiCancello() {
if (digitalRead(pinFinecorsaChiusura) == LOW) {
fermaMotore();
statoCancello = "Chiuso";
chiudi = false;
return;
}
analogWrite(pinRPWM, 0);
analogWrite(pinLPWM, velocitaMotore);
statoCancello = "In chiusura";
}
void fermaMotore() {
analogWrite(pinRPWM, 0);
analogWrite(pinLPWM, 0);
digitalWrite(pinLed, LOW);
statoCancello = "Fermo";
}
void leggiEncoder() {
bool a = digitalRead(pinEncoderA);
bool b = digitalRead(pinEncoderB);
if (a == b) encoderCount++;
else encoderCount--;
}
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);
}
}
}
Lo sketch mostra la struttura teorica: controllo motore, finecorsa, encoder, LED e variabili Arduino Cloud.
Controlli e limiti
In un cancello reale la sicurezza e la parte piu importante. Qui viene descritta in modo teorico per capire quali controlli sono necessari.
Ferma il motore quando il cancello e completamente aperto.
Interrompe la chiusura al punto finale.
Ha priorita 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.
Questo progetto non sostituisce un impianto certificato.
Interfaccia IoT
Arduino Cloud permette di creare una Thing, definire variabili condivise e costruire una dashboard per controllare e monitorare il sistema teorico 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 | bool | Read & Write | Comando apertura |
| chiudi | bool | Read & Write | Comando chiusura |
| stopMotore | bool | Read & Write | Arresto immediato |
| statoCancello | String | Read Only | Visualizzazione stato |
Controllo remoto, monitoraggio, aggiornamento dello stato e separazione tra interfaccia utente e logica embedded.
Visual concept
Le immagini sono placeholder grafici moderni, utili per rappresentare le parti del progetto anche senza fotografie reali dei componenti.
Vista teorica del cancello scorrevole con motore laterale e finecorsa.
Scheda di controllo con connettivita integrata.
Modulo di potenza per comandare il motore DC.
Attuatore 12V con lettura degli impulsi.
Rappresentazione dei segnali tra Arduino, driver e motore.
Interfaccia con pulsanti APRI, CHIUDI, STOP e stato.
Scenario teorico per verificare logica e sicurezza.
Sintesi finale
Il progetto Michelangelo Smart Gate riassume il valore formativo dell'integrazione tra discipline tecniche.
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.
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