MicroPython/pyb.py

# -*- coding: utf-8 -*-

# Copyright (c) 2019 Detlev Offenbach <detlev@die-offenbachs.de>
#

"""
Module containing stubs for API generation of the def 'pyb' module.
"""

hid_mouse = 0
hid_keyboard = 0

def delay(ms):
    pass

def udelay(us):
    pass

def millis():
    pass

def micros():
    pass

def elapsed_millis(start):
    pass

def elapsed_micros(start):
    pass

def hard_reset():
    pass

def bootloader():
    pass

def fault_debug(value):
    pass

def disable_irq():
    pass

def enable_irq(state=True):
    pass

def freq(sysclk=None, hclk=None, pclk1=None, pclk2=None):
    pass

def wfi():
    pass

def stop():
    pass

def standby():
    pass

def have_cdc():
    pass

def hid(buttons, x, y, z):
    pass

def info(dump_alloc_table=None):
    pass

def main(filename):
    pass

def mount(device, mountpoint, *, readonly=False, mkfs=False):
    pass

def repl_uart(uart):
    pass

def rng():
    pass

def sync():
    pass

def unique_id():
    pass

def usb_mode(modestr=None, vid=0xf055, pid=0x9801, hid=hid_mouse):
    pass

class Accel():
    def __init__(self):
        pass
    
    def filtered_xyz(self):
        pass
    
    def tilt(self):
        pass
    
    def x(self):
        pass
    
    def y(self):
        pass
    
    def z(self):
        pass

class ADC():
    def __init__(self, pin):
        pass
    
    def read(self):
        pass
    
    def read_timed(self, buf, timer):
        pass
    
    def read_timed_multi(self, adcs, bufs, timer):
        pass

class CAN():
    NORMAL = 0
    LOOPBACK = 0
    SILENT = 0
    SILENT_LOOPBACK = 0
    STOPPED = 0
    ERROR_ACTIVE = 0
    ERROR_WARNING = 0
    ERROR_PASSIVE = 0
    BUS_OFF = 0
    LIST16 = 0
    MASK16 = 0
    LIST32 = 0
    MASK32 = 0

    def __init__(self, bus, mode, extframe=False, prescaler=100, *, sjw=1,
                 bs1=6, bs2=8, auto_restart=False):
        pass
    
    def init(self, mode, extframe=False, prescaler=100, *, sjw=1, bs1=6, bs2=8,
             auto_restart=False):
        pass
    
    @classmethod
    def initfilterbanks(cls, nr):
        pass
    
    def deinit(self):
        pass
    
    def restart(self):
        pass
    
    def state(self):
        pass
    
    def info(self, list=None):
        pass
    
    def setfilter(self, bank, mode, fifo, params, *, rtr):
        pass
    
    def clearfilter(self, bank):
        pass
    
    def any(self, fifo):
        pass
    
    def recv(self, fifo, list=None, *, timeout=5000):
        pass
    
    def send(self, data, id, *, timeout=0, rtr=False):
        pass
    
    def rxcallback(self, fifo, fun):
        pass

class DAC():
    NORMAL = 0
    CIRCULAR = 0
    
    def __init__(self, port, bits=8, *, buffering=None):
        pass
    
    def init(self, bits=8, *, buffering=None):
        pass
    
    def deinit(self):
        pass
    
    def noise(self, freq):
        pass
    
    def triangle(self, freq):
        pass
    
    def write(self, value):
        pass
    
    def write_timed(self, data, freq, *, mode=NORMAL):
        pass

class ExtInt():
    IRQ_FALLING = 0
    IRQ_RISING = 0
    IRQ_RISING_FALLING = 0
    
    def __init__(self, pin, mode, pull, callback):
        pass
    
    def disable(self):
        pass
    
    def enable(self):
        pass
    
    def line(self):
        pass
    
    def swint(self):
        pass
    
    @classmethod
    def regs(cls):
        pass

class I2C():
    MASTER = 0
    SLAVE = 0
    
    def __init__(self, bus, mode=None, *, addr=0x12, baudrate=400000,
                 gencall=False, dma=False):
        pass
    
    def deinit(self):
        pass
    
    def init(self, mode, *, addr=0x12, baudrate=400000, gencall=False,
             dma=False):
        pass
    
    def is_ready(self, addr):
        pass
    
    def mem_read(self, data, addr, memaddr, *, timeout=5000, addr_size=8):
        pass
    
    def mem_write(self, data, addr, memaddr, *, timeout=5000, addr_size=8):
        pass
    
    def recv(self, recv, addr=0x00, *, timeout=5000):
        pass
    
    def send(self, send, addr=0x00, *, timeout=5000):
        pass
    
    def scan(self):
        pass

class LCD():
    def __init__(self, skin_position):
        pass
    
    def command(self, instr_data, buf):
        pass
    
    def contrast(self, value):
        pass
    
    def fill(self, colour):
        pass
    
    def get(self, x, y):
        pass
    
    def light(self, value):
        pass
    
    def pixel(self, x, y, colour):
        pass
    
    def show(self):
        pass
    
    def text(self, text, x, y, colour):
        pass
    
    def write(self, text):
        pass

class LED():
    def __init__(self, id):
        pass
    
    def intensity(self, value=None):
        pass
    
    def off(self):
        pass
    
    def on(self):
        pass
    
    def toggle(self):
        pass

