syntax: glob

.config

*.o

*.pyc

*.old

*.lock

build/

managed_components/

.vscode/

sdkconfig

# The following five lines of boilerplate have to be in your project's

# CMakeLists in this exact order for cmake to work correctly

cmake_minimum_required(VERSION 3.16)

include($ENV{IDF_PATH}/tools/cmake/project.cmake)

project(protofusion_template)

# Protofusion ESP32S3 Template

## Configure

Run menuconfig with `idf.py menuconfig` and choose the Protofusion menu option.

Set target with `idf.y set-target esp32s3`

Rename the project by editing CMakeLists.txt and change `project(protofusion_template)` to reflect your project name

Note that clean doesn't always clean everything... do `idf.py fullclean` to make sure all generated files are removed (especially when switching processors).

## Build and Flash

Build the project and flash it to the board, then run monitor tool to view serial output:

```bash

idf.py flash monitor

```

(To exit the serial monitor, type ``Ctrl-]``.)

idf_component_register(SRCS "main.c"

                       INCLUDE_DIRS .)

menu "Protofusion Configuration"

    config ESP_WIFI_SSID

        string "WiFi SSID"

        default "myssid"

        help

            SSID (network name) for the example to connect to.

    config ESP_WIFI_PASSWORD

        string "WiFi Password"

        default "mypassword"

        help

            WiFi password (WPA or WPA2) for the example to use.

    choice ESP_WIFI_SAE_MODE

        prompt "WPA3 SAE mode selection"

        default ESP_WPA3_SAE_PWE_BOTH

        help

            Select mode for SAE as Hunt and Peck, H2E or both.

        config ESP_WPA3_SAE_PWE_HUNT_AND_PECK

            bool "HUNT AND PECK"

        config ESP_WPA3_SAE_PWE_HASH_TO_ELEMENT

            bool "H2E"

        config ESP_WPA3_SAE_PWE_BOTH

            bool "BOTH"

    endchoice

    config ESP_WIFI_PW_ID

        string "PASSWORD IDENTIFIER"

        depends on  ESP_WPA3_SAE_PWE_HASH_TO_ELEMENT|| ESP_WPA3_SAE_PWE_BOTH

        default ""

        help

            password identifier for SAE H2E

    config ESP_MAXIMUM_RETRY

        int "Maximum retry"

        default 5

        help

            Set the Maximum retry to avoid station reconnecting to the AP unlimited when the AP is really inexistent.

    choice ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD

        prompt "WiFi Scan auth mode threshold"

        default ESP_WIFI_AUTH_WPA2_PSK

        help

            The weakest authmode to accept in the scan mode.

            This value defaults to ESP_WIFI_AUTH_WPA2_PSK incase password is present and ESP_WIFI_AUTH_OPEN is used.

            Please select ESP_WIFI_AUTH_WEP/ESP_WIFI_AUTH_WPA_PSK incase AP is operating in WEP/WPA mode.

        config ESP_WIFI_AUTH_OPEN

            bool "OPEN"

        config ESP_WIFI_AUTH_WEP

            bool "WEP"

        config ESP_WIFI_AUTH_WPA_PSK

            bool "WPA PSK"

        config ESP_WIFI_AUTH_WPA2_PSK

            bool "WPA2 PSK"

        config ESP_WIFI_AUTH_WPA_WPA2_PSK

            bool "WPA/WPA2 PSK"

        config ESP_WIFI_AUTH_WPA3_PSK

            bool "WPA3 PSK"

        config ESP_WIFI_AUTH_WPA2_WPA3_PSK

            bool "WPA2/WPA3 PSK"

        config ESP_WIFI_AUTH_WAPI_PSK

            bool "WAPI PSK"

    endchoice

endmenu

## IDF Component Manager Manifest File

dependencies:

  espressif/esp_tinyusb: "^1"

  idf: "^5.0"

//

// Protofusion ESP32S3 Template

//

#include <stdint.h>

#include "esp_log.h"

#include "freertos/FreeRTOS.h"

#include "freertos/task.h"

#include "freertos/event_groups.h"

#include "esp_system.h"

#include "esp_wifi.h"

#include "esp_event.h"

#include "esp_log.h"

#include "nvs_flash.h"

#include "lwip/err.h"

#include "lwip/sys.h"

#include "tinyusb.h"

#include "tusb_cdc_acm.h"

#include "sdkconfig.h"

// ------------------------ Wifi ------------------------------------------------

// Set via menuconfig -- do not set in source code

#define EXAMPLE_ESP_WIFI_SSID      CONFIG_ESP_WIFI_SSID

