lowr.c

这是经典的卫星编程应用程序

		fprintf(stderr,"Too Many Route Points, 200 is the maximum supported\n");
		return;
	}
	memcpy(&RteGet,SerialMessage,RteGet.NumOfWaypoints*2+17);
	strcpy(route_comment,(char*)RteGet.Name);
	fprintf(stderr,"R%05d of %d  W%05d of %5d\r",
		route_number,LowrID.NumOfRoutes,0,RteGet.NumOfWaypoints);
	for(i=0;i<RteGet.NumOfWaypoints;i++) {
		fprintf(stderr,"R%05d of %d  W%05d of %5d\r",
			route_number,LowrID.NumOfRoutes,i+1,RteGet.NumOfWaypoints);
		LastCommand=0x0303;
		SendLowrMessage(LastCommand,(BYTE*)&RteGet.Waypoints[i],2,"GetLowrWaypoint,GetLowrRoute");
		GetLowrMessage(1);
		strcpy(buf,Text);
		push_route();
		strcpy(Text,buf);
		push_waypoint();
	}
} // DoLowrRoute

struct IconGet {
	BYTE Reserved;
	short IconNumber;
	long Latitude;
	long Longitude;
	BYTE IconSymbol;
} IconGet;

/* -------------------------------------------------------------------------- */
PROCX void DoNumIcons(void)
{
	memcpy(&IconGet,SerialMessage,3);
} // void DoNumIcons

/* -------------------------------------------------------------------------- */
PROCX void DoLowrIcons(void)
{
	memcpy(&IconGet,SerialMessage,sizeof(struct IconGet));
	record.la=LatMMtoDeg(IconGet.Latitude);
	record.lo=LongMMtoDeg(IconGet.Longitude);
	set_ns();
	record.icon_smbl=convert_from_Lowr(IconGet.IconSymbol);
	record.type='I';
    sprintf(Text,"%c;%d;;",record.type,20000+IconGet.IconNumber+1);
	push_icon();
	fprintf(stderr,"I%05d\r",IconGet.IconNumber+1);
} // void DoLowrIcons
/* -------------------------------------------------------------------------- */
PROCX void GetLowrIcons(void)
{
	short i;
//
	if(LowrID.NumOfIcons<1) {
		fprintf(stderr,"Icons not supported on this Lowrance/Eagle unit\n");
		return;
	}
//
// get number of icons in unit
//
	LastCommand=0x0308;
	SendLowrMessage(LastCommand,(BYTE*)&IconGet,0,"GetNumOfIcons");
	GetLowrMessage(1);
	NumberOfIcons=IconGet.IconNumber;
	if(NumberOfIcons==0) {
		fprintf(stderr,"No Icons to send\n");
		return;
	}
	fprintf(stderr,"I%05d of %5d\r",0,NumberOfIcons);
	for(i=0;i<NumberOfIcons;i++) {
		LastCommand=0x0309;
		SendLowrMessage(LastCommand,(BYTE*)&i,2,"GetLowrIcons");
		GetLowrMessage(1);
	}
} // GetLowrIcons()
/* -------------------------------------------------------------------------- */

PROCX void GetLowrID()
{
	BYTE M[2];

	if(gotID==1) return;
	M[0]=0;
	LastCommand=Login;
	LastLowrLen=0;
	SendLowrMessage(LastCommand, M, LastLowrLen, (char *)"GetLowrIDLogin");
	timeoutp=3;
	GetLowrMessage(0);
	if(COMtimeout==1) return;
	timeoutp=1;
	COMtimeout=0;
	LastCommand=GetProductInfo;
	SendLowrMessage(LastCommand, M, (INT)0, (char *)"GetLowrID");
	GetLowrMessage(1);  // also parses via DoLowrID
	gotID=1;
} // GetLowrID()

PROCX void DoLowrID(void)
{
	memcpy(&LowrID,SerialMessage,sizeof(struct LowrID));
} // DoLowrID()

