From ecd7ad677bb317afa9c0347722d166437cb9f16f Mon Sep 17 00:00:00 2001
From: IMback <philipp@uvos.net>
Date: Fri, 19 May 2017 09:48:19 +0200
Subject: [PATCH] command interpreter and epprom

---
 CMakeLists.txt    |   2 +-
 WirelessRelay.cpp |  20 +++-
 WirelessRelay.h   |   7 +-
 eeprom.h          |  42 +++++++++
 main.cpp          | 229 ++++++++++++++++++++++++++++++++++++++--------
 pwm.cpp           |  23 +++--
 pwm.h             |   5 +-
 serial.cpp        |   8 +-
 serial.h          |   4 +-
 9 files changed, 282 insertions(+), 58 deletions(-)
 create mode 100644 eeprom.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c3cd2f5..d5ce2c0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -37,7 +37,7 @@ add_definitions(-fno-exceptions -ffunction-sections -fdata-sections)
 # Linker flags
 set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "")   # remove -rdynamic for C
 set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "") # remove -rdynamic for CXX
-set(CMAKE_EXE_LINKER_FLAGS "-Os -Wl,--gc-sections -mmcu=${MCU}")
+set(CMAKE_EXE_LINKER_FLAGS "-s -Os -Wl,--gc-sections -mmcu=${MCU}")
 
 add_executable(${PROJECT_NAME} ${ARDUINO_CORE_SRC} ${SRC_FILES})
 
diff --git a/WirelessRelay.cpp b/WirelessRelay.cpp
index 6ffae4d..5e4872a 100644
--- a/WirelessRelay.cpp
+++ b/WirelessRelay.cpp
@@ -72,4 +72,22 @@ void WirelessRelay::off()
     }
 }
 
-WirelessRelay::WirelessRelay( volatile unsigned char *port, const unsigned char pin, const uint16_t id):_id(id), _port(port), _pin(pin){}
+uint16_t WirelessRelay::getId()
+{
+    return _id;
+}
+
+
+void WirelessRelay::init( volatile unsigned char *port, const unsigned char pin, const uint16_t id)
+{
+    _port=port;
+    _id=id;
+    _pin=pin;
+}
+
+WirelessRelay::WirelessRelay( volatile unsigned char *port, const unsigned char pin, const uint16_t id)
+{
+    init( port, pin, id);
+}
+
+WirelessRelay::WirelessRelay(){}
diff --git a/WirelessRelay.h b/WirelessRelay.h
index 570962d..e166798 100644
--- a/WirelessRelay.h
+++ b/WirelessRelay.h
@@ -10,16 +10,19 @@
 class WirelessRelay
 {
 private:
-     const uint16_t _id;
+     uint16_t _id;
      volatile unsigned char *_port;
-     const unsigned char _pin;
+     unsigned char _pin;
      void sendBit( const bool i);
      void sync();
      void sendId();
      
 public:
     WirelessRelay( volatile unsigned char *port, const  unsigned char pin, const uint16_t id);
+    WirelessRelay();
+    void init( volatile unsigned char *port, const  unsigned char pin, const uint16_t id);
     void on(); 
     void off();
+    uint16_t getId();
 };
 #endif
