├── LICENSE
├── README.md
├── components
    └── usb_host
    │   ├── CMakeLists.txt
    │   ├── acm
    │       └── usb_acm.cpp
    │   ├── host
    │       ├── usb_device.cpp
    │       └── usb_host.cpp
    │   ├── include
    │       ├── diskio_rawmsc.hpp
    │       ├── usb_acm.hpp
    │       ├── usb_device.hpp
    │       ├── usb_host.hpp
    │       ├── usb_msc.hpp
    │       └── usb_requests.hpp
    │   └── msc
    │       ├── usb_msc.cpp
    │       └── vfs
    │           └── diskio_rawmsc.cpp
└── examples
    ├── cdc_acm
        ├── .gitignore
        ├── CMakeLists.txt
        └── main
        │   ├── CMakeLists.txt
        │   └── main.cpp
    ├── read_write
        ├── .gitignore
        ├── CMakeLists.txt
        └── main
        │   ├── CMakeLists.txt
        │   └── main.cpp
    └── remote_pendrive
        ├── .gitignore
        ├── CMakeLists.txt
        ├── embedded
            ├── app.css
            ├── app.js
            └── index.html
        └── main
            ├── CMakeLists.txt
            ├── main.cpp
            ├── web_server.c
            ├── wifi.c
            └── wifi.h


/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 chegewara
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | This new USB host library based is based on changed and hopefully somehow final API from espressif.
 2 | 
 3 | The idea is to make this library usable with esp-idf and arduino. I see the need to add files required by arduino and i think this will be maintained in other branch.
 4 | 
 5 | 
 6 | For start it is very simple library without proper error handling and probably with many errors, but i decided to share it because i have functional USB MSC code with cool example (functional, not finished). 
 7 | 
 8 | Currently library is working only with esp-idf, due to missing some files in arduino. 
 9 | 
10 | Maybe someone would like to join and to add other examples:
11 | - simple read/write example using POSIX
12 | - remote pendrive - we can connect regular pendrive and open files with web browser, there is missing upload files option.
13 | - simple CDC ACM example
14 | 
15 | 
16 | Added CDC ACM serial class.
17 | Maybe next step is to add USB HID class with some examples.
18 | 


--------------------------------------------------------------------------------
/components/usb_host/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | idf_component_register(SRCS 
 2 |     "host/usb_host.cpp" 
 3 |     "acm/usb_acm.cpp" 
 4 |     "msc/usb_msc.cpp" 
 5 |     "host/usb_device.cpp"
 6 |     "msc/vfs/diskio_rawmsc.cpp"
 7 |     
 8 |     INCLUDE_DIRS "include"
 9 | 
10 |     REQUIRES usb fatfs
11 | )
12 | 


--------------------------------------------------------------------------------
/components/usb_host/acm/usb_acm.cpp:
--------------------------------------------------------------------------------
  1 | #include "esp_log.h"
  2 | #include "string.h"
  3 | 
  4 | #include "usb_acm.hpp"
  5 | 
  6 | void IRAM_ATTR usb_ctrl_cb(usb_transfer_t *transfer)
  7 | {
  8 |     USBacmDevice *dev = (USBacmDevice *)transfer->context;
  9 | 
 10 |     if (transfer->data_buffer[0] == SET_VALUE && transfer->data_buffer[1] == SET_LINE_CODING) // set line coding
 11 |     {
 12 |         dev->_callback(CDC_CTRL_SET_LINE_CODING, transfer);
 13 |     }
 14 |     else if (transfer->data_buffer[0] == GET_VALUE && transfer->data_buffer[1] == GET_LINE_CODING) // get line coding
 15 |     {
 16 |         dev->_callback(CDC_CTRL_GET_LINE_CODING, transfer);
 17 |     }
 18 |     else if (transfer->data_buffer[0] == SET_VALUE && transfer->data_buffer[1] == SET_CONTROL_LINE_STATE) // set line coding
 19 |     {
 20 |         dev->_callback(CDC_CTRL_SET_CONTROL_LINE_STATE, transfer);
 21 |     }
 22 | }
 23 | 
 24 | void IRAM_ATTR usb_read_cb(usb_transfer_t *transfer)
 25 | {
 26 |     USBacmDevice *dev = (USBacmDevice *)transfer->context;
 27 |     dev->_callback(CDC_DATA_IN, transfer);
 28 |     dev->deallocate(transfer);
 29 | }
 30 | 
 31 | void IRAM_ATTR usb_write_cb(usb_transfer_t *transfer)
 32 | {
 33 |     USBacmDevice *dev = (USBacmDevice *)transfer->context;
 34 |     dev->_callback(CDC_DATA_OUT, transfer);
 35 |     dev->deallocate(transfer);
 36 | }
 37 | 
 38 | USBacmDevice::USBacmDevice(const usb_config_desc_t *config_desc, USBhost *host)
 39 | {
 40 |     _host = host;
 41 |     int offset = 0;
 42 |     for (size_t n = 0; n < config_desc->bNumInterfaces; n++)
 43 |     {
 44 |         const usb_intf_desc_t *intf = usb_parse_interface_descriptor(config_desc, n, 0, &offset);
 45 |         const usb_ep_desc_t *ep = nullptr;
 46 | 
 47 |         if (intf->bInterfaceClass == 0x02)
 48 |         {
 49 |             if (intf->bNumEndpoints != 1)
 50 |                 return;
 51 |             int _offset = 0;
 52 |             ep = usb_parse_endpoint_descriptor_by_index(intf, 0, config_desc->wTotalLength, &_offset);
 53 |             ep_int = ep;
 54 |             ESP_LOGI("", "EP CDC comm.");
 55 | 
 56 |             printf("EP num: %d/%d, len: %d, ", 1, intf->bNumEndpoints, config_desc->wTotalLength);
 57 |             if (ep)
 58 |                 printf("address: 0x%02x, EP max size: %d, dir: %s\n", ep->bEndpointAddress, ep->wMaxPacketSize, (ep->bEndpointAddress & 0x80) ? "IN" : "OUT");
 59 |             else
 60 |                 ESP_LOGW("", "error to parse endpoint by index; EP num: %d/%d, len: %d", 1, intf->bNumEndpoints, config_desc->wTotalLength);
 61 | 
 62 |             esp_err_t err = usb_host_interface_claim(_host->clientHandle(), _host->deviceHandle(), n, 0);
 63 |             ESP_LOGI("", "interface claim status: %d", err);
 64 |             itf_num = 0;
 65 |         }
 66 |         else if (intf->bInterfaceClass == 0x0a)
 67 |         {
 68 |             if (intf->bNumEndpoints != 2)
 69 |                 return;
 70 |             ESP_LOGI("", "EP CDC data.");
 71 |             for (size_t i = 0; i < intf->bNumEndpoints; i++)
 72 |             {
 73 |                 int _offset = 0;
 74 |                 ep = usb_parse_endpoint_descriptor_by_index(intf, i, config_desc->wTotalLength, &_offset);
 75 |                 if (ep->bEndpointAddress & 0x80)
 76 |                 {
 77 |                     ep_in = ep;
 78 |                 }
 79 |                 else
 80 |                 {
 81 |                     ep_out = ep;
 82 |                 }
 83 | 
 84 |                 printf("EP num: %d/%d, len: %d, ", i + 1, intf->bNumEndpoints, config_desc->wTotalLength);
 85 |                 if (ep)
 86 |                     printf("address: 0x%02x, EP max size: %d, dir: %s\n", ep->bEndpointAddress, ep->wMaxPacketSize, (ep->bEndpointAddress & 0x80) ? "IN" : "OUT");
 87 |                 else
 88 |                     ESP_LOGW("", "error to parse endpoint by index; EP num: %d/%d, len: %d", i + 1, intf->bNumEndpoints, config_desc->wTotalLength);
 89 |             }
 90 |             esp_err_t err = usb_host_interface_claim(_host->clientHandle(), _host->deviceHandle(), n, 0);
 91 |             ESP_LOGI("", "interface claim status: %d", err);
 92 |         }
 93 |     }
 94 | }
 95 | 
 96 | USBacmDevice::~USBacmDevice()
 97 | {
 98 |     // TODO
 99 |     deallocate(xfer_ctrl);
100 | }
101 | 
102 | bool USBacmDevice::init()
103 | {
104 |     usb_device_info_t info = _host->getDeviceInfo();
105 |     USBhostDevice::init(info.bMaxPacketSize0);
106 |     xfer_ctrl->callback = usb_ctrl_cb;
107 | 
108 |     return true;
109 | }
110 | 
111 | void USBacmDevice::setControlLine(bool dtr, bool rts)
112 | {
113 |     USB_CTRL_REQ_CDC_SET_CONTROL_LINE_STATE((usb_setup_packet_t *)xfer_ctrl->data_buffer, 0, dtr, rts);
114 |     xfer_ctrl->num_bytes = sizeof(usb_setup_packet_t) + ((usb_setup_packet_t *)xfer_ctrl->data_buffer)->wLength;
115 |     esp_err_t err = usb_host_transfer_submit_control(_host->clientHandle(), xfer_ctrl);
116 | }
117 | 
118 | void USBacmDevice::setLineCoding(uint32_t bitrate, uint8_t cf, uint8_t parity, uint8_t bits)
119 | {
120 |     line_coding_t data;
121 |     data.dwDTERate = bitrate;
122 |     data.bCharFormat = cf;
123 |     data.bParityType = parity;
124 |     data.bDataBits = bits;
125 |     USB_CTRL_REQ_CDC_SET_LINE_CODING((usb_setup_packet_t *)xfer_ctrl->data_buffer, 0, bitrate, cf, parity, bits);
126 |     memcpy(xfer_ctrl->data_buffer + sizeof(usb_setup_packet_t), &data, sizeof(line_coding_t));
127 |     xfer_ctrl->num_bytes = sizeof(usb_setup_packet_t) + 7;
128 |     esp_err_t err = usb_host_transfer_submit_control(_host->clientHandle(), xfer_ctrl);
129 | }
130 | 
131 | void USBacmDevice::getLineCoding()
132 | {
133 |     USB_CTRL_REQ_CDC_GET_LINE_CODING((usb_setup_packet_t *)xfer_ctrl->data_buffer, 0);
134 |     xfer_ctrl->num_bytes = sizeof(usb_setup_packet_t) + ((usb_setup_packet_t *)xfer_ctrl->data_buffer)->wLength;
135 |     esp_err_t err = usb_host_transfer_submit_control(_host->clientHandle(), xfer_ctrl);
136 | }
137 | 
138 | void USBacmDevice::INDATA(size_t len)
139 | {
140 |     if (!connected)
141 |         return;
142 | 
143 |     size_t _len = usb_round_up_to_mps(len, ep_out->wMaxPacketSize);
144 | 
145 |     usb_transfer_t *xfer_read = allocate(_len);
146 |     xfer_read->num_bytes = _len;
147 |     xfer_read->callback = usb_read_cb;
148 |     xfer_read->context = this;
149 |     xfer_read->bEndpointAddress = ep_in->bEndpointAddress;
150 | 
151 |     esp_err_t err = usb_host_transfer_submit(xfer_read);
152 |     if (err)
153 |     {
154 |         ESP_LOGW("", "test read data: 0x%02x", err);
155 |     }
156 | }
157 | 
158 | void USBacmDevice::OUTDATA(uint8_t *data, size_t len)
159 | {
160 |     if (!connected)
161 |         return;
162 |     if (!len)
163 |         return;
164 | 
165 |     usb_transfer_t *xfer_write = allocate(64);
166 |     xfer_write->callback = usb_write_cb;
167 |     xfer_write->context = this;
168 |     xfer_write->bEndpointAddress = ep_out->bEndpointAddress;
169 |     xfer_write->num_bytes = len;
170 |     memcpy(xfer_write->data_buffer, data, len);
171 | 
172 |     esp_err_t err = usb_host_transfer_submit(xfer_write);
173 |     if (err)
174 |     {
175 |         ESP_LOGW("", "test write data: 0x%02x", err);
176 |     }
177 | }
178 | 
179 | bool USBacmDevice::isConnected()
180 | {
181 |     return connected;
182 | }
183 | 
184 | void USBacmDevice::_callback(int event, usb_transfer_t *transfer)
185 | {
186 |     switch (event)
187 |     {
188 |     case CDC_DATA_IN:
189 |     case CDC_DATA_OUT:
190 |         break;
191 | 
192 |     default:
193 |         connected = true;
194 |         break;
195 |     }
196 |     if (event_cb)
197 |         event_cb(event, transfer->data_buffer, transfer->actual_num_bytes);
198 | }
199 | 


--------------------------------------------------------------------------------
/components/usb_host/host/usb_device.cpp:
--------------------------------------------------------------------------------
 1 | #include "esp_log.h"
 2 | #include "usb_device.hpp"
 3 | 
 4 | USBhostDevice::USBhostDevice()
 5 | {
 6 | }
 7 | 
 8 | USBhostDevice::~USBhostDevice()
 9 | {
10 | }
11 | 
12 | esp_err_t USBhostDevice::init(size_t len)
13 | {
14 |     esp_err_t err = usb_host_transfer_alloc(len, 0, &xfer_ctrl);
15 |     xfer_ctrl->device_handle = _host->deviceHandle();
16 |     xfer_ctrl->context = this;
17 |     xfer_ctrl->bEndpointAddress = 0;
18 | 
19 |     return err;
20 | }
21 | 
22 | IRAM_ATTR usb_transfer_t *USBhostDevice::allocate(size_t _size)
23 | {
24 |     usb_transfer_t *transfer = NULL;
25 | 
26 |     esp_err_t err = usb_host_transfer_alloc(_size, 0, &transfer);
27 |     if (!err)
28 |     {
29 |         transfer->device_handle = _host->deviceHandle();
30 |         transfer->context = this;
31 |     }
32 |     return transfer;
33 | }
34 | 
35 | IRAM_ATTR esp_err_t USBhostDevice::deallocate(usb_transfer_t *transfer)
36 | {
37 |     esp_err_t err = usb_host_transfer_free(transfer);
38 |     if (ESP_OK != err)
39 |     {
40 |         ESP_LOGE("", "deallocate free transfer : %d", err);
41 |     }
42 | 
43 |     return err;
44 | }
45 | 
46 | void USBhostDevice::onEvent(usb_host_event_cb_t _cb)
47 | {
48 |     event_cb = _cb;
49 | }
50 | 
51 | bool USBhostDevice::deinit()
52 | {
53 |     for (size_t n = 0; n < config_desc->bNumInterfaces; n++)
54 |     {
55 |         usb_host_interface_release(_host->clientHandle(), _host->deviceHandle(), n);
56 |     }
57 | 
58 |     return true;
59 | }
60 | 


--------------------------------------------------------------------------------
/components/usb_host/host/usb_host.cpp:
--------------------------------------------------------------------------------
  1 | #include "freertos/FreeRTOS.h"
  2 | #include "freertos/task.h"
  3 | #include "esp_log.h"
  4 | #include "usb/usb_host.h"
  5 | 
  6 | #include "usb_host.hpp"
  7 | 
  8 | void _client_event_callback(const usb_host_client_event_msg_t *event_msg, void *arg)
  9 | {
 10 |     USBhost *host = (USBhost *)arg;
 11 |     if (event_msg->event == USB_HOST_CLIENT_EVENT_NEW_DEV)
 12 |     {
 13 |         host->open(event_msg);
 14 |         ESP_LOGI("USB_HOST_CLIENT_EVENT_NEW_DEV", "client event: %d, address: %d", event_msg->event, event_msg->new_dev.address);
 15 |         if (host->_client_event_cb)
 16 |         {
 17 |             host->_client_event_cb(event_msg, arg);
 18 |         } else {
 19 |             
 20 |         }
 21 |     } else {
 22 |         ESP_LOGI("USB_HOST_CLIENT_EVENT_DEV_GONE", "client event: %d", event_msg->event);
 23 |         if (host->_client_event_cb)
 24 |         {
 25 |             host->_client_event_cb(event_msg, arg);
 26 |         }
 27 |         host->close();
 28 |     }
 29 | }
 30 | 
 31 | static void client_async_seq_task(void *param)
 32 | {
 33 |     USBhost* host = (USBhost *)param;
 34 |     printf("create async task\n");
 35 |     while (1)
 36 |     {
 37 |         usb_host_client_handle_t client_hdl = host->client_hdl;
 38 |         uint32_t event_flags;
 39 |         if(client_hdl)usb_host_client_handle_events(client_hdl, 1);
 40 |         if (ESP_OK == usb_host_lib_handle_events(1, &event_flags))
 41 |         {
 42 |             if (event_flags & USB_HOST_LIB_EVENT_FLAGS_NO_CLIENTS)
 43 |             {
 44 |                 ESP_LOGD("", "No more clients\n");
 45 |                 do{
 46 |                     if(usb_host_device_free_all() != ESP_ERR_NOT_FINISHED) break;
 47 |                 }while(1);
 48 |                 usb_host_uninstall();
 49 |                 host->init(false);
 50 |             }
 51 |             if (event_flags & USB_HOST_LIB_EVENT_FLAGS_ALL_FREE)
 52 |             {
 53 |                 ESP_LOGD("", "USB_HOST_LIB_EVENT_FLAGS_ALL_FREE\n");
 54 |                 usb_host_client_deregister(client_hdl);
 55 |                 host->client_hdl = NULL;
 56 |             }
 57 |         }
 58 |     }
 59 |     printf("delete task\n");
 60 |     vTaskDelete(NULL);
 61 | }
 62 | 
 63 | USBhost::USBhost()
 64 | {
 65 | }
 66 | 
 67 | USBhost::~USBhost()
 68 | {
 69 | }
 70 | 
 71 | bool USBhost::init(bool create_tasks)
 72 | {
 73 |     const usb_host_config_t config = {
 74 |         .intr_flags = ESP_INTR_FLAG_LEVEL1,
 75 |     };
 76 |     esp_err_t err = usb_host_install(&config);
 77 |     ESP_LOGI("", "install status: %d", err);
 78 | 
 79 |     const usb_host_client_config_t client_config = {
 80 |         .max_num_event_msg = 15,
 81 |         .async = {
 82 |             .client_event_callback = _client_event_callback,
 83 |             .callback_arg = this,
 84 |         }
 85 |     };
 86 | 
 87 |     err = usb_host_client_register(&client_config, &client_hdl);
 88 |     ESP_LOGI("", "client register status: %d", err);
 89 | 
 90 |     if (create_tasks)
 91 |     {
 92 |         xTaskCreate(client_async_seq_task, "async", 6 * 512, this, 20, NULL);
 93 |     }
 94 | 
 95 |     return true;
 96 | }
 97 | 
 98 | bool USBhost::open(const usb_host_client_event_msg_t *event_msg)
 99 | {
100 |     esp_err_t err = usb_host_device_open(client_hdl, event_msg->new_dev.address, &dev_hdl);
101 |     parseConfig();
102 | 
103 |     return true;
104 | }
105 | 
106 | void USBhost::close()
107 | {
108 |     usb_host_device_close(client_hdl, dev_hdl);
109 | }
110 | 
111 | void USBhost::parseConfig()
112 | {
113 |     const usb_device_desc_t *device_desc;
114 |     usb_host_get_device_descriptor(dev_hdl, &device_desc);
115 |     // ESP_LOG_BUFFER_HEX("", device_desc->val, USB_DEVICE_DESC_SIZE);
116 |     const usb_config_desc_t *config_desc;
117 |     usb_host_get_active_config_descriptor(dev_hdl, &config_desc);
118 | }
119 | 
120 | usb_device_info_t USBhost::getDeviceInfo()
121 | {
122 |     usb_host_device_info(dev_hdl, &dev_info);
123 | 
124 |     return dev_info;
125 | }
126 | 
127 | const usb_device_desc_t* USBhost::getDeviceDescriptor()
128 | {
129 |     const usb_device_desc_t *device_desc;
130 |     usb_host_get_device_descriptor(dev_hdl, &device_desc);
131 | 
132 |     return device_desc;
133 | }
134 | 
135 | const usb_config_desc_t* USBhost::getConfigurationDescriptor()
136 | {
137 |     const usb_config_desc_t *config_desc;
138 |     usb_host_get_active_config_descriptor(dev_hdl, &config_desc);
139 |     return config_desc;
140 | }
141 | 
142 | uint8_t USBhost::getConfiguration()
143 | {
144 |     return getDeviceInfo().bConfigurationValue;
145 | }
146 | 
147 | usb_host_client_handle_t USBhost::clientHandle()
148 | {
149 |     return client_hdl;
150 | }
151 | 
152 | usb_device_handle_t USBhost::deviceHandle()
153 | {
154 |     return dev_hdl;
155 | }
156 | 
157 | // bool USBhost::setConfiguration(uint8_t);
158 | 


