#if defined(STM32F091xC) || defined (STM32F098xx)

/** @defgroup HAL_SYSCFG_IRDA_modulation_envelope_selection HAL SYSCFG IRDA modulation envelope selection

  * @brief  selection of the modulation envelope signal macro, using bits [7:6] of SYS_CTRL(CFGR1) register

  * @note This feature is applicable on STM32F09x

  * @param __SOURCE__: This parameter can be a value of @ref HAL_IRDA_ENV_SEL

  * @{  

  */

#define __HAL_SYSCFG_IRDA_ENV_SELECTION(__SOURCE__)  do {assert_param(IS_HAL_SYSCFG_IRDA_ENV_SEL((__SOURCE__))); \

                                                         SYSCFG->CFGR1 &= ~(SYSCFG_CFGR1_IRDA_ENV_SEL); \

                                                         SYSCFG->CFGR1 |= (__SOURCE__);    \

                                                        }while(0)

#define __HAL_SYSCFG_GET_IRDA_ENV_SELECTION()  ((SYSCFG->CFGR1) & 0x000000C0)

/**

  * @}

  */

#endif /* (STM32F091xC) || defined (STM32F098xx)*/

/**

  * @}

  */  

/* Exported functions --------------------------------------------------------*/

/** @addtogroup HAL_Exported_Functions

  * @{

  */

/** @addtogroup HAL_Exported_Functions_Group1

  * @{

  */    

/* Initialization and de-initialization functions  ******************************/

HAL_StatusTypeDef HAL_Init(void);

HAL_StatusTypeDef HAL_DeInit(void);

void              HAL_MspInit(void);

void              HAL_MspDeInit(void);

HAL_StatusTypeDef HAL_InitTick (uint32_t TickPriority);

/**

  * @}

  */  

/** @addtogroup HAL_Exported_Functions_Group2

  * @{

  */    

/* Peripheral Control functions  ************************************************/

void              HAL_IncTick(void);

void              HAL_Delay(__IO uint32_t Delay);

uint32_t          HAL_GetTick(void);

void              HAL_SuspendTick(void);

void              HAL_ResumeTick(void);

uint32_t          HAL_GetHalVersion(void);

uint32_t          HAL_GetREVID(void);

uint32_t          HAL_GetDEVID(void);

void              HAL_DBGMCU_EnableDBGStopMode(void);

void              HAL_DBGMCU_DisableDBGStopMode(void);

void              HAL_DBGMCU_EnableDBGStandbyMode(void);

void              HAL_DBGMCU_DisableDBGStandbyMode(void);

/**

  * @}

  */ 

/**

  * @}

  */

/**

  * @}

  */ 

/**

  * @}

  */

#ifdef __cplusplus

}

#endif

#endif /* __STM32F0xx_HAL_H */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

  /*Configure the SysTick IRQ priority */

  HAL_NVIC_SetPriority(SysTick_IRQn, TickPriority ,0);

   /* Return function status */

  return HAL_OK;

}

/**

  * @}

  */

/** @defgroup HAL_Exported_Functions_Group2 HAL Control functions 

  * @brief    HAL Control functions

  *

@verbatim

 ===============================================================================

                      ##### HAL Control functions #####

 ===============================================================================

    [..]  This section provides functions allowing to:

      (+) Provide a tick value in millisecond

      (+) Provide a blocking delay in millisecond

      (+) Suspend the time base source interrupt

      (+) Resume the time base source interrupt

      (+) Get the HAL API driver version

      (+) Get the device identifier

      (+) Get the device revision identifier

      (+) Enable/Disable Debug module during Sleep mode

      (+) Enable/Disable Debug module during STOP mode

      (+) Enable/Disable Debug module during STANDBY mode

@endverbatim

  * @{

  */

/**

  * @brief This function is called to increment  a global variable "uwTick"

  *        used as application time base.

  * @note In the default implementation, this variable is incremented each 1ms

  *       in Systick ISR.

  * @note This function is declared as __weak to be overwritten in case of other 

  *       implementations in user file.

  * @retval None

  */

__weak void HAL_IncTick(void)

{

  uwTick++;

}

