Arduino – lezione 06: modulazione di larghezza di impulso (PWM)

Nella precedente lezione abbiamo visto come progettare un controllo presenza in due stanze adiacenti in cui abbiamo utilizzato due pulsanti per simulare due sensori PIR (uno per ogni stanza) e due led per simulare l’accensione delle lampade nelle due stanze.
L’ultimo sketch consentiva di silmulare la seguente situazione per entrambe le stanze:

  • entro nella stanza
  • PIR avverte la mia presenza
  • si accende la luce
  • ritardo lo spegnimento della luce per darmi il tempo di uscire dalla stanza

In questa e nella successiva lezione vorrei giungere alla realizzazione di un comportamento più vicino alla realtà:

  • entro nella stanza
  • PIR avverte la mia presenza
  • si accende in fade la luce
  • esco dalla stanza
  • il PIR non rileva più la mia presenza
  • si spegne in fade la luce

Suddivido la soluzione del problema in due sottoproblemi che risolverò in questa e nella successiva lezione:

  1. funzione fade
  2. funzione controllo presenza

Realizziamo la funzione fade

Se ricordate nella lezione 2 abbiamo realizzato il famoso “blink” lo sketch che accendeva e spegneva in modo continuativo un LED.
Realizziamo nuovamente il circuito ed eseguite lo sketch allegato:

// Esempio 01: fare lampeggiare un LED

#define LED 13                // LED collegato al pin digitale 13

void setup() {
  pinMode(LED, OUTPUT);       // imposta il pin digitale come output
}

void loop() {
  digitalWrite(LED, HIGH);   // accende il LED
  delay(1000);               // aspetta 1 secondo
  digitalWrite(LED, LOW);    // spegne il LED
  delay(1000);               // aspetta 1 secondo
}

Provate a ridurre drasticamente il ritardo di accensione e spegnimento, arrivate a 10 millisecondi, quasi non dovreste più pecepire lampeggiare il LED e inoltre dovreste aver notato che la luminosità del LED è diminuita.

// Esempio 02: modulazione di larghezza di impulso (PWM)

#define LED 13                // LED collegato al pin digitale 13

void setup() {
  pinMode(LED, OUTPUT);       // imposta il pin digitale come output
}

void loop() {
  digitalWrite(LED, HIGH);   // accende il LED
  delay(10);               // aspetta 10 millisecondi
  digitalWrite(LED, LOW);    // spegne il LED
  delay(10);               // aspetta 10 millisecondi
}

Il motivo per cui si vede illuminare di meno il diodo LED è dovuta alla modulazione di larghezza di impulso in inglese Pulse Width Modulation – PWM, che detta in modo meno tecnico vuol dire che se facciamo lampeggiare un diodo LED ad una frequenza sufficientemente elevata e se cambiamo il rapporto tra il tempo in cui sta acceso ed il tempo in cui sta spento, il nostro occhio non percepirà il lampeggiare del LED ed inoltre a secondo del rapporto del tempo di accensione e spegnimento potremo regolare la luminosità del LED.

Possiamo dire che il PWM è una tecnica per ottenere risultati analogici con mezzi digitali.

Un po’ di teoria: il Duty cycle

Il duty cycle di un onda quadra/rettangolare e il rapporto tra la durata (in secondi) del segnale quando è “alto” ed il periodo totale del segnale. In altre parole è un numero che esprime quant’è la parte di periodo in cui il segnale è alto.

Facendo riferimento al disegno la formula che esprime il duty cycle è:

d=tau/T

dove T è il periodo e tau la parte di periodo in cui il segnale è alto.

Dalla formula potete subito notare che tau può variare da un valore minimo di 0 a un valore massimo pari a T, ciò implica che il valore del duty cycle varia da 0 a 1:

d=tau/T

Caso 1: per tau=0

0/T=0

livello basso per tutto il periodo

Caso 2: per tau=T

T/T=1

livello alto per tutto il periodo

in entrambi i casi siamo in presenza di segnali continui.

Dalla formula possiamo comprendere quindi che il duty cycle è sempre un valore che varia tra 0 e 1.

