/*

 * Master Firmware: NMEA Parser

 *

 * This file is part of OpenTrack.

 *

 * OpenTrack is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Affero General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * OpenTrack 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 Affero General Public License for more details.

 *

 * You should have received a copy of the GNU Affero General Public License

 * along with OpenTrack. If not, see <http://www.gnu.org/licenses/>.

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#ifndef GPS_H_

#define GPS_H_

#include <stdint.h>

// Messages (REMOVEME?)

#define GGA_MESSAGE

#define RMC_MESSAGE

#define UKN_MESSAGE

void gps_poweron(void);

void gps_poweroff(void);

void gps_init(void);

void gps_sendubx(uint8_t* data, uint8_t size);

char* get_longitudeTrimmed(void);

char* get_longitudeLSBs(void);

char* get_latitudeTrimmed(void);

char* get_latitudeLSBs(void);

char* get_timestamp(void);

char* get_gpsaltitude(void);

char* get_speedKnots(void);

char* get_course(void);

char* get_hdop(void);

char* get_sv(void);

char* get_dayofmonth(void);

uint8_t gps_hasfix(void);

void parse_gps_transmission(void);

void XORbyteWithChecksum(uint8_t byte);

#endif /* GPS_H_ */

#ifndef __usart_H

#define __usart_H

#include "stm32f0xx_hal.h"

void uart_init(void);

UART_HandleTypeDef* uart_gethandle(void);

DMA_HandleTypeDef* uart_get_txdma_handle(void);

DMA_HandleTypeDef* uart_get_rxdma_handle(void);

#endif 

// TODO: Transition to using https://github.com/cuspaceflight/joey-m/blob/master/firmware/gps.c requesting UBX data

#include "stm32f0xx_hal.h"

#include "config.h"

#include "usart.h"

#include "gps.h"

// Circular buffer for incoming data

uint8_t nmeaBuffer[NMEABUFFER_SIZE];

// Location of parser in the buffer

uint8_t nmeaBufferParsePosition = 0;

uint8_t skipBytes = 0;

//used to index data arrays during data collection

uint32_t numBytes = 0;

//variables to store data from transmission

//least significant digit is stored at location 0 of arrays

char tramsmissionType[7];

void gps_poweron(void)

{

    // NOTE: pchannel

}

void gps_poweroff(void)

{

    // NOTE: pchannel

}

char timestamp[12];	//hhmmss.ss

char* get_timestamp() 

{

	return timestamp;

}

char latitude[14];	//lllll.lla

char latitudeTmpTRIM[8];

char latitudeTmpLSB[4];

char* get_latitudeTrimmed() 

{

	strncpy(latitudeTmpTRIM, &latitude[0], 7);

	latitudeTmpTRIM[7] = 0x00;

	return latitudeTmpTRIM;

}

char* get_latitudeLSBs()

{

	strncpy(latitudeTmpLSB, &latitude[7], 3);

	latitudeTmpLSB[3] = 0x00;

	return latitudeTmpLSB;

}

char longitude[14];	//yyyyy.yyb

char longitudeTmpTRIM[9];

char longitudeTmpLSB[4];

char* get_longitudeTrimmed() 

{

	strncpy(longitudeTmpTRIM, &longitude[0], 8);

	longitudeTmpTRIM[8] = 0x00;

	return longitudeTmpTRIM;

}

char* get_longitudeLSBs()

{

	strncpy(longitudeTmpLSB, &longitude[8], 3);

	longitudeTmpLSB[3] = 0x00;

	return longitudeTmpLSB;

}

char quality;		//quality for GGA and validity for RMC

char numSatellites[4];

char* get_sv() 

{

	return numSatellites;

}

char hdop[6];		//xx.x

char* get_hdop() 

{

	return hdop;

}

char altitude[10];	//xxxxxx.x

char* get_gpsaltitude()

{

	return altitude;

}

//char wgs84Height[8];	//sxxx.x

//char lastUpdated[8];	//blank - included for testing

//char stationID[8];	//blank - included for testing

char checksum[3];	//xx

char knots[8];		//xxx.xx

char* get_speedKnots() 

{

	return knots;

}

char course[8];		//xxx.x

char* get_course() 

{

	return course;

}

char dayofmonth[9];	//ddmmyy

char* get_dayofmonth() 

{

	return dayofmonth;

}

uint8_t gps_hadfix = 0;

uint8_t gps_hasfix() 

{

	uint8_t hasFix = get_latitudeTrimmed()[0] != 0x00;

	gps_hadfix = hasFix;

	return hasFix;

}

//char variation[9];	//xxx.xb

