#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#include "common.h"
#include "console_handlers.h"

// static const char* TAG = "Test";
TaskHandle_t xHandle = NULL;

// extern "C" void app_main(void)
void app_main(void) {
   configure_output_pins();
   init_console();
}


main.c

# Wokwi project

This is a Wokwi project. Please edit this README file and add a description of your project.

## Usage

1. Add parts by clicking the blue "+" button in the diagram editor
2. Connect parts by dragging wires between them
3. Click the green play button to start the simulation


README.md

diagram.json

#include "driver/gpio.h"

#include "common.h"

void reset_all_task() {
    if (xHandle) {
        vTaskDelete(xHandle);
        xHandle = NULL;
    }
    
    gpio_set_level(BUILTIN_LED_GPIO, GPIO_OUT_LOW);
    gpio_set_level(GREEN_LED_PIN, GPIO_OUT_LOW);
    gpio_set_level(YELLOW_LED_PIN, GPIO_OUT_LOW);
    gpio_set_level(RED_LED_PIN, GPIO_OUT_LOW);
    gpio_set_level(YELLOW_LED_PIN2, GPIO_OUT_LOW);
    gpio_set_level(GREEN_LED_PIN2, GPIO_OUT_LOW);
}

void configure_output_pins() {
    gpio_reset_pin(BUILTIN_LED_GPIO);
    gpio_reset_pin(GREEN_LED_PIN);
    gpio_reset_pin(YELLOW_LED_PIN);
    gpio_reset_pin(RED_LED_PIN);
    gpio_reset_pin(YELLOW_LED_PIN2);
    gpio_reset_pin(GREEN_LED_PIN2);

    /* Set the GPIO as a push/pull output */
    gpio_set_direction(BUILTIN_LED_GPIO, GPIO_MODE_OUTPUT);
    gpio_set_direction(GREEN_LED_PIN, GPIO_MODE_OUTPUT);
    gpio_set_direction(YELLOW_LED_PIN, GPIO_MODE_OUTPUT);
    gpio_set_direction(RED_LED_PIN, GPIO_MODE_OUTPUT);
    gpio_set_direction(YELLOW_LED_PIN2, GPIO_MODE_OUTPUT);
    gpio_set_direction(GREEN_LED_PIN2, GPIO_MODE_OUTPUT);
}

void set_pin_high(int pin) {
    /* Set the GPIO level according to the state (LOW or HIGH)*/
    gpio_set_level(pin, GPIO_OUT_HIGH);
}

void set_pin_low(int pin) {
    /* Set the GPIO level according to the state (LOW or HIGH)*/
    gpio_set_level(pin, GPIO_OUT_LOW);
}

void toggle_pin(int pin) {
    gpio_set_level(pin, !gpio_get_level(pin));
}



common.c

#pragma once

void register_blink_cmd();
void register_set_pin_cmd();
void register_test_cmd();
void register_light_mode_video_cmd();


command_list.h

#ifndef COMMON_H_
#define COMMON_H_

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#define DEFAULT_TASK_PRIO 10
#define STACK_SIZE_1024 1024
#define STACK_SIZE_2048 2048

#define GPIO_OUT_HIGH true
#define GPIO_OUT_LOW  false

#define BUILTIN_LED_GPIO 2
#define GREEN_LED_PIN    22
#define YELLOW_LED_PIN   21
#define RED_LED_PIN      19
#define GREEN_LED_PIN2   4
#define YELLOW_LED_PIN2  5

extern TaskHandle_t xHandle;

void reset_all_task();
void configure_output_pins();

void set_pin_high(int pin);
void set_pin_low(int pin);
void toggle_pin(int pin);

#endif


common.h

#include "esp_log.h"
#include "esp_console.h"
#include "argtable3/argtable3.h"
#include "sdkconfig.h"

#include "console_handlers.h"
#include "command_list.h"

/**************************************************************************
 *                                  INIT                                  *
 **************************************************************************/

#define PROMPT_STR CONFIG_IDF_TARGET

void init_console() {
    esp_console_repl_t *repl = NULL;
    esp_console_repl_config_t repl_config = ESP_CONSOLE_REPL_CONFIG_DEFAULT();
    /* Prompt to be printed before each line.
     * This can be customized, made dynamic, etc.
     */
    repl_config.prompt = PROMPT_STR ">";
    repl_config.max_cmdline_length = CONFIG_CONSOLE_MAX_COMMAND_LINE_LENGTH;

    /* Register commands */
    esp_console_register_help_command();

    esp_console_dev_uart_config_t hw_config = ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_console_new_repl_uart(&hw_config, &repl_config, &repl));

    register_test_cmd();
    register_set_pin_cmd();
    register_blink_cmd();
    register_light_mode_video_cmd();

    ESP_ERROR_CHECK(esp_console_start_repl(repl));
}