/**

  * @brief  Provides a tick value in millisecond.

  * @note   This function is declared as __weak  to be overwritten  in case of other 

  *       implementations in user file.

  * @retval tick value

  */

__weak uint32_t HAL_GetTick(void)

{

  return uwTick;

}

/**

  * @brief This function provides accurate delay (in milliseconds) based 

  *        on variable incremented.

  * @note In the default implementation , SysTick timer is the source of time base.

  *       It is used to generate interrupts at regular time intervals where uwTick

  *       is incremented.

  * @note ThiS function is declared as __weak to be overwritten in case of other

  *       implementations in user file.

  * @param Delay: specifies the delay time length, in milliseconds.

  * @retval None

  */

__weak void HAL_Delay(__IO uint32_t Delay)

{

  uint32_t tickstart = 0;

  tickstart = HAL_GetTick();

  while((HAL_GetTick() - tickstart) < Delay)

  {

  }

}

/**

  * @brief Suspend Tick increment.

  * @note In the default implementation , SysTick timer is the source of time base. It is

  *       used to generate interrupts at regular time intervals. Once HAL_SuspendTick()

  *       is called, the the SysTick interrupt will be disabled and so Tick increment 

  *       is suspended.

  * @note This function is declared as __weak to be overwritten in case of other

  *       implementations in user file.

  * @retval None

  */

__weak void HAL_SuspendTick(void)

{

  /* Disable SysTick Interrupt */

  CLEAR_BIT(SysTick->CTRL,SysTick_CTRL_TICKINT_Msk);

}

#ifndef __gpio_H

#define __gpio_H

#include "stm32f0xx_hal.h"

enum _blinkrate

{

    BLINK_FAST = 50,

    BLINK_MED = 250, 

};

#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);

#endif 

#ifndef __rtc_H

#define __rtc_H

#include "stm32f0xx_hal.h"

void rtc_init(void);

RTC_HandleTypeDef* rtc_gethandle(void);

#endif /*__ rtc_H */

#include "uart.h"

#include "gpio.h"

#include "wspr.h"

#include "rtc.h"

#include "gps.h"

#include "config.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

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

// TODO: Add JT9 message with more grid locator digits + altitude + vbatt + temp

// MSG13charmax:

// 	X: gridloc

//  Y: altitude

//  Z: temperature

//  KD8TDF XXYYZZ // could use alt callsign thing

enum _state

{

    SYSTEM_IDLE = 0, // 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

};

static void __calc_gridloc(char *dst, double lat, double lon);

static void ledpulse(void);

uint32_t statled_ontime = 0;

int main(void)