--------------------------------------------------------------------------------
/components/usb_host/include/diskio_rawmsc.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string.h>
 4 | #include "diskio_impl.h"
 5 | #include "ffconf.h"
 6 | #include "ff.h"
 7 | #include "esp_log.h"
 8 | #include "diskio_rawflash.h"
 9 | #include "esp_compiler.h"
10 | 
11 | esp_err_t ff_msc_register_raw_partition(BYTE pdrv, USBmscDevice* part_handle);
12 | BYTE ff_msc_get_pdrv_raw(uint8_t lun);
13 | esp_err_t vfs_fat_rawmsc_mount(const char* base_path,
14 |     const esp_vfs_fat_mount_config_t* mount_config, uint8_t lun);
15 | 
16 | void vfs_fat_rawmsc_unmount(char *base_path, uint8_t lun);
17 | 


--------------------------------------------------------------------------------
/components/usb_host/include/usb_acm.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "usb_device.hpp"
 3 | #include "usb_requests.hpp"
 4 | 
 5 | #define CDC_DATA_IN                             1
 6 | #define CDC_DATA_OUT                            2
 7 | #define CDC_CTRL_SET_CONTROL_LINE_STATE         3
 8 | #define CDC_CTRL_SET_LINE_CODING                4
 9 | #define CDC_CTRL_GET_LINE_CODING                5
10 | 
11 | class USBacmDevice : public USBhostDevice
12 | {
13 |     friend void IRAM_ATTR usb_ctrl_cb(usb_transfer_t *transfer);
14 |     friend void IRAM_ATTR usb_read_cb(usb_transfer_t *transfer);
15 |     friend void IRAM_ATTR usb_write_cb(usb_transfer_t *transfer);
16 | 
17 | private:
18 |     const usb_ep_desc_t * ep_int;
19 |     const usb_ep_desc_t * ep_in;
20 |     const usb_ep_desc_t * ep_out;
21 |     bool connected;
22 | 
23 | public:
24 |     USBacmDevice(const usb_config_desc_t* config_desc, USBhost*);
25 |     ~USBacmDevice();
26 | 
27 |     bool init();
28 |     void setControlLine(bool dtr, bool rts);
29 |     void setLineCoding(uint32_t bitrate, uint8_t cf, uint8_t parity, uint8_t bits);
30 |     void getLineCoding();
31 |     void INDATA(size_t len = 64);
32 |     void OUTDATA(uint8_t*, size_t);
33 |     bool isConnected();
34 | 
35 | private:
36 |     void _callback(int event, usb_transfer_t* data);
37 | };
38 | 
39 | 


--------------------------------------------------------------------------------
/components/usb_host/include/usb_device.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "esp_err.h"
 3 | #include "usb/usb_host.h"
 4 | #include "usb_host.hpp"
 5 | 
 6 | typedef void (*usb_host_event_cb_t)(int, void* data, size_t len);
 7 | 
 8 | class USBhostDevice
 9 | {
10 | protected:
11 |     const usb_config_desc_t *config_desc;
12 |     uint8_t itf_num;
13 |     usb_host_event_cb_t event_cb = nullptr;
14 | 
15 |     usb_transfer_t *xfer_ctrl = NULL;   // every device have EP0
16 | 
17 | public:
18 |     USBhostDevice();
19 |     ~USBhostDevice();
20 | 
21 |     esp_err_t init(size_t len = 64);
22 |     usb_transfer_t * allocate(size_t);
23 |     esp_err_t deallocate(usb_transfer_t *);    
24 |     void onEvent(usb_host_event_cb_t _cb);
25 |     USBhost* _host;
26 |     bool deinit();
27 | };
28 | 
29 | 


--------------------------------------------------------------------------------
/components/usb_host/include/usb_host.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "usb/usb_host.h"
 3 | 
 4 | class USBhost
 5 | {
 6 |     friend void _client_event_callback(const usb_host_client_event_msg_t *event_msg, void *arg);
 7 | 
 8 | protected:
 9 |     usb_device_info_t dev_info;
10 |     
11 |     usb_device_handle_t dev_hdl;
12 |     
13 |     usb_host_client_event_cb_t _client_event_cb = nullptr;
14 |     uint8_t _dev_addr;
15 |     uint8_t _configs;
16 |     uint8_t _itfs;
17 | 
18 | public:
19 |     USBhost();
20 |     ~USBhost();
21 | 
22 |     usb_host_client_handle_t client_hdl;
23 |     bool init(bool create_tasks = true);
24 |     bool open(const usb_host_client_event_msg_t *event_msg);
25 |     void close();
26 |     usb_device_info_t getDeviceInfo();
27 |     const usb_device_desc_t* getDeviceDescriptor();
28 |     const usb_config_desc_t* getConfigurationDescriptor();
29 | 
30 |     uint8_t getConfiguration();
31 |     bool setConfiguration(uint8_t);
32 |     void parseConfig();
33 | 
34 |     usb_host_client_handle_t clientHandle();
35 |     usb_device_handle_t deviceHandle();
36 |     
37 |     void registerClientCb(usb_host_client_event_cb_t cb) { _client_event_cb = cb; }
38 | 
39 | };
40 | 


--------------------------------------------------------------------------------
/components/usb_host/include/usb_msc.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "freertos/FreeRTOS.h"
 3 | #include "freertos/task.h"
 4 | #include "freertos/semphr.h"
 5 | #include "usb_device.hpp"
 6 | #include "usb_requests.hpp"
 7 | 
 8 | typedef int host_event_t;
 9 | 
10 | class USBmscDevice : public USBhostDevice
11 | {
12 |     friend void usb_transfer_cb(usb_transfer_t *transfer);
13 | 
14 | private:
15 |     const usb_ep_desc_t * ep_in;
16 |     const usb_ep_desc_t * ep_out;
17 |     
18 |     uint8_t* temp_buffer;               // pointer to buffer in read10, write10
19 | 
20 |     bool _in = false;
21 |     TaskHandle_t xTaskToNotify = NULL;  // notify 
22 |     uint32_t block_count[4];
23 |     uint32_t block_size[4] = {4096};
24 |     uint8_t _luns;                  // max lun number
25 |     uint8_t _lun;                   // current handled lun
26 |     int event = -1;                 // current handled event
27 | 
28 |     static USBmscDevice* instance;      // class is treat as singleton, it is used in ff_vfs
29 |     msc_transfer_cb_t callbacks = {};   // user callbacks
30 | 
31 | public:
32 |     static USBmscDevice* getInstance();
33 |     USBmscDevice(const usb_config_desc_t* config_desc, USBhost*);
34 |     ~USBmscDevice();
35 | 
36 |     bool            init();
37 |     bool            mount(char*, uint8_t lun = 0);
38 |     void            unmount(char *path, uint8_t lun = 0);
39 |     void            getDrivePath(char* path, uint8_t lun = 0);
40 |     uint8_t         getMaxLUN();
41 |     uint32_t        getBlockCount(uint8_t lun = 0);
42 |     uint16_t        getBlockSize(uint8_t lun = 0);
43 |     void            registerCallbacks(msc_transfer_cb_t);
44 |     void            reset();
45 |     void            format();
46 | 
47 | public: // POSIX
48 | 
49 |     // int  open(char* name);
50 |     // void close(int);
51 |     // void read(char* name, uint8_t* buffer, size_t len);
52 |     // void write(char* name, uint8_t* buffer, size_t len);
53 |     // void delete(char* name);
54 | 
55 | 
56 | public: // public to use from ff_diskio
57 |     esp_err_t _read10 (uint8_t lun, int offset, int num_sectors, uint8_t* buff);
58 |     esp_err_t _write10(uint8_t lun, int offset, int num_sectors, uint8_t* buff);
59 | 
60 | private:
61 |     void _inquiry();
62 |     esp_err_t _unitReady();
63 |     void _getCapacity(uint8_t);
64 |     void _setCapacity(uint32_t, uint32_t);
65 |     void _emitEvent(host_event_t event, usb_transfer_t* data);
66 |     void _getMaxLUN();
67 |     void _csw();
68 | 
69 | private: // internal callbacks
70 |     void onCSW(usb_transfer_t *transfer);
71 |     void onCBW(usb_transfer_t *transfer);
72 |     void onData(usb_transfer_t *transfer);
73 | };
74 | 
75 | 


--------------------------------------------------------------------------------
/components/usb_host/include/usb_requests.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #define SET_VALUE       0x21
  4 | #define GET_VALUE       0xA1
  5 | 
  6 | // DTR/RTS control in SET_CONTROL_LINE_STATE
  7 | #define ENABLE_DTR(val)      (val<<0)
  8 | #define ENABLE_RTS(val)      (val<<1)
  9 | 
 10 | #define SET_LINE_CODING 0x20
 11 | #define GET_LINE_CODING 0x21
 12 | #define SET_CONTROL_LINE_STATE 0x22
 13 | // #define SERIAL_STATE    0x20
 14 | 
 15 | #define MSC_SCSI_REQ_INIT_RESET(setup_pkt_ptr, intf_num) ({  \
 16 |     (setup_pkt_ptr)->bmRequestType = USB_BM_REQUEST_TYPE_DIR_OUT | USB_BM_REQUEST_TYPE_TYPE_CLASS | USB_BM_REQUEST_TYPE_RECIP_INTERFACE; \
 17 |     (setup_pkt_ptr)->bRequest = 0xFF;    \
 18 |     (setup_pkt_ptr)->wValue = 0; \
 19 |     (setup_pkt_ptr)->wIndex = (intf_num);    \
 20 |     (setup_pkt_ptr)->wLength = 0;    \
 21 | })
 22 | 
 23 | #define MSC_SCSI_REQ_MAX_LUN(setup_pkt_ptr, intf_num) ({  \
 24 |     (setup_pkt_ptr)->bmRequestType = USB_BM_REQUEST_TYPE_DIR_IN | USB_BM_REQUEST_TYPE_TYPE_CLASS | USB_BM_REQUEST_TYPE_RECIP_INTERFACE; \
 25 |     (setup_pkt_ptr)->bRequest = 0xFE;    \
 26 |     (setup_pkt_ptr)->wValue = 0; \
 27 |     (setup_pkt_ptr)->wIndex = (intf_num);    \
 28 |     (setup_pkt_ptr)->wLength = 1;    \
 29 | })
 30 | 
 31 | /**
 32 |  * @brief 
 33 |  *
 34 |  */
 35 | #define USB_CTRL_REQ_CDC_SET_LINE_CODING(ctrl_req_ptr, index, bitrate, cf, parity, bits) ({  \
 36 |     (ctrl_req_ptr)->bmRequestType = SET_VALUE;   \
 37 |     (ctrl_req_ptr)->bRequest = SET_LINE_CODING;  \
 38 |     (ctrl_req_ptr)->wValue = 0;   \
 39 |     (ctrl_req_ptr)->wIndex = (index);    \
 40 |     (ctrl_req_ptr)->wLength = (7);   \
 41 | })
 42 | 
 43 | #define USB_CTRL_REQ_CDC_GET_LINE_CODING(ctrl_req_ptr, index) ({  \
 44 |     (ctrl_req_ptr)->bmRequestType = GET_VALUE;   \
 45 |     (ctrl_req_ptr)->bRequest = GET_LINE_CODING;  \
 46 |     (ctrl_req_ptr)->wValue = 0;   \
 47 |     (ctrl_req_ptr)->wIndex = (index);    \
 48 |     (ctrl_req_ptr)->wLength = (7);   \
 49 | })
 50 | 
 51 | #define USB_CTRL_REQ_CDC_SET_CONTROL_LINE_STATE(ctrl_req_ptr, index, dtr, rts) ({  \
 52 |     (ctrl_req_ptr)->bmRequestType = SET_VALUE;   \
 53 |     (ctrl_req_ptr)->bRequest = SET_CONTROL_LINE_STATE;  \
 54 |     (ctrl_req_ptr)->wValue = ENABLE_DTR(dtr) | ENABLE_RTS(rts);   \
 55 |     (ctrl_req_ptr)->wIndex = (index);    \
 56 |     (ctrl_req_ptr)->wLength = (0);   \
 57 | })
 58 | 
 59 | #define MSC_SCSI_INIT_CBW(cbw, is_read, lun, tag, cmd, len)({  \
 60 |     (cbw)->dCBWSignature = 0x43425355;  \
 61 |     (cbw)->dCBWTag = tag;  \
 62 |     (cbw)->dCBWDataTransferLength = len;  \
 63 |     (cbw)->bmCBWFlags = (is_read) ? (1 << 7) : 0;   \
 64 |     (cbw)->bCBWLUN = lun;  \
 65 |     (cbw)->bCBWCBLength = 10;  \
 66 |     (cbw)->CBWCB = cmd;  \
 67 | })
 68 | 
 69 | /// SCSI Command Operation Code
 70 | typedef enum
 71 | {
 72 |   SCSI_CMD_TEST_UNIT_READY              = 0x00, ///< The SCSI Test Unit Ready command is used to determine if a device is ready to transfer data (read/write), i.e. if a disk has spun up, if a tape is loaded and ready etc. The device does not perform a self-test operation.
 73 |   SCSI_CMD_MAX_LUN                      = 0x01, ///< The SCSI Test Unit Ready command is used to determine if a device is ready to transfer data (read/write), i.e. if a disk has spun up, if a tape is loaded and ready etc. The device does not perform a self-test operation.
 74 |   SCSI_CMD_FORMAT_UNIT                  = 0x04, ///
 75 |   SCSI_CMD_INQUIRY                      = 0x12, ///< The SCSI Inquiry command is used to obtain basic information from a target device.
 76 |   SCSI_CMD_MODE_SELECT_6                = 0x15, ///<  provides a means for the application client to specify medium, logical unit, or peripheral device parameters to the device server. Device servers that implement the MODE SELECT(6) command shall also implement the MODE SENSE(6) command. Application clients should issue MODE SENSE(6) prior to each MODE SELECT(6) to determine supported mode pages, page lengths, and other parameters.
 77 |   SCSI_CMD_MODE_SENSE_6                 = 0x1A, ///< provides a means for a device server to report parameters to an application client. It is a complementary command to the MODE SELECT(6) command. Device servers that implement the MODE SENSE(6) command shall also implement the MODE SELECT(6) command.
 78 |   SCSI_CMD_START_STOP_UNIT              = 0x1B,
 79 |   SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL = 0x1E,
 80 |   SCSI_CMD_READ_CAPACITY_10             = 0x25, ///< The SCSI Read Capacity command is used to obtain data capacity information from a target device.
 81 |   SCSI_CMD_REQUEST_SENSE                = 0x03, ///< The SCSI Request Sense command is part of the SCSI computer protocol standard. This command is used to obtain sense data -- status/error information -- from a target device.
 82 |   SCSI_CMD_READ_FORMAT_CAPACITY         = 0x23, ///< The command allows the Host to request a list of the possible format capacities for an installed writable media. This command also has the capability to report the writable capacity for a media when it is installed
 83 |   SCSI_CMD_READ_10                      = 0x28, ///< The READ (10) command requests that the device server read the specified logical block(s) and transfer them to the data-in buffer.
 84 |   SCSI_CMD_WRITE_10                     = 0x2A, ///< The WRITE (10) command requests thatthe device server transfer the specified logical block(s) from the data-out buffer and write them.
 85 | }scsi_cmd_type_t;
 86 | 
 87 | typedef struct __attribute__((packed)) {
 88 |     uint8_t opcode; //0x28 = read(10), 0x2A=write(10)
 89 |     uint8_t flags;
 90 |     uint8_t lba_3;
 91 |     uint8_t lba_2;
 92 |     uint8_t lba_1;
 93 |     uint8_t lba_0;
 94 |     uint8_t group;
 95 |     uint8_t len_1;
 96 |     uint8_t len_0;
 97 |     uint8_t control;
 98 | } scsi_cmd10_t;
 99 | 
100 | typedef struct __attribute__((packed)) {
101 |     uint32_t dCBWSignature;
102 |     uint32_t dCBWTag;
103 |     uint32_t dCBWDataTransferLength;
104 |     uint8_t bmCBWFlags;
105 |     uint8_t bCBWLUN;
106 |     uint8_t bCBWCBLength;
107 |     scsi_cmd10_t CBWCB;
108 |     uint8_t padding[6];
109 | } msc_bulk_cbw_t;
110 | 
111 | // USB Bulk Transfer Command Status Wrapper data
112 | typedef struct __attribute__((packed)) {
113 |     uint32_t dCSWSignature;
114 |     uint32_t dCSWTag;
115 |     uint32_t dCSWDataResidue;
116 |     uint8_t bCSWStatus;
117 | } msc_bulk_csw_t;
118 | 
119 | typedef struct {
120 |     usb_transfer_cb_t cbw_cb;
121 |     usb_transfer_cb_t data_cb;
122 |     usb_transfer_cb_t csw_cb;
123 |     usb_transfer_cb_t capacity_cb;
124 |     usb_transfer_cb_t inquiry_cb;
125 |     usb_transfer_cb_t unit_ready_cb;
126 |     usb_transfer_cb_t max_luns_cb;
127 |     usb_transfer_cb_t sense_cb;
128 | } msc_transfer_cb_t;
129 | 
130 | typedef struct{
131 |     uint32_t dwDTERate;
132 |     uint8_t bCharFormat;
133 |     uint8_t bParityType;
134 |     uint8_t bDataBits;
135 | }line_coding_t;
136 | 
137 | 