#define EXAMPLE_ESP_WIFI_PASS      CONFIG_ESP_WIFI_PASSWORD

#define EXAMPLE_ESP_MAXIMUM_RETRY  CONFIG_ESP_MAXIMUM_RETRY

#if CONFIG_ESP_WPA3_SAE_PWE_HUNT_AND_PECK

#define ESP_WIFI_SAE_MODE WPA3_SAE_PWE_HUNT_AND_PECK

#define EXAMPLE_H2E_IDENTIFIER ""

#elif CONFIG_ESP_WPA3_SAE_PWE_HASH_TO_ELEMENT

#define ESP_WIFI_SAE_MODE WPA3_SAE_PWE_HASH_TO_ELEMENT

#define EXAMPLE_H2E_IDENTIFIER CONFIG_ESP_WIFI_PW_ID

#elif CONFIG_ESP_WPA3_SAE_PWE_BOTH

#define ESP_WIFI_SAE_MODE WPA3_SAE_PWE_BOTH

#define EXAMPLE_H2E_IDENTIFIER CONFIG_ESP_WIFI_PW_ID

#endif

#if CONFIG_ESP_WIFI_AUTH_OPEN

#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_OPEN

#elif CONFIG_ESP_WIFI_AUTH_WEP

#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WEP

#elif CONFIG_ESP_WIFI_AUTH_WPA_PSK

#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA_PSK

#elif CONFIG_ESP_WIFI_AUTH_WPA2_PSK

#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA2_PSK

#elif CONFIG_ESP_WIFI_AUTH_WPA_WPA2_PSK

#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA_WPA2_PSK

#elif CONFIG_ESP_WIFI_AUTH_WPA3_PSK

#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA3_PSK

#elif CONFIG_ESP_WIFI_AUTH_WPA2_WPA3_PSK

#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA2_WPA3_PSK

#elif CONFIG_ESP_WIFI_AUTH_WAPI_PSK

#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WAPI_PSK

#endif

/* FreeRTOS event group to signal when we are connected*/

static EventGroupHandle_t s_wifi_event_group;

/* The event group allows multiple bits for each event, but we only care about two events:

 * - we are connected to the AP with an IP

 * - we failed to connect after the maximum amount of retries */

#define WIFI_CONNECTED_BIT BIT0

#define WIFI_FAIL_BIT      BIT1

static const char *TAG = "wifi station";

static int s_retry_num = 0;

static void event_handler(void* arg, esp_event_base_t event_base,

                                int32_t event_id, void* event_data)

{

    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {

        esp_wifi_connect();

    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {

        if (s_retry_num < EXAMPLE_ESP_MAXIMUM_RETRY) {

            esp_wifi_connect();

            s_retry_num++;

            ESP_LOGI(TAG, "retry to connect to the AP");

        } else {

            xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);

        }

        ESP_LOGI(TAG,"connect to the AP fail");

    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {

        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;

        ESP_LOGI(TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip));

        s_retry_num = 0;

        xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);

    }

}

void wifi_init_sta(void)

{

    s_wifi_event_group = xEventGroupCreate();

    ESP_ERROR_CHECK(esp_netif_init());

    ESP_ERROR_CHECK(esp_event_loop_create_default());

    esp_netif_create_default_wifi_sta();

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();

    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

    esp_event_handler_instance_t instance_any_id;

    esp_event_handler_instance_t instance_got_ip;

    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,

                                                        ESP_EVENT_ANY_ID,

                                                        &event_handler,

                                                        NULL,

                                                        &instance_any_id));

    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,

                                                        IP_EVENT_STA_GOT_IP,

                                                        &event_handler,

                                                        NULL,

                                                        &instance_got_ip));

    wifi_config_t wifi_config = {

        .sta = {

            .ssid = EXAMPLE_ESP_WIFI_SSID,

            .password = EXAMPLE_ESP_WIFI_PASS,

            /* Authmode threshold resets to WPA2 as default if password matches WPA2 standards (pasword len => 8).

             * If you want to connect the device to deprecated WEP/WPA networks, Please set the threshold value

             * to WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK and set the password with length and format matching to

             * WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK standards.

             */

            .threshold.authmode = ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD,

            .sae_pwe_h2e = ESP_WIFI_SAE_MODE,

            .sae_h2e_identifier = EXAMPLE_H2E_IDENTIFIER,

        },

    };

    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA) );

    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config) );

    ESP_ERROR_CHECK(esp_wifi_start() );

    ESP_LOGI(TAG, "wifi_init_sta finished.");

    /* Waiting until either the connection is established (WIFI_CONNECTED_BIT) or connection failed for the maximum

     * number of re-tries (WIFI_FAIL_BIT). The bits are set by event_handler() (see above) */

    EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,

            WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,

            pdFALSE,

            pdFALSE,

            portMAX_DELAY);

    /* xEventGroupWaitBits() returns the bits before the call returned, hence we can test which event actually

     * happened. */

    if (bits & WIFI_CONNECTED_BIT) {

        ESP_LOGI(TAG, "connected to ap SSID:%s password:%s",

                 EXAMPLE_ESP_WIFI_SSID, EXAMPLE_ESP_WIFI_PASS);

    } else if (bits & WIFI_FAIL_BIT) {

        ESP_LOGI(TAG, "Failed to connect to SSID:%s, password:%s",

                 EXAMPLE_ESP_WIFI_SSID, EXAMPLE_ESP_WIFI_PASS);

    } else {

        ESP_LOGE(TAG, "UNEXPECTED EVENT");

    }

}

