Changeset - 8e3cff0b603c
Parent rev.
Child rev.
[Not reviewed]
default
0 2 0
Ethan Zonca - 8 years ago 2017-09-23 23:58:56
ez@ethanzonca.com
Fix callsign ID for balloon message, actually add grid locator encode to correct var
2 files changed with 13 insertions and 10 deletions:
src/main.c
2
2
src/wspr.c
11
8
0 comments (0 inline, 0 general)
src/main.c
➞
Show inline comments
 
@@ -49,49 +49,49 @@ int main(void)
 
    wspr_init();
 
 
    uint32_t led_timer = HAL_GetTick();
 
 
    led_blink(4);
 
 
    uint16_t blink_rate = BLINK_FAST;
 
    uint8_t state = SYSTEM_GPSACQ;
 
 
    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 fix_ok = 0;
 
    uint8_t numsats = 0;
 
 
    uint8_t packet_type = 0;
 
 
    while (1)
 
    {
 
 
    	// Every 10 minutes, wake up and try to wspr
 
    	if(state == SYSTEM_IDLE && (HAL_GetTick() - last_wspr_tx_time > 60000 /* * 10 */))
 
    	if(state == SYSTEM_IDLE && (HAL_GetTick() - last_wspr_tx_time > 60000 * 10))
 
    	{
 
    		state = SYSTEM_GPSACQ;
 
    	}
 
 
        // Update fix status every 2 seconds
 
        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));
 
@@ -172,49 +172,49 @@ int main(void)
 
            } 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
 
                        packet_type = !packet_type; // alternate packet type
 
						last_wspr_tx_time = HAL_GetTick();
 
						state = SYSTEM_IDLE;
 
            		}
 
            		else
 
            		{
 
            			// Window was missed, go back to idle, and try again after time delay
 
						last_wspr_tx_time = HAL_GetTick();
 
            			state = SYSTEM_IDLE;
 
            		}
 
                    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 ot timeslot if no osc trim)
 
                // Next wakeup should enter SYSTEM_GPSACQ state...
 
 
            } break;
 
src/wspr.c
➞
Show inline comments
 
#include "stm32f0xx_hal.h"
 
#include "si5351.h"
 
#include "jtencode.h"
 
#include "gpio.h"
 
#include "wspr.h"
 
#include "i2c.h"
 
#include "gps.h"
 
#include "config.h"
 

			




	
	
	
		
 

			




	
	
	
		
 
#define WSPR_DEFAULT_FREQ 10140100UL

			




	
	
	
		
 
#define WSPR_TONE_SPACING 146 // ~1.46 Hz

			




	
	
	
		
 
#define WSPR_CTC 10672 // CTC value for WSPR

			




	
	
	
		
 

			




	
	
	
		
 
char call_orig[7] = "KD8TDF";

			




	
	
	
		
 
#define DBM_ORIG 10

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
// Test stuff

			




	
	
	
		
 
char call[7] = "KD8TDF";

			




	
	
	
		
 
char loc[5] = "EN82";

			




	
	
	
		
 
char loc[7] = "EN82";

			




	
	
	
		
 
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;

			




	
	
	
		
 

			




	
	
	
		
 
TIM_HandleTypeDef htim1;

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
void wspr_init(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // Turn off ICs

			




	
	
	
		
 
    HAL_GPIO_WritePin(OSC_NOTEN, 1);

			




	
	
	
		
 
    HAL_GPIO_WritePin(TCXO_EN, 0);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// Do anything needed to prepare for sleep

			




	
	
	
		
 
void wspr_sleep(void)

			




	
	
	
		
 
{

			




	
	
		
 
@@ -48,82 +48,85 @@ void wspr_sleep(void)

			




	
	
	
		
 

			




	
	
	
		
 
void wspr_wakeup(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    HAL_TIM_Base_Start_IT(&htim1);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
// Bring up TCXO and oscillator IC

			




	
	
	
		
 
void wspr_transmit(uint8_t* grid_locator, uint8_t send_alternate)

			




	
	
	
		
 
{

			




	
	
	
		
 
	// Copy 4 digit grid locator to local buffer; null terminate

			




	
	
	
		
 
	for(uint8_t i=0; i<4; i++)

			




	
	
	
		
 
		loc[i] = grid_locator[i];

			




	
	
	
		
 
	loc[4] = '\0';

			




	
	
	
		
 

			




	
	
	
		
 
    // Set power to altitude in m / 150

			




	
	
	
		
 
    uint8_t altscaled = gps_getdata()->altitude / 150;

			




	
	
	
		
 
    if(altscaled > 60)

			




	
	
	
		
 
        altscaled = 60;

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    // If alternate packet, send 0XFXXEN82XX

			




	
	
	
		
 
    if(send_alternate)

			




	
	
	
		
 
    {

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
        /////////////////////////////////////////////////

			




	
	
	
		
 
        // Composite altitude and sub-maidenhead locator

			




	
	
	
		
 
        ///////////////////////////////////////////////// 

			




	
	
	
		
 
        uint16_t maiden_ext = (loc[4] - 'A') + ((loc[5] - 'A') * 24); // 0-575

			




	
	
	
		
 
        uint16_t altitude_mod = gps_getdata()->altitude / 20;   

			




	
	
	
		
 

			




	
	
	
		
 
        // Ciel at 21,340 meters

			




	
	
	
		
 
        if(altitude_mod > 1067)

			




	
	
	
		
 
            altitude_mod = 1067; // Don't overflow into maidenhead!

			




	
	
	
		
 
    

			




	
	
	
		
 
        // Compose composite altitude (lsbs) with maidenhead locator (msbs)

			




	
	
	
		
 
        uint32_t subalt = (1068 * maiden_ext) + (gps_getdata()->altitude / 20);

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
        ////////////////////////////////////////////

			




	
	
	
		
 
        // Encode extended maidenhead and altitude

			




	
	
	
		
 
        ////////////////////////////////////////////

			




	
	
	
		
 

			




	
	
	
		
 
        // Static set first char: balloon ID (invalid call)

			




	
	
	
		
 
        call[0] = '0';

			




	
	
	
		
 

			




	
	
	
		
 
        // Split into chunks of valmax 36, 26, 26, 26

			




	
	
	
		
 

			




	
	
	
		
 
        // Mask off following 3 26valmax fields

			




	
	
	
		
 
        uint32_t chunk = subalt / 26 / 26 / 26; 

			




	
	
	
		
 

			




	
	
	
		
 
        // Encode to callsign

			




	
	
	
		
 
        if(chunk < 10)

			




	
	
	
		
 
            call[1] = '0' + chunk;

			




	
	
	
		
 
        else

			




	
	
	
		
 
            call[1] = chunk - 10 + 'A';

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
        // Static set ID

			




	
	
	
		
 
        call[2] = '4'; // balloon ID #4

			




	
	
	
		
 

			




	
	
	
		
 
        // Subtract off previous portion

			




	
	
	
		
 
        subalt -= (chunk * 26 * 26 * 26);

			




	
	
	
		
 

			




	
	
	
		
 
        // Mask off following 2 26bit values

			




	
	
	
		
 
        chunk = (subalt / 26 / 26);

			




	
	
	
		
 

			




	
	
	
		
 
        call[3] = 'A' + chunk;

			




	
	
	
		
 

			




	
	
	
		
 
        // Subtract off previous portion

			




	
	
	
		
 
        subalt -= (chunk * 26 * 26);

			




	
	
	
		
 

			




	
	
	
		
 
        // Mask off following 1 26bit values

			




	
	
	
		
 
        chunk = (subalt / 26);

			




	
	
	
		
 

			




	
	
	
		
 
        call[4] = 'A' + chunk;

			




	
	
	
		
 

			




	
	
	
		
 
        // Subtract off previous portion

			




	
	
	
		
 
        subalt -= (chunk * 26);

			




	
	
	
		
 

			




	
	
	
		
 
        // Remainder is the last call char

			




	
	
	
		
 
        call[5] = 'A' + subalt;

			




	
	
	
		
 
 

			




	
	
	
		
 

			




	
	
	
		
 
        ////////////////////////////////////////

			




	
	
		
 
@@ -139,76 +142,76 @@ void wspr_transmit(uint8_t* grid_locator

			




	
	
	
		
 
        // Encode speed in knots from 0-82 to 0-41

			




	
	
	
		
 
        uint8_t speed_enc = gps_getdata()->speed / 2;

			




	
	
	
		
 
        if(speed_enc > 41)

			




	
	
	
		
 
            speed_enc = 41;

			




	
	
	
		
 

			




	
	
	
		
 
        // Encode GPS status

			




	
	
	
		
 
        uint8_t gps_status = 0b00; // MSB is valid fix, lsb is sats > 8

			




	
	
	
		
 

			




	
	
	
		
 
        if(gps_getdata()->fixtype == 2 || gps_getdata()->fixtype == 3)

			




	
	
	
		
 
            gps_status |= 0b10;

			




	
	
	
		
 

			




	
	
	
		
 
        if(gps_getdata()->sats_in_solution > 5)

			




	
	
	
		
 
            gps_status |= 0b01;

			




	
	
	
		
 

			




	
	
	
		
 
        uint32_t engdata = gps_status + 2 * (speed_enc + 42 * (batt_enc + 40 * temp_enc));

			




	
	
	
		
 

			




	
	
	
		
 
        ////////////////////////////////////////////

			




	
	
	
		
 
        // Encode temp/batt/speed/gps

			




	
	
	
		
 
        ////////////////////////////////////////////

			




	
	
	
		
 

			




	
	
	
		
 
        // Mask off fields

			




	
	
	
		
 
        chunk = engdata / 18 / 10 / 10 / 19;  

			




	
	
	
		
 

			




	
	
	
		
 
        // Encode to grid locator

			




	
	
	
		
 
        grid_locator[0] = 'A' + chunk;

			




	
	
	
		
 
        loc[0] = 'A' + chunk;

			




	
	
	
		
 

			




	
	
	
		
 
        // Subtract off previous portion 

			




	
	
	
		
 
        engdata -= (chunk * 18 * 10 * 10 * 19);  

			




	
	
	
		
 

			




	
	
	
		
 
        // Mask of fields

			




	
	
	
		
 
        chunk = engdata / 10 / 10 / 19;  

			




	
	
	
		
 

			




	
	
	
		
 
        // Encode to grid locator

			




	
	
	
		
 
        grid_locator[1] = 'A' + chunk;

			




	
	
	
		
 
        loc[1] = 'A' + chunk;

			




	
	
	
		
 

			




	
	
	
		
 
        // Subtract off previous portion

			




	
	
	
		
 
        engdata -= (chunk * 10 * 10 * 19);  

			




	
	
	
		
 

			




	
	
	
		
 
        // Mask off fields

			




	
	
	
		
 
        chunk = engdata / 10 / 19;  

			




	
	
	
		
 

			




	
	
	
		
 
        // Encode

			




	
	
	
		
 
        grid_locator[2] = '0' + chunk;

			




	
	
	
		
 
        loc[2] = '0' + chunk;

			




	
	
	
		
 

			




	
	
	
		
 
        // Subtract

			




	
	
	
		
 
        engdata -= (chunk * 10 * 19);  

			




	
	
	
		
 

			




	
	
	
		
 
        // Mask off

			




	
	
	
		
 
        chunk = engdata / 19;  

			




	
	
	
		
 

			




	
	
	
		
 
        // Encode

			




	
	
	
		
 
        grid_locator[3] = chunk;

			




	
	
	
		
 
        loc[3] = chunk;

			




	
	
	
		
 

			




	
	
	
		
 
        // Subtract

			




	
	
	
		
 
        engdata -= (chunk * 19);  

			




	
	
	
		
 

			




	
	
	
		
 
        // Mask off

			




	
	
	
		
 
        chunk = engdata;  

			




	
	
	
		
 

			




	
	
	
		
 
        // Encode

			




	
	
	
		
 
        uint8_t powers[] = {0, 3, 7, 10, 13, 17, 20, 23, 27, 30, 33, 37, 40, 43, 47, 50, 53, 57, 60};

			




	
	
	
		
 
        dbm = powers[chunk];

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        call[0] = call_orig[0];

			




	
	
	
		
 
        call[1] = call_orig[1];

			




	
	
	
		
 
        call[2] = call_orig[2];

			




	
	
	
		
 
        call[3] = call_orig[3];

			




	
	
	
		
 
        call[4] = call_orig[4];

			




	
	
	
		
 
        call[5] = call_orig[5];

			




	
	
	
		
 
        call[6] = call_orig[6];

			




	
	
	
		
 

			




	
	
	
		
 
        dbm = DBM_ORIG; 

			




        

    



    


    



    



      

      





    
    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