Il duty cycle è spesso rappresentato in percentuale, D% e per ottenere la percentuale è sufficiente moltiplicare per 100 il rapporto tau/T, dire quindi che il D%=30% vuol dire che per il 30% del periodo totale il segnale si trova a livello alto, come conseguenza possiamo subito dire che il segnale sarà a livello basso per il restante 70% del periodo.

Dire quindi che il duty cycle è del 50% vuol dire che nel periodo T il segnale si mantiene alto per T/2 e per il restante T/2 a livello basso in questo caso siamo quindi in presenza di un’onda quadra.

Passiamo ora alla pratica

Poniamoci nelle seguenti 3 condizioni:

  1. 50% LED acceso e 50% LED spento
    luminosità al 50%
  2. 25% LED acceso e 75% LED spento
    luminosità al 25%
  3. 75% LED acceso e 25% LED spento
    luminosità al 75%

Per realizzare le tre condizioni impostate scegliamo un periodo sufficientemente breve tale da non percepire il lampeggiare del LED:

Poniamo un periodo T = 20ms

  1. 10ms acceso e 10ms spento
  2. 5 ms acceso e 15ms spento
  3. 75 ms acceso e 5ms spento
// Esempio 03: modulazione di larghezza di impulso (PWM) - on: 10ms - off: 10ms

#define LED 13                // LED collegato al pin digitale 13

void setup() {
  pinMode(LED, OUTPUT);       // imposta il pin digitale come output
}

void loop() {
  digitalWrite(LED, HIGH);   // accende il LED
  delay(10);               // aspetta 10 millisecondi
  digitalWrite(LED, LOW);    // spegne il LED
  delay(10);               // aspetta 10 millisecondi
}
// Esempio 04: modulazione di larghezza di impulso (PWM) - on: 5ms - off: 15ms

#define LED 13                // LED collegato al pin digitale 13

void setup() {
  pinMode(LED, OUTPUT);       // imposta il pin digitale come output
}

void loop() {
  digitalWrite(LED, HIGH);   // accende il LED
  delay(5);               // aspetta 5 millisecondi
  digitalWrite(LED, LOW);    // spegne il LED
  delay(15);               // aspetta 15 millisecondi
}
// Esempio 05: modulazione di larghezza di impulso (PWM) - on: 15ms - off: 5ms

#define LED 13                // LED collegato al pin digitale 13

void setup() {
  pinMode(LED, OUTPUT);       // imposta il pin digitale come output
}

void loop() {
  digitalWrite(LED, HIGH);   // accende il LED
  delay(15);               // aspetta 15 millisecondi
  digitalWrite(LED, LOW);    // spegne il LED
  delay(5);               // aspetta 5 millisecondi
}

Dal filmato potete notare la variazione di luminosità nelle tre condizioni:

Con un po’ di esperimenti noterete che la tecnica di variazione della luminosità, utilizzando il ritardo “delay()”, non è il metodo migliore in quanto, non appena inseite altri sensori ad Arduino, oppure inviate dei dati alla seriale, il LED tremolerà nell’attesa che termini la lettura del sensore o la scrittura sulla seriale.

Come evitare questo problema?

Arduino UNO offre la possibilità di usare i pin 3, 5, 6, 9, 10, 11 l’istruzione: analogWrite(), istruzione che consente appunto di far lampeggiare il LED o governare un motore elettrico mentre lo sketch esegue altre istruzioni.

Sintassi:

analogWrite(pin, valore)

dove:

  • pin: è il piedino su cui inviamo il segnale, per Arduino UNO i pin 3, 5, 6, 9, 10, 11
  • valore: è il duty cycle compreso tra 0 (sempre off) a 255 (sempre on)

La funzione non restituisce nessun valore.

Quindi se utilizziamo la funzione analogWrite() per il controllo della luminosità del LED e scriviamo:

analogWrite(11, 0)
il LED collegato al pin 11 avrà una luminosità dello 0% (duty cycle 0%)

// Esempio 06: utilizzo della funzione analgoWrite() - LED spento - (duty cycle 0%)

#define LED 11                // LED collegato al pin digitale 11

void setup() {
  pinMode(LED, OUTPUT);       // imposta il pin digitale come output
}

void loop() {
  analogWrite(LED, 0);   // accende il LED
}

analogWrite(11, 64)
il LED collegato al pin 11 avrà una luminosità del 25% (duty cycle 25%)

