From 1e23f92880bf60d6062db837c10c2bf29638e84a Mon Sep 17 00:00:00 2001 From: Michal Sojka Date: Thu, 29 Aug 2013 13:42:20 +0200 Subject: [PATCH] Move flexray string based initialization functions from the library to the command implementation --- commands/cmd_fr_basic_test.c | 232 ++++++++++++++++++++++++++++++++++- rpp-lib | 2 +- 2 files changed, 232 insertions(+), 2 deletions(-) diff --git a/commands/cmd_fr_basic_test.c b/commands/cmd_fr_basic_test.c index 8b93f8b..b2b06c4 100644 --- a/commands/cmd_fr_basic_test.c +++ b/commands/cmd_fr_basic_test.c @@ -517,6 +517,236 @@ static Fr_ConfigType Fr_config_node_B= { .staticBufferConfigs = Fr_node_B_static_buffers_config }; +/* User configuration */ + +static Fr_TMS570LS_ClusterConfigType user_cluster_config; +static Fr_TMS570LS_NodeConfigType user_node_config; +static Fr_TMS570LS_MsgRAMConfig user_msg_ram_config; +static Fr_TMS570LS_BufferConfigType user_static_buffer_config[RPP_FR_MAX_STATIC_BUF_CNT]; +static Fr_TMS570LS_BufferConfigType user_dynamic_buffer_config[RPP_FR_MAX_DYNAMIC_BUF_CNT]; +static Fr_TMS570LS_BufferConfigType user_fifo_buffer_config[RPP_FR_MAX_FIFO_BUF_DEPTH]; +static Fr_ConfigType user_configuration = { + .clusterConfiguration = &user_cluster_config, + .nodeConfiguration = &user_node_config, + .msgRAMConfig = &user_msg_ram_config, + .staticBufferConfigs = user_static_buffer_config, + .dynamicBufferConfigs = user_dynamic_buffer_config, + .fifoBufferConfigs = user_fifo_buffer_config, +};; + +#define USER_CONFIG_NOT_DONE 0x0 +#define USER_CONFIG_CLUSTER 0x1 +#define USER_CONFIG_NODE 0x2 +#define USER_CONFIG_STATIC_BUF 0x4 + +static uint8_t user_configuration_state = USER_CONFIG_NOT_DONE; +static uint8_t user_static_buffer_index; +static uint8_t user_dynamic_buffer_index; +static uint8_t user_fifo_buffer_depth = 0; + +/** + * Split string into numbers + * + * The function takes a string with hexadecimal numbers, + * separated by spaces, and converts it into an array of numbers. + * + * For example "0x2 0xA 0XDD 0xABCD" -> {0x2, 0xA, 0XDD, 0xABCD} + * + * @param [in] params Address of the string which will be converted + * @param [in] params_cnt A number of parameters, which should be found and converted from the string params + * @param [out] tmp_params Address, where converted array of numbers will be stored + * + * @return SUCCESS when all parameters were converted to the array of numbers, + * FAILURE when the string was too short, too long or some other error occurred. + */ +static int8_t rpp_fr_parse_params(const char* params, uint32_t params_cnt, uint32_t* tmp_params) { + char cpy_params[256]; + char* token; + int i; + + if (params == NULL || tmp_params == NULL) { + return FAILURE; + } + strncpy(cpy_params, params, 256); + token = strtok(cpy_params, " "); + if (token == NULL) { + return FAILURE; + } + for (i = 0; i < params_cnt; i++) { + if (sscanf(token, "%x", &tmp_params[i]) == EOF) { // No number found + return FAILURE; + } + if ((token = strtok(NULL, " ")) == NULL && i < params_cnt-1) { // Not enough parameters in the string + return FAILURE; + } + } + return SUCCESS; +} + +int8_t rpp_fr_config_cluster_params(const char* params) { + uint32_t tmp_params[FR_CLUSTER_PARAMS_CNT]; + + if (rpp_fr_parse_params(params, FR_CLUSTER_PARAMS_CNT, tmp_params) == FAILURE) { + return FAILURE; + } + + user_cluster_config.gColdStartAttempts = tmp_params[0]; + user_cluster_config.gListenNoise = tmp_params[1]; + user_cluster_config.gMacroPerCycle = tmp_params[2]; + user_cluster_config.gMaxWithoutClockCorrectionFatal = tmp_params[3]; + user_cluster_config.gMaxWithoutClockCorrectionPassive = tmp_params[4]; + user_cluster_config.gNetworkManagementVectorLength = tmp_params[5]; + user_cluster_config.gNumberOfMinislots = tmp_params[6]; + user_cluster_config.gNumberOfStaticSlots = tmp_params[7]; + user_cluster_config.gOffsetCorrectionStart = tmp_params[8]; + user_cluster_config.gPayloadLengthStatic = tmp_params[9]; + user_cluster_config.gSyncNodeMax = tmp_params[10]; + user_cluster_config.gdActionPointOffset = tmp_params[11]; + user_cluster_config.gdCASRxLowMax = tmp_params[12]; + user_cluster_config.gdDynamicSlotIdlePhase = tmp_params[13]; + user_cluster_config.gdMinislot = tmp_params[14]; + user_cluster_config.gdMinislotActionPointOffset = tmp_params[15]; + user_cluster_config.gdNIT = tmp_params[16]; + user_cluster_config.gdSampleClockPeriod = tmp_params[17]; + user_cluster_config.gdStaticSlot = tmp_params[18]; + user_cluster_config.gdTSSTransmitter = tmp_params[19]; + user_cluster_config.gdWakeupSymbolRxIdle = tmp_params[20]; + user_cluster_config.gdWakeupSymbolRxLow = tmp_params[21]; + user_cluster_config.gdWakeupSymbolRxWindow = tmp_params[22]; + user_cluster_config.gdWakeupSymbolTxIdle = tmp_params[23]; + user_cluster_config.gdWakeupSymbolTxLow = tmp_params[24]; + + user_configuration_state |= USER_CONFIG_CLUSTER; + return SUCCESS; +} + +int8_t rpp_fr_config_node_params(const char* params) { + uint32_t tmp_params[FR_NODE_PARAMS_CNT+2]; // +2 because two more parameters from message RAM structure are expected in the string. + Fr_ChannelType channels[3] = {FR_CHANNEL_A, FR_CHANNEL_B, FR_CHANNEL_AB}; + Fr_TMS570LS_SecureBuffersType secure[4] = {FR_SB_RECONFIG_ENABLED, FR_SB_STAT_REC_DISABLED_STAT_TR_DISABLED, FR_SB_ALL_REC_DISABLED, FR_SB_ALL_REC_DISABLED_STAT_TR_DISABLED}; + + if (rpp_fr_parse_params(params, FR_NODE_PARAMS_CNT+2, tmp_params) == FAILURE) { + return FAILURE; + } + + user_node_config.pAllowHaltDueToClock = tmp_params[0]; + user_node_config.pAllowPassiveToActive = tmp_params[1]; + if (tmp_params[2] > 2) return FAILURE; + user_node_config.pChannels = channels[ tmp_params[2] ]; + user_node_config.pClusterDriftDamping = tmp_params[3]; + user_node_config.pDelayCompensationA = tmp_params[4]; + user_node_config.pDelayCompensationB = tmp_params[5]; + user_node_config.pExternOffsetCorrection = tmp_params[6]; + user_node_config.pExternRateCorrection = tmp_params[7]; + user_node_config.pKeySlotUsedForStartup = tmp_params[8]; + user_node_config.pKeySlotUsedForSync = tmp_params[9]; + user_node_config.pLatestTx = tmp_params[10]; + user_node_config.pMacroInitialOffsetA = tmp_params[11]; + user_node_config.pMacroInitialOffsetB = tmp_params[12]; + user_node_config.pMicroInitialOffsetA = tmp_params[13]; + user_node_config.pMicroInitialOffsetB = tmp_params[14]; + user_node_config.pMicroPerCycle = tmp_params[15]; + user_node_config.pRateCorrectionOut = tmp_params[16]; + user_node_config.pOffsetCorrectionOut = tmp_params[17]; + user_node_config.pSamplesPerMicrotick = tmp_params[18]; + user_node_config.pSingleSlotEnabled = tmp_params[19]; + if (tmp_params[20] > 1) return FAILURE; + user_node_config.pWakeupChannel = channels[ tmp_params[20] ]; + user_node_config.pWakeupPattern = tmp_params[21]; + user_node_config.pdAcceptedStartupRange = tmp_params[22]; + user_node_config.pdListenTimeout = tmp_params[23]; + user_node_config.pdMaxDrift = tmp_params[24]; + user_node_config.pDecodingCorrection = tmp_params[25]; + user_msg_ram_config.syncFramePayloadMultiplexEnabled = tmp_params[26]; + if (tmp_params[27] > 3) return FAILURE; + user_msg_ram_config.secureBuffers = secure[ tmp_params[27] ]; + + user_configuration_state |= USER_CONFIG_NODE; + return SUCCESS; +} + +int8_t rpp_fr_config_static_buffer(const char* params) { + uint32_t tmp_params[FR_STATIC_BUF_PARAMS_CNT]; + Fr_ChannelType channels[3] = {FR_CHANNEL_A, FR_CHANNEL_B, FR_CHANNEL_AB}; + + if (user_static_buffer_index >= RPP_FR_MAX_STATIC_BUF_CNT) { + return FAILURE; + } + + if (rpp_fr_parse_params(params, FR_STATIC_BUF_PARAMS_CNT, tmp_params) == FAILURE) { + return FAILURE; + } + + if (tmp_params[0] > 2) return FAILURE; + user_static_buffer_config[user_static_buffer_index].channel = channels[ tmp_params[0] ]; + user_static_buffer_config[user_static_buffer_index].cycleCounterFiltering = tmp_params[1]; + user_static_buffer_config[user_static_buffer_index].isTx = tmp_params[2]; + user_static_buffer_config[user_static_buffer_index].maxPayload = tmp_params[3]; + user_static_buffer_config[user_static_buffer_index].msgBufferInterrupt = tmp_params[4]; + user_static_buffer_config[user_static_buffer_index].payloadPreambleIndicatorTr = tmp_params[5]; + user_static_buffer_config[user_static_buffer_index].singleTransmit = tmp_params[6]; + user_static_buffer_config[user_static_buffer_index].slotId = tmp_params[7]; + user_static_buffer_index++; + + user_configuration_state |= USER_CONFIG_STATIC_BUF; + return SUCCESS; +} + +int8_t rpp_fr_config_dynamic_buffer(const char* params) { + uint32_t tmp_params[FR_DYNAMIC_BUF_PARAMS_CNT]; + Fr_ChannelType channels[3] = {FR_CHANNEL_A, FR_CHANNEL_B, FR_CHANNEL_AB}; + + if (user_dynamic_buffer_index >= RPP_FR_MAX_DYNAMIC_BUF_CNT) { + return FAILURE; + } + + if (rpp_fr_parse_params(params, FR_DYNAMIC_BUF_PARAMS_CNT, tmp_params) == FAILURE) { + return FAILURE; + } + + if (tmp_params[0] > 1) return FAILURE; + user_dynamic_buffer_config[user_dynamic_buffer_index].channel = channels[ tmp_params[0] ]; + user_dynamic_buffer_config[user_dynamic_buffer_index].cycleCounterFiltering = tmp_params[1]; + user_dynamic_buffer_config[user_dynamic_buffer_index].isTx = tmp_params[2]; + user_dynamic_buffer_config[user_dynamic_buffer_index].maxPayload = tmp_params[3]; + user_dynamic_buffer_config[user_dynamic_buffer_index].msgBufferInterrupt = tmp_params[4]; + user_dynamic_buffer_config[user_dynamic_buffer_index].singleTransmit = tmp_params[5]; + user_dynamic_buffer_config[user_dynamic_buffer_index].slotId = tmp_params[6]; + user_dynamic_buffer_index++; + + return SUCCESS; +} + +int8_t rpp_fr_config_fifo_buffer(const char* params) { + uint32_t tmp_params[FR_FIFO_BUF_PARAMS_CNT+1]; // +1 because the first parameter in the string means the depth of the buffer, and the constant means the number of items in the configuration structure. + Fr_ChannelType channels[3] = {FR_CHANNEL_A, FR_CHANNEL_B, FR_CHANNEL_AB}; + Fr_TMS570LS_BufferConfigType* fifo_buffer_ptr = &user_fifo_buffer_config[0]; + + if (user_fifo_buffer_depth != 0) { + return FAILURE; + } + + if (rpp_fr_parse_params(params, FR_FIFO_BUF_PARAMS_CNT+1, tmp_params) == FAILURE) { + return FAILURE; + } + + if (tmp_params[0] > RPP_FR_MAX_FIFO_BUF_DEPTH) return FAILURE; + if (tmp_params[1] > 2) return FAILURE; + + for (fifo_buffer_ptr = &user_fifo_buffer_config[0]; fifo_buffer_ptr < &user_fifo_buffer_config[tmp_params[0]]; fifo_buffer_ptr++) { + fifo_buffer_ptr->channel = channels[ tmp_params[1] ]; + fifo_buffer_ptr->cycleCounterFiltering = tmp_params[2]; + fifo_buffer_ptr->maxPayload = tmp_params[3]; + fifo_buffer_ptr->rejectNullFrames = tmp_params[4]; + fifo_buffer_ptr->rejectStaticSegment = tmp_params[5]; + fifo_buffer_ptr->slotId = tmp_params[6]; + } + user_fifo_buffer_depth = tmp_params[0]; + + return SUCCESS; +} + + /** * @brief Do the user configuration of the FlexRay cluster parameters * @@ -591,7 +821,7 @@ int cmd_do_fr_init(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[]) { Fr_ConfigPtr = &Fr_config_node_B; } else if (*param[1] == 'U') { // Select the user configuration - call config commands first - Fr_ConfigPtr = NULL; + Fr_ConfigPtr = &user_configuration; } else { return -CMDERR_BADPAR; diff --git a/rpp-lib b/rpp-lib index 94db69c..d5d6a25 160000 --- a/rpp-lib +++ b/rpp-lib @@ -1 +1 @@ -Subproject commit 94db69c1029c2e5a48c4a05efb45907d373b7eaf +Subproject commit d5d6a256f5970fb6ebb207d814d1e967b07ed608 -- 2.39.2