private void SelectDevice()
{
try
{
// get selected device info
deviceManager = VciServer.Instance().DeviceManager;
deviceList = deviceManager.GetDeviceList();
deviceEnum = deviceListCBox.Items.GetEnumerator();
deviceEnum.MoveNext();
mDevice = deviceEnum.Current as IVciDevice;
IVciCtrlInfo info = mDevice.Equipment[0];
// inform the user on the selected device
MessageBox.Show("Selected Device:\n" + mDevice.ToString(), "INFO",
MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error!", MessageBoxButtons.OK, MessageBoxIcon.Error);
slctDevBtn.Enabled = true;
}
finally
{
// release the resources of the library
DisposeVciObject(deviceManager);
DisposeVciObject(deviceList);
DisposeVciObject(deviceEnum);
slctDevBtn.Enabled = false;
}
}
/// <summary>
/// Проверка списка CAN-адаптеров
/// </summary>
public string[] ListOfDevices()
{
string CheckDevice = "";
IVciDeviceManager deviceManager = null;
System.Collections.IEnumerator deviceEnum = null;
try
{
deviceManager = VciServer.GetDeviceManager();
deviceList = deviceManager.GetDeviceList();
deviceEnum = deviceList.GetEnumerator();
deviceEnum.MoveNext();
do
{
mDevice = deviceEnum.Current as IVciDevice;
object serialNumberGuid = mDevice.UniqueHardwareId;
string serialNumberText = GetSerialNumberText(ref serialNumberGuid);
CheckDevice += mDevice.Description + " " + mDevice.UniqueHardwareId.ToString() + ";";
} while (deviceEnum.MoveNext() != false);
}
catch (Exception)
{
CheckDevice = "Error: No VCI device installed";
}
finally
{
DisposeVciObject(deviceManager);
DisposeVciObject(deviceEnum);
}
return(CheckDevice.Split(';'));
}
//************************************************************************
/// <summary>
/// Selects the first CAN adapter.
/// </summary>
//************************************************************************
static void SelectDevice()
{
IVciDeviceManager deviceManager = null;
IVciDeviceList deviceList = null;
IEnumerator deviceEnum = null;
try
{
//
// Get device manager from VCI server
//
deviceManager = VciServer.GetDeviceManager();
//
// Get the list of installed VCI devices
//
deviceList = deviceManager.GetDeviceList();
deviceList = deviceManager.GetDeviceList();
//
// Get enumerator for the list of devices
//
deviceEnum = deviceList.GetEnumerator();
//
// Get first device
//
deviceEnum.MoveNext();
mDevice = deviceEnum.Current as IVciDevice;
// show the device name and serial number
object serialNumberGuid = mDevice.UniqueHardwareId;
string serialNumberText = GetSerialNumberText(ref serialNumberGuid);
Console.Write(" Interface : " + mDevice.Description + "\n");
Console.Write(" Serial number: " + serialNumberText + "\n");
}
catch (Exception)
{
Console.WriteLine("Error: No VCI device installed");
}
finally
{
//
// Dispose device manager ; it's no longer needed.
//
DisposeVciObject(deviceManager);
//
// Dispose device list ; it's no longer needed.
//
DisposeVciObject(deviceList);
//
// Dispose device list ; it's no longer needed.
//
DisposeVciObject(deviceEnum);
}
}
//************************************************************************
/// <summary>
/// Selects the first LIN adapter.
/// </summary>
/// <return> true if succeeded, false otherwise</return>
//************************************************************************
static bool SelectDevice()
{
bool succeeded = true;
IVciDeviceManager deviceManager = null;
IVciDeviceList deviceList = null;
IEnumerator deviceEnum = null;
try
{
//
// Get device manager from VCI server
//
deviceManager = VciServer.GetDeviceManager();
//
// Get the list of installed VCI devices
//
deviceList = deviceManager.GetDeviceList();
deviceList = deviceManager.GetDeviceList();
//
// Get enumerator for the list of devices
//
deviceEnum = deviceList.GetEnumerator();
//
// Get first device
//
deviceEnum.MoveNext();
mDevice = deviceEnum.Current as IVciDevice;
}
catch (Exception)
{
Console.WriteLine("Error: No VCI device installed");
succeeded = false;
}
finally
{
//
// Dispose device manager ; it's no longer needed.
//
DisposeVciObject(deviceManager);
//
// Dispose device list ; it's no longer needed.
//
DisposeVciObject(deviceList);
//
// Dispose device list ; it's no longer needed.
//
DisposeVciObject(deviceEnum);
}
return(succeeded);
}
public static bool InitDevice(byte canNo, int canSpeed, int adapterNo)
{
IBalObject bal = null;
System.Collections.IEnumerator deviceEnum = null;
int i = -1;
try
{
deviceEnum = deviceList.GetEnumerator();
deviceEnum.MoveNext();
do
{
i++;
if (i == adapterNo)
{
mDevice = deviceEnum.Current as IVciDevice;
}
} while (deviceEnum.MoveNext() != false);
bal = mDevice.OpenBusAccessLayer();
mCanChn = bal.OpenSocket(canNo, typeof(ICanChannel)) as ICanChannel;
mCanChn.Initialize(1024, 128, false);
mReader = mCanChn.GetMessageReader();
mReader.Threshold = 1;
mRxEvent = new AutoResetEvent(false);
mReader.AssignEvent(mRxEvent);
mWriter = mCanChn.GetMessageWriter();
mWriter.Threshold = 1;
mCanChn.Activate();
int a = bal.Resources.Count - 1;
mCanCtl = bal.OpenSocket(canNo, typeof(ICanControl)) as ICanControl;
mCanCtl.InitLine(CanOperatingModes.Standard | CanOperatingModes.ErrFrame
, CanBitrate.Cia250KBit);
mCanCtl.SetAccFilter(CanFilter.Std,
(uint)CanAccCode.All, (uint)CanAccMask.All);
mCanCtl.StartLine();
return(true);
}
catch (Exception e)
{
MessageBox.Show("Error: Initializing socket failed: " + e.Message);
return(false);
}
finally
{
DisposeVciObject(bal);
DisposeVciObject(deviceEnum);
IsOpen = true;
}
}
static IVciDevice GetDeviceByString(String adapterSerial)
{
IVciDevice _return = null;
IVciDeviceManager deviceManager = null;
IVciDeviceList deviceList = null;
System.Collections.IEnumerator deviceEnum = null;
String SerialNumber = String.Empty;
try
{
deviceManager = VciServer.Instance().DeviceManager;
deviceList = deviceManager.GetDeviceList();
deviceEnum = deviceList.GetEnumerator();
while (deviceEnum.MoveNext())
{
_return = deviceEnum.Current as IVciDevice;
object serialNumberGuid = _return.UniqueHardwareId;
if (GetSerialNumberText(serialNumberGuid) == adapterSerial)
{
break;
}
}
}
catch (Exception exc)
{
Debug.WriteLine("Error: " + exc.Message + "\n");
}
finally
{
DisposeVciObject(deviceManager);
DisposeVciObject(deviceList);
DisposeVciObject(deviceEnum);
}
return(_return);
}
static void DeviceListEvent()
{
IVciDeviceManager _deviceManager = null;
IVciDeviceList _deviceList = null;
System.Collections.IEnumerator _deviceEnum = null;
IVciDevice _mDevice = null;
Devices = new List <string>();
Debug.WriteLine("DeviceListEvent\n");
try
{
_deviceManager = VciServer.Instance().DeviceManager;
_deviceList = _deviceManager.GetDeviceList();
_deviceEnum = _deviceList.GetEnumerator();
for (int i = 1; _deviceEnum.MoveNext(); i++)
{
_mDevice = _deviceEnum.Current as IVciDevice;
Devices.Add(Can.GetSerialNumberText(_mDevice.UniqueHardwareId));
Debug.WriteLine(" " + i + ":" + Can.GetSerialNumberText(_mDevice.UniqueHardwareId) + "\n");
}
ListChanged();
}
catch (Exception exc)
{
Debug.WriteLine("Error: " + exc.Message + "\n");
}
finally
{
Can.DisposeVciObject(_mDevice);
Can.DisposeVciObject(_deviceManager);
Can.DisposeVciObject(_deviceList);
Can.DisposeVciObject(_deviceEnum);
}
}
/// <summary>
/// Закрывает CAN порт
/// </summary>
public override void Close()
{
String msg;
// Закрываем поток на чтение
Interlocked.Exchange(ref _FlagMustQuit, 0);
lock (_SyncRoot)
{
this._RxEvent.Set();
}
for (int i = 0; i < 1; i++)
{
if (this._ThreadForInput.IsAlive == true)
{
// Ждём завершение потока
Thread.Sleep(500);
}
else
{
// Поток завершён
break;
}
}
// Если поток не завершился в течнии 10 секунд, значит дело плохо.
// Выводим об этом трассировочную информацию
if (this._ThreadForInput.IsAlive == true)
{
this._ThreadForInput.Abort();
msg = String.Format(
"{0}: class CanPort.Close(): Рабочий поток не завершился за 0,5 секунду и находится в состоянии {1}",
DateTime.Now.ToString(new System.Globalization.CultureInfo("ru-Ru", false)), this._ThreadForInput.ThreadState.ToString());
Trace.TraceError(msg);
}
//SetMode(CANPORTSTATUS.IsPassive);
_CanController.StopLine();
//_CanChannel.Deactivate();
_RxEvent.Close();
_RxEvent = null;
// Освобождаем ресурсы
DisposeVciObject(_CanBusLayer);
DisposeVciObject(_CanChannel);
DisposeVciObject(_CanController);
DisposeVciObject(_CanDevice);
DisposeVciObject(_Reader);
DisposeVciObject(_Writer);
_CanBusLayer = null;
_CanChannel = null;
_CanController = null;
_CanDevice = null;
_Reader = null;
_Writer = null;
// Устанавливаем флаг признак "порт закрыт"
this._PortStatus = CanPortStatus.IsClosed;
// Формирум событие
OnPortChangesStatus(CanPortStatus.IsClosed);
Trace.TraceInformation("{0}: class CanPort.Close(): Порт закрыт",
DateTime.Now.ToString(new System.Globalization.CultureInfo("ru-Ru")));
return;
}
/// <summary>
/// Открывает порт
/// </summary>
public override void Open()
{
String msg;
IVciDeviceList deviceList;
String serialNumber;
Object pack;
if (this._CanDevice == null)
{
// Получаем список доступных устройств
deviceList = GetDeviceList();
// Находим нужное нам устройство и открываем его
foreach (IVciDevice item in deviceList)
{
pack = (Object)item.UniqueHardwareId;
serialNumber = GetSerialNumber(ref pack);
if (serialNumber == this._SerialNumber)
{
// Устройство найдено
this._CanDevice = item;
break;
}
}
}
if (this._CanDevice != null)
{
// Открываем порт
Byte numberPort = 0;
// Устройство найдено, открываем порт
if (this.InitSocket(numberPort, ref this._CanDevice))
{
// Порт открыт
// Устанавливаем флаг начала опроса порта
Interlocked.Exchange(ref _FlagMustQuit, Int32.MaxValue);
// start the receive thread
_ThreadForInput = new Thread(new ThreadStart(HandleQueueIncomingMessages));
_ThreadForInput.Start();
// Устанавливаем флаг - признак "порт открыт"
//_PortStatus = CANPORTSTATUS.IsPassive;
// Здесь костыль: Почему-то, инфо-сообщения драйвера о переходе в новый статус при открытии порта не приходят.
// Поэтому проверяем в ручную. Если поле _PortStatus не соответсвует текущему состоянию,
// то останавливаем принудительно
if (this._CanChannel.ChannelStatus.IsActivated)
{
if (this._PortStatus != CanPortStatus.IsActive)
{
this._PortStatus = CanPortStatus.IsActive;
// Генерируем событие
this.OnPortChangesStatus(CanPortStatus.IsActive);
}
}
}
else
{
// Порт не удалось открыть
msg = String.Format(
"{0}: class CanPort: Невозможно открыть CAN порт. Порт: {1} не удалось открыть.",
DateTime.Now.ToString(new System.Globalization.CultureInfo("ru-Ru", false)), this._SerialNumber);
Trace.TraceError(msg);
throw new InvalidOperationException(msg, null);
}
}
else
{
// Устройство не найдено
msg = String.Format("{0}: class CanPort: Невозможно открыть CAN порт. Порт: {1} не найден",
DateTime.Now.ToString(new System.Globalization.CultureInfo("ru-Ru", false)), this._SerialNumber);
Trace.TraceError(msg);
throw new Exception(msg);
//throw new InvalidOperationException(msg, null);
}
return;
}
/// <summary>
/// Освобождает ресурсы.
/// </summary>
public override void Dispose()
{
// Закрываем поток
Interlocked.Exchange(ref this._FlagMustQuit, 0);
// Завершаем событие, предварительно установив сигнальное состояние
// для пробуждения рабочего потока и возможность его завершения
if (this._RxEvent != null)
{
this._RxEvent.Set();
this._RxEvent.Close();
}
// Освобождаем ресурсы
DisposeVciObject(_CanBusLayer);
DisposeVciObject(_CanChannel);
DisposeVciObject(_CanController);
DisposeVciObject(_CanDevice);
_CanBusLayer = null;
_CanChannel = null;
_CanController = null;
_CanDevice = null;
return;
}
private void OnDeserialized(StreamingContext context)
{
IVciDeviceList deviceList;
String serialNumber;
Object pack;
// Получаем список доступных устройств
deviceList = GetDeviceList();
// Находим нужное нам устройство и открываем его
foreach (IVciDevice item in deviceList)
{
pack = (Object)item.UniqueHardwareId;
serialNumber = GetSerialNumber(ref pack);
if (serialNumber == this._SerialNumber)
{
// Устройство найдено
this._CanDevice = item;
break;
}
}
return;
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="portName">Наименование порта (серийный номер порта)</param>
public CanPort(String portName, BaudRate bitRate, FrameFormat frameFormat,
PortMode mode)
{
IVciDeviceList deviceList;
String serialNumber;
Object pack;
// Настраиваем поля
this.PortName = portName;
// Инициализируем входной буфер сообщений
this._InputBufferMessages = new Queue<Frame>(100);
// Инициализируем свойства порта
this._FrameFormat = frameFormat;
this._ErrorFrameEnable = true;
((ICanPort)this).Mode = mode;
this._LowSpeedModeEnable = false;
// Устанавливаем скорость по умолчанию
this._CanBitRate = bitRate;
// Получаем список доступных устройств
deviceList = GetDeviceList();
// Находим нужное нам устройство и открываем его
foreach (IVciDevice item in deviceList)
{
pack = (Object)item.UniqueHardwareId;
serialNumber = GetSerialNumber(ref pack);
if (serialNumber == this._SerialNumber)
{
// Устройство найдено
this._CanDevice = item;
break;
}
}
}
/// <summary>
/// Opens the specified socket, creates a message channel, initializes
/// and starts the CAN controller.
/// </summary>
/// <param name="canNo">
/// Number of the CAN controller to open.
/// </param>
/// <returns>
/// A value indicating if the socket initialization succeeded or failed.
/// </returns>
private bool InitSocket(Byte canNo,
ref IVciDevice device)
{
this._CanBusLayer = null;
bool succeeded = false;
try
{
// Open bus access layer
_CanBusLayer = device.OpenBusAccessLayer();
// Open a message channel for the CAN controller
_CanChannel = _CanBusLayer.OpenSocket(canNo, typeof(ICanChannel)) as ICanChannel;
// Initialize the message channel
// Используем канал единолично (true)
_CanChannel.Initialize(1024, 128, true);
// Get a message reader object
_Reader = _CanChannel.GetMessageReader();
// Initialize message reader
_Reader.Threshold = 1;
// Create and assign the event that's set if at least one message
// was received.
_RxEvent = new AutoResetEvent(false);
_Reader.AssignEvent(_RxEvent);
// Get a message wrtier object
_Writer = _CanChannel.GetMessageWriter();
// Initialize message writer
_Writer.Threshold = 1;
// Activate the message channel
_CanChannel.Activate();
// Open the CAN controller
_CanController = _CanBusLayer.OpenSocket(canNo, typeof(ICanControl)) as ICanControl;
// Инициализируем контроллер с текущими параметрами
this.Init();
// !!!! ВНИМАНИЕ применяется фильтр, с данным куском не разобрался
// Set the acceptance filter
//_CanController.SetAccFilter(CanFilter.Std,
// (uint)CanAccCode.All, (uint)CanAccMask.All);
// Start the CAN controller
_CanController.StartLine();
succeeded = true;
}
catch
{
//MessageBox.Show(this, "Error: Initializing socket failed. Description: " + ex.Message, "Ошибка",
// MessageBoxButtons.OK, MessageBoxIcon.Error);
succeeded = false;
// Если не удалось открыть порт удаляем всё объекты
DisposeVciObject(_CanChannel);
DisposeVciObject(_Reader);
DisposeVciObject(_Writer);
DisposeVciObject(_CanBusLayer);
DisposeVciObject(_CanController);
throw; // Возобнавляем исключение
}
return succeeded;
}
static public bool InitSocket(String adapter, uint baudrate)
{
FinalizeApp();
IBalObject bal = null;
bool succeeded = false;
IVciDevice device = null;
try
{
device = GetDeviceByString(adapter);
//
// Open bus access layer
//
bal = device.OpenBusAccessLayer();
//
// Open a message channel for the CAN controller
//
mCanChn = bal.OpenSocket(0, typeof(ICanChannel)) as ICanChannel;
/*//
* // Open the scheduler of the CAN controller
* //
* Log("4"); // не проходит переинициализацию, что-то надо сделать
* mCanSched = bal.OpenSocket(0, typeof(ICanScheduler)) as ICanScheduler;*/
// Initialize the message channel
mCanChn.Initialize(1024, 128, false);
// Get a message reader object
mReader = mCanChn.GetMessageReader();
// Initialize message reader
mReader.Threshold = 1;
// Create and assign the event that's set if at least one message
// was received.
mRxEvent = new System.Threading.AutoResetEvent(false);
mReader.AssignEvent(mRxEvent);
// Get a message wrtier object
mWriter = mCanChn.GetMessageWriter();
// Initialize message writer
mWriter.Threshold = 1;
mTxEvent = new System.Threading.AutoResetEvent(false);
mWriter.AssignEvent(mTxEvent);
// Activate the message channel
mCanChn.Activate();
//
// Open the CAN controller
//
mCanCtl = bal.OpenSocket(0, typeof(ICanControl)) as ICanControl;
CanBitrate _cb = new CanBitrate();
switch (baudrate)
{
case BAUDRATE_125:
_cb = CanBitrate.Cia125KBit; break;
case BAUDRATE_250:
_cb = CanBitrate.Cia250KBit; break;
default:
_cb = CanBitrate.Cia125KBit; break;
}
// Initialize the CAN controller
mCanCtl.InitLine(CanOperatingModes.Standard |
CanOperatingModes.Extended | //extended отключить наверняка стоит
CanOperatingModes.ErrFrame,
_cb);
//
// print line status
//
Debug.WriteLine(" LineStatus: " + mCanCtl.LineStatus + "\n|");
// Set the acceptance filter for std identifiers
mCanCtl.SetAccFilter(CanFilter.Std,
(uint)CanAccCode.All, (uint)CanAccMask.All);
// Set the acceptance filter for ext identifiers
mCanCtl.SetAccFilter(CanFilter.Ext,
(uint)CanAccCode.All, (uint)CanAccMask.All);
// Start the CAN controller
mCanCtl.StartLine();
succeeded = true;
}
catch (Exception exc)
{
Debug.WriteLine("Error: Initializing socket failed : " + exc.Message + "\n|");
succeeded = false;
}
finally
{
DisposeVciObject(device);
DisposeVciObject(bal);
}
return(succeeded);
}
