From d652511dd270b9e951dbaec8f93aff3daa70f604 Mon Sep 17 00:00:00 2001 From: Andrea Manni Date: Mon, 21 Nov 2016 17:09:57 +0100 Subject: [PATCH] oggi --- oggi/blink_0/blink_0.ino | 31 ------- .../blink_3_1_while_veloce.ino | 43 ++++++++++ .../blink_3_ciclo_while.ino | 52 ++++++++++++ .../blink_4_1_ciclo_for_veloce.ino | 85 +++++++++++++++++++ oggi/blink_4_ciclo_for/blink_4_ciclo_for.ino | 53 ++++++++++++ .../blink_5_while_funzione_argomento.ino | 67 +++++++++++++++ .../blink_6_doppio_leds.ino | 65 ++++++++++++++ 7 files changed, 365 insertions(+), 31 deletions(-) delete mode 100644 oggi/blink_0/blink_0.ino create mode 100644 oggi/blink_3_1_while_veloce/blink_3_1_while_veloce.ino create mode 100644 oggi/blink_3_ciclo_while/blink_3_ciclo_while.ino create mode 100644 oggi/blink_4_1_ciclo_for_veloce/blink_4_1_ciclo_for_veloce.ino create mode 100644 oggi/blink_4_ciclo_for/blink_4_ciclo_for.ino create mode 100644 oggi/blink_5_while_funzione_argomento/blink_5_while_funzione_argomento.ino create mode 100644 oggi/blink_6_doppio_leds/blink_6_doppio_leds.ino diff --git a/oggi/blink_0/blink_0.ino b/oggi/blink_0/blink_0.ino deleted file mode 100644 index f26f96d..0000000 --- a/oggi/blink_0/blink_0.ino +++ /dev/null @@ -1,31 +0,0 @@ -// 1. //////////// -// Commento iniziale multi linea -/* - Blink - - Accensione e spegnimanto di un LED utilizzando variabili - per impostare la velocita' del lampeggio. - - */ - -// 2. ////////////// -// Dichiarazione variabili -// -int led = 13; // Il LED onboard corrisponde al PIN 13 - // Ha una resistenza premontata - -// 3. ///////////////// -// Setup: eseguita una volta sola all'accensione della scheda -void setup() { - pinMode(led, OUTPUT); // Abilita il PIN del LED come OUTPUT in modo che - // possa essere acceso -} - -// 4. /////////////// -// loop: Le istruzioni vengono eseguite all'infinito -void loop() { - digitalWrite(led, HIGH); // Mette il PIN del LED in stato acceso - delay(1000); // Aspetta un secondo (mille millisecondi) - digitalWrite(led, LOW); // Mette il PIN del LED in stato spento - delay(500); // Aspetta mezzo secondo -} diff --git a/oggi/blink_3_1_while_veloce/blink_3_1_while_veloce.ino b/oggi/blink_3_1_while_veloce/blink_3_1_while_veloce.ino new file mode 100644 index 0000000..7a92d6b --- /dev/null +++ b/oggi/blink_3_1_while_veloce/blink_3_1_while_veloce.ino @@ -0,0 +1,43 @@ +/* + Blink v4: while loop + + Accensione e spegnimanto di un LED utilizzando un ciclo + iterativo while per comandare il lampeggio. + + Iterazione modificata da una variabile. + Introduzione const. + + */ + +const int led = 13; // Il valore non cambia + // durante l'esecuzione del programma +const int acceleratore = 30 ; +int tempo ; // + +void setup() { + pinMode(led, OUTPUT); +} + +void loop() { + int iterator = 0; // Defniamo una variabile per controllare il ciclo iterativo + while (iterator < 10) { // Condizione del ciclo + iterator = iterator + 1 ; // incrementa l'iteratore + + tempo = acceleratore * iterator ; // Varia il tempo di blink + brilla(tempo); // accende e spegne rapidamente il LED + // la pausa e' in funzione della variabile iteratore + } +} + +// Funzioni create dall'utente: +void brilla(int velocita) { + // Accende e spegne il LED accetando un argomento + // per impostare la velocita'. + + // sequenze di istruzione: accendere e spegnere il LED + digitalWrite(led, HIGH); // Mette il PIN del LED in stato acceso) + delay(velocita); // Pausa + digitalWrite(led, LOW); // Mette il PIN del LED in stato spento + delay(velocita); // Pausa +} + diff --git a/oggi/blink_3_ciclo_while/blink_3_ciclo_while.ino b/oggi/blink_3_ciclo_while/blink_3_ciclo_while.ino new file mode 100644 index 0000000..48065db --- /dev/null +++ b/oggi/blink_3_ciclo_while/blink_3_ciclo_while.ino @@ -0,0 +1,52 @@ +/* + Blink v4: while loop + + Accensione e spegnimanto di un LED utilizzando un ciclo + iterativo while per comandare il lampeggio. + + */ + +int led = 13; // LED OnBoard + + +// ///////////////// +// Setup: eseguita una volta sola all'accensione della scheda +void setup() { + // initialize the digital pin as an output. + pinMode(led, OUTPUT); +} + +// /////////////// +// loop: Le istruzioni vengono eseguite all'infinito +void loop() { + int iterator = 0; // Defniamo una variabile per controllare il ciclo iterativo + while (iterator < 10) { // Condizione del ciclo + + rapido(); + iterator = iterator + 1 ; // incrementa l'iteratore + } + +lento(); +} + +// Funzioni create dall'utente: +void rapido() { + // Accende e spegne rapidamente il LED + int breve = 200; + // sequenze di istruzione: accendere e spegnere il LED + digitalWrite(led, HIGH); // Mette il PIN del LED in stato acceso + delay(breve); // Pausa + digitalWrite(led, LOW); // Mette il PIN del LED in stato spento + delay(breve); // Pausa +} + + +void lento() { + // Accende e spegne lentamente il LED + int lunga = 1000; + // sequenze di istruzione: accendere e spegnere il LED + digitalWrite(led, HIGH); // Mette il PIN del LED in stato spento) + delay(lunga); // Pausa + digitalWrite(led, LOW); // Mette il PIN del LED in stato spento + delay(lunga); // Pausa +} diff --git a/oggi/blink_4_1_ciclo_for_veloce/blink_4_1_ciclo_for_veloce.ino b/oggi/blink_4_1_ciclo_for_veloce/blink_4_1_ciclo_for_veloce.ino new file mode 100644 index 0000000..a330935 --- /dev/null +++ b/oggi/blink_4_1_ciclo_for_veloce/blink_4_1_ciclo_for_veloce.ino @@ -0,0 +1,85 @@ +/* + Blink v4: for loop + + Accensione e spegnimanto di un LED utilizzando un ciclo + iterativo while per comandare il lampeggio. + + Reference: http://arduino.cc/en/Reference/for + Altri esempi: sketchbook_andrea/programming/loops/ + + */ + +const int led = 13; // Il valore non cambia + // durante l'esecuzione del programma + + +// ///////////////// +// Setup: eseguita una volta sola all'accensione della scheda +void setup() { + // initialize the digital pin as an output. + pinMode(led, OUTPUT); +} + +// /////////////// +// loop: Le istruzioni vengono eseguite all'infinito +void loop() { +for (int i = 0; i < 10; i++) { +// (Definizione iteratore, condizione di verifica, gestione dell'iteratore) +// Operatore ternario (3 elementi) +// i++ incrementa di uno la variabile + brilla(30 * i); // accende e spegne rapidamente il LED + // la pausa e' in funzione della variabile iteratore +} +} + +// Funzioni create dall'utente: +void brilla(int velocita) { + // Accende e spegne il LED accetando un argomento + // per impostare la velocita'. + + // sequenze di istruzione: accendere e spegnere il LED + digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level) + delay(velocita); // wait for a second + digitalWrite(led, LOW); // turn the LED off by making the voltage LOW + delay(velocita); // wait for a second +} + + +/* Domande + +1. Che differenza c'e' nella gestione dell'iteratore tra un ciclo + while e for ? +2. In quali casi si usa un ciclo for piuttosto che uno while? + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + Soluzioni +1. Nel ciclo for l'iteratore e tutta la sua gestione avviene al di fuori + del corpo della struttura del ciclo. Questa viene esplicitamente definita. +2. Un ciclo for e' indicato per casi in cui si conosce e si vuole controllare + il numero delle iterazioni. + Un ciclo while quando basta controllare + il perdurare di una situazione di durata indefinita ad es. lo stato + di un bottone. Es: + + while (stato_bottone = HIGH) { + digitalWrite(LED, HI); +} +*/ diff --git a/oggi/blink_4_ciclo_for/blink_4_ciclo_for.ino b/oggi/blink_4_ciclo_for/blink_4_ciclo_for.ino new file mode 100644 index 0000000..70e4ef2 --- /dev/null +++ b/oggi/blink_4_ciclo_for/blink_4_ciclo_for.ino @@ -0,0 +1,53 @@ +/* + Blink v4: while loop + + Accensione e spegnimanto di un LED utilizzando un ciclo + iterativo while per comandare il lampeggio. + + */ + +const int led = 13; // LED OnBoard + + + +// ///////////////// +// Setup: eseguita una volta sola all'accensione della scheda +void setup() { + // initialize the digital pin as an output. + pinMode(led, OUTPUT); +} + +// /////////////// +// loop: Le istruzioni vengono eseguite all'infinito +void loop() { +for (int i = 0; i < 10; i++) { +// (Definizione iteratore, condizione di verifica, gestione dell'iteratore) +// Operatore ternario (3 elementi) + + rapido(); // Unica istruzione + } + +lento(); +} + +// Funzioni create dall'utente: +void rapido() { + // Accende e spegne rapidamente il LED + int breve = 200; + // sequenze di istruzione: accendere e spegnere il LED + digitalWrite(led, HIGH); // Mette il PIN del LED in stato acceso + delay(breve); // Pausa + digitalWrite(led, LOW); // Mette il PIN del LED in stato spento + delay(breve); // Pausa +} + + +void lento() { + // Accende e spegne lentamente il LED + int lunga = 1000; + // sequenze di istruzione: accendere e spegnere il LED + digitalWrite(led, HIGH); // Mette il PIN del LED in stato spento) + delay(lunga); // Pausa + digitalWrite(led, LOW); // Mette il PIN del LED in stato spento + delay(lunga); // Pausa +} diff --git a/oggi/blink_5_while_funzione_argomento/blink_5_while_funzione_argomento.ino b/oggi/blink_5_while_funzione_argomento/blink_5_while_funzione_argomento.ino new file mode 100644 index 0000000..1f43d12 --- /dev/null +++ b/oggi/blink_5_while_funzione_argomento/blink_5_while_funzione_argomento.ino @@ -0,0 +1,67 @@ +/* + Blink v3 + Accensione e spegnimanto di un LED utilizzando un ciclo + iterativo while per comandare il lampeggio. + Questa volta il ciclo while() e' relegato in una funzione + che accetta come argomento il numero di ripetizionei da effettuare. + + This example code is in the public domain. + */ + +// Pin 13 has an LED connected on most Arduino boards. +// give it a name: +int led = 13; +int breve = 200; // Variabile richiambile nel corso dell'esecuzione +int lunga = 1000; + +// the setup routine runs once when you press reset: +void setup() { + // initialize the digital pin as an output. + pinMode(led, OUTPUT); +} + +// the loop routine runs over and over again forever: +void loop() { + lampeggia(8); + lento(); // accende e spegne lentamente il LED + // Domanda: a quanto equivale iterator ora? +} + +// Funzioni create dall'utente: + +void rapido() { + // Accende e spegne rapidamente il LED + + // sequenze di istruzione: accendere e spegnere il LED + digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level) + delay(breve); // wait for a second + digitalWrite(led, LOW); // turn the LED off by making the voltage LOW + delay(breve); // wait for a second +} + +void lento() { + // Accende e spegne lentamente il LED + + // sequenze di istruzione: accendere e spegnere il LED + digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level) + delay(lunga); // wait for a second + digitalWrite(led, LOW); // turn the LED off by making the voltage LOW + delay(lunga); +} + +void lampeggia(int ripetizioni) { + // Accende un LED per un numero stabilito di volte + + // Questa funziona accetta un parametro: ripetizioni + int i = 0; + while (i < ripetizioni) { + rapido(); // accende e spegne rapidamente il LED + i = i + 1 ; // incrementa l'iteratore + // i++ ; // equivalente + } +} + + + + + diff --git a/oggi/blink_6_doppio_leds/blink_6_doppio_leds.ino b/oggi/blink_6_doppio_leds/blink_6_doppio_leds.ino new file mode 100644 index 0000000..60615a4 --- /dev/null +++ b/oggi/blink_6_doppio_leds/blink_6_doppio_leds.ino @@ -0,0 +1,65 @@ +/* + Blink v5 + + Accensione e spegnimanto di 2 LED. + Nel circuito oltre al LED montato direttamente sul pin 13 + viene aggiunto un altro LED pilotato dal PIN 12. + + Ricordarsi di usare una resistenza da ~320ohms per il secondo LED. + Resistenza = (Voltaggio_Arduino - Forward_voltage_LED) / (ampere utilizzati) + R = (5v-1.8v) / 0.010a + R =320ohms + + + Schema: http://lab.piffa.net/schemi/led_single_bb.png + - http://lab.piffa.net/schemi/led_single_schem.png + + This example code is in the public domain. + */ + + +int led = 13; // Il LED onboard corrisponde al PIN 13 + // Ha una resistenza premontata +int red = 12; // Definiamo un altro led +int breve = 200; // Variabile richiambile nel corso dell'esecuzione +int lunga = 1000; + +// ///////////////// +// Setup: eseguita una volta sola all'accensione della scheda +void setup() { + // initialize the digital pin as an output. + pinMode(led, OUTPUT); // Abilitaiamo entrambi i LED + pinMode(red, OUTPUT); +} + +// /////////////// +// loop: Le istruzioni vengono eseguite all'infinito +void loop() { + digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level) + delay(breve); // wait for a second + digitalWrite(led, LOW); // turn the LED off by making the voltage LOW + delay(breve); // wait for a second + + digitalWrite(red, HIGH); // turn the LED on (HIGH is the voltage level) + delay(lunga); // wait for a second + digitalWrite(red, LOW); // turn the LED off by making the voltage LOW + delay(lunga); +} + +/* Domande + * + * 1. Creare una funzione che sia slegata dal PIN con cui interagisce. + * + * 2. Come procede il flusso delle istruzioni per far brillare i LED? + * E' possibile far brillare i LED indipendentemente l'uno dall'altro? + * + * + * Nota: la risposta alla domanda 2 arrivera' a fine corso! + */ + + + + + + + -- 2.39.2