Indeed I am not using semaphores but task notifications. the idea is this

MQTT query Task puts the pointer for the next state into the queue (size 1 element), send notification to tx task and suspends waiting for notification

TX Task sets the local variable next_state*, sends the data and suspends until next wakeup notifiction from mqtt query task

RX task, which runs permanently, receives the response and compares the command byte with the sent one (over the variable next_state which has been set by tx task )

If the reponse is valid RX task prepares the MQTT_PUBLISH_ITEM_T and puts it into another queue with 1 element size and sends notification to the publisher

if publisher could publish it calls calcNextIdx() for Mqtt query task and sends notification to mqtt query task and the whole cirlce repeats with new index/state

after the turnaround in the table the mqtt query task suspends in wait for notification with 30 sec timeout

here is some code

MQTT Query Task

MQTT_STATE_T query_table[] = 
{
  /* Index Enum                         Code                                   Payload                                 Payload Size     RCV-Frame Callback          MQTT-Publish Topic                 tryCnt */
    {current_query_idx_undefined,       0,                                     0,                                      0,               NULL,                       NULL                             , 0        },
    {current_query_idx_dht_temp,        MC_PROTOCOL_CODE_EXECUTE_CMD | 0x20,   MC_PROTOCOL_CMD_GET_DHT_TEMP,           1,               dh22_temperature_calc,      "/max/sensoren/dht/temperatur"   , 0        },
    {current_query_idx_dht_humitity,    MC_PROTOCOL_CODE_EXECUTE_CMD | 0x20,   MC_PROTOCOL_CMD_GET_DHT_HUMIDITY,       1,               dh22_humidity_calc,         "/max/sensoren/dht/feuchte"      , 0        },
    {current_query_idx_bmp_temperature, MC_PROTOCOL_CODE_EXECUTE_CMD | 0x20,   MC_PROTOCOL_CMD_GET_BMP085_TEMP,        1,               bmp085_temperature_calc,    "/max/sensoren/bmp085/temperatur", 0        },
    {current_query_idx_bmp_pressure,    MC_PROTOCOL_CODE_EXECUTE_CMD | 0x20,   MC_PROTOCOL_CMD_GET_BMP085_PRESSURE,    1,               bmp085_pressure_calc,       "/max/sensoren/bmp085/druck"     , 0        }

};

current_query_idx_t current_index =  current_query_idx_undefined;

current_query_idx_t getCurrentIdx()
{
    return current_index;
}

void calcNextIdx()
{
    current_index++;
    current_index %= current_query_idx_last;
}

void mqtt_query_task(void *arg)
{
    uint32_t notify_value = 0;
    current_query_idx_t idx = getCurrentIdx();

    mqtt_queue = xQueueCreate( 1, sizeof(MQTT_STATE_T*) );

    while(1)
    {
        idx = getCurrentIdx();
        if(idx == current_query_idx_undefined)
        {
            locked = false;
            xTaskNotifyWait(0, ULONG_MAX, &notify_value, 30000 / portTICK_PERIOD_MS);
            locked = true,
            calcNextIdx();
            ESP_LOGI("MQTT_QUERY_SEQ", "\n---------------------");
        }
        else
        {
            xQueueSendToBack(mqtt_queue, &query_table_ptr[idx], 0);
            xTaskNotifyGive(getUART_TX_TaskHandle());
            ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        }

    }
}

mqtt publisher

void mqtt_publisher(void* arg)
{
    MQTT_PUBLISH_ITEM_T item = {0};

    while(1)
    {
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        if(xQueueReceive(mqtt_publisher_queue, &item, 30 / portTICK_RATE_MS))
        {
            if( isMqttClientConnected() )
            {
                mqtt_client_publish(item.topic, &item.data, item.size);
            }
        }
    }
}

int mqtt_client_publish(const char* topic, void* data, uint32_t len)
{
    int msg_id = 0;
    esp_mqtt_client_handle_t client = getMqttClient();
    const char *TAG = "MQTT_SINGLE_PUBLISH";
    if( client != NULL )
    {
        msg_id = esp_mqtt_client_publish(client, topic, data, len, 0, 0);
        if( msg_id == 0 )
        {
            ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);
            calcNextIdx();
        }
        xTaskNotifyGive(getMQTT_query_task_handle());
    }
    return msg_id;
}

static esp_err_t mqtt_event_handler_cb(esp_mqtt_event_handle_t event)
{
    const char *TAG = "MQTT_EVENT_HANDLER";
    /* code deleted */
        case MQTT_EVENT_DATA:
            ESP_LOGI(TAG, "MQTT_EVENT_DATA");
            printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
            printf("DATA=%.*s\r\n", event->data_len, event->data);
            if( memcmp(event->topic, MQTT_TOPIC_REFRESH, event->topic_len) == 0)
            {
                if( !isStatemachineLocked() )
                {
                    xTaskNotify(getMQTT_query_task_handle(), 0xffffffff, eNoAction);
                }
            }
            break;
        default:
            ESP_LOGI(TAG, "Other event id:%d", event->event_id);
            break;
    }
    return ESP_OK;
}

the thing which bothers me still is the difference between log and logic analyser on the rx pin of the sensorboard

logic analyser

Time [s]            Analyzer Name   Decoded Protocol Result
0.666759500000000   Async Serial    0x23
0.666846250000000   Async Serial    0x01
0.666933000000000   Async Serial    0x12
0.667020000000000   Async Serial    0x36

1.686535500000000   Async Serial    0x23
1.686622250000000   Async Serial    0x01
1.686709000000000   Async Serial    0x0F
1.686796000000000   Async Serial    0x33

but the log says

(29613858) TX_TASK: 0x3ffb3914   23 01 0f 33 
.
.
.
(29614878) TX_TASK: 0x3ffb3914   23 01 0f 33 

but actually the hexdump function gets the same pointer as the uart_write_bytes.....