CircuitPython - a Python implementation for teaching coding with microcontrollers https://git.suspectdevices.com/suspect-devices/circuitpython/atom?h=2.x 2017-07-31T08:35:40+00:00 2017-07-31T08:35:40+00:00 Alexander Steffen devel.20.webmeister@spamgourmet.com 2017-06-30T07:22:17+00:00 urn:sha1:55f33240f3d7051d4213629e92437a36f1fac50e There were several different spellings of MicroPython present in comments, when there should be only one. 2017-07-18T01:57:39+00:00 Alexander Steffen devel.20.webmeister@spamgourmet.com 2017-06-29T21:14:58+00:00 urn:sha1:299bc625864b9e624ed599c94a5f95870516139a The code conventions suggest using header guards, but do not define how those should look like and instead point to existing files. However, not all existing files follow the same scheme, sometimes omitting header guards altogether, sometimes using non-standard names, making it easy to accidentally pick a "wrong" example. This commit ensures that all header files of the MicroPython project (that were not simply copied from somewhere else) follow the same pattern, that was already present in the majority of files, especially in the py folder. The rules are as follows. Naming convention: * start with the words MICROPY_INCLUDED * contain the full path to the file * replace special characters with _ In addition, there are no empty lines before #ifndef, between #ifndef and one empty line before #endif. #endif is followed by a comment containing the name of the guard macro. py/grammar.h cannot use header guards by design, since it has to be included multiple times in a single C file. Several other files also do not need header guards as they are only used internally and guaranteed to be included only once: * MICROPY_MPHALPORT_H * mpconfigboard.h * mpconfigport.h * mpthreadport.h * pin_defs_*.h * qstrdefs*.h 2017-04-22T13:39:20+00:00 Damien George damien.p.george@gmail.com 2017-04-18T23:45:59+00:00 urn:sha1:dd11af209d226b7d18d5148b239662e30ed60bad This patch allows the following code to run without allocating on the heap: super().foo(...) Before this patch such a call would allocate a super object on the heap and then load the foo method and call it right away. The super object is only needed to perform the lookup of the method and not needed after that. This patch makes an optimisation to allocate the super object on the C stack and discard it right after use. Changes in code size due to this patch are: bare-arm: +128 minimal: +232 unix x64: +416 unix nanbox: +364 stmhal: +184 esp8266: +340 cc3200: +128 2017-02-16T07:38:06+00:00 Damien George damien.p.george@gmail.com 2017-01-17T04:30:18+00:00 urn:sha1:30b42dd72d4aa310e8c96ccbaf75150f8649c262 2017-02-16T07:38:06+00:00 Damien George damien.p.george@gmail.com 2016-01-09T23:59:52+00:00 urn:sha1:f4df3aaa72a0460614b1ab8b7b8a7927a1165e31 So that the "for x in it: ..." statement can now work without using the heap (so long as the iterator argument fits in an iter_buf structure). 2016-12-09T10:23:17+00:00 Damien George damien.p.george@gmail.com 2016-12-09T10:23:17+00:00 urn:sha1:e920bab9768f71c7e22fcfc5af3e1c40f2db8eeb This patch moves some common code from the individual inline assemblers to the compiler, the code that calls the emit-glue to assign the machine code to the functions scope. 2016-12-09T09:54:54+00:00 Damien George damien.p.george@gmail.com 2016-12-09T09:54:54+00:00 urn:sha1:dd53b12193dca4800ab207170fcc883142dd0f22 These are generic methods that don't depend on the architecture and so can be handled directly by the compiler. 2016-12-09T06:07:38+00:00 Damien George damien.p.george@gmail.com 2016-12-09T06:03:33+00:00 urn:sha1:f76b1bfa9f59fcfa03837c6934ad51d2db3ff4a3 This patch adds the MICROPY_EMIT_INLINE_XTENSA option, which, when enabled, allows the @micropython.asm_xtensa decorator to be used. The following opcodes are currently supported (ax is a register, a0-a15): ret_n() callx0(ax) j(label) jx(ax) beqz(ax, label) bnez(ax, label) mov(ax, ay) movi(ax, imm) # imm can be full 32-bit, uses l32r if needed and_(ax, ay, az) or_(ax, ay, az) xor(ax, ay, az) add(ax, ay, az) sub(ax, ay, az) mull(ax, ay, az) l8ui(ax, ay, imm) l16ui(ax, ay, imm) l32i(ax, ay, imm) s8i(ax, ay, imm) s16i(ax, ay, imm) s32i(ax, ay, imm) l16si(ax, ay, imm) addi(ax, ay, imm) ball(ax, ay, label) bany(ax, ay, label) bbc(ax, ay, label) bbs(ax, ay, label) beq(ax, ay, label) bge(ax, ay, label) bgeu(ax, ay, label) blt(ax, ay, label) bnall(ax, ay, label) bne(ax, ay, label) bnone(ax, ay, label) Upon entry to the assembly function the registers a0, a12, a13, a14 are pushed to the stack and the stack pointer (a1) decreased by 16. Upon exit, these registers and the stack pointer are restored, and ret.n is executed to return to the caller (caller address is in a0). Note that the ABI for the Xtensa emitters is non-windowing. 2016-12-09T05:51:49+00:00 Damien George damien.p.george@gmail.com 2016-12-09T05:39:39+00:00 urn:sha1:8e5aced1fd4845b23b203d8d15f9b34b6b022ceb The config option MICROPY_EMIT_XTENSA can now be enabled to target the Xtensa architecture with @micropython.native and @micropython.viper decorators. 2016-12-09T02:28:25+00:00 Damien George damien.p.george@gmail.com 2016-12-09T02:28:25+00:00 urn:sha1:c2713592bc5dd2c9bcd9c306ec8c907c0125c8f7