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

Running one valve at a time with max pressure from the pump. (10 valves)

Browse Source
This commit is contained in:
VineetaGupta 2025-12-09 10:40:54 +01:00
parent 8817de2da0
commit a3fba33c29
5 changed files with 141 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
EnduranceTestBench/nehemis/enduranceTestBench.c
View File

@ -24,18 +24,26 @@
/****************************************************************************** /******************************************************************************
* Macro constant declarations * Macro constant declarations
******************************************************************************/ ******************************************************************************/
#define ENDURANCE_TEST_BENCH_RUN_TWO_ROWS_ONLY
#define ENDURANCE_TEST_BENCH_MAX_RETRY_CNT 3u #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_POSITION_SETPOINT_INDEX 0x2002 #define ENDURANCE_TEST_BENCH_POSITION_SETPOINT_INDEX 0x2002
#define ENDURANCE_TEST_BENCH_POSITION_SETPOINT_SUB_INDEX 0x0 #define ENDURANCE_TEST_BENCH_POSITION_SETPOINT_SUB_INDEX 0x0
#define ENDURANCE_TEST_BENCH_POSITION_FEEDBACK_INDEX 0x2004 #define ENDURANCE_TEST_BENCH_POSITION_FEEDBACK_INDEX 0x2004
#define ENDURANCE_TEST_BENCH_POSITION_FEEDBACK_SUB_INDEX 0x0 #define ENDURANCE_TEST_BENCH_POSITION_FEEDBACK_SUB_INDEX 0x0
#define ENDURANCE_TEST_BENCH_TEST_PATTERN_2_ROWS 3
#define ENDURANCE_TEST_BENCH_TEST_PATTERN_COUNT 3
#define TEST_PATTERN_COUNT 3
#define VALVE_COUNT 20
static const uint8 testPatterns[TEST_PATTERN_COUNT][VALVE_COUNT] = { #ifdef ENDURANCE_TEST_BENCH_RUN_TWO_ROWS_ONLY
#define ENDURANCE_TEST_BENCH_LSS_NODE_COUNT 10u
#define ENDURANCE_TEST_BENCH_VALVE_COUNT 10
#else
#define ENDURANCE_TEST_BENCH_LSS_NODE_COUNT 20u
#define ENDURANCE_TEST_BENCH_VALVE_COUNT 20
#endif
static const uint8 testPatterns[ENDURANCE_TEST_BENCH_TEST_PATTERN_COUNT][ENDURANCE_TEST_BENCH_VALVE_COUNT] = {
/* Pattern 0: Columns alternately closed or open */ /* Pattern 0: Columns alternately closed or open */
{ {
0, 0, 0, 0, 255, // Row 0 0, 0, 0, 0, 255, // Row 0
@ -56,7 +64,12 @@ static const uint8 testPatterns[TEST_PATTERN_COUNT][VALVE_COUNT] = {
0, 0, 0, 0, 252, // Row 1 0, 0, 0, 0, 252, // Row 1
252, 252, 252, 252, 252, // Row 2 252, 252, 252, 252, 252, // Row 2
0, 0, 0, 0, 252 // Row 3 0, 0, 0, 0, 252 // Row 3
} },
/* Pattern 4: Random placeholder for only two rows */
{
0, 0, 0, 0, 0, // Row 0
0, 0, 0, 0, 0, // Row 1
},
}; };
/****************************************************************************** /******************************************************************************
@ -81,7 +94,7 @@ typedef enum
typedef struct typedef struct
{ {
uint8 targetPositions_gau8[ENDURANCE_TEST_BENCH_LSS_NODE_COUNT]; uint16 targetPositions_gau8[ENDURANCE_TEST_BENCH_LSS_NODE_COUNT];
uint8 readPosition_gau8[ENDURANCE_TEST_BENCH_LSS_NODE_COUNT]; uint8 readPosition_gau8[ENDURANCE_TEST_BENCH_LSS_NODE_COUNT];
TestBenchStatus_en status_en[ENDURANCE_TEST_BENCH_LSS_NODE_COUNT]; TestBenchStatus_en status_en[ENDURANCE_TEST_BENCH_LSS_NODE_COUNT];
} TestBenchData_en; } TestBenchData_en;
@ -112,17 +125,17 @@ void EnduranceTestBenchRun(bool *testBenchStarted_pb)
if (startTime_u64 == 0uLL) if (startTime_u64 == 0uLL)
{ {
HalSystemGetRunTimeMs(&startTime_u64); HalSystemGetRunTimeMs(&startTime_u64);
testBenchState_en = TEST_BENCH_STARTUP; testBenchState_en = TEST_BENCH_IDLE;
} }
switch (testBenchState_en) switch (testBenchState_en)
{ {
case TEST_BENCH_STARTUP: case TEST_BENCH_STARTUP:
{ {
uint8 max_u8 = NMS_UINT8_MAX; /* Fully open (255) */ uint16 max_u8 = 1000u; /* Fully open (255) */
uint8 min_u8 = 0u; /* Fully closed (0) */ uint16 min_u8 = 0u; /* Fully closed (0) */
if ((currentTime_u64 - startTime_u64) < 5000uLL) if ((currentTime_u64 - startTime_u64) < 50uLL)
{ {
/* 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++)
@ -130,7 +143,7 @@ void EnduranceTestBenchRun(bool *testBenchStarted_pb)
testBenchData_en.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) < 10uLL)
{ {
/* 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++)
@ -152,32 +165,45 @@ void EnduranceTestBenchRun(bool *testBenchStarted_pb)
case TEST_BENCH_IDLE: case TEST_BENCH_IDLE:
{ {
*testBenchStarted_pb = true; *testBenchStarted_pb = true;
uint8 randIndex_u8 = (uint8)(rand() % ENDURANCE_TEST_BENCH_VALVE_COUNT);
uint8 patternIndex_u8 = alternate_u8 % TEST_PATTERN_COUNT; /* --- TEST MODE: force single-random pattern --- */
uint8 patternIndex_u8 = ENDURANCE_TEST_BENCH_TEST_PATTERN_2_ROWS;
if (patternIndex_u8 == 1u) if (patternIndex_u8 == 1u)
{ {
/* Fill with random values */ /* Randomize all valves */
for (uint8 i_u8 = 0u; i_u8 < VALVE_COUNT; i_u8++) for (uint8 i_u8 = 0u; i_u8 < ENDURANCE_TEST_BENCH_VALVE_COUNT; i_u8++)
{ {
testBenchData_en.targetPositions_gau8[i_u8] = (uint8)(rand() % 256); testBenchData_en.targetPositions_gau8[i_u8] = (uint16)(rand() % 1000);
} }
} }
else if (patternIndex_u8 == ENDURANCE_TEST_BENCH_TEST_PATTERN_2_ROWS)
{
/* All zero */
for (uint8 i_u8 = 0u; i_u8 < ENDURANCE_TEST_BENCH_VALVE_COUNT; i_u8++)
{
testBenchData_en.targetPositions_gau8[i_u8] = 25u;
}
/* Pick one random valve and give it a random setpoint */
testBenchData_en.targetPositions_gau8[randIndex_u8] = (uint16)(rand() % 1000);
}
else else
{ {
/* Copy from predefined pattern */ /* Copy from predefined pattern (0 or 2) */
for (uint8 i_u8 = 0u; i_u8 < VALVE_COUNT; i_u8++) for (uint8 i_u8 = 0u; i_u8 < ENDURANCE_TEST_BENCH_VALVE_COUNT; i_u8++)
{ {
testBenchData_en.targetPositions_gau8[i_u8] = testPatterns[patternIndex_u8][i_u8]; testBenchData_en.targetPositions_gau8[i_u8] = testPatterns[patternIndex_u8][i_u8];
} }
} }
alternate_u8++; currentNode_gu8 = randIndex_u8;
currentNode_gu8 = 0u;
testBenchState_en = TEST_BENCH_WRITE; testBenchState_en = TEST_BENCH_WRITE;
} }
break; break;
/* -------------------- Write -------------------- */ /* -------------------- Write -------------------- */
case TEST_BENCH_WRITE: case TEST_BENCH_WRITE:
{ {
@ -188,17 +214,20 @@ void EnduranceTestBenchRun(bool *testBenchStarted_pb)
ENDURANCE_TEST_BENCH_POSITION_SETPOINT_INDEX, ENDURANCE_TEST_BENCH_POSITION_SETPOINT_INDEX,
ENDURANCE_TEST_BENCH_POSITION_SETPOINT_SUB_INDEX, ENDURANCE_TEST_BENCH_POSITION_SETPOINT_SUB_INDEX,
&testBenchData_en.targetPositions_gau8[currentNode_gu8], &testBenchData_en.targetPositions_gau8[currentNode_gu8],
sizeof(uint8), sizeof(uint16),
CO_FALSE, CO_FALSE,
ENDURANCE_TEST_BENCH_TIMEOUT ENDURANCE_TEST_BENCH_TIMEOUT
); );
if (retVal_en == RET_OK) if (retVal_en == RET_OK)
{ {
NmsCanPutObj_u8(0x2004, currentNode_gu8 + 1, testBenchData_en.targetPositions_gau8[currentNode_gu8]); uint8 targetPos = (uint8)(testBenchData_en.targetPositions_gau8[currentNode_gu8] / 10u);
NmsCanPutObj_u8(0x2004, currentNode_gu8 + 1, targetPos);
HalSystemGetRunTimeMs(&writeTime_u64); HalSystemGetRunTimeMs(&writeTime_u64);
retries_u8 = 0u; retries_u8 = 0u;
testBenchState_en = TEST_BENCH_WRITE_WAIT; testBenchState_en = TEST_BENCH_WRITE_WAIT;
} }
else else
{ {
@ -208,7 +237,7 @@ void EnduranceTestBenchRun(bool *testBenchStarted_pb)
testBenchData_en.status_en[currentNode_gu8] = TEST_BENCH_DATA_NODE_SKIPPED; testBenchData_en.status_en[currentNode_gu8] = TEST_BENCH_DATA_NODE_SKIPPED;
/* Mark node as skipped and move on */ /* Mark node as skipped and move on */
currentNode_gu8++; //currentNode_gu8++;
retries_u8 = 0u; retries_u8 = 0u;
testBenchState_en = TEST_BENCH_WRITE; testBenchState_en = TEST_BENCH_WRITE;
} }
@ -218,7 +247,7 @@ void EnduranceTestBenchRun(bool *testBenchStarted_pb)
else else
{ {
/* Finished writing to all nodes */ /* Finished writing to all nodes */
currentNode_gu8 = 0u; /* Reset index for read phase */ //currentNode_gu8 = 0u; /* Reset index for read phase */
testBenchState_en = TEST_BENCH_CYCLE_COMPLETE; testBenchState_en = TEST_BENCH_CYCLE_COMPLETE;
} }
break; break;
@ -227,11 +256,26 @@ void EnduranceTestBenchRun(bool *testBenchStarted_pb)
case TEST_BENCH_WRITE_WAIT: case TEST_BENCH_WRITE_WAIT:
{ {
/* Wait 100ms between writes */ /* Wait 100ms between writes */
if ((currentTime_u64 - writeTime_u64) >= 200) if ((currentTime_u64 - writeTime_u64) >= 30000uLL)
{ {
/* Move to next node write */ /* Move to next node write */
currentNode_gu8++; //currentNode_gu8++;
testBenchState_en = TEST_BENCH_WRITE; RET_T retVal_en = coSdoWrite(
(currentNode_gu8 + 1),
ENDURANCE_TEST_BENCH_POSITION_SETPOINT_INDEX,
ENDURANCE_TEST_BENCH_POSITION_SETPOINT_SUB_INDEX,
25u,
sizeof(uint16),
CO_FALSE,
ENDURANCE_TEST_BENCH_TIMEOUT
);
if(retVal_en == RET_OK)
{
NmsCanPutObj_u8(0x2004, currentNode_gu8 + 1, 2u);
}
testBenchState_en = TEST_BENCH_IDLE;
} }
break; break;
} }

87
EnduranceTestBench/nehemis/processBoard.c
View File

@ -29,9 +29,9 @@
******************************************************************************/ ******************************************************************************/
#define NMS_CAN_CANOPEN_MASTER_LINE 1u #define NMS_CAN_CANOPEN_MASTER_LINE 1u
#define PU_PUMP_SPEED_CHANGE_INTERVAL 900000uLL #define PU_PUMP_SPEED_CHANGE_INTERVAL 120000uLL
#define PU_PUMP_MAX_SPEED 10u #define PU_PUMP_MAX_SPEED 10u
#define PU_PUMP_MIN_SPEED 2u #define PU_PUMP_MIN_SPEED 4u
#define PU_PMP_ENABLE 1u #define PU_PMP_ENABLE 1u
#define PU_PMP_DISABLE 0u #define PU_PMP_DISABLE 0u
#define PU_PMP_RATED_SPEED 3600uL #define PU_PMP_RATED_SPEED 3600uL
@ -92,13 +92,10 @@ void ProcessBoardInit(void)
GrundfosPmpInit(&grundfosPMP_gst); GrundfosPmpInit(&grundfosPMP_gst);
} }
void ProcessBoardRun(bool pumpTurnOn_b) void ProcessBoardRun(void)
{ {
AnalogMesaurementRun(); AnalogMesaurementRun();
if (pumpTurnOn_b == true)
{
GrundfosPmpEnable(PU_PMP_ENABLE);
/* Flowmeter data IN */ /* Flowmeter data IN */
FlowmeterGetFlow(&flowmeterFM1_gst); FlowmeterGetFlow(&flowmeterFM1_gst);
FlowmeterGetFlow(&flowmeterFM2_gst); FlowmeterGetFlow(&flowmeterFM2_gst);
@ -106,10 +103,10 @@ void ProcessBoardRun(bool pumpTurnOn_b)
FlowmeterGetFlow(&flowmeterFM4_gst); FlowmeterGetFlow(&flowmeterFM4_gst);
/* Pressure sensor data IN */ /* Pressure sensor data IN */
/* Removed to work with pressure controller */
PressureSensorGetVal(&pressureSensorPS1_gst); PressureSensorGetVal(&pressureSensorPS1_gst);
PressureSensorGetVal(&pressureSensorPS2_gst); PressureSensorGetVal(&pressureSensorPS2_gst);
PressureSensorGetVal(&pressureSensorPS3_gst); PressureSensorGetVal(&pressureSensorPS3_gst);
PressureSensorGetVal(&pressureSensorPS4_gst);
/* Flowmeter data OUT */ /* Flowmeter data OUT */
ProcessBoardFlowmeterDataOUT(flowmeterFM1_gst.rawQ_f32); ProcessBoardFlowmeterDataOUT(flowmeterFM1_gst.rawQ_f32);
@ -127,25 +124,8 @@ void ProcessBoardRun(bool pumpTurnOn_b)
ProcessBoardGrundfosPumpHandler(); ProcessBoardGrundfosPumpHandler();
} }
else
{
GrundfosPmpEnable(PU_PMP_DISABLE);
}
}
/* To be used with preesure controller */
//void ProcessBoardGrundfosPumpHandler(uint8 speed_u8)
//{
// GrundfosPmpSetSpeed(speed_u8);
//
// /* Grundfos Pump feedback speed OUT */
// GrundfosPmpFeedback(&grundfosPMP_gst);
//
// if ((uint8)(grundfosPMP_gst.rawQ_f32) > PU_PMP_RATED_SPEED)
// {
// speed_u8 -= 2u;
// }
//}
/****************************************************************************** /******************************************************************************
* Private function definitions * Private function definitions
******************************************************************************/ ******************************************************************************/
@ -155,7 +135,6 @@ static void ProcessBoardGrundfosPumpHandler(void)
static uint64 startTime_u64 = 0uLL; static uint64 startTime_u64 = 0uLL;
uint64 currentTimeMs_u64; uint64 currentTimeMs_u64;
GrundfosPmpEnable(PU_PMP_ENABLE);
HalSystemGetRunTimeMs(&currentTimeMs_u64); HalSystemGetRunTimeMs(&currentTimeMs_u64);
if (startTime_u64 == 0uLL) if (startTime_u64 == 0uLL)
@ -163,33 +142,40 @@ static void ProcessBoardGrundfosPumpHandler(void)
HalSystemGetRunTimeMs(&startTime_u64); HalSystemGetRunTimeMs(&startTime_u64);
} }
if ((currentTimeMs_u64 - startTime_u64) >= PU_PUMP_SPEED_CHANGE_INTERVAL) GrundfosPmpEnable(PU_PMP_ENABLE);
{
if (pressureSensorPS1_gst.rawT_f32 > PU_MAX_PRESSURE || pressureSensorPS2_gst.rawT_f32 > PU_MAX_PRESSURE ||
pressureSensorPS3_gst.rawT_f32 > PU_MAX_PRESSURE || pressureSensorPS4_gst.rawT_f32 > PU_MAX_PRESSURE)
{
/* Decrease speed if pressure is too high */
if (speed_u8 > PU_PUMP_MIN_SPEED)
{
speed_u8 -= 2u;
}
}
else if (speed_u8 <= PU_PUMP_MAX_SPEED)
{
speed_u8 += 2u;
}
else
{
speed_u8 = PU_PUMP_MIN_SPEED;
}
startTime_u64 = currentTimeMs_u64; // if ((currentTimeMs_u64 - startTime_u64) >= PU_PUMP_SPEED_CHANGE_INTERVAL)
} // {
// if (pressureSensorPS1_gst.rawT_f32 > PU_MAX_PRESSURE || pressureSensorPS2_gst.rawT_f32 > PU_MAX_PRESSURE ||
// pressureSensorPS3_gst.rawT_f32 > PU_MAX_PRESSURE || pressureSensorPS4_gst.rawT_f32 > PU_MAX_PRESSURE)
// {
// /* Decrease speed if pressure is too high */
// if (speed_u8 > PU_PUMP_MIN_SPEED)
// {
// speed_u8 -= 2u;
// }
// }
// else if (speed_u8 <= PU_PUMP_MAX_SPEED)
// {
// speed_u8 += 2u;
// }
// else
// {
// speed_u8 = PU_PUMP_MIN_SPEED;
// }
//
// startTime_u64 = currentTimeMs_u64;
// }
GrundfosPmpSetSpeed(speed_u8); GrundfosPmpSetSpeed(9u);
/* Grundfos Pump feedback speed OUT */ /* Grundfos Pump feedback speed OUT */
GrundfosPmpFeedback(&grundfosPMP_gst); GrundfosPmpFeedback(&grundfosPMP_gst);
if ((uint8)(grundfosPMP_gst.rawQ_f32) > PU_PMP_RATED_SPEED)
{
speed_u8 -= 2u;
}
} }
static void ProcessBoardFlowmeterDataOUT(float32 rawQ_f32) static void ProcessBoardFlowmeterDataOUT(float32 rawQ_f32)
@ -203,10 +189,7 @@ static void ProcessBoardFlowmeterDataOUT(float32 rawQ_f32)
static void ProcessBoardPressureSensorDataOUT(float32 rawT_f32) static void ProcessBoardPressureSensorDataOUT(float32 rawT_f32)
{ {
NmsCanPutObj_u16(OD_ENTRY_PU_PRESSURE_DATA_OUT_INDEX, OD_ENTRY_PU_PRESSURE1_DATA_OUT_SUB_INDEX, (uint16)pressureSensorPS1_gst.rawT_f32 * 100u); NmsCanPutObj_u16(OD_ENTRY_PU_PRESSURE_DATA_OUT_INDEX, OD_ENTRY_PU_PRESSURE1_DATA_OUT_SUB_INDEX, (uint16)(pressureSensorPS3_gst.rawT_f32 * 100.0f));
NmsCanPutObj_u16(OD_ENTRY_PU_PRESSURE_DATA_OUT_INDEX, OD_ENTRY_PU_PRESSURE2_DATA_OUT_SUB_INDEX, (uint16)pressureSensorPS2_gst.rawT_f32 * 100u);
NmsCanPutObj_u16(OD_ENTRY_PU_PRESSURE_DATA_OUT_INDEX, OD_ENTRY_PU_PRESSURE3_DATA_OUT_SUB_INDEX, (uint16)(pressureSensorPS3_gst.rawT_f32 * 100.0f));
NmsCanPutObj_u16(OD_ENTRY_PU_PRESSURE_DATA_OUT_INDEX, OD_ENTRY_PU_PRESSURE4_DATA_OUT_SUB_INDEX, (uint16)pressureSensorPS4_gst.rawT_f32 * 100u);
} }