--------------------------------------------------------------------------------
/components/usb_host/msc/usb_msc.cpp:
--------------------------------------------------------------------------------
  1 | #include "freertos/FreeRTOS.h"
  2 | #include "freertos/task.h"
  3 | #include "esp_log.h"
  4 | #include "esp_vfs_fat.h"
  5 | #include <string.h>
  6 | 
  7 | #include "usb_msc.hpp"
  8 | #include "diskio_rawmsc.hpp"
  9 | #include "usb_requests.hpp"
 10 | 
 11 | void IRAM_ATTR usb_transfer_cb(usb_transfer_t *transfer)
 12 | {
 13 |     ESP_LOGW("STATUS", "status: %d, bytes: %d", transfer->status, transfer->actual_num_bytes);
 14 |     ESP_LOG_BUFFER_HEX("HEX_DATA", transfer->data_buffer, transfer->actual_num_bytes);
 15 | 
 16 |     USBmscDevice *dev = (USBmscDevice *)transfer->context;
 17 | 
 18 |     if (dev && transfer->actual_num_bytes == 9 && *(uint16_t *)transfer->data_buffer == 0xfea1) // max luns
 19 |     {
 20 |         dev->onCSW(transfer);
 21 |     }
 22 |     else if (dev && transfer->actual_num_bytes == 31 && *(uint32_t *)transfer->data_buffer == 0x43425355) // CBW
 23 |     {
 24 |         dev->onCBW(transfer);
 25 |     }
 26 |     else if (dev && transfer->actual_num_bytes == 13 && *(uint32_t *)transfer->data_buffer == 0x53425355) // CSW
 27 |     {
 28 |         dev->onCSW(transfer);
 29 |     }
 30 |     else
 31 |     {
 32 |         dev->onData(transfer);
 33 |         ESP_LOG_BUFFER_HEX("DATA", transfer->data_buffer, transfer->actual_num_bytes);
 34 |     }
 35 |     dev->deallocate(transfer);
 36 | }
 37 | 
 38 | USBmscDevice *USBmscDevice::instance = nullptr;
 39 | 
 40 | USBmscDevice *USBmscDevice::getInstance()
 41 | {
 42 |     return instance;
 43 | }
 44 | 
 45 | USBmscDevice::USBmscDevice(const usb_config_desc_t *_config_desc, USBhost *host)
 46 | {
 47 |     esp_log_level_set("STATUS", ESP_LOG_ERROR);
 48 |     esp_log_level_set("EMIT", ESP_LOG_ERROR);
 49 |     esp_log_level_set("HEX", ESP_LOG_ERROR);
 50 |     esp_log_level_set("HEX_DATA", ESP_LOG_ERROR);
 51 |     esp_log_level_set("DATA", ESP_LOG_ERROR);
 52 | 
 53 |     _host = host;
 54 |     config_desc = _config_desc;
 55 |     int offset = 0;
 56 |     for (size_t n = 0; n < config_desc->bNumInterfaces; n++)
 57 |     {
 58 |         const usb_intf_desc_t *intf = usb_parse_interface_descriptor(config_desc, n, 0, &offset);
 59 |         const usb_ep_desc_t *ep = nullptr;
 60 | 
 61 |         if (intf->bInterfaceClass == 0x08)
 62 |         {
 63 |             if (intf->bNumEndpoints != 2)
 64 |                 return;
 65 |             // ESP_LOGI("", "EP MSC.");
 66 |             for (size_t i = 0; i < intf->bNumEndpoints; i++)
 67 |             {
 68 |                 int _offset = 0;
 69 |                 ep = usb_parse_endpoint_descriptor_by_index(intf, i, config_desc->wTotalLength, &_offset);
 70 |                 if (ep->bEndpointAddress & 0x80)
 71 |                 {
 72 |                     ep_in = ep;
 73 |                 }
 74 |                 else
 75 |                 {
 76 |                     ep_out = ep;
 77 |                 }
 78 | 
 79 |                 if (ep)
 80 |                 {
 81 |                     printf("EP num: %d/%d, len: %d, ", i + 1, intf->bNumEndpoints, config_desc->wTotalLength);
 82 |                     printf("address: 0x%02x, EP max size: %d, dir: %s\n", ep->bEndpointAddress, ep->wMaxPacketSize, (ep->bEndpointAddress & 0x80) ? "IN" : "OUT");
 83 |                 }
 84 |                 else
 85 |                     ESP_LOGW("", "error to parse endpoint by index; EP num: %d/%d, len: %d", i + 1, intf->bNumEndpoints, config_desc->wTotalLength);
 86 |             }
 87 |             itf_num = n;
 88 |             esp_err_t err = usb_host_interface_claim(_host->clientHandle(), _host->deviceHandle(), itf_num, 0);
 89 |             ESP_LOGI("", "interface %d claim status: %d", itf_num, err);
 90 |         }
 91 |     }
 92 |     instance = this;
 93 | }
 94 | 
 95 | USBmscDevice::~USBmscDevice()
 96 | {
 97 |     // TODO
 98 |     // deallocate(xfer_ctrl);
 99 | }
100 | 
101 | bool USBmscDevice::init()
102 | {
103 |     usb_device_info_t info = _host->getDeviceInfo();
104 |     USBhostDevice::init(info.bMaxPacketSize0);
105 |     xfer_ctrl->callback = usb_transfer_cb;
106 | 
107 |     _getMaxLUN();
108 |     return true;
109 | }
110 | 
111 | bool USBmscDevice::mount(char *path, uint8_t lun)
112 | {
113 |     if(lun > _luns) return false;
114 |     const esp_vfs_fat_mount_config_t mount_config = {
115 |         .format_if_mount_failed = false,
116 |         .max_files = 1,
117 |         .allocation_unit_size = block_size[lun]};
118 |     esp_err_t err = vfs_fat_rawmsc_mount(path, &mount_config, lun);
119 |     ESP_LOGI("", "VFS mount status: %d", err);
120 | 
121 |     return err == ESP_OK;
122 | }
123 | 
124 | void USBmscDevice::unmount(char *path, uint8_t lun)
125 | {
126 |     vfs_fat_rawmsc_unmount(path, lun);
127 | }
128 | 
129 | void USBmscDevice::getDrivePath(char* path, uint8_t lun)
130 | {
131 |     int8_t vol = ff_msc_get_pdrv_raw(lun);
132 |     if(vol >= 0)
133 |         sprintf(path, "%d:", vol);
134 | }
135 | 
136 | uint8_t USBmscDevice::getMaxLUN()
137 | {
138 |     return _luns;
139 | }
140 | 
141 | uint32_t USBmscDevice::getBlockCount(uint8_t lun)
142 | {
143 |     return block_count[lun];
144 | }
145 | 
146 | uint16_t USBmscDevice::getBlockSize(uint8_t lun)
147 | {
148 |     return block_size[lun];
149 | }
150 | 
151 | void USBmscDevice::registerCallbacks(msc_transfer_cb_t cb)
152 | {
153 |     callbacks = cb;
154 | }
155 | 
156 | void USBmscDevice::reset()
157 | {
158 |     event = 2;  // our own event value
159 |     MSC_SCSI_REQ_INIT_RESET((usb_setup_packet_t *)xfer_ctrl->data_buffer, itf_num);
160 |     xfer_ctrl->num_bytes = sizeof(usb_setup_packet_t);
161 |     esp_err_t err = usb_host_transfer_submit_control(_host->clientHandle(), xfer_ctrl);
162 | }
163 | 
164 | // TODO
165 | void USBmscDevice::format()
166 | {
167 |     /*
168 |     scsi_cmd10_t cbw = {};
169 |     cbw.opcode = SCSI_CMD_FORMAT_UNIT;
170 |     // cbw.flags = _lun | 0xE8;
171 |     // cbw.lba_3 = (offset >> 24);
172 |     // cbw.lba_2 = (offset >> 16);
173 |     // cbw.lba_1 = (offset >> 8);
174 |     // cbw.lba_0 = (offset >> 0);
175 |     // cbw.group = 0;
176 |     // cbw.len_1 = (num_sectors >> 8);
177 |     // cbw.len_0 = (num_sectors >> 0);
178 |     // cbw.control = 0;
179 |     event = cbw.opcode;
180 | 
181 |     MSC_SCSI_INIT_CBW((msc_bulk_cbw_t *)xfer_out->data_buffer, true, _lun, 0x1234, cbw, 8);
182 | 
183 |     xfer_out->num_bytes = sizeof(msc_bulk_cbw_t);
184 | 
185 |     esp_err_t err = usb_host_transfer_submit(xfer_out);
186 |     printf("test capacity: 0x%02x => 0x%02x\n", err, xfer_out->bEndpointAddress);
187 |     _csw();
188 |     */
189 | }
190 | 
191 | //------------------------------------- ff_diskio ---------------------------------//
192 | 
193 | esp_err_t USBmscDevice::_read10(uint8_t lun, int offset, int num_sectors, uint8_t *buff)
194 | {
195 |     temp_buffer = buff;
196 |     scsi_cmd10_t cbw = {};
197 |     cbw.opcode = SCSI_CMD_READ_10;
198 |     cbw.flags = 0;
199 |     cbw.lba_3 = (offset >> 24);
200 |     cbw.lba_2 = (offset >> 16);
201 |     cbw.lba_1 = (offset >> 8);
202 |     cbw.lba_0 = (offset >> 0);
203 |     cbw.group = 0;
204 |     cbw.len_1 = (num_sectors >> 8);
205 |     cbw.len_0 = (num_sectors >> 0);
206 |     cbw.control = 0;
207 | 
208 |     event = cbw.opcode;
209 | 
210 |     usb_transfer_t *xfer_read = allocate(num_sectors * block_size[lun]);
211 |     if (!xfer_read)
212 |     {
213 |         return ESP_ERR_NO_MEM;
214 |     }
215 |     
216 |     xfer_read->callback = usb_transfer_cb;
217 |     xfer_read->bEndpointAddress = ep_out->bEndpointAddress;
218 |     xfer_read->num_bytes = sizeof(msc_bulk_cbw_t);
219 |     MSC_SCSI_INIT_CBW((msc_bulk_cbw_t *)xfer_read->data_buffer, true /*is_read*/, lun, 0x1234, cbw, num_sectors * block_size[lun]);
220 | 
221 |     esp_err_t err = usb_host_transfer_submit(xfer_read);
222 |     _csw();
223 |     // TODO fix this workaround
224 |     if (err == 0x103){
225 |         ESP_LOGW("", "test read10: 0x%02x => 0x%02x, sector: %d [%d][%d]\n", err, xfer_read->bEndpointAddress, offset, *(uint32_t *)&cbw.lba_3, __builtin_bswap32(*(uint32_t *)&cbw.lba_3));
226 |         vTaskDelay(1);
227 |         deallocate(xfer_read);
228 |         err = _read10(lun, offset, num_sectors, buff);
229 |     }
230 |     else
231 |     {
232 |         xTaskToNotify = xTaskGetCurrentTaskHandle();
233 |         uint32_t pulNotificationValue;
234 |         if (xTaskNotifyWait(0, 0, &pulNotificationValue, 20 / portTICK_PERIOD_MS) == pdTRUE)
235 |         {
236 |             return ESP_OK;
237 |         } else
238 | 
239 |         err = ESP_ERR_TIMEOUT;
240 |         ESP_LOGE("", "test write10 data: 0x%02x", err);
241 |     }
242 | 
243 |     return err;
244 | }
245 | 
246 | esp_err_t USBmscDevice::_write10(uint8_t lun, int offset, int num_sectors, uint8_t *buff)
247 | {
248 | 
249 |     scsi_cmd10_t cbw;
250 |     cbw.opcode = SCSI_CMD_WRITE_10;
251 |     cbw.flags = 0;
252 |     cbw.lba_3 = (offset >> 24);
253 |     cbw.lba_2 = (offset >> 16);
254 |     cbw.lba_1 = (offset >> 8);
255 |     cbw.lba_0 = (offset >> 0);
256 |     cbw.group = 0;
257 |     cbw.len_1 = (num_sectors >> 8);
258 |     cbw.len_0 = (num_sectors >> 0);
259 |     cbw.control = 0;
260 | 
261 |     event = cbw.opcode;
262 | 
263 |     usb_transfer_t *xfer_write = allocate(sizeof(msc_bulk_cbw_t));
264 |     if (!xfer_write)
265 |     {
266 |         return ESP_ERR_NO_MEM;
267 |     }
268 |     
269 |     xfer_write->callback = usb_transfer_cb;
270 |     xfer_write->bEndpointAddress = ep_out->bEndpointAddress;
271 | 
272 |     MSC_SCSI_INIT_CBW((msc_bulk_cbw_t *)xfer_write->data_buffer, false /*is_read*/, lun, 0x1234, cbw, block_size[_lun] * num_sectors);
273 | 
274 |     xfer_write->num_bytes = sizeof(msc_bulk_cbw_t);
275 | 
276 |     esp_err_t err = usb_host_transfer_submit(xfer_write);
277 |     if (err){
278 |         ESP_LOGW("", "test write10: 0x%02x => 0x%02x, sector: %d [%d][%d]", err, xfer_write->bEndpointAddress, offset, *(uint32_t *)&cbw.lba_3, __builtin_bswap32(*(uint32_t *)&cbw.lba_3));
279 |         deallocate(xfer_write);
280 |         return -1;
281 |     }
282 | 
283 |     usb_transfer_t *xfer_read = allocate(num_sectors * block_size[lun]);
284 |     if (!xfer_read)
285 |     {
286 |         return ESP_ERR_NO_MEM;
287 |     }
288 | 
289 |     xfer_read->callback = usb_transfer_cb;
290 |     xfer_read->bEndpointAddress = ep_out->bEndpointAddress;
291 |     xfer_read->num_bytes = block_size[_lun] * num_sectors;
292 |     memcpy(xfer_read->data_buffer, buff, xfer_read->num_bytes);
293 | 
294 |     err = usb_host_transfer_submit(xfer_read);
295 |     if (err)
296 |     {
297 |         deallocate(xfer_read);
298 |         ESP_LOGW("", "test write10 data: 0x%02x", err);
299 |         _csw();
300 |     }
301 |     else
302 |     {
303 |         xTaskToNotify = xTaskGetCurrentTaskHandle();
304 |         uint32_t pulNotificationValue;
305 |         _csw();
306 |         if (xTaskNotifyWait(0, 0, &pulNotificationValue, 50 / portTICK_PERIOD_MS) == pdTRUE)
307 |         {
308 |             return ESP_OK;
309 |         }
310 | 
311 |         err = ESP_ERR_TIMEOUT;
312 |         ESP_LOGE("", "test write10 data: 0x%02x", err);
313 |     }
314 |     return err;
315 | }
316 | 
317 | //-------------------------------------- Private ----------------------------------//
318 | 
319 | void USBmscDevice::_emitEvent(host_event_t _event, usb_transfer_t *transfer)
320 | {
321 |     switch (_event)
322 |     {
323 |     case SCSI_CMD_MAX_LUN:
324 |         ESP_LOGI("EMIT", "%s", "SCSI_CMD_MAX_LUN");
325 |         _luns = transfer->data_buffer[8];
326 |         _lun = 0;
327 |         _getCapacity(_lun);
328 | 
329 |         if (callbacks.max_luns_cb)
330 |         {
331 |             callbacks.max_luns_cb(transfer);
332 |         }
333 |         if (event_cb)
334 |             event_cb(event, transfer->data_buffer, transfer->actual_num_bytes);
335 |         break;
336 |     case SCSI_CMD_TEST_UNIT_READY:
337 |         ESP_LOGI("EMIT", "%s", "SCSI_CMD_TEST_UNIT_READY");
338 |         // ets_delay_us(500);
339 |         if (xTaskToNotify)
340 |             xTaskNotify(xTaskToNotify, 0, eNoAction);
341 |         break;
342 |     case SCSI_CMD_INQUIRY:
343 |         ESP_LOG_BUFFER_HEX("EMIT", transfer->data_buffer, transfer->actual_num_bytes);
344 | 
345 |         if (callbacks.inquiry_cb)
346 |         {
347 |             callbacks.inquiry_cb(transfer);
348 |         }
349 |         break;
350 |     case SCSI_CMD_READ_CAPACITY_10:
351 |     {
352 |         ESP_LOGI("EMIT", "%s", "SCSI_CMD_READ_CAPACITY_10");
353 |         if (_lun < _luns) // all LUNS get capacity at first
354 |         {
355 |             _getCapacity(++_lun);
356 |         }
357 |         else  // then INQUIRY
358 |         {
359 |             _inquiry();
360 |             if (callbacks.capacity_cb)
361 |             {
362 |                 callbacks.capacity_cb(transfer);
363 |             }
364 |             if (event_cb)
365 |                 event_cb(event, transfer->data_buffer, transfer->actual_num_bytes);
366 |         }
367 |     }
368 |     break;
369 |     case SCSI_CMD_WRITE_10:
370 |         ESP_LOGI("EMIT", "%s", "SCSI_CMD_WRITE_10");
371 |         // ets_delay_us(500);
372 |         if (xTaskToNotify)
373 |             xTaskNotify(xTaskToNotify, 0, eNoAction);
374 |         break;
375 |     case SCSI_CMD_READ_10:
376 |         ESP_LOGI("EMIT", "%s", "SCSI_CMD_READ_10");
377 |         if (xTaskToNotify)
378 |             xTaskNotify(xTaskToNotify, 0, eNoAction);
379 |         break;
380 | 
381 |     default:
382 |         ESP_LOGW("EMIT", "%d", _event);
383 |         break;
384 |     }
385 | }
386 | 
387 | void USBmscDevice::_getMaxLUN()
388 | {
389 |     event = SCSI_CMD_MAX_LUN;
390 |     MSC_SCSI_REQ_MAX_LUN((usb_setup_packet_t *)xfer_ctrl->data_buffer, itf_num);
391 |     xfer_ctrl->num_bytes = sizeof(usb_setup_packet_t) + ((usb_setup_packet_t *)xfer_ctrl->data_buffer)->wLength;
392 |     esp_err_t err = usb_host_transfer_submit_control(_host->clientHandle(), xfer_ctrl);
393 |     (void) err;
394 | }
395 | 
396 | void USBmscDevice::_getCapacity(uint8_t lun)
397 | {
398 |     _lun = lun;
399 |     scsi_cmd10_t cbw = {};
400 |     cbw.opcode = SCSI_CMD_READ_CAPACITY_10;
401 |     event = cbw.opcode;
402 |     usb_transfer_t* xfer_out = allocate(64);
403 | 
404 |     xfer_out->callback = usb_transfer_cb;
405 |     xfer_out->bEndpointAddress = ep_out->bEndpointAddress;
406 |     xfer_out->num_bytes = sizeof(msc_bulk_cbw_t);
407 | 
408 |     MSC_SCSI_INIT_CBW((msc_bulk_cbw_t *)xfer_out->data_buffer, true /*is_read*/, lun, 0x1234, cbw, 8);
409 |     esp_err_t err = usb_host_transfer_submit(xfer_out);
410 |     if (err)
411 |         ESP_LOGW("", "test capacity: 0x%02x => 0x%02x\n", err, xfer_out->bEndpointAddress);
412 | 
413 |     _csw();
414 | }
415 | 
416 | void USBmscDevice::_setCapacity(uint32_t count, uint32_t _size)
417 | {
418 |     block_count[_lun] = count;
419 |     block_size[_lun] = _size;
420 |     ESP_LOGI("", "capacity => lun: %d count %d, size: %d", _lun, block_count[_lun], block_size[_lun]);
421 |     _csw();
422 | }
423 | 
424 | void USBmscDevice::_csw()
425 | {
426 |     usb_transfer_t *transfer = allocate(block_size[0]);
427 |     if(transfer){
428 |         transfer->callback = usb_transfer_cb;
429 |         transfer->bEndpointAddress = ep_in->bEndpointAddress;
430 |         transfer->num_bytes = block_size[0];
431 | 
432 |         esp_err_t err = usb_host_transfer_submit(transfer);
433 |         if(err)usb_host_transfer_free(transfer);
434 |     } else {
435 |         ESP_LOGE("", "faile to allocate CSW transfer");
436 |     }
437 | }
438 | 
439 | void USBmscDevice::onCSW(usb_transfer_t *transfer)
440 | {
441 |     _emitEvent(event, transfer);
442 | 
443 |     if (callbacks.csw_cb)
444 |     {
445 |         callbacks.csw_cb(transfer);
446 |     }
447 |     // deallocate(transfer);
448 | }
449 | 
450 | void USBmscDevice::onCBW(usb_transfer_t *transfer)
451 | {
452 |     ESP_LOG_BUFFER_HEX("HEX", transfer->data_buffer, transfer->actual_num_bytes);
453 |     if (callbacks.cbw_cb)
454 |     {
455 |         callbacks.cbw_cb(transfer);
456 |     }
457 |     // deallocate(transfer);
458 | }
459 | 
460 | void USBmscDevice::onData(usb_transfer_t *transfer)
461 | {
462 |     switch (event)
463 |     {
464 |     case SCSI_CMD_INQUIRY:
465 |     {
466 |         ESP_LOG_BUFFER_HEX("HEX", transfer->data_buffer, transfer->actual_num_bytes);
467 |         _csw();
468 |     }
469 |     break;
470 |     case SCSI_CMD_READ_10:
471 |     {
472 |         memcpy(temp_buffer, transfer->data_buffer, block_size[_lun]);
473 |         _csw();
474 |     }
475 |     break;
476 |     case SCSI_CMD_WRITE_10:
477 |         break;
478 |     case SCSI_CMD_READ_CAPACITY_10:
479 |     {
480 |         uint32_t block_count = __builtin_bswap32(*(uint32_t *)&transfer->data_buffer[0]);
481 |         uint32_t block_size = __builtin_bswap32(*(uint32_t *)&transfer->data_buffer[4]);
482 | 
483 |         _setCapacity(block_count, block_size);
484 |     }
485 |     break;
486 | 
487 |     default:
488 |     {
489 |         ESP_LOGE("", "event: %d", event);
490 |         ESP_LOG_BUFFER_HEX("HEX", transfer->data_buffer, 16);
491 |     }
492 |     break;
493 |     }
494 | 
495 |     if (callbacks.data_cb)
496 |     {
497 |         callbacks.data_cb(transfer);
498 |     }
499 | 
500 |     if (event_cb)
501 |         event_cb(event, transfer->data_buffer, transfer->actual_num_bytes);
502 |     // deallocate(transfer);
503 | }
504 | 
505 | // FIXME the same as a write10
506 | esp_err_t USBmscDevice::_unitReady()
507 | {
508 |     /*
509 |     scsi_cmd10_t cbw = {};
510 |     cbw.opcode = SCSI_CMD_TEST_UNIT_READY;
511 |     cbw.flags = 0;
512 |     event = cbw.opcode;
513 | 
514 |     usb_transfer_t *xfer_out = allocate(64);
515 |     xfer_out->callback = usb_transfer_cb;
516 |     xfer_out->bEndpointAddress = ep_out->bEndpointAddress;
517 |     xfer_out->num_bytes = sizeof(msc_bulk_cbw_t);
518 | 
519 |     MSC_SCSI_INIT_CBW((msc_bulk_cbw_t *)xfer_out->data_buffer, false, _lun, 0x1234, cbw, 0);
520 | 
521 |     esp_err_t err = usb_host_transfer_submit(xfer_out);
522 | 
523 |     err = usb_host_transfer_submit(xfer_out);
524 |     ESP_LOGW("", "test unit ready data: 0x%02x", err);
525 | 
526 |     if (err)
527 |     {
528 |         ESP_LOGW("", "test unit ready data: 0x%02x", err);
529 |         _csw();
530 |     }
531 |     else
532 |     {
533 |         xTaskToNotify = xTaskGetCurrentTaskHandle();
534 |         uint32_t pulNotificationValue;
535 |         _csw();
536 | 
537 |         if (xTaskNotifyWait(0, 0, &pulNotificationValue, 100) == pdTRUE)
538 |         {
539 |             return ESP_OK;
540 |         }
541 | 
542 |         ESP_LOGE("", "test unit ready data: 0x%02x", ESP_FAIL);
543 |     }
544 |     */
545 |     return ESP_FAIL;
546 | }
547 | 
548 | void USBmscDevice::_inquiry()
549 | {
550 |     scsi_cmd10_t cbw = {};
551 |     cbw.opcode = SCSI_CMD_INQUIRY;
552 |     cbw.lba_1 = 36;
553 | 
554 |     event = cbw.opcode;
555 |     usb_transfer_t *xfer_out = allocate(64);
556 |     xfer_out->callback = usb_transfer_cb;
557 |     xfer_out->bEndpointAddress = ep_out->bEndpointAddress;
558 |     xfer_out->num_bytes = sizeof(msc_bulk_cbw_t);
559 |     MSC_SCSI_INIT_CBW((msc_bulk_cbw_t *)xfer_out->data_buffer, true /*is_read*/, 0, 0x1234, cbw, 36);
560 | 
561 |     esp_err_t err = usb_host_transfer_submit(xfer_out);
562 |     if (err)
563 |         ESP_LOGW("", "inquiry: 0x%02x => 0x%02x\n", err, xfer_out->bEndpointAddress);
564 | 
565 |     // xfer_in->callback = usb_transfer_cb; // TODO separate cb
566 |     _csw();
567 | }
568 | 
569 | 
570 | 
571 | 


