millis concatenato

[ilguargua]

Prova a modificare le funzioni così :

 

void led1Blink(){
    static unsigned long lastToggle = 0;
    uint16_t toggleTime = 1000;
    uint16_t duration = 5000;
    unsigned long start = millis();
    while(start + duration > millis()){
        if(lastToggle + toggleTime < millis()){
            toggleLed(led1);
            lastToggle = millis();
        }
    }
}

 

 

Ciao, Ale.

[kemosabe]

cosa è cambiato? 

che invece dell'if c'è il while, d'accordo ma il risultato non cambia di molto.

Stai temporizzando solo il blink da acceso a spento.

Io oltre che al tempo tra acceso e spento, vorrei dare un tempo di durata del blink totale.

ovvero per esempio:

tempo totale 5 secondi, nei quali il led ai accende e si spegne ogni secondo....

ma poi deve passare ad un secondo ed ad un terzo ecc. 

esempio:

per 5 secondi fai blinkare a 1 secondo il rosso

poi per 5 secondi fai blinkare a 1 secongo il verde

ecc   ecc 

solo che, sia il tempo totale di ogni blink che il blink stesso dovrei farli con millis

 

 

grazie

Modificato: 16 dicembre 2019 da kemosabe

[ilguargua]

 

tempo totale 5 secondi, nei quali il led ai accende e si spegne ogni secondo....

ma poi deve passare ad un secondo ed ad un terzo ecc. 

esempio:

per 5 secondi fai blinkare a 1 secondo il rosso

poi per 5 secondi fai blinkare a 1 secongo il verde

Oddio, non ho provato perchè qui a casa ora non ho tutto il materiale, ma la funzione modificata dovrebbe fare esattamente quello che chiedi. Visto che le funzioni sono 3, come i led, e le richiami una dopo l'altra nel loop(), dovresti avere esattamente quello che hai scritto. L'unica cosa è che mentre lampeggia ad esempio il rosso, gli altri sono fermi (che però mi pare sia quello che vuoi). Poi non è detto che questo sia il sistema migliore per ottenere quello che vuoi, io ho fatto questo esempio perchè mi pareva più vicino a quello che avevi postato per primo, ma sicuramente si può fare anche in altri modi.

 

Ciao, Ale.

[kemosabe]

Sempre rimanendo in tema, ma solo perchè vorrei capire per poter proseguire, molte volte in alcuni listati trovo questo:

void fade(unsigned char *val, unsigned char fadeTime)

mi spiegate cosa fa e a cosa serve scrivere un cilclo in questo modo?

 

grazie

[Livio Orsini]

Dovrebbe essere una funzione di una libreria che esegue il "fading",ovvero lospegnimento graduale di un LEDo di una lampada.

E'' una funzione parametrica che non restituisce alcun dato (void)si passano 2 parametri "unsigned char" ovvero un byte senza segno.

 

Sarà legata ad un'uscita PWM così da passare da 255 a 0 in modo graduale.

[ilguargua]

Nella speranza di fare cosa gradita, aggiorno lo sketch di esempio, con qualche modifica e qualche commento in più :

 

#define MIN_BLINKS      3   //cicli di lampeggio minimi

//durata minima ciclo on/off, non conviene scendere sotto questo valore
#define MIN_TOGGLE      200   
//durata massima ciclo on/off
#define MAX_TOGGLE      2000  

//durata minima per ogni led
#define MIN_DURATION    3000
//durata massima per ogni led
#define MAX_DURATION   10000 

// pin a cui sono collegati i led
uint8_t leds[] = {2,3,4};

//diamo un nome ad ogni led e definiamo contemporaneamente il totale
typedef enum {
    led_R,
    led_G,
    led_B,
    ledsCount
} ledsDefs_t;


