djsundog/circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
862944a71f
circuitpython/ports/renesas-ra/machine_pwm.c
mbedNoobNinja fae96b17a7 renesas-ra: Add support for RA6M5, and add machine PWM, DAC, SDCard. 
This commit adds support for a new processor RA6M5.  It also adds the
following classes to the machine module: PWM, DAC, SDCard.

Signed-off-by: mbedNoobNinja <novoltage@gmail.com>
2023-06-27 12:30:25 +10:00

358 lines
13 KiB
C
Raw Blame History

/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Damien P. George
* Copyright (c) 2023 Vekatech Ltd.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "py/runtime.h"
#include "py/mphal.h"
#include "py/mperrno.h"
#include "extmod/machine_pwm.h"
#include "pin.h"
#include "ra/ra_gpt.h"
#include "modmachine.h"
#if MICROPY_HW_ENABLE_HW_PWM
typedef struct _machine_pwm_obj_t {
mp_obj_base_t base;
R_GPT0_Type *pwm_inst;
uint8_t active;
uint8_t ch;
uint8_t id;
uint8_t duty;
uint32_t freq;
mp_hal_pin_obj_t pwm;
} machine_pwm_obj_t;
STATIC machine_pwm_obj_t machine_pwm_obj[] = {
#if defined(MICROPY_HW_PWM_0A)
{{&machine_pwm_type}, R_GPT0, 0, 0, 'A', 0, 0ul, MICROPY_HW_PWM_0A},
#endif
#if defined(MICROPY_HW_PWM_0B)
{{&machine_pwm_type}, R_GPT0, 0, 0, 'B', 0, 0ul, MICROPY_HW_PWM_0B},
#endif
#if defined(MICROPY_HW_PWM_1A)
{{&machine_pwm_type}, R_GPT1, 0, 1, 'A', 0, 0ul, MICROPY_HW_PWM_1A},
#endif
#if defined(MICROPY_HW_PWM_1B)
{{&machine_pwm_type}, R_GPT1, 0, 1, 'B', 0, 0ul, MICROPY_HW_PWM_1B},
#endif
#if defined(MICROPY_HW_PWM_2A)
{{&machine_pwm_type}, R_GPT2, 0, 2, 'A', 0, 0ul, MICROPY_HW_PWM_2A},
#endif
#if defined(MICROPY_HW_PWM_2B)
{{&machine_pwm_type}, R_GPT2, 0, 2, 'B', 0, 0ul, MICROPY_HW_PWM_2B},
#endif
#if defined(MICROPY_HW_PWM_3A)
{{&machine_pwm_type}, R_GPT3, 0, 3, 'A', 0, 0ul, MICROPY_HW_PWM_3A},
#endif
#if defined(MICROPY_HW_PWM_3B)
{{&machine_pwm_type}, R_GPT3, 0, 3, 'B', 0, 0ul, MICROPY_HW_PWM_3B},
#endif
#if defined(MICROPY_HW_PWM_4A)
{{&machine_pwm_type}, R_GPT4, 0, 4, 'A', 0, 0ul, MICROPY_HW_PWM_4A},
#endif
#if defined(MICROPY_HW_PWM_4B)
{{&machine_pwm_type}, R_GPT4, 0, 4, 'B', 0, 0ul, MICROPY_HW_PWM_4B},
#endif
#if defined(MICROPY_HW_PWM_5A)
{{&machine_pwm_type}, R_GPT5, 0, 5, 'A', 0, 0ul, MICROPY_HW_PWM_5A},
#endif
#if defined(MICROPY_HW_PWM_5B)
{{&machine_pwm_type}, R_GPT5, 0, 5, 'B', 0, 0ul, MICROPY_HW_PWM_5B},
#endif
#if defined(MICROPY_HW_PWM_6A)
{{&machine_pwm_type}, R_GPT6, 0, 6, 'A', 0, 0ul, MICROPY_HW_PWM_6A},
#endif
#if defined(MICROPY_HW_PWM_6B)
{{&machine_pwm_type}, R_GPT6, 0, 6, 'B', 0, 0ul, MICROPY_HW_PWM_6B},
#endif
#if defined(MICROPY_HW_PWM_7A)
{{&machine_pwm_type}, R_GPT7, 0, 7, 'A', 0, 0ul, MICROPY_HW_PWM_7A},
#endif
#if defined(MICROPY_HW_PWM_7B)
{{&machine_pwm_type}, R_GPT7, 0, 7, 'B', 0, 0ul, MICROPY_HW_PWM_7B},
#endif
#if defined(MICROPY_HW_PWM_8A)
{{&machine_pwm_type}, R_GPT8, 0, 8, 'A', 0, 0ul, MICROPY_HW_PWM_8A},
#endif
#if defined(MICROPY_HW_PWM_8B)
{{&machine_pwm_type}, R_GPT8, 0, 8, 'B', 0, 0ul, MICROPY_HW_PWM_8B},
#endif
#if defined(MICROPY_HW_PWM_9A)
{{&machine_pwm_type}, R_GPT9, 0, 9, 'A', 0, 0ul, MICROPY_HW_PWM_9A},
#endif
#if defined(MICROPY_HW_PWM_9B)
{{&machine_pwm_type}, R_GPT9, 0, 9, 'B', 0, 0ul, MICROPY_HW_PWM_9B},
#endif
#if defined(MICROPY_HW_PWM_10A)
{{&machine_pwm_type}, R_GPT10, 0, 10, 'A', 0, 0ul, MICROPY_HW_PWM_10A},
#endif
#if defined(MICROPY_HW_PWM_10B)
{{&machine_pwm_type}, R_GPT10, 0, 10, 'B', 0, 0ul, MICROPY_HW_PWM_10B},
#endif
#if defined(MICROPY_HW_PWM_11A)
{{&machine_pwm_type}, R_GPT11, 0, 11, 'A', 0, 0ul, MICROPY_HW_PWM_11A},
#endif
#if defined(MICROPY_HW_PWM_11B)
{{&machine_pwm_type}, R_GPT11, 0, 11, 'B', 0, 0ul, MICROPY_HW_PWM_11B},
#endif
#if defined(MICROPY_HW_PWM_12A)
{{&machine_pwm_type}, R_GPT12, 0, 12, 'A', 0, 0ul, MICROPY_HW_PWM_12A},
#endif
#if defined(MICROPY_HW_PWM_12B)
{{&machine_pwm_type}, R_GPT12, 0, 12, 'B', 0, 0ul, MICROPY_HW_PWM_12B},
#endif
#if defined(MICROPY_HW_PWM_13A)
{{&machine_pwm_type}, R_GPT13, 0, 13, 'A', 0, 0ul, MICROPY_HW_PWM_13A},
#endif
#if defined(MICROPY_HW_PWM_13B)
{{&machine_pwm_type}, R_GPT13, 0, 13, 'B', 0, 0ul, MICROPY_HW_PWM_13B}
#endif
};
/******************************************************************************/
// MicroPython bindings for PWM
STATIC void mp_machine_pwm_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
machine_pwm_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "PWM(GTIOC %d%c[#%d], runing=%u, freq=%u, duty=%u)", self->ch, self->id, self->pwm->pin, self->active, self->freq, self->duty);
}
STATIC void mp_machine_pwm_init_helper(machine_pwm_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
uint32_t D = 0ul;
enum { ARG_freq, ARG_duty };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_freq, MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_duty, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} }
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
if (args[ARG_freq].u_int != -1) {
if ((args[ARG_freq].u_int < 0) || (args[ARG_freq].u_int > 24000000)) {
mp_raise_ValueError(MP_ERROR_TEXT("freq should be 0-24000000"));
} else {
self->freq = args[ARG_freq].u_int;
}
}
ra_gpt_timer_init(self->pwm->pin, self->ch, self->id, 0, (float)self->freq);
if (args[ARG_duty].u_int != -1) {
if ((args[ARG_duty].u_int < 0) || (args[ARG_duty].u_int > 100)) {
mp_raise_ValueError(MP_ERROR_TEXT("duty should be 0-100"));
} else {
self->duty = args[ARG_duty].u_int;
}
}
D = self->duty * ra_gpt_timer_get_period(self->ch);
ra_gpt_timer_set_duty(self->ch, self->id, (uint32_t)(D / 100));
if (self->duty && self->freq) {
ra_gpt_timer_start(self->ch);
self->active = 1;
}
}
STATIC mp_obj_t mp_machine_pwm_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
mp_hal_pin_obj_t pin_id = MP_OBJ_NULL;
machine_pwm_obj_t *self = MP_OBJ_NULL;
enum { ARG_pin, ARG_freq, ARG_duty };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_pin, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_freq, MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_duty, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} }
};
mp_arg_check_num(n_args, n_kw, 1, 3, true);
mp_arg_val_t init_args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all_kw_array(n_args, n_kw, args, MP_ARRAY_SIZE(allowed_args), allowed_args, init_args);
// Get GPIO and optional device to connect to PWM.
pin_id = mp_hal_get_pin_obj(init_args[ARG_pin].u_obj);
if (pin_id) {
for (int i = 0; i < MP_ARRAY_SIZE(machine_pwm_obj); i++) {
if (pin_id->pin == machine_pwm_obj[i].pwm->pin) {
self = &machine_pwm_obj[i];
break;
}
}
if (self) {
if (ra_gpt_timer_is_pwm_pin(self->pwm->pin)) {
// start the PWM running for this channel
mp_map_t kw_args;
mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
mp_machine_pwm_init_helper(self, n_args - 1, args + 1, &kw_args);
} else {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Pin(%d) has no timer output"), self->pwm->pin);
}
} else {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Pin(%d) is used with other peripheral"), pin_id->pin);
}
} else {
mp_raise_ValueError(MP_ERROR_TEXT("Pin doesn't exist"));
}
return MP_OBJ_FROM_PTR(self);
}
STATIC void mp_machine_pwm_deinit(machine_pwm_obj_t *self) {
ra_gpt_timer_deinit(self->pwm->pin, self->ch, self->id);
self->active = 0;
self->ch = 0;
self->id = ' ';
self->duty = 0;
self->freq = 0;
}
STATIC mp_obj_t mp_machine_pwm_freq_get(machine_pwm_obj_t *self) {
return MP_OBJ_NEW_SMALL_INT((uint32_t)ra_gpt_timer_get_freq(self->ch));
}
STATIC void mp_machine_pwm_freq_set(machine_pwm_obj_t *self, mp_int_t freq) {
if (freq) {
ra_gpt_timer_set_freq(self->ch, (float)freq);
self->freq = (uint32_t)ra_gpt_timer_get_freq(self->ch);
if (!self->freq) {
mp_raise_ValueError(MP_ERROR_TEXT("freq should be 0-24000000"));
} else
if (!self->active) {
ra_gpt_timer_start(self->ch);
self->active = 1;
}
} else {
ra_gpt_timer_stop(self->ch);
ra_gpt_timer_set_freq(self->ch, (float)freq);
self->freq = 0;
self->active = 0;
}
}
STATIC mp_obj_t mp_machine_pwm_duty_get(machine_pwm_obj_t *self) {
// give the result in %
uint64_t Dc = ra_gpt_timer_get_duty(self->ch, self->id) * 100;
return MP_OBJ_NEW_SMALL_INT(Dc / ra_gpt_timer_get_period(self->ch));
}
STATIC void mp_machine_pwm_duty_set(machine_pwm_obj_t *self, mp_int_t duty) {
// assume duty is in %
if (duty < 0 || duty > 100) {
mp_raise_ValueError(MP_ERROR_TEXT("duty should be 0-100"));
} else {
if (duty) {
uint64_t D = (uint8_t)(duty) * ra_gpt_timer_get_period(self->ch);
ra_gpt_timer_set_duty(self->ch, self->id, (uint32_t)(D / 100));
self->duty = (uint8_t)duty;
if (!self->active && self->freq) {
ra_gpt_timer_start(self->ch);
self->active = 1;
}
} else {
if (self->active) {
ra_gpt_timer_stop(self->ch);
ra_gpt_timer_set_duty(self->ch, self->id, 0);
self->duty = 0;
self->active = 0;
}
}
}
}
STATIC mp_obj_t mp_machine_pwm_duty_get_u16(machine_pwm_obj_t *self) {
// give the result in ratio (u16 / 65535)
uint64_t Dc = ra_gpt_timer_get_duty(self->ch, self->id) * 65535;
return MP_OBJ_NEW_SMALL_INT(Dc / ra_gpt_timer_get_period(self->ch));
}
STATIC void mp_machine_pwm_duty_set_u16(machine_pwm_obj_t *self, mp_int_t duty_u16) {
// assume duty is a ratio (u16 / 65535)
if (duty_u16 < 0 || duty_u16 > 65535) {
mp_raise_ValueError(MP_ERROR_TEXT("duty should be 0-65535"));
} else {
if (duty_u16) {
uint64_t D = duty_u16 * ra_gpt_timer_get_period(self->ch);
ra_gpt_timer_set_duty(self->ch, self->id, (uint32_t)(D / 65535));
self->duty = (uint8_t)((duty_u16 * 100) / 65535);
if (!self->active && self->freq) {
ra_gpt_timer_start(self->ch);
self->active = 1;
}
} else {
if (self->active) {
ra_gpt_timer_stop(self->ch);
ra_gpt_timer_set_duty(self->ch, self->id, 0);
self->duty = 0;
self->active = 0;
}
}
}
}
STATIC mp_obj_t mp_machine_pwm_duty_get_ns(machine_pwm_obj_t *self) {
// give the result in ns
float ns = ra_gpt_timer_tick_time(self->ch);
ns *= (float)ra_gpt_timer_get_duty(self->ch, self->id);
return MP_OBJ_NEW_SMALL_INT(ns);
}
STATIC void mp_machine_pwm_duty_set_ns(machine_pwm_obj_t *self, mp_int_t duty_ns) {
// assume duty is ns
uint32_t ns_min = (uint32_t)ra_gpt_timer_tick_time(self->ch);
uint32_t ns_max = ns_min * ra_gpt_timer_get_period(self->ch);
if (duty_ns) {
if (duty_ns < ns_min || duty_ns > ns_max) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("duty should be in period range %d-%d"), ns_min, ns_max);
} else {
uint32_t D = (uint32_t)duty_ns / ns_min;
ra_gpt_timer_set_duty(self->ch, self->id, D);
D *= ns_min * 100;
self->duty = D / ns_max;
if (!self->active && self->freq) {
ra_gpt_timer_start(self->ch);
self->active = 1;
}
}
} else {
if (self->active) {
ra_gpt_timer_stop(self->ch);
ra_gpt_timer_set_duty(self->ch, self->id, 0);
self->duty = 0;
self->active = 0;
}
}
}
#endif // MICROPY_HW_ENABLE_HW_PWM
Reference in New Issue View Git Blame Copy Permalink