<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<project>

	<configuration id="ilg.gnuarmeclipse.managedbuild.cross.toolchain.base.1766192373" name="Default">

		<extension point="org.eclipse.cdt.core.LanguageSettingsProvider">

			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>

			<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>

			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>

		</extension>

	</configuration>

	<configuration id="com.atollic.truestudio.exe.debug.1518366166.1945969626" name="testTS">

		<extension point="org.eclipse.cdt.core.LanguageSettingsProvider">

			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>

			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>

				<language-scope id="org.eclipse.cdt.core.gcc"/>

				<language-scope id="org.eclipse.cdt.core.g++"/>

			</provider>

		</extension>

	</configuration>

</project>

#ifndef __rtc_H

#define __rtc_H

#include "stm32f0xx_hal.h"

void rtc_init(void);

RTC_TimeTypeDef* rtc_time(void);

uint64_t rtc_timestamp(void);

RTC_HandleTypeDef* rtc_gethandle(void);

#endif /*__ rtc_H */

//

// Interrupts: all global ISRs

//

#include "stm32f0xx_hal.h"

#include "stm32f0xx.h"

#include "interrupts.h"

#include "uart.h"

#include "rtc.h"

#include "adc.h"

#include "gpio.h"

extern TIM_HandleTypeDef htim1;

extern volatile uint8_t proceed;

void SysTick_Handler(void)

{

    HAL_IncTick();

    HAL_SYSTICK_IRQHandler();

}

void DMA1_Channel2_3_IRQHandler(void)

{

    HAL_DMA_IRQHandler(uart_get_txdma_handle());

    HAL_DMA_IRQHandler(uart_get_txdma_handle());

}

void USART1_IRQHandler(void)

{

    HAL_UART_IRQHandler(uart_gethandle());

}

void TIM1_BRK_UP_TRG_COM_IRQHandler(void)

{

    proceed = 1;

    HAL_TIM_IRQHandler(&htim1);

}

void RTC_IRQHandler(void)

{

  HAL_RTC_AlarmIRQHandler(rtc_gethandle());

}

void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)

{

	// Do something awesome or not

}

void DMA1_Channel1_IRQHandler(void)

{

    HAL_DMA_IRQHandler(adc_gethandle()->DMA_Handle);

}

//

// 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 "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 __sleep_enter_stop(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;

    uint8_t state = SYSTEM_GPSACQ;

    // DEBUG EMZ FIXME

//    state = SYSTEM_IDLE;

    uint32_t gps_polltimer = 0;

    uint8_t nextwspr_time_valid = 0;

    uint64_t last_wspr_tx_time = 0;

    uint64_t idle_blink_last = 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);

//    __DBGMCU_CLK_ENABLE() ; // (RCC->APB2ENR |= (RCC_APB2ENR_DBGMCUEN))

//    HAL_EnableDBGStopMode();  //  SET_BIT(DBGMCU->CR, DBGMCU_CR_DBG_STOP);

    while (1)

    {

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

    	{

    		state = SYSTEM_GPSACQ;

    	}

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

        {

            if(gps_ison())

            {

            	HAL_GPIO_WritePin(LED_BLUE, 1);

            	HAL_Delay(50);

            	HAL_GPIO_WritePin(LED_BLUE, 0);

            	gps_update_data();

            	// If odd minute

            	if(gps_getdata()->minute % 2)

            	{

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

                    nextwspr_time_valid = 1;

            	}

            	// If even minute

            	else

            	{

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

                    nextwspr_time_valid = 1;

            	}

            }

        }

        switch(state)

        {

            // Idling: sleep and wait for RTC timeslot trigger

            case SYSTEM_IDLE:

            {

            	// Don't blink with the usual method

                blink_rate = BLINK_DISABLE;

                // If we haven't blinked for a while, blink now

                if(rtc_timestamp() - idle_blink_last > 10 * 1000)

                {

                	HAL_GPIO_WritePin(LED_BLUE, 1);

                	HAL_Delay(20);

                	HAL_GPIO_WritePin(LED_BLUE, 0);

                	idle_blink_last = rtc_timestamp();

                }

                // Go into stop mode for ~1s or so

                __sleep_enter_stop();

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

            } break;

            // Attempt to acquire GPS fix

            case SYSTEM_GPSACQ:

            {

                //blink_rate = BLINK_FAST;

                blink_rate = BLINK_DISABLE;

                if(!gps_ison())

                {

                    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

                {

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

                	led_blink(4);

                    gps_poweroff();

                    fix_acq_starttime = 0;

                	state = SYSTEM_IDLE;

                }

                else

                {

                	// We're waiting for a GPS fix, might as well sleep and let the GPS get a fix.

            		// Enter stop mode for 1 second. Blink in the GPS code above.

                    __sleep_enter_stop();

                }

            } break;

            // Wait for wspr timeslot and start transmitting

            case SYSTEM_WSPRTX:

            {

            	//blink_rate = BLINK_MED;

                blink_rate = BLINK_DISABLE;

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

            	{

            		{

            			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

						state = SYSTEM_IDLE;

                        adc_stop();

            		}

            		else

            		{

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

            			state = SYSTEM_IDLE;

                        adc_stop();

            		}

                    nextwspr_time_valid = 0; // invalidate wspr time

                }

            	else

            	{

                	HAL_GPIO_WritePin(LED_BLUE, 1);

                	HAL_Delay(50);

                	HAL_GPIO_WritePin(LED_BLUE, 0);

                	HAL_Delay(50);

                	HAL_GPIO_WritePin(LED_BLUE, 1);

                	HAL_Delay(50);

                	HAL_GPIO_WritePin(LED_BLUE, 0);

            		// Enter stop mode for 1 second

                    __sleep_enter_stop();

            	}

            } break;

        }

		#ifndef LED_DISABLE

			if((blink_rate != BLINK_DISABLE) && (HAL_GetTick() - led_timer > blink_rate))

			{

				led_timer = HAL_GetTick();

			}

			if((blink_rate != BLINK_DISABLE) && (statled_ontime && HAL_GetTick() - statled_ontime > 10))

			{

				HAL_GPIO_WritePin(LED_BLUE, 0);

				statled_ontime = 0;

			}

		#endif

    }

}

