feedc0de/arduino-esp32
1
0
Fork 0
forked from espressif/arduino-esp32
Code Pull Requests Activity

IDF master b86fe0c66c

Browse Source
This commit is contained in:
me-no-dev
2021-10-13 18:21:12 +00:00
parent 2fb2ef54ce
commit 34c81be93b
538 changed files with 17119 additions and 4346 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
tools/sdk/esp32s2/include/arduino_tinyusb/include/tusb_config.h
View File

@ -52,6 +52,10 @@ extern "C" {
# define CONFIG_TINYUSB_MIDI_ENABLED 0
#endif
#ifndef CONFIG_TINYUSB_VIDEO_ENABLED
# define CONFIG_TINYUSB_VIDEO_ENABLED 0
#endif
#ifndef CONFIG_TINYUSB_CUSTOM_CLASS_ENABLED
# define CONFIG_TINYUSB_CUSTOM_CLASS_ENABLED 0
#endif
@ -99,6 +103,7 @@ extern "C" {
#define CFG_TUD_MSC CONFIG_TINYUSB_MSC_ENABLED
#define CFG_TUD_HID CONFIG_TINYUSB_HID_ENABLED
#define CFG_TUD_MIDI CONFIG_TINYUSB_MIDI_ENABLED
#define CFG_TUD_VIDEO CONFIG_TINYUSB_VIDEO_ENABLED
#define CFG_TUD_CUSTOM_CLASS CONFIG_TINYUSB_CUSTOM_CLASS_ENABLED
#define CFG_TUD_DFU_RUNTIME CONFIG_TINYUSB_DFU_RT_ENABLED
#define CFG_TUD_VENDOR CONFIG_TINYUSB_VENDOR_ENABLED
@ -117,6 +122,10 @@ extern "C" {
#define CFG_TUD_MIDI_RX_BUFSIZE CONFIG_TINYUSB_MIDI_RX_BUFSIZE
#define CFG_TUD_MIDI_TX_BUFSIZE CONFIG_TINYUSB_MIDI_TX_BUFSIZE
// The number of video streaming interfaces and endpoint size
#define CFG_TUD_VIDEO_STREAMING CONFIG_TINYUSB_VIDEO_STREAMING_IFS
#define CFG_TUD_VIDEO_STREAMING_EP_BUFSIZE CONFIG_TINYUSB_VIDEO_STREAMING_BUFSIZE
// VENDOR FIFO size of TX and RX
#define CFG_TUD_VENDOR_RX_BUFSIZE CONFIG_TINYUSB_VENDOR_RX_BUFSIZE
#define CFG_TUD_VENDOR_TX_BUFSIZE CONFIG_TINYUSB_VENDOR_TX_BUFSIZE

12
tools/sdk/esp32s2/include/arduino_tinyusb/tinyusb/src/class/audio/audio.h
View File

@ -494,18 +494,6 @@ typedef enum
/// All remaining definitions are taken from the descriptor descriptions in the UAC2 main specification
/// Isochronous End Point Attributes
typedef enum
{
TUSB_ISO_EP_ATT_NO_SYNC = 0x00,
TUSB_ISO_EP_ATT_ASYNCHRONOUS = 0x04,
TUSB_ISO_EP_ATT_ADAPTIVE = 0x08,
TUSB_ISO_EP_ATT_SYNCHRONOUS = 0x0C,
TUSB_ISO_EP_ATT_DATA = 0x00, ///< Data End Point
TUSB_ISO_EP_ATT_EXPLICIT_FB = 0x10, ///< Feedback End Point
TUSB_ISO_EP_ATT_IMPLICIT_FB = 0x20, ///< Data endpoint that also serves as an implicit feedback
} tusb_iso_ep_attribute_t;
/// Audio Class-Control Values UAC2
typedef enum
{

71
tools/sdk/esp32s2/include/arduino_tinyusb/tinyusb/src/class/cdc/cdc.h
View File

@ -58,31 +58,32 @@ typedef enum
/// Communication Interface Subclass Codes
typedef enum
{
CDC_COMM_SUBCLASS_DIRECT_LINE_CONTROL_MODEL = 0x01 , ///< Direct Line Control Model [USBPSTN1.2]
CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL , ///< Abstract Control Model [USBPSTN1.2]
CDC_COMM_SUBCLASS_TELEPHONE_CONTROL_MODEL , ///< Telephone Control Model [USBPSTN1.2]
CDC_COMM_SUBCLASS_MULTICHANNEL_CONTROL_MODEL , ///< Multi-Channel Control Model [USBISDN1.2]
CDC_COMM_SUBCLASS_CAPI_CONTROL_MODEL , ///< CAPI Control Model [USBISDN1.2]
CDC_COMM_SUBCLASS_ETHERNET_CONTROL_MODEL , ///< Ethernet Networking Control Model [USBECM1.2]
CDC_COMM_SUBCLASS_ATM_NETWORKING_CONTROL_MODEL , ///< ATM Networking Control Model [USBATM1.2]
CDC_COMM_SUBCLASS_WIRELESS_HANDSET_CONTROL_MODEL , ///< Wireless Handset Control Model [USBWMC1.1]
CDC_COMM_SUBCLASS_DEVICE_MANAGEMENT , ///< Device Management [USBWMC1.1]
CDC_COMM_SUBCLASS_MOBILE_DIRECT_LINE_MODEL , ///< Mobile Direct Line Model [USBWMC1.1]
CDC_COMM_SUBCLASS_OBEX , ///< OBEX [USBWMC1.1]
CDC_COMM_SUBCLASS_ETHERNET_EMULATION_MODEL ///< Ethernet Emulation Model [USBEEM1.0]
CDC_COMM_SUBCLASS_DIRECT_LINE_CONTROL_MODEL = 0x01 , ///< Direct Line Control Model [USBPSTN1.2]
CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL = 0x02 , ///< Abstract Control Model [USBPSTN1.2]
CDC_COMM_SUBCLASS_TELEPHONE_CONTROL_MODEL = 0x03 , ///< Telephone Control Model [USBPSTN1.2]
CDC_COMM_SUBCLASS_MULTICHANNEL_CONTROL_MODEL = 0x04 , ///< Multi-Channel Control Model [USBISDN1.2]
CDC_COMM_SUBCLASS_CAPI_CONTROL_MODEL = 0x05 , ///< CAPI Control Model [USBISDN1.2]
CDC_COMM_SUBCLASS_ETHERNET_CONTROL_MODEL = 0x06 , ///< Ethernet Networking Control Model [USBECM1.2]
CDC_COMM_SUBCLASS_ATM_NETWORKING_CONTROL_MODEL = 0x07 , ///< ATM Networking Control Model [USBATM1.2]
CDC_COMM_SUBCLASS_WIRELESS_HANDSET_CONTROL_MODEL = 0x08 , ///< Wireless Handset Control Model [USBWMC1.1]
CDC_COMM_SUBCLASS_DEVICE_MANAGEMENT = 0x09 , ///< Device Management [USBWMC1.1]
CDC_COMM_SUBCLASS_MOBILE_DIRECT_LINE_MODEL = 0x0A , ///< Mobile Direct Line Model [USBWMC1.1]
CDC_COMM_SUBCLASS_OBEX = 0x0B , ///< OBEX [USBWMC1.1]
CDC_COMM_SUBCLASS_ETHERNET_EMULATION_MODEL = 0x0C , ///< Ethernet Emulation Model [USBEEM1.0]
CDC_COMM_SUBCLASS_NETWORK_CONTROL_MODEL = 0x0D ///< Network Control Model [USBNCM1.0]
} cdc_comm_sublcass_type_t;
/// Communication Interface Protocol Codes
typedef enum
{
CDC_COMM_PROTOCOL_NONE = 0x00 , ///< No specific protocol
CDC_COMM_PROTOCOL_ATCOMMAND , ///< AT Commands: V.250 etc
CDC_COMM_PROTOCOL_ATCOMMAND_PCCA_101 , ///< AT Commands defined by PCCA-101
CDC_COMM_PROTOCOL_ATCOMMAND_PCCA_101_AND_ANNEXO , ///< AT Commands defined by PCCA-101 & Annex O
CDC_COMM_PROTOCOL_ATCOMMAND_GSM_707 , ///< AT Commands defined by GSM 07.07
CDC_COMM_PROTOCOL_ATCOMMAND_3GPP_27007 , ///< AT Commands defined by 3GPP 27.007
CDC_COMM_PROTOCOL_ATCOMMAND_CDMA , ///< AT Commands defined by TIA for CDMA
CDC_COMM_PROTOCOL_ETHERNET_EMULATION_MODEL ///< Ethernet Emulation Model
CDC_COMM_PROTOCOL_NONE = 0x00 , ///< No specific protocol
CDC_COMM_PROTOCOL_ATCOMMAND = 0x01 , ///< AT Commands: V.250 etc
CDC_COMM_PROTOCOL_ATCOMMAND_PCCA_101 = 0x02 , ///< AT Commands defined by PCCA-101
CDC_COMM_PROTOCOL_ATCOMMAND_PCCA_101_AND_ANNEXO = 0x03 , ///< AT Commands defined by PCCA-101 & Annex O
CDC_COMM_PROTOCOL_ATCOMMAND_GSM_707 = 0x04 , ///< AT Commands defined by GSM 07.07
CDC_COMM_PROTOCOL_ATCOMMAND_3GPP_27007 = 0x05 , ///< AT Commands defined by 3GPP 27.007
CDC_COMM_PROTOCOL_ATCOMMAND_CDMA = 0x06 , ///< AT Commands defined by TIA for CDMA
CDC_COMM_PROTOCOL_ETHERNET_EMULATION_MODEL = 0x07 ///< Ethernet Emulation Model
} cdc_comm_protocol_type_t;
//------------- SubType Descriptor in COMM Functional Descriptor -------------//
@ -114,7 +115,8 @@ typedef enum
CDC_FUNC_DESC_COMMAND_SET = 0x16 , ///< Command Set Functional Descriptor
CDC_FUNC_DESC_COMMAND_SET_DETAIL = 0x17 , ///< Command Set Detail Functional Descriptor
CDC_FUNC_DESC_TELEPHONE_CONTROL_MODEL = 0x18 , ///< Telephone Control Model Functional Descriptor
CDC_FUNC_DESC_OBEX_SERVICE_IDENTIFIER = 0x19 ///< OBEX Service Identifier Functional Descriptor
CDC_FUNC_DESC_OBEX_SERVICE_IDENTIFIER = 0x19 , ///< OBEX Service Identifier Functional Descriptor
CDC_FUNC_DESC_NCM = 0x1A , ///< NCM Functional Descriptor
}cdc_func_desc_type_t;
//--------------------------------------------------------------------+
@ -122,7 +124,8 @@ typedef enum
//--------------------------------------------------------------------+
// SUBCLASS code of Data Interface is not used and should/must be zero
/// Data Interface Protocol Codes
// Data Interface Protocol Codes
typedef enum{
CDC_DATA_PROTOCOL_ISDN_BRI = 0x30, ///< Physical interface protocol for ISDN BRI
CDC_DATA_PROTOCOL_HDLC = 0x31, ///< HDLC
@ -147,7 +150,6 @@ typedef enum
{
CDC_REQUEST_SEND_ENCAPSULATED_COMMAND = 0x00, ///< is used to issue a command in the format of the supported control protocol of the Communications Class interface
CDC_REQUEST_GET_ENCAPSULATED_RESPONSE = 0x01, ///< is used to request a response in the format of the supported control protocol of the Communications Class interface.
CDC_REQUEST_SET_COMM_FEATURE = 0x02,
CDC_REQUEST_GET_COMM_FEATURE = 0x03,
CDC_REQUEST_CLEAR_COMM_FEATURE = 0x04,
@ -194,21 +196,18 @@ typedef enum
// Management Elemenent Notification (Notification Endpoint)
//--------------------------------------------------------------------+
/// Communication Interface Management Element Notification Codes
/// 6.3 Notification Codes
typedef enum
{
NETWORK_CONNECTION = 0x00, ///< This notification allows the device to notify the host about network connection status.
RESPONSE_AVAILABLE = 0x01, ///< This notification allows the device to notify the hostthat a response is available. This response can be retrieved with a subsequent \ref CDC_REQUEST_GET_ENCAPSULATED_RESPONSE request.
AUX_JACK_HOOK_STATE = 0x08,
RING_DETECT = 0x09,
SERIAL_STATE = 0x20,
CALL_STATE_CHANGE = 0x28,
LINE_STATE_CHANGE = 0x29,
CONNECTION_SPEED_CHANGE = 0x2A, ///< This notification allows the device to inform the host-networking driver that a change in either the upstream or the downstream bit rate of the connection has occurred
MDLM_SEMANTIC_MODEL_NOTIFICATION = 0x40,
CDC_NOTIF_NETWORK_CONNECTION = 0x00, ///< This notification allows the device to notify the host about network connection status.
CDC_NOTIF_RESPONSE_AVAILABLE = 0x01, ///< This notification allows the device to notify the hostthat a response is available. This response can be retrieved with a subsequent \ref CDC_REQUEST_GET_ENCAPSULATED_RESPONSE request.
CDC_NOTIF_AUX_JACK_HOOK_STATE = 0x08,
CDC_NOTIF_RING_DETECT = 0x09,
CDC_NOTIF_SERIAL_STATE = 0x20,
CDC_NOTIF_CALL_STATE_CHANGE = 0x28,
CDC_NOTIF_LINE_STATE_CHANGE = 0x29,
CDC_NOTIF_CONNECTION_SPEED_CHANGE = 0x2A, ///< This notification allows the device to inform the host-networking driver that a change in either the upstream or the downstream bit rate of the connection has occurred
CDC_NOTIF_MDLM_SEMANTIC_MODEL_NOTIFICATION = 0x40,
}cdc_notification_request_t;
//--------------------------------------------------------------------+

8
tools/sdk/esp32s2/include/arduino_tinyusb/tinyusb/src/class/cdc/cdc_device.h
View File

@ -82,7 +82,7 @@ int32_t tud_cdc_n_read_char (uint8_t itf);
void tud_cdc_n_read_flush (uint8_t itf);
// Get a byte from FIFO at the specified position without removing it
bool tud_cdc_n_peek (uint8_t itf, uint8_t* u8);
bool tud_cdc_n_peek (uint8_t itf, uint8_t* ui8);
// Write bytes to TX FIFO, data may remain in the FIFO for a while
uint32_t tud_cdc_n_write (uint8_t itf, void const* buffer, uint32_t bufsize);
@ -116,7 +116,7 @@ static inline uint32_t tud_cdc_available (void);
static inline int32_t tud_cdc_read_char (void);
static inline uint32_t tud_cdc_read (void* buffer, uint32_t bufsize);
static inline void tud_cdc_read_flush (void);
static inline bool tud_cdc_peek (uint8_t* u8);
static inline bool tud_cdc_peek (uint8_t* ui8);
static inline uint32_t tud_cdc_write_char (char ch);
static inline uint32_t tud_cdc_write (void const* buffer, uint32_t bufsize);
@ -206,9 +206,9 @@ static inline void tud_cdc_read_flush (void)
tud_cdc_n_read_flush(0);
}
static inline bool tud_cdc_peek (uint8_t* u8)
static inline bool tud_cdc_peek (uint8_t* ui8)
{
return tud_cdc_n_peek(0, u8);
return tud_cdc_n_peek(0, ui8);
}
static inline uint32_t tud_cdc_write_char (char ch)

69
tools/sdk/esp32s2/include/arduino_tinyusb/tinyusb/src/class/net/ncm.h Normal file
View File

@ -0,0 +1,69 @@
/*
* The MIT License (MIT)
*
* Copyright (c) 2021, Ha Thach (tinyusb.org)
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* This file is part of the TinyUSB stack.
*/
#ifndef _TUSB_NCM_H_
#define _TUSB_NCM_H_
#include "common/tusb_common.h"
#ifdef __cplusplus
extern "C" {
#endif
// Table 4.3 Data Class Interface Protocol Codes
typedef enum
{
NCM_DATA_PROTOCOL_NETWORK_TRANSFER_BLOCK = 0x01
} ncm_data_interface_protocol_code_t;
// Table 6.2 Class-Specific Request Codes for Network Control Model subclass
typedef enum
{
NCM_SET_ETHERNET_MULTICAST_FILTERS = 0x40,
NCM_SET_ETHERNET_POWER_MANAGEMENT_PATTERN_FILTER = 0x41,
NCM_GET_ETHERNET_POWER_MANAGEMENT_PATTERN_FILTER = 0x42,
NCM_SET_ETHERNET_PACKET_FILTER = 0x43,
NCM_GET_ETHERNET_STATISTIC = 0x44,
NCM_GET_NTB_PARAMETERS = 0x80,
NCM_GET_NET_ADDRESS = 0x81,
NCM_SET_NET_ADDRESS = 0x82,
NCM_GET_NTB_FORMAT = 0x83,
NCM_SET_NTB_FORMAT = 0x84,
NCM_GET_NTB_INPUT_SIZE = 0x85,
NCM_SET_NTB_INPUT_SIZE = 0x86,
NCM_GET_MAX_DATAGRAM_SIZE = 0x87,
NCM_SET_MAX_DATAGRAM_SIZE = 0x88,
NCM_GET_CRC_MODE = 0x89,
NCM_SET_CRC_MODE = 0x8A,
} ncm_request_code_t;
#ifdef __cplusplus
}
#endif
#endif

53
tools/sdk/esp32s2/include/arduino_tinyusb/tinyusb/src/class/net/net_device.h
View File

@ -30,14 +30,36 @@
#include "class/cdc/cdc.h"
#if CFG_TUD_ECM_RNDIS && CFG_TUD_NCM
#error "Cannot enable both ECM_RNDIS and NCM network drivers"
#endif
#include "ncm.h"
/* declared here, NOT in usb_descriptors.c, so that the driver can intelligently ZLP as needed */
#define CFG_TUD_NET_ENDPOINT_SIZE (TUD_OPT_HIGH_SPEED ? 512 : 64)
/* Maximum Tranmission Unit (in bytes) of the network, including Ethernet header */
/* Maximum Transmission Unit (in bytes) of the network, including Ethernet header */
#ifndef CFG_TUD_NET_MTU
#define CFG_TUD_NET_MTU 1514
#endif
#ifndef CFG_TUD_NCM_IN_NTB_MAX_SIZE
#define CFG_TUD_NCM_IN_NTB_MAX_SIZE 3200
#endif
#ifndef CFG_TUD_NCM_OUT_NTB_MAX_SIZE
#define CFG_TUD_NCM_OUT_NTB_MAX_SIZE 3200
#endif
#ifndef CFG_TUD_NCM_MAX_DATAGRAMS_PER_NTB
#define CFG_TUD_NCM_MAX_DATAGRAMS_PER_NTB 8
#endif
#ifndef CFG_TUD_NCM_ALIGNMENT
#define CFG_TUD_NCM_ALIGNMENT 4
#endif
#ifdef __cplusplus
extern "C" {
#endif
@ -46,8 +68,18 @@
// Application API
//--------------------------------------------------------------------+
// client must provide this: initialize any network state back to the beginning
void tud_network_init_cb(void);
// indicate to network driver that client has finished with the packet provided to network_recv_cb()
void tud_network_recv_renew(void);
// poll network driver for its ability to accept another packet to transmit
bool tud_network_can_xmit(uint16_t size);
// if network_can_xmit() returns true, network_xmit() can be called once
void tud_network_xmit(void *ref, uint16_t arg);
//--------------------------------------------------------------------+
// Application Callbacks (WEAK is optional)
//--------------------------------------------------------------------+
// client must provide this: return false if the packet buffer was not accepted
bool tud_network_recv_cb(const uint8_t *src, uint16_t size);
@ -55,18 +87,19 @@ bool tud_network_recv_cb(const uint8_t *src, uint16_t size);
// client must provide this: copy from network stack packet pointer to dst
uint16_t tud_network_xmit_cb(uint8_t *dst, void *ref, uint16_t arg);
//------------- ECM/RNDIS -------------//
// client must provide this: initialize any network state back to the beginning
void tud_network_init_cb(void);
// client must provide this: 48-bit MAC address
// TODO removed later since it is not part of tinyusb stack
extern const uint8_t tud_network_mac_address[6];
// indicate to network driver that client has finished with the packet provided to network_recv_cb()
void tud_network_recv_renew(void);
//------------- NCM -------------//
// poll network driver for its ability to accept another packet to transmit
bool tud_network_can_xmit(void);
// if network_can_xmit() returns true, network_xmit() can be called once
void tud_network_xmit(void *ref, uint16_t arg);
// callback to client providing optional indication of internal state of network driver
void tud_network_link_state_cb(bool state);
//--------------------------------------------------------------------+
// INTERNAL USBD-CLASS DRIVER API

8
tools/sdk/esp32s2/include/arduino_tinyusb/tinyusb/src/class/vendor/vendor_device.h vendored
View File

@ -44,7 +44,7 @@ bool tud_vendor_n_mounted (uint8_t itf);
uint32_t tud_vendor_n_available (uint8_t itf);
uint32_t tud_vendor_n_read (uint8_t itf, void* buffer, uint32_t bufsize);
bool tud_vendor_n_peek (uint8_t itf, uint8_t* u8);
bool tud_vendor_n_peek (uint8_t itf, uint8_t* ui8);
void tud_vendor_n_read_flush (uint8_t itf);
uint32_t tud_vendor_n_write (uint8_t itf, void const* buffer, uint32_t bufsize);
@ -59,7 +59,7 @@ uint32_t tud_vendor_n_write_str (uint8_t itf, char const* str);
static inline bool tud_vendor_mounted (void);
static inline uint32_t tud_vendor_available (void);
static inline uint32_t tud_vendor_read (void* buffer, uint32_t bufsize);
static inline bool tud_vendor_peek (uint8_t* u8);
static inline bool tud_vendor_peek (uint8_t* ui8);
static inline void tud_vendor_read_flush (void);
static inline uint32_t tud_vendor_write (void const* buffer, uint32_t bufsize);
static inline uint32_t tud_vendor_write_str (char const* str);
@ -96,9 +96,9 @@ static inline uint32_t tud_vendor_read (void* buffer, uint32_t bufsize)
return tud_vendor_n_read(0, buffer, bufsize);
}
static inline bool tud_vendor_peek (uint8_t* u8)
static inline bool tud_vendor_peek (uint8_t* ui8)
{
return tud_vendor_n_peek(0, u8);
return tud_vendor_n_peek(0, ui8);
}
static inline void tud_vendor_read_flush(void)

472
tools/sdk/esp32s2/include/arduino_tinyusb/tinyusb/src/class/video/video.h Normal file
View File

@ -0,0 +1,472 @@
/*
* The MIT License (MIT)
*
* Copyright (c) 2021 Koji KITAYAMA
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* This file is part of the TinyUSB stack.
*/
#ifndef TUSB_VIDEO_H_
#define TUSB_VIDEO_H_
#include "common/tusb_common.h"
// Table 3-19 Color Matching Descriptor
typedef enum {
VIDEO_COLOR_PRIMARIES_UNDEFINED = 0x00,
VIDEO_COLOR_PRIMARIES_BT709, // sRGB (default)
VIDEO_COLOR_PRIMARIES_BT470_2M,
VIDEO_COLOR_PRIMARIES_BT470_2BG,
VIDEO_COLOR_PRIMARIES_SMPTE170M,
VIDEO_COLOR_PRIMARIES_SMPTE240M,
} video_color_primaries_t;
// Table 3-19 Color Matching Descriptor
typedef enum {
VIDEO_COLOR_XFER_CH_UNDEFINED = 0x00,
VIDEO_COLOR_XFER_CH_BT709, // default
VIDEO_COLOR_XFER_CH_BT470_2M,
VIDEO_COLOR_XFER_CH_BT470_2BG,
VIDEO_COLOR_XFER_CH_SMPTE170M,
VIDEO_COLOR_XFER_CH_SMPTE240M,
VIDEO_COLOR_XFER_CH_LINEAR,
VIDEO_COLOR_XFER_CH_SRGB,
} video_color_transfer_characteristics_t;
// Table 3-19 Color Matching Descriptor
typedef enum {
VIDEO_COLOR_COEF_UNDEFINED = 0x00,
VIDEO_COLOR_COEF_BT709,
VIDEO_COLOR_COEF_FCC,
VIDEO_COLOR_COEF_BT470_2BG,
VIDEO_COLOR_COEF_SMPTE170M, // BT.601 default
VIDEO_COLOR_COEF_SMPTE240M,
} video_color_matrix_coefficients_t;
/* 4.2.1.2 Request Error Code Control */
typedef enum {
VIDEO_ERROR_NONE = 0, /* The request succeeded. */
VIDEO_ERROR_NOT_READY,
VIDEO_ERROR_WRONG_STATE,
VIDEO_ERROR_POWER,
VIDEO_ERROR_OUT_OF_RANGE,
VIDEO_ERROR_INVALID_UNIT,
VIDEO_ERROR_INVALID_CONTROL,
VIDEO_ERROR_INVALID_REQUEST,
VIDEO_ERROR_INVALID_VALUE_WITHIN_RANGE,
VIDEO_ERROR_UNKNOWN = 0xFF,
} video_error_code_t;
/* A.2 Interface Subclass */
typedef enum {
VIDEO_SUBCLASS_UNDEFINED = 0x00,
VIDEO_SUBCLASS_CONTROL,
VIDEO_SUBCLASS_STREAMING,
VIDEO_SUBCLASS_INTERFACE_COLLECTION,
} video_subclass_type_t;
/* A.3 Interface Protocol */
typedef enum {
VIDEO_ITF_PROTOCOL_UNDEFINED = 0x00,
VIDEO_ITF_PROTOCOL_15,
} video_interface_protocol_code_t;
/* A.5 Class-Specific VideoControl Interface Descriptor Subtypes */
typedef enum {
VIDEO_CS_ITF_VC_UNDEFINED = 0x00,
VIDEO_CS_ITF_VC_HEADER,
VIDEO_CS_ITF_VC_INPUT_TERMINAL,
VIDEO_CS_ITF_VC_OUTPUT_TERMINAL,
VIDEO_CS_ITF_VC_SELECTOR_UNIT,
VIDEO_CS_ITF_VC_PROCESSING_UNIT,
VIDEO_CS_ITF_VC_EXTENSION_UNIT,
VIDEO_CS_ITF_VC_ENCODING_UNIT,
VIDEO_CS_ITF_VC_MAX,
} video_cs_vc_interface_subtype_t;
/* A.6 Class-Specific VideoStreaming Interface Descriptor Subtypes */
typedef enum {
VIDEO_CS_ITF_VS_UNDEFINED = 0x00,
VIDEO_CS_ITF_VS_INPUT_HEADER = 0x01,
VIDEO_CS_ITF_VS_OUTPUT_HEADER = 0x02,
VIDEO_CS_ITF_VS_STILL_IMAGE_FRAME = 0x03,
VIDEO_CS_ITF_VS_FORMAT_UNCOMPRESSED = 0x04,
VIDEO_CS_ITF_VS_FRAME_UNCOMPRESSED = 0x05,
VIDEO_CS_ITF_VS_FORMAT_MJPEG = 0x06,
VIDEO_CS_ITF_VS_FRAME_MJPEG = 0x07,
VIDEO_CS_ITF_VS_FORMAT_MPEG2TS = 0x0A,
VIDEO_CS_ITF_VS_FORMAT_DV = 0x0C,
VIDEO_CS_ITF_VS_COLORFORMAT = 0x0D,
VIDEO_CS_ITF_VS_FORMAT_FRAME_BASED = 0x10,
VIDEO_CS_ITF_VS_FRAME_FRAME_BASED = 0x11,
VIDEO_CS_ITF_VS_FORMAT_STREAM_BASED = 0x12,
VIDEO_CS_ITF_VS_FORMAT_H264 = 0x13,
VIDEO_CS_ITF_VS_FRAME_H264 = 0x14,
VIDEO_CS_ITF_VS_FORMAT_H264_SIMULCAST = 0x15,
VIDEO_CS_ITF_VS_FORMAT_VP8 = 0x16,
VIDEO_CS_ITF_VS_FRAME_VP8 = 0x17,
VIDEO_CS_ITF_VS_FORMAT_VP8_SIMULCAST = 0x18,
} video_cs_vs_interface_subtype_t;
/* A.7. Class-Specific Endpoint Descriptor Subtypes */
typedef enum {
VIDEO_CS_EP_UNDEFINED = 0x00,
VIDEO_CS_EP_GENERAL,
VIDEO_CS_EP_ENDPOINT,
VIDEO_CS_EP_INTERRUPT
} video_cs_ep_subtype_t;
/* A.8 Class-Specific Request Codes */
typedef enum {
VIDEO_REQUEST_UNDEFINED = 0x00,
VIDEO_REQUEST_SET_CUR = 0x01,
VIDEO_REQUEST_SET_CUR_ALL = 0x11,
VIDEO_REQUEST_GET_CUR = 0x81,
VIDEO_REQUEST_GET_MIN = 0x82,
VIDEO_REQUEST_GET_MAX = 0x83,
VIDEO_REQUEST_GET_RES = 0x84,
VIDEO_REQUEST_GET_LEN = 0x85,
VIDEO_REQUEST_GET_INFO = 0x86,
VIDEO_REQUEST_GET_DEF = 0x87,
VIDEO_REQUEST_GET_CUR_ALL = 0x91,
VIDEO_REQUEST_GET_MIN_ALL = 0x92,
VIDEO_REQUEST_GET_MAX_ALL = 0x93,
VIDEO_REQUEST_GET_RES_ALL = 0x94,
VIDEO_REQUEST_GET_DEF_ALL = 0x97
} video_control_request_t;
/* A.9.1 VideoControl Interface Control Selectors */
typedef enum {
VIDEO_VC_CTL_UNDEFINED = 0x00,
VIDEO_VC_CTL_VIDEO_POWER_MODE,
VIDEO_VC_CTL_REQUEST_ERROR_CODE,
} video_interface_control_selector_t;
/* A.9.8 VideoStreaming Interface Control Selectors */
typedef enum {
VIDEO_VS_CTL_UNDEFINED = 0x00,
VIDEO_VS_CTL_PROBE,
VIDEO_VS_CTL_COMMIT,
VIDEO_VS_CTL_STILL_PROBE,
VIDEO_VS_CTL_STILL_COMMIT,
VIDEO_VS_CTL_STILL_IMAGE_TRIGGER,
VIDEO_VS_CTL_STREAM_ERROR_CODE,
VIDEO_VS_CTL_GENERATE_KEY_FRAME,
VIDEO_VS_CTL_UPDATE_FRAME_SEGMENT,
VIDEO_VS_CTL_SYNCH_DELAY_CONTROL,
} video_interface_streaming_selector_t;
/* B. Terminal Types */
typedef enum {
// Terminal
VIDEO_TT_VENDOR_SPECIFIC = 0x0100,
VIDEO_TT_STREAMING = 0x0101,
// Input
VIDEO_ITT_VENDOR_SPECIFIC = 0x0200,
VIDEO_ITT_CAMERA = 0x0201,
VIDEO_ITT_MEDIA_TRANSPORT_INPUT = 0x0202,
// Output
VIDEO_OTT_VENDOR_SPECIFIC = 0x0300,
VIDEO_OTT_DISPLAY = 0x0301,
VIDEO_OTT_MEDIA_TRANSPORT_OUTPUT = 0x0302,
// External
VIDEO_ETT_VENDOR_SPEIFIC = 0x0400,
VIDEO_ETT_COMPOSITE_CONNECTOR = 0x0401,
VIDEO_ETT_SVIDEO_CONNECTOR = 0x0402,
VIDEO_ETT_COMPONENT_CONNECTOR = 0x0403,
} video_terminal_type_t;
//--------------------------------------------------------------------+
// Descriptors
//--------------------------------------------------------------------+
/* 2.3.4.2 */
typedef struct TU_ATTR_PACKED {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bDescriptorSubType;
uint16_t bcdUVC;
uint16_t wTotalLength;
uint32_t dwClockFrequency;
uint8_t bInCollection;
uint8_t baInterfaceNr[];
} tusb_desc_cs_video_ctl_itf_hdr_t;
/* 2.4.3.3 */
typedef struct TU_ATTR_PACKED {
uint8_t bHeaderLength;
union {
uint8_t bmHeaderInfo;
struct {
uint8_t FrameID: 1;
uint8_t EndOfFrame: 1;
uint8_t PresentationTime: 1;
uint8_t SourceClockReference: 1;
uint8_t PayloadSpecific: 1;
uint8_t StillImage: 1;
uint8_t Error: 1;
uint8_t EndOfHeader: 1;
};
};
} tusb_video_payload_header_t;
/* 3.9.2.1 */
typedef struct TU_ATTR_PACKED {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bDescriptorSubType;
uint8_t bNumFormats;
uint16_t wTotalLength;
uint8_t bEndpointAddress;
uint8_t bmInfo;
uint8_t bTerminalLink;
uint8_t bStillCaptureMethod;
uint8_t bTriggerSupport;
uint8_t bTriggerUsage;
uint8_t bControlSize;
uint8_t bmaControls[];
} tusb_desc_cs_video_stm_itf_in_hdr_t;
/* 3.9.2.2 */
typedef struct TU_ATTR_PACKED {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bDescriptorSubType;
uint8_t bNumFormats;
uint16_t wTotalLength;
uint8_t bEndpointAddress;
uint8_t bTerminalLink;
uint8_t bControlSize;
uint8_t bmaControls[];
} tusb_desc_cs_video_stm_itf_out_hdr_t;
typedef struct TU_ATTR_PACKED {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bDescriptorSubType;
uint8_t bNumFormats;
uint16_t wTotalLength;
uint8_t bEndpointAddress;
union {
struct {
uint8_t bmInfo;
uint8_t bTerminalLink;
uint8_t bStillCaptureMethod;
uint8_t bTriggerSupport;
uint8_t bTriggerUsage;
uint8_t bControlSize;
uint8_t bmaControls[];
} input;
struct {
uint8_t bEndpointAddress;
uint8_t bTerminalLink;
uint8_t bControlSize;
uint8_t bmaControls[];
} output;
};
} tusb_desc_cs_video_stm_itf_hdr_t;
typedef struct TU_ATTR_PACKED {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bDescriptorSubType;
uint8_t bFormatIndex;
uint8_t bNumFrameDescriptors;
uint8_t guidFormat[16];
uint8_t bBitsPerPixel;
uint8_t bDefaultFrameIndex;
uint8_t bAspectRatioX;
uint8_t bAspectRatioY;
uint8_t bmInterlaceFlags;
uint8_t bCopyProtect;
} tusb_desc_cs_video_fmt_uncompressed_t;
typedef struct TU_ATTR_PACKED {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bDescriptorSubType;
uint8_t bFrameIndex;
uint8_t bmCapabilities;
uint16_t wWidth;
uint16_t wHeight;
uint32_t dwMinBitRate;
uint32_t dwMaxBitRate;
uint32_t dwMaxVideoFrameBufferSize; /* deprecated */
uint32_t dwDefaultFrameInterval;
uint8_t bFrameIntervalType;
uint32_t dwFrameInterval[];
} tusb_desc_cs_video_frm_uncompressed_t;
//--------------------------------------------------------------------+
// Requests
//--------------------------------------------------------------------+
/* 4.3.1.1 */
typedef struct TU_ATTR_PACKED {
union {
uint8_t bmHint;
struct TU_ATTR_PACKED {
uint16_t dwFrameInterval: 1;
uint16_t wKeyFrameRatel : 1;
uint16_t wPFrameRate : 1;
uint16_t wCompQuality : 1;
uint16_t wCompWindowSize: 1;
uint16_t : 0;
} Hint;
};
uint8_t bFormatIndex;
uint8_t bFrameIndex;
uint32_t dwFrameInterval;
uint16_t wKeyFrameRate;
uint16_t wPFrameRate;
uint16_t wCompQuality;
uint16_t wCompWindowSize;
uint16_t wDelay;
uint32_t dwMaxVideoFrameSize;
uint32_t dwMaxPayloadTransferSize;
uint32_t dwClockFrequency;
union {
uint8_t bmFramingInfo;
struct TU_ATTR_PACKED {
uint8_t FrameID : 1;
uint8_t EndOfFrame: 1;
uint8_t EndOfSlice: 1;
uint8_t : 0;
} FramingInfo;
};
uint8_t bPreferedVersion;
uint8_t bMinVersion;
uint8_t bMaxVersion;
uint8_t bUsage;
uint8_t bBitDepthLuma;
uint8_t bmSettings;
uint8_t bMaxNumberOfRefFramesPlus1;
uint16_t bmRateControlModes;
uint64_t bmLayoutPerStream;
} video_probe_and_commit_control_t;
TU_VERIFY_STATIC( sizeof(video_probe_and_commit_control_t) == 48, "size is not correct");
#define TUD_VIDEO_DESC_IAD_LEN 8
#define TUD_VIDEO_DESC_STD_VC_LEN 9
#define TUD_VIDEO_DESC_CS_VC_LEN 12
#define TUD_VIDEO_DESC_INPUT_TERM_LEN 8
#define TUD_VIDEO_DESC_OUTPUT_TERM_LEN 9
#define TUD_VIDEO_DESC_STD_VS_LEN 9
#define TUD_VIDEO_DESC_CS_VS_IN_LEN 13
#define TUD_VIDEO_DESC_CS_VS_OUT_LEN 9
#define TUD_VIDEO_DESC_CS_VS_FMT_UNCOMPR_LEN 27
#define TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_CONT_LEN 38
#define TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_DISC_LEN 26
#define TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING_LEN 6
/* 2.2 compression formats */
#define TUD_VIDEO_GUID_YUY2 0x59,0x55,0x59,0x32,0x00,0x00,0x10,0x00,0x00,0x80,0x71,0x9B,0x38,0x00,0xAA,0x00
#define TUD_VIDEO_GUID_NV12 0x4E,0x56,0x31,0x32,0x00,0x00,0x10,0x00,0x00,0x80,0x71,0x9B,0x38,0x00,0xAA,0x00
#define TUD_VIDEO_GUID_M420 0x4D,0x34,0x32,0x30,0x00,0x00,0x10,0x00,0x00,0x80,0x71,0x9B,0x38,0x00,0xAA,0x00
#define TUD_VIDEO_GUID_I420 0x49,0x34,0x32,0x30,0x00,0x00,0x10,0x00,0x00,0x80,0x71,0x9B,0x38,0x00,0xAA,0x00
#define TUD_VIDEO_DESC_IAD(_firstitfs, _nitfs, _stridx) \
TUD_VIDEO_DESC_IAD_LEN, TUSB_DESC_INTERFACE_ASSOCIATION, \
_firstitfs, _nitfs, TUSB_CLASS_VIDEO, VIDEO_SUBCLASS_INTERFACE_COLLECTION, \
VIDEO_ITF_PROTOCOL_UNDEFINED, _stridx
#define TUD_VIDEO_DESC_STD_VC(_itfnum, _nEPs, _stridx) \
TUD_VIDEO_DESC_STD_VC_LEN, TUSB_DESC_INTERFACE, _itfnum, /* fixed to zero */ 0x00, \
_nEPs, TUSB_CLASS_VIDEO, VIDEO_SUBCLASS_CONTROL, VIDEO_ITF_PROTOCOL_15, _stridx
/* 3.7.2 */
#define TUD_VIDEO_DESC_CS_VC(_bcdUVC, _totallen, _clkfreq, ...) \
TUD_VIDEO_DESC_CS_VC_LEN + (TU_ARGS_NUM(__VA_ARGS__)), TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VC_HEADER, \
U16_TO_U8S_LE(_bcdUVC), U16_TO_U8S_LE((_totallen) + TUD_VIDEO_DESC_CS_VC_LEN + (TU_ARGS_NUM(__VA_ARGS__))), \
U32_TO_U8S_LE(_clkfreq), TU_ARGS_NUM(__VA_ARGS__), __VA_ARGS__
/* 3.7.2.1 */
#define TUD_VIDEO_DESC_INPUT_TERM(_tid, _tt, _at, _stridx) \
TUD_VIDEO_DESC_INPUT_TERM_LEN, TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VC_INPUT_TERMINAL, \
_tid, U16_TO_U8S_LE(_tt), _at, _stridx
/* 3.7.2.2 */
#define TUD_VIDEO_DESC_OUTPUT_TERM(_tid, _tt, _at, _srcid, _stridx) \
TUD_VIDEO_DESC_OUTPUT_TERM_LEN, TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VC_OUTPUT_TERMINAL, \
_tid, U16_TO_U8S_LE(_tt), _at, _srcid, _stridx
/* 3.9.1 */
#define TUD_VIDEO_DESC_STD_VS(_itfnum, _alt, _epn, _stridx) \
TUD_VIDEO_DESC_STD_VS_LEN, TUSB_DESC_INTERFACE, _itfnum, _alt, \
_epn, TUSB_CLASS_VIDEO, VIDEO_SUBCLASS_STREAMING, VIDEO_ITF_PROTOCOL_15, _stridx
/* 3.9.2.1 */
#define TUD_VIDEO_DESC_CS_VS_INPUT(_numfmt, _totallen, _ep, _inf, _termlnk, _sticaptmeth, _trgspt, _trgusg, ...) \
TUD_VIDEO_DESC_CS_VS_IN_LEN + (_numfmt) * (TU_ARGS_NUM(__VA_ARGS__)), TUSB_DESC_CS_INTERFACE, \
VIDEO_CS_ITF_VS_INPUT_HEADER, _numfmt, \
U16_TO_U8S_LE((_totallen) + TUD_VIDEO_DESC_CS_VS_IN_LEN + (_numfmt) * (TU_ARGS_NUM(__VA_ARGS__))), \
_ep, _inf, _termlnk, _sticaptmeth, _trgspt, _trgusg, (TU_ARGS_NUM(__VA_ARGS__)), __VA_ARGS__
/* 3.9.2.2 */
#define TUD_VIDEO_DESC_CS_VS_OUTPUT(_numfmt, _totallen, _ep, _inf, _termlnk, ...) \
TUD_VIDEO_DESC_CS_VS_OUT_LEN + (_numfmt) * (TU_ARGS_NUM(__VA_ARGS__)), TUSB_DESC_CS_INTERFACE, \
VIDEO_CS_ITF_VS_OUTPUT_HEADER, _numfmt, \
U16_TO_U8S_LE((_totallen) + TUD_VIDEO_DESC_CS_VS_OUT_LEN + (_numfmt) * (TU_ARGS_NUM(__VA_ARGS__))), \
_ep, _inf, _termlnk, (TU_ARGS_NUM(__VA_ARGS__)), __VA_ARGS__
/* Uncompressed 3.1.1 */
#define TUD_VIDEO_GUID(_g0,_g1,_g2,_g3,_g4,_g5,_g6,_g7,_g8,_g9,_g10,_g11,_g12,_g13,_g14,_g15) _g0,_g1,_g2,_g3,_g4,_g5,_g6,_g7,_g8,_g9,_g10,_g11,_g12,_g13,_g14,_g15
#define TUD_VIDEO_DESC_CS_VS_FMT_UNCOMPR(_fmtidx, _numfrmdesc, \
_guid, _bitsperpix, _frmidx, _asrx, _asry, _interlace, _cp) \
TUD_VIDEO_DESC_CS_VS_FMT_UNCOMPR_LEN, TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VS_FORMAT_UNCOMPRESSED, \
_fmtidx, _numfrmdesc, TUD_VIDEO_GUID(_guid), \
_bitsperpix, _frmidx, _asrx, _asry, _interlace, _cp
/* Uncompressed 3.1.2 Table 3-3 */
#define TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_CONT(_frmidx, _cap, _width, _height, _minbr, _maxbr, _maxfrmbufsz, _frminterval, _minfrminterval, _maxfrminterval, _frmintervalstep) \
TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_CONT_LEN, TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VS_FRAME_UNCOMPRESSED, \
_frmidx, _cap, U16_TO_U8S_LE(_width), U16_TO_U8S_LE(_height), U32_TO_U8S_LE(_minbr), U32_TO_U8S_LE(_maxbr), \
U32_TO_U8S_LE(_maxfrmbufsz), U32_TO_U8S_LE(_frminterval), 0, \
U32_TO_U8S_LE(_minfrminterval), U32_TO_U8S_LE(_maxfrminterval), U32_TO_U8S_LE(_frmintervalstep)
/* Uncompressed 3.1.2 Table 3-4 */
#define TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_DISC(_frmidx, _cap, _width, _height, _minbr, _maxbr, _maxfrmbufsz, _frminterval, ...) \
TUD_VIDEO_DESC_CS_VS_FRM_UNCOMPR_DISC_LEN + (TU_ARGS_NUM(__VA_ARGS__)) * 4, \
TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VS_FRAME_UNCOMPRESSED, \
_frmidx, _cap, U16_TO_U8S_LE(_width), U16_TO_U8S_LE(_height), U32_TO_U8S_LE(_minbr), U32_TO_U8S_LE(_maxbr), \
U32_TO_U8S_LE(_maxfrmbufsz), U32_TO_U8S_LE(_frminterval), (TU_ARGS_NUM(__VA_ARGS__)), __VA_ARGS__
/* 3.9.2.6 */
#define TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING(_color, _trns, _mat) \
TUD_VIDEO_DESC_CS_VS_COLOR_MATCHING_LEN, \
TUSB_DESC_CS_INTERFACE, VIDEO_CS_ITF_VS_COLORFORMAT, \
_color, _trns, _mat
/* 3.10.1.1 */
#define TUD_VIDEO_DESC_EP_ISO(_ep, _epsize, _ep_interval) \
7, TUSB_DESC_ENDPOINT, _ep, TUSB_XFER_ISOCHRONOUS | TUSB_ISO_EP_ATT_ASYNCHRONOUS,\
U16_TO_U8S_LE(_epsize), _ep_interval
/* 3.10.1.2 */
#define TUD_VIDEO_DESC_EP_BULK(_ep, _epsize, _ep_interval) \
7, TUSB_DESC_ENDPOINT, _ep, TUSB_XFER_BULK, U16_TO_U8S_LE(_epsize), _ep_interval
#endif

97
tools/sdk/esp32s2/include/arduino_tinyusb/tinyusb/src/class/video/video_device.h Normal file
View File

@ -0,0 +1,97 @@
/*
* The MIT License (MIT)
*
* Copyright (c) 2019 Ha Thach (tinyusb.org)
* Copyright (c) 2021 Koji KITAYAMA
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* This file is part of the TinyUSB stack.
*/
#ifndef TUSB_VIDEO_DEVICE_H_
#define TUSB_VIDEO_DEVICE_H_
#include "common/tusb_common.h"
#include "video.h"
#ifdef __cplusplus
extern "C" {
#endif
//--------------------------------------------------------------------+
// Application API (Multiple Ports)
// CFG_TUD_VIDEO > 1
//--------------------------------------------------------------------+
/** Return true if streaming
*
* @param[in] ctl_idx Destination control interface index
* @param[in] stm_idx Destination streaming interface index */
bool tud_video_n_streaming(uint_fast8_t ctl_idx, uint_fast8_t stm_idx);
/** Transfer a frame
*
* @param[in] ctl_idx Destination control interface index
* @param[in] stm_idx Destination streaming interface index
* @param[in] buffer Frame buffer. The caller must not use this buffer until the operation is completed.
* @param[in] bufsize Byte size of the frame buffer */
bool tud_video_n_frame_xfer(uint_fast8_t ctl_idx, uint_fast8_t stm_idx, void *buffer, size_t bufsize);
/*------------- Optional callbacks -------------*/
/** Invoked when compeletion of a frame transfer
*
* @param[in] ctl_idx Destination control interface index
* @param[in] stm_idx Destination streaming interface index */
TU_ATTR_WEAK void tud_video_frame_xfer_complete_cb(uint_fast8_t ctl_idx, uint_fast8_t stm_idx);
//--------------------------------------------------------------------+
// Application Callback API (weak is optional)
//--------------------------------------------------------------------+
/** Invoked when SET_POWER_MODE request received
*
* @param[in] ctl_idx Destination control interface index
* @param[in] stm_idx Destination streaming interface index
* @return video_error_code_t */
TU_ATTR_WEAK int tud_video_power_mode_cb(uint_fast8_t ctl_idx, uint8_t power_mod);
/** Invoked when VS_COMMIT_CONTROL(SET_CUR) request received
*
* @param[in] ctl_idx Destination control interface index
* @param[in] stm_idx Destination streaming interface index
* @param[in] parameters Video streaming parameters
* @return video_error_code_t */
TU_ATTR_WEAK int tud_video_commit_cb(uint_fast8_t ctl_idx, uint_fast8_t stm_idx,
video_probe_and_commit_control_t const *parameters);
//--------------------------------------------------------------------+
// INTERNAL USBD-CLASS DRIVER API
//--------------------------------------------------------------------+
void videod_init (void);
void videod_reset (uint8_t rhport);
uint16_t videod_open (uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
bool videod_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request);
bool videod_xfer_cb (uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
#ifdef __cplusplus
}
#endif
#endif

35
tools/sdk/esp32s2/include/arduino_tinyusb/tinyusb/src/common/tusb_common.h
View File

@ -38,18 +38,18 @@
#define TU_MIN(_x, _y) ( ( (_x) < (_y) ) ? (_x) : (_y) )
#define TU_MAX(_x, _y) ( ( (_x) > (_y) ) ? (_x) : (_y) )
#define TU_U16_HIGH(u16) ((uint8_t) (((u16) >> 8) & 0x00ff))
#define TU_U16_LOW(u16) ((uint8_t) ((u16) & 0x00ff))
#define U16_TO_U8S_BE(u16) TU_U16_HIGH(u16), TU_U16_LOW(u16)
#define U16_TO_U8S_LE(u16) TU_U16_LOW(u16), TU_U16_HIGH(u16)
#define TU_U16_HIGH(_u16) ((uint8_t) (((_u16) >> 8) & 0x00ff))
#define TU_U16_LOW(_u16) ((uint8_t) ((_u16) & 0x00ff))
#define U16_TO_U8S_BE(_u16) TU_U16_HIGH(_u16), TU_U16_LOW(_u16)
#define U16_TO_U8S_LE(_u16) TU_U16_LOW(_u16), TU_U16_HIGH(_u16)
#define TU_U32_BYTE3(u32) ((uint8_t) ((((uint32_t) u32) >> 24) & 0x000000ff)) // MSB
#define TU_U32_BYTE2(u32) ((uint8_t) ((((uint32_t) u32) >> 16) & 0x000000ff))
#define TU_U32_BYTE1(u32) ((uint8_t) ((((uint32_t) u32) >> 8) & 0x000000ff))
#define TU_U32_BYTE0(u32) ((uint8_t) (((uint32_t) u32) & 0x000000ff)) // LSB
#define TU_U32_BYTE3(_u32) ((uint8_t) ((((uint32_t) _u32) >> 24) & 0x000000ff)) // MSB
#define TU_U32_BYTE2(_u32) ((uint8_t) ((((uint32_t) _u32) >> 16) & 0x000000ff))
#define TU_U32_BYTE1(_u32) ((uint8_t) ((((uint32_t) _u32) >> 8) & 0x000000ff))
#define TU_U32_BYTE0(_u32) ((uint8_t) (((uint32_t) _u32) & 0x000000ff)) // LSB
#define U32_TO_U8S_BE(u32) TU_U32_BYTE3(u32), TU_U32_BYTE2(u32), TU_U32_BYTE1(u32), TU_U32_BYTE0(u32)
#define U32_TO_U8S_LE(u32) TU_U32_BYTE0(u32), TU_U32_BYTE1(u32), TU_U32_BYTE2(u32), TU_U32_BYTE3(u32)
#define U32_TO_U8S_BE(_u32) TU_U32_BYTE3(_u32), TU_U32_BYTE2(_u32), TU_U32_BYTE1(_u32), TU_U32_BYTE0(_u32)
#define U32_TO_U8S_LE(_u32) TU_U32_BYTE0(_u32), TU_U32_BYTE1(_u32), TU_U32_BYTE2(_u32), TU_U32_BYTE3(_u32)
#define TU_BIT(n) (1UL << (n))
@ -105,16 +105,13 @@ TU_ATTR_ALWAYS_INLINE static inline uint16_t tu_u16(uint8_t high, uint8_t low)
return (uint16_t) ((((uint16_t) high) << 8) | low);
}
TU_ATTR_ALWAYS_INLINE static inline uint8_t tu_u32_byte3(uint32_t u32) { return TU_U32_BYTE3(u32); }
TU_ATTR_ALWAYS_INLINE static inline uint8_t tu_u32_byte2(uint32_t u32) { return TU_U32_BYTE2(u32); }
TU_ATTR_ALWAYS_INLINE static inline uint8_t tu_u32_byte1(uint32_t u32) { return TU_U32_BYTE1(u32); }
TU_ATTR_ALWAYS_INLINE static inline uint8_t tu_u32_byte0(uint32_t u32) { return TU_U32_BYTE0(u32); }
TU_ATTR_ALWAYS_INLINE static inline uint8_t tu_u32_byte3(uint32_t ui32) { return TU_U32_BYTE3(ui32); }
TU_ATTR_ALWAYS_INLINE static inline uint8_t tu_u32_byte2(uint32_t ui32) { return TU_U32_BYTE2(ui32); }
TU_ATTR_ALWAYS_INLINE static inline uint8_t tu_u32_byte1(uint32_t ui32) { return TU_U32_BYTE1(ui32); }
TU_ATTR_ALWAYS_INLINE static inline uint8_t tu_u32_byte0(uint32_t ui32) { return TU_U32_BYTE0(ui32); }
TU_ATTR_ALWAYS_INLINE static inline uint16_t tu_u32_high16(uint32_t u32) { return (uint16_t) (u32 >> 16); }
TU_ATTR_ALWAYS_INLINE static inline uint16_t tu_u32_low16 (uint32_t u32) { return (uint16_t) (u32 & 0x0000ffffu); }
TU_ATTR_ALWAYS_INLINE static inline uint8_t tu_u16_high(uint16_t u16) { return TU_U16_HIGH(u16); }
TU_ATTR_ALWAYS_INLINE static inline uint8_t tu_u16_low (uint16_t u16) { return TU_U16_LOW(u16); }
TU_ATTR_ALWAYS_INLINE static inline uint8_t tu_u16_high(uint16_t ui16) { return TU_U16_HIGH(ui16); }
TU_ATTR_ALWAYS_INLINE static inline uint8_t tu_u16_low (uint16_t ui16) { return TU_U16_LOW(ui16); }
//------------- Bits -------------//
TU_ATTR_ALWAYS_INLINE static inline uint32_t tu_bit_set (uint32_t value, uint8_t pos) { return value | TU_BIT(pos); }

12
tools/sdk/esp32s2/include/arduino_tinyusb/tinyusb/src/common/tusb_types.h
View File

@ -69,6 +69,18 @@ typedef enum
TUSB_DIR_IN_MASK = 0x80
}tusb_dir_t;
/// Isochronous End Point Attributes
typedef enum
{
TUSB_ISO_EP_ATT_NO_SYNC = 0x00,
TUSB_ISO_EP_ATT_ASYNCHRONOUS = 0x04,
TUSB_ISO_EP_ATT_ADAPTIVE = 0x08,
TUSB_ISO_EP_ATT_SYNCHRONOUS = 0x0C,
TUSB_ISO_EP_ATT_DATA = 0x00, ///< Data End Point
TUSB_ISO_EP_ATT_EXPLICIT_FB = 0x10, ///< Feedback End Point
TUSB_ISO_EP_ATT_IMPLICIT_FB = 0x20, ///< Data endpoint that also serves as an implicit feedback
}tusb_iso_ep_attribute_t;
/// USB Descriptor Types
typedef enum
{

3
tools/sdk/esp32s2/include/arduino_tinyusb/tinyusb/src/device/dcd_attr.h
View File

@ -63,6 +63,9 @@
#elif TU_CHECK_MCU(MKL25ZXX) || TU_CHECK_MCU(K32L2BXX)
#define DCD_ATTR_ENDPOINT_MAX 16
#elif TU_CHECK_MCU(MM32F327X)
#define DCD_ATTR_ENDPOINT_MAX 16
//------------- Nordic -------------//
#elif TU_CHECK_MCU(NRF5X)
// 8 CBI + 1 ISO

93
tools/sdk/esp32s2/include/arduino_tinyusb/tinyusb/src/device/usbd.h
View File

@ -178,17 +178,18 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
0x9C, 0xD2, 0x65, 0x9D, 0x9E, 0x64, 0x8A, 0x9F
//--------------------------------------------------------------------+
// Configuration & Interface Descriptor Templates
// Configuration Descriptor Templates
//--------------------------------------------------------------------+
//------------- Configuration -------------//
#define TUD_CONFIG_DESC_LEN (9)
// Config number, interface count, string index, total length, attribute, power in mA
#define TUD_CONFIG_DESCRIPTOR(config_num, _itfcount, _stridx, _total_len, _attribute, _power_ma) \
9, TUSB_DESC_CONFIGURATION, U16_TO_U8S_LE(_total_len), _itfcount, config_num, _stridx, TU_BIT(7) | _attribute, (_power_ma)/2
//------------- CDC -------------//
//--------------------------------------------------------------------+
// CDC Descriptor Templates
//--------------------------------------------------------------------+
// Length of template descriptor: 66 bytes
#define TUD_CDC_DESC_LEN (8+9+5+5+4+5+7+9+7+7)
@ -217,7 +218,9 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
/* Endpoint In */\
7, TUSB_DESC_ENDPOINT, _epin, TUSB_XFER_BULK, U16_TO_U8S_LE(_epsize), 0
//------------- MSC -------------//
//--------------------------------------------------------------------+
// MSC Descriptor Templates
//--------------------------------------------------------------------+
// Length of template descriptor: 23 bytes
#define TUD_MSC_DESC_LEN (9 + 7 + 7)
@ -231,7 +234,10 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
/* Endpoint In */\
7, TUSB_DESC_ENDPOINT, _epin, TUSB_XFER_BULK, U16_TO_U8S_LE(_epsize), 0
//------------- HID -------------//
//--------------------------------------------------------------------+
// HID Descriptor Templates
//--------------------------------------------------------------------+
// Length of template descriptor: 25 bytes
#define TUD_HID_DESC_LEN (9 + 9 + 7)
@ -261,8 +267,10 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
/* Endpoint In */\
7, TUSB_DESC_ENDPOINT, _epin, TUSB_XFER_INTERRUPT, U16_TO_U8S_LE(_epsize), _ep_interval
//------------- MIDI -------------//
// MIDI v1.0 is based on Audio v1.0
//--------------------------------------------------------------------+
// MIDI Descriptor Templates
// Note: MIDI v1.0 is based on Audio v1.0
//--------------------------------------------------------------------+
#define TUD_MIDI_DESC_HEAD_LEN (9 + 9 + 9 + 7)
#define TUD_MIDI_DESC_HEAD(_itfnum, _stridx, _numcables) \
@ -319,7 +327,9 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
TUD_MIDI_DESC_EP(_epin, _epsize, 1),\
TUD_MIDI_JACKID_OUT_EMB(1)
//------------- AUDIO -------------//
//--------------------------------------------------------------------+
// Audio v2.0 Descriptor Templates
//--------------------------------------------------------------------+
/* Standard Interface Association Descriptor (IAD) */
#define TUD_AUDIO_DESC_IAD_LEN 8
@ -551,7 +561,10 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
((((_maxFrequency + ((CFG_TUSB_RHPORT0_MODE & OPT_MODE_HIGH_SPEED) ? 7999 : 999)) / ((CFG_TUSB_RHPORT0_MODE & OPT_MODE_HIGH_SPEED) ? 8000 : 1000)) + 1) * _nBytesPerSample * _nChannels)
//------------- TUD_USBTMC/USB488 -------------//
//--------------------------------------------------------------------+
// USBTMC/USB488 Descriptor Templates
//--------------------------------------------------------------------+
#define TUD_USBTMC_APP_CLASS (TUSB_CLASS_APPLICATION_SPECIFIC)
#define TUD_USBTMC_APP_SUBCLASS 0x03u
@ -581,8 +594,10 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
#define TUD_USBTMC_INT_DESCRIPTOR_LEN (7u)
//--------------------------------------------------------------------+
// Vendor Descriptor Templates
//--------------------------------------------------------------------+
//------------- Vendor -------------//
#define TUD_VENDOR_DESC_LEN (9+7+7)
// Interface number, string index, EP Out & IN address, EP size
@ -594,7 +609,10 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
/* Endpoint In */\
7, TUSB_DESC_ENDPOINT, _epin, TUSB_XFER_BULK, U16_TO_U8S_LE(_epsize), 0
//------------- DFU Runtime -------------//
//--------------------------------------------------------------------+
// DFU Runtime Descriptor Templates
//--------------------------------------------------------------------+
#define TUD_DFU_APP_CLASS (TUSB_CLASS_APPLICATION_SPECIFIC)
#define TUD_DFU_APP_SUBCLASS (APP_SUBCLASS_DFU_RUNTIME)
@ -609,6 +627,10 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
/* Function */ \
9, DFU_DESC_FUNCTIONAL, _attr, U16_TO_U8S_LE(_timeout), U16_TO_U8S_LE(_xfer_size), U16_TO_U8S_LE(0x0101)
//--------------------------------------------------------------------+
// DFU Descriptor Templates
//--------------------------------------------------------------------+
// Length of template descriptor: 9 bytes + number of alternatives * 9
#define TUD_DFU_DESC_LEN(_alt_count) (9 + (_alt_count) * 9)
@ -654,8 +676,9 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
_TUD_DFU_ALT(_itfnum, _alt_count, _stridx), \
_TUD_DFU_ALT_7(_itfnum, _alt_count+1, _stridx+1)
//------------- CDC-ECM -------------//
//--------------------------------------------------------------------+
// CDC-ECM Descriptor Templates
//--------------------------------------------------------------------+
// Length of template descriptor: 71 bytes
#define TUD_CDC_ECM_DESC_LEN (8+9+5+5+13+7+9+9+7+7)
@ -684,8 +707,9 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
/* Endpoint Out */\
7, TUSB_DESC_ENDPOINT, _epout, TUSB_XFER_BULK, U16_TO_U8S_LE(_epsize), 0
//------------- RNDIS -------------//
//--------------------------------------------------------------------+
// RNDIS Descriptor Templates
//--------------------------------------------------------------------+
#if 0
/* Windows XP */
@ -726,7 +750,10 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
/* Endpoint Out */\
7, TUSB_DESC_ENDPOINT, _epout, TUSB_XFER_BULK, U16_TO_U8S_LE(_epsize), 0
//------------- BT Radio -------------//
//--------------------------------------------------------------------+
// Bluetooth Radio Descriptor Templates
//--------------------------------------------------------------------+
#define TUD_BT_APP_CLASS (TUSB_CLASS_WIRELESS_CONTROLLER)
#define TUD_BT_APP_SUBCLASS 0x01
#define TUD_BT_PROTOCOL_PRIMARY_CONTROLLER 0x01
@ -777,10 +804,44 @@ TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb
// BT Primary controller descriptor
// Interface number, string index, attributes, event endpoint, event endpoint size, interval, data in, data out, data endpoint size, iso endpoint sizes
// TODO BTH should also use IAD like CDC for composite device
#define TUD_BTH_DESCRIPTOR(_itfnum, _stridx, _ep_evt, _ep_evt_size, _ep_evt_interval, _ep_in, _ep_out, _ep_size,...) \
TUD_BTH_PRI_ITF(_itfnum, _stridx, _ep_evt, _ep_evt_size, _ep_evt_interval, _ep_in, _ep_out, _ep_size) \
TUD_BTH_ISO_ITFS(_itfnum + 1, _ep_in + 1, _ep_out + 1, __VA_ARGS__)
//--------------------------------------------------------------------+
// CDC-NCM Descriptor Templates
//--------------------------------------------------------------------+
// Length of template descriptor
#define TUD_CDC_NCM_DESC_LEN (8+9+5+5+13+6+7+9+9+7+7)
// CDC-ECM Descriptor Template
// Interface number, description string index, MAC address string index, EP notification address and size, EP data address (out, in), and size, max segment size.
#define TUD_CDC_NCM_DESCRIPTOR(_itfnum, _desc_stridx, _mac_stridx, _ep_notif, _ep_notif_size, _epout, _epin, _epsize, _maxsegmentsize) \
/* Interface Association */\
8, TUSB_DESC_INTERFACE_ASSOCIATION, _itfnum, 2, TUSB_CLASS_CDC, CDC_COMM_SUBCLASS_NETWORK_CONTROL_MODEL, 0, 0,\
/* CDC Control Interface */\
9, TUSB_DESC_INTERFACE, _itfnum, 0, 1, TUSB_CLASS_CDC, CDC_COMM_SUBCLASS_NETWORK_CONTROL_MODEL, 0, _desc_stridx,\
/* CDC-NCM Header */\
5, TUSB_DESC_CS_INTERFACE, CDC_FUNC_DESC_HEADER, U16_TO_U8S_LE(0x0110),\
/* CDC-NCM Union */\
5, TUSB_DESC_CS_INTERFACE, CDC_FUNC_DESC_UNION, _itfnum, (uint8_t)((_itfnum) + 1),\
/* CDC-NCM Functional Descriptor */\
13, TUSB_DESC_CS_INTERFACE, CDC_FUNC_DESC_ETHERNET_NETWORKING, _mac_stridx, 0, 0, 0, 0, U16_TO_U8S_LE(_maxsegmentsize), U16_TO_U8S_LE(0), 0, \
/* CDC-NCM Functional Descriptor */\
6, TUSB_DESC_CS_INTERFACE, CDC_FUNC_DESC_NCM, U16_TO_U8S_LE(0x0100), 0, \
/* Endpoint Notification */\
7, TUSB_DESC_ENDPOINT, _ep_notif, TUSB_XFER_INTERRUPT, U16_TO_U8S_LE(_ep_notif_size), 50,\
/* CDC Data Interface (default inactive) */\
9, TUSB_DESC_INTERFACE, (uint8_t)((_itfnum)+1), 0, 0, TUSB_CLASS_CDC_DATA, 0, NCM_DATA_PROTOCOL_NETWORK_TRANSFER_BLOCK, 0,\
/* CDC Data Interface (alternative active) */\
9, TUSB_DESC_INTERFACE, (uint8_t)((_itfnum)+1), 1, 2, TUSB_CLASS_CDC_DATA, 0, NCM_DATA_PROTOCOL_NETWORK_TRANSFER_BLOCK, 0,\
/* Endpoint In */\
7, TUSB_DESC_ENDPOINT, _epin, TUSB_XFER_BULK, U16_TO_U8S_LE(_epsize), 0,\
/* Endpoint Out */\
7, TUSB_DESC_ENDPOINT, _epout, TUSB_XFER_BULK, U16_TO_U8S_LE(_epsize), 0
#ifdef __cplusplus
}
#endif

12
tools/sdk/esp32s2/include/arduino_tinyusb/tinyusb/src/tusb.h
View File

@ -76,9 +76,13 @@
#include "class/msc/msc_device.h"
#endif
#if CFG_TUD_AUDIO
#include "class/audio/audio_device.h"
#endif
#if CFG_TUD_AUDIO
#include "class/audio/audio_device.h"
#endif
#if CFG_TUD_VIDEO
#include "class/video/video_device.h"
#endif
#if CFG_TUD_MIDI
#include "class/midi/midi_device.h"
@ -100,7 +104,7 @@
#include "class/dfu/dfu_device.h"
#endif
#if CFG_TUD_NET
#if CFG_TUD_ECM_RNDIS || CFG_TUD_NCM
#include "class/net/net_device.h"
#endif

49
tools/sdk/esp32s2/include/arduino_tinyusb/tinyusb/src/tusb_option.h
View File

@ -241,6 +241,10 @@
#define CFG_TUD_AUDIO 0
#endif
#ifndef CFG_TUD_VIDEO
#define CFG_TUD_VIDEO 0
#endif
#ifndef CFG_TUD_MIDI
#define CFG_TUD_MIDI 0
#endif
@ -261,14 +265,23 @@
#define CFG_TUD_DFU 0
#endif
#ifndef CFG_TUD_NET
#define CFG_TUD_NET 0
#endif
#ifndef CFG_TUD_BTH
#define CFG_TUD_BTH 0
#endif
#ifndef CFG_TUD_ECM_RNDIS
#ifdef CFG_TUD_NET
#warning "CFG_TUD_NET is renamed to CFG_TUD_ECM_RNDIS"
#define CFG_TUD_ECM_RNDIS CFG_TUD_NET
#else
#define CFG_TUD_ECM_RNDIS 0
#endif
#endif
#ifndef CFG_TUD_NCM
#define CFG_TUD_NCM 0
#endif
//--------------------------------------------------------------------
// HOST OPTIONS
//--------------------------------------------------------------------
@ -280,10 +293,34 @@
#ifndef CFG_TUH_ENUMERATION_BUFSIZE
#define CFG_TUH_ENUMERATION_BUFSIZE 256
#endif
//------------- CLASS -------------//
#endif // TUSB_OPT_HOST_ENABLED
//------------- CLASS -------------//
#ifndef CFG_TUH_HUB
#define CFG_TUH_HUB 0
#endif
#ifndef CFG_TUH_CDC
#define CFG_TUH_CDC 0
#endif
#ifndef CFG_TUH_HID
#define CFG_TUH_HID 0
#endif
#ifndef CFG_TUH_MIDI
#define CFG_TUH_MIDI 0
#endif
#ifndef CFG_TUH_MSC
#define CFG_TUH_MSC 0
#endif
#ifndef CFG_TUH_VENDOR
#define CFG_TUH_VENDOR 0
#endif
//--------------------------------------------------------------------+
// Port Specific
// TUP stand for TinyUSB Port (can be renamed)

5
tools/sdk/esp32s2/include/asio/port/include/esp_asio_config.h
View File

@ -18,6 +18,11 @@
# define ASIO_NO_TYPEID
# endif // CONFIG_COMPILER_RTTI
//
// Supress OpenSSL deprecation warning, when building ASIO
//
#define ESP_OPENSSL_SUPPRESS_LEGACY_WARNING
//
// LWIP compatibility inet and address macros/functions
//

3
tools/sdk/esp32s2/include/coap/libcoap/include/coap3/coap_block_internal.h
View File

@ -191,6 +191,9 @@ int coap_handle_response_get_block(coap_context_t *context,
void coap_block_delete_lg_xmit(coap_session_t *session,
coap_lg_xmit_t *lg_xmit);
coap_tick_t coap_block_check_lg_xmit_timeouts(coap_session_t *session,
coap_tick_t now);
/**
* The function that does all the work for the coap_add_data_large*()
* functions.

6
tools/sdk/esp32s2/include/coap/libcoap/include/coap3/coap_dtls.h
View File

@ -27,6 +27,12 @@ typedef struct coap_dtls_pki_t coap_dtls_pki_t;
#ifndef COAP_DTLS_HINT_LENGTH
#define COAP_DTLS_HINT_LENGTH 128
#endif
#ifndef COAP_DTLS_MAX_PSK_IDENTITY
#define COAP_DTLS_MAX_PSK_IDENTITY 64
#endif
#ifndef COAP_DTLS_MAX_PSK
#define COAP_DTLS_MAX_PSK 64
#endif
typedef enum coap_dtls_role_t {
COAP_DTLS_ROLE_CLIENT, /**< Internal function invoked for client */

28
tools/sdk/esp32s2/include/coap/libcoap/include/coap3/coap_event.h
View File

@ -24,34 +24,34 @@
* Scalar type to represent different events, e.g. DTLS events or
* retransmission timeouts.
*/
typedef unsigned int coap_event_t;
typedef enum coap_event_t {
/**
* (D)TLS events for COAP_PROTO_DTLS and COAP_PROTO_TLS
*/
#define COAP_EVENT_DTLS_CLOSED 0x0000
#define COAP_EVENT_DTLS_CONNECTED 0x01DE
#define COAP_EVENT_DTLS_RENEGOTIATE 0x01DF
#define COAP_EVENT_DTLS_ERROR 0x0200
COAP_EVENT_DTLS_CLOSED = 0x0000,
COAP_EVENT_DTLS_CONNECTED = 0x01DE,
COAP_EVENT_DTLS_RENEGOTIATE = 0x01DF,
COAP_EVENT_DTLS_ERROR = 0x0200,
/**
* TCP events for COAP_PROTO_TCP and COAP_PROTO_TLS
*/
#define COAP_EVENT_TCP_CONNECTED 0x1001
#define COAP_EVENT_TCP_CLOSED 0x1002
#define COAP_EVENT_TCP_FAILED 0x1003
COAP_EVENT_TCP_CONNECTED = 0x1001,
COAP_EVENT_TCP_CLOSED = 0x1002,
COAP_EVENT_TCP_FAILED = 0x1003,
/**
* CSM exchange events for reliable protocols only
*/
#define COAP_EVENT_SESSION_CONNECTED 0x2001
#define COAP_EVENT_SESSION_CLOSED 0x2002
#define COAP_EVENT_SESSION_FAILED 0x2003
COAP_EVENT_SESSION_CONNECTED = 0x2001,
COAP_EVENT_SESSION_CLOSED = 0x2002,
COAP_EVENT_SESSION_FAILED = 0x2003,
/**
* BLOCK2 receive errors
* (Q-)BLOCK receive errors
*/
#define COAP_EVENT_PARTIAL_BLOCK 0x3001
COAP_EVENT_PARTIAL_BLOCK = 0x3001
} coap_event_t;
/**
* Type for event handler functions that can be registered with a CoAP

4
tools/sdk/esp32s2/include/coap/libcoap/include/coap3/coap_time.h
View File

@ -88,7 +88,11 @@ COAP_STATIC_INLINE uint64_t coap_ticks_to_rt_us(coap_tick_t t) {
#elif defined(RIOT_VERSION)
#include <xtimer.h>
#ifdef XTIMER_HZ
#define COAP_TICKS_PER_SECOND (XTIMER_HZ)
#else /* XTIMER_HZ */
#define COAP_TICKS_PER_SECOND (XTIMER_HZ_BASE)
#endif /* XTIMER_HZ */
typedef uint64_t coap_tick_t;
typedef int64_t coap_tick_diff_t;

1
tools/sdk/esp32s2/include/coap/libcoap/include/coap3/net.h
View File

@ -15,6 +15,7 @@
#include <stdlib.h>
#include <string.h>
#ifndef _WIN32
#include <sys/select.h>
#include <sys/time.h>
#endif
#include <time.h>

1
tools/sdk/esp32s2/include/coap/libcoap/include/coap3/pdu.h
View File

@ -299,7 +299,6 @@ typedef enum coap_pdu_code_t {
COAP_REQUEST_CODE_PATCH = COAP_REQUEST_PATCH,
COAP_REQUEST_CODE_IPATCH = COAP_REQUEST_IPATCH,
COAP_RESPONSE_CODE_OK = COAP_RESPONSE_CODE(200),
COAP_RESPONSE_CODE_CREATED = COAP_RESPONSE_CODE(201),
COAP_RESPONSE_CODE_DELETED = COAP_RESPONSE_CODE(202),
COAP_RESPONSE_CODE_VALID = COAP_RESPONSE_CODE(203),

3
tools/sdk/esp32s2/include/coap/libcoap/include/coap3/resource.h
View File

@ -83,7 +83,8 @@ typedef void (*coap_method_handler_t)
* variable of coap_str_const_t has to point to constant text, or point to data
* within the allocated coap_str_const_t parameter.
*
* @param uri_path The string URI path of the new resource.
* @param uri_path The string URI path of the new resource. The leading '/' is
* not normally required - e.g. just "full/path/for/resource".
* @param flags Flags for memory management (in particular release of
* memory). Possible values:@n
*

11
tools/sdk/esp32s2/include/config/sdkconfig.h
View File

@ -30,6 +30,7 @@
#define CONFIG_BOOT_ROM_LOG_ALWAYS_ON 1
#define CONFIG_ESPTOOLPY_BAUD_OTHER_VAL 115200
#define CONFIG_ESPTOOLPY_FLASHMODE_QIO 1
#define CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_STR 1
#define CONFIG_ESPTOOLPY_FLASHMODE "dio"
#define CONFIG_ESPTOOLPY_FLASHFREQ_80M 1
#define CONFIG_ESPTOOLPY_FLASHFREQ "80m"
@ -70,7 +71,7 @@
#define CONFIG_TINYUSB_CDC_TX_BUFSIZE 64
#define CONFIG_TINYUSB_MSC_ENABLED 1
#define CONFIG_TINYUSB_DESC_MSC_STRING "Espressif MSC Device"
#define CONFIG_TINYUSB_MSC_BUFSIZE 512
#define CONFIG_TINYUSB_MSC_BUFSIZE 4096
#define CONFIG_TINYUSB_HID_ENABLED 1
#define CONFIG_TINYUSB_DESC_HID_STRING "Espressif HID Device"
#define CONFIG_TINYUSB_HID_BUFSIZE 64
@ -78,6 +79,10 @@
#define CONFIG_TINYUSB_DESC_MIDI_STRING "Espressif MIDI Device"
#define CONFIG_TINYUSB_MIDI_RX_BUFSIZE 64
#define CONFIG_TINYUSB_MIDI_TX_BUFSIZE 64
#define CONFIG_TINYUSB_VIDEO_ENABLED 1
#define CONFIG_TINYUSB_DESC_VIDEO_STRING "Espressif VIDEO Device"
#define CONFIG_TINYUSB_VIDEO_STREAMING_BUFSIZE 64
#define CONFIG_TINYUSB_VIDEO_STREAMING_IFS 1
#define CONFIG_TINYUSB_DFU_RT_ENABLED 1
#define CONFIG_TINYUSB_DESC_DFU_RT_STRING "Espressif DFU Device"
#define CONFIG_TINYUSB_VENDOR_ENABLED 1
@ -289,6 +294,7 @@
#define CONFIG_LWIP_GARP_TMR_INTERVAL 60
#define CONFIG_LWIP_TCPIP_RECVMBOX_SIZE 32
#define CONFIG_LWIP_DHCP_RESTORE_LAST_IP 1
#define CONFIG_LWIP_DHCP_OPTIONS_LEN 68
#define CONFIG_LWIP_DHCPS 1
#define CONFIG_LWIP_DHCPS_LEASE_UNIT 60
#define CONFIG_LWIP_DHCPS_MAX_STATION_NUM 8
@ -401,6 +407,7 @@
#define CONFIG_MDNS_TASK_AFFINITY 0x0
#define CONFIG_MDNS_SERVICE_ADD_TIMEOUT_MS 2000
#define CONFIG_MDNS_TIMER_PERIOD_MS 100
#define CONFIG_MDNS_MULTIPLE_INSTANCE 1
#define CONFIG_MQTT_PROTOCOL_311 1
#define CONFIG_MQTT_TRANSPORT_SSL 1
#define CONFIG_MQTT_TRANSPORT_WEBSOCKET 1
@ -575,5 +582,5 @@
#define CONFIG_USB_MSC_BUFSIZE CONFIG_TINYUSB_MSC_BUFSIZE
#define CONFIG_USB_MSC_ENABLED CONFIG_TINYUSB_MSC_ENABLED
#define CONFIG_WARN_WRITE_STRINGS CONFIG_COMPILER_WARN_WRITE_STRINGS
#define CONFIG_ARDUINO_IDF_COMMIT "3e370c4296"
#define CONFIG_ARDUINO_IDF_COMMIT "b86fe0c66c"
#define CONFIG_ARDUINO_IDF_BRANCH "master"

6
tools/sdk/esp32s2/include/driver/esp32s2/include/driver/touch_sensor.h
View File

@ -293,7 +293,7 @@ esp_err_t touch_pad_reset_benchmark(touch_pad_t touch_num);
* @return
* - ESP_OK Success
*/
esp_err_t touch_pad_filter_set_config(touch_filter_config_t *filter_info);
esp_err_t touch_pad_filter_set_config(const touch_filter_config_t *filter_info);
/**
* @brief get parameter of touch sensor filter and detection algorithm.
@ -331,7 +331,7 @@ esp_err_t touch_pad_filter_disable(void);
* @return
* - ESP_OK Success
*/
esp_err_t touch_pad_denoise_set_config(touch_pad_denoise_t *denoise);
esp_err_t touch_pad_denoise_set_config(const touch_pad_denoise_t *denoise);
/**
* @brief get parameter of denoise pad (TOUCH_PAD_NUM0).
@ -380,7 +380,7 @@ esp_err_t touch_pad_denoise_read_data(uint32_t *data);
* @return
* - ESP_OK Success
*/
esp_err_t touch_pad_waterproof_set_config(touch_pad_waterproof_t *waterproof);
esp_err_t touch_pad_waterproof_set_config(const touch_pad_waterproof_t *waterproof);
/**
* @brief get parameter of waterproof function.

25
tools/sdk/esp32s2/include/driver/include/driver/rmt.h
View File

@ -856,16 +856,35 @@ esp_err_t rmt_remove_channel_from_group(rmt_channel_t channel);
#if SOC_RMT_SUPPORT_TX_LOOP_COUNT
/**
* @brief Set loop count for RMT TX channel
* @brief Set loop count threshold value for RMT TX channel
*
* When tx loop count reaches this value, an ISR callback will notify user
*
* @param channel RMT channel
* @param count loop count
* @param count loop count, 1 ~ 1023
* @return
* - ESP_ERR_INVALID_ARG Parameter error
* - ESP_OK Success
*/
esp_err_t rmt_set_tx_loop_count(rmt_channel_t channel, uint32_t count);
#endif
/**
* @brief Enable or disable the feature that when loop count reaches the threshold, RMT will stop transmitting.
*
* - When the loop auto-stop feature is enabled will halt RMT transmission after the loop count reaches a certain threshold
* - When disabled, the RMT transmission continue indefinitely until halted by the users
*
* @note The auto-stop feature is implemented in hardware on particular targets (i.e. those with SOC_RMT_SUPPORT_TX_LOOP_AUTOSTOP defined).
* Otherwise, the auto-stop feature is implemented in software via the interrupt.
*
* @param channel RMT channel
* @param en enable bit
* @return
* - ESP_ERR_INVALID_ARG Parameter error
* - ESP_OK Success
*/
esp_err_t rmt_enable_tx_loop_autostop(rmt_channel_t channel, bool en);
#endif // SOC_RMT_SUPPORT_TX_LOOP_COUNT
/**
* @brief Reset RMT TX/RX memory index.

19
tools/sdk/esp32s2/include/esp-face/include/dl_define.hpp
View File

@ -10,7 +10,7 @@
#define DL_LOG_LAYER_LATENCY 0 /*<! - 1: print the latency of each parts of layer */
/*<! - 0: mute */
#if CONFIG_SPIRAM_SUPPORT || CONFIG_ESP32_SPIRAM_SUPPORT || CONFIG_ESP32S3_SPIRAM_SUPPORT
#if CONFIG_SPIRAM_SUPPORT || CONFIG_ESP32_SPIRAM_SUPPORT || CONFIG_ESP32S2_SPIRAM_SUPPORT || CONFIG_ESP32S3_SPIRAM_SUPPORT
#define DL_SPIRAM_SUPPORT 1
#else
#define DL_SPIRAM_SUPPORT 0
@ -83,8 +83,17 @@ namespace dl
typedef enum
{
PADDING_VALID, /*<! no padding >*/
PADDING_SAME, /*<! SAME in TensorFlow style >*/
PADDING_SAME_MXNET /*<! SAME in MXNET style >*/
PADDING_NOT_SET,
PADDING_VALID, /*<! no padding >*/
PADDING_SAME_BEGIN, /*<! SAME in MXNET style >*/
PADDING_SAME_END, /*<! SAME in TensorFlow style >*/
} padding_type_t;
} // namespace dl
typedef enum
{
CONSTANT,
EDGE,
REFLECT,
SYMMETRIC,
} padding_mode_t;
} // namespace dl

61
tools/sdk/esp32s2/include/esp-face/include/image/dl_image.hpp
View File

@ -370,11 +370,70 @@ namespace dl
*/
uint32_t get_moving_point_number(uint8_t *f1, uint8_t *f2, const uint32_t height, const uint32_t width, const uint32_t stride, const uint32_t threshold = 5);
/**
* @brief Apply an affine transformation to an image.
*
* @tparam T
* @param input the input image.
* @param output the output image.
* @param M_inv the inverse transformation matrix.
*/
template <typename T>
void warp_affine(dl::Tensor<T> *input, dl::Tensor<T> *output, dl::math::Matrix<float> *M_inv);
/**
* @brief Apply an affine transformation to an image.
*
* @tparam T
* @param input the pointer of the input image.
* @param shape the shape of the input image.
* @param output the output image.
* @param M_inv the inverse transformation matrix.
*/
template <typename T>
void warp_affine(uint16_t *input, std::vector<int> shape, dl::Tensor<T> *output, dl::math::Matrix<float> *M_inv);
/**
* @brief Get the otsu thresh object.
*
* @param image the gray image.
* @return uint8_t the otsu thresh.
*/
uint8_t get_otsu_thresh(Tensor<uint8_t> &image);
/**
* @brief Convert RGB image to gray image
*
* @param image input image
* @param bgr true: the image is in BGR format
* false: the image is in RGB format
* @return Tensor<uint8_t>* output image in gray format
*/
Tensor<uint8_t> *rgb2gray(Tensor<uint8_t> &image, bool bgr = false);
/**
* @brief Convert RGB image to LAB image
*
* @param image input image
* @param bgr true: the image is in BGR format
* false: the image is in RGB format
* @param fast true: use the fast alogrithm， but the accuracy will be reduced
* false: do not use the fast alogrithm
* @return Tensor<uint8_t>* output image in LAB foramt
*/
Tensor<uint8_t> *rgb2lab(Tensor<uint8_t> &image, bool bgr = false, bool fast = true);
/**
* @brief Convert RGB image to HSV image
*
* @param image input image
* @param bgr true: the image is in BGR format
* false: the image is in RGB format
* @param fast true: use the fast alogrithm， but the accuracy will be reduced
* false: do not use the fast alogrithm
* @return Tensor<uint8_t>* output image in HSV format
*/
Tensor<uint8_t> *rgb2hsv(Tensor<uint8_t> &image, bool bgr = false, bool fast = true);
} // namespace image
} // namespace dl

36
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_add2d.hpp
View File

@ -25,7 +25,8 @@ namespace dl
const int output_exponent; /*<! exponent of output >*/
Tensor<feature_t> *output; /*<! output ptr of add2d >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a seperate memeory >*/
false: the output will store to a separate memory >*/
std::vector<int> output_shape; /*<! output shape of add2d >*/
public:
/**
@ -35,19 +36,21 @@ namespace dl
* @param activation activation of add2d, if you don't specify anything, no activation is applied
* @param name name of add2d
* @param inplace true: the output will store to input0
* false: the output will store to a seperate memeory
* false: the output will store to a separate memory
*/
Add2D(const int output_exponent, const Activation<feature_t> *activation = NULL, const char *name = NULL, bool inplace = false) : Layer(name), activation(activation), output_exponent(output_exponent), output(NULL)
{
this->inplace = inplace;
}
Add2D(const int output_exponent, const Activation<feature_t> *activation = NULL, const char *name = "Add2D", bool inplace = false) : Layer(name),
activation(activation),
output_exponent(output_exponent),
output(NULL),
inplace(inplace),
output_shape({}) {}
/**
* @brief Destroy the Add2D object
*/
~Add2D()
{
if((!this->inplace) && (this->output != NULL))
if ((!this->inplace) && (this->output != NULL))
{
delete this->output;
}
@ -59,10 +62,12 @@ namespace dl
*
* @param input0 as one input
* @param input1 as another input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input0, Tensor<feature_t> &input1)
void build(Tensor<feature_t> &input0, Tensor<feature_t> &input1, bool print_shape = false)
{
assert(input0.is_same_shape(input1));
this->output_shape = input0.shape;
if (!this->inplace)
{
@ -78,6 +83,11 @@ namespace dl
{
this->output = &input0;
}
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
@ -105,7 +115,11 @@ namespace dl
if (!this->inplace)
{
DL_LOG_LAYER_LATENCY_START();
this->output->apply_element();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->malloc_element();
this->output->set_exponent(this->output_exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");
@ -116,6 +130,10 @@ namespace dl
else
{
DL_LOG_LAYER_LATENCY_START();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
nn::add2d(*this->output, input0, input1, this->activation, assign_core, this->output_exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "add2d");
}

70
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_avg_pool2d.hpp
View File

@ -24,23 +24,26 @@ namespace dl
std::vector<int> filter_shape; /*<! filter shape in [filter_height, filter_width] >*/
const int stride_y; /*<! stride in height >*/
const int stride_x; /*<! stride in width >*/
const padding_type_t padding_type; /*<! one of PADDING_VALID or PADDING_SAME or PADDING_SAME_MXNET >*/
const padding_type_t padding_type; /*<! one of PADDING_VALID or PADDING_SAME_END or PADDING_SAME_BEGIN >*/
std::vector<int> padding; /*<! padding size needed in [top, bottom, left, right] of this operation >*/
Tensor<feature_t> *output; /*<! output ptr of AvgPool2D >*/
Tensor<feature_t> *output; /*<! output ptr of AvgPool2D >*/
std::vector<int> output_shape; /*<! output shape of AvgPool2D >*/
public:
/**
* @brief Construct a new AvgPool2D object.
*
* @param output_exponent exponent of output
* @param filter_shape filter shape in [filter_height, filter_width]
* @param padding_type one of PADDING_VALID or PADDING_SAME or PADDING_SAME_MXNET,
* @param padding_type one of PADDING_VALID or PADDING_SAME_END or PADDING_SAME_BEGIN or PADDING_NOT_SET,
* - PADDING_VALID means no padding
* PADDING_SAME and PADDING_SAME_MXNET results in padding with zeros evenly to the left/right or up/down of the input
* PADDING_SAME_END and PADDING_SAME_BEGIN results in padding with zeros evenly to the left/right or up/down of the input
* such that output has the same height/width dimension as the input,
* - PADDING_SAME results padding in TensorFlow style
* - PADDING_SAME_MXNET results padding in MXNET style
* - PADDING_SAME_END results padding in TensorFlow style
* - PADDING_SAME_BEGIN results padding in MXNET style
* - PADDING_NOT_SET means padding with the specific "padding" value below.
* @param padding if padding_type is PADDING_NOT_SET, this value will be used as padding size.
* the shape must be 4, the value of each position is: [padding top, padding bottom, padding left, padding right]
* @param stride_y stride in height
* @param stride_x stride in width
* @param name name of layer
@ -48,16 +51,23 @@ namespace dl
AvgPool2D(const int output_exponent,
const std::vector<int> filter_shape,
const padding_type_t padding_type = PADDING_VALID,
std::vector<int> padding = {},
const int stride_y = 1,
const int stride_x = 1,
const char *name = NULL) : Layer(name),
output_exponent(output_exponent),
filter_shape(filter_shape),
stride_y(stride_y),
stride_x(stride_x),
padding_type(padding_type)
const char *name = "AvgPool2D") : Layer(name),
output_exponent(output_exponent),
filter_shape(filter_shape),
padding_type(padding_type),
padding(padding),
stride_y(stride_y),
stride_x(stride_x),
output_shape({})
{
this->output = new Tensor<feature_t>;
if (this->padding_type == PADDING_NOT_SET)
{
assert(this->padding.size() == 4);
}
}
/**
@ -66,7 +76,7 @@ namespace dl
*/
~AvgPool2D()
{
if(this->output != NULL)
if (this->output != NULL)
{
delete this->output;
}
@ -76,20 +86,31 @@ namespace dl
* @brief Update output shape and padding.
*
* @param input as an input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input)
void build(Tensor<feature_t> &input, bool print_shape = false)
{
assert(input.shape[0] > 0);
assert(input.shape[1] > 0);
std::vector<int> output_shape = nn::get_output_shape(input.shape, filter_shape, this->stride_y, this->stride_x, this->padding_type);
this->output->set_shape(output_shape);
assert(input.shape.size() == 3);
this->output_shape = nn::get_output_shape(input.shape, filter_shape, this->stride_y, this->stride_x, this->padding_type, false, this->padding);
this->output->set_shape(this->output_shape);
this->output->set_exponent(this->output_exponent);
this->padding = nn::get_pad_size(output_shape, input.shape, filter_shape, this->stride_y, this->stride_x, this->padding_type);
input.set_padding_size(this->padding);
this->output->free_element();
}
if (this->padding_type != PADDING_NOT_SET)
{
this->padding = nn::get_pad_size(this->output_shape, input.shape, filter_shape, this->stride_y, this->stride_x, this->padding_type);
}
this->output->free_element();
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
* @brief Get the output
@ -108,7 +129,6 @@ namespace dl
* @param autoload_enable one of true or false,
* - true: load input and output from PSRAM to CACHE automatically
* - false: do not
* @param assign_core not effective yet
* @return AvgPool2D result
*/
Tensor<feature_t> &call(Tensor<feature_t> &input, uint8_t autoload_enable = 0)
@ -116,7 +136,11 @@ namespace dl
DL_LOG_LAYER_LATENCY_INIT();
DL_LOG_LAYER_LATENCY_START();
this->output->apply_element();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->malloc_element();
this->output->set_exponent(this->output_exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");

1
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_base.hpp
View File

@ -1,6 +1,7 @@
#pragma once
#include "dl_tool.hpp"
#include "dl_tool_cache.hpp"
#include <iostream>
namespace dl
{

139
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_concat.hpp Normal file
View File

@ -0,0 +1,139 @@
#pragma once
#include <assert.h>
#include <vector>
#include "dl_constant.hpp"
#include "dl_variable.hpp"
#include "dl_tool.hpp"
#include "dl_layer_base.hpp"
#include "dl_nn_concat.hpp"
namespace dl
{
namespace layer
{
/**
* @brief Concat(input1, input2, input3, ...).
*
* @tparam feature_t support all kinds of integer and float data type
*/
template <typename feature_t>
class Concat : Layer
{
private:
int output_exponent; /*<! exponent of output >*/
int axis; /*<! The axis along which the Tensor will be concatenated. >*/
Tensor<feature_t> *output; /*<! output ptr of Concat >*/
std::vector<int> output_shape; /*<! output shape of Concat >*/
public:
/**
* @brief Construct a new Concat object.
*
* @param name name of layer
* @param axis The axis along which the Tensor will be concatenated.
*/
Concat(int axis, const char *name = "Concat") : Layer(name), axis(axis), output_shape({})
{
this->output = new Tensor<feature_t>;
}
/**
* @brief Destroy the Concat object
*/
~Concat()
{
if (this->output != NULL)
{
delete this->output;
}
}
/**
* @brief Collect inputs' channel and memory offset, called in Model.build().
*
* @param args pointers of concatenated Tensor
* @param print_shape whether to print the output shape.
*/
void build(std::vector<Tensor<feature_t> *> args, bool print_shape = false)
{
assert(args.size() > 1);
int shape_size = args[0]->shape.size();
if (this->axis < 0)
{
this->axis = shape_size + this->axis;
}
assert((this->axis < shape_size) && (this->axis > -1));
int output_shape_axis = args[0]->shape[this->axis];
for (int i = 1; i < args.size(); i++)
{
assert(shape_size == args[i]->shape.size());
assert(args[i]->exponent == args[i - 1]->exponent);
output_shape_axis += args[i]->shape[this->axis];
for (int j = 0; j < shape_size; j++)
{
if (j != this->axis)
{
assert(args[i]->shape[j] == args[i - 1]->shape[j]);
}
}
}
this->output_exponent = args[0]->exponent;
this->output_shape = args[0]->shape;
this->output_shape[this->axis] = output_shape_axis;
this->output->set_shape(this->output_shape);
this->output->set_exponent(this->output_exponent);
this->output->free_element();
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
* @brief Call Concat operation
*
* @param inputs the pointers of inputs
* @param free_inputs true: free the inputs after call
* false: do not free inputs
* @return Tensor<feature_t>& concat result
*/
Tensor<feature_t> &call(std::vector<Tensor<feature_t> *> inputs, bool free_inputs = false)
{
DL_LOG_LAYER_LATENCY_INIT();
DL_LOG_LAYER_LATENCY_START();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->malloc_element();
this->output->set_exponent(this->output_exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");
DL_LOG_LAYER_LATENCY_START();
nn::concat(*this->output, inputs, this->axis, free_inputs);
DL_LOG_LAYER_LATENCY_END(this->name, "concat");
return *this->output;
}
/**
* @brief Get the output
*
* @return Tensor<feature_t>& Concat result
*/
Tensor<feature_t> &get_output()
{
return *this->output;
}
};
} // namespace layer
} // namespace dl

77
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_conv2d.hpp
View File

@ -13,8 +13,11 @@ namespace dl
* @tparam feature_t supports int16_t and int8_t,
* - int16_t: stands for operation in int16_t quantize
* - int8_t: stands for operation in int8_t quantize
* @tparam bias_t supports int16_t and int8_t, must specify when using int8 per-channel quantization
* - int16_t: for int16 quantization and int8 per-channel quantization
* - int8_t: for int8 per-tensor quantization
*/
template <typename feature_t>
template <typename feature_t, typename bias_t = feature_t>
class Conv2D : public Layer
{
private:
@ -22,14 +25,14 @@ namespace dl
const Filter<feature_t> *filter; /*<! filter of Conv2D >*/
const int stride_y; /*<! stride in height >*/
const int stride_x; /*<! stride in width >*/
const padding_type_t padding_type; /*<! one of PADDING_VALID or PADDING_SAME or PADDING_SAME_MXNET >*/
const Bias<feature_t> *bias; /*<! bias of Conv2D, if you don't specify anything, no bias is added >*/
const padding_type_t padding_type; /*<! one of PADDING_VALID or PADDING_SAME_END or PADDING_SAME_BEGIN >*/
const Bias<bias_t> *bias; /*<! bias of Conv2D, if you don't specify anything, no bias is added >*/
const Activation<feature_t> *activation; /*<! activation of Conv2D, if you don't specify anything, no activation is applied >*/
std::vector<int> padding; /*<! padding size needed in [top, bottom, left, right] of this operation >*/
Tensor<feature_t> *output; /*<! output ptr of Conv2D >*/
Tensor<feature_t> *output; /*<! output ptr of Conv2D >*/
std::vector<int> output_shape; /*<! output shape of Conv2D >*/
public:
/**
* @brief Construct a new Conv2D object.
*
@ -37,33 +40,43 @@ namespace dl
* @param filter filter of Conv2D
* @param bias bias of Conv2D, if you don't specify anything, no bias is added
* @param activation activation of Conv2D, if you don't specify anything, no activation is applied
* @param padding_type one of PADDING_VALID or PADDING_SAME or PADDING_SAME_MXNET,
* @param padding_type one of PADDING_VALID or PADDING_SAME_END or PADDING_SAME_BEGIN or PADDING_NOT_SET,
* - PADDING_VALID means no padding
* PADDING_SAME and PADDING_SAME_MXNET results in padding with zeros evenly to the left/right or up/down of the input
* PADDING_SAME_END and PADDING_SAME_BEGIN results in padding with zeros evenly to the left/right or up/down of the input
* such that output has the same height/width dimension as the input,
* - PADDING_SAME results padding in TensorFlow style
* - PADDING_SAME_MXNET results padding in MXNET style
* - PADDING_SAME_END results padding in TensorFlow style
* - PADDING_SAME_BEGIN results padding in MXNET style
* - PADDING_NOT_SET means padding with the specific "padding" value below.
* @param padding if padding_type is PADDING_NOT_SET, this value will be used as padding size.
* the shape must be 4, the value of each position is: [padding top, padding bottom, padding left, padding right]
* @param stride_y stride in height
* @param stride_x stride in width
* @param name name of layer
*/
Conv2D(const int output_exponent,
const Filter<feature_t> *filter,
const Bias<feature_t> *bias = NULL,
const Bias<bias_t> *bias = NULL,
const Activation<feature_t> *activation = NULL,
const padding_type_t padding_type = PADDING_VALID,
std::vector<int> padding = {},
const int stride_y = 1,
const int stride_x = 1,
const char *name = NULL) : Layer(name),
output_exponent(output_exponent),
filter(filter),
stride_y(stride_y),
stride_x(stride_x),
padding_type(padding_type),
bias(bias),
activation(activation)
const char *name = "Conv2D") : Layer(name),
output_exponent(output_exponent),
filter(filter),
stride_y(stride_y),
stride_x(stride_x),
padding_type(padding_type),
bias(bias),
activation(activation),
padding(padding),
output_shape({})
{
this->output = new Tensor<feature_t>;
if (this->padding_type == PADDING_NOT_SET)
{
assert(this->padding.size() == 4);
}
}
/**
@ -82,19 +95,30 @@ namespace dl
* @brief Update output padding and input padding.
*
* @param input as an input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input)
void build(Tensor<feature_t> &input, bool print_shape = false)
{
assert(input.shape[0] > 0);
assert(input.shape[1] > 0);
assert(input.shape.size() == 3);
assert(this->filter->shape.size() == 4);
assert(input.shape[2] == this->filter->shape[2]);
std::vector<int> output_shape = nn::get_output_shape(input.shape, this->filter->shape_with_dilation, this->stride_y, this->stride_x, this->padding_type, true);
this->output->set_shape(output_shape);
this->output_shape = nn::get_output_shape(input.shape, this->filter->shape_with_dilation, this->stride_y, this->stride_x, this->padding_type, true, this->padding);
this->output->set_shape(this->output_shape);
this->output->set_exponent(this->output_exponent);
this->output->free_element();
if (this->padding_type != PADDING_NOT_SET)
{
this->padding = nn::get_pad_size(this->output_shape, input.shape, this->filter->shape_with_dilation, this->stride_y, this->stride_x, this->padding_type);
}
this->padding = nn::get_pad_size(output_shape, input.shape, this->filter->shape_with_dilation, this->stride_y, this->stride_x, this->padding_type);
input.set_padding_size(this->padding);
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
@ -122,7 +146,11 @@ namespace dl
DL_LOG_LAYER_LATENCY_INIT();
DL_LOG_LAYER_LATENCY_START();
this->output->apply_element();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->malloc_element();
this->output->set_exponent(this->output_exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");
@ -153,5 +181,6 @@ namespace dl
dl::tool::cache::preload_func((uint32_t)(this->filter->element), size);
}
};
} // namespace layer
} // namespace dl

80
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_depthwise_conv2d.hpp
View File

@ -13,8 +13,11 @@ namespace dl
* @tparam feature_t supports int16_t and int8_t,
* - int16_t: stands for operation in int16_t quantize
* - int8_t: stands for operation in int8_t quantize
* @tparam bias_t supports int16_t and int8_t, must specify when using int8 per-channel quantization
* - int16_t: for int16 quantization and int8 per-channel quantization
* - int8_t: for int8 per-tensor quantization
*/
template <typename feature_t>
template <typename feature_t, typename bias_t = feature_t>
class DepthwiseConv2D : public Layer
{
private:
@ -22,14 +25,14 @@ namespace dl
const Filter<feature_t> *filter; /*<! filter of DepthwiseConv2D >*/
const int stride_y; /*<! stride in height >*/
const int stride_x; /*<! stride in width >*/
const padding_type_t padding_type; /*<! one of PADDING_VALID or PADDING_SAME or PADDING_SAME_MXNET >*/
const Bias<feature_t> *bias; /*<! bias of DepthwiseConv2D, if you don't specify anything, no bias is added >*/
const padding_type_t padding_type; /*<! one of PADDING_VALID or PADDING_SAME_END or PADDING_SAME_BEGIN >*/
const Bias<bias_t> *bias; /*<! bias of DepthwiseConv2D, if you don't specify anything, no bias is added >*/
const Activation<feature_t> *activation; /*<! activation of DepthwiseConv2D, if you don't specify anything, no activation is applied >*/
std::vector<int> padding; /*<! padding size needed in [top, bottom, left, right] of this operation >*/
Tensor<feature_t> *output; /*<! output ptr of DepthwiseConv2D >*/
std::vector<int> output_shape; /*<! output shape of DepthwiseConv2D >*/
public:
/**
* @brief Construct a new DepthwiseConv2D object.
*
@ -37,40 +40,50 @@ namespace dl
* @param filter filter of DepthwiseConv2D
* @param bias bias of DepthwiseConv2D, if you don't specify anything, no bias is added
* @param activation activation of DepthwiseConv2D, if you don't specify anything, no activation is applied
* @param padding_type one of PADDING_VALID or PADDING_SAME or PADDING_SAME_MXNET,
* @param padding_type one of PADDING_VALID or PADDING_SAME_END or PADDING_SAME_BEGIN or PADDING_NOT_SET,
* - PADDING_VALID means no padding
* PADDING_SAME and PADDING_SAME_MXNET results in padding with zeros evenly to the left/right or up/down of the input
* such that output has the same height/width dimension as the input
* - PADDING_SAME results padding in TensorFlow style
* - PADDING_SAME_MXNET results padding in MXNET style
* PADDING_SAME_END and PADDING_SAME_BEGIN results in padding with zeros evenly to the left/right or up/down of the input
* such that output has the same height/width dimension as the input,
* - PADDING_SAME_END results padding in TensorFlow style
* - PADDING_SAME_BEGIN results padding in MXNET style
* - PADDING_NOT_SET means padding with the specific "padding" value below.
* @param padding if padding_type is PADDING_NOT_SET, this value will be used as padding size.
* the shape must be 4, the value of each position is: [padding top, padding bottom, padding left, padding right]
* @param stride_y - stride in height
* @param stride_x - stride in width
* @param name name of layer
*/
DepthwiseConv2D(const int output_exponent,
const Filter<feature_t> *filter,
const Bias<feature_t> *bias = NULL,
const Bias<bias_t> *bias = NULL,
const Activation<feature_t> *activation = NULL,
const padding_type_t padding_type = PADDING_VALID,
std::vector<int> padding = {},
const int stride_y = 1,
const int stride_x = 1,
const char *name = NULL) : Layer(name),
output_exponent(output_exponent),
filter(filter),
stride_y(stride_y),
stride_x(stride_x),
padding_type(padding_type),
bias(bias),
activation(activation)
const char *name = "DepthwiseConv2D") : Layer(name),
output_exponent(output_exponent),
filter(filter),
stride_y(stride_y),
stride_x(stride_x),
padding_type(padding_type),
bias(bias),
activation(activation),
padding(padding),
output_shape({})
{
this->output = new Tensor<feature_t>;
if (this->padding_type == PADDING_NOT_SET)
{
assert(this->padding.size() == 4);
}
}
/**
* @brief Destroy the DepthwiseConv2D object.
*
*/
~DepthwiseConv2D()
~DepthwiseConv2D()
{
if (this->output != NULL)
{
@ -82,19 +95,31 @@ namespace dl
* @brief Update output shape and padding.
*
* @param input as an input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input)
void build(Tensor<feature_t> &input, bool print_shape = false)
{
assert(input.shape[0] > 0);
assert(input.shape[1] > 0);
assert(input.shape.size() == 3);
assert(this->filter->shape.size() == 4);
assert(input.shape[2] == this->filter->shape[2]);
std::vector<int> output_shape = nn::get_output_shape(input.shape, this->filter->shape_with_dilation, this->stride_y, this->stride_x, this->padding_type);
this->output->set_shape(output_shape);
this->output_shape = nn::get_output_shape(input.shape, this->filter->shape_with_dilation, this->stride_y, this->stride_x, this->padding_type, false, this->padding);
this->output->set_shape(this->output_shape);
this->output->set_exponent(this->output_exponent);
this->padding = nn::get_pad_size(output_shape, input.shape, this->filter->shape_with_dilation, this->stride_y, this->stride_x, this->padding_type);
input.set_padding_size(this->padding);
if (this->padding_type != PADDING_NOT_SET)
{
this->padding = nn::get_pad_size(this->output_shape, input.shape, this->filter->shape_with_dilation, this->stride_y, this->stride_x, this->padding_type);
}
this->output->free_element();
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
@ -122,7 +147,12 @@ namespace dl
DL_LOG_LAYER_LATENCY_INIT();
DL_LOG_LAYER_LATENCY_START();
this->output->apply_element();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->malloc_element();
this->output->set_exponent(this->output_exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");

128
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_expand_dims.hpp Normal file
View File

@ -0,0 +1,128 @@
#pragma once
#include "dl_constant.hpp"
#include "dl_variable.hpp"
#include "dl_tool.hpp"
#include "dl_layer_base.hpp"
namespace dl
{
namespace layer
{
/**
* @brief
*
* @tparam feature_t
*/
template <typename feature_t>
class ExpandDims : public Layer
{
private:
std::vector<int> output_shape; /*<! output shape of ExpandDims >*/
std::vector<int> axis; /*<! position where the new axis is placed. >*/
Tensor<feature_t> *output; /*<! output ptr of ExpandDims >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a separate memory >*/
public:
int output_exponent;
/**
* @brief Construct a new ExpandDims object
*
* @param axis position where the new axis is placed.
* @param name name of layer
* @param inplace true: the output will store to input
* false: the output will store to a separate memory
*/
ExpandDims(std::vector<int> axis, const char *name = "ExpandDims", bool inplace = false) : Layer(name),
axis(axis), inplace(inplace), output_shape({})
{
}
/**
* @brief Destroy the ExpandDims object
*
*/
~ExpandDims()
{
if ((!this->inplace) && (this->output != NULL))
{
delete this->output;
}
}
/**
* @brief Update output shape.
*
* @param input as an input.
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input, bool print_shape = false)
{
this->output_exponent = input.exponent;
if (!this->inplace)
{
if (this->output != NULL)
{
this->output = new Tensor<feature_t>;
}
this->output->set_exponent(this->output_exponent);
this->output->set_shape(this->output_shape);
this->output->expand_dims(this->axis);
this->output->free_element();
}
else
{
this->output = &input;
this->output->set_shape(this->output_shape);
this->output->expand_dims(this->axis);
}
this->output_shape = this->output->shape;
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
* @brief Get the output
*
* @return Tensor<feature_t>& ExpandDims result
*/
Tensor<feature_t> &get_output()
{
return *this->output;
}
/**
* @brief call ExpandDims opeartion
*
* @param input
* @return Tensor<feature_t>& ExpandDims result
*/
Tensor<feature_t> &call(Tensor<feature_t> &input)
{
DL_LOG_LAYER_LATENCY_INIT();
if (!this->inplace)
{
DL_LOG_LAYER_LATENCY_START();
this->output->set_exponent(input.exponent);
this->output->set_shape(this->output_shape);
this->output->copy_element(input, true);
DL_LOG_LAYER_LATENCY_END(this->name, "ExpandDims");
}
else
{
DL_LOG_LAYER_LATENCY_START();
this->output->set_shape(this->output_shape);
DL_LOG_LAYER_LATENCY_END(this->name, "ExpandDims");
}
return *this->output;
}
};
} // namespace layer
} // namespace dl

120
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_flatten.hpp Normal file
View File

@ -0,0 +1,120 @@
#pragma once
#include "dl_constant.hpp"
#include "dl_variable.hpp"
#include "dl_tool.hpp"
#include "dl_layer_base.hpp"
namespace dl
{
namespace layer
{
/**
* @brief
*
* @tparam feature_t
*/
template <typename feature_t>
class Flatten : public Layer
{
private:
int output_exponent; /*<! exponent of output >*/
Tensor<feature_t> *output; /*<! output ptr of Flatten >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a separate memory >*/
std::vector<int> output_shape; /*<! output shape of Flatten >*/
public:
/**
* @brief Construct a new Flatten object
*
* @param name name of layer
* @param inplace true: the output will store to input0
* false: the output will store to a separate memory
*/
Flatten(const char *name = "Flatten", bool inplace = false) : Layer(name), inplace(inplace), output_shape({})
{}
/**
* @brief Destroy the Flatten object
*
*/
~Flatten()
{
if ((!this->inplace) && (this->output != NULL))
{
delete this->output;
}
}
/**
* @brief Update output shape.
*
* @param input as an input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input, bool print_shape = false)
{
this->output_exponent = input.exponent;
this->output_shape = {input.get_size()};
if (!this->inplace)
{
if (this->output != NULL)
{
this->output = new Tensor<feature_t>;
}
this->output->set_exponent(this->output_exponent);
this->output->set_shape(this->output_shape);
this->output->free_element();
}
else
{
this->output = &input;
this->output->set_shape(this->output_shape);
}
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
* @brief Get the output
*
* @return Tensor<feature_t>& Flatten result
*/
Tensor<feature_t> &get_output()
{
return *this->output;
}
/**
* @brief Call Flatten operation.
*
* @param input as an input
* @return Tensor<feature_t>& Flatten result
*/
Tensor<feature_t> &call(Tensor<feature_t> &input)
{
DL_LOG_LAYER_LATENCY_INIT();
if (!this->inplace)
{
DL_LOG_LAYER_LATENCY_START();
this->output->set_exponent(input.exponent);
this->output->flatten();
this->output->copy_element(input, true);
DL_LOG_LAYER_LATENCY_END(this->name, "flatten");
}
else
{
DL_LOG_LAYER_LATENCY_START();
this->output->flatten();
DL_LOG_LAYER_LATENCY_END(this->name, "flatten");
}
return *this->output;
}
};
} // namespace layer
} // namespace dl

167
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_fullyconnected.hpp Normal file
View File

@ -0,0 +1,167 @@
#pragma once
#include "dl_nn_fully_connected.hpp"
#include "dl_layer_base.hpp"
namespace dl
{
namespace layer
{
/**
* @brief Activation(FullyConnected(input, filter) + bias).
*
* @tparam feature_t supports int16_t and int8_t,
* - int16_t: stands for operation in int16_t quantize
* - int8_t: stands for operation in int8_t quantize
* @tparam bias_t supports int16_t and int8_t, must specify when using int8 per-channel quantization
* - int16_t: for int16 quantization and int8 per-channel quantization
* - int8_t: for int8 per-tensor quantization
*/
template <typename feature_t, typename bias_t = feature_t>
class FullyConnected : public Layer
{
private:
const int output_exponent; /*<! exponent of output >*/
const bool flatten; /*<! true: input shape is [x1, x2, ..., xn], filter shape is [1, 1, x1 * x2 * ... * xn, output_dim], output shape is [output_dim]
false: input shape is [x1, x2, ..., xn, input_dim], filter shape is [1, 1, input_dim, output_dim], output shape is [x1, x2, ...., xn, output_dim] >*/
const Filter<feature_t> *filter; /*<! filter of FullyConnected >*/
const Bias<bias_t> *bias; /*<! bias of FullyConnected, if you don't specify anything, no bias is added >*/
const Activation<feature_t> *activation; /*<! activation of FullyConnected, if you don't specify anything, no activation is applied >*/
Tensor<feature_t> *output; /*<! output ptr of FullyConnected >*/
std::vector<int> output_shape; /*<! output shape of FullyConnected >*/
public:
/**
* @brief Construct a new FullyConnected object.
*
* @param output_exponent exponent of output
* @param filter filter of FullyConnected
* @param bias bias of FullyConnected, if you don't specify anything, no bias is added
* @param activation activation of FullyConnected, if you don't specify anything, no activation is applied
* @param flatten true: input shape is [x1, x2, ..., xn], filter shape is [1, 1, x1 * x2 * ... * xn, output_dim], output shape is [output_dim]
false: input shape is [x1, x2, ..., xn, input_dim], filter shape is [1, 1, input_dim, output_dim], output shape is [x1, x2, ...., xn, output_dim]
* @param name name of layer
*/
FullyConnected(const int output_exponent,
const Filter<feature_t> *filter,
const Bias<bias_t> *bias = NULL,
const Activation<feature_t> *activation = NULL,
const bool flatten = true,
const char *name = "FullyConnected") : Layer(name),
output_exponent(output_exponent),
flatten(flatten),
filter(filter),
bias(bias),
activation(activation),
output_shape({})
{
this->output = new Tensor<feature_t>;
}
/**
* @brief Destroy the FullyConnected object.
*
*/
~FullyConnected()
{
if (this->output != NULL)
{
delete this->output;
}
}
/**
* @brief Update output padding and input padding.
*
* @param input as an input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input, bool print_shape = false)
{
assert(this->filter->shape.size() == 4);
assert(this->filter->shape[0] == 1);
assert(this->filter->shape[1] == 1);
if (this->flatten)
{
assert(input.get_size() == this->filter->shape[2]);
this->output_shape = {this->filter->shape[3]};
}
else
{
assert(input.shape.back() == this->filter->shape[2]);
this->output_shape = input.shape;
this->output_shape[this->output_shape.size() - 1] = this->filter->shape[3];
}
this->output->set_shape(this->output_shape);
this->output->set_exponent(this->output_exponent);
this->output->free_element();
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
* @brief Get the output
*
* @return Tensor<feature_t>& FullyConnected result
*/
Tensor<feature_t> &get_output()
{
return *this->output;
}
/**
* @brief Call FullyConnected operation
*
* @param input as an input.
* @param autoload_enable one of true or false,
* - true: load input and output from PSRAM to CACHE automatically
* - false: do not
* @param assign_core not effective yet
* @return FullyConnected result
*/
Tensor<feature_t> &call(Tensor<feature_t> &input, bool autoload_enable = false, const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE)
{
DL_LOG_LAYER_LATENCY_INIT();
DL_LOG_LAYER_LATENCY_START();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->malloc_element();
this->output->set_exponent(this->output_exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");
if (autoload_enable)
{
dl::tool::cache::autoload_func((uint32_t)(this->output->element), this->output->get_size() * sizeof(feature_t),
(uint32_t)(input.element), input.get_size() * sizeof(feature_t));
}
DL_LOG_LAYER_LATENCY_START();
nn::fully_connected(*this->output, input, *(this->filter), this->bias, this->activation, this->flatten, assign_core);
DL_LOG_LAYER_LATENCY_END(this->name, "fully_connected");
return *this->output;
}
/**
* @brief Preload the filter to Cache.
* NOTE: Call this layer's preload() before previous layer's call() such that filter could be loaded while previous layer is doing calculation.
*/
void preload()
{
size_t size = sizeof(feature_t);
int shape_size = this->filter->shape.size();
for (int i = 0; i < shape_size; ++i)
{
size *= filter->shape[i];
}
dl::tool::cache::preload_func((uint32_t)(this->filter->element), size);
}
};
} // namespace layer
} // namespace dl

29
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_global_avg_pool2d.hpp
View File

@ -20,8 +20,9 @@ namespace dl
class GlobalAveragePool2D : public Layer
{
private:
const int output_exponent; /*<! exponent of output >*/
Tensor<feature_t> *output; /*<! output ptr of GlobalAveragePool2D >*/
const int output_exponent; /*<! exponent of output >*/
std::vector<int> output_shape; /*<! output shape of GlobalAveragePool2D >*/
Tensor<feature_t> *output; /*<! output ptr of GlobalAveragePool2D >*/
public:
/**
* @brief Construct a new GlobalAveragePool2D object.
@ -29,8 +30,9 @@ namespace dl
* @param output_exponent exponent of output
* @param name name of layer
*/
GlobalAveragePool2D(const int output_exponent, const char *name = NULL) : Layer(name),
output_exponent(output_exponent)
GlobalAveragePool2D(const int output_exponent, const char *name = "GlobalAveragePool2D") : Layer(name),
output_exponent(output_exponent),
output_shape({})
{
this->output = new Tensor<feature_t>;
@ -52,17 +54,26 @@ namespace dl
* @brief Update output shape.
*
* @param input as an input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input)
void build(Tensor<feature_t> &input, bool print_shape = false)
{
assert(input.shape[0] > 0);
assert(input.shape[1] > 0);
assert(input.shape.size() == 3);
std::vector<int> output_shape(input.shape.size(), 1);
output_shape[2] = input.shape[2];
this->output->set_shape(output_shape);
this->output_shape = output_shape;
this->output->set_shape(this->output_shape);
this->output->set_exponent(this->output_exponent);
this->output->free_element();
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
@ -90,7 +101,11 @@ namespace dl
DL_LOG_LAYER_LATENCY_INIT();
DL_LOG_LAYER_LATENCY_START();
this->output->apply_element();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->malloc_element();
this->output->set_exponent(this->output_exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");

25
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_global_max_pool2d.hpp
View File

@ -20,15 +20,15 @@ namespace dl
class GlobalMaxPool2D : public Layer
{
private:
Tensor<feature_t> *output; /*<! output ptr of GlobalMaxPool2D >*/
Tensor<feature_t> *output; /*<! output ptr of GlobalMaxPool2D >*/
std::vector<int> output_shape; /*<! output shape of GlobalMaxPool2D >*/
public:
/**
* @brief Construct a new GlobalMaxPool2D object.
*
* @param name name of layer
*/
GlobalMaxPool2D(const char *name = NULL) : Layer(name)
GlobalMaxPool2D(const char *name = "GlobalMaxPool2D") : Layer(name), output_shape({})
{
this->output = new Tensor<feature_t>;
}
@ -49,17 +49,26 @@ namespace dl
* @brief Update output shape and exponent.
*
* @param input as an input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input)
void build(Tensor<feature_t> &input, bool print_shape = false)
{
assert(input.shape[0] > 0);
assert(input.shape[1] > 0);
assert(input.shape.size() == 3);
this->output->set_exponent(input.exponent);
std::vector<int> output_shape(input.shape.size(), 1);
output_shape[2] = input.shape[2];
this->output->set_shape(output_shape);
this->output_shape = output_shape;
this->output->set_shape(this->output_shape);
this->output->free_element();
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
@ -87,7 +96,11 @@ namespace dl
DL_LOG_LAYER_LATENCY_INIT();
DL_LOG_LAYER_LATENCY_START();
this->output->apply_element();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->malloc_element();
this->output->set_exponent(input.exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");

52
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_leakyrelu.hpp
View File

@ -2,7 +2,7 @@
#include "dl_constant.hpp"
#include "dl_variable.hpp"
#include "dl_nn_LeakyReLU.hpp"
#include "dl_nn_leakyrelu.hpp"
#include "dl_layer_base.hpp"
namespace dl
@ -20,13 +20,13 @@ namespace dl
class LeakyReLU : public Layer
{
private:
feature_t activation_alpha; /*<! quantized alpha >*/
int activation_exponent; /*<! exponent of quantized alpha >*/
Tensor<feature_t> *output; /*<! output ptr of leakyrelu>*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a seperate memeory >*/
feature_t activation_alpha; /*<! quantized alpha >*/
int activation_exponent; /*<! exponent of quantized alpha >*/
Tensor<feature_t> *output; /*<! output ptr of leakyrelu>*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a separate memory >*/
std::vector<int> output_shape; /*<! output shape of leakyrelu >*/
public:
/**
* @brief Construct a new LeakyReLU object
*
@ -34,9 +34,9 @@ namespace dl
* @param activation_exponent exponent of quantized alpha
* @param name name of leakyrelu
* @param inplace true: the output will store to input0
* false: the output will store to a seperate memeory
* false: the output will store to a separate memory
*/
LeakyReLU(const int activation_alpha, const int activation_exponent, const char *name = NULL, bool inplace = false) : Layer(name), output(NULL)
LeakyReLU(const int activation_alpha, const int activation_exponent, const char *name = "LeakyReLU", bool inplace = false) : Layer(name), output(NULL), output_shape({})
{
this->activation_alpha = activation_alpha;
this->activation_exponent = activation_exponent;
@ -47,7 +47,7 @@ namespace dl
* @brief Destroy the LeakyReLU object
*
*/
~LeakyReLU()
~LeakyReLU()
{
if ((!this->inplace) && (this->output != NULL))
{
@ -59,24 +59,32 @@ namespace dl
* @brief Update output shape and exponent
*
* @param input as an input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input)
void build(Tensor<feature_t> &input, bool print_shape = false)
{
if(!this->inplace)
this->output_shape = input.shape;
if (!this->inplace)
{
if(this->output != NULL)
if (this->output != NULL)
{
this->output = new Tensor<feature_t>;
}
this->output->set_shape(input.shape);
}
this->output->set_shape(this->output_shape);
this->output->set_exponent(input.exponent);
this->output->free_element();
}
else
{
this->output = &input;
this->output->set_shape(this->output_shape);
}
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
@ -100,10 +108,14 @@ namespace dl
{
DL_LOG_LAYER_LATENCY_INIT();
if(!this->inplace)
if (!this->inplace)
{
DL_LOG_LAYER_LATENCY_START();
this->output->apply_element();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->malloc_element();
this->output->set_exponent(input.exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");
@ -114,6 +126,10 @@ namespace dl
else
{
DL_LOG_LAYER_LATENCY_START();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
nn::leakyrelu<true>(*this->output, input, this->activation_alpha, this->activation_exponent, assign_core);
DL_LOG_LAYER_LATENCY_END(this->name, "leakyrelu");
}

46
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_max2d.hpp
View File

@ -22,28 +22,28 @@ namespace dl
class Max2D : public Layer
{
private:
Tensor<feature_t> *output; /*<! output ptr of max2d >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a seperate memeory >*/
Tensor<feature_t> *output; /*<! output ptr of max2d >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a separate memory >*/
std::vector<int> output_shape; /*<! output shape of max2d >*/
public:
/**
* @brief Construct a new Max2D object.
*
* @param name name of max2d
* @param inplace true: the output will store to input0
* false: the output will store to a seperate memeory
* false: the output will store to a separate memory
*/
Max2D(const char *name = NULL, bool inplace = false) : Layer(name), output(NULL)
Max2D(const char *name = "Max2D", bool inplace = false) : Layer(name),
output(NULL), inplace(inplace), output_shape({})
{
this->inplace = inplace;
}
/**
* @brief Destroy the Max2D object
*
*/
~Max2D()
~Max2D()
{
if ((!this->inplace) && (this->output != NULL))
{
@ -58,24 +58,34 @@ namespace dl
*
* @param input0 as one input
* @param input1 as another input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input0, Tensor<feature_t> &input1)
void build(Tensor<feature_t> &input0, Tensor<feature_t> &input1, bool print_shape = false)
{
assert(input0.is_same_shape(input1));
assert(input0.exponent == input1.exponent);
this->output_shape = input0.shape;
if(!this->inplace)
if (!this->inplace)
{
if(this->output != NULL)
if (this->output != NULL)
{
this->output = new Tensor<feature_t>;
}
this->output->set_exponent(this->output_exponent);
this->output->set_shape(input0.shape);
this->output->set_shape(this->output_shape);
this->output->free_element();
}
else
{
this->output = &input0;
}
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
@ -100,10 +110,14 @@ namespace dl
{
DL_LOG_LAYER_LATENCY_INIT();
if(!this->inplace)
if (!this->inplace)
{
DL_LOG_LAYER_LATENCY_START();
this->output->apply_element();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->malloc_element();
this->output->set_exponent(input0.exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");
@ -114,6 +128,10 @@ namespace dl
else
{
DL_LOG_LAYER_LATENCY_START();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
nn::max2d<true>(*this->output, input0, input1, assign_core);
DL_LOG_LAYER_LATENCY_END(this->name, "max2d");
}

63
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_max_pool2d.hpp
View File

@ -23,44 +23,54 @@ namespace dl
std::vector<int> filter_shape; /*<! filter shape in [filter_height, filter_width] >*/
const int stride_y; /*<! stride in height >*/
const int stride_x; /*<! stride in width >*/
const padding_type_t padding_type; /*<! one of PADDING_VALID or PADDING_SAME or PADDING_SAME_MXNET >*/
const padding_type_t padding_type; /*<! one of PADDING_VALID or PADDING_SAME_END or PADDING_SAME_BEGIN >*/
std::vector<int> padding; /*<! padding size needed in [top, bottom, left, right] of this operation >*/
Tensor<feature_t> *output; /*<! output ptr of MaxPool2D >*/
std::vector<int> output_shape; /*<! output shape of MaxPool2D >*/
public:
/**
* @brief Construct a new MaxPool2D object.
*
* @param filter_shape filter shape in [filter_height, filter_width]
* @param padding_type one of PADDING_VALID or PADDING_SAME or PADDING_SAME_MXNET,
* @param padding_type one of PADDING_VALID or PADDING_SAME_END or PADDING_SAME_BEGIN or PADDING_NOT_SET,
* - PADDING_VALID means no padding
* PADDING_SAME and PADDING_SAME_MXNET results in padding with zeros evenly to the left/right or up/down of the input
* PADDING_SAME_END and PADDING_SAME_BEGIN results in padding with zeros evenly to the left/right or up/down of the input
* such that output has the same height/width dimension as the input,
* - PADDING_SAME results padding in TensorFlow style
* - PADDING_SAME_MXNET results padding in MXNET style
* - PADDING_SAME_END results padding in TensorFlow style
* - PADDING_SAME_BEGIN results padding in MXNET style
* - PADDING_NOT_SET means padding with the specific "padding" value below.
* @param padding if padding_type is PADDING_NOT_SET, this value will be used as padding size.
* the shape must be 4, the value of each position is: [padding top, padding bottom, padding left, padding right]
* @param stride_y stride in height
* @param stride_x stride in width
* @param name name of layer
*/
MaxPool2D(const std::vector<int> filter_shape,
const padding_type_t padding_type = PADDING_VALID,
std::vector<int> padding = {},
const int stride_y = 1,
const int stride_x = 1,
const char *name = NULL) : Layer(name),
filter_shape(filter_shape),
stride_y(stride_y),
stride_x(stride_x),
padding_type(padding_type)
const char *name = "MaxPool2D") : Layer(name),
filter_shape(filter_shape),
padding_type(padding_type),
padding(padding),
stride_y(stride_y),
stride_x(stride_x),
output_shape({})
{
this->output = new Tensor<feature_t>;
if (this->padding_type == PADDING_NOT_SET)
{
assert(this->padding.size() == 4);
}
}
/**
* @brief Destroy the MaxPool2D object.
*
*/
~MaxPool2D()
~MaxPool2D()
{
if (this->output != NULL)
{
@ -72,18 +82,29 @@ namespace dl
* @brief Update output shape and padding.
*
* @param input as an input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input)
void build(Tensor<feature_t> &input, bool print_shape = false)
{
assert(input.shape[0] > 0);
assert(input.shape[1] > 0);
this->output->set_exponent(input.exponent);
std::vector<int> output_shape = nn::get_output_shape(input.shape, filter_shape, this->stride_y, this->stride_x, this->padding_type);
this->output->set_shape(output_shape);
assert(input.shape.size() == 3);
this->padding = nn::get_pad_size(output_shape, input.shape, filter_shape, this->stride_y, this->stride_x, this->padding_type);
input.set_padding_size(this->padding);
this->output->set_exponent(input.exponent);
this->output_shape = nn::get_output_shape(input.shape, filter_shape, this->stride_y, this->stride_x, this->padding_type, false, this->padding);
this->output->set_shape(this->output_shape);
if (this->padding_type != PADDING_NOT_SET)
{
this->padding = nn::get_pad_size(this->output_shape, input.shape, filter_shape, this->stride_y, this->stride_x, this->padding_type);
}
this->output->free_element();
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
@ -111,7 +132,11 @@ namespace dl
DL_LOG_LAYER_LATENCY_INIT();
DL_LOG_LAYER_LATENCY_START();
this->output->apply_element();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->malloc_element();
this->output->set_exponent(input.exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");

53
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_min2d.hpp
View File

@ -22,28 +22,28 @@ namespace dl
class Min2D : public Layer
{
private:
Tensor<feature_t> *output; /*<! output of ptr min2d>*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a seperate memeory >*/
public:
Tensor<feature_t> *output; /*<! output of ptr min2d>*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a separate memory >*/
std::vector<int> output_shape; /*<! output shape of min2d >*/
public:
/**
* @brief Construct a new Min2D object
*
* @param name name of min2d
* @param inplace true: the output will store to input0
* false: the output will store to a seperate memeory
* false: the output will store to a separate memory
*/
Min2D(const char *name = NULL, bool inplace = false) : Layer(name), output(NULL)
{
this->inplace = inplace;
}
Min2D(const char *name = "Min2D", bool inplace = false) : Layer(name),
output(NULL),
inplace(inplace),
output_shape({}) {}
/**
* @brief Destroy the Min2D object
*
*/
~Min2D()
~Min2D()
{
if ((!this->inplace) && (this->output != NULL))
{
@ -58,25 +58,34 @@ namespace dl
*
* @param input0 as one input
* @param input1 as another input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input0, Tensor<feature_t> &input1)
void build(Tensor<feature_t> &input0, Tensor<feature_t> &input1, bool print_shape = false)
{
assert(input0.is_same_shape(input1));
assert(input0.exponent == input1.exponent);
this->output_shape = input0.shape;
if(!this->inplace)
if (!this->inplace)
{
if(this->output != NULL)
if (this->output != NULL)
{
this->output = new Tensor<feature_t>;
}
this->output->set_shape(input0.shape);
this->output->set_shape(this->output_shape);
this->output->set_exponent(input0.exponent);
this->output->free_element();
}
else
{
this->output = &input0;
}
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
@ -101,10 +110,14 @@ namespace dl
{
DL_LOG_LAYER_LATENCY_INIT();
if(!this->inplace)
if (!this->inplace)
{
DL_LOG_LAYER_LATENCY_START();
this->output->apply_element();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->malloc_element();
this->output->set_exponent(input0.exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");
@ -115,6 +128,10 @@ namespace dl
else
{
DL_LOG_LAYER_LATENCY_START();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
nn::min2d<true>(*this->output, input0, input1, assign_core);
DL_LOG_LAYER_LATENCY_END(this->name, "min2d");
}

55
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_mul2d.hpp
View File

@ -21,14 +21,13 @@ namespace dl
class Mul2D : public Layer
{
private:
const int output_exponent; /*<! exponent of output >*/
const int output_exponent; /*<! exponent of output >*/
const Activation<feature_t> *activation; /*<! activation of Mul2D, if you don't specify anything, no activation is applied >*/
Tensor<feature_t> *output; /*<! output ptr of Mul2D >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a seperate memeory >*/
Tensor<feature_t> *output; /*<! output ptr of Mul2D >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a separate memory >*/
std::vector<int> output_shape; /*<! output shape of Mul2D >*/
public:
const int output_exponent; /*<! exponent of output >*/
/**
* @brief Construct a new Mul2D object.
*
@ -36,18 +35,24 @@ namespace dl
* @param activation activation of Mul2D, if you don't specify anything, no activation is applied
* @param name name of layer
* @param inplace true: the output will store to input0
* false: the output will store to a seperate memeory
* false: the output will store to a separate memory
*/
Mul2D(const int output_exponent, const Activation<feature_t> *activation = NULL, const char *name = NULL, bool inplace = false) : Layer(name),
output_exponent(output_exponent),activation(activation), output(NULL)
Mul2D(const int output_exponent,
const Activation<feature_t> *activation = NULL,
const char *name = "Mul2D",
bool inplace = false) : Layer(name),
output_exponent(output_exponent),
activation(activation),
output(NULL),
inplace(inplace),
output_shape({})
{
this->inplace = inplace;
}
/**
* @brief Destroy the Multiply2D object.
*/
~Mul2D()
~Mul2D()
{
if ((!this->inplace) && (this->output != NULL))
{
@ -61,24 +66,34 @@ namespace dl
*
* @param input0 as one input
* @param input1 as another input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input0, Tensor<feature_t> &input1)
void build(Tensor<feature_t> &input0, Tensor<feature_t> &input1, bool print_shape = false)
{
assert(input0.is_same_shape(input1));
this->output_shape = input0.shape;
if (!this->inplace)
{
if(this->output != NULL)
if (this->output != NULL)
{
this->output = new Tensor<feature_t>;
}
this->output->set_exponent(this->output_exponent);
this->output->set_shape(input0.shape);
this->output->set_shape(this->output_shape);
this->output->free_element();
}
else
{
this->output = &input0;
}
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
@ -106,7 +121,11 @@ namespace dl
if (!this->inplace)
{
DL_LOG_LAYER_LATENCY_START();
this->output->apply_element();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->malloc_element();
this->output->set_exponent(this->output_exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");
@ -117,6 +136,10 @@ namespace dl
else
{
DL_LOG_LAYER_LATENCY_START();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
nn::mul2d<true>(*this->output, input0, input1, this->activation, assign_core);
DL_LOG_LAYER_LATENCY_END(this->name, "mul2d");
}

49
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_prelu.hpp
View File

@ -24,9 +24,9 @@ namespace dl
int activation_exponent; /*<! exponent of quantized alpha elements >*/
Tensor<feature_t> *output; /*<! output ptr of prelu >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a seperate memeory >*/
false: the output will store to a separate memory >*/
std::vector<int> output_shape; /*<! output shape of prelu >*/
public:
/**
* @brief Construct a new PReLU object
*
@ -34,20 +34,25 @@ namespace dl
* @param activation_exponent exponent of quantized alpha elements
* @param name name of prelu
* @param inplace true: the output will store to input0
* false: the output will store to a seperate memeory
* false: the output will store to a separate memory
*/
PReLU(const feature_t *activation_element, const int activation_exponent = 0, const char *name = NULL, bool inplace = false) : Layer(name), output(NULL)
PReLU(const feature_t *activation_element,
const int activation_exponent = 0,
const char *name = NULL,
bool inplace = "PReLU") : Layer(name),
activation_element(activation_element),
activation_exponent(activation_exponent),
output(NULL),
inplace(inplace),
output_shape({})
{
this->activation_element = activation_element;
this->activation_exponent = activation_exponent;
this->inplace = inplace;
}
/**
* @brief Destroy the PReLU object
*
*/
~PReLU()
~PReLU()
{
if ((!this->inplace) && (this->output != NULL))
{
@ -59,23 +64,31 @@ namespace dl
* @brief Update output shape and exponent
*
* @param input as an input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input)
void build(Tensor<feature_t> &input, bool print_shape = false)
{
if(!this->inplace)
this->output_shape = input.shape;
if (!this->inplace)
{
if(this->output != NULL)
if (this->output != NULL)
{
this->output = new Tensor<feature_t>;
}
this->output->set_exponent(input.exponent);
this->output->set_shape(input.shape);
this->output->set_shape(this->output_shape);
this->output->free_element();
}
else
{
this->output = &input;
}
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
@ -99,11 +112,15 @@ namespace dl
{
DL_LOG_LAYER_LATENCY_INIT();
if(!this->inplace)
if (!this->inplace)
{
DL_LOG_LAYER_LATENCY_START();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->set_exponent(input.exponent);
this->output->apply_element();
this->output->malloc_element();
DL_LOG_LAYER_LATENCY_END(this->name, "apply");
DL_LOG_LAYER_LATENCY_START();
@ -113,6 +130,10 @@ namespace dl
else
{
DL_LOG_LAYER_LATENCY_START();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
nn::prelu(*this->output, input, this->activation_element, this->activation_exponent, assign_core);
DL_LOG_LAYER_LATENCY_END(this->name, "leakyrelu");
}

45
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_relu.hpp
View File

@ -21,29 +21,28 @@ namespace dl
class ReLU : public Layer
{
private:
Tensor<feature_t> *output; /*<! output ptr of relu >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a seperate memeory >*/
Tensor<feature_t> *output; /*<! output ptr of relu >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a separate memory >*/
std::vector<int> output_shape; /*<! output shape of relu >*/
public:
/**
* @brief Construct a new ReLU object
*
* @param name name of relu
* @param inplace true: the output will store to input0
* false: the output will store to a seperate memeory
* false: the output will store to a separate memory
*/
ReLU(const char *name = NULL, bool inplace = false) : Layer(name), output(NULL)
ReLU(const char *name = "ReLU", bool inplace = false) : Layer(name),
output(NULL), inplace(inplace), output_shape({})
{
this->inplace = inplace;
}
/**
* @brief Destroy the ReLU object
*
*/
~ReLU()
~ReLU()
{
if ((!this->inplace) && (this->output != NULL))
{
@ -55,23 +54,31 @@ namespace dl
* @brief Update output shape and exponent
*
* @param input as an input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input)
void build(Tensor<feature_t> &input, bool print_shape = false)
{
if(!this->inplace)
this->output_shape = input.shape;
if (!this->inplace)
{
if(this->output != NULL)
if (this->output != NULL)
{
this->output = new Tensor<feature_t>;
}
this->output->set_exponent(input.exponent);
this->output->set_shape(input.shape);
this->output->set_shape(this->output_shape);
this->output->free_element();
}
else
{
this->output = &input;
}
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
@ -95,10 +102,14 @@ namespace dl
{
DL_LOG_LAYER_LATENCY_INIT();
if(!this->inplace)
if (!this->inplace)
{
DL_LOG_LAYER_LATENCY_START();
this->output->apply_element();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output->malloc_element();
this->output->set_exponent(input.exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");
@ -109,6 +120,10 @@ namespace dl
else
{
DL_LOG_LAYER_LATENCY_START();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
nn::relu(*this->output, input, assign_core);
DL_LOG_LAYER_LATENCY_END(this->name, "relu");
}

124
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_reshape.hpp Normal file
View File

@ -0,0 +1,124 @@
#pragma once
#include "dl_constant.hpp"
#include "dl_variable.hpp"
#include "dl_tool.hpp"
#include "dl_layer_base.hpp"
namespace dl
{
namespace layer
{
/**
* @brief Reshape(input)
*
* @tparam feature_t supports int16_t and int8_t,
* - int16_t: stands for operation in int16_t quantize
* - int8_t: stands for operation in int8_t quantize
*/
template <typename feature_t>
class Reshape : public Layer
{
private:
int output_exponent; /*<! exponent of output >*/
Tensor<feature_t> *output; /*<! output ptr of Reshape >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a separate memory >*/
std::vector<int> output_shape; /*<! output shape of Reshape >*/
public:
/**
* @brief Construct a new Reshape object
*
* @param shape the target shape
* @param name name of Reshape layer
* @param inplace true: the output will store to input0
* false: the output will store to a separate memory
*/
Reshape(std::vector<int> shape, const char *name = "Reshape", bool inplace = false) : Layer(name),
output_shape(shape), inplace(inplace)
{
}
/**
* @brief Destroy the Reshape object
*
*/
~Reshape()
{
if ((!this->inplace) && (this->output != NULL))
{
delete this->output;
}
}
/**
* @brief Update output shape and exponent
*
* @param input as an input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input, bool print_shape = false)
{
this->output_exponent = input.exponent;
if (!this->inplace)
{
if (this->output != NULL)
{
this->output = new Tensor<feature_t>;
}
this->output->set_exponent(this->output_exponent);
this->output->set_shape(this->output_shape);
this->output->free_element();
}
else
{
this->output = &input;
this->output->set_shape(this->output_shape);
}
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
* @brief Get the output
*
* @return Tensor<feature_t>& Reshape result
*/
Tensor<feature_t> &get_output()
{
return *this->output;
}
/**
* @brief Call Reshape operation.
*
* @param input as an input
* @return Tensor<feature_t>& Reshape result
*/
Tensor<feature_t> &call(Tensor<feature_t> &input)
{
DL_LOG_LAYER_LATENCY_INIT();
if (!this->inplace)
{
DL_LOG_LAYER_LATENCY_START();
this->output->set_exponent(input.exponent);
this->output->reshape(this->output_shape);
this->output->copy_element(input, true);
DL_LOG_LAYER_LATENCY_END(this->name, "reshape");
}
else
{
DL_LOG_LAYER_LATENCY_START();
this->output->reshape(this->output_shape);
DL_LOG_LAYER_LATENCY_END(this->name, "reshape");
}
return *this->output;
}
};
} // namespace layer
} // namespace dl

127
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_squeeze.hpp Normal file
View File

@ -0,0 +1,127 @@
#pragma once
#include "dl_constant.hpp"
#include "dl_variable.hpp"
#include "dl_tool.hpp"
#include "dl_layer_base.hpp"
namespace dl
{
namespace layer
{
/**
* @brief
*
* @tparam feature_t
*/
template <typename feature_t>
class Squeeze : public Layer
{
private:
int output_exponent; /*<! exponent of output >*/
Tensor<feature_t> *output; /*<! output ptr of Squeeze >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a separate memory >*/
int axis; /*<! the dim to to be remove. make sure the length of the dim is equal to 1.
if axis == INT32_MAX, all the dims with length==1 will be removed. >*/
std::vector<int> output_shape; /*<! output shape of AvgPool2D >*/
public:
/**
* @brief Construct a new Squeeze object
*
* @param axis the dim to to be remove. make sure the length of the dim is equal to 1.
* if axis == INT32_MAX, all the dims with length==1 will be removed.
* @param name name of Squeeze layer
* @param inplace true: the output will store to input0
* false: the output will store to a separate memory
*/
Squeeze(int axis = INT32_MAX, const char *name = "Squeeze", bool inplace = false) : Layer(name), axis(axis), inplace(inplace), output_shape({})
{
}
/**
* @brief Destroy the Squeeze object
*
*/
~Squeeze()
{
if ((!this->inplace) && (this->output != NULL))
{
delete this->output;
}
}
/**
* @brief Update output shape and exponent
*
* @param input as an input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input, bool print_shape = false)
{
this->output_exponent = input.exponent;
if (!this->inplace)
{
if (this->output != NULL)
{
this->output = new Tensor<feature_t>;
}
this->output->set_exponent(this->output_exponent);
this->output->set_shape(input.shape);
this->output->squeeze(this->axis);
this->output->free_element();
}
else
{
this->output = &input;
this->output->set_shape(input.shape);
this->output->squeeze(this->axis);
}
this->output_shape = this->output->shape;
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
* @brief Get the output
*
* @return Tensor<feature_t>& Squeeze result
*/
Tensor<feature_t> &get_output()
{
return *this->output;
}
/**
* @brief Call Squeeze operation.
*
* @param input as an input
* @return Tensor<feature_t>& Squeeze result
*/
Tensor<feature_t> &call(Tensor<feature_t> &input)
{
DL_LOG_LAYER_LATENCY_INIT();
if (!this->inplace)
{
DL_LOG_LAYER_LATENCY_START();
this->output->set_exponent(input.exponent);
this->output->set_shape(this->output_shape);
this->output->copy_element(input, true);
DL_LOG_LAYER_LATENCY_END(this->name, "Squeeze");
}
else
{
DL_LOG_LAYER_LATENCY_START();
this->output->set_shape(this->output_shape);
DL_LOG_LAYER_LATENCY_END(this->name, "Squeeze");
}
return *this->output;
}
};
} // namespace layer
} // namespace dl

49
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_sub2d.hpp
View File

@ -21,13 +21,13 @@ namespace dl
class Sub2D : public Layer
{
private:
const int output_exponent; /*<! exponent of output >*/
const Activation<feature_t> *activation; /*<! activation of Mul2D, if you don't specify anything, no activation is applied >*/
Tensor<feature_t> *output; /*<! output ptr of Sub2D >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a seperate memeory >*/
const int output_exponent; /*<! exponent of output >*/
const Activation<feature_t> *activation; /*<! activation of Sub2D, if you don't specify anything, no activation is applied >*/
Tensor<feature_t> *output; /*<! output ptr of Sub2D >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a separate memory >*/
std::vector<int> output_shape; /*<! output shape of Sub2D >*/
public:
/**
* @brief Construct a new Sub2D object.
*
@ -35,18 +35,17 @@ namespace dl
* @param activation activation of Mul2D, if you don't specify anything, no activation is applied
* @param name name of layer
* @param inplace true: the output will store to input0
* false: the output will store to a seperate memeory
* false: the output will store to a separate memory
*/
Sub2D(const int output_exponent, const Activation<feature_t> *activation = NULL, const char *name = NULL, bool inplace = false) : Layer(name),
output_exponent(output_exponent), activation(activation), output(NULL)
Sub2D(const int output_exponent, const Activation<feature_t> *activation = NULL, const char *name = "Sub2D", bool inplace = false) : Layer(name),
output_exponent(output_exponent), activation(activation), output(NULL), inplace(inplace), output_shape({})
{
this->inplace = inplace;
}
/**
* @brief Destroy the Sub2D object.
*/
~Sub2D()
~Sub2D()
{
if ((!this->inplace) && (this->output != NULL))
{
@ -60,22 +59,32 @@ namespace dl
*
* @param input0 as one input
* @param input1 as another input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input0, Tensor<feature_t> &input1)
void build(Tensor<feature_t> &input0, Tensor<feature_t> &input1, bool print_shape = false)
{
assert(input0.is_same_shape(input1));
this->output_shape = input0.shape;
if (!this->inplace)
{
if(this->output != NULL)
if (this->output != NULL)
{
this->output = new Tensor<feature_t>;
}
this->output->set_exponent(this->output_exponent);
this->output->set_shape(input0.shape);
this->output->set_shape(this->output_shape);
this->output->free_element();
}
}
else
{
this->output = &input0;
}
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
@ -103,7 +112,11 @@ namespace dl
if (!this->inplace)
{
DL_LOG_LAYER_LATENCY_START();
this->output.apply_element();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
this->output.malloc_element();
this->output->set_exponent(input0.exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "apply");
@ -114,6 +127,10 @@ namespace dl
else
{
DL_LOG_LAYER_LATENCY_START();
if (this->output->shape != this->output_shape)
{
this->output->set_shape(this->output_shape);
}
nn::sub2d<true>(this->output, input0, input1, this->activation, assign_core, this->output_exponent);
DL_LOG_LAYER_LATENCY_END(this->name, "sub2d");
}

126
tools/sdk/esp32s2/include/esp-face/include/layer/dl_layer_transpose.hpp Normal file
View File

@ -0,0 +1,126 @@
#pragma once
#include "dl_constant.hpp"
#include "dl_variable.hpp"
#include "dl_tool.hpp"
#include "dl_layer_base.hpp"
namespace dl
{
namespace layer
{
/**
* @brief
*
* @tparam feature_t
*/
template <typename feature_t>
class Transpose : public Layer
{
private:
int output_exponent; /*<! exponent of output >*/
Tensor<feature_t> *output; /*<! output ptr of Transpose >*/
bool inplace; /*<! true: the output will store to input0
false: the output will store to a separate memory >*/
std::vector<int> perm; /*<! the new arangement of the dims. if perm == {}, the dims arangement will be reversed. >*/
std::vector<int> output_shape; /*<! output shape of Transpose >*/
public:
/**
* @brief Construct a new Transpose object
*
* @param perm the new arangement of the dims. if perm == {}, the dims arangement will be reversed.
* @param name name of Transpose layer
* @param inplace true: the output will store to input
* false: the output will store to a separate memory
*/
Transpose(std::vector<int> perm = {}, const char *name = "Transpose", bool inplace = false) : Layer(name), perm(perm), inplace(inplace), output_shape({})
{
}
/**
* @brief Destroy the Transpose object
*
*/
~Transpose()
{
if ((!this->inplace) && (this->output != NULL))
{
delete this->output;
}
}
/**
* @brief Update output shape and exponent
*
* @param input as an input
* @param print_shape whether to print the output shape.
*/
void build(Tensor<feature_t> &input, bool print_shape = false)
{
this->output_exponent = input.exponent;
this->output_shape = input.shape;
for (int i = 0; i < this->perm.size(); i++)
{
this->output_shape[i] = input.shape[this->perm[i]];
}
if (!this->inplace)
{
if (this->output != NULL)
{
this->output = new Tensor<feature_t>;
}
this->output->set_exponent(this->output_exponent);
this->output->set_shape(this->output_shape);
this->output->free_element();
}
else
{
this->output = &input;
this->output->set_shape(this->output_shape);
}
if (print_shape)
{
std::cout << this->name << " | ";
this->output->print_shape();
}
}
/**
* @brief Get the output
*
* @return Tensor<feature_t>& Transpose result
*/
Tensor<feature_t> &get_output()
{
return *this->output;
}
/**
* @brief Call Transpose operation.
*
* @param input as an input.
* @return Tensor<feature_t>& Transpose result.
*/
Tensor<feature_t> &call(Tensor<feature_t> &input)
{
DL_LOG_LAYER_LATENCY_INIT();
if (!this->inplace)
{
DL_LOG_LAYER_LATENCY_START();
this->output->set_exponent(input.exponent);
this->output->transpose(input, this->perm);
DL_LOG_LAYER_LATENCY_END(this->name, "transpose");
}
else
{
DL_LOG_LAYER_LATENCY_START();
this->output->transpose(this->perm);
DL_LOG_LAYER_LATENCY_END(this->name, "transpose");
}
return *this->output;
}
};
} // namespace layer
} // namespace dl

68
tools/sdk/esp32s2/include/esp-face/include/model_zoo/color_detector.hpp Normal file
View File

@ -0,0 +1,68 @@
#pragma once
#include "dl_image.hpp"
typedef struct
{
int area; /*!< Area of connected domains >*/
std::vector<int> center; /*<! centroid of connected domains [x, y] >*/
std::vector<int> box; /*<! [left_up_x, left_up_y, right_down_x, right_down_y] >*/
} components_stats_t;
class ColorDetector
{
private:
std::vector<std::vector<components_stats_t>> results; /*!< detection results >*/
public:
std::vector<std::vector<uint8_t>> color_thresh; /*!< threshold of colors, The threshold of each color is composed of 6 numbers >*/
std::vector<int> area_thresh; /*!< the area threshold of each color,
the area that is smaller than the threshold is filtered >*/
bool bgr; /*!< true: the input image is in BGR format
false: the input image is in RGB format >*/
/**
* @brief get the color threshold of rectangular region in the image
*
* @param image the input image
* @param box the coordinates of the rectanglar region : [left_up_x, left_up_y, right_down_x, right_down_y]
* @return std::vector<uint8_t> the threshold.
*/
std::vector<uint8_t> cal_color_thresh(dl::Tensor<uint8_t> &image, std::vector<int> box);
/**
* @brief detect the colors based on the color thresholds
*
* @param image the input image.
* @return std::vector<std::vector<components_stats_t>>& detection result.
*/
std::vector<std::vector<components_stats_t>> &detect(dl::Tensor<uint8_t> &image);
/**
* @brief Construct a new Color Detector object
*
* @param color_thresh threshold of colors, The threshold of each color is composed of 6 numbers
* @param area_thresh the area threshold of each color,the area that is smaller than the threshold is filtered
* @param bgr true: the input image is in BGR format
* false: the input image is in RGB format
*/
ColorDetector(std::vector<std::vector<uint8_t>> color_thresh, std::vector<int> area_thresh, bool bgr = false) : color_thresh(color_thresh), area_thresh(area_thresh), bgr(bgr)
{
}
/**
* @brief Destroy the Color Detector object
*
*/
~ColorDetector() {}
/**
* @brief Get the results object
*
* @return std::vector<std::vector<components_stats_t>>& the detection result.
*/
std::vector<std::vector<components_stats_t>> &get_results()
{
return this->results;
}
};

4
tools/sdk/esp32s2/include/esp-face/include/model_zoo/face_recognition_tool.hpp
View File

@ -92,7 +92,7 @@ namespace face_recognition_tool
* @return dl::Tensor<T>*
*/
template <typename T>
dl::Tensor<T> *transform_mfn_input(dl::Tensor<uint8_t> &image, bool free_input = false, bool do_padding = true);
dl::Tensor<T> *transform_mfn_input(dl::Tensor<uint8_t> &image, bool free_input = false);
/**
* @brief transform the image to the input of a mfn model
@ -106,7 +106,7 @@ namespace face_recognition_tool
* false: do not pad the result
*/
template <typename T>
void transform_mfn_input(dl::Tensor<uint8_t> &image, dl::Tensor<T> &output, bool free_input = false, bool do_padding = true);
void transform_mfn_input(dl::Tensor<uint8_t> &image, dl::Tensor<T> &output, bool free_input = false);
/**
* @brief transform the mfn output embedding to a floating embedding

6
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn.hpp
View File

@ -14,13 +14,13 @@ namespace dl
* @param filter_shape filter shape with dilation
* @param stride_y stride in height
* @param stride_x stride in width
* @param pad_type one of PADDING_VALID or PADDING_SAME or PADDING_SAME_MXNET
* @param pad_type one of PADDING_VALID or PADDING_SAME_END or PADDING_SAME_BEGIN
* @param is_conv2d one of true or false,
* - true: serve for Conv2D
* - false: serve for other operations
* @return std::vector<int>
*/
std::vector<int> get_output_shape(const std::vector<int> &input_shape, const std::vector<int> &filter_shape, const int stride_y, const int stride_x, const padding_type_t pad_type, const bool is_conv2d = false);
std::vector<int> get_output_shape(const std::vector<int> &input_shape, const std::vector<int> &filter_shape, const int stride_y, const int stride_x, const padding_type_t pad_type, const bool is_conv2d = false, std::vector<int> padding = {});
/**
* @brief Get the pad size object
@ -30,7 +30,7 @@ namespace dl
* @param filter_shape filter shape with dilation
* @param stride_y stride in height
* @param stride_x stride in width
* @param padding_type one of PADDING_VALID or PADDING_SAME or PADDING_SAME_MXNET
* @param padding_type one of PADDING_VALID or PADDING_SAME_END or PADDING_SAME_BEGIN
* @return padding size
*/
std::vector<int> get_pad_size(const std::vector<int> &output_shape, const std::vector<int> &input_shape, const std::vector<int> &filter_shape, const int stride_y, const int stride_x, const padding_type_t padding_type);

12
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_add2d.hpp
View File

@ -58,20 +58,20 @@ namespace dl
*/
template <bool inplace = false, typename feature_t>
auto add2d(const int output_exponent,
Tensor<feature_t> &input0,
Tensor<feature_t> &input1,
const Activation<feature_t> *activation,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE) -> typename std::conditional<inplace, void, Tensor<feature_t>>::type
Tensor<feature_t> &input0,
Tensor<feature_t> &input1,
const Activation<feature_t> *activation,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE) -> typename std::conditional<inplace, void, Tensor<feature_t>>::type
{
assert(input0.is_same_shape(input1));
DL_LOG_NN_LATENCY_INIT();
Tensor<feature_t> output;
if constexpr(!inplace)
if constexpr (!inplace)
{
DL_LOG_NN_LATENCY_START();
output.set_exponent(output_exponent).set_shape(input0.shape).apply_element();
output.set_exponent(output_exponent).set_shape(input0.shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
DL_LOG_NN_LATENCY_START();

18
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_avg_pool2d.hpp
View File

@ -58,12 +58,12 @@ namespace dl
* @param filter_shape filter_shape in [filter_height, filter_width]
* @param stride_y stride in height
* @param stride_x stride in width
* @param padding_type one of PADDING_VALID or PADDING_SAME or PADDING_SAME_MXNET,
* @param padding_type one of PADDING_VALID or PADDING_SAME_END or PADDING_SAME_BEGIN,
* - PADDING_VALID: no padding
* PADDING_SAME and PADDING_SAME_MXNET results in padding with zeros evenly to the left/right or up/down of the input
* PADDING_SAME_END and PADDING_SAME_BEGIN results in padding with zeros evenly to the left/right or up/down of the input
* such that output has the same height/width dimension as the input,
* - PADDING_SAME results padding in TensorFlow style
* - PADDING_SAME_MXNET results padding in MXNET style
* - PADDING_SAME_END results padding in TensorFlow style
* - PADDING_SAME_BEGIN results padding in MXNET style
* @param assign_core not effective yet
* @return avg_pool2d result
*/
@ -81,19 +81,19 @@ namespace dl
DL_LOG_NN_LATENCY_START();
std::vector<int> output_shape = get_output_shape(input.shape, filter_shape, stride_y, stride_x, padding_type);
Tensor<feature_t> output;
output.set_exponent(output_exponent).set_shape(output_shape).apply_element();
output.set_exponent(output_exponent).set_shape(output_shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
std::vector<int> padding(4, 0);
DL_LOG_NN_LATENCY_START();
if (padding_type == PADDING_SAME || padding_type == PADDING_SAME_MXNET)
if (padding_type == PADDING_SAME_END || padding_type == PADDING_SAME_BEGIN)
{
std::vector<int> padding = get_pad_size(output_shape, input.shape, filter_shape, stride_y, stride_x, padding_type);
input.set_padding_size(padding);
padding = get_pad_size(output_shape, input.shape, filter_shape, stride_y, stride_x, padding_type);
}
DL_LOG_NN_LATENCY_END("padding");
DL_LOG_NN_LATENCY_START();
avg_pool2d(output, input, input.padding, filter_shape, stride_y, stride_x, assign_core);
avg_pool2d(output, input, padding, filter_shape, stride_y, stride_x, assign_core);
DL_LOG_NN_LATENCY_END("avg_pool2d");
return output;

63
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_concat.hpp Normal file
View File

@ -0,0 +1,63 @@
#pragma once
#include <vector>
#include "dl_variable.hpp"
#include "dl_nn.hpp"
namespace dl
{
namespace nn
{
template <typename feature_t>
void concat(Tensor<feature_t> &output, std::vector<Tensor<feature_t> *> &inputs, int axis, bool free_inputs = false);
template <typename feature_t>
Tensor<feature_t> concat(std::vector<Tensor<feature_t> *> &inputs, int axis, bool free_inputs = false)
{
DL_LOG_NN_LATENCY_INIT();
DL_LOG_NN_LATENCY_START();
assert(inputs.size() > 1);
int shape_size = inputs[0]->shape.size();
if (axis < 0)
{
axis = shape_size + axis;
}
assert((axis < shape_size) && (axis > -1));
int output_shape_axis = inputs[0]->shape[axis];
for (int i = 1; i < inputs.size(); i++)
{
assert(shape_size == inputs[i]->shape.size());
assert(inputs[i]->exponent == inputs[i - 1]->exponent);
output_shape_axis += inputs[i]->shape[axis];
for (int j = 0; j < shape_size; j++)
{
if (j != axis)
{
assert(inputs[i]->shape[j] == inputs[i - 1]->shape[j]);
}
}
}
DL_LOG_NN_LATENCY_END("assert");
DL_LOG_NN_LATENCY_START();
Tensor<feature_t> output;
std::vector<int> output_shape = inputs[0]->shape;
output_shape[axis] = output_shape_axis;
output.set_shape(output_shape);
output.set_exponent(inputs[0]->exponent);
output.malloc_element();
DL_LOG_NN_LATENCY_END("malloc");
DL_LOG_NN_LATENCY_START();
concat(output, inputs, axis, free_inputs);
DL_LOG_NN_LATENCY_END("concat");
return output;
}
} // namespace nn
} // namespace dl

48
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_conv2d.hpp
View File

@ -10,7 +10,6 @@ namespace dl
{
/**
* @brief activation(conv2d(input, filter) + bias).
* NOTE: When padding_type is SAME, make sure padding is already added in input.
*
* @param output as an output
* @param input as an input
@ -34,7 +33,6 @@ namespace dl
/**
* @brief activation(conv2d(input, filter) + bias).
* NOTE: When padding_type is SAME, make sure padding is already added in input.
*
* @param output as an output
* @param input as an input
@ -56,6 +54,29 @@ namespace dl
const Activation<int8_t> *const activation = NULL,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE);
/**
* @brief activation(conv2d(input, filter) + bias).
*
* @param output as an output
* @param input as an input
* @param padding padding size needed in [top, bottom, left, right] of this operation
* @param filter filter of conv2d
* @param stride_y stride in height
* @param stride_x stride in width
* @param bias bias of conv2d, if you don't specify anything, no bias is added
* @param activation activation of conv2d, if you don't specify anything, no activation is applied
* @param assign_core not effective yet
*/
void conv2d(Tensor<int8_t> &output,
Tensor<int8_t> &input,
std::vector<int> &padding,
const Filter<int8_t> &filter,
const int stride_y,
const int stride_x,
const Bias<int16_t> *const bias = NULL,
const Activation<int8_t> *const activation = NULL,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE);
/**
* @brief activation(conv2d(input, filter) + bias).
*
@ -67,25 +88,25 @@ namespace dl
* @param filter Filter of conv2d
* @param stride_y stride in height
* @param stride_x stride in width
* @param padding_type one of PADDING_VALID or PADDING_SAME or PADDING_SAME_MXNET,
* @param padding_type one of PADDING_VALID or PADDING_SAME_END or PADDING_SAME_BEGIN,
* - PADDING_VALID: no padding
* PADDING_SAME and PADDING_SAME_MXNET results in padding with zeros evenly to the left/right or up/down of the input
* PADDING_SAME_END and PADDING_SAME_BEGIN results in padding with zeros evenly to the left/right or up/down of the input
* such that output has the same height/width dimension as the input,
* - PADDING_SAME results padding in TensorFlow style
* - PADDING_SAME_MXNET results padding in MXNET style
* - PADDING_SAME_END results padding in TensorFlow style
* - PADDING_SAME_BEGIN results padding in MXNET style
* @param bias bias of conv2d, if you don't specify anything, no bias is added
* @param activation activation of conv2d, if you don't specify anything, no activation is applied
* @param assign_core not effective yet
* @return conv2d result
*/
template <typename feature_t>
template <typename feature_t, typename bias_t>
Tensor<feature_t> conv2d(const int output_exponent,
Tensor<feature_t> &input,
const Filter<feature_t> &filter,
const int stride_y,
const int stride_x,
const padding_type_t padding_type,
const Bias<feature_t> *bias,
const Bias<bias_t> *bias,
const Activation<feature_t> *activation,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE)
{
@ -94,20 +115,19 @@ namespace dl
DL_LOG_NN_LATENCY_START();
std::vector<int> output_shape = get_output_shape(input.shape, filter.shape_with_dilation, stride_y, stride_x, padding_type, true);
Tensor<feature_t> output;
output.set_exponent(output_exponent).set_shape(output_shape).apply_element();
output.set_exponent(output_exponent).set_shape(output_shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
std::vector<int> padding(4, 0);
DL_LOG_NN_LATENCY_START();
if (padding_type == PADDING_SAME || padding_type == PADDING_SAME_MXNET)
if (padding_type == PADDING_SAME_END || padding_type == PADDING_SAME_BEGIN)
{
std::vector<int> padding = get_pad_size(output_shape, input.shape, filter.shape_with_dilation, stride_y, stride_x, padding_type);
input.set_padding_size(padding);
input.set_padding_value(padding, 0);
padding = get_pad_size(output_shape, input.shape, filter.shape_with_dilation, stride_y, stride_x, padding_type);
}
DL_LOG_NN_LATENCY_END("padding");
DL_LOG_NN_LATENCY_START();
conv2d(output, input, input.padding, filter, stride_y, stride_x, bias, activation, assign_core);
conv2d(output, input, padding, filter, stride_y, stride_x, bias, activation, assign_core);
DL_LOG_NN_LATENCY_END("conv2d");
return output;

49
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_depthwise_conv2d.hpp
View File

@ -10,7 +10,6 @@ namespace dl
{
/**
* @brief activate(depthwise_conv2d(input, filter) + bias)
* NOTE: When padding_type is SAME, make sure padding is already added in input
*
* @param output as an output
* @param input as an input
@ -34,7 +33,6 @@ namespace dl
/**
* @brief activate(depthwise_conv2d(input, filter) + bias)
* NOTE: When padding_type is SAME, make sure padding is already added in input
*
* @param output as an output
* @param input as an input
@ -56,6 +54,29 @@ namespace dl
const Activation<int8_t> *activation = NULL,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE);
/**
* @brief activate(depthwise_conv2d(input, filter) + bias)
*
* @param output as an output
* @param input as an input
* @param padding padding size needed in [top, bottom, left, right] of this operation
* @param filter Filter of depthwise_conv2d
* @param stride_y stride in height
* @param stride_x stride in width
* @param bias bias of depthwise_conv2d, if you don't specify anything, no bias is added
* @param activation activation of depthwise_conv2d, if you don't specify anything, no activation is applied
* @param assign_core not effective yet
*/
void depthwise_conv2d(Tensor<int8_t> &output,
Tensor<int8_t> &input,
std::vector<int> &padding,
const Filter<int8_t> &filter,
const int stride_y,
const int stride_x,
const Bias<int16_t> *bias = NULL,
const Activation<int8_t> *activation = NULL,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE);
/**
* @brief activation(depthwise_conv2d(input, filter) + bias)
*
@ -67,25 +88,25 @@ namespace dl
* @param filter filter of depthwise_conv2d
* @param stride_y stride in height
* @param stride_x stride in width
* @param pad_type one of PADDING_VALID or PADDING_SAME or PADDING_SAME_MXNET,
* @param pad_type one of PADDING_VALID or PADDING_SAME_END or PADDING_SAME_BEGIN,
* - PADDING_VALID means no padding
* PADDING_SAME and PADDING_SAME_MXNET results in padding with zeros evenly to the left/right or up/down of the input
* PADDING_SAME_END and PADDING_SAME_BEGIN results in padding with zeros evenly to the left/right or up/down of the input
* such that output has the same height/width dimension as the input,
* - PADDING_SAME results padding in TensorFlow style
* - PADDING_SAME_MXNET results padding in MXNET style
* - PADDING_SAME_END results padding in TensorFlow style
* - PADDING_SAME_BEGIN results padding in MXNET style
* @param bias bias of depthwise_conv2d, if you don't specify anything, no bias is added
* @param activation activation of depthwise_conv2d, if you don't specify anything, no activation is applied
* @param assign_core not effective yet
* @return depthwise_conv2d result
*/
template <typename feature_t>
template <typename feature_t, typename bias_t>
Tensor<feature_t> depthwise_conv2d(const int output_exponent,
Tensor<feature_t> &input,
const Filter<feature_t> &filter,
const int stride_y,
const int stride_x,
const padding_type_t padding_type,
const Bias<feature_t> *bias,
const Bias<bias_t> *bias,
const Activation<feature_t> *activation,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE)
{
@ -94,20 +115,20 @@ namespace dl
DL_LOG_NN_LATENCY_START();
std::vector<int> output_shape = get_output_shape(input.shape, filter.shape_with_dilation, stride_y, stride_x, padding_type);
Tensor<feature_t> output;
output.set_exponent(output_exponent).set_shape(output_shape).apply_element();
output.set_exponent(output_exponent).set_shape(output_shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
std::vector<int> padding(4, 0);
DL_LOG_NN_LATENCY_START();
if (padding_type == PADDING_SAME || padding_type == PADDING_SAME_MXNET)
if (padding_type == PADDING_SAME_END || padding_type == PADDING_SAME_BEGIN)
{
std::vector<int> padding = get_pad_size(output_shape, input.shape, filter.shape_with_dilation, stride_y, stride_x, padding_type);
input.set_padding_size(padding);
input.set_padding_value(padding, 0);
padding = get_pad_size(output_shape, input.shape, filter.shape_with_dilation, stride_y, stride_x, padding_type);
}
DL_LOG_NN_LATENCY_END("padding");
DL_LOG_NN_LATENCY_START();
depthwise_conv2d(output, input, input.padding, filter, stride_y, stride_x, bias, activation, assign_core);
depthwise_conv2d(output, input, padding, filter, stride_y, stride_x, bias, activation, assign_core);
DL_LOG_NN_LATENCY_END("depthwise_conv2d");
return output;

126
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_fully_connected.hpp Normal file
View File

@ -0,0 +1,126 @@
#pragma once
#include "dl_constant.hpp"
#include "dl_variable.hpp"
#include "dl_nn.hpp"
namespace dl
{
namespace nn
{
/**
* @brief activation(FullyConnected(input, filter) + bias).
*
* @param output as an output
* @param input as an input
* @param filter filter of FullyConnected
* @param bias bias of FullyConnected, if you don't specify anything, no bias is added
* @param activation activation of FullyConnected, if you don't specify anything, no activation is applied
* @param flatten true: input shape is [x1, x2, ..., xn], filter shape is [1, 1, x1 * x2 * ... * xn, output_dim], output shape is [output_dim]
* false: input shape is [x1, x2, ..., xn, input_dim], filter shape is [1, 1, input_dim, output_dim], output shape is [x1, x2, ...., xn, output_dim]
* @param assign_core not effective yet
*/
void fully_connected(Tensor<int16_t> &output,
Tensor<int16_t> &input,
const Filter<int16_t> &filter,
const Bias<int16_t> *const bias = NULL,
const Activation<int16_t> *const activation = NULL,
const bool flatten = true,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE);
/**
* @brief activation(FullyConnected(input, filter) + bias).
*
* @param output as an output
* @param input as an input
* @param filter filter of FullyConnected
* @param bias bias of FullyConnected, if you don't specify anything, no bias is added
* @param activation activation of FullyConnected, if you don't specify anything, no activation is applied
* @param flatten true: input shape is [x1, x2, ..., xn], filter shape is [1, 1, x1 * x2 * ... * xn, output_dim], output shape is [output_dim]
* false: input shape is [x1, x2, ..., xn, input_dim], filter shape is [1, 1, input_dim, output_dim], output shape is [x1, x2, ...., xn, output_dim]
* @param assign_core not effective yet
*/
void fully_connected(Tensor<int8_t> &output,
Tensor<int8_t> &input,
const Filter<int8_t> &filter,
const Bias<int8_t> *const bias = NULL,
const Activation<int8_t> *const activation = NULL,
const bool flatten = true,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE);
/**
* @brief activation(FullyConnected(input, filter) + bias).
*
* @param output as an output
* @param input as an input
* @param filter filter of FullyConnected
* @param bias bias of FullyConnected, if you don't specify anything, no bias is added
* @param activation activation of FullyConnected, if you don't specify anything, no activation is applied
* @param flatten true: input shape is [x1, x2, ..., xn], filter shape is [1, 1, x1 * x2 * ... * xn, output_dim], output shape is [output_dim]
* false: input shape is [x1, x2, ..., xn, input_dim], filter shape is [1, 1, input_dim, output_dim], output shape is [x1, x2, ...., xn, output_dim]
* @param assign_core not effective yet
*/
void fully_connected(Tensor<int8_t> &output,
Tensor<int8_t> &input,
const Filter<int8_t> &filter,
const Bias<int16_t> *const bias = NULL,
const Activation<int8_t> *const activation = NULL,
const bool flatten = true,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE);
/**
* @brief activation(FullyConnected(input, filter) + bias).
*
* @tparam feature_t supports int16_t and int8_t,
* - int16_t: stands for operation in int16_t quantize
* - int8_t: stands for operation in int8_t quantize
* @param output_exponent exponent of output
* @param input as an input
* @param filter Filter of FullyConnected
* @param bias bias of FullyConnected, if you don't specify anything, no bias is added
* @param activation activation of FullyConnected, if you don't specify anything, no activation is applied
* @param flatten true: input shape is [x1, x2, ..., xn], filter shape is [1, 1, x1 * x2 * ... * xn, output_dim], output shape is [output_dim]
* false: input shape is [x1, x2, ..., xn, input_dim], filter shape is [1, 1, input_dim, output_dim], output shape is [x1, x2, ...., xn, output_dim]
* @param assign_core not effective yet
* @return FullyConnected result
*/
template <typename feature_t>
Tensor<feature_t> fully_connected(const int output_exponent,
Tensor<feature_t> &input,
const Filter<feature_t> &filter,
const Bias<feature_t> *bias,
const Activation<feature_t> *activation,
const bool flatten,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE)
{
DL_LOG_NN_LATENCY_INIT();
DL_LOG_NN_LATENCY_START();
assert(filter.shape.size() == 4);
assert(filter.shape[0] == 1);
assert(filter.shape[1] == 1);
std::vector<int> output_shape;
if (flatten)
{
assert(input.get_size() == filter.shape[2]);
output_shape = {filter.shape.back()};
}
else
{
assert(input.shape.back() == filter->shape[2]);
output_shape = input.shape;
output_shape[output_shape.size() - 1] = filter.shape.back();
}
Tensor<feature_t> output;
output.set_exponent(output_exponent).set_shape(output_shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
DL_LOG_NN_LATENCY_START();
fully_connected(output, input, filter, bias, activation, flatten, assign_core);
DL_LOG_NN_LATENCY_END("fully_connected");
return output;
}
} // namespace nn
} // namespace dl

2
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_global_avg_pool2d.hpp
View File

@ -53,7 +53,7 @@ namespace dl
std::vector<int> output_shape(input.shape.size(), 1);
output_shape[2] = input.shape[2];
Tensor<feature_t> output;
output.set_exponent(output_exponent).set_shape(output_shape).apply_element();
output.set_exponent(output_exponent).set_shape(output_shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
DL_LOG_NN_LATENCY_START();

2
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_global_max_pool2d.hpp
View File

@ -51,7 +51,7 @@ namespace dl
std::vector<int> output_shape(input.shape.size(), 1);
output_shape[2] = input.shape[2];
Tensor<feature_t> output;
output.set_exponent(input.exponent).set_shape(output_shape).apply_element();
output.set_exponent(input.exponent).set_shape(output_shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
DL_LOG_NN_LATENCY_START();

12
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_leakyrelu.hpp
View File

@ -52,17 +52,17 @@ namespace dl
* @return leakyrelu result or no return(result store to input)
*/
template <bool inplace = false, typename feature_t>
auto leakyrelu(Tensor<feature_t> &input,
const int activation_alpha,
const int activation_exponent,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE) -> typename std::conditional<inplace, void, Tensor<feature_t>>::type
auto leakyrelu(Tensor<feature_t> &input,
const int activation_alpha,
const int activation_exponent,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE) -> typename std::conditional<inplace, void, Tensor<feature_t>>::type
{
DL_LOG_NN_LATENCY_INIT();
Tensor<feature_t> output;
if constexpr(!inplace)
if constexpr (!inplace)
{
DL_LOG_NN_LATENCY_START();
output.set_exponent(input.exponent).set_shape(input.shape).apply_element();
output.set_exponent(input.exponent).set_shape(input.shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
DL_LOG_NN_LATENCY_START();

12
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_max2d.hpp
View File

@ -48,20 +48,20 @@ namespace dl
* @return max2d result or no return(result store to input0)
*/
template <bool inplace = false, typename feature_t>
auto max2d(Tensor<feature_t> &input0,
Tensor<feature_t> &input1,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE) -> typename std::conditional<inplace, void, Tensor<feature_t>>::type
auto max2d(Tensor<feature_t> &input0,
Tensor<feature_t> &input1,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE) -> typename std::conditional<inplace, void, Tensor<feature_t>>::type
{
assert(input0.is_same_shape(input1));
assert(input0.exponent == input1.exponent);
DL_LOG_NN_LATENCY_INIT();
Tensor<feature_t> output;
if constexpr(!inplace)
if constexpr (!inplace)
{
DL_LOG_NN_LATENCY_START();
output.set_exponent(input0.exponent).set_shape(input0.shape).apply_element();
output.set_exponent(input0.exponent).set_shape(input0.shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
DL_LOG_NN_LATENCY_START();

20
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_max_pool2d.hpp
View File

@ -57,12 +57,12 @@ namespace dl
* @param filter_shape filter shape in [filter_height, filter_width]
* @param stride_y stride in height
* @param stride_x stride in width
* @param padding_type one of PADDING_VALID or PADDING_SAME or PADDING_SAME_MXNET,
* @param padding_type one of PADDING_VALID or PADDING_SAME_END or PADDING_SAME_BEGIN,
* - PADDING_VALID: no padding
* PADDING_SAME and PADDING_SAME_MXNET results in padding with zeros evenly to the left/right or up/down of the input
* PADDING_SAME_END and PADDING_SAME_BEGIN results in padding with zeros evenly to the left/right or up/down of the input
* such that output has the same height/width dimension as the input,
* - PADDING_SAME results padding in TensorFlow style
* - PADDING_SAME_MXNET results padding in MXNET style
* - PADDING_SAME_END results padding in TensorFlow style
* - PADDING_SAME_BEGIN results padding in MXNET style
* @param assign_core not effective yet
* @return max_pool2d result
*/
@ -79,20 +79,20 @@ namespace dl
DL_LOG_NN_LATENCY_START();
std::vector<int> output_shape = get_output_shape(input.shape, filter_shape, stride_y, stride_x, padding_type);
Tensor<feature_t> output;
output.set_exponent(input.exponent).set_shape(output_shape).apply_element();
output.set_exponent(input.exponent).set_shape(output_shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
std::vector<int> padding(4, 0);
DL_LOG_NN_LATENCY_START();
if (padding_type == PADDING_SAME || padding_type == PADDING_SAME_MXNET)
if (padding_type == PADDING_SAME_END || padding_type == PADDING_SAME_BEGIN)
{
std::vector<int> padding = get_pad_size(output_shape, input.shape, filter_shape, stride_y, stride_x, padding_type);
input.set_padding_size(padding);
input.set_padding_value(padding, 0);
padding = get_pad_size(output_shape, input.shape, filter_shape, stride_y, stride_x, padding_type);
}
DL_LOG_NN_LATENCY_END("padding");
DL_LOG_NN_LATENCY_START();
max_pool2d(output, input, input.padding, filter_shape, stride_y, stride_x, assign_core);
max_pool2d(output, input, padding, filter_shape, stride_y, stride_x, assign_core);
DL_LOG_NN_LATENCY_END("max_pool2d");
return output;

12
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_min2d.hpp
View File

@ -47,20 +47,20 @@ namespace dl
* @return min2d result or no return(result store to input0)
*/
template <bool inplace = false, typename feature_t>
auto min2d(Tensor<feature_t> &input0,
Tensor<feature_t> &input1,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE) -> typename std::conditional<inplace, void, Tensor<feature_t>>::type
auto min2d(Tensor<feature_t> &input0,
Tensor<feature_t> &input1,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE) -> typename std::conditional<inplace, void, Tensor<feature_t>>::type
{
assert(input0.is_same_shape(input1));
assert(input0.exponent == input1.exponent);
DL_LOG_NN_LATENCY_INIT();
Tensor<feature_t> output;
if constexpr(!inplace)
if constexpr (!inplace)
{
DL_LOG_NN_LATENCY_START();
output.set_exponent(input0.exponent).set_shape(input0.shape).apply_element();
output.set_exponent(input0.exponent).set_shape(input0.shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
DL_LOG_NN_LATENCY_START();

38
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_mul2d.hpp
View File

@ -18,12 +18,12 @@ namespace dl
* @param assign_core not effective yet
* @param output_exponent exponent of output, only and must specify if inplace operation happens
*/
void mul2d(Tensor<int16_t> &output,
Tensor<int16_t> &input0,
Tensor<int16_t> &input1,
const Activation<int16_t> *const activation = NULL,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE,
const int output_exponent = INT_MIN);
void mul2d(Tensor<int16_t> &output,
Tensor<int16_t> &input0,
Tensor<int16_t> &input1,
const Activation<int16_t> *const activation = NULL,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE,
const int output_exponent = INT_MIN);
/**
* @brief activation(mul2d(input0, input1)).
@ -35,12 +35,12 @@ namespace dl
* @param assign_core not effective yet
* @param output_exponent exponent of output, only and must specify if inplace operation happens
*/
void mul2d(Tensor<int8_t> &output,
Tensor<int8_t> &input0,
Tensor<int8_t> &input1,
const Activation<int8_t> *const activation = NULL,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE,
const int output_exponent = INT_MIN);
void mul2d(Tensor<int8_t> &output,
Tensor<int8_t> &input0,
Tensor<int8_t> &input1,
const Activation<int8_t> *const activation = NULL,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE,
const int output_exponent = INT_MIN);
/**
* @brief activation(mul2d(input0, input1)).
@ -57,21 +57,21 @@ namespace dl
* @return mul2d result or no return(result store to input0)
*/
template <bool inplace = false, typename feature_t>
auto mul2d(const int output_exponent,
Tensor<feature_t> &input0,
Tensor<feature_t> &input1,
const Activation<feature_t> *activation,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE) -> typename std::conditional<inplace, void, Tensor<feature_t>>::type
auto mul2d(const int output_exponent,
Tensor<feature_t> &input0,
Tensor<feature_t> &input1,
const Activation<feature_t> *activation,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE) -> typename std::conditional<inplace, void, Tensor<feature_t>>::type
{
assert(input0.is_same_shape(input1));
DL_LOG_NN_LATENCY_INIT();
Tensor<feature_t> output;
if constexpr(!inplace)
if constexpr (!inplace)
{
DL_LOG_NN_LATENCY_START();
output.set_exponent(output_exponent).set_shape(input0.shape).apply_element();
output.set_exponent(output_exponent).set_shape(input0.shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
DL_LOG_NN_LATENCY_START();

14
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_prelu.hpp
View File

@ -52,17 +52,17 @@ namespace dl
* @return prelu result or no return(result store to input)
*/
template <bool inplace = false, typename feature_t>
auto prelu(Tensor<feature_t> &input,
const feature_t *activation_element,
const int activation_exponent,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE) -> typename std::conditional<inplace, void, Tensor<feature_t>>::type
auto prelu(Tensor<feature_t> &input,
const feature_t *activation_element,
const int activation_exponent,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE) -> typename std::conditional<inplace, void, Tensor<feature_t>>::type
{
DL_LOG_NN_LATENCY_INIT();
Tensor<feature_t> output;
if constexpr(!inplace)
if constexpr (!inplace)
{
DL_LOG_NN_LATENCY_START();
output.set_exponent(input.exponent).set_shape(input.shape).apply_element();
output.set_exponent(input.exponent).set_shape(input.shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
DL_LOG_NN_LATENCY_START();
@ -76,7 +76,7 @@ namespace dl
DL_LOG_NN_LATENCY_START();
prelu(input, input, activation_element, activation_exponent, assign_core);
DL_LOG_NN_LATENCY_END("prelu");
}
}
}
} // namespace nn
} // namespace dl

18
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_relu.hpp
View File

@ -15,9 +15,9 @@ namespace dl
* @param input as an input
* @param assign_core not effective yet
*/
void relu(Tensor<int16_t> &output,
Tensor<int16_t> &input,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE);
void relu(Tensor<int16_t> &output,
Tensor<int16_t> &input,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE);
/**
* @brief relu(input).
@ -26,9 +26,9 @@ namespace dl
* @param input as an input
* @param assign_core not effective yet
*/
void relu(Tensor<int8_t> &output,
Tensor<int8_t> &input,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE);
void relu(Tensor<int8_t> &output,
Tensor<int8_t> &input,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE);
/**
* @brief relu(input)
@ -46,11 +46,11 @@ namespace dl
{
DL_LOG_NN_LATENCY_INIT();
Tensor<feature_t> output;
if constexpr(!inplace)
if constexpr (!inplace)
{
DL_LOG_NN_LATENCY_START();
output.set_exponent(input.exponent).set_shape(input.shape).apply_element();
output.set_exponent(input.exponent).set_shape(input.shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
DL_LOG_NN_LATENCY_START();

38
tools/sdk/esp32s2/include/esp-face/include/nn/dl_nn_sub2d.hpp
View File

@ -18,12 +18,12 @@ namespace dl
* @param assign_core not effective yet
* @param output_exponent exponent of output, only and must specify if inplace operation happens
*/
void sub2d(Tensor<int16_t> &output,
Tensor<int16_t> &input0,
Tensor<int16_t> &input1,
const Activation<int16_t> *const activation = NULL,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE,
const int output_exponent = INT_MIN);
void sub2d(Tensor<int16_t> &output,
Tensor<int16_t> &input0,
Tensor<int16_t> &input1,
const Activation<int16_t> *const activation = NULL,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE,
const int output_exponent = INT_MIN);
/**
* @brief activation(sub2d(input0, input1)).
@ -35,12 +35,12 @@ namespace dl
* @param assign_core not effective yet
* @param output_exponent exponent of output, only and must specify if inplace operation happens
*/
void sub2d(Tensor<int8_t> &output,
Tensor<int8_t> &input0,
Tensor<int8_t> &input1,
const Activation<int8_t> *const activation = NULL,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE,
const int output_exponent = INT_MIN);
void sub2d(Tensor<int8_t> &output,
Tensor<int8_t> &input0,
Tensor<int8_t> &input1,
const Activation<int8_t> *const activation = NULL,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE,
const int output_exponent = INT_MIN);
/**
* @brief activation(sub2d(input0, input1)).
@ -57,20 +57,20 @@ namespace dl
* @return sub2d result or no return(result store to input0)
*/
template <bool inplace = false, typename feature_t>
auto sub2d(const int output_exponent,
Tensor<feature_t> &input0,
Tensor<feature_t> &input1,
const Activation<feature_t> *activation,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE) -> typename std::conditional<inplace, void, Tensor<feature_t>>::type
auto sub2d(const int output_exponent,
Tensor<feature_t> &input0,
Tensor<feature_t> &input1,
const Activation<feature_t> *activation,
const std::vector<int> &assign_core = CONFIG_DEFAULT_ASSIGN_CORE) -> typename std::conditional<inplace, void, Tensor<feature_t>>::type
{
assert(input0.is_same_shape(input1));
DL_LOG_NN_LATENCY_INIT();
Tensor<feature_t> output;
if constexpr(!inplace)
if constexpr (!inplace)
{
DL_LOG_NN_LATENCY_START();
output.set_exponent(output_exponent).set_shape(input0.shape).apply_element();
output.set_exponent(output_exponent).set_shape(input0.shape).malloc_element();
DL_LOG_NN_LATENCY_END("apply");
DL_LOG_NN_LATENCY_START();

106
tools/sdk/esp32s2/include/esp-face/include/tool/dl_tool.hpp
View File

@ -67,62 +67,49 @@ namespace dl
void copy_memory(void *dst, void *src, const int n);
/**
* @brief Apply memory without initialized. Must use free_aligned() to free the memory.
* @brief Apply memory without initialized. Can use free_aligned() to free the memory.
*
* @param number number of elements
* @param size size of element
* @param align number of aligned, e.g., 16 means 16-byte aligned
* @param align number of byte aligned, e.g., 16 means 16-byte aligned
* @return pointer of allocated memory. NULL for failed
*/
inline void *malloc_aligned(int number, int size, int align = 0)
inline void *malloc_aligned(int number, int size, int align = 4)
{
int n = number * size;
n >>= 4;
n += 2;
n <<= 4;
int total_size = n + align + sizeof(void *) + sizeof(int);
void *res = malloc(total_size);
assert((align > 0) && (((align & (align-1)) == 0)));
int total_size = number * size;
void *res = heap_caps_aligned_alloc(align, total_size, MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
#if DL_SPIRAM_SUPPORT
if (NULL == res)
res = heap_caps_malloc(total_size, MALLOC_CAP_SPIRAM);
res = heap_caps_aligned_alloc(align, total_size, MALLOC_CAP_SPIRAM);
#endif
if (NULL == res)
{
printf("Fail to malloc %d bytes from DRAM(%d bytyes) and PSRAM(%d bytes), PSRAM is %s.\n",
total_size,
heap_caps_get_free_size(MALLOC_CAP_INTERNAL),
heap_caps_get_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL),
heap_caps_get_free_size(MALLOC_CAP_SPIRAM),
DL_SPIRAM_SUPPORT ? "on" : "off");
return NULL;
}
void **data = (void **)res + 2; // 4-byte for pointer, 4-bytes for n
void **aligned;
if (align)
aligned = (void **)(((size_t)data + (align - 1)) & -align);
else
aligned = data;
aligned[-1] = res;
int *temp = (int *)aligned;
temp[-2] = n;
return (void *)aligned;
return (void *)res;
}
/**
* @brief Apply memory with zero-initialized. Must use dl_lib_free() to free the memory.
* @brief Apply memory with zero-initialized. Can use free_aligned() to free the memory.
*
* @param number number of elements
* @param size size of element
* @param align number of aligned, e.g., 16 means 16-byte aligned
* @param align number of byte aligned, e.g., 16 means 16-byte aligned
* @return pointer of allocated memory. NULL for failed
*/
inline void *calloc_aligned(int number, int size, int align = 0)
inline void *calloc_aligned(int number, int size, int align = 4)
{
void *aligned = malloc_aligned(number, size, align);
int n = *((int *)aligned - 2);
set_zero(aligned, n);
set_zero(aligned, number * size);
return (void *)aligned;
}
@ -137,7 +124,70 @@ namespace dl
if (NULL == address)
return;
free(((void **)address)[-1]);
heap_caps_free(address);
}
/**
* @brief Apply memory without initialized in preference order: internal aligned, internal, external aligned
*
* @param number number of elements
* @param size size of element
* @param align number of byte aligned, e.g., 16 means 16-byte aligned
* @return pointer of allocated memory. NULL for failed
*/
inline void *malloc_aligned_prefer(int number, int size, int align = 4)
{
assert((align > 0) && (((align & (align-1)) == 0)));
int total_size = number * size;
void *res = heap_caps_aligned_alloc(align, total_size, MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
if (NULL == res){
res = heap_caps_malloc(total_size, MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
}
#if DL_SPIRAM_SUPPORT
if (NULL == res){
res = heap_caps_aligned_alloc(align, total_size, MALLOC_CAP_SPIRAM);
}
#endif
if (NULL == res)
{
printf("Fail to malloc %d bytes from DRAM(%d bytyes) and PSRAM(%d bytes), PSRAM is %s.\n",
total_size,
heap_caps_get_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL),
heap_caps_get_free_size(MALLOC_CAP_SPIRAM),
DL_SPIRAM_SUPPORT ? "on" : "off");
return NULL;
}
return res;
}
/**
* @brief Apply memory with zero-initialized in preference order: internal aligned, internal, external aligned
*
* @param number number of elements
* @param size size of element
* @param align number of byte aligned, e.g., 16 means 16-byte aligned
* @return pointer of allocated memory. NULL for failed
*/
inline void *calloc_aligned_prefer(int number, int size, int align = 4)
{
void *res = malloc_aligned_prefer(number, size, align);
set_zero(res, number * size);
return (void *)res;
}
/**
* @brief Free the calloc_aligned_prefer() and malloc_aligned_prefer() memory
*
* @param address pointer of memory to free
*/
inline void free_aligned_prefer(void *address)
{
if (NULL == address)
return;
heap_caps_free(address);
}
/**

6
tools/sdk/esp32s2/include/esp-face/include/typedef/dl_constant.hpp
View File

@ -57,7 +57,8 @@ namespace dl
* @param exponent exponent of element
* @param shape shape of Filter,
* - 1D: reserved
* - 2D: [filter_height, filter_width, input_channel, output_channel]
* - 2D: for convolution is [filter_height, filter_width, input_channel, output_channel],
* for depthwise convolution is [filter_height, filter_width, input_channel, 1]
* @param dilation dilation of Filter
* - 1D: reserved
* - 2D: [dilation_in_height, dilation_in_width]
@ -97,6 +98,9 @@ namespace dl
{
public:
using Constant<T>::Constant;
std::vector<int> channel_exponent; /*<! exponent for per-channel >*/
Bias(const T *element, const std::vector<int> channel_exponent, const std::vector<int> shape);
};
/**

669
tools/sdk/esp32s2/include/esp-face/include/typedef/dl_variable.hpp
View File

@ -3,6 +3,7 @@
#include <stdio.h>
#include <vector>
#include <assert.h>
#include <iostream>
#include "dl_tool.hpp"
@ -17,27 +18,20 @@ namespace dl
class Tensor
{
private:
int size; /*<! size of element including padding */
bool auto_free; /*<! free element when object destroy */
int size; /*<! size of element including padding */
bool auto_free; /*<! free element when object destroy */
std::vector<int> axis_offset; /*<! element offset of each axis */
public:
T *element; /*<! point to element */
int exponent; /*<! exponent of element */
std::vector<int> shape; /*<! shape of Tensor */
/*<! 2D: shape is [height, width, channel] */
/*<! 1D: reserved */
std::vector<int> shape_with_padding; /*<! shape with padding of Tensor */
/*<! 2D: shape_with_padding is [height_with_padding, width_with_padding, channel_with_padding] */
/*<! 1D: reserved */
std::vector<int> padding; /*<! padding of Tensor */
/*<!- 2D: padding format is [top, bottom, left, right] */
/*<! - 1D: reserved */
T *element; /*<! point to element */
int exponent; /*<! exponent of element */
std::vector<int> shape; /*<! shape of Tensor */
/**
* @brief Construct a new Tensor object
*
*/
Tensor() : size(-1), auto_free(true), element(NULL), exponent(0) {}
Tensor() : auto_free(true), element(NULL), exponent(0) { this->set_shape({0}); }
/**
* @brief Construct a new Tensor object by copying from input.
@ -49,21 +43,20 @@ namespace dl
*/
Tensor(Tensor<T> &input, bool deep) : size(input.size),
auto_free(input.auto_free),
exponent(input.exponent),
shape(input.shape),
shape_with_padding(input.shape_with_padding),
padding(input.padding)
exponent(input.exponent)
{
if (deep)
this->set_shape(input.shape);
if (deep && (input.element != NULL))
{
int size_real = input.shape_with_padding.size() ? input.shape_with_padding[0] * input.shape_with_padding[1] * input.shape_with_padding[2] : 0;
T *new_element = (T *)tool::calloc_aligned(size_real, sizeof(T), 16);
int size_real = input.get_size();
T *new_element = (T *)tool::calloc_aligned_prefer(size_real, sizeof(T), 16);
tool::copy_memory(new_element, input.element, size_real * sizeof(T));
this->element = new_element;
}
else
{
this->element = input.element;
this->auto_free = false;
}
}
@ -77,6 +70,33 @@ namespace dl
this->free_element();
}
/**
* @brief
*
* @param input an input Tensor
* @param deep one of true or false
* - true: apply a new memory, copy value from input.element to this new memory
* - false: take over input.element to this->element
* @return Tensor<T>& self
*/
Tensor<T> &copy_element(Tensor<T> &input, bool deep)
{
assert(this->get_size() == input.get_size());
assert(input.element != NULL);
this->malloc_element();
if (deep)
{
tool::copy_memory(this->element, input.element, this->get_size() * sizeof(T));
}
else
{
this->element = input.element;
this->auto_free = false;
}
return *this;
}
/**
* @brief Set the auto free object.
*
@ -120,190 +140,144 @@ namespace dl
}
/**
* @brief Set the shape of Tensor. Initial this->padding = {0}. Initial this->size = -1.
* @brief Set the shape of Tensor.
*
* @param shape shape in
* - 2D: [height, width]
* @param shape the target shape
*
* @return self
*/
Tensor<T> &set_shape(const std::vector<int> shape)
Tensor<T> &set_shape(const std::vector<int> shape);
/**
* @brief print the shape of the Tensor
*
*/
void print_shape()
{
for (int i = 0; i < shape.size(); ++i)
if (this->shape.size())
{
assert(shape[i] > 0);
printf("shape = (");
for (int i = 0; i < this->shape.size() - 1; i++)
{
printf("%d, ", this->shape[i]);
}
printf("%d)\n", this->shape.back());
}
else
{
printf("shape = ()\n");
}
this->shape = shape;
this->shape_with_padding = shape;
this->size = -1;
this->padding = std::vector<int>(((this->shape.size() - 1) << 1), 0);
return *this;
}
/**
* @brief Set the padding size object.
* @brief flatten the Tensor
*
* @param padding padding size in
* - 2D: [top, bottom, left, right]
* @return self
* @return Tensor<T>& self
*/
Tensor &set_padding_size(std::vector<int> &padding)
{
assert(this->shape.size()); // call Tensor.set_shape() first
assert(this->shape.size() == 3); // TODO: || this->shape.size() == 2
if (this->shape.size() == 3)
{
std::vector<int> new_padding = this->padding;
bool dont_update = true;
if (padding[0] > this->padding[0])
{
new_padding[0] = padding[0];
dont_update = false;
}
if (padding[1] > this->padding[1])
{
new_padding[1] = padding[1];
dont_update = false;
}
if (padding[2] > this->padding[2])
{
new_padding[2] = padding[2];
dont_update = false;
}
if (padding[3] > this->padding[3])
{
new_padding[3] = padding[3];
dont_update = false;
}
if (dont_update)
{
return *this;
}
std::vector<int> new_shape_with_padding = this->shape;
new_shape_with_padding[0] += (new_padding[0] + new_padding[1]);
new_shape_with_padding[1] += (new_padding[2] + new_padding[3]);
int new_size = new_shape_with_padding[0] * new_shape_with_padding[1] * new_shape_with_padding[2];
if (this->element) // if this->element != NULL, do padding by copy memory
{
T *new_element = (T *)tool::malloc_aligned(new_size, sizeof(T), 16);
T *dst = new_element + ((new_padding[0] * new_shape_with_padding[1]) + new_padding[2]) * new_shape_with_padding[2];
T *src = this->get_element_ptr();
int offset_dst_next_y = new_shape_with_padding[1] * new_shape_with_padding[2]; // width * channel
int src_copy_length = this->shape[1] * this->shape[2]; // width * channel
int offset_src_next_y = this->shape_with_padding[1] * this->shape_with_padding[2]; // width * channel
for (int y = 0; y < this->shape[0]; y++)
{
tool::copy_memory(dst, src, src_copy_length * sizeof(T));
dst += offset_dst_next_y;
src += offset_src_next_y;
}
if (this->auto_free)
tool::free_aligned(this->element);
this->element = new_element;
this->auto_free = true;
}
this->padding = new_padding;
this->shape_with_padding = new_shape_with_padding;
this->size = new_size;
}
else if (this->shape.size() == 2)
{
printf("Tensor.set_padding_size with this->shape.size() == 2 not implement yet.\n");
}
return *this;
}
Tensor<T> &flatten();
/**
* @brief Set the padding value object.
* @brief Change a new shape to the Tensor without changing its data.
*
* @param padding padding size in
* - 2D: [top, bottom, left, right]
* @param value value to set
* @return self
* @param shape the target shape
* @return Tensor<T>& self
*/
Tensor<T> &set_padding_value(std::vector<int> &padding, T value);
Tensor<T> &reshape(std::vector<int> shape);
/**
* @brief Remove dims with length==1 from Tensor
*
* @param axis the dim to to be remove. make sure the length of the dim is equal to 1.
* if axis == INT32_MAX, all the dims with length==1 will be removed.
* @return Tensor<T>& self
*/
Tensor<T> &squeeze(int axis = INT32_MAX);
/**
* @brief Insert a new dim that will appear at the axis position in the expanded Tensor shape.
*
* @param axis the dim to be inserted
* @return Tensor<T>& self
*/
Tensor<T> &expand_dims(int axis);
/**
* @brief Insert a new dim that will appear at the axis position in the expanded Tensor shape.
*
* @param axis the dim to be inserted
* @return Tensor<T>& self
*/
Tensor<T> &expand_dims(std::vector<int> axis);
/**
* @brief Reverse or permute the axes of the Tensor
*
* @param perm the new arangement of the dims. if perm == {}, the dims arangement will be reversed.
* @return Tensor<T>& self
*/
Tensor<T> &transpose(std::vector<int> perm = {});
/**
* @brief Reverse or permute the axes of the input Tensor
*
* @param input the input Tensor
* @param perm the new arangement of the dims. if perm == {}, the dims arangement will be reversed.
* @return Tensor<T>& self
*/
Tensor<T> &transpose(Tensor<T> &input, std::vector<int> perm = {});
/**
* @brief Get the element pointer.
*
* @param padding padding size in
* - 2D: [top, bottom, left, right]
* @return pointer to memory with padding
* @return pointer to memory
*/
T *get_element_ptr(const std::vector<int> padding = {0, 0, 0, 0})
T *get_element_ptr()
{
assert(this->shape.size() == 3); // TODO: || this->shape.size() == 2
if (this->shape.size() == 3)
{
return this->element + ((this->padding[0] - padding[0]) * this->shape_with_padding[1] + (this->padding[2] - padding[2])) * this->shape_with_padding[2];
}
else if (this->shape.size() == 2)
{
printf("Tensor.get_element_ptr with this->shape.size() == 2 is not implemented.\n");
}
return NULL;
return this->element;
}
/**
* @brief Get the element value.
*
* @param index index in
* - 2D: [y, x, c]
* @param with_padding one of true or false,
* - true: make padding size in count
* - false: do not
* @return element value
* @param index the index of each dim.
* @return T element value
*/
T &get_element_value(const std::vector<int> index, const bool with_padding = false)
T get_element_value(const std::vector<int> index)
{
assert(index.size() == this->shape.size());
assert(this->shape.size() == 3); // TODO: || this->shape() == 2
int i = 0;
if (this->shape.size() == 3)
{
int y = index[0];
int x = index[1];
int c = index[2];
i = with_padding ? (y * this->shape_with_padding[1] + x) * this->shape_with_padding[2] + c : ((y + this->padding[0]) * this->shape_with_padding[1] + x + this->padding[2]) * this->shape_with_padding[2] + c;
}
else if (this->shape.size() == 2)
{
printf("Tensor.get_element_value with this->shape.size() == 2 is not implemented.\n");
}
return this->element[i];
return this->element[this->get_element_index(index)];
}
/**
* @brief Get the size of element.
* @brief Get the element value.
*
* @return size of element including padding
* @param index the index of the element.
* @return T element value
*/
T get_element_value(int index)
{
return this->element[index];
}
/**
* @brief Get the size of Tensor.
*
* @return the size of Tensor.
*/
int get_size()
{
if (this->size == -1) // didn't call Tensor.set_padding_size() before
{
this->size = 1;
for (std::vector<int>::iterator d = this->shape.begin(); d != this->shape.end(); d++)
this->size *= *d;
}
return this->size;
}
/**
* @brief Get the axis offset
*
* @return std::vector<int> the axis offset
*/
std::vector<int> get_axis_offset()
{
return this->axis_offset;
}
/**
* @brief Apply memory with zero-initialized only if this->element is NULL.
*
@ -319,7 +293,7 @@ namespace dl
if (this->element != NULL)
return false;
this->element = (T *)dl::tool::calloc_aligned(this->get_size(), sizeof(T), 16);
this->element = (T *)dl::tool::calloc_aligned_prefer(this->get_size(), sizeof(T), 16);
this->auto_free = auto_free;
return true;
@ -340,31 +314,7 @@ namespace dl
if (this->element != NULL)
return false;
this->element = (T *)tool::malloc_aligned(this->get_size(), sizeof(T), 16);
this->auto_free = auto_free;
return true;
}
/**
* @brief If this->element != NULL no memory will be applied and no value will be set in padding.
* Else apply memory without initialized and set value to padding.
*
* @param padding_value value to set in padding
* @param auto_free one of true of false
* - true: free element when object destroyed
* - false: do not
* @return
* - true: apply memory and set padding value successfully
* - false: no memory applied and no padding value set
*/
bool apply_element(const T padding_value = 0, const bool auto_free = true)
{
if (this->element != NULL)
return false;
this->element = (T *)tool::malloc_aligned(this->get_size(), sizeof(T), 16);
this->set_padding_value(this->padding, padding_value);
this->element = (T *)tool::malloc_aligned_prefer(this->get_size(), sizeof(T), 16);
this->auto_free = auto_free;
return true;
@ -379,258 +329,56 @@ namespace dl
{
if (this->auto_free && this->element)
{
tool::free_aligned(this->element);
tool::free_aligned_prefer(this->element);
this->element = NULL;
}
}
/**
* @brief Print the shape of Tensor in format "shape = ({top_padding} + {height} + {bottom_padding}, {left_padding} + {width} + {right_padding}, {channel}(channel_with_padding))\n".
* @brief print the element of the tensor
*
* @param axis_index_range the element range of each dims to be print. if axis_index_range == {}, all the element will be print.
* @param message to print
*/
void print_shape()
{
printf("shape = (%d + %d + %d, %d + %d + %d, %d(%d))\n",
this->padding[0], this->shape[0], this->padding[1],
this->padding[2], this->shape[1], this->padding[3],
this->shape[2], this->shape_with_padding[2]);
}
void print(std::vector<int> axis_index_range = {}, const char *message = "");
/**
* @brief Take numpy for example, this function print Tensor[y_start:y_end, x_start:x_end, c_start:c_end].
* @brief print all the element of the Tensor.
*
* inner box is effective value of Tensor, "0" around is padding.
*
* (with padding)
* 00000000000000000000000000000000000000000000000000
* 00000000000000000000000000000000000000000000000000
* 00000000000000000000000000000000000000000000000000
* 000000(without padding) 00000000
* 000000 00000000
* 000000 00000000
* 000000 effective value 00000000
* 000000 00000000
* 000000 00000000
* 00000000000000000000000000000000000000000000000000
* 00000000000000000000000000000000000000000000000000
* 00000000000000000000000000000000000000000000000000
*
* @param y_start start index in height
* @param y_end end index in height
* @param x_start start index in width
* @param x_end end index in width
* @param c_start start index in channel
* @param c_end end index in channel
* @param message to print
* @param axis print aligned this axis, effective only if all y_end - y_start, x_end - x_start and c_end - c_start equals to 1
* @param message to print
* @param with_padding one of true or false,
* - true: count from (with padding) in upper image
* - false: count from (without padding) in upper image
* - true: the padding element will also be ed
* - false: the padding element will not be ed
*/
void print(int y_start, int y_end,
int x_start, int x_end,
int c_start, int c_end,
const char *message, int axis = 0, const bool with_padding = false)
void print_all(const char *message = "")
{
assert(y_end > y_start);
assert(x_end > x_start);
assert(c_end > c_start);
y_start = DL_MAX(y_start, 0);
x_start = DL_MAX(x_start, 0);
c_start = DL_MAX(c_start, 0);
if (with_padding)
{
y_end = DL_MIN(y_end, this->shape_with_padding[0]);
x_end = DL_MIN(x_end, this->shape_with_padding[1]);
c_end = DL_MIN(c_end, this->shape_with_padding[2]);
}
else
{
y_end = DL_MIN(y_end, this->shape[0]);
x_end = DL_MIN(x_end, this->shape[1]);
c_end = DL_MIN(c_end, this->shape[2]);
}
printf("%s[%d:%d, %d:%d, %d:%d] | ", message, y_start, y_end, x_start, x_end, c_start, c_end);
std::cout << "\n"
<< message << " | ";
this->print_shape();
if (y_end - y_start == 1)
for (int i = 0; i < this->get_size(); i++)
{
if (x_end - x_start == 1)
{
for (int c = c_start; c < c_end; c++)
printf("%7d", c);
printf("\n");
for (int c = c_start; c < c_end; c++)
printf("%7d", this->get_element_value({y_start, x_start, c}, with_padding));
printf("\n");
return;
}
else
{
if (c_end - c_start == 1)
{
for (int x = x_start; x < x_end; x++)
printf("%7d", x);
printf("\n");
for (int x = x_start; x < x_end; x++)
printf("%7d", this->get_element_value({y_start, x, c_start}, with_padding));
printf("\n");
return;
}
}
std::cout << this->element[i] << " ";
}
else
{
if (x_end - x_start == 1)
{
if (c_end - c_start == 1)
{
for (int y = y_start; y < y_end; y++)
printf("%7d", y);
printf("\n");
for (int y = y_start; y < y_end; y++)
printf("%7d", this->get_element_value({y, x_start, c_start}, with_padding));
printf("\n");
return;
}
}
}
if (y_end - y_start == 1)
axis = 0;
if (x_end - x_start == 1)
axis = 1;
if (c_end - c_start == 1)
axis = 2;
if (axis == 0)
{
// ______c
// |
// |
// x
//
for (int y = y_start; y < y_end; y++)
{
printf("y = %d\n ", y);
for (int c = c_start; c < c_end; c++)
printf("%7d", c);
printf("\n");
for (int x = x_start; x < x_end; x++)
{
printf("%5d", x);
for (int c = c_start; c < c_end; c++)
printf("%7d", this->get_element_value({y, x, c}, with_padding));
printf("\n");
}
printf("\n");
}
}
else if (axis == 1)
{
// ______c
// |
// |
// y
//
for (int x = x_start; x < x_end; x++)
{
printf("x = %d\n ", x);
for (int c = c_start; c < c_end; c++)
printf("%7d", c);
printf("\n");
for (int y = y_start; y < y_end; y++)
{
printf("%5d", y);
for (int c = c_start; c < c_end; c++)
printf("%7d", this->get_element_value({y, x, c}, with_padding));
printf("\n");
}
printf("\n");
}
}
else
{
// ______x
// |
// |
// y
//
for (int c = c_start; c < c_end; c++)
{
printf("c = %d\n ", c);
for (int x = x_start; x < x_end; x++)
printf("%7d", x);
printf("\n");
for (int y = y_start; y < y_end; y++)
{
printf("%5d", y);
for (int x = x_start; x < x_end; x++)
printf("%7d", this->get_element_value({y, x, c}, with_padding));
printf("\n");
}
printf("\n");
}
}
std::cout << "\n";
return;
}
/**
* @brief print all the element of the Tensor.
* @brief Get the index of each dims
*
* @param message to print
* @param with_padding one of true or false,
* - true: the padding element will also be printed
* - false: the padding element will not be printed
* @param element_index the index of the element
* @return std::vector<int> the index of each dims
*/
void print_all(const char *message, const bool with_padding = false)
{
int y_end;
int x_end;
int c_end;
if (with_padding)
{
y_end = this->shape_with_padding[0];
x_end = this->shape_with_padding[1];
c_end = this->shape_with_padding[2];
}
else
{
y_end = this->shape[0];
x_end = this->shape[1];
c_end = this->shape[2];
}
std::vector<int> get_axis_index(int element_index);
printf("\n%s | ", message);
this->print_shape();
for (int y = 0; y < y_end; y++)
{
for (int x = 0; x < x_end; x++)
{
for (int c = 0; c < c_end; c++)
printf("%d ", this->get_element_value({y, x, c}, with_padding));
}
}
printf("\n");
return;
}
/**
* @brief Get the index of element
*
* @param axis_index the index of each dims
* @return int the index of element
*/
int get_element_index(const std::vector<int> axis_index);
/**
* @brief Check the element value with input ground-truth.
@ -638,35 +386,39 @@ namespace dl
* @param gt_element ground-truth value of element
* @param bias permissible error
* @param info one of true or false
* - true: print shape and result
* - true: shape and result
* - false: do not
* @param failed_number maximum number of wrong element that will be printed
*
* @return
* - true: in permissible error
* - false: not
*/
bool check_element(T *gt_element, int bias = 2, bool info = true)
bool check_element(T *gt_element, int bias = 2, bool info = true, int failed_number = 0)
{
int count = 0;
if (info)
this->print_shape();
int i = 0;
for (int y = 0; y < this->shape[0]; y++)
int size = this->get_size();
for (int i = 0; i < size; i++)
{
for (int x = 0; x < this->shape[1]; x++)
if (DL_ABS(this->element[i] - gt_element[i]) > bias)
{
for (int c = 0; c < this->shape[2]; c++)
std::vector<int> index = get_axis_index(i);
std::cout << "element[";
for (int j = 0; j < index.size() - 1; j++)
{
int a = this->get_element_value({y, x, c});
int b = gt_element[i];
int offset = DL_ABS(a - b);
if (offset > bias)
{
printf("element[%d, %d, %d]: %d v.s. %d\n", y, x, c, a, b);
return false;
}
i++;
std::cout << index[j] << ", ";
}
std::cout << index.back() << "]: ";
std::cout << +this->element[i] << " v.s. " << +gt_element[i] << "\n";
count++;
if (count > failed_number)
return false;
}
}
if (count)
return false;
if (info)
printf("PASS\n");
@ -700,35 +452,44 @@ namespace dl
Tensor<T> &operator=(const Tensor<T> &input)
{
this->size = input.size;
this->auto_free = input.auto_free;
this->exponent = input.exponent;
this->shape = input.shape;
this->padding = input.padding;
int size_real_tmp = this->shape_with_padding.size() ? this->shape_with_padding[0] * this->shape_with_padding[1] * this->shape_with_padding[2] : 0;
int size_input_real = input.shape_with_padding.size() ? input.shape_with_padding[0] * input.shape_with_padding[1] * input.shape_with_padding[2] : 0;
this->shape_with_padding = input.shape_with_padding;
if (this->element)
int size_real_tmp = this->size;
int size_input_real = input.size;
this->set_shape(input.shape);
if (input.element)
{
if (size_real_tmp != size_input_real)
if (this->element)
{
tool::free_aligned(this->element);
T *new_element = (T *)tool::calloc_aligned(size_input_real, sizeof(T), 16);
tool::copy_memory(new_element, input.element, size_input_real * sizeof(T));
this->element = new_element;
if (size_real_tmp != size_input_real)
{
tool::free_aligned_prefer(this->element);
T *new_element = (T *)tool::malloc_aligned_prefer(size_input_real, sizeof(T), 16);
tool::copy_memory(new_element, input.element, size_input_real * sizeof(T));
this->element = new_element;
}
else
{
tool::copy_memory(this->element, input.element, size_input_real * sizeof(T));
}
}
else
{
tool::copy_memory(this->element, input.element, size_input_real * sizeof(T));
T *new_element = (T *)tool::malloc_aligned_prefer(size_input_real, sizeof(T), 16);
tool::copy_memory(new_element, input.element, size_input_real * sizeof(T));
this->element = new_element;
}
return *this;
}
else
{
T *new_element = (T *)tool::calloc_aligned(size_input_real, sizeof(T), 16);
tool::copy_memory(new_element, input.element, size_input_real * sizeof(T));
this->element = new_element;
if (this->element)
{
tool::free_aligned_prefer(this->element);
this->element = NULL;
}
return *this;
}
return *this;
}
};
} // namespace dl

21
tools/sdk/esp32s2/include/esp_https_server/include/esp_https_server.h
View File

@ -10,6 +10,7 @@
#include <stdbool.h>
#include "esp_err.h"
#include "esp_http_server.h"
#include "esp_tls.h"
#ifdef __cplusplus
extern "C" {
@ -20,6 +21,22 @@ typedef enum {
HTTPD_SSL_TRANSPORT_INSECURE // SSL disabled
} httpd_ssl_transport_mode_t;
/**
* @brief Callback data struct, contains the ESP-TLS connection handle
*/
typedef struct esp_https_server_user_cb_arg {
const esp_tls_t *tls;
} esp_https_server_user_cb_arg_t;
/**
* @brief Callback function prototype
* Can be used to get connection or client information (SSL context)
* E.g. Client certificate, Socket FD, Connection state, etc.
*
* @param user_cb Callback data struct
*/
typedef void esp_https_server_user_cb(esp_https_server_user_cb_arg_t *user_cb);
/**
* HTTPS server config struct
*
@ -66,6 +83,9 @@ struct httpd_ssl_config {
/** Enable tls session tickets */
bool session_tickets;
/** User callback for esp_https_server */
esp_https_server_user_cb *user_cb;
};
typedef struct httpd_ssl_config httpd_ssl_config_t;
@ -113,6 +133,7 @@ typedef struct httpd_ssl_config httpd_ssl_config_t;
.port_secure = 443, \
.port_insecure = 80, \
.session_tickets = false, \
.user_cb = NULL, \
}
/**

1
tools/sdk/esp32s2/include/esp_hw_support/include/esp_sleep.h
View File

@ -44,6 +44,7 @@ typedef enum {
#if SOC_PM_SUPPORT_CPU_PD
ESP_PD_DOMAIN_CPU, //!< CPU core
#endif
ESP_PD_DOMAIN_RTC8M, //!< Internal 8M oscillator
ESP_PD_DOMAIN_VDDSDIO, //!< VDD_SDIO
ESP_PD_DOMAIN_MAX //!< Number of domains
} esp_sleep_pd_domain_t;

28
tools/sdk/esp32s2/include/esp_lcd/include/esp_lcd_panel_io.h
View File

@ -65,6 +65,22 @@ esp_err_t esp_lcd_panel_io_tx_color(esp_lcd_panel_io_handle_t io, int lcd_cmd, c
*/
esp_err_t esp_lcd_panel_io_del(esp_lcd_panel_io_handle_t io);
/**
* @brief Type of LCD panel IO event data
*/
typedef struct {
} esp_lcd_panel_io_event_data_t;
/**
* @brief Declare the prototype of the function that will be invoked when panel IO finishes transferring color data
*
* @param[in] panel_io LCD panel IO handle, which is created by factory API like `esp_lcd_new_panel_io_spi()`
* @param[in] edata Panel IO event data, fed by driver
* @param[in] user_ctx User data, passed from `esp_lcd_panel_io_xxx_config_t`
* @return Whether a high priority task has been waken up by this function
*/
typedef bool (*esp_lcd_panel_io_color_trans_done_cb_t)(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_io_event_data_t *edata, void *user_ctx);
/**
* @brief Panel IO configuration structure, for SPI interface
*/
@ -74,8 +90,8 @@ typedef struct {
int spi_mode; /*!< Traditional SPI mode (0~3) */
unsigned int pclk_hz; /*!< Frequency of pixel clock */
size_t trans_queue_depth; /*!< Size of internal transaction queue */
bool (*on_color_trans_done)(esp_lcd_panel_io_handle_t panel_io, void *user_data, void *event_data); /*!< Callback, invoked when color data transfer has finished */
void *user_data; /*!< User private data, passed directly to on_trans_frame_done's user_data */
esp_lcd_panel_io_color_trans_done_cb_t on_color_trans_done; /*!< Callback invoked when color data transfer has finished */
void *user_ctx; /*!< User private data, passed directly to on_color_trans_done's user_ctx */
int lcd_cmd_bits; /*!< Bit-width of LCD command */
int lcd_param_bits; /*!< Bit-width of LCD parameter */
struct {
@ -100,8 +116,8 @@ esp_err_t esp_lcd_new_panel_io_spi(esp_lcd_spi_bus_handle_t bus, const esp_lcd_p
typedef struct {
uint32_t dev_addr; /*!< I2C device address */
bool (*on_color_trans_done)(esp_lcd_panel_io_handle_t panel_io, void *user_data, void *event_data); /*!< Callback, invoked when color data transfer has finished */
void *user_data; /*!< User private data, passed directly to on_trans_frame_done's user_data */
esp_lcd_panel_io_color_trans_done_cb_t on_color_trans_done; /*!< Callback invoked when color data transfer has finished */
void *user_ctx; /*!< User private data, passed directly to on_color_trans_done's user_ctx */
size_t control_phase_bytes; /*!< I2C LCD panel will encode control information (e.g. D/C seclection) into control phase, in several bytes */
unsigned int dc_bit_offset; /*!< Offset of the D/C selection bit in control phase */
int lcd_cmd_bits; /*!< Bit-width of LCD command */
@ -168,8 +184,8 @@ typedef struct {
int cs_gpio_num; /*!< GPIO used for CS line, set to -1 will declaim exclusively use of I80 bus */
unsigned int pclk_hz; /*!< Frequency of pixel clock */
size_t trans_queue_depth; /*!< Transaction queue size, larger queue, higher throughput */
bool (*on_color_trans_done)(esp_lcd_panel_io_handle_t panel_io, void *user_data, void *event_data); /*!< Callback, invoked when color data was tranferred done */
void *user_data; /*!< User private data, passed directly to on_trans_done's user_data */
esp_lcd_panel_io_color_trans_done_cb_t on_color_trans_done; /*!< Callback invoked when color data was tranferred done */
void *user_ctx; /*!< User private data, passed directly to on_color_trans_done's user_ctx */
int lcd_cmd_bits; /*!< Bit-width of LCD command */
int lcd_param_bits; /*!< Bit-width of LCD parameter */
struct {

51
tools/sdk/esp32s2/include/esp_lcd/include/esp_lcd_panel_rgb.h
View File

@ -18,6 +18,37 @@ extern "C" {
#if SOC_LCD_RGB_SUPPORTED
/**
* @brief LCD RGB timing structure
*
* Total Width
* <--------------------------------------------------->
* Hsync width HBP Active Width HFP
* <---><--><--------------------------------------><--->
* ____ ____|_______________________________________|____|
* |___| | | |
* | | |
* __| | | |
* /|\ /|\ | | | |
* | VSYNC| | | | |
* |Width\|/ |__ | | |
* | /|\ | | | |
* | VBP | | | | |
* | \|/_____|_________|_______________________________________| |
* | /|\ | | / / / / / / / / / / / / / / / / / / / | |
* | | | |/ / / / / / / / / / / / / / / / / / / /| |
* Total | | | |/ / / / / / / / / / / / / / / / / / / /| |
* Heigh | | | |/ / / / / / / / / / / / / / / / / / / /| |
* |Active| | |/ / / / / / / / / / / / / / / / / / / /| |
* |Heigh | | |/ / / / / / Active Display Area / / / /| |
* | | | |/ / / / / / / / / / / / / / / / / / / /| |
* | | | |/ / / / / / / / / / / / / / / / / / / /| |
* | | | |/ / / / / / / / / / / / / / / / / / / /| |
* | | | |/ / / / / / / / / / / / / / / / / / / /| |
* | | | |/ / / / / / / / / / / / / / / / / / / /| |
* | \|/_____|_________|_______________________________________| |
* | /|\ | |
* | VFP | | |
* \|/ \|/_____|______________________________________________________|
*
*/
typedef struct {
unsigned int pclk_hz; /*!< Frequency of pixel clock */
@ -38,6 +69,22 @@ typedef struct {
} flags;
} esp_lcd_rgb_timing_t;
/**
* @brief Type of RGB LCD panel event data
*/
typedef struct {
} esp_lcd_rgb_panel_event_data_t;
/**
* @brief Declare the prototype of the function that will be invoked when panel IO finishes transferring color data
*
* @param[in] panel LCD panel handle, returned from `esp_lcd_new_rgb_panel`
* @param[in] edata Panel event data, fed by driver
* @param[in] user_ctx User data, passed from `esp_lcd_rgb_panel_config_t`
* @return Whether a high priority task has been waken up by this function
*/
typedef bool (*esp_lcd_rgb_panel_frame_trans_done_cb_t)(esp_lcd_panel_handle_t panel, esp_lcd_rgb_panel_event_data_t *edata, void *user_ctx);
/**
* @brief LCD RGB panel configuration structure
*/
@ -51,8 +98,8 @@ typedef struct {
int pclk_gpio_num; /*!< GPIO used for PCLK signal */
int data_gpio_nums[SOC_LCD_RGB_DATA_WIDTH]; /*!< GPIOs used for data lines */
int disp_gpio_num; /*!< GPIO used for display control signal, set to -1 if it's not used */
bool (*on_frame_trans_done)(esp_lcd_panel_handle_t panel, void *user_data); /*!< Callback, invoked when one frame buffer has transferred done */
void *user_data; /*!< User data which would be passed to on_frame_trans_done's user_data */
esp_lcd_rgb_panel_frame_trans_done_cb_t on_frame_trans_done; /*!< Callback invoked when one frame buffer has transferred done */
void *user_ctx; /*!< User data which would be passed to on_frame_trans_done's user_ctx */
struct {
unsigned int disp_active_low: 1; /*!< If this flag is enabled, a low level of display control signal can turn the screen on; vice versa */
unsigned int relax_on_idle: 1; /*!< If this flag is enabled, the host won't refresh the LCD if nothing changed in host's frame buffer (this is usefull for LCD with built-in GRAM) */

2
tools/sdk/esp32s2/include/esp_littlefs/include/esp_littlefs.h
View File

@ -14,7 +14,7 @@
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/poll.h>
#include <dirent.h>
#include <sys/dirent.h>
#include <string.h>
#include "sdkconfig.h"

67
tools/sdk/esp32s2/include/esp_wifi/include/esp_coexist.h
View File

@ -1,16 +1,8 @@
// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/*
* SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef __ESP_COEXIST_H__
#define __ESP_COEXIST_H__
@ -32,6 +24,13 @@ typedef enum {
ESP_COEX_PREFER_NUM, /*!< Prefer value numbers */
} esp_coex_prefer_t;
typedef enum {
EXTERN_COEX_WIRE_1 = 0,
EXTERN_COEX_WIRE_2,
EXTERN_COEX_WIRE_3,
EXTERN_COEX_WIRE_NUM,
} external_coex_wire_t;
/**
* @brief coex status type
*/
@ -41,6 +40,36 @@ typedef enum {
ESP_COEX_ST_TYPE_BT,
} esp_coex_status_type_t;
/**
* @brief external coex gpio pti
*/
typedef struct {
int32_t in_pin0;
int32_t in_pin1;
int32_t out_pin0;
} esp_external_coex_gpio_set_t;
/**
* @brief external coex pti level
*/
typedef enum {
EXTERN_COEX_PTI_MID = 0,
EXTERN_COEX_PTI_HIGH,
EXTERN_COEX_PTI_NUM,
} esp_coex_pti_level_t;
/**
* @brief external coex pti
*/
typedef struct {
uint32_t in_pti1;
uint32_t in_pti2;
uint32_t in_pti3;
uint32_t out_pti1;
uint32_t out_pti2;
uint32_t out_pti3;
} esp_external_coex_pti_set_t;
#define ESP_COEX_BLE_ST_MESH_CONFIG 0x08
#define ESP_COEX_BLE_ST_MESH_TRAFFIC 0x10
#define ESP_COEX_BLE_ST_MESH_STANDBY 0x20
@ -84,6 +113,18 @@ esp_err_t esp_coex_status_bit_set(esp_coex_status_type_t type, uint32_t status);
*/
esp_err_t esp_coex_status_bit_clear(esp_coex_status_type_t type, uint32_t status);
#if CONFIG_EXTERNAL_COEX_ENABLE
/**
* @brief Setup gpio pin and corresponding pti level, start external coex.
* @param wire_type : to select the whole external coex gpio number.
* @param gpio_pin : gpio pin number to choose.
* @return : ESP_OK - success, other - failed
*/
esp_err_t esp_enable_extern_coex_gpio_pin(external_coex_wire_t wire_type,
esp_external_coex_gpio_set_t gpio_pin);
esp_err_t esp_disable_extern_coex_gpio_pin();
#endif
#ifdef __cplusplus
}

42
tools/sdk/esp32s2/include/esp_wifi/include/esp_coexist_internal.h
View File

@ -1,21 +1,14 @@
// Copyright 2018-2018 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/*
* SPDX-FileCopyrightText: 2018-2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef __ESP_COEXIST_INTERNAL_H__
#define __ESP_COEXIST_INTERNAL_H__
#include <stdbool.h>
#include "esp_coexist.h"
#include "esp_coexist_adapter.h"
#ifdef __cplusplus
@ -210,6 +203,29 @@ int coex_schm_curr_phase_idx_get(void);
*/
esp_err_t esp_coex_adapter_register(coex_adapter_funcs_t *funcs);
#if CONFIG_EXTERNAL_COEX_ENABLE
/**
* @brief Set external coexistence pti level and enable it.
*
* @param level1 external coex low pti
* @param level2 external coex mid pti
* @param level3 external coex high pti
*
* @return
* - ESP_OK: succeed
*/
esp_err_t esp_coex_external_set(esp_coex_pti_level_t level1,
esp_coex_pti_level_t level2, esp_coex_pti_level_t level3);
/**
* @brief Disable external coexist
*
* @return
* - ESP_OK: succeed
*/
void esp_coex_external_stop(void);
#endif /*External Coex*/
/**
* @brief Check the MD5 values of the coexistence adapter header files in IDF and WiFi library
*

22
tools/sdk/esp32s2/include/esp_wifi/include/esp_wifi_types.h
View File

@ -1,16 +1,8 @@
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/*
* SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef __ESP_WIFI_TYPES_H__
@ -80,6 +72,7 @@ typedef enum {
WIFI_REASON_ASSOC_NOT_AUTHED = 9,
WIFI_REASON_DISASSOC_PWRCAP_BAD = 10,
WIFI_REASON_DISASSOC_SUPCHAN_BAD = 11,
WIFI_REASON_BSS_TRANSITION_DISASSOC = 12,
WIFI_REASON_IE_INVALID = 13,
WIFI_REASON_MIC_FAILURE = 14,
WIFI_REASON_4WAY_HANDSHAKE_TIMEOUT = 15,
@ -250,7 +243,8 @@ typedef struct {
wifi_pmf_config_t pmf_cfg; /**< Configuration for Protected Management Frame. Will be advertized in RSN Capabilities in RSN IE. */
uint32_t rm_enabled:1; /**< Whether Radio Measurements are enabled for the connection */
uint32_t btm_enabled:1; /**< Whether BSS Transition Management is enabled for the connection */
uint32_t reserved:30; /**< Reserved for future feature set */
uint32_t mbo_enabled:1; /**< Whether MBO is enabled for the connection */
uint32_t reserved:29; /**< Reserved for future feature set */
} wifi_sta_config_t;
/** @brief Configuration data for ESP32 AP or STA.

7
tools/sdk/esp32s2/include/freertos/include/esp_additions/freertos/FreeRTOSConfig.h
View File

@ -90,7 +90,6 @@
#define portNUM_PROCESSORS 1
#endif
#define configASSERT_2 0
#define portUSING_MPU_WRAPPERS 0
#define configUSE_MUTEX 1
@ -206,7 +205,6 @@
#define configGENERATE_RUN_TIME_STATS 1 /* Used by vTaskGetRunTimeStats() */
#endif
#define configUSE_TRACE_FACILITY_2 0
#define configBENCHMARK 0
#define configUSE_16_BIT_TICKS 0
#define configIDLE_SHOULD_YIELD 0
@ -306,4 +304,9 @@ extern void vPortCleanUpTCB ( void *pxTCB );
#define configTASK_NOTIFICATION_ARRAY_ENTRIES 1
// backward compatibility for 4.4
#define xTaskRemoveFromUnorderedEventList vTaskRemoveFromUnorderedEventList
#define configNUM_CORES portNUM_PROCESSORS
#endif /* FREERTOS_CONFIG_H */

48
tools/sdk/esp32s2/include/freertos/include/freertos/event_groups.h
View File

@ -64,7 +64,7 @@
* used to create a synchronisation point between multiple tasks (a
* 'rendezvous').
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup EventGroup EventGroup
* @endcond
*/
@ -78,7 +78,7 @@
* xEventGroupCreate() returns an EventGroupHandle_t variable that can then
* be used as a parameter to other event group functions.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup EventGroupHandle_t EventGroupHandle_t
* @endcond
* \ingroup EventGroup
@ -94,7 +94,7 @@ typedef struct EventGroupDef_t * EventGroupHandle_t;
* number of bits it holds is set by configUSE_16_BIT_TICKS (16 bits if set to 1,
* 32 bits if set to 0.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup EventBits_t EventBits_t
* @endcond
* \ingroup EventGroup
@ -102,7 +102,7 @@ typedef struct EventGroupDef_t * EventGroupHandle_t;
typedef TickType_t EventBits_t;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* event_groups.h
* @code{c}
* EventGroupHandle_t xEventGroupCreate( void );
@ -152,7 +152,7 @@ typedef TickType_t EventBits_t;
* // The event group was created.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xEventGroupCreate xEventGroupCreate
* @endcond
* \ingroup EventGroup
@ -162,7 +162,7 @@ typedef TickType_t EventBits_t;
#endif
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* event_groups.h
* @code{c}
* EventGroupHandle_t xEventGroupCreateStatic( EventGroupHandle_t * pxEventGroupBuffer );
@ -217,7 +217,7 @@ typedef TickType_t EventBits_t;
#endif
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* event_groups.h
* @code{c}
* EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
@ -307,7 +307,7 @@ typedef TickType_t EventBits_t;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xEventGroupWaitBits xEventGroupWaitBits
* @endcond
* \ingroup EventGroup
@ -319,7 +319,7 @@ EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* event_groups.h
* @code{c}
* EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear );
@ -372,7 +372,7 @@ EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xEventGroupClearBits xEventGroupClearBits
* @endcond
* \ingroup EventGroup
@ -381,7 +381,7 @@ EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup,
const EventBits_t uxBitsToClear ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* event_groups.h
* @code{c}
* BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet );
@ -432,7 +432,7 @@ EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup,
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xEventGroupClearBitsFromISR xEventGroupClearBitsFromISR
* @endcond
* \ingroup EventGroup
@ -446,7 +446,7 @@ EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup,
#endif
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* event_groups.h
* @code{c}
* EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet );
@ -516,7 +516,7 @@ EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup,
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xEventGroupSetBits xEventGroupSetBits
* @endcond
* \ingroup EventGroup
@ -525,7 +525,7 @@ EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
const EventBits_t uxBitsToSet ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* event_groups.h
* @code{c}
* BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, BaseType_t *pxHigherPriorityTaskWoken );
@ -595,7 +595,7 @@ EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xEventGroupSetBitsFromISR xEventGroupSetBitsFromISR
* @endcond
* \ingroup EventGroup
@ -610,7 +610,7 @@ EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
#endif
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* event_groups.h
* @code{c}
* EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
@ -732,7 +732,7 @@ EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
* }
*
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xEventGroupSync xEventGroupSync
* @endcond
* \ingroup EventGroup
@ -744,7 +744,7 @@ EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* event_groups.h
* @code{c}
* EventBits_t xEventGroupGetBits( EventGroupHandle_t xEventGroup );
@ -758,7 +758,7 @@ EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
*
* @return The event group bits at the time xEventGroupGetBits() was called.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xEventGroupGetBits xEventGroupGetBits
* @endcond
* \ingroup EventGroup
@ -766,7 +766,7 @@ EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
#define xEventGroupGetBits( xEventGroup ) xEventGroupClearBits( xEventGroup, 0 )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* event_groups.h
* @code{c}
* EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup );
@ -779,7 +779,7 @@ EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
*
* @return The event group bits at the time xEventGroupGetBitsFromISR() was called.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xEventGroupGetBitsFromISR xEventGroupGetBitsFromISR
* @endcond
* \ingroup EventGroup
@ -787,7 +787,7 @@ EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* event_groups.h
* @code{c}
* void xEventGroupDelete( EventGroupHandle_t xEventGroup );
@ -802,7 +802,7 @@ EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup ) PRIVILEG
*/
void vEventGroupDelete( EventGroupHandle_t xEventGroup ) PRIVILEGED_FUNCTION;
/** @cond */
/** @cond !DOC_EXCLUDE_HEADER_SECTION */
/* For internal use only. */
void vEventGroupSetBitsCallback( void * pvEventGroup,

50
tools/sdk/esp32s2/include/freertos/include/freertos/message_buffer.h
View File

@ -85,7 +85,7 @@ typedef void * MessageBufferHandle_t;
/*-----------------------------------------------------------*/
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
*
* @code{c}
@ -139,7 +139,7 @@ typedef void * MessageBufferHandle_t;
* }
*
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xMessageBufferCreate xMessageBufferCreate
* @endcond
* \ingroup MessageBufferManagement
@ -148,7 +148,7 @@ typedef void * MessageBufferHandle_t;
( MessageBufferHandle_t ) xStreamBufferGenericCreate( xBufferSizeBytes, ( size_t ) 0, pdTRUE )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
*
* @code{c}
@ -210,7 +210,7 @@ typedef void * MessageBufferHandle_t;
* }
*
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xMessageBufferCreateStatic xMessageBufferCreateStatic
* @endcond
* \ingroup MessageBufferManagement
@ -219,7 +219,7 @@ typedef void * MessageBufferHandle_t;
( MessageBufferHandle_t ) xStreamBufferGenericCreateStatic( xBufferSizeBytes, 0, pdTRUE, pucMessageBufferStorageArea, pxStaticMessageBuffer )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
*
* @code{c}
@ -314,7 +314,7 @@ typedef void * MessageBufferHandle_t;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xMessageBufferSend xMessageBufferSend
* @endcond
* \ingroup MessageBufferManagement
@ -323,7 +323,7 @@ typedef void * MessageBufferHandle_t;
xStreamBufferSend( ( StreamBufferHandle_t ) xMessageBuffer, pvTxData, xDataLengthBytes, xTicksToWait )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
*
* @code{c}
@ -423,7 +423,7 @@ typedef void * MessageBufferHandle_t;
* portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xMessageBufferSendFromISR xMessageBufferSendFromISR
* @endcond
* \ingroup MessageBufferManagement
@ -432,7 +432,7 @@ typedef void * MessageBufferHandle_t;
xStreamBufferSendFromISR( ( StreamBufferHandle_t ) xMessageBuffer, pvTxData, xDataLengthBytes, pxHigherPriorityTaskWoken )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
*
* @code{c}
@ -516,7 +516,7 @@ typedef void * MessageBufferHandle_t;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xMessageBufferReceive xMessageBufferReceive
* @endcond
* \ingroup MessageBufferManagement
@ -526,7 +526,7 @@ typedef void * MessageBufferHandle_t;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
*
* @code{c}
@ -622,7 +622,7 @@ typedef void * MessageBufferHandle_t;
* portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xMessageBufferReceiveFromISR xMessageBufferReceiveFromISR
* @endcond
* \ingroup MessageBufferManagement
@ -631,7 +631,7 @@ typedef void * MessageBufferHandle_t;
xStreamBufferReceiveFromISR( ( StreamBufferHandle_t ) xMessageBuffer, pvRxData, xBufferLengthBytes, pxHigherPriorityTaskWoken )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
*
* @code{c}
@ -654,7 +654,7 @@ typedef void * MessageBufferHandle_t;
vStreamBufferDelete( ( StreamBufferHandle_t ) xMessageBuffer )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
* @code{c}
* BaseType_t xMessageBufferIsFull( MessageBufferHandle_t xMessageBuffer ) );
@ -674,7 +674,7 @@ typedef void * MessageBufferHandle_t;
xStreamBufferIsFull( ( StreamBufferHandle_t ) xMessageBuffer )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
* @code{c}
* BaseType_t xMessageBufferIsEmpty( MessageBufferHandle_t xMessageBuffer ) );
@ -693,7 +693,7 @@ typedef void * MessageBufferHandle_t;
xStreamBufferIsEmpty( ( StreamBufferHandle_t ) xMessageBuffer )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
* @code{c}
* BaseType_t xMessageBufferReset( MessageBufferHandle_t xMessageBuffer );
@ -712,7 +712,7 @@ typedef void * MessageBufferHandle_t;
* the message queue to wait for space to become available, or to wait for a
* a message to be available, then pdFAIL is returned.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xMessageBufferReset xMessageBufferReset
* @endcond
* \ingroup MessageBufferManagement
@ -722,7 +722,7 @@ typedef void * MessageBufferHandle_t;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
* @code{c}
* size_t xMessageBufferSpaceAvailable( MessageBufferHandle_t xMessageBuffer ) );
@ -740,7 +740,7 @@ typedef void * MessageBufferHandle_t;
* architecture, so if xMessageBufferSpacesAvailable() returns 10, then the size
* of the largest message that can be written to the message buffer is 6 bytes.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xMessageBufferSpaceAvailable xMessageBufferSpaceAvailable
* @endcond
* \ingroup MessageBufferManagement
@ -751,7 +751,7 @@ typedef void * MessageBufferHandle_t;
xStreamBufferSpacesAvailable( ( StreamBufferHandle_t ) xMessageBuffer ) /* Corrects typo in original macro name. */
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
* @code{c}
* size_t xMessageBufferNextLengthBytes( MessageBufferHandle_t xMessageBuffer ) );
@ -767,7 +767,7 @@ typedef void * MessageBufferHandle_t;
* @return The length (in bytes) of the next message in the message buffer, or 0
* if the message buffer is empty.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xMessageBufferNextLengthBytes xMessageBufferNextLengthBytes
* @endcond
* \ingroup MessageBufferManagement
@ -776,7 +776,7 @@ typedef void * MessageBufferHandle_t;
xStreamBufferNextMessageLengthBytes( ( StreamBufferHandle_t ) xMessageBuffer ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
*
* @code{c}
@ -811,7 +811,7 @@ typedef void * MessageBufferHandle_t;
* @return If a task was removed from the Blocked state then pdTRUE is returned.
* Otherwise pdFALSE is returned.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xMessageBufferSendCompletedFromISR xMessageBufferSendCompletedFromISR
* @endcond
* \ingroup StreamBufferManagement
@ -820,7 +820,7 @@ typedef void * MessageBufferHandle_t;
xStreamBufferSendCompletedFromISR( ( StreamBufferHandle_t ) xMessageBuffer, pxHigherPriorityTaskWoken )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
*
* @code{c}
@ -856,7 +856,7 @@ typedef void * MessageBufferHandle_t;
* @return If a task was removed from the Blocked state then pdTRUE is returned.
* Otherwise pdFALSE is returned.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xMessageBufferReceiveCompletedFromISR xMessageBufferReceiveCompletedFromISR
* @endcond
* \ingroup StreamBufferManagement

82
tools/sdk/esp32s2/include/freertos/include/freertos/queue.h
View File

@ -62,7 +62,7 @@ typedef struct QueueDefinition * QueueSetHandle_t;
*/
typedef struct QueueDefinition * QueueSetMemberHandle_t;
/** @cond */
/** @cond !DOC_EXCLUDE_HEADER_SECTION */
/* For internal use only. */
#define queueSEND_TO_BACK ( ( BaseType_t ) 0 )
@ -80,7 +80,7 @@ typedef struct QueueDefinition * QueueSetMemberHandle_t;
/** @endcond */
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* QueueHandle_t xQueueCreate(
@ -146,7 +146,7 @@ typedef struct QueueDefinition * QueueSetMemberHandle_t;
* // ... Rest of task code.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueueCreate xQueueCreate
* @endcond
* \ingroup QueueManagement
@ -156,7 +156,7 @@ typedef struct QueueDefinition * QueueSetMemberHandle_t;
#endif
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* QueueHandle_t xQueueCreateStatic(
@ -235,7 +235,7 @@ typedef struct QueueDefinition * QueueSetMemberHandle_t;
* // ... Rest of task code.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueueCreateStatic xQueueCreateStatic
* @endcond
* \ingroup QueueManagement
@ -245,7 +245,7 @@ typedef struct QueueDefinition * QueueSetMemberHandle_t;
#endif /* configSUPPORT_STATIC_ALLOCATION */
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* BaseType_t xQueueSendToToFront(
@ -321,7 +321,7 @@ typedef struct QueueDefinition * QueueSetMemberHandle_t;
* // ... Rest of task code.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueueSend xQueueSend
* @endcond
* \ingroup QueueManagement
@ -330,7 +330,7 @@ typedef struct QueueDefinition * QueueSetMemberHandle_t;
xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_FRONT )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* BaseType_t xQueueSendToBack(
@ -408,7 +408,7 @@ typedef struct QueueDefinition * QueueSetMemberHandle_t;
* // ... Rest of task code.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueueSend xQueueSend
* @endcond
* \ingroup QueueManagement
@ -417,7 +417,7 @@ typedef struct QueueDefinition * QueueSetMemberHandle_t;
xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* BaseType_t xQueueSend(
@ -497,7 +497,7 @@ typedef struct QueueDefinition * QueueSetMemberHandle_t;
* // ... Rest of task code.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueueSend xQueueSend
* @endcond
* \ingroup QueueManagement
@ -506,7 +506,7 @@ typedef struct QueueDefinition * QueueSetMemberHandle_t;
xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* BaseType_t xQueueOverwrite(
@ -585,7 +585,7 @@ typedef struct QueueDefinition * QueueSetMemberHandle_t;
* // ...
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueueOverwrite xQueueOverwrite
* @endcond
* \ingroup QueueManagement
@ -595,7 +595,7 @@ typedef struct QueueDefinition * QueueSetMemberHandle_t;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* BaseType_t xQueueGenericSend(
@ -678,7 +678,7 @@ typedef struct QueueDefinition * QueueSetMemberHandle_t;
* // ... Rest of task code.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueueSend xQueueSend
* @endcond
* \ingroup QueueManagement
@ -689,7 +689,7 @@ BaseType_t xQueueGenericSend( QueueHandle_t xQueue,
const BaseType_t xCopyPosition ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* BaseType_t xQueuePeek(
@ -780,7 +780,7 @@ BaseType_t xQueueGenericSend( QueueHandle_t xQueue,
* // ... Rest of task code.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueuePeek xQueuePeek
* @endcond
* \ingroup QueueManagement
@ -790,7 +790,7 @@ BaseType_t xQueuePeek( QueueHandle_t xQueue,
TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* BaseType_t xQueuePeekFromISR(
@ -820,7 +820,7 @@ BaseType_t xQueuePeek( QueueHandle_t xQueue,
* @return pdTRUE if an item was successfully received from the queue,
* otherwise pdFALSE.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueuePeekFromISR xQueuePeekFromISR
* @endcond
* \ingroup QueueManagement
@ -829,7 +829,7 @@ BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue,
void * const pvBuffer ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* BaseType_t xQueueReceive(
@ -917,7 +917,7 @@ BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue,
* // ... Rest of task code.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueueReceive xQueueReceive
* @endcond
* \ingroup QueueManagement
@ -927,7 +927,7 @@ BaseType_t xQueueReceive( QueueHandle_t xQueue,
TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue );
@ -940,7 +940,7 @@ BaseType_t xQueueReceive( QueueHandle_t xQueue,
*
* @return The number of messages available in the queue.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup uxQueueMessagesWaiting uxQueueMessagesWaiting
* @endcond
* \ingroup QueueManagement
@ -948,7 +948,7 @@ BaseType_t xQueueReceive( QueueHandle_t xQueue,
UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue );
@ -963,7 +963,7 @@ UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue ) PRIVILEGED_FUNC
*
* @return The number of spaces available in the queue.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup uxQueueMessagesWaiting uxQueueMessagesWaiting
* @endcond
* \ingroup QueueManagement
@ -971,7 +971,7 @@ UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue ) PRIVILEGED_FUNC
UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* void vQueueDelete( QueueHandle_t xQueue );
@ -983,7 +983,7 @@ UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue ) PRIVILEGED_FUNC
*
* @param xQueue A handle to the queue to be deleted.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vQueueDelete vQueueDelete
* @endcond
* \ingroup QueueManagement
@ -991,7 +991,7 @@ UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue ) PRIVILEGED_FUNC
void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* BaseType_t xQueueSendToFrontFromISR(
@ -1057,7 +1057,7 @@ void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
* }
* @endcode
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueueSendFromISR xQueueSendFromISR
* @endcond
* \ingroup QueueManagement
@ -1067,7 +1067,7 @@ void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* BaseType_t xQueueSendToBackFromISR(
@ -1133,7 +1133,7 @@ void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
* }
* @endcode
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueueSendFromISR xQueueSendFromISR
* @endcond
* \ingroup QueueManagement
@ -1142,7 +1142,7 @@ void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* BaseType_t xQueueOverwriteFromISR(
@ -1225,7 +1225,7 @@ void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueueOverwriteFromISR xQueueOverwriteFromISR
* @endcond
* \ingroup QueueManagement
@ -1234,7 +1234,7 @@ void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueOVERWRITE )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* BaseType_t xQueueSendFromISR(
@ -1304,7 +1304,7 @@ void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
* }
* @endcode
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueueSendFromISR xQueueSendFromISR
* @endcond
* \ingroup QueueManagement
@ -1312,10 +1312,10 @@ void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
#define xQueueSendFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) \
xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
/** @cond */
/** @cond !DOC_EXCLUDE_HEADER_SECTION */
/**@{*/
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* BaseType_t xQueueGenericSendFromISR(
@ -1402,7 +1402,7 @@ BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue,
/** @endcond */
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* queue. h
* @code{c}
* BaseType_t xQueueReceiveFromISR(
@ -1487,7 +1487,7 @@ BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue,
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xQueueReceiveFromISR xQueueReceiveFromISR
* @endcond
* \ingroup QueueManagement
@ -1504,7 +1504,7 @@ BaseType_t xQueueIsQueueEmptyFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FU
BaseType_t xQueueIsQueueFullFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
UBaseType_t uxQueueMessagesWaitingFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
/** @cond */
/** @cond !DOC_EXCLUDE_HEADER_SECTION */
/*
* The functions defined above are for passing data to and from tasks. The
* functions below are the equivalents for passing data to and from
@ -1778,7 +1778,7 @@ QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
*/
QueueSetMemberHandle_t xQueueSelectFromSetFromISR( QueueSetHandle_t xQueueSet ) PRIVILEGED_FUNCTION;
/** @cond */
/** @cond !DOC_EXCLUDE_HEADER_SECTION */
/* Not public API functions. */
void vQueueWaitForMessageRestricted( QueueHandle_t xQueue,

56
tools/sdk/esp32s2/include/freertos/include/freertos/semphr.h
View File

@ -39,7 +39,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
#define semSEMAPHORE_QUEUE_ITEM_LENGTH ( ( uint8_t ) 0U )
#define semGIVE_BLOCK_TIME ( ( TickType_t ) 0U )
/** @cond */
/** @cond !DOC_EXCLUDE_HEADER_SECTION */
/**
* semphr. h
* @code{c}
@ -88,7 +88,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vSemaphoreCreateBinary vSemaphoreCreateBinary
* @endcond
* \ingroup Semaphores
@ -106,7 +106,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
/** @endcond */
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* semphr. h
* @code{c}
* SemaphoreHandle_t xSemaphoreCreateBinary( void );
@ -163,7 +163,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xSemaphoreCreateBinary xSemaphoreCreateBinary
* @endcond
* \ingroup Semaphores
@ -173,7 +173,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
#endif
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* semphr. h
* @code{c}
* SemaphoreHandle_t xSemaphoreCreateBinaryStatic( StaticSemaphore_t *pxSemaphoreBuffer );
@ -229,7 +229,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
* // Rest of task code goes here.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xSemaphoreCreateBinaryStatic xSemaphoreCreateBinaryStatic
* @endcond
* \ingroup Semaphores
@ -239,7 +239,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
#endif /* configSUPPORT_STATIC_ALLOCATION */
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* semphr. h
* @code{c}
* xSemaphoreTake(
@ -304,7 +304,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xSemaphoreTake xSemaphoreTake
* @endcond
* \ingroup Semaphores
@ -312,7 +312,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
#define xSemaphoreTake( xSemaphore, xBlockTime ) xQueueSemaphoreTake( ( xSemaphore ), ( xBlockTime ) )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* semphr. h
* @code{c}
* xSemaphoreTakeRecursive(
@ -403,7 +403,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xSemaphoreTakeRecursive xSemaphoreTakeRecursive
* @endcond
* \ingroup Semaphores
@ -465,7 +465,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xSemaphoreGive xSemaphoreGive
* @endcond
* \ingroup Semaphores
@ -473,7 +473,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
#define xSemaphoreGive( xSemaphore ) xQueueGenericSend( ( QueueHandle_t ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* semphr. h
* @code{c}
* xSemaphoreGiveRecursive( SemaphoreHandle_t xMutex );
@ -555,7 +555,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xSemaphoreGiveRecursive xSemaphoreGiveRecursive
* @endcond
* \ingroup Semaphores
@ -641,7 +641,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xSemaphoreGiveFromISR xSemaphoreGiveFromISR
* @endcond
* \ingroup Semaphores
@ -649,7 +649,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
#define xSemaphoreGiveFromISR( xSemaphore, pxHigherPriorityTaskWoken ) xQueueGiveFromISR( ( QueueHandle_t ) ( xSemaphore ), ( pxHigherPriorityTaskWoken ) )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* semphr. h
* @code{c}
* xSemaphoreTakeFromISR(
@ -686,7 +686,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
#define xSemaphoreTakeFromISR( xSemaphore, pxHigherPriorityTaskWoken ) xQueueReceiveFromISR( ( QueueHandle_t ) ( xSemaphore ), NULL, ( pxHigherPriorityTaskWoken ) )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* semphr. h
* @code{c}
* SemaphoreHandle_t xSemaphoreCreateMutex( void );
@ -741,7 +741,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xSemaphoreCreateMutex xSemaphoreCreateMutex
* @endcond
* \ingroup Semaphores
@ -751,7 +751,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
#endif
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* semphr. h
* @code{c}
* SemaphoreHandle_t xSemaphoreCreateMutexStatic( StaticSemaphore_t *pxMutexBuffer );
@ -808,7 +808,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
* // so there is no need to check it.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xSemaphoreCreateMutexStatic xSemaphoreCreateMutexStatic
* @endcond
* \ingroup Semaphores
@ -951,7 +951,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
#endif /* configSUPPORT_STATIC_ALLOCATION */
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* semphr. h
* @code{c}
* SemaphoreHandle_t xSemaphoreCreateCounting( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount );
@ -1027,7 +1027,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xSemaphoreCreateCounting xSemaphoreCreateCounting
* @endcond
* \ingroup Semaphores
@ -1037,7 +1037,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
#endif
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* semphr. h
* @code{c}
* SemaphoreHandle_t xSemaphoreCreateCountingStatic( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount, StaticSemaphore_t *pxSemaphoreBuffer );
@ -1118,7 +1118,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
* // is no need to check its value.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xSemaphoreCreateCountingStatic xSemaphoreCreateCountingStatic
* @endcond
* \ingroup Semaphores
@ -1128,7 +1128,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
#endif /* configSUPPORT_STATIC_ALLOCATION */
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* semphr. h
* @code{c}
* void vSemaphoreDelete( SemaphoreHandle_t xSemaphore );
@ -1140,7 +1140,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
*
* @param xSemaphore A handle to the semaphore to be deleted.
*
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* \defgroup vSemaphoreDelete vSemaphoreDelete
* @endcond
* \ingroup Semaphores
@ -1148,7 +1148,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
#define vSemaphoreDelete( xSemaphore ) vQueueDelete( ( QueueHandle_t ) ( xSemaphore ) )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* semphr.h
* @code{c}
* TaskHandle_t xSemaphoreGetMutexHolder( SemaphoreHandle_t xMutex );
@ -1167,7 +1167,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
#define xSemaphoreGetMutexHolder( xSemaphore ) xQueueGetMutexHolder( ( xSemaphore ) )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* semphr.h
* @code{c}
* TaskHandle_t xSemaphoreGetMutexHolderFromISR( SemaphoreHandle_t xMutex );
@ -1182,7 +1182,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
#define xSemaphoreGetMutexHolderFromISR( xSemaphore ) xQueueGetMutexHolderFromISR( ( xSemaphore ) )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* semphr.h
* @code{c}
* UBaseType_t uxSemaphoreGetCount( SemaphoreHandle_t xSemaphore );

62
tools/sdk/esp32s2/include/freertos/include/freertos/stream_buffer.h
View File

@ -71,7 +71,7 @@ typedef struct StreamBufferDef_t * StreamBufferHandle_t;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* message_buffer.h
*
* @code{c}
@ -134,7 +134,7 @@ typedef struct StreamBufferDef_t * StreamBufferHandle_t;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xStreamBufferCreate xStreamBufferCreate
* @endcond
* \ingroup StreamBufferManagement
@ -142,7 +142,7 @@ typedef struct StreamBufferDef_t * StreamBufferHandle_t;
#define xStreamBufferCreate( xBufferSizeBytes, xTriggerLevelBytes ) xStreamBufferGenericCreate( xBufferSizeBytes, xTriggerLevelBytes, pdFALSE )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* stream_buffer.h
*
* @code{c}
@ -220,7 +220,7 @@ typedef struct StreamBufferDef_t * StreamBufferHandle_t;
* }
*
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xStreamBufferCreateStatic xStreamBufferCreateStatic
* @endcond
* \ingroup StreamBufferManagement
@ -229,7 +229,7 @@ typedef struct StreamBufferDef_t * StreamBufferHandle_t;
xStreamBufferGenericCreateStatic( xBufferSizeBytes, xTriggerLevelBytes, pdFALSE, pucStreamBufferStorageArea, pxStaticStreamBuffer )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* stream_buffer.h
*
* @code{c}
@ -319,7 +319,7 @@ typedef struct StreamBufferDef_t * StreamBufferHandle_t;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xStreamBufferSend xStreamBufferSend
* @endcond
* \ingroup StreamBufferManagement
@ -330,7 +330,7 @@ size_t xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* stream_buffer.h
*
* @code{c}
@ -424,7 +424,7 @@ size_t xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
* taskYIELD_FROM_ISR( xHigherPriorityTaskWoken );
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xStreamBufferSendFromISR xStreamBufferSendFromISR
* @endcond
* \ingroup StreamBufferManagement
@ -435,7 +435,7 @@ size_t xStreamBufferSendFromISR( StreamBufferHandle_t xStreamBuffer,
BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* stream_buffer.h
*
* @code{c}
@ -517,7 +517,7 @@ size_t xStreamBufferSendFromISR( StreamBufferHandle_t xStreamBuffer,
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xStreamBufferReceive xStreamBufferReceive
* @endcond
* \ingroup StreamBufferManagement
@ -528,7 +528,7 @@ size_t xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* stream_buffer.h
*
* @code{c}
@ -607,7 +607,7 @@ size_t xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
* taskYIELD_FROM_ISR( xHigherPriorityTaskWoken );
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xStreamBufferReceiveFromISR xStreamBufferReceiveFromISR
* @endcond
* \ingroup StreamBufferManagement
@ -618,7 +618,7 @@ size_t xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer,
BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* stream_buffer.h
*
* @code{c}
@ -636,7 +636,7 @@ size_t xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer,
*
* @param xStreamBuffer The handle of the stream buffer to be deleted.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vStreamBufferDelete vStreamBufferDelete
* @endcond
* \ingroup StreamBufferManagement
@ -644,7 +644,7 @@ size_t xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer,
void vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* stream_buffer.h
*
* @code{c}
@ -660,7 +660,7 @@ void vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTI
* @return If the stream buffer is full then pdTRUE is returned. Otherwise
* pdFALSE is returned.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xStreamBufferIsFull xStreamBufferIsFull
* @endcond
* \ingroup StreamBufferManagement
@ -668,7 +668,7 @@ void vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTI
BaseType_t xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* stream_buffer.h
*
* @code{c}
@ -684,7 +684,7 @@ BaseType_t xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_
* @return If the stream buffer is empty then pdTRUE is returned. Otherwise
* pdFALSE is returned.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xStreamBufferIsEmpty xStreamBufferIsEmpty
* @endcond
* \ingroup StreamBufferManagement
@ -692,7 +692,7 @@ BaseType_t xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_
BaseType_t xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* stream_buffer.h
*
* @code{c}
@ -711,7 +711,7 @@ BaseType_t xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED
* a task blocked waiting to send to or read from the stream buffer then the
* stream buffer is not reset and pdFAIL is returned.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xStreamBufferReset xStreamBufferReset
* @endcond
* \ingroup StreamBufferManagement
@ -719,7 +719,7 @@ BaseType_t xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED
BaseType_t xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* stream_buffer.h
*
* @code{c}
@ -736,7 +736,7 @@ BaseType_t xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_F
* @return The number of bytes that can be written to the stream buffer before
* the stream buffer would be full.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xStreamBufferSpacesAvailable xStreamBufferSpacesAvailable
* @endcond
* \ingroup StreamBufferManagement
@ -744,7 +744,7 @@ BaseType_t xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_F
size_t xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* stream_buffer.h
*
* @code{c}
@ -761,7 +761,7 @@ size_t xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) PRIVIL
* @return The number of bytes that can be read from the stream buffer before
* the stream buffer would be empty.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xStreamBufferBytesAvailable xStreamBufferBytesAvailable
* @endcond
* \ingroup StreamBufferManagement
@ -769,7 +769,7 @@ size_t xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) PRIVIL
size_t xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* stream_buffer.h
*
* @code{c}
@ -802,7 +802,7 @@ size_t xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) PRIVILE
* then the trigger level will be updated and pdTRUE is returned. Otherwise
* pdFALSE is returned.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xStreamBufferSetTriggerLevel xStreamBufferSetTriggerLevel
* @endcond
* \ingroup StreamBufferManagement
@ -811,7 +811,7 @@ BaseType_t xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
size_t xTriggerLevel ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* stream_buffer.h
*
* @code{c}
@ -846,7 +846,7 @@ BaseType_t xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
* @return If a task was removed from the Blocked state then pdTRUE is returned.
* Otherwise pdFALSE is returned.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xStreamBufferSendCompletedFromISR xStreamBufferSendCompletedFromISR
* @endcond
* \ingroup StreamBufferManagement
@ -855,7 +855,7 @@ BaseType_t xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer
BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* stream_buffer.h
*
* @code{c}
@ -891,7 +891,7 @@ BaseType_t xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer
* @return If a task was removed from the Blocked state then pdTRUE is returned.
* Otherwise pdFALSE is returned.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xStreamBufferReceiveCompletedFromISR xStreamBufferReceiveCompletedFromISR
* @endcond
* \ingroup StreamBufferManagement
@ -899,7 +899,7 @@ BaseType_t xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer
BaseType_t xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuffer,
BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
/** @cond */
/** @cond !DOC_EXCLUDE_HEADER_SECTION */
/* Functions below here are not part of the public API. */
StreamBufferHandle_t xStreamBufferGenericCreate( size_t xBufferSizeBytes,
size_t xTriggerLevelBytes,

237
tools/sdk/esp32s2/include/freertos/include/freertos/task.h
View File

@ -76,7 +76,7 @@
* returns (via a pointer parameter) an TaskHandle_t variable that can then
* be used as a parameter to vTaskDelete to delete the task.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup TaskHandle_t TaskHandle_t
* @endcond
* \ingroup Tasks
@ -114,7 +114,7 @@ typedef enum
eSetValueWithoutOverwrite /* Set the task's notification value if the previous value has been read by the task. */
} eNotifyAction;
/** @cond */
/** @cond !DOC_EXCLUDE_HEADER_SECTION */
/**
* Used internally only.
*/
@ -189,11 +189,13 @@ typedef enum
#define tskIDLE_PRIORITY ( ( UBaseType_t ) 0U )
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @endcond
*
* Macro for forcing a context switch.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup taskYIELD taskYIELD
* @endcond
* \ingroup SchedulerControl
@ -201,7 +203,9 @@ typedef enum
#define taskYIELD() portYIELD()
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @endcond
*
* Macro to mark the start of a critical code region. Preemptive context
* switches cannot occur when in a critical region.
@ -209,7 +213,7 @@ typedef enum
* @note This may alter the stack (depending on the portable implementation)
* so must be used with care!
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup taskENTER_CRITICAL taskENTER_CRITICAL
* @endcond
* \ingroup SchedulerControl
@ -228,7 +232,9 @@ typedef enum
#endif // ESP_PLATFORM
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @endcond
*
* Macro to mark the end of a critical code region. Preemptive context
* switches cannot occur when in a critical region.
@ -236,7 +242,7 @@ typedef enum
* @note This may alter the stack (depending on the portable implementation)
* so must be used with care!
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup taskEXIT_CRITICAL taskEXIT_CRITICAL
* @endcond
* \ingroup SchedulerControl
@ -255,11 +261,13 @@ typedef enum
#define taskEXIT_CRITICAL_ISR( ) portEXIT_CRITICAL_ISR( )
#endif // ESP_PLATFORM
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @endcond
*
* Macro to disable all maskable interrupts.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup taskDISABLE_INTERRUPTS taskDISABLE_INTERRUPTS
* @endcond
* \ingroup SchedulerControl
@ -267,11 +275,13 @@ typedef enum
#define taskDISABLE_INTERRUPTS() portDISABLE_INTERRUPTS()
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @endcond
*
* Macro to enable microcontroller interrupts.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup taskENABLE_INTERRUPTS taskENABLE_INTERRUPTS
* @endcond
* \ingroup SchedulerControl
@ -422,7 +432,7 @@ typedef enum
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskCreate xTaskCreate
* @endcond
* \ingroup Tasks
@ -430,14 +440,14 @@ typedef enum
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
static inline IRAM_ATTR BaseType_t xTaskCreate(
TaskFunction_t pvTaskCode,
const char * const pcName,
const uint32_t usStackDepth,
void * const pvParameters,
UBaseType_t uxPriority,
TaskHandle_t * const pvCreatedTask)
TaskFunction_t pvTaskCode,
const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
const uint32_t usStackDepth,
void * const pvParameters,
UBaseType_t uxPriority,
TaskHandle_t * const pxCreatedTask) PRIVILEGED_FUNCTION
{
return xTaskCreatePinnedToCore( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pvCreatedTask, tskNO_AFFINITY );
return xTaskCreatePinnedToCore( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask, tskNO_AFFINITY );
}
#endif
@ -599,20 +609,20 @@ typedef enum
#if( configSUPPORT_STATIC_ALLOCATION == 1 )
static inline IRAM_ATTR TaskHandle_t xTaskCreateStatic(
TaskFunction_t pvTaskCode,
const char * const pcName,
const uint32_t ulStackDepth,
void * const pvParameters,
UBaseType_t uxPriority,
StackType_t * const pxStackBuffer,
StaticTask_t * const pxTaskBuffer)
TaskFunction_t pvTaskCode,
const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
const uint32_t ulStackDepth,
void * const pvParameters,
UBaseType_t uxPriority,
StackType_t * const puxStackBuffer,
StaticTask_t * const pxTaskBuffer) PRIVILEGED_FUNCTION
{
return xTaskCreateStaticPinnedToCore( pvTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, pxStackBuffer, pxTaskBuffer, tskNO_AFFINITY );
return xTaskCreateStaticPinnedToCore( pvTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer, tskNO_AFFINITY );
}
#endif /* configSUPPORT_STATIC_ALLOCATION */
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* BaseType_t xTaskCreateRestricted( TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask );
@ -683,18 +693,18 @@ typedef enum
* for( ;; );
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskCreateRestricted xTaskCreateRestricted
* @endcond
* \ingroup Tasks
*/
#if ( portUSING_MPU_WRAPPERS == 1 )
BaseType_t xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition,
TaskHandle_t * pxCreatedTask );
TaskHandle_t * pxCreatedTask ) PRIVILEGED_FUNCTION;
#endif
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* BaseType_t xTaskCreateRestrictedStatic( TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask );
@ -777,7 +787,7 @@ typedef enum
* for( ;; );
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskCreateRestrictedStatic xTaskCreateRestrictedStatic
* @endcond
* \ingroup Tasks
@ -788,7 +798,7 @@ typedef enum
#endif
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* void vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const pxRegions );
@ -833,7 +843,7 @@ typedef enum
* // defined or shared regions have been declared elsewhere).
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskCreateRestricted xTaskCreateRestricted
* @endcond
* \ingroup Tasks
@ -842,7 +852,7 @@ void vTaskAllocateMPURegions( TaskHandle_t xTask,
const MemoryRegion_t * const pxRegions ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* void vTaskDelete( TaskHandle_t xTask );
@ -881,7 +891,7 @@ void vTaskAllocateMPURegions( TaskHandle_t xTask,
* vTaskDelete( xHandle );
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vTaskDelete vTaskDelete
* @endcond
* \ingroup Tasks
@ -893,10 +903,12 @@ void vTaskDelete( TaskHandle_t xTaskToDelete ) PRIVILEGED_FUNCTION;
*----------------------------------------------------------*/
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* void vTaskDelay( const TickType_t xTicksToDelay );
* @endcode
* @endcond
*
* Delay a task for a given number of ticks. The actual time that the
* task remains blocked depends on the tick rate. The constant
@ -938,7 +950,7 @@ void vTaskDelete( TaskHandle_t xTaskToDelete ) PRIVILEGED_FUNCTION;
* }
* @endcode
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vTaskDelay vTaskDelay
* @endcond
* \ingroup TaskCtrl
@ -946,10 +958,12 @@ void vTaskDelete( TaskHandle_t xTaskToDelete ) PRIVILEGED_FUNCTION;
void vTaskDelay( const TickType_t xTicksToDelay ) PRIVILEGED_FUNCTION;
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* BaseType_t xTaskDelayUntil( TickType_t *pxPreviousWakeTime, const TickType_t xTimeIncrement );
* @endcode
* @endcond
*
* INCLUDE_xTaskDelayUntil must be defined as 1 for this function to be available.
* See the configuration section for more information.
@ -1007,7 +1021,7 @@ void vTaskDelay( const TickType_t xTicksToDelay ) PRIVILEGED_FUNCTION;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskDelayUntil xTaskDelayUntil
* @endcond
* \ingroup TaskCtrl
@ -1026,7 +1040,7 @@ BaseType_t xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* BaseType_t xTaskAbortDelay( TaskHandle_t xTask );
@ -1054,7 +1068,7 @@ BaseType_t xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
* @return If the task referenced by xTask was not in the Blocked state then
* pdFAIL is returned. Otherwise pdPASS is returned.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskAbortDelay xTaskAbortDelay
* @endcond
* \ingroup TaskCtrl
@ -1062,7 +1076,7 @@ BaseType_t xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
BaseType_t xTaskAbortDelay( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask );
@ -1107,7 +1121,7 @@ BaseType_t xTaskAbortDelay( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup uxTaskPriorityGet uxTaskPriorityGet
* @endcond
* \ingroup TaskCtrl
@ -1115,7 +1129,7 @@ BaseType_t xTaskAbortDelay( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask );
@ -1127,7 +1141,7 @@ UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* eTaskState eTaskGetState( TaskHandle_t xTask );
@ -1149,7 +1163,7 @@ UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask ) PRIVILEGED_FUNC
eTaskState eTaskGetState( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* void vTaskGetInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState );
@ -1203,7 +1217,7 @@ eTaskState eTaskGetState( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
* eInvalid ); // Include the task state in xTaskDetails.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vTaskGetInfo vTaskGetInfo
* @endcond
* \ingroup TaskCtrl
@ -1214,7 +1228,7 @@ void vTaskGetInfo( TaskHandle_t xTask,
eTaskState eState ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority );
@ -1254,7 +1268,7 @@ void vTaskGetInfo( TaskHandle_t xTask,
* vTaskPrioritySet( NULL, tskIDLE_PRIORITY + 1 );
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vTaskPrioritySet vTaskPrioritySet
* @endcond
* \ingroup TaskCtrl
@ -1263,7 +1277,7 @@ void vTaskPrioritySet( TaskHandle_t xTask,
UBaseType_t uxNewPriority ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* void vTaskSuspend( TaskHandle_t xTaskToSuspend );
@ -1312,7 +1326,7 @@ void vTaskPrioritySet( TaskHandle_t xTask,
* // with our handle as the parameter.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vTaskSuspend vTaskSuspend
* @endcond
* \ingroup TaskCtrl
@ -1320,7 +1334,7 @@ void vTaskPrioritySet( TaskHandle_t xTask,
void vTaskSuspend( TaskHandle_t xTaskToSuspend ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* void vTaskResume( TaskHandle_t xTaskToResume );
@ -1367,7 +1381,7 @@ void vTaskSuspend( TaskHandle_t xTaskToSuspend ) PRIVILEGED_FUNCTION;
* // time in accordance with its priority within the system.
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vTaskResume vTaskResume
* @endcond
* \ingroup TaskCtrl
@ -1375,7 +1389,7 @@ void vTaskSuspend( TaskHandle_t xTaskToSuspend ) PRIVILEGED_FUNCTION;
void vTaskResume( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* void xTaskResumeFromISR( TaskHandle_t xTaskToResume );
@ -1402,7 +1416,7 @@ void vTaskResume( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
* otherwise pdFALSE. This is used by the ISR to determine if a context switch
* may be required following the ISR.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vTaskResumeFromISR vTaskResumeFromISR
* @endcond
* \ingroup TaskCtrl
@ -1412,9 +1426,9 @@ BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
/*-----------------------------------------------------------
* SCHEDULER CONTROL
*----------------------------------------------------------*/
/** @cond */
/** @cond !DOC_EXCLUDE_HEADER_SECTION */
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* void vTaskStartScheduler( void );
@ -1445,7 +1459,7 @@ BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
* }
* @endcode
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vTaskStartScheduler vTaskStartScheduler
* @endcond
* \ingroup SchedulerControl
@ -1453,7 +1467,7 @@ BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
void vTaskStartScheduler( void ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* void vTaskEndScheduler( void );
@ -1507,7 +1521,7 @@ void vTaskStartScheduler( void ) PRIVILEGED_FUNCTION;
* }
* @endcode
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vTaskEndScheduler vTaskEndScheduler
* @endcond
* \ingroup SchedulerControl
@ -1517,7 +1531,7 @@ void vTaskEndScheduler( void ) PRIVILEGED_FUNCTION;
/** @endcond */
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* void vTaskSuspendAll( void );
@ -1566,7 +1580,7 @@ void vTaskEndScheduler( void ) PRIVILEGED_FUNCTION;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vTaskSuspendAll vTaskSuspendAll
* @endcond
* \ingroup SchedulerControl
@ -1574,7 +1588,7 @@ void vTaskEndScheduler( void ) PRIVILEGED_FUNCTION;
void vTaskSuspendAll( void ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* BaseType_t xTaskResumeAll( void );
@ -1626,7 +1640,7 @@ void vTaskSuspendAll( void ) PRIVILEGED_FUNCTION;
* }
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskResumeAll xTaskResumeAll
* @endcond
* \ingroup SchedulerControl
@ -1638,7 +1652,7 @@ BaseType_t xTaskResumeAll( void ) PRIVILEGED_FUNCTION;
*----------------------------------------------------------*/
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* TickType_t xTaskGetTickCount( void );
@ -1647,7 +1661,7 @@ BaseType_t xTaskResumeAll( void ) PRIVILEGED_FUNCTION;
*
* @return The count of ticks since vTaskStartScheduler was called.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskGetTickCount xTaskGetTickCount
* @endcond
* \ingroup TaskUtils
@ -1655,7 +1669,7 @@ BaseType_t xTaskResumeAll( void ) PRIVILEGED_FUNCTION;
TickType_t xTaskGetTickCount( void ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* TickType_t xTaskGetTickCountFromISR( void );
@ -1669,7 +1683,7 @@ TickType_t xTaskGetTickCount( void ) PRIVILEGED_FUNCTION;
* microcontroller being used or interrupt nesting is either not supported or
* not being used.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskGetTickCountFromISR xTaskGetTickCountFromISR
* @endcond
* \ingroup TaskUtils
@ -1677,7 +1691,7 @@ TickType_t xTaskGetTickCount( void ) PRIVILEGED_FUNCTION;
TickType_t xTaskGetTickCountFromISR( void ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* uint16_t uxTaskGetNumberOfTasks( void );
@ -1689,7 +1703,7 @@ TickType_t xTaskGetTickCountFromISR( void ) PRIVILEGED_FUNCTION;
* has been deleted but not yet freed by the idle task will also be
* included in the count.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup uxTaskGetNumberOfTasks uxTaskGetNumberOfTasks
* @endcond
* \ingroup TaskUtils
@ -1697,7 +1711,7 @@ TickType_t xTaskGetTickCountFromISR( void ) PRIVILEGED_FUNCTION;
UBaseType_t uxTaskGetNumberOfTasks( void ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* char *pcTaskGetName( TaskHandle_t xTaskToQuery );
@ -1708,7 +1722,7 @@ UBaseType_t uxTaskGetNumberOfTasks( void ) PRIVILEGED_FUNCTION;
* xTaskToQuery. A task can query its own name by either passing in its own
* handle, or by setting xTaskToQuery to NULL.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup pcTaskGetName pcTaskGetName
* @endcond
* \ingroup TaskUtils
@ -1716,7 +1730,7 @@ UBaseType_t uxTaskGetNumberOfTasks( void ) PRIVILEGED_FUNCTION;
char * pcTaskGetName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* TaskHandle_t xTaskGetHandle( const char *pcNameToQuery );
@ -1730,7 +1744,7 @@ char * pcTaskGetName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION; /*lin
* NULL is returned if no matching name is found. INCLUDE_xTaskGetHandle
* must be set to 1 in FreeRTOSConfig.h for pcTaskGetHandle() to be available.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup pcTaskGetHandle pcTaskGetHandle
* @endcond
* \ingroup TaskUtils
@ -1813,7 +1827,7 @@ uint8_t* pxTaskGetStackStart( TaskHandle_t xTask) PRIVILEGED_FUNCTION;
#ifdef configUSE_APPLICATION_TASK_TAG
#if configUSE_APPLICATION_TASK_TAG == 1
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task.h
* @code{c}
* void vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxHookFunction );
@ -1830,7 +1844,7 @@ uint8_t* pxTaskGetStackStart( TaskHandle_t xTask) PRIVILEGED_FUNCTION;
TaskHookFunction_t pxHookFunction ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task.h
* @code{c}
* void xTaskGetApplicationTaskTag( TaskHandle_t xTask );
@ -1844,7 +1858,7 @@ uint8_t* pxTaskGetStackStart( TaskHandle_t xTask) PRIVILEGED_FUNCTION;
TaskHookFunction_t xTaskGetApplicationTaskTag( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task.h
* @code{c}
* void xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask );
@ -1932,7 +1946,7 @@ uint8_t* pxTaskGetStackStart( TaskHandle_t xTask) PRIVILEGED_FUNCTION;
#if ( configCHECK_FOR_STACK_OVERFLOW > 0 )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task.h
* @code{c}
* void vApplicationStackOverflowHook( TaskHandle_t xTask char *pcTaskName);
@ -1952,7 +1966,7 @@ uint8_t* pxTaskGetStackStart( TaskHandle_t xTask) PRIVILEGED_FUNCTION;
#if ( configUSE_TICK_HOOK > 0 )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task.h
* @code{c}
* void vApplicationTickHook( void );
@ -1967,7 +1981,7 @@ uint8_t* pxTaskGetStackStart( TaskHandle_t xTask) PRIVILEGED_FUNCTION;
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task.h
* @code{c}
* void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer, StackType_t ** ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize )
@ -1986,7 +2000,7 @@ uint8_t* pxTaskGetStackStart( TaskHandle_t xTask) PRIVILEGED_FUNCTION;
#endif
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task.h
* @code{c}
* BaseType_t xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter );
@ -2155,7 +2169,7 @@ UBaseType_t uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray,
* enough to contain the generated report. Approximately 40 bytes per
* task should be sufficient.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vTaskList vTaskList
* @endcond
* \ingroup TaskUtils
@ -2210,7 +2224,7 @@ void vTaskList( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unq
* contain the generated report. Approximately 40 bytes per task should
* be sufficient.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup vTaskGetRunTimeStats vTaskGetRunTimeStats
* @endcond
* \ingroup TaskUtils
@ -2218,7 +2232,7 @@ void vTaskList( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unq
void vTaskGetRunTimeStats( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code
* uint32_t ulTaskGetIdleRunTimeCounter( void );
@ -2246,7 +2260,7 @@ void vTaskGetRunTimeStats( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lin
* frequency configured using the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and
* portGET_RUN_TIME_COUNTER_VALUE() macros.
*
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup ulTaskGetIdleRunTimeCounter ulTaskGetIdleRunTimeCounter
* @endcond
* \ingroup TaskUtils
@ -2254,11 +2268,13 @@ void vTaskGetRunTimeStats( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lin
uint32_t ulTaskGetIdleRunTimeCounter( void ) PRIVILEGED_FUNCTION;
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* BaseType_t xTaskNotifyIndexed( TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction );
* BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction );
* @endcode
* @endcond
*
* See https://www.FreeRTOS.org/RTOS-task-notifications.html for details.
*
@ -2359,7 +2375,9 @@ uint32_t ulTaskGetIdleRunTimeCounter( void ) PRIVILEGED_FUNCTION;
* @return Dependent on the value of eAction. See the description of the
* eAction parameter.
*
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskNotifyIndexed xTaskNotifyIndexed
* @endcond
* \ingroup TaskNotifications
*/
BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify,
@ -2373,11 +2391,13 @@ BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify,
xTaskGenericNotify( ( xTaskToNotify ), ( uxIndexToNotify ), ( ulValue ), ( eAction ), NULL )
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* BaseType_t xTaskNotifyAndQueryIndexed( TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotifyValue );
* BaseType_t xTaskNotifyAndQuery( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotifyValue );
* @endcode
* @endcond
*
* See https://www.FreeRTOS.org/RTOS-task-notifications.html for details.
*
@ -2393,7 +2413,9 @@ BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify,
* than when the function returns) in the additional pulPreviousNotifyValue
* parameter.
*
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskNotifyAndQueryIndexed xTaskNotifyAndQueryIndexed
* @endcond
* \ingroup TaskNotifications
*/
#define xTaskNotifyAndQuery( xTaskToNotify, ulValue, eAction, pulPreviousNotifyValue ) \
@ -2402,11 +2424,13 @@ BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify,
xTaskGenericNotify( ( xTaskToNotify ), ( uxIndexToNotify ), ( ulValue ), ( eAction ), ( pulPreviousNotifyValue ) )
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* BaseType_t xTaskNotifyIndexedFromISR( TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken );
* BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken );
* @endcode
* @endcond
*
* See https://www.FreeRTOS.org/RTOS-task-notifications.html for details.
*
@ -2511,7 +2535,9 @@ BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify,
* @return Dependent on the value of eAction. See the description of the
* eAction parameter.
*
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskNotifyIndexedFromISR xTaskNotifyIndexedFromISR
* @endcond
* \ingroup TaskNotifications
*/
BaseType_t xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify,
@ -2526,11 +2552,13 @@ BaseType_t xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify,
xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( uxIndexToNotify ), ( ulValue ), ( eAction ), NULL, ( pxHigherPriorityTaskWoken ) )
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* BaseType_t xTaskNotifyAndQueryIndexedFromISR( TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue, BaseType_t *pxHigherPriorityTaskWoken );
* BaseType_t xTaskNotifyAndQueryFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue, BaseType_t *pxHigherPriorityTaskWoken );
* @endcode
* @endcond
*
* See https://www.FreeRTOS.org/RTOS-task-notifications.html for details.
*
@ -2546,7 +2574,9 @@ BaseType_t xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify,
* function is called rather than at the time the function returns) in the
* additional pulPreviousNotifyValue parameter.
*
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskNotifyAndQueryIndexedFromISR xTaskNotifyAndQueryIndexedFromISR
* @endcond
* \ingroup TaskNotifications
*/
#define xTaskNotifyAndQueryIndexedFromISR( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue, pxHigherPriorityTaskWoken ) \
@ -2555,12 +2585,14 @@ BaseType_t xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify,
xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( ulValue ), ( eAction ), ( pulPreviousNotificationValue ), ( pxHigherPriorityTaskWoken ) )
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* BaseType_t xTaskNotifyWaitIndexed( UBaseType_t uxIndexToWaitOn, uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );
*
* BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );
* @endcode
* @endcond
*
* Waits for a direct to task notification to be pending at a given index within
* an array of direct to task notifications.
@ -2655,7 +2687,9 @@ BaseType_t xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify,
* already pending when xTaskNotifyWait was called) then pdPASS is
* returned. Otherwise pdFAIL is returned.
*
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskNotifyWaitIndexed xTaskNotifyWaitIndexed
* @endcond
* \ingroup TaskNotifications
*/
BaseType_t xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
@ -2669,11 +2703,13 @@ BaseType_t xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
xTaskGenericNotifyWait( ( uxIndexToWaitOn ), ( ulBitsToClearOnEntry ), ( ulBitsToClearOnExit ), ( pulNotificationValue ), ( xTicksToWait ) )
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* BaseType_t xTaskNotifyGiveIndexed( TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify );
* BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify );
* @endcode
* @endcond
*
* Sends a direct to task notification to a particular index in the target
* task's notification array in a manner similar to giving a counting semaphore.
@ -2737,7 +2773,9 @@ BaseType_t xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
* @return xTaskNotifyGive() is a macro that calls xTaskNotify() with the
* eAction parameter set to eIncrement - so pdPASS is always returned.
*
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskNotifyGiveIndexed xTaskNotifyGiveIndexed
* @endcond
* \ingroup TaskNotifications
*/
#define xTaskNotifyGive( xTaskToNotify ) \
@ -2746,11 +2784,13 @@ BaseType_t xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
xTaskGenericNotify( ( xTaskToNotify ), ( uxIndexToNotify ), ( 0 ), eIncrement, NULL )
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* void vTaskNotifyGiveIndexedFromISR( TaskHandle_t xTaskHandle, UBaseType_t uxIndexToNotify, BaseType_t *pxHigherPriorityTaskWoken );
* void vTaskNotifyGiveFromISR( TaskHandle_t xTaskHandle, BaseType_t *pxHigherPriorityTaskWoken );
* @endcode
* @endcond
*
* A version of xTaskNotifyGiveIndexed() that can be called from an interrupt
* service routine (ISR).
@ -2821,7 +2861,9 @@ BaseType_t xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
* requested from an ISR is dependent on the port - see the documentation page
* for the port in use.
*
* @cond !DOC_SINGLE_GROUP
* \defgroup vTaskNotifyGiveIndexedFromISR vTaskNotifyGiveIndexedFromISR
* @endcond
* \ingroup TaskNotifications
*/
void vTaskGenericNotifyGiveFromISR( TaskHandle_t xTaskToNotify,
@ -2833,12 +2875,14 @@ void vTaskGenericNotifyGiveFromISR( TaskHandle_t xTaskToNotify,
vTaskGenericNotifyGiveFromISR( ( xTaskToNotify ), ( uxIndexToNotify ), ( pxHigherPriorityTaskWoken ) );
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* uint32_t ulTaskNotifyTakeIndexed( UBaseType_t uxIndexToWaitOn, BaseType_t xClearCountOnExit, TickType_t xTicksToWait );
*
* uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait );
* @endcode
* @endcond
*
* Waits for a direct to task notification on a particular index in the calling
* task's notification array in a manner similar to taking a counting semaphore.
@ -2927,7 +2971,9 @@ void vTaskGenericNotifyGiveFromISR( TaskHandle_t xTaskToNotify,
* @return The task's notification count before it is either cleared to zero or
* decremented (see the xClearCountOnExit parameter).
*
* @cond !DOC_SINGLE_GROUP
* \defgroup ulTaskNotifyTakeIndexed ulTaskNotifyTakeIndexed
* @endcond
* \ingroup TaskNotifications
*/
uint32_t ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn,
@ -2939,12 +2985,14 @@ uint32_t ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn,
ulTaskGenericNotifyTake( ( uxIndexToWaitOn ), ( xClearCountOnExit ), ( xTicksToWait ) )
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* BaseType_t xTaskNotifyStateClearIndexed( TaskHandle_t xTask, UBaseType_t uxIndexToCLear );
*
* BaseType_t xTaskNotifyStateClear( TaskHandle_t xTask );
* @endcode
* @endcond
*
* See https://www.FreeRTOS.org/RTOS-task-notifications.html for details.
*
@ -2992,7 +3040,9 @@ uint32_t ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn,
* @return pdTRUE if the task's notification state was set to
* eNotWaitingNotification, otherwise pdFALSE.
*
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskNotifyStateClearIndexed xTaskNotifyStateClearIndexed
* @endcond
* \ingroup TaskNotifications
*/
BaseType_t xTaskGenericNotifyStateClear( TaskHandle_t xTask,
@ -3003,12 +3053,14 @@ BaseType_t xTaskGenericNotifyStateClear( TaskHandle_t xTask,
xTaskGenericNotifyStateClear( ( xTask ), ( uxIndexToClear ) )
/**
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task. h
* @code{c}
* uint32_t ulTaskNotifyValueClearIndexed( TaskHandle_t xTask, UBaseType_t uxIndexToClear, uint32_t ulBitsToClear );
*
* uint32_t ulTaskNotifyValueClear( TaskHandle_t xTask, uint32_t ulBitsToClear );
* @endcode
* @endcond
*
* See https://www.FreeRTOS.org/RTOS-task-notifications.html for details.
*
@ -3057,7 +3109,9 @@ BaseType_t xTaskGenericNotifyStateClear( TaskHandle_t xTask,
*
* @return The value of the target task's notification value before the bits
* specified by ulBitsToClear were cleared.
* @cond !DOC_SINGLE_GROUP
* \defgroup ulTaskNotifyValueClear ulTaskNotifyValueClear
* @endcond
* \ingroup TaskNotifications
*/
uint32_t ulTaskGenericNotifyValueClear( TaskHandle_t xTask,
@ -3069,7 +3123,7 @@ uint32_t ulTaskGenericNotifyValueClear( TaskHandle_t xTask,
ulTaskGenericNotifyValueClear( ( xTask ), ( uxIndexToClear ), ( ulBitsToClear ) )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task.h
* @code{c}
* void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut );
@ -3082,14 +3136,14 @@ uint32_t ulTaskGenericNotifyValueClear( TaskHandle_t xTask,
* is to be captured. The captured time includes the tick count and the number
* of times the tick count has overflowed since the system first booted.
* \defgroup vTaskSetTimeOutState vTaskSetTimeOutState
* @cond
* @cond !DOC_SINGLE_GROUP
* \ingroup TaskCtrl
* @endcond
*/
void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task.h
* @code
* BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait );
@ -3170,7 +3224,7 @@ void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;
* return uxReceived;
* }
* @endcode
* @cond
* @cond !DOC_SINGLE_GROUP
* \defgroup xTaskCheckForTimeOut xTaskCheckForTimeOut
* @endcond
* \ingroup TaskCtrl
@ -3179,7 +3233,7 @@ BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
TickType_t * const pxTicksToWait ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task.h
* @code{c}
* BaseType_t xTaskCatchUpTicks( TickType_t xTicksToCatchUp );
@ -3204,7 +3258,7 @@ BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
* blocked state and a context switch being performed. Otherwise pdFALSE.
*
* \defgroup xTaskCatchUpTicks xTaskCatchUpTicks
* @cond
* @cond !DOC_SINGLE_GROUP
* \ingroup TaskCtrl
* @endcond
*/
@ -3214,7 +3268,7 @@ BaseType_t xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) PRIVILEGED_FUNCTION;
/*-----------------------------------------------------------
* SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES
*----------------------------------------------------------*/
/** @cond */
/** @cond !DOC_EXCLUDE_HEADER_SECTION */
/*
* Return the handle of the task running on a certain CPU. Because of
* the nature of SMP processing, there is no guarantee that this
@ -3335,8 +3389,8 @@ void vTaskPlaceOnEventListRestricted( List_t * const pxEventList,
* making the call, otherwise pdFALSE.
*/
BaseType_t xTaskRemoveFromEventList( const List_t * const pxEventList ) PRIVILEGED_FUNCTION;
BaseType_t xTaskRemoveFromUnorderedEventList( ListItem_t * pxEventListItem,
const TickType_t xItemValue ) PRIVILEGED_FUNCTION;
void vTaskRemoveFromUnorderedEventList( ListItem_t * pxEventListItem,
const TickType_t xItemValue ) PRIVILEGED_FUNCTION;
/*
* THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS ONLY
@ -3399,11 +3453,6 @@ void vTaskPriorityDisinheritAfterTimeout( TaskHandle_t const pxMutexHolder,
*/
UBaseType_t uxTaskGetTaskNumber( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
/*
* Get the current core affinity of a task
*/
BaseType_t xTaskGetAffinity( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
/*
* Set the uxTaskNumber of the task referenced by the xTask parameter to
* uxHandle.

6
tools/sdk/esp32s2/include/freertos/include/freertos/timers.h
View File

@ -450,7 +450,7 @@ void vTimerSetTimerID( TimerHandle_t xTimer,
BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* TaskHandle_t xTimerGetTimerDaemonTaskHandle( void );
* @endcond
*
@ -1315,7 +1315,7 @@ TickType_t xTimerGetPeriod( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
*/
TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
/** @cond */
/** @cond !DOC_EXCLUDE_HEADER_SECTION */
/*
* Functions beyond this part are not part of the public API and are intended
@ -1339,7 +1339,7 @@ BaseType_t xTimerGenericCommand( TimerHandle_t xTimer,
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
/**
* @cond
* @cond !DOC_EXCLUDE_HEADER_SECTION
* task.h
* @code{c}
* void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer, StackType_t ** ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize )

941
tools/sdk/esp32s2/include/freertos/port/xtensa/include/freertos/portmacro.h
View File

File diff suppressed because it is too large Load Diff

78
tools/sdk/esp32s2/include/freertos/port/xtensa/include/freertos/portmacro_priv.h
View File

@ -1,78 +0,0 @@
/*
FreeRTOS V8.2.0 - Copyright (C) 2015 Real Time Engineers Ltd.
All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
***************************************************************************
* *
* FreeRTOS provides completely free yet professionally developed, *
* robust, strictly quality controlled, supported, and cross *
* platform software that has become a de facto standard. *
* *
* Help yourself get started quickly and support the FreeRTOS *
* project by purchasing a FreeRTOS tutorial book, reference *
* manual, or both from: http://www.FreeRTOS.org/Documentation *
* *
* Thank you! *
* *
***************************************************************************
This file is part of the FreeRTOS distribution.
FreeRTOS is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License (version 2) as published by the
Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
>>! NOTE: The modification to the GPL is included to allow you to !<<
>>! distribute a combined work that includes FreeRTOS without being !<<
>>! obliged to provide the source code for proprietary components !<<
>>! outside of the FreeRTOS kernel. !<<
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. Full license text is available from the following
link: http://www.freertos.org/a00114.html
1 tab == 4 spaces!
***************************************************************************
* *
* Having a problem? Start by reading the FAQ "My application does *
* not run, what could be wrong?" *
* *
* http://www.FreeRTOS.org/FAQHelp.html *
* *
***************************************************************************
http://www.FreeRTOS.org - Documentation, books, training, latest versions,
license and Real Time Engineers Ltd. contact details.
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, a DOS
compatible FAT file system, and our tiny thread aware UDP/IP stack.
http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High
Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS
licenses offer ticketed support, indemnification and middleware.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and
mission critical applications that require provable dependability.
1 tab == 4 spaces!
*/
/* This header holds the macros for porting which should only be used inside FreeRTOS */
#pragma once
#include "soc/soc_memory_layout.h"
//xTaskCreateStatic uses these functions to check incoming memory.
#define portVALID_TCB_MEM(ptr) (esp_ptr_internal(ptr) && esp_ptr_byte_accessible(ptr))
#ifdef CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY
#define portVALID_STACK_MEM(ptr) esp_ptr_byte_accessible(ptr)
#else
#define portVALID_STACK_MEM(ptr) (esp_ptr_internal(ptr) && esp_ptr_byte_accessible(ptr))
#endif

21
tools/sdk/esp32s2/include/hal/esp32s2/include/hal/rmt_ll.h
View File

@ -1,16 +1,9 @@
// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/*
* SPDX-FileCopyrightText: 2019-2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <stdbool.h>
@ -22,6 +15,8 @@
extern "C" {
#endif
#define RMT_LL_MAX_LOOP_COUNT (1023)/*!< Max loop count that hardware is supported */
#define RMT_LL_HW_BASE (&RMT)
#define RMT_LL_MEM_BASE (&RMTMEM)

26
tools/sdk/esp32s2/include/hal/include/hal/i2s_hal.h
View File

@ -1,16 +1,8 @@
// Copyright 2020 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/*
* SPDX-FileCopyrightText: 2020-2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
/*******************************************************************************
* NOTICE
@ -176,28 +168,28 @@ void i2s_hal_enable_slave_fd_mode(i2s_hal_context_t *hal);
*
* @param hal Context of the HAL layer
*/
#define i2s_hal_start_tx(hal) i2s_ll_tx_start((hal)->dev)
void i2s_hal_start_tx(i2s_hal_context_t *hal);
/**
* @brief Start I2S rx
*
* @param hal Context of the HAL layer
*/
#define i2s_hal_start_rx(hal) i2s_ll_rx_start((hal)->dev)
void i2s_hal_start_rx(i2s_hal_context_t *hal);
/**
* @brief Stop I2S tx
*
* @param hal Context of the HAL layer
*/
#define i2s_hal_stop_tx(hal) i2s_ll_tx_stop((hal)->dev)
void i2s_hal_stop_tx(i2s_hal_context_t *hal);
/**
* @brief Stop I2S rx
*
* @param hal Context of the HAL layer
*/
#define i2s_hal_stop_rx(hal) i2s_ll_rx_stop((hal)->dev)
void i2s_hal_stop_rx(i2s_hal_context_t *hal);
/**
* @brief Set the received data length to trigger `in_suc_eof` interrupt.

24
tools/sdk/esp32s2/include/hal/include/hal/lcd_hal.h
View File

@ -1,22 +1,8 @@
// Copyright 2021 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/*******************************************************************************
* NOTICE
* The HAL is not public api, don't use in application code.
* See readme.md in soc/README.md
******************************************************************************/
/*
* SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once

33
tools/sdk/esp32s2/include/hal/include/hal/lcd_types.h
View File

@ -1,16 +1,8 @@
// Copyright 2021 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/*
* SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
@ -21,15 +13,12 @@ extern "C" {
/**
* @brief LCD clock source
* @note User should select the clock source based on the real requirement:
* ╔═════════════════════╦══════════════════════════╦════════════════════════════╗
* ║ LCD clock source ║ Features ║ Power Management ║
* ╠═════════════════════╬══════════════════════════╬════════════════════════════╣
* ║ LCD_CLK_SRC_PLL160M ║ High resolution, fixed ║ ESP_PM_APB_FREQ_MAX lock ║
* ╠═════════════════════╬══════════════════════════╬════════════════════════════╣
* ║ LCD_CLK_SRC_APLL ║ Configurable resolution ║ ESP_PM_NO_LIGHT_SLEEP lock ║
* ╠═════════════════════╬══════════════════════════╬════════════════════════════╣
* ║ LCD_CLK_SRC_XTAL ║ Medium resolution, fixed ║ No PM lock ║
* ╚═════════════════════╩══════════════════════════╩════════════════════════════╝
*
* | LCD clock source | Features | Power Management |
* |---------------------|--------------------------|----------------------------|
* | LCD_CLK_SRC_PLL160M | High resolution, fixed | ESP_PM_APB_FREQ_MAX lock |
* | LCD_CLK_SRC_APLL | Configurable resolution | ESP_PM_NO_LIGHT_SLEEP lock |
* | LCD_CLK_SRC_XTAL | Medium resolution, fixed | No PM lock |
*/
typedef enum {
LCD_CLK_SRC_PLL160M, /*!< Select PLL160M as the source clock */

29
tools/sdk/esp32s2/include/hal/include/hal/touch_sensor_types.h
View File

@ -1,16 +1,8 @@
// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/*
* SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
@ -155,12 +147,23 @@ typedef enum {
TOUCH_PAD_INTR_MASK_INACTIVE = BIT(2), /*!<Inactive for one of the enabled channels. */
TOUCH_PAD_INTR_MASK_SCAN_DONE = BIT(3), /*!<Measurement done for all the enabled channels. */
TOUCH_PAD_INTR_MASK_TIMEOUT = BIT(4), /*!<Timeout for one of the enabled channels. */
#if SOC_TOUCH_PROXIMITY_MEAS_DONE_SUPPORTED
TOUCH_PAD_INTR_MASK_PROXI_MEAS_DONE = BIT(5), /*!<For proximity sensor, when the number of measurements reaches the set count of measurements, an interrupt will be generated. */
TOUCH_PAD_INTR_MASK_MAX
#define TOUCH_PAD_INTR_MASK_ALL (TOUCH_PAD_INTR_MASK_TIMEOUT \
| TOUCH_PAD_INTR_MASK_SCAN_DONE \
| TOUCH_PAD_INTR_MASK_INACTIVE \
| TOUCH_PAD_INTR_MASK_ACTIVE \
| TOUCH_PAD_INTR_MASK_DONE \
| TOUCH_PAD_INTR_MASK_PROXI_MEAS_DONE) /*!<All touch interrupt type enable. */
#else
TOUCH_PAD_INTR_MASK_MAX
#define TOUCH_PAD_INTR_MASK_ALL (TOUCH_PAD_INTR_MASK_TIMEOUT \
| TOUCH_PAD_INTR_MASK_SCAN_DONE \
| TOUCH_PAD_INTR_MASK_INACTIVE \
| TOUCH_PAD_INTR_MASK_ACTIVE \
| TOUCH_PAD_INTR_MASK_DONE) /*!<All touch interrupt type enable. */
#endif
} touch_pad_intr_mask_t;
FLAG_ATTR(touch_pad_intr_mask_t)

6
tools/sdk/esp32s2/include/lwip/port/esp32/include/lwipopts.h
View File

@ -266,6 +266,12 @@
#endif
/**
* CONFIG_LWIP_DHCP_OPTIONS_LEN: The total length of outgoing DHCP option msg. If you have many options
* and options value is too long, you can configure the length according to your requirements
*/
#define DHCP_OPTIONS_LEN CONFIG_LWIP_DHCP_OPTIONS_LEN
/*
------------------------------------
---------- AUTOIP options ----------

24
tools/sdk/esp32s2/include/mdns/include/mdns.h
View File

@ -187,7 +187,10 @@ esp_err_t mdns_instance_name_set(const char * instance_name);
* @note The value length of txt items will be automatically decided by strlen
*
* @param instance_name instance name to set. If NULL,
* global instance name or hostname will be used
* global instance name or hostname will be used.
* Note that MDNS_MULTIPLE_INSTANCE config option
* needs to be enabled for adding multiple instances
* with the same instance type.
* @param service_type service type (_http, _ftp, etc)
* @param proto service protocol (_tcp, _udp)
* @param port service port
@ -209,6 +212,9 @@ esp_err_t mdns_service_add(const char * instance_name, const char * service_type
*
* @param instance_name instance name to set. If NULL,
* global instance name or hostname will be used
* Note that MDNS_MULTIPLE_INSTANCE config option
* needs to be enabled for adding multiple instances
* with the same instance type.
* @param service_type service type (_http, _ftp, etc)
* @param proto service protocol (_tcp, _udp)
* @param hostname service hostname. If NULL, local hostname will be used.
@ -238,6 +244,22 @@ esp_err_t mdns_service_add_for_host(const char * instance_name, const char * ser
*/
bool mdns_service_exists(const char * service_type, const char * proto, const char * hostname);
/**
* @brief Check whether a service has been added.
*
* @param instance instance name
* @param service_type service type (_http, _ftp, etc)
* @param proto service protocol (_tcp, _udp)
* @param hostname service hostname. If NULL, checks for the local hostname.
*
* @return
* - true Correspondding service has been added.
* - false Service not found.
*/
bool mdns_service_exists_with_instance(const char *instance, const char *service_type, const char *proto,
const char *hostname);
/**
* @brief Remove service from mDNS server
*

2
tools/sdk/esp32s2/include/mqtt/esp-mqtt/include/mqtt_client.h
View File

@ -206,6 +206,7 @@ typedef struct {
int network_timeout_ms; /*!< Abort network operation if it is not completed after this value, in milliseconds (defaults to 10s) */
bool disable_keepalive; /*!< Set disable_keepalive=true to turn off keep-alive mechanism, false by default (keepalive is active by default). Note: setting the config value `keepalive` to `0` doesn't disable keepalive feature, but uses a default keepalive period */
const char *path; /*!< Path in the URI*/
int message_retransmit_timeout; /*!< timeout for retansmit of failded packet */
} esp_mqtt_client_config_t;
/**
@ -375,6 +376,7 @@ esp_err_t esp_mqtt_client_destroy(esp_mqtt_client_handle_t client);
* @param config mqtt configuration structure
*
* @return ESP_ERR_NO_MEM if failed to allocate
* ESP_ERR_INVALID_ARG if conflicts on transport configuration.
* ESP_OK on success
*/
esp_err_t esp_mqtt_set_config(esp_mqtt_client_handle_t client, const esp_mqtt_client_config_t *config);

21
tools/sdk/esp32s2/include/openssl/include/openssl/ssl.h
View File

@ -1,16 +1,13 @@
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
/*
* SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Allow for this warning suppression only in IDF_CI_BUILD
#if !defined(ESP_OPENSSL_SUPPRESS_LEGACY_WARNING) || !defined(IDF_CI_BUILD)
#warning "OpenSSL component will be removed from ESP-IDF in v5.0, please use esp_tls instead"
#endif
#ifndef _SSL_H_
#define _SSL_H_

22
tools/sdk/esp32s2/include/protocomm/include/transports/protocomm_ble.h
View File

@ -1,16 +1,8 @@
// Copyright 2018 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/*
* SPDX-FileCopyrightText: 2018-2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
@ -86,6 +78,10 @@ typedef struct protocomm_ble_config {
* Pointer to the Name-UUID lookup table
*/
protocomm_ble_name_uuid_t *nu_lookup;
/* BLE bonding */
unsigned ble_bonding:1;
} protocomm_ble_config_t;
/**

Some files were not shown because too many files have changed in this diff Show More