def main():
try:
# initialize sensors and output modules
lcd = RPi_I2C_driver.lcd()
red_led = LED(GPIO_PINS['red_led'])
green_led = LED(GPIO_PINS['green_led'])
button = Button(GPIO_PINS['button'])
while True:
# wait for button to be pressed to take image
button.wait_for_press()
# capture image from camera
img_fp = capture_image()
# detect if person has face mask or not
mask_detected = detect_face_mask(img_fp)
if mask_detected:
# flash green led and display on LCD
lcd.lcd_display_string("Access granted!", 1)
green_led.on()
sleep(3)
lcd.lcd_clear()
green_led.off()
else:
# flash red led and display on LCD
lcd.lcd_display_string("Access denied!", 1)
red_led.on()
sleep(3)
lcd.lcd_clear()
red_led.off()
except KeyboardInterrupt:
print("[INFO] Terminating")
class Camera:
def __init__(self, DIR_PATH, FILE_NAME):
self.DIR_PATH = DIR_PATH
self.FILE_NAME = FILE_NAME
self.button = Button(21)
self.camera = PiCamera()
def getPicture(self):
subprocess.run(
['omxplayer', '-o', 'local', self.DIR_PATH + '/notification.mp3'])
self.camera.start_preview()
self.camera.resolution = (800, 480)
#self.camera.start_preview(fullscreen=False, window=(100, 20, 640, 480))
self.button.wait_for_press()
self.camera.capture(self.DIR_PATH + '/' + self.FILE_NAME)
subprocess.run(
['omxplayer', '-o', 'local', self.DIR_PATH + '/camera_click.mp3'])
self.camera.stop_preview()
def getPreview(self):
self.camera.start_preview()
def run(self):
self.getPicture()
def getBtn(self):
return self.button
class Fallo():
def __init__(self, index):
self.pin = pines_out[index]
self.led = LED(pines_out[index])
self.button = Button(pines_in[index])
self.estado = False
self.swich = True
def run(self):
while self.swich:
if self.button.is_pressed:
if not self.estado:
self.estado = True
fails = Fail.objects.filter(pin=self.pin)
for f in fails:
f.activo = True
f.save()
else:
if self.estado:
fails = Fail.objects.filter(pin=self.pin)
for f in fails:
f.activo = False
f.save()
self.estado = False
self.button.wait_for_press()
self.press()
def press(self):
print('press: ' + str(self.pin))
self.led.on()
sleep(3)
self.led.off()
def getbuttonpress(bid):
""" Check if button has been pressed yet. If so turn off LED """
button = Button(buttonpins[bid])
button.wait_for_press(10)
buttonoff(bid)
bidtime = time.time()
return bidtime
def wait_button():
button = Button(21)
button.wait_for_press()
camera.stop_recording()
camera.close()
os.system("sudo shutdown now")
exit(1)
def button_led2():
led = LED(2)
button = Button(3)
while True:
button.wait_for_press()
sleep(.1)
led.toggle()
sleep(.1)
def shutdownButton():
button_2 = Button(23, pull_up=True)
button_2.wait_for_press()
speak("Herrunterfahren...")
time.sleep(3)
quitThread()
call("mpg123 -q snd/Robot_dying.mp3", shell=True)
call("/sbin/poweroff &", shell=True)
class Camera(object):
def __init__(self):
self.button = Button(17)
self.camera = PiCamera()
def start(self, save_to_file):
print('Ready to take Photo press button...')
self.button.wait_for_press()
print('Button pressed, taking photo!')
self.camera.capture(save_to_file)
def button_pressed_with_pause_until_press(gpio=""):
from gpiozero import Button
# note how this method is called
# vs how the is_pressed method
button = Button(gpio)
button.wait_for_press()
print("This only runs once the button has been pressed")
print(
"Should be very valuable for have a series of steps with buttons\nstarting or stopping the code"
)
class Data:
from gpiozero import Button
def __init__(self, args: Namespace) -> None:
self.__pin = Button(args.datapin,
pull_up=None,
active_state=not args.invert)
def recv(self) -> int:
return self.__pin.value
def wait(self) -> None:
self.__pin.wait_for_press()
def record_voice():
# globals
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 44100
CHUNK = 1024
RECORD_SECONDS = 3
button = Button(27)
led = LED(18)
# start recording
audio = pyaudio.PyAudio()
stream = audio.open(format=FORMAT,
channels=CHANNELS,
rate=RATE,
input=True,
frames_per_buffer=CHUNK)
# print("recording...")
frames = []
# record for RECORD_SECONDS
button.wait_for_press()
led.on()
while button.is_pressed:
# for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
data = stream.read(CHUNK, exception_on_overflow=False)
frames.append(data)
led.off()
# print("finished recording")
# stop Recording
stream.stop_stream()
stream.close()
audio.terminate()
# write your new .wav file with built in Python 3 Wave module
waveFile = wave.open("out.wav", 'wb')
waveFile.setnchannels(CHANNELS)
waveFile.setsampwidth(audio.get_sample_size(FORMAT))
waveFile.setframerate(RATE)
waveFile.writeframes(b''.join(frames))
waveFile.close()
# stt
s = Serializer()
with open("out.wav", "rb") as fin:
r = requests.post(url="http://192.168.1.172:8000/transcribe",
data={"audio": s.serialize(fin.read())})
print(r.json())
return r.json()["msg"]
def takephoto():
from gpiozero import Button
button = Button(2)
camera = picamera.PiCamera()
sleep(2)
camera.rotation = 180
camera.start_preview()
camera.preview_fullscreen = False
camera.preview_window = (0, 0, 1024, 768)
print("Press the button")
button.wait_for_press()
camera.capture('image.jpg')
sleep(2)
camera.stop_preview()
def main(win):
win.nodelay(True)
shots = Shots()
button = Button(25)
while True:
try:
key = win.getkey()
if key == os.linesep:
break
button.wait_for_press()
shots.choose_random_shots()
except Exception as e:
pass
class ButtonLED(object):
def __init__(self, ledPin, buttonPin):
self.led = LED(ledPin)
self.button = Button(buttonPin)
def on(self):
self.led.on()
def off(self):
self.led.off()
def wait(self, timeout):
self.button.wait_for_press(timeout)
return self.button.is_pressed
def commission_test_repair_switch(switch_name,pin_number):
sleep(.5)
button = Button(pin_number)
def switch_up():
print(switch_name+' up')
lcd_text(switch_name+' up')
button.when_pressed = switch_up
def switch_down():
print(switch_name+' down')
lcd_text(switch_name+' down')
button.when_released = switch_down
print('test ' +switch_name)
lcd_text('test ' +switch_name)
if button.wait_for_press(3):
if button.wait_for_release(3):
print("it works")
return button
else:
print("it failed release")
del button
return commission_test_repair_switch(switch_name,pin_number)
else:
print("it failed press")
del button
return commission_test_repair_switch(switch_name,pin_number)
def record_audio():
button = Button(17)
button.wait_for_press()
# recording setup
CHUNK = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 16000
RECORD_SECONDS = 5
WAVE_OUTPUT_FILENAME = "voice.wav"
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paInt16,
channels=CHANNELS,
rate=RATE,
input=True,
frames_per_buffer=CHUNK)
frames = []
print("* recording")
time.sleep(0.5)
# read in data
while True:
data = stream.read(CHUNK)
frames.append(data)
if button.is_pressed:
break
print("* done recording")
stream.stop_stream()
stream.close()
p.terminate()
wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
wf.setnchannels(CHANNELS)
wf.setsampwidth(p.get_sample_size(FORMAT))
wf.setframerate(RATE)
wf.writeframes(b''.join(frames))
wf.close()
return
class Track(object):
def __init__(self, controller):
self.controller = controller
self.logger = logging.getLogger(__name__)
track_pin = 17
self.button = Button(track_pin)
_thread.start_new_thread(self._toggle_track, ())
def _toggle_track(self):
"""
that's the callback function that toggles tracking
"""
while True:
self.button.wait_for_press()
self.logger.debug("toggle tracking")
self.controller.toggle_tracking()
sleep(0.5)
def commission_test_repair_roating_button(button_name,right_pin_number,left_pin_number,button_pin_number):
sleep(.5)
right = Button(right_pin_number)
left = Button(left_pin_number)
button = Button(button_pin_number)
def left_test():
if left.is_pressed:
print(button_name+' left')
lcd_text(button_name+' left')
right.when_pressed = left_test
def right_test():
if right.is_pressed:
print(button_name+' right')
lcd_text(button_name+' right')
left.when_pressed = right_test
def button_pressed():
print(button_name+' pushed')
lcd_text(button_name+' pushed')
button.when_pressed = button_pressed
print('test ' +button_name+' right left press')
lcd_text('test ' +button_name+'\nright left\n press')
if left.wait_for_press(3):
if right.is_pressed:
if right.wait_for_press(3):
if left.is_pressed:
if button.wait_for_press(3):
print("it works")
return right, left, button;
else:
del right, left, button;
return commission_test_repair_roating_button(button_name,right_pin_number,left_pin_number,button_pin_number)
else:
del right, left, button;
return commission_test_repair_roating_button(button_name,right_pin_number,left_pin_number,button_pin_number)
else:
del right, left, button;
return commission_test_repair_roating_button(button_name,right_pin_number,left_pin_number,button_pin_number)
else:
del right, left, button;
return commission_test_repair_roating_button(button_name,right_pin_number,left_pin_number,button_pin_number)
else:
del right, left, button;
return commission_test_repair_roating_button(button_name,right_pin_number,left_pin_number,button_pin_number)
def startInternal():
mode = internal(settings.getVoteTimeSetting(),settings.getVoteCycleSetting())
print("press again to start voting")
internalButton = Button(15,pull_up=False)
internalButton.wait_for_press()
internalButton
playNextSong = input("1.update\n 2.start voting\n")
if playNextSong == "2" or "start voting":
print(str(settings.voteTimeSetting) + " " + " seconds to vote!")
mode.startVoting()
time.sleep(float(settings.getVoteTimeSetting()))
print(playSong())
mode.continueWatching()
elif playNextSong == "1" or "update":
mode.updateInternal()
playSong()
mode.continueWatching()
def listen(gpio_num, log_path, *args):
button = Button(gpio_num)
def pressed():
#print( " Button Pressed " )
listen.press_start = time.time()
def released():
#print( " Button released " )
listen.press_end = time.time()
button.wait_for_press()
pressed()
button.wait_for_release()
released()
duration = listen.press_end - listen.press_start
print(duration)
log_button_presss(log_path, duration)
def main():
"""
Blinks an LED on and off forever
"""
parser = argparse.ArgumentParser(
description='Turn an LED on when a button is pressed')
parser.add_argument('--led',
'-l',
type=str,
default="GPIO17",
help='The pin the LED is connected to')
parser.add_argument('--button',
'-b',
type=str,
default="GPIO27",
help='The pin the button is connected to')
parser.add_argument('--blink-when-ready',
default=False,
dest='blink',
action='store_true',
help='If set, blink the LED when GPIO is ready')
args = parser.parse_args()
led = LED(args.led)
button = Button(args.button)
print('Ready for interaction!')
if args.blink:
for _ in range(1, 5):
led.on()
sleep(0.5)
led.off()
sleep(0.5)
while True:
button.wait_for_press()
print('Button Pressed! Turning led ON...')
led.on()
button.wait_for_release()
print('Button released! Turning led OFF...')
led.off()
def main():
"""
Main method.
:return:
"""
api = init_tweepy_api()
photo_path = ""
count = 1
#while count > 0:
button = Button(17)
camera = PiCamera()
camera.start_preview()
while True:
count -= 1
try:
#curtime, photo_name = click_camera_cli()
curtime = datetime.now()
now = curtime.strftime('%Y%m%d-%H%M%S')
photo_name = now + '.jpg'
# Take a picture upon button press
print "Starting camera preview"
print "Is button pressed: " + str(button.is_pressed)
button.wait_for_press()
print "Button pressed"
photo_path = '/home/pi/' + photo_name
camera.capture(photo_path)
print "Photo taken " + photo_path
#camera.stop_preview()
# Send the tweet with photo
print "Tweeting pic at : " + photo_path
status = 'Photo auto-tweet from Smart Tree: ' + curtime.strftime(
'%Y/%m/%d %H:%M:%S')
api.update_with_media(photo_path, status=status)
sleep(10)
# Delete pic after successful upload
cleanup_pic(photo_path)
except:
# Catch all errors and continue looping
print "Unexpected error:", sys.exc_info()
cleanup_pic(photo_path)
def main():
"""
Main method.
:return:
"""
api = init_tweepy_api()
photo_path = ""
count = 1
#while count > 0:
button = Button(17)
camera = PiCamera()
camera.start_preview()
while True:
count -= 1
try:
#curtime, photo_name = click_camera_cli()
curtime = datetime.now()
now = curtime.strftime('%Y%m%d-%H%M%S')
photo_name = now + '.jpg'
# Take a picture upon button press
print "Starting camera preview"
print "Is button pressed: " + str(button.is_pressed)
button.wait_for_press()
print "Button pressed"
photo_path = '/home/pi/' + photo_name
camera.capture(photo_path)
print "Photo taken " + photo_path
#camera.stop_preview()
# Send the tweet with photo
print "Tweeting pic at : " + photo_path
status = 'Photo auto-tweet from Smart Tree: ' + curtime.strftime('%Y/%m/%d %H:%M:%S')
api.update_with_media(photo_path, status=status)
sleep(10)
# Delete pic after successful upload
cleanup_pic(photo_path)
except:
# Catch all errors and continue looping
print "Unexpected error:", sys.exc_info()
cleanup_pic(photo_path)
class ButtonPressRelease:
def __init__(self):
self.button = Button(2)
self.led = PWMLED(17)
def continuously_listen(self):
while True:
if self.button.is_pressed:
self.print_message_pressed()
else:
self.print_message_released()
def wait_for_being_pressed(self):
self.button.wait_for_press()
self.print_message_pressed(False)
def when_pressed_or_released_print_something(self):
self.button.when_pressed = self.print_message_pressed
self.button.when_released = self.print_message_released
pause()
def turn_on_off_led(self):
self.button.when_released = self.turn_off_led
self.button.when_pressed = self.led_pulse
pause()
def print_message_pressed(self, is_continous=True):
if is_continous:
tense = "is"
else:
tense = "was"
print("Button " + tense + " pressed.")
def print_message_released(self):
print("Button is released.")
def led_pulse(self):
self.print_message_pressed(True)
self.led.pulse()
def turn_off_led(self):
self.print_message_released()
self.led.off()
def setup():
'''
Setup the Raspberry Pi to run
@return list of threads
@return vehicle object
'''
skipStart, calibrate = parseArgs()
if not skipStart:
print("Waiting for start")
startButton = Button(Constants.START_BUTTON_PIN)
startButton.wait_for_press()
print("Started")
# Start button has been pressed, so continue setup
#courseMap = CourseMap()
courseMap = WallMap()
# Construct Threads
# TODO: Untie threads
dataConsumerThread = DataConsumerThread(daemon=True)
sensorConversionThread = SensorConversion(
daemon=True, dataConsumerThread=dataConsumerThread)
controlPlannerThread = ControlPlanner(
daemon=True,
courseMap=courseMap,
sensorConversionThread=sensorConversionThread)
vehicle = Vehicle(sensorConversionThread)
# TODO: IMPORTANT: Send 0.5 pulse before start button
# Register Subscribers
controlPlannerThread.register(vehicle, vehicle.updateGoals)
# Start threads
dataConsumerThread.start()
sensorConversionThread.start()
controlPlannerThread.start()
performIMUCalibration(calibrate, dataConsumerThread)
Constants.MAP_HEADING_OFFSET = math.radians(
Constants.HEADING_WRAP_AROUND - dataConsumerThread.sensors.heading)
print("Heading Offset = {0} deg".format(
math.degrees(Constants.MAP_HEADING_OFFSET)))
return [dataConsumerThread, sensorConversionThread,
controlPlannerThread], vehicle
def main():
FLASH = flash.Flash(3)
BUTTON = Button(14)
while True:
BUTTON.wait_for_press()
print('Capturing...')
fileName = 'image ' + datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S') + '.png'
FLASH.on()
raspEYE.takePicture(fileName, sec=0, res=(1000, 750))
FLASH.off()
print('Finished')
def main(device_id, verbose):
logging.basicConfig(level=logging.DEBUG if verbose else logging.INFO)
with open("credentials.json", "r") as f:
credentials = google.oauth2.credentials.Credentials(**json.load(f))
http_request = google.auth.transport.requests.Request()
credentials.refresh(http_request)
grpc_channel = google.auth.transport.grpc.secure_authorized_channel(
credentials, http_request, ASSISTANT_API_ENDPOINT
)
logging.info("Connecting to %s", ASSISTANT_API_ENDPOINT)
audio_sink = audio_source = audio_helpers.SoundDeviceStream(
sample_rate=audio_helpers.DEFAULT_AUDIO_SAMPLE_RATE,
sample_width=audio_helpers.DEFAULT_AUDIO_SAMPLE_WIDTH,
block_size=audio_helpers.DEFAULT_AUDIO_DEVICE_BLOCK_SIZE,
flush_size=audio_helpers.DEFAULT_AUDIO_DEVICE_FLUSH_SIZE,
)
# Create conversation stream with the given audio source and sink.
conversation_stream = audio_helpers.ConversationStream(
source=audio_source,
sink=audio_sink,
iter_size=audio_helpers.DEFAULT_AUDIO_ITER_SIZE,
sample_width=audio_helpers.DEFAULT_AUDIO_SAMPLE_WIDTH,
)
trigger = Button(INPUT_PIN, pull_up=False)
with Assistant(device_id, conversation_stream, grpc_channel) as assistant:
print('Waiting for trigger...')
trigger.wait_for_press()
print('Triggered!')
while trigger.is_pressed:
print('Running assist')
assistant.assist()
print('Done with assist')
def main():
button = Button(5)
red=LED(2)
amber=LED(17)
green=LED(11)
button.wait_for_press()
red.on()
amber.on()
green.on()
with PiCamera() as camera:
timestamp = datetime.now().isoformat()
photo_path = '/home/pi/push-button-photo/photos/%s.jpg' % timestamp
camera.start_preview()
sleep(1)
red.off()
amber.on()
green.on()
sleep(1)
red.off()
amber.off()
green.on()
sleep(1)
red.off()
amber.off()
green.off()
camera.capture(photo_path)
camera.stop_preview()
message = "I have been taking photos with code..."
with open(photo_path, 'rb') as photo:
twitter.update_status_with_media(status=message, media=photo)
print("Tweeted: %s" % message)
def commission_test_repair_button(button_name,pin_number):
sleep(.5)
button = Button(pin_number)
def button_pressed():
print(button_name+' pressed')
lcd_text(button_name+'\nwas pressed')
button.when_pressed = button_pressed
print('press ' +button_name)
lcd_text('press ' +button_name)
while not button.wait_for_press(3):
del button
button = Button(pin_number)
button.when_pressed = button_pressed
print(button_name+' repaired')
return button
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Tue Apr 17 16:04:15 2018
@author: Gregor
"""
from picamera import PiCamera
from time import sleep
from gpiozero import Button
button = Button(21)
camera = PiCamera()
camera.start_preview()
button.wait_for_press()
camera.capture('/home/pi/image3.jpg')
camera.stop_preview()
from gpiozero import LED, Button
import socket
#Configuração inicial para comunicação
ipServidor = '192.168.0.110'
porta = 8080 #Valor ficticio
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((ipServidor, porta))
#Configuração GPIO
btn = Button(25, pull_up=True)
ld = LED(18)
while True:
btn.wait_for_press()
s.send('Pressionado')
serv_info = s.recv(4096)
if serv_info == 'led_on': #Mensagem recebida pelo servidor
ld.on()
btn.wait_for_release()
s.send('Solto')
serv_info = s.recv(4096)
if serv_info == 'led_off': #Mensagem recebida pelo servidor
ld.off()
from gpiozero import LED, Button
from time import sleep
from random import uniform
# Declare LED at GPIO 4
led = LED(4)
# Declare buttons at GPIO 14 (top) and 15 (bottom)
top_button = Button(14)
bottom_button = Button(15)
# Main program
while True:
top_button.wait_for_press()
#on_duration = uniform(1,4)
#print('on for {:f} seconds' .format(on_duration) )
led.on()
#sleep(on_duration)
top_button.wait_for_release()
#off_duration = uniform(.5,1)
#print('off for {:f} seconds' .format(off_duration) )
led.off()
#sleep(off_duration)
# check if a button is pressed
from gpiozero import Button
button = Button(2)
while True:
if button.is_pressed:
print("Button is pressed")
else:
print("Button is not pressed")
"""
# Wait for a button to be pressed before continuing:
from gpiozero import Button
button = Button(2)
button.wait_for_press()
print("Button was pressed")
# Run a function every time the button is pressed:
from gpiozero import Button
from signal import pause
def say_hello():
print("Hello!")
button = Button(2)
button.when_pressed = say_hello
pause()
with PiCamera() as camera:
#camera.start_preview()
path, dirs, files = os.walk('/home/pi/photo_output').next()
file_count = len(files)
print (file_count)
frame = 1 + file_count
while True:
if stop.is_pressed:
draw.rectangle((0,0,LCD.LCDWIDTH,LCD.LCDHEIGHT), outline=255, fill=255)
draw.text((3,20), 'Safe stop', font=font)
disp.image(image)
disp.display()
time.sleep(2)
subprocess.call('sudo halt', shell=True)
button.wait_for_press()
yellow.source = button.values
draw.rectangle((0,0,LCD.LCDWIDTH,LCD.LCDHEIGHT), outline=255, fill=255)
#disp.image(image)
disp.display()
draw.text((3,0),'Taking ....', font=font)
disp.image(image)
disp.display()
print ("About to capture photo")
camera.capture('/home/pi/photo_output/frame%03d.jpg' % frame)
print (frame)
draw.text((3,10),'Frames taken:', font=font)
draw.text((10,20), str(frame), font=font)
draw.text((0,30), str(startup), font=font)
disp.image(image)
disp.display()
subprocess.run(['raspistill', '-n', '-t', '2s', '-o', '/tmp/out.jpeg'], check=True)
subprocess.run(['convert', '/tmp/out.jpeg', '-resize', '128x64!', '/tmp/small.jpeg'])
img = Image.open('/tmp/small.jpeg').convert('1')
screen.display_image(img)
def release():
led.off()
with open('db_config.json') as inf:
dbconfig = json.load(inf)
repo = TemperatureRepository(**dbconfig)
temp_reader = BME280()
lux_reader = TSL2561()
button.when_pressed = button_press
button.when_released = release
try:
while True:
temp = temp_reader.read()
repo.insert_temp(temp)
lux = lux_reader.read()
repo.insert_lux(lux)
button.wait_for_press(300)
except KeyboardInterrupt:
button.close()
led.close()
# Create instance of StrikeZone
detectZone = StrikeZone()
#Now initialize sensors
for index, horizPin in enumerate(HORIZ_GPIO_PINS):
horizSensors.append(LightSensor(horizPin,
queue_len = QUEUE_LEN,
charge_time_limit = CHARGE_TIME))
horizSensors[index].when_dark = detectZone.horizDark
horizSensors[index].when_light = detectZone.horizLight
for index, vertPin in enumerate(VERT_GPIO_PINS):
vertSensors.append(LightSensor(vertPin,
queue_len = QUEUE_LEN,
charge_time_limit = CHARGE_TIME))
vertSensors[index].when_dark = detectZone.vertDark
vertSensors[index].when_light = detectZone.vertLight
while True:
if pitchButton.wait_for_press(10):
#Button was pressed
detectZone.start()
sleep(1)
elif detectZone.waitForPitch:
# If ready for pitch but got timeout
# Tell strikezone it was a ball an reset
detectZone.ball()
except KeyboardInterrupt:
print("Thanks for playing...")
# wait for button event before continuing....
from gpiozero import Button
btn = Button(4)
btn.wait_for_press()
print("Button was pressed")
quizfilename = "quiz.txt"
start_button = Button(23)
true_button = Button(22)
false_button = Button(4)
# Initialise display
lcd_init()
# Send some test
lcd_string("Raspberry Pi",LCD_LINE_1)
lcd_string("True or False quiz",LCD_LINE_2)
lcd_string("",LCD_LINE_3)
lcd_string("Press start",LCD_LINE_4)
start_button.wait_for_press()
# Note that there is no error handling of file not exist
# Consider using a try except block
# Open the file
file = open(quizfilename)
questions = 0
score = 0
answer = ''
while True:
# print 4 lines as the questions
thisline = file.readline().rstrip("\n")
if thisline == "" : break
lcd_string(thisline,LCD_LINE_1)
sleep(n)
for i in range(150):
strip.setPixelColor(i,Color(0,0,0))
strip.show()
sleep(n)
if __name__ == '__main__':
strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS)
strip.begin()
try:
lights = ['pink','yellow','blue','green']
while True:
green.wait_for_press()
for i in range(16):
for light in lights:
neo(light,0.1)
random.shuffle(lights)
print(lights)
sleep(0.5)
player = []
for light in lights:
neo(light,0.3)
for i in range(150):
strip.setPixelColor(i,Color(0,0,0))
strip.show()
while len(player) <4:
sleep(0.3)
if green.is_pressed:
global last_capture
dt = datetime.now().isoformat()
filename = '/home/pi/photobooth/{}.jpg'.format(dt)
camera.capture(filename)
last_capture = filename
def tweet(message, img):
with open(img, 'rb') as photo:
twitter.update_status_with_media(status=message, media=photo)
left.when_pressed = change_effect
while True:
camera.start_preview()
camera.annotate_text = "Press left button to change the effect"
sleep(2)
camera.annotate_text = "Press right button to take a picture"
sleep(2)
camera.annotate_text = None
right.wait_for_press()
capture()
camera.annotate_text = "Press right button to tweet the photo"
right.wait_for_press()
camera.stop_preview()
handle = input("Enter your Twitter handle: @")
message = "Welcome to @Raspberry_Pi Towers, @{}".format(handle)
tweet(message, last_capture)
camera.start_preview()
camera.annotate_text = "Tweeted!"
sleep(2)
life2.off()
life3.off()
lives = 3
life_counter(lives)
while True:
time.sleep(0.01)
for i in range(2):
buzzer.on()
time.sleep(0.5)
buzzer.off()
time.sleep(0.5)
while lives > 0:
time.sleep(0.01)
tool.wait_for_press()
for i in range(3):
buzzer.on()
time.sleep(0.2)
buzzer.off()
time.sleep(0.2)
time.sleep(0.1)
print("You lost a life")
lives = lives - 1
life_counter(lives)
if lives == 0:
print("Game Over")
time.sleep(3)
lives=3
life_counter(lives)
camera.start_preview()
camera.annotate_text = "Press red button to post to Twitter"
rightbutton.wait_for_press()
camera.annotate_text = ""
camera.capture(photo_path)
camera.stop_preview()
photo_tweet(photo_path)
sleep(5)
while True:
#replace with you video, always needs to reestablish variable or won't loop video
player = OMXPlayer("test.mov")
print("Press the left button to play")
rightbutton.when_pressed = player.pause
leftbutton.wait_for_press()
player.play()
print(player.playback_status())
try:
while player.playback_status():
if player.playback_status() == "Paused":
terrorcam()
except:
pass
print("Waiting for motion")
pir.wait_for_motion()
tweetpic()
