stmhal: Add stm module, which contains some constants for the MCU.
Also contains raw memory read/write functions, read8, read16, read32,
write8, write16, write32. Can now do:
stm.write16(stm.GPIOA + stm.GPIO_BSRRL, 1 << 13)
This turns on the red LED.
With the new constant folding, the above constants for the GPIO address
are actually compiled to constants (and the addition done) at compile
time. For viper code and inline assembler, this optimisation will make
a big difference. In the inline assembler, using these constants would
not be possible without this constant folding.
2014-04-10 22:46:40 +01:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
|
2014-04-18 22:38:09 +01:00
|
|
|
#include "stm32f4xx_hal.h"
|
stmhal: Add stm module, which contains some constants for the MCU.
Also contains raw memory read/write functions, read8, read16, read32,
write8, write16, write32. Can now do:
stm.write16(stm.GPIOA + stm.GPIO_BSRRL, 1 << 13)
This turns on the red LED.
With the new constant folding, the above constants for the GPIO address
are actually compiled to constants (and the addition done) at compile
time. For viper code and inline assembler, this optimisation will make
a big difference. In the inline assembler, using these constants would
not be possible without this constant folding.
2014-04-10 22:46:40 +01:00
|
|
|
|
|
|
|
#include "nlr.h"
|
|
|
|
#include "misc.h"
|
|
|
|
#include "mpconfig.h"
|
|
|
|
#include "qstr.h"
|
|
|
|
#include "obj.h"
|
|
|
|
#include "modstm.h"
|
|
|
|
|
2014-04-18 22:38:09 +01:00
|
|
|
// To use compile-time constants we are restricted to 31-bit numbers (a small int,
|
|
|
|
// so it fits in a Micro Python object pointer). Thus, when extracting a constant
|
|
|
|
// from an object, we must clear the MSB.
|
|
|
|
|
stmhal: Add stm module, which contains some constants for the MCU.
Also contains raw memory read/write functions, read8, read16, read32,
write8, write16, write32. Can now do:
stm.write16(stm.GPIOA + stm.GPIO_BSRRL, 1 << 13)
This turns on the red LED.
With the new constant folding, the above constants for the GPIO address
are actually compiled to constants (and the addition done) at compile
time. For viper code and inline assembler, this optimisation will make
a big difference. In the inline assembler, using these constants would
not be possible without this constant folding.
2014-04-10 22:46:40 +01:00
|
|
|
STATIC uint32_t get_read_addr(mp_obj_t addr_o, uint align) {
|
|
|
|
uint32_t addr = mp_obj_get_int(addr_o) & 0x7fffffff;
|
2014-04-18 22:38:09 +01:00
|
|
|
/*
|
stmhal: Add stm module, which contains some constants for the MCU.
Also contains raw memory read/write functions, read8, read16, read32,
write8, write16, write32. Can now do:
stm.write16(stm.GPIOA + stm.GPIO_BSRRL, 1 << 13)
This turns on the red LED.
With the new constant folding, the above constants for the GPIO address
are actually compiled to constants (and the addition done) at compile
time. For viper code and inline assembler, this optimisation will make
a big difference. In the inline assembler, using these constants would
not be possible without this constant folding.
2014-04-10 22:46:40 +01:00
|
|
|
if (addr < 0x10000000) {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "cannot read from address %08x", addr));
|
|
|
|
}
|
2014-04-18 22:38:09 +01:00
|
|
|
*/
|
stmhal: Add stm module, which contains some constants for the MCU.
Also contains raw memory read/write functions, read8, read16, read32,
write8, write16, write32. Can now do:
stm.write16(stm.GPIOA + stm.GPIO_BSRRL, 1 << 13)
This turns on the red LED.
With the new constant folding, the above constants for the GPIO address
are actually compiled to constants (and the addition done) at compile
time. For viper code and inline assembler, this optimisation will make
a big difference. In the inline assembler, using these constants would
not be possible without this constant folding.
2014-04-10 22:46:40 +01:00
|
|
|
if ((addr & (align - 1)) != 0) {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "address %08x is not aligned to %d bytes", addr, align));
|
|
|
|
}
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC uint32_t get_write_addr(mp_obj_t addr_o, uint align) {
|
|
|
|
uint32_t addr = mp_obj_get_int(addr_o) & 0x7fffffff;
|
|
|
|
if (addr < 0x10000000) {
|
2014-04-18 22:38:09 +01:00
|
|
|
// Everything below 0x10000000 is either ROM or aliased to something higher, so we don't
|
|
|
|
// lose anything by restricting writes to this area, and we gain some safety.
|
stmhal: Add stm module, which contains some constants for the MCU.
Also contains raw memory read/write functions, read8, read16, read32,
write8, write16, write32. Can now do:
stm.write16(stm.GPIOA + stm.GPIO_BSRRL, 1 << 13)
This turns on the red LED.
With the new constant folding, the above constants for the GPIO address
are actually compiled to constants (and the addition done) at compile
time. For viper code and inline assembler, this optimisation will make
a big difference. In the inline assembler, using these constants would
not be possible without this constant folding.
2014-04-10 22:46:40 +01:00
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "cannot write to address %08x", addr));
|
|
|
|
}
|
|
|
|
if ((addr & (align - 1)) != 0) {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "address %08x is not aligned to %d bytes", addr, align));
|
|
|
|
}
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
2014-04-18 22:38:09 +01:00
|
|
|
typedef struct _stm_mem_obj_t {
|
|
|
|
mp_obj_base_t base;
|
|
|
|
uint32_t elem_size; // in bytes
|
|
|
|
} stm_mem_obj_t;
|
stmhal: Add stm module, which contains some constants for the MCU.
Also contains raw memory read/write functions, read8, read16, read32,
write8, write16, write32. Can now do:
stm.write16(stm.GPIOA + stm.GPIO_BSRRL, 1 << 13)
This turns on the red LED.
With the new constant folding, the above constants for the GPIO address
are actually compiled to constants (and the addition done) at compile
time. For viper code and inline assembler, this optimisation will make
a big difference. In the inline assembler, using these constants would
not be possible without this constant folding.
2014-04-10 22:46:40 +01:00
|
|
|
|
2014-04-18 22:38:09 +01:00
|
|
|
STATIC void stm_mem_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
|
|
|
|
stm_mem_obj_t *self = self_in;
|
|
|
|
print(env, "<%u-bit memory>", 8 * self->elem_size);
|
stmhal: Add stm module, which contains some constants for the MCU.
Also contains raw memory read/write functions, read8, read16, read32,
write8, write16, write32. Can now do:
stm.write16(stm.GPIOA + stm.GPIO_BSRRL, 1 << 13)
This turns on the red LED.
With the new constant folding, the above constants for the GPIO address
are actually compiled to constants (and the addition done) at compile
time. For viper code and inline assembler, this optimisation will make
a big difference. In the inline assembler, using these constants would
not be possible without this constant folding.
2014-04-10 22:46:40 +01:00
|
|
|
}
|
|
|
|
|
2014-04-18 22:38:09 +01:00
|
|
|
STATIC mp_obj_t stm_mem_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
|
|
|
|
// TODO support slice index to read/write multiple values at once
|
|
|
|
stm_mem_obj_t *self = self_in;
|
|
|
|
if (value == MP_OBJ_NULL) {
|
|
|
|
// delete
|
|
|
|
return MP_OBJ_NOT_SUPPORTED;
|
|
|
|
} else if (value == MP_OBJ_SENTINEL) {
|
|
|
|
// load
|
|
|
|
uint32_t addr = get_read_addr(index, self->elem_size);
|
|
|
|
uint32_t val;
|
|
|
|
switch (self->elem_size) {
|
|
|
|
case 1: val = (*(uint8_t*)addr); break;
|
|
|
|
case 2: val = (*(uint16_t*)addr); break;
|
|
|
|
default: val = (*(uint32_t*)addr); break;
|
|
|
|
}
|
|
|
|
return mp_obj_new_int(val);
|
|
|
|
} else {
|
|
|
|
// store
|
|
|
|
uint32_t addr = get_write_addr(index, self->elem_size);
|
|
|
|
uint32_t val = mp_obj_get_int(value);
|
|
|
|
switch (self->elem_size) {
|
|
|
|
case 1: (*(uint8_t*)addr) = val; break;
|
|
|
|
case 2: (*(uint16_t*)addr) = val; break;
|
|
|
|
default: (*(uint32_t*)addr) = val; break;
|
|
|
|
}
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
stmhal: Add stm module, which contains some constants for the MCU.
Also contains raw memory read/write functions, read8, read16, read32,
write8, write16, write32. Can now do:
stm.write16(stm.GPIOA + stm.GPIO_BSRRL, 1 << 13)
This turns on the red LED.
With the new constant folding, the above constants for the GPIO address
are actually compiled to constants (and the addition done) at compile
time. For viper code and inline assembler, this optimisation will make
a big difference. In the inline assembler, using these constants would
not be possible without this constant folding.
2014-04-10 22:46:40 +01:00
|
|
|
}
|
|
|
|
|
2014-04-18 22:38:09 +01:00
|
|
|
STATIC const mp_obj_type_t stm_mem_type = {
|
|
|
|
{ &mp_type_type },
|
|
|
|
.name = MP_QSTR_mem,
|
|
|
|
.print = stm_mem_print,
|
|
|
|
.subscr = stm_mem_subscr,
|
|
|
|
};
|
stmhal: Add stm module, which contains some constants for the MCU.
Also contains raw memory read/write functions, read8, read16, read32,
write8, write16, write32. Can now do:
stm.write16(stm.GPIOA + stm.GPIO_BSRRL, 1 << 13)
This turns on the red LED.
With the new constant folding, the above constants for the GPIO address
are actually compiled to constants (and the addition done) at compile
time. For viper code and inline assembler, this optimisation will make
a big difference. In the inline assembler, using these constants would
not be possible without this constant folding.
2014-04-10 22:46:40 +01:00
|
|
|
|
2014-04-18 22:38:09 +01:00
|
|
|
STATIC const stm_mem_obj_t stm_mem8_obj = {{&stm_mem_type}, 1};
|
|
|
|
STATIC const stm_mem_obj_t stm_mem16_obj = {{&stm_mem_type}, 2};
|
|
|
|
STATIC const stm_mem_obj_t stm_mem32_obj = {{&stm_mem_type}, 4};
|
stmhal: Add stm module, which contains some constants for the MCU.
Also contains raw memory read/write functions, read8, read16, read32,
write8, write16, write32. Can now do:
stm.write16(stm.GPIOA + stm.GPIO_BSRRL, 1 << 13)
This turns on the red LED.
With the new constant folding, the above constants for the GPIO address
are actually compiled to constants (and the addition done) at compile
time. For viper code and inline assembler, this optimisation will make
a big difference. In the inline assembler, using these constants would
not be possible without this constant folding.
2014-04-10 22:46:40 +01:00
|
|
|
|
|
|
|
STATIC const mp_map_elem_t stm_module_globals_table[] = {
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_stm) },
|
|
|
|
|
2014-04-18 22:38:09 +01:00
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_mem8), (mp_obj_t)&stm_mem8_obj },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_mem16), (mp_obj_t)&stm_mem16_obj },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_mem32), (mp_obj_t)&stm_mem32_obj },
|
stmhal: Add stm module, which contains some constants for the MCU.
Also contains raw memory read/write functions, read8, read16, read32,
write8, write16, write32. Can now do:
stm.write16(stm.GPIOA + stm.GPIO_BSRRL, 1 << 13)
This turns on the red LED.
With the new constant folding, the above constants for the GPIO address
are actually compiled to constants (and the addition done) at compile
time. For viper code and inline assembler, this optimisation will make
a big difference. In the inline assembler, using these constants would
not be possible without this constant folding.
2014-04-10 22:46:40 +01:00
|
|
|
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_GPIOA), MP_OBJ_NEW_SMALL_INT(GPIOA_BASE) },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_GPIOB), MP_OBJ_NEW_SMALL_INT(GPIOB_BASE) },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_GPIOC), MP_OBJ_NEW_SMALL_INT(GPIOC_BASE) },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_GPIOD), MP_OBJ_NEW_SMALL_INT(GPIOD_BASE) },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_GPIO_IDR), MP_OBJ_NEW_SMALL_INT(0x10) },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_GPIO_BSRRL), MP_OBJ_NEW_SMALL_INT(0x18) },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_GPIO_BSRRH), MP_OBJ_NEW_SMALL_INT(0x1a) },
|
|
|
|
};
|
|
|
|
|
|
|
|
STATIC const mp_obj_dict_t stm_module_globals = {
|
|
|
|
.base = {&mp_type_dict},
|
|
|
|
.map = {
|
|
|
|
.all_keys_are_qstrs = 1,
|
|
|
|
.table_is_fixed_array = 1,
|
|
|
|
.used = sizeof(stm_module_globals_table) / sizeof(mp_map_elem_t),
|
|
|
|
.alloc = sizeof(stm_module_globals_table) / sizeof(mp_map_elem_t),
|
|
|
|
.table = (mp_map_elem_t*)stm_module_globals_table,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
const mp_obj_module_t stm_module = {
|
|
|
|
.base = { &mp_type_module },
|
|
|
|
.name = MP_QSTR_stm,
|
|
|
|
.globals = (mp_obj_dict_t*)&stm_module_globals,
|
|
|
|
};
|