looper - un semplice schedulatore senza timer/interrupt

Nuovo looper 1.0!

Fantastico, che devo dire di pi√Ļ? :stuck_out_tongue_closed_eyes:
Ecco un piccolo riassunto delle novità:

  1. ridotto il codice compilato rispetto al vecchio looper2 (usando struct e ripulendo il codice)
  2. mantenuta la sintassi dei metodi del looper2 (quindi addJob, removeJob ecc…) per poter usare il looper abbinato al leOS
  3. nuovo metodo myDelay! Adesso è possibile introdurre nel codice principale un’attesa mentre lo scheduler continua a lanciare i job in sospeso!! Allegato alla libreria c’è un esempio che mostra proprio questa possibilità: un job fa lampeggiare un led ogni 100 ms mentre nel loop principale un altro led viene fatto lampeggiare con un intervallo di 1000 ms gestito proprio con myDelay. Come si può vedere, il led che lampeggia con il minor tempo di intervallo non risente del delay di 1000 ms, mentre i precedenti looper e looper2 soffrivano di questo problema.

@leo72 +1

e complimenti! Pighixxx

Grazie pighi. Tornando ai punti, il 3 √® quello pi√Ļ interessante. L'esempio che ho inserito exnovo √® questo:

//include the scheduler
#include "looper.h"

looper myScheduler; //create a new istance of the class looper

//variabiles to control the LEDs
byte led1Status = 0;
byte led2Status = 0;
const byte LED1 = 7;
const byte LED2 = 8;

//program setup
void setup() {
    pinMode(LED1, OUTPUT);
    pinMode(LED2, OUTPUT);
    
    //add the tasks at the scheduler
    myScheduler.addJob(flashLed1, 100);
}


//main loop
void loop() {
    digitalWrite(LED2, led2Status);
    led2Status ^= 1;    
    myScheduler.myDelay(1000);
    myScheduler.scheduler();
}


//first task
void flashLed1() {
    led1Status^=1;
    digitalWrite(LED1, led1Status);
}

Ciò che mi preme evidenziare è :

myScheduler.myDelay(1000);

Questa istruzione mette il looper in un ciclo in cui per 1000 milisecondi altro non fa che controllare lo scheduler per lanciare i job eventualmente da eseguire. Il job flashLed1 deve essere eseguito ogni 100 ms, e così viene fatto, nonostante il loop si fermi per 1000 ms. Ciò si evidenzia dal fatto che il secondo led lampeggia proprio con la frequenza di 1 secondo.

instancabile leo! posso chiederti come funziona il myDelay? in realtà è una sotto-dalay di 1ms che poi cha il ckeck, oppure fai un delay+delayMisslis fino al primo job schedulato, esegui, e così via fino a fine delay?

lesto: instancabile leo! posso chiederti come funziona il myDelay? in realtà è una sotto-dalay di 1ms che poi cha il ckeck, oppure fai un delay+delayMisslis fino al primo job schedulato, esegui, e così via fino a fine delay?

E' una scemenza immane :sweat_smile:

void looper::myDelay(unsigned long myPause) {
unsigned long _tMillis = millis();
  while (millis() - _tMillis < myPause) {
    scheduler();
  }
}

In pratica è un while basato su millis() che dura per il tempo passato come argomento e dentro a cui chiamo ripetutamente lo scheduler ;)

ahahaha, ah ragione astro, sono proprio un UCAS :grin:

Tengo a precisare che la scemenza immane non era quello che avevi detto tu ma la soluzione che avevo adottato io ;) ;)

bhe alla luce dei fatti la mia √® una scemenza.. √® valida per ambienti multithread, dove sprecare CPU vuol dire rubare risorse ad altri processi/thread, ma sull'arduino la tua soluzione √® pi√Ļ che ottima :grin:

leo ma a questo punto possiamo dire di avere inventato il ‚Äúmio‚ÄĚ Delay2.0 ?

cioe’ posso usare in autonomia myDelay, sostituendolo ai delay normali di arduino, senza creare nessun AddJob ?

cioe’ questo funziona e non e’ bloccante ?

BLINK 2.0 
(idea Testato - creazione Leo :-) )

void loop() {
  digitalWrite(13, HIGH);  
  myScheduler.myDelay(1000);
  myScheduler.scheduler();
  digitalWrite(13, LOW);    
  myScheduler.myDelay(1000);
  myScheduler.scheduler();
}

funziona e puoi eliminare le due righe myScheduler.scheduler();

Testato: leo ma a questo punto possiamo dire di avere inventato il "mio" Delay2.0 ?

Guarda che l'ho chiamato myDelay, e non testatoDelay :P

cioe' posso usare in autonomia myDelay, sostituendolo ai delay normali di arduino, senza creare nessun AddJob ?