class Pin():
    AF_OD = 0
    AF_PP = 0
    ANALOG = 0
    IN = 0
    OUT_OD = 0
    OUT_PP = 0
    PULL_DOWN = 0
    PULL_NONE = 0
    PULL_UP = 0

    def __init__(self, id, mode, pull=PULL_NONE, af=-1):
        pass
    
    def init(self, mode, pull=PULL_NONE, af=-1):
        pass
    
    def value(self, value=None):
        pass
    
    def af(self):
        pass
    
    def af_list(self):
        pass
    
    def gpio(self):
        pass
    
    def mode(self):
        pass
    
    def name(self):
        pass
    
    def names(self):
        pass
    
    def pin(self):
        pass
    
    def port(self):
        pass
    
    def pull(self):
        pass

    @classmethod
    def debug(cls, state=None):
        pass
    
    @classmethod
    def dict(cls, dict=None):
        pass
    
    @classmethod
    def mapper(cls, fun=None):
        pass

class RTC():
    def __init__(self):
        pass
    
    def datetime(self, datetimetuple=None):
        pass
    
    def wakeup(self, timeout, callback=None):
        pass
    
    def info(self):
        pass
    
    def calibration(self, cal):
        pass

class Servo():
    def __init__(self, id):
        pass
    
    def angle(self, angle=None, time=0):
        pass
    
    def speed(self, speed=None, time=0):
        pass
    
    def pulse_width(self, value=None):
        pass
    
    def calibration(self, pulse_min=None, pulse_max=None, pulse_centre=None,
                    pulse_angle_90=None, pulse_speed_100=None):
        pass

class SPI():
    MASTER = 0
    SLAVE = 0
    LSB = 0
    MSB = 0
    
    def __init__(self, bus, mode=None, baudrate=328125, *, prescaler,
                 polarity=1, phase=0, bits=8, firstbit=MSB, ti=False,
                 crc=None):
        pass
    
    def deinit(self):
        pass
    
    def init(self, mode, baudrate=328125, *, prescaler, polarity=1, phase=0,
             bits=8, firstbit=MSB, ti=False, crc=None):
        pass
    
    def recv(self, recv, *, timeout=5000):
        pass
    
    def send(self, send, *, timeout=5000):
        pass
    
    def send_recv(self, send, recv=None, *, timeout=5000):
        pass

class Switch():
    def __init__(self):
        pass
    
    def value(self):
        pass
    
    def callback(self, fun):
        pass

class Timer():
    PWM = 0
    PWM_INVERTED = 0
    OC_TIMING = 0
    OC_ACTIVE = 0
    OC_INACTIVE = 0
    OC_TOGGLE = 0
    OC_FORCED_ACTIVE = 0
    OC_FORCED_INACTIVE = 0
    IC = 0
    ENC_A = 0
    ENC_B = 0
    ENC_AB = 0
    HIGH = 0
    LOW = 0
    RISING = 0
    FALLING = 0
    BOTH = 0

    def __init__(self, id, *, freq, prescaler, period):
        pass
    
    def init(self, *, freq, prescaler, period):
        pass
    
    def deinit(self):
        pass
    
    def callback(self, fun):
        pass
    
    def channel(self, channel, mode, **kwargs):
        pass
    
    def counter(self, value=None):
        pass
    
    def freq(self, value=None):
        pass
    
    def period(self, value=None):
        pass
    
    def prescaler(self, value=None):
        pass
    
    def source_freq(self):
        pass

class TimerChannel():
    def callback(self, fun):
        pass
    
    def capture(self, value=None):
        pass
    
    def compare(self, value=None):
        pass
    
    def pulse_width(self, value=None):
        pass
    
    def pulse_width_percent(self, value=None):
        pass

class UART():
    RTS = 0
    CTS = 0

    def __init__(self, bus, baudrate=None, bits=8, parity=None, stop=1, *,
                 timeout=0, flow=0, timeout_char=0, read_buf_len=64):
        pass
    
    def init(self, baudrate, bits=8, parity=None, stop=1, *, timeout=0, flow=0,
             timeout_char=0, read_buf_len=64):
        pass
    
    def deinit(self):
        pass
    
    def any(self):
        pass
    
    def read(self, nbytes=None):
        pass
    
    def readchar(self):
        pass
    
    def readinto(self, buf, nbytes=None):
        pass
    
    def readline(self):
        pass
    
    def write(self, buf):
        pass
    
    def writechar(self, char):
        pass
    
    def sendbreak(self):
        pass

class USB_HID():
    def __init__(self):
        pass
    
    def recv(self, data, *, timeout=5000):
        pass
    
    def send(self, data):
        pass

class USB_VCP():
    def __init__(self):
        pass
    
    def setinterrupt(self, chr):
        pass
    
    def isconnected(self):
        pass
    
    def any(self):
        pass
    
    def close(self):
        pass
    
    def read(self, nbytes=None):
        pass
    
    def readinto(self, buf, maxlen=None):
        pass
    
    def readline(self):
        pass
    
    def readlines(self):
        pass
    
    def write(self, buf):
        pass
    
    def recv(self, data, *, timeout=5000):
        pass
    
    def send(self, data, *, timeout=5000):
        pass