WebSites    Projekte    CCD_ControllerCommandDispatcher

STM32F103-CommandDispatcher

Übersicht


  •  STM32F103CommandDispatcher unter der VSCode-Entwicklungsoberfläche
  •  Code für MicroController STM32F103C8T6 (BluePill)
  •  Analyse / Response und Ausführung von UART-ASCII-Commands
  •  Senden von System-Events zum PC-Client
  •  Minimale Version: nur Berücksichtigung von System- und Led-Commands

Download

  •  2212261851_Stm32CommandDispatcher_01V05.zip

Bestandteile


  •  main.cpp :
//
#include "Define.h"
#include "Helper.h"
#include "Pin.h"
#include "Led.h"
#include "SerialUart.h"
#include "Command.h"
#include "System.h"
//
extern Character BufferLine[];
//
CSerialUart UartA(PIN_SERIALA_RX, PIN_SERIALA_TX);
CSerialUart* PUartSystem;
CLed LedSystem(PIN_LEDSYSTEM, true);
CCommand Command;
CSystem System;


void Error(const char* text)
{
    sprintf(BufferLine, "!Error: %s!\r\n", text);
    UartA.Write(BufferLine);
}

void setup() 
{
    PUartSystem = &UartA;
    //
    LedSystem.Open(sldOff);
    UartA.Open(115200);
    delay(330);
    UartA.Write("\r\n");
    UartA.Write("**************************\r\n");
    UartA.Write("* Stm32CommandDispatcher *\r\n");
    UartA.Write("**************************\r\n");
    UartA.Write("* Version: 01V01         *\r\n");
    UartA.Write("* Date...: 221206        *\r\n");
    UartA.Write("* Time...: 1845          *\r\n");
    UartA.Write("* Author.: OMdevelop     *\r\n");
    UartA.Write("**************************\r\n");
    //
    OnSystemHelp();
    //
    System.Open(1000);
}

void loop() 
{
    if (UartA.Execute())
    {
        if (UartA.ReadLine(BufferLine))
        {
            if (Command.Analyse(BufferLine))
            {
                if (false == Command.Execute())
                {
                    Error("Invalid Command-Execution");
                }
            }
        }
    }
    System.Execute();
    LedSystem.Execute();    
}
//
  •  Command.cpp :