// ------------------------ USB CDC ----------------------------------------

static uint8_t buf[CONFIG_TINYUSB_CDC_RX_BUFSIZE + 1];

void tinyusb_cdc_rx_callback(int itf, cdcacm_event_t *event)

{

    /* initialization */

    size_t rx_size = 0;

    /* read */

    esp_err_t ret = tinyusb_cdcacm_read(itf, buf, CONFIG_TINYUSB_CDC_RX_BUFSIZE, &rx_size);

    if (ret == ESP_OK) {

        ESP_LOGI(TAG, "Data from channel %d:", itf);

        ESP_LOG_BUFFER_HEXDUMP(TAG, buf, rx_size, ESP_LOG_INFO);

    } else {

        ESP_LOGE(TAG, "Read error");

    }

    /* write back */

    tinyusb_cdcacm_write_queue(itf, buf, rx_size);

    tinyusb_cdcacm_write_flush(itf, 0);

}

void tinyusb_cdc_line_state_changed_callback(int itf, cdcacm_event_t *event)

{

    int dtr = event->line_state_changed_data.dtr;

    int rts = event->line_state_changed_data.rts;

    ESP_LOGI(TAG, "Line state changed on channel %d: DTR:%d, RTS:%d", itf, dtr, rts);

}

// ------------------------- Application --------------------------

void app_main(void)

{

    ESP_LOGI(TAG, "USB initialization");

    const tinyusb_config_t tusb_cfg = {

        .device_descriptor = NULL,

        .string_descriptor = NULL,

        .external_phy = false,

        .configuration_descriptor = NULL,

    };

    ESP_ERROR_CHECK(tinyusb_driver_install(&tusb_cfg));

    tinyusb_config_cdcacm_t acm_cfg = {

        .usb_dev = TINYUSB_USBDEV_0,

        .cdc_port = TINYUSB_CDC_ACM_0,

        .rx_unread_buf_sz = 64,

        .callback_rx = &tinyusb_cdc_rx_callback, // the first way to register a callback

        .callback_rx_wanted_char = NULL,

        .callback_line_state_changed = NULL,

        .callback_line_coding_changed = NULL

    };

    ESP_ERROR_CHECK(tusb_cdc_acm_init(&acm_cfg));

    /* the second way to register a callback */

    ESP_ERROR_CHECK(tinyusb_cdcacm_register_callback(

                        TINYUSB_CDC_ACM_0,

                        CDC_EVENT_LINE_STATE_CHANGED,

                        &tinyusb_cdc_line_state_changed_callback));

#if (CONFIG_TINYUSB_CDC_COUNT > 1)

    acm_cfg.cdc_port = TINYUSB_CDC_ACM_1;

    ESP_ERROR_CHECK(tusb_cdc_acm_init(&acm_cfg));

    ESP_ERROR_CHECK(tinyusb_cdcacm_register_callback(

                        TINYUSB_CDC_ACM_1,

                        CDC_EVENT_LINE_STATE_CHANGED,

                        &tinyusb_cdc_line_state_changed_callback));

#endif

    ESP_LOGI(TAG, "USB initialization DONE");

    //Initialize NVS

    esp_err_t ret = nvs_flash_init();

    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {

      ESP_ERROR_CHECK(nvs_flash_erase());

      ret = nvs_flash_init();

    }

    ESP_ERROR_CHECK(ret);

    ESP_LOGI(TAG, "ESP_WIFI_MODE_STA");

    wifi_init_sta();

}

CONFIG_TINYUSB_CDC_ENABLED=y