private void HandleTelemetryMessage(SerialMessage message)
{
if (message.Parameters.Length != 5)
{
throw new SerialMessageMalformedException($"Telemetry message has the incorrect number of params; expected 5, was {message.Parameters.Length}", message);
}
bool.TryParse(message.Parameters[0], out bool IsScalingAtLimit);
float.TryParse(message.Parameters[1], out float LimitScaleFactor);
string ThrusterOutputs = message.Parameters[2].Replace(",", ", ");
string ImuCalibStates = message.Parameters[3].Replace(",", ", ");
int.TryParse(message.Parameters[4], out int OverallImuCalibState);
string data = $"Telemetry: {Environment.NewLine}"
+ $"\t{nameof(IsScalingAtLimit)}: {IsScalingAtLimit}{Environment.NewLine}"
+ $"\t{nameof(LimitScaleFactor)}: {LimitScaleFactor}{Environment.NewLine}"
+ $"\t{nameof(ThrusterOutputs)}: {ThrusterOutputs}{Environment.NewLine}"
+ $"\t{nameof(ImuCalibStates)}: {ImuCalibStates}{Environment.NewLine}"
+ $"\t{nameof(OverallImuCalibState)}: {OverallImuCalibState}";
TelemetryDataReceived?.Invoke(this, new RawStringReceivedEventArgs()
{
Text = data
});
}
private void OnTimedEvent(object sender, MicroTimerEventArgs timerEventArgs)
{
//_debugMessageList.Add(timerEventArgs.ElapsedMicroseconds.ToString());
_dispatcher.BeginInvoke((Action)(() =>
{
_totalTime += 10;
//_debugMessageList.Add(_totalTime.ToString())
if (_messageBuffer != null)
{
var message = new SerialMessage();
_messageBuffer.TryGetValue(_totalTime, out message);
if (message != null)
{
var result = _messageService.Send(message).GetAwaiter().GetResult();
if (String.IsNullOrWhiteSpace(result))
{
_debugMessageList.Add($"Sending message '{message.Message}' at {_totalTime}ms to port: {message.PortName}, OK");
}
else
{
_debugMessageList.Add($"Sending message '{message.Message}' at {_totalTime}ms to port: {message.PortName}, FAILED, {result}");
}
// _ea.GetEvent<MessageSendEvent>().Publish("");
}
}
}
));
}
protected override void SolveInstance(IGH_DataAccess DA)
{
string name = "";
bool read = false;
if (!DA.GetData(0, ref name))
{
return;
}
if (!DA.GetData(1, ref read))
{
return;
}
if (!read)
{
return;
}
byte[] message = SerialMessage.Read(name);
if (message == null)
{
return;
}
List <GH_Integer> ints = new List <GH_Integer>();
for (int i = 0; i < message.Length; i++)
{
ints.Add(new GH_Integer(message[i]));
}
DA.SetDataList(0, ints);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
string name = "";
List <int> values = new List <int>();
bool run = false;
if (!DA.GetData(0, ref name))
{
return;
}
if (!DA.GetDataList(1, values))
{
return;
}
if (!DA.GetData(2, ref run))
{
return;
}
byte[] bytes = new byte[values.Count];
for (int i = 0; i < values.Count; i++)
{
bytes[i] = (byte)Math.Max(0, Math.Min(255, values[i]));
}
if (run)
{
DA.SetData(0, SerialMessage.Write(bytes, name));
}
}
private async Task ProcessMessage(List <string> messages)
{
Debug.WriteLine("Messages: " + messages.Count.ToString());
foreach (string item in messages)
{
try
{
if (item.Length == 0)
{
continue;
}
SerialMessage msg = JsonConvert.DeserializeObject <SerialMessage>(item);
if (msg.Reciver != 0)
{
return; //komunikat nie jest dla mnie
}
SerialMessageFactory smf = new SerialMessageFactory();
await smf.ManageMessage(msg);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
}
public void AreEqual()
{
var a = SerialMessage.Parse("DEADBEEF|01-02-03-04-05-06-07-08");
var b = SerialMessage.Parse("DEADBEEF|01-02-03-04-05-06-07-08");
Assert.IsTrue(a.Equals(b));
Assert.AreNotEqual(a, b); // AreEqual does not work, as SerialMessage does not override Object.Equals
}
public void ParseTooLong()
{
SerialMessage message = SerialMessage.Parse("DEADBEEF|01-02-03-04-05-06-07-08-09");
Assert.AreEqual("DEADBEEF", message.Identifier);
Assert.AreEqual(1, message.Data.Bytes.First());
Assert.AreEqual(8, message.Data.Bytes.Last());
}
public void AddDifferentIdentifier()
{
var set = new ObservableSet <SerialMessage>(new SerialMessageSameIdentifier())
{
SerialMessage.Parse("DEADBEED|01-02-03-04-05-06-07-08"),
SerialMessage.Parse("DEADBEEE|00-00-00-00-00-00-00-00"),
SerialMessage.Parse("DEADBEEF|FF-FF-FF-FF-FF-FF-FF-FF")
};
Assert.AreEqual(3, set.Count);
}
private void HandleEnableStateMessage(SerialMessage message)
{
if (message.Parameters.Length != 1)
{
throw new SerialMessageMalformedException($"Enable state message has the incorrect number of params; expected 1, was {message.Parameters.Length}", message);
}
bool.TryParse(message.Parameters[0], out bool IsEnabled);
EnableStateReceived?.Invoke(this, new EnableStateEventArgs()
{
EnableState = IsEnabled
});
}
protected override void SolveInstance(IGH_DataAccess DA)
{
bool run = false;
if (!DA.GetData(0, ref run))
{
return;
}
if (run)
{
SerialMessage.CloseAll();
}
}
public void AddSameIdentifier()
{
var set = new ObservableSet <SerialMessage>(new SerialMessageSameIdentifier())
{
SerialMessage.Parse("DEADBEEF|01-02-03-04-05-06-07-08"),
SerialMessage.Parse("DEADBEEF|00-00-00-00-00-00-00-00"),
SerialMessage.Parse("DEADBEEF|FF-FF-FF-FF-AA-AA-AA-AA")
};
Assert.AreEqual(1, set.Count);
Assert.AreEqual(set[0].Data.Bytes.First(), 0xFF);
Assert.AreEqual(set[0].Data.Bytes.Last(), 0xAA);
}
private void HandleLogMessage(SerialMessage message)
{
if (message.Parameters.Length < 1)
{
throw new SerialMessageMalformedException($"Log message has the incorrect number of params; expected at least 1, was {message.Parameters.Length}", message);
}
LogMessageReceived?.Invoke(this, new LogMessageEventArgs()
{
Type = message.Parameters[0],
Message = string.Join(' ', message.Parameters.Skip(1).ToArray())
});
}
async Task ManageSensorValues(SerialMessage message)
{
ISenssor val = new SensorDs8b20();
switch (message.SensorType)
{
case SensorTypeEnum.test:
break;
case SensorTypeEnum.Ds18B20:
val = JsonConvert.DeserializeObject <SensorDs8b20>(message.Message);
await WolaClient.PostItemToController <SensorDs8b20>("SensorDs18b20", (SensorDs8b20)val);
// WolaClient.PostItemToController<SensorTemperatureValues>("SensorTempValue", item);
break;
case SensorTypeEnum.Dht11:
val = JsonConvert.DeserializeObject <SensorDht>(message.Message);
await WolaClient.PostItemToController <SensorDht>("SensorDht22", (SensorDht)val);
break;
case SensorTypeEnum.Dht22:
val = JsonConvert.DeserializeObject <SensorDht>(message.Message);
await WolaClient.PostItemToController <SensorDht>("SensorDht22", (SensorDht)val);
break;
case SensorTypeEnum.BMP180:
val = JsonConvert.DeserializeObject <SensorBmp180>(message.Message);
await WolaClient.PostItemToController <SensorBmp180>("SensorBMP180", (SensorBmp180)val);
break;
case SensorTypeEnum.ACS712:
val = JsonConvert.DeserializeObject <SensorAcs712>(message.Message);
await WolaClient.PostItemToController <SensorAcs712>("SensorAcs712", (SensorAcs712)val);
break;
case SensorTypeEnum.OnOff:
break;
default:
break;
}
Debug.WriteLine(val.ToString());
}
public void AddMultiple()
{
var set = new ObservableSet <SerialMessage>(new SerialMessageSameIdentifier())
{
SerialMessage.Parse("DEADBEEF|01-02-03-04-05-06-07-08"),
SerialMessage.Parse("DEADBEEC|01-02-03-04-05-06-07-08"),
SerialMessage.Parse("DEADBEED|00-00-00-00-00-00-00-00"),
SerialMessage.Parse("DEADBEEF|FF-FF-FF-FF-FF-FF-FF-FF")
};
Assert.AreEqual(3, set.Count);
Assert.IsFalse(set.Any(x => x.Equals(SerialMessage.Parse("DEADBEEF|01-02-03-04-05-06-07-08"))));
Assert.IsTrue(set.Any(x => x.Equals(SerialMessage.Parse("DEADBEEF|FF-FF-FF-FF-FF-FF-FF-FF"))));
}
public Object SendOne(SerialMessage msg)
{
if (mote == null)
{
return(null);
}
mote.Send(msg);
prompt.WriteLine("Packet sent", prompt.successTextColor);
if (listen)
{
return(new Listener(mote, prompt));
}
mote.Close();
return(null);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
List <int> readBuffer = new List <int>();
List <int> writeBuffer = new List <int>();
List <int> bauds = new List <int>();
foreach (string item in SerialMessage.Ports.Keys)
{
readBuffer.Add(SerialMessage.Ports[item].ReadBufferSize);
writeBuffer.Add(SerialMessage.Ports[item].WriteBufferSize);
bauds.Add(SerialMessage.Ports[item].BaudRate);
}
DA.SetDataList(0, SerialMessage.GetNames());
DA.SetDataList(1, readBuffer);
DA.SetDataList(2, writeBuffer);
DA.SetDataList(3, bauds);
}
private void HandleOrientationMessage(SerialMessage message)
{
if (message.Parameters.Length != 3)
{
throw new SerialMessageMalformedException($"Orientation message has the incorrect number of params; expected 3, was {message.Parameters.Length}", message);
}
double.TryParse(message.Parameters[0], out double Yaw);
double.TryParse(message.Parameters[1], out double Roll);
double.TryParse(message.Parameters[2], out double Pitch);
OrientationDataReceived?.Invoke(this, new OrientationEventArgs()
{
Roll = Roll,
Pitch = Pitch,
Yaw = Yaw
});
}
static void Send()
{
int counter = 0;
byte AM_ID = 0x89;
//int dest = 1;
TestSerialMessage testSerialMsg = new TestSerialMessage(counter);
SerialMessage serialMsg = new SerialMessage(testSerialMsg.GetMessageBytes(), AM_ID);
//serialMsg[(int)SerialMessage.H.DEST] = dest;
while (true)
{
Console.WriteLine("Sending packet " + counter);
mote.Send(serialMsg);
testSerialMsg[TestSerialMessage.COUNTER] = (uint)++counter;
serialMsg.SetPayload(testSerialMsg.GetMessageBytes());
Thread.Sleep(1000);
}
}
public async Task ManageMessage(SerialMessage message)
{
try
{
switch (message.MessageType)
{
case SerialOperationEnum.SensorValues:
await ManageSensorValues(message);
break;
default:
break;
}
}
catch (Exception ex)
{
LoggerFactory.LogExceptionStack(ex, "SerialMessageFactory.ManageMessage", new { message });
}
}
private void ReadSerial()
{
try
{
serialPort.Open();
}
catch (Exception e)
{
MessageBox.Show($"Failed to open port: {e.Message}", "Serial Inspector");
return;
}
OnPropertyChanged(nameof(IsRunning));
int errorCount = 0;
while (keepRunning && serialPort.IsOpen && errorCount < 50)
{
try
{
string line = serialPort.ReadLine();
SerialMessage message = SerialMessage.Parse(line, FirstChunkMath, SecondChunkMath);
var addItem = new Action(() => messages.Add(message));
Application.Current?.Dispatcher.Invoke(DispatcherPriority.Background, addItem);
}
catch (IOException e)
{
MessageBox.Show($"I/O exception occurred: {e.Message}", "Serial Inspector");
break;
}
catch (Exception e)
{
Debug.WriteLine($"An exception occurred: {e.Message}");
++errorCount;
continue;
}
}
serialPort?.Close();
OnPropertyChanged(nameof(IsRunning));
}
public Object SendOne(uint dest, uint src, uint group, uint amtype)
{
if (mote == null)
{
return(null);
}
byte[] bpayload = SerialMessage.HexStringToByteArray(payload);
SerialMessage msg = new SerialMessage(bpayload, (byte)amtype);
msg[SerialMessage.DEST] = dest;
msg[SerialMessage.SRC] = src;
msg[SerialMessage.GROUP] = group;
mote.Send(msg);
prompt.WriteLine("Packet sent", prompt.successTextColor);
if (listen)
{
return(new Listener(mote, prompt));
}
mote.Close();
return(null);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
string name = "";
int baud = 100;
bool run = false;
if (!DA.GetData(0, ref name))
{
return;
}
if (!DA.GetData(1, ref baud))
{
return;
}
if (!DA.GetData(2, ref run))
{
return;
}
if (run)
{
DA.SetData(0, SerialMessage.AddPort(name, baud));
}
}
private async Task ReadSerialPortAsync()
{
SerialMessage?message = null;
try
{
while (!_cts.IsCancellationRequested)
{
try
{
// Reconnection happens higher up
while (!_serialPort.IsOpen)
{
await Task.Delay(100)
.ConfigureAwait(false);
}
var b = new byte[1024];
var receivedLength = await _serialPort.BaseStream.ReadAsync(b, 0, b.Length)
.ConfigureAwait(false);
var buffer = b.AsMemory(0, receivedLength);
while (buffer.Length > 0)
{
var messageEnd = buffer.Span.IndexOf((byte)0x00);
// We didn't find the end to a message
if (messageEnd == -1)
{
if (message == null)
{
message = new SerialMessage(buffer);
}
else
{
message.AddSegment(buffer);
}
break;
}
else
{
// We read the whole message during this iteration
if (message == null)
{
var msg = buffer.Slice(0, messageEnd);
buffer = buffer.Slice(messageEnd + 1);
DecodeAndProcessPacket(msg, _cts.Token);
}
// We had some part of the message from a previous iteration
else
{
message.AddSegment(buffer.Slice(0, messageEnd));
buffer = buffer.Slice(messageEnd + 1);
var msg = message.ToArray();
DecodeAndProcessPacket(msg, _cts.Token);
message = null;
}
}
}
}
catch (TimeoutException)
{
}
catch (Exception ex)
{
_logger.LogTrace(ex, "An error occurred while listening to the serial port.");
await Task.Delay(100, _cts.Token)
.ConfigureAwait(false);
}
}
}
catch (ThreadAbortException)
{
//ignoring for now until we wire cancellation ...
//this blocks the thread abort exception when the console app closes
}
catch (InvalidOperationException)
{
// common if the port is reset/closed (e.g. mono enable/disable) - don't spew confusing info
}
catch (Exception ex)
{
_logger.LogTrace($"Exception: {ex} may mean the target connection dropped");
}
}
private void DebugText(string message)
{
if (this.InvokeRequired)
{
SerialMessage d = new SerialMessage(DebugText);
this.Invoke(d, new object[] { message });
}
else
{
txtDebug.AppendText(message + "\n");
}
}
public SerialMessageMalformedException(string message, SerialMessage sourceMessageData) : base(message + Environment.NewLine + $"Serialized message: {sourceMessageData.Serialize()}")
{
}
