Alguém portou a estrutura de estado QP para o Arduino?

Ao revisar possíveis abordagens para o meu projeto de registro de dados, achei o livro "Estatística UML prática em C / C ++" muito interessante para trabalhos mais sérios com o Arduino. O QP é uma família de estruturas ultraleves, de código aberto e baseadas em máquinas para sistemas embarcados, e elas distribuem código e portas para suas estruturas (GNU GPL2) em http://www.state-machine.com/, onde possuem um porta para o AVR e AVR mega usando o conjunto de ferramentas WinAVR / Gnu C ++.

Embora os cabeçalhos específicos do chip sejam apropriados, alguém criou um arquivo BSP da placa ou teve alguma experiência com essas estruturas? Estou apenas começando com o livro, então qualquer comentário muito apreciado.

Eu evitaria esse tipo de coisa como a praga.

A maioria dos softwares de baixo nível "sérios" que encontrei foi uma máquina de estado neste formato:

#include <stdio.h>

typedef enum
{
    STATE_INIT,     // Description
    STATE_RUNNING,  // Description
    STATE_COMPLETE  // Description
} state_t;

int main(void)
{
    state_t state = STATE_INIT; // setup the initial state

    while(1)
    {
        os_run(); // call the OS services (poll the UART, check buttons, etc.)

        switch(state)
        {
            case STATE_INIT:
                state = STATE_RUNNING;
                puts("init");
                break;
            case STATE_RUNNING:
                state = STATE_COMPLETE;
                puts("running");
                break;
            case STATE_COMPLETE:
                puts("complete");
                break;
        }
    }
    return 0;
}

Existem muitas outras boas abordagens no C / C ++, mas elas não são as minhas favoritas.

O grande problema com ferramentas como QP é que geralmente é muito difícil fazer coisas que elas não querem que você faça. Se você optar por mexer no código manualmente, precisará manter o caso especial para sempre.

Eu diria que os gráficos de estados UML são uma ferramenta fantástica para documentação, ensino e análise. Mas, não para a programação real - existem ferramentas muito melhores para isso :)

Pessoalmente, não usei a estrutura / biblioteca QP, devido à licença GPL. Naquela época, eu não achava que meu empregador estivesse pronto para pagar a quantia necessária para eu experimentar as máquinas de estado hierárquicas do HSM usando QP. Eu tive que implementar o meu próprio, semelhante ao QP, quando refatorava uma máquina de estado horrível que ocupava centenas de linhas de código como o exemplo de Joby, mas multiplicava-se por mil. Era uma dor terrível de se manter. Eu temia tentar adicionar algo novo a ele por medo de quebrar algo mais.

Redesenhei o código em um HSM que fazia muito mais sentido para mim, pessoalmente, sobre como o sistema deveria se comportar. Funcionou muito melhor do que eu poderia imaginar. Era muito mais fácil modificar e manter do que eu jamais poderia sonhar. Eu até tive que refazer grande parte da máquina de estado, devido a um comportamento inesperado no sistema. Foi muito mais fácil consertar a estrutura que eu havia criado e tenho certeza de que teria sido tão fácil no QP. A estrutura que construí tornou-se popular e se espalhou para outras máquinas de estado complexas dentro de nossa base de código.

Um amigo implementou a estrutura quântica usando Java em um robô que funcionou muito bem. Fazia parte do algoritmo de tomada de decisão do robô com base em determinadas entradas. Era um ajuste natural, dadas as decisões que ele precisava tomar com base no estado do robô.

O que eu entendo da beleza do QP é a capacidade de ter uma estrutura pronta para um projeto de máquina de estado que seja otimizado para o seu processador e não precise confiar nas ferramentas CASE que emitem código ineficiente. Porém, eu usaria o QP apenas se você tiver um conjunto complexo de máquinas de estado para implementar que descreva seu design.

Se tudo o que você tem é algo tão simples quanto o exemplo de Joby, faça como ele explicou. Mas se você encontrar sua máquina de estado crescendo e crescendo com todos os tipos de instruções "if else" envolvidas em diferentes condições ... talvez seja hora de tentar algo como QP para dividi-lo em HSMs.

Expandindo o exemplo de Joby, uma maneira mais limpa de implementar uma máquina de estado muito grande é substituir a instrução case por uma matriz de ponteiros de função. Em seguida, você pode isolar todo o código de um estado específico dentro de uma função. Eu descobri que implementá-lo dessa maneira requer muito menos memória do programa.

substitua a instrução case por uma matriz de ponteiros de função

É assim que o material QP funciona. A representação de um estado é apenas um ponteiro de função (para a função do estado atual). Em C ++, poderia ser um ponteiro para a função de membro, mas basicamente o mesmo. A função de estado atual é chamada com eventos, bem como com alguns pseudo-eventos (entrada, saída), um dos quais é sempre não tratado e é usado para determinar o aninhamento de estado ao fazer transições aninhadas (o QP suporta máquinas de estado hierárquicas).

Miro Samek diz que em breve fará uma porta direcionada ao Arduino.