def shat():
sense = SenseHat()
sense.clear()
g = (0, 255, 0)
k = (0, 0, 0,)
r = (255, 0, 0,)
y = (255, 255, 0,)
draw_pixels = [
g, g, g, g, g, g, g, g,
g, g, g, g, g, g, g, g,
g, k, k, g, g, k, k, g,
g, k, k, g, g, k, k, g,
g, g, g, k, k, g, g, g,
g, g, k, k, k, k, g, g,
g, g, k, k, k, k, g, g,
g, g, k, g, g, k, g, g,
]
sense.set_pixels(draw_pixels)
r = (255, 0, 0) #red
g = (0, 255, 0) #green
b = (0, 0, 255) #blue
k = (0, 0, 0) #blank (black)
w = (255, 255, 255) #white
c = (0, 255, 255) #cyan
y = (255, 255, 0) #yellow
o = (255, 128, 0) #orange
n = (255, 128, 128) #pink
p = (128, 0, 128) #purple
d = (255, 0, 128) #darkPink
l = (128, 255, 128) #lightGreen
open_eyes = [
k, k, d, d, d, d, k, k, k, d, d, w, d, w, d, k, d, d, d, k, d, k, d, d, d,
d, r, d, d, d, r, d, p, p, d, d, k, d, d, p, k, r, r, d, d, d, p, k, r, r,
r, r, p, p, p, p, k, k, k, k, k, k, k, k
]
closed_eyes = [
k, k, d, d, d, d, k, k, k, d, d, d, d, d, d, k, d, d, d, d, d, d, d, d, d,
d, r, d, d, d, r, d, p, p, d, d, k, d, d, p, k, r, r, d, d, d, p, k, r, r,
r, r, p, p, p, p, k, k, k, k, k, k, k, k
]
sense.set_pixels(open_eyes)
#Create animation below
print('Done')
ip_servidor = sys.argv[1] # Recebendo ip que o servidor ira operar
porta_servidor = int(
sys.argv[2]) # Recebendo a porta do servidor irá operar
servidor = CoAPServer(
ip_servidor, porta_servidor
) # iniciando o servidor no ip e porta informados como parâmetro
rgb_vermelho = (255, 0, 0) # Setando o rgb da cor vermelha
# Iniciando threads para possibilitar que os clientes sejam ouvidos
# e o senseHat seja usado simultaneamente
thread = Thread(target=ouvir_clientes, args=(servidor, ))
thread.setDaemon(True)
thread.start()
while True:
# Capturando informações de pressão e temperatura informados no sensor
pressao_atual = sensor.get_pressure()
temperatura_atual = sensor.get_temperature()
print("Limite de temperatura " + str(servidor.limtemperatura))
print("Limite de pressao " + str(servidor.limpressao))
# Teste para acender ou apagar os leds
if temperatura_atual > servidor.limtemperatura and pressao_atual > servidor.limpressao:
# Acende o led na cor vermelha
pixels = [rgb_vermelho for i in range(64)
] # Configurando a cor vermelha para cada um dos 64 leds
sensor.set_pixels(pixels)
else:
# Apagando os leds
sensor.clear()
# Author : Nikunj Parmar
from sense_emu import SenseHat
red, blue = (255, 0, 0), (0, 0, 255)
sense = SenseHat()
while True:
temp = sense.temp
pixels = [red if i < temp else blue for i in range(64)]
sense.set_pixels(pixels)
anim2left = [
r, r, r, r, y, r, r, r,
y, r, r, y, r, r, r, r,
r, y, r, r, y, r, y, r,
y, b, b, y, y, r, r, r,
b, b, b, b, y, y, r, r,
y, b, b, y, y, r, y, r,
y, y, r, y, y, r, r, r,
r, r, y, r, r, r, r, r
]
anim3left = [
r, r, r, r, y, r, r, r,
y, r, y, y, r, y, r, r,
r, y, r, r, y, r, y, r,
y, b, b, y, y, r, y, r,
b, b, b, b, y, y, r, y,
y, b, b, y, y, r, y, r,
y, r, r, y, y, y, r, y,
r, y, y, r, r, r, r, r
]
# Display these colours on the LED matrix
while True:
sense.set_pixels(anim1left)
time.sleep(sleep)
sense.set_pixels(anim2left)
time.sleep(sleep)
sense.set_pixels(anim3left)
time.sleep(sleep)
sense.show_message("Keep the arrow pointing up",
scroll_speed=0.05,
text_colour=[100, 100, 100])
# WHILE play == True
while play:
# CHOOSE a new random angle
last_angle = angle
while angle == last_angle:
angle = choice([0, 90, 180, 270])
sense.set_rotation(angle)
# DISPLAY the white arrow
sense.set_pixels(arrow)
# SLEEP for current pause length
sleep(pause)
acceleration = sense.get_accelerometer_raw()
x = acceleration['x']
y = acceleration['y']
z = acceleration['z']
x = round(x, 0)
y = round(y, 0)
print(angle)
print(x)
print(y)
import time
from PIL import Image
import os
# Open image file
image_file = os.path.join(os.sep, "/home", "pi", "GlosLibCodeClub", "Coders",
"Martha", "example1.png")
img = Image.open(image_file)
# generate rbg values for image pixels
rbg_img = img.convert('RGB')
image_pixels = list(rbg_img.getdata())
# Get the 64 Pixels you need
pixel_width = 1
image_width = pixel_width * 8
sense_pixels = []
start_pixel = 0
while start_pixel < (image_width * 64):
sense_pixels.extend(image_pixels[start_pixel:(start_pixel +
image_width):pixel_width])
start_pixel += (image_width * pixel_width)
# Display the image
sense = SenseHat()
sense.set_rotation(r=180)
sense.set_pixels(sense_pixels)
time.sleep(30)
sense.clear()
G,
G,
G,
G,
G,
G,
G,
G,
G,
G,
G,
G,
]
while 1:
temp = sense.get_temperature()
humidity = sense.get_humidity()
print(temp)
print(humidity)
if temp > 20 and humidity > 80:
sense.set_pixels(RAINBOW)
continue
elif (temp > 20 and temp < 25) and (humidity > 60 and humidity < 80):
sense.set_pixels(RAIN)
continue
elif (temp > 30 and temp < 50) and (humidity > 40 and humidity < 60):
sense.set_pixels(SUNSHINE)
continue
else:
sense.set_pixels(SNOW)
continue
sense.clear()
sense.clear()
sense.show_message("Bonjour de Alice et Charles!",
text_colour=y,
back_colour=r,
scroll_speed=0.05)
temperature = round(sense.get_temperature(), 1)
message = "Temperature is " + str(temperature) + " C and "
sense.show_message(message, text_colour=o, back_colour=b, scroll_speed=0.05)
humidity = round(sense.get_humidity(), 1)
message = "humidity is " + str(humidity) + "%"
sense.show_message(message, text_colour=y, back_colour=b, scroll_speed=0.05)
time.sleep(1)
smiley = [
e, e, e, e, e, e, e, e, e, b, b, e, b, b, e, e, e, b, b, e, b, b, e, e, e,
e, e, p, e, e, e, e, e, p, e, p, e, p, e, e, e, p, e, e, e, p, e, e, e, e,
p, p, p, e, e, e, e, e, e, e, e, e, e, e
]
sense.set_pixels(smiley)
time.sleep(1)
rainbow_hearts()
time.sleep(1)
sense.set_pixel(4, 6, (255, 0, 0))
sense.set_pixel(5, 5, (255, 0, 0))
sleep(3)
sense.clear()
sleep(1)
g = (0, 255, 0)
b = (0, 0, 0)
creeper_pixels = [
g, g, g, g, g, g, g, g, g, g, g, g, g, g, g, g, g, g, g, g, g, b, b, g, g,
g, g, g, g, b, b, g, g, g, g, b, b, g, g, g, g, g, b, b, b, b, g, g, g, g,
b, b, b, b, g, g, g, g, b, g, g, b, g, g
]
sense.set_pixels(creeper_pixels)
while True:
sleep(1)
#sense.flip_h()
sense.set_rotation(90)
sleep(1)
#sense.flip_h()
sense.set_rotation(180)
sleep(1)
#sense.flip_h()
sense.set_rotation(270)
sleep(1)
#sense.flip_h()
sense.set_rotation(0)
# create a SenseHat object
sense = SenseHat()
# print out the temperature, humidity, atmospheric pressure,
# and raw accelerometer from the SenseHat emulated sensors
print('The temperature is ',sense.get_temperature(),'degrees Celsius')
print('The humidity is ',sense.get_humidity(),'%')
print('The atmospheric pressure is ',sense.get_pressure(),'millibars')
print('The raw accelerometer data is ',sense.get_accelerometer_raw())
sense.show_message('Marques',scroll_speed=0.1, text_colour=[255,69,0])
w = (200, 200, 200) # the color white
p = (102, 0, 153) # the color purple
letter = [
w, w, w, w, w, w, w, w,
w, p, p, p, p, p, w, w,
w, p, w, w, w, w, p, w,
w, p, w, w, w, w, p, w,
w, p, p, p, p, p, w, w,
w, p, w, w, p, w, w, w,
w, p, w, w, w, p, w, w,
w, p, w, w, w, w, p, w
]
sense.set_pixels(letter)
time.sleep(5.0)
else:
return 0
white_arrow = generate_arrow(white, black)
green_arrow = generate_arrow(green, black)
red_arrow = generate_arrow(red, black)
pause = 3
score = 0
angle = 0
play = True
while play == True:
angle = choice(rotations)
sense.set_rotation(angle)
sense.set_pixels(white_arrow)
sleep(pause)
if check_orientation == angle:
score = score + 1
sense.set_pixels(green_arrow)
else:
sense.set_pixels(red_arrow)
play = False
pause = pause * 0.97
sleep(1)
gameover = "Game over, score {}".format(score)
from sense_emu import SenseHat
sense = SenseHat()
r = [255, 0, 0]
y = [240, 230, 5]
b = [0, 0, 255]
flag_ro = [
r, r, r, y, y, b, b, b, r, r, r, y, y, b, b, b, r, r, r, y, y, b, b, b, r,
r, r, y, y, b, b, b, r, r, r, y, y, b, b, b, r, r, r, y, y, b, b, b, r, r,
r, y, y, b, b, b, r, r, r, y, y, b, b, b
]
sense.set_pixels(flag_ro)
hot = [
b, b, b, b, b, y, y, b,
b, b, b, b, y, y, y, y,
b, b, b, b, b, y, y, b,
b, b, b, b, b, b, b, b,
b, b, b, b, b, b, b, b,
b, b, b, b, b, b, b, b,
g, g, g, g, g, g, g, g,
g, g, g, g, g, g, g, g
]
cold = [
b, b, w, b, b, b, w, b,
b, b, b, b, b, w, b, b,
b, w, b, b, b, b, b, w,
b, b, b, b, w, b, b, b,
w, b, b, w, b, b, w, b,
b, b, b, b, b, b, b, b,
w, w, w, w, w, w, w, w,
w, w, w, w, w, w, w, w
]
sense.set_pixels(picture)
sleep(2)
temp = sense.get_temperature()
temp = round( sense.get_temperature(), 1 )
sense.show_message( "Temp is " + str(temp) + "C", text_colour=g, back_colour=w)
temp = sense.get_temperature()
if temp >= 20:
sense.set_pixels(hot)
else:
sense.set_pixels(cold)
from sense_emu import SenseHat
sense = SenseHat()
r = [255, 0, 0]
o = [255, 127, 0]
y = [255, 255, 0]
g = [0, 255, 0]
b = [0, 0, 255]
i = [75, 0, 130]
v = [159, 0, 255]
e = [0, 0, 0]
image = [
e, e, e, e, e, e, e, e, e, e, e, r, r, e, e, e, e, r, r, o, o, r, r, e, r,
o, o, y, y, o, o, r, o, y, y, g, g, y, y, o, y, g, g, b, b, g, g, y, b, b,
b, i, i, b, b, b, b, i, i, v, v, i, i, b
]
sense.set_pixels(image)
O, O, B, O, O, O, O, O,
O, O, B, O, B, B, O, O,
O, O, B, O, O, B, O, O,
O, O, B, O, O, B, O, O,
O, O, B, B, B, B, O, O,
]
return logo
images = [d,g]
count = 0
while True:
if keyboard.press('up arrow'):
s.set_pixels(images[count % len(images)]())
time.sleep(1)
elif keyboard.press('down arrow'):
s.set_pixels(images[count % len(images)]())
time.sleep(1)
elif keyboard.press('left arrow'):
s.set_pixels(images[count % len(images)]())
time.sleep(1)
elif keyboard.press('right arrow'):
s.set_pixels(images[count % len(images)]())
time.sleep(1)
else:
print('waiting')
time.sleep(1)
count += 1
y = -1
if z < -0.9:
z = -1
if x > 0.9:
x = 1
if y > 0.9:
y = 1
if z > 0.9:
z = 1
print(str(x)+" "+str(y)+" "+str(z))
printMode()
# Tryb do przełączania trybów
if(mode == switchMode):
img = Image(black)
hat.set_pixels(img.getData())
hat.show_letter(modeLetters[newMode],back_colour=red)
applyRotate(rot=rotate)
# Temperatura - wyświetla 2 cyfry na czerwono lub niebiesko
# zależnie od tego czy temperatura jest ujemna lub dodatnia.
# Jeśli wartość absolutna temperatury jest przynajmniej równa 100
# to zamiast jednej liczby jest wyświetlany znak większości
elif(mode == temperatureMode):
digit_a_color = black
digit_b_color = black
t = int(hat.get_temperature())
if t < 0:
digit_a_color = blue
digit_b_color = blue_dark
else:
digit_a_color = red
from sense_emu import SenseHat
from time import sleep
sense = SenseHat()
y = [255, 255, 255]
e = [0, 0, 0]
O = [0, 0, 255]
A = 0
B = 0
path = [
y, y, y, e, e, e, e, e, e, e, y, e, e, e, e, e, e, e, y, e, e, e, e, e, e,
e, y, y, y, y, y, e, e, e, e, e, e, e, y, e, e, e, e, e, e, e, y, e, e, e,
e, e, y, y, y, e, e, e, e, e, y, e, e, e
]
while 1:
sense.set_pixels(path)
sense.set_pixel(A, B, O)
pitch = sense.get_orientation()['pitch']
roll = sense.get_orientation()['roll']
print('Pitch:', pitch)
print('Roll:', roll)
if 270 < pitch < 315 and A < 7:
A += 1
if 45 < pitch < 90 and A > 0:
A -= 1
if 45 < roll < 90 and B < 7:
B += 1
if 270 < roll < 315 and B > 0:
B -= 1
current = sense.get_pixel(A, B)
if current == e:
A = 0
x1, y1 = origin
x2 = x1 + width
y2 = y1 + height
# Invert the Y-coords so we're drawing bottom up
max_y, max_x = screen.shape[:2]
y1, y2 = max_y - y2, max_y - y1
# Draw the bar
screen[y1:y2, x1:x2, :] = color
sh = SenseHat()
while True:
# Decide each sensor range
temperature_range = (0, 40)
pressure_range = (950, 1050)
humidity_range = (0, 100)
# Get each sensor value and change LED scale
temperature = get_scale(sh.temperature, *temperature_range)
pressure = get_scale(sh.pressure, *pressure_range)
humidity = get_scale(sh.humidity, *humidity_range)
# make screen buffer LED Matrix 8(Height) * 8(Width) * 3(Color)
screen = np.zeros((8, 8, 3), dtype=np.uint8)
# Draw Bar to screen (3 position(0, 0), (3, 0), (6, 0))
draw_bar(screen, (0, 0), 2, round(temperature), color=(255, 0, 0))
draw_bar(screen, (3, 0), 2, round(pressure), color=(0, 255, 0))
draw_bar(screen, (6, 0), 2, round(humidity), color=(0, 0, 255))
# Set screen to LED
sh.set_pixels([pixel for row in screen for pixel in row])
sleep(1)
b,
o,
o,
o,
o,
o,
o,
]
return logo
letters = [letter_r(), letter_f()]
s.clear() # clear the screen
count = 0 # keep track of what letter to show next
while True:
for event in s.stick.get_events():
# Check if the joystick was pressed
if event.action == "pressed":
s.set_pixels(letters[count % len(letters)])
# increment count
count += 1
"""
change letters to TA
only change every second time you change button
"""
sad = [
e,e,e,e,e,e,e,e,
e,e,e,e,e,e,e,e,
e,e,r,e,e,r,e,e,
e,e,e,e,e,e,e,e,
e,e,e,e,e,e,e,e,
e,e,r,r,r,r,e,e,
e,r,e,e,e,e,r,e,
e,e,e,e,e,e,e,e
]
neutral = [
e,e,e,e,e,e,e,e,
e,e,e,e,e,e,e,e,
e,e,w,e,e,w,e,e,
e,e,e,e,e,e,e,e,
e,e,e,e,e,e,e,e,
e,e,w,w,w,w,e,e,
e,e,e,e,e,e,e,e,
e,e,e,e,e,e,e,e
]
sentiment = sentiment_analysis.collectSentiment()
if(sentiment > 0.1):
sense.set_pixels(smile)
if(sentiment < -0.1):
sense.set_pixels(sad)
else:
sense.set_pixels(neutral)
class Game:
def __init__(self):
self.sense = SenseHat()
self.sense.low_light = True
self.intro_msg()
self.grid = Grid(colors["white"])
self.sense.set_pixels(self.grid)
self.cursor = Cursor(colors["pink"])
self.tiles = [GameTile(i) for i in range(9)]
self.players = [Player(colors["blue"]), Player(colors["red"])]
@property
def current_player(self):
nb = self.turn % 2
return self.players[nb]
@property
def other_player(self):
nb = self.turn % 2
return self.players[nb ^ 1]
@property
def turn(self):
nb_used_tiles = len(self.players[0].tiles) + len(self.players[1].tiles)
return nb_used_tiles
def refresh(self):
for tile in self.tiles:
self._draw_tile(tile)
def _draw_tile(self, tile):
for led in tile.coords:
self.sense.set_pixel(led[0], led[1], tile.color)
def play(self, socket):
self.cursor.place(4)
self._draw_tile(self.cursor)
while True:
event = self.sense.stick.wait_for_event()
if event.action == "pressed":
if not event.direction == "middle":
self.cursor.move(event.direction)
self.refresh()
self._draw_tile(self.cursor)
else:
selected_tile = self.tiles[self.cursor.nb]
if selected_tile.color == colors["blank"]:
self.current_player.play(
selected_tile) # the turn is incremented here
if self.turn > 3:
if self.other_player.has_win():
socket.sendall(bytes([9]))
self.win_msg()
return True
socket.sendall(bytes([self.cursor.nb]))
self.refresh()
return False
def wait_for_play(self, socket):
while True:
data = socket.recv(1024)
if data:
tile_nb = int.from_bytes(data, "little")
if tile_nb == 9:
self.loose_msg()
return True
else:
self.current_player.play(self.tiles[tile_nb])
self.refresh()
return False
def intro_msg(self):
self.sense.show_message(
"Welcome to pitactoe!!",
text_colour=colors["white"],
scroll_speed=SCROLL_SPEED,
)
def draw_msg(self):
self.sense.show_message("Draw!",
text_colour=colors["white"],
scroll_speed=SCROLL_SPEED)
def win_msg(self):
self.sense.show_message("You win!",
text_colour=colors["white"],
scroll_speed=SCROLL_SPEED)
def loose_msg(self):
self.sense.show_message("You loose!",
text_colour=colors["white"],
scroll_speed=SCROLL_SPEED)
r = (255, 0, 0)
g = (0, 255, 0)
b = (0, 0, 255)
k = (0, 0, 0)
w = (255, 255, 255)
c = (0, 255, 255)
y = (255, 255, 0)
o = (255, 128, 0)
n = (255, 128, 128)
p = (128, 0, 128)
d = (255, 0, 128)
l = (128, 255, 128)
#define another color. Use one letter variable names to make it easy later
raspimon = [
k, k, k, k, k, k, k, k, k, r, r, r, r, r, r, k, k, r, k, k, k, k, r, k, k,
r, r, k, r, k, r, k, k, r, k, k, k, k, r, k, k, r, r, r, r, r, r, k, k, k,
r, k, r, k, k, k, k, k, r, k, r, k, k, k
]
rmon1 = [
c, c, c, c, c, c, c, c, c, c, n, n, n, n, c, c, c, n, n, n, n, n, n, c, c,
n, n, k, n, k, n, c, n, n, n, b, n, b, n, n, n, n, d, n, n, n, d, n, c, n,
n, n, n, n, n, c, g, n, n, g, g, n, n, g
]
sense.set_pixels(rmon1)
#add a one-pixel mouth
from sense_emu import SenseHat
sense = SenseHat()
while True:
temp = sense.get_temperature()
if temp >= 20:
sense.set_pixels([(255,0 ,0) for i in range(64)])
else:
sense.set_pixels([(0,0,255) for i in range(64)])
P,
O,
O,
O,
O,
O,
O,
P,
O,
O,
O,
O,
O,
O,
O,
O,
O,
O,
O,
O,
]
return logo
while True:
s.set_pixels(raspi_logo()) #images[count % len(images)]())
time.sleep(0.75)
s.set_pixels(raspi_logo_random())
time.sleep(0.75)
#count += 1
@app.route('/allmessages')
def allmessages():
# connect to db
conn = sqlite3.connect('./static/data/collectedmessages.db')
curs = conn.cursor()
message = []
rows = curs.execute("SELECT * from messages")
for row in rows:
message = {'message': row[0]}
messages.append(message)
conn.close()
return render_template('allmessages.html', messages=messages)
heart = [
w, r, r, w, w, r, r, w, r, o, o, r, r, o, o, r, r, o, y, o, o, y, o, r, r,
o, y, y, y, y, o, r, w, r, o, y, y, o, r, w, w, r, o, y, y, o, r, w, w, w,
r, o, o, r, w, w, w, w, w, r, r, w, w, w
]
# mario = [
# w, w, r, r, r, r, w, w,
# w, r, r, r, r, r, r, w,
# w, c, c, y, y, k, w, w,
# c, y, c,
# ]
sense.set_pixels(heart)
if __name__ == '__main__':
app.run(debug=True, host='0.0.0.0')
class LightMatrix:
def __init__(self):
self.hat = SenseHat()
self.dim = 8
self.arr = np.array([
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
E,
]).reshape(8, 8, -1)
def show(self):
arr_list = self.arr.reshape(64, -1).tolist()
self.hat.set_pixels(arr_list)
def set_row(self, row_num, color):
for i in range(self.dim):
self.arr[row_num][i] = color
print(self.arr)
k,
k,
k,
g,
g,
g,
g,
k,
g,
g,
k,
g,
g,
]
sense.set_pixels(draw_pixels)
if sel == "T":
import turtle
t = turtle.Turtle()
for i in range(10):
for i in range(2):
t.forward(100)
t.right(90)
t.forward(100)
t.right(90)
t.right(32)
if sel == "S":
print("SHELL")
if sel == "GUI":
import pygame
from pygame.locals import *
0.73,
0.80,
0.87,
0.45,
0.52,
0.60,
0.67,
0.74,
0.81,
0.88,
0.95,
]
hat = SenseHat()
def scale(v):
return int(v * 255)
while True:
# Rotate the hues
hues = [(h + 0.01) % 1.0 for h in hues]
# Convert the hues to RGB values
pixels = [hsv_to_rgb(h, 1.0, 1.0) for h in hues]
# hsv_to_rgb returns 0..1 floats; convert to ints in the range 0..255
pixels = [(scale(r), scale(g), scale(b)) for r, g, b in pixels]
# Update the display
hat.set_pixels(pixels)
sleep(0.04)
#!/usr/bin/python
import json
from sense_emu import SenseHat
sense = SenseHat()
duty = []
filename = "led_display.json"
def getRGBfromI(RGBint):
blue = RGBint & 255
green = (RGBint >> 8) & 255
red = (RGBint >> 16) & 255
return red, green, blue
if filename:
with open(filename, 'r') as f:
ledDisplayArray = json.load(f)
def draw():
for x in ledDisplayArray:
duty.append(getRGBfromI(x))
return duty
sense.set_pixels(draw())