Lo puoi fare ma a questo punto è inutile la lib.

cioe' questo funziona e non e' bloccante ?

BLINK 2.0 
(idea Testato - creazione Leo :-) )

void loop() {  digitalWrite(13, HIGH);    myScheduler.myDelay(1000);  myScheduler.scheduler();  digitalWrite(13, LOW);      myScheduler.myDelay(1000);  myScheduler.scheduler(); }

Funziona ma non va bene ed il myDelay è bloccante per il codice così come il delay. Non è bloccante per i job inseriti nello scheduler. Ma se non usi nessun job nello scheduler, a che ti serve myDelay?

Ti spiego perché il tuo codice non va bene. Questo andrebbe bene:

BLINK 2.0 
(idea Testato - creazione Leo :-) )

void loop() {
  digitalWrite(13, HIGH);  
  myScheduler.myDelay(1000);
  digitalWrite(13, LOW);    
  myScheduler.myDelay(1000);
}

Non so se hai visto il codice di myDelay che ho postato un paio di messaggi sopra per capire come funziona ma in pratica si tratta di un ciclo while che chiama costantemente lo scheduler finché non sono trascorsi i ms passati come parametro. Se il myDelay è l'ultima istruzione del loop, puoi evitare di chiamare lo scheduler perché l'ultima cosa fatta da myDelay è appunto l'invocazione di esso.

Ma a questo punto il codice qui sopra non va bene lo stesso perché nello scheduler non c'è nulla. Che lo fai a fare uno sketch del genere? :P Il codice giusto per avere un Blink non bloccante è invertire le cose e mettere il codice del lampeggio in un job e lasciare tutto il resto nel loop. Ad esempio, questo fa il blink mentre ad intervalli di 1 secondo stampa un valore sulla seriale:

#include "looper.h"
looper myScheduler;

byte led1Status = 0;
const byte LED1 = 13;
int counter = 0;

void setup() {
    pinMode(LED1, OUTPUT);
    Serial.begin(19200);
    myScheduler.addJob(flashLed1, 100);
}

void loop() {
    Serial.println(++counter);
    myScheduler.myDelay(1000);
}

void flashLed1() {
    led1Status^=1;
    digitalWrite(LED1, led1Status);
}

Questo è un esempio concreto del delay 2.0, che non ferma l'esecuzione dei job in background ma funziona invece come delay classico per il codice principale.

Se nemmeno lesto ha capito che mydelay è bloccante figurati se lo capivo io.

Ma quindi il delay2.0, mio e basta come diritti di autore, intedo come semplive comando da mettere nel loop, non si può tecnicamente fare ? O è difficile farlo ?

Il myDelay ha un senso se ragioni in termini di RTOS o pseudotali. Gli RTOS sono basati su un multitasking di tipo senza prelazione o cooperativo (cooperativo) o con prelazione (preemptive). Questi ultimi sono quelli che dopo un certo periodo di tempo congelano lo stato di un task indipendentemente dalla volontà di quest'ultimo di essere bloccato. Quelli di tipo cooperativo passano il controllo al SO in modo volontario. In questo modo lo scheduler può passare il controllo della CPU ad un altro task. Sull'Arduino DUE è stato implementato una specie di RTOS cooperativo in cui il codice della delay è stato rivisto ed ora fa un po' ciò che fa myDelay. Durante l'esecuzione del delay la CPU non è bloccata in un ciclo inutile ma salta da un task all'altro.

myDelay cerca di fare il verso a questo comportamento, con tutti i limiti di uno scheduler non gestito da interrupt né capace di salvare lo stato della CPU e dei suoi registri per congelare un task. Semplicemente fintanto che bisogna stare fermi ad aspettare viene comunque eseguito lo scheduler.

Rammentiamoci che delay è un'istruzione valida ed utile in alcuni casi. Se metto un delay significa che voglio bloccare il codice per un certo lasso di tempo. Magari, però, potrei voler bloccare solo una determinata parte di codice. I job, appunto, potrei volerli continuare ad eseguire. Quindi myDelay fa proprio questo: ferma il codice nel punto in cui è stata messa ma permette di continuare a fare altro.

Può risultare utile. Pensa ad esempio all'attesa dell'inizializzazione di qualcosa. Pensa ad esempio, per riallacciarsi al problema della Ethernet shield, al delay(300) che c'è in Ethernet.begin. Se ci metto myDelay(300) la libreria Etherner attende che il W5100 abbia fatto la sua inizializzazione ma nel contempo posso continuare ad eseguire altri compiti.

Testato: Se nemmeno lesto ha capito che mydelay è bloccante figurati se lo capivo io.

:~ ho datol'impressione di non averlo capito?

la myDelay è a tutti gli effetti una delay() che però al contrario della vera delay permette a looper di funzionare. detta terra terra :D

