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

reformat in uvostyle

Browse Source
This commit is contained in:
uvos 2022-04-12 00:36:58 +02:00
parent 00ca1d6f03
commit 4aca3c3a11
22 changed files with 1260 additions and 1234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

277
W433DataReciver.cpp
View File

@ -8,112 +8,115 @@
W433DataReciver* W433DataReciver::instance = nullptr;
W433DataReciver::W433DataReciver(volatile unsigned char* const port , const unsigned char pin, volatile uint16_t * timerRegister, volatile uint8_t* const timerOverflowRegister, void (* const packetCallback)(uint32_t, void*), void* const userData, void (*errorCodeHandler)(uint8_t, void*) ):
_port(port), _pin(pin), _timerRegister(timerRegister), _timerOverflowRegister(timerOverflowRegister), _packetCallback(packetCallback), _errorCodeHandler(errorCodeHandler), _userData(userData)
W433DataReciver::W433DataReciver(volatile unsigned char* const port, const unsigned char pin,
volatile uint16_t * timerRegister, volatile uint8_t* const timerOverflowRegister,
void (* const packetCallback)(uint32_t, void*), void* const userData, void (*errorCodeHandler)(uint8_t, void*) ):
_port(port), _pin(pin), _timerRegister(timerRegister), _timerOverflowRegister(timerOverflowRegister),
_packetCallback(packetCallback), _errorCodeHandler(errorCodeHandler), _userData(userData)
{
instance = this;
for(uint8_t i = 0; i < 33; i++) timesBuffer[i] = 0;
instance = this;
for(uint8_t i = 0; i < 33; i++) timesBuffer[i] = 0;
}
W433DataReciver::~W433DataReciver()
{
instance = nullptr;
instance = nullptr;
}
void W433DataReciver::staticInterrupt()
{
if(instance != nullptr) instance->interrupt();
if(instance != nullptr) instance->interrupt();
}
int8_t W433DataReciver::reciveBit(uint8_t index)
{
if(
timesBuffer[index] < 0 &&
isTime(timesBuffer[index+1], SMALL_TIME, true, SMALL_TIME_TOLERANCE) &&
isTime(timesBuffer[index+2], LARGE_TIME, false, LARGE_TIME_TOLERANCE) //&&
//isTime(timesBuffer[index+3], SMALL_TIME, true, SMALL_TIME_TOLERANCE)
)
{
return 1;
}
else if(
timesBuffer[index] < 0 &&
isTime(timesBuffer[index+1], LARGE_TIME, true, LARGE_TIME_TOLERANCE) &&
isTime(timesBuffer[index+2], SMALL_TIME, false, SMALL_TIME_TOLERANCE) //&&
//isTime(timesBuffer[index+3], SMALL_TIME, true, SMALL_TIME_TOLERANCE)
)
{
return 0;
}
else return -1;
if(
timesBuffer[index] < 0 &&
isTime(timesBuffer[index+1], SMALL_TIME, true, SMALL_TIME_TOLERANCE) &&
isTime(timesBuffer[index+2], LARGE_TIME, false, LARGE_TIME_TOLERANCE) //&&
//isTime(timesBuffer[index+3], SMALL_TIME, true, SMALL_TIME_TOLERANCE)
)
{
return 1;
}
else if(
timesBuffer[index] < 0 &&
isTime(timesBuffer[index+1], LARGE_TIME, true, LARGE_TIME_TOLERANCE) &&
isTime(timesBuffer[index+2], SMALL_TIME, false, SMALL_TIME_TOLERANCE) //&&
//isTime(timesBuffer[index+3], SMALL_TIME, true, SMALL_TIME_TOLERANCE)
)
{
return 0;
}
else return -1;
}
void W433DataReciver::waitForReciveIdle(const uint16_t timeoutMs)
{
uint16_t counter = 0;
while(true)
{
while(counter < timeoutMs && state != LOOKING_FOR_SYNC)
{
_delay_ms(1);
++counter;
}
_delay_ms(500);
counter+=500;
if(state == LOOKING_FOR_SYNC || counter >= timeoutMs) break;
}
uint16_t counter = 0;
while(true)
{
while(counter < timeoutMs && state != LOOKING_FOR_SYNC)
{
_delay_ms(1);
++counter;
}
_delay_ms(500);
counter+=500;
if(state == LOOKING_FOR_SYNC || counter >= timeoutMs) break;
}
}
bool W433DataReciver::isTime(int16_t input, const uint16_t time, const bool state, const uint16_t tollerance)
{
if((state && input < 0) || (!state && input > 0)) return false;
input = abs(input);
return input < (int16_t)(time+tollerance) && input > (int16_t)(time-tollerance);
if((state && input < 0) || (!state && input > 0)) return false;
input = abs(input);
return input < (int16_t)(time+tollerance) && input > (int16_t)(time-tollerance);
}
bool W433DataReciver::reciveSync(const uint16_t elapsedTime)
{
if(elapsedTime < SYNC_TIME+SYNC_TIME_TOLERANCE && elapsedTime > SYNC_TIME-SYNC_TIME_TOLERANCE)
{
++syncCount;
}
else
if(elapsedTime < SYNC_TIME+SYNC_TIME_TOLERANCE && elapsedTime > SYNC_TIME-SYNC_TIME_TOLERANCE)
{
++syncCount;
}
else
{
if(syncCount > 4 && syncFailCount < 3) ++syncFailCount;
else
else
{
//if(syncCount > 7) error(ERR_SYNC_FAIL);
setState(LOOKING_FOR_SYNC);
}
}
if(syncCount > 10) return true;
else return false;
if(syncCount > 10) return true;
else return false;
}
bool W433DataReciver::recivedByte(const uint16_t elapsedTime)
{
timesBuffer[timesBufferIndex] = readPin(_port, _pin) ? 0-elapsedTime : elapsedTime;
++timesBufferIndex;
timesBuffer[timesBufferIndex] = readPin(_port, _pin) ? 0-elapsedTime : elapsedTime;
++timesBufferIndex;
if(timesBufferIndex == 32) writePin(&PORTC, PC0, true);
return timesBufferIndex == 32;
return timesBufferIndex == 32;
}
uint8_t W433DataReciver::assmbleByte()
{
uint8_t byte = 0;
for(uint8_t i = 0; i < 8; ++i)
{
int8_t bit = reciveBit(i*4);
if(bit >= 0) byte = byte | (bit << (7-i));
else
uint8_t byte = 0;
for(uint8_t i = 0; i < 8; ++i)
{
int8_t bit = reciveBit(i*4);
if(bit >= 0) byte = byte | (bit << (7-i));
else
{
setState(LOOKING_FOR_SYNC);
error(ERR_BYTE_ASM);
}
}
timesBufferIndex = 0;
return byte;
}
timesBufferIndex = 0;
return byte;
}
void W433DataReciver::error(const uint8_t errorCode)
@ -123,18 +126,19 @@ void W433DataReciver::error(const uint8_t errorCode)
void W433DataReciver::setState(const uint8_t stateIn)
{
state = stateIn;
timesBufferIndex = 0;
packetIndex = 0;
state = stateIn;
timesBufferIndex = 0;
packetIndex = 0;
syncCount = 0;
syncFailCount = 0;
}
void W433DataReciver::interrupt()
{
uint16_t elapsedTime = polarity*(((*_timerOverflowRegister & 0x01) ? *_timerRegister+(UINT16_MAX - previousTime) : *_timerRegister - previousTime)/TICKS_PER_US);
if(elapsedTime < DISCARD_TIME)
uint16_t elapsedTime = polarity*(((*_timerOverflowRegister & 0x01) ? *_timerRegister+
(UINT16_MAX - previousTime) : *_timerRegister - previousTime)/TICKS_PER_US);
if(elapsedTime < DISCARD_TIME)
{
if(timesBufferIndex > 0 && elapsedTime + abs(timesBuffer[timesBufferIndex-1]) < LARGE_TIME+LARGE_TIME_TOLERANCE)
{
@ -144,89 +148,90 @@ void W433DataReciver::interrupt()
}
return;
}
previousTime = *_timerRegister;
previousTime = *_timerRegister;
*_timerOverflowRegister = *_timerOverflowRegister | 0x01;
if(state == LOOKING_FOR_SYNC && reciveSync(elapsedTime))
{
setState(LOOKING_FOR_SYNC_END);
}
else if(state == LOOKING_FOR_SYNC_END)
{
if(elapsedTime > SYNC_TIME + SYNC_END_TIME_TOLERANCE)
{
if(elapsedTime < LARGE_TIME - LARGE_TIME_TOLERANCE)
if(state == LOOKING_FOR_SYNC && reciveSync(elapsedTime))
{
setState(LOOKING_FOR_SYNC_END);
}
else if(state == LOOKING_FOR_SYNC_END)
{
if(elapsedTime > SYNC_TIME + SYNC_END_TIME_TOLERANCE)
{
if(elapsedTime < LARGE_TIME - LARGE_TIME_TOLERANCE)
{
setState(LOOKING_FOR_SYNC);
error(ERR_NO_SYNC_END);
}
else
{
timesBuffer[0] = -LARGE_TIME;
setState(LOOKING_FOR_SIGNATURE);
++timesBufferIndex;
}
}
}
else if(state == LOOKING_FOR_SIGNATURE)
{
if(recivedByte(elapsedTime))
{
uint8_t recivedSignature = assmbleByte();
if( recivedSignature == signature) setState(RECVING_PACKET);
else
else
{
timesBuffer[0] = -LARGE_TIME;
setState(LOOKING_FOR_SIGNATURE);
++timesBufferIndex;
}
}
}
else if(state == LOOKING_FOR_SIGNATURE)
{
if(recivedByte(elapsedTime))
{
uint8_t recivedSignature = assmbleByte();
if( recivedSignature == signature) setState(RECVING_PACKET);
else
{
error(ERR_WRONG_SIG);
setState(LOOKING_FOR_SYNC);
}
}
}
else if( state == RECVING_PACKET )
{
if(recivedByte(elapsedTime))
{
uint8_t packetByte = assmbleByte();
packet = packet | ((uint32_t)packetByte) << ((3-packetIndex)*8);
++packetIndex;
if(packetIndex > 3)
{
packetIndex = 0;
timesBufferIndex = 0;
setState(RECVING_PACKET_CHECKSUM);
}
}
}
else if(state == RECVING_PACKET_CHECKSUM)
{
if(recivedByte(elapsedTime))
{
uint8_t recivedChecksum = assmbleByte();
volatile uint8_t* buffer = reinterpret_cast<volatile uint8_t*>(&packet);
uint8_t computedChecksum = 0;
for(uint8_t j = 0; j < sizeof(packet); j++) for(uint8_t i = 0; i < 8; i++) computedChecksum = computedChecksum + ((buffer[j] & ( 1 << (8 - i))) >> (8 - i));
//for(uint8_t j = 0; j < sizeof(packet); j++) for(uint8_t i = 0; i < 8; i++) computedChecksum = computedChecksum + (buffer[j] & ( 1 << (8 - i)));
if(computedChecksum == recivedChecksum)
{
#ifdef USE_RINGBUFFER
_ringBuffer.write(const_cast<uint8_t*>(buffer), sizeof(packet));
#endif
if(_packetCallback != nullptr)(*_packetCallback)(packet, _userData);
}
else error(ERR_CHECKSUM);
packet = 0;
setState(LOOKING_FOR_SYNC);
}
}
}
}
else if( state == RECVING_PACKET )
{
if(recivedByte(elapsedTime))
{
uint8_t packetByte = assmbleByte();
packet = packet | ((uint32_t)packetByte) << ((3-packetIndex)*8);
++packetIndex;
if(packetIndex > 3)
{
packetIndex = 0;
timesBufferIndex = 0;
setState(RECVING_PACKET_CHECKSUM);
}
}
}
else if(state == RECVING_PACKET_CHECKSUM)
{
if(recivedByte(elapsedTime))
{
uint8_t recivedChecksum = assmbleByte();
volatile uint8_t* buffer = reinterpret_cast<volatile uint8_t*>(&packet);
uint8_t computedChecksum = 0;
for(uint8_t j = 0; j < sizeof(packet); j++) for(uint8_t i = 0; i < 8;
i++) computedChecksum = computedChecksum + ((buffer[j] & ( 1 << (8 - i))) >> (8 - i));
//for(uint8_t j = 0; j < sizeof(packet); j++) for(uint8_t i = 0; i < 8; i++) computedChecksum = computedChecksum + (buffer[j] & ( 1 << (8 - i)));
if(computedChecksum == recivedChecksum)
{
#ifdef USE_RINGBUFFER
_ringBuffer.write(const_cast<uint8_t*>(buffer), sizeof(packet));
#endif
if(_packetCallback != nullptr)(*_packetCallback)(packet, _userData);
}
else error(ERR_CHECKSUM);
packet = 0;
setState(LOOKING_FOR_SYNC);
}
}
}
#ifdef USE_RINGBUFFER
RingBuffer<W433DataReciver::RINGBUFFER_LENGTH, uint8_t>* W433DataReciver::getRingBuffer()
{
return &_ringBuffer;
return &_ringBuffer;
}
#endif

