#include "stm32f0xx_hal.h"

#include "si446x.h"

#include "config.h"

#include "error.h"

#include "system/gpio.h"

#include "system/sysclk.h"

// Private variables

static SPI_HandleTypeDef hspi1;

static uint8_t si446x_cw_status = 0;

// Private function prototypes

static void __init_spi1(void);

// Initialize Si446x in 2FSK transmit mode

void si446x_init(void)

{

	// init spi port

	__init_spi1();

	GPIO_InitTypeDef GPIO_InitStruct;

	// GPIO: TCXO control

	GPIO_InitStruct.Pin = SI446x_TCXO_EN_PIN;

	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

	GPIO_InitStruct.Pull = GPIO_NOPULL;

	HAL_GPIO_Init(SI446x_TCXO_EN_PORT, &GPIO_InitStruct);

	HAL_GPIO_WritePin(SI446x_TCXO_EN_PORT, SI446x_TCXO_EN_PIN, 1);

	// GPIO: VHF radio shutdown control

	GPIO_InitStruct.Pin = SI446x_SHUTDOWN_PIN;

	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

	GPIO_InitStruct.Pull = GPIO_NOPULL;

	HAL_GPIO_Init(SI446x_SHUTDOWN_PORT, &GPIO_InitStruct);

	// Perform PoR (takes 20ms) and turn device on

	si446x_reset();

	si446x_reset();

    // Divide SI446x_VCXO_FREQ into its bytes; MSB first

    uint16_t x3 = SI446x_VCXO_FREQ / 0x1000000;

    uint16_t x2 = (SI446x_VCXO_FREQ - x3 * 0x1000000) / 0x10000;

    uint16_t x1 = (SI446x_VCXO_FREQ - x3 * 0x1000000 - x2 * 0x10000) / 0x100;

    uint16_t x0 = (SI446x_VCXO_FREQ - x3 * 0x1000000 - x2 * 0x10000 - x1 * 0x100);

    // Power up radio module                          boot  xtal  _XO_frequency_

    //TCXO

    const char init_command[] = {SI446x_CMD_POWER_UP, 0x01, 0x01, x3, x2, x1, x0};

    si446x_sendcmd(7, init_command, SI446x_CHECK_ACK);

    HAL_Delay(10);

	// Change to SPI Ready state EMZ added for re-init, might help on startup

	uint8_t change_state_commanda[] = {SI446x_CMD_CHANGE_STATE, 0x02}; //  Change to spi ready

    si446x_sendcmd(2, change_state_commanda, SI446x_CHECK_ACK);

    HAL_Delay(10);

    // Radio ready: clear all pending interrupts and get the interrupt status back

	uint8_t get_int_status_command[] = {SI446x_CMD_GET_INT_STATUS, 0x00, 0x00, 0x00};

    si446x_sendcmd(4, get_int_status_command, SI446x_CHECK_ACK);

    HAL_Delay(10);

    // GPIO config: Set all GPIOs LOW; Link NIRQ to CTS; Link SDO to MISO; Max drive strength

	uint8_t gpio_pin_cfg_command[] = {

    		SI446x_CMD_GPIO_PIN_CFG, // Command

			SI446x_GPIO_LOW,      // GPIO0 - Power amp control DAC AD5611 Sync Pin

			SI446x_GPIO_INPUT,    // GPIO1 - Input for modulation

			SI446x_GPIO_LOW,      // GPIO2 - Blue LED

			SI446x_GPIO_NOCHANGE, // GPIO3 - Unused

			SI446x_GPIO_NOCHANGE, // NIRQ

			SI446x_GPIO_NOCHANGE, // 0x11, // SDO

			SI446x_GPIO_NOCHANGE, // Gencfg

	};

    si446x_sendcmd(8, gpio_pin_cfg_command, SI446x_CHECK_ACK);

    HAL_Delay(10);

//	uint8_t tune_xo_cmd[] = {

//    		SI446x_CMD_SET_PROPERTY,

//			SI446x_XO_TUNE_REGISTER_GROUP,

//			0x1, // num data

//			SI446x_XO_TUNE_REGISTER_PROP,

//			SI446x_CRYSTAL_LOAD_TUNING,

//    };

//    si446x_sendcmd(5, tune_xo_cmd, SI446x_CHECK_ACK);

    HAL_Delay(10);

    // Tune to frequency specified

	si446x_setchannel(TUNE_FREQUENCY);

	HAL_Delay(10);

    // Set to 2FSK mode

    uint8_t modemconfig = SI446x_MOD_TYPE_2FSK | SI446x_MOD_TYPE_SOURCE_DIRECTMODE | SI446x_MOD_TYPE_DIRECT_ASYNCH | SI446x_MOD_TYPE_DIRECT_SOURCE_GPIO1; //SI446x_MOD_TYPE_SOURCE_PACKETHANDLER

    uint8_t set_modem_mod_type_command[] = {

    		SI446x_CMD_SET_PROPERTY,

    		SI446x_MOD_TYPE_REGISTER_GROUP,

			0x01, // num data

			SI446x_MOD_TYPE_REGISTER_PROP,

			modemconfig

    };

    si446x_sendcmd(5, set_modem_mod_type_command, SI446x_CHECK_ACK);

    HAL_Delay(10);

	// Set Si446x initial output power, input to power amp (0-0x7F, 0mW - 40mw?)

	uint8_t basepower = 0x02;

	// FIXME: basepower should be 0x10 for underperforming units and 0x04 for normal units

    uint8_t set_power_level_command[] = {SI446x_CMD_SET_PROPERTY, 0x22, 0x01, 0x01, basepower};

	si446x_sendcmd(5, set_power_level_command, SI446x_CHECK_ACK);

	HAL_Delay(10);

    // Set air data rate

    si446x_setdatarate();

    HAL_Delay(10);

	// Tune TX

	uint8_t change_state_command[] = {SI446x_CMD_CHANGE_STATE, 0x05}; //  Change to TX tune state

    si446x_sendcmd(2, change_state_command, SI446x_CHECK_ACK);

    HAL_Delay(10);

	si446x_cw_status = 0;

}

