#include "myRadio.h"
#include "board.h"
#include "stm32f10x.h"
#include "stm32f10x_exti.h"
#include "misc.h"

//------------radio include
#include "sx1208.h"
//------------
#include "myRadio_gpio.h"
// #include "myRadio_setting.h"

int8_t rfTxPower;
sx1208_rx_pkt_t *rx_pkt;
static rfRxCallBack rxCb;
static uint8_t rfRxBuffer[255];

void EXTI0_IRQHandler(void)
{
  if(EXTI_GetITStatus(EXTI_Line0) != RESET)
  {
    /* Clear the EXTI line 1 pending bit */
    EXTI_ClearITPendingBit(EXTI_Line0);
    sx1208_onDioIrq();
  }
}
// BOARD_PIN_SPI_GPIOB
void NVIC_Config()
{
  NVIC_InitTypeDef  NVIC_InitStructure;
  EXTI_InitTypeDef  EXTI_InitStructure;
  
  EXTI_ClearITPendingBit(EXTI_Line0);
  EXTI_InitStructure.EXTI_Line = EXTI_Line0;
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  EXTI_Init(&EXTI_InitStructure);
  GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource0);
  /* Enable and set EXTI1 Interrupt */
  NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
}
void sx1208_event(sx1208_event_t state, void *ptr)
{
	switch(state){
	case SX1208_TX_DONE:
    {
		rfRxPacket_ts rfRxPacket;
        if (rxCb)
        {
            rxCb(TX_STA_SECCESS, rfRxPacket);
        }
    }
		break;
	case SX1208_RX_DONE:
    {
        rfRxPacket_ts rfRxPacket;
        rx_pkt = ptr;
        if (rx_pkt->len > MAX_RF_PACKET_LEN)
        {
            rx_pkt->len = MAX_RF_PACKET_LEN;
        }
        
        memset(rfRxPacket.payload, 0, sizeof(rfRxPacket.payload));
        memcpy(rfRxPacket.payload, rx_pkt->buf, rx_pkt->len);
        rfRxPacket.len = rx_pkt->len;
        rfRxPacket.rssi = (-rx_pkt->raw_rssi) / 2;
        if (rxCb)
        {
            rxCb(RX_STA_SECCESS, rfRxPacket);
        }
    }
		break;
	case SX1208_RX_ERROR:
    {
        rfRxPacket_ts rfRxPacket;
        if (rxCb)
        {
            rxCb(RX_STA_TIMEOUT, rfRxPacket);
        }
    }
		break;
	case SX1208_RX_TIMEOUT:
    {
        rfRxPacket_ts rfRxPacket;
        if (rxCb)
        {
            rxCb(RX_STA_TIMEOUT, rfRxPacket);
        }
    }
		break;
	default:
		break;
	}
}
void myRadio_init(int agr0, void *agr1_ptr)
{
    sx1208_config_t sx1208_config;
	myRadio_gpio_init();
    NVIC_Config();
    sx1208_init(sx1208_event);
	sx1208_config.protocol = SX1208_PROTOCOL_NONE;

	sx1208_config.frf = 915000000;
	// sx1208_config.bitrate = 4800;
	// sx1208_config.fdev = 5005;
	sx1208_config.bitrate = 10000;
	sx1208_config.fdev = 25000;

	sx1208_config.crc_mode = SX1208_CRC_OFF;
	sx1208_config.header_mode = SX1208_HEADER_ENABLE;
	sx1208_config.payload_len = 0;		// Set

	sx1208_config.tx_power = 20;

	sx1208_config.tx_preamble_len = 6;
	sx1208_config.rx_preamble_len = 5;

	sx1208_config.sync_word_len = 4;
	sx1208_config.sync_word[0] = 0x55;
	sx1208_config.sync_word[1] = 0x55;
	sx1208_config.sync_word[2] = 0x98;
	sx1208_config.sync_word[3] = 0xF3;
	// sx1208_config.sync_word[0] = 0xC1;
	// sx1208_config.sync_word[1] = 0x94;
	// sx1208_config.sync_word[2] = 0xC1;
	// sx1208_config.sync_word[3] = 0x00;
    // sx1208_initParams();
	sx1208_set_config(&sx1208_config);
    if ((rfRxCallBack )agr1_ptr)
    {
        rxCb = (rfRxCallBack )agr1_ptr;
    }
}

void myRadio_process(void)
{
    sx1208_process();
}
void myRadio_abort(void)
{
    sx1208_set_mode(SX1208_MODE_STANDBY);
}

void myRadio_setChipType(uint8_t type)
{

}
uint8_t myRadio_getChipType(void)
{
    return 0;
}
uint32_t myRadio_getFrequency(void)
{
    return 0;
}
int8_t myRadio_getRssi(void)
{
    return (-sx1208_read_rssi()) / 2;
}
void myRadio_setFrequency(uint32_t freq)
{
    sx1208_set_frf(freq);
}
int8_t myRadio_getTxPower(void)
{
    return rfTxPower;
}
void myRadio_setTxPower(int8_t power)
{
    rfTxPower = power;
    sx1208_set_tx_power(power);
}
void myRadio_transmit(rfTxPacket_ts *packet)
{
    sx1208_send(packet->payload, packet->len, 0);
}
void myRadio_receiver(void)
{ 
    sx1208_receive(rfRxBuffer, 255, 0);
}
void myRadio_receiverSync(rfRxPacket_ts *packet)
{

}
void myRadio_setCtrl(controlMode_te mode, uint32_t value)
{
    static uint8_t old_mode = 0xff;
    // if (old_mode == mode)
    // {
    //     return;
    // }
      
    switch (mode)
    {
    case RADIO_EXT_CONTROL_TX_UNMODULATED:
    {
        sx1208_set_frf(value);
        sx1208_set_fdev(0);
        sx1208_tx_test_mode();
    }
        break;
    case RADIO_EXT_CONTROL_RX_SENSITIVITY:
    {
        sx1208_set_frf(value);
    //   sx1208_set_bitrate(4800);
    //   sx1208_set_fdev(8000);
    //   sx1208_set_rxbw(8000, 4800);
        sx1208_set_bitrate(10000);
        sx1208_set_fdev(25000);
        sx1208_set_rxbw(25000, 10000);
        sx1208_rx_test_mode();
    }
        break;
    
    default:
        break;
    }
    old_mode = mode;
}