--------------------------------------------------------------------------------
/components/usb_host/msc/vfs/diskio_rawmsc.cpp:
--------------------------------------------------------------------------------
  1 | // Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
  2 | //
  3 | // Licensed under the Apache License, Version 2.0 (the "License");
  4 | // you may not use this file except in compliance with the License.
  5 | // You may obtain a copy of the License at
  6 | //
  7 | //     http://www.apache.org/licenses/LICENSE-2.0
  8 | //
  9 | // Unless required by applicable law or agreed to in writing, software
 10 | // distributed under the License is distributed on an "AS IS" BASIS,
 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | // See the License for the specific language governing permissions and
 13 | // limitations under the License.
 14 | 
 15 | #include <string.h>
 16 | #include "diskio_impl.h"
 17 | #include "ff.h"
 18 | extern "C" {
 19 |     #include "ffconf.h"
 20 | }
 21 | #include "esp_log.h"
 22 | #include "diskio_rawflash.h"
 23 | #include "esp_compiler.h"
 24 | #include "esp_vfs_fat.h"
 25 | 
 26 | #include "usb_msc.hpp"
 27 | 
 28 | static const char* TAG = "msc_rawflash";
 29 | 
 30 | uint8_t ff_raw_handles[FF_VOLUMES] = {0xff};
 31 | 
 32 | DSTATUS ff_raw_initialize (BYTE pdrv)
 33 | {
 34 |     ESP_LOGD(TAG, "ff_raw_initialize => %d", pdrv);
 35 |     return 0;
 36 | }
 37 | 
 38 | DSTATUS ff_raw_status (BYTE pdrv)
 39 | {
 40 |     return 0;
 41 | }
 42 | 
 43 | DRESULT ff_raw_read (BYTE pdrv, BYTE *buff, DWORD sector, UINT count)
 44 | {
 45 |     ESP_LOGV(TAG, "ff_raw_read - pdrv=%i, sector=%i, count=%in", (unsigned int)pdrv, (unsigned int)sector, (unsigned int)count);
 46 |     uint8_t lun = ff_raw_handles[pdrv];
 47 |     USBmscDevice* part = USBmscDevice::getInstance();
 48 |     assert(part);
 49 |     esp_err_t err = part->_read10(lun, sector, count, buff);
 50 |     if (unlikely(err != ESP_OK)) {
 51 |         ESP_LOGE(TAG, "msc disk lun failed (0x%x)", err);
 52 |         return RES_ERROR;
 53 |     }
 54 |     return RES_OK;
 55 | }
 56 | 
 57 | DRESULT ff_raw_write (BYTE pdrv, const BYTE *buff, DWORD sector, UINT count)
 58 | {
 59 |     ESP_LOGV(TAG, "ff_raw_write - pdrv=%i, sector=%i, count=%in", (unsigned int)pdrv, (unsigned int)sector, (unsigned int)count);
 60 |     uint8_t lun = ff_raw_handles[pdrv];
 61 |     USBmscDevice* part = USBmscDevice::getInstance();
 62 |     assert(part);
 63 |     
 64 |     esp_err_t err = part->_write10(lun, sector, count, (uint8_t*)buff);
 65 |     if (unlikely(err != ESP_OK)) {
 66 |         ESP_LOGE(TAG, "msc disk lun failed (0x%x)", err);
 67 |         return RES_ERROR;
 68 |     }
 69 |     return RES_OK;
 70 |     return RES_ERROR;
 71 | }
 72 | 
 73 | DRESULT ff_raw_ioctl (BYTE pdrv, BYTE cmd, void *buff)
 74 | {
 75 |     uint8_t lun = ff_raw_handles[pdrv];
 76 |     USBmscDevice* part = USBmscDevice::getInstance();
 77 |     ESP_LOGV(TAG, "ff_raw_ioctl: cmd=%in", cmd);
 78 |     assert(part);
 79 |     switch (cmd) {
 80 |         case CTRL_SYNC:
 81 |             return RES_OK;
 82 |         case GET_SECTOR_COUNT:
 83 |             *((DWORD *) buff) = part->getBlockCount(lun);
 84 |             return RES_OK;
 85 |         case GET_SECTOR_SIZE:
 86 |             *((WORD *) buff) = part->getBlockSize(lun);
 87 |             return RES_OK;
 88 |         case GET_BLOCK_SIZE:
 89 |             return RES_ERROR;
 90 |     }
 91 |     return RES_ERROR;
 92 | }
 93 | 
 94 | 
 95 | esp_err_t ff_msc_register_raw_partition(BYTE pdrv, uint8_t lun)
 96 | {
 97 |     if (pdrv >= FF_VOLUMES) {
 98 |         return ESP_ERR_INVALID_ARG;
 99 |     }
100 |     static const ff_diskio_impl_t raw_impl = {
101 |         .init = &ff_raw_initialize,
102 |         .status = &ff_raw_status,
103 |         .read = &ff_raw_read,
104 |         .write = &ff_raw_write,
105 |         .ioctl = &ff_raw_ioctl
106 |     };
107 |     ff_diskio_register(pdrv, &raw_impl);
108 |     ff_raw_handles[pdrv] = lun;
109 |     return ESP_OK;
110 | }
111 | 
112 | 
113 | BYTE ff_msc_get_pdrv_raw(uint8_t lun)
114 | {
115 |     int pdrv = -1;
116 |     for (size_t i = 0; i < FF_VOLUMES; i++)
117 |     {
118 |         if(ff_raw_handles[i] == lun)
119 |         {
120 |             pdrv = i;
121 |             break;
122 |         }
123 |     }
124 |     return pdrv;
125 | }
126 | 
127 | esp_err_t vfs_fat_rawmsc_mount(const char* base_path,
128 |     const esp_vfs_fat_mount_config_t* mount_config, uint8_t lun)
129 | {
130 |     esp_err_t result = ESP_OK;
131 | 
132 |     USBmscDevice* part = USBmscDevice::getInstance();
133 |     assert(part);
134 |     if(lun > part->getMaxLUN())
135 |     {
136 |         result = ESP_ERR_INVALID_STATE;
137 |         return result;
138 |     }
139 | 
140 |     BYTE pdrv = 0xFF;
141 |     if (ff_diskio_get_drive(&pdrv) != ESP_OK) {
142 |         ESP_LOGW(TAG, "the maximum count of volumes is already mounted");
143 |         return ESP_ERR_NO_MEM;
144 |     }
145 |     char drv[3] = {(char)('0' + pdrv), ':', 0};
146 |     ESP_LOGD(TAG, "using pdrv=%i, drv: %s", pdrv, drv);
147 | 
148 |     result = ff_msc_register_raw_partition(pdrv, lun);
149 |     if (result != ESP_OK) {
150 |         ESP_LOGE(TAG, "ff_msc_register_raw_partition failed pdrv=%i, error - 0x(%x)", pdrv, result);
151 |         goto fail;
152 |     }
153 | 
154 |     FRESULT fresult;
155 |     FATFS *fs;
156 |     result = esp_vfs_fat_register(base_path, drv, mount_config->max_files, &fs);
157 |     if (result == ESP_ERR_INVALID_STATE) {
158 |         // it's okay, already registered with VFS
159 |     } else if (result != ESP_OK) {
160 |         ESP_LOGD(TAG, "esp_vfs_fat_register failed 0x(%x)", result);
161 |         goto fail;
162 |     }
163 | 
164 |     // Try to mount partition
165 |     fresult = f_mount(fs, drv, 0);
166 |     if (fresult != FR_OK) {
167 |         ESP_LOGW(TAG, "f_mount failed (%d)", fresult);
168 |         result = ESP_FAIL;
169 |         goto fail;
170 |     }
171 |     return ESP_OK;
172 | 
173 | fail:
174 |     esp_vfs_fat_unregister_path(base_path);
175 |     ff_diskio_unregister(pdrv);
176 |     return result;
177 | }
178 | 
179 | void vfs_fat_rawmsc_unmount(char *base_path, uint8_t lun)
180 | {
181 |     uint8_t pdrv = 0xff;
182 |     for (size_t i = 0; i < FF_VOLUMES; i++)
183 |     {
184 |         if(ff_raw_handles[i] == lun)
185 |         {
186 |             pdrv = i;
187 |             ff_raw_handles[i] = 0xff;
188 |             break;
189 |         }
190 |     }
191 |     
192 |     if(pdrv < FF_VOLUMES) 
193 |     {
194 |         char drv[3] = {(char)('0' + pdrv), ':', 0};
195 |         esp_vfs_fat_unregister_path(base_path);
196 |         f_mount(0, drv, 0);
197 |         ff_diskio_unregister(pdrv);
198 |         ESP_LOGI(TAG, "unregister path: %s, volume pdrv: %s", base_path, drv);
199 |     }
200 | }
201 | 


