def main():
sense = SenseHat()
sense.low_light = True
print( "<---- SinusGraph ---->\n" )
pixelStatuses = [ [ 0, 0, 0 ] for i in range( 64 ) ]
for i in range( 150 ):
assert len( pixelStatuses ) == 64
del pixelStatuses[ : 8 ]
pixelStatuses.extend( [ [ 0, 0, 0 ] for i in range( 8 ) ] )
pixelStatuses[ 60 + round( cos( i / 1.5 ) * 3 ) ] = [ 0, 255, 0 ]
pixelStatuses[ 60 + round( sin( i / 2 ) * 3 ) ] = [ 255, 255, 255 ]
sense.set_pixels( pixelStatuses )
pixelStatuses = sense.get_pixels()
print( pixelStatuses )
sleep( 0.096 )
sense.clear()
def main():
sense = SenseHat()
"""
sense.show_message("Hello World!!");
sense.set_rotation(180)
sense.show_message("Hello World!!");
"""
sense.flip_v()
list = sense.get_pixels()
#print list
sense.set_pixel(0,0,255,0,0)
sense.clear()
for i in range(0, 5):
sense.show_letter(str(i))
time.sleep(1)
sense.clear()
def display_cabin_alt():
sampling_interval = astro_display.orbitPosIncrementSeconds
global displaying
displaying = True
sense = SenseHat()
current_pixels = sense.get_pixels()
sense.clear()
p = sense.get_pressure()
a = (1 - (p / 1013.25)**0.190284) * 145366.45
alt = int(round(a))
if alt > 9999:
c = [255, 0, 0]
else:
c = [0, 255, 0]
sense.show_message("Cabin Alt: " + str(alt) + "ft", text_colour=c)
displaying = False
sense.set_pixels(current_pixels)
threading.Timer(sampling_interval, display_cabin_alt).start()
# https://pythonhosted.org/sense-hat/api/#get_pixels
import argparse
from _return import finish
parser = argparse.ArgumentParser(description='Get all 8x8 pixels')
args = parser.parse_args()
try:
from sense_hat import SenseHat
sense = SenseHat()
result = sense.get_pixels()
finish({"result": result})
except Exception, e:
finish(e, 1)
sense.flip_h(True)
if key == "flipV":
if showDebug:
print("[ledMatrixBridge] flip vertical")
sense.flip_v(True)
if key == "setPixels":
if showDebug:
print("[ledMatrixBridge] set pixels from array")
sense.set_pixels(payload["value"])
if key == "getPixels":
if showDebug:
print("[ledMatrixBridge] flip vertical")
print(sense.get_pixels())
if key == "setPixel":
if showDebug:
print("[ledMatrixBridge] set single pixel")
sense.set_pixel(payload["x"], payload["y"], payload["r"],
payload["g"], payload["b"])
if key == "getPixel":
if showDebug:
print("[ledMatrixBridge] get single pixel")
print(sense.get_pixel(payload["x"], payload["y"]))
if key == "loadImage":
if showDebug:
print("[ledMatrixBridge] load image", payload["value"])
display = matrix.tolist()
# Flatten the list one more layer
display = [item for sublist in display for item in sublist]
sense.set_pixels(display)
sense = SenseHat()
height = 8
width = 8
depth = 3
#matrix = np.zeros([height,width,depth],dtype=np.uint8)
# read the current pixels and transform it to a 3d matrix
matrix = np.array(sense.get_pixels(), dtype=np.uint8).reshape(8, 8, 3)
# change color
matrix[:, :] = [255, 100, 0]
#print(matrix)
#print((matrix*0.5).astype(int))
displayMatrix(matrix)
# color the 2nd row white
matrix[1:2, :] = [128, 255, 128]
# color the 2 col white
matrix[:, 1:2] = [128, 128, 255]
fade_in_out(matrix, 2)
background = [255, 34, 34]
matrix[:, :] = background
def darken(color):
step = 10
if color[0] > step:
color[0] -= step
if color[1] > step:
color[1] -= step
if color[2] > step:
color[2] -= step
return color
# Second we make a loop that at each iteration darken the "image"
for i in range(0, 50):
pixel_list = myHAT.get_pixels()
# We create a new list of colors to store the new values
new_list = []
# We need to get the current status of each LED
for pixel in pixel_list:
print(type(pixel))
# For each pixel we darken the color and store it in new_list
pixel = darken(pixel)
new_list.append(pixel)
# Finally we draw the new image
myHAT.set_pixels(new_list)
sleep(0.1)
ladders = game.getLadders()
players = game.getPlayers()
##Cursor
cursorPositionX = 0
cursorPositionY = 7
cursorColour = [255,255,255]
##Main Loop
while True:
for player in players:
turnPlayed = False
image = sense.get_pixels()
while not turnPlayed:
for event in sense.stick.get_events():
##Add cursor
sense.set_pixels(image)
sense.set_pixel(cursorPositionX, cursorPositionY, cursorColour)
if event.action == "pressed":
if event.direction == "up":
cursorPositionY -= 1
if cursorPositionY < 0:
cursorPositionY = 7
elif event.direction == "down":
cursorPositionY += 1
if cursorPositionY > 7:
from sense_hat import SenseHat sense = SenseHat() pixel_list = sense.get_pixels()
async def handle(self, context: RequestContext, responder: BaseResponder):
"""
Message handler logic for basic messages.
Args:
context: request context
responder: responder callback
"""
self._logger.debug(f"ReadSensorHandler called with context {context}")
assert isinstance(context.message, ReadSensor)
self._logger.info("Received read sensor: %s", context.message.sensors)
sensors = context.message.sensors
meta = {"sensors": sensors}
conn_mgr = ConnectionManager(context)
await conn_mgr.log_activity(
context.connection_record,
"read_sensor",
context.connection_record.DIRECTION_RECEIVED,
meta,
)
await responder.send_webhook(
"read_sensor",
{
"message_id": context.message._id,
"sensors": sensors,
"state": "received"
},
)
sense = SenseHat()
temperature = None
humidity = None
pressure = None
orientation = None
accelerometer = None
compass = None
gyroscope = None
stick_events = None
pixels = None
if "temperature" in sensors:
temperature = sense.get_temperature()
if "humidity" in sensors:
humidity = sense.get_humidity()
if "pressure" in sensors:
pressure = sense.get_pressure()
if "orientation" in sensors:
orientation = sense.get_orientation_degrees()
if "accelerometer" in sensors:
accelerometer = sense.get_accelerometer_raw()
if "compass" in sensors:
compass = sense.get_compass_raw()
if "gyroscope" in sensors:
gyroscope = sense.get_gyroscope_raw()
if "stick_events" in sensors:
stick_events = []
stick_event_objects = sense.stick.get_events()
for event in stick_event_objects:
event_dict = {}
event_dict['timestamp'] = event.timestamp
event_dict['direction'] = event.direction
event_dict['action'] = event.action
stick_events.append(event_dict)
if "pixels" in sensors:
pixels = sense.get_pixels()
reply_msg = SensorValue(temperature=temperature,
humidity=humidity,
pressure=pressure,
orientation=orientation,
accelerometer=accelerometer,
compass=compass,
gyroscope=gyroscope,
stick_events=stick_events,
pixels=pixels)
await responder.send_reply(reply_msg)
await conn_mgr.log_activity(
context.connection_record,
"sensor_value",
context.connection_record.DIRECTION_SENT,
{"content": "reply"},
)
sense = SenseHat() # This will be used to control the the SenseHat.
initialise(
sense
) # Initialises the senselib library, that provides us with some useful functions
sense.clear() # Clears all pixels on the screen.
#### 1.3 Set up the variables
posx = 4
posy = 4
posvx = 0.5
posvy = 0.5
rot = 0.1
fade_factor = 0.9
screen = sense.get_pixels()
#### 2. Main game code
while True:
posvx = posvx * math.cos(rot) - posvy * math.sin(rot)
posvy = posvx * math.sin(rot) + posvy * math.cos(rot)
posx += posvx
posy += posvy
ix = int(posx % 8)
iy = int(posy % 8)
#sense.set_pixel(0, 1, 255, 255, 255 )
set_color(x, y)
if sense.get_pixel(previous_x, previous_y) == [
248, 252, 248
]: #verifie si la position precedente est blanche,si oui, efface
sense.set_pixel(previous_x, previous_y, 0, 0, 0)
if event.direction == "down" and event.action == "held": # clean l'ecran
sense.clear()
if event.direction == "up" and event.action == "held": #quand validation
pixel = sense.get_pixel(x, y) #Prend la couleur du pixel
if pixel == [248, 252, 248]: #Si le pixel est blanc, efface le curseur
sense.set_pixel(x, y, nothing)
if sense.get_pixels(
) == dessin and event.action == "held" and event.direction == "up": #Tant que corresond au dessin secret et que le joystick est maintenu vers le haut
tempb = sense.get_temperature() #Prend une deuxieme temperature
tempc = sense.get_temperature_from_pressure()
if tempb > temp + 0.3 or tempc > temp + 0.3: #si la t augmente, affiche du vert et lance le .py correspondant a la situation
print("b")
pro = False #Arrete la boucle permettant de dessiner
sense.clear(0, 255, 0)
time.sleep(2)
sense.clear()
#Verifie s il y a un message enregistre, si oui lance le .py pour rentrer le mdp. S il n y en a pas lance message.py pour en rentrer un.
f = open("message.txt", "r") #ouvre le document message.txt
message = f.read() #string message = contenu du doc
f.close()
if message == "":
import encode_key.py # Permet de rentrer la clef
else:
import time
import sys
import os
import base64
import StringIO
from PIL import Image # pillow
from sense_hat import SenseHat
sense = SenseHat()
sense.low_light = True
try:
data = sys.argv[1]
except IndexError:
display_pixels = sense.get_pixels()
img = Image.new("RGB", (8, 8), "black")
pixels = img.load()
## Set pixels ...
idx = 0
for i in range(8):
for j in range(8):
pixels[i, j] = tuple(display_pixels[idx])
idx += 1
img = img.rotate(-90)
output = StringIO.StringIO()
img.save(output, format="PNG")
print base64.b64encode(output.getvalue())
sys.exit(0)
if os.path.exists(sys.argv[1]):
import atexit
import subprocess
import os
from subprocess import Popen
from sense import rainbow
"""
Response to joystick presses and update the Sense Hat for a Raspberry Pi
"""
x = 0
y = 0
sense = SenseHat()
rainbow_pixels = rainbow.default_pixels()
total_pixels = len(sense.get_pixels())
dim_size = int(math.sqrt(total_pixels))
max_value = dim_size - 1
processes = []
last_press_time = 0
def on_exit():
sense.clear()
def index(x, y):
return y * dim_size + x
class Paint(object):
def motion(self, event):
#tbd: sense LED 'cursor'?
x, y = self.scale_sense_pixels(event.x, event.y)
old_value = self.sense.get_pixel(x, y)
print value
def key(self, event):
global current_paint_brush
if event.char == ' ':
current_paint_brush += 1
if current_paint_brush == len(paint_brushes):
current_paint_brush = 0
return
if event.char == 'i':
pixels = self.sense.get_pixels()
print pixels
def scale_sense_pixels(self, canvas_x, canvas_y):
x = canvas_x / self.x_step
y = canvas_y / self.y_step
if x < 0:
x = 0
if y < 0:
y = 0
if x >= self.sense_width:
x = self.sense_width - 1
if y >= self.sense_height:
y = self.sense_height - 1
return (x, y)
# Clear the pixel
def right_click(self, event):
x, y = self.scale_sense_pixels(event.x, event.y)
self.sense.set_pixel(x, y, eraser)
w = event.widget.find_closest(event.x, event.y)
self.canvas.itemconfigure(w, fill='black') # sort of cheating here
# 'Paint' the pixel
def left_click(self, event):
global current_paint_brush
global paint_brushes
x, y = self.scale_sense_pixels(event.x, event.y)
self.sense.set_pixel(x, y, paint_brushes[current_paint_brush])
w = event.widget.find_closest(event.x, event.y)
self.canvas.itemconfigure(w,
fill="#%02X%02X%02X" %
(paint_brushes[current_paint_brush][0],
paint_brushes[current_paint_brush][1],
paint_brushes[current_paint_brush][2]))
def __init__(self, width=200, height=200):
self.sense = SenseHat()
self.sense.set_rotation(
180
) # this actually messes up our 'get_pixels()' , since it doesn't seem to take into account the rot !
self.sense.clear(
(0, 0, 0)
) # which is why we have to clear them each time (I guess we should store the rotation value and compensate for each startup?)
self.width = width
self.height = height
self.sense_width = 8
self.sense_height = 8
self.x_step = self.width / self.sense_width
self.y_step = self.height / self.sense_height
self.root = Tk()
self.root.title('LED Painter')
self.canvas = Canvas(self.root, width=self.width, height=self.height)
self.mypixels = self.sense.get_pixels()
pixel_counter = 0
for x in range(0, self.width, self.x_step):
for y in range(0, self.height, self.y_step):
fill_colour = 'black' # temporary hack, should really take the 'clear' off earlier and map FROM senseboard to Tkinter initially
p = self.canvas.create_rectangle(x,
y,
x + self.x_step,
y + self.y_step,
outline='white',
fill=fill_colour)
pixel_counter += 1
self.canvas.tag_bind(p, '<ButtonPress-1>', self.left_click)
self.canvas.tag_bind(p, '<B1-Motion>', self.left_click)
self.canvas.tag_bind(p, '<ButtonPress-3>', self.right_click)
self.canvas.tag_bind(p, '<B3-Motion>', self.right_click)
self.root.bind("<Key>", self.key)
# self.root.bind("<Motion>", self.motion)
self.canvas.pack()
self.root.mainloop()
import time
import sys
import os
import base64
import StringIO
from PIL import Image # pillow
from sense_hat import SenseHat
sense = SenseHat()
sense.low_light = True
try:
data = sys.argv[1]
except IndexError:
display_pixels = sense.get_pixels()
img = Image.new( 'RGB', (8,8), "black")
pixels = img.load()
## Set pixels ...
idx = 0
for i in range(8):
for j in range(8):
pixels[i,j] = tuple(display_pixels[idx])
idx += 1
img = img.rotate(-90)
output = StringIO.StringIO()
img.save(output,format="PNG")
print base64.b64encode(output.getvalue())
sys.exit(0)
if os.path.exists(sys.argv[1]):
class LedResource(Resource):
sensehat = None # senseHat object
payload = ""
def __init__(self, name="LedResource", coap_server=None):
'''
Constructor
'''
super(LedResource, self).__init__(name, coap_server, visible=True, observable=True, allow_children=True)
# instantiate senseHat
self.sensehat = SenseHat()
def render_GET_advanced(self, request, response):
'''
GET request handler
return led status if possible (2.05 CONTENT)
if error, return 5.03
'''
try:
response.payload = self.LedStatus()
response.code = defines.Codes.CONTENT[0]
return self, response
except (RuntimeError, OSError):
response.code = defines.Codes.SERVICE_UNAVAILABLE[0]
return self, response
def render_POST_advanced(self, request, response):
'''
POST request handler
try to trigger the LED actuator according to request
return OK in payload and 2.01 CREATED
if error, return 5.03
'''
# set default color
color = (110, 90, 255)
if request.payload == "on":
try:
self.sensehat.clear(color)
response.payload = "OK"
response.code = defines.Codes.CREATED[0]
return self, response
except (RuntimeError, OSError):
response.code = defines.Codes.SERVICE_UNAVAILABLE[0]
return self, response
elif request.payload == "off":
try:
self.sensehat.clear()
response.payload = "OK"
response.code = defines.Codes.CREATED[0]
return self, response
except (RuntimeError, OSError):
response.code = defines.Codes.SERVICE_UNAVAILABLE[0]
return self, response
elif request.payload == "dim":
try:
self.sensehat.low_light = True
response.payload = "OK"
response.code = defines.Codes.CREATED[0]
return self, response
except (RuntimeError, OSError):
response.code = defines.Codes.SERVICE_UNAVAILABLE[0]
return self, response
elif request.payload == "brighten":
try:
self.sensehat.low_light = False
response.payload = "OK"
response.code = defines.Codes.CREATED[0]
return self, response
except (RuntimeError, OSError):
response.code = defines.Codes.SERVICE_UNAVAILABLE[0]
return self, response
def LedStatus(self):
'''
Helper function to check the LED status
'''
# black/off RGB for led pixel
black = [0, 0, 0]
# get list containing 64 smaller lists of [R, G, B] pixels
pixel_list = self.sensehat.get_pixels()
# set default status to off
status = "off"
# check if it is on (no all pixel is [0,0,0])
for p in pixel_list:
if p != black:
status = "on"
break
# check if it is in low_light mode
if status == "on":
if self.sensehat.low_light == True:
status = "dim"
return status
def fade( pixel ): new_pixel=[] for comp in pixel: if comp>0: new_pixel.append( comp-1) else: new_pixel.append( 0 ) return new_pixel while True: rx=random.randint(0,3) ry=random.randint(0,3) if random.randint(0,100) < 25: col=[ random.randint(0,255), random.randint(0,255), random.randint(0,255) ] if sense.get_pixel(rx,ry)==[0,0,0]: sense.set_pixel(rx, ry, col) sense.set_pixel(7-rx, ry, col) sense.set_pixel(7-rx, 7-ry, col) sense.set_pixel(rx, 7-ry, col) pixels=sense.get_pixels() new_pixels=[] for p in pixels: new_pixels.append( fade( p ) ) sense.set_pixels( new_pixels ) #sleep(0.1)
green = int(rgb[1])
blue = int(rgb[2])
#Initialize the pixels with random colors
sense.set_pixels([[randint(0, 255),
randint(0, 255),
randint(0, 255)] for x in xrange(0, 64)])
print "rgb={},{},{}, isMatch={}".format(red, green, blue,
inspect.getsourcelines(isMatch))
iteration = 0
try:
matches = 0
while True:
grid = sense.get_pixels()
for i in xrange(0, len(grid)):
if not isMatch(grid[i]):
grid[i] = [randint(0, 255), randint(0, 255), randint(0, 255)]
else:
print "Pixel {} matches [{},{},{}]".format(i, red, green, blue)
matches += 1
if matches == 64:
print "Took {} iterations to all match goal".format(iteration)
try:
input("Press Enter to exit")
except NameError:
pass
finally:
sys.exit()
else:
##Player 1
playerPostionX = 0
playerPositionY = 7
playerColour = [100,255,100]
##Player 2
##Cursor
cursorPositionX = 0
cursorPositionY = 7
cursorColour = [255,255,255]
image = sense.get_pixels() # Save the sreen as it is for now
sense.set_pixel(cursorPositionX,cursorPositionY,cursorColour)
##Main Loop
while True:
for event in sense.stick.get_events():
if event.action == "pressed":
if event.direction == "up":
cursorPositionY -= 1
if cursorPositionY < 0:
cursorPositionY = 7
elif event.direction == "down":
cursorPositionY += 1
if cursorPositionY > 7:
cursorPositionY = 0
class MatrixController():
WHITE = [255, 255, 255]
BLACK = [0, 0, 0]
RED = [255, 0, 0]
USER_EXIT = 'exit'
def __init__(self):
self.trying = False
self.sense = SenseHat()
self.handler = {
"up": self.pushed_up,
"down": self.pushed_down,
"right": self.pushed_right,
"left": self.pushed_left,
"middle": self.pushed
}
def get_username(self):
os.system("clear")
self.sense.clear()
print "Enter your Username. Type 'exit' to close the app \n"
return raw_input("Username: "******"\nEnter your authentication pattern in the Raspberry Pi"
print "\n - Move the joystick to move around"
print "\n - Press the joystick to select/deselect"
print "\n - Select any spot in the green lines to submit"
self.trying = True
self.sense.load_image("res/start_pattern.png")
self.x, self.y = [3, 3]
self.next_x, self.next_y = [3, 3]
self.hold_color = MatrixController.BLACK
while self.trying:
event = self.sense.stick.wait_for_event(emptybuffer=True)
self.handler[event.direction](event)
self.refresh()
if self.trying == False:
pattern_entered = self.sense.get_pixels()
del pattern_entered[56:] # Delete last row
del pattern_entered[7::8] # Delete last coloumn
for i in range(len(pattern_entered)):
pattern_entered[
i] = pattern_entered[i] != MatrixController.BLACK
self.sense.clear()
return pattern_entered
def exit(self):
print "\nBye!!"
self.sense.show_message("Bye!!")
def display_error(self, error):
self.sense.load_image("res/error.png")
print "\nAn error has occured: \n"
print error
print "\nPress Enter to continue"
raw_input()
self.sense.clear()
def display_success(self, user):
self.sense.load_image("res/success.png")
print "\n\n Welcome " + user['name'] + "!"
print "\n We will send you an email to <" + user[
'mail'] + "> every " + str(
user['wait']) + " seconds with the weather data."
print "\n Press Ctrl + C to logout"
time.sleep(1)
self.sense.clear()
def animation(self):
"One second animation"
self.sense.load_image("res/cloud1.png")
time.sleep(0.25)
self.sense.load_image("res/cloud2.png")
time.sleep(0.25)
self.sense.load_image("res/cloud3.png")
time.sleep(0.25)
self.sense.load_image("res/cloud4.png")
time.sleep(0.25)
def clamp(self, value, min_value=0, max_value=7):
"Check it doesn't go out of the boundaries of the matrix"
return min(max_value, max(min_value, value))
def pushed_up(self, event):
if event.action != ACTION_RELEASED:
self.next_y = self.clamp(self.y - 1)
def pushed_down(self, event):
if event.action != ACTION_RELEASED:
self.next_y = self.clamp(self.y + 1)
def pushed_left(self, event):
if event.action != ACTION_RELEASED:
self.next_x = self.clamp(self.x - 1)
def pushed_right(self, event):
if event.action != ACTION_RELEASED:
self.next_x = self.clamp(self.x + 1)
def pushed(self, event):
if event.action != ACTION_RELEASED:
if self.x == 7 or self.y == 7:
self.trying = False
else:
self.toggle_color()
def toggle_color(self):
"If the joystick is pressed, change the color from Black to Red or viceversa"
if self.hold_color == MatrixController.BLACK:
self.hold_color = MatrixController.RED
else:
self.hold_color = MatrixController.BLACK
def refresh(self):
#Color the current pixel with the proper color before moving
self.sense.set_pixel(self.x, self.y, self.hold_color)
#Saves the color of the next pixel
self.hold_color = self.sense.get_pixel(self.next_x, self.next_y)
#Moves to the next pixel, coloring it white
self.sense.set_pixel(self.next_x, self.next_y, MatrixController.WHITE)
#Updates the current position
self.x, self.y = self.next_x, self.next_y
