primo sketch

International Italiano Software
1

salve un augurio a tutti di buon anno.
dalla serie prima vai gattoni , dopo cammini e alla fine corri.
ho scritto questo piccolo sketc

const int ledverde = 2;
const int ledgiallo = 3;
const int ledrosso = 4;
const int ledblu = 5;
const int bottone = 6;

int a = 0;//variabili ustate per cambiare sequesnza
int b = 1;//variabili ustate per cambiare sequesnza
void setup() {

pinMode (ledverde, OUTPUT);//definisco pin uscita
pinMode (ledgiallo, OUTPUT);
pinMode (ledrosso, OUTPUT);
pinMode(ledblu, OUTPUT);
pinMode(6 , INPUT);

}

void loop() {
  int somma = a+b;// risultato che discrimina la sequenza di accensione
sbottone = digitalRead(6);
if (sbottone == LOW)/*ho provato a scrivere if(sbottone == LOW) { a=1;}
if  (somma == 1 ) ma non funziona */

  {
  // put your main code here, to run repeatedly:
  digitalWrite(ledrosso, LOW);
  digitalWrite(ledverde, HIGH);
  delay(150);
  digitalWrite(ledverde,LOW);
  
   digitalWrite(ledgiallo, HIGH);
  delay(150);
  digitalWrite(ledgiallo,LOW);
   
   digitalWrite(ledrosso, HIGH);
  delay(150);
  digitalWrite(ledrosso,LOW);
  
   digitalWrite(ledblu, HIGH);
  delay(150);
  digitalWrite(ledblu,LOW);
  delay(150);//inverto
  
   digitalWrite(ledrosso, HIGH);
  delay(150);
  digitalWrite(ledrosso,LOW);
   
   digitalWrite(ledgiallo, HIGH);
  delay(150);
  digitalWrite(ledgiallo,LOW);
  
   digitalWrite(ledverde, HIGH);
  delay(150);
  digitalWrite(ledverde,LOW);
  delay(150);
 }
 else {
  digitalWrite(ledverde,HIGH);
  digitalWrite(ledblu, HIGH);
  delay (150);
  digitalWrite(ledverde,LOW);
  digitalWrite(ledblu, LOW);
  delay (150);
   digitalWrite(ledgiallo,HIGH);
  digitalWrite(ledrosso, HIGH);
  delay (150);
   digitalWrite(ledgiallo,LOW);
  digitalWrite(ledrosso, LOW);
  delay (150);
   
 }
 }

semplicemente 4 led che scorrono e alla pressione del tasto , cambia la seqwuenza di accensione.
avrei un paio di domande.
prima : senza riscrivere completamente la serie di digitalwrite potrei usare una variabile come discriminante?
ho provato cambianto il valore di una variabile che a sua volta cambia il risultato di una somma , pero non so se e la strada giusta e come usarla,
seconda : ( se ho capito un po il funzionamento credo che non si possafare) quando premo il pulsante prima di cambiare
la sequenza di funzionamento , arduino termina la fase che sta facendo .
vi ringrazio anticipatamente per le risposte

2

Ma non ti da errore quando provi a compilarlo?

Nel programma utilizzi la variabile sbottone ma non viene definita da nessuna parte!

Definisci invece bottone ma poi utilizzi direttamente il numero della porta (6) invece della costante

Per come è adesso il programma effettua una sequenza con il pulsante premuto e l'altra con il pulsante non premuto, somma, a e b non servono a nulla.

Quando premi il pulsante arduino deve terminare la sequenza in corso in quanto hai usato delay ed essendo tutto in sequenza, non controlla se il pulsante nel frattempo è stato premuto, per avere una gestione in tempo reale della pressione del pulsante devi gestire i ritardi con millis, poi un modo per gestire le sequenze è con una variabile che si incrementa e una serie di "switch...case" per accendere i led come desiderato.

3

grazie per la risposta,
non mi da errore nella compilazione ,
io ho definito( o per lo meno credo di averlo fatto) scrivendo int sbottone= 0 , ho scritto cosi per porlo da subito in uno stato definito.per le variabili , cosi come e scritto sono inutili , nel sketch che ho postato ho inserito anche i comandi che ho usato e non hanno funzionato

int somma = a+b;// risultato che discrimina la sequenza di accensione
sbottone = digitalRead(6);
if (sbottone == LOW)  [color=red]/*ho provato a scrivere if(sbottone == LOW) { a=1;}
if  (somma == 1 ) ma non funziona */[/color]

