FeatherHAB/wsprhab Changeset - dd3b59fcb7a7

Changeset - dd3b59fcb7a7

Parent rev.

Child rev.

[Not reviewed]

default

0 5 0

Ethan Zonca - 10 years ago 2016-04-06 23:10:46
ez@ethanzonca.com

Added code to handle GPS fix acquisition. Hot reaq time is around 3-4s. WSPR currently disabled.

5 files changed with 141 insertions and 39 deletions:

inc/gps.h

inc/usart.h

src/gps.c

src/main.c

src/usart.c

0 comments (0 inline, 0 general)

inc/gps.h

➞

Show inline comments

 /*
  * Master Firmware: NMEA Parser
+ *
  * This file is part of OpenTrack.
+ *
  * OpenTrack is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
+ *
  * OpenTrack is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Affero General Public License for more details.
+ *
  * You should have received a copy of the GNU Affero General Public License
  * along with OpenTrack. If not, see <http://www.gnu.org/licenses/>.
+ *
  * Ethan Zonca
  * Matthew Kanning
  * Kyle Ripperger
  * Matthew Kroening
+ *
  */
 #ifndef GPS_H_
 #define GPS_H_
 #include <stdint.h>
 // Hardware config
 /*#define GPS_USART USART1
 #define GPS_IRQ NVIC_USART1_IRQ
 #define GPS_TX_PORT GPIOB
 #define GPS_TX_PIN GPIO6
 #define GPS_TX_AF GPIO_AF0
 // Duration before GPS fix is declared stale
 #define GPS_STALEFIX_MS 60000
 #define GPS_RX_PORT GPIOB
 #define GPS_RX_PIN GPIO7
 #define GPS_RX_AF GPIO_AF0
 enum gps_state
+{
     GPS_STATE_ACQUIRING = 0,
     GPS_STATE_FRESHFIX,
     GPS_STATE_STALEFIX,
     GPS_STATE_NOFIX
 };
 #define GPS_ONOFF_PORT GPIOA
 #define GPS_ONOFF_PIN GPIO1
 #define GPS_ONOFF GPS_ONOFF_PORT, GPS_ONOFF_PIN
 */
 // Messages (REMOVEME?)
 #define GGA_MESSAGE
 #define RMC_MESSAGE
 #define UKN_MESSAGE
 void gps_poweron(void);
 void gps_poweroff(void);
 void gps_init(void);
 void gps_sendubx(uint8_t* data, uint8_t size);
 char* get_longitudeTrimmed(void);
 char* get_longitudeLSBs(void);
 char* get_latitudeTrimmed(void);
 char* get_latitudeLSBs(void);
 char* get_timestamp(void);
 char* get_gpsaltitude(void);
 char* get_speedKnots(void);
 char* get_course(void);
 char* get_hdop(void);
 uint16_t get_hdop_int_tenths(void);
 char* get_sv(void);
 char* get_dayofmonth(void);
 uint8_t gps_hasfix(void);
 void gps_process(void);
 uint8_t gps_getstate(void);
 void gps_acquirefix(void);
 void parse_gps_transmission(void);
 void XORbyteWithChecksum(uint8_t byte);
 #endif /* GPS_H_ */

inc/usart.h

➞

Show inline comments

 #ifndef __usart_H
 #define __usart_H
 #include "stm32f0xx_hal.h"
 void uart_init(void);
 void uart_deinit(void);
 UART_HandleTypeDef* uart_gethandle(void);
 DMA_HandleTypeDef* uart_get_txdma_handle(void);
 DMA_HandleTypeDef* uart_get_rxdma_handle(void);
 #endif

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 "gpio.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;
 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);
     HAL_GPIO_WritePin(GPS_NOTEN, 0);
     uart_init();
     // Begin DMA reception
     HAL_UART_Receive_DMA(uart_gethandle(), nmeaBuffer, NMEABUFFER_SIZE);
+}
 void gps_poweroff(void)
+{
     // NOTE: pchannel
     //gpio_set(GPS_ONOFF);
     uart_deinit();
     HAL_GPIO_WritePin(GPS_NOTEN, 1);
+}
 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;
