WebSVN - Projects - Blame - /FollowMe/ubx.c

Rev	Author	Line No.	Line
231	killagreg	1	#include <inttypes.h>
		2	#include "ubx.h"
274	killagreg	3	#include "timer0.h"
303	joko	4	#include "uart0.h"
231	killagreg	5
		6
274	killagreg	7	// ------------------------------------------------------------------------------------------------
		8	// defines
231	killagreg	9
274	killagreg	10	#define DAYS_FROM_JAN01YEAR0001_TO_JAN6_1980 722819 // the year 0 does not exist!
		11	#define DAYS_PER_YEAR 365
		12	#define DAYS_PER_LEAPYEAR 366
		13	#define DAYS_PER_4YEARS 1461 //((3 * DAYS_PER_YEAR) + DAYS_PER_LEAPYEAR) // years dividable by 4 are leap years
		14	#define DAYS_PER_100YEARS 36524 //((25 * DAYS_PER_4YEARS) - 1) // years dividable by 100 are no leap years
		15	#define DAYS_PER_400YEARS 146097 //((4 * DAYS_PER_100YEARS) + 1L) // but years dividable by 400 are leap years
		16	#define SECONDS_PER_MINUTE 60
		17	#define MINUTES_PER_HOUR 60
		18	#define HOURS_PER_DAY 24
		19	#define DAYS_PER_WEEK 7
		20	#define SECONDS_PER_HOUR 3600 //(SECONDS_PER_MINUTE * MINUTES_PER_HOUR)
		21	#define SECONDS_PER_DAY 86400 //(SECONDS_PER_HOUR * HOURS_PER_DAY)
		22	#define SECONDS_PER_WEEK 604800 //(SECONDS_PER_DAY * DAYS_PER_WEEK)
		23
		24	// days per month in normal and leap years
		25	const uint32_t Leap[ 13 ] = { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 };
		26	const uint32_t Normal[ 13 ] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
		27
		28	#define LEAP_SECONDS_FROM_1980 15 // the last one was on the Dec 31th 2008
		29
		30	// message sync bytes
		31	#define UBX_SYNC1_CHAR 0xB5
		32	#define UBX_SYNC2_CHAR 0x62
		33	// protocoll identifier
231	killagreg	34	#define UBX_CLASS_NAV 0x01
274	killagreg	35	// message id
231	killagreg	36	#define UBX_ID_POSLLH 0x02
		37	#define UBX_ID_SOL 0x06
		38	#define UBX_ID_VELNED 0x12
		39
274	killagreg	40	// ------------------------------------------------------------------------------------------------
		41	// typedefs
231	killagreg	42
		43
274	killagreg	44	// ubx parser state
		45	typedef enum
		46	{
		47	UBXSTATE_IDLE,
		48	UBXSTATE_SYNC1,
		49	UBXSTATE_SYNC2,
		50	UBXSTATE_CLASS,
		51	UBXSTATE_LEN1,
		52	UBXSTATE_LEN2,
		53	UBXSTATE_DATA,
		54	UBXSTATE_CKA,
		55	UBXSTATE_CKB
		56	} ubxState_t;
231	killagreg	57
274	killagreg	58	typedef struct
		59	{
		60	uint32_t itow; // ms GPS Millisecond Time of Week
		61	int32_t frac; // ns remainder of rounded ms above
		62	int16_t week; // GPS week
		63	uint8_t GPSfix; // GPSfix Type, range 0..6
		64	uint8_t Flags; // Navigation Status Flags
		65	int32_t ECEF_X; // cm ECEF X coordinate
		66	int32_t ECEF_Y; // cm ECEF Y coordinate
		67	int32_t ECEF_Z; // cm ECEF Z coordinate
		68	int32_t PAcc; // cm 3D Position Accuracy Estimate
		69	int32_t ECEFVX; // cm/s ECEF X velocity
		70	int32_t ECEFVY; // cm/s ECEF Y velocity
		71	int32_t ECEFVZ; // cm/s ECEF Z velocity
		72	uint32_t SAcc; // cm/s Speed Accuracy Estimate
		73	uint16_t PDOP; // 0.01 Position DOP
		74	uint8_t res1; // reserved
		75	uint8_t numSV; // Number of SVs used in navigation solution
		76	uint32_t res2; // reserved
		77	uint8_t Status; // invalid/newdata/processed
		78	} __attribute__((packed)) ubx_nav_sol_t;
