def main():
# Initialization stuff
sense = SenseHat()
sense.low_light = True
# Display a random pixel matrix
pixelValues = [ [ random.randint( 0, 255 ) for j in range( 3 ) ] for i in range( 64 ) ]
sense.set_pixels( pixelValues )
time.sleep( 3 )
# Create a colour 'beat'
for i in range( 3 ):
sense.clear( 255, 0, 0 )
time.sleep ( 0.333 )
sense.clear( 0, 255, 0 )
time.sleep ( 0.333 )
sense.clear( 0, 0, 255 )
time.sleep ( 0.333 )
# Toy around with text display
message = "Einfach Mensch..."
sense.show_message( message, 0.05 )
rotation = 0
for letter in message:
sense.set_rotation( rotation, False )
rotation += 90
if rotation == 270:
rotation = 0
sense.show_letter( letter )
time.sleep( 0.24 )
sense.clear()
def index():
user = {'nickname': 'Miguel'} # fake user
sense = SenseHat()
sense.show_message("Hello world!")
return render_template('index.html',
title='Home',
user=user)
def menu():
global sense, time1, time2, r, t, m, w, k, a, b, elapsed
sense = SenseHat()
sense.set_rotation(180)
sense.clear()
sense.set_pixels(imagemenu)
sense.stick.get_events()
while True:
print (" new game1",a," ",b)
y1 = sense.get_accelerometer_raw()['y']
y1 = round(y1, 0)
if y1 == -1:
sense.show_message("Highscore '%s'"% (h))
sense.set_pixels(imagemenu)
for event in sense.stick.get_events():
if event.action == "pressed" and event.direction == "middle":
elapsed = timedelta(seconds=0)
sense.set_rotation(180)
sense.stick.direction_up = move_up
sense.stick.direction_down = move_down
sense.stick.direction_right = move_right
sense.stick.direction_left = move_left
x=0
y=0
time1 = datetime.now()
print(elapsed, " elapsed and e ", e)
while elapsed < e:
sense.clear()
draw_player()
test = draw_enemy(x, y)
print("menu nivel1 ",test)
if test == 1:
new_game()
break
sleep(0.25)
y = y+1
if y > 7:
r = randint(0,7)
t = randint(0,7)
m = randint(0,7)
y = 0
x = x+1
if x > 7:
w = randint(0,7)
k = randint(0,7)
x = 0
if elapsed > e:
sense.show_message("Next level", scroll_speed=0.05)
sense.set_pixels(imagesmile)
sleep(1)
level_2(x,y)
new_game()
break
if event.action == "pressed" and (event.direction == "up" or event.direction == "down" or event.direction == "left" or event.direction == "right"):
return
class Screen:
def __init__(self):
self.sense = SenseHat()
self.general_level = 0
self.wait_time = 4
self.cur_time = 0
self.clear()
self.balance = 0
def clear(self):
for i in range(SIZE):
for j in range(SIZE):
self.sense.set_pixel(i, j, BLACK)
def clear_col(self, x):
for i in range(0, 7):
self.sense.set_pixel(x, i, BLACK)
def plot_bar(self, x, height, colors=None):
if colors is None:
colors = BAR_COLORS
self.clear_col(x)
for i in range(height):
self.sense.set_pixel(x, 7 - i, colors[7 - i])
def plot_balance(self):
for i in range(SIZE):
self.plot_bar(i, max(1, self.general_level), BAR_COLORS)
def show_amount(self):
self.show_message(str(self.balance), color=list(BAR_COLORS[min(7, 8 - self.general_level)]))
def show_message(self, message, speed=0.1, color=[255, 255, 255]):
self.sense.show_message(message, speed, color)
self.plot_balance()
""" Parses an input in the form:
balance percentage """
def parse_input(self, line):
self.cur_time = 0
# Split balance and percentage.
[self.balance, percent] = [float(x) for x in line.split()]
self.general_level = int(round(min(max(0, percent), 100) / 100.0 * SIZE))
self.draw_check()
def draw_check(self):
types = [BLACK, GREEN]
pixels = [types[CHECK[i / SIZE][i % SIZE]] for i in range(SIZE * SIZE)]
self.sense.set_pixels(pixels)
def no_text(self):
self.cur_time += SLEEP_TIME
if self.cur_time > self.wait_time:
self.cur_time = 0
self.show_amount()
def login():
form = LoginForm()
if form.validate_on_submit():
sense = SenseHat()
sense.show_message("Hello {}!".format(form.openid.data))
#flash('Login requested for OpenID="{}", remember_me={}'.format(form.openid.data, form.remember_me.data))
return redirect('/index')
return render_template('login.html',
title='Sign In',
form=form)
def show_tph():
sense = SenseHat()
t = 0
h = 0
p = 0
while p < 1:
p = sense.get_pressure()
time.sleep(1)
t = sense.get_temperature()
h = sense.get_humidity()
t = round(t, 1)
p = round(p, 0)
h = round(h, 0)
msg = "P{0}H{1}".format(p,h)
msg1 = "T{0}".format(t)
sense.set_rotation(rotate_degree)
sense.show_message(msg, text_colour=cadetblue)
sense.show_message(msg1, text_colour=red)
class SenseHatMonitor(Sensor):
"""
Data logger class for Astro Pi Sensehat
No need to supply anything except the identifier as the SenseHad uses some kind of black sorcery to work it out.
"""
data_headers = ("temperature", "humidity", "pressure")
def __init__(self, identifier: str = None, **kwargs):
self.sensehat = SenseHat()
self.display_str = "Init Sensors..."
self.sensehat.show_message(self.display_str)
super(SenseHatMonitor, self).__init__(identifier, **kwargs)
def show_data(self, measurement):
"""
displays the data on the osd.
:param measurement:
:return:
"""
try:
message_str = "T:{0:.2f} H:{1:.2f} P:{2:.2f}"
self.sensehat.show_message(message_str.format(*measurement))
except Exception as e:
self.logger.error(str(e))
def get_measurement(self) -> tuple:
"""
get measurements for sensehat
:return:
"""
try:
return self.sensehat.temperature, self.sensehat.humidity, self.sensehat.pressure
except Exception as e:
self.logger.error("Couldnt get data, {}".format(str(e)))
return tuple(None for _ in range(len(self.data_headers)))
def main():
menu = Menu(SenseHat(), SenseStick())
menu.run()
return
sense_stick = SenseStick()
sense_hat = SenseHat()
sense_hat.clear()
while True:
event = sense_stick.read()
if event.state == SenseStick.STATE_PRESS:
message = ''
if event.key == SenseStick.KEY_UP:
message = 'poo'
elif event.key == SenseStick.KEY_LEFT:
message = 'bum'
elif event.key == SenseStick.KEY_RIGHT:
message = 'dick'
elif event.key == SenseStick.KEY_DOWN:
message = 'balls'
elif event.key == SenseStick.KEY_ENTER:
message = 'rofl'
red = (255, 0, 0)
sense_hat.show_message(message, text_colour=red, scroll_speed=0.05)
print 'hello'
worksheet = login_open_sheet(GDOCS_OAUTH_JSON, GDOCS_SPREADSHEET_NAME)
# Attempt to get sensor reading.
temp = sense.get_temperature()
temp = ((temp / 5) * 9) + 32
temp = round(temp, 1)
humidity = sense.get_humidity()
humidity = round(humidity, 1)
pressure = sense.get_pressure()
pressure = round(pressure, 1)
# 8x8 RGB
sense.clear()
info = 'Temperature (C): ' + str(temp) + 'Humidity: ' + str(
humidity) + 'Pressure: ' + str(pressure)
sense.show_message(info, text_colour=[255, 0, 0])
# Print
print "Temperature (C): ", temp
print "Humidity: ", humidity
print "Pressure: ", pressure, "\n"
# Append the data in the spreadsheet, including a timestamp
try:
worksheet.append_row(
(datetime.datetime.now(), temp, humidity, pressure))
except:
# Error appending data, most likely because credentials are stale.
# Null out the worksheet so a login is performed at the top of the loop.
print 'Append error, logging in again'
worksheet = None
from sense_hat import SenseHat
s = SenseHat()
s.clear()
old_humidity = 0
while True:
humidity = s.get_humidity()
if humidity != old_humidity:
print(humidity)
s.show_message(str(round(humidity, 2)))
old_humidity = humidity
from sense_hat import SenseHat
sense = SenseHat()
while True:
sense.show_message("Astro Pi is awesome!!", scroll_speed=0.05, text_colour=[255,255,0], back_colour=[0,0,255])
class DataCollector:
COLOR = [95, 189, 242]
TIME_FORMAT = '%Y-%m-%d:%H:%M'
field_names = ['date', 'temp', 'temp_press', 'humidity', 'pressure']
def __init__(self, filename, samples=3, sample_time=1, no_append=False):
self._filename = filename
self._no_append = no_append
self._sample_time = sample_time
self._samples = int(samples) if samples and (samples and 1 <= samples < 100) else 3
self._field_names = DataCollector.field_names + DataCollector.field_names + ['{}{}'.format(name, i) for name in
DataCollector.field_names for i in
range(self._samples)]
self._sense = SenseHat()
self._write_header()
self._sense.show_message("Start!", scroll_speed=0.2, text_colour=DataCollector.COLOR)
print("Collecting data at {}".format(strftime(DataCollector.TIME_FORMAT)), file=sys.stderr)
def _write_header(self):
if not exists(self._filename) or not isfile(self._filename):
with smart_open(self._filename, no_append=True) as f:
fcsv = csv.DictWriter(f, delimiter=',', fieldnames=self._field_names)
fcsv.writeheader()
f.flush()
def _get_sample(self):
# Check if samples and sample_time are realistic,else the script will take forever to produce data.
dt = self._sample_time if 1 <= self._sample_time < 3 else 1
temp_data = defaultdict(list)
for _ in range(self._samples):
temp_data['date'].append(time())
temp_data['humidity'].append(self._sense.humidity)
temp_data['temp'].append(self._sense.temperature)
temp_data['temp_press'].append(self._sense.get_temperature_from_pressure())
temp_data['pressure'].append(self._sense.pressure)
sleep(dt)
return temp_data
def _mean_sample(self, data_raw):
result_data = {}
for key, value in data_raw.items():
result_data[key] = mean(value)
return result_data
def _procces_raw(self, data_raw):
raw = {}
for key, value in data_raw.items():
for i in range(len(value)):
raw["{}{}".format(key, i)] = value[i]
return raw
def sample(self):
print("Start Sampling at {}".format(strftime(DataCollector.TIME_FORMAT + ':%S')), file=sys.stderr)
self._sense.show_message("Sample!", scroll_speed=0.075, text_colour=DataCollector.COLOR)
with smart_open(self._filename, no_append=self._no_append) as f:
fcsv = csv.DictWriter(f, delimiter=',', fieldnames=self._field_names)
raw_data = self._get_sample()
mean_data = self._mean_sample(raw_data)
mean_data.update(self._procces_raw(raw_data))
mean_data['date'] = strftime(DataCollector.TIME_FORMAT)
fcsv.writerow(mean_data)
f.flush()
def monitor(self, interval, max_intervals=-1):
"""
Collect sensor data with intervals in seconds. And if it has to stop after n intervals
set max_intervals.
:param interval: integer
:param max_intervals: integer
:return:
"""
# Check if interval is realistic,else the script will take forever to produce data.
# to exclude almost everlasting invervals the biggest interval is two days. default each hour.
dt = interval if interval and 1 <= interval < (2 * 24 * 60 * 60) else (15 * 60)
if self._no_append:
self._no_append = True
i = 0
while max_intervals < 0 or i < max_intervals:
self.sample()
sleep(interval)
#!/usr/bin/python
# Uses the user inputted message as a
# command line argument. Argument is then
# concatenated as a string, and sent to SenseHat.
import sys
from sense_hat import SenseHat
sense = SenseHat()
sense.clear(0, 0, 0)
message = ""
for index in range(len(sys.argv) - 1):
if index == (len(sys.argv) - 1):
message += sys.argv[index + 1]
else:
message += sys.argv[index + 1] + " "
sense.show_message(message, text_colour=(0, 255, 0))
#!/usr/bin/env/ python
#this script will show a scrolling message on the Pi HAT
from sense_hat import SenseHat
sense = SenseHat()
# send the text Hello World! to the show_message() function
sense.show_message("Steven Brown waz Here!!")
from sense_hat import SenseHat
sense = SenseHat()
while True:
t = sense.get_temperature()
p = sense.get_pressure()
h = sense.get_humidity()
t = round(t,1)
p = round(p,1)
h = round(h,1)
msg = "Temperature = %s, Pressure=%s, Humidity=%s" % (t,p,h)
print(t)
print(p)
print(h)
sense.show_message(msg,scroll_speed=0.05)
from sense_hat import SenseHat
sense = SenseHat()
sense.show_message("Ja was geht? Das hier ist der Testtext der Testdatei")
w, b, w, w, w, w, b, w,
w, b, w, w, w, b, w, w,
w, b, w, w, b, w, w, w,
w, b, w, w, b, b, b, w,
w, w, w, w, w, w, w, w,
]
rudolf = [
y, w, w, w, w, w, w, y,
w, y, y, w, w, y, y, w,
y, y, w, br, br, w, y, y,
w, y, br, br, br, br, y, w,
w, br, br, br, br, br, br, w,
w, br, br, r, r, br, br, w,
w, br, br, r, r, br, br, w,
w, w, br, br, br, br, w, w,
]
sense.show_message("On the 12th day of xmas")
while True:
sense.set_pixels(door12)
event = sense.stick.wait_for_event()
if event.action == "pressed":
if event.direction == "down":
sense.set_pixels (rudolf)
sleep (2)
else:
sense.show_message("Error")
client = paho.Client()
client.on_subscribe = on_subscribe
client.on_message = on_message
client.connect('192.168.1.150', 1883)
client.subscribe('/andrzej/sensorki')
client.loop_start()
while True:
try:
client.loop_start() == True
except:
print('no network')
time.sleep(2)
else:
time.sleep(5)
print(info)
sense.show_message(info,
text_colour=[
random.randrange(0, 150),
random.randrange(70, 210),
random.randrange(50, 150)
],
scroll_speed=0.1)
db.insert({
'datetime': str(datetime.datetime.now()),
"sensor": str(info)
})
if 0 <= (y-3+i) < rows and 0 <= (x-3+j) < cols:
display[i][j] = maze[y-3+i][x-3+j]
else:
display[i][j] = w
for i in range(0,7): #displaying the remaining lives in the bottom row
display[7][i] = b
for li in range(0, life):
display[7][li] = l
while not game_over: #main program
o = sense.get_orientation() #getting the internal mesurement unit data from the sense hat
pitch = o["pitch"]
roll = o["roll"]
x, y = move_marble(pitch, roll, x, y)
if maze[y][x] == g: #checking if the win condition is fulfilled
sense.show_message("WIN!")
game_over = True
if maze[y][x] == t: #checking if the marble collided with a trap
if life > 1:
life -= 1
x = 1
y = 1
sense.show_message("LIFE LOST!") #if there are still lives left remove one and display message
sense.clear()
else:
sense.show_message("GAME OVER!") #if none left set game over condition to true and display message
game_over = True
maze[y][x] = m
set_display(x,y)
sense.set_pixels(sum(display,[]))
sleep(0.2)
from sense_hat import SenseHat
import time
import os
import sys
from datetime import datetime
sense = SenseHat()
sense.rotation = 180
count = 0
while True:
orientation = sense.get_orientation_degrees()
roll = orientation['roll']
roll = int(roll)
print roll
print("p: {pitch}, r: {roll}, y: {yaw}".format(**orientation))
rollnow = str(roll)
count = count + 1
if count ==100:
count = 0
sense.show_message(rollnow, text_colour=(255,0,0))
from sense_hat import SenseHat
sense = SenseHat()
# sense.show_message("Hello world")
blue = (0, 0, 255)
yellow = (255, 255, 0)
while True:
sense.show_message("Astro Pi is awesome!", text_colour=yellow, back_colour=blue, scroll_speed=0.05)
from sense_hat import SenseHat
sense = SenseHat()
sense.clear()
#get the temperature from the temperature sensor on the LED screen
temp = sense.get_temperature()
#we get a number with a lot of numbers after the decimal, so we use this code to round that value
round_temp = round(temp,2)
#display the temperature from the LED screen
sense.show_message("The temperature is "+ str(round_temp)+ " degrees Celsius")
def main():
sense = SenseHat()
sense.show_message("Hello World!!");
#!/usr/bin/env python
from sense_hat import SenseHat
sense = SenseHat()
sense.show_message("Anu Lingineni")
sense.set_pixels(xplod5)
time.sleep(0.4)
sense.clear(255,255,255)
time.sleep(0.05)
sense.set_pixels(xplod6)
time.sleep(0.75)
# Warning flash
for i in range(50):
sense.clear(255,255,255)
time.sleep(0.05)
sense.clear()
time.sleep(0.05)
# Message
sense.show_message("10..9..8..7..6..5..4..3..2..1..", scroll_speed=0.08, text_colour=[204,0,0])
sense.show_message("HAPPY NEW YEAR!", scroll_speed=0.04, text_colour=[204,0,204])
sense.show_letter("2")
time.sleep(0.25)
sense.show_letter("0")
time.sleep(0.25)
sense.show_letter("1")
time.sleep(0.25)
sense.show_letter("6")
time.sleep(0.25)
# Bombs Away
for i in range(7):
fireworks()
sense.clear()
global colour256
colour256 = [225,128,55]
global colour512
colour512 = [0,0,255]
global colour1024
colour1024 = [134,55,10]
global colour2048
colour2048 = [255,255,255]
# Dictionary of colours and their corresponding number
colours = {'2':colour2, '4':colour4,'8':colour8,'16':colour16,
'32':colour32,'64':colour64,'128':colour128,'256':colour256,
'512':colour512,'1024':colour1024,'2048':colour2048}
# Print each colour with its number
for c in sorted(colours,key=lambda k: int(k) if k.isdigit()else float('-inf')):
sh.show_message(c,text_colour=[0,0,0],back_colour=colours[c],scroll_speed=0.03)
global score
score = 0
r = [255,0,0]
g = [0,255,0]
b = [0,0,255]
# define each 4x4 square and the pixels that comprise it
global sq00
sq00 = [(0,0),(0,1),(1,0),(1,1)]
global sq01
sq01 = [(0,2),(0,3),(1,2),(1,3)]
global sq02
sq02 = [(0,4),(0,5),(1,4),(1,5)]
global sq03
sq03 = [(0,6),(0,7),(1,6),(1,7)]
from sense_hat import SenseHat
import time
import sys
sense = SenseHat()
sense.set_rotation(180)
for v in sys.argv[1:]:
sense.show_message(v, text_colour=[255, 0, 0])
import time
sense = SenseHat()
sense.clear()
speed = 0.05
x = [255, 255, 0]
o = [0, 0, 0]
skull = [
o, o, x, x, x, x, o, o, o, x, x, x, x, x, x, o, o, x, o, x, x, o, x, o, o,
x, x, x, x, x, x, o, o, x, x, o, o, x, x, o, o, o, x, x, x, x, o, o, o, o,
x, o, o, x, o, o, o, o, o, o, o, o, o, o
]
sense.show_message("Let's Roll!", speed)
def roll_dice():
r = random.randint(1, 20)
if r < 20:
sense.show_message(str(r), speed)
elif r == 20:
sense.show_message("Critical Hit!",
speed,
text_colour=[255, 255, 0],
back_colour=[0, 0, 0])
sense.set_pixels(skull)
while True:
# sense.show_message("IoT Sensor Pack")
# sense.show_message(str(datetime.datetime.now()))
def signal_handler(signal, frame):
print("Shutting down.")
sense.clear()
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
sense.clear()
try:
while True:
t = sense.get_temperature()
p = sense.get_pressure()
h = sense.get_humidity()
t = round(t, 1)
p = round(p, 1)
h = round(h, 1)
print("T: %d P: %d H: %d" % (t, p, h))
sense.show_message("T: %d P: %d H: %d" % (t, p, h))
time.sleep(5)
except KeyboardInterrupt:
print("Breaking out.")
sense.clear()
from sense_hat import SenseHat
from time import sleep
sense = SenseHat()
sense.set_rotation(90)
sense.clear(0, 0, 0,)
while True:
sense.show_message(" %s F" % round(sense.get_temperature() * 1.8 + 32))
sleep(1)
sense.show_message(" %s prh" % round((sense.get_humidity)()))
sleep(1)
sense.show_message(" %s''" % round((sense.get_pressure() * 0.0295301), 2))
sleep(1)
def joystick_moved(event):
global direction
direction = event.direction
def make_veg():
new = slug[0]
while new in slug:
x = randint(0, 7)
y = randint(0, 7)
new = [x, y]
sense.set_pixel(x, y, red)
vegetables.append(new)
# Main program ------------------------
sense.clear()
draw_slug()
sense.stick.direction_any = joystick_moved
while not dead:
move()
sleep(pause)
# Have a 20% chance of making a veggie if there aren't many about
if len(vegetables) < 3 and randint(1, 5) > 4:
make_veg()
sense.show_message(str(score))
speed = -1
else:
speed = +1
def collision(x,gap):
if x == 3:
if y < gap -1 or y > gap +1:
return True
return False
columns = Thread(target=draw_columns)
columns.start()
shake = Thread(target=get_shake)
shake.start()
while not game_over:
sense.set_pixel(3,y,BLUE)
sleep(0.1)
sense.set_pixel(3,y,BLACK)
y += speed
if y > 7:
y = 7
if y < 0:
y = 0
shake.join()
columns.join()
sense.show_message("You Lose", text_colour=(255,0,0))
class SenseHatHangman:
X = [135, 64, 8] # Brown
O = [100, 100, 100] # White
B = [0, 0, 100] # Blue
G = [0, 100, 0] # Green
# lights/display for each step
step_O = [
O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O
]
step_1 = [
X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O,
X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O,
X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O
]
step_2 = [
X, X, X, X, X, X, O, O, X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O,
X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O,
X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O
]
step_3 = [
X, X, X, X, X, X, O, O, X, O, O, X, O, O, O, O, X, O, X, O, O, O, O, O,
X, X, O, O, O, O, O, O, X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O,
X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O
]
step_4 = [
X, X, X, X, X, X, O, O, X, O, O, X, O, X, O, O, X, O, X, O, O, X, O, O,
X, X, O, O, O, O, O, O, X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O,
X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O
]
step_5 = [
X, X, X, X, X, X, O, O, X, O, O, X, O, X, O, O, X, O, X, O, O, X, O, O,
X, X, O, O, O, G, O, O, X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O,
X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O
]
step_6 = [
X, X, X, X, X, X, O, O, X, O, O, X, O, X, O, O, X, O, X, O, O, X, O, O,
X, X, O, O, O, G, O, O, X, O, O, O, O, B, O, O, X, O, O, O, O, B, O, O,
X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O
]
step_7 = [
X, X, X, X, X, X, O, O, X, O, O, X, O, X, O, O, X, O, X, O, O, X, O, O,
X, X, O, O, O, G, O, O, X, O, O, O, O, B, B, G, X, O, O, O, O, B, O, O,
X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O
]
step_8 = [
X, X, X, X, X, X, O, O, X, O, O, X, O, X, O, O, X, O, X, O, O, X, O, O,
X, X, O, O, O, G, O, O, X, O, O, G, B, B, B, G, X, O, O, O, O, B, O, O,
X, O, O, O, O, O, O, O, X, O, O, O, O, O, O, O
]
step_9 = [
X, X, X, X, X, X, O, O, X, O, O, X, O, X, O, O, X, O, X, O, O, X, O, O,
X, X, O, O, O, G, O, O, X, O, O, G, B, B, B, G, X, O, O, O, O, B, O, O,
X, O, O, O, O, O, B, O, X, O, O, O, O, O, O, G
]
step_10 = [
X, X, X, X, X, X, O, O, X, O, O, X, O, X, O, O, X, O, X, O, O, X, O, O,
X, X, O, O, O, G, O, O, X, O, O, G, B, B, B, G, X, O, O, O, O, B, O, O,
X, O, O, O, B, O, B, O, X, O, O, G, O, O, O, G
]
# all of the steps in order
steps = [
step_O, step_1, step_2, step_3, step_4, step_5, step_6, step_7, step_8,
step_9, step_10
]
def __init__(self):
self.sense = SenseHat()
self.index = 0
def start(self):
self.sense.set_pixels(self.step_O)
self.index = 0
def wrongGuess(self):
if self.index < 10:
self.index += 1
self.sense.set_pixels(self.steps[self.index])
def gameOver(self):
self.sense.show_message("Game Over")
def winner(self, w):
self.sense.show_message("Congratulations, you guessed %s" % w)
class MClock:
def __init__(self, radius=200, segments=9, dim=0.8, sleep=5.0):
self.segments = segments
self.image = Image.new('RGB', (RADIUS * 2, RADIUS * 2))
self.img = ImageDraw.Draw(self.image)
self.display_credits = False
self.seconds = True
self.hat = SenseHat()
self.radius = RADIUS
self.dim = dim
self.sleep = sleep
self.recalc(self.radius*2, self.radius*2)
def set_segments(self, *args):
self.segments = max(self.segments, 2)
def toggle_text(self, *args):
self.showtext = not self.showtext
def toggle_seconds(self, *args):
self.seconds = not self.seconds
def show_credits(self, *args):
self.hat.show_message(self.credits)
def quit(self, *args):
self.running = False
credits = ("M Clock 2.0\n"
"by Johnny Gill\n"
"after tkinter by Guido van Rossum\n"
"after a design by Rob Juda")
creditid = None
showtext = False
def recalc(self, width, height):
radius = min(width, height) // 2
self.radius = radius
self.bigsize = radius * .975
self.litsize = radius * .67
def run(self):
self.running = True
while self.running:
t = time.time()
hh, mm, ss = time.localtime(t)[3:6]
self.draw(hh, mm, ss)
self.blit()
time.sleep(self.sleep)
def blit(self):
""" Update the image on the sense hat
Need to downsample from RADIUS to 8
Let's just pick a pixel at random and see how that works
"""
size = self.radius // 4
for x in range(8):
for y in range(8):
xpos = size * x
ypos = size * y
pix = self.pixel_picker(xpos, ypos, size, size)
self.hat.set_pixel(x, y, pix)
def pick_pixel(self, xpos, ypos, xx, yy):
rr = gg =bb = 0
for x in range(xx):
for y in range(yy):
r, g, b = self.image.getpixel((xpos + x, ypos + y))
rr += r
gg += g
bb += b
count = xx * yy
pix = (rr // count, gg // count, bb // count)
return pix
def weighted_pick_pixel(self, xpos, ypos, xx, yy):
rr = gg =bb = 0
weight = 0
for x in range(xx):
for y in range(yy):
# Use Euclidean distance from centre as weight
this_weight = (abs(x - xx/2)) ** 2
this_weight += (abs(y - yy/2)) ** 2
this_weight = this_weight ** 0.5
weight += this_weight
r, g, b = self.image.getpixel((xpos + x, ypos + y))
rr += this_weight * r
gg += this_weight * g
bb += this_weight * b
count = weight / self.dim
pix = (int(rr // count),
int(gg // count),
int(bb // count))
return pix
pixel_picker = weighted_pick_pixel
def xpick_pixel(self, xpos, ypos, xx, yy):
pickx = random.randint(0, xx-1)
picky = random.randint(0, xx-1)
pix = self.image.getpixel((xpos + pickx, ypos + picky))
return pix
def get_angles(self, hh, mm, ss):
# Set bigd, litd to angles in degrees for big, little hands
# 12 => 90, 3 => 0, etc.
secd = (90 - (ss * 60) / 10) % 360
bigd = (90 - (mm*60 + ss) / 10) % 360
litd = (90 - (hh*3600 + mm*60 + ss) / 120) % 360
return secd, bigd, litd
def draw(self, hh, mm, ss, colors=(0, 1, 2)):
radius = self.radius
bigsize = self.bigsize
litsize = self.litsize
# Delete old items
#self.hat.clear()
secd, bigd, litd = self.get_angles(hh, mm, ss)
# Set bigr, litr to the same values in radians
bigr = radians(bigd)
litr = radians(litd)
# Draw the background colored arcs
self.drawbg(bigd, litd, secd, colors)
# Draw the hands
self.draw_hands(bigr, litr)
def draw_hands(self, bigr, litr, colour=(0,0,0), scale=1.0):
# Draw the hands
radius = self.radius
bigsize = self.bigsize * scale
litsize = self.litsize * scale
img = self.img
r, g, b = colour
xcolour = (255-r, 255-g, 255-b)
xcolour = (255, 0, 0)
b = img.line([radius, radius,
radius + int(bigsize*math.cos(bigr)),
radius - int(bigsize*math.sin(bigr))],
width=12,
fill=xcolour)
l = img.line([radius, radius,
radius + int(bigsize*math.cos(litr)),
radius - int(bigsize*math.sin(litr))],
width=12,
fill=colour)
def drawbg(self, bigd, litd, secd, colors=(0, 1, 2)):
# This is tricky. We have to simulate a white background with
# three transparent discs in front of it; one disc is
# stationary and the other two are attached to the big and
# little hands, respectively. Each disc has 9 pie segments in
# sucessive shades of pigment applied to it, ranging from
# fully transparent to only allowing one of the three colors
# Cyan, Magenta, Yellow through.
if not self.seconds:
secd = 90
img = self.img
N = self.segments
table = []
for angle, colorindex in [(bigd - 180/N, 0),
(litd - 180/N, 1),
(secd - 180/N, 2)]:
angle %= 360
for i in range(N):
color = 255
if colorindex in colors:
color = (N-1-i)*color//(N-1)
table.append((angle, color, colorindex))
angle += 360/N
if angle >= 360:
angle -= 360
table.append((0, color, colorindex))
table.sort()
table.append((360, None))
radius = self.radius
fill = [0, 0, 0]
i = 0
for angle, color, colorindex in table[:-1]:
fill[colorindex] = color
if table[i+1][0] > angle:
extent = table[i+1][0] - angle
if extent < 1.:
# XXX Work around a bug in Tk for very small angles
# I think this bug is also present in appuifw
extent = 1.
#print([0, 0, 2 * radius, 2 * radius])
#print(type(2 * radius))
#print(fill)
img.pieslice([0, 0, 2 * radius, 2 * radius],
int(angle), int(extent+angle),
fill=tuple(fill))
i+=1
import time
from sense_hat import SenseHat
sense = SenseHat()
#this script will print a message to the Pi Sense HAT
yellow = (255, 255, 0)
blue = (0, 0, 255)
speed = 0.05
message = 'Hello World'
sense.show_message(message, speed, text_colour=yellow, back_colour=blue)
time.sleep(1)
sense.show_letter('!',yellow)
time.sleep(1)
sense.clear()
#!/usr/bin/python
# Import modules
from sense_hat import SenseHat
import random
# Instantiate SenseHat
sense = SenseHat()
sense.set_rotation(270)
# Define colour palette
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] # e stands for empty/black
# Main loop
while True:
# Initialise random colors
r = random.randint(0,255)
g = random.randint(0,255)
b = random.randint(0,255)
# Display welcome message
sense.show_message("Hello World!", scroll_speed=0.05, text_colour=[r,g,b],back_colour=[0,0,0])
sense.set_pixels(one)
elif ran == 2:
sense.set_pixels(two)
elif ran == 3:
sense.set_pixels(three)
elif ran == 4:
sense.set_pixels(four)
elif ran == 5:
sense.set_pixels(five)
elif ran == 6:
sense.set_pixels(six)
try:
sense.clear()
sense.show_message("Shake...")
print("Shake to Roll the Die")
start_time = time.time()
next_roll = True
while True:
x, y, z = sense.get_accelerometer_raw().values()
x1 = abs(x)
y1 = abs(y)
z1 = abs(z)
time.sleep(0.1)
x, y, z = sense.get_accelerometer_raw().values()
dx = abs(abs(x1) - abs(x))
dy = abs(abs(y1) - abs(y))
dz = abs(abs(z1) - abs(z))
if dx > accel_thresh or dy > accel_thresh or dz > accel_thresh:
if next_roll:
"""
str(code)
f = open("code.txt", "w")
f.write(hashing("".join(code)))
f.close()
def confirmer():
"""
Affiche sur la matrix du sensehat un message qui demande a l'utilisateur de confirmer son choix
Ensuite celui-ci doit selectionner entre Y ou N a l'aide du joystick
return: (Boolean) True Si l'utilisateur choisit Y
return: (Boolean) False si l'utilisateur choisit N
"""
l = ["Y","N"]
i = 0
sense.show_message("Sure?", back_colour=green, scroll_speed=0.04)
sense.show_letter(l[i])
while joystick:
event = sense.stick.wait_for_event()
if event.action == "pressed" and event.direction == "middle" and event.action != ACTION_RELEASED:
if i == 0:
sense.show_letter("Y", back_colour = green)
print("confirmed")
return True
else:
sense.show_letter("N", back_colour = red)
print("non confirmed")
return False
if event.action == "pressed" and event.direction == "left" and event.action != ACTION_RELEASED:
i -= 1
if i%2 == 0: i=0
from sense_hat import SenseHat
sense = SenseHat()
sense.show_message("Hello my name is Andrew")
from NumberMatrix import *
sense = SenseHat()
sense.set_rotation(90)
print("Weather is shown on LED matrix. Press Ctrl-C to exit")
try:
while True:
t = int(sense.get_temperature())
sense.show_letter("T")
matrix = create_matrix(t)
pixels = create_pixels(matrix)
sense.set_pixels(pixels)
rh = int(sense.get_humidity())
sense.show_message("RH")
matrix = create_matrix(rh)
pixels = create_pixels(matrix)
sense.set_pixels(pixels)
p = int(sense.get_pressure())
sense.show_message("p=" + str(p))
except KeyboardInterrupt:
off = [0, 0, 0]
pixels_off = [
off, off, off, off, off, off, off, off, off, off, off, off, off, off,
off, off, off, off, off, off, off, off, off, off, off, off, off, off,
off, off, off, off, off, off, off, off, off, off, off, off, off, off,
off, off, off, off, off, off, off, off, off, off, off, off, off, off,
off, off, off, off, off, off, off, off
from sense_hat import SenseHat, ACTION_HELD
from time import process_time
sense = SenseHat()
i = 0
while i < 20:
for event in sense.stick.get_events():
if event.action is ACTION_HELD:
i += 1
else:
i = 0
sense.show_message("1")
time_start = 0
naopassou = True
while naopassou:
for event in sense.stick.get_events():
if event.action is ACTION_HELD:
if time_start is 0:
time_start = process_time()
time_now = process_time()
if time_now > time_start + 2:
from sense_hat import SenseHat
from random import randint
sense = SenseHat()
while True:
colour = (0, 0, 0)
randomBackgroundCol = (randint(0, 255), randint(0, 255), randint(0, 255))
sense.show_message("Hello! We are New Media Development :)",
text_colour=colour,
back_colour=randomBackgroundCol)
sense.low_light = True
forecast_key = os.environ['FORECAST_KEY']
except KeyError as e:
print 'FORECAST_KEY not set'
sys.exit(1)
latitude = os.getenv('FORECAST_LATITUDE', 53.4667)
longitude = os.getenv('FORECAST_LONGITUDE', -2.2333)
url = 'https://api.darksky.net/forecast/%s/%s,%s' % (forecast_key, latitude, longitude)
while True:
response = requests.get(url)
if(response.ok):
jData = json.loads(response.content)
current = jData['currently']['icon']
max_counter = 60 * 5
counter = 0
while counter < max_counter:
icon = icon_mapper.get_images(current)
for icon_frame in icon:
sense.load_image(icon_frame[0])
counter = counter + 1
sleep(icon_frame[1])
else:
sense.show_message('ERROR', text_colour=[255,0,0])
w = [255, 255, 255]
e = [0, 0, 0] # e stands for empty/black
image = [
e, e, e, e, e, e, w, w, e, e, e, e, r, r, w, w, e, e, e, r, r, e, e, e, e,
r, r, r, r, r, e, e, e, r, r, r, r, r, e, e, r, r, r, r, r, r, r, e, r, r,
r, r, r, r, r, e, w, w, w, w, w, w, w, e
]
sense.set_pixels(image)
sleep(2)
sense.flip_h()
sleep(2)
sense.show_message("Kalh Xronia 2017 !!!",
scroll_speed=0.07,
text_colour=[0, 0, 255],
back_colour=[0, 0, 0])
sense.show_letter("O", text_colour=[255, 255, 0])
sleep(1)
sense.show_letter("M", text_colour=[255, 0, 255])
sleep(1)
sense.show_letter("G", text_colour=[0, 255, 0])
sleep(1)
sense.show_letter("!", text_colour=[0, 0, 0], back_colour=[255, 255, 0])
sleep(1)
sense.clear()
sense.set_rotation(90)
sense.set_pixel(0, 3, [0, 255, 0])
sense.set_pixel(1, 2, [0, 255, 0])
sense.set_pixel(1, 3, [0, 255, 0])
if lights == True:
sense.clear()
x = randint(0, 7)
y = randint(0, 7)
r = randint(0, 255)
g = randint(0, 255)
b = randint(0, 255)
pixel = (r, g, b)
sense.set_pixel(x, y, pixel)
time.sleep(0.01)
if choice == 4:
print("To modify color please check code")
message = raw_input()
#Color Here
sense.show_message(message,text_colour=[0,255,0])
if choice == 5:
humidity = sense.get_humidity()
print("Humidity: %s %%rH" % humidity)
elif choice == 6:
pressure = sense.get_pressure()
print("Pressure: %s Millibars" % pressure)
elif choice == 7:
r = 255
g = 0
b = 0
nsleep = lambda x: time.sleep(x / 1000.0)
from sense_hat import SenseHat
sense = SenseHat()
while True:
t = sense.get_temperature()
p = sense.get_pressure()
h = sense.get_humidity()
t = round(t, 1)
p = round(p, 1)
h = round(h, 1)
message = ("Temperature: " + str(t) + "Pressure: " + str(p) +
"Humidity: " + str(h))
sense.show_message(message)
def sensors():
from sense_hat import SenseHat
sense = SenseHat()
tempC = sense.get_temperature() # obtains temperature in Celsius from sensor
tempC = round(tempC, 1)
tempF = c_to_f(tempC) # conversion from Celsius to Fahrenheit
tempF = round(tempF, 1)
print "\nThe temperature at the Sense Hat is", tempC, "C or", tempF, "F"
humidity = sense.get_humidity()
humidity = round(humidity, 1)
print "The relative humidity at the Sense Hat is", humidity, "%"
pressure = sense.get_pressure()
pressure = round(pressure, 1)
print "The atmospheric pressure at the Sense Hat is", pressure, "mbar\n"
# outputing the temp, humidity, and pressure to the matrix
sense.clear() # clear the 8x8 matrix
sense.set_rotation(0) # sets orientation of Sense Hat matrix
# setting colors for the scrolling text on the matrix
red = (255, 0, 0)
green = (0, 255, 0)
blue = (0, 0, 255)
speed = 0.02 # speed of text scroll (0.10 is default)
sleep = 0.2 # time of pause in seconds
sense.show_message("Temp:", text_colour=red, scroll_speed=speed)
sense.show_message(str(tempC), text_colour=red, scroll_speed=speed)
sense.show_message("C", text_colour=red, scroll_speed=speed)
sense.show_message("or", text_colour=red, scroll_speed=speed)
sense.show_message(str(tempF), text_colour=red, scroll_speed=speed)
sense.show_message("F", text_colour=red, scroll_speed=speed)
time.sleep(sleep)
sense.show_message("Humidity:", text_colour=green, scroll_speed=speed)
sense.show_message(str(humidity), text_colour=green, scroll_speed=speed)
sense.show_message("%", text_colour=green, scroll_speed=speed)
time.sleep(sleep)
sense.show_message("Pressure:", text_colour=blue, scroll_speed=speed)
sense.show_message(str(pressure), text_colour=blue, scroll_speed=speed)
sense.show_message("mbar", text_colour=blue, scroll_speed=speed)
sense.clear()
from sense_hat import SenseHat
sense = SenseHat()
sense.set_rotation(180)
while True:
t = sense.get_temperature()
p = sense.get_pressure()
h = sense.get_humidity()
t = round(t, 1)
p = round(p, 1)
h = round(h, 1)
if t > 21.3 and t < 29.7:
bg = [0, 100, 0] # green
else:
bg = [100, 0, 0] # red
msg = "Temperature = %s, Pressure=%s, Humidity=%s" % (t, p, h)
sense.show_message(msg, scroll_speed=0.05, back_colour=bg)
from sense_hat import SenseHat
import time
import random
sense = SenseHat()
sense.show_message("Hallo", scroll_speed=0.05, text_colour=[255, 255, 0], back_colour=[0, 0, 255])
sense.show_letter("F", text_colour=[255, 0, 0])
time.sleep(1)
sense.show_letter("+", text_colour=[0, 255, 0])
time.sleep(1)
sense.show_letter("M", text_colour=[0, 0, 255])
time.sleep(1)
a = 0
while a < 3:
a = a + 1
z = random.randint(0, 255)
y = random.randint(0, 255)
x = random.randint(0, 255)
sense.show_message("Bunt", scroll_speed=0.05, text_colour=[z, y, x])
sense.set_pixel(1, 1, [255, 0, 0])
sense.set_pixel(6, 6, [0, 0, 255])
time.sleep(1)
r = [255, 0, 0]
g = [0, 255, 0]
b = [0, 0, 255]
image = [
def ShowId():
sense = SenseHat()
sense.low_light = True
while (True):
sense.show_message(str(raspID), text_colour=[100, 100, 190])
from sense_hat import SenseHat
import time
# https://www.raspberrypi.org/learning/getting-started-with-the-sense-hat/worksheet/
sense = SenseHat()
sense.show_message("Hello World")
sense.show_letter("O", text_colour=[255, 0, 0])
time.sleep(1)
sense.show_letter("M", text_colour=[0, 0, 255])
time.sleep(1)
sense.show_letter("G", text_colour=[0, 255, 0])
time.sleep(1)
sense.show_letter("!", text_colour=[0, 0, 0], back_colour=[255, 255, 255])
time.sleep(1)
sense.clear()
t = sense.get_temperature()
p = sense.get_pressure()
h = sense.get_humidity()
t = round(t, 1)
p = round(p, 1)
h = round(h, 1)
msg = "Temperature = %s, Pressure=%s, Humidity=%s" % (t, p, h)
## OU SECS Summer Camp
## Adventures in Coding 1
## Summer 2018
## Erik Fredericks
## sense_hello.py
## Now, it's time to do hello world on the Sense hat!
from sense_hat import SenseHat
sense = SenseHat()
sense.show_message("Hello world!")
print 'Could not detect single face! Check the image in capture.pgm' \
' to see what was captured and try again with only one face visible.'
continue
x, y, w, h = result
# Crop and resize image to face.
crop = face.resize(face.crop(image, x, y, w, h))
found = False
for user, model in models:
label, confidence = model.predict(crop)
print 'Predicted {0} face with confidence {1} (lower is more confident).'.format(
'POSITIVE' if label == config.POSITIVE_LABEL else 'NEGATIVE',
confidence), 'for user', user
if label == config.POSITIVE_LABEL and confidence < config.POSITIVE_THRESHOLD:
print 'Recognized face! Hello', user
found = True
sense.set_pixels(tick)
time.sleep(3)
sense.show_message("Hi "+user+"!")
sense.clear()
break
if not found:
print 'Did not recognize face'
sense.set_pixels(cross)
time.sleep(3)
sense.clear()
print "Capture another face to test"
from sense_hat import SenseHat
import time
from time import asctime
sense = SenseHat()
while True:
temp = round(sense.get_temperature()*1.8 +32)
humidity = round(sense.get_humidity())
pressure = round(sense.get_pressure())
message = ' T=%dF, H=%d, P=%d ' %(temp,humidity,pressure)
sense.show_message (message, scroll_speed=(0.08), text_colour=[200,240,200], black_colour= [0,0,0]
time.sleep(4)
log = open('weather.txt',"a")
now = str(asctime())
log.write(now+' '+message+'\n')
print(message)
log.close()
time.sleep(5)
# Magic 8 Ball
import random
import time
from sense_hat import SenseHat
sh = SenseHat()
sh.show_message("Ask a question", scroll_speed=(0.06))
time.sleep(3)
replies = ['Signs point to yes',
'Without a doubt',
'You may rely on it',
'Do not count on it',
'Looking good',
'Cannot predict now',
'It is decidedly so',
'Outlook not so good'
]
<<<<<<< HEAD
sh.show_message(random.choice(replies), scroll_speed=(0.06))
=======
ap.show_message(random.choice(replies), scroll_speed=(0.06))
>>>>>>> origin/master
from sense_hat import SenseHat
sense = SenseHat()
green = (0, 255, 0)
white = (255, 255, 255)
keep_looping = True
while keep_looping:
try:
hum = sense.humidity
print("Hum %: {}".format(hum))
hum_value = 64 * hum / 100
pixels = [green if i < hum_value else white for i in range(64)]
sense.set_pixels(pixels)
except KeyboardInterrupt:
keep_looping = False
sense.show_message("Bye!")
sense.clear()
print("Bye!")
#!/usr/bin/python
from sense_hat import SenseHat
sense = SenseHat()
while True:
t = sense.get_temperature()
p = sense.get_pressure()
h = sense.get_humidity()
t = round(t, 1)
p = round(p, 1)
h = round(h, 1)
if t > 18.3 and t < 26.7:
bg = [0,100,0] #green
else:
bg = [100,0,0] #red
msg = "Temperature = %s, Pressure=%s, Humidity=%s" % (t, p, h)
sense.show_message(msg, scroll_speed=0.05, back_colour=bg)
#!/usr/bin/env python
import sys
import signal
from sense_hat import SenseHat
sense = SenseHat()
def exit_gracefully(signal, frame):
sense.clear()
sys.exit(0)
signal.signal(signal.SIGINT, exit_gracefully)
argv = sys.argv
program_name = argv.pop(0)
argv_string = ' '.join(argv)
print argv_string
sense.show_message(argv_string)
global colour256
colour256 = [225,128,55]
global colour512
colour512 = [0,0,255]
global colour1024
colour1024 = [134,55,10]
global colour2048
colour2048 = [255,255,255]
# Dictionary of colours and their corresponding number
colours = {'2':colour2, '4':colour4,'8':colour8,'16':colour16,
'32':colour32,'64':colour64,'128':colour128,'256':colour256,
'512':colour512,'1024':colour1024,'2048':colour2048}
# Print each colour with its number
for c in sorted(colours,key=lambda k: int(k) if k.isdigit()else float('-inf')):
sh.show_message(c,text_colour=[0,0,0],back_colour=colours[c],scroll_speed=0.03)
global score
score = 0
r = [255,0,0]
g = [0,255,0]
b = [0,0,255]
# define each 4x4 square and the pixels that comprise it
global sq00
sq00 = [(0,0),(0,1),(1,0),(1,1)]
global sq01
sq01 = [(0,2),(0,3),(1,2),(1,3)]
global sq02
sq02 = [(0,4),(0,5),(1,4),(1,5)]
global sq03
sq03 = [(0,6),(0,7),(1,6),(1,7)]
class Sense:
def __init__(self, c8y):
self.sense = SenseHat()
self.c8y = c8y
self.reset = 0
self.resetMax = 3
def send(self):
self.c8y.logger.debug("Sensehat Sending called: ")
self.sendTemperature()
self.sendHumidity()
self.sendPressure()
self.sendAcceleration()
self.sendGyroscope()
self.listenForJoystick()
def sendTemperature(self):
tempString = "211," + str(self.sense.get_temperature())
self.c8y.logger.debug("Sending Temperature measurement: " +
tempString)
self.c8y.publish("s/us", tempString)
def sendHumidity(self):
tempString = "992,," + str(self.sense.get_humidity())
self.c8y.logger.debug("Sending Humidity measurement: " + tempString)
self.c8y.publish("s/uc/pi", tempString)
def sendPressure(self):
tempString = "994,," + str(self.sense.get_pressure())
self.c8y.logger.debug("Sending Pressure measurement: " + tempString)
self.c8y.publish("s/uc/pi", tempString)
def sendAcceleration(self):
acceleration = self.sense.get_accelerometer_raw()
x = acceleration['x']
y = acceleration['y']
z = acceleration['z']
accString = "991,," + str(x) + "," + str(y) + "," + str(z)
self.c8y.logger.debug("Sending Acceleration measurement: " + accString)
self.c8y.publish("s/uc/pi", accString)
def sendGyroscope(self):
o = self.sense.get_orientation()
pitch = o["pitch"]
roll = o["roll"]
yaw = o["yaw"]
gyString = "993,," + str(pitch) + "," + str(roll) + "," + str(yaw)
self.c8y.logger.debug("Sending Gyroscope measurement: " + gyString)
self.c8y.publish("s/uc/pi", gyString)
def displayMessage(self, message):
messageArray = shlex.shlex(message, posix=True)
messageArray.whitespace = ','
messageArray.whitespace_split = True
msg = str(list(messageArray)[-1])
self.c8y.logger.info("Display message: " + msg)
self.sense.show_message(msg)
self.sense.clear
def listenForJoystick(self):
self.c8y.logger.info("listenForJoystick")
for event in self.sense.stick.get_events():
text = "The joystick was {} {}".format(event.action,
event.direction)
self.c8y.logger.debug(text)
self.c8y.publish(
"s/uc/pi", "997,{},,{},{}".format(text, event.action,
event.direction))
if event.action == 'pressed' and event.direction == 'middle':
self.reset
self.resetMax
self.reset += 1
if self.reset >= self.resetMax:
self.c8y.logger.info(
'Resetting c8y.properties initializing re-register device....'
)
self.c8y.reset()
c8y.serviceRestart('Joystick reset')