.
controllero il link che mi hai postato , anche se è in inglese , provero a capirci qualcosa.

grazie ancora

4

ciao
provo ad intervenire solo perche sto tentando di leggere gli schetc scritti da altri.

a parte SBOTTONE che magari lo ha ridefinito dopo aver postato,
ed a parte le varibili usate in modalità SPRECO IMMENSO

da quel poco che ho capito vorresti far accendere e spegnere in sequenza i 4 led in sequenza prima da un lato poi dall'altro(correggimi se sbaglio)utilizzando il pulsante,

ma non ho capito ne il punto di partenza ne il punto finale del pulsante.

5

forse èper sbaglio non l ho copiato tutto ,,,
cmq , come ho scritto nella presentazione :frowning: dalla serie prima si va gattoni poi si cammina e solo dopo si corre).
sono partito dal semplice le che lampeggia ed copiando la parte di codice sono arrivato a 4 , li ho ricopiati ma in sequenza inversa e quindi da un effetto tipo super car , per intenderci ,
fatto questo volevo aggiungere un cambiamento gestito dal un punsante.
come cambiamento della sequenza ho impostato l accensione dei led 1 e 4 e dopo 2 e2 .
fatto questo volevo usare come discriminante una variabile , so che non serve pero è per sperimentare

6

I copia incolla se non hai capito cosa stai copiando ed incollando.... bloccano la mente e basta.

Prova a vederla in questo modo:

-I led devono fare solo 2 cose..accendersi se spenti oppure spegnersi se accesi.PUNTO.quando farlo glielo deve dire qualkun'altro.

-Anche il pulsante deve fare solo 2 cose SE è premuto manda un INPUT altrimenti non lo manda.PUNTO.

-Qualkun'altro o sei tu oppure è una variabile.

7

Quello che penso vuoi fare, in realtà, non è semplice.
Se ti accontenti e semplifichiamo, con un interruttore (occhio NON un pulsante ma un interruttore che mantiene la posizione) allora puoi fare una sequenza e QUANDO ha finito se hai cambiato la posizione dell'interruttore allora fai l'altra sequenza.
Perchè con un pulsante, solo l'istruzione digitalRead() lo legge, se Arduino sta eseguendo il codice di una sequenza, non può sentire che hai premuto il tasto.

Dovresti prima imparare a fare lampeggiare i led senza la delay, vedi l'esempio BlinkWithoutDelay.
Poi, fare una sequenza sola ma con variabili che dicono in quale fase della sequenza sei ed i ritradi pilotati da millis()

8

Igor ne approfitto per ringraziarti per le dritte dell'altra volta sul for nel contesto degli array.

9

Di nulla :slight_smile:

10

intendevo copiarlo dall ide a qui sul forum.
leggendoo in rete ho trovato una spiegazione che si basa su un esempio che e sul ide .
blinkwithout delay. devo fare delle prove operche non mi e chiaro il discorso sulle variabili

onst int ledPin =  13; // the number of the LED pin
int ledState = 0; // ledState used to set the LED
unsigned long previousMillis = 0; //variabile che memorizza l ultimo cambio di stato del led
unsigned long interval = 1000; //intervallo con cui cambia di stato
  pinMode(ledPin, OUTPUT); //set the digital pin as output:
}

