developer/xiuos
1
0
Fork 0
forked from xuos/xiuos
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(knowing app): add common k210 yolov2 detection procedure

Browse Source
This commit is contained in:
yangtuo250
2021-12-08 08:38:05 +00:00
parent d368db9e76
commit c07c918150
29 changed files with 148 additions and 1069 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
APP_Framework/Framework/knowing/kpu/Kconfig
View File

@@ -4,4 +4,5 @@ menuconfig USING_KPU_PROCESSING
if USING_KPU_PROCESSING
source "$APP_DIR/Framework/knowing/kpu/yolov2/Kconfig"
source "$APP_DIR/Framework/knowing/kpu/yolov2_json/Kconfig"
source "$APP_DIR/Framework/knowing/kpu/k210_detect_procedure/Kconfig"
endif

7
APP_Framework/Framework/knowing/kpu/k210_detect_procedure/Kconfig Normal file
View File

@@ -0,0 +1,7 @@
menuconfig USING_K210_DETECT
bool "k210 yolov2 detect procedure"
depends on USING_KPU_PROCESSING
default n

10
APP_Framework/Framework/knowing/kpu/k210_detect_procedure/SConscript Normal file
View File

@@ -0,0 +1,10 @@
from building import *
import os
cwd = GetCurrentDir()
src = Glob('*.c')
group = DefineGroup('k210_detect_procedure', src, depend = ['USING_YOLOV2', 'USING_YOLOV2_JSONPARSER', 'USING_KPU_PROCESSING'], CPPPATH = [cwd])
Return('group')

243
APP_Framework/Framework/knowing/kpu/k210_detect_procedure/k210_detect.c Normal file
View File