diff --git a/eeprom.h b/eeprom.h
new file mode 100644
index 0000000..bb28b58
--- /dev/null
+++ b/eeprom.h
@@ -0,0 +1,42 @@
+void EEPROM_write_char(uint16_t address, unsigned char data)
+{
+    /* Wait for completion of previous write */
+    while(EECR & (1<<EEPE))
+    ;
+    /* Set up address and Data Registers */
+    EEAR = address;
+    EEDR = data;
+    /* Write logical one to EEMPE */
+    EECR |= (1<<EEMPE);
+    /* Start eeprom write by setting EEPE */
+    EECR |= (1<<EEPE);
+}
+
+unsigned char EEPROM_read_char(uint16_t uiAddress)
+{
+    /* Wait for completion of previous write */
+    while(EECR & (1<<EEPE))
+    ;
+    /* Set up address register */
+    EEAR = uiAddress;
+    /* Start eeprom read by writing EERE */
+    EECR |= (1<<EERE);
+    /* 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] );
+    }
+}
+
+void EEPROM_read_string(uint16_t address, char* buffer, uint16_t length)
+{
+    for(uint16_t i = 0; i < length; i++)
+    {
+        buffer[i] = EEPROM_read_char( address+i);
+    }
+}
diff --git a/main.cpp b/main.cpp
index 41124cd..b873eb4 100644
--- a/main.cpp
+++ b/main.cpp
@@ -2,72 +2,227 @@
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include "serial.h"
 #include "writepin.h"
 #include "WirelessRelay.h"
 #include "pwm.h"
+#include "eeprom.h"
 
-bool serialDispatch(Serial* serial , WirelessRelay* relayOne,  WirelessRelay* relayTow,  WirelessRelay* relayThree,  WirelessRelay* relayFour)
+#define MAX_RELAYS 32
+#define COMMAND_BUFFER_SIZE 32
+
+struct WirelessRelayStore
+{
+    WirelessRelay array[MAX_RELAYS];
+    uint8_t count;
+};
+
+inline static void printHelp(Serial* serial)
+{
+    serial->putString("Available Commands: \n\
+                help                       :  Show this prompt \n\
+                relay add [id]             :  Add Wireless Relay\n\
+                relay list                 :  Print list of saved Wireless Relays \n\
+                relay [on/off] [nn]        :  Turn on/off nth relay\n\
+                erase                      :  Erase epprom\n\
+                rgb [on/off]               :  Turn on/off RGB leds at current value.\n\
+                rgb print                  :  Print current RGB value.\n\
+                rgb set [RRR] [GGG] [BBB]  :  Set RGB value.\n\
+                rgb pattern                :  RGB pattern\n\
+                version                    :  Print Version.\n\n");
+}
+
+void relayDispatch(WirelessRelayStore* relays, char* inBuffer, Serial* serial)
+{
+    if( strncmp(inBuffer, "add", 3) == 0 && inBuffer[3] != '\0')
+    {
+        uint16_t id = strtol( inBuffer+4, nullptr, 16 );
+        if(id != 0 && relays->count < MAX_RELAYS) 
+        {
+            relays->array[relays->count].init(&PORTB, PB5, id);
+            char buffer[64];
+            
+            EEPROM_write_char( 0, relays->count+1 );
+            EEPROM_write_string( relays->count*2+1, (char*) &id, 2 );
+            
+            sprintf(buffer, "Relay saved! NUMBER: %u ID: %X\n\n", relays->count, id);
+            serial->putString(buffer, 64);
+            
+            relays->count++;
+        }
+        else serial->putString("Usage: relay add [id]    [id] being a 16bit hex nummber\n\n");
+    }
+    else if( strncmp(inBuffer, "list", 4) == 0)
+    {
+        serial->putString("Relays:\n");
+        for(uint8_t i = 0; i < relays->count; i++)
+        {
+            char buffer[64];
+            sprintf(buffer, "NUMBER: %u ID: %X\n", i, relays->array[i].getId());
+            serial->putString(buffer, 64);
+        }
+        serial->putChar('\n');
+    }
+    else if( strncmp(inBuffer, "on", 2) == 0 && inBuffer[2] != '\0')
+    {
+        uint8_t selected = atoi(inBuffer+2);
+        if (selected <= relays->count)
+        {
+            relays->array[selected].on();
+        }
+    }
+    else if( strncmp(inBuffer, "off", 3) == 0 && inBuffer[3] != '\0')
+    {
+        uint8_t selected = atoi(inBuffer+3);
+        if (selected <= relays->count)
+        {
+            relays->array[selected].off();
+        }
+    }
+    else 
+    { 
+        serial->putString(inBuffer, COMMAND_BUFFER_SIZE-5);
+        serial->putString(" is not a valid subcommand: relay [add/list/on/off]\n\n");
+    }
+}
+
+void rgbDispatch(Pwm8b* pwmTc0, Pwm8b* pwmTc2, char* inBuffer, Serial* serial)
+{
+    if( strncmp(inBuffer, "on", 2) == 0 )
+    {
+        pwmTc0->on();
+        pwmTc2->on();
+        serial->putString("RGB lights on\n\n");
+    }
+    else if( strncmp(inBuffer, "off", 3) == 0 )
+    {
+        pwmTc0->off();
+        pwmTc2->off();
+        serial->putString("RGB lights off\n\n");
+    }
+    else if( strncmp(inBuffer, "print", 5) == 0 )
+    {
+        char buffer[64];
+        sprintf(buffer, "Current RGB values:\nR: %u G: %u B: %u\n\n", OCR0A, OCR0B, OCR2B);
+        serial->putString(buffer, 64);
+    }
+    else if( strncmp(inBuffer, "set", 3) == 0 )
+    {
+        uint8_t i = 0;
+        for(; inBuffer[i] != '\0' && i < COMMAND_BUFFER_SIZE-4; i++ );
+        if( i > 14)
+        {
+            inBuffer[7] = '\0';
+            inBuffer[11] = '\0';
+            pwmTc0->setDutyA(atoi(inBuffer+4));
+            pwmTc0->setDutyB(atoi(inBuffer+8));
+            pwmTc2->setDutyB(atoi(inBuffer+12));
+            serial->putString("Set RGB values\n\n");
+        }
+        else serial->putString("Usage: rgb set [RRR] [GGG] [BBB]\n\n");
+    }
+    else 
+    {
+        serial->putString(inBuffer, COMMAND_BUFFER_SIZE-4);
+        serial->putString(" is not a valid subcommand: rgb [/on/off/print/set]\n\n");
+    }
+}
+
+void serialDispatch(Serial* serial , WirelessRelayStore* relays, Pwm8b* pwmTc0, Pwm8b* pwmTc2)
 {
     
     if(serial->dataIsWaiting())
     {
-        char buffer[20];
-        const int length = serial->getString(buffer, 7); 
+        char buffer[COMMAND_BUFFER_SIZE];
+        const int length = serial->getString(buffer, COMMAND_BUFFER_SIZE);
+        if(length != 0)
+        {
+            //serial->putString("InString: ");
+            //serial->putString(buffer, COMMAND_BUFFER_SIZE);
+            //serial->putChar('\n');
+            if(length > 4 && strncmp(buffer, "relay", 5) == 0)
+            {
+                relayDispatch(relays, buffer+6, serial);
+            }
+            else if(length > 2 && strncmp(buffer, "rgb", 3) == 0)
+            {
+                rgbDispatch(pwmTc0, pwmTc2, buffer+4, serial);
+            }
+            else if(length > 4 && strncmp(buffer, "erase", 5) == 0)
+            {
+                for(uint16_t i = 0; i < MAX_RELAYS*2+1; i++) EEPROM_write_char(i, 0);
+                serial->putString("EEPROM erased\n\n");
+            }
+            else if(buffer[0] == '?' || ( length > 3 && strncmp(buffer, "help", 4) == 0))
+            {
+                printHelp(serial);
+            }
+            else
+            {
+                serial->putString("Not a valid command\n\n");
+            }
+        }
     }
-    return false;
 }
 
+void restore_relays(WirelessRelayStore* relays)
+{
+    relays->count = EEPROM_read_char(0);
+    if(relays->count > MAX_RELAYS ) 
+    {
+        for(uint16_t i = 0; i < MAX_RELAYS*2+1; i++) EEPROM_write_char(i, 0);
+        relays->count = 0;
+    }
+    for(uint8_t i = 0; i <= relays->count; i++)
+    {
+        uint16_t id;
+        EEPROM_read_string(1+i*2, (char*) &id, 2);
+        relays->array[i].init(&PORTB, PB5, id); 
+    }
+}
+
+
 int main() 
 {
-    DDRB =  0xFF;//= (1 << PB5) | ( 1 << PB1); 
-    DDRD =  0xFF;//= (1 << PD3) | (1 << PD5);
+    DDRB =  (1 << PB5) | ( 1 << PB1); 
+    DDRD =  (1 << PD3) | (1 << PD5)| (1 << PD6);
      
     PORTB  = 0x00;
-    sei();
     
+    sei();
     Serial serial;
     
-    
-   /* Pwm16b pwmA;
+    /*
+    Pwm16b pwmA;
     pwmA.setDuty(10);
-    pwmA.on();*/
+    pwmA.on();
+    */
     
-    
-    Pwm8b pwmTc0( &TCCR0A, &TCCR0B, &OCR0A, &OCR0B );
-    //pwmB.on();
+    Pwm8b pwmTc0( &TCCR0A, &TCCR0B, &OCR0A, &OCR0B, 0b00000011, true, true );
     
     Pwm8b pwmTc2( &TCCR2A, &TCCR2B, &OCR2A, &OCR2B, 0b00000101, false, true );
     
-    //pwmTc0.setDutyA(10);
-        //pwmTc0.setDutyB(10);
-        pwmTc2.setDutyB(128);
-        
+    bool pattern = true;
     
-    /*
-    //fast 8 bit PWM pwm A
-    TCCR0A|= (1<<COM0A1) | (1<<COM0B1); 
-    TCCR0A|=(1<<WGM01) | (1<<WGM00);
+    WirelessRelayStore relays;
+    relays.count=0;    
+    restore_relays(&relays);
     
-    //start with /1024 prescaller
-    TCCR0B =(1 << CS00) |  (1 << CS01);*/
+    uint8_t counter = 0;
     
-    WirelessRelay relayOne(&PORTB, PB5,    0b1001110000000000);
-    WirelessRelay relayTow(&PORTB, PB5,    0b1001101000000000);
-    WirelessRelay relayThree(&PORTB, PB5, 0b1001100100000000);
-    WirelessRelay relayFour(&PORTB, PB5,   0b1001100010000000);
-    
-    serial.putString("RGBController v0.1 starting\n");
-    
-    uint8_t duty = 0;
+    serial.putString("RGBController v0.1 starting\n\n");
     while(true)
     {
-        serialDispatch(&serial, &relayOne, &relayTow, &relayThree, &relayFour);
-        pwmTc0.setDutyA(duty);
-        pwmTc0.setDutyB(duty);
-        pwmTc2.setDutyB(duty);
-        duty++;
-        _delay_us(50000);
+        serialDispatch(&serial, &relays, &pwmTc0, &pwmTc2);
+        if(pattern)
+        {
+            counter++;
+            pwmTc0.setDutyA(counter);
+            pwmTc0.setDutyB(counter-64);
+            pwmTc2.setDutyB(counter-128);
+            _usleep(20);
+        }
     }
 
     return 0; //master interupt.
diff --git a/pwm.cpp b/pwm.cpp
index 50dc5fc..768ee83 100644
--- a/pwm.cpp
+++ b/pwm.cpp
@@ -39,37 +39,40 @@ Pwm16b::~Pwm16b()
 Pwm8b::Pwm8b( volatile unsigned char *timerControlRegisterA, volatile unsigned char *timerControlRegisterB, volatile unsigned char *compareRegisterA, volatile unsigned char *compareRegisterB, const uint8_t speed, const bool enableA, const bool enableB, const uint8_t dutyA,  const uint8_t dutyB)
 {
     _timerControlRegisterA = timerControlRegisterA;
-    _timerControlRegisterB = timerControlRegisterB;
     _compareRegisterA = compareRegisterA;
     _compareRegisterB = compareRegisterB;
-    _speed=speed;
+    
+    _enableA =enableA;
+    _enableB =enableB;
     
     *_timerControlRegisterA = 0x00;
-    off();
+    *timerControlRegisterB = 0x00;
+    //off();
     
     //fast 8 bit PWM pwm A
-    if(enableA) *_timerControlRegisterA|= (1<<COM0A1);
-    if(enableB) *_timerControlRegisterA|=  (1<<COM0B1);
+    if(_enableA) *_timerControlRegisterA|= (1<<COM0A1);
+    if(_enableB) *_timerControlRegisterA|=  (1<<COM0B1);
     
     *_timerControlRegisterA|= (1<<WGM01) | (1<<WGM00);
+    *timerControlRegisterB |= 0b00000111 & speed;
     
     *_compareRegisterA = 0; //0% pwm to start0
     *_compareRegisterB = 0; //0% pwm to start0
     
-    on();
+    //on();
 }
 
 void Pwm8b::off()
 {
-    *_timerControlRegisterB = 0x00;
+    *_timerControlRegisterA &= 0b00000011;
 }
 
 void Pwm8b::on()
 {
     off();
-    //start with /1024 prescaller
-    //*_timerControlRegisterB =(1 << CS00) |  (1 << CS01);
-    *_timerControlRegisterB |= _speed;
+    if(_enableA) *_timerControlRegisterA|= (1<<COM0A1);
+    if(_enableB) *_timerControlRegisterA|=  (1<<COM0B1);
+    
 }
 
 void Pwm8b::setDutyA(const uint8_t duty)
diff --git a/pwm.h b/pwm.h
index a332782..399d72b 100644
--- a/pwm.h
+++ b/pwm.h
@@ -17,10 +17,11 @@ class Pwm8b
 {
 private:
      volatile unsigned char *_timerControlRegisterA; //TCCRxA
-     volatile unsigned char *_timerControlRegisterB; //TCCRxB
      volatile unsigned char *_compareRegisterA;      //OCRxA
      volatile unsigned char *_compareRegisterB;      //OCRxB
-     uint8_t _speed = 0b00000011;
+     
+     bool _enableA;
+     bool _enableB;
      
 public:
   Pwm8b( volatile unsigned char *timerControlRegisterA, volatile unsigned char *timerControlRegisterB, volatile unsigned char *compareRegisterA, volatile unsigned char *compareRegisterB, const uint8_t speed = 0b00000011, const bool enableA = true, const bool enableB = true, const uint8_t dutyA = 0,  const uint8_t dutyB = 0 );
diff --git a/serial.cpp b/serial.cpp
index 86b0483..e882620 100644
--- a/serial.cpp
+++ b/serial.cpp
@@ -26,7 +26,7 @@ void Serial::putChar(const char c)
 
 void Serial::putString(const char* in, const unsigned int length)
 {
-    for(unsigned int i = 0; i < length; i++)
+    for(unsigned int i = 0; i < length && in[i] != '\0'; i++)
     {
         putChar(in[i]);
     }
@@ -56,17 +56,19 @@ char Serial::getChar()
     else return '\0';
 }
 
-int Serial::getString(char* buffer, const int bufferLength)
+unsigned int Serial::getString(char* buffer, const int bufferLength)
 {
     int i = 0;
     for(; i <= (interruptIndex-_rxIndex) && i <= BUFFER_SIZE && rxBuffer[(_rxIndex+i) % BUFFER_SIZE] != _terminator; i++);
     
     if( i < (interruptIndex-_rxIndex) && i > 0)
     {
-       for(int j = 0 ; j < i &&  j < bufferLength ; j++)
+       int j = 0;
+       for(; j < i &&  j < bufferLength-1 ; j++)
        {
            buffer[j] = getChar();
        }
+       buffer[j+1]='\0';
        _rxIndex++;
     }
     else
diff --git a/serial.h b/serial.h
index 437b0c3..810ef8d 100644
--- a/serial.h
+++ b/serial.h
@@ -2,7 +2,7 @@
 #define SERIAL_H
 
 #define BAUD 38400
-#define BUFFER_SIZE 64
+#define BUFFER_SIZE 128
 
 #include <util/setbaud.h>
 #include <avr/io.h>
@@ -22,7 +22,7 @@ public:
     void putString(const char in[]);
     bool dataIsWaiting();
     char getChar();
-    int getString(char* buffer, const int bufferLength);
+    unsigned int getString(char* buffer, const int bufferLength);
     void flush();    
     void setTerminator(const char terminator);
 };