void loop() {
  unsigned long currentMillis = millis();// qui sta assegnando una variabile??????????

  if(currentMillis - previousMillis > interval)// qui sta facendo un operazione di sottrazione e verificando se è maggiore di 1000????????
 {
    previousMillis = currentMillis; //save the last time you blinked the LED??????????????
    //if the LED is off turn it on and vice-versa:

    ledState ^= 1;///  qui????????????
    digitalWrite(ledPin, ledState);

questo èil codice che ho trovato ho scritto accando ad ogni riga il significato che credo di aver capito

11

leggendo l esempio che cè nell ide ho ( provato ) modificcato in modo da gestire 4 led .
esattamente cosi

const int ledbianco =  2;// pin led
const int ledgiallo = 3;
const int ledverde = 4;
const int ledblu = 5;

int statoledbianco = LOW; //stato iniziale led
int statoledgiallo = LOW; 
int statoledverde = LOW; 
int statoledblu = LOW; 

// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
unsigned long previousMillisb = 0;        // variabile che memoriuzza l ultimo aggiornamento led
unsigned long previousMillisg = 0;
unsigned long previousMillisv = 0;
unsigned long previousMillisbl = 0;
// constants won't change:
const long intervallob = 3000;           // interval at which to blink (milliseconds)
const long intervallog = 3000;
const long intervallov = 3000;
const long intervallobl = 3000;

void setup() {
  // set the digital pin as output:
  pinMode(ledbianco, OUTPUT);
  pinMode(ledverde, OUTPUT);
  pinMode(ledgiallo, OUTPUT);
  pinMode(ledblu, OUTPUT);
}

void loop() {
  // here is where you'd put code that needs to be running all the time.

  // check to see if it's time to blink the LED; that is, if the difference
  // between the current time and last time you blinked the LED is bigger than
  // the interval at which you want to blink the LED.
  unsigned long currentMillisb = millis();
  unsigned long currentMillisg = millis();
  unsigned long currentMillisv = millis();
  unsigned long currentMillisbl = millis();

  if (currentMillisb - previousMillisb >= intervallob) {
    // save the last time you blinked the LED
    previousMillisb = currentMillisb;

    // if the LED is off turn it on and vice-versa:
    if (statoledbianco == LOW) {
      statoledbianco = HIGH;
      
    } else {
      statoledbianco = LOW;
    }

    
    digitalWrite(ledbianco, statoledbianco);//led bianco-----------------------------------------------
  }
   if (currentMillisg - previousMillisg >= intervallog) {
    // save the last time you blinked the LED
    previousMillisg = currentMillisg;

    // if the LED is off turn it ounsigned long currentMillis = millis();n and vice-versa:
    if (statoledgiallo == LOW) {
      statoledgiallo = HIGH;
    } else {
      statoledgiallo = LOW;
    }

    
    digitalWrite(ledgiallo, statoledgiallo);//ledgiallo---------------------------------------------
  }
   if (currentMillisv - previousMillisv >= intervallov) {
    // save the last time you blinked the LED0
    previousMillisv = currentMillisv;

    // if the LED is off turn it on and vice-versa:
    if (statoledverde == LOW) {
      statoledverde = HIGH;
    } else {
      statoledverde = LOW;
    }

    
    digitalWrite(ledverde, statoledverde);//ledverde------------------------------------------
  }
   if (currentMillisbl - previousMillisbl >= intervallobl) {
    // save the last time you blinked the LED
    previousMillisbl = currentMillisbl;

    // if the LED is off turn it on and vice-versa:
    if (statoledblu == LOW) {
      statoledblu = HIGH;
      
    } else {
      statoledblu = LOW;
    }

    // set the LED with the ledState of the variable:
    digitalWrite(ledblu, statoledblu);
  }
}

ovviamente come e scritto qui i led lampeggiano simultaneamente con intervalli di 3 secondi per cambio di stato.
per qullo che vorrei fare io bisognerebbe variare gli intervalli tra acceso e spento mantenedo 3 secondi lo stato alto e portandolo a 9 quello basso .

12

Ti do lo spunto,ma cerca di capire quello che ho fatto fare allo schetc.

Innanzitutto gli dò degli "strumenti" (variabili) con cui dovrà lavorare,preparati psicologicamente che le variabili sono tante,diverse e da studiare (cosa che devo fare pure io).

#define ledverde 2//definisco ledverde il pin 2
#define ledgiallo 3
#define ledrosso 4
#define ledblu 5
#define bottone 6//definisco bottone il pin 2

byte a=0;//variabile usata per cambiare sequenza

Poi gli dico cosa deve fare 1 sola volta (setup),ma fai attenzione quello che ho detto NON è inciso sù pietra,quindi lo farà 1 sola volta,ma potrà essere modificato.

void setup() 
{
 pinMode (ledverde, OUTPUT);//definisco il pin ledverde come uscita
 pinMode (ledgiallo, OUTPUT);
 pinMode (ledrosso, OUTPUT);
 pinMode (ledblu, OUTPUT);
 pinMode (bottone, INPUT);//definisco il pin bottone come entrara
}

Poi gli dico cosa deve fare ciclicamente(loop) in pratica parte dall'inizio esegue la prima riga,poi la seconda,poi la terza ect.ect. e quando ha eseguito l'ultima, riparte dall'inizio all'infinito.

Stai attento perchè fà solo quello che gli dici di fare,se non gli dici di fare una cosa,semplicemente non la fà,perche da solo non ci arriva a sapere cosa vuoi fare tu, quindi o glielo dici tu oppure glielo fai dire da degli "strumenti" (variabili).

void loop() 
{
 if(digitalRead(bottone))//SE leggi bottone
    {
     a++;// il valore di a incrementa    
    }
 if(a>2)//SE il valore di a è maggiore di 2 
   {
    a=1;// il valore di a diventa 1
   }

 if(a==1)//SE il valore di a é 1
   {   
    digitalWrite(ledverde, HIGH);//SCRIVI sul ledverde un valore alto
    delay(150);//dormi
    digitalWrite(ledverde,LOW);//SCRIVI sul ledverde un valore basso
    digitalWrite(ledgiallo, HIGH);//SCRIVI sul ledgiallo un valore alto
    delay(150);//dormi
    digitalWrite(ledgiallo,LOW);   
    digitalWrite(ledrosso, HIGH);
    delay(150);
    digitalWrite(ledrosso,LOW);  
    digitalWrite(ledblu, HIGH);
    delay(150);
    digitalWrite(ledblu,LOW);
    delay(150);
   }
 if(a==2)//SE il valore di a é 1
   {      
    digitalWrite(ledblu, HIGH);
    delay(150);
    digitalWrite(ledblu,LOW);
    digitalWrite(ledrosso, HIGH);
    delay(150);
    digitalWrite(ledrosso,LOW);   
    digitalWrite(ledgiallo, HIGH);
    delay(150);
    digitalWrite(ledgiallo,LOW);  
    digitalWrite(ledverde, HIGH);
    delay(150);
    digitalWrite(ledverde,LOW);
    delay(150);
   }
 }

Ovviamente questo è uno dei modi più sbagliati e darà un sacco di problemi,ma per iniziare va bene,poi starà in te studiare per risolverli.

Ciao

13

albepancio:
ovviamente come e scritto qui i led lampeggiano simultaneamente con intervalli di 3 secondi per cambio di stato.
per qullo che vorrei fare io bisognerebbe variare gli intervalli tra acceso e spento mantenedo 3 secondi lo stato alto e portandolo a 9 quello basso .

prova a fare qualcosa del genere:

 if (statoledbianco == LOW) {
      statoledbianco = HIGH;
      intervallob = 3000;
     
    } else {
      statoledbianco = LOW;
      intervallob = 9000;
    }

cambia le varie costanti:

const long intervallob = 3000;
const long intervallog = 3000;
const long intervallov = 3000;
const long intervallobl = 3000;

in variabili int se rimani dentro un valore di 32,767 secondi come intervallo massimo.

Così puoi avere un tempo di acceso e di spento diverso per ogni led

14

Albe, dal tuo post #10 il tuo codice non è male. Devi aggiungere una variabile fase. L'intervallo era fisso mi pare, 150 e ti basta una millis. Allo scattare di Millis fai fase=fase +1 ed in base a fase accendi il led giusto, se fase 4 lo riporti a 0 o 1
La ledState ^= 1
Lavora sui bit, se 1 diventa zero, se 0 diventa 1

15

gazie ancora per le risposte.
per eseguire la sequenza avanti ed indietro dei led , ci sono ho anche capito un altro modo usando l istruzione for.
pero anche con questa prima di cmbiare la sequenza deve terminare quella in esecuzione.
pratic<mente non riesco ad effettuare istantaneamente il cambio di sequenza .

grazie per l aiuto
p.s. se non lo ho gia fatto vi auguro buon anno

16 
const byte ledbianco =  2;// pin led
const byte ledverde = 3;
const byte ledgiallo = 4;
const byte ledblu = 5;
byte fase=0;

unsigned long prevMillis = 0;        // variabile che memoriuzza l ultimo aggiornamento led
const long intervallo = 300;           // interval at which to blink (milliseconds)

void setup() 
{ pinMode(ledbianco, OUTPUT);
  pinMode(ledverde, OUTPUT);
  pinMode(ledgiallo, OUTPUT);
  pinMode(ledblu, OUTPUT);  
}

void loop() 
{ unsigned long currMillis = millis();
  if (currMillis - prevMillis >= intervallo) 
  { prevMillis = currMillis;
    fase++;
    if(fase>4) fase=1;
    switch(fase)
    { case 1: 
        digitalWrite(ledbianco,HIGH);
        digitalWrite(ledverde ,LOW);
        digitalWrite(ledgiallo,LOW);
        digitalWrite(ledblu   ,LOW);
        break;
      case 2: 
        digitalWrite(ledbianco,LOW);
        digitalWrite(ledverde ,HIGH);
        digitalWrite(ledgiallo,LOW);
        digitalWrite(ledblu   ,LOW);
        break;
      case 3: 
        digitalWrite(ledbianco,LOW);
        digitalWrite(ledverde ,LOW);
        digitalWrite(ledgiallo,HIGH);
        digitalWrite(ledblu   ,LOW);
        break;
      case 4: 
        digitalWrite(ledbianco,LOW);
        digitalWrite(ledverde ,LOW);
        digitalWrite(ledgiallo,LOW);
        digitalWrite(ledblu   ,HIGH);
        break;
    }
  }
}

Con questo sistema, una digitalRead() ad inizio permette di sentire se premi un bottone e a seconda del bottone potrai fare sequenze diverse

17

void loop()
statobottone = digitalRead(6, input); // o è meglio input_pullup???
if ( statobottone == HIGH) {
digitalWrite (ledgiallo, HIGH);}
else
{ unsigned long currMillis = millis();
IT

con questa piccola aggiunta dovrei saltare dalla sequenza al led giallo fisso ?
correggimi se sbaglio :slight_smile:
la variabile stato bottone legge il pin 6 e l istruzione if discrimina led giallo acceso fisso se il pin 6 è a livello alto
o continua con lo sketc ponendo subito currmills uguale a mills p.s. mills e il contatore interno?
grazie ancora pe ril tempo che mi dedicate
e le tante domande ma sono nuovo , e ho appena iniziato a leggere questo libro , quindi le nozioni sono poche

p.s. che differenza cèp fra const int ledverde = 2; , int ledverde = 2 e #define ledverde 2 ?

18

Ci sono un mucchio di altri modi.

Prova a capire quelli semplici poi fai un passo in avanti e prova a farlo in un altro modo.

Ma tenta sempre di capire quello che hai fatto.

19

ciao,

questo non ha senso:

statobottone = digitalRead(6, input);

anzi il compilagtore solleva un errore dicendoti che ci sono troppi "argomenti" in quanto la digitalRead si riferisce già ad un pin che è stato impostato come INPUT od INPUT_PULLUP...quindi dovrebbe essere "semplicemente":

statobottone = digitalRead(6);

dove 6 è il PIN da leggere.

con i tre ledverde che hai inizializzato in questo modo:

int ledverde = 2;

const int ledverde = 2;

#define ledverde 2

fai tre cose che sembrano simili ma che hanno delle differenze sostanziali tra loro:
int ledverde = 2; crei una varibile di tipo int (2 byte) a cui assegni il valore 2; questo valore può essere modificato durante l'esecuzione del programma.
const int ledverde = 2; crei una "variabile" ditipo int (2 byte) a cui assegni il valore due; anteponendo il qualificatore "const" dichiari che questa variabile non è più modificabile nel programma...avrà sempre il valore 2.
#define ledverde 2 con questa scrittura dai una direttiva al compilatore che andrà a sostituire tutte le parti di codice dove c'è scritto "ledverde" con 2; di solito le chiavi in #define vengono scritte con le lettere maiuscole...cioè il tuo ledverde dovrebbe essere LEDVERDE o, forse, meglio LED_VERDE.
con il #define si possono anche creare delle macro tipo:

#define PRINT(a) Serial.println(a)
#define MOLTIPLICA(a,b)   a*b
//#define MOLTIPLICA(a,b)   (a)*(b)

int led = 3;
char stringa[] = "ciao";

int a = 5, b = 3;

void setup() {
  Serial.begin(9600);
  PRINT(led);
  PRINT(led + (led * 2));
  PRINT(stringa);
  PRINT(MOLTIPLICA(a, b)); // sempre OK
  PRINT(MOLTIPLICA( a + b, b ));  // ATTENZIONE...con il primo #define divente a+b*b -> 14
                                  // si deve usare il secondo #define per eseguire (a+b)*(b) -> 24
}

void loop() {
}

attenzione però...per quanto detto sopra (sostituzione del testo del programma) il primo #define MOLTIPLICA, per come è scritto, non esegue quello che ci aspetteremo...la forma giusta è quella del secondo #define MOLTIPLICA.

20

grazie per le risposte.
quindi se ho capipto bene , se do int led = 2 ; la variabile led ha valore 2 ma per volere o per sbaglio potrebbe cambiare il suo valore durante l esecuzione del programma.
con const int il valore rimarra forzato a 2 , con dedine sara impostato a 2 per tutta l esecuzione , per un semplice valore numerico funziona tipo const int giusto?

grazie
p.s. per orso si ho scritto male sbottone digitalRead(6);
pinMode(6, input);