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

command interpreter and epprom

Browse Source
This commit is contained in:
IMback
2017-05-19 09:48:19 +02:00
parent cb779f21d4
commit ecd7ad677b
9 changed files with 282 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -37,7 +37,7 @@ add_definitions(-fno-exceptions -ffunction-sections -fdata-sections)
# Linker flags # Linker flags
set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "") # remove -rdynamic for C set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "") # remove -rdynamic for C
set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "") # remove -rdynamic for CXX 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}) add_executable(${PROJECT_NAME} ${ARDUINO_CORE_SRC} ${SRC_FILES})

20
WirelessRelay.cpp
View File

@ -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(){}

7
WirelessRelay.h
View File

@ -10,16 +10,19 @@
class WirelessRelay class WirelessRelay
{ {
private: private:
const uint16_t _id; uint16_t _id;
volatile unsigned char *_port; volatile unsigned char *_port;
const unsigned char _pin; unsigned char _pin;
void sendBit( const bool i); void sendBit( const bool i);
void sync(); void sync();
void sendId(); void sendId();
public: public:
WirelessRelay( volatile unsigned char *port, const unsigned char pin, const uint16_t id); 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 on();
void off(); void off();
uint16_t getId();
}; };
#endif #endif

42
eeprom.h Normal file
View File

@ -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);
}
}

229
main.cpp
View File

