fanwuyang
/
SENG302
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/networkingTest' into splitIntoTwoModules

Browse Source 
# Conflicts:
#	mock/src/main/java/seng302/RaceEventMessages/BoatLocationMessage.java
#             Selected copy from splitIntoTwoModules.
main
fjc40 9 years ago
parent 1e3b816ff5 538f1bd6ba
commit 06d786d581
43 changed files with 3229 additions and 50 deletions
Show Stats Download Patch File Download Diff File

71
src/main/java/seng302/Networking/BinaryMesageEncoder.java
Unescape View File

@ -0,0 +1,71 @@
package seng302.Networking;
import seng302.Networking.Utils.MessageType;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.zip.CRC32;
import static seng302.Networking.Utils.ByteConverter.intToBytes;
import static seng302.Networking.Utils.ByteConverter.longToBytes;
import static seng302.Networking.Utils.ByteConverter.shortToBytes;
/**
* Created by hba56 on 21/04/17.
*/
public class BinaryMesageEncoder {
private byte[] fullMessage;
private byte[] header;
private byte[] message;
//private byte[] crc;
private byte headerSync1 = (byte)0x47;
private byte headerSync2 = (byte)0x83;
private byte headerMessageType;
private long headerTimeStamp;
private int headerSourceID;
private short headerMessageLength;
public BinaryMesageEncoder(MessageType headerMessageType, long headerTimeStamp, int headerSourceID, short headerMessageLength, byte[] message){
//set the header
this.headerMessageType = headerMessageType.getValue();
this.headerTimeStamp = headerTimeStamp;
this.headerSourceID = headerSourceID;
this.headerMessageLength = headerMessageLength;
ByteBuffer tempHeaderByteBuffer = ByteBuffer.allocate(15);
tempHeaderByteBuffer.put(this.headerSync1);
tempHeaderByteBuffer.put(this.headerSync2);
tempHeaderByteBuffer.put(this.headerMessageType);
tempHeaderByteBuffer.put(longToBytes(this.headerTimeStamp, 6));
tempHeaderByteBuffer.putInt(this.headerSourceID);
tempHeaderByteBuffer.put(shortToBytes(this.headerMessageLength));
this.header = tempHeaderByteBuffer.array();
//set the message
this.message = message;
//set full message
ByteBuffer tempMessageByteBuffer = ByteBuffer.allocate(19+this.headerMessageLength);
tempMessageByteBuffer.put(this.header);
tempMessageByteBuffer.put(this.message);
CRC32 crc = new CRC32();
crc.reset();
byte[] messageAndHeader = new byte[this.header.length + this.message.length];
System.arraycopy(this.header, 0, messageAndHeader, 0, this.header.length);
System.arraycopy(this.message, 0, messageAndHeader, this.header.length, this.message.length);
crc.update(messageAndHeader);
//System.out.println(Arrays.toString(messageAndHeader));
tempMessageByteBuffer.put(intToBytes((int) crc.getValue()));
this.fullMessage = tempMessageByteBuffer.array();
}
public byte[] getFullMessage() {
return fullMessage;
}
}

165
src/main/java/seng302/Networking/BinaryMessageDecoder.java
Unescape View File

@ -0,0 +1,165 @@
package seng302.Networking;
import seng302.Networking.MessageDecoders.*;
import seng302.Networking.Utils.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
import java.util.zip.CRC32;
/**
* Created by hba56 on 21/04/17.
*/
public class BinaryMessageDecoder {
private byte[] fullMessage;
private byte[] header;
private byte[] message;
private byte[] crc;
private byte headerSync1;
private byte headerSync2;
private byte headerMessageType;
private byte[] headerTimeStamp;
private byte[] headerSourceID;
private byte[] headerMessageLength;
public BinaryMessageDecoder(byte[] fullMessage) {
this.fullMessage = fullMessage;
}
public AC35Data decode() throws IndexOutOfBoundsException{
//get the header
this.header = Arrays.copyOfRange(this.fullMessage, 0, 15);
this.headerSync1 = this.header[0];
this.headerSync2 = this.header[1];
this.headerMessageType = this.header[2];
this.headerTimeStamp = Arrays.copyOfRange(this.header, 3, 9);
this.headerSourceID = Arrays.copyOfRange(this.header, 9, 13);
this.headerMessageLength = Arrays.copyOfRange(this.header, 13, 15);
if (15 > this.fullMessage.length - 4){
//System.err.println("Message is too short.");
return null;
}
//get message
this.message = Arrays.copyOfRange(this.fullMessage, 15, this.fullMessage.length - 4);
//get crc
this.crc = Arrays.copyOfRange(this.fullMessage, this.fullMessage.length - 4, fullMessage.length);
CRC32 crc = new CRC32();
crc.reset();
crc.update(this.fullMessage);
//run through the checks
if (this.message.length != ByteConverter.bytesToShort(this.headerMessageLength)){//keep like this - hba65
System.err.println("message length in header does not equal the message length");
System.err.println("message length in header: " + ByteConverter.bytesToInt(this.headerMessageLength));
System.err.println("message length: " + this.message.length);
return null;
}else if(this.headerSync1 != 0x47){
System.err.println("Sync byte 1 is wrong: " + this.headerSync1);
return null;
}else if(this.headerSync2 !=(byte) 0x83){
System.err.println("Sync byte 2 is wrong: " + this.headerSync2);
return null;
}/*else if(crc.getValue() != 0){
//todo check crc
System.err.println("CRC is not 0 and is instead:" + crc.getValue());
return;
}*/
MessageType mType = MessageType.valueOf(this.headerMessageType);
AC35Data data = null;
switch(mType){
case HEARTBEAT:
// System.out.println("HeartBeat Message!");
data = new Heartbeat();
break;
case RACESTATUS:
// System.out.println("Race Status Message");
RaceStatusDecoder rsdecoder = new RaceStatusDecoder(this.message);
data = new RaceStatus(rsdecoder.getTime(), rsdecoder.getRace(), rsdecoder.getRaceState(), rsdecoder.getStartTime(), rsdecoder.getRaceWindDir(), rsdecoder.getRaceWindSpeed(), rsdecoder.getRaceType(), rsdecoder.getBoats());
break;
case DISPLAYTEXTMESSAGE:
// System.out.println("Display Text Message");
//no decoder for this.
break;
case XMLMESSAGE:
// System.out.println("XML Message!");
XMLMessageDecoder xmdecoder = new XMLMessageDecoder(this.message);
xmdecoder.decode();
data = new XMLMessage(xmdecoder.getAckNumber(), xmdecoder.getTimeStamp(), xmdecoder.getXmlMsgSubType(), xmdecoder.getSequenceNumber(), xmdecoder.getXmlMsgLength(), xmdecoder.getXmlMessageInputSource());
break;
case RACESTARTSTATUS:
// System.out.println("Race Start Status Message");
RaceStartStatusDecoder rssDecoder = new RaceStartStatusDecoder(this.message);
data = new RaceStartStatus(rssDecoder.getTime(), rssDecoder.getAck(), rssDecoder.getStartTime(), rssDecoder.getRaceID(), rssDecoder. getNotification());
break;
case YACHTEVENTCODE:
// System.out.println("Yacht Action Code!");
//no decoder
break;
case YACHTACTIONCODE:
// System.out.println("Yacht Action Code!");
//no decoder
break;
case CHATTERTEXT:
// System.out.println("Chatter Text Message!");
//no decoder
break;
case BOATLOCATION:
// System.out.println("Boat Location Message!");
BoatLocationDecoder blDecoder = new BoatLocationDecoder(this.message);
data = blDecoder.getMessage();
break;
case MARKROUNDING:
// System.out.println("Mark Rounding Message!");
MarkRoundingDecoder mrDecoder = new MarkRoundingDecoder(this.message);
data = mrDecoder.getMarkRounding();
break;
case COURSEWIND:
// System.out.println("Couse Wind Message!");
CourseWindDecoder cwDecoder = new CourseWindDecoder(this.message);
data =new CourseWinds(cwDecoder.getMessageVersionNumber(), cwDecoder.getByteWindID(), cwDecoder.getLoopMessages());
break;
case AVGWIND:
// System.out.println("Average Wind Message!");
AverageWindDecoder awDecoder = new AverageWindDecoder(this.message);
data = awDecoder.getAverageWind();
break;
default:
// System.out.println("Broken Message!");
break;
}
return data;
}
public long getTimeStamp() {
return ByteConverter.bytesToLong(this.headerTimeStamp);
}
public int getSourceID() {
return ByteConverter.bytesToInt(this.headerSourceID, ByteOrder.BIG_ENDIAN);
}
public short getMessageLength() {
return ByteConverter.bytesToShort(this.headerMessageLength);
}
public int getMessageType(){
return (int) this.headerMessageType;
}
public byte[] getMessage() {
return message;
}
}

55
src/main/java/seng302/Networking/MessageDecoders/AverageWindDecoder.java
Unescape View File

@ -0,0 +1,55 @@
package seng302.Networking.MessageDecoders;
import seng302.Networking.Utils.AverageWind;
import seng302.Networking.Utils.ByteConverter;
import java.util.Arrays;
/**
* Created by hba56 on 23/04/17.
*/
public class AverageWindDecoder {
byte messageVersionNumber;
byte[] byteTime;
byte[] byteRawPeriod;
byte[] byteRawSpeed;
byte[] bytePeriod2;
byte[] byteSpeed2;
byte[] bytePeriod3;
byte[] byteSpeed3;
byte[] bytePeriod4;
byte[] byteSpeed4;
AverageWind averageWind;
public AverageWindDecoder(byte[] encodedAverageWind) {
messageVersionNumber = encodedAverageWind[0];
byteTime = Arrays.copyOfRange(encodedAverageWind, 1, 7);
byteRawPeriod = Arrays.copyOfRange(encodedAverageWind, 7, 9);
byteRawSpeed = Arrays.copyOfRange(encodedAverageWind, 9, 11);
bytePeriod2 = Arrays.copyOfRange(encodedAverageWind, 11, 13);
byteSpeed2 = Arrays.copyOfRange(encodedAverageWind, 13, 15);
bytePeriod3 = Arrays.copyOfRange(encodedAverageWind, 15, 17);
byteSpeed3 = Arrays.copyOfRange(encodedAverageWind, 17, 19);
bytePeriod4 = Arrays.copyOfRange(encodedAverageWind, 19, 21);
byteSpeed4 = Arrays.copyOfRange(encodedAverageWind, 21, 23);
int msgNum = ByteConverter.bytesToInt(messageVersionNumber);
long lngTime = ByteConverter.bytesToLong(byteTime);
int intRawPeriod = ByteConverter.bytesToInt(byteRawPeriod);
int intRawSpeed = ByteConverter.bytesToInt(byteRawSpeed);
int intPeriod2 = ByteConverter.bytesToInt(bytePeriod2);
int intSpeed2 = ByteConverter.bytesToInt(byteSpeed2);
int intPeriod3 = ByteConverter.bytesToInt(bytePeriod3);
int intSpeed3 = ByteConverter.bytesToInt(byteSpeed3);
int intPeriod4 = ByteConverter.bytesToInt(bytePeriod4);
int intSpeed4 = ByteConverter.bytesToInt(byteSpeed4);
this.averageWind = new AverageWind(msgNum, lngTime, intRawPeriod, intRawSpeed, intPeriod2, intSpeed2, intPeriod3, intSpeed3, intPeriod4, intSpeed4);
}
public AverageWind getAverageWind() {
return averageWind;
}
}

82
src/main/java/seng302/Networking/MessageDecoders/BoatLocationDecoder.java
Unescape View File

@ -0,0 +1,82 @@
package seng302.Networking.MessageDecoders;
import seng302.Networking.Utils.BoatLocationMessage;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
import static seng302.Networking.Utils.ByteConverter.*;
/**
* Created by hba56 on 21/04/17.
*/
public class BoatLocationDecoder {
private byte messageVersionNumber;
private byte[] time;
private byte[] sourceID;
private byte[] seqNum;
private byte deviceType;
private byte[] latitude;
private byte[] longitude;
private byte[] altitude;
private byte[] heading;
private byte[] pitch;
private byte[] roll;
private byte[] boatSpeed;
private byte[] cog;
private byte[] sog;
private byte[] apparentWindSpeed;
private byte[] apparentWindAngle;
private byte[] trueWindSpeed;
private byte[] trueWindDirection;
private byte[] trueWindAngle;
private byte[] currentDrift;
private byte[] currentSet;
private byte[] rudderAngle;
private BoatLocationMessage message;
public BoatLocationDecoder(byte[] encodedBoatLocation) {
messageVersionNumber = encodedBoatLocation[0];
time = Arrays.copyOfRange(encodedBoatLocation, 1, 7);
sourceID = Arrays.copyOfRange(encodedBoatLocation, 7, 11);
seqNum = Arrays.copyOfRange(encodedBoatLocation, 11, 15);
deviceType = encodedBoatLocation[15];
latitude = Arrays.copyOfRange(encodedBoatLocation, 16, 20);
longitude = Arrays.copyOfRange(encodedBoatLocation,20, 24);
altitude = Arrays.copyOfRange(encodedBoatLocation, 24, 28);
heading = Arrays.copyOfRange(encodedBoatLocation,28, 30);
pitch =Arrays.copyOfRange(encodedBoatLocation,30,32);
roll = Arrays.copyOfRange(encodedBoatLocation,32,34);
boatSpeed = Arrays.copyOfRange(encodedBoatLocation,34,36);
cog = Arrays.copyOfRange(encodedBoatLocation,36,38);
sog = Arrays.copyOfRange(encodedBoatLocation,38, 40);
apparentWindSpeed = Arrays.copyOfRange(encodedBoatLocation, 40, 42);
apparentWindAngle = Arrays.copyOfRange(encodedBoatLocation, 42, 44);
trueWindSpeed = Arrays.copyOfRange(encodedBoatLocation,44, 46);
trueWindDirection = Arrays.copyOfRange(encodedBoatLocation, 46, 48);
trueWindAngle = Arrays.copyOfRange(encodedBoatLocation, 48, 50);
currentDrift = Arrays.copyOfRange(encodedBoatLocation,50,52);
currentSet = Arrays.copyOfRange(encodedBoatLocation,52, 54);
rudderAngle = Arrays.copyOfRange(encodedBoatLocation,54, 56);
message = new BoatLocationMessage(messageVersionNumber, bytesToLong(time),
bytesToInt(sourceID), bytesToInt(seqNum),
deviceType, bytesToInt(latitude),
bytesToInt(longitude), bytesToInt(altitude),
bytesToInt(heading), bytesToShort(pitch),
bytesToShort(roll), bytesToInt(boatSpeed),
bytesToInt(cog), bytesToInt(sog),
bytesToInt(apparentWindSpeed), bytesToShort(apparentWindAngle),
bytesToInt(trueWindSpeed), bytesToShort(trueWindDirection),
bytesToShort(trueWindAngle), bytesToInt(currentDrift),
bytesToInt(currentSet), bytesToShort(rudderAngle)
);
}
public BoatLocationMessage getMessage() {
return message;
}
}