//
#include "Define.h"
#include "Helper.h"
#include "Pin.h"
#include "Led.h"
#include "SerialUart.h"
#include "Command.h"
//
extern Character BufferLine[];
extern CSerialUart UartA;
extern CLed LedSystem;
extern CCommand Command;
//
CCommand::CCommand(void)
{
    FCommand[0] = 0x00;
     FParameterCount = 0;
     FParameterA[0] = 0x00;
     FParameterB[0] = 0x00;
     FParameterC[0] = 0x00;
     FParameterD[0] = 0x00;
}
//
char* CCommand::GetCommand(void)
{
    return FCommand;
}
byte CCommand::GetParameterCount(void)
{
    return FParameterCount;
}
char* CCommand::GetParameterA(void)
{
    return FParameterA;
}
char* CCommand::GetParameterB(void)
{
    return FParameterB;
}
char* CCommand::GetParameterC(void)
{
    return FParameterC;
}
char* CCommand::GetParameterD(void)
{
    return FParameterD;
}
//
Boolean CCommand::Analyse(char* pline)
{
    const char* TOKEN_RXD = " \r\n\t";    
    char* Token;
    FCommand[0] = 0x00;
    FParameterCount = 0;
    FParameterA[0] = 0x00;
    FParameterB[0] = 0x00;
    FParameterC[0] = 0x00;
    FParameterD[0] = 0x00;
    Token = strtok(pline, TOKEN_RXD);
    if (NULL != Token)
    {
        strcpy(FCommand, Token);
        strupr(FCommand);
        FParameterCount = 0;
        Token = strtok(NULL, TOKEN_RXD);
        if (NULL != Token)
        {
            strcpy(FParameterA, Token);
            FParameterCount = 1;
            Token = strtok(NULL, TOKEN_RXD);
            if (NULL != Token)
            {
                strcpy(FParameterB, Token);
                FParameterCount = 2;
                Token = strtok(NULL, TOKEN_RXD);
                if (NULL != Token)
                {
                    strcpy(FParameterC, Token);
                    FParameterCount = 3;
                    Token = strtok(NULL, TOKEN_RXD);
                    if (NULL != Token)
                    {
                        strcpy(FParameterD, Token);
                        FParameterCount = 4;
                    }
                }
            }
        }
    }    
    return (0 < strlen(FCommand));
}
//--------------------------------
// System
//--------------------------------
Boolean CCommand::AnalyseSystemHelp(void)
{ // Parameter -
    return OnSystemHelp(true);
}
Boolean CCommand::AnalyseSystemAbort(void)
{ // Parameter -
    return OnSystemAbort();
}
Boolean CCommand::AnalyseSystemReset(void)
{ // Parameter -
    return OnSystemReset();
}
Boolean CCommand::AnalyseSystemRefreshInterval(void)
{ // Parameter -
    if (GetParameterCount() < 1)
        return false;    
    UInt32 TI = atol(GetParameterA());
    return OnSystemRefreshInterval(TI);
}
//--------------------------------
// LedSystem
//--------------------------------
Boolean CCommand::AnalyseLedSystemOn(void)
{ // Parameter -
    return OnLedSystemOn();
}
Boolean CCommand::AnalyseLedSystemOff(void)
{ // Parameter -
    return OnLedSystemOff();
}
Boolean CCommand::AnalyseLedSystemInvert(void)
{ // Parameter -
    return OnLedSystemInvert();
}
Boolean CCommand::AnalyseLedSystemBlink(void)
{ // ParameterA:count ParameterB:ontime[ms] ParameterC:offtime[ms]
    if (GetParameterCount() < 3)
        return false;    
    UInt32 BC = atol(GetParameterA());
    UInt32 TO = atol(GetParameterB());
    UInt32 TF = atol(GetParameterC());
    return OnLedSystemBlink(BC, TO, TF);
}
//
Boolean CCommand::Execute(void)
{ // []0..4
    //--------------------------------
    // System
    //--------------------------------
    if (0 == strcmp("H", FCommand))
    {
        return AnalyseSystemHelp();
    }
    if (0 == strcmp("A", FCommand))
    {
        return AnalyseSystemAbort();
    }
    if (0 == strcmp("R", FCommand))
    {
        return AnalyseSystemReset();
    }
    if (0 == strcmp("SRI", FCommand))
    {
        return AnalyseSystemRefreshInterval();
    }
    //--------------------------------
    // LedSystem
    //--------------------------------
    if (0 == strcmp("LSO", FCommand))
    {
        return AnalyseLedSystemOn();
    }
    if (0 == strcmp("LSF", FCommand))
    {        
        return AnalyseLedSystemOff();
    }
    if (0 == strcmp("LSI", FCommand))
    {        
        return AnalyseLedSystemInvert();
    }
    if (0 == strcmp("LSB", FCommand))
    {        
        return AnalyseLedSystemBlink();
    }
    return false;    
}
//
  •  CommandAnalysis.cpp :
//
#include "Define.h"
#include "Helper.h"
#include "Pin.h"
#include "Led.h"
#include "SerialUart.h"
#include "Command.h"
#include "System.h"
//
extern Character BufferLine[];
//
extern CSerialUart UartA;
extern CLed LedSystem;
extern CCommand Command;
extern CSystem System;
//
//--------------------------------
//  System
//--------------------------------
Boolean OnSystemHelp(bool response)
{   
    if (response)
    {
        Response("H");
    }        
    UartA.WriteLine("# Help : System");
    UartA.WriteLine("# H - This Help");
    UartA.WriteLine("# A - Abort");
    UartA.WriteLine("# R - Reset");
    UartA.WriteLine("# SRI  - System Refresh Interval ime[ms]");
    UartA.WriteLine("# Help : LedSystem");
    UartA.WriteLine("# LSO - SetOn");
    UartA.WriteLine("# LSF - SetOff");
    UartA.WriteLine("# LSI - Invert");
    UartA.WriteLine("# LSB    - Blink ount Timen[ms] TimeOf[ms]");
    return true;
}
Boolean OnSystemAbort(void)
{   
    Response("A");
    // abort all FSMs
    LedSystem.Abort();
    return true;
}
Boolean OnSystemReset(void)
{   
    Response("R");
    delay(1000);
    NVIC_SystemReset();
    return true;
}
Boolean OnSystemRefreshInterval(UInt32 time)
{   
    sprintf(BufferLine, "SRI %lu", time);
    Response(BufferLine);    
    System.SetRefreshInterval(time); 
    return true;
}
//--------------------------------
//  LedSystem
//--------------------------------
Boolean OnLedSystemOn(void)
{   
    LedSystem.Set(sldOn);       
    Response("LSO");
    return true;
}
Boolean OnLedSystemOff(void)
{
    LedSystem.Set(sldOff);
    Response("LSF");
    return true;
}
Boolean OnLedSystemInvert(void)
{
    LedSystem.Invert();
    Response("LSI");
    return true;
}
Boolean OnLedSystemBlink(UInt32 count, UInt32 timeon, UInt32 timeoff)
{
    sprintf(BufferLine, "LSB %i %i %i", count, timeon, timeoff);
    Response(BufferLine);    
    return LedSystem.Blink(count, timeon, timeoff);
}
  •  Led.cpp :
