Browse Source
solve the Conflicts # Conflicts: # APP_Framework/Framework/knowing/Kconfigpull/120/head
139 changed files with 763 additions and 1550 deletions
@ -1,6 +1,6 @@ |
|||
[submodule "Ubiquitous/RT_Thread/rt-thread"] |
|||
path = Ubiquitous/RT_Thread/rt-thread |
|||
url = https://git.trustie.net/chunyexixiaoyu/rt-thread.git |
|||
url = https://code.gitlink.org.cn/chunyexixiaoyu/rt-thread.git |
|||
[submodule "Ubiquitous/RT_Thread/bsp/k210/kendryte-sdk/kendryte-sdk-source"] |
|||
path = Ubiquitous/RT_Thread/bsp/k210/kendryte-sdk/kendryte-sdk-source |
|||
url = https://git.trustie.net/chunyexixiaoyu/kendryte-sdk-source.git |
|||
path = Ubiquitous/RT_Thread/aiit_board/k210/kendryte-sdk/kendryte-sdk-source |
|||
url = https://code.gitlink.org.cn/chunyexixiaoyu/kendryte-sdk-source.git |
|||
|
@ -1,17 +1,15 @@ |
|||
menu "knowing app" |
|||
menuconfig APPLICATION_KNOWING |
|||
bool "Using knowing apps" |
|||
default n |
|||
|
|||
if APPLICATION_KNOWING |
|||
source "$APP_DIR/Applications/knowing_app/mnist/Kconfig" |
|||
source "$APP_DIR/Applications/knowing_app/face_detect/Kconfig" |
|||
source "$APP_DIR/Applications/knowing_app/instrusion_detect/Kconfig" |
|||
source "$APP_DIR/Applications/knowing_app/helmet_detect/Kconfig" |
|||
source "$APP_DIR/Applications/knowing_app/iris_ml_demo/Kconfig" |
|||
source "$APP_DIR/Applications/knowing_app/k210_fft_test/Kconfig" |
|||
source "$APP_DIR/Applications/knowing_app/image_processing/Kconfig" |
|||
source "$APP_DIR/Applications/knowing_app/cmsis_5_demo/Kconfig" |
|||
|
|||
endif |
|||
endmenu |
|||
menu "knowing app" |
|||
menuconfig APPLICATION_KNOWING |
|||
bool "Using knowing apps" |
|||
default n |
|||
|
|||
if APPLICATION_KNOWING |
|||
source "$APP_DIR/Applications/knowing_app/mnist/Kconfig" |
|||
source "$APP_DIR/Applications/knowing_app/k210_detect_entry/Kconfig" |
|||
source "$APP_DIR/Applications/knowing_app/iris_ml_demo/Kconfig" |
|||
source "$APP_DIR/Applications/knowing_app/k210_fft_test/Kconfig" |
|||
source "$APP_DIR/Applications/knowing_app/image_processing/Kconfig" |
|||
source "$APP_DIR/Applications/knowing_app/cmsis_5_demo/Kconfig" |
|||
|
|||
endif |
|||
endmenu |
|||
|
@ -1,8 +0,0 @@ |
|||
config FACE_DETECT |
|||
bool "enable apps/face detect" |
|||
depends on BOARD_K210_EVB |
|||
depends on DRV_USING_OV2640 |
|||
depends on USING_KPU_POSTPROCESSING |
|||
depends on USING_YOLOV2 |
|||
select LIB_USING_CJSON |
|||
default n |
@ -1,9 +0,0 @@ |
|||
from building import * |
|||
|
|||
cwd = GetCurrentDir() |
|||
src = Glob('*.c') + Glob('*.cpp') |
|||
CPPPATH = [cwd] |
|||
|
|||
group = DefineGroup('Applications', src, depend = ['FACE_DETECT'], LOCAL_CPPPATH = CPPPATH) |
|||
|
|||
Return('group') |
@ -1,379 +0,0 @@ |
|||
#include <transform.h> |
|||
#ifdef LIB_USING_CJSON |
|||
#include <cJSON.h> |
|||
#endif |
|||
#include "region_layer.h" |
|||
#define ANCHOR_NUM 5 |
|||
#define STACK_SIZE (128 * 1024) |
|||
#define JSON_FILE_PATH "/kmodel/detect.json" |
|||
#define JSON_BUFFER_SIZE (4 * 1024) |
|||
static dmac_channel_number_t dma_ch = DMAC_CHANNEL_MAX; |
|||
// params from json
|
|||
static float anchor[ANCHOR_NUM * 2] = {}; |
|||
static int net_output_shape[3] = {}; |
|||
static int net_input_size[2] = {}; |
|||
static int sensor_output_size[2] = {}; |
|||
static char kmodel_path[127] = ""; |
|||
static int kmodel_size = 0; |
|||
static float obj_thresh[20] = {}; |
|||
static float nms_thresh = 0.0; |
|||
static char labels[20][32] = {}; |
|||
static int class_num = 0; |
|||
|
|||
#define THREAD_PRIORITY_FACE_D (11) |
|||
static pthread_t facetid = 0; |
|||
static void *thread_face_detcet_entry(void *parameter); |
|||
static int g_fd = 0; |
|||
static int kmodel_fd = 0; |
|||
static int if_exit = 0; |
|||
static unsigned char *showbuffer = NULL; |
|||
static unsigned char *kpurgbbuffer = NULL; |
|||
|
|||
static _ioctl_shoot_para shoot_para_t = {0}; |
|||
unsigned char *model_data = NULL; // kpu data load memory
|
|||
unsigned char *model_data_align = NULL; |
|||
|
|||
kpu_model_context_t face_detect_task; |
|||
static region_layer_t face_detect_rl; |
|||
static obj_info_t face_detect_info; |
|||
volatile uint32_t g_ai_done_flag; |
|||
|
|||
static void ai_done(void *ctx) { g_ai_done_flag = 1; } |
|||
|
|||
static void param_parse() |
|||
{ |
|||
int fin; |
|||
char buffer[JSON_BUFFER_SIZE] = ""; |
|||
// char *buffer;
|
|||
// if (NULL != (buffer = (char*)malloc(JSON_BUFFER_SIZE * sizeof(char)))) {
|
|||
// memset(buffer, 0, JSON_BUFFER_SIZE * sizeof(char));
|
|||
// } else {
|
|||
// printf("Json buffer malloc failed!");
|
|||
// exit(-1);
|
|||
// }
|
|||
int array_size; |
|||
cJSON *json_obj; |
|||
cJSON *json_item; |
|||
cJSON *json_array_item; |
|||
|
|||
fin = open(JSON_FILE_PATH, O_RDONLY); |
|||
if (!fin) { |
|||
printf("Error open file %s", JSON_FILE_PATH); |
|||
exit(-1); |
|||
} |
|||
read(fin, buffer, sizeof(buffer)); |
|||
close(fin); |
|||
|
|||
// read json string
|
|||
json_obj = cJSON_Parse(buffer); |
|||
// free(buffer);
|
|||
char *json_print_str = cJSON_Print(json_obj); |
|||
printf("Json file content: \n%s\n", json_print_str); |
|||
cJSON_free(json_print_str); |
|||
// get anchors
|
|||
json_item = cJSON_GetObjectItem(json_obj, "anchors"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (ANCHOR_NUM * 2 != array_size) { |
|||
printf("Expect anchor size: %d, got %d in json file", ANCHOR_NUM * 2, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d anchors from json file\n", ANCHOR_NUM); |
|||
} |
|||
for (int i = 0; i < ANCHOR_NUM * 2; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
anchor[i] = json_array_item->valuedouble; |
|||
printf("%d: %f\n", i, anchor[i]); |
|||
} |
|||
// net_input_size
|
|||
json_item = cJSON_GetObjectItem(json_obj, "net_input_size"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (2 != array_size) { |
|||
printf("Expect net_input_size: %d, got %d in json file", 2, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d net_input_size from json file\n", 2); |
|||
} |
|||
for (int i = 0; i < 2; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
net_input_size[i] = json_array_item->valueint; |
|||
printf("%d: %d\n", i, net_input_size[i]); |
|||
} |
|||
// net_output_shape
|
|||
json_item = cJSON_GetObjectItem(json_obj, "net_output_shape"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (3 != array_size) { |
|||
printf("Expect net_output_shape: %d, got %d in json file", 3, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d net_output_shape from json file\n", 3); |
|||
} |
|||
for (int i = 0; i < 3; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
net_output_shape[i] = json_array_item->valueint; |
|||
printf("%d: %d\n", i, net_output_shape[i]); |
|||
} |
|||
// sensor_output_size
|
|||
json_item = cJSON_GetObjectItem(json_obj, "sensor_output_size"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (2 != array_size) { |
|||
printf("Expect sensor_output_size: %d, got %d in json file", 2, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d sensor_output_size from json file\n", 2); |
|||
} |
|||
for (int i = 0; i < 2; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
sensor_output_size[i] = json_array_item->valueint; |
|||
printf("%d: %d\n", i, sensor_output_size[i]); |
|||
} |
|||
// kmodel_path
|
|||
json_item = cJSON_GetObjectItem(json_obj, "kmodel_path"); |
|||
memcpy(kmodel_path, json_item->valuestring, strlen(json_item->valuestring)); |
|||
printf("Got kmodel_path: %s\n", kmodel_path); |
|||
// kmodel_size
|
|||
json_item = cJSON_GetObjectItem(json_obj, "kmodel_size"); |
|||
kmodel_size = json_item->valueint; |
|||
printf("Got kmodel_size: %d\n", kmodel_size); |
|||
// labels
|
|||
json_item = cJSON_GetObjectItem(json_obj, "labels"); |
|||
class_num = cJSON_GetArraySize(json_item); |
|||
if (0 >= class_num) { |
|||
printf("No labels!"); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d labels\n", class_num); |
|||
} |
|||
for (int i = 0; i < class_num; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
memcpy(labels[i], json_array_item->valuestring, strlen(json_array_item->valuestring)); |
|||
printf("%d: %s\n", i, labels[i]); |
|||
} |
|||
// obj_thresh
|
|||
json_item = cJSON_GetObjectItem(json_obj, "obj_thresh"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (class_num != array_size) { |
|||
printf("label number and thresh number mismatch! label number : %d, obj thresh number %d", class_num, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d obj_thresh\n", array_size); |
|||
} |
|||
for (int i = 0; i < array_size; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
obj_thresh[i] = json_array_item->valuedouble; |
|||
printf("%d: %f\n", i, obj_thresh[i]); |
|||
} |
|||
// nms_thresh
|
|||
json_item = cJSON_GetObjectItem(json_obj, "nms_thresh"); |
|||
nms_thresh = json_item->valuedouble; |
|||
printf("Got nms_thresh: %f\n", nms_thresh); |
|||
|
|||
cJSON_Delete(json_obj); |
|||
return; |
|||
} |
|||
|
|||
void face_detect() |
|||
{ |
|||
int ret = 0; |
|||
int result = 0; |
|||
int size = 0; |
|||
param_parse(); |
|||
g_fd = open("/dev/ov2640", O_RDONLY); |
|||
if (g_fd < 0) { |
|||
printf("open ov2640 fail !!"); |
|||
return; |
|||
} |
|||
_ioctl_set_dvp_reso set_dvp_reso = {sensor_output_size[1], sensor_output_size[0]}; |
|||
ioctl(g_fd, IOCTRL_CAMERA_SET_DVP_RESO, &set_dvp_reso); |
|||
showbuffer = (unsigned char *)rt_malloc_align(sensor_output_size[0] * sensor_output_size[1] * 2,64); |
|||
if (NULL == showbuffer) { |
|||
close(g_fd); |
|||
printf("showbuffer apply memory fail !!"); |
|||
return; |
|||
} |
|||
kpurgbbuffer = (unsigned char *)rt_malloc_align(net_input_size[0] * net_input_size[1] * 3,64); |
|||
if (NULL == kpurgbbuffer) { |
|||
close(g_fd); |
|||
rt_free_align(showbuffer); |
|||
printf("kpurgbbuffer apply memory fail !!"); |
|||
return; |
|||
} |
|||
model_data = (unsigned char *)malloc(kmodel_size + 255); |
|||
if (NULL == model_data) { |
|||
rt_free_align(showbuffer); |
|||
rt_free_align(kpurgbbuffer); |
|||
close(g_fd); |
|||
printf("model_data apply memory fail !!"); |
|||
return; |
|||
} |
|||
memset(model_data, 0, kmodel_size + 255); |
|||
memset(showbuffer, 0, sensor_output_size[0] * sensor_output_size[1] * 2); |
|||
memset(kpurgbbuffer, 0, net_input_size[0] * net_input_size[1] * 3); |
|||
shoot_para_t.pdata = (unsigned int *)(showbuffer); |
|||
shoot_para_t.length = (size_t)(sensor_output_size[0] * sensor_output_size[1] * 2); |
|||
/*
|
|||
load memory |
|||
*/ |
|||
kmodel_fd = open(kmodel_path, O_RDONLY); |
|||
if (kmodel_fd < 0) { |
|||
printf("open kmodel fail"); |
|||
close(g_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
return; |
|||
} else { |
|||
size = read(kmodel_fd, model_data, kmodel_size); |
|||
if (size != kmodel_size) { |
|||
printf("read kmodel error size %d\n", size); |
|||
close(g_fd); |
|||
close(kmodel_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
return; |
|||
|
|||
} else { |
|||
printf("read kmodel success \n"); |
|||
} |
|||
} |
|||
unsigned char *model_data_align = (unsigned char *)(((unsigned int)model_data + 255) & (~255)); |
|||
dvp_set_ai_addr((uint32_t)kpurgbbuffer, (uint32_t)(kpurgbbuffer + net_input_size[0] * net_input_size[1]), |
|||
(uint32_t)(kpurgbbuffer + net_input_size[0] * net_input_size[1] * 2)); |
|||
if (kpu_load_kmodel(&face_detect_task, model_data_align) != 0) { |
|||
printf("\nmodel init error\n"); |
|||
close(g_fd); |
|||
close(kmodel_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
return; |
|||
} |
|||
face_detect_rl.anchor_number = ANCHOR_NUM; |
|||
face_detect_rl.anchor = anchor; |
|||
face_detect_rl.threshold = malloc(class_num * sizeof(float)); |
|||
for (int idx = 0; idx < class_num; idx++) { |
|||
face_detect_rl.threshold[idx] = obj_thresh[idx]; |
|||
} |
|||
face_detect_rl.nms_value = nms_thresh; |
|||
result = region_layer_init(&face_detect_rl, net_output_shape[0], net_output_shape[1], net_output_shape[2], |
|||
net_input_size[1], net_input_size[0]); |
|||
printf("region_layer_init result %d \n\r", result); |
|||
size_t stack_size = STACK_SIZE; |
|||
pthread_attr_t attr; /* ็บฟ็จๅฑๆง */ |
|||
struct sched_param prio; /* ็บฟ็จไผๅ
็บง */ |
|||
prio.sched_priority = 8; /* ไผๅ
็บง่ฎพ็ฝฎไธบ 8 */ |
|||
pthread_attr_init(&attr); /* ๅ
ไฝฟ็จ้ป่ฎคๅผๅๅงๅๅฑๆง */ |
|||
pthread_attr_setschedparam(&attr, &prio); /* ไฟฎๆนๅฑๆงๅฏนๅบ็ไผๅ
็บง */ |
|||
pthread_attr_setstacksize(&attr, stack_size); |
|||
|
|||
/* ๅๅปบ็บฟ็จ 1, ๅฑๆงไธบ attr๏ผๅ
ฅๅฃๅฝๆฐๆฏ thread_entry๏ผๅ
ฅๅฃๅฝๆฐๅๆฐๆฏ 1 */ |
|||
result = pthread_create(&facetid, &attr, thread_face_detcet_entry, NULL); |
|||
if (0 == result) { |
|||
printf("thread_face_detcet_entry successfully!\n"); |
|||
} else { |
|||
printf("thread_face_detcet_entry failed! error code is %d\n", result); |
|||
close(g_fd); |
|||
} |
|||
} |
|||
#ifdef __RT_THREAD_H__ |
|||
MSH_CMD_EXPORT(face_detect, face detect task); |
|||
#endif |
|||
|
|||
static void *thread_face_detcet_entry(void *parameter) |
|||
{ |
|||
extern void lcd_draw_picture(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, uint32_t * ptr); |
|||
printf("thread_face_detcet_entry start!\n"); |
|||
int ret = 0; |
|||
// sysctl_enable_irq();
|
|||
while (1) { |
|||
// memset(showbuffer,0,320*240*2);
|
|||
g_ai_done_flag = 0; |
|||
ret = ioctl(g_fd, IOCTRL_CAMERA_START_SHOT, &shoot_para_t); |
|||
if (RT_ERROR == ret) { |
|||
printf("ov2640 can't wait event flag"); |
|||
rt_free(showbuffer); |
|||
close(g_fd); |
|||
pthread_exit(NULL); |
|||
return NULL; |
|||
} |
|||
if (dmalock_sync_take(&dma_ch, 2000)) |
|||
{ |
|||
printf("Fail to take DMA channel"); |
|||
} |
|||
kpu_run_kmodel(&face_detect_task, kpurgbbuffer, DMAC_CHANNEL5, ai_done, NULL); |
|||
while (!g_ai_done_flag) |
|||
; |
|||
dmalock_release(dma_ch); |
|||
float *output; |
|||
size_t output_size; |
|||
kpu_get_output(&face_detect_task, 0, (uint8_t **)&output, &output_size); |
|||
face_detect_rl.input = output; |
|||
region_layer_run(&face_detect_rl, &face_detect_info); |
|||
/* display result */ |
|||
|
|||
for (int face_cnt = 0; face_cnt < face_detect_info.obj_number; face_cnt++) { |
|||
draw_edge((uint32_t *)showbuffer, &face_detect_info, face_cnt, 0xF800, (uint16_t)sensor_output_size[1], |
|||
(uint16_t)sensor_output_size[0]); |
|||
// printf("%d: (%d, %d, %d, %d) cls: %s conf: %f\t", face_cnt, face_detect_info.obj[face_cnt].x1,
|
|||
// face_detect_info.obj[face_cnt].y1, face_detect_info.obj[face_cnt].x2, face_detect_info.obj[face_cnt].y2,
|
|||
// labels[face_detect_info.obj[face_cnt].class_id], face_detect_info.obj[face_cnt].prob);
|
|||
} |
|||
#ifdef BSP_USING_LCD |
|||
lcd_draw_picture(0, 0, (uint16_t)sensor_output_size[1], (uint16_t)sensor_output_size[0], (uint32_t *)showbuffer); |
|||
//lcd_show_image(0, 0, (uint16_t)sensor_output_size[1], (uint16_t)sensor_output_size[0], (unsigned int *)showbuffer);
|
|||
#endif |
|||
usleep(500); |
|||
if (1 == if_exit) { |
|||
if_exit = 0; |
|||
printf("thread_face_detcet_entry exit"); |
|||
pthread_exit(NULL); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void face_detect_delete() |
|||
{ |
|||
if (showbuffer != NULL) { |
|||
int ret = 0; |
|||
close(g_fd); |
|||
close(kmodel_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
printf("face detect task cancel!!! ret %d ", ret); |
|||
if_exit = 1; |
|||
} |
|||
} |
|||
#ifdef __RT_THREAD_H__ |
|||
MSH_CMD_EXPORT(face_detect_delete, face detect task delete); |
|||
#endif |
|||
|
|||
void kmodel_load(unsigned char *model_data) |
|||
{ |
|||
int kmodel_fd = 0; |
|||
int size = 0; |
|||
kmodel_fd = open(kmodel_path, O_RDONLY); |
|||
|
|||
model_data = (unsigned char *)malloc(kmodel_size + 255); |
|||
if (NULL == model_data) { |
|||
printf("model_data apply memory fail !!"); |
|||
return; |
|||
} |
|||
memset(model_data, 0, kmodel_size + 255); |
|||
|
|||
if (kmodel_fd >= 0) { |
|||
size = read(kmodel_fd, model_data, kmodel_size); |
|||
if (size != kmodel_size) { |
|||
printf("read kmodel error size %d\n", size); |
|||
|
|||
} else { |
|||
printf("read kmodel success"); |
|||
} |
|||
} else { |
|||
free(model_data); |
|||
printf("open kmodel fail"); |
|||
} |
|||
} |
|||
#ifdef __RT_THREAD_H__ |
|||
MSH_CMD_EXPORT(kmodel_load, kmodel load memory); |
|||
#endif |
@ -1,8 +0,0 @@ |
|||
config HELMET_DETECT |
|||
bool "enable apps/helmet detect" |
|||
depends on BOARD_K210_EVB |
|||
depends on DRV_USING_OV2640 |
|||
depends on USING_KPU_POSTPROCESSING |
|||
depends on USING_YOLOV2 |
|||
select LIB_USING_CJSON |
|||
default n |
@ -1,167 +0,0 @@ |
|||
# Helmet detection demo |
|||
|
|||
### A helmet and head without helmet object detection task demo. Running MobileNet-yolo on K210-based edge devices. |
|||
|
|||
--- |
|||
|
|||
## Training |
|||
|
|||
### Enviroment preparation |
|||
|
|||
Model generated by [aXeleRate](https://forgeplus.trustie.net/projects/yangtuo250/aXeleRate) and converted to kmodel by [nncase](https://github.com/kendryte/nncase/tree/v0.1.0-rc5). |
|||
|
|||
```shell |
|||
# master branch for MobileNetv1-yolov2 and unstable branch to test MobileNetv1(v2)-yolov2(v3) |
|||
git clone https://git.trustie.net/yangtuo250/aXeleRate.git (-b unstable) |
|||
cd aXeleRate |
|||
pip install -r requirments.txt && pip install -e . |
|||
``` |
|||
|
|||
### training config setting |
|||
|
|||
Example [config](https://forgeplus.trustie.net/projects/yangtuo250/aXeleRate/tree/master/configs/detector.json), some hyper-parameters: |
|||
|
|||
- architecture: backbone, MobileNet7_5 for default, MobileNet1_0(ฮฑ = 1.0) and above cannot run on K210 because of OOM on feature map in master branch. For unstable branch MobileNetV2_1_0 is OK. |
|||
|
|||
- input_size: fixed model input size, single integer for height equals to width, otherwise a list([height, width]). |
|||
- anchors: yolov2 anchor(for master) or anchor scaled to 1.0(for unstable), can be generate by [darknet](https://github.com/AlexeyAB/darknet). |
|||
- labels: labels of all classes. |
|||
- train(valid)_image(annot)_folder: path of images and annoations for training and validation. |
|||
- saved_folder: path for trainig result storage(models, checkpoints, logs ...). |
|||
|
|||
Mine config for unstable: |
|||
```json |
|||
{ |
|||
"model": { |
|||
"type": "Detector", |
|||
"architecture": "MobileNetV2_1_0", |
|||
"input_size": [ |
|||
224, |
|||
320 |
|||
], |
|||
"anchors": [ |
|||
[ |
|||
[ |
|||
0.1043, |
|||
0.1560 |
|||
], |
|||
[ |
|||
0.0839, |
|||
0.3036 |
|||
], |
|||
[ |
|||
0.1109, |
|||
0.3923 |
|||
], |
|||
[ |
|||
0.1378, |
|||
0.5244 |
|||
], |
|||
[ |
|||
0.2049, |
|||
0.6673 |
|||
] |
|||
] |
|||
], |
|||
"labels": [ |
|||
"human" |
|||
], |
|||
"obj_thresh": 0.5, |
|||
"iou_thresh": 0.45, |
|||
"coord_scale": 1.0, |
|||
"class_scale": 0.0, |
|||
"object_scale": 5.0, |
|||
"no_object_scale": 3.0 |
|||
}, |
|||
"weights": { |
|||
"full": "", |
|||
"backend": "" |
|||
}, |
|||
"train": { |
|||
"actual_epoch": 2000, |
|||
"train_image_folder": "mydata/human/Images/train", |
|||
"train_annot_folder": "mydata/human/Annotations/train", |
|||
"train_times": 2, |
|||
"valid_image_folder": "mydata/human/Images/val", |
|||
"valid_annot_folder": "mydata/human/Annotations/val", |
|||
"valid_times": 1, |
|||
"valid_metric": "precision", |
|||
"batch_size": 32, |
|||
"learning_rate": 2e-5, |
|||
"saved_folder": "mydata/human/results", |
|||
"first_trainable_layer": "", |
|||
"augmentation": true, |
|||
"is_only_detect": false, |
|||
"validation_freq": 5, |
|||
"quantize": false, |
|||
"class_weights": [1.0] |
|||
}, |
|||
"converter": { |
|||
"type": [ |
|||
"k210" |
|||
] |
|||
} |
|||
} |
|||
``` |
|||
|
|||
*(For more detailed config usage, please refer to original aXeleRate repo.)* |
|||
|
|||
### data preparation |
|||
|
|||
Please refer to [VOC format](https://towardsdatascience.com/coco-data-format-for-object-detection-a4c5eaf518c5), path as config above. |
|||
|
|||
### train it! |
|||
|
|||
```shell |
|||
python -m aXeleRate.train -c PATH_TO_YOUR_CONFIG |
|||
``` |
|||
|
|||
### model convert |
|||
|
|||
Please refer to [nncase repo](https://github.com/kendryte/nncase/tree/v0.1.0-rc5). |
|||
|
|||
--- |
|||
|
|||
## Deployment |
|||
|
|||
### compile and burn |
|||
|
|||
Use `(scons --)menuconfig` in bsp folder *(Ubiquitous/RT_Thread/bsp/k210)*, open: |
|||
|
|||
- More Drivers --> ov2640 driver |
|||
- Board Drivers Config --> Enable LCD on SPI0 |
|||
- Board Drivers Config --> Enable SDCARD (spi1(ss0)) |
|||
- Board Drivers Config --> Enable DVP(camera) |
|||
- RT-Thread Components --> POSIX layer and C standard library --> Enable pthreads APIs |
|||
- APP_Framework --> Framework --> support knowing framework --> kpu model postprocessing --> yolov2 region layer |
|||
- APP_Framework --> Applications --> knowing app --> enable apps/helmet detect |
|||
|
|||
`scons -j(n)` to compile and burn in by *kflash*. |
|||
|
|||
### json config and kmodel |
|||
|
|||
Copy json config for deployment o SD card */kmodel*. Example config file is *helmet.json* in this directory. Something to be modified: |
|||
|
|||
- net_input_size: same as *input_size* in training config file, but array only. |
|||
- net_output_shape: final feature map size, can be found in **nncase** output. |
|||
- sensor_output_size: image height and width from camera. |
|||
- kmodel_size: kmodel size shown in file system. |
|||
- anchors: same as *anchor* in training config file(multi-dimention anchors flatten to 1 dim). |
|||
- labels: same as *label* in training config file. |
|||
- obj_thresh: array, object threshold of each label. |
|||
- nms_thresh: NMS threshold of boxes. |
|||
|
|||
Copy final kmodel to SD card */kmodel* either. |
|||
|
|||
--- |
|||
|
|||
## Run |
|||
|
|||
In serial terminal, `helmet_detect` to start a detection thread, `helmet_detect_delete` to stop it. Detection results can be found in output. |
|||
|
|||
--- |
|||
|
|||
## TODO |
|||
|
|||
- [ ] Fix LCD real-time result display. |
|||
- [ ] Test more object detection backbone and algorithm(like yolox). |
@ -1,380 +0,0 @@ |
|||
#include <transform.h> |
|||
#ifdef LIB_USING_CJSON |
|||
#include <cJSON.h> |
|||
#endif |
|||
#include "region_layer.h" |
|||
#define ANCHOR_NUM 5 |
|||
#define STACK_SIZE (128 * 1024) |
|||
#define JSON_FILE_PATH "/kmodel/helmet.json" |
|||
#define JSON_BUFFER_SIZE (4 * 1024) |
|||
|
|||
// params from json
|
|||
static float anchor[ANCHOR_NUM * 2] = {}; |
|||
static int net_output_shape[3] = {}; |
|||
static int net_input_size[2] = {}; |
|||
static int sensor_output_size[2] = {}; |
|||
static char kmodel_path[127] = ""; |
|||
static int kmodel_size = 0; |
|||
static float obj_thresh[20] = {}; |
|||
static float nms_thresh = 0.0; |
|||
static char labels[20][32] = {}; |
|||
static int class_num = 0; |
|||
|
|||
#define THREAD_PRIORITY_HELMET_D (11) |
|||
static pthread_t helmettid = 0; |
|||
static void *thread_helmet_detect_entry(void *parameter); |
|||
static int g_fd = 0; |
|||
static int kmodel_fd = 0; |
|||
static int if_exit = 0; |
|||
static unsigned char *showbuffer = NULL; |
|||
static unsigned char *kpurgbbuffer = NULL; |
|||
|
|||
static _ioctl_shoot_para shoot_para_t = {0}; |
|||
unsigned char *model_data = NULL; // kpu data load memory
|
|||
unsigned char *model_data_align = NULL; |
|||
|
|||
kpu_model_context_t helmet_detect_task; |
|||
static region_layer_t helmet_detect_rl; |
|||
static obj_info_t helmet_detect_info; |
|||
volatile uint32_t g_ai_done_flag; |
|||
|
|||
static void ai_done(void *ctx) { g_ai_done_flag = 1; } |
|||
|
|||
static void param_parse() |
|||
{ |
|||
int fin; |
|||
char buffer[JSON_BUFFER_SIZE] = ""; |
|||
// char *buffer;
|
|||
// if (NULL != (buffer = (char*)malloc(JSON_BUFFER_SIZE * sizeof(char)))) {
|
|||
// memset(buffer, 0, JSON_BUFFER_SIZE * sizeof(char));
|
|||
// } else {
|
|||
// printf("Json buffer malloc failed!");
|
|||
// exit(-1);
|
|||
// }
|
|||
int array_size; |
|||
cJSON *json_obj; |
|||
cJSON *json_item; |
|||
cJSON *json_array_item; |
|||
|
|||
fin = open(JSON_FILE_PATH, O_RDONLY); |
|||
if (!fin) { |
|||
printf("Error open file %s", JSON_FILE_PATH); |
|||
exit(-1); |
|||
} |
|||
read(fin, buffer, sizeof(buffer)); |
|||
close(fin); |
|||
|
|||
// read json string
|
|||
json_obj = cJSON_Parse(buffer); |
|||
// free(buffer);
|
|||
char *json_print_str = cJSON_Print(json_obj); |
|||
printf("Json file content: \n%s\n", json_print_str); |
|||
cJSON_free(json_print_str); |
|||
// get anchors
|
|||
json_item = cJSON_GetObjectItem(json_obj, "anchors"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (ANCHOR_NUM * 2 != array_size) { |
|||
printf("Expect anchor size: %d, got %d in json file", ANCHOR_NUM * 2, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d anchors from json file\n", ANCHOR_NUM); |
|||
} |
|||
for (int i = 0; i < ANCHOR_NUM * 2; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
anchor[i] = json_array_item->valuedouble; |
|||
printf("%d: %f\n", i, anchor[i]); |
|||
} |
|||
// net_input_size
|
|||
json_item = cJSON_GetObjectItem(json_obj, "net_input_size"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (2 != array_size) { |
|||
printf("Expect net_input_size: %d, got %d in json file", 2, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d net_input_size from json file\n", 2); |
|||
} |
|||
for (int i = 0; i < 2; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
net_input_size[i] = json_array_item->valueint; |
|||
printf("%d: %d\n", i, net_input_size[i]); |
|||
} |
|||
// net_output_shape
|
|||
json_item = cJSON_GetObjectItem(json_obj, "net_output_shape"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (3 != array_size) { |
|||
printf("Expect net_output_shape: %d, got %d in json file", 3, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d net_output_shape from json file\n", 3); |
|||
} |
|||
for (int i = 0; i < 3; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
net_output_shape[i] = json_array_item->valueint; |
|||
printf("%d: %d\n", i, net_output_shape[i]); |
|||
} |
|||
// sensor_output_size
|
|||
json_item = cJSON_GetObjectItem(json_obj, "sensor_output_size"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (2 != array_size) { |
|||
printf("Expect sensor_output_size: %d, got %d in json file", 2, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d sensor_output_size from json file\n", 2); |
|||
} |
|||
for (int i = 0; i < 2; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
sensor_output_size[i] = json_array_item->valueint; |
|||
printf("%d: %d\n", i, sensor_output_size[i]); |
|||
} |
|||
// kmodel_path
|
|||
json_item = cJSON_GetObjectItem(json_obj, "kmodel_path"); |
|||
memcpy(kmodel_path, json_item->valuestring, strlen(json_item->valuestring)); |
|||
printf("Got kmodel_path: %s\n", kmodel_path); |
|||
// kmodel_size
|
|||
json_item = cJSON_GetObjectItem(json_obj, "kmodel_size"); |
|||
kmodel_size = json_item->valueint; |
|||
printf("Got kmodel_size: %d\n", kmodel_size); |
|||
// labels
|
|||
json_item = cJSON_GetObjectItem(json_obj, "labels"); |
|||
class_num = cJSON_GetArraySize(json_item); |
|||
if (0 >= class_num) { |
|||
printf("No labels!"); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d labels\n", class_num); |
|||
} |
|||
for (int i = 0; i < class_num; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
memcpy(labels[i], json_array_item->valuestring, strlen(json_array_item->valuestring)); |
|||
printf("%d: %s\n", i, labels[i]); |
|||
} |
|||
// obj_thresh
|
|||
json_item = cJSON_GetObjectItem(json_obj, "obj_thresh"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (class_num != array_size) { |
|||
printf("label number and thresh number mismatch! label number : %d, obj thresh number %d", class_num, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d obj_thresh\n", array_size); |
|||
} |
|||
for (int i = 0; i < array_size; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
obj_thresh[i] = json_array_item->valuedouble; |
|||
printf("%d: %f\n", i, obj_thresh[i]); |
|||
} |
|||
// nms_thresh
|
|||
json_item = cJSON_GetObjectItem(json_obj, "nms_thresh"); |
|||
nms_thresh = json_item->valuedouble; |
|||
printf("Got nms_thresh: %f\n", nms_thresh); |
|||
|
|||
cJSON_Delete(json_obj); |
|||
return; |
|||
} |
|||
|
|||
void helmet_detect() |
|||
{ |
|||
int ret = 0; |
|||
int result = 0; |
|||
int size = 0; |
|||
param_parse(); |
|||
g_fd = open("/dev/ov2640", O_RDONLY); |
|||
if (g_fd < 0) { |
|||
printf("open ov2640 fail !!"); |
|||
return; |
|||
} |
|||
_ioctl_set_dvp_reso set_dvp_reso = {sensor_output_size[1], sensor_output_size[0]}; |
|||
ioctl(g_fd, IOCTRL_CAMERA_SET_DVP_RESO, &set_dvp_reso); |
|||
showbuffer = (unsigned char *)malloc(sensor_output_size[0] * sensor_output_size[1] * 2); |
|||
if (NULL == showbuffer) { |
|||
close(g_fd); |
|||
printf("showbuffer apply memory fail !!"); |
|||
return; |
|||
} |
|||
kpurgbbuffer = (unsigned char *)malloc(net_input_size[0] * net_input_size[1] * 3); |
|||
if (NULL == kpurgbbuffer) { |
|||
close(g_fd); |
|||
free(showbuffer); |
|||
printf("kpurgbbuffer apply memory fail !!"); |
|||
return; |
|||
} |
|||
model_data = (unsigned char *)malloc(kmodel_size + 255); |
|||
if (NULL == model_data) { |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
close(g_fd); |
|||
printf("model_data apply memory fail !!"); |
|||
return; |
|||
} |
|||
memset(model_data, 0, kmodel_size + 255); |
|||
memset(showbuffer, 0, sensor_output_size[0] * sensor_output_size[1] * 2); |
|||
memset(kpurgbbuffer, 127, net_input_size[0] * net_input_size[1] * 3); |
|||
shoot_para_t.pdata = (unsigned int *)(showbuffer); |
|||
shoot_para_t.length = (size_t)(sensor_output_size[0] * sensor_output_size[1] * 2); |
|||
/*
|
|||
load memory |
|||
*/ |
|||
kmodel_fd = open(kmodel_path, O_RDONLY); |
|||
if (kmodel_fd < 0) { |
|||
printf("open kmodel fail"); |
|||
close(g_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
return; |
|||
} else { |
|||
size = read(kmodel_fd, model_data, kmodel_size); |
|||
if (size != kmodel_size) { |
|||
printf("read kmodel error size %d\n", size); |
|||
close(g_fd); |
|||
close(kmodel_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
return; |
|||
|
|||
} else { |
|||
printf("read kmodel success \n"); |
|||
} |
|||
} |
|||
unsigned char *model_data_align = (unsigned char *)(((unsigned int)model_data + 255) & (~255)); |
|||
dvp_set_ai_addr((uint32_t)(kpurgbbuffer + net_input_size[1] * (net_input_size[0] - sensor_output_size[0])), |
|||
(uint32_t)(kpurgbbuffer + net_input_size[1] * (net_input_size[0] - sensor_output_size[0]) + |
|||
net_input_size[0] * net_input_size[1]), |
|||
(uint32_t)(kpurgbbuffer + net_input_size[0] * net_input_size[1] * 2 + |
|||
net_input_size[1] * (net_input_size[0] - sensor_output_size[0]))); |
|||
if (kpu_load_kmodel(&helmet_detect_task, model_data_align) != 0) { |
|||
printf("\nmodel init error\n"); |
|||
close(g_fd); |
|||
close(kmodel_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
return; |
|||
} |
|||
helmet_detect_rl.anchor_number = ANCHOR_NUM; |
|||
helmet_detect_rl.anchor = anchor; |
|||
helmet_detect_rl.threshold = malloc(class_num * sizeof(float)); |
|||
for (int idx = 0; idx < class_num; idx++) { |
|||
helmet_detect_rl.threshold[idx] = obj_thresh[idx]; |
|||
} |
|||
helmet_detect_rl.nms_value = nms_thresh; |
|||
result = region_layer_init(&helmet_detect_rl, net_output_shape[0], net_output_shape[1], net_output_shape[2], |
|||
net_input_size[1], net_input_size[0]); |
|||
printf("region_layer_init result %d \n\r", result); |
|||
size_t stack_size = STACK_SIZE; |
|||
pthread_attr_t attr; /* ็บฟ็จๅฑๆง */ |
|||
struct sched_param prio; /* ็บฟ็จไผๅ
็บง */ |
|||
prio.sched_priority = 8; /* ไผๅ
็บง่ฎพ็ฝฎไธบ 8 */ |
|||
pthread_attr_init(&attr); /* ๅ
ไฝฟ็จ้ป่ฎคๅผๅๅงๅๅฑๆง */ |
|||
pthread_attr_setschedparam(&attr, &prio); /* ไฟฎๆนๅฑๆงๅฏนๅบ็ไผๅ
็บง */ |
|||
pthread_attr_setstacksize(&attr, stack_size); |
|||
|
|||
/* ๅๅปบ็บฟ็จ 1, ๅฑๆงไธบ attr๏ผๅ
ฅๅฃๅฝๆฐๆฏ thread_entry๏ผๅ
ฅๅฃๅฝๆฐๅๆฐๆฏ 1 */ |
|||
result = pthread_create(&helmettid, &attr, thread_helmet_detect_entry, NULL); |
|||
if (0 == result) { |
|||
printf("thread_helmet_detect_entry successfully!\n"); |
|||
} else { |
|||
printf("thread_helmet_detect_entry failed! error code is %d\n", result); |
|||
close(g_fd); |
|||
} |
|||
} |
|||
#ifdef __RT_THREAD_H__ |
|||
MSH_CMD_EXPORT(helmet_detect, helmet detect task); |
|||
#endif |
|||
|
|||
static void *thread_helmet_detect_entry(void *parameter) |
|||
{ |
|||
extern void lcd_draw_picture(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, uint32_t * ptr); |
|||
printf("thread_helmet_detect_entry start!\n"); |
|||
int ret = 0; |
|||
// sysctl_enable_irq();
|
|||
while (1) { |
|||
// memset(showbuffer,0,320*240*2);
|
|||
g_ai_done_flag = 0; |
|||
ret = ioctl(g_fd, IOCTRL_CAMERA_START_SHOT, &shoot_para_t); |
|||
if (RT_ERROR == ret) { |
|||
printf("ov2640 can't wait event flag"); |
|||
rt_free(showbuffer); |
|||
close(g_fd); |
|||
pthread_exit(NULL); |
|||
return NULL; |
|||
} |
|||
kpu_run_kmodel(&helmet_detect_task, kpurgbbuffer, DMAC_CHANNEL5, ai_done, NULL); |
|||
while (!g_ai_done_flag) |
|||
; |
|||
float *output; |
|||
size_t output_size; |
|||
kpu_get_output(&helmet_detect_task, 0, (uint8_t **)&output, &output_size); |
|||
helmet_detect_rl.input = output; |
|||
region_layer_run(&helmet_detect_rl, &helmet_detect_info); |
|||
/* display result */ |
|||
#ifdef BSP_USING_LCD |
|||
for (int helmet_cnt = 0; helmet_cnt < helmet_detect_info.obj_number; helmet_cnt++) { |
|||
// draw_edge((uint32_t *)showbuffer, &helmet_detect_info, helmet_cnt, 0xF800,
|
|||
// (uint16_t)sensor_output_size[1],
|
|||
// (uint16_t)sensor_output_size[0]);
|
|||
printf("%d: (%d, %d, %d, %d) cls: %s conf: %f\t", helmet_cnt, helmet_detect_info.obj[helmet_cnt].x1, |
|||
helmet_detect_info.obj[helmet_cnt].y1, helmet_detect_info.obj[helmet_cnt].x2, |
|||
helmet_detect_info.obj[helmet_cnt].y2, labels[helmet_detect_info.obj[helmet_cnt].class_id], |
|||
helmet_detect_info.obj[helmet_cnt].prob); |
|||
} |
|||
if (0 != helmet_detect_info.obj_number) { |
|||
printf("\n"); |
|||
} |
|||
lcd_draw_picture(0, 0, (uint16_t)sensor_output_size[1], (uint16_t)sensor_output_size[0], (unsigned int *)showbuffer); |
|||
#endif |
|||
usleep(1); |
|||
if (1 == if_exit) { |
|||
if_exit = 0; |
|||
printf("thread_helmet_detect_entry exit"); |
|||
pthread_exit(NULL); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void helmet_detect_delete() |
|||
{ |
|||
if (showbuffer != NULL) { |
|||
int ret = 0; |
|||
close(g_fd); |
|||
close(kmodel_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
printf("helmet detect task cancel!!! ret %d ", ret); |
|||
if_exit = 1; |
|||
} |
|||
} |
|||
#ifdef __RT_THREAD_H__ |
|||
MSH_CMD_EXPORT(helmet_detect_delete, helmet detect task delete); |
|||
#endif |
|||
|
|||
void kmodel_load(unsigned char *model_data) |
|||
{ |
|||
int kmodel_fd = 0; |
|||
int size = 0; |
|||
kmodel_fd = open(kmodel_path, O_RDONLY); |
|||
|
|||
model_data = (unsigned char *)malloc(kmodel_size + 255); |
|||
if (NULL == model_data) { |
|||
printf("model_data apply memory fail !!"); |
|||
return; |
|||
} |
|||
memset(model_data, 0, kmodel_size + 255); |
|||
|
|||
if (kmodel_fd >= 0) { |
|||
size = read(kmodel_fd, model_data, kmodel_size); |
|||
if (size != kmodel_size) { |
|||
printf("read kmodel error size %d\n", size); |
|||
|
|||
} else { |
|||
printf("read kmodel success"); |
|||
} |
|||
} else { |
|||
free(model_data); |
|||
printf("open kmodel fail"); |
|||
} |
|||
} |
|||
#ifdef __RT_THREAD_H__ |
|||
MSH_CMD_EXPORT(kmodel_load, kmodel load memory); |
|||
#endif |
@ -1,6 +1,6 @@ |
|||
menuconfig USING_IMAGE_PROCESSING_APP |
|||
bool "image processing app " |
|||
default n |
|||
if USING_IMAGE_PROCESSING_APP |
|||
source "$APP_DIR/Applications/knowing_app/image_processing/TJpgDec_APP/Kconfig" |
|||
endif |
|||
menuconfig USING_IMAGE_PROCESSING_APP |
|||
bool "image processing app " |
|||
default n |
|||
if USING_IMAGE_PROCESSING_APP |
|||
source "$APP_DIR/Applications/knowing_app/image_processing/TJpgDec_APP/Kconfig" |
|||
endif |
|||
|
@ -1,4 +1,4 @@ |
|||
config IMAGE_PROCESSING_TJPGDEC_APP |
|||
bool "image processing apps/TJpgDec(example)" |
|||
select IMAGE_PROCESSING_USING_TJPGD |
|||
default n |
|||
config IMAGE_PROCESSING_TJPGDEC_APP |
|||
bool "image processing apps/TJpgDec(example)" |
|||
select IMAGE_PROCESSING_USING_TJPGD |
|||
default n |
|||
|
@ -1,8 +0,0 @@ |
|||
config INSTRUSION_DETECT |
|||
bool "enable apps/instrusion detect" |
|||
depends on BOARD_K210_EVB |
|||
depends on DRV_USING_OV2640 |
|||
depends on USING_KPU_POSTPROCESSING |
|||
depends on USING_YOLOV2 |
|||
select LIB_USING_CJSON |
|||
default n |
@ -1,5 +0,0 @@ |
|||
# Instrusion detect demo |
|||
|
|||
### A human object detection task demo. Running MobileNet-yolo on K210-based edge devices. |
|||
|
|||
***Training, deployment and running, please see helmet_detect*** |
@ -1,9 +0,0 @@ |
|||
from building import * |
|||
|
|||
cwd = GetCurrentDir() |
|||
src = Glob('*.c') + Glob('*.cpp') |
|||
CPPPATH = [cwd] |
|||
|
|||
group = DefineGroup('Applications', src, depend = ['INSTRUSION_DETECT'], LOCAL_CPPPATH = CPPPATH) |
|||
|
|||
Return('group') |
@ -1,390 +0,0 @@ |
|||
#include <transform.h> |
|||
#include <unistd.h> |
|||
#ifdef LIB_USING_CJSON |
|||
#include <cJSON.h> |
|||
#endif |
|||
#include "region_layer.h" |
|||
#define ANCHOR_NUM 5 |
|||
#define STACK_SIZE (128 * 1024) |
|||
#define JSON_FILE_PATH "/kmodel/human.json" |
|||
#define JSON_BUFFER_SIZE (4 * 1024) |
|||
static dmac_channel_number_t dma_ch = DMAC_CHANNEL_MAX; |
|||
|
|||
extern void lcd_show_image(int x, int y, int wide, int height,const rt_uint8_t *buf); |
|||
// params from json
|
|||
static float anchor[ANCHOR_NUM * 2] = {}; |
|||
static int net_output_shape[3] = {}; |
|||
static int net_input_size[2] = {}; |
|||
static int sensor_output_size[2] = {}; |
|||
static char kmodel_path[127] = ""; |
|||
static int kmodel_size = 0; |
|||
static float obj_thresh[20] = {}; |
|||
static float nms_thresh = 0.0; |
|||
static char labels[20][32] = {}; |
|||
static int class_num = 0; |
|||
|
|||
#define THREAD_PRIORITY_HUMAN_D (11) |
|||
static pthread_t instrusiontid = 0; |
|||
static void *thread_instrusion_detect_entry(void *parameter); |
|||
static int g_fd = 0; |
|||
static int kmodel_fd = 0; |
|||
static int if_exit = 0; |
|||
static unsigned char *showbuffer = NULL; |
|||
static unsigned char *kpurgbbuffer = NULL; |
|||
|
|||
static _ioctl_shoot_para shoot_para_t = {0}; |
|||
unsigned char *model_data = NULL; // kpu data load memory
|
|||
unsigned char *model_data_align = NULL; |
|||
|
|||
kpu_model_context_t instrusion_detect_task; |
|||
static region_layer_t instrusion_detect_rl; |
|||
static obj_info_t instrusion_detect_info; |
|||
volatile uint32_t g_ai_done_flag; |
|||
|
|||
static void ai_done(void *ctx) { g_ai_done_flag = 1; } |
|||
|
|||
static void param_parse() |
|||
{ |
|||
int fin; |
|||
char buffer[JSON_BUFFER_SIZE] = ""; |
|||
// char *buffer;
|
|||
// if (NULL != (buffer = (char*)malloc(JSON_BUFFER_SIZE * sizeof(char)))) {
|
|||
// memset(buffer, 0, JSON_BUFFER_SIZE * sizeof(char));
|
|||
// } else {
|
|||
// printf("Json buffer malloc failed!");
|
|||
// exit(-1);
|
|||
// }
|
|||
int array_size; |
|||
cJSON *json_obj; |
|||
cJSON *json_item; |
|||
cJSON *json_array_item; |
|||
|
|||
fin = open(JSON_FILE_PATH, O_RDONLY); |
|||
if (!fin) { |
|||
printf("Error open file %s", JSON_FILE_PATH); |
|||
exit(-1); |
|||
} |
|||
read(fin, buffer, sizeof(buffer)); |
|||
close(fin); |
|||
|
|||
// read json string
|
|||
json_obj = cJSON_Parse(buffer); |
|||
// free(buffer);
|
|||
char *json_print_str = cJSON_Print(json_obj); |
|||
printf("Json file content: \n%s\n", json_print_str); |
|||
cJSON_free(json_print_str); |
|||
// get anchors
|
|||
json_item = cJSON_GetObjectItem(json_obj, "anchors"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (ANCHOR_NUM * 2 != array_size) { |
|||
printf("Expect anchor size: %d, got %d in json file", ANCHOR_NUM * 2, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d anchors from json file\n", ANCHOR_NUM); |
|||
} |
|||
for (int i = 0; i < ANCHOR_NUM * 2; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
anchor[i] = json_array_item->valuedouble; |
|||
printf("%d: %f\n", i, anchor[i]); |
|||
} |
|||
// net_input_size
|
|||
json_item = cJSON_GetObjectItem(json_obj, "net_input_size"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (2 != array_size) { |
|||
printf("Expect net_input_size: %d, got %d in json file", 2, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d net_input_size from json file\n", 2); |
|||
} |
|||
for (int i = 0; i < 2; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
net_input_size[i] = json_array_item->valueint; |
|||
printf("%d: %d\n", i, net_input_size[i]); |
|||
} |
|||
// net_output_shape
|
|||
json_item = cJSON_GetObjectItem(json_obj, "net_output_shape"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (3 != array_size) { |
|||
printf("Expect net_output_shape: %d, got %d in json file", 3, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d net_output_shape from json file\n", 3); |
|||
} |
|||
for (int i = 0; i < 3; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
net_output_shape[i] = json_array_item->valueint; |
|||
printf("%d: %d\n", i, net_output_shape[i]); |
|||
} |
|||
// sensor_output_size
|
|||
json_item = cJSON_GetObjectItem(json_obj, "sensor_output_size"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (2 != array_size) { |
|||
printf("Expect sensor_output_size: %d, got %d in json file", 2, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d sensor_output_size from json file\n", 2); |
|||
} |
|||
for (int i = 0; i < 2; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
sensor_output_size[i] = json_array_item->valueint; |
|||
printf("%d: %d\n", i, sensor_output_size[i]); |
|||
} |
|||
// kmodel_path
|
|||
json_item = cJSON_GetObjectItem(json_obj, "kmodel_path"); |
|||
memcpy(kmodel_path, json_item->valuestring, strlen(json_item->valuestring)); |
|||
printf("Got kmodel_path: %s\n", kmodel_path); |
|||
// kmodel_size
|
|||
json_item = cJSON_GetObjectItem(json_obj, "kmodel_size"); |
|||
kmodel_size = json_item->valueint; |
|||
printf("Got kmodel_size: %d\n", kmodel_size); |
|||
// labels
|
|||
json_item = cJSON_GetObjectItem(json_obj, "labels"); |
|||
class_num = cJSON_GetArraySize(json_item); |
|||
if (0 >= class_num) { |
|||
printf("No labels!"); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d labels\n", class_num); |
|||
} |
|||
for (int i = 0; i < class_num; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
memcpy(labels[i], json_array_item->valuestring, strlen(json_array_item->valuestring)); |
|||
printf("%d: %s\n", i, labels[i]); |
|||
} |
|||
// obj_thresh
|
|||
json_item = cJSON_GetObjectItem(json_obj, "obj_thresh"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (class_num != array_size) { |
|||
printf("label number and thresh number mismatch! label number : %d, obj thresh number %d", class_num, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d obj_thresh\n", array_size); |
|||
} |
|||
for (int i = 0; i < array_size; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
obj_thresh[i] = json_array_item->valuedouble; |
|||
printf("%d: %f\n", i, obj_thresh[i]); |
|||
} |
|||
// nms_thresh
|
|||
json_item = cJSON_GetObjectItem(json_obj, "nms_thresh"); |
|||
nms_thresh = json_item->valuedouble; |
|||
printf("Got nms_thresh: %f\n", nms_thresh); |
|||
|
|||
cJSON_Delete(json_obj); |
|||
return; |
|||
} |
|||
|
|||
void instrusion_detect() |
|||
{ |
|||
int ret = 0; |
|||
int result = 0; |
|||
int size = 0; |
|||
param_parse(); |
|||
g_fd = open("/dev/ov2640", O_RDONLY); |
|||
if (g_fd < 0) { |
|||
printf("open ov2640 fail !!"); |
|||
return; |
|||
} |
|||
_ioctl_set_dvp_reso set_dvp_reso = {sensor_output_size[1], sensor_output_size[0]}; |
|||
ioctl(g_fd, IOCTRL_CAMERA_SET_DVP_RESO, &set_dvp_reso); |
|||
showbuffer = (unsigned char *)rt_malloc_align(sensor_output_size[0] * sensor_output_size[1] * 2,64); |
|||
if (NULL == showbuffer) { |
|||
close(g_fd); |
|||
printf("showbuffer apply memory fail !!"); |
|||
return; |
|||
} |
|||
kpurgbbuffer = (unsigned char *)rt_malloc_align(net_input_size[0] * net_input_size[1] * 3,64); |
|||
if (NULL == kpurgbbuffer) { |
|||
close(g_fd); |
|||
rt_free_align(showbuffer); |
|||
printf("kpurgbbuffer apply memory fail !!"); |
|||
return; |
|||
} |
|||
model_data = (unsigned char *)malloc(kmodel_size + 255); |
|||
if (NULL == model_data) { |
|||
rt_free_align(showbuffer); |
|||
rt_free_align(kpurgbbuffer); |
|||
close(g_fd); |
|||
printf("model_data apply memory fail !!"); |
|||
return; |
|||
} |
|||
memset(model_data, 0, kmodel_size + 255); |
|||
memset(showbuffer, 0, sensor_output_size[0] * sensor_output_size[1] * 2); |
|||
memset(kpurgbbuffer, 127, net_input_size[0] * net_input_size[1] * 3); |
|||
shoot_para_t.pdata = (unsigned int *)(showbuffer); |
|||
shoot_para_t.length = (size_t)(sensor_output_size[0] * sensor_output_size[1] * 2); |
|||
/*
|
|||
load memory |
|||
*/ |
|||
kmodel_fd = open(kmodel_path, O_RDONLY); |
|||
if (kmodel_fd < 0) { |
|||
printf("open kmodel fail"); |
|||
close(g_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
return; |
|||
} else { |
|||
size = read(kmodel_fd, model_data, kmodel_size); |
|||
if (size != kmodel_size) { |
|||
printf("read kmodel error size %d\n", size); |
|||
close(g_fd); |
|||
close(kmodel_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
return; |
|||
|
|||
} else { |
|||
printf("read kmodel success \n"); |
|||
} |
|||
} |
|||
unsigned char *model_data_align = (unsigned char *)(((unsigned int)model_data + 255) & (~255)); |
|||
dvp_set_ai_addr((uint32_t)(kpurgbbuffer + net_input_size[1] * (net_input_size[0] - sensor_output_size[0])), |
|||
(uint32_t)(kpurgbbuffer + net_input_size[1] * (net_input_size[0] - sensor_output_size[0]) + |
|||
net_input_size[0] * net_input_size[1]), |
|||
(uint32_t)(kpurgbbuffer + net_input_size[0] * net_input_size[1] * 2 + |
|||
net_input_size[1] * (net_input_size[0] - sensor_output_size[0]))); |
|||
if (kpu_load_kmodel(&instrusion_detect_task, model_data_align) != 0) { |
|||
printf("\nmodel init error\n"); |
|||
close(g_fd); |
|||
close(kmodel_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
return; |
|||
} |
|||
instrusion_detect_rl.anchor_number = ANCHOR_NUM; |
|||
instrusion_detect_rl.anchor = anchor; |
|||
instrusion_detect_rl.threshold = malloc(class_num * sizeof(float)); |
|||
for (int idx = 0; idx < class_num; idx++) { |
|||
instrusion_detect_rl.threshold[idx] = obj_thresh[idx]; |
|||
} |
|||
instrusion_detect_rl.nms_value = nms_thresh; |
|||
result = region_layer_init(&instrusion_detect_rl, net_output_shape[0], net_output_shape[1], net_output_shape[2], |
|||
net_input_size[1], net_input_size[0]); |
|||
printf("region_layer_init result %d \n\r", result); |
|||
size_t stack_size = STACK_SIZE; |
|||
pthread_attr_t attr; /* ็บฟ็จๅฑๆง */ |
|||
struct sched_param prio; /* ็บฟ็จไผๅ
็บง */ |
|||
prio.sched_priority = 8; /* ไผๅ
็บง่ฎพ็ฝฎไธบ 8 */ |
|||
pthread_attr_init(&attr); /* ๅ
ไฝฟ็จ้ป่ฎคๅผๅๅงๅๅฑๆง */ |
|||
pthread_attr_setschedparam(&attr, &prio); /* ไฟฎๆนๅฑๆงๅฏนๅบ็ไผๅ
็บง */ |
|||
pthread_attr_setstacksize(&attr, stack_size); |
|||
|
|||
/* ๅๅปบ็บฟ็จ 1, ๅฑๆงไธบ attr๏ผๅ
ฅๅฃๅฝๆฐๆฏ thread_entry๏ผๅ
ฅๅฃๅฝๆฐๅๆฐๆฏ 1 */ |
|||
result = pthread_create(&instrusiontid, &attr, thread_instrusion_detect_entry, NULL); |
|||
if (0 == result) { |
|||
printf("thread_instrusion_detect_entry successfully!\n"); |
|||
} else { |
|||
printf("thread_instrusion_detect_entry failed! error code is %d\n", result); |
|||
close(g_fd); |
|||
} |
|||
} |
|||
#ifdef __RT_THREAD_H__ |
|||
MSH_CMD_EXPORT(instrusion_detect, instrusion detect task); |
|||
#endif |
|||
extern void lcd_draw_picture(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, uint32_t * ptr); |
|||
extern void lcd_show_image(int x, int y, int wide, int height,const rt_uint8_t *buf); |
|||
extern void lcd_draw_16_picture(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, uint32_t * ptr); |
|||
|
|||
static void *thread_instrusion_detect_entry(void *parameter) |
|||
{ |
|||
printf("thread_instrusion_detect_entry start!\n"); |
|||
int ret = 0; |
|||
// sysctl_enable_irq();
|
|||
while (1) { |
|||
// memset(showbuffer,0,320*240*2);
|
|||
g_ai_done_flag = 0; |
|||
ret = ioctl(g_fd, IOCTRL_CAMERA_START_SHOT, &shoot_para_t); |
|||
if (RT_ERROR == ret) { |
|||
printf("ov2640 can't wait event flag"); |
|||
rt_free(showbuffer); |
|||
close(g_fd); |
|||
pthread_exit(NULL); |
|||
return NULL; |
|||
} |
|||
if (dmalock_sync_take(&dma_ch, 2000)) |
|||
{ |
|||
printf("Fail to take DMA channel"); |
|||
} |
|||
kpu_run_kmodel(&instrusion_detect_task, kpurgbbuffer, DMAC_CHANNEL5, ai_done, NULL); |
|||
while (!g_ai_done_flag) |
|||
; |
|||
dmalock_release(dma_ch); |
|||
float *output; |
|||
size_t output_size; |
|||
kpu_get_output(&instrusion_detect_task, 0, (uint8_t **)&output, &output_size); |
|||
instrusion_detect_rl.input = output; |
|||
region_layer_run(&instrusion_detect_rl, &instrusion_detect_info); |
|||
/* display result */ |
|||
for (int instrusion_cnt = 0; instrusion_cnt < instrusion_detect_info.obj_number; instrusion_cnt++) |
|||
{ |
|||
draw_edge((uint32_t *)showbuffer, &instrusion_detect_info, instrusion_cnt, 0xF800,(uint16_t)sensor_output_size[1],(uint16_t)sensor_output_size[0]); |
|||
printf("%d: (%d, %d, %d, %d) cls: %s conf: %f\t", instrusion_cnt, instrusion_detect_info.obj[instrusion_cnt].x1, |
|||
instrusion_detect_info.obj[instrusion_cnt].y1, instrusion_detect_info.obj[instrusion_cnt].x2, |
|||
instrusion_detect_info.obj[instrusion_cnt].y2, labels[instrusion_detect_info.obj[instrusion_cnt].class_id], |
|||
instrusion_detect_info.obj[instrusion_cnt].prob); |
|||
} |
|||
#ifdef BSP_USING_LCD |
|||
//lcd_show_image(0, 0,(uint16_t)sensor_output_size[1], (uint16_t)sensor_output_size[0],(unsigned int *)showbuffer);
|
|||
lcd_draw_picture(0, 0, (uint16_t)sensor_output_size[1], (uint16_t)sensor_output_size[0], (uint32_t *)showbuffer); |
|||
#endif |
|||
if (0 != instrusion_detect_info.obj_number) { |
|||
printf("\n"); |
|||
} |
|||
usleep(1); |
|||
if (1 == if_exit) { |
|||
if_exit = 0; |
|||
printf("thread_instrusion_detect_entry exit"); |
|||
pthread_exit(NULL); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void instrusion_detect_delete() |
|||
{ |
|||
if (showbuffer != NULL) { |
|||
int ret = 0; |
|||
close(g_fd); |
|||
close(kmodel_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
printf("instrusion detect task cancel!!! ret %d ", ret); |
|||
if_exit = 1; |
|||
} |
|||
} |
|||
#ifdef __RT_THREAD_H__ |
|||
MSH_CMD_EXPORT(instrusion_detect_delete, instrusion detect task delete); |
|||
#endif |
|||
|
|||
void kmodel_load(unsigned char *model_data) |
|||
{ |
|||
int kmodel_fd = 0; |
|||
int size = 0; |
|||
kmodel_fd = open(kmodel_path, O_RDONLY); |
|||
|
|||
model_data = (unsigned char *)malloc(kmodel_size + 255); |
|||
if (NULL == model_data) { |
|||
printf("model_data apply memory fail !!"); |
|||
return; |
|||
} |
|||
memset(model_data, 0, kmodel_size + 255); |
|||
|
|||
if (kmodel_fd >= 0) { |
|||
size = read(kmodel_fd, model_data, kmodel_size); |
|||
if (size != kmodel_size) { |
|||
printf("read kmodel error size %d\n", size); |
|||
|
|||
} else { |
|||
printf("read kmodel success"); |
|||
} |
|||
} else { |
|||
free(model_data); |
|||
printf("open kmodel fail"); |
|||
} |
|||
} |
|||
#ifdef __RT_THREAD_H__ |
|||
MSH_CMD_EXPORT(kmodel_load, kmodel load memory); |
|||
#endif |