MB_PORT_COMMON: vMBMasterRunResRelease(194): Resource release failure.

[jbsaibes]

hi @alisitsyn

I read all your posts concerning the above subject, i tried all patches and fixes and i am still getting the same issue.

my application includes 3 modbus sensors, one is on parity of even and can not be changed , the other two are on parity none.

in my code i am switching between parities on different sensors. everything works fine until one of the sensors times out or is off for some reason.

i read the post Modbus in Master Mode crashes (IDFGH-3047) #5072 in details. i simulated my application when i siimulate a timeout error > timeout to wait for receive from slave. i get the above error.

can you please assist .

i am using the following:

Environment
Development Kit: [M5stack Switch]
Module or chip used: [ESP32-PICO]
IDF version: [v4.4-dev-8-ge80a8735f6-dirty]
Build System: [CMake]
Compiler version: [xtensa-esp32-elf-gcc]
Operating System: [Windows]
(Windows only) environment type: [|ESP Command Prompt].
Using an IDE?: [Visual Studio Code]
Power Supply: [USB]

Code
void modbus(void *parameters)
{

 cJSON *tempreading=NULL;
  char *outter = NULL;

ESP_LOGI(SystemTag,"Modbus Task Fired!");
ESP_LOGI(SystemTag,"Initiate Modbus");

modbus_initialize();
vTaskDelay(pdMS_TO_TICKS(1000));

ESP_LOGI(SystemTag,"Modbus Initialized");
// u8g2_ClearBuffer(&u8g2);
// u8g2_SetFont(&u8g2, u8g2_font_synchronizer_nbp_tf );
// u8g2_DrawStr(&u8g2, 0,7,"Stack Remaining: ");
// u8g2_SendBuffer(&u8g2);

parsed = initialize_cjsons();

mb_parameter_descriptor_t *add[3];

add[0] = device_parameters1;
add[1] = device_parameters2;
add[2] = device_parameters3;

esp_err_t err = ESP_OK;
//float value = 0;
//bool alarm_state = false;
const mb_parameter_descriptor_t *param_descriptor = NULL;

//
#if oled
ESP_LOGI(MASTER_TAG, "Start modbus test...");
u8g2_ClearBuffer(&u8g2);
u8g2_SetFont(&u8g2, u8g2_font_synchronizer_nbp_tf);
u8g2_DrawStr(&u8g2, 0, 17, "Modbus mb test!");
u8g2_SendBuffer(&u8g2);
#endif

//  printf("total CIDS is %d \n",num_device_parameters);


// vTaskDelay(pdMS_TO_TICKS(1000));
uint16_t num_device_parameters[3];
num_device_parameters[0] = (sizeof(device_parameters1) / sizeof(device_parameters1[0]));
num_device_parameters[1] = (sizeof(device_parameters2) / sizeof(device_parameters2[0]));
num_device_parameters[2] = (sizeof(device_parameters3) / sizeof(device_parameters3[0]));

char cidstr[16];

while(true)
{

for(int i = 0; i < 3/MASTER_MAX_RETRY/ ; i++)

{

// change parity
if (i==0)
{
uart_set_parity(1,UART_PARITY_EVEN);
}
else
{
uart_set_parity(1,UART_PARITY_DISABLE);
}

    vTaskDelay(pdMS_TO_TICKS(100));
    #if oled
    u8g2_ClearBuffer(&u8g2);
    u8g2_SetFont(&u8g2, u8g2_font_synchronizer_nbp_tf    );
 	u8g2_DrawStr(&u8g2, 0,17,"Loop IN!");
	u8g2_SendBuffer(&u8g2);
    #endif
    //set desciptor table for sensor
    err = mbc_master_set_descriptor(add[i], num_device_parameters[i]);

    MASTER_CHECK((err == ESP_OK), ESP_ERR_INVALID_STATE,
                                "mb controller set descriptor fail, returns(0x%x).",
                                (uint32_t)err);
    // ESP_LOGI(MASTER_TAG, "Modbus master stack initialized...");
    // return err;

    // Read all found characteristics from slave(s)
    for (uint16_t cid = 0; (err != ESP_ERR_NOT_FOUND) && cid < (num_device_parameters[i]); cid++)
    {   
      //  ESP_LOGI(MASTER_TAG, "CID#%d:",cid);
      
        #if oled
         u8g2_ClearBuffer(&u8g2);
        u8g2_SetFont(&u8g2, u8g2_font_synchronizer_nbp_tf    );
        u8g2_DrawStr(&u8g2, 0,17,"CID IN!");
        u8g2_SendBuffer(&u8g2);
        #endif
        // Get data from parameters description table
        // and use this information to fill the characteristics description table
        // and having all required fields in just one table
        err = mbc_master_get_cid_info(cid, &param_descriptor);
        if ((err != ESP_ERR_NOT_FOUND) && (param_descriptor != NULL))
        {
            void *temp_data_ptr = master_get_param_data(param_descriptor);

            assert(temp_data_ptr);
            uint8_t type = 0;

            // if ((param_descriptor->cid == CID_INP_DATA_2)||(param_descriptor->cid == CID_INP_DATA_2)||(param_descriptor->cid == CID_INP_DATA_3)||(param_descriptor->cid == CID_INP_DATA_4)||(param_descriptor->cid == CID_INP_DATA_5))
            //   {
                #if oled
                u8g2_ClearBuffer(&u8g2);
            u8g2_SetFont(&u8g2, u8g2_font_synchronizer_nbp_tf    );
            sprintf(cidstr,"cid#%d %s",cid,(char *)param_descriptor->param_key);
             u8g2_DrawStr(&u8g2, 0,17,cidstr);
             u8g2_SendBuffer(&u8g2);
             #endif
             
            err = mbc_master_get_parameter(cid, (char *)param_descriptor->param_key,
                                           (uint8_t *)temp_data_ptr, &type);
             
            if (err == ESP_OK)
            { 
                #if oled
                                u8g2_ClearBuffer(&u8g2);
                            
                            u8g2_DrawStr(&u8g2, 0,17,"esp_ok");
                            u8g2_SendBuffer(&u8g2);
                            vTaskDelay(pdMS_TO_TICKS(200));
                            #endif
                float result = 0;

               switch(param_descriptor->param_size)
                        {
                            case (PARAM_SIZE_U32|PARAM_SIZE_FLOAT):
                            // the processor is low endian so we have to swap bytes, then multiply result by divisor
                            //printf("swapping is %x %d\n",swap_int32(((uint32_t*)temp_data_ptr)),param_descriptor->param_opts.opt1);
                            
                           { 
                           if (param_descriptor->param_type==PARAM_TYPE_U32)
                           {
                            result=(double)swap_int32(((uint32_t*)temp_data_ptr))/(param_descriptor->param_opts.opt1); 
                           // printf("result is %f\n",result);
                           }
                            else
                            {
                            uint32_t *pnum=NULL;
                            uint32_t num=swap_int32(((uint32_t*)temp_data_ptr));
                            pnum=&num;
                            
                            result=convert2float(pnum)/(param_descriptor->param_opts.opt1);
                           // printf("float raw value is %0f\n",result);
                           #if oled
                                            u8g2_ClearBuffer(&u8g2);
                            u8g2_SetFont(&u8g2, u8g2_font_synchronizer_nbp_tf    );
                            sprintf(cidstr,"%s is %f",(char *)param_descriptor->param_key,result);
                            u8g2_DrawStr(&u8g2, 0,17,cidstr);
                            u8g2_SendBuffer(&u8g2);
                            #endif
                                
                            }
                           }
                            break;

                            case (PARAM_SIZE_U64):
                            result=(double)swap_int64((uint32_t*)temp_data_ptr)/(param_descriptor->param_opts.opt1);
                            break;

                            case (PARAM_SIZE_U48):
                          //   printf("swap 4 result 1: %0llX  \n", swap_int48((uint16_t*)temp_data_ptr));//,*((uint16_t*)(temp_data_ptr+1)),*((uint16_t*)(temp_data_ptr+2)));
                             result=(double)swap_int48((uint16_t*)temp_data_ptr)/(param_descriptor->param_opts.opt1);
                            break;
                            

                            default: 
                            result=(double)(*(uint16_t*)temp_data_ptr) / (param_descriptor->param_opts.opt1);
                            break;
                        }
                #if 0
                ESP_LOGI(MASTER_TAG, "fuck characeristic #%d %s (%s) (%d) value =  (%.3f) read successful.",
                         param_descriptor->cid,
                         (char *)param_descriptor->param_key,
                         (char *)param_descriptor->param_units,
                         param_descriptor->param_size,
                         result);
               #endif
               
                tempreading = cJSON_GetObjectItemCaseSensitive(&parsed[i], param_descriptor->param_key);
                //    cJSON *tempreading = cJSON_GetObjectItemCaseSensitive(roots, list[i]);
              
           //  vTaskDelay(pdMS_TO_TICKS(500));
                cJSON_SetNumberValue(tempreading, result);

                // ESP_LOGE(MASTER_TAG, "Characteristic #%d (%s) read fail, err = 0x%x (%s).",
                //                     param_descriptor->cid,
                //                     (char*)param_descriptor->param_key,
                //                     (int)err,
                //                     (char*)esp_err_to_name(err));
            }

            else

            {   
                #if  oled   
                
                u8g2_ClearBuffer(&u8g2);
                            
                            u8g2_DrawStr(&u8g2, 0,17,"esp_not_ok");
                            u8g2_SendBuffer(&u8g2);
                            vTaskDelay(pdMS_TO_TICKS(200));
                            #endif
            }
            //  }
            vTaskDelay(POLL_TIMEOUT_TICS); // timeout between polls
        }
    }
    
    //jsonarray[i]=*parsed[i];
   //  outter = cJSON_Print(&parsed[i]);
    // //  cJSON_Delete(roots);
  //   printf(outter);
    vTaskDelay(UPDATE_CIDS_TIMEOUT_TICS); //
}

[alisitsyn]

Hi @jbsaibes,

Thank you for the question. The scenario in which you are using ESP-Modbus I would say is very specific and is not supported.

1. You are changing the parity of UART on the fly. This may work in some cases but is not guarantee correct functionality and may cause the issues while receiving UART data.

• Read the last characteristic from first sensor and send Modbus corresponding request.
• Modbus FSM gets RESPONSE TIMEOUT event because the slave does not send response during configured timeout;
• The app reinitializes the UART parity option. The UART peripheral is still active and can start to process some data (it may be delayed response of slave). Reactivation of parity option on the fly causes the receive error. The transaction is completed because of timeout but the data is received outside of transaction and FSM starts EV_MASTER_ERROR_PROCESS and tries to release run sema vMBMasterRunResRelease() which is free. This causes the error above.

2. In the original approach of ESP_Modbus is supposed to have one Data Dictionary with the characteristics for all slaves and set it during initialization of the master stack.

I will try to check this tomorrow and will give you my recommendations on how to repair from fail as soon as I have them.

[jbsaibes]

thanks for your reply.
I know its an uncomon modbus settings, but the hardware used we can not change the parity.
I have updated the freemodbus folder to the latest files you posted on esp-idf and increased timeout to 1000ms and run a simulation.
Everything seems to work fine, it has been 24 hrs testing with one physical meter (parity even) and two other simulated meters(parity none).
In the modbus simulator,I can inject errors, time outs, no response,etc... so far everything is working fine. i have to test it on the ground now.
Let me know if yuo have any thoughts, or if anything could pop up.
P.s: i tried injecting timeouts of >1000ms from the slaves and there were no errors.

[alisitsyn]

@jbsaibes,

Thank you for shared results.

1. I would recommend also to increase timeouts between requests. This will give to the FSM additional chance to repair from failure because the Modbus task is unblocked after exactly FMB_MASTER_TIMEOUT_MS_RESPOND timeout but FSM can delay release of run semaphore in some unexpected conditions. The Resource release failure just tells you that the semaphore is free but you try to release it again. This can be due to response delayed due to your injected errors during simulation.

2. If you receive the data with error ESP_ERR_INVALID_RESPONSE, please try to retry the request again.

Unfortunately the Modbus serial does not have any good opportunity to reliably recover from errors when responses after timeout are received. The specification treat this situation as unusual.

I am working on new release of ESP_Modbus that should be more reliable in some unexpected conditions.

Good luck! Let me know if you need help or some results in your project. I will try to give you support as soon as I can.

[jbsaibes]

@alisitsyn

1. I will add the timeout between requests and tested on the field after monitoring the simulated results
2. noted i will try it out

i will keep you posted and thanks for the support.

[alisitsyn]

@jbsaibes,

This answer is too late but just in case please update the component to the latest version. I guess the issues are fixed long time ago.

1. The related issue for master to use different communication options for each slave may partly address the issue with the parity.
2. The extended data types feature may help to work with the slave which use different endianness options.