// Perform power-on-reset of Si446x. Takes 20ms.

void si446x_reset(void)

{

	si446x_shutdown();

	HAL_Delay(10);

	si446x_wakeup();

	HAL_Delay(10);

}

// Set GPIO pin state on Si446x

void si446x_gpio(uint8_t gpio, uint8_t state, uint8_t doack)

{

	// GPIO invalid

	if(gpio > 7)

		return;

	// Default to not changing any GPIO

	uint8_t gpio_pin_cfg_command[] = {

			SI446x_CMD_GPIO_PIN_CFG, // Command

			SI446x_GPIO_NOCHANGE, // GPIO0 - Power amp control DAC AD5611 Sync Pin

			SI446x_GPIO_NOCHANGE, // GPIO1 - Input for modulation

			SI446x_GPIO_NOCHANGE, // GPIO2 - Blue

			SI446x_GPIO_NOCHANGE, // GPIO3 - Unused

			SI446x_GPIO_NOCHANGE, // NIRQ

			SI446x_GPIO_NOCHANGE, // 0x11, // SDO

			SI446x_GPIO_NOCHANGE, // Gencfg

	};

	// Set requested GPIO to requested state

	gpio_pin_cfg_command[gpio+1] = state;

	si446x_sendcmd(8, gpio_pin_cfg_command, doack);

}

// Set over-air data rate

void si446x_setdatarate(void)

{

    // Set data rate (unsure if this actually affects direct modulation)

                         //        set prop   group     numprops  startprop   data

	uint8_t set_data_rate_command[] = {SI446x_CMD_SET_PROPERTY,     0x20,     0x03,     0x03,       0x0F, 0x42, 0x40};

    si446x_sendcmd(7, set_data_rate_command, SI446x_CHECK_ACK);

}

// Block write data to the Si446x SPI interface, up to 128 byte length

void si446x_senddata(uint8_t* data, uint8_t len)

{

	uint8_t dummy[128];

	SI446x_SELECT;

	HAL_SPI_TransmitReceive(&hspi1, data, dummy, len, SI446x_TIMEOUT);

	SI446x_DESELECT;

}

// Delay approximately 20us

static void delay_cycles(void)

{

	uint32_t delay_cycles = 180;

	while(delay_cycles>0)

	{

		asm("NOP");

		delay_cycles--;

	}

}

// Send a command to the radio (Blocking)

// Avoid calling this during code runtime as it will block for a significant period of time due to delays

void si446x_sendcmd(uint8_t tx_len, uint8_t* data, uint8_t doack)