Nota mi √® pi√Ļ chiaro, grazie,
Vediamo se ho capito tentando di trovare l anello che manca. Io un idea c’è l ho, e magari davvero chiudiamo la questione.

  • il delay ufficiale blocca tutto e va bene cosi
  • il myDelay ( a questo punto tuo) √® una via di mezzo, utile anch‚Äôesso
  • il testatoDelay deve semplicemente nascondere ci√≤ che facciamo con millis dietro ad una funzione, quindi il classico calcolo di millis a cui passiamo il valore che vogliamo

testatoDelay(1000);

Testato: - il testatoDelay deve semplicemente nascondere ciò che facciamo con millis dietro ad una funzione, quindi il classico calcolo di millis a cui passiamo il valore che vogliamo

E' ciò che fa myDelay. Sembra che sia tutto bloccato ma in realtà mentre è "ferma" può eseguire altre cose.

io voglio anche ammettere che non mi spieghi bene, ma voi ci mettete di vostro :P

volete sapere meglio di un principiante di cosa ha bisogno un principiante ? non e' il vostro campo, fatevi da parte :)

allora a noi esseri infimi che non capiamo nulla, ne' abbiamo voglia di capire nulla, serve questo

BLINK 2.0 
(idea Testato - creazione (se ha voglia e mi riesco a spiegare) Leo :-) )

void loop() 
{
  digitalWrite(13, HIGH);  
  testatoDelay(1000);
  digitalWrite(13, LOW);    
  testatoDelay(1000);
  nel_frattempo_che_lampeggi_fai_infinite_cose();
}

in questo momento: - se usi delay standard essendo bloccante blocchi le infinite cose per 2 secondi - se crei un job dove mettere le infinite cose il gioco funge, ma come vedi tu stesso il programma diventa piu' grande e ostico. - se invece vieni incontro al popolo che aspetta e pende dalle tue dita, creando il testatoDelay, avrai fatto la cosa piu' importante ed utile per la community, superiore alla stessa swRTC che ormai il mondo intero ci invidia :)

Testato: ``` BLINK 2.0 (idea Testato - creazione (se ha voglia e mi riesco a spiegare) Leo :-) )

void loop() {  digitalWrite(13, HIGH);    testatoDelay(1000);  digitalWrite(13, LOW);      testatoDelay(1000);  nel_frattempo_che_lampeggi_fai_infinite_cose(); }

Questo codice non va bene :P Ti dimentichi che la CPU del microcontrollore esegue il codice in maniera sequenziale, ossia una istruzione dietro l'altra. Tu stai cercando un delay che non sia bloccante ma in realtà vuoi un delay che dica al compilatore: ecco, hai trovato la newDelay? Bene, ignorala e passa oltre.

Ora però ti spiego cosa succede col tuo codice: 1) loop 2) metti su HIGH il led 13 3) testatoDelay? allora salta avanti 4) metti su LOW il led 13 5) altra testatoDelay? salta avanti 6) ho del codice da eseguire, bene lo eseguo 7) torno a 1)

Ecco cosa farebbe testatoDelay ;) In realtà tu vorresti qualcosa tipo un blocco di codice da mettere nella tua testatoDelay da eseguirlo solo dopo l'intervallo desiderato. Come lo vuoi te non si può fare, va fatto in un'altra maniera, ad esempio così:

testatoDelay(1000, digitalWrite(13, HIGH));  
testatoDelay(1000, digitalWrite(13, LOW));    
codice_da_eseguire

Ma così dovrei prendere il puntatore alla funzione e passarlo poi ad uno scheduler che lo infilerebbe nell'elenco dei lavori da eseguire, poi ogni volta dovrei passarglielo come parametro e tutte le volte dovrebbe controllare che funzione è, se è da eseguire o se è da saltare. Ma allora non è meglio la myDelay attuale? E poi statureresti la delay intesa come funzione che ferma il codice. Può esserci un'occasione in cui la delay serve, con la tua delay la si salta a piè pari.

Ma il delay standard perche dovrebbe essere toccato ? Quello resta, e se mi serve lo uso. Cosa facciamo ora con millis ? If questo - quello = x allora fai questaltro Else vai avanti. Se pi√Ļ avanti mi serve delay standard lo uso. Non vedere la mia idea come sostituto del delay, ma come nuovo tipo di delay. Io dico solo di nascondere sotto una nuova funzione di looper questo delay nuovo fatto con if e millis

Mi spiace, io non riesco a capire questo tuo delay. Non riesco a capire proprio cos'è che vuoi fare. Io ho inteso che quel che vuoi fare tu è ciò che ti ho spiegato nel precedente post. Tu però mi dici che ti serve un delay diverso. E che non riesco a focalizzare. :~