//
#include "Led.h"

//
#include "Define.h"
#include "Helper.h"
#include "SerialUart.h"
//
extern char LineBuffer[];
extern CSerialUart UartA;

CLed::CLed(int pin, bool inverted)
{
    FState = sldOff;
    FPin = pin;
    FInverted = inverted;
    FCount = 0;
    FTimeOn = 1;
    FTimeOff = 1;
    FTicksPreset = millis();
}
//
void CLed::Open(EStateLed state)
{
    pinMode(FPin, OUTPUT);
    Set(state);
}
//
void CLed::Abort(void)
{
    FCount = 0;
    FTimeOn = 1;
    FTimeOff = 1;
    Set(sldOff);
}
//
void CLed::Set(EStateLed state)
{
    FState = state;
    if (FInverted)
    {
        if (sldOn == FState)
        {
            digitalWrite(FPin, LOW);
            Event("LSO");
        }
        else
        {
            digitalWrite(FPin, HIGH);
            Event("LSF");
        }
    }
    else
    {
        if (sldOn == FState)
        {
            digitalWrite(FPin, HIGH);
            Event("LSO");
        }
        else
        {
            digitalWrite(FPin, LOW);
            Event("LSF");
        }
    }
}
//
EStateLed CLed::Get(void)
{    
    return FState;
}
//
EStateLed CLed::Invert(void)
{
    if (sldOff == Get())
    {
        Set(sldOn);
    }
    else
    {
        Set(sldOff);
    }
    return Get();
}
//
Boolean CLed::Blink(UInt32 count, UInt32 timeon, UInt32 timeoff)
{
    FCount = max((UInt32)1, count);
    FTimeOn = timeon;
    FTimeOff = timeoff;
    FTicksPreset = millis();
    Set(sldOn);
    return true;
}

void CLed::Execute(void)
{
    if (0 < FCount)
    {
        if ((sldOn == Get()) && (FTicksPreset + FTimeOn) <= millis())
        {
            Set(sldOff);
        } 
        else
        if ((sldOff == Get()) && (FTicksPreset + FTimeOn + FTimeOff) <= millis())
        {
            FTicksPreset = millis();
            FCount--;
            if (0 < FCount)
            {
                Set(sldOn);
            }
        }
    }
}
  •  SerialUart.cpp :
//
#include "SerialUart.h"
//
CSerialUart::CSerialUart(int pinrxd, int pintxd)
{
    FPinRxD = pinrxd;
    FPinTxD = pintxd;
    FPUart = new HardwareSerial(FPinRxD, FPinTxD);
    FRxCharacter = 0x00;
    FRxIndex = 0;
}

void CSerialUart::Open(int baudrate)
{
    FPUart->begin(baudrate);
    FRxIndex = 0;
}
//
void CSerialUart::WriteLine(void)
{
    FPUart->print("\r\n");
}
void CSerialUart::WriteLine(const char* value)
{
    FPUart->print(value);
    FPUart->print("\r\n");
}
void CSerialUart::Write(const char* value)
{
    sprintf(FTxBuffer, "%s", value);
    FPUart->print(FTxBuffer);
}
void CSerialUart::Write(char* value)
{
    sprintf(FTxBuffer, "%s", value);
    FPUart->print(FTxBuffer);
}
void CSerialUart::Write(Int8 value)
{
    sprintf(FTxBuffer, "%i", value);
    FPUart->print(FTxBuffer);
}
void CSerialUart::Write(UInt8 value)
{
    sprintf(FTxBuffer, "%u", value);
    FPUart->print(FTxBuffer);
}
void CSerialUart::Write(Int16 value)
{
    sprintf(FTxBuffer, "%i", value);
    FPUart->print(FTxBuffer);
}
void CSerialUart::Write(UInt16 value)
{
    sprintf(FTxBuffer, "%u", value);
    FPUart->print(FTxBuffer);
}
void CSerialUart::Write(Int32 value)
{
    sprintf(FTxBuffer, "%i", value);
    FPUart->print(FTxBuffer);
}
void CSerialUart::Write(UInt32 value)
{
    sprintf(FTxBuffer, "%u", value);
    FPUart->print(FTxBuffer);
}
void CSerialUart::Write(Float32 value)
{
    sprintf(FTxBuffer, "%.3f", value);
    FPUart->print(FTxBuffer);
}
void CSerialUart::Write(Double64 value)
{
    sprintf(FTxBuffer, "%.6f", value);
    FPUart->print(FTxBuffer);
}
//
Boolean CSerialUart::ReadCharacter(Character &character)
{
    character = FRxCharacter;
    FRxCharacter = 0x00;
    return true;
}
Boolean CSerialUart::ReadLine(PCharacter pcharacter)
{
    strcpy(pcharacter, FRxBuffer);
    FRxIndex = 0;
    FRxBuffer[FRxIndex] = 0x00;
    return (0 < strlen(pcharacter));
}
//
Boolean CSerialUart::Execute(void)
{
    if (FPUart->available())
    {
        FRxCharacter = FPUart->read();
        if ((TOKEN_CR == FRxCharacter) ||
            (TOKEN_LF == FRxCharacter))
        {
            FRxBuffer[FRxIndex] = 0x00;
            FRxIndex = 0;
            return (0 < strlen(FRxBuffer));
        }
        else
        {
            FRxBuffer[FRxIndex] = FRxCharacter;
            FRxIndex++;
            FRxBuffer[FRxIndex] = 0x00;
        }
    }
    return false;
}
  •  Helper.cpp :
