From 6b48b6426f15d60ec74b4012432003518c4504c5 Mon Sep 17 00:00:00 2001 From: ian Date: Fri, 14 Mar 2025 11:24:26 +0900 Subject: [PATCH] add file --- test data/ASAP2Example.a2l | 2309 ++++++++++++++++++++++++++++++++++++ 1 file changed, 2309 insertions(+) create mode 100644 test data/ASAP2Example.a2l diff --git a/test data/ASAP2Example.a2l b/test data/ASAP2Example.a2l new file mode 100644 index 0000000..5ab1c7b --- /dev/null +++ b/test data/ASAP2Example.a2l @@ -0,0 +1,2309 @@ +/* + Written by ASAP2 Library v7.0.5 + 8/6/2017 12:21 PM + Original file: ASAP2Example.a2l +*/ + +ASAP2_VERSION 1 71 + +/begin PROJECT Example "Example project" + + /begin HEADER + "General project description" + VERSION "0815" + PROJECT_NO _0815 + /end HEADER + + /begin MODULE Module + "Module \"description\" with escaped quotes" + + /begin A2ML + 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 { + "GET_COMM_MODE_INFO" = 251, + "GET_ID" = 250, + "SET_REQUEST" = 249, + "GET_SEED" = 248, + "UNLOCK" = 247, + "SET_MTA" = 246, + "UPLOAD" = 245, + "SHORT_UPLOAD" = 244, + "BUILD_CHECKSUM" = 243, + "TRANSPORT_LAYER_CMD" = 242, + "USER_CMD" = 241, + "DOWNLOAD" = 240, + "DOWNLOAD_NEXT" = 239, + "DOWNLOAD_MAX" = 238, + "SHORT_DOWNLOAD" = 237, + "MODIFY_BITS" = 236, + "SET_CAL_PAGE" = 235, + "GET_CAL_PAGE" = 234, + "GET_PAG_PROCESSOR_INFO" = 233, + "GET_SEGMENT_INFO" = 232, + "GET_PAGE_INFO" = 231, + "SET_SEGMENT_MODE" = 230, + "GET_SEGMENT_MODE" = 229, + "COPY_CAL_PAGE" = 228, + "CLEAR_DAQ_LIST" = 227, + "SET_DAQ_PTR" = 226, + "WRITE_DAQ" = 225, + "SET_DAQ_LIST_MODE" = 224, + "GET_DAQ_LIST_MODE" = 223, + "START_STOP_DAQ_LIST" = 222, + "START_STOP_SYNCH" = 221, + "GET_DAQ_CLOCK" = 220, + "READ_DAQ" = 219, + "GET_DAQ_PROCESSOR_INFO" = 218, + "GET_DAQ_RESOLUTION_INFO" = 217, + "GET_DAQ_LIST_INFO" = 216, + "GET_DAQ_EVENT_INFO" = 215, + "FREE_DAQ" = 214, + "ALLOC_DAQ" = 213, + "ALLOC_ODT" = 212, + "ALLOC_ODT_ENTRY" = 211, + "PROGRAM_START" = 210, + "PROGRAM_CLEAR" = 209, + "PROGRAM" = 208, + "PROGRAM_RESET" = 207, + "GET_PGM_PROCESSOR_INFO" = 206, + "GET_SECTOR_INFO" = 205, + "PROGRAM_PREPARE" = 204, + "PROGRAM_FORMAT" = 203, + "PROGRAM_NEXT" = 202, + "PROGRAM_MAX" = 201, + "PROGRAM_VERIFY" = 200 + })*; + "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 { + "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, + "STIM" = 2, + "DAQ_STIM" = 3 + }; + "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, + "STIM" = 2, + "DAQ_STIM" = 3 + }; + uchar; /* MAX_DAQ_LIST */ + uchar; /* TIME_CYCLE */ + uchar; /* TIME_UNIT */ + uchar; /* PRIORITY */ + })*; + }; + }; + + taggedunion Daq_Event { + "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 { + 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 { + 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, + "DUAL" = 2 + }; + "MAX_DLC_REQUIRED" ; /* master to slave frames */ + (block "DAQ_LIST_CAN_ID" struct { + uint; /* reference to DAQ_LIST_NUMBER */ + taggedstruct { + "VARIABLE" ; + "FIXED" ulong; /* this DAQ_LIST always on this CAN_ID */ + }; + })*; + (block "EVENT_CAN_ID_LIST" struct { /* At IF_DATA DAQ */ + uint; /* reference to EVENT_NUMBER */ + taggedstruct { /* exclusive tags */ + ("FIXED" ulong)*; /* this Event always on this ID */ + }; + })*; + block "CAN_FD" struct { /* The CAN_FD block definition indicates the use of CAN-FD frames */ + taggedstruct { + "MAX_DLC" uint; /* 8, 12, 16, 20, 24, 32, 48 or 64 */ + "CAN_FD_DATA_TRANSFER_BAUDRATE" ulong; /* BAUDRATE [Hz] */ + "SAMPLE_POINT" uchar; /* sample point receiver [% complete bit time] */ + "BTL_CYCLES" uchar; /* BTL_CYCLES [slots per bit time] */ + "SJW" uchar; /* length synchr. segment [BTL_CYCLES] */ + "SYNC_EDGE" enum { + "SINGLE" = 1, /* on falling edge only */ + "DUAL" = 2 /* on falling and rising edge */ + }; + "MAX_DLC_REQUIRED"; /* master to slave frames always to have DLC = MAX_DLC_for CAN-FD */ + "SECONDARY_SAMPLE_POINT" uchar; /* sender sample point [% complete bit time] */ + "TRANSCEIVER_DELAY_COMPENSATION" enum { + "OFF" = 0, + "ON" = 1 + }; + }; + }; + }; + }; + + struct SxI_Parameters { + uint; /* XCP on SxI version, currently 0x0100 */ + ulong; /* BAUDRATE [Hz] */ + taggedstruct { + "ASYNCH_FULL_DUPLEX_MODE" struct { + enum { + "PARITY_NONE" = 0, + "PARITY_ODD" = 1, + "PARITY_EVEN" = 2 + }; + enum { + "ONE_STOP_BIT" = 1, + "TWO_STOP_BITS" = 2 + }; + taggedstruct { + block "FRAMING" struct { + uchar; /* SYNC */ + uchar; /* ESC */ + }; + }; + }; + "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_FILL_BYTE" = 2, + "HEADER_LEN_WORD" = 3, + "HEADER_LEN_CTR_WORD" = 4, + "HEADER_LEN_FILL_WORD" = 5 + }; + 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, + "INTERRUPT_TRANSFER" = 3 + }; + uint; /* wMaxPacketSize: Maximum packet size of endpoint in bytes */ + uchar; /* bInterval: polling of endpoint */ + enum { + "MESSAGE_PACKING_SINGLE" = 0, + "MESSAGE_PACKING_MULTIPLE" = 1, + "MESSAGE_PACKING_STREAMING" = 2 + }; + enum { + "ALIGNMENT_8_BIT" = 0, + "ALIGNMENT_16_BIT" = 1, + "ALIGNMENT_32_BIT" = 2, + "ALIGNMENT_64_BIT" = 3 + }; + taggedstruct { + "RECOMMENDED_HOST_BUFSIZE" uint; /* Recommended size for the host buffer size. The size is defined as multiple of wMaxPacketSize. */ + }; + }; + + 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 { + block "OUT_EP_CMD_STIM" struct ep_parameters; + }; + taggedunion { + block "IN_EP_RESERR_DAQ_EVSERV" struct ep_parameters; + }; + taggedstruct { + "ALTERNATE_SETTING_NO" uchar; /* Number of alternate setting */ + "INTERFACE_STRING_DESCRIPTOR" char[101]; + (block "OUT_EP_ONLY_STIM" struct ep_parameters)*; + (block "IN_EP_ONLY_DAQ" struct ep_parameters)*; + block "IN_EP_ONLY_EVSERV" struct ep_parameters; + (block "DAQ_LIST_USB_ENDPOINT" struct { + uint; /* reference to DAQ_LIST_NUMBER */ + taggedstruct { + "FIXED_IN" uchar; /* this DAQ list always ENDPOINT_NUMBER, not endpoint address */ + "FIXED_OUT" uchar; /* this STIM list always ENDPOINT_NUMBER, not endpoint address */ + }; + })*; + }; + }; + + enum packet_assignment_type { + "NOT_ALLOWED" = 0, + "FIXED" = 1, + "VARIABLE_INITIALISED" = 2, + "VARIABLE" = 3 + }; + + struct buffer { + uchar; /* FLX_BUF */ + taggedstruct { + "MAX_FLX_LEN_BUF" taggedunion { + "FIXED" uchar; /* constant value */ + "VARIABLE" uchar; /* initial value */ + }; + block "LPDU_ID" taggedstruct { + "FLX_SLOT_ID" taggedunion { + "FIXED" uint; + "VARIABLE" taggedstruct { + "INITIAL_VALUE" uint; + }; + }; + "OFFSET" taggedunion { + "FIXED" uchar; + "VARIABLE" taggedstruct { + "INITIAL_VALUE" uchar; + }; + }; + "CYCLE_REPETITION" taggedunion { + "FIXED" uchar; + "VARIABLE" taggedstruct { + "INITIAL_VALUE" uchar; + }; + }; + "CHANNEL" taggedunion { + "FIXED" enum { + "A" = 0, + "B" = 1 + }; + "VARIABLE" taggedstruct { + "INITIAL_VALUE" enum { + "A" = 0, + "B" = 1 + }; + }; + }; + }; + block "XCP_PACKET" taggedstruct { + "CMD" enum packet_assignment_type; + "RES_ERR" enum packet_assignment_type; + "EV_SERV" enum packet_assignment_type; + "DAQ" enum packet_assignment_type; + "STIM" enum packet_assignment_type; + }; + }; + }; + + 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 { + "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 */ + }; + }; + }; + "ASAP1B_CCP" taggedstruct { + (block "SOURCE" struct { + struct { + char[101]; /* Name of the DAQ list (data acquisition list), measurement source */ + int; /* Period definition : Basic scaling unit in CSE */ + long; /* Period definition : Rate in Scaling Units */ + }; + taggedstruct { + "DISPLAY_IDENTIFIER" char[32]; /* display identifier of DAQ list*/ + block "QP_BLOB" struct { + uint; /* Number of the DAQ list 0..n */ + taggedstruct { + "LENGTH" uint; /* Length of the DAQ list, maximum number of the useable ODTs */ + "CAN_ID_VARIABLE" ; /* CAN-Message-ID is variable */ + "CAN_ID_FIXED" ulong; /* CAN-Message-ID of the DTOs if fixed */ + ("RASTER" uchar)*; /* Supported CCP Event Channel Names of this DAQ List */ + ("EXCLUSIVE" int)*; /* Exclusion of other DAQ-Lists */ + "REDUCTION_ALLOWED" ; /* Data reduction possible */ + "FIRST_PID" uchar; /* First Packet ID (PID) of this DAQ List */ + }; + }; + }; /* optional parameters for this DAQ list */ + })*; /* DAQ list description*/ + (block "RASTER" struct { + char[101]; /* CCP Event Channel Name */ + char[9]; /* Short Display Name of the Event Channel Name */ + uchar; /* Event Channel No., used for CCP START_STOP) */ + int; /* Period definition : basic scaling unit in CSE as defined in ASAP1b */ + long; /* ECU sample rate of the event channel */ + taggedstruct { + ("EXCLUSIVE" uchar)*; /* Exclusion of other CCP Event Channels */ + }; /* optional parameters*/ + })*; /* Event channel description*/ + (block "EVENT_GROUP" struct { + char[101]; /* Event group name */ + char[9]; /* Short name for the event group */ + taggedstruct { + ("RASTER" uchar)*; /* event channel number*/ + }; /* list of all event channels beloging to the group*/ + })*; /* Group several event channels to form one combined event*/ + block "SEED_KEY" struct { + char[256]; /* Name of the Seed&Key DLL for CAL Priviledge, including file-Extension without path */ + char[256]; /* Name of the Seed&Key DLL for DAQ Priviledge, including file-Extension without path */ + char[256]; /* Name of the Seed&Key DLL for PGM Priviledge, including file-Extension without path */ + }; /* Description of the authentification process*/ + block "CHECKSUM" struct { + char[256]; /* Name of the Checksum DLL representing the ECU Algorithm, including file-Extension without path */ + }; /* Description of the checksum calculation process*/ + block "TP_BLOB" struct { + uint; /* CCP Version, High Byte: Version, Low Byte : subversion (dec.) */ + uint; /* Blob-Version, High Byte: Version, Low Byte : subversion (dec.) */ + ulong; /* CAN-Message ID for 'Transmitting to ECU (CRM)' */ + ulong; /* CAN-Message ID for 'Receiving from ECU (DTM)' */ + uint; /* Logical CCP-Address of the (station address) */ + uint; /* Byte order of Multiple-byte-items 1 = high Byte first, 2 = low byte first */ + taggedstruct { + block "CAN_PARAM" struct { + uint; /* Quartz freq. of the elec. control unit */ + uchar; /* BTR0: Bit timing register */ + uchar; /* BTR1: Bit timing register */ + }; /* CAN parameters*/ + "BAUDRATE" ulong; /* Baud rate in Hz. */ + "SAMPLE_POINT" uchar; /* sampling point of time in percent */ + "SAMPLE_RATE" uchar; /* number of samples per Bit (1 oder 3) */ + "BTL_CYCLES" uchar; /* number of BTL-cycles */ + "SJW" uchar; /* SJW-parameter in BTL-cycles */ + "SYNC_EDGE" enum { + "SINGLE" = 0, + "DUAL" = 1 + }; /* Synchronisation (SINGLE: on falling edge only, DUAL: on falling and rising edge)*/ + "DAQ_MODE" enum { + "ALTERNATING" = 0, + "BURST" = 1 + }; /* mode of cylcic data acquisition (ALTERNATING: ECU is sending one ODT per cycle, BURST: ECU is sending a complete DAQ)*/ + "BYTES_ONLY" ; /* ECU supports max. elements of one Byte size otherwise ECU supports different dataTypes */ + "RESUME_SUPPORTED" ; /* ECU supports the Resume function */ + "STORE_SUPPORTED" ; /* ECU supports the Store function */ + "CONSISTENCY" enum { + "DAQ" = 0, + "ODT" = 1 + }; /* guaranteed consistency (DAQ: consistency of a complete DAQ is guaranteed, ODT: consistency of a complete ODT is guaranteed)*/ + "ADDRESS_EXTENSION" enum { + "DAQ" = 0, + "ODT" = 1 + }; /* ECU supported address extension (DAQ: only one address extension within a DAQ, ODT: only one address extension within an ODT)*/ + block "CHECKSUM_PARAM" struct { + uint; /* checksum calculation procedure standard types not yet defined, if greater of equal 1000 : manufacturer specific */ + ulong; /* Maximum block length used by an ASAP1a-CCP command, for checksum calculation procedure */ + taggedstruct { + "CHECKSUM_CALCULATION" enum { + "ACTIVE_PAGE" = 0, + "BIT_OR_WITH_OPT_PAGE" = 1 + }; /* checksum calculation method*/ + }; /* optional*/ + }; /* checksum parameters */ + (block "DEFINED_PAGES" struct { + struct { + uint; /* logical number of the memory page (1,2,..) */ + char[101]; /* name of the memory page */ + uint; /* adress-Extension of the memory page (only Low Byte significant) */ + ulong; /* base address of the memory page */ + ulong; /* length of the memory page in Bytes */ + }; /* fixed parameters*/ + taggedstruct { + "RAM" ; /* memory page in RAM */ + "ROM" ; /* memory page in ROM */ + "FLASH" ; /* memory page in FLASH */ + "EEPROM" ; /* memory page in EEPROM */ + "RAM_INIT_BY_ECU" ; /* memory page is initialised by ECU start-up */ + "RAM_INIT_BY_TOOL" ; /* RAM- memory page is initialised by the MCS */ + "AUTO_FLASH_BACK" ; /* RAM memory page is automatically flashed back */ + "FLASH_BACK" ; /* feature available to flash back the RAM memory page */ + "DEFAULT" ; /* memory page is standard (fallback mode) */ + }; /* optional parameters */ + })*; /* memory page description */ + ("OPTIONAL_CMD" uint)*; /* CCP-Code of the optional command available */ + }; /* optional parameters */ + }; + ("ADDR_MAPPING" struct { + ulong; /* base address of the memory segment to be mapped*/ + ulong; /* address to which the base address is to be mapped*/ + ulong; /* length of the segment to be mapped*/ + })*; /* address mapping for memory segment*/ + "DP_BLOB" struct { + uint; /* address extension of the calibration data (only low byte significant) */ + ulong; /* base address of the calibration data */ + ulong; /* number of Bytes belonging to the calibration data */ + }; /* address information for calibration objects and memory segments*/ + "KP_BLOB" struct { + uint; /* address extension of the online data (only Low Byte significant) */ + ulong; /* base address of the online data */ + ulong; /* number of bytes belonging to the online data (1,2 or 4) */ + taggedstruct { + ("RASTER" uchar)*; /* event channel number*/ + }; + }; /* address information for measure objects (online data)*/ + }; + + "CANAPE_EXT" struct { + int; + taggedstruct { + "LINK_MAP" struct { + char[256]; + long; + uint; + uint; + long; + uint; + uint; + uint; + }; + "DISPLAY" struct { long; double; double; }; + "VIRTUAL_CONVERSION" struct { char[256]; }; + }; + }; + + "CANAPE_ADDRESS_UPDATE" taggedstruct { + // to be used in MODULE + // to get start address of EPK + ("EPK_ADDRESS" struct { + char[1024]; // name of the corresponding symbol in MAP file + long; // optional address offset + })*; + // to be used in MODULE + // to get start address of EPK + "ECU_CALIBRATION_OFFSET" struct { + char[1024]; // name of the corresponding symbol in MAP file + long; // optional address offset + }; + // to be used in MODULE + // to get start address and size of pointer tables + (block "CALIBRATION_METHOD" taggedunion { + "AUTOSAR_SINGLE_POINTERED" struct { + char[1024]; // MAP symbol name for pointer table in RAM + long; // optional address offset + taggedstruct { + "ORIGINAL_POINTER_TABLE" struct { + char[1024]; // MAP symbol name for pointer table in FLASH + long; // optional address offset + }; + }; + }; + "InCircuit2" struct { + char[1024]; // MAP symbol name for pointer table in RAM + long; // optional address offset + taggedstruct { + "ORIGINAL_POINTER_TABLE" struct { + char[1024]; // MAP symbol name for pointer table in FLASH + long; // optional address offset + }; + "FLASH_SECTION" struct { + ulong; // start address of flash section + ulong; // length of flash section + } + }; + }; + })*; + // to be used in MEMORY_SEGMENT + // to get start address and size of the segment and mapped ranges for XCP + block "MAP_SYMBOL" taggedstruct { + "FIRST" struct { + char[1024]; // symbol name of the corresponding segment in MAP file + long; // offset; + }; + "LAST" struct { + char[1024]; // symbol name of the corresponding segment in MAP file + long; // offset; + }; + ("ADDRESS_MAPPING_XCP" struct { + char[1024]; // symbol name of source range in MAP file + char[1024]; // symbol name of destination range in MAP file + })*; + }; + // to be used in MODULE + // workaround to avoid direct usage in MEMORY_SEGMENT (see above) + // (INCA cannot read ASAP2 files with unknown IF_DATA in MEMORY_SEGMENTs) + // !! name of the memory segment must be unique !! + (block "MEMORY_SEGMENT" struct { + char[1024]; // name of the memory segment + taggedstruct { + "FIRST" struct { + char[1024]; // symbol name of the corresponding segment in MAP file + long; // offset; + }; + "LAST" struct { + char[1024]; // symbol name of the corresponding segment in MAP file + long; // offset; + }; + ("ADDRESS_MAPPING_XCP" struct { + char[1024]; // symbol name of source range in MAP file + char[1024]; // symbol name of destination range in MAP file + })*; + }; + })*; + }; + + }; + /end A2ML + + /begin MOD_PAR + "Module parameter description" + VERSION "Test version 01.01.2013" + SUPPLIER "jnsoft" + CUSTOMER "Customer" + CUSTOMER_NO "1234" + USER "joe nachbaur" + PHONE_NO "+49 171 1234567890" + ECU "Engine control" + CPU_TYPE "Intel x" + EPK "EPROM identifier test" + ADDR_EPK 0x0 + NO_OF_INTERFACES 1 + SYSTEM_CONSTANT "CONST_PI" "3.14159" + SYSTEM_CONSTANT "CONST_PI_2" "$(CONST_PI)/2" + SYSTEM_CONSTANT "CONST_PI_REF_2" "$(CONST_PI_2)/2" + SYSTEM_CONSTANT "CONST_SIN_PI_2" "sin($(CONST_PI_REF_2))" + SYSTEM_CONSTANT "CONST_SIN_COS_PI" "1.24242 * (sin ( $(CONST_PI) ) + cos ( $(CONST_PI) ))" + SYSTEM_CONSTANT "Simple text" "test text test" + + /begin MEMORY_SEGMENT CALIBRATIONRAM1 + "Calibration RAM segment 1" + DATA FLASH INTERN 0x0 0x8000 -1 -1 -1 -1 -1 + /begin IF_DATA XCP + /begin SEGMENT + 0x0 + 0x2 + 0x0 + 0x0 + 0x0 + /begin CHECKSUM + XCP_ADD_12 + /end CHECKSUM + /begin PAGE + 0x0 + ECU_ACCESS_WITH_XCP_ONLY + XCP_READ_ACCESS_WITH_ECU_ONLY + XCP_WRITE_ACCESS_NOT_ALLOWED + /end PAGE + /begin PAGE + 0x1 + ECU_ACCESS_WITH_XCP_ONLY + XCP_READ_ACCESS_WITH_ECU_ONLY + XCP_WRITE_ACCESS_WITH_ECU_ONLY + /end PAGE + // /begin ADDRESS_MAPPING 0x0 0x8000 0x8000 /end ADDRESS_MAPPING + /end SEGMENT + /end IF_DATA + /begin IF_DATA CANAPE_ADDRESS_UPDATE + /begin MAP_SYMBOL + FIRST + "ReferencePage" + 0 + LAST + "ReferencePage" + 0 + ADDRESS_MAPPING_XCP + "ReferencePage" + "WorkingPage" + /end MAP_SYMBOL + /end IF_DATA + /end MEMORY_SEGMENT + + /begin MEMORY_SEGMENT CALIBRATIONRAM2 + "Calibration RAM segment 2" + DATA FLASH INTERN 0x8000 0x1000 -1 -1 -1 -1 -1 + /begin IF_DATA XCP + /begin SEGMENT + 0x1 + 0x2 + 0x0 + 0x0 + 0x0 + /begin CHECKSUM + XCP_ADD_12 + /end CHECKSUM + /begin PAGE + 0x0 + ECU_ACCESS_WITH_XCP_ONLY + XCP_READ_ACCESS_WITH_ECU_ONLY + XCP_WRITE_ACCESS_NOT_ALLOWED + /end PAGE + /begin PAGE + 0x1 + ECU_ACCESS_WITH_XCP_ONLY + XCP_READ_ACCESS_WITH_ECU_ONLY + XCP_WRITE_ACCESS_WITH_ECU_ONLY + /end PAGE + // /begin ADDRESS_MAPPING 0x0 0x8000 0x8000 /end ADDRESS_MAPPING + /end SEGMENT + /end IF_DATA + /end MEMORY_SEGMENT + /end MOD_PAR + + /begin IF_DATA CANAPE_ADDRESS_UPDATE + EPK_ADDRESS + "EpromIdentifier" + 0 + /begin CALIBRATION_METHOD AUTOSAR_SINGLE_POINTERED + "Pointer_Table_Work_RAM" + 0 + ORIGINAL_POINTER_TABLE + "Pointer_Table_Base" + 0 + /end CALIBRATION_METHOD + /begin CALIBRATION_METHOD InCircuit2 + "Pointer_Table_Work_FLASH" + 0 + ORIGINAL_POINTER_TABLE + "Pointer_Table_Base" + 0 + FLASH_SECTION + 0 + 0x10000 + /end CALIBRATION_METHOD + /begin MEMORY_SEGMENT + "CALRAM" + FIRST + "CALRAM_START" + 0 + LAST + "CALRAM_LAST" + 0 + /end MEMORY_SEGMENT + /end IF_DATA + + /begin IF_DATA ASAP1B_CCP + /begin SOURCE + "1 ms" + 3 + 1 + /begin QP_BLOB + 1 + LENGTH 10 + CAN_ID_FIXED 0x710 + RASTER 0 + /end QP_BLOB + /end SOURCE + /begin SOURCE + "10 ms" + 4 + 1 + /begin QP_BLOB + 2 + LENGTH 10 + CAN_ID_FIXED 0x720 + RASTER 1 + /end QP_BLOB + /end SOURCE + /begin SOURCE + "100" + 5 + 1 + /begin QP_BLOB + 3 + LENGTH 100 + CAN_ID_FIXED 0x728 + RASTER 2 + /end QP_BLOB + /end SOURCE + /begin RASTER + "1 ms" + "1_ms" + 0 + 3 + 1 + /end RASTER + /begin RASTER + "10 ms" + "10_ms" + 1 + 4 + 1 + /end RASTER + /begin RASTER + "100 ms" + "100_ms" + 2 + 5 + 1 + /end RASTER + /begin SEED_KEY + /* seed&key dll for CAL privilege */ "" + /* seed&key dll for DAQ privilege */ "" + /* seed&key dll for PGM privilege */ "" + /end SEED_KEY + /begin TP_BLOB + /* CCP version */ 0x201 + /* Blob version */ 0x202 + /* CAN msg ID - recv */ 0x7ef + /* CAN msg ID - send */ 0x7ee + /* station address */ 0x1234 + /* byte order */ 2 + BAUDRATE 1000000 + DAQ_MODE BURST + CONSISTENCY DAQ + /begin CHECKSUM_PARAM + /* algorithm */ 0x8001 /* M_16_BIT_BY_ADD8 */ + /* limit */ 0xFFFFFFFF + CHECKSUM_CALCULATION BIT_OR_WITH_OPT_PAGE + /end CHECKSUM_PARAM + /begin DEFINED_PAGES + 1 + "reference page" + /* address ext. */ 0x00 + /* base address */ 0x0 + /* page length */ 0x8000 + FLASH + /end DEFINED_PAGES + /begin DEFINED_PAGES + 2 + "working page" + /* address ext. */ 0x00 + /* base address */ 0x00008000 + /* page length */ 0x8000 + RAM + FLASH_BACK + RAM_INIT_BY_ECU + /end DEFINED_PAGES + OPTIONAL_CMD 0x12 /* GET_SEED */ + OPTIONAL_CMD 0x13 /* UNLOCK */ + OPTIONAL_CMD 0x23 /* DNLOAD_6 */ + OPTIONAL_CMD 0x0F /* SHORT_UP */ + OPTIONAL_CMD 0x11 /* SELECT_CAL_PAGE */ + OPTIONAL_CMD 0x0C /* SET_S_STATUS */ + OPTIONAL_CMD 0x0D /* GET_S_STATUS */ + OPTIONAL_CMD 0x0E /* BUILD_CHKSUM */ + OPTIONAL_CMD 0x10 /* CLEAR_MEMORY */ + OPTIONAL_CMD 0x18 /* PROGRAM */ + OPTIONAL_CMD 0x22 /* PROGRAM_6 */ + OPTIONAL_CMD 0x19 /* MOVE */ + OPTIONAL_CMD 0x05 /* TEST */ + OPTIONAL_CMD 0x09 /* GET_ACTIVE_CAL_PAGE */ + OPTIONAL_CMD 0x08 /* START_STOP_ALL */ + OPTIONAL_CMD 0x20 /* DIAG_SERVICE */ + /end TP_BLOB + /end IF_DATA + + /begin IF_DATA XCP + /begin PROTOCOL_LAYER + 0x100 + 100 1000 1000 1000 1000 0 0 + 0xFF + 0x400 + BYTE_ORDER_MSB_LAST + ADDRESS_GRANULARITY_BYTE + OPTIONAL_CMD PROGRAM_PREPARE + OPTIONAL_CMD GET_DAQ_RESOLUTION_INFO + OPTIONAL_CMD GET_DAQ_PROCESSOR_INFO + OPTIONAL_CMD GET_DAQ_CLOCK + OPTIONAL_CMD GET_DAQ_LIST_MODE + OPTIONAL_CMD WRITE_DAQ_MULTIPLE + OPTIONAL_CMD COPY_CAL_PAGE + OPTIONAL_CMD GET_CAL_PAGE + OPTIONAL_CMD SET_CAL_PAGE + OPTIONAL_CMD GET_PAG_PROCESSOR_INFO + OPTIONAL_CMD SHORT_DOWNLOAD + OPTIONAL_CMD DOWNLOAD_NEXT + OPTIONAL_CMD DOWNLOAD_MAX + OPTIONAL_CMD PROGRAM_NEXT + OPTIONAL_CMD PROGRAM_MAX + OPTIONAL_CMD BUILD_CHECKSUM + OPTIONAL_CMD SHORT_UPLOAD + OPTIONAL_CMD UPLOAD + OPTIONAL_CMD SET_MTA + OPTIONAL_CMD GET_SEED + OPTIONAL_CMD UNLOCK + OPTIONAL_CMD GET_ID + COMMUNICATION_MODE_SUPPORTED BLOCK SLAVE MASTER 0x2A 0x00 + /* SEED_AND_KEY_EXTERNAL_FUNCTION "C:\somewhere.dll" */ + /end PROTOCOL_LAYER + /begin DAQ + DYNAMIC + 0x4 + 0x4 + 0x0 + OPTIMISATION_TYPE_DEFAULT + ADDRESS_EXTENSION_FREE + IDENTIFICATION_FIELD_TYPE_RELATIVE_BYTE + GRANULARITY_ODT_ENTRY_SIZE_DAQ_BYTE + 0xF8 + OVERLOAD_INDICATION_PID + /begin STIM + GRANULARITY_ODT_ENTRY_SIZE_STIM_BYTE + 0xF8 + /end STIM + /begin TIMESTAMP_SUPPORTED + 0x1 + SIZE_DWORD + UNIT_10US + /end TIMESTAMP_SUPPORTED + /begin DAQ_LIST + 0 + DAQ_LIST_TYPE DAQ + MAX_ODT 2 + MAX_ODT_ENTRIES 2 + EVENT_FIXED 0 + + /begin PREDEFINED + /begin ODT 0 + ODT_ENTRY 0 0x4000 0x00 0x01 0xFF + ODT_ENTRY 1 0x4001 0x00 0x01 0xFF + /end ODT + /end PREDEFINED + + /end DAQ_LIST + /begin DAQ_LIST + 1 + DAQ_LIST_TYPE DAQ + MAX_ODT 2 + MAX_ODT_ENTRIES 5 + EVENT_FIXED 1 + /end DAQ_LIST + /begin EVENT + "100 ms" + "100 ms" + 0 + DAQ + 1 + 100 + 6 + 0 + /end EVENT + /begin EVENT + "10 ms" + "10 ms" + 1 + DAQ + 1 + 10 + 6 + 0 + /end EVENT + /begin EVENT + "1 ms" + "1 ms" + 2 + DAQ + 1 + 1 + 6 + 0 + /end EVENT + /begin EVENT + "free" + "free" + 3 + DAQ + 1 + 0 + 0 + 0 + /end EVENT + /end DAQ + /begin PAG + 0x1 + FREEZE_SUPPORTED + /end PAG + /begin PGM + PGM_MODE_ABSOLUTE + 0x14 0xff + COMMUNICATION_MODE_SUPPORTED BLOCK SLAVE MASTER 0x2A 0x00 + /begin SECTOR + "Sector" + 0x0 0xA0000000 0x20000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0x1 0xA0020000 0x20000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0x2 0xA0040000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0x3 0xA0080000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0x4 0xA00C0000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0x5 0xA0100000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0x6 0xA0140000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0x7 0xA0180000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0x8 0xA01C0000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0x9 0xA01C0000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0xA 0xA0200000 0x10000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0xB 0xA0210000 0x10000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0xC 0xA0220000 0x20000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0xD 0xA0240000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0xE 0xA0280000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0xF 0xA02C0000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0x10 0xA0300000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0x11 0xA0340000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0x12 0xA0380000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /begin SECTOR + "Sector" + 0x13 0xA03C0000 0x40000 + 0x0 0x0 0x0 + /end SECTOR + /end PGM + /begin XCP_ON_TCP_IP + 0x100 + 1800 + ADDRESS "192.168.0.2" + /end XCP_ON_TCP_IP + /begin XCP_ON_UDP_IP + 0x100 + 21000 + ADDRESS "192.168.0.2" + /end XCP_ON_UDP_IP + + /begin XCP_ON_SxI + 0x0104 + 115200 + ASYNCH_FULL_DUPLEX_MODE PARITY_NONE ONE_STOP_BIT + /begin FRAMING + 0x01 0x27 + /end FRAMING + SYNCH_FULL_DUPLEX_MODE_DWORD + SYNCH_MASTER_SLAVE_MODE_DWORD + HEADER_LEN_FILL_WORD + CHECKSUM_WORD + /end XCP_ON_SxI + + /begin XCP_ON_CAN + 0x100 + CAN_ID_MASTER 0xDBFFB610 + CAN_ID_SLAVE 0xDBFFB611 + // CAN_ID_BROADCAST 0x100 + BAUDRATE 1000000 + SAMPLE_POINT 75 + SAMPLE_RATE SINGLE + BTL_CYCLES 8 + SJW 0x2 + MAX_DLC_REQUIRED + SYNC_EDGE SINGLE + /begin DAQ_LIST_CAN_ID + 0 + FIXED 0x80000310 + /end DAQ_LIST_CAN_ID + /begin DAQ_LIST_CAN_ID + 1 + FIXED 0x80000320 + /end DAQ_LIST_CAN_ID + /begin DAQ_LIST_CAN_ID + 2 + FIXED 0x80000330 + /end DAQ_LIST_CAN_ID + /begin DAQ_LIST_CAN_ID + 3 + FIXED 0x80000340 + /end DAQ_LIST_CAN_ID + /begin EVENT_CAN_ID_LIST + 0x00 + FIXED 0x00000778 + /end EVENT_CAN_ID_LIST + /begin EVENT_CAN_ID_LIST + 0x01 + FIXED 0x00000779 + /end EVENT_CAN_ID_LIST + /begin EVENT_CAN_ID_LIST + 0x02 + FIXED 0x0000077A + /end EVENT_CAN_ID_LIST + /begin EVENT_CAN_ID_LIST + 0x03 + FIXED 0x0000077B FIXED 0x077C + /end EVENT_CAN_ID_LIST + /begin PROTOCOL_LAYER + 0x100 + 100 1000 1000 1000 1000 0 0 + 0x08 + 0x08 + /end PROTOCOL_LAYER +/* + /begin CAN_FD + MAX_DLC 64 + CAN_FD_DATA_TRANSFER_BAUDRATE 4000000 + MAX_DLC_REQUIRED + /end CAN_FD +*/ + /end XCP_ON_CAN + /begin XCP_ON_USB + 0x100 + 0x108C + 0xEDC + 2 + HEADER_LEN_FILL_WORD + /begin OUT_EP_CMD_STIM + 0x1 + BULK_TRANSFER + 0x40 + 0 + MESSAGE_PACKING_SINGLE + ALIGNMENT_32_BIT + /end OUT_EP_CMD_STIM + /begin IN_EP_RESERR_DAQ_EVSERV + 0x1 + BULK_TRANSFER + 0x40 + 0 + MESSAGE_PACKING_SINGLE + ALIGNMENT_32_BIT + /end IN_EP_RESERR_DAQ_EVSERV + /begin OUT_EP_ONLY_STIM + 0x2 + BULK_TRANSFER + 0x40 + 0 + MESSAGE_PACKING_MULTIPLE + ALIGNMENT_32_BIT + /end OUT_EP_ONLY_STIM + /begin IN_EP_ONLY_DAQ + 0x2 + BULK_TRANSFER + 0x40 + 0 + MESSAGE_PACKING_STREAMING + ALIGNMENT_32_BIT + /end IN_EP_ONLY_DAQ + /begin IN_EP_ONLY_EVSERV + 0x3 + INTERRUPT_TRANSFER + 0x40 + 16 + MESSAGE_PACKING_SINGLE + ALIGNMENT_32_BIT + /end IN_EP_ONLY_EVSERV + /begin DAQ_LIST_USB_ENDPOINT + 0x0 + /end DAQ_LIST_USB_ENDPOINT + /begin DAQ_LIST_USB_ENDPOINT + 0x1 + /end DAQ_LIST_USB_ENDPOINT + /begin DAQ_LIST_USB_ENDPOINT + 0x2 + /end DAQ_LIST_USB_ENDPOINT + /end XCP_ON_USB + /end IF_DATA + + /begin MOD_COMMON + "Characteristic maps always deposited in same mode" + BYTE_ORDER MSB_LAST + DEPOSIT ABSOLUTE + DATA_SIZE 16 + ALIGNMENT_BYTE 1 + ALIGNMENT_WORD 2 + ALIGNMENT_LONG 4 + ALIGNMENT_FLOAT32_IEEE 4 + ALIGNMENT_FLOAT64_IEEE 4 + ALIGNMENT_INT64 8 + /end MOD_COMMON + + /begin CHARACTERISTIC SINGLE_BIG_VALUE + "SINGLE_BIG_VALUE description" + VALUE + 0x1004 + _LONG + 0 + BIGVALUES + 0 100000 + PHYS_UNIT "m/s" + /begin ANNOTATION + ANNOTATION_ORIGIN "SINGLE_BIG_VALUE annotation origin" + ANNOTATION_LABEL "SINGLE_BIG_VALUE annotation label" + /begin ANNOTATION_TEXT + "SINGLE_BIG_VALUE annotation text" + /end ANNOTATION_TEXT + /end ANNOTATION + SYMBOL_LINK "Link_To_Variable" 0 + MODEL_LINK "system/sub-system/object.name" + /end CHARACTERISTIC + + /begin CHARACTERISTIC SINGLE_VALUE_LINEAR + "SINGLE_VALUE_LINEAR description" + VALUE + 0x800 + _UBYTE + 0 + LINEAR + 0 1000 + /end CHARACTERISTIC + + /begin CHARACTERISTIC SINGLE_VALUE + "SINGLE_VALUE description" + VALUE + 0x1000 + _LONG + 0 + SMALLVALUES + 0.2 0.8 + FORMAT "%8.4" + PHYS_UNIT "m/s" + EXTENDED_LIMITS 0 1 + /end CHARACTERISTIC + + /begin CHARACTERISTIC SINGLE_VALUE_ADAPTIVE + "SINGLE_VALUE adaptive description" + VALUE + 0x1000 + _LONG + 0 + SMALLVALUES + 0.2 0.8 + MAX_REFRESH 6 30 + FORMAT "%8.4" + PHYS_UNIT "m/s" + READ_ONLY + EXTENDED_LIMITS 0 1 + /end CHARACTERISTIC + + /begin CHARACTERISTIC SINGLE_VERBAL + "SINGLE_VERBAL description" + VALUE + 0x32 + _UBYTE + 0 + VERBAL + 0 255 + /end CHARACTERISTIC + + /begin CHARACTERISTIC SINGLE_VERBAL_RANGE + "SINGLE_VERBAL_RANGE description" + VALUE + 0x33 + _UBYTE + 0 + RANGE_BYTE + 0 255 + /end CHARACTERISTIC + + /begin CHARACTERISTIC EPKID + "EEPROM identifier" + ASCII + 0x0 + _UBYTE + 0 + IDENTITY + 0 255 + NUMBER 32 + ENCODING UTF8 + /begin IF_DATA ASAP1B_CCP DP_BLOB 0x00 0x00 32 /end IF_DATA + /end CHARACTERISTIC + + /begin CHARACTERISTIC VAL_BLK_NUMERIC + "VAL_BLK_NUMERIC description" + VAL_BLK + 0x33 + _UBYTE + 0 + IDENTITY + 0 255 + NUMBER 31 + /end CHARACTERISTIC + + /begin CHARACTERISTIC VAL_BLK_VERBAL + "VAL_BLK_VERBAL description" + VAL_BLK + 0x33 + _UBYTE + 0 + VERBAL + 0 255 + NUMBER 31 + /end CHARACTERISTIC + + /begin RECORD_LAYOUT RL_DEMO_CURVE_AXIS + NO_AXIS_PTS_X 1 UWORD + AXIS_PTS_X 2 UWORD INDEX_INCR DIRECT + /end RECORD_LAYOUT + + /begin AXIS_PTS + DEMO_CURVE_AXIS + "DEMO_CURVE_AXIS Description" + 0x300 + NO_INPUT_QUANTITY + RL_DEMO_CURVE_AXIS + 1 + IDENTITY + 7 + 0 + 6553.5 + DEPOSIT ABSOLUTE + /end AXIS_PTS + + /begin RECORD_LAYOUT RL_DEMO_CURVE_REF_AXIS + FNC_VALUES 1 UWORD COLUMN_DIR DIRECT + /end RECORD_LAYOUT + + /begin CHARACTERISTIC DEMO_CURVE_REF_AXIS + "DEMO_CURVE_REF_AXIS Description" + CURVE + 0x200 + RL_DEMO_CURVE_REF_AXIS + 1 + IDENTITY + 0 + 1000 + FORMAT "%10.4" + /begin AXIS_DESCR + COM_AXIS + NO_INPUT_QUANTITY + IDENTITY + 7 + 0 + 6553.5 + AXIS_PTS_REF DEMO_CURVE_AXIS + /end AXIS_DESCR + /end CHARACTERISTIC + + /begin CHARACTERISTIC DEMO_CURVE + "CURVE description" + CURVE + 0x64 + CURVE_LAYOUT + 0 + IDENTITY + 0 100 + EXTENDED_LIMITS 0 255 + /begin AXIS_DESCR + FIX_AXIS + revolution + NO_COMPU_METHOD + 11 + 0 20000 + FORMAT "%4.0" + PHYS_UNIT "rpm" + FIX_AXIS_PAR_DIST 0 2000 11 + /end AXIS_DESCR + /begin ANNOTATION + ANNOTATION_LABEL "Calibration Note" + /begin ANNOTATION_TEXT + "Calibration Text" + /end ANNOTATION_TEXT + /end ANNOTATION + /end CHARACTERISTIC + + /begin CHARACTERISTIC DEMO_MAP + "MAP description" + MAP + 0x7C + MAP_LAYOUT + 0 + IDENTITY + 0 100 + EXTENDED_LIMITS 0 255 + /begin AXIS_DESCR + FIX_AXIS + revolution + NO_COMPU_METHOD + 11 + 0 20000 + FORMAT "%4.0" + PHYS_UNIT "rpm" + FIX_AXIS_PAR_DIST 0 2000 11 + /end AXIS_DESCR + /begin AXIS_DESCR + FIX_AXIS + speed + NO_COMPU_METHOD + 11 + 0 360 + FORMAT "%8.2" + PHYS_UNIT "mph" + FIX_AXIS_PAR_DIST 0 36 11 + /end AXIS_DESCR + /begin ANNOTATION + ANNOTATION_LABEL "Calibration Note" + /begin ANNOTATION_TEXT + "Calibration Text" + /end ANNOTATION_TEXT + /end ANNOTATION + /end CHARACTERISTIC + +/* + /begin CHARACTERISTIC DEMO_CUBOID + "CUBOID description" + CUBOID + 0x3000 + MAP_LAYOUT + 0 + IDENTITY + 0 100 + EXTENDED_LIMITS 0 255 + /begin AXIS_DESCR + FIX_AXIS + revolution + NO_COMPU_METHOD + 11 + 0 20000 + FORMAT "%4.0" + PHYS_UNIT "rpm" + FIX_AXIS_PAR_DIST 0 2000 11 + /end AXIS_DESCR + /begin AXIS_DESCR + FIX_AXIS + speed + NO_COMPU_METHOD + 11 + 0 360 + FORMAT "%8.2" + PHYS_UNIT "mph" + FIX_AXIS_PAR_DIST 0 36 11 + /end AXIS_DESCR + /begin AXIS_DESCR + FIX_AXIS + speed + NO_COMPU_METHOD + 11 + 0 360 + FORMAT "%8.2" + PHYS_UNIT "mph" + FIX_AXIS_PAR_DIST 0 36 11 + /end AXIS_DESCR + /end CHARACTERISTIC +*/ + + /begin MEASUREMENT bit1_2_3 + "bit1&2&3 description" + UBYTE + VERBAL + 0 0 + 0 100 + ECU_ADDRESS 0xC00000 + BIT_MASK 0x7 + + /begin IF_DATA XCP + /begin DAQ_EVENT + DEFAULT_EVENT_LIST EVENT 0001 + /end DAQ_EVENT + /end IF_DATA + /begin IF_DATA XCPplus 0x0103 /* IF_DATA XCP version */ + /begin DAQ_EVENT VARIABLE + /begin AVAILABLE_EVENT_LIST + EVENT 0001 EVENT 0002 + /end AVAILABLE_EVENT_LIST + /begin DEFAULT_EVENT_LIST + EVENT 0001 + /end DEFAULT_EVENT_LIST + /begin CONSISTENCY_EVENT_LIST + EVENT 0001 + /end CONSISTENCY_EVENT_LIST + /end DAQ_EVENT + /end IF_DATA + + /begin IF_DATA ASAP1B_CCP KP_BLOB 0x00 0xC35E 0x1 RASTER 1 /end IF_DATA + /end MEASUREMENT + + /begin MEASUREMENT byte_10_array + "single byte measurement value array (10x1) +ARRAY_SIZE=10" + SBYTE + IDENTITY_SMALL + 0 0 + -1.26 1.26 + ECU_ADDRESS 0xC00001 + MATRIX_DIM 10 1 1 + + + /begin IF_DATA XCPplus 0x0103 /* IF_DATA XCP version */ + /begin DAQ_EVENT FIXED_EVENT_LIST + EVENT 0001 EVENT 0002 + /end DAQ_EVENT + /end IF_DATA + + /end MEASUREMENT + + /begin MEASUREMENT Float32_8x4_array + "float measurement value array (8x4) +MATRIX_DIM = 8 4 1" + FLOAT32_IEEE + IDENTITY + 0 0 + -.08 .08 + ECU_ADDRESS 0xC0000B + MATRIX_DIM 8 4 + /end MEASUREMENT + + /begin MEASUREMENT revolution + "revolution description" + SWORD + IDENTITY + 0 0 + 0 20000 + PHYS_UNIT "rpm" + ECU_ADDRESS 0xC01000 + /end MEASUREMENT + + /begin MEASUREMENT speed + "Measures and computes values defined by a 1:1 conversion" + FLOAT32_IEEE + IDENTITY + 0 0 + 0 360 + PHYS_UNIT "mph" + ECU_ADDRESS 0xC00200 + /end MEASUREMENT + + /begin MEASUREMENT speed_by_formula + "Measures and computes values defined by a C-style formula" + SWORD + C_STYLE_FORMULA + 0 0 + -1000 1000 + ECU_ADDRESS 0xC00204 + /end MEASUREMENT + + /begin MEASUREMENT speed_by_interpolation + "Measures and computes values defined by a data table" + UBYTE + INTERPOLATION + 0 0 + 0 360 + ECU_ADDRESS 0xC00206 + /end MEASUREMENT + + /begin FUNCTION FUNC_ASCIIs + "ASCII Values description" + /begin DEF_CHARACTERISTIC + EPKID + /end DEF_CHARACTERISTIC + /begin AR_COMPONENT + "AR COMPONENT Type" + AR_PROTOTYPE_OF GROUP_ASCIIs + /end AR_COMPONENT + /end FUNCTION + + /begin GROUP GROUP_ASCIIs + "ASCII group description" + /begin REF_CHARACTERISTIC + EPKID + /end REF_CHARACTERISTIC + /end GROUP + + /begin FUNCTION FUNC_CURVEs + "CURVEs description" + /begin DEF_CHARACTERISTIC + DEMO_CURVE + /end DEF_CHARACTERISTIC + /begin REF_CHARACTERISTIC + DEMO_CURVE_REF_AXIS + /end REF_CHARACTERISTIC + /end FUNCTION + + /begin FUNCTION FUNC_MAPs + "MAPs description" + /begin DEF_CHARACTERISTIC + DEMO_MAP + /end DEF_CHARACTERISTIC + /end FUNCTION +/* + /begin FUNCTION FUNC_CUBOIDSs + "CUBOIDs description" + /begin DEF_CHARACTERISTIC + DEMO_CUBOID + /end DEF_CHARACTERISTIC + /end FUNCTION +*/ + /begin FUNCTION FUNC_MEASUREMENTs + "MEASUREMENTs description" + /begin OUT_MEASUREMENT + bit1_2_3 revolution speed_by_interpolation speed_by_formula byte_10_array + Float32_8x4_array speed + /end OUT_MEASUREMENT + /end FUNCTION + + /begin FUNCTION FUNC_VAL_BLKs + "Value Blocks description" + /begin DEF_CHARACTERISTIC + VAL_BLK_NUMERIC VAL_BLK_VERBAL + /end DEF_CHARACTERISTIC + /end FUNCTION + + /begin FUNCTION FUNC_VALUESs + "VALUESs description" + /begin DEF_CHARACTERISTIC + SINGLE_VALUE SINGLE_VALUE_LINEAR SINGLE_VALUE_ADAPTIVE SINGLE_BIG_VALUE SINGLE_VERBAL SINGLE_VERBAL_RANGE + /end DEF_CHARACTERISTIC + /end FUNCTION + + /begin COMPU_METHOD BIGVALUES + "BIGVALUES description" + RAT_FUNC + "%.0" "---" + COEFFS 0 1 0 0 0 1 + /end COMPU_METHOD + + /begin COMPU_METHOD C_STYLE_FORMULA + "Defines a C-Style formula to convert between +raw and physical values. +For simulator support, the inverse formula +must be defined, too." + FORM + "%8.1" "km/h" + /begin FORMULA + "X*20" + FORMULA_INV "X/20" + /end FORMULA + /end COMPU_METHOD + + /begin COMPU_METHOD IDENTITY + "IDENTITY description" + RAT_FUNC + "%4.2" "---" + COEFFS 0 1 0 0 0 1 + /end COMPU_METHOD + + /begin COMPU_METHOD IDENTITY_SMALL + "IDENTITY description" + RAT_FUNC + "%4.2" "---" + COEFFS 0 100 0 0 0 1 + /end COMPU_METHOD + + /begin COMPU_METHOD INTERPOLATION + "INTERPOLATION description" + TAB_INTP + "%8.1" "mph" + COMPU_TAB_REF INTERPOLATION_TABLE_0_360 + /end COMPU_METHOD + + /begin COMPU_METHOD NO_INTERPOLATION + "NO_INTERPOLATION description" + TAB_NOINTP + "%8.1" "" + COMPU_TAB_REF NO_INTERPOLATION_TABLE + /end COMPU_METHOD + + /begin COMPU_METHOD SMALLVALUES + "SMALLVALUES description" + RAT_FUNC + "%8.5" "---" + COEFFS 0 10000 0 0 0 1 + /end COMPU_METHOD + + /begin COMPU_METHOD LINEAR + "Linear coeffs description" + LINEAR + "%8.2" "mm" + COEFFS_LINEAR 1.25 1 + /end COMPU_METHOD + + /begin COMPU_METHOD VERBAL + "VERBAL description" + TAB_VERB + "" "" + COMPU_TAB_REF VERBAL_TABLE + /end COMPU_METHOD + + /begin COMPU_METHOD VERBAL_BOOL + "VERBAL_BOOL description" + TAB_VERB + "" "" + COMPU_TAB_REF VERBAL_BOOL_TABLE + /end COMPU_METHOD + + /begin COMPU_VTAB VERBAL_BOOL_TABLE + "VERBAL_BOOL_TABLE description" + TAB_VERB + 2 + 0 "FALSE" + 1 "TRUE" + DEFAULT_VALUE "Not set" + /end COMPU_VTAB + + /begin COMPU_METHOD RANGE_BYTE + "RANGE_BYTE description" + TAB_VERB + "" "" + COMPU_TAB_REF VTAB_RANGE_TABLE + /end COMPU_METHOD + + /begin COMPU_VTAB_RANGE VTAB_RANGE_TABLE + "VTAB_RANGE_TABLE description" + 2 + 0.0 0.9 "< 1" + 1.0 255 ">= 1" + DEFAULT_VALUE "Not set" + /end COMPU_VTAB_RANGE + + /begin COMPU_VTAB VERBAL_TABLE + "VERBAL_TABLE description" + TAB_VERB + 7 + 1 "Bit1 set" + 2 "Bit2 set" + 3 "Bit1&2 set" + 4 "Bit3 set" + 5 "Bit1&3 set" + 6 "Bit2&3 set" + 7 "Bit1&2&3 set" + DEFAULT_VALUE "Not set" + /end COMPU_VTAB + + /begin RECORD_LAYOUT _LONG + FNC_VALUES 1 SLONG COLUMN_DIR DIRECT + /end RECORD_LAYOUT + + /begin RECORD_LAYOUT _UBYTE + FNC_VALUES 1 UBYTE COLUMN_DIR DIRECT + /end RECORD_LAYOUT + + /begin RECORD_LAYOUT CURVE_LAYOUT + FNC_VALUES 1 UWORD COLUMN_DIR DIRECT + /end RECORD_LAYOUT + + /begin RECORD_LAYOUT MAP_LAYOUT + FNC_VALUES 1 SWORD COLUMN_DIR DIRECT + /end RECORD_LAYOUT + + /begin COMPU_TAB INTERPOLATION_TABLE_0_360 + "INTERPOLATION_TABLE description" + TAB_INTP + 5 + 0 0 + 64 90 + 128 180 + 192 270 + 255 360 + DEFAULT_VALUE_NUMERIC 180 + /end COMPU_TAB + + /begin COMPU_TAB NO_INTERPOLATION_TABLE + "NO_INTERPOLATION_TABLE description" + TAB_NOINTP + 9 + 0 0 + 32 45 + 64 90 + 96 120 + 128 180 + 160 210 + 192 270 + 224 300 + 255 360 + DEFAULT_VALUE_NUMERIC 180 + /end COMPU_TAB + + /begin UNIT + metres_per_second + "extended SI unit for velocity" + "m/s" + EXTENDED_SI + SI_EXPONENTS 1 0 -1 0 0 0 0 /* [m] * [s] -1 */ + /end UNIT + /begin UNIT + kms_per_hour + "derived unit for velocity: kilometres per hour" + "km/h" + DERIVED + REF_UNIT metres_per_second + UNIT_CONVERSION 3.6 0.0 /* y [km/h] = (60*60/1000) * x [m/s] + 0.0 */ + /end UNIT + /begin UNIT + miles_per_hour + "derived unit for velocity: miles per hour" + "mph" + DERIVED + REF_UNIT metres_per_second + UNIT_CONVERSION 2.237 0.0 /* y [mph] = (60*60/1609) * x [m/s] + 0.0 */ + /end UNIT + + /begin VARIANT_CODING + VAR_SEPARATOR "." /* PUMKF.1 */ + VAR_NAMING NUMERIC + + /* variant criterion "Car body" with three variants */ + /begin VAR_CRITERION Car + "Car body" + Limousine Kombi Cabrio + VAR_MEASUREMENT bit1_2_3 + /end VAR_CRITERION + + /* variant criterion "Type of gear box" with two variants */ + /begin VAR_CRITERION Gear + "Type of gear box" + Manual Automatic + VAR_SELECTION_CHARACTERISTIC EPKID + /end VAR_CRITERION + + /begin VAR_FORBIDDEN_COMB /* forbidden: Limousine-Manual*/ + Car Limousine + Gear Manual + /end VAR_FORBIDDEN_COMB + + /begin VAR_FORBIDDEN_COMB /* forbidden: Cabrio-Automatic*/ + Car Cabrio + Gear Automatic + /end VAR_FORBIDDEN_COMB + + /begin VAR_CHARACTERISTIC + DEMO_CURVE /*define DEMO_CURVE as variant coded*/ + Gear /* Gear box variants */ + /begin VAR_ADDRESS + 0x7140 + 0x7168 + /end VAR_ADDRESS + /end VAR_CHARACTERISTIC + + /begin VAR_CHARACTERISTIC + DEMO_MAP /*define DEMO_MAP as variant coded */ + Gear Car /*car body and gear box variants*/ + /begin VAR_ADDRESS + 0x7840 + 0x7858 + 0x7870 + 0x7888 + /end VAR_ADDRESS + /end VAR_CHARACTERISTIC + /end VARIANT_CODING + + /begin BLOB DEMO_BLOB + "binary blob for FIM matrix" + 0x6000 + 0x400 + /end BLOB + + /begin TYPEDEF_BLOB TD_BLOB + "binary blob" + 0x400 + /end TYPEDEF_BLOB + + /begin INSTANCE INSTANCE_BLOB + "blob for FIM matrix" + TD_BLOB + 0x5000 + /end INSTANCE + + /begin TYPEDEF_CHARACTERISTIC TD_CHARACTERISTIC + "" + VALUE + _LONG + 100 + NO_COMPU_METHOD + -100 655 + /end TYPEDEF_CHARACTERISTIC + + /begin TYPEDEF_STRUCTURE TD_STRUCTURE + "binary structure" + 0x400 + /begin STRUCTURE_COMPONENT MemberA + TD_CHARACTERISTIC + 0x0 + /end STRUCTURE_COMPONENT + /begin STRUCTURE_COMPONENT MemberB + TD_CHARACTERISTIC + 0x22 + MATRIX_DIM 10 + /end STRUCTURE_COMPONENT + /end TYPEDEF_STRUCTURE + + /begin TYPEDEF_MEASUREMENT TD_MEASUREMENT + "register content" + SWORD + IDENTITY + 1 0 + -200 200 + /end TYPEDEF_MEASUREMENT + + /begin INSTANCE instance_measurement + "" + TD_MEASUREMENT + 0x94 + /begin OVERWRITE THIS + 0 + CONVERSION IDENTITY_SMALL + /end OVERWRITE + /end INSTANCE + + /begin TYPEDEF_AXIS TD_AXIS + "axis points for speed" + revolution + RL_DEMO_CURVE_AXIS + 100 + IDENTITY + 21 + 0 5800 + /end TYPEDEF_AXIS + + /begin INSTANCE INSTANCE_AXIS + "" + TD_AXIS + 0x4000 + /end INSTANCE + + /begin INSTANCE INSTANCE_CHARACTERISTIC + "delay time for filtering" + TD_CHARACTERISTIC + 0x4080 + MATRIX_DIM 5 + /end INSTANCE + + /begin TRANSFORMER Transformer + "1.0.0.0" + "transformer32.dll" + "transformer64.dll" + 25000 + ON_USER_REQUEST + TransformerReverse + /begin TRANSFORMER_IN_OBJECTS + DEMO_CURVE + /end TRANSFORMER_IN_OBJECTS + /begin TRANSFORMER_OUT_OBJECTS + DEMO_BLOB + /end TRANSFORMER_OUT_OBJECTS + /end TRANSFORMER + + /begin TRANSFORMER TransformerReverse + "1.0.0.0" + "TransformerReverse32.dll" + "" + 20000 + ON_CHANGE + Transformer + /begin TRANSFORMER_IN_OBJECTS + DEMO_BLOB + /end TRANSFORMER_IN_OBJECTS + /begin TRANSFORMER_OUT_OBJECTS + DEMO_CURVE + /end TRANSFORMER_OUT_OBJECTS + /end TRANSFORMER + +/* + /begin MEASUREMENT r1 + "" + SLONG + IDENTITY + 0 0 + -800 -200 + PHYS_UNIT "%1" + ECU_ADDRESS 0xC01004 + /end MEASUREMENT + + /begin MEASUREMENT r2 + "" + SLONG + IDENTITY + 0 0 + -200 200 + PHYS_UNIT "%2" + ECU_ADDRESS 0xC01008 + /end MEASUREMENT + + /begin MEASUREMENT r3 + "" + FLOAT64_IEEE + IDENTITY + 0 0 + -200 200 + PHYS_UNIT "%3" + ECU_ADDRESS 0xC0100C + /end MEASUREMENT + /begin FUNCTION ArrayTest + "" + /begin LOC_MEASUREMENT + r1 r2 r3 + /end LOC_MEASUREMENT + /end FUNCTION +*/ + + /end MODULE +/end PROJECT