Documentation

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 slave 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 Master 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 Master 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 Slave 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');