aniketSaha/NorthStar-Endurance-TestBench
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Endurance testbench data logging: Writing and reading the data from the node

Browse Source
This commit is contained in:
VineetaGupta 2025-03-13 16:12:27 +01:00
parent 4cc9c33563
commit 9ac0b4ff69
3 changed files with 100 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

172
EnduranceTestBench/nehemis/enduranceTestBench.c
View File

@ -14,6 +14,7 @@
******************************************************************************/ ******************************************************************************/
#include "enduranceTestBench.h" #include "enduranceTestBench.h"
#include "hal_system.h" #include "hal_system.h"
#include "stdlib.h"
/* CANopen includes */ /* CANopen includes */
#include <gen_define.h> #include <gen_define.h>
@ -22,7 +23,7 @@
/****************************************************************************** /******************************************************************************
* Macro constant declarations * Macro constant declarations
******************************************************************************/ ******************************************************************************/
#define ENDURANCE_TEST_BENCH_MAX_RETRY_CNT 5u #define ENDURANCE_TEST_BENCH_MAX_RETRY_CNT 3u
#define ENDURANCE_TEST_BENCH_TIMEOUT 1000u #define ENDURANCE_TEST_BENCH_TIMEOUT 1000u
#define ENDURANCE_TEST_BENCH_LSS_NODE_COUNT 20u #define ENDURANCE_TEST_BENCH_LSS_NODE_COUNT 20u
#define ENDURANCE_TEST_BENCH_POSITION_SETPOINT_INDEX 0x6002 #define ENDURANCE_TEST_BENCH_POSITION_SETPOINT_INDEX 0x6002
@ -37,17 +38,24 @@ typedef enum
TEST_BENCH_STARTUP, TEST_BENCH_STARTUP,
TEST_BENCH_IDLE, TEST_BENCH_IDLE,
TEST_BENCH_WRITE_REQUEST, TEST_BENCH_WRITE_REQUEST,
TEST_BENCH_WAIT_BEFORE_READ, TEST_BENCH_READ_FEEDBACK,
TEST_BENCH_WAIT_FOR_FEEDBACK, TEST_BENCH_VERIFY_RESULTS,
TEST_BENCH_DELAY_BEFORE_NEXT TEST_BENCH_DELAY_BEFORE_NEXT
} SdlTestBenchState_en; } SdlTestBenchState_en;
typedef struct
{
uint8 targetPositions_gau8[ENDURANCE_TEST_BENCH_LSS_NODE_COUNT];
uint8 readPosition_gau8[ENDURANCE_TEST_BENCH_LSS_NODE_COUNT];
uint8 status[ENDURANCE_TEST_BENCH_LSS_NODE_COUNT];
} TestBenchData_en;
/****************************************************************************** /******************************************************************************
* Global variable declarations * Global variable declarations
******************************************************************************/ ******************************************************************************/
static TestBenchData_en testBenchData_en;
static uint8 currentNode_gu8 = 0u; static uint8 currentNode_gu8 = 0u;
static SdlTestBenchState_en testBenchState_en = TEST_BENCH_IDLE; static SdlTestBenchState_en testBenchState_en = TEST_BENCH_IDLE;
static uint8 targetPositions_gau8[ENDURANCE_TEST_BENCH_LSS_NODE_COUNT]; static uint32 readPosition_gu32;
/****************************************************************************** /******************************************************************************
* Public Function Definitions * Public Function Definitions
******************************************************************************/ ******************************************************************************/
@ -80,7 +88,7 @@ void EnduranceTestBenchRun(void)
/* First 5 seconds: First 10 open, rest closed */ /* First 5 seconds: First 10 open, rest closed */
for (uint8 i_u8 = 0u; i_u8 < ENDURANCE_TEST_BENCH_LSS_NODE_COUNT; i_u8++) for (uint8 i_u8 = 0u; i_u8 < ENDURANCE_TEST_BENCH_LSS_NODE_COUNT; i_u8++)
{ {
targetPositions_gau8[i_u8] = (i_u8 < 10u) ? max_u8 : min_u8; testBenchData_en.targetPositions_gau8[i_u8] = (i_u8 < 10u) ? max_u8 : min_u8;
} }
} }
else if ((currentTime_u64 - startTime_u64) < 10000uLL) else if ((currentTime_u64 - startTime_u64) < 10000uLL)
@ -88,7 +96,7 @@ void EnduranceTestBenchRun(void)
/* Next 5 seconds: First 10 closed, rest open */ /* Next 5 seconds: First 10 closed, rest open */
for (uint8 i_u8 = 0u; i_u8 < ENDURANCE_TEST_BENCH_LSS_NODE_COUNT; i_u8++) for (uint8 i_u8 = 0u; i_u8 < ENDURANCE_TEST_BENCH_LSS_NODE_COUNT; i_u8++)
{ {
targetPositions_gau8[i_u8] = (i_u8 < 10) ? min_u8 : max_u8; testBenchData_en.targetPositions_gau8[i_u8] = (i_u8 < 10) ? min_u8 : max_u8;
} }
} }
else else
@ -119,7 +127,7 @@ void EnduranceTestBenchRun(void)
/* Randomized cycle */ /* Randomized cycle */
for (uint8 i_u8 = 0u; i_u8 < ENDURANCE_TEST_BENCH_LSS_NODE_COUNT; i_u8++) for (uint8 i_u8 = 0u; i_u8 < ENDURANCE_TEST_BENCH_LSS_NODE_COUNT; i_u8++)
{ {
targetPositions_gau8[i_u8] = (uint8)(rand() % 256); /* Assign random value between 0-255 */ testBenchData_en.targetPositions_gau8[i_u8] = (uint8)(rand() % 256); /* Assign random value between 0-255 */
} }
} }
else else
@ -129,11 +137,11 @@ void EnduranceTestBenchRun(void)
{ {
if (((i_u8 / 5) % 2) == currentGroup_u8) if (((i_u8 / 5) % 2) == currentGroup_u8)
{ {
targetPositions_gau8[i_u8] = max_u8; /* Fully open */ testBenchData_en.targetPositions_gau8[i_u8] = max_u8; /* Fully open */
} }
else else
{ {
targetPositions_gau8[i_u8] = min_u8; /* Fully closed */ testBenchData_en.targetPositions_gau8[i_u8] = min_u8; /* Fully closed */
} }
} }
} }
@ -150,108 +158,77 @@ void EnduranceTestBenchRun(void)
{ {
if (currentNode_gu8 < ENDURANCE_TEST_BENCH_LSS_NODE_COUNT) if (currentNode_gu8 < ENDURANCE_TEST_BENCH_LSS_NODE_COUNT)
{ {
RET_T retVal_en = coSdoWrite((currentNode_gu8 + 1), ENDURANCE_TEST_BENCH_POSITION_SETPOINT_INDEX, ENDURANCE_TEST_BENCH_POSITION_SETPOINT_SUB_INDEX, testBenchData_en.targetPositions_gau8[currentNode_gu8] = (uint8)(rand() % 256);
&targetPositions_gau8[currentNode_gu8], sizeof(targetPositions_gau8[currentNode_gu8]),
RET_T retVal_en = coSdoWrite((1), ENDURANCE_TEST_BENCH_POSITION_SETPOINT_INDEX, ENDURANCE_TEST_BENCH_POSITION_SETPOINT_SUB_INDEX,
&testBenchData_en.targetPositions_gau8[currentNode_gu8], sizeof(uint8),
CO_FALSE, ENDURANCE_TEST_BENCH_TIMEOUT); CO_FALSE, ENDURANCE_TEST_BENCH_TIMEOUT);
if (retVal_en == RET_OK) if (retVal_en == RET_OK)
{ {
retries_u8 = 0u; retries_u8 = 0u;
currentNode_gu8++;
HalSystemGetRunTimeMs(&startTime_u64); HalSystemGetRunTimeMs(&startTime_u64);
testBenchState_en = TEST_BENCH_WAIT_BEFORE_READ;
}
else if (retVal_en == RET_SERVICE_BUSY)
{
retries_u8++;
if (retries_u8 < 5u)
{
printf("SDO Busy for node %d, retrying...\n", currentNode_gu8 + 1);
}
else
{
currentNode_gu8++; /* Skip this node */
testBenchState_en = TEST_BENCH_WRITE_REQUEST;
}
} }
else else
{ {
currentNode_gu8++; /* Skip this node */ retries_u8++;
testBenchState_en = TEST_BENCH_WRITE_REQUEST; if (retries_u8 >= ENDURANCE_TEST_BENCH_MAX_RETRY_CNT)
{
currentNode_gu8++; /* Skip this node */
}
} }
} }
else
{
batchCompleted_u8 = 1u;
testBenchState_en = TEST_BENCH_IDLE;
}
} }
break; break;
case TEST_BENCH_WAIT_BEFORE_READ: case TEST_BENCH_READ_FEEDBACK:
{ {
HalSystemGetRunTimeMs(&currentTime_u64); RET_T retVal_en = coSdoRead((1),ENDURANCE_TEST_BENCH_POSITION_FEEDBACK_INDEX, ENDURANCE_TEST_BENCH_POSITION_FEEDBACK_SUB_INDEX,
(uint8*)&readPosition_gu32, sizeof(uint32), CO_FALSE, ENDURANCE_TEST_BENCH_TIMEOUT);
if ((currentTime_u64 - startTime_u64) >= 2000uLL) /* Wait for a predefined settling time */
{
testBenchState_en = TEST_BENCH_WAIT_FOR_FEEDBACK;
}
}
break;
case TEST_BENCH_WAIT_FOR_FEEDBACK:
{
uint8 readPos_u8 = 0u;
RET_T retVal_en = coSdoRead((currentNode_gu8 + 1), ENDURANCE_TEST_BENCH_POSITION_FEEDBACK_INDEX, ENDURANCE_TEST_BENCH_POSITION_FEEDBACK_SUB_INDEX,
&readPos_u8, sizeof(readPos_u8), CO_FALSE, ENDURANCE_TEST_BENCH_TIMEOUT);
if (retVal_en == RET_OK) if (retVal_en == RET_OK)
{ {
if (readPos_u8 == targetPositions_gau8[currentNode_gu8]) /* Wait for indication */
{ }
printf("Node %d reached target position %d\n", currentNode_gu8 + 1, readPos_u8);
currentNode_gu8++;
retries_u8 = 0u; /* Reset retries */
if (currentNode_gu8 < ENDURANCE_TEST_BENCH_LSS_NODE_COUNT) else if (retVal_en == RET_SERVICE_BUSY && retries_u8 < ENDURANCE_TEST_BENCH_MAX_RETRY_CNT)
{ {
HalSystemGetRunTimeMs(&startTime_u64); /* Store time before sending the next command */ retries_u8++;
testBenchState_en = TEST_BENCH_DELAY_BEFORE_NEXT;
}
else
{
batchCompleted_u8 = 1u;
testBenchState_en = TEST_BENCH_IDLE;
}
}
} }
else else
{ {
retries_u8++; currentNode_gu8++;
if (retries_u8 >= ENDURANCE_TEST_BENCH_MAX_RETRY_CNT) retries_u8 = 0;
{
currentNode_gu8++;
if (currentNode_gu8 < ENDURANCE_TEST_BENCH_LSS_NODE_COUNT)
{
HalSystemGetRunTimeMs(&startTime_u64);
testBenchState_en = TEST_BENCH_DELAY_BEFORE_NEXT;
}
else
{
batchCompleted_u8 = 1u;
testBenchState_en = TEST_BENCH_IDLE;
}
}
} }
} }
break; break;
case TEST_BENCH_VERIFY_RESULTS:
{
for (uint8 index_u8 = 0u; index_u8 < ENDURANCE_TEST_BENCH_LSS_NODE_COUNT; index_u8++)
{
if (testBenchData_en.targetPositions_gau8[index_u8] != testBenchData_en.readPosition_gau8[index_u8])
{
testBenchData_en.status[index_u8] = 1u;
}
else
{
testBenchData_en.status[index_u8] = 0u;
}
}
testBenchState_en = TEST_BENCH_DELAY_BEFORE_NEXT;
}
break;
case TEST_BENCH_DELAY_BEFORE_NEXT: case TEST_BENCH_DELAY_BEFORE_NEXT:
{ {
HalSystemGetRunTimeMs(&currentTime_u64); HalSystemGetRunTimeMs(&currentTime_u64);
if ((currentTime_u64 - startTime_u64) >= ENDURANCE_TEST_BENCH_TIMEOUT) if ((currentTime_u64 - startTime_u64) >= ENDURANCE_TEST_BENCH_TIMEOUT)
{ {
currentNode_gu8 = 0u;
testBenchState_en = TEST_BENCH_WRITE_REQUEST; testBenchState_en = TEST_BENCH_WRITE_REQUEST;
} }
} }
@ -259,3 +236,38 @@ void EnduranceTestBenchRun(void)
} }
} }
/******************************************************************************
* Callback Function
******************************************************************************/
void EnduranceTestBenchWriteInd(uint8 sdoNr_u8, uint16 index_u16, uint8 subIndex_u8, uint32 errorVal_u32)
{
if (currentNode_gu8 < ENDURANCE_TEST_BENCH_LSS_NODE_COUNT)
{
testBenchState_en = TEST_BENCH_WRITE_REQUEST;
}
else
{
currentNode_gu8 = 0u; /* Reset before reading */
testBenchState_en = TEST_BENCH_READ_FEEDBACK;
}
}
void EnduranceTestBenchReadInd(uint8 sdoNr_u8, uint16 index_u16, uint8 subIndex_u8, uint32 size, uint32 errorVal_u32)
{
if (sdoNr_u8 <= ENDURANCE_TEST_BENCH_LSS_NODE_COUNT)
{
testBenchData_en.readPosition_gau8[currentNode_gu8] = readPosition_gu32;
if (currentNode_gu8 + 1 == ENDURANCE_TEST_BENCH_LSS_NODE_COUNT)
{
testBenchState_en = TEST_BENCH_VERIFY_RESULTS;
}
else
{
testBenchState_en = TEST_BENCH_READ_FEEDBACK;
}
}
}

