protected override void OnCellValueNeeded(DataGridViewCellValueEventArgs e) { base.OnCellValueNeeded(e); if ((e.RowIndex < 0) || (e.RowIndex > _Data.Count)) { e.Value = "ERROR"; return; } CanMessage msg = _Data[e.RowIndex]; switch (e.ColumnIndex) { case 0: e.Value = e.RowIndex; break; case 1: e.Value = (msg.Sec + msg.Usec / 1000000.0 - BaseTime).ToString("F6") + " s"; break; case 2: e.Value = (msg.FrameLengthStuffed * 1000 / 1000000.0).ToString("F3") + " ms"; break; case 3: e.Value = msg.Mailbox.IsTx ? "TX" : "RX"; break; case 4: e.Value = msg.COB.ToString(); break; case 5: e.Value = BitConverter.ToString(msg.Data); break; default: e.Value = "ERROR"; break; } }
private void SDO_Block_Send_Btn_Click(object sender, EventArgs e) { bool ret; CanMessage sendCanMessage; CanMessage receivedCanMessage; sendCanMessage = new CanMessage { id = 0x600 + m_NodeID, dlc = 8, msg = new byte[8] { 0x11, 0xbf, 0, 0, 0, 0, 0, 0 } }; receivedCanMessage = new CanMessage { msg = new byte[8] { 0, 0, 0, 0, 0, 0, 0, 0 } }; ret = ExecuteCanMessage(sendCanMessage, 0x580, ref receivedCanMessage, true, m_NodeID); /// STAT CHECK sendCanMessage = new CanMessage { id = 0x600 + m_NodeID, dlc = 8, msg = new byte[8] { 0x40, 0x56, 0x1f, 0x01, 0, 0, 0, 0 } }; receivedCanMessage = new CanMessage { msg = new byte[8] { 0, 0, 0, 0, 0, 0, 0, 0 } }; ret = ExecuteCanMessage(sendCanMessage, 0x580, ref receivedCanMessage, true, m_NodeID); }
protected void OnMessageReceived(CanMessage message) { if (MessageReceived != null) { MessageReceived(this, message); } }
static void Main(string[] args) { /*Adapter példányosítása*/ CanAdapterDevice adapter = new CanAdapterDevice(); /*Kapcsolódás egy létező adapterhez.*/ adapter.Connect(); /*Kapcsolódott ezzel a SerialNumber-el rendlekező adapterhez.*/ Console.WriteLine("Connected to: " + adapter.Attributes.SerialNumber); /*Busz lezárás engedélyezése. */ adapter.Attributes.Termination = true; /*Megnyitás az átviteli sebesség paraméterrel.*/ adapter.Open(CanBaudRateCollection.Speed500kBaud); /*Üzenet tömb létrehozása.*/ var txMsgArray = new CanMessage[] { new CanMessage(0x01FF, new byte[] { 0x01, 0x02, 0x03, 0x04 }) }; /*Üzenet tömb küldése.*/ adapter.Write(txMsgArray); /*Kapcsolat zárása*/ adapter.Close(); /*Kapcsolat bontása*/ adapter.Disconnect(); Console.Read(); }
private void AddMessageToActivityIndicator(CanMessage receivedMessage) { UInt32 id = receivedMessage.Id; CanActivityDisplayData temp; if (ReceivedDataSummary.TryGetValue(id, out temp)) { temp.Count++; temp.Data = receivedMessage.Data; temp.Length = receivedMessage.DLC; temp.RcvTime = new DateTime(receivedMessage.SystemTimeStamp); } else { string name = "Unknown type"; CanMessageType canMessageType; if (CanMessagesDatabase.TryGetValue(id, out canMessageType)) { name = canMessageType.Name; } ReceivedDataSummary.Add(id, new CanActivityDisplayData { Id = id, Type = name, Data = receivedMessage.Data, Length = receivedMessage.DLC, RcvTime = new DateTime(receivedMessage.SystemTimeStamp), }); } }
/// <summary> /// Отправка CAN сообщения /// </summary> public void TransmitData(CanMsg msg) { CanMessage canMsg = new CanMessage(); // ExtendedFrameFormat - тип идентификатора - 11 или 22 бит canMsg.TimeStamp = 0; //canMsg.Identifier = 0x100; canMsg.Identifier = msg.Id; canMsg.FrameType = CanMsgFrameType.Data; canMsg.DataLength = msg.Size; if (msg.Size == 0) { canMsg.RemoteTransmissionRequest = true; } canMsg.SelfReceptionRequest = true; // Отображение сообщения в консоле for (Byte i = 0; i < canMsg.DataLength; i++) { canMsg[i] = msg.Size; } // Запись сообщения в FIFO(буфер can-адаптера?) mWriter.SendMessage(canMsg); }
public CanMessage[] GetLastMessages(int num) { WaitSemaphore(); _busy = true; CanMessage[] msgs; if (_putIndex == _getIndex) { // No new messages msgs = new CanMessage[0]; } else if (_putIndex > _getIndex || _putIndex >= num) { // New messages in a single block var size = (_putIndex > _getIndex) ? Math.Min(_putIndex - _getIndex, num) : num; msgs = new CanMessage[size]; Array.Copy(_buffer, _putIndex - size, msgs, 0, size); _getIndex = _putIndex; } else { // New messages in two blocks (putIndex < getIndex) // Block1: ??? --> last index, Block2: 0 --> (putIndex - 1) var sizeBlock1 = Math.Min(_buffer.Length - _getIndex, num - _putIndex); msgs = new CanMessage[sizeBlock1 + _putIndex]; Array.Copy(_buffer, _buffer.Length - sizeBlock1, msgs, 0, sizeBlock1); Array.Copy(_buffer, 0, msgs, sizeBlock1, _putIndex); _getIndex = _putIndex; } _busy = false; return(msgs); }
public void AddMessage(CanMessage msg) { WaitSemaphore(); _busy = true; _buffer[_putIndex++] = msg; if (_putIndex == _buffer.Length) { _putIndex = 0; } if (_putIndex == _getIndex) { _getIndex++; if (_getIndex == _buffer.Length) { _getIndex = 0; } } if (_bufferDistinct.ContainsKey(msg.Id)) { _bufferDistinct[msg.Id] = msg; } else { _bufferDistinct.Add(msg.Id, msg); } _busy = false; }
private void Parse(byte[] bytes) { try { for (int i = 0; i < bytes.Length; i++) { if (bytes[i] == carriageReturn) { if (_buffer.Count > 0 && _buffer[0] == 0x74) { if (_buffer.Count == 21) { _buffer.RemoveAt(0); OnCanMessageRecieved(CanMessage.Parse(_buffer.ToArray())); } } else { ControllerMessageRecieved?.Invoke(this, new ControllerMessageRecievedEventArgs(_buffer.ToArray())); } _buffer = new List <byte>(); } else { _buffer.Add(bytes[i]); } } } catch (Exception ex) { Debug.Write(ex.Message); } }
public void _0003_NiPacketToCanFrames() { byte[] expect = new byte[] { 0x02, 0x00, 0x01, 0x00, 0xA1, 0x00, 0xA2, 0x00, 0x00, 0x00, 0xA3, 0x00, 0x00, 0x00, 0xA4, 0x08, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xB1, 0x00, 0xB2, 0x00, 0x00, 0x00, 0xB3, 0x00, 0x00, 0x00, 0xB4, 0x08, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, }; CanMessage msg = new CanMessage(); CanMessage[] frames = null; CanMessage.MsgPacketToCanFrames(expect, expect.Length, out frames); msg.TwoByte = 0x00A1; msg.TimestampTick = 0x000000A2; msg.ArbitrationId = 0x000000A3; msg.IsRemote = 0xA4; msg.DataLength = 0x08; msg.Data = new byte[] { 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, }; Assert.AreEqual(2, frames.Length); Assert.AreEqual(msg.TwoByte, frames[0].TwoByte); Assert.AreEqual(msg.TimestampTick, frames[0].TimestampTick); Assert.AreEqual(msg.ArbitrationId, frames[0].ArbitrationId); Assert.AreEqual(msg.IsRemote, frames[0].IsRemote); Assert.AreEqual(msg.DataLength, frames[0].DataLength); Assert.AreEqual(msg.Data.Length, frames[0].Data.Length); Assert.AreEqual(msg.Data[0], frames[0].Data[0]); Assert.AreEqual(msg.Data[7], frames[0].Data[7]); }
public MOTGEARNodeReader(CanMessage canMessage) { if (canMessage.Identifier != Identifier) { throw new NotSupportedException($"Identifier is not supported."); } _canMessage = canMessage; Signals = new ISignalParser[] { new BoolSignalParser(_canMessage.Data, 63, "EngineTorqueForNCAValidData"), new BoolSignalParser(_canMessage.Data, 62, "EngineTorqueReductNCAValidData"), new BoolSignalParser(_canMessage.Data, 61, "StopLightSwitchStsValidData"), new BoolSignalParser(_canMessage.Data, 60, "StopLightSwitchSts"), new BoolSignalParser(_canMessage.Data, 59, "AirConSts"), new BoolSignalParser(_canMessage.Data, 58, "EngineSpeedValidData"), new BoolSignalParser(_canMessage.Data, 57, "KickDownRequest"), new EmptySignalParser("NotUsed"), new RangeSignalParser(_canMessage.Data, 48, 55, "EngineTorqueForNCA"), new RangeSignalParser(_canMessage.Data, 40, 47, "EngineTorqueReductNCA"), new RangeSignalParser(_canMessage.Data, 32, 39, "EngineWaterTempForNCA"), new BoolSignalParser(_canMessage.Data, 31, "EngineWaterTempForNCAFailSts"), new EmptySignalParser("NotUsed") }; }
public MOT1NodeReader(CanMessage canMessage) { if (canMessage.Identifier != Identifier) { throw new NotSupportedException($"Identifier is not supported."); } _canMessage = canMessage; Signals = new ISignalParser[] { new BoolSignalParser(_canMessage.Data, 63, "MaxEngineTorqueValidData"), new BoolSignalParser(_canMessage.Data, 62, "GasPedalPositionValidData"), new BoolSignalParser(_canMessage.Data, 61, "EngineFrictionTorqueValidData"), new BoolSignalParser(_canMessage.Data, 60, "FeedbackASR/VDCReq"), new BoolSignalParser(_canMessage.Data, 59, "EngineTorqueValidData"), new BoolSignalParser(_canMessage.Data, 58, "EngineTorqueDriverReqValidData"), new EnumSignalParser <TorqueIntervention>(_canMessage.Data, 56, 57, "TorqueInterventionSts"), new RangeSignalParser(_canMessage.Data, 48, 55, "EngineTorque"), new RangeSignalParser(_canMessage.Data, 32, 47, "EngineSpeed"), new RangeSignalParser(_canMessage.Data, 24, 31, "EngineTorqueDriverReq"), new RangeSignalParser(_canMessage.Data, 16, 23, "EngineFrictionTorque"), new RangeSignalParser(_canMessage.Data, 8, 15, "MaxEngineTorque"), new RangeSignalParser(_canMessage.Data, 0, 7, "GasPedalPosition") }; }
public INodeReader CreateNodeReader(CanMessage canMessage) { switch (canMessage.Identifier) { case MOT1NodeReader.TypeIdentifier: return(new MOT1NodeReader(canMessage)); case MOT2NodeReader.TypeIdentifier: return(new MOT2NodeReader(canMessage)); case ASR1NodeReader.TypeIdentifier: return(new ASR1NodeReader(canMessage)); case ASR2NodeReader.TypeIdentifier: return(new ASR2NodeReader(canMessage)); case STNBNodeReader.TypeIdentifier: return(new STNBNodeReader(canMessage)); case MOTGEARNodeReader.TypeIdentifier: return(new MOTGEARNodeReader(canMessage)); case STNB_CUSW11NodeReader.TypeIdentifier: return(new STNB_CUSW11NodeReader(canMessage)); default: throw new NotSupportedException(); } }
public STNB_CUSW11NodeReader(CanMessage canMessage) { if (canMessage.Identifier != Identifier) { throw new NotSupportedException($"Identifier is not supported."); } _canMessage = canMessage; Signals = new ISignalParser[] { // AC Status on CAN // 1 = AC Request // 2 = No AC Request new BoolSignalParser(_canMessage.Data, 50, "CompressorACReqSts"), // Value Range -40ºC to +87ºC // CAN Conversion E = N * 0.5 - 40ºC new RangeSignalParser(_canMessage.Data, 32, 39, "ExternalTemperature"), // This signal contains the faulty information related to the signal "ExternalTemperature". If the value is "Fail Present", then the ECM doesn' t take into account the external temperature value. // TRUE = Fail Present // FALSE = Fail not Present new BoolSignalParser(_canMessage.Data, 31, "ExternalTemperatureFailSts"), // This signal contains the information about Drive Style Sts. // Value Range 0 to 7 new RangeSignalParser(_canMessage.Data, 27, 29, "Drive Style Sts"), // This signal contains the information about hand brake insertion. If the hand break is activated, the value $1(On) will be received. // 1 = On // 0 = Off new BoolSignalParser(_canMessage.Data, 13, "HandBrakeSts") }; }
public void _0014_Write_Exception() { if (_adapter.IsOpen) { _adapter.Close(); } if (_adapter.Attributes.State != CanState.SDEV_IDLE) { _adapter.Services.Reset(); } _adapter.Open(_targetBaudrate); CanMessage[] txFrames = new CanMessage[512]; for (int i = 0; i < 512; i++) { txFrames[i] = CanMessage.MessageStdC8; byte[] valuebytes = BitConverter.GetBytes((uint)i + 1); Buffer.BlockCopy(valuebytes, 0, txFrames[i].Data, 0, valuebytes.Length); } _adapter.Write(txFrames); Thread.Sleep(200); Assert.AreEqual(512, _adapter.Attributes.TxDrop); }
public static ConcurrentBag <IAnalyzer> Analyzers = new ConcurrentBag <IAnalyzer>(); // List of all analyzers public static void Analyze() { foreach (IAnalyzer anal in Analyzers) { if (anal.IsRunning) { return; } } CanMessage[] msgs = new CanMessage[InputQueue.Count]; for (int i = 0; i < msgs.Length; i++) { if (!InputQueue.TryDequeue(out msgs[i])) { Array.Resize(ref msgs, i - 1); break; } } foreach (IAnalyzer anal in Analyzers) { anal.Analyze(msgs); } }
/// <summary> /// Get one CAN message from the receive queue, RKSCANOpen(...) must have /// been called before. Returns TRUE on success. /// </summary> /// <returns></returns> public virtual CanMessage RKSCANRx() { NativeCanEntryPoints.can_msg_t pMsg = new NativeCanEntryPoints.can_msg_t(); var result = Procedure <NativeCanEntryPoints.RKSCANRx>(NativeCanEntryPoints._RKSCANRx)(ref pMsg); if (!result) { throw new Exception(); } var canMessage = new CanMessage { byType = pMsg.byType, dwTimeStamp = pMsg.dwTimeStamp, byError = pMsg.uFrm.sErr.byError, dwID = pMsg.uFrm.sData.dwID, byDLC = pMsg.uFrm.sData.byDLC, abyData = new byte[] { pMsg.uFrm.sData.abyData0, pMsg.uFrm.sData.abyData1, pMsg.uFrm.sData.abyData2, pMsg.uFrm.sData.abyData3, pMsg.uFrm.sData.abyData4, pMsg.uFrm.sData.abyData5, pMsg.uFrm.sData.abyData6, pMsg.uFrm.sData.abyData7, } }; return(canMessage); }
/// <summary> /// Interrupt Service Routine when pin INT falls LOW (message received) /// uses the rollover feature from MAB to RXB1, when RXB0 is full /// Note: Only standard identifier, no RTR frame detection /// </summary> private void INT_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs e) { var readCmd = (ReadReg(regCANINTF) & 0x01) == 0x01 ? cmdReadRXB0 : cmdReadRXB1; lock (_socket.LockSpi) { _canSpi.TransferFullDuplex(new Byte[] { readCmd, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, valueChangedBuffer); Array.Copy(valueChangedBuffer, 1, valueChangedBuffer, 0, valueChangedBuffer.Length - 1); } var Msg = new CanMessage() { Timestamp = e.Timestamp, ArbitrationId = valueChangedBuffer[0] << 3 | valueChangedBuffer[1] >> 5, IsExtendedId = false, IsRemoteTransmissionRequest = false, Length = (Byte)(valueChangedBuffer[4] & 0x0F), Data = new Byte[(Byte)(valueChangedBuffer[4] & 0x0F)] }; for (Byte i = 0; i < Msg.Length; i++) { Msg.Data[i] = valueChangedBuffer[i + 5]; } MessageReceivedEventHandler messageReceived = MessageReceived; messageReceived(this, new MessageReceivedEventArgs(Msg)); }
public void _0009_WirteRead_ZerroLengthArray() { if (_adapterWriter.IsOpen) { _adapterWriter.Close(); } if (_adapterReader.IsOpen) { _adapterReader.Close(); } if (_adapterWriter.Attributes.State != CanState.SDEV_IDLE) { _adapterWriter.Services.Reset(); } if (_adapterReader.Attributes.State != CanState.SDEV_IDLE) { _adapterReader.Services.Reset(); } _adapterWriter.Attributes.Termination = true; _adapterReader.Attributes.Termination = true; _adapterWriter.Open(_targetBaudrate); Thread.Sleep(50); _adapterReader.Open(_targetBaudrate); _adapterWriter.Write(new CanMessage[] { CanMessage.MessageStdA8 }, 0, 0); CanMessage[] rxFrames = new CanMessage[128]; int offset = 0, length = 0; bool isTimeout = false; long startTick = DateTime.Now.Ticks; do { if (DateTime.Now.Ticks - startTick > 1000 * 10000) { isTimeout = true; } length = _adapterReader.Attributes.PendingRxMessages; _adapterReader.Read(rxFrames, offset, length); offset += length; } while (!isTimeout); Assert.AreEqual(0, _adapterReader.Attributes.RxDrop, "Reader RxDrop nem nulla. "); Assert.AreEqual(0, _adapterReader.Attributes.RxTotal, ""); Assert.AreEqual(0, _adapterWriter.Attributes.TxDrop, "Writer TxDrop nem nulla. "); Assert.AreEqual(0, _adapterWriter.Attributes.TxTotal, ""); Assert.AreEqual(0, _adapterWriter.Attributes.TxDrop, "Writer TxDrop nem nulla. "); Assert.AreEqual(0, _adapterReader.Attributes.RxTotal, "Az adapter FIFO-jába nem jött meg minden."); Assert.AreEqual(0, offset, "A Host FIFO-jaba nem jött meg minden."); }
public void ParseStatusMessage(CanMessage message) { var heater = (byte)(message.Data[0] >> 4); var ventilation = (byte)(message.Data[1] & 0xF); var massage = (message.Data[0] & 0xF) == 1; SetValues(heater, ventilation, massage); }
public override bool SendMessage(CanMessage message) { CheckEnabled(); var sent = can.Transmit(message.MCP2515Message, 10); OnMessageSent(message, sent); return(sent); }
public void _0001_WriteRead_SingleMessage() { if (_adapterWriter.IsOpen) { _adapterWriter.Close(); } if (_adapterReader.IsOpen) { _adapterReader.Close(); } if (_adapterWriter.Attributes.State != CanState.SDEV_IDLE) { _adapterWriter.Services.Reset(); } if (_adapterReader.Attributes.State != CanState.SDEV_IDLE) { _adapterReader.Services.Reset(); } _adapterWriter.Attributes.Termination = true; _adapterReader.Attributes.Termination = true; _adapterWriter.Open(_targetBaudrate); Thread.Sleep(50); _adapterReader.Open(_targetBaudrate); _adapterWriter.Write(new CanMessage[] { CanMessage.MessageStdC8 }); CanMessage[] rxFrames = new CanMessage[128]; int offset = 0, length = 0; long startTick = DateTime.Now.Ticks; do { length = _adapterReader.Attributes.PendingRxMessages; _adapterReader.Read(rxFrames, offset, length); offset += length; if (DateTime.Now.Ticks - startTick > 1000 * 10000) { throw new Exception("Timeout"); } } while (offset == 0); Assert.AreEqual(0, _adapterReader.Attributes.RxDrop, "Reader RxDrop nem nulla: " + _adapterReader.Attributes.RxDrop.ToString()); Assert.AreEqual(1, _adapterReader.Attributes.RxTotal, ""); Assert.AreEqual(0, _adapterWriter.Attributes.TxDrop, "Writer TxDrop nem nulla: " + _adapterWriter.Attributes.TxDrop.ToString()); Assert.AreEqual(1, _adapterWriter.Attributes.TxTotal, "Writer TxDrop nem nulla: " + _adapterWriter.Attributes.TxTotal.ToString()); Assert.AreEqual(0, _adapterWriter.Attributes.TxDrop, "Writer TxDrop nem nulla: " + _adapterWriter.Attributes.TxDrop.ToString()); Assert.AreEqual(1, _adapterReader.Attributes.RxTotal, "Az adapter FIFO-jába nem jött meg minden:" + _adapterReader.Attributes.RxTotal.ToString()); Assert.AreEqual(1, offset, "A Host FIFO-jaba nem jött meg minden."); }
public void _0004_WirteRead_ExtId_0x7FF() { CanMessage rxFrame; CanMessage outgoing = CanMessage.MessageMaxStdId; outgoing.ArbitrationId |= 0x20000000; WirteReadSingleMessage(_targetBaudrate, outgoing, out rxFrame); Assert.AreEqual(outgoing, rxFrame); }
public void Analyze(CanMessage[] msgs) { foreach (CanMessage cm in msgs) { Result r = Results.GetOrAdd(cm.Source, x => new Result()); r.Messages.Add(cm); } }
/// <summary> /// /// </summary> /// <param name="slaveMacId"></param> /// <param name="classCode"></param> /// <param name="instanceId"></param> public void ObjectResetService(int slaveMacId, byte classCode, byte instanceId) { byte[] request = new byte[] { (byte)MasterMacId, /*Source MAC Id: 0..64 */ Services.SRVS_RESET, /*Get Attribute Single*/ classCode, /*Class Code*/ instanceId, /*Instance Id*/ }; Adapter.Write(new CanMessage[] { new CanMessage(DeviceNetAddressing.GetExplicitRequestCanId(slaveMacId), request) }); int retrty = 3; long timestamp = DateTime.Now.Ticks; bool isTimeout = false; CanMessage[] rxMsgBuffer = new CanMessage[1]; do { do { if (Adapter.Attributes.PendingRxMessages > 0) { isTimeout = false; Adapter.Read(rxMsgBuffer, 0, 1); break; } isTimeout = DateTime.Now.Ticks - timestamp > 1000 * 10000; } while (!isTimeout); if (isTimeout && retrty != 0) { timestamp = DateTime.Now.Ticks; } } while (--retrty != 0 && isTimeout); if (isTimeout) { throw new DeviceNetException("DeviceNet: Response Timeout."); } byte[] response = rxMsgBuffer[0].Data; if (response[1] == 0x94) { throw new DeviceNetException("DeviceNet:" + DeviceNetException.ErrorMessageToString(response[2], response[3])); } if ((response[1] & 0x80) != 0x80) { throw new ApplicationException("DeviceNet:" + "Response Invalid."); } }
public void _0001_MaxWriteSpeed_500kBaud() { CanMessage cm = new CanMessage(0x000001, new byte[] { 0x01, 0x02 }); long timestamp = DateTime.Now.Ticks; do { _adapterWriter.Write(new CanMessage[] { cm }); } while ((DateTime.Now.Ticks - timestamp) < 10000 * 10000); }
/// <summary> /// SendCanMessage /// </summary> /// <param name="CanMessage">canMessage</param> /// <returns>Return true if write command successfully, otherwise return false</returns> public bool SendCanMessage(CanMessage canMessage) { bool ret = m_CANopenLibHelper.Write(canMessage); if (!ret) { return(false); } return(true); }
void cbt_CanMessageReceived(CanMessage msg) { if (msg.Bus != _bus) { return; } _sw?.WriteLine(string.Format("{0};{1};{2};{3};{4};{5}", msg.Time, msg.Bus, $"{ msg.Id:X3}", msg.HexData, msg.Status, msg.ConvertedValue)); _buffer.AddMessage(msg); }
public CanMessage[] GetDistinctMessages() { WaitSemaphore(); _busy = true; CanMessage[] msgs = new CanMessage[_bufferDistinct.Count]; _bufferDistinct.Values.CopyTo(msgs, 0); _busy = false; return(msgs); }
public void WriteMessage(CanMessage message) { if (!CanConnectionRunning) { // TODO: Do something? Throw exception, or just return quietly? } if (base.CanWriteLL(message) != Brg_StatusT.BRG_NO_ERR) { this.CloseConnection(); // TODO: Consider allowing a few errors for increased robustness } }
void cbt_CanMessageReceived(CanMessage msg) { if (msg.Bus != _bus) { return; } _sw?.WriteLine("\"" + msg.Time + "\";\"" + $"{msg.Id:X3}" + "\";\"" + msg.HexData + "\";" + msg.Status + ";\"\""); _buffer.AddMessage(msg); }
public void Analyze(CanMessage[] msgs) { foreach (CanMessage msg in msgs) { Result result = Results.GetOrAdd(msg.Source, x => new Result()); if (!result.AutoDeleteEnable) result.StatsTotal.AddOrUpdate(msg.COB, 1, (qid, val) => val + 1); else result.StatsAutoDelete.AddOrUpdate(msg.COB, new OneCounter(), (qid, val) => val.Count()); } }
public static void Analyze() { foreach (IAnalyzer anal in Analyzers) if (anal.IsRunning) return; CanMessage[] msgs = new CanMessage[InputQueue.Count]; for (int i = 0; i < msgs.Length; i++) if (!InputQueue.TryDequeue(out msgs[i])) { Array.Resize(ref msgs, i - 1); break; } foreach (IAnalyzer anal in Analyzers) anal.Analyze(msgs); }
public void Analyze(CanMessage[] msgs) { foreach (CanMessage msg in msgs) { Result result = Results.GetOrAdd(msg.Source, x => new Result()); if (msg.Mailbox.IsTx) result.nTx++; else result.nRx++; if (result.second == msg.Sec) result.bits += msg.FrameLengthStuffed + 7 + 3; // EOF + IFS else { result.load = result.bits / 1000000.0f; result.bits = msg.FrameLengthStuffed + 7 + 3; // EOF + IFS result.second = msg.Sec; } } }
public void Analyze(CanMessage[] msgs) { foreach (CanMessage m in msgs) { Result result = Results.GetOrAdd(m.Source, x => new Result()); if (m.COB.IdStd == 0x80) // std ID 0x80 = SYNC { result.oldsynctime = result.synctime; result.synctime = m.Time; } else if (result.CycleLog.Count == 0) // make the cycle entire from the beginning return; CanopenMsg msg = result.CycleLog.GetOrAdd(m.COB, x => new CanopenMsg() { COB = x, count = 0 }); msg.data = BitConverter.ToString(m.Data); msg.count++; msg.delay = TimeDiff(result.synctime, m.Time) / (2*BitRate); msg.length = m.FrameLengthStuffed / BitRate; msg.IsTx = m.Mailbox.IsTx; } }
/// <summary> /// Записывает в порт сообщение (кадр) /// </summary> /// <param name="identifier">Идентификатор сообщения</param> /// <param name="frameType">Тип сообщения</param> /// <param name="extendedFrame">Формат сообщения</param> /// <param name="remoteTransmissionRequest">Удалённый запрос</param> /// <param name="data">Данные сообщения (0...8 байт)</param> public void WriteMessage(UInt32 identifier, CanMsgFrameType frameType, Boolean extendedFrame, Boolean remoteTransmissionRequest, Byte[] data) { lock (_SyncRoot) { CanMessage canMsg = new CanMessage(); canMsg.TimeStamp = 0; canMsg.Identifier = identifier; canMsg.FrameType = frameType; canMsg.DataLength = System.Convert.ToByte(data.Length); canMsg.ExtendedFrameFormat = extendedFrame; canMsg.RemoteTransmissionRequest = remoteTransmissionRequest; // Ехо!!! canMsg.SelfReceptionRequest = true; // show this message in the console window for (Byte i = 0; i < data.Length; i++) { canMsg[i] = data[i]; } // Write the CAN message into the transmit FIFO this._Writer.SendMessage(canMsg); } return; }
/// <summary> /// Записывает в порт сообщение (кадр) /// </summary> /// <param name="identifier">Идентификатор сообщения</param> /// <param name="frameType">Тип сообщения</param> /// <param name="frameFormat">Формат сообщения</param> /// <param name="data">Данные сообщения (0...8 байт)</param> public override void WriteMessage(UInt32 identifier, FrameType frameType, FrameFormat frameFormat, Byte[] data) { String msg; lock (_SyncRoot) { CanMessage canMsg = new CanMessage(); canMsg.TimeStamp = 0; canMsg.Identifier = identifier; switch (frameType) { case FrameType.DATAFRAME: { canMsg.FrameType = CanMsgFrameType.Data; canMsg.RemoteTransmissionRequest = false; break; } case FrameType.REMOTEFRAME: { canMsg.FrameType = CanMsgFrameType.Data; canMsg.RemoteTransmissionRequest = true; break; } default: { msg = String.Format("{0}: class CanPort.WriteMessage: Невозможно записать в порт сообщение данного типа: {1}", DateTime.Now.ToString(new System.Globalization.CultureInfo("ru-Ru", false)), frameFormat.ToString()); Trace.TraceError(msg); throw new ArgumentException(msg, FrameType.DATAFRAME.ToString()); } } if (data.Length > 8) { msg = String.Format( "{0}: class CanPort: Невозмоно записать в порт сообщение. Поле данных в сообщении не может быть больше 8 байт, передано: {1}", DateTime.Now.ToString(new System.Globalization.CultureInfo("ru-Ru", false)), data.Length.ToString()); Trace.TraceError(msg); throw new ArgumentException(msg, "data.Length"); } else { canMsg.DataLength = System.Convert.ToByte(data.Length); } switch (frameFormat) { case FrameFormat.ExtendedFrame: { canMsg.ExtendedFrameFormat = true; break; } case FrameFormat.StandardFrame: { canMsg.ExtendedFrameFormat = false; break; } default: { msg = String.Format( "{0}: class CanPort: Невозможно записать в порт сообщение с форматом кадра: {1}", frameFormat.ToString()); Trace.TraceError(msg); throw new ArgumentException(msg, "frameFormat"); } } // Эхо!!! canMsg.SelfReceptionRequest = true; // show this message in the console window for (Byte i = 0; i < data.Length; i++) { canMsg[i] = data[i]; } //#if DEBUG //StringBuilder sb = new StringBuilder(); //sb.Append("OUT: "); //sb.Append("Type: " + frameType.ToString() + " "); //sb.Append("Format: " + frameFormat.ToString() + " "); //sb.Append("Id:" + identifier.ToString() + " "); //foreach (Byte item in data) //{ // sb.Append("0x" + item.ToString("X2") + " "); //} //WindowsDebugging.WriteLine(sb.ToString(), Category.Information); //#endif // Write the CAN message into the transmit FIFO this._Writer.SendMessage(canMsg); } return; }