console_handlers.c

console_handlers.h

#include <string.h>
#include "esp_log.h"
#include "esp_console.h"
#include "esp_random.h"
#include "argtable3/argtable3.h"

#include "common.h"
#include "command_list.h"


#define BLINK_INTERVAL  200
#define TRAFFIC_LIGHT_DELAY 5000
#define TRAFFIC_LIGHT_YELLOW_DELAY 3000
#define ADVANCED_LIGHT_DURATION 3000
#define FLASH_DELAY_DEFAULT 600
#define FLASH_DELAY_MIN 200
#define FLASH_DELAY_MAX 3000
#define FLASH_DELAY_STEP 200
#define LED_CNT 5

#define MODE_ON      "1"
#define MODE_FLASH   "2"
#define MODE_BOUNCE  "3"
#define MODE_TRAFFIC "4"
#define MODE_RANDOM  "5"
#define MODE_CYCLE   "6"
#define MODE_CYCLE_2 "7"
#define MODE_SPD_UP  "u"
#define MODE_SPD_DWN "d"
#define MODE_STOP    "s"

#define LVM_ARG_HELP_TEXT              "Mode to use:\n" \
                          "\t"MODE_ON      ": All on\n" \
                          "\t"MODE_FLASH   ": All flash\n" \
                          "\t"MODE_BOUNCE  ": Bounce\n" \
                          "\t"MODE_TRAFFIC ": Traffic (Advanced green light)\n" \
                          "\t"MODE_RANDOM  ": Random lights\n" \
                          "\t"MODE_CYCLE   ": Cycle\n" \
                          "\t"MODE_CYCLE_2 ": Cycle 2\n" \
                          "\t"MODE_SPD_UP  ": Speed up\n" \
                          "\t"MODE_SPD_DWN ": Slow down\n" \
                          "\t"MODE_STOP    ": Stop"


typedef struct cmd_lmv_args_t {
    arg_str_t *mode;
    arg_end_t *end;
} cmd_lmv_args_t;
cmd_lmv_args_t cmd_lmv_args;

unsigned int current_flash_delay = FLASH_DELAY_DEFAULT;
int pin_list[LED_CNT] = {GREEN_LED_PIN, YELLOW_LED_PIN, RED_LED_PIN, YELLOW_LED_PIN2, GREEN_LED_PIN2};

static void run_advanced_light(int pin) {
    bool isOn = false;
    for (int time_passed = 0; time_passed < ADVANCED_LIGHT_DURATION; time_passed += BLINK_INTERVAL) {
        if (isOn) {
            set_pin_low(pin);
        } else {
            set_pin_high(pin);
        }
        isOn = !isOn;
        vTaskDelay(BLINK_INTERVAL);
    }
}

static void printState(bool gOn, bool yOn, bool rOn) {
    if (gOn) ESP_LOGI(__func__, "Green: on");
    else ESP_LOGI(__func__, "Green: off");
    
    if (yOn) ESP_LOGI(__func__, "Yellow: on");
    else ESP_LOGI(__func__, "Yellow: off");
    
    if (rOn) ESP_LOGI(__func__, "Red: on");
    else ESP_LOGI(__func__, "Red: off");
}

static void run_advanced_green_task() {
    while (true) {

        ESP_LOGI(__func__, "Advanced green");
        run_advanced_light(GREEN_LED_PIN);
        printState(true, false, false);
        set_pin_high(GREEN_LED_PIN);
        vTaskDelay(TRAFFIC_LIGHT_DELAY);

        set_pin_low(GREEN_LED_PIN);
        ESP_LOGI(__func__, "Advanced yellow");
        printState(false, true, true);
        set_pin_high(YELLOW_LED_PIN);
        vTaskDelay(TRAFFIC_LIGHT_YELLOW_DELAY);

        set_pin_low(YELLOW_LED_PIN);
        ESP_LOGI(__func__, "Advanced red");
        printState(false, false, true);
        set_pin_high(RED_LED_PIN);
        vTaskDelay(TRAFFIC_LIGHT_DELAY);

        set_pin_low(RED_LED_PIN);
    }
}

