FeatherHAB/wsprhab Changeset - 9ba4d6855ba4

Changeset - 9ba4d6855ba4

Parent rev.

Child rev.

[Not reviewed]

default

0 3 0

Ethan Zonca - 9 years ago 2016-10-11 21:17:20
ez@ethanzonca.com

GPS parsing endianness fixe

3 files changed with 94 insertions and 106 deletions:

inc/gps.h

src/gps.c

src/main.c

0 comments (0 inline, 0 general)

inc/gps.h

➞

Show inline comments

 #ifndef GPS_H_
 #define GPS_H_
 #include <stdint.h>
 typedef struct _gps_data
+{
     int32_t pdop;
     int32_t sats_in_solution;
     uint32_t speed;
     //! int32_t heading;
     uint32_t pdop;
     uint8_t sats_in_solution;
     int32_t speed;
     int32_t heading;
     int32_t latitude;
     int32_t longitude;
     int32_t altitude;
     uint8_t month;
     uint8_t day;
     uint8_t hour;
     uint8_t minute;
     uint8_t second;
     uint8_t valid;
     uint8_t fixtype;
 } gps_data_t;
 void gps_init();
 void gps_update_data(void);
 uint8_t gps_check_nav(void);
 void gps_poweron(void);
 void gps_poweroff(void);
 void gps_acquirefix(void);
 uint8_t gps_getstate(void);
 gps_data_t* gps_getdata(void);
 uint8_t gps_ison(void);
 #endif /* GPS_H_ */

src/gps.c

➞

Show inline comments

 //
 // GPS: communicate with ublox GPS module via ubx protocol
 //
 #include "stm32f0xx_hal.h"
 #include "config.h"
 #include "gpio.h"
 #include "uart.h"
 #include "gps.h"
 volatile gps_data_t position;
+uint8_t gpson = 0;
 // Private methods
 static void gps_ubx_checksum(uint8_t* data, uint8_t len, uint8_t* cka, uint8_t* ckb);
 static uint8_t _gps_verify_checksum(uint8_t* data, uint8_t len);
 // Initialize GPS module on startup
 void gps_init()