// Esempio 07: utilizzo della funzione analgoWrite() - LED spento - (duty cycle 25%)

#define LED 11                // LED collegato al pin digitale 11

void setup() {
  pinMode(LED, OUTPUT);       // imposta il pin digitale come output
}

void loop() {
  analogWrite(LED, 64);   // accende il LED
}

analogWrite(11, 128)
il LED collegato al pin 11 avrà una luminosità del 50% (duty cycle 50%)

// Esempio 08: utilizzo della funzione analgoWrite() - LED spento - (duty cycle 50%)

#define LED 11                // LED collegato al pin digitale 11

void setup() {
  pinMode(LED, OUTPUT);       // imposta il pin digitale come output
}

void loop() {
  analogWrite(11, 128);   // accende il LED
}

analogWrite(11, 191)
il LED collegato al pin 11 avrà una luminosità del 75% (duty cycle 75%)

// Esempio 09: utilizzo della funzione analgoWrite() - LED spento - (duty cycle 75%)

#define LED 11                // LED collegato al pin digitale 11

void setup() {
  pinMode(LED, OUTPUT);       // imposta il pin digitale come output
}

void loop() {
  analogWrite(11, 191);   // accende il LED
}

analogWrite(11, 255)
il LED collegato al pin 11 avrà una luminosità del 100% (duty cycle 100%)

// Esempio 10: utilizzo della funzione analgoWrite() - LED spento - (duty cycle 100%)

#define LED 11                // LED collegato al pin digitale 11

void setup() {
  pinMode(LED, OUTPUT);       // imposta il pin digitale come output
}

void loop() {
  analogWrite(11, 255);   // accende il LED
}

Nel filmato allegato potete notare la differenza di luminosità nelle 5 condizioni sopra illustrate.

Imparato come variare la luminosità del LED usando la funzione analogWrite(), vediamo come realizzare il fade del LED ovvero l’accensione e lo spegnimento graduale, attenzione che questo modo di procedere sarà utile anche quando dovremo imparare a variare la velocità di un motorino elettrico.

Lo schetch che vi allego è già presente negli esempi disponibili dal menù: File -> Examples -> 3.Analog -> Fading ne ho variato alcune parti:

// Esempio 11: Fading


#define LED 11              // LED collegato al pin digitale 11
int valoreFade = 0;         // variabile usata per contare in avanti e indietro

void setup()  { 
  pinMode(LED, OUTPUT);     // imposta il pin digitale come output
} 

void loop()  {
  // procede ciclicamente da 0 a 254 (fade in -> aumento luminosità)
  for (valoreFade = 0 ; valoreFade < 255; valoreFade++) { 
    analogWrite(LED, valoreFade);      //impostiamo la luminosità del LED
    delay(10);  
    // aspettiamo 10ms per percepire la viariazione di luminosità,
    //perché analogWrite è istantaneo                        
  } 
  // procede ciclicamente da 255 a 1 (fade out -> diminuzione della luminosità)
  for(valoreFade = 255 ; valoreFade > 0; valoreFade--) {
    analogWrite(LED, valoreFade);      //impostiamo la luminosità del LED
    delay(10);  
    // aspettiamo 10ms per percepire la viariazione di luminosità,
    //perché analogWrite è istantaneo                               
  } 
}

Analizzaimo il codice.

Prendiamo in analisi la prima parte del loop(). All’interno troviamo un primo ciclo for:

...
  // procede ciclicamente da 0 a 254 (fade in -> aumento luminosità)
  for (valoreFade = 0 ; valoreFade < 255; valoreFade++) { 
    analogWrite(LED, valoreFade);      //impostiamo la luminosità del LED
    delay(10);  
    // aspettiamo 10ms per percepire la viariazione di luminosità,
    //perché analogWrite è istantaneo                        
  }
...

Ad ogni ciclo incrementiamo la variabile valoreFade di 1 (valoreFade++) partendo da 0 fino a 254. valoreFade viene utilizzata in analogWrite(LED, valoreFade) per variare il valore del duty cycle ed incrementare la luminosità del LED. Poichè l'azione di analogWrite(LED, valoreFade) è immediata per percepire visivamente la variazione di luminosità introduciamo un piccolo ritardo di 10ms con delay(10). Il ciclo terminerà non appena la condizione valoreFade < 255 non è più vera, cioè valoreFade non più minore di 255.