--------------------------------------------------------------------------------
/examples/cdc_acm/.gitignore:
--------------------------------------------------------------------------------
1 | build/*
2 | 
3 | sdkconfig*


--------------------------------------------------------------------------------
/examples/cdc_acm/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # For more information about build system see
 2 | # https://docs.espressif.com/projects/esp-idf/en/latest/api-guides/build-system.html
 3 | # The following five lines of boilerplate have to be in your project's
 4 | # CMakeLists in this exact order for cmake to work correctly
 5 | cmake_minimum_required(VERSION 3.5)
 6 | 
 7 | set(EXTRA_COMPONENT_DIRS "../../components")
 8 | 
 9 | include($ENV{IDF_PATH}/tools/cmake/project.cmake)
10 | project(usb_host_arduino)
11 | 


--------------------------------------------------------------------------------
/examples/cdc_acm/main/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | idf_component_register(SRCS "main.cpp"
2 |                     INCLUDE_DIRS ".")
3 | 


--------------------------------------------------------------------------------
/examples/cdc_acm/main/main.cpp:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include "string.h"
  3 | #include "freertos/FreeRTOS.h"
  4 | #include "freertos/task.h"
  5 | #include "esp_log.h"
  6 | #include "usb/usb_host.h"
  7 | 
  8 | #include "usb_host.hpp"
  9 | #include "usb_acm.hpp"
 10 | 
 11 | #include <stdio.h>
 12 | #include <string.h>
 13 | #include <sys/unistd.h>
 14 | #include <sys/stat.h>
 15 | #include <fcntl.h>
 16 | #include <sys/stat.h>
 17 | #include <dirent.h>
 18 | #include <sys/types.h>
 19 | #include <esp_vfs_fat.h>
 20 | 
 21 | USBhost host;
 22 | USBacmDevice *device;
 23 | 
 24 | bool is_ready = false;
 25 | 
 26 | void callback(int event, void *data, size_t len)
 27 | {
 28 |     switch (event)
 29 |     {
 30 |     case CDC_CTRL_SET_CONTROL_LINE_STATE:
 31 |         printf("CDC_CTRL_SET_CONTROL_LINE_STATE\n");
 32 |         device->setLineCoding(115200, 0, 0, 8);
 33 |         break;
 34 | 
 35 |     case CDC_DATA_IN:
 36 |     {
 37 |         device->INDATA();
 38 |         char *buf = (char *)data;
 39 |         buf[len] = 0;
 40 |         printf("%s", (char *)data);
 41 |         break;
 42 |     }
 43 |     case CDC_DATA_OUT:
 44 | 
 45 |         break;
 46 | 
 47 |     case CDC_CTRL_SET_LINE_CODING:
 48 |         printf("CDC_CTRL_SET_LINE_CODING\n");
 49 |         break;
 50 |     }
 51 | }
 52 | 
 53 | void client_event_callback(const usb_host_client_event_msg_t *event_msg, void *arg)
 54 | {
 55 |     if (event_msg->event == USB_HOST_CLIENT_EVENT_NEW_DEV)
 56 |     {
 57 |         usb_device_info_t info = host.getDeviceInfo();
 58 |         ESP_LOGI("", "device speed: %s, device address: %d, max ep_ctrl size: %d, config: %d", info.speed ? "USB_SPEED_FULL" : "USB_SPEED_LOW", info.dev_addr, info.bMaxPacketSize0, info.bConfigurationValue);
 59 |         const usb_device_desc_t *dev_desc = host.getDeviceDescriptor();
 60 |         int offset = 0;
 61 |         for (size_t i = 0; i < dev_desc->bNumConfigurations; i++)
 62 |         {
 63 |             const usb_config_desc_t *config_desc = host.getConfigurationDescriptor();
 64 |             for (size_t n = 0; n < config_desc->bNumInterfaces; n++)
 65 |             {
 66 |                 const usb_intf_desc_t *intf = usb_parse_interface_descriptor(config_desc, n, 0, &offset);
 67 |                 if (intf->bInterfaceClass == 0x0a) // CDC ACM
 68 |                 {
 69 |                     device = new USBacmDevice(config_desc, &host);
 70 |                     n = config_desc->bNumInterfaces;
 71 |                     if (device)
 72 |                     {
 73 |                         device->init();
 74 |                         device->onEvent(callback);
 75 |                         device->setControlLine(1, 1);
 76 |                         device->INDATA();
 77 |                     }
 78 |                 } 
 79 |                 
 80 |                 printf("config: %d[%d], interface: %d[%d], intf class: %d\n", i, dev_desc->bNumConfigurations, n, config_desc->bNumInterfaces, intf->bInterfaceClass);
 81 | 
 82 |             }            
 83 |         }
 84 |     }
 85 |     else
 86 |     {
 87 |         ESP_LOGW("", "DEVICE gone event");
 88 |         if(device)
 89 |         {
 90 |             device->deinit();
 91 |             delete(device);
 92 |         }
 93 |         device = NULL;
 94 |     }
 95 | }
 96 | 
 97 | extern "C" void app_main(void)
 98 | {
 99 |     // heap_caps_print_heap_info(MALLOC_CAP_INTERNAL);
100 |     host.registerClientCb(client_event_callback);
101 |     host.init();
102 | 
103 | 
104 |     while (1)
105 |     {
106 |         while (!device || !device->isConnected())
107 |         {
108 |             vTaskDelay(10);
109 |         }
110 | 
111 |         vTaskDelay(1000 / portTICK_PERIOD_MS);
112 |         device->OUTDATA((uint8_t *)"test\n", 5);
113 |     }
114 | }
115 | 


--------------------------------------------------------------------------------
/examples/read_write/.gitignore:
--------------------------------------------------------------------------------
1 | build/*
2 | 
3 | sdkconfig*


--------------------------------------------------------------------------------
/examples/read_write/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # For more information about build system see
 2 | # https://docs.espressif.com/projects/esp-idf/en/latest/api-guides/build-system.html
 3 | # The following five lines of boilerplate have to be in your project's
 4 | # CMakeLists in this exact order for cmake to work correctly
 5 | cmake_minimum_required(VERSION 3.5)
 6 | 
 7 | set(EXTRA_COMPONENT_DIRS "../../components")
 8 | 
 9 | include($ENV{IDF_PATH}/tools/cmake/project.cmake)
10 | project(usb_host_arduino)
11 | 


--------------------------------------------------------------------------------
/examples/read_write/main/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | idf_component_register(SRCS "main.cpp"
2 |                     INCLUDE_DIRS ".")
3 | 


--------------------------------------------------------------------------------
/examples/read_write/main/main.cpp:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include "string.h"
  3 | #include "freertos/FreeRTOS.h"
  4 | #include "freertos/task.h"
  5 | #include "esp_log.h"
  6 | #include "usb/usb_host.h"
  7 | 
  8 | #include "usb_host.hpp"
  9 | #include "usb_msc.hpp"
 10 | 
 11 | #include <stdio.h>
 12 | #include <string.h>
 13 | #include <sys/unistd.h>
 14 | #include <sys/stat.h>
 15 | #include <fcntl.h>
 16 | #include <sys/stat.h>
 17 | #include <dirent.h>
 18 | #include <sys/types.h>
 19 | #include <esp_vfs_fat.h>
 20 | 
 21 | USBhost host;
 22 | USBmscDevice *device;
 23 | void read_test(int t);
 24 | void write_test();
 25 | static void getFreeSpace(uint64_t* used_space, uint64_t* max_space);
 26 | 
 27 | void cbw_cb(usb_transfer_t *transfer)
 28 | {
 29 |     printf("USER CBW CB\n");
 30 | }
 31 | 
 32 | void data_cb(usb_transfer_t *transfer)
 33 | {
 34 |     printf("USER data CB\n");
 35 | }
 36 | 
 37 | static void csw_cb(usb_transfer_t *transfer)
 38 | {
 39 |     printf("USER CSW CB\n");
 40 | }
 41 | 
 42 | void vApplicationStackOverflowHook(TaskHandle_t xTask, char *pcTaskName)
 43 | {
 44 |     ESP_LOGE("", "stack overflow: %s\n", pcTaskName);
 45 | }
 46 | 
 47 | #define MOUNT_POINT "/msc"
 48 | #define MOUNT_POINT1 "/msc1"
 49 | char line[5000];
 50 | bool is_mount = false;
 51 | 
 52 | static void test(void* p)
 53 | {
 54 |     while (!is_mount)
 55 |     {
 56 |         vTaskDelay(1);
 57 |     }
 58 |     printf("test task\n");
 59 | 
 60 |     uint64_t used_space;
 61 |     uint64_t max_space;
 62 |     getFreeSpace(&used_space, &max_space);
 63 | 
 64 |     ESP_LOGI("TEST", "storage used: %s => %lld/%lld", MOUNT_POINT, used_space, max_space);
 65 |     write_test();
 66 |     read_test(0);
 67 | 
 68 |     vTaskDelete(NULL);
 69 | }
 70 | 
 71 | static void capacity_cb(usb_transfer_t *transfer)
 72 | {
 73 |     printf("capacity_cb: block_size: %d, block_count: %d\n", device->getBlockSize(0), device->getBlockCount(0));
 74 | }
 75 | 
 76 | static void inquiry_cb(usb_transfer_t *transfer)
 77 | {
 78 |     printf("inquiry_cb\n");
 79 |     if(!is_mount){
 80 |         device->mount(MOUNT_POINT, 0);
 81 |     }
 82 |     is_mount = true;
 83 |     xTaskCreate(test, "test", 4096, NULL, 5, NULL);
 84 | }
 85 | 
 86 | static void unit_ready_cb(usb_transfer_t *transfer)
 87 | {
 88 |     printf("unit_ready_cb\n");
 89 | }
 90 | 
 91 | static void max_luns_cb(usb_transfer_t *transfer)
 92 | {
 93 |     printf("max_luns_cb\n");
 94 | }
 95 | 
 96 | static void sense_cb(usb_transfer_t *transfer)
 97 | {
 98 |     printf("sense_cb\n");
 99 | }
100 | 
101 | void client_event_callback(const usb_host_client_event_msg_t *event_msg, void *arg)
102 | {
103 |     if (event_msg->event == USB_HOST_CLIENT_EVENT_NEW_DEV)
104 |     {
105 |         usb_device_info_t info = host.getDeviceInfo();
106 |         ESP_LOGI("", "device speed: %s, device address: %d, max ep_ctrl size: %d, config: %d", info.speed ? "USB_SPEED_FULL" : "USB_SPEED_LOW", info.dev_addr, info.bMaxPacketSize0, info.bConfigurationValue);
107 |         const usb_config_desc_t *config_desc = host.getConfigurationDescriptor();
108 |         int offset = 0;
109 | 
110 |         for (size_t n = 0; n < config_desc->bNumInterfaces; n++)
111 |         {
112 |             const usb_intf_desc_t *intf = usb_parse_interface_descriptor(config_desc, n, 0, &offset);
113 | 
114 |             if (intf->bInterfaceClass == 0x08) // MSC
115 |             {
116 |                 msc_transfer_cb_t cb = {
117 |                     // .cbw_cb = cbw_cb,
118 |                     // .data_cb = data_cb,
119 |                     // .csw_cb = csw_cb,
120 |                     .capacity_cb = capacity_cb,
121 |                     .inquiry_cb = inquiry_cb,
122 |                     // .unit_ready_cb = unit_ready_cb,
123 |                     // .max_luns_cb = max_luns_cb,
124 |                     // .sense_cb = sense_cb,
125 |                 };
126 |                 device = new USBmscDevice(config_desc, &host);
127 |                 ((USBmscDevice *)device)->registerCallbacks(cb);
128 |                 n = config_desc->bNumInterfaces;
129 |             }
130 | 
131 |             if (device)
132 |                 device->init();
133 | 
134 |         }
135 |     } else {
136 |         ESP_LOGW("", "DEVICE gone event");
137 |         if(device)
138 |         {
139 |             device->unmount(MOUNT_POINT, 0);
140 |             // device->unmount(MOUNT_POINT1, 1);
141 |             device->deinit();
142 |             delete(device);
143 |             is_mount = false;
144 |         }
145 |         device = NULL;
146 |     }
147 | }
148 | 
149 | #define TAG ""
150 | 
151 | void read_test(int t)
152 | {
153 |     FILE *f;
154 |     char* mount;
155 |     if (t)
156 |     {
157 |         f = fopen(MOUNT_POINT"/README.txt", "r");
158 |         mount = MOUNT_POINT;
159 |     } else
160 |     {
161 |         f = fopen(MOUNT_POINT"/README1.txt", "r");
162 |         mount = MOUNT_POINT;
163 |     }
164 |     
165 |     if (f == NULL)
166 |     {
167 |         ESP_LOGE("TAG", "Failed to open file");
168 |     }
169 |     else
170 |     {
171 |         ESP_LOGI("READ file", "%s", MOUNT_POINT"/README.txt");
172 |         char *pos;
173 |         fgets(line, sizeof(line), f);
174 |         // strip newline
175 |         pos = strchr(line, '\n');        
176 |         do{
177 |             if (pos)
178 |             {
179 |                 *pos = '\0';
180 |             }
181 |             ESP_LOGI("", "%s", line);
182 |             fgets(line, sizeof(line), f);
183 |             pos = strchr(line, '\n');
184 |         }while(pos);
185 |         fclose(f);
186 |     }
187 | 
188 |     char* _dirpath = mount;
189 |     char* dirpath = "/msc/";
190 |     DIR *dir = opendir(_dirpath);
191 | 
192 |     // /* Retrieve the base path of file storage to construct the full path */
193 |     // strlcpy(entrypath, dirpath, sizeof(entrypath));
194 |     char entrypath[256];
195 |     char entrysize[32];
196 |     const char *entrytype;
197 | 
198 |     struct dirent *entry;
199 |     struct stat entry_stat;
200 |     const size_t dirpath_len = strlen(dirpath);
201 |     strlcpy(entrypath, dirpath, sizeof(entrypath));
202 | 
203 |     if (!dir)
204 |     {
205 |         ESP_LOGE("TAG", "Failed to stat dir : %s", _dirpath);
206 |     }
207 |     else
208 |     {
209 |         entry = readdir(dir);
210 |         while (entry != NULL)
211 |         {
212 |             entrytype = (entry->d_type == DT_DIR ? "directory" : "file");
213 | 
214 |             strlcpy(entrypath + dirpath_len, entry->d_name, sizeof(entrypath) - dirpath_len);
215 | 
216 |             int st = 0;
217 |             st = stat(entrypath, &entry_stat);
218 |             if (st == -1)
219 |             {
220 |                 ESP_LOGE(TAG, "Failed to stat %s : %s", entrytype, entrypath);
221 |                 if(unlink(entrypath))
222 |                     ESP_LOGE(TAG, "unlink failed");
223 |                 entry = readdir(dir);
224 |                 continue;
225 |             }
226 |             sprintf(entrysize, "%ld", entry_stat.st_size);
227 |             ESP_LOGI(TAG, "Found %s : %s (%s bytes)", entrytype, entrypath, entrysize);
228 |             entry = readdir(dir);
229 |         }
230 |         closedir(dir);
231 |     }
232 | }
233 | 
234 | void write_test()
235 | {
236 |     FILE* f = fopen("/msc/README.txt", "w");
237 |     if (f == NULL) {
238 |         ESP_LOGE(TAG, "Failed to open file for writing");
239 |         return;
240 |     }
241 |     fprintf(f, "Hello World!\n");
242 |     fclose(f);
243 |     ESP_LOGI(TAG, "File written");
244 |     read_test(1);
245 | 
246 |     // Check if destination file exists before renaming
247 |     struct stat st;
248 |     if (stat("/msc/README1.txt", &st) == 0) {
249 |         // Delete it if it exists
250 |         if(unlink("/msc/README1.txt"))
251 |             ESP_LOGE(TAG, "unlink failed");
252 |     }
253 | 
254 |     // Rename original file
255 |     ESP_LOGI(TAG, "Renaming file");
256 |     if (rename("/msc/README.txt", "/msc/README1.txt") != 0) {
257 |         ESP_LOGE(TAG, "Rename failed");
258 |         // return;
259 |     }
260 | 
261 |     // Open renamed file for reading
262 |     ESP_LOGI(TAG, "Reading file");
263 |     f = fopen("/msc/README1.txt", "r");
264 |     if (f == NULL) {
265 |         ESP_LOGE(TAG, "Failed to open file for reading");
266 |         return;
267 |     }
268 |     char line[64];
269 |     fgets(line, sizeof(line), f);
270 |     fclose(f);
271 |     // strip newline
272 |     char* pos = strchr(line, '\n');
273 |     if (pos) {
274 |         *pos = '\0';
275 |     }
276 |     ESP_LOGI(TAG, "Read from file %s: '%s'", "/msc/README1.txt", line);
277 | }
278 | 
279 | 
280 | static void getFreeSpace(uint64_t* used_space, uint64_t* max_space)
281 | {
282 |     FATFS *fs;
283 |     DWORD dwc;
284 |     char drv[4] = {};
285 |     device->getDrivePath(drv);
286 |     if (f_getfree(drv, &dwc, &fs) == FR_OK)
287 |     {
288 |         *used_space =
289 |             ((uint64_t)fs->csize * (fs->n_fatent - 2 - fs->free_clst)) * fs->ssize;
290 |         *max_space = ((uint64_t)fs->csize * (fs->n_fatent - 2)) * fs->ssize;
291 |     }
292 | }
293 | 
294 | 
295 | extern "C" void app_main(void)
296 | {
297 |     host.registerClientCb(client_event_callback);
298 |     host.init();
299 | }
300 | 