static void __sleep_enter_stop(void)

{

	// Save ms unix timestamp before we enter sleep mode

	HAL_SuspendTick();

	uint64_t start = rtc_timestamp();

	__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);

	HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);

	// Calculate how long we were asleep

	uint32_t timedelta = rtc_timestamp() - start;

	// Increment systick by this value to keep all timing happy

	HAL_IncTickBy(timedelta);

	HAL_ResumeTick();

	// We have woken up! Clear wakeup flag

	__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);

}

{

    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;

}

//

// RTC: configure real-time clock

//

#include "stm32f0xx_hal.h"

#include "rtc.h"

#include "gpio.h"

static void Error_Handler(void)

{

	volatile uint8_t crap = 1;

	for(uint16_t i=0; i<300; i++)

	{

		HAL_GPIO_TogglePin(LED_BLUE);

		HAL_Delay(100);

	}

}

// Initialize RTC

void rtc_init(void)

{

	__HAL_RCC_RTC_ENABLE();

	RTC_TimeTypeDef sTime;

	RTC_DateTypeDef sDate;

	RTC_AlarmTypeDef sAlarm;

	HAL_PWR_EnableBkUpAccess();

	hrtc.Instance = RTC;

	hrtc.Init.HourFormat = RTC_HOURFORMAT_24;

	hrtc.Init.AsynchPrediv = 127; // Note that both these dividers actually divide by their value + 1

	hrtc.Init.SynchPrediv = 311; // About 1Hz with 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.AlarmSubSecondMask = RTC_ALARMSUBSECONDMASK_SS14; //RTC_ALARMSUBSECONDMASK_ALL;

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

}

RTC_TimeTypeDef* rtc_time(void)

{

	HAL_RTC_GetTime(&hrtc, &time_last, RTC_FORMAT_BCD);

	return &time_last;

}

uint16_t __rtc_millis(uint32_t sub_seconds)

{

	// Subsecond counter counts down from SynchPrediv value to zero

	return (hrtc.Init.SynchPrediv - sub_seconds) * 999 / hrtc.Init.SynchPrediv; // 0 - 999 mS

}

#define JULIAN_DATE_BASE 2440588 // Unix epoch time in Julian calendar (UnixTime = 00:00:00 01.01.1970 => JDN = 2440588)

uint64_t rtc_timestamp(void)

{

	RTC_TimeTypeDef time = {0};

	RTC_DateTypeDef date = {0};

	HAL_RTC_GetTime(&hrtc, &time, RTC_FORMAT_BCD);

	HAL_RTC_GetDate(&hrtc, &date, RTC_FORMAT_BCD);

	// Thanks to LonelyWolf: https://github.com/LonelyWolf/stm32/blob/master/stm32l-dosfs/RTC.c

	// Convert Date/Time structures to epoch time

	uint8_t  a;

	uint16_t y;

	uint8_t  m;

	uint64_t JDN;

	// These hardcore math's are taken from http://en.wikipedia.org/wiki/Julian_day

	// Calculate some coefficients

	a = (14 - date.Month) / 12;

	y = (date.Year + 2000) + 4800 - a; // years since 1 March, 4801 BC

	m = date.Month + (12 * a) - 3; // since 1 March, 4801 BC

	// Gregorian calendar date compute

	JDN  = date.Date;

	JDN += (153 * m + 2) / 5;

	JDN += 365 * y;

	JDN += y / 4;

	JDN += -y / 100;

	JDN += y / 400;

	JDN  = JDN - 32045;

	JDN  = JDN - JULIAN_DATE_BASE;    // Calculate from base date

	JDN *= 86400;                     // Days to seconds

	JDN += time.Hours * 3600;    // ... and today seconds

	JDN += time.Minutes * 60;

	JDN += time.Seconds;

	JDN *= 1000; // Prepare to add ms

	JDN += __rtc_millis(time.SubSeconds);

	return JDN;

}

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;

}