Satic vector, new epprom routines, new wireless relay storage method

WirelessRelay.cpp

@@ -1,5 +1,6 @@
 #include"WirelessRelay.h"
 #include <avr/io.h>
+#include "eeprom.h"
 
 volatile unsigned char *_port = &PORTB;
 unsigned char _pin = PB5;

WirelessRelay.h

@@ -9,18 +9,25 @@
 
 class WirelessRelay
 {
+public:
+    
+    static const MAX_NAME_LENGTH = 32;
+    
+    char name[MAX_NAME_LENGTH];
+    
 private:
      bool _state = false;
+     uint16_t _nameAddr;
      uint16_t _id;
      void sendBit( const bool i);
      void sync();
      void sendId();
      
 public:
-    WirelessRelay(const uint16_t id);
+    WirelessRelay(const uint16_t id, uint16_t nameAddr, char* nameIn = "");
     WirelessRelay();
     void setTimeout(uint64_t timeout);
-    void init(const uint16_t id);
+    void init(const uint16_t id, uint16_t nameAddr, char* nameIn = "");
     void on(); 
     void off();
     uint16_t getId();

eeprom.h

@@ -1,40 +1,51 @@
 void EEPROM_write_char(uint16_t address, unsigned char data)
 {
-    /* Wait for completion of previous write */
+    //Wait for completion of previous write
     while(EECR & (1<<EEPE));
-    /* Set up address and Data Registers */
+    //Set up address and Data Registers
     EEAR = address;
     EEDR = data;
-    /* Write logical one to EEMPE */
+    //Write logical one to EEMPE
     EECR |= (1<<EEMPE);
-    /* Start eeprom write by setting EEPE */
+    //Start eeprom write by setting EEPE
     EECR |= (1<<EEPE);
 }
 
 unsigned char EEPROM_read_char(uint16_t uiAddress)
 {
-    /* Wait for completion of previous write */
+    // Wait for completion of previous write
     while(EECR & (1<<EEPE));
-    /* Set up address register */
+    //Set up address register
     EEAR = uiAddress;
-    /* Start eeprom read by writing EERE */
+    //Start eeprom read by writing EERE
     EECR |= (1<<EERE);
-    /* Return data from Data Register */
+    //Return data from Data Register
     return EEDR;
 }
 
 void EEPROM_write_string(uint16_t address, char* buffer, uint16_t length)
 {
-    for(uint16_t i = 0; i < length; i++)
-    {
-        EEPROM_write_char( address+i, buffer[i] );
-    }
+    for(uint16_t i = 0; i < length; i++) EEPROM_write_char( address+i, buffer[i] );
 }
 
 void EEPROM_read_string(uint16_t address, char* buffer, uint16_t length)
 {
-    for(uint16_t i = 0; i < length; i++)
+    for(uint16_t i = 0; i < length; i++) buffer[i] = EEPROM_read_char( address+i);
+}
+
+template <class T> void EEPROM_write_class(uint16_t address, const T& in)
 {
-        buffer[i] = EEPROM_read_char( address+i);
+    EEPROM_write_string( address, reinterpret_cast<char*> &in, sizeof(in));
 }
+
+template <class T> T EEPROM_read_class(uint16_t address)
+{
+    char data[sizeof(T)];
+    EEPROM_read_string( address, data, sizeof(T) );
+    return *reinterpret_cast<T*>(data);
+}
+
+template <class T> T EEPROM_read_class(uint16_t address, T* in)
+{
+    EEPROM_read_string( address, reinterpret_cast<char*> &in, sizeof(T) );
 }

main.cpp

@@ -10,18 +10,30 @@
 #include "eeprom.h"
 #include "bitrep.h"
 
-#define MAX_RELAYS 32
 #define COMMAND_BUFFER_SIZE 32
 #define SNPRINTF_BUFFER_SIZE 64
 
 char buffer[SNPRINTF_BUFFER_SIZE];
 
-struct WirelessRelayStore
+class WirelessRelayStore
 {
+public: 
+    static const MAX_RELAYS = 16;
+    
+private:
+    
     WirelessRelay array[MAX_RELAYS];
+    uint8_t count;
     bool states[MAX_RELAYS]={};
     bool printState = true;
-    uint8_t count;
+    uint16_t baseNameAddr_;
+    
+public:
+    
+    WirelessRelayStore(uint16_t baseNameAddr = 0)
+    bool add( uint16_t id, char* name );
+    bool remove();
+    WirelessRelay* getRelay(uint8_t id);
 };
 
 WirelessRelayStore relays;
@@ -357,7 +369,7 @@ int main()
 
     restore_relays(&relays);
     
-    serial.write_p(PSTR("RGBController v0.6 starting\n"));
+    serial.write_p(PSTR("RGBController v0.7 starting\n"));
     while(true)
     {
         serialDispatch(&serial, &relays, &rgbled, &pwmTc1);

staticvector.h

@@ -0,0 +1,75 @@
+#pragma once
+
+template<typename T, std::size_t size> class SVector;
+{
+private:
+    size_t stored = 0;
+    
+    T array[size];
+    
+public:
+    
+    constexpr T* data()
+    {
+        return array;
+    }
+    
+    T operator[](size_t i)
+    {
+        return array[i];
+    }
+    
+    T at(size_t i)
+    {
+        return array[i];
+    }
+    
+    T front()
+    {
+        return array[0];
+    }
+    
+    T back()
+    {
+        return array[stored];
+    }
+    
+    bool empty()
+    {
+        return stored == 0 ? true : false;
+    }
+    
+    size_t size();
+    {
+        return stored;
+    }
+    
+    constexpr size_t maxSize()
+    {
+        return std::array::size();
+    }
+    
+    size_t remainingCapacity()
+    {
+        return std::array::size() - stored;
+    }
+    
+    bool push_back(const T in)
+    {
+        if( remainingCapacity() != 0)
+        {
+            std::array::operator[](stored) =  in;
+            return true;
+        }
+        else return false;
+    }
+    
+    bool erase(size_t position)
+    {
+       if(position > stored) return false;
+       if constexpr( std::is_class<T> ) array[position].~T();
+       --stored;
+       for( size_t i = position; i < stored ) array[i] = array[i+1];
+       return true;
+    }
+}