Avr/RGBController
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

contienus previous commit

Browse Source
This commit is contained in:
IMback
2018-10-08 21:10:35 +02:00
parent 445b60985f
commit 4ae82c698c
6 changed files with 99 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -31,7 +31,7 @@ set(CMAKE_LINKER /usr/bin/avr-ld)
# Compiler flags # Compiler flags
add_definitions(-mmcu=${MCU} -DF_CPU=${CPU_SPEED}) add_definitions(-mmcu=${MCU} -DF_CPU=${CPU_SPEED})
add_definitions(-s -c -g -Os -Wall -std=c++11 ) add_definitions(-s -c -g -Os -Wall -std=c++17 )
add_definitions(-fno-exceptions -ffunction-sections -fdata-sections) add_definitions(-fno-exceptions -ffunction-sections -fdata-sections)
# Linker flags # Linker flags

20
WirelessRelay.cpp
View File

@ -1,6 +1,6 @@
#include"WirelessRelay.h" #include"WirelessRelay.h"
#include <avr/io.h> #include <avr/io.h>
#include "eeprom.h" #include <string.h>
volatile unsigned char *_port = &PORTB; volatile unsigned char *_port = &PORTB;
unsigned char _pin = PB5; unsigned char _pin = PB5;
@ -88,15 +88,25 @@ bool WirelessRelay::getExpectedState()
return _state; return _state;
} }
char* WirelessRelay::getName()
void WirelessRelay::init( const uint16_t id)
{ {
return _name;
}
void WirelessRelay::setName(char name[])
{
memcpy(_name, name, strlen(name)+1);
}
void WirelessRelay::init( const uint16_t id, char nameIn[])
{
setName(nameIn);
_id=id; _id=id;
} }
WirelessRelay::WirelessRelay(const uint16_t id) WirelessRelay::WirelessRelay(const uint16_t id, char nameIn[])
{ {
init(id); init(id, nameIn);
} }
WirelessRelay::WirelessRelay(){} WirelessRelay::WirelessRelay(){}

11
WirelessRelay.h
View File

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

8
eeprom.h
View File

@ -33,9 +33,9 @@ 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); 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) template <class T> void EEPROM_write_class(uint16_t address, T& in)
{ {
EEPROM_write_string( address, reinterpret_cast<char*> &in, sizeof(in)); EEPROM_write_string( address, reinterpret_cast<char*>(&in), sizeof(in));
} }
template <class T> T EEPROM_read_class(uint16_t address) template <class T> T EEPROM_read_class(uint16_t address)
@ -45,7 +45,7 @@ template <class T> T EEPROM_read_class(uint16_t address)
return *reinterpret_cast<T*>(data); return *reinterpret_cast<T*>(data);
} }
template <class T> T EEPROM_read_class(uint16_t address, T* in) template <class T> void EEPROM_read_class(uint16_t address, T* in)
{ {
EEPROM_read_string( address, reinterpret_cast<char*> &in, sizeof(T) ); EEPROM_read_string( address, reinterpret_cast<char*>(&in), sizeof(T) );
} }

149
main.cpp
View File

