You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
701 lines
25 KiB
701 lines
25 KiB
|
|
/begin A2ML
|
|
|
|
|
|
/*********************************************************/
|
|
/* Definitions for XCP */
|
|
/*********************************************************/
|
|
|
|
struct Protocol_Layer {
|
|
uint; /* XCP protocol layer version, current 0x100 */
|
|
uint; /* T1 [ms] */
|
|
uint; /* T2 [ms] */
|
|
uint; /* T3 [ms] */
|
|
uint; /* T4 [ms] */
|
|
uint; /* T5 [ms] */
|
|
uint; /* T6 [ms] */
|
|
uint; /* T7 [ms] */
|
|
uchar; /* MAX_CTO */
|
|
uint; /* MAX_DTO */
|
|
enum {
|
|
"BYTE_ORDER_MSB_LAST" = 0,
|
|
"BYTE_ORDER_MSB_FIRST" = 1
|
|
};
|
|
enum {
|
|
"ADDRESS_GRANULARITY_BYTE" = 1,
|
|
"ADDRESS_GRANULARITY_WORD" = 2,
|
|
"ADDRESS_GRANULARITY_DWORD" = 4
|
|
};
|
|
taggedstruct {
|
|
("OPTIONAL_CMD" enum { /* XCP-Code of optional command supported by the slave */
|
|
"GET_COMM_MODE_INFO" = 0xFB,
|
|
"GET_ID" = 0xFA,
|
|
"SET_REQUEST" = 0xF9,
|
|
"GET_SEED" = 0xF8,
|
|
"UNLOCK" = 0xF7,
|
|
"SET_MTA" = 0xF6,
|
|
"UPLOAD" = 0xF5,
|
|
"SHORT_UPLOAD" = 0xF4,
|
|
"BUILD_CHECKSUM" = 0xF3,
|
|
"TRANSPORT_LAYER_CMD" = 0xF2,
|
|
"USER_CMD" = 0xF1,
|
|
"DOWNLOAD" = 0xF0,
|
|
"DOWNLOAD_NEXT" = 0xEF,
|
|
"DOWNLOAD_MAX" = 0xEE,
|
|
"SHORT_DOWNLOAD" = 0xED,
|
|
"MODIFY_BITS" = 0xEC,
|
|
"SET_CAL_PAGE" = 0xEB,
|
|
"GET_CAL_PAGE" = 0xEA,
|
|
"GET_PAG_PROCESSOR_INFO" = 0xE9,
|
|
"GET_SEGMENT_INFO" = 0xE8,
|
|
"GET_PAGE_INFO" = 0xE7,
|
|
"SET_SEGMENT_MODE" = 0xE6,
|
|
"GET_SEGMENT_MODE" = 0xE5,
|
|
"COPY_CAL_PAGE" = 0xE4,
|
|
"CLEAR_DAQ_LIST" = 0xE3,
|
|
"SET_DAQ_PTR" = 0xE2,
|
|
"WRITE_DAQ" = 0xE1,
|
|
"SET_DAQ_LIST_MODE" = 0xE0,
|
|
"GET_DAQ_LIST_MODE" = 0xDF,
|
|
"START_STOP_DAQ_LIST" = 0xDE,
|
|
"START_STOP_SYNCH" = 0xDD,
|
|
"GET_DAQ_CLOCK" = 0xDC,
|
|
"READ_DAQ" = 0xDB,
|
|
"GET_DAQ_PROCESSOR_INFO" = 0xDA,
|
|
"GET_DAQ_RESOLUTION_INFO" = 0xD9,
|
|
"GET_DAQ_LIST_INFO" = 0xD8,
|
|
"GET_DAQ_EVENT_INFO" = 0xD7,
|
|
"FREE_DAQ" = 0xD6,
|
|
"ALLOC_DAQ" = 0xD5,
|
|
"ALLOC_ODT" = 0xD4,
|
|
"ALLOC_ODT_ENTRY" = 0xD3,
|
|
"PROGRAM_START" = 0xD2,
|
|
"PROGRAM_CLEAR" = 0xD1,
|
|
"PROGRAM" = 0xD0,
|
|
"PROGRAM_RESET" = 0xCF,
|
|
"GET_PGM_PROCESSOR_INFO" = 0xCE,
|
|
"GET_SECTOR_INFO" = 0xCD,
|
|
"PROGRAM_PREPARE" = 0xCC,
|
|
"PROGRAM_FORMAT" = 0xCB,
|
|
"PROGRAM_NEXT" = 0xCA,
|
|
"PROGRAM_MAX" = 0xC9,
|
|
"PROGRAM_VERIFY" = 0xC8
|
|
})*;
|
|
"COMMUNICATION_MODE_SUPPORTED" taggedunion {
|
|
"BLOCK" taggedstruct {
|
|
"SLAVE";
|
|
"MASTER" struct {
|
|
uchar; /* MAX_BS */
|
|
uchar; /* MIN_ST */
|
|
};
|
|
};
|
|
"INTERLEAVED" uchar; /* QUEUE_SIZE */
|
|
};
|
|
"SEED_AND_KEY_EXTERNAL_FUNCTION" char[256]; /* Name of the Seed&Key function */
|
|
};
|
|
};
|
|
|
|
struct Daq {
|
|
enum { /* DAQ_CONFIG_TYPE */
|
|
"STATIC" = 0,
|
|
"DYNAMIC" = 1
|
|
};
|
|
uint; /* MAX_DAQ */
|
|
uint; /* MAX_EVENT_CHANNEL */
|
|
uchar; /* MIN_DAQ */
|
|
enum {
|
|
"OPTIMISATION_TYPE_DEFAULT" = 0,
|
|
"OPTIMISATION_TYPE_ODT_TYPE_16" = 1,
|
|
"OPTIMISATION_TYPE_ODT_TYPE_32" = 2,
|
|
"OPTIMISATION_TYPE_ODT_TYPE_64" = 3,
|
|
"OPTIMISATION_TYPE_ODT_TYPE_ALIGNMENT" = 4,
|
|
"OPTIMISATION_TYPE_MAX_ENTRY_SIZE" = 5
|
|
};
|
|
enum {
|
|
"ADDRESS_EXTENSION_FREE" = 0,
|
|
"ADDRESS_EXTENSION_ODT" = 1,
|
|
"ADDRESS_EXTENSION_DAQ" = 3
|
|
};
|
|
enum {
|
|
"IDENTIFICATION_FIELD_TYPE_ABSOLUTE" = 0,
|
|
"IDENTIFICATION_FIELD_TYPE_RELATIVE_BYTE" = 1,
|
|
"IDENTIFICATION_FIELD_TYPE_RELATIVE_WORD" = 2,
|
|
"IDENTIFICATION_FIELD_TYPE_RELATIVE_WORD_ALIGNED" = 3
|
|
};
|
|
enum {
|
|
"GRANULARITY_ODT_ENTRY_SIZE_DAQ_BYTE" = 1,
|
|
"GRANULARITY_ODT_ENTRY_SIZE_DAQ_WORD" = 2,
|
|
"GRANULARITY_ODT_ENTRY_SIZE_DAQ_DWORD" = 4,
|
|
"GRANULARITY_ODT_ENTRY_SIZE_DAQ_DLONG" = 8
|
|
};
|
|
uchar; /* MAX_ODT_ENTRY_SIZE_DAQ */
|
|
enum {
|
|
"NO_OVERLOAD_INDICATION" = 0,
|
|
"OVERLOAD_INDICATION_PID" = 1,
|
|
"OVERLOAD_INDICATION_EVENT" = 2
|
|
};
|
|
taggedstruct {
|
|
"PRESCALER_SUPPORTED";
|
|
"RESUME_SUPPORTED";
|
|
block "STIM" struct {
|
|
enum {
|
|
"GRANULARITY_ODT_ENTRY_SIZE_STIM_BYTE" = 1,
|
|
"GRANULARITY_ODT_ENTRY_SIZE_STIM_WORD" = 2,
|
|
"GRANULARITY_ODT_ENTRY_SIZE_STIM_DWORD" = 4,
|
|
"GRANULARITY_ODT_ENTRY_SIZE_STIM_DLONG" = 8
|
|
};
|
|
uchar; /* MAX_ODT_ENTRY_SIZE_STIM */
|
|
taggedstruct {
|
|
"BIT_STIM_SUPPORTED";
|
|
};
|
|
};
|
|
block "TIMESTAMP_SUPPORTED" struct {
|
|
uint; /* TIMESTAMP_TICKS */
|
|
enum {
|
|
"NO_TIME_STAMP" = 0,
|
|
"SIZE_BYTE" = 1,
|
|
"SIZE_WORD" = 2,
|
|
"SIZE_DWORD" = 4
|
|
};
|
|
enum {
|
|
"UNIT_1NS" = 0,
|
|
"UNIT_10NS" = 1,
|
|
"UNIT_100NS" = 2,
|
|
"UNIT_1US" = 3,
|
|
"UNIT_10US" = 4,
|
|
"UNIT_100US" = 5,
|
|
"UNIT_1MS" = 6,
|
|
"UNIT_10MS" = 7,
|
|
"UNIT_100MS" = 8,
|
|
"UNIT_1S" = 9
|
|
};
|
|
taggedstruct {
|
|
"TIMESTAMP_FIXED";
|
|
};
|
|
};
|
|
"PID_OFF_SUPPORTED";
|
|
(block "DAQ_LIST" struct {
|
|
uint; /* DAQ_LIST_NUMBER */
|
|
taggedstruct {
|
|
"DAQ_LIST_TYPE" enum {
|
|
"DAQ" = 1, /* DIRECTION = DAQ only */
|
|
"STIM" = 2, /* DIRECTION = STIM only */
|
|
"DAQ_STIM" = 3 /* both directions possible */
|
|
};
|
|
"MAX_ODT" uchar;
|
|
"MAX_ODT_ENTRIES" uchar;
|
|
"FIRST_PID" uchar;
|
|
"EVENT_FIXED" uint;
|
|
block "PREDEFINED" taggedstruct {
|
|
(block "ODT" struct {
|
|
uchar; /* ODT number */
|
|
taggedstruct {
|
|
("ODT_ENTRY" struct {
|
|
uchar; /* ODT_ENTRY number */
|
|
ulong; /* address of element */
|
|
uchar; /* address extension of element */
|
|
uchar; /* size of element [AG] */
|
|
uchar; /* BIT_OFFSET */
|
|
})*;
|
|
};
|
|
})*;
|
|
};
|
|
};
|
|
})*;
|
|
(block "EVENT" struct {
|
|
char[101]; /* EVENT_CHANNEL_NAME */
|
|
char[9]; /* EVENT_CHANNEL_SHORT_NAME */
|
|
uint; /* EVENT_CHANNEL_NUMBER */
|
|
enum {
|
|
"DAQ" = 1, /* only DAQ_LISTs with DIRECTION = DAQ */
|
|
"STIM" = 2, /* only DAQ_LISTs with DIRECTION = STIM */
|
|
"DAQ_STIM" = 3 /* both kind of DAQ_LISTs */
|
|
};
|
|
uchar; /* MAX_DAQ_LIST */
|
|
uchar; /* TIME_CYCLE */
|
|
uchar; /* TIME_UNIT */
|
|
uchar; /* PRIORITY */
|
|
})*;
|
|
};
|
|
};
|
|
|
|
taggedunion Daq_Event { /* for MEASUREMENTs */
|
|
"FIXED_EVENT_LIST" taggedstruct {
|
|
("EVENT" uint)*;
|
|
};
|
|
"VARIABLE" taggedstruct {
|
|
block "AVAILABLE_EVENT_LIST" taggedstruct {
|
|
("EVENT" uint)*;
|
|
};
|
|
block "DEFAULT_EVENT_LIST" taggedstruct {
|
|
("EVENT" uint)*;
|
|
};
|
|
};
|
|
};
|
|
|
|
struct Pag {
|
|
uchar; /* MAX_SEGMENTS */
|
|
taggedstruct {
|
|
"FREEZE_SUPPORTED";
|
|
};
|
|
};
|
|
struct Pgm {
|
|
enum {
|
|
"PGM_MODE_ABSOLUTE" = 1,
|
|
"PGM_MODE_FUNCTIONAL" = 2,
|
|
"PGM_MODE_ABSOLUTE_AND_FUNCTIONAL" = 3
|
|
};
|
|
uchar; /* MAX_SECTORS */
|
|
uchar; /* MAX_CTO_PGM */
|
|
taggedstruct {
|
|
(block "SECTOR" struct {
|
|
char[101]; /* SECTOR_NAME */
|
|
uchar; /* SECTOR_NUMBER */
|
|
ulong; /* Address */
|
|
ulong; /* Length */
|
|
uchar; /* CLEAR_SEQUENCE_NUMBER */
|
|
uchar; /* PROGRAM_SEQUENCE_NUMBER */
|
|
uchar; /* PROGRAM_METHOD */
|
|
})*;
|
|
"COMMUNICATION_MODE_SUPPORTED" taggedunion {
|
|
"BLOCK" taggedstruct {
|
|
"SLAVE";
|
|
"MASTER" struct {
|
|
uchar; /* MAX_BS_PGM */
|
|
uchar; /* MIN_ST_PGM */
|
|
};
|
|
};
|
|
"INTERLEAVED" uchar; /* QUEUE_SIZE_PGM */
|
|
};
|
|
};
|
|
};
|
|
|
|
struct Segment { /* for MEMORY_SEGMENT */
|
|
uchar; /* SEGMENT_NUMBER */
|
|
uchar; /* number of pages */
|
|
uchar; /* ADDRESS_EXTENSION */
|
|
uchar; /* COMPRESSION_METHOD */
|
|
uchar; /* ENCRYPTION_METHOD */
|
|
taggedstruct {
|
|
block "CHECKSUM" struct {
|
|
enum {
|
|
"XCP_ADD_11" = 1,
|
|
"XCP_ADD_12" = 2,
|
|
"XCP_ADD_14" = 3,
|
|
"XCP_ADD_22" = 4,
|
|
"XCP_ADD_24" = 5,
|
|
"XCP_ADD_44" = 6,
|
|
"XCP_CRC_16" = 7,
|
|
"XCP_CRC_16_CITT" = 8,
|
|
"XCP_CRC_32" = 9,
|
|
"XCP_USER_DEFINED" = 255
|
|
};
|
|
taggedstruct {
|
|
"MAX_BLOCK_SIZE" ulong ;
|
|
"EXTERNAL_FUNCTION" char[256]; /* Name of the Checksum.DLL */
|
|
};
|
|
};
|
|
(block "PAGE" struct { /* PAGES for this SEGMENT */
|
|
uchar; /* PAGE_NUMBER */
|
|
enum {
|
|
"ECU_ACCESS_NOT_ALLOWED" = 0,
|
|
"ECU_ACCESS_WITHOUT_XCP_ONLY" = 1,
|
|
"ECU_ACCESS_WITH_XCP_ONLY" = 2,
|
|
"ECU_ACCESS_DONT_CARE" = 3
|
|
};
|
|
enum {
|
|
"XCP_READ_ACCESS_NOT_ALLOWED" = 0,
|
|
"XCP_READ_ACCESS_WITHOUT_ECU_ONLY" = 1,
|
|
"XCP_READ_ACCESS_WITH_ECU_ONLY" = 2,
|
|
"XCP_READ_ACCESS_DONT_CARE" = 3
|
|
};
|
|
enum {
|
|
"XCP_WRITE_ACCESS_NOT_ALLOWED" = 0,
|
|
"XCP_WRITE_ACCESS_WITHOUT_ECU_ONLY" = 1,
|
|
"XCP_WRITE_ACCESS_WITH_ECU_ONLY" = 2,
|
|
"XCP_WRITE_ACCESS_DONT_CARE" = 3
|
|
};
|
|
taggedstruct {
|
|
"INIT_SEGMENT" uchar; /* references segment that initialises this page */
|
|
};
|
|
})*;
|
|
(block "ADDRESS_MAPPING" struct {
|
|
ulong; /* source address */
|
|
ulong; /* destination address */
|
|
ulong; /* length */
|
|
})*;
|
|
"PGM_VERIFY" ulong; /* verification value for PGM */
|
|
};
|
|
};
|
|
|
|
taggedstruct Common_Parameters {
|
|
block "PROTOCOL_LAYER" struct Protocol_Layer;
|
|
block "SEGMENT" struct Segment;
|
|
block "DAQ" struct Daq;
|
|
block "PAG" struct Pag;
|
|
block "PGM" struct Pgm;
|
|
block "DAQ_EVENT" taggedunion Daq_Event;
|
|
};
|
|
|
|
struct CAN_Parameters {
|
|
uint; /* XCP on CAN version, currentl 0x0100 */
|
|
taggedstruct {
|
|
"CAN_ID_BROADCAST" ulong; /* Auto-detection CAN-ID */
|
|
"CAN_ID_MASTER" ulong; /* CMD/STIM CAN-ID */
|
|
"CAN_ID_SLAVE" ulong; /* RES/ERR/EV/SERV/DAQ CAN-ID */
|
|
"BAUDRATE" ulong; /* Baudrate in Hz */
|
|
"SAMPLE_POINT" uchar; /* Sample point in % of bit time */
|
|
"SAMPLE_RATE" enum {
|
|
"SINGLE" = 1,
|
|
"TRIPLE" = 3
|
|
};
|
|
"BTL_CYCLES" uchar; /* slots per bit time */
|
|
"SJW" uchar;
|
|
"SYNC_EDGE" enum {
|
|
"SINGLE" = 1, /* on falling edge only */
|
|
"DUAL" = 2 /* on falling and rising edge */
|
|
};
|
|
"MAX_DLC_REQUIRED"; /* master to slave frames */
|
|
(block "DAQ_LIST_CAN_ID" struct {
|
|
uint; /* reference to DAQ_LIST_NUMBER */
|
|
taggedstruct { /* exclusive tags: either VARIABLE or FIXED */
|
|
"VARIABLE";
|
|
"FIXED" ulong; /* this DAQ_LIST always on this CAN_ID */
|
|
};
|
|
})*;
|
|
};
|
|
};
|
|
|
|
struct SxI_Parameters {
|
|
uint; /* XCP on SxI version, currently 0x0100 */
|
|
ulong; /* BAUDRATE [Hz] */
|
|
taggedstruct { /* exclusive tags */
|
|
"ASYNCH_FULL_DUPLEX_MODE" struct {
|
|
enum {
|
|
"PARITY_NONE" = 0,
|
|
"PARITY_ODD" = 1,
|
|
"PARITY_EVEN" = 2
|
|
};
|
|
enum {
|
|
"ONE_STOP_BIT" = 1,
|
|
"TWO_STOP_BITS" = 2
|
|
};
|
|
};
|
|
"SYNCH_FULL_DUPLEX_MODE_BYTE";
|
|
"SYNCH_FULL_DUPLEX_MODE_WORD";
|
|
"SYNCH_FULL_DUPLEX_MODE_DWORD";
|
|
"SYNCH_MASTER_SLAVE_MODE_BYTE";
|
|
"SYNCH_MASTER_SLAVE_MODE_WORD";
|
|
"SYNCH_MASTER_SLAVE_MODE_DWORD";
|
|
};
|
|
enum {
|
|
"HEADER_LEN_BYTE" = 0,
|
|
"HEADER_LEN_CTR_BYTE" = 1,
|
|
"HEADER_LEN_WORD" = 2,
|
|
"HEADER_LEN_CTR_WORD" = 3
|
|
};
|
|
enum {
|
|
"NO_CHECKSUM" = 0,
|
|
"CHECKSUM_BYTE" = 1,
|
|
"CHECKSUM_WORD" = 2
|
|
};
|
|
};
|
|
|
|
struct TCP_IP_Parameters {
|
|
uint; /* XCP on TCP_IP version, currently 0x0100 */
|
|
uint; /* PORT */
|
|
taggedunion {
|
|
"HOST_NAME" char[256];
|
|
"ADDRESS" char[15];
|
|
};
|
|
};
|
|
|
|
struct UDP_Parameters {
|
|
uint; /* XCP on UDP version, currently 0x0100 */
|
|
uint; /* PORT */
|
|
taggedunion {
|
|
"HOST_NAME" char[256];
|
|
"ADDRESS" char[15];
|
|
};
|
|
};
|
|
|
|
struct ep_parameters {
|
|
uchar; /* ENDPOINT_NUMBER, not endpoint address */
|
|
enum {
|
|
"BULK_TRANSFER" = 2, /* Numbers according to USB spec.*/
|
|
"INTERRUPT_TRANSFER" = 3
|
|
};
|
|
uint; /* wMaxPacketSize: Maximum packet */
|
|
/* size of endpoint in bytes */
|
|
|
|
uchar; /* bInterval: polling of endpoint */
|
|
|
|
enum { /* Packing of XCP Messages */
|
|
"MESSAGE_PACKING_SINGLE" = 0, /* Single per USB data packet */
|
|
"MESSAGE_PACKING_MULTIPLE" = 1, /* Multiple per USB data packet */
|
|
"MESSAGE_PACKING_STREAMING" = 2 /* No restriction by packet sizes*/
|
|
};
|
|
enum { /* Alignment mandatory for all */
|
|
"ALIGNMENT_8_BIT" = 0, /* packing types */
|
|
"ALIGNMENT_16_BIT"= 1,
|
|
"ALIGNMENT_32_BIT"= 2,
|
|
"ALIGNMENT_64_BIT"= 3
|
|
};
|
|
|
|
taggedstruct { /* Optional */
|
|
"RECOMMENDED_HOST_BUFSIZE" uint; /* Recommended size for the host */
|
|
/* buffer size. The size is defined*/
|
|
/* as multiple of wMaxPacketSize. */
|
|
};
|
|
}; /* end of ep_parameters */
|
|
|
|
struct USB_Parameters {
|
|
uint; /* XCP on USB version */
|
|
/* e.g. "1.0" = 0x0100 */
|
|
|
|
uint; /* Vendor ID */
|
|
uint; /* Product ID */
|
|
uchar; /* Number of interface */
|
|
|
|
|
|
enum {
|
|
"HEADER_LEN_BYTE" = 0,
|
|
"HEADER_LEN_CTR_BYTE" = 1,
|
|
"HEADER_LEN_FILL_BYTE" = 2,
|
|
"HEADER_LEN_WORD" = 3,
|
|
"HEADER_LEN_CTR_WORD" = 4,
|
|
"HEADER_LEN_FILL_WORD" = 5
|
|
};
|
|
|
|
taggedunion { /* OUT-EP for CMD and */
|
|
/* STIM (if not specified otherwise) */
|
|
block "OUT_EP_CMD_STIM" struct ep_parameters;
|
|
};
|
|
|
|
taggedunion { /* IN-EP for RES/ERR, */
|
|
/* DAQ (if not specified otherwise) and */
|
|
/* EV/SERV (if not specified otherwise) */
|
|
block "IN_EP_RESERR_DAQ_EVSERV" struct ep_parameters;
|
|
};
|
|
/* ----------- Begin of optional ------- */
|
|
|
|
taggedstruct { /* Optional */
|
|
"ALTERNATE_SETTING_NO" uchar; /* Number of alternate setting */
|
|
|
|
/* String Descriptor of XCP */
|
|
/* interface */
|
|
"INTERFACE_STRING_DESCRIPTOR" char [101];
|
|
/* multiple OUT-EP's for STIM */
|
|
(block "OUT_EP_ONLY_STIM" struct ep_parameters)*;
|
|
/* multiple IN-EP's for DAQ */
|
|
(block "IN_EP_ONLY_DAQ" struct ep_parameters)*;
|
|
/* only one IN-EP for EV/SERV */
|
|
block "IN_EP_ONLY_EVSERV" struct ep_parameters;
|
|
|
|
(block "DAQ_LIST_USB_ENDPOINT" struct {
|
|
uint; /* reference to DAQ_LIST_NUMBER */
|
|
taggedstruct { /* only mentioned if not VARIABLE */
|
|
"FIXED_IN" uchar; /* this DAQ list always */
|
|
/* ENDPOINT_NUMBER, not endpoint address */
|
|
"FIXED_OUT" uchar; /* this STIM list always */
|
|
/* ENDPOINT_NUMBER, not endpoint address */
|
|
};
|
|
})*; /* end of DAQ_LIST_USB_ENDPOINT */
|
|
}; /* end of optional */
|
|
};
|
|
|
|
enum packet_assignment_type {
|
|
"NOT_ALLOWED",
|
|
"FIXED",
|
|
"VARIABLE_INITIALISED",
|
|
"VARIABLE"
|
|
}; /* end of packet_assignment_type */
|
|
|
|
struct buffer {
|
|
|
|
uchar; /* FLX_BUF */
|
|
|
|
taggedstruct {
|
|
|
|
"MAX_FLX_LEN_BUF" taggedunion {
|
|
"FIXED" uchar; /* constant value */
|
|
"VARIABLE" uchar; /* initial value */
|
|
}; /* end of MAX_FLX_LEN_BUF */
|
|
|
|
block "LPDU_ID" taggedstruct {
|
|
|
|
"FLX_SLOT_ID" taggedunion {
|
|
"FIXED" uint;
|
|
"VARIABLE" taggedstruct{
|
|
"INITIAL_VALUE" uint;
|
|
};
|
|
}; /* end of FLX_SLOT_ID */
|
|
|
|
"OFFSET" taggedunion {
|
|
"FIXED" uchar;
|
|
"VARIABLE" taggedstruct{
|
|
"INITIAL_VALUE" uchar;
|
|
};
|
|
}; /* end of OFFSET */
|
|
|
|
"CYCLE_REPETITION" taggedunion {
|
|
"FIXED" uchar;
|
|
"VARIABLE" taggedstruct{
|
|
"INITIAL_VALUE" uchar;
|
|
};
|
|
}; /* end of CYCLE_REPETITION */
|
|
|
|
"CHANNEL" taggedunion {
|
|
"FIXED" enum {
|
|
"A" = 0,
|
|
"B" = 1
|
|
};
|
|
"VARIABLE" taggedstruct{
|
|
"INITIAL_VALUE" enum {
|
|
"A" = 0,
|
|
"B" = 1
|
|
};
|
|
};
|
|
}; /* end of CHANNEL */
|
|
|
|
}; /* end of LPDU_ID */
|
|
|
|
block "XCP_PACKET" taggedstruct {
|
|
|
|
"CMD" enum packet_assignment_type; /* end of CMD */
|
|
"RES_ERR" enum packet_assignment_type; /* end of RES_ERR */
|
|
"EV_SERV" enum packet_assignment_type; /* end of EV_SERV */
|
|
"DAQ" enum packet_assignment_type; /* end of DAQ */
|
|
"STIM" enum packet_assignment_type; /* end of STIM */
|
|
|
|
}; /* end of XCP_PACKET */
|
|
|
|
};
|
|
|
|
}; /* end of buffer */
|
|
|
|
struct FLX_Parameters {
|
|
|
|
uint; /* XCP on FlexRay version */
|
|
/* e.g. "1.0" = 0x0100 */
|
|
|
|
uint; /* T1_FLX [ms] */
|
|
|
|
char[256]; /* FIBEX-file */
|
|
/* including CHI information */
|
|
/* including extension */
|
|
/* without path */
|
|
|
|
char[256]; /* Cluster-ID */
|
|
|
|
uchar; /* NAX */
|
|
|
|
enum {
|
|
"HEADER_NAX" = 0,
|
|
"HEADER_NAX_FILL" = 1,
|
|
"HEADER_NAX_CTR" = 2,
|
|
"HEADER_NAX_FILL3" = 3,
|
|
"HEADER_NAX_CTR_FILL2" = 4,
|
|
"HEADER_NAX_LEN" = 5,
|
|
"HEADER_NAX_CTR_LEN" = 6,
|
|
"HEADER_NAX_FILL2_LEN" = 7,
|
|
"HEADER_NAX_CTR_FILL_LEN" = 8
|
|
};
|
|
|
|
enum {
|
|
"PACKET_ALIGNMENT_8" = 0,
|
|
"PACKET_ALIGNMENT_16" = 1,
|
|
"PACKET_ALIGNMENT_32" = 2
|
|
};
|
|
|
|
taggedunion {
|
|
block "INITIAL_CMD_BUFFER" struct buffer;
|
|
};
|
|
|
|
taggedunion {
|
|
block "INITIAL_RES_ERR_BUFFER" struct buffer;
|
|
};
|
|
|
|
taggedstruct {
|
|
(block "POOL_BUFFER" struct buffer)*;
|
|
};
|
|
|
|
};
|
|
|
|
block "IF_DATA" taggedunion if_data {
|
|
|
|
|
|
"CANAPE_EXT" struct {
|
|
int; /* version number */
|
|
taggedstruct {
|
|
"LINK_MAP" struct {
|
|
char[256]; /* segment name */
|
|
long; /* base address of the segment */
|
|
uint; /* address extension of the segment */
|
|
uint; /* flag: address is relative to DS */
|
|
long; /* offset of the segment address */
|
|
uint; /* datatypValid */
|
|
uint; /* enum datatyp */
|
|
uint; /* bit offset of the segment */
|
|
};
|
|
"DISPLAY" struct {
|
|
long; /* display color */
|
|
double; /* minimal display value (phys)*/
|
|
double; /* maximal display value (phys)*/
|
|
};
|
|
"VIRTUAL_CONVERSION" struct {
|
|
char[256]; /* name of the conversion formula */
|
|
};
|
|
};
|
|
};
|
|
"CANAPE_MODULE" struct {
|
|
taggedstruct {
|
|
("RECORD_LAYOUT_STEPSIZE" struct {
|
|
char[256]; /* name of record layout*/
|
|
uint; /* stepsize for FNC_VALUES */
|
|
uint; /* stepsize for AXIS_PTS_X */
|
|
uint; /* stepsize for AXIS_PTS_Y */
|
|
uint; /* stepsize for AXIS_PTS_Z */
|
|
uint; /* stepsize for AXIS_PTS_4 */
|
|
uint; /* stepsize for AXIS_PTS_5 */
|
|
})*;
|
|
};
|
|
};
|
|
/*********************************************************/
|
|
/* XCP */
|
|
/*********************************************************/
|
|
"XCP" struct {
|
|
taggedstruct Common_Parameters ; /* default parameters */
|
|
taggedstruct {
|
|
block "XCP_ON_CAN" struct {
|
|
struct CAN_Parameters; /* specific for CAN */
|
|
taggedstruct Common_Parameters; /* overruling of default */
|
|
};
|
|
block "XCP_ON_SxI" struct {
|
|
struct SxI_Parameters; /* specific for SxI */
|
|
taggedstruct Common_Parameters; /* overruling of default */
|
|
};
|
|
block "XCP_ON_TCP_IP" struct {
|
|
struct TCP_IP_Parameters; /* specific for TCP_IP */
|
|
taggedstruct Common_Parameters; /* overruling of default */
|
|
};
|
|
block "XCP_ON_UDP_IP" struct {
|
|
struct UDP_Parameters; /* specific for UDP */
|
|
taggedstruct Common_Parameters; /* overruling of default */
|
|
};
|
|
block "XCP_ON_USB" struct {
|
|
struct USB_Parameters ; /* specific for USB */
|
|
taggedstruct Common_Parameters; /* overruling of default */
|
|
};
|
|
block "XCP_ON_FLX" struct {
|
|
struct FLX_Parameters ; /* specific for FlexRay */
|
|
taggedstruct Common_Parameters; /* overruling of default */
|
|
};
|
|
};
|
|
};
|
|
"CANAPE_GROUP" taggedstruct {
|
|
block "STRUCTURE_LIST" (char[1024])*;
|
|
};
|
|
};
|
|
|
|
/end A2ML
|
|
|