231	killagreg	79
		80
274	killagreg	81	typedef struct
		82	{
		83	uint32_t itow; // ms GPS Millisecond Time of Week
		84	int32_t VEL_N; // cm/s NED north velocity
		85	int32_t VEL_E; // cm/s NED east velocity
		86	int32_t VEL_D; // cm/s NED down velocity
		87	int32_t Speed; // cm/s Speed (3-D)
		88	int32_t GSpeed; // cm/s Ground Speed (2-D)
		89	int32_t Heading; // 1e-05 deg Heading 2-D
		90	uint32_t SAcc; // cm/s Speed Accuracy Estimate
		91	uint32_t CAcc; // deg Course / Heading Accuracy Estimate
		92	uint8_t Status; // invalid/newdata/processed
		93	} __attribute__((packed)) ubx_nav_velned_t;
231	killagreg	94
274	killagreg	95	typedef struct
231	killagreg	96	{
274	killagreg	97	uint32_t itow; // ms GPS Millisecond Time of Week
		98	int32_t LON; // 1e-07 deg Longitude
		99	int32_t LAT; // 1e-07 deg Latitude
		100	int32_t HEIGHT; // mm Height above Ellipsoid
		101	int32_t HMSL; // mm Height above mean sea level
		102	uint32_t Hacc; // mm Horizontal Accuracy Estimate
		103	uint32_t Vacc; // mm Vertical Accuracy Estimate
		104	uint8_t Status; // invalid/newdata/processed
		105	} __attribute__((packed)) ubx_nav_posllh_t;
