espressif/arduino-esp32
1
0
Fork 1
mirror of https://github.com/0xFEEDC0DE64/arduino-esp32.git synced 2025-06-30 04:21:00 +02:00
Code Issues Packages Projects Releases Wiki Activity

IDF release/v4.4 f23dcd3555 (#5996)

Browse Source 
esp-dsp: master 6b25cbb
esp-face: master d141502
esp-rainmaker: f1b82c7
esp32-camera: master 61400bc
esp_littlefs: master 3c29afc
This commit is contained in:
Me No Dev
2021-12-14 16:38:06 +02:00
committed by GitHub
parent 7bb30b3cf8
commit 6d400df952
348 changed files with 2934 additions and 932 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tools/sdk/esp32c3/include/app_trace/include/esp_app_trace_util.h
View File

@ -68,7 +68,7 @@ typedef struct {
*/
static inline void esp_apptrace_lock_init(esp_apptrace_lock_t *lock)
{
vPortCPUInitializeMutex(&lock->mux);
portMUX_INITIALIZE(&lock->mux);
lock->int_state = 0;
}

3
tools/sdk/esp32c3/include/config/sdkconfig.h
View File

@ -261,6 +261,7 @@
#define CONFIG_ESP_WIFI_FTM_ENABLE 1
#define CONFIG_ESP_WIFI_FTM_INITIATOR_SUPPORT 1
#define CONFIG_ESP_WIFI_FTM_RESPONDER_SUPPORT 1
#define CONFIG_ESP_WIFI_SOFTAP_SUPPORT 1
#define CONFIG_ESP_COREDUMP_ENABLE_TO_NONE 1
#define CONFIG_FATFS_CODEPAGE_437 1
#define CONFIG_FATFS_CODEPAGE 437
@ -629,5 +630,5 @@
#define CONFIG_TIMER_TASK_STACK_SIZE CONFIG_ESP_TIMER_TASK_STACK_SIZE
#define CONFIG_TOOLPREFIX CONFIG_SDK_TOOLPREFIX
#define CONFIG_UDP_RECVMBOX_SIZE CONFIG_LWIP_UDP_RECVMBOX_SIZE
#define CONFIG_ARDUINO_IDF_COMMIT "ddc44956bf"
#define CONFIG_ARDUINO_IDF_COMMIT "f23dcd3555"
#define CONFIG_ARDUINO_IDF_BRANCH "release/v4.4"

52
tools/sdk/esp32c3/include/esp-face/include/image/dl_image.hpp
View File

@ -48,6 +48,15 @@ namespace dl
output[2] = input & 0xF8; // red
}
/**
* @brief Convert RGB565 image to RGB888 image.
*
* @param image ptr of RGB565 image
* @param image_shape shape of the input image
* @return Tensor<uint8_t>* output RGB88 image
*/
Tensor<uint8_t> *convert_image_rgb565_to_rgb888(uint16_t *image, std::vector<int> &image_shape);
/**
* @brief Convert RGB565 pixel to Gray.
*
@ -435,5 +444,48 @@ namespace dl
*/
Tensor<uint8_t> *rgb2hsv(Tensor<uint8_t> &image, bool bgr = false, bool fast = true);
/**
* @brief resize an image to the target shape.
*
* @param image the input image Tensor
* @param target_shape the target shape of the resized image.
* @param resize_type one of IMAGE_RESIZE_BILINEAR or IMAGE_RESIZE_MEAN or IMAGE_RESIZE_NEAREST
* @return Tensor<uint8_t>* the pointer of the resized image Tensor
*/
Tensor<uint8_t> *resize_image(Tensor<uint8_t> &image, std::vector<int> target_shape, resize_type_t resize_type);
/**
* @brief resize an image to the target shape.
*
* @param image the input image Tensor
* @param resized_image the resized image Tensor
* @param resize_type one of IMAGE_RESIZE_BILINEAR or IMAGE_RESIZE_MEAN or IMAGE_RESIZE_NEAREST
*/
void resize_image(Tensor<uint8_t> &image, Tensor<uint8_t> &resized_image, resize_type_t resize_type);
/**
* @brief resize an image to the target shape with nearest method.
*
* @tparam T
* @param image the pointer of the input image
* @param input_shape the input shape of the image
* @param target_shape the target shape of the resized image
* @return T* the pointer of the resized image
*/
template <typename T>
T *resize_image_nearest(T *image, std::vector<int> input_shape, std::vector<int> target_shape);
/**
* @brief resize an image to the target shape with nearest method.
*
* @tparam T
* @param image the pointer of the input image
* @param input_shape the input shape of the image
* @param resized_image the pointer of the resized image
* @param target_shape the target shape of the resized image
*/
template <typename T>
void resize_image_nearest(T *image, std::vector<int> input_shape, T *resized_image, std::vector<int> target_shape);
} // namespace image
} // namespace dl

4
tools/sdk/esp32c3/include/esp-face/include/layer/dl_layer_avg_pool2d.hpp
View File

@ -57,10 +57,10 @@ namespace dl
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),
padding_type(padding_type),
padding(padding),
output_shape({})
{
this->output = new Tensor<feature_t>;

5
tools/sdk/esp32c3/include/esp-face/include/layer/dl_layer_expand_dims.hpp
View File

@ -36,7 +36,10 @@ namespace dl
* 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({})
output_shape({}),
axis(axis),
output(NULL),
inplace(inplace)
{
}

2
tools/sdk/esp32c3/include/esp-face/include/layer/dl_layer_flatten.hpp
View File

@ -32,7 +32,7 @@ namespace dl
* @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({})
Flatten(const char *name = "Flatten", bool inplace = false) : Layer(name), output(NULL), inplace(inplace), output_shape({})
{}
/**

4
tools/sdk/esp32c3/include/esp-face/include/layer/dl_layer_max_pool2d.hpp
View File

@ -53,10 +53,10 @@ namespace dl
const int stride_x = 1,
const char *name = "MaxPool2D") : Layer(name),
filter_shape(filter_shape),
padding_type(padding_type),
padding(padding),
stride_y(stride_y),
stride_x(stride_x),
padding_type(padding_type),
padding(padding),
output_shape({})
{
this->output = new Tensor<feature_t>;

6
tools/sdk/esp32c3/include/esp-face/include/layer/dl_layer_relu.hpp
View File

@ -18,7 +18,7 @@ namespace dl
* - int8_t: stands for operation in int8_t quantize
*/
template <typename feature_t>
class ReLU : public Layer
class Relu : public Layer
{
private:
Tensor<feature_t> *output; /*<! output ptr of relu >*/
@ -33,7 +33,7 @@ namespace dl
* @param inplace true: the output will store to input0
* false: the output will store to a separate memory
*/
ReLU(const char *name = "ReLU", bool inplace = false) : Layer(name),
Relu(const char *name = "Relu", bool inplace = false) : Layer(name),
output(NULL), inplace(inplace), output_shape({})
{
}
@ -42,7 +42,7 @@ namespace dl
* @brief Destroy the ReLU object
*
*/
~ReLU()
~Relu()
{
if ((!this->inplace) && (this->output != NULL))
{

4
tools/sdk/esp32c3/include/esp-face/include/layer/dl_layer_reshape.hpp
View File

@ -35,7 +35,9 @@ namespace dl
* 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)
output(NULL),
inplace(inplace),
output_shape(shape)
{
}

6
tools/sdk/esp32c3/include/esp-face/include/layer/dl_layer_squeeze.hpp
View File

@ -35,7 +35,11 @@ namespace dl
* @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({})
Squeeze(int axis = INT32_MAX, const char *name = "Squeeze", bool inplace = false) : Layer(name),
output(NULL),
inplace(inplace),
axis(axis),
output_shape({})
{
}

6
tools/sdk/esp32c3/include/esp-face/include/layer/dl_layer_sub2d.hpp
View File

@ -38,7 +38,11 @@ namespace dl
* false: the output will store to a separate memory
*/
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({})
output_exponent(output_exponent),
activation(activation),
output(NULL),
inplace(inplace),
output_shape({})
{
}

6
tools/sdk/esp32c3/include/esp-face/include/layer/dl_layer_transpose.hpp
View File

@ -33,7 +33,11 @@ namespace dl
* @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({})
Transpose(std::vector<int> perm = {}, const char *name = "Transpose", bool inplace = false) : Layer(name),
output(NULL),
inplace(inplace),
perm(perm),
output_shape({})
{
}

334
tools/sdk/esp32c3/include/esp-face/include/model_zoo/color_detector.hpp
View File

@ -7,46 +7,143 @@ 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;
} color_detect_result_t;
typedef struct
{
std::vector<int> start_col;
std::vector<int> end_col;
std::vector<int> row;
std::vector<int> index;
std::vector<int> area;
} color_segment_result_t;
typedef struct
{
std::vector<uint8_t> color_thresh; /*!< threshold of colors, The threshold of each color is composed of 6 numbers >*/
int area_thresh; /*!< the area threshold of each color,
the area that is smaller than the threshold is filtered >*/
std::string name; /*!<name of the color>*/
} color_info_t;
class ColorDetector
{
private:
std::vector<std::vector<components_stats_t>> results; /*!< detection results >*/
std::vector<std::vector<color_detect_result_t>> detection_results; /*!< detection results >*/
std::vector<color_segment_result_t> segmentation_results; /*!< segmentation results >*/
std::vector<color_info_t> registered_colors; /*!< the infomation of registered colors >*/
std::vector<uint8_t> color_thresh_offset; /*!< HSV offset of the registered colors>*/
std::vector<int> detection_shape; /*!< the inference shape of images, the input image will be resized to this shape.
if the shape == {}, the input image will not be resized >*/
bool bgr; /*!< true: the input image is in BGR format
false: the input image is in RGB format >*/
int id_nums; /*!< the number of registered colors in history>*/
float h_ratio;
float w_ratio;
void color_detection_forward(dl::Tensor<uint8_t> &bin, int area_thresh);
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 image the input image in RGB888 format.
* @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 get the color threshold of rectangular region in the image
*
* @param input the ptr of RGB565 image.
* @param input_shape shape of 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(uint16_t *input, std::vector<int> input_shape, std::vector<int> box);
/**
* @brief register a new color to the color detector
*
* @param image the input image in RGB888 format.
* @param box the coordinates of the rectanglar region : [left_up_x, left_up_y, right_down_x, right_down_y]
* @param area_thresh the area threshold of the color
* @param id the index of the color
* @return int the number of the registered colors. if the id is not valid, return -1.
*/
int register_color(dl::Tensor<uint8_t> &image, std::vector<int> box, int area_thresh = 256, std::string color_name = "", int id = -1);
/**
* @brief register a new color to the color detector
*
* @param input the ptr of RGB565 image.
* @param input_shape shape of the input image.
* @param box the coordinates of the rectanglar region : [left_up_x, left_up_y, right_down_x, right_down_y]
* @param area_thresh the area threshold of the color
* @param id the index of the color
* @return int the number of the registered colors. if the id is not valid, return -1.
*/
int register_color(uint16_t *input, std::vector<int> input_shape, std::vector<int> box, int area_thresh = 256, std::string color_name = "", int id = -1);
/**
* @brief register a new color to the color detector
*
* @param color_thresh the color threshold
* @param area_thresh the area threshold of the color
* @param id the index of the color
* @return int the number of the registered colors. if the id is not valid, return -1.
*/
int register_color(std::vector<uint8_t> color_thresh, int area_thresh = 256, std::string color_name = "", int id = -1);
/**
* @brief delete a registered color
*
* @param id the index of the color
* @return int the number of the registered colors. if the id is not valid, return -1.
*/
int delete_color(int id = -1);
/**
* @brief delete a registered color
*
* @param color_name name of the registered_color
* @return int the number of the registered colors. if the id is not valid, return -1.
*/
int delete_color(std::string color_name);
/**
* @brief delete all the registered colors
*
*/
void clear_color();
/**
* @brief detect the colors based on the color thresholds
*
* @param image the input image.
* @return std::vector<std::vector<components_stats_t>>& detection result.
* @return std::vector<std::vector<color_detect_result_t>>& detection result.
*/
std::vector<std::vector<components_stats_t>> &detect(dl::Tensor<uint8_t> &image);
std::vector<std::vector<color_detect_result_t>> &detect(dl::Tensor<uint8_t> &image, std::vector<int> color_ids = {});
/**
* @brief
*
* @param input
* @param input_shape
* @return std::vector<std::vector<color_detect_result_t>>&
*/
std::vector<std::vector<color_detect_result_t>> &detect(uint16_t *input_shape, std::vector<int> shape, std::vector<int> color_ids = {});
/**
* @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 color_thresh_offset HSV offset of the registered colors>
* @param detection_shape the inference shape of images, the input image will be resized to this shape
* @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)
ColorDetector(std::vector<uint8_t> color_thresh_offset = {}, std::vector<int> detection_shape = {}, bool bgr = true) : color_thresh_offset(color_thresh_offset),
detection_shape(detection_shape), bgr(bgr), id_nums(0)
{
}
@ -57,12 +154,213 @@ public:
~ColorDetector() {}
/**
* @brief Get the results object
* @brief Get the detection results object
*
* @return std::vector<std::vector<components_stats_t>>& the detection result.
* @return std::vector<std::vector<color_detect_result_t>>& the detection result.
*/
std::vector<std::vector<components_stats_t>> &get_results()
std::vector<std::vector<color_detect_result_t>> &get_detection_results()
{
return this->results;
return this->detection_results;
}
/**
* @brief Get the segmentation results object
*
* @return std::vector<color_segment_result_t>& the segmentation result.
*/
std::vector<color_segment_result_t> &get_segmentation_results()
{
return this->segmentation_results;
}
/**
* @brief Get the registered colors object
*
* @return std::vector<color_info_t> the information of resgistered colors
*/
std::vector<color_info_t> get_registered_colors()
{
return this->registered_colors;
}
/**
* @brief Set the color thresh offset object
*
* @param color_thresh_offset the offset of color thresh for registered colors
* @return ColorDetector&
*/
ColorDetector &set_color_thresh_offset(std::vector<uint8_t> color_thresh_offset)
{
assert(color_thresh_offset.size() == 3);
this->color_thresh_offset = color_thresh_offset;
return *this;
}
/**
* @brief Get the color thresh offset object
*
* @return std::vector<uint8_t> color_thresh_offset
*/
std::vector<uint8_t> get_color_thresh_offset()
{
return this->color_thresh_offset;
}
/**
* @brief Set the area thresh object
*
* @param area_thresh the area thresh for each registered colors
* @return ColorDetector&
*/
ColorDetector &set_area_thresh(std::vector<int> area_thresh)
{
assert((area_thresh.size() == this->registered_colors.size()) || (area_thresh.size() == 1));
if (area_thresh.size() == 1)
{
for (int i = 0; i < this->registered_colors.size(); ++i)
{
this->registered_colors[i].area_thresh = area_thresh[0];
}
}
else
{
for (int i = 0; i < this->registered_colors.size(); ++i)
{
this->registered_colors[i].area_thresh = area_thresh[i];
}
}
return *this;
}
/**
* @brief Set the area thresh object
*
* @param area_thresh the area thresh for each registered colors
* @param id index of the registered color
* @return ColorDetector&
*/
ColorDetector &set_area_thresh(int area_thresh, int id)
{
assert((id >= 0) && (id < this->registered_colors.size()));
this->registered_colors[id].area_thresh = area_thresh;
return *this;
}
/**
* @brief Set the bgr object
*
* @param bgr
* @return ColorDetector&
*/
ColorDetector &set_bgr(bool bgr)
{
this->bgr = bgr;
return *this;
}
/**
* @brief Get the bgr object
*
* @return bool bgr flag
*/
bool get_bgr()
{
return this->bgr;
}
/**
* @brief Get the detection shape object
*
* @return std::vector<int>
*/
std::vector<int> get_detection_shape()
{
return this->detection_shape;
}
/**
* @brief Set the detection shape object
*
* @param detection_shape the inference shape of images, the input image will be resized to this shape
* @return ColorDetector&
*/
ColorDetector &set_detection_shape(std::vector<int> detection_shape)
{
assert(detection_shape.size() == 3);
this->detection_shape = detection_shape;
return *this;
}
/**
* @brief Get the registered colors num
*
* @return int the registered colors num
*/
int get_registered_colors_num()
{
return this->registered_colors.size();
}
/**
* @brief print the detection detection results
*
* @param tag
*/
void print_detection_results(const char *tag = "RGB")
{
printf("\n%s | color detection result:\n", tag);
for (int i = 0; i < this->detection_results.size(); ++i)
{
printf("color %d: detected box :%d\n", i, this->detection_results[i].size());
for (int j = 0; j < this->detection_results[i].size(); ++j)
{
printf("center: (%d, %d)\n", this->detection_results[i][j].center[0], this->detection_results[i][j].center[1]);
printf("box: (%d, %d), (%d, %d)\n", this->detection_results[i][j].box[0], this->detection_results[i][j].box[1], this->detection_results[i][j].box[2], this->detection_results[i][j].box[3]);
printf("area: %d\n", this->detection_results[i][j].area);
}
printf("\n");
}
}
/**
* @brief print the segmentation results
*
* @param tag
*/
void print_segmentation_results(const char *tag = "RGB")
{
printf("\n%s | color segmentation result:\n", tag);
for (int i = 0; i < this->segmentation_results.size(); ++i)
{
printf("color %d: detected box :%d\n", i, this->detection_results[i].size());
for (int j = 0; j < this->segmentation_results[i].index.size(); ++j)
{
printf("box_index: %d, start col: %d, end col: %d, row: %d, area: %d\n",
this->segmentation_results[i].index[j], this->segmentation_results[i].start_col[j], this->segmentation_results[i].end_col[j],
this->segmentation_results[i].row[j], this->segmentation_results[i].area[j]);
}
printf("\n");
}
}
/**
* @brief draw the color segmentation result on the input image
*
* @param image the input RGB image
* @param draw_colors RGB values for each detected colors
* @param draw_backgound draw the background if it is true
* @param background_color RGB values for the background color
*/
void draw_segmentation_results(dl::Tensor<uint8_t> &image, std::vector<std::vector<uint8_t>> draw_colors, bool draw_backgound = true, std::vector<uint8_t> background_color = {0, 0, 0});
/**
* @brief draw the color segmentation result on the input image
*
* @param image the pointer of the input RGB565 image
* @param image_shape the shape of the input image
* @param draw_colors RGB565 values for each detected colors
* @param draw_backgound draw the background if it is true
* @param background_color RGB565 values for the background color
*/
void draw_segmentation_results(uint16_t *image, std::vector<int> image_shape, std::vector<uint16_t> draw_colors, bool draw_backgound = true, uint16_t background_color = 0x0000);
};

8
tools/sdk/esp32c3/include/esp-face/include/model_zoo/face_recognition_tool.hpp
View File

@ -10,6 +10,7 @@
#include <algorithm>
#include <math.h>
#include <string>
#include "esp_partition.h"
/**
* @brief struct of face similarity
@ -45,6 +46,13 @@ public:
*/
FaceID(int id, dl::Tensor<feature_t> &id_emb, std::string name = "");
/**
* @brief Construct a new Face ID which is same as input face_id
*
* @param face_id input face_id
*/
FaceID(FaceID<feature_t> &face_id);
/**
* @brief Destroy the Face ID object
*

108
tools/sdk/esp32c3/include/esp-face/include/model_zoo/face_recognizer.hpp
View File

@ -148,7 +148,7 @@ class FaceRecognizer
* @param name name of the face id.
* @return int the face id index of the enrolled embedding.
*/
int enroll_id(uint16_t *image_input, std::vector<int> shape, std::vector<int> &landmarks, std::string name="");
int enroll_id(uint16_t *image_input, std::vector<int> shape, std::vector<int> &landmarks, std::string name="", bool update_flash = false);
/**
* @brief enroll face id
@ -158,9 +158,11 @@ class FaceRecognizer
* @param aligned_face the Tensor to store the intermeidate aligned face.
* @param landmarks face landmarks coordinates
* @param name name of the face id.
* @param update_flash true: the enrolled ids will be stored to flash
* false: the enrolled ids will not be stored to flash
* @return int the face id index of the enrolled embedding.
*/
int enroll_id(uint16_t *image_input, std::vector<int> shape, Tensor<uint8_t> &aligned_face, std::vector<int> &landmarks, std::string name="");
int enroll_id(uint16_t *image_input, std::vector<int> shape, Tensor<uint8_t> &aligned_face, std::vector<int> &landmarks, std::string name="", bool update_flash = false);
/**
* @brief enroll face id
@ -168,9 +170,11 @@ class FaceRecognizer
* @param image_input the Tensor of input image with format bgr888.
* @param landmarks face landmarks coordinates
* @param name name of the face id.
* @param update_flash true: the enrolled ids will be stored to flash
* false: the enrolled ids will not be stored to flash
* @return int the face id index of the enrolled embedding.
*/
int enroll_id(Tensor<uint8_t> &image_input, std::vector<int> &landmarks, std::string name="");
int enroll_id(Tensor<uint8_t> &image_input, std::vector<int> &landmarks, std::string name="", bool update_flash = false);
/**
* @brief enroll face id
@ -179,42 +183,114 @@ class FaceRecognizer
* @param aligned_face the Tensor to store the intermeidate aligned face.
* @param landmarks face landmarks coordinates
* @param name name of the face id.
* @param update_flash true: the enrolled ids will be stored to flash
* false: the enrolled ids will not be stored to flash
* @return int the face id index of the enrolled embedding.
*/
int enroll_id(Tensor<uint8_t> &image_input, Tensor<uint8_t> &aligned_face, std::vector<int> &landmarks, std::string name="");
int enroll_id(Tensor<uint8_t> &image_input, Tensor<uint8_t> &aligned_face, std::vector<int> &landmarks, std::string name="", bool update_flash = false);
/**
* @brief enroll face id
*
* @param aligned_face the Tensor of the input aligned face with format bgr888.
* @param name name of the face id.
* @param update_flash true: the enrolled ids will be stored to flash
* false: the enrolled ids will not be stored to flash
* @return int the face id index of the enrolled embedding.
*/
int enroll_id(Tensor<uint8_t> &aligned_face, std::string name="");
int enroll_id(Tensor<uint8_t> &aligned_face, std::string name="", bool update_flash = false);
/**
* @brief enroll the normalzied face embedding.
*
* @param emb the normalized face embbeding.
* @param name name of the face id.
* @return int the face id index of the enrolled embedding.
* @param emb the normalized face embbeding.
* @param name name of the face id.
* @param update_flash true: the enrolled ids will be stored to flash
* false: the enrolled ids will not be stored to flash
* @return int the face id index of the enrolled embedding.
*/
int enroll_id(Tensor<float> &emb, std::string name="");
int enroll_id(Tensor<float> &emb, std::string name="", bool update_flash = false);
/**
* @brief delete the last enrolled face id.
* @brief delete the last enrolled face id.
* @param update_flash true: the ids will be updated to flash
* false: the ids will not be stored to flash
*
* @return int the number of remained face ids.
* if the face ids list is empty, return -1
*/
int delete_id();
int delete_id(bool update_flash = false);
/**
* @brief delete the face id with id index.
* @brief delete the face id with id index.
*
* @param id face id index.
* @return int the number of remained face ids.
* if there is no matched id return -1
* @param id face id index.
* @param update_flash true: the ids will be updated to flash
* false: the ids will not be stored to flash
* @return int the number of remained face ids.
* if there is no matched id return -1
*/
int delete_id(int id);
int delete_id(int id, bool update_flash = false);
/**
* @brief Set the enrolled ids
*
* @param ids the ids to be set
* @param update_flash true: the ids will be updated to flash
* false: the ids will not be stored to flash
* @return int the number of enrolled ids.
*/
int set_ids(std::vector<FaceID<float> *> &ids, bool update_flash = false);
/**
* @brief Set the enrolled ids from flash
*
* @return int the number of enrolled ids.
*/
int set_ids_from_flash();
/**
* @brief write the enrolled ids to flash
*
* @return int the number of enrolled ids.
*/
int write_ids_to_flash();
/**
* @brief Get the enrolled ids with name object
*
* @param name
* @return std::vector<face_info_t>
*/
std::vector<face_info_t> get_enrolled_ids_with_name(std::string name);
/**
* @brief Check whether the Flash partition is available
*
* @return int -2: the partition has not been set
* -1: the data in the flash does not match the current model.
* model_check_code: the Flash partition is available.
* number of ids in flash: The IDs in Flash and RAM does not sync.
*/
int check_partition();
/**
* @brief delete all the enrolled face ids.
* @param update_flash true: the ids will be updated to flash
* false: the ids will not be stored to flash
*
*/
void clear_id(bool update_flash = false);
/**
* @brief Set the partition for saving face ids to flash or reading face ids from flash.
*
* @param type esp_partition_type
* @param subtype esp_partition_subtype
* @param label the partition label
* @return int 0: set the partition failed
* 1: set the partition successfully
*/
int set_partition(esp_partition_type_t type, esp_partition_subtype_t subtype, const char *label);
};

26
tools/sdk/esp32c3/include/esp-face/include/typedef/dl_constant.hpp
View File

@ -2,6 +2,7 @@
#include "dl_define.hpp"
#include <vector>
#include <stdint.h>
namespace dl
{
@ -48,10 +49,11 @@ namespace dl
/*<! - 2D: [dilation_in_height, dilation_in_width] >*/
std::vector<int> shape_with_dilation; /*<! - 1D: reserved >*/
/*<! - 2D: [filter_height_with_dilation, filter_width_with_dilation, input_channel, output_channel] >*/
std::vector<int> channel_exponent; /*<! exponent for per-channel >*/
const int8_t* channel_exponent; /*<! exponent for per-channel >*/
const int channel_exponent_size;
/**
* @brief Construct a new Filter object.
* @brief Construct a new Filter object.
*
* @param element point to element
* @param exponent exponent of element
@ -66,16 +68,17 @@ namespace dl
Filter(const T *element, const int exponent, const std::vector<int> shape, const std::vector<int> dilation = {1, 1});
/**
* @brief Construct a new Filter object.
* @brief Construct a new Filter object. it is only avaliable to int16_t
*
* @param element point to element
* @param channel_exponent exponent for per-channel
* @param shape shape of element
* @param dilation dilation of Filter
* - 1D: reserved
* - 2D: [dilation_in_height, dilation_in_width]
* @param element point to element
* @param channel_exponent exponent for per-channel
* @param channel_exponent_size size of exponent
* @param shape shape of element
* @param dilation dilation of Filter
* - 1D: reserved
* - 2D: [dilation_in_height, dilation_in_width]
*/
Filter(const T *element, const std::vector<int> channel_exponent, const std::vector<int> shape, const std::vector<int> dilation = {1, 1});
Filter(const T *element, const int8_t* channel_exponent, const int channel_exponent_size, const std::vector<int> shape, const std::vector<int> dilation = {1, 1});
/**
* @brief Print the n-th filter.
@ -98,9 +101,6 @@ 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);
};
/**

11
tools/sdk/esp32c3/include/esp_http_client/include/esp_http_client.h
View File

@ -344,6 +344,17 @@ esp_err_t esp_http_client_set_password(esp_http_client_handle_t client, const ch
*/
esp_err_t esp_http_client_set_authtype(esp_http_client_handle_t client, esp_http_client_auth_type_t auth_type);
/**
* @brief Get HTTP client session errno
*
* @param[in] client The esp_http_client handle
*
* @return
* - (-1) if invalid argument
* - errno
*/
int esp_http_client_get_errno(esp_http_client_handle_t client);
/**
* @brief Set http request method
*

18
tools/sdk/esp32c3/include/esp_hw_support/include/soc/spinlock.h
View File

@ -52,6 +52,15 @@ static inline void __attribute__((always_inline)) spinlock_initialize(spinlock_t
/**
* @brief Top level spinlock acquire function, spins until get the lock
*
* This function will:
* - Save current interrupt state, then disable interrupts
* - Spin until lock is acquired or until timeout occurs
* - Restore interrupt state
*
* @note Spinlocks alone do no constitute true critical sections (as this
* function reenables interrupts once the spinlock is acquired). For critical
* sections, use the interface provided by the operating system.
* @param lock - target spinlock object
* @param timeout - cycles to wait, passing SPINLOCK_WAIT_FOREVER blocs indefinitely
*/
@ -125,6 +134,15 @@ static inline bool __attribute__((always_inline)) spinlock_acquire(spinlock_t *l
/**
* @brief Top level spinlock unlock function, unlocks a previously locked spinlock
*
* This function will:
* - Save current interrupt state, then disable interrupts
* - Release the spinlock
* - Restore interrupt state
*
* @note Spinlocks alone do no constitute true critical sections (as this
* function reenables interrupts once the spinlock is acquired). For critical
* sections, use the interface provided by the operating system.
* @param lock - target, locked before, spinlock object
*/
static inline void __attribute__((always_inline)) spinlock_release(spinlock_t *lock)

54
tools/sdk/esp32c3/include/esp_lcd/include/esp_lcd_panel_commands.h Normal file
View File

@ -0,0 +1,54 @@
/*
* SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
/* Common LCD panel commands */
#define LCD_CMD_NOP 0x00 // This command is empty command
#define LCD_CMD_SWRESET 0x01 // Software reset registers (the built-in frame buffer is not affected)
#define LCD_CMD_RDDID 0x04 // Read 24-bit display ID
#define LCD_CMD_RDDST 0x09 // Read display status
#define LCD_CMD_RDDPM 0x0A // Read display power mode
#define LCD_CMD_RDD_MADCTL 0x0B // Read display MADCTL
#define LCD_CMD_RDD_COLMOD 0x0C // Read display pixel format
#define LCD_CMD_RDDIM 0x0D // Read display image mode
#define LCD_CMD_RDDSM 0x0E // Read display signal mode
#define LCD_CMD_RDDSR 0x0F // Read display self-diagnostic result
#define LCD_CMD_SLPIN 0x10 // Go into sleep mode (DC/DC, oscillator, scanning stopped, but memory keeps content)
#define LCD_CMD_SLPOUT 0x11 // Exit sleep mode
#define LCD_CMD_PTLON 0x12 // Turns on partial display mode
#define LCD_CMD_NORON 0x13 // Turns on normal display mode
#define LCD_CMD_INVOFF 0x20 // Recover from display inversion mode
#define LCD_CMD_INVON 0x21 // Go into display inversion mode
#define LCD_CMD_GAMSET 0x26 // Select Gamma curve for current display
#define LCD_CMD_DISPOFF 0x28 // Display off (disable frame buffer output)
#define LCD_CMD_DISPON 0x29 // Display on (enable frame buffer output)
#define LCD_CMD_CASET 0x2A // Set column address
#define LCD_CMD_RASET 0x2B // Set row address
#define LCD_CMD_RAMWR 0x2C // Write frame memory
#define LCD_CMD_RAMRD 0x2E // Read frame memory
#define LCD_CMD_PTLAR 0x30 // Define the partial area
#define LCD_CMD_VSCRDEF 0x33 // Vertical scrolling definition
#define LCD_CMD_TEOFF 0x34 // Turns of tearing effect
#define LCD_CMD_TEON 0x35 // Turns on tearing effect
#define LCD_CMD_MADCTL 0x36 // Memory data access control
#define LCD_CMD_MH_BIT (1 << 2) // Display data latch order, 0: refresh left to right, 1: refresh right to left
#define LCD_CMD_BGR_BIT (1 << 3) // RGB/BGR order, 0: RGB, 1: BGR
#define LCD_CMD_ML_BIT (1 << 4) // Line address order, 0: refresh top to bottom, 1: refresh bottom to top
#define LCD_CMD_MV_BIT (1 << 5) // Row/Column order, 0: normal mode, 1: reverse mode
#define LCD_CMD_MX_BIT (1 << 6) // Column address order, 0: left to right, 1: right to left
#define LCD_CMD_MY_BIT (1 << 7) // Row address order, 0: top to bottom, 1: bottom to top
#define LCD_CMD_VSCSAD 0x37 // Vertical scroll start address
#define LCD_CMD_IDMOFF 0x38 // Recover from IDLE mode
#define LCD_CMD_IDMON 0x39 // Fall into IDLE mode (8 color depth is displayed)
#define LCD_CMD_COLMOD 0x3A // Defines the format of RGB picture data
#define LCD_CMD_RAMWRC 0x3C // Memory write continue
#define LCD_CMD_RAMRDC 0x3E // Memory read continue
#define LCD_CMD_STE 0x44 // Set tear scanline, tearing effect output signal when display module reaches line N
#define LCD_CMD_GDCAN 0x45 // Get scanline
#define LCD_CMD_WRDISBV 0x51 // Write display brightness
#define LCD_CMD_RDDISBV 0x52 // Read display brightness value

10
tools/sdk/esp32c3/include/esp_lcd/include/esp_lcd_panel_rgb.h
View File

@ -18,10 +18,10 @@ extern "C" {
#if SOC_LCD_RGB_SUPPORTED
/**
* @brief LCD RGB timing structure
*
* @verbatim
* Total Width
* <--------------------------------------------------->
* Hsync width HBP Active Width HFP
* HSYNC width HBP Active Width HFP
* <---><--><--------------------------------------><--->
* ____ ____|_______________________________________|____|
* |___| | | |
@ -36,7 +36,7 @@ extern "C" {
* | /|\ | | / / / / / / / / / / / / / / / / / / / | |
* | | | |/ / / / / / / / / / / / / / / / / / / /| |
* Total | | | |/ / / / / / / / / / / / / / / / / / / /| |
* Heigh | | | |/ / / / / / / / / / / / / / / / / / / /| |
* Height | | | |/ / / / / / / / / / / / / / / / / / / /| |
* |Active| | |/ / / / / / / / / / / / / / / / / / / /| |
* |Heigh | | |/ / / / / / Active Display Area / / / /| |
* | | | |/ / / / / / / / / / / / / / / / / / / /| |
@ -48,7 +48,7 @@ extern "C" {
* | /|\ | |
* | VFP | | |
* \|/ \|/_____|______________________________________________________|
*
* @endverbatim
*/
typedef struct {
unsigned int pclk_hz; /*!< Frequency of pixel clock */
@ -65,7 +65,7 @@ typedef struct {
unsigned int vsync_idle_low: 1; /*!< The vsync signal is low in IDLE state */
unsigned int de_idle_high: 1; /*!< The de signal is high in IDLE state */
unsigned int pclk_active_neg: 1; /*!< The display will write data lines when there's a falling edge on PCLK */
unsigned int pclk_idle_low: 1; /*!< The PCLK stays at low level in IDLE phase */
unsigned int pclk_idle_high: 1; /*!< The PCLK stays at high level in IDLE phase */
} flags;
} esp_lcd_rgb_timing_t;

32
tools/sdk/esp32c3/include/esp_netif/include/esp_netif_defaults.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_NETIF_DEFAULTS_H
#define _ESP_NETIF_DEFAULTS_H
@ -37,6 +29,7 @@ extern "C" {
.route_prio = 100 \
} \
#ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
#define ESP_NETIF_INHERENT_DEFAULT_WIFI_AP() \
{ \
.flags = (esp_netif_flags_t)(ESP_NETIF_DHCP_SERVER | ESP_NETIF_FLAG_AUTOUP), \
@ -48,6 +41,7 @@ extern "C" {
.if_desc = "ap", \
.route_prio = 10 \
};
#endif
#define ESP_NETIF_INHERENT_DEFAULT_ETH() \
{ \
@ -108,6 +102,7 @@ extern "C" {
.stack = ESP_NETIF_NETSTACK_DEFAULT_ETH, \
}
#ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
/**
* @brief Default configuration reference of WIFI AP
*/
@ -117,6 +112,7 @@ extern "C" {
.driver = NULL, \
.stack = ESP_NETIF_NETSTACK_DEFAULT_WIFI_AP, \
}
#endif
/**
* @brief Default configuration reference of WIFI STA
@ -154,10 +150,12 @@ extern "C" {
*/
#define ESP_NETIF_BASE_DEFAULT_WIFI_STA &_g_esp_netif_inherent_sta_config
#ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
/**
* @brief Default base config (esp-netif inherent) of WIFI AP
*/
#define ESP_NETIF_BASE_DEFAULT_WIFI_AP &_g_esp_netif_inherent_ap_config
#endif
/**
* @brief Default base config (esp-netif inherent) of ethernet interface
@ -177,7 +175,9 @@ extern "C" {
#define ESP_NETIF_NETSTACK_DEFAULT_ETH _g_esp_netif_netstack_default_eth
#define ESP_NETIF_NETSTACK_DEFAULT_WIFI_STA _g_esp_netif_netstack_default_wifi_sta
#ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
#define ESP_NETIF_NETSTACK_DEFAULT_WIFI_AP _g_esp_netif_netstack_default_wifi_ap
#endif
#define ESP_NETIF_NETSTACK_DEFAULT_PPP _g_esp_netif_netstack_default_ppp
#define ESP_NETIF_NETSTACK_DEFAULT_SLIP _g_esp_netif_netstack_default_slip
#define ESP_NETIF_NETSTACK_DEFAULT_OPENTHREAD _g_esp_netif_netstack_default_openthread
@ -190,7 +190,9 @@ extern "C" {
//
extern const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_eth;
extern const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_wifi_sta;
#ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
extern const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_wifi_ap;
#endif
extern const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_ppp;
extern const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_slip;
@ -200,12 +202,16 @@ extern const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_slip;
// common behavioural patterns for common interfaces such as STA, AP, ETH, PPP
//
extern const esp_netif_inherent_config_t _g_esp_netif_inherent_sta_config;
#ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
extern const esp_netif_inherent_config_t _g_esp_netif_inherent_ap_config;
#endif
extern const esp_netif_inherent_config_t _g_esp_netif_inherent_eth_config;
extern const esp_netif_inherent_config_t _g_esp_netif_inherent_ppp_config;
extern const esp_netif_inherent_config_t _g_esp_netif_inherent_slip_config;
#ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
extern const esp_netif_ip_info_t _g_esp_netif_soft_ap_ip;
#endif
#if CONFIG_OPENTHREAD_ENABLED
/**

18
tools/sdk/esp32c3/include/esp_wifi/include/esp_private/wifi_os_adapter.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
*/
#ifndef ESP_WIFI_OS_ADAPTER_H_
#define ESP_WIFI_OS_ADAPTER_H_

20
tools/sdk/esp32c3/include/esp_wifi/include/esp_wifi.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
*/
/* Notes about WiFi Programming
@ -275,7 +267,7 @@ esp_err_t esp_wifi_deinit(void);
* @brief Set the WiFi operating mode
*
* Set the WiFi operating mode as station, soft-AP or station+soft-AP,
* The default mode is soft-AP mode.
* The default mode is station mode.
*
* @param mode WiFi operating mode
*

11
tools/sdk/esp32c3/include/freertos/include/esp_additions/freertos/FreeRTOSConfig.h
View File

@ -166,10 +166,19 @@
#define configSTACK_OVERHEAD_APPTRACE 0
#endif
/* Stack watchpoint decreases minimum usable stack size by up to 60 bytes.
See FreeRTOS FREERTOS_WATCHPOINT_END_OF_STACK option in Kconfig. */
#if CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK
#define configSTACK_OVERHEAD_WATCHPOINT 60
#else
#define configSTACK_OVERHEAD_WATCHPOINT 0
#endif
#define configSTACK_OVERHEAD_TOTAL ( \
configSTACK_OVERHEAD_CHECKER + \
configSTACK_OVERHEAD_OPTIMIZATION + \
configSTACK_OVERHEAD_APPTRACE \
configSTACK_OVERHEAD_APPTRACE + \
configSTACK_OVERHEAD_WATCHPOINT \
)
#define configMINIMAL_STACK_SIZE (768 + configSTACK_OVERHEAD_TOTAL)

83
tools/sdk/esp32c3/include/freertos/port/riscv/include/freertos/portmacro.h
View File

@ -162,69 +162,19 @@ BaseType_t xPortInterruptedFromISRContext(void);
typedef struct {
uint32_t owner;
uint32_t count;
#ifdef CONFIG_FREERTOS_PORTMUX_DEBUG
const char *lastLockedFn;
int lastLockedLine;
#endif
} portMUX_TYPE;
/**< Spinlock initializer */
#ifndef CONFIG_FREERTOS_PORTMUX_DEBUG
#define portMUX_INITIALIZER_UNLOCKED { \
#define portMUX_INITIALIZER_UNLOCKED { \
.owner = portMUX_FREE_VAL, \
.count = 0, \
}
#else
#define portMUX_INITIALIZER_UNLOCKED { \
.owner = portMUX_FREE_VAL, \
.count = 0, \
.lastLockedFn = "(never locked)", \
.lastLockedLine = -1 \
}
#endif /* CONFIG_FREERTOS_PORTMUX_DEBUG */
#define portMUX_FREE_VAL SPINLOCK_FREE /**< Spinlock is free. [refactor-todo] check if this is still required */
#define portMUX_NO_TIMEOUT SPINLOCK_WAIT_FOREVER /**< When passed for 'timeout_cycles', spin forever if necessary. [refactor-todo] check if this is still required */
#define portMUX_TRY_LOCK SPINLOCK_NO_WAIT /**< Try to acquire the spinlock a single time only. [refactor-todo] check if this is still required */
/**
* @brief Initialize a spinlock
*
* - Initializes a spinlock that is used by FreeRTOS SMP critical sections
*
* @note [refactor-todo] We can make this inline or consider making it a macro
* @param[in] mux Spinlock
*/
void vPortCPUInitializeMutex(portMUX_TYPE *mux);
/**
* @brief Acquire a spinlock
*
* @note [refactor-todo] check if we still need this
* @note [refactor-todo] Check if this should be inlined
* @param[in] mux Spinlock
*/
void vPortCPUAcquireMutex(portMUX_TYPE *mux);
/**
* @brief Acquire a spinlock but with a specified timeout
*
* @note [refactor-todo] Check if we still need this
* @note [refactor-todo] Check if this should be inlined
* @note [refactor-todo] Check if this function should be renamed (due to bool return type)
* @param[in] mux Spinlock
* @param[in] timeout Timeout in number of CPU cycles
* @return true Spinlock acquired
* @return false Timed out
*/
bool vPortCPUAcquireMutexTimeout(portMUX_TYPE *mux, int timeout_cycles);
/**
* @brief Release a spinlock
*
* @note [refactor-todo] check if we still need this
* @note [refactor-todo] Check if this should be inlined
* @param[in] mux Spinlock
*/
void vPortCPUReleaseMutex(portMUX_TYPE *mux);
#define portMUX_FREE_VAL SPINLOCK_FREE /**< Spinlock is free. [refactor-todo] check if this is still required */
#define portMUX_NO_TIMEOUT SPINLOCK_WAIT_FOREVER /**< When passed for 'timeout_cycles', spin forever if necessary. [refactor-todo] check if this is still required */
#define portMUX_TRY_LOCK SPINLOCK_NO_WAIT /**< Try to acquire the spinlock a single time only. [refactor-todo] check if this is still required */
#define portMUX_INITIALIZE(mux) ({ \
(mux)->owner = portMUX_FREE_VAL; \
(mux)->count = 0; \
})
/**
* @brief Wrapper for atomic compare-and-set instruction
@ -398,11 +348,19 @@ static inline BaseType_t IRAM_ATTR xPortGetCoreID(void)
// ------------------ Critical Sections --------------------
#define portENTER_CRITICAL(mux) {(void)mux; vPortEnterCritical();}
#define portEXIT_CRITICAL(mux) {(void)mux; vPortExitCritical();}
#define portENTER_CRITICAL(mux) {(void)mux; vPortEnterCritical();}
#define portEXIT_CRITICAL(mux) {(void)mux; vPortExitCritical();}
#define portTRY_ENTER_CRITICAL(mux, timeout) ({ \
(void)mux; (void)timeout; \
vPortEnterCritical(); \
BaseType_t ret = pdPASS; \
ret; \
})
//In single-core RISC-V, we can use the same critical section API
#define portENTER_CRITICAL_ISR(mux) portENTER_CRITICAL(mux)
#define portEXIT_CRITICAL_ISR(mux) portEXIT_CRITICAL(mux)
#define portENTER_CRITICAL_ISR(mux) portENTER_CRITICAL(mux)
#define portEXIT_CRITICAL_ISR(mux) portEXIT_CRITICAL(mux)
#define portTRY_ENTER_CRITICAL_ISR(mux, timeout) portTRY_ENTER_CRITICAL(mux, timeout)
/* [refactor-todo] on RISC-V, both ISR and non-ISR cases result in the same call. We can redefine this macro */
#define portENTER_CRITICAL_SAFE(mux) ({ \
if (xPortInIsrContext()) { \
@ -418,6 +376,7 @@ static inline BaseType_t IRAM_ATTR xPortGetCoreID(void)
portEXIT_CRITICAL(mux); \
} \
})
#define portTRY_ENTER_CRITICAL_SAFE(mux, timeout) portENTER_CRITICAL_SAFE(mux, timeout)
// ---------------------- Yielding -------------------------

