rusefi
/
openblt
mirror of https://github.com/rusefi/openblt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
openblt/Host/Source/LibOpenBLT/port/windows/canif/peak/pcanusb.c

1018 lines
39 KiB
C
Raw Blame History

/************************************************************************************//**
* \file pcanusb.c
* \brief Peak PCAN-USB interface source file.
* \ingroup PCanUsb
* \internal
*----------------------------------------------------------------------------------------
* C O P Y R I G H T
*----------------------------------------------------------------------------------------
* Copyright (c) 2017 by Feaser http://www.feaser.com All rights reserved
*
*----------------------------------------------------------------------------------------
* L I C E N S E
*----------------------------------------------------------------------------------------
* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option) any later
* version.
*
* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You have received a copy of the GNU General Public License along with OpenBLT. It
* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy.
*
* \endinternal
****************************************************************************************/
/****************************************************************************************
* Include files
****************************************************************************************/
#include <assert.h> /* for assertions */
#include <stdint.h> /* for standard integer types */
#include <stddef.h> /* for NULL declaration */
#include <stdbool.h> /* for boolean type */
#include <stdlib.h> /* for standard library */
#include <string.h> /* for string library */
#include "candriver.h" /* Generic CAN driver module */
#include "pcanusb.h" /* Peak PCAN-USB interface */
#include <windows.h> /* for Windows API */
#include "PCANBasic.h" /* for PCAN-Basic API */
/****************************************************************************************
* Macro definitions
****************************************************************************************/
/** \brief Configurable to enabled/disable the automatic CAN bus off recovery feature.
* Testing shows that it is better to leave this disabled. If no connection
* with the target can be made, the PCAN-USB automatically re-initialized anyway.
*/
#define PCANUSB_BUSOFF_AUTORECOVERY_ENABLE (0u)
/***************************************************************************************
* Type definitions
****************************************************************************************/
/* Type definitions of the functions in the PCAN-Basic API that this CAN interface uses.*/
typedef TPCANStatus (__stdcall * tPCanUsbLibFuncInitialize)(TPCANHandle, TPCANBaudrate, TPCANType, DWORD, WORD);
typedef TPCANStatus (__stdcall * tPCanUsbLibFuncUninitialize)(TPCANHandle);
typedef TPCANStatus (__stdcall * tPCanUsbLibFuncGetStatus)(TPCANHandle);
typedef TPCANStatus (__stdcall * tPCanUsbLibFuncSetValue)(TPCANHandle, TPCANParameter, void*, DWORD);
typedef TPCANStatus (__stdcall * tPCanUsbLibFuncRead)(TPCANHandle, TPCANMsg*, TPCANTimestamp*);
typedef TPCANStatus (__stdcall * tPCanUsbLibFuncWrite)(TPCANHandle, TPCANMsg*);
typedef TPCANStatus (__stdcall * tPCanUsbLibFuncFilterMessages)(TPCANHandle, DWORD, DWORD, TPCANMode);
/***************************************************************************************
* Function prototypes
****************************************************************************************/
/* CAN interface functions. */
static void PCanUsbInit(tCanSettings const * settings);
static void PCanUsbTerminate(void);
static bool PCanUsbConnect(void);
static void PCanUsbDisconnect(void);
static bool PCanUsbTransmit(tCanMsg const * msg);
static bool PCanUsbIsBusError(void);
static void PCanUsbRegisterEvents(tCanEvents const * events);
/* CAN message reception thread. */
static DWORD WINAPI PCanUsbReceptionThread(LPVOID pv);
/* PCAN-Basic library handling. */
static void PCanUsbLibLoadDll(void);
static void PCanUsbLibUnloadDll(void);
static TPCANStatus PCanUsbLibFuncInitialize(TPCANHandle Channel, TPCANBaudrate Btr0Btr1,
TPCANType HwType, DWORD IOPort,
WORD Interrupt);
static TPCANStatus PCanUsbLibFuncUninitialize(TPCANHandle Channel);
static TPCANStatus PCanUsbLibFuncGetStatus(TPCANHandle Channel);
static TPCANStatus PCanUsbLibFuncSetValue(TPCANHandle Channel, TPCANParameter Parameter,
void * Buffer, DWORD BufferLength);
static TPCANStatus PCanUsbLibFuncRead(TPCANHandle Channel, TPCANMsg * MessageBuffer,
TPCANTimestamp * TimestampBuffer);
static TPCANStatus PCanUsbLibFuncWrite(TPCANHandle Channel, TPCANMsg * MessageBuffer);
static TPCANStatus PCanUsbLibFuncFilterMessages(TPCANHandle Channel, DWORD FromID,
DWORD ToID, TPCANMode Mode);
/****************************************************************************************
* Local constant declarations
****************************************************************************************/
/** \brief CAN interface structure filled with Peak PCAN-USB specifics. */
static const tCanInterface pCanUsbInterface =
{
PCanUsbInit,
PCanUsbTerminate,
PCanUsbConnect,
PCanUsbDisconnect,
PCanUsbTransmit,
PCanUsbIsBusError,
PCanUsbRegisterEvents
};
/** \brief PCAN-USB channel handle lookup table. The pCanUsbSettings.channel value can
* be used as the index.
*/
static const TPCANHandle pCanUsbChannelLookup[] =
{
PCAN_USBBUS1, /* PCAN-USB interface, channel 1. */
PCAN_USBBUS2, /* PCAN-USB interface, channel 2. */
PCAN_USBBUS3, /* PCAN-USB interface, channel 3. */
PCAN_USBBUS4, /* PCAN-USB interface, channel 4. */
PCAN_USBBUS5, /* PCAN-USB interface, channel 5. */
PCAN_USBBUS6, /* PCAN-USB interface, channel 6. */
PCAN_USBBUS7, /* PCAN-USB interface, channel 7. */
PCAN_USBBUS8, /* PCAN-USB interface, channel 8. */
PCAN_USBBUS9, /* PCAN-USB interface, channel 9. */
PCAN_USBBUS10, /* PCAN-USB interface, channel 10. */
PCAN_USBBUS11, /* PCAN-USB interface, channel 11. */
PCAN_USBBUS12, /* PCAN-USB interface, channel 12. */
PCAN_USBBUS13, /* PCAN-USB interface, channel 13. */
PCAN_USBBUS14, /* PCAN-USB interface, channel 14. */
PCAN_USBBUS15, /* PCAN-USB interface, channel 15. */
PCAN_USBBUS16 /* PCAN-USB interface, channel 16. */
};
/****************************************************************************************
* Local data declarations
****************************************************************************************/
/** \brief The settings to use in this CAN interface. */
static tCanSettings pCanUsbSettings;
/** \brief List with callback functions that this driver should use. */
static tCanEvents * pCanUsbEventsList;
/** \brief Total number of event entries into the \ref pCanUsbEventsList list. */
static uint32_t pCanUsbEventsEntries;
/** \brief Handle to the PCAN-Basic dynamic link library. */
static HINSTANCE pCanUsbDllHandle;
/** \brief Function pointer to the PCAN-Basic Initialize function. */
static tPCanUsbLibFuncInitialize pCanUsbLibFuncInitializePtr;
/** \brief Function pointer to the PCAN-Basic Uninitialize function. */
static tPCanUsbLibFuncUninitialize pCanUsbLibFuncUninitializePtr;
/** \brief Function pointer to the PCAN-Basic GetStatus function. */
static tPCanUsbLibFuncGetStatus pCanUsbLibFuncGetStatusPtr;
/** \brief Function pointer to the PCAN-Basic SetValue function. */
static tPCanUsbLibFuncSetValue pCanUsbLibFuncSetValuePtr;
/** \brief Function pointer to the PCAN-Basic Read function. */
static tPCanUsbLibFuncRead pCanUsbLibFuncReadPtr;
/** \brief Function pointer to the PCAN-Basic Write function. */
static tPCanUsbLibFuncWrite pCanUsbLibFuncWritePtr;
/** \brief Function pointer to the PCAN-Basic FilterMessages function. */
static tPCanUsbLibFuncFilterMessages pCanUsbLibFuncFilterMessagesPtr;
/** \brief Handle for the event to terminate the reception thread. */
static HANDLE pCanUsbTerminateEvent;
/** \brief Handle for a CAN related event. */
static HANDLE pCanUsbCanEvent;
/** \brief Handle for the CAN reception thread. */
static HANDLE pCanUsbRxThreadHandle;
/***********************************************************************************//**
** \brief Obtains a pointer to the CAN interface structure, so that it can be linked
** to the generic CAN driver module.
** \return Pointer to CAN interface structure.
**
****************************************************************************************/
tCanInterface const * PCanUsbGetInterface(void)
{
return &pCanUsbInterface;
} /*** end of PCanUsbGetInterface ***/
/************************************************************************************//**
** \brief Initializes the CAN interface.
** \param settings Pointer to the CAN interface settings.
**
****************************************************************************************/
static void PCanUsbInit(tCanSettings const * settings)
{
char * canDeviceName;
/* Initialize locals. */
pCanUsbEventsList = NULL;
pCanUsbEventsEntries = 0;
pCanUsbTerminateEvent = NULL;
pCanUsbCanEvent = NULL;
pCanUsbRxThreadHandle = NULL;
pCanUsbDllHandle = NULL;
/* Reset library function pointers. */
pCanUsbLibFuncInitializePtr = NULL;
pCanUsbLibFuncUninitializePtr = NULL;
pCanUsbLibFuncGetStatusPtr = NULL;
pCanUsbLibFuncSetValuePtr = NULL;
pCanUsbLibFuncReadPtr = NULL;
pCanUsbLibFuncWritePtr = NULL;
pCanUsbLibFuncFilterMessagesPtr = NULL;
/* Reset CAN interface settings. */
pCanUsbSettings.devicename = "";
pCanUsbSettings.channel = 0;
pCanUsbSettings.baudrate = CAN_BR500K;
pCanUsbSettings.code = 0x00000000u;
pCanUsbSettings.mask = 0x00000000u;
/* Check parameters. */
assert(settings != NULL);
/* Only continue with valid parameters. */
if (settings != NULL) /*lint !e774 */
{
/* Shallow copy the CAN interface settings for later usage. */
pCanUsbSettings = *settings;
/* The devicename is a pointer and it is not gauranteed that it stays valid so we need
* to deep copy this one. note the +1 for '\0' in malloc.
*/
assert(settings->devicename != NULL);
if (settings->devicename != NULL) /*lint !e774 */
{
canDeviceName = malloc(strlen(settings->devicename) + 1);
assert(canDeviceName != NULL);
if (canDeviceName != NULL) /*lint !e774 */
{
strcpy(canDeviceName, settings->devicename);
pCanUsbSettings.devicename = canDeviceName;
}
}
/* Perform initialization of PCAN-Basic API. */
PCanUsbLibLoadDll();
}
} /*** end of PCanUsbInit ***/
/************************************************************************************//**
** \brief Terminates the CAN interface.
**
****************************************************************************************/
static void PCanUsbTerminate(void)
{
/* Perform termination of PCAN-Basic API. */
PCanUsbLibUnloadDll();
/* Release memory that was allocated for storing the device name. */
if (pCanUsbSettings.devicename != NULL)
{
free((char *)pCanUsbSettings.devicename);
}
/* Reset CAN interface settings. */
pCanUsbSettings.devicename = "";
pCanUsbSettings.channel = 0;
pCanUsbSettings.baudrate = CAN_BR500K;
pCanUsbSettings.code = 0x00000000u;
pCanUsbSettings.mask = 0x00000000u;
/* Release memory that was allocated for CAN events and reset the entry count. */
if ( (pCanUsbEventsList != NULL) && (pCanUsbEventsEntries != 0) )
{
free(pCanUsbEventsList);
pCanUsbEventsEntries = 0;
}
} /*** end of PCanUsbTerminate ***/
/************************************************************************************//**
** \brief Connects the CAN interface.
** \return True if connected, false otherwise.
**
****************************************************************************************/
static bool PCanUsbConnect(void)
{
bool result = false;
bool baudrateSupported = true;
bool channelSupported;
bool libInitialized = false;
TPCANBaudrate baudrate = PCAN_BAUD_500K;
#if (PCANUSB_BUSOFF_AUTORECOVERY_ENABLE > 0)
uint32_t iBuffer;
#endif
/* Convert the baudrate to a value supported by the PCAN-Basic API. */
switch (pCanUsbSettings.baudrate)
{
case CAN_BR10K:
baudrate = PCAN_BAUD_10K;
break;
case CAN_BR20K:
baudrate = PCAN_BAUD_20K;
break;
case CAN_BR50K:
baudrate = PCAN_BAUD_50K;
break;
case CAN_BR100K:
baudrate = PCAN_BAUD_100K;
break;
case CAN_BR125K:
baudrate = PCAN_BAUD_125K;
break;
case CAN_BR250K:
baudrate = PCAN_BAUD_250K;
break;
case CAN_BR500K:
baudrate = PCAN_BAUD_500K;
break;
case CAN_BR800K:
baudrate = PCAN_BAUD_800K;
break;
case CAN_BR1M:
baudrate = PCAN_BAUD_1M;
break;
default:
baudrateSupported = false;
break;
}
/* Validate channel index. For this CAN interface, the channel index specifies the
* PCAN-USB device, in case multiple are connected.
*/
channelSupported = (pCanUsbSettings.channel < (sizeof(pCanUsbChannelLookup) /
sizeof(pCanUsbChannelLookup[0])));
/* Note that the device name itself is not needed anymore at this point, it was only
* needed by the CAN driver to link the correct interface (this one). Check settings.
*/
assert(baudrateSupported);
assert(channelSupported);
/* Invalidate handles. */
pCanUsbTerminateEvent = NULL;
pCanUsbCanEvent = NULL;
pCanUsbRxThreadHandle = NULL;
/* Only continue with valid settings. */
if ( (baudrateSupported) && (channelSupported) )
{
/* Init result code to success and only negate it on detection of error. */
result = true;
/* Connect to the CAN hardware interface. */
if (PCanUsbLibFuncInitialize(pCanUsbChannelLookup[pCanUsbSettings.channel],
baudrate, 0, 0, 0) != PCAN_ERROR_OK)
{
result = false;
}
else
{
libInitialized = true;
}
/* Create the terminate event handle used in the reception thread. */
if (result)
{
pCanUsbTerminateEvent = CreateEvent(NULL, TRUE, FALSE, "");
if (pCanUsbTerminateEvent == NULL)
{
result = false;
}
}
/* Create the CAN event handle used in the reception thread. */
if (result)
{
pCanUsbCanEvent = CreateEvent(NULL, FALSE, FALSE, "");
if (pCanUsbCanEvent == NULL)
{
result = false;
}
}
#if (PCANUSB_BUSOFF_AUTORECOVERY_ENABLE > 0)
/* Enable the bus off auto reset. */
if (result)
{
iBuffer = PCAN_PARAMETER_ON;
if (PCanUsbLibFuncSetValue(pCanUsbChannelLookup[pCanUsbSettings.channel],
PCAN_BUSOFF_AUTORESET, &iBuffer,
sizeof(iBuffer)) != PCAN_ERROR_OK)
{
result = false;
}
}
#endif
/* Configure reception acceptance filter, if it is not supposed to be fully open. */
if ( (result) && (pCanUsbSettings.mask != 0x00000000u) )
{
/* Configuration of the reception acceptance filter in the PCAN-Basic library does
* not use a mask and code approach. Instead it has an API function for setting
* the filter by specifing an identifier range. This means the mask and code pair
* should be used to calculate the lowest and highest identifier that should pass
* the filter. It is not 100% accurate. In some cases more identifiers can pass
* the filter than desired, but there is no other option:
* Lowest CAN ID = (code & mask) & 0x1fffffff
* Highest CAN ID = (code | ~mask) & 0x1fffffff
*/
uint32_t lowestCanID = (pCanUsbSettings.code & pCanUsbSettings.mask) & 0x1fffffffu;
uint32_t highestCanID = (pCanUsbSettings.code | ~pCanUsbSettings.mask) & 0x1fffffffu;
/* Use bit logic to determine if the filter should accept standard 11-bit and/or
* extended 29-bit identifiers:
* acceptStdId = ((mask & code & CAN_MSG_EXT_ID_MASK) == 0)
* acceptExtId = ((mask & code & CAN_MSG_EXT_ID_MASK) != 0) ||
* ((mask & CAN_MSG_EXT_ID_MASK) == 0)
*/
bool acceptStdID = ((pCanUsbSettings.mask & pCanUsbSettings.code & CAN_MSG_EXT_ID_MASK) == 0);
bool acceptExtID = ((pCanUsbSettings.mask & pCanUsbSettings.code & CAN_MSG_EXT_ID_MASK) != 0) ||
((pCanUsbSettings.mask & CAN_MSG_EXT_ID_MASK) == 0);
/* Configure acceptance filter for standard 11-bit identifiers. */
if (acceptStdID)
{
if (PCanUsbLibFuncFilterMessages(pCanUsbChannelLookup[pCanUsbSettings.channel],
lowestCanID, highestCanID,
PCAN_MODE_STANDARD) != PCAN_ERROR_OK)
{
result = false;
}
}
/* Configure acceptance filter for extended 29-bit identifiers. */
if ( (acceptExtID) && (result) )
{
if (PCanUsbLibFuncFilterMessages(pCanUsbChannelLookup[pCanUsbSettings.channel],
lowestCanID, highestCanID,
PCAN_MODE_EXTENDED) != PCAN_ERROR_OK)
{
result = false;
}
}
}
/* Register the event reception handle. */
if (result)
{
if (PCanUsbLibFuncSetValue(pCanUsbChannelLookup[pCanUsbSettings.channel],
PCAN_RECEIVE_EVENT, &pCanUsbCanEvent,
sizeof(pCanUsbCanEvent)) != PCAN_ERROR_OK)
{
result = false;
}
}
/* Start the reception thread as the last step. */
if (result)
{
pCanUsbRxThreadHandle = CreateThread(NULL, 0, PCanUsbReceptionThread,
NULL, 0, NULL);
if (pCanUsbRxThreadHandle == NULL)
{
result = false;
}
}
}
/* Clean-up in case an error occurred. */
if (!result)
{
if (libInitialized)
{
/* Uninitialize the library. */
(void)PCanUsbLibFuncUninitialize(pCanUsbChannelLookup[pCanUsbSettings.channel]);
}
if (pCanUsbTerminateEvent != NULL)
{
/* Close the event handle. */
(void)CloseHandle(pCanUsbTerminateEvent);
pCanUsbTerminateEvent = NULL;
}
if (pCanUsbCanEvent != NULL)
{
/* Close the event handle. */
(void)CloseHandle(pCanUsbCanEvent);
pCanUsbCanEvent = NULL;
}
}
/* Give the result back to the caller. */
return result;
} /*** end of PCanUsbConnect ***/
/************************************************************************************//**
** \brief Disconnects the CAN interface.
**
****************************************************************************************/
static void PCanUsbDisconnect(void)
{
/* Stop the reception thread. */
if (pCanUsbRxThreadHandle != NULL)
{
/* Trigger event to request the reception thread to stop. */
(void)SetEvent(pCanUsbTerminateEvent);
/* Wait for the thread to signal termination. */
(void)WaitForSingleObject(pCanUsbRxThreadHandle, INFINITE);
/* Close the thread handle. */
(void)CloseHandle(pCanUsbRxThreadHandle);
pCanUsbRxThreadHandle = NULL;
}
/* Close the terminate event handle. */
if (pCanUsbTerminateEvent != NULL)
{
(void)CloseHandle(pCanUsbTerminateEvent);
pCanUsbTerminateEvent = NULL;
}
/* Close the CAN event handle. */
if (pCanUsbCanEvent != NULL)
{
(void)CloseHandle(pCanUsbCanEvent);
pCanUsbCanEvent = NULL;
}
/* Disconnect from the CAN interface. */
(void)PCanUsbLibFuncUninitialize(pCanUsbChannelLookup[pCanUsbSettings.channel]);
} /*** end of PCanUsbDisconnect ***/
/************************************************************************************//**
** \brief Submits a message for transmission on the CAN bus.
** \param msg Pointer to CAN message structure.
** \return True if successful, false otherwise.
**
****************************************************************************************/
static bool PCanUsbTransmit(tCanMsg const * msg)
{
bool result = false;
TPCANMsg msgBuf;
tCanEvents const * pEvents;
/* Check parameters. */
assert(msg != NULL);
/* Only continue with valid parameters. */
if (msg != NULL) /*lint !e774 */
{
/* Convert the message to a type supported by the PCAN-Basic API. */
if ((msg->id & CAN_MSG_EXT_ID_MASK) == 0)
{
msgBuf.ID = msg->id & 0x7ffu;
msgBuf.MSGTYPE = PCAN_MESSAGE_STANDARD;
}
else
{
msgBuf.ID = msg->id & 0x1fffffffu;
msgBuf.MSGTYPE = PCAN_MESSAGE_EXTENDED;
}
msgBuf.LEN = ((msg->dlc <= CAN_MSG_MAX_LEN) ? msg->dlc : CAN_MSG_MAX_LEN);
for (uint8_t idx = 0; idx < msgBuf.LEN; idx++)
{
msgBuf.DATA[idx] = msg->data[idx];
}
/* Submit CAN message for transmission. */
if (PCanUsbLibFuncWrite(pCanUsbChannelLookup[pCanUsbSettings.channel],
&msgBuf) == PCAN_ERROR_OK)
{
/* Update result value to success. */
result = true;
/* Trigger transmit complete event(s). */
pEvents = pCanUsbEventsList;
for (uint32_t idx = 0; idx < pCanUsbEventsEntries; idx++)
{
if (pEvents != NULL)
{
if (pEvents->MsgTxed != NULL)
{
pEvents->MsgTxed(msg);
}
/* Move on to the next entry in the list. */
pEvents++;
}
}
}
}
/* Give the result back to the caller. */
return result;
} /*** end of PCanUsbTransmit ***/
/************************************************************************************//**
** \brief Checks if a bus off or bus heavy situation occurred.
** \return True if a bus error situation was detected, false otherwise.
**
****************************************************************************************/
static bool PCanUsbIsBusError(void)
{
bool result = false;
TPCANStatus status;
/* Obtain the status information. */
status = PCanUsbLibFuncGetStatus(pCanUsbChannelLookup[pCanUsbSettings.channel]);
/* Process the status to detect bus off or bus heavy. */
if ((status == PCAN_ERROR_BUSOFF) || (status == PCAN_ERROR_BUSHEAVY))
{
result = true;
}
/* Give the result back to the caller. */
return result;
} /*** end of PCanUsbIsBusError ***/
/************************************************************************************//**
** \brief Registers the event callback functions that should be called by the CAN
** interface.
** \param events Pointer to structure with event callback function pointers.
**
****************************************************************************************/
static void PCanUsbRegisterEvents(tCanEvents const * events)
{
/* Check parameters. */
assert(events != NULL);
/* Only continue with valid parameters. */
if (events != NULL) /*lint !e774 */
{
/* Increase length of the list to make space for one more event entry. Note that
* it is okay to call realloc with a NULL pointer. In this case it simply behaves
* as malloc.
*/
pCanUsbEventsList = realloc(pCanUsbEventsList,
(sizeof(tCanEvents) * (pCanUsbEventsEntries + 1)));
/* Assert reallocation. */
assert(pCanUsbEventsList != NULL);
/* Only continue if reallocation was successful. */
if (pCanUsbEventsList != NULL)
{
/* Increment events entry count. */
pCanUsbEventsEntries++;
/* Store the events in the new entry. */
pCanUsbEventsList[pCanUsbEventsEntries - 1] = *events;
}
/* Reallocation failed. */
else
{
/* Reset events entry count. */
pCanUsbEventsEntries = 0;
}
}
} /*** end of PCanUsbRegisterEvents ***/
/************************************************************************************//**
** \brief CAN message reception thread.
** \param pv Pointer to thread parameters.
** \return Thread exit code.
**
****************************************************************************************/
static DWORD WINAPI PCanUsbReceptionThread(LPVOID pv)
{
DWORD waitResult;
HANDLE handles[] =
{
pCanUsbCanEvent,
pCanUsbTerminateEvent
};
bool running = true;
TPCANMsg rxLibMsg;
tCanMsg rxMsg;
tCanEvents const * pEvents;
/* Parameter not used. */
(void)pv;
/* Enter thread's infinite loop. */
while (running)
{
waitResult = WaitForMultipleObjects(sizeof(handles)/sizeof(handles[0]), handles,
FALSE, INFINITE);
switch (waitResult)
{
/* CAN reception event. */
case WAIT_OBJECT_0 + 0: /*lint !e835 */
/* Empty out the queue with received events. */
while (PCanUsbLibFuncRead(pCanUsbChannelLookup[pCanUsbSettings.channel],
&rxLibMsg, NULL) == PCAN_ERROR_OK)
{
/* Only process events that contain a CAN message with a 11-bit or 29-bit
* identifier.
*/
if ((rxLibMsg.MSGTYPE == PCAN_MESSAGE_STANDARD) ||
(rxLibMsg.MSGTYPE == PCAN_MESSAGE_EXTENDED))
{
/* Convert CAN mesage from PCAN-Basic format to the one of the CAN driver
* module.
*/
rxMsg.id = rxLibMsg.ID;
if (rxLibMsg.MSGTYPE == PCAN_MESSAGE_EXTENDED)
{
rxMsg.id |= CAN_MSG_EXT_ID_MASK;
}
rxMsg.dlc = rxLibMsg.LEN;
for (uint8_t idx = 0; idx < rxMsg.dlc; idx++)
{
rxMsg.data[idx] = rxLibMsg.DATA[idx];
}
/* Trigger message reception event(s). */
pEvents = pCanUsbEventsList;
for (uint32_t idx = 0; idx < pCanUsbEventsEntries; idx++)
{
if (pEvents != NULL)
{
if (pEvents->MsgRxed != NULL)
{
pEvents->MsgRxed(&rxMsg);
}
/* Move on to the next entry in the list. */
pEvents++;
}
}
}
}
break;
/* Termination event. */
default:
case WAIT_OBJECT_0 + 1: /*lint !e835 */
/* Stop thread. */
running = false;
break;
}
}
/* Exit thread. */
return 0;
} /*** end of PCanUsbReceptionThread ***/
/************************************************************************************//**
** \brief Loads the PCAN-Basic DLL and initializes the API function pointers.
**
****************************************************************************************/
static void PCanUsbLibLoadDll(void)
{
/* Start out by resetting the API function pointers. */
pCanUsbLibFuncInitializePtr = NULL;
pCanUsbLibFuncUninitializePtr = NULL;
pCanUsbLibFuncGetStatusPtr = NULL;
pCanUsbLibFuncSetValuePtr = NULL;
pCanUsbLibFuncReadPtr = NULL;
pCanUsbLibFuncWritePtr = NULL;
pCanUsbLibFuncFilterMessagesPtr = NULL;
/* Attempt to load the library and obtain a handle to it. */
pCanUsbDllHandle = LoadLibrary("PCANBasic");
/* Assert libary handle. */
assert(pCanUsbDllHandle != NULL);
/* Only continue if the library was successfully loaded */
if (pCanUsbDllHandle != NULL) /*lint !e774 */
{
/* Set CAN_Initialize function pointer. */
pCanUsbLibFuncInitializePtr = (tPCanUsbLibFuncInitialize)GetProcAddress(pCanUsbDllHandle, "CAN_Initialize");
/* Set CAN_Uninitialize function pointer. */
pCanUsbLibFuncUninitializePtr = (tPCanUsbLibFuncUninitialize)GetProcAddress(pCanUsbDllHandle, "CAN_Uninitialize");
/* Set CAN_GetStatus function pointer. */
pCanUsbLibFuncGetStatusPtr = (tPCanUsbLibFuncGetStatus)GetProcAddress(pCanUsbDllHandle, "CAN_GetStatus");
/* Set CAN_SetValue function pointer. */
pCanUsbLibFuncSetValuePtr = (tPCanUsbLibFuncSetValue)GetProcAddress(pCanUsbDllHandle, "CAN_SetValue");
/* Set CAN_Read function pointer. */
pCanUsbLibFuncReadPtr = (tPCanUsbLibFuncRead)GetProcAddress(pCanUsbDllHandle, "CAN_Read");
/* Set CAN_Write function pointer. */
pCanUsbLibFuncWritePtr = (tPCanUsbLibFuncWrite)GetProcAddress(pCanUsbDllHandle, "CAN_Write");
/* Set CAN_FilterMessages function pointer. */
pCanUsbLibFuncFilterMessagesPtr = (tPCanUsbLibFuncFilterMessages)GetProcAddress(pCanUsbDllHandle, "CAN_FilterMessages");
}
} /*** end of PCanUsbLibLoadDll ***/
/************************************************************************************//**
** \brief Unloads the PCAN-Basic DLL and resets the API function pointers.
**
****************************************************************************************/
static void PCanUsbLibUnloadDll(void)
{
/* Reset the API function pointers. */
pCanUsbLibFuncInitializePtr = NULL;
pCanUsbLibFuncUninitializePtr = NULL;
pCanUsbLibFuncGetStatusPtr = NULL;
pCanUsbLibFuncSetValuePtr = NULL;
pCanUsbLibFuncReadPtr = NULL;
pCanUsbLibFuncWritePtr = NULL;
pCanUsbLibFuncFilterMessagesPtr = NULL;
/* Unload the library and invalidate its handle. */
if (pCanUsbDllHandle != NULL)
{
(void)FreeLibrary(pCanUsbDllHandle);
pCanUsbDllHandle = NULL;
}
} /*** end of PCanUsbLibUnloadDll ***/
/************************************************************************************//**
** \brief Initializes a PCAN Channel.
** \param Channel The handle of a PCAN Channel.
** \param Btr0Btr1 The speed for the communication (BTR0BTR1 code).
** \param HwType The type of the Non-Plug-and-Play hardware and its operation mode.
** \param IOPort The I/O address for the parallel port of the Non-Plug-and-Play
** hardware.
** \param Interrupt The Interrupt number of the parallel port of the Non-Plug-
** and-Play hardware.
** \return The return value is a TPCANStatus code. PCAN_ERROR_OK is returned on
** success.
**
****************************************************************************************/
static TPCANStatus PCanUsbLibFuncInitialize(TPCANHandle Channel, TPCANBaudrate Btr0Btr1,
TPCANType HwType, DWORD IOPort,
WORD Interrupt)
{
/* set result to error. */
TPCANStatus result = PCAN_ERROR_INITIALIZE;
/* Check function pointer and library handle. */
assert(pCanUsbLibFuncInitializePtr != NULL);
assert(pCanUsbDllHandle != NULL);
/* Only continue with valid function pointer and library handle. */
if ((pCanUsbLibFuncInitializePtr != NULL) && (pCanUsbDllHandle != NULL)) /*lint !e774 */
{
/* Call library function. */
result = pCanUsbLibFuncInitializePtr(Channel, Btr0Btr1, HwType, IOPort, Interrupt);
}
/* Give the result back to the caller. */
return result;
} /*** end of PCanUsbLibFuncInitialize ***/
/************************************************************************************//**
** \brief Uninitializes a PCAN Channel.
** \param Channel The handle of a PCAN Channel.
** \return The return value is a TPCANStatus code. PCAN_ERROR_OK is returned on
** success.
**
****************************************************************************************/
static TPCANStatus PCanUsbLibFuncUninitialize(TPCANHandle Channel)
{
/* set result to error. */
TPCANStatus result = PCAN_ERROR_INITIALIZE;
/* Check function pointer and library handle. */
assert(pCanUsbLibFuncUninitializePtr != NULL);
assert(pCanUsbDllHandle != NULL);
/* Only continue with valid function pointer and library handle. */
if ((pCanUsbLibFuncUninitializePtr != NULL) && (pCanUsbDllHandle != NULL)) /*lint !e774 */
{
/* Call library function. */
result = pCanUsbLibFuncUninitializePtr(Channel);
}
/* Give the result back to the caller. */
return result;
} /*** end of PCanUsbLibFuncUninitialize ***/
/************************************************************************************//**
** \brief Gets the current BUS status of a PCAN Channel.
** \param Channel The handle of a PCAN Channel.
** \return The return value is a TPCANStatus code. PCAN_ERROR_OK is returned on
** success.
**
****************************************************************************************/
static TPCANStatus PCanUsbLibFuncGetStatus(TPCANHandle Channel)
{
/* set result to error. */
TPCANStatus result = PCAN_ERROR_INITIALIZE;
/* Check function pointer and library handle. */
assert(pCanUsbLibFuncGetStatusPtr != NULL);
assert(pCanUsbDllHandle != NULL);
/* Only continue with valid function pointer and library handle. */
if ((pCanUsbLibFuncGetStatusPtr != NULL) && (pCanUsbDllHandle != NULL)) /*lint !e774 */
{
/* Call library function. */
result = pCanUsbLibFuncGetStatusPtr(Channel);
}
/* Give the result back to the caller. */
return result;
} /*** end of PCanUsbLibFuncGetStatus ***/
/************************************************************************************//**
** \brief Sets a configuration or information value within a PCAN Channel.
** \param Channel The handle of a PCAN Channel.
** \param Parameter The code of the value to be set .
** \param Buffer The buffer containing the value to be set.
** \param BufferLength The length in bytes of the given buffer.
** \return The return value is a TPCANStatus code. PCAN_ERROR_OK is returned on
** success.
**
****************************************************************************************/
static TPCANStatus PCanUsbLibFuncSetValue(TPCANHandle Channel, TPCANParameter Parameter,
void * Buffer, DWORD BufferLength)
{
/* set result to error. */
TPCANStatus result = PCAN_ERROR_INITIALIZE;
/* Check function pointer and library handle. */
assert(pCanUsbLibFuncSetValuePtr != NULL);
assert(pCanUsbDllHandle != NULL);
/* Only continue with valid function pointer and library handle. */
if ((pCanUsbLibFuncSetValuePtr != NULL) && (pCanUsbDllHandle != NULL)) /*lint !e774 */
{
/* Call library function. */
result = pCanUsbLibFuncSetValuePtr(Channel, Parameter, Buffer, BufferLength);
}
/* Give the result back to the caller. */
return result;
} /*** end of PCanUsbLibFuncSetValue ***/
/************************************************************************************//**
** \brief Reads a CAN message from the receive queue of a PCAN Channel.
** \param Channel The handle of a PCAN Channel.
** \param MessageBuffer A TPCANMsg buffer to store the CAN message.
** \param TimestampBuffer A TPCANTimestamp buffer to get the reception time of the
** message.
** \return The return value is a TPCANStatus code. PCAN_ERROR_OK is returned on
** success.
**
****************************************************************************************/
static TPCANStatus PCanUsbLibFuncRead(TPCANHandle Channel, TPCANMsg * MessageBuffer,
TPCANTimestamp * TimestampBuffer)
{
/* set result to error. */
TPCANStatus result = PCAN_ERROR_INITIALIZE;
/* Check function pointer and library handle. */
assert(pCanUsbLibFuncReadPtr != NULL);
assert(pCanUsbDllHandle != NULL);
/* Only continue with valid function pointer and library handle. */
if ((pCanUsbLibFuncReadPtr != NULL) && (pCanUsbDllHandle != NULL)) /*lint !e774 */
{
/* Call library function. */
result = pCanUsbLibFuncReadPtr(Channel, MessageBuffer, TimestampBuffer);
}
/* Give the result back to the caller. */
return result;
} /*** end of PCanUsbLibFuncRead ***/
/************************************************************************************//**
** \brief Transmits a CAN message.
** \param Channel The handle of a PCAN Channel.
** \param MessageBuffer A TPCANMsg buffer containing the CAN message to be sent.
** \return The return value is a TPCANStatus code. PCAN_ERROR_OK is returned on
** success.
**
****************************************************************************************/
static TPCANStatus PCanUsbLibFuncWrite(TPCANHandle Channel, TPCANMsg * MessageBuffer)
{
/* set result to error. */
TPCANStatus result = PCAN_ERROR_INITIALIZE;
/* Check function pointer and library handle. */
assert(pCanUsbLibFuncWritePtr != NULL);
assert(pCanUsbDllHandle != NULL);
/* Only continue with valid function pointer and library handle. */
if ((pCanUsbLibFuncWritePtr != NULL) && (pCanUsbDllHandle != NULL)) /*lint !e774 */
{
/* Call library function. */
result = pCanUsbLibFuncWritePtr(Channel, MessageBuffer);
}
/* Give the result back to the caller. */
return result;
} /*** end of PCanUsbLibFuncWrite ***/
/************************************************************************************//**
** \brief Configures the reception filter.
** \param Channel The handle of a PCAN Channel.
** \param FromID The lowest CAN ID wanted to be received.
** \param ToID The highest CAN ID wanted to be received.
** \param Mode The type of the filter being set.
** \return The return value is a TPCANStatus code. PCAN_ERROR_OK is returned on
** success.
**
****************************************************************************************/
static TPCANStatus PCanUsbLibFuncFilterMessages(TPCANHandle Channel, DWORD FromID,
DWORD ToID, TPCANMode Mode)
{
/* set result to error. */
TPCANStatus result = PCAN_ERROR_INITIALIZE;
/* Check function pointer and library handle. */
assert(pCanUsbLibFuncFilterMessagesPtr != NULL);
assert(pCanUsbDllHandle != NULL);
/* Only continue with valid function pointer and library handle. */
if ((pCanUsbLibFuncFilterMessagesPtr != NULL) && (pCanUsbDllHandle != NULL)) /*lint !e774 */
{
/* Call library function. */
result = pCanUsbLibFuncFilterMessagesPtr(Channel, FromID, ToID, Mode);
}
/* Give the result back to the caller. */
return result;
} /*** end of PCanUsbLibFuncFilterMessages ***/
/*********************************** end of pcanusb.c **********************************/
Reference in New Issue View Git Blame Copy Permalink