#include "project.h"


#define N_VALVES 8

static volatile int semaphore = 0;



static const char *plc0_valve_names[N_VALVES] = {
  "dd_radiator1",
  "dd_radiator2",
  "dd_radiator3",
  "hall_radiator",
  "kitchen_radiator",
  "music_room_radiator",
  "bathroom_radiator",
  "plc0_radiator7",
};

static const Onewire_addr plc0_valve_owas[N_VALVES] = {
  {{0x28, 0x09, 0xb3, 0xc3, 0x0b, 0x00, 0x00, 0xf9}},
  {{0x28, 0x89, 0xda, 0xc3, 0x0b, 0x00, 0x00, 0xf1}},
  {{0x28, 0xdf, 0xb2, 0xc6, 0x0b, 0x00, 0x00, 0xc3}},
  {{0x28, 0x42, 0x23, 0xc4, 0x0b, 0x00, 0x00, 0x45}},
  {{0x28, 0xf9, 0xd6, 0xc6, 0x0b, 0x00, 0x00, 0xc9}},
  {{0x28, 0x8d, 0x0a, 0xc6, 0x0b, 0x00, 0x00, 0xf2}},
  {{0x28, 0x5f, 0xb7, 0xc6, 0x0b, 0x00, 0x00, 0xfb}},
  {{0x28, 0x25, 0xe5, 0xc6, 0x0b, 0x00, 0x00, 0xba}},
};












static const char *plc1_valve_names[N_VALVES] = {
  "2fl_main_radiator",
  "2fl_stair_radiator",
  "plc1_radiator2",
  "plc1_radiator3",
  "plc1_radiator4",
  "plc1_radiator5",
  "plc1_radiator6",
  "plc1_radiator7",
};


static const Onewire_addr plc1_valve_owas[N_VALVES] = {
  {{0x28, 0x03, 0x01, 0xc5, 0x0b, 0x00, 0x00, 0xf3}},
  {{0x28, 0xea, 0x79, 0xc5, 0x0b, 0x00, 0x00, 0x1f}},
  {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
  {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
  {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
  {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
  {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
  {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
};


Onewire_addr owa_zero = {0};


static const char **valve_name;
static const Onewire_addr *valve_owa;
volatile int temp[N_VALVES];

#define BAD_TEMP 0x7fffffff

int low_limit[N_VALVES] = {
  15000,
  15000,
  15000,
  15000,
  15000,
  15000,
  15000,
  00000,
};


int high_limit[N_VALVES] = {
  15000,
  15000,
  15000,
  15000,
  15000,
  15000,
  15000,
  00000,
};

int override[N_VALVES];

int valve_state[N_VALVES];
int failed_reads[N_VALVES];



static float scale (int i)
{
  float ret;

  ret = i;
  return ret / 1000.;
}


void mqtt_dispatch (char *type, char *who, char *what, char *msg)
{
  unsigned i;
  static char msg_buf[80];

  if (strcmp (type, "cmnd")) return;

  for (i = 0; i < N_VALVES; ++i) {

    if (!strcmp (who, valve_name[i])) {
      if (!strcmp (what, "var1")) {
        low_limit[i] = atoi (msg) * 1000;
        usart1_queue_buf (msg_buf, sprintf (msg_buf, "\r\nMQTTR stat/%s/var1 %.2f\r\n", valve_name[i], scale (low_limit[i])));
      }

      if (!strcmp (what, "var2")) {
        high_limit[i] = atoi (msg) * 1000;
        usart1_queue_buf (msg_buf, sprintf (msg_buf, "\r\nMQTTR stat/%s/var2 %.2f\r\n", valve_name[i], scale (high_limit[i])));
      }

      if (!strcmp (what, "var3")) {
        override[i] = atoi (msg);
        usart1_queue_buf (msg_buf, sprintf (msg_buf, "\r\nMQTTR stat/%s/var3 %d\r\n", valve_name[i], override[i]));
      }

    }
  }
}

void logic_tick (void)
{
  static unsigned i;
  static int read_failed = 1;
  static int not_present = 1;
  static char msg_buf[80];
  int t;
  int o;
  int v;

  if (!not_present) {
    if (!read_failed)
      read_failed = ds18b20_read (&valve_owa[i], &t);

    if (read_failed)  {
      temp[i] = BAD_TEMP;
      valve_state[i] = 0;
      failed_reads[i]++;
    } else  {
      temp[i] = t;
      failed_reads[i] = 0;

      if (t < low_limit[i])
        valve_state[i] = 1;

      if (t >= high_limit[i])
        valve_state[i] = 0;
    }

    if (override[i])
	valve_state[i]=1;

    o = valve_state[i];

    output_write (i, o);
    v = input_get (i);

    usart1_queue_buf (msg_buf, sprintf (msg_buf, "\r\nMQTTR stat/%s/POWER %s\r\n", valve_name[i], o ? "ON" : "OFF"));
    usart1_queue_buf (msg_buf, sprintf (msg_buf, "\r\nMQTTR stat/%s/OPEN %d\r\n", valve_name[i], v));

    usart1_queue_buf (msg_buf, sprintf (msg_buf, "\r\nMQTTR stat/%s/var1 %.2f\r\n", valve_name[i], scale (low_limit[i])));

    usart1_queue_buf (msg_buf, sprintf (msg_buf, "\r\nMQTTR stat/%s/var2 %.2f\r\n", valve_name[i], scale (high_limit[i])));



    if (!read_failed) {
      usart1_queue_buf (msg_buf, sprintf (msg_buf, "\r\nMQTTR stat/%s/TEMPERATURE %.2f\r\n", valve_name[i], scale (temp[i])));
      usart1_queue_buf (msg_buf, sprintf (msg_buf, "\r\nMQTTR stat/%s/DELTA %.2f\r\n", valve_name[i], scale (low_limit[i] - temp[i])));
    }

    usart1_queue_buf (msg_buf, sprintf (msg_buf, "\r\nMQTTR stat/%s/failed_reads %d\r\n", valve_name[i], failed_reads[i]));

  } else {
    valve_state[i] = 0;
    o = valve_state[i];
    output_write (i, o);
  }


  i++;

  if (i >= N_VALVES)
    i = 0;

  if (request_search) {
    request_search = 0;
    onewire_search();
  }

  if (!memcmp (&valve_owa[i], &owa_zero, sizeof (owa_zero)))
    not_present = 1;
  else {
    not_present = 0;
    read_failed = ds18b20_set_12_convert (&valve_owa[i]);
  }
}


void logic_slow_tick (void)
{
  semaphore = 1;
}


void logic_dispatch (void)
{
}


void logic_init (void)
{
  char serial[25] = {0};

  desig_get_unique_id_as_string (serial, sizeof (serial));

  if (!strcmp (serial, "325715574155303632FFD305")) {
    valve_name = plc0_valve_names;
    valve_owa = plc0_valve_owas;
      low_limit[5] = 18000;
      high_limit[5] = 19000;
  } else if (!strcmp (serial, "378125574155383139FFD805")) {
    valve_name = plc1_valve_names;
    valve_owa = plc1_valve_owas;
  } else {
    printf ("serial: %s\n", serial);
    valve_name = plc0_valve_names;
    valve_owa = plc0_valve_owas;
  }


}