@ -2,72 +2,227 @@
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
#include "serial.h" #include "serial.h"
#include "writepin.h" #include "writepin.h"
#include "WirelessRelay.h" #include "WirelessRelay.h"
#include "pwm.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()) if(serial->dataIsWaiting())
{ {
char buffer[20]; char buffer[COMMAND_BUFFER_SIZE];
const int length = serial->getString(buffer, 7); 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() int main()
{ {
DDRB = 0xFF;//= (1 << PB5) | ( 1 << PB1); DDRB = (1 << PB5) | ( 1 << PB1);
DDRD = 0xFF;//= (1 << PD3) | (1 << PD5); DDRD = (1 << PD3) | (1 << PD5)| (1 << PD6);
PORTB = 0x00; PORTB = 0x00;
sei();
sei();
Serial serial; Serial serial;
/*
/* Pwm16b pwmA; Pwm16b pwmA;
pwmA.setDuty(10); pwmA.setDuty(10);
pwmA.on();*/ pwmA.on();
*/
Pwm8b pwmTc0( &TCCR0A, &TCCR0B, &OCR0A, &OCR0B, 0b00000011, true, true );
Pwm8b pwmTc0( &TCCR0A, &TCCR0B, &OCR0A, &OCR0B );
//pwmB.on();
Pwm8b pwmTc2( &TCCR2A, &TCCR2B, &OCR2A, &OCR2B, 0b00000101, false, true ); Pwm8b pwmTc2( &TCCR2A, &TCCR2B, &OCR2A, &OCR2B, 0b00000101, false, true );
//pwmTc0.setDutyA(10); bool pattern = true;
//pwmTc0.setDutyB(10);
pwmTc2.setDutyB(128);
/* WirelessRelayStore relays;
//fast 8 bit PWM pwm A relays.count=0;
TCCR0A|= (1<<COM0A1) | (1<<COM0B1); restore_relays(&relays);
TCCR0A|=(1<<WGM01) | (1<<WGM00);
//start with /1024 prescaller uint8_t counter = 0;
TCCR0B =(1 << CS00) | (1 << CS01);*/
WirelessRelay relayOne(&PORTB, PB5, 0b1001110000000000); serial.putString("RGBController v0.1 starting\n\n");
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;
while(true) while(true)
{ {
serialDispatch(&serial, &relayOne, &relayTow, &relayThree, &relayFour); serialDispatch(&serial, &relays, &pwmTc0, &pwmTc2);
pwmTc0.setDutyA(duty); if(pattern)
pwmTc0.setDutyB(duty); {
pwmTc2.setDutyB(duty); counter++;
duty++; pwmTc0.setDutyA(counter);
_delay_us(50000); pwmTc0.setDutyB(counter-64);
pwmTc2.setDutyB(counter-128);
_usleep(20);
}
} }
return 0; //master interupt. return 0; //master interupt.

23
pwm.cpp
View File

@ -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) 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; _timerControlRegisterA = timerControlRegisterA;
_timerControlRegisterB = timerControlRegisterB;
_compareRegisterA = compareRegisterA; _compareRegisterA = compareRegisterA;
_compareRegisterB = compareRegisterB; _compareRegisterB = compareRegisterB;
_speed=speed;
_enableA =enableA;
_enableB =enableB;
*_timerControlRegisterA = 0x00; *_timerControlRegisterA = 0x00;
off(); *timerControlRegisterB = 0x00;
//off();
//fast 8 bit PWM pwm A //fast 8 bit PWM pwm A
if(enableA) *_timerControlRegisterA|= (1<<COM0A1); if(_enableA) *_timerControlRegisterA|= (1<<COM0A1);
if(enableB) *_timerControlRegisterA|= (1<<COM0B1); if(_enableB) *_timerControlRegisterA|= (1<<COM0B1);
*_timerControlRegisterA|= (1<<WGM01) | (1<<WGM00); *_timerControlRegisterA|= (1<<WGM01) | (1<<WGM00);
*timerControlRegisterB |= 0b00000111 & speed;
*_compareRegisterA = 0; //0% pwm to start0 *_compareRegisterA = 0; //0% pwm to start0
*_compareRegisterB = 0; //0% pwm to start0 *_compareRegisterB = 0; //0% pwm to start0
on(); //on();
} }
void Pwm8b::off() void Pwm8b::off()
{ {
*_timerControlRegisterB = 0x00; *_timerControlRegisterA &= 0b00000011;
} }
void Pwm8b::on() void Pwm8b::on()
{ {
off(); off();
//start with /1024 prescaller if(_enableA) *_timerControlRegisterA|= (1<<COM0A1);
//*_timerControlRegisterB =(1 << CS00) | (1 << CS01); if(_enableB) *_timerControlRegisterA|= (1<<COM0B1);
*_timerControlRegisterB |= _speed;
} }
void Pwm8b::setDutyA(const uint8_t duty) void Pwm8b::setDutyA(const uint8_t duty)

5
pwm.h
View File

@ -17,10 +17,11 @@ class Pwm8b
{ {
private: private:
volatile unsigned char *_timerControlRegisterA; //TCCRxA volatile unsigned char *_timerControlRegisterA; //TCCRxA
volatile unsigned char *_timerControlRegisterB; //TCCRxB
volatile unsigned char *_compareRegisterA; //OCRxA volatile unsigned char *_compareRegisterA; //OCRxA
volatile unsigned char *_compareRegisterB; //OCRxB volatile unsigned char *_compareRegisterB; //OCRxB
uint8_t _speed = 0b00000011;
bool _enableA;
bool _enableB;
public: 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 ); 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 );

8
serial.cpp
View File

@ -26,7 +26,7 @@ void Serial::putChar(const char c)
void Serial::putString(const char* in, const unsigned int length) 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]); putChar(in[i]);
} }
@ -56,17 +56,19 @@ char Serial::getChar()
else return '\0'; else return '\0';
} }
int Serial::getString(char* buffer, const int bufferLength) unsigned int Serial::getString(char* buffer, const int bufferLength)
{ {
int i = 0; int i = 0;
for(; i <= (interruptIndex-_rxIndex) && i <= BUFFER_SIZE && rxBuffer[(_rxIndex+i) % BUFFER_SIZE] != _terminator; i++); for(; i <= (interruptIndex-_rxIndex) && i <= BUFFER_SIZE && rxBuffer[(_rxIndex+i) % BUFFER_SIZE] != _terminator; i++);
if( i < (interruptIndex-_rxIndex) && i > 0) 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] = getChar();
} }
buffer[j+1]='\0';
_rxIndex++; _rxIndex++;
} }
else else

4
serial.h
View File

@ -2,7 +2,7 @@
#define SERIAL_H #define SERIAL_H
#define BAUD 38400 #define BAUD 38400
#define BUFFER_SIZE 64 #define BUFFER_SIZE 128
#include <util/setbaud.h> #include <util/setbaud.h>
#include <avr/io.h> #include <avr/io.h>
@ -22,7 +22,7 @@ public:
void putString(const char in[]); void putString(const char in[]);
bool dataIsWaiting(); bool dataIsWaiting();
char getChar(); char getChar();
int getString(char* buffer, const int bufferLength); unsigned int getString(char* buffer, const int bufferLength);
void flush(); void flush();
void setTerminator(const char terminator); void setTerminator(const char terminator);
}; };