124
W433DataReciver.h
View File

@ -7,88 +7,90 @@
class W433DataReciver
{
public:
static constexpr uint8_t RINGBUFFER_LENGTH = 32;
static constexpr uint8_t RINGBUFFER_LENGTH = 32;
//errors
static constexpr uint8_t ERR_SYNC_FAIL = 1;
static constexpr uint8_t ERR_NO_SYNC_END = 2;
static constexpr uint8_t ERR_BYTE_ASM = 3;
static constexpr uint8_t ERR_WRONG_SIG = 4;
static constexpr uint8_t ERR_CHECKSUM = 5;
private:
static W433DataReciver* instance;
//constants
static W433DataReciver* instance;
//constants
static constexpr uint8_t CLOCK_DEVIDER = 1;
static constexpr uint16_t LARGE_TIME = 2000;
static constexpr uint16_t SMALL_TIME = 500;
static constexpr uint16_t SYNC_TIME = 800;
static constexpr uint16_t LARGE_TIME = 2000;
static constexpr uint16_t SMALL_TIME = 500;
static constexpr uint16_t SYNC_TIME = 800;
static constexpr uint8_t SYNC_TIME_TOLERANCE = SYNC_TIME*0.20;
static constexpr uint16_t SYNC_END_TIME_TOLERANCE = SYNC_TIME*0.50;
static constexpr uint16_t LARGE_TIME_TOLERANCE = LARGE_TIME*0.30;
static constexpr uint8_t SMALL_TIME_TOLERANCE = SMALL_TIME*0.30;
static constexpr uint16_t DISCARD_TIME = SMALL_TIME*0.6;
static constexpr uint16_t TICKS_PER_US = (F_CPU) / (1000000*CLOCK_DEVIDER);
static constexpr uint8_t signature = 0xA5;
static constexpr int8_t polarity = 1;
static constexpr uint8_t LOOKING_FOR_SYNC = 0;
static constexpr uint8_t LOOKING_FOR_SYNC_END = 1;
static constexpr uint8_t LOOKING_FOR_SIGNATURE = 2;
static constexpr uint8_t RECVING_PACKET = 3;
static constexpr uint8_t RECVING_PACKET_CHECKSUM = 4;
//variables
volatile unsigned char *_port;
unsigned char _pin;
static constexpr uint16_t TICKS_PER_US = (F_CPU) / (1000000*CLOCK_DEVIDER);
static constexpr uint8_t signature = 0xA5;
static constexpr int8_t polarity = 1;
static constexpr uint8_t LOOKING_FOR_SYNC = 0;
static constexpr uint8_t LOOKING_FOR_SYNC_END = 1;
static constexpr uint8_t LOOKING_FOR_SIGNATURE = 2;
static constexpr uint8_t RECVING_PACKET = 3;
static constexpr uint8_t RECVING_PACKET_CHECKSUM = 4;
//variables
volatile unsigned char *_port;
unsigned char _pin;
volatile uint16_t *_timerRegister;
volatile uint8_t *_timerOverflowRegister;
#ifdef USE_RINGBUFFER
RingBuffer<RINGBUFFER_LENGTH, uint8_t> _ringBuffer;
RingBuffer<RINGBUFFER_LENGTH, uint8_t> _ringBuffer;
#endif
volatile uint16_t previousTime = 0;
volatile uint8_t timesBufferIndex = 0;
volatile int16_t timesBuffer[33];
volatile uint8_t packetIndex = 0;
volatile uint32_t packet = 0;
void (* const _packetCallback)(uint32_t, void*);
volatile uint16_t previousTime = 0;
volatile uint8_t timesBufferIndex = 0;
volatile int16_t timesBuffer[33];
volatile uint8_t packetIndex = 0;
volatile uint32_t packet = 0;
void (* const _packetCallback)(uint32_t, void*);
void (* const _errorCodeHandler)(uint8_t, void*);
void* const _userData;
volatile uint8_t syncCount = 0;
void* const _userData;
volatile uint8_t syncCount = 0;
volatile uint8_t syncFailCount = 0;
volatile uint8_t state = 0;
//private functions
int8_t reciveBit(uint8_t index);
inline uint8_t assmbleByte();
inline void setState(const uint8_t stateIn);
inline bool recivedByte(const uint16_t elapsedTime);
inline bool reciveSync(const uint16_t elapsedTime);
volatile uint8_t state = 0;
//private functions
int8_t reciveBit(uint8_t index);
inline uint8_t assmbleByte();
inline void setState(const uint8_t stateIn);
inline bool recivedByte(const uint16_t elapsedTime);
inline bool reciveSync(const uint16_t elapsedTime);
inline void error(const uint8_t errorCode);
static inline bool isTime(int16_t input, const uint16_t time, const bool state = true, const uint16_t tollerance = 100);
static inline bool isTime(int16_t input, const uint16_t time, const bool state = true, const uint16_t tollerance = 100);
public:
W433DataReciver(volatile unsigned char* const port , const unsigned char pin, volatile uint16_t * timerRegister, volatile uint8_t* const timerOverflowRegister, void (*packetCallback)(uint32_t, void*) = nullptr, void* userData = nullptr, void (*errorCodeHandler)(uint8_t, void*) = nullptr );
~W433DataReciver();
static void initTimer();
static void staticInterrupt();
void waitForReciveIdle(const uint16_t timeoutMs = 10000);
void interrupt();
W433DataReciver(volatile unsigned char* const port, const unsigned char pin, volatile uint16_t * timerRegister,
volatile uint8_t* const timerOverflowRegister, void (*packetCallback)(uint32_t, void*) = nullptr,
void* userData = nullptr, void (*errorCodeHandler)(uint8_t, void*) = nullptr );
~W433DataReciver();
static void initTimer();
static void staticInterrupt();
void waitForReciveIdle(const uint16_t timeoutMs = 10000);
void interrupt();
#ifdef USE_RINGBUFFER
RingBuffer<RINGBUFFER_LENGTH, uint8_t>* getRingBuffer();
RingBuffer<RINGBUFFER_LENGTH, uint8_t>* getRingBuffer();
#endif
};

120
W433DataTransmitter.cpp
View File

