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;
}