void setup(){
    //assegniamo i pin ed effettuiamo un breve self-test
    for(uint8_t i=0;i<ledsCount;i++){
        pinMode(i,OUTPUT);
        digitalWrite(i,HIGH);
        delay(1000);
        digitalWrite(i,LOW);
    }
}


void ledBlink(uint8_t led, uint16_t toggleTime, uint32_t period){
    uint32_t lastToggle = 0;
    // controlliamo che il tempo sia sufficiente per effettuare un minimo di lampeggi
    uint16_t duration = max(toggleTime * MIN_BLINKS, period);
    duration += 50 ; //giusto per essere sicuri di rientrare nei tempi
    uint32_t start = millis();
    while(start + duration > millis()){
        if(lastToggle + toggleTime < millis()){
            digitalWrite(led, ! digitalRead(led));
            lastToggle = millis();
        }
    }
    digitalWrite(led, LOW); // lasciamo il led in uno stato noto
}


void loop(){
    // richiamiamo la funzione per ogni led
    ledBlink(led_R,random(MIN_TOGGLE,MAX_TOGGLE),random(MIN_DURATION,MAX_DURATION));
    ledBlink(led_G,random(MIN_TOGGLE,MAX_TOGGLE),random(MIN_DURATION,MAX_DURATION));
    ledBlink(led_B,random(MIN_TOGGLE,MAX_TOGGLE),random(MIN_DURATION,MAX_DURATION));
    
    // oppure se vogliamo la possiamo richiamare come nel setup()
    //for(uint8_t i=0;i<ledsCount;i++){
    //    ledBlink(i,random(MIN_TOGGLE,MAX_TOGGLE),random(MIN_DURATION,MAX_DURATION));
    //}
    
    
}

 

 

Ciao, Ale.

[Livio Orsini]

Ale hai scritto lo sketch i stile Pascal, con le funzioni prima del main, hai programmato in Pascal?

[ilguargua]

 

hai programmato in Pascal?

No, mai, ma ho preso le brutte abitudini dello stile "Arduino" ...

 

Ciao, Ale.

[kemosabe]

porgo alla vostra attenzione questo listato che ho trovato facendo varie ricerche:

const int RED_PIN = 7;
const int GREEN_PIN = 6;
const int BLUE_PIN = 8;

// This variable controls how fast we loop through the colors.
// (Try changing this to make the fading faster or slower.)

int DISPLAY_TIME = 10;  // In milliseconds

void setup()
{
// Here we'll configure the Arduino pins we're using to
// drive the LED to be outputs:

pinMode(RED_PIN, OUTPUT);
pinMode(GREEN_PIN, OUTPUT);
pinMode(BLUE_PIN, OUTPUT);
}

void loop()
{

mainColors();
showSpectrum();
}

void mainColors()
{
// Off (all LEDs off):
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);

delay(1000);

// Red (turn just the red LED on):
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);

delay(1000);

// Green (turn just the green LED on):
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, LOW);

delay(1000);

// Blue (turn just the blue LED on):
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);

delay(1000);

// Yellow (turn red and green on):
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, LOW);

delay(1000);

// Cyan (turn green and blue on):
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, HIGH);

delay(1000);

// Purple (turn red and blue on):
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);

delay(1000);

// White (turn all the LEDs on):
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, HIGH);

delay(1000);
}


// Below are two more functions we've written,
// showSpectrum() and showRGB().

// showRGB() displays a single color on the RGB LED.
// You call showRGB() with the number of a color you want
// to display.

// showSpectrum() steps through all the colors of the RGB LED,
// displaying a rainbow. showSpectrum() actually calls showRGB()
// over and over to do this.

// We'll often break tasks down into individual functions like
// this, which makes your sketches easier to follow, and once
// you have a handy function, you can reuse it in your other
// programs.


// showSpectrum()

// This function steps through all the colors of the RGB LED.
// It does this by stepping a variable from 0 to 768 (the total
// number of colors), and repeatedly calling showRGB() to display
// the individual colors.