2
EnduranceTestBench/nehemis/processBoard.h
View File

@ -47,6 +47,6 @@ void ProcessBoardInit(void);
* @return void * @return void
* *
*/ */
void ProcessBoardRun(bool pumpTurnOn_b); void ProcessBoardRun(void);
#endif /* PROCESSBOARD_H_ */ #endif /* PROCESSBOARD_H_ */

34
EnduranceTestBench/nms_can/nms_can.c
View File

@ -48,8 +48,8 @@
#define NMS_CAN_SDO_TRANSMIT 0x580u #define NMS_CAN_SDO_TRANSMIT 0x580u
#define NMS_CAN_SDO_RECEIVE 0x600u #define NMS_CAN_SDO_RECEIVE 0x600u
#define NMS_CAN_SDO_PARAM_INDEX 0x1280u #define NMS_CAN_SDO_PARAM_INDEX 0x1280u
#define NMS_CAN_LSS_NODE_COUNT 20u #define NMS_CAN_LSS_NODE_COUNT 10u
#define NMS_CAN_MIN_OPERATIONAL_NODES 15u #define NMS_CAN_MIN_OPERATIONAL_NODES 8u
/****************************************************************************** /******************************************************************************
* Type Declarations * Type Declarations
******************************************************************************/ ******************************************************************************/
@ -70,26 +70,16 @@ static bool monitorSleep_gb = CO_FALSE; /**< sleep flag */
static bool masterStarted_gb; /**< master started flag */ static bool masterStarted_gb; /**< master started flag */
static const NmsCanLssNodeInfo_t nodeLookupTable_gast[NMS_CAN_LSS_NODE_COUNT] = static const NmsCanLssNodeInfo_t nodeLookupTable_gast[NMS_CAN_LSS_NODE_COUNT] =
{ {
{0x59A, 0x4d2, 0x1, 0x01, 0x5} , {0x59A, 0x184, 0x1, 0x65, 0x5} ,
{0x59A, 0x4d2, 0x1, 0x02, 0x6} , {0x59A, 0x184, 0x1, 0x66, 0x6} ,
{0x59A, 0x4d2, 0x1, 0x03, 0x7} , {0x59A, 0x184, 0x1, 0x67, 0x7} ,
{0x59A, 0x4d2, 0x1, 0x04, 0x8} , {0x59A, 0x184, 0x1, 0x68, 0x8} ,
{0x59A, 0x4d2, 0x1, 0x05, 0x9} , {0x59A, 0x184, 0x1, 0x69, 0x9} ,
{0x59A, 0x4d2, 0x1, 0x06, 0xA} , {0x59A, 0x184, 0x1, 0x6A, 0xA} ,
{0x59A, 0x4d2, 0x1, 0x07, 0xB} , {0x59A, 0x184, 0x1, 0x6B, 0xB} ,
{0x59A, 0x4d2, 0x1, 0x08, 0xC} , {0x59A, 0x184, 0x1, 0x6C, 0xC} ,
{0x59A, 0x4d2, 0x1, 0x09, 0xD} , {0x59A, 0x184, 0x1, 0x6D, 0xD} ,
{0x59A, 0x4d2, 0x1, 0x0A, 0xE} , {0x59A, 0x184, 0x1, 0x6E, 0xE} ,
{0x59A, 0x4d2, 0x1, 0x0B, 0xF} ,
{0x59A, 0x4d2, 0x1, 0x0C, 0x10},
{0x59A, 0x4d2, 0x1, 0x0D, 0x11},
{0x59A, 0x4d2, 0x1, 0x0E, 0x12},
{0x59A, 0x4d2, 0x1, 0x0F, 0x13},
{0x59A, 0x4d2, 0x1, 0x10, 0x14},
{0x59A, 0x4d2, 0x1, 0x11, 0x15},
{0x59A, 0x4d2, 0x1, 0x12, 0x16},
{0x59A, 0x4d2, 0x1, 0x13, 0x17},
{0x59A, 0x4d2, 0x1, 0x14, 0x18}
}; };
static CO_NMT_STATE_T nodeNMTState_gaen[NMS_CAN_LSS_NODE_COUNT]; static CO_NMT_STATE_T nodeNMTState_gaen[NMS_CAN_LSS_NODE_COUNT];
static CO_TIMER_T nodeResetTimer_gst; static CO_TIMER_T nodeResetTimer_gst;

4
EnduranceTestBench/scheduler/sdl.c
View File

@ -122,11 +122,11 @@ void SdlRun(void)
EnduranceTestBenchRun(&testBenchStarted_b); EnduranceTestBenchRun(&testBenchStarted_b);
if (testBenchStarted_b) if (testBenchStarted_b)
{ {
ProcessBoardRun(true); ProcessBoardRun();
} }
else else
{ {
ProcessBoardRun(false); ProcessBoardRun();
} }
} }
#endif #endif