/*****************************************************************************
*
* acCanOpen
*
* Purpose:
* open can port by name
*
*
* Arguments:
* PortName - port name
* synchronization - true, synchronization ; false, asynchronous
* MsgNumberOfReadBuffer - message number of read intptr
* MsgNumberOfWriteBuffer - message number of write intptr
* Returns:
* =0 SUCCESS; or <0 failure
*
*****************************************************************************/
private int acCanOpen(string CanPortName, bool synchronization, uint MsgNumberOfReadBuffer, uint MsgNumberOfWriteBuffer)
{
CanPortName = "\\\\.\\" + CanPortName;
if (!synchronization)
{
hDevice = CanDriver.CreateFile(CanPortName, CanDriver.GENERIC_READ + CanDriver.GENERIC_WRITE, 0, IntPtr.Zero, CanDriver.OPEN_EXISTING, CanDriver.FILE_ATTRIBUTE_NORMAL + CanDriver.FILE_FLAG_OVERLAPPED, IntPtr.Zero);
}
else
{
hDevice = CanDriver.CreateFile(CanPortName, CanDriver.GENERIC_READ + CanDriver.GENERIC_WRITE, 0, IntPtr.Zero, CanDriver.OPEN_EXISTING, CanDriver.FILE_ATTRIBUTE_NORMAL, IntPtr.Zero);
}
if (hDevice.ToInt32() == -1)
{
hDevice = INVALID_HANDLE_VALUE;
return(OPERATION_ERROR);
}
if (hDevice != INVALID_HANDLE_VALUE)
{
MaxReadMsgNumber = MsgNumberOfReadBuffer;
MaxWriteMsgNumber = MsgNumberOfWriteBuffer;
orgReadBuf = Marshal.AllocHGlobal((int)(CanDriver.CAN_MSG_LENGTH * 10000));
orgWriteBuf = Marshal.AllocHGlobal((int)(CanDriver.CAN_MSG_LENGTH * 10000));
return(SUCCESS);
}
else
{
return(OPERATION_ERROR);
}
}
public ServiceToolCtrl(ref CanDriver CAN)
{
this.CAN = CAN;
ServiceToolWorker = new Thread(ServiceToolBackgroundWorker);
ServiceToolWorker.IsBackground = true;
ServiceToolWorker.Start();
}
/*****************************************************************************
*
* acSetCommMask
*
* Purpose:
* Execute SetCommMask of AdvCan.
*
*
* Arguments:
* EvtMask - event type
*
*
* Returns:
* true SUCCESS; or false failure
*
*****************************************************************************/
private bool acSetCommMask(uint EvtMask)
{
if (!CanDriver.SetCommMask(hDevice, EvtMask))
{
int num1 = Marshal.GetLastWin32Error();
return(false);
}
Marshal.WriteInt32(this.events.evPtr, 0);
return(true);
}
/*****************************************************************************
*
* acGetStatus
*
* Purpose:
* Get the current status of the driver and the CAN Controller
*
*
* Arguments:
* Status - status buffer
* Returns:
* =0 SUCCESS; or <0 failure
*
*****************************************************************************/
private int acGetStatus(ref Can.CanDriver.CanStatusPar_t Status)
{
bool flag = false;
flag = CanDriver.DeviceIoControl(hDevice, CanDriver.CAN_IOCTL_STATUS, IntPtr.Zero, 0, lpStatusBuffer, CanDriver.CAN_CANSTATUS_LENGTH, ref OutLen, this.ioctlOvr.memPtr);
if (!flag)
{
return(OPERATION_ERROR);
}
Status = (CanDriver.CanStatusPar_t)(Marshal.PtrToStructure(lpStatusBuffer, typeof(CanDriver.CanStatusPar_t)));
return(SUCCESS);
}
/*****************************************************************************
*
* acClearRxFifo
*
* Purpose:
* Clear can port receive buffer
*
*
* Arguments:
*
* Returns:
* =0 SUCCESS; or <0 failure
*
*****************************************************************************/
private int acClearRxFifo()
{
bool flag = false;
Command.cmd = CanDriver.CMD_CLEARBUFFERS;
Marshal.StructureToPtr(Command, lpCommandBuffer, true);
flag = CanDriver.DeviceIoControl(hDevice, CanDriver.CAN_IOCTL_COMMAND, lpCommandBuffer, CanDriver.CAN_COMMAND_LENGTH, IntPtr.Zero, 0, ref OutLen, this.ioctlOvr.memPtr);
if (!flag)
{
return(OPERATION_ERROR);
}
return(SUCCESS);
}
/*****************************************************************************
*
* acEnterWorkMode
*
* Purpose:
* Enter work mode
*
*
* Arguments:
*
* Returns:
* =0 SUCCESS; or <0 failure
*
*****************************************************************************/
private int acEnterWorkMode()
{
bool flag;
Command.cmd = CanDriver.CMD_START;
Marshal.StructureToPtr(Command, lpCommandBuffer, true);
flag = CanDriver.DeviceIoControl(hDevice, CanDriver.CAN_IOCTL_COMMAND, lpCommandBuffer, CanDriver.CAN_COMMAND_LENGTH, IntPtr.Zero, 0, ref OutLen, this.ioctlOvr.memPtr);
if (!flag)
{
return(OPERATION_ERROR);
}
return(SUCCESS);
}
/*****************************************************************************
*
* acCanWrite
*
* Purpose:
* Write can msg
*
*
* Arguments:
* msgWrite - managed buffer for write
* nWriteCount - msg number for write
* pulNumberofWritten - real msgs have written
*
* Returns:
* =0 SUCCESS; or <0 failure
*
*****************************************************************************/
private int acCanWrite(Can.CanDriver.canmsg_t[] msgWrite, uint nWriteCount, ref uint pulNumberofWritten)
{
bool flag;
int nRet;
uint dwErr;
if (nWriteCount > MaxWriteMsgNumber)
{
nWriteCount = MaxWriteMsgNumber;
}
pulNumberofWritten = 0;
flag = CanDriver.WriteFile(hDevice, msgWrite, nWriteCount, out pulNumberofWritten, this.txOvr.memPtr);
if (flag)
{
if (nWriteCount > pulNumberofWritten)
{
nRet = TIME_OUT; //Sending data timeout
}
else
{
nRet = SUCCESS; //Sending data ok
}
}
else
{
dwErr = (uint)Marshal.GetLastWin32Error();
if (dwErr == CanDriver.ERROR_IO_PENDING)
{
if (CanDriver.GetOverlappedResult(hDevice, this.txOvr.memPtr, out pulNumberofWritten, true))
{
if (nWriteCount > pulNumberofWritten)
{
nRet = TIME_OUT; //Sending data timeout
}
else
{
nRet = SUCCESS; //Sending data ok
}
}
else
{
nRet = OPERATION_ERROR; //Sending data error
}
}
else
{
nRet = OPERATION_ERROR; //Sending data error
}
}
return(nRet);
}
/*****************************************************************************
*
* acWaitEvent
*
* Purpose:
* Wait can message or error of the CAN Controller.
*
*
* Arguments:
* msgRead - managed buffer for read
* nReadCount - msg number that unmanaged buffer can preserve
* pulNumberofRead - real msgs have read
* ErrorCode - return error code when the CAN Controller has error
*
* Returns:
* =0 SUCCESS; or <0 failure
*
*****************************************************************************/
private int acWaitEvent(Can.CanDriver.canmsg_t[] msgRead, uint nReadCount, ref uint pulNumberofRead, ref uint ErrorCode)
{
int nRet = OPERATION_ERROR;
ErrorCode = 0;
pulNumberofRead = 0;
if (CanDriver.WaitCommEvent(hDevice, this.events.evPtr, this.events.olPtr) == true)
{
EventCode = (uint)Marshal.ReadInt32(this.events.evPtr, 0);
if ((EventCode & CanDriver.EV_RXCHAR) != 0)
{
nRet = acCanRead(msgRead, nReadCount, ref pulNumberofRead);
}
if ((EventCode & CanDriver.EV_ERR) != 0)
{
nRet = OPERATION_ERROR;
acClearCommError(ref ErrorCode);
}
}
else
{
int err = Marshal.GetLastWin32Error();
if (CanDriver.ERROR_IO_PENDING == err)
{
if (CanDriver.GetOverlappedResult(hDevice, this.eventOvr.memPtr, out pulNumberofRead, true))
{
EventCode = (uint)Marshal.ReadInt32(this.events.evPtr, 0);
if ((EventCode & CanDriver.EV_RXCHAR) != 0)
{
nRet = acCanRead(msgRead, nReadCount, ref pulNumberofRead);
}
if ((EventCode & CanDriver.EV_ERR) != 0)
{
nRet = OPERATION_ERROR;
acClearCommError(ref ErrorCode);
}
}
else
{
nRet = OPERATION_ERROR;
}
}
else
{
nRet = OPERATION_ERROR;
}
}
return(nRet);
}
/*****************************************************************************
*
* acCanClose
*
* Purpose:
* Close can port
*
*
* Arguments:
*
* Returns:
* =0 SUCCESS; or <0 failure
*
*****************************************************************************/
private int acCanClose()
{
if (hDevice != INVALID_HANDLE_VALUE)
{
CanDriver.CloseHandle(hDevice);
Thread.Sleep(100);
Marshal.FreeHGlobal(orgWriteBuf);
Marshal.FreeHGlobal(orgReadBuf);
hDevice = INVALID_HANDLE_VALUE;
}
return(SUCCESS);
}
/*****************************************************************************
*
* acSetAcceptanceFilterCode
*
* Purpose:
* Set acceptance filter code of the CAN Controller
*
*
* Arguments:
* Code - acceptance filter code
* Returns:
* =0 SUCCESS; or <0 failure
*
*****************************************************************************/
private int acSetAcceptanceFilterCode(uint Code)
{
bool flag = false;
Config.target = CanDriver.CONF_ACCC;
Config.val1 = Code;
Marshal.StructureToPtr(Config, lpConfigBuffer, true);
flag = CanDriver.DeviceIoControl(hDevice, CanDriver.CAN_IOCTL_CONFIG, lpConfigBuffer, CanDriver.CAN_CONFIG_LENGTH, IntPtr.Zero, 0, ref OutLen, this.ioctlOvr.memPtr);
if (!flag)
{
return(OPERATION_ERROR);
}
return(SUCCESS);
}
/*****************************************************************************
*
* acSetBaud
*
* Purpose:
* Set baudrate of the CAN Controller.The two modes of configuring
* baud rate are custom mode and standard mode.
* - Custom mode
* If Baud Rate value is user defined, driver will write the first 8
* bit of low 16 bit in BTR0 of SJA1000.
* The lower order 8 bit of low 16 bit will be written in BTR1 of SJA1000.
* - Standard mode
* Target value BTR0 BTR1 Setting value
* 10K 0x31 0x1c 10
* 20K 0x18 0x1c 20
* 50K 0x09 0x1c 50
* 100K 0x04 0x1c 100
* 125K 0x03 0x1c 125
* 250K 0x01 0x1c 250
* 500K 0x00 0x1c 500
* 800K 0x00 0x16 800
* 1000K 0x00 0x14 1000
*
*
* Arguments:
* BaudRateValue - baudrate will be set
* Returns:
* =0 SUCCESS; or <0 failure
*
*****************************************************************************/
private int acSetBaud(uint BaudRateValue)
{
bool flag;
Config.target = CanDriver.CONF_TIMING;
Config.val1 = BaudRateValue;
Marshal.StructureToPtr(Config, lpConfigBuffer, true);
flag = CanDriver.DeviceIoControl(hDevice, CanDriver.CAN_IOCTL_CONFIG, lpConfigBuffer, CanDriver.CAN_CONFIG_LENGTH, IntPtr.Zero, 0, ref OutLen, this.ioctlOvr.memPtr);
if (!flag)
{
return(OPERATION_ERROR);
}
return(SUCCESS);
}
/*****************************************************************************
*
* acSetListenOnlyMode
*
* Purpose:
* Set listen only mode of the CAN Controller
*
*
* Arguments:
* ListenOnly - true, open only listen mode; false, close only listen mode
* Returns:
* =0 succeeded; or <0 Failed
*
*****************************************************************************/
private int acSetListenOnlyMode(bool ListenOnly)
{
bool flag;
Config.target = CanDriver.CONF_LISTEN_ONLY_MODE;
if (ListenOnly)
{
Config.val1 = 1;
}
else
{
Config.val1 = 0;
}
Marshal.StructureToPtr(Config, lpConfigBuffer, true);
flag = CanDriver.DeviceIoControl(hDevice, CanDriver.CAN_IOCTL_CONFIG, lpConfigBuffer, CanDriver.CAN_CONFIG_LENGTH, IntPtr.Zero, 0, ref OutLen, this.ioctlOvr.memPtr);
if (!flag)
{
return(OPERATION_ERROR);
}
return(SUCCESS);
}
/*****************************************************************************
*
* acSetSelfReception
*
* Purpose:
* Set support for self reception
*
*
* Arguments:
* SelfFlag - true, open self reception; false, close self reception
* Returns:
* =0 SUCCESS; or <0 failure
*
*****************************************************************************/
private int acSetSelfReception(bool SelfFlag)
{
bool flag;
Config.target = CanDriver.CONF_SELF_RECEPTION;
if (SelfFlag)
{
Config.val1 = 1;
}
else
{
Config.val1 = 0;
}
Marshal.StructureToPtr(Config, lpConfigBuffer, true);
flag = CanDriver.DeviceIoControl(hDevice, CanDriver.CAN_IOCTL_CONFIG, lpConfigBuffer, CanDriver.CAN_CONFIG_LENGTH, IntPtr.Zero, 0, ref OutLen, this.ioctlOvr.memPtr);
if (!flag)
{
return(OPERATION_ERROR);
}
return(SUCCESS);
}
void Init_Can()
{
CAN = new CanDriver();
CAN.IntCanDriver();
CAN_SetupFilters();
CAN.UiEvent += CAN_UiEvent;
CAN.OpenCanChannel(0);
}
void DeInit_Can()
{
if (CAN != null)
{
CAN.Kill_Threads();
CAN = null;
}
}
/*****************************************************************************
*
* acGetCommMask
*
* Purpose:
* Execute GetCommMask of AdvCan.
*
*
* Arguments:
* EvtMask - event type
*
*
* Returns:
* true SUCCESS; or false failure
*
*****************************************************************************/
private bool acGetCommMask(ref uint EvtMask)
{
return(CanDriver.GetCommMask(hDevice, ref EvtMask));
}
/*****************************************************************************
*
* acClearCommError
*
* Purpose:
* Execute ClearCommError of AdvCan.
*
*
* Arguments:
* ErrorCode - error code if the CAN Controller occur error
*
*
* Returns:
* true SUCCESS; or false failure
*
*****************************************************************************/
private bool acClearCommError(ref uint ErrorCode)
{
CanDriver.COMSTAT lpState = new CanDriver.COMSTAT();
return(CanDriver.ClearCommError(hDevice, out ErrorCode, out lpState));
}
/*****************************************************************************
*
* acCanRead
*
* Purpose:
* Read can message.
*
*
* Arguments:
* msgRead - managed buffer for read
* nReadCount - msg number that unmanaged buffer can preserve
* pulNumberofRead - real msgs have read
*
* Returns:
* =0 SUCCESS; or <0 failure
*
*****************************************************************************/
private int acCanRead(Can.CanDriver.canmsg_t[] msgRead, uint nReadCount, ref uint pulNumberofRead)
{
bool flag;
int nRet;
uint i;
if (nReadCount > MaxReadMsgNumber)
{
nReadCount = MaxReadMsgNumber;
}
pulNumberofRead = 0;
flag = CanDriver.ReadFile(hDevice, orgReadBuf, nReadCount, out pulNumberofRead, this.rxOvr.memPtr);
if (flag)
{
if (pulNumberofRead == 0)
{
nRet = TIME_OUT;
}
else
{
for (i = 0; i < pulNumberofRead; i++)
{
if (OS_TYPE == 8)
{
msgRead[i] = (CanDriver.canmsg_t)(Marshal.PtrToStructure(new IntPtr(orgReadBuf.ToInt64() + CanDriver.CAN_MSG_LENGTH * i), typeof(CanDriver.canmsg_t)));
}
else
{
msgRead[i] = (CanDriver.canmsg_t)(Marshal.PtrToStructure(new IntPtr(orgReadBuf.ToInt32() + CanDriver.CAN_MSG_LENGTH * i), typeof(CanDriver.canmsg_t)));
}
}
nRet = SUCCESS;
}
}
else
{
if (CanDriver.GetOverlappedResult(hDevice, this.rxOvr.memPtr, out pulNumberofRead, true))
{
if (pulNumberofRead == 0)
{
nRet = TIME_OUT; //Package receiving timeout
}
else
{
for (i = 0; i < pulNumberofRead; i++)
{
if (OS_TYPE == 8)
{
msgRead[i] = (CanDriver.canmsg_t)(Marshal.PtrToStructure(new IntPtr(orgReadBuf.ToInt64() + CanDriver.CAN_MSG_LENGTH * i), typeof(CanDriver.canmsg_t)));
}
else
{
msgRead[i] = (CanDriver.canmsg_t)(Marshal.PtrToStructure(new IntPtr(orgReadBuf.ToInt32() + CanDriver.CAN_MSG_LENGTH * i), typeof(CanDriver.canmsg_t)));
}
}
nRet = SUCCESS;
}
}
else
{
nRet = OPERATION_ERROR; //Package receiving error
}
}
return(nRet);
}