Embedded/pikapython
1
0
Fork 0
mirror of https://gitee.com/Lyon1998/pikapython.git synced 2025-01-29 17:22:56 +08:00
Code Issues Packages Projects Releases Wiki Activity

support cq for evnet, get res from event

Browse Source
This commit is contained in:
lyon 2022-11-05 12:34:18 +08:00
parent 98d43550ef
commit 85ece20f4c
8 changed files with 110 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
port/linux/package/pikascript/pikascript-lib/TemplateDevice/TemplateDevice_GPIO.c
View File

@ -15,13 +15,14 @@ void TemplateDevice_GPIO_platformGetEventId(PikaObj* self) {
} }
} }
extern PikaEventListener* g_pika_device_event_listener; extern PikaEventListener* g_pika_device_event_listener;
#define EVENT_SIGAL_IO_RISING_EDGE 0x01 #define EVENT_SIGNAL_IO_RISING_EDGE 0x01
#define EVENT_SIGAL_IO_FALLING_EDGE 0x02 #define EVENT_SIGNAL_IO_FALLING_EDGE 0x02
#define GPIO_PA8_EVENT_ID 0x08 #define GPIO_PA8_EVENT_ID 0x08
void TemplateDevice_GPIO_eventTest(PikaObj *self){ void TemplateDevice_GPIO_eventTest(PikaObj* self) {
pks_eventLisener_sendSignal(g_pika_device_event_listener, GPIO_PA8_EVENT_ID, pks_eventLisener_sendSignal(g_pika_device_event_listener, GPIO_PA8_EVENT_ID,
EVENT_SIGAL_IO_FALLING_EDGE); EVENT_SIGNAL_IO_FALLING_EDGE);
pks_eventLisener_sendSignal(g_pika_device_event_listener, GPIO_PA8_EVENT_ID,
EVENT_SIGNAL_IO_RISING_EDGE);
} }

46
src/PikaObj.c
View File