231	killagreg	106
274	killagreg	107
		108
		109	//------------------------------------------------------------------------------------
		110	// global variables
		111
		112	// local buffers for the incomming ubx messages
		113	volatile ubx_nav_sol_t UbxSol = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, INVALID};
		114	volatile ubx_nav_posllh_t UbxPosLlh = {0,0,0,0,0,0,0, INVALID};
		115	volatile ubx_nav_velned_t UbxVelNed = {0,0,0,0,0,0,0,0,0, INVALID};
		116
		117	uint16_t CheckGPSOkay = 0;
		118
		119	// shared buffer
		120	gps_data_t GPSData = {{0,0,0,INVALID},0,0,0,0,0,0,0, INVALID};
		121
		122	//------------------------------------------------------------------------------------
		123	// functions
		124
		125	uint8_t IsLeapYear(uint16_t year)
		126	{
		127	if((year%400 == 0) \|\| ( (year%4 == 0) && (year%100 != 0) ) ) return 1;
		128	else return 0;
		129	}
		130
		131	/********************************************************/
		132	/* Calculates the UTC Time from the GPS week and tow */
		133	/********************************************************/
		134	void SetGPSTime(DateTime_t * pTimeStruct)
		135	{
		136	uint32_t Days, Seconds, Week;
		137	uint16_t YearPart;
		138	uint32_t * MonthDayTab = 0;
		139	uint8_t i;
		140
		141
		142
		143	// if GPS data show valid time data
		144	if((UbxSol.Status != INVALID) && (UbxSol.Flags & FLAG_WKNSET) && (UbxSol.Flags & FLAG_TOWSET) )
231	killagreg	145	{
274	killagreg	146	Seconds = UbxSol.itow / 1000L;
		147	Week = (uint32_t)UbxSol.week;
		148	// correct leap seconds since 1980
		149	if(Seconds < LEAP_SECONDS_FROM_1980)
231	killagreg	150	{
274	killagreg	151	Week--;
		152	Seconds = SECONDS_PER_WEEK - LEAP_SECONDS_FROM_1980 + Seconds;
		153	}
		154	else Seconds -= LEAP_SECONDS_FROM_1980;
231	killagreg	155
274	killagreg	156	Days = DAYS_FROM_JAN01YEAR0001_TO_JAN6_1980;
		157	Days += (Week * DAYS_PER_WEEK);
		158	Days += Seconds / SECONDS_PER_DAY; // seperate days from GPS seconds of week
231	killagreg	159
274	killagreg	160	pTimeStruct->Year = 1;
		161	YearPart = (uint16_t)(Days / DAYS_PER_400YEARS);
		162	pTimeStruct->Year += YearPart * 400;
		163	Days = Days % DAYS_PER_400YEARS;
		164	YearPart = (uint16_t)(Days / DAYS_PER_100YEARS);
		165	pTimeStruct->Year += YearPart * 100;
		166	Days = Days % DAYS_PER_100YEARS;
		167	YearPart = (uint16_t)(Days / DAYS_PER_4YEARS);
		168	pTimeStruct->Year += YearPart * 4;
		169	Days = Days % DAYS_PER_4YEARS;
		170	if(Days < (3* DAYS_PER_YEAR)) YearPart = (uint16_t)(Days / DAYS_PER_YEAR);
		171	else YearPart = 3;
		172	pTimeStruct->Year += YearPart;
		173	// calculate remaining days of year
		174	Days -= (uint32_t)(YearPart * DAYS_PER_YEAR);
		175	Days += 1;
		176	// check if current year is a leap year
		177	if(IsLeapYear(pTimeStruct->Year)) MonthDayTab = (uint32_t*)Leap;
		178	else MonthDayTab = (uint32_t*)Normal;
		179	// seperate month and day from days of year
		180	for ( i = 0; i < 12; i++ )
		181	{
		182	if ( (MonthDayTab[i]< Days) && (Days <= MonthDayTab[i+1]) )
		183	{
		184	pTimeStruct->Month = i+1;
		185	pTimeStruct->Day = Days - MonthDayTab[i];
		186	i = 12;
		187	}
231	killagreg	188	}
274	killagreg	189	Seconds = Seconds % SECONDS_PER_DAY; // remaining seconds of current day
		190	pTimeStruct->Hour = (uint8_t)(Seconds / SECONDS_PER_HOUR);
		191	Seconds = Seconds % SECONDS_PER_HOUR; // remaining seconds of current hour
		192	pTimeStruct->Min = (uint8_t)(Seconds / SECONDS_PER_MINUTE);
		193	Seconds = Seconds % SECONDS_PER_MINUTE; // remaining seconds of current minute
		194	pTimeStruct->Sec = (uint8_t)(Seconds);
		195	pTimeStruct->mSec = (uint16_t)(UbxSol.itow % 1000L);
		196	pTimeStruct->Valid = 1;
231	killagreg	197	}
274	killagreg	198	else
		199	{
		200	pTimeStruct->Valid = 0;
		201	}
		202	}
231	killagreg	203
		204
274	killagreg	205
		206	/********************************************************/
		207	/* Initialize UBX Parser */
		208	/********************************************************/
		209	void UBX_Init(void)
		210	{
		211	// mark msg buffers invalid
		212	UbxSol.Status = INVALID;
		213	UbxPosLlh.Status = INVALID;
		214	UbxVelNed.Status = INVALID;
		215	GPSData.Status = INVALID;
231	killagreg	216	}
		217