Il secondo ciclo for consente di diminuire la luminosità:

...
  // procede ciclicamente da 255 a 1 (fade out -> diminuzione della luminosità)
  for(valoreFade = 255 ; valoreFade > 0; valoreFade--) {
    analogWrite(LED, valoreFade);      //impostiamo la luminosità del LED
    delay(10);  
    // aspettiamo 10ms per percepire la viariazione di luminosità,
    //perché analogWrite è istantaneo                               
  } 
...

Ad ogni ciclo la variabie valoreFade viene decrementata di 1 (valoreFade--) facendo decrescere valoreFade da 255 a 1 e di conseguenza la luminosità del LED. Il ciclo terminerà quando la condizione valoreFade > 0 non è più vera.
Usciti da questo secondo ciclo si ripartirà con il primo ciclo for che permetterà nuovamente l'aumento della luminosità del LED.

Nella prossima lezione vedreme come interagire mediante pulsanti sull'intensità luminosità del LED.

Articoli simili:

Questa voce è stata pubblicata in arduino e contrassegnata con , , , , , , , . Contrassegna il permalink.

31 risposte a Arduino – lezione 06: modulazione di larghezza di impulso (PWM)

  1. Francesco basso scrive:

    Ho sperimentato con successo la variazione di luminosità del led con arduino uno; non riesco però, da quel momento, a caricare un altro programma, la scheda è diventata inacessibile. Perchè?
    Grazie.

  2. Claudio scrive:

    Salve Professore.

    Intanto AUGURI.

    Volevo sapere se erano presenti delle librerie PWM per la scheda Arduino Uno…ne ho travata una ma non funziona…mi da errore nella compilazione!

    Grazie
    Saluti
    Claudio

    • admin scrive:

      Ciao Claudio.

      Grazie per gli auguri 🙂
      Buon Anno anche a te.

      Per le librerie PWM on-line trovi molto, per l’errore che mi dici dovrei vedere la libreria e capire il progetto, ti segnalo alcuni link che potrebbero esserti di aiuto:

      Secrets of Arduino PWM
      http://www.arcfn.com/2009/07/secrets-of-arduino-pwm.html

      PwmFrequency
      http://www.arduino.cc/playground/Code/PwmFrequency

      Arduino/Wiring SoftPWM Library
      http://code.google.com/p/rogue-code/wiki/SoftPWMLibraryDocumentation

      ShiftPWM
      http://www.elcojacobs.com/shiftpwm/

      Arduino code: led pwm code library
      http://mattkuhs.com/?p=907

      • Claudio scrive:

        Salve Prof,

        grazie per la risposta.

        Allora, proprio da questo sito (postato da Lei) : Arduino/Wiring SoftPWM Library
        http://code.google.com/p/rogue-code/wiki/SoftPWMLibraryDocumentation ho scaricato la libreria e messa all’ interno della cartella “libraries” di Arduino.
        Ho provato a incollare l’ esempio presente sullo stesso sito, ma quando compilo mi da errore.
        Premetto che non ho ancora la scheda Arduino UNO (dovrebbe arrivare a poco); utilizzo il software Arduino 1.0…

        Potrebbe dare un’occhiata Lei???

        Grazie mille
        Claudio

        • admin scrive:

          Ciao Claudio.

          Ho provato la libreria e funziona perfettamente. Se ottieni errore probabilmente è capitata una delle seguenti cose:

          1. se ottieni un errore di questo genere:

          errore caricamento libreria

          allora:

          non hai inserito correttamente i file della libreria nella cartella “libraries” di Arduino. La cartella “libraries” la trovi nella cartella dove vengono salvati automaticamente gli sketch (sotto Mac ad esempio è allocata in Documents -> Arduino).

          oppure

          hai inserito la libreria SoftPWM nella cartella “libraries” dopo aver avviato Arduino.

          Quindi prima inserisci la libreria nella posizione corretta e poi avvia Arduino.

          2. hai commesso qualche errore facendo il copia e incolla dello sketch.

          Fammi sapere.
          Saluti.

          • Claudio scrive:

            Salve Prof.

            Le spiego, aprendo il programma Arduino, nella voce “Examples” sono presenti gli esempi per l’ utilizzo di quella libreria…ma anche quelli non funzionano!!
            La cartella “libreria PWM” l’ho incollata all’ interno della cartella “libraries” dove è presente l’ eseguibile del programma Arduino. In pratica, ho scaricato il programma da Arduino.cc, lo scompattato e in quella cartella è presente Arduino.exe e la cartella “libraries”…li dentro ho messo la libreria…dove sbaglio??

            Grazie mille

  3. Claudio scrive:

    Salve professore,

    ho risolto il problema…o almeno, ho cambiato versione del software di programmazione.

    Usavo Arduino1.0 e mi da errore…usando lo 0023, non mi da nessun problema!!
    PS. Non smetta di scrivere questi tutorial fatti a regola d’arte:)
    Grazie
    Claudio

  4. Carlo scrive:

    Ho provato tutti i tutorial, credevo di riuscire a pilotare i led con chip WS2801 della spark fun ma con l’esempio dato non sono riuscito a cereare un led bianco che corre da una parte all’altra. Sono led a strip rgb addressable avrei voluto capire dove in un esempio pratico andare a definire il colore e il n° del led da acendere avrebbe mica un esempio del genere?
    Grazie e Complimenti!

    • admin scrive:

      Ciao Carlo.

      Io personalmente non ho mai utilizzato i WS2801, ma dalle ricerche che ho fatto potresti trovare la tua soluzione leggendo il topic: ws2801 led strip problems sul forum di arduino.cc e guarda anche su davidbu.ch: Arduino and WS2801 RGB LED strip. Spero che questa segnalazione risolva il tuo problema.

      Saluti.

      • Carlo scrive:

        Buongiorno, ho provato ad incollare il contenuto di parecchie soluzioni trovate sul web compreso il suo link però ho dei problemi mi da errore quando faccio upload
        Il primo link non funziona il secondo contiene:
        // walking r-g-b
        for (int j = 0; j < 3; j++) {
        memset(leds, 0, NUM_LEDS * 3);
        for(int i = 0; i < NUM_LEDS; i++ ) {
        switch((i+j) % 3) {
        case 0: leds[i].r = 200; break;
        case 1: leds[i].g = 200; break;
        case 2: leds[i].b = 200; break;
        }
        }
        Probabilmente devo fare operazioni preliminari come letto nel post precedente di copiare delle librerie e non basta che copio incollo?
        Saluti Carlo

      • Carlo scrive:

        Evviva ho capito qualcosa… Ho copiato l’intera cartella link:
        https://github.com/adafruit/WS2801-Library
        nel librarie di arduino poi per problema di nome cartello lo rinominata comunque ora ho ottenuto questo:
        la striscia parte dal led 1 e corre fino al 32′ posso scegliere i colori e la velocità col quale riparte e la sovrascrive.
        Ora resta solo un problema che il loop va all’infinito e dovrei con un pulsante far partire la funzione.
        Premo pulsante parte il primo led fino al 32°, subito dopo sovrascrivo con colore nero cioè spento e sta fermo fino a che non premo nuovamente il pulsante….. la vedo dura penso ci vadano delle variabili ma non riesco ad integrarle… comunque ecco le istruzioni
        #include “SPI.h”
        #include “WS2801.h”

        /*****************************************************************************
        Example sketch for driving WS2801 pixels
        *****************************************************************************/

        // Choose which 2 pins you will use for output.
        // Can be any valid output pins.
        // The colors of the wires may be totally different so
        // BE SURE TO CHECK YOUR PIXELS TO SEE WHICH WIRES TO USE!
        int dataPin = 2;
        int clockPin = 3;
        // Don’t forget to connect the ground wire to Arduino ground,
        // and the +5V wire to a +5V supply

        // Set the first variable to the NUMBER of pixels. 25 = 25 pixels in a row
        WS2801 strip = WS2801(25, dataPin, clockPin);

        // Optional: leave off pin numbers to use hardware SPI
        // (pinout is then specific to each board and can’t be changed)
        //WS2801 strip = WS2801(25);

        void setup() {

        strip.begin();

        // Update LED contents, to start they are all ‘off’
        strip.show();
        }

        void loop() {
        // Some example procedures showing how to display to the pixels

        colorWipe(Color(0, 0, 0), 0.1); // r g b a zero quindi spenti
        colorWipe(Color(255, 255, 255), 0.1); //tutti accesi bianco
        }

        void rainbow(uint8_t wait) {
        int i, j;

        for (j=0; j < 256; j++) { // 3 cycles of all 256 colors in the wheel
        for (i=0; i < strip.numPixels(); i++) {
        strip.setPixelColor(i, Wheel( (i + j) % 255));
        }
        strip.show(); // write all the pixels out
        delay(wait);
        }
        }

        // fill the dots one after the other with said color
        // good for testing purposes
        void colorWipe(uint32_t c, uint8_t wait) {
        int i;

        for (i=0; i < strip.numPixels(); i++) {
        strip.setPixelColor(i, c);
        strip.show();
        delay(wait);
        }
        }

        /* Helper functions */

        // Create a 24 bit color value from R,G,B
        uint32_t Color(byte r, byte g, byte b)
        {
        uint32_t c;
        c = r;
        c <<= 8;
        c |= g;
        c <<= 8;
        c |= b;
        return c;
        }

        //Input a value 0 to 255 to get a color value.
        //The colours are a transition r – g -b – back to r
        uint32_t Wheel(byte WheelPos)
        {
        if (WheelPos < 85) {
        return Color(WheelPos * 3, 255 – WheelPos * 3, 0);
        } else if (WheelPos < 170) {
        WheelPos -= 85;
        return Color(255 – WheelPos * 3, 0, WheelPos * 3);
        } else {
        WheelPos -= 170;
        return Color(0, WheelPos * 3, 255 – WheelPos * 3);
        }
        }

        Grazie per l'aiuto aspetto fiducioso qualche idea resto a disposizione se qualcuno volesse info o video del funzionamento
        GRAZIE Carlo

  5. giorgio scrive:

    Salve professore, molto interessante il suo sito e anche questa lezione che mi interessa particolarmente. A riguardo avrei una domanda per quanto riguarda il valore di incremento di 1 per la funzione:
    void loop() {
    // procede ciclicamente da 0 a 254 (fade in -> aumento luminosità)
    for (valoreFade = 0 ; valoreFade < 255; valoreFade++) {
    analogWrite(LED, valoreFade); //impostiamo la luminosità del LED

    Se invece di voler incrementare di 1 per arrivare a 255, vorrei incrementare di 51 per volta cosicchè in cinque fasi(step) arriverei a 255, come dovrei scrivere il for ??
    Non vado più a scuola da almeno 20anni, e mi sto avvicinando solo adesso all'elettronica ed a Arduino. Grazie della sua disponibilità, attendo risposta.
    Complimenti.

  6. Matteo scrive:

    Salve Professore,
    non sono un suo alunno ma un appassionato dei suoi tutorial.
    Avrei una domanda circa questo estratto del codice

    for (valoreFade = 0 ; valoreFade < 255; valoreFade++) {   
        analogWrite(LED, valoreFade);      //impostiamo la luminosità del LED  
        delay(10);
    

    La mia domanda è come faccio a calcolare quando il led, a seconda del delay che mettiamo, va a regime. Il led cambia luninosità ogni 10ms per 255 volte impiegando 2,55 seondi?

    grazie per l’attenzione
    saluti da Cagliari
    Matteo

    • Matteo scrive:

      ho sbagliato nel copiare la parte di diminuzione dell’intensità piuttosto che la fase di incremento di luminosità, ma il concetto sui tempi rimane lo stesso…
      sorry!

      • admin scrive:

        Ciao Matteo.
        Grazie per aver letto i miei tutorial 🙂

        Non capisco bene cosa intendi quando mi dici a regime, perché la risposta del led è istantanea, nel senso che l’azione dell’analogWrite è immediata ed il led avrà una luminosità pari a quella indicata dalla variabile “valoreFade”, il delay serve esclusivamente per far percepire visivamente la diminuzione di luminosità al nostro occhio e quindi ho bisogno di bloccare, ad ogni ciclo, per 10 ms la luminosità del led, in questo modo siamo in grado di percepire l’effetto.
        Per quanto riguarda la durata ti rispondo sì il tuo calcolo è giusto, l’intera variazione da piena luce ad assenza di luce dura 2,55 secondi o in altro modo 0,0425 minuti.

        Se possibile fammi sapere se ho recepito correttamente la tua domanda e se hai dubbi scrivimi quando vuoi.

        Saluti.

  7. mimmo scrive:

    Salve professore,
    Le faccio in primis i complimenti per il tutorial che è veramente interessante; veniamo ora al mio prob.
    se volessi nel ciclo una pausa, spiego meglio, vorrei accendere il led con luminosità crescente per poi farla diminuire fino a spegnerlo, lasciarlo in questo stato per un tempo x e riprendere il ciclo

    • admin scrive:

      Ciao Mimmo.

      Lo sketch è composto da due parti, la prima in cui aumenta la luminosità e la seconda in cui diminuisce, al termine di questa seconda ciclo for, dopo la penultima parentesi graffa chiusa, dovrebbe essere sufficiente aggiungere un delay con il tempo che ti necessita che metta temporaneamente in pausa lo sketch.
      Spero di aver risposto alla tua domanda.

      Grazie per aver letto i miei appunti.
      Un caro saluto.

  8. Daniele scrive:

    Salve, volevo chiederle maggiori informazioni riguardo alle ventoline dei PC (motori brushless DC 12V). Si può effettuare un controllo delle velocità/posizione?
    Grazie.

  9. Michele scrive:

    Salve professore,
    complimenti per il tutorial molto chiari e semplici da capire!
    è da poco che mi sono dedicato al mondo di arduino quindi premetto che le mie conoscenze sono abbastanza scarse e su internet non riesco a trovare una guida semplice ed asaustiva…
    le pongo il mio problema se per cortesia mi può dare una mano… ho aggiornato la plafoniera del mio acquario da neon l’ho portata a led …la parte hardware funziona però ho problemi col sviluppo dello sketch …
    il progetto sarebbe giorno/notte
    – la prima parte è accendere in pwm la striscia di led (e fino a li tutto ok);
    – il problema è la seconda parte cioè nel mantenere lo stato del pwm a 255 per un tot di ore per poi passare alla fase 3 cioè riportare il valore pwm da 255 a 0

    io l’avevo pensata così inizialmente:

    //nella pausa ho utilizzato un’uscita che in realtà non viene utilizzata

    int giorno = 9;
    int notte = 10;
    int pausa = 11;
    void setup()
    {}

    void loop()
    {
    for(int fadeValue = 0 ; fadeValue = 0; fadeValue -=5)
    {
    analogWrite(giorno, fadeValue);
    delay(50);
    }

    for(int fadeValue = 0 ; fadeValue = 0; fadeValue -=5)
    {
    analogWrite(notte, fadeValue);
    delay(50);
    }

    for(int fadeValue = 0 ; fadeValue = 0; fadeValue -=5)
    {
    analogWrite(pausa, fadeValue);
    delay(50);
    }
    }

    altrimenti avevo visto questo per basarmi però va aldilà delle mie conoscenze:
    http://forum.fisertek.it/viewtopic.php?f=6&t=1497&start=10

    grazie per l’attenzione

  10. Michele scrive:

    ho sbagliato a copiare sketch pardon

    int giorno = 9;
    int notte = 10;
    int pausa = 11;
    void setup()
    {}

    void loop()
    {
    for(int fadeValue = 0 ; fadeValue = 0; fadeValue -=5)
    {
    analogWrite(giorno, fadeValue);
    delay(500);
    }

    for(int fadeValue = 0 ; fadeValue = 0; fadeValue -=5)
    {
    analogWrite(notte, fadeValue);
    delay(500);
    }

    for(int fadeValue = 0 ; fadeValue = 0; fadeValue -=5)
    {
    analogWrite(pausa, fadeValue);
    delay(500);
    }
    }

  11. Michele scrive:

    lo sketch è giusto però quando lo pubblico mi taglia dei pezzi k devo fare?

  12. mattia scrive:

    Che bell’articolo:)
    ora avevo pensato ad una lampada a 10 led (3,3v e 20ma ciascuno)
    dovrei accenderli e spegnerli con arduino MA anche far cambiare luminosità tipo 25/70/100%…tutto da software da pc.. alimentatore 5v 500ma.
    è tutto pronto ma non capisco se conviene usare un transistor (e quale?) o attaccare tutto direttamente ad arduino…

    • Giovanni scrive:

      salve a tutti mi chiamo Giovanni e sono ormai un vecchietto ma sono rimasto sempre curioso nel campo dell’elettronica e programmazione fin dai tempi del vecchio commodre64 allora ero molto più giovane.Negli ultimi tempi (qualche mese) mi sono interessato ad Arduino e ho iniziato a smanettare con questo gioiellino però in programmazione mi sento un po’ impacciato anche se ho avuto qualche buon risultato. Questo mio sketch l’ho applicato a tre led in dissolvenza uno dopo l’altro. Professore la ringrazio per i vari tutorial le chiedo un consiglio vorrei sapere se ho fatto bene oppure ci sono delle scorciatoie non conoscendo benissimo sia Arduino che il linguaggio usato per la programmazione il vecchio basic ormai è superato la ringrazio aticipatamente.
      Giovanni.

      [code]
      int Pin1 = 9; //Inizzializziamo le variabili
      int Pin2 = 10; //assegnando i tre pin alle porte digitali
      int Pin3 = 11; // da 9 a 11
      int valoreFade = 0; //valore di fade di partenza
      int Pausa = 5;

      void setup() { // una sola volta, all’avvio, definiamo le modalità
        pinMode (Pin1, OUTPUT); // tutti i pin in modalità output(uscita)
        pinMode (Pin2, OUTPUT);
        pinMode (Pin3, OUTPUT);

      }

      void loop() { // da qui tutto si ripete all’infinito
      for (valoreFade = 0 ; valoreFade 0; valoreFade–) {
        analogWrite (Pin1,valoreFade); // disattiviamo il primo pin che spenge il primo Led
        delay (Pausa);
        }
        for (valoreFade = 0 ; valoreFade 0; valoreFade–) {
        analogWrite (Pin2, valoreFade); // disattiviamo il secondo pin per spengere il 2 Led
        delay (Pausa);
        }
        for (valoreFade = 0 ; valoreFade 0; valoreFade–) {
        analogWrite (Pin3, valoreFade);
        delay (Pausa);
        }

      }

      [/code]

  13. Giovanni scrive:

    [code]
    int Pin1 = 9; //Inizzializziamo le variabili
    int Pin2 = 10; //assegnando i tre pin alle porte digitali
    int Pin3 = 11; // da 9 a 11
    int valoreFade = 0;
    int Pausa = 5;

    void setup() { // una sola volta, all’avvio, definiamo le modalità
      pinMode (Pin1, OUTPUT); // tutti i pin in modalità output(uscita)
      pinMode (Pin2, OUTPUT);
      pinMode (Pin3, OUTPUT);

    }

    void loop() { // da qui tutto si ripete all’infinito
      for (valoreFade = 0 ; valoreFade 0; valoreFade–) {
        analogWrite (Pin1, valoreFade); // disattiviamo il primo pin che spenge il primo Led
        delay (Pausa);
      }
      for (valoreFade = 0 ; valoreFade 0; valoreFade–) {
        analogWrite (Pin2, valoreFade); // disattiviamo il secondo pin per spengere il 2 Led
        delay (Pausa);
      }
      for (valoreFade = 0 ; valoreFade 0; valoreFade–) {
        analogWrite (Pin3, valoreFade);
        delay (Pausa);
      }

    }

    [/code]

  14. marcello scrive:

    qualcuno mi sa indicare dove posso trovare un sensore di presenza e non di movimento? grazie

  15. Giuliano scrive:

    Professore buon giorno il commento che mi viene in mente per primo è : si può realizzare un PWM senza l’ausilio di arduino? cerco da giorni di trovare uno schema
    per realizzare il progetto di far girare il motore Brushless che ho. Con arduino tutto va
    bene, se può aiutarmi la ringrazio. Complimenti per tutto quello che scrive e spiega
    saluti Giuliano

    • admin scrive:

      Ciao Giuliano.

      Si è possibile, in modo abbastanza semplice puoi provare ad utilizzare NE555.
      Se fai una ricerca su internet trovi moltissime informazioni, se hai problemi fammi sapere.

      Saluti.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *