def make_packet_plan(self, starting_snake_length=None): L, H, D = self.light_dimensions packets = [] if self.macro_mode == 0: colors_rgb = [ Lights.rgb_from_color(x) for x in self.current_colors ] if self.select_mode == 0: # blocks packet = Lights.get_blocks_packet(colors_rgb, self.light_dimensions) packets.append(packet) # for i in range(L): # packets.append(Lights.shift_packet(packet, i, right=True)) elif self.select_mode == 1: # alternating packet = Lights.get_alternating_packet(colors_rgb, self.light_dimensions, self.segment_size) packets.append(packet) # for i in range(len(colors_rgb)): # for j in range(self.segment_size): # packets.append(Lights.shift_packet(packet, i * self.segment_size + j + 1, right=True)) elif self.macro_mode == 1: # chase game kwargs = {} if self.chase_game is not None: kwargs['is_3d'] = self.chase_game.is_3d kwargs['num_enemies'] = self.chase_game.num_enemies kwargs[ 'wall_density_divisor_index'] = self.chase_game.wall_density_divisor_index self.chase_game = ChaseGame(self.logger, self.light_dimensions, self.light_sender, gui=self.gui, **kwargs) self.chase_game.make_new_game() packets.append(self.chase_game.draw_game_board()) elif self.macro_mode == 2: # snake game if self.snake_game is not None: self.snake_game = SnakeGame.create_new(self.snake_game, self.light_dimensions) else: self.snake_game = SnakeGame(self.logger, self.light_dimensions, self.light_sender, gui=self.gui) self.snake_game.make_new_game( starting_snake_length=starting_snake_length) packets.append(self.snake_game.draw_game_board()) return PacketPlan(packets)
def cozmo_program(robot: cozmo.robot.Robot): f = Face(robot) f.find_person() d = Drive(robot) weather = Weather(f.city) weather.set_outfit() welcome = Welcome(robot) welcome.hello(weather.w, weather.outfit, f.city, f.name) e = input() if e == "exit": robot.say_text("Goodbye") else: l = Lights() l.set_lights(d, weather.number) d.find(weather.number)
def update_lights(self): # grab the current index for all active plans and merge those plans together # if there are no active plans left, then set to black if self.current_packet_plans: packets_to_merge = [x.get_current_packet() for x in self.current_packet_plans] try: packet = Lights.merge_packets(packets_to_merge, self.light_dimensions) except IndexError: self.logger.warning('Index error when merging packets, likely due to light dimensions being reallocated. Setting to black for now and expecting it to fix itself next time around') packet = Lights.make_whole_string_packet((0, 0, 0), self.light_dimensions) else: packet = Lights.make_whole_string_packet((0, 0, 0), self.light_dimensions) # invoke light updater self.light_sender.set_lights(self.name, packet)
def __init__(self): self.datapoints = [] self.measured_value = 0 # TODO Rufe den Konstruktor von MTTFCalculator (s. Datei MTTF) # auf und speichere das Objekt in der Instanzvariable "self.mttf_calculator". # Tipp: Konstruktoren werden mit "Klassenname()" aufgerufen. # Ein Beispiel ist die Definition von "self.rule_checker" weiter unten. self.estimated_value = self.ask_for_estimated_value() # TODO Rufe die von dir erstelle Methode auf, die nach der Standardabweichung fragt # und speichere das Ergebnis in "self.standard_deviation". # Tipp: Schau dir die Definition vom Erwartungswert ("estimated_value") an. self.rule_checker = WesternDigitalRuleChecker(self.estimated_value, self.standard_deviation) self.lights = Lights(17, 27, 22)
def main(): parser = argparse.ArgumentParser() parser.add_argument( "--input", "-i", help="Parameter required to provide input to the program", action="store_true") parser.add_argument("filename", help="Complete path for the file") args = parser.parse_args() filePath = args.filename if args.input: count = "" if filePath.startswith("http:"): response = requests.get(filePath) with open('input.txt', 'w') as fout: fout.writelines(response.text) fout.close() filePath = 'input.txt' with open(filePath) as fin: L = int(fin.readline()) if L > 0: _lights = Lights(L) regex = re.compile( ".*(turn on|turn off|switch)\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*through\s*([+-]?\d+)\s*,\s*([+-]?\d+).*" ) for i in fin.readlines(): result = regex.search(i) if result != None: method = str(result.group(1)) # print(method.strip()) l1 = int(result.group(2)) l2 = int(result.group(3)) l3 = int(result.group(4)) l4 = int(result.group(5)) if l1 < 0: l1 = 0 if l3 < 0: l3 = 0 if l2 > L: l2 = L - 1 if l4 > L: l4 = L - 1 _lights.runCmd(method, l1, l2, l3, l4) count = _lights.counts() print(count)
def run_lights(self): self.current_packet_plan = Lights.make_interlude_packet_plan( self.light_dimensions) self.current_packet_plan_index = 0 self.last_motion_step_time = datetime.now() # invoke light updater self.light_sender.set_lights( self.name, self.current_packet_plan[self.current_packet_plan_index])
def on_button_pressed(self, button): super().on_button_pressed(button) # when a drum is hit, light up in that color color = self.get_friendly_button_name(button) self.logger.info(f"{color} press") if color in ['red', 'yellow', 'blue', 'green', 'orange']: L, H, D = self.light_dimensions if self.mode == 0: # Make the pulse plan and multiply by the appropriate dimming mask packet_plan = Lights.make_pulse_packet_plan( color_rgb=Lights.rgb_from_color(color), light_dimensions=self.light_dimensions ) packet_plan = Lights.apply_dim_plan(packet_plan, [self.color_masks[color]]*len(packet_plan)) self.current_packet_plans.append(PacketPlan(packet_plan, time_delay=self.time_delay)) elif self.mode == 1: try: for starting_point in self.color_spread_map[color]["starts"]: packet_plan = Lights.make_meteor_packet_plan( color_rgb=Lights.rgb_from_color(color), light_dimensions=self.light_dimensions, start_pixel=starting_point, pulse_size=self.color_spread_map[color]["pulse"] ) self.current_packet_plans.append(PacketPlan(packet_plan, time_delay=self.time_delay)) except KeyError: self.logger.error('Error finding color starting point for mode 1. Skipping for now and will try again next time') elif color == 'plus': self.mode = 0 if self.mode == 1 else self.mode + 1 self.light_sender.write_log_entry(self.name, f"mode_{self.mode}_active") elif color == 'minus': self.mode = 1 if self.mode == 0 else self.mode - 1 self.light_sender.write_log_entry(self.name, f"mode_{self.mode}_active")
def run(): print("Tap your magic band!") rfid_reader = RFIDReader() lights = Lights() if rfid_reader.read() == True: lights.turn_on() time.sleep(2) lights.turn_off()
def update_lights(self): # invoke light updater new_packet = self.main_packet_plan.get_current_packet() if self.temp_packet_plans: packets_to_merge = [new_packet] + [ x.get_current_packet() for x in self.temp_packet_plans ] try: new_packet = Lights.merge_packets(packets_to_merge, self.light_dimensions) except IndexError: self.logger.warning( 'Index error when merging packets, likely due to light dimensions being reallocated. Skipping merge and using main packet instead and expecting it to fix itself next time around' ) self.light_sender.set_lights(self.name, new_packet)
def draw_game_board(self): L, H, D = self.light_dimensions packet = Lights.make_whole_string_packet( Lights.rgb_from_color('white'), self.light_dimensions, scale_value=0.05) snake_colors = Lights.make_gradient_colors( len(self.snake), Lights.rgb_from_color('green'), Lights.rgb_from_color('yellow')) for s, item in enumerate(self.snake): k, j, i = item packet[i][j][k] = snake_colors[s] k, j, i = self.target packet[i][j][k] = Lights.rgb_from_color('teal') return packet
def __init__(self, controller, logger, name, light_dimensions, light_sender, gui): super().__init__(controller, logger, name, light_dimensions, light_sender, gui) self.select_mode = 0 self.selector_position = None self.dim_ratio = None self.motion_direction_list = ['right', 'up', 'forward', 'left', 'down', 'backward'] self.motion_direction_index = 0 self.current_colors = [] self.current_motion_colors = [] self.main_packet_plan = PacketPlan([Lights.make_whole_string_packet((0, 0, 0), self.light_dimensions)]) for button in controller.buttons: button.when_pressed = self.on_button_pressed button.when_released = self.on_button_released for axis in controller.axes: if self.get_friendly_axis_name(axis.name) == 'selector': # initialize selector switch _, self.selector_position = self.get_axis_details(axis) self.main_packet_plan.time_delay = self.get_time_delay_from_selector_position(self.selector_position) axis.when_moved = self.on_axis_moved
def draw_game_board(self): L, H, D = self.light_dimensions packet = Lights.make_whole_string_packet( Lights.rgb_from_color('white'), self.light_dimensions, scale_value=0.1) for wall in self.walls: k, j, i = wall packet[i][j][k] = Lights.rgb_from_color('yellow') k, j, i = self.target_pixel packet[i][j][k] = Lights.rgb_from_color('green') k, j, i = self.chase_pixel packet[i][j][k] = Lights.rgb_from_color('blue') for enemy in self.enemies: k, j, i = enemy packet[i][j][k] = Lights.rgb_from_color('red') return packet
def next_moving_step(self, current_time): pulse_plan = None if (current_time - self.last_motion_step_time ).total_seconds() >= self.speed_time_delay: hit_boundary, hit_self, hit_target = self.move_one_step() self.last_motion_step_time = current_time # if hit boundary, pulse red and start the game over by making a new board if hit_boundary: pulse_plan = PacketPlan(Lights.make_pulse_packet_plan( Lights.rgb_from_color('red'), self.light_dimensions, frames=6), time_delay=0.05) self.make_new_game() # if hit snake, pulse orange and start the game over by making a new board elif hit_self: pulse_plan = PacketPlan(Lights.make_pulse_packet_plan( Lights.rgb_from_color('orange'), self.light_dimensions, frames=6), time_delay=0.05) self.make_new_game() # if caught the next bite, quick pulse green and make a new target elif hit_target: pulse_plan = PacketPlan(Lights.make_pulse_packet_plan( Lights.rgb_from_color('green'), self.light_dimensions, frames=3), time_delay=0.05) self.target = self.make_target() # draw the board packet = self.draw_game_board() return packet, pulse_plan
def next_moving_step(self, current_time, left=None, right=None, forward=None, backward=None, desired_height=None): pulse_plan = None if not self.is_3d: forward = False backward = False if left or right or forward or backward or self.chase_pixel[ 1] + 1 != desired_height: reached_target, hit_walls, hit_enemy = self.move_chase_pixel( left=left, right=right, forward=forward, backward=backward, height_val=desired_height) if hit_enemy: # make a brand new game board self.logger.info(f'Hit enemy at location: {self.chase_pixel}') self.chase_pixel = (0, 0, 0) self.make_new_game(chase_position=self.chase_pixel) packet = self.draw_game_board() pulse_plan = PacketPlan(Lights.make_pulse_packet_plan( Lights.rgb_from_color('red'), self.light_dimensions, frames=6), time_delay=0.05) return packet, pulse_plan if reached_target: # make a new game board but keep the chase pixel and the enemies in current locations self.logger.info( f'Reached target at location: {self.chase_pixel}') self.make_new_game(chase_position=self.chase_pixel, create_new_enemies=False) packet = self.draw_game_board() pulse_plan = PacketPlan(Lights.make_pulse_packet_plan( Lights.rgb_from_color('green'), self.light_dimensions, frames=6), time_delay=0.05) return packet, pulse_plan if (current_time - self.last_motion_step_time_enemy ).total_seconds() >= self.enemy_time_delay: self.last_motion_step_time_enemy = current_time any_hit_target = False new_enemies = [] for enemy in self.enemies: if not any_hit_target: # if an earlier one hit the target, then don't check the next ones, just keep them where they are new_enemy, enemy_reached_target, enemy_hit_walls = self.move_enemy_pixel( enemy) if enemy_reached_target: # this means the enemy moved onto the chase pixel and we should flash red and make a new game board any_hit_target = True self.chase_pixel = (0, 0, 0) self.make_new_game(chase_position=self.chase_pixel) packet = self.draw_game_board() pulse_plan = PacketPlan(Lights.make_pulse_packet_plan( Lights.rgb_from_color('red'), self.light_dimensions, frames=6), time_delay=0.05) return packet, pulse_plan else: # just keep the enemy where it is as the starting point for next time since a different one hit the target new_enemy = enemy # add the enemy back to the list new_enemies.append(new_enemy) self.enemies = new_enemies packet = self.draw_game_board() return packet, pulse_plan
def run_lights(self, color_list, mode=0): L, H, D = self.light_dimensions num_colors = len(color_list) if num_colors == 0: packet_plan = PacketPlan([Lights.make_whole_string_packet((0, 0, 0), self.light_dimensions)]) else: colors_rgb = [Lights.rgb_from_color(x) for x in color_list] if mode == 0: # lights form 1 block of each color that was pressed packet_plan = PacketPlan([Lights.get_blocks_packet(colors_rgb, self.light_dimensions)]) elif mode == 1: # lights alternate statically with each color that was pressed pixel by pixel packet_plan = PacketPlan([Lights.get_alternating_packet(colors_rgb, self.light_dimensions)]) else: # moving modes packets = [] motion_dirs = self.motion_direction_list[self.motion_direction_index].split('_') dir_kw_args = {x: True for x in motion_dirs} if mode == 2: # the lights in the string scroll perpetually in the same pattern as mode 1 packet = Lights.get_blocks_packet(colors_rgb, self.light_dimensions) for i in range(L): packets.append(Lights.shift_packet(packet, i, **dir_kw_args)) elif mode == 3: # the lights in the string scroll perpetually in the same pattern as mode 0 packet = Lights.get_alternating_packet(colors_rgb, self.light_dimensions) for i in range(len(colors_rgb)): packets.append(Lights.shift_packet(packet, i, **dir_kw_args)) elif mode == 4: # the lights wipe on and off, in color blocks like in mode 0 packet = Lights.get_blocks_packet(colors_rgb, self.light_dimensions) packets = Lights.make_wipe_plan(packet, motion_dirs[0]) elif mode == 5: # the lights wipe on and off, alternating like in mode 1 packet = Lights.get_alternating_packet(colors_rgb, self.light_dimensions) packets = Lights.make_wipe_plan(packet, motion_dirs[0]) packet_plan = PacketPlan(packets, is_repeating=True, time_delay=self.get_time_delay_from_selector_position(self.selector_position)) self.main_packet_plan = packet_plan # check whammy position and dim accordingly new_packet = self.dim_packet(self.main_packet_plan.get_current_packet(), self.dim_ratio) # invoke light updater self.light_sender.set_lights(self.name, new_packet)
class QASystem: def __init__(self): self.datapoints = [] self.measured_value = 0 # TODO Rufe den Konstruktor von MTTFCalculator (s. Datei MTTF) # auf und speichere das Objekt in der Instanzvariable "self.mttf_calculator". # Tipp: Konstruktoren werden mit "Klassenname()" aufgerufen. # Ein Beispiel ist die Definition von "self.rule_checker" weiter unten. self.estimated_value = self.ask_for_estimated_value() # TODO Rufe die von dir erstelle Methode auf, die nach der Standardabweichung fragt # und speichere das Ergebnis in "self.standard_deviation". # Tipp: Schau dir die Definition vom Erwartungswert ("estimated_value") an. self.rule_checker = WesternDigitalRuleChecker(self.estimated_value, self.standard_deviation) self.lights = Lights(17, 27, 22) def ask_for_estimated_value(self): """Asks for the estimated value and returns the user input""" #TODO Erstelle eine Eingabeaufforderung die nach dem Erwartungswert fragt und gebe diesen zurueck. # Achte darauf, dass das Ergebnis eine Gleitkommazahl ist. # Das "pass" kann hier geloscht werden, wenn du deinen Code einfuegst. pass # TODO Erstelle eine Methode, die den Nutzer um die Standardabweichung # bittet und diese als Gleitkommazahl zurueckgibt. # Tipp: Schau dir die Definition von der ask_for_estimated_value-Funktion an. def handle_input(self, value): """Wird aufgerufen, wenn ein neuer Messpunkt eingegeben wurde""" self.measured_value = value self.datapoints.append(self.measured_value) if (not self.rule_checker.check_rule_1(self.datapoints)): print("Rule 1 failed") # TODO Wenn diese Regel nicht eingehalten wird, # ist das Werkstueck nicht nutzbar. Zeige dies mit der roten Lampe an. self.handle_error() elif (not self.rule_checker.check_rule_2(self.datapoints)): print("Rule 2 failed") self.handle_error() elif (not self.rule_checker.check_rule_3(self.datapoints)): print("Rule 3 failed") self.handle_error() # TODO Vervollstaendige die if-Abfrage um einen Test fuer die 4. Regel. else: #Datapoint is good self.lights.turn_green_light_on() def handle_error(self): """Diese Methode wird aufgerufen, wenn ein Fehler festgestellt wurde.""" # TODO Stelle sicher, dass die Lampen in der richtigen Konfiguration leuchten. # Welche Lampen sind evenutell noch auszuschalten, welche eventuell anzuschalten? # TODO Berechne den alten MTTF # TODO Haenge die Anzahl der erfolgreich produzierten Stuecke an die failures Liste (mttf-Objekt) an. # TODO Berechne die neue MTTF. self.mttf_calculator.write_to_file() # TODO Gebe die alte und neue MTTF ueber die Konsole aus. self.datapoints = [] self.measured_value = 0 # TODO Frage den Nutzer, ob die Produktion fortgesetzt werden soll. # Wenn ja, soll die Ampel entsprechend zurueckgesetzt werden. # Wenn nein, soll der Nutzer wieder gefragt werden. # Tipp: "while(true):" erstellt eine Endlosschleife. # Die Ausfuehrung einer Schleife kann mit dem Befehl "break" beendet werden. while (True): if (eingabe == "ja"): self.lights.turn
import json from Lights import Lights, LightStates from TV import TV, TVStates from flask import Flask, render_template, current_app, request from flask_ask import Ask, statement app = Flask(__name__) ask = Ask(app, '/remote/') light_thread = Lights(1, "Lights-1", 1) light_thread.start() tv_thread = TV(2, "Tv-1", 2) tv_thread.start() @ask.launch def launch(): message = "Hello Kaylie. I am the Alexa Remote. " \ "You can ask me to power on or off the tv, turn volume up or down, and change inputs. " \ "What would you like to do?" return statement(message) @ask.intent('TVPowerOn') def power_on(): if tv_thread.power_tv(True): message = "TV has been turned on" else: message = "TV is already on" return statement(message)
__author__ = 'sander' from Lights import Lights str = "get light kitchen" print(str.split(" ")) test = Lights() print(test.get_lights())
import numpy as np import sys, time import signal import Utils as u from Process import Processor from Trigger import Trigger from Parse import Parser import config haveLeds = config.device == "mypi" proc = Processor() parser = Parser() if haveLeds: from Lights import Lights led = Lights() led.stop() tr = Trigger(verbose=True, led=led, AMBIENT_MULT = 1.9) else: tr = Trigger(verbose=True) # proc.processTrainingSet(basedir="sounds/train/", signalword="oknavsa", savedir="data/") # proc.processTrainingSet(basedir="16khz/", signalword="oknavsa", savedir="data/") proc.loadTrainData("data/imagedata_15_15.npy") #if not in this range, we want to not fingerprint it to save time and trouble lower,upper = proc.getKeywordDurationRange() tr.setParams({"MIN_WORD_TIME": lower, "MAX_WORD_TIME": upper}) tr.setParams({"THRESHOLD": 150}) # tr.getAmbientLevels(duration=0.7)
def next_moving_step(self, current_time): # determine when a sequence should be shifted right = False left = False up = False down = False forward = False backward = False changed = False enemy_changed = False # handle current temp packet plans indexes_to_remove = [] for i, packet_plan in enumerate(self.temp_packet_plans): is_advanced, is_ended = packet_plan.advance_packet_plan( current_time) if is_advanced: changed = True if is_ended: indexes_to_remove.append(i) indexes_to_remove.sort(reverse=True) for ind in indexes_to_remove: try: self.temp_packet_plans.pop(ind) except IndexError: pass if self.macro_mode == 0: # if direction is not None, that means some control is engaged so we want motion # if the current_time is greater than the last motion time by at least the time_delay amount, then we need to do a motion step if self.wheel_direction is not None and ( current_time - self.last_motion_step_time_wheel ).total_seconds() >= self.wheel_time_delay: self.last_motion_step_time_wheel = current_time if self.wheel_direction == 'right': right = True else: left = True changed = True # gas pedal behavior changes between macro modes as does paddle shifter behavior # in mode 0, it controls the speed of motion and the reverse button controls direction up or down # in mode 1, it controls height above the bottom, with gravity pulling the pixel back down when the gas pedal is released if self.macro_mode == 0: if self.gas_direction is not None and ( current_time - self.last_motion_step_time_gas ).total_seconds() >= self.gas_time_delay: self.last_motion_step_time_gas = current_time up = True changed = True if self.brake_direction is not None and ( current_time - self.last_motion_step_time_brake ).total_seconds() >= self.brake_time_delay: self.last_motion_step_time_brake = current_time down = True changed = True if self.paddle_direction is not None and ( current_time - self.last_motion_step_time_paddle ).total_seconds() >= self.paddle_time_delay: self.last_motion_step_time_paddle = current_time if self.paddle_direction == 'forward': forward = True else: backward = True changed = True if changed: # shift the sequence packet = Lights.shift_packet( self.main_packet_plan.get_current_packet(), 1, left=left, right=right, up=up, down=down, forward=forward, backward=backward) self.main_packet_plan = PacketPlan([packet]) self.main_packet_plan.last_motion_step_time = current_time self.update_lights() elif self.macro_mode == 1 and self.chase_game is not None: if self.wheel_direction is not None and ( current_time - self.last_motion_step_time_wheel ).total_seconds() >= self.wheel_time_delay: self.last_motion_step_time_wheel = current_time if self.wheel_direction == 'right': right = True else: left = True H = self.light_dimensions[1] desired_height = round(self.current_gas_value * H) if self.paddle_click_direction is not None: if self.paddle_click_direction == 'forward': forward = True else: backward = True self.paddle_click_direction = None # for chase game, we always need to call out because there might be enemy movement even if no controller input packet, pulse_plan = self.chase_game.next_moving_step( current_time, left=left, right=right, forward=forward, backward=backward, desired_height=desired_height) if pulse_plan is not None: self.temp_packet_plans.append(pulse_plan) if packet is not None: self.main_packet_plan = PacketPlan([packet]) self.main_packet_plan.last_motion_step_time = current_time self.update_lights() elif self.macro_mode == 2 and self.snake_game is not None: # for snake game, just call out to the game and let it decide what to do since all direction input is asynchronously set packet, pulse_plan = self.snake_game.next_moving_step(current_time) if pulse_plan is not None: self.temp_packet_plans.append(pulse_plan) if packet is not None: self.main_packet_plan = PacketPlan([packet]) self.main_packet_plan.last_motion_step_time = current_time self.update_lights()