#ifndef __gpio_H

#define __gpio_H

#include "stm32f0xx_hal.h"

enum _blinkrate

{

    BLINK_FAST = 50,

    BLINK_MED = 250, 

    BLINK_SLOW = 500

#define OSC_EN_Pin GPIO_PIN_1

#define OSC_EN_GPIO_Port GPIOF

#define OSC_NOTEN OSC_EN_GPIO_Port , OSC_EN_Pin

#define GPS_NEN_Pin GPIO_PIN_0

#define GPS_NEN_GPIO_Port GPIOF

#define GPS_NOTEN GPS_NEN_GPIO_Port , GPS_NEN_Pin

#define VBATT_SENSE_Pin GPIO_PIN_6

#define VBATT_SENSE_GPIO_Port GPIOA

#define LED_BLUE_Pin GPIO_PIN_0

#define LED_BLUE_GPIO_Port GPIOB

#define LED_BLUE LED_BLUE_GPIO_Port , LED_BLUE_Pin

#define TCXO_EN_Pin GPIO_PIN_8

#define TCXO_EN_GPIO_Port GPIOA

#define TCXO_EN TCXO_EN_GPIO_Port  , TCXO_EN_Pin

void gpio_init(void);

void led_blink(uint8_t n);

#include "gpio.h"

void gpio_init(void)

{

  GPIO_InitTypeDef GPIO_InitStruct;

  /* GPIO Ports Clock Enable */

  __GPIOF_CLK_ENABLE();

  __GPIOA_CLK_ENABLE();

  __GPIOB_CLK_ENABLE();

  // Oscillator enable pin

  GPIO_InitStruct.Pin = OSC_EN_Pin;

  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

  GPIO_InitStruct.Pull = GPIO_NOPULL;

  GPIO_InitStruct.Speed = GPIO_SPEED_LOW;

  HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

  // GPS enable pin

  GPIO_InitStruct.Pin = GPS_NEN_Pin;

  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;

  GPIO_InitStruct.Pull = GPIO_NOPULL;

  GPIO_InitStruct.Speed = GPIO_SPEED_LOW;

  HAL_GPIO_Init(GPS_NEN_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : PA0 PA2 PA3 PA4 

                           PA5 PA7 PA15 */

  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4 

                          |GPIO_PIN_5|GPIO_PIN_7|GPIO_PIN_15;

  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;

  GPIO_InitStruct.Pull = GPIO_NOPULL;

  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

//  /*Configure GPIO pin : PA1 */

//  GPIO_InitStruct.Pin = GPIO_PIN_1;

//  GPIO_InitStruct.Mode = GPIO_MODE_EVT_RISING;

//  GPIO_InitStruct.Pull = GPIO_NOPULL;

//  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pin : PtPin */

  GPIO_InitStruct.Pin = LED_BLUE_Pin;

  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

  GPIO_InitStruct.Pull = GPIO_NOPULL;

  GPIO_InitStruct.Speed = GPIO_SPEED_LOW;

  HAL_GPIO_Init(LED_BLUE_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : PB1 PB3 PB4 PB5 */

  GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5;

  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;

  GPIO_InitStruct.Pull = GPIO_NOPULL;

  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pin : PtPin */

  GPIO_InitStruct.Pin = TCXO_EN_Pin;

  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

  GPIO_InitStruct.Pull = GPIO_NOPULL;

  GPIO_InitStruct.Speed = GPIO_SPEED_LOW;

  HAL_GPIO_Init(TCXO_EN_GPIO_Port, &GPIO_InitStruct);

}

void led_blink(uint8_t n)

{

    for(int i = 0; i < n; i++)

    {

        HAL_GPIO_WritePin(LED_BLUE, 1);

        HAL_Delay(100);

        HAL_GPIO_WritePin(LED_BLUE, 0);

        HAL_Delay(100);

    }

}

    int32_t latitude;

    int32_t longitude;

    int32_t altitude;

    uint8_t hour;

    uint8_t minute;

    uint8_t second;

} gps_data_t;

gps_data_t position;

// Private methods

static void gps_ubx_checksum(uint8_t* data, uint8_t len, uint8_t* cka, uint8_t* ckb);

static uint8_t _gps_verify_checksum(uint8_t* data, uint8_t len);

void gps_init()

{

    // Initialize serial port

   // done in poweron uart_init();

   // Disable messages

   HAL_UART_Transmit(uart_gethandle(), setGSA, sizeof(setGSA)/sizeof(uint8_t), 100);

   HAL_UART_Transmit(uart_gethandle(), setGSV, sizeof(setGSV)/sizeof(uint8_t), 100);

   HAL_UART_Transmit(uart_gethandle(), setRMC, sizeof(setRMC)/sizeof(uint8_t), 100);

}

void gps_update_position()

{

    // Request a NAV-POSLLH message from the GPS

    //_gps_send_msg(request, 8);

    uint8_t flushed = uart_gethandle()->Instance->RDR;

    uint8_t buf[36];

    //for(uint8_t i = 0; i < 36; i++)

    //    buf[i] = _gps_get_byte();

//    // Verify the sync and header bits

//    if( buf[0] != 0xB5 || buf[1] != 0x62 )

//        led_set(LED_RED, 1);

//    if( buf[2] != 0x01 || buf[3] != 0x02 )

//        led_set(LED_RED, 1);

    // 4 bytes of longitude (1e-7)

    position.longitude = (int32_t)buf[10] | (int32_t)buf[11] << 8 |

        (int32_t)buf[12] << 16 | (int32_t)buf[13] << 24;

    // 4 bytes of latitude (1e-7)

    position.latitude = (int32_t)buf[14] | (int32_t)buf[15] << 8 |

        (int32_t)buf[16] << 16 | (int32_t)buf[17] << 24;

    // 4 bytes of altitude above MSL (mm)

    position.altitude = (int32_t)buf[22] | (int32_t)buf[23] << 8 |

        (int32_t)buf[24] << 16 | (int32_t)buf[25] << 24;

    if( !_gps_verify_checksum(&buf[2], 32) )

        led_blink(2);

}

void gps_update_time(uint8_t* hour, uint8_t* minute, uint8_t* second)

{

    // Send a NAV-TIMEUTC message to the receiver

    uint8_t request[8] = {0xB5, 0x62, 0x01, 0x21, 0x00, 0x00, 0x22, 0x67};

    uint8_t flushed = uart_gethandle()->Instance->RDR;

    volatile HAL_StatusTypeDef res = HAL_UART_Transmit(uart_gethandle(), request, 8, 100);

    // Get the message back from the GPS

    uint8_t buf[28];

    res = HAL_UART_Receive(uart_gethandle(), buf, 28, 500);

//    // Verify the sync and header bits

//    if( buf[0] != 0xB5 || buf[1] != 0x62 )

//        led_set(LED_RED, 1);

//    if( buf[2] != 0x01 || buf[3] != 0x21 )

//        led_set(LED_RED, 1);

    *hour = buf[22];

    *minute = buf[23];

    *second = buf[24];

//    if( !_gps_verify_checksum(&buf[2], 24) ) led_set(LED_RED, 1);

}

/**

 * Check the navigation status to determine the quality of the

 * fix currently held by the receiver with a NAV-STATUS message.

 */

void gps_check_lock(uint8_t* lock, uint8_t* sats)

{

    // Construct the request to the GPS

    uint8_t flushed = uart_gethandle()->Instance->RDR;

    HAL_UART_Transmit(uart_gethandle(), request, 8, 100);

    // Get the message back from the GPS

    uint8_t buf[60];

    // Verify the sync and header bits

//    if( buf[0] != 0xB5 || buf[1] != 0x62 )

//        led_set(LED_RED, 1);

//    if( buf[2] != 0x01 || buf[3] != 0x06 )

//        led_set(LED_RED, 1);

    // Check 60 bytes minus SYNC and CHECKSUM (4 bytes)

    // Return the value if GPSfixOK is set in 'flags'

    if( buf[17] & 0x01 )

        *lock = buf[16];

    else

        *lock = 0;

    *sats = buf[53];

}

/**

 * Verify that the uBlox 6 GPS receiver is set to the <1g airborne

 * navigaion mode.

 */

uint8_t gps_check_nav(void)

{

    uint8_t request[8] = {0xB5, 0x62, 0x06, 0x24, 0x00, 0x00,

        0x2A, 0x84};

    uint8_t flushed = uart_gethandle()->Instance->RDR;

    HAL_UART_Transmit(uart_gethandle(), request, 8, 100);

    // Get the message back from the GPS

    uint8_t buf[44];

    HAL_UART_Receive(uart_gethandle(), buf, 44, 100);

//

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

//

#include "stm32f0xx_hal.h"

#include "adc.h"

#include "system.h"

#include "i2c.h"

#include "uart.h"

#include "gpio.h"

#include "wspr.h"

#include "gps.h"

// We have access to the 1PPS pin of the gps... could have trim routine for internal oscillator based on this when we have a fix

// Probabl wake up 1 minute early -- 0.45min possible +/- on wakeup time with 15min sync intervals

enum _state

{

    SYSTEM_POWERUP_SYNC = 0, // on powerup, get a GPS fix and set the RTC

    SYSTEM_IDLE, // awaiting RTC interrupt for wakeup TODO wake up before scheduled time to get fix?

    SYSTEM_GPSACQ, // RTC interrupted

    SYSTEM_WSPRTX, // Wait for timeslot and actually transmit the message

int main(void)

{

    HAL_Init();

    sysclk_init();

    gpio_init();

    adc_init();

    i2c_init();

    gps_init();

    wspr_init();

    uint32_t led_timer = HAL_GetTick();

    led_blink(4);

    uint16_t blink_rate = BLINK_FAST;

    uint8_t state = SYSTEM_GPSACQ;

    while (1)

    {

        switch(state)

        {

            // Idling: sleep and wait for RTC timeslot trigger

            case SYSTEM_IDLE:

            {

                blink_rate = BLINK_SLOW;

                // Wait for RTC wakeup interrupt

                //enter_sleep();

                // Somehow go to another state when we get an interrupt

                state = SYSTEM_GPSACQ;

            } break;

            // Attempt to acquire GPS fix

            case SYSTEM_GPSACQ:

            {

                blink_rate = BLINK_FAST;

                // TODO: probably don't power on all the time, just on state transition

                if(fix_ok)

                {

                    // Disable GPS module

                    gps_poweroff();

                    // TODO: Set RTC from GPS time

                    // TODO: Set RTC for countdown to next transmission timeslot!

                    // TODO: Set wspr countdown timer for this transmission!

                    state = SYSTEM_WSPRTX;

                }

            } break;

            // Wait for wspr timeslot and start transmitting

            case SYSTEM_WSPRTX:

            {

                // Wait for wspr countdown timer to expire and go to tx

                // Schedule next wakeup (maybe 2mins prior ot timeslot if no osc trim)

                // Next wakeup should enter SYSTEM_GPSACQ state...

                state = SYSTEM_IDLE;

            } break;

        }

        if(HAL_GetTick() - led_timer > blink_rate)

        {

            HAL_GPIO_TogglePin(LED_BLUE);

            led_timer = HAL_GetTick();

        }

    }

}