CodingPirates/python-microbit
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Update. /JL

Browse Source
This commit is contained in:
Jan Lerking
2025-04-09 06:23:45 +02:00
parent c7bfcef0a0
commit 91bc7878f2
11 changed files with 923 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

505
microbit/__init__.py Normal file
View File

@@ -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