cs_MicroappController.h

Go to the documentation of this file.

#pragma once
 
#include <ble/cs_BleConstants.h>
#include <cs_MicroappStructs.h>
#include <events/cs_EventListener.h>
#include <ipc/cs_IpcRamData.h>
#include <protocol/cs_Packets.h>
#include <protocol/cs_Typedefs.h>
#include <protocol/mesh/cs_MeshModelPackets.h>
#include <services/cs_MicroappService.h>
 
extern "C" {
#include <util/cs_DoubleStackCoroutine.h>
}
 
static_assert(sizeof(bluenet2microapp_ipcdata_t) <= BLUENET_IPC_RAM_DATA_ITEM_SIZE);
 
// Do some asserts on the redefinitions in the shared header files
// These asserts cannot be done where declared since the shared files do not depend on the rest of bluenet
static_assert(MAC_ADDRESS_LENGTH == MAC_ADDRESS_LEN);
static_assert(MAX_BLE_ADV_DATA_LENGTH == ADVERTISEMENT_DATA_MAX_SIZE);
static_assert(MAX_MICROAPP_MESH_PAYLOAD_SIZE == MAX_MESH_MSG_PAYLOAD_SIZE);
 
static_assert(CS_MICROAPP_SDK_SWITCH_OFF == CS_SWITCH_CMD_VAL_OFF);
static_assert(CS_MICROAPP_SDK_SWITCH_ON == CS_SWITCH_CMD_VAL_FULLY_ON);
static_assert(CS_MICROAPP_SDK_SWITCH_TOGGLE == CS_SWITCH_CMD_VAL_TOGGLE);
static_assert(CS_MICROAPP_SDK_SWITCH_BEHAVIOUR == CS_SWITCH_CMD_VAL_BEHAVIOUR);
static_assert(CS_MICROAPP_SDK_SWITCH_SMART_ON == CS_SWITCH_CMD_VAL_SMART_ON);
 
struct microapp_coroutine_args_t {
    uintptr_t entry;
    bluenet_io_buffers_t* ioBuffers;
};
 
struct microapp_soft_interrupt_registration_t {
    MicroappSdkType type = CS_MICROAPP_SDK_TYPE_NONE;
    uint8_t id           = 0;
    int8_t counter       = 0;
};
 
enum class MicroappOperatingState {
    CS_MICROAPP_NOT_RUNNING,
    CS_MICROAPP_RUNNING,
};
 
struct microapp_data_t {
    bool isScanning  = false;
 
    Service* service = nullptr;
};
 
class MicroappController {
private:
    MicroappController();
    MicroappController(MicroappController const&);
    void operator=(MicroappController const&);
 
    static const int8_t MICROAPP_MAX_SOFT_INTERRUPTS_WITHIN_A_TICK          = 3;
 
    static const uint8_t MICROAPP_MAX_NUMBER_CONSECUTIVE_CALLS              = 3;
 
    static const uint8_t MICROAPP_MAX_SOFT_INTERRUPT_REGISTRATIONS          = 10;
 
    static const uint8_t MICROAPP_MAX_BLUENET_EVENT_INTERRUPT_REGISTRATIONS = 10;
 
    static const uint32_t MICROAPP_MAX_CALL_DURATION_MS                     = 20;
 
    microapp_soft_interrupt_registration_t _softInterruptRegistrations[MICROAPP_MAX_SOFT_INTERRUPT_REGISTRATIONS];
 
    CS_TYPE _eventInterruptRegistrations[MICROAPP_MAX_BLUENET_EVENT_INTERRUPT_REGISTRATIONS];
 
    microapp_sdk_ble_scan_filter_t _scanFilter = {.type = CS_MICROAPP_SDK_BLE_SCAN_FILTER_NONE, .rssi = 0};
 
    uint8_t _tickCounter                       = 0;
 
    uint8_t _consecutiveMicroappCallCounter    = 0;
 
    uint8_t _emptySoftInterruptSlots           = 1;
 
    void setOperatingState(uint8_t appIndex, MicroappOperatingState state);
 
protected:
    void callMicroapp();
 
    bool handleAck();
 
    bool handleRequest();
 
    bool stopAfterMicroappRequest(microapp_sdk_header_t* header);
 
    cs_ret_code_t checkFlashBoundaries(uint8_t appIndex, uintptr_t address);
 
public:
    static MicroappController& getInstance() {
        static MicroappController instance;
        return instance;
    }
 
    void setIpcRam();
 
    uint16_t initMemory(uint8_t appIndex);
 
    void startMicroapp(uint8_t appIndex);
 
    void tickMicroapp(uint8_t appIndex);
 
    uint8_t* getInputMicroappBuffer();
 
    uint8_t* getOutputMicroappBuffer();
 
    cs_ret_code_t registerSoftInterrupt(MicroappSdkType type, uint8_t id);
 
    microapp_soft_interrupt_registration_t* getRegisteredInterrupt(MicroappSdkType type, uint8_t id);
 
    bool allowSoftInterrupts(MicroappSdkType type, uint8_t id);
 
    bool isCpuBusy();
 
    cs_ret_code_t registerBluenetEventInterrupt(CS_TYPE eventType);
 
    bool isEventInterruptRegistered(CS_TYPE type);
 
    cs_ret_code_t setScanFilter(microapp_sdk_ble_scan_filter_t& filter);
 
    microapp_sdk_ble_scan_filter_t& getScanFilter();
 
    void setEmptySoftInterruptSlots(uint8_t emptySlots);
 
    void incrementEmptySoftInterruptSlots();
 
    void generateSoftInterrupt(MicroappSdkType type, uint8_t id);
 
    MicroappOperatingState getOperatingState(uint8_t appIndex);
 
    void clear(uint8_t appIndex);
 
    microapp_data_t microappData;
};