{

    HAL_Init();

    HAL_Delay(1000); // startup delay before infinisleep

    sysclk_init();

    gpio_init();

    rtc_init();

    adc_init();

    wspr_init();

    uint32_t led_timer = HAL_GetTick();

    led_blink(4);

    uint16_t blink_rate = BLINK_FAST;

//DEBUG:

    uint32_t gps_polltimer = 0;

    uint32_t fix_acq_starttime = 0;

    uint32_t nextwspr_time = 0;

    uint8_t nextwspr_time_valid = 0;

    uint32_t last_wspr_tx_time = 0;

    uint8_t packet_type = 0;

    // Transmit pilot tone to test TX on bootup

    HAL_Delay(1000);

    wspr_pilot_tone();

    adc_stop();

    HAL_Delay(1000);

    while (1)

    {

    	// TODO: Disable GPIO port clocking when not needed!

    	// Every 10 minutes, wake up and try to wspr

    	if(state == SYSTEM_IDLE && (HAL_GetTick() - last_wspr_tx_time > 60000 * 10))

    	{

    		state = SYSTEM_GPSACQ;

    	}

        // Update fix status every 2 seconds, only if the GPS is powered on

        if(HAL_GetTick() - gps_polltimer > 2000)

        {

            if(gps_ison())

            {

            	gps_update_data();

            	// If odd minute

            	if(gps_getdata()->minute % 2)

            	{

            		// Wait until even minute plus one second, coming soon

            		nextwspr_time = HAL_GetTick() + (60000 - (gps_getdata()->second * 1000));

                    nextwspr_time_valid = 1;

            	}

            	// If even minute

            	else

            	{

            		// Wait until odd minute, one minute and some change away

            		nextwspr_time = HAL_GetTick() + 60000 + (60000 - (gps_getdata()->second * 1000));

                    nextwspr_time_valid = 1;

            	}

            }

            gps_polltimer = HAL_GetTick();

        }

        switch(state)

        {

            // Idling: sleep and wait for RTC timeslot trigger

            case SYSTEM_IDLE:

            {

                // Enter sleep mode: wait for interrupt

                //HAL_PWR_EnterSLEEPMode(0, PWR_SLEEPENTRY_WFI);

                __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);

        		HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);

                // We have woken up! Clear wakeup flag

        		__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);

                // This is hopefully the only timer that needs to stay alive in idle mode

 //               last_wspr_tx_time += 0; // move this timer forward based on sleep length

 //               HAL_ResumeTick();

                // TODO: Eventually use GPS time to calibrate the RTC maybe

            } break;

            // Attempt to acquire GPS fix

            case SYSTEM_GPSACQ:

            {

                blink_rate = BLINK_FAST;

                HAL_PWR_EnterSLEEPMode(0, PWR_SLEEPENTRY_WFI);

                HAL_PWR_EnterSLEEPMode(0, PWR_SLEEPENTRY_WFI);

                HAL_PWR_EnterSLEEPMode(0, PWR_SLEEPENTRY_WFI);

                HAL_PWR_EnterSLEEPMode(0, PWR_SLEEPENTRY_WFI);

                if(!gps_ison())

                {

                	fix_acq_starttime = HAL_GetTick();

                    gps_poweron(); // power on and initialize GPS module

                }

                // TODO: Move GPS processing into here from above!

                // If 3d fix with a decent enough precision

                if( ((gps_getdata()->fixtype == 2) || (gps_getdata()->fixtype == 3)) && gps_getdata()->pdop < 10 && nextwspr_time_valid == 1)

                {

                    // 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!

                    fix_acq_starttime = 0;

                    state = SYSTEM_WSPRTX;

                    adc_start();

                }

                // If no decent fix in 3 minutes

                else if(HAL_GetTick() - fix_acq_starttime > 60000 * 3)

                {

                	// Flash error code and go to idle, try again next time

                	led_blink(4);

                    gps_poweroff();

                    fix_acq_starttime = 0;

                    last_wspr_tx_time = HAL_GetTick(); // repeat acq/tx cycle after big time delay

                	state = SYSTEM_IDLE;

                }

            } break;

            // Wait for wspr timeslot and start transmitting

            case SYSTEM_WSPRTX:

            {

            	blink_rate = BLINK_MED;

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

//                if(timeout_expired)

//                {

            	// If we're after the minute but not more than 2s after the minute, start tx

            	if(HAL_GetTick() >= nextwspr_time)

            	{

            		if(HAL_GetTick() < nextwspr_time + 2000)

            		{

            			volatile double latitude_flt = (double)gps_getdata()->latitude / 10000000.0;

            			volatile double longitude_flt = (double)gps_getdata()->longitude / 10000000.0;

            			volatile uint8_t grid_locator[7];

            			__calc_gridloc(grid_locator, latitude_flt, longitude_flt);

                        // TODO: Switch between alternate and standard packet

						wspr_transmit(grid_locator, packet_type);

                        packet_type = !packet_type; // alternate packet type

						last_wspr_tx_time = HAL_GetTick();

						state = SYSTEM_IDLE;

                        adc_stop();

            		}

            		else

            		{

            			// Window was missed, go back to idle, and try again after time delay

						last_wspr_tx_time = HAL_GetTick();

            			state = SYSTEM_IDLE;

                        adc_stop();

            		}

                    nextwspr_time_valid = 0; // invalidate wspr time

                }

            	else

            	{

                    HAL_PWR_EnterSLEEPMode(0, PWR_SLEEPENTRY_WFI);

                    HAL_PWR_EnterSLEEPMode(0, PWR_SLEEPENTRY_WFI);

                    HAL_PWR_EnterSLEEPMode(0, PWR_SLEEPENTRY_WFI);

                    HAL_PWR_EnterSLEEPMode(0, PWR_SLEEPENTRY_WFI);

            	}

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

                // Next wakeup should enter SYSTEM_GPSACQ state...

            } break;

        }

		#ifndef LED_DISABLE

			{

				ledpulse();

				led_timer = HAL_GetTick();

			}

			{

				HAL_GPIO_WritePin(LED_BLUE, 0);

				statled_ontime = 0;

			}

		#endif

    }

}

