471 lines
12 KiB
C++
471 lines
12 KiB
C++
#include <avr/io.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <util/delay.h>
|
|
#include <avr/pgmspace.h>
|
|
#include "serial.h"
|
|
#include "writepin.h"
|
|
#include "eeprom.h"
|
|
#include "bitrep.h"
|
|
#include "watchdog.h"
|
|
#include "staticvector.h"
|
|
#include "W433DataReciver.h"
|
|
#include "CL56.h"
|
|
#include "buttons.h"
|
|
#include "ds1302.h"
|
|
#include "sensor.h"
|
|
#include "pwm.h"
|
|
#include "dht11.h"
|
|
#include "WirelessRelay.h"
|
|
|
|
//#define HAS_DHT
|
|
#define HAS_TRANSMITTER
|
|
//#define HAS_RECIVER
|
|
|
|
#define MAX_SENSORS 32
|
|
#define COMMAND_BUFFER_SIZE 64
|
|
#define SNPRINTF_BUFFER_SIZE 96
|
|
|
|
#define welcomeString "HELO "
|
|
static constexpr bool bdayMsg = false;
|
|
|
|
void buttonHandler(uint8_t index, uint8_t type, void* data);
|
|
SVector<Sensor, MAX_SENSORS> sensors;
|
|
ShiftReg<16> shiftReg(&PORTB, PB3, PB2, PB1);
|
|
DS1302 clock(&PORTC, &PINC, &DDRC, PC0, PC2, PC1);
|
|
DualCl56 display(&shiftReg);
|
|
Buttons buttons(&buttonHandler);
|
|
|
|
#ifdef HAS_DHT
|
|
#define DPY_FIXED_ITEMS 4
|
|
#else
|
|
#define DPY_FIXED_ITEMS 2
|
|
#endif
|
|
|
|
static constexpr uint8_t almA = 0b01;
|
|
static constexpr uint8_t almB = 0b10;
|
|
|
|
uint8_t displaying = 0;
|
|
uint8_t alm = 0;
|
|
|
|
volatile bool setting = false;
|
|
volatile int8_t settingOffset = 0;
|
|
|
|
volatile bool ringging = false;
|
|
|
|
char buffer[SNPRINTF_BUFFER_SIZE];
|
|
|
|
volatile bool sensorsPaused = true;
|
|
|
|
volatile bool relaySetting = false;
|
|
|
|
volatile uint8_t timer = 0;
|
|
|
|
ISR(INT1_vect)
|
|
{
|
|
W433DataReciver::staticInterrupt();
|
|
}
|
|
|
|
ISR(TIMER2_OVF_vect)
|
|
{
|
|
display.tick();
|
|
buttons.tick();
|
|
if(ringging && ((timer % 4 == 0 && timer < 128) || (timer > 128 && timer % 16 == 0)) ) writePin(&PORTD, PD4, true);
|
|
else writePin(&PORTD, PD4, false);
|
|
++timer;
|
|
}
|
|
|
|
void buttonHandler(uint8_t index, uint8_t type, void* data)
|
|
{
|
|
if(!setting)
|
|
{
|
|
if(index == 0 && type == Buttons::RELEASED)
|
|
{
|
|
if(++displaying < sensors.count()+DPY_FIXED_ITEMS);
|
|
else displaying = 0;
|
|
}
|
|
else if(index == 0 && type == Buttons::LONG_PRESSED)
|
|
{
|
|
relaySetting = !relaySetting;
|
|
}
|
|
else if(index == 1 && type == Buttons::RELEASED )
|
|
{
|
|
if(!ringging) if(++alm > 3) alm = 0;
|
|
else ringging = false;
|
|
}
|
|
else if(index == 1 && type == Buttons::LONG_PRESSED )
|
|
{
|
|
setting = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(index == 1 && type == Buttons::LONG_PRESSED ) setting = false;
|
|
else if(index == 0 && type == Buttons::RELEASED ) settingOffset += 10;
|
|
else if(index == 1 && type == Buttons::RELEASED ) settingOffset -= 1;
|
|
}
|
|
}
|
|
|
|
void printSensor(const Sensor& sensor, Serial* serial)
|
|
{
|
|
serial->write_p(PSTR("SENSOR TYPE: "));
|
|
serial->write(sensor.type);
|
|
serial->write_p(PSTR(" ID: "));
|
|
serial->write(sensor.id);
|
|
|
|
if(sensor.type == 1) serial->write_p(PSTR(" TEMPERATURE: "));
|
|
else if(sensor.type == 2) serial->write_p(PSTR(" HUMIDITY: "));
|
|
else serial->write_p(PSTR(" FIELD: "));
|
|
serial->write(sensor.field);
|
|
serial->putChar('\n');
|
|
}
|
|
|
|
void packetHandler(uint32_t packet, void* data)
|
|
{
|
|
Serial* serial = reinterpret_cast<Serial*>(data);
|
|
|
|
Sensor sensor;
|
|
|
|
sensor.field = packet & 0x0000FFFF;
|
|
sensor.type = packet >> 24;
|
|
sensor.id = (packet & 0x00FF0000) >> 16;
|
|
|
|
bool found = false;
|
|
for(uint8_t i = 0; i < sensors.count() && !found; ++i)
|
|
{
|
|
if(sensors[i] == sensor)
|
|
{
|
|
sensors[i] = sensor;
|
|
found = true;
|
|
}
|
|
}
|
|
if(!found) sensors.push_back(sensor);
|
|
|
|
if(!sensorsPaused) printSensor(sensor, serial);
|
|
}
|
|
|
|
void reciverError(uint8_t code, void* userData)
|
|
{
|
|
if(!sensorsPaused)
|
|
{
|
|
Serial* serial = reinterpret_cast<Serial*>(userData);
|
|
serial->write_p(PSTR("RECV ERROR CODE: "));
|
|
serial->write(code);
|
|
serial->putChar('\n');
|
|
}
|
|
}
|
|
|
|
inline static void printHelp(Serial* serial)
|
|
{
|
|
serial->write_p(PSTR("Available Commands: \n\
|
|
help : Show this prompt.\n\
|
|
date : Show current date and time.\n\
|
|
set [yyyy] [mm] [dd] [hh] [mm] [ss] : Show current date and time.\n\
|
|
pause : pause sensor output.\n\
|
|
resume : resume sensor output.\n\
|
|
dump : Dump epprom.\n\
|
|
free : Show free ram.\n\
|
|
beep : Test buzzer.\n\
|
|
list : List sensors.\n"));
|
|
}
|
|
|
|
|
|
int freeRAM()
|
|
{
|
|
extern int __heap_start, *__brkval;
|
|
int v;
|
|
return (int) &v - (__brkval == 0 ? (int) &__heap_start: (int) __brkval);
|
|
}
|
|
|
|
void serialDispatch(Serial* serial, SVector<Sensor, MAX_SENSORS>* sensors)
|
|
{
|
|
if(serial->dataIsWaiting())
|
|
{
|
|
char buffer[COMMAND_BUFFER_SIZE];
|
|
unsigned int length = serial->getString(buffer, COMMAND_BUFFER_SIZE);
|
|
if(length > 2)
|
|
{
|
|
char* token = strtok(buffer, " \n");
|
|
if(strcmp(token, "date") == 0)
|
|
{
|
|
DS1302::Timeval time = clock.getTime();
|
|
snprintf(buffer, SNPRINTF_BUFFER_SIZE, "%04u.%02u.%02u %02u:%02u:%02u\n", time.year, time.month, time.day, time.hour, time.min, time.sec);
|
|
serial->write(buffer, SNPRINTF_BUFFER_SIZE);
|
|
}
|
|
else if(strcmp(token, "set") == 0)
|
|
{
|
|
char* year = strtok(NULL, " \n");
|
|
char* mon = strtok(NULL, " \n");
|
|
char* day = strtok(NULL, " \n");
|
|
char* hour = strtok(NULL, " \n");
|
|
char* min = strtok(NULL, " \n");
|
|
char* sec = strtok(NULL, " \n");
|
|
if(year != NULL && mon != NULL && day != NULL && hour != NULL && min != NULL && sec != NULL)
|
|
{
|
|
DS1302::Timeval time = {atoi(sec),atoi(min),atoi(hour),atoi(day),atoi(mon),atoi(year)};
|
|
clock.setTime(time);
|
|
serial->write_p(PSTR("date and time set\n"));
|
|
display.setString("SET ");
|
|
_delay_ms(1000);
|
|
}
|
|
else serial->write_p(PSTR("usage: set [yyyy] [mm] [dd] [hh] [mm] [ss]\n"));
|
|
}
|
|
else if(strcmp(token, "pause") == 0)
|
|
{
|
|
sensorsPaused = true;
|
|
serial->write_p(PSTR("Sensors paused\n"));
|
|
}
|
|
else if(strcmp(token, "resume") == 0)
|
|
{
|
|
sensorsPaused = false;
|
|
serial->write_p(PSTR("Sensors resumed\n"));
|
|
}
|
|
else if(strcmp(token, "list") == 0)
|
|
{
|
|
serial->write_p(PSTR("Sensors:\n"));
|
|
for(uint8_t i = 0; i < sensors->count(); ++i) printSensor(sensors->at(i), serial);
|
|
serial->write('\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"));
|
|
}
|
|
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, "beep") == 0)
|
|
{
|
|
serial->write_p(PSTR("Beeping\n"));
|
|
ringging = true;
|
|
_delay_ms(1000);
|
|
serial->write_p(PSTR("Done\n"));
|
|
ringging = false;
|
|
}
|
|
else if(strcmp(token, "help") == 0)
|
|
{
|
|
printHelp(serial);
|
|
}
|
|
else serial->write_p(PSTR("Not a valid command\n"));
|
|
}
|
|
}
|
|
}
|
|
|
|
void displayItems(const DS1302::Timeval& time, int16_t temp, int16_t humid)
|
|
{
|
|
switch(displaying)
|
|
{
|
|
case 0:
|
|
writePin(&PORTB, PB4, time.sec % 2);
|
|
snprintf(buffer, 9, " %02u%02u", time.hour, time.min);
|
|
display.setString(buffer);
|
|
display.setSegments((alm & almA ? DualCl56::SEG_A : 0) | (alm & almB ? DualCl56::SEG_D : 0), 0);
|
|
break;
|
|
case 1:
|
|
writePin(&PORTB, PB4, false);
|
|
snprintf(buffer, 9, "%02u%02u%04u", time.day, time.month, time.year);
|
|
display.setString(buffer, DualCl56::DP_B | DualCl56::DP_D);
|
|
break;
|
|
#ifdef HAS_DHT
|
|
case 2:
|
|
writePin(&PORTB, PB4, false);
|
|
snprintf(buffer, 9, "0 1%4u", temp);
|
|
display.setString(buffer, DualCl56::DP_G);
|
|
break;
|
|
case 3:
|
|
writePin(&PORTB, PB4, false);
|
|
snprintf(buffer, 9, "0 2%4u", humid);
|
|
display.setString(buffer, DualCl56::DP_G);
|
|
break;
|
|
#endif
|
|
default:
|
|
writePin(&PORTB, PB4, false);
|
|
snprintf(buffer, 9, "%u%3u%4u",
|
|
sensors[displaying-DPY_FIXED_ITEMS].id,
|
|
sensors[displaying-DPY_FIXED_ITEMS].type,
|
|
sensors[displaying-DPY_FIXED_ITEMS].field);
|
|
display.setString(buffer, sensors[displaying-DPY_FIXED_ITEMS].type == 1 || sensors[displaying-2].type == 2 ? DualCl56::DP_G : 0);
|
|
}
|
|
}
|
|
|
|
void setAlarm(DS1302::Timeval* alarm, uint8_t leadingSegment = 0)
|
|
{
|
|
writePin(&PORTB, PB4, true);
|
|
while(setting)
|
|
{
|
|
if(settingOffset+alarm->min > 59)
|
|
{
|
|
if(++alarm->hour > 23) alarm->hour = 0;
|
|
alarm->min = settingOffset+alarm->min-60;
|
|
}
|
|
else if(settingOffset+alarm->min < 0)
|
|
{
|
|
if(alarm->hour-1 < 0) alarm->hour = 24;
|
|
--alarm->hour;
|
|
alarm->min = settingOffset+alarm->min+60;
|
|
}
|
|
else alarm->min += settingOffset;
|
|
settingOffset = 0;
|
|
snprintf(buffer, 9, "S %02u%02u", alarm->hour, alarm->min);
|
|
display.setString(buffer);
|
|
display.setSegments(leadingSegment, 1);
|
|
}
|
|
writePin(&PORTB, PB4, false);
|
|
}
|
|
|
|
int main()
|
|
{
|
|
DDRB = (1 << PB1) | ( 1 << PB2) | ( 1 << PB3) | ( 1 << PB4) | ( 1 << PB5);
|
|
DDRD = (1<<PD4) | (1<<PD2);
|
|
PORTD |= (1<<PD6) | (1<<PD7);
|
|
|
|
TCCR2B = 1<<CS22;
|
|
TIMSK2 = 1;
|
|
|
|
TCCR1B = 1<<CS10;
|
|
|
|
EICRA = 1<<ISC10;
|
|
EIMSK = 1<<INT1;
|
|
|
|
sei();
|
|
|
|
Serial serial;
|
|
serial.write_p(PSTR("SensorDisplay v0.4 starting\n"));
|
|
|
|
DS1302::Timeval alarmA = EEPROM_read_class<DS1302::Timeval>(128);
|
|
DS1302::Timeval alarmB = EEPROM_read_class<DS1302::Timeval>(128+64);
|
|
DS1302::Timeval time = clock.getTime();
|
|
alm = EEPROM_read_char(0);
|
|
uint8_t oldAlm = alm;
|
|
|
|
|
|
#ifdef HAS_TRANSMITTER
|
|
char name[] = "relay";
|
|
WirelessRelay relay(0b1011010001000000, name);
|
|
#endif
|
|
|
|
#ifdef HAS_DHT
|
|
Dht11 sensor(&PORTD, &PIND, &DDRD, PD2);
|
|
#endif
|
|
if(time.day == 28 && time.month == 5)
|
|
{
|
|
if constexpr(bdayMsg)
|
|
{
|
|
display.setString("HAPPY ");
|
|
_delay_ms(1000);
|
|
display.setString("b-DAY ");
|
|
_delay_ms(1000);
|
|
display.setString("SASA ");
|
|
_delay_ms(1000);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
display.setString(welcomeString);
|
|
_delay_ms(1000);
|
|
}
|
|
|
|
#ifdef HAS_DHT
|
|
sensor.read();
|
|
_delay_ms(1000);
|
|
sensor.read();
|
|
#endif
|
|
|
|
W433DataReciver reciver(&PIND, PD3, &TCNT1, &TIFR1, &packetHandler, reinterpret_cast<void*>(&serial), &reciverError);
|
|
|
|
uint8_t deleteDate = 0;
|
|
|
|
serial.write_p(PSTR("Ready\n"));
|
|
|
|
uint16_t i = 0;
|
|
|
|
bool oldRelaySetting = false;
|
|
|
|
while(true)
|
|
{
|
|
#ifdef HAS_DHT
|
|
if((displaying == 2 || displaying == 3) && i%2048 == 0)
|
|
{
|
|
cli();
|
|
sensor.read();
|
|
sei();
|
|
}
|
|
#endif
|
|
|
|
if(alm != oldAlm)
|
|
{
|
|
oldAlm = alm;
|
|
EEPROM_write_char(0, alm);
|
|
}
|
|
|
|
#ifdef HAS_TRANSMITTER
|
|
if(oldRelaySetting != relaySetting)
|
|
{
|
|
writePin(&PORTB, PB4, false);
|
|
oldRelaySetting = relaySetting;
|
|
relay.setValue(relaySetting);
|
|
display.setString( relaySetting ? "RLY ON " : "RLY OFF ");
|
|
_delay_ms(1000);
|
|
}
|
|
#endif
|
|
|
|
if(setting)
|
|
{
|
|
setAlarm(&alarmA, DualCl56::SEG_A);
|
|
setting = true;
|
|
setAlarm(&alarmB, DualCl56::SEG_D);
|
|
EEPROM_write_class(128, alarmA);
|
|
EEPROM_write_class(128+64, alarmB);
|
|
}
|
|
|
|
time = clock.getTime();
|
|
|
|
#ifdef HAS_DHT
|
|
displayItems(time, sensor.temperature, sensor.humidity);
|
|
#else
|
|
displayItems(time, 0, 0);
|
|
#endif
|
|
if(time.hour == alarmA.hour && time.min == alarmA.min && time.sec == 0)
|
|
{
|
|
ringging = true;
|
|
}
|
|
|
|
if(time.hour == alarmB.hour && time.min == alarmB.min && time.sec == 0)
|
|
{
|
|
#ifdef HAS_TRANSMITTER
|
|
relay.setValue(true);
|
|
#else
|
|
ringging = true;
|
|
#endif
|
|
}
|
|
|
|
#ifdef HAS_RECIVER
|
|
serialDispatch(&serial, &sensors);
|
|
if(deleteDate != time.day)
|
|
{
|
|
displaying = 0;
|
|
sensors.clear();
|
|
deleteDate = time.day;
|
|
display.setString("CLEAR ");
|
|
_delay_ms(1000);
|
|
}
|
|
#endif
|
|
++i;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|