@ -5,94 +5,94 @@ W433DataTransmitter::W433DataTransmitter(volatile unsigned char *port, const uns
{
}
void W433DataTransmitter::sendBit(const bool bit)
{
switch(bit)
{
case true:
void W433DataTransmitter::sendBit(const bool bit)
{
switch(bit)
{
case true:
writePin(_port,_pin,true);
_delay_us(SMALL_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
writePin(_port,_pin,true);
_delay_us(SMALL_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
break;
_delay_us(SMALL_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
writePin(_port,_pin,true);
_delay_us(SMALL_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
break;
case false:
writePin(_port,_pin,true);
_delay_us(LARGE_TIME);
writePin(_port,_pin,false);
_delay_us(SMALL_TIME);
writePin(_port,_pin,true);
_delay_us(SMALL_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
break;
}
case false:
writePin(_port,_pin,true);
_delay_us(LARGE_TIME);
writePin(_port,_pin,false);
_delay_us(SMALL_TIME);
writePin(_port,_pin,true);
_delay_us(SMALL_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
break;
}
}
void W433DataTransmitter::sendSyncpulse()
{
for(uint8_t i = 0; i < 25; ++i)
{
writePin(_port,_pin,true);
_delay_us(SYNC_TIME);
writePin(_port,_pin,false);
_delay_us(SYNC_TIME);
}
for(uint8_t i = 0; i < 25; ++i)
{
writePin(_port,_pin,true);
_delay_us(SYNC_TIME);
writePin(_port,_pin,false);
_delay_us(SYNC_TIME);
}
}
void W433DataTransmitter::sendEndPulse()
{
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
writePin(_port,_pin,true);
_delay_us(LARGE_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME*10);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
writePin(_port,_pin,true);
_delay_us(LARGE_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME*10);
}
void W433DataTransmitter::sendRawData(const uint8_t data)
{
for(uint8_t i = 0; i < 8; i++) sendBit(data & ( 1 << (7 - i)));
for(uint8_t i = 0; i < 8; i++) sendBit(data & ( 1 << (7 - i)));
}
void W433DataTransmitter::sendPacket(const uint32_t data)
{
sendSyncpulse();
_delay_us(LARGE_TIME);
sendRawData(signature);
uint8_t checksum = 0;
for(uint8_t i = 0; i < 4; ++i)
{
uint8_t dataOctet = (data & (0xFF000000 >> i*8 )) >> (24 - 8*i);
//for(uint8_t i = 0; i < 8; i++) checksum = checksum + (dataOctet & ( 1 << (8 - i)));
for(uint8_t i = 0; i < 8; i++) checksum = checksum + ((dataOctet & ( 1 << (8 - i))) >> (8 - i));
sendRawData( dataOctet );
}
sendRawData( checksum );
sendEndPulse();
sendSyncpulse();
_delay_us(LARGE_TIME);
sendRawData(signature);
uint8_t checksum = 0;
for(uint8_t i = 0; i < 4; ++i)
{
uint8_t dataOctet = (data & (0xFF000000 >> i*8 )) >> (24 - 8*i);
//for(uint8_t i = 0; i < 8; i++) checksum = checksum + (dataOctet & ( 1 << (8 - i)));
for(uint8_t i = 0; i < 8; i++) checksum = checksum + ((dataOctet & ( 1 << (8 - i))) >> (8 - i));
sendRawData( dataOctet );
}
sendRawData( checksum );
sendEndPulse();
}
void W433DataTransmitter::send(const uint8_t* const data, uint16_t length)
{
uint16_t packets = length/4;
if(length % 4 != 0) ++packets;
for(uint8_t j = 0; j < packets; j++)
{
uint32_t paketData = 0;
uint8_t* paketDataPointer = reinterpret_cast<uint8_t*>(&paketData);
for(uint8_t i = 0; i < 4 && j*4+i < length; i++) paketDataPointer[3-i] = data[j*4+i];
sendPacket(paketData);
}
for(uint8_t j = 0; j < packets; j++)
{
uint32_t paketData = 0;
uint8_t* paketDataPointer = reinterpret_cast<uint8_t*>(&paketData);
for(uint8_t i = 0; i < 4 && j*4+i < length; i++) paketDataPointer[3-i] = data[j*4+i];
sendPacket(paketData);
}
}
void W433DataTransmitter::send(const uint8_t data)
{
sendPacket(data);
sendPacket(data);
}

38
W433DataTransmitter.h
View File

@ -7,24 +7,24 @@
class W433DataTransmitter
{
private:
static constexpr uint16_t LARGE_TIME = 2000;
static constexpr uint16_t SMALL_TIME = 500;
static constexpr uint16_t SYNC_TIME = 800;
static constexpr uint8_t signature = 0xA5;
volatile unsigned char * const _port;
const unsigned char _pin;
void sendBit(const bool bit);
void sendSyncpulse();
void sendRawData(const uint8_t data);
void sendEndPulse();
static constexpr uint16_t LARGE_TIME = 2000;
static constexpr uint16_t SMALL_TIME = 500;
static constexpr uint16_t SYNC_TIME = 800;
static constexpr uint8_t signature = 0xA5;
volatile unsigned char * const _port;
const unsigned char _pin;
void sendBit(const bool bit);
void sendSyncpulse();
void sendRawData(const uint8_t data);
void sendEndPulse();
public:
W433DataTransmitter(volatile unsigned char * const port, const unsigned char pin);
void send(const uint8_t* const data, uint16_t length);
void send(const uint8_t data);
void sendPacket(const uint32_t data);
W433DataTransmitter(volatile unsigned char * const port, const unsigned char pin);
void send(const uint8_t* const data, uint16_t length);
void send(const uint8_t data);
void sendPacket(const uint32_t data);
};

100
WirelessRelay.cpp
View File

@ -7,63 +7,63 @@ unsigned char _pin = PB5;
void WirelessRelay::sendId()
{
writePin(_port,_pin,true);
_delay_us(SMALL_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
for(short i = 0; i<10; i++)
{
sendBit( id & 1 << (15 - i) );
}
writePin(_port,_pin,true);
_delay_us(SMALL_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
for(short i = 0; i<10; i++)
{
sendBit( id & 1 << (15 - i) );
}
}
void WirelessRelay::sendBit(const bool in)
{
switch(in)
{
case true:
//Der Code fuer '0'
writePin(_port,_pin,true);
_delay_us(SMALL_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
writePin(_port,_pin,true);
_delay_us(SMALL_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
break;
void WirelessRelay::sendBit(const bool in)
{
switch(in)
{
case true:
//Der Code fuer '0'
writePin(_port,_pin,true);
_delay_us(SMALL_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
writePin(_port,_pin,true);
_delay_us(SMALL_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
break;
case false:
//Der Code fuer '1'
writePin(_port,_pin,true);
_delay_us(LARGE_TIME);
writePin(_port,_pin,false);
_delay_us(SMALL_TIME);
writePin(_port,_pin,true);
_delay_us(SMALL_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
break;
}
case false:
//Der Code fuer '1'
writePin(_port,_pin,true);
_delay_us(LARGE_TIME);
writePin(_port,_pin,false);
_delay_us(SMALL_TIME);
writePin(_port,_pin,true);
_delay_us(SMALL_TIME);
writePin(_port,_pin,false);
_delay_us(LARGE_TIME);
break;
}
}
void WirelessRelay::sync()
{
writePin(_port,_pin,false);
_delay_us(SMALL_TIME*31);
writePin(_port,_pin,false);
_delay_us(SMALL_TIME*31);
}
void WirelessRelay::setValue(const uint8_t value)
{
lastValue = value;
for(short z = 0; z<10; z++)
{
sendId();
sendBit(value);
sendBit(!value);
sync();
}
for(short z = 0; z<10; z++)
{
sendId();
sendBit(value);
sendBit(!value);
sync();
}
}
void WirelessRelay::resend()
@ -73,13 +73,13 @@ void WirelessRelay::resend()
WirelessRelay::WirelessRelay(const uint16_t idIn, char nameIn[])
{
id = idIn;
setName(nameIn);
type = 0;
id = idIn;
setName(nameIn);
type = 0;
}
WirelessRelay::WirelessRelay(const Item& item)
{
Item::operator=(item);
type = 0;
Item::operator=(item);
type = 0;
}

24
WirelessRelay.h
View File

@ -8,20 +8,20 @@
class WirelessRelay: public Item
{
public:
static constexpr uint16_t LARGE_TIME = 750;
static constexpr uint8_t SMALL_TIME = 250;
static constexpr uint16_t MAX_NAME_LENGTH = 16;
static constexpr uint16_t LARGE_TIME = 750;
static constexpr uint8_t SMALL_TIME = 250;
static constexpr uint16_t MAX_NAME_LENGTH = 16;
private:
void sendBit(const bool i);
void sync();
void sendId();
void sendBit(const bool i);
void sync();
void sendId();
public:
WirelessRelay(const uint16_t idIn, char nameIn[]);
WirelessRelay(const Item& item);
void setValue(const uint8_t value);
WirelessRelay(const uint16_t idIn, char nameIn[]);
WirelessRelay(const Item& item);
void setValue(const uint8_t value);
void resend();
};
#endif

10
bitrep.h
View File

@ -1,9 +1,9 @@
#pragma once
const char *bit_rep[16] =
const char *bit_rep[16] =
{
[ 0] = "0000", [ 1] = "0001", [ 2] = "0010", [ 3] = "0011",
[ 4] = "0100", [ 5] = "0101", [ 6] = "0110", [ 7] = "0111",
[ 8] = "1000", [ 9] = "1001", [10] = "1010", [11] = "1011",
[12] = "1100", [13] = "1101", [14] = "1110", [15] = "1111",
[ 0] = "0000", [ 1] = "0001", [ 2] = "0010", [ 3] = "0011",
[ 4] = "0100", [ 5] = "0101", [ 6] = "0110", [ 7] = "0111",
[ 8] = "1000", [ 9] = "1001", [10] = "1010", [11] = "1011",
[12] = "1100", [13] = "1101", [14] = "1110", [15] = "1111",
};

48
eeprom.h
View File

@ -1,51 +1,51 @@
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);
//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;
// 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] );
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);
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, 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)
{
char data[sizeof(T)];
EEPROM_read_string( address, data, sizeof(T) );
return *reinterpret_cast<T*>(data);
char data[sizeof(T)];
EEPROM_read_string( address, data, sizeof(T) );
return *reinterpret_cast<T*>(data);
}
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) );
}

4
item.cpp
View File

@ -3,7 +3,7 @@
void Item::setName(const char * const nameN)
{
size_t len = strlen(nameN);
if(len < MAX_NAME_LENGTH)memcpy(name, nameN, len+1);
size_t len = strlen(nameN);
if(len < MAX_NAME_LENGTH)memcpy(name, nameN, len+1);
}

14
item.h
View File

@ -4,11 +4,11 @@
class Item
{
public:
static constexpr uint16_t MAX_NAME_LENGTH = 16;
bool lastValue = 0;
uint16_t id;
char name[MAX_NAME_LENGTH]="";
uint8_t type = 0;
void setName(const char * const name);
static constexpr uint16_t MAX_NAME_LENGTH = 16;
bool lastValue = 0;
uint16_t id;
char name[MAX_NAME_LENGTH]="";
uint8_t type = 0;
void setName(const char * const name);
};

634
main.cpp
View File

@ -33,13 +33,13 @@ static bool resendEnabled = false;
ISR(PCINT1_vect)
{
W433DataReciver::staticInterrupt();
W433DataReciver::staticInterrupt();
}
ISR(WDT_vect)
{
if(++resendCounter > 225)
{
{
resendCounter = 0;
if(resendEnabled)resendNow = true;
}
@ -47,8 +47,8 @@ ISR(WDT_vect)
inline static void printHelp(Serial* serial)
{
serial->write_p(PSTR("Available Commands: \n\
serial->write_p(PSTR("Available Commands: \n\
help : Show this prompt.\n\
item add [id] [type] [name]: Add Wireless item. Save to make permant.\n\
item delete [n] : Delete n'th item. Save to make permant.\n\
@ -82,7 +82,7 @@ int freeRAM()
void save()
{
EEPROM_write_char(4, resendEnabled);
EEPROM_write_class< SVector<Item, MAX_ITEMS> > (ITEM_VECTOR_EEPROM_ADDR, items);
EEPROM_write_class< SVector<Item, MAX_ITEMS> > (ITEM_VECTOR_EEPROM_ADDR, items);
}
void loadRGB(RgbLed* rgbled)
@ -93,47 +93,48 @@ void loadRGB(RgbLed* rgbled)
void load()
{
resendEnabled = EEPROM_read_char(4);
EEPROM_read_class< SVector<Item, MAX_ITEMS> > (ITEM_VECTOR_EEPROM_ADDR, &items);
EEPROM_read_class< SVector<Item, MAX_ITEMS> > (ITEM_VECTOR_EEPROM_ADDR, &items);
}
void writeItemState(Serial* serial, Item* relay, uint8_t number)
{
const uint16_t id = relay->id;
snprintf(buffer, SNPRINTF_BUFFER_SIZE, "ITEM NUMBER: %u ID: %s%s%s%s TYPE: %u STATE: %u NAME: %s\n", number,
bit_rep[ id >> 12],
bit_rep[(id & 0x0F00) >> 8 ],
bit_rep[(id & 0x00F0) >> 4 ],
bit_rep[(id & 0x000F)],
relay->type,
relay->lastValue,
relay->name
);
snprintf(buffer, SNPRINTF_BUFFER_SIZE, "ITEM NUMBER: %u ID: %s%s%s%s TYPE: %u STATE: %u NAME: %s\n", number,
bit_rep[ id >> 12],
bit_rep[(id & 0x0F00) >> 8 ],
bit_rep[(id & 0x00F0) >> 4 ],
bit_rep[(id & 0x000F)],
relay->type,
relay->lastValue,
relay->name
);
serial->write(buffer, SNPRINTF_BUFFER_SIZE);
}
void itemDispatch(SVector<Item, MAX_ITEMS>* items, Pwm16b* auxPwm, char* token, Serial* serial)
{
if( strcmp(token, "add") == 0 )
{
token = strtok(NULL, " \n");
uint16_t id = strtol(token, nullptr, 2 );
token = strtok(NULL, " \n");
uint8_t type = strtol(token, nullptr, 10 );
if(id != 0 && (type == 0 || type == 1) && items->remainingCapacity() > 0)
{
token = strtok(NULL, "\n\0");
Item item;
item.id = id;
item.type = type;
if( token != NULL ) item.setName(token);
items->push_back(item);
writeItemState(serial, &items->back(), items->count()-1);
}
else if(items->remainingCapacity() == 0) serial->write_p(PSTR("Relay storage full.\n"));
else serial->write_p(PSTR("Usage: item add [id] [type] [name]\n [id] being a 16bit binary nummber and [name] an optional string\n"));
}
else if( strcmp(token, "delete") == 0 )
{
if( strcmp(token, "add") == 0 )
{
token = strtok(NULL, " \n");
uint16_t id = strtol(token, nullptr, 2 );
token = strtok(NULL, " \n");
uint8_t type = strtol(token, nullptr, 10 );
if(id != 0 && (type == 0 || type == 1) && items->remainingCapacity() > 0)
{
token = strtok(NULL, "\n\0");
Item item;
item.id = id;
item.type = type;
if( token != NULL ) item.setName(token);
items->push_back(item);
writeItemState(serial, &items->back(), items->count()-1);
}
else if(items->remainingCapacity() == 0) serial->write_p(PSTR("Relay storage full.\n"));
else serial->write_p(
PSTR("Usage: item add [id] [type] [name]\n [id] being a 16bit binary nummber and [name] an optional string\n"));
}
else if( strcmp(token, "delete") == 0 )
{
token = strtok(NULL, " \n");
if(items->count() > 0)
{
@ -143,248 +144,250 @@ void itemDispatch(SVector<Item, MAX_ITEMS>* items, Pwm16b* auxPwm, char* token,
serial->write(buffer, SNPRINTF_BUFFER_SIZE);
items->erase(index);
}
}
else if( strcmp(token, "on") == 0 )
{
char* token = strtok(NULL, " \n");
if( token != NULL)
{
uint8_t selected = strtol(token, nullptr, 10);
if (selected < items->count())
{
}
else if( strcmp(token, "on") == 0 )
{
char* token = strtok(NULL, " \n");
if( token != NULL)
{
uint8_t selected = strtol(token, nullptr, 10);
if (selected < items->count())
{
items->at(selected).lastValue = true;
if(items->at(selected).type == 0)WirelessRelay(items->at(selected)).setValue(true);
else UvosItem(items->at(selected)).setValue(true);
writeItemState(serial, &items->at(selected), selected);
}
else serial->write_p(PSTR("No sutch item\n"));
}
else serial->write_p(PSTR("Usage: item on [nn]\n"));
}
else if( strcmp(token, "off") == 0 )
{
char* token = strtok(NULL, " \n");
if( token != NULL)
{
uint8_t selected = strtol(token, nullptr, 10);
if (selected < items->count())
{
else UvosItem(items->at(selected)).setValue(true);
writeItemState(serial, &items->at(selected), selected);
}
else serial->write_p(PSTR("No sutch item\n"));
}
else serial->write_p(PSTR("Usage: item on [nn]\n"));
}
else if( strcmp(token, "off") == 0 )
{
char* token = strtok(NULL, " \n");
if( token != NULL)
{
uint8_t selected = strtol(token, nullptr, 10);
if (selected < items->count())
{
items->at(selected).lastValue = false;
if(items->at(selected).type == 0)WirelessRelay(items->at(selected)).setValue(false);
else UvosItem(items->at(selected)).setValue(false);
writeItemState(serial, &items->at(selected), selected);
}
else serial->write_p(PSTR("No sutch item\n"));
}
else serial->write_p(PSTR("Usage: item off [nn]\n"));
}
else if( strcmp(token, "resend") == 0 )
{
char* token = strtok(NULL, " \n");
if(items->at(selected).type == 0)WirelessRelay(items->at(selected)).setValue(false);
else UvosItem(items->at(selected)).setValue(false);
writeItemState(serial, &items->at(selected), selected);
}
else serial->write_p(PSTR("No sutch item\n"));
}
else serial->write_p(PSTR("Usage: item off [nn]\n"));
}
else if( strcmp(token, "resend") == 0 )
{
char* token = strtok(NULL, " \n");
serial->write_p(PSTR("Resend every 30 min is "));
if( token != NULL )
{
if( token != NULL )
{
serial->write_p(PSTR("now "));
if(strcmp(token, "on") == 0) resendEnabled = true;
if(strcmp(token, "on") == 0) resendEnabled = true;
else resendEnabled = false;
}
resendEnabled ? serial->write_p(PSTR("enabled.\n")) : serial->write_p(PSTR("disabled.\n")) ;
}
else
{
serial->write(token);
serial->write_p(PSTR(" is not a valid subcommand: item [add/delete/on/off]\n"));
}
}
resendEnabled ? serial->write_p(PSTR("enabled.\n")) : serial->write_p(PSTR("disabled.\n")) ;
}
else
{
serial->write(token);
serial->write_p(PSTR(" is not a valid subcommand: item [add/delete/on/off]\n"));
}
}
void rgbDispatch(RgbLed* rgbled, char* token, Serial* serial)
{
if( strcmp(token, "on") == 0 )
{
rgbled->on();
serial->write_p(PSTR("RGB lights on\n"));
}
else if( strcmp(token, "off") == 0 )
{
rgbled->off();
serial->write_p(PSTR("RGB lights off\n"));
}
else if( strcmp(token, "print") == 0 )
{
snprintf(buffer, SNPRINTF_BUFFER_SIZE, "Current RGB values:\nR: %u G: %u B: %u\n", rgbled->getR(), rgbled->getG(), rgbled->getB());
serial->write(buffer, SNPRINTF_BUFFER_SIZE);
}
else if( strcmp(token, "set") == 0 )
{
char* rToken = strtok(NULL, " \n");
char* gToken = strtok(NULL, " \n");
char* bToken = strtok(NULL, " \n");
if(rToken != NULL && gToken != NULL && bToken != NULL)
{
if( strcmp(token, "on") == 0 )
{
rgbled->on();
serial->write_p(PSTR("RGB lights on\n"));
}
else if( strcmp(token, "off") == 0 )
{
rgbled->off();
serial->write_p(PSTR("RGB lights off\n"));
}
else if( strcmp(token, "print") == 0 )
{
snprintf(buffer, SNPRINTF_BUFFER_SIZE, "Current RGB values:\nR: %u G: %u B: %u\n", rgbled->getR(), rgbled->getG(),
rgbled->getB());
serial->write(buffer, SNPRINTF_BUFFER_SIZE);
}
else if( strcmp(token, "set") == 0 )
{
char* rToken = strtok(NULL, " \n");
char* gToken = strtok(NULL, " \n");
char* bToken = strtok(NULL, " \n");
if(rToken != NULL && gToken != NULL && bToken != NULL)
{
uint8_t r = atoi(rToken);
uint8_t g = atoi(gToken);
uint8_t b = atoi(bToken);
rgbled->setSolidColor(r,g,b);
rgbled->setSolidColor(r,g,b);
EEPROM_write_char(1, r);
EEPROM_write_char(2, g);
EEPROM_write_char(3, b);
serial->write_p(PSTR("Set RGB values\n"));
}
else serial->write_p(PSTR("Usage: rgb set [RRR] [GGG] [BBB]\n"));
}
else if( strcmp(token, "pattern") == 0 )
{
token = strtok(NULL, " \n");
if( token != NULL )
{
rgbled->setPattern(atoi(token));
serial->write_p(PSTR("Set Pattern\n"));
}
else serial->write_p(PSTR("Usage: rgb pattern [id]\n"));
}
else if( strcmp(token, "preset") == 0 )
{
token = strtok(NULL, " \n");
if( token != NULL )
{
rgbled->setPreset(atoi(token));
serial->write_p(PSTR("Set Preset\n"));
}
else serial->write_p(PSTR("Usage: rgb preset [ID]\n"));
}
else if( strcmp(token, "fade") == 0 )
{
token = strtok(NULL, " \n");
if( token != NULL )
{
if( strcmp(token, "on") == 0 )
{
rgbled->setFade(true);
serial->write_p(PSTR("Turned on Fade\n"));
}
else
{
rgbled->setFade(false);
serial->write_p(PSTR("Turned off Fade\n"));
}
}
else serial->write_p(PSTR("Usage: rgb fade [on/off]\n"));
}
else
{
serial->write(token);
serial->write_p(PSTR(" is not a valid subcommand: rgb [on/off/print/set/pattern/preset/fade]\n"));
}
serial->write_p(PSTR("Set RGB values\n"));
}
else serial->write_p(PSTR("Usage: rgb set [RRR] [GGG] [BBB]\n"));
}
else if( strcmp(token, "pattern") == 0 )
{
token = strtok(NULL, " \n");
if( token != NULL )
{
rgbled->setPattern(atoi(token));
serial->write_p(PSTR("Set Pattern\n"));
}
else serial->write_p(PSTR("Usage: rgb pattern [id]\n"));
}
else if( strcmp(token, "preset") == 0 )
{
token = strtok(NULL, " \n");
if( token != NULL )
{
rgbled->setPreset(atoi(token));
serial->write_p(PSTR("Set Preset\n"));
}
else serial->write_p(PSTR("Usage: rgb preset [ID]\n"));
}
else if( strcmp(token, "fade") == 0 )
{
token = strtok(NULL, " \n");
if( token != NULL )
{
if( strcmp(token, "on") == 0 )
{
rgbled->setFade(true);
serial->write_p(PSTR("Turned on Fade\n"));
}
else
{
rgbled->setFade(false);
serial->write_p(PSTR("Turned off Fade\n"));
}
}
else serial->write_p(PSTR("Usage: rgb fade [on/off]\n"));
}
else
{
serial->write(token);
serial->write_p(PSTR(" is not a valid subcommand: rgb [on/off/print/set/pattern/preset/fade]\n"));
}
}
void auxDispatch(Pwm16b* auxPwm, char* token, Serial* serial)
{
if(strcmp(token, "set") == 0 )
{
token = strtok(NULL, " \n");
if(token != NULL)
{
{
token = strtok(NULL, " \n");
if(token != NULL)
{
if(atoi(token) == 0) auxPwm->off();
else auxPwm->on();
auxPwm->setDutyA(atoi(token) << 8);
serial->write_p(PSTR("Set PWM value\n"));
}
else serial->write_p(PSTR("Usage: aux set [VALUE]\n"));
}
else
{
serial->write(token, COMMAND_BUFFER_SIZE-4);
serial->write_p(PSTR(" is not a valid subcommand: aux set [value]\n"));
}
auxPwm->setDutyA(atoi(token) << 8);
serial->write_p(PSTR("Set PWM value\n"));
}
else serial->write_p(PSTR("Usage: aux set [VALUE]\n"));
}
else
{
serial->write(token, COMMAND_BUFFER_SIZE-4);
serial->write_p(PSTR(" is not a valid subcommand: aux set [value]\n"));
}
}
void serialDispatch(Serial* serial, SVector<Item, MAX_ITEMS>* items, RgbLed* rgbled, Pwm16b* auxPwm, W433DataReciver* reciver)
void serialDispatch(Serial* serial, SVector<Item, MAX_ITEMS>* items, RgbLed* rgbled, Pwm16b* auxPwm,
W433DataReciver* reciver)
{
if(serial->dataIsWaiting())
{
char buffer[COMMAND_BUFFER_SIZE];
unsigned int length = serial->getString(buffer, COMMAND_BUFFER_SIZE);
if(length > 2)
{
if(serial->dataIsWaiting())
{
char buffer[COMMAND_BUFFER_SIZE];
unsigned int length = serial->getString(buffer, COMMAND_BUFFER_SIZE);
if(length > 2)
{
setBit(&PCICR, PCIE1, false);
char* token = strtok(buffer, " \n");
if(strcmp(token, "item") == 0)
{
reciver->waitForReciveIdle();
itemDispatch(items, auxPwm, strtok(NULL, " \n"), serial);
}
else if(strcmp(token, "rgb") == 0)
{
rgbDispatch(rgbled, strtok(NULL, " \n"), serial);
}
else if(strcmp(token, "aux") == 0)
{
auxDispatch(auxPwm, strtok(NULL, " \n"), serial);
}
else if(strcmp(token, "pause") == 0)
{
sensorsPaused = true;
char* token = strtok(buffer, " \n");
if(strcmp(token, "item") == 0)
{
reciver->waitForReciveIdle();
itemDispatch(items, auxPwm, strtok(NULL, " \n"), serial);
}
else if(strcmp(token, "rgb") == 0)
{
rgbDispatch(rgbled, strtok(NULL, " \n"), serial);
}
else if(strcmp(token, "aux") == 0)
{
auxDispatch(auxPwm, strtok(NULL, " \n"), serial);
}
else if(strcmp(token, "pause") == 0)
{
sensorsPaused = true;
serial->write_p(PSTR("Sensors paused\n"));
}
else if(strcmp(token, "resume") == 0)
{
sensorsPaused = false;
}
else if(strcmp(token, "resume") == 0)
{
sensorsPaused = false;
serial->write_p(PSTR("Sensors resumed\n"));
}
else if(strcmp(token, "state") == 0)
{
serial->write_p(PSTR("Items:\n"));
for(uint8_t i = 0; i < items->count(); i++)
{
writeItemState(serial, &items->at(i), i);
}
serial->write_p(PSTR("EOL\n"));
}
else if(strcmp(token, "save") == 0)
{
save();
serial->write_p(PSTR("State saved to EEPROM.\n"));
}
else if(strcmp(token, "load") == 0)
{
load();
serial->write_p(PSTR("Loaded state from EEPROM.\n"));
}
else if(strcmp(token, "erase") == 0)
{
for(uint16_t i = 0; i < 1024; i++) EEPROM_write_char(i, 0);
serial->write_p(PSTR("EEPROM erased\n"));
load();
}
else if(strcmp(token, "dump") == 0)
{
for(uint16_t i = 0; i < 1024; i++)
{
if(i != 0) serial->putChar(',');
serial->write((uint16_t)EEPROM_read_char(i));
}
serial->putChar('\n');
}
else if(strcmp(token, "free") == 0)
{
serial->write_p(PSTR("Free Ram: "));
}
else if(strcmp(token, "state") == 0)
{
serial->write_p(PSTR("Items:\n"));
for(uint8_t i = 0; i < items->count(); i++)
{
writeItemState(serial, &items->at(i), i);
}
serial->write_p(PSTR("EOL\n"));
}
else if(strcmp(token, "save") == 0)
{
save();
serial->write_p(PSTR("State saved to EEPROM.\n"));
}
else if(strcmp(token, "load") == 0)
{
load();
serial->write_p(PSTR("Loaded state from EEPROM.\n"));
}
else if(strcmp(token, "erase") == 0)
{
for(uint16_t i = 0; i < 1024; i++) EEPROM_write_char(i, 0);
serial->write_p(PSTR("EEPROM erased\n"));
load();
}
else if(strcmp(token, "dump") == 0)
{
for(uint16_t i = 0; i < 1024; i++)
{
if(i != 0) serial->putChar(',');
serial->write((uint16_t)EEPROM_read_char(i));
}
serial->putChar('\n');
}
else if(strcmp(token, "free") == 0)
{
serial->write_p(PSTR("Free Ram: "));
serial->write(freeRAM());
serial->write_p(PSTR(" Bytes.\n"));
}
else if(strcmp(token, "help") == 0)
{
printHelp(serial);
}
else
{
serial->write_p(PSTR("Not a valid command\n"));
}
setBit(&PCICR, PCIE1, true);
}
}
}
else if(strcmp(token, "help") == 0)
{
printHelp(serial);
}
else
{
serial->write_p(PSTR("Not a valid command\n"));
}
setBit(&PCICR, PCIE1, true);
}
}
}
void reciverError(uint8_t code, void* userData)
@ -403,72 +406,73 @@ void sensorPacketRecived(uint32_t data, void* userData)
if(!sensorsPaused)
{
Serial* serial = reinterpret_cast<Serial*>(userData);
uint16_t field = data & 0x0000FFFF;
serial->write_p(PSTR("SENSOR TYPE: "));
serial->write(data >> 24);
serial->write_p(PSTR(" ID: "));
serial->write((data & 0x00FF0000) >> 16);
if(data >> 24 == 1) serial->write_p(PSTR(" TEMPERATURE: "));
else if(data >> 24 == 2) serial->write_p(PSTR(" HUMIDITY: "));
else serial->write_p(PSTR(" FIELD: "));
if(data >> 24 == 1) serial->write_p(PSTR(" TEMPERATURE: "));
else if(data >> 24 == 2) serial->write_p(PSTR(" HUMIDITY: "));
else serial->write_p(PSTR(" FIELD: "));
serial->write(field);
serial->putChar('\n');
}
}
int main()
int main()
{
wdt_set(WDTO_8S);
DDRB = (1 << PB5) | ( 1 << PB1);
DDRD = (1 << PD3) | (1 << PD5)| (1 << PD6);
//door watcher
PORTB = (1<< PB3) | (1<< PB4); //Enable pull up on door watcher pins;
bool doorOne = readPin(&PINB, PB3);
bool doorTow = readPin(&PINB, PB4);
sei();
Serial serial;
Pwm8b pwmTc0( &TCCR0A, &TCCR0B, &OCR0A, &OCR0B, 0b00000011, true, true );
Pwm8b pwmTc2( &TCCR2A, &TCCR2B, &OCR2A, &OCR2B, 0b00000101, false, true );
pwmTc0.off();
pwmTc2.off();
RgbLed rgbled( &pwmTc0, &pwmTc2 );
DDRB = (1 << PB5) | ( 1 << PB1);
DDRD = (1 << PD3) | (1 << PD5)| (1 << PD6);
//door watcher
PORTB = (1<< PB3) | (1<< PB4); //Enable pull up on door watcher pins;
bool doorOne = readPin(&PINB, PB3);
bool doorTow = readPin(&PINB, PB4);
sei();
Serial serial;
Pwm8b pwmTc0( &TCCR0A, &TCCR0B, &OCR0A, &OCR0B, 0b00000011, true, true );
Pwm8b pwmTc2( &TCCR2A, &TCCR2B, &OCR2A, &OCR2B, 0b00000101, false, true );
pwmTc0.off();
pwmTc2.off();
RgbLed rgbled( &pwmTc0, &pwmTc2 );
loadRGB(&rgbled);
Pwm16b pwmTc1 ( &TCCR1A, &TCCR1B, &OCR1A, &OCR1B, &ICR1, 0b00000001, true, false);
Pwm16b pwmTc1 ( &TCCR1A, &TCCR1B, &OCR1A, &OCR1B, &ICR1, 0b00000001, true, false);
setBit(&PCICR, PCIE1, true);
setBit(&PCMSK1, PCINT8, true);
W433DataReciver reciver(&PINC, PC0, &TCNT1, &TIFR1, &sensorPacketRecived, reinterpret_cast<void*>(&serial), &reciverError);
W433DataTransmitter transmitter(&PORTB, PB5);
UvosItem::transmitter=&transmitter;
serial.write_p(PSTR("RGBController v1.5 starting\n"));
load();
while(true)
{
serialDispatch(&serial, &items, &rgbled, &pwmTc1, &reciver);
rgbled.logic();
if(doorOne != readPin(&PINB, PB3) && !sensorsPaused)
{
_delay_ms(10);
if(doorOne != readPin(&PINB, PB3))
{
W433DataReciver reciver(&PINC, PC0, &TCNT1, &TIFR1, &sensorPacketRecived, reinterpret_cast<void*>(&serial),
&reciverError);
W433DataTransmitter transmitter(&PORTB, PB5);
UvosItem::transmitter=&transmitter;
serial.write_p(PSTR("RGBController v1.5 starting\n"));
load();
while(true)
{
serialDispatch(&serial, &items, &rgbled, &pwmTc1, &reciver);
rgbled.logic();
if(doorOne != readPin(&PINB, PB3) && !sensorsPaused)
{
_delay_ms(10);
if(doorOne != readPin(&PINB, PB3))
{
doorOne = readPin(&PINB, PB3);
serial.write_p(PSTR("SENSOR TYPE: "));
serial.putChar('0');
@ -477,15 +481,15 @@ int main()
serial.write_p(PSTR(" STATE: "));
serial.write(doorOne);
serial.putChar('\n');
}
}
if(doorTow != readPin(&PINB, PB4) && !sensorsPaused)
{
_delay_ms(10);
if(doorTow != readPin(&PINB, PB4))
{
}
}
if(doorTow != readPin(&PINB, PB4) && !sensorsPaused)
{
_delay_ms(10);
if(doorTow != readPin(&PINB, PB4))
{
doorTow = readPin(&PINB, PB4);
serial.write_p(PSTR("SENSOR TYPE: "));
serial.putChar('0');
@ -494,22 +498,22 @@ int main()
serial.write_p(PSTR(" STATE: "));
serial.write(doorTow);
serial.putChar('\n');
}
}
if(resendNow)
}
}
if(resendNow)
{
for(uint16_t i = 0; i < items.count(); i++)
for(uint16_t i = 0; i < items.count(); i++)
{
reciver.waitForReciveIdle();
reciver.waitForReciveIdle();
items[i].type == 0 ? WirelessRelay(items[i]).resend() : UvosItem(items[i]).resend();
_delay_ms(100);
}
resendNow = false;
}
_delay_ms(2);
}
_delay_ms(2);
}
return 0;
return 0;
}

124
pwm.cpp
View File

@ -2,136 +2,140 @@
//16bit
Pwm16b::Pwm16b( volatile unsigned char *timerControlRegisterA, volatile unsigned char *timerControlRegisterB, volatile uint16_t *compareRegisterA, volatile uint16_t *compareRegisterB, volatile uint16_t *inputCaptureRegister, const uint8_t speed, const bool enableA, const bool enableB)
Pwm16b::Pwm16b( volatile unsigned char *timerControlRegisterA, volatile unsigned char *timerControlRegisterB,
volatile uint16_t *compareRegisterA, volatile uint16_t *compareRegisterB, volatile uint16_t *inputCaptureRegister,
const uint8_t speed, const bool enableA, const bool enableB)
{
_timerControlRegisterA = timerControlRegisterA;
_compareRegisterA = compareRegisterA;
_compareRegisterB = compareRegisterB;
_enableA =enableA;
_enableB =enableB;
*_timerControlRegisterA = 0x00;
*timerControlRegisterB = 0x00;
*inputCaptureRegister = 0xFFFF;
*timerControlRegisterB |= (1<<WGM13) | (1<<WGM12);
*timerControlRegisterB |= 0b00000111 & speed;
*_timerControlRegisterA|= (1<<WGM11);
*_compareRegisterA = 0;
*_compareRegisterB = 0;
_timerControlRegisterA = timerControlRegisterA;
_compareRegisterA = compareRegisterA;
_compareRegisterB = compareRegisterB;
_enableA =enableA;
_enableB =enableB;
*_timerControlRegisterA = 0x00;
*timerControlRegisterB = 0x00;
*inputCaptureRegister = 0xFFFF;
*timerControlRegisterB |= (1<<WGM13) | (1<<WGM12);
*timerControlRegisterB |= 0b00000111 & speed;
*_timerControlRegisterA|= (1<<WGM11);
*_compareRegisterA = 0;
*_compareRegisterB = 0;
}
bool Pwm16b::isOn()
{
return *_timerControlRegisterA != (1<<WGM11);
return *_timerControlRegisterA != (1<<WGM11);
}
void Pwm16b::off()
{
*_timerControlRegisterA = 0x00;
*_timerControlRegisterA |= (1<<WGM11);
*_timerControlRegisterA = 0x00;
*_timerControlRegisterA |= (1<<WGM11);
}
void Pwm16b::on()
{
off();
if(_enableA) *_timerControlRegisterA|= (1<<COM1A1);
if(_enableB) *_timerControlRegisterA|= (1<<COM1B1);
off();
if(_enableA) *_timerControlRegisterA|= (1<<COM1A1);
if(_enableB) *_timerControlRegisterA|= (1<<COM1B1);
}
uint16_t Pwm16b::getValueA()
{
return *_compareRegisterA;
return *_compareRegisterA;
}
uint16_t Pwm16b::getValueB()
{
return *_compareRegisterB;
return *_compareRegisterB;
}
void Pwm16b::setDutyA(const uint16_t duty)
{
*_compareRegisterA = duty;
*_compareRegisterA = duty;
}
void Pwm16b::setDutyB(const uint16_t duty)
{
*_compareRegisterB = duty;
*_compareRegisterB = duty;
}
Pwm16b::~Pwm16b()
{
off();
off();
}
//8bit
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)
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)
{
_timerControlRegisterA = timerControlRegisterA;
_compareRegisterA = compareRegisterA;
_compareRegisterB = compareRegisterB;
_enableA =enableA;
_enableB =enableB;
*_timerControlRegisterA = 0x00;
*timerControlRegisterB = 0x00;
//fast 8 bit PWM pwm A
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
_timerControlRegisterA = timerControlRegisterA;
_compareRegisterA = compareRegisterA;
_compareRegisterB = compareRegisterB;
_enableA =enableA;
_enableB =enableB;
*_timerControlRegisterA = 0x00;
*timerControlRegisterB = 0x00;
//fast 8 bit PWM pwm A
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
}
bool Pwm8b::isOn()
{
return (*_timerControlRegisterA & 0x11111100) != 0;
return (*_timerControlRegisterA & 0x11111100) != 0;
}
void Pwm8b::off()
{
*_timerControlRegisterA &= 0b00000011;
*_timerControlRegisterA &= 0b00000011;
}
void Pwm8b::on()
{
off();
if(_enableA) *_timerControlRegisterA|= (1<<COM0A1);
if(_enableB) *_timerControlRegisterA|= (1<<COM0B1);
off();
if(_enableA) *_timerControlRegisterA|= (1<<COM0A1);
if(_enableB) *_timerControlRegisterA|= (1<<COM0B1);
}
uint8_t Pwm8b::getValueA()
{
return *_compareRegisterA;
return *_compareRegisterA;
}
uint8_t Pwm8b::getValueB()
{
return *_compareRegisterB;
return *_compareRegisterB;
}
void Pwm8b::setDutyA(const uint8_t duty)
{
*_compareRegisterA = duty;
*_compareRegisterA = duty;
}
void Pwm8b::setDutyB(const uint8_t duty)
{
*_compareRegisterB = duty;
*_compareRegisterB = duty;
}
Pwm8b::~Pwm8b()
{
off();
off();
}

66
pwm.h
View File

@ -6,44 +6,48 @@
class Pwm16b //TC1 pwm on PB1 & PB2
{
private:
volatile unsigned char *_timerControlRegisterA; //TCCRxA
volatile uint16_t *_compareRegisterA; //OCRxA
volatile uint16_t *_compareRegisterB; //OCRxB
bool _enableA;
bool _enableB;
volatile unsigned char *_timerControlRegisterA; //TCCRxA
volatile uint16_t *_compareRegisterA; //OCRxA
volatile uint16_t *_compareRegisterB; //OCRxB
bool _enableA;
bool _enableB;
public:
Pwm16b( volatile unsigned char *timerControlRegisterA, volatile unsigned char *timerControlRegisterB, volatile uint16_t *compareRegisterA, volatile uint16_t *compareRegisterB, volatile uint16_t *inputCaptureRegister, const uint8_t speed = 0b00000011, const bool enableA = true, const bool enableB = true);
~Pwm16b();
void setDutyA(const uint16_t duty);
void setDutyB(const uint16_t duty);
uint16_t getValueA();
uint16_t getValueB();
bool isOn();
void off();
void on();
Pwm16b( volatile unsigned char *timerControlRegisterA, volatile unsigned char *timerControlRegisterB,
volatile uint16_t *compareRegisterA, volatile uint16_t *compareRegisterB, volatile uint16_t *inputCaptureRegister,
const uint8_t speed = 0b00000011, const bool enableA = true, const bool enableB = true);
~Pwm16b();
void setDutyA(const uint16_t duty);
void setDutyB(const uint16_t duty);
uint16_t getValueA();
uint16_t getValueB();
bool isOn();
void off();
void on();
};
class Pwm8b
{
private:
volatile unsigned char *_timerControlRegisterA; //TCCRxA
volatile unsigned char *_compareRegisterA; //OCRxA
volatile unsigned char *_compareRegisterB; //OCRxB
bool _enableA;
bool _enableB;
volatile unsigned char *_timerControlRegisterA; //TCCRxA
volatile unsigned char *_compareRegisterA; //OCRxA
volatile unsigned char *_compareRegisterB; //OCRxB
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);
~Pwm8b();
void setDutyA(const uint8_t duty);
void setDutyB(const uint8_t duty);
uint8_t getValueA();
uint8_t getValueB();
bool isOn();
void off();
void on();
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);
~Pwm8b();
void setDutyA(const uint8_t duty);
void setDutyB(const uint8_t duty);
uint8_t getValueA();
uint8_t getValueB();
bool isOn();
void off();
void on();
};
#endif

303
rgbled.cpp
View File

@ -4,106 +4,106 @@ RgbLed::RgbLed( Pwm8b* pwmA, Pwm8b* pwmB ): _pwmA(pwmA), _pwmB(pwmB) {}
void RgbLed::setSolidColor( const uint8_t r, const uint8_t g, const uint8_t b)
{
_pattern=0;
_targetR = applyCal(r, calRed);
_targetG = applyCal(g, calGreen);
_targetB = applyCal(b, calBlue);
_pattern=0;
_targetR = applyCal(r, calRed);
_targetG = applyCal(g, calGreen);
_targetB = applyCal(b, calBlue);
}
void RgbLed::setPreset( const uint8_t preset)
{
switch (preset)
{
//whites
case 1:
setSolidColor( 160,255,80 ); //neutral white
break;
case 2:
setSolidColor( 200,255,20 ); //Warm white
break;
case 3:
setSolidColor( 180,255,140 ); //cold white
break;
//reds
case 4:
setSolidColor( 255,0,0 ); //red
break;
case 5:
setSolidColor( 255,60,10 ); //ruby
break;
case 6:
setSolidColor( 255,30,30 ); //pink
break;
case 7:
setSolidColor( 255,155,0 ); //orange
break;
//greens
case 8:
setSolidColor( 0,255,0 ); //green
break;
case 9:
setSolidColor( 55,255,10 ); //poison
break;
case 10:
setSolidColor( 0,255,0 ); //green
break;
case 11:
setSolidColor( 8,80,7 ); //mint
break;
//blues
case 12:
setSolidColor( 0,0,255 ); //blue
break;
case 13:
setSolidColor( 50,255,255 ); //sky
break;
case 14:
setSolidColor( 10,80,150 ); //ocean
break;
case 15:
setSolidColor( 0,255,220 ); //turqouse
break;
//strange yellow color color
case 16:
setSolidColor( 200,255,0 );
break;
default:
setSolidColor( 255,055,20 );
}
switch (preset)
{
//whites
case 1:
setSolidColor( 160,255,80 ); //neutral white
break;
case 2:
setSolidColor( 200,255,20 ); //Warm white
break;
case 3:
setSolidColor( 180,255,140 ); //cold white
break;
//reds
case 4:
setSolidColor( 255,0,0 ); //red
break;
case 5:
setSolidColor( 255,60,10 ); //ruby
break;
case 6:
setSolidColor( 255,30,30 ); //pink
break;
case 7:
setSolidColor( 255,155,0 ); //orange
break;
//greens
case 8:
setSolidColor( 0,255,0 ); //green
break;
case 9:
setSolidColor( 55,255,10 ); //poison
break;
case 10:
setSolidColor( 0,255,0 ); //green
break;
case 11:
setSolidColor( 8,80,7 ); //mint
break;
//blues
case 12:
setSolidColor( 0,0,255 ); //blue
break;
case 13:
setSolidColor( 50,255,255 ); //sky
break;
case 14:
setSolidColor( 10,80,150 ); //ocean
break;
case 15:
setSolidColor( 0,255,220 ); //turqouse
break;
//strange yellow color color
case 16:
setSolidColor( 200,255,0 );
break;
default:
setSolidColor( 255,055,20 );
}
}
void RgbLed::setPattern(const uint8_t id)
{
_pattern=id;
if( id != 0 )
{
_pwmA->setDutyB(0);
_pwmA->setDutyA(0);
_pwmB->setDutyB(0);
on();
_stroke = false;
_counter = 0;
}
_pattern=id;
if( id != 0 )
{
_pwmA->setDutyB(0);
_pwmA->setDutyA(0);
_pwmB->setDutyB(0);
on();
_stroke = false;
_counter = 0;
}
}
void RgbLed::on()
{
_powerd = true;
_pwmA->on();
_pwmB->on();
_powerd = true;
_pwmA->on();
_pwmB->on();
}
void RgbLed::off()
{
_powerd = false;
_pwmA->off();
_pwmB->off();
_powerd = false;
_pwmA->off();
_pwmB->off();
}
void RgbLed::setFade(bool fade)
{
_fade=fade;
_fade=fade;
}
uint8_t RgbLed::applyCal(uint16_t value, const uint16_t* cal)
@ -126,89 +126,90 @@ void RgbLed::adjustHeadroom(uint8_t& r, uint8_t& g, uint8_t& b, const uint8_t lu
void RgbLed::patternStep()
{
if(_pattern == 1)
{
if(!_stroke)_counter++;
else _counter --;
if(_counter == 255) _stroke = true;
else if(_counter == 0) _stroke = false;
_pwmA->setDutyB(_counter);
_pwmA->setDutyA(255-_counter);
_pwmB->setDutyB(_counter-64);
}
else if(_pattern == 2) //Alarm!
{
if(!_stroke)_counter++;
else _counter --;
if(_counter == 255 << 1) _stroke = true;
else if(_counter == 0) _stroke = false;
_pwmA->setDutyB(_counter >> 1);
_pwmA->setDutyA(0);
_pwmB->setDutyB(0);
}
else if(_pattern == 3)
{
if(!_stroke)_counter++;
else _counter --;
if(_counter == (uint8_t) 255 << 8) _stroke = true;
else if(_counter == 0) _stroke = false;
_pwmA->setDutyB(_counter >> 6);
_pwmA->setDutyA(_counter >> 8);
_pwmB->setDutyB(_counter >> 3);
}
else if(_pattern == 4)
{
( _counter < 8192 ) ? _pwmA->setDutyB(_counter >> 6) : _pwmA->setDutyB( 128 + (_counter >> 11));
if( _counter > 1024 ) ( 8192 < _counter && _counter < 16384 ) ? _pwmA->setDutyA((_counter-8192) >> 6) : _pwmA->setDutyA( 128 + (_counter >> 9 ));
if( _counter > 8192 ) _pwmB->setDutyB(_counter >> 9);
if(_counter<65530) _counter++;
else _pwmB->setDutyB(140);
_delay_ms(18);
}
if(_pattern == 1)
{
if(!_stroke)_counter++;
else _counter --;
if(_counter == 255) _stroke = true;
else if(_counter == 0) _stroke = false;
_pwmA->setDutyB(_counter);
_pwmA->setDutyA(255-_counter);
_pwmB->setDutyB(_counter-64);
}
else if(_pattern == 2) //Alarm!
{
if(!_stroke)_counter++;
else _counter --;
if(_counter == 255 << 1) _stroke = true;
else if(_counter == 0) _stroke = false;
_pwmA->setDutyB(_counter >> 1);
_pwmA->setDutyA(0);
_pwmB->setDutyB(0);
}
else if(_pattern == 3)
{
if(!_stroke)_counter++;
else _counter --;
if(_counter == (uint8_t) 255 << 8) _stroke = true;
else if(_counter == 0) _stroke = false;
_pwmA->setDutyB(_counter >> 6);
_pwmA->setDutyA(_counter >> 8);
_pwmB->setDutyB(_counter >> 3);
}
else if(_pattern == 4)
{
( _counter < 8192 ) ? _pwmA->setDutyB(_counter >> 6) : _pwmA->setDutyB( 128 + (_counter >> 11));
if( _counter > 1024 ) ( 8192 < _counter
&& _counter < 16384 ) ? _pwmA->setDutyA((_counter-8192) >> 6) : _pwmA->setDutyA( 128 + (_counter >> 9 ));
if( _counter > 8192 ) _pwmB->setDutyB(_counter >> 9);
if(_counter<65530) _counter++;
else _pwmB->setDutyB(140);
_delay_ms(18);
}
}
void RgbLed::logic()
{
patternStep();
if(_pattern == 0 && _fade)
{
_counter++;
if( uint8_t(_counter << _fadeSpeed) == 0)
{
if( getR() != _targetR)
{
_pwmA->setDutyB(getR() - sgn(getR() - _targetR));
}
if( getG() != _targetG)
{
_pwmA->setDutyA(getG() - sgn(getG() - _targetG));
}
if( getB() != _targetB)
{
_pwmB->setDutyB(getB() - sgn(getB() - _targetB));
}
}
}
else if(_pattern == 0)
{
_pwmA->setDutyA(_targetG);
_pwmA->setDutyB(_targetR);
_pwmB->setDutyB(_targetB);
}
patternStep();
if(_pattern == 0 && _fade)
{
_counter++;
if( uint8_t(_counter << _fadeSpeed) == 0)
{
if( getR() != _targetR)
{
_pwmA->setDutyB(getR() - sgn(getR() - _targetR));
}
if( getG() != _targetG)
{
_pwmA->setDutyA(getG() - sgn(getG() - _targetG));
}
if( getB() != _targetB)
{
_pwmB->setDutyB(getB() - sgn(getB() - _targetB));
}
}
}
else if(_pattern == 0)
{
_pwmA->setDutyA(_targetG);
_pwmA->setDutyB(_targetR);
_pwmB->setDutyB(_targetB);
}
}
uint8_t RgbLed::getR()
{
return _pwmA->getValueB();
return _pwmA->getValueB();
}
uint8_t RgbLed::getB()
{
return _pwmB->getValueB();
return _pwmB->getValueB();
}
uint8_t RgbLed::getG()
{
return _pwmA->getValueA();
return _pwmA->getValueA();
}

76
rgbled.h
View File

@ -4,54 +4,54 @@
class RgbLed
{
private:
Pwm8b* _pwmA;
Pwm8b* _pwmB;
Pwm8b* _pwmA;
Pwm8b* _pwmB;
static constexpr uint16_t calRed[] = {1000, 1000, 1000};
static constexpr uint16_t calGreen[] = {1000, 1000, 1000};
static constexpr uint16_t calBlue[] = {400, 500, 500};
uint8_t _pattern = 0;
uint16_t _counter = 0;
bool _stroke = false;
uint8_t _targetR = 0;
uint8_t _targetG = 0;
uint8_t _targetB = 0;
bool _fade = true;
uint8_t _fadeSpeed = 7;
bool _powerd = false;
void patternStep();
uint8_t _pattern = 0;
uint16_t _counter = 0;
bool _stroke = false;
uint8_t _targetR = 0;
uint8_t _targetG = 0;
uint8_t _targetB = 0;
bool _fade = true;
uint8_t _fadeSpeed = 7;
bool _powerd = false;
void patternStep();
uint16_t getCalValue();
uint8_t applyCal(uint16_t value, const uint16_t* cal);
void adjustHeadroom(uint8_t& r, uint8_t& g, uint8_t& b, const uint8_t lumina);
public:
RgbLed( Pwm8b* pwmA, Pwm8b* pwmB );
void setSolidColor( const uint8_t r, const uint8_t g, const uint8_t b);
void setPattern(const uint8_t id);
void setPreset( const uint8_t preset);
void on();
void off();
void setFade(bool fade = true);
void logic();
uint8_t getR();
uint8_t getB();
uint8_t getG();
bool isPowerd();
uint8_t getPattern();
RgbLed( Pwm8b* pwmA, Pwm8b* pwmB );
void setSolidColor( const uint8_t r, const uint8_t g, const uint8_t b);
void setPattern(const uint8_t id);
void setPreset( const uint8_t preset);
void on();
void off();
void setFade(bool fade = true);
void logic();
uint8_t getR();
uint8_t getB();
uint8_t getG();
bool isPowerd();
uint8_t getPattern();
};
template <typename T> T sgn(T val)
template <typename T> T sgn(T val)
{
return (T(0) < val) - (val < T(0));
return (T(0) < val) - (val < T(0));
}

188
ringbuffer.h Executable file → Normal file
View File

@ -22,104 +22,104 @@ template < int BUFFER_SIZE, typename T = uint8_t >
class RingBuffer
{
private:
volatile uint_fast16_t _headIndex = 0;
volatile uint_fast16_t _tailIndex = 0;
volatile uint_fast16_t _headIndex = 0;
volatile uint_fast16_t _tailIndex = 0;
volatile bool _overrun = false;
volatile T _buffer[BUFFER_SIZE];
volatile T _buffer[BUFFER_SIZE];
public:
RingBuffer()
{
flush();
}
uint_fast16_t remaining() const volatile
{
return (_headIndex-_tailIndex);
}
uint_fast16_t remainingCapacity() const volatile
{
return BUFFER_SIZE - (_headIndex-_tailIndex);
}
bool isOverun() volatile
{
bool returnVal = _overrun;
_overrun = false;
return returnVal;
}
bool isEmpty() const volatile
{
return _tailIndex >= _headIndex;
}
T read() volatile
{
if(!isEmpty())
{
_tailIndex++;
return _buffer[(_tailIndex - 1) % BUFFER_SIZE];
}
else return '\0';
}
unsigned int read( T* buffer, unsigned int length ) volatile
{
unsigned int i = 0;
for(; i < length && !isEmpty(); i++)
{
buffer[i] = read();
}
return i;
}
void write( T in ) volatile
{
if (_headIndex - BUFFER_SIZE > 0 && _tailIndex - BUFFER_SIZE > 0)
{
_headIndex -= BUFFER_SIZE;
_tailIndex -= BUFFER_SIZE;
}
_buffer[_headIndex % BUFFER_SIZE] = in;
_headIndex++;
if(remaining() > BUFFER_SIZE)
RingBuffer()
{
flush();
}
uint_fast16_t remaining() const volatile
{
return (_headIndex-_tailIndex);
}
uint_fast16_t remainingCapacity() const volatile
{
return BUFFER_SIZE - (_headIndex-_tailIndex);
}
bool isOverun() volatile
{
bool returnVal = _overrun;
_overrun = false;
return returnVal;
}
bool isEmpty() const volatile
{
return _tailIndex >= _headIndex;
}
T read() volatile
{
if(!isEmpty())
{
_tailIndex++;
return _buffer[(_tailIndex - 1) % BUFFER_SIZE];
}
else return '\0';
}
unsigned int read( T* buffer, unsigned int length ) volatile
{
unsigned int i = 0;
for(; i < length && !isEmpty(); i++)
{
buffer[i] = read();
}
return i;
}
void write( T in ) volatile
{
if (_headIndex - BUFFER_SIZE > 0 && _tailIndex - BUFFER_SIZE > 0)
{
_headIndex -= BUFFER_SIZE;
_tailIndex -= BUFFER_SIZE;
}
_buffer[_headIndex % BUFFER_SIZE] = in;
_headIndex++;
if(remaining() > BUFFER_SIZE)
{
_overrun = true;
_tailIndex = _headIndex - BUFFER_SIZE;
}
}
void write( T* buffer, const unsigned int length ) volatile
{
for(unsigned int i = 0; i < length; i++) write(buffer[i]);
}
void flush(T flushCharacter = ' ') volatile
{
_headIndex = 0;
_tailIndex = 0;
for(int i = 0; i < BUFFER_SIZE; i++) _buffer[i] = flushCharacter;
}
unsigned int getString(T terminator, T* buffer, const unsigned int bufferLength) volatile
{
unsigned int i = 0;
for(; i <= remaining() && i <= BUFFER_SIZE && _buffer[(_tailIndex+i) % BUFFER_SIZE] != terminator; i++);
if( i < remaining() && i > 0)
{
if(i > bufferLength-1) i = bufferLength-1;
read(buffer, i);
buffer[i]='\0';
_tailIndex++;
}
else if(i == 0) _tailIndex++;
else i = 0;
return i;
}
}
void write( T* buffer, const unsigned int length ) volatile
{
for(unsigned int i = 0; i < length; i++) write(buffer[i]);
}
void flush(T flushCharacter = ' ') volatile
{
_headIndex = 0;
_tailIndex = 0;
for(int i = 0; i < BUFFER_SIZE; i++) _buffer[i] = flushCharacter;
}
unsigned int getString(T terminator, T* buffer, const unsigned int bufferLength) volatile
{
unsigned int i = 0;
for(; i <= remaining() && i <= BUFFER_SIZE && _buffer[(_tailIndex+i) % BUFFER_SIZE] != terminator; i++);
if( i < remaining() && i > 0)
{
if(i > bufferLength-1) i = bufferLength-1;
read(buffer, i);
buffer[i]='\0';
_tailIndex++;
}
else if(i == 0) _tailIndex++;
else i = 0;
return i;
}
};

129
serial.cpp
View File

@ -16,113 +16,116 @@ ISR(USART_RX_vect) //I have seen worse interrupt sintax
}
}
Serial::Serial()
Serial::Serial()
{
UBRR0H = UBRRH_VALUE;
UBRR0L = UBRRL_VALUE;
UCSR0C = _BV(UCSZ01) | _BV(UCSZ00);
UCSR0B = _BV(RXEN0) | _BV(TXEN0); //Enable RX and TX
UCSR0B |= (1 << RXCIE0); //Enable Rx interuppt
UBRR0H = UBRRH_VALUE;
UBRR0L = UBRRL_VALUE;
UCSR0C = _BV(UCSZ01) | _BV(UCSZ00);
UCSR0B = _BV(RXEN0) | _BV(TXEN0); //Enable RX and TX
UCSR0B |= (1 << RXCIE0); //Enable Rx interuppt
sei();
}
void Serial::putChar(const char c)
{
loop_until_bit_is_set(UCSR0A, UDRE0);
UDR0 = c;
loop_until_bit_is_set(UCSR0A, UDRE0);
UDR0 = c;
}
void Serial::write(const char* in, const unsigned int length)
{
for(unsigned int i = 0; i < length && in[i] != '\0'; i++)
{
putChar(in[i]);
}
for(unsigned int i = 0; i < length && in[i] != '\0'; i++)
{
putChar(in[i]);
}
}
void Serial::write_p(const char in[])
{
cli();
char ch = pgm_read_byte(in);
while (ch != '\0')
{
putChar(ch);
in++;
ch = pgm_read_byte(in);
}
sei();
cli();
char ch = pgm_read_byte(in);
while (ch != '\0')
{
putChar(ch);
in++;
ch = pgm_read_byte(in);
}
sei();
}
void Serial::write(const char in[])
{
for(unsigned int i = 0; i < strlen(in); i++)
{
putChar(in[i]);
}
for(unsigned int i = 0; i < strlen(in); i++)
{
putChar(in[i]);
}
}
void Serial::write(int32_t in)
{
if(in == 0)
{
putChar('0');
}
else
{
bool flag = false;
char str[64] = { 0 };
int16_t i = 62;
if (in < 0)
{
flag = true;
in = abs(in);
}
if(in == 0)
{
putChar('0');
}
else
{
bool flag = false;
char str[64] = { 0 };
int16_t i = 62;
if (in < 0)
{
flag = true;
in = abs(in);
}
while (in != 0 && i > 0)
{
str[i--] = (in % 10) + '0';
in /= 10;
}
while (in != 0 && i > 0)
{
str[i--] = (in % 10) + '0';
in /= 10;
}
if (flag) str[i--] = '-';
write(str + i + 1, 64-(i+1));
}
if (flag) str[i--] = '-';
write(str + i + 1, 64-(i+1));
}
}
bool Serial::dataIsWaiting()
{
return !rxBuffer.isEmpty();
return !rxBuffer.isEmpty();
}
char Serial::getChar()
{
if(!rxBuffer.isEmpty())
{
if(serialFlowControl && stopped && rxBuffer.remainingCapacity() > 32 )
{
loop_until_bit_is_set(UCSR0A, UDRE0);
UDR0 = 0x11;
stopped = false;
}
return rxBuffer.read();
}
else return '\0';
if(!rxBuffer.isEmpty())
{
if(serialFlowControl && stopped && rxBuffer.remainingCapacity() > 32 )
{
loop_until_bit_is_set(UCSR0A, UDRE0);
UDR0 = 0x11;
stopped = false;
}
return rxBuffer.read();
}
else return '\0';
}
unsigned int Serial::getString(char* buffer, const int bufferLength)
{
return rxBuffer.getString(_terminator, (uint8_t*)buffer, bufferLength);
return rxBuffer.getString(_terminator, (uint8_t*)buffer, bufferLength);
}
unsigned int Serial::read(char* buffer, const unsigned int length )
{
return rxBuffer.read((uint8_t*)buffer, length);
return rxBuffer.read((uint8_t*)buffer, length);
}
void Serial::flush()
{
rxBuffer.flush();
rxBuffer.flush();
}
void Serial::setTerminator(char terminator){_terminator = terminator;}
void Serial::setTerminator(char terminator)
{
_terminator = terminator;
}

28
serial.h
View File

@ -16,21 +16,21 @@ const bool serialFlowControl = false;
class Serial
{
private:
char _terminator = '\n';
char _terminator = '\n';
public:
Serial();
void putChar(const char c);
void write(const char* in, const unsigned int length);
void write(const char in[]);
void write_p(const char in[]); //for flash space strigns
void write(const int32_t in);
unsigned int read( char* buffer, const unsigned int length );
bool dataIsWaiting();
char getChar();
unsigned int getString(char* buffer, const int bufferLength);
void flush();
void setTerminator(const char terminator);
Serial();
void putChar(const char c);
void write(const char* in, const unsigned int length);
void write(const char in[]);
void write_p(const char in[]); //for flash space strigns
void write(const int32_t in);
unsigned int read( char* buffer, const unsigned int length );
bool dataIsWaiting();
char getChar();
unsigned int getString(char* buffer, const int bufferLength);
void flush();
void setTerminator(const char terminator);
};
#endif

148
staticvector.h
View File

@ -4,80 +4,80 @@
template<typename T, size_t size> class SVector
{
private:
size_t stored = 0;
T array[size];
size_t stored = 0;
T array[size];
public:
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-1];
}
bool empty() const
{
return stored == 0 ? true : false;
}
size_t count() const
{
return stored;
}
constexpr size_t maxSize() const
{
return size;
}
size_t remainingCapacity() const
{
return size - stored;
}
bool push_back(const T in)
{
if( remainingCapacity() != 0)
{
array[stored] = in;
++stored;
return true;
}
else return false;
}
bool erase(size_t position)
{
if(position > stored) return false;
array[position].~T();
--stored;
for( size_t i = position; i < stored; i++ ) memcpy(&array[i], &array[i+1], sizeof(T));
return true;
}
void clear()
{
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-1];
}
bool empty() const
{
return stored == 0 ? true : false;
}
size_t count() const
{
return stored;
}
constexpr size_t maxSize() const
{
return size;
}
size_t remainingCapacity() const
{
return size - stored;
}
bool push_back(const T in)
{
if( remainingCapacity() != 0)
{
array[stored] = in;
++stored;
return true;
}
else return false;
}
bool erase(size_t position)
{
if(position > stored) return false;
array[position].~T();
--stored;
for( size_t i = position; i < stored; i++ ) memcpy(&array[i], &array[i+1], sizeof(T));
return true;
}
void clear()
{
for( size_t i = 0; i < stored; i++ ) array[i].~T();
stored = 0;
}
stored = 0;
}
};

14
uvositem.cpp
View File

@ -2,23 +2,23 @@
UvosItem::UvosItem(const uint8_t idIn, char nameIn[])
{
id = 129 << 8 + idIn;
type = 1;
id = 129 << 8 + idIn;
type = 1;
}
UvosItem::UvosItem(const Item& item)
{
Item::operator=(item);
type = 1;
Item::operator=(item);
type = 1;
}
void UvosItem::setValue(const uint8_t value)
{
const uint8_t paket[4] = {id >> 8, id & 0x00FF, 0, value};
if(transmitter)transmitter->send(paket, 4);
const uint8_t paket[4] = {id >> 8, id & 0x00FF, 0, value};
if(transmitter)transmitter->send(paket, 4);
}
void UvosItem::resend()
{
setValue(lastValue);
setValue(lastValue);
}

12
uvositem.h
View File

@ -5,12 +5,12 @@
class UvosItem: public Item
{
public:
inline static W433DataTransmitter* transmitter = nullptr;
public:
UvosItem(const uint8_t idIn, char nameIn[]);
UvosItem(const Item& item);
void setValue(const uint8_t value);
inline static W433DataTransmitter* transmitter = nullptr;
public:
UvosItem(const uint8_t idIn, char nameIn[]);
UvosItem(const Item& item);
void setValue(const uint8_t value);
void resend();
};

13
writepin.h
View File

@ -5,22 +5,25 @@
inline void writePin(volatile unsigned char *port, const unsigned char pin, const bool state) //waste 2 cycles
{
*port &= ~(1 << pin);
if(state) *port |= (1 << pin);
*port &= ~(1 << pin);
if(state) *port |= (1 << pin);
}
inline void setBit( volatile unsigned char *reg, const unsigned char bit, bool value )
{
writePin(reg, bit, value);
writePin(reg, bit, value);
}
inline void setDirection( volatile unsigned char *portDirReg, const unsigned char pin, bool makeOutput )
{
writePin(portDirReg, pin, makeOutput);
writePin(portDirReg, pin, makeOutput);
}
inline bool readPin( volatile unsigned char *inPort, const unsigned char pin){ return (bool) (*inPort & (1 << pin));}
inline bool readPin( volatile unsigned char *inPort, const unsigned char pin)
{
return (bool) (*inPort & (1 << pin));
}
#endif