This is a correct way to programming many resources?

[erickchicatto1]

/* GPIO Example

This example code is in the Public Domain (or CC0 licensed, at your option.)

Unless required by applicable law or agreed to in writing, this software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ //gpio

include

include

include

include "freertos/FreeRTOS.h"

include "freertos/task.h"

include "freertos/queue.h"

include "driver/gpio.h"

//pwm

include "driver/mcpwm.h"

include "soc/mcpwm_reg.h"

include "soc/mcpwm_struct.h"

//adc

include "driver/adc.h"

include "driver/dac.h"

include "esp_system.h"

include "esp_adc_cal.h"

//uart

include "esp_system.h"

include "driver/uart.h"

include "soc/uart_struct.h"

include "esp_log.h"

define GPIO_OUTPUT_IO_0 4

define GPIO_OUTPUT_IO_1 5

define GPIO_OUTPUT_PIN_SEL ((1ULL<<GPIO_OUTPUT_IO_0) | (1ULL<<GPIO_OUTPUT_IO_1))

define GPIO_INPUT_IO_0 14

define GPIO_INPUT_IO_1 13

define GPIO_INPUT_PIN_SEL ((1ULL<<GPIO_INPUT_IO_0) | (1ULL<<GPIO_INPUT_IO_1))

define ESP_INTR_FLAG_DEFAULT 0

//You can get these value from the datasheet of servo you use, in general pulse width varies between 1000 to 2000 mocrosecond

define SERVO_MIN_PULSEWIDTH 1000 //Minimum pulse width in microsecond

define SERVO_MAX_PULSEWIDTH 2000 //Maximum pulse width in microsecond

define SERVO_MAX_DEGREE 90 //Maximum angle in degree upto which servo can rotate

// adc

define DAC_EXAMPLE_CHANNEL 6

define ADC2_EXAMPLE_CHANNEL 7

//uart

define TXD_PIN (8)

define RXD_PIN (9)

// la mayor parte de la logica se va en configuraciones , en mover punteros y optimizar memoria

static const int RX_BUF_SIZE = 1024; static xQueueHandle gpio_evt_queue = NULL;

// UART void init_uart(){ const uart_config_t uart_config = { .baud_rate = 115200, .data_bits = UART_DATA_8_BITS, .parity = UART_PARITY_DISABLE, .stop_bits = UART_STOP_BITS_1, .flow_ctrl = UART_HW_FLOWCTRL_DISABLE }; uart_param_config(UART_NUM_1, &uart_config); uart_set_pin(UART_NUM_1, TXD_PIN, RXD_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE); uart_driver_install(UART_NUM_1, RX_BUF_SIZE * 2, 0, 0, NULL, 0);

}

// configurar los datos que va a enviar int sendData(const char logName, const char data){ const int len = strlen(data); const int txBytes = uart_write_bytes(UART_NUM_1, data, len); ESP_LOGI(logName, "Wrote %d bytes", txBytes); return txBytes; }

static void tx_task(){ static const char *TX_TASK_TAG = "TX_TASK"; esp_log_level_set(TX_TASK_TAG, ESP_LOG_INFO);

while(1){
    // usa la funcion de arriba
    sendData(TX_TASK_TAG, "Hello world");
    vTaskDelay(2000 / portTICK_PERIOD_MS);
}    

}

static void rx_task(){ static const char RX_TASK_TAG = "RX_TASK"; esp_log_level_set(RX_TASK_TAG, ESP_LOG_INFO); // crea un espacio de memoria de 8 bits // crea un espacio de memoria de 8 bits y te devuelve un apuntador al bloque de memoria alojado uint8_t data = (uint8_t*) malloc(RX_BUF_SIZE+1);

while(1){
    const int rxBytes = uart_read_bytes(UART_NUM_1, data, RX_BUF_SIZE, 1000 / portTICK_RATE_MS);
    if(rxBytes){
        data[rxBytes] = 0;
        ESP_LOGI(RX_TASK_TAG, "Read %d bytes: '%s'", rxBytes, data);
        ESP_LOG_BUFFER_HEXDUMP(RX_TASK_TAG, data, rxBytes, ESP_LOG_INFO);
    }
}
free(data);

}

//pwm static void mcpwm_example_gpio_initialize() { printf("initializing mcpwm servo control gpio......\n"); mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM0A, 23); //Set GPIO 18 as PWM0A, to which servo is connected }

static uint32_t servo_per_degree_init(uint32_t degree_of_rotation) { uint32_t cal_pulsewidth = 0; cal_pulsewidth = (SERVO_MIN_PULSEWIDTH + (((SERVO_MAX_PULSEWIDTH - SERVO_MIN_PULSEWIDTH) * (degree_of_rotation)) / (SERVO_MAX_DEGREE))); return cal_pulsewidth; }

void mcpwm_example_servo_control(void *arg) { uint32_t angle, count; //1. mcpwm gpio initialization mcpwm_example_gpio_initialize();

//2. initial mcpwm configuration
printf("Configuring Initial Parameters of mcpwm......\n");
mcpwm_config_t pwm_config;
pwm_config.frequency = 50;    //frequency = 50Hz, i.e. for every servo motor time period should be 20ms
pwm_config.cmpr_a = 0;    //duty cycle of PWMxA = 0
pwm_config.cmpr_b = 0;    //duty cycle of PWMxb = 0
pwm_config.counter_mode = MCPWM_UP_COUNTER;
pwm_config.duty_mode = MCPWM_DUTY_MODE_0;
mcpwm_init(MCPWM_UNIT_0, MCPWM_TIMER_0, &pwm_config);    //Configure PWM0A & PWM0B with above settings
//while (1) {
    for (count = 0; count < SERVO_MAX_DEGREE; count++) {
        printf("Angle of rotation: %d\n", count);
        angle = servo_per_degree_init(count);
        printf("pulse width: %dus\n", angle);
        mcpwm_set_duty_in_us(MCPWM_UNIT_0, MCPWM_TIMER_0, MCPWM_OPR_A, angle);
        vTaskDelay(10);     //Add delay, since it takes time for servo to rotate, generally 100ms/60degree rotation at 5V
    }
//}

}

// ADC-DAC void adc_dac_control(void *arg){ // uint8_t output_data = 0 ; int read_raw;

esp_err_t readdata; // lo llama a una estructura
gpio_num_t adc_gpio_num, dac_gpio_num;

readdata = adc2_pad_get_io_num( ADC2_EXAMPLE_CHANNEL, &adc_gpio_num );
assert(readdata == ESP_OK );

readdata = dac_pad_get_io_num( DAC_EXAMPLE_CHANNEL, &dac_gpio_num );
assert( readdata == ESP_OK );

printf("ADC channel %d @ GPIO %d, DAC channel %d @ GPIO %d.\n", ADC2_EXAMPLE_CHANNEL, adc_gpio_num,
            DAC_EXAMPLE_CHANNEL, dac_gpio_num );

dac_output_enable( DAC_EXAMPLE_CHANNEL );
printf("adc2_init...\n");
adc2_config_channel_atten( ADC2_EXAMPLE_CHANNEL, ADC_ATTEN_0db );

vTaskDelay(10 * portTICK_PERIOD_MS);

// comienza la conversion
printf("comienza la conversion....\n");
while(1){
    dac_output_voltage( DAC_EXAMPLE_CHANNEL, output_data++ );
    readdata = adc2_get_raw( ADC2_EXAMPLE_CHANNEL, ADC_WIDTH_12Bit, &read_raw);
    if ( readdata == ESP_OK ) {
        printf("%d: %d\n", output_data, read_raw );
    } else if ( readdata == ESP_ERR_INVALID_STATE ) {
        printf("%s: ADC2 not initialized yet.\n", esp_err_to_name(readdata));
    } else if ( readdata == ESP_ERR_TIMEOUT ) {
        //This can not happen in this example. But if WiFi is in use, such error code could be returned.
        printf("%s: ADC2 is in use by Wi-Fi.\n", esp_err_to_name(readdata));
    } else {
        printf("%s\n", esp_err_to_name(readdata));
    }

    vTaskDelay( 2 * portTICK_PERIOD_MS );
}

}

static void IRAM_ATTR gpio_isr_handler(void* arg) // ESTA FUNCION TOMA LOS VALORES DE LA ULTIMA FUNCION { uint32_t gpio_num = (uint32_t) arg; xQueueSendFromISR(gpio_evt_queue, &gpio_num, NULL); // LO GUARDA EN EL QUEUE }

static void gpio_task_example(void* arg) // LO RETOMA DEL QUEUE Y LO UTILIZA { uint32_t io_num; // ESTA ESTRUCTURA LA PODEMOS USAR , PARA COMPARAR CON GPIO for(;;) { if(xQueueReceive(gpio_evt_queue, &io_num, portMAX_DELAY)) { printf("GPIO[%d] intr, val: %d\n", io_num, gpio_get_level(io_num));

        if(io_num==GPIO_OUTPUT_IO_0){
            gpio_set_level(GPIO_OUTPUT_IO_0,1); // on GPIO
        }
        else if(io_num==GPIO_OUTPUT_IO_1){
            gpio_set_level(GPIO_OUTPUT_IO_0,0); // on GPIO
        }
    }

}

}

void app_main() {
//OUTPUT! gpio_config_t io_conf; //disable interrupt io_conf.intr_type = GPIO_PIN_INTR_DISABLE; //set as output mode io_conf.mode = GPIO_MODE_OUTPUT; //bit mask of the pins that you want to set,e.g.GPIO18/19 io_conf.pin_bit_mask = GPIO_OUTPUT_PIN_SEL; //disable pull-down mode io_conf.pull_down_en = 0; //disable pull-up mode io_conf.pull_up_en = 0; //configure GPIO with the given settings gpio_config(&io_conf);

//interrupt of rising edge
io_conf.intr_type = GPIO_PIN_INTR_POSEDGE;
//bit mask of the pins, use GPIO4/5 here
io_conf.pin_bit_mask = GPIO_INPUT_PIN_SEL;
//set as input mode    
io_conf.mode = GPIO_MODE_INPUT;
//enable pull-up mode
io_conf.pull_up_en = 1;
gpio_config(&io_conf);

//change gpio intrrupt type for one pin
// gpio_set_intr_type(GPIO_INPUT_IO_0, GPIO_INTR_ANYEDGE);

//create a queue to handle gpio event from isr
gpio_evt_queue = xQueueCreate(10, sizeof(uint32_t));

//la primera opcion fue poner ciclos for
//puedes crear un swtich case para que cada sentencia se ejecute con un tiempo?!?!! 

for(int i=0;i<=500;i++){
     //start gpio task
   switch(i){

      case 20:
         printf("Testing GPIO.......\n");
         xTaskCreate(gpio_task_example, "gpio_task_example", 1024, NULL, 1, NULL);
         break;

      case 120:
         // To create a servomotor hilo
         printf("Testing servo motor.......\n");
         xTaskCreate(mcpwm_example_servo_control, "mcpwm_example_servo_control", 1024, NULL, 2, NULL);
         break;

      case 200:
         printf("Testing ADC/DAC.......\n");
         xTaskCreate(adc_dac_control, "adc_dac_control", 1024, NULL, 3, NULL);
         break;

      case 300:
         // uart
        init_uart();
        // se deben de crear dos taks uno para enviar y otro para recibir
        printf("Testing uart.......\n");
        xTaskCreate(rx_task, "uart_rx_task", 1024*2, NULL, configMAX_PRIORITIES, NULL);
        xTaskCreate(tx_task, "uart_tx_task", 1024*2, NULL, configMAX_PRIORITIES-1, NULL);
        break;

     default:
        printf("this a default option \n");

   }

}

}

I tried to write this code, but i dont know if its correct , please help me