FeatherHAB/wsprhab Changeset - 2dcb56fc814b

Changeset - 2dcb56fc814b

Parent rev.

Child rev.

[Not reviewed]

default

0 3 0

Ethan Zonca - 10 years ago 2016-04-02 20:17:20
ez@ethanzonca.com

GPS parse succeed, doesn't coexist with wspr right now, probably malloc taking up all of the heap...

3 files changed with 468 insertions and 481 deletions:

STM32F031G6_FLASH.ld

src/gps.c

463

475

src/main.c

0 comments (0 inline, 0 general)

STM32F031G6_FLASH.ld

➞

Show inline comments

 /*
 *****************************************************************************
 **
 **  File        : stm32_flash.ld
 **
 **  Abstract    : Linker script for STM32F031G6 Device with
 **                32KByte FLASH, 4KByte RAM
 **
 **                Set heap size, stack size and stack location according
 **                to application requirements.
 **
 **                Set memory bank area and size if external memory is used.
 **
 **  Target      : STMicroelectronics STM32
 **
 **  Environment : Atollic TrueSTUDIO(R)
 **
 **  Distribution: The file is distributed “as is,” without any warranty
 **                of any kind.
 **
 **  (c)Copyright Atollic AB.
 **  You may use this file as-is or modify it according to the needs of your
 **  project. This file may only be built (assembled or compiled and linked)
 **  using the Atollic TrueSTUDIO(R) product. The use of this file together
 **  with other tools than Atollic TrueSTUDIO(R) is not permitted.
 **
 *****************************************************************************
 */
 /* Entry Point */
 ENTRY(Reset_Handler)
 /* Highest address of the user mode stack */
 _estack = 0x20001000;    /* end of RAM */
 /* Generate a link error if heap and stack don't fit into RAM */
 _Min_Heap_Size = 0;      /* required amount of heap  */
-_Min_Stack_Size = 0x200; /* required amount of stack */
+_Min_Stack_Size = 0x300; /* required amount of stack */
 /* Specify the memory areas */
 MEMORY
+{
 FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 32K
 RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 4K
+}
 /* Define output sections */
 SECTIONS
