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

run event when vm is idle

Browse Source
This commit is contained in:
lyon 2022-11-02 12:25:02 +08:00
parent 08d996c98d
commit feeca8f135
16 changed files with 102 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
port/linux/package/pikascript/TemplateDevice.pyi
View File

@ -10,6 +10,7 @@ class GPIO(PikaStdDevice.GPIO):
def platformSetMode(self): ...
def platformRead(self): ...
def platformGetEventId(self): ...
def eventTest(self): ...
class Time(PikaStdDevice.Time):

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

@ -14,3 +14,14 @@ void TemplateDevice_GPIO_platformGetEventId(PikaObj* self) {
obj_setInt(self, "eventId", GPIO_PA8_EVENT_ID);
}
}
extern PikaEventListener* g_pika_device_event_listener;
#define EVENT_SIGAL_IO_RISING_EDGE 0x01
#define EVENT_SIGAL_IO_FALLING_EDGE 0x02
#define GPIO_PA8_EVENT_ID 0x08
void TemplateDevice_GPIO_eventTest(PikaObj *self){
pks_eventLisener_sendSignal(g_pika_device_event_listener, GPIO_PA8_EVENT_ID,
EVENT_SIGAL_IO_FALLING_EDGE);
}

4
src/PikaCompiler.c
View File

