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()