From 1cb59504671100dd41d3072821e31b3da931f723 Mon Sep 17 00:00:00 2001 From: Aditya Naik Date: Thu, 4 Jun 2020 20:26:13 -0400 Subject: Testing micropython slave --- makefile | 2 +- src/main-master.c | 192 +++++++++++------------------------------- src/main-slave.c | 247 +++++++++++++++++++++--------------------------------- 3 files changed, 144 insertions(+), 297 deletions(-) diff --git a/makefile b/makefile index 91fca11..640d80d 100644 --- a/makefile +++ b/makefile @@ -36,7 +36,7 @@ BUILD_DIR = build ###################################### # C sources C_SOURCES = \ -src/main-slave.c \ +src/main-master.c \ src/stm32f4xx_it.c \ src/stm32f4xx_hal_msp.c \ src/system_stm32f4xx.c \ diff --git a/src/main-master.c b/src/main-master.c index a4a278e..8242539 100644 --- a/src/main-master.c +++ b/src/main-master.c @@ -33,7 +33,7 @@ #define COUNTOF(__BUFFER__) (sizeof(__BUFFER__) / sizeof(*(__BUFFER__))) #define I2C_ADDRESS 0x05 -#define BUS_DEVICE_LIMIT 128 +#define BUS_DEVICE_LIMIT 5 /* Macro to toggle between master and slave firmware */ #define MASTER @@ -105,7 +105,7 @@ int main(void) while (1) { if (priority_counter == 0) { hs_status_t hs_status; - for (int curr_addr=0; curr_addr < 5; curr_addr++) { + for (uint8_t curr_addr=1; curr_addr < BUS_DEVICE_LIMIT; curr_addr++) { if (todo_hs_or_not_todo_hs(curr_addr)) { hs_status = handshake(curr_addr); dev_sts[GET_IDX_FROM_ADDR(curr_addr)] = get_state_from_hs_status(curr_addr, hs_status); @@ -113,7 +113,7 @@ int main(void) } } - else if (priority_counter == 5) { + else if (priority_counter == 5 && routing_ptr > 0) { routing(); } else { @@ -137,14 +137,11 @@ hs_status_t handshake(uint32_t i2c_addr) /* Handshake variables */ uint8_t hs_sts = IDLE; - uint8_t *MDR_req_buf, *MDR_ACK_buf, *MDR_CTS_buf, *MDR_buf; + uint8_t *MDR_buf; uint32_t AF_error_counter = 0; uint32_t dev_idx = GET_IDX_FROM_ADDR(i2c_addr); - uint32_t MDR_len = 0; + uint16_t MDR_len = 0; - m2s_MDR_request MDR_req_message = m2s_MDR_request_init_default; - s2m_MDR_req_ACK MDR_ACK = s2m_MDR_req_ACK_init_default; - m2s_MDR_res_CTS MDR_CTS = m2s_MDR_res_CTS_init_default; s2m_MDR_response MDR_res_message = s2m_MDR_response_init_default; #if defined(TESTING_ENABLE) || defined(DEBUG_ENABLE) @@ -152,54 +149,32 @@ hs_status_t handshake(uint32_t i2c_addr) #endif #ifdef TESTING_ENABLE uint8_t term[] = "\r\n"; - size_t MDR_req_size, MDR_CTS_size; #endif while (hs_sts != HS_FAILED && hs_sts != HS_REGISTERED) { switch (hs_sts) { case (IDLE): { - MDR_req_buf = malloc(8); - pb_ostream_t MDR_req_stream = pb_ostream_from_buffer(MDR_req_buf, 2); - MDR_req_message.record_type = 7; /* Placeholder for default record type */ - if(!pb_encode(&MDR_req_stream, m2s_MDR_request_fields, &MDR_req_message)) { + uint8_t MDR_req_buf[2] = {0x0, 0x1}; + if (HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)i2c_addr, MDR_req_buf, 2, 10000) != HAL_OK) { hs_sts = HS_FAILED; #ifdef DEBUG_ENABLE - goto __MDR_REQ_ENC_FAIL; - __MDR_REQ_ENC_FAIL_END: + goto __HS_MDR_REQ_I2C_ERROR; + __HS_MDR_REQ_I2C_ERROR_END: __asm__("nop"); #endif } else { -#ifdef TESTING_ENABLE - MDR_req_size = MDR_req_stream.bytes_written; - goto __HS_IDLE_TESTING; - __HS_IDLE_TESTING_END: - __asm__("nop"); -#endif - if (HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)i2c_addr, (uint8_t*)MDR_req_buf, - MDR_req_buf_len, 10000) != HAL_OK) { - hs_sts = HS_FAILED; -#ifdef DEBUG_ENABLE - goto __HS_MDR_REQ_I2C_ERROR; - __HS_MDR_REQ_I2C_ERROR_END: - __asm__("nop"); -#endif - } - else { - hs_sts = HS_MDR_ACK; - } - free(MDR_req_buf); - break; + hs_sts = HS_MDR_ACK; } + break; } case (HS_MDR_ACK): { HAL_Delay(MASTER_I2C_BUS_INTERVAL); - MDR_ACK_buf = malloc(8); + uint8_t MDR_ACK_buf[2] = {0x0, 0x0}; AF_error_counter = 0; - while (HAL_I2C_Master_Receive(&hi2c1, (uint16_t)i2c_addr, (uint8_t*)MDR_ACK_buf, - s2m_MDR_req_ACK_size, 100) != HAL_OK) { + while (HAL_I2C_Master_Receive(&hi2c1, (uint16_t)i2c_addr, MDR_ACK_buf, 2, 100) != HAL_OK) { if (HAL_I2C_GetError(&hi2c1) != HAL_I2C_ERROR_AF) { hs_sts = HS_FAILED; } @@ -216,62 +191,32 @@ hs_status_t handshake(uint32_t i2c_addr) } } if (hs_sts != HS_FAILED) { - pb_istream_t MDR_ACK_istream = pb_istream_from_buffer(MDR_ACK_buf, 2); - if (!pb_decode(&MDR_ACK_istream, s2m_MDR_req_ACK_fields, &MDR_ACK)) { - hs_sts = HS_FAILED; -#ifdef DEBUG_ENABLE - goto __MDR_ACK_DEC_ERROR; - __MDR_ACK_DEC_ERROR_END: - __asm__("nop"); -#endif + uint8_t ACK_flag = MDR_ACK_buf[1]; + if (ACK_flag == 0xFF) { + MDR_len = MDR_ACK_buf[0]; + hs_sts = HS_MDR_CTS; } else { - MDR_len = MDR_ACK.MDR_res_length; - hs_sts = HS_MDR_CTS; -#ifdef TESTING_ENABLE - goto __HS_MDR_ACK_TESTING; - __HS_MDR_ACK_TESTING_END: - __asm__("nop"); -#endif + hs_sts = HS_FAILED; } - free(MDR_ACK_buf); } break; } case (HS_MDR_CTS): { - MDR_CTS_buf = (uint8_t*)malloc(8); - pb_ostream_t MDR_CTS_ostream = pb_ostream_from_buffer(MDR_CTS_buf, sizeof(MDR_CTS_buf)); - MDR_CTS.timeout = 100; - if (!pb_encode(&MDR_CTS_ostream, m2s_MDR_res_CTS_fields, &MDR_CTS)) { + uint8_t MDR_CTS_buf[2] = {0x0, 0x02}; + if (HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)i2c_addr, MDR_CTS_buf, 2, 10000) != HAL_OK) { hs_sts = HS_FAILED; #ifdef DEBUG_ENABLE - goto __MDR_CTS_ENC_ERROR; - __MDR_CTS_ENC_ERROR_END: + goto __HS_CTS_I2C_ERROR; + __HS_CTS_I2C_ERROR_END: __asm__("nop"); #endif } else { -#ifdef TESTING_ENABLE - MDR_CTS_size = MDR_CTS_ostream.bytes_written; - goto __HS_MDR_CTS_TESTING; - __HS_MDR_CTS_TESTING_END: - __asm__("nop"); -#endif - if (HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)i2c_addr, - (uint8_t*)MDR_CTS_buf, 2, 10000) != HAL_OK) { - hs_sts = HS_FAILED; -#ifdef DEBUG_ENABLE - goto __HS_CTS_I2C_ERROR; - __HS_CTS_I2C_ERROR_END: - __asm__("nop"); -#endif - } - else { - hs_sts = HS_MDR_MDR; - free(MDR_CTS_buf); - } + hs_sts = HS_MDR_MDR; } + break; } case (HS_MDR_MDR): @@ -304,6 +249,7 @@ hs_status_t handshake(uint32_t i2c_addr) MDR_res_message.subscriptions.arg = (void*)dev_idx; pb_istream_t MDR_res_stream = pb_istream_from_buffer(MDR_buf, MDR_len); if (!pb_decode(&MDR_res_stream, s2m_MDR_response_fields, &MDR_res_message)) { + hs_sts = HS_FAILED; #ifdef DEBUG_ENABLE goto __HS_MDR_DEC_ERROR; __HS_MDR_DEC_ERROR_END: @@ -327,43 +273,11 @@ hs_status_t handshake(uint32_t i2c_addr) break; } } - } #ifdef TESTING_ENABLE { goto __TESTING_BLOCK_END; - __HS_IDLE_TESTING: - sprintf((char*)debug_buf, "MDR req length: %d\r\n", MDR_req_size); - HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); - memset(debug_buf, 0, 128); - uint8_t bufbuf[] = "MDR req buffer: "; - HAL_UART_Transmit(&huart1, bufbuf, sizeof(bufbuf), 100); - for(int x=0; xmod_idx && !alloc; dev_sub_idx++) { @@ -845,7 +747,7 @@ bool decode_subscriptions_callback(pb_istream_t *istream, const pb_field_t *fiel } if(!pb_decode(istream, _subscriptions_fields, &subs)) - return false; + return false; /* Parse all fields if they're included */ if (subs.has_module_id) @@ -970,16 +872,16 @@ bool decode_data_callback(pb_istream_t *istream, const pb_field_t *field, void * datapoint[data_idx].data = loc_datapoint.data; if (loc_datapoint.has_channel_id) { - datapoint[data_idx].has_channel_id = true; - datapoint[data_idx].channel_id = loc_datapoint.channel_id; + datapoint[data_idx].has_channel_id = true; + datapoint[data_idx].channel_id = loc_datapoint.channel_id; } if (loc_datapoint.has_unit_id) { - datapoint[data_idx].has_unit_id = true; - datapoint[data_idx].unit_id = loc_datapoint.unit_id; + datapoint[data_idx].has_unit_id = true; + datapoint[data_idx].unit_id = loc_datapoint.unit_id; } if (loc_datapoint.has_timestamp) { - datapoint[data_idx].has_timestamp = true; - datapoint[data_idx].timestamp = loc_datapoint.timestamp; + datapoint[data_idx].has_timestamp = true; + datapoint[data_idx].timestamp = loc_datapoint.timestamp; } data_idx++; diff --git a/src/main-slave.c b/src/main-slave.c index f5979db..8218290 100644 --- a/src/main-slave.c +++ b/src/main-slave.c @@ -51,7 +51,7 @@ bool decode_subscriptions_callback(pb_istream_t *istream, const pb_field_t *fiel bool encode_subscription_callback(pb_ostream_t *ostream, const pb_field_t *field, void * const *arg); bool encode_datapoint_callback(pb_ostream_t *ostream, const pb_field_t *field, void * const *arg); bool decode_data_callback(pb_istream_t *istream, const pb_field_t *field, void **args); - +bool handshake(void); /** * @brief The application entry point. * @retval int @@ -74,157 +74,8 @@ int main(void) uint8_t reset_string[] = "\r\n\n==========SLAVE RESET=========\r\n\n"; HAL_UART_Transmit(&huart1, reset_string, sizeof(reset_string), 100); - { - uint8_t MDR_buf[128], debug_buf[128], term[]="\r\n"; - size_t MDR_enc_size; - s2m_MDR_response res; - res.MDR_version = 0.1; - res.module_id = 1; - res.module_class = 2; - res.entity_id=1; - - res.subscriptions.funcs.encode=encode_subscription_callback; - pb_ostream_t ostream = pb_ostream_from_buffer(MDR_buf, sizeof(MDR_buf)); - if(!pb_encode(&ostream, s2m_MDR_response_fields, &res)) { -#ifdef DEBUG_ENABLE - uint8_t err_buf[] = "MDR encoding error\r\n"; - HAL_UART_Transmit(&huart1, err_buf, sizeof(err_buf), 100); -#endif - while(1) { - HAL_GPIO_TogglePin(led_GPIO_Port, led_Pin); - HAL_Delay(500); - } - } - MDR_enc_size = ostream.bytes_written; -#ifdef TESTING_ENABLE - sprintf((char*)debug_buf, "MDR Encoded size: %d\r\n", MDR_enc_size); - HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); - memset(debug_buf, 0, 128); - - uint8_t bufbuf[] = "MDR Buffer: "; - HAL_UART_Transmit(&huart1, bufbuf, sizeof(bufbuf), 100); - for(int x=0; xtag == s2m_MDR_response_subscriptions_tag) { -- cgit v1.2.3 From 3f5f496bd809fa417dbaa7bbd33db0d903033155 Mon Sep 17 00:00:00 2001 From: Aditya Naik Date: Fri, 5 Jun 2020 13:26:13 -0400 Subject: Dataflow errors, switching CTS to bytes TX --- src/main-master.c | 105 +++++++++++++++++++----------------------------------- src/main-slave.c | 39 ++++---------------- 2 files changed, 42 insertions(+), 102 deletions(-) diff --git a/src/main-master.c b/src/main-master.c index 8242539..e4a8fd4 100644 --- a/src/main-master.c +++ b/src/main-master.c @@ -32,8 +32,8 @@ #define SET_BIT_FROM_IDX(a, b) a[b>>5]|=(1<<(b%32)) #define COUNTOF(__BUFFER__) (sizeof(__BUFFER__) / sizeof(*(__BUFFER__))) -#define I2C_ADDRESS 0x05 -#define BUS_DEVICE_LIMIT 5 +/* #define I2C_ADDRESS 0x05 */ +#define BUS_DEVICE_LIMIT 16 /* Macro to toggle between master and slave firmware */ #define MASTER @@ -105,7 +105,7 @@ int main(void) while (1) { if (priority_counter == 0) { hs_status_t hs_status; - for (uint8_t curr_addr=1; curr_addr < BUS_DEVICE_LIMIT; curr_addr++) { + for (uint8_t curr_addr=1; curr_addr <= BUS_DEVICE_LIMIT; curr_addr++) { if (todo_hs_or_not_todo_hs(curr_addr)) { hs_status = handshake(curr_addr); dev_sts[GET_IDX_FROM_ADDR(curr_addr)] = get_state_from_hs_status(curr_addr, hs_status); @@ -117,7 +117,7 @@ int main(void) routing(); } else { - for (int device_idx = 0; device_idx < BUS_DEVICE_LIMIT-1; device_idx++) { + for (int device_idx = 0; device_idx < BUS_DEVICE_LIMIT; device_idx++) { if (dev_sts[device_idx] == REGISTERED) { device_dataflow(GET_ADDR_FROM_IDX(device_idx), SLAVE_TX, 0); } @@ -340,12 +340,11 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r uint8_t dev_idx = GET_IDX_FROM_ADDR(i2c_addr); dataflow_status_t df_status = DF_IDLE; - uint8_t *SOR_buf, *DOC_buf, *CTS_buf, *data_buf; + uint8_t *CTS_buf, *data_buf; uint32_t AF_error_counter = 0; uint32_t data_len = 0; _datapoint datapoints[16]; - m2s_SOR SOR_message = m2s_SOR_init_default; s2m_DOC DOC_message = s2m_DOC_init_zero; /* TODO Add default values to the CTS message in proto */ m2s_CTS CTS_message = m2s_CTS_init_default; @@ -361,49 +360,39 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r switch (df_status) { case (DF_IDLE): { - SOR_buf = malloc(sizeof(m2s_SOR)); - pb_ostream_t SOR_stream = pb_ostream_from_buffer(SOR_buf, sizeof(SOR_buf)); - SOR_message.SOR_code = SOR_code; - if (!pb_encode(&SOR_stream, m2s_SOR_fields, &SOR_message)) { + /* HAL_Delay(MASTER_I2C_BUS_INTERVAL); */ + uint8_t SOR_buf[2] = {SOR_code, 0x0}; + if (HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)i2c_addr, SOR_buf, 2, 10000) != HAL_OK) { df_status = DF_FAIL; #ifdef DEBUG_ENABLE - goto __DF_SOR_ENC_FAIL; - __DF_SOR_ENC_FAIL_END: + goto __DF_SOR_I2C_ERROR; + __DF_SOR_I2C_ERROR_END: __asm__("nop"); #endif } else { - if (HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)i2c_addr, (uint8_t*)SOR_buf, - m2s_SOR_size, 10000) != HAL_OK) { - df_status = DF_FAIL; -#ifdef DEBUG_ENABLE - goto __DF_SOR_I2C_ERROR; - __DF_SOR_I2C_ERROR_END: - __asm__("nop"); -#endif + if (SOR_code == SLAVE_TX) { + df_status = DF_RX_DOC; } - else { - if (SOR_code == SLAVE_TX) { - df_status = DF_RX_DOC; - } - else if (SOR_code == SLAVE_RX_DATAPOINT) { - /* TODO */ - df_status = DF_LEN_TX; - } - else if (SOR_code == SLAVE_RX_COMMAND) { - /* TODO */ - } + else if (SOR_code == SLAVE_RX_DATAPOINT) { + /* TODO */ + df_status = DF_LEN_TX; + } + else if (SOR_code == SLAVE_RX_COMMAND) { + /* TODO */ } } break; } + + case (DF_RX_DOC): { HAL_Delay(MASTER_I2C_BUS_INTERVAL); - DOC_buf = (uint8_t*)malloc(4); + uint8_t DOC_buf[4]; AF_error_counter = 0; while (HAL_I2C_Master_Receive(&hi2c1, (uint16_t)i2c_addr, - (uint8_t*)DOC_buf, 4, 500) != HAL_OK) { + (uint8_t*)DOC_buf, 4, 1000) != HAL_OK) { if (HAL_I2C_GetError(&hi2c1) != HAL_I2C_ERROR_AF) { df_status = DF_FAIL; #ifdef DEBUG_ENABLE @@ -413,35 +402,24 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r #endif break; } - else if (++AF_error_counter > 4000) { + else if (++AF_error_counter > 1500) { df_status = DF_FAIL; break; } } - if (df_status != DF_FAIL) { - pb_istream_t DOC_istream = pb_istream_from_buffer(DOC_buf, 4); - if (!pb_decode(&DOC_istream, s2m_DOC_fields, &DOC_message)) { - df_status = DF_FAIL; -#ifdef DEBUG_ENABLE - goto __DF_DOC_DECODE_ERROR; - __DF_DOC_DECODE_ERROR_END: - __asm__("nop"); -#endif + if (df_status != DF_FAIL) { + if (DOC_buf[1] == DATA) { + df_status = DF_CTS; + data_len = DOC_buf[3]; } - else { - if (DOC_message.DOC_code == DATA) { - df_status = DF_CTS; - data_len = DOC_message.tx_length; - } - else if (DOC_message.DOC_code == CMD_UNICAST) { - /* TODO */ - } - else if (DOC_message.DOC_code == CMD_MULTICAST) { - /* TODO */ - } - else if (DOC_message.DOC_code == CMD_BROADCAST) { - /* TODO */ - } + else if (DOC_message.DOC_code == CMD_UNICAST) { + /* TODO */ + } + else if (DOC_message.DOC_code == CMD_MULTICAST) { + /* TODO */ + } + else if (DOC_message.DOC_code == CMD_BROADCAST) { + /* TODO */ } } break; @@ -489,7 +467,7 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r data_buf = (uint8_t*)malloc(128); AF_error_counter = 0; while (HAL_I2C_Master_Receive(&hi2c1, (uint16_t)i2c_addr, - (uint8_t*)data_buf, data_len, 10000) != HAL_OK) { + (uint8_t*)data_buf, data_len, 1000) != HAL_OK) { if (HAL_I2C_GetError(&hi2c1) != HAL_I2C_ERROR_AF) { df_status = DF_FAIL; #ifdef DEBUG_ENABLE @@ -647,11 +625,6 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r #ifdef DEBUG_ENABLE { goto __DF_DEBUG_BLOCK_END; - __DF_SOR_ENC_FAIL: - sprintf((char*)debug_buf, "SOR encoding error\r\n"); - HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); - memset(debug_buf, 0, 128); - goto __DF_SOR_ENC_FAIL_END; __DF_SOR_I2C_ERROR: sprintf((char*)debug_buf, "Unable to send SOR request to %d. I2C error: %ld\r\n", i2c_addr, HAL_I2C_GetError(&hi2c1)); @@ -663,11 +636,6 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); memset(debug_buf, 0, 128); goto __DF_DOC_I2C_ERROR_END; - __DF_DOC_DECODE_ERROR: - sprintf((char*)debug_buf, "DOC decoding error\r\n"); - HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); - memset(debug_buf, 0, 128); - goto __DF_DOC_DECODE_ERROR_END; __DF_CTS_ENC_FAIL: sprintf((char*)debug_buf, "CTS encoding error\r\n"); HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); @@ -936,7 +904,6 @@ static void MX_I2C1_Init(void) hi2c1.Instance = I2C1; hi2c1.Init.ClockSpeed = 100000; hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2; - hi2c1.Init.OwnAddress1 = I2C_ADDRESS; hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE; hi2c1.Init.OwnAddress2 = 0xFF; diff --git a/src/main-slave.c b/src/main-slave.c index 8218290..39d31bb 100644 --- a/src/main-slave.c +++ b/src/main-slave.c @@ -76,11 +76,11 @@ int main(void) while (handshake() == false); - + uint8_t SOR_buf[2] = {0}, debug_buf[128]; HAL_Delay(1000); while (1) { - uint8_t SOR_buf[m2s_SOR_size] = {0}, debug_buf[128]; - if (HAL_I2C_Slave_Receive(&hi2c1, (uint8_t*)SOR_buf, m2s_SOR_size, 100) != HAL_OK) { + + if (HAL_I2C_Slave_Receive(&hi2c1, (uint8_t*)SOR_buf, 2, 500) != HAL_OK) { sprintf((char*)debug_buf, "Failed to get SOR\r\n"); HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); memset(debug_buf, 0, 128); @@ -91,21 +91,8 @@ int main(void) HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); memset(debug_buf, 0, 128); } - m2s_SOR SOR_message; - pb_istream_t SOR_istream = pb_istream_from_buffer(SOR_buf, 2); - if (!pb_decode(&SOR_istream, m2s_SOR_fields, &SOR_message)) { - sprintf((char*)debug_buf, "SOR decode error\r\n"); - HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); - memset(debug_buf, 0, 128); - continue; - } - else { - sprintf((char*)debug_buf, "SOR decoded; code: %ld\r\n", SOR_message.SOR_code); - HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); - memset(debug_buf, 0, 128); - } - if (SOR_message.SOR_code == 1) { + if (SOR_buf[0] == 1) { uint8_t data_buf[128]; size_t data_enc_size; s2m_data data; @@ -120,21 +107,7 @@ int main(void) data_enc_size = data_ostream.bytes_written; s2m_DOC doc = s2m_DOC_init_zero; - uint8_t doc_buf[s2m_DOC_size]; - doc.DOC_code = 5; - doc.tx_length = data_enc_size; - pb_ostream_t doc_ostream = pb_ostream_from_buffer(doc_buf, 4); - - if (!pb_encode(&doc_ostream, s2m_DOC_fields, &doc)) { - sprintf((char*)debug_buf, "DOC encoding error\r\n"); - HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); - memset(debug_buf, 0, 128); - continue; - } - - sprintf((char*)debug_buf, "s2m_DOC encoded length: %d\r\n", doc_ostream.bytes_written); - HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); - memset(debug_buf, 0, 128); + uint8_t doc_buf[4] = {0x0, 0x5, 0x0, data_enc_size}; if (HAL_I2C_Slave_Transmit(&hi2c1, (uint8_t*)doc_buf, 4, 10000) != HAL_OK) { sprintf((char*)debug_buf, "DOC I2C send error: %ld\r\n", HAL_I2C_GetError(&hi2c1)); @@ -174,7 +147,7 @@ int main(void) memset(debug_buf, 0, 128); } } - else if (SOR_message.SOR_code == 2) { + else if (SOR_buf[0] == 2) { uint8_t CTS_buf[] = {0x0, 0x1}; uint8_t len_buf[4], *MDR_buf, *data_buf; /* _datapoint datapoints[16]; */ -- cgit v1.2.3 From a466dbd8d310d5c01a104b0956a0a03ef8560c75 Mon Sep 17 00:00:00 2001 From: Aditya Naik Date: Fri, 5 Jun 2020 15:39:00 -0400 Subject: Debugged DF DOC/CTS errors --- src/dataflow.h | 2 +- src/main-master.c | 64 +++++++++++++++++++++---------------------------------- src/main-slave.c | 16 ++++++-------- 3 files changed, 31 insertions(+), 51 deletions(-) diff --git a/src/dataflow.h b/src/dataflow.h index a2217ca..d39126e 100644 --- a/src/dataflow.h +++ b/src/dataflow.h @@ -42,5 +42,5 @@ typedef enum DOC_codes { CMD_MULTICAST = 2, CMD_BROADCAST = 3, RESERVED = 4, - DATA = 5 + DATA = 0x5 } DOC_codes_t; diff --git a/src/main-master.c b/src/main-master.c index e4a8fd4..2b47020 100644 --- a/src/main-master.c +++ b/src/main-master.c @@ -33,7 +33,7 @@ #define COUNTOF(__BUFFER__) (sizeof(__BUFFER__) / sizeof(*(__BUFFER__))) /* #define I2C_ADDRESS 0x05 */ -#define BUS_DEVICE_LIMIT 16 +#define BUS_DEVICE_LIMIT 5 /* Macro to toggle between master and slave firmware */ #define MASTER @@ -105,7 +105,8 @@ int main(void) while (1) { if (priority_counter == 0) { hs_status_t hs_status; - for (uint8_t curr_addr=1; curr_addr <= BUS_DEVICE_LIMIT; curr_addr++) { + for (uint8_t curr_addr=5; curr_addr == 5; curr_addr++) { + /* for (uint8_t curr_addr=1; curr_addr <= BUS_DEVICE_LIMIT; curr_addr++) { */ if (todo_hs_or_not_todo_hs(curr_addr)) { hs_status = handshake(curr_addr); dev_sts[GET_IDX_FROM_ADDR(curr_addr)] = get_state_from_hs_status(curr_addr, hs_status); @@ -117,7 +118,7 @@ int main(void) routing(); } else { - for (int device_idx = 0; device_idx < BUS_DEVICE_LIMIT; device_idx++) { + for (int device_idx = 4; device_idx ==4; device_idx++) { if (dev_sts[device_idx] == REGISTERED) { device_dataflow(GET_ADDR_FROM_IDX(device_idx), SLAVE_TX, 0); } @@ -204,7 +205,7 @@ hs_status_t handshake(uint32_t i2c_addr) } case (HS_MDR_CTS): { - uint8_t MDR_CTS_buf[2] = {0x0, 0x02}; + uint8_t MDR_CTS_buf[2] = {0x0, 0x02}; if (HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)i2c_addr, MDR_CTS_buf, 2, 10000) != HAL_OK) { hs_sts = HS_FAILED; #ifdef DEBUG_ENABLE @@ -339,15 +340,15 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r { uint8_t dev_idx = GET_IDX_FROM_ADDR(i2c_addr); dataflow_status_t df_status = DF_IDLE; - - uint8_t *CTS_buf, *data_buf; + + uint8_t DOC_buf[4]; + uint8_t *data_buf; uint32_t AF_error_counter = 0; uint32_t data_len = 0; _datapoint datapoints[16]; s2m_DOC DOC_message = s2m_DOC_init_zero; /* TODO Add default values to the CTS message in proto */ - m2s_CTS CTS_message = m2s_CTS_init_default; s2m_data data_message = s2m_data_init_zero; #if defined(TESTING_ENABLE) || defined(DEBUG_ENABLE) uint8_t debug_buf[128]; @@ -362,7 +363,7 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r { /* HAL_Delay(MASTER_I2C_BUS_INTERVAL); */ uint8_t SOR_buf[2] = {SOR_code, 0x0}; - if (HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)i2c_addr, SOR_buf, 2, 10000) != HAL_OK) { + if (HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)i2c_addr, SOR_buf, 2, 1000) != HAL_OK) { df_status = DF_FAIL; #ifdef DEBUG_ENABLE goto __DF_SOR_I2C_ERROR; @@ -389,10 +390,9 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r case (DF_RX_DOC): { HAL_Delay(MASTER_I2C_BUS_INTERVAL); - uint8_t DOC_buf[4]; AF_error_counter = 0; while (HAL_I2C_Master_Receive(&hi2c1, (uint16_t)i2c_addr, - (uint8_t*)DOC_buf, 4, 1000) != HAL_OK) { + (uint8_t*)DOC_buf, 4, 10000) != HAL_OK) { if (HAL_I2C_GetError(&hi2c1) != HAL_I2C_ERROR_AF) { df_status = DF_FAIL; #ifdef DEBUG_ENABLE @@ -407,7 +407,7 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r break; } } - if (df_status != DF_FAIL) { + if (df_status != DF_FAIL) { if (DOC_buf[1] == DATA) { df_status = DF_CTS; data_len = DOC_buf[3]; @@ -426,44 +426,33 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r } case (DF_CTS): { - HAL_Delay(MASTER_I2C_BUS_INTERVAL); - CTS_buf = (uint8_t*)malloc(8); - pb_ostream_t CTS_ostream = pb_ostream_from_buffer(CTS_buf, 8); - CTS_message.timeout = 100; - - if (!pb_encode(&CTS_ostream, m2s_CTS_fields, &CTS_message)) { + /* HAL_Delay(MASTER_I2C_BUS_INTERVAL); */ + uint8_t CTS_buf[2] = {0x2, 0xFF}; + if (HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)i2c_addr, CTS_buf, 2, 10000) != HAL_OK) { df_status = DF_FAIL; #ifdef DEBUG_ENABLE - goto __DF_CTS_ENC_FAIL; - __DF_CTS_ENC_FAIL_END: + goto __DF_CTS_I2C_ERROR; + __DF_CTS_I2C_ERROR_END: __asm__("nop"); #endif } else { - HAL_Delay(MASTER_I2C_BUS_INTERVAL); - if (HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)i2c_addr, (uint8_t*)CTS_buf, - 2, 10000) != HAL_OK) { - df_status = DF_FAIL; -#ifdef DEBUG_ENABLE - goto __DF_CTS_I2C_ERROR; - __DF_CTS_I2C_ERROR_END: - __asm__("nop"); -#endif + if (DOC_buf[1] == DATA) { + df_status = DF_RX_DATA; } else { - if (DOC_message.DOC_code == DATA) { - df_status = DF_RX_DATA; - } - else { - /* TODO */ - } + /* TODO RX CMD stuff */ } } break; } case (DF_RX_DATA): { - HAL_Delay(MASTER_I2C_BUS_INTERVAL); + /* HAL_Delay(MASTER_I2C_BUS_INTERVAL); */ + sprintf((char*)debug_buf, "data len: %ld\r\n", data_len); + HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); + memset(debug_buf, 0, 128); + data_buf = (uint8_t*)malloc(128); AF_error_counter = 0; while (HAL_I2C_Master_Receive(&hi2c1, (uint16_t)i2c_addr, @@ -636,11 +625,6 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); memset(debug_buf, 0, 128); goto __DF_DOC_I2C_ERROR_END; - __DF_CTS_ENC_FAIL: - sprintf((char*)debug_buf, "CTS encoding error\r\n"); - HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); - memset(debug_buf, 0, 128); - goto __DF_CTS_ENC_FAIL_END; __DF_CTS_I2C_ERROR: sprintf((char*)debug_buf, "CTS I2C error: %ld\r\n", HAL_I2C_GetError(&hi2c1)); HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); diff --git a/src/main-slave.c b/src/main-slave.c index 39d31bb..7476436 100644 --- a/src/main-slave.c +++ b/src/main-slave.c @@ -80,7 +80,7 @@ int main(void) HAL_Delay(1000); while (1) { - if (HAL_I2C_Slave_Receive(&hi2c1, (uint8_t*)SOR_buf, 2, 500) != HAL_OK) { + if (HAL_I2C_Slave_Receive(&hi2c1, (uint8_t*)SOR_buf, 2, 10000) != HAL_OK) { sprintf((char*)debug_buf, "Failed to get SOR\r\n"); HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); memset(debug_buf, 0, 128); @@ -104,11 +104,8 @@ int main(void) memset(debug_buf, 0, 128); continue; } - data_enc_size = data_ostream.bytes_written; - - s2m_DOC doc = s2m_DOC_init_zero; + data_enc_size = data_ostream.bytes_written; uint8_t doc_buf[4] = {0x0, 0x5, 0x0, data_enc_size}; - if (HAL_I2C_Slave_Transmit(&hi2c1, (uint8_t*)doc_buf, 4, 10000) != HAL_OK) { sprintf((char*)debug_buf, "DOC I2C send error: %ld\r\n", HAL_I2C_GetError(&hi2c1)); HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); @@ -121,21 +118,20 @@ int main(void) memset(debug_buf, 0, 128); } - uint8_t CTS_buf[8]; - - if (HAL_I2C_Slave_Receive(&hi2c1, (uint8_t*)CTS_buf, 2, 10000) != HAL_OK) { + uint8_t CTS_buf[2] = {0x0, 0x0}; + if (HAL_I2C_Slave_Receive(&hi2c1, (uint8_t*)CTS_buf, 2, 100000) != HAL_OK) { sprintf((char*)debug_buf, "Failed to get CTS: %ld\r\n", HAL_I2C_GetError(&hi2c1)); HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); memset(debug_buf, 0, 128); continue; } else { - sprintf((char*)debug_buf, "Got CTS\r\n"); + sprintf((char*)debug_buf, "Got CTS: %d\r\n", CTS_buf[0]); HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); memset(debug_buf, 0, 128); } - if (HAL_I2C_Slave_Transmit(&hi2c1, (uint8_t*)data_buf, data_enc_size, 10000) != HAL_OK) { + if (HAL_I2C_Slave_Transmit(&hi2c1, (uint8_t*)data_buf, data_enc_size, 100000) != HAL_OK) { sprintf((char*)debug_buf, "Data I2C send error: %ld\r\n", HAL_I2C_GetError(&hi2c1)); HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); memset(debug_buf, 0, 128); -- cgit v1.2.3 From 564b43443f31affe87b2b20f5c36a626a369e4a9 Mon Sep 17 00:00:00 2001 From: Aditya Naik Date: Mon, 8 Jun 2020 14:32:21 -0400 Subject: Addressing changes --- src/main-master.c | 28 ++++++++++++++++------------ src/main-slave.c | 11 ++++++----- 2 files changed, 22 insertions(+), 17 deletions(-) diff --git a/src/main-master.c b/src/main-master.c index 2b47020..d77cc20 100644 --- a/src/main-master.c +++ b/src/main-master.c @@ -26,14 +26,14 @@ /* Private Macros */ #define device_MDR s2m_MDR_response -#define GET_IDX_FROM_ADDR(i2c_addr) i2c_addr-1 -#define GET_ADDR_FROM_IDX(idx) idx+1 +#define GET_IDX_FROM_ADDR(i2c_addr) (i2c_addr>>1)-1 +#define GET_ADDR_FROM_IDX(idx) (idx+1)<<1 #define GET_BIT_FROM_IDX(a, b) a[b>>5]&(1<<(b%32)) #define SET_BIT_FROM_IDX(a, b) a[b>>5]|=(1<<(b%32)) #define COUNTOF(__BUFFER__) (sizeof(__BUFFER__) / sizeof(*(__BUFFER__))) /* #define I2C_ADDRESS 0x05 */ -#define BUS_DEVICE_LIMIT 5 +#define BUS_DEVICE_LIMIT 16 /* Macro to toggle between master and slave firmware */ #define MASTER @@ -105,8 +105,8 @@ int main(void) while (1) { if (priority_counter == 0) { hs_status_t hs_status; - for (uint8_t curr_addr=5; curr_addr == 5; curr_addr++) { - /* for (uint8_t curr_addr=1; curr_addr <= BUS_DEVICE_LIMIT; curr_addr++) { */ + /* for (uint8_t curr_addr=5; curr_addr == 5; curr_addr++) { */ + for (uint8_t curr_addr=0x1; curr_addr <= BUS_DEVICE_LIMIT; curr_addr++) { if (todo_hs_or_not_todo_hs(curr_addr)) { hs_status = handshake(curr_addr); dev_sts[GET_IDX_FROM_ADDR(curr_addr)] = get_state_from_hs_status(curr_addr, hs_status); @@ -118,7 +118,7 @@ int main(void) routing(); } else { - for (int device_idx = 4; device_idx ==4; device_idx++) { + for (int device_idx = 0; device_idx < BUS_DEVICE_LIMIT-1; device_idx++) { if (dev_sts[device_idx] == REGISTERED) { device_dataflow(GET_ADDR_FROM_IDX(device_idx), SLAVE_TX, 0); } @@ -304,7 +304,7 @@ __TESTING_BLOCK_END: { goto __DEBUG_BLOCK_END; __HS_MDR_REQ_I2C_ERROR: - sprintf((char*)debug_buf, "Unable to send MDR request. I2C error: %ld\r\n", HAL_I2C_GetError(&hi2c1)); + sprintf((char*)debug_buf, "Unable to send MDR request to %lx. I2C error: %ld\r\n", i2c_addr, HAL_I2C_GetError(&hi2c1)); HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); memset(debug_buf, 0, 128); goto __HS_MDR_REQ_I2C_ERROR_END; @@ -361,9 +361,9 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r switch (df_status) { case (DF_IDLE): { - /* HAL_Delay(MASTER_I2C_BUS_INTERVAL); */ + HAL_Delay(MASTER_I2C_BUS_INTERVAL); uint8_t SOR_buf[2] = {SOR_code, 0x0}; - if (HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)i2c_addr, SOR_buf, 2, 1000) != HAL_OK) { + if (HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)i2c_addr, SOR_buf, 2, 500) != HAL_OK) { df_status = DF_FAIL; #ifdef DEBUG_ENABLE goto __DF_SOR_I2C_ERROR; @@ -421,12 +421,15 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r else if (DOC_message.DOC_code == CMD_BROADCAST) { /* TODO */ } + else { + df_status = DF_FAIL; + } } break; } case (DF_CTS): { - /* HAL_Delay(MASTER_I2C_BUS_INTERVAL); */ + HAL_Delay(MASTER_I2C_BUS_INTERVAL); uint8_t CTS_buf[2] = {0x2, 0xFF}; if (HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)i2c_addr, CTS_buf, 2, 10000) != HAL_OK) { df_status = DF_FAIL; @@ -448,7 +451,7 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r } case (DF_RX_DATA): { - /* HAL_Delay(MASTER_I2C_BUS_INTERVAL); */ + HAL_Delay(MASTER_I2C_BUS_INTERVAL); sprintf((char*)debug_buf, "data len: %ld\r\n", data_len); HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); memset(debug_buf, 0, 128); @@ -726,7 +729,7 @@ bool todo_hs_or_not_todo_hs(uint8_t i2c_addr) case NO_HS: case CONNECTED: case FAILED: - case OFFLINE: + case OFFLINE: do_hs = true; break; case REGISTERED: @@ -893,6 +896,7 @@ static void MX_I2C1_Init(void) hi2c1.Init.OwnAddress2 = 0xFF; hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE; hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE; + /* hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_ENABLE; */ if (HAL_I2C_Init(&hi2c1) != HAL_OK) { Error_Handler(); diff --git a/src/main-slave.c b/src/main-slave.c index 7476436..e2364e3 100644 --- a/src/main-slave.c +++ b/src/main-slave.c @@ -32,7 +32,7 @@ #define SET_BIT_FROM_IDX(a, b) a[b>>5]|=(1<<(b%32)) #define COUNTOF(__BUFFER__) (sizeof(__BUFFER__) / sizeof(*(__BUFFER__))) -#define I2C_ADDRESS 0x05 +#define I2C_ADDRESS 0x05<<1 #define BUS_DEVICE_LIMIT 128 /* Macro to toggle between master and slave firmware */ @@ -80,7 +80,7 @@ int main(void) HAL_Delay(1000); while (1) { - if (HAL_I2C_Slave_Receive(&hi2c1, (uint8_t*)SOR_buf, 2, 10000) != HAL_OK) { + if (HAL_I2C_Slave_Receive(&hi2c1, (uint8_t*)SOR_buf, 2, 500) != HAL_OK) { sprintf((char*)debug_buf, "Failed to get SOR\r\n"); HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); memset(debug_buf, 0, 128); @@ -119,7 +119,7 @@ int main(void) } uint8_t CTS_buf[2] = {0x0, 0x0}; - if (HAL_I2C_Slave_Receive(&hi2c1, (uint8_t*)CTS_buf, 2, 100000) != HAL_OK) { + if (HAL_I2C_Slave_Receive(&hi2c1, (uint8_t*)CTS_buf, 2, 10000) != HAL_OK) { sprintf((char*)debug_buf, "Failed to get CTS: %ld\r\n", HAL_I2C_GetError(&hi2c1)); HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); memset(debug_buf, 0, 128); @@ -131,7 +131,7 @@ int main(void) memset(debug_buf, 0, 128); } - if (HAL_I2C_Slave_Transmit(&hi2c1, (uint8_t*)data_buf, data_enc_size, 100000) != HAL_OK) { + if (HAL_I2C_Slave_Transmit(&hi2c1, (uint8_t*)data_buf, data_enc_size, 10000) != HAL_OK) { sprintf((char*)debug_buf, "Data I2C send error: %ld\r\n", HAL_I2C_GetError(&hi2c1)); HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); memset(debug_buf, 0, 128); @@ -163,7 +163,7 @@ int main(void) sprintf((char*)debug_buf, "Got lengths. MDR: %d, data: %d\r\n", MDR_len, data_len); HAL_UART_Transmit(&huart1, debug_buf, sizeof(debug_buf), 100); memset(debug_buf, 0, 128); - + HAL_I2C_Slave_Transmit(&hi2c1, CTS_buf, 2, 10000); HAL_I2C_Slave_Receive(&hi2c1, MDR_buf, MDR_len, 10000); HAL_I2C_Slave_Receive(&hi2c1, data_buf, data_len, 10000); @@ -373,6 +373,7 @@ static void MX_I2C1_Init(void) hi2c1.Init.OwnAddress2 = 0xFF; hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE; hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE; + /* hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_ENABLE; */ if (HAL_I2C_Init(&hi2c1) != HAL_OK) { Error_Handler(); -- cgit v1.2.3 From c74e98439abffb40270f5708b300c7b74c153d73 Mon Sep 17 00:00:00 2001 From: Aditya Naik Date: Mon, 8 Jun 2020 14:56:45 -0400 Subject: Dataflow DF_RX_DOC changes --- src/main-master.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main-master.c b/src/main-master.c index d77cc20..c6b0858 100644 --- a/src/main-master.c +++ b/src/main-master.c @@ -412,13 +412,13 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r df_status = DF_CTS; data_len = DOC_buf[3]; } - else if (DOC_message.DOC_code == CMD_UNICAST) { + else if (DOC_buf[1] == CMD_UNICAST) { /* TODO */ } - else if (DOC_message.DOC_code == CMD_MULTICAST) { + else if (DOC_buf[1] == CMD_MULTICAST) { /* TODO */ } - else if (DOC_message.DOC_code == CMD_BROADCAST) { + else if (DOC_buf[1] == CMD_BROADCAST) { /* TODO */ } else { -- cgit v1.2.3 From 6ba734f12032319cdaf892646e9f76ea9cbd4a79 Mon Sep 17 00:00:00 2001 From: Aditya Naik Date: Mon, 8 Jun 2020 15:25:19 -0400 Subject: Master changes and TODO --- src/devices.h | 3 ++- src/main-master.c | 1 - 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/devices.h b/src/devices.h index ef4e65b..b2cb825 100644 --- a/src/devices.h +++ b/src/devices.h @@ -12,12 +12,13 @@ typedef struct _device_info { uint32_t subscriptions[4]; /* Subscriptions by this device */ } device_info_t; +/* TODO These IDs could be represented as a single 8-bit integer */ typedef struct _subscription_info { uint8_t module_ids[128]; uint8_t entity_ids[128]; uint8_t module_class[3]; uint8_t i2c_address[128]; - uint8_t mod_idx, entity_idx, class_idx, i2c_idx; + uint8_t mod_idx, entity_idx, class_idx, i2c_idx; } subscription_info_t; typedef enum hs_status { diff --git a/src/main-master.c b/src/main-master.c index c6b0858..f4b1fe2 100644 --- a/src/main-master.c +++ b/src/main-master.c @@ -347,7 +347,6 @@ dataflow_status_t device_dataflow(uint8_t i2c_addr, uint32_t SOR_code, uint8_t r uint32_t data_len = 0; _datapoint datapoints[16]; - s2m_DOC DOC_message = s2m_DOC_init_zero; /* TODO Add default values to the CTS message in proto */ s2m_data data_message = s2m_data_init_zero; #if defined(TESTING_ENABLE) || defined(DEBUG_ENABLE) -- cgit v1.2.3 From 505fafe99b734fe35d5e6958de7fd73eb088777d Mon Sep 17 00:00:00 2001 From: Aditya Naik Date: Mon, 8 Jun 2020 17:39:17 -0400 Subject: Routing bugfix --- src/main-master.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main-master.c b/src/main-master.c index f4b1fe2..c627a45 100644 --- a/src/main-master.c +++ b/src/main-master.c @@ -657,15 +657,15 @@ bool routing(void) /* Build table with routing information */ for (uint8_t rbuf_data_idx = 0; rbuf_data_idx < routing_ptr; rbuf_data_idx++) { - uint8_t module_idx = routing_idx_buffer[rbuf_data_idx]; + uint8_t src_module_idx = routing_idx_buffer[rbuf_data_idx]; for (uint8_t dev_idx = 0; dev_idx < BUS_DEVICE_LIMIT; dev_idx++) { if (!(GET_BIT_FROM_IDX(allocated, dev_idx)&&1)) { // No module at this index continue; } bool alloc = false; for (uint8_t dev_sub_idx = 0; dev_sub_idx < subs_info[dev_idx]->mod_idx && !alloc; dev_sub_idx++) { - if (subs_info[dev_idx]->module_ids[dev_sub_idx] == device_info[module_idx]->MDR.module_id) { - SET_BIT_FROM_IDX(routing_table[rbuf_data_idx], module_idx); + if (subs_info[dev_idx]->module_ids[dev_sub_idx] == device_info[src_module_idx]->MDR.module_id) { + SET_BIT_FROM_IDX(routing_table[rbuf_data_idx], dev_idx); alloc = true; } } -- cgit v1.2.3