ESP32 Forum

Code: Select all

static void rx_task(void *arg)
{

    uint8_t effective_message[34] = {};
    uint8_t working_message[34] = {};
    uint8_t tx_buffer[34]={};

    static const char *RX_TASK_TAG = "RX_TASK";
    esp_log_level_set(RX_TASK_TAG, ESP_LOG_INFO) ;
    uint8_t* data = (uint8_t*) malloc(RX_BUF_SIZE+1);
    static const int UART_MSG_length = 34; 


    int count = 0; 
    

    queue_msg msg_to_send; 
    msg_to_send.q_sender = robot; 
    bool tag=false;
    udp_send_msg udp_to_send;


    while (1) {

        const int rxBytes = uart_read_bytes(UART_NUM_1, data, 34, 1);
          
        if (rxBytes > 0) {
            data[rxBytes] = 0;
            
            tag=!tag;
            gpio_set_level(GPIO_OUTPUT_IO_1, tag);


            int remaining_bytes = rxBytes; 
            

            if(count >0) 
            {
                
                int required_bytes=UART_MSG_length-count;

                if( required_bytes > rxBytes)
                {
                    memcpy(&working_message[count], data, rxBytes);
                    count = count + rxBytes; 
                }
                else 
                {
                    memcpy(&working_message[count], data, required_bytes);
                    memcpy(data, &data[UART_MSG_length-count], rxBytes-required_bytes);
                    if(working_message[UART_MSG_length-1] == 0x26)
                    {
                        memcpy(msg_to_send.msg_array, working_message, 34);
                        memcpy(udp_to_send.udp_send_array, working_message, 34);
                        xQueueSend(uart_queue, (void*) &msg_to_send, portMAX_DELAY); 
                        xQueueSend(udp_send_queue, (void*) &udp_to_send, portMAX_DELAY);
                    }
                    remaining_bytes = rxBytes-required_bytes; 
                    count = 0 ; 
                    memset(working_message, 0, sizeof(working_message)); 
                }
            }
            
            if(count ==0 && remaining_bytes > 0 )
            {
                for(int i=0; i< rxBytes; i++)
                {
                    if(data[i]==0x2A)
                    {
                        if(rxBytes-i<34)
                        {
                            memcpy(&working_message[0], &data[i], remaining_bytes -i); 
                            count = remaining_bytes -i;  
                        }
                        else
                        {
                            memcpy(working_message, &data[i], UART_MSG_length);
                            if(working_message[UART_MSG_length-1] == 0x26)
                            {
                                memcpy(effective_message, working_message, 34);

                                memcpy(msg_to_send.msg_array, working_message, 34);
                                memcpy(udp_to_send.udp_send_array, working_message, 34);

                                xQueueSend(uart_queue, (void*) &msg_to_send, portMAX_DELAY); 
                                xQueueSend(udp_send_queue, (void*) &udp_to_send, portMAX_DELAY);

                            }
                        }
                        break;
                    } 
                }
            }  
        }  
    }
    free(data);
    free(effective_message); 
    free(working_message);
}