//struct LowrTrailOriginMem {
//	BYTE Reserved;
//	BYTE PlotTrailNumber;
//	long StructurePointer;
//	short StructureSize;
//} LowrTrailOriginMem;

//struct LowrMemRead {
//	BYTE reserved;
//	union data {
//		struct ptp {				// for reading Plot trail structure
//			long BaseLatitude;
//			long BaseLongitude;
//			long TailAdrPointer;
//			long HeadAdrPointer;
//		} ptp;
//		short data[180];			// for reading 80 shorts
//		BYTE  bytes[260];			// for reading 160 bytes
//	} data;
//} LowrMemRead;
/* -------------------------------------------------------------------------- */
PROCX void SendLowrTracks(INT trk)
{
	unsigned INT trk_index;
	INT track_to_use,i, ii, indx, left;
	long bla, blo;

	struct TrailOrigin {
		BYTE PlotTrailNumber;
		long OriginY;
		long OriginX;
		short NumberOfDeltas;
	} TrailOrigin;

	struct delta {
		BYTE PlotTrailNumber;
		short Number;
		short deltas[40][2];
	} delta;

    count_tracks();
	if(to_lowr_track>LowrID.NumOfPlotTrails) {
		fprintf(stderr,"This unit supports %d trails, not %d\n",LowrID.NumOfPlotTrails,to_lowr_track);
		fprintf(stderr," Sending info to last track: %d\n",to_lowr_track);
		to_lowr_track=LowrID.NumOfPlotTrails;
	}
//
// if user specified we send track 1 or 2 then we will send track 1
//
	if(to_lowr_track!=0) {
		trk=1;
		track_to_use=to_lowr_track-1;
	}
	else {
		track_to_use=trk-1;
	}
	if(trk==1)
		trk_index=0;
	else
		trk_index=trks[trk-1];

//
// Track 'trk' data?
//
    if(trks[trk]>1) {
        fill_track((unsigned INT)(trk_index+1),0);        // get origin of track 'trk'
		TrailOrigin.PlotTrailNumber=track_to_use;
		bla=TrailOrigin.OriginY=LatDegtoMM(record.la);
		blo=TrailOrigin.OriginX=LongDegtoMM(record.lo);
		TrailOrigin.NumberOfDeltas=trks[trk]-1;
		LastCommand=0x0314;
		SendLowrMessage(LastCommand,(BYTE*)&TrailOrigin,sizeof(struct TrailOrigin),"SetPlotTrailOrigin");
		GetLowrMessage(1);
//
// Send the actual deltas
//
		indx=i=0;
		left=trks[trk]-1;
		do {
			if(left>=40) {
				while(indx<=39) {
					fill_track((unsigned INT)(trk_index+i+2),0);
					left--;
					set_sign();
					delta.deltas[indx][0]=LatDegtoMM(record.la) - bla;
					bla=LatDegtoMM(record.la);
					delta.deltas[indx][1]=LongDegtoMM(record.lo) - blo;
					blo=LongDegtoMM(record.lo);
					i++;
					indx++;
				}; // while
				indx=0;
//
// Send array in 40 pair chunks
//
				LastCommand=0x0315;  // Set Plot Trail Deltas
				delta.PlotTrailNumber=track_to_use;
				delta.Number=40;
				SendLowrMessage(LastCommand, (BYTE*)&delta, sizeof(struct delta), "SetPlotTrailDeltas");
				fprintf(stderr,"T%05d Sent\r",i+1);
				GetLowrMessage(1);
			} // if(left>=40);
		} while(left>=40);
//
// Send rest of chunks
//
		memset(&delta.deltas,0,163);
		ii=left;
		indx=0;
		if(left>0) {
			while(left>0) {
				fill_track((unsigned INT)(trk_index+i+2),0);
				left--;
				set_sign();
				delta.deltas[indx][0]=LatDegtoMM(record.la) - bla;
				bla=LatDegtoMM(record.la);
				delta.deltas[indx][1]=LongDegtoMM(record.lo) - blo;
				blo=LongDegtoMM(record.lo);
				i++;
				indx++;
			} // while
//
// Send rest of array
//
			LastCommand=0x0315;  // Set Plot Trail Deltas
			delta.PlotTrailNumber=track_to_use;
			delta.Number=ii;
			SendLowrMessage(LastCommand, (BYTE*)&delta, (INT)(delta.Number*4+3), "SendLowrTrkMemDeltas");
			fprintf(stderr,"T%05d Sent\n",i+1);
			GetLowrMessage(1);
		} // if(left>0);
	}
} // void SendLowrTracks

