From: eaman Date: Mon, 12 Dec 2016 14:04:42 +0000 (+0100) Subject: Oggi X-Git-Url: http://git.piffa.net/web?a=commitdiff_plain;h=eaee426ed0a1dc6f099b9426164ca5cb5b8132cd;p=sketchbook_andrea Oggi --- diff --git a/oggi/RGB_LED/README b/oggi/RGB_LED/README new file mode 100644 index 0000000..133660a --- /dev/null +++ b/oggi/RGB_LED/README @@ -0,0 +1,2 @@ +Ottima lezione in italiano: +- http://www.maffucci.it/2014/09/27/arduino-lezione-09-uso-di-led-rgb-parte-1/ diff --git a/oggi/RGB_LED/rgb_0/rgb_0.ino b/oggi/RGB_LED/rgb_0/rgb_0.ino new file mode 100644 index 0000000..d69d451 --- /dev/null +++ b/oggi/RGB_LED/rgb_0/rgb_0.ino @@ -0,0 +1,46 @@ +/* + Adafruit Arduino - Lesson 3. RGB LED + + RGB LED: mpostare i colori per un LED RGB + common anode + + Schema: http://lab.piffa.net/schemi/rgb.jpg + */ + +int redPin = 11; // 2v a 20ma: che resistenza dovro usare? +int greenPin = 10; // 3.5v a 20ma: che resistenza dovro usare? +int bluePin = 9; // 3.5v a 20ma: che resistenza dovro usare? + + + +void setup() +{ + pinMode(redPin, OUTPUT); + pinMode(greenPin, OUTPUT); + pinMode(bluePin, OUTPUT); +} + +void loop() +{ + analogWrite(redPin, 255); + analogWrite(greenPin,255); + analogWrite(bluePin, 255); +} + +/* Domande: + 1. Come scrivere le istruzioni analog Write in modo da sottrarre i valori? + 2. Accendere il LED nei vari colori + - http://i.stack.imgur.com/LcBvQ.gif + Soluzione: vedi lo sketch rgb_1_all_color + + 3. Scrivere una funzione che accetti 3 parametri per impostare i colori + 4. Scrivere una funzione che accetti come parametro il nome del colore + es "blue" e imposti il LED. + + Eventuale: + 5. Scrivere una funzione che accetti i colori in esadecimale + - http://www.yellowpipe.com/yis/tools/hex-to-rgb/color-converter.php + */ + + + diff --git a/oggi/RGB_LED/rgb_0_soluzione/rgb_0_soluzione.ino b/oggi/RGB_LED/rgb_0_soluzione/rgb_0_soluzione.ino new file mode 100644 index 0000000..5a5c971 --- /dev/null +++ b/oggi/RGB_LED/rgb_0_soluzione/rgb_0_soluzione.ino @@ -0,0 +1,71 @@ +/* + Adafruit Arduino - Lesson 3. RGB LED + + RGB LED: mpostare i colori per un LED RGB + common anode + */ + +int redPin = 11; // 2v a 20ma: che resistenza dovro usare? +int greenPin = 10; // 3.5v a 20ma: che resistenza dovro usare? +int bluePin = 9; // 3.5v a 20ma: che resistenza dovro usare? + + +void setup() +{ + pinMode(redPin, OUTPUT); + pinMode(greenPin, OUTPUT); + pinMode(bluePin, OUTPUT); +} + +void loop() +{ + + rendiBlu(); + delay(1000); + //setColor(255,0,0) ; // imposta il LED in rosso + //setColor(0xFF,0x00,0x00) ; // imposta il LED in rosso in esadecimale + // setName("green") ; + // delay(1000); +} + +// Funzioni: + +void rendiBlu() { + // Accende di Blu + + analogWrite(redPin, 255 ); + analogWrite(greenPin, 255 ); + analogWrite(bluePin, 0 ); + } + +void setColor(int red, int green, int blue) { +// Imposta i colori di un LED RGB Common Anodote +// in esadecimale + + analogWrite(redPin, 255 -red); + analogWrite(greenPin, 255 - green); + analogWrite(bluePin, 255 - blue); +} + +void setName(String colorName) { +// Imposta i colori di un LED RGB Common Anodote +// tramite una stringa + + if (colorName == "red") { + analogWrite(redPin, 0 ); + analogWrite(greenPin, 255 ); + analogWrite(bluePin, 255 ); + } + else if (colorName == "green") { + analogWrite(redPin, 255 ); + analogWrite(greenPin, 0 ); + analogWrite(bluePin, 255 ); + } + // ... +} +/* Hints: + +1. Per usare un solo valore esadecimale per settare i colori: + - http://ardx.org/src/code/CIRC12-code-MB-SPAR.txt + + */ diff --git a/oggi/RGB_LED/rgb_1_all_color/rgb_1_all_color.ino b/oggi/RGB_LED/rgb_1_all_color/rgb_1_all_color.ino new file mode 100644 index 0000000..a53a02a --- /dev/null +++ b/oggi/RGB_LED/rgb_1_all_color/rgb_1_all_color.ino @@ -0,0 +1,54 @@ +/* + Adafruit Arduino - Lesson 3. RGB LED + + RGB LED: rotazione tra tutti i colori. + + Schema: http://lab.piffa.net/schemi/rgb.jpg + + */ + +int redPin = 11; +int greenPin = 10; +int bluePin = 9; + +//uncomment this line if using a Common Anode LED +#define COMMON_ANODE + +void setup() +{ + pinMode(redPin, OUTPUT); + pinMode(greenPin, OUTPUT); + pinMode(bluePin, OUTPUT); +} + +void loop() +{ + setColor(255, 0, 0); // red + delay(1000); + setColor(0, 255, 0); // green + delay(1000); + setColor(0, 0, 255); // blue + delay(1000); + setColor(255, 255, 0); // yellow + delay(1000); + setColor(80, 0, 80); // purple + delay(1000); + setColor(0, 255, 255); // aqua + delay(1000); +} + +void setColor(int red, int green, int blue) +{ +#ifdef COMMON_ANODE + red = 255 - red; + green = 255 - green; + blue = 255 - blue; +#endif + analogWrite(redPin, red); + analogWrite(greenPin, green); + analogWrite(bluePin, blue); +} + + + + diff --git a/oggi/RGB_LED/rgb_2_pwm/rgb_2_pwm.ino b/oggi/RGB_LED/rgb_2_pwm/rgb_2_pwm.ino new file mode 100644 index 0000000..8e712fc --- /dev/null +++ b/oggi/RGB_LED/rgb_2_pwm/rgb_2_pwm.ino @@ -0,0 +1,69 @@ +// RGB LED PWM transizione + +// Transizione di un LED RGB tra rosso - blue -verde +// tramite PWM + +// This is meant for a Common Anodote RGB LED +// See all those (255 - val). + + +// Schema: http://lab.piffa.net/schemi/rgb.jpg + + +#define GREEN 10 +#define BLUE 9 +#define RED 11 +#define delayTime 20 + +void setup() { + + pinMode(GREEN, OUTPUT); + pinMode(BLUE, OUTPUT); + pinMode(RED, OUTPUT); + digitalWrite(GREEN, HIGH); + digitalWrite(BLUE, HIGH); + digitalWrite(RED, HIGH); +} + +int redVal; +int blueVal; +int greenVal; + +void loop() { + + int redVal = 255; + int blueVal = 0; + int greenVal = 0; + for( int i = 0 ; i < 255 ; i += 1 ){ + greenVal += 1; + redVal -= 1; + analogWrite( GREEN, 255 - greenVal ); + analogWrite( RED, 255 - redVal ); + + delay( delayTime ); + } + + redVal = 0; + blueVal = 0; + greenVal = 255; + for( int i = 0 ; i < 255 ; i += 1 ){ + blueVal += 1; + greenVal -= 1; + analogWrite( BLUE, 255 - blueVal ); + analogWrite( GREEN, 255 - greenVal ); + + delay( delayTime ); + } + + redVal = 0; + blueVal = 255; + greenVal = 0; + for( int i = 0 ; i < 255 ; i += 1 ){ + redVal += 1; + blueVal -= 1; + analogWrite( RED, 255 - redVal ); + analogWrite( BLUE, 255 - blueVal ); + + delay( delayTime ); + } +} diff --git a/oggi/RGB_LED/rgb_3_ReadASCIIString/rgb_3_ReadASCIIString.ino b/oggi/RGB_LED/rgb_3_ReadASCIIString/rgb_3_ReadASCIIString.ino new file mode 100644 index 0000000..13cf2b8 --- /dev/null +++ b/oggi/RGB_LED/rgb_3_ReadASCIIString/rgb_3_ReadASCIIString.ino @@ -0,0 +1,81 @@ +/* + Reading a serial ASCII-encoded string. + + Beware: set monitor to NL NewLine only + + This sketch demonstrates the Serial parseInt() function. + It looks for an ASCII string of comma-separated values. + It parses them into ints, and uses those to fade an RGB LED. + + + + Once you have programmed the Arduino, open your Serial minitor. + Make sure you have chosen to send a newline character when sending a message. + Enter values between 0-255 for the lights in the following format : + Red,Green,Blue. + + Seriously: did you set the Newline setting in the monitor? + + + Once you have sent the values to the Arduino, + the attached LED will turn the color you specified, + and you will receive the HEX values in the serial monitor. + + created 13 Apr 2012 + by Tom Igoe + + This example code is in the public domain. + + + + Schema: http://lab.piffa.net/schemi/rgb.jpg + + */ + +// pins for the LEDs: +const int redPin = 11; +const int greenPin = 10; +const int bluePin = 9; + +void setup() { + // initialize serial: + Serial.begin(9600); + // make the pins outputs: + pinMode(redPin, OUTPUT); + pinMode(greenPin, OUTPUT); + pinMode(bluePin, OUTPUT); + +} + +void loop() { + // if there's any serial available, read it: + while (Serial.available() > 0) { + + // look for the next valid integer in the incoming serial stream: + int red = Serial.parseInt(); + // do it again: + int green = Serial.parseInt(); + // do it again: + int blue = Serial.parseInt(); + + // look for the newline. That's the end of your + // sentence: + if (Serial.read() == '\n') { + // constrain the values to 0 - 255 and invert + // if you're using a common-cathode LED, just use "constrain(color, 0, 255);" + red = 255 - constrain(red, 0, 255); + green = 255 - constrain(green, 0, 255); + blue = 255 - constrain(blue, 0, 255); + + // fade the red, green, and blue legs of the LED: + analogWrite(redPin, red); + analogWrite(greenPin, green); + analogWrite(bluePin, blue); + + // print the three numbers in one string as hexadecimal: + Serial.print(red, HEX); + Serial.print(green, HEX); + Serial.println(blue, HEX); + } + } +} diff --git a/oggi/RGB_LED/rgb_4_array/rgb_4_array.ino b/oggi/RGB_LED/rgb_4_array/rgb_4_array.ino new file mode 100644 index 0000000..39060d4 --- /dev/null +++ b/oggi/RGB_LED/rgb_4_array/rgb_4_array.ino @@ -0,0 +1,35 @@ +/* + RGB Array + + RGB LED: impostare i colori per un LED RGB + common anode tramite array + + Schema: http://lab.piffa.net/schemi/rgb.jpg + */ + +byte pin[3] = {11, 10, 9}; // 2v a 20ma: che resistenza dovro usare? +byte color[3] = {255, 255, 255}; + + + +void setup() +{ + for (byte i = 0; i < 4; i++) { + pinMode(pin[i], OUTPUT); + } +} + + +void loop() +{ + analogWrite(pin[0], color[0]); + analogWrite(pin[1], color[1]); + analogWrite(pin[2], color[2]); +} + +/* Domande: + 1. Che differenza c'e' tra le variabili dei pin e dei colori? + */ + + + diff --git a/oggi/RGB_LED/rgb_5_struct/rgb_5_struct.ino b/oggi/RGB_LED/rgb_5_struct/rgb_5_struct.ino new file mode 100644 index 0000000..dbe0d05 --- /dev/null +++ b/oggi/RGB_LED/rgb_5_struct/rgb_5_struct.ino @@ -0,0 +1,80 @@ +/* + RGB struct LED + + RGB LED: mpostare i colori per un LED RGB + common anode utilizzando uno struct + + Schema: http://lab.piffa.net/schemi/rgb.jpg + */ + +byte pin[3] = {11, 10, 9}; // 2v a 20ma: che resistenza dovro usare? + +struct color { + byte red ; + byte blue; + byte green; + +} ; + +color led; + + +void setup() +{ + for (byte i = 0; i < 4; i++) { + pinMode(pin[i], OUTPUT); + } +} + + +void loop() +{ + analogWrite(pin[0], led.red); + analogWrite(pin[1], led.green); + analogWrite(pin[2], led.blue); +} + +/* Domande: + 1. Potrei mettere i numeri dei PIN dentro lo stesso struct? + 2. Quale differenza funzionale c'e' tra i numeri dei PIN e i colori? + 2.1 Quando devo settare i pin e quante volte? + 2.2 Quando imposto i colori e quanto spesso? + + 3. Sarebbe piu' elegante scrivere una funzione per gestire il setup dei PIN + e impostare i colori? + 3.1 Servira' una o piu' funzioni? + 4. Esiste un costrutto che mi permetta di legare le differenti proprieta' + del LED RGB e contemporaneamente raggruppare le funzioni che tipicamente uso con questo? + */ + + +/* Risposte: + * 1. + +struct ledRGB { + byte rPin ; // PINS + byte gPin; + byte bPin; + byte blue; // Colors + byte green; + byte red; +}; + +ledRGB led {0,255,255,9,10,11}; + + + +void setup() +{ + pinMode(led.Pin, OUTPUT); + pinMode(led.Pin, OUTPUT); + pinMode(led.Pin, OUTPUT); +} + +void loop() +{ + analogWrite(led.rPin,led.red ); + analogWrite(led.gPin,led.green); + analogWrite(led.bPin,led.blue); +} +*/ diff --git a/oggi/RGB_LED/rgb_6_quasi_obj/rgb_6_quasi_obj.ino b/oggi/RGB_LED/rgb_6_quasi_obj/rgb_6_quasi_obj.ino new file mode 100644 index 0000000..967cf25 --- /dev/null +++ b/oggi/RGB_LED/rgb_6_quasi_obj/rgb_6_quasi_obj.ino @@ -0,0 +1,86 @@ +/* + RGB Object (quasi!) + + Gestione di un LED RGB tramite programmazione a oggetti + Esercizio intermedio: manca constructor. + + Schema: http://lab.piffa.net/schemi/rgb.jpg + */ + +class RGBLed { + // Classe rappresentativa di un LED RGB + + byte redPin =11; + byte greenPin =10; + byte bluePin =9; + byte redValue ; + byte greenValue ; + byte blueValue ; + + public: + void Arrossa () { + // Metodo = funzione dell'oggetto + // Imposta il colore di un LED RGB a rosso + + analogWrite(redPin, 0); + analogWrite(greenPin, 255); + analogWrite(bluePin, 255); + } + + void SetColor (byte r, byte g, byte b) { + // Imposta il colore di un LED RGB + + analogWrite(redPin, r); + analogWrite(greenPin, g); + analogWrite(bluePin, b); + } +} led; // Dichiariamo un instanza dell'oggetto + + +void setup() { + pinMode(9, OUTPUT); + pinMode(10, OUTPUT); + pinMode(11, OUTPUT); +} + +void loop() { + led.Arrossa(); + delay(1000); + led.SetColor(255, 0, 255) ; // Mettiamo il LED in Green + delay(1000); + +} + +/* Domande + 1. Potrei istanziare un altro oggetto RGBLed con PIN diversi? + 2. Posso accedere (leggere / modificare) le proprieta' dell'oggetto? + 3. A quali di queste proprieta' potrei voler accedere? + 4. Devo comunque abilitare i PIN come OUTPUT nel setup(): sarebbe possibile + farlo tramite una funione, magari automaticamente? + . + . + . + . + . + . + . + . + . + . + . + . + . + . + . + . + 1. Mi serve una funzione che permetta di assegnare delle proprieta come i PIN + 2. Al momento no: sono tutte PRIVATE. provate a spostarne alcune sotto + la dichiarazione PUBLIC . + 3. Ad es. i colori che vado a modificare, i numeri dei pin su suppone + debbano restare immutati. + 4. Per usare una funzione nel setup() bisognerebbe rendere pubbliche + le proprieta' che indicano i PIM. + Meglio sarebbe avere una funzione che venga invocata una sola volta + al momento di instanziare l'oggetto. Un CONSTRUCTOR . + */ + diff --git a/oggi/RGB_LED/rgb_7_obj/rgb_7_obj.ino b/oggi/RGB_LED/rgb_7_obj/rgb_7_obj.ino new file mode 100644 index 0000000..e63ace4 --- /dev/null +++ b/oggi/RGB_LED/rgb_7_obj/rgb_7_obj.ino @@ -0,0 +1,78 @@ +/* + RGB Object + + Gestione di un LED RGB tramite programmazione a oggetti + + Schema: http://lab.piffa.net/schemi/rgb.jpg + */ + +class RGBLed { + // Classe rappresentativa di un LED RGB + + // Private properties, le proprieta' sono private per default + byte redPin ; + byte greenPin ; + byte bluePin ; + + public: + // Public properties + byte redValue ; + byte greenValue ; + byte blueValue ; + + // Constructor: come viene instanziato un oggetto facente parte della classe + RGBLed(byte pinR, byte pinG, byte pinB) + { + // Carichiamo i valori dei PIN dentro alle proprieta' + redPin = pinR ; + greenPin = pinG ; + bluePin = pinB ; + + // Equvalente del Setup() per inizializzare i PIN + pinMode(redPin, OUTPUT); + pinMode(greenPin, OUTPUT); + pinMode(greenPin, OUTPUT); + } + + void Arrossa () { + // Metodo = funzione dell'oggetto + // Imposta il colore di un LED RGB a rosso + + analogWrite(redPin, 0); + analogWrite(greenPin, 255); + analogWrite(bluePin, 255); + } + + void SetColor (byte r, byte g, byte b) { + // Imposta il colore di un LED RGB + + analogWrite(redPin, r); + analogWrite(greenPin, g); + analogWrite(bluePin, b); + } +}; + +// Instanziamo un LED +RGBLed led(11, 10, 9); +/* L'oggetto viene istanziato qui e non nella funzione di setup() + perche' altrimenti la sua esistenza sarebbe legata solo + al contesto (scope) del setup(), non sarebbe disponibile nel loop() + */ + +void setup() { + // I PIN mode vengono settati dal constructor +} + +void loop() { + led.Arrossa(); + delay(1000); + led.SetColor(255, 0, 255) ; // Mettiamo il LED in Green + delay(1000); + +} + +/* Domande + 1. Provate ad accedere (serial print oppure modificare) le proprieta private e pubbliche. + + */ + diff --git a/oggi/button_1/button_1.ino b/oggi/button_1/button_1.ino new file mode 100644 index 0000000..f409028 --- /dev/null +++ b/oggi/button_1/button_1.ino @@ -0,0 +1,45 @@ +/* + Input Condizionale + + Accensione e spegnimanto di un LED utilizzando un pin come input. + + Utilizzare un jumper per collegare il PIN Input + alternativamente a +5 o GND . + +Schema: +- http://lab.piffa.net/schemi/led_condizionale.png + + */ + +// Pin 13 has an LED connected on most Arduino boards. +// give it a name: +int led = 12; +int input = 2; + +// the setup routine runs once when you press reset: +void setup() { + // initialize the digital pin as an output. + pinMode(led, OUTPUT); // Il PIN e' attivato come output + pinMode(input, INPUT); // Il PIN e' attivato come output +} + +// the loop routine runs over and over again forever: +void loop() { + if (digitalRead(input) == HIGH) { // Verifica se il PIN input e' +5V + digitalWrite(led, HIGH); + } + if (digitalRead(input) == LOW) { // Verifica se il PIN input e' 0V + digitalWrite(led, LOW); + } +} + +/* Domande: + 1. Invertire il programma facendo in modo che il led si spenga + quando il bottone e' premuto. Considerare come ottenere lo stesso risultato + modificando il circuito. + 2. Modificare il programma per far brillare il led cinque volte al secondo + quando il bottone e' premuto. + 3. Si potrebbe usare un ciclo iterativo while invece che + un ciclo condizonale if? Che differenza c'e' tra il ciclo while, if e for? + 4. Domanda: cosa succede se il jumper input non e' collegato ne al +5 ne al ground? + */ diff --git a/oggi/button_state_3/button_state_3.ino b/oggi/button_state_3/button_state_3.ino new file mode 100644 index 0000000..2afa6d9 --- /dev/null +++ b/oggi/button_state_3/button_state_3.ino @@ -0,0 +1,47 @@ +/* + Stato di un bottone + + Legge lo stato di un input + + */ + +int switchPin = 2; // switch connesso al pin 2 + // Nota: le prossime due variabili sono + // solo "definite" e non "inizializzate" +int statoAttuale; // Variabile per leggere lo stato del bottone +int ultimoStato; // Variabile per registrare l'ultimo stato del bottone + +void setup() { + pinMode(switchPin, INPUT); // Set the switch pin as input + + Serial.begin(9600); // Set up serial communication at 9600bps + ultimoStato = digitalRead(switchPin); // read the initial state +} + + +void loop(){ + statoAttuale = digitalRead(switchPin); // Legge lo stato del bottone e + // lo resistra nella variabile + delay(20); // riduce l'effetto bounce + if (statoAttuale != ultimoStato) { + // verifica due condizioni che devono realizzarsi contemporaneamente + if (statoAttuale == HIGH) { // il bottone e' stato premuto + Serial.println("Bottone premuto"); + } + else { // il bottone non e' premuto... + Serial.println("Bottone rilasciato"); + } + } + + ultimoStato = statoAttuale; // Aggiorna lo stato finale al valore attuale +} + +/* Domande: + + 1. Cosa succde se non uso un delay(20) alla lettura del bottone? + 2. Implementare un LED che cambia stato quando viene premuto il bottone. + 3. Quanti stati ha il LED? + 4. Sarebbe possibile passare rapidamente da uno stato all'altro? + + */ + diff --git a/oggi/button_state_4_final/button_state_4_final.ino b/oggi/button_state_4_final/button_state_4_final.ino new file mode 100644 index 0000000..4c0593f --- /dev/null +++ b/oggi/button_state_4_final/button_state_4_final.ino @@ -0,0 +1,62 @@ +/* + Stato di un bottone + + Legge lo stato di un input + + */ +const int led = 13; +const int buttonPin = 2; +boolean statoAttuale; // Variabile per leggere lo stato del bottone +boolean ultimoStato; // Variabile per registrare l'ultimo stato del bottone + +void setup() { + pinMode(buttonPin, INPUT); // Set the switch pin as input + pinMode(led, OUTPUT); + ultimoStato = digitalRead(buttonPin); // Prima lettura del bottone +} + +void loop(){ + statoAttuale = digitalRead(buttonPin); // Legge lo stato del bottone e lo resistra in val + delay(20); // riduce l'effetto bounce + if (statoAttuale != ultimoStato && statoAttuale == HIGH) { // due condizione contemporanee + // lo stato del bottone e' camabiato AND lo stato attuale e' HIGH + digitalWrite(led, !(digitalRead(led))); + // Il processore setta lo stato di un led + // impostando il relativo PIN: possiamo leggere il relativo registro + // allo stesso modo di un bottone. + } + + ultimoStato = statoAttuale; // Aggiorna lo stato finale al valore attuale +} + + + +/* Domande: + + 1. La variabile ledstatus serve per tenere traccia dello stato del LED: + si potrebbe fare a meno di questa? + Cosa fa Arduino quando deve accendere o spegnere un LED? + Come funziona DigiralRead() ? + + . + . + . + . + . + . + . + . + . + . + . + . + . + . + . + Soluzione: + + 1. Per accendere o spegnere un LED Arduino imposta il valore del registro corrispondente + al PIN: se questo e' 0 il circuito e' aperto mentre se e' 1 il circuito e' chiuso. + Allo stesso modo con DigitalRead() e' possibile leggere lo stato di quel regustro + e conoscere se il LED e' acceso o spento. + */ diff --git a/oggi/button_state_4_state/button_state_4_state.ino b/oggi/button_state_4_state/button_state_4_state.ino new file mode 100644 index 0000000..30a330b --- /dev/null +++ b/oggi/button_state_4_state/button_state_4_state.ino @@ -0,0 +1,49 @@ +/* + Stato di un bottone + + Legge lo stato di un input + + */ +int led = 13; // Definizione delle variabili +int buttonPin = 2; + // Dichiarazione di variabili +int statoAttuale; // Variabile per leggere lo stato del bottone +int ultimoStato; // Variabile per registrare l'ultimo stato del bottone +int ledStatus; // varabile per mantenere lo stato del led + +void setup() { + pinMode(buttonPin, INPUT); + pinMode(led, OUTPUT); + Serial.begin(9600); // Attiva la comunicazione seriale a 9600bps + ultimoStato = digitalRead(buttonPin); // Prima lettura del bottone + ledStatus = 0; // Il LED viene inpostato come spento +} + +void loop(){ + statoAttuale = digitalRead(buttonPin); // Legge lo stato del bottone e + // lo registra nella variabile + delay(20); // riduce l'effetto bounce + if (statoAttuale != ultimoStato) { // lo stato del bottone e' cambiato + if (statoAttuale == HIGH) { // il bottone e' stato premuto + Serial.println("Button premuto"); + + ledStatus = !ledStatus ; // Inverte lo stato del LED + // ledStatus = 1 - ledStatus ; // Forma analoga + + Serial.print("Stato del LED: "); // DEBUG + Serial.println(ledStatus) ; + } + } + + ultimoStato = statoAttuale; // Aggiorna lo stato finale al valore attuale + digitalWrite(led, ledStatus); // setta il led allo stato richiesto + +} + +/* Domande: + + 1. I due cicli if verificano che due condizioni siano concomitanti: e' possibile + integrarli semplificando il codice? + + */ + diff --git a/oggi/button_state_4_state_and_condition/button_state_4_state_and_condition.ino b/oggi/button_state_4_state_and_condition/button_state_4_state_and_condition.ino new file mode 100644 index 0000000..5ac0879 --- /dev/null +++ b/oggi/button_state_4_state_and_condition/button_state_4_state_and_condition.ino @@ -0,0 +1,72 @@ +/* + Stato di un bottone + + Legge lo stato di un input + + */ +int led = 13; +int buttonPin = 2; +int statoAttuale; // Variabile per leggere lo stato del bottone +int ultimoStato; // Variabile per registrare l'ultimo stato del bottone +int ledStatus; // varabile per mantenere lo stato del led + +void setup() { + pinMode(buttonPin, INPUT); // Set the switch pin as input + pinMode(led, OUTPUT); + Serial.begin(9600); // Attiva la comunicazione seriale a 9600bps + ultimoStato = digitalRead(buttonPin); // Prima lettura del bottone + ledStatus = 0; // Il LED viene inpostato come spento +} + +void loop(){ + statoAttuale = digitalRead(buttonPin); // Legge lo stato del bottone e lo resistra in val + delay(20); // riduce l'effetto bounce + if (statoAttuale != ultimoStato && statoAttuale == HIGH) { // due condizione contemporanee + // lo stato del bottone e' camabiato AND lo stato attuale e' HIGH + Serial.println("Button premuto"); + + ledStatus = !ledStatus ; // Inverte lo stato del LED + // ledStatus = 1 - ledStatus ; // Forma analoga + + Serial.print("Stato del LED: "); // DEBUG + Serial.println(ledStatus) ; + } + + ultimoStato = statoAttuale; // Aggiorna lo stato finale al valore attuale + digitalWrite(led, ledStatus); // setta il led allo stato richiesto + +} + + + +/* Domande: + + 1. La variabile ledstatus serve per tenere traccia dello stato del LED: + si potrebbe fare a meno di questa? + Cosa fa Arduino quando deve accendere o spegnere un LED? + Come funziona DigiralRead() ? + + . + . + . + . + . + . + . + . + . + . + . + . + . + . + . + Soluzione: + + 1. Per accendere o spegnere un LED Arduino imposta il valore del registro corrispondente + al PIN: se questo e' 0 il circuito e' aperto mentre se e' 1 il circuito e' chiuso. + Allo stesso modo con DigitalRead() e' possibile leggere lo stato di quel registro + e conoscere se il LED e' acceso o spento. + - https://www.arduino.cc/en/Reference/PortManipulation + - http://www.instructables.com/id/Microcontroller-Register-Manipulation/ + */ diff --git a/oggi/pwm_3_fade_reverser/pwm_3_fade_reverser.ino b/oggi/pwm_3_fade_reverser/pwm_3_fade_reverser.ino deleted file mode 100644 index 70bc48b..0000000 --- a/oggi/pwm_3_fade_reverser/pwm_3_fade_reverser.ino +++ /dev/null @@ -1,64 +0,0 @@ -/* -Fade - - This example shows how to fade an LED on pin 9 - using the analogWrite() function. - This example code is in the public domain. - From Arduino for dummies. - */ - -const int led = 9; // LED con PWM -byte brightness = 0; // Luminosita' -const int fadeAmount = 5; // Step di modifica luminosita' -const int pause = 30; // Pausa tra incrementi - - -void setup() { - pinMode(led, OUTPUT); // declare pin 9 to be an output: -} - -void loop() { - - analogWrite(led, brightness); - brightness = brightness + fadeAmount; - - if (brightness == 0 || brightness == 255) { - // Invertire incremento ai valori limiti - fadeAmount = -fadeAmount ; - } - // wait for 30 milliseconds to see the dimming effect - delay(pause); -} - - -/* Domande: - 1. Che rapporto c'e' tra un OR e due cicli IF ? - 2. E tra un AND e due cicli IF ? -. -. -. -. -. -. -. -. -. -. -. -. -. -. -. -. -. -. -. -. -Soluzioni: - 1. Due cicli IF sequenziali con: - - Condizioni diverse - - stessa conseguenza - - 2. Due cicli IF annidiati che verificano due condizioni in sucessione - -*/