274	killagreg	218	/********************************************************/
		219	/* Upate GPS data stcructure */
		220	/********************************************************/
		221	void Update_GPSData (void)
		222	{
		223	static uint16_t Ubx_Timeout = 0;
		224	static uint8_t Msg_Count = 0;
231	killagreg	225
274	killagreg	226	// the timeout is used to detect the delay between two message sets
		227	// and is used for synchronisation so that always a set is collected
		228	// that belongs together
		229	// _______NAVSOL\|POSLLH\|VELNED\|___________________NAVSOL\|POSLLH\|VELNED\|_____________
		230	// \| 8ms \| 8ms \| 184 ms \| \| \|
		231	// msg_count: 0 1 2 0 1 2
		232
		233	if(CheckDelay(Ubx_Timeout)) Msg_Count = 0;
		234	else Msg_Count++;
		235	Ubx_Timeout = SetDelay(100); // reset ubx msg timeout
		236
		237	// if a new set of ubx messages was collected
		238	if((Msg_Count >= 2))
		239	{ // if set is complete
		240	if((UbxSol.Status == NEWDATA) && (UbxPosLlh.Status == NEWDATA) && (UbxVelNed.Status == NEWDATA))
		241	{
		242	CheckGPSOkay++;
		243	// update GPS data only if the status is INVALID or PROCESSED and the last ubx message was received within less than 100 ms
		244	if(GPSData.Status != NEWDATA) // if last data were processed
		245	{ // wait for new data at all neccesary ubx messages
		246	GPSData.Status = INVALID;
		247	// NAV SOL
		248	GPSData.Flags = UbxSol.Flags;
		249	GPSData.NumOfSats = UbxSol.numSV;
		250	GPSData.SatFix = UbxSol.GPSfix;
		251	GPSData.Position_Accuracy = UbxSol.PAcc;
		252	GPSData.Speed_Accuracy = UbxSol.SAcc;
		253	SetGPSTime(&SystemTime); // update system time
		254	// NAV POSLLH
		255	GPSData.Position.Status = INVALID;
		256	GPSData.Position.Longitude = UbxPosLlh.LON;
		257	GPSData.Position.Latitude = UbxPosLlh.LAT;
		258	GPSData.Position.Altitude = UbxPosLlh.HMSL;
		259	GPSData.Position.Status = NEWDATA;
		260	// NAV VELNED
		261	GPSData.Speed_East = UbxVelNed.VEL_E;
		262	GPSData.Speed_North = UbxVelNed.VEL_N;
		263	GPSData.Speed_Top = -UbxVelNed.VEL_D;
		264	GPSData.Speed_Ground = UbxVelNed.GSpeed;
		265	GPSData.Heading = UbxVelNed.Heading;
		266
		267	GPSData.Status = NEWDATA; // new data available
		268	} // EOF if(GPSData.Status != NEWDATA)
		269	} // EOF all ubx messages received
		270	// set state to collect new data
		271	UbxSol.Status = PROCESSED; // ready for new data
		272	UbxPosLlh.Status = PROCESSED; // ready for new data
		273	UbxVelNed.Status = PROCESSED; // ready for new data
		274	}
		275	}
		276
		277
		278	/********************************************************/
		279	/* UBX Parser */
		280	/********************************************************/
		281	void UBX_Parser(uint8_t c)
