Communication protocol

lib/utils/type_utils.h

@@ -0,0 +1,5 @@
+template<class T>
+T* getSingleton() {
+    static T obj;
+    return &obj;
+}

platformio.ini

@@ -13,6 +13,15 @@ lib_deps =
 	arduino-libraries/Servo@^1.1.8
 	adafruit/DHT sensor library@^1.4.4
 	https://github.com/lexus2k/tinyproto#v1.0.0
+	adafruit/Adafruit Unified Sensor@^1.1.13
+	adafruit/Adafruit BMP3XX Library@^2.1.2
+	adafruit/Adafruit BNO055@^1.6.1
+
+[env:uno_mini]
+platform = atmelavr
+board = ATmega328P
+framework = arduino
+monitor_speed = 9600
 
 [env:uno]
 platform = atmelavr

src/AComponents/container.cpp

@@ -0,0 +1,40 @@
+#include "container.h"
+
+#include "Parts/AParts/interface.h"
+
+Container::Container() {
+    for (int i = 0; i < Parts + Sensors; ++i)
+        array[i] = nullptr;
+}
+
+void Container::registerPart(Interface *part) {
+    for (int i = 0; i < Parts; ++i) {
+        if (!array[i])  {
+            array[i] = part;
+            return;
+        }
+    }
+}
+
+void Container::registerSensor(Interface *sensor) {
+    for (int i = Parts; i < Parts + Sensors; ++i) {
+        if (!array[i]) {
+            array[i] = sensor;
+            return;
+        }
+    }
+}
+
+Interface *Container::find(char partID) const {
+    for (int i = 0; i < Parts + Sensors; ++i)
+        if (array[i]->getCode() == partID)
+            return array[i];
+
+    return nullptr;
+}
+
+void Container::read_data() {
+    for (int i = Parts; i < Parts + Sensors; ++i)
+        if (array[i])
+            array[i]->fun(0x00);
+}

src/AComponents/container.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#define Parts 3
+#define Sensors 2
+
+class Interface;
+
+class Container {
+public:
+  Container();
+
+  void registerPart(Interface* part);
+  void registerSensor(Interface* sensor);
+  Interface* find(char partID) const;
+  void read_data();
+
+private:
+  Interface* array[Parts + Sensors];
+};

src/AComponents/heap.h

@@ -0,0 +1,123 @@
+#pragma once
+
+
+template<class T>
+class Wrapper {
+public:
+    Wrapper() : nextCall(0), ptr(nullptr) {}
+
+    Wrapper(unsigned long time, T data)
+        : nextCall(time),
+          ptr(data) {}
+
+    T get_val() const {
+        return ptr;
+    }
+
+    bool operator< (const Wrapper& obj) const {
+        return  nextCall < obj.nextCall;
+    }
+
+    T show() const {
+        return ptr;
+    }
+
+    void remove() {
+        nextCall = 0;
+        ptr = nullptr;
+    }
+
+    void setTime(unsigned long nextUpdate) {
+        nextCall = nextUpdate;
+    }
+
+    unsigned long getTime() const {
+        return nextCall;
+    }
+
+    void setPtr(T newPtr) {
+        ptr = newPtr;
+    }
+
+private:
+    unsigned long nextCall;
+    T ptr;
+};
+
+
+class Interface;
+
+template<class T>
+class Heap {
+public:
+    Heap() : size(0) {}
+
+    void insert(unsigned long nextUpdate, Interface* data) {
+        arr[size].setTime(nextUpdate);
+        arr[size].setPtr(data);
+
+        _insert((size - 1) / 2, size);
+        ++size;
+    }
+
+    void pop() {
+        if(!size) return;
+
+        --size;
+        swap(0, size);
+        arr[size].remove();
+
+        _pop(0);
+    }
+
+    T top() const {
+        return arr[0];
+    }
+
+    int get_size() const {
+        return size;
+    }
+
+    bool empty() const {
+        return !size;
+    }
+private:
+    const int capacity = 5;
+    int size;
+    T arr[5];
+
+private:
+    void _insert(int s, int target) {
+        if(!target) return;
+        if (arr[target] < arr[s]) {
+            swap(target, s);
+
+            _insert((s - 1) / 2, s);
+        }
+    }
+
+    void _pop(uint8_t parent) {
+        uint8_t smallest = parent;
+        uint8_t l = 2 * parent + 1;
+        uint8_t r = 2 * parent + 2;
+
+        if(l < size && arr[l] < arr[smallest])
+            smallest = l;
+
+
+        if(r < size && arr[r] < arr[smallest])
+            smallest = r;
+
+        if(smallest != parent) {
+            swap(parent, smallest);
+
+            _pop(smallest);
+        }
+    }
+
+    void swap(uint8_t firstIndex, uint8_t secondIndex) {
+        T t = arr[firstIndex];
+        arr[firstIndex] = arr[secondIndex];
+        arr[secondIndex] = t;
+    }
+};