+{
     // Initialize serial port
    // done in poweron uart_init();
 	gps_poweron();
 //	// uart1 ubx only
 //
 //	uint8_t setUBXuart1 = {0xB5, 0x62, 0x06, 0x00, 0x14, 0x00, 0x01, 0x00, 0x00, 0x00, 0xD0, 0x08, 0x00, 0x00, 0x80, 0x25,
 //	0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9A, 0x79};
 //	HAL_UART_Transmit(uart_gethandle(), setUBXuart1, sizeof(setUBXuart1)/sizeof(uint8_t), 100);
 //	HAL_Delay(100);
 //
 //
 //	// uart0 ubx only
 //	uint8_t setUBXuart0 = {0xB5, 0x62, 0x06, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD0, 0x08, 0x00, 0x00, 0x80, 0x25,
 //	0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x99, 0x65};
 //	HAL_UART_Transmit(uart_gethandle(), setUBXuart0, sizeof(setUBXuart0)/sizeof(uint8_t), 100);
 //	HAL_Delay(100);
 //
 //
 //	// uart1 ubx only
 //
 //	uint8_t setUBXuart2 = {0xB5, 0x62, 0x06, 0x00, 0x14, 0x00, 0x02, 0x00, 0x00, 0x00, 0xD0, 0x08, 0x00, 0x00, 0x80, 0x25,
 //	0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9B, 0x8D};
 //	HAL_UART_Transmit(uart_gethandle(), setUBXuart2, sizeof(setUBXuart2)/sizeof(uint8_t), 100);
 //	HAL_Delay(100);
 	// Disable messages
 	uint8_t setGGA[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0XFF, 0X23};
 	HAL_UART_Transmit(uart_gethandle(), setGGA, sizeof(setGGA)/sizeof(uint8_t), 100);
 	HAL_Delay(100);
 	uint8_t ackbuffer[10];
 	for(uint8_t i=0; i<10; i++)
 		ackbuffer[i] = 0xaa;
 	HAL_UART_Receive(uart_gethandle(), ackbuffer, 10, 100);
 	uint8_t setZDA[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X07, 0X5B};
 	HAL_UART_Transmit(uart_gethandle(), setZDA, sizeof(setZDA)/sizeof(uint8_t), 100);
 	HAL_Delay(100);
 	uint8_t setGLL[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X01, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X2A};
 	HAL_UART_Transmit(uart_gethandle(), setGLL, sizeof(setGLL)/sizeof(uint8_t), 100);
 	HAL_Delay(100);
 	uint8_t setGSA[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X02, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X01, 0X31};
 	HAL_UART_Transmit(uart_gethandle(), setGSA, sizeof(setGSA)/sizeof(uint8_t), 100);
 	HAL_Delay(100);
 	uint8_t setGSV[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X02, 0X38};
 	HAL_UART_Transmit(uart_gethandle(), setGSV, sizeof(setGSV)/sizeof(uint8_t), 100);
 	HAL_Delay(100);
 	uint8_t setRMC[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X04, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X03, 0X3F};
 	HAL_UART_Transmit(uart_gethandle(), setRMC, sizeof(setRMC)/sizeof(uint8_t), 100);
 	HAL_Delay(100);
 	uint8_t setVTG[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X05, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X04, 0X46};
 	HAL_UART_Transmit(uart_gethandle(), setVTG, sizeof(setRMC)/sizeof(uint8_t), 100);
 	HAL_Delay(100);
 //    // Disable GLONASS mode
 //    uint8_t disable_glonass[20] = {0xB5, 0x62, 0x06, 0x3E, 0x0C, 0x00, 0x00, 0x00, 0x20, 0x01, 0x06, 0x08, 0x0E, 0x00, 0x00, 0x00, 0x01, 0x01, 0x8F, 0xB2};
 //
 //    //gps_sendubx(disable_glonass, 20);
 //    volatile HAL_StatusTypeDef res = HAL_UART_Transmit(uart_gethandle(), disable_glonass, 20, 100);
 //
 //    // Enable power saving
 //    uint8_t enable_powersave[10] = {0xB5, 0x62, 0x06, 0x11, 0x02, 0x00, 0x08, 0x01, 0x22, 0x92};
 //    //gps_sendubx(enable_powersave, 10);
 //    res = HAL_UART_Transmit(uart_gethandle(), enable_powersave, 10, 100);
 //
 //
 //    // Set dynamic model 6 (<1g airborne platform)
 //    uint8_t airborne_model[] = { 0xB5, 0x62, 0x06, 0x24, 0x24, 0x00, 0xFF, 0xFF, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10, 0x27, 0x00, 0x00, 0x05, 0x00, 0xFA, 0x00, 0xFA, 0x00, 0x64, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0xDC };
 //    //gps_sendubx(airborne_model, sizeof(airborne_model)/sizeof(uint8_t));
 //    res = HAL_UART_Transmit(uart_gethandle(), airborne_model, sizeof(airborne_model)/sizeof(uint8_t), 100);
+}
 // Poll for fix data from the GPS and update the internal structure
 void gps_update_data(void)