static void ledpulse(void)

{

    HAL_GPIO_WritePin(LED_BLUE, 1);

	statled_ontime = HAL_GetTick();

}

static void __calc_gridloc(char *dst, double lat, double lon)

{

	int o1, o2, o3;

	int a1, a2, a3;

	double remainder;

	// longitude

	remainder = lon + 180.0;

	o1 = (int)(remainder / 20.0);

	remainder = remainder - (double)o1 * 20.0;

	o2 = (int)(remainder / 2.0);

	remainder = remainder - 2.0 * (double)o2;

	o3 = (int)(12.0 * remainder);

	// latitude

	remainder = lat + 90.0;

	a1 = (int)(remainder / 10.0);

	remainder = remainder - (double)a1 * 10.0;

	a2 = (int)(remainder);

	remainder = remainder - (double)a2;

	a3 = (int)(24.0 * remainder);

	dst[0] = (char)o1 + 'A';

	dst[1] = (char)a1 + 'A';

	dst[2] = (char)o2 + '0';

	dst[3] = (char)a2 + '0';

	dst[4] = (char)o3 + 'A';

	dst[5] = (char)a3 + 'A';

	dst[6] = (char)0;

}

	HAL_PWR_EnableBkUpAccess();

	hrtc.Instance = RTC;

	hrtc.Init.HourFormat = RTC_HOURFORMAT_24;

	hrtc.Init.AsynchPrediv = 124;

	hrtc.Init.SynchPrediv = 322; // if this has enough bits should be 1.0018Hz based on 40kHz LSI

	hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;

 	hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;

	hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;

	if (HAL_RTC_Init(&hrtc) != HAL_OK)

	{

		Error_Handler();

	}

	sTime.Hours = 0x0;

	sTime.Minutes = 0x0;

	sTime.Seconds = 0x0;

	sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;

	sTime.StoreOperation = RTC_STOREOPERATION_RESET;

	if (HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BCD) != HAL_OK)

	{

		Error_Handler();

	}

	sDate.WeekDay = RTC_WEEKDAY_MONDAY;

	sDate.Month = RTC_MONTH_JANUARY;

	sDate.Date = 0x01;

	sDate.Year = 0x19;

	if (HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BCD) != HAL_OK)

	{

		Error_Handler();

	}

	/**Enable the Alarm A

	*/

	sAlarm.AlarmTime.Hours = 0x0;

	sAlarm.AlarmTime.Minutes = 0x0;

	sAlarm.AlarmTime.Seconds = 0x0;

	sAlarm.AlarmTime.SubSeconds = 0x0;

	sAlarm.AlarmTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;

	sAlarm.AlarmTime.StoreOperation = RTC_STOREOPERATION_RESET;

	// Alarm will trigger on the Xth second of every minute

	sAlarm.AlarmMask = RTC_ALARMMASK_ALL; // Trigger every second for now

	sAlarm.AlarmDateWeekDaySel = RTC_ALARMDATEWEEKDAYSEL_DATE;

	sAlarm.AlarmDateWeekDay = RTC_WEEKDAY_MONDAY;

	sAlarm.Alarm = RTC_ALARM_A;

	if (HAL_RTC_SetAlarm_IT(&hrtc, &sAlarm, RTC_FORMAT_BCD) != HAL_OK)

	{

		Error_Handler();

	}

	HAL_NVIC_SetPriority(RTC_IRQn, 0, 0);

	HAL_NVIC_EnableIRQ(RTC_IRQn);

	HAL_RTC_WaitForSynchro(&hrtc);

}

void rtc_cal(void)

{

	// Do something with hrtc.Instance->CALR; // this has a plus and minus component, see refman

}

RTC_HandleTypeDef* rtc_gethandle(void)

{

	return &hrtc;

}