jro_hard/gen_acq Commit - r115:116 · Jicamarca Repository

aaguilar -

r115:116

parent child

Context file:

r115:116

trunk/firmware/sources/saigd/nmealib++/nmeaCode.cpp +7 -7

             	// TODO Auto-generated destructor stub
             }
-            virtual void nmeaCode::code_init() {
+            bool nmeaCode::nmea_code_set(const char* cd) {
-            virtual int  nmeaCode::code_gen(char *buff, int buff_sz) {
+            	size_t sz = strlen(cd);
-            	return 0;
+            	codebuff = new char[sz];
+            	strcpy(codebuff, cd);
+            	return true;
             }
-            virtual int  nmeaCode::code_parse(const char *buff, int buff_sz) {
+            bool nmeaCode::nmea_code_get(char* cd) {
-            	return 0;
+            	return true;
             }
             ////////////////////////////////////////////////////////////////////////////////////////

trunk/firmware/sources/saigd/nmealib++/nmeaCode.h +3 -6

             	nmeaCode(char* name=nullptr);
             	virtual ~nmeaCode();
-            	virtual void code_init(void);
+            	bool nmea_code_set(const char* cd);
-            	virtual int  code_gen(char *buff, int buff_sz);// TODO para generator
+            	bool nmea_code_get(char* cd);
-            	virtual int  code_parse(const char *buff, int buff_sz);// TODO para parser
             private:
+            	size_t size;
             	const char codename[8];
             	const int  type;
             	char *codebuff;

trunk/firmware/sources/saigd/nmealib++/nmeaGenerator.cpp +3 -3

             }
-            virtual int nmeaGenerator::code_info2nmea(const nmeaInfo *info, nmeaCode* code)
+            virtual int nmeaGenerator::nmea_gen_info2code(const nmeaInfo *info, nmeaCode* code)
             {
             	return 1;
             }
             {
                 int RetVal = 1; int smask = info->smask;
-                info->code_init_INFO();
+                info->nmea_info_init_INFO();
                 info->smask = smask;
                 info->lat = NMEA_DEF_LAT;
                 while(code)
                 {
-            		code_info2nmea(info, code)
+                	nmea_gen_info2code(info, code)
             		gen_count += code->code_gen(buff + gen_count, buff_sz - gen_count);
             		code += 1;
             		if(buff_sz - gen_count <= 0)

trunk/firmware/sources/saigd/nmealib++/nmeaGenerator.h +1 -1

             	virtual ~nmeaGenerator();
-            	virtual int code_info2nmea(const nmeaInfo *info, nmeaCode* code);
+            	virtual int nmea_gen_info2code(const nmeaInfo *info, nmeaCode* code);
             	int nmea_gen_init(nmeaInfo *info);
             	int nmea_gen_loop(nmeaInfo *info);

trunk/firmware/sources/saigd/nmealib++/nmeaInfo.cpp +11 -11

             	// TODO Auto-generated destructor stub
             }
-            void nmeaInfo::code_init_INFO()
+            void nmeaInfo::nmea_info_init_INFO()
+            {
-                code_time_now();
+            	nmea_info_time_now();
                 sig = NMEA_SIG_BAD;
                 fix = NMEA_FIX_BAD;
             }
-            static void nmeaInfo::code_time_now() {
+            static void nmeaInfo::nmea_info_time_now() {
                 time_t lt;
                 struct tm *tt;
             /**
              * \brief Convert position from INFO to radians position
              */
-            void nmeaInfo::code_info2pos(nmeaPOS *pos) {
+            void nmeaInfo::nmea_info_info2pos(nmeaPOS *pos) {
                 pos->lat = code_ndeg2radian(lat);
                 pos->lon = code_ndeg2radian(lon);
             }
             /**
              * \brief Convert radians position to INFOs position
              */
-            void nmeaInfo::code_pos2info(const nmeaPOS *pos) {
+            void nmeaInfo::nmea_info_pos2info(const nmeaPOS *pos) {
                 lat = code_radian2ndeg(pos->lat);
                 lon = code_radian2ndeg(pos->lon);
             }
             int nmeaInfo::nmea_igen_static_loop()
             {
-            	code_time_now();
+            	nmea_info_time_now();
                 return 1;
             };
                 double deg = 360 / (count?count:1);
                 double srt = (count?(satinfo.sat[0].azimuth):0) + 5;
-                code_time_now();
+                nmea_info_time_now();
                 for(it = 0; it < count; ++it)
                 {
                 if(speed < 1)
                     speed = 1;
-                code_info2pos(&crd);
+                nmea_info_info2pos(&crd);
                 code_move_horz(&crd, &crd, direction, speed / 3600);
-                code_pos2info(&crd);
+                nmea_info_pos2info(&crd);
                 declination = direction;

trunk/firmware/sources/saigd/nmealib++/nmeaInfo.h +23 -15

@@ -47,22 +47,22
47	public:	47	public:
48	nmeaInfo();	48	nmeaInfo();
49	virtual ~nmeaInfo();	49	virtual ~nmeaInfo();
50	void ~~code~~_init_INFO();	50	void nmea_info_init_INFO();
51	static void ~~code~~_time_now();	51	static void nmea_info_time_now();
52	void ~~code~~_info2pos(nmeaPOS *pos);	52	void nmea_info_info2pos(nmeaPOS *pos);
53	void ~~code~~_pos2info(const nmeaPOS *pos);	53	void nmea_info_pos2info(const nmeaPOS *pos);
54		54
55	int nmea_igen_noise_init();	55	int nmea_info_noise_init();
56	int nmea_igen_noise_loop();	56	int nmea_info_noise_loop();
57	int nmea_igen_noise_reset();	57	int nmea_info_noise_reset();
58	int nmea_igen_static_loop();	58	int nmea_info_static_loop();
59	int nmea_igen_static_reset();	59	int nmea_info_static_reset();
60	int nmea_igen_static_init();	60	int nmea_info_static_init();
61	int nmea_igen_rotate_loop();	61	int nmea_info_rotate_loop();
62	int nmea_igen_rotate_reset();	62	int nmea_info_rotate_reset();
63	int nmea_igen_rotate_init();	63	int nmea_info_rotate_init();
64	int nmea_igen_pos_rmove_init();	64	int nmea_info_pos_rmove_init();
65	int nmea_igen_pos_rmove_loop();	65	int nmea_info_pos_rmove_loop();
66		66
67	private:	67	private:
68	int smask; /*< Mask specifying types of packages from which data have been obtained /	68	int smask; /*< Mask specifying types of packages from which data have been obtained /
@@ -78,6 +78,14
78	double speed; /*< Speed over the ground in kilometers/hour /	78	double speed; /*< Speed over the ground in kilometers/hour /
79	double direction; /*< Track angle in degrees True /	79	double direction; /*< Track angle in degrees True /
80	double declination; /*< Magnetic variation degrees (Easterly var. subtracts from true course) /	80	double declination; /*< Magnetic variation degrees (Easterly var. subtracts from true course) /
		81	char ns;
		82	char ew;
		83	double satinuse;
		84	char elv_units;
		85	double diff;
		86	char diff_units;
		87	double dgps_age;
		88	double dgps_sid;
81	nmeaSATINFO satinfo; /*< Satellites information /	89	nmeaSATINFO satinfo; /*< Satellites information /
82	};	90	};
83		91

trunk/firmware/sources/saigd/nmealib++/nmeaParser.h +75 -1

@@ -31,7 +31,7
31	int nmea_parser_buff_clear(void);	31	int nmea_parser_buff_clear(void);
32	int nmea_parser_queue_clear(void);	32	int nmea_parser_queue_clear(void);
33		33
34	virtual void code_2info(nmeaCode* code, nmeaInfo* info);	34	virtual void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
35		35
36	private:	36	private:
37	void *top_node;	37	void *top_node;
@@ -43,4 +43,78
43	int nmea_parser_real_push(const char *buff, int buff_sz);	43	int nmea_parser_real_push(const char *buff, int buff_sz);
44	};	44	};
45		45
		46
		47	class nmeaGPALMParser:nmeaParser {
		48	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		49	};
		50
		51	//codigos NMEA que se pueden enviar al receptor GPS GARMIN
		52	class nmeaPGRMIParser:nmeaParser {
		53	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		54	};
		55
		56	class nmeaPGRMCParser:nmeaParser {
		57	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		58	};
		59
		60	class nmeaPGRMC1Parser:nmeaParser {
		61	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		62	};
		63
		64	class nmeaPGRMOParser:nmeaParser {
		65	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		66	};
		67
		68
		69	//Codigos NMEA que puede transmitir el receptor GNSS
		70
		71	class nmeaGPGGAParser:nmeaParser {
		72	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		73	};
		74
		75	class nmeaGPGSAParser:nmeaParser {
		76	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		77	};
		78
		79	class nmeaGPGSVParser:nmeaParser {
		80	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		81	};
		82
		83	class nmeaGPRMCParser:nmeaParser {
		84	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		85	};
		86
		87	class nmeaGPVTGParser:nmeaParser {
		88	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		89	};
		90
		91	class nmeaGPGLLParser:nmeaParser {
		92	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		93	};
		94
		95	//codigos de propiedad de GARMIN
		96	class nmeaPGRMEParser:nmeaParser {
		97	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		98	};
		99
		100	class nmeaPGRMFParser:nmeaParser {
		101	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		102	};
		103
		104	class nmeaPGRMMParser:nmeaParser {
		105	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		106	};
		107
		108	class nmeaPGRMTParser:nmeaParser {
		109	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		110	};
		111
		112	class nmeaPGRMVParser:nmeaParser {
		113	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		114	};
		115
		116	class nmeaPGRMBParser:nmeaParser {
		117	void nmea_parser_code2info(nmeaCode* code, nmeaInfo* info);
		118	};
		119
46	#endif /* NMEALIB_NMEALIB___NMEAPARSER_H_ */	120	#endif /* NMEALIB_NMEALIB___NMEAPARSER_H_ */

trunk/firmware/sources/saigd/nmealib++/utils.cpp +28 -28

              * \fn code_degree2radian
              * \brief Convert degree to radian
              */
-            double code_degree2radian(double val) {
+            double nmea_utils_degree2radian(double val) {
             	return (val * code_PI180);
             }
              * \fn code_radian2degree
              * \brief Convert radian to degree
              */
-            double code_radian2degree(double val) {
+            double nmea_utils_radian2degree(double val) {
             	return (val / code_PI180);
             }
             /**
              * \brief Convert NDEG (NMEA degree) to fractional degree
              */
-            double code_ndeg2degree(double val) {
+            double nmea_utils_ndeg2degree(double val) {
                 double deg = ((int)(val / 100));
                 val = deg + (val - deg * 100) / 60;
                 return val;
             /**
              * \brief Convert fractional degree to NDEG (NMEA degree)
              */
-            double code_degree2ndeg(double val) {
+            double nmea_utils_degree2ndeg(double val) {
                 double int_part;
                 double fra_part;
                 fra_part = modf(val, &int_part);
              * \brief Convert NDEG (NMEA degree) to radian
              */
             double code_ndeg2radian(double val) {
-            	return code_degree2radian(code_ndeg2degree(val));
+            	return nmea_utils_degree2radian(nmea_utils_ndeg2degree(val));
             }
             /**
              * \fn code_radian2ndeg
              * \brief Convert radian to NDEG (NMEA degree)
              */
-            double code_radian2ndeg(double val) {
+            double nmea_utils_radian2ndeg(double val) {
-            	return code_degree2ndeg(code_radian2degree(val));
+            	return nmea_utils_degree2ndeg(nmea_utils_radian2degree(val));
             }
             /**
              * \brief Calculate PDOP (Position Dilution Of Precision) factor
              */
-            double code_calc_pdop(double hdop, double vdop) {
+            double nmea_utils_calc_pdop(double hdop, double vdop) {
             	return sqrt(pow(hdop, 2) + pow(vdop, 2));
             }
-            double code_dop2meters(double dop) {
+            double nmea_utils_dop2meters(double dop) {
             	return (dop * code_DOP_FACTOR);
             }
-            double code_meters2dop(double meters) {
+            double nmea_utils_meters2dop(double meters) {
             	return (meters / code_DOP_FACTOR);
             }
              * \brief Calculate distance between two points
              * \return Distance in meters
              */
-            double code_distance(
+            double nmea_utils_distance(
             		const nmeaPOS *from_pos,    /**< From position in radians */
                     const nmeaPOS *to_pos       /**< To position in radians */
             		)
              * http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf
              * \return Distance in meters
              */
-            double code_distance_ellipsoid(
+            double nmea_utils_distance_ellipsoid(
                     const nmeaPOS *from_pos,    /**< From position in radians */
                     const nmeaPOS *to_pos,      /**< To position in radians */
                     double *from_azimuth,       /**< (O) azimuth at "from" position in radians */
             /**
              * \brief Horizontal move of point position
              */
-            int code_move_horz(
+            int nmea_utils_move_horz(
             		const nmeaPOS *start_pos,   /**< Start position in radians */
             		nmeaPOS *end_pos,           /**< Result position in radians */
             		double azimuth,             /**< Azimuth (degree) [0, 359] */
                 int RetVal = 1;
                 distance /= code_EARTHRADIUS_KM; /* Angular distance covered on earth's surface */
-                azimuth = code_degree2radian(azimuth);
+                azimuth = nmea_utils_degree2radian(azimuth);
                 end_pos->lat = asin(
                     sin(p1.lat) * cos(distance) + cos(p1.lat) * sin(distance) * cos(azimuth));
              * The algorithm is described here:
              * http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf
              */
-            int code_move_horz_ellipsoid(
+            int nmea_utils_move_horz_ellipsoid(
             	    const nmeaPOS *start_pos,   /**< Start position in radians */
             	    nmeaPOS *end_pos,           /**< (O) Result position in radians */
             	    double azimuth,             /**< Azimuth in radians */
             /**
              * \brief Calculate control sum of binary buffer
              */
-            int code_calc_crc(const char *buff, int buff_sz)
+            int nmea_utils_calc_crc(const char *buff, int buff_sz)
             {
                 int chsum = 0,
                     it;
             /**
              * \brief Convert string to number
              */
-            int code_atoi(const char *str, int str_sz, int radix)
+            int nmea_utils_atoi(const char *str, int str_sz, int radix)
             {
                 char *tmp_ptr;
                 char buff[NMEA_CONVSTR_BUF];
             /**
              * \brief Convert string to fraction number
              */
-            double code_atof(const char *str, int str_sz)
+            double nmea_utils_atof(const char *str, int str_sz)
             {
                 char *tmp_ptr;
                 char buff[NMEA_CONVSTR_BUF];
             /**
              * \brief Formating string (like standart printf) with CRC tail (*CRC)
              */
-            int code_printf(char *buff, int buff_sz, const char *format, ...)
+            int nmea_utils_printf(char *buff, int buff_sz, const char *format, ...)
             {
                 int retval, add = 0;
                 va_list arg_ptr;
                 {
                     add = NMEA_POSIX(snprintf)(
                         buff + retval, buff_sz - retval, "*%02x\r\n",
-                        code_calc_crc(buff + 1, retval - 1));
+            			nmea_utils_calc_crc(buff + 1, retval - 1));
                 }
                 retval += add;
             /**
              * \brief Analyse string (specificate for NMEA sentences)
              */
-            int code_scanf(const char *buff, int buff_sz, const char *format, ...)
+            int nmea_utils_scanf(const char *buff, int buff_sz, const char *format, ...)
             {
                 const char *beg_tok;
                 const char *end_buf = buff + buff_sz;
                         {
                             tok_type = NMEA_TOKS_TYPE;
                             if(format > beg_fmt)
-                                width = code_atoi(beg_fmt, (int)(format - beg_fmt), 10);
+                                width = nmea_utils_atoi(beg_fmt, (int)(format - beg_fmt), 10);
                         }
                     case NMEA_TOKS_TYPE:
                         beg_tok = buff;
                         case 'E':
                             parg_target = (void *)va_arg(arg_ptr, double *);
                             if(width && 0 != (parg_target))
-                                *((double *)parg_target) = code_atof(beg_tok, width);
+                                *((double *)parg_target) = nmea_utils_atof(beg_tok, width);
                             break;
                         };
                         {
                         case 'd':
                         case 'i':
-                            snum = code_atoi(beg_tok, width, 10);
+                            snum = nmea_utils_atoi(beg_tok, width, 10);
                             memcpy(parg_target, &snum, sizeof(int));
                             break;
                         case 'u':
-                            unum = code_atoi(beg_tok, width, 10);
+                            unum = nmea_utils_atoi(beg_tok, width, 10);
                             memcpy(parg_target, &unum, sizeof(unsigned int));
                             break;
                         case 'x':
                         case 'X':
-                            unum = code_atoi(beg_tok, width, 16);
+                            unum = nmea_utils_atoi(beg_tok, width, 16);
                             memcpy(parg_target, &unum, sizeof(unsigned int));
                             break;
                         case 'o':
-                            unum = code_atoi(beg_tok, width, 8);
+                            unum = nmea_utils_atoi(beg_tok, width, 8);
                             memcpy(parg_target, &unum, sizeof(unsigned int));
                             break;
                         default:
             }
-            double nmeaGenerator::nmea_random(double min, double max)
+            double nmea_utils_random(double min, double max)
             {
                 static double rand_max = RAND_MAX;
                 double rand_val = rand();

trunk/firmware/sources/saigd/nmealib++/utils.h +19 -19

@@ -10,29 +10,29
10		10
11	#include "nmea_defs.h"	11	#include "nmea_defs.h"
12		12
13	double ~~code~~_degree2radian(double val);	13	double nmea_utils_degree2radian(double val);
14	double ~~code~~_radian2degree(double val);	14	double nmea_utils_radian2degree(double val);
15	double ~~code~~_ndeg2degree(double val);	15	double nmea_utils_ndeg2degree(double val);
16	double ~~code~~_degree2ndeg(double val);	16	double nmea_utils_degree2ndeg(double val);
17	double ~~code~~_ndeg2radian(double val);	17	double nmea_utils_ndeg2radian(double val);
18	double ~~code~~_radian2ndeg(double val);	18	double nmea_utils_radian2ndeg(double val);
19	double ~~code~~_calc_pdop(double hdop, double vdop);	19	double nmea_utils_calc_pdop(double hdop, double vdop);
20	double ~~code~~_dop2meters(double dop);	20	double nmea_utils_dop2meters(double dop);
21	double ~~code~~_meters2dop(double meters);	21	double nmea_utils_meters2dop(double meters);
22	double ~~code~~_distance(const nmeaPOS from_pos, const nmeaPOS to_pos);	22	double nmea_utils_distance(const nmeaPOS from_pos, const nmeaPOS to_pos);
23	double ~~code~~_distance_ellipsoid(const nmeaPOS from_pos, const nmeaPOS to_pos,	23	double nmea_utils_distance_ellipsoid(const nmeaPOS from_pos, const nmeaPOS to_pos,
24	double from_azimuth, double to_azimuth);	24	double from_azimuth, double to_azimuth);
25	int ~~code~~_move_horz(const nmeaPOS start_pos, nmeaPOS end_pos,	25	int nmea_utils_move_horz(const nmeaPOS start_pos, nmeaPOS end_pos,
26	double azimuth, double distance);	26	double azimuth, double distance);
27	int ~~code~~_move_horz_ellipsoid(const nmeaPOS start_pos, nmeaPOS end_pos,	27	int nmea_utils_move_horz_ellipsoid(const nmeaPOS start_pos, nmeaPOS end_pos,
28	double azimuth, double distance, double *end_azimuth );	28	double azimuth, double distance, double *end_azimuth );
29		29
30	int ~~code~~_calc_crc(const char *buff, int buff_sz);	30	int nmea_utils_calc_crc(const char *buff, int buff_sz);
31	int ~~code~~_atoi(const char *str, int str_sz, int radix);	31	int nmea_utils_atoi(const char *str, int str_sz, int radix);
32	double ~~code~~_atof(const char *str, int str_sz);	32	double nmea_utils_atof(const char *str, int str_sz);
33	int ~~code~~_printf(char buff, int buff_sz, const char format, ...);	33	int nmea_utils_printf(char buff, int buff_sz, const char format, ...);
34	int ~~code~~_scanf(const char buff, int buff_sz, const char format, ...);	34	int nmea_utils_scanf(const char buff, int buff_sz, const char format, ...);
35		35
36	double nmea_random(double min, double max);	36	double nmea_utils_random(double min, double max);
37		37
38	#endif /* NMEALIB___UTILS_H_ */	38	#endif /* NMEALIB___UTILS_H_ */

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages