diff --git a/W433DataReciver.cpp b/W433DataReciver.cpp index ada77cc..c766c32 100644 --- a/W433DataReciver.cpp +++ b/W433DataReciver.cpp @@ -8,8 +8,8 @@ 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 ): -_port(port), _pin(pin), _timerRegister(timerRegister), _timerOverflowRegister(timerOverflowRegister), _packetCallback(packetCallback), _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; @@ -62,7 +62,11 @@ bool W433DataReciver::reciveSync(const uint16_t elapsedTime) { ++syncCount; } - else syncCount = 0; + else + { + if(syncCount > 5) error(ERR_SYNC_FAIL); + syncCount = 0; + } if(syncCount > 10) return true; else return false; } @@ -81,12 +85,21 @@ uint8_t W433DataReciver::assmbleByte() { int8_t bit = reciveBit(i*4); if(bit >= 0) byte = byte | (bit << (7-i)); - else setState(LOOKING_FOR_SYNC); + else + { + setState(LOOKING_FOR_SYNC); + error(ERR_BYTE_ASM); + } } timesBufferIndex = 0; return byte; } +void W433DataReciver::error(const uint8_t errorCode) +{ + if(_errorCodeHandler != nullptr) (*_errorCodeHandler)(errorCode, _userData); +} + void W433DataReciver::setState(const uint8_t stateIn) { state = stateIn; @@ -119,7 +132,11 @@ void W433DataReciver::interrupt() { if(elapsedTime > SYNC_TIME + 50) { - if(elapsedTime < LARGE_TIME + 50) setState(LOOKING_FOR_SYNC); + if(elapsedTime < LARGE_TIME + 50) + { + setState(LOOKING_FOR_SYNC); + error(ERR_NO_SYNC_END); + } else { timesBuffer[0] = -LARGE_TIME; @@ -134,7 +151,11 @@ void W433DataReciver::interrupt() { uint8_t recivedSignature = assmbleByte(); if( recivedSignature == signature) setState(RECVING_PACKET); - else setState(LOOKING_FOR_SYNC); + else + { + error(ERR_WRONG_SIG); + setState(LOOKING_FOR_SYNC); + } } } else if( state == RECVING_PACKET ) @@ -170,6 +191,7 @@ void W433DataReciver::interrupt() _ringBuffer.write(const_cast(buffer), sizeof(packet)); if(_packetCallback != nullptr)(*_packetCallback)(packet, _userData); } + else error(ERR_CHECKSUM); packet = 0; setState(LOOKING_FOR_SYNC); } diff --git a/W433DataReciver.h b/W433DataReciver.h index c92976d..4db8e5e 100644 --- a/W433DataReciver.h +++ b/W433DataReciver.h @@ -7,6 +7,13 @@ class W433DataReciver public: 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: @@ -31,9 +38,8 @@ private: static constexpr uint8_t LOOKING_FOR_SIGNATURE = 2; static constexpr uint8_t RECVING_PACKET = 3; static constexpr uint8_t RECVING_PACKET_CHECKSUM = 4; - - //variables + //variables volatile unsigned char *_port; unsigned char _pin; @@ -49,7 +55,8 @@ private: volatile uint8_t packetIndex = 0; volatile uint32_t packet = 0; - void (* const _packetCallback)(uint32_t, void*) = nullptr; + void (* const _packetCallback)(uint32_t, void*); + void (* const _errorCodeHandler)(uint8_t, void*); void* const _userData; volatile uint8_t syncCount = 0; @@ -62,12 +69,14 @@ private: 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); 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 ); + 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(); diff --git a/main.cpp b/main.cpp index 0197ae1..04f0472 100644 --- a/main.cpp +++ b/main.cpp @@ -372,6 +372,17 @@ void serialDispatch(Serial* serial, SVector* relays, } } +void reciverError(uint8_t code, void* userData) +{ + if(!sensorsPaused) + { + Serial* serial = reinterpret_cast(userData); + serial->write_p(PSTR("ERROR CODE: ")); + serial->write(code); + serial->putChar('\n'); + } +} + void sensorPacketRecived(uint32_t data, void* userData) { if(!sensorsPaused) @@ -424,7 +435,7 @@ int main() setBit(&PCICR, PCIE1, true); setBit(&PCMSK1, PCINT8, true); - W433DataReciver reciver(&PINC, PC0, &TCNT1, &TIFR1, &sensorPacketRecived, reinterpret_cast(&serial)); + W433DataReciver reciver(&PINC, PC0, &TCNT1, &TIFR1, &sensorPacketRecived, reinterpret_cast(&serial), &reciverError); serial.write_p(PSTR("RGBController v1.0 starting\n")); diff --git a/rgbled.cpp b/rgbled.cpp index af31a00..80e80ca 100644 --- a/rgbled.cpp +++ b/rgbled.cpp @@ -109,9 +109,8 @@ void RgbLed::setFade(bool fade) uint8_t RgbLed::applyCal(uint16_t value, const uint16_t* cal) { uint16_t calValue; - if(value < 128) calValue = cal[0] + ((cal[1] - cal[0])*(value/8))/16; - else calValue = cal[1] + ((cal[2] - cal[1])*((value-128)/8))/16; - + if(value < 128) calValue = cal[0] + ((cal[1] - cal[0])*((uint32_t)value))/128; + else calValue = cal[1] + ((cal[2] - cal[1])*((uint32_t)(value-128)))/128; return (value*calValue)/1000; } diff --git a/rgbled.h b/rgbled.h index 0ad1110..ce059a1 100644 --- a/rgbled.h +++ b/rgbled.h @@ -7,9 +7,9 @@ private: Pwm8b* _pwmA; Pwm8b* _pwmB; - static constexpr uint16_t calRed[] = {650, 650, 650}; + static constexpr uint16_t calRed[] = {1000, 1000, 1000}; static constexpr uint16_t calGreen[] = {1000, 1000, 1000}; - static constexpr uint16_t calBlue[] = {200, 250, 300}; + static constexpr uint16_t calBlue[] = {400, 500, 500}; diff --git a/ringbuffer.h b/ringbuffer.h new file mode 100755 index 0000000..2796310 --- /dev/null +++ b/ringbuffer.h @@ -0,0 +1,125 @@ +/*UVOS*/ + +/* This file is part of TelemetrySystem. + * + * TelemetrySystem is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License (LGPL) version 3 as published by + * the Free Software Foundation. + * + * TelemetrySystem is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with TelemetrySystem. If not, see . +*/ +#pragma once + +#include + +template < int BUFFER_SIZE, typename T = uint8_t > +class RingBuffer +{ +private: + + volatile uint_fast16_t _headIndex = 0; + volatile uint_fast16_t _tailIndex = 0; + volatile bool _overrun = false; + 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) + { + _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; + } +}; diff --git a/watchdog.h b/watchdog.h new file mode 100644 index 0000000..de49320 --- /dev/null +++ b/watchdog.h @@ -0,0 +1,33 @@ +#pragma once +#include + +#define wdt_set(value) \ + __asm__ __volatile__ ( \ + "in __tmp_reg__,__SREG__" "\n\t" \ + "cli" "\n\t" \ + "wdr" "\n\t" \ + "sts %0,%1" "\n\t" \ + "out __SREG__,__tmp_reg__" "\n\t" \ + "sts %0,%2" \ + : /* no outputs */ \ + : "M" (_SFR_MEM_ADDR(_WD_CONTROL_REG)), \ + "r" (_BV(_WD_CHANGE_BIT) | _BV(WDE)), \ + "r" ((uint8_t) ((value & 0x08 ? _WD_PS3_MASK : 0x00) | \ + _BV(WDIE) | (value & 0x07)) ) \ + : "r0" \ + ) + + +#define wdt_off(x) \ + __asm__ __volatile__ ( \ + "in __tmp_reg__,__SREG__" "\n\t" \ + "cli" "\n\t" \ + "wdr" "\n\t" \ + "sts %0,%1" "\n\t" \ + "sts %0,%2" \ + : /* no outputs */ \ + : "M" (_SFR_MEM_ADDR(_WD_CONTROL_REG)), \ + "r" (_BV(_WD_CHANGE_BIT) | _BV(WDE)), \ + "r" ((uint8_t) (0x00)) \ + : "r0" \ + )