+{
   /* The startup code goes first into FLASH */
   .isr_vector :
+  {
     . = ALIGN(4);
     KEEP(*(.isr_vector)) /* Startup code */
     . = ALIGN(4);
   } >FLASH
   /* The program code and other data goes into FLASH */
   .text :
+  {
     . = ALIGN(4);
     *(.text)           /* .text sections (code) */
     *(.text*)          /* .text* sections (code) */
     *(.glue_7)         /* glue arm to thumb code */
     *(.glue_7t)        /* glue thumb to arm code */
     *(.eh_frame)
     KEEP (*(.init))
     KEEP (*(.fini))
     . = ALIGN(4);
     _etext = .;        /* define a global symbols at end of code */
   } >FLASH
   /* Constant data goes into FLASH */
   .rodata :
+  {
     . = ALIGN(4);
     *(.rodata)         /* .rodata sections (constants, strings, etc.) */
     *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
     . = ALIGN(4);
   } >FLASH
   .ARM.extab   : { *(.ARM.extab* .gnu.linkonce.armextab.*) } >FLASH
   .ARM : {
     __exidx_start = .;
     *(.ARM.exidx*)
     __exidx_end = .;
   } >FLASH
   .preinit_array     :
+  {
     PROVIDE_HIDDEN (__preinit_array_start = .);
     KEEP (*(.preinit_array*))
     PROVIDE_HIDDEN (__preinit_array_end = .);
   } >FLASH
   .init_array :
+  {
     PROVIDE_HIDDEN (__init_array_start = .);
     KEEP (*(SORT(.init_array.*)))
     KEEP (*(.init_array*))
     PROVIDE_HIDDEN (__init_array_end = .);
   } >FLASH
   .fini_array :
+  {
     PROVIDE_HIDDEN (__fini_array_start = .);
     KEEP (*(SORT(.fini_array.*)))
     KEEP (*(.fini_array*))
     PROVIDE_HIDDEN (__fini_array_end = .);
   } >FLASH
   /* used by the startup to initialize data */
   _sidata = LOADADDR(.data);
   /* Initialized data sections goes into RAM, load LMA copy after code */
   .data :
+  {
     . = ALIGN(4);
     _sdata = .;        /* create a global symbol at data start */
     *(.data)           /* .data sections */
     *(.data*)          /* .data* sections */
     . = ALIGN(4);
     _edata = .;        /* define a global symbol at data end */
   } >RAM AT> FLASH
   /* Uninitialized data section */
   . = ALIGN(4);
   .bss :
+  {
     /* This is used by the startup in order to initialize the .bss secion */
     _sbss = .;         /* define a global symbol at bss start */
     __bss_start__ = _sbss;

src/gps.c

➞

Show inline comments

 // TODO: Transition to using https://github.com/cuspaceflight/joey-m/blob/master/firmware/gps.c requesting UBX data
 #include "stm32f0xx_hal.h"
 #include "config.h"
 #include "usart.h"
 #include "gps.h"
 // Circular buffer for incoming data
 uint8_t nmeaBuffer[NMEABUFFER_SIZE];
 // Location of parser in the buffer
 uint8_t nmeaBufferParsePosition = 0;
 // Location of receive byte interrupt in the buffer
 volatile uint16_t nmeaBufferDataPosition = 0;
 // holds the byte ALREADY PARSED. includes starting character
 int bytesReceived = 0;
 //data (and checksum) of most recent transmission
 char data[16];
 //used to skip over bytes during parse
 uint32_t skipBytes = 0;
 uint8_t skipBytes = 0;
 //used to index data arrays during data collection
 uint32_t numBytes = 0;
 //variables to store data from transmission
 //least significant digit is stored at location 0 of arrays
 char tramsmissionType[7];
 void gps_poweron(void)
+{
     // NOTE: pchannel
     //gpio_clear(GPS_ONOFF);
+}
 void gps_poweroff(void)
+{
     // NOTE: pchannel
     //gpio_set(GPS_ONOFF);
+}
 char timestamp[12];	//hhmmss.ss
 char* get_timestamp()
+{
 	return timestamp;
+}
 char latitude[14];	//lllll.lla
 char latitudeTmpTRIM[8];
 char latitudeTmpLSB[4];
 char* get_latitudeTrimmed()
+{
 	strncpy(latitudeTmpTRIM, &latitude[0], 7);
 	latitudeTmpTRIM[7] = 0x00;
 	return latitudeTmpTRIM;
+}
 char* get_latitudeLSBs()
+{
 	strncpy(latitudeTmpLSB, &latitude[7], 3);
 	latitudeTmpLSB[3] = 0x00;
 	return latitudeTmpLSB;
+}
 char longitude[14];	//yyyyy.yyb
 char longitudeTmpTRIM[9];
 char longitudeTmpLSB[4];
 char* get_longitudeTrimmed()
+{
 	strncpy(longitudeTmpTRIM, &longitude[0], 8);
 	longitudeTmpTRIM[8] = 0x00;
 	return longitudeTmpTRIM;
+}
 char* get_longitudeLSBs()
+{
 	strncpy(longitudeTmpLSB, &longitude[8], 3);
 	longitudeTmpLSB[3] = 0x00;
 	return longitudeTmpLSB;
+}
 char quality;		//quality for GGA and validity for RMC
 char numSatellites[4];
 char* get_sv()
+{
 	return numSatellites;
+}
 char hdop[6];		//xx.x
 char* get_hdop()
+{
 	return hdop;
+}
 char altitude[10];	//xxxxxx.x
 char* get_gpsaltitude()
+{
 	return altitude;
+}
 //char wgs84Height[8];	//sxxx.x
 //char lastUpdated[8];	//blank - included for testing
 //char stationID[8];	//blank - included for testing
 char checksum[3];	//xx
 char knots[8];		//xxx.xx
 char* get_speedKnots()
+{
 	return knots;
+}
 char course[8];		//xxx.x
 char* get_course()
+{
 	return course;
+}
 char dayofmonth[9];	//ddmmyy
 char* get_dayofmonth()
+{
 	return dayofmonth;
+}
 uint8_t gps_hadfix = 0;
 uint8_t gps_hasfix()
+{
 	uint8_t hasFix = get_latitudeTrimmed()[0] != 0x00;
 	gps_hadfix = hasFix;
 	return hasFix;
+}
 //char variation[9];	//xxx.xb
 int calculatedChecksum;
 int receivedChecksum;
 // transmission state machine
 enum decodeState {
 	//shared fields
 	INITIALIZE=0,
 	GET_TYPE,
 	GPS_CHECKSUM,	//XOR of all the bytes between the $ and the * (not including the delimiters themselves), written in hexadecimal
 	//GGA data fields
 	GGA_TIME,
 	GGA_LATITUDE,
 	GGA_LONGITUDE,
 	GGA_QUALITY,
 	GGA_SATELLITES,
 	GGA_HDOP,
 	GGA_ALTITUDE,
 	GGA_WGS84,
 	GGA_LAST_UPDATE,
 	GGA_STATION_ID,
 	//RMC data fields
 	RMC_TIME,
 	RMC_VALIDITY,
 	RMC_LATITUDE,
 	RMC_LONGITUDE,
 	RMC_KNOTS,
 	RMC_COURSE,
 	RMC_DATE,
 	RMC_MAG_VARIATION,
 }decodeState;
 //
 //void usart1_isr(void)
 //{
 //	uint8_t recv = 0;// usart_recv(GPS_USART);
 //	//ECHO debug: usart_send_blocking(GPS_USART, recv);
 //	nmeaBuffer[nmeaBufferDataPosition % NMEABUFFER_SIZE] = recv;
 //	nmeaBufferDataPosition = (nmeaBufferDataPosition + 1) % NMEABUFFER_SIZE;
 //}
 void gps_init()
+{
     // Initialize serial port
     uart_init();
     // Begin DMA reception
     HAL_UART_Receive_DMA(uart_gethandle(), nmeaBuffer, NMEABUFFER_SIZE);
     uint8_t buf2[4] = {0};
     //volatile HAL_StatusTypeDef res = HAL_UART_Receive(uart_gethandle(), nmeaBuffer, 2, 3000);
     timestamp[0] = 0x00;
     latitude[0] = 0x00;
     longitude[0] = 0x00;
     numSatellites[0] = 0x00;
     hdop[0] = 0x00;
     knots[0] = 0x00;
     course[0] = 0x00;
     dayofmonth[0] = 0x00;
     gps_poweron();
     HAL_Delay(100); // Make sure GPS is awake and alive
 //    // 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);
 //
 //    // Enable power saving
 //    uint8_t enable_powersave[10] = {0xB5, 0x62, 0x06, 0x11, 0x02, 0x00, 0x08, 0x01, 0x22, 0x92};
 //    gps_sendubx(enable_powersave, 10);
 //
 //
 //    // 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));
+}
 void gps_sendubx(uint8_t* dat, uint8_t size)
+{
     uint8_t sendctr;
     for(sendctr = 0; sendctr < size; sendctr++)
+    {
         //usart_send(GPS_USART, dat[sendctr]);
+    }
+}
 // Could inline if program space available
 static void setParserState(uint8_t state)
+{
 	decodeState = state;
 	// If resetting, clear vars
 	if(state == INITIALIZE)
+	{
 		calculatedChecksum = 0;
+	}
 	// Every time we change state, we have parsed a byte
 	nmeaBufferParsePosition = (nmeaBufferParsePosition + 1) % NMEABUFFER_SIZE;
+}
 //// MKa GPS transmission parser START
 void parse_gps_transmission(void){
 //	// Pull byte off of the buffer
 //	char byte;
 //
 //	while(nmeaBufferDataPosition != nmeaBufferParsePosition)
 //	{
 //		byte = nmeaBuffer[nmeaBufferParsePosition];
 //
 //		if(decodeState == INITIALIZE) //start of transmission sentence
 //		{
 //			if(byte == '$')
 //			{
 //				setParserState(GET_TYPE);
 //				numBytes = 0; //prep for next phases
 //				skipBytes = 0;
 //				calculatedChecksum = 0;
 //			}
 //
 //			else
 //			{
 //				setParserState(INITIALIZE);
 //			}
 //		}
 //
 //		//parse transmission type
 //		else if (decodeState == GET_TYPE)
 //		{
 //			tramsmissionType[numBytes] = byte;
 //			numBytes++;
 //
 //			if(byte == ',') //end of this data type
 //			{
 //				tramsmissionType[5] = 0x00;
 //
 //				if (tramsmissionType[2] == 'G' &&
 //				tramsmissionType[3] == 'G' &&
 //				tramsmissionType[4] == 'A')
 //				{
 //					setParserState(GGA_TIME);
 //					numBytes = 0;
 //				}
 //				else if (tramsmissionType[2] == 'R' &&
 //				tramsmissionType[3] == 'M' &&
 //				tramsmissionType[4] == 'C')
 //				{
 //					setParserState(RMC_TIME);
 //					numBytes = 0;
 //				}
 //				else //this is an invalid transmission type
 //				{
 //					setParserState(INITIALIZE);
 //				}
 //			}
 //			else {
 //				// continue
 //				setParserState(GET_TYPE);
 //			}
 //
 //		}
 //
 //		///parses GGA transmissions START
 //		/// $--GGA,hhmmss.ss,llll.ll,a,yyyyy.yy,a,x,xx,x.x,x.x,M,x.x,M,x.x,xxxx*xx
 //		//timestamp
 //		else if (decodeState == GGA_TIME)
 //		{
 //			if (byte == ',') //end of this data type
 //			{
 //				timestamp[4] = 0x00; // Cut off at 4 (no seconds) for APRS
 //				setParserState(GGA_LATITUDE);
 //				skipBytes = 0; //prep for next phase of parse
 //				numBytes = 0;
 //			}
 //			else //store data
 //			{
 //				setParserState(GGA_TIME);
 //				timestamp[numBytes] = byte; //byte; //adjust number of bytes to fit array
 //				numBytes++;
 //			}
 //		}
 //
 //		//latitude
 //		else if (decodeState == GGA_LATITUDE)
 //		{
 //			if (byte == ',' && skipBytes == 0) //discard this byte
 //			{
 //				skipBytes = 1;
 //				setParserState(GGA_LATITUDE);
 //			}
 //			else if (byte == ',') //end of this data type
 //			{
 //
 //				latitude[numBytes] = 0x00; // null terminate
 //
 //				setParserState(GGA_LONGITUDE);
 //				skipBytes = 0; //prep for next phase of parse
 //				numBytes = 0;
 //			}
 //			else //store data
 //			{
 //				latitude[numBytes] = byte; //adjust number of bytes to fit array
 //				numBytes++;
 //				setParserState(GGA_LATITUDE);
 //			}
 //		}
 //
 //		//longitude
 //		else if (decodeState == GGA_LONGITUDE)
 //		{
 //			if (byte == ',' && skipBytes == 0) //discard this byte
 //			{
 //				skipBytes = 1;
 //				setParserState(GGA_LONGITUDE);
 //			}
 //			else if (byte == ',') //end of this data type
 //			{
 //				longitude[numBytes] = 0x00;
 //				setParserState(GGA_QUALITY);
 //				numBytes = 0; //prep for next phase of parse
 //				skipBytes = 0;
 //			}
 //			else //store data
 //			{
 //				longitude[numBytes] = byte; //adjust number of bytes to fit array
 //				numBytes++;
 //				setParserState(GGA_LONGITUDE);
 //			}
 //		}
 //
 //		//GGA quality
 //		else if (decodeState == GGA_QUALITY)
 //		{
 //			if (byte == ',') //end of this data type
 //			{
 //				setParserState(GGA_SATELLITES);
 //				numBytes = 0; //prep for next phase of parse
 //			}
 //			else //store data
 //			{
 //				quality = byte; //maybe reset if invalid data ??
 //				setParserState(GGA_QUALITY);
 //			}
 //		}
 //
 //		//number of satellites
 //		else if (decodeState == GGA_SATELLITES)
 //		{
 //			if (byte == ',') //end of this data type
 //			{
 //				numSatellites[numBytes] = 0x00;
 //				setParserState(GGA_HDOP);
 //				numBytes = 0; //prep for next phase of parse
 //			}
 //			else //store data
 //			{
 //				numSatellites[numBytes] = byte; //adjust number of bytes to fit array
 //				numBytes++;
 //				setParserState(GGA_SATELLITES);
 //			}
 //		}
 //
 //		//HDOP
 //		else if (decodeState == GGA_HDOP)
 //		{
 //			if (byte == ',' ) //end of this data type
 //			{
 //				hdop[numBytes] = 0x00;
 //				setParserState(GGA_ALTITUDE);
 //				numBytes = 0; //prep for next phase of parse
 //				skipBytes = 0;
 //			}
 //			else //store data
 //			{
 //				hdop[numBytes] = byte; //adjust number of bytes to fit array
 //				numBytes++;
 //				setParserState(GGA_HDOP);
 //			}
 //		}
 //
 //		//altitude
 //		else if (decodeState == GGA_ALTITUDE)
 //		{
 //			if (byte == ',' && skipBytes == 0) //discard this byte
 //			{
 //				altitude[numBytes] = 0x00;
 //				skipBytes = 1;
 //				setParserState(GGA_ALTITUDE);
 //			}
 //			else if(byte == ',') //end of this data type
 //			{
 //				// If we actually have an altitude
 //				if(numBytes>0)
 //				{
 //					altitude[numBytes-1] = 0x00; // Cut off the "M" from the end of the altitude
 //				}
 //				else
 //				{
 //					altitude[numBytes] = 0x00;
 //				}
 //				setParserState(GGA_WGS84);
 //				numBytes = 0; //prep for next phase of parse
 //			}
 //			else //store data
 //			{
 //				altitude[numBytes] = byte; //adjust number of bytes to fit array
 //				numBytes++;
 //				setParserState(GGA_ALTITUDE);
 //			}
 //		}
 //
 //		//WGS84 Height
 //		else if (decodeState == GGA_WGS84)
 //		{
 //			if (byte == ',' && skipBytes == 0) //discard this byte
 //			{
 //				skipBytes = 1;
 //				setParserState(GGA_WGS84);
 //			}
 //			else if(byte == ',') //end of this data type
 //			{
 //				//wgs84Height[numBytes] = 0x00;
 //				setParserState(GGA_LAST_UPDATE);
 //				skipBytes = 0; //prep for next phase of parse
 //				numBytes = 0;
 //			}
 //			else //store data
 //			{
 //				//wgs84Height[numBytes] = byte; //adjust number of bytes to fit array
 //				numBytes++;
 //				setParserState(GGA_WGS84);
 //			}
 //		}
 //
 //		//last GGA DGPS update
 //		else if (decodeState == GGA_LAST_UPDATE)
 //		{
 //			if (byte == ',') //end of this data type
 //			{
 ////				lastUpdated[numBytes] = 0x00;
 //				setParserState(GGA_STATION_ID);
 //				numBytes = 0; //prep for next phase of parse
 //			}
 //			else //store data - this should be blank
 //			{
 ////				lastUpdated[numBytes] = byte; //adjust number of bytes to fit array
 //				numBytes++;
 //				setParserState(GGA_LAST_UPDATE);
 //			}
 //		}
 //
 //		//GGA DGPS station ID
 //		else if (decodeState == GGA_STATION_ID)
 //		{
 //			if (byte == ',' || byte == '*') //end of this data type
 //			{
 ////				stationID[numBytes] = 0x00;
 //				setParserState(GPS_CHECKSUM);
 //				numBytes = 0; //prep for next phase of parse
 //			}
 //			else //store data - this should be blank
 //			{
 ////				stationID[numBytes] = byte; //adjust number of bytes to fit array
 //				numBytes++;
 //				setParserState(GGA_STATION_ID);
 //			}
 //		}
 //		///parses GGA transmissions END
 //
 //		/// $GPRMC,hhmmss.ss,A,llll.ll,a,yyyyy.yy,a,x.x,x.x,ddmmyy,x.x,a*hh
 //		///parses RMC transmissions
 //		//time
 //		// emz: commented setter, GMC time better?
 //		else if(decodeState == RMC_TIME)
 //		{
 //			if (byte == ',') //end of this data type
 //			{
 //				//timestamp[numBytes] = 0x00;
 //				setParserState(RMC_VALIDITY);
 //				numBytes = 0; //prep for next phase of parse
 //			}
 //			else //store data
 //			{
 //				//timestamp[numBytes] = byte; //adjust number of bytes to fit array
 //				numBytes++;
 //				setParserState(RMC_TIME);
 //			}
 //		}
 //
 //		//validity
 //		// not needed? dupe gga
 //		else if(decodeState == RMC_VALIDITY)
 //		{
 //			if (byte == ',') //end of this data type
 //			{
 //				setParserState(RMC_LATITUDE);
 //				skipBytes = 0; //prep for next phase of parse
 //				numBytes = 0;
 //			}
 //			else //store data
 //			{
 //				//quality = byte;
 //				numBytes++;
 //				setParserState(RMC_VALIDITY);
 //			}
 //		}
 //
 //		//latitude RMC (we don't need this, commented out setter)
 //		else if(decodeState == RMC_LATITUDE)
 //		{
 //			if (byte == ',' && skipBytes == 0) //discard this byte
 //			{
 //				skipBytes = 1;
 //				setParserState(RMC_LATITUDE);
 //			}
 //			else if (byte == ',') //end of this data type
 //			{
 //				setParserState(RMC_LONGITUDE);
 //				skipBytes = 0; //prep for next phase of parse
 //				numBytes = 0;
 //			}
 //			else //store data
 //			{
 //				//latitude[numBytes]= byte; //adjust number of bytes to fit array
 //				numBytes++;
 //				setParserState(RMC_LATITUDE);
 //			}
 //		}
 //
 //		//longitude RMC (we don't need this, commented out setter)
 //		else if(decodeState == RMC_LONGITUDE)
 //		{
 //			if (byte == ',' && skipBytes == 0) //discard this byte
 //			{
 //				skipBytes = 1;
 //				setParserState(RMC_LONGITUDE);
 //			}
 //			else if (byte == ',') //end of this data type
 //			{
 //				setParserState(RMC_KNOTS);
 //				skipBytes = 0;
 //				numBytes = 0;
 //			}
 //			else //store data
 //			{
 //				//longitude[numBytes]= byte; //adjust number of bytes to fit array
 //				numBytes++;
 //				setParserState(RMC_LONGITUDE);
 //			}
 //		}
 //
 //		//knots
 //		else if(decodeState == RMC_KNOTS)
 //		{
 //			if (byte == ',') //end of this data type
 //			{
 //				knots[numBytes] = 0x00;
 //				setParserState(RMC_COURSE);
 //				numBytes = 0; //prep for next phase of parse
 //			}
 //			else //store data
 //			{
 //				setParserState(RMC_KNOTS);
 //				knots[numBytes]= byte; //adjust number of bytes to fit array
 //				numBytes++;
 //			}
 //		}
 //
 //		//course
 //		else if(decodeState == RMC_COURSE)
 //		{
 //			if (byte == ',') //end of this data type
 //			{
 //				course[numBytes] = 0x00;
 //				setParserState(RMC_DATE);
 //				numBytes = 0; //prep for next phase of parse
 //			}
 //			else //store data
 //			{
 //				setParserState(RMC_COURSE);
 //				course[numBytes] = byte; //adjust number of bytes to fit array
 //				numBytes++;
 //			}
 //		}
 //
 //		//date
 //		else if(decodeState == RMC_DATE)
 //		{
 //			if (byte == ',') //end of this data type
 //			{
 //				// Cut it off at day of month. Also has month and year if we ever need it.
 //				dayofmonth[2] = 0x00;
 //				setParserState(RMC_MAG_VARIATION);
 //				skipBytes = 0; //prep for next phase of parse
 //				numBytes = 0;
 //			}
 //			else //store data
 //			{
 //				setParserState(RMC_DATE);
 //				dayofmonth[numBytes] = byte; //adjust number of bytes to fit array
 //				numBytes++;
 //			}
 //		}
 //
 //		//magnetic variation
 //		else if(decodeState == RMC_MAG_VARIATION)
 //		{
 //			if (byte == '*') //end of this data type
 //			{
 //				//variation[numBytes] = 0x00;
 //				setParserState(GPS_CHECKSUM);
 //				numBytes = 0; //prep for next phase of parse
 //			}
 //			else //store data
 //			{
 //				setParserState(RMC_MAG_VARIATION);
 //				//variation[numBytes] = byte; //adjust number of bytes to fit array
 //				numBytes++;
 //			}
 //		}
 //		///parses RMC transmissions END
 //
 //
 //		//checksum
 //		else if (decodeState == GPS_CHECKSUM)
 //		{
 //			if (numBytes == 2) //end of data - terminating character ??
 //			{
 //				//checksum calculator for testing http://www.hhhh.org/wiml/proj/nmeaxor.html
 //				//TODO: must determine what to do with correct and incorrect messages
 //				receivedChecksum = checksum[0] + (checksum[1]*16);	//convert bytes to int
 //				if(calculatedChecksum==receivedChecksum)
 //				{
 //
 //				}
 //				else
 //				{
 //
 //				}
 //
 //				setParserState(INITIALIZE);
 //				numBytes = 0; //prep for next phase of parse
 //			}
 //			else //store data
 //			{
 //				setParserState(GPS_CHECKSUM);
 //				checksum[numBytes] = byte; //adjust number of bytes to fit array
 //				numBytes++;
 //			}
 //		}
 //		else {
 //			setParserState(INITIALIZE);
 //		}
 //
 //		if (decodeState!=GPS_CHECKSUM && decodeState!=INITIALIZE)	//want bytes between '$' and '*'
 //		{
 //			//input byte into running checksum
 //			XORbyteWithChecksum(byte);
 //		}
 //	}
 //
 void parse_gps_transmission(void)
+{
     uint16_t nmeaBufferDataPosition = NMEABUFFER_SIZE - uart_get_rxdma_handle()->Instance->CNDTR;
 	char byte;
 	while(nmeaBufferDataPosition != nmeaBufferParsePosition)
+	{
 	    // Pull byte off of the buffer
 	    byte = nmeaBuffer[nmeaBufferParsePosition];
 		if(decodeState == INITIALIZE) //start of transmission sentence
+		{
 			if(byte == '$')
+			{
 				setParserState(GET_TYPE);
 				numBytes = 0; //prep for next phases
 				skipBytes = 0;
 				calculatedChecksum = 0;
+			}
 			else
+			{
 				setParserState(INITIALIZE);
+			}
+		}
 		//parse transmission type
 		else if (decodeState == GET_TYPE)
+		{
 			tramsmissionType[numBytes] = byte;
 			numBytes++;
 			if(byte == ',') //end of this data type
+			{
 				tramsmissionType[5] = 0x00;
 				if (tramsmissionType[2] == 'G' &&
 				tramsmissionType[3] == 'G' &&
 				tramsmissionType[4] == 'A')
+				{
 					setParserState(GGA_TIME);
 					numBytes = 0;
+				}
 				else if (tramsmissionType[2] == 'R' &&
 				tramsmissionType[3] == 'M' &&
 				tramsmissionType[4] == 'C')
+				{
 					setParserState(RMC_TIME);
 					numBytes = 0;
+				}
 				else //this is an invalid transmission type
+				{
 					setParserState(INITIALIZE);
+				}
+			}
 			else {
 				// continue
 				setParserState(GET_TYPE);
+			}
+		}
 		///parses GGA transmissions START
 		/// $--GGA,hhmmss.ss,llll.ll,a,yyyyy.yy,a,x,xx,x.x,x.x,M,x.x,M,x.x,xxxx*xx
 		//timestamp
 		else if (decodeState == GGA_TIME)
+		{
 			if (byte == ',') //end of this data type
+			{
 				timestamp[4] = 0x00; // Cut off at 4 (no seconds) for APRS
 				setParserState(GGA_LATITUDE);
 				skipBytes = 0; //prep for next phase of parse
 				numBytes = 0;
+			}
 			else //store data
+			{
 				setParserState(GGA_TIME);
 				timestamp[numBytes] = byte; //byte; //adjust number of bytes to fit array
 				numBytes++;
+			}
+		}
 		//latitude
 		else if (decodeState == GGA_LATITUDE)
+		{
 			if (byte == ',' && skipBytes == 0) //discard this byte
+			{
 				skipBytes = 1;
 				setParserState(GGA_LATITUDE);
+			}
 			else if (byte == ',') //end of this data type
+			{
 				latitude[numBytes] = 0x00; // null terminate
 				setParserState(GGA_LONGITUDE);
 				skipBytes = 0; //prep for next phase of parse
 				numBytes = 0;
+			}
 			else //store data
+			{
 				latitude[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_LATITUDE);
+			}
+		}
 		//longitude
 		else if (decodeState == GGA_LONGITUDE)
+		{
 			if (byte == ',' && skipBytes == 0) //discard this byte
+			{
 				skipBytes = 1;
 				setParserState(GGA_LONGITUDE);
+			}
 			else if (byte == ',') //end of this data type
+			{
 				longitude[numBytes] = 0x00;
 				setParserState(GGA_QUALITY);
 				numBytes = 0; //prep for next phase of parse
 				skipBytes = 0;
+			}
 			else //store data
+			{
 				longitude[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_LONGITUDE);
+			}
+		}
 		//GGA quality
 		else if (decodeState == GGA_QUALITY)
+		{
 			if (byte == ',') //end of this data type
+			{
 				setParserState(GGA_SATELLITES);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				quality = byte; //maybe reset if invalid data ??
 				setParserState(GGA_QUALITY);
+			}
+		}
 		//number of satellites
 		else if (decodeState == GGA_SATELLITES)
+		{
 			if (byte == ',') //end of this data type
+			{
 				numSatellites[numBytes] = 0x00;
 				setParserState(GGA_HDOP);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				numSatellites[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_SATELLITES);
+			}
+		}
 		//HDOP
 		else if (decodeState == GGA_HDOP)
+		{
 			if (byte == ',' ) //end of this data type
+			{
 				hdop[numBytes] = 0x00;
 				setParserState(GGA_ALTITUDE);
 				numBytes = 0; //prep for next phase of parse
 				skipBytes = 0;
+			}
 			else //store data
+			{
 				hdop[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_HDOP);
+			}
+		}
 		//altitude
 		else if (decodeState == GGA_ALTITUDE)
+		{
 			if (byte == ',' && skipBytes == 0) //discard this byte
+			{
 				altitude[numBytes] = 0x00;
 				skipBytes = 1;
 				setParserState(GGA_ALTITUDE);
+			}
 			else if(byte == ',') //end of this data type
+			{
 				// If we actually have an altitude
 				if(numBytes>0)
+				{
 					altitude[numBytes-1] = 0x00; // Cut off the "M" from the end of the altitude
+				}
 				else
+				{
 					altitude[numBytes] = 0x00;
+				}
 				setParserState(GGA_WGS84);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				altitude[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_ALTITUDE);
+			}
+		}
 		//WGS84 Height
 		else if (decodeState == GGA_WGS84)
+		{
 			if (byte == ',' && skipBytes == 0) //discard this byte
+			{
 				skipBytes = 1;
 				setParserState(GGA_WGS84);
+			}
 			else if(byte == ',') //end of this data type
+			{
 				//wgs84Height[numBytes] = 0x00;
 				setParserState(GGA_LAST_UPDATE);
 				skipBytes = 0; //prep for next phase of parse
 				numBytes = 0;
+			}
 			else //store data
+			{
 				//wgs84Height[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_WGS84);
+			}
+		}
 		//last GGA DGPS update
 		else if (decodeState == GGA_LAST_UPDATE)
+		{
 			if (byte == ',') //end of this data type
+			{
 //				lastUpdated[numBytes] = 0x00;
 				setParserState(GGA_STATION_ID);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data - this should be blank
+			{
 //				lastUpdated[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_LAST_UPDATE);
+			}
+		}
 		//GGA DGPS station ID
 		else if (decodeState == GGA_STATION_ID)
+		{
 			if (byte == ',' || byte == '*') //end of this data type
+			{
 //				stationID[numBytes] = 0x00;
 				setParserState(GPS_CHECKSUM);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data - this should be blank
+			{
 //				stationID[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_STATION_ID);
+			}
+		}
 		///parses GGA transmissions END
 		/// $GPRMC,hhmmss.ss,A,llll.ll,a,yyyyy.yy,a,x.x,x.x,ddmmyy,x.x,a*hh
 		///parses RMC transmissions
 		//time
 		// emz: commented setter, GMC time better?
 		else if(decodeState == RMC_TIME)
+		{
 			if (byte == ',') //end of this data type
+			{
 				//timestamp[numBytes] = 0x00;
 				setParserState(RMC_VALIDITY);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				//timestamp[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(RMC_TIME);
+			}
+		}
 		//validity
 		// not needed? dupe gga
 		else if(decodeState == RMC_VALIDITY)
+		{
 			if (byte == ',') //end of this data type
+			{
 				setParserState(RMC_LATITUDE);
 				skipBytes = 0; //prep for next phase of parse
 				numBytes = 0;
+			}
 			else //store data
+			{
 				//quality = byte;
 				numBytes++;
 				setParserState(RMC_VALIDITY);
+			}
+		}
 		//latitude RMC (we don't need this, commented out setter)
 		else if(decodeState == RMC_LATITUDE)
+		{
 			if (byte == ',' && skipBytes == 0) //discard this byte
+			{
 				skipBytes = 1;
 				setParserState(RMC_LATITUDE);
+			}
 			else if (byte == ',') //end of this data type
+			{
 				setParserState(RMC_LONGITUDE);
 				skipBytes = 0; //prep for next phase of parse
 				numBytes = 0;
+			}
 			else //store data
+			{
 				//latitude[numBytes]= byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(RMC_LATITUDE);
+			}
+		}
 		//longitude RMC (we don't need this, commented out setter)
 		else if(decodeState == RMC_LONGITUDE)
+		{
 			if (byte == ',' && skipBytes == 0) //discard this byte
+			{
 				skipBytes = 1;
 				setParserState(RMC_LONGITUDE);
+			}
 			else if (byte == ',') //end of this data type
+			{
 				setParserState(RMC_KNOTS);
 				skipBytes = 0;
 				numBytes = 0;
+			}
 			else //store data
+			{
 				//longitude[numBytes]= byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(RMC_LONGITUDE);
+			}
+		}
 		//knots
 		else if(decodeState == RMC_KNOTS)
+		{
 			if (byte == ',') //end of this data type
+			{
 				knots[numBytes] = 0x00;
 				setParserState(RMC_COURSE);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				setParserState(RMC_KNOTS);
 				knots[numBytes]= byte; //adjust number of bytes to fit array
 				numBytes++;
+			}
+		}
 		//course
 		else if(decodeState == RMC_COURSE)
+		{
 			if (byte == ',') //end of this data type
+			{
 				course[numBytes] = 0x00;
 				setParserState(RMC_DATE);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				setParserState(RMC_COURSE);
 				course[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
+			}
+		}
 		//date
 		else if(decodeState == RMC_DATE)
+		{
 			if (byte == ',') //end of this data type
+			{
 				// Cut it off at day of month. Also has month and year if we ever need it.
 				dayofmonth[2] = 0x00;
 				setParserState(RMC_MAG_VARIATION);
 				skipBytes = 0; //prep for next phase of parse
 				numBytes = 0;
+			}
 			else //store data
+			{
 				setParserState(RMC_DATE);
 				dayofmonth[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
+			}
+		}
 		//magnetic variation
 		else if(decodeState == RMC_MAG_VARIATION)
+		{
 			if (byte == '*') //end of this data type
+			{
 				//variation[numBytes] = 0x00;
 				setParserState(GPS_CHECKSUM);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				setParserState(RMC_MAG_VARIATION);
 				//variation[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
+			}
+		}
 		///parses RMC transmissions END
 		//checksum
 		else if (decodeState == GPS_CHECKSUM)
+		{
 			if (numBytes == 2) //end of data - terminating character ??
+			{
 				//checksum calculator for testing http://www.hhhh.org/wiml/proj/nmeaxor.html
 				//TODO: must determine what to do with correct and incorrect messages
 				receivedChecksum = checksum[0] + (checksum[1]*16);	//convert bytes to int
 				if(calculatedChecksum==receivedChecksum)
+				{
+				}
 				else
+				{
+				}
 				setParserState(INITIALIZE);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				setParserState(GPS_CHECKSUM);
 				checksum[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
+			}
+		}
 		else {
 			setParserState(INITIALIZE);
+		}
 		if (decodeState!=GPS_CHECKSUM && decodeState!=INITIALIZE)	//want bytes between '$' and '*'
+		{
 			//input byte into running checksum
 			XORbyteWithChecksum(byte);
+		}
+	}
+}
 void XORbyteWithChecksum(uint8_t byte)
+{
 	calculatedChecksum ^= (int)byte; //this may need to be re-coded
+}
 // vim:softtabstop=4 shiftwidth=4 expandtab

src/main.c

➞

Show inline comments

@@ @@ -5,217 +5,216 @@ @@
 #include "stm32f0xx_hal.h"
 #include "si5351.h"
 #include "jtencode.h"
 #include "adc.h"
 #include "i2c.h"
 #include "usart.h"
 #include "gpio.h"
 #include "gps.h"
 #define WSPR_DEFAULT_FREQ 10140100UL
 #define WSPR_TONE_SPACING 146 // ~1.46 Hz
 #define WSPR_CTC 10672 // CTC value for WSPR
 // Private functions
 void sysclk_init(void);
 void enter_sleep(void);
 void enter_deepsleep(void);
 // Test stuff
 char call[7] = "KD8TDF";
 char loc[5] = "EN72";
 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;
 // Bring up TCXO and oscillator IC
 void encode_wspr(void)
+{
     HAL_GPIO_WritePin(OSC_NOTEN, 0);
     HAL_GPIO_WritePin(TCXO_EN, 1);
     HAL_Delay(100);
     // Bring up the chip
     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_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);
     // Encode message to transmit
     wspr_encode(call, loc, dbm, tx_buffer);
     // Key transmitter
     si5351_output_enable(SI5351_CLK0, 1);
     // Loop through and transmit symbols TODO: Do this from an ISR or ISR-triggered main loop function call (optimal)
     uint8_t i;
     for(i=0; i<symbol_count; i++)
+    {
         uint32_t freq2 = (freq * 100) + (tx_buffer[i] * tone_spacing);
         si5351_set_freq(freq2, 0, SI5351_CLK0);
         HAL_GPIO_TogglePin(LED_BLUE);
         proceed = 0;
         while(!proceed);
+    }
     // Disable transmitter
     si5351_output_enable(SI5351_CLK0, 0);
     HAL_GPIO_WritePin(OSC_NOTEN, 1);
     HAL_GPIO_WritePin(TCXO_EN, 0);
+}
 TIM_HandleTypeDef htim1;
 int main(void)
+{
     HAL_Init();
     sysclk_init();
     gpio_init();
     adc_init();
     i2c_init();
     gps_init();
     jtencode_init();
+//    jtencode_init();
     HAL_Delay(300);
     // Turn GPS on
     HAL_GPIO_WritePin(GPS_NOTEN, 0);
     // Disable ICs
     HAL_GPIO_WritePin(OSC_NOTEN, 1);
     HAL_GPIO_WritePin(TCXO_EN, 0);
     HAL_GPIO_TogglePin(LED_BLUE);
     // Start timer for WSPR
     __TIM1_CLK_ENABLE();
     htim1.Instance = TIM1;
     htim1.Init.Prescaler = 512; // gives 64uS ticks from 8MHz ahbclk
     htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
     htim1.Init.Period = ctc; // Count up to this value (how many 64uS ticks per symbol)
     htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
     htim1.Init.RepetitionCounter = 0;
     HAL_TIM_Base_Init(&htim1);
     HAL_TIM_Base_Start_IT(&htim1);
     HAL_NVIC_SetPriority(TIM1_BRK_UP_TRG_COM_IRQn, 0, 0);
     HAL_NVIC_EnableIRQ(TIM1_BRK_UP_TRG_COM_IRQn);
     uint32_t led_timer = HAL_GetTick();
     uint32_t last_gps  = HAL_GetTick();
     uint32_t last_wspr  = 0xfffff; // start immediately.
     HAL_GPIO_TogglePin(LED_BLUE);
     HAL_Delay(100);
     HAL_GPIO_TogglePin(LED_BLUE);
     HAL_Delay(100);
     HAL_GPIO_TogglePin(LED_BLUE);
     HAL_Delay(100);
     HAL_GPIO_TogglePin(LED_BLUE);
     HAL_Delay(100);
     while (1)
+    {
         parse_gps_transmission();
         if(HAL_GetTick() - last_wspr > 120000)
+        {
             encode_wspr();
+            //encode_wspr();
             last_wspr = HAL_GetTick();
+        }
         if(HAL_GetTick() - led_timer > 100)
+        {
             HAL_GPIO_TogglePin(LED_BLUE);
             led_timer = HAL_GetTick();
+        }
-        if(HAL_GetTick() - last_gps > 3000)
+        if(HAL_GetTick() - last_gps > 10)
+        {
-//            gps_process();
+            parse_gps_transmission();
             last_gps = HAL_GetTick();
+        }
         //enter_sleep();
+    }
+}
 void enter_sleep(void)
+{
     //HAL_SuspendTick();
     HAL_TIM_Base_Stop_IT(&htim1);
     HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);
     HAL_TIM_Base_Start_IT(&htim1);
     //HAL_ResumeTick();
+}
 void enter_deepsleep(void)
+{
     // Request to enter STOP mode with regulator in low power mode
     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     // After wake-up from STOP reconfigure the PLL
     sysclk_init();
+}
 // Initialize system clocks
 void sysclk_init(void)
+{
     RCC_OscInitTypeDef RCC_OscInitStruct;
     RCC_ClkInitTypeDef RCC_ClkInitStruct;
     RCC_PeriphCLKInitTypeDef PeriphClkInit;
     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI|RCC_OSCILLATORTYPE_HSI14;
     RCC_OscInitStruct.HSIState = RCC_HSI_ON;
     RCC_OscInitStruct.HSI14State = RCC_HSI14_ON;
     RCC_OscInitStruct.HSICalibrationValue = 16;
     RCC_OscInitStruct.HSI14CalibrationValue = 16;
     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
     HAL_RCC_OscConfig(&RCC_OscInitStruct);
     RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                                 |RCC_CLOCKTYPE_PCLK1;
     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
     RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
     HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);
     PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_I2C1;
     PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_SYSCLK; //RCC_USART1CLKSOURCE_PCLK1;
     PeriphClkInit.I2c1ClockSelection = RCC_I2C1CLKSOURCE_SYSCLK;
     HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit);
     HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
     HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
     __SYSCFG_CLK_ENABLE();
     // SysTick_IRQn interrupt configuration
     HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
+}

0 comments (0 inline, 0 general)