Custom device

CustomDevices/_template/MFCustomDevice.cpp

@@ -0,0 +1,230 @@
+#include "MFCustomDevice.h"
+#include "commandmessenger.h"
+#include "allocateMem.h"
+#include "MyCustomClass.h"
+#include "MFEEPROM.h"
+extern MFEEPROM MFeeprom;
+
+/* **********************************************************************************
+    The custom device pins, type and configuration is stored in the EEPROM
+    While loading the config the adresses in the EEPROM are transferred to the constructor
+    Within the constructor you have to copy the EEPROM content to a buffer
+    and evaluate him. The buffer is used for all 3 types (pins, type configuration),
+    so do it step by step.
+    The max size of the buffer is defined here. It must be the size of the
+    expected max length of these strings.
+
+    E.g. 6 pins are required, each pin could have two characters (two digits),
+    each pins are delimited by "|" and the string is NULL terminated.
+    -> (6 * 2) + 5 + 1 = 18 bytes is the maximum.
+    The custom type is "MyCustomClass", which means 14 characters plus NULL = 15
+    The configuration is "myConfig", which means 8 characters plus NULL = 9
+    The maximum characters to be expected is 18, so MEMLEN_STRING_BUFFER has to be at least 18
+********************************************************************************** */
+#define MEMLEN_STRING_BUFFER 40
+
+// reads a string from EEPROM at given address which is '.' terminated and saves it to the buffer
+bool MFCustomDevice::getStringFromEEPROM(uint16_t addreeprom, char *buffer)
+{
+    char    temp    = 0;
+    uint8_t counter = 0;
+    do {
+        temp              = MFeeprom.read_byte((addreeprom)++); // read the first character
+        buffer[counter++] = temp;                               // save character and locate next buffer position
+        if (counter >= MEMLEN_STRING_BUFFER) {                  // nameBuffer will be exceeded
+            return false;                                       // abort copying to buffer
+        }
+    } while (temp != '.');      // reads until limiter '.' and locates the next free buffer position
+    buffer[counter - 1] = 0x00; // replace '.' by NULL, terminates the string
+    return true;
+}
+
+/* **********************************************************************************
+    Within the connector pins, a device name and a config string can be defined
+    These informations are stored in the EEPROM like for the other devices.
+    While reading the config from the EEPROM this function is called.
+    It is the first function which will be called for the custom device.
+    If it fits into the memory buffer, the constructor for the customer device
+    will be called
+********************************************************************************** */
+
+MFCustomDevice::MFCustomDevice(uint16_t adrPin, uint16_t adrType, uint16_t adrConfig)
+{
+    _initialized = true;
+    /* **********************************************************************************
+        Do something which is required to setup your custom device
+    ********************************************************************************** */
+
+    char   *params, *p = NULL;
+    char    parameter[MEMLEN_STRING_BUFFER];
+    uint8_t _pin1, _pin2, _pin3;
+
+    /* **********************************************************************************
+        read the Type from the EEPROM, copy it into a buffer and evaluate it
+        it's only required if your custom device handles multiple devices with
+        different contructors
+        the string get's NOT stored as this would need a lot of RAM, instead a variable
+        is used to store the type
+    ********************************************************************************** */
+    getStringFromEEPROM(adrType, parameter);
+    if (strcmp(parameter, MY_CUSTOM_TYPE_1) == 0)
+        _customType = MY_CUSTOM_DEVICE_1;
+    if (strcmp(parameter, MY_CUSTOM_TYPE_2) == 0)
+        _customType = MY_CUSTOM_DEVICE_2;
+
+    /* **********************************************************************************
+        Next call the constructor of your custom device
+        adapt it to the needs of your constructor
+        if you have multiple classes, check for _customType which constructor
+        has to be called (e.g. if (_customType == MY_CUSTOM_DEVICE_1) ....)
+    ********************************************************************************** */
+    if (_customType == 1) {
+        if (!FitInMemory(sizeof(MyCustomClass))) {
+            // Error Message to Connector
+            cmdMessenger.sendCmd(kStatus, F("Custom Device does not fit in Memory"));
+            return;
+        }
+        /* **********************************************************************************************
+            read the pins from the EEPROM, copy them into a buffer
+        ********************************************************************************************** */
+        getStringFromEEPROM(adrPin, parameter);
+        /* **********************************************************************************************
+            split the pins up into single pins. As the number of pins could be different between
+            multiple devices, it is done here.
+        ********************************************************************************************** */
+        params = strtok_r(parameter, "|", &p);
+        _pin1  = atoi(params);
+        params = strtok_r(NULL, "|", &p);
+        _pin2  = atoi(params);
+        params = strtok_r(NULL, "|", &p);
+        _pin3  = atoi(params);
+
+        /* **********************************************************************************
+            read the configuration from the EEPROM, copy it into a buffer.
+        ********************************************************************************** */
+        getStringFromEEPROM(adrConfig, parameter);
+        /* **********************************************************************************
+            split the config up into single parameter. As the number of parameters could be
+            different between multiple devices, it is done here.
+            This is just an example how to process the init string. Do NOT use
+            "," or ";" as delimiter for multiple parameters but e.g. "|"
+            For most customer devices it is not required.
+            In this case just delete the following
+        ********************************************************************************** */
+        uint16_t Parameter1;
+        char    *Parameter2;
+        params     = strtok_r(parameter, "|", &p);
+        Parameter1 = atoi(params);
+        params     = strtok_r(NULL, "|", &p);
+        Parameter2 = params;
+
+        // In most cases you need only one of the following functions
+        // depending on if the constuctor takes the variables or a separate function is required
+        _mydevice = new (allocateMemory(sizeof(MyCustomClass))) MyCustomClass(_pin1, _pin2);
+        _mydevice->attach(Parameter1, Parameter2);
+        // if your custom device does not need a separate begin() function, delete the following
+        // or this function could be called from the custom constructor or attach() function
+        _mydevice->begin();
+    } else if (_customType == 2) {
+        if (!FitInMemory(sizeof(MyCustomClass))) {
+            // Error Message to Connector
+            cmdMessenger.sendCmd(kStatus, F("Custom Device does not fit in Memory"));
+            return;
+        }
+        /* **********************************************************************************************
+            read the pins from the EEPROM, copy them into a buffer
+        ********************************************************************************************** */
+        getStringFromEEPROM(adrPin, parameter);
+        /* **********************************************************************************************
+            split the pins up into single pins, as the number of pins could be different between
+            multiple devices, it is done here
+        ********************************************************************************************** */
+        params = strtok_r(parameter, "|", &p);
+        _pin1  = atoi(params);
+        params = strtok_r(NULL, "|", &p);
+        _pin2  = atoi(params);
+        params = strtok_r(NULL, "|", &p);
+        _pin3  = atoi(params);
+
+        /* **********************************************************************************
+            read the configuration from the EEPROM, copy it into a buffer.
+        ********************************************************************************** */
+        getStringFromEEPROM(adrConfig, parameter);
+        /* **********************************************************************************
+            split the config up into single parameter. As the number of parameters could be
+            different between multiple devices, it is done here.
+            This is just an example how to process the init string. Do NOT use
+            "," or ";" as delimiter for multiple parameters but e.g. "|"
+            For most customer devices it is not required.
+            In this case just delete the following
+        ********************************************************************************** */
+        uint16_t Parameter1;
+        char    *Parameter2;
+        params     = strtok_r(parameter, "|", &p);
+        Parameter1 = atoi(params);
+        params     = strtok_r(NULL, "|", &p);
+        Parameter2 = params;
+
+        // In most cases you need only one of the following functions
+        // depending on if the constuctor takes the variables or a separate function is required
+        _mydevice = new (allocateMemory(sizeof(MyCustomClass))) MyCustomClass(_pin1, _pin2);
+        _mydevice->attach(Parameter1, Parameter2);
+        // if your custom device does not need a separate begin() function, delete the following
+        // or this function could be called from the custom constructor or attach() function
+        _mydevice->begin();
+    }
+    /* ******************************************************************************* */
+}
+
+/* **********************************************************************************
+    The custom devives gets unregistered if a new config gets uploaded.
+    Keep it as it is, mostly nothing must be changed.
+    It gets called from CustomerDevice::Clear()
+********************************************************************************** */
+void MFCustomDevice::detach()
+{
+    _initialized = false;
+    if (_customType == 1) {
+        _mydevice->detach();
+    } else if (_customType == 2) {
+        _mydevice->detach();
+    }
+}
+
+/* **********************************************************************************
+    Within in loop() the update() function is called regularly
+    Within the loop() you can define a time delay where this function gets called
+    or as fast as possible. See comments in loop().
+    It is only needed if you have to update your custom device without getting
+    new values from the connector.
+    Otherwise just make a return; in the calling function.
+    It gets called from CustomerDevice::update()
+********************************************************************************** */
+void MFCustomDevice::update()
+{
+    if (!_initialized) return;
+    /* **********************************************************************************
+        Do something if required
+    ********************************************************************************** */
+    if (_customType == 1) {
+        _mydevice->update();
+    } else if (_customType == 2) {
+        _mydevice->update();
+    }
+}
+
+/* **********************************************************************************
+    If an output for the custom device is defined in the connector,
+    this function gets called when a new value is available.
+    It gets called from CustomerDevice::OnSet()
+********************************************************************************** */
+void MFCustomDevice::set(int8_t messageID, char *setPoint)
+{
+    if (!_initialized) return;
+
+    if (_customType == 1) {
+        _mydevice->set(messageID, setPoint);
+    } else if (_customType == 2) {
+        _mydevice->set(messageID, setPoint);
+    }
+}

