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()}") { }