1 files changed, 358 insertions, 0 deletions

diff --git a/tv_light/src/tv_light.cpp b/tv_light/src/tv_light.cpp
new file mode 100644
index 0000000..caf3a6e
--- /dev/null
+++ b/tv_light/src/tv_light.cpp
@@ -0,0 +1,358 @@
+/**
+ * The MySensors Arduino library handles the wireless radio link and protocol
+ * between your home built sensors/actuators and HA controller of choice.
+ * The sensors forms a self healing radio network with optional repeaters. Each
+ * repeater and gateway builds a routing tables in EEPROM which keeps track of the
+ * network topology allowing messages to be routed to nodes.
+ */
+
+// Enable debug prints to serial monitor
+//#define MY_DEBUG
+
+// configure radio
+#define MY_RADIO_RFM69
+
+/** @brief RFM69 frequency to use (RF69_433MHZ for 433MHz, RF69_868MHZ for 868MHz or RF69_915MHZ for 915MHz). */
+#define MY_RFM69_FREQUENCY RF69_868MHZ
+
+/** @brief Enable this if you're running the RFM69HW model. */
+#define MY_IS_RFM69HW
+
+/** @brief RFM69 Network ID. Use the same for all nodes that will talk to each other. */
+#define MY_RFM69_NETWORKID 1
+
+/** @brief Node id defaults to AUTO (tries to fetch id from controller). */
+#define MY_NODE_ID 2
+
+/** @brief If set, transport traffic is unmonitored and GW connection is optional */
+#define MY_TRANSPORT_DONT_CARE_MODE
+
+/** @brief Node parent defaults to AUTO (tries to find a parent automatically). */
+#define MY_PARENT_NODE_ID 0
+
+/** @brief The user-defined AES key to use for EEPROM personalization */
+#include "aes_key.h"
+
+// Enable repeater functionality for this node
+//#define MY_REPEATER_FEATURE
+
+/** @brief Enables RFM69 automatic transmit power control class. */
+//#define MY_RFM69_ATC
+
+#ifdef MY_AES_KEY
+/** @brief enables RFM69 encryption */
+#define MY_RFM69_ENABLE_ENCRYPTION
+#endif
+
+#include <Arduino.h>
+#include <MySensors.h>
+#include <avr/pgmspace.h>
+
+enum sensor_type : uint8_t
+{
+  SENSOR_RELAY  = (1u << 0),
+  SENSOR_DIMMER = (1u << 1),
+  SENSOR_BUTTON = (1u << 2),
+};
+
+struct sensor_t
+{
+  uint8_t id;
+  uint8_t type;
+  struct
+  {
+    uint8_t pin;    // relay pin
+  } relay;
+  struct
+  {
+    uint8_t  pin;   // dimmer pin
+    uint16_t level; // current dim level (0 to 100)
+  } dimmer;
+};
+
+struct sensor_t sensors[] = {
+  {
+    .id     = 0,
+    .type   = SENSOR_RELAY,
+    .relay  = { .pin = 4 },
+  },
+  {
+    .id     = 1,
+    .type   = SENSOR_RELAY | SENSOR_DIMMER,
+    //.type   = SENSOR_RELAY,
+    .relay  = { .pin = 5 },
+    .dimmer = { .pin = 6, .level = 100 },
+  },
+};
+
+//#define SAVE_RESTORE
+
+#define NUM(a) (sizeof(a) / sizeof(*a))
+
+#define RELAY_ON          1  // GPIO value to write to turn on attached relay
+#define RELAY_OFF         0  // GPIO value to write to turn off attached relay
+
+#define DIMMER_FADE_DELAY 40 // Delay in ms for each percentage fade up/down (10ms = 1s full-range dim)
+
+#define TEMP_SENSOR_ID     254
+#define TEMP_READ_INTERVAL 1000L // read temp every 1 sec
+#define TEMP_N_READS_MSG   60*60 // force temp message every n reads
+#define TEMP_OFFSET        0
+
+MyMessage msg(0, V_STATUS);
+
+inline void checkTemperature(void);
+bool relayRead(struct sensor_t *sensor);
+void relayWrite(struct sensor_t *sensor, bool state, bool send_update=false);
+void flipRelay(struct sensor_t *sensor, bool send_update=false);
+inline uint8_t pwmValue(uint8_t level);
+void fadeDimmer(struct sensor_t *sensor, uint8_t level, bool send_update=false);
+
+void before()
+{
+  // set relay pins to output mode + restore to last known state
+  for (uint8_t i = 0; i < NUM(sensors); i++)
+  {
+    struct sensor_t *sensor = &sensors[i];
+    if (sensor->type & SENSOR_RELAY)
+    {
+      pinMode(sensor->relay.pin, OUTPUT);
+#ifdef SAVE_RESTORE
+      digitalWrite(sensor->relay.pin, loadState(sensor->id) ? RELAY_ON : RELAY_OFF);
+#else
+      digitalWrite(sensor->relay.pin, RELAY_OFF);
+#endif
+    }
+
+    if (sensor->type & SENSOR_DIMMER)
+    {
+      pinMode(sensor->dimmer.pin, OUTPUT);
+#ifdef SAVE_RESTORE
+      uint8_t level = loadState(NUM(sensors) + sensor->id;
+#else
+      uint8_t level = sensor->dimmer.level;
+#endif
+      if ((sensor->type & SENSOR_RELAY) && !relayRead(sensor))
+        level = 0;
+      analogWrite(sensor->dimmer.pin, pwmValue(level));
+    }
+  }
+
+#ifdef MY_AES_KEY
+  const uint8_t user_aes_key[16] = { MY_AES_KEY };
+  uint8_t cur_aes_key[16];
+  hwReadConfigBlock((void*)&cur_aes_key, (void*)EEPROM_RF_ENCRYPTION_AES_KEY_ADDRESS, sizeof(cur_aes_key));
+  if (memcmp(&user_aes_key, &cur_aes_key, 16) != 0)
+  {
+    hwWriteConfigBlock((void*)user_aes_key, (void*)EEPROM_RF_ENCRYPTION_AES_KEY_ADDRESS, sizeof(user_aes_key));
+    debug(PSTR("AES key written\n"));
+  }
+#endif
+}
+
+void setup()
+{
+#ifdef MY_IS_RFM69HW
+  _radio.setHighPower(true);
+#endif
+#ifdef MY_RFM69_ATC
+  _radio.enableAutoPower(-70);
+  debug(PSTR("ATC enabled\n"));
+#endif
+}
+
+void presentation()
+{
+  sendSketchInfo("TVLight", "1.0");
+
+  // register all sensors to gw (they will be created as child devices)
+  for (uint8_t i = 0; i < NUM(sensors); i++)
+  {
+    struct sensor_t *sensor = &sensors[i];
+    if (sensor->type & SENSOR_DIMMER)
+      present(sensor->id, S_DIMMER);
+    else if (sensor->type & SENSOR_RELAY || sensor->type & SENSOR_BUTTON)
+      present(sensor->id, S_BINARY);
+  }
+
+#if TEMP_SENSOR_ID >= 0
+  present(TEMP_SENSOR_ID, S_TEMP);
+#endif
+}
+
+void loop()
+{
+  //TODO maybe call _radio.rcCalibration() all 1000x changes?
+#if TEMP_SENSOR_ID >= 0
+  checkTemperature();
+#endif
+}
+
+inline void checkTemperature(void)
+{
+  static unsigned long lastTempUpdate = millis();
+  static unsigned int numTempUpdates = 0;
+  static float lastTemp = 0;
+  static MyMessage msgTemp(TEMP_SENSOR_ID, V_TEMP);
+
+  unsigned long now = millis();
+  if (now - lastTempUpdate > TEMP_READ_INTERVAL)
+  {
+    float temp = _radio.readTemperature() + TEMP_OFFSET;
+    lastTempUpdate = now;
+    if (isnan(temp))
+      Serial.println(F("Failed reading temperature"));
+    else if (abs(temp - lastTemp) >= 2 || numTempUpdates == TEMP_N_READS_MSG)
+    {
+      lastTemp = temp;
+      numTempUpdates = 0;
+      send(msgTemp.set(temp, 2));
+#ifdef MY_DEBUG
+      char str_temp[6];
+      dtostrf(temp, 4, 2, str_temp);
+      debug(PSTR("Temperature: %s °C\n"), str_temp);
+#endif
+    }
+    else
+      ++numTempUpdates;
+  }
+}
+
+void receive(const MyMessage &message)
+{
+  if (message.type == V_STATUS || message.type == V_PERCENTAGE)
+  {
+    uint8_t sensor_id = message.sensor;
+    if (sensor_id >= NUM(sensors))
+    {
+      Serial.print(F("Invalid sensor id:"));
+      Serial.println(sensor_id);
+      return;
+    }
+
+    struct sensor_t *sensor = &sensors[sensor_id];
+    if (message.type == V_STATUS && sensor->type & SENSOR_RELAY)
+    {
+      if (mGetCommand(message) == C_REQ)
+        send(msg.setType(V_STATUS).setSensor(sensor->id).set(relayRead(sensor)));
+      else if (mGetCommand(message) == C_SET)
+        relayWrite(sensor, message.getBool());
+    }
+    else if (message.type == V_PERCENTAGE && sensor->type & SENSOR_DIMMER)
+    {
+      if (mGetCommand(message) == C_REQ)
+        send(msg.setType(V_PERCENTAGE).setSensor(sensor->id).set(sensor->dimmer.level));
+      else if (mGetCommand(message) == C_SET)
+      {
+        uint16_t level = message.getUInt();
+        fadeDimmer(sensor, (level > 100) ? 100 : level);
+      }
+    }
+  }
+}
+
+bool relayRead(struct sensor_t *sensor)
+{
+  if (sensor->type & SENSOR_RELAY)
+    return digitalRead(sensor->relay.pin) == RELAY_ON;
+  return false;
+}
+
+void relayWrite(struct sensor_t *sensor, bool state, bool send_update)
+{
+  if (!(sensor->type & SENSOR_RELAY))
+    return;
+
+  Serial.print(F("Incoming change for relay: "));
+  Serial.print(sensor->relay.pin);
+  Serial.print(F(", New state: "));
+  Serial.println(state);
+
+  digitalWrite(sensor->relay.pin, state ? RELAY_ON : RELAY_OFF);
+
+  if (sensor->type & SENSOR_DIMMER)
+    analogWrite(sensor->dimmer.pin, state ? pwmValue(sensor->dimmer.level) : 0);
+
+#ifdef SAVE_RESTORE
+  saveState(sensor->id, state ? RELAY_ON : RELAY_OFF);
+#endif
+
+  if (send_update)
+    send(msg.setType(V_STATUS).setSensor(sensor->id).set(state));
+}
+
+void flipRelay(struct sensor_t *sensor, bool send_update)
+{
+  relayWrite(sensor, relayRead(sensor) ? RELAY_OFF : RELAY_ON, send_update);
+}
+
+inline uint8_t pwmValue(uint8_t level)
+{
+  // see https://www.mikrocontroller.net/articles/LED-Fading
+#if 0
+  static const uint8_t pwmtable[101] PROGMEM = {
+    0,   1,   1,   1,   1,   1,   1,   2,   2,   2,
+    2,   2,   2,   2,   2,   2,   3,   3,   3,   3,
+    3,   3,   4,   4,   4,   4,   4,   5,   5,   5,
+    5,   6,   6,   6,   7,   7,   8,   8,   8,   9,
+    9,   10,  11,  11,  12,  12,  13,  14,  15,  16,
+    16,  17,  18,  19,  20,  22,  23,  24,  25,  27,
+    28,  30,  32,  33,  35,  37,  39,  42,  44,  47,
+    49,  52,  55,  58,  61,  65,  68,  72,  76,  81,
+    85,  90,  95,  100, 106, 112, 118, 125, 132, 139,
+    147, 156, 164, 174, 183, 194, 205, 216, 228, 241,
+    255
+  };
+  return (uint8_t)pgm_read_byte(&pwmtable[level]);
+#else
+  // max pwm: 255-19, 101 steps, every step +20
+  static const uint8_t pwmtable[101] PROGMEM = {
+      0,  20,  20,  20,  20,  20,  20,  21,  21,  21,
+     21,  21,  21,  21,  21,  21,  22,  22,  22,  22,
+     22,  22,  22,  23,  23,  23,  23,  24,  24,  24,
+     24,  25,  25,  25,  26,  26,  26,  27,  27,  28,
+     28,  29,  29,  30,  30,  31,  32,  32,  33,  34,
+     35,  36,  37,  38,  39,  40,  41,  42,  43,  45,
+     46,  48,  49,  51,  53,  55,  57,  59,  61,  63,
+     66,  68,  71,  74,  77,  80,  83,  87,  91,  95,
+     99, 103, 108, 113, 118, 124, 130, 136, 142, 149,
+    156, 164, 172, 181, 190, 199, 209, 220, 231, 243,
+    255
+  };
+  return 255 - (uint8_t)pgm_read_byte(&pwmtable[level]);
+#endif
+}
+
+void fadeDimmer(struct sensor_t *sensor, uint8_t level, bool send_update)
+{
+  if (!(sensor->type & SENSOR_DIMMER))
+    return;
+  if (level > 100)
+    level = 100;
+
+  Serial.print(F("Incoming change for dimmer: "));
+  Serial.print(sensor->dimmer.pin);
+  Serial.print(F(", New level: "));
+  Serial.println(level);
+
+  if (level > 0 && sensor->type & SENSOR_RELAY && !relayRead(sensor))
+    relayWrite(sensor, RELAY_ON);
+
+  int delta = ((int8_t)(level - sensor->dimmer.level) < 0) ? -1 : 1;
+  while (sensor->dimmer.level != level)
+  {
+    sensor->dimmer.level += delta;
+    analogWrite(sensor->dimmer.pin, pwmValue(sensor->dimmer.level));
+    delay(DIMMER_FADE_DELAY);
+  }
+
+  if (level == 0 && sensor->type & SENSOR_RELAY && relayRead(sensor))
+    relayWrite(sensor, RELAY_OFF);
+
+#ifdef SAVE_RESTORE
+  saveState(NUM(sensors) + sensor->id, level);
+#endif
+
+  if (send_update)
+    send(msg.setType(V_PERCENTAGE).setSensor(sensor->id).set(level));
+}