def blink_led(color=RED, period=1, n_blinks=3): for blink in range(n_blinks): leds.update(Leds.rgb_off()) sleep(period / 2) leds.update(Leds.rgb_on(color)) sleep(period / 2) leds.update(Leds.rgb_off())
def _run(self): while not self._done.is_set(): joy_score = self._joy_score.value if joy_score > 0: self._leds.update(Leds.rgb_on(blend(JOY_COLOR, SAD_COLOR, joy_score))) else: self._leds.update(Leds.rgb_off())
def send_signal_to_pins(result0, gpio_logic): if 'stop' in result0: pinStatus(pin_A, 'LOW', gpio_logic) pinStatus(pin_B, 'LOW', gpio_logic) pinStatus(pin_C, 'LOW', gpio_logic) leds.update(Leds.rgb_on(RED)) elif 'left' in result0: pinStatus(pin_A, 'LOW', gpio_logic) pinStatus(pin_B, 'LOW', gpio_logic) pinStatus(pin_C, 'HIGH', gpio_logic) leds.update(Leds.rgb_on(BLUE)) elif 'right' in result0: pinStatus(pin_A, 'LOW', gpio_logic) pinStatus(pin_B, 'HIGH', gpio_logic) pinStatus(pin_C, 'LOW', gpio_logic) leds.update(Leds.rgb_on(PURPLE)) elif 'slow' in result0: pinStatus(pin_A, 'LOW', gpio_logic) pinStatus(pin_B, 'HIGH', gpio_logic) pinStatus(pin_C, 'HIGH', gpio_logic) leds.update(Leds.rgb_on(GREEN)) else: pinStatus(pin_A, 'HIGH', gpio_logic) pinStatus(pin_B, 'LOW', gpio_logic) pinStatus(pin_C, 'LOW', gpio_logic) leds.update(Leds.rgb_off()) time.sleep(1)
def process(self, joy_score): if joy_score > 0: self._leds.update( Leds.rgb_on(blend(JOY_COLOR, SAD_COLOR, joy_score))) else: self._leds.update(Leds.rgb_off())
class MultiColorLed: Config = namedtuple('Config', ['channels', 'pattern']) OFF = Config(channels=lambda color: Leds.rgb_off(), pattern=None) ON = Config(channels=Leds.rgb_on, pattern=None) BLINK = Config(channels=Leds.rgb_pattern, pattern=Pattern.blink(500)) BLINK_3 = BLINK BEACON = BLINK BEACON_DARK = BLINK DECAY = BLINK PULSE_SLOW = Config(channels=Leds.rgb_pattern, pattern=Pattern.breathe(500)) PULSE_QUICK = Config(channels=Leds.rgb_pattern, pattern=Pattern.breathe(100)) def _update(self, state, brightness): with self._lock: if state is not None: self._state = state if brightness is not None: self._brightness = brightness color = (int(255 * self._brightness), 0, 0) if self._state.pattern: self._leds.pattern = self._state.pattern self._leds.update(self._state.channels(color)) def __init__(self, channel): self._lock = threading.Lock() self._brightness = 1.0 # Read and written atomically. self._state = self.OFF self._leds = Leds() def close(self): self._leds.reset() def __enter__(self): return self def __exit__(self, exc_type, exc_value, exc_tb): self.close() @property def brightness(self): return self._brightness @brightness.setter def brightness(self, value): if value < 0.0 or value > 1.0: raise ValueError('Brightness must be between 0.0 and 1.0.') self._update(state=None, brightness=value) def _set_state(self, state): self._update(state=state, brightness=None) state = property(None, _set_state)
def main(): button.when_pressed = run leds.update(Leds.rgb_on(WHITE)) try: while True: pass except KeyboardInterrupt: leds.update(Leds.rgb_off()) pass
def main(): button.when_pressed = run leds.update(Leds.rgb_on(WHITE)) manual_screen() while True: for event in pygame.event.get(): if event.type == KEYDOWN: if event.key == K_ESCAPE: leds.update(Leds.rgb_off()) sys.exit()
def run(): if KeepWatchForSeconds(3): print("Going shutdown by GPIO") leds.update(Leds.rgb_off()) os.system("/sbin/shutdown -h now 'Poweroff by GPIO'") else: print("Beep sound") toneplayer.play(*BEEP_SOUND) leds.update(Leds.rgb_on(RED)) print("process") print("Done") leds.update(Leds.rgb_on(WHITE))
def run(): if KeepWatchForSeconds(3): print("Going shutdown by GPIO") leds.update(Leds.rgb_off()) os.system("/sbin/shutdown -h now 'Poweroff by GPIO'") else: print("Beep sound") toneplayer.play(*BEEP_SOUND) leds.update(Leds.rgb_on(RED)) print("Taking photo") sh.cameraLoad() sh.shutter() sh.cameraSave() print("Done") leds.update(Leds.rgb_on(WHITE))
def send_signal_to_servos(result0): if 'stop' in result0: tuned_servoA.value = 0.5 tuned_servoB.value = 0.5 leds.update(Leds.rgb_on(RED)) elif 'left' in result0: tuned_servoA.min() tuned_servoB.min() leds.update(Leds.rgb_on(BLUE)) elif 'right' in result0: tuned_servoA.max() tuned_servoB.max() leds.update(Leds.rgb_on(PURPLE)) elif 'slow' in result0: tuned_servoA.value = 0.6 tuned_servoB.value = 0.3 leds.update(Leds.rgb_on(GREEN)) else: tuned_servoA.max() tuned_servoB.min() leds.update(Leds.rgb_off()) time.sleep(0.002)
def run(): if KeepWatchForSeconds(3): print("Going shutdown by GPIO") leds.update(Leds.rgb_off()) os.system("/sbin/shutdown -h now 'Poweroff by GPIO'") else: print("Beep sound") toneplayer.play(*BEEP_SOUND) leds.update(Leds.rgb_on(RED)) print("Taking photo") with picamera.PiCamera() as camera: camera.resolution = (640, 480) camera.start_preview() sleep(3.000) camera.capture(photo_filename) leds.update(Leds.rgb_on(GREEN)) print("Dish classifier") with ImageInference(dish_classification.model()) as inference: image = Image.open(photo_filename) classes = dish_classification.get_classes( inference.run(image), max_num_objects=5, object_prob_threshold=0.1) dish_name = '' for i, (label, score) in enumerate(classes): dish_name += label + '/' print('Result %d: %s (prob=%f)' % (i, label, score)) leds.update(Leds.rgb_on(BLUE)) print("Post to slack") slack.files.upload(photo_filename, channels='#food_diary', title=dish_name) leds.update(Leds.rgb_on(WHITE))
def main(): with Leds() as leds: print('Windows Up') tuned_servo.min() # blueLED1.blink(.2,.2) # risk of servo burning if kept # blueLED2.blink(.2,.2) leds.pattern = Pattern.blink(500) leds.update(Leds.rgb_pattern(Color.BLUE)) time.sleep(5) print('Windows Down') tuned_servo.max() interior.on() yellowLED.on() leds.pattern = Pattern.breathe(1000) leds.update(Leds.rgb_pattern(Color.YELLOW)) # Fade from yellow to red for i in range(32): color = Color.blend(Color.RED, Color.YELLOW, i / 32) leds.update(Leds.rgb_on(color)) time.sleep(0.1) # leds.update({ # 1: Leds.Channel(Leds.Channel.PATTERN, 64), # 2: Leds.Channel(Leds.Channel.OFF, 128), # 3: Leds.Channel(Leds.Channel.ON, 128), # 4: Leds.Channel(Leds.Channel.PATTERN, 64), # }) time.sleep(5) leds.update(Leds.rgb_off()) tuned_servo.close() yellowLED.close() interior.close() blueLED2.close()
def main(): parser = argparse.ArgumentParser( 'Image classification camera inference example.') parser.add_argument( '--num_frames', '-n', type=int, default=None, help='Sets the number of frames to run for, otherwise runs forever.') parser.add_argument('--num_objects', '-c', type=int, default=3, help='Sets the number of object interences to print.') parser.add_argument('--nopreview', dest='preview', action='store_false', default=True, help='Enable camera preview') args = parser.parse_args() with Leds() as leds: with PiCamera(sensor_mode=4, framerate=30) as camera, \ CameraPreview(camera, enabled=args.preview), \ CameraInference(image_classification.model()) as inference: for result in inference.run(args.num_frames): classes = image_classification.get_classes( result, top_k=args.num_objects) print(classes_info(classes)) #print("my class: "+classes[0][0]) if classes: camera.annotate_text = '%s (%.2f)' % classes[0] if "mouse" in str(classes[0][0]): leds.update(Leds.rgb_on(Color.RED)) else: leds.update(Leds.rgb_off())
def main(): """Face detection camera inference example.""" parser = argparse.ArgumentParser() parser.add_argument( '--label', '-lbl', type=str, dest='label', required=True, help='Specifies the class (label) of training images (e.g. no_hangs).') parser.add_argument('--num_images', '-nimg', type=int, dest='num_images', default=10, help='Sets the number of training images to make.') args = parser.parse_args() with PiCamera() as camera: # Forced sensor mode, 1640x1232, full FoV. See: # https://picamera.readthedocs.io/en/release-1.13/fov.html#sensor-modes # This is the resolution inference run on. camera.sensor_mode = 4 # Scaled and cropped resolution. If different from sensor mode implied # resolution, inference results must be adjusted accordingly. This is # true in particular when camera.start_recording is used to record an # encoded h264 video stream as the Pi encoder can't encode all native # sensor resolutions, or a standard one like 1080p may be desired. camera.resolution = (1640, 1232) # Start the camera stream. camera.framerate = 30 camera.start_preview() # Stage #1: Capture and store raw images # Create foler to store raw images path_to_raw_img_folder = path_to_training_folder + 'raw/' if not os.path.exists(path_to_raw_img_folder): os.makedirs(path_to_raw_img_folder) time.sleep(2) # Create list to store hand boxes location for each image hand_boxes_locations = [] with CameraInference(face_detection.model()) as inference: leds.update(Leds.rgb_on(RED)) time.sleep(3) counter = 1 start = time.time() for result in inference.run(): faces = face_detection.get_faces(result) face = select_face(faces) if face: if counter > args.num_images: break face_box = transform(face.bounding_box) hands = hand_box(face_box) # Capture raw image img_name = path_to_raw_img_folder + 'img' + str( counter) + '.jpg' camera.capture(img_name) time.sleep(0.2) # Record position of hands hand_boxes_locations.append([counter, hands]) print('Captured ', str(counter), " out of ", str(args.num_images)) counter += 1 print('Stage #1: It took', str(round(time.time() - start, 1)), 'sec to record', str(args.num_images), 'raw images') camera.stop_preview() # Stage #2: Crop training images from the raw ones and store them in class (label) subfolder leds.update(Leds.rgb_on(BLUE)) start = time.time() for i, entry in enumerate(hand_boxes_locations): img_number = entry[0] hands = entry[1] raw_img_name = path_to_raw_img_folder + 'img' + str( img_number) + '.jpg' if os.path.isfile(raw_img_name): raw_image = Image.open(raw_img_name) crop_and_store_images(args.label, hands, raw_image) raw_image.close() time.sleep(0.5) os.remove(raw_img_name) print('Processed ', str(i + 1), " out of ", str(args.num_images)) print('Stage #2: It took ', str(round(time.time() - start, 1)), 'sec to process', str(args.num_images), 'images') time.sleep(3) # Delete empty folder for raw images if os.listdir(path_to_raw_img_folder) == []: os.rmdir(path_to_raw_img_folder) leds.update(Leds.rgb_off())
def shutdown(self): self._leds.update(Leds.rgb_off())
def main(): with Leds() as leds: print('RGB: Solid RED for 1 second') leds.update(Leds.rgb_on(Color.RED)) time.sleep(1) print('RGB: Solid GREEN for 1 second') leds.update(Leds.rgb_on(Color.GREEN)) time.sleep(1) print('RGB: Solid YELLOW for 1 second') leds.update(Leds.rgb_on(Color.YELLOW)) time.sleep(1) print('RGB: Solid BLUE for 1 second') leds.update(Leds.rgb_on(Color.BLUE)) time.sleep(1) print('RGB: Solid PURPLE for 1 second') leds.update(Leds.rgb_on(Color.PURPLE)) time.sleep(1) print('RGB: Solid CYAN for 1 second') leds.update(Leds.rgb_on(Color.CYAN)) time.sleep(1) print('RGB: Solid WHITE for 1 second') leds.update(Leds.rgb_on(Color.WHITE)) time.sleep(1) print('RGB: Off for 1 second') leds.update(Leds.rgb_off()) time.sleep(1) for _ in range(3): print('Privacy: On (brightness=default)') leds.update(Leds.privacy_on()) time.sleep(1) print('Privacy: Off') leds.update(Leds.privacy_off()) time.sleep(1) for _ in range(3): print('Privacy: On (brightness=5)') leds.update(Leds.privacy_on(5)) time.sleep(1) print('Privacy: Off') leds.update(Leds.privacy_off()) time.sleep(1) print('Set blink pattern: period=500ms (2Hz)') leds.pattern = Pattern.blink(500) print('RGB: Blink RED for 5 seconds') leds.update(Leds.rgb_pattern(Color.RED)) time.sleep(5) print('RGB: Blink GREEN for 5 seconds') leds.update(Leds.rgb_pattern(Color.GREEN)) time.sleep(5) print('RGB: Blink BLUE for 5 seconds') leds.update(Leds.rgb_pattern(Color.BLUE)) time.sleep(5) print('Set breathe pattern: period=1000ms (1Hz)') leds.pattern = Pattern.breathe(1000) print('RGB: Breathe RED for 5 seconds') leds.update(Leds.rgb_pattern(Color.RED)) time.sleep(5) print('RGB: Breathe GREEN for 5 seconds') leds.update(Leds.rgb_pattern(Color.GREEN)) time.sleep(5) print('RGB: Breathe BLUE for 5 seconds') leds.update(Leds.rgb_pattern(Color.BLUE)) time.sleep(5) print('RGB: Increase RED brightness for 3.2 seconds') for i in range(32): leds.update(Leds.rgb_on((8 * i, 0, 0))) time.sleep(0.1) print('RGB: Decrease RED brightness for 3.2 seconds') for i in reversed(range(32)): leds.update(Leds.rgb_on((8 * i, 0, 0))) time.sleep(0.1) print('RGB: Blend between GREEN and BLUE for 3.2 seconds') for i in range(32): color = Color.blend(Color.BLUE, Color.GREEN, i / 32) leds.update(Leds.rgb_on(color)) time.sleep(0.1) print('RGB: Off for 1 second') leds.update(Leds.rgb_off()) time.sleep(1) print('Privacy: On for 2 seconds') with PrivacyLed(leds): time.sleep(2) print('RGB: Solid GREEN for 2 seconds') with RgbLeds(leds, Leds.rgb_on(Color.GREEN)): time.sleep(2) print('Custom configuration for 5 seconds') leds.update({ 1: Leds.Channel(Leds.Channel.PATTERN, 128), # Red channel 2: Leds.Channel(Leds.Channel.OFF, 0), # Green channel 3: Leds.Channel(Leds.Channel.ON, 128), # Blue channel 4: Leds.Channel(Leds.Channel.PATTERN, 64), # Privacy channel }) time.sleep(5) print('Done')
def main(): parser = argparse.ArgumentParser() parser.add_argument( '--model_path', required=True, help='Path to converted model file that can run on VisionKit.') parser.add_argument( '--label_path', required=True, help='Path to label file that corresponds to the model.') parser.add_argument( '--input_height', type=int, required=True, help='Input height.') parser.add_argument( '--input_width', type=int, required=True, help='Input width.') parser.add_argument( '--input_layer', required=True, help='Name of input layer.') parser.add_argument( '--output_layer', required=True, help='Name of output layer.') parser.add_argument( '--num_frames', type=int, default=-1, help='Sets the number of frames to run for, otherwise runs forever.') parser.add_argument( '--input_mean', type=float, default=128.0, help='Input mean.') parser.add_argument( '--input_std', type=float, default=128.0, help='Input std.') parser.add_argument( '--input_depth', type=int, default=3, help='Input depth.') parser.add_argument( '--threshold', type=float, default=0.6, help='Threshold for classification score (from output tensor).') parser.add_argument( '--preview', action='store_true', default=False, help='Enables camera preview in addition to printing result to terminal.') parser.add_argument( '--gpio_logic', default='NORMAL', help='Indicates if NORMAL or INVERSE logic is used in GPIO pins.') parser.add_argument( '--show_fps', action='store_true', default=False, help='Shows end to end FPS.') args = parser.parse_args() # Model & labels model = ModelDescriptor( name='mobilenet_based_classifier', input_shape=(1, args.input_height, args.input_width, args.input_depth), input_normalizer=(args.input_mean, args.input_std), compute_graph=utils.load_compute_graph(args.model_path)) labels = read_labels(args.label_path) with PiCamera() as camera: # Forced sensor mode, 1640x1232, full FoV. See: # https://picamera.readthedocs.io/en/release-1.13/fov.html#sensor-modes # This is the resolution inference run on. camera.sensor_mode = 4 # Scaled and cropped resolution. If different from sensor mode implied # resolution, inference results must be adjusted accordingly. This is # true in particular when camera.start_recording is used to record an # encoded h264 video stream as the Pi encoder can't encode all native # sensor resolutions, or a standard one like 1080p may be desired. camera.resolution = (1640, 1232) # Start the camera stream. camera.framerate = 30 camera.start_preview() while True: while True: long_buffer = [] short_buffer = [] pinStatus(pin_A,'LOW',args.gpio_logic) pinStatus(pin_B,'LOW',args.gpio_logic) pinStatus(pin_C,'LOW',args.gpio_logic) leds.update(Leds.rgb_on(GREEN)) face_box = detect_face() print("Entered the loop of face classifier") hand_box_params = determine_hand_box_params(face_box) if image_boundary_check(hand_box_params): print("Hand gesture identified") break # Start hand classifier is_active = False leds.update(Leds.rgb_on(PURPLE)) start_timer = time.time() with ImageInference(model) as img_inference: while True: print("Entered the loop of gesture classifier") #check_termination_trigger() if is_active: leds.update(Leds.rgb_on(RED)) hands_image = capture_hands_image(camera,hand_box_params) output = classify_hand_gestures(img_inference,hands_image,model=model,labels=labels,output_layer=args.output_layer,threshold = args.threshold) short_guess, num_short_guess = buffer_update(output,short_buffer,short_buffer_length) long_guess, num_long_guess = buffer_update(output,long_buffer,long_buffer_length) # Activation of classifier if (long_guess == activation_index or long_guess == deactivation_index) and not is_active and num_long_guess >= (long_buffer_length - 3): is_active = True leds.update(Leds.rgb_on(RED)) send_signal_to_pins(activation_index,args.gpio_logic) long_buffer = [] num_long_guess = 0 time.sleep(1) # Deactivation of classifier (go back to stable face detection) if (long_guess == activation_index or long_guess == deactivation_index) and is_active and num_long_guess >= (long_buffer_length - 3): is_active = False leds.update(Leds.rgb_off()) long_buffer = [] num_long_guess = 0 send_signal_to_pins(deactivation_index,args.gpio_logic) time.sleep(1) break # If not activated within max_no_activity_period seconds, go back to stable face detection if not is_active: timer = time.time()-start_timer if timer >= max_no_activity_period: leds.update(Leds.rgb_off()) send_signal_to_pins(deactivation_index,args.gpio_logic) time.sleep(1) break else: start_timer = time.time() # Displaying classified hand gesture commands if num_short_guess >= (short_buffer_length-1) and is_active: print_hand_command(short_guess) send_signal_to_pins(short_guess,args.gpio_logic) camera.stop_preview()
def check_termination_trigger(): if button.is_pressed: print('Terinating session...') leds.update(Leds.rgb_off()) time.sleep(5) os.system("sudo shutdown -h now")
def main(): global video_thread global audio_thread global tmp_dir global final_dir # Creates tmp directory if does not exist tmp_dir = os.path.expanduser(tmp_dir) if(os.path.isdir(tmp_dir) == False): print("Can't find tmp media directory, creating...") os.mkdir(tmp_dir) # Creates final media directory if does not exist final_dir = os.path.expanduser(final_dir) if(os.path.isdir(final_dir) == False): print("Can't find media directory, creating...") os.mkdir(final_dir) # Initializes threads video_thread = VideoRecorder(timestamp_fontcolor=colors.WHITE, timestamp_pos=(10,50)) # optional params (defaults) : # res_x=640, # res_y=480, # framerate=25, # timestamp=True, # timestamp_pos=(50,50), # timestamp_fontcolor=(255, 255, 255), # timestamp_fontthickness=1, # timestamp_fontsize=1, # timestamp_format="%d/%m/%Y, %H:%M:%S" audio_thread = AudioRecorder(device=1) # optional params (defaults) : # device=0, # channels=2, # samplerate=44100 # Allows time for camera to boot up time.sleep(2) # button.when_pressed = record_ten_seconds button.when_pressed = toggle_recording print("ready for action!") with Leds() as leds: while True: if recording: leds.update(Leds.rgb_off()) for i in range(8): leds.update(Leds.rgb_on((2 * i, 0, 0))) time.sleep(0.1) for i in reversed(range(8)): leds.update(Leds.rgb_on((2 * i, 0, 0))) time.sleep(0.1) else: leds.update(Leds.rgb_off()) for i in range(8): leds.update(Leds.rgb_on((0, 2 * i, 0))) time.sleep(0.1) for i in reversed(range(8)): leds.update(Leds.rgb_on((0, 2 * i, 0))) time.sleep(0.1)
def main(): """Face detection camera inference example.""" parser = argparse.ArgumentParser() parser.add_argument( '--num_frames', '-n', type=int, dest='num_frames', default=-1, help='Sets the number of frames to run for, otherwise runs forever.') args = parser.parse_args() blink_led(color=BLUE, period=0.5, n_blinks=10) # Initialize variables for automatic shutdown shuttdown_flag = False min_frames_w_arduino_power = 10 max_frames_w_no_arduino_power = 10 counter_frames_w_power = 0 counter_frames_w_no_power = 0 focal_length = 1320 # focal length in pixels for 1640 x 1232 resolution - found by calibration camera_resolution = (1640, 1232) x_center = int(camera_resolution[0] / 2) real_face_width_inch = 11 # width/height of bounding box of human face in inches min_angle = atan2( -x_center, focal_length ) # min angle where face can be detected (leftmost area) in radians max_angle = atan2( x_center, focal_length ) # max angle where face can be detected (rightmost area) in radians min_distance = 20 # min distance to detected face in inches max_distance = 200 # max distance to detected face in inches face_detected_on_prev_frame = False # Flag indicated if face was detected on the previous frame a = (0.9 - 0.2) / ( max_distance - min_distance ) # Coefficient a (slope) for coding distance value from range [min_distance, max_distance] to [0.2, 0.9] b = 0.9 - a * max_distance # Coefficient b (intercept) for coding distance value from range [min_distance, max_distance] to [0.2, 0.9] with PiCamera() as camera: # Forced sensor mode, 1640x1232, full FoV. See: # https://picamera.readthedocs.io/en/release-1.13/fov.html#sensor-modes # This is the resolution inference run on. camera.sensor_mode = 4 # Scaled and cropped resolution. If different from sensor mode implied # resolution, inference results must be adjusted accordingly. This is # true in particular when camera.start_recording is used to record an # encoded h264 video stream as the Pi encoder can't encode all native # sensor resolutions, or a standard one like 1080p may be desired. camera.resolution = camera_resolution # Start the camera stream. camera.framerate = 30 #camera.start_preview() # Calculate face data (x_mean, y_mean, width, height). def face_data(face): x, y, width, height = face.bounding_box x_mean = int(x + width / 2) angle = atan2(x_mean - x_center, focal_length) distance = 0 if width > 0: distance = focal_length * real_face_width_inch / width return angle, distance with CameraInference(face_detection.model()) as inference: for i, result in enumerate(inference.run()): if i == args.num_frames: break faces = face_detection.get_faces(result) face = select_face(faces) if face: if face_detected_on_prev_frame: angle, distance = face_data(face) if angle < min_angle: angle = min_angle if angle > max_angle: angle = max_angle angle_to_send = (angle - min_angle) / (max_angle - min_angle) pin_A.value = 0.8 * angle_to_send + 0.1 if distance < min_distance: distance = min_distance if distance > max_distance: distance = max_distance pin_B.value = a * distance + b leds.update(Leds.rgb_on(GREEN)) face_detected_on_prev_frame = True else: if not face_detected_on_prev_frame: pin_A.value = 0.5 pin_B.value = 0.1 leds.update(Leds.rgb_off()) face_detected_on_prev_frame = False clock = i % 80 + 11 pin_C.value = clock / 100 print('Iteration #', str(i), ' A=', str(pin_A.value), ' B=', str(pin_B.value), ' C=', str(pin_C.value), ' D=', str(pin_D.value)) print('face_detected_on_prev_frame = ', face_detected_on_prev_frame) if pin_D.is_pressed: counter_frames_w_no_power += 1 else: counter_frames_w_power += 1 print('released, shuttdown_flag = ', shuttdown_flag, ' frames with power=', str(counter_frames_w_power)) print('pressed, shuttdown_flag = ', shuttdown_flag, ' frames with no power=', str(counter_frames_w_no_power)) if counter_frames_w_power >= min_frames_w_arduino_power and not shuttdown_flag: shuttdown_flag = True counter_frames_w_no_power = 0 if counter_frames_w_no_power >= max_frames_w_no_arduino_power and shuttdown_flag: shut_aiy_kit_down() sleep(0.1)
def process(self, joy_score): if joy_score > 0: self._leds.update(Leds.rgb_on(Color.blend(JOY_COLOR, SAD_COLOR, joy_score))) else: self._leds.update(Leds.rgb_off())
def main_loop(self): while True: with Leds() as leds: leds.update(Leds.rgb_on(Color.RED)) with Board() as board: print("Waiting for input") board.button.wait_for_press() leds.update(Leds.rgb_on((0, 0, 250))) #print('ON') self.start = True self.counter = 0 self.completed = False self.stopwatch = time.time() board.button.wait_for_release() #print('OFF') leds.update(Leds.rgb_off()) while self.start: classes = currentState #print("current State: ", classes) if classes == 0 and self.state != 0: self.standing() elif classes == 1 and self.state != 1: self.empty() elif classes == 2 and self.state != 2 and self.last_detected_state != 2: self.squat() # Selecting a State if (time.time()-self.stopwatch) > 0.15: print("State:\t ",states_names[self.state] , "\t| [selected]") if self.state == 2 and self.last_detected_state != 2: # Squat detected self.counter += 1 leds.update(Leds.rgb_on((0, 0, 250))) self._newSqaut() #print("### Current Score: ", self.counter,"###") if self.state == 2 or self.state == 0: #self.stopwatch = time.time() leds.update(Leds.rgb_on(Color.WHITE)) if self.state == 1 and ((time.time()-self.stopwatch) > 1): leds.update(Leds.rgb_off()) self.last_detected_state = self.state # Resting the counter if nobody is in the frame if (time.time()-self.stopwatch) > 10: if self.state == 1: # if nobody is in the frame reset counter print("### Reset Score ###") self.counter = 0 self.start = False leds.pattern = Pattern.blink(500) leds.update(Leds.rgb_pattern(Color.RED)) time.sleep(2) leds.update(Leds.rgb_off()) self.stopwatch = time.time() # Checking of the finish if self.counter >= TOTAL_SQUATS: self.completed = True self.output.on() self.counter = 0 print("Completed Workout") self.start = False leds.pattern = Pattern.blink(500) leds.update(Leds.rgb_pattern(Color.GREEN)) time.sleep(2) leds.update(Leds.rgb_on(Color.GREEN)) with Board() as board: print("Waiting for input") board.button.wait_for_press() print('ON') board.led.state = Led.ON self.start = False self.counter = 0 self.completed = False self.stopwatch = time.time() board.button.wait_for_release() print('OFF') self.output.off() board.led.state = Led.OFF leds.pattern = Pattern.blink(500) leds.update(Leds.rgb_pattern(Color.RED)) time.sleep(2) leds.update(Leds.rgb_off())
time.sleep(1) print('RGB: Solid PURPLE for 1 second') leds.update(Leds.rgb_on(PURPLE)) time.sleep(1) print('RGB: Solid CYAN for 1 second') leds.update(Leds.rgb_on(CYAN)) time.sleep(1) print('RGB: Solid WHITE for 1 second') leds.update(Leds.rgb_on(WHITE)) time.sleep(1) print('RGB: Off for 1 second') leds.update(Leds.rgb_off()) time.sleep(1) for _ in range(3): print('Privacy: On (brightness=default)') leds.update(Leds.privacy_on()) time.sleep(1) print('Privacy: Off') leds.update(Leds.privacy_off()) time.sleep(1) for _ in range(3): print('Privacy: On (brightness=5)') leds.update(Leds.privacy_on(5)) time.sleep(1) print('Privacy: Off')
def blink_led(color=RED,period=1,num_blinks=5): for _ in range(num_blinks): leds.update(Leds.rgb_on(color)) time.sleep(period/2) leds.update(Leds.rgb_off()) time.sleep(period/2)