Categoria: Giochi di luce con Arduino

  • Wokwi

    Disponibile all’indirizzo https://wokwi.com/, Wokwi è un simulatore online per Arduino, ESP32 ed altre schede di sviluppo e dispositivi di maggior uso.

    Quando si avvia un nuovo progetto, dopo aver selezionato il microprocessore da usare fra quelli supportati, si accede ad una schermata nella cui metà di sinistra vi è l’editor del codice e nella cui parte superiore compaiono 3 schede:

    • sketch.ino

    • diagram.json

    • Gestione librerie

    delle quali, per chi già smanetta, sono ovvie le funzionalità della prima e della terza.

    Nella parte destra, in cui compare già la scheda selezionata, è possibile in modo interattivo disegnare il circuito da simulare, aggiungendo i componenti e definendo le loro connessioni.

    Cablaggio del circuito da simulare

    Come fare per: (Se si è nel browser Firefox e le scorciatoie da tastiera non funzionano, assicurarsi che sia disabilitata l’impostazione “Cerca testo quando inizi a digitare“.)

    • Aggiungere un dispositivo
      Cliccando sul pulsante “+”, di color viola e posto nella parte superiore dell’editor di diagrammi, si aprirà un menu a discesa con un elenco dei dispositivi dei quali poter far uso; il dispositivo scelto verrà aggiunto e potrà essere spostato nella posizione desiderata facendo clic su di essa e trascinandola con il mouse.

    • Selezionare più parti
      Cliccare sulle parti interessate tenendo premuto il tasto Maiuscolo.

    • Duplicare
      Selezionare la parte interessata e premere “D” tante volte quante sono le copie da creare.

    • Cancellare
      Selezionare e premere il pulsante Canc.

    • Copiare
      Ctrl+C dopo aver selezionato le parti interessate; se si selezionano più parti, vengono copiati anche tutti i fili di collegamento fra esse.

    • Incollare
      Ctrl+V. Il copia incolla può essere utilizzato anche fra progetti diversi.
      Se la copia non è visibile, può essere che essa sia al di fuori dell’area attualmente visibile; si consiglia in tal caso di agire sullo zoom per trovarle.

    • Ruotare

      Dopo aver selezionato la parte da ruotare, premendo “R” essa ruoterà di 90° in senso orario; per una rotazione diversa, modificare l’attributo “rotate” nella scheda diagram.json.

    ctrl A, ctrl Z e ctrl Y conservano le consuete funzioni. La combinazione dei tasti alt + Maiusc + F consente la formattazione automatica nell’editor del codice, in alternativa alla voce di menu Format code.

    Collegamenti

    Per creare un collegamento tra due piedini, basta fare clic in sequenza su di essi e sarà subito creato il filo desiderato; se si vuole invece che il filo segua un percorso specifico, si deve selezionare il primo pin e guidarlo cliccando dove si vuole che vada. Il tasto “Esc”, cancella il collegamento che si sta tracciando.

    I fili che partono dai pin GND sono automaticamente neri, così come sono rossi quelli che partono dal pin 5 V; mentre gli altri collegamenti vengono creati di colore verde. È possibile modificare il colore di un filo: facendo clic su di esso si apre un menu dal quale è possibile selezionare un nuovo colore.

    Altre scorciatoie da tastiera da ricordare per lo zoom:

    “–”, per rimpicciolire

    “+”, per ingrandire

    “F”, per adattare il diagramma alla finestra (zoom automatico)

    Aggancio alla griglia

    Il tasto “G” alterna la presenza della griglia e dei righelli sullo schermo con maglie di 2,54 mm.

    Se la griglia è attiva i dispositivi si agganciano ad essa; per fare assumere una posizione libera pigiare il tasto Maiusc durante il rilascio.

    Il tasto Alt o il tasto Ctrl alternano l’aggancio ad una griglia fine la cui maglia è di 1,27 mm, indipendentemente dal fatto che la griglia sia visibile o meno.

    Quando si avvia la simulazione, Wokwi nasconde la griglia e la ripristina al suo arresto.

    Il monitor seriale

    In Wokwi, per impostazione predefinita, il monitor seriale viene mostrato solo dopo aver stampato su di esso un output dal programma; per cui, se si vuole che venga mostrato all’avvio della simulazione, la maniera più semplice è di inserire nel setup un comando di stampa sul monitor di una stringa vuota con Serial.println(” “).

    Librerie per Arduino

    Per includere una libreria, digitare “#“ in una riga vuota dell’editor di codice: si aprirà un menu a discesa di completamento automatico con le librerie più usate, precedute dalla direttiva #include.

    Per impostazione predefinita, Wokwi compila il codice con le librerie Arduino integrate standard, come Wire.h e SPI.

    Aggiunta di librerie di terze parti

    Si può aggiungere una libreria di terze parti ad un progetto, dalla scheda “Gestione Librerie“; premere il pulsante viola “+” e, mentre se ne digita il nome nella casella di ricerca, fare clic nell’elenco delle librerie che è possibile aggiungere.

    Tale operazione creerà il file “libraries.txt” che è un semplice file di testo che elenca tutte le librerie installate nel tuo progetto, una per riga e nel quale il simbolo “#” individua i commenti. Se vuoi installare una versione specifica di una libreria aggiungi “@” dopo il nome della libreria, seguito dal numero della versione che si desidera installare.

    Il file diagram.json

    Ogni progetto di simulazione contiene un file diagram.json. Questo file definisce i componenti che verranno utilizzati per la simulazione, le loro proprietà e le connessioni.

    La descrizione completa di questo file esula dall’obiettivo di questa guida. Ci basta sapere che in esso è possibile indicare per le resistenze valori diversi da quelli proposti o imporre una rotazione ad un dispositivo più fine di quella di 90° in 90° ottenibile con il tasto “R”.

    Ad esempio

    {

          “type”: “wokwi-resistor”,

          “id”: “r1”,

          “top”: -188.05,

          “left”: -201.6,

          “rotate”: 45,

          “attrs”: { “value”: “220” }

        }

     imprime alla resistenza, denominata r1, una rotazione di 45° e ne attribuisce il valore di 220 ohm.

  • Ambienti di programmazione

     L’IDE classico di Arduino

    I nostri progetti per Arduino verranno preparati in un ambiente integrato di sviluppo detto IDE, acronimo di Integrated Development Environment. Attraverso l’IDE produrremo un programma sotto forma di file di testo, di estensione .ino e contenente tutte le istruzioni con cui Arduino con­trollerà i nostri circuiti.

    Un programma viene chiamato sketch (schizzo), noi lo chiameremo anche progetto; automatica­mente viene salvato in un modo particolare, ma poco esplicativo; ad esempio un progetto salvato di default come sketch_feb27a.ino è il primo progetto che ha avuto inizio il 27 febbraio, sketch_feb27b.ino il secondo… All’atto del salvataggio del progetto è consentito (e consigliato!) no­minarlo a proprio piacimento per meglio identificare il suo contenuto.

    È possibile utilizzare online l’IDE di Arduino dove i progetti saranno salvati nel cloud e disponibili da qualsiasi dispositivo.

    Se invece preferisci lavorare offline allora scarica la versione desktop all’indirizzo http://arduino.cc/en/Main/Software scegliendo quella idonea al tuo sistema operativo.

    01 PiacereSonoArduinoUNOR3 html f9aa1c78d9c5a800

     L’IDE Arduino, come si può vedere in figura, raggruppa nello stesso ambiente

    • un editor;

    • un compilatore immagine.png che verifica la sintassi del programma presente nell’editor e  lo converte in una forma idonea e riconoscibile dal microcontrollore Atmega di Arduino;

    • un loader 01 PiacereSonoArduinoUNOR3 html 30a5054af4f95ae5 che compila il programma e lo carica sulla scheda Arduino;

    • un monitor seriale 01 PiacereSonoArduinoUNOR3 html 3249a0e93b642cb8 che apre una finestra, detta per l’appunto Monitor seriale, che  permette di esaminare i dati scambiati dal computer con Arduino.

    La sintassi del linguaggio di programmazione è il Wiring, derivato dal linguaggio informatico C/C++; creare uno sketch è semplicissimo poiché è come “compilare un modulo” in cui è necessario inserire i comandi fra le parentesi graffe di due funzioni:

    • la prima, setup(), dove vengono inserite le istruzioni da eseguire una sola volta all’avvio o al reset del programma;

    • la seconda, loop(), dove vengono inserite le istruzioni da eseguire ciclicamente.


    Arduino IDE 2.0

    L’IDE 2.0 presenta ovviamente maggiori prestazioni rispetto a quello classico 1.8.x, quali:

    • il completamento automatico che, non solo contribuisce a farti apprendere il linguaggio di Arduino mentre crei un progetto, ma ti fa anche risparmiare tempo.
      Lo si attiva/disattiva da File/Preferenze spuntando o meno la casella “Suggerimenti rapidi dell’editor”. Per abilitarlo devi prima collegare, dall’apposito menu a tendina, la scheda che intendi utilizzare con il tuo progetto; poi, mentre si digita, premendo ctrl + barra spaziatrice verranno dati suggerimenti fra i quali possiamo selezionare, se c’è, il completamento che fa al nostro caso.

    • un debugger integrato; è utilizzabile solo con le schede: MKR Zero, MKR Wi-Fi 1010, MKR FOX 1200, MKR WAN 1300, MKR WAN 1310, MKR GSM 1400, MKRNB 1500, MSEK VIDOR 4000, Nano 33 IoT, Zero

    • la sincronizzazione degli schizzi con Arduino Cloud; non trattata in questa guida, per approfondimenti:
      https://docs.arduino.cc/software/ide-v2/tutorials/ide-v2-cloud-sketch-sync

    • interfaccia utente migliorata

    Panoramica dell’interfaccia utente

    All’apertura dell’IDE 2.0 di Arduino possiamo notare, oltre alla barra dei menu, altre due barre: una orizzontale in alto ed una verticale sulla sinistra dalle quali è possibile accedere agli strumenti più comunemente usati

    IDE2

    Nella barra orizzontale troviamo da sinistra a destra:

    • Verifica, per verificare il codice (in realtà è una compilazione).

    • Carica, per compilare il codice e caricarlo sulla scheda Arduino.

    • Debug, come già detto non è disponibile per tutte le schede.

    • Seleziona scheda e porta: qui viene visualizzata automaticamente sia la scheda Arduino rilevata che il numero di porta.

    • Plotter Seriale, ottimo per la rappresentazione grafica dei dati; è possibile rappresentare più variabili contemporaneamente.

    • Monitor Seriale Integrato, si apre nella parte inferiore dell’editor.

    Nella barra laterale troviamo, dall’alto in basso:

    • Sketchbook: mostra l’elenco dei progetti memorizzati localmente sul nostro computer e, sincronizzando con Arduino Cloud, si possono anche ottenere quelli online (https://docs.arduino.cc/software/ide-v2/tutorials/ide-v2-cloud-sketch-sync).

    • Gestore di schede: mostra i pacchetti di schede sia di Arduino che di terze parti .

    • Gestore delle librerie: mostra le librerie create sia da Arduino che dalla sua comunità.

    • Debug.

    • Cerca: cerca le parole chiave nel codice.


    Otto Blockly

    La creazione di alcuni nostri primi progetti passa anche attraverso la programmazione visuale di Otto Blockly, un software creato per la gestione del piccolo robot umanoide Otto (https://www.ottodiy.com/) mostrato in figura:

    otto 

    Immagine di un modello di Otto. Immagine disponibile sul sito https://www.ottodiy.com/

    Otto ha al suo interno proprio una scheda Arduino Nano, ma Otto Blockly lavora bene anche con altri microprocessori, come ad esempio Arduino R3.

    Il software di programmazione di Otto è liberamente scaricabile dal sito di Otto all’indirizzo https://www.ottodiy.com/software e permette la programmazione a blocchi con 3 diversi livelli di complessità (Level 1-2-3). Inoltre, tramite il comando codice  è possibile, a fianco dei blocchi, visualizzare la programmazione in linguaggio Wiring.

    Si consiglia di usare il programma nella versione in inglese in quanto alcune funzionalità sono mal tradotte in italiano e possono generare errori.

    Installazione e collegamento con Arduino

    Dopo aver installato l’IDE di Arduino, scarichiamo ed installiamo il programma Otto blockly dal sito di Otto https://www.ottodiy.com/software

    Faremo riferimento particolarmente al livello 3 che, al momento della stesura della presente guida, risulta più ricco di estensioni per la scheda Arduino.

    Lanciato il programma, per far dialogare Otto blockly con Arduino:

    • collegare Arduino al PC tramite la porta USB;

    • in alto al centro selezionare la porta USB di collegamento (in genere è quella che riporta il numero più alto);

    • dalla voce di menu Scheda scegliere quella in uso, nel nostro caso Arduino Uno.

    dispositivo 

    Una volta interrotta la comunicazione, tramite cavetto USB, una programmazione con Otto Blockly interromperà ogni azione tramite Arduino; se vogliamo memorizzare il programma compilato sulla nostra scheda e, scollegato dal PC, viva di vita propria, è necessario tramite il pulsante verifica verificare l’esattezza del programma scritto e successivamente premendo sul pulsante carica  caricarlo su Arduino.

     


    Tinkercad

    TinkerCad è un software di programmazione visuale anch’esso in stile SCRATCH, utilizzabile online e completamente gratuito, con il quale tra l’altro è possibile simulare sia la realizzazione di circuiti con Arduino, che il loro funzionamento; è necessario registrarsi.

    Una volta effettuato l’accesso ed aver cliccato su Circuiti è possibile creare un nuovo progetto.

    • Si aprirà una finestra con, nella parte destra, tutti gli strumenti necessari per iniziare a costruire il circuito, trascinando i componenti ed i dispositivi nell’area di lavoro; è possibile rinominare i componenti per facilitare la comprensione del progetto.

    • Una volta assemblato il vostro circuito, per programmarne il comportamento, clicchiamo sul pulsante Codice, in alto a destra della pagina; possiamo scegliere tra programmazione

      • blocchi,

      • blocchi + testo,

      • testo.

    Con blocchi si ha la sola programmazione visuale, con testo quella in Wiring ed è modificabile mentre con blocchi + testo si ha sia la programmazione visuale che il software Wiring (non modificabile) creato da TinkerCad.

    È possibile passare dalla programmazione blocchi a quella blocchi + testo e viceversa.

    Non è possibile passare a solo testo da blocchi, o blocchi + testo, e viceversa, senza perdere parte della programmazione effettuata. È possibile simulare il progetto con il pulsante Avvia simulazione.

    Nella finestra di programmazione è presente il pulsante con il quale è possibile salvare il progetto sul nostro dispositivo per caricarlo poi nell’IDE di Arduino.

  • Luci di Natale

     In questo progetto viene proposto un gioco di luci.

     

    {tab=Descrizione}

     

      In questo progetto viene proposto un gioco di luci (come quello che, nel periodo natalizio, si vede ai balconi di molte abitazioni) mediante l’uso delle funzioni:

    • lampeggio
    • sequenza: i 6 LED, in sequenza, prima si accendo da sinistra verso destra e poi si spengono nel verso opposto
    • simmetrica_int: prima si accendono a coppie i LED 4 e 5, 3 e 6, infine 2 e 7; in maniera analoga avviene lo spegnimento
    • centro_periferia: si accende e spengono i LED dall’interno verso l’esterno, prima da un lato e poi dall’altro
    • casuale

     

    {tab=Cablaggio}

    Luci di Natale

     

     

    Componenti

     

    • 6 LED (2 gialli, 2 verdi, 2 rossi)
    • 6 resistenze da 220 Ω
    • 7 cavetti

     

     {tab=Il codice}

    Il codice

     

    void lampeggio() {

       for (int i = 2; i < 8; i = i + 1) {

         digitalWrite(i, HIGH);

       }

       delay(300);

       for (int i = 2; i < 8; i = i + 1) {

         digitalWrite(i, LOW);

       }

       delay(300);

    }

     

    void sequenza() {

       for (int i = 2; i < 8; i = i + 1) {

         digitalWrite(i, HIGH);

         delay(200);

       }

       delay(300);

       for (int i = 7; i > 1; i = i - 1) {

         digitalWrite(i, LOW);

         delay(200);

       }

       delay(300);

    }

     

    void simmetrica_int() {

       int k = 1;

       for (int i = 4; i > 1; i = i - 1){   // ciclo di accensione simmetrica

         digitalWrite(i, HIGH);

         digitalWrite(i + k, HIGH);

         delay(400);

         k = k + 2;

    /* prima accende i LED 4 e 5, poi incrementa k di 2 (k = 3) ed accende i LED 3 e 6; poi incrementa ancora una volta k di 2 (k = 5) ed accende i LED 2 e 7 */

       }

       delay(500);

       k = 1;

       for (int i = 4; i > 1; i = i - 1) { // ciclo di spegnimento simmetrico

         digitalWrite(i, LOW);

         digitalWrite(i + k, LOW);

         delay(400);

         k = k + 2;

       }

    }

     

    void centro_periferia() {

       for (int i = 5; i < 8; i = i + 1) {

         digitalWrite(i, HIGH);

         delay(50);

         digitalWrite(i, LOW);

         delay(400);

       }

       for (int i = 4; i > 1; i = i - 1) {

         digitalWrite(i, HIGH);

         delay(30);

         digitalWrite(i, LOW);

         delay(30);

       }

    }

     

    void casuale() { // ciclo di accensione (e spenimento) casuale dei LED

       for (int i = 0; i < 100; i = i + 1) {

         int k = random(8);

         digitalWrite(k, HIGH);

         delay(30);

         digitalWrite(k, LOW);

         delay(30);

       }

    }

     

    void setup() {

      for (int i = 2; i < 8; i = i + 1) pinMode(i, OUTPUT);

    }

     

    void loop() {

       sequenza(); sequenza(); sequenza();

       lampeggio(); lampeggio(); lampeggio();

       simmetrica_int(); simmetrica_int(); simmetrica_int(); simmetrica_int();

       lampeggio(); lampeggio(); lampeggio();

       casuale();

       lampeggio(); lampeggio(); lampeggio();

       centro_periferia(); centro_periferia(); centro_periferia(); centro_periferia(); centro_periferia();

       lampeggio(); lampeggio(); lampeggio();

    }

     

       Adeguando i tempi è possibile personalizzarne gli effetti. Si può snellire il loop, evitando di richiamare più volte la stessa funzione, introducendo ulteriori for nel loop stesso o nelle singole funzioni.

     

     {/tabs}


     

    Liberamente tratto da https://www.progettiarduino.com/28-arduino-luci-di-natale-6ch.html

  • E pur si muove: segnalatore di presenza

    Si vuol creare un circuito che, con l’aiuto di un sensore di rilevamento di movimento a raggi infrarossi (PIR acronimo di Passive InfraRed) provochi l’azione da noi desiderata, come l’accensione di un led, l’attivazione di un allarme sonoro…

     

    {tab=Sensore passivo a infrarossi}

     

    Sensore passivo a infrarossi

     

       Tutti gli oggetti emettono radiazioni; il più delle volte la frequenza di queste radiazioni sono al di sotto dello spettro visibile e perciò non percepibili dall’occhio umano, ma possono essere rilevate da specifici dispositivi elettronici come appunto i PIR.
    I PIR, avendo una rilevazione ad infrarossi, si attivano nel momento in cui si verifica un cambio di temperatura all’interno dell’ambiente monitorato, come ad esempio l’ingresso di una persona; ecco perché possono trovare applicazione nei sistemi di antifurto ed antintruzione
    Va segnalato però che questi tipi di sensori possono provocare false attivazioni.

    Il termine passivo trova giustificazione nel fatto che i PIR non emettono energia, ma lavorano rilevando l’energia emessa da persone, animali ed oggetti.

    Segnalatore di presenza html f1c9ff1059e2189f   Il modulo HC-SR501 rappresentato in figura è quello che utilizzeremo; esso è costituito da un sensore in grado di rilevare le radiazioni infrarosse e da un circuito che memorizza l’intensità della radiazione rilevata e quando riscontra una variazione nell’intensità della radiazione attuale emette un segnale elettrico interpretabile da Arduino.
    Nel modulo notiamo in basso due resistenze variabili (trimmer): quella posta a sinistra consente di regolare il tempo di azione (3-200 s), l’altro la dimensione del raggio di azione (sensibilità, 3-7 m); la rotazione in senso orario ne aumenta i rispettivi valori.

    {tab=Il Progetto}

     

    Segnalare una presenza mediante i LED

       Costruiamo un progetto che accenda un LED rosso se viene rilevato un movimento, uno verde in caso contrario.

     

       Componenti

    • 2 LED: rosso, verde
    • 2 resistenze da 220 Ω
    • Sensore PIR
    • Connettori jumper

     

       Collegamenti

     

    Segnalatore di presenza html 474822c7e2e04895

    PIR

    Arduino

    Vcc

    5 V

    OUT

    D3

    GND

    GND

       Assemblaggio

     Segnalatore di presenza html 4cb476441294c6cb

    {tab=Il codice}

     

    Il codice:

     

    int durataCalibrazione = 30; /*tempo di calibrazione 10-60 secondi come indicato nella scheda tecnica */

    int PIR = 3;

    int ledVerde = 5;

    int ledRosso = 6;

     

    void setup(){

    pinMode( ledRosso, OUTPUT );

    pinMode( ledVerde, OUTPUT );

    pinMode(PIR, INPUT );

    Serial.begin(9600);

    Serial.print("calibrazione del sensore ");

    for(int i = 0; i < durataCalibrazione; i++){

    Serial.print(".");

    delay(1000);

    }

    Serial.println(" fatto"); // dopo un tempo di 30 s

    Serial.println("Il sensore PIR ora è attivo");

    delay(50);

    }

     

    void loop(){

    digitalWrite(ledRosso, digitalRead(PIR));// Mantieni acceso il led rosso se c'è movimento

    digitalWrite(ledVerde, !digitalRead(ledRosso));// Spegni il led verde se il Led rosso è acceso e viceversa

    }

    {/tabs}

  • Semaforo a due direzioni: un secondo progetto


    Semaforo a due direzioni html d159e4cc2416e881 

      

    Il codice

     

    #define rosso_O1 11

    #define giallo_O1 12

    #define verde_O1 13

    #define rosso_O2 2

    #define giallo_O2 3

    #define verde_O2 4

    #define rosso_V1 8

    #define giallo_V1 9

    #define verde_V1 10

    #define rosso_V2 5

    #define giallo_V2 6

    #define verde_V2 7

     

    void commuta_O(bool R, bool G, bool V) {

    digitalWrite(rosso_O1, R);

    digitalWrite(rosso_O2, R);

    digitalWrite(giallo_O1, G);

    digitalWrite(giallo_O2, G);

    digitalWrite(verde_O2, V);

    digitalWrite(verde_O1, V);

    }

     

    void commuta_V(bool R, bool G, bool V) {

    digitalWrite(rosso_V1, R);

    digitalWrite(rosso_V2, R);

    digitalWrite(giallo_V1, G);

    digitalWrite(giallo_V2, G);

    digitalWrite(verde_V2, V);

    digitalWrite(verde_V1, V);

    }

     

    void setup() {

    for (int i = 2; i <= 13; i++) {

    pinMode(i, OUTPUT);

    }

    for (int i = 2; i <= 6; i++) {

    commuta_O(0,1,0);

    commuta_V(0,1,0);

    delay(1000);

    commuta_O(0,0,0);

    commuta_V(0,0,0);

    delay(1000);

    }

    }

     

    void loop() {

    commuta_O(0,0,1);

    commuta_V(1,0,0);

    delay(5000);

    commuta_O(0,1,0);

    commuta_V(1,0,0);

    delay(1000);

    commuta_O(1,0,0);

    commuta_V(0,0,1);

    delay(5000);

    commuta_O(1,0,0);

    commuta_V(0,1,0);

    delay(1000);

    }

  • Semaforo a due direzioni

     Semaforo a due direzioni html d159e4cc2416e881

      

    Il codice

     

    #define rossoA 13

    #define gialloA 12

    #define verdeA 11

    #define rossoB 10

    #define gialloB 9

    #define verdeB 8

    #define puls 2

    boolean statoP = LOW;

     

    void setup() {

    for (int i = 8; i < 14; i++) {

    pinMode(i, OUTPUT);

    }

    pinMode(puls, INPUT);

    }

     

    void loop() {

    if (digitalRead(puls) == HIGH) statoP = !statoP ;

     

    delay(250);

     

    if (statoP == true) {

    digitalWrite(rossoB, HIGH);

    digitalWrite(rossoA, LOW);

    digitalWrite(verdeA, HIGH);

    delay(6000);

    digitalWrite(verdeA, LOW);

    digitalWrite(gialloA, HIGH);

    delay(1500);

    digitalWrite(gialloA, LOW);

    digitalWrite(verdeA, LOW);

    digitalWrite(rossoA, HIGH);

    digitalWrite(rossoB, LOW);

    digitalWrite(verdeB, HIGH);

    delay(6000);

    digitalWrite(verdeB, LOW);

    digitalWrite(gialloB, HIGH);

    delay(1500);

    digitalWrite(gialloB, LOW);

    }

     

    if (statoP == false) {

    digitalWrite(rossoA, LOW);

    digitalWrite(rossoB, LOW);

    digitalWrite(verdeA, LOW);

    digitalWrite(verdeB, LOW);

    digitalWrite(gialloA, HIGH);

    digitalWrite(gialloB, HIGH);

    delay(1000);

    digitalWrite(gialloA, LOW);

    digitalWrite(gialloB, LOW);

    delay(1000);

    }

     

    }

  • Il semaforo unidirezionale con commutazione fra comportamento normale e lampeggiante

    Mediante un pulsante si vuol passare da un funzionamento che coinvolga tre LED (rosso, giallo e verde) ad uno lampeggiante del LED giallo.  Ci serviremo di una variabile in cui salvare lo stato del pulsante con cui determinare la commutazione.

    Il semaforo unidirezionale con commutazione fra comportamento normale e lampeggiante html 8ed402a51846228f

     

    Il codice:

     

    #define red1 9

    #define yel1 10

    #define gre1 11

    #define puls 2

    boolean statoP = 0;

     

    void setup() {

    pinMode(red1, OUTPUT);

    pinMode(yel1, OUTPUT);

    pinMode(gre1, OUTPUT);

    pinMode(puls, INPUT);

    }

     

    void loop() {

    if (digitalRead(puls) == HIGH) statoP = !statoP ;

    delay(250);

    if (statoP == 1) {

    digitalWrite(yel1, LOW);

    digitalWrite(red1, LOW);

    digitalWrite(gre1, HIGH);

    delay(6000);

    digitalWrite(gre1, LOW);

    digitalWrite(yel1, HIGH);

    delay(1500);

    digitalWrite(yel1, LOW);

    digitalWrite(gre1, LOW);

    digitalWrite(red1, HIGH);

    delay(6000);

    }

    if (statoP == 0) {

    digitalWrite(red1, LOW);

    digitalWrite(gre1, LOW);

    digitalWrite(yel1, HIGH);

    delay(1000);

    digitalWrite(yel1, LOW);

    delay(1000);

    }

    }

     


     http://sistemisds.altervista.org/

       Si può rendere più frendly il codice con l’introduzione di due funzioni: una per il funzionamento normale, l’altro per quello lampeggiante.

       Per la presenza della funzione delay() la commutazione avviene se il pulsante viene tenuto premuto alla fine della fase normale o lampeggiante, cioè durante l’accensione del rosso nel primo caso e del giallo nel secondo. In definitiva, conviene tenere premuto il pulsante finché non avviene la commutazione.

  • Il semaforo unidirezionale con cicalino e pulsante a chiamata

    Questo progetto simula il funzionamento di un semaforo con chiamata da parte di un pedone; nell’approssimarsi del divieto di attraversamento, il pedone riceve una segnalazione acustica.

    Il semaforo unidirezionale con cicalino e pulsante a chiamata html 42cd0bf442304556

     

     

     

     

    Componenti:

    • 8 cavetti MM
    • 2 LED verde
    • 2 LED giallo
    • 2 LED rosso
    • 1 cicalino
    • 1 pulsante
    • 1 resistenza di 100 Ω
    • 6 resistenze di 220 Ω
    • 1 resistenza di 10 kΩ
    • 12 cavetti MM

     

     

     

     

       Le fasi:

     

    AUTO LED verde + –
    LED giallo + –
    LED rosso + –
    PEDONE LED verde + –
    LED giallo + –
    LED rosso + –

     

       Il codice

     

    int pulsante;

    int verde_auto = 8;

    int giallo_auto = 9;

    int rosso_auto = 10;

    int verde_pedone = 11;

    int giallo_pedone = 12;

    int rosso_pedone = 13;

    int cicalino = 7;

     

    void setup() {

    for (int i = 7; i < 14; i++) {

    pinMode(i, OUTPUT);

    digitalWrite(i, LOW);

    }

    pinMode(2, INPUT); //pulsante

    }

     

    void loop() {

    noTone(cicalino);

    digitalWrite(verde_auto, HIGH); // ON

    digitalWrite(rosso_pedone, HIGH); // ON

     

    pulsante = digitalRead(2);

     

    if (pulsante == HIGH) {

    delay[2000];

     

    digitalWrite(verde_auto, LOW); //OFF

    digitalWrite(giallo_auto, HIGH); // ON

     

    delay (4000);

     

    digitalWrite(giallo_auto, LOW ); // OFF

    digitalWrite(rosso_auto, HIGH); // ON

    digitalWrite(verde_pedone, HIGH ); // ON

    digitalWrite(rosso_pedone, LOW); // OFF

    tone(7, 100);

     

    delay(4000);

     

    digitalWrite(verde_pedone, LOW); // OFF

    digitalWrite(giallo_pedone, HIGH); // ON

    tone(cicalino, 200);

     

    delay(2000);

     

    digitalWrite(giallo_pedone, LOW); // OFF

    digitalWrite(rosso_auto, LOW); // OFF

    }

    }

     

     

  • Semaforo unidirezionale con cicalino

    Semaforo unidirezionale con cicalino html b36403400678a280

     

     

     

     

     Componenti:

    • 5 cavetti MM
    • 3 LED: verde, giallo e rosso
    • 1 cicalino
    • 3 resistenze di 220 Ω

     

     

     

     

     

     Il codice:

     

    void setup()
    {
      pinMode(3, OUTPUT); // cicalino
      pinMode(11, OUTPUT); // verde
      pinMode(10, OUTPUT); // giallo
      pinMode(9, OUTPUT); // rosso
    }

    void loop()
    {
      digitalWrite(11, HIGH);
      delay(2500);

      for (int i = 0; i < 5; i++) {
        digitalWrite(3, HIGH);
        digitalWrite(10, HIGH);
        delay(500);
        digitalWrite(10, LOW);
        digitalWrite(3, LOW);
        delay(500);
      }

      digitalWrite(11, LOW);
      digitalWrite(10, HIGH);
      delay(1000);

      digitalWrite(10, LOW);
      digitalWrite(9, HIGH);
      delay(4000);

      digitalWrite(9, LOW);
    }

  • Il semaforo unidirezionale a tre tempi con un LED RGB

    L’obiettivo è quello di realizzare un semaforo con il solo LED RedGgreeBlue; poiché non è presente un LED per il giallo, tale colore sarà generato dalla mescolanza delle luci di tonalità rossa e verde.

     

     

    Il semaforo unidirezionale Con led RGB html f77638ae19b81123

     

     

     

     

     

    Componenti:

    •  1 LED RGB,
    •  3 Resistenza da 220 Ω,
    •  4 cavetti MM.

    Gli anodi del rosso e verde vanno collegati a pin PWM; nel nostro caso

    Pin 5 [PWM] = anodo del verde

    Pin 6 [PWM] = anodo del rosso

     

     

     

     

     

     

     

     

     

    Il codice:

     

    #define rosso 6
    #define verde 5

     

    void setup() {
      pinMode(rosso, OUTPUT);
      pinMode(verde, OUTPUT);
    }

     

    void loop() {

      analogWrite(rosso, 255);
      delay(8000);

      analogWrite(rosso, 0);
      analogWrite(verde, 255);
      delay(8000);

      analogWrite(verde, 0);
      analogWrite(rosso, 255);
      analogWrite(verde, 255);
      delay(3000);

      analogWrite(rosso, 0);
      analogWrite(verde, 0);

    }