CustomDevices/_template/MFCustomDevice.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <Arduino.h>
+#include "MyCustomClass.h"
+
+// only required if you have more than one custom device
+enum {
+    MY_CUSTOM_DEVICE_1 = 1,
+    MY_CUSTOM_DEVICE_2
+};
+class MFCustomDevice
+{
+public:
+    MFCustomDevice(uint16_t adrPin, uint16_t adrType, uint16_t adrConfig);
+    void detach();
+    void update();
+    void set(int8_t messageID, char *setPoint);
+
+private:
+    bool           getStringFromEEPROM(uint16_t addreeprom, char *buffer);
+    bool           _initialized = false;
+    MyCustomClass *_mydevice;
+    uint8_t        _pin1, _pin2, _pin3;
+    uint8_t        _customType = 0;
+};

CustomDevices/_template/MyCustomClass.cpp

@@ -0,0 +1,71 @@
+#include "MyCustomClass.h"
+
+/* **********************************************************************************
+    This is just the basic code to set up your custom device.
+    Change/add your code as needed.
+    If you have no class and/or only less code you could also put it
+    into MFCustomDevice.cpp and delete this file and MyCustomClass.h
+********************************************************************************** */
+
+MyCustomClass::MyCustomClass(uint8_t Pin1, uint8_t Pin2)
+{
+    _pin1 = Pin1;
+    _pin2 = Pin2;
+}
+
+void MyCustomClass::begin()
+{
+}
+
+void MyCustomClass::attach(uint16_t Pin3, char *init)
+{
+    _pin3 = Pin3;
+}
+
+void MyCustomClass::detach()
+{
+    if (!_initialised)
+        return;
+    _initialised = false;
+}
+
+void MyCustomClass::set(int8_t messageID, char *setPoint)
+{
+    /* **********************************************************************************
+        Each messageID has it's own value
+        check for the messageID and define what to do.
+        Important Remark!
+        MessageID == -1 will be send from the connector when Mobiflight is closed
+        Put in your code to shut down your custom device (e.g. clear a display)
+        MessageID == -2 will be send from the connector when PowerSavingMode is entered
+        Put in your code to enter this mode (e.g. clear a display)
+
+    ********************************************************************************** */
+    int32_t  data = atoi(setPoint);
+    uint16_t output;
+
+    // do something according your messageID
+    switch (messageID) {
+    case -1:
+        // tbd., get's called when Mobiflight shuts down
+    case -2:
+        // tbd., get's called when PowerSavingMode is entered
+    case 0:
+        output = (uint16_t)data;
+        data   = output;
+        break;
+    case 1:
+        /* code */
+        break;
+    case 2:
+        /* code */
+        break;
+    default:
+        break;
+    }
+}
+
+void MyCustomClass::update()
+{
+    // Do something which is required regulary
+}

CustomDevices/_template/MyCustomClass.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "Arduino.h"
+
+/* **********************************************************************************
+    These defines are required to differ between multiple classes within
+    MFCustomDevice.cpp (see example in this file)
+    If you have only one class, these defines are not required as you have
+    not to differ.
+********************************************************************************** */
+#define MY_CUSTOM_TYPE_1 "MyCustomType1"
+// This define should be in the second class, it's only here to show how to handle it
+#define MY_CUSTOM_TYPE_2 "MyCustomType2"
+class MyCustomClass
+{
+public:
+    MyCustomClass(uint8_t Pin1, uint8_t Pin2);
+    void begin();
+    void attach(uint16_t Pin3, char *init);
+    void detach();
+    void set(int8_t messageID, char *setPoint);
+    void update();
+
+private:
+    bool    _initialised;
+    uint8_t _pin1, _pin2, _pin3;
+};