// In this function, we're using a "for() loop" to step a variable
// from one value to another, and perform a set of instructions
// for each step. For() loops are a very handy way to get numbers
// to count up or down.

// Every for() loop has three statements separated by semicolons:

//   1. Something to do before starting

//   2. A test to perform; as long as it's true,
//      it will keep looping

//   3. Something to do after each loop (usually
//      increase a variable)

// For the for() loop below, these are the three statements:

//   1. x = 0;     Before starting, make x = 0.

//   2. x < 768;   While x is less than 768, run the
//                 following code.

//   3. x++        Putting "++" after a variable means
//                 "add one to it". (You can also use "x = x + 1")

// Every time you go through the loop, the statements following
// the loop (those within the brackets) will run.

// And when the test in statement 2 is finally false, the sketch
// will continue.


void showSpectrum()
{
int x;  // define an integer variable called "x"

// Now we'll use a for() loop to make x count from 0 to 767
// (Note that there's no semicolon after this line!
// That's because the for() loop will repeat the next
// "statement", which in this case is everything within
// the following brackets {} )

for (x = 0; x < 768; x++)

// Each time we loop (with a new value of x), do the following:

{
showRGB(x);  // Call RGBspectrum() with our new x
delay(DISPLAY_TIME);   // Delay for 10 ms (1/100th of a second)
}
}


// showRGB()

// This function translates a number between 0 and 767 into a
// specific color on the RGB LED. If you have this number count
// through the whole range (0 to 767), the LED will smoothly
// change color through the entire spectrum.

// The "base" numbers are:
// 0   = pure red
// 255 = pure green
// 511 = pure blue
// 767 = pure red (again)

// Numbers between the above colors will create blends. For
// example, 640 is midway between 512 (pure blue) and 767
// (pure red). It will give you a 50/50 mix of blue and red,
// resulting in purple.

// If you count up from 0 to 767 and pass that number to this
// function, the LED will smoothly fade between all the colors.
// (Because it starts and ends on pure red, you can start over
// at 0 without any break in the spectrum).


void showRGB(int color)
{
int redIntensity;
int greenIntensity;
int blueIntensity;

// Here we'll use an "if / else" statement to determine which
// of the three (R,G,B) zones x falls into. Each of these zones
// spans 255 because analogWrite() wants a number from 0 to 255.

// In each of these zones, we'll calculate the brightness
// for each of the red, green, and blue LEDs within the RGB LED.

if (color <= 255)          // zone 1
{
redIntensity = 255 - color;    // red goes from on to off
greenIntensity = color;        // green goes from off to on
blueIntensity = 0;             // blue is always off
}
else if (color <= 511)     // zone 2
{
redIntensity = 0;                     // red is always off
greenIntensity = 255 - (color - 256); // green on to off
blueIntensity = (color - 256);        // blue off to on
}
else // color >= 512       // zone 3
{
redIntensity = (color - 512);         // red off to on
greenIntensity = 0;                   // green is always off
blueIntensity = 255 - (color - 512);  // blue on to off
}

// Now that the brightness values have been set, command the LED
// to those values

analogWrite(RED_PIN, redIntensity);
analogWrite(BLUE_PIN, blueIntensity);
analogWrite(GREEN_PIN, greenIntensity);
}

quello che vorrei chiedervi è:

come mai non vedo nessun timer millis per lo svolgimento dei cicli

come mai i cicli "void" sono fuori sia dal void setup che dal void loop.

eppure il primo ciclo passa al secondo solo dopo che ha finito e anche il secondo passa al primo solo dopo che ha finito.

 

La mia ricerca di fare dei cicli temporizzati, era perchè non riesco a capire come passare da un ciclo all'altro solo dopo che ogni ciclo abbia finito di fare quello che c'è al suo interno.

Forse adesso ho spiegato come mai sono partito con il farvi certe domande all'inizio.

Grazie

[Livio Orsini]

 

