jeans/Tasmota
jeans/Tasmota
1
0
Fork 0
mirror of https://github.com/arendst/Tasmota.git synced 2025-07-28 05:06:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Berry add module `import persist` (#13264)

Browse Source 
* Berry add module ``import persist``

* Call `persist.save()` before restart
This commit is contained in:
s-hadinger 2021-10-03 11:54:29 +02:00 committed by GitHub
parent 54359e5aa7
commit 6878bf9fbf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 651 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -8,6 +8,7 @@ All notable changes to this project will be documented in this file.
- Command ``SetOption129 1`` to enable split total energy results (#13030) - Command ``SetOption129 1`` to enable split total energy results (#13030)
- Commands ``EnergyTotal<phase>``, ``EnergyToday<phase>`` and ``EnergyYesterday<phase>`` to (re)set energy values - Commands ``EnergyTotal<phase>``, ``EnergyToday<phase>`` and ``EnergyYesterday<phase>`` to (re)set energy values
- Commands ``EnergyUsage`` and ``EnergyExport`` to (re)set energy usage and export values - Commands ``EnergyUsage`` and ``EnergyExport`` to (re)set energy usage and export values
- Berry add module ``import persist``
### Breaking Changed ### Breaking Changed
- ESP32 LVGL updated to v8.0.2 - ESP32 LVGL updated to v8.0.2

2
lib/libesp32/Berry/default/be_modtab.c
View File

@ -24,6 +24,7 @@ be_extern_native_module(introspect);
be_extern_native_module(strict); be_extern_native_module(strict);
/* Tasmota specific */ /* Tasmota specific */
be_extern_native_module(persist);
be_extern_native_module(light); be_extern_native_module(light);
be_extern_native_module(gpio); be_extern_native_module(gpio);
be_extern_native_module(energy); be_extern_native_module(energy);
@ -80,6 +81,7 @@ BERRY_LOCAL const bntvmodule* const be_module_table[] = {
/* user-defined modules register start */ /* user-defined modules register start */
&be_native_module(path), &be_native_module(path),
&be_native_module(persist),
&be_native_module(gpio), &be_native_module(gpio),
#ifdef USE_LIGHT #ifdef USE_LIGHT
&be_native_module(light), &be_native_module(light),

382
lib/libesp32/Berry/default/be_persist_lib.c Normal file
View File

@ -0,0 +1,382 @@
/********************************************************************
* Tasmota lib
*
* To use: `import power`
*
* read power values
*******************************************************************/
#include "be_constobj.h"
/********************************************************************
** Solidified function: setmember
********************************************************************/
be_local_closure(setmember, /* name */
be_nested_proto(
4, /* nstack */
3, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 2]) { /* constants */
/* K0 */ be_nested_string("p", -183745553, 1),
/* K1 */ be_nested_string("dirty", -1627386213, 5),
}),
(be_nested_const_str("setmember", 1432909441, 9)),
(be_nested_const_str("stdin", -1529146723, 5)),
( &(const binstruction[ 5]) { /* code */
0x880C0100, // 0000 GETMBR R3 R0 K0
0x980C0202, // 0001 SETIDX R3 R1 R2
0x500C0200, // 0002 LDBOOL R3 1 0
0x90020203, // 0003 SETMBR R0 K1 R3
0x80000000, // 0004 RET 0
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: save
********************************************************************/
be_local_closure(save, /* name */
be_nested_proto(
8, /* nstack */
1, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 8]) { /* constants */
/* K0 */ be_nested_string("json", 916562499, 4),
/* K1 */ be_nested_string("filename", 1058081160, 8),
/* K2 */ be_nested_string("w", -234078410, 1),
/* K3 */ be_nested_string("write", -1104765092, 5),
/* K4 */ be_nested_string("dump", -631966073, 4),
/* K5 */ be_nested_string("p", -183745553, 1),
/* K6 */ be_nested_string("close", 667630371, 5),
/* K7 */ be_nested_string("dirty", -1627386213, 5),
}),
(be_nested_const_str("save", -855671224, 4)),
(be_nested_const_str("stdin", -1529146723, 5)),
( &(const binstruction[30]) { /* code */
0xA4060000, // 0000 IMPORT R1 K0
0x4C080000, // 0001 LDNIL R2
0xA802000D, // 0002 EXBLK 0 #0011
0x600C0011, // 0003 GETGBL R3 G17
0x88100101, // 0004 GETMBR R4 R0 K1
0x58140002, // 0005 LDCONST R5 K2
0x7C0C0400, // 0006 CALL R3 2
0x5C080600, // 0007 MOVE R2 R3
0x8C0C0503, // 0008 GETMET R3 R2 K3
0x8C140304, // 0009 GETMET R5 R1 K4
0x881C0105, // 000A GETMBR R7 R0 K5
0x7C140400, // 000B CALL R5 2
0x7C0C0400, // 000C CALL R3 2
0x8C0C0506, // 000D GETMET R3 R2 K6
0x7C0C0200, // 000E CALL R3 1
0xA8040001, // 000F EXBLK 1 1
0x70020009, // 0010 JMP #001B
0xAC0C0002, // 0011 CATCH R3 0 2
0x70020006, // 0012 JMP #001A
0x4C140000, // 0013 LDNIL R5
0x20140405, // 0014 NE R5 R2 R5
0x78160001, // 0015 JMPF R5 #0018
0x8C140506, // 0016 GETMET R5 R2 K6
0x7C140200, // 0017 CALL R5 1
0xB0040604, // 0018 RAISE 1 R3 R4
0x70020000, // 0019 JMP #001B
0xB0080000, // 001A RAISE 2 R0 R0
0x500C0000, // 001B LDBOOL R3 0 0
0x90020E03, // 001C SETMBR R0 K7 R3
0x80000000, // 001D RET 0
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: init
********************************************************************/
be_local_closure(init, /* name */
be_nested_proto(
6, /* nstack */
2, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 6]) { /* constants */
/* K0 */ be_nested_string("filename", 1058081160, 8),
/* K1 */ be_nested_string("_persist.json", 2008425138, 13),
/* K2 */ be_nested_string("p", -183745553, 1),
/* K3 */ be_nested_string("copy", -446502332, 4),
/* K4 */ be_nested_string("load", -435725847, 4),
/* K5 */ be_nested_string("dirty", -1627386213, 5),
}),
(be_nested_const_str("init", 380752755, 4)),
(be_nested_const_str("stdin", -1529146723, 5)),
( &(const binstruction[20]) { /* code */
0x90020101, // 0000 SETMBR R0 K0 K1
0x6008000F, // 0001 GETGBL R2 G15
0x5C0C0200, // 0002 MOVE R3 R1
0x60100013, // 0003 GETGBL R4 G19
0x7C080400, // 0004 CALL R2 2
0x780A0003, // 0005 JMPF R2 #000A
0x8C080303, // 0006 GETMET R2 R1 K3
0x7C080200, // 0007 CALL R2 1
0x90020402, // 0008 SETMBR R0 K2 R2
0x70020002, // 0009 JMP #000D
0x60080013, // 000A GETGBL R2 G19
0x7C080000, // 000B CALL R2 0
0x90020402, // 000C SETMBR R0 K2 R2
0x8C080104, // 000D GETMET R2 R0 K4
0x88100102, // 000E GETMBR R4 R0 K2
0x88140100, // 000F GETMBR R5 R0 K0
0x7C080600, // 0010 CALL R2 3
0x50080000, // 0011 LDBOOL R2 0 0
0x90020A02, // 0012 SETMBR R0 K5 R2
0x80000000, // 0013 RET 0
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: zero
********************************************************************/
be_local_closure(zero, /* name */
be_nested_proto(
2, /* nstack */
1, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 2]) { /* constants */
/* K0 */ be_nested_string("p", -183745553, 1),
/* K1 */ be_nested_string("dirty", -1627386213, 5),
}),
(be_nested_const_str("zero", -1955600541, 4)),
(be_nested_const_str("stdin", -1529146723, 5)),
( &(const binstruction[ 6]) { /* code */
0x60040013, // 0000 GETGBL R1 G19
0x7C040000, // 0001 CALL R1 0
0x90020001, // 0002 SETMBR R0 K0 R1
0x50040200, // 0003 LDBOOL R1 1 0
0x90020201, // 0004 SETMBR R0 K1 R1
0x80000000, // 0005 RET 0
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: tostring
********************************************************************/
be_local_closure(tostring, /* name */
be_nested_proto(
8, /* nstack */
1, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 4]) { /* constants */
/* K0 */ be_nested_string("string", 398550328, 6),
/* K1 */ be_nested_string("format", -1180859054, 6),
/* K2 */ be_nested_string("<instance: %s(%s)>", 1553432777, 18),
/* K3 */ be_nested_string("p", -183745553, 1),
}),
(be_nested_const_str("tostring", -1995258651, 8)),
(be_nested_const_str("stdin", -1529146723, 5)),
( &(const binstruction[11]) { /* code */
0xA4060000, // 0000 IMPORT R1 K0
0x8C080301, // 0001 GETMET R2 R1 K1
0x58100002, // 0002 LDCONST R4 K2
0x60140005, // 0003 GETGBL R5 G5
0x5C180000, // 0004 MOVE R6 R0
0x7C140200, // 0005 CALL R5 1
0x60180008, // 0006 GETGBL R6 G8
0x881C0103, // 0007 GETMBR R7 R0 K3
0x7C180200, // 0008 CALL R6 1
0x7C080800, // 0009 CALL R2 4
0x80040400, // 000A RET 1 R2
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: member
********************************************************************/
be_local_closure(member, /* name */
be_nested_proto(
5, /* nstack */
2, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 2]) { /* constants */
/* K0 */ be_nested_string("p", -183745553, 1),
/* K1 */ be_nested_string("find", -1108310694, 4),
}),
(be_nested_const_str("member", 719708611, 6)),
(be_nested_const_str("stdin", -1529146723, 5)),
( &(const binstruction[ 5]) { /* code */
0x88080100, // 0000 GETMBR R2 R0 K0
0x8C080501, // 0001 GETMET R2 R2 K1
0x5C100200, // 0002 MOVE R4 R1
0x7C080400, // 0003 CALL R2 2
0x80040400, // 0004 RET 1 R2
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified function: load
********************************************************************/
be_local_closure(load, /* name */
be_nested_proto(
9, /* nstack */
1, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[10]) { /* constants */
/* K0 */ be_nested_string("json", 916562499, 4),
/* K1 */ be_nested_string("path", -2071507658, 4),
/* K2 */ be_nested_string("exists", 1002329533, 6),
/* K3 */ be_nested_string("filename", 1058081160, 8),
/* K4 */ be_nested_string("r", -150190315, 1),
/* K5 */ be_nested_string("load", -435725847, 4),
/* K6 */ be_nested_string("read", -824204347, 4),
/* K7 */ be_nested_string("close", 667630371, 5),
/* K8 */ be_nested_string("p", -183745553, 1),
/* K9 */ be_nested_string("dirty", -1627386213, 5),
}),
(be_nested_const_str("load", -435725847, 4)),
(be_nested_const_str("stdin", -1529146723, 5)),
( &(const binstruction[37]) { /* code */
0xA4060000, // 0000 IMPORT R1 K0
0xA40A0200, // 0001 IMPORT R2 K1
0x4C0C0000, // 0002 LDNIL R3
0x4C100000, // 0003 LDNIL R4
0x8C140502, // 0004 GETMET R5 R2 K2
0x881C0103, // 0005 GETMBR R7 R0 K3
0x7C140400, // 0006 CALL R5 2
0x7816001B, // 0007 JMPF R5 #0024
0xA802000D, // 0008 EXBLK 0 #0017
0x60140011, // 0009 GETGBL R5 G17
0x88180103, // 000A GETMBR R6 R0 K3
0x581C0004, // 000B LDCONST R7 K4
0x7C140400, // 000C CALL R5 2
0x5C0C0A00, // 000D MOVE R3 R5
0x8C140305, // 000E GETMET R5 R1 K5
0x8C1C0706, // 000F GETMET R7 R3 K6
0x7C1C0200, // 0010 CALL R7 1
0x7C140400, // 0011 CALL R5 2
0x5C100A00, // 0012 MOVE R4 R5
0x8C140707, // 0013 GETMET R5 R3 K7
0x7C140200, // 0014 CALL R5 1
0xA8040001, // 0015 EXBLK 1 1
0x70020009, // 0016 JMP #0021
0xAC140002, // 0017 CATCH R5 0 2
0x70020006, // 0018 JMP #0020
0x4C1C0000, // 0019 LDNIL R7
0x201C0607, // 001A NE R7 R3 R7
0x781E0001, // 001B JMPF R7 #001E
0x8C1C0707, // 001C GETMET R7 R3 K7
0x7C1C0200, // 001D CALL R7 1
0xB0040A06, // 001E RAISE 1 R5 R6
0x70020000, // 001F JMP #0021
0xB0080000, // 0020 RAISE 2 R0 R0
0x90021004, // 0021 SETMBR R0 K8 R4
0x50140000, // 0022 LDBOOL R5 0 0
0x90021205, // 0023 SETMBR R0 K9 R5
0x80000000, // 0024 RET 0
})
)
);
/*******************************************************************/
/********************************************************************
** Solidified class: Persist
********************************************************************/
be_local_class(Persist,
3,
NULL,
be_nested_map(10,
( (struct bmapnode*) &(const bmapnode[]) {
{ be_nested_key("filename", 1058081160, 8, -1), be_const_var(0) },
{ be_nested_key("setmember", 1432909441, 9, 7), be_const_closure(setmember_closure) },
{ be_nested_key("save", -855671224, 4, -1), be_const_closure(save_closure) },
{ be_nested_key("dirty", -1627386213, 5, 8), be_const_var(2) },
{ be_nested_key("init", 380752755, 4, -1), be_const_closure(init_closure) },
{ be_nested_key("zero", -1955600541, 4, 6), be_const_closure(zero_closure) },
{ be_nested_key("tostring", -1995258651, 8, 4), be_const_closure(tostring_closure) },
{ be_nested_key("member", 719708611, 6, -1), be_const_closure(member_closure) },
{ be_nested_key("p", -183745553, 1, -1), be_const_var(1) },
{ be_nested_key("load", -435725847, 4, -1), be_const_closure(load_closure) },
})),
(be_nested_const_str("Persist", 1456346147, 7))
);
/********************************************************************
** Solidified function: _anonymous_
********************************************************************/
be_local_closure(_anonymous_, /* name */
be_nested_proto(
3, /* nstack */
1, /* argc */
0, /* varg */
0, /* has upvals */
NULL, /* no upvals */
0, /* has sup protos */
NULL, /* no sub protos */
1, /* has constants */
( &(const bvalue[ 1]) { /* constants */
/* K0 */ be_const_class(be_class_Persist),
}),
(be_nested_const_str("_anonymous_", 1957281476, 11)),
(be_nested_const_str("stdin", -1529146723, 5)),
( &(const binstruction[ 5]) { /* code */
0x58040000, // 0000 LDCONST R1 K0
0xB4000000, // 0001 CLASS K0
0x5C080200, // 0002 MOVE R2 R1
0x7C080000, // 0003 CALL R2 0
0x80040400, // 0004 RET 1 R2
})
)
);
/*******************************************************************/
/* @const_object_info_begin
module persist (scope: global) {
init, closure(_anonymous__closure)
}
@const_object_info_end */
#include "../generate/be_fixed_persist.h"

163
lib/libesp32/Berry/default/be_tasmotalib.c
View File

@ -1412,7 +1412,7 @@ be_local_closure(gc, /* name */
********************************************************************/ ********************************************************************/
be_local_closure(event, /* name */ be_local_closure(event, /* name */
be_nested_proto( be_nested_proto(
19, /* nstack */ 20, /* nstack */
6, /* argc */ 6, /* argc */
0, /* varg */ 0, /* varg */
0, /* has upvals */ 0, /* has upvals */
@ -1420,7 +1420,7 @@ be_local_closure(event, /* name */
0, /* has sup protos */ 0, /* has sup protos */
NULL, /* no sub protos */ NULL, /* no sub protos */
1, /* has constants */ 1, /* has constants */
( &(const bvalue[15]) { /* constants */ ( &(const bvalue[18]) { /* constants */
/* K0 */ be_nested_string("introspect", 164638290, 10), /* K0 */ be_nested_string("introspect", 164638290, 10),
/* K1 */ be_nested_string("every_50ms", -1911083288, 10), /* K1 */ be_nested_string("every_50ms", -1911083288, 10),
/* K2 */ be_nested_string("run_deferred", 371594696, 12), /* K2 */ be_nested_string("run_deferred", 371594696, 12),
@ -1436,89 +1436,96 @@ be_local_closure(event, /* name */
/* K12 */ be_nested_string("format", -1180859054, 6), /* K12 */ be_nested_string("format", -1180859054, 6),
/* K13 */ be_nested_string("BRY: Exception> '%s' - %s", -2047976332, 25), /* K13 */ be_nested_string("BRY: Exception> '%s' - %s", -2047976332, 25),
/* K14 */ be_nested_string("stop_iteration", -121173395, 14), /* K14 */ be_nested_string("stop_iteration", -121173395, 14),
/* K15 */ be_nested_string("save_before_restart", 1253239338, 19),
/* K16 */ be_nested_string("persist", -377883517, 7),
/* K17 */ be_nested_string("save", -855671224, 4),
}), }),
(be_nested_const_str("event", -30355297, 5)), (be_nested_const_str("event", -30355297, 5)),
(be_nested_const_str("Tasmota.be", 825809411, 10)), (be_nested_const_str("input", -103256197, 5)),
( &(const binstruction[79]) { /* code */ ( &(const binstruction[83]) { /* code */
0xA41A0000, // 0000 IMPORT R6 K0 0xA41A0000, // 0000 IMPORT R6 K0
0x1C1C0301, // 0001 EQ R7 R1 K1 0x1C1C0301, // 0001 EQ R7 R1 K1
0x781E0001, // 0002 JMPF R7 #0005 0x781E0001, // 0002 JMPF R7 #0005
0x8C1C0102, // 0003 GETMET R7 R0 K2 0x8C1C0102, // 0003 GETMET R7 R0 K2
0x7C1C0200, // 0004 CALL R7 1 0x7C1C0200, // 0004 CALL R7 1
0x1C1C0303, // 0005 EQ R7 R1 K3 0x501C0000, // 0005 LDBOOL R7 0 0
0x781E0006, // 0006 JMPF R7 #000E 0x1C200303, // 0006 EQ R8 R1 K3
0x8C1C0104, // 0007 GETMET R7 R0 K4 0x78220006, // 0007 JMPF R8 #000F
0x5C240400, // 0008 MOVE R9 R2 0x8C200104, // 0008 GETMET R8 R0 K4
0x5C280600, // 0009 MOVE R10 R3 0x5C280400, // 0009 MOVE R10 R2
0x5C2C0800, // 000A MOVE R11 R4 0x5C2C0600, // 000A MOVE R11 R3
0x7C1C0800, // 000B CALL R7 4 0x5C300800, // 000B MOVE R12 R4
0x80040E00, // 000C RET 1 R7 0x7C200800, // 000C CALL R8 4
0x7002003F, // 000D JMP #004E 0x80041000, // 000D RET 1 R8
0x1C1C0305, // 000E EQ R7 R1 K5 0x7002003D, // 000E JMP #004D
0x781E0004, // 000F JMPF R7 #0015 0x1C200305, // 000F EQ R8 R1 K5
0x8C1C0106, // 0010 GETMET R7 R0 K6 0x78220004, // 0010 JMPF R8 #0016
0x5C240800, // 0011 MOVE R9 R4 0x8C200106, // 0011 GETMET R8 R0 K6
0x7C1C0400, // 0012 CALL R7 2 0x5C280800, // 0012 MOVE R10 R4
0x80040E00, // 0013 RET 1 R7 0x7C200400, // 0013 CALL R8 2
0x70020038, // 0014 JMP #004E 0x80041000, // 0014 RET 1 R8
0x1C1C0307, // 0015 EQ R7 R1 K7 0x70020036, // 0015 JMP #004D
0x781E0003, // 0016 JMPF R7 #001B 0x1C200307, // 0016 EQ R8 R1 K7
0x8C1C0107, // 0017 GETMET R7 R0 K7 0x78220003, // 0017 JMPF R8 #001C
0x7C1C0200, // 0018 CALL R7 1 0x8C200107, // 0018 GETMET R8 R0 K7
0x80040E00, // 0019 RET 1 R7 0x7C200200, // 0019 CALL R8 1
0x70020032, // 001A JMP #004E 0x80041000, // 001A RET 1 R8
0x881C0108, // 001B GETMBR R7 R0 K8 0x70020030, // 001B JMP #004D
0x781E0030, // 001C JMPF R7 #004E 0x88200108, // 001C GETMBR R8 R0 K8
0x601C0010, // 001D GETGBL R7 G16 0x7822002E, // 001D JMPF R8 #004D
0x88200108, // 001E GETMBR R8 R0 K8 0x60200010, // 001E GETGBL R8 G16
0x7C1C0200, // 001F CALL R7 1 0x88240108, // 001F GETMBR R9 R0 K8
0xA8020027, // 0020 EXBLK 0 #0049 0x7C200200, // 0020 CALL R8 1
0x5C200E00, // 0021 MOVE R8 R7 0xA8020027, // 0021 EXBLK 0 #004A
0x7C200000, // 0022 CALL R8 0 0x5C241000, // 0022 MOVE R9 R8
0x8C240D09, // 0023 GETMET R9 R6 K9 0x7C240000, // 0023 CALL R9 0
0x5C2C1000, // 0024 MOVE R11 R8 0x8C280D09, // 0024 GETMET R10 R6 K9
0x5C300200, // 0025 MOVE R12 R1 0x5C301200, // 0025 MOVE R12 R9
0x7C240600, // 0026 CALL R9 3 0x5C340200, // 0026 MOVE R13 R1
0x60280004, // 0027 GETGBL R10 G4 0x7C280600, // 0027 CALL R10 3
0x5C2C1200, // 0028 MOVE R11 R9 0x602C0004, // 0028 GETGBL R11 G4
0x7C280200, // 0029 CALL R10 1 0x5C301400, // 0029 MOVE R12 R10
0x1C28150A, // 002A EQ R10 R10 K10 0x7C2C0200, // 002A CALL R11 1
0x782A001B, // 002B JMPF R10 #0048 0x1C2C170A, // 002B EQ R11 R11 K10
0xA802000E, // 002C EXBLK 0 #003C 0x782E0019, // 002C JMPF R11 #0047
0x5C281200, // 002D MOVE R10 R9 0xA802000C, // 002D EXBLK 0 #003B
0x5C2C1000, // 002E MOVE R11 R8 0x5C2C1400, // 002E MOVE R11 R10
0x5C300400, // 002F MOVE R12 R2 0x5C301200, // 002F MOVE R12 R9
0x5C340600, // 0030 MOVE R13 R3 0x5C340400, // 0030 MOVE R13 R2
0x5C380800, // 0031 MOVE R14 R4 0x5C380600, // 0031 MOVE R14 R3
0x5C3C0A00, // 0032 MOVE R15 R5 0x5C3C0800, // 0032 MOVE R15 R4
0x7C280A00, // 0033 CALL R10 5 0x5C400A00, // 0033 MOVE R16 R5
0x502C0200, // 0034 LDBOOL R11 1 0 0x7C2C0A00, // 0034 CALL R11 5
0x1C2C140B, // 0035 EQ R11 R10 R11 0x5C1C1600, // 0035 MOVE R7 R11
0x782E0002, // 0036 JMPF R11 #003A 0x781E0001, // 0036 JMPF R7 #0039
0x502C0200, // 0037 LDBOOL R11 1 0 0xA8040001, // 0037 EXBLK 1 1
0xA8040002, // 0038 EXBLK 1 2 0x7002000E, // 0038 JMP #0048
0x80041600, // 0039 RET 1 R11 0xA8040001, // 0039 EXBLK 1 1
0xA8040001, // 003A EXBLK 1 1 0x7002000B, // 003A JMP #0047
0x7002000B, // 003B JMP #0048 0xAC2C0002, // 003B CATCH R11 0 2
0xAC280002, // 003C CATCH R10 0 2 0x70020008, // 003C JMP #0046
0x70020008, // 003D JMP #0047 0xA4361600, // 003D IMPORT R13 K11
0xA4321600, // 003E IMPORT R12 K11 0x60380001, // 003E GETGBL R14 G1
0x60340001, // 003F GETGBL R13 G1 0x8C3C1B0C, // 003F GETMET R15 R13 K12
0x8C38190C, // 0040 GETMET R14 R12 K12 0x5844000D, // 0040 LDCONST R17 K13
0x5840000D, // 0041 LDCONST R16 K13 0x5C481600, // 0041 MOVE R18 R11
0x5C441400, // 0042 MOVE R17 R10 0x5C4C1800, // 0042 MOVE R19 R12
0x5C481600, // 0043 MOVE R18 R11 0x7C3C0800, // 0043 CALL R15 4
0x7C380800, // 0044 CALL R14 4 0x7C380200, // 0044 CALL R14 1
0x7C340200, // 0045 CALL R13 1 0x70020000, // 0045 JMP #0047
0x70020000, // 0046 JMP #0048 0xB0080000, // 0046 RAISE 2 R0 R0
0xB0080000, // 0047 RAISE 2 R0 R0 0x7001FFD9, // 0047 JMP #0022
0x7001FFD7, // 0048 JMP #0021 0xA8040001, // 0048 EXBLK 1 1
0x581C000E, // 0049 LDCONST R7 K14 0x70020002, // 0049 JMP #004D
0xAC1C0200, // 004A CATCH R7 1 0 0x5820000E, // 004A LDCONST R8 K14
0xB0080000, // 004B RAISE 2 R0 R0 0xAC200200, // 004B CATCH R8 1 0
0x501C0000, // 004C LDBOOL R7 0 0 0xB0080000, // 004C RAISE 2 R0 R0
0x80040E00, // 004D RET 1 R7 0x1C20030F, // 004D EQ R8 R1 K15
0x80000000, // 004E RET 0 0x78220002, // 004E JMPF R8 #0052
0xA4222000, // 004F IMPORT R8 K16
0x8C241111, // 0050 GETMET R9 R8 K17
0x7C240200, // 0051 CALL R9 1
0x80040E00, // 0052 RET 1 R7
}) })
) )
); );

14
lib/libesp32/Berry/default/embedded/Tasmota.be
View File

@ -291,6 +291,7 @@ class Tasmota
import introspect import introspect
if event_type=='every_50ms' self.run_deferred() end #- first run deferred events -# if event_type=='every_50ms' self.run_deferred() end #- first run deferred events -#
var done = false
if event_type=='cmd' return self.exec_cmd(cmd, idx, payload) if event_type=='cmd' return self.exec_cmd(cmd, idx, payload)
elif event_type=='rule' return self.exec_rules(payload) elif event_type=='rule' return self.exec_rules(payload)
elif event_type=='gc' return self.gc() elif event_type=='gc' return self.gc()
@ -299,16 +300,23 @@ class Tasmota
var f = introspect.get(d, event_type) # try to match a function or method with the same name var f = introspect.get(d, event_type) # try to match a function or method with the same name
if type(f) == 'function' if type(f) == 'function'
try try
var done = f(d, cmd, idx, payload, raw) done = f(d, cmd, idx, payload, raw)
if done == true return true end if done break end
except .. as e,m except .. as e,m
import string import string
print(string.format("BRY: Exception> '%s' - %s", e, m)) print(string.format("BRY: Exception> '%s' - %s", e, m))
end end
end end
end end
return false
end end
# save persist
if event_type=='save_before_restart'
import persist
persist.save()
end
return done
end end
def add_driver(d) def add_driver(d)

98
lib/libesp32/Berry/default/embedded/persist.be Normal file
View File

@ -0,0 +1,98 @@
#- persistance module for Berry -#
#- -#
#- To solidify: -#
#-
# load only persis_module and persist_module.init
import solidify
solidify.dump(persist_module.init)
# copy and paste into `be_persist_lib.c`
-#
var persist_module = module("persist")
persist_module.init = def (m)
class Persist
var filename
var p
var dirty
#- persist can be initialized with pre-existing values. The map is not copied so any change will be reflected -#
def init(m)
# print("Persist init")
self.filename = '_persist.json'
if isinstance(m,map)
self.p = m.copy() # need to copy instead?
else
self.p = {}
end
self.load(self.p, self.filename)
self.dirty = false
# print("Persist init")
end
#- virtual member getter, if a key does not exists return `nil`-#
def member(key)
return self.p.find(key)
end
#- virtual member setter -#
def setmember(key, value)
self.p[key] = value
self.dirty = true
end
#- clear all entries -#
def zero()
self.p = {}
self.dirty = true
end
#- custom tostring -#
def tostring()
import string
return string.format("<instance: %s(%s)>", classname(self), str(self.p))
end
def load()
import json
import path
var f # file object
var val # values loaded from json
if path.exists(self.filename)
try
f = open(self.filename, "r")
val = json.load(f.read())
f.close()
except .. as e, m
if f != nil f.close() end
raise e, m
end
self.p = val
self.dirty = false
end
# print("Loading")
end
def save()
import json
var f # file object
try
f = open(self.filename, "w")
f.write(json.dump(self.p))
f.close()
except .. as e, m
if f != nil f.close() end
raise e, m
end
self.dirty = false
# print("Saving")
end
end
return Persist() # return an instance of this class
end
return persist_module

17
lib/libesp32/Berry/generate/be_fixed_persist.h Normal file
View File

@ -0,0 +1,17 @@
#include "be_constobj.h"
static be_define_const_map_slots(m_libpersist_map) {
{ be_const_key(init, -1), be_const_closure(_anonymous__closure) },
};
static be_define_const_map(
m_libpersist_map,
1
);
static be_define_const_module(
m_libpersist,
"persist"
);
BE_EXPORT_VARIABLE be_define_const_native_module(persist, NULL);

10
lib/libesp32/Berry/src/be_module.c
View File

@ -254,14 +254,18 @@ static void cache_module(bvm *vm, bstring *name)
/* Try to run '()' function of module. Module is already loaded. */ /* Try to run '()' function of module. Module is already loaded. */
static void module_init(bvm *vm) { static void module_init(bvm *vm) {
if (be_ismodule(vm, -1)) {
if (be_getmember(vm, -1, "init")) { if (be_getmember(vm, -1, "init")) {
/* found, call it with current module as parameter */ /* found, call it with current module as parameter */
be_pushvalue(vm, -2); be_pushvalue(vm, -2);
be_call(vm, 1); be_call(vm, 1);
/* we don't care about the result */ /* the result of init() is cached and returned */
be_pop(vm, 1);
be_remove(vm, -2); /* remove initial module */
} else {
be_pop(vm, 1); be_pop(vm, 1);
} }
be_pop(vm, 1); }
} }
/* load module to vm->top */ /* load module to vm->top */
@ -273,9 +277,9 @@ int be_module_load(bvm *vm, bstring *path)
if (res == BE_IO_ERROR) if (res == BE_IO_ERROR)
res = load_package(vm, path); res = load_package(vm, path);
if (res == BE_OK) { if (res == BE_OK) {
cache_module(vm, path);
/* on first load of the module, try running the '()' function */ /* on first load of the module, try running the '()' function */
module_init(vm); module_init(vm);
cache_module(vm, path);
} }
} }
return res; return res;

4
lib/libesp32/Berry/src/be_parser.c
View File

@ -602,12 +602,12 @@ static bproto* funcbody(bparser *parser, bstring *name, int type)
return finfo.proto; /* return fully constructed `bproto` */ return finfo.proto; /* return fully constructed `bproto` */
} }
/* anonymous function, build `bproto` object with name `<anonymous>` */ /* anonymous function, build `bproto` object with name `_anonymous_` */
/* and build a expdesc for the bproto */ /* and build a expdesc for the bproto */
static void anon_func(bparser *parser, bexpdesc *e) static void anon_func(bparser *parser, bexpdesc *e)
{ {
bproto *proto; bproto *proto;
bstring *name = parser_newstr(parser, "<anonymous>"); bstring *name = parser_newstr(parser, "_anonymous_");
/* 'def' ID '(' varlist ')' block 'end' */ /* 'def' ID '(' varlist ')' block 'end' */
scan_next_token(parser); /* skip 'def' */ scan_next_token(parser); /* skip 'def' */
proto = funcbody(parser, name, FUNC_ANONYMOUS); proto = funcbody(parser, name, FUNC_ANONYMOUS);

40
lib/libesp32/Berry/src/be_solidifylib.c
View File

@ -47,14 +47,14 @@ static void m_solidify_bvalue(bvm *vm, bvalue * value)
#if BE_INTGER_TYPE == 2 #if BE_INTGER_TYPE == 2
logfmt("be_const_int(%lli)", var_toint(value)); logfmt("be_const_int(%lli)", var_toint(value));
#else #else
logfmt("be_const_int(%i)", var_toint(value)); logfmt("be_const_int(%li)", var_toint(value));
#endif #endif
break; break;
case BE_INDEX: case BE_INDEX:
#if BE_INTGER_TYPE == 2 #if BE_INTGER_TYPE == 2
logfmt("be_const_var(%lli)", var_toint(value)); logfmt("be_const_var(%lli)", var_toint(value));
#else #else
logfmt("be_const_var(%i)", var_toint(value)); logfmt("be_const_var(%li)", var_toint(value));
#endif #endif
break; break;
case BE_REAL: case BE_REAL:
@ -78,6 +78,9 @@ static void m_solidify_bvalue(bvm *vm, bvalue * value)
case BE_CLOSURE: case BE_CLOSURE:
logfmt("be_const_closure(%s_closure)", str(((bclosure*) var_toobj(value))->proto->name)); logfmt("be_const_closure(%s_closure)", str(((bclosure*) var_toobj(value))->proto->name));
break; break;
case BE_CLASS:
logfmt("be_const_class(be_class_%s)", str(((bclass*) var_toobj(value))->name));
break;
default: default:
{ {
char error[64]; char error[64];
@ -87,6 +90,23 @@ static void m_solidify_bvalue(bvm *vm, bvalue * value)
} }
} }
static void m_solidify_subclass(bvm *vm, bclass *cl, int builtins);
/* solidify any inner class */
static void m_solidify_proto_inner_class(bvm *vm, bproto *pr, int builtins)
{
// parse any class in constants to output it first
if (pr->nconst > 0) {
for (int k = 0; k < pr->nconst; k++) {
if (var_type(&pr->ktab[k]) == BE_CLASS) {
// output the class
m_solidify_subclass(vm, (bclass*) var_toobj(&pr->ktab[k]), builtins);
}
}
}
}
static void m_solidify_proto(bvm *vm, bproto *pr, const char * func_name, int builtins, int indent) static void m_solidify_proto(bvm *vm, bproto *pr, const char * func_name, int builtins, int indent)
{ {
// const char * func_name = str(pr->name); // const char * func_name = str(pr->name);
@ -172,12 +192,15 @@ static void m_solidify_closure(bvm *vm, bclosure *cl, int builtins)
be_raise(vm, "internal_error", "Unsupported upvals in closure"); be_raise(vm, "internal_error", "Unsupported upvals in closure");
} }
int indent = 2;
m_solidify_proto_inner_class(vm, pr, builtins);
logfmt("\n"); logfmt("\n");
logfmt("/********************************************************************\n"); logfmt("/********************************************************************\n");
logfmt("** Solidified function: %s\n", func_name); logfmt("** Solidified function: %s\n", func_name);
logfmt("********************************************************************/\n"); logfmt("********************************************************************/\n");
int indent = 2;
logfmt("be_local_closure(%s, /* name */\n", func_name); logfmt("be_local_closure(%s, /* name */\n", func_name);
m_solidify_proto(vm, pr, func_name, builtins, indent); m_solidify_proto(vm, pr, func_name, builtins, indent);
@ -188,8 +211,7 @@ static void m_solidify_closure(bvm *vm, bclosure *cl, int builtins)
logfmt("/*******************************************************************/\n\n"); logfmt("/*******************************************************************/\n\n");
} }
static void m_solidify_subclass(bvm *vm, bclass *cl, int builtins)
static void m_solidify_class(bvm *vm, bclass *cl, int builtins)
{ {
const char * class_name = str(cl->name); const char * class_name = str(cl->name);
@ -251,6 +273,14 @@ static void m_solidify_class(bvm *vm, bclass *cl, int builtins)
logfmt(" (be_nested_const_str(\"%s\", %i, %i))\n", class_name, be_strhash(cl->name), str_len(cl->name)); logfmt(" (be_nested_const_str(\"%s\", %i, %i))\n", class_name, be_strhash(cl->name), str_len(cl->name));
logfmt(");\n"); logfmt(");\n");
}
static void m_solidify_class(bvm *vm, bclass *cl, int builtins)
{
const char * class_name = str(cl->name);
m_solidify_subclass(vm, cl, builtins);
logfmt("/*******************************************************************/\n\n"); logfmt("/*******************************************************************/\n\n");
logfmt("void be_load_%s_class(bvm *vm) {\n", class_name); logfmt("void be_load_%s_class(bvm *vm) {\n", class_name);

2
tasmota/xdrv_52_7_berry_embedded.ino
View File

@ -26,7 +26,7 @@
\*********************************************************************************************/ \*********************************************************************************************/
const char berry_prog[] = const char berry_prog[] =
"" "import persist "
// create a 'ntv' module to allow functions to be registered in a safe namespace // create a 'ntv' module to allow functions to be registered in a safe namespace
// "ntv = module('ntv') " // "ntv = module('ntv') "