Mutual exclusion

To access system data structures with mutual exclusion support, the XCP driver depends on basic APIs for definition, initialization, lock, and unlock.

To support mutual exclusion for your target hardware, provide a custom implementation.

The default implementation for Linux and Windows supports mutual exclusion.

#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
...
#define XCP_MUTEX_DEFINE(lock) HANDLE lock
#define XCP_MUTEX_INIT(lock) lock = CreateMutex(0, FALSE, 0)
#define XCP_MUTEX_LOCK(lock) WaitForSingleObject((lock), INFINITE)
#define XCP_MUTEX_UNLOCK(lock) ReleaseMutex(lock)

#else 
...
#include <pthread.h>
#define XCP_MUTEX_DEFINE(lock) pthread_mutex_t lock
#define XCP_MUTEX_INIT(lock) pthread_mutex_init(&(lock), NULL)
#define XCP_MUTEX_LOCK(lock) pthread_mutex_lock(&(lock))
#define XCP_MUTEX_UNLOCK(lock) pthread_mutex_unlock(&(lock))
...
#endif

Provide a sleep API that makes the calling thread sleep until a specified time has elapsed. The default implementation for Linux and Windows systems is:

#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
...
#define XCP_SLEEP(seconds,microseconds)  Sleep((seconds) * 1000 \  
+ (((microseconds) + 1000 - 1) / 1000))

#else 
...
#if _POSIX_C_SOURCE >= 199309L
#define XCP_SLEEP(seconds,microseconds)  do {struct timespec t;\
 t.tv_sec = seconds; t.tv_nsec = microseconds * 1000; nanosleep(&t, NULL);} while(0)
#else
/* nanosleep is not available. Use select instead. */
#define XCP_SLEEP(seconds,microseconds)  do {struct timeval t; t.tv_sec = seconds;\
 t.tv_usec = microseconds; select(0, NULL, NULL, NULL, &t);} while(0)
#endif /* _POSIX_C_SOURCE >= 199309L */
...
#endif

Logging

To generate diagnostic messages, the XCP server software requires a custom print API that supports logging services provided by the target hardware. If you do not define the XCP_PRINTF preprocessor macro, the default implementation is empty.

Address conversion

The XCP standard expresses the address of a variable in memory as a 32-bit address with an 8-bit extension.

The XCP client extracts the addresses of signals and parameters of the model by parsing the debug information that the build process creates. The debug information is in DWARF or PDB format.

The XCP client requests access to parameters and signals by sending an XCP command that contains the arguments addressExtension and address.

When addressExtension and address information is received by the target hardware, the XCP server must convert the address to the location of the variable in the target hardware memory. The variable location is assigned by the loader and is target-specific.

Use the XCP_ADDRESS_GET() macro to specify the conversion logic. The default implementation for Linux and Windows systems is:

#if defined(__MINGW32__) || defined(__MINGW64__)
#define XCP_ADDRESS_GET(addressExtension, address) \ 
(uint8_T*) ((uintptr_t) address)
#else
#define XCP_ADDRESS_GET(addressExtension, address) \ 
(uint8_T*) ((address) + (uint8_T*)&__ImageBase)
#endif

Set and copy memory

You can specify an optimized version of copy memory and set memory operations.

If you do not define the XCP_MEMCPY and XCP_MEMSET preprocessor macros, the default implementation specifies the standard C functions, memcpy and memset.

#ifndef XCP_MEMCPY
#define XCP_MEMCPY memcpy
#endif

#ifndef XCP_MEMSET
#define XCP_MEMSET memset
#endif

Parsing command-line arguments

If your target hardware does not support the parsing of command-line arguments, define the preprocessor macro EXTMODE_DISABLE_ARGS_PROCESSING.

To replace the -w option, you can use this command to specify that the target application enters and stays in a wait state until it receives a Connect message from Simulink:

set_param(modelName, 'OnTargetWaitForStart', 'on');

Structure packing and alignment

The XCP software stack implementation requires the packing and alignment of some internal C structures. In the platform abstraction layer, provide packing and alignment information by using preprocessor directives that are compiler-specific.

To pack and align C structures, provide these preprocessor directives:

#define XCP_PRAGMA_PACK_BEGIN(n)
#define XCP_PRAGMA_PACK_END()
#define XCP_ATTRIBUTE_ALIGNED(n)
#define XCP_ATTRIBUTE_PACKED

XCP_PRAGMA_PACK_BEGIN(1)
typedef struct XCP_ATTRIBUTE_PACKED XcpSetDaqListModeCmdPacketFrame {
    uint8_T    PID;       /* Packet identifier, always XCP_PID_SET_DAQ_LIST_MODE */
    uint8_T    mode;      /* DAQ list mode (XCP DAQ Mode bit masks) */
    uint16_T   daqListId; /* DAQ list Id */
    uint16_T   eventId;   /* Event Channel Id */
    uint8_T    prescaler; /* Transmission rate prescaler */
    uint8_T    priority;  /* DAQ list priority (0xFF -> highest) */
}   XcpSetDaqListModeCmdPacketFrame;
XCP_PRAGMA_PACK_END()

XCP_PRAGMA_PACK_BEGIN(XCP_MEM_ALIGNMENT)
struct XCP_ATTRIBUTE_ALIGNED(XCP_MEM_ALIGNMENT) xcpFifoEntry {
    struct xcpFifoEntry *next;
    size_t msgFrameSize;    /* in AG units */
};
XCP_PRAGMA_PACK_END()

For a GCC compiler, use these directives:

#define XCP_PRAGMA_PACK_BEGIN(n)
#define XCP_PRAGMA_PACK_END()
#define XCP_ATTRIBUTE_ALIGNED(n)  __attribute__((aligned(n)))
#define XCP_ATTRIBUTE_PACKED      __attribute__((packed))

For a Microsoft^® Visual C++^® compiler, use these directives:

#define PRAGMA(n)   _Pragma(#n)
#define XCP_PRAGMA_PACK_BEGIN(n)  PRAGMA(pack(push, n))
#define XCP_PRAGMA_PACK_END()     PRAGMA(pack(pop))
#define XCP_ATTRIBUTE_ALIGNED(n)
#define XCP_ATTRIBUTE_PACKED