+{
     // Construct the request to the GPS
     uint8_t request[8] = {0xB5, 0x62, 0x01, 0x07, 0x00, 0x00, 0xFF, 0xFF};
     volatile uint8_t check_a = 0;
     volatile uint8_t check_b = 0;
     for(uint8_t i = 2; i<6; i++)
+    {
     	check_a += request[i];
     	check_b += check_a;
+    }
     request[6] = check_a;
     request[7] = check_b;
     uint8_t flushed = uart_gethandle()->Instance->RDR;
     HAL_UART_Transmit(uart_gethandle(), request, 8, 100);
     // Get the message back from the GPS
     uint8_t buf[100];
     for(uint8_t i=0; i<100; i++)
     	buf[i] = 0xaa;
     volatile HAL_StatusTypeDef res = HAL_UART_Receive(uart_gethandle(), buf, 100, 3000);
     // Check 60 bytes minus SYNC and CHECKSUM (4 bytes)
     if( !_gps_verify_checksum(&buf[2], 96) )
         led_blink(2);
     //volatile uint32_t gpstime_ms = (buf[6+0] << 24) | (buf[6+1] << 16) | buf[6+2] << 8) | (buf[6+3]);
     position.month = buf[6+6];
     position.day = buf[6+7];
     position.hour = buf[6+8];
     position.minute = buf[6+9];
     position.second = buf[6+10];
     position.valid = buf[6+11] & 0b1111;
     position.fixtype = buf[6+20];
     position.sats_in_solution = buf[6+23];
     position.longitude = (buf[6+24] << 24) | (buf[6+25] << 16) | (buf[6+26] << 8) | (buf[6+27]);
     position.latitude =  (buf[6+28] << 24) | (buf[6+29] << 16) | (buf[6+30] << 8) | (buf[6+31]);
     position.altitude = (buf[6+36] << 24) | (buf[6+37] << 16) | (buf[6+38] << 8) | (buf[6+39]);
     position.speed = (buf[6+60] << 24) | (buf[6+61] << 16) | (buf[6+62] << 8) | (buf[6+63]);
     position.pdop = (buf[6+76] << 8) | (buf[6+77]);
     position.longitude = (buf[6+24] << 0) | (buf[6+25] << 8) | (buf[6+26] << 16) | (buf[6+27] << 24); // degrees
     position.latitude =  (buf[6+28] << 0) | (buf[6+29] << 8) | (buf[6+30] << 16) | (buf[6+31] << 24); // degrees
     position.altitude = (buf[6+36] << 0) | (buf[6+37] << 8) | (buf[6+38] << 16) | (buf[6+39] << 24); // mm above sealevel
     position.altitude /= 1000; // mm => m
     position.speed = (buf[6+60] << 0) | (buf[6+61] << 8) | (buf[6+62] << 16) | (buf[6+63] << 24); // mm/second
     position.speed /= 1000; // mm/s -> m/s
     position.pdop = (buf[6+76] << 0) | (buf[6+77] << 8);
     position.pdop /= 100; // scale to dop units
     position.heading = (buf[6+84] << 0) | (buf[6+85] << 8) | (buf[6+86] << 16) | (buf[6+87] << 24); // mm above sealevel
     position.heading /= 100000; // 1e-5
 //    // Return the value if GPSfixOK is set in 'flags'
 //    if( buf[17] & 0x01 )
 //        *lock = buf[16];
 //    else
 //        *lock = 0;
+}
 // TODO: Add data valid flag: invalidate data when GPS powered off
 // Verify that the uBlox 6 GPS receiver is set to the <1g airborne navigaion mode.
 uint8_t gps_check_nav(void)
+{
     uint8_t request[8] = {0xB5, 0x62, 0x06, 0x24, 0x00, 0x00,
 x2A, 0x84};
     uint8_t flushed = uart_gethandle()->Instance->RDR;
     HAL_UART_Transmit(uart_gethandle(), request, 8, 100);
     // Get the message back from the GPS
     uint8_t buf[44];
     HAL_UART_Receive(uart_gethandle(), buf, 44, 100);
 //    // Verify sync and header bytes
 //    if( buf[0] != 0xB5 || buf[1] != 0x62 )
 //        led_set(LED_RED, 1);
 //    if( buf[2] != 0x06 || buf[3] != 0x24 )
 //        led_set(LED_RED, 1);
     // Check 40 bytes of message checksum
 //    if( !_gps_verify_checksum(&buf[2], 40) ) led_set(LED_RED, 1);
     // Clock in and verify the ACK/NACK
     uint8_t ack[10];
 //    for(uint8_t i = 0; i < 10; i++)
 //        ack[i] = _gps_get_byte();
     HAL_UART_Receive(uart_gethandle(), ack, 10, 100);
     // If we got a NACK, then return 0xFF
     if( ack[3] == 0x00 ) return 0xFF;
     // Return the navigation mode and let the caller analyse it
     return buf[8];
+}
 // Verify the checksum for the given data and length.
 static uint8_t _gps_verify_checksum(uint8_t* data, uint8_t len)