src/Messages/commandmessage.cpp

@@ -0,0 +1,37 @@
+#include "commandmessage.h"
+#include "errors.h"
+
+CommandMessage::CommandMessage() {
+    arr[0] = 0;
+    arr[1] = 0;
+    arr[2] = 0;
+
+    arr[0] |= 1 << 7;  // Set command direction flag: 1 -> arduino to flight computer
+}
+
+
+char CommandMessage::getPart() const {
+    unsigned char mask = 63; 
+
+    return arr[0] & mask;
+}
+
+char CommandMessage::getCommand() const {
+    unsigned char mask = 15; 
+    return (arr[2] >> 4) & mask;
+}
+
+int CommandMessage::getIndex() const {
+    return arr[0];
+}
+
+void CommandMessage::sendResponse(char result) {
+    arr[0] |= 1 << 6;
+    arr[2] |= result;
+
+    HdlcSerial::sendPacket(reinterpret_cast<char*>(arr), 3); 
+}
+
+void CommandMessage::send()  {
+    HdlcSerial::sendPacket(reinterpret_cast<char*>(arr), 3); 
+}

src/Messages/commandmessage.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "errors.h"
+#include "Serial/hdlc_serial.h"
+
+
+class CommandMessage{
+public:
+    CommandMessage();
+
+    char getPart()    const;
+    char getCommand() const;
+    int  getIndex()   const;
+    void sendResponse(char result);
+    void send();
+
+private:
+    char arr[6];
+};

src/Messages/sensormessage.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "Serial/hdlc_serial.h"
+
+template <unsigned int PayloadL>
+class SensorMessages
+{
+public:
+    SensorMessages(char partID, unsigned int type)
+        : i(0)
+    {
+        arr[0] = (partID & 127) << 1; // Cut off first bit (only 127 parts supported, as first bit is reserved for command type)
+        arr[0] |= ((PayloadL -1) & 0b00010000) >> 4; // Payload length is split between byte 0 and 1: most significant bit goes here
+        arr[1] = ((PayloadL -1) & 0b00001111) << 4; // rest here
+        arr[1] |= type & 0b00001111;
+    }
+
+    void reset(){
+        i = 0;
+    }
+
+    /// @brief Assigns the provide data to the message. WARNING: unsafe operation, be careful that the byte length match PayloadL defined beforehand
+    /// @param data Raw data pointer
+    /// @param length Length of the data to add
+    void addData(int* data)
+    {
+        memcpy(arr + 2 + i, data, sizeof(int));
+        i += sizeof(int);
+    }
+
+    /// @brief Assigns the provide data to the message. WARNING: unsafe operation, be careful that the byte length match PayloadL defined beforehand
+    /// @param data Raw data pointer
+    /// @param length Length of the data to add
+    void addData(bool* data)
+    {
+        memcpy(arr + 2 + i, data, sizeof(bool));
+        i += sizeof(bool);
+    }
+
+    /// @brief Assigns the provide data to the message. WARNING: unsafe operation, be careful that the byte length match PayloadL defined beforehand
+    /// @param data Raw data pointer
+    /// @param length Length of the data to add
+    void addData(float* data)
+    {
+        memcpy(arr + 2 + i, data, sizeof(float));
+        i += sizeof(float);
+    }
+
+    int getPart() const
+    {
+        unsigned char mask = 127;
+
+        return arr[0] & mask;
+    }
+
+    void sendMessage()
+    {
+        HdlcSerial::sendPacket(arr, PayloadL + 2); // 2 header bytes + data
+    }
+
+private:
+    unsigned char arr[PayloadL + 2];
+    char i;
+};