come mai i cicli "void" sono fuori sia dal void setup che dal void loop.

eppure il primo ciclo passa al secondo solo dopo che ha finito e anche il secondo passa al primo solo dopo che ha finito.

 

 

 

Se tu cercassi di capire quello che ti si scrive ti saresti già risposto da solo.

 

Non essitono cicli "void" cazzo! Scusa la parolaccia ma quandi ci vuole ci vuole! Sei proprio di coccio, come dicono a Roma.

Esistono dell funzioni che non ritornano alcun dato; essendo funzioni devono essere esterne sia alla funzione di setup o inizializzazione, sia al programma principale (loop per arduino).

 

Hanno usato la funzione delay che, come ti ho scritto sin da subito, è bloccante; in altri termini quando il programma incontra la funzione delay(nn) si ferma ed attende che sia trascorso il tempo di ritardo impostato.

 

Perchè invece di andare per tentativi stile pene di molosso non ti stufi un po' uno dei tanti tutorial in italiano che si trovano in rete?

Lo segui passo, senza saltare nemmeno una parola, passando al passo successivo solo dopo aaver capito bene il passo che stai seguendo.

 

Cercare di fare le cose senza sapere quello che si fa si perde solo tempo, nella migliore delle ipotesi; nella peggiore si fanno anche danni.

 

[Livio Orsini]

 

ma ho preso le brutte abitudini dello stile "Arduino" ..

 

Ale guarda che non è sbagliato, anzi.

Pascal è nato come linguaggio didattico per forzare gli studenti a seguire le procedure corrette.

L'autore era (o è se è ancora vivente) un professore Svizzero di lingua tedesca, quindi il massimo della pedanteria.

Per essere sicuro che gli studenti seguissero un filo logico, il linguaggio obbliga a scrivere prima le funzioni e procedure ausiliarie, poi il main program.

 

Io che ho iniziato con il Fortran, invece, sono abituato a scrivere prima il main e poi le sub.

[kemosabe]

il problema che ti ho posto, è appunto per cercare di capire......

Le terminologie esatte non le conosco, quindi, vienimi incontro.

il problema posto sopra non riguarda il fatto di usare i " delay " oppure i " millis", quello è indifferente.

Quello che non capisco io, è cercare di capire come uscire da un void aggiuntivo ai due principali, solo dopo che ha svolto quello che c'è dentro, per poi passare al successivo, ma sempre dopo che ha svolto tutto quello che dentro.

 

P.S.....hai ragione ad incazzarti, e... si sono un po gnucco, non è da molto tempo che sto cercando di addentrarmi nel linguaggio di arduino, ma senza corsi o tutor, non è facile.

P.P.S.S.......lo so che non è una scusante, ma sono anche su di età, .....sai " L'ARTERIO"    😁

 

comunque grazie per tutto quello che potete per me .

[rodolfok]

 

Le terminologie esatte non le conosco, quindi, vienimi incontro.

il problema posto sopra non riguarda il fatto di usare i " delay " oppure i " millis", quello è indifferente.

Quello che non capisco io, è cercare di capire come uscire da un void aggiuntivo ai due principali, solo dopo che ha svolto quello che c'è dentro, per poi passare al successivo, ma sempre dopo che ha svolto tutto quello che dentro.

