kopia lustrzana https://github.com/micropython/micropython
renesas-ra/boards/make-pins.py: Update to use tools/boardgen.py.
This removes previously unused functionality to generate pins_ad_const.h, as well as the unused handling of pin AF in machine_pin.c. This work was funded through GitHub Sponsors. Signed-off-by: Jim Mussared <jim.mussared@gmail.com>pull/12211/head
Jim Mussared
Damien George
rodzic
c0b64a3f23
commit
1f804e03f6
|
|
@ -556,8 +556,6 @@ AF_FILE = boards/ra6m5_af.csv
|
|||
endif
|
||||
GEN_PINS_SRC = $(BUILD)/pins_$(BOARD).c
|
||||
GEN_PINS_HDR = $(HEADER_BUILD)/pins.h
|
||||
# Currently unused.
|
||||
GEN_PINS_AD_CONST = $(HEADER_BUILD)/pins_ad_const.h
|
||||
|
||||
FILE2H = $(TOP)/tools/file2h.py
|
||||
|
||||
|
|
@ -578,10 +576,10 @@ $(HEADER_BUILD)/qstrdefs.generated.h: $(BOARD_DIR)/mpconfigboard.h
|
|||
# Use a pattern rule here so that make will only call make-pins.py once to make
|
||||
# both pins_$(BOARD).c and pins.h
|
||||
.PRECIOUS: $(GEN_PINS_SRC)
|
||||
$(BUILD)/%_$(BOARD).c $(HEADER_BUILD)/%.h $(HEADER_BUILD)/%_ad_const.h: $(BOARD_DIR)/%.csv $(MAKE_PINS) $(AF_FILE) $(PREFIX_FILE) | $(HEADER_BUILD)
|
||||
$(BUILD)/%_$(BOARD).c $(HEADER_BUILD)/%.h: $(BOARD_DIR)/%.csv $(MAKE_PINS) $(AF_FILE) $(PREFIX_FILE) | $(HEADER_BUILD)
|
||||
$(ECHO) "GEN $@"
|
||||
$(Q)$(PYTHON) $(MAKE_PINS) --board-csv $(BOARD_PINS) --af-csv $(AF_FILE) --prefix $(PREFIX_FILE) \
|
||||
--output-source $(GEN_PINS_SRC) --output-header $(GEN_PINS_HDR) --output-ad-const $(GEN_PINS_AD_CONST)
|
||||
--output-source $(GEN_PINS_SRC) --output-header $(GEN_PINS_HDR)
|
||||
|
||||
CMSIS_MCU_HDR = $(CMSIS_DIR)/$(CMSIS_MCU_LOWER).h
|
||||
|
||||
|
|
|
|||
|
|
@ -1,258 +1,89 @@
|
|||
#!/usr/bin/env python
|
||||
"""Creates the pin file for the RAxxx."""
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import argparse
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
import csv
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../../../tools"))
|
||||
import boardgen
|
||||
|
||||
|
||||
class PinAD(object):
|
||||
def __init__(self, name, cpu_pin_name, pin_idx, bit, channel):
|
||||
self._name = name
|
||||
self._cpu_pin_name = cpu_pin_name
|
||||
self._pin_idx = pin_idx
|
||||
self._bit = bit
|
||||
self._channel = channel
|
||||
class RenesasRaPin(boardgen.Pin):
|
||||
def __init__(self, cpu_pin_name):
|
||||
super().__init__(cpu_pin_name)
|
||||
|
||||
def cpu_pin_name(self):
|
||||
return self._cpu_pin_name
|
||||
self._port = int(cpu_pin_name[1], 16)
|
||||
self._bit = int(cpu_pin_name[2:])
|
||||
|
||||
def name(self):
|
||||
return self._name
|
||||
self._adc_name = None
|
||||
self._adc_bits = 0
|
||||
self._adc_channel = 0
|
||||
|
||||
def bit(self):
|
||||
return self._bit
|
||||
def add_adc(self, adc):
|
||||
# The previous version of make-pins.py handled len==4 to mean
|
||||
# adc_bits=8, but this is not used in any of the current af.csv files,
|
||||
# so this needs to be validated.
|
||||
assert len(adc) == 5 and (adc.startswith("AN0") or adc.startswith("AN1"))
|
||||
self._adc_name = adc
|
||||
self._adc_bit = 12
|
||||
self._adc_channel = int(adc[2:])
|
||||
|
||||
def channel(self):
|
||||
return self._channel
|
||||
# Called for each AF defined in the csv file for this pin.
|
||||
def add_af(self, af_idx, af_name, af):
|
||||
if af_idx == 0 and af:
|
||||
assert af_name == "Analog"
|
||||
self.add_adc(af)
|
||||
|
||||
def print(self, out_source):
|
||||
print(
|
||||
"const pin_ad_obj_t pin_{:s}_ad_obj = PIN_AD({:s}, {:d}, {:d}, {:d});".format(
|
||||
self._cpu_pin_name, self._name, self._pin_idx, self._bit, self._channel
|
||||
),
|
||||
file=out_source,
|
||||
)
|
||||
print("", file=out_source)
|
||||
# Use the PIN() macro defined in ra_pin_prefix.c for defining the pin
|
||||
# objects.
|
||||
def definition(self):
|
||||
# PIN(p_name, p_pin, p_adc)
|
||||
adc = "&pin_{}_adc_obj".format(self.name()) if self._adc_name else "NULL"
|
||||
return "PIN({:s}, {:d}, {:s})".format(self.name(), self._port * 16 + self._bit, adc)
|
||||
|
||||
def print_header(self, out_header):
|
||||
n = self.cpu_pin_name()
|
||||
print("extern const pin_ad_obj_t pin_{:s}_ad_obj;".format(n), file=out_header)
|
||||
print("#define pin_{:s}_ad (&pin_{:s}_ad_obj)".format(n, n), file=out_header)
|
||||
|
||||
|
||||
class Pin(object):
|
||||
def __init__(self, name, port, bit):
|
||||
self._name = name
|
||||
self._pin_idx = port * 16 + bit
|
||||
self._pin_ad = []
|
||||
self._board_pin = False
|
||||
# print('// pin_{:s}_obj = PIN({:s}, {:d});'.format(self.name, self.name, self.pin))
|
||||
|
||||
def cpu_pin_name(self):
|
||||
return self._name
|
||||
|
||||
def pin_ad(self):
|
||||
return self._pin_ad
|
||||
|
||||
def is_board_pin(self):
|
||||
return self._board_pin
|
||||
|
||||
def set_is_board_pin(self):
|
||||
self._board_pin = True
|
||||
|
||||
def parse_ad(self, ad_str):
|
||||
ad_bit = 0
|
||||
ad_channel = 0
|
||||
if (len(ad_str) == 5) and (ad_str[:3] == "AN0"):
|
||||
ad_bit = 12
|
||||
ad_channel = int(ad_str[2:])
|
||||
self._pin_ad.append(PinAD(ad_str, self._name, self._pin_idx, ad_bit, ad_channel))
|
||||
elif (len(ad_str) == 5) and (ad_str[:3] == "AN1"):
|
||||
ad_bit = 12
|
||||
ad_channel = int(ad_str[2:])
|
||||
self._pin_ad.append(PinAD(ad_str, self._name, self._pin_idx, ad_bit, ad_channel))
|
||||
elif ad_str[:2] == "AN":
|
||||
ad_bit = 8
|
||||
ad_channel = int(ad_str[2:4])
|
||||
self._pin_ad.append(PinAD(ad_str, self._name, self._pin_idx, ad_bit, ad_channel))
|
||||
|
||||
def print(self, out_source):
|
||||
pin_ad_name = "NULL"
|
||||
for pin_ad in self._pin_ad:
|
||||
pin_ad.print(out_source)
|
||||
pin_ad_name = "pin_{:s}_ad".format(pin_ad.cpu_pin_name())
|
||||
print(
|
||||
"const machine_pin_obj_t pin_{:s}_obj = PIN({:s}, {:d}, {:s});".format(
|
||||
self._name, self._name, self._pin_idx, pin_ad_name
|
||||
),
|
||||
file=out_source,
|
||||
)
|
||||
print("", file=out_source)
|
||||
|
||||
def print_header(self, out_header):
|
||||
n = self.cpu_pin_name()
|
||||
print("extern const machine_pin_obj_t pin_{:s}_obj;".format(n), file=out_header)
|
||||
print("#define pin_{:s} (&pin_{:s}_obj)".format(n, n), file=out_header)
|
||||
|
||||
|
||||
class NamedPin(object):
|
||||
def __init__(self, name, pin):
|
||||
self._name = name
|
||||
self._pin = pin
|
||||
# print('// NamedPin {:s}'.format(self._name))
|
||||
|
||||
def pin(self):
|
||||
return self._pin
|
||||
|
||||
def name(self):
|
||||
return self._name
|
||||
|
||||
|
||||
class Pins(object):
|
||||
def __init__(self):
|
||||
self.cpu_pins = [] # list of NamedPin objects
|
||||
self.board_pins = [] # list of NamedPin objects
|
||||
|
||||
def find_pin(self, cpu_pin_name):
|
||||
for named_pin in self.cpu_pins:
|
||||
pin = named_pin.pin()
|
||||
if pin.cpu_pin_name() == cpu_pin_name:
|
||||
return pin
|
||||
|
||||
# rx63n_al.csv
|
||||
# cpu_pin_name, cpu_pin_port, cpu_pin_bit
|
||||
def parse_af_file(self, filename):
|
||||
with open(filename, "r") as csvfile:
|
||||
rows = csv.reader(csvfile)
|
||||
for row in rows:
|
||||
try:
|
||||
cpu_pin_name = row[0]
|
||||
cpu_pin_port = int(row[1], 16)
|
||||
cpu_pin_bit = int(row[2])
|
||||
except:
|
||||
continue
|
||||
pin = Pin(cpu_pin_name, cpu_pin_port, cpu_pin_bit)
|
||||
self.cpu_pins.append(NamedPin(cpu_pin_name, pin))
|
||||
pin.parse_ad(row[3])
|
||||
|
||||
# pins.csv
|
||||
# named_pin, cpu_pin_name
|
||||
def parse_board_file(self, filename):
|
||||
with open(filename, "r") as csvfile:
|
||||
rows = csv.reader(csvfile)
|
||||
for row in rows:
|
||||
try:
|
||||
board_pin_name = row[0]
|
||||
cpu_pin_name = row[1]
|
||||
except:
|
||||
continue
|
||||
pin = self.find_pin(cpu_pin_name)
|
||||
if pin:
|
||||
pin.set_is_board_pin()
|
||||
self.board_pins.append(NamedPin(board_pin_name, pin))
|
||||
|
||||
def print_named(self, label, named_pins, out_source):
|
||||
print(
|
||||
"STATIC const mp_rom_map_elem_t pin_{:s}_pins_locals_dict_table[] = {{".format(label),
|
||||
file=out_source,
|
||||
)
|
||||
for named_pin in named_pins:
|
||||
pin = named_pin.pin()
|
||||
if pin.is_board_pin():
|
||||
print(
|
||||
" {{ MP_ROM_QSTR(MP_QSTR_{:s}), MP_ROM_PTR(&pin_{:s}_obj) }},".format(
|
||||
named_pin.name(), pin.cpu_pin_name()
|
||||
),
|
||||
file=out_source,
|
||||
)
|
||||
print("};", file=out_source)
|
||||
print(
|
||||
"MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);".format(
|
||||
label, label
|
||||
),
|
||||
file=out_source,
|
||||
)
|
||||
|
||||
def print(self, out_source):
|
||||
for named_pin in self.cpu_pins:
|
||||
pin = named_pin.pin()
|
||||
if pin.is_board_pin():
|
||||
pin.print(out_source)
|
||||
self.print_named("cpu", self.cpu_pins, out_source)
|
||||
print("", file=out_source)
|
||||
self.print_named("board", self.board_pins, out_source)
|
||||
|
||||
def print_header(self, out_header):
|
||||
for named_pin in self.cpu_pins:
|
||||
pin = named_pin.pin()
|
||||
if pin.is_board_pin():
|
||||
pin.print_header(out_header)
|
||||
pin_ads = pin.pin_ad()
|
||||
for pin_ad in pin_ads:
|
||||
pin_ad.print_header(out_header)
|
||||
# provide #define's mapping board to cpu name
|
||||
for named_pin in self.board_pins:
|
||||
# This will be called at the start of the output (after the prefix). Use
|
||||
# it to emit the ADC objects (via the PIN_ADC() macro).
|
||||
def print_source(self, out_source):
|
||||
# PIN_ADC(p_name, p_pin, adc_bit, adc_channel)
|
||||
if self._adc_name:
|
||||
print(
|
||||
"#define pyb_pin_{:s} pin_{:s}".format(
|
||||
named_pin.name(), named_pin.pin().cpu_pin_name()
|
||||
"const machine_pin_adc_obj_t pin_{}_adc_obj = PIN_ADC({:s}, {:d}, {:d}, {:d});".format(
|
||||
self.name(),
|
||||
self._adc_name,
|
||||
self._port * 16 + self._bit,
|
||||
self._adc_bits,
|
||||
self._adc_channel,
|
||||
),
|
||||
file=out_header,
|
||||
file=out_source,
|
||||
)
|
||||
|
||||
def print_ad_hdr(self, out_ad_const):
|
||||
for named_pin in self.cpu_pins:
|
||||
pin = named_pin.pin()
|
||||
if pin.is_board_pin():
|
||||
pin_ads = pin.pin_ad()
|
||||
for pin_ad in pin_ads:
|
||||
print(
|
||||
" {{ MP_ROM_QSTR(MP_QSTR_{:s}), MP_ROM_INT(GPIO_{:s}) }}, \n".format(
|
||||
pin_ad.name(), pin_ad.name()
|
||||
),
|
||||
file=out_ad_const,
|
||||
)
|
||||
# RA cpu names must be "PXNN", where X is hexadecimal port, NN is decimal bit offset.
|
||||
@staticmethod
|
||||
def validate_cpu_pin_name(cpu_pin_name):
|
||||
boardgen.Pin.validate_cpu_pin_name(cpu_pin_name)
|
||||
|
||||
if not re.match("^P[0-9A-F][0-9][0-9]$", cpu_pin_name):
|
||||
raise boardgen.PinGeneratorError("Invalid cpu pin name '{}'".format(cpu_pin_name))
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description="Generate board specific pin file")
|
||||
parser.add_argument("--board-csv")
|
||||
parser.add_argument("--af-csv")
|
||||
parser.add_argument("--prefix")
|
||||
parser.add_argument("--output-source")
|
||||
parser.add_argument("--output-header")
|
||||
parser.add_argument("--output-ad-const")
|
||||
args = parser.parse_args()
|
||||
class RenesasRaPinGenerator(boardgen.PinGenerator):
|
||||
def __init__(self):
|
||||
# Use custom pin type above, and also enable the --af-csv argument so
|
||||
# that add_af gets called on each pin.
|
||||
super().__init__(
|
||||
pin_type=RenesasRaPin,
|
||||
enable_af=True,
|
||||
)
|
||||
|
||||
pins = Pins()
|
||||
# Override the default implementation just to change the default arguments.
|
||||
def parse_af_csv(self, filename):
|
||||
return super().parse_af_csv(filename, header_rows=1, pin_col=0, af_col=3)
|
||||
|
||||
with open(args.output_source, "w") as out_source:
|
||||
print("// This file was automatically generated by make-pins.py", file=out_source)
|
||||
print("//", file=out_source)
|
||||
if args.af_csv:
|
||||
print("// --af {:s}".format(args.af_csv), file=out_source)
|
||||
pins.parse_af_file(args.af_csv)
|
||||
|
||||
if args.board_csv:
|
||||
print("// --board {:s}".format(args.board_csv), file=out_source)
|
||||
pins.parse_board_file(args.board_csv)
|
||||
|
||||
if args.prefix:
|
||||
print("// --prefix {:s}".format(args.prefix), file=out_source)
|
||||
print("", file=out_source)
|
||||
with open(args.prefix, "r") as prefix_file:
|
||||
print(prefix_file.read(), file=out_source)
|
||||
|
||||
pins.print(out_source)
|
||||
|
||||
with open(args.output_header, "w") as out_header:
|
||||
pins.print_header(out_header)
|
||||
|
||||
with open(args.output_ad_const, "w") as out_ad_const:
|
||||
pins.print_ad_hdr(out_ad_const)
|
||||
# Renesas-specific behavior, we use pin_PNNN for the cpu names, but
|
||||
# pyb_pin_FOO for the board names.
|
||||
def board_name_define_prefix(self):
|
||||
return "pyb_"
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
RenesasRaPinGenerator().main()
|
||||
|
|
|
|||
|
|
@ -7,19 +7,19 @@
|
|||
#include "extmod/modmachine.h"
|
||||
#include "pin.h"
|
||||
|
||||
#define PIN_AD(p_name, p_pin, ad_bit, ad_channel) \
|
||||
#define PIN_ADC(p_name, p_pin, adc_bits, adc_channel) \
|
||||
{ \
|
||||
{ &machine_pin_type }, \
|
||||
.name = MP_QSTR_##p_name, \
|
||||
.pin = p_pin, \
|
||||
.bit = ad_bit, \
|
||||
.channel = ad_channel \
|
||||
.bit = adc_bits, \
|
||||
.channel = adc_channel \
|
||||
}
|
||||
|
||||
#define PIN(p_name, p_pin, p_ad) \
|
||||
#define PIN(p_name, p_pin, p_adc) \
|
||||
{ \
|
||||
{ &machine_pin_type }, \
|
||||
.name = MP_QSTR_##p_name, \
|
||||
.pin = p_pin, \
|
||||
.ad = p_ad, \
|
||||
.ad = p_adc, \
|
||||
}
|
||||
|
|
|
|||
|
|
@ -56,13 +56,13 @@ const machine_pin_obj_t *machine_pin_find(mp_obj_t user_obj) {
|
|||
}
|
||||
|
||||
// See if the pin name matches a board pin
|
||||
pin_obj = pin_find_named_pin(&pin_board_pins_locals_dict, user_obj);
|
||||
pin_obj = pin_find_named_pin(&machine_pin_board_pins_locals_dict, user_obj);
|
||||
if (pin_obj) {
|
||||
return pin_obj;
|
||||
}
|
||||
|
||||
// See if the pin name matches a cpu pin
|
||||
pin_obj = pin_find_named_pin(&pin_cpu_pins_locals_dict, user_obj);
|
||||
pin_obj = pin_find_named_pin(&machine_pin_cpu_pins_locals_dict, user_obj);
|
||||
if (pin_obj) {
|
||||
return pin_obj;
|
||||
}
|
||||
|
|
@ -134,12 +134,7 @@ STATIC void machine_pin_print(const mp_print_t *print, mp_obj_t self_in, mp_prin
|
|||
// AF mode
|
||||
if (af) {
|
||||
mp_uint_t af_idx = pin_get_af(self);
|
||||
const pin_af_obj_t *af_obj = pin_find_af_by_index(self, af_idx);
|
||||
if (af_obj == NULL) {
|
||||
mp_printf(print, ", alt=%d)", af_idx);
|
||||
} else {
|
||||
mp_printf(print, ", alt=Pin.%q)", af_obj->name);
|
||||
}
|
||||
mp_printf(print, ", alt=%d)", af_idx);
|
||||
} else {
|
||||
mp_print_str(print, ")");
|
||||
}
|
||||
|
|
@ -306,8 +301,8 @@ STATIC const mp_rom_map_elem_t machine_pin_locals_dict_table[] = {
|
|||
{ MP_ROM_QSTR(MP_QSTR_high), MP_ROM_PTR(&machine_pin_high_obj) },
|
||||
|
||||
// class attributes
|
||||
{ MP_ROM_QSTR(MP_QSTR_board), MP_ROM_PTR(&pin_board_pins_obj_type) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_cpu), MP_ROM_PTR(&pin_cpu_pins_obj_type) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_board), MP_ROM_PTR(&machine_pin_board_pins_obj_type) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_cpu), MP_ROM_PTR(&machine_pin_cpu_pins_obj_type) },
|
||||
|
||||
// class constants
|
||||
{ MP_ROM_QSTR(MP_QSTR_IN), MP_ROM_INT(MP_HAL_PIN_MODE_INPUT) },
|
||||
|
|
@ -391,17 +386,17 @@ uint32_t pin_get_af(const machine_pin_obj_t *pin) {
|
|||
}
|
||||
|
||||
MP_DEFINE_CONST_OBJ_TYPE(
|
||||
pin_cpu_pins_obj_type,
|
||||
machine_pin_cpu_pins_obj_type,
|
||||
MP_QSTR_cpu,
|
||||
MP_TYPE_FLAG_NONE,
|
||||
locals_dict, &pin_cpu_pins_locals_dict
|
||||
locals_dict, &machine_pin_cpu_pins_locals_dict
|
||||
);
|
||||
|
||||
MP_DEFINE_CONST_OBJ_TYPE(
|
||||
pin_board_pins_obj_type,
|
||||
machine_pin_board_pins_obj_type,
|
||||
MP_QSTR_board,
|
||||
MP_TYPE_FLAG_NONE,
|
||||
locals_dict, &pin_board_pins_locals_dict
|
||||
locals_dict, &machine_pin_board_pins_locals_dict
|
||||
);
|
||||
|
||||
const machine_pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name) {
|
||||
|
|
@ -412,13 +407,3 @@ const machine_pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_
|
|||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const pin_af_obj_t *pin_find_af_by_index(const machine_pin_obj_t *pin, mp_uint_t af_idx) {
|
||||
const pin_af_obj_t *af = pin->af;
|
||||
for (mp_uint_t i = 0; i < pin->num_af; i++, af++) {
|
||||
if (af->idx == af_idx) {
|
||||
return af;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,57 +31,29 @@
|
|||
#include "shared/runtime/mpirq.h"
|
||||
#include "py/obj.h"
|
||||
|
||||
typedef struct {
|
||||
mp_obj_base_t base;
|
||||
qstr name;
|
||||
uint8_t idx;
|
||||
uint8_t fn;
|
||||
uint8_t unit;
|
||||
uint8_t type;
|
||||
void *reg; // The peripheral associated with this AF
|
||||
} pin_af_obj_t;
|
||||
|
||||
typedef struct {
|
||||
mp_obj_base_t base;
|
||||
qstr name;
|
||||
uint8_t pin;
|
||||
uint8_t bit;
|
||||
uint8_t channel;
|
||||
} pin_ad_obj_t;
|
||||
} machine_pin_adc_obj_t;
|
||||
|
||||
typedef struct {
|
||||
mp_obj_base_t base;
|
||||
qstr name;
|
||||
uint8_t pin;
|
||||
uint8_t num_af;
|
||||
const pin_af_obj_t *af;
|
||||
const pin_ad_obj_t *ad;
|
||||
const machine_pin_adc_obj_t *ad;
|
||||
} machine_pin_obj_t;
|
||||
|
||||
extern const mp_obj_type_t pin_af_type;
|
||||
|
||||
// Include all of the individual pin objects
|
||||
#include "genhdr/pins.h"
|
||||
|
||||
typedef struct {
|
||||
const char *name;
|
||||
const machine_pin_obj_t *pin;
|
||||
} pin_named_pin_t;
|
||||
extern const mp_obj_type_t machine_pin_board_pins_obj_type;
|
||||
extern const mp_obj_type_t machine_pin_cpu_pins_obj_type;
|
||||
|
||||
extern const pin_named_pin_t pin_board_pins[];
|
||||
extern const pin_named_pin_t pin_cpu_pins[];
|
||||
|
||||
typedef struct {
|
||||
mp_obj_base_t base;
|
||||
qstr name;
|
||||
const pin_named_pin_t *named_pins;
|
||||
} pin_named_pins_obj_t;
|
||||
|
||||
extern const mp_obj_type_t pin_board_pins_obj_type;
|
||||
extern const mp_obj_type_t pin_cpu_pins_obj_type;
|
||||
|
||||
extern const mp_obj_dict_t pin_cpu_pins_locals_dict;
|
||||
extern const mp_obj_dict_t pin_board_pins_locals_dict;
|
||||
extern const mp_obj_dict_t machine_pin_cpu_pins_locals_dict;
|
||||
extern const mp_obj_dict_t machine_pin_board_pins_locals_dict;
|
||||
|
||||
void machine_pin_init(void);
|
||||
uint32_t pin_get_mode(const machine_pin_obj_t *pin);
|
||||
|
|
@ -90,8 +62,5 @@ uint32_t pin_get_drive(const machine_pin_obj_t *pin);
|
|||
uint32_t pin_get_af(const machine_pin_obj_t *pin);
|
||||
const machine_pin_obj_t *machine_pin_find(mp_obj_t user_obj);
|
||||
const machine_pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name);
|
||||
const pin_af_obj_t *pin_find_af(const machine_pin_obj_t *pin, uint8_t fn, uint8_t unit);
|
||||
const pin_af_obj_t *pin_find_af_by_index(const machine_pin_obj_t *pin, mp_uint_t af_idx);
|
||||
const pin_af_obj_t *pin_find_af_by_name(const machine_pin_obj_t *pin, const char *name);
|
||||
|
||||
#endif // MICROPY_INCLUDED_RA_PIN_H
|
||||
|
|
|
|||
Ładowanie…
Reference in New Issue