diff --git a/A2lTestDlg/A2lTestDlg.sln b/A2lTestDlg/A2lTestDlg.sln new file mode 100644 index 0000000..59a3099 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.35731.53 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "A2lTestDlg", "A2lTestDlg\A2lTestDlg.vcxproj", "{86752C60-05E4-465C-9D79-876C97ABD2BA}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {86752C60-05E4-465C-9D79-876C97ABD2BA}.Debug|x64.ActiveCfg = Debug|x64 + {86752C60-05E4-465C-9D79-876C97ABD2BA}.Debug|x64.Build.0 = Debug|x64 + {86752C60-05E4-465C-9D79-876C97ABD2BA}.Debug|x86.ActiveCfg = Debug|Win32 + {86752C60-05E4-465C-9D79-876C97ABD2BA}.Debug|x86.Build.0 = Debug|Win32 + {86752C60-05E4-465C-9D79-876C97ABD2BA}.Release|x64.ActiveCfg = Release|x64 + {86752C60-05E4-465C-9D79-876C97ABD2BA}.Release|x64.Build.0 = Release|x64 + {86752C60-05E4-465C-9D79-876C97ABD2BA}.Release|x86.ActiveCfg = Release|Win32 + {86752C60-05E4-465C-9D79-876C97ABD2BA}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {F96F38CF-D37B-45D8-9FA2-665EB10C5913} + EndGlobalSection +EndGlobal diff --git a/A2lTestDlg/A2lTestDlg/A2L.c b/A2lTestDlg/A2lTestDlg/A2L.c new file mode 100644 index 0000000..9638bbc --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2L.c @@ -0,0 +1,718 @@ +/*---------------------------------------------------------------------------- +| File: +| A2L.c +| +| Description: +| Create A2L file +| +| Copyright (c) Vector Informatik GmbH. All rights reserved. +| Licensed under the MIT license. See LICENSE file in the project root for details. +| + ----------------------------------------------------------------------------*/ +#include "pch.h" +#include "framework.h" + +#include "main.h" +#include "platform.h" +#include "dbg_print.h" +#include "xcpLite.h" +#include "A2L.h" + +static FILE* gA2lFile = NULL; +static uint16_t gA2lFixedEvent = XCP_INVALID_EVENT; +static uint16_t gA2lDefaultEvent = XCP_INVALID_EVENT; + +static uint32_t gA2lMeasurements; +static uint32_t gA2lParameters; +static uint32_t gA2lTypedefs; +static uint32_t gA2lComponents; +static uint32_t gA2lInstances; +static uint32_t gA2lConversions; + + +//---------------------------------------------------------------------------------- +// Check for memory accessibility +//#define A2L_ENABLE_MEMORY_CHECK +#ifdef A2L_ENABLE_MEMORY_CHECK +static void mem_check(const char* name, int32_t type, uint8_t ext, uint32_t addr) { + (void)type; (void)name; + volatile uint8_t *p = ApplXcpGetPointer(ext,addr); + if (p==NULL) { DBG_PRINTF1("ERROR: memory address 0x%04X of variable %s not accessible !\n",addr,name); assert(0); } + volatile uint8_t b = *p; // if this leads to a memory protection error, check if address transformation from A2L to uint_8_p* transformation is correct +} +#endif + + +//---------------------------------------------------------------------------------- +static const char* gA2lHeader = +"ASAP2_VERSION 1 71\n" +"/begin PROJECT %s \"\"\n" +"/begin HEADER \"\" VERSION \"1.0\" /end HEADER\n" +"/begin MODULE %s \"\"\n" +"/include \"XCP_104.aml\"\n\n" + +"/begin MOD_COMMON \"\"\n" +"BYTE_ORDER MSB_LAST\n" +"ALIGNMENT_BYTE 1\n" +"ALIGNMENT_WORD 1\n" +"ALIGNMENT_LONG 1\n" +"ALIGNMENT_FLOAT16_IEEE 1\n" +"ALIGNMENT_FLOAT32_IEEE 1\n" +"ALIGNMENT_FLOAT64_IEEE 1\n" +"ALIGNMENT_INT64 1\n" +"/end MOD_COMMON\n" +"\n"; + +//---------------------------------------------------------------------------------- +static const char* gA2lMemorySegment = +"/begin MEMORY_SEGMENT\n" +"CALRAM \"\" DATA FLASH INTERN 0x%08X 0x%08X -1 -1 -1 -1 -1\n" // CALRAM_START, CALRAM_SIZE +"/begin IF_DATA XCP\n" +"/begin SEGMENT 0x01 0x02 0x00 0x00 0x00 \n" +"/begin CHECKSUM XCP_ADD_44 MAX_BLOCK_SIZE 0xFFFF EXTERNAL_FUNCTION \"\" /end CHECKSUM\n" +"/begin PAGE 0x01 ECU_ACCESS_WITH_XCP_ONLY XCP_READ_ACCESS_WITH_ECU_ONLY XCP_WRITE_ACCESS_NOT_ALLOWED /end PAGE\n" +"/begin PAGE 0x00 ECU_ACCESS_WITH_XCP_ONLY XCP_READ_ACCESS_WITH_ECU_ONLY XCP_WRITE_ACCESS_WITH_ECU_ONLY /end PAGE\n" +"/end SEGMENT\n" +"/end IF_DATA\n" +"/end MEMORY_SEGMENT\n"; + +//---------------------------------------------------------------------------------- +static const char* const gA2lIfDataBegin = +"\n/begin IF_DATA XCP\n"; + +//---------------------------------------------------------------------------------- +static const char* gA2lIfDataProtocolLayer = // Parameter: XCP_PROTOCOL_LAYER_VERSION, MAX_CTO, MAX_DTO +"/begin PROTOCOL_LAYER\n" +" 0x%04X" // XCP_PROTOCOL_LAYER_VERSION +" 1000 2000 0 0 0 0 0" // Timeouts T1-T7 +" %u %u " // MAX_CTO, MAX_DTO +"BYTE_ORDER_MSB_LAST ADDRESS_GRANULARITY_BYTE\n" // Intel and BYTE pointers +"OPTIONAL_CMD GET_COMM_MODE_INFO\n" // Optional commands +"OPTIONAL_CMD GET_ID\n" +"OPTIONAL_CMD SET_MTA\n" +"OPTIONAL_CMD UPLOAD\n" +"OPTIONAL_CMD SHORT_UPLOAD\n" +"OPTIONAL_CMD DOWNLOAD\n" +"OPTIONAL_CMD SHORT_DOWNLOAD\n" +#ifdef XCP_ENABLE_CAL_PAGE +"OPTIONAL_CMD GET_CAL_PAGE\n" +"OPTIONAL_CMD SET_CAL_PAGE\n" +//"OPTIONAL_CMD CC_GET_PAG_PROCESSOR_INFO\n" +//"OPTIONAL_CMD CC_GET_SEGMENT_INFO\n" +//"OPTIONAL_CMD CC_GET_PAGE_INFO\n" +//"OPTIONAL_CMD CC_SET_SEGMENT_MODE\n" +//"OPTIONAL_CMD CC_GET_SEGMENT_MODE\n" +//"OPTIONAL_CMD CC_COPY_CAL_PAGE\n" +#endif +#ifdef XCP_ENABLE_CHECKSUM +"OPTIONAL_CMD BUILD_CHECKSUM\n" +#endif +//"OPTIONAL_CMD TRANSPORT_LAYER_CMD\n" +//"OPTIONAL_CMD USER_CMD\n" +"OPTIONAL_CMD GET_DAQ_RESOLUTION_INFO\n" +"OPTIONAL_CMD GET_DAQ_PROCESSOR_INFO\n" +#ifdef XCP_ENABLE_DAQ_EVENT_INFO +"OPTIONAL_CMD GET_DAQ_EVENT_INFO\n" +#endif +//"OPTIONAL_CMD GET_DAQ_LIST_INFO\n" +"OPTIONAL_CMD FREE_DAQ\n" +"OPTIONAL_CMD ALLOC_DAQ\n" +"OPTIONAL_CMD ALLOC_ODT\n" +"OPTIONAL_CMD ALLOC_ODT_ENTRY\n" +//"OPTIONAL_CMD CLEAR_DAQ_LIST\n" +//"OPTIONAL_CMD READ_DAQ\n" +"OPTIONAL_CMD SET_DAQ_PTR\n" +"OPTIONAL_CMD WRITE_DAQ\n" +"OPTIONAL_CMD GET_DAQ_LIST_MODE\n" +"OPTIONAL_CMD SET_DAQ_LIST_MODE\n" +"OPTIONAL_CMD START_STOP_SYNCH\n" +"OPTIONAL_CMD START_STOP_DAQ_LIST\n" +"OPTIONAL_CMD GET_DAQ_CLOCK\n" +#if XCP_TRANSPORT_LAYER_TYPE == XCP_TRANSPORT_LAYER_ETH +"OPTIONAL_CMD WRITE_DAQ_MULTIPLE\n" +#if XCP_PROTOCOL_LAYER_VERSION >= 0x0103 +"OPTIONAL_CMD TIME_CORRELATION_PROPERTIES\n" +//"OPTIONAL_CMD DTO_CTR_PROPERTIES\n" +#endif +#if XCP_PROTOCOL_LAYER_VERSION >= 0x0104 +"OPTIONAL_LEVEL1_CMD GET_VERSION\n" +#ifdef XCP_ENABLE_PACKED_MODE +"OPTIONAL_LEVEL1_CMD SET_DAQ_PACKED_MODE\n" +"OPTIONAL_LEVEL1_CMD GET_DAQ_PACKED_MODE\n" +#endif +#endif +#if XCP_PROTOCOL_LAYER_VERSION >= 0x0150 +//"OPTIONAL_LEVEL1_CMD SW_DBG_COMMAND_SPACE\n" +//"OPTIONAL_LEVEL1_CMD POD_COMMAND_SPACE\n" +#endif +#endif // ETH +"/end PROTOCOL_LAYER\n" + +#if XCP_PROTOCOL_LAYER_VERSION >= 0x0103 +/* +"/begin TIME_CORRELATION\n" // TIME +"/end TIME_CORRELATION\n" +*/ +#endif +; + +//---------------------------------------------------------------------------------- +static const char* gA2lIfDataBeginDAQ = // Parameter: %u max event, %s timestamp unit +"/begin DAQ\n" +"DYNAMIC 0 %u 0 OPTIMISATION_TYPE_DEFAULT ADDRESS_EXTENSION_FREE IDENTIFICATION_FIELD_TYPE_RELATIVE_BYTE GRANULARITY_ODT_ENTRY_SIZE_DAQ_BYTE 0xF8 OVERLOAD_INDICATION_PID\n" +"/begin TIMESTAMP_SUPPORTED\n" +"0x01 SIZE_DWORD %s TIMESTAMP_FIXED\n" +"/end TIMESTAMP_SUPPORTED\n"; + +// ... Event list follows, before EndDaq + +//---------------------------------------------------------------------------------- +static const char * const gA2lIfDataEndDAQ = +"/end DAQ\n"; + + +//---------------------------------------------------------------------------------- +// XCP_ON_ETH +static const char* gA2lIfDataEth = // Parameter: %s TCP or UDP, %04X tl version, %u port, %s ip address string, %s TCP or UDP +"/begin XCP_ON_%s_IP\n" // Transport Layer +" 0x%04X %u ADDRESS \"%s\"\n" +//"OPTIONAL_TL_SUBCMD GET_SERVER_ID\n" +//"OPTIONAL_TL_SUBCMD GET_DAQ_ID\n" +//"OPTIONAL_TL_SUBCMD SET_DAQ_ID\n" +#if defined(XCPTL_ENABLE_MULTICAST) && defined(XCP_ENABLE_DAQ_CLOCK_MULTICAST) +" OPTIONAL_TL_SUBCMD GET_DAQ_CLOCK_MULTICAST\n" +#endif +"/end XCP_ON_%s_IP\n" // Transport Layer +; + +//---------------------------------------------------------------------------------- +// XCP_ON_CAN (CAN_FD not implemented yet) +static const char* gA2lIfDataCan = // Parameter: TRANSPORT_LAYER_VERSION, CRO_ID, DTO_ID, BITRATE +"/begin XCP_ON_CAN\n" // Transport Layer +" 0x%04X\n" +" CAN_ID_MASTER 0x%x\n" +" CAN_ID_SLAVE 0x%x\n" +" BAUDRATE %u\n" +" SAMPLE_POINT 0x4B\n" +" SAMPLE_RATE SINGLE\n" +" BTL_CYCLES 0x08\n" +" SJW 0x02\n" +" SYNC_EDGE SINGLE\n" +"/end XCP_ON_CAN\n"; + + +//---------------------------------------------------------------------------------- +static const char* const gA2lIfDataEnd = +"/end IF_DATA\n\n"; + + +//---------------------------------------------------------------------------------- +static const char* const gA2lFooter = + "/end MODULE\n" + "/end PROJECT\n"; + + + +#define printPhysUnit(unit) if (unit != NULL && strlen(unit) > 0) fprintf(gA2lFile, " PHYS_UNIT \"%s\"", unit); +#define printAddrExt(ext) if (ext>0) fprintf(gA2lFile, " ECU_ADDRESS_EXTENSION %u",ext); + +const char* A2lGetSymbolName(const char* instanceName, const char* name) { + static char s[256]; + if (instanceName != NULL && strlen(instanceName) > 0) { + SNPRINTF(s, 256, "%s.%s", instanceName, name); + return s; + } + else { + return name; + } +} + +static const char* getType(int32_t type) { + const char* types; + switch (type) { + case A2L_TYPE_INT8: types = "SBYTE"; break; + case A2L_TYPE_INT16: types = "SWORD"; break; + case A2L_TYPE_INT32: types = "SLONG"; break; + case A2L_TYPE_INT64: types = "A_INT64"; break; + case A2L_TYPE_UINT8: types = "UBYTE"; break; + case A2L_TYPE_UINT16: types = "UWORD"; break; + case A2L_TYPE_UINT32: types = "ULONG"; break; + case A2L_TYPE_UINT64: types = "A_UINT64"; break; + case A2L_TYPE_FLOAT: types = "FLOAT32_IEEE"; break; + case A2L_TYPE_DOUBLE: types = "FLOAT64_IEEE"; break; + default: + types = NULL; + } + return types; +} + +static const char* getTypeMin(int32_t type) { + const char* min; + switch (type) { + case A2L_TYPE_INT8: min = "-128"; break; + case A2L_TYPE_INT16: min = "-32768"; break; + case A2L_TYPE_INT32: min = "-2147483648"; break; + case A2L_TYPE_INT64: min = "-1E12"; break; + case A2L_TYPE_FLOAT: min = "-1E12"; break; + case A2L_TYPE_DOUBLE: min = "-1E12"; break; + default: min = "0"; + } + return min; +} + +static const char* getTypeMax(int32_t type) { + const char* max; + switch (type) { + case A2L_TYPE_INT8: max = "127"; break; + case A2L_TYPE_INT16: max = "32767"; break; + case A2L_TYPE_INT32: max = "2147483647"; break; + case A2L_TYPE_UINT8: max = "255"; break; + case A2L_TYPE_UINT16: max = "65535"; break; + case A2L_TYPE_UINT32: max = "4294967295"; break; + default: max = "1E12"; + } + return max; +} + +static const char* getPhysMin(int32_t type, double factor, double offset) { + double value = 0.0; + switch (type) { + case A2L_TYPE_INT8: value = -128; break; + case A2L_TYPE_INT16: value = -32768; break; + case A2L_TYPE_INT32: value = -(double)2147483648; break; + case A2L_TYPE_INT64: value = -1E12; break; + case A2L_TYPE_FLOAT: value = -1E12; break; + case A2L_TYPE_DOUBLE: value = -1E12; break; + default: value = 0.0; + } + + static char str[20]; + snprintf(str, 20, "%f", factor * value + offset); + return str; +} + +static const char* getPhysMax(int32_t type, double factor, double offset) { + double value = 0.0; + switch (type) { + case A2L_TYPE_INT8: value = 127; break; + case A2L_TYPE_INT16: value = 32767; break; + case A2L_TYPE_INT32: value = 2147483647; break; + case A2L_TYPE_UINT8: value = 255; break; + case A2L_TYPE_UINT16: value = 65535; break; + case A2L_TYPE_UINT32: value = 4294967295; break; + default: value = 1E12; + } + static char str[20]; + snprintf(str, 20, "%f", factor * value + offset); + return str; +} + + +BOOL A2lOpen(const char *filename, const char* projectName ) { + + DBG_PRINTF1("\nCreate A2L %s\n", filename); + gA2lFile = NULL; + gA2lFixedEvent = XCP_INVALID_EVENT; + gA2lMeasurements = gA2lParameters = gA2lTypedefs = gA2lInstances = gA2lConversions = gA2lComponents = 0; + gA2lFile = fopen(filename, "w"); + if (gA2lFile == 0) { + DBG_PRINTF_ERROR("ERROR: Could not create A2L file %s!\n", filename); + return FALSE; + } + + // Create header + fprintf(gA2lFile, gA2lHeader, projectName, projectName); + + // Create standard record layouts for elementary types + for (int i = -10; i <= +10; i++) { + const char* t = getType(i); + if (t != NULL) { + fprintf(gA2lFile, "/begin RECORD_LAYOUT R_%s FNC_VALUES 1 %s ROW_DIR DIRECT /end RECORD_LAYOUT\n", t, t); + fprintf(gA2lFile, "/begin TYPEDEF_MEASUREMENT M_%s \"\" %s NO_COMPU_METHOD 0 0 %s %s /end TYPEDEF_MEASUREMENT\n", t, t, getTypeMin(i), getTypeMax(i)); + fprintf(gA2lFile, "/begin TYPEDEF_CHARACTERISTIC C_%s \"\" VALUE R_%s 0 NO_COMPU_METHOD %s %s /end TYPEDEF_CHARACTERISTIC\n", t, t, getTypeMin(i), getTypeMax(i)); + } + } + fprintf(gA2lFile, "\n"); + + return TRUE; +} + +// Memory segments +void A2lCreate_MOD_PAR(uint32_t startAddr, uint32_t size, char *epk) { + + assert(gA2lFile != NULL); + fprintf(gA2lFile, "/begin MOD_PAR \"\"\n"); + fprintf(gA2lFile, "EPK \"%s\"\n", epk); + fprintf(gA2lFile, "ADDR_EPK 0x%08X\n", ApplXcpGetAddr((uint8_t*)epk)); + fprintf(gA2lFile, gA2lMemorySegment, startAddr, size); + DBG_PRINTF1(" A2L MOD_PAR MEMORY_SEGMENT 1: 0x%08X %u\n", startAddr, size); + fprintf(gA2lFile, "/end MOD_PAR\n\n"); +#if OPTION_ENABLE_DBG_PRINTS + if (epk) DBG_PRINTF1(" A2L MOD_PAR EPK \"%s\" 0x%08X\n", epk, ApplXcpGetAddr((uint8_t*)epk)); +#endif +} + + +static void A2lCreate_IF_DATA_DAQ() { + + assert(gA2lFile != NULL); + +#if defined( XCP_ENABLE_DAQ_EVENT_LIST ) && !defined( XCP_ENABLE_DAQ_EVENT_INFO ) + tXcpEvent* eventList; +#endif + uint16_t eventCount = 0; + +#if (XCP_TIMESTAMP_UNIT==DAQ_TIMESTAMP_UNIT_1NS) +#define XCP_TIMESTAMP_UNIT_S "UNIT_1NS" +#elif (XCP_TIMESTAMP_UNIT==DAQ_TIMESTAMP_UNIT_1US) +#define XCP_TIMESTAMP_UNIT_S "UNIT_1US" +#else +#error +#endif + + // Event list in A2L file (if event info by XCP is not active) +#if defined( XCP_ENABLE_DAQ_EVENT_LIST ) && !defined( XCP_ENABLE_DAQ_EVENT_INFO ) + eventList = XcpGetEventList(&eventCount); +#endif + + fprintf(gA2lFile, gA2lIfDataBeginDAQ, eventCount, XCP_TIMESTAMP_UNIT_S); + + // Eventlist +#if defined( XCP_ENABLE_DAQ_EVENT_LIST ) && !defined( XCP_ENABLE_DAQ_EVENT_INFO ) + for (uint32_t i = 0; i < eventCount; i++) { + + fprintf(gA2lFile, "/begin EVENT \"%s\" \"%s\" 0x%X DAQ 0xFF %u %u %u CONSISTENCY EVENT", eventList[i].shortName, eventList[i].shortName, i, eventList[i].timeCycle, eventList[i].timeUnit, eventList[i].priority); +#ifdef XCP_ENABLE_PACKED_MODE + if (eventList[i].sampleCount != 0) { + fprintf(gA2lFile, " /begin DAQ_PACKED_MODE ELEMENT_GROUPED STS_LAST MANDATORY %u /end DAQ_PACKED_MODE", eventList[i].sampleCount); + } +#endif + fprintf(gA2lFile, " /end EVENT\n"); + } +#endif + + fprintf(gA2lFile, gA2lIfDataEndDAQ); + +} + +void A2lCreate_ETH_IF_DATA(BOOL useTCP, const uint8_t* addr, uint16_t port) { + + fprintf(gA2lFile, gA2lIfDataBegin); + + // Protocol Layer info + fprintf(gA2lFile, gA2lIfDataProtocolLayer, XCP_PROTOCOL_LAYER_VERSION, XCPTL_MAX_CTO_SIZE, XCPTL_MAX_DTO_SIZE); + + // DAQ info + A2lCreate_IF_DATA_DAQ(); + + // Transport Layer info + uint8_t addr0[] = { 127,0,0,1 }; // Use localhost if no other option + if (addr != NULL && addr[0] != 0) { + memcpy(addr0, addr, 4); + } else { + socketGetLocalAddr(NULL, addr0); + } + char addrs[17]; + SPRINTF(addrs, "%u.%u.%u.%u", addr0[0], addr0[1], addr0[2], addr0[3]); + char* prot = useTCP ? (char*)"TCP" : (char*)"UDP"; + fprintf(gA2lFile, gA2lIfDataEth, prot, XCP_TRANSPORT_LAYER_VERSION, port, addrs, prot); + + fprintf(gA2lFile, gA2lIfDataEnd); + + DBG_PRINTF1(" IF_DATA XCP_ON_%s, ip=%s, port=%u\n", prot, addrs, port); +} + +void A2lCreate_CAN_IF_DATA(BOOL useCANFD, uint16_t croId, uint16_t dtoId, uint32_t bitRate) { + + (void)useCANFD; + + fprintf(gA2lFile, gA2lIfDataBegin); + + // Protocol Layer info + fprintf(gA2lFile, gA2lIfDataProtocolLayer, XCP_PROTOCOL_LAYER_VERSION, XCPTL_MAX_CTO_SIZE, XCPTL_MAX_DTO_SIZE); + + // DAQ info + A2lCreate_IF_DATA_DAQ(); + + // Transport Layer info + uint32_t _croId = croId; + uint32_t _dtoId = dtoId; + if (useCANFD) { + _croId |= 0x40000000; + _dtoId |= 0x40000000; + } + fprintf(gA2lFile, gA2lIfDataCan, XCP_TRANSPORT_LAYER_VERSION, _croId, _dtoId, bitRate); + + fprintf(gA2lFile, gA2lIfDataEnd); + + DBG_PRINTF1(" IF_DATA XCP_ON_CAN, CRO=%u, DTO=%u, BITRATE=%u\n", croId, dtoId, bitRate); +} + + +void A2lCreateMeasurement_IF_DATA() { + + assert(gA2lFile != NULL); + if (gA2lFixedEvent != XCP_INVALID_EVENT) { + fprintf(gA2lFile, " /begin IF_DATA XCP /begin DAQ_EVENT FIXED_EVENT_LIST EVENT 0x%X /end DAQ_EVENT /end IF_DATA", gA2lFixedEvent); + } + else if (gA2lDefaultEvent != XCP_INVALID_EVENT) { + fprintf(gA2lFile, " /begin IF_DATA XCP /begin DAQ_EVENT VARIABLE DEFAULT_EVENT_LIST EVENT 0x%X /end DAQ_EVENT /end IF_DATA", gA2lDefaultEvent); + } +} + + +void A2lSetDefaultEvent(uint16_t event) { + +#if defined( XCP_ENABLE_DAQ_EVENT_LIST ) && !defined( XCP_ENABLE_DAQ_EVENT_INFO ) + uint16_t eventCount = 0; + XcpGetEventList(&eventCount); + assert(event >= 0 && event < eventCount); +#endif + + A2lRstFixedEvent(); + gA2lDefaultEvent = event; +} + +void A2lSetFixedEvent(uint16_t event) { + +#if defined( XCP_ENABLE_DAQ_EVENT_LIST ) && !defined( XCP_ENABLE_DAQ_EVENT_INFO ) + uint16_t eventCount = 0; + XcpGetEventList(&eventCount); + assert(event >= 0 && event < eventCount); +#endif + + gA2lFixedEvent = event; +} + +uint16_t A2lGetFixedEvent() { + return gA2lFixedEvent; +} + +void A2lRstDefaultEvent() { + gA2lDefaultEvent = XCP_INVALID_EVENT; +} + +void A2lRstFixedEvent() { + gA2lFixedEvent = XCP_INVALID_EVENT; +} + + +void A2lTypedefBegin_(const char* name, uint32_t size, const char* comment) { + + assert(gA2lFile != NULL); + fprintf(gA2lFile,"/begin TYPEDEF_STRUCTURE %s \"%s\" 0x%X SYMBOL_TYPE_LINK \"%s\"\n", name, comment, size, name); + gA2lTypedefs++; +} + +void A2lTypedefMeasurementComponent_(const char* name, int32_t type, uint32_t offset) { + + assert(gA2lFile != NULL); + fprintf(gA2lFile, " /begin STRUCTURE_COMPONENT %s M_%s 0x%X SYMBOL_TYPE_LINK \"%s\" /end STRUCTURE_COMPONENT\n", name, getType(type), offset, name); + gA2lComponents++; +} + +void A2lTypedefParameterComponent_(const char* name, int32_t type, uint32_t offset) { + + assert(gA2lFile != NULL); + fprintf(gA2lFile, " /begin STRUCTURE_COMPONENT %s C_%s 0x%X SYMBOL_TYPE_LINK \"%s\" /end STRUCTURE_COMPONENT\n", name, getType(type), offset, name); + gA2lComponents++; +} + +void A2lTypedefEnd_() { + + assert(gA2lFile != NULL); + fprintf(gA2lFile,"/end TYPEDEF_STRUCTURE\n"); +} + + +void A2lCreateTypedefInstance_(const char* instanceName, const char* typeName, uint8_t ext, uint32_t addr, const char* comment) { + + assert(gA2lFile != NULL); + fprintf(gA2lFile, "/begin INSTANCE %s \"%s\" %s 0x%X", instanceName, comment, typeName, addr); + printAddrExt(ext); + A2lCreateMeasurement_IF_DATA(); + fprintf(gA2lFile, " /end INSTANCE\n"); + gA2lInstances++; + +} + + +void A2lCreateMeasurement_(const char* instanceName, const char* name, int32_t type, uint8_t ext, uint32_t addr, double factor, double offset, const char* unit, const char* comment) { + + assert(gA2lFile != NULL); +#ifdef A2L_ENABLE_MEMORY_CHECK + mem_check(name, type, ext, addr); +#endif + if (unit == NULL) unit = ""; + if (comment == NULL) comment = ""; + const char *conv = "NO"; + if (factor != 0.0 || offset != 0.0) { + fprintf(gA2lFile, "/begin COMPU_METHOD %s.Conversion \"\" LINEAR \"%%6.3\" \"%s\" COEFFS_LINEAR %g %g /end COMPU_METHOD\n", name, unit!=NULL?unit:"", factor,offset); + conv = name; + gA2lConversions++; + } + + //fprintf(gA2lFile, "/begin MEASUREMENT %s \"%s\" %s %s.Conversion 0 0 %s %s ECU_ADDRESS 0x%X", A2lGetSymbolName(instanceName, name), comment, getType(type), conv, getTypeMin(type), getTypeMax(type), addr); + fprintf(gA2lFile, "/begin MEASUREMENT %s \"%s\" %s %s.Conversion 0 0 %s %s ECU_ADDRESS 0x%X", A2lGetSymbolName(instanceName, name), comment, getType(type), conv, getPhysMin(type, factor, offset), getPhysMax(type, factor, offset), addr); + printAddrExt(ext); + printPhysUnit(unit); + fprintf(gA2lFile, " READ_WRITE"); +#if OPTION_ENABLE_A2L_SYMBOL_LINKS + fprintf(gA2lFile, " SYMBOL_LINK \"%s\" %u", A2lGetSymbolName(instanceName, name), 0); +#else + (void)symbolLink; +#endif + A2lCreateMeasurement_IF_DATA(); + fprintf(gA2lFile, " /end MEASUREMENT\n"); + gA2lMeasurements++; +} + + +void A2lCreateMeasurementArray_(const char* instanceName, const char* name, int32_t type, int dim, uint8_t ext, uint32_t addr) { + + assert(gA2lFile != NULL); + fprintf(gA2lFile, "/begin CHARACTERISTIC %s \"\" VAL_BLK 0x%X R_%s 0 NO_COMPU_METHOD %s %s MATRIX_DIM %u", A2lGetSymbolName(instanceName, name), addr, getType(type), getTypeMin(type), getTypeMax(type), dim); + printAddrExt(ext); +#if OPTION_ENABLE_A2L_SYMBOL_LINKS + fprintf(gA2lFile, " SYMBOL_LINK \"%s\" %u", A2lGetSymbolName(instanceName, name), 0); +#endif + A2lCreateMeasurement_IF_DATA(); + fprintf(gA2lFile, " /end CHARACTERISTIC\n"); + gA2lMeasurements++; +} + + +void A2lCreateParameterWithLimits_(const char* name, int32_t type, uint8_t ext, uint32_t addr, const char* comment, const char* unit, double min, double max) { + + assert(gA2lFile != NULL); + fprintf(gA2lFile, "/begin CHARACTERISTIC %s \"%s\" VALUE 0x%X R_%s 0 NO_COMPU_METHOD %g %g", name, comment, addr, getType(type), min, max); + printPhysUnit(unit); + printAddrExt(ext); +#if OPTION_ENABLE_A2L_SYMBOL_LINKS + fprintf(gA2lFile, " SYMBOL_LINK \"%s\" %u", name, 0); +#endif + fprintf(gA2lFile, " /end CHARACTERISTIC\n"); + gA2lParameters++; +} + +void A2lCreateParameter_(const char* name, int32_t type, uint8_t ext, uint32_t addr, const char* comment, const char* unit) { + + assert(gA2lFile != NULL); + fprintf(gA2lFile, "/begin CHARACTERISTIC %s \"%s\" VALUE 0x%X R_%s 0 NO_COMPU_METHOD %s %s", name, comment, addr, getType(type), getTypeMin(type), getTypeMax(type)); + printPhysUnit(unit); + printAddrExt(ext); +#if OPTION_ENABLE_A2L_SYMBOL_LINKS + fprintf(gA2lFile, " SYMBOL_LINK \"%s\" %u", name, 0); +#endif + fprintf(gA2lFile, " /end CHARACTERISTIC\n"); + gA2lParameters++; +} + +void A2lCreateMap_(const char* name, int32_t type, uint8_t ext, uint32_t addr, uint32_t xdim, uint32_t ydim, const char* comment, const char* unit) { + + assert(gA2lFile != NULL); + fprintf(gA2lFile, + "/begin CHARACTERISTIC %s \"%s\" MAP 0x%X R_%s 0 NO_COMPU_METHOD %s %s" + " /begin AXIS_DESCR FIX_AXIS NO_INPUT_QUANTITY NO_COMPU_METHOD %u 0 %u FIX_AXIS_PAR_DIST 0 1 %u /end AXIS_DESCR" + " /begin AXIS_DESCR FIX_AXIS NO_INPUT_QUANTITY NO_COMPU_METHOD %u 0 %u FIX_AXIS_PAR_DIST 0 1 %u /end AXIS_DESCR", + name, comment, addr, getType(type), getTypeMin(type), getTypeMax(type), xdim, xdim-1, xdim, ydim, ydim-1, ydim); + printPhysUnit(unit); + printAddrExt(ext); +#if OPTION_ENABLE_A2L_SYMBOL_LINKS + fprintf(gA2lFile, " SYMBOL_LINK \"%s\" %u", name, 0); +#endif + fprintf(gA2lFile, " /end CHARACTERISTIC\n"); + gA2lParameters++; +} + +void A2lCreateCurve_(const char* name, int32_t type, uint8_t ext, uint32_t addr, uint32_t xdim, const char* comment, const char* unit) { + + assert(gA2lFile != NULL); + fprintf(gA2lFile, + "/begin CHARACTERISTIC %s \"%s\" CURVE 0x%X R_%s 0 NO_COMPU_METHOD %s %s" + " /begin AXIS_DESCR FIX_AXIS NO_INPUT_QUANTITY NO_COMPU_METHOD %u 0 %u FIX_AXIS_PAR_DIST 0 1 %u /end AXIS_DESCR", + name, comment, addr, getType(type), getTypeMin(type), getTypeMax(type), xdim, xdim-1, xdim); + printPhysUnit(unit); + printAddrExt(ext); +#if OPTION_ENABLE_A2L_SYMBOL_LINKS + fprintf(gA2lFile, " SYMBOL_LINK \"%s\" %u", name, 0); +#endif + fprintf(gA2lFile, " /end CHARACTERISTIC\n"); + gA2lParameters++; +} + + +void A2lParameterGroup(const char* name, int count, ...) { + + va_list ap; + + assert(gA2lFile != NULL); + fprintf(gA2lFile, "/begin GROUP %s \"\"", name); + fprintf(gA2lFile, " /begin REF_CHARACTERISTIC\n"); + va_start(ap, count); + for (int i = 0; i < count; i++) { + fprintf(gA2lFile, " %s", va_arg(ap, char*)); + } + va_end(ap); + fprintf(gA2lFile, "\n/end REF_CHARACTERISTIC "); + fprintf(gA2lFile, "/end GROUP\n\n"); +} + + +void A2lParameterGroupFromList(const char* name, const char* pNames[], size_t count) { + + assert(gA2lFile != NULL); + fprintf(gA2lFile, "/begin GROUP %s \"\"", name); + fprintf(gA2lFile, " /begin REF_CHARACTERISTIC\n"); + for (size_t i = 0; i < count; i++) { + fprintf(gA2lFile, " %s", pNames[i]); + } + fprintf(gA2lFile, "\n/end REF_CHARACTERISTIC "); + fprintf(gA2lFile, "/end GROUP\n\n"); +} + + +void A2lMeasurementGroup(const char* name, int count, ...) { + + va_list ap; + + assert(gA2lFile != NULL); + fprintf(gA2lFile, "/begin GROUP %s \"\"", name); + fprintf(gA2lFile, " /begin REF_MEASUREMENT"); + va_start(ap, count); + for (int i = 0; i < count; i++) { + fprintf(gA2lFile, " %s", va_arg(ap, char*)); + } + va_end(ap); + fprintf(gA2lFile, " /end REF_MEASUREMENT"); + fprintf(gA2lFile, " /end GROUP\n\n"); +} + + +void A2lMeasurementGroupFromList(const char *name, char* names[], uint32_t count) { + + assert(gA2lFile != NULL); + fprintf(gA2lFile, "/begin GROUP %s \"\" \n", name); + fprintf(gA2lFile, " /begin REF_MEASUREMENT"); + for (uint32_t i1 = 0; i1 < count; i1++) { + fprintf(gA2lFile, " %s", names[i1]); + } + fprintf(gA2lFile, " /end REF_MEASUREMENT"); + fprintf(gA2lFile, "\n/end GROUP\n"); +} + + +void A2lClose() { + + if (gA2lFile != NULL) { + fprintf(gA2lFile, "%s", gA2lFooter); + fclose(gA2lFile); + gA2lFile = NULL; + DBG_PRINTF1("A2L created: %u measurements, %u params, %u typedefs, %u components, %u instances, %u conversions\n\n", + gA2lMeasurements, gA2lParameters, gA2lTypedefs, gA2lComponents, gA2lInstances, gA2lConversions); + } +} + + + + diff --git a/A2lTestDlg/A2lTestDlg/A2L.h b/A2lTestDlg/A2lTestDlg/A2L.h new file mode 100644 index 0000000..a839827 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2L.h @@ -0,0 +1,121 @@ +#pragma once +/* A2L.h */ + +/* Copyright(c) Vector Informatik GmbH.All rights reserved. + Licensed under the MIT license.See LICENSE file in the project root for details. */ + +#define OPTION_ENABLE_A2L_SYMBOL_LINKS ON // Enable generation of symbol links (required for CANape integrated linker map update) + + +#define A2L_TYPE_UINT8 1 +#define A2L_TYPE_UINT16 2 +#define A2L_TYPE_UINT32 4 +#define A2L_TYPE_UINT64 8 +#define A2L_TYPE_INT8 -1 +#define A2L_TYPE_INT16 -2 +#define A2L_TYPE_INT32 -4 +#define A2L_TYPE_INT64 -8 +#define A2L_TYPE_FLOAT -9 +#define A2L_TYPE_DOUBLE -10 + +#define A2L_TYPE_BOOL sizeof(BOOL) + +#ifndef A2lGetAddr + #define A2lGetAddr(p) ApplXcpGetAddr(p) +#endif + +#ifdef __cplusplus + +#include + +#ifndef A2lGetType +#define A2lGetSign_(var) ((int)(typeid(var).name()[0]=='u'?+1:-1)) +#define A2lGetType(var) (A2lGetSign_(var)*(typeid(var).name()[0]=='f'?9:typeid(var).name()[0]=='d'?10:sizeof(var))) +#endif +#ifndef A2lGetOffset +#define A2lGetOffset(var) (uint32_t)((uint8_t*)&(var) - (uint8_t*)this) +#endif + + // Create parameters +#define A2lCreateParameter(name,comment,unit) A2lCreateParameter_(#name, A2lGetType(name), 0, A2lGetAddr((uint8_t*)&name), comment, unit) +#define A2lCreateParameterWithLimits(name,comment,unit,min,max) A2lCreateParameterWithLimits_(#name, A2lGetType(name), 0, A2lGetAddr((uint8_t*)&name), comment, unit, min, max) +#define A2lCreateCurve(name,xdim,comment,unit) A2lCreateCurve_(#name, A2lGetType(name[0]), 0, A2lGetAddr((uint8_t*)&name[0]), xdim, comment, unit) +#define A2lCreateMap(name,xdim,ydim,comment,unit) A2lCreateMap_(#name, A2lGetType(name[0][0]), 0, A2lGetAddr((uint8_t*)&name[0][0]), xdim, ydim, comment, unit) + +// Create measurements +#define A2lCreateMeasurement(name,comment) A2lCreateMeasurement_(NULL, #name, A2lGetType(name), 0, A2lGetAddr((uint8_t*)&(name)), 1.0, 0.0, NULL, comment) +#define A2lCreatePhysMeasurement(name,comment,factor,offset,unit) A2lCreateMeasurement_(NULL, #name, A2lGetType(name), 0, A2lGetAddr((uint8_t*)&name), factor, offset, unit, comment) // unsigned integer (8/16/32) with linear physical conversion rule +#define A2lCreateMeasurementArray(name) A2lCreateMeasurementArray_(NULL,#name, A2lGetType(name[0]), sizeof(name)/sizeof(name[0]), 0, A2lGetAddr((uint8_t*)&name[0])) // unsigned integer (8/16/32) or double array + +// Create typedefs +#define A2lTypedefComponent(name) A2lTypedefMeasurementComponent_(#name, A2lGetType(name), A2lGetOffset(name)) + +#else + +// Create parameters +#define A2lCreateParameter(name,type,comment,unit) A2lCreateParameter_(#name, type, 0, A2lGetAddr((uint8_t*)&name), comment, unit) +#define A2lCreateParameterWithLimits(name,type,comment,unit,min,max) A2lCreateParameterWithLimits_(#name, type, 0, A2lGetAddr((uint8_t*)&name), comment, unit, min, max) +#define A2lCreateCurve(name,type,xdim,comment,unit) A2lCreateCurve_(#name, type, 0, A2lGetAddr((uint8_t*)&name[0]), xdim, comment, unit) +#define A2lCreateMap(name,type,xdim,ydim,comment,unit) A2lCreateMap_(#name, type, 0, A2lGetAddr((uint8_t*)&name[0][0]), xdim, ydim, comment, unit) + +// Create measurements +#define A2lCreateMeasurement(name,type,comment) A2lCreateMeasurement_(NULL,#name,type, 0, A2lGetAddr((uint8_t*)&(name)), 1.0, 0.0, NULL, comment) +#define A2lCreatePhysMeasurement(name,type,comment,factor,offset,unit) A2lCreateMeasurement_(NULL, #name,type, 0, A2lGetAddr((uint8_t*)&name), factor, offset, unit, comment) // unsigned integer (8/16/32) with linear physical conversion rule +#define A2lCreateMeasurementArray(name,type) A2lCreateMeasurementArray_(NULL, #name, type, sizeof(name)/sizeof(name[0]), 0, A2lGetAddr((uint8_t*)&name[0])) // unsigned integer (8/16/32) or double array + +// Create typedefs +#define A2lTypedefComponent(name,type,offset) A2lTypedefMeasurementComponent_(#name, type, offset) + +#endif + +#define A2lTypedefBegin(name,comment) A2lTypedefBegin_(#name,(uint32_t)sizeof(name),comment) +#define A2lTypedefEnd() A2lTypedefEnd_() +#define A2lCreateTypedefInstance(instanceName, typeName, addr, comment) A2lCreateTypedefInstance_(instanceName, typeName, 0, A2lGetAddr((uint8_t*)&instanceName), comment) +#define A2lCreateDynTypedefInstance(instanceName, typeName, comment) A2lCreateTypedefInstance_(instanceName, typeName, 1, 0, comment) + +// Init A2L generation +extern BOOL A2lOpen(const char *filename, const char* projectName); + +// Create memory segments +extern void A2lCreate_MOD_PAR( uint32_t startAddr, uint32_t size, char* epk); + +// Create XCP IF_DATA +extern void A2lCreate_ETH_IF_DATA(BOOL useTCP, const uint8_t* addr, uint16_t port); +extern void A2lCreate_CAN_IF_DATA(BOOL useCANFD, uint16_t croId, uint16_t dtoId, uint32_t bitRate); + +// Set fixec or default event for all following creates +extern void A2lSetFixedEvent(uint16_t event); +extern void A2lRstFixedEvent(); +extern void A2lSetDefaultEvent(uint16_t event); +extern void A2lRstDefaultEvent(); + +// Create measurements +extern void A2lCreateMeasurement_(const char* instanceName, const char* name, int32_t type, uint8_t ext, uint32_t addr, double factor, double offset, const char* unit, const char* comment); +extern void A2lCreateMeasurementArray_(const char* instanceName, const char* name, int32_t type, int dim, uint8_t ext, uint32_t addr); + +// Create typedefs +void A2lTypedefBegin_(const char* name, uint32_t size, const char* comment); +void A2lTypedefMeasurementComponent_(const char* name, int32_t type, uint32_t offset); +void A2lTypedefParameterComponent_(const char* name, int32_t type, uint32_t offset); +void A2lTypedefEnd_(); +void A2lCreateTypedefInstance_(const char* instanceName, const char* typeName, uint8_t ext, uint32_t addr, const char* comment); + +// Create parameters +void A2lCreateParameter_(const char* name, int32_t type, uint8_t ext, uint32_t addr, const char* comment, const char* unit); +void A2lCreateParameterWithLimits_(const char* name, int32_t type, uint8_t ext, uint32_t addr, const char* comment, const char* unit, double min, double max); +void A2lCreateMap_(const char* name, int32_t type, uint8_t ext, uint32_t addr, uint32_t xdim, uint32_t ydim, const char* comment, const char* unit); +void A2lCreateCurve_(const char* name, int32_t type, uint8_t ext, uint32_t addr, uint32_t xdim, const char* comment, const char* unit); + +// Create groups +void A2lParameterGroup(const char* name, int count, ...); +void A2lParameterGroupFromList(const char* name, const char* pNames[], size_t count); +void A2lMeasurementGroup(const char* name, int count, ...); +void A2lMeasurementGroupFromList(const char *name, char* names[], uint32_t count); + +// Finish A2L generation +extern void A2lClose(); + + +// For A2L.CPP +extern const char* A2lGetSymbolName(const char* instanceName, const char* name); +extern uint16_t A2lGetFixedEvent(); diff --git a/A2lTestDlg/A2lTestDlg/A2Lpp.cpp b/A2lTestDlg/A2lTestDlg/A2Lpp.cpp new file mode 100644 index 0000000..5f832b7 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2Lpp.cpp @@ -0,0 +1,124 @@ +/*---------------------------------------------------------------------------- +| File: +| A2L.cpp +| +| Description: +| Create A2L file +| +| Copyright (c) Vector Informatik GmbH. All rights reserved. +| Licensed under the MIT license. See LICENSE file in the project root for details. +| + ----------------------------------------------------------------------------*/ + +#include "main.h" +#include "platform.h" +#include "xcp.hpp" +#include "A2L.h" +#include "A2Lpp.hpp" + + //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + A2L::A2L(const char * name) { + + filename = name; + } + + A2L::~A2L() { + + close(); + } + +void A2L::close() { + + A2lClose(); + } + +BOOL A2L::open(const char *projectName) { + + return A2lOpen(filename, projectName); +} + +// Create memory segments +void A2L::create_MOD_PAR(uint32_t startAddr, uint32_t size) { + A2lCreate_MOD_PAR(startAddr, size, NULL); +} + +// Create XCP IF_DATA +void A2L::create_XCP_IF_DATA(BOOL tcp, const uint8_t* addr, uint16_t port) { + + A2lCreate_ETH_IF_DATA(tcp, addr, port); +} + + +//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + +void A2L::setDefaultEvent(uint16_t e) { + A2lSetDefaultEvent(e); +} + +void A2L::setFixedEvent(uint16_t e) { + A2lSetFixedEvent(e); +} + +void A2L::rstFixedEvent() { + A2lRstFixedEvent(); +} + +uint16_t A2L::getFixedEvent() { + return A2lGetFixedEvent(); +} + + //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + void A2L::createTypedefBegin_(const char* name, int32_t size, const char* comment) { + A2lTypedefBegin_(name,size,comment); +} + + void A2L::createTypedefMeasurementComponent_(const char* name, int32_t type, uint32_t offset) { + A2lTypedefMeasurementComponent_(name,type,offset); + } + + void A2L::createTypedefParameterComponent_(const char* name, int32_t type, uint32_t offset) { + A2lTypedefParameterComponent_(name, type, offset); + } + + void A2L::createTypedefEnd_() { + A2lTypedefEnd_(); +} + + + void A2L::createTypedefInstance_(const char* instanceName, const char* typeName, uint8_t ext, uint32_t addr, const char* comment) { + A2lCreateTypedefInstance_(instanceName, typeName, ext, addr, comment); +} + + //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + void A2L::createMeasurement_(const char* instanceName, const char* name, int32_t type, uint8_t ext, uint32_t addr, double factor, double offset, const char* unit, const char* comment) { + A2lCreateMeasurement_(instanceName, name, type, ext, addr, factor, offset, unit, comment); +} + + void A2L::createMeasurementArray_(const char* instanceName, const char* name, int32_t type, int dim, uint8_t ext, uint32_t addr) { + A2lCreateMeasurementArray_(instanceName, name, type, dim, ext, addr); +} + + //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + void A2L::createParameterWithLimits_(const char* instanceName, const char* name, int32_t type, uint8_t ext, uint32_t addr, const char* comment, const char* unit, double min, double max) { + A2lCreateParameterWithLimits_(A2lGetSymbolName(instanceName, name), type, ext, addr, comment, unit, min, max); +} + + + void A2L::createParameter_(const char* instanceName, const char* name, int32_t type, uint8_t ext, uint32_t addr, const char* comment, const char* unit) { + A2lCreateParameter_(A2lGetSymbolName(instanceName, name), type, ext, addr, comment, unit); +} + + void A2L::createMap_(const char* instanceName, const char* name, int32_t type, uint8_t ext, uint32_t addr, uint32_t xdim, uint32_t ydim, const char* comment, const char* unit) { + A2lCreateMap_(A2lGetSymbolName(instanceName, name), type, ext, addr, xdim, ydim, comment, unit); +} + + void A2L::createCurve_(const char* instanceName, const char* name, int32_t type, uint8_t ext, uint32_t addr, uint32_t xdim, const char* comment, const char* unit) { + A2lCreateCurve_(A2lGetSymbolName(instanceName, name), type, ext, addr, xdim, comment, unit); +} + + + \ No newline at end of file diff --git a/A2lTestDlg/A2lTestDlg/A2Lpp.hpp b/A2lTestDlg/A2lTestDlg/A2Lpp.hpp new file mode 100644 index 0000000..c9ccb42 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2Lpp.hpp @@ -0,0 +1,122 @@ +#pragma once +/* A2L.h - A2L Generator */ + +/* Copyright(c) Vector Informatik GmbH.All rights reserved. + Licensed under the MIT license.See LICENSE file in the project root for details. */ + +#ifndef __cplusplus +#error +#endif + +#include "A2L.h" + + +#define A2lGetSign_(var) ((int)(typeid(var).name()[0]=='u'?+1:-1)) +#define A2lGetType_(var) (A2lGetSign_(var)*(typeid(var).name()[0]=='f'?9:typeid(var).name()[0]=='d'?10:sizeof(var))) +#define A2lGetAddr_(var) Xcp::getInstance()->getA2lAddr((uint8_t*)&var) +#define A2lGetOffset_(struct_name,full_name) (uint16_t)((uint8_t*)&(full_name) - (uint8_t*)&struct_name) + + +//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + +// Create typedefs +#define createTypedefBegin(name,comment) createTypedefBegin_(#name,(int)sizeof(name),comment) +#define createTypedefParameterComponent(struct_name,var_name) createTypedefParameterComponent_(#var_name,A2lGetType_(struct_name.var_name),A2lGetOffset_(struct_name,struct_name.var_name)) +#define createTypedefMeasurementComponent(struct_name,var_name) createTypedefMeasurementComponent_(#var_name,A2lGetType_(struct_name.var_name),A2lGetOffset_(struct_name,struct_name.var_name)) +#define createTypedefEnd() createTypedefEnd_() + +// Create measurement or parameter from typedef +#define createTypedefInstance(instanceName,typeName,comment) createTypedefInstance_(#instanceName, #typeName, 0, A2lGetAddr_(instanceName), comment) + +// Create measurements +#define createMeasurement(name,comment) createMeasurement_(NULL,#name,A2lGetType_(name),0,A2lGetAddr_(name),1.0,0.0,NULL,comment) +#define createPhysMeasurement(name,comment,factor,offset,unit) createMeasurement_(NULL,#name,A2lGetType_(name),0,A2lGetAddr_(name),factor,offset,unit,comment) // unsigned integer (8/16/32) with linear physical conversion rule +#define createMeasurementArray(name) createMeasurementArray_(NULL,#name,A2lGetType_(name[0]),sizeof(name)/sizeof(name[0]),0,A2lGetAddr_(name[0])) // unsigned integer (8/16/32) or double array + +// Create parameters +#define createParameter(name,comment,unit) createParameter_(NULL,#name,A2lGetType_(name),0,A2lGetAddr_(name),comment,unit) +#define createParameterWithLimits(name,comment,unit,min,max) createParameterWithLimits_(NULL,#name, A2lGetType_(name), 0, A2lGetAddr_(name), comment, unit, min, max) +#define createCurve(name,xdim,comment,unit) createCurve_(NULL,#name, A2lGetType_(name[0]), 0, A2lGetAddr_(name[0]), xdim, comment, unit) +#define createMap(name,xdim,ydim,comment,unit) createMap_(NULL,#name, A2lGetType_(name[0][0]), 0, A2lGetAddr_(name[0][0]), xdim, ydim, comment, unit) + + +//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + +// The functions below are assumed to be called from methods of classes derived from XcpObject ! + +#define A2lGetDynAddr_(var) xcpGetA2lDynAddr(A2lGetDynOffset_(var)) +#define A2lGetDynBaseAddr_() xcpGetA2lDynAddr(0) +#define A2lGetDynOffset_(var) (uint16_t)((uint8_t*)&(var) - (uint8_t*)this) // object data size limited to 64K ! + +// Create measurement or parameter from typedef +#define createDynTypedefInstance(instanceName,typeName,comment) createTypedefInstance_(instanceName, typeName, 1, A2lGetDynBaseAddr_(), comment) +#define createDynTypedefParameterComponent(name) createTypedefParameterComponent_(#name,A2lGetType_(name),A2lGetDynOffset_(name)) +#define createDynTypedefMeasurementComponent(name) createTypedefMeasurementComponent_(#name,A2lGetType_(name),A2lGetDynOffset_(name)) + +// Create measurements +#define createDynMeasurement(instanceName,name,comment) createMeasurement_(instanceName,#name,A2lGetType_(name),1,A2lGetDynAddr_(name),1.0,0.0,NULL,comment) +#define createDynPhysMeasurement(instanceName,name,var,comment,factor,offset,unit) createMeasurement_(instanceName,name,A2lGetType_(var),1,A2lGetDynAddr_(name),factor,offset,unit,comment) // named unsigned integer (8/16/32) with linear physical conversion rule +#define createDynMeasurementArray(name) createMeasurementArray_(NULL,#name,A2lGetType_(name[0]),sizeof(name)/sizeof(name[0]),0,A2lGetDynAddr_(name[0])) // unsigned integer (8/16/32) or double array + +// Create parameters +#define createDynParameter(instanceName,name,comment,unit) createParameter_(instanceName,#name,A2lGetType_(name),1,A2lGetDynAddr_(name),comment,unit) +#define createDynParameterWithLimits(instanceName,name,comment,unit,min,max) createParameterWithLimits_(instanceName,#name, A2lGetType_(name), 1, A2lGetDynAddr_(name), comment, unit, min, max) +#define createDynCurve(instanceName,name,xdim,comment,unit) createCurve_(instanceName,#name, A2lGetType_(name[0]), 0, A2lGetDynAddr_(name[0]), xdim, comment, unit) +#define createDynMap(instanceName,name,xdim,ydim,comment,unit) createMap_(instanceName,#name, A2lGetType_(name[0][0]), 1, A2lGetDynAddr_(name[0][0]), xdim, ydim, comment, unit) + + + + +//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +class A2L { + +private: + + const char* filename; + +public: + + + A2L(const char* filename); + ~A2L(); + + // Start A2L generation + BOOL open(const char* projectName); + + // Create memory segments + void create_MOD_PAR(uint32_t startAddr, uint32_t size); + + // Create IF_DATA for XCP + // All XCP events must have been be created before + void create_XCP_IF_DATA(BOOL tcp, const uint8_t* addr, uint16_t port); + + // Set XCP events for all following creates + void setFixedEvent(uint16_t xcp_event); + void setDefaultEvent(uint16_t xcp_event); + void rstFixedEvent(); + uint16_t getFixedEvent(); + + // Create measurements + void createMeasurement_(const char* instanceName, const char* name, int32_t type, uint8_t ext, uint32_t addr, double factor, double offset, const char* unit, const char* comment); + void createMeasurementArray_(const char* instanceName, const char* name, int32_t type, int32_t dim, uint8_t ext, uint32_t addr); + + // Create typedefs + void createTypedefBegin_(const char* name, int32_t size, const char* comment); + void createTypedefParameterComponent_(const char* name, int32_t type, uint32_t offset); + void createTypedefMeasurementComponent_(const char* name, int32_t type, uint32_t offset); + void createTypedefEnd_(); + void createTypedefInstance_(const char* instanceName, const char* typeName, uint8_t ext, uint32_t addr, const char* comment); + + // Create parameters + void createParameter_(const char* instanceName, const char* name, int32_t type, uint8_t ext, uint32_t addr, const char* comment, const char* unit); + void createParameterWithLimits_(const char* instanceName, const char* name, int32_t type, uint8_t ext, uint32_t addr, const char* comment, const char* unit, double min, double max); + void createMap_(const char* instanceName, const char* name, int32_t type, uint8_t ext, uint32_t addr, uint32_t xdim, uint32_t ydim, const char* comment, const char* unit); + void createCurve_(const char* instanceName, const char* name, int32_t type, uint8_t ext, uint32_t addr, uint32_t xdim, const char* comment, const char* unit); + + // Finalize and close A2L file + void close(); +}; + + diff --git a/A2lTestDlg/A2lTestDlg/A2lTestDlg.cpp b/A2lTestDlg/A2lTestDlg/A2lTestDlg.cpp new file mode 100644 index 0000000..70136fa --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2lTestDlg.cpp @@ -0,0 +1,153 @@ + +// A2lTestDlg.cpp : Defines the class behaviors for the application. +// + +#include "pch.h" +#include "framework.h" +#include "A2lTestDlg.h" +#include "A2lTestDlgDlg.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#endif + + +// CA2lTestDlgApp + +BEGIN_MESSAGE_MAP(CA2lTestDlgApp, CWinApp) + ON_COMMAND(ID_HELP, &CWinApp::OnHelp) +END_MESSAGE_MAP() + + +// CA2lTestDlgApp construction + +CA2lTestDlgApp::CA2lTestDlgApp() +{ + // support Restart Manager + m_dwRestartManagerSupportFlags = AFX_RESTART_MANAGER_SUPPORT_RESTART; + + // TODO: add construction code here, + // Place all significant initialization in InitInstance +} + + +// The one and only CA2lTestDlgApp object + +CA2lTestDlgApp theApp; + +const GUID CDECL BASED_CODE _tlid = + {0xaacf2bb9,0x0c94,0x4623,{0x8c,0x20,0xbb,0xe3,0x07,0x07,0x21,0xea}}; +const WORD _wVerMajor = 1; +const WORD _wVerMinor = 0; + + +// CA2lTestDlgApp initialization + +BOOL CA2lTestDlgApp::InitInstance() +{ + // InitCommonControlsEx() is required on Windows XP if an application + // manifest specifies use of ComCtl32.dll version 6 or later to enable + // visual styles. Otherwise, any window creation will fail. + INITCOMMONCONTROLSEX InitCtrls; + InitCtrls.dwSize = sizeof(InitCtrls); + // Set this to include all the common control classes you want to use + // in your application. + InitCtrls.dwICC = ICC_WIN95_CLASSES; + InitCommonControlsEx(&InitCtrls); + + CWinApp::InitInstance(); + + + // Initialize OLE libraries + if (!AfxOleInit()) + { + AfxMessageBox(IDP_OLE_INIT_FAILED); + return FALSE; + } + + AfxEnableControlContainer(); + + // Create the shell manager, in case the dialog contains + // any shell tree view or shell list view controls. + CShellManager *pShellManager = new CShellManager; + + // Activate "Windows Native" visual manager for enabling themes in MFC controls + CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows)); + + // Standard initialization + // If you are not using these features and wish to reduce the size + // of your final executable, you should remove from the following + // the specific initialization routines you do not need + // Change the registry key under which our settings are stored + // TODO: You should modify this string to be something appropriate + // such as the name of your company or organization + SetRegistryKey(_T("Local AppWizard-Generated Applications")); + // Parse command line for automation or reg/unreg switches. + CCommandLineInfo cmdInfo; + ParseCommandLine(cmdInfo); + + // App was launched with /Embedding or /Automation switch. + // Run app as automation server. + if (cmdInfo.m_bRunEmbedded || cmdInfo.m_bRunAutomated) + { + // Register class factories via CoRegisterClassObject(). + COleTemplateServer::RegisterAll(); + } + // App was launched with /Unregserver or /Unregister switch. Remove + // entries from the registry. + else if (cmdInfo.m_nShellCommand == CCommandLineInfo::AppUnregister) + { + COleObjectFactory::UpdateRegistryAll(FALSE); + AfxOleUnregisterTypeLib(_tlid, _wVerMajor, _wVerMinor); + return FALSE; + } + // App was launched standalone or with other switches (e.g. /Register + // or /Regserver). Update registry entries, including typelibrary. + else + { + COleObjectFactory::UpdateRegistryAll(); + AfxOleRegisterTypeLib(AfxGetInstanceHandle(), _tlid); + if (cmdInfo.m_nShellCommand == CCommandLineInfo::AppRegister) + return FALSE; + } + + CA2lTestDlgDlg dlg; + m_pMainWnd = &dlg; + INT_PTR nResponse = dlg.DoModal(); + if (nResponse == IDOK) + { + // TODO: Place code here to handle when the dialog is + // dismissed with OK + } + else if (nResponse == IDCANCEL) + { + // TODO: Place code here to handle when the dialog is + // dismissed with Cancel + } + else if (nResponse == -1) + { + TRACE(traceAppMsg, 0, "Warning: dialog creation failed, so application is terminating unexpectedly.\n"); + TRACE(traceAppMsg, 0, "Warning: if you are using MFC controls on the dialog, you cannot #define _AFX_NO_MFC_CONTROLS_IN_DIALOGS.\n"); + } + + // Delete the shell manager created above. + if (pShellManager != nullptr) + { + delete pShellManager; + } + +#if !defined(_AFXDLL) && !defined(_AFX_NO_MFC_CONTROLS_IN_DIALOGS) + ControlBarCleanUp(); +#endif + + // Since the dialog has been closed, return FALSE so that we exit the + // application, rather than start the application's message pump. + return FALSE; +} + +int CA2lTestDlgApp::ExitInstance() +{ + AfxOleTerm(FALSE); + + return CWinApp::ExitInstance(); +} diff --git a/A2lTestDlg/A2lTestDlg/A2lTestDlg.h b/A2lTestDlg/A2lTestDlg/A2lTestDlg.h new file mode 100644 index 0000000..3bf400a --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2lTestDlg.h @@ -0,0 +1,33 @@ + +// A2lTestDlg.h : main header file for the PROJECT_NAME application +// + +#pragma once + +#ifndef __AFXWIN_H__ + #error "include 'pch.h' before including this file for PCH" +#endif + +#include "resource.h" // main symbols + + +// CA2lTestDlgApp: +// See A2lTestDlg.cpp for the implementation of this class +// + +class CA2lTestDlgApp : public CWinApp +{ +public: + CA2lTestDlgApp(); + +// Overrides +public: + virtual BOOL InitInstance(); + virtual int ExitInstance(); + +// Implementation + + DECLARE_MESSAGE_MAP() +}; + +extern CA2lTestDlgApp theApp; diff --git a/A2lTestDlg/A2lTestDlg/A2lTestDlg.idl b/A2lTestDlg/A2lTestDlg/A2lTestDlg.idl new file mode 100644 index 0000000..e53307d --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2lTestDlg.idl @@ -0,0 +1,29 @@ +// A2lTestDlg.idl : type library source for A2lTestDlg.exe + +// This file will be processed by the MIDL compiler to produce the +// type library (A2lTestDlg.tlb). + +[ uuid(aacf2bb9-0c94-4623-8c20-bbe3070721ea), version(1.0) ] +library A2lTestDlg +{ + importlib("stdole32.tlb"); + importlib("stdole2.tlb"); + + // Primary dispatch interface for CA2lTestDlgDoc + + [ uuid(9fc78fa1-82e8-4469-9a9f-60c6d387b64a) ] + dispinterface IA2lTestDlg + { + properties: + + methods: + }; + + // Class information for CA2lTestDlgDoc + + [ uuid(04615303-44d9-45b7-b802-02b06c0dde4f) ] + coclass A2lTestDlg + { + [default] dispinterface IA2lTestDlg; + }; +}; diff --git a/A2lTestDlg/A2lTestDlg/A2lTestDlg.rc b/A2lTestDlg/A2lTestDlg/A2lTestDlg.rc new file mode 100644 index 0000000..56f3261 Binary files /dev/null and b/A2lTestDlg/A2lTestDlg/A2lTestDlg.rc differ diff --git a/A2lTestDlg/A2lTestDlg/A2lTestDlg.reg b/A2lTestDlg/A2lTestDlg/A2lTestDlg.reg new file mode 100644 index 0000000..6976ebb --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2lTestDlg.reg @@ -0,0 +1,17 @@ +REGEDIT +; This .REG file may be used by your SETUP program. +; If a SETUP program is not available, the entries below will be +; registered in your InitInstance automatically with a call to +; CWinApp::RegisterShellFileTypes and COleObjectFactory::UpdateRegistryAll. + + +HKEY_CLASSES_ROOT\A2lTestDlg.Application = A2lTestDlg Application + + +HKEY_CLASSES_ROOT\A2lTestDlg.Application\CLSID = {04615303-44d9-45b7-b802-02b06c0dde4f} + +HKEY_CLASSES_ROOT\CLSID\{04615303-44d9-45b7-b802-02b06c0dde4f} = A2lTestDlg Application +HKEY_CLASSES_ROOT\CLSID\{04615303-44d9-45b7-b802-02b06c0dde4f}\ProgId = A2lTestDlg.Application + + +HKEY_CLASSES_ROOT\CLSID\{04615303-44d9-45b7-b802-02b06c0dde4f}\LocalServer32 = A2lTestDlg.EXE diff --git a/A2lTestDlg/A2lTestDlg/A2lTestDlg.vcxproj b/A2lTestDlg/A2lTestDlg/A2lTestDlg.vcxproj new file mode 100644 index 0000000..0b7cef4 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2lTestDlg.vcxproj @@ -0,0 +1,252 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 16.0 + {86752C60-05E4-465C-9D79-876C97ABD2BA} + MFCProj + A2lTestDlg + 10.0 + + + + Application + true + v142 + Unicode + Dynamic + + + Application + false + v142 + true + Unicode + Dynamic + + + Application + true + v142 + Unicode + Dynamic + + + Application + false + v142 + true + Unicode + Dynamic + + + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + Use + Level3 + true + WIN32;_WINDOWS;_DEBUG;%(PreprocessorDefinitions) + pch.h + CompileAsCpp + + + Windows + true + + + false + true + _DEBUG;%(PreprocessorDefinitions) + $(IntDir)A2lTestDlg.tlb + A2lTestDlg_h.h + + + 0x0409 + _DEBUG;%(PreprocessorDefinitions) + $(IntDir);%(AdditionalIncludeDirectories) + + + + + Use + Level3 + true + _WINDOWS;_DEBUG;%(PreprocessorDefinitions) + pch.h + + + Windows + true + + + false + true + _DEBUG;%(PreprocessorDefinitions) + $(IntDir)A2lTestDlg.tlb + A2lTestDlg_h.h + + + 0x0409 + _DEBUG;%(PreprocessorDefinitions) + $(IntDir);%(AdditionalIncludeDirectories) + + + + + Use + Level3 + true + true + true + WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions) + pch.h + stdcpp20 + stdc17 + CompileAsCpp + + + Windows + true + true + true + + + false + true + NDEBUG;%(PreprocessorDefinitions) + $(IntDir)A2lTestDlg.tlb + A2lTestDlg_h.h + + + 0x0409 + NDEBUG;%(PreprocessorDefinitions) + $(IntDir);%(AdditionalIncludeDirectories) + + + + + Use + Level3 + true + true + true + _WINDOWS;NDEBUG;%(PreprocessorDefinitions) + pch.h + + + Windows + true + true + true + + + false + true + NDEBUG;%(PreprocessorDefinitions) + $(IntDir)A2lTestDlg.tlb + A2lTestDlg_h.h + + + 0x0409 + NDEBUG;%(PreprocessorDefinitions) + $(IntDir);%(AdditionalIncludeDirectories) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Create + Create + Create + Create + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/A2lTestDlg/A2lTestDlg/A2lTestDlg.vcxproj.filters b/A2lTestDlg/A2lTestDlg/A2lTestDlg.vcxproj.filters new file mode 100644 index 0000000..4b07686 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2lTestDlg.vcxproj.filters @@ -0,0 +1,118 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Source Files + + + + + + Resource Files + + + + + + Resource Files + + + + + Resource Files + + + \ No newline at end of file diff --git a/A2lTestDlg/A2lTestDlg/A2lTestDlg.vcxproj.user b/A2lTestDlg/A2lTestDlg/A2lTestDlg.vcxproj.user new file mode 100644 index 0000000..d2bbed9 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2lTestDlg.vcxproj.user @@ -0,0 +1,6 @@ + + + + A2lTestDlg.rc + + \ No newline at end of file diff --git a/A2lTestDlg/A2lTestDlg/A2lTestDlgDlg.cpp b/A2lTestDlg/A2lTestDlg/A2lTestDlgDlg.cpp new file mode 100644 index 0000000..54f7d60 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2lTestDlgDlg.cpp @@ -0,0 +1,252 @@ + +// A2lTestDlgDlg.cpp : implementation file +// + +#include "pch.h" +#include "framework.h" +#include "A2lTestDlg.h" +#include "A2lTestDlgDlg.h" +#include "DlgProxy.h" +#include "afxdialogex.h" + +#include + +#ifdef _DEBUG +#define new DEBUG_NEW +#endif + +//template +//std::wstring wstring_format(const std::wstring& format, Args ... args); +template +std::string string_format(const std::string& format, Args ... args) +{ + size_t size = snprintf(nullptr, 0, format.c_str(), args ...) + 1; // Extra space for '\0' + if (size <= 0) { + throw std::runtime_error("Error during formatting."); + } + std::unique_ptr buf(new char[size]); + snprintf(buf.get(), size, format.c_str(), args ...); + return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside } +} + + + +// CAboutDlg dialog used for App About + +class CAboutDlg : public CDialogEx +{ +public: + CAboutDlg(); + +// Dialog Data +#ifdef AFX_DESIGN_TIME + enum { IDD = IDD_ABOUTBOX }; +#endif + + protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support + +// Implementation +protected: + DECLARE_MESSAGE_MAP() +}; + +CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX) +{ +} + +void CAboutDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); +} + +BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx) +END_MESSAGE_MAP() + + +// CA2lTestDlgDlg dialog + + +IMPLEMENT_DYNAMIC(CA2lTestDlgDlg, CDialogEx); + +CA2lTestDlgDlg::CA2lTestDlgDlg(CWnd* pParent /*=nullptr*/) + : CDialogEx(IDD_A2LTESTDLG_DIALOG, pParent) +{ + m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME); + m_pAutoProxy = nullptr; +} + +CA2lTestDlgDlg::~CA2lTestDlgDlg() +{ + // If there is an automation proxy for this dialog, set + // its back pointer to this dialog to null, so it knows + // the dialog has been deleted. + if (m_pAutoProxy != nullptr) + m_pAutoProxy->m_pDialog = nullptr; +} + +void CA2lTestDlgDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); +} + +BEGIN_MESSAGE_MAP(CA2lTestDlgDlg, CDialogEx) + ON_WM_SYSCOMMAND() + ON_WM_CLOSE() + ON_WM_PAINT() + ON_WM_QUERYDRAGICON() + ON_BN_CLICKED(IDC_BUTTON_OPEN, &CA2lTestDlgDlg::OnBnClickedButtonOpen) +END_MESSAGE_MAP() + + +// CA2lTestDlgDlg message handlers + +BOOL CA2lTestDlgDlg::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + + // Add "About..." menu item to system menu. + + // IDM_ABOUTBOX must be in the system command range. + ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX); + ASSERT(IDM_ABOUTBOX < 0xF000); + + CMenu* pSysMenu = GetSystemMenu(FALSE); + if (pSysMenu != nullptr) + { + BOOL bNameValid; + CString strAboutMenu; + bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX); + ASSERT(bNameValid); + if (!strAboutMenu.IsEmpty()) + { + pSysMenu->AppendMenu(MF_SEPARATOR); + pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu); + } + } + + // Set the icon for this dialog. The framework does this automatically + // when the application's main window is not a dialog + SetIcon(m_hIcon, TRUE); // Set big icon + SetIcon(m_hIcon, FALSE); // Set small icon + + // TODO: Add extra initialization here + + return TRUE; // return TRUE unless you set the focus to a control +} + +void CA2lTestDlgDlg::OnSysCommand(UINT nID, LPARAM lParam) +{ + if ((nID & 0xFFF0) == IDM_ABOUTBOX) + { + CAboutDlg dlgAbout; + dlgAbout.DoModal(); + } + else + { + CDialogEx::OnSysCommand(nID, lParam); + } +} + +// If you add a minimize button to your dialog, you will need the code below +// to draw the icon. For MFC applications using the document/view model, +// this is automatically done for you by the framework. + +void CA2lTestDlgDlg::OnPaint() +{ + if (IsIconic()) + { + CPaintDC dc(this); // device context for painting + + SendMessage(WM_ICONERASEBKGND, reinterpret_cast(dc.GetSafeHdc()), 0); + + // Center icon in client rectangle + int cxIcon = GetSystemMetrics(SM_CXICON); + int cyIcon = GetSystemMetrics(SM_CYICON); + CRect rect; + GetClientRect(&rect); + int x = (rect.Width() - cxIcon + 1) / 2; + int y = (rect.Height() - cyIcon + 1) / 2; + + // Draw the icon + dc.DrawIcon(x, y, m_hIcon); + } + else + { + CDialogEx::OnPaint(); + } +} + +// The system calls this function to obtain the cursor to display while the user drags +// the minimized window. +HCURSOR CA2lTestDlgDlg::OnQueryDragIcon() +{ + return static_cast(m_hIcon); +} + +// Automation servers should not exit when a user closes the UI +// if a controller still holds on to one of its objects. These +// message handlers make sure that if the proxy is still in use, +// then the UI is hidden but the dialog remains around if it +// is dismissed. + +void CA2lTestDlgDlg::OnClose() +{ + if (CanExit()) + CDialogEx::OnClose(); +} + +void CA2lTestDlgDlg::OnOK() +{ + if (CanExit()) + CDialogEx::OnOK(); +} + +void CA2lTestDlgDlg::OnCancel() +{ + if (CanExit()) + CDialogEx::OnCancel(); +} + +BOOL CA2lTestDlgDlg::CanExit() +{ + // If the proxy object is still around, then the automation + // controller is still holding on to this application. Leave + // the dialog around, but hide its UI. + if (m_pAutoProxy != nullptr) + { + ShowWindow(SW_HIDE); + return FALSE; + } + + return TRUE; +} + + + +void CA2lTestDlgDlg::OnBnClickedButtonOpen() +{ + // TODO: Add your control notification handler code here + // TODO: ¿©±â¿¡ ÄÁÆ®·Ñ ¾Ë¸² 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù. + TCHAR a2lExt[] = _T("*.a2l"); + TCHAR a2lBaseFilter[] = _T("A2L file(*.A2L) | *.a2l;*.A2L | ¸ðµçÆÄÀÏ(*.*) | *.* ||"); + CFileDialog dlg(TRUE, a2lExt, NULL, OFN_HIDEREADONLY, a2lBaseFilter); + + if (dlg.DoModal() == IDOK) { + std::wstring strPath = dlg.GetPathName().GetBuffer(); + + std::string strA2lPath; + strA2lPath.assign(strPath.begin(), strPath.end()); + + loadA2lFile(strA2lPath.c_str()); + } +} + +void CA2lTestDlgDlg::AddLogString(std::string strMessage) +{ + CListBox* pListBox = (CListBox*)GetDlgItem(IDC_LIST_DATA); + std::wstring message_w; + message_w.assign(strMessage.begin(), strMessage.end()); + + pListBox->AddString(message_w.c_str()); +} \ No newline at end of file diff --git a/A2lTestDlg/A2lTestDlg/A2lTestDlgDlg.h b/A2lTestDlg/A2lTestDlg/A2lTestDlgDlg.h new file mode 100644 index 0000000..bf0a035 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2lTestDlgDlg.h @@ -0,0 +1,60 @@ + +// A2lTestDlgDlg.h : header file +// + + +#pragma once + +#include +#include +#include +#include + +#include "A2Lpp.hpp" // A2L generator + +class CA2lTestDlgDlgAutoProxy; + + +// CA2lTestDlgDlg dialog +class CA2lTestDlgDlg : public CDialogEx +{ + DECLARE_DYNAMIC(CA2lTestDlgDlg); + friend class CA2lTestDlgDlgAutoProxy; + +// Construction +public: + CA2lTestDlgDlg(CWnd* pParent = nullptr); // standard constructor + virtual ~CA2lTestDlgDlg(); + +// Dialog Data +#ifdef AFX_DESIGN_TIME + enum { IDD = IDD_A2LTESTDLG_DIALOG }; +#endif + + protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support + + +// Implementation +protected: + CA2lTestDlgDlgAutoProxy* m_pAutoProxy; + HICON m_hIcon; + + BOOL CanExit(); + + // Generated message map functions + virtual BOOL OnInitDialog(); + afx_msg void OnSysCommand(UINT nID, LPARAM lParam); + afx_msg void OnPaint(); + afx_msg HCURSOR OnQueryDragIcon(); + afx_msg void OnClose(); + virtual void OnOK(); + virtual void OnCancel(); + DECLARE_MESSAGE_MAP() +public: + afx_msg void OnBnClickedButtonOpen(); + + void AddLogString(std::string strMessage); + + A2L* a2lFile; +}; diff --git a/A2lTestDlg/A2lTestDlg/A2lTestDlg_h.h b/A2lTestDlg/A2lTestDlg/A2lTestDlg_h.h new file mode 100644 index 0000000..708bc1c --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2lTestDlg_h.h @@ -0,0 +1,226 @@ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 8.01.0628 */ +/* at Tue Jan 19 12:14:07 2038 + */ +/* Compiler settings for A2lTestDlg.idl: + Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 8.01.0628 + protocol : dce , ms_ext, c_ext, robust + error checks: allocation ref bounds_check enum stub_data + VC __declspec() decoration level: + __declspec(uuid()), __declspec(selectany), __declspec(novtable) + DECLSPEC_UUID(), MIDL_INTERFACE() +*/ +/* @@MIDL_FILE_HEADING( ) */ + + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif /* __RPCNDR_H_VERSION__ */ + + +#ifndef __A2lTestDlg_h_h__ +#define __A2lTestDlg_h_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +#ifndef DECLSPEC_XFGVIRT +#if defined(_CONTROL_FLOW_GUARD_XFG) +#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func)) +#else +#define DECLSPEC_XFGVIRT(base, func) +#endif +#endif + +/* Forward Declarations */ + +#ifndef __IA2lTestDlg_FWD_DEFINED__ +#define __IA2lTestDlg_FWD_DEFINED__ +typedef interface IA2lTestDlg IA2lTestDlg; + +#endif /* __IA2lTestDlg_FWD_DEFINED__ */ + + +#ifndef __A2lTestDlg_FWD_DEFINED__ +#define __A2lTestDlg_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class A2lTestDlg A2lTestDlg; +#else +typedef struct A2lTestDlg A2lTestDlg; +#endif /* __cplusplus */ + +#endif /* __A2lTestDlg_FWD_DEFINED__ */ + + +#ifdef __cplusplus +extern "C"{ +#endif + + + +#ifndef __A2lTestDlg_LIBRARY_DEFINED__ +#define __A2lTestDlg_LIBRARY_DEFINED__ + +/* library A2lTestDlg */ +/* [version][uuid] */ + + +EXTERN_C const IID LIBID_A2lTestDlg; + +#ifndef __IA2lTestDlg_DISPINTERFACE_DEFINED__ +#define __IA2lTestDlg_DISPINTERFACE_DEFINED__ + +/* dispinterface IA2lTestDlg */ +/* [uuid] */ + + +EXTERN_C const IID DIID_IA2lTestDlg; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9fc78fa1-82e8-4469-9a9f-60c6d387b64a") + IA2lTestDlg : public IDispatch + { + }; + +#else /* C style interface */ + + typedef struct IA2lTestDlgVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IA2lTestDlg * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + IA2lTestDlg * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + IA2lTestDlg * This); + + DECLSPEC_XFGVIRT(IDispatch, GetTypeInfoCount) + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IA2lTestDlg * This, + /* [out] */ UINT *pctinfo); + + DECLSPEC_XFGVIRT(IDispatch, GetTypeInfo) + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IA2lTestDlg * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + DECLSPEC_XFGVIRT(IDispatch, GetIDsOfNames) + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IA2lTestDlg * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + DECLSPEC_XFGVIRT(IDispatch, Invoke) + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IA2lTestDlg * This, + /* [annotation][in] */ + _In_ DISPID dispIdMember, + /* [annotation][in] */ + _In_ REFIID riid, + /* [annotation][in] */ + _In_ LCID lcid, + /* [annotation][in] */ + _In_ WORD wFlags, + /* [annotation][out][in] */ + _In_ DISPPARAMS *pDispParams, + /* [annotation][out] */ + _Out_opt_ VARIANT *pVarResult, + /* [annotation][out] */ + _Out_opt_ EXCEPINFO *pExcepInfo, + /* [annotation][out] */ + _Out_opt_ UINT *puArgErr); + + END_INTERFACE + } IA2lTestDlgVtbl; + + interface IA2lTestDlg + { + CONST_VTBL struct IA2lTestDlgVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IA2lTestDlg_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IA2lTestDlg_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IA2lTestDlg_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IA2lTestDlg_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IA2lTestDlg_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IA2lTestDlg_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IA2lTestDlg_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + +#endif /* __IA2lTestDlg_DISPINTERFACE_DEFINED__ */ + + +EXTERN_C const CLSID CLSID_A2lTestDlg; + +#ifdef __cplusplus + +class DECLSPEC_UUID("04615303-44d9-45b7-b802-02b06c0dde4f") +A2lTestDlg; +#endif +#endif /* __A2lTestDlg_LIBRARY_DEFINED__ */ + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/A2lTestDlg/A2lTestDlg/A2lTestDlg_i.c b/A2lTestDlg/A2lTestDlg/A2lTestDlg_i.c new file mode 100644 index 0000000..6f52ad9 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/A2lTestDlg_i.c @@ -0,0 +1,84 @@ + + +/* this ALWAYS GENERATED file contains the IIDs and CLSIDs */ + +/* link this file in with the server and any clients */ + + + /* File created by MIDL compiler version 8.01.0628 */ +/* at Tue Jan 19 12:14:07 2038 + */ +/* Compiler settings for A2lTestDlg.idl: + Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 8.01.0628 + protocol : dce , ms_ext, c_ext, robust + error checks: allocation ref bounds_check enum stub_data + VC __declspec() decoration level: + __declspec(uuid()), __declspec(selectany), __declspec(novtable) + DECLSPEC_UUID(), MIDL_INTERFACE() +*/ +/* @@MIDL_FILE_HEADING( ) */ + + + +#ifdef __cplusplus +extern "C"{ +#endif + + +#include +#include + +#ifdef _MIDL_USE_GUIDDEF_ + +#ifndef INITGUID +#define INITGUID +#include +#undef INITGUID +#else +#include +#endif + +#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \ + DEFINE_GUID(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) + +#else // !_MIDL_USE_GUIDDEF_ + +#ifndef __IID_DEFINED__ +#define __IID_DEFINED__ + +typedef struct _IID +{ + unsigned long x; + unsigned short s1; + unsigned short s2; + unsigned char c[8]; +} IID; + +#endif // __IID_DEFINED__ + +#ifndef CLSID_DEFINED +#define CLSID_DEFINED +typedef IID CLSID; +#endif // CLSID_DEFINED + +#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \ + EXTERN_C __declspec(selectany) const type name = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}} + +#endif // !_MIDL_USE_GUIDDEF_ + +MIDL_DEFINE_GUID(IID, LIBID_A2lTestDlg,0xaacf2bb9,0x0c94,0x4623,0x8c,0x20,0xbb,0xe3,0x07,0x07,0x21,0xea); + + +MIDL_DEFINE_GUID(IID, DIID_IA2lTestDlg,0x9fc78fa1,0x82e8,0x4469,0x9a,0x9f,0x60,0xc6,0xd3,0x87,0xb6,0x4a); + + +MIDL_DEFINE_GUID(CLSID, CLSID_A2lTestDlg,0x04615303,0x44d9,0x45b7,0xb8,0x02,0x02,0xb0,0x6c,0x0d,0xde,0x4f); + +#undef MIDL_DEFINE_GUID + +#ifdef __cplusplus +} +#endif + + + diff --git a/A2lTestDlg/A2lTestDlg/DlgProxy.cpp b/A2lTestDlg/A2lTestDlg/DlgProxy.cpp new file mode 100644 index 0000000..b128141 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/DlgProxy.cpp @@ -0,0 +1,87 @@ + +// DlgProxy.cpp : implementation file +// + +#include "pch.h" +#include "framework.h" +#include "A2lTestDlg.h" +#include "DlgProxy.h" +#include "A2lTestDlgDlg.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#endif + + +// CA2lTestDlgDlgAutoProxy + +IMPLEMENT_DYNCREATE(CA2lTestDlgDlgAutoProxy, CCmdTarget) + +CA2lTestDlgDlgAutoProxy::CA2lTestDlgDlgAutoProxy() +{ + EnableAutomation(); + + // To keep the application running as long as an automation + // object is active, the constructor calls AfxOleLockApp. + AfxOleLockApp(); + + // Get access to the dialog through the application's + // main window pointer. Set the proxy's internal pointer + // to point to the dialog, and set the dialog's back pointer to + // this proxy. + ASSERT_VALID(AfxGetApp()->m_pMainWnd); + if (AfxGetApp()->m_pMainWnd) + { + ASSERT_KINDOF(CA2lTestDlgDlg, AfxGetApp()->m_pMainWnd); + if (AfxGetApp()->m_pMainWnd->IsKindOf(RUNTIME_CLASS(CA2lTestDlgDlg))) + { + m_pDialog = reinterpret_cast(AfxGetApp()->m_pMainWnd); + m_pDialog->m_pAutoProxy = this; + } + } +} + +CA2lTestDlgDlgAutoProxy::~CA2lTestDlgDlgAutoProxy() +{ + // To terminate the application when all objects created with + // with automation, the destructor calls AfxOleUnlockApp. + // Among other things, this will destroy the main dialog + if (m_pDialog != nullptr) + m_pDialog->m_pAutoProxy = nullptr; + AfxOleUnlockApp(); +} + +void CA2lTestDlgDlgAutoProxy::OnFinalRelease() +{ + // When the last reference for an automation object is released + // OnFinalRelease is called. The base class will automatically + // deletes the object. Add additional cleanup required for your + // object before calling the base class. + + CCmdTarget::OnFinalRelease(); +} + +BEGIN_MESSAGE_MAP(CA2lTestDlgDlgAutoProxy, CCmdTarget) +END_MESSAGE_MAP() + +BEGIN_DISPATCH_MAP(CA2lTestDlgDlgAutoProxy, CCmdTarget) +END_DISPATCH_MAP() + +// Note: we add support for IID_IA2lTestDlg to support typesafe binding +// from VBA. This IID must match the GUID that is attached to the +// dispinterface in the .IDL file. + +// {9fc78fa1-82e8-4469-9a9f-60c6d387b64a} +static const IID IID_IA2lTestDlg = +{0x9fc78fa1,0x82e8,0x4469,{0x9a,0x9f,0x60,0xc6,0xd3,0x87,0xb6,0x4a}}; + +BEGIN_INTERFACE_MAP(CA2lTestDlgDlgAutoProxy, CCmdTarget) + INTERFACE_PART(CA2lTestDlgDlgAutoProxy, IID_IA2lTestDlg, Dispatch) +END_INTERFACE_MAP() + +// The IMPLEMENT_OLECREATE2 macro is defined in pch.h of this project +// {04615303-44d9-45b7-b802-02b06c0dde4f} +IMPLEMENT_OLECREATE2(CA2lTestDlgDlgAutoProxy, "A2lTestDlg.Application", 0x04615303,0x44d9,0x45b7,0xb8,0x02,0x02,0xb0,0x6c,0x0d,0xde,0x4f) + + +// CA2lTestDlgDlgAutoProxy message handlers diff --git a/A2lTestDlg/A2lTestDlg/DlgProxy.h b/A2lTestDlg/A2lTestDlg/DlgProxy.h new file mode 100644 index 0000000..539960d --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/DlgProxy.h @@ -0,0 +1,43 @@ + +// DlgProxy.h: header file +// + +#pragma once + +class CA2lTestDlgDlg; + + +// CA2lTestDlgDlgAutoProxy command target + +class CA2lTestDlgDlgAutoProxy : public CCmdTarget +{ + DECLARE_DYNCREATE(CA2lTestDlgDlgAutoProxy) + + CA2lTestDlgDlgAutoProxy(); // protected constructor used by dynamic creation + +// Attributes +public: + CA2lTestDlgDlg* m_pDialog; + +// Operations +public: + +// Overrides + public: + virtual void OnFinalRelease(); + +// Implementation +protected: + virtual ~CA2lTestDlgDlgAutoProxy(); + + // Generated message map functions + + DECLARE_MESSAGE_MAP() + DECLARE_OLECREATE(CA2lTestDlgDlgAutoProxy) + + // Generated OLE dispatch map functions + + DECLARE_DISPATCH_MAP() + DECLARE_INTERFACE_MAP() +}; + diff --git a/A2lTestDlg/A2lTestDlg/dbg_print.h b/A2lTestDlg/A2lTestDlg/dbg_print.h new file mode 100644 index 0000000..c2ec327 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/dbg_print.h @@ -0,0 +1,50 @@ +#pragma once + +/* dbg_print.h */ +/* +| Code released into public domain, no attribution required +*/ + + +//------------------------------------------------------------------------------- +// Debug print + +#if OPTION_ENABLE_DBG_PRINTS + +extern unsigned int gDebugLevel; +#define DBG_LEVEL gDebugLevel + +#define DBG_PRINTF_ERROR(format, ...) printf(format, __VA_ARGS__) +#define DBG_PRINTF(level, format, ...) if (DBG_LEVEL>=level) printf(format, __VA_ARGS__) +#define DBG_PRINTF1(format, ...) if (DBG_LEVEL>=1) printf(format, __VA_ARGS__) +#define DBG_PRINTF2(format, ...) if (DBG_LEVEL>=2) printf(format, __VA_ARGS__) +#define DBG_PRINTF3(format, ...) if (DBG_LEVEL>=3) printf(format, __VA_ARGS__) +#define DBG_PRINTF4(format, ...) if (DBG_LEVEL>=4) printf(format, __VA_ARGS__) + +#define DBG_PRINT_ERROR(format) printf(format) +#define DBG_PRINT(level, format) if (DBG_LEVEL>=level) printf(format) +#define DBG_PRINT1(format) if (DBG_LEVEL>=1) printf(format) +#define DBG_PRINT2(format) if (DBG_LEVEL>=2) printf(format) +#define DBG_PRINT3(format) if (DBG_LEVEL>=3) printf(format) +#define DBG_PRINT4(format) if (DBG_LEVEL>=4) printf(format) + +#else + +#undef DBG_LEVEL + +#define DBG_PRINTF_ERROR(s, ...) // printf(s,__VA_ARGS__) +#define DBG_PRINTF(level, s, ...) +#define DBG_PRINTF1(s, ...) +#define DBG_PRINTF2(s, ...) +#define DBG_PRINTF3(s, ...) +#define DBG_PRINTF4(s, ...) + +#define DBG_PRINT_ERROR(s, ...) // printf(s,__VA_ARGS__) +#define DBG_PRINT(level, s, ...) +#define DBG_PRINT1(s, ...) +#define DBG_PRINT2(s, ...) +#define DBG_PRINT3(s, ...) +#define DBG_PRINT4(s, ...) + +#endif + diff --git a/A2lTestDlg/A2lTestDlg/framework.h b/A2lTestDlg/A2lTestDlg/framework.h new file mode 100644 index 0000000..52ad5d8 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/framework.h @@ -0,0 +1,60 @@ +#pragma once + +#ifndef VC_EXTRALEAN +#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers +#endif + +#include "targetver.h" + +#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // some CString constructors will be explicit + +// turns off MFC's hiding of some common and often safely ignored warning messages +#define _AFX_ALL_WARNINGS + +#include // MFC core and standard components +#include // MFC extensions + + +#include // MFC Automation classes + + + +#ifndef _AFX_NO_OLE_SUPPORT +#include // MFC support for Internet Explorer 4 Common Controls +#endif +#ifndef _AFX_NO_AFXCMN_SUPPORT +#include // MFC support for Windows Common Controls +#endif // _AFX_NO_AFXCMN_SUPPORT + +#include // MFC support for ribbons and control bars + + + + + + + + +// This macro is the same as IMPLEMENT_OLECREATE, except it passes TRUE +// for the bMultiInstance parameter to the COleObjectFactory constructor. +// We want a separate instance of this application to be launched for +// each automation proxy object requested by automation controllers. +#ifndef IMPLEMENT_OLECREATE2 +#define IMPLEMENT_OLECREATE2(class_name, external_name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \ + AFX_DATADEF COleObjectFactory class_name::factory(class_name::guid, \ + RUNTIME_CLASS(class_name), TRUE, _T(external_name)); \ + const AFX_DATADEF GUID class_name::guid = \ + { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }; +#endif // IMPLEMENT_OLECREATE2 + +#ifdef _UNICODE +#if defined _M_IX86 +#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"") +#elif defined _M_X64 +#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"") +#else +#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") +#endif +#endif + + diff --git a/A2lTestDlg/A2lTestDlg/main.h b/A2lTestDlg/A2lTestDlg/main.h new file mode 100644 index 0000000..7ed8265 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/main.h @@ -0,0 +1,95 @@ +#pragma once + +/* main.h */ +/* +| Code released into public domain, no attribution required +*/ + +// Windows or Linux ? +#if defined(_WIN32) || defined(_WIN64) + #define _WIN + #if defined(_WIN32) && defined(_WIN64) + #undef _WIN32 + #endif + #if defined(_LINUX) || defined(_LINUX64)|| defined(_LINUX32) + #error + #endif +#else + #define _LINUX + #if defined (_ix64_) || defined (__x86_64__) || defined (__aarch64__) + #define _LINUX64 + #else + #define _LINUX32 + #endif + #if defined(_WIN) || defined(_WIN64)|| defined(_WIN32) + #error + #endif +#endif + + +#ifdef _WIN +#define WIN32_LEAN_AND_MEAN +#define _CRT_SECURE_NO_WARNINGS +#else +#define _DEFAULT_SOURCE +#endif + + +#include +#include +#include +#include +#include + +#ifdef _WIN +#define M_PI 3.14159265358979323846 +#endif +#define M_2PI (M_PI*2) + +#include + +#ifndef _WIN // Linux + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#define MAX_PATH 256 +#define BOOL int +#define FALSE 0 +#define TRUE 1 + +#else // Windows + +#include +#include +#include + +#define BOOL int +#define FALSE 0 +#define TRUE 1 + +#endif + +#ifdef __cplusplus +#include +#include +#include +#include +#endif + +#include "main_cfg.h" + diff --git a/A2lTestDlg/A2lTestDlg/main_cfg.h b/A2lTestDlg/A2lTestDlg/main_cfg.h new file mode 100644 index 0000000..1dadbcc --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/main_cfg.h @@ -0,0 +1,48 @@ +#pragma once + +// main_cfg.h +// CPP_Demo + +/* Copyright(c) Vector Informatik GmbH.All rights reserved. + Licensed under the MIT license.See LICENSE file in the project root for details. */ + +// Application configuration: +// XCP configuration is in xcp_cfg.h (Protocol Layer) and xcptl_cfg.h (Transport Layer) + + +#define ON 1 +#define OFF 0 + + +// Debug prints +#define OPTION_ENABLE_DBG_PRINTS ON +#define OPTION_DEBUG_LEVEL 2 +#define OPTION_UDP_DEBUG_LEVEL 0 + + +// Enable C++ class wrapper +#define OPTION_ENABLE_XCP_CLASS ON + +// Enable demo how to measure dynamic instances +#define OPTION_ENABLE_DYNAMIC_DEMO ON + + +// A2L generation +#define OPTION_ENABLE_A2L_GEN ON // Enable A2L generation +#if OPTION_ENABLE_A2L_GEN + #define OPTION_A2L_NAME "CPP_Demo" // A2L name + #define OPTION_A2L_FILE_NAME "CPP_Demo.a2l" // A2L filename +#endif + + +// Set clock resolution (for clock function in platform.c) +#define CLOCK_USE_APP_TIME_US +//#define CLOCK_USE_UTC_TIME_NS + + +// Ethernet Transport Layer +#define OPTION_USE_TCP OFF +#define OPTION_MTU 1500 // Ethernet MTU +#define OPTION_SERVER_PORT 5555 // Default UDP port +#define OPTION_SERVER_ADDR {127,0,0,1} // IP addr to bind, 0.0.0.0 = ANY + diff --git a/A2lTestDlg/A2lTestDlg/main_cfg.h.in b/A2lTestDlg/A2lTestDlg/main_cfg.h.in new file mode 100644 index 0000000..4a3f597 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/main_cfg.h.in @@ -0,0 +1,39 @@ +#pragma once + +// main_cfg.h +// CPP_Demo + +/* Copyright(c) Vector Informatik GmbH.All rights reserved. + Licensed under the MIT license.See LICENSE file in the project root for details. */ + +#define APP_CPP_Demo + +#define APP_NAME "CPP_Demo" +#define APP_VERSION_MAJOR @CPP_Demo_VERSION_MAJOR@ +#define APP_VERSION_MINOR @CPP_Demo_VERSION_MINOR@ + +//----------------------------------------------------------------------------------------------------- +// Application configuration: +// XCP configuration is in xcp_cfg.h (Protocol Layer) and xcptl_cfg.h (Transport Layer) + +#define ON 1 +#define OFF 0 + +#define OPTION_DEBUG_LEVEL @OPTION_DEBUG_LEVEL@ + +// A2L generation +#define OPTION_ENABLE_A2L_GEN ON // Enable A2L generation +#if OPTION_ENABLE_A2L_GEN +#define OPTION_ENABLE_A2L_SYMBOL_LINKS ON // Enable generation of symbol links (required for CANape integrated linker map update) +#define OPTION_A2L_NAME "CPP_Demo" // A2L name +#define OPTION_A2L_FILE_NAME "CPP_Demo.a2l" // A2L filename +#define OPTION_A2L_PROJECT_NAME "CPP_Demo" // A2L project name +#endif + +// Default communication parameters +#define OPTION_ENABLE_TCP @OPTION_ENABLE_TCP@ // Enable TCP support +#define OPTION_USE_TCP @OPTION_USE_TCP@ // Default +#define OPTION_MTU @OPTION_MTU@ // Ethernet MTU +#define OPTION_SERVER_PORT @OPTION_SERVER_PORT@ // Default UDP port, overwritten by commandline option -port +#define OPTION_SERVER_ADDR @OPTION_SERVER_ADDR@ // Default IP addr to bind, 0.0.0.0 = ANY, overwritten by commandline option -bind x.x.x.x + diff --git a/A2lTestDlg/A2lTestDlg/pch.cpp b/A2lTestDlg/A2lTestDlg/pch.cpp new file mode 100644 index 0000000..64b7eef --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/pch.cpp @@ -0,0 +1,5 @@ +// pch.cpp: source file corresponding to the pre-compiled header + +#include "pch.h" + +// When you are using pre-compiled headers, this source file is necessary for compilation to succeed. diff --git a/A2lTestDlg/A2lTestDlg/pch.h b/A2lTestDlg/A2lTestDlg/pch.h new file mode 100644 index 0000000..885d5d6 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/pch.h @@ -0,0 +1,13 @@ +// pch.h: This is a precompiled header file. +// Files listed below are compiled only once, improving build performance for future builds. +// This also affects IntelliSense performance, including code completion and many code browsing features. +// However, files listed here are ALL re-compiled if any one of them is updated between builds. +// Do not add files here that you will be updating frequently as this negates the performance advantage. + +#ifndef PCH_H +#define PCH_H + +// add headers that you want to pre-compile here +#include "framework.h" + +#endif //PCH_H diff --git a/A2lTestDlg/A2lTestDlg/platform.h b/A2lTestDlg/A2lTestDlg/platform.h new file mode 100644 index 0000000..3ff2579 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/platform.h @@ -0,0 +1,183 @@ +#pragma once +/* platform.h */ +/* +| Code released into public domain, no attribution required +*/ + + +//------------------------------------------------------------------------------- +// Keyboard + +#ifdef _LINUX + +#include + +extern int _getch(); +extern int _kbhit(); + +#endif + + +//------------------------------------------------------------------------------- +// Safe sprintf + +#if defined(_WIN) // Windows +#define SPRINTF(dest,format,...) sprintf_s((char*)dest,sizeof(dest),format,__VA_ARGS__) +#define SNPRINTF(dest,len,format,...) sprintf_s((char*)dest,len,format,__VA_ARGS__) +#elif defined(_LINUX) // Linux +#define SPRINTF(dest,format,...) snprintf((char*)dest,sizeof(dest),format,__VA_ARGS__) +#define SNPRINTF(dest,len,format,...) snprintf((char*)dest,len,format,__VA_ARGS__) +#endif + + +//------------------------------------------------------------------------------- +// Delay + +// Delay based on clock +extern void sleepNs(uint32_t ns); + +// Delay - Less precise and less CPU load, not based on clock, time domain different +extern void sleepMs(uint32_t ms); + + +//------------------------------------------------------------------------------- +// Mutex + + +#if defined(_WIN) // Windows + +#define MUTEX CRITICAL_SECTION +#define mutexLock EnterCriticalSection +#define mutexUnlock LeaveCriticalSection + +#elif defined(_LINUX) // Linux + +#define MUTEX pthread_mutex_t +#define MUTEX_INTIALIZER PTHREAD_MUTEX_INITIALIZER +#define mutexLock pthread_mutex_lock +#define mutexUnlock pthread_mutex_unlock + +#endif + +void mutexInit(MUTEX* m, BOOL recursive, uint32_t spinCount); +void mutexDestroy(MUTEX* m); + + +//------------------------------------------------------------------------------- +// Threads + +#if defined(_WIN) // Windows + +typedef HANDLE tXcpThread; +#define create_thread(h,t) *h = CreateThread(0, 0, t, NULL, 0, NULL) +#define join_thread(h) WaitForSingleObject(h, INFINITE); +#define terminate_thread(h) { TerminateThread(h,0); WaitForSingleObject(h,1000); CloseHandle(h); } +#define cancel_thread terminate_thread + +#elif defined(_LINUX) // Linux + +typedef pthread_t tXcpThread; +#define create_thread(h,t) pthread_create(h, NULL, t, NULL); +#define join_thread(h) pthread_join(h,NULL); +#define detach_thread(h) { pthread_detach(h); pthread_cancel(h); } +#define cancel_thread detach_thread + +#endif + + +//------------------------------------------------------------------------------- +// Platform independant socket functions + +#ifdef _LINUX // Linux sockets + +#define SOCKET int +#define INVALID_SOCKET (-1) + +#define SOCKADDR_IN struct sockaddr_in +#define SOCKADDR struct sockaddr + +#define SOCKET_ERROR_ABORT EBADF +#define SOCKET_ERROR_RESET EBADF +#define SOCKET_ERROR_INTR EBADF +#define SOCKET_ERROR_WBLOCK EAGAIN + +#undef htonll +#define htonll(val) ((((uint64_t)htonl((uint32_t)val)) << 32) + htonl((uint32_t)(val >> 32))) + + +#define socketGetLastError() errno + +#endif + +#if defined(_WIN) // Windows // Windows sockets or XL-API + +#include +#include + +#define SOCKET_ERROR_OTHER 1 +#define SOCKET_ERROR_WBLOCK WSAEWOULDBLOCK +#define SOCKET_ERROR_ABORT WSAECONNABORTED +#define SOCKET_ERROR_RESET WSAECONNRESET +#define SOCKET_ERROR_INTR WSAEINTR + +#endif + +// Timestamp mode +#define SOCKET_TIMESTAMP_NONE 0 // No timestamps +#define SOCKET_TIMESTAMP_HW 1 // Hardware clock +#define SOCKET_TIMESTAMP_HW_SYNT 2 // Hardware clock syntonized to PC clock +#define SOCKET_TIMESTAMP_PC 3 // PC clock + +// Clock mode +#define SOCKET_TIMESTAMP_FREE_RUNNING 0 +#define SOCKET_TIMESTAMP_SOFTWARE_SYNC 1 + +extern BOOL socketStartup(); +extern int32_t socketGetLastError(); +extern void socketCleanup(); +extern BOOL socketOpen(SOCKET* sp, BOOL useTCP, BOOL nonBlocking, BOOL reuseaddr, BOOL timestamps); +extern BOOL socketBind(SOCKET sock, uint8_t* addr, uint16_t port); +extern BOOL socketJoin(SOCKET sock, uint8_t* maddr); +extern BOOL socketListen(SOCKET sock); +extern SOCKET socketAccept(SOCKET sock, uint8_t addr[]); +extern int16_t socketRecv(SOCKET sock, uint8_t* buffer, uint16_t bufferSize, BOOL waitAll); +extern int16_t socketRecvFrom(SOCKET sock, uint8_t* buffer, uint16_t bufferSize, uint8_t* srcAddr, uint16_t* srcPort, uint64_t *time); +extern int16_t socketSend(SOCKET sock, const uint8_t* buffer, uint16_t bufferSize); +extern int16_t socketSendTo(SOCKET sock, const uint8_t* buffer, uint16_t bufferSize, const uint8_t* addr, uint16_t port, uint64_t *time); +extern BOOL socketShutdown(SOCKET sock); +extern BOOL socketClose(SOCKET* sp); +extern BOOL socketGetLocalAddr(uint8_t* mac, uint8_t* addr); + + +//------------------------------------------------------------------------------- +// Clock + +// Clock resolution and epoch +#if !defined(CLOCK_USE_UTC_TIME_NS) && !defined(CLOCK_USE_APP_TIME_US) + // Default + #define CLOCK_USE_UTC_TIME_NS // Use ns timestamps relative to 1.1.1970 (TAI monotonic - no backward jumps) + //#define CLOCK_USE_APP_TIME_US // Use arbitrary us timestamps relative to application start +#endif + +#ifdef CLOCK_USE_UTC_TIME_NS + +#define CLOCK_TICKS_PER_M (1000000000ULL*60) +#define CLOCK_TICKS_PER_S 1000000000 +#define CLOCK_TICKS_PER_MS 1000000 +#define CLOCK_TICKS_PER_US 1000 +#define CLOCK_TICKS_PER_NS 1 + +#else + +#define CLOCK_TICKS_PER_S 1000000 +#define CLOCK_TICKS_PER_MS 1000 +#define CLOCK_TICKS_PER_US 1 + +#endif + +// Clock +extern BOOL clockInit(); +extern uint64_t clockGet(); +extern uint64_t clockGetLast(); +extern char* clockGetString(char* s, uint32_t l, uint64_t c); +extern char* clockGetTimeString(char* s, uint32_t l, int64_t c); diff --git a/A2lTestDlg/A2lTestDlg/res/A2lTestDlg.ico b/A2lTestDlg/A2lTestDlg/res/A2lTestDlg.ico new file mode 100644 index 0000000..d56fbcd Binary files /dev/null and b/A2lTestDlg/A2lTestDlg/res/A2lTestDlg.ico differ diff --git a/A2lTestDlg/A2lTestDlg/res/A2lTestDlg.rc2 b/A2lTestDlg/A2lTestDlg/res/A2lTestDlg.rc2 new file mode 100644 index 0000000..9c3dc67 Binary files /dev/null and b/A2lTestDlg/A2lTestDlg/res/A2lTestDlg.rc2 differ diff --git a/A2lTestDlg/A2lTestDlg/resource.h b/A2lTestDlg/A2lTestDlg/resource.h new file mode 100644 index 0000000..bbb3959 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/resource.h @@ -0,0 +1,24 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by A2lTestDlg.rc +// +#define IDM_ABOUTBOX 0x0010 +#define IDD_ABOUTBOX 100 +#define IDP_OLE_INIT_FAILED 100 +#define IDS_ABOUTBOX 101 +#define IDD_A2LTESTDLG_DIALOG 102 +#define IDR_MAINFRAME 128 +#define IDC_LIST2 1001 +#define IDC_LIST_DATA 1001 +#define IDC_BUTTON_OPEN 1002 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 130 +#define _APS_NEXT_COMMAND_VALUE 32771 +#define _APS_NEXT_CONTROL_VALUE 1003 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/A2lTestDlg/A2lTestDlg/targetver.h b/A2lTestDlg/A2lTestDlg/targetver.h new file mode 100644 index 0000000..87c0086 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/targetver.h @@ -0,0 +1,8 @@ +#pragma once + +// Including SDKDDKVer.h defines the highest available Windows platform. + +// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and +// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h. + +#include diff --git a/A2lTestDlg/A2lTestDlg/xcp.h b/A2lTestDlg/A2lTestDlg/xcp.h new file mode 100644 index 0000000..ff355b9 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/xcp.h @@ -0,0 +1,1235 @@ +#pragma once + +/* xcp.h */ + +/* Copyright(c) Vector Informatik GmbH.All rights reserved. + Licensed under the MIT license.See LICENSE file in the project root for details. */ + + +/***************************************************************************/ +/* Commands */ +/***************************************************************************/ + +/*-------------------------------------------------------------------------*/ +/* Standard Commands */ + +#define CC_CONNECT 0xFF +#define CC_DISCONNECT 0xFE +#define CC_GET_STATUS 0xFD +#define CC_SYNCH 0xFC + +#define CC_GET_COMM_MODE_INFO 0xFB +#define CC_GET_ID 0xFA +#define CC_SET_REQUEST 0xF9 +#define CC_GET_SEED 0xF8 +#define CC_UNLOCK 0xF7 +#define CC_SET_MTA 0xF6 +#define CC_UPLOAD 0xF5 +#define CC_SHORT_UPLOAD 0xF4 +#define CC_BUILD_CHECKSUM 0xF3 + +#define CC_TRANSPORT_LAYER_CMD 0xF2 +#define CC_USER_CMD 0xF1 + + +/*-------------------------------------------------------------------------*/ +/* Calibration Commands*/ + +#define CC_DOWNLOAD 0xF0 + +#define CC_DOWNLOAD_NEXT 0xEF +#define CC_DOWNLOAD_MAX 0xEE +#define CC_SHORT_DOWNLOAD 0xED +#define CC_MODIFY_BITS 0xEC + + +/*-------------------------------------------------------------------------*/ +/* Page switching Commands (PAG) */ + +#define CC_SET_CAL_PAGE 0xEB +#define CC_GET_CAL_PAGE 0xEA + +#define CC_GET_PAG_PROCESSOR_INFO 0xE9 +#define CC_GET_SEGMENT_INFO 0xE8 +#define CC_GET_PAGE_INFO 0xE7 +#define CC_SET_SEGMENT_MODE 0xE6 +#define CC_GET_SEGMENT_MODE 0xE5 +#define CC_COPY_CAL_PAGE 0xE4 + + +/*-------------------------------------------------------------------------*/ +/* Data acquisition and Stimulation Commands (DAQ/STIM) */ + +#define CC_CLEAR_DAQ_LIST 0xE3 +#define CC_SET_DAQ_PTR 0xE2 +#define CC_WRITE_DAQ 0xE1 +#define CC_SET_DAQ_LIST_MODE 0xE0 +#define CC_GET_DAQ_LIST_MODE 0xDF +#define CC_START_STOP_DAQ_LIST 0xDE +#define CC_START_STOP_SYNCH 0xDD + +#define CC_GET_DAQ_CLOCK 0xDC +#define CC_READ_DAQ 0xDB +#define CC_GET_DAQ_PROCESSOR_INFO 0xDA +#define CC_GET_DAQ_RESOLUTION_INFO 0xD9 +#define CC_GET_DAQ_LIST_INFO 0xD8 +#define CC_GET_DAQ_EVENT_INFO 0xD7 + +#define CC_FREE_DAQ 0xD6 +#define CC_ALLOC_DAQ 0xD5 +#define CC_ALLOC_ODT 0xD4 +#define CC_ALLOC_ODT_ENTRY 0xD3 + + +/*-------------------------------------------------------------------------*/ +/* Non volatile memory Programming Commands PGM */ + +#define CC_PROGRAM_START 0xD2 +#define CC_PROGRAM_CLEAR 0xD1 +#define CC_PROGRAM 0xD0 +#define CC_PROGRAM_RESET 0xCF +#define CC_GET_PGM_PROCESSOR_INFO 0xCE +#define CC_GET_SECTOR_INFO 0xCD +#define CC_PROGRAM_PREPARE 0xCC +#define CC_PROGRAM_FORMAT 0xCB +#define CC_PROGRAM_NEXT 0xCA +#define CC_PROGRAM_MAX 0xC9 +#define CC_PROGRAM_VERIFY 0xC8 + +/*-------------------------------------------------------------------------*/ +/* XCP >= V1.1 Commands */ +# define CC_WRITE_DAQ_MULTIPLE 0xC7 /* XCP V1.1 specific commands */ + +/*-------------------------------------------------------------------------*/ +/* XCP >= V1.3 Commands */ +#if XCP_PROTOCOL_LAYER_VERSION >= 0x0103 +# define CC_TIME_CORRELATION_PROPERTIES 0xC6 /* XCP V1.3 specific commands */ +#endif + +/*-------------------------------------------------------------------------*/ +/* XCP >= V1.4 Commands */ +#if XCP_PROTOCOL_LAYER_VERSION >= 0x0104 +#define CC_LEVEL_1_COMMAND 0xC0 /* XCP V1.4 Level 1 Commands: */ +#define CC_GET_VERSION 0x00 +#define CC_SET_DAQ_LIST_PACKED_MODE 0x01 +#define CC_GET_DAQ_LIST_PACKED_MODE 0x02 +#define CC_SW_DBG_OVER_XCP 0xFC +#endif + +/*-------------------------------------------------------------------------*/ +/* Packet Identifiers Server -> Master */ +#define PID_RES 0xFF /* response packet */ +#define PID_ERR 0xFE /* error packet */ +#define PID_EV 0xFD /* event packet */ +#define PID_SERV 0xFC /* service request packet */ + + +/*-------------------------------------------------------------------------*/ +/* Command Return Codes */ + +#define CRC_CMD_SYNCH 0x00 +#define CRC_CMD_PENDING 0x01 +#define CRC_CMD_BUSY 0x10 +#define CRC_DAQ_ACTIVE 0x11 +#define CRC_PRM_ACTIVE 0x12 +#define CRC_CMD_UNKNOWN 0x20 +#define CRC_CMD_SYNTAX 0x21 +#define CRC_OUT_OF_RANGE 0x22 +#define CRC_WRITE_PROTECTED 0x23 +#define CRC_ACCESS_DENIED 0x24 +#define CRC_ACCESS_LOCKED 0x25 +#define CRC_PAGE_NOT_VALID 0x26 +#define CRC_PAGE_MODE_NOT_VALID 0x27 +#define CRC_SEGMENT_NOT_VALID 0x28 +#define CRC_SEQUENCE 0x29 +#define CRC_DAQ_CONFIG 0x2A +#define CRC_MEMORY_OVERFLOW 0x30 +#define CRC_GENERIC 0x31 +#define CRC_VERIFY 0x32 +#define CRC_RESOURCE_TEMPORARY_NOT_ACCESSIBLE 0x33 +#define CRC_SUBCMD_UNKNOWN 0x34 +#define CRC_TIMECORR_STATE_CHANGE 0x35 + + +/*-------------------------------------------------------------------------*/ +/* Event Codes */ + +#define EVC_RESUME_MODE 0x00 +#define EVC_CLEAR_DAQ 0x01 +#define EVC_STORE_DAQ 0x02 +#define EVC_STORE_CAL 0x03 +#define EVC_CMD_PENDING 0x05 +#define EVC_DAQ_OVERLOAD 0x06 +#define EVC_SESSION_TERMINATED 0x07 +#define EVC_TIME_SYNCH 0x08 +#define EVC_STIM_TIMEOUT 0x09 +#define EVC_SLEEP 0x0A +#define EVC_WAKEUP 0x0B +#define EVC_ECU_STATE 0x0C +#define EVC_USER 0xFE +#define EVC_TRANSPORT 0xFF + + +/*-------------------------------------------------------------------------*/ +/* Service Request Codes */ + +#define SERV_RESET 0x00 /* Server requesting to be reset */ +#define SERV_TEXT 0x01 /* Plain ASCII text null terminated */ + + + + +/***************************************************************************/ +/* Definitions */ +/***************************************************************************/ + +/*-------------------------------------------------------------------------*/ +/* ResourceMask (CONNECT) */ + +#define RM_CAL_PAG 0x01 +#define RM_DAQ 0x04 +#define RM_STIM 0x08 +#define RM_PGM 0x10 +#define RM_DBG 0x20 + + +/*-------------------------------------------------------------------------*/ +/* CommModeBasic (CONNECT) */ + +#define PI_MOTOROLA 0x01 + +#define CMB_BYTE_ORDER (0x01u<<0) +#define CMB_ADDRESS_GRANULARITY (0x03u<<1) +#define CMB_SERVER_BLOCK_MODE (0x01u<<6) +#define CMB_OPTIONAL (0x01u<<7) + +#define CMB_ADDRESS_GRANULARITY_BYTE (0<<1) +#define CMB_ADDRESS_GRANULARITY_WORD (1<<1) +#define CMB_ADDRESS_GRANULARITY_DWORD (2<<1) +#define CMB_ADDRESS_GRANULARITY_QWORD (3<<1) + + +/*-------------------------------------------------------------------------*/ +/* Protocol Info (GET_COMM_MODE_INFO - COMM_OPTIONAL) */ + +#define CMO_MASTER_BLOCK_MODE 0x01 +#define CMO_INTERLEAVED_MODE 0x02 + + +/*-------------------------------------------------------------------------*/ +/* Session Status (GET_STATUS and SET_REQUEST) */ + +// XCP states (low byte) */ +#define SS_STORE_CAL_REQ ((uint16_t)0x0001) +#define SS_STORE_DAQ_REQ ((uint16_t)0x0004) +#define SS_CLEAR_DAQ_REQ ((uint16_t)0x0008) +#define SS_DAQ ((uint16_t)0x0040) +#define SS_RESUME ((uint16_t)0x0080) + +// Internal states (high byte) */ +#define SS_BLOCK_UPLOAD ((uint16_t)0x0100) /* Block upload in progress */ +#define SS_LEGACY_MODE ((uint16_t)0x0200) /* XCP 1.3 legacy mode */ +#define SS_CMD_PENDING ((uint16_t)0x0800) /* async comand pending */ +#define SS_INITIALIZED ((uint16_t)0x8000) /* initialized */ +#define SS_STARTED ((uint16_t)0x4000) /* started*/ +#define SS_CONNECTED ((uint16_t)0x2000) /* connected */ + + +/*-------------------------------------------------------------------------*/ +/* Identifier Type (GET_ID) */ + +#define IDT_ASCII 0 +#define IDT_ASAM_NAME 1 +#define IDT_ASAM_PATH 2 +#define IDT_ASAM_URL 3 +#define IDT_ASAM_UPLOAD 4 +#define IDT_ASAM_EPK 5 +#define IDT_ASAM_ECU 6 +#define IDT_ASAM_SYSID 7 + +/*-------------------------------------------------------------------------*/ +/* Checksum Types (BUILD_CHECKSUM) */ + +#define XCP_CHECKSUM_TYPE_ADD11 0x01 /* Add BYTE into a BYTE checksum, ignore overflows */ +#define XCP_CHECKSUM_TYPE_ADD12 0x02 /* Add BYTE into a WORD checksum, ignore overflows */ +#define XCP_CHECKSUM_TYPE_ADD14 0x03 /* Add BYTE into a DWORD checksum, ignore overflows */ +#define XCP_CHECKSUM_TYPE_ADD22 0x04 /* Add WORD into a WORD checksum, ignore overflows, blocksize must be modulo 2 */ +#define XCP_CHECKSUM_TYPE_ADD24 0x05 /* Add WORD into a DWORD checksum, ignore overflows, blocksize must be modulo 2 */ +#define XCP_CHECKSUM_TYPE_ADD44 0x06 /* Add DWORD into DWORD, ignore overflows, blocksize must be modulo 4 */ +#define XCP_CHECKSUM_TYPE_CRC16 0x07 /* See CRC error detection algorithms */ +#define XCP_CHECKSUM_TYPE_CRC16CCITT 0x08 /* See CRC error detection algorithms */ +#define XCP_CHECKSUM_TYPE_CRC32 0x09 /* See CRC error detection algorithms */ +#define XCP_CHECKSUM_TYPE_DLL 0xFF /* User defined, ASAM MCD 2MC DLL Interface */ + + +/*-------------------------------------------------------------------------*/ +/* Page Mode (SET_CAL_PAGE) */ + +#define CAL_PAGE_MODE_ECU 0x01 +#define CAL_PAGE_MODE_XCP 0x02 +#define CAL_PAGE_MODE_ALL 0x80 + + +/*-------------------------------------------------------------------------*/ +/* PAG_PROPERTIES (GET_PAG_PROCESSOR_INFO) */ + +#define PAG_PROPERTY_FREEZE 0x01 + + +/*-------------------------------------------------------------------------*/ +/* PAGE_PROPERTIES (GET_PAGE_INFO)*/ + +#define ECU_ACCESS_TYPE 0x03 +#define XCP_READ_ACCESS_TYPE 0x0C +#define XCP_WRITE_ACCESS_TYPE 0x30 + +/* ECU_ACCESS_TYPE */ +#define ECU_ACCESS_NONE (0<<0) +#define ECU_ACCESS_WITHOUT (1<<0) +#define ECU_ACCESS_WITH (2<<0) +#define ECU_ACCESS_DONT_CARE (3<<0) + +/* XCP_READ_ACCESS_TYPE */ +#define XCP_READ_ACCESS_NONE (0<<2) +#define XCP_READ_ACCESS_WITHOUT (1<<2) +#define XCP_READ_ACCESS_WITH (2<<2) +#define XCP_READ_ACCESS_DONT_CARE (3<<2) + +/* XCP_WRITE_ACCESS_TYPE */ +#define XCP_WRITE_ACCESS_NONE (0<<4) +#define XCP_WRITE_ACCESS_WITHOUT (1<<4) +#define XCP_WRITE_ACCESS_WITH (2<<4) +#define XCP_WRITE_ACCESS_DONT_CARE (3<<4) + + +/*-------------------------------------------------------------------------*/ +/* SEGMENT_MODE (GET_SEGMENT_MODE, SET_SEGMENT_MODE) */ + +#define SEGMENT_FLAG_FREEZE 0x01 /* */ + + +/*-------------------------------------------------------------------------*/ +/* DAQ list flags (from GET_DAQ_LIST_MODE, SET_DAQ_LIST_MODE) */ + +// DAQ list mode bit mask coding +#define DAQ_MODE_ALTERNATING ((uint8_t)0x01) /* Bit0 - Enable/disable alternating display mode */ +#define DAQ_MODE_DIRECTION ((uint8_t)0x02) /* Bit1 - DAQ list stim mode */ +#define DAQ_MODE_RESERVED2 ((uint8_t)0x04) /* Bit2 - Not used */ +#define DAQ_MODE_DTO_CTR ((uint8_t)0x08) /* Bit3 - Use DTO CTR field */ +#define DAQ_MODE_TIMESTAMP ((uint8_t)0x10) /* Bit4 - Enable timestamp */ +#define DAQ_MODE_PID_OFF ((uint8_t)0x20) /* Bit5 - Disable PID */ +#define DAQ_MODE_RESERVED6 ((uint8_t)0x40) /* Bit6 - Not used */ +#define DAQ_MODE_RESERVED7 ((uint8_t)0x80) /* Bit7 - Not used */ + + +/*-------------------------------------------------------------------------*/ +/* DAQ list state */ + +// DAQ list state bit mask coding +#define DAQ_STATE_STOPPED_UNSELECTED ((uint8_t)0x00) /* Not selected, stopped */ +#define DAQ_STATE_SELECTED ((uint8_t)0x01) /* Selected */ +#define DAQ_STATE_RUNNING ((uint8_t)0x02) /* Running */ +#define DAQ_STATE_OVERRUN ((uint8_t)0x04) /* Overrun */ + + + +/*-------------------------------------------------------------------------*/ +/* GET_DAQ_PROCESSOR_INFO */ + +/* DAQ_PROPERTIES */ +#define DAQ_PROPERTY_CONFIG_TYPE 0x01 +#define DAQ_PROPERTY_PRESCALER 0x02 +#define DAQ_PROPERTY_RESUME 0x04 +#define DAQ_PROPERTY_BIT_STIM 0x08 +#define DAQ_PROPERTY_TIMESTAMP 0x10 +#define DAQ_PROPERTY_NO_PID 0x20 +#define DAQ_PROPERTY_OVERLOAD_INDICATION 0xC0 + +/* DAQ Overload Indication Type */ +#define DAQ_OVERLOAD_INDICATION_NONE (0<<6) +#define DAQ_OVERLOAD_INDICATION_PID (1<<6) +#define DAQ_OVERLOAD_INDICATION_EVENT (2<<6) + +/* DAQ_KEY_BYTE */ +#define DAQ_OPT_TYPE 0x0F +#define DAQ_EXT_TYPE 0x30 +#define DAQ_HDR_TYPE 0xC0 + +/* DAQ Optimisation Type */ +#define DAQ_OPT_DEFAULT (0<<0) +#define DAQ_OPT_ODT_16 (1<<0) +#define DAQ_OPT_ODT_32 (2<<0) +#define DAQ_OPT_ODT_64 (3<<0) +#define DAQ_OPT_ALIGNMENT (4<<0) +#define DAQ_OPT_MAX_ENTRY_SIZE (5<<0) + +/* DAQ Address Extension Scope */ +#define DAQ_EXT_FREE (0<<4) +#define DAQ_EXT_ODT (1<<4) +#define DAQ_EXT_DAQ (3<<4) + +/* DAQ Identification Field Type */ +#define DAQ_HDR_PID (0<<6) +#define DAQ_HDR_ODT_DAQB (1<<6) +#define DAQ_HDR_ODT_DAQW (2<<6) +#define DAQ_HDR_ODT_FIL_DAQW (3<<6) + + +/*-------------------------------------------------------------------------*/ +/* GET_DAQ_RESOLUTION_INFO */ + +/* TIMESTAMP_MODE Bitmasks */ +#define DAQ_TIMESTAMP_TYPE 0x07 +#define DAQ_TIMESTAMP_FIXED 0x08 +#define DAQ_TIMESTAMP_UNIT 0xF0 + +/* DAQ Timestamp Type */ +#define DAQ_TIMESTAMP_OFF (0<<0) +#define DAQ_TIMESTAMP_BYTE (1<<0) +#define DAQ_TIMESTAMP_WORD (2<<0) +#define DAQ_TIMESTAMP_DWORD (4<<0) + +/* DAQ Timestamp Unit */ +#define DAQ_TIMESTAMP_UNIT_1NS (0<<4) +#define DAQ_TIMESTAMP_UNIT_10NS (1<<4) +#define DAQ_TIMESTAMP_UNIT_100NS (2<<4) +#define DAQ_TIMESTAMP_UNIT_1US (3<<4) +#define DAQ_TIMESTAMP_UNIT_10US (4<<4) +#define DAQ_TIMESTAMP_UNIT_100US (5<<4) +#define DAQ_TIMESTAMP_UNIT_1MS (6<<4) +#define DAQ_TIMESTAMP_UNIT_10MS (7<<4) +#define DAQ_TIMESTAMP_UNIT_100MS (8<<4) +#define DAQ_TIMESTAMP_UNIT_1S (9<<4) + + +/*-------------------------------------------------------------------------*/ +/* DAQ_LIST_PROPERTIES (GET_DAQ_LIST_INFO) */ + +#define DAQ_LIST_PREDEFINED 0x01 +#define DAQ_LIST_FIXED_EVENT 0x02 +#define DAQ_LIST_DIR_DAQ 0x04 +#define DAQ_LIST_DIR_STIM 0x08 +#define DAQ_LIST_PACKED 0x10 + + +/*-------------------------------------------------------------------------*/ +/* EVENT_PROPERTY (GET_DAQ_EVENT_INFO) */ + +#define DAQ_EVENT_DIRECTION_DAQ 0x04 +#define DAQ_EVENT_DIRECTION_STIM 0x08 +#define DAQ_EVENT_DIRECTION_DAQ_STIM 0x0C + + +/*-------------------------------------------------------------------------*/ +/* Comm mode programming parameter (PROGRAM_START) */ + +#define PI_PGM_BLOCK_DOWNLOAD 0x01 +#define PI_PGM_BLOCK_UPLOAD 0x40 + + +/*-------------------------------------------------------------------------*/ +/* PGM_PROPERTIES (GET_PGM_PROCESSOR_INFO) */ + +#define PGM_ACCESS_TYPE 0x03 +#define PGM_COMPRESSION_TYPE 0x0C +#define PGM_ENCRYPTION_TYPE 0x30 +#define PGM_NON_SEQ_TYPE 0xC0 + +/* PGM Access Mode */ +#define PGM_ACCESS_ABSOLUTE (1<<0) +#define PGM_ACCESS_FUNCTIONAL (2<<0) +#define PGM_ACCESS_FREE (3<<0) + +/* PGM Compression type */ +#define PGM_COMPRESSION_NONE (0<<2) +#define PGM_COMPRESSION_SUPPORTED (1<<2) +#define PGM_COMPRESSION_REQUIRED (3<<2) + +/* PGM Encryption type */ +#define PGM_ENCRYPTION_NONE (0<<4) +#define PGM_ENCRYPTION_SUPPORTED (1<<4) +#define PGM_ENCRYPTION_REQUIRED (3<<4) + +/* PGM non sequential programming type */ +#define PGM_NON_SEQ_NONE (0<<6) +#define PGM_NON_SEQ_SUPPORTED (1<<6) +#define PGM_NON_SEQ_REQUIRED (3<<6) + + +/***************************************************************************/ +/* XCP Protocol Commands and Responces, Type Definition */ +/***************************************************************************/ + +/* Protocol command structure definition */ +#define CRO_CMD CRO_BYTE(0) +#define CRM_CMD CRM_BYTE(0) +#define CRM_ERR CRM_BYTE(1) +#define CRM_EVENTCODE CRM_BYTE(1) + + + +/* CONNECT */ +#define CRO_CONNECT_LEN 2 +#define CRO_CONNECT_MODE CRO_BYTE(1) +#define CRM_CONNECT_LEN 8 +#define CRM_CONNECT_RESOURCE CRM_BYTE(1) +#define CRM_CONNECT_COMM_BASIC CRM_BYTE(2) +#define CRM_CONNECT_MAX_CTO_SIZE CRM_BYTE(3) +#define CRM_CONNECT_MAX_DTO_SIZE CRM_WORD(2) +#define CRM_CONNECT_PROTOCOL_VERSION CRM_BYTE(6) +#define CRM_CONNECT_TRANSPORT_VERSION CRM_BYTE(7) + + +/* DISCONNECT */ +#define CRO_DISCONNECT_LEN 1 +#define CRM_DISCONNECT_LEN 1 + + +/* GET_STATUS */ +#define CRO_GET_STATUS_LEN 1 +#define CRM_GET_STATUS_LEN 6 +#define CRM_GET_STATUS_STATUS CRM_BYTE(1) +#define CRM_GET_STATUS_PROTECTION CRM_BYTE(2) +#define CRM_GET_STATUS_CONFIG_ID CRM_WORD(2) + +/* SYNCH */ +#define CRO_SYNCH_LEN 1 +#define CRM_SYNCH_LEN 2 +#define CRM_SYNCH_RESULT CRM_BYTE(1) + + +/* GET_COMM_MODE_INFO */ +#define CRO_GET_COMM_MODE_INFO_LEN 1 +#define CRM_GET_COMM_MODE_INFO_LEN 8 +#define CRM_GET_COMM_MODE_INFO_COMM_OPTIONAL CRM_BYTE(2) +#define CRM_GET_COMM_MODE_INFO_MAX_BS CRM_BYTE(4) +#define CRM_GET_COMM_MODE_INFO_MIN_ST CRM_BYTE(5) +#define CRM_GET_COMM_MODE_INFO_QUEUE_SIZE CRM_BYTE(6) +#define CRM_GET_COMM_MODE_INFO_DRIVER_VERSION CRM_BYTE(7) + + +/* GET_ID */ +#define CRO_GET_ID_LEN 2 +#define CRO_GET_ID_TYPE CRO_BYTE(1) +#define CRM_GET_ID_LEN 8 +#define CRM_GET_ID_MODE CRM_BYTE(1) +#define CRM_GET_ID_LENGTH CRM_DWORD(1) +#define CRM_GET_ID_DATA (&CRM_BYTE(8)) +#define CRM_GET_ID_DATA_MAX_LEN (sizeof(CRM)-8) + +/* SET_REQUEST */ +#define CRO_SET_REQUEST_LEN 4 +#define CRO_SET_REQUEST_MODE CRO_BYTE(1) +#define CRO_SET_REQUEST_CONFIG_ID CRO_WORD(1) +#define CRM_SET_REQUEST_LEN 1 + + +/* GET_SEED */ +#define CRO_GET_SEED_LEN 3 +#define CRO_GET_SEED_MODE CRO_BYTE(1) +#define CRO_GET_SEED_RESOURCE CRO_BYTE(2) +#define CRM_GET_SEED_LEN (CRM_GET_SEED_LENGTH+2u) +#define CRM_GET_SEED_LENGTH CRM_BYTE(1) +#define CRM_GET_SEED_DATA (&CRM_BYTE(2)) + + +/* UNLOCK */ +#define CRO_UNLOCK_LEN 8 +#define CRO_UNLOCK_LENGTH CRO_BYTE(1) +#define CRO_UNLOCK_KEY (&CRO_BYTE(2)) +#define CRM_UNLOCK_LEN 2 +#define CRM_UNLOCK_PROTECTION CRM_BYTE(1) + + +/* SET_MTA */ +#define CRO_SET_MTA_LEN 8 +#define CRO_SET_MTA_EXT CRO_BYTE(3) +#define CRO_SET_MTA_ADDR CRO_DWORD(1) +#define CRM_SET_MTA_LEN 1 + + +/* UPLOAD */ +#define CRO_UPLOAD_LEN 2 +#define CRO_UPLOAD_SIZE CRO_BYTE(1) +#define CRM_UPLOAD_MAX_SIZE ((uint8_t)(XCPTL_MAX_CTO_SIZE-1)) +#define CRM_UPLOAD_LEN 1 /* +CRO_UPLOAD_SIZE */ +#define CRM_UPLOAD_DATA (&CRM_BYTE(1)) + + +/* SHORT_UPLOAD */ +#define CRO_SHORT_UPLOAD_LEN 8 +#define CRO_SHORT_UPLOAD_SIZE CRO_BYTE(1) +#define CRO_SHORT_UPLOAD_EXT CRO_BYTE(3) +#define CRO_SHORT_UPLOAD_ADDR CRO_DWORD(1) +#define CRM_SHORT_UPLOAD_MAX_SIZE ((uint8_t)(XCPTL_MAX_CTO_SIZE-1)) +#define CRM_SHORT_UPLOAD_LEN 1u /* +CRO_SHORT_UPLOAD_SIZE */ +#define CRM_SHORT_UPLOAD_DATA (&CRM_BYTE(1)) + + +/* BUILD_CHECKSUM */ +#define CRO_BUILD_CHECKSUM_LEN 8 +#define CRO_BUILD_CHECKSUM_SIZE CRO_DWORD(1) +#define CRM_BUILD_CHECKSUM_LEN 8 +#define CRM_BUILD_CHECKSUM_TYPE CRM_BYTE(1) +#define CRM_BUILD_CHECKSUM_RESULT CRM_DWORD(1) + + +/* DOWNLOAD */ +#define CRO_DOWNLOAD_MAX_SIZE ((uint8_t)(XCPTL_MAX_CTO_SIZE-2)) +#define CRO_DOWNLOAD_LEN 2 /* + CRO_DOWNLOAD_SIZE */ +#define CRO_DOWNLOAD_SIZE CRO_BYTE(1) +#define CRO_DOWNLOAD_DATA (&CRO_BYTE(2)) +#define CRM_DOWNLOAD_LEN 1 + + +/* DOWNLOAD_NEXT */ +#define CRO_DOWNLOAD_NEXT_MAX_SIZE ((uint8_t)(XCPTL_MAX_CTO_SIZE-2)) +#define CRO_DOWNLOAD_NEXT_LEN 2 /* + size */ +#define CRO_DOWNLOAD_NEXT_SIZE CRO_BYTE(1) +#define CRO_DOWNLOAD_NEXT_DATA (&CRO_BYTE(2)) +#define CRM_DOWNLOAD_NEXT_LEN 1 + + +/* DOWNLOAD_MAX */ +#define CRO_DOWNLOAD_MAX_MAX_SIZE ((uint8_t)(XCPTL_MAX_CTO_SIZE-1)) +#define CRO_DOWNLOAD_MAX_DATA (&CRO_BYTE(1)) +#define CRM_DOWNLOAD_MAX_LEN 1 + + +/* SHORT_DOWNLOAD */ +#define CRO_SHORT_DOWNLOAD_MAX_SIZE ((uint8_t)(XCPTL_MAX_CTO_SIZE-8)) +#define CRO_SHORT_DOWNLOAD_LEN 8 +#define CRO_SHORT_DOWNLOAD_SIZE CRO_BYTE(1) +#define CRO_SHORT_DOWNLOAD_EXT CRO_BYTE(3) +#define CRO_SHORT_DOWNLOAD_ADDR CRO_DWORD(1) +#define CRO_SHORT_DOWNLOAD_DATA (&CRO_BYTE(8)) +#define CRM_SHORT_DOWNLOAD_LEN 1 /* +CRO_SHORT_UPLOAD_SIZE */ + + +/* MODIFY_BITS */ +#define CRO_MODIFY_BITS_LEN 6 +#define CRO_MODIFY_BITS_SHIFT CRO_BYTE(1) +#define CRO_MODIFY_BITS_AND CRO_WORD(1) +#define CRO_MODIFY_BITS_XOR CRO_WORD(2) +#define CRM_MODIFY_BITS_LEN 1 + + +/* SET_CAL_PAGE */ +#define CRO_SET_CAL_PAGE_LEN 4 +#define CRO_SET_CAL_PAGE_MODE CRO_BYTE(1) +#define CRO_SET_CAL_PAGE_SEGMENT CRO_BYTE(2) +#define CRO_SET_CAL_PAGE_PAGE CRO_BYTE(3) +#define CRM_SET_CAL_PAGE_LEN 1 + + +/* GET_CAL_PAGE */ +#define CRO_GET_CAL_PAGE_LEN 3 +#define CRO_GET_CAL_PAGE_MODE CRO_BYTE(1) +#define CRO_GET_CAL_PAGE_SEGMENT CRO_BYTE(2) +#define CRM_GET_CAL_PAGE_LEN 4 +#define CRM_GET_CAL_PAGE_PAGE CRM_BYTE(3) + + +/* GET_PAG_PROCESSOR_INFO */ +#define CRO_GET_PAG_PROCESSOR_INFO_LEN 1 +#define CRM_GET_PAG_PROCESSOR_INFO_LEN 3 +#define CRM_GET_PAG_PROCESSOR_INFO_MAX_SEGMENT CRM_BYTE(1) +#define CRM_GET_PAG_PROCESSOR_INFO_PROPERTIES CRM_BYTE(2) + + +/* GET_SEGMENT_INFO */ +#define CRO_GET_SEGMENT_INFO_LEN 5 +#define CRO_GET_SEGMENT_INFO_MODE CRO_BYTE(1) +#define CRO_GET_SEGMENT_INFO_NUMBER CRO_BYTE(2) +#define CRO_GET_SEGMENT_INFO_MAPPING_INDEX CRO_BYTE(3) +#define CRO_GET_SEGMENT_INFO_MAPPING CRO_BYTE(4) +#define CRM_GET_SEGMENT_INFO_LEN 8 +#define CRM_GET_SEGMENT_INFO_MAX_PAGES CRM_BYTE(1) +#define CRM_GET_SEGMENT_INFO_ADDRESS_EXTENSION CRM_BYTE(2) +#define CRM_GET_SEGMENT_INFO_MAX_MAPPING CRM_BYTE(3) +#define CRM_GET_SEGMENT_INFO_COMPRESSION CRM_BYTE(4) +#define CRM_GET_SEGMENT_INFO_ENCRYPTION CRM_BYTE(5) +#define CRM_GET_SEGMENT_INFO_MAPPING_INFO CRM_DWORD(1) + + +/* GET_PAGE_INFO */ +#define CRO_GET_PAGE_INFO_LEN 4 +#define CRO_GET_PAGE_INFO_SEGMENT_NUMBER CRO_BYTE(2) +#define CRO_GET_PAGE_INFO_PAGE_NUMBER CRO_BYTE(3) +#define CRM_GET_PAGE_INFO_LEN 3 +#define CRM_GET_PAGE_INFO_PROPERTIES CRM_BYTE(1) +#define CRM_GET_PAGE_INFO_INIT_SEGMENT CRM_BYTE(2) + + +/* SET_SEGMENT_MODE */ +#define CRO_SET_SEGMENT_MODE_LEN 3 +#define CRO_SET_SEGMENT_MODE_MODE CRO_BYTE(1) +#define CRO_SET_SEGMENT_MODE_SEGMENT CRO_BYTE(2) +#define CRM_SET_SEGMENT_MODE_LEN 1 + + +/* GET_SEGMENT_MODE */ +#define CRO_GET_SEGMENT_MODE_LEN 3 +#define CRO_GET_SEGMENT_MODE_SEGMENT CRO_BYTE(2) +#define CRM_GET_SEGMENT_MODE_LEN 3 +#define CRM_GET_SEGMENT_MODE_MODE CRM_BYTE(2) + + +/* COPY_CAL_PAGE */ +#define CRO_COPY_CAL_PAGE_LEN 5 +#define CRO_COPY_CAL_PAGE_SRC_SEGMENT CRO_BYTE(1) +#define CRO_COPY_CAL_PAGE_SRC_PAGE CRO_BYTE(2) +#define CRO_COPY_CAL_PAGE_DEST_SEGMENT CRO_BYTE(3) +#define CRO_COPY_CAL_PAGE_DEST_PAGE CRO_BYTE(4) +#define CRM_COPY_CAL_PAGE_LEN 1 + + +/* CLEAR_DAQ_LIST */ +#define CRO_CLEAR_DAQ_LIST_LEN 4 +#define CRO_CLEAR_DAQ_LIST_DAQ CRO_WORD(1) +#define CRM_CLEAR_DAQ_LIST_LEN 1 + + +/* SET_DAQ_PTR */ +#define CRO_SET_DAQ_PTR_LEN 6 +#define CRO_SET_DAQ_PTR_DAQ CRO_WORD(1) +#define CRO_SET_DAQ_PTR_ODT CRO_BYTE(4) +#define CRO_SET_DAQ_PTR_IDX CRO_BYTE(5) +#define CRM_SET_DAQ_PTR_LEN 1 + + +/* WRITE_DAQ */ +#define CRO_WRITE_DAQ_LEN 8 +#define CRO_WRITE_DAQ_BITOFFSET CRO_BYTE(1) +#define CRO_WRITE_DAQ_SIZE CRO_BYTE(2) +#define CRO_WRITE_DAQ_EXT CRO_BYTE(3) +#define CRO_WRITE_DAQ_ADDR CRO_DWORD(1) +#define CRM_WRITE_DAQ_LEN 1 + + +/* WRITE_DAQ_MULTIPLE */ +#define CRO_WRITE_DAQ_MULTIPLE_LEN(n) (2+(n)*8) +#define CRO_WRITE_DAQ_MULTIPLE_NODAQ CRO_BYTE(1) +#define CRO_WRITE_DAQ_MULTIPLE_BITOFFSET(i) CRO_BYTE(2 + (8*(i))) +#define CRO_WRITE_DAQ_MULTIPLE_SIZE(i) CRO_BYTE(3 + (8*(i))) +#define CRO_WRITE_DAQ_MULTIPLE_ADDR(i) CRO_DWORD(1 + (2*(i))) +#define CRO_WRITE_DAQ_MULTIPLE_EXT(i) CRO_BYTE(8 + (8*(i))) +#define CRM_WRITE_DAQ_MULTIPLE_LEN 1 + + +/* SET_DAQ_LIST_MODE */ +#define CRO_SET_DAQ_LIST_MODE_LEN 8 +#define CRO_SET_DAQ_LIST_MODE_MODE CRO_BYTE(1) +#define CRO_SET_DAQ_LIST_MODE_DAQ CRO_WORD(1) +#define CRO_SET_DAQ_LIST_MODE_EVENTCHANNEL CRO_WORD(2) +#define CRO_SET_DAQ_LIST_MODE_PRESCALER CRO_BYTE(6) +#define CRO_SET_DAQ_LIST_MODE_PRIORITY CRO_BYTE(7) +#define CRM_SET_DAQ_LIST_MODE_LEN 6 + + +/* GET_DAQ_LIST_MODE */ +#define CRO_GET_DAQ_LIST_MODE_LEN 4 +#define CRO_GET_DAQ_LIST_MODE_DAQ CRO_WORD(1) +#define CRM_GET_DAQ_LIST_MODE_LEN 8 +#define CRM_GET_DAQ_LIST_MODE_MODE CRM_BYTE(1) +#define CRM_GET_DAQ_LIST_MODE_EVENTCHANNEL CRM_WORD(2) +#define CRM_GET_DAQ_LIST_MODE_PRESCALER CRM_BYTE(6) +#define CRM_GET_DAQ_LIST_MODE_PRIORITY CRM_BYTE(7) + + +/* START_STOP_DAQ_LIST */ +#define CRO_START_STOP_DAQ_LIST_LEN 4 +#define CRO_START_STOP_DAQ_LIST_MODE CRO_BYTE(1) +#define CRO_START_STOP_DAQ_LIST_DAQ CRO_WORD(1) +#define CRM_START_STOP_DAQ_LIST_LEN 2 +#define CRM_START_STOP_DAQ_LIST_FIRST_PID CRM_BYTE(1) + + +/* START_STOP_SYNCH */ +#define CRO_START_STOP_SYNCH_LEN 2 +#define CRO_START_STOP_SYNCH_MODE CRO_BYTE(1) +#define CRM_START_STOP_SYNCH_LEN 1 + + +/* GET_DAQ_CLOCK */ +#define CRO_GET_DAQ_CLOCK_LEN 1 +#define CRM_GET_DAQ_CLOCK_LEN 8 + +#if XCP_PROTOCOL_LAYER_VERSION >= 0x0103 +#define CRM_GET_DAQ_CLOCK_RES1 CRM_BYTE(1) // 1 +#define CRM_GET_DAQ_CLOCK_TRIGGER_INFO CRM_BYTE(2) // 2 +#define CRM_GET_DAQ_CLOCK_PAYLOAD_FMT CRM_BYTE(3) // 3 + +#define CRM_GET_DAQ_CLOCK_TIME CRM_DWORD(1) // 4 +#define CRM_GET_DAQ_CLOCK_SYNCH_STATE CRM_BYTE(8) // 8 + +#define CRM_GET_DAQ_CLOCK_TIME64_LOW CRM_DWORD(1) // 4 +#define CRM_GET_DAQ_CLOCK_TIME64_HIGH CRM_DWORD(2) // 8 +#define CRM_GET_DAQ_CLOCK_SYNCH_STATE64 CRM_BYTE(12) // 12 +#else +#define CRM_GET_DAQ_CLOCK_TIME CRM_DWORD(1) // 4 +#endif + +#define DAQ_CLOCK_PAYLOAD_FMT_SLV_32 (1<<0) +#define DAQ_CLOCK_PAYLOAD_FMT_SLV_64 (2<<0) +#define DAQ_CLOCK_PAYLOAD_FMT_ID (1<<6) + +/* GET_DAQ_CLOCK_MULTICAST */ +#if XCP_PROTOCOL_LAYER_VERSION >= 0x0103 +#define CRO_GET_DAQ_CLOC_MCAST_LEN 4 +#define CRM_GET_DAQ_CLOCK_MCAST_LEN 8 + +#define CRO_GET_DAQ_CLOCK_MCAST_CLUSTER_IDENTIFIER CRO_WORD(1) +#define CRO_GET_DAQ_CLOCK_MCAST_COUNTER CRO_BYTE(4) + +#define CRM_GET_DAQ_CLOCK_MCAST_TRIGGER_INFO CRM_BYTE(2) // 2 +#define CRM_GET_DAQ_CLOCK_MCAST_PAYLOAD_FMT CRM_BYTE(3) // 3 + +#define CRM_GET_DAQ_CLOCK_MCAST_TIME CRM_DWORD(1) // 4 +#define CRM_GET_DAQ_CLOCK_MCAST_CLUSTER_IDENTIFIER CRM_WORD(4) // 8 +#define CRM_GET_DAQ_CLOCK_MCAST_COUNTER CRM_BYTE(10) // 10 +#define CRM_GET_DAQ_CLOCK_MCAST_SYNCH_STATE CRM_BYTE(11) // 11 + +#define CRM_GET_DAQ_CLOCK_MCAST_TIME64_LOW CRM_DWORD(1) // 4 +#define CRM_GET_DAQ_CLOCK_MCAST_TIME64_HIGH CRM_DWORD(2) // 8 +#define CRM_GET_DAQ_CLOCK_MCAST_CLUSTER_IDENTIFIER64 CRM_WORD(6) // 12 +#define CRM_GET_DAQ_CLOCK_MCAST_COUNTER64 CRM_BYTE(14) // 14 +#define CRM_GET_DAQ_CLOCK_MCAST_SYNCH_STATE64 CRM_BYTE(15) // 15 +#endif + +/* READ_DAQ */ +#define CRO_READ_DAQ_LEN 1 +#define CRM_READ_DAQ_LEN 8 +#define CRM_READ_DAQ_BITOFFSET CRM_BYTE(1) +#define CRM_READ_DAQ_SIZE CRM_BYTE(2) +#define CRM_READ_DAQ_EXT CRM_BYTE(3) +#define CRM_READ_DAQ_ADDR CRM_DWORD(1) + + +/* GET_DAQ_PROCESSOR_INFO */ +#define CRO_GET_DAQ_PROCESSOR_INFO_LEN 1 +#define CRM_GET_DAQ_PROCESSOR_INFO_LEN 8 +#define CRM_GET_DAQ_PROCESSOR_INFO_PROPERTIES CRM_BYTE(1) +#define CRM_GET_DAQ_PROCESSOR_INFO_MAX_DAQ CRM_WORD(1) +#define CRM_GET_DAQ_PROCESSOR_INFO_MAX_EVENT CRM_WORD(2) +#define CRM_GET_DAQ_PROCESSOR_INFO_MIN_DAQ CRM_BYTE(6) +#define CRM_GET_DAQ_PROCESSOR_INFO_DAQ_KEY_BYTE CRM_BYTE(7) + + +/* GET_DAQ_RESOLUTION_INFO */ +#define CRO_GET_DAQ_RESOLUTION_INFO_LEN 1 +#define CRM_GET_DAQ_RESOLUTION_INFO_LEN 8 +#define CRM_GET_DAQ_RESOLUTION_INFO_GRANULARITY_DAQ CRM_BYTE(1) +#define CRM_GET_DAQ_RESOLUTION_INFO_MAX_SIZE_DAQ CRM_BYTE(2) +#define CRM_GET_DAQ_RESOLUTION_INFO_GRANULARITY_STIM CRM_BYTE(3) +#define CRM_GET_DAQ_RESOLUTION_INFO_MAX_SIZE_STIM CRM_BYTE(4) +#define CRM_GET_DAQ_RESOLUTION_INFO_TIMESTAMP_MODE CRM_BYTE(5) +#define CRM_GET_DAQ_RESOLUTION_INFO_TIMESTAMP_TICKS CRM_WORD(3) +#define CRM_GET_DAQ_RESOLUTION_INFO_TIMESTAMP_TICKS_WRITE(ticks) CRM_WORD_WRITE(3, ticks) + + +/* GET_DAQ_LIST_INFO */ +#define CRO_GET_DAQ_LIST_INFO_LEN 4 +#define CRO_GET_DAQ_LIST_INFO_DAQ CRO_WORD(1) +#define CRM_GET_DAQ_LIST_INFO_LEN 6 +#define CRM_GET_DAQ_LIST_INFO_PROPERTIES CRM_BYTE(1) +#define CRM_GET_DAQ_LIST_INFO_MAX_ODT CRM_BYTE(2) +#define CRM_GET_DAQ_LIST_INFO_MAX_ODT_ENTRY CRM_BYTE(3) +#define CRM_GET_DAQ_LIST_INFO_FIXED_EVENT CRM_WORD(2) + + +/* GET_DAQ_EVENT_INFO */ +#define CRO_GET_DAQ_EVENT_INFO_LEN 4 +#define CRO_GET_DAQ_EVENT_INFO_EVENT CRO_WORD(1) +#define CRM_GET_DAQ_EVENT_INFO_LEN 7 +#define CRM_GET_DAQ_EVENT_INFO_PROPERTIES CRM_BYTE(1) +#define CRM_GET_DAQ_EVENT_INFO_MAX_DAQ_LIST CRM_BYTE(2) +#define CRM_GET_DAQ_EVENT_INFO_NAME_LENGTH CRM_BYTE(3) +#define CRM_GET_DAQ_EVENT_INFO_TIME_CYCLE CRM_BYTE(4) +#define CRM_GET_DAQ_EVENT_INFO_TIME_UNIT CRM_BYTE(5) +#define CRM_GET_DAQ_EVENT_INFO_PRIORITY CRM_BYTE(6) + + +#define DAQ_EVENT_PROPERTIES_DAQ 0x04 +#define DAQ_EVENT_PROPERTIES_STIM 0x08 +#define DAQ_EVENT_PROPERTIES_PACKED 0x10 +#define DAQ_EVENT_PROPERTIES_EVENT_CONSISTENCY 0x80 + + +/* FREE_DAQ */ +#define CRO_FREE_DAQ_LEN 1 +#define CRM_FREE_DAQ_LEN 1 + + +/* ALLOC_DAQ */ +#define CRO_ALLOC_DAQ_LEN 4 +#define CRO_ALLOC_DAQ_COUNT CRO_WORD(1) +#define CRM_ALLOC_DAQ_LEN 1 + + +/* ALLOC_ODT */ +#define _CRO_ALLOC_ODT_LEN 3 +#define _CRO_ALLOC_ODT_DAQ CRO_WORD(1) +#define _CRO_ALLOC_ODT_COUNT CRO_BYTE(1) +#define CRO_ALLOC_ODT_LEN 5 +#define CRO_ALLOC_ODT_DAQ CRO_WORD(1) +#define CRO_ALLOC_ODT_COUNT CRO_BYTE(4) +#define CRM_ALLOC_ODT_LEN 1 + + +/* ALLOC_ODT_ENTRY */ +#define CRO_ALLOC_ODT_ENTRY_LEN 6 +#define CRO_ALLOC_ODT_ENTRY_DAQ CRO_WORD(1) +#define CRO_ALLOC_ODT_ENTRY_ODT CRO_BYTE(4) +#define CRO_ALLOC_ODT_ENTRY_COUNT CRO_BYTE(5) +#define CRM_ALLOC_ODT_ENTRY_LEN 1 + + +/* PROGRAM_START */ +#define CRO_PROGRAM_START_LEN 1 +#define CRM_PROGRAM_START_LEN 7 +#define CRM_PROGRAM_COMM_MODE_PGM CRM_BYTE(2) +#define CRM_PROGRAM_MAX_CTO_PGM CRM_BYTE(3) +#define CRM_PROGRAM_MAX_BS_PGM CRM_BYTE(4) +#define CRM_PROGRAM_MIN_ST_PGM CRM_BYTE(5) +#define CRM_PROGRAM_QUEUE_SIZE_PGM CRM_BYTE(6) + + +/* PROGRAM_CLEAR */ +#define CRO_PROGRAM_CLEAR_LEN 8 +#define CRO_PROGRAM_CLEAR_MODE CRO_BYTE(1) +#define CRO_PROGRAM_CLEAR_SIZE CRO_DWORD(1) +#define CRM_PROGRAM_CLEAR_LEN 1 + + +/* PROGRAM */ +#define CRO_PROGRAM_MAX_SIZE ((uint8_t)(XCPTL_MAX_CTO_SIZE-2)) +#define CRO_PROGRAM_LEN 2 /* + CRO_PROGRAM_SIZE */ +#define CRO_PROGRAM_SIZE CRO_BYTE(1) +#define CRO_PROGRAM_DATA (&CRO_BYTE(2)) +#define CRM_PROGRAM_LEN 1 + + +/* PROGRAM RESET */ +#define CRO_PROGRAM_RESET_LEN 1 +#define CRM_PROGRAM_RESET_LEN 1 + + +/* GET_PGM_PROCESSOR_INFO*/ +#define CRO_GET_PGM_PROCESSOR_INFO_LEN 1 +#define CRM_GET_PGM_PROCESSOR_INFO_LEN 3 +#define CRM_GET_PGM_PROCESSOR_INFO_PROPERTIES CRM_BYTE(1) +#define CRM_GET_PGM_PROCESSOR_INFO_MAX_SECTOR CRM_BYTE(2) + + +/* GET_SECTOR_INFO */ +#define CRO_PROGRAM_GET_SECTOR_INFO_LEN 3 +#define CRO_PROGRAM_GET_SECTOR_INFO_MODE CRO_BYTE(1) +#define CRO_PROGRAM_GET_SECTOR_INFO_NUMBER CRO_BYTE(2) +#define CRM_PROGRAM_GET_SECTOR_INFO_LEN 8 +#define CRM_PROGRAM_GET_SECTOR_CLEAR_SEQ_NUM CRM_BYTE(1) +#define CRM_PROGRAM_GET_SECTOR_PGM_SEQ_NUM CRM_BYTE(2) +#define CRM_PROGRAM_GET_SECTOR_PGM_METHOD CRM_BYTE(3) +#define CRM_PROGRAM_GET_SECTOR_SECTOR_INFO CRM_DWORD(1) +#define CRM_PROGRAM_GET_SECTOR_SECTOR_INFO_WRITE(info) CRM_DWORD_WRITE(1, info) + + +/* PROGRAM_PREPARE */ +#define CRO_PROGRAM_PREPARE_LEN 4 +#define CRO_PROGRAM_PREPARE_SIZE CRO_WORD(1) +#define CRM_PROGRAM_PREPARE_LEN 1 + + +/* PROGRAM_FORMAT */ +#define CRO_PROGRAM_FORMAT_LEN 5 +#define CRO_PROGRAM_FORMAT_COMPRESSION_METHOD CRO_BYTE(1) +#define CRO_PROGRAM_FORMAT_ENCRYPTION_METHOD CRO_BYTE(2) +#define CRO_PROGRAM_FORMAT_PROGRAMMING_METHOD CRO_BYTE(3) +#define CRO_PROGRAM_FORMAT_ACCESS_METHOD CRO_BYTE(4) +#define CRM_PROGRAM_FORMAT_LEN 1 + + +/* PROGRAM_NEXT */ +#define CRO_PROGRAM_NEXT_MAX_SIZE ((uint8_t)(XCPTL_MAX_CTO_SIZE-2)) +#define CRO_PROGRAM_NEXT_LEN 2 /* + size */ +#define CRO_PROGRAM_NEXT_SIZE CRO_BYTE(1) +#define CRO_PROGRAM_NEXT_DATA (&CRO_BYTE(2)) +#define CRM_PROGRAM_NEXT_LEN 3 +#define CRM_PROGRAM_NEXT_ERR_SEQUENCE CRM_BYTE(1) +#define CRM_PROGRAM_NEXT_SIZE_EXPECTED_DATA CRM_BYTE(2) + + +/* PROGRAM_MAX */ +#define CRO_PROGRAM_MAX_MAX_SIZE ((uint8_t)(XCPTL_MAX_CTO_SIZE-1)) +#define CRO_PROGRAM_MAX_DATA (&CRO_BYTE(1)) +#define CRM_PROGRAM_MAX_LEN 1 + + +/* PROGRAM_VERIFY */ +#define CRO_PROGRAM_VERIFY_LEN 8 +#define CRO_PROGRAM_VERIFY_MODE CRO_BYTE(1) +#define CRO_PROGRAM_VERIFY_TYPE CRO_WORD(1) +#define CRO_PROGRAM_VERIFY_VALUE CRO_DWORD(1) +#define CRM_PROGRAM_VERIFY_LEN 1 + + +/* GET_SERVER_ID */ +/* +#define CRO_GET_SERVER_ID_LEN 6 +#define CRO_GET_SERVER_ID_SUB_CODE CRO_BYTE(1) +#define CRO_GET_SERVER_ID_X CRO_BYTE(2) +#define CRO_GET_SERVER_ID_C CRO_BYTE(3) +#define CRO_GET_SERVER_ID_P CRO_BYTE(4) +#define CRO_GET_SERVER_ID_MODE CRO_BYTE(5) +#define CRM_GET_SERVER_ID_LEN 8 +#define CRM_GET_SERVER_ID_X CRM_BYTE(1) +#define CRM_GET_SERVER_ID_C CRM_BYTE(2) +#define CRM_GET_SERVER_ID_P CRM_BYTE(3) +#define CRM_GET_SERVER_ID_CAN_ID_CMD_STIM CRM_DWORD(1) +*/ + +/* GET_DAQ_ID */ +#define CRO_GET_DAQ_ID_LEN 3 +#define CRO_GET_DAQ_ID_SUB_CODE CRO_BYTE(1) +#define CRO_GET_DAQ_ID_DAQ CRO_WORD(1) +#define CRM_GET_DAQ_ID_LEN 8 +#define CRM_GET_DAQ_ID_FIXED CRM_BYTE(1) +#define CRM_GET_DAQ_ID_ID CRM_DWORD(1) + + +/* SET_DAQ_ID */ +#define CRO_SET_DAQ_ID_LEN 8 +#define CRO_SET_DAQ_ID_SUB_CODE CRO_BYTE(1) +#define CRO_SET_DAQ_ID_DAQ CRO_WORD(1) +#define CRO_SET_DAQ_ID_ID CRO_DWORD(1) +#define CRM_SET_DAQ_ID_LEN 1 + + +/* SET_SERVER_PORT */ +#define CRO_SET_SERVER_PORT_LEN 4 +#define CRO_SET_SERVER_PORT_SUB_CODE CRO_BYTE(1) +#define CRO_SET_SERVER_PORT_PORT CRO_WORD(1) +#define CRM_SET_SERVER_PORT 1 + + +/* Level 1 commands */ +#define CRO_LEVEL_1_COMMAND_LEN 2 +#define CRO_LEVEL_1_COMMAND_CODE CRO_BYTE(1) + + +/* GET_VERSION */ +#define CRO_GET_VERSION_LEN 2 +#define CRM_GET_VERSION_LEN 6 +#define CRM_GET_VERSION_RESERVED CRM_BYTE(1) +#define CRM_GET_VERSION_PROTOCOL_VERSION_MAJOR CRM_BYTE(2) +#define CRM_GET_VERSION_PROTOCOL_VERSION_MINOR CRM_BYTE(3) +#define CRM_GET_VERSION_TRANSPORT_VERSION_MAJOR CRM_BYTE(4) +#define CRM_GET_VERSION_TRANSPORT_VERSION_MINOR CRM_BYTE(5) + + +/* GET_DAQ_LIST_PACKED_MODE */ +#define CRO_GET_DAQ_LIST_PACKED_MODE_DAQ CRM_WORD(1) +#define CRM_GET_DAQ_LIST_PACKED_MODE_LEN 8 +#define CRM_GET_DAQ_LIST_PACKED_MODE_MODE CRM_BYTE(2) + + +/* SET_DAQ_LIST_PACKED_MODE */ +#define CRO_SET_DAQ_LIST_PACKED_MODE_DAQ CRO_WORD(1) +#define CRO_SET_DAQ_LIST_PACKED_MODE_MODE CRO_BYTE(4) +#define CRO_SET_DAQ_LIST_PACKED_MODE_TIMEMODE CRO_BYTE(5) +#define CRO_SET_DAQ_LIST_PACKED_MODE_SAMPLECOUNT CRO_WORD(3) + +#define DPM_TIMESTAMP_MODE_LAST 0 +#define DPM_TIMESTAMP_MODE_FIRST 1 + + +/* TIME SYNCHRONIZATION PROPERTIES*/ +#define CRO_TIME_SYNCH_PROPERTIES_LEN 6 +#define CRO_TIME_SYNCH_PROPERTIES_SET_PROPERTIES CRO_BYTE(1) +#define CRO_TIME_SYNCH_PROPERTIES_GET_PROPERTIES_REQUEST CRO_BYTE(2) +#define CRO_TIME_SYNCH_PROPERTIES_CLUSTER_ID CRO_WORD(2) + +/* CRO_TIME_SYNCH_PROPERTIES_SET_PROPERTIES: */ +#define TIME_SYNCH_SET_PROPERTIES_RESPONSE_FMT (3 << 0) +#define TIME_SYNCH_SET_PROPERTIES_TIME_SYNCH_BRIDGE (3 << 2) +#define TIME_SYNCH_SET_PROPERTIES_CLUSTER_ID (1 << 4) + +#define TIME_SYNCH_RESPONSE_FMT_LEGACY 0 +#define TIME_SYNCH_RESPONSE_FMT_TRIGGER_SUBSET 1 +#define TIME_SYNCH_RESPONSE_FMT_TRIGGER_ALL 2 + +/* CRO_TIME_SYNCH_PROPERTIES_GET_PROPERTIES_REQUEST: */ +#define TIME_SYNCH_GET_PROPERTIES_GET_CLK_INFO (1 << 0) + + +#define CRM_TIME_SYNCH_PROPERTIES_LEN 8 +#define CRM_TIME_SYNCH_PROPERTIES_SERVER_CONFIG CRM_BYTE(1) +#define CRM_TIME_SYNCH_PROPERTIES_OBSERVABLE_CLOCKS CRM_BYTE(2) +#define CRM_TIME_SYNCH_PROPERTIES_SYNCH_STATE CRM_BYTE(3) +#define CRM_TIME_SYNCH_PROPERTIES_CLOCK_INFO CRM_BYTE(4) +#define CRM_TIME_SYNCH_PROPERTIES_RESERVED CRM_BYTE(5) +#define CRM_TIME_SYNCH_PROPERTIES_CLUSTER_ID CRM_WORD(3) + +/* CRM_TIME_SYNCH_PROPERTIES_SERVER_CONFIG: */ +#define SERVER_CONFIG_RESPONSE_FMT_LEGACY (0) +#define SERVER_CONFIG_RESPONSE_FMT_ADVANCED (2) +#define SERVER_CONFIG_DAQ_TS_ECU (1 << 2) +#define SERVER_CONFIG_DAQ_TS_SERVER (0 << 2) +#define SERVER_CONFIG_TIME_SYNCH_BRIDGE_NONE (0 << 3) + +/* CRM_TIME_SYNCH_PROPERTIES_OBSERVABLE_CLOCKS: */ +#define LOCAL_CLOCK_FREE_RUNNING (0<<0) +#define LOCAL_CLOCK_SYNCHED (1<<0) +#define LOCAL_CLOCK_NONE (2<<0) +#define GRANDM_CLOCK_NONE (0<<2) +#define GRANDM_CLOCK_READABLE (1<<2) +#define GRANDM_CLOCK_EVENT (2<<2) +#define ECU_CLOCK_NONE (0<<4) +#define ECU_CLOCK_READABLE (1<<4) +#define ECU_CLOCK_EVENT (2<<4) +#define ECU_CLOCK_NOTREADABLE (3<<4) + +/* CRM_TIME_SYNCH_PROPERTIES_SYNCH_STATE: */ +#define LOCAL_CLOCK_STATE_SYNCH_IN_PROGRESS (0 << 0) +#define LOCAL_CLOCK_STATE_SYNCH (1 << 0) +#define LOCAL_CLOCK_STATE_SYNT_IN_PROGRESS (2 << 0) +#define LOCAL_CLOCK_STATE_SYNT (3 << 0) +#define LOCAL_CLOCK_STATE_FREE_RUNNING (7 << 0) +#define GRANDM_CLOCK_STATE_SYNCH_IN_PROGRESS (0 << 3) +#define GRANDM_CLOCK_STATE_SYNCH (1 << 3) + + +/* CRM_TIME_SYNCH_PROPERTIES_CLOCK_INFO: */ +#define CLOCK_INFO_SERVER (1<<0) +#define CLOCK_INFO_GRANDM (1<<1) +#define CLOCK_INFO_RELATION (1<<2) +#define CLOCK_INFO_ECU (1<<3) +#define CLOCK_INFO_ECU_GRANDM (1<<4) + +/* TRIGGER_INITIATOR: + 0 = HW trigger, i.e.Vector Syncline + 1 = Event derived from XCP - independent time synchronization event - e.g.globally synchronized pulse per second signal + 2 = GET_DAQ_CLOCK_MULTICAST + 3 = GET_DAQ_CLOCK_MULTICAST via Time Sync Bridge + 4 = State change in syntonization / synchronization to grandmaster clock(either established or lost, additional information is provided by the SYNCH_STATE field - see Table 236) + 5 = Leap second occurred on grandmaster clock + 6 = release of ECU reset +*/ +#define TRIG_INITIATOR_SYNCH_LINE 0UL +#define TRIG_INITIATOR_XCP_INDEPENDENT 1UL +#define TRIG_INITIATOR_MULTICAST 2UL +#define TRIG_INITIATOR_MULTICAST_TS_BRIDGE 3UL +#define TRIG_INITIATOR_SYNCH_STATE_CHANGE 4UL +#define TRIG_INITIATOR_LEAP_SECOND 5UL +#define TRIG_INITIATOR_ECU_RESET_RELEASE 6UL +#define TRIG_INITIATOR_RESERVED 7UL + + +#define TIME_OF_TS_SAMPLING_PROTOCOL_PROCESSOR 0UL +#define TIME_OF_TS_SAMPLING_LOW_JITTER 1UL +#define TIME_OF_TS_SAMPLING_PHY_TRANSMISSION 2UL +#define TIME_OF_TS_SAMPLING_PHY_RECEPTION 3UL + + +/****************************************************************************/ +/* XCP clock information */ +/****************************************************************************/ + +#define XCP_STRATUM_LEVEL_UNKNOWN 255 // Unknown +#define XCP_STRATUM_LEVEL_RTC 3 // Realtime Clock +#define XCP_STRATUM_LEVEL_GPS 0 // GPS Clock + +#define XCP_EPOCH_TAI 0 // Atomic monotonic time since 1.1.1970 (TAI) +#define XCP_EPOCH_UTC 1 // Universal Coordinated Time (with leap seconds) since 1.1.1970 (UTC) +#define XCP_EPOCH_ARB 2 // Arbitrary (unknown) + +#pragma pack(push, 1) + +typedef struct { + uint8_t UUID[8]; + uint16_t timestampTicks; + uint8_t timestampUnit; + uint8_t stratumLevel; + uint8_t nativeTimestampSize; + uint8_t fill[3]; // for alignment (8 byte) of structure + uint64_t valueBeforeWrapAround; +} T_CLOCK_INFO; + + +#ifdef XCP_ENABLE_PTP + +typedef struct { + uint8_t UUID[8]; + uint16_t timestampTicks; + uint8_t timestampUnit; + uint8_t stratumLevel; + uint8_t nativeTimestampSize; + uint8_t epochOfGrandmaster; + uint8_t fill[2]; // for alignment (8 byte) of structure + uint64_t valueBeforeWrapAround; +} T_CLOCK_INFO_GRANDMASTER; + +typedef struct { + uint64_t timestampOrigin; + uint64_t timestampLocal; +} T_CLOCK_INFO_RELATION; + +#endif + +#pragma pack(pop) + +/***************************************************************************/ +/* XCP Transport Layer Commands and Responces, Type Definition */ +/***************************************************************************/ + + +/* Transport Layer commands */ +#define CC_TL_GET_SERVER_ID 0xFF +#define CC_TL_GET_SERVER_ID_EXTENDED 0xFD +#define CC_TL_SET_SERVER_IP 0xFC +#define CC_TL_GET_DAQ_CLOCK_MULTICAST 0xFA +#define CRO_TL_SUBCOMMAND CRO_BYTE(1) + + +/* GET_SERVER_ID and GET_SERVER_ID_EXTENDED */ +#define CRO_TL_GET_SERVER_ID_LEN 21 +#define CRO_TL_GET_SERVER_ID_PORT CRO_WORD(1) +#define CRO_TL_GET_SERVER_ID_ADDR(n) CRO_BYTE(4+n) +#define CRO_TL_GET_SERVER_ID_MODE CRO_BYTE(20) + +/* GET_SERVER_ID */ +/* +#define CRM_TL_GET_SERVER_ID_LEN(n) (24+1+(n)) +#define CRM_TL_GET_SERVER_ID_ADDR(n) CRM_BYTE(n) +#define CRM_TL_GET_SERVER_ID_PORT CRM_WORD(8) +#define CRM_TL_GET_SERVER_ID_STATUS CRM_BYTE(18) +#define CRM_TL_GET_SERVER_ID_RESOURCE CRM_BYTE(19) +#define CRM_TL_GET_SERVER_ID_ID_LEN CRM_BYTE(20) +#define CRM_TL_GET_SERVER_ID_ID CRM_BYTE(21) +#define CRM_TL_GET_SERVER_ID_MAX_LEN 128 +*/ + +#define GET_SERVER_ID_STATUS_PROTOCOL_TCP 0 +#define GET_SERVER_ID_STATUS_PROTOCOL_UDP 1 +#define GET_SERVER_ID_STATUS_PROTOCOL_TCP_UDP 2 +#define GET_SERVER_ID_STATUS_IP_VERSION_IPV4 (0) +#define GET_SERVER_ID_STATUS_SLV_AVAILABILITY_BUSY (1<<3) +#define GET_SERVER_ID_STATUS_SLV_ID_EXT_SUPPORTED (1<<4) + +/* GET_SERVER_ID_EXT */ +#define CRM_TL_GET_SERVER_ID_LEN(n) (24+1+(n)) +#define CRM_TL_GET_SERVER_ID_ADDR(n) CRM_BYTE(2+n) +#define CRM_TL_GET_SERVER_ID_PORT CRM_WORD(18) +#define CRM_TL_GET_SERVER_ID_STATUS CRM_BYTE(20) +#define CRM_TL_GET_SERVER_ID_RESOURCE CRM_BYTE(21) +#define CRM_TL_GET_SERVER_ID_ID_LEN *(uint32_t*)&(CRM_BYTE(22)) // this is a DWORD on unaligned offset +#define CRM_TL_GET_SERVER_ID_ID CRM_BYTE(26) +#define CRM_TL_GET_SERVER_ID_MAC(n) CRM_BYTE(26+n) /*+CRM_TL_GET_SERVER_ID_ID_LEN*/ + +#define CRM_TL_GET_SERVER_ID_MAX_LEN (XCPTL_MAX_CTO_SIZE-(26+6)) + +/* GET_SERVER_ID_EXTENDED */ +#define TL_SLV_DETECT_STATUS_SLV_ID_EXT_RADAR_DATA (1<<0) +#define TL_SLV_DETECT_STATUS_SLV_ID_EXT_XCP_ON_PCIE (1<<1) + + diff --git a/A2lTestDlg/A2lTestDlg/xcpEthTl.h b/A2lTestDlg/A2lTestDlg/xcpEthTl.h new file mode 100644 index 0000000..b9dee19 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/xcpEthTl.h @@ -0,0 +1,27 @@ +#pragma once + +/* xcpEthTl.h */ + +/* Copyright(c) Vector Informatik GmbH.All rights reserved. + Licensed under the MIT license.See LICENSE file in the project root for details. */ + +/* ETH transport Layer functions called by application */ +extern BOOL XcpEthTlInit(const uint8_t* addr, uint16_t port, BOOL useTCP, uint16_t segmentSize, BOOL blockingRx); // Start transport layer + +// Test mode +#ifdef XCPTL_ENABLE_SELF_TEST +extern void XcpEthTlCreateA2lDescription(); +extern void XcpEthTlCreateXcpEvents(); +extern uint64_t XcpEthTlGetBytesWritten(); // Get the number of bytes send +#endif + + +/* ETH transport Layer functions called by XCPlite.c */ +extern void XcpEthTlSendMulticastCrm(const uint8_t* data, uint16_t n, const uint8_t* addr, uint16_t port); // Send multicast command response +#ifdef XCPTL_ENABLE_MULTICAST +extern void XcpEthTlSetClusterId(uint16_t clusterId); // Set cluster id for GET_DAQ_CLOCK_MULTICAST reception +#endif + +extern void XcpEthTlGetInfo(BOOL* isTCP, uint8_t* mac, uint8_t* addr, uint16_t* port); + + diff --git a/A2lTestDlg/A2lTestDlg/xcpLite.h b/A2lTestDlg/A2lTestDlg/xcpLite.h new file mode 100644 index 0000000..bf3229e --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/xcpLite.h @@ -0,0 +1,188 @@ +#pragma once +/* xcpLite.h */ + +/* Copyright(c) Vector Informatik GmbH.All rights reserved. + Licensed under the MIT license.See LICENSE file in the project root for details. */ + + +#ifdef __XCPTL_CFG_H__ +#error "Include dependency error!" +#endif +#ifdef __XCP_CFG_H__ +#error "Include dependency error!" +#endif + + +// Transport layer type +// The protocol layer implementation has some dependencies on the transport layer type +// Some XCP commands are only supported on Ethernet and can not be compiled with MAX_CTO == 8 +#define XCP_TRANSPORT_LAYER_ETH 1 +#define XCP_TRANSPORT_LAYER_CAN 0 + +#include "xcptl_cfg.h" // Transport layer configuration + +// Transport layer definitions and configuration +#if XCP_TRANSPORT_LAYER_TYPE==XCP_TRANSPORT_LAYER_ETH +#include "xcpTl.h" +#include "xcpEthTl.h" // Ethernet transport layer specific functions +#elif XCP_TRANSPORT_LAYER_TYPE==XCP_TRANSPORT_LAYER_CAN +#include "xcptl.h" +#include "xcpcantl.h" +#else +#error "Define XCP_TRANSPORT_LAYER_ETH or XCP_TRANSPORT_LAYER_CAN" +#endif + +// Protocol layer definitions and configuration +#include "xcp_cfg.h" // Protocol layer configuration +#include "xcp.h" // XCP protocol defines + + + +/****************************************************************************/ +/* DAQ event information */ +/****************************************************************************/ + +#ifdef XCP_ENABLE_DAQ_EVENT_LIST + +#define XCP_MAX_EVENT_NAME 8 + +typedef struct { + char shortName[XCP_MAX_EVENT_NAME+1]; // A2L XCP IF_DATA short event name, long name not supported + uint32_t size; // ext event size + uint8_t timeUnit; // timeCycle unit, 1ns=0, 10ns=1, 100ns=2, 1us=3, ..., 1ms=6, ... + uint8_t timeCycle; // cycletime in units, 0 = sporadic or unknown + uint16_t sampleCount; // packed event sample count + uint16_t daqList; // associated DAQ list + uint8_t priority; // priority 0 = queued, 1 = pushing, 2 = realtime +#ifdef XCP_ENABLE_MULTITHREAD_EVENTS + MUTEX mutex; +#endif +#ifdef XCP_ENABLE_TEST_CHECKS + uint64_t time; // last event time stamp +#endif +} tXcpEvent; + +#endif + + +/****************************************************************************/ +/* Protocol layer interface */ +/****************************************************************************/ + +/* Initialization for the XCP Protocol Layer */ +extern void XcpInit(void); +extern void XcpStart(void); +extern void XcpDisconnect(); +extern void XcpReset(); + +/* Trigger a XCP data acquisition or stimulation event */ +extern void XcpEvent(uint16_t event); +extern void XcpEventExt(uint16_t event, uint8_t* base); +extern void XcpEventAt(uint16_t event, uint64_t clock); + +/* XCP command processor */ +extern void XcpCommand( const uint32_t* pCommand, uint16_t len ); + +/* Send an XCP event message */ +extern void XcpSendEvent(uint8_t evc, const uint8_t* d, uint8_t l); + +/* Check status */ +extern BOOL XcpIsStarted(); +extern BOOL XcpIsConnected(); +extern BOOL XcpIsDaqRunning(); +extern BOOL XcpIsDaqEventRunning(uint16_t event); +extern uint64_t XcpGetDaqStartTime(); +extern uint32_t XcpGetDaqOverflowCount(); + +/* Time synchronisation */ +#ifdef XCP_ENABLE_DAQ_CLOCK_MULTICAST +extern uint16_t XcpGetClusterId(); +#endif + +// Event list +#ifdef XCP_ENABLE_DAQ_EVENT_LIST + +#define XCP_INVALID_EVENT 0xFFFF + +// Clear event list +extern void XcpClearEventList(); +// Add a measurement event to event list, return event number (0..MAX_EVENT-1) +extern uint16_t XcpCreateEvent(const char* name, uint32_t cycleTimeNs /* ns */, uint8_t priority /* 0-normal, >=1 realtime*/, uint16_t sampleCount, uint32_t size); +// Get event list +extern tXcpEvent* XcpGetEventList(uint16_t* eventCount); +// Lookup event +extern tXcpEvent* XcpGetEvent(uint16_t event); + +#endif + + +/****************************************************************************/ +/* Protocol layer external dependencies */ +/****************************************************************************/ + +// All callback functions supplied by the application +// Must be thread save + +/* Callbacks on connect, measurement prepare, start and stop */ +extern BOOL ApplXcpConnect(); +#if XCP_PROTOCOL_LAYER_VERSION >= 0x0104 +extern BOOL ApplXcpPrepareDaq(); +#endif +extern BOOL ApplXcpStartDaq(); +extern void ApplXcpStopDaq(); + +/* Address conversions from A2L address to pointer and vice versa */ +/* Note that xcpAddrExt 0x01 and 0xFF are reserved for special use cases (0x01 if XCP_ENABLE_DYN_ADDRESSING, 0xFF if XCP_ENABLE_IDT_A2L_UPLOAD) */ +extern uint8_t* ApplXcpGetPointer(uint8_t xcpAddrExt, uint32_t xcpAddr); /* Create a pointer (uint8_t*) from xcpAddrExt and xcpAddr, returns NULL if no access */ +extern uint32_t ApplXcpGetAddr(uint8_t* p); // Calculate the xcpAddr address from a pointer +extern uint8_t *ApplXcpGetBaseAddr(); // Get the base address for DAQ data access */ +/* + Note 1: + For DAQ performance and memory optimization: + XCPlite DAQ tables do not store address extensions and do not use ApplXcpGetPointer(), addr is stored as 32 Bit value and access is hardcoded by *(baseAddr+xcpAddr) + All accesible DAQ data is within a 4GByte range starting at ApplXcpGetBaseAddr() + Address extensions to increase the addressable range are not supported yet + Attempting to setup an ODT entry with address extension != 0 gives a CRC_ACCESS_DENIED error message + + Note 2: + ApplXcpGetPointer may do address transformations according to active calibration page + When measuring calibration variables inswitch +*/ + + +/* Switch calibration pages */ +#ifdef XCP_ENABLE_CAL_PAGE +extern uint8_t ApplXcpGetCalPage(uint8_t segment, uint8_t mode); +extern uint8_t ApplXcpSetCalPage(uint8_t segment, uint8_t page, uint8_t mode); +#endif + +/* DAQ clock */ +extern uint64_t ApplXcpGetClock64(); + +#define CLOCK_STATE_SYNCH_IN_PROGRESS (0) +#define CLOCK_STATE_SYNCH (1) +#define CLOCK_STATE_FREE_RUNNING (7) +#define CLOCK_STATE_GRANDMASTER_STATE_SYNCH (1 << 3) +extern uint8_t ApplXcpGetClockState(); + +#ifdef XCP_ENABLE_PTP +#define CLOCK_STRATUM_LEVEL_UNKNOWN 255 +#define CLOCK_STRATUM_LEVEL_ARB 16 // unsychronized +#define CLOCK_STRATUM_LEVEL_UTC 0 // Atomic reference clock +#define CLOCK_EPOCH_TAI 0 // Atomic monotonic time since 1.1.1970 (TAI) +#define CLOCK_EPOCH_UTC 1 // Universal Coordinated Time (with leap seconds) since 1.1.1970 (UTC) +#define CLOCK_EPOCH_ARB 2 // Arbitrary (epoch unknown) +extern BOOL ApplXcpGetClockInfoGrandmaster(uint8_t* uuid, uint8_t* epoch, uint8_t* stratum); +#endif + +/* Get info for GET_ID command (pointer to and length of data) */ +/* Supports IDT_ASCII, IDT_ASAM_NAME, IDT_ASAM_PATH, IDT_ASAM_URL, IDT_ASAM_EPK and IDT_ASAM_UPLOAD */ +/* Returns 0 if not available */ +extern uint32_t ApplXcpGetId(uint8_t id, uint8_t* buf, uint32_t bufLen); + +/* Read a chunk (offset,size) of the A2L file for upload */ +/* Return FALSE if out of bounds */ +#ifdef XCP_ENABLE_IDT_A2L_UPLOAD // Enable A2L content upload to host (IDT_ASAM_UPLOAD) +extern BOOL ApplXcpReadA2L(uint8_t size, uint32_t offset, uint8_t* data); +#endif + diff --git a/A2lTestDlg/A2lTestDlg/xcpTl.h b/A2lTestDlg/A2lTestDlg/xcpTl.h new file mode 100644 index 0000000..058083d --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/xcpTl.h @@ -0,0 +1,32 @@ +#pragma once +/* xcpTl.h */ + +/* Copyright(c) Vector Informatik GmbH.All rights reserved. + Licensed under the MIT license.See LICENSE file in the project root for details. */ + +#define XCPTL_TIMEOUT_INFINITE 0xFFFFFFFF // Infinite timeout (blocking mode) for XcpTlHandleCommands, XcpTlWaitForTransmitData + + +/* Transport Layer functions called by XCPlite.c */ +extern BOOL XcpTlHandleCommands(uint32_t timeout_ms); // Handle all incoming XCP commands, (wait for at least timeout_ms) +extern void XcpTlSendCrm(const uint8_t* data, uint16_t n); // Send or queue (depending on XCPTL_QUEUED_CRM) a command response +extern uint8_t* XcpTlGetTransmitBuffer(void** par, uint16_t size); // Get a buffer for a message with size +extern void XcpTlCommitTransmitBuffer(void* par, BOOL flush); // Commit a buffer (by handle returned from XcpTlGetTransmitBuffer) +extern void XcpTlFlushTransmitBuffer(); // Finalize the current transmit packet (ETH only) +extern void XcpTlWaitForTransmitQueueEmpty(); // Wait (sleep) until transmit queue is empty + +/* Generic transport Layer functions called by application */ +/* All other application functions functions declared in xcpCanTl.h or xcpEthTl.h */ +extern int32_t XcpTlHandleTransmitQueue(); // Send all outgoing packets in the transmit queue +extern BOOL XcpTlWaitForTransmitData(uint32_t timeout_ms); // Wait for at least timeout_ms, until packets are pending in the transmit queue +extern void XcpTlShutdown(); + +// Get last error code +#define XCPTL_OK 0 +#define XCPTL_ERROR_WOULD_BLOCK 1 +#define XCPTL_ERROR_SEND_FAILED 2 +#define XCPTL_ERROR_INVALID_MASTER 3 +extern int32_t XcpTlGetLastError(); + +// Get transmit queue level +extern int32_t XcpTlGetTransmitQueueLevel(); diff --git a/A2lTestDlg/A2lTestDlg/xcp_cfg.h b/A2lTestDlg/A2lTestDlg/xcp_cfg.h new file mode 100644 index 0000000..7b4a0ce --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/xcp_cfg.h @@ -0,0 +1,104 @@ +#pragma once + +/*---------------------------------------------------------------------------- +| File: +| xcp_cfg.h +| +| Description: +| User configuration file for XCP protocol layer parameters +| +| Code released into public domain, no attribution required +| + ----------------------------------------------------------------------------*/ + + + +/*----------------------------------------------------------------------------*/ +/* Version */ + +// Driver version (GET_COMM_MODE_INFO) +#define XCP_DRIVER_VERSION 0x01 + +// Protocol layer version +// #define XCP_PROTOCOL_LAYER_VERSION 0x0101 +#define XCP_PROTOCOL_LAYER_VERSION 0x0103 // GET_DAQ_CLOCK_MULTICAST, GET_TIME_CORRELATION_PROPERTIES +// #define XCP_PROTOCOL_LAYER_VERSION 0x0104 // PACKED_MODE, CC_START_STOP_SYNCH prepare + + + + + +/*----------------------------------------------------------------------------*/ +/* Driver features */ + +#define XCP_TRANSPORT_LAYER_TYPE XCP_TRANSPORT_LAYER_ETH // Enable ethernet specific commands + +#if OPTION_ENABLE_XCP_CLASS + #define XCP_ENABLE_DYN_ADDRESSING // Enable addr_ext=1 indicating relative addr format (event<<16)|offset +#endif + +/*----------------------------------------------------------------------------*/ +/* Protocol features */ + +//#define XCP_ENABLE_INTERLEAVED +//#define XCP_INTERLEAVED_QUEUE_SIZE 16 + +#define XCP_ENABLE_CHECKSUM // Enable checksum calculation command + +#define XCP_ENABLE_CAL_PAGE // Enable cal page switch + + +/*----------------------------------------------------------------------------*/ +/* GET_ID command */ + +#if OPTION_ENABLE_A2L_GEN +#define XCP_ENABLE_IDT_A2L_UPLOAD // Upload A2L via XCP UPLOAD +#endif + +/*----------------------------------------------------------------------------*/ +/* DAQ features and parameters */ + +// #define XCP_ENABLE_DAQ_EVENT_INFO // Enable XCP_GET_EVENT_INFO, if this is enabled, A2L file event information will be ignored +#define XCP_ENABLE_DAQ_EVENT_LIST // Enable event list +#define XCP_MAX_EVENT 256 // Maximum number of events, size of event table +#define XCP_ENABLE_MULTITHREAD_EVENTS // Make XcpEvent thread safe also for same event from different thread +// #define XCP_ENABLE_PACKED_MODE // Enable packed mode emulation + +#define XCP_DAQ_MEM_SIZE (5*100) // Amount of memory for DAQ tables, each ODT entry (e.g. measurement variable) needs 5 bytes + +// CLOCK_USE_UTC_TIME_NS +// Settings for 64 bit ns since 1.1.1970 TAI clock (CLOCK_USE_UTC_TIME_NS) + +#define XCP_DAQ_CLOCK_64BIT // Use 64 Bit time stamps in GET_DAQ_CLOCK +#define XCP_DAQ_CLOCK_UIID { 0xdc,0xa6,0x32,0xFF,0xFE,0x7e,0x66,0xdc } + +// Server DAQ clock info (mandatory) +#define XCP_TIMESTAMP_UNIT DAQ_TIMESTAMP_UNIT_1NS // unit DAQ_TIMESTAMP_UNIT_xxx +#define XCP_TIMESTAMP_TICKS 1 // ticks per unit +#define XCP_TIMESTAMP_EPOCH XCP_EPOCH_TAI + +// Grandmaster clock (optional, use XcpSetGrandmasterClockInfo, implement ApplXcpGetClockInfoGrandmaster) +// #define XCP_ENABLE_PTP + + +//#define XCP_ENABLE_DAQ_CLOCK_MULTICAST // Enable GET_DAQ_CLOCK_MULTICAST +#ifdef XCP_ENABLE_DAQ_CLOCK_MULTICAST + // XCP default cluster id (multicast addr 239,255,0,1, group 127,0,1 (mac 01-00-5E-7F-00-01) +#define XCP_MULTICAST_CLUSTER_ID 1 +#endif + +#define XCP_TIMESTAMP_TICKS_S CLOCK_TICKS_PER_S // ticks per s (for debug output) + + +//------------------------------------------------------------------------------- +// Debug + +// Debug console prints +#if OPTION_ENABLE_DBG_PRINTS +#define XCP_ENABLE_DEBUG_PRINTS +#define XCP_DBG_LEVEL XCP_DEBUG_LEVEL +#endif + +// Enable extended error checks, performance penalty !!! +#define XCP_ENABLE_TEST_CHECKS + diff --git a/A2lTestDlg/A2lTestDlg/xcptl_cfg.h b/A2lTestDlg/A2lTestDlg/xcptl_cfg.h new file mode 100644 index 0000000..c990486 --- /dev/null +++ b/A2lTestDlg/A2lTestDlg/xcptl_cfg.h @@ -0,0 +1,70 @@ +#pragma once + +/*---------------------------------------------------------------------------- +| File: +| xcptl_cfg.h +| +| Description: +| User configuration file for XCP transport layer parameters +| +| Code released into public domain, no attribution required +| + ----------------------------------------------------------------------------*/ + +// Transport layer +#define XCP_TRANSPORT_LAYER_TYPE XCP_TRANSPORT_LAYER_ETH +#define XCP_TRANSPORT_LAYER_VERSION 0x0104 + +// TCP or/and UDP option enabled +#define XCPTL_ENABLE_TCP +#define XCPTL_ENABLE_UDP + +// Transmit mode +#define XCPTL_QUEUED_CRM // Use transmit queue for command responces +/* +Benefits: +- Unique transport layers message counters for CRM and DTO (CANape default transport layer option is "include command response") +- Transmit queue empty before DAQ is stopped (end of measurement consistent for all event channels) +- socketSendTo needs not to be thread safe for a socket +Drawbacks: +- Increased latency for GET_DAQ_CLOCK response during DAQ running, which impacts time sync quality if XCP 1.3 trigger initiator "sampled on reception" is not supported +- Impact on DAQ performance because transport layer packet is flushed for command responses +- DAQ queue overflow can happen on command responses, CANape aborts when response to GET_DAQ_CLOCK is missing +*/ + +// Transport layer header size +// This is fixed, no other options supported +#define XCPTL_TRANSPORT_LAYER_HEADER_SIZE 4 + +// TL segment size and DTO size +// Segment size is the maximum data buffer size given to send/sendTo, for UDP it is the MTU +#define XCPTL_MAX_SEGMENT_SIZE (OPTION_MTU-20-8) // UDP MTU (MTU - IP-header - UDP-header) +#define XCPTL_MAX_DTO_SIZE (XCPTL_MAX_SEGMENT_SIZE-XCPTL_TRANSPORT_LAYER_HEADER_SIZE) // Normal ETH frame MTU - IPhdr - UDPhdr- XCPhdr, DTO size must be mod 4 +#define XCPTL_PACKET_ALIGNMENT 4 // Packet alignment for multiple XCP transport layer packets in a XCP transport layer message + +// CTO size +// Maximum size of a XCP command +#define XCPTL_MAX_CTO_SIZE 252 // must be mod 4 + +// DAQ transmit queue +// Transmit queue size in segments, should at least be able to hold all data produced until the next call to HandleTransmitQueue +#define XCPTL_QUEUE_SIZE 64 // array[XCPTL_QUEUE_SIZE] of tXcpMessageBuffer (XCPTL_MAX_SEGMENT_SIZE+4) +// Maximum queue trigger event rate +#define XCPTL_QUEUE_TRANSMIT_CYCLE_TIME (1*CLOCK_TICKS_PER_MS) +// Flush cycle +#define XCPTL_QUEUE_FLUSH_CYCLE_MS 50 // Send a DTO packet at least every x ms, XCPTL_TIMEOUT_INFINITE to turn off + +// Transport layer header size +// This is fixed, no other options supported +#define XCPTL_TRANSPORT_LAYER_HEADER_SIZE 4 + +// Multicast (GET_DAQ_CLOCK_MULTICAST) +// Use multicast time synchronisation to improve synchronisation of multiple XCP slaves +// This is standard in XCP V1.3, but it needs to create an additional thread and socket for multicast reception +// Has no benefit with PTP time synchronized slave and is just unnesserary effort +// CANape expects this by default -> adjust setting in device/protocol/event/TIME_CORRELATION_GETDAQCLOCK from "multicast" to "extended response" to switch it of +//#define XCPTL_ENABLE_MULTICAST +#ifdef XCPTL_ENABLE_MULTICAST + #define XCPTL_MULTICAST_PORT 5557 +#endif +