Scusa se intervengo, ma non ce l'ho fatta a trattenermi.
Livio ti è venuto incontro diverse volte sulla terminologia, spiegandoti che "void" non è un ciclo e nemmeno una funzione, ma è un "tipo" nel linguaggio di programmazione utilizzato. Per semplificarti la comprensione, per il caso specifico puoi far finta che "void" non esista nemmeno.
Quello che devi anche capire è che le funzioni (è questo il termine corretto) dalle quali tu vuoi uscire, non sono dei cicli (se leggi i commenti nel programma che riporti come esempio, c'è spiegato tutto).
Gli unici "cicli" in quel pezzo di codice sono la funzione loop(), intrinseca al modo di funzionare di Arduino, e il ciclo for() all'interno di una delle funzioni ("showSpectrum()"). Le due funzioni vengono eseguite ripetutamente e in sequenza all'interno di loop(), che gira finché non spegni Arduino, quindi hanno esattamente il comportamento che ti aspetti, cioè iniziano e terminano.
Altra cosa è inserire, all'interno di dette funzioni, del codice che ne impedisca la terminazione e che blocchi l'esecuzione all'interno di esse.
Anche delay() e millis() sono funzioni, ma hanno un comportamento molto diverso: delay() ad esempio non restituisce nulla, mentre millis() restituisce il numero di millisecondi trascorsi da quando Arduino ha iniziato a eseguire il codice (in pratica da quando lo accendi). Giusto per capirci, la funzione delay() è di tipo "void", mentre la funzione millis() è di tipo "unsigned long", cioè restituisce un valore che puoi usare nei calcoli.

Se una funzione esegue un ciclo o meno lo decidi tu in base al suo codice o al codice che la richiama.

ciao

rodolfo

[ilguargua]

 

Quello che non capisco io, è cercare di capire come uscire da un void aggiuntivo ai due principali, solo dopo che ha svolto quello che c'è dentro, per poi passare al successivo, ma sempre dopo che ha svolto tutto quello che dentro.

Dalle funzioni (quelle che ti ostini a chiamare void) si esce semplicemente quando si arriva alla fine (l'ultima parentesi graffa), e dopo che si è svolto tutto ciò che si trova dentro la funzione, o quando si incontra il comando "return".

Nel caso sia necessario, si può usare il comando "return" anche prima della fine della funzione, e in ogni caso il programma esce dalla funzione prosegue dal punto successivo al richiamo alla funzione stessa. Se la funzione non è di tipo "void" con return si deve ritornare un valore. Per farti capire, la dichiarazione di millis() è questa :

unsigned long millis(void);

il che ci dice che millis() è una funzione che non ha parametri (vedi il void tra le parentesi) e che ti restituisce un numero intero senza segno a 32 bit, che rappresenta i millisecondi trascorsi dall'avvio del programma. Questo è il codice di millis() :

unsigned long millis()
{
        unsigned long m;
        uint8_t oldSREG = SREG;

        // disable interrupts while we read timer0_millis or we might get an
        // inconsistent value (e.g. in the middle of a write to timer0_millis)
        cli();
        m = timer0_millis;
        SREG = oldSREG;

        return m;
}

nota il "return m;" alla fine, è quello che ti restituisce l'attuale valore di millis(). Se una funzione non ritorna nessun valore viene dichiarata "void", ed in quel caso si può omettere il "return".

Se provo a scrivere una funzione diversa da void senza usare "return" il compilatore lo accetta, ma ti avvisa con un "warning". Esempio, se aggiungo allo sketch che ho postato prima questa funzione :

int notUsefulFunc(){
    int a;
}

al momento della compilazione succede questo :

/home/guargua/sketchbook/leds_blink/leds_blink.ino: In function 'int notUsefulFunc()':
/home/guargua/sketchbook/leds_blink/leds_blink.ino:54:9: warning: unused variable 'a' [-Wunused-variable]
     int a;
         ^
/home/guargua/sketchbook/leds_blink/leds_blink.ino:55:1: warning: no return statement in function returning non-void [-Wreturn-type]
 }
 ^

Accertati di avere nelle impostazioni dell'IDE di Arduino la voce "Warning del compilatore" impostata come "tutti", non è rigorosamente necessario, ma è sempre bene sapere che c'è qualcosa nel codice che non torna.

 

Ciao, Ale.

 

Edit: Rodolfo mi ha anticipato, ma i concetti sono quelli...

Modificato: 18 dicembre 2019 da ilguargua
Aggiunta

[kemosabe]

Signori, io capisco che voi dopo tanto tempo dedicato agli studi di programmazioni vi vogliate soffermare su alcuni punti importanti quali sono i nomi di questo o di quello.

Quello che non capisco è l'insistenza nel fermarvi a guardare il dito invece che guardare la luna.

Ho capito che sbaglio le terminologia, credo che con il tempo a forza di leggerle le imparerò, ma vorrei capire meglio le cose che vi sto chiedendo per la programmazione.

Da parte vostra, credevo, forse sbagliando, ci fosse piu comprensione per quelli come me che non masticano come voi.

Credo che un approccio del tipo, guarda che quella cosa si chiama così, ma il suo funzionamento sarebbe questo, non sarebbe sbagliata.

Prendereste due piccioni con una fava, primo insegnate le corrette terminologie e nel frattempo date consigli o soluzioni ai vari problemi.

 

Comunque vi ringrazio, ma lascio perdere. Credevo potesse diventare un buon hobby per tenere impegnata la mente, ma vedo che è fuori dalla mia portata.

Chiedo scusa se vi ho fatto perdere tempo, ma per voi non dovrebbe esserlo, anzi, secondo me insegnare qualcosa che so è piacevole e divertente.

 

Grazie ancora a tutti.

[Darlington]

 

guarda che quella cosa si chiama così, ma il suo funzionamento sarebbe questo

 

mi sembra che Livio proprio questo abbia fatto... 

 

il discorso è che ogni mondo ha le sue terminologie, prima si imparano quelle, poi si può discutere alla pari con chi ci è già dentro, altrimenti è una gara a non capirsi, come pretendere di trasferirsi in Cina ma non sapere una parola di mandarino, senza dubbio faresti poca strada

 

pure la mia ragazza bacchetto sempre con le terminologie, per lei le luci di posizione erano "gli stop" ora sembra averla capita che si tratta di due luci differenti 

 

riguardo al tuo problema, io non so una cippa di C ma se dovessi farla in ladder una cosa del genere non inserirei le temporizzazioni all'interno dei blocchi, semmai creerei una funzione che conta i secondi e li memorizza in un registro incrementale, ovviamente da azzerare ogni tot, ed userei quel numero coi comparatori di valore per dire al programma "se il numero è compreso tra 1 e 10 fai questa cosa, se è compreso tra 10 e 20 fai quest'altra"

 

sono sicuro si possa fare anche in C, ma non ho idea come, prendilo come uno spunto

[Livio Orsini]

 

semmai creerei una funzione che conta i secondi e li memorizza in un registro incrementale

 

E quello che faccio solitamente. Uso il timer1 programmato a 10 ms e all'interno della routine di servizio dell'inturrupt metto dei contatori che mi servono per le temporizzazioni.

però per un programmino come questo che serve per far accendere e spegnere dei LEDs si può usare tranquillamente lafunzione delay() sesi fanno in sequenza. Se invece si vogliono fare in parallelo si può usare la funzione millis()che è simile al temporizzatore di cui sopra, ma che rende il tempo trascorso dall'ultimo reset (se ricordo bne).

 

 

......lo so che non è una scusante, ma sono anche su di età, .....sai " L'ARTERIO"    😁

 

Ma no, io oramai son più vicino agli 80 che ai 70, purtroppo. Non è l'età, ma e solo il metodo.

Tu sei partito forse a fare un qualche cosa più grande delle tue possibilità, se invece segui il metodo di uno dei tanti tutorials che trovi in rete, forse non farai in tempo a preparare il giochino di luci per questo natale, ma ne farai uno che funzionerà sicuramente bene per il Natale 2020

Cerca un tutorial, se vuoi chiedi e qualche links te lodiamo; seguilo con metodo e senza fretta, poi se hai necessità di chiarimenti siamo qui per darteli.

Ricorda l'età non conta, se non si tratta di esercizi fisici. Rispetto ad un ventenne impiego più tempo ad imparare qualche cosa di nuovo, di questo fatto ne sono dolorosamente consapevole, però basta avere metodo e non scoraggiarsi, che alla fine ci si riesce.

Certo non mi metto a studiare problemi di astrofisica, visto che son molto distanti dalla mia base culturale, però quasi ogni giorno affronto cose nuove, anche solo per il piacere di farle.

[kemosabe]

Allora, siccome sono un curioso dalla nascita, anche a me piace imparare ogni giorno qualcosa di nuovo. Di esempi, tutorial manuali ne ho letti un sacco, e per ognuno cerco di fare prove, quasi sempre a tentoni, pasticciando su ogni cosa per vedere cosa succede cambiando istruzioni, posizione ecc. ecc

il fatto è che leggendo vari libri, sempre da solo, ti spiegano solo alcune cose, quasi sempre solo le cose di base.

Vorrei farvi capire, che come funziona un delay o un millis, credo di averlo compreso.Le mie domande sono rivolte, per comprendere come funziona sto " contenitore " di nome void.

Perchè in molti esempi vedo che talvolta  quando ho molti contenitori esterni, senza nessun millis, ma solo dei delay, il programma gira in modo che fino a quando non si è svolto tutto quello che c'è nel contenitore esterno, non esce da li.

Per esempio, ho trovato molti esempi in cui il programma funziona solo se ci sono degli input esterni che lo fanno procedere in un modo o in un'altro.

Quello che vorrei fare io è di trasformarlo, facendo in modo che funzioni da solo.

allora cominciano le difficoltà.

Comunque grazie.  

[Darlington]

 

il programma gira in modo che fino a quando non si è svolto tutto quello che c'è nel contenitore esterno, non esce da li

 

Forse perché manca una istruzione che gli dice di uscire dal ciclo.

 

Ripeto, io il C non lo conosco, a malapena conosco il ladder e ho una infarinatura di basic, ma generalmente in ogni linguaggio di programmazione, in assenza di una condizione specifica per uscire dal blocco, se il blocco stesso è un loop il programma rimane nel loop.

 

In basic ad esempio si usa il GOTO o il RETURN per saltare ad una riga di programma fuori dal loop, il C è un linguaggio a oggetti quindi praticamente devi dirgli di passare ad un altro blocco.

[kemosabe]

Dunque, da quel che capisco, tutto quello che metto nel void loop(), dovrebbe ciclare continuamente.

void loop() {
  int i;
  for( i=0;i<strip.numPixels();i++){
    strip.setPixelColor(i, strip.Color(255,255,255)); // Moderately bright green color.
    strip.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
 
 if (i>=strip.numPixels()){i=0;}
  }
 
  
 strip.setPixelColor(i, strip.Color(0,0,0));
  strip.show();
 
}

come mai nonostante ci sia if che mette a zero i, fa solo un ciclo e poi si ferma?

Vediamo se facendo cosi capisco qualcosa

 

grazie

[ilguargua]

 

fa solo un ciclo e poi si ferma?

Da cosa lo deduci?

 

 

Ciao, Ale.

[kemosabe]

dalle prove. l'ho caricato su un Arduino Nano, e succede che dopo il primo ciclo si ferma.

[ilguargua]

No, non si ferma, ripete il ciclo for all'infinito, e siccome il ciclo fa sempre la stessa cosa a te sembra fermo. Togli quell'if con i=0 e vedrai che non si ferma.

 

Ciao, Ale.

[kemosabe]

no, fa il  primo ciclo e si ferma lo stesso, è per quello che avevo aggiunto l'IF

oltretutto, non passa nemmeno da qui

strip.setPixelColor(i, strip.Color(0,0,0));
  strip.show();

restano tutti accesi

Modificato: 19 dicembre 2019 da kemosabe

[GiRock]

Per forza, manca il delay, appena si spengono sei già nel ciclo for e si riaccendono subito...