ElectroYou

Ciao a tutti
sto iniziando a scrivere FW e mi trovo in difficoltà al momento in cui devo scrivere qualcosa in più di una semplice funzione.
Vorrei imparare a scrivere un FW (non bloccante) ed a gestire l'interazione fra le funzioni con macchine a stati (FSM),funzioni di transizioni di stato (STF), ecc.

Purtroppo non ho trovato risorse online per la scrittura a regola d'arte di un FW e chiedo a voi.
Come posso imparare? Solo leggendo e riflettendo sul codice scritto da altri, o ci sono delle linee guida da poter seguire?

Grazie

Lucast85 ha scritto:Vorrei imparare a scrivere un FW (non bloccante)

Ciao Lucast85, l'auspicio è sempre quello di scrivere del codice che non si "blocchi" o che non blocchi qualcosa d'altro a prescindere dalla "filosofia" adottata ...

La gestione Finite-Sate Machine ( ... o Macchina a Stati Finiti) non si caratterizza come tale tanto in base alla "interazione fra le funzioni"; è piuttosto un "modo" di strutturare e organizzare il software (a prescindere dal fatto che venga sviluppato su un microcontrollore piuttosto che su un PLC o utilizzando un PC come piattaforma).

Una forma semplice e intuitiva che penso possa essere di aiuto alla comprensione potrebbe essere una porzione di codice scritto ricorrendo allo statement "switch" in linguaggio "C" (prendo questo come base di confronto ignorando le tue conoscenze).
In rete qualche riferimento si trova, magari sono solo degli accenni ma se hai già un minimo di idea possono essere utili; prova a dare una occhiata qui e qui; sono solo un paio di richiami ma puoi cercare oltre.

Sicuramente, osservare e studiare il codice scritto da altri è un ottimo esercizio, ammesso che il codice sia di buon livello.
Questo è un modo per imparare; se poi tu avessi "sottomano" l'autore sarebbe ancora meglio perché ovviamente ti potresti rivolgere a lui per i chiarimenti del caso.

Intanto questo poi non è detto che passi di "qui" qualcuno in grado di fornirti precisazioni o ulteriori riferimenti, o rettificare quanto già scritto.

Saluti

WALTERmwp ha scritto:

Lucast85 ha scritto:Vorrei imparare a scrivere un FW (non bloccante)

Ciao Lucast85, l'auspicio è sempre quello di scrivere del codice che non si "blocchi" o che non blocchi qualcosa d'altro a prescindere dalla "filosofia" adottata ...

Mi sono espresso male, intendevo dire che non vorrei mantenere la CPU bloccata ad eseguire certi task mentre potrebbe tranquillamente fare altro: il classico esempio è quello del ritardo sw (ad es. con la funzione delay_ms()). La soluzione è quella di usare interrupt legati al timer, ma non l'ho mai fatto e mi piacerebbe saperne di più.

Intanto ti ringrazio per i due link. Mi sto esercitando con i consigli dati dall'autore del primo. Sono molto interessanti!
Cercherò di creare una FSM con il puntatore a funzione, come espresso nell'articolo, poi ve la farò vedere: magari può essere utile come "template" a qualcun altro.

Chiunque possa consigliarmi qualche buon libro o lettura, è ancora ben accetto.

Lucast85 ha scritto:Mi sono espresso male

... si, ma ora è chiaro.
E' una corretta "ambizione" quella di tendere all'ottimizzazione del codice, specialmente quando le risorse (e la potenza) sono relativamente limitate.

Ti suggerirei allora la lettura di articoli, qui su EY, come questo che per esempio può essere di aiuto per l'impostazione del software, poi quest'altro per quanto riguarda le(gli) "interrupt(s)".
Poi puoi "rovistare" nella raccolta di articoli per genere (Articoli -> Microcontrollori e PIC) e scoprire altre cose interessanti, valide anche sotto il profilo didattico.

Saluti

