private void readSettingsBtn_Click(object sender, EventArgs e)
{
// $PTNT8,0
var cStr = NMEAParser.BuildProprietarySentence(ManufacturerCodes.TNT, "8", new object[] { 0 });
Send(cStr);
}
public APLEmulator()
{
timer = new PrecisionTimer();
timer.Period = 10;
timer.Mode = Mode.Periodic;
timer.Tick += (o, e) =>
{
sec += 0.01;
if (sec > data[idx][0])
{
var msg = NMEAParser.BuildProprietarySentence(ManufacturerCodes.APL, "A", new object[]
{
Convert.ToInt32(data[idx][1]),
data[idx][2],
data[idx][3],
data[idx][4],
1,
data[idx][5]
});
EmulatorOutputEvent.Rise(this, new NewNMEAMessageEventArgs(msg));
idx++;
if (idx >= data.Count)
{
sec = 0;
idx = 0;
}
}
};
}
private void locDataQueryBtn_Click(object sender, EventArgs e)
{
// $PTNT4,locDataID,reserved
var cStr = NMEAParser.BuildProprietarySentence(ManufacturerCodes.TNT, "4", new object[] { (int)locDataID, 0 });
Send(cStr);
}
public MainForm()
{
InitializeComponent();
timer = new PrecisionTimer();
timer.Period = 6000;
timer.Tick += new EventHandler(timer_Tick);
initialPortSpeedCbx.SelectedIndex = 0;
portNameCbx.Items.AddRange(SerialPort.GetPortNames());
#region NMEA
NMEAParser.AddManufacturerToProprietarySentencesBase(ManufacturerCodes.UCN);
NMEAParser.AddProprietarySentenceDescription(ManufacturerCodes.UCN, "L", "x,x,c--c");
#endregion
if (portNameCbx.Items.Count > 0)
{
portNameCbx.SelectedIndex = 0;
SetCtrlState(true);
}
else
{
SetCtrlState(false);
}
}
private void Parse(int sourceID, string message)
{
NMEAIncomingMessageReceived.Rise(this, new NMEAMessageEventArgs(sourceID, message));
try
{
var pResult = NMEAParser.Parse(message);
if (pResult is NMEAStandartSentence)
{
NMEAStandartSentence sentence = (NMEAStandartSentence)pResult;
if (standardSenteceParsers.ContainsKey(sentence.SentenceID))
{
standardSenteceParsers[sentence.SentenceID](sourceID, sentence.TalkerID, sentence.parameters);
}
else
{
NMEAStandartUnsupportedSentenceParsed.Rise(this, new NMEAUnsupportedStandartEventArgs(sourceID, sentence));
}
}
else
{
NMEAProprietaryUnsupportedSentenceParsed.Rise(this, new NMEAUnsupportedProprietaryEventArgs(sourceID, (pResult as NMEAProprietarySentence)));
}
}
catch (Exception ex)
{
LogEventHandler.Rise(this, new LogEventArgs(LogLineType.ERROR, ex));
}
}
public void WXTMsgTest()
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
string message = "$WIXDR,A,204,D,0,A,219,D,1,A,248,D,2,S,0.9,M,0,S,1.2,M,1,S,1.6,M,2*5A" + Environment.NewLine;
var nmeaSentence = NMEAParser.Parse(message);
stopWatch.Stop();
Debug.WriteLine("Time 1:" + stopWatch.ElapsedTicks);
var tmp = (NMEAStandardSentence)nmeaSentence;
var talkerID = tmp.TalkerID;
var sentenceIdentifiers = tmp.SentenceID;
stopWatch.Start();
message = "$WIXDR,C,22.7,C,0,H,41.5,P,0,P,1017.7,H,0*79" + Environment.NewLine;
nmeaSentence = NMEAParser.Parse(message);
stopWatch.Stop();
Debug.WriteLine("Time 2:" + stopWatch.ElapsedTicks);
stopWatch.Start();
message = "$WIXDR,A,204,D,0,A,219,D,1,A,248,D,2,S,0.9,M,0,S,1.2,M,1,S,1.6,M,2*5A" + Environment.NewLine;
nmeaSentence = NMEAParser.Parse(message);
stopWatch.Stop();
Debug.WriteLine("Time 3:" + stopWatch.ElapsedTicks);
}
private void writeSettingsBtn_Click(object sender, EventArgs e)
{
// $PTNT7,rxChID,txChID,isRTX
var cStr = NMEAParser.BuildProprietarySentence(ManufacturerCodes.TNT, "7", new object[] { rxChId, txChId, Convert.ToInt32(isRetranslation), Convert.ToInt32(isReverse) });
Send(cStr);
}
private void gtr_QueryRemote(int targetAddr, CDS_CMD cmd, int timeoutMs)
{
// $PTNTE,targetAddr,requestedCmd,timeoutMs
var msg = NMEAParser.BuildProprietarySentence(ManufacturerCodes.TNT, "E", new object[] { targetAddr, (int)cmd, timeoutMs });
gtr_requestID = cmd;
gtr_TrySend(msg, string.Format("RedGTR << ? SUB #{0}, CMD {1}, TMO {2} ms", targetAddr, cmd, timeoutMs), true);
}
public MainForm()
{
InitializeComponent();
var portNames = SerialPort.GetPortNames();
if (portNames.Length > 0)
{
#region Other
buoyAddrCbx.Items.AddRange(Enum.GetNames(typeof(RedBASE_Addr)));
BuoyAddr = RedBASE_Addr.REDBASE_ADDR_INVALID;
#endregion
#region NMEA
NMEAParser.AddManufacturerToProprietarySentencesBase(ManufacturerCodes.TNT);
NMEAParser.AddProprietarySentenceDescription(ManufacturerCodes.TNT, "0", "x"); // ACK $PTNT0,errCode
NMEAParser.AddProprietarySentenceDescription(ManufacturerCodes.TNT, "4", "x,x"); // LOC_DATA_GET $PTNT4,dataID,reserved
NMEAParser.AddProprietarySentenceDescription(ManufacturerCodes.TNT, "5", "x,x"); // LOC_DATA_VAL $PTNT5,dataID,dataVal
NMEAParser.AddProprietarySentenceDescription(ManufacturerCodes.TNT, "!", "c--c,x,c--c,x,x,c--c"); // DEV_INFO $PTNT!,sys_moniker,sys_ver,dev_type,core_moniker,core_ver,dev_serial_num
NMEAParser.AddProprietarySentenceDescription(ManufacturerCodes.TNT, "7", "x"); // SETTINGS_GET $PTNT7,reserved
NMEAParser.AddProprietarySentenceDescription(ManufacturerCodes.TNT, "8", "x,x"); // SETTINGS_SET $PTNT8,buoyAddr,isInverted
NMEAParser.AddProprietarySentenceDescription(ManufacturerCodes.TNT, "9", "x,x"); // SETTINGS_VAL $PTNT9,buoyAddr,isInverted
#endregion
#region timer
timer = new PrecisionTimer();
timer.Period = 1000;
timer.Mode = Mode.Periodic;
timer.Tick += new EventHandler(timer_Tick);
timer.Started += new EventHandler(timer_Started);
timer.Stopped += new EventHandler(timer_Stopped);
#endregion
#region port
port = new NMEASerialPort(new SerialPortSettings("COM1", BaudRate.baudRate9600, Parity.None, DataBits.dataBits8, StopBits.One, Handshake.None));
port.NewNMEAMessage += new EventHandler <NewNMEAMessageEventArgs>(port_NewNMEAMessage);
port.PortError += new EventHandler <SerialErrorReceivedEventArgs>(port_Error);
port.IsRawModeOnly = false;
#endregion
portNameCbx.Items.AddRange(portNames);
portNameCbx.SelectedIndex = 0;
State = AppState.PORT_CLOSED;
}
else
{
State = AppState.PORT_ABSENT;
}
}
public void Parse_OneSatelliteData_OneListLength()
{
string testData = "$GPGSV,3,1,12,30,72,253,36,,,,,,,,,,,,*76";
int expectedCount = 1;
var entityList = NMEAParser.Parse(new List <string>(new string[] { testData })).Key.ToList();
Assert.AreEqual(expectedCount, entityList.Count);
}
public void ParseGPGGAStringWithNullField()
{
string str = "$GPGGA,,,,,,,,,,,99.99,M,,*35";
var parser = new NMEAParser();
var res = parser.Parse(str);
FixData data = (FixData)res;
}
public void Parse_FourSatelliteData_FourListLength()
{
string testData = "$GPGSV,3,1,12,30,72,253,36,05,70,124,42,24,37,082,43,02,37,112,45*76";
int expectedCount = 4;
var entityList = NMEAParser.Parse(new List <string>(new string[] { testData })).Key.ToList();
Assert.AreEqual(expectedCount, entityList.Count);
}
public bool PacketMode_Send(byte target_ptAddress, byte maxTries, byte[] data)
{
if (data.Length <= uWAVE.PT_MAX_PACKET_SIZE)
{
var msg = NMEAParser.BuildProprietarySentence(ManufacturerCodes.UWV, "G", new object[] { (int)target_ptAddress, (int)maxTries, data });
return(TrySend(msg, ICs.IC_H2D_PT_SEND));
}
return(false);
}
private void OnPortFree()
{
if (dataToSend.Count > 0)
{
var msg = NMEAParser.BuildProprietarySentence(ManufacturerCodes.MCP, "4", new object[] { dataToSend.Dequeue() });
port.SendData(msg);
IsWaiting = true;
}
}
private void port_NewNMEAMessage(object sender, NewNMEAMessageEventArgs e)
{
try
{
var sentence = NMEAParser.Parse(e.Message);
if (sentence is NMEAProprietarySentence)
{
NMEAProprietarySentence snt = ((NMEAProprietarySentence)(sentence));
if (snt.SentenceIDString == "0")
{
// ACK - analyze error code
Process_ACK(snt.parameters);
}
else if (snt.SentenceIDString == "5")
{
// local data value
Process_LOC_DATA(snt.parameters);
}
else if (snt.SentenceIDString == "3")
{
// settings field value
Process_FLD_Value(snt.parameters);
}
else if (snt.SentenceIDString == "!")
{
// device info
Process_DEVICE_INFO(snt.parameters);
}
else if (snt.SentenceIDString == "!!")
{
Process_DEVICE_INFO_RN(snt.parameters);
}
else if (snt.SentenceIDString == "I")
{
// track point val
Process_TRACK_POINT_VAL(snt.parameters);
}
else if (snt.SentenceIDString == "L")
{
// waypoint value
Process_WAYPOINT_VAL(snt.parameters);
}
}
else
{
// TODO: write log
}
}
catch (Exception ex)
{
// TODO: write log
}
}
public void Start(byte SID, byte TID, bool selectDefaultState, int selIntMs, int toutIntMs)
{
if (!isWaiting)
{
var msg = NMEAParser.BuildProprietarySentence(ManufacturerCodes.MCP, "1",
new object[] { SID, TID, Convert.ToInt32(selectDefaultState), selIntMs, toutIntMs });
port.SendData(msg);
isWaiting = true;
}
}
public void ParseGPVTGString()
{
string str = "$GPVTG,055.7,T,034.4,M,005.5,N,010.2,K*49";
var parser = new NMEAParser();
var res = parser.Parse(str);
CourseData data = (CourseData)res;
Assert.AreEqual(55.7, data.COG);
Assert.AreEqual(5.5, data.KnotSOG);
Assert.AreEqual(10.2, data.KphSOG);
}
private void applyBuoyAddrBtn_Click(object sender, EventArgs e)
{
string message = NMEAParser.BuildProprietarySentence(ManufacturerCodes.TNT, "8", new object[] { BuoyAddr, 0 });
if (TrySend(message))
{
State = AppState.DEV_SETTINGS_APPLY_QUERIED;
}
else
{
State = AppState.PORT_ERROR;
}
}
private void Parse_RMC(object[] parameters)
{
DateTime tStamp = (DateTime)parameters[0];
var latitude = doubleNullChecker(parameters[2]);
var longitude = doubleNullChecker(parameters[4]);
var groundSpeed = doubleNullChecker(parameters[6]);
var courseOverGround = doubleNullChecker(parameters[7]);
var dateTime = (DateTime)parameters[8];
var magneticVariation = doubleNullChecker(parameters[9]);
bool isValid = (parameters[1].ToString() != "Invalid") &&
(!double.IsNaN(latitude)) &&
(!double.IsNaN(longitude)) &&
(!double.IsNaN(groundSpeed)) &&
(!double.IsNaN(courseOverGround)) &&
(parameters[11].ToString() != "N");
if (isValid)
{
dateTime.AddHours(tStamp.Hour);
dateTime.AddMinutes(tStamp.Minute);
dateTime.AddSeconds(tStamp.Second);
dateTime.AddMilliseconds(tStamp.Millisecond);
groundSpeed = NMEAParser.NM2Km(groundSpeed);
if (parameters[3].ToString() == "South")
{
latitude = -latitude;
}
if (parameters[5].ToString() == "West")
{
longitude = -longitude;
}
bLatitude.Value = latitude;
bLongitude.Value = longitude;
GeoPoint newPoint = new GeoPoint();
newPoint.Latitude = latitude;
newPoint.Longitude = longitude;
bLocation.Add(newPoint);
InvokeUpdateTrack("BOAT GNSS", latitude, longitude);
InvokeInvalidatePlot();
InvokeSetEnabled(mainToolStrip, tracksBtn, true);
}
}
public void ParseUnknownNMEAString()
{
string str = "$GPABC,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*46";
var parser = new NMEAParser();
try
{
var res = parser.Parse(str);
Assert.Fail("Parsing message with unknown message type should fail");
}
catch (Legacy.UnknownMessageException)
{
}
}
public bool SettingsWriteQuery(int txChID, int rxChID, double salinityPSU, bool isCmdMode, bool isACKOnTXFinished, double gravityAcc)
{
var msg = NMEAParser.BuildProprietarySentence(ManufacturerCodes.UWV, "1", new object[]
{
txChID,
rxChID,
salinityPSU,
Convert.ToInt32(isCmdMode),
Convert.ToInt32(isACKOnTXFinished),
gravityAcc
});
return(TrySend(msg, ICs.IC_H2D_SETTINGS_WRITE));
}
public void ParseGPGGAStringFalseChecksum()
{
string str = "$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*12";
var parser = new NMEAParser();
try
{
var res = parser.Parse(str);
Assert.Fail("Parsing message with invalid checksum should fail");
}
catch (Legacy.InvalidChecksumException)
{
}
}
public string QueryMirroredSet(bool isMirrored)
{
int fldVal;
if (isMirrored)
{
fldVal = 1;
}
else
{
fldVal = 0;
}
return(NMEAParser.BuildProprietarySentence(ManufacturerCodes.TNT, "2", new object[] { (int)FieldIDs.FLD_IS_MIRROR_SCREEN, fldVal }));
}
public bool AMBDTAConfigQuery(bool isSaveToFlash, int periodMs, bool isPressure, bool isTemperature, bool isDepth, bool isVCC)
{
var msg = NMEAParser.BuildProprietarySentence(ManufacturerCodes.UWV, "6", new object[]
{
Convert.ToInt32(isSaveToFlash),
periodMs,
Convert.ToInt32(isPressure),
Convert.ToInt32(isTemperature),
Convert.ToInt32(isDepth),
Convert.ToInt32(isVCC)
});
return(TrySend(msg, ICs.IC_H2D_AMB_DTA_CFG));
}
public MeasMsg Parse(string message)
{
try
{
if (string.IsNullOrWhiteSpace(message))
{
return(null);
}
// Debug.WriteLine("Parsing AWAC message:" + message);
int dollarIndex = message.IndexOf("$");
if (dollarIndex == -1)
{
return(null);
}
int crLfIndex = message.IndexOf("/r/n");
if (crLfIndex == -1)
{
message = message + Environment.NewLine;
}
if (nameDictionary.Count == 0)
{
InitDictionary();
}
int index = message.IndexOf("$PN");
if (index == -1)
{
return(null);
}
if (index > 0)
{
message = message.Substring(index);
}
NMEAProprietarySentence nmeaSentence = (NMEAParser.Parse(message)) as NMEAProprietarySentence;
return(ParseMsg(nmeaSentence));
}
catch (Exception ex)
{
ExceptionHandler.HandleException(ex, "Error while parsing NMEA message." + message);
return(null);
}
}
void PortOnDataReceived(object sender, SerialDataReceivedEventArgs serialDataReceivedEventArgs)
{
int bytesToRead = _port.BytesToRead;
var buffer = new byte[bytesToRead];
_port.Read(buffer, 0, bytesToRead);
var dataString = Encoding.ASCII.GetString(buffer);
_buffer.Append(dataString);
var temp = _buffer.ToString();
int lIndex = temp.LastIndexOf(NMEAParser.SentenceEndDelimiter, StringComparison.InvariantCulture);
if (lIndex >= 0)
{
_buffer = _buffer.Remove(0, lIndex + 2);
if (lIndex + 2 < temp.Length)
{
temp = temp.Remove(lIndex + 2);
}
temp = temp.Trim(_kTrimZeroChar);
var lines = temp.Split(new[] { NMEAParser.SentenceEndDelimiter }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x + NMEAParser.SentenceEndDelimiter);
foreach (var line in lines)
{
try
{
var result = NMEAParser.Parse(line);
ProcessNMEASentence(result);
}
catch
{
// TODO errors
}
}
}
if (_buffer.Length >= _port.ReadBufferSize * 2)
{
_buffer.Remove(0, _port.ReadBufferSize);
}
}
private void port_NewNMEAMessage(object sender, NewNMEAMessageEventArgs e)
{
if (IsLogIncoming)
{
LogEventHandler.Rise(this, new LogEventArgs(LogLineType.INFO, string.Format("{0} ({1}) >> {2}", PortName, PortDescription, e.Message)));
}
try
{
var _result = NMEAParser.Parse(e.Message);
ProcessIncoming(_result);
}
catch (Exception ex)
{
LogEventHandler.Rise(this, new LogEventArgs(LogLineType.ERROR, string.Format("{0} ({1}) >> {2} Caused error ({3})", PortName, PortDescription, e.Message, ex.Message)));
}
}
private void port_NewNMEAMessage(object sender, NewNMEAMessageEventArgs e)
{
InvokeAppendText(commLogTxb, logger.Write(string.Format(">> {0}", e.Message)));
try
{
var parseResult = NMEAParser.Parse(e.Message);
if (parseResult is NMEAProprietarySentence)
{
NMEAProprietarySentence pSentence = (parseResult as NMEAProprietarySentence);
if (pSentence.Manufacturer == ManufacturerCodes.TNT)
{
if (pSentence.SentenceIDString == "!")
{
Parse_DEVICE_INFO(pSentence.parameters);
}
else if (pSentence.SentenceIDString == "0")
{
Parse_ACK(pSentence.parameters);
}
else if (pSentence.SentenceIDString == "5")
{
Parse_LOC_DATA_VAL(pSentence.parameters);
}
else if (pSentence.SentenceIDString == "9")
{
Parse_SETTINGS(pSentence.parameters);
}
else
{
InvokeAppendText(commLogTxb, logger.Write(string.Format("ERROR: Unsupported sentence: \"{0}\"", pSentence.SentenceIDString)));
}
}
else
{
InvokeAppendText(commLogTxb, logger.Write(string.Format("ERROR: Unsupported manufacturer: \"{0}\"", pSentence.Manufacturer)));
}
}
else
{
InvokeAppendText(commLogTxb, logger.Write(string.Format("ERROR: Unsupported sentence: \"{0}\"", (parseResult as NMEAStandartSentence).SentenceID)));
}
}
catch (Exception ex) { InvokeAppendText(commLogTxb, logger.Write(ex)); }
}
private void port_NewNMEAMessage(object sender, NewNMEAMessageEventArgs e)
{
try
{
var parseResult = NMEAParser.Parse(e.Message);
if (parseResult is NMEAProprietarySentence)
{
NMEAProprietarySentence sentence = (parseResult as NMEAProprietarySentence);
if (sentence.Manufacturer == ManufacturerCodes.TNT)
{
if (sentence.SentenceIDString == "!")
{
// DEVICE INFO
DEVICE_INFO_Parse(sentence.parameters);
}
else if (sentence.SentenceIDString == "0")
{
// ACK
ACK_Parse(sentence.parameters);
}
else if (sentence.SentenceIDString == "5")
{
// LOC_DATA_VAL
LOC_DATA_VAL_Parse(sentence.parameters);
}
else if (sentence.SentenceIDString == "9")
{
// SETTINGS_VAL
SETTINGS_VAL_Parse(sentence.parameters);
}
}
else
{
// WTF?
}
}
}
catch (Exception ex)
{
// WTF?
}
}
public ActionResult Open(string fileName)
{
if (!String.IsNullOrEmpty(fileName))
{
var lines = FileHandler.Open(fileName);
var entityList = NMEAParser.Parse(lines);
NMEAModel model = new NMEAModel
{
UserCoordinatesList = entityList.Value.ToList(),
SatelliteList = GetSatelliteList(entityList.Key).ToList(),
};
return(Json(model));
}
return(Json(""));
}