+}
 uint16_t get_hdop_int_tenths(void)
+{
     // If only one digit before decimal
     if(hdop[1] == '.')
+    {
         return (hdop[0]-0x30)*10 + (hdop[2]-0x30);
+    }
     // Return normal hdop
     return (hdop[0]-0x30)*100 + (hdop[1]-0x30)*10 + (hdop[2]-0x30);
+}
 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();
+   // done in poweron uart_init();
     // Begin DMA reception
     HAL_UART_Receive_DMA(uart_gethandle(), nmeaBuffer, NMEABUFFER_SIZE);
     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;
+}
 static uint8_t gps_acquiring = 0;
 static uint32_t gps_lastfix_time = 0;
 //// MKa GPS transmission parser START
 void gps_process(void)
+{
     // If we're trying to acquire a GPS fix
     if(gps_acquiring)
+    {
         // Process incoming bytes
         parse_gps_transmission();
         // If fix acquired
         uint16_t hdop_int = get_hdop_int_tenths();
         if(hdop_int < 50 && hdop_int > 0)
+        {
             // Set RTC to GPS time
             // Record time of fix (TODO: don't use ticks if sleeping... use RTC time)
             gps_lastfix_time = HAL_GetTick();
             // Turn off GPS module
             gps_poweroff();
             // Invalidate HDOP
             hdop[0] = '9';
             // Go to idle state
             gps_acquiring = 0;
+        }
         else
+        {
             // if too much time has elapsed, set an error flag and go idle
             //gps_acquiring = 0;
+        }
+    }
+}
 void gps_acquirefix(void)
+{
     gps_poweron();
     // Wait for fix
     gps_acquiring = 1;
+}
 uint8_t gps_getstate(void)
+{
     if(gps_acquiring)
         return GPS_STATE_ACQUIRING;
     else if(gps_lastfix_time == 0)
         return GPS_STATE_NOFIX;
     else if(HAL_GetTick() - gps_lastfix_time < GPS_STALEFIX_MS)
         return GPS_STATE_FRESHFIX;
     else
         return GPS_STATE_STALEFIX;
+}
 // MKa GPS transmission parser START
 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++;
+			}

src/main.c

➞

Show inline comments

 //
 // WSPRHAB: Minimal high-altitude balloon tracker with WSPR telemetry
 //
 #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();
     HAL_Delay(300);
     // Turn GPS on
     HAL_GPIO_WritePin(GPS_NOTEN, 0);
     //gps_poweroff();
     // 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  = HAL_GetTick(); //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);
     uint8_t lastMinute = 0;
     uint16_t blink_rate = 250;
     while (1)
+    {
         // TODO: Trigger this when RTC thinks its time to go
         if(HAL_GetTick() - last_wspr > 500)
+        {
             if(get_hdop()[0] == '9' && get_hdop()[1] == '9')
                 blink_rate = 250;
             else
                 blink_rate = 100;
             volatile uint8_t minute = get_timestamp()[3] - 0x30;
             // If last minute was odd and this minute is even (transition)
             if(lastMinute%2 == 1 && minute%2 == 0)
             switch(gps_getstate())
+            {
                 // Wait until the first second of the minute
                 HAL_Delay(1000);
                 encode_wspr();
                 case GPS_STATE_ACQUIRING:
                     blink_rate = 250;
                     break;
                 case GPS_STATE_FRESHFIX:
                     blink_rate = 50;
                     break;
                 case GPS_STATE_STALEFIX:
                 case GPS_STATE_NOFIX:
                     gps_acquirefix();
                     blink_rate = 500;
                     break;
+            }
             lastMinute = minute;
             // EMZ TODO: this needs to trigger off of RTC minute, not GPS minute
 //            volatile uint8_t minute = get_timestamp()[3] - 0x30;
 //
 //            // If last minute was odd and this minute is even (transition)
 //            if(lastMinute%2 == 1 && minute%2 == 0)
 //            {
 //                // Wait until the first second of the minute
 //                HAL_Delay(1000);
 //                encode_wspr();
 //            }
 //            lastMinute = minute;
             last_wspr = HAL_GetTick();
+        }
         if(HAL_GetTick() - led_timer > blink_rate)
+        {
             HAL_GPIO_TogglePin(LED_BLUE);
             led_timer = HAL_GetTick();
+        }
         if(HAL_GetTick() - last_gps > 10)
+        {
-            parse_gps_transmission();
+            gps_process();
             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);
+}