+{
     uint8_t a, b;
     gps_ubx_checksum(data, len, &a, &b);
     if( a != *(data + len) || b != *(data + len + 1))
         return 0;
     else
         return 1;
+}
 // Calculate a UBX checksum using 8-bit Fletcher (RFC1145)
 static void gps_ubx_checksum(uint8_t* data, uint8_t len, uint8_t* cka, uint8_t* ckb)
+{
     *cka = 0;
     *ckb = 0;
     for( uint8_t i = 0; i < len; i++ )
+    {
         *cka += *data;
         *ckb += *cka;
         data++;
+    }
+}
 // Power on GPS module and initialize UART
 void gps_poweron(void)
+{
     // NOTE: pchannel
     HAL_GPIO_WritePin(GPS_NOTEN, 0);
     uart_init();
 	// Disable messages
 	uint8_t setGGA[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0XFF, 0X23};
 	HAL_UART_Transmit(uart_gethandle(), setGGA, sizeof(setGGA)/sizeof(uint8_t), 100);
 	HAL_Delay(100);
 	uint8_t ackbuffer[10];
 	for(uint8_t i=0; i<10; i++)
 		ackbuffer[i] = 0xaa;
 	HAL_UART_Receive(uart_gethandle(), ackbuffer, 10, 100);
 	uint8_t setZDA[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X07, 0X5B};
 	HAL_UART_Transmit(uart_gethandle(), setZDA, sizeof(setZDA)/sizeof(uint8_t), 100);
 	HAL_Delay(100);
 	uint8_t setGLL[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X01, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X2A};
 	HAL_UART_Transmit(uart_gethandle(), setGLL, sizeof(setGLL)/sizeof(uint8_t), 100);
 	HAL_Delay(100);
 	uint8_t setGSA[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X02, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X01, 0X31};
 	HAL_UART_Transmit(uart_gethandle(), setGSA, sizeof(setGSA)/sizeof(uint8_t), 100);
 	HAL_Delay(100);
 	uint8_t setGSV[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X02, 0X38};
 	HAL_UART_Transmit(uart_gethandle(), setGSV, sizeof(setGSV)/sizeof(uint8_t), 100);
 	HAL_Delay(100);
 	uint8_t setRMC[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X04, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X03, 0X3F};
 	HAL_UART_Transmit(uart_gethandle(), setRMC, sizeof(setRMC)/sizeof(uint8_t), 100);
 	HAL_Delay(100);
 	uint8_t setVTG[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X05, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X04, 0X46};
 	HAL_UART_Transmit(uart_gethandle(), setVTG, sizeof(setRMC)/sizeof(uint8_t), 100);
 	HAL_Delay(100);
 //    // Disable GLONASS mode
 //    uint8_t disable_glonass[20] = {0xB5, 0x62, 0x06, 0x3E, 0x0C, 0x00, 0x00, 0x00, 0x20, 0x01, 0x06, 0x08, 0x0E, 0x00, 0x00, 0x00, 0x01, 0x01, 0x8F, 0xB2};
 //
 //    //gps_sendubx(disable_glonass, 20);
 //    volatile HAL_StatusTypeDef res = HAL_UART_Transmit(uart_gethandle(), disable_glonass, 20, 100);
 //
 //    // Enable power saving
 //    uint8_t enable_powersave[10] = {0xB5, 0x62, 0x06, 0x11, 0x02, 0x00, 0x08, 0x01, 0x22, 0x92};
 //    //gps_sendubx(enable_powersave, 10);
 //    res = HAL_UART_Transmit(uart_gethandle(), enable_powersave, 10, 100);
 //
 //
 //    // Set dynamic model 6 (<1g airborne platform)
 //    uint8_t airborne_model[] = { 0xB5, 0x62, 0x06, 0x24, 0x24, 0x00, 0xFF, 0xFF, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10, 0x27, 0x00, 0x00, 0x05, 0x00, 0xFA, 0x00, 0xFA, 0x00, 0x64, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0xDC };
 //    //gps_sendubx(airborne_model, sizeof(airborne_model)/sizeof(uint8_t));
 //    res = HAL_UART_Transmit(uart_gethandle(), airborne_model, sizeof(airborne_model)/sizeof(uint8_t), 100);
     // Begin DMA reception
     //HAL_UART_Receive_DMA(uart_gethandle(), nmeaBuffer, NMEABUFFER_SIZE);
     gpson = 1;
+}
 // Power off GPS module
 void gps_poweroff(void)
