Conteggio che torna indietro dopo determinata soglia

[dimaios]

Un metodo alternativo è quello di utilizzare la ricorsione.
Non avendo a disposizione Arduino l'ho scritto in C++ ma l'implementazione non cambia molto ; basta variare la funzione di stampa e sostituire la funzione del delay.

Codice: Seleziona tutto

#include "stdafx.h"
#include <iostream>
#include <chrono>
#include <thread>

const int MAX_VALUE = 31 ;
const int MIN_VALUE = 0 ;



void PrintResult( int n )
{
   std::cout << n << std::endl ;
   std::this_thread::sleep_for( std::chrono::milliseconds( 100 ) ) ;
}

void DoStep( int n )
{
   if ( n < MAX_VALUE ) {
      PrintResult( n ) ;
      DoStep( n + 1 ) ;
   }
   
   if ( n > 0 ) {
      PrintResult( n ) ;
   }

   return ;
}

int main( )
{

   while ( 1 )
   {
      DoStep( 0 ) ;
   }

    return 0 ;
}

[IlGuru]

La soluzione è molto bella, ma probabilmente non è utilizzabile con i microntrollori.
Ogni chiamata ricorsiva utilizza dello spazio nella pila di sistema che spesso è molto limitata specialmente su mcu ad 8 bit. Magari succede che non viene nemmeno segnalato il rollover dello stack pointer, e dopo l ottava chiamata ricorsiva inizia a scrivere gli indirizzi di ritorno dalla prima posizione e ti giochi la possibilità di tornare nel main. Ma che ne sanno gli arduinisti di queste cose

[dimaios]

In effetti era solo per proporre qualcosa di alternativo.
Comunque quando mi capita tra le mani un Arduino provo a far girare il codice, siccome l'occupazione dello stack non è esagerata potrebbe anche funzionare.
Vi farò sapere.

[IlGuru]

Ho controllato sul datasheet, con l'MCU atmel328P di arduino dovrebbe funzionare.
Il suo stack pointer è formato da 11 bit spalmati su due registri ad 8 bit SPH ed SPL, la memoria dello stack è tutta la SRAM interna quindi anche se fossero 32 PUSH sulla stack di spazio ce n'è a sufficienza.
Cosa diversa sarebbe farlo fare ad un PIC628a dove la stack è limitato ad 8 livelli. Ho già provato a trovarmi a debuggare del codice che apparentemente andava in loop solo perché l'ultima RET non poteva più tornare nel main ma nel mezzo di una funzione che era stata chiamata 8 livelli di CALL prima
Del resto il datasheet lo diceva pure:
The stack operates as a circular buffer. This means that after the stack has been PUSHed eight times, the ninth PUSH overwrites the value that was stored from the first PUSH. The tenth PUSH overwrites the second PUSH (and so on).