--------------------------------------------------------------------------------
/examples/remote_pendrive/.gitignore:
--------------------------------------------------------------------------------
1 | build/*
2 | 
3 | sdkconfig*


--------------------------------------------------------------------------------
/examples/remote_pendrive/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # For more information about build system see
 2 | # https://docs.espressif.com/projects/esp-idf/en/latest/api-guides/build-system.html
 3 | # The following five lines of boilerplate have to be in your project's
 4 | # CMakeLists in this exact order for cmake to work correctly
 5 | cmake_minimum_required(VERSION 3.5)
 6 | 
 7 | set(EXTRA_COMPONENT_DIRS "../../components")
 8 | 
 9 | include($ENV{IDF_PATH}/tools/cmake/project.cmake)
10 | project(usb_host_arduino)
11 | 


--------------------------------------------------------------------------------
/examples/remote_pendrive/embedded/app.css:
--------------------------------------------------------------------------------
  1 | .main-content {
  2 |     width: 1440px;
  3 |     margin: auto;
  4 |     font-size: 14px;
  5 |   }
  6 |   
  7 |   .connect-container {
  8 |     margin: 20px 0;
  9 |   }
 10 |   
 11 |   .container {
 12 |     display: flex;
 13 |   }
 14 |   
 15 |   .sender, .receiver {
 16 |     flex-grow: 0.5;
 17 |     flex-shrink: 1;
 18 |   }
 19 |   
 20 |   .sender {
 21 |     margin-right: 8px;
 22 |   }
 23 |   
 24 |   .receiver {
 25 |     margin-right: 8px;
 26 |   }
 27 |   
 28 |   .lines-header {
 29 |     height: 30px;
 30 |     width: 100%;
 31 |     box-sizing: border-box;
 32 |     background-color: #444;
 33 |     line-height: 30px;
 34 |     color: white;
 35 |     padding-left: 10px;
 36 |   }
 37 |   
 38 |   .lines-body {
 39 |     width: 100%;
 40 |     background-color: #222;
 41 |     min-height: 300px;
 42 |     padding: 10px 0 20px 0;
 43 |   }
 44 |   
 45 |   .line, .command-line {
 46 |     box-sizing: border-box;
 47 |     width: 100%;
 48 |     color: #f1f1f1;
 49 |     background-color: #222;
 50 |     outline: none;
 51 |     border: none;
 52 |     padding: 5px 10px;
 53 |     font-size: 14px;
 54 |   }
 55 |   
 56 |   .line:hover {
 57 |      background-color: #444;
 58 |   }
 59 |   
 60 |   .button::before {
 61 |       -webkit-border-radius: 3px;
 62 |       -moz-border-radius: 3px;
 63 |       -webkit-box-shadow: #959595 0 2px 5px;
 64 |       -moz-box-shadow: #959595 0 2px 5px;
 65 |       border-radius: 3px;
 66 |       box-shadow: #959595 0 2px 5px;
 67 |       content: "";
 68 |       display: block;
 69 |       left: 0;
 70 |       padding: 2px 0 0;
 71 |       position: absolute;
 72 |       top: 0;
 73 |   }
 74 |   
 75 |   .button:active::before { padding: 1px 0 0; }
 76 |   
 77 |   .button.black {
 78 |       background: #656565;
 79 |       background: -webkit-gradient(linear, 0 0, 0 bottom, from(#656565), to(#444));
 80 |       background: -moz-linear-gradient(#656565, #444);
 81 |       background: linear-gradient(#656565, #444);
 82 |       border: solid 1px #535353;
 83 |       border-bottom: solid 3px #414141;
 84 |       box-shadow: inset 0 0 0 1px #939393;
 85 |       color: #fff;
 86 |       text-shadow: 0 1px 0 #2f2f2f;
 87 |       padding: 8px 16px;
 88 |       outline: none;
 89 |   }
 90 |   
 91 |   .button.black:hover {
 92 |       background: #4c4c4c;
 93 |       background: -webkit-gradient(linear, 0 0, 0 bottom, from(#4c4c4c), to(#565656));
 94 |       background: -moz-linear-gradient(#4c4c4c, #565656);
 95 |       background: linear-gradient(#4c4c4c, #565656);
 96 |       border: solid 1px #464646;
 97 |       border-bottom: solid 3px #414141;
 98 |       box-shadow: inset 0 0 0 1px #818181;
 99 |   }
100 |   
101 |   .button.black:active {
102 |       background: #474747;
103 |       background: -webkit-gradient(linear, 0 0, 0 bottom, from(#474747), to(#444));
104 |       background: -moz-linear-gradient(#474747, #444);
105 |       background: linear-gradient(#474747, #444);
106 |       border: solid 1px #2f2f2f;
107 |       box-shadow: inset 0 10px 15px 0 #3e3e3e;
108 |   }
109 |   
110 |   
111 |   .filestree {
112 |     border: 1px solid black;
113 |     width: 100%;
114 |   }
115 |   
116 |   .filestree1 {
117 |     border: 1px solid black;
118 |     width: 100%;
119 |     text-align: end;
120 |   }
121 |   
122 |   th {
123 |     border: 1px solid black;
124 |     width: 100%;
125 |   }
126 |   
127 | body {
128 |   background-color: #125597;
129 |   /* background-image: url('https://cdn.shopify.com/s/files/1/0770/0935/files/nasa-53884_1512x.jpg'); */
130 |   text-decoration-color: white;
131 |   background-size: cover;
132 |   font-family: 'Helvetica Neue', Arial, sans-serif;
133 | }
134 | 
135 | * {
136 |   box-sizing: border-box;
137 | }
138 | 
139 | .card {
140 |   background: linear-gradient(-45deg, #5555FF, #9787FF);
141 |   box-shadow: 0 0 6px rgba(0, 0, 0, 0.1); 
142 |   position: absolute;
143 |   top: 50%;
144 |   left: 50%;
145 |   transform: translate(-50%, -50%);
146 |   width: 300px;
147 |   height: 375px;
148 |   border-radius: 10px;
149 |   overflow: hidden;
150 | }
151 | 
152 | /* hide limit values on X axis */
153 | .card #canvas {
154 |   margin-left: -30px;
155 |   margin-right: -30px;
156 |   width: 360px!important;
157 | }
158 | 
159 | .card .about {
160 |   height: 185px;
161 |   padding: 20px;
162 |   box-sizing: border-box;
163 | }
164 | 
165 | .card .about h3,
166 | .card .about .lead {
167 |   margin-top: 0;
168 |   margin-bottom: 0;
169 |   font-weight: 400;
170 | }
171 | 
172 | .card .about h3 {
173 |   font-size: 24px;
174 |   color: #fff;
175 | }
176 | 
177 | .card .about .lead {
178 |   color: #eee;
179 | }
180 | 
181 | .card .info {
182 |   float: left;
183 |   padding: 10px 30px 10px 0;
184 | }
185 | 
186 | .card .info p {
187 |   font-size: 11px;
188 |   color: #aaa;
189 |   font-weight: 300;
190 | }
191 | 
192 | .legends {
193 |   padding-top: 20px;
194 |   overflow: hidden;
195 | }
196 | 
197 | .legend {
198 |   display: block;
199 |   width: 8px;
200 |   height: 8px;
201 |   margin-top: 15px;
202 |   margin-bottom: 15px;
203 |   border-radius: 50%;
204 | }
205 | 
206 | .legend--this {
207 |   background-color: #5555FF;
208 | }
209 | 
210 | .legend--prev {
211 |   background-color: #FF55B8;
212 | }
213 | 
214 | .axis {
215 |   position: absolute;
216 |   color: #fff;
217 |   z-index: 1;
218 |   text-transform: uppercase;
219 |   display: flex;
220 |   width: 100%;
221 |   bottom: 0;
222 | }
223 | 
224 | .axis .tick {
225 |   flex: 1;
226 |   position: relative;
227 |   font-size: 11px;
228 |   text-align: center;
229 |   padding-top: 10px;
230 |   padding-bottom: 10px;
231 |   line-height: 20px;
232 | }
233 | 
234 | .axis .tick::after {
235 |   content: "";
236 |   position: absolute;
237 |   display: block;
238 |   right: 0;
239 |   bottom: 0;
240 |   width: 1px;
241 |   height: 200px;
242 |   background: rgba(255, 255, 255, 0.2);
243 | }
244 | 
245 | .axis .tick .value {
246 |   transform: translateY(-240px);
247 |   opacity: 0;
248 |   transition: all 0.3s;
249 |   position: absolute;
250 |   top: 20px;
251 |   left: 0;
252 |   color: #fff;
253 |   border-radius: 2px;
254 |   width: 100%;
255 |   line-height: 20px;
256 | }
257 | 
258 | .axis .tick:hover .value.value--this {
259 |   transform: translateY(-160px);
260 |   display: block;
261 |   opacity: 0.4;
262 | }
263 | 
264 | .value.value--this {
265 |   color: #fff;
266 |   font-weight: bold;
267 | }
268 | 
269 | .day-number {
270 |   display: block;
271 | }
272 | 
273 | .day-name {
274 |   display: block;
275 |   opacity: 0.4;
276 | }
277 | 
278 | /* Animated background, credits: Manuel Pinto, https://codepen.io/P1N2O/pen/pyBNzX */
279 | .card {
280 |   background: linear-gradient(-45deg, #5555FF, #9787FF, #FF55B8, #FF8787);
281 |   background-size: 400% 400%;
282 |   animation: bg 20s infinite;
283 | }
284 | 
285 | @keyframes bg
286 | {
287 |   0% {
288 | 		background-position: 0% 50%
289 | 	}
290 | 	50% {
291 | 		background-position: 100% 50%
292 | 	}
293 | 	100% {
294 | 		background-position: 0% 50%
295 | 	}
296 | }
297 | 
298 | 
299 | 
300 | /* The Modal (background) */
301 | .modal {
302 |   display: none; /* Hidden by default */
303 |   position: fixed; /* Stay in place */
304 |   z-index: 1; /* Sit on top */
305 |   left: 0;
306 |   top: 0;
307 |   width: 100%; /* Full width */
308 |   height: 100%; /* Full height */
309 |   overflow: auto; /* Enable scroll if needed */
310 |   background-color: rgb(0,0,0); /* Fallback color */
311 |   background-color: rgba(0,0,0,0.4); /* Black w/ opacity */
312 | }
313 | 
314 | /* Modal Content/Box */
315 | .modal-content {
316 |   background-color: #fefefe;
317 |   margin: 10% 10% auto; /* 15% from the top and centered */
318 |   padding: 20px;
319 |   border: 1px solid #888;
320 |   width: 80%; /* Could be more or less, depending on screen size */
321 | }
322 | 
323 | /* The Close Button */
324 | .close {
325 |   color: #aaa;
326 |   float: right;
327 |   font-size: 28px;
328 |   font-weight: bold;
329 | }
330 | 
331 | .close:hover,
332 | .close:focus {
333 |   color: black;
334 |   text-decoration: none;
335 |   cursor: pointer;
336 | }
337 | 
338 | footer {
339 |     position: absolute;
340 |     bottom: 0px;
341 | }


--------------------------------------------------------------------------------
/examples/remote_pendrive/embedded/app.js:
--------------------------------------------------------------------------------
  1 | let myip = '192.168.4.1';
  2 | 
  3 | (function() {
  4 |     'use strict';
  5 | 
  6 |     // fake data for simulating files tree in case sd card is not connected and/or server returns error 404
  7 |     let files_tree_json = [{"path":"/files", "dir":1,"name":"Refresh", "size":"0"}];
  8 | 
  9 |     const xhr = new XMLHttpRequest();
 10 |     xhr.responseType = "json";
 11 | 
 12 |     xhr.addEventListener("load", e => {
 13 |         if (xhr.status === 200) {
 14 |             filestree(xhr.response);
 15 |         }
 16 |     });
 17 | 
 18 |     xhr.addEventListener("error", e => {
 19 |         // alert("Cant connect, use template");
 20 |         filestree(files_tree_json);
 21 |     });
 22 | 
 23 |     xhr.onreadystatechange = function() { // Call a function when the state changes.
 24 |         if (this.readyState === XMLHttpRequest.DONE && this.status === 404) {
 25 |             // Request finished. Do processing here.
 26 |             filestree(files_tree_json);
 27 |             alert("Thumbdrive not found");
 28 |         }
 29 |     }
 30 | 
 31 |     let current_path = '';
 32 | 
 33 |     function getfilestree(path)
 34 |     {
 35 |         current_path = path;
 36 |         console.log(path);
 37 |         xhr.open("GET", path + '/', true);
 38 |         xhr.send();    
 39 |     }
 40 | 
 41 | 
 42 |     function filestree(json){
 43 |         let tree = document.getElementById("filestree");
 44 |         let _path = document.getElementById("full_path");
 45 |         _path.innerText = current_path;
 46 |         tree.innerHTML = "<th>Name</th><th>Type</th><th>Size</th><th>Delete</th>";
 47 |     
 48 |         console.log(json);
 49 |         let n = 0;
 50 |         json.forEach(element => {
 51 |             let tr = document.createElement("tr");
 52 |             tr.className = 'filestree';
 53 |             let a = document.createElement("a");
 54 |             if (element.dir) {
 55 |                 a.href = '#';
 56 |                 a.target = "_self";
 57 |                 a.link = element.path;
 58 |                 a.onclick = function (event) {
 59 |                     event.preventDefault();
 60 |                     getfilestree(element.path);
 61 |                 };
 62 |             } else{
 63 |                 a.href = element.path;
 64 |                 a.target = "_blank";
 65 |             }
 66 |             a.text = element.name;
 67 |             let td1 = document.createElement("td");
 68 |             td1.appendChild(a);
 69 |             let td2 = document.createElement("td");
 70 |             td2.innerHTML = element.dir?"directory":"file";
 71 |             let td3 = document.createElement("td");
 72 |             td3.innerHTML = element.size;
 73 |             td1.className = 'filestree';
 74 |             td2.className = 'filestree1';
 75 |             td3.className = 'filestree1';
 76 | 
 77 |             tr.appendChild(td1);
 78 |             tr.appendChild(td2);
 79 |             tr.appendChild(td3);
 80 |             
 81 | 
 82 |             let btnDel = document.createElement("button");
 83 |             btnDel.path = element.path;
 84 |             btnDel.className = 'button black';
 85 |             if (n > 0) {                
 86 |                 btnDel.innerText = "delete";
 87 |                 btnDel.addEventListener('click', () => {
 88 |                     const http = new XMLHttpRequest();
 89 |                     var params = 'file=' + element.path;
 90 |                     var url = '/delete';
 91 |                     http.open("POST", url, true);
 92 |                     // Send the proper header information along with the request
 93 |                     http.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
 94 |                 
 95 |                     http.onreadystatechange = function() {//Call a function when the state changes.
 96 |                         if(http.readyState == 4 && http.status == 201) {
 97 |                             console.log('element deleted', http.responseText);
 98 |                             getfilestree(current_path);
 99 |                         } else if (http.readyState == 4 && http.status == 409) {
100 |                             console.log('cant delete', element.path);
101 |                         }
102 |                     }
103 |                     http.send(params);
104 |                 });
105 |             } else {
106 |                 btnDel.innerText = "mkdir";
107 |                 btnDel.addEventListener('click', () => {
108 |                     let dirname = prompt("New directory name");
109 |                     if(dirname == null || dirname == "") return;
110 |                     const http = new XMLHttpRequest();
111 |                     let sub;
112 |                     if (element.path.substring(element.path.length - 3, element.path.length) === '/..') {
113 |                         sub = element.path.substring(0, element.path.length - 2);
114 |                     } else {
115 |                         sub = element.path + '/';
116 |                     }
117 |                     var params = 'dirname=' + sub + dirname;
118 |                     console.log(params);
119 |                     var url = '/mkdir';
120 |                     http.open("POST", url, true);
121 |                     // Send the proper header information along with the request
122 |                     http.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
123 |                 
124 |                     http.onreadystatechange = function() {//Call a function when the state changes.
125 |                         if(http.readyState == 4 && http.status == 201) {
126 |                             console.log('directory created', http.responseText);
127 |                             getfilestree(current_path);
128 |                         } else if (http.readyState == 4 && http.status == 409) {
129 |                             alert('directory already exist');
130 |                         }
131 |                     }
132 |                     http.send(params);
133 |                 });
134 |             }
135 | 
136 |             let td4 = document.createElement("td");
137 |             td4.appendChild(btnDel);
138 |             td4.className = 'filestree1';
139 |             tr.appendChild(td4);
140 | 
141 |             tree.appendChild(tr);
142 |             n++;
143 |         });
144 |     }
145 |     
146 |     function postwifiap(path, ssid, pass, ap, auth)
147 |     {
148 |         const http = new XMLHttpRequest();
149 |     
150 |         console.log(path);
151 |         var params = 'ssid=' + ssid + '&pass=' + pass + '&ap=' + ap + '&auth=' + auth;
152 |         var url = '/wifi';
153 |         http.open("POST", url, true);
154 |         // Send the proper header information along with the request
155 |         http.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
156 |     
157 |         http.onreadystatechange = function() {//Call a function when the state changes.
158 |             if(http.readyState == 4 && http.status == 200) {
159 |                 console.log('credentials set', http.responseText);
160 |             }
161 |         }
162 |         http.send(params);
163 |     }
164 |     
165 |     function postsettings(freq, bw, sf, cr)
166 |     {
167 |         const http = new XMLHttpRequest();
168 |     
169 |         var params = 'freq=' + freq + '&bw=' + bw + '&sf=' + sf + '&cr=' + cr;
170 |         var url = '/settings';
171 |         http.open("POST", url, true);
172 |         // Send the proper header information along with the request
173 |         http.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
174 |     
175 |         http.onreadystatechange = function() {//Call a function when the state changes.
176 |             if(http.readyState == 4 && http.status == 200) {
177 |                 console.log('settings set', http.responseText);
178 |             }
179 |         }
180 |         http.send(params);
181 |     }
182 |     
183 |     document.addEventListener('DOMContentLoaded', event => {
184 | 
185 |         getfilestree('/files');
186 | 
187 |         let stabtn = document.getElementById("sta_btn");
188 |         let apbtn = document.getElementById("ap_btn");
189 |         let enable_ap = document.getElementById("en_ap");
190 |         let enable_sta = document.getElementById("en_sta");
191 |         let settingsSend = document.getElementById("settingsSend");
192 | 
193 |         // Get the modal
194 |         let modalstats = document.getElementById("myModal");
195 |         let modalwifi = document.getElementById("myModal1");
196 |         let modaltree = document.getElementById("myModal2");
197 |         let spinner = document.getElementById("spinner");
198 |         let settingsForm = document.getElementById("settingsForm");
199 |         
200 |         // Get the button that opens the modal
201 |         let settingsBtn = document.getElementById("settingsBtn");
202 |         let btnwifi = document.getElementById("wifi");
203 |         let btntree = document.getElementById("tree");
204 |         let btnformat = document.getElementById("format");
205 |         let btnmkdir = document.getElementById("mkdir");
206 | 
207 |         // Settings fields
208 |         let FREQ = document.querySelector("#freq1");
209 |         let BW = document.querySelector("#bw1");
210 |         let SF = document.querySelector("#sf1");
211 |         let CR = document.querySelector("#cr1");
212 | 
213 |         try {
214 |             FREQ.value = init_freq;
215 |             BW.value = init_bw;
216 |             SF.value = init_sf;
217 |             CR.value = init_cr;           
218 |         } catch (error) {}
219 | /*
220 |         btnformat.onclick = function() {
221 |             if(confirm("Do you want to format SD crad?\nIt will takes about 5 minutes!!!")){
222 |                 spinner.display = 'block';
223 |                 const http = new XMLHttpRequest();
224 |                 var url = '/format';
225 |                 http.open("POST", url, true);
226 |             
227 |                 http.onreadystatechange = function() {//Call a function when the state changes.
228 |                     if(http.readyState == 4 && http.status == 200) {
229 |                         console.log('sd card formatted', http.responseText);
230 |                         spinner.display = 'none';
231 |                     }
232 |                 }
233 |                 http.send();
234 |             }
235 |         }
236 | */
237 |         let _btnmkdir = function() {
238 |         // btnmkdir.onclick = function() {
239 |             let dirname = prompt("New directory name");
240 |             if(dirname == null || dirname == "") return;
241 |             const http = new XMLHttpRequest();
242 |             var params = 'dirname=' + dirname;
243 |             var url = '/mkdir';
244 |             http.open("POST", url, true);
245 |             // Send the proper header information along with the request
246 |             http.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
247 |         
248 |             http.onreadystatechange = function() {//Call a function when the state changes.
249 |                 if(http.readyState == 4 && http.status == 201) {
250 |                     console.log('directory created', http.responseText);
251 |                     getfilestree(current_path);
252 |                 } else if (http.readyState == 4 && http.status == 409) {
253 |                     console.log('directory already exist', http.responseText);
254 |                     alert('directory already exist');
255 |                 }
256 |             }
257 |             http.send(params);
258 |         }
259 | 
260 |         btnwifi.onclick = function() {
261 |             modalwifi.style.display = "block";
262 |         }
263 |         btntree.onclick = function() {
264 |             modaltree.style.display = "block";
265 |         }
266 |         enable_ap.onclick = function(ev) {
267 |             console.log('AP', ev);
268 |             let content = document.getElementById("ap_content");
269 |             if(ev.target.checked) content.style.display = "block";
270 |             else content.style.display = "none";
271 |         }
272 |         enable_sta.onclick = function(ev) {
273 |             let content = document.getElementById("sta_content");
274 |             if(ev.target.checked) content.style.display = "block";
275 |             else content.style.display = "none";
276 |         }
277 |         // Get the <span> element that closes the modal
278 |         // let span1 = document.getElementsByClassName("close1")[0];
279 |         let span2 = document.getElementById("close2");
280 |         let span3 = document.getElementById("close3");
281 |         let span4 = document.getElementById("close4");
282 |         
283 |         // When the user clicks on <span> (x), close the modal
284 |         // span1.onclick = function() {
285 |         //     modalstats.style.display = "none";
286 |         // }
287 |         span2.onclick = function() {
288 |             modalwifi.style.display = "none";
289 |         }
290 |         // span3.onclick = function() {
291 |         //     modaltree.style.display = "none";
292 |         // }
293 |         
294 |         // When the user clicks anywhere outside of the modal, close it
295 |         window.onclick = function(event) {
296 |             if (event.target == modalstats) {
297 |                 modalstats.style.display = "none";
298 |             }
299 |             if (event.target == modalwifi) {
300 |                 modalwifi.style.display = "none";
301 |             }
302 |             if (event.target == modaltree) {
303 |                 modaltree.style.display = "none";
304 |             }
305 |             if (event.target == settingsForm) {
306 |                 settingsForm.style.display = "none";
307 |             }
308 |         }
309 | 
310 |         stabtn.addEventListener('click', function() {
311 |             const ssid = document.querySelector("#sta_ssid").value;
312 |             const pass = document.querySelector("#sta_pass").value;
313 |             postwifiap('', ssid, pass, 0, 0);
314 |         });
315 | 
316 |         apbtn.addEventListener('click', function() {
317 |             const ssid = document.querySelector("#ap_ssid").value;
318 |             const pass = document.querySelector("#ap_pass").value;
319 |             var auth = document.getElementById("auth");
320 |             postwifiap('', ssid, pass, 1, auth.value);
321 |         });
322 | 
323 |     });
324 | 
325 | })();
326 | 


--------------------------------------------------------------------------------
/examples/remote_pendrive/embedded/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | 
  4 | <head>
  5 |   <title>Remote pendrive</title>
  6 |   <script src="app.js"></script>
  7 |   <link rel="stylesheet" href="app.css">
  8 | </head>
  9 | 
 10 | <body>
 11 |   <div class="modal" id='spinner'>
 12 |     <div style="width: 320px;">
 13 |     </div>
 14 |   </div>
 15 |   <div class="main-content">
 16 |     <div class="connect-container">
 17 |       <span id="status"></span>
 18 |       <button id="wifi" class="button black">Setup wifi</button>
 19 |       <button id="tree" class="button black">Files tree</button>
 20 |       <!-- <button id="format" class="button black">Format</button> -->
 21 |     </div>
 22 | 
 23 |     <!-- 
 24 |     <div style="background-color: #216cb7; max-width: 400px;">
 25 |       <div class="container">
 26 |         <div class="receiver" style="max-width: 400px">
 27 |           <div class="lines-header">Storage:</div>
 28 |           <table style="min-width: 300px;">
 29 |             <tr>
 30 |               <td>Used space: </td>
 31 |               <td id="used" style='text-align: right;'>0</td>
 32 |             </tr>
 33 |             <tr>
 34 |               <td>Free space: </td>
 35 |               <td id="free" style='text-align: right;'>0</td>
 36 |             </tr>
 37 |             <tr>
 38 |               <td>Max space: </td>
 39 |               <td id="max" style='text-align: right;'>0</td>
 40 |             </tr>
 41 |           </table>
 42 |         </div>
 43 |       </div>
 44 |     </div>
 45 | -->
 46 |     <div id="myModal1" class="modal">
 47 |       <!-- Modal content -->
 48 |       <div class="modal-content" style="background-color: #216cb7;max-width: 400px;">
 49 |         <span id='close2' class="close">&times;</span>
 50 |         <div class="container">
 51 |           <div class="receiver" style="max-width: 400px; min-width: 320px;">
 52 |             <input type="checkbox" id="en_ap">AP </input>
 53 |             <div id="ap_content" hidden>
 54 |               <div class="lines-header">Wifi access point:</div>
 55 |               <label for="ap_ssid">AP ssid: </label><input id="ap_ssid" style="position: relative; left: 75px;"/></br>
 56 |               <label for="ap_pass">AP password: </label><input id="ap_pass" style="position: relative; left: 40px;" /></br>
 57 |               <label for="enc_type">Auth mode: </label>
 58 |               <select id="auth" style="position: relative; left: 8px;">
 59 |                 <option value=0>WIFI_AUTH_OPEN</option>
 60 |                 <option value=1>WIFI_AUTH_WEP</option>
 61 |                 <option value=2>WIFI_AUTH_WPA_PSK</option>
 62 |                 <option value=3>WIFI_AUTH_WPA2_PSK</option>
 63 |                 <option value=4>WIFI_AUTH_WPA_WPA2_PSK</option>
 64 |                 <option value=5>WIFI_AUTH_WPA2_ENTERPRISE</option>
 65 |                 <option value=6>WIFI_AUTH_WPA3_PSK</option>
 66 |                 <option value=7>WIFI_AUTH_WPA2_WPA3_PSK</option>
 67 |               </select></br>
 68 | 
 69 |               <a href='' id='ap_ip' hidden>Connect device</a>
 70 |               <button id="ap_btn" class="button black">Setup wifi</button>
 71 |               </br></br>
 72 |             </div>
 73 | 
 74 |             <input type="checkbox" id="en_sta">STA</input>
 75 |             <div id="sta_content" hidden>
 76 |               <div class="lines-header">Wifi station:</div>
 77 |               <label for="sta_ssid">STA ssid: </label><input id="sta_ssid"  style="position: relative; left: 70px;"/></br>
 78 |               <label for="sta_pass">STA password: </label><input id="sta_pass"  style="position: relative; left: 35px;"/></br>
 79 |               <a href='' id='sta_ip' hidden>Connect device</a>
 80 |               <button id="sta_btn" class="button black">Connect wifi</button>
 81 |             </div>
 82 |           </div>
 83 |         </div>
 84 |       </div>
 85 |     </div>
 86 | 
 87 |     <div id="myModal2" class="modal" >
 88 |       <!-- Modal content -->
 89 |       <div class="modal-content" style="background-color: #216cb7; max-width: 600px; min-width: fit-content;">
 90 |         <div class="container">
 91 |           <div class="receiver" style="max-width: 400px">
 92 |             <div>
 93 |               <label style="font-size: large; font-weight: bold; ">Path:</label>
 94 |                 <label id='full_path' style="font-size: large; font-weight: bold;"></label>
 95 |               </div>
 96 |             <table id='filestree' class="filestree"></table>
 97 |           </div>
 98 |         </div>
 99 |       </div>
100 |     </div>
101 | 
102 |   </div>
103 | </body>
104 | 
105 | </html>


--------------------------------------------------------------------------------
/examples/remote_pendrive/main/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | idf_component_register(SRCS "main.cpp" "wifi.c" "web_server.c"
2 |                     INCLUDE_DIRS "."
3 |                     EMBED_FILES "../embedded/index.html" "../embedded/app.js" "../embedded/app.css"
4 |         )
5 | 


--------------------------------------------------------------------------------
/examples/remote_pendrive/main/main.cpp:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include "string.h"
  3 | #include "freertos/FreeRTOS.h"
  4 | #include "freertos/task.h"
  5 | #include "esp_log.h"
  6 | #include "usb/usb_host.h"
  7 | #include "esp_err.h"
  8 | #include "nvs_flash.h"
  9 | 
 10 | #include "usb_host.hpp"
 11 | #include "usb_msc.hpp"
 12 | 
 13 | #include <stdio.h>
 14 | #include <string.h>
 15 | #include <sys/unistd.h>
 16 | #include <sys/stat.h>
 17 | #include <fcntl.h>
 18 | #include <sys/stat.h>
 19 | #include <dirent.h>
 20 | #include <sys/types.h>
 21 | #include <esp_vfs_fat.h>
 22 | #include "wifi.h"
 23 | 
 24 | #define EXAMPLE_ESP_WIFI_SSID      "pendrive"
 25 | #define EXAMPLE_ESP_WIFI_PASS      ""
 26 | #define MOUNT_POINT "/files"
 27 | 
 28 | USBhost host;
 29 | USBmscDevice *device;
 30 | 
 31 | bool is_mount = false;
 32 | static void capacity_cb(usb_transfer_t *transfer)
 33 | {
 34 |     printf("capacity_cb: block_size: %d, block_count: %d\n", device->getBlockSize(0), device->getBlockCount(0));
 35 | }
 36 | 
 37 | static void inquiry_cb(usb_transfer_t *transfer)
 38 | {
 39 |     printf("inquiry_cb\n");
 40 |     if(!is_mount){
 41 |         device->mount(MOUNT_POINT, 0);
 42 |     }
 43 |     is_mount = true;
 44 | }
 45 | 
 46 | void client_event_callback(const usb_host_client_event_msg_t *event_msg, void *arg)
 47 | {
 48 |     if (event_msg->event == USB_HOST_CLIENT_EVENT_NEW_DEV)
 49 |     {
 50 |         usb_device_info_t info = host.getDeviceInfo();
 51 |         ESP_LOGI("", "device speed: %s, device address: %d, max ep_ctrl size: %d, config: %d", info.speed ? "USB_SPEED_FULL" : "USB_SPEED_LOW", info.dev_addr, info.bMaxPacketSize0, info.bConfigurationValue);
 52 |         const usb_config_desc_t *config_desc = host.getConfigurationDescriptor();
 53 |         int offset = 0;
 54 | 
 55 |         for (size_t n = 0; n < config_desc->bNumInterfaces; n++)
 56 |         {
 57 |             const usb_intf_desc_t *intf = usb_parse_interface_descriptor(config_desc, n, 0, &offset);
 58 | 
 59 |             if (intf->bInterfaceClass == 0x08) // MSC
 60 |             {
 61 |                 msc_transfer_cb_t cb = {
 62 |                     .capacity_cb = capacity_cb,
 63 |                     .inquiry_cb = inquiry_cb,
 64 |                 };
 65 |                 device = new USBmscDevice(config_desc, &host);
 66 |                 ((USBmscDevice *)device)->registerCallbacks(cb);
 67 |                 n = config_desc->bNumInterfaces;
 68 |             }
 69 | 
 70 |             if (device)
 71 |                 device->init();
 72 |         }
 73 |     } else {
 74 |         ESP_LOGI("", "DEVICE gone event");
 75 |         if(device)
 76 |         {
 77 |             device->unmount(MOUNT_POINT);
 78 |             device->deinit();
 79 |             delete(device);
 80 |             is_mount = false;
 81 |         }
 82 |         device = NULL;
 83 |     }
 84 | }
 85 | 
 86 | #define TAG ""
 87 | char line[5000];
 88 | 
 89 | static void getFreeSpace(uint64_t* used_space, uint64_t* max_space)
 90 | {
 91 |     FATFS *fs;
 92 |     DWORD dwc;
 93 |     char drv[4] = {};
 94 |     device->getDrivePath(drv);
 95 |     if (f_getfree(drv, &dwc, &fs) == FR_OK)
 96 |     {
 97 |         *used_space =
 98 |             ((uint64_t)fs->csize * (fs->n_fatent - 2 - fs->free_clst)) * fs->ssize;
 99 |         *max_space = ((uint64_t)fs->csize * (fs->n_fatent - 2)) * fs->ssize;
100 |     }
101 | }
102 | 
103 | extern "C" void app_main(void)
104 | {
105 |     esp_err_t err = nvs_flash_init();
106 |     if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
107 |         // NVS partition was truncated and needs to be erased
108 |         // Retry nvs_flash_init
109 |         nvs_flash_erase();
110 |         err = nvs_flash_init();
111 |     }
112 | 
113 |     esp_log_level_set("wifi", ESP_LOG_ERROR);
114 | 
115 | 
116 |     // heap_caps_print_heap_info(MALLOC_CAP_INTERNAL);
117 |     host.registerClientCb(client_event_callback);
118 |     host.init();
119 | 
120 |     initWifi(EXAMPLE_ESP_WIFI_SSID, EXAMPLE_ESP_WIFI_PASS);
121 | 
122 |     web_server(MOUNT_POINT);
123 | 
124 |     while (!is_mount)
125 |     {
126 |         vTaskDelay(1);
127 |     }
128 | 
129 |     uint64_t used_space; 
130 |     uint64_t max_space;
131 |     getFreeSpace(&used_space, &max_space);
132 | 
133 |     ESP_LOGI("TEST", "storage used: %lld/%lld", used_space, max_space);
134 | }
135 | 