int calculatedChecksum;

int receivedChecksum;

// transmission state machine

enum decodeState {

	//shared fields

	INITIALIZE=0,

	GET_TYPE,

	GPS_CHECKSUM,	//XOR of all the bytes between the $ and the * (not including the delimiters themselves), written in hexadecimal

	//GGA data fields

	GGA_TIME,

	GGA_LATITUDE,

	GGA_LONGITUDE,

	GGA_QUALITY,

	GGA_SATELLITES,

	GGA_HDOP,

	GGA_ALTITUDE,

	GGA_WGS84,

	GGA_LAST_UPDATE,

	GGA_STATION_ID,

	//RMC data fields

	RMC_TIME,

	RMC_VALIDITY,

	RMC_LATITUDE,

	RMC_LONGITUDE,

	RMC_KNOTS,

	RMC_COURSE,

	RMC_DATE,

	RMC_MAG_VARIATION,

}decodeState;

//

//void usart1_isr(void)

//{

//	uint8_t recv = 0;// usart_recv(GPS_USART);

//	//ECHO debug: usart_send_blocking(GPS_USART, recv);

//	nmeaBuffer[nmeaBufferDataPosition % NMEABUFFER_SIZE] = recv;

//	nmeaBufferDataPosition = (nmeaBufferDataPosition + 1) % NMEABUFFER_SIZE;

//}

void gps_init() 

{

    // Initialize serial port

    timestamp[0] = 0x00;

    latitude[0] = 0x00;

    longitude[0] = 0x00;

    numSatellites[0] = 0x00;

    hdop[0] = 0x00;

    knots[0] = 0x00;

    course[0] = 0x00;

    dayofmonth[0] = 0x00;

//    // Disable GLONASS mode

//    uint8_t disable_glonass[20] = {0xB5, 0x62, 0x06, 0x3E, 0x0C, 0x00, 0x00, 0x00, 0x20, 0x01, 0x06, 0x08, 0x0E, 0x00, 0x00, 0x00, 0x01, 0x01, 0x8F, 0xB2};

//

//    gps_sendubx(disable_glonass, 20);

//

//    // Enable power saving

//    uint8_t enable_powersave[10] = {0xB5, 0x62, 0x06, 0x11, 0x02, 0x00, 0x08, 0x01, 0x22, 0x92};

//    gps_sendubx(enable_powersave, 10);

//

//

//    // Set dynamic model 6 (<1g airborne platform)

//    uint8_t airborne_model[] = { 0xB5, 0x62, 0x06, 0x24, 0x24, 0x00, 0xFF, 0xFF, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10, 0x27, 0x00, 0x00, 0x05, 0x00, 0xFA, 0x00, 0xFA, 0x00, 0x64, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0xDC };

//    gps_sendubx(airborne_model, sizeof(airborne_model)/sizeof(uint8_t));

}

void gps_sendubx(uint8_t* dat, uint8_t size)

{

    uint8_t sendctr;

    for(sendctr = 0; sendctr < size; sendctr++)

    {

        //usart_send(GPS_USART, dat[sendctr]);

    }

}

// Could inline if program space available

static void setParserState(uint8_t state)

{

	decodeState = state;

	// If resetting, clear vars

	if(state == INITIALIZE)

	{

		calculatedChecksum = 0;

	}

	// Every time we change state, we have parsed a byte

	nmeaBufferParsePosition = (nmeaBufferParsePosition + 1) % NMEABUFFER_SIZE;

}

void parse_gps_transmission(void)