@@ -0,0 +1,243 @@
#include "k210_detect.h"
#include "cJSON.h"
#ifdef USING_YOLOV2_JSONPARSER
#include <json_parser.h>
#endif
#include "region_layer.h"
#define STACK_SIZE (128 * 1024)
static dmac_channel_number_t dma_ch = DMAC_CHANNEL_MAX;
#define THREAD_PRIORITY_D (11)
static pthread_t tid = 0;
static void *thread_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 detect_task;
static region_layer_t detect_rl;
static obj_info_t detect_info;
volatile uint32_t g_ai_done_flag;
static void ai_done(void *ctx) { g_ai_done_flag = 1; }
void k210_detect(char *json_file_path)
{
int ret = 0;
int result = 0;
int size = 0;
yolov2_params_t detect_params = param_parse(json_file_path);
g_fd = open("/dev/ov2640", O_RDONLY);
if (g_fd < 0) {
printf("open ov2640 fail !!");
return;
}
_ioctl_set_dvp_reso set_dvp_reso = {detect_params.sensor_output_size[1], detect_params.sensor_output_size[0]};
ioctl(g_fd, IOCTRL_CAMERA_SET_DVP_RESO, &set_dvp_reso);
showbuffer =
(unsigned char *)rt_malloc_align(detect_params.sensor_output_size[0] * detect_params.sensor_output_size[1] * 2, 64);
if (NULL == showbuffer) {
close(g_fd);
printf("showbuffer apply memory fail !!");
return;
}
kpurgbbuffer = (unsigned char *)rt_malloc_align(detect_params.net_input_size[0] * detect_params.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(detect_params.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, detect_params.kmodel_size + 255);
memset(showbuffer, 0, detect_params.sensor_output_size[0] * detect_params.sensor_output_size[1] * 2);
memset(kpurgbbuffer, 0, detect_params.net_input_size[0] * detect_params.net_input_size[1] * 3);
shoot_para_t.pdata = (unsigned int *)(showbuffer);
shoot_para_t.length = (size_t)(detect_params.sensor_output_size[0] * detect_params.sensor_output_size[1] * 2);
/*
load memory
*/
printf("%s\n", detect_params.kmodel_path);
kmodel_fd = open(detect_params.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, detect_params.kmodel_size);
if (size != detect_params.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 + detect_params.net_input_size[0] * detect_params.net_input_size[1]),
(uint32_t)(kpurgbbuffer + detect_params.net_input_size[0] * detect_params.net_input_size[1] * 2));
if (kpu_load_kmodel(&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;
}
detect_rl.anchor_number = ANCHOR_NUM;
detect_rl.anchor = detect_params.anchor;
detect_rl.threshold = malloc(detect_params.class_num * sizeof(float));
for (int idx = 0; idx < detect_params.class_num; idx++) {
detect_rl.threshold[idx] = detect_params.obj_thresh[idx];
}
detect_rl.nms_value = detect_params.nms_thresh;
result =
region_layer_init(&detect_rl, detect_params.net_output_shape[0], detect_params.net_output_shape[1],
detect_params.net_output_shape[2], detect_params.net_input_size[1], detect_params.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(&tid, &attr, thread_detect_entry, &detect_params);
if (0 == result) {
printf("thread_detect_entry successfully!\n");
} else {
printf("thread_detect_entry failed! error code is %d\n", result);
close(g_fd);
}
}
// #ifdef __RT_THREAD_H__
// MSH_CMD_EXPORT(detect, detect task);
// #endif
static void *thread_detect_entry(void *parameter)
{
yolov2_params_t detect_params = *(yolov2_params_t *)parameter;
extern void lcd_draw_picture(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, uint32_t * ptr);
printf("thread_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(&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(&detect_task, 0, (uint8_t **)&output, &output_size);
detect_rl.input = output;
region_layer_run(&detect_rl, &detect_info);
/* display result */
for (int cnt = 0; cnt < detect_info.obj_number; cnt++) {
draw_edge((uint32_t *)showbuffer, &detect_info, cnt, 0xF800, (uint16_t)detect_params.sensor_output_size[1],
(uint16_t)detect_params.sensor_output_size[0]);
printf("%d: (%d, %d, %d, %d) cls: %s conf: %f\t", cnt, detect_info.obj[cnt].x1, detect_info.obj[cnt].y1,
detect_info.obj[cnt].x2, detect_info.obj[cnt].y2, detect_params.labels[detect_info.obj[cnt].class_id],
detect_info.obj[cnt].prob);
}
#ifdef BSP_USING_LCD
lcd_draw_picture(0, 0, (uint16_t)detect_params.sensor_output_size[1], (uint16_t)detect_params.sensor_output_size[0],
(uint32_t *)showbuffer);
// lcd_show_image(0, 0, (uint16_t)detect_params.sensor_output_size[1], (uint16_t)detect_params.sensor_output_size[0],
// (unsigned int *)showbuffer);
#endif
usleep(500);
if (1 == if_exit) {
if_exit = 0;
printf("thread_detect_entry exit");
pthread_exit(NULL);
}
}
}
void detect_delete()
{
if (showbuffer != NULL) {
int ret = 0;
close(g_fd);
close(kmodel_fd);
free(showbuffer);
free(kpurgbbuffer);
free(model_data);
printf("detect task cancel!!! ret %d ", ret);
if_exit = 1;
}
}
// #ifdef __RT_THREAD_H__
// MSH_CMD_EXPORT(detect_delete, detect task delete);
// #endif
// void kmodel_load(unsigned char *model_data)
// {
// int kmodel_fd = 0;
// int size = 0;
// kmodel_fd = open(detect_params.kmodel_path, O_RDONLY);
// model_data = (unsigned char *)malloc(detect_params.kmodel_size + 255);
// if (NULL == model_data) {
// printf("model_data apply memory fail !!");
// return;
// }
// memset(model_data, 0, detect_params.kmodel_size + 255);
// if (kmodel_fd >= 0) {
// size = read(kmodel_fd, model_data, detect_params.kmodel_size);
// if (size != detect_params.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

8
APP_Framework/Framework/knowing/kpu/k210_detect_procedure/k210_detect.h Normal file
View File

@@ -0,0 +1,8 @@
#ifndef _K210_DETECT_H_
#define _K210_DETECT_H_
#include <transform.h>
void k210_detect(char *json_file_path);
#endif

2
APP_Framework/Framework/knowing/kpu/yolov2_json/SConscript
View File

@@ -5,6 +5,6 @@ cwd = GetCurrentDir()
src = Glob('*.c')
group = DefineGroup('yolov2_json', src, depend = ['USING_YOLOV2_JSONPARSER', 'LIB_USING_CJSON'], CPPPATH = [cwd])
group = DefineGroup('yolov2_json', src, depend = ['LIB_USING_CJSON'], CPPPATH = [cwd])
Return('group')

2
APP_Framework/Framework/knowing/kpu/yolov2_json/json_parser.c
View File

@@ -93,6 +93,7 @@ yolov2_params_t param_parse(char *json_file_path)
}
// kmodel_path
json_item = cJSON_GetObjectItem(json_obj, "kmodel_path");
memset(params_return.kmodel_path, 0, 127);
memcpy(params_return.kmodel_path, json_item->valuestring, strlen(json_item->valuestring));
printf("Got kmodel_path: %s\n", params_return.kmodel_path);
// kmodel_size
@@ -110,6 +111,7 @@ yolov2_params_t param_parse(char *json_file_path)
}
for (int i = 0; i < params_return.class_num; i++) {
json_array_item = cJSON_GetArrayItem(json_item, i);
memset(params_return.labels[i], 0, 127);
memcpy(params_return.labels[i], json_array_item->valuestring, strlen(json_array_item->valuestring));
printf("%d: %s\n", i, params_return.labels[i]);
}