Sono riuscito a scrivere una prima versione di una macchina a stati finiti in C, utilizzando i puntatori a funzione, seguendo sia l'articolo già linkato da WALTERmwp che i consigli di un amico. Per ora l'ho fatto girare su PC con Eclipse/GCC. A breve proverò col micro e con qualche interrupt/timer che mi faccia avanzare automaticamente la macchina a stati finiti.

Dopo aver abbozzato una FSM di esempio e le relative funzioni di transizione:

• ho iniziato a scrivere codice definendo un nuovo tipo di dato basato se enumerato, contenente i nomi di tutti gli stati della FSM.

  Codice: Seleziona tutto

  /****************************************************************************************
* 1- Definition of a new (enum) type containing all different states of the FSM
****************************************************************************************/
typedef enum FSM_status_e
{
   STATE1=1   ,
   STATE2      ,
   STATE3      ,
   ERROR
}FSM_status_t;

• poi ho definito un nuovo tipo di dato FSM_STF_ptr_t che è il "famoso" puntatore a funzione.
  

  Codice: Seleziona tutto

  /****************************************************************************************
* 2- Declaration of a new type that describe the FSM-State Transition Functions pointer
****************************************************************************************/
typedef FSM_status_t (*FSM_STF_ptr_t)();   //function pointer that return an FSM_status_t and accept no input parameters

• in seguito dichiaro le tre funzioni di transizione di stato (STF) (le definirò in seguito)
  

  Codice: Seleziona tutto

  /****************************************************************************************
* 3- Declaration of three FSM State Transition Function
****************************************************************************************/
static FSM_status_t FSM_STF_f1(void);
static FSM_status_t FSM_STF_f2(void);
static FSM_status_t FSM_STF_f3(void);

• qui sotto dichiaro una variabile che conterrà lo stato attuale della FSM
  

  Codice: Seleziona tutto

  /****************************************************************************************
* 4- Declaration of a variable containing actual status
****************************************************************************************/
FSM_status_t actual_FSM_status;            //actual FSM status

• e definisco un array con gli indirizzi alle tre STF. Fate attenzione, occorre allineare le posizioni delle funzioni con i relativi stati della FSMdefiniti nell'enumerato! Ad es. la funzione FSM_STF_f3 che è la f. di transizione dallo stato 3, deve essere allineata con lo Stato 3 dell'enumerato: per fare in modo che siano allineati ho inserito un'offset all'array tramite l'indirizzo vuoto "NULL" alla riga "0".

  Codice: Seleziona tutto

  /****************************************************************************************
* 5- FSM State Transition Function list
****************************************************************************************/
static const FSM_STF_ptr_t FSM_STF[]=       // Address of pointed STFs according to FSM states order
{
      NULL      ,
      FSM_STF_f1   ,      //STF for STATE1
      FSM_STF_f2   ,      //STF for STATE2
      FSM_STF_f3   ,      //STF for STATE3
};


• Finalmente definisco le funzioni di transizione di stato che al termine dell'esecuzione ritorneranno lo stato della FSM di arrivo. Da notare che, per ogni STF, ci sono tanti "return" quante sono le frecce che partono da uno stato.

  Codice: Seleziona tutto

  static FSM_status_t FSM_STF_f3(void)
{
   printf("FSM_STF_f3 execution\n");
   fflush(stdout);
   uint8_t desired_FSM_state;
   printf("digit a number [1 or 2] to switch into FSM state 1 or 2, other key to exit\n");
   fflush(stdout);
   scanf("%d",(int*) &desired_FSM_state);
   switch (desired_FSM_state)
   {
      case 1:
         return STATE1;
         break;
      case 2:
         return STATE2;
         break;
      default:
         return ERROR;
   }
}