--------------------------------------------------------------------------------
/examples/remote_pendrive/main/web_server.c:
--------------------------------------------------------------------------------
  1 | /* HTTP File Server Example
  2 | 
  3 |    This example code is in the Public Domain (or CC0 licensed, at your option.)
  4 | 
  5 |    Unless required by applicable law or agreed to in writing, this
  6 |    software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
  7 |    CONDITIONS OF ANY KIND, either express or implied.
  8 | */
  9 | 
 10 | #include <stdio.h>
 11 | #include <string.h>
 12 | #include <sys/param.h>
 13 | #include <sys/unistd.h>
 14 | #include <sys/stat.h>
 15 | #include <dirent.h>
 16 | 
 17 | #include <driver/sdmmc_defs.h>
 18 | #include <driver/sdspi_host.h>
 19 | #include <driver/sdmmc_types.h>
 20 | #include <driver/sdspi_host.h>
 21 | #include <esp_spiffs.h>
 22 | #include <esp_vfs_fat.h>
 23 | #include <sdmmc_cmd.h>
 24 | #include <sys/stat.h>
 25 | #include <sys/types.h>
 26 | #include "diskio.h"
 27 | #include <fcntl.h>
 28 | #include "ff.h"
 29 | 
 30 | #include "esp_err.h"
 31 | #include "esp_log.h"
 32 | 
 33 | #include "esp_vfs.h"
 34 | #include "esp_spiffs.h"
 35 | #include "esp_http_server.h"
 36 | #include "esp_wifi_types.h"
 37 | #include "esp_ota_ops.h"
 38 | #include "esp_partition.h"
 39 | 
 40 | #include "wifi.h"
 41 | #include <math.h>
 42 | 
 43 | extern const char index_html_start[] asm("_binary_index_html_start");
 44 | extern const char index_html_end[] asm("_binary_index_html_end");
 45 | extern const char app_js_start[] asm("_binary_app_js_start");
 46 | extern const char app_js_end[] asm("_binary_app_js_end");
 47 | extern const char app_css_start[] asm("_binary_app_css_start");
 48 | extern const char app_css_end[] asm("_binary_app_css_end");
 49 | 
 50 | /* Max length a file path can have on storage */
 51 | #define FILE_PATH_MAX 255
 52 | #define VFS_MOUNT "/files"
 53 | 
 54 | /* Scratch buffer size */
 55 | #define SCRATCH_BUFSIZE 20 * 1024
 56 | 
 57 | /**
 58 |  * Helper function to encode URL with %20 (space) in folder/file name
 59 |  * 
 60 |  */
 61 | unsigned char h2int(char c)
 62 | {
 63 |     if (c >= '0' && c <= '9')
 64 |     {
 65 |         return ((unsigned char)c - '0');
 66 |     }
 67 |     if (c >= 'a' && c <= 'f')
 68 |     {
 69 |         return ((unsigned char)c - 'a' + 10);
 70 |     }
 71 |     if (c >= 'A' && c <= 'F')
 72 |     {
 73 |         return ((unsigned char)c - 'A' + 10);
 74 |     }
 75 |     return (0);
 76 | }
 77 | 
 78 | void urldecode(char *file)
 79 | {
 80 |     char encodedString[256] = {};
 81 |     char c;
 82 |     char code0;
 83 |     char code1;
 84 |     int n = 0;
 85 |     for (int i = 0; i < strlen(file); i++)
 86 |     {
 87 |         c = file[i];
 88 |         if (c == '+')
 89 |         {
 90 |             encodedString[n++] = ' ';
 91 |         }
 92 |         else if (c == '%')
 93 |         {
 94 |             i++;
 95 |             code0 = file[i];
 96 |             i++;
 97 |             code1 = file[i];
 98 |             c = (h2int(code0) << 4) | h2int(code1);
 99 |             encodedString[n++] = c;
100 |         }
101 |         else
102 |         {
103 | 
104 |             encodedString[n++] = c;
105 |         }
106 |         // yield();
107 |     }
108 |     encodedString[n++] = 0x0;
109 | 
110 |     memset(file, 0, strlen(file));
111 |     strlcpy(file, encodedString, strlen(encodedString) + 1);
112 | }
113 | 
114 | struct web_server_data
115 | {
116 |     /* Base path of file storage */
117 |     char base_path[ESP_VFS_PATH_MAX + 1];
118 | 
119 |     /* Scratch buffer for temporary storage during file transfer */
120 |     char *scratch;
121 | };
122 | 
123 | static const char *TAG = "web_server";
124 | static esp_err_t set_content_type_from_file(httpd_req_t *req, const char *filename);
125 | 
126 | /**
127 |  * Make files tree to JSON string
128 |  * TODO add indexing or send in chunks
129 |  */
130 | static esp_err_t http_resp_dir_js(httpd_req_t *req, const char *dirpath)
131 | {
132 |     char entrypath[FILE_PATH_MAX];
133 |     char entrysize[32];
134 |     const char *entrytype;
135 | 
136 |     struct dirent *entry;
137 |     struct stat entry_stat;
138 |     char _dirpath[255] = {0};
139 |     const size_t dirpath_len = strlen(dirpath);
140 |     strncpy(_dirpath, dirpath, 255);
141 |     _dirpath[dirpath_len - 1] = 0x0;
142 |     int len = httpd_req_get_url_query_len(req);
143 |     int queryindex = 0;
144 |     char buf[20] = {0};
145 |     if (len)
146 |     {
147 |         httpd_req_get_url_query_str(req, buf, 20);
148 |         char *index = strstr(buf, "index=");
149 |         queryindex = atoi(index + 6);
150 |         ESP_LOGI(TAG, "query string len: %d => %s", queryindex, buf);
151 |     }
152 | 
153 |     DIR *dir = opendir(_dirpath);
154 | 
155 |     /* Retrieve the base path of file storage to construct the full path */
156 |     strlcpy(entrypath, dirpath, sizeof(entrypath));
157 | 
158 |     if (!dir)
159 |     {
160 |         ESP_LOGE(TAG, "Failed to stat dir : %s", _dirpath);
161 |         /* Respond with 404 Not Found */
162 |         httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "Directory does not exist");
163 |         return ESP_FAIL;
164 |     }
165 | 
166 |     uint8_t n = 0;
167 |     // /* Iterate over all files / folders and fetch their names and sizes */
168 |     char _script[500] = {0};
169 |     strcpy(_script, "[");
170 |     if (strlen(dirpath) > 7)
171 |     {
172 |         sprintf(_script + strlen(_script), "{\"path\":\"%s/..\", \"dir\":1,\"name\":\"Up\", \"size\":\"0\"}", _dirpath);
173 |     }
174 |     else
175 |     {
176 |         sprintf(_script + strlen(_script), "{\"path\":\"%s\", \"dir\":1,\"name\":\"Refresh\", \"size\":\"0\"}", _dirpath);
177 |     }
178 |     httpd_resp_set_type(req, "application/json; charset=utf-8");
179 |     httpd_resp_sendstr_chunk(req, _script);
180 |     memset(_script, 0, 500);
181 | 
182 |     entry = readdir(dir);
183 | 
184 |     while (entry != NULL)
185 |     {
186 |         entrytype = (entry->d_type == DT_DIR ? "directory" : "file");
187 | 
188 |         strlcpy(entrypath + dirpath_len, entry->d_name, sizeof(entrypath) - dirpath_len);
189 | 
190 |         int st = 0;
191 |         st = stat(entrypath, &entry_stat);
192 | 
193 |         if (st == -1)
194 |         {
195 |             ESP_LOGE(TAG, "Failed to stat %s : %s", entrytype, entry->d_name);
196 |             entry = readdir(dir);
197 |             continue;
198 |         }
199 |         sprintf(entrysize, "%ld", entry_stat.st_size);
200 |         // ESP_LOGI(TAG, "Found %s : %s (%s bytes)", entrytype, entry->d_name, entrysize);
201 | 
202 |         strlcpy(_script + strlen(_script), ", ", 3);
203 |         /* Send chunk of HTML file containing table entries with file name and size */
204 |         strlcpy(_script + strlen(_script), "{\"path\":\"", 10);
205 |         strlcpy(_script + strlen(_script), dirpath, strlen(dirpath) + 1);
206 |         strlcpy(_script + strlen(_script), entry->d_name, strlen(entry->d_name) + 1);
207 |         strlcpy(_script + strlen(_script), "\", ", 4);
208 | 
209 |         if (entry->d_type == DT_DIR)
210 |         {
211 |             strlcpy(_script + strlen(_script), "\"dir\":1,", 9);
212 |         }
213 |         else
214 |         {
215 |             strlcpy(_script + strlen(_script), "\"dir\":0,", 9);
216 |         }
217 | 
218 |         strlcpy(_script + strlen(_script), "\"name\":\"", 9);
219 |         strlcpy(_script + strlen(_script), entry->d_name, strlen(entry->d_name) + 1);
220 |         strlcpy(_script + strlen(_script), "\", \"size\":\"", 12);
221 |         strlcpy(_script + strlen(_script), entrysize, strlen(entrysize) + 1);
222 |         strlcpy(_script + strlen(_script), "\"", 2);
223 |         strlcpy(_script + strlen(_script), "}", 4);
224 | 
225 |         n++;
226 |         httpd_resp_sendstr_chunk(req, _script);
227 |         memset(_script, 0, 500);
228 | 
229 |         entry = readdir(dir);
230 |     }
231 |     closedir(dir);
232 |     strlcpy(_script + strlen(_script), "]", 2);
233 |     ESP_LOGD(TAG, "[%d] => %s", strlen(_script), _script);
234 | 
235 |     httpd_resp_sendstr_chunk(req, _script);
236 | 
237 |     /* Respond with an empty chunk to signal HTTP response completion */
238 |     httpd_resp_send_chunk(req, NULL, 0);
239 |     return ESP_OK;
240 | }
241 | 
242 | #define IS_FILE_EXT(filename, ext) \
243 |     (strcasecmp(&filename[strlen(filename) - sizeof(ext) + 1], ext) == 0)
244 | 
245 | /* Set HTTP response content type according to file extension */
246 | static esp_err_t set_content_type_from_file(httpd_req_t *req, const char *filename)
247 | {
248 |     if (IS_FILE_EXT(filename, ".html"))
249 |     {
250 |         return httpd_resp_set_type(req, "text/html");
251 |     }
252 |     else if (IS_FILE_EXT(filename, ".htm"))
253 |     {
254 |         return httpd_resp_set_type(req, "text/html");
255 |     }
256 |     else if (IS_FILE_EXT(filename, ".jpeg"))
257 |     {
258 |         return httpd_resp_set_type(req, "image/jpeg");
259 |     }
260 |     else if (IS_FILE_EXT(filename, ".png"))
261 |     {
262 |         return httpd_resp_set_type(req, "image/png");
263 |     }
264 |     else if (IS_FILE_EXT(filename, ".ico"))
265 |     {
266 |         return httpd_resp_set_type(req, "image/x-icon");
267 |     }
268 |     else if (IS_FILE_EXT(filename, ".mpg"))
269 |     {
270 |         return httpd_resp_set_type(req, "audio/mpeg");
271 |     }
272 |     else if (IS_FILE_EXT(filename, ".mp3"))
273 |     {
274 |         return httpd_resp_set_type(req, "audio/mpeg");
275 |     }
276 |     else if (IS_FILE_EXT(filename, ".css"))
277 |     {
278 |         return httpd_resp_set_type(req, "text/css");
279 |     }
280 |     else if (IS_FILE_EXT(filename, ".js"))
281 |     {
282 |         return httpd_resp_set_type(req, "application/javascript");
283 |     }
284 |     else if (IS_FILE_EXT(filename, ".pdf"))
285 |     {
286 |         return httpd_resp_set_type(req, "application/pdf");
287 |     }
288 | 
289 |     /* This is a limited set only */
290 |     /* For any other type always set as plain text */
291 |     return httpd_resp_set_type(req, "text/plain");
292 | }
293 | 
294 | /* Copies the full path into destination buffer and returns
295 |  * pointer to path (skipping the preceding base path) */
296 | static const char *get_path_from_uri(char *dest, const char *base_path, const char *uri, size_t destsize)
297 | {
298 |     const size_t base_pathlen = strlen(base_path);
299 |     size_t pathlen = strlen(uri);
300 | 
301 |     const char *quest = strchr(uri, '?');
302 |     if (quest)
303 |     {
304 |         pathlen = MIN(pathlen, quest - uri);
305 |     }
306 |     const char *hash = strchr(uri, '#');
307 |     if (hash)
308 |     {
309 |         pathlen = MIN(pathlen, hash - uri);
310 |     }
311 | 
312 |     if (base_pathlen + pathlen + 1 > destsize)
313 |     {
314 |         /* Full path string won't fit into destination buffer */
315 |         return NULL;
316 |     }
317 | 
318 |     /* Construct full path (base + path) */
319 |     strcpy(dest, base_path);
320 |     strlcpy(dest + strlen(base_path), &uri[6], pathlen + 1);
321 |     urldecode(dest);
322 |     /* Return pointer to path, skipping the base */
323 |     return dest;
324 | }
325 | 
326 | /*
327 |  * Structure holding server handle
328 |  * and internal socket fd in order
329 |  * to use out of request send
330 |  */
331 | struct async_resp_arg
332 | {
333 |     httpd_handle_t hd;
334 |     int fd;
335 | };
336 | 
337 | /**
338 |  * Handles to send static files
339 |  */
340 | static esp_err_t index_handler(httpd_req_t *req)
341 | {
342 |     httpd_resp_send_chunk(req, index_html_start, index_html_end - index_html_start);
343 | 
344 |     /* Respond with an empty chunk to signal HTTP response completion */
345 |     httpd_resp_send_chunk(req, NULL, 0);
346 |     return ESP_OK;
347 | }
348 | 
349 | static esp_err_t appcss_handler(httpd_req_t *req)
350 | {
351 |     set_content_type_from_file(req, "app.css");
352 |     httpd_resp_send_chunk(req, app_css_start, app_css_end - app_css_start);
353 | 
354 |     /* Respond with an empty chunk to signal HTTP response completion */
355 |     httpd_resp_send_chunk(req, NULL, 0);
356 |     return ESP_OK;
357 | }
358 | 
359 | /**
360 |  * Set STA or AP wifi credentials and init wifi accordingly
361 |  */
362 | static esp_err_t wifi_credentials_handler(httpd_req_t *req)
363 | {
364 |     char content[200] = {0};
365 | 
366 |     /* Truncate if content length larger than the buffer */
367 |     size_t len = MIN(req->content_len, sizeof(content));
368 | 
369 |     int ret = httpd_req_recv(req, content, len);
370 |     if (ret <= 0)
371 |     { /* 0 return value indicates connection closed */
372 |         /* Check if timeout occurred */
373 |         if (ret == HTTPD_SOCK_ERR_TIMEOUT)
374 |         {
375 |             httpd_resp_send_408(req);
376 |         }
377 |         return ESP_FAIL;
378 |     }
379 | 
380 |     char *ssid = strstr(content, "ssid=");
381 |     char *pass = strstr(content, "pass=");
382 |     char *ap = strstr(content, "ap=");
383 |     char *auth = strstr(content, "auth=");
384 |     char _ssid[32] = {0}, _pass[32] = {0};
385 |     int ssid_len = pass - ssid - 6;
386 |     int pass_len = ap - pass - 6;
387 |     int type = atoi(ap + 3);
388 |     int _auth = atoi(auth + 5);
389 |     strncpy(_ssid, ssid + 5, ssid_len);
390 |     strncpy(_pass, pass + 5, pass_len);
391 |     ESP_LOGI(TAG, "query string len: %d => %s", len, content);
392 |     ESP_LOGI(TAG, "ssid: %s, pass: %s, type: %s, auth: %d", _ssid, _pass, type ? "AP" : "STA", _auth);
393 | 
394 |     if (ssid_len && (!pass_len || (8 <= pass_len && pass_len <= 32)))
395 |     {
396 |         if (type)
397 |         {
398 |             wifi_init_softap(_ssid, _pass, _auth);
399 |         }
400 |         else
401 |         {
402 |             wifi_init_sta(_ssid, _pass);
403 |         }
404 |     }
405 | 
406 |     /* Respond with an empty chunk to signal HTTP response completion */
407 |     httpd_resp_send_chunk(req, NULL, 0);
408 |     return ESP_OK;
409 | }
410 | 
411 | /* Handler to download a file kept on the server */
412 | static esp_err_t files_tree_handler(httpd_req_t *req)
413 | {
414 |     char filepath[FILE_PATH_MAX];
415 |     FILE *fd = NULL;
416 |     struct stat file_stat;
417 | 
418 |     const char *filename = get_path_from_uri(filepath, ((struct web_server_data *)req->user_ctx)->base_path,
419 |                                              req->uri, sizeof(filepath));
420 |     if (!filename)
421 |     {
422 |         ESP_LOGE(TAG, "Filename is too long");
423 |         /* Respond with 500 Internal Server Error */
424 |         httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Filename too long");
425 |         return ESP_FAIL;
426 |     }
427 | 
428 |     /* If name has trailing '/', respond with directory contents */
429 |     if (filename[strlen(filename) - 1] == '/')
430 |     {
431 |         return http_resp_dir_js(req, filename);
432 |     }
433 | 
434 |     if (stat(filepath, &file_stat) == -1)
435 |     {
436 |         /* If file not present on SPIFFS check if URI
437 |          * corresponds to one of the hardcoded paths */
438 |         if (strcmp(filename, "/index.html") == 0)
439 |         {
440 |             return index_handler(req);
441 |             // } else if (strcmp(filename, "/favicon.ico") == 0) {
442 |             //     return favicon_get_handler(req);
443 |         }
444 |         ESP_LOGE(TAG, "Failed to stat file : %s", filepath);
445 |         /* Respond with 404 Not Found */
446 |         httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "File does not exist");
447 |         return ESP_FAIL;
448 |     }
449 | 
450 |     fd = fopen(filepath, "r");
451 |     if (!fd)
452 |     {
453 |         ESP_LOGE(TAG, "Failed to read existing file : %s", filepath);
454 |         /* Respond with 500 Internal Server Error */
455 |         httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to read existing file");
456 |         return ESP_FAIL;
457 |     }
458 | 
459 |     ESP_LOGI(TAG, "Sending file : %s (%ld bytes)...", filename, file_stat.st_size);
460 |     set_content_type_from_file(req, filename);
461 | 
462 |     /* Retrieve the pointer to scratch buffer for temporary storage */
463 |     char *chunk = ((struct web_server_data *)req->user_ctx)->scratch;
464 |     size_t chunksize;
465 |     do
466 |     {
467 |         /* Read file in chunks into the scratch buffer */
468 |         chunksize = fread(chunk, 1, SCRATCH_BUFSIZE, fd);
469 | 
470 |         if (chunksize > 0)
471 |         {
472 |             esp_err_t err;
473 |             /* Send the buffer contents as HTTP response chunk */
474 |             if ((err = httpd_resp_send_chunk(req, chunk, chunksize)) != ESP_OK)
475 |             {
476 |                 fclose(fd);
477 |                 ESP_LOGE(TAG, "File sending failed! => %d", err);
478 |                 /* Abort sending file */
479 |                 httpd_resp_sendstr_chunk(req, NULL);
480 |                 /* Respond with 500 Internal Server Error */
481 |                 httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to send file");
482 |                 return ESP_FAIL;
483 |             }
484 |         }
485 |         /* Keep looping till the whole file is sent */
486 |     } while (chunksize > 0);
487 | 
488 |     /* Close file after sending complete */
489 |     fclose(fd);
490 |     ESP_LOGI(TAG, "File sending complete");
491 | 
492 |     /* Respond with an empty chunk to signal HTTP response completion */
493 |     httpd_resp_send_chunk(req, NULL, 0);
494 |     return ESP_OK;
495 | }
496 | 
497 | static esp_err_t appjs_handler(httpd_req_t *req)
498 | {
499 |     set_content_type_from_file(req, "app.js");
500 |     httpd_resp_send_chunk(req, app_js_start, app_js_end - app_js_start);
501 | 
502 |     /* Respond with an empty chunk to signal HTTP response completion */
503 |     httpd_resp_send_chunk(req, NULL, 0);
504 |     return ESP_OK;
505 | }
506 | 
507 | esp_err_t formatSD()
508 | {
509 |     FRESULT res = FR_OK;
510 |     esp_err_t err = ESP_OK;
511 |     const size_t workbuf_size = 4096;
512 |     void *workbuf = NULL;
513 |     ESP_LOGW(TAG, "partitioning card");
514 | 
515 |     workbuf = ff_memalloc(workbuf_size);
516 |     if (workbuf == NULL)
517 |     {
518 |         return ESP_ERR_NO_MEM;
519 |     }
520 | 
521 |     DWORD plist[] = {20, 0};
522 |     res = f_fdisk(0, plist, workbuf);
523 |     if (res != FR_OK)
524 |     {
525 |         err = ESP_FAIL;
526 |         ESP_LOGE(TAG, "f_fdisk failed (%d)", res);
527 |     }
528 |     else
529 |     {
530 |         size_t alloc_unit_size = 8 * 512;
531 |         ESP_LOGW(TAG, "formatting card, allocation unit size=%d", alloc_unit_size);
532 |         res = f_mkfs("", FM_FAT32, alloc_unit_size, workbuf, workbuf_size);
533 |         if (res != FR_OK)
534 |         {
535 |             err = ESP_FAIL;
536 |             ESP_LOGE(TAG, "f_mkfs failed (%d)", res);
537 |         }
538 |     }
539 |     mkdir("/files/tmp", 0755); // add tmp folder
540 | 
541 |     ESP_LOGW(TAG, "partitioning card finished");
542 |     free(workbuf);
543 |     return err;
544 | }
545 | 
546 | bool isFormatting;
547 | static esp_err_t format_card_handler(httpd_req_t *req)
548 | {
549 |     if (isFormatting)
550 |         return ESP_OK;
551 |     isFormatting = true;
552 |     formatSD();
553 |     isFormatting = false;
554 |     /* Respond with an empty chunk to signal HTTP response completion */
555 |     httpd_resp_send_chunk(req, NULL, 0);
556 |     return ESP_OK;
557 | }
558 | 
559 | static esp_err_t mkdir_handler(httpd_req_t *req)
560 | {
561 |     char content[200] = {0};
562 | 
563 |     /* Truncate if content length larger than the buffer */
564 |     size_t len = MIN(req->content_len, sizeof(content));
565 | 
566 |     int ret = httpd_req_recv(req, content, len);
567 |     if (ret <= 0)
568 |     { /* 0 return value indicates connection closed */
569 |         /* Check if timeout occurred */
570 |         if (ret == HTTPD_SOCK_ERR_TIMEOUT)
571 |         {
572 |             httpd_resp_send_408(req);
573 |         }
574 |         return ESP_FAIL;
575 |     }
576 | 
577 |     char *name = strstr(content, "dirname=");
578 |     char path[256] = {};
579 |     sprintf(path, "%s", name + 8);
580 |     if (mkdir(path, 0755))
581 |     {
582 |         ESP_LOGE("", "failed to mkdir: %s", path);
583 |         httpd_resp_set_status(req, "409");
584 |         httpd_resp_send(req, NULL, 0);
585 |     }
586 |     else
587 |     {
588 |         httpd_resp_set_status(req, "201");
589 |         httpd_resp_send(req, NULL, 0);
590 |     }
591 |     /* Respond with an empty chunk to signal HTTP response completion */
592 |     // httpd_resp_send_chunk(req, NULL, 0);
593 |     return ESP_OK;
594 | }
595 | 
596 | static esp_err_t delete_handler(httpd_req_t *req)
597 | {
598 |     char content[200] = {0};
599 | 
600 |     /* Truncate if content length larger than the buffer */
601 |     size_t len = MIN(req->content_len, sizeof(content));
602 | 
603 |     int ret = httpd_req_recv(req, content, len);
604 |     if (ret <= 0)
605 |     { /* 0 return value indicates connection closed */
606 |         /* Check if timeout occurred */
607 |         if (ret == HTTPD_SOCK_ERR_TIMEOUT)
608 |         {
609 |             httpd_resp_send_408(req);
610 |         }
611 |         return ESP_FAIL;
612 |     }
613 | 
614 |     char *name = strstr(content, "file=");
615 |     char path[256] = {};
616 |     sprintf(path, "%s", name + 5);
617 |     if (unlink(path))
618 |     {
619 |         ESP_LOGE("", "failed to unlink: %s", path);
620 |         httpd_resp_set_status(req, "409");
621 |         httpd_resp_send(req, NULL, 0);
622 |     }
623 |     else
624 |     {
625 |         httpd_resp_set_status(req, "201");
626 |         httpd_resp_send(req, NULL, 0);
627 |     }
628 |     /* Respond with an empty chunk to signal HTTP response completion */
629 |     // httpd_resp_send_chunk(req, NULL, 0);
630 |     return ESP_OK;
631 | }
632 | 
633 | /**
634 |  * Function to start the file server
635 |  */
636 | void web_server(char *path)
637 | {
638 |     static struct web_server_data *server_data = NULL;
639 | 
640 |     /* Allocate memory for server data */
641 |     server_data = calloc(1, sizeof(struct web_server_data));
642 |     server_data->scratch = heap_caps_calloc(1, SCRATCH_BUFSIZE, MALLOC_CAP_INTERNAL);
643 | 
644 |     if (!server_data)
645 |     {
646 |         ESP_LOGE(TAG, "Failed to allocate memory for server data");
647 |         vTaskDelete(NULL);
648 |     }
649 |     strlcpy(server_data->base_path, path,
650 |             sizeof(server_data->base_path));
651 | 
652 |     httpd_handle_t server = NULL;
653 |     httpd_config_t config = HTTPD_DEFAULT_CONFIG();
654 | 
655 |     /* Use the URI wildcard matching function in order to
656 |      * allow the same handler to respond to multiple different
657 |      * target URIs which match the wildcard scheme */
658 |     config.uri_match_fn = httpd_uri_match_wildcard;
659 |     config.max_open_sockets = 7;
660 |     config.stack_size = 10 * 1024;
661 |     config.max_uri_handlers = 10;
662 | 
663 |     ESP_LOGI(TAG, "Starting HTTP Server");
664 |     if (httpd_start(&server, &config) != ESP_OK)
665 |     {
666 |         ESP_LOGE(TAG, "Failed to start file server!");
667 |         free(server_data->scratch);
668 |         free(server_data);
669 |     }
670 | 
671 |     httpd_uri_t index = {
672 |         .uri = "/", // Match all URIs of type /path/to/file
673 |         .method = HTTP_GET,
674 |         .handler = index_handler,
675 |         .user_ctx = server_data // Pass server data as context
676 |     };
677 |     httpd_register_uri_handler(server, &index);
678 | 
679 |     httpd_uri_t app_css = {
680 |         .uri = "/app.css", // Match all URIs of type /path/to/file
681 |         .method = HTTP_GET,
682 |         .handler = appcss_handler,
683 |         .user_ctx = server_data // Pass server data as context
684 |     };
685 |     httpd_register_uri_handler(server, &app_css);
686 | 
687 |     /* URI handler for getting files tree and display files */
688 |     httpd_uri_t files_tree = {
689 |         .uri = "/files/*", // Match all URIs of type /path/to/file
690 |         .method = HTTP_GET,
691 |         .handler = files_tree_handler,
692 |         .user_ctx = server_data // Pass server data as context
693 |     };
694 |     httpd_register_uri_handler(server, &files_tree);
695 | 
696 |     httpd_uri_t wifi = {
697 |         .uri = "/wifi",
698 |         .method = HTTP_POST,
699 |         .handler = wifi_credentials_handler,
700 |         .user_ctx = server_data // Pass server data as context
701 |     };
702 |     httpd_register_uri_handler(server, &wifi);
703 | 
704 |     httpd_uri_t app_js = {
705 |         .uri = "/app.js", // Match all URIs of type /path/to/file
706 |         .method = HTTP_GET,
707 |         .handler = appjs_handler,
708 |         .user_ctx = server_data // Pass server data as context
709 |     };
710 |     httpd_register_uri_handler(server, &app_js);
711 | 
712 |     httpd_uri_t format = {
713 |         .uri = "/format",
714 |         .method = HTTP_POST,
715 |         .handler = format_card_handler,
716 |         .user_ctx = server_data // Pass server data as context
717 |     };
718 |     httpd_register_uri_handler(server, &format);
719 | 
720 |     httpd_uri_t _mkdir = {
721 |         .uri = "/mkdir",
722 |         .method = HTTP_POST,
723 |         .handler = mkdir_handler,
724 |         .user_ctx = server_data // Pass server data as context
725 |     };
726 |     httpd_register_uri_handler(server, &_mkdir);
727 | 
728 |     httpd_uri_t _delete = {
729 |         .uri = "/delete",
730 |         .method = HTTP_POST,
731 |         .handler = delete_handler,
732 |         .user_ctx = server_data // Pass server data as context
733 |     };
734 |     httpd_register_uri_handler(server, &_delete);
735 | }
736 | 