static void run_flash_task() {
    while (true) {
        set_pin_high(GREEN_LED_PIN);
        set_pin_high(YELLOW_LED_PIN);
        set_pin_high(RED_LED_PIN);
        set_pin_high(YELLOW_LED_PIN2);
        set_pin_high(GREEN_LED_PIN2);
        vTaskDelay(current_flash_delay);

        set_pin_low(GREEN_LED_PIN);
        set_pin_low(YELLOW_LED_PIN);
        set_pin_low(RED_LED_PIN);
        set_pin_low(YELLOW_LED_PIN2);
        set_pin_low(GREEN_LED_PIN2);
        vTaskDelay(current_flash_delay);
    }
}

static void run_bounce_task() {
    int dir = 1;
    int current = 0;
    while (true) {
        set_pin_low(pin_list[current]);
        current += dir;
        set_pin_high(pin_list[current]);

        if (current == 0 || current == LED_CNT-1) {
            dir = -dir;
        }
        
        vTaskDelay(current_flash_delay);
    }
}

static void run_random_task() {
    while (true) {
        if (esp_random() % 2 == 0) {
            set_pin_high(pin_list[esp_random() % LED_CNT]);
        } else {
            set_pin_low(pin_list[esp_random() % LED_CNT]);
        }
        
        vTaskDelay(esp_random() % current_flash_delay);
    }
}

static void run_cycle_task() {
    while (true) {
        for (int i = 0; i < LED_CNT; i++) {
            set_pin_high(pin_list[i]);
            vTaskDelay(current_flash_delay);
            set_pin_low(pin_list[i]);
        }
    }
}

static void run_cycle_2_task() {
    bool isOn = false;
    while (true) {
        for (int i = 0; i < LED_CNT; i++) {
            if (isOn) {
                set_pin_low(pin_list[i]);
            } else {
                set_pin_high(pin_list[i]);
            }
            vTaskDelay(current_flash_delay);
        }
        isOn = !isOn;
    }
}

static int run_light_mode_video_cmd(int argc, char **argv) {
    int nerrors = arg_parse(argc, argv, (void **) &cmd_lmv_args);
    if (nerrors != 0) {
        arg_print_errors(stderr, cmd_lmv_args.end, argv[0]);
        return 1;
    }

    const char *mode = cmd_lmv_args.mode->sval[0];
    ESP_LOGI(__func__, "Running command with %d parameters", argc);
    ESP_LOGI(__func__, "--> Switch mode '%s'", mode);

    
    // Turn everything off
    set_pin_low(GREEN_LED_PIN);
    set_pin_low(YELLOW_LED_PIN);
    set_pin_low(RED_LED_PIN);
    set_pin_low(YELLOW_LED_PIN2);
    set_pin_low(GREEN_LED_PIN2);

    if (strcmp(MODE_ON, mode) == 0) {
        set_pin_high(GREEN_LED_PIN);
        set_pin_high(YELLOW_LED_PIN);
        set_pin_high(RED_LED_PIN);
        set_pin_high(YELLOW_LED_PIN2);
        set_pin_high(GREEN_LED_PIN2);

    } else if (strcmp(MODE_FLASH, mode) == 0) {
        reset_all_task();
        xTaskCreate(run_flash_task, "run_flash_task", STACK_SIZE_1024, NULL, DEFAULT_TASK_PRIO, &xHandle);

    } else if (strcmp(MODE_BOUNCE, mode) == 0) {
        reset_all_task();
        xTaskCreate(run_bounce_task, "run_bounce_task", STACK_SIZE_1024, NULL, DEFAULT_TASK_PRIO, &xHandle);

    } else if (strcmp(MODE_TRAFFIC, mode) == 0) {
        reset_all_task();
        xTaskCreate(run_advanced_green_task, "run_advanced_green_task", STACK_SIZE_2048, NULL, DEFAULT_TASK_PRIO, &xHandle);
        
    } else if (strcmp(MODE_RANDOM, mode) == 0) {
        reset_all_task();
        xTaskCreate(run_random_task, "run_random_task", STACK_SIZE_1024, NULL, DEFAULT_TASK_PRIO, &xHandle);
        
    } else if (strcmp(MODE_CYCLE, mode) == 0) {
        reset_all_task();
        xTaskCreate(run_cycle_task, "run_cycle_task", STACK_SIZE_1024, NULL, DEFAULT_TASK_PRIO, &xHandle);
        
    } else if (strcmp(MODE_CYCLE_2, mode) == 0) {
        reset_all_task();
        xTaskCreate(run_cycle_2_task, "run_cycle_2_task", STACK_SIZE_1024, NULL, DEFAULT_TASK_PRIO, &xHandle);
        
    } else if (strcmp(MODE_SPD_UP, mode) == 0) {
        ESP_LOGI(__func__, "Delay: %d'", current_flash_delay);
        if (current_flash_delay > FLASH_DELAY_MIN) {
            current_flash_delay -= FLASH_DELAY_STEP;
        }

    } else if (strcmp(MODE_SPD_DWN, mode) == 0) {
        ESP_LOGI(__func__, "Delay: %d'", current_flash_delay);
        if (current_flash_delay < FLASH_DELAY_MAX) {
            current_flash_delay += FLASH_DELAY_STEP;
        }

    } else if (strcmp(MODE_STOP, mode) == 0) {
        reset_all_task();
    }  else {
        ESP_LOGI(__func__, "Unknow mode '%s'", mode);
    }


    return 0;
}

