WebSVN – public – Diff – /sportwatcher/trunk/libgarmin/protocol.c



static void
garmin_assign_protocol ( garmin_unit *  garmin, 
			 uint16         protocol,
			 uint16 *       datatypes )
{
  if (!garmin)
     return;
  /* Unknown protocols and their data types are ignored. */
 
  switch ( protocol ) {
  case appl_A010:
  case appl_A011:

  int     n1;
  int     n2;
  char ** pos;
  char ** ret = NULL;
 
  if (!one || !two) return ret;
  for ( pos = one, n1 = 0; pos && *pos; pos++, n1++ );
  for ( pos = two, n2 = 0; pos && *pos; pos++, n2++ );
 
  if ( n1 + n2 > 0 ) {
    ret = calloc(n1+n2+1,sizeof(char *));

			garmin_pid        pid,
			garmin_datatype   type )
{
  garmin_data *     d = NULL;
  garmin_packet     p;
  link_protocol     link;
  garmin_pid        ppid;
  char              hv0[256];
 
  if (!garmin) return NULL;
  link = garmin->protocol.link;
 
  if ( garmin_read(garmin,&p) > 0 ) {
    ppid = garmin_gpid(link,garmin_packet_id(&p));
    if ( ppid == pid ) {
      d = garmin_unpack_packet(&p,type);
    } else {

		      garmin_datatype   type )
{
  garmin_data *     d         = NULL;
  garmin_list *     l         = NULL;
  garmin_packet     p;
  link_protocol     link;
  int               done      = 0;
  int               expected  = 0;
  int               got       = 0;
  garmin_pid        ppid;
  char              hv0[256];
 
  if (!garmin) return NULL;
  link = garmin->protocol.link;
 
  if ( garmin_read(garmin,&p) > 0 ) {
    ppid = garmin_gpid(link,garmin_packet_id(&p));
    if ( ppid == Pid_Records ) {
      expected = get_uint16(p.packet.data);
 

		       garmin_datatype   type2 )
{
  garmin_data *     d         = NULL;
  garmin_list *     l         = NULL;
  garmin_packet     p;
  link_protocol     link;
  int               expected  = 0;
  int               got       = 0;
  int               state     = 0;
  garmin_pid        ppid;
  char              hv0[256];
 
  if (!garmin) return NULL;
  link = garmin->protocol.link;
 
  if ( garmin_read(garmin,&p) > 0 ) {
    ppid = garmin_gpid(link,garmin_packet_id(&p));
    if ( ppid == Pid_Records ) {
      expected = get_uint16(p.packet.data);
 

		       garmin_datatype   type3 )
{
  garmin_data *     d         = NULL;
  garmin_list *     l         = NULL;
  garmin_packet     p;
  link_protocol     link;
  int               expected  = 0;
  int               got       = 0;
  garmin_pid        ppid;
  int               state     = 0;
  char              hv0[256];
 
  if (!garmin) return NULL;
  link      = garmin->protocol.link;
 
  if ( garmin_read(garmin,&p) > 0 ) {
    ppid = garmin_gpid(link,garmin_packet_id(&p));
    if ( ppid == Pid_Records ) {
      expected = get_uint16(p.packet.data);
 

  int                    j;
  uint8                  tag;
  uint16                 data;
  uint16 *               datatypes;
 
  if (!garmin) return;
  /* Send the product request */
  garmin_packetize(&p,L000_Pid_Product_Rqst,0,NULL);
  garmin_write(garmin,&p);
 
  /* Read the response. */

garmin_data *
garmin_read_a100 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Wpt) != 0 ) {
    d = garmin_read_records(garmin,
			    Pid_Wpt_Data,
			    garmin->datatype.waypoint.waypoint);
  }

garmin_data *
garmin_read_a101 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Wpt_Cats) != 0 ) {
    d = garmin_read_records(garmin,
			    Pid_Wpt_Cat,
			    garmin->datatype.waypoint.category);
  }

garmin_data *
garmin_read_a200 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Rte) != 0 ) {
    d = garmin_read_records2(garmin,
			     Pid_Rte_Hdr,
			     garmin->datatype.route.header,
			     Pid_Rte_Wpt_Data,

garmin_data *
garmin_read_a201 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Rte) != 0 ) {
    d = garmin_read_records3(garmin,
			     Pid_Rte_Hdr,
			     garmin->datatype.route.header,
			     Pid_Rte_Wpt_Data,

garmin_data *
garmin_read_a300 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Trk) != 0 ) {
    d = garmin_read_records(garmin,
			    Pid_Trk_Data,
			    garmin->datatype.track.data);
  }

garmin_data *
garmin_read_a301 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Trk) != 0 ) {
    d = garmin_read_records2(garmin,
			     Pid_Trk_Hdr,
			     garmin->datatype.track.header,
			     Pid_Trk_Data,

garmin_data *
garmin_read_a400 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Prx) != 0 ) {
    d = garmin_read_records(garmin,
			    Pid_Prx_Wpt_Data,
			    garmin->datatype.waypoint.proximity);
  }

garmin_data *
garmin_read_a500 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Alm) != 0 ) {
    d = garmin_read_records(garmin,
			    Pid_Almanac_Data,
			    garmin->datatype.almanac);
  }

garmin_data *
garmin_read_a600 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  d = garmin_read_singleton(garmin,
			    Pid_Date_Time_Data,
			    garmin->datatype.date_time);
 
  return d;

garmin_data *
garmin_read_a650 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_FlightBook_Transfer) ) {
    d = garmin_read_records(garmin,
			    Pid_FlightBook_Record,
			    garmin->datatype.flightbook);
  }