• In ultimo ho scritto il main che riporto per intero di seguito. La parte in cui avanza la macchina a stati finiti è quella in cui aggiorno lo stato attuale della FSM (stato di arrivo), invocando il puntatore a funzione con l'istruzione actual_FSM_status=(*FSM_STF[actual_FSM_status])() dove l'indice dell'array di puntatori a funzione è lo stato di partenza.
  

  Codice: Seleziona tutto

  /****************************************************************************************
*                            MAIN                                    *
****************************************************************************************/
int main()
{
   bool end_application=false;
   printf("FSM application started! Chose desired initial state [1...3]\n");   //user will chose the initial state
   fflush(stdout);
   scanf("%d",(int*) &actual_FSM_status);

   while(!end_application)
   {
      actual_FSM_status=(*FSM_STF[actual_FSM_status])();         //start STF according to actual FSM status and update the FSM status
      printf("actual_FSM_status is %d\n",actual_FSM_status);
      fflush(stdout);

      if(actual_FSM_status!=ERROR)                        //ask if user want to end application
      {
      printf("Type 1 to end application or 0 to continue...\n");
      fflush(stdout);
      scanf("%d",(int*) &end_application);
      }
      else end_application=true;                           //if FSM status == ERROR, end application
   }

   printf("application ended");
   fflush(stdout);
   return 0;
}

Provare per credere! Allego il codice compilato con MinGW/GCC ed il progetto per Eclipse CDT.
Che dite, fila il discorso...ehm..il sw ?

Bravo !
Apprezzabile anche l'ordine dell'esposizione.
Non ho guardato la sintassi nel dettaglio ma penso non ci siano errori se lo hai già provato.
Grazie per averlo condiviso e ... buona continuazione.

Saluti

Un libro che mi sembra molto ben fatto è Practical UML Statecharts in C/C++, 2nd Ed. di Miro Samek, fondatore di Quantum Leaps.

Tratta delle "buone pratiche" da applicare alle macchine a stati fino ad arrivare ad un completo framework.
Questo framework è il prodotto di punta della Quantum Leaps per sviluppare codice basato su macchine a stati, in alternativa a uno RTOS.
È open source. Si può usare gratis per progetti open source. Se invece non si vuole rilasciare il proprio codice sorgente, è disponibile una licenza a pagamento.

Segnalo anche la seconda parte di questo intervento su una variante dello schema "extended handlers" (per la gestione non bloccante degli eventi con event handlers, questi ultimi solitamente implementati come macchine a stati). È una discussione un po' vecchia, e alla fine l'articolo di cui parlavo lì non l'ho terminato.

Se ti interessano i microcontrollori ARM, vedi anche questo intervento e i seguenti. È di una discussione dove cercavamo un IDE gratuito per programmare i microcontrollori ARM Cortex. Alla fine abbiamo trovato che emIDE è il più consigliabile. Nel blog di TardoFreak (ma anche altri) trovi tanti ottimi articoli per mettere seriamente le "mani in pasta" coi microcontrollori.

Grazie per il materiale ed i consigli!
In effetti ho iniziato la programmazione/sperimentazione proprio con degli ARM; precisamente dei Cortex M0 della Nordic Semicoductor (nRF51822).
Dovrei sviluppare un'applicazione che, per la gestione dello stack Bluetooth Low Energy, utilizza delle librerie precompilate ( SoftDevice S110). Ho già sviluppato i driver e l'applicazione principale ma ora che ho dovuto metter le mani sul codice di esempio, che utilizza proprio tali librerie, son venuti fuori i primi dolori o, meglio, la mia scarsa esperienza in materia.
Ora, che "conosco" i puntatori a funzione, sembra tutto più chiaro...e speriamo che effettivamente lo sia.

Con tutto il materiale di riferimento a disposizione non rimane molto spazio per aggiungere qualcosa.
Limitando l'osservazione al codice che hai riportato potrebbe tornare utile considerare nella struttura dati anche lo stato di provenienza.
Trovarsi nella condizione di consultare questa informazione non so se è indice del fatto di non avere implementato nel migliore dei modi la FSM o più semplicemente è un modo per contrarre gli stati stessi.
Posso solo scrivere che mi è capitato di ricorrervi.

Saluti