idf_component_register(SRCS "main.c" "wifi.c" "usb_cdc.c"

// User defines from menuconfig

#include "wifi.h"

#include "usb_cdc.h"

// Private variables

static const char *TAG = "main";

// Application entry point

    // Initialize usb-cdc interface

    usb_cdc_init();

    // Initialize NVS

    // Connect to wifi

    wifi_init();

//

// usb-cdc

//

#include "usb_cdc.h"

#include "tinyusb.h"

#include "tusb_cdc_acm.h"

#include "sdkconfig.h"

#include "esp_log.h"

// Private variables

static const char *TAG = "main";

// ------------------------ 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);

}

void usb_cdc_init(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");

}

#ifndef _USB_CDC_H_

#define _USB_CDC_H_

void usb_cdc_init(void);

#endif

//

// wifi

//

#include "wifi.h"

#include "esp_wifi.h"

#include "esp_event.h"

#include "esp_log.h"

#include "lwip/err.h"

#include "lwip/sys.h"

// FreeRTOS event group to signal when we are connected

static EventGroupHandle_t s_wifi_event_group;

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(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");

    }

}

#ifndef __WIFI_SETUP_H

#define __WIFI_SETUP_H

#include "sdkconfig.h"

/* 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

// 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

void wifi_init(void);

#endif