4
EnduranceTestBench/nehemis/enduranceTestBench.h
View File

@ -26,5 +26,9 @@
*/ */
void EnduranceTestBenchRun(void); void EnduranceTestBenchRun(void);
void EnduranceTestBenchWriteInd(uint8 sdoNr_u8, uint16 index_u16, uint8 subIndex_u8, uint32 errorVal_u32);
void EnduranceTestBenchReadInd(uint8 sdoNr_u8, uint16 index_u16, uint8 subIndex_u8, uint32 size, uint32 errorVal_u32);
#endif /* ENDURANCETESTBENCH_H_ */ #endif /* ENDURANCETESTBENCH_H_ */

4
EnduranceTestBench/scheduler/sdl.c
View File

@ -157,6 +157,10 @@ static void SdlInitCanopen(void)
retval = coEventRegister_LSS_MASTER(SdlLssIndCallback); retval = coEventRegister_LSS_MASTER(SdlLssIndCallback);
retval = coEventRegister_ERRCTRL(SdlLssHbMonitorCallback); retval = coEventRegister_ERRCTRL(SdlLssHbMonitorCallback);
/* Register SDO event handlers from test.c */
coEventRegister_SDO_CLIENT_READ(EnduranceTestBenchReadInd);
coEventRegister_SDO_CLIENT_WRITE(EnduranceTestBenchWriteInd);
/* enable CAN communication */ /* enable CAN communication */
retval = codrvCanEnable(); retval = codrvCanEnable();
retval = coTimerStart(&monitorTimer_gst, SDL_APPL_TIMER_TIME, SdlLssToggleMonitorFlag, NULL, CO_TIMER_ATTR_ROUNDUP_CYCLIC); retval = coTimerStart(&monitorTimer_gst, SDL_APPL_TIMER_TIME, SdlLssToggleMonitorFlag, NULL, CO_TIMER_ATTR_ROUNDUP_CYCLIC);