{

    SI446x_SELECT;

    delay_cycles();

    uint8_t dummyrx[25];

    if(tx_len >=25)

    {

    	SI446x_DESELECT;

    	return;

    }

    // using transmit receive to transmit data because it actually blocks until the data is sent

    // an additional byte is added on to the transmission so we can receive the CTS byte

    volatile HAL_StatusTypeDef res = HAL_SPI_TransmitReceive(&hspi1, data, dummyrx, tx_len+1, SI446x_TIMEOUT);

    if(res != HAL_OK)

    {

    	SI446x_DESELECT;

    	return;

    }

    SI446x_DESELECT;

    // If checking for the ACK, perform a SPI read and see if the command was acknowledged

    if(doack)

    {

		delay_cycles();

		SI446x_SELECT;

		int reply = 0x00;

		uint8_t tx_requestack[2];

		tx_requestack[0] = SI446x_CMD_READ_CMD_BUFF;

		tx_requestack[1] = 0x00;

		volatile uint16_t attempts = 0;

		// Keep trying receive until it returns 0xFF (successful ACK)

		while (reply != 0xFF)

		{

			// Attempt to receive two bytes from the Si446x which should be an ACK

			uint8_t tmprx[2] = {0,0};

			res = HAL_SPI_TransmitReceive(&hspi1, tx_requestack, tmprx, 2, SI446x_TIMEOUT);

			if(res != HAL_OK)

			{

				//error_assert_silent(ERR_VHF_SPIBUSY);

		    	break; // Break out, deinit, and exit

			}

			reply = tmprx[1];

			// Cycle chip select line on and off

			if (reply != 0xFF)

			{

				delay_cycles();

				SI446x_DESELECT;

				delay_cycles();

				SI446x_SELECT;

				delay_cycles();

				//HAL_GPIO_TogglePin(LED_ACT);

			}

			// Maximum number of attempts exceeded

			if(attempts > 1024)

			{

				//error_assert_silent(ERR_VHF_TIMEOUT);

				volatile uint32_t test = 344;

				break; // Break out, deinit and exit

			}

			attempts++;

		}

    }

    // Turn off activity LED

    //HAL_GPIO_WritePin(LED_ACT, GPIO_PIN_RESET);

    SI446x_DESELECT;

    delay_cycles();

}

// Set transmit frequency of Si446x

void si446x_setchannel(uint32_t frequency)

{

    // Set the output divider according to recommended ranges given in si446x datasheet

    uint32_t outdiv = 4;

    uint32_t band = 0;

    if (frequency < 705000000UL) { outdiv = 6;  band = 1;};

    if (frequency < 525000000UL) { outdiv = 8;  band = 2;};

    if (frequency < 353000000UL) { outdiv = 12; band = 3;};

    if (frequency < 239000000UL) { outdiv = 16; band = 4;};

    if (frequency < 177000000UL) { outdiv = 24; band = 5;};

    uint32_t f_pfd = 2 * SI446x_VCXO_FREQ / outdiv;

    uint32_t n = ((uint32_t)(frequency / f_pfd)) - 1;

    float ratio = (float)frequency / (float)f_pfd;

    float rest  = ratio - (float)n;

    uint32_t m = (uint32_t)(rest * 524288UL);

    // Set the band parameter

    uint32_t sy_sel = 8;

    uint8_t set_band_property_command[] = {SI446x_CMD_SET_PROPERTY, 0x20, 0x01, 0x51, (band + sy_sel)};

    si446x_sendcmd(5, set_band_property_command, SI446x_CHECK_ACK);

    // Set the pll parameters

    uint32_t m2 = m / 0x10000;

    uint32_t m1 = (m - m2 * 0x10000) / 0x100;

    uint32_t m0 = (m - m2 * 0x10000 - m1 * 0x100);

    // Assemble parameter string

    uint8_t set_frequency_property_command[] = {SI446x_CMD_SET_PROPERTY, 0x40, 0x04, 0x00, n, m2, m1, m0};

    si446x_sendcmd(8, set_frequency_property_command, SI446x_CHECK_ACK);

    // Set frequency deviation

    // ...empirically 0xF9 looks like about 5khz. Sketchy.

    //                           set prop   group     numprops  startprop   data                     // Was 0x0F 00 for ~40kHz dev, switched to 56khzish? dev

    //2DF5 is correct for 56khz

    uint8_t set_frequency_separation[] = {SI446x_CMD_SET_PROPERTY, 0x20,     0x03,      0x0a,     0x00, 0x03, 0x00};

    si446x_sendcmd(7, set_frequency_separation, SI446x_CHECK_ACK);

}