void register_light_mode_video_cmd() {
    // arg_int1 and arg_str1 to require the paramaters
    cmd_lmv_args.mode = arg_str1(NULL, NULL, "<mode>", LVM_ARG_HELP_TEXT);
    cmd_lmv_args.end = arg_end(2);

    const esp_console_cmd_t cmd_def = {
        .command = "light-mode",
        .help = "Light mode video",
        .hint = NULL,
        .func = &run_light_mode_video_cmd,
        .argtable = &cmd_lmv_args
    };

    ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_def) );
}



light_mode_video.c

#include <string.h>
#include "esp_log.h"
#include "esp_console.h"
#include "argtable3/argtable3.h"

#include "common.h"
#include "command_list.h"


const char *PIN_HIGH_STATE_STR = "high";
const char *PIN_LOW_STATE_STR = "low";

typedef struct cmd_set_pin_args_t {
    arg_int_t *pin;
    arg_str_t *state;
    arg_end_t *end;
} cmd_set_pin_args_t;
cmd_set_pin_args_t cmd_set_pin_args;

static int set_pin_state(int argc, char **argv) {
    int nerrors = arg_parse(argc, argv, (void **) &cmd_set_pin_args);
    if (nerrors != 0) {
        arg_print_errors(stderr, cmd_set_pin_args.end, argv[0]);
        return 1;
    }

    reset_all_task();

    int pin = cmd_set_pin_args.pin->ival[0];
    const char* state = cmd_set_pin_args.state->sval[0];

    ESP_LOGI(__func__, "Running command with %d parameters", argc);
    ESP_LOGI(__func__, "--> Change pin %d to state '%s'", pin, state);

    if (strcmp(state, PIN_HIGH_STATE_STR) == 0) {
        set_pin_high(pin);
    } else if (strcmp(state, PIN_LOW_STATE_STR) == 0) {
        set_pin_low(pin);
    } else {
        ESP_LOGI(__func__, "Unknow state %s. Valid states are either '%s' or '%s'", state, PIN_HIGH_STATE_STR, PIN_LOW_STATE_STR);
    }

    return 0;
}

void register_set_pin_cmd() {
    // arg_int1 and arg_str1 to require the paramaters
    cmd_set_pin_args.pin = arg_int1(NULL, NULL, "<GPIO pin>", "GPIO pin to change state");
    cmd_set_pin_args.state = arg_str1(NULL, NULL, "<state>", "Pin state ('high' or 'low')");
    cmd_set_pin_args.end = arg_end(2);

    const esp_console_cmd_t cmd_def = {
        .command = "set-pin",
        .help = "Change pin state to high or low",
        .hint = NULL,
        .func = &set_pin_state,
        .argtable = &cmd_set_pin_args
    };

    ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_def) );
}



set_pin.c

#include "esp_log.h"
#include "esp_console.h"
#include "argtable3/argtable3.h"
#include "driver/gpio.h"

#include "common.h"
#include "command_list.h"


#define BLINK_ALL_PIN   -1
#define BLINK_INTERVAL  200

bool current_blink_state;
int active_pin = BLINK_ALL_PIN;

typedef struct cmd_blink_args_t {
    arg_str_t *mode;
    arg_lit_t *blink;
    arg_end_t *end;
} cmd_blink_args_t;
cmd_blink_args_t cmd_blink_args;