60
tools/sdk/esp32c3/include/freertos/port/riscv/include/freertos/portmacro_deprecated.h
View File

@ -32,3 +32,63 @@ static inline void __attribute__((deprecated)) portEXIT_CRITICAL_NESTED(UBaseTyp
{
portCLEAR_INTERRUPT_MASK_FROM_ISR(prev_level);
}
/* ---------------------- Spinlocks --------------------- */
/**
* @brief Deprecated placed holder function to initialize a spinlock
*
* Currently does nothing.
*
* @deprecated This function is deprecated. If on multi-core, use spinlock_initialize() instead
* @param[in] mux Spinlock
*/
static inline void __attribute__((deprecated)) __attribute__((always_inline)) vPortCPUInitializeMutex(portMUX_TYPE *mux)
{
(void)mux;
}
/**
* @brief Deprecated placed holder function to acquire a spinlock
*
* Currently does nothing.
*
* @deprecated This function is deprecated. If on multi-core, use spinlock_acquire() instead
* @param[in] mux Spinlock
*/
static inline void __attribute__((deprecated)) __attribute__((always_inline)) vPortCPUAcquireMutex(portMUX_TYPE *mux)
{
(void)mux;
}
/**
* @brief Deprecated placed holder function to acquire a spinlock but with a specified timeout
*
* Currently just returns true
*
* @deprecated This function is deprecated. If on multi-core, use spinlock_acquire() instead
* @note Does not have deprecated attribute due to usage in app_trace_util.c
* @param[in] mux Spinlock
* @param[in] timeout Timeout in number of CPU cycles
* @return true Always returns true
*/
static inline bool __attribute__((always_inline)) vPortCPUAcquireMutexTimeout(portMUX_TYPE *mux, int timeout_cycles)
{
(void)mux;
(void)timeout_cycles;
return true;
}
/**
* @brief Deprecated placed holder function to release a spinlock
*
* Currently does nothing.
*
* @deprecated This function is deprecated. If on multi-core, use spinlock_release() instead
* @note Does not have deprecated attribute due to usage in app_trace_util.c
* @param[in] mux Spinlock
*/
static inline void __attribute__((always_inline)) vPortCPUReleaseMutex(portMUX_TYPE *mux)
{
(void)mux;
}

17
tools/sdk/esp32c3/include/hal/include/hal/lcd_types.h
View File

@ -13,12 +13,17 @@ 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 |
* @verbatim embed:rst:leading-asterisk
* +---------------------+-------------------------+----------------------------+
* | LCD clock source | Features | Power Management |
* +=====================+=========================+============================+
* | LCD_CLK_SRC_PLL160M | High resolution | ESP_PM_APB_FREQ_MAX lock |
* +---------------------+-------------------------+----------------------------+
* | LCD_CLK_SRC_APLL | Configurable resolution | ESP_PM_NO_LIGHT_SLEEP lock |
* +---------------------+-------------------------+----------------------------+
* | LCD_CLK_SRC_XTAL | Medium resolution | No PM lock |
* +---------------------+-------------------------+----------------------------+
* @endverbatim
*/
typedef enum {
LCD_CLK_SRC_PLL160M, /*!< Select PLL160M as the source clock */

18
tools/sdk/esp32c3/include/idf_test/include/esp32s2/idf_performance_target.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
*/
#pragma once

20
tools/sdk/esp32c3/include/idf_test/include/esp32s3/idf_performance_target.h
View File

@ -1,23 +1,15 @@
// 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
*/
#pragma once
#define IDF_PERFORMANCE_MIN_AES_CBC_THROUGHPUT_MBSEC 43
// SHA256 hardware throughput at 240MHz, threshold set lower than worst case
#define IDF_PERFORMANCE_MIN_SHA256_THROUGHPUT_MBSEC 19.8
#define IDF_PERFORMANCE_MIN_SHA256_THROUGHPUT_MBSEC 90
// esp_sha() time to process 32KB of input data from RAM
#define IDF_PERFORMANCE_MAX_TIME_SHA1_32KB 1000
#define IDF_PERFORMANCE_MAX_TIME_SHA512_32KB 900

2
tools/sdk/esp32c3/include/idf_test/include/idf_performance.h
View File

@ -8,7 +8,7 @@
*/
#ifndef IDF_PERFORMANCE_MAX_FREERTOS_SPINLOCK_CYCLES_PER_OP
#define IDF_PERFORMANCE_MAX_FREERTOS_SPINLOCK_CYCLES_PER_OP 200
#define IDF_PERFORMANCE_MAX_FREERTOS_SPINLOCK_CYCLES_PER_OP 250
#endif
#ifndef IDF_PERFORMANCE_MAX_FREERTOS_SPINLOCK_CYCLES_PER_OP_PSRAM
#define IDF_PERFORMANCE_MAX_FREERTOS_SPINLOCK_CYCLES_PER_OP_PSRAM 300

45
tools/sdk/esp32c3/include/mbedtls/port/include/mbedtls/bignum.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
#include_next "mbedtls/bignum.h"
@ -77,4 +69,31 @@ void esp_mpi_release_hardware(void);
*/
int esp_mpi_mul_mpi_mod(mbedtls_mpi *Z, const mbedtls_mpi *X, const mbedtls_mpi *Y, const mbedtls_mpi *M);
#if CONFIG_MBEDTLS_LARGE_KEY_SOFTWARE_MPI
/**
* @brief Perform a sliding-window exponentiation: X = A^E mod N
*
* @param X The destination MPI. This must point to an initialized MPI.
* @param A The base of the exponentiation.
* This must point to an initialized MPI.
* @param E The exponent MPI. This must point to an initialized MPI.
* @param N The base for the modular reduction. This must point to an
* initialized MPI.
* @param _RR A helper MPI depending solely on \p N which can be used to
* speed-up multiple modular exponentiations for the same value
* of \p N. This may be \c NULL. If it is not \c NULL, it must
* point to an initialized MPI.
*
* @return \c 0 if successful.
* @return #MBEDTLS_ERR_MPI_ALLOC_FAILED if a memory allocation failed.
* @return #MBEDTLS_ERR_MPI_BAD_INPUT_DATA if \c N is negative or
* even, or if \c E is negative.
* @return Another negative error code on different kinds of failures.
*
*/
int mbedtls_mpi_exp_mod_soft(mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *E, const mbedtls_mpi *N, mbedtls_mpi *_RR);
#endif // CONFIG_MBEDTLS_LARGE_KEY_SOFTWARE_MPI
#endif // CONFIG_MBEDTLS_HARDWARE_MPI

19
tools/sdk/esp32c3/include/mbedtls/port/include/mbedtls/esp_config.h
View File

@ -153,15 +153,22 @@
#undef MBEDTLS_MD5_ALT
#endif
/* The following MPI (bignum) functions have ESP32 hardware support.
For exponential mod, both software and hardware implementation
will be compiled. If CONFIG_MBEDTLS_HARDWARE_MPI is enabled, mod APIs
will be wrapped to use hardware implementation.
*/
#undef MBEDTLS_MPI_EXP_MOD_ALT
/* The following MPI (bignum) functions have hardware support.
* Uncommenting these macros will use the hardware-accelerated
* implementations.
*/
#ifdef CONFIG_MBEDTLS_HARDWARE_MPI
#ifdef CONFIG_MBEDTLS_LARGE_KEY_SOFTWARE_MPI
/* Prefer hardware and fallback to software */
#define MBEDTLS_MPI_EXP_MOD_ALT_FALLBACK
#else
/* Hardware only mode */
#define MBEDTLS_MPI_EXP_MOD_ALT
#endif
#define MBEDTLS_MPI_MUL_MPI_ALT
#else
#undef MBEDTLS_MPI_EXP_MOD_ALT_FALLBACK
#undef MBEDTLS_MPI_EXP_MOD_ALT
#undef MBEDTLS_MPI_MUL_MPI_ALT
#endif

21
tools/sdk/esp32c3/include/vfs/include/esp_vfs.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
*/
#ifndef __ESP_VFS_H__
#define __ESP_VFS_H__
@ -410,7 +402,8 @@ int esp_vfs_utime(const char *path, const struct utimbuf *times);
* @param timeout If not NULL, then points to timeval structure which
* specifies the time period after which the functions should
* time-out and return. If it is NULL, then the function will
* not time-out.
* not time-out. Note that the timeout period is rounded up to
* the system tick and incremented by one.
*
* @return The number of descriptors set in the descriptor sets, or -1
* when an error (specified by errno) have occurred.