@ -1427,40 +1427,50 @@ void pks_eventLisener_deinit(PikaEventListener** p_self) {
} }
} }
void __eventLisener_runEvent(PikaObj* eventHandleObj) { Arg* __eventLisener_runEvent(PikaEventListener* lisener,
uint32_t eventId,
int eventSignal) {
PikaObj* handler = pks_eventLisener_getEventHandleObj(lisener, eventId);
if (NULL == handler) {
__platform_printf(
"Error: can not find event handler by id: [0x%02x]\r\n", eventId);
return NULL;
}
obj_setInt(handler, "eventSignal", eventSignal);
/* clang-format off */ /* clang-format off */
PIKA_PYTHON( PIKA_PYTHON(
eventCallBack(eventSignal) _res = eventCallBack(eventSignal)
) )
/* clang-format on */ /* clang-format on */
const uint8_t bytes[] = { const uint8_t bytes[] = {
0x08, 0x00, 0x00, 0x00, /* instruct array size */ 0x0c, 0x00, 0x00, 0x00, /* instruct array size */
0x10, 0x81, 0x01, 0x00, 0x00, 0x02, 0x0d, 0x00, /* instruct array */ 0x10, 0x81, 0x01, 0x00, 0x00, 0x02, 0x0d, 0x00, 0x00, 0x04, 0x1b, 0x00,
0x1b, 0x00, 0x00, 0x00, /* const pool size */ /* instruct array */
0x00, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x69, 0x67, 0x20, 0x00, 0x00, 0x00, /* const pool size */
0x6e, 0x61, 0x6c, 0x00, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x00, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c,
0x43, 0x61, 0x6c, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x00, /* const pool */ 0x00, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x43, 0x61, 0x6c, 0x6c, 0x42, 0x61,
0x63, 0x6b, 0x00, 0x5f, 0x72, 0x65, 0x73, 0x00, /* const pool */
}; };
pikaVM_runByteCode(eventHandleObj, (uint8_t*)bytes); pikaVM_runByteCode(handler, (uint8_t*)bytes);
Arg* res = obj_getArg(handler, "_res");
res = arg_copy(res);
obj_removeArg(handler, "_res");
return res;
} }
void pks_eventLisener_sendSignal(PikaEventListener* self, void pks_eventLisener_sendSignal(PikaEventListener* self,
uint32_t eventId, uint32_t eventId,
int eventSignal) { int eventSignal) {
PikaObj* eventHandleObj = pks_eventLisener_getEventHandleObj(self, eventId);
if (NULL == eventHandleObj) {
__platform_printf(
"Error: can not find event handler by id: [0x%02x]\r\n", eventId);
return;
}
obj_setInt(eventHandleObj, "eventSignal", eventSignal);
if (0 == VMSignal_getVMCnt()) { if (0 == VMSignal_getVMCnt()) {
/* no vm is running, run event handler directly */ /* no vm is running, run event handler directly */
__eventLisener_runEvent(eventHandleObj); Arg* res = __eventLisener_runEvent(self, eventId, eventSignal);
if (NULL != res) {
arg_deinit(res);
}
return; return;
} }
/* push event handler to vm event list */ /* push event handler to vm event list */
if (PIKA_RES_OK != VMSignal_pushEvent(eventHandleObj)) { if (PIKA_RES_OK != VMSignal_pushEvent(self, eventId, eventSignal)) {
__platform_printf( __platform_printf(
"OverflowError: event list is full, please use bigger " "OverflowError: event list is full, please use bigger "
"PIKA_EVENT_LIST_SIZE\r\n"); "PIKA_EVENT_LIST_SIZE\r\n");

4
src/PikaObj.h
View File

@ -470,6 +470,8 @@ void _obj_updateProxyFlag(PikaObj* self);
_obj_updateProxyFlag((_self)) _obj_updateProxyFlag((_self))
Arg* _obj_getProp(PikaObj* obj, char* name); Arg* _obj_getProp(PikaObj* obj, char* name);
void __eventLisener_runEvent(PikaObj* eventHandleObj); Arg* __eventLisener_runEvent(PikaEventListener* lisener,
uint32_t eventId,
int eventSignal);
#endif #endif

1
src/PikaPlatform.h
View File

@ -96,6 +96,7 @@ typedef enum {
PIKA_RES_ERR_IO, PIKA_RES_ERR_IO,
PIKA_RES_ERR_ASSERT, PIKA_RES_ERR_ASSERT,
PIKA_RES_ERR_SIGNAL_EVENT_FULL, PIKA_RES_ERR_SIGNAL_EVENT_FULL,
PIKA_RES_ERR_SIGNAL_EVENT_EMPTY,
} PIKA_RES; } PIKA_RES;
/* clang-format off */ /* clang-format off */

63
src/PikaVM.c
View File

@ -36,29 +36,51 @@
#include <math.h> #include <math.h>
#endif #endif
static volatile VMSignal PikaVMSignal = { static volatile VMSignal PikaVMSignal = {.signal_ctrl = VM_SIGNAL_CTRL_NONE,
.signal_ctrl = VM_SIGNAL_CTRL_NONE, .vm_cnt = 0,
.vm_cnt = 0, .cq = {
.event_top = 0, .head = 0,
}; .tail = 0,
}};
int VMSignal_getVMCnt(void) { int VMSignal_getVMCnt(void) {
return PikaVMSignal.vm_cnt; return PikaVMSignal.vm_cnt;
} }
PIKA_RES VMSignal_pushEvent(PikaObj* eventHandleObj) { static PIKA_BOOL _cq_isEmpty(volatile VMSignal* signal) {
if (PikaVMSignal.event_top >= PIKA_EVENT_LIST_SIZE) { return signal->cq.head == signal->cq.tail;
}
static PIKA_BOOL _cq_isFull(volatile VMSignal* signal) {
return (signal->cq.tail + 1) % PIKA_EVENT_LIST_SIZE == signal->cq.head;
}
PIKA_RES VMSignal_pushEvent(PikaEventListener* lisener,
uint32_t eventId,
int eventSignal) {
/* push to event_cq_buff */
if (_cq_isFull(&PikaVMSignal)) {
return PIKA_RES_ERR_SIGNAL_EVENT_FULL; return PIKA_RES_ERR_SIGNAL_EVENT_FULL;
} }
PikaVMSignal.event_obj_list[PikaVMSignal.event_top++] = eventHandleObj; PikaVMSignal.cq.id[PikaVMSignal.cq.tail] = eventId;
PikaVMSignal.cq.signal[PikaVMSignal.cq.tail] = eventSignal;
PikaVMSignal.cq.lisener[PikaVMSignal.cq.tail] = lisener;
PikaVMSignal.cq.tail = (PikaVMSignal.cq.tail + 1) % PIKA_EVENT_LIST_SIZE;
return PIKA_RES_OK; return PIKA_RES_OK;
} }
PikaObj* VMSignal_popEvent(void) { PIKA_RES VMSignal_popEvent(PikaEventListener** lisener_p,
if (PikaVMSignal.event_top <= 0) { uint32_t* id,
return NULL; int* signal) {
/* pop from event_cq_buff */
if (_cq_isEmpty(&PikaVMSignal)) {
return PIKA_RES_ERR_SIGNAL_EVENT_EMPTY;
} }
return PikaVMSignal.event_obj_list[--PikaVMSignal.event_top]; *id = PikaVMSignal.cq.id[PikaVMSignal.cq.head];
*signal = PikaVMSignal.cq.signal[PikaVMSignal.cq.head];
*lisener_p = PikaVMSignal.cq.lisener[PikaVMSignal.cq.head];
PikaVMSignal.cq.head = (PikaVMSignal.cq.head + 1) % PIKA_EVENT_LIST_SIZE;
return PIKA_RES_OK;
} }
VM_SIGNAL_CTRL VMSignal_getCtrl(void) { VM_SIGNAL_CTRL VMSignal_getCtrl(void) {
@ -2824,6 +2846,8 @@ void instructArray_printAsArray(InstructArray* self) {
uint8_t* ins_size_p = (uint8_t*)&self->size; uint8_t* ins_size_p = (uint8_t*)&self->size;
__platform_printf("0x%02x, ", *(ins_size_p)); __platform_printf("0x%02x, ", *(ins_size_p));
__platform_printf("0x%02x, ", *(ins_size_p + (uintptr_t)1)); __platform_printf("0x%02x, ", *(ins_size_p + (uintptr_t)1));
__platform_printf("0x%02x, ", *(ins_size_p + (uintptr_t)2));
__platform_printf("0x%02x, ", *(ins_size_p + (uintptr_t)3));
__platform_printf("/* instruct array size */\n"); __platform_printf("/* instruct array size */\n");
while (1) { while (1) {
InstructUnit* ins_unit = instructArray_getNow(self); InstructUnit* ins_unit = instructArray_getNow(self);
@ -2943,9 +2967,16 @@ static VMParameters* __pikaVM_runByteCodeFrameWithState(
__pks_hook_instruct(); __pks_hook_instruct();
} }
#endif #endif
PikaObj* eventHandleObj = VMSignal_popEvent(); PikaObj* event_lisener;
if (NULL != eventHandleObj) { uint32_t event_id;
__eventLisener_runEvent(eventHandleObj); int event_signal;
if (PIKA_RES_OK ==
VMSignal_popEvent(&event_lisener, &event_id, &event_signal)) {
Arg* res =
__eventLisener_runEvent(event_lisener, event_id, event_signal);
if (NULL != res) {
arg_deinit(res);
}
} }
if (0 != vm.error_code) { if (0 != vm.error_code) {
vm.line_error_code = vm.error_code; vm.line_error_code = vm.error_code;
@ -2999,6 +3030,8 @@ void constPool_printAsArray(ConstPool* self) {
uint8_t* const_size_str = (uint8_t*)&(self->size); uint8_t* const_size_str = (uint8_t*)&(self->size);
__platform_printf("0x%02x, ", *(const_size_str)); __platform_printf("0x%02x, ", *(const_size_str));
__platform_printf("0x%02x, ", *(const_size_str + (uintptr_t)1)); __platform_printf("0x%02x, ", *(const_size_str + (uintptr_t)1));
__platform_printf("0x%02x, ", *(const_size_str + (uintptr_t)2));
__platform_printf("0x%02x, ", *(const_size_str + (uintptr_t)3));
__platform_printf("/* const pool size */\n"); __platform_printf("/* const pool size */\n");
uint16_t ptr_befor = self->content_offset_now; uint16_t ptr_befor = self->content_offset_now;
uint8_t line_num = 12; uint8_t line_num = 12;

19
src/PikaVM.h
View File

@ -104,12 +104,19 @@ typedef enum VM_SIGNAL_CTRL {
VM_SIGNAL_CTRL_EXIT, VM_SIGNAL_CTRL_EXIT,
} VM_SIGNAL_CTRL; } VM_SIGNAL_CTRL;
typedef struct EventCQ {
uint32_t id[PIKA_EVENT_LIST_SIZE];
int signal[PIKA_EVENT_LIST_SIZE];
PikaEventListener* lisener[PIKA_EVENT_LIST_SIZE];
int head;
int tail;
} EventCQ;
typedef struct VMSignal VMSignal; typedef struct VMSignal VMSignal;
struct VMSignal { struct VMSignal {
VM_SIGNAL_CTRL signal_ctrl; VM_SIGNAL_CTRL signal_ctrl;
int vm_cnt; int vm_cnt;
PikaObj* event_obj_list[PIKA_EVENT_LIST_SIZE]; EventCQ cq;
int event_top;
}; };
VMParameters* pikaVM_run(PikaObj* self, char* pyLine); VMParameters* pikaVM_run(PikaObj* self, char* pyLine);
@ -233,7 +240,11 @@ VM_SIGNAL_CTRL VMSignal_getCtrl(void);
void pks_vm_exit(void); void pks_vm_exit(void);
void pks_vmSignal_setCtrlElear(void); void pks_vmSignal_setCtrlElear(void);
int VMSignal_getVMCnt(void); int VMSignal_getVMCnt(void);
PikaObj* VMSignal_popEvent(void); PIKA_RES VMSignal_popEvent(PikaEventListener** lisener_p,
PIKA_RES VMSignal_pushEvent(PikaObj* eventHandleObj); uint32_t* id,
int* signal);
PIKA_RES VMSignal_pushEvent(PikaEventListener* lisener,
uint32_t eventId,
int eventSignal);
#endif #endif

2
test/compile-test.cpp
View File

@ -573,7 +573,7 @@ TEST(compiler, event_cb) {
} }
TEST(compiler, event_cb_lvgl) { TEST(compiler, event_cb_lvgl) {
char* lines = "eventCallBack(eventSignal)"; char* lines = "_res = eventCallBack(eventSignal)";
Parser_linesToArray(lines); Parser_linesToArray(lines);
EXPECT_EQ(pikaMemNow(), 0); EXPECT_EQ(pikaMemNow(), 0);
} }

9
test/event-test.cpp
View File

@ -22,10 +22,15 @@ TEST(event, gpio) {
obj_run(pikaMain, "io1.eventTest()"); obj_run(pikaMain, "io1.eventTest()");
EXPECT_STREQ(log_buff[2], "get rising edge!\r\n"); EXPECT_STREQ(log_buff[3], "get rising edge!\r\n");
EXPECT_STREQ(log_buff[1], "get falling edge!\r\n"); EXPECT_STREQ(log_buff[2], "get falling edge!\r\n");
EXPECT_STREQ(log_buff[1], "get rising edge!\r\n");
EXPECT_STREQ(log_buff[0], "get falling edge!\r\n"); EXPECT_STREQ(log_buff[0], "get falling edge!\r\n");
for (int i = 0; i < 255; i++) {
obj_run(pikaMain, "io1.eventTest()");
}
/* deinit */ /* deinit */
obj_deinit(pikaMain); obj_deinit(pikaMain);