+{
     // NOTE: pchannel
     uart_deinit();
     HAL_GPIO_WritePin(GPS_NOTEN, 1);
     gpson = 0;
+}
 gps_data_t* gps_getdata(void)
+{
     return &position;
+}
 uint8_t gps_ison(void)
+{
     return gpson;
+}
 // vim:softtabstop=4 shiftwidth=4 expandtab

src/main.c

➞

Show inline comments

 //
 // 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 "gps.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
 // Probabl wake up 1 minute early -- 0.45min possible +/- on wakeup time with 15min sync intervals
 enum _state
+{
     SYSTEM_POWERUP_SYNC = 0, // on powerup, get a GPS fix and set the RTC
     SYSTEM_IDLE, // 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
 };
 int main(void)
+{
     HAL_Init();
     sysclk_init();
     gpio_init();
     adc_init();
     i2c_init();
     gps_init();
     wspr_init();
     uint32_t led_timer = HAL_GetTick();
     led_blink(4);
     uint16_t blink_rate = BLINK_FAST;
     uint8_t state = SYSTEM_GPSACQ;
     uint32_t fixinfo_timer = 0;
     uint8_t fix_ok = 0;
     uint8_t numsats = 0;
     while (1)
+    {
         // Update fix status every 2 seconds
         if(HAL_GetTick() - fixinfo_timer > 2000)
+        {
             if(gps_ison())
         	gps_update_data();
         	fixinfo_timer = HAL_GetTick();
+        }
         switch(state)
+        {
             // Idling: sleep and wait for RTC timeslot trigger
             case SYSTEM_IDLE:
+            {
                 blink_rate = BLINK_SLOW;
                 // Wait for RTC wakeup interrupt
                 //wfi();
                 //enter_sleep();
                 // Somehow go to another state when we get an interrupt
 //                state = SYSTEM_GPSACQ;
             } break;
             // Attempt to acquire GPS fix
             case SYSTEM_GPSACQ:
+            {
                 blink_rate = BLINK_FAST;
                 // TODO: probably don't power on all the time, just on state transition
 //                gps_poweron();
 //                HAL_Delay(100);
 //                gps_update_position();
                 if(!gps_ison())
                     gps_poweron(); // power on and initialize GPS module
                 if(gps_getdata()->fixtype > 0)
+                if(gps_getdata()->fixtype > 0 && gps_getdata()->pdop < 5)
+                {
                     // Disable GPS module
-                    //gps_poweroff();
                     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!
                     state = SYSTEM_WSPRTX;
+                }
 //                else if(fix_timeout)
  //               {
   //                  // Flash error code and go to idle probably? or just try forever?
    //             }
             } break;
             // Wait for wspr timeslot and start transmitting
             case SYSTEM_WSPRTX:
+            {
             	blink_rate = BLINK_SLOW;
                 // Wait for wspr countdown timer to expire and go to tx
 //                if(timeout_expired)
 //                {
 //                    wspr_transmit();
 //                }
                 // Schedule next wakeup (maybe 2mins prior ot timeslot if no osc trim)
                 // Next wakeup should enter SYSTEM_GPSACQ state...
 //                state = SYSTEM_IDLE;
             } break;
+        }
         if(HAL_GetTick() - led_timer > blink_rate)
+        {
             HAL_GPIO_TogglePin(LED_BLUE);
             led_timer = HAL_GetTick();
+        }
+    }
+}

0 comments (0 inline, 0 general)