{

    uint16_t nmeaBufferDataPosition = NMEABUFFER_SIZE - uart_get_rxdma_handle()->Instance->CNDTR;

	char byte;

	while(nmeaBufferDataPosition != nmeaBufferParsePosition)

	{

	    // Pull byte off of the buffer

	    byte = nmeaBuffer[nmeaBufferParsePosition];

		if(decodeState == INITIALIZE) //start of transmission sentence

		{

			if(byte == '$')

			{

				setParserState(GET_TYPE);

				numBytes = 0; //prep for next phases

				skipBytes = 0;

				calculatedChecksum = 0;

			}

			else

			{

				setParserState(INITIALIZE);

			}

		}

		//parse transmission type

		else if (decodeState == GET_TYPE)

		{

			tramsmissionType[numBytes] = byte;

			numBytes++;

			if(byte == ',') //end of this data type

			{

				tramsmissionType[5] = 0x00;

				if (tramsmissionType[2] == 'G' &&

				tramsmissionType[3] == 'G' &&

				tramsmissionType[4] == 'A')

				{

					setParserState(GGA_TIME);

					numBytes = 0;

				}

				else if (tramsmissionType[2] == 'R' &&

				tramsmissionType[3] == 'M' &&

				tramsmissionType[4] == 'C')

				{

					setParserState(RMC_TIME);

					numBytes = 0;

				}

				else //this is an invalid transmission type

				{

					setParserState(INITIALIZE);

				}

			}

			else {

				// continue

				setParserState(GET_TYPE);

			}

		}

		///parses GGA transmissions START

		/// $--GGA,hhmmss.ss,llll.ll,a,yyyyy.yy,a,x,xx,x.x,x.x,M,x.x,M,x.x,xxxx*xx

		//timestamp

		else if (decodeState == GGA_TIME)

		{

			if (byte == ',') //end of this data type

			{

				//timestamp[4] = 0x00; // Cut off at 4 (no seconds) for APRS

				setParserState(GGA_LATITUDE);

				skipBytes = 0; //prep for next phase of parse

				numBytes = 0;

			}

			else //store data

			{

				setParserState(GGA_TIME);

				timestamp[numBytes] = byte; //byte; //adjust number of bytes to fit array

				numBytes++;

			}

		}

		//latitude

		else if (decodeState == GGA_LATITUDE)

		{

			if (byte == ',' && skipBytes == 0) //discard this byte

			{

				skipBytes = 1;

				setParserState(GGA_LATITUDE);

			}

			else if (byte == ',') //end of this data type

			{

				latitude[numBytes] = 0x00; // null terminate

//

// WSPRHAB: Minimal high-altitude balloon tracker with WSPR telemetry

//

#include "stm32f0xx_hal.h"

#include "si5351.h"

#include "jtencode.h"

#include "adc.h"

#include "i2c.h"

#include "usart.h"

#include "gpio.h"

#include "gps.h"

#define WSPR_DEFAULT_FREQ 10140100UL

#define WSPR_TONE_SPACING 146 // ~1.46 Hz

#define WSPR_CTC 10672 // CTC value for WSPR

// Private functions

void sysclk_init(void);

void enter_sleep(void);

void enter_deepsleep(void);

// Test stuff

char call[7] = "KD8TDF";

char loc[5] = "EN72";

uint8_t dbm = 10;

uint8_t tx_buffer[255];

// Frequencies and channel info

uint32_t freq = WSPR_DEFAULT_FREQ;

uint8_t symbol_count = WSPR_SYMBOL_COUNT;

uint16_t ctc = WSPR_CTC;

uint16_t tone_spacing = WSPR_TONE_SPACING;

volatile uint8_t proceed = 0;

// Bring up TCXO and oscillator IC

void encode_wspr(void)

{

    HAL_GPIO_WritePin(OSC_NOTEN, 0);

    HAL_GPIO_WritePin(TCXO_EN, 1);

    HAL_Delay(100);

    // Bring up the chip

    si5351_init(i2c_get(), SI5351_CRYSTAL_LOAD_8PF, 0);

    si5351_set_correction(0);

    //si5351_set_pll(SI5351_PLL_FIXED, SI5351_PLLA);

    //si5351_set_ms_source(SI5351_CLK0, SI5351_PLLA);

    si5351_set_freq(WSPR_DEFAULT_FREQ * 100, 0, SI5351_CLK0);

    si5351_drive_strength(SI5351_CLK0, SI5351_DRIVE_8MA); // Set for max power if desired (8ma max)

    si5351_output_enable(SI5351_CLK0, 1);

    //si5351_pll_reset(SI5351_PLLA);

    // Make sure the other outputs of the SI5351 are disabled

    si5351_output_enable(SI5351_CLK1, 0); // Disable the clock initially

    si5351_output_enable(SI5351_CLK2, 0); // Disable the clock initially

    // disable clock powers

    si5351_set_clock_pwr(SI5351_CLK1, 0);

    si5351_set_clock_pwr(SI5351_CLK2, 0);

    // Encode message to transmit

    wspr_encode(call, loc, dbm, tx_buffer);

    // Key transmitter

    si5351_output_enable(SI5351_CLK0, 1);

    // Loop through and transmit symbols TODO: Do this from an ISR or ISR-triggered main loop function call (optimal)

    uint8_t i;

    for(i=0; i<symbol_count; i++)

    {

        uint32_t freq2 = (freq * 100) + (tx_buffer[i] * tone_spacing);

        si5351_set_freq(freq2, 0, SI5351_CLK0);

        HAL_GPIO_TogglePin(LED_BLUE);

        proceed = 0;

        while(!proceed);

    }

    // Disable transmitter

    si5351_output_enable(SI5351_CLK0, 0);

    HAL_GPIO_WritePin(OSC_NOTEN, 1);

    HAL_GPIO_WritePin(TCXO_EN, 0);

}

TIM_HandleTypeDef htim1;

int main(void)

{

    HAL_Init();

    sysclk_init();

    gpio_init();

    adc_init();

    i2c_init();

    gps_init();

    //jtencode_init();

    HAL_Delay(300);

    // Disable ICs

    HAL_GPIO_WritePin(OSC_NOTEN, 1);

    HAL_GPIO_WritePin(TCXO_EN, 0);

    HAL_GPIO_TogglePin(LED_BLUE);

    // Start timer for WSPR

    __TIM1_CLK_ENABLE();

    htim1.Instance = TIM1;

    htim1.Init.Prescaler = 512; // gives 64uS ticks from 8MHz ahbclk

    htim1.Init.CounterMode = TIM_COUNTERMODE_UP;

    htim1.Init.Period = ctc; // Count up to this value (how many 64uS ticks per symbol)

    htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

    htim1.Init.RepetitionCounter = 0;

    HAL_TIM_Base_Init(&htim1);

    HAL_TIM_Base_Start_IT(&htim1);

    HAL_NVIC_SetPriority(TIM1_BRK_UP_TRG_COM_IRQn, 0, 0);

    HAL_NVIC_EnableIRQ(TIM1_BRK_UP_TRG_COM_IRQn);

    uint32_t led_timer = HAL_GetTick();

    uint32_t last_gps  = HAL_GetTick();

    uint32_t last_wspr  = HAL_GetTick(); //0xfffff; // start immediately.

    HAL_GPIO_TogglePin(LED_BLUE);

    HAL_Delay(100);

    HAL_GPIO_TogglePin(LED_BLUE);

    HAL_Delay(100);

    HAL_GPIO_TogglePin(LED_BLUE);

    HAL_Delay(100);

    HAL_GPIO_TogglePin(LED_BLUE);

    HAL_Delay(100);

    uint8_t lastMinute = 0;

    uint16_t blink_rate = 250;

    while (1)

    {

        if(HAL_GetTick() - last_wspr > 500)

        {

                blink_rate = 250;

            }

            last_wspr = HAL_GetTick();

        }

        if(HAL_GetTick() - led_timer > blink_rate)

        {

            HAL_GPIO_TogglePin(LED_BLUE);

            led_timer = HAL_GetTick();

        }

        if(HAL_GetTick() - last_gps > 10)

        {

            last_gps = HAL_GetTick();

        }

        //enter_sleep();

    }

}

void enter_sleep(void)

{

    //HAL_SuspendTick();

    HAL_TIM_Base_Stop_IT(&htim1);

    HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);

    HAL_TIM_Base_Start_IT(&htim1);

    //HAL_ResumeTick();

}

void enter_deepsleep(void) 

{

    // Request to enter STOP mode with regulator in low power mode

    HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);

    // After wake-up from STOP reconfigure the PLL

    sysclk_init();

}

// Initialize system clocks

void sysclk_init(void)

{

    RCC_OscInitTypeDef RCC_OscInitStruct;

    RCC_ClkInitTypeDef RCC_ClkInitStruct;

    RCC_PeriphCLKInitTypeDef PeriphClkInit;

    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI|RCC_OSCILLATORTYPE_HSI14;

    RCC_OscInitStruct.HSIState = RCC_HSI_ON;

    RCC_OscInitStruct.HSI14State = RCC_HSI14_ON;

    RCC_OscInitStruct.HSICalibrationValue = 16;

    RCC_OscInitStruct.HSI14CalibrationValue = 16;

    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;

    HAL_RCC_OscConfig(&RCC_OscInitStruct);

    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK

                                |RCC_CLOCKTYPE_PCLK1;

    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;

    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

    HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);

    PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_I2C1;

    PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_SYSCLK; //RCC_USART1CLKSOURCE_PCLK1;

    PeriphClkInit.I2c1ClockSelection = RCC_I2C1CLKSOURCE_SYSCLK;

    HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit);

    HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);

    HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);

    __SYSCFG_CLK_ENABLE();

    // SysTick_IRQn interrupt configuration 

    HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

}

#include "stm32f0xx_hal.h"

#include "usart.h"

#include "config.h"

#include "gpio.h"

UART_HandleTypeDef huart1;

DMA_HandleTypeDef hdma_usart1_rx;

DMA_HandleTypeDef hdma_usart1_tx;

void uart_init(void)

{

    __GPIOB_CLK_ENABLE();

    __HAL_RCC_USART1_CLK_ENABLE();