garmin_data *
garmin_read_a700 ( garmin_unit * garmin )
{
  garmin_data * d;
 
  if (!garmin) return NULL;
 
  d = garmin_read_singleton(garmin,
			    Pid_Position_Data,
			    garmin->datatype.position);
 
  return d;

garmin_data *
garmin_read_a800 ( garmin_unit * garmin )
{
  garmin_data * d;
 
  if (!garmin) return NULL;
 
  d = garmin_read_singleton(garmin,
			    Pid_Pvt_Data,
			    garmin->datatype.pvt);
 
  return d;

garmin_data *
garmin_read_a906 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Laps) != 0 ) {
    d = garmin_read_records(garmin,Pid_Lap,garmin->datatype.lap);
  }
 
  return d;

garmin_read_a1000 ( garmin_unit * garmin )
{
  garmin_data * d  = NULL;
  garmin_list * l  = NULL;
 
  if (!garmin) return NULL;
 
  /* Read the runs, then the laps, then the track log. */
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Runs) != 0 ) {
    d = garmin_alloc_data(data_Dlist);
    l = d->data;

garmin_read_a1002 ( garmin_unit * garmin )
{
  garmin_data * d  = NULL;
  garmin_list * l  = NULL;
 
  if (!garmin) return NULL;
 
  /* Read the workouts, then the workout occurrences */
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Workouts) != 0 ) {
    d = garmin_alloc_data(data_Dlist);
    l = d->data;

garmin_data *
garmin_read_a1003 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  /* Read the workouts, then the workout occurrences */
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Workout_Occurrences) != 0 ) {
    d = garmin_read_records(garmin,
			    Pid_Workout_Occurrence,

garmin_data *
garmin_read_a1004 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Fitness_User_Profile) != 0 ) {
    d = garmin_read_singleton(garmin,
			      Pid_Fitness_User_Profile,
			      garmin->datatype.fitness);
  }

garmin_data *
garmin_read_a1005 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Workout_Limits) != 0 ) {
    d = garmin_read_singleton(garmin,
			      Pid_Workout_Limits,
			      garmin->datatype.workout.limits);
  }

garmin_read_a1006 ( garmin_unit * garmin )
{
  garmin_data * d  = NULL;
  garmin_list * l  = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Courses) != 0 ) {
    d = garmin_alloc_data(data_Dlist);
    l = d->data;
    garmin_list_append(l,garmin_read_records(garmin,
					     Pid_Course,

garmin_data *
garmin_read_a1007 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Course_Laps) != 0 ) {
    d = garmin_read_records(garmin,
			    Pid_Course_Lap,
			    (garmin->datatype.course.lap != data_Dnil) ?
			    garmin->datatype.course.lap :

garmin_data *
garmin_read_a1008 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Course_Points) != 0 ) {
    d = garmin_read_records(garmin,
			    Pid_Course_Point,
			    garmin->datatype.course.point);
  }

garmin_data *
garmin_read_a1009 ( garmin_unit * garmin )
{
  garmin_data * d = NULL;
 
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Course_Limits) != 0 ) {
    d = garmin_read_singleton(garmin,
			      Pid_Course_Limits,
			      garmin->datatype.course.limits);
  }

