Обновление

Inc/CanSerialPortFrameXCP.h

@@ -222,7 +222,7 @@ typedef struct __attribute__ ((packed)) {
 #define MAX_ODT 20
 #define MAX_ODT_ENTRIES_SIZE 6
 
-#define MAX_EVENT_CHANNEL 20
+#define MAX_EVENT_CHANNEL 1
 
 typedef struct {
     uint8_t ODT_ENTRIES_COUNT;
@@ -232,7 +232,25 @@ typedef struct {
     uint32_t ODT_ENTRIES_ADR[MAX_ODT_ENTRIES_SIZE];
 } tXCP_ODT_ENTRIES;
 
+//typedef struct {
+//    uint8_t ALTERNATING;
+//    uint8_t DIRECTION;
+//    uint8_t DTO_CTR;
+//    uint8_t TIMESTAMP;
+//    uint8_t PID_OFF;
+//    uint8_t TRANSMISSION_RATE_PRESCALER;
+//    uint8_t DAQ_LIST_PRIORITY;
+
+//    uint8_t COUNTER;
+
+//} tXCP_EVENT_CHANNEL;
+
 typedef struct {
+    uint8_t SELECTED;
+    uint8_t RUNNING;
+    uint8_t ODT_COUNT;
+    uint16_t EVENT_CHANNEL;
+
     uint8_t ALTERNATING;
     uint8_t DIRECTION;
     uint8_t DTO_CTR;
@@ -243,12 +261,7 @@ typedef struct {
 
     uint8_t COUNTER;
 
-} tXCP_EVENT_CHANNEL;
 
-typedef struct {
-    uint16_t EVENT_CHANNEL;
-    eXcpDAQ_Mode MODE;
-    uint8_t ODT_COUNT;
     tXCP_ODT_ENTRIES ODT_NUMBER[MAX_ODT];
 } tXCP_DAQ;
 
@@ -362,6 +375,68 @@ typedef struct __attribute__ ((packed)) {
 
 } eXcpCommand_GET_DAQ_PROCESSOR_INFO;
 
+typedef struct __attribute__ ((packed)) {
+    eXcpTypeCommand COM;
+    uint8_t GRANULARITY_ODT_ENTRY_SIZE_DAQ;
+    uint8_t MAX_ODT_ENTRY_SIZE_DAQ;
+    uint8_t GRANULARITY_ODT_ENTRY_SIZE_STIM;
+    uint8_t MAX_ODT_ENTRY_SIZE_STIM;
+    uint8_t TIMESTAMP_MODE;
+    uint16_t TIMESTAMP_TICKS;
+} eXcpCommand_GET_DAQ_RESOLUTION_INFO;
+
+
+typedef struct __attribute__ ((packed)) {
+    eXcpTypeCommand COM;
+    uint8_t RESERVED;
+    uint16_t DAQ_LIST_NUMBER;
+} eXcpCommand_GET_DAQ_LIST_MODE_GET;
+
+typedef struct __attribute__ ((packed)) {
+    eXcpTypeCommand COM;
+
+    uint8_t SELECTED: 1;
+    uint8_t DIRECTION: 1;
+    uint8_t RESERVED1: 1;
+    uint8_t DTO_CTR: 1;
+    uint8_t TIMESTAMP: 1;
+    uint8_t PID_OFF: 1;
+    uint8_t RUNNING: 1;
+    uint8_t RESUME: 1;
+
+    uint16_t RESERVED2;
+    uint16_t CURRENT_EVENT_CHANNEL_NUMBER;
+    uint8_t CURRENT_PRESCALER;
+    uint8_t CURRENT_DAQ_LIST_PRIORITY;
+
+} eXcpCommand_GET_DAQ_LIST_MODE;
+
+typedef struct __attribute__ ((packed)) {
+    eXcpTypeCommand COM;
+    uint8_t RESERVED;
+    uint16_t EVENT_CHANNEL_NUMBER;
+} eXcpCommand_GET_DAQ_EVENT_INFO_GET;
+
+typedef struct __attribute__ ((packed)) {
+    eXcpTypeCommand COM;
+
+    uint8_t RESERVED1: 1;
+    uint8_t RESERVED2: 1;
+    uint8_t DAQ: 1;
+    uint8_t STM: 1;
+    uint8_t RESERVED3: 1;
+    uint8_t RESERVED4: 1;
+    uint8_t CONSISTENCY_DAQ: 1;
+    uint8_t CONSISTENCY_EVENT: 1;
+
+    uint8_t MAX_DAQ_LIST;
+    uint8_t EVENT_CHANNEL_NAME_LENGTH;
+    uint8_t EVENT_CHANNEL_TIME_CYCLE;
+    uint8_t EVENT_CHANNEL_TIME_UNIT;
+    uint8_t EVENT_CHANNEL_PRIORITY;
+
+} eXcpCommand_GET_DAQ_EVENT_INFO;
+
 typedef struct {
     tSerialPortFrameIO *ioCanFrame;
     tLoggerInterface *logger;
@@ -378,7 +453,7 @@ typedef struct {
     uint8_t downloadRemaining;
     uint8_t response[8];
 
-    tXCP_EVENT_CHANNEL EVENT_CHANNEL[MAX_EVENT_CHANNEL];
+    //tXCP_EVENT_CHANNEL EVENT_CHANNEL[MAX_EVENT_CHANNEL];
     tXCP_DAQ DAQ[MAX_DAO];
     uint16_t DAQ_COUNT;
 

Src/CanSerialPortFrameXCP.c

@@ -315,7 +315,8 @@ uint8_t XCP_FREE_DAQ_214(tCanSerialPortFrameXCP *env) {
 
     for (uint16_t i = 0; i < MAX_DAO; ++i) {
 
-        env->DAQ[i].MODE = XCP_STOP;
+        env->DAQ[i].SELECTED = 0;
+        env->DAQ[i].RUNNING = 0;
         env->DAQ[i].ODT_COUNT = 0;
 
         for (uint8_t j = 0; j < MAX_ODT; ++j) {
@@ -412,16 +413,16 @@ uint8_t XCP_SET_DAQ_LIST_MODE_224(tCanSerialPortFrameXCP *env) {
 
     env->DAQ[request->DAQ_LIST_NUMBER].EVENT_CHANNEL = request->EVENT_CHANNEL_NUMBER;
 
-    env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].ALTERNATING = request->ALTERNATING;
+    env->DAQ[request->DAQ_LIST_NUMBER].ALTERNATING = request->ALTERNATING;
-    env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].DIRECTION = request->DIRECTION;
+    env->DAQ[request->DAQ_LIST_NUMBER].DIRECTION = request->DIRECTION;
-    env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].DTO_CTR = request->DTO_CTR;
+    env->DAQ[request->DAQ_LIST_NUMBER].DTO_CTR = request->DTO_CTR;
-    env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].TIMESTAMP = request->TIMESTAMP;
+    env->DAQ[request->DAQ_LIST_NUMBER].TIMESTAMP = request->TIMESTAMP;
-    env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].PID_OFF = request->PID_OFF;
+    env->DAQ[request->DAQ_LIST_NUMBER].PID_OFF = request->PID_OFF;
 
-    env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].TRANSMISSION_RATE_PRESCALER = request->TRANSMISSION_RATE_PRESCALER;
+    env->DAQ[request->DAQ_LIST_NUMBER].TRANSMISSION_RATE_PRESCALER = request->TRANSMISSION_RATE_PRESCALER;
-    env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].DAQ_LIST_PRIORITY = request->DAQ_LIST_PRIORITY;
+    env->DAQ[request->DAQ_LIST_NUMBER].DAQ_LIST_PRIORITY = request->DAQ_LIST_PRIORITY;
 
-    env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].COUNTER = request->TRANSMISSION_RATE_PRESCALER;
+    env->DAQ[request->DAQ_LIST_NUMBER].COUNTER = request->TRANSMISSION_RATE_PRESCALER;
 
     env->response[0] = XCP_COMMAND_CONNECT;
     return 1;
@@ -437,7 +438,17 @@ uint8_t XCP_START_STOP_DAQ_LIST_222(tCanSerialPortFrameXCP *env) {
         return 2;
     }
 
-    env->DAQ[request->DAQ_LIST_NUMBER].MODE = request->MODE;
+    if (request->MODE == XCP_STOP) {
+        env->DAQ[request->DAQ_LIST_NUMBER].RUNNING = 0;
+    }
+
+    if (request->MODE == XCP_START) {
+        env->DAQ[request->DAQ_LIST_NUMBER].RUNNING = 1;
+    }
+
+    if (request->MODE == XCP_SELECT) {
+        env->DAQ[request->DAQ_LIST_NUMBER].SELECTED = 1;
+    }
 
     env->response[0] = XCP_COMMAND_CONNECT;
     return 1;
@@ -448,22 +459,22 @@ uint8_t XCP_START_STOP_SYNCH_221(tCanSerialPortFrameXCP *env) {
 
     if (request->MODE == XCP_SYNC_START_SEL) {
         for (uint16 i = 0; i < MAX_DAO; ++i) {
-            if (env->DAQ[i].MODE == XCP_SELECT) {
+            if (env->DAQ[i].SELECTED) {
-                env->DAQ[i].MODE = XCP_START;
+                env->DAQ[i].RUNNING = 1;
             }
         }
     }
 
     if (request->MODE == XCP_SYNC_STOP_ALL) {
         for (uint16 i = 0; i < MAX_DAO; ++i) {
-            env->DAQ[i].MODE = XCP_STOP;
+            env->DAQ[i].RUNNING = 0;
         }
     }
 
     if (request->MODE == XCP_SYNC_STOP_SEL) {
         for (uint16 i = 0; i < MAX_DAO; ++i) {
-            if (env->DAQ[i].MODE == XCP_SELECT) {
+            if (env->DAQ[i].SELECTED) {
-                env->DAQ[i].MODE = XCP_STOP;
+                env->DAQ[i].RUNNING = 1;
             }
         }
     }
@@ -518,6 +529,87 @@ uint8_t XCP_GET_DAQ_PROCESSOR_INFO_218(tCanSerialPortFrameXCP *env) {
     return 8;
 }
 
+uint8_t XCP_GET_DAQ_RESOLUTION_INFO_217(tCanSerialPortFrameXCP *env) {
+    eXcpCommand_GET_DAQ_RESOLUTION_INFO *response = (eXcpCommand_GET_DAQ_RESOLUTION_INFO *) env->response;
+
+    response->COM = XCP_COMMAND_CONNECT;
+
+    response->GRANULARITY_ODT_ENTRY_SIZE_DAQ = 1;
+    response->MAX_ODT_ENTRY_SIZE_DAQ = MAX_ODT_ENTRIES_SIZE;
+    response->GRANULARITY_ODT_ENTRY_SIZE_STIM = 1;
+    response->MAX_ODT_ENTRY_SIZE_STIM = MAX_ODT_ENTRIES_SIZE;
+    response->TIMESTAMP_MODE = 0;
+    response->TIMESTAMP_TICKS = 0;
+
+    return 8;
+}
+
+
+uint8_t XCP_GET_DAQ_LIST_MODE_223(tCanSerialPortFrameXCP *env) {
+
+    eXcpCommand_GET_DAQ_LIST_MODE_GET *request = (eXcpCommand_GET_DAQ_LIST_MODE_GET *) env->canFrame.data;
+
+    if (request->DAQ_LIST_NUMBER > MAX_DAO) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_OUT_OF_RANGE;
+
+        return 2;
+    }
+
+    eXcpCommand_GET_DAQ_LIST_MODE *response = (eXcpCommand_GET_DAQ_LIST_MODE *) env->response;
+
+    response->COM = XCP_COMMAND_CONNECT;
+
+    response->SELECTED = env->DAQ[request->DAQ_LIST_NUMBER].SELECTED;
+    response->DIRECTION = env->DAQ[request->DAQ_LIST_NUMBER].DIRECTION;
+    response->RESERVED1 = 0;
+    response->DTO_CTR = env->DAQ[request->DAQ_LIST_NUMBER].DTO_CTR;
+    response->TIMESTAMP = env->DAQ[request->DAQ_LIST_NUMBER].TIMESTAMP;
+    response->PID_OFF = env->DAQ[request->DAQ_LIST_NUMBER].PID_OFF;
+    response->RUNNING = env->DAQ[request->DAQ_LIST_NUMBER].RUNNING;
+    response->RESUME = 0;
+
+    response->RESERVED2 = 0;
+    response->CURRENT_EVENT_CHANNEL_NUMBER = env->DAQ[request->DAQ_LIST_NUMBER].EVENT_CHANNEL;
+    response->CURRENT_PRESCALER = env->DAQ[request->DAQ_LIST_NUMBER].TRANSMISSION_RATE_PRESCALER;
+    response->CURRENT_DAQ_LIST_PRIORITY = env->DAQ[request->DAQ_LIST_NUMBER].DAQ_LIST_PRIORITY;
+
+    return 8;
+}
+
+
+uint8_t XCP_GET_DAQ_EVENT_INFO_215(tCanSerialPortFrameXCP *env) {
+
+    eXcpCommand_GET_DAQ_EVENT_INFO_GET *request = (eXcpCommand_GET_DAQ_EVENT_INFO_GET *) env->canFrame.data;
+
+    if (request->EVENT_CHANNEL_NUMBER > MAX_EVENT_CHANNEL) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_OUT_OF_RANGE;
+
+        return 2;
+    }
+
+    eXcpCommand_GET_DAQ_EVENT_INFO *response = (eXcpCommand_GET_DAQ_EVENT_INFO *) env->response;
+
+    response->COM = XCP_COMMAND_CONNECT;
+
+    response->RESERVED1 = 0;
+    response->RESERVED2 = 0;
+    response->DAQ = 1;
+    response->STM = 1;
+    response->RESERVED3 = 0;
+    response->RESERVED4 = 0;
+    response->CONSISTENCY_DAQ = 0;
+    response->CONSISTENCY_EVENT = 0;
+
+    response->MAX_DAQ_LIST = 255;
+    response->EVENT_CHANNEL_NAME_LENGTH = 0;
+    response->EVENT_CHANNEL_TIME_CYCLE = 1;
+    response->EVENT_CHANNEL_TIME_UNIT = 7; // EVENT_CHANNEL _TIME_UNIT_10MS
+    response->EVENT_CHANNEL_PRIORITY = 255;
+
+    return 7;
+}
 
 const xcp_func_ptr fXcp_func_ptr[256] = {
         NULL,
@@ -735,15 +827,15 @@ const xcp_func_ptr fXcp_func_ptr[256] = {
         XCP_ALLOC_ODT_212,
         XCP_ALLOC_DAQ_213,
         XCP_FREE_DAQ_214,
-        NULL,
+        XCP_GET_DAQ_EVENT_INFO_215,
         XCP_GET_DAQ_LIST_INFO_216,
-        NULL,
+        XCP_GET_DAQ_RESOLUTION_INFO_217,
         XCP_GET_DAQ_PROCESSOR_INFO_218,
         XCP_READ_DAQ_219,
         NULL,
         XCP_START_STOP_SYNCH_221,
         XCP_START_STOP_DAQ_LIST_222,
-        NULL,
+        XCP_GET_DAQ_LIST_MODE_223,
         XCP_SET_DAQ_LIST_MODE_224,
         XCP_WRITE_DAQ_225,
         XCP_SET_DAQ_PTR_226,
@@ -818,37 +910,52 @@ _Noreturn void CanXcpProcessing_ServiceTask(tCanSerialPortFrameXCP *env) {
         if (osMutexAcquire(env->access, 100) == osOK) {
 
             for (uint16 i = 0; i < env->DAQ_COUNT; ++i) {
-                if (env->DAQ[i].MODE == XCP_START) {
+                if (env->DAQ[i].RUNNING) {
 
 
-                    if (env->EVENT_CHANNEL[env->DAQ[i].EVENT_CHANNEL].COUNTER == 0) {
+                    if ((env->DAQ[i].EVENT_CHANNEL == 0) && (env->DAQ[i].COUNTER == 0)) {
 
-                        env->EVENT_CHANNEL[env->DAQ[i].EVENT_CHANNEL].COUNTER = env->EVENT_CHANNEL[env->DAQ[i].EVENT_CHANNEL].TRANSMISSION_RATE_PRESCALER;
+                        env->DAQ[i].COUNTER = env->DAQ[i].TRANSMISSION_RATE_PRESCALER;
 
-                        for (uint8_t j = 0; j < env->DAQ[i].ODT_COUNT; ++j) {
+                        if (env->DAQ[i].DIRECTION == 0) { // DAQ - DTO
+                            for (uint8_t j = 0; j < env->DAQ[i].ODT_COUNT; ++j) {
 
-                            env->response[0] = j; // ODT
+                                env->response[0] = j; // ODT
-                            env->response[1] = i; // DAQ
+                                env->response[1] = i; // DAQ
-                            response_size = 0;
+                                response_size = 0;
 
-                            for (uint8_t k = 0; k < env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_COUNT; ++k) {
+                                for (uint8_t k = 0; k < env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_COUNT; ++k) {
 
-                                memcpy(&env->response[2] + response_size,
+                                    memcpy(&env->response[2] + response_size,
-                                       (uint8_t *) env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_ADR[k],
+                                           (uint8_t *) env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_ADR[k],
-                                       env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k]);
+                                           env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k]);
 
-                                response_size += env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k];
+                                    response_size += env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k];
+
+                                }
+
+                                if (response_size) {
+                                    env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, response_size, 1000);
+                                }
 
                             }
+                        } else { // STIM - DTO
+
+                            for (uint8_t j = 0; j < env->DAQ[i].ODT_COUNT; ++j) {
+
+                                for (uint8_t k = 0; k < env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_COUNT; ++k) {
+
+                                    memcpy(&env->response[2] + response_size,
+                                           (uint8_t *) env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_ADR[k],
+                                           env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k]);
+
+                                }
 
-                            if (response_size) {
-                                env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, response_size, 1000);
                             }
-
                         }
 
                     } else {
-                        --env->EVENT_CHANNEL[env->DAQ[i].EVENT_CHANNEL].COUNTER;
+                        --env->DAQ[i].COUNTER;
                     }
 
 
@@ -860,7 +967,7 @@ _Noreturn void CanXcpProcessing_ServiceTask(tCanSerialPortFrameXCP *env) {
             osMutexRelease(env->access);
         }
 
-        SystemDelayMs(50);
+        SystemDelayMs(10);
     }