src/usart.c

➞

Show inline comments

 #include "stm32f0xx_hal.h"
 #include "usart.h"
 #include "config.h"
 #include "gpio.h"
 UART_HandleTypeDef huart1;
 DMA_HandleTypeDef hdma_usart1_rx;
 DMA_HandleTypeDef hdma_usart1_tx;
 uint8_t uart_initted = 0;
 void uart_init(void)
+{
     __GPIOB_CLK_ENABLE();
     __HAL_RCC_USART1_CLK_ENABLE();
     GPIO_InitTypeDef GPIO_InitStruct;
     // Init gpio pins for uart
     GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7;
     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
     GPIO_InitStruct.Pull = GPIO_NOPULL; //GPIO_PULLUP;
     GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
     GPIO_InitStruct.Alternate = GPIO_AF0_USART1;
     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
     // Init UART periph
     huart1.Instance = USART1;
     huart1.Init.BaudRate = 9600;
     huart1.Init.WordLength = UART_WORDLENGTH_8B;
     huart1.Init.StopBits = UART_STOPBITS_1;
     huart1.Init.Parity = UART_PARITY_NONE;
     huart1.Init.Mode = UART_MODE_TX_RX;
     huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
     huart1.Init.OverSampling = UART_OVERSAMPLING_16;
     huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
     huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_RXOVERRUNDISABLE_INIT|UART_ADVFEATURE_DMADISABLEONERROR_INIT;
     huart1.AdvancedInit.OverrunDisable = UART_ADVFEATURE_OVERRUN_DISABLE;
     huart1.AdvancedInit.DMADisableonRxError = UART_ADVFEATURE_DMA_DISABLEONRXERROR;
     HAL_UART_Init(&huart1);
     __DMA1_CLK_ENABLE();
   // Init UART DMA
     hdma_usart1_rx.Instance = DMA1_Channel3;
     hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
     hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
     hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
     hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
     hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
     hdma_usart1_rx.Init.Mode = DMA_CIRCULAR;
     hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW;
     HAL_DMA_Init(&hdma_usart1_rx);
     __HAL_LINKDMA(&huart1,hdmarx,hdma_usart1_rx);
     hdma_usart1_tx.Instance = DMA1_Channel2;
     hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
     hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
     hdma_usart1_tx.Init.MemInc = DMA_MINC_DISABLE;
     hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
     hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
     hdma_usart1_tx.Init.Mode = DMA_NORMAL;
     hdma_usart1_tx.Init.Priority = DMA_PRIORITY_LOW;
     HAL_DMA_Init(&hdma_usart1_tx);
     __HAL_LINKDMA(&huart1,hdmatx,hdma_usart1_tx);
 //    HAL_NVIC_SetPriority(DMA1_Channel2_3_IRQn, 0, 0);
 //    HAL_NVIC_EnableIRQ(DMA1_Channel2_3_IRQn);
     HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);
     //HAL_NVIC_EnableIRQ(USART1_IRQn);
     HAL_NVIC_DisableIRQ(USART1_IRQn);
     uart_initted = 1;
+}
 void uart_deinit(void)
+{
     if(uart_initted == 1)
+    {
         HAL_DMA_DeInit(&hdma_usart1_rx);
         HAL_DMA_DeInit(&hdma_usart1_tx);
         HAL_UART_DeInit(&huart1);
         uart_initted = 0;
+    }
+}
 UART_HandleTypeDef* uart_gethandle(void)
+{
     return &huart1;
+}
 DMA_HandleTypeDef* uart_get_txdma_handle(void)
+{
     return &hdma_usart1_tx;
+}
 DMA_HandleTypeDef* uart_get_rxdma_handle(void)
+{
     return &hdma_usart1_rx;
+}

0 comments (0 inline, 0 general)