{
  garmin_datatype  header;
  garmin_datatype  data;
  garmin_data *    d = NULL;
  
  if (!garmin) return NULL;
 
  if ( garmin_send_command(garmin,Cmnd_Transfer_Course_Tracks) != 0 ) {
 
    if ( garmin->datatype.course.track.header != data_Dnil ) {
      header = garmin->datatype.course.track.header;
    } else {

garmin_data *
garmin_read_via ( garmin_unit * garmin, appl_protocol protocol )
{
  garmin_data * data = NULL;
 
  if (!garmin) return NULL;
 
#define CASE_PROTOCOL(x)                                                      \
  case appl_A##x:                                                             \
    if ( garmin->verbose != 0 ) {                                             \
      fprintf(stderr, "[garmin] -> garmin_read_a" #x "\n");                            \
    }                                                                         \

garmin_data *
garmin_get ( garmin_unit * garmin, garmin_get_type what )
{
  garmin_data * data = NULL;
 
  if (!garmin) return NULL;
 
#define CASE_WHAT(x,y) \
  case GET_##x: data = garmin_read_via(garmin,garmin->protocol.y); break
 
  switch ( what ) {
  CASE_WHAT(WAYPOINTS,waypoint.waypoint);

 
/* Initialize a connection with a Garmin unit. */
 
int garmin_init(garmin_unit *garmin, int verbose)
{
  if (!garmin) return 0;
 
	memset(garmin, 0, sizeof(garmin_unit));
	garmin->verbose = verbose;
	garmin->usb.fd = -1;
 
	if ( garmin_open(garmin) != 0 )

Rev 142	Rev 246
Line 11...	Line 11...
11	`static void`	11	`static void`
12	`garmin_assign_protocol ( garmin_unit * garmin,`	12	`garmin_assign_protocol ( garmin_unit * garmin,`
13	`uint16 protocol,`	13	`uint16 protocol,`
14	`uint16 * datatypes )`	14	`uint16 * datatypes )`
15	`{`	15	`{`
-		16	`if (!garmin)`
-		17	`return;`
16	`/* Unknown protocols and their data types are ignored. */`	18	`/* Unknown protocols and their data types are ignored. */`
17		19
18	`switch ( protocol ) {`	20	`switch ( protocol ) {`
19	`case appl_A010:`	21	`case appl_A010:`
20	`case appl_A011:`	22	`case appl_A011:`
Line 173...	Line 175...
173	`int n1;`	175	`int n1;`
174	`int n2;`	176	`int n2;`
175	`char ** pos;`	177	`char ** pos;`
176	`char ** ret = NULL;`	178	`char ** ret = NULL;`
177		179
-		180	`if (!one \|\| !two) return ret;`
178	`for ( pos = one, n1 = 0; pos && *pos; pos++, n1++ );`	181	`for ( pos = one, n1 = 0; pos && *pos; pos++, n1++ );`
179	`for ( pos = two, n2 = 0; pos && *pos; pos++, n2++ );`	182	`for ( pos = two, n2 = 0; pos && *pos; pos++, n2++ );`
180		183
181	`if ( n1 + n2 > 0 ) {`	184	`if ( n1 + n2 > 0 ) {`
182	`ret = calloc(n1+n2+1,sizeof(char *));`	185	`ret = calloc(n1+n2+1,sizeof(char *));`
Line 197...	Line 200...
197	`garmin_pid pid,`	200	`garmin_pid pid,`
198	`garmin_datatype type )`	201	`garmin_datatype type )`
199	`{`	202	`{`
200	`garmin_data * d = NULL;`	203	`garmin_data * d = NULL;`
201	`garmin_packet p;`	204	`garmin_packet p;`
202	`link_protocol link = garmin->protocol.link;`	205	`link_protocol link;`
203	`garmin_pid ppid;`	206	`garmin_pid ppid;`
204	`char hv0[256];`	207	`char hv0[256];`
205		208
-		209	`if (!garmin) return NULL;`
-		210	`link = garmin->protocol.link;`
-		211
206	`if ( garmin_read(garmin,&p) > 0 ) {`	212	`if ( garmin_read(garmin,&p) > 0 ) {`
207	`ppid = garmin_gpid(link,garmin_packet_id(&p));`	213	`ppid = garmin_gpid(link,garmin_packet_id(&p));`
208	`if ( ppid == pid ) {`	214	`if ( ppid == pid ) {`
209	`d = garmin_unpack_packet(&p,type);`	215	`d = garmin_unpack_packet(&p,type);`
210	`} else {`	216	`} else {`
Line 230...	Line 236...
230	`garmin_datatype type )`	236	`garmin_datatype type )`
231	`{`	237	`{`
232	`garmin_data * d = NULL;`	238	`garmin_data * d = NULL;`
233	`garmin_list * l = NULL;`	239	`garmin_list * l = NULL;`
234	`garmin_packet p;`	240	`garmin_packet p;`
235	`link_protocol link = garmin->protocol.link;`	241	`link_protocol link;`
236	`int done = 0;`	242	`int done = 0;`
237	`int expected = 0;`	243	`int expected = 0;`
238	`int got = 0;`	244	`int got = 0;`
239	`garmin_pid ppid;`	245	`garmin_pid ppid;`
240	`char hv0[256];`	246	`char hv0[256];`
241		247
-		248	`if (!garmin) return NULL;`
-		249	`link = garmin->protocol.link;`
-		250
242	`if ( garmin_read(garmin,&p) > 0 ) {`	251	`if ( garmin_read(garmin,&p) > 0 ) {`
243	`ppid = garmin_gpid(link,garmin_packet_id(&p));`	252	`ppid = garmin_gpid(link,garmin_packet_id(&p));`
244	`if ( ppid == Pid_Records ) {`	253	`if ( ppid == Pid_Records ) {`
245	`expected = get_uint16(p.packet.data);`	254	`expected = get_uint16(p.packet.data);`
246		255
Line 307...	Line 316...
307	`garmin_datatype type2 )`	316	`garmin_datatype type2 )`
308	`{`	317	`{`
309	`garmin_data * d = NULL;`	318	`garmin_data * d = NULL;`
310	`garmin_list * l = NULL;`	319	`garmin_list * l = NULL;`
311	`garmin_packet p;`	320	`garmin_packet p;`
312	`link_protocol link = garmin->protocol.link;`	321	`link_protocol link;`
313	`int expected = 0;`	322	`int expected = 0;`
314	`int got = 0;`	323	`int got = 0;`
315	`int state = 0;`	324	`int state = 0;`
316	`garmin_pid ppid;`	325	`garmin_pid ppid;`
317	`char hv0[256];`	326	`char hv0[256];`
318		327
-		328	`if (!garmin) return NULL;`
-		329	`link = garmin->protocol.link;`
-		330
319	`if ( garmin_read(garmin,&p) > 0 ) {`	331	`if ( garmin_read(garmin,&p) > 0 ) {`
320	`ppid = garmin_gpid(link,garmin_packet_id(&p));`	332	`ppid = garmin_gpid(link,garmin_packet_id(&p));`
321	`if ( ppid == Pid_Records ) {`	333	`if ( ppid == Pid_Records ) {`
322	`expected = get_uint16(p.packet.data);`	334	`expected = get_uint16(p.packet.data);`
323		335
Line 417...	Line 429...
417	`garmin_datatype type3 )`	429	`garmin_datatype type3 )`
418	`{`	430	`{`
419	`garmin_data * d = NULL;`	431	`garmin_data * d = NULL;`
420	`garmin_list * l = NULL;`	432	`garmin_list * l = NULL;`
421	`garmin_packet p;`	433	`garmin_packet p;`
422	`link_protocol link = garmin->protocol.link;`	434	`link_protocol link;`
423	`int expected = 0;`	435	`int expected = 0;`
424	`int got = 0;`	436	`int got = 0;`
425	`garmin_pid ppid;`	437	`garmin_pid ppid;`
426	`int state = 0;`	438	`int state = 0;`
427	`char hv0[256];`	439	`char hv0[256];`
428		440
-		441	`if (!garmin) return NULL;`
-		442	`link = garmin->protocol.link;`
-		443
429	`if ( garmin_read(garmin,&p) > 0 ) {`	444	`if ( garmin_read(garmin,&p) > 0 ) {`
430	`ppid = garmin_gpid(link,garmin_packet_id(&p));`	445	`ppid = garmin_gpid(link,garmin_packet_id(&p));`
431	`if ( ppid == Pid_Records ) {`	446	`if ( ppid == Pid_Records ) {`
432	`expected = get_uint16(p.packet.data);`	447	`expected = get_uint16(p.packet.data);`
433		448
Line 542...	Line 557...
542	`int j;`	557	`int j;`
543	`uint8 tag;`	558	`uint8 tag;`
544	`uint16 data;`	559	`uint16 data;`
545	`uint16 * datatypes;`	560	`uint16 * datatypes;`
546		561
-		562	`if (!garmin) return;`
547	`/* Send the product request */`	563	`/* Send the product request */`
548	`garmin_packetize(&p,L000_Pid_Product_Rqst,0,NULL);`	564	`garmin_packetize(&p,L000_Pid_Product_Rqst,0,NULL);`
549	`garmin_write(garmin,&p);`	565	`garmin_write(garmin,&p);`
550		566
551	`/* Read the response. */`	567	`/* Read the response. */`
Line 621...	Line 637...
621	`garmin_data *`	637	`garmin_data *`
622	`garmin_read_a100 ( garmin_unit * garmin )`	638	`garmin_read_a100 ( garmin_unit * garmin )`
623	`{`	639	`{`
624	`garmin_data * d = NULL;`	640	`garmin_data * d = NULL;`
625		641
-		642	`if (!garmin) return NULL;`
-		643
626	`if ( garmin_send_command(garmin,Cmnd_Transfer_Wpt) != 0 ) {`	644	`if ( garmin_send_command(garmin,Cmnd_Transfer_Wpt) != 0 ) {`
627	`d = garmin_read_records(garmin,`	645	`d = garmin_read_records(garmin,`
628	`Pid_Wpt_Data,`	646	`Pid_Wpt_Data,`
629	`garmin->datatype.waypoint.waypoint);`	647	`garmin->datatype.waypoint.waypoint);`
630	`}`	648	`}`
Line 640...	Line 658...
640	`garmin_data *`	658	`garmin_data *`
641	`garmin_read_a101 ( garmin_unit * garmin )`	659	`garmin_read_a101 ( garmin_unit * garmin )`
642	`{`	660	`{`
643	`garmin_data * d = NULL;`	661	`garmin_data * d = NULL;`
644		662
-		663	`if (!garmin) return NULL;`
-		664
645	`if ( garmin_send_command(garmin,Cmnd_Transfer_Wpt_Cats) != 0 ) {`	665	`if ( garmin_send_command(garmin,Cmnd_Transfer_Wpt_Cats) != 0 ) {`
646	`d = garmin_read_records(garmin,`	666	`d = garmin_read_records(garmin,`
647	`Pid_Wpt_Cat,`	667	`Pid_Wpt_Cat,`
648	`garmin->datatype.waypoint.category);`	668	`garmin->datatype.waypoint.category);`
649	`}`	669	`}`
Line 659...	Line 679...
659	`garmin_data *`	679	`garmin_data *`
660	`garmin_read_a200 ( garmin_unit * garmin )`	680	`garmin_read_a200 ( garmin_unit * garmin )`
661	`{`	681	`{`
662	`garmin_data * d = NULL;`	682	`garmin_data * d = NULL;`
663		683
-		684	`if (!garmin) return NULL;`
-		685
664	`if ( garmin_send_command(garmin,Cmnd_Transfer_Rte) != 0 ) {`	686	`if ( garmin_send_command(garmin,Cmnd_Transfer_Rte) != 0 ) {`
665	`d = garmin_read_records2(garmin,`	687	`d = garmin_read_records2(garmin,`
666	`Pid_Rte_Hdr,`	688	`Pid_Rte_Hdr,`
667	`garmin->datatype.route.header,`	689	`garmin->datatype.route.header,`
668	`Pid_Rte_Wpt_Data,`	690	`Pid_Rte_Wpt_Data,`
Line 680...	Line 702...
680	`garmin_data *`	702	`garmin_data *`
681	`garmin_read_a201 ( garmin_unit * garmin )`	703	`garmin_read_a201 ( garmin_unit * garmin )`
682	`{`	704	`{`
683	`garmin_data * d = NULL;`	705	`garmin_data * d = NULL;`
684		706
-		707	`if (!garmin) return NULL;`
-		708
685	`if ( garmin_send_command(garmin,Cmnd_Transfer_Rte) != 0 ) {`	709	`if ( garmin_send_command(garmin,Cmnd_Transfer_Rte) != 0 ) {`
686	`d = garmin_read_records3(garmin,`	710	`d = garmin_read_records3(garmin,`
687	`Pid_Rte_Hdr,`	711	`Pid_Rte_Hdr,`
688	`garmin->datatype.route.header,`	712	`garmin->datatype.route.header,`
689	`Pid_Rte_Wpt_Data,`	713	`Pid_Rte_Wpt_Data,`
Line 703...	Line 727...
703	`garmin_data *`	727	`garmin_data *`
704	`garmin_read_a300 ( garmin_unit * garmin )`	728	`garmin_read_a300 ( garmin_unit * garmin )`
705	`{`	729	`{`
706	`garmin_data * d = NULL;`	730	`garmin_data * d = NULL;`
707		731
-		732	`if (!garmin) return NULL;`
-		733
708	`if ( garmin_send_command(garmin,Cmnd_Transfer_Trk) != 0 ) {`	734	`if ( garmin_send_command(garmin,Cmnd_Transfer_Trk) != 0 ) {`
709	`d = garmin_read_records(garmin,`	735	`d = garmin_read_records(garmin,`
710	`Pid_Trk_Data,`	736	`Pid_Trk_Data,`
711	`garmin->datatype.track.data);`	737	`garmin->datatype.track.data);`
712	`}`	738	`}`
Line 722...	Line 748...
722	`garmin_data *`	748	`garmin_data *`
723	`garmin_read_a301 ( garmin_unit * garmin )`	749	`garmin_read_a301 ( garmin_unit * garmin )`
724	`{`	750	`{`
725	`garmin_data * d = NULL;`	751	`garmin_data * d = NULL;`
726		752
-		753	`if (!garmin) return NULL;`
-		754
727	`if ( garmin_send_command(garmin,Cmnd_Transfer_Trk) != 0 ) {`	755	`if ( garmin_send_command(garmin,Cmnd_Transfer_Trk) != 0 ) {`
728	`d = garmin_read_records2(garmin,`	756	`d = garmin_read_records2(garmin,`
729	`Pid_Trk_Hdr,`	757	`Pid_Trk_Hdr,`
730	`garmin->datatype.track.header,`	758	`garmin->datatype.track.header,`
731	`Pid_Trk_Data,`	759	`Pid_Trk_Data,`
Line 754...	Line 782...
754	`garmin_data *`	782	`garmin_data *`
755	`garmin_read_a400 ( garmin_unit * garmin )`	783	`garmin_read_a400 ( garmin_unit * garmin )`
756	`{`	784	`{`
757	`garmin_data * d = NULL;`	785	`garmin_data * d = NULL;`
758		786
-		787	`if (!garmin) return NULL;`
-		788
759	`if ( garmin_send_command(garmin,Cmnd_Transfer_Prx) != 0 ) {`	789	`if ( garmin_send_command(garmin,Cmnd_Transfer_Prx) != 0 ) {`
760	`d = garmin_read_records(garmin,`	790	`d = garmin_read_records(garmin,`
761	`Pid_Prx_Wpt_Data,`	791	`Pid_Prx_Wpt_Data,`
762	`garmin->datatype.waypoint.proximity);`	792	`garmin->datatype.waypoint.proximity);`
763	`}`	793	`}`
Line 773...	Line 803...
773	`garmin_data *`	803	`garmin_data *`
774	`garmin_read_a500 ( garmin_unit * garmin )`	804	`garmin_read_a500 ( garmin_unit * garmin )`
775	`{`	805	`{`
776	`garmin_data * d = NULL;`	806	`garmin_data * d = NULL;`
777		807
-		808	`if (!garmin) return NULL;`
-		809
778	`if ( garmin_send_command(garmin,Cmnd_Transfer_Alm) != 0 ) {`	810	`if ( garmin_send_command(garmin,Cmnd_Transfer_Alm) != 0 ) {`
779	`d = garmin_read_records(garmin,`	811	`d = garmin_read_records(garmin,`
780	`Pid_Almanac_Data,`	812	`Pid_Almanac_Data,`
781	`garmin->datatype.almanac);`	813	`garmin->datatype.almanac);`
782	`}`	814	`}`
Line 792...	Line 824...
792	`garmin_data *`	824	`garmin_data *`
793	`garmin_read_a600 ( garmin_unit * garmin )`	825	`garmin_read_a600 ( garmin_unit * garmin )`
794	`{`	826	`{`
795	`garmin_data * d = NULL;`	827	`garmin_data * d = NULL;`
796		828
-		829	`if (!garmin) return NULL;`
-		830
797	`d = garmin_read_singleton(garmin,`	831	`d = garmin_read_singleton(garmin,`
798	`Pid_Date_Time_Data,`	832	`Pid_Date_Time_Data,`
799	`garmin->datatype.date_time);`	833	`garmin->datatype.date_time);`
800		834
801	`return d;`	835	`return d;`
Line 809...	Line 843...
809	`garmin_data *`	843	`garmin_data *`
810	`garmin_read_a650 ( garmin_unit * garmin )`	844	`garmin_read_a650 ( garmin_unit * garmin )`
811	`{`	845	`{`
812	`garmin_data * d = NULL;`	846	`garmin_data * d = NULL;`
813		847
-		848	`if (!garmin) return NULL;`
-		849
814	`if ( garmin_send_command(garmin,Cmnd_FlightBook_Transfer) ) {`	850	`if ( garmin_send_command(garmin,Cmnd_FlightBook_Transfer) ) {`
815	`d = garmin_read_records(garmin,`	851	`d = garmin_read_records(garmin,`
816	`Pid_FlightBook_Record,`	852	`Pid_FlightBook_Record,`
817	`garmin->datatype.flightbook);`	853	`garmin->datatype.flightbook);`
818	`}`	854	`}`
Line 828...	Line 864...
828	`garmin_data *`	864	`garmin_data *`
829	`garmin_read_a700 ( garmin_unit * garmin )`	865	`garmin_read_a700 ( garmin_unit * garmin )`
830	`{`	866	`{`
831	`garmin_data * d;`	867	`garmin_data * d;`
832		868
-		869	`if (!garmin) return NULL;`
-		870
833	`d = garmin_read_singleton(garmin,`	871	`d = garmin_read_singleton(garmin,`
834	`Pid_Position_Data,`	872	`Pid_Position_Data,`
835	`garmin->datatype.position);`	873	`garmin->datatype.position);`
836		874
837	`return d;`	875	`return d;`
Line 845...	Line 883...
845	`garmin_data *`	883	`garmin_data *`
846	`garmin_read_a800 ( garmin_unit * garmin )`	884	`garmin_read_a800 ( garmin_unit * garmin )`
847	`{`	885	`{`
848	`garmin_data * d;`	886	`garmin_data * d;`
849		887
-		888	`if (!garmin) return NULL;`
-		889
850	`d = garmin_read_singleton(garmin,`	890	`d = garmin_read_singleton(garmin,`
851	`Pid_Pvt_Data,`	891	`Pid_Pvt_Data,`
852	`garmin->datatype.pvt);`	892	`garmin->datatype.pvt);`
853		893
854	`return d;`	894	`return d;`
Line 862...	Line 902...
862	`garmin_data *`	902	`garmin_data *`
863	`garmin_read_a906 ( garmin_unit * garmin )`	903	`garmin_read_a906 ( garmin_unit * garmin )`
864	`{`	904	`{`
865	`garmin_data * d = NULL;`	905	`garmin_data * d = NULL;`
866		906
-		907	`if (!garmin) return NULL;`
-		908
867	`if ( garmin_send_command(garmin,Cmnd_Transfer_Laps) != 0 ) {`	909	`if ( garmin_send_command(garmin,Cmnd_Transfer_Laps) != 0 ) {`
868	`d = garmin_read_records(garmin,Pid_Lap,garmin->datatype.lap);`	910	`d = garmin_read_records(garmin,Pid_Lap,garmin->datatype.lap);`
869	`}`	911	`}`
870		912
871	`return d;`	913	`return d;`
Line 880...	Line 922...
880	`garmin_read_a1000 ( garmin_unit * garmin )`	922	`garmin_read_a1000 ( garmin_unit * garmin )`
881	`{`	923	`{`
882	`garmin_data * d = NULL;`	924	`garmin_data * d = NULL;`
883	`garmin_list * l = NULL;`	925	`garmin_list * l = NULL;`
884		926
-		927	`if (!garmin) return NULL;`
-		928
885	`/* Read the runs, then the laps, then the track log. */`	929	`/* Read the runs, then the laps, then the track log. */`
886		930
887	`if ( garmin_send_command(garmin,Cmnd_Transfer_Runs) != 0 ) {`	931	`if ( garmin_send_command(garmin,Cmnd_Transfer_Runs) != 0 ) {`
888	`d = garmin_alloc_data(data_Dlist);`	932	`d = garmin_alloc_data(data_Dlist);`
889	`l = d->data;`	933	`l = d->data;`
Line 905...	Line 949...
905	`garmin_read_a1002 ( garmin_unit * garmin )`	949	`garmin_read_a1002 ( garmin_unit * garmin )`
906	`{`	950	`{`
907	`garmin_data * d = NULL;`	951	`garmin_data * d = NULL;`
908	`garmin_list * l = NULL;`	952	`garmin_list * l = NULL;`
909		953
-		954	`if (!garmin) return NULL;`
-		955
910	`/* Read the workouts, then the workout occurrences */`	956	`/* Read the workouts, then the workout occurrences */`
911		957
912	`if ( garmin_send_command(garmin,Cmnd_Transfer_Workouts) != 0 ) {`	958	`if ( garmin_send_command(garmin,Cmnd_Transfer_Workouts) != 0 ) {`
913	`d = garmin_alloc_data(data_Dlist);`	959	`d = garmin_alloc_data(data_Dlist);`
914	`l = d->data;`	960	`l = d->data;`
Line 930...	Line 976...
930	`garmin_data *`	976	`garmin_data *`
931	`garmin_read_a1003 ( garmin_unit * garmin )`	977	`garmin_read_a1003 ( garmin_unit * garmin )`
932	`{`	978	`{`
933	`garmin_data * d = NULL;`	979	`garmin_data * d = NULL;`
934		980
-		981	`if (!garmin) return NULL;`
-		982
935	`/* Read the workouts, then the workout occurrences */`	983	`/* Read the workouts, then the workout occurrences */`
936		984
937	`if ( garmin_send_command(garmin,Cmnd_Transfer_Workout_Occurrences) != 0 ) {`	985	`if ( garmin_send_command(garmin,Cmnd_Transfer_Workout_Occurrences) != 0 ) {`
938	`d = garmin_read_records(garmin,`	986	`d = garmin_read_records(garmin,`
939	`Pid_Workout_Occurrence,`	987	`Pid_Workout_Occurrence,`
Line 951...	Line 999...
951	`garmin_data *`	999	`garmin_data *`
952	`garmin_read_a1004 ( garmin_unit * garmin )`	1000	`garmin_read_a1004 ( garmin_unit * garmin )`
953	`{`	1001	`{`
954	`garmin_data * d = NULL;`	1002	`garmin_data * d = NULL;`
955		1003
-		1004	`if (!garmin) return NULL;`
-		1005
956	`if ( garmin_send_command(garmin,Cmnd_Transfer_Fitness_User_Profile) != 0 ) {`	1006	`if ( garmin_send_command(garmin,Cmnd_Transfer_Fitness_User_Profile) != 0 ) {`
957	`d = garmin_read_singleton(garmin,`	1007	`d = garmin_read_singleton(garmin,`
958	`Pid_Fitness_User_Profile,`	1008	`Pid_Fitness_User_Profile,`
959	`garmin->datatype.fitness);`	1009	`garmin->datatype.fitness);`
960	`}`	1010	`}`
Line 970...	Line 1020...
970	`garmin_data *`	1020	`garmin_data *`
971	`garmin_read_a1005 ( garmin_unit * garmin )`	1021	`garmin_read_a1005 ( garmin_unit * garmin )`
972	`{`	1022	`{`
973	`garmin_data * d = NULL;`	1023	`garmin_data * d = NULL;`
974		1024
-		1025	`if (!garmin) return NULL;`
-		1026
975	`if ( garmin_send_command(garmin,Cmnd_Transfer_Workout_Limits) != 0 ) {`	1027	`if ( garmin_send_command(garmin,Cmnd_Transfer_Workout_Limits) != 0 ) {`
976	`d = garmin_read_singleton(garmin,`	1028	`d = garmin_read_singleton(garmin,`
977	`Pid_Workout_Limits,`	1029	`Pid_Workout_Limits,`
978	`garmin->datatype.workout.limits);`	1030	`garmin->datatype.workout.limits);`
979	`}`	1031	`}`
Line 990...	Line 1042...
990	`garmin_read_a1006 ( garmin_unit * garmin )`	1042	`garmin_read_a1006 ( garmin_unit * garmin )`
991	`{`	1043	`{`
992	`garmin_data * d = NULL;`	1044	`garmin_data * d = NULL;`
993	`garmin_list * l = NULL;`	1045	`garmin_list * l = NULL;`
994		1046
-		1047	`if (!garmin) return NULL;`
-		1048
995	`if ( garmin_send_command(garmin,Cmnd_Transfer_Courses) != 0 ) {`	1049	`if ( garmin_send_command(garmin,Cmnd_Transfer_Courses) != 0 ) {`
996	`d = garmin_alloc_data(data_Dlist);`	1050	`d = garmin_alloc_data(data_Dlist);`
997	`l = d->data;`	1051	`l = d->data;`
998	`garmin_list_append(l,garmin_read_records(garmin,`	1052	`garmin_list_append(l,garmin_read_records(garmin,`
999	`Pid_Course,`	1053	`Pid_Course,`
Line 1014...	Line 1068...
1014	`garmin_data *`	1068	`garmin_data *`
1015	`garmin_read_a1007 ( garmin_unit * garmin )`	1069	`garmin_read_a1007 ( garmin_unit * garmin )`
1016	`{`	1070	`{`
1017	`garmin_data * d = NULL;`	1071	`garmin_data * d = NULL;`
1018		1072
-		1073	`if (!garmin) return NULL;`
-		1074
1019	`if ( garmin_send_command(garmin,Cmnd_Transfer_Course_Laps) != 0 ) {`	1075	`if ( garmin_send_command(garmin,Cmnd_Transfer_Course_Laps) != 0 ) {`
1020	`d = garmin_read_records(garmin,`	1076	`d = garmin_read_records(garmin,`
1021	`Pid_Course_Lap,`	1077	`Pid_Course_Lap,`
1022	`(garmin->datatype.course.lap != data_Dnil) ?`	1078	`(garmin->datatype.course.lap != data_Dnil) ?`
1023	`garmin->datatype.course.lap :`	1079	`garmin->datatype.course.lap :`
Line 1035...	Line 1091...
1035	`garmin_data *`	1091	`garmin_data *`
1036	`garmin_read_a1008 ( garmin_unit * garmin )`	1092	`garmin_read_a1008 ( garmin_unit * garmin )`
1037	`{`	1093	`{`
1038	`garmin_data * d = NULL;`	1094	`garmin_data * d = NULL;`
1039		1095
-		1096	`if (!garmin) return NULL;`
-		1097
1040	`if ( garmin_send_command(garmin,Cmnd_Transfer_Course_Points) != 0 ) {`	1098	`if ( garmin_send_command(garmin,Cmnd_Transfer_Course_Points) != 0 ) {`
1041	`d = garmin_read_records(garmin,`	1099	`d = garmin_read_records(garmin,`
1042	`Pid_Course_Point,`	1100	`Pid_Course_Point,`
1043	`garmin->datatype.course.point);`	1101	`garmin->datatype.course.point);`
1044	`}`	1102	`}`
Line 1054...	Line 1112...
1054	`garmin_data *`	1112	`garmin_data *`
1055	`garmin_read_a1009 ( garmin_unit * garmin )`	1113	`garmin_read_a1009 ( garmin_unit * garmin )`
1056	`{`	1114	`{`
1057	`garmin_data * d = NULL;`	1115	`garmin_data * d = NULL;`
1058		1116
-		1117	`if (!garmin) return NULL;`
-		1118
1059	`if ( garmin_send_command(garmin,Cmnd_Transfer_Course_Limits) != 0 ) {`	1119	`if ( garmin_send_command(garmin,Cmnd_Transfer_Course_Limits) != 0 ) {`
1060	`d = garmin_read_singleton(garmin,`	1120	`d = garmin_read_singleton(garmin,`
1061	`Pid_Course_Limits,`	1121	`Pid_Course_Limits,`
1062	`garmin->datatype.course.limits);`	1122	`garmin->datatype.course.limits);`
1063	`}`	1123	`}`
Line 1075...	Line 1135...
1075	`{`	1135	`{`
1076	`garmin_datatype header;`	1136	`garmin_datatype header;`
1077	`garmin_datatype data;`	1137	`garmin_datatype data;`
1078	`garmin_data * d = NULL;`	1138	`garmin_data * d = NULL;`
1079		1139
-		1140	`if (!garmin) return NULL;`
-		1141
1080	`if ( garmin_send_command(garmin,Cmnd_Transfer_Course_Tracks) != 0 ) {`	1142	`if ( garmin_send_command(garmin,Cmnd_Transfer_Course_Tracks) != 0 ) {`
1081		1143
1082	`if ( garmin->datatype.course.track.header != data_Dnil ) {`	1144	`if ( garmin->datatype.course.track.header != data_Dnil ) {`
1083	`header = garmin->datatype.course.track.header;`	1145	`header = garmin->datatype.course.track.header;`
1084	`} else {`	1146	`} else {`
Line 1109...	Line 1171...
1109	`garmin_data *`	1171	`garmin_data *`
1110	`garmin_read_via ( garmin_unit * garmin, appl_protocol protocol )`	1172	`garmin_read_via ( garmin_unit * garmin, appl_protocol protocol )`
1111	`{`	1173	`{`
1112	`garmin_data * data = NULL;`	1174	`garmin_data * data = NULL;`
1113		1175
-		1176	`if (!garmin) return NULL;`
-		1177
1114	`#define CASE_PROTOCOL(x) \`	1178	`#define CASE_PROTOCOL(x) \`
1115	`case appl_A##x: \`	1179	`case appl_A##x: \`
1116	`if ( garmin->verbose != 0 ) { \`	1180	`if ( garmin->verbose != 0 ) { \`
1117	`fprintf(stderr, "[garmin] -> garmin_read_a" #x "\n"); \`	1181	`fprintf(stderr, "[garmin] -> garmin_read_a" #x "\n"); \`
1118	`} \`	1182	`} \`
Line 1156...	Line 1220...
1156	`garmin_data *`	1220	`garmin_data *`
1157	`garmin_get ( garmin_unit * garmin, garmin_get_type what )`	1221	`garmin_get ( garmin_unit * garmin, garmin_get_type what )`
1158	`{`	1222	`{`
1159	`garmin_data * data = NULL;`	1223	`garmin_data * data = NULL;`
1160		1224
-		1225	`if (!garmin) return NULL;`
-		1226
1161	`#define CASE_WHAT(x,y) \`	1227	`#define CASE_WHAT(x,y) \`
1162	`case GET_##x: data = garmin_read_via(garmin,garmin->protocol.y); break`	1228	`case GET_##x: data = garmin_read_via(garmin,garmin->protocol.y); break`
1163		1229
1164	`switch ( what ) {`	1230	`switch ( what ) {`
1165	`CASE_WHAT(WAYPOINTS,waypoint.waypoint);`	1231	`CASE_WHAT(WAYPOINTS,waypoint.waypoint);`
Line 1186...	Line 1252...
1186		1252
1187	`/* Initialize a connection with a Garmin unit. */`	1253	`/* Initialize a connection with a Garmin unit. */`
1188		1254
1189	`int garmin_init(garmin_unit *garmin, int verbose)`	1255	`int garmin_init(garmin_unit *garmin, int verbose)`
1190	`{`	1256	`{`
-		1257	`if (!garmin) return 0;`
-		1258
1191	`memset(garmin, 0, sizeof(garmin_unit));`	1259	`memset(garmin, 0, sizeof(garmin_unit));`
1192	`garmin->verbose = verbose;`	1260	`garmin->verbose = verbose;`
1193	`garmin->usb.fd = -1;`	1261	`garmin->usb.fd = -1;`
1194		1262
1195	`if ( garmin_open(garmin) != 0 )`	1263	`if ( garmin_open(garmin) != 0 )`

Subversion Repositories public

(root)/sportwatcher/trunk/libgarmin/protocol.c – Rev 142 → 246