mbusgateway3variant/cube/User/Src/mbusComm.c

#include <main.h>
#include <usart.h>
#include <PontCoopScheduler.h>
#include <mbusComm.h>
#include <loopCtrl.h>
#include <led.h>
#include <logger.h>
#include <frontend.h>


typedef enum {
    IDLE,
    SEND,
    SEND_CONT,
    SENDING,
    ENABLE_FRONTEND,
    DISABLE_FRONTEND
} e_mbusCommState;

typedef struct {
    e_mbusCommState state;
    uint8_t retryCnt;
    uint8_t cmd;
    uint8_t addr;
    uint8_t sendBuf[5];
} t_mbusCommHandle;

static t_mbusCommHandle mbusCommHandle = { .state = IDLE, .retryCnt = 0, .cmd = 0, .addr = 0 };


static void handleRequestEngine(void *handle) {
    t_mbusCommHandle *localMbusCommHandle = (t_mbusCommHandle*) handle;

    switch (localMbusCommHandle->state) {
        case IDLE:
        logMsg("hre state IDLE");
        break;

        case SEND:
        logMsg("hre state SEND");
        localMbusCommHandle->sendBuf[0] = 0x10;
        localMbusCommHandle->sendBuf[1] = localMbusCommHandle->cmd;
        localMbusCommHandle->sendBuf[2] = localMbusCommHandle->addr;
        localMbusCommHandle->sendBuf[3] = localMbusCommHandle->cmd + localMbusCommHandle->addr; // checksum
        localMbusCommHandle->sendBuf[4] = 0x16;
        localMbusCommHandle->state = SEND_CONT;
        // no break !!

        case SEND_CONT:
        logMsg("hre state SEND_CONT");
        led(RED, OFF);
        if (! loopActive) {
            logMsg("hre enabling loop, try %d", localMbusCommHandle->retryCnt);
            localMbusCommHandle->retryCnt++;
            loopEnable();
            schAdd(handleRequestEngine, handle, 10, 0); // give 10ms to settled the loop
        } else {
            // write(fd, sendBuf, 5);
            localMbusCommHandle->retryCnt = 0;
            HAL_UART_Transmit_IT(&mbusUart, localMbusCommHandle->sendBuf, 5);
            localMbusCommHandle->state = SENDING;
            schAdd(handleRequestEngine, handle, 15, 0);  // ask me again in 15ms in the next state ...
        }
        break;

        case SENDING:
        logMsg("hre state SENDING");
        if (HAL_UART_GetState(&mbusUart) == HAL_UART_STATE_READY) { // ... whether I'm done
            localMbusCommHandle->state = ENABLE_FRONTEND;
            schAdd(handleRequestEngine, handle, 3, 0);
        } else {
            schAdd(handleRequestEngine, handle, 1, 0); // not yet done, ask me again in 1ms
        }
        break;

        case ENABLE_FRONTEND:
        logMsg("hre state ENABLE_FRONTEND");
        frontendEnable();
        localMbusCommHandle->state = DISABLE_FRONTEND;
        schAdd(handleRequestEngine, handle, 500, 0);
        break;

        case DISABLE_FRONTEND:
        logMsg("hre state DISABLE_FRONTEND");
        frontendDisable();
        localMbusCommHandle->state = IDLE;
        break;
        

        default:
        localMbusCommHandle->state = IDLE;
        break;
    }
}


void mbusCommRequest(uint8_t cmd, uint8_t addr) {
    if (mbusCommHandle.state == IDLE) {
        mbusCommHandle.state = SEND;
        mbusCommHandle.retryCnt = 0;
        mbusCommHandle.cmd = cmd;
        mbusCommHandle.addr = addr;
        schAdd(handleRequestEngine, (void*) &mbusCommHandle, 0, 0);
    } else {
        // busy
    }
}