--------------------------------------------------------------------------------
/examples/remote_pendrive/main/wifi.c:
--------------------------------------------------------------------------------
  1 | #include <string.h>
  2 | #include "freertos/FreeRTOS.h"
  3 | #include "freertos/task.h"
  4 | #include "esp_system.h"
  5 | #include "esp_wifi.h"
  6 | #include "esp_event.h"
  7 | #include "esp_log.h"
  8 | #include "nvs_flash.h"
  9 | 
 10 | #include "lwip/err.h"
 11 | #include "lwip/sys.h"
 12 | #include "wifi.h"
 13 | 
 14 | static const char *TAG = "wifi softAP";
 15 | 
 16 | static void wifi_event_handler(void* arg, esp_event_base_t event_base,
 17 |                                     int32_t event_id, void* event_data)
 18 | {
 19 |     if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
 20 |         esp_wifi_connect();
 21 |     } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_STACONNECTED) {
 22 |         wifi_event_ap_staconnected_t* event = (wifi_event_ap_staconnected_t*) event_data;
 23 |         ESP_LOGI(TAG, "station " MACSTR " join, AID=%d",
 24 |                  MAC2STR(event->mac), event->aid);
 25 |     } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_STADISCONNECTED) {
 26 |         wifi_event_ap_stadisconnected_t* event = (wifi_event_ap_stadisconnected_t*) event_data;
 27 |         ESP_LOGI(TAG, "station " MACSTR " leave, AID=%d",
 28 |                  MAC2STR(event->mac), event->aid);
 29 |     } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_CONNECTED) {
 30 |         wifi_event_sta_connected_t* event = (wifi_event_sta_connected_t*) event_data;
 31 |         ESP_LOGI(TAG, "station connected");
 32 |     } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
 33 |         wifi_event_sta_disconnected_t* event = (wifi_event_sta_disconnected_t*) event_data;
 34 |         ESP_LOGI(TAG, "station disconnected");
 35 |         vTaskDelay(1000);
 36 |         esp_wifi_connect();
 37 |     } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
 38 |         char myIP[20];
 39 |         memset(myIP, 0, 20);
 40 |         ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
 41 |         sprintf(myIP, IPSTR, IP2STR(&event->ip_info.ip));
 42 |         ESP_LOGI(TAG, "got ip: %s", myIP );
 43 |     }
 44 | }
 45 | 
 46 | void initWifi(const char* ssid_ap, const char* pass_ap)
 47 | {
 48 |     ESP_ERROR_CHECK(esp_netif_init());
 49 |     ESP_ERROR_CHECK(esp_event_loop_create_default());
 50 |     
 51 |     esp_netif_create_default_wifi_sta();
 52 |     esp_netif_create_default_wifi_ap();
 53 | 
 54 |     esp_netif_t *esp_netif = NULL;
 55 |     esp_netif = esp_netif_next(esp_netif);
 56 |     esp_netif_set_hostname(esp_netif, "Othernet-DC4");
 57 | 
 58 |     esp_netif = esp_netif_next(esp_netif);
 59 |     esp_netif_set_hostname(esp_netif, "Othernet-DC4");
 60 | 
 61 |     wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
 62 |     ESP_ERROR_CHECK(esp_wifi_init(&cfg));
 63 |     esp_event_handler_instance_t instance_any_id;
 64 |     ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
 65 |                                                         ESP_EVENT_ANY_ID,
 66 |                                                         &wifi_event_handler,
 67 |                                                         NULL,
 68 |                                                         &instance_any_id));
 69 | 
 70 |     esp_event_handler_instance_t instance_got_ip;
 71 |     ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
 72 |                                                     IP_EVENT_STA_GOT_IP,
 73 |                                                     &wifi_event_handler,
 74 |                                                     NULL,
 75 |                                                     &instance_got_ip));
 76 | 
 77 |     ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM) );
 78 |     // ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_NULL) );
 79 |     ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_APSTA));
 80 |     ESP_ERROR_CHECK(esp_wifi_start() );
 81 |     // wifi_init_sta(EXAMPLE_ESP_WIFI_SSID, EXAMPLE_ESP_WIFI_PASS, WIFI_MODE_STA);
 82 |     wifi_init_softap(ssid_ap, pass_ap, WIFI_AUTH_WPA2_PSK);
 83 |     esp_wifi_set_ps(WIFI_PS_NONE);
 84 | }
 85 | 
 86 | void wifi_init_softap(char* ssid, char* pass, uint8_t auth)
 87 | {
 88 | 
 89 |     wifi_config_t wifi_config = {
 90 |         .ap = {
 91 |             .ssid_len = strlen(ssid),
 92 |             .channel = 0,
 93 |             .max_connection = 3,
 94 |             .authmode = auth
 95 |         },
 96 |     };
 97 |     strcpy((char*)wifi_config.ap.ssid, ssid);
 98 |     strcpy((char*)wifi_config.ap.password, pass);
 99 |     if (strlen(pass) == 0) {
100 |         wifi_config.ap.authmode = WIFI_AUTH_OPEN;
101 |     }
102 | 
103 |     ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_AP, &wifi_config));
104 | 
105 |     ESP_LOGI(TAG, "wifi_init_softap finished. SSID:%s password:%s",
106 |              ssid, pass);
107 | }
108 | 
109 | void wifi_init_sta(char* ssid, char* pass)
110 | {
111 | 
112 |     wifi_config_t wifi_config = {0};
113 |     strcpy((char*)wifi_config.sta.ssid, ssid);
114 |     strcpy((char*)wifi_config.sta.password, pass);
115 | 
116 |     ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config));
117 |     esp_wifi_disconnect(); // if we're trying to connect with wrong credentials, don't bomb.
118 |     ESP_ERROR_CHECK( esp_wifi_connect() );
119 | 
120 |     ESP_LOGI(TAG, "wifi_init_sta finished. SSID:%s password:%s",
121 |              ssid, pass);
122 | }
123 | 


--------------------------------------------------------------------------------
/examples/remote_pendrive/main/wifi.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #pragma once
 3 | 
 4 | #ifdef __cplusplus
 5 | extern "C" {
 6 | #endif
 7 | 
 8 | void initWifi(const char*, const char*);
 9 | void wifi_init_softap(char* ssid, char* pass, uint8_t auth);
10 | void wifi_init_sta(char* ssid, char* pass);
11 | void ip_to_webusb(uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint8_t mode);
12 | void urldecode(char* file);
13 | void getStats(uint16_t*, uint16_t*);
14 | void getPacketStats(int8_t*, int8_t*, int8_t*);
15 | 
16 | void web_server(char*);
17 | 
18 | #ifdef __cplusplus
19 | }
20 | #endif
21 | 


--------------------------------------------------------------------------------