231	killagreg	282	{
274	killagreg	283	static ubxState_t ubxState = UBXSTATE_IDLE;
		284	static uint16_t msglen;
231	killagreg	285	static uint8_t cka, ckb;
274	killagreg	286	static uint8_t ubxP, ubxEp, *ubxSp; // pointers to data currently transfered
231	killagreg	287
274	killagreg	288
		289	//state machine
		290	switch (ubxState) // ubx message parser
231	killagreg	291	{
		292	case UBXSTATE_IDLE: // check 1st sync byte
274	killagreg	293	if (c == UBX_SYNC1_CHAR) ubxState = UBXSTATE_SYNC1;
		294	else ubxState = UBXSTATE_IDLE; // out of synchronization
231	killagreg	295	break;
		296
		297	case UBXSTATE_SYNC1: // check 2nd sync byte
274	killagreg	298	if (c == UBX_SYNC2_CHAR) ubxState = UBXSTATE_SYNC2;
		299	else ubxState = UBXSTATE_IDLE; // out of synchronization
231	killagreg	300	break;
		301
		302	case UBXSTATE_SYNC2: // check msg class to be NAV
274	killagreg	303	if (c == UBX_CLASS_NAV) ubxState = UBXSTATE_CLASS;
		304	else ubxState = UBXSTATE_IDLE; // unsupported message class
231	killagreg	305	break;
		306
		307	case UBXSTATE_CLASS: // check message identifier
		308	switch(c)
		309	{
		310	case UBX_ID_POSLLH: // geodetic position
274	killagreg	311	ubxP = (uint8_t *)&UbxPosLlh; // data start pointer
		312	ubxEp = (uint8_t *)(&UbxPosLlh + 1); // data end pointer
		313	ubxSp = (uint8_t *)&UbxPosLlh.Status; // status pointer
231	killagreg	314	break;
		315
		316	case UBX_ID_SOL: // navigation solution
274	killagreg	317	ubxP = (uint8_t *)&UbxSol; // data start pointer
		318	ubxEp = (uint8_t *)(&UbxSol + 1); // data end pointer
		319	ubxSp = (uint8_t *)&UbxSol.Status; // status pointer
231	killagreg	320	break;
		321
		322	case UBX_ID_VELNED: // velocity vector in tangent plane
274	killagreg	323	ubxP = (uint8_t *)&UbxVelNed; // data start pointer
		324	ubxEp = (uint8_t *)(&UbxVelNed + 1); // data end pointer
		325	ubxSp = (uint8_t *)&UbxVelNed.Status; // status pointer
231	killagreg	326	break;
		327
		328	default: // unsupported identifier
274	killagreg	329	ubxState = UBXSTATE_IDLE;
231	killagreg	330	break;
		331	}
274	killagreg	332	if (ubxState != UBXSTATE_IDLE)
231	killagreg	333	{
274	killagreg	334	ubxState = UBXSTATE_LEN1;
231	killagreg	335	cka = UBX_CLASS_NAV + c;
		336	ckb = UBX_CLASS_NAV + cka;
		337	}
		338	break;
		339
		340	case UBXSTATE_LEN1: // 1st message length byte
274	killagreg	341	msglen = (uint16_t)c; // lowbyte first
231	killagreg	342	cka += c;
		343	ckb += cka;
274	killagreg	344	ubxState = UBXSTATE_LEN2;
231	killagreg	345	break;
		346
		347	case UBXSTATE_LEN2: // 2nd message length byte
274	killagreg	348	msglen += ((uint16_t)c)<<8; // high byte last
231	killagreg	349	cka += c;
		350	ckb += cka;
		351	// if the old data are not processed so far then break parsing now
		352	// to avoid writing new data in ISR during reading by another function
		353	if ( *ubxSp == NEWDATA )
		354	{
274	killagreg	355	ubxState = UBXSTATE_IDLE;
		356	Update_GPSData(); //update GPS info respectively
231	killagreg	357	}
		358	else // data invalid or allready processd
		359	{
274	killagreg	360	*ubxSp = INVALID; // mark invalid during buffer filling
		361	ubxState = UBXSTATE_DATA;
231	killagreg	362	}
		363	break;
		364
274	killagreg	365	case UBXSTATE_DATA: // collecting data
		366	if (ubxP < ubxEp)
		367	{
		368	*ubxP++ = c; // copy curent data byte if any space is left
		369	cka += c;
		370	ckb += cka;
		371	if (--msglen == 0) ubxState = UBXSTATE_CKA; // switch to next state if all data was read
		372	}
		373	else // rx buffer overrun
		374	{
		375	ubxState = UBXSTATE_IDLE;
		376	}
231	killagreg	377	break;
		378
		379	case UBXSTATE_CKA:
274	killagreg	380	if (c == cka) ubxState = UBXSTATE_CKB;
231	killagreg	381	else
		382	{
		383	*ubxSp = INVALID;
274	killagreg	384	ubxState = UBXSTATE_IDLE;
231	killagreg	385	}
		386	break;
		387
		388	case UBXSTATE_CKB:
		389	if (c == ckb)
		390	{
		391	*ubxSp = NEWDATA; // new data are valid
274	killagreg	392	Update_GPSData(); //update GPS info respectively
231	killagreg	393	}
		394	else
274	killagreg	395	{ // if checksum not match then set data invalid
231	killagreg	396	*ubxSp = INVALID;
		397	}
274	killagreg	398	ubxState = UBXSTATE_IDLE; // ready to parse new data
231	killagreg	399	break;
		400
		401	default: // unknown ubx state
274	killagreg	402	ubxState = UBXSTATE_IDLE;
231	killagreg	403	break;
274	killagreg	404
231	killagreg	405	}
303	joko	406	DebugOut.Analog[9] = GPSData.Speed_North;
		407	DebugOut.Analog[10] = GPSData.Speed_East;
		408	DebugOut.Analog[11] = GPSData.Speed_Top;
		409	DebugOut.Analog[12] = GPSData.NumOfSats;
		410	DebugOut.Analog[13] = GPSData.Position.Longitude;
		411	DebugOut.Analog[14] = GPSData.Position.Latitude;
		412	DebugOut.Analog[15] = GPSData.Position.Altitude;
231	killagreg	413	}

Subversion Repositories Projects

(root)/FollowMe/ubx.c @ 338 - Rev