From 91bc7878f27f0e86d3bd27cf7771265186c53238 Mon Sep 17 00:00:00 2001 From: Jan Lerking Date: Wed, 9 Apr 2025 06:23:45 +0200 Subject: [PATCH] Update. /JL --- begynder/billede.py | 6 + microbit/__init__.py | 505 ++++++++++++++++++++++++++++++++++++++ microbit/accelerometer.py | 70 ++++++ microbit/compass.py | 48 ++++ microbit/display.py | 69 ++++++ microbit/i2c.py | 35 +++ microbit/microphone.py | 51 ++++ microbit/power.py | 50 ++++ microbit/speaker.py | 19 ++ microbit/spi.py | 52 ++++ microbit/uart.py | 18 ++ 11 files changed, 923 insertions(+) create mode 100644 begynder/billede.py create mode 100644 microbit/__init__.py create mode 100644 microbit/accelerometer.py create mode 100644 microbit/compass.py create mode 100644 microbit/display.py create mode 100644 microbit/i2c.py create mode 100644 microbit/microphone.py create mode 100644 microbit/power.py create mode 100644 microbit/speaker.py create mode 100644 microbit/spi.py create mode 100644 microbit/uart.py diff --git a/begynder/billede.py b/begynder/billede.py new file mode 100644 index 0000000..cfae438 --- /dev/null +++ b/begynder/billede.py @@ -0,0 +1,6 @@ +from microbit import * + +while True: + display.show(Image.HEART) + sleep(1000) + display.scroll('Hello') diff --git a/microbit/__init__.py b/microbit/__init__.py new file mode 100644 index 0000000..2e99e7f --- /dev/null +++ b/microbit/__init__.py @@ -0,0 +1,505 @@ +# Basics +import accelerometer +import compass +import display +import i2c +import microphone +import power +import speaker +import spi +import uart +# Extended +import audio +import machine +import music +import neopixel +import os +import radio +import random +import speech + +#Functions + +def panic(): + """ Enter a panic mode that stops all execution, scrolls an + error code in the micro:bit display and requires restart. + Parameters: n – An arbitrary integer between 0 and 255 + to indicate an error code. """ + pass + +def reset(): + """ Restart the board. """ + pass + +def running_time(): + """ Returns: The number of milliseconds since the board was switched on or restarted. """ + pass + +def scale(value, from_, to): + """ Converts a value from a range to another range. + For example, to convert 30 degrees from Celsius to Fahrenheit: + temp_fahrenheit = scale(30, from_=(0.0, 100.0), to=(32.0, 212.0)) + + This can be useful to convert values between inputs and outputs, + for example an accelerometer x value to a speaker volume. + + If one of the numbers in the to parameter is a floating point + (i.e a decimal number like 10.0), this function will return a floating point + number. If they are both integers (i.e 10), it will return an integer: + + returns_int = scale(accelerometer.get_x(), from_=(-2000, 2000), to=(0, 255)) + + Negative scaling is also supported, for example scale(25, from_=(0, 100), + to=(0, -200)) will return -50. + + Parameters: + value – A number to convert. + from – A tuple to define the range to convert from. + to – A tuple to define the range to convert to. + + Returns: + The value converted to the to range. """ + pass + +def set_volume(volume): + """ (V2 only) Configure the output volume of the micro:bit speaker and pins. + Parameters: volume – An integer between 0 and 255 to set the volume. """ + pass + +def sleep(n): + """ Wait for n milliseconds. One second is 1000 milliseconds. + Parameters: n – An integer or floating point number indicating the number + of milliseconds to wait. """ + pass + +def run_every(callback, days=None, h=None, min=None, s=None, ms=None): + """ Schedule to run a function at the interval specified by the time arguments. + run_every can be used in two ways: + As a Decorator - placed on top of the function to schedule. For example: + + @run_every(days=1, h=1, min=20, s=30, ms=50) + def my_function(): + # Do something here + + As a Function - passing the callback as a positional argument. For example: + + def my_function(): + # Do something here + run_every(my_function, s=30) + + Each argument corresponds to a different time unit and they are additive. + So run_every(min=1, s=30) schedules the callback every minute and a half. + + When an exception is thrown inside the callback function it deschedules the function. + To avoid this you can catch exceptions with try/except. + Parameters: + + callback – Function to call at the provided interval. + days – Sets the days mark for the scheduling. + h – Sets the hour mark for the scheduling. + min – Sets the minute mark for the scheduling. + s – Sets the second mark for the scheduling. + ms – Sets the millisecond mark for the scheduling. """ + pass + +def temperature(): + """ Returns: An integer with the temperature of the micro:bit in degrees Celcius. """ + pass + +#Attributes-Buttons + +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 __init__(self) -> None: + pass + + def is_pressed(): + """ Returns True if the specified button button is currently being held down, + and False otherwise. """ + pass + + def was_pressed(): + """ Returns True or False to indicate if the button was pressed (went from up to down) + since the device started or the last time this method was called. Calling this + method will clear the press state so that the button must be pressed again before + this method will return True again. """ + pass + + def get_presses(): + """ Returns the running total of button presses, and resets this total + to zero before returning. """ + pass + +button_a = _Button() +""" A Button instance representing the left button. """ + +button_b = _Button() +""" Represents the right button. """ + +#Attributes-Input/Output Pins + +""" There are three kinds of pins, differing in what is available for them. They +are represented by the classes listed below. Note that they form a hierarchy, +so that each class has all the functionality of the previous class, and adds +its own to that. + +Note: +Those classes are not actually available for the user, you can’t create new +instances of them. You can only use the instances already provided, representing +the physical pins on your board. """ + +class _MicroBitDigitalPin(): + + def __init__(self) -> None: + pass + + def read_digital(): + """ Return 1 if the pin is high, and 0 if it’s low. """ + pass + + def write_digital(value): + """ Set the pin to high if value is 1, or to low, if it is 0. """ + pass + + def set_pull(value): + """ 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). + 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 + default pull mode for these is, respectively, NO_PULL, PULL_DOWN, PULL_UP. Calling + set_pull will configure the pin to be in read_digital mode with the given pull mode. """ + pass + + def get_pull(): + """ Returns the pull configuration on a pin, which can be one of three possible values: + NO_PULL, PULL_DOWN, or PULL_UP. These are set using the set_pull() method or + automatically configured when a pin mode requires it. """ + pass + + def get_mode(): + """ Returns the pin mode. When a pin is used for a specific function, like writing a + digital value, or reading an analog value, the pin mode changes. Pins can have one of + the following modes: "unused", "analog", "read_digital", "write_digital", "display", + "button", "music", "audio", "touch", "i2c", "spi". """ + pass + + def write_analog(value): + """ 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). """ + pass + + def set_analog_period(period): + """ Set the period of the PWM signal being output to period in milliseconds. The minimum + valid value is 1ms. """ + pass + + def set_analog_period_microseconds(period): + """ Set the period of the PWM signal being output to period in microseconds. The minimum + valid value is 256µs. """ + pass + + def get_analog_period_microseconds(): + """ Returns the configured period of the PWM signal in microseconds. """ + pass + +class _MicroBitAnalogDigitalPin(_MicroBitDigitalPin): + + def __init__(self) -> None: + pass + + def read_analog(): + """ Read the voltage applied to the pin, and return it as an integer + between 0 (meaning 0V) and 1023 (meaning 3.3V). """ + pass + +class _MicroBitTouchPin(_MicroBitAnalogDigitalPin): + + def __init__(self) -> None: + pass + + def is_touched(): + """ Return True if the pin is being touched with a finger, otherwise return False. + Note: + The default touch mode for the pins on the edge connector is resistive. The default + for the logo pin V2 is capacitive. + Resistive touch This test is done by measuring how much resistance there is between + the pin and ground. A low resistance gives a reading of True. To get a reliable + reading using a finger you may need to touch the ground pin with another part of your + body, for example your other hand. + Capacitive touch This test is done by interacting with the electric field of a + capacitor using a finger as a conductor. Capacitive touch does not require you to make + a ground connection as part of a circuit. """ + pass + + def set_touch_mode(value): + """ Set the touch mode for the given pin. Value can be either CAPACITIVE or RESISTIVE. + For example, pin0.set_touch_mode(pin0.CAPACITIVE). """ + pass + +pin_logo = _MicroBitTouchPin() +""" A touch sensitive logo pin on the front of the micro:bit, which by default is set to +capacitive touch mode. """ +pin_speaker = _MicroBitAnalogDigitalPin() +""" A pin to address the micro:bit speaker. This API is intended only for use in Pulse-Width +Modulation pin operations eg. pin_speaker.write_analog(128). """ + +pin0 = _MicroBitTouchPin() +pin1 = _MicroBitTouchPin() +pin2 = _MicroBitTouchPin() + +pin3 = _MicroBitAnalogDigitalPin() +pin4 = _MicroBitAnalogDigitalPin() + +pin5 = _MicroBitDigitalPin() +pin6 = _MicroBitDigitalPin() +pin7 = _MicroBitDigitalPin() +pin8 = _MicroBitDigitalPin() +pin9 = _MicroBitDigitalPin() + +pin10 = _MicroBitAnalogDigitalPin() + +pin11 = _MicroBitDigitalPin() +pin12 = _MicroBitDigitalPin() +pin13 = _MicroBitDigitalPin() +pin14 = _MicroBitDigitalPin() +pin15 = _MicroBitDigitalPin() +pin16 = _MicroBitDigitalPin() +# Pin17 = 3v3 +# Pin18 = 3v3 +pin19 = _MicroBitDigitalPin() +pin20 = _MicroBitDigitalPin() +# pin21 = gnd +# pin22 = gnd + +""" Note: +GPIO pins are also used for the display, as described in the table above. If you want to use +these pins for another purpose, you may need to turn the display off. For more info see the +edge connector data sheet. """ + +#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) """ + + +class Image(): + """ There are four ways in which you can construct an image: + Image() - Create a blank 5x5 image + Image(string) + Create an image by parsing the string, + 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. + A single character returns that glyph. + Image(width, height) + Creates an empty image with width columns and height rows. + Image(width, height, buffer) + Optionally buffer can be an array of width``×``height integers in range 0-9 to + initialize the image: + Image(2, 2, bytearray([9,9,9,9])) """ + def __init__(self) -> None: + pass + + def width(): + """ Return the number of columns in the image. """ + pass + + def height(): + """ Return the numbers of rows in the image. """ + pass + + def set_pixel(x, y, value): + """ 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. """ + pass + + def get_pixel(x, y): + """ Return the brightness of pixel at column x and row y as an integer between 0 and 9. """ + pass + + def shift_left(n): + """ Return a new image created by shifting the picture left by n columns. """ + pass + + def shift_right(n): + """ Same as image.shift_left(-n). """ + pass + + def shift_up(n): + """ Return a new image created by shifting the picture up by n rows. """ + pass + def shift_down(n): + """ Same as image.shift_up(-n). """ + pass + + def crop(x, y, w, h): + """ 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. """ + pass + + def copy(): + """ Return an exact copy of the image. """ + pass + + def invert(): + """ Return a new image by inverting the brightness of the pixels in the source image. """ + pass + + def fill(value): + """ 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. """ + pass + + def blit(src, x, y, w, h, xdest=0, ydest=0): + """ 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 """ + pass + + #Class-Image-Attributes + """ The Image class also has the following built-in instances of itself included as its attributes + (the attribute names indicate what the image represents): """ + + HEART = None + HEART_SMALL = None + HAPPY = None + SMILE = None + SAD = None + CONFUSED = None + ANGRY = None + ASLEEP = None + SURPRISED = None + SILLY = None + FABULOUS = None + MEH = None + YES = None + NO = None + CLOCK12 = None + CLOCK11 = None + CLOCK10 = None + CLOCK9 = None + CLOCK8 = None + CLOCK7 = None + CLOCK6 = None + CLOCK5 = None + CLOCK4 = None + CLOCK3 = None + CLOCK2 = None + CLOCK1 = None + ARROW_N = None + ARROW_NE = None + ARROW_E = None + ARROW_SE = None + ARROW_S = None + ARROW_SW = None + ARROW_W = None + ARROW_NW = None + TRIANGLE = None + TRIANGLE_LEFT = None + CHESSBOARD = None + DIAMOND = None + DIAMOND_SMALL = None + SQUARE = None + SQUARE_SMALL = None + RABBIT = None + COW = None + MUSIC_CROTCHET = None + MUSIC_QUAVER = None + MUSIC_QUAVERS = None + PITCHFORK = None + XMAS = None + PACMAN = None + TARGET = None + TSHIRT = None + ROLLERSKATE = None + DUCK = None + HOUSE = None + TORTOISE = None + BUTTERFLY = None + STICKFIGURE = None + GHOST = None + SWORD = None + GIRAFFE = None + SKULL = None + UMBRELLA = None + SNAKE = None + + #Finally, related collections of images have been grouped together: + + ALL_CLOCKS = [None] #A list of all CLOCK images. + ALL_ARROWS = [None] #A list of all ARROW images. + + #Class-Image-Attributes-Operations + def repr(image_attribute): + """ Get a compact string representation of the image attribute. + Parameters: image_attribute - Name of image e.g. HEART""" + pass + + def str(image_attribute): + """ Get a readable string representation of the image. + Parameters: image_attribute - Name of image e.g. HEART """ + pass + + def addimg(): + """ Create a new image by adding the brightness values from the two images for each pixel. + Parameters: image_attribute - Name of image e.g. HEART """ + pass + + def multimg(): + """ Create a new image by multiplying the brightness of each pixel by n. + Parameters: image_attribute - Name of image e.g. HEART """ + pass + +#Class-Sound + +class Sound(): + """ Built-in sounds V2. The built-in sounds can be called using audio.play(Sound.NAME). """ + def __init__(self): + pass + + GIGGLE = None + HAPPY = None + HELLO = None + MYSTERIOUS = None + SAD = None + SLIDE = None + SOARING = None + SPRING = None + TWINKLE = None + YAWN = None + +#Class-SoundEvent + +class SoundEvent(): + """ The microphone can respond to a pre-defined set of sound events that are based on the + amplitude and wavelength of the sound. These sound events are represented by instances of + the SoundEvent class, accessible via variables in microbit.SoundEvent: + + microbit.SoundEvent.QUIET: Represents the transition of sound events, from loud to quiet + like speaking or background music. + microbit.SoundEvent.LOUD: Represents the transition of sound events, from quiet to loud + like clapping or shouting. + """ + def __init__(self): + pass + + QUIET=None + LOUD=None \ No newline at end of file diff --git a/microbit/accelerometer.py b/microbit/accelerometer.py new file mode 100644 index 0000000..de26ddd --- /dev/null +++ b/microbit/accelerometer.py @@ -0,0 +1,70 @@ +#Accelerometer + +""" This module gives you access to the on-board accelerometer. +By default MicroPython sets the accelerometer range to +/- 2000 mg (g being a unit of +acceleration based on the standard gravity), which configures the maximum and minimum +values returned by the accelerometer functions. The range can be changed via set_range(). + +The accelerometer also provides convenience functions for detecting gestures. The +recognised gestures are represented as strings: up, down, left, right, face up, face down, +freefall, 3g, 6g, 8g, shake. + +Note: +Gestures are not updated in the background so there needs to be constant calls to some +accelerometer method to do the gesture detection. Usually gestures can be detected using a +loop with a small sleep() delay. +Functions """ + +#Functions + +def get_x(): + """ Returns: The acceleration measurement in the x axis in milli-g, as a positive or + negative integer. """ + pass + +def get_y(): + """ Returns: The acceleration measurement in the y axis in milli-g, as a positive or + negative integer. """ + pass + +def get_z(): + """ Returns: The acceleration measurement in the z axis in milli-g, as a positive or + negative integer. """ + pass + +def get_values(): + """ Returns: The acceleration measurements in all axes at once, as a three-element tuple + of integers ordered as X, Y, Z. """ + pass + +def get_strength(): + """ Get the acceleration measurement of all axes combined, as a positive integer. This is the + Pythagorean sum of the X, Y and Z axes. + Returns: The combined acceleration strength of all the axes, in milli-g. """ + pass + +def current_gesture(): + """ Returns: String with the name of the current gesture. """ + pass + +def is_gesture(name): + """ Parameters: name – String with the name of the gesture to check. + Returns: Boolean indicating if the named gesture is currently active. """ + pass + +def was_gesture(name): + """ Parameters: name – String with the name of the gesture to check. + Returns: Boolean indicating if the named gesture was active since the last call. """ + pass + +def get_gestures(): + """ Get a historical list of the registered gestures. + Calling this function clears the gesture history before returning. + Returns: A tuple of the gesture history, most recent is listed last. """ + pass + +def set_range(value): + """ Set the accelerometer sensitivity range, in g (standard gravity), to the closest values + supported by the hardware, so it rounds to either 2, 4, or 8 g. + Parameters: value – New range for the accelerometer, an integer in g. """ + pass \ No newline at end of file diff --git a/microbit/compass.py b/microbit/compass.py new file mode 100644 index 0000000..7cfa7e4 --- /dev/null +++ b/microbit/compass.py @@ -0,0 +1,48 @@ +#Compass +""" 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. """ + +#Functions + +def calibrate(): + """ 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 fill the LED display. """ + pass + +def is_calibrated(): + """ Returns True if the compass has been successfully calibrated, and returns False otherwise. """ + pass + +def clear_calibration(): + """ Undoes the calibration, making the compass uncalibrated again. """ + pass + +def get_x(): + """ Gives the reading of the magnetic field strength on the x axis in nano tesla, as a + positive or negative integer, depending on the direction of the field. """ + pass + +def get_y(): + """ Gives the reading of the magnetic field strength on the y axis in nano tesla, as a + positive or negative integer, depending on the direction of the field. """ + pass + +def get_z(): + """ Gives the reading of the magnetic field strength on the z axis in nano tesla, as a + positive or negative integer, depending on the direction of the field. """ + pass + +def heading(): + """ 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. """ + pass + +def get_field_strength(): + """ Returns an integer indication of the magnitude of the magnetic field around the device + in nano tesla. """ + pass \ No newline at end of file diff --git a/microbit/display.py b/microbit/display.py new file mode 100644 index 0000000..c94086e --- /dev/null +++ b/microbit/display.py @@ -0,0 +1,69 @@ +#Display +""" 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. """ + +#Functions + +def get_pixel(x, y): + """ Return the brightness of the LED at column x and row y as an integer between 0 (off) + and 9 (bright). """ + pass + +def set_pixel(x, y, value): + """ Set the brightness of the LED at column x and row y to value, which has to be an integer + between 0 and 9. """ + pass + +def clear(): + """ Set the brightness of all LEDs to 0 (off). """ + pass + +def show(image, delay=400, *, wait=True, loop=False, clear=False): + """ If image is a string, float or integer, display letters/digits in sequence. Otherwise, + if image is an iterable sequence of images, display these images in sequence. Each letter, + digit or image is shown 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. """ + pass + +def scroll(text, delay=150, *, wait=True, loop=False, monospace=False): + """ Scrolls text horizontally on the display. If text is an integer or float it is first + converted to a string using str(). 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. """ + pass + +def on(): + """ Use on() to turn on the display. """ + pass + +def off(): + """ Use off() to turn off the display (thus allowing you to re-use the GPIO pins associated + with the display for other purposes). """ + pass + +def is_on(): + """ Returns True if the display is on, otherwise returns False. """ + pass + +def read_light_level(): + """ Use the display’s LEDs in reverse-bias mode to sense the amount of light falling on + the display. Returns an integer between 0 and 255 representing the light level, with + larger meaning more light. """ + pass diff --git a/microbit/i2c.py b/microbit/i2c.py new file mode 100644 index 0000000..68bd0e5 --- /dev/null +++ b/microbit/i2c.py @@ -0,0 +1,35 @@ +from microbit import pin19, pin20 +#I²C + +""" 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. """ + +#Functions + +def init(freq=100000, sda=pin20, scl=pin19): + """ Re-initialize peripheral with the specified clock frequency freq on the specified sda + and scl pins. + + Warning + On a micro:bit V1 board, changing the I²C pins from defaults will make the accelerometer + and compass stop working, as they are connected internally to those pins. This warning + does not apply to the V2 revision of the micro:bit as this has separate I²C lines for the + motion sensors and the edge connector. """ + pass + +def scan(): + """ Scan the bus for devices. Returns a list of 7-bit addresses corresponding to those + devices that responded to the scan. """ + pass + +def read(addr, n, repeat=False): + """ Read n bytes from the device with 7-bit address addr. If repeat is True, no stop bit + will be sent. """ + pass + +def write(addr, buf, repeat=False): + """ Write bytes from buf to the device with 7-bit address addr. If repeat is True, no stop + bit will be sent. """ + pass \ No newline at end of file diff --git a/microbit/microphone.py b/microbit/microphone.py new file mode 100644 index 0000000..043eab2 --- /dev/null +++ b/microbit/microphone.py @@ -0,0 +1,51 @@ +#Microphone V2 + +""" This object lets you access the built-in microphone available on the micro:bit V2. It can +be used to respond to sound. The microphone input is located on the front of the board +alongside a microphone activity LED, which is lit when the microphone is in use. """ + + +#Sound events + +""" The microphone can respond to a pre-defined set of sound events that are based on the +amplitude and wavelength of the sound. These sound events are represented by instances of +the SoundEvent class, accessible via variables in SoundEvent: + SoundEvent.QUIET: Represents the transition of sound events, from loud to quiet + like speaking or background music. + SoundEvent.LOUD: Represents the transition of sound events, from quiet to loud + like clapping or shouting. """ + +#Functions + +def current_event(): + """ return: the name of the last recorded sound event, SoundEvent('loud') or + SoundEvent('quiet'). """ + pass + +def was_event(event): + """ event: a sound event, such as SoundEvent.LOUD or SoundEvent.QUIET. + return: true if sound was heard at least once since the last call, + otherwise false. was_event() also clears the sound event history before returning. """ + pass + +def is_event(event): + """ event: a sound event, such as SoundEvent.LOUD or SoundEvent.QUIET. + return: true if sound event is the most recent since the last call, otherwise false. + It does not clear the sound event history. """ + pass + +def get_events(): + """ return: a tuple of the event history. The most recent is listed last. get_events() + also clears the sound event history before returning. """ + pass + +def set_threshold(event, value): + """ event: a sound event, such as SoundEvent.LOUD or SoundEvent.QUIET. + value: The threshold level in the range 0-255. For example, + set_threshold(SoundEvent.LOUD, 250) will only trigger if the sound is very + loud (>= 250). """ + pass + +def sound_level(): + """ return: a representation of the sound pressure level in the range 0 to 255. """ + pass \ No newline at end of file diff --git a/microbit/power.py b/microbit/power.py new file mode 100644 index 0000000..fa58082 --- /dev/null +++ b/microbit/power.py @@ -0,0 +1,50 @@ +#Power Management V2 + +""" This module lets you manage the power modes of the micro:bit V2. + +There are two micro:bit board low power modes that can be requested +from MicroPython: + + Deep Sleep: Low power mode where the board can be woken up via + multiple sources (pins, button presses, uart data, or a timer) + and resume operation. + Off: The power mode with the lowest power consumption, the only + way to wake up the board is via the reset button, or by plugging + the USB cable while on battery power. When the board wakes up it + will restart and execute your programme from the beginning. """ + +#Functions + +def off(): + """ Power down the board to the lowest possible power mode. This is + the equivalent to pressing the reset button for a few second, + to set the board in “Off mode”. + The micro:bit will only wake up if the reset button is pressed or, + if on battery power, when a USB cable is connected. + When the board wakes up it will start for a reset state, so your + programme will start running from the beginning. """ + pass + +def deep_sleep(ms=None, wake_on=None, run_every=True): + """ Set the micro:bit into a low power mode where it can wake up and + continue operation. + The programme state is preserved and when it wakes up it will resume + operation where it left off. + Deep Sleep mode will consume more battery power than Off mode. + The wake up sources are configured via arguments. + The board will always wake up when receiving UART data, when the reset + button is pressed (which resets the board) or, in battery power, when + the USB cable is inserted. + + When the run_every parameter is set to True (the default), any function + scheduled with microbit.run_every will momentarily wake up the board to + run and when it finishes it will go back to sleep. + Parameters: + + ms – A time in milliseconds to wait before it wakes up. + wake_on – A single instance or a tuple of pins and/or buttons + to wake up the board, e.g. deep_sleep(wake_on=button_a) or + deep_sleep(wake_on=(pin0, pin2, button_b)). + run_every – A boolean to configure if the functions scheduled + with microbit.run_every will continue to run while it sleeps. """ + pass diff --git a/microbit/speaker.py b/microbit/speaker.py new file mode 100644 index 0000000..8d2bf90 --- /dev/null +++ b/microbit/speaker.py @@ -0,0 +1,19 @@ +#Speaker V2 + +""" The micro:bit V2 has a built-in speaker located on the rear of the board. +By default sound output will be via the edge connector on pin 0 and the built-in speaker V2. +You can connect wired headphones or a speaker to pin 0 and GND on the edge connector to hear +the sounds. +The speaker can be turned off or on using the functions listed here. """ + +#Functions + +def off(): + """ Use off() to turn off the speaker. This does not disable sound output to an + edge connector pin. """ + pass + +def on(): + """ Use on() to turn on the speaker. """ + pass + diff --git a/microbit/spi.py b/microbit/spi.py new file mode 100644 index 0000000..90134cb --- /dev/null +++ b/microbit/spi.py @@ -0,0 +1,52 @@ +from microbit import pin13, pin15, pin14 +#SPI + +""" The SPI module lets you talk to a device connected to your board using a serial +peripheral interface (SPI) bus. SPI uses a so-called master-slave architecture with +a single master. You will need to specify the connections for three signals: + + SCLK : Serial Clock (output from master). + MOSI : Master Output, Slave Input (output from master). + MISO : Master Input, Slave Output (output from slave). """ + +#Functions + +def init(baudrate=1000000, bits=8, mode=0, sclk=pin13, mosi=pin15, miso=pin14): + """ Initialize SPI communication with the specified parameters on the specified pins. + Note that for correct communication, the parameters have to be the same on both + communicating devices. + + The baudrate defines the speed of communication. + + The bits defines the size of bytes being transmitted. Currently only bits=8 is + supported. However, this may change in the future. + + The mode determines the combination of clock polarity and phase according to the + following convention, with polarity as the high order bit and phase as the low + order bit: + SPI Mode Polarity (CPOL) Phase (CPHA) + 0 0 0 + 1 0 1 + 2 1 0 + 3 1 1 + + Polarity (aka CPOL) 0 means that the clock is at logic value 0 when idle and goes high + (logic value 1) when active; polarity 1 means the clock is at logic value 1 when idle + and goes low (logic value 0) when active. Phase (aka CPHA) 0 means that data is sampled + on the leading edge of the clock, and 1 means on the trailing edge + (viz. https://en.wikipedia.org/wiki/Signal_edge). + + The sclk, mosi and miso arguments specify the pins to use for each type of signal. """ + pass +def read(nbytes): + """ Read at most nbytes. Returns what was read. """ + pass + +def write(buffer): + """ Write the buffer of bytes to the bus. """ + pass + +def write_readinto(Out, In): + """ Write the out buffer to the bus and read any response into the in buffer. + The length of the buffers should be the same. The buffers can be the same object. """ + pass \ No newline at end of file diff --git a/microbit/uart.py b/microbit/uart.py new file mode 100644 index 0000000..9ec326d --- /dev/null +++ b/microbit/uart.py @@ -0,0 +1,18 @@ +#UART + +""" The uart module lets you talk to a device connected to your board +using a serial interface. + +Warning + Initializing the UART on external pins will cause the Python console on USB to become + unaccessible, as it uses the same hardware. To bring the console back you must + reinitialize the UART without passing anything for tx or rx (or passing None to these + arguments). This means that calling uart.init(115200) is enough to restore the Python + console.""" + +#Functions + +def init(baudrate=9600, bits=8, parity=None, stop=1, *, tx=None, rx=None): + """ Initialize serial communication with the specified parameters on the specified + tx and rx pins. Note that for correct communication, the parameters have to be + the same on both communicating devices. """ \ No newline at end of file