@ -9,34 +9,17 @@
#include "rgbled.h" #include "rgbled.h"
#include "eeprom.h" #include "eeprom.h"
#include "bitrep.h" #include "bitrep.h"
#include "staticvector.h"
#define COMMAND_BUFFER_SIZE 32 #define COMMAND_BUFFER_SIZE 32
#define SNPRINTF_BUFFER_SIZE 64 #define SNPRINTF_BUFFER_SIZE 64
#define MAX_RELAYS 16
#define RELAY_VECTOR_EEPROM_ADDR 32
char buffer[SNPRINTF_BUFFER_SIZE]; char buffer[SNPRINTF_BUFFER_SIZE];
class WirelessRelayStore SVector<WirelessRelay, MAX_RELAYS> relays;
{
public:
static const MAX_RELAYS = 16;
private:
WirelessRelay array[MAX_RELAYS];
uint8_t count;
bool states[MAX_RELAYS]={};
bool printState = true;
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;
inline static void printHelp(Serial* serial) inline static void printHelp(Serial* serial)
{ {
@ -60,58 +43,72 @@ inline static void printHelp(Serial* serial)
aux set [VAL] : Set PWM value, pattern must be 0.\n")); aux set [VAL] : Set PWM value, pattern must be 0.\n"));
} }
void writeState( WirelessRelayStore* relays, Pwm16b* auxPwm, Serial* serial ) void save()
{
EEPROM_write_class< SVector<WirelessRelay, MAX_RELAYS> > (RELAY_VECTOR_EEPROM_ADDR, relays);
}
void load()
{
EEPROM_read_class< SVector<WirelessRelay, MAX_RELAYS> > (RELAY_VECTOR_EEPROM_ADDR, &relays);
}
void writeState( SVector<WirelessRelay, MAX_RELAYS>* relays, Pwm16b* auxPwm, Serial* serial )
{ {
serial->write("ST"); serial->write("ST");
serial->write(auxPwm->isOn() ? auxPwm->getValueA() >> 8 : 0); serial->write(auxPwm->isOn() ? auxPwm->getValueA() >> 8 : 0);
serial->putChar(','); serial->putChar(',');
serial->write(relays->count); serial->write(relays->count());
for(uint8_t i = 0; i < relays->count; i++) for(uint8_t i = 0; i < relays->count(); i++)
{ {
serial->putChar(','); serial->putChar(',');
relays->array[i].getExpectedState() ? serial->putChar('1') : serial->putChar('0'); relays->at(i).getExpectedState() ? serial->putChar('1') : serial->putChar('0');
} }
serial->putChar('\n'); serial->putChar('\n');
} }
void relayDispatch(WirelessRelayStore* relays, Pwm16b* auxPwm, char* token, Serial* serial) void relayDispatch(SVector<WirelessRelay, MAX_RELAYS>* relays, Pwm16b* auxPwm, char* token, Serial* serial)
{ {
if( strcmp(token, "add") == 0 ) if( strcmp(token, "add") == 0 )
{ {
char* token = strtok(NULL, " \n"); token = strtok(NULL, " \n");
uint16_t id = strtol(token, nullptr, 2 ); uint16_t id = strtol(token, nullptr, 2 );
if(id != 0 && relays->count < MAX_RELAYS) if(id != 0 && relays->remainingCapacity() > 0)
{ {
relays->array[relays->count].init(id); token = strtok(NULL, " \n");
if( token == NULL )
EEPROM_write_char( 0, relays->count+1 ); {
EEPROM_write_string( relays->count*2+1, (char*) &id, 2 ); char name[] = "";
WirelessRelay relay(id, name);
uint8_t size = snprintf(buffer, SNPRINTF_BUFFER_SIZE, "Relay saved! NUMBER: %u ID: %X \n", relays->count, id); relays->push_back(relay);
serial->write(buffer, size);
relays->count++;
} }
else serial->write_p(PSTR("Usage: relay add [id] [id] being a 16bit binary nummber\n")); else
{
WirelessRelay relay(id, token);
relays->push_back(relay);
}
save();
}
else if(relays->remainingCapacity() == 0) serial->write_p(PSTR("Relay storage full.\n"));
else serial->write_p(PSTR("Usage: relay add [id] [name]\n [id] being a 16bit binary nummber and [name] an optional string\n"));
} }
else if( strcmp(token, "delete") == 0 ) else if( strcmp(token, "delete") == 0 )
{ {
serial->write_p(PSTR("Relay: ")); relays->erase(relays->count());
serial->write(relays->count); save();
serial->write_p(PSTR(" deleted\n"));
relays->count--;
} }
else if( strcmp(token, "list") == 0 ) else if( strcmp(token, "list") == 0 )
{ {
serial->write_p(PSTR("Relays:\n")); serial->write_p(PSTR("Relays:\n"));
for(uint8_t i = 0; i < relays->count; i++) for(uint8_t i = 0; i < relays->count(); i++)
{ {
uint16_t id = relays->array[i].getId(); uint16_t id = relays->at(i).getId();
snprintf(buffer, SNPRINTF_BUFFER_SIZE, "NUMBER: %u ID: %s%s%s%s\n", i, snprintf(buffer, SNPRINTF_BUFFER_SIZE, "NUMBER: %u ID: %s%s%s%s NAME: %s\n", i,
bit_rep[ id >> 12], bit_rep[ id >> 12],
bit_rep[(id & 0x0F00) >> 8 ], bit_rep[(id & 0x0F00) >> 8 ],
bit_rep[(id & 0x00F0) >> 4 ], bit_rep[(id & 0x00F0) >> 4 ],
bit_rep[ id & 0x000F ]); bit_rep[ id & 0x000F ],
relays->at(i).getName());
serial->write(buffer, SNPRINTF_BUFFER_SIZE); serial->write(buffer, SNPRINTF_BUFFER_SIZE);
} }
serial->putChar('\n'); serial->putChar('\n');
@ -122,13 +119,13 @@ void relayDispatch(WirelessRelayStore* relays, Pwm16b* auxPwm, char* token, Ser
if( token != NULL) if( token != NULL)
{ {
uint8_t selected = atoi(token); uint8_t selected = atoi(token);
if (selected <= relays->count) if (selected <= relays->count())
{ {
relays->array[selected].on(); relays->at(selected).on();
snprintf(buffer, SNPRINTF_BUFFER_SIZE, "RELAY: %u turned on\n", selected); snprintf(buffer, SNPRINTF_BUFFER_SIZE, "RELAY: %u turned on\n", selected);
serial->write(buffer, SNPRINTF_BUFFER_SIZE); serial->write(buffer, SNPRINTF_BUFFER_SIZE);
if(relays->printState) writeState(relays, auxPwm, serial); writeState(relays, auxPwm, serial);
} }
else serial->write("No sutch Relay\n"); else serial->write("No sutch Relay\n");
} }
@ -139,39 +136,21 @@ void relayDispatch(WirelessRelayStore* relays, Pwm16b* auxPwm, char* token, Ser
if( token != NULL) if( token != NULL)
{ {
uint8_t selected = atoi(token); uint8_t selected = atoi(token);
if (selected <= relays->count) if (selected <= relays->count())
{ {
relays->array[selected].off(); relays->at(selected).off();
snprintf(buffer, SNPRINTF_BUFFER_SIZE, "RELAY: %u turned off\n", selected); snprintf(buffer, SNPRINTF_BUFFER_SIZE, "RELAY: %u turned off\n", selected);
serial->write(buffer, SNPRINTF_BUFFER_SIZE); serial->write(buffer, SNPRINTF_BUFFER_SIZE);
if(relays->printState) writeState(relays, auxPwm, serial); writeState(relays, auxPwm, serial);
} }
else serial->write("No sutch Relay\n"); else serial->write("No sutch Relay\n");
} }
} }
else if( strcmp(token, "machine") == 0 )
{
char* token = strtok(NULL, " \n");
if( token != NULL)
{
if( strcmp(token, "on") == 0 )
{
relays->printState = true;
serial->write_p(PSTR("Turned on State printing\n"));
}
else
{
relays->printState = false;
serial->write("Turned off State printing\n");
}
}
else serial->write_p(PSTR("Usage: relay machine [on/off]\n"));
}
else else
{ {
serial->write(token); serial->write(token);
serial->write_p(PSTR(" is not a valid subcommand: relay [add/delete/list/on/off/state/machine]\n")); serial->write_p(PSTR(" is not a valid subcommand: relay [add/delete/list/on/off]\n"));
} }
} }
@ -278,7 +257,7 @@ void auxDispatch(Pwm16b* auxPwm, char* token, Serial* serial)
} }
} }
void serialDispatch(Serial* serial , WirelessRelayStore* relays, RgbLed* rgbled, Pwm16b* auxPwm) void serialDispatch(Serial* serial, SVector<WirelessRelay, MAX_RELAYS>* relays, RgbLed* rgbled, Pwm16b* auxPwm)
{ {
if(serial->dataIsWaiting()) if(serial->dataIsWaiting())
@ -299,7 +278,7 @@ void serialDispatch(Serial* serial , WirelessRelayStore* relays, RgbLed* rgbled,
else if(strcmp(token, "aux") == 0) else if(strcmp(token, "aux") == 0)
{ {
auxDispatch(auxPwm, strtok(NULL, " \n"), serial); auxDispatch(auxPwm, strtok(NULL, " \n"), serial);
if(relays->printState == true) writeState(relays, auxPwm, serial); writeState(relays, auxPwm, serial);
} }
else if(strcmp(token, "state") == 0) else if(strcmp(token, "state") == 0)
{ {
@ -309,7 +288,7 @@ void serialDispatch(Serial* serial , WirelessRelayStore* relays, RgbLed* rgbled,
{ {
for(uint16_t i = 0; i < MAX_RELAYS*2+1; i++) EEPROM_write_char(i, 0); for(uint16_t i = 0; i < MAX_RELAYS*2+1; i++) EEPROM_write_char(i, 0);
serial->write_p(PSTR("EEPROM erased\n")); serial->write_p(PSTR("EEPROM erased\n"));
relays->count = 0; load();
} }
else if(strcmp(token, "help") == 0) else if(strcmp(token, "help") == 0)
{ {
@ -323,22 +302,6 @@ void serialDispatch(Serial* serial , WirelessRelayStore* relays, RgbLed* rgbled,
} }
} }
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(id);
}
}
int main() int main()
{ {
@ -365,9 +328,7 @@ int main()
Pwm16b pwmTc1 ( &TCCR1A, &TCCR1B, &OCR1A, &OCR1B, &ICR1, 0b00000001, true, false); Pwm16b pwmTc1 ( &TCCR1A, &TCCR1B, &OCR1A, &OCR1B, &ICR1, 0b00000001, true, false);
relays.count=0; load();
restore_relays(&relays);
serial.write_p(PSTR("RGBController v0.7 starting\n")); serial.write_p(PSTR("RGBController v0.7 starting\n"));
while(true) while(true)

27
staticvector.h
View File

@ -1,6 +1,7 @@
#pragma once #pragma once
#include <stdint.h>
template<typename T, std::size_t size> class SVector; template<typename T, size_t size> class SVector
{ {
private: private:
size_t stored = 0; size_t stored = 0;
@ -34,31 +35,32 @@ public:
return array[stored]; return array[stored];
} }
bool empty() bool empty() const
{ {
return stored == 0 ? true : false; return stored == 0 ? true : false;
} }
size_t size(); size_t count() const
{ {
return stored; return stored;
} }
constexpr size_t maxSize() constexpr size_t maxSize() const
{ {
return std::array::size(); return size;
} }
size_t remainingCapacity() size_t remainingCapacity() const
{ {
return std::array::size() - stored; return size - stored;
} }
bool push_back(const T in) bool push_back(const T in)
{ {
if( remainingCapacity() != 0) if( remainingCapacity() != 0)
{ {
std::array::operator[](stored) = in; array[stored] = in;
++stored;
return true; return true;
} }
else return false; else return false;
@ -67,9 +69,14 @@ public:
bool erase(size_t position) bool erase(size_t position)
{ {
if(position > stored) return false; if(position > stored) return false;
if constexpr( std::is_class<T> ) array[position].~T(); array[position].~T();
--stored; --stored;
for( size_t i = position; i < stored ) array[i] = array[i+1]; for( size_t i = position; i < stored; i++ ) array[i] = array[i+1];
return true; return true;
} }
void clear()
{
stored = 0;
} }
};