/*
 *
 *  mur.sat
 *
 *  Somewhen in the year 20xx, mur.at will have a nano satellite launched
 *  into a low earth orbit (310 km above the surface of our planet). The
 *  satellite itself is a TubeSat personal satellite kit, developed and
 *  launched by interorbital systems. mur.sat is a joint venture of mur.at,
 *  ESC im Labor and realraum.
 *
 *  Please visit the project hompage at sat.mur.at for further information.
 *
 *
 *  Copyright (C) 2013-2015 Christian Pointner <equinox@mur.at>
 *
 *  This file is part of mur.sat.
 *
 *  mur.sat is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *
 *  mur.sat 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 mur.sat. If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include <avr/io.h>
#include <avr/wdt.h>
#include <avr/interrupt.h>
#include <avr/power.h>
#include <stdio.h>
#include <avr/pgmspace.h>

#include "led.h"
#include "util.h"
#include "usbio.h"

#include "hhd70.h"
#include "cc1101.h"
#include "cc1101_defines.h"

#define DEFAULT_FREQ 437525000
int32_t current_freq_hz = DEFAULT_FREQ;


typedef enum { none, receive, send, beacon } task_t;
task_t current_task = none;
task_t last_task = none;

static char* task_to_string(cc1101_state_t state)
{
  switch(state) {
  case none: return "none";
  case receive: return "receiving";
  case send: return "sending";
  case beacon: return "beacon";
  default: return "unknown";
  }
}


static void reset_hhd70(void)
{
  printf("soft resetting HHD70.\r\n");
  cc1101_soft_reset();
}

static void reinit_hhd70(void)
{
  printf("initializing HHD70.\r\n");
  cc1101_reg_init();
}

static void powerdown_hhd70(void)
{
  printf("sending CC1101 to sleep.\r\n");
  cc1101_powerdown();
}

static void osc_off_hhd70(void)
{
  printf("disabling CC1101 oscillator.\r\n");
  cc1101_osc_off();
}

static uint32_t print_actual_freq(void)
{
  uint32_t f = cc1101_get_freq_hz();
  uint16_t hz = f % 1000;
  uint16_t mhz = f / 1000000;
  uint16_t khz = (f % 1000000)/1000;
  printf("actual frequency: %d.%03d%03d MHz\r\n", mhz, khz, hz);
  return f;
}

static void update_current_freq(void)
{
  uint16_t hz = current_freq_hz % 1000;
  uint16_t mhz = current_freq_hz / 1000000;
  uint16_t khz = (current_freq_hz % 1000000)/1000;
  printf("setting frequency to %d.%03d%03d MHz\r\n", mhz, khz, hz);

      // TODO: goto idle mode

  cc1101_set_freq_hz(current_freq_hz);

      // TODO: if old mode wasn't idle go back to this mode

  print_actual_freq();
}

static void print_status(void)
{
  printf("current state: %s\r\n", cc1101_state_to_string(cc1101_get_state()));

  int16_t rssi = (int16_t)cc1101_get_rssi();
  printf("rssi: ");
  if(rssi < 0) {
    printf("-");
    rssi*=-1;
  }
  printf("%d.%01d dB\r\n", (uint16_t)(rssi / 2), (uint16_t)((rssi % 2)*5));
}

static void dump_register_normalized(void)
{
  printf_P(PSTR("IOCFG0: 0x%02X\r\n"), cc1101_get_iocfg0());
  printf_P(PSTR("IOCFG1: 0x%02X\r\n"), cc1101_get_iocfg1());
  printf_P(PSTR("IOCFG2: 0x%02X\r\n"), cc1101_get_iocfg2());

  printf_P(PSTR("FIFOTHR: 0x%02X\r\n"), cc1101_get_fifothr());

  printf_P(PSTR("SYNC: 0x%04X\r\n"), cc1101_get_sync());
  printf_P(PSTR("PKTLEN: 0x%02X\r\n"), cc1101_get_pktlen());
  printf_P(PSTR("PKTCTRL: 0x%04X\r\n"), cc1101_get_pktctrl());
  printf_P(PSTR("ADDR: 0x%02X\r\n"), cc1101_get_addr());

  printf_P(PSTR("CHANNR: 0x%02X\r\n"), cc1101_get_channr());
  printf_P(PSTR("IFFREQ: 0x%02X\r\n"), cc1101_get_iffreq());
  printf_P(PSTR("FREQ_OFFSET: 0x%02X\r\n"), cc1101_get_freq_offset());
  printf_P(PSTR("FREQ: 0x%08lX\r\n"), cc1101_get_freq());
  printf_P(PSTR("MODEMCFG: 0x%08lX\r\n"), cc1101_get_modemcfg());
  printf_P(PSTR("DRATE_BW: 0x%04X\r\n"), cc1101_get_drate_bw());
  printf_P(PSTR("DEVIATN: 0x%02X\r\n"), cc1101_get_deviatn());

  printf_P(PSTR("MCSM: 0x%08lX\r\n"), cc1101_get_mcsm());

  printf_P(PSTR("FOCCFG: 0x%02X\r\n"), cc1101_get_foccfg());
  printf_P(PSTR("BSCFG: 0x%02X\r\n"), cc1101_get_bscfg());
  printf_P(PSTR("AGCCTRL: 0x%08lX\r\n"), cc1101_get_agcctrl());
  printf_P(PSTR("WOREVT: 0x%04X\r\n"), cc1101_get_worevt());
  printf_P(PSTR("WORCTRL: 0x%02X\r\n"), cc1101_get_worctrl());

  printf_P(PSTR("FREND: 0x%04X\r\n"), cc1101_get_frend());
  printf_P(PSTR("FSCAL: 0x%08lX\r\n"), cc1101_get_fscal());
  printf_P(PSTR("RCCTRL: 0x%04X\r\n"), cc1101_get_rcctrl());

  printf_P(PSTR("FSTEST: 0x%02X\r\n"), cc1101_get_fstest());
  printf_P(PSTR("PTEST: 0x%02X\r\n"), cc1101_get_ptest());
  printf_P(PSTR("AGCTEST: 0x%02X\r\n"), cc1101_get_agctest());
  printf_P(PSTR("TEST0: 0x%02X\r\n"), cc1101_get_test0());
  printf_P(PSTR("TEST1: 0x%02X\r\n"), cc1101_get_test1());
  printf_P(PSTR("TEST2: 0x%02X\r\n"), cc1101_get_test2());

  printf_P(PSTR("PARTNUM: 0x%02X\r\n"), cc1101_get_partnum());
  printf_P(PSTR("CHIP_VERSION: 0x%02X\r\n"), cc1101_get_chip_version());
  printf_P(PSTR("FREQ_OFFSET_EST: 0x%02X\r\n"), cc1101_get_freq_offset_est());
  printf_P(PSTR("LQI: 0x%02X\r\n"), cc1101_get_lqi());
  printf_P(PSTR("RSSI: 0x%02X\r\n"), cc1101_get_rssi());
  printf_P(PSTR("MARCSTATE: 0x%02X\r\n"), cc1101_get_marcstate());
  printf_P(PSTR("WORTIME: 0x%04X\r\n"), cc1101_get_wortime());
  printf_P(PSTR("PKT_STATUS: 0x%02X\r\n"), cc1101_get_pkt_status());
  printf_P(PSTR("VCO_VC_DAC: 0x%02X\r\n"), cc1101_get_vco_vc_dac());
  printf_P(PSTR("TX_BYTES: 0x%02X\r\n"), cc1101_get_tx_bytes());
  printf_P(PSTR("RX_BYTES: 0x%02X\r\n"), cc1101_get_rx_bytes());
  printf_P(PSTR("RCCTRL0: 0x%02X\r\n"), cc1101_get_rcctrl0_status());
  printf_P(PSTR("RCCTRL1: 0x%02X\r\n"), cc1101_get_rcctrl1_status());
}

uint8_t patable_data[CC1101_PATABLE_SIZE];

static void print_pa_table(void)
{
  printf("PA Table: ");
  uint8_t i;
  uint8_t l = cc1101_read_patable(patable_data, CC1101_PATABLE_SIZE);
  for(i=0; i<l; ++i)
    printf("%s%02X", i ? " " : "", patable_data[i]);
  printf("\r\n");
}

static void handle_cmd(uint8_t cmd)
{
  switch(cmd) {
  case '0': led_off(); printf("led OFF\r\n"); break;
  case '1': led_on(); printf("led ON\r\n"); break;
  case 't': led_toggle(); printf("led TOGGLE\r\n"); break;
  case '!': cc1101_soft_reset(); reset2bootloader(); break;

  case 'r': reset_hhd70(); current_task = none; break;
  case 'i': reinit_hhd70(); current_task = none; break;
  case 'F': current_freq_hz = DEFAULT_FREQ; update_current_freq(); break;

  case '#': current_freq_hz+=100000; update_current_freq(); break;
  case '+': current_freq_hz+=10000; update_current_freq(); break;
  case ':': current_freq_hz+=1000; update_current_freq(); break;
  case '.': current_freq_hz-=1000; update_current_freq(); break;
  case '-': current_freq_hz-=10000; update_current_freq(); break;
  case '_': current_freq_hz-=100000; update_current_freq(); break;

  case 'P': powerdown_hhd70(); current_task = none; break;
  case 'I': cc1101_idle(); print_status(); current_task = none; break;
  case 'O': osc_off_hhd70(); current_task = none; break;
  case 'C': cc1101_calibrate(); print_status(); current_task = none; break;
  case 'X': cc1101_fasttxon(); print_status(); current_task = none; break;
  case 'R': current_task = receive; break;
  case 'T': current_task = send; break;
  case 'B': current_task = beacon; break;

  case 'f': print_actual_freq(); break;
  case 's': print_status(); break;
  case 'D': cc1101_dump_register(); break;
  case 'd': dump_register_normalized(); break;

  case 'p': print_pa_table(); break;

  default: printf("unknown command\r\n"); return;
  }
}

uint8_t tempdata[255];

static void do_receive_task(uint8_t first)
{
  static uint8_t pos = 0;
  if(first) {
    pos = 0;
    cc1101_rx();
  }

  cc1101_state_t s = cc1101_get_state();
  switch(s) {
  case fs_wakeup:
  case calibrate:
  case settling:
  case rx:
  case txrx_settling: break;
  case rxfifo_overflow: {
    printf("%sRX-Fifo overflow! - resetting fifo...\r\n", pos ? "\r\n": "");
    cc1101_reset_rx_fifo();
    pos = 0;
    break;
  }
  default: {
    printf("%sleaving receive task: invalid state '%s'\r\n", pos ? "\r\n": "", cc1101_state_to_string(s));
    current_task = none;
    return;
  }
  }

  uint8_t r = cc1101_read_rxfifo(tempdata, 255);
  if(r) {
    uint8_t i;
    for(i=0; i<r; ++i) {
      pos++;
      printf("%02X%s", tempdata[i], (pos==8) ? "  " : " ");
      if(pos >= 16) {
        pos = 0;
        printf("\r\n");
      }
    }
  }
}

static void do_send_task(uint8_t first)
{
  printf("leaving send task: not implemented!\r\n");
  current_task = none;
}

static void do_beacon_task(uint8_t first)
{
  printf("leaving beacon task: not implemented!\r\n");
  current_task = none;
}

static void handle_task(void)
{
  uint8_t first = 0;
  if(current_task != last_task) {
    printf("switching to task: %s\r\n", task_to_string(current_task));
    last_task = current_task;
    first = 1;
  }
  switch(current_task) {
  case receive: do_receive_task(first); return;
  case send: do_send_task(first); return;
  case beacon: do_beacon_task(first); return;
  case none: return;
  }
}

int main(void)
{
  MCUSR &= ~(1 << WDRF);
  wdt_disable();

  cpu_init();
  led_init();
  usbio_init();

  hhd70_init();

  sei();
  for(;;) {
    int16_t BytesReceived = usbio_bytes_received();
    while(BytesReceived > 0) {
      int ReceivedByte = fgetc(stdin);
      if(ReceivedByte != EOF) {
        handle_cmd(ReceivedByte);
      }
      BytesReceived--;
    }
    handle_task();

    usbio_task();
  }
}