505 lines
16 KiB
Python
505 lines
16 KiB
Python
# 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 |