#define HDR_SIZ 0x10
#define DELTA_SIZ 160
/* -------------------------------------------------------------------------- */
PROCX void SendLowrTracksMem(INT trk)
{
	INT track_to_use,i,left,chnksiz,indx,trk_index=0;
	INT maxdeltas;
	long cksum;
	INT cki, deltas;

	long bla,blo;
	struct SendTrkHdrs {
		long	Adr;
		long	BaseLa;
		long	BaseLo;
		long	Tail;
		long	Head;
	} SendTrkHdrs;

	struct deltasend {
		long  Adr;
		union d {
			short deltas[41][2];
			long  lbytes[41];    // room for 40 deltas + checksum (if needed)
		} d;
	} deltasend;
//
// if user specified we send track 1 or 2 then we will send track 1
//
	count_tracks();
	if(to_lowr_track>LowrID.NumOfPlotTrails) {
		to_lowr_track=LowrID.NumOfPlotTrails;
		fprintf(stderr,"This unit supports %d trails\n",LowrID.NumOfPlotTrails);
		fprintf(stderr," Sending info to last track: %d\n",to_lowr_track);
	}
	if(to_lowr_track!=0) {
		trk=1;
		track_to_use=to_lowr_track;
	}
	else {
		track_to_use=trk;
	}
	if(trk==1)
		trk_index=0;
	else
		trk_index=trks[trk-1];

//
// Track 'trk' data?
//
	if(trks[trk]>1) {
		deltas=trks[trk]-1;  							// how many deltas we sending?
		GetPlotTrailPointer(track_to_use);
		fill_track((unsigned INT)(trk_index+1),0);		// get origin of track 'trk'
		set_sign();
//
// Setup structure values
//
		SendTrkHdrs.BaseLa=swaplongendian(bla=LatDegtoMM(record.la));
		SendTrkHdrs.BaseLo=swaplongendian(blo=LongDegtoMM(record.lo));
		SendTrkHdrs.Tail=swaplongendian(LowrTrailOriginMem.StructurePointer+HDR_SIZ);
		SendTrkHdrs.Head=swaplongendian(LowrTrailOriginMem.StructurePointer+HDR_SIZ+(deltas)*4);
		SendTrkHdrs.Adr=LowrTrailOriginMem.StructurePointer;
		maxdeltas=(LowrTrailOriginMem.StructureSize-HDR_SIZ)/4 - 1;
//
// checksum header
//
		cksum=0;
		cksum+=bla;
		cksum+=blo;
		cksum+=swaplongendian(SendTrkHdrs.Tail);
		cksum+=swaplongendian(SendTrkHdrs.Head);

//
// Write structure values
//
		LastCommand=0x0009;
		SendLowrMessage(LastCommand,(BYTE*)&SendTrkHdrs, HDR_SIZ+4, (char*)"SendLowrTrkHdrs");
		GetLowrMessage(1);
//
// Now we send the deltas.  Up to 40 at a time
//
//
		memset(&deltasend.d.deltas,0,DELTA_SIZ);
		deltasend.Adr=LowrTrailOriginMem.StructurePointer+HDR_SIZ;
		indx=i=0;
		left=deltas;
//
// only send a GPS's track buffer's full, not more
//
		if(left>maxdeltas) {
			left=maxdeltas;
			fprintf(stderr,"Too many plot points. Sending the first %d points.\n",left+1);
		}
		do {
			if(left>=40) {
//
// Fill deltas array
//
				while(indx<=39) {
					fill_track((unsigned INT)(trk_index+i+2),0);
					left--;
					set_sign();
					deltasend.d.deltas[indx][0]=swapshortendian((short)(LatDegtoMM(record.la)-bla));
					bla=LatDegtoMM(record.la);
					deltasend.d.deltas[indx][1]=swapshortendian((short)(LongDegtoMM(record.lo)-blo));
					blo=LongDegtoMM(record.lo);
					i++;
					indx++;
				}; // while
				indx=0;
//
// checksum this chunk
//
				for(cki=0;cki<40;cki++) cksum+=swaplongendian(deltasend.d.lbytes[cki]);
//
// Send array in 40 pair chunks
//
				LastCommand=0x0009;  // write memory
				SendLowrMessage(LastCommand, (BYTE*)&deltasend, DELTA_SIZ+4,"SendLowrTrkMemDeltas");
//
// update display
//
				fprintf(stderr,"T%05d Sent\r",i+1);
				GetLowrMessage(1);
				deltasend.Adr+=DELTA_SIZ;
			} // if(left>=40);
		} while(left>=40);
//
// Send rest of chunks
//
		memset(&deltasend.d.deltas,0,DELTA_SIZ);
		chnksiz=left;
		indx=0;
		if(left>0) {
			while(left>0) {
				fill_track((unsigned INT)(trk_index+i+2),0);
				left--;
				set_sign();
				deltasend.d.deltas[indx][0]=swapshortendian((short)(LatDegtoMM(record.la) - bla));
				bla=LatDegtoMM(record.la);
				deltasend.d.deltas[indx][1]=swapshortendian((short)(LongDegtoMM(record.lo) - blo));
				blo=LongDegtoMM(record.lo);
				i++;
				indx++;
			} // while
//
// checksum this chunk
//
			for(cki=0;cki<chnksiz;cki++) cksum+=swaplongendian(deltasend.d.lbytes[cki]);
//
// Send rest of array
//
			LastCommand=0x0009;  // write memory
			SendLowrMessage(LastCommand,(BYTE*)&deltasend,(INT)(chnksiz*4+4),"SendLowrTrkMemDeltas");
//
// update display
//
			fprintf(stderr,"T%05d Sent\n",i+1);
			GetLowrMessage(1);
		} // if(left>0);
		deltasend.Adr+=(chnksiz*4);
//=======================================================================================
// 
// Send zeroes...
//
		left=maxdeltas-deltas;
		memset(&deltasend.d.deltas,0,DELTA_SIZ);
		fprintf(stderr,"Clearing buffer\n");
		do {
			if(left>=40) {
				fprintf(stderr,"T%05d left\r",left);
				left=left-40;
//
// Send array in 40 pair chunks, all zeroes
//
				LastCommand=0x0009;  // write memory
				SendLowrMessage(LastCommand,(BYTE*)&deltasend,DELTA_SIZ+4,"SendLowrTrkMemDeltas0");
				GetLowrMessage(1);
				deltasend.Adr+=DELTA_SIZ;
			} // if(left>=40);
		} while(left>=40);
//
// Send rest of chunks
//
		fprintf(stderr,"T%05d left\r",left);
		if(left>0) {
//
// Send rest of array and checksum
//
			deltasend.d.lbytes[left]=swaplongendian(cksum);
			LastCommand=0x0009;  // write memory
			SendLowrMessage(LastCommand,(BYTE*)&deltasend,(INT)(left*4+8),"SendLowrTrkMemDeltas02");
			fprintf(stderr,"\n");
			GetLowrMessage(1);
		} // if(left>0);
//=======================================================================================
	} // if(trks[trk]>1)
} // SendLowrTracksMem

struct LowrWPTs {
	short WaypointNumber;
	BYTE Status;
	BYTE IconSymbol;
	long Latitude;  // LONG (Mercator Meter)
	long Longitude; // LONG (Mercator Meter)
	BYTE Name[13];
	long Date;		// seconds since 00:00 January 1, 1992
} LowrWPTs;

/* -------------------------------------------------------------------------- */
//
// Sends the waypoint currently in the record structure to waypoint slot 'no'
// on the GPS
//
// * Note:  unix_time = garmin_time   + 631065600L
//          unix_time = Lowrance_time + 694224000L
//          garmin_time = Lowrance_time + 63158400L
//          Lowrance_time = garmin_time - 63158400L
PROCX void SendLowrWPT(short no)
{
		LastCommand=SendWaypoint;
		LowrWPTs.WaypointNumber=no;
		LowrWPTs.Status=record.status;
		LowrWPTs.IconSymbol=convert_to_Lowr(record.icon_smbl);

		set_sign();  // makes N+ and W+
		LowrWPTs.Latitude=LatDegtoMM(record.la);
		LowrWPTs.Longitude=LongDegtoMM(record.lo); // LWR Wants E+
// blank fill name
		record.ident[13]=0;
		trim(record.ident);
		strcpy((char*)LowrWPTs.Name,(char*)record.ident);
		LowrWPTs.Date = dt2secs((short)gPrefs.offset) - 63158400L;
		SendLowrMessage(LastCommand,(BYTE*)&LowrWPTs,sizeof(struct LowrWPTs),(char *)"SendLowrWPT");
		GetLowrMessage(1);  // get response
} // void SendLowrWPT

/* -------------------------------------------------------------------------- */
PROCX void SendLowrWaypoints(void)
{
   unsigned INT i,cc,inactives,ia=0;
   INT maxw,tosend;

	maxw=LowrID.NumOfWaypoints;
	tosend=waypoints;
	if(maxw<waypoints) {
		fprintf(stderr,"This GPS only supports %d waypoints.\n",maxw);	
		fprintf(stderr,"Sending %d of %d waypoints.\n",maxw,waypoints);
	}
	record.status=1;
	if(maxw<(LwrStartPt+tosend-1)) {
		fprintf(stderr,"Sending too many waypoints to start at #%d\n",LwrStartPt);
		tosend=maxw-LwrStartPt;
		fprintf(stderr,"Sending only the first %d waypoints\n",tosend);
	}
	fprintf(stderr,"W00000 of %d\r",waypoints);
	inactives=LowrID.NumOfWaypoints-tosend-LwrStartPt+1;
	for(i=1;i<=tosend;i++) {
		fprintf(stderr,"W%05d\r",i);
		fill_waypoint_from_push(i,NORMAL_WP,0);
		SendLowrWPT((short)(LwrStartPt+i-2));
		cc=kbraw();
		cc=toupper(cc);
		if(cc=='X') {
    		fprintf(stderr,"\nOperator Exit 2\n");
    		byebye(0);
		} else if(cc=='Y') {
			fprintf(stderr,"\nOperator Abort 2\n");
			goto rtss;
		}
	}
	if(!SendLowrInactives) goto rtss;
	fprintf(stderr,"\nSending Inactives\n");
	fprintf(stderr,"IA%04d of %04d\r",0,inactives);
	record.status=0;
	record.icon_smbl=default_LWR_icon; 					//usually a diamond
	for(i=LwrStartPt+tosend;i<=LowrID.NumOfWaypoints;i++) {
		fprintf(stderr,"IA%04d of %04d\r",++ia,inactives);
		SendLowrWPT((short)(i-1));
		cc=kbraw();
		cc=toupper(cc);
		if(cc=='X') {
    		fprintf(stderr,"\nOperator Exit 3\n");
    		byebye(0);
		} else if(cc=='Y') {
			fprintf(stderr,"\nOperator Abort 3\n");
			goto rtss;
		}
	}
rtss:;
	fprintf(stderr,"\n");
} // void SendLowrWaypoints

/* -------------------------------------------------------------------------- */
PROCX void DoNumGraphSymbols(void)
{
	struct s {
		BYTE a;
		BYTE num;
	} s;
	memcpy(&s,SerialMessage,sizeof(struct s));
	NumOfGraphSymbols=s.num;
} // void DoNumGraphSymbols