63
src/main/java/seng302/Networking/MessageDecoders/CourseWindDecoder.java
Unescape View File

@ -0,0 +1,63 @@
package seng302.Networking.MessageDecoders;
import seng302.Networking.Utils.CourseWind;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Arrays;
import static seng302.Networking.Utils.ByteConverter.*;
/**
* Created by hba56 on 23/04/17.
*/
public class CourseWindDecoder {
byte messageVersionNumber;
byte byteWindID;
byte loopCount;
ArrayList<CourseWind> loopMessages = new ArrayList();
public CourseWindDecoder(byte[] encodedCourseWind) {
final int lengthInBytesOfMessages = 20;
messageVersionNumber = encodedCourseWind[0];
byteWindID = encodedCourseWind[1];
loopCount = encodedCourseWind[2];
byte[] loopMessagesBytes = Arrays.copyOfRange(encodedCourseWind, 3, lengthInBytesOfMessages*loopCount+3);
int messageLoopIndex = 0;
for (int i=0; i < loopCount; i++) {
byte[] messageBytes = Arrays.copyOfRange(loopMessagesBytes, messageLoopIndex, messageLoopIndex+20);
ArrayList test = new ArrayList();
byte[] windId = Arrays.copyOfRange(messageBytes, 0, 1);
byte[] time = Arrays.copyOfRange(messageBytes, 1, 7);
byte[] raceID = Arrays.copyOfRange(messageBytes, 7, 11);
byte[] windDirection = Arrays.copyOfRange(messageBytes, 11, 13);
byte[] windSpeed = Arrays.copyOfRange(messageBytes, 13, 15);
byte[] bestUpwindAngle = Arrays.copyOfRange(messageBytes, 15, 17);
byte[] bestDownwindAngle = Arrays.copyOfRange(messageBytes, 17, 19);
byte[] flags = Arrays.copyOfRange(messageBytes, 19, 20);
CourseWind message = new CourseWind(windId[0], bytesToLong(time),
bytesToInt(raceID), bytesToInt(windDirection),
bytesToInt(windSpeed), bytesToInt(bestUpwindAngle),
bytesToInt(bestDownwindAngle), flags[0]);
loopMessages.add(message);
messageLoopIndex += 20;
}
}
public ArrayList<CourseWind> getLoopMessages() {
return loopMessages;
}
public byte getMessageVersionNumber() {
return messageVersionNumber;
}
public byte getByteWindID() {
return byteWindID;
}
}

51
src/main/java/seng302/Networking/MessageDecoders/MarkRoundingDecoder.java
Unescape View File

@ -0,0 +1,51 @@
package seng302.Networking.MessageDecoders;
import seng302.Networking.Utils.ByteConverter;
import seng302.Networking.Utils.MarkRounding;
import java.util.Arrays;
/**
* Created by hba56 on 23/04/17.
*/
public class MarkRoundingDecoder {
byte messageVersionNumber;
byte[] byteTime;
byte[] byteAck;
byte[] byteRaceID;
byte[] byteSourceID;
byte byteBoatStatus;
byte byteRoundingSide;
byte byteMarkType;
byte byteMarkID;
MarkRounding markRounding;
public MarkRoundingDecoder(byte[] encodedMarkRounding) {
messageVersionNumber = encodedMarkRounding[0];
byteTime = Arrays.copyOfRange(encodedMarkRounding, 1, 7);
byteAck = Arrays.copyOfRange(encodedMarkRounding, 7, 9);
byteRaceID = Arrays.copyOfRange(encodedMarkRounding, 9, 13);
byteSourceID = Arrays.copyOfRange(encodedMarkRounding, 13, 17);
byteBoatStatus = encodedMarkRounding[17];
byteRoundingSide = encodedMarkRounding[18];
byteMarkType = encodedMarkRounding[19];
byteMarkID = encodedMarkRounding[20];
int intMsgVer = ByteConverter.bytesToInt(messageVersionNumber);
long lngTime = ByteConverter.bytesToLong(byteTime);
int intAck = ByteConverter.bytesToInt(byteAck);
int intRaceID = ByteConverter.bytesToInt(byteRaceID);
int intSourceID = ByteConverter.bytesToInt(byteSourceID);
int intBoatState = ByteConverter.bytesToInt(byteBoatStatus);
int intRoundingSide = ByteConverter.bytesToInt(byteRoundingSide);
int intMarkType = ByteConverter.bytesToInt(byteMarkType);
int intMarkID = ByteConverter.bytesToInt(byteMarkID);
markRounding = new MarkRounding(intMsgVer, lngTime, intAck, intRaceID, intSourceID, intBoatState, intRoundingSide, intMarkType, intMarkID);
}
public MarkRounding getMarkRounding() {
return markRounding;
}
}

69
src/main/java/seng302/Networking/MessageDecoders/RaceStartStatusDecoder.java
Unescape View File

@ -0,0 +1,69 @@
package seng302.Networking.MessageDecoders;
import seng302.Model.BoatInRace;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Arrays;
import static seng302.Networking.Utils.ByteConverter.*;
/**
* Created by hba56 on 21/04/17.
*/
public class RaceStartStatusDecoder {
private byte messageVersion;
private byte[] timestamp;
private byte[] ackNumber;
private byte[] raceStartTime;
private byte[] raceIdentifier;
private byte notificationType;
private long time;
private short ack;
private long startTime;
private int raceID;
private char notification;
public RaceStartStatusDecoder(byte[] encodedRaceStartStatus) {
messageVersion = encodedRaceStartStatus[0];
timestamp = Arrays.copyOfRange(encodedRaceStartStatus, 1, 7);
ackNumber = Arrays.copyOfRange(encodedRaceStartStatus, 7, 9);
raceStartTime = Arrays.copyOfRange(encodedRaceStartStatus, 9, 15);
raceIdentifier = Arrays.copyOfRange(encodedRaceStartStatus, 15, 19);
notificationType = encodedRaceStartStatus[19];
time = bytesToLong(timestamp);
ack = bytesToShort(ackNumber);
startTime = bytesToLong(raceStartTime);
raceID = bytesToInt(raceIdentifier);
notification = bytesToChar(notificationType);
}
public byte getMessageVersion() {
return messageVersion;
}
public long getTime() {
return time;
}
public short getAck() {
return ack;
}
public long getStartTime() {
return startTime;
}
public int getRaceID() {
return raceID;
}
public char getNotification() {
return notification;
}
}

119
src/main/java/seng302/Networking/MessageDecoders/RaceStatusDecoder.java
Unescape View File

@ -0,0 +1,119 @@
package seng302.Networking.MessageDecoders;
import seng302.Networking.Utils.BoatStatus;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Arrays;
import static seng302.Networking.Utils.ByteConverter.*;
/**
* Created by hba56 on 21/04/17.
*/
public class RaceStatusDecoder {
private byte versionNum;
private byte[] timeBytes;
private byte[] raceID;
private byte raceStatus;
private byte[] expectedStart;
private byte[] raceWind;
private byte[] windSpeed;
private byte numBoats;
private byte bytesRaceType;
private byte[] boatsBytes;
private long time;
private int race;
private int raceState;
private long startTime;
private int raceWindDir;
private short raceWindSpeed;
private int numberOfBoats;
private int raceType;
private ArrayList<BoatStatus> boats = new ArrayList<>();
public RaceStatusDecoder(byte[] encodedRaceStatus){
versionNum = encodedRaceStatus[0];
timeBytes = Arrays.copyOfRange(encodedRaceStatus, 1, 7);
raceID = Arrays.copyOfRange(encodedRaceStatus, 7, 11);
raceStatus = encodedRaceStatus[11];
expectedStart = Arrays.copyOfRange(encodedRaceStatus, 12, 18);
raceWind = Arrays.copyOfRange(encodedRaceStatus, 18, 20);
windSpeed = Arrays.copyOfRange(encodedRaceStatus, 20, 22);
numBoats = encodedRaceStatus[22];
bytesRaceType = encodedRaceStatus[23];
boatsBytes = Arrays.copyOfRange(encodedRaceStatus, 24, 25+20*this.numBoats);
time = bytesToLong(timeBytes);
race = bytesToInt(raceID);
raceState = bytesToInt(raceStatus);
startTime = bytesToLong(expectedStart);
raceWindDir = bytesToInt(raceWind);
raceWindSpeed = bytesToShort(windSpeed);
numberOfBoats = bytesToInt(numBoats);
int boatLoopIndex = 0;
for (int i=0; i < numberOfBoats; i++) {
byte[] boatBytes = Arrays.copyOfRange(boatsBytes, boatLoopIndex, boatLoopIndex+20);
byte[] sourceID = Arrays.copyOfRange(boatBytes, 1, 5);
byte boatStatus = boatBytes[5];
byte legNumber = boatBytes[6];
byte numPenaltiesAwarded = boatBytes[7];
byte numPenaltiesServed = boatBytes[8];
byte[] estTimeAtNextMark = Arrays.copyOfRange(boatBytes, 9, 15);
byte[] estTimeAtFinish = Arrays.copyOfRange(boatBytes, 15, 20);
BoatStatus boat = new BoatStatus(bytesToInt(sourceID),boatStatus,
legNumber, numPenaltiesAwarded, numPenaltiesServed,
bytesToLong(estTimeAtNextMark), bytesToLong(estTimeAtFinish));
boats.add(boat);
boatLoopIndex += 20;
}
}
public byte getVersionNum() {
return versionNum;
}
public long getTime() {
return time;
}
public int getRace() {
return race;
}
public int getRaceState() {
return raceState;
}
public long getStartTime() {
return startTime;
}
public int getRaceWindDir() {
return raceWindDir;
}
public short getRaceWindSpeed() {
return raceWindSpeed;
}
public int getNumberOfBoats() {
return numberOfBoats;
}
public int getRaceType() {
return raceType;
}
public ArrayList<BoatStatus> getBoats() {
return boats;
}
}

89
src/main/java/seng302/Networking/MessageDecoders/XMLMessageDecoder.java
Unescape View File

@ -0,0 +1,89 @@
package seng302.Networking.MessageDecoders;
import org.xml.sax.InputSource;
import java.io.StringReader;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
import static seng302.Networking.Utils.ByteConverter.bytesToLong;
/**
* Created by hba56 on 20/04/17.
*/
public class XMLMessageDecoder {
private byte messageVersionNumber;
private short ackNumber;
private long timeStamp;
private byte xmlMsgSubType;
private short sequenceNumber;
private short xmlMsgLength;
private String xmlMessage;
private byte[] bytes;
public XMLMessageDecoder(byte[] bytes) {
this.bytes = bytes;
}
public void decode(){
byte[] ackNumberBytes = Arrays.copyOfRange(bytes, 1, 3);
byte[] timeStampBytes = Arrays.copyOfRange(bytes, 3, 9);
byte[] sequenceNumberBytes = Arrays.copyOfRange(bytes, 10, 12);
byte[] xmlMsgLengthBytes = Arrays.copyOfRange(bytes, 12, 14);
byte[] xmlMessagebytes = Arrays.copyOfRange(bytes, 14, bytes.length);
this.xmlMsgSubType = bytes[9];
this.messageVersionNumber = bytes[0];
this.ackNumber = bytesToShort(ackNumberBytes);
this.timeStamp = bytesToLong(timeStampBytes);
this.sequenceNumber = bytesToShort(sequenceNumberBytes);
this.xmlMsgLength = bytesToShort(xmlMsgLengthBytes);
this.xmlMessage = new String(xmlMessagebytes);
}
private short bytesToShort(byte[] bytesShort){
ByteBuffer byteBuffer = ByteBuffer.allocate(2);
byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
byteBuffer.put(bytesShort[0]);
byteBuffer.put(bytesShort[1]);
short shortVal = byteBuffer.getShort(0);
return shortVal;
}
public byte getMessageVersionNumber() {
return messageVersionNumber;
}
public short getAckNumber() {
return ackNumber;
}
public long getTimeStamp() {
return timeStamp;
}
public byte getXmlMsgSubType() {
return xmlMsgSubType;
}
public short getSequenceNumber() {
return sequenceNumber;
}
public short getXmlMsgLength() {
return xmlMsgLength;
}
/**
* this will be used latter for the vis
* @return xml string as inputsource
*/
public InputSource getXmlMessageInputSource() {
InputSource is = new InputSource(new StringReader(xmlMessage));
return is;
}
}

286
src/main/java/seng302/Networking/MessageEncoders/RaceVisionByteEncoder.java
Unescape View File

