Changeset - 7f3f8f2d539f
Parent rev.
Child rev.
[Not reviewed]
default
0 4 0
Ethan Zonca - 7 years ago 2019-09-02 20:06:26
ez@ethanzonca.com
Add support for RTC-based full unix timestamp with subsecond support
4 files changed with 83 insertions and 14 deletions:
inc/rtc.h
1
src/main.c
26
10
src/rtc.c
54
2
src/wspr.c
2
2
0 comments (0 inline, 0 general)
inc/rtc.h
➞
Show inline comments
 
#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 */
src/main.c
➞
Show inline comments
 
@@ -46,50 +46,49 @@ int main(void)
 
    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:
 
//    uint8_t state = SYSTEM_IDLE;
 
 
    // DEBUG EMZ FIXME
 
    state = SYSTEM_IDLE;
 
 
    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;
 
    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);
 
 
    uint32_t idle_blink_last = 0;
 
 
    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();
 
@@ -112,45 +111,60 @@ int main(void)
 
            }
 
            gps_polltimer = HAL_GetTick();
 
        }
 
 
 
 
        switch(state)
 
        {
 
 
            // Idling: sleep and wait for RTC timeslot trigger
 
            case SYSTEM_IDLE:
 
            {
 
            	// Don't blink normally
 
                blink_rate = 9999; //BLINK_SLOW;
 
            	// Don't blink with the usual method
 
                blink_rate = BLINK_DISABLE;
 
 
                // If we haven't blinked for a while, blink now
 
                if(HAL_GetTick() - idle_blink_last > 10 * 1000)
 
                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 = HAL_GetTick();
 
                	idle_blink_last = rtc_timestamp();
 
                }
 
 
 
                // Enter STOP mode for one second using RTC for wakeup
 
                // 1s might not be accurate because we're entering STOP
 
                // mode any time between 1s interrupt ticks...
 
 
                // TODO: Calculate full RTC timestamp before entering
 
                // and after entering, find delta, this is the amount
 
                // we use to increment SYSTICK
 
 
 
                // Enter sleep mode: wait for interrupt
 
                //HAL_PWR_EnterSLEEPMode(0, PWR_SLEEPENTRY_WFI);
 
 
                uint64_t start = rtc_timestamp();
 
 
                __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
 
                HAL_SuspendTick();
 
 
        		HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
 
 
        		// We probably stopped for a second
 
        		HAL_IncTickBy(1000); // maybe check the RTC before and after this, increment tick by the delta?
 
        		uint32_t timedelta = rtc_timestamp() - start;
 
        		HAL_IncTickBy(timedelta);
 
        		//HAL_IncTickBy(1000); // maybe check the RTC before and after this, increment tick by the delta?
 
                HAL_ResumeTick();
 
 
                // 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
 
 
@@ -262,24 +276,26 @@ int main(void)
 
			}
 
 
			if((blink_rate != BLINK_DISABLE) && (statled_ontime && HAL_GetTick() - statled_ontime > 10))
 
			{
 
				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
src/rtc.c
➞
Show inline comments
 
@@ -25,26 +25,26 @@ 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 = 124;
 
	hrtc.Init.SynchPrediv = 322; // if this has enough bits should be 1.0018Hz based on 40kHz LSI
 
	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;
 
@@ -93,24 +93,76 @@ void rtc_init(void)
 
 
 
}
 
 
RTC_TimeTypeDef time_last = {0};
 
 
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;
 
}
 
 
src/wspr.c
➞
Show inline comments
 
@@ -245,26 +245,26 @@ void wspr_transmit(uint8_t* grid_locator
 

			




	
	
	
		
 
    HAL_GPIO_WritePin(OSC_NOTEN, 0);

			




	
	
	
		
 
    HAL_GPIO_WritePin(TCXO_EN, 1);

			




	
	
	
		
 
    HAL_Delay(100);

			




	
	
	
		
 

			




	
	
	
		
 
    // Bring up the chip

			




	
	
	
		
 
    i2c_init();

			




	
	
	
		
 
    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_drive_strength(SI5351_CLK0, SI5351_DRIVE_6MA); // Set for max power if desired (8ma max)

			




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

			




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

			




	
	
	
		
 
//    si5351_drive_strength(SI5351_CLK0, SI5351_DRIVE_2MA); // 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);

			




	
	
	
		
 

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: zserverv-626845
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2021 by various authors & licensed under GPLv3.
            – Support