Features:
Currently the plugin supports ESP8266, Pyboard, Micro:bit, and Raspberry Pi Pico devices. Your feedback and contributions are welcome! See the project page on GitHub.
]]>Detects missing Python packages that are required for communicating with your MicroPython device.
================================================ FILE: typehints/esp32/esp.pyi ================================================ from typing import Optional from typing import Final LOG_NONE: Final[int] = ... LOG_ERROR: Final[int] = ... LOG_WARN: Final[int] = ... LOG_INFO: Final[int] = ... LOG_DEBUG: Final[int] = ... LOG_VERBOSE: Final[int] = ... def flash_size(): """Read the total size of the flash memory.""" ... def flash_user_start(): """Read the memory offset at which the user flash space begins.""" ... def flash_read(byte_offset, length_or_buffer): ... def flash_write(byte_offset, bytes): ... def flash_erase(sector_no): ... def osdebug(level: Optional[int]): """ Turn esp os debugging messages on or off. The level parameter sets the threshold for the log messages for all esp components. The log levels are defined as constants: * ``LOG_NONE`` – No log output * ``LOG_ERROR`` – Critical errors, software module can not recover on its own * ``LOG_WARN`` – Error conditions from which recovery measures have been taken * ``LOG_INFO`` – Information messages which describe normal flow of events * ``LOG_DEBUG`` – Extra information which is not necessary for normal use (values, pointers, sizes, etc) * ``LOG_VERBOSE`` – Bigger chunks of debugging information, or frequent messages which can potentially flood the output """ ... ================================================ FILE: typehints/esp32/esp32.pyi ================================================ from machine import Pin from typing import Optional from typing import overload from typing import Final HEAP_DATA: Final[int] = ... """Used in ``idf_heap_info``.""" HEAP_EXEC: Final[int] = ... """Used in ``idf_heap_info``.""" WAKEUP_ALL_LOW: Final[int] = ... """Selects the wake level for pins.""" WAKEUP_ANY_HIGH: Final[int] = ... """Selects the wake level for pins.""" def wake_on_touch(wake: bool): """ :param wake: Configure whether or not a touch will wake the device from sleep. """ def wake_on_ulp(wake: bool): """ :param wake: Configure whether or not the Ultra-Low-Power co-processor can wake the device from sleep. """ def wake_on_ext0(pin: Pin, level: Optional[int]): """ Configure how EXT0 wakes the device from sleep. :param pin: None or a valid Pin object. :param level: ``esp32.WAKEUP_ALL_LOW`` or ``esp32.WAKEUP_ANY_HIGH``. """ def wake_on_ext1(pin: Pin, level: Optional[int]): """ Configure how EXT1 wakes the device from sleep. :param pin: None or a valid Pin object. :param level: ``esp32.WAKEUP_ALL_LOW`` or ``esp32.WAKEUP_ANY_HIGH``. """ def gpio_deep_sleep_hold(enable: bool): """ :param enable: Whether non-RTC GPIO pin configuration is retained during deep-sleep mode for held pads. """ def raw_temperature() -> int: """ :return: The raw value of the internal temperature sensor. """ def hall_sensor() -> int: """ :return: The raw value of the internal Hall sensor. """ def idf_heap_info(capabilities: Optional[int]) -> list: """ Returns information about the ESP-IDF heap memory regions. One of them contains the MicroPython heap and the others are used by ESP-IDF, e.g., for network buffers and other data. This data is useful to get a sense of how much memory is available to ESP-IDF and the networking stack in particular. It may shed some light on situations where ESP-IDF operations fail due to allocation failures. The information returned is not useful to troubleshoot Python allocation failures, use ``micropython.mem_info()`` instead. The capabilities parameter corresponds to ESP-IDF’s ``MALLOC_CAP_XXX`` values but the two most useful ones are predefined as ``esp32.HEAP_DATA`` for data heap regions and ``esp32.HEAP_EXEC`` for executable regions as used by the native code emitter. The return value is a list of 4-tuples, where each 4-tuple corresponds to one heap and contains: the total bytes, the free bytes, the largest free block, and the minimum free seen over time. """ class Partition: """ This class gives access to the partitions in the device’s flash memory and includes methods to enable over-the-air (OTA) updates. """ BOOT: Final[str] = ... """Used in ``Partition`` constructor - The partition that will be booted at the next reset.""" RUNNING: Final[str] = ... """Used in ``Partition`` constructor - The currently running partition.""" TYPE_APP: Final[int] = ... """ Used in ``Partition.find`` - for bootable firmware partitions (typically labelled ``factory``, ``ota_0``, ``ota_1``) """ TYPE_DATA: Final[int] = ... """ Used in Partition.find - for other partitions, e.g. ``nvs``, ``otadata``, ``phy_init``, ``vfs``. """ def __init__(self, id: str, block_size=4096, /): """ Create an object representing a partition. :param id: Can be a string which is the label of the partition to retrieve or one of the constants: ``BOOT`` or ``RUNNING``. :param block_size: Specifies the byte size of an individual block. """ @classmethod def find(self, type=TYPE_APP, subtype=0xFF, label=None, block_size=4096) -> list: """ Find a partition specified by type, subtype and label. Note: ``subtype=0xff`` matches any subtype and ``label=None`` matches any label. :param block_size: Specifies the byte size of an individual block used by the returned objects. :return: A (possibly empty) list of Partition objects. """ def info(self) -> tuple: """ :return: A 6-tuple ``(type, subtype, addr, size, label, encrypted)``. """ @overload def readblocks(self, block_num, buf): ... @overload def readblocks(self, block_num, buf, offset): ... @overload def writeblocks(self, block_num, buf): ... @overload def writeblocks(self, block_num, buf, offset): ... def ioctl(self, cmd, arg): """These methods implement the simple and extended block protocol defined by ``os.AbstractBlockDev``.""" def set_boot(self): """Sets the partition as the boot partition.""" def get_next_update(self): """ Gets the next update partition after this one, and returns a new Partition object. Typical usage is ``Partition(Partition.RUNNING).get_next_update()``. :return: The next partition to update given the current running one. """ def mark_app_valid_cancel_rollback(self): """ Signals that the current boot is considered successful. Calling ``mark_app_valid_cancel_rollback`` is required on the first boot of a new partition to avoid an automatic rollback at the next boot. This uses the ESP-IDF “app rollback” feature with “CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE” and an ``OSError(-261)`` is raised if called on firmware that doesnt have the feature enabled. It is OK to call ``mark_app_valid_cancel_rollback`` on every boot and it is not necessary when booting firmware that was loaded using esptool. """ class RMT: """ This class provides access to one of the eight RMT channels. WARNING: The current MicroPython RMT implementation lacks some features, most notably receiving pulses. RMT should be considered a beta feature and the interface may change in the future. """ def __init__(self, channel: int, *, pin=None, clock_div=8, idle_level=False, tx_carrier=None): """ :param channel: Identifies which RMT channel (0-7) will be configured. :param pin: Configures which Pin is bound to the RMT channel :param clock_div: An 8-bit clock divider that divides the source clock (80MHz) to the RMT channel allowing the resolution to be specified. :param idle_level: Specifies what level the output will be when no transmission is in progress To enable the transmission carrier feature, ``tx_carrier`` should be a tuple of three positive integers: carrier frequency, duty percent (0 to 100) and the output level to apply the carrier to (a boolean as per idle_level). """ def source_freq(self): """ :return: The source clock frequency. Currently the source clock is not configurable so this will always return 80MHz. """ def clock_div(self): """ :return: The clock divider. Note that the channel resolution is ``1 / (source_freq / clock_div)``. """ def wait_done(self, *, timeout=0): """ If the timeout keyword argument is given then block for up to this many milliseconds for transmission to complete. :return: ``True`` if the channel is idle or ``False`` if a sequence of pulses started with ``RMT.write_pulses`` is being transmitted. """ def loop(self, enable_loop: bool): """ Configure looping on the channel. :param enable_loop: ``True`` to enable looping on the next call to ``RMT.write_pulses``. If called with ``False`` while a looping sequence is currently being transmitted then the current loop iteration will be completed and then transmission will stop. """ def write_pulses(self, duration, data=True): """ Begin transmitting a sequence. There are three ways to specify this: Mode 1: duration is a list or tuple of durations. The optional data argument specifies the initial output level. The output level will toggle after each duration. Mode 2: duration is a positive integer and data is a list or tuple of output levels. duration specifies a fixed duration for each. Mode 3: duration and data are lists or tuples of equal length, specifying individual durations and the output level for each. Durations are in integer units of the channel resolution (as described above), between 1 and 32767 units. Output levels are any value that can be converted to a boolean, with ``True`` representing high voltage and ``False`` representing low. If transmission of an earlier sequence is in progress then this method will block until that transmission is complete before beginning the new sequence. If looping has been enabled with RMT.loop, the sequence will be repeated indefinitely. Further calls to this method will block until the end of the current loop iteration before immediately beginning to loop the new sequence of pulses. Looping sequences longer than 126 pulses is not supported by the hardware. """ @staticmethod def bitstream_channel(value: Optional[int]) -> int: """ Select which RMT channel is used by the ``machine.bitstream`` implementation. :param value: Can be None or a valid RMT channel number. The default RMT channel is the highest numbered one. Passing in None disables the use of RMT and instead selects a bit-banging implementation for ``machine.bitstream``. Passing in no argument will not change the channel. This function returns the current channel number. :type value: int """ class ULP: """This class provides access to the Ultra-Low-Power co-processor.""" def set_wakeup_period(self, period_index: int, period_us): """Set the wake-up period.""" def load_binary(self, load_addr, program_binary): """Load a program_binary into the ULP at the given load_addr.""" def run(self, entry_point): """Start the ULP running at the given entry_point.""" class NVS: """ This class gives access to the Non-Volatile storage managed by ESP-IDF. The NVS is partitioned into namespaces and each namespace contains typed key-value pairs. The keys are strings and the values may be various integer types, strings, and binary blobs. The driver currently only supports 32-bit signed integers and blobs. """ def __init__(self, namespace: str): """Create an object providing access to a namespace (which is automatically created if not present).""" def set_i32(self, key, value): """Sets a 32-bit signed integer value for the specified key. Remember to call commit!""" def get_i32(self, key): """ Returns the signed integer value for the specified key. Raises an OSError if the key does not exist or has a different type. """ def set_blob(self, key, value): """ Sets a binary blob value for the specified key. The value passed in must support the buffer protocol, e.g. bytes, bytearray, str. (Note that esp-idf distinguishes blobs and strings, this method always writes a blob even if a string is passed in as value.) Remember to call commit! """ def get_blob(self, key, buffer): """ Reads the value of the blob for the specified key into the buffer, which must be a bytearray. Returns the actual length read. Raises an OSError if the key does not exist, has a different type, or if the buffer is too small. """ def erase_key(self, key): """Erases a key-value pair.""" def commit(self): """Commits changes made by set_xxx methods to flash.""" ================================================ FILE: typehints/esp32/network.pyi ================================================ """network configuration This module provides network drivers and routing configuration. To use this module, a MicroPython variant/build with network capabilities must be installed. Network drivers for specific hardware are available within this module and are used to configure hardware network interface(s). Network services provided by configured interfaces are then available for use via the :mod:`usocket` module. For example:: # connect/ show IP config a specific network interface # see below for examples of specific drivers import network import utime nic = network.Driver(...) if not nic.isconnected(): nic.connect() print("Waiting for connection...") while not nic.isconnected(): utime.sleep(1) print(nic.ifconfig()) # now use usocket as usual import usocket as socket addr = socket.getaddrinfo('micropython.org', 80)[0][-1] s = socket.socket() s.connect(addr) s.send(b'GET / HTTP/1.1\r\nHost: micropython.org\r\n\r\n') data = s.recv(1000) s.close() """ from typing import overload, Optional, List, Tuple, Union, Any, Final STA_IF: Final[int] = ... AP_IF: Final[int] = ... @overload def phy_mode() -> int: """Get the PHY mode.""" ... @overload def phy_mode(mode: int) -> None: """Set the PHY mode. The possible modes are defined as constants: * ``MODE_11B`` -- IEEE 802.11b, * ``MODE_11G`` -- IEEE 802.11g, * ``MODE_11N`` -- IEEE 802.11n. """ ... class WLAN: def __init__(self, interface_id: int) -> None: """Create a WLAN network interface object. Supported interfaces are ``network.STA_IF`` (station aka client, connects to upstream WiFi access points) and ``network.AP_IF`` (access point, allows other WiFi clients to connect). Availability of the methods below depends on interface type. For example, only STA interface may `connect()` to an access point. """ ... @overload def active(self) -> bool: """Query current state of the interface.""" ... @overload def active(self, is_active: bool) -> None: """Activate ("up") or deactivate ("down") network interface.""" ... def connect(self, ssid: Optional[Union[bytes, str]] = None, password: Optional[Union[bytes, str]] = None, *, bssid: Optional[Union[bytes, str]] = None) -> None: """Connect to the specified wireless network, using the specified password. If *bssid* is given then the connection will be restricted to the access-point with that MAC address (the *ssid* must also be specified in this case). """ ... def disconnect(self) -> None: """Disconnect from the currently connected wireless network.""" ... def scan(self) -> List[Tuple[bytes, bytes, int, int, int, int]]: """Scan for the available wireless networks. Scanning is only possible on STA interface. Returns list of tuples with the information about WiFi access points: (ssid, bssid, channel, RSSI, authmode, hidden) *bssid* is hardware address of an access point, in binary form, returned as bytes object. You can use `ubinascii.hexlify()` to convert it to ASCII form. There are five values for authmode: * 0 -- open * 1 -- WEP * 2 -- WPA-PSK * 3 -- WPA2-PSK * 4 -- WPA/WPA2-PSK and two for hidden: * 0 -- visible * 1 -- hidden """ ... def status(self) -> int: """Return the current status of the wireless connection. The possible statuses are defined as constants: * ``STAT_IDLE`` -- no connection and no activity, * ``STAT_CONNECTING`` -- connecting in progress, * ``STAT_WRONG_PASSWORD`` -- failed due to incorrect password, * ``STAT_NO_AP_FOUND`` -- failed because no access point replied, * ``STAT_CONNECT_FAIL`` -- failed due to other problems, * ``STAT_GOT_IP`` -- connection successful. """ ... def isconnected(self) -> bool: """In case of STA mode, returns ``True`` if connected to a WiFi access point and has a valid IP address. In AP mode returns ``True`` when a station is connected. Returns ``False`` otherwise. """ ... @overload def ifconfig(self) -> Tuple[str, str, str, str]: """Get IP-level network interface parameters: IP address, subnet mask, gateway and DNS server. """ ... @overload def ifconfig(self, ip: str, subnet: str, gateway: str, dns: str) -> None: """Get/set IP-level network interface parameters: IP address, subnet mask, gateway and DNS server. """ ... @overload def config(self, param: str) -> Any: """Get general network interface parameters.""" ... @overload def config(self, **kwargs: Any) -> None: """Get or set general network interface parameters. These methods allow to work with additional parameters beyond standard IP configuration (as dealt with by `wlan.ifconfig()`). These include network-specific and hardware-specific parameters. For setting parameters, keyword argument syntax should be used, multiple parameters can be set at once. For querying, parameters name should be quoted as a string, and only one parameter can be queries at time:: # Set WiFi access point name (formally known as ESSID) and WiFi channel ap.config(essid='My AP', channel=11) # Query params one by one print(ap.config('essid')) print(ap.config('channel')) Following are commonly supported parameters (availability of a specific parameter depends on network technology type, driver, and `MicroPython port`). ============= =========== Parameter Description ============= =========== mac MAC address (bytes) essid WiFi access point name (string) channel WiFi channel (integer) hidden Whether ESSID is hidden (boolean) authmode Authentication mode supported (enumeration, see module constants) password Access password (string) dhcp_hostname The DHCP hostname to use ============= =========== """ ... STA_IF: int AP_IF: int STAT_IDLE: int STAT_CONNECTING: int STAT_WRONG_PASSWORD: int STAT_NO_AP_FOUND: int STAT_CONNECT_FAIL: int STAT_GOT_IP: int MODE_11B: int MODE_11G: int MODE_11N: int ================================================ FILE: typehints/esp8266/esp.pyi ================================================ from typing import Optional def sleep_type(sleep_type: Optional[int]) -> Optional[int]: """ Get or set the sleep type. If the sleep_type parameter is provided, sets the sleep type to its value. If the function is called without parameters, returns the current sleep type. The possible sleep types are defined as constants: * ``SLEEP_NONE`` – all functions enabled,\n * ``SLEEP_MODEM`` – modem sleep, shuts down the WiFi Modem circuit.\n * ``SLEEP_LIGHT`` – light sleep, shuts down the WiFi Modem circuit and suspends the processor periodically.\n The system enters the set sleep mode automatically when possible. :param sleep_type: Sleep type. :type sleep_type: int :return: Current sleep type :rtype: int """ def deepsleep(time: int = 0) -> None: """ Enter deep sleep. The whole module powers down, except for the RTC clock circuit, which can be used to restart the module after the specified time if the pin 16 is connected to the reset pin. Otherwise the module will sleep until manually reset. :param time: Amount of time in milliseconds to sleep. """ def set_native_code_location(start: Optional[int], length: Optional[int]) -> None: """ Set the location that native code will be placed for execution after it is compiled. Native code is emitted when the ``@micropython.native``, ``@micropython.viper`` and ``@micropython.asm_xtensa`` decorators are applied to a function. The ESP8266 must execute code from either iRAM or the lower 1MByte of flash (which is memory mapped), and this function controls the location. If start and length are both **None** then the native code location is set to the unused portion of memory at the end of the iRAM1 region. The size of this unused portion depends on the firmware and is typically quite small (around 500 bytes), and is enough to store a few very small functions. The advantage of using this iRAM1 region is that it does not get worn out by writing to it. If neither start nor length are None then they should be integers. start should specify the byte offset from the beginning of the flash at which native code should be stored. length specifies how many bytes of flash from start can be used to store native code. start and length should be multiples of the sector size (being 4096 bytes). The flash will be automatically erased before writing to it so be sure to use a region of flash that is not otherwise used, for example by the firmware or the filesystem. When using the flash to store native code *start*+*length* must be less than or equal to 1MByte. Note that the flash can be worn out if repeated erasures (and writes) are made so use this feature sparingly. In particular, native code needs to be recompiled and rewritten to flash on each boot (including wake from deepsleep). In both cases above, using iRAM1 or flash, if there is no more room left in the specified region then the use of a native decorator on a function will lead to ``MemoryError`` exception being raised during compilation of that function. :param start: Start of native code region. :param length: End of native code region. """ ================================================ FILE: typehints/esp8266/network.pyi ================================================ """network configuration This module provides network drivers and routing configuration. To use this module, a MicroPython variant/build with network capabilities must be installed. Network drivers for specific hardware are available within this module and are used to configure hardware network interface(s). Network services provided by configured interfaces are then available for use via the :mod:`usocket` module. For example:: # connect/ show IP config a specific network interface # see below for examples of specific drivers import network import utime nic = network.Driver(...) if not nic.isconnected(): nic.connect() print("Waiting for connection...") while not nic.isconnected(): utime.sleep(1) print(nic.ifconfig()) # now use usocket as usual import usocket as socket addr = socket.getaddrinfo('micropython.org', 80)[0][-1] s = socket.socket() s.connect(addr) s.send(b'GET / HTTP/1.1\r\nHost: micropython.org\r\n\r\n') data = s.recv(1000) s.close() """ from typing import overload, Optional, List, Tuple, Union, Any, Final STA_IF: Final[int] = ... AP_IF: Final[int] = ... @overload def phy_mode() -> int: """Get the PHY mode.""" ... @overload def phy_mode(mode: int) -> None: """Set the PHY mode. The possible modes are defined as constants: * ``MODE_11B`` -- IEEE 802.11b, * ``MODE_11G`` -- IEEE 802.11g, * ``MODE_11N`` -- IEEE 802.11n. """ ... class WLAN: def __init__(self, interface_id: int) -> None: """Create a WLAN network interface object. Supported interfaces are ``network.STA_IF`` (station aka client, connects to upstream WiFi access points) and ``network.AP_IF`` (access point, allows other WiFi clients to connect). Availability of the methods below depends on interface type. For example, only STA interface may `connect()` to an access point. """ ... @overload def active(self) -> bool: """Query current state of the interface.""" ... @overload def active(self, is_active: bool) -> None: """Activate ("up") or deactivate ("down") network interface.""" ... def connect(self, ssid: Optional[Union[bytes, str]] = None, password: Optional[Union[bytes, str]] = None, *, bssid: Optional[Union[bytes, str]] = None) -> None: """Connect to the specified wireless network, using the specified password. If *bssid* is given then the connection will be restricted to the access-point with that MAC address (the *ssid* must also be specified in this case). """ ... def disconnect(self) -> None: """Disconnect from the currently connected wireless network.""" ... def scan(self) -> List[Tuple[bytes, bytes, int, int, int, int]]: """Scan for the available wireless networks. Scanning is only possible on STA interface. Returns list of tuples with the information about WiFi access points: (ssid, bssid, channel, RSSI, authmode, hidden) *bssid* is hardware address of an access point, in binary form, returned as bytes object. You can use `ubinascii.hexlify()` to convert it to ASCII form. There are five values for authmode: * 0 -- open * 1 -- WEP * 2 -- WPA-PSK * 3 -- WPA2-PSK * 4 -- WPA/WPA2-PSK and two for hidden: * 0 -- visible * 1 -- hidden """ ... def status(self) -> int: """Return the current status of the wireless connection. The possible statuses are defined as constants: * ``STAT_IDLE`` -- no connection and no activity, * ``STAT_CONNECTING`` -- connecting in progress, * ``STAT_WRONG_PASSWORD`` -- failed due to incorrect password, * ``STAT_NO_AP_FOUND`` -- failed because no access point replied, * ``STAT_CONNECT_FAIL`` -- failed due to other problems, * ``STAT_GOT_IP`` -- connection successful. """ ... def isconnected(self) -> bool: """In case of STA mode, returns ``True`` if connected to a WiFi access point and has a valid IP address. In AP mode returns ``True`` when a station is connected. Returns ``False`` otherwise. """ ... @overload def ifconfig(self) -> Tuple[str, str, str, str]: """Get IP-level network interface parameters: IP address, subnet mask, gateway and DNS server. """ ... @overload def ifconfig(self, ip: str, subnet: str, gateway: str, dns: str) -> None: """Get/set IP-level network interface parameters: IP address, subnet mask, gateway and DNS server. """ ... @overload def config(self, param: str) -> Any: """Get general network interface parameters.""" ... @overload def config(self, **kwargs: Any) -> None: """Get or set general network interface parameters. These methods allow to work with additional parameters beyond standard IP configuration (as dealt with by `wlan.ifconfig()`). These include network-specific and hardware-specific parameters. For setting parameters, keyword argument syntax should be used, multiple parameters can be set at once. For querying, parameters name should be quoted as a string, and only one parameter can be queries at time:: # Set WiFi access point name (formally known as ESSID) and WiFi channel ap.config(essid='My AP', channel=11) # Query params one by one print(ap.config('essid')) print(ap.config('channel')) Following are commonly supported parameters (availability of a specific parameter depends on network technology type, driver, and `MicroPython port`). ============= =========== Parameter Description ============= =========== mac MAC address (bytes) essid WiFi access point name (string) channel WiFi channel (integer) hidden Whether ESSID is hidden (boolean) authmode Authentication mode supported (enumeration, see module constants) password Access password (string) dhcp_hostname The DHCP hostname to use ============= =========== """ ... STA_IF: int AP_IF: int STAT_IDLE: int STAT_CONNECTING: int STAT_WRONG_PASSWORD: int STAT_NO_AP_FOUND: int STAT_CONNECT_FAIL: int STAT_GOT_IP: int MODE_11B: int MODE_11G: int MODE_11N: int ================================================ FILE: typehints/microbit/microbit/__init__.pyi ================================================ """micro:bit Micropython API Everything directly related to interacting with the hardware lives in the `microbit` module. For ease of use it's recommended you start all scripts with:: from microbit import * The following documentation assumes you have done this. There are a few functions available directly:: # sleep for the given number of milliseconds. sleep(ms) # returns the number of milliseconds since the micro:bit was last switched on. running_time() # makes the micro:bit enter panic mode (this usually happens when the DAL runs # out of memory, and causes a sad face to be drawn on the display). The error # code can be any arbitrary integer value. panic(error_code) # resets the micro:bit. reset() The rest of the functionality is provided by objects and classes in the microbit module, as described below. Note that the API exposes integers only (ie no floats are needed, but they may be accepted). We thus use milliseconds for the standard time unit. """ from . import (display as display, uart as uart, spi as spi, i2c as i2c, accelerometer as accelerometer, compass as compass) from typing import Any, List, overload def panic(n: int) -> None: """Enter a panic mode. Requires restart. Pass in an arbitrary integer <= 255 to indicate a status:: microbit.panic(255) """ def reset() -> None: """Restart the board.""" def sleep(n: int) -> None: """Wait for ``n`` milliseconds. One second is 1000 milliseconds, so:: microbit.sleep(1000) will pause the execution for one second. ``n`` can be an integer or a floating point number. """ def running_time() -> int: """Return the number of milliseconds since the board was switched on or restarted. """ def temperature() -> int: """Return the temperature of the micro:bit in degrees Celcius.""" class Button: """Represents a button. .. note:: This class is not actually available to the user, it is only used by the two button instances, which are provided already initialized. """ def is_pressed(self) -> bool: """Returns ``True`` if the specified button ``button`` is pressed, and ``False`` otherwise. """ def was_pressed(self) -> bool: """Returns ``True`` or ``False`` to indicate if the button was pressed since the device started or the last time this method was called. """ def get_presses(self) -> int: """Returns the running total of button presses, and resets this total to zero before returning. """ button_a: Button """A ``Button`` instance (see below) representing the left button.""" button_b: Button """Represents the right button.""" class MicroBitDigitalPin: """ The pull mode for a pin is automatically configured when the pin changes to an input mode. Input modes are when you call ``read_analog`` / ``read_digital`` / ``is_touched``. The pull mode for these is, respectively, ``NO_PULL``, ``PULL_DOWN``, ``PULL_UP``. Only when in ``read_digital`` mode can you call ``set_pull`` to change the pull mode from the default. """ NO_PULL: int = 0 PULL_UP: int = 1 PULL_DOWN: int = 2 def read_digital(self) -> int: """Return 1 if the pin is high, and 0 if it's low.""" def set_pull(self, value: int = (NO_PULL or PULL_UP or PULL_DOWN)) -> None: """Set the pull state to one of three possible values: ``pin.PULL_UP``, ``pin.PULL_DOWN`` or ``pin.NO_PULL`` (where ``pin`` is an instance of a pin). See below for discussion of default pull states. """ def write_digital(self, value: int) -> None: """Set the pin to high if ``value`` is 1, or to low, if it is 0.""" def write_analog(self, value: int) -> None: """Output a PWM signal on the pin, with the duty cycle proportional to the provided ``value``. The ``value`` may be either an integer or a floating point number between 0 (0% duty cycle) and 1023 (100% duty). """ def set_analog_period(self, period: int) -> None: """Set the period of the PWM signal being output to ``period`` in milliseconds. The minimum valid value is 1ms. """ def set_analog_period_microseconds(self, period: int) -> None: """Set the period of the PWM signal being output to ``period`` in microseconds. The minimum valid value is 35µs. """ class MicroBitAnalogDigitalPin(MicroBitDigitalPin): def read_analog(self) -> int: """Read the voltage applied to the pin, and return it as an integer between 0 (meaning 0V) and 1023 (meaning 3.3V). """ class MicroBitTouchPin(MicroBitAnalogDigitalPin): def is_touched(self) -> bool: """Return ``True`` if the pin is being touched with a finger, otherwise return ``False``. This test is done by measuring the capacitance of the pin together with whatever is connected to it. Human body has quite a large capacitance, so touching the pin gives a dramatic change in reading, which can be detected. """ pin0: MicroBitTouchPin """Pad 0.""" pin1: MicroBitTouchPin """Pad 1.""" pin2: MicroBitTouchPin """Pad 2.""" pin3: MicroBitAnalogDigitalPin """Column 1.""" pin4: MicroBitAnalogDigitalPin """Column 2.""" pin5: MicroBitDigitalPin """Button A.""" pin6: MicroBitDigitalPin """Row 2.""" pin7: MicroBitDigitalPin """Row 1.""" pin8: MicroBitDigitalPin pin9: MicroBitDigitalPin """Row 3.""" pin10: MicroBitAnalogDigitalPin """Column 3.""" pin11: MicroBitDigitalPin """Button B.""" pin12: MicroBitDigitalPin pin13: MicroBitDigitalPin """SPI MOSI.""" pin14: MicroBitDigitalPin """SPI MISO.""" pin15: MicroBitDigitalPin """SPI SCK.""" pin16: MicroBitDigitalPin pin19: MicroBitDigitalPin """I2C SCL.""" pin20: MicroBitDigitalPin """I2C SDA.""" class Image: """The ``Image`` class is used to create images that can be displayed easily on the device's LED matrix. Given an image object it's possible to display it via the ``display`` API:: display.show(Image.HAPPY) """ HEART: Image HEART_SMALL: Image HAPPY: Image SMILE: Image SAD: Image CONFUSED: Image ANGRY: Image ASLEEP: Image SURPRISED: Image SILLY: Image FABULOUS: Image MEH: Image YES: Image NO: Image CLOCK12: Image CLOCK11: Image CLOCK10: Image CLOCK9: Image CLOCK8: Image CLOCK7: Image CLOCK6: Image CLOCK5: Image CLOCK4: Image CLOCK3: Image CLOCK2: Image CLOCK1: Image ARROW_N: Image ARROW_NE: Image ARROW_E: Image ARROW_SE: Image ARROW_S: Image ARROW_SW: Image ARROW_W: Image ARROW_NW: Image TRIANGLE: Image TRIANGLE_LEFT: Image CHESSBOARD: Image DIAMOND: Image DIAMOND_SMALL: Image SQUARE: Image SQUARE_SMALL: Image RABBIT: Image COW: Image MUSIC_CROTCHET: Image MUSIC_QUAVER: Image MUSIC_QUAVERS: Image PITCHFORK: Image XMAS: Image PACMAN: Image TARGET: Image TSHIRT: Image ROLLERSKATE: Image DUCK: Image HOUSE: Image TORTOISE: Image BUTTERFLY: Image STICKFIGURE: Image GHOST: Image SWORD: Image GIRAFFE: Image SKULL: Image UMBRELLA: Image SNAKE: Image ALL_CLOCKS: List[Image] ALL_ARROWS: List[Image] @overload def __init__(self, string: str) -> None: """``string`` has to consist of digits 0-9 arranged into lines, describing the image, for example:: image = Image("90009:" "09090:" "00900:" "09090:" "90009") will create a 5×5 image of an X. The end of a line is indicated by a colon. It's also possible to use a newline (\n) to indicate the end of a line like this:: image = Image("90009\n" "09090\n" "00900\n" "09090\n" "90009") """ @overload def __init__(self, width: int = None, height: int = None, buffer: Any = None) -> None: """Create an empty image with ``width`` columns and ``height`` rows. Optionally ``buffer`` can be an array of ``width``×``height`` integers in range 0-9 to initialize the image. """ def width(self) -> int: """Return the number of columns in the image.""" def height(self) -> int: """Return the numbers of rows in the image.""" def set_pixel(self, x: int, y: int, value: int) -> None: """Set the brightness of the pixel at column ``x`` and row ``y`` to the ``value``, which has to be between 0 (dark) and 9 (bright). This method will raise an exception when called on any of the built-in read-only images, like ``Image.HEART``. """ def get_pixel(self, x: int, y: int) -> int: """Return the brightness of pixel at column ``x`` and row ``y`` as an integer between 0 and 9. """ def shift_left(self, n: int) -> Image: """Return a new image created by shifting the picture left by ``n`` columns. """ def shift_right(self, n: int) -> Image: """Same as ``image.shift_left(-n)``.""" def shift_up(self, n: int) -> Image: """Return a new image created by shifting the picture up by ``n`` rows. """ def shift_down(self, n: int) -> Image: """Same as ``image.shift_up(-n)``.""" def crop(self, x: int, y: int, w: int, h: int) -> Image: """Return a new image by cropping the picture to a width of ``w`` and a height of ``h``, starting with the pixel at column ``x`` and row ``y``. """ def copy(self) -> Image: """Return an exact copy of the image.""" def invert(self) -> Image: """Return a new image by inverting the brightness of the pixels in the source image.""" def fill(self, value: int) -> None: """Set the brightness of all the pixels in the image to the ``value``, which has to be between 0 (dark) and 9 (bright). This method will raise an exception when called on any of the built-in read-only images, like ``Image.HEART``. """ def blit(self, src: Image, x: int, y: int, w: int, h: int, xdest: int = 0, ydest: int = 0) -> None: """Copy the rectangle defined by ``x``, ``y``, ``w``, ``h`` from the image ``src`` into this image at ``xdest``, ``ydest``. Areas in the source rectangle, but outside the source image are treated as having a value of 0. ``shift_left()``, ``shift_right()``, ``shift_up()``, ``shift_down()`` and ``crop()`` can are all implemented by using ``blit()``. For example, img.crop(x, y, w, h) can be implemented as:: def crop(self, x, y, w, h): res = Image(w, h) res.blit(self, x, y, w, h) return res """ def __repr__(self) -> str: """Get a compact string representation of the image.""" def __str__(self) -> str: """Get a readable string representation of the image.""" def __add__(self, other: Image) -> Image: """Create a new image by adding the brightness values from the two images for each pixel. """ def __mul__(self, n: float) -> Image: """Create a new image by multiplying the brightness of each pixel by ``n``. """ ================================================ FILE: typehints/microbit/microbit/accelerometer.pyi ================================================ """This object gives you access to the on-board accelerometer. The accelerometer also provides convenience functions for detecting gestures. The recognised gestures are: ``up``, ``down``, ``left``, ``right``, ``face up``, ``face down``, ``freefall``, ``3g``, ``6g``, ``8g``, ``shake``. """ from typing import Tuple def get_x() -> int: """Get the acceleration measurement in the ``x`` axis, as a positive or negative integer, depending on the direction. """ def get_y() -> int: """Get the acceleration measurement in the ``y`` axis, as a positive or negative integer, depending on the direction. """ def get_z() -> int: """Get the acceleration measurement in the ``z`` axis, as a positive or negative integer, depending on the direction. """ def get_values() -> Tuple[int, int, int]: """Get the acceleration measurements in all axes at once, as a three-element tuple of integers ordered as X, Y, Z. """ def current_gesture() -> str: """Return the name of the current gesture. .. note:: MicroPython understands the following gesture names: ``"up"``, ``"down"``, ``"left"``, ``"right"``, ``"face up"``, ``"face down"``, ``"freefall"``, ``"3g"``, ``"6g"``, ``"8g"``, ``"shake"``. Gestures are always represented as strings.""" def is_gesture(name: str) -> bool: """Return True or False to indicate if the named gesture is currently active.""" def was_gesture(name: str) -> bool: """Return True or False to indicate if the named gesture was active since the last call. """ def get_gestures() -> Tuple[str, ...]: """Return a tuple of the gesture history. The most recent is listed last. Also clears the gesture history before returning. """ ================================================ FILE: typehints/microbit/microbit/compass.pyi ================================================ """This module lets you access the built-in electronic compass. Before using, the compass should be calibrated, otherwise the readings may be wrong. .. warning:: Calibrating the compass will cause your program to pause until calibration is complete. Calibration consists of a little game to draw a circle on the LED display by rotating the device. """ def calibrate() -> None: """Starts the calibration process. An instructive message will be scrolled to the user after which they will need to rotate the device in order to draw a circle on the LED display. """ def is_calibrated() -> bool: """Returns ``True`` if the compass has been successfully calibrated, and returns ``False`` otherwise. """ def clear_calibration() -> None: """Undoes the calibration, making the compass uncalibrated again.""" def get_x() -> int: """Gives the reading of the magnetic force on the ``x`` axis, as a positive or negative integer, depending on the direction of the force. """ def get_y() -> int: """Gives the reading of the magnetic force on the ``x`` axis, as a positive or negative integer, depending on the direction of the force. """ def get_z() -> int: """Gives the reading of the magnetic force on the ``x`` axis, as a positive or negative integer, depending on the direction of the force. """ def heading() -> int: """Gives the compass heading, calculated from the above readings, as an integer in the range from 0 to 360, representing the angle in degrees, clockwise, with north as 0. If the compass has not been calibrated, then this will call ``calibrate``. """ def get_field_strength() -> int: """Returns an integer indication of the magnitude of the magnetic field around the device.""" ================================================ FILE: typehints/microbit/microbit/display.pyi ================================================ """This module controls the 5×5 LED display on the front of your board. It can be used to display images, animations and even text. To continuously scroll a string across the display, and do it in the background, you can use:: import microbit microbit.display.scroll('Hello!', wait=False, loop=True) """ from . import Image from typing import overload, Iterable def get_pixel(x: int, y: int) -> int: """Return the brightness of the LED at column ``x`` and row ``y`` as an integer between 0 (off) and 9 (bright). """ def set_pixel(x: int, y: int, value: int) -> None: """Set the brightness of the LED at column ``x`` and row ``y`` to ``value``, which has to be an integer between 0 and 9. """ def clear() -> None: """Set the brightness of all LEDs to 0 (off).""" @overload def show(image: Image) -> None: """Display the ``image``.""" @overload def show(iterable: Iterable[Image, str], delay: int = 400, *, wait: bool = True, loop: bool =False, clear: bool = False) -> None: """Display images or letters from the ``iterable`` in sequence, with ``delay`` milliseconds between them. If ``wait`` is ``True``, this function will block until the animation is finished, otherwise the animation will happen in the background. If ``loop`` is ``True``, the animation will repeat forever. If ``clear`` is ``True``, the display will be cleared after the iterable has finished. Note that the ``wait``, ``loop`` and ``clear`` arguments must be specified using their keyword. .. note:: If using a generator as the ``iterable``, then take care not to allocate any memory in the generator as allocating memory in an interrupt is prohibited and will raise a ``MemoryError``. """ def scroll(string: str, delay: int = 150, *, wait: bool = True, loop: bool = False, monospace: bool = False) -> None: """Similar to ``show``, but scrolls the ``string`` horizontally instead. The ``delay`` parameter controls how fast the text is scrolling. If ``wait`` is ``True``, this function will block until the animation is finished, otherwise the animation will happen in the background. If ``loop`` is ``True``, the animation will repeat forever. If ``monospace`` is ``True``, the characters will all take up 5 pixel-columns in width, otherwise there will be exactly 1 blank pixel-column between each character as they scroll. Note that the ``wait``, ``loop`` and ``monospace`` arguments must be specified using their keyword. """ def on() -> None: """Use on() to turn on the display.""" def off() -> None: """Use off() to turn off the display (thus allowing you to re-use the GPIO pins associated with the display for other purposes). """ def is_on() -> bool: """Returns ``True`` if the display is on, otherwise returns ``False``.""" ================================================ FILE: typehints/microbit/microbit/i2c.pyi ================================================ """The ``i2c`` module lets you communicate with devices connected to your board using the I²C bus protocol. There can be multiple slave devices connected at the same time, and each one has its own unique address, that is either fixed for the device or configured on it. Your board acts as the I²C master. We use 7-bit addressing for devices because of the reasons stated `here