@ -329,11 +329,9 @@ int LibObj_saveLibraryFile(LibObj* self, char* output_file_name) {
}
int LibObj_loadLibrary(LibObj* self, uint8_t* library_bytes) {
#ifndef _WIN32
if (0 != ((uintptr_t)library_bytes & 0x03)) {
if (0 != ((intptr_t)library_bytes & 0x03)) {
return PIKA_RES_ERR_UNALIGNED_PTR;
}
#endif
char* magic_code = (char*)library_bytes;

40
src/PikaObj.c
View File

@ -1307,9 +1307,7 @@ PikaObj* Obj_linkLibraryFile(PikaObj* self, char* input_file_name) {
PikaObj* obj_linkLibrary(PikaObj* self, uint8_t* library_bytes) {
obj_newMetaObj(self, "@lib", New_LibObj);
LibObj* lib = obj_getObj(self, "@lib");
if(0 != LibObj_loadLibrary(lib, library_bytes)){
__platform_printf("VM Error: load bytecode library failed\r\n");
}
LibObj_loadLibrary(lib, library_bytes);
return self;
}
@ -1428,16 +1426,7 @@ void pks_eventLisener_deinit(PikaEventListener** p_self) {
}
}
void pks_eventLisener_sendSignal(PikaEventListener* self,
uint32_t eventId,
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);
void __eventLisener_runEvent(PikaObj* eventHandleObj) {
/* clang-format off */
PIKA_PYTHON(
eventCallBack(eventSignal)
@ -1454,6 +1443,31 @@ void pks_eventLisener_sendSignal(PikaEventListener* self,
pikaVM_runByteCode(eventHandleObj, (uint8_t*)bytes);
}
void pks_eventLisener_sendSignal(PikaEventListener* self,
uint32_t eventId,
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()) {
/* no vm is running, run event handler directly */
__eventLisener_runEvent(eventHandleObj);
return;
}
/* push event handler to vm event list */
if (PIKA_RES_OK != VMSignal_pushEvent(eventHandleObj)) {
__platform_printf(
"OverflowError: event list is full, please use bigger "
"PIKA_EVENT_LIST_SIZE\r\n");
while (1) {
}
}
}
/* print major version info */
void pks_printVersion(void) {
__platform_printf("pikascript-core==v%d.%d.%d (%s)\r\n", PIKA_VERSION_MAJOR,

1
src/PikaObj.h
View File

@ -470,5 +470,6 @@ void _obj_updateProxyFlag(PikaObj* self);
_obj_updateProxyFlag((_self))
Arg* _obj_getProp(PikaObj* obj, char* name);
void __eventLisener_runEvent(PikaObj* eventHandleObj);
#endif

12
src/PikaParser.c
View File

@ -881,11 +881,11 @@ char* Lexer_getOperator(Args* outBuffs, char* stmt) {
const char void_str[] = "";
void LexToken_update(struct LexToken* lex_token) {
lex_token->type = Token_getType(lex_token->token);
lex_token->type = Token_getType(lex_token->tokenStream);
if (lex_token->type == TOKEN_strEnd) {
lex_token->pyload = (char*)void_str;
} else {
lex_token->pyload = Token_getPyload(lex_token->token);
lex_token->pyload = Token_getPyload(lex_token->tokenStream);
}
}
@ -893,12 +893,12 @@ void Cursor_iterStart(struct Cursor* cs) {
cs->iter_index++;
cs->iter_buffs = New_strBuff();
/* token1 is the last token */
cs->token1.token = strsCopy(cs->iter_buffs, arg_getStr(cs->last_token));
cs->token1.tokenStream = strsCopy(cs->iter_buffs, arg_getStr(cs->last_token));
/* token2 is the next token */
cs->token2.token = TokenStream_pop(cs->iter_buffs, &cs->tokenStream);
cs->token2.tokenStream = TokenStream_pop(cs->iter_buffs, &cs->tokenStream);
/* store last token */
arg_deinit(cs->last_token);
cs->last_token = arg_newStr(cs->token2.token);
cs->last_token = arg_newStr(cs->token2.tokenStream);
LexToken_update(&cs->token1);
LexToken_update(&cs->token2);
@ -924,7 +924,7 @@ void Cursor_iterStart(struct Cursor* cs) {
void LexToken_init(struct LexToken* lt) {
lt->pyload = NULL;
lt->token = NULL;
lt->tokenStream = NULL;
lt->type = TOKEN_strEnd;
}

2
src/PikaParser.h
View File

@ -79,7 +79,7 @@ typedef struct GenRule {
typedef struct LexToken LexToken;
struct LexToken {
char* token;
char* tokenStream;
enum TokenType type;
char* pyload;
};

14
src/PikaPlatform.h
View File

@ -36,16 +36,13 @@
#include <stdlib.h>
#include <string.h>
#define _pika_assert(expr) \
if (!(expr)) { \
__platform_printf("Assertion failed: %s\nfile: %s:%d\n", #expr, \
__FILE__, __LINE__); \
abort(); \
}
/* clang-format off */
#if PIKA_ASSERT_ENABLE
#define pika_assert(expr) _pika_assert(expr)
#define pika_assert(expr) \
if(!(expr)) { \
__platform_printf("Assertion failed: %s\nfile: %s:%d\n", #expr, __FILE__, __LINE__); \
abort(); \
}
#else
#define pika_assert(...)
#endif
@ -98,6 +95,7 @@ typedef enum {
PIKA_RES_ERR_SYNTAX_ERROR,
PIKA_RES_ERR_IO,
PIKA_RES_ERR_ASSERT,
PIKA_RES_ERR_SIGNAL_EVENT_FULL,
} PIKA_RES;
/* clang-format off */

26
src/PikaVM.c
View File

@ -39,8 +39,28 @@
static volatile VMSignal PikaVMSignal = {
.signal_ctrl = VM_SIGNAL_CTRL_NONE,
.vm_cnt = 0,
.event_top = 0,
};
int VMSignal_getVMCnt(void) {
return PikaVMSignal.vm_cnt;
}
PIKA_RES VMSignal_pushEvent(PikaObj* eventHandleObj) {
if (PikaVMSignal.event_top >= PIKA_EVENT_LIST_SIZE) {
return PIKA_RES_ERR_SIGNAL_EVENT_FULL;
}
PikaVMSignal.event_obj_list[PikaVMSignal.event_top++] = eventHandleObj;
return PIKA_RES_OK;
}
PikaObj* VMSignal_popEvent(void) {
if (PikaVMSignal.event_top <= 0) {
return NULL;
}
return PikaVMSignal.event_obj_list[--PikaVMSignal.event_top];
}
VM_SIGNAL_CTRL VMSignal_getCtrl(void) {
return PikaVMSignal.signal_ctrl;
}
@ -2856,7 +2876,7 @@ void VMState_solveUnusedStack(VMState* vm) {
} else if (type == ARG_TYPE_BYTES) {
arg_printBytes(arg);
} else if (ARG_TYPE_POINTER == type ||
ARG_TYPE_METHOD_NATIVE_CONSTRUCTOR == type) {
ARG_TYPE_METHOD_NATIVE_CONSTRUCTOR) {
__platform_printf("%p\r\n", arg_getPtr(arg));
}
arg_deinit(arg);
@ -2913,6 +2933,10 @@ static VMParameters* __pikaVM_runByteCodeFrameWithState(
__pks_hook_instruct();
}
#endif
PikaObj* eventHandleObj = VMSignal_popEvent();
if (NULL != eventHandleObj) {
__eventLisener_runEvent(eventHandleObj);
}
if (0 != vm.error_code) {
vm.line_error_code = vm.error_code;
InstructUnit* head_ins_unit = this_ins_unit;

5
src/PikaVM.h
View File

@ -108,6 +108,8 @@ typedef struct VMSignal VMSignal;
struct VMSignal {
VM_SIGNAL_CTRL signal_ctrl;
int vm_cnt;
PikaObj* event_obj_list[PIKA_EVENT_LIST_SIZE];
int event_top;
};
VMParameters* pikaVM_run(PikaObj* self, char* pyLine);
@ -230,5 +232,8 @@ void __vm_Dict___init__(PikaObj* self);
VM_SIGNAL_CTRL VMSignal_getCtrl(void);
void pks_vm_exit(void);
void pks_vmSignal_setCtrlElear(void);
int VMSignal_getVMCnt(void);
PikaObj* VMSignal_popEvent(void);
PIKA_RES VMSignal_pushEvent(PikaObj* eventHandleObj);
#endif

4
src/PikaVersion.h
View File

@ -1,5 +1,5 @@
#define PIKA_VERSION_MAJOR 1
#define PIKA_VERSION_MINOR 11
#define PIKA_VERSION_MICRO 6
#define PIKA_VERSION_MICRO 5
#define PIKA_EDIT_TIME "2022/10/28 14:38:46"
#define PIKA_EDIT_TIME "2022/10/27 13:03:23"

2
src/dataArg.h
View File

@ -113,7 +113,7 @@ Arg* arg_setBytes(Arg* self, char* name, uint8_t* src, size_t size);
#define arg_newInt(val) arg_setInt(NULL, "", (val))
#define arg_newFloat(val) arg_setFloat(NULL, "", (val))
#define arg_newPtr(type, pointer) arg_setPtr(NULL, "", (type), (pointer))
#define arg_newStr(string) arg_setStr(NULL, "", (char*)(string))
#define arg_newStr(string) arg_setStr(NULL, "", (string))
#define arg_newNull() arg_setNull(NULL)
#define arg_newBytes(src, size) arg_setBytes(NULL, "", (src), (size))

2
src/dataArgs.c
View File

@ -480,7 +480,7 @@ char* args_print(Args* self, char* name) {
}
if (argType_isObject(type) || ARG_TYPE_POINTER == type ||
ARG_TYPE_METHOD_NATIVE_CONSTRUCTOR == type) {
ARG_TYPE_METHOD_NATIVE_CONSTRUCTOR) {
void* val = args_getPtr(self, name);
res = getPrintStringFromPtr(self, name, val);
goto exit;

6
src/dataArgs.h
View File

@ -154,10 +154,7 @@ PikaDict* New_dict(void);
#define dict_getStr(self, name) (args_getStr((&((self)->super)), (name)))
#define dict_getPtr(self, name) (args_getPtr((&((self)->super)), (name)))
#define dict_getArg(self, name) (args_getArg((&((self)->super)), (name)))
#define dict_getArgByidex(self, index) \
(args_getArgByidex((&((self)->super)), (index)))
#define dict_getBytes(self, name) (args_getBytes((&((self)->super)), (name)))
#define dict_getSize(self) (args_getSize((&((self)->super))))
#define dict_getType(self, name) (args_getType((&((self)->super)), (name)))
#define dict_getBytesSize(self, name) \
(args_getBytesSize((&((self)->super)), (name)))
@ -180,7 +177,8 @@ char* strsFormatArg(Args* out_buffs, char* fmt, Arg* arg);
#define tuple_getArg(self, index) (list_getArg((&((self)->super)), (index)))
#define tuple_getSize(self) (list_getSize((&((self)->super))))
#define tuple_getInt(self, index) (list_getInt((&((self)->super)), (index)))
#define tuple_getFloat(self, index) (list_getFloat((&((self)->super)), (index)))
#define tuple_getFloat(self, index) \
(list_getFloat((&((self)->super)), (index)))
#define tuple_getStr(self, index) (list_getStr((&((self)->super)), (index)))
#define tuple_getPtr(self, index) (list_getPtr((&((self)->super)), (index)))
#define tuple_getType(self, index) (list_getType((&((self)->super)), (index)))

5
src/pika_config_valid.h
View File

@ -331,6 +331,11 @@
#ifndef PIKA_SHELL_SAVE_FILE_NAME
#define PIKA_SHELL_SAVE_FILE_NAME "pika_shell_save.py"
#endif
#ifndef PIKA_EVENT_LIST_SIZE
#define PIKA_EVENT_LIST_SIZE 16
#endif
/* configuration validation */
#endif

8
test/event-test.cpp
View File

@ -18,10 +18,14 @@ TEST(event, gpio) {
EVENT_SIGAL_IO_RISING_EDGE);
pks_eventLisener_sendSignal(g_pika_device_event_listener, GPIO_PA8_EVENT_ID,
EVENT_SIGAL_IO_FALLING_EDGE);
/* collect */
/* assert */
EXPECT_STREQ(log_buff[1], "get rising edge!\r\n");
obj_run(pikaMain, "io1.eventTest()");
EXPECT_STREQ(log_buff[2], "get rising edge!\r\n");
EXPECT_STREQ(log_buff[1], "get falling edge!\r\n");
EXPECT_STREQ(log_buff[0], "get falling edge!\r\n");
/* deinit */
obj_deinit(pikaMain);