kopia lustrzana https://github.com/micropython/micropython
stmhal: Add Timer class: simple TIM control, incl callback on IRQ.
Simple but functional timer control. More sophistication will eventually be added, or for now just use direct register access :) Also added pyb.freq() function to get MCU clock frequencies.pull/515/head
Damien George
rodzic
e5f8a77db6
commit
7fdfa93700
|
|
@ -78,7 +78,8 @@ void __fatal_error(const char *msg) {
|
|||
led_toggle(((i++) & 3) + 1);
|
||||
for (volatile uint delay = 0; delay < 10000000; delay++) {
|
||||
}
|
||||
if (i >= 8) {
|
||||
if (i >= 16) {
|
||||
// to conserve power
|
||||
__WFI();
|
||||
}
|
||||
}
|
||||
|
|
@ -457,15 +458,12 @@ soft_reset:
|
|||
}
|
||||
#endif
|
||||
|
||||
timer_init0();
|
||||
|
||||
#if MICROPY_HW_ENABLE_RNG
|
||||
rng_init0();
|
||||
#endif
|
||||
|
||||
#if MICROPY_HW_ENABLE_TIMER
|
||||
// timer
|
||||
//timer_init();
|
||||
#endif
|
||||
|
||||
i2c_init0();
|
||||
spi_init0();
|
||||
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@
|
|||
#include "pyexec.h"
|
||||
#include "led.h"
|
||||
#include "pin.h"
|
||||
#include "timer.h"
|
||||
#include "extint.h"
|
||||
#include "usrsw.h"
|
||||
#include "rng.h"
|
||||
|
|
@ -31,14 +32,7 @@
|
|||
#include "modpyb.h"
|
||||
#include "ff.h"
|
||||
|
||||
STATIC mp_obj_t pyb_unique_id(void) {
|
||||
// get unique id; 96 bits
|
||||
byte *id = (byte*)0x1fff7a10;
|
||||
return mp_obj_new_bytes(id, 12);
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_unique_id_obj, pyb_unique_id);
|
||||
|
||||
// get lots of info about the board
|
||||
// print lots of info about the board
|
||||
STATIC mp_obj_t pyb_info(uint n_args, const mp_obj_t *args) {
|
||||
// get and print unique id; 96 bits
|
||||
{
|
||||
|
|
@ -103,28 +97,44 @@ STATIC mp_obj_t pyb_info(uint n_args, const mp_obj_t *args) {
|
|||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_info_obj, 0, 1, pyb_info);
|
||||
|
||||
// get unique MCU id; 96 bits = 12 bytes
|
||||
STATIC mp_obj_t pyb_unique_id(void) {
|
||||
byte *id = (byte*)0x1fff7a10;
|
||||
return mp_obj_new_bytes(id, 12);
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_unique_id_obj, pyb_unique_id);
|
||||
|
||||
// get clock frequencies
|
||||
// TODO should also be able to set frequency via this function
|
||||
STATIC mp_obj_t pyb_freq(void) {
|
||||
mp_obj_t tuple[4] = {
|
||||
mp_obj_new_int(HAL_RCC_GetSysClockFreq()),
|
||||
mp_obj_new_int(HAL_RCC_GetHCLKFreq()),
|
||||
mp_obj_new_int(HAL_RCC_GetPCLK1Freq()),
|
||||
mp_obj_new_int(HAL_RCC_GetPCLK2Freq()),
|
||||
};
|
||||
return mp_obj_new_tuple(4, tuple);
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_freq_obj, pyb_freq);
|
||||
|
||||
// sync all file systems
|
||||
STATIC mp_obj_t pyb_sync(void) {
|
||||
storage_flush();
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_sync_obj, pyb_sync);
|
||||
|
||||
STATIC mp_obj_t pyb_millis(void) {
|
||||
return mp_obj_new_int(HAL_GetTick());
|
||||
}
|
||||
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_millis_obj, pyb_millis);
|
||||
|
||||
STATIC mp_obj_t pyb_delay(mp_obj_t count) {
|
||||
HAL_Delay(mp_obj_get_int(count));
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_delay_obj, pyb_delay);
|
||||
|
||||
STATIC mp_obj_t pyb_udelay(mp_obj_t usec) {
|
||||
|
|
@ -241,8 +251,9 @@ MP_DECLARE_CONST_FUN_OBJ(pyb_usb_mode_obj); // defined in main.c
|
|||
STATIC const mp_map_elem_t pyb_module_globals_table[] = {
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_pyb) },
|
||||
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_unique_id), (mp_obj_t)&pyb_unique_id_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_info), (mp_obj_t)&pyb_info_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_unique_id), (mp_obj_t)&pyb_unique_id_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_freq), (mp_obj_t)&pyb_freq_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_gc), (mp_obj_t)&pyb_gc_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_repl_info), (mp_obj_t)&pyb_set_repl_info_obj },
|
||||
|
||||
|
|
@ -264,6 +275,8 @@ STATIC const mp_map_elem_t pyb_module_globals_table[] = {
|
|||
{ MP_OBJ_NEW_QSTR(MP_QSTR_udelay), (mp_obj_t)&pyb_udelay_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_sync), (mp_obj_t)&pyb_sync_obj },
|
||||
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_Timer), (mp_obj_t)&pyb_timer_type },
|
||||
|
||||
#if MICROPY_HW_ENABLE_RNG
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_rng), (mp_obj_t)&pyb_rng_get_obj },
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -91,6 +91,16 @@ Q(all)
|
|||
Q(send)
|
||||
Q(recv)
|
||||
|
||||
// for Timer class
|
||||
Q(Timer)
|
||||
Q(counter)
|
||||
Q(prescaler)
|
||||
Q(period)
|
||||
Q(callback)
|
||||
Q(freq)
|
||||
Q(mode)
|
||||
Q(div)
|
||||
|
||||
// for ExtInt class
|
||||
Q(ExtInt)
|
||||
Q(pin)
|
||||
|
|
|
|||
|
|
@ -355,12 +355,55 @@ void RTC_WKUP_IRQHandler(void) {
|
|||
Handle_EXTI_Irq(EXTI_RTC_WAKEUP);
|
||||
}
|
||||
|
||||
void TIM1_BRK_TIM9_IRQHandler(void) {
|
||||
timer_irq_handler(9);
|
||||
}
|
||||
|
||||
void TIM1_UP_TIM10_IRQHandler(void) {
|
||||
timer_irq_handler(1);
|
||||
timer_irq_handler(10);
|
||||
}
|
||||
|
||||
void TIM1_TRG_COM_TIM11_IRQHandler(void) {
|
||||
timer_irq_handler(11);
|
||||
}
|
||||
|
||||
void TIM2_IRQHandler(void) {
|
||||
timer_irq_handler(2);
|
||||
}
|
||||
|
||||
void TIM3_IRQHandler(void) {
|
||||
HAL_TIM_IRQHandler(&TIM3_Handle);
|
||||
}
|
||||
|
||||
void TIM4_IRQHandler(void) {
|
||||
timer_irq_handler(4);
|
||||
}
|
||||
|
||||
void TIM5_IRQHandler(void) {
|
||||
timer_irq_handler(5);
|
||||
HAL_TIM_IRQHandler(&TIM5_Handle);
|
||||
}
|
||||
|
||||
void TIM6_DAC_IRQHandler(void) {
|
||||
timer_irq_handler(6);
|
||||
}
|
||||
|
||||
void TIM7_IRQHandler(void) {
|
||||
timer_irq_handler(7);
|
||||
}
|
||||
|
||||
void TIM8_BRK_TIM12_IRQHandler(void) {
|
||||
timer_irq_handler(12);
|
||||
}
|
||||
|
||||
void TIM8_UP_TIM13_IRQHandler(void) {
|
||||
timer_irq_handler(8);
|
||||
timer_irq_handler(13);
|
||||
}
|
||||
|
||||
void TIM8_TRG_COM_TIM14_IRQHandler(void) {
|
||||
timer_irq_handler(14);
|
||||
}
|
||||
|
||||
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
||||
|
|
|
|||
384
stmhal/timer.c
384
stmhal/timer.c
|
|
@ -10,6 +10,7 @@
|
|||
#include "misc.h"
|
||||
#include "mpconfig.h"
|
||||
#include "qstr.h"
|
||||
#include "gc.h"
|
||||
#include "obj.h"
|
||||
#include "runtime.h"
|
||||
#include "timer.h"
|
||||
|
|
@ -25,6 +26,27 @@
|
|||
//
|
||||
// TIM5:
|
||||
// - servo controller, PWM
|
||||
//
|
||||
// TIM6:
|
||||
// - ADC, DAC for read_timed and write_timed
|
||||
//
|
||||
// Python usage model:
|
||||
//
|
||||
// tim = pyb.Timer(4, freq=100) # freq in Hz
|
||||
// tim = pyb.Timer(4, prescaler=1, period=100)
|
||||
// tim.counter() # get counter (can also set)
|
||||
// tim.prescaler(2) # set prescaler (can also get)
|
||||
// tim.period(200) # set period (can also get)
|
||||
// tim.callback(lambda t: ...) # set callback for update interrupt (t=tim instance)
|
||||
// tim.callback(None) # clear callback
|
||||
|
||||
typedef struct _pyb_timer_obj_t {
|
||||
mp_obj_base_t base;
|
||||
machine_uint_t tim_id;
|
||||
mp_obj_t callback;
|
||||
TIM_HandleTypeDef tim;
|
||||
IRQn_Type irqn;
|
||||
} pyb_timer_obj_t;
|
||||
|
||||
TIM_HandleTypeDef TIM3_Handle;
|
||||
TIM_HandleTypeDef TIM5_Handle;
|
||||
|
|
@ -33,6 +55,17 @@ TIM_HandleTypeDef TIM6_Handle;
|
|||
// Used to divide down TIM3 and periodically call the flash storage IRQ
|
||||
static uint32_t tim3_counter = 0;
|
||||
|
||||
// Used to do callbacks to Python code on interrupt
|
||||
STATIC pyb_timer_obj_t *pyb_timer_obj_all[14];
|
||||
#define PYB_TIMER_OBJ_ALL_NUM (sizeof(pyb_timer_obj_all) / sizeof(pyb_timer_obj_all[0]))
|
||||
|
||||
void timer_init0(void) {
|
||||
tim3_counter = 0;
|
||||
for (uint i = 0; i < PYB_TIMER_OBJ_ALL_NUM; i++) {
|
||||
pyb_timer_obj_all[i] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
// TIM3 is set-up for the USB CDC interface
|
||||
void timer_tim3_init(void) {
|
||||
// set up the timer for USBD CDC
|
||||
|
|
@ -89,7 +122,7 @@ void timer_tim6_init(uint freq) {
|
|||
|
||||
// Timer runs at SystemCoreClock / 2
|
||||
// Compute the prescaler value so TIM6 triggers at freq-Hz
|
||||
uint32_t period = (SystemCoreClock / 2) / freq;
|
||||
uint32_t period = MAX(1, (SystemCoreClock / 2) / freq);
|
||||
uint32_t prescaler = 1;
|
||||
while (period > 0xffff) {
|
||||
period >>= 1;
|
||||
|
|
@ -121,107 +154,282 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
|
|||
}
|
||||
}
|
||||
|
||||
// below is old code from stm/ which has not yet been fully ported to stmhal/
|
||||
#if 0
|
||||
typedef struct _pyb_hal_tim_t {
|
||||
mp_obj_base_t base;
|
||||
TIM_HandleTypeDef htim;
|
||||
} pyb_hal_tim_t;
|
||||
/******************************************************************************/
|
||||
/* Micro Python bindings */
|
||||
|
||||
pyb_hal_tim_t pyb_hal_tim_6;
|
||||
STATIC void pyb_timer_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
|
||||
pyb_timer_obj_t *self = self_in;
|
||||
|
||||
pyb_hal_tim_6 = {
|
||||
.base = {&pyb_type_hal_tim};
|
||||
.htim = {TIM6
|
||||
if (self->tim.State == HAL_TIM_STATE_RESET) {
|
||||
print(env, "Timer(%u)", self->tim_id);
|
||||
} else {
|
||||
print(env, "Timer(%u, prescaler=%u, period=%u, mode=%u, div=%u)",
|
||||
self->tim_id,
|
||||
self->tim.Init.Prescaler,
|
||||
self->tim.Init.Period,
|
||||
self->tim.Init.CounterMode,
|
||||
self->tim.Init.ClockDivision
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// TIM6 is used as an internal interrup to schedule something at a specific rate
|
||||
STATIC const mp_arg_parse_t pyb_timer_init_accepted_args[] = {
|
||||
{ MP_QSTR_freq, MP_ARG_PARSE_KW_ONLY | MP_ARG_PARSE_INT, {.u_int = 0xffffffff} },
|
||||
{ MP_QSTR_prescaler, MP_ARG_PARSE_KW_ONLY | MP_ARG_PARSE_INT, {.u_int = 0xffffffff} },
|
||||
{ MP_QSTR_period, MP_ARG_PARSE_KW_ONLY | MP_ARG_PARSE_INT, {.u_int = 0xffffffff} },
|
||||
{ MP_QSTR_mode, MP_ARG_PARSE_KW_ONLY | MP_ARG_PARSE_INT, {.u_int = TIM_COUNTERMODE_UP} },
|
||||
{ MP_QSTR_div, MP_ARG_PARSE_KW_ONLY | MP_ARG_PARSE_INT, {.u_int = TIM_CLOCKDIVISION_DIV1} },
|
||||
};
|
||||
#define PYB_TIMER_INIT_NUM_ARGS (sizeof(pyb_timer_init_accepted_args) / sizeof(pyb_timer_init_accepted_args[0]))
|
||||
|
||||
STATIC mp_obj_t pyb_timer_init_helper(pyb_timer_obj_t *self, uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
|
||||
// parse args
|
||||
mp_arg_parse_val_t vals[PYB_TIMER_INIT_NUM_ARGS];
|
||||
mp_arg_parse_all(n_args, args, kw_args, PYB_TIMER_INIT_NUM_ARGS, pyb_timer_init_accepted_args, vals);
|
||||
|
||||
// set the TIM configuration values
|
||||
TIM_Base_InitTypeDef *init = &self->tim.Init;
|
||||
|
||||
if (vals[0].u_int != 0xffffffff) {
|
||||
// set prescaler and period from frequency
|
||||
|
||||
if (vals[0].u_int == 0) {
|
||||
nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "can't have 0 frequency"));
|
||||
}
|
||||
|
||||
// work out TIM's clock source
|
||||
uint tim_clock;
|
||||
if (self->tim_id == 1 || (8 <= self->tim_id && self->tim_id <= 11)) {
|
||||
// TIM{1,8,9,10,11} are on APB2
|
||||
tim_clock = HAL_RCC_GetPCLK2Freq();
|
||||
} else {
|
||||
// TIM{2,3,4,5,6,7,12,13,14} are on APB1
|
||||
tim_clock = HAL_RCC_GetPCLK1Freq();
|
||||
}
|
||||
|
||||
// compute the prescaler value so TIM triggers at freq-Hz
|
||||
// dpgeorge: I don't understand why we need to multiply tim_clock by 2
|
||||
uint32_t period = MAX(1, 2 * tim_clock / vals[0].u_int);
|
||||
uint32_t prescaler = 1;
|
||||
while (period > 0xffff) {
|
||||
period >>= 1;
|
||||
prescaler <<= 1;
|
||||
}
|
||||
init->Prescaler = prescaler - 1;
|
||||
init->Period = period - 1;
|
||||
} else if (vals[1].u_int != 0xffffffff && vals[2].u_int != 0xffffffff) {
|
||||
// set prescaler and period directly
|
||||
init->Prescaler = vals[1].u_int;
|
||||
init->Period = vals[2].u_int;
|
||||
} else {
|
||||
nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "must specify either freq, or prescaler and period"));
|
||||
}
|
||||
|
||||
init->CounterMode = vals[3].u_int;
|
||||
init->ClockDivision = vals[4].u_int;
|
||||
init->RepetitionCounter = 0;
|
||||
|
||||
// init the TIM peripheral
|
||||
switch (self->tim_id) {
|
||||
case 1: __TIM1_CLK_ENABLE(); break;
|
||||
case 2: __TIM2_CLK_ENABLE(); break;
|
||||
case 3: __TIM3_CLK_ENABLE(); break;
|
||||
case 4: __TIM4_CLK_ENABLE(); break;
|
||||
case 5: __TIM5_CLK_ENABLE(); break;
|
||||
case 6: __TIM6_CLK_ENABLE(); break;
|
||||
case 7: __TIM7_CLK_ENABLE(); break;
|
||||
case 8: __TIM8_CLK_ENABLE(); break;
|
||||
case 9: __TIM9_CLK_ENABLE(); break;
|
||||
case 10: __TIM10_CLK_ENABLE(); break;
|
||||
case 11: __TIM11_CLK_ENABLE(); break;
|
||||
case 12: __TIM12_CLK_ENABLE(); break;
|
||||
case 13: __TIM13_CLK_ENABLE(); break;
|
||||
case 14: __TIM14_CLK_ENABLE(); break;
|
||||
}
|
||||
HAL_TIM_Base_Init(&self->tim);
|
||||
HAL_TIM_Base_Start(&self->tim);
|
||||
|
||||
// set the priority (if not a special timer)
|
||||
if (self->tim_id != 3 && self->tim_id != 5) {
|
||||
HAL_NVIC_SetPriority(self->irqn, 0xe, 0xe); // next-to lowest priority
|
||||
}
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
STATIC mp_obj_t pyb_timer_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
|
||||
// check arguments
|
||||
mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
|
||||
|
||||
// create new Timer object
|
||||
pyb_timer_obj_t *tim = m_new_obj(pyb_timer_obj_t);
|
||||
tim->base.type = &pyb_timer_type;
|
||||
tim->callback = mp_const_none;
|
||||
memset(&tim->tim, 0, sizeof(tim->tim));
|
||||
|
||||
// get TIM number
|
||||
tim->tim_id = mp_obj_get_int(args[0]);
|
||||
|
||||
switch (tim->tim_id) {
|
||||
case 1: tim->tim.Instance = TIM1; tim->irqn = TIM1_UP_TIM10_IRQn; break;
|
||||
case 2: tim->tim.Instance = TIM2; tim->irqn = TIM2_IRQn; break;
|
||||
case 3: nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "Timer 3 is for internal use only")); // TIM3 used for low-level stuff; go via regs if necessary
|
||||
case 4: tim->tim.Instance = TIM4; tim->irqn = TIM4_IRQn; break;
|
||||
case 5: tim->tim.Instance = TIM5; tim->irqn = TIM5_IRQn; break;
|
||||
case 6: tim->tim.Instance = TIM6; tim->irqn = TIM6_DAC_IRQn; break;
|
||||
case 7: tim->tim.Instance = TIM7; tim->irqn = TIM7_IRQn; break;
|
||||
case 8: tim->tim.Instance = TIM8; tim->irqn = TIM8_UP_TIM13_IRQn; break;
|
||||
case 9: tim->tim.Instance = TIM9; tim->irqn = TIM1_BRK_TIM9_IRQn; break;
|
||||
case 10: tim->tim.Instance = TIM10; tim->irqn = TIM1_UP_TIM10_IRQn; break;
|
||||
case 11: tim->tim.Instance = TIM11; tim->irqn = TIM1_TRG_COM_TIM11_IRQn; break;
|
||||
case 12: tim->tim.Instance = TIM12; tim->irqn = TIM8_BRK_TIM12_IRQn; break;
|
||||
case 13: tim->tim.Instance = TIM13; tim->irqn = TIM8_UP_TIM13_IRQn; break;
|
||||
case 14: tim->tim.Instance = TIM14; tim->irqn = TIM8_TRG_COM_TIM14_IRQn; break;
|
||||
default: nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Timer %d does not exist", tim->tim_id));
|
||||
}
|
||||
|
||||
if (n_args > 1 || n_kw > 0) {
|
||||
// start the peripheral
|
||||
mp_map_t kw_args;
|
||||
mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
|
||||
pyb_timer_init_helper(tim, n_args - 1, args + 1, &kw_args);
|
||||
}
|
||||
|
||||
// set the global variable for interrupt callbacks
|
||||
if (tim->tim_id - 1 < PYB_TIMER_OBJ_ALL_NUM) {
|
||||
pyb_timer_obj_all[tim->tim_id - 1] = tim;
|
||||
}
|
||||
|
||||
return (mp_obj_t)tim;
|
||||
}
|
||||
|
||||
STATIC mp_obj_t pyb_timer_init(uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
|
||||
return pyb_timer_init_helper(args[0], n_args - 1, args + 1, kw_args);
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_timer_init_obj, 1, pyb_timer_init);
|
||||
|
||||
STATIC mp_obj_t pyb_timer_deinit(mp_obj_t self_in) {
|
||||
//pyb_timer_obj_t *self = self_in;
|
||||
// TODO implement me
|
||||
return mp_const_none;
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_timer_deinit_obj, pyb_timer_deinit);
|
||||
|
||||
mp_obj_t pyb_timer_counter(uint n_args, const mp_obj_t *args) {
|
||||
pyb_timer_obj_t *self = args[0];
|
||||
if (n_args == 1) {
|
||||
// get
|
||||
return mp_obj_new_int(self->tim.Instance->CNT);
|
||||
} else {
|
||||
// set
|
||||
__HAL_TIM_SetCounter(&self->tim, mp_obj_get_int(args[1]));
|
||||
return mp_const_none;
|
||||
}
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_timer_counter_obj, 1, 2, pyb_timer_counter);
|
||||
|
||||
mp_obj_t pyb_timer_prescaler(uint n_args, const mp_obj_t *args) {
|
||||
pyb_timer_obj_t *self = args[0];
|
||||
if (n_args == 1) {
|
||||
// get
|
||||
return mp_obj_new_int(self->tim.Instance->PSC & 0xffff);
|
||||
} else {
|
||||
// set
|
||||
self->tim.Init.Prescaler = self->tim.Instance->PSC = mp_obj_get_int(args[1]) & 0xffff;
|
||||
return mp_const_none;
|
||||
}
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_timer_prescaler_obj, 1, 2, pyb_timer_prescaler);
|
||||
|
||||
mp_obj_t pyb_timer_period(uint n_args, const mp_obj_t *args) {
|
||||
pyb_timer_obj_t *self = args[0];
|
||||
if (n_args == 1) {
|
||||
// get
|
||||
return mp_obj_new_int(self->tim.Instance->ARR & 0xffff);
|
||||
} else {
|
||||
// set
|
||||
__HAL_TIM_SetAutoreload(&self->tim, mp_obj_get_int(args[1]) & 0xffff);
|
||||
return mp_const_none;
|
||||
}
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_timer_period_obj, 1, 2, pyb_timer_period);
|
||||
|
||||
// TIM6 is used as an internal interrupt to schedule something at a specific rate
|
||||
mp_obj_t timer_py_callback;
|
||||
|
||||
mp_obj_t timer_py_set_callback(mp_obj_t f) {
|
||||
timer_py_callback = f;
|
||||
STATIC mp_obj_t pyb_timer_callback(mp_obj_t self_in, mp_obj_t callback) {
|
||||
pyb_timer_obj_t *self = self_in;
|
||||
if (callback == mp_const_none) {
|
||||
// stop interrupt (but not timer)
|
||||
__HAL_TIM_DISABLE_IT(&self->tim, TIM_IT_UPDATE);
|
||||
self->callback = mp_const_none;
|
||||
} else if (mp_obj_is_callable(callback)) {
|
||||
self->callback = callback;
|
||||
HAL_NVIC_EnableIRQ(self->irqn);
|
||||
// start timer, so that it interrupts on overflow
|
||||
HAL_TIM_Base_Start_IT(&self->tim);
|
||||
} else {
|
||||
nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "callback must be None or a callable object"));
|
||||
}
|
||||
return mp_const_none;
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_timer_callback_obj, pyb_timer_callback);
|
||||
|
||||
mp_obj_t timer_py_set_period(mp_obj_t period) {
|
||||
TIM6->ARR = mp_obj_get_int(period) & 0xffff;
|
||||
return mp_const_none;
|
||||
}
|
||||
STATIC const mp_map_elem_t pyb_timer_locals_dict_table[] = {
|
||||
// instance methods
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_init), (mp_obj_t)&pyb_timer_init_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_deinit), (mp_obj_t)&pyb_timer_deinit_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_counter), (mp_obj_t)&pyb_timer_counter_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_prescaler), (mp_obj_t)&pyb_timer_prescaler_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_period), (mp_obj_t)&pyb_timer_period_obj },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_callback), (mp_obj_t)&pyb_timer_callback_obj },
|
||||
};
|
||||
|
||||
mp_obj_t timer_py_set_prescaler(mp_obj_t prescaler) {
|
||||
TIM6->PSC = mp_obj_get_int(prescaler) & 0xffff;
|
||||
return mp_const_none;
|
||||
}
|
||||
STATIC MP_DEFINE_CONST_DICT(pyb_timer_locals_dict, pyb_timer_locals_dict_table);
|
||||
|
||||
mp_obj_t timer_py_get_value(void) {
|
||||
return mp_obj_new_int(TIM6->CNT & 0xfffff);
|
||||
}
|
||||
const mp_obj_type_t pyb_timer_type = {
|
||||
{ &mp_type_type },
|
||||
.name = MP_QSTR_Timer,
|
||||
.print = pyb_timer_print,
|
||||
.make_new = pyb_timer_make_new,
|
||||
.locals_dict = (mp_obj_t)&pyb_timer_locals_dict,
|
||||
};
|
||||
|
||||
void timer_init(void) {
|
||||
timer_py_callback = mp_const_none;
|
||||
void timer_irq_handler(uint tim_id) {
|
||||
if (tim_id - 1 < PYB_TIMER_OBJ_ALL_NUM) {
|
||||
// get the timer object
|
||||
pyb_timer_obj_t *tim = pyb_timer_obj_all[tim_id - 1];
|
||||
|
||||
// TIM6 clock enable
|
||||
__TIM6_CLK_ENABLE();
|
||||
if (tim == NULL) {
|
||||
// timer object has not been set, so we can't do anything
|
||||
return;
|
||||
}
|
||||
|
||||
// Compute the prescaler value so TIM6 runs at 20kHz
|
||||
uint16_t PrescalerValue = (uint16_t) ((SystemCoreClock / 2) / 20000) - 1;
|
||||
// see if it was a TIM update event (the only event we currently interrupt on)
|
||||
if (__HAL_TIM_GET_FLAG(&tim->tim, TIM_FLAG_UPDATE) != RESET) {
|
||||
if (__HAL_TIM_GET_ITSTATUS(&tim->tim, TIM_IT_UPDATE) != RESET) {
|
||||
// clear the interrupt
|
||||
__HAL_TIM_CLEAR_IT(&tim->tim, TIM_IT_UPDATE);
|
||||
|
||||
// Time base configuration
|
||||
tim_handle.Instance = TIM6;
|
||||
tim_handle.Init.Prescaler = PrescalerValue;
|
||||
tim_handle.Init.CounterMode = TIM_COUNTERMODE_UP; // unused for TIM6
|
||||
tim_handle.Init.Period = 20000; // timer cycles at 1Hz
|
||||
tim_handle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; // unused for TIM6
|
||||
tim_handle.Init.RepetitionCounter = 0; // unused for TIM6
|
||||
HAL_TIM_Base_Init(&tim_handle);
|
||||
|
||||
// enable perhipheral preload register
|
||||
//TIM_ARRPreloadConfig(TIM6, ENABLE); ??
|
||||
|
||||
// set up interrupt
|
||||
HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 0xf, 0xf); // lowest priority
|
||||
HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);
|
||||
|
||||
// start timer, so that it interrupts on overflow
|
||||
HAL_TIM_Base_Start_IT(&tim_handle);
|
||||
|
||||
// Python interface
|
||||
mp_obj_t m = mp_obj_new_module(QSTR_FROM_STR_STATIC("timer"));
|
||||
rt_store_attr(m, QSTR_FROM_STR_STATIC("callback"), rt_make_function_n(1, timer_py_set_callback));
|
||||
rt_store_attr(m, QSTR_FROM_STR_STATIC("period"), rt_make_function_n(1, timer_py_set_period));
|
||||
rt_store_attr(m, QSTR_FROM_STR_STATIC("prescaler"), rt_make_function_n(1, timer_py_set_prescaler));
|
||||
rt_store_attr(m, QSTR_FROM_STR_STATIC("value"), rt_make_function_n(0, timer_py_get_value));
|
||||
rt_store_name(QSTR_FROM_STR_STATIC("timer"), m);
|
||||
}
|
||||
|
||||
void timer_interrupt(void) {
|
||||
if (timer_py_callback != mp_const_none) {
|
||||
nlr_buf_t nlr;
|
||||
if (nlr_push(&nlr) == 0) {
|
||||
// XXX what to do if the GC is in the middle of running??
|
||||
rt_call_function_0(timer_py_callback);
|
||||
nlr_pop();
|
||||
} else {
|
||||
// uncaught exception
|
||||
printf("exception in timer interrupt\n");
|
||||
mp_obj_print((mp_obj_t)nlr.ret_val, PRINT_REPR);
|
||||
printf("\n");
|
||||
// execute callback if it's set
|
||||
if (tim->callback != mp_const_none) {
|
||||
// When executing code within a handler we must lock the GC to prevent
|
||||
// any memory allocations. We must also catch any exceptions.
|
||||
gc_lock();
|
||||
nlr_buf_t nlr;
|
||||
if (nlr_push(&nlr) == 0) {
|
||||
mp_call_function_1(tim->callback, tim);
|
||||
nlr_pop();
|
||||
} else {
|
||||
// Uncaught exception; disable the callback so it doesn't run again.
|
||||
tim->callback = mp_const_none;
|
||||
__HAL_TIM_DISABLE_IT(&tim->tim, TIM_IT_UPDATE);
|
||||
printf("Uncaught exception in Timer(%lu) interrupt handler\n", tim->tim_id);
|
||||
mp_obj_print_exception((mp_obj_t)nlr.ret_val);
|
||||
}
|
||||
gc_unlock();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mp_obj_t pyb_Timer(mp_obj_t timx_in) {
|
||||
TIM_TypeDef *TIMx = (TIM_TypeDef*)mp_obj_get_int(timx_in);
|
||||
if (!IS_TIM_INSTANCE(TIMx)) {
|
||||
nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "argument 1 is not a TIM instance"));
|
||||
}
|
||||
pyb_hal_tim_t *tim = m_new_obj(pyb_hal_tim_t);
|
||||
tim->htim.Instance = TIMx;
|
||||
tim->htim.Instance.Init.Prescaler = x;
|
||||
tim->htim.Instance.Init.CounterMode = y;
|
||||
tim->htim.Instance.Init.Period = y;
|
||||
tim->htim.Instance.Init.ClockDivision = y;
|
||||
tim->htim.Instance.Init.RepetitionCounter = y;
|
||||
HAL_TIM_Base_Init(&tim->htim);
|
||||
return tim;
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -7,6 +7,11 @@ extern TIM_HandleTypeDef TIM3_Handle;
|
|||
extern TIM_HandleTypeDef TIM5_Handle;
|
||||
extern TIM_HandleTypeDef TIM6_Handle;
|
||||
|
||||
extern const mp_obj_type_t pyb_timer_type;
|
||||
|
||||
void timer_init0(void);
|
||||
void timer_tim3_init(void);
|
||||
void timer_tim5_init(void);
|
||||
void timer_tim6_init(uint freq);
|
||||
|
||||
void timer_irq_handler(uint tim_id);
|
||||
|
|
|
|||
Ładowanie…
Reference in New Issue