def fade(time):
for x in range(0, 5):
for y in range(0, 5):
b = display.get_pixel(x, y)
if b > 0:
display.set_pixel(x, y, b - 1)
sleep(time)
def RadioReceived(text):
global ball
global prevBallMove
global lookingForGame
print("Received: " + text)
if(not gameStarted and lookingForGame):
if(text == "s"):
ball = Ball(random.randint(0, 4), 0, random.choice([-1, 1]), 1)
StartCountdown()
elif(text == "q"):
radio.send("s")
ball = None
StartCountdown()
else:
if(text == "w"):
EndScreen(True)
elif(text == "l"):
EndScreen(False)
elif(text == "p"):
AddPoint()
ball = Ball(random.randint(0, 4), 0, random.choice([-1, 1]), 1)
display.set_pixel(ball.x, ball.y, 9)
CheckBounce()
prevBallMove = time.ticks_ms()
else:
args = text.split(",")
if(len(args) == 2):
ball = Ball(int(args[0]), 0, int(args[1]), 1)
display.set_pixel(ball.x, ball.y, 9)
CheckBounce()
prevBallMove = time.ticks_ms()
def fade_display(fade=-3):
"""Loop over every pixel and reduce the brightness by the fade value."""
for x in range(0, 5):
for y in range(0, 5):
current = display.get_pixel(x, y)
faded = max(0, current + fade)
display.set_pixel(x, y, faded)
def scan(level, pause=500):
# Mark reverse as global so we can update it from this method
global reverse
# Loop through the various rows of our square. As we're going diagonally we need to loop
# 9 times.
for i in range(0, 5):
# Start looping over the pixel grid
for x in range(0, 5):
# if we press a button reverse the direction
if button_a.is_pressed() or button_b.is_pressed():
reverse = False if reverse else True
for y in range(0, i + 1):
# If the pixel we're trying to set wouldn't be on the grid
# then don't try and set it
if x <= MAX_ROWS and y <= MAX_ROWS:
x_coord = MAX_ROWS - x if reverse else x
y_coord = MAX_ROWS - y if reverse else y
display.set_pixel(x_coord, y_coord, level)
i += 1
sleep(pause)
def show(present):
for x in range(5):
for y in range(5):
if present[x][y] == 1:
display.set_pixel(x, y, 9)
else:
display.set_pixel(x, y, 0)
def plotBarGraph(value, max_value, b=9):
order = (
23,
21,
20,
22,
24,
18,
16,
15,
17,
19,
13,
11,
10,
12,
14,
8,
6,
5,
7,
9,
3,
1,
0,
2,
4,
)
counter = 0
display.clear()
for y in range(5):
for x in range(5):
if value / max_value > order[counter] / 25:
display.set_pixel(x, y, b)
counter += 1
def count_down(delay):
"""Count down and show progress"""
on_image = Image('99999:99999:99999:99999:99999')
display.show(on_image)
for y_coord in range(5):
for x_coord in range(5):
wait = delay
while wait >= 300:
sleep(300)
wait -= 300
if abandon_talk() is True:
return
# Flash the last row, so making it clear that
# the talk is coming to an end
if y_coord == 4:
for i in range(x_coord, 5):
brightness = display.get_pixel(i, y_coord)
if brightness == 0:
brightness = 9
else:
brightness = 0
display.set_pixel(i, y_coord, brightness)
sleep(wait)
display.set_pixel(x_coord, y_coord, 0)
start_up_screen()
return
def main():
data_sent = 0
state = GET_DATA_NUM
while True:
# State 0
if state == GET_DATA_NUM:
data_num = 1
attempt = 0
while True:
cy, cx = divmod(data_num-1, 5) # Cursor x and y depending on the data_num
display.set_pixel(cx, cy, 9)
if button_a.is_pressed() and button_b.is_pressed():
state = READY_TO_SAMPLE # TODO: Change state to some other state
data_sent = 0
sleep(500)
break
elif button_a.is_pressed():
if data_num > 1:
display.set_pixel(cx, cy, 0) # Clear LED pixel if data_num > 1
data_num = data_num - 1 if (data_num > 1) else 1
elif button_b.is_pressed():
data_num = data_num + 1 if (data_num < MAX_FILES_NUM) else MAX_FILES_NUM
sleep(200)
# State 1
elif state == READY_TO_SAMPLE:
while True:
if button_a.is_pressed():
state = SAMPLE_DATA
break
elif button_b.is_pressed():
display.clear()
cy, cx = divmod(data_num-data_sent-1, 5)
setPixelTill(cx, cy, 9)
else:
display.show(Image.ARROW_W)
sleep(200)
# State 2
elif state == SAMPLE_DATA:
countdown(3)
display.show(Image.TARGET)
with open("file_{}.csv".format(data_sent), "w") as data_file:
data_file.write("x,y,z\n")
initial_time = running_time()
while (running_time()-initial_time) < SAMPLE_DURATION:
t0 = running_time()
data_file.write("{},{},{}\n".format(*accelerometer.get_values()))
t_diff = running_time()-t0
sleep(0 if (SAMPLE_PERIOD-t_diff)<0 else SAMPLE_PERIOD-t_diff)
data_sent += 1
if (data_num-data_sent)>0:
state = READY_TO_SAMPLE
else:
state = EXIT
# State 3
elif state == EXIT:
display.show(Image.HAPPY)
break
def update(self):
# Move enemy down screen
display.set_pixel(self.x, self.y, 0)
self.y = self.y + 1
# Move back to top once off the bottom
# TODO we should have a delay here
if self.y >= 5:
self.x = randint(1, 3)
self.y = 0
display.set_pixel(self.x, self.y, 9)
def imp_lista(lista: list, isDificil: bool) -> None:
display.clear()
if isDificil:
fator = 6
else:
fator = 1.5
for y, x in enumerate(lista):
if (0 <= x < 5 and 0 <= y < 5):
display.set_pixel(x, y, 9 - int(y * fator))
def dataWrite(db=databyte, ledrow=3):
#global databyte
p = 0
bright = 6 + ledrow
for y in range(ledrow, ledrow + 2):
for x in range(1, 5):
if db[p] == "1":
display.set_pixel(x, y, bright)
else:
display.set_pixel(x, y, 0)
p = p + 1
def draw(self, board):
for i in range(len(board)):
for j in range(len(board[i])):
if board[i][j] == 1:
setting = 9
elif board[i][j] == 2:
setting = 4
else:
setting = 0
display.set_pixel(i, j, setting)
def update(self):
# Clear old pixel
# TODO we don't need to clear if no button is pressed
display.set_pixel(self.x, self.y, 0)
# Move left or right
if button_a.is_pressed() and self.x > 1:
self.x = self.x - 1
if button_b.is_pressed() and self.x < 3:
self.x = self.x + 1
# Redraw
display.set_pixel(self.x, self.y, 9)
def bar_chart(value, columns=(0, 1, 2, 3, 4), *, max_value=100):
"""Draw a vertical bar chart based on percentage value
using variable brightness levels on display."""
### Nine brightness levels on 5x5 LED matrix equates
### to 45 pixel steps - start at bottow row (no 4) and
### light pixels until value px_steps value is reached
px_steps = round(value * 45 / max_value)
for y in range(4, -1, -1):
for x in columns:
### The min/max here limit values from 0 to 9
display.set_pixel(x, y, min(MAX_BRIGHTNESS, max(0, px_steps)))
px_steps -= MAX_BRIGHTNESS
def setPixelTill(cx, cy, value=9):
"""
Sets all pixel from (0, 0) till the given (x, y) coordinate to given value
@param cx : X-coordiante of the final pixel
@param cy : Y-coordinate of the final pixel
@param value : Value to set for the pixels
@returns : Nothing
"""
for y in range(5):
for x in range(5):
display.set_pixel(x, y, value)
if x==cx and y==cy:
return
def startGame(self):
self.score = 0
self.endGame = False
display.clear()
X = [2, 2, 2, 2, 3, 4, 4, 4, 3, 1, 0, 0, 0, 1]
Y = [0, 1, 2, 4, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4]
for i in range(4):
display.set_pixel(X[i], Y[i], 9)
sleep(200)
for i in range(4, 14):
display.set_pixel(X[i], Y[i], 9)
sleep(50)
sleep(1000)
display.clear()
def update_display():
global kills
if DEAD:
display.show(Image.SAD)
return
display.set_pixel(IDENTITY[0], IDENTITY[1], 9)
new_kills = set()
for x, y, val in kills:
display.set_pixel(x, y, val)
if val > 0:
new_kills.add((x, y, val - 1))
kills = new_kills
def reset(self):
""" Set the lights to a series of dark/light values """
for y in [0, 2, 4]:
display.set_pixel(0, y, 4)
display.set_pixel(4, y, 4)
for y in [1, 3]:
display.set_pixel(0, y, 1)
display.set_pixel(4, y, 1)
def drawExplosion(self, brightness, radius):
x = self.properties[0]
y = self.properties[1]
left_of_centre = x - radius
right_of_centre = x + radius
above_centre = y - radius
if left_of_centre >= game.screenMinX:
display.set_pixel(left_of_centre, y, brightness)
display.set_pixel(left_of_centre, above_centre, brightness)
display.set_pixel(x, above_centre, brightness)
if right_of_centre <= game.screenMaxX:
display.set_pixel(right_of_centre, y, brightness)
display.set_pixel(right_of_centre, above_centre, brightness)
def swish(direction):
ostart = 0 if direction == RIGHT else 5
oend = 9 if direction == RIGHT else -5
step = 1 if direction == RIGHT else -1
istart = 1 if direction == RIGHT else 3
iend = 4 if direction == RIGHT else -1
for i in range(ostart, oend, step):
display.clear()
if -1 < i < 5:
display.set_pixel(i, 2, 9)
for j in range(istart, iend, step):
k = i - j * step
brightness = 9 - (2 * j)
if 5 > k >= 0:
display.set_pixel(k, 2, brightness)
sleep(100)
def rccar_rx(cmd):
global px_cur, py_cur
px_cmd = int(cmd / 100)
py_cmd = cmd % 100
px = mymap(px_cmd, 0, 100, 0, 5)
py = mymap(py_cmd, 0, 100, 0, 5)
if px_cur != px or py_cur != py:
di.set_pixel(px_cur, py_cur, 0)
di.set_pixel(px, py, 9)
px_cur = px
py_cur = py
go_value = -(py_cmd - 50) * 2
percent = (px_cmd - 50)
go_value = -mymap(py_cmd, 0, 99, -100, 100)
percent = mymap(px_cmd, 0, 99, -100, 100)
big = max(abs(go_value), abs(percent))
if big > 100:
big = 100
if big <= -100:
big = -100
big_p = big * abs(percent) / 100
if go_value > 0:
if percent > 0:
r = big
l = big - 2 * big_p
else:
l = big
r = big - 2 * big_p
else:
if percent > 0:
r = -big
l = -big + 2 * big_p
else:
l = -big
r = -big + 2 * big_p
#print("x=%i,y=%i,go=%i,lr=%i,l=%i,r=%i" %(px_cmd,py_cmd,go_value,percent,l,r))
move_motor_lr(int(l), int(r))
def leds(part,va):#pixel_debug
if part==1: # tx
va = va *3 % 10
di.set_pixel(4, 4, va)
elif part==2:#master
di.set_pixel(3, 4, va)
else: #3 Rx
return
va = va % 30
for i in range(3):
if va >=9:
di.set_pixel(i, 4, 9)
elif va<0:
di.set_pixel(i, 4, 0)
else:
di.set_pixel(i, 4, va)
va -=10
def main():
sb = ScrollBit()
sd = ScrollDisplay(100)
bd = BitDisplay(7)
while True:
sb.set_pixel(sd.x, sd.y, sd.b)
sb.show()
display.set_pixel(bd.x, bd.y, bd.b)
sd.step()
bd.step()
sleep(200)
sb.clear()
display.clear()
def main():
state = READY
while True:
# Ready state
if state == READY:
while True:
if button_a.is_pressed():
state = SAMPLE_DATA
break
elif button_b.is_pressed():
radio.on()
radio.send("done")
radio.off()
else:
display.show(Image.ARROW_W)
sleep(100)
# Sample Data state
elif state == SAMPLE_DATA:
data_sent = 0 # Reset data sent value
countdown(3) # Show countdown on the Microbit LED
display.show(Image.TARGET)
radio.on()
initial_time = running_time()
while (running_time() - initial_time) < SAMPLE_DURATION:
t0 = running_time()
if data_sent == 0: # Turn off all Microbit LEDs
display.clear()
cx, cy = divmod(
data_sent,
5) # Get current LED pixel coordinate of the BBC Microbit
radio.send(str(accelerometer.get_values()))
display.set_pixel(4 - cx, cy, 9)
data_sent = 0 if data_sent >= 24 else data_sent + 1 # Increase and limit data_sent value within 0-24 range
wait_t = SAMPLE_INTERVAL - (running_time() - t0
) # Time till next sample
if (wait_t > 0):
sleep(wait_t)
radio.send("done")
radio.off()
state = READY
# Exit state
elif state == EXIT:
display.show(Image.HAPPY)
return 0
sleep(100)
def rccar_tx(did):
global px_cur, py_cur
[x, y, z] = accelerometer.get_values()
px = mymap(x, -1000, 1000, 0, 5)
py = mymap(y, -1000, 1000, 0, 5)
#print("(%i,%i,%i,%i,%i)"%(x,y,z,px,py))
if px_cur != px or py_cur != py:
di.set_pixel(px_cur, py_cur, 0)
di.set_pixel(px, py, 9)
px_cur = px
py_cur = py
px_cmd = mymap(x, -1000, 1000, 0, 100)
py_cmd = mymap(y, -1000, 1000, 0, 100)
cmd = px_cmd * 100 + py_cmd
txp(did, 23, str(cmd))
def StartCountdown():
global lookingForGame
global gameStarted
global ball
global points
display.clear()
for i in range(5, -1, -1):
display.show(i)
time.sleep(1)
display.clear()
lookingForGame = False
points = 0
gameStarted = True
prevBallMove = time.ticks_ms()
if(not ball is None):
display.set_pixel(ball.x, ball.y, 9)
CheckBounce()
def check_crash(car, enemy, barrier):
""" Check for a crash between car and enemy """
if (car.x == enemy.x) and (car.y == enemy.y):
# Repeat crazy flashes on crash
for _ in range(5):
for y in range(5):
display.set_pixel(0, y, 9)
display.set_pixel(4, y, 9)
sleep(100)
for y in range(5):
display.set_pixel(0, y, 0)
display.set_pixel(4, y, 0)
sleep(100)
barrier.reset()
def main():
""" entry point to the app """
# loop forever
while True:
# generate a random number to represent the number of leds to show ...
num = random.randint(0, 10)
# clear the display from the previous game ...
display.clear()
# a list to keep track of which leds have been used ...
used = []
# loop 'num' times ...
for i in range(num):
# generate a random number to represent which led to show ...
led = random.randint(0, NUM_LEDS - 1)
# if the led has already been used,
# generate another random number ...
while led in used:
led = random.randint(0, NUM_LEDS - 1)
used.append(led)
# get the coords for the led to show ...
x, y = get_coords(led)
# show the led ...
display.set_pixel(x, y, 9)
# get the answer from the user ...
input_num = get_button_presses()
# if the answer is correct, display WIN otherwise LOSE ...
if num == input_num:
display.scroll("WIN!")
else:
display.scroll("LOSE!")
def main():
""" entry point to the app """
# loop forever
while True:
# generate a random number to represent the number of leds to show ...
num = random.randint(0, 10)
# clear the display from the previous game ...
display.clear()
# a list to keep track of which leds have been used ...
used = []
# loop 'num' times ...
for i in range(num):
# generate a random number to represent which led to show ...
led = random.randint(0, NUM_LEDS-1)
# if the led has already been used,
# generate another random number ...
while led in used:
led = random.randint(0, NUM_LEDS-1)
used.append(led)
# get the coords for the led to show ...
x, y = get_coords(led)
# show the led ...
display.set_pixel(x, y, 9)
# get the answer from the user ...
input_num = get_button_presses()
# if the answer is correct, display WIN otherwise LOSE ...
if num == input_num:
display.scroll("WIN!")
else:
display.scroll("LOSE!")
def logic(self):
display.clear()
p1 = pin1.read_analog()
p2 = pin2.read_analog()
if p1 <= 204:
x = 0
elif 204 < p1 <= 408:
x = 1
elif 408 < p1 <= 612:
x = 2
elif 612 < p1 <= 816:
x = 3
else:
x = 4
if p2 <= 204:
y = 4
elif 204 < p2 <= 408:
y = 3
elif 408 < p2 <= 612:
y = 2
elif 612 < p2 <= 816:
y = 1
else:
y = 0
display.set_pixel(*self.pix)
display.set_pixel(x, y, 9)
if [x, y, 9] == self.pix:
self.pix = None
display.show(Image.HAPPY)
music.play(music.JUMP_UP)
sleep(500)
if self.btn_pressed():
sleep(150)
self.set_random_pix()
def calibrate():
t = running_time()
lastrt = t
prev = 0
calibrated = False
while not calibrated:
r = pin0.read_analog() - 11
r = abs(r) / 900 * 5
r = int(r) if r < 6 else 5
if (r == 5 and prev != 5) or (r == 0 and prev != 0):
t = running_time()
prev = r
if running_time() - t > 3000:
lastrt = running_time()
if r == 0: # No sound for more than 3 seconds
# Turn right
display.show(Image.ARROW_E)
else: # Saturated for more than 3 seconds
# Turn left
display.show(Image.ARROW_W)
else:
for y in range(0, 5):
for x in range(0, 5):
if 4 - y < r:
display.set_pixel(x, y, 5)
else:
display.set_pixel(x, y, 0)
if r > 0:
# If there is sound, leave the leds on for .1 seconds
sleep(100)
if running_time() - lastrt > 5000:
display.show(Image.YES)
sleep(1000)
calibrated = True
display.clear()
return calibrated
def main():
data_received = 0
display.show(Image.HAPPY)
while True:
response = radio.receive()
if response is not None: # Some data received
uart.write(response+"\n") # Write received data with line break on serial bus
if data_received == 0:
display.clear() # Clear Microbit LEDs
if "," in response: # "(x,y,z)" data received
cy, cx = divmod(data_received, 5)
display.set_pixel(cx, cy, 9)
# Increase and limit data_received value within 0-24 range
data_received = 0 if data_received >= 24 else data_received+1
elif response == "done":
data_received = 0
display.show(Image.YES)
elif response == "exit":
display.show(Image.HAPPY)
sleep(2000)
display.clear()
break
else:
sleep(100)
def level():
global row, col
bright = 4
for x in range(1, 5):
display.set_pixel(x, 0, 0)
for y in range(0, 5):
display.set_pixel(0, y, 0)
row = accelerometer.get_x() #pitch 2 row
row = min(max(1,
int(row / 200) + 2),
4) # roll sensitivity row/60=narrow 400=wide + tilt factor
display.set_pixel(row, 0, bright)
col = accelerometer.get_y() # roll 4 bit cols
col = min(
max(3,
int(col / 200) + 2),
4) #pitch sensitivity 200 horizontal 300 more vertical + tilt factor
display.set_pixel(0, col, bright)
def leds(part, va): #pixel_debug
va = va % 10
if part == 1: # tx
va = va * 3 % 10
di.set_pixel(4, 4, va)
elif part == 0: # rxc
di.set_pixel(0, 4, va)
elif part == 2: #master
di.set_pixel(3, 4, va)
else: #3 Rx
pass
def display_minutes(minutes):
"""Show minutes"""
i = 0
for y_coord in range(5):
for x_coord in range(5):
i += 1
if i <= minutes:
display.set_pixel(x_coord, y_coord, 9)
else:
if x_coord == 0 and y_coord == 0 and minutes < 1:
display.set_pixel(x_coord, y_coord, 4)
else:
display.set_pixel(x_coord, y_coord, 0)
def show_id():
di.clear()
for id in uids:
if id > 0:
uid = id - 1
di.set_pixel(uid % 5, int(uid / 5), 2)
uid = lid - 1
di.set_pixel(uid % 5, int(uid / 5), 5)
id = mid
if id > 0:
uid = id - 1
di.set_pixel(uid % 5, int(uid / 5), 9)
def play(midi, notes):
led = 0
duration = octave = 4
bpm, ticks = music.get_tempo()
mpt = 60000 / bpm / ticks
try:
for note in notes:
try:
note, duration = note.split(':')
duration = int(duration)
except:
pass
try:
octave = int(note[-1])
note = note[:-1]
except (ValueError, IndexError):
pass
note = note.lower()
midinote = NOTES.get(note[0])
if midinote is not None:
if note.endswith('#'):
midinote += 1
elif len(note) > 1 and note.endswith('b'):
midinote -= 1
midinote = max(0, min(127, midinote + 12 * octave))
midi.note_on(midinote, 96)
display.set_pixel(led, 0, 5)
sleep(duration * mpt)
if midinote is not None:
midi.note_off(midinote)
display.set_pixel(led, 0, 0)
led = (led+1) % 5
# make sure led and last note is turned off
if midinote is not None:
display.set_pixel(led, 0, 0)
midi.note_off(midinote)
except:
# Send all sound off to prevent hanging notes
midi.control_change(0x78, 0)
def fade(how_much=1):
for x in range(5):
for y in range(5):
brightness = display.get_pixel(x, y)
if brightness >= how_much:
display.set_pixel(x, y, brightness - how_much)
def draw(self):
# Draw the droplet (with fainter tail)
display.set_pixel(self.x[2], self.y[2], 0)
display.set_pixel(self.x[1], self.y[1], 1)
display.set_pixel(self.x[0], self.y[0], 9)
def set_pixel(x=2, y=2):
"""Set the specified pixel to max brightness and fade everything else."""
fade_display()
return display.set_pixel(x, y, 9)
pause = 100
level = 1
accelerometer_sensitivity = 1 / 300
# set initial position
x, y = 2, 2
yaccel, xaccel = get_xy()
y = max(0, min(4, int(y + yaccel)))
x = max(0, min(4, int(x + xaccel)))
while pause > 0:
yaccel, xaccel = get_xy()
newy = max(0, min(4, int(y + yaccel)))
newx = max(0, min(4, int(x + xaccel)))
if newy != y or newx != x:
display.set_pixel(x, y, 1)
x, y = newx, newy
display.set_pixel(x, y, 9)
else:
display.set_pixel(newx, newy, 9)
pixels = count_lit_pixels()
if pixels == 25:
play(POWER_UP, wait=False)
level += 1
pause -= 5
sleep(200)
display.show(str(level))
sleep(1000)
display.clear()
sleep(pause)
#
# Filename = "mbSimplePong.py"
from microbit import display, Image, accelerometer, sleep, button_a, reset
from random import randint
maxScore = 6 # Change this if you want more rounds / game.
gestureSensitivity = 120
delay = 400
# Set initial position of pong game's "paddle"
padY = 4
padX = 2
# Display initial paddle
display.set_pixel(padX, padY, 9)
# Set initial position of pong game's "ball"
ballX = 0
ballY = 0
# Display initial ball, blink ball 3 times
# to attract the player's attention
for i in range(0, 3):
display.set_pixel(ballX, ballY, 5)
sleep(delay)
display.set_pixel(ballX, ballY, 0)
sleep(delay)
ballX = randint(0, 4) # Randomly select column to serve ball in.
display.set_pixel(ballX, ballY, 5)
def fade():
for x in range(5):
for y in range(5):
brightness = display.get_pixel(x, y)
if brightness > 0:
display.set_pixel(x, y, brightness - 1)
"""
LEDs start at random brightnesses and deltas (either up or down) and bounce
back when brightness goes out of its boundaries.
"""
import random
from microbit import display
[[display.set_pixel(x, y, 4) for y in range(5)] for x in range(4)]
delta = [[random.choice((-1, +1)) for _ in range(5)] for _ in range(5)]
while True:
for x in range(5):
for y in range(5):
brightness = display.get_pixel(x, y)
if ((brightness == 9 and delta[x][y] > 0)
or (brightness == 0 and delta[x][y] < 0)):
delta[x][y] = -delta[x][y]
if random.random() > .5:
brightness += delta[x][y]
display.set_pixel(x, y, brightness)
def swap_led(x, y):
""" Alternate an LED between light and dark """
if display.get_pixel(x, y) == 1:
display.set_pixel(x, y, 4)
else:
display.set_pixel(x, y, 1)
led = (led+1) % 5
# make sure led and last note is turned off
if midinote is not None:
display.set_pixel(led, 0, 0)
midi.note_off(midinote)
except:
# Send all sound off to prevent hanging notes
midi.control_change(0x78, 0)
# wait for button A press before initializing the UART
# to allow uploading of new firmware
while True:
if button_a.is_pressed():
display.set_pixel(0, 0, 0)
break
display.set_pixel(0, 0, 5)
sleep(100)
display.set_pixel(0, 0, 0)
sleep(100)
# Initialize UART for MIDI
uart.init(baudrate=31250)
midi = MidiOut(uart)
tune = program = 0
# send a PROGRAM CHANGE to set instrument to #0 (Grand Piano)
midi.program_change(program)
# set led on first 4 rows of display to indicate current tune (1-20)
def show(self):
# Completely untested, I had to write it blindly :(
display.clear()
for y, row in enumerate(self.rows):
for x, pixel in enumerate(row):
display.set_pixel(x, y, pixel)
(0, 1),
(2, 0),
]
terrain_multiplier = 5
pos = 0
while True:
sleep(100)
if -256 < accelerometer.get_y() < 450:
bird = max(0, bird - 1)
elif 568 < accelerometer.get_y() < 1024:
bird = min(4, bird + 1)
display.clear()
display.set_pixel(0, bird, 9)
pos_terrain = pos // terrain_multiplier
lost_status = False
for column, (top, bottom) in enumerate(
terrain[pos_terrain:pos_terrain + 5]):
for y in range(top):
display.set_pixel(column, y, 4)
if column == 0 and bird == y:
lost_status = True
for y in range(bottom):
display.set_pixel(column, 4 - y, 4)
if column == 0 and bird == (4 - y):
lost_status = True
if lost_status:
display.show(Image.SAD)
return random.randrange(100)
def xy(channel):
x = channel // 20
y = channel // 4 % 5
return x, y
radio.on()
channel = new_channel()
x, y = xy(channel)
radio.config(channel=channel)
while True:
display.set_pixel(x, y, 4)
radio.send('hello, microbit')
display.set_pixel(x, y, 0)
if accelerometer.is_gesture('shake'):
channel = new_channel()
radio.config(channel=channel)
x, y = xy(channel)
if button_a.was_pressed():
channel += 1
radio.config(channel=channel)
if channel > 99:
channel = 0
x, y = xy(channel)
if button_b.was_pressed():
channel -= 1
radio.config(channel=channel)
value >> 7 if lsb else value, ch=ch)
if lsb and control < 20:
self.channel_message(CONTROLLER_CHANGE, control + 32, value, ch=ch)
def program_change(self, program, ch=None):
self.channel_message(PROGRAM_CHANGE, program, ch=ch)
# -----------------------------------------------------------------------------
# Main script
from microbit import button_a, display, sleep
while True:
if button_a.is_pressed():
display.set_pixel(0, 0, 0)
break
display.set_pixel(0, 0, 5)
sleep(100)
display.set_pixel(0, 0, 0)
sleep(100)
# Initialize UART for MIDI
midi = MidiOut()
while True:
# send NOTE ON for middle C (60) at velocity 100
midi.note_on(60, 100)
display.set_pixel(0, 0, 5)
sleep(500)
"""
LEDs start at random brightnesses and go up or down randomly by one level.
"""
import random
from microbit import display
while True:
for x in range(5):
for y in range(5):
brightness = display.get_pixel(x, y)
brightness += random.randrange(-1, 2)
if brightness > 9:
brightness = 9
elif brightness < 0:
brightness = 0
display.set_pixel(x, y, brightness)
"""
Because cool computers have lots of blinking lights (or used to be).
Each LED gets a random brightness.
"""
import random
from microbit import display, sleep
while True:
for x in range(5):
for y in range(5):
display.set_pixel(x, y, random.randrange(0, 10))
sleep(10)
from microbit import button_a, button_b, display, sleep
delay = 20
def fade():
for x in range(5):
for y in range(5):
brightness = display.get_pixel(x, y)
if brightness > 0:
display.set_pixel(x, y, brightness - 1)
while True:
for x in range(5):
for y in range(5):
fade()
if button_a.is_pressed():
delay += 1
elif delay > 0 and button_b.is_pressed():
delay -= 1
display.set_pixel(x, y, 9)
for _ in range(delay):
sleep(1)
