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.");
}
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();
}
public void Setup()
{
Adapter = new CanAdapterDevice();
Adapter.ConnectTo("3869366E3133");
Adapter.Attributes.Termination = true;
Adapter.Open(250000);
}
/********************************************************************************/
public void Open()
{
if (!_adapter.IsConnected)
{
throw new Iso15765Exception("Adapter not Connected!");
}
_adapter.Open(BaudRate);
}
/// <summary>
///
/// </summary>
/// <param name="baudrate"></param>
public void Open(uint baudrate)
{
if (!Adapter.IsConnected)
{
throw new ApplicationException("Adapter not Connected!");
}
Adapter.Open(baudrate);
}
/// <summary>
/// Connect To Can Adapter
/// </summary>
/// <param name="serialNumber"></param>
public void Connect(string serialNumber)
{
Adapter.ConnectTo(serialNumber);
Adapter.Services.Reset();
Adapter.Attributes.Termination = true;
//Worker.RunWorkerAsync();
Adapter.Open(250000);
}
public void Setup()
{
_adapterWriter = new CanAdapterDevice();
_adapterWriter.ConnectTo(CanAdapterDevice.GetAdapters()[0]);
_targetBaudrate = 500000;
_adapterWriter.Services.Reset();
_adapterWriter.Open(_targetBaudrate);
}
static void Main(string[] args)
{
/*Adapter példányosítása*/
CanAdapterDevice adapter = new CanAdapterDevice();
/*Kapcsolódás egy létező adapterhez.*/
adapter.Connect();
/*Busz lezárás engedélyezése. */
adapter.Attributes.Termination = true;
/*Megnyitás az átviteli sebesség paraméterrel.*/
adapter.Open(CanBaudRateCollection.Speed500kBaud);
/*10 elemü üzenet tömb létrehozása.*/
var rxMsgArray = new CanMessage[10];
/*Bérkezett üzenet beolvasása a tömbe */
adapter.Read(rxMsgArray, 0, adapter.Attributes.PendingRxMessages);
/*Kapcsolat zárása*/
adapter.Close();
/*Kapcsolat bontása*/
adapter.Disconnect();
Console.Read();
}
/*ExpectedMessage = "The bus is already opened. Code:-8608."*/
public void _0003_ReOpen_Exception()
{
Assert.Catch <CanAdapterException>(() =>
{
if (_adapter.IsOpen)
{
_adapter.Close();
}
if (_adapter.Attributes.State != CanState.SDEV_IDLE)
{
_adapter.Services.Reset();
}
_adapter.Attributes.Baudrate = _targetBaudrate;
_adapter.Open();
_adapter.Open();
});
}
void AsyncTest(int msgCount, uint baudrate)
{
CanAdapterDevice adapterWriter = new CanAdapterDevice();
var selectedAdapterWriter = CanAdapterDevice.GetAdapters()[0]; //{CAN Bus Adpater - MCAN120803 3873366E3133 }
adapterWriter.ConnectTo(selectedAdapterWriter);
CanAdapterDevice adapterReader = new CanAdapterDevice();
var selectedAdapterReader = CanAdapterDevice.GetAdapters()[1]; //{CAN Bus Adpater - MCAN120803 387536633133 }
adapterReader.ConnectTo(selectedAdapterReader);
Stopwatch watch = new Stopwatch();
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;
try
{
CanMessage[] txFrames = new CanMessage[msgCount];
Action writer = () =>
{
try
{
for (int i = 0; i < msgCount; i++)
{
txFrames[i] = CanMessage.MessageStdC8;
byte[] valuebytes = BitConverter.GetBytes((uint)i + 1);
Buffer.BlockCopy(valuebytes, 0, txFrames[i].Data, 0, valuebytes.Length);
}
adapterWriter.Write(txFrames);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
};
CanMessage[] rxFrames = new CanMessage[msgCount];
int offset = 0;
watch.Start();
long startTick = DateTime.Now.Ticks;
AutoResetEvent doneEv = new AutoResetEvent(false);
Action reader = () =>
{
try
{
do
{
if (DateTime.Now.Ticks - startTick > 15000 * 10000)
{
throw new Exception("Timeout");
}
int length = adapterReader.Attributes.PendingRxMessages;
adapterReader.Read(rxFrames, offset, length);
//Console.WriteLine("Pending: " + length + "Length: " + offset );
offset += length;
} while (offset != msgCount);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine("RxTotal:" + adapterReader.Attributes.RxTotal.ToString());
Console.WriteLine("RxDrop:" + adapterReader.Attributes.RxDrop.ToString());
}
doneEv.Set();
};
adapterWriter.Open(baudrate);
adapterReader.Open(baudrate);
reader.BeginInvoke(null, null);
Thread.Sleep(50);
writer.BeginInvoke(null, null);
doneEv.WaitOne();
watch.Stop();
double calcBps1 = ((msgCount * 8E+0) / (watch.ElapsedMilliseconds / 1000E+0));
double calcBps2 = ((msgCount * 8E+0) / (((DateTime.Now.Ticks - startTick) / 10000E+0) / 1000E+0));
uint rxTotal = adapterReader.Attributes.RxTotal;
Console.WriteLine("Reader RxDrop: " + adapterReader.Attributes.RxDrop);
Console.WriteLine("Writer TxDrop: " + adapterWriter.Attributes.TxDrop);
Console.WriteLine("Átjött Host FIFO-jába: " + offset);
Console.WriteLine("Számított Baudrate 1: " + calcBps1.ToString());
Console.WriteLine("Számított Baudrate 2: " + calcBps2.ToString());
adapterReader.Close();
adapterWriter.Close();
Assert.AreEqual(msgCount, rxTotal, "Az adapter FIFO-jába nem jött meg minden.");
Assert.AreEqual(msgCount, offset, "A Host FIFO-jaba nem jött meg minden.");
}
catch
{
throw;
}
finally
{
adapterWriter.Disconnect();
adapterReader.Disconnect();
}
}
static void Main(string[] args)
{
/*Adapter példányosítása*/
CanAdapterDevice adapter = new CanAdapterDevice();
/*Kapcsolódás egy létező adapterhez.*/
adapter.Connect();
/*Busz lezárás engedélyezése. */
adapter.Attributes.Termination = true;
/*Loopback moód engedélyezése*/
adapter.Attributes.Loopback = true;
/*Megnyitás az átviteli sebesség paraméterrel.*/
adapter.Open(CanBaudRateCollection.Speed125000Baud);
/*2 CAN üzenet tartalmazó tömb létrehozása a kimenő üzenetknek.*/
CanMessage[] txMsgArray = new CanMessage[]
{
/* ArbId Data */
new CanMessage(0x000001, new byte[] { 0x01, 0x02, 0x03 }),
new CanMessage(0x000002, new byte[] { 0x04, 0x05, 0x06 }),
};
/*Üzenetek küldése*/
adapter.Write(txMsgArray);
/*2 elemü üzenet tömb létrehozása a bejövő üzeneteknek.*/
var rxMsgArray = new CanMessage[2];
/*Timeout figyeléshez megjegyezzük az beolvasás indításának időpontját.*/
long timestampTicks = DateTime.Now.Ticks;
bool isTimeout = false;
do
{
/*Ha 2db CAN üzenet várakozik a Bufferben, akkor kiolvassuk.*/
if (adapter.Attributes.PendingRxMessages == 2)
{
/*Bérkezett üzenet beolvasása a tömbe */
adapter.Read(rxMsgArray, 0, adapter.Attributes.PendingRxMessages);
/*Kilépés a do-while-ból*/
break;
}
/*Inditás óta eltelt már 5000ms?*/
isTimeout = (DateTime.Now.Ticks - timestampTicks) > (5000 * 10000);
/*Timeout-ig ismétli a ciklust...*/
} while (!isTimeout);
if (isTimeout)
{
Console.WriteLine("Timeout...");
}
else
{
foreach (CanMessage msg in rxMsgArray)
{
Console.WriteLine("Incoming Msg:" + msg.ToString());
}
Console.WriteLine("Complete.");
}
/*Kapcsolat zárása*/
adapter.Close();
/*Kapcsolat bontása*/
adapter.Disconnect();
Console.Read();
}