def go(): b = blinkstick.find_first() b.set_color(name='blue') async def tally(): while True: try: async with websockets.connect(config.url) as websocket: await websocket.send(config.me) while True: data = await websocket.recv() data = json.loads(data) if data is None: b.turn_off() else: b.set_color( name='red' if config.me in data else 'white') except Exception as e: print('network error') b.turn_off() time.sleep(5) asyncio.get_event_loop().run_until_complete(tally())
def demo_hourly(): bstick = blinkstick.find_first() # Do processing needed to update blinkstick [output how/where?] #code goes here with status to [syslog?] # Get "state" of blinkstick from one of its two [registers?] #code goes here with "old state" to [syslog?] # Turn blinkstick off bstick.turn_off() # Update blinkstick with info from processing done "not long ago" for x in range(5): bstick.set_random_color() print bstick.get_serial() + " " + bstick.get_color(color_format="hex") time.sleep(0.5) # with "new state" to [syslog?] # Restore "state" of blinkstick bstick.turn_off() # Log status print bstick.get_serial() + " turned off"
def __init__(self): from blinkstick import blinkstick self.bstick = blinkstick.find_first() if self.bstick is None: print "No BlinkSticks found..." time.sleep(10) sys.exit(1)
def main(): color1 = (0.05, 1, 0.98) # These are in hsv format color2 = (0.08, 0.95, 1) speed = 10 # Speed of the animation width = 15 # Width of the stripes. Lower = wider. fps = 50.0 # FPS of the animation. 50 is about the upper limit. ### END OPTIONS ### stk = blinkstick.find_first() cnt = stk.get_led_count() while True: data = [] for i in range(cnt): fac = math.sin((time.time()) * speed + i * width) / 2 + 0.5 hue = color1[0] + (color2[0] - color1[0]) * fac sat = color1[1] + (color2[1] - color1[1]) * fac val = color1[2] + (color2[2] - color1[2]) * fac r, g, b = colorsys.hsv_to_rgb(hue, sat, val) data = data + [ int(g * 255), int(r * 255), int(b * 255), ] # Convert to GRB and add to the frame. stk.set_led_data(0, data) # Send off to the blinkstick time.sleep(1 / fps) # Nap for a bit so we don't overwhelm the blinkstick.
def process_user_commands(): working_flag = True with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen(10) conn, addr = s.accept() with conn: print('Connected by', addr) while True: data = conn.recv(1024) if not data: # conn.sendall(b'empty command') break syslog.syslog(syslog.LOG_CRIT, 'chainvu_test data: {0}'.format(data)) command = data.decode("utf-8") if (command == 'led'): led = blinkstick.find_first() led.set_color(name = 'red') #working_flag = False #conn.sendall(b'done') #conn.sendto(b'done', addr) else: working_flag = True
def __init__(self, channel): self.animator = threading.Thread(target=self._animate) self.channel = channel self.iterator = None self.running = False self.state = None self.last_known_state = None self.sleep = 0 self.max_pwm = 100 GPIO.setup(channel, GPIO.OUT) # GPIO pin 25 by default self.pwm = GPIO.PWM(channel, self.max_pwm) # Find the first BlinkStick self.max_brightness = 255 self.bstick = blinkstick.find_first() # Set the color red on the 1st LED of G channel to OFF self.led_index = 0 self.led_channel = 1 # Ensure the LED is OFF after boot self.bstick.set_color( channel=self.led_channel, index=self.led_index, name="black") # Default LED colour self.base_red = 255 self.base_green = 0 self.base_blue = 0
def __new__(cls, *args, **kwargs): led = blinkstick.find_first() if InternetCheck() is True: print("Internet is up!") led.set_color(name="green") elif InternetCheck() is False: print("Internet is down") led.set_color("red")
def setup(self): """ Setup this sink. Returns True if a BlinkStick is found """ if not has_blinkstick: return False self.blinkstick = blinkstick.find_first() # TODO support more than one BlinkStick (and configuration) if self.blinkstick is not None: return True
def __init__(self, name, role, sn=None, max_power=0.1, inversed=False, **kwargs): """ sn (None or str): serial number. If None, it will pick the first device found. max_power (0<float): maxium power emitted in W. """ model.Emitter.__init__(self, name, role, **kwargs) self._sn = sn self._max_power = max_power # Just find the first BlinkStick led controller if sn is None: self._bstick = blinkstick.find_first() else: # Note: doesn't work with v1.1.7: # need fix on get_string(), reported here: https://github.com/arvydas/blinkstick-python/pull/35 logging.warning( "Using sn to select the device doesn't currently work") self._bstick = blinkstick.find_by_serial(sn) if self._bstick is None: raise HwError( "Failed to find a Blinkstick for component %s. " "Check that the device is connected to the computer." % (name, )) self._bstick.set_inverse(inversed) time.sleep(0.1) # Device apparently needs some time to recover self._shape = () # list of 5-tuples of floats self.spectra = model.ListVA([(380e-9, 390e-9, 560e-9, 730e-9, 740e-9)], unit="m", readonly=True) self.power = model.ListContinuous([ 0., ], ((0., ), (max_power, )), unit="W", cls=(int, long, float), setter=self._setPower) self.power.subscribe(self._updatePower, init=True) self._swVersion = "Blinkstick v%s" % (blinkstick.__version__, ) # These functions report wrong values on Linux with v1.1.7 # man = self._bstick.get_manufacturer() # desc = self._bstick.get_description() # rsn = self._bstick.get_serial() man = self._bstick.device.manufacturer desc = self._bstick.device.product rsn = self._bstick.device.serial_number self._hwVersion = "%s %s (s/n: %s)" % (man, desc, rsn)
def __init__(self, reader, n, pupdate=None, pcl=None): self.lights = [] for i in range(n): self.lights.append(Light(blinkstick.find_first())) self.programReader = reader if pupdate: self.PUPDATE = pupdate if pcl: self.PCL = pcl
def __init__(self): """Initializes a BlinkStick controller""" try: from blinkstick import blinkstick except ImportError as e: print('Unable to import the blinkstick library') print('You can install this library with `pip install blinkstick`') raise e self.stick = blinkstick.find_first()
def main(): ### START OPTIONS ### speed = 2 # Overall speed of the animation popspeed = 4 # Speed of the flickers/pops ### END OPTIONS ### # try to find the blinkstick try: stk = blinkstick.find_first() cnt = stk.get_led_count() print("It's lit bruv. Press CTRL-C to turn down.") # exit if not found except: print("Blinkstick not detected. Is it plugged in?") exit(0) #### START MAIN LOOP #### errors = 0 while True: data = [] for i in range(cnt): x = time() * speed # Base speed control y = x + i # For some variation from LED to LED z = x * popspeed + i ** 2 # For the sporadic flickering hue = ( (sin(y / 0.4) + sin(y / 0.2) + sin(y / 0.5)) / 6 + 0.5 ) * 0.06 # Main color hueplus = max( (sin(z) + sin(z / 3.0) + sin(z / 7.0)) / 5 - 0.4, 0 ) # Flicker r, g, b = hsv_to_rgb( min(hue + hueplus, 0.07), 1.0 - hueplus, sin(z) / 8 + 0.875 ) # Convert to RGB # print(hueplus, r, g, b) data = data + [ int(g * 255), int(r * 255), int(b * 255), ] # Convert to GRB and add to the frame. # try to write the colors to the strip try: stk.set_led_data(0, data) # if there's an error, increment the error counter and try again except: errors += 1 # if we accumulate more than 10 errors without a successful write, # strip is probably unplugged, so exit program if errors > 15: print("Looks like we've been unplugged!") exit(0) # else if write successful, reset the error counter else: errors = 0 sleep(0.02) # Nap for a bit so we don't overwhelm the blinkstick.
def main(): ### START OPTIONS ### speed = 1 # Overall speed of the animation. ff_speed = 5 # Speed of the fireflies. fps = 50.0 # FPS of the animation. 50 is about the upper limit. ### END OPTIONS ### # try to find the blinkstick try: stk = blinkstick.find_first() cnt = stk.get_led_count() print("It's lit bruv. Press CTRL-C to turn down.") # exit if not found except: print("Blinkstick not detected. Is it plugged in?") exit(0) #### START MAIN LOOP #### errors = 0 while True: data = [] for i in range(cnt): x = time.time() * speed # Base speed control y = x + i # For a bit of random color for the flies. z = x * ff_speed + i**2 # Firefly speed control ff_glow = max( (sin(z) + sin(z / 3.0) + sin(z / 7.0)) / 5 - 0.4, 0 ) # Flicker. Honestly with this math I just threw stuff at the wall on desmos.com to see what stuck. r, g, b = colorsys.hsv_to_rgb(0.10 + (sin(y) / 32 + 0.03125), 1.0 - ff_glow * 1.3, ff_glow * 5) # Convert to RGB. # print(hueplus, r, g, b) data = data + [ int(g * 255), int(r * 255), int(b * 255), ] # Convert to GRB and add to the frame. # try to write the colors to the strip try: stk.set_led_data(0, data) # if there's an error, increment the error counter and try again except: errors += 1 # if we accumulate more than 10 errors without a successful write, # strip is probably unplugged, so exit program if errors > 15: print("Looks like we've been unplugged!") exit(0) # else if write successful, reset the error counter else: errors = 0 time.sleep(1 / fps) # Nap for a bit so we don't overwhelm the blinkstick.
def turn_off_sequence(red=0, green=0, blue=255, step=0.1): try: turn_all_on(red, green, blue) led = blinkstick.find_first() for i in range(32, -1, -1): led.set_color(channel=0, index=i, red=0, green=0, blue=0) time.sleep(step) except KeyboardInterrupt: print("Exiting... Bye!") turn_all_off()
def __init__(self, num_pixels, num_rows=1): super().__init__(num_pixels, num_rows) """Initializes a BlinkStick controller""" try: from blinkstick import blinkstick except ImportError as e: logger.error('Unable to import the blinkstick library') logger.error( 'You can install this library with `pip install blinkstick`') raise e self.stick = blinkstick.find_first()
def turn_on_sequence(red=0, green=0, blue=255, step=0.1): try: turn_all_off() led = blinkstick.find_first() for i in range(1, 32): led.set_color(0, i, green, red, blue) time.sleep(step) except KeyboardInterrupt: print("Exiting... Bye!") turn_all_off()
def demo_set_get_block_info(info_block1, info_block2): bstick = blinkstick.find_first() # set and get device info-block1 here bstick.set_info_block1(info_block1) print bstick.get_info_block1() # set and get device info-block2 here bstick.set_info_block2(info_block2) print bstick.get_info_block2()
def get_blinkstick(self): bs = None try: bs = blinkstick.find_first() except: # more attempts to get around the blinkstick USB flakiness logger.warn('Trying to reset USB device...') dev = usb.core.find(find_all=False, idVendor=blinkstick.VENDOR_ID, idProduct=blinkstick.PRODUCT_ID) if dev: dev.reset() logger.warn('Reset USB device') return bs
def __init__(self): try: self.bstick = blinkstick.find_first() except: rospy.logerr('unable to find BlinkStick Square') sys.exit(-1) rospy.loginfo('connected to BlinkStick Square') rospy.Subscriber("set_all_led", ColorRGBA, self.set_all) rospy.Subscriber("set_single_led", ColorRGBA, self.set_single) self.bstick.morph(channel=0, index=0, red=0, green=40, blue=0)
def __init__(self): self.cube = blinkstick.find_first() self.drawingarea = gtk.DrawingArea() self.color = self.drawingarea.get_colormap().alloc_color(0, 255, 0) self.colorseldlg = gtk.ColorSelectionDialog("Select Cube Color") colorsel = self.colorseldlg.colorsel colorsel.set_previous_color(self.color) colorsel.set_current_color(self.color) colorsel.set_has_palette(True) colorsel.set_has_opacity_control(True) colorsel.connect("color_changed", self.update_cubecolor) colorsel.connect("delete_event", self.bye) self.colorseldlg.run() self.bye()
def off(): if skipBlinkStick: if isBlinkStickAttached(): if resetBlinkStick() is False: return else: return bs = blinkstick.find_first() if bs is None: return False for i in range(8): bs.set_color(channel=0, index=i, name=None)
def __init__(self, name, role, sn=None, max_power=0.1, inversed=False, **kwargs): """ sn (None or str): serial number. If None, it will pick the first device found. max_power (0<float): maxium power emitted in W. """ model.Emitter.__init__(self, name, role, **kwargs) self._sn = sn self._max_power = max_power # Just find the first BlinkStick led controller if sn is None: self._bstick = blinkstick.find_first() else: # Note: doesn't work with v1.1.7: # need fix on get_string(), reported here: https://github.com/arvydas/blinkstick-python/pull/35 logging.warning("Using sn to select the device doesn't currently work") self._bstick = blinkstick.find_by_serial(sn) if self._bstick is None: raise HwError("Failed to find a Blinkstick for component %s. " "Check that the device is connected to the computer." % (name,)) self._bstick.set_inverse(inversed) time.sleep(0.1) # Device apparently needs some time to recover self._shape = () # TODO: allow to change the power also via emissions? Or just make it a choice self.emissions = model.ListVA([0], unit="", setter=self._setEmissions) self.emissions.subscribe(self._updatePower) # list of 5-tuples of floats self.spectra = model.ListVA([(380e-9, 390e-9, 560e-9, 730e-9, 740e-9)], unit="m", readonly=True) self.power = model.FloatContinuous(0., (0., self._max_power), unit="W", setter=self._setPower) self.power.subscribe(self._updatePower, init=True) self._swVersion = "Blinkstick v%s" % (blinkstick.__version__,) # These functions report wrong values on Linux with v1.1.7 # man = self._bstick.get_manufacturer() # desc = self._bstick.get_description() # rsn = self._bstick.get_serial() man = self._bstick.device.manufacturer desc = self._bstick.device.product rsn = self._bstick.device.serial_number self._hwVersion = "%s %s (s/n: %s)" % (man, desc, rsn)
def __init__(self, bstick=None): if not bstick: try: bstick = blinkstick.find_first() print('Blinkstick connected.') except IOError as e: print('No blinkstick found.') raise e self.bstick = bstick if self.bstick.get_mode() != 2: print('Changing to WS2812 mode (mode 2).') self.bstick.set_mode(2) self.grid = np.zeros((HEIGHT, WIDTH, COLOR_CHANNELS)) self._update_neopixel() print('State initialized.')
def startup(delay=0.15): global startupCompleted ping.play() bs = blinkstick.find_first() if bs is None: startupCompleted = True #raise BlinkStickNotConnected return False for i in range(8): bs.set_color(channel=0, index=i, name="blue") time.sleep(delay) startupCompleted = True
def main(): fps = 50.0 # How many frames per second. 50 is about the upper limit. colorin = Color("#b71500") colorout = Color("black") ### END OPTIONS ### stk = blinkstick.find_first() cnt = stk.get_led_count() while True: mult = 0 last = colorout while ( last.hex != colorin.hex ): # For some reason if I use anything but .hex, they'll never equal the same color. last = Color(rgb=( (last.red * 5 + colorin.red) / 6, (last.green * 5 + colorin.green) / 6, (last.blue * 5 + colorin.blue) / 6, )) data = [ int(last.green * 255), int(last.red * 255), int(last.blue * 255), ] * cnt stk.set_led_data(0, data) sleep(1 / fps) print("breathe in", last) print("pause", last) sleep(1 / fps * 7) while ( last.hex != colorout.hex and last.luminance > 0.004 ): # For fading to black, this helps a bit since the blinkstick completely blanks out at low brightness levels. last = Color(rgb=( (last.red * 6 + colorout.red) / 7, (last.green * 6 + colorout.green) / 7, (last.blue * 6 + colorout.blue) / 7, )) data = [ int(last.green * 255), int(last.red * 255), int(last.blue * 255), ] * cnt stk.set_led_data(0, data) sleep(1 / fps) print("breathe out", last)
def process_user_commands(): working_flag = True sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP sock.bind((IP, PORT)) while working_flag: data = sock.recvfrom(1024) syslog.syslog(syslog.LOG_CRIT, 'chainvu_test data: {0}'.format(data)) command = data[0] if (command == 'led'): led = blinkstick.find_first() led.set_color(name='red') working_flag = False
def snake(red=0, green=0, blue=255, size=3, cicles=9, speed=0.1): try: led = blinkstick.find_first() for i in range(cicles): head = 0 while head < 32: for j in range(0, 32): if head >= j > head - size: led.set_color(0, j, green, red, blue) else: led.set_color(0, j, 0, 0, 0) time.sleep(speed) head += 1 except KeyboardInterrupt: print("Exiting... Bye!") turn_all_off()
def main(): ### START OPTIONS ### fps = 50.0 # FPS of the animation. 50 is about the upper limit. speed = 1 # Speed of animation type = 1.0 # "1" for hard edges on colors, "1.0" for smooth fading. brightness = 1.0 # Brightness of animation, from 0 to 1 ### END OPTIONS ### # try to find the blinkstick try: stk = blinkstick.find_first() cnt = stk.get_led_count() print("It's lit bruv. Press CTRL-C to turn down.") # exit if not found except: print("Blinkstick not detected. Is it plugged in?") exit(0) #### START MAIN LOOP #### errors = 0 while True: data = [] # choose and set the colors for i in range(1, cnt + 1): (r, g, b) = hsv_to_rgb( (sin(time() / (8.0 / speed) + i / (4 * type)) + 1) / 2, 1, brightness) data = data + [int(g * 255), int(r * 255), int(b * 255)] # try to write the colors to the strip try: stk.set_led_data(0, data) # if there's an error, increment the error counter and try again except: errors += 1 # if we accumulate more than 10 errors without a successful write, # strip is probably unplugged, so exit program if errors > 250: print("Looks like we've been unplugged!") exit(0) # else if write successful, reset the error counter else: errors = 0 sleep(1 / fps)
def fail(delay=0.1): buzz.play() if skipBlinkStick: if isBlinkStickAttached(): if resetBlinkStick() is False: return else: return bs = blinkstick.find_first() if bs is None: return False for i in range(8): bs.set_color(channel=0, index=i, name="red") time.sleep(delay)
def loop_square(): call(['sudo', 'amixer', 'cset', 'numid=3', '1']) bstick = blinkstick.find_first() pygame.init() SONG_END = pygame.USEREVENT + 1 pygame.mixer.music.set_endevent(SONG_END) pygame.mixer.music.load('/home/pi/Projects/b_square/TARDIS.mp3') pygame.mixer.music.play() print 'Playing song' while pygame.mixer.music.get_busy() == True: for x in range(0, 8): if x >= 1: bstick.set_color(channel=0, index=(x - 1)) if x < 8: bstick.set_color(channel=0, index=x, name="white") time.sleep(0.05) continue turn_off_square()
def main(): speed = 1 # 2 is 2x speed, .5 is half speed, you get the idea. fps = 50.0 # Frames per second of the animation. 50 is about the upper limit. cut = 2 # how much of the spectrum to show. 1 = full spectrum, 2 = 2 full spectrums, .5 is half a spectrum. brightness = 1.0 # Brightness of animation from 0 to 1 stk = blinkstick.find_first() cnt = stk.get_led_count() while True: data = [] for i in range(1, cnt + 1): (r, g, b) = hsv_to_rgb(i / float(cnt * (1.0 / cut)) + time() * speed, 1, brightness) data = data + [int(g * 255), int(r * 255), int(b * 255)] # print(int(r*255), int(g*255), int(b*255), i/32.0,) stk.set_led_data(0, data) sleep(1 / fps)
def pingSuccess(hold=0.50): global skipBlinkStick if skipBlinkStick: if isBlinkStickAttached(): if resetBlinkStick() is False: return else: return skipBlinkStick = False bs = blinkstick.find_first() if bs is None: return False bs.set_color(channel=0, index=0, name=None) time.sleep(hold) bs.set_color(channel=0, index=0, name="blue") time.sleep(hold)
def __init__(self, app=None): """ Sets up everything required, connects with the blinkstick and registers with the app :param app: flask-app to register with """ Thread.__init__(self) self.daemon = True self.queue = Queue() self.running = False # Find blinckstick and set mode self.led = blinkstick.find_first() if self.led is not None: self.led.set_mode(3) else: raise Exception('Blinkstick not found') if app is not None: self.init_app(app)
def __init__(self): # initialize the blinkstick self.vision_led = blinkstick.find_first() # set initial states self.state = rospy.get_param("~state_init", "Idle") self.state_last = "" self.cmd_state = rospy.get_param("~cmd_state_init", "Idle") # flag that indicates whether haptic tether is enables # 0 - Teleoperation # 1 - Autonomous # 2 - Haptic Tether # 3 - Training self.follower_mode = 3 # timer for state machine self.cmd_state_timer = rospy.get_time() self.cmd_state_period = 0.0 # time in following mode self.dt_following = 0.0 # loop counters self.stuck_count = 0 self.stuck_backup_count = 0 self.lost_vision_count = 0 self.too_fast_count = 0 self.slow_down_count = 0 self.too_fast_pause_count = 0 self.flag_too_fast_check_pause = False self.stuck_backup_count_limit = 50 self.stuck_count_limit = rospy.get_param("~stuck_count_limit", 20) self.lost_vision_count_limit = rospy.get_param("~lost_vision_count_limit", 25) self.too_fast_count_limit_low = rospy.get_param("~too_fast_count_limit_low", 25) self.too_fast_count_limit_high = rospy.get_param("~too_fast_count_limit_high", 45) self.too_fast_pause_count_limit = rospy.get_param("~too_fast_pause_count_limit", 65) self.slow_down_count_limit = rospy.get_param("~slow_down_count_limit", 25) self.turtlebot_vel_max = rospy.get_param("~turtlebot_vel_max", 0.7) self.turtlebot_angvel_max = rospy.get_param("~turtlebot_angvel_max", np.pi) # a little bit of hysteresis self.too_fast_threshold_low = rospy.get_param("~too_fast_threshold_low", self.turtlebot_vel_max * 1.4) self.too_fast_threshold_high = rospy.get_param("~too_fast_threshold_high", self.turtlebot_vel_max * 1.5) # desired velocity for publish self.cmd_vel = Twist() self.measured_vel = Twist() # teleoperation parameters self.tele_vel = Twist() self.tele_vel.linear.x = rospy.get_param("~default_teleop_vel_linear", 0.3) self.tele_vel_inc_linear = rospy.get_param("~telop_vel_increment_linear", 0.01) # bumper variable self.bumper_event = BumperEvent() # human tracking variables self.human_pose = Pose2D() self.human_vel = Vector3() self.track_status = "Lost" # human input variables self.human_input_tilt = Vector3() # roll, pitch, yaw self.human_input_gesture = -1 # 10 means no gesture input self.flag_button_pressed = False self.flag_latch_cmd_vel = False self.human_input_mode = rospy.get_param("~human_input_mode", "tilt_control") # state machine control self.set_state = -1 # < 0 means no set state command self.set_cmd_state = -1 # variables for follower control self.dist_desired = rospy.get_param("~dist_desired_follower", 1.0) self.kp_linear = rospy.get_param("~kp_linear", 1.0) self.kd_linear = rospy.get_param("~kd_linear", 0.1) self.kb_linear = rospy.get_param("~kb_linear", 0.1) self.kp_angular = rospy.get_param("~kp_angular", 2.0) self.kd_angular = rospy.get_param("~kd_angular", 0.2) self.kb_angular = rospy.get_param("~kb_angular", 0.2) self.dist_range_min = rospy.get_param("~dist_range_min", 0.3) self.dist_range_max = rospy.get_param("~dist_range_max", 1.9) self.dist_stuck_resume_max = rospy.get_param("~dist_stuck_resume_max", 1.0) # variables for tilt control self.pitch_to_linear_scale = rospy.get_param("~roll_to_linear_scale", 1.0) self.roll_to_angular_scale = rospy.get_param("~pitch_to_angular_scale", -2.0) self.pitch_deadband = rospy.get_param("~pitch_deadband", 0.2) self.roll_deadband = rospy.get_param("~roll_deadband", 0.2) self.pitch_offset = rospy.get_param("~pitch_offset", 0.15) self.roll_offset = rospy.get_param("~roll_offset", 0.1) self.roll_center_offset = rospy.get_param("~roll_center_offset", 0.0) self.pitch_center_offset = rospy.get_param("~pitch_center_offset", 0.0) self.flag_reverse_mapping = rospy.get_param("~reverse_mapping", False) # variables for the autonomous turning self.measured_pose = Odometry() self.pos_init_pre_turning = Pose2D() self.dist_pre_turning = 0.0 self.angle_turning = np.pi / 2.0 self.angle_turning_goal = 0.0 self.tilt_turning_thresh = 0.75 # turning direction, 0 - no turning, 1 - turning left, 2 - turning right self.dir_turning = 0 # subscribers to human tracking self.human_pose_sub = rospy.Subscriber("tracking/human_pos2d", Pose2D, self.human_track_pose_cb) self.human_vel_sub = rospy.Subscriber("tracking/human_vel2d", Vector3, self.human_track_vel_cb) self.track_status_sub = rospy.Subscriber("tracking/status", String, self.human_track_status_cb) self.odom_sub = rospy.Subscriber("odom", Odometry, self.odom_cb) # subscribers to human input self.human_input_ort_sub = rospy.Subscriber("human_input/tilt", Vector3, self.human_input_tilt_cb) self.human_input_gesture_sub = rospy.Subscriber("human_input/gesture", Int8, self.human_input_gesture_cb) self.human_input_mode_sub = rospy.Subscriber("human_input/button", Bool, self.human_input_mode_cb) self.button_event_sub = rospy.Subscriber("human_input/button_event", Int8, self.button_event_cb) # subscriber to reverse mapping self.reverse_mapping_sub = rospy.Subscriber("human_input/reverse_mapping", Bool, self.reverse_mapping_cb) # subscriber to state control self.state_control_sub = rospy.Subscriber("state_control/set_state", Int8, self.set_state_cb) self.cmd_state_control_sub = rospy.Subscriber("cmd_state_control/set_state", Int8, self.set_cmd_state_cb) # subscriber to haptic tether control self.follower_mode_control_sub = rospy.Subscriber("state_control/set_follower_mode", Int8, self.follower_mode_control_cb) # subscribe to the bumper event self.bumper_event_sub = rospy.Subscriber("mobile_base/events/bumper", BumperEvent, self.bumper_event_cb) # publisher to robot velocity self.robot_state_pub = rospy.Publisher("robot_follower_state", Int8, queue_size=1) self.robot_vel_pub = rospy.Publisher("cmd_vel", Twist, queue_size=1) self.haptic_msg_pub = rospy.Publisher("haptic_control", haptic_msg, queue_size=1) # publisher to system message self.sys_msg_pub = rospy.Publisher("sys_message", String, queue_size=1)
class BothMode(BlinkstickNanoMode): def inbox_item_received(self, inbox_item): r, g, b = image_helper.get_random_rgb() for led in range(2): _blinkstick.set_color(channel=0, index=led, red=r, green=g, blue=b) def lights(self): r, g, b = image_helper.get_random_rgb() for led in range(2): _blinkstick.set_color(channel=0, index=led, red=r, green=g, blue=b) time.sleep(1) _blinkstick = blinkstick.find_first() for led in range(2): _blinkstick.set_color(channel=0, index=led, red=0, green=0, blue=0) _modes = itertools.cycle([ AlternateMode(), BothMode() ]) _mode = next(_modes) def lights(): _mode.lights()
#! /usr/bin/python import re import signal import sys import time import requests from threading import Event, Thread from jenkinsapi.jenkins import Jenkins from jenkinsapi.utils.requester import Requester from blinkstick import blinkstick # preset configuration JENKINS_URL = 'https://jenkins.midvale.leedsdev.net/' DISABLE_SSL_VERIFY = True led = blinkstick.find_first() current_time = lambda: int(time.time()) found_running_job = False thread_status_stop = thread_status = None def get_server_instance(): jenkins_url = JENKINS_URL while True: try: if DISABLE_SSL_VERIFY == True: requests.packages.urllib3.disable_warnings() return Jenkins(jenkins_url,requester=Requester("","",baseurl=jenkins_url,ssl_verify=False)) else: return Jenkins(jenkins_url) except ConnectionError: