comm.java

Java Op Processor java vhdl processor

			m.data[1] = Status.melNr;
			m.data[2] = gpsInfo;
			m.data[3] = lat;
			m.data[4] = lon;
			m.len = 5;
			m.send();
		}
	}

	public static void charlyStatus(int cmd, int val) {

		MsgOut m = MsgOut.getFree(cmd);
		if (m!=null) {
			m.data[0] = Status.strNr;
			m.data[1] = Status.melNr;
			m.data[2] = val;
			m.len = 3;
			m.send();
		}
	}

	public static void melnrCmd(int cmd, int strnr, int melnr) {

		MsgOut m = MsgOut.getFree(cmd);
		if (m!=null) {
			m.data[0] = strnr;
			m.data[1] = melnr;
			m.len = 2;
			m.send();
		}
	}

	public static void simpleCmd(int cmd) {

		MsgOut m = MsgOut.getFree(cmd);
		if (m!=null) {
			m.len = 0;
			m.send();
		}
	}

/* not used for now
	private static Packet head(int cmd) {

		Packet p = Packet.getPacket(Packet.FREE, Packet.ALLOC, ipLink);
		if (p == null) {								// got no free buffer!
			Dbg.wr('!');
			Dbg.wr('b');
			return null;
		}
	
		p.buf[OFF_CMD] = cmd;
		p.buf[OFF_ID] = Timer.us();		// id is timer value
		p.buf[OFF_BGID] = bgid;			// bg263 serial number

		return p;
	}
*/












/***************************************************************/
	private static void ping() {

		MsgOut m = MsgOut.getFree(Cmd.PING);
		if (m!=null) {
			m.data[0] = 0xcafe;		// magic number
			m.len = 1;
			m.send();
			pingOut = true;
		}
Dbg.wr('.');
	}




	public static void mel(int strnr, int melnr) {

		MsgOut m = MsgOut.getFree(Cmd.MLR);
		if (m!=null) {
			m.data[0] = strnr;
			m.data[1] = melnr;
			m.len = 2;
			m.send();
		}
/*
Object o = new Object();
synchronized(o) {
Dbg.wr('\n');
for (int i=0; i<1024; ++i) {
Dbg.intVal(com.jopdesign.sys.Native.rdMem(i));
}
}
*/
	}


	/**
	*	request from FDL.
	*/
	// private static void rqt(Packet p) {
	public static void rqt(Packet p) {

		if (!checkPkt(p)) return;
		int nr = p.buf[Udp.DATA];
Dbg.wr("got cmd ");
Dbg.intVal(p.buf[Udp.DATA]);
/*
for (int i=Udp.DATA; i<(p.len>>2); ++i) {
	Dbg.intVal(p.buf[i]);
}
*/
Dbg.lf();

		if (nr==Cmd.PING) {
			sendPingReply(p);
		} else if (nr==Cmd.DGPS) {
			Gps.dgps(p);
			sendDgpsReply(p);
		} else if (nr==Cmd.SWVER) {
			sendSwverReply(p);
		} else if (nr==Cmd.RESET) {
			sendSimpleReply(p);
			scheduleReset = true;
		} else if (nr==Cmd.ANMOK) {
			Status.anmOk = true;
			sendReply(p);
		} else if (nr==Cmd.FLAN) {
			Status.angabe = p.buf[OFF_DATA+1];
			Status.state = Status.ANGABE;
			sendReply(p);
		} else if (nr==Cmd.FERL) {
			synchronized (Status.dirMutex) {
				// let Logik.check() update the direction
				Status.direction = Gps.DIR_UNKNOWN;
				Status.melNrStart = Status.melNr;
				Status.melNrZiel = p.buf[OFF_DATA+1];
			}
Dbg.wr("FERL ");
Dbg.intVal(Status.melNrStart);
Dbg.intVal(Status.melNrZiel);
Dbg.lf();

			Status.state = Status.ERLAUBNIS;
			Status.sendFerlQuit = true;
			sendReply(p);
		} else if (nr==Cmd.FWR) {
			Status.melNrZiel = Status.melNr;
			Status.state = Status.WIDERRUF;
			sendReply(p);
		} else if (nr==Cmd.ABM) {
			Status.state = Status.ABGEMELDET;
			Status.anmOk = false;
			sendReply(p);
		} else if (nr==Cmd.NOT) {
			Status.melNrZiel = Status.melNr;
			Status.state = Status.NOTHALT;
			sendReply(p);
		} else if (nr==Cmd.DLSTAT) {
			Status.dlType = p.buf[OFF_DATA];
			Status.dlPercent = p.buf[OFF_DATA+1];
			sendSimpleReply(p);
		} else {
			Dbg.wr("unknown cmd\n");
		}
		p.setStatus(Packet.FREE);
	}


	/**
	*	reply from FDL.
	*/
	// private static void rpl(Packet p) {
	public static void rpl(Packet p) {

		if (!checkPkt(p)) return;
		if (!MsgOut.inList(p)) return;

		int nr = p.buf[Udp.DATA];
Dbg.wr("got reply ");
Dbg.intVal(nr);
Dbg.lf();
/*
for (int i=0; i<p.len>>2; ++i) Dbg.intVal(p.buf[i]);
Dbg.lf();
*/
		if (nr==Cmd.PING_RPL) {
			rcvPingReply(p);
		} else if (nr==Cmd.CONN_RPL) {
			// first set dl status and then connOk!
			if (p.buf[OFF_DATA]!=0) Status.download = true;
			Status.dlType = -1;
			Status.dlPercent = -1;
			Status.connOk = true;

		} else if (nr==Cmd.LERN_RPL) {
			Status.lernOk = true;
		} else if (nr==Cmd.VERSCHUB_RPL) {
			Status.von = p.buf[OFF_DATA+1];
			Status.bis = p.buf[OFF_DATA+2];
		} else if (nr==Cmd.ANM_RPL || nr==Cmd.MLR_RPL) {
			;
		} else if (nr==Cmd.ANK_RPL) {
			Status.ankunftOk = true;
		} else if (nr==Cmd.VERL_RPL) {
			Status.verlassenOk = true;
		} else {
			// just ignore it 
		}
		p.setStatus(Packet.FREE);
	}

	private static boolean checkPkt(Packet p) {

stat[2]++;
stat[3] += p.len;
		if (p.len < ((OFF_DATA)<<2)) {		// minimum length
			Status.commErr = 2;
			Dbg.wr('w');
			Dbg.wr('l');
			Dbg.intVal(p.len);
			Dbg.wr('\n');
			p.setStatus(Packet.FREE);		// mark packet free
stat[4]++;
			return false;
		}
		if (p.buf[OFF_CMD]<Cmd.FIRST_CMD || p.buf[OFF_CMD]>Cmd.LAST_CMD) {
//			Status.commErr = 3;
			Dbg.wr('w');
			Dbg.wr('c');
			Dbg.intVal(p.buf[OFF_CMD]);
			Dbg.wr('\n');
			p.setStatus(Packet.FREE);		// mark packet free
stat[4]++;
			return false;
		}
		if (p.buf[OFF_BGID] != bgid) {		// check bgid
			Status.commErr = 4;
			Dbg.wr('w');
			Dbg.wr('i');
			Dbg.intVal(p.buf[OFF_BGID]);
			Dbg.wr('\n');
			p.setStatus(Packet.FREE);		// mark packet free
stat[4]++;
			return false;
		}

		return true;
	}


	/**
	*	a simple reply (without additional data)
	*/
	static void sendReply(Packet p) {

		// get a free packet and set source to LinkLayer
		Packet np = Packet.getPacket(Packet.FREE, Packet.ALLOC, ipLink);
		if (np == null) {								// got no free buffer!
			Dbg.wr('!');
			Dbg.wr('b');
			return;
		}
		np.len = (OFF_DATA)<<2;
		np.buf[OFF_CMD] = p.buf[OFF_CMD]+1;	// reply
		np.buf[OFF_ID] = p.buf[OFF_ID];		// copy id
		np.buf[OFF_BGID] = bgid;			// bg263 serial number
stat[0]++;
stat[1] += np.len;
		Udp.build(np, dst_ip, BG_REPLY);
Dbg.wr("send reply ");
Dbg.intVal(np.buf[OFF_CMD]);
Dbg.lf();


p.setStatus(Packet.FREE);		// mark packet free
// we could reuse p now with changed Udp.java
	}

	public static void sendPingReply(Packet p) {

		// get a free packet and set source to LinkLayer
		Packet np = Packet.getPacket(Packet.FREE, Packet.ALLOC, ipLink);
		if (np == null) {								// got no free buffer!
			Dbg.wr('!');
			Dbg.wr('b');
			return;
		}
		np.len = p.len;
		// TODO I don't like this packet copy
		// Udp swaps fields, TcpIp swaps ip fields and sends it back
		// when p.len != 0.
		// should change this
		for (int i=0; i<p.len>>2; ++i) {
			np.buf[i] = p.buf[i];
		}
		np.buf[OFF_CMD] = Cmd.PING_RPL;		// reply
		np.buf[OFF_BGID] = bgid;			// bg263 serial number
stat[0]++;
stat[1] += np.len;
		Udp.build(np, dst_ip, BG_REPLY);
Dbg.wr("send reply ");
Dbg.intVal(np.buf[OFF_CMD]);
Dbg.lf();

p.setStatus(Packet.FREE);		// mark packet free
// we could reuse p now with changed Udp.java
	}

	public static void sendDgpsReply(Packet p) {

		// get a free packet and set source to LinkLayer
		Packet np = Packet.getPacket(Packet.FREE, Packet.ALLOC, ipLink);
		if (np == null) {					// got no free buffer!
			Dbg.wr('!');
			Dbg.wr('b');
			return;
		}

		np.len = (OFF_DATA+3)<<2;
		np.buf[OFF_CMD] = Cmd.DGPS_RPL;		// reply
		np.buf[OFF_ID] = p.buf[OFF_ID];		// copy id
		np.buf[OFF_BGID] = bgid;			// bg263 serial number
		np.buf[OFF_DATA] = Gps.last_lat;
		np.buf[OFF_DATA+1] = Gps.last_lon;
		np.buf[OFF_DATA+2] = Status.melNr;
stat[0]++;
stat[1] += np.len;
		Udp.build(np, dst_ip, BG_REPLY);
p.setStatus(Packet.FREE);		// mark packet free
// we could reuse p now with changed Udp.java
	}

	public static void sendSwverReply(Packet p) {

		// get a free packet and set source to LinkLayer
		Packet np = Packet.getPacket(Packet.FREE, Packet.ALLOC, ipLink);
		if (np == null) {								// got no free buffer!
			Dbg.wr('!');
			Dbg.wr('b');
			return;
		}
		np.len = (OFF_DATA+1)<<2;
		np.buf[OFF_CMD] = Cmd.SWVER_RPL;	// reply
		np.buf[OFF_ID] = p.buf[OFF_ID];		// copy id
		np.buf[OFF_BGID] = bgid;			// bg263 serial number
		np.buf[OFF_DATA] = (Main.VER_MAJ<<16)+Main.VER_MIN;
stat[0]++;
stat[1] += np.len;
		Udp.build(np, dst_ip, BG_REPLY);
Dbg.wr("send reply ");
Dbg.intVal(np.buf[OFF_CMD]);
Dbg.lf();
p.setStatus(Packet.FREE);		// mark packet free
// we could reuse p now with changed Udp.java
	}

	/**
	*	Send a simple reply without any user data.
	*	Just increment CMD from original packet to get the RPL number.
	*/
	public static void sendSimpleReply(Packet p) {

		// get a free packet and set source to LinkLayer
		Packet np = Packet.getPacket(Packet.FREE, Packet.ALLOC, ipLink);
		if (np == null) {								// got no free buffer!
			Dbg.wr('!');
			Dbg.wr('b');
			return;
		}
		np.len = (OFF_DATA)<<2;
		np.buf[OFF_CMD] = p.buf[OFF_CMD]+1;	// reply
		np.buf[OFF_ID] = p.buf[OFF_ID];		// copy id
		np.buf[OFF_BGID] = bgid;			// bg263 serial number
stat[0]++;
stat[1] += np.len;
		Udp.build(np, dst_ip, BG_REPLY);
Dbg.wr("send reply ");
Dbg.intVal(np.buf[OFF_CMD]);
Dbg.lf();
p.setStatus(Packet.FREE);		// mark packet free
// we could reuse p now with changed Udp.java
	}

	public static void sendAnmOkReply(Packet p) {

		// get a free packet and set source to LinkLayer
		Packet np = Packet.getPacket(Packet.FREE, Packet.ALLOC, ipLink);
		if (np == null) {								// got no free buffer!
			Dbg.wr('!');
			Dbg.wr('b');
			return;
		}
		np.len = (OFF_DATA)<<2;
		np.buf[OFF_CMD] = Cmd.ANMOK_RPL;	// reply
		np.buf[OFF_ID] = p.buf[OFF_ID];		// copy id
		np.buf[OFF_BGID] = bgid;			// bg263 serial number
stat[0]++;
stat[1] += np.len;
		Udp.build(np, dst_ip, BG_REPLY);

Dbg.wr("send reply ");
Dbg.intVal(np.buf[OFF_CMD]);
Dbg.lf();
		Status.anmOk = true;
p.setStatus(Packet.FREE);		// mark packet free
// we could reuse p now with changed Udp.java
	}
/**
*	received reply to ping.
*/
	public static void rcvPingReply(Packet p) {

		if (p.len != ((OFF_DATA+1)<<2)) {
			Dbg.wr('x');
			return;
		}

		int tim = Timer.us()-p.buf[Udp.DATA+1];
		tim /= 1000;		// in ms

		if (p.buf[OFF_DATA] != 0xcafe) {		// check magic
			Dbg.wr('m');
			return;
		}
		Dbg.wr("r ");
		Dbg.intVal(tim);
		Dbg.wr("ms ");
		pingOut = false;

		// upper level frees buffer
	}


	static void timeout() {

		Dbg.wr('.');
		Dbg.wr('t');
		Dbg.wr(' ');
		pingOut = false;
	}

}