// Turn CW transmit on

void si446x_cw_on(void)

{

    // Change to TX state

	uint8_t change_state_command[] = {SI446x_CMD_CHANGE_STATE, 0x07};

    si446x_sendcmd(2, change_state_command, SI446x_CHECK_ACK);

    si446x_cw_status = 1;

}

// Turn CW transmit off

void si446x_cw_off(void)

{

    // Change to ready state

	uint8_t change_state_command[] = {SI446x_CMD_CHANGE_STATE, 0x03};

    si446x_sendcmd(2, change_state_command, SI446x_CHECK_ACK);

    si446x_cw_status = 0;

}

// Returns 1 if CW is on or 0 if CW is off

inline uint8_t si446x_tx_status(void)

{

	return si446x_cw_status;

}

// Initialize SPI port for generation of direct modulation for Si446x

static void __init_spi1(void)

{

	GPIO_InitTypeDef GPIO_InitStruct;

	// GPIO: VHF chip select

	GPIO_InitStruct.Pin = SI446x_CS_PIN;

	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

	GPIO_InitStruct.Pull = GPIO_NOPULL;

	GPIO_InitStruct.Speed = GPIO_SPEED_LOW;

	HAL_GPIO_Init(SI446x_CS_PORT, &GPIO_InitStruct);

	SI446x_DESELECT;

	// SPI pins

	__SPI1_CLK_ENABLE();

	GPIO_InitStruct.Pin = SI446x_SCK_PIN|SI446x_MOSI_PIN|SI446x_MISO_PIN;

	GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

	GPIO_InitStruct.Pull = GPIO_NOPULL;

	GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;

	GPIO_InitStruct.Alternate = GPIO_AF0_SPI1;

#include "config.h"

#include "error.h"

#include "system/gpio.h"

#include "system/sysclk.h"

#include "system/watchdog.h"

#include "system/uart.h"

#include "system/adc.h"

#include "si446x/si446x.h"

#include "aprs/aprs.h"

#include "aprs/afsk.h"

int main(void)

{

  hal_init();

  sysclock_init();

  gpio_init();

  adc_init();

  afsk_init();

  si446x_init();

  si446x_init();

  gps_poweron();

  pressure_init();

  // Software timers

  uint32_t last_transmission = HAL_GetTick();

  uint32_t last_led = HAL_GetTick();

  while (1)

  {

	  // Blink LEDs

	  if(HAL_GetTick() - last_transmission > 700)

	  {

		  gps_update_data(); // Will always return at 1hz rate (default measurement rate)

		  pressure_read();

		  aprs_send();

		  //while(afsk_busy());

		  last_transmission = HAL_GetTick();

	  }

	  if(HAL_GetTick() - last_led > 100)

	  {

		  HAL_GPIO_TogglePin(LED_POWER);

		  last_led = HAL_GetTick();

	  }

	  if(afsk_request_cwoff())

		  si446x_cw_off();

	  // High-frequency function calls

//	  watchdog_feed();

  }

}

#include "config.h"

#include "system/gpio.h"

#include "stm32f0xx_hal.h"

// Private variables

static uint8_t shutdown_triggered = 0;

static uint32_t shutdown_triggered_time = 0;

// Initialize GPIOs

void gpio_init(void)

{

  GPIO_InitTypeDef GPIO_InitStruct;

  // Enable clocks

  __GPIOC_CLK_ENABLE();

  __GPIOF_CLK_ENABLE();

  __GPIOA_CLK_ENABLE();

  __GPIOB_CLK_ENABLE();

  // LEDs 1/2

  GPIO_InitStruct.Pin = PIN_LED_POWER;

  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

  GPIO_InitStruct.Pull = GPIO_NOPULL;

  GPIO_InitStruct.Speed = GPIO_SPEED_LOW;

  HAL_GPIO_Init(PORT_LED_POWER, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = GPS_NOTEN_PIN;

  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

  GPIO_InitStruct.Pull = GPIO_NOPULL;

  GPIO_InitStruct.Speed = GPIO_SPEED_LOW;

  HAL_GPIO_Init(GPS_NOTEN_PORT, &GPIO_InitStruct);

  HAL_GPIO_WritePin(GPS_NOTEN, 1); // yes, keep the chip disabled

  // Toggle the power LED

  HAL_GPIO_TogglePin(LED_POWER);

}

#include "stm32f0xx_hal.h"

#include "system/uart.h"

#include "config.h"

#include "system/gpio.h"

UART_HandleTypeDef huart1;

DMA_HandleTypeDef hdma_usart1_rx;

DMA_HandleTypeDef hdma_usart1_tx;

uint8_t uart_initted = 0;

void uart_init(void)

{

    __GPIOB_CLK_ENABLE();

    __USART1_CLK_ENABLE();

    GPIO_InitTypeDef GPIO_InitStruct;

    // Init gpio pins for uart

    GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

    GPIO_InitStruct.Pull = GPIO_NOPULL; //GPIO_PULLUP;

    GPIO_InitStruct.Speed = GPIO_SPEED_LOW;

    GPIO_InitStruct.Alternate = GPIO_AF1_USART1;

    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // Init UART periph

    huart1.Instance = USART1;

    huart1.Init.BaudRate = 9600;

    huart1.Init.WordLength = UART_WORDLENGTH_8B;

    huart1.Init.StopBits = UART_STOPBITS_1;

    huart1.Init.Parity = UART_PARITY_NONE;

    huart1.Init.Mode = UART_MODE_TX_RX;

    huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;

    huart1.Init.OverSampling = UART_OVERSAMPLING_16;

    //huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;

    huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_RXOVERRUNDISABLE_INIT|UART_ADVFEATURE_DMADISABLEONERROR_INIT;

    huart1.AdvancedInit.OverrunDisable = UART_ADVFEATURE_OVERRUN_DISABLE;

    huart1.AdvancedInit.DMADisableonRxError = UART_ADVFEATURE_DMA_DISABLEONRXERROR;

    HAL_UART_Init(&huart1);

    HAL_Delay(100);

	uint8_t switch_baud[] = "$PUBX,41,1,0003,0001,115200,0*1E\r\n";

	HAL_UART_Transmit(uart_gethandle(), switch_baud, sizeof(switch_baud)/sizeof(uint8_t), 1000);

    HAL_UART_DeInit(&huart1);

    huart1.Init.BaudRate = 115200;

    HAL_UART_Init(&huart1);

//

//    __DMA1_CLK_ENABLE();

//

//  // Init UART DMA

//    hdma_usart1_rx.Instance = DMA1_Channel3;

//    hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;

//    hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;

//    hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;

//    hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;

//    hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;

//    hdma_usart1_rx.Init.Mode = DMA_CIRCULAR;

//    hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW;

//    HAL_DMA_Init(&hdma_usart1_rx);

//

//    __HAL_LINKDMA(&huart1,hdmarx,hdma_usart1_rx);

//

//    hdma_usart1_tx.Instance = DMA1_Channel2;

//    hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;

//    hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;

//    hdma_usart1_tx.Init.MemInc = DMA_MINC_DISABLE;

//    hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;

//    hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;

//    hdma_usart1_tx.Init.Mode = DMA_NORMAL;

//    hdma_usart1_tx.Init.Priority = DMA_PRIORITY_LOW;

//    HAL_DMA_Init(&hdma_usart1_tx);

//

//    __HAL_LINKDMA(&huart1,hdmatx,hdma_usart1_tx);

//

////    HAL_NVIC_SetPriority(DMA1_Channel2_3_IRQn, 0, 0);

////    HAL_NVIC_EnableIRQ(DMA1_Channel2_3_IRQn);

    HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);

    //HAL_NVIC_EnableIRQ(USART1_IRQn);

    HAL_NVIC_DisableIRQ(USART1_IRQn);

    uart_initted = 1;

}

void uart_deinit(void)

{

    if(uart_initted == 1)

    {

        //HAL_DMA_DeInit(&hdma_usart1_rx);

        //HAL_DMA_DeInit(&hdma_usart1_tx);

        HAL_UART_DeInit(&huart1);

        __HAL_RCC_USART1_CLK_DISABLE();

        uart_initted = 0;

    }

}

UART_HandleTypeDef* uart_gethandle(void)

{

    return &huart1;

} 

DMA_HandleTypeDef* uart_get_txdma_handle(void)

{

    return &hdma_usart1_tx;

}

DMA_HandleTypeDef* uart_get_rxdma_handle(void)

{

    return &hdma_usart1_rx;

}