static void blink_task() {
    for (;;) {
        current_blink_state = !current_blink_state;
        if (active_pin == BLINK_ALL_PIN) {
            gpio_set_level(GREEN_LED_PIN, current_blink_state);
            gpio_set_level(YELLOW_LED_PIN, current_blink_state);
            gpio_set_level(RED_LED_PIN, current_blink_state);
        } else {
            gpio_set_level(active_pin, current_blink_state);
        }

        vTaskDelay(BLINK_INTERVAL);
    }
}

static int blink(int argc, char **argv) {
    int nerrors = arg_parse(argc, argv, (void **) &cmd_blink_args);
    if (nerrors != 0) {
        arg_print_errors(stderr, cmd_blink_args.end, argv[0]);
        return 1;
    }

    reset_all_task();

    current_blink_state = false;
    const char mode = cmd_blink_args.mode->sval[0][0];
    bool will_blink = cmd_blink_args.blink->count > 0;

    ESP_LOGI(__func__, "Running command with %d parameters", argc);

    switch (mode) {
    case 'b':
        active_pin = BLINK_ALL_PIN;
        break;
    case 'g':
        active_pin = GREEN_LED_PIN;
        break;
    case 'y':
        active_pin = YELLOW_LED_PIN;
        break;
    case 'r':
        active_pin = RED_LED_PIN;
        break;
    default:
        ESP_LOGI(__func__, "Unknow mode %c. Aborted.", mode);
        return 0;
    }
    
    if (will_blink || mode == 'b') {
        xTaskCreate(blink_task, "blink_task", STACK_SIZE_1024, NULL, DEFAULT_TASK_PRIO, &xHandle);
    } else {
        gpio_set_level(GREEN_LED_PIN, GPIO_OUT_LOW);
        gpio_set_level(YELLOW_LED_PIN, GPIO_OUT_LOW);
        gpio_set_level(RED_LED_PIN, GPIO_OUT_LOW);

        gpio_set_level(active_pin, GPIO_OUT_HIGH);
    }
    

    return 0;
}

void register_blink_cmd() {
    // arg_int1 and arg_str1 to require the paramaters
    cmd_blink_args.mode = arg_str1(NULL, NULL, "<mode>", "'b' for blink, 'g' for green.");
    cmd_blink_args.blink = arg_lit0("b", "blink", "Blink the LED. This flag is ignored in 'b' mode.");
    cmd_blink_args.end = arg_end(2);

    const esp_console_cmd_t cmd_def = {
        .command = "light",
        .help = "Turn on or blink a specific LED color, or blink all LEDs at once",
        .hint = NULL,
        .func = &blink,
        .argtable = &cmd_blink_args
    };

    ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_def) );
}



simple_led.c

#include "esp_log.h"
#include "esp_console.h"
#include "argtable3/argtable3.h"

#include "common.h"
#include "command_list.h"

/**************************************************************************
 *                             TEST COMMAND                               *
 **************************************************************************/

typedef struct cmd_test_args_t {
    arg_int_t *num;
    arg_str_t *a_string;
    arg_end_t *end;
} cmd_test_args_t;
cmd_test_args_t cmd_test_args;

static int run_test_cmd(int argc, char **argv) {
    int nerrors = arg_parse(argc, argv, (void **) &cmd_test_args);
    if (nerrors != 0) {
        arg_print_errors(stderr, cmd_test_args.end, argv[0]);
        return 1;
    }

    ESP_LOGI(__func__, "Running command with %d parameters", argc);

    // "num" param is provided
    if (cmd_test_args.num->count > 0)
        ESP_LOGI(__func__, "--> num: %d", cmd_test_args.num->ival[0]);

    ESP_LOGI(__func__, "--> a_string: %s", cmd_test_args.a_string->sval[0]);

    ESP_LOGI(__func__, "Done");
    return 0;
}

void register_test_cmd(void) {
    // arg_int0 makes parameter optional
    cmd_test_args.num = arg_int0(NULL, "num", "<n>", "A random number to display");
    cmd_test_args.a_string = arg_str1(NULL, NULL, "<a_string>", "A random string to display");
    cmd_test_args.end = arg_end(2);

    const esp_console_cmd_t cmd_def = {
        .command = "test_cmd",
        .help = "Just a simple command to test",
        .hint = NULL,
        .func = &run_test_cmd,
        .argtable = &cmd_test_args
    };

    ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_def) );
}