//
#include "Define.h"
#include "Helper.h"
#include "SerialUart.h"
//
extern CSerialUart UartA;
//
char BufferLine[SIZE_BUFFERLINE];

void Response(const char* text)
{
    UartA.Write(":");
    UartA.Write(text);
    UartA.Write("\r\n");
}

void Event(const char* text)
{
    UartA.Write("!");
    UartA.Write(text);
    UartA.Write("\r\n");
}
  •  System.cpp :
//
#include "Define.h"
#include "Helper.h"
#include "Led.h"
#include "SerialUart.h"
#include "System.h"
//
extern Character BufferLine[];
extern CSerialUart* PUartSystem;
extern CLed LedSystem;
//
CSystem::CSystem(void)
{
    FRefreshInterval = INIT_REFRESHINTERVAL;
}
    
void CSystem::Open(UInt32 interval)
{
    FRefreshInterval = interval;
}    
//
void CSystem::SetRefreshInterval(UInt32 time)
{
    FRefreshInterval = time;
}
//
void CSystem::Execute(void)
{   
    if (FTicksPreset < millis()) 
    {
        FTicksPreset = millis() + FRefreshInterval;
        sprintf(BufferLine, "!SYS %lu %u", millis(), (int)LedSystem.Get());
        PUartSystem->WriteLine(BufferLine);
    }
}

Signalfluss

Modul main.cpp :
  •  Zentrales Programm mit setup() und loop()
  •  Globale Error()-Routine (Uart-Ausgabe)
  •  setup() : Ausgabe Program-Header, Ausgabe Help
  •  loop() : Analyse der eingehenden Uart-Daten und Ausführung der Commands

Module Command.cpp mit Class CCommand:
  •  Splitting Command/ParameterCount/ParamterA/B/C/D
  •  Analyse Commands SystemHelp/Abort/Reset/RefreshInterval
  •  Analyse Commands SystemLedOn/Off/Invert/Blink
  •  Execution aller eingehenden Commands (Execute())

Module CommandAnalysis.cpp :
  •  zu Command.cpp ergänzendes Modul mit Callback-OnExecute-Funktionen:
     OnSystemHelp() / OnSystemAbort() / OnSystemReset()
     OnSystemRefreshInterval(UInt32 time) / OnLedSystemOn() / OnLedSystemOff()
     OnLedSystemInvert() / OnLedSystemBlink(UInt32 count, UInt32 timeon, UInt32 timeoff)

Module Led.cpp mit Class CLed:
  •  Constructor mit Vorgabe von Pin und Invert-State
  •  Initialisierung mit Open()
  •  Get()- und Set()(On/Off)-Funktionen
  •  Blink(UInt32 count, UInt32 timeon, UInt32 timeoff)-Routine
  •  Main: Permanenter Aufruf der Execute-Funktion (für Blink)
  •  Abort() der Blink()-Funktion

Module SerialUart.cpp mit Class CSerialUart:
  •  Constructor mit Vorgabe von RxD- und TxD-Pin
  •  Initialisierung mit Open()
  •  Write()-Funktionen mit unterschiedlichen Aufruf-Parametern
  •  ReadCharacter()-Funktion mit Character-Rückgabe-Parameter
  •  ReadLine()-Funktion mit Line-Rückgabe-Parameter
  •  Main: Permanenter Aufruf der Execute-Funktion (Poll RxD)

Modul Helper.cpp :
  •  Uart-Ausgabe der Response()- und Event()-Routine

Module System.cpp mit Class CSystem:
  •  Class CSystem : Periodischer System-Refresh über Uart zum PC
  •  Class CSystem : Vorgabe der Refresh-Periode [ms]
WebSites    Projekte    CCD_ControllerCommandDispatcher
All rights reserved ©2022 - Open Hard- & Software - www.openhardsoftware.de