@ -0,0 +1,286 @@
package seng302.Networking.MessageEncoders;
import seng302.Model.BoatInRace;
import seng302.Networking.Utils.BoatLocationMessage;
import seng302.Networking.Utils.CourseWind;
import seng302.Networking.Utils.RaceMessage;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import static seng302.Networking.Utils.ByteConverter.*;
/**
* Created by fwy13 on 19/04/17.
*/
public class RaceVisionByteEncoder {
public byte[] heartBeat(int seq){
ByteBuffer heartBeat = ByteBuffer.allocate(4);
heartBeat.put(intToBytes(seq));
byte [] result = heartBeat.array();
return result;
}
public byte[] raceStatus(long time, int race, int raceState, long startTime, short raceWindDir, short raceWindSpeed, int raceType, ArrayList<BoatInRace> boats){
ByteBuffer raceStatusMessage = ByteBuffer.allocate(24 + 20*boats.size());
//Version Number 1 bytes
byte versionNum = 0b10; //this changes with the pdf. (2)
byte[] timeBytes = longToBytes(time, 6);//time (6 bytes)
byte[] raceID = ByteBuffer.allocate(4).put(intToBytes(race)).array();//race identifier incase multiple races are going at once.
byte[] raceStatus = intToBytes(raceState, 1);//race status 0 - 10
byte[] expectedStart = longToBytes(startTime, 6);//number of milliseconds from Jan 1, 1970 for when the data is valid
byte[] raceWind = ByteBuffer.allocate(2).put(shortToBytes(raceWindDir)).array();//North = 0x0000 East = 0x4000 South = 0x8000
byte[] windSpeed = ByteBuffer.allocate(2).put(shortToBytes(raceWindSpeed)).array();//mm/sec
byte[] numBoats = intToBytes(boats.size(), 1);
byte[] bytesRaceType = intToBytes(raceType, 1);//1 match race, 2 fleet race
raceStatusMessage.put(versionNum);
raceStatusMessage.put(timeBytes);
raceStatusMessage.put(raceID);
raceStatusMessage.put(raceStatus);
raceStatusMessage.put(expectedStart);
raceStatusMessage.put(raceWind);
raceStatusMessage.put(windSpeed);
raceStatusMessage.put(numBoats);
raceStatusMessage.put(bytesRaceType);
for (int i = 0; i < boats.size(); i++){
int sourceID = 0; //TODO use boats source id.
byte[] legNum = intToBytes(boats.get(i).getCurrentLeg().getLegNumber(), 1);
byte[] numPenalties = intToBytes(0, 1); //TODO use boats in race penalties class
byte[] numPenaltiesServed = intToBytes(0, 1);//TODO use boats in race penalites served.
byte[] estNextMarkTime = longToBytes((long)0, 6);//TODO use boats estimated time to next mark.
byte[] estFinishTime = longToBytes((long) 0, 6);//TODO use boats estimated time to the finish.
raceStatusMessage.put(intToBytes(sourceID));
raceStatusMessage.put(legNum);
raceStatusMessage.put(numPenalties);
raceStatusMessage.put(numPenaltiesServed);
raceStatusMessage.put(estNextMarkTime);
raceStatusMessage.put(estFinishTime);
}
return raceStatusMessage.array();
}
public byte[] displayTextMessage(RaceMessage[] message){
//ByteBuffer result = ByteBuffer.allocate(4 + numLines * 32);
int messageVersionNumber = 0b1;//version number
short ackNum = 0;//no clue what this does just a placeholder for 2 bytes.
byte[] messLines = intToBytes(message.length, 1);
// result.putInt(messageVersionNumber);
// result.putShort(ackNum);
// result.put(messLines);
ArrayList<byte[]> messages = new ArrayList<byte[]>();
int size = 4;
for (int i = 0; i < message.length; i ++){
int messageLen = message[i].getMessageText().getBytes().length;
byte[] messageAsBytes = message[i].getMessageText().getBytes();
if (messageLen < 30){
messageLen = 30;
}
ByteBuffer mess = ByteBuffer.allocate(2 + messageLen);
mess.put(intToBytes(message[i].getLineNumber(), 1));
mess.put(intToBytes(messageLen, 1));
for (int j = 0; j < messageLen; j ++){
mess.put(messageAsBytes[j]);
}
messages.add(mess.array());
size += 2 + messageLen;
}
ByteBuffer result = ByteBuffer.allocate(size);
result.put(intToBytes(messageVersionNumber, 1));
result.putShort(ackNum);
result.put(messLines);
for(byte[] mess: messages){
result.put(mess);
}
return result.array();
}
public byte[] raceStartStatus(long time, short ack, long startTime, int raceID, char notification){
int messageVersion = 0b1;
byte[] timestamp = longToBytes(time, 6);
byte[] ackNumber = intToBytes(ack, 2);
byte[] raceStartTime = longToBytes(startTime, 6);
int raceIdentifier = raceID;
byte[] notificationType = intToBytes(notification, 1);
ByteBuffer result = ByteBuffer.allocate(20);
result.put(intToBytes(messageVersion, 1));
result.put(timestamp);
result.put(ackNumber);
result.put(raceStartTime);
result.put(intToBytes(raceIdentifier));
result.put(notificationType);
return result.array();
}
public byte[] yachtEventCode(long time, short acknowledgeNumber, int raceID, int destSourceID, int incidentID,
int eventID){
int messageVersion = 0b10;
byte[] encodeTime = longToBytes(time, 6);
short ackNum = acknowledgeNumber;
int raceUID = raceID;//TODO chekc if this is an into for a 4 char string.
int destSource = destSourceID;
int incident = incidentID;
byte[] event = intToBytes(eventID, 1);
ByteBuffer result = ByteBuffer.allocate(22);
result.put(intToBytes(messageVersion, 1));
result.put(encodeTime);
result.putShort(ackNum);
result.put(intToBytes(raceUID));
result.put(intToBytes(destSource));
result.put(intToBytes(incident));
result.put(event);
return result.array();
}
public byte[] chatterText(int messageType, String message){
int messageVersion = 0b1;
byte[] type = intToBytes(messageType, 1);
byte[] text = message.getBytes();
byte[] length = intToBytes(text.length, 1);
ByteBuffer result = ByteBuffer.allocate(3 + text.length);
result.put(intToBytes(messageVersion, 1));
result.put(type);
result.put(length);
result.put(text);
return result.array();
}
public byte[] boatLocation(BoatLocationMessage boatLocationMessage){
int messageVersionNumber = 0b1;
byte[] time = longToBytes(boatLocationMessage.getTime(), 6);
byte[] sourceID = intToBytes(boatLocationMessage.getSourceID(), 4);
byte[] seqNum = intToBytes(boatLocationMessage.getSequenceNumber(), 4);
byte[] deviceType = intToBytes(boatLocationMessage.getDeviceType(), 1);
byte[] latitude = intToBytes(boatLocationMessage.getLatitude(), 4);
byte[] longitude = intToBytes(boatLocationMessage.getLongitude(), 4);
byte[] altitude = intToBytes(boatLocationMessage.getAltitude(), 4);
byte[] heading = intToBytes(boatLocationMessage.getHeading(), 2);
byte[] pitch = intToBytes(boatLocationMessage.getPitch(), 2);
byte[] roll = intToBytes(boatLocationMessage.getRoll(), 2);
byte[] boatSpeed = intToBytes(boatLocationMessage.getBoatSpeed(), 2);
byte[] cog = intToBytes(boatLocationMessage.getBoatCOG(), 2);
byte[] sog = intToBytes(boatLocationMessage.getBoatSOG(), 2);
byte[] apparentWindSpeed = intToBytes(boatLocationMessage.getApparentWindSpeed(), 2);
byte[] apparentWindAngle = intToBytes(boatLocationMessage.getApparentWindAngle(), 2);
byte[] trueWindSpeed = intToBytes(boatLocationMessage.getTrueWindSpeed(), 2);
byte[] trueWindDirection = intToBytes(boatLocationMessage.getTrueWindDirection(), 2);
byte[] trueWindAngle = intToBytes(boatLocationMessage.getTrueWindAngle(), 2);
byte[] currentDrift = intToBytes(boatLocationMessage.getCurrentDrift(), 2);
byte[] currentSet = intToBytes(boatLocationMessage.getCurrentSet(), 2);
byte[] rudderAngle = intToBytes(boatLocationMessage.getRudderAngle(), 2);
ByteBuffer result = ByteBuffer.allocate(56);
result.put(intToBytes(messageVersionNumber, 1));
result.put(time);
result.put(sourceID);
result.put(seqNum);
result.put(deviceType);
result.put(latitude);
result.put(longitude);
result.put(altitude);
result.put(heading);
result.put(pitch);
result.put(roll);
result.put(boatSpeed);
result.put(cog);
result.put(sog);
result.put(apparentWindSpeed);
result.put(apparentWindAngle);
result.put(trueWindSpeed);
result.put(trueWindDirection);
result.put(trueWindAngle);
result.put(currentDrift);
result.put(currentSet);
result.put(rudderAngle);
return result.array();
}
public byte[] markRounding(int time, int ackNumber, int raceID, int sourceID, int boatStatus, int roundingSide, int markType, int markID){
int messageVersionNumber = 0b1;
byte[] byteTime = longToBytes(time, 6);
byte[] byteAck = intToBytes(ackNumber, 2);
byte[] byteRaceID = intToBytes(raceID, 4);
byte[] byteSourceID = intToBytes(sourceID, 4);
byte[] byteBoatStatus = intToBytes(boatStatus, 1);
byte[] byteRoundingSide = intToBytes(roundingSide, 1);
byte[] byteMarkType = intToBytes(markType, 1);
byte[] byteMarkID = intToBytes(markID, 1);
ByteBuffer result = ByteBuffer.allocate(21);
result.put(intToBytes(messageVersionNumber, 1));
result.put(byteTime);
result.put(byteAck);
result.put(byteRaceID);
result.put(byteSourceID);
result.put(byteBoatStatus);
result.put(byteRoundingSide);
result.put(byteMarkType);
result.put(byteMarkID);
return result.array();
}
public byte[] courseWind(byte windID, ArrayList<CourseWind> courseWinds){
int messageVersionNumber = 0b1;
byte byteWindID = windID;
byte[] loopcount = intToBytes(courseWinds.size(), 1);
ByteBuffer result = ByteBuffer.allocate(3 + 20 * courseWinds.size());
result.put(intToBytes(messageVersionNumber, 1));
result.put(byteWindID);
result.put(loopcount);
for (CourseWind wind: courseWinds){
result.put(intToBytes(wind.getID(), 1));
result.put(longToBytes(wind.getTime(), 6));
result.put(intToBytes(wind.getRaceID(), 4));
result.put(intToBytes(wind.getWindDirection(), 2));
result.put(intToBytes(wind.getWindSpeed(), 2));
result.put(intToBytes(wind.getBestUpwindAngle(), 2));
result.put(intToBytes(wind.getBestDownwindAngle(), 2));
result.put(intToBytes(wind.getFlags(), 1));
}
return result.array();
}
public byte[] averageWind(int time, int rawPeriod, int rawSampleSpeed, int period2, int speed2, int period3, int speed3, int period4, int speed4){
int messageVersionNumber = 0b1;
byte[] byteTime = longToBytes(time,6);
byte[] byteRawPeriod = intToBytes(rawPeriod, 2);
byte[] byteRawSpeed = intToBytes(rawSampleSpeed, 2);
byte[] bytePeriod2 = intToBytes(period2, 2);
byte[] byteSpeed2 = intToBytes(speed2, 2);
byte[] bytePeriod3 = intToBytes(period3, 2);
byte[] byteSpeed3 = intToBytes(speed3, 2);
byte[] bytePeriod4 = intToBytes(period4, 2);
byte[] byteSpeed4 = intToBytes(speed4, 2);
ByteBuffer result = ByteBuffer.allocate(23);
result.put(intToBytes(messageVersionNumber, 1));
result.put(byteTime);
result.put(byteRawPeriod);
result.put(byteRawSpeed);
result.put(bytePeriod2);
result.put(byteSpeed2);
result.put(bytePeriod3);
result.put(byteSpeed3);
result.put(bytePeriod4);
result.put(byteSpeed4);
return result.array();
}
}

62
src/main/java/seng302/Networking/MessageEncoders/XMLMessageEncoder.java
Unescape View File

@ -0,0 +1,62 @@
package seng302.Networking.MessageEncoders;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
import static seng302.Networking.Utils.ByteConverter.intToBytes;
import static seng302.Networking.Utils.ByteConverter.longToBytes;
import static seng302.Networking.Utils.ByteConverter.shortToBytes;
/**
* Encodes a XML file into a message of AC35 format
*/
public class XMLMessageEncoder {
private byte[] messageVersionNumber;
private short ackNumber;
private long timeStamp;
private byte[] xmlMsgSubType;
private short sequenceNumber;
private short xmlMsgLength;
private String xmlMessage;
public XMLMessageEncoder(short ackNumber, long timeStamp, int xmlMsgSubType, short sequenceNumber, short xmlMsgLenght, String xmlMessage) {
this.messageVersionNumber = intToBytes(1, 1);
this.ackNumber = ackNumber;
this.timeStamp = timeStamp;
this.xmlMsgSubType = intToBytes(xmlMsgSubType, 1);
this.sequenceNumber = sequenceNumber;
this.xmlMsgLength = xmlMsgLenght;
this.xmlMessage = xmlMessage;
}
public byte[] encode() {
byte[] messageBytes = xmlMessage.getBytes();
if (messageBytes.length > this.xmlMsgLength) {
//System.err.println("Xml message is to big");
return null;
}
ByteBuffer tempOutputByteBuffer = ByteBuffer.allocate(14 + messageBytes.length);
//ackNumber converted to bytes
byte[] ackNumberBytes = shortToBytes(ackNumber, 2);
//sequenceNumber converted to bytes
byte[] sequenceNumberBytes = shortToBytes(sequenceNumber, 2);
//xmlMsgLength converted to bytes
byte[] xmlMsgLengthBytes = shortToBytes(xmlMsgLength, 2);
tempOutputByteBuffer.put(messageVersionNumber);
tempOutputByteBuffer.put(ackNumberBytes);
tempOutputByteBuffer.put(longToBytes(timeStamp, 6));
tempOutputByteBuffer.put(xmlMsgSubType);
tempOutputByteBuffer.put(sequenceNumberBytes);
tempOutputByteBuffer.put(xmlMsgLengthBytes);
tempOutputByteBuffer.put(messageBytes);
return tempOutputByteBuffer.array();
}
}

134
src/main/java/seng302/Networking/MockOutput.java
Unescape View File

@ -0,0 +1,134 @@
package seng302.Networking;
import seng302.Networking.MessageEncoders.RaceVisionByteEncoder;
import seng302.Networking.MessageEncoders.XMLMessageEncoder;
import seng302.Networking.Utils.BoatLocationMessage;
import seng302.Networking.Utils.MessageType;
import java.io.*;
import java.net.*;
import java.util.ArrayList;
/**
* TCP client to recive information from AC35 data source
*/
public class MockOutput
{
private long lastHeartbeatTime;
private RaceVisionByteEncoder messageEncoder = new RaceVisionByteEncoder();
//socket port 4942 as 4940 is ac35 live port and 4941 is ac35 test port
private Socket mockSocket;
private DataOutputStream outToVisualiser;
//a buffer that contains items that are waiting to be sent
private ArrayList<byte[]> messagesToSendBuffer = new ArrayList<>();
private short messageNumber = 1;
private short xmlSequenceNumber = 1;
private int heartbeatSequenceNum = 1;
MockOutput() throws IOException{
/*******************************Test********************************/
StringBuilder xmlString;
BufferedReader br = new BufferedReader(new InputStreamReader(
this.getClass().getResourceAsStream(("/raceXML/Regatta.xml"))));
String line;
xmlString = new StringBuilder();
while((line=br.readLine())!= null){
xmlString.append(line.trim());
}
parseXMLString(xmlString.toString(), 5);
/*******************************Test********************************/
/**************sockets*******************/
//start Time
lastHeartbeatTime = System.currentTimeMillis();
mockSocket = new Socket("localhost", 4942);
outToVisualiser = new DataOutputStream(mockSocket.getOutputStream());
//loop that sends
while(true)
{
//sends a heartbeat every 5 seconds
if (timeSinceHeartbeat() >= 5.00){
outToVisualiser.write(heartbeat());
lastHeartbeatTime = System.currentTimeMillis();
}
//checks the buffer to see if there is anything to send
if (messagesToSendBuffer.size() > 0) {
for (byte[] binaryMessage : messagesToSendBuffer) {
//sends the message to the visualiser
outToVisualiser.write(binaryMessage);
}
//cleans out buffer
messagesToSendBuffer.clear();
}
}
/**************sockets*******************/
}
/**
* calculates the time since last heartbeat
* @return time since last heartbeat
*/
private double timeSinceHeartbeat() {
long now = System.currentTimeMillis();
return (now - lastHeartbeatTime) / 1000.0;
}
//returns the heartbeat message
private byte[] heartbeat(){
byte[] heartbeatMessage = messageEncoder.heartBeat(heartbeatSequenceNum);
heartbeatSequenceNum++;
BinaryMesageEncoder binaryMesageEncoder = new BinaryMesageEncoder(MessageType.HEARTBEAT, System.currentTimeMillis(), messageNumber, (short)heartbeatMessage.length, heartbeatMessage);
messageNumber++;
return binaryMesageEncoder.getFullMessage();
}
/**
* Used to give the mockOutput an xml string to be made into a message and sent
* @param xmlString the xml string to send
* @param messageType the kind of xml string, values given in AC35 spec (5 regatta, 6 race, 7 boat)
*/
public void parseXMLString(String xmlString, int messageType){
XMLMessageEncoder encoder = new XMLMessageEncoder(messageNumber, System.currentTimeMillis(), messageType, xmlSequenceNumber,(short) xmlString.length(), xmlString);
//iterates the sequence numbers
xmlSequenceNumber++;
byte[] encodedXML = encoder.encode();
BinaryMesageEncoder binaryMesageEncoder = new BinaryMesageEncoder(MessageType.XMLMESSAGE, System.currentTimeMillis(), messageNumber, (short)encodedXML.length, encodedXML);
//iterates the message number
messageNumber++;
addMessageToBufferToSend(binaryMesageEncoder.getFullMessage());
}
/**
* Used to give the mocOutput information about boat location to be made into a message and sent
*/
public void parseBoatLocation(){
/// TODO: 26/04/17
}
private void addMessageToBufferToSend(byte[] messagesToSendBuffer) {
this.messagesToSendBuffer.add(messagesToSendBuffer);
}
public static void main(String argv[]) throws Exception
{
MockOutput client = new MockOutput();
}
}

67
src/main/java/seng302/Networking/PacketDump/AC35DumpReader.java
Unescape View File

@ -0,0 +1,67 @@
package seng302.Networking.PacketDump;
import seng302.Networking.BinaryMesageEncoder;
import seng302.Networking.BinaryMessageDecoder;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.ByteBuffer;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
/**
* Created by fwy13 on 25/04/17.
*/
public class AC35DumpReader {
private byte[] dump;
private ArrayList<AC35Packet> packets;
public AC35DumpReader(String url) throws IOException, URISyntaxException {
URL uri = getClass().getClassLoader().getResource(url);
Path path = Paths.get(uri.toURI());
dump = Files.readAllBytes(path);
packets = new ArrayList<>();
System.out.println(dump.length);
readAllPackets();
}
private void readAllPackets(){
int pointer = 0;
while(pointer < dump.length){
byte[] messLen = new byte[2];
messLen[1] = dump[pointer + 13];
messLen[0] = dump[pointer + 14];
int messageLength = ByteBuffer.wrap(messLen).getShort();
//System.out.println(messageLength);
packets.add(new AC35Packet(Arrays.copyOfRange(dump, pointer, pointer + messageLength + 19)));
pointer += 19 + messageLength;
}
for (AC35Packet pack: packets){
BinaryMessageDecoder decoder = new BinaryMessageDecoder(pack.getData());
decoder.decode();
}
}
public static void main(String[] args){
try {
AC35DumpReader ac35DumpReader = new AC35DumpReader("dataDumps/ac35.bin");
} catch (IOException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
}
}
}

17
src/main/java/seng302/Networking/PacketDump/AC35Packet.java
Unescape View File

@ -0,0 +1,17 @@
package seng302.Networking.PacketDump;
/**
* Created by fwy13 on 25/04/17.
*/
public class AC35Packet {
byte[] data;
public AC35Packet(byte[] data){
this.data = data;
}
public byte[] getData() {
return data;
}
}

15
src/main/java/seng302/Networking/Utils/AC35Data.java
Unescape View File

@ -0,0 +1,15 @@
package seng302.Networking.Utils;
/**
* Created by fwy13 on 25/04/17.
*/
public abstract class AC35Data {
protected MessageType type;
public AC35Data (MessageType type){
this.type = type;
}
}

33
src/main/java/seng302/Networking/Utils/AverageWind.java
Unescape View File

@ -0,0 +1,33 @@
package seng302.Networking.Utils;
/**
* Created by fwy13 on 25/04/17.
*/
public class AverageWind extends AC35Data{
private int msgNum;
private long lngTime;
private int rawPeriod;
private int rawSpeed;
private int period2;
private int speed2;
private int period3;
private int speed3;
private int period4;
private int speed4;
public AverageWind(int msgNum, long lngTime, int rawPeriod, int rawSpeed, int period2, int speed2, int period3, int speed3, int period4, int speed4){
super(MessageType.AVGWIND);
this.msgNum = msgNum;
this.lngTime = lngTime;
this.rawPeriod = rawPeriod;
this.rawSpeed = rawSpeed;
this.period2 = period2;
this.speed2 = speed2;
this.period3 = period3;
this.speed3 = speed3;
this.period4 = period4;
this.speed4 = speed4;
}
}

359
src/main/java/seng302/Networking/Utils/BoatLocationMessage.java
Unescape View File

@ -0,0 +1,359 @@
package seng302.Networking.Utils;
/**
* Created by f123 on 21-Apr-17.
*/
/**
* Represents the information in a boat location message (AC streaming spec: 4.9).
*/
public class BoatLocationMessage extends AC35Data
{
///Version number of the message - is always 1.
private int messageVersionNumber = 1;
///Time of the event - milliseconds since jan 1 1970. Proper type is 6 byte int.
private long time;
///Source ID of the boat.
private int sourceID;
///Sequence number of the message.
private int sequenceNumber;
///Device type of the message (physical source of the message).
private int deviceType;
///Latitude of the boat.
private int latitude;
///Longitude of the boat.
private int longitude;
///Altitude of the boat.
private int altitude;
///Heading of the boat. Clockwise, 0 = north. Proper type is unsigned 2 byte int.
private int heading;
///Pitch of the boat.
private int pitch;
///Roll of the boat.
private int roll;
///Speed of the boat. Proper type is unsigned 2 byte int. millimeters per second.
private int boatSpeed;
///Course over ground (COG) of the boat. Proper type is unsigned 2 byte int.
private int boatCOG;
///Speed over ground (SOG) of the boat. Proper type is unsigned 2 byte int. millimeters per second.
private int boatSOG;
///Apparent wind speed at time of event. Proper type is unsigned 2 byte int. millimeters per second.
private int apparentWindSpeed;
///Apparent wind angle at time of the event. Wind over starboard = positive.
private int apparentWindAngle;
///True wind speed. Proper type is unsigned 2 byte int. millimeters per second.
private int trueWindSpeed;
private int trueWindDirection;
///True wind angle. Clockwise compass direction, 0 = north.
private int trueWindAngle;
///Current drift. Proper type is unsigned 2 byte int. millimeters per second.
private int currentDrift;
///Current set. Proper type is unsigned 2 byte int. Clockwise compass direction, 0 = north.
private int currentSet;
///Rudder angle. Positive is rudder set to turn yacht to port.
private int rudderAngle;
/**
* Ctor.
*/
public BoatLocationMessage(MessageType type)
{
super(type);
}
/**
* Ctor, with all parameters.
* @param messageVersionNumber
* @param time
* @param sourceID
* @param sequenceNumber
* @param deviceType
* @param latitude
* @param longitude
* @param altitude
* @param heading
* @param pitch
* @param roll
* @param boatSpeed
* @param boatCOG
* @param boatSOG
* @param apparentWindSpeed
* @param apparentWindAngle
* @param trueWindSpeed
* @param trueWindDirection
* @param trueWindAngle
* @param currentDrift
* @param currentSet
* @param rudderAngle
*/
public BoatLocationMessage(int messageVersionNumber, long time, int sourceID, int sequenceNumber, int deviceType, int latitude, int longitude, int altitude, int heading, int pitch, int roll, int boatSpeed, int boatCOG, int boatSOG, int apparentWindSpeed, int apparentWindAngle, int trueWindSpeed, int trueWindDirection, int trueWindAngle, int currentDrift, int currentSet, int rudderAngle)
{
super(MessageType.BOATLOCATION);
this.messageVersionNumber = messageVersionNumber;
this.time = time;
this.sourceID = sourceID;
this.sequenceNumber = sequenceNumber;
this.deviceType = deviceType;
this.latitude = latitude;
this.longitude = longitude;
this.altitude = altitude;
this.heading = heading;
this.pitch = pitch;
this.roll = roll;
this.boatSpeed = boatSpeed;
this.boatCOG = boatCOG;
this.boatSOG = boatSOG;
this.apparentWindSpeed = apparentWindSpeed;
this.apparentWindAngle = apparentWindAngle;
this.trueWindSpeed = trueWindSpeed;
this.trueWindDirection = trueWindDirection;
this.trueWindAngle = trueWindAngle;
this.currentDrift = currentDrift;
this.currentSet = currentSet;
this.rudderAngle = rudderAngle;
}
//Getters and setters for message properties.
public int getMessageVersionNumber()
{
return messageVersionNumber;
}
public void setMessageVersionNumber(int messageVersionNumber)
{
this.messageVersionNumber = messageVersionNumber;
}
public long getTime()
{
return time;
}
public void setTime(long time)
{
this.time = time;
}
public int getSourceID()
{
return sourceID;
}
public void setSourceID(int sourceID)
{
this.sourceID = sourceID;
}
public int getSequenceNumber()
{
return sequenceNumber;
}
public void setSequenceNumber(int sequenceNumber)
{
this.sequenceNumber = sequenceNumber;
}
public int getDeviceType()
{
return deviceType;
}
public void setDeviceType(int deviceType)
{
this.deviceType = deviceType;
}
public int getLatitude()
{
return latitude;
}
public void setLatitude(int latitude)
{
this.latitude = latitude;
}
public int getLongitude()
{
return longitude;
}
public void setLongitude(int longitude)
{
this.longitude = longitude;
}
public int getAltitude()
{
return altitude;
}
public void setAltitude(int altitude)
{
this.altitude = altitude;
}
public int getHeading()
{
return heading;
}
public void setHeading(int heading)
{
this.heading = heading;
}
public int getPitch()
{
return pitch;
}
public void setPitch(int pitch)
{
this.pitch = pitch;
}
public int getRoll()
{
return roll;
}
public void setRoll(int roll)
{
this.roll = roll;
}
public int getBoatSpeed()
{
return boatSpeed;
}
public void setBoatSpeed(int boatSpeed)
{
this.boatSpeed = boatSpeed;
}
public int getBoatCOG()
{
return boatCOG;
}
public void setBoatCOG(int boatCOG)
{
this.boatCOG = boatCOG;
}
public int getBoatSOG()
{
return boatSOG;
}
public void setBoatSOG(int boatSOG)
{
this.boatSOG = boatSOG;
}
public int getApparentWindSpeed()
{
return apparentWindSpeed;
}
public void setApparentWindSpeed(int apparentWindSpeed)
{
this.apparentWindSpeed = apparentWindSpeed;
}
public int getApparentWindAngle()
{
return apparentWindAngle;
}
public void setApparentWindAngle(int apparentWindAngle)
{
this.apparentWindAngle = apparentWindAngle;
}
public int getTrueWindSpeed()
{
return trueWindSpeed;
}
public void setTrueWindSpeed(int trueWindSpeed)
{
this.trueWindSpeed = trueWindSpeed;
}
public int getTrueWindDirection() {
return trueWindDirection;
}
public void setTrueWindDirection(int trueWindDirection) {
this.trueWindDirection = trueWindDirection;
}
public int getTrueWindAngle()
{
return trueWindAngle;
}
public void setTrueWindAngle(int trueWindAngle)
{
this.trueWindAngle = trueWindAngle;
}
public int getCurrentDrift()
{
return currentDrift;
}
public void setCurrentDrift(int currentDrift)
{
this.currentDrift = currentDrift;
}
public int getCurrentSet()
{
return currentSet;
}
public void setCurrentSet(int currentSet)
{
this.currentSet = currentSet;
}
public int getRudderAngle()
{
return rudderAngle;
}
public void setRudderAngle(int rudderAngle)
{
this.rudderAngle = rudderAngle;
}
}

52
src/main/java/seng302/Networking/Utils/BoatStatus.java
Unescape View File

@ -0,0 +1,52 @@
package seng302.Networking.Utils;
/**
* Created by hba56 on 23/04/17.
*/
public class BoatStatus{
private int sourceID;
private byte boatStatus;
private byte legNumber;
private byte numPenaltiesAwarded;
private byte numPenaltiesServed;
private long estTimeAtNextMark;
private long estTimeAtFinish;
public BoatStatus(int sourceID, byte boatStatus, byte legNumber, byte numPenaltiesAwarded, byte numPenaltiesServed, long estTimeAtNextMark, long estTimeAtFinish) {
this.sourceID = sourceID;
this.boatStatus = boatStatus;
this.legNumber = legNumber;
this.numPenaltiesAwarded = numPenaltiesAwarded;
this.numPenaltiesServed = numPenaltiesServed;
this.estTimeAtNextMark = estTimeAtNextMark;
this.estTimeAtFinish = estTimeAtFinish;
}
public int getSourceID() {
return sourceID;
}
public byte getBoatStatus() {
return boatStatus;
}
public byte getLegNumber() {
return legNumber;
}
public byte getNumPenaltiesAwarded() {
return numPenaltiesAwarded;
}
public byte getNumPenaltiesServed() {
return numPenaltiesServed;
}
public long getEstTimeAtNextMark() {
return estTimeAtNextMark;
}
public long getEstTimeAtFinish() {
return estTimeAtFinish;
}
}

253
src/main/java/seng302/Networking/Utils/ByteConverter.java
Unescape View File

@ -0,0 +1,253 @@
package seng302.Networking.Utils;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
/**
* Created by fwy13 on 25/04/17.
*/
public class ByteConverter {
public static int IntegerSize = 4;
public static int LongSize = 8;
public static int CharSize = 2;
public static int ShortSize = 2;
//default for AC35 is Little Endian therefore all overloads will be done with Little_Endian unless told else wise
//////////////////////////////////////////////////
//Bytes[] to number conversions
//////////////////////////////////////////////////
//////////////////////////////////////////////////
//Integer
//////////////////////////////////////////////////
public static int bytesToInt(byte bite){
byte[] bytes = {bite};
return bytesToInt(bytes, ByteOrder.LITTLE_ENDIAN);
}
public static int bytesToInt(byte[] bytes){
return bytesToInt(bytes, ByteOrder.LITTLE_ENDIAN);
}
public static int bytesToInt(byte[] bytes, ByteOrder byteOrder){
byte[] bites = convertBytesToNum(bytes,byteOrder, IntegerSize);
return ByteBuffer.wrap(bites).order(byteOrder).getInt();
}
//////////////////////////////////////////////////
//Long
//////////////////////////////////////////////////
public static long bytesToLong(byte bite){
byte[] bytes = {bite};
return bytesToLong(bytes, ByteOrder.LITTLE_ENDIAN);
}
public static long bytesToLong(byte[] bytes){
return bytesToLong(bytes, ByteOrder.LITTLE_ENDIAN);
}
public static long bytesToLong(byte[] bytes, ByteOrder byteOrder){
byte[] bites = convertBytesToNum(bytes,byteOrder, LongSize);
return ByteBuffer.wrap(bites).order(byteOrder).getLong();
}
//////////////////////////////////////////////////
//Short
//////////////////////////////////////////////////
public static short bytesToShort(byte bite){
byte[] bytes = {bite};
return bytesToShort(bytes, ByteOrder.LITTLE_ENDIAN);
}
public static short bytesToShort(byte[] bytes){
return bytesToShort(bytes, ByteOrder.LITTLE_ENDIAN);
}
public static short bytesToShort(byte[] bytes, ByteOrder byteOrder){
byte[] bites = convertBytesToNum(bytes,byteOrder, ShortSize);
return ByteBuffer.wrap(bites).order(byteOrder).getShort();
}
//////////////////////////////////////////////////
//Char
//////////////////////////////////////////////////
public static char bytesToChar(byte bite){
byte[] bytes = {bite};
return bytesToChar(bytes, ByteOrder.LITTLE_ENDIAN);
}
public static char bytesToChar(byte[] bytes){
return bytesToChar(bytes, ByteOrder.LITTLE_ENDIAN);
}
public static char bytesToChar(byte[] bytes, ByteOrder byteOrder){
byte[] bites = convertBytesToNum(bytes,byteOrder, CharSize);
return ByteBuffer.wrap(bites).order(byteOrder).getChar();
}
//////////////////////////////////////////////////
//Conversion Function
//////////////////////////////////////////////////
private static byte[] convertBytesToNum(byte[] bytes, ByteOrder byteOrder, int maxSize){
byte[] bites = new byte[maxSize];
if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
for (int i = 0; i < bytes.length; i++) {
bites[i] = bytes[i];
if (i > maxSize){//break if over hte limit
break;
}
}
for (int i = bytes.length; i < maxSize; i++) {
bites[i] = 0b0;
}
}else{//if big endian
for (int i = 0; i < maxSize - bytes.length; i++) {
bites[i] = 0b0;
}
for (int i = maxSize - bytes.length; i < maxSize; i++) {
bites[i] = bytes[i - maxSize + bytes.length];
if (i > maxSize){//break if over the limit
break;
}
}
}
return bites;
}
//////////////////////////////////////////////////////////
//Number to Byte[] conversions
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////
//Integer
//////////////////////////////////////////////////
public static byte[] intToBytes(int i){
return intToBytes(i, 4, ByteOrder.LITTLE_ENDIAN);
}
public static byte[] intToBytes(int i ,int size){
return intToBytes(i, size, ByteOrder.LITTLE_ENDIAN);
}
/**
* Converts an Integer to a Byte Array
* @param i the integer to be converted
* @param size Size that the byte array should be
* @param byteOrder the order that the bytes should be ie Big Endian
* @return
*/
public static byte[] intToBytes(int i ,int size, ByteOrder byteOrder){
ByteBuffer buffer = ByteBuffer.allocate(IntegerSize);
buffer.order(byteOrder);
buffer.putInt(i);
byte[] copy = buffer.array();
return convertNumtoBytes(copy, size, byteOrder, IntegerSize);
}
//////////////////////////////////////////////////
//Long
//////////////////////////////////////////////////
public static byte[] longToBytes(long i){
return longToBytes(i, LongSize, ByteOrder.LITTLE_ENDIAN);
}
public static byte[] longToBytes(long i ,int size){
return longToBytes(i, size, ByteOrder.LITTLE_ENDIAN);
}
/**
* Converts an Long to a Byte Array
* @param i the Long to be converted
* @param size Size that the byte array should be
* @param byteOrder the order that the bytes should be ie Big Endian
* @return
*/
public static byte[] longToBytes(long i ,int size, ByteOrder byteOrder){
ByteBuffer buffer = ByteBuffer.allocate(LongSize);
buffer.order(byteOrder);
buffer.putLong(i);
byte[] copy = buffer.array();
return convertNumtoBytes(copy, size, byteOrder, LongSize);
}
//////////////////////////////////////////////////
//Short
//////////////////////////////////////////////////
public static byte[] shortToBytes(short i){
return shortToBytes(i, ShortSize, ByteOrder.LITTLE_ENDIAN);
}
public static byte[] shortToBytes(short i ,int size){
return shortToBytes(i, size, ByteOrder.LITTLE_ENDIAN);
}
/**
* Converts an Short to a Byte Array
* @param i the Short to be converted
* @param size Size that the byte array should be
* @param byteOrder the order that the bytes should be ie Big Endian
* @return
*/
public static byte[] shortToBytes(short i ,int size, ByteOrder byteOrder){
ByteBuffer buffer = ByteBuffer.allocate(ShortSize);
buffer.order(byteOrder);
buffer.putShort(i);
byte[] copy = buffer.array();
return convertNumtoBytes(copy, size, byteOrder, ShortSize);
}
//////////////////////////////////////////////////
//Char
//////////////////////////////////////////////////
public static byte[] charToBytes(char i){
return charToBytes(i, CharSize, ByteOrder.LITTLE_ENDIAN);
}
public static byte[] charToBytes(char i ,int size){
return charToBytes(i, size, ByteOrder.LITTLE_ENDIAN);
}
/**
* Converts an Char to a Byte Array
* @param i the Char to be converted
* @param size Size that the byte array should be
* @param byteOrder the order that the bytes should be ie Big Endian
* @return
*/
public static byte[] charToBytes(char i ,int size, ByteOrder byteOrder){
ByteBuffer buffer = ByteBuffer.allocate(CharSize);
buffer.order(byteOrder);
buffer.putChar(i);
byte[] copy = buffer.array();
return convertNumtoBytes(copy, size, byteOrder, CharSize);
}
//////////////////////////////////////////////////
//Conversion Function
//////////////////////////////////////////////////
private static byte[] convertNumtoBytes(byte[] copy ,int size, ByteOrder byteOrder, int fullsize){
byte[] bytes = new byte[size];
if (byteOrder == ByteOrder.LITTLE_ENDIAN){
bytes = Arrays.copyOfRange(copy, 0, size);
}else{// if it is Big Endian
bytes = Arrays.copyOfRange(copy, fullsize - size, fullsize);
}
return bytes;
}
}

55
src/main/java/seng302/Networking/Utils/CourseWind.java
Unescape View File

@ -0,0 +1,55 @@
package seng302.Networking.Utils;
/**
* Created by fwy13 on 21/04/17.
*/
public class CourseWind extends AC35Data{
private int ID, raceID, windDirection, windSpeed, bestUpwindAngle, bestDownwindAngle, flags;
private long time;
public CourseWind(int ID, long time, int raceID, int windDirection, int windSpeed, int bestUpwindAngle, int bestDownwindAngle,
int flags){
super(MessageType.COURSEWIND);
this.ID = ID;
this.time = time;
this.raceID = raceID;
this.windDirection = windDirection;
this.windSpeed = windSpeed;
this.bestUpwindAngle = bestUpwindAngle;
this.bestDownwindAngle = bestDownwindAngle;
this.flags = flags;
}
public int getID() {
return ID;
}
public int getRaceID() {
return raceID;
}
public int getWindDirection() {
return windDirection;
}
public int getWindSpeed() {
return windSpeed;
}
public int getBestUpwindAngle() {
return bestUpwindAngle;
}
public int getBestDownwindAngle() {
return bestDownwindAngle;
}
public int getFlags() {
return flags;
}
public long getTime() {
return time;
}
}

21
src/main/java/seng302/Networking/Utils/CourseWinds.java
Unescape View File

@ -0,0 +1,21 @@
package seng302.Networking.Utils;
import java.util.ArrayList;
/**
* Created by fwy13 on 25/04/17.
*/
public class CourseWinds extends AC35Data{
private int msgVerNum;
private int selectedWindID;
private ArrayList<CourseWind> courseWinds;
public CourseWinds(int msgVerNum, int selectedWindID, ArrayList<CourseWind> courseWinds){
super(MessageType.COURSEWIND);
this.msgVerNum = msgVerNum;
this.selectedWindID = selectedWindID;
this.courseWinds = courseWinds;
}
}

12
src/main/java/seng302/Networking/Utils/Heartbeat.java
Unescape View File

@ -0,0 +1,12 @@
package seng302.Networking.Utils;
/**
* Created by fwy13 on 25/04/17.
*/
public class Heartbeat extends AC35Data{
public Heartbeat(){
super(MessageType.HEARTBEAT);
}
}

52
src/main/java/seng302/Networking/Utils/MarkRounding.java
Unescape View File

@ -0,0 +1,52 @@
package seng302.Networking.Utils;
/**
* Created by fwy13 on 25/04/17.
*/
public class MarkRounding extends AC35Data{
private int msgVerNum;
private long time;
private int ackNum;
private int raceID;
private int sourceID;
private int boatStatus;
private int roundingSide;
private int markType;
private int markID;
public static int BoatStatusUnknown = 0;
public static int BoatStatusRacing = 1;
public static int BoatStatusDSQ = 2;
public static int BoatStatusWithdrawn = 3;
public static int RoundingSideUnknown = 0;
public static int RoundingSidePort = 1;
public static int RoundingSideStarboard = 2;
public static int MarkTypeUnknown = 0;
public static int MarkTypeRoundingMark = 1;
public static int MarkTypeGate = 2;
public static int MarkIDEntryLimitLine = 100;
public static int MarkIDEntryLine = 101;
public static int MarkIDRaceStartStartline = 102;
public static int MarkIDRaceFinishline = 103;
public static int MarkIDSpeedTestStart = 104;
public static int MarkIDSpeedTestFinish = 105;
public static int MarkIDClearStart = 106;
public MarkRounding(int msgVerNum, long time, int ackNum, int raceID, int sourceID, int boatStatus, int roundingSide, int markType, int markID){
super(MessageType.MARKROUNDING);
this.msgVerNum = msgVerNum;
this.time = time;
this.ackNum = ackNum;
this.raceID = raceID;
this.sourceID = sourceID;
this.boatStatus = boatStatus;
this.roundingSide = roundingSide;
this.markType = markType;
this.markID = markID;
}
}

49
src/main/java/seng302/Networking/Utils/MessageType.java
Unescape View File

@ -0,0 +1,49 @@
package seng302.Networking.Utils;
/**
* Created by hba56 on 21/04/17.
*/
public enum MessageType {
HEARTBEAT(1), RACESTATUS(12), DISPLAYTEXTMESSAGE(20),
XMLMESSAGE(26), RACESTARTSTATUS(27), YACHTEVENTCODE(29), YACHTACTIONCODE(31),
CHATTERTEXT(36), BOATLOCATION(37), MARKROUNDING(38), COURSEWIND(44), AVGWIND(47), NOTAMESSAGE(0);
private byte value;
private MessageType(int value) { this.value = (byte)value; }
public byte getValue() {
return value;
}
public static MessageType valueOf(byte bite){
switch(bite){
case 1:
return HEARTBEAT;
case 12:
return RACESTATUS;
case 20:
return DISPLAYTEXTMESSAGE;
case 26:
return XMLMESSAGE;
case 27:
return RACESTARTSTATUS;
case 29:
return YACHTEVENTCODE;
case 31:
return YACHTACTIONCODE;
case 36:
return CHATTERTEXT;
case 37:
return BOATLOCATION;
case 38:
return MARKROUNDING;
case 44:
return COURSEWIND;
case 47:
return AVGWIND;
default:
return NOTAMESSAGE;
}
}
}

24
src/main/java/seng302/Networking/Utils/RaceMessage.java
Unescape View File

@ -0,0 +1,24 @@
package seng302.Networking.Utils;
/**
* Created by fwy13 on 19/04/17.
*/
public class RaceMessage extends AC35Data {
private int lineNumber;
private String messageText;
public RaceMessage(int lineNumber, String messageText){
super(MessageType.DISPLAYTEXTMESSAGE);
this.lineNumber = lineNumber;
this.messageText = messageText;
}
public int getLineNumber() {
return lineNumber;
}
public String getMessageText() {
return messageText;
}
}

24
src/main/java/seng302/Networking/Utils/RaceStartStatus.java
Unescape View File

@ -0,0 +1,24 @@
package seng302.Networking.Utils;
import java.util.ArrayList;
/**
* Created by fwy13 on 25/04/17.
*/
public class RaceStartStatus extends AC35Data{
private long timestamp;
private int ackNum;
private long raceStartTime;
private int raceID;
private int notificationType;
public RaceStartStatus(long timestamp, int ackNum, long raceStartTime, int raceID, int notificationType){
super(MessageType.RACESTARTSTATUS);
this.timestamp = timestamp;
this.ackNum = ackNum;
this.raceStartTime = raceStartTime;
this.raceID = raceID;
this.notificationType = notificationType;
}
}

30
src/main/java/seng302/Networking/Utils/RaceStatus.java
Unescape View File

@ -0,0 +1,30 @@
package seng302.Networking.Utils;
import java.util.ArrayList;
/**
* Created by fwy13 on 25/04/17.
*/
public class RaceStatus extends AC35Data{
long currentTime;
int raceID;
int raceStatus;
long expectedStartTime;
int windDirection;
int windSpeed;
int raceType;
ArrayList<BoatStatus> boatStatuses;
public RaceStatus(long currentTime, int raceID, int raceStatus, long expectedStartTime, int windDirection, int windSpeed, int raceType, ArrayList<BoatStatus> boatStatuses){
super(MessageType.RACESTATUS);
this.currentTime = currentTime;
this.raceID = raceID;
this.raceStatus = raceStatus;
this.expectedStartTime = expectedStartTime;
this.windDirection = windDirection;
this.windSpeed = windSpeed;
this.raceType = raceType;
this.boatStatuses = boatStatuses;//note this is a copy so any alterations to the parent will affect this.
}
}

31
src/main/java/seng302/Networking/Utils/XMLMessage.java
Unescape View File

@ -0,0 +1,31 @@
package seng302.Networking.Utils;
import org.xml.sax.InputSource;
/**
* Created by fwy13 on 25/04/17.
*/
public class XMLMessage extends AC35Data{
private int ackNumber;
private long timeStamp;
private int xmlMsgSubType;
private int sequenceNumber;
private int xmlMsgLength;
private InputSource xmlMessage;
public static int XMLTypeRegatta = 5;
public static int XMLTypeRace = 6;
public static int XMLTypeBoat = 7;
public XMLMessage(int ackNumber, long timeStamp, int xmlMsgSubType, int sequenceNumber, int xmlMsgLength, InputSource xmlMessage){
super(MessageType.XMLMESSAGE);
this.ackNumber = ackNumber;
this.timeStamp = timeStamp;
this.xmlMsgSubType = xmlMsgSubType;
this.sequenceNumber = sequenceNumber;
this.xmlMsgLength = xmlMsgLength;
this.xmlMessage = xmlMessage;
}
}

157
src/main/java/seng302/Networking/VisualiserInput.java
Unescape View File

@ -0,0 +1,157 @@
package seng302.Networking;
import seng302.Networking.BinaryMessageDecoder;
import seng302.Networking.MessageDecoders.*;
import seng302.Networking.Utils.*;
import java.io.*;
import java.net.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import static seng302.Networking.Utils.ByteConverter.bytesToInt;
import static seng302.Networking.Utils.ByteConverter.bytesToShort;
import static seng302.Networking.Utils.MessageType.*;
/**
* TCP server to act as the mock AC35 streaming interface
*/
public class VisualiserInput
{
//time since last heartbeat
private long lastHeartbeatTime;
//socket port 4942 as 4940 is ac35 live port and 4941 is ac35 test port
private ServerSocket visualiserSocket;
private Socket connectionSocket;
long heartbeatSeqNum;
VisualiserInput() throws IOException{
//sockets to connect to
// ServerSocket visualiserSocket = new ServerSocket(4942);
// Socket connectionSocket = visualiserSocket.accept();
//this is the test data that streams form the AC35 website
Socket connectionSocket = new Socket("livedata.americascup.com",4941);
//start Time
lastHeartbeatTime = System.currentTimeMillis();
//receiver loop that gets the input
boolean receiverLoop = true;
while(receiverLoop) {
//gets the input from the socket
InputStream inFromClient = connectionSocket.getInputStream();
//converts the input into a byte array that can be read by the decoder
byte[] binaryMessage = getBytes(inFromClient);
//decode the binary message into readable date
BinaryMessageDecoder testDecoder = new BinaryMessageDecoder(binaryMessage);
testDecoder.decode();
//checks which message is being received and does what is needed for that message
MessageType mType = MessageType.valueOf((byte) testDecoder.getMessageType());
switch (mType) {
case HEARTBEAT:
lastHeartbeatTime = System.currentTimeMillis();
//note: if the program runs for over 340 years, this will crash.
heartbeatSeqNum = ByteConverter.bytesToLong(testDecoder.getMessage());
System.out.println("HeartBeat Message! " + heartbeatSeqNum);
break;
case RACESTATUS:
// System.out.println("Race Status Message");
break;
case DISPLAYTEXTMESSAGE:
// System.out.println("Display Text Message");
//no decoder for this.
break;
case XMLMESSAGE:
// System.out.println("XML Message!");
XMLMessageDecoder xmlMessageDecoder = new XMLMessageDecoder(testDecoder.getMessage());
xmlMessageDecoder.decode();
System.out.println(xmlMessageDecoder.getXmlMessageInputSource());
break;
case RACESTARTSTATUS:
// System.out.println("Race Start Status Message");
break;
case YACHTEVENTCODE:
// System.out.println("Yacht Action Code!");
//no decoder
break;
case YACHTACTIONCODE:
// System.out.println("Yacht Action Code!");
//no decoder
break;
case CHATTERTEXT:
// System.out.println("Chatter Text Message!");
//no decoder
break;
case BOATLOCATION:
// System.out.println("Boat Location Message!");
break;
case MARKROUNDING:
// System.out.println("Mark Rounding Message!");
break;
case COURSEWIND:
// System.out.println("Course Wind Message!");
break;
case AVGWIND:
// System.out.println("Average Wind Message!");
break;
default:
// System.out.println("Broken Message!");
break;
}
//if no heartbeat has been received in more than 6 seconds
//the connection will need to be restarted
if (timeSinceHeartbeat() > 6){
System.out.println("Connection has stopped, trying to reconnect");
receiverLoop = false;
}
}
}
/**
* calculates the time since last heartbeat
* @return time since last heartbeat
*/
private double timeSinceHeartbeat() {
long now = System.currentTimeMillis();
return (now - lastHeartbeatTime) / 1000.0;
}
/**
* Takes an inputStream and reads the first 15 bytes (the header) and gets the message length
* for the whole message then reads that and returns the byte array
* @param inStream inputStream from socket
* @return encoded binary messsage bytes
* @throws IOException
*/
private static byte[] getBytes(InputStream inStream) throws IOException {
byte[] headerBytes = new byte[15];
int i = inStream.read(headerBytes);
byte[] messageLenBytes = Arrays.copyOfRange(headerBytes, 13, 15);
short messageLen = bytesToShort(messageLenBytes);
byte[] messageBytesWithCRC = new byte[messageLen+4];
int j = inStream.read(messageBytesWithCRC);
ByteBuffer binaryMessageBytes = ByteBuffer.allocate(headerBytes.length+messageBytesWithCRC.length);
binaryMessageBytes.put(headerBytes);
binaryMessageBytes.put(messageBytesWithCRC);
return binaryMessageBytes.array();
}
public static void main(String argv[]) throws Exception
{
VisualiserInput reciever = new VisualiserInput();
}
}

BIN
src/main/resources/dataDumps/ac35.bin
View File

Binary file not shown.

119
src/main/resources/raceXML/Boats.xml
Unescape View File

@ -0,0 +1,119 @@
<?xml version="1.0" encoding="utf-8"?>
<BoatConfig>
<Modified>2017-04-19T15:49:40+1200</Modified>
<Version>1</Version>
<Settings>
<RaceBoatType Type="AC45" />
<BoatDimension BoatLength="14.019" HullLength="13.449" />
<ZoneSize MarkZoneSize="40.347" CourseZoneSize="40.347" />
<ZoneLimits Limit1="200" Limit2="100" Limit3="40.347" Limit4="0" Limit5="-100" />
</Settings>
<BoatShapes>
<BoatShape ShapeID="0">
<Vertices>
<Vtx Seq="1" Y="0" X="-2.659" />
<Vtx Seq="2" Y="18.359" X="-2.659" />
<Vtx Seq="3" Y="18.359" X="2.659" />
<Vtx Seq="4" Y="0" X="2.659" />
</Vertices>
</BoatShape>
<BoatShape ShapeID="1">
<Vertices>
<Vtx Seq="1" Y="0" X="-1.278" />
<Vtx Seq="2" Y="8.876" X="-1.278" />
<Vtx Seq="3" Y="8.876" X="1.278" />
<Vtx Seq="4" Y="0" X="1.278" />
</Vertices>
</BoatShape>
<BoatShape ShapeID="2">
<Vertices>
<Vtx Seq="1" Y="0" X="-1.1" />
<Vtx Seq="2" Y="8.3" X="-1.1" />
<Vtx Seq="3" Y="8.3" X="1.1" />
<Vtx Seq="4" Y="0" X="1.1" />
</Vertices>
</BoatShape>
<BoatShape ShapeID="3">
<Vertices>
<Vtx Seq="1" Y="0" X="-0.75" />
<Vtx Seq="2" Y="3" X="-0.75" />
<Vtx Seq="3" Y="3" X="0.75" />
<Vtx Seq="4" Y="0" X="0.75" />
</Vertices>
</BoatShape>
<BoatShape ShapeID="4">
<Vertices>
<Vtx Seq="1" Y="0" X="-3.46" />
<Vtx Seq="2" Y="13.449" X="-3.46" />
<Vtx Seq="3" Y="14.019" X="0" />
<Vtx Seq="4" Y="13.449" X="3.46" />
<Vtx Seq="5" Y="0" X="3.46" />
</Vertices>
<Catamaran>
<Vtx Seq="1" Y="1.769" X="-2.752" />
<Vtx Seq="2" Y="0" X="-2.813" />
<Vtx Seq="3" Y="0" X="-3.34" />
<Vtx Seq="4" Y="5.351" X="-3.46" />
<Vtx Seq="5" Y="10.544" X="-3.387" />
<Vtx Seq="6" Y="13.449" X="-3.075" />
<Vtx Seq="7" Y="10.851" X="-2.793" />
<Vtx Seq="8" Y="6.669" X="-2.699" />
<Vtx Seq="9" Y="6.669" X="2.699" />
<Vtx Seq="10" Y="10.851" X="2.793" />
<Vtx Seq="11" Y="13.449" X="3.075" />
<Vtx Seq="12" Y="10.544" X="3.387" />
<Vtx Seq="13" Y="5.351" X="3.46" />
<Vtx Seq="14" Y="0" X="3.34" />
<Vtx Seq="15" Y="0" X="2.813" />
<Vtx Seq="16" Y="1.769" X="2.752" />
</Catamaran>
<Bowsprit>
<Vtx Seq="1" Y="6.669" X="-0.2" />
<Vtx Seq="2" Y="11.377" X="-0.2" />
<Vtx Seq="3" Y="14.019" X="0" />
<Vtx Seq="4" Y="11.377" X="0.2" />
<Vtx Seq="5" Y="6.669" X="0.2" />
</Bowsprit>
<Trampoline>
<Vtx Seq="1" Y="2" X="-2.699" />
<Vtx Seq="2" Y="6.438" X="-2.699" />
<Vtx Seq="3" Y="6.438" X="2.699" />
<Vtx Seq="4" Y="2" X="2.699" />
</Trampoline>
</BoatShape>
<BoatShape ShapeID="5" />
</BoatShapes>
<Boats>>
<Boat Type="Yacht" SourceID="101" ShapeID="4" HullNum="AC4501" ShortName="USA"
BoatName="ORACLE TEAM USA" Country="USA">
<GPSposition Z="1.738" Y="0.625" X="0.001" />
<MastTop Z="21.496" Y="4.233" X="0.000" />
</Boat>
<Boat Type="Yacht" SourceID="102" ShapeID="4" HullNum="AC4502" ShortName="GBR"
BoatName="Land Rover BAR" Country="United Kingdom">
<GPSposition Z="1.738" Y="0.625" X="0.001" />
<MastTop Z="21.496" Y="4.233" X="0.000" />
</Boat>
<Boat Type="Yacht" SourceID="103" ShapeID="4" HullNum="AC4503" ShortName="JPN"
BoatName="SoftBank Team Japan" Country="Japan">
<GPSposition Z="1.738" Y="0.625" X="0.001" />
<MastTop Z="21.496" Y="4.233" X="0.000" />
</Boat>
<Boat Type="Yacht" SourceID="104" ShapeID="4" HullNum="AC4504" ShortName="FRA"
BoatName="Groupama Team France" Country="France">
<GPSposition Z="1.738" Y="0.625" X="0.001" />
<MastTop Z="21.496" Y="4.233" X="0.000" />
</Boat>
<Boat Type="Yacht" SourceID="105" ShapeID="4" HullNum="AC4505" ShortName="SWE"
BoatName="Artemis Racing" Country="Sweden">
<GPSposition Z="1.738" Y="0.625" X="0.001" />
<MastTop Z="21.496" Y="4.233" X="0.000" />
</Boat>
<Boat Type="Yacht" SourceID="106" ShapeID="4" HullNum="AC4506" ShortName="NZL"
BoatName="Emirates Team New Zealand" Country="New Zealand">
<GPSposition Z="1.738" Y="0.625" X="0.001" />
<MastTop Z="21.496" Y="4.233" X="0.000" />
</Boat>
</Boats>
</BoatConfig>

58
src/main/resources/raceXML/Race.xml
Unescape View File

@ -0,0 +1,58 @@
<?xml version="1.0" encoding="utf-8"?>
<Race>
<RaceID>17041901</RaceID>
<RaceType>Fleet</RaceType>
<CreationTimeDate>2017-04-19T15:30:00+1200</CreationTimeDate >
<RaceStartTime Time="2019-06-01T13:30:00-0400" Postpone="false" />
<Participants>
<Yacht SourceID="001" Entry="Port" />
<Yacht SourceID="002" Entry="Port" />
<Yacht SourceID="003" Entry="Port" />
<Yacht SourceID="004" Entry="Port" />
<Yacht SourceID="005" Entry="Port" />
<Yacht SourceID="006" Entry="Port" />
</Participants>
<Course>
<CompoundMark CompoundMarkID="1" Name="StartLine">
<Mark SeqID="1" Name="PRO" TargetLat="32.296577" TargetLng="-64.854304" SourceID="101" />
<Mark SeqID="2" Name="PIN" TargetLat="32.293771" TargetLng="-64.855242" SourceID="102" />
</CompoundMark>
<CompoundMark CompoundMarkID="2" Name="M1">
<Mark Name="M1" TargetLat="32.293039" TargetLng="-64.843983" SourceID="103" />
</CompoundMark>
<CompoundMark CompoundMarkID="3" Name="WindwardGate">
<Mark SeqID="1" Name="G1" TargetLat="32.284680" TargetLng="-64.850045" SourceID="104" />
<Mark SeqID="2" Name="G2" TargetLat="32.280164" TargetLng="-64.847591" SourceID="105" />
</CompoundMark>
<CompoundMark CompoundMarkID="4" Name="LeewardGate">
<Mark SeqID="1" Name="G1" TargetLat="32.309693" TargetLng="-64.835249" SourceID="106" />
<Mark SeqID="2" Name="G2" TargetLat="32.308046" TargetLng="-64.831785" SourceID="107" />
</CompoundMark>
<CompoundMark CompoundMarkID="5" Name="FinishLine">
<Mark SeqID="1" Name="PRO" TargetLat="32.317379" TargetLng="-64.839291" SourceID="108" />
<Mark SeqID="2" Name="PIN" TargetLat="32.317257" TargetLng="-64.836260" SourceID="109" />
</CompoundMark>
</Course>
<CompoundMarkSequence>
<Corner SeqID="1" CompoundMarkID="1" Rounding="SP" ZoneSize="3" />
<Corner SeqID="2" CompoundMarkID="2" Rounding="Port" ZoneSize="3" />
<Corner SeqID="3" CompoundMarkID="3" Rounding="Port" ZoneSize="3" />
<Corner SeqID="4" CompoundMarkID="4" Rounding="Port" ZoneSize="3" />
<Corner SeqID="3" CompoundMarkID="3" Rounding="Port" ZoneSize="3" />
<Corner SeqID="5" CompoundMarkID="5" Rounding="SP" ZoneSize="3"/>
</CompoundMarkSequence>
<CourseLimit>
<Limit SeqID="1" Lat="32.313922" Lon="-64.837168"/>
<Limit SeqID="2" Lat="32.317379" Lon="-64.839291"/>
<Limit SeqID="3" Lat="32.317911" Lon="-64.836996"/>
<Limit SeqID="4" Lat="32.317257" Lon="-64.836260"/>
<Limit SeqID="5" Lat="32.304273" Lon="-64.822834"/>
<Limit SeqID="6" Lat="32.279097" Lon="-64.841545"/>
<Limit SeqID="7" Lat="32.279604" Lon="-64.849871"/>
<Limit SeqID="8" Lat="32.289545" Lon="-64.854162"/>
<Limit SeqID="9" Lat="32.290198" Lon="-64.858711"/>
<Limit SeqID="10" Lat="32.297164" Lon="-64.856394"/>
<Limit SeqID="11" Lat="32.296148" Lon="-64.849184"/>
</CourseLimit>
</Race>

12
src/main/resources/raceXML/Regatta.xml
Unescape View File

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="utf-8"?>
<RegattaConfig>
<RegattaID>1</RegattaID>
<RegattaName>Seng302 Mock Test</RegattaName>
<CourseName>Bermuda AC35</CourseName>
<CentralLatitude>-32.296577</CentralLatitude>
<CentralLongitude>64.854304</CentralLongitude>
<CentralAltitude>0.00</CentralAltitude>
<UtcOffset>-4</UtcOffset>
<MagneticVariation>-14.78</MagneticVariation>
</RegattaConfig>

69
src/test/java/seng302/Networking/BinaryMessageDecoderTest.java
Unescape View File

@ -0,0 +1,69 @@
package seng302.Networking;
import org.junit.Assert;
import org.junit.Test;
import org.xml.sax.InputSource;
import seng302.Networking.MessageDecoders.XMLMessageDecoder;
import seng302.Networking.MessageEncoders.XMLMessageEncoder;
import seng302.Networking.Utils.MessageType;
import java.io.*;
/**
* Created by hba56 on 21/04/17.
*/
public class BinaryMessageDecoderTest {
@Test
public void decodeTest(){
try{
StringBuilder xmlString;
BufferedReader br = new BufferedReader(new InputStreamReader(
this.getClass().getResourceAsStream(("../../raceXML/Regatta.xml"))));
String line;
xmlString = new StringBuilder();
while((line=br.readLine())!= null){
xmlString.append(line.trim());
}
long time = System.currentTimeMillis();
XMLMessageEncoder testEncoder = new XMLMessageEncoder((short)1, time, (byte)7, (short)1, (short)xmlString.length(), xmlString.toString());
byte[] encodedMessage = testEncoder.encode();
BinaryMesageEncoder testMessage = new BinaryMesageEncoder(MessageType.XMLMESSAGE, time, 1, (short)encodedMessage.length, encodedMessage);
BinaryMessageDecoder testDecoder = new BinaryMessageDecoder(testMessage.getFullMessage());
testDecoder.decode();
//message length
Assert.assertEquals((short) encodedMessage.length,testDecoder.getMessageLength());
//time stamp
Assert.assertEquals(time,testDecoder.getTimeStamp());
//source ID
Assert.assertEquals((short) 1, testDecoder.getSourceID());
//message type
Assert.assertEquals(26, testDecoder.getMessageType());
XMLMessageDecoder decoderXML = new XMLMessageDecoder(testDecoder.getMessage());
decoderXML.decode();
//tests from seng302.Networking.MessageDecoders.XMLMessageDecoderTest to make sure the file is still good
Assert.assertEquals((byte)1, decoderXML.getMessageVersionNumber());
Assert.assertEquals((short)1, decoderXML.getAckNumber());
Assert.assertEquals(time, decoderXML.getTimeStamp());
Assert.assertEquals((byte)7, decoderXML.getXmlMsgSubType());
Assert.assertEquals((short)1, decoderXML.getSequenceNumber());
Assert.assertEquals((short)xmlString.length(), decoderXML.getXmlMsgLength());
Reader reader = decoderXML.getXmlMessageInputSource().getCharacterStream();
int c;
String contents = "";
while((c = reader.read()) != -1) {
contents += (char)c;
}
Assert.assertEquals(xmlString.toString(), contents);
}catch (IOException e){
System.out.println(e);
}
}
}

165
src/test/java/seng302/Networking/ByteConverterTest.java
Unescape View File

@ -0,0 +1,165 @@
package seng302.Networking;
import org.junit.Test;
import seng302.Networking.Utils.ByteConverter;
import java.nio.ByteOrder;
import java.util.Arrays;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* Created by fwy13 on 25/04/17.
*/
public class ByteConverterTest {
@Test
public void testLargerIntToByte(){
int int1 = 1532158456; //100 in bytes
byte[] bytes1 = {(byte)0xF8, (byte)0xE1, 0x52, 0x5B};//this is in little endian
assertTrue(testArrayContents(ByteConverter.intToBytes(int1), bytes1));
byte[] bytes2 = {0x5B, 0x52, (byte)0xE1, (byte)0xF8};// this is big endian
assertTrue(testArrayContents(ByteConverter.intToBytes(int1, ByteConverter.IntegerSize, ByteOrder.BIG_ENDIAN), bytes2));
//test chopping
byte[] chopped1 = ByteConverter.intToBytes(int1, 3, ByteOrder.LITTLE_ENDIAN);
byte[] bytes3 = {(byte)0xF8, (byte)0xE1, 0x52};
assertTrue(testArrayContents(chopped1, bytes3));
byte[] chopped2 = ByteConverter.intToBytes(int1, 2, ByteOrder.LITTLE_ENDIAN);
byte[] bytes4 = {(byte)0xF8, (byte)0xE1};
assertTrue(testArrayContents(chopped2, bytes4));
byte[] chopped3 = ByteConverter.intToBytes(int1, 1, ByteOrder.LITTLE_ENDIAN);
byte[] bytes5 = {(byte)0xF8};
assertTrue(testArrayContents(chopped3, bytes5));
byte[] chopped4 = ByteConverter.intToBytes(int1, 3, ByteOrder.BIG_ENDIAN);
byte[] bytes6 = {0x52, (byte)0xE1, (byte)0xF8};
assertTrue(testArrayContents(chopped4, bytes6));
byte[] chopped5 = ByteConverter.intToBytes(int1, 2, ByteOrder.BIG_ENDIAN);
byte[] bytes7 = {(byte)0xE1, (byte)0xF8};
assertTrue(testArrayContents(chopped5, bytes7));
byte[] chopped6 = ByteConverter.intToBytes(int1, 1, ByteOrder.BIG_ENDIAN);
byte[] bytes8 = {(byte)0xF8};
assertTrue(testArrayContents(chopped6, bytes8));
}
@Test
public void testByteToInt(){
int int1 = 100; //100 in bytes
byte[] bytes1 = {100, 0, 0, 0};//this is in little endian
assertTrue(ByteConverter.bytesToInt(bytes1) == int1);
assertTrue(ByteConverter.bytesToInt(bytes1, ByteOrder.LITTLE_ENDIAN) == int1);
byte[] bytes2 = {0, 0, 0, 100};// this is big endian
assertTrue(ByteConverter.bytesToInt(bytes2, ByteOrder.BIG_ENDIAN) == int1);
//check single bytes to integers
assertTrue(ByteConverter.bytesToInt((byte)100) == int1);
}
@Test
public void testByteToLong(){
long lng1 = 15; //100 in bytes
byte[] bytes1 = {15, 0, 0, 0, 0, 0, 0, 0};//this is in little endian
assertTrue(ByteConverter.bytesToLong(bytes1) == lng1);
assertTrue(ByteConverter.bytesToLong(bytes1, ByteOrder.LITTLE_ENDIAN) == lng1);
byte[] bytes2 = {0, 0, 0, 0, 0, 0, 0, 15};// this is big endian
assertTrue(ByteConverter.bytesToLong(bytes2, ByteOrder.BIG_ENDIAN) == lng1);
//check single bytes to integers
assertTrue(ByteConverter.bytesToLong((byte)15) == lng1);
}
@Test
public void testByteToShort(){
short short1 = 20; //100 in bytes
byte[] bytes1 = {20, 0};//this is in little endian
assertTrue(ByteConverter.bytesToShort(bytes1) == short1);
assertTrue(ByteConverter.bytesToShort(bytes1, ByteOrder.LITTLE_ENDIAN) == short1);
byte[] bytes2 = {0, 20};// this is big endian
assertTrue(ByteConverter.bytesToShort(bytes2, ByteOrder.BIG_ENDIAN) == short1);
//check single bytes to integers
assertTrue(ByteConverter.bytesToShort((byte)20) == short1);
}
@Test
public void testByteToChar(){
char char1 = 20; //100 in bytes
byte[] bytes1 = {20, 0};//this is in little endian
assertTrue(ByteConverter.bytesToChar(bytes1) == char1);
assertTrue(ByteConverter.bytesToChar(bytes1, ByteOrder.LITTLE_ENDIAN) == char1);
byte[] bytes2 = {0, 20};// this is big endian
assertTrue(ByteConverter.bytesToChar(bytes2, ByteOrder.BIG_ENDIAN) == char1);
//check single bytes to integers
assertTrue(ByteConverter.bytesToChar((byte)20) == char1);
}
@Test
public void testIntToByte(){
int int1 = 100; //100 in bytes
byte[] bytes1 = {100, 0, 0, 0};//this is in little endian
assertTrue(testArrayContents(ByteConverter.intToBytes(int1), bytes1));
byte[] bytes2 = {0, 0, 0, 100};// this is big endian
assertTrue(testArrayContents(ByteConverter.intToBytes(int1, ByteConverter.IntegerSize, ByteOrder.BIG_ENDIAN), bytes2));
//test chopping
byte[] chopped1 = ByteConverter.intToBytes(int1, 3, ByteOrder.LITTLE_ENDIAN);
byte[] bytes3 = {100, 0, 0};
assertTrue(testArrayContents(chopped1, bytes3));
byte[] chopped2 = ByteConverter.intToBytes(int1, 2, ByteOrder.LITTLE_ENDIAN);
byte[] bytes4 = {100, 0};
assertTrue(testArrayContents(chopped2, bytes4));
byte[] chopped3 = ByteConverter.intToBytes(int1, 1, ByteOrder.LITTLE_ENDIAN);
byte[] bytes5 = {100};
assertTrue(testArrayContents(chopped3, bytes5));
byte[] chopped4 = ByteConverter.intToBytes(int1, 3, ByteOrder.BIG_ENDIAN);
byte[] bytes6 = {0, 0, 100};
assertTrue(testArrayContents(chopped4, bytes6));
byte[] chopped5 = ByteConverter.intToBytes(int1, 2, ByteOrder.BIG_ENDIAN);
byte[] bytes7 = {0, 100};
assertTrue(testArrayContents(chopped5, bytes7));
byte[] chopped6 = ByteConverter.intToBytes(int1, 1, ByteOrder.BIG_ENDIAN);
byte[] bytes8 = {100};
assertTrue(testArrayContents(chopped6, bytes8));
}
@Test
public void testLongToBytes(){
long lng1 = 15; //100 in bytes
byte[] bytes1 = {15, 0, 0, 0, 0, 0, 0, 0};//this is in little endian
assertTrue(testArrayContents(ByteConverter.longToBytes(lng1), bytes1));
byte[] bytes2 = {0, 0, 0, 0, 0, 0, 0, 15};// this is big endian
assertTrue(testArrayContents(ByteConverter.longToBytes(lng1, ByteConverter.LongSize, ByteOrder.BIG_ENDIAN), bytes2));
//test chopping
byte[] chopped1 = ByteConverter.longToBytes(lng1, 3, ByteOrder.LITTLE_ENDIAN);
byte[] bytes3 = {15, 0, 0};
assertTrue(testArrayContents(chopped1, bytes3));
byte[] chopped2 = ByteConverter.longToBytes(lng1, 2, ByteOrder.LITTLE_ENDIAN);
byte[] bytes4 = {15, 0};
assertTrue(testArrayContents(chopped2, bytes4));
byte[] chopped3 = ByteConverter.longToBytes(lng1, 1, ByteOrder.LITTLE_ENDIAN);
byte[] bytes5 = {15};
assertTrue(testArrayContents(chopped3, bytes5));
byte[] chopped4 = ByteConverter.longToBytes(lng1, 3, ByteOrder.BIG_ENDIAN);
byte[] bytes6 = {0, 0, 15};
assertTrue(testArrayContents(chopped4, bytes6));
byte[] chopped5 = ByteConverter.longToBytes(lng1, 2, ByteOrder.BIG_ENDIAN);
byte[] bytes7 = {0, 15};
assertTrue(testArrayContents(chopped5, bytes7));
byte[] chopped6 = ByteConverter.longToBytes(lng1, 1, ByteOrder.BIG_ENDIAN);
byte[] bytes8 = {15};
assertTrue(testArrayContents(chopped6, bytes8));
}
public boolean testArrayContents(byte[] bytes1, byte[] bytes2){
if (bytes1.length != bytes2.length){
return false;
}
for (int i = 0; i < bytes1.length; i++){
if (bytes1[i] != bytes2[i]){
return false;
}
}
return true;
}
}

49
src/test/java/seng302/Networking/MessageDecoders/BoatLocationDecoderTest.java
Unescape View File

@ -0,0 +1,49 @@
package seng302.Networking.MessageDecoders;
import org.junit.Assert;
import org.junit.Test;
import seng302.Networking.Utils.BoatLocationMessage;
import seng302.Networking.MessageEncoders.RaceVisionByteEncoder;
/**
* Created by hba56 on 23/04/17.
*/
public class BoatLocationDecoderTest {
@Test
public void getByteArrayTest(){
long time = System.currentTimeMillis();
BoatLocationMessage testMessage = new BoatLocationMessage(1, time, 2,
3, 1, 180, -180, 4, 5,
6, 7, 8, 9, 10, 11,
12, 13, 14 , 15,
16, 17, 18);
RaceVisionByteEncoder raceVisionByteEncoder = new RaceVisionByteEncoder();
byte [] testEncodedMessage = raceVisionByteEncoder.boatLocation(testMessage);
BoatLocationDecoder testDecoder = new BoatLocationDecoder(testEncodedMessage);
BoatLocationMessage decodedTest = testDecoder.getMessage();
Assert.assertEquals(testMessage.getMessageVersionNumber(), decodedTest.getMessageVersionNumber());
Assert.assertEquals(testMessage.getTime(), decodedTest.getTime());
Assert.assertEquals(testMessage.getSequenceNumber(), decodedTest.getSequenceNumber());
Assert.assertEquals(testMessage.getDeviceType(), decodedTest.getDeviceType());
Assert.assertEquals(testMessage.getLatitude(), decodedTest.getLatitude());
Assert.assertEquals(testMessage.getLongitude(), decodedTest.getLongitude());
Assert.assertEquals(testMessage.getAltitude(), decodedTest.getAltitude());
Assert.assertEquals(testMessage.getHeading(), decodedTest.getHeading());
Assert.assertEquals(testMessage.getPitch(), decodedTest.getPitch());
Assert.assertEquals(testMessage.getRoll(), decodedTest.getRoll());
Assert.assertEquals(testMessage.getBoatSpeed(), decodedTest.getBoatSpeed());
Assert.assertEquals(testMessage.getBoatCOG(), decodedTest.getBoatCOG());
Assert.assertEquals(testMessage.getBoatSOG(), decodedTest.getBoatSOG());
Assert.assertEquals(testMessage.getApparentWindSpeed(), decodedTest.getApparentWindSpeed());
Assert.assertEquals(testMessage.getTrueWindSpeed(), decodedTest.getTrueWindSpeed());
Assert.assertEquals(testMessage.getTrueWindDirection(), decodedTest.getTrueWindDirection());
Assert.assertEquals(testMessage.getTrueWindAngle(), decodedTest.getTrueWindAngle());
Assert.assertEquals(testMessage.getCurrentDrift(), decodedTest.getCurrentDrift());
Assert.assertEquals(testMessage.getCurrentSet(), decodedTest.getCurrentSet());
Assert.assertEquals(testMessage.getRudderAngle(), decodedTest.getRudderAngle());
}
}

59
src/test/java/seng302/Networking/MessageDecoders/CourseWindDecoderTest.java
Unescape View File

@ -0,0 +1,59 @@
package seng302.Networking.MessageDecoders;
import org.junit.Assert;
import org.junit.Test;
import seng302.Networking.Utils.CourseWind;
import seng302.Networking.MessageEncoders.RaceVisionByteEncoder;
import java.util.ArrayList;
/**
* Created by hba56 on 23/04/17.
*/
public class CourseWindDecoderTest {
@Test
public void getByteArrayTest(){
long time = System.currentTimeMillis();
CourseWind testCourseWind1 = new CourseWind(1, time, 2,
3, 4, 5,
7, 6);
long time2 = System.currentTimeMillis();
CourseWind testCourseWind2 = new CourseWind(2, time2, 2,
3, 4, 5,
7, 6);
ArrayList<CourseWind> testCourseWinds = new ArrayList<CourseWind>();
testCourseWinds.add(testCourseWind1);
testCourseWinds.add(testCourseWind2);
RaceVisionByteEncoder raceVisionByteEncoder = new RaceVisionByteEncoder();
byte[] testEncodedCourseWind = raceVisionByteEncoder.courseWind((byte) 1, testCourseWinds);
CourseWindDecoder testDecoder = new CourseWindDecoder(testEncodedCourseWind);
ArrayList<CourseWind> testDecodedCourseWinds = testDecoder.getLoopMessages();
Assert.assertEquals(testCourseWinds.get(0).getID(), testDecodedCourseWinds.get(0).getID());
Assert.assertEquals(testCourseWinds.get(0).getTime(), testDecodedCourseWinds.get(0).getTime());
Assert.assertEquals(testCourseWinds.get(0).getRaceID(), testDecodedCourseWinds.get(0).getRaceID());
Assert.assertEquals(testCourseWinds.get(0).getWindDirection(), testDecodedCourseWinds.get(0).getWindDirection());
Assert.assertEquals(testCourseWinds.get(0).getWindSpeed(), testDecodedCourseWinds.get(0).getWindSpeed());
Assert.assertEquals(testCourseWinds.get(0).getBestUpwindAngle(), testDecodedCourseWinds.get(0).getBestUpwindAngle());
Assert.assertEquals(testCourseWinds.get(0).getBestDownwindAngle(), testDecodedCourseWinds.get(0).getBestDownwindAngle());
Assert.assertEquals(testCourseWinds.get(0).getFlags(), testDecodedCourseWinds.get(0).getFlags());
Assert.assertEquals(testCourseWinds.get(1).getID(), testDecodedCourseWinds.get(1).getID());
Assert.assertEquals(testCourseWinds.get(1).getTime(), testDecodedCourseWinds.get(1).getTime());
Assert.assertEquals(testCourseWinds.get(1).getRaceID(), testDecodedCourseWinds.get(1).getRaceID());
Assert.assertEquals(testCourseWinds.get(1).getWindDirection(), testDecodedCourseWinds.get(1).getWindDirection());
Assert.assertEquals(testCourseWinds.get(1).getWindSpeed(), testDecodedCourseWinds.get(1).getWindSpeed());
Assert.assertEquals(testCourseWinds.get(1).getBestUpwindAngle(), testDecodedCourseWinds.get(1).getBestUpwindAngle());
Assert.assertEquals(testCourseWinds.get(1).getBestDownwindAngle(), testDecodedCourseWinds.get(1).getBestDownwindAngle());
Assert.assertEquals(testCourseWinds.get(1).getFlags(), testDecodedCourseWinds.get(1).getFlags());
}
}

30
src/test/java/seng302/Networking/MessageDecoders/RaceStartStatusDecoderTest.java
Unescape View File

@ -0,0 +1,30 @@
package seng302.Networking.MessageDecoders;
import org.junit.Assert;
import org.junit.Test;
import seng302.Networking.MessageEncoders.RaceVisionByteEncoder;
/**
* Created by hba56 on 23/04/17.
*/
public class RaceStartStatusDecoderTest {
@Test
public void getByteArrayTest(){
long time = System.currentTimeMillis();
RaceVisionByteEncoder raceVisionByteEncoder = new RaceVisionByteEncoder();
long time2 = System.currentTimeMillis();
byte[] encodedRaceStartStatus = raceVisionByteEncoder.raceStartStatus(time, (short)1,
time2, 2, (char)3);
RaceStartStatusDecoder testDecoder = new RaceStartStatusDecoder(encodedRaceStartStatus);
Assert.assertEquals(0b1, testDecoder.getMessageVersion());
Assert.assertEquals(time, testDecoder.getTime());
Assert.assertEquals(1, testDecoder.getAck());
Assert.assertEquals(time2, testDecoder.getStartTime());
Assert.assertEquals(2, testDecoder.getRaceID());
Assert.assertEquals((char)3, testDecoder.getNotification());
}
}

49
src/test/java/seng302/Networking/MessageDecoders/RaceStatusDecoderTest.java
Unescape View File

@ -0,0 +1,49 @@
package seng302.Networking.MessageDecoders;
import javafx.scene.paint.Color;
import org.junit.Assert;
import org.junit.Test;
import seng302.Model.BoatInRace;
import seng302.Model.Leg;
import seng302.Networking.MessageEncoders.RaceVisionByteEncoder;
import java.util.ArrayList;
/**
* Created by hba56 on 23/04/17.
*/
public class RaceStatusDecoderTest {
@Test
public void getByteArrayTest(){
long time = System.currentTimeMillis();
BoatInRace boat1 = new BoatInRace("Test", 1, Color.ALICEBLUE, "tt");
Leg testLeg = new Leg("test leg", 1);
boat1.setCurrentLeg(testLeg);
BoatInRace boat2 = new BoatInRace("Test2", 1, Color.ALICEBLUE, "tt");
boat2.setCurrentLeg(testLeg);
ArrayList boats = new ArrayList();
boats.add(boat1);
boats.add(boat2);
long time2 = System.currentTimeMillis();
RaceVisionByteEncoder raceVisionByteEncoder = new RaceVisionByteEncoder();
byte[] encodedRaceStatus = raceVisionByteEncoder.raceStatus(time, 1, 2, time2,
(short)2, (short)3,4, boats);
RaceStatusDecoder decoderTest = new RaceStatusDecoder(encodedRaceStatus);
Assert.assertEquals(0b10, decoderTest.getVersionNum());
Assert.assertEquals(time, decoderTest.getTime());
Assert.assertEquals(1, decoderTest.getRace());
Assert.assertEquals(2, decoderTest.getRaceState());
Assert.assertEquals(time2, decoderTest.getStartTime());
Assert.assertEquals(2, decoderTest.getRaceWindDir());
Assert.assertEquals((short)3, decoderTest.getRaceWindSpeed());
Assert.assertEquals(0, decoderTest.getBoats().get(0).getBoatStatus());
Assert.assertEquals(0, decoderTest.getBoats().get(0).getLegNumber());
Assert.assertEquals(0, decoderTest.getBoats().get(0).getNumPenaltiesAwarded());
}
}

55
src/test/java/seng302/Networking/MessageDecoders/XMLMessageDecoderTest.java
Unescape View File

@ -0,0 +1,55 @@
package seng302.Networking.MessageDecoders;
import org.junit.Assert;
import org.junit.Test;
import seng302.Networking.MessageEncoders.XMLMessageEncoder;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
/**
* Created by hba56 on 20/04/17.
*/
public class XMLMessageDecoderTest {
@Test
public void getByteArrayTest(){
try{
StringBuilder xmlString;
BufferedReader br = new BufferedReader(new InputStreamReader(
this.getClass().getResourceAsStream(("../../../raceXML/Regatta.xml"))));
String line;
xmlString = new StringBuilder();
while((line=br.readLine())!= null){
xmlString.append(line.trim());
}
long time = System.currentTimeMillis();
XMLMessageEncoder testEncoder = new XMLMessageEncoder((short)1, time, (byte)7, (short)1, (short)xmlString.length(), xmlString.toString());
byte[] encodedXML = testEncoder.encode();
XMLMessageDecoder decoderXML = new XMLMessageDecoder(encodedXML);
decoderXML.decode();
Assert.assertEquals((byte)1, decoderXML.getMessageVersionNumber());
Assert.assertEquals((short)1, decoderXML.getAckNumber());
Assert.assertEquals(time, decoderXML.getTimeStamp());
Assert.assertEquals((byte)7, decoderXML.getXmlMsgSubType());
Assert.assertEquals((short)1, decoderXML.getSequenceNumber());
Assert.assertEquals((short)xmlString.length(), decoderXML.getXmlMsgLength());
Reader reader = decoderXML.getXmlMessageInputSource().getCharacterStream();
int c;
String contents = "";
while((c = reader.read()) != -1) {
contents += (char)c;
}
Assert.assertEquals(xmlString.toString(), contents);
}catch (IOException e){
System.out.println(e);
}
}
}

55
src/test/java/seng302/Networking/XMLMessageEncoderTest.java
Unescape View File

@ -0,0 +1,55 @@
package seng302.Networking;
import org.junit.Assert;
import org.junit.Test;
import seng302.Networking.MessageEncoders.XMLMessageEncoder;
import java.io.*;
/**
* Created by hba56 on 19/04/17.
*/
public class XMLMessageEncoderTest {
@Test
public void getByteArrayTest(){
StringBuilder xmlString;
try{
BufferedReader br = new BufferedReader(new InputStreamReader(
this.getClass().getResourceAsStream(("../../raceXML/Regatta.xml"))));
String line;
xmlString = new StringBuilder();
while((line=br.readLine())!= null){
xmlString.append(line.trim());
}
XMLMessageEncoder testEncoder = new XMLMessageEncoder((short)1, System.currentTimeMillis(), (byte)7, (short)1, (short)xmlString.length(), xmlString.toString());
byte[] encodedXML = testEncoder.encode();
//1 + 2 + 6 + 1 + 2 + 2 + 374
Assert.assertEquals(388, encodedXML.length);
}catch (IOException e){
System.out.println(e);
}
}
@Test
public void getByteArrayNullTest(){
StringBuilder xmlString;
try{
BufferedReader br = new BufferedReader(new InputStreamReader(
this.getClass().getResourceAsStream(("../../raceXML/Regatta.xml"))));
String line;
xmlString = new StringBuilder();
while((line=br.readLine())!= null){
xmlString.append(line.trim());
}
XMLMessageEncoder testEncoder = new XMLMessageEncoder((short)1, System.currentTimeMillis(), (byte)7, (short)1, (short)1, xmlString.toString());
byte[] encodedXML = testEncoder.encode();
Assert.assertEquals(null, encodedXML);
}catch (IOException e){
System.out.println(e);
}
}
}

12
src/test/resources/raceXML/Regatta.xml
Unescape View File

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="utf-8"?>
<RegattaConfig>
<RegattaID>1</RegattaID>
<RegattaName>Seng302 Mock Test</RegattaName>
<CourseName>Bermuda AC35</CourseName>
<CentralLatitude>-32.296577</CentralLatitude>
<CentralLongitude>64.854304</CentralLongitude>
<CentralAltitude>0.00</CentralAltitude>
<UtcOffset>-4</UtcOffset>
<MagneticVariation>-14.78</MagneticVariation>
</RegattaConfig>

50
visualiser/src/main/java/seng302/App.java
Unescape View File

@ -29,54 +29,4 @@ public class App extends Application {
stage.show(); stage.show();
} }
// /**
// * Loads and sets up the GUI elements
// *
// * @param primaryStage Base for all scenes
// * @throws Exception Error in initialising programme
// */
// @Override
// public void start(Stage primaryStage) throws Exception {
// this.primaryStage = primaryStage;
// primaryStage.minHeightProperty().setValue(600);
// primaryStage.minWidthProperty().setValue(780);
// //load the first container
// try {
// FXMLLoader loader = new FXMLLoader();
// InputStream in = getClass().getClassLoader().getResourceAsStream("scenes/main.fxml");
// mainContainer = (BorderPane) loader.load(in);
// mainScene = new Scene(mainContainer, 1200, 800);
// primaryStage.setScene(mainScene);
// primaryStage.sizeToScene();
// MainController mainController = (MainController) loader.getController();
// mainController.setParent(this);
// in.close();
// //add the center
// loadPane("race.fxml");
// } catch (Exception e) {
// e.printStackTrace();
// }
// primaryStage.show();
// }
//
// /**
// * Loads panes for use in the GUI
// *
// * @param fxmlName name of resource fxml file
// * @throws Exception critical error in loading file
// */
// public void loadPane(String fxmlName) throws Exception {
// FXMLLoader loader = new FXMLLoader();
// InputStream in = getClass().getClassLoader().getResourceAsStream("scenes/" + fxmlName);
// Parent page;
// try {
// page = (Parent) loader.load(in);
// } finally {
// in.close();
// }
// mainContainer.getChildren().remove(mainContainer.getCenter());
// mainContainer.setCenter(page);
// Controller controller = (Controller) loader.getController();
// controller.setParent(this);
// }
} }

Write Preview
Loading…
Cancel
Save