Changeset - 8e3cff0b603c
[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:
0 comments (0 inline, 0 general)
src/main.c
Show inline comments
 
@@ -61,25 +61,25 @@ int main(void)
 
    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
 
@@ -184,25 +184,25 @@ int main(void)
 
            	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
src/wspr.c
Show inline comments
 
@@ -9,25 +9,25 @@
 

	
 

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

	
 
@@ -60,58 +60,61 @@ void wspr_transmit(uint8_t* grid_locator
 
		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
 
@@ -151,52 +154,52 @@ void wspr_transmit(uint8_t* grid_locator
 
            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];
 

	
 

	
0 comments (0 inline, 0 general)