def config_socket(ledCount): # Define zmq socket context = zmq.Context() # Create a Pusher socket socket = context.socket(zmq.PUSH) # Connect Pusher to configuration socket socket.connect('tcp://{0}:{1}'.format(matrix_ip, everloop_port)) # Loop forever while True: # Create a new driver config driver_config_proto = driver_pb2.DriverConfig() # Create an empty Everloop image image = [] # For each device LED for led in range(ledCount): # Set individual LED value ledValue = io_pb2.LedValue() ledValue.blue = randint(0, 50) ledValue.red = randint(0, 200) ledValue.green = randint(0, 255) ledValue.white = 0 image.append(ledValue) # Store the Everloop image in driver configuration driver_config_proto.image.led.extend(image) # Send driver configuration through ZMQ socket socket.send(driver_config_proto.SerializeToString()) #Wait before restarting loop time.sleep(0.05)
def set_everloop_intensity(intensity): """Sets all of the LEDS to a given rgbw value""" # grab zmq context context = zmq.Context() # get socket for config config_socket = context.socket(zmq.PUSH) config_socket.connect('tcp://{0}:{1}'.format(creator_ip, creator_everloop_base_port)) # create a new driver config strut config = driver_pb2.DriverConfig() # initialize an empty list for the "image" or LEDS image = [] # iterate over all 35 LEDS and set the rgbw value of each # then append it to the end of the list/image thing for led in range(35): ledValue = io_pb2.LedValue() ledValue.blue = 0 ledValue.red = 0 ledValue.green = intensity ledValue.white = 0 image.append(ledValue) # add the "image" to the config driver config.image.led.extend(image) # send a serialized string of the driver config # to the config socket config_socket.send(config.SerializeToString())
def ring_image(led_count, ledOn): # Create a new driver config driver_config_proto = driver_pb2.DriverConfig() # Create an empty Everloop image image = [] # Set individual LED value for led in range(led_count): if led in ledOn: ledValue = io_pb2.LedValue( ) # Protocol buffer custom type for Matrix Voice ledValue.blue = ledOn[led]["blue"] ledValue.red = ledOn[led]["red"] ledValue.green = ledOn[led]["green"] ledValue.white = ledOn[led]["white"] image.append(ledValue) else: ledValue = io_pb2.LedValue() ledValue.blue = 0 ledValue.red = 0 ledValue.green = 0 ledValue.white = 0 image.append(ledValue) # Store the Everloop image in driver configuration driver_config_proto.image.led.extend(image) return driver_config_proto.SerializeToString()
def send_servo_command(pin): # Define zmq socket context = zmq.Context() # Create a Pusher socket socket = context.socket(zmq.PUSH) # Connect Pusher to configuration socket socket.connect('tcp://{0}:{1}'.format(matrix_ip, servo_port)) # Create a new driver config servo_config = driver_pb2.DriverConfig() # Set a pin that the servo will operate on servo_config.servo.pin = pin # Function to change servo angle def moveServo(angle): # Log angle print('Angle: {0}'.format(angle)) # Set the servo's angle in the config servo_config.servo.angle = angle # Serialize the config and send it to the driver socket.send(servo_config.SerializeToString()) # Wait for 1 second time.sleep(1) # Run function again with random angle moveServo(random.randint(0, 180)) # Initial moveServo call moveServo(180)
def construct_config_proto(self): # Create a new driver config driver_config_proto = driver_pb2.DriverConfig() driver_config_proto.delay_between_updates = 1.0 driver_config_proto.timeout_after_last_ping = 1.0 return driver_config_proto
def _create_everloop_color_config(led_array): """Set everloop colors""" config = driver_pb2.DriverConfig() # add the led colors array to the config driver config.image.led.extend(led_array) return config
def IsGatewayActive(self): _LOGGER.info('Checking connection with the Gateway') driver_config_proto = driver_pb2.DriverConfig() driver_config_proto.zigbee_message.type = comm_pb2.ZigBeeMsg.ZigBeeCmdType.Value( "NETWORK_MGMT") driver_config_proto.zigbee_message.network_mgmt_cmd.type = comm_pb2.ZigBeeMsg.NetworkMgmtCmd.NetworkMgmtCmdTypes.Value( "IS_PROXY_ACTIVE") self.push(driver_config_proto) return Status.CHECK_GATEWAY_ACTIVE
def config_gpio_read(): # Create a new driver config config = driver_pb2.DriverConfig() # Delay between updates in seconds config.delay_between_updates = 2.0 # Timeout after last ping config.timeout_after_last_ping = 3.5 # Send driver configuration through ZMQ socket socket.send(config.SerializeToString())
def RequestNetworkStatus(self): _LOGGER.info('Requesting network status') driver_config_proto = driver_pb2.DriverConfig() driver_config_proto.zigbee_message.type = comm_pb2.ZigBeeMsg.ZigBeeCmdType.Value( "NETWORK_MGMT") driver_config_proto.zigbee_message.network_mgmt_cmd.type = comm_pb2.ZigBeeMsg.NetworkMgmtCmd.NetworkMgmtCmdTypes.Value( "NETWORK_STATUS") driver_config_proto.zigbee_message.network_mgmt_cmd.permit_join_params.time = 60 self.push(driver_config_proto) return Status.WAITING_FOR_NETWORK_STATUS
def ResetGateway(self): _LOGGER.info('Reseting the Gateway App') _LOGGER.info(_comm_pb2.ZigBeeMsg.ZigBeeCmdType.keys()) driver_config_proto = driver_pb2.DriverConfig() driver_config_proto.zigbee_message.type = comm_pb2.ZigBeeMsg.ZigBeeCmdType.Value( "NETWORK_MGMT") driver_config_proto.zigbee_message.network_mgmt_cmd.type = comm_pb2.ZigBeeMsg.NetworkMgmtCmd.NetworkMgmtCmdTypes.Value( "RESET_PROXY") self.push(driver_config_proto) return Status.RESET_GATEWAY
def CreateNetwork(self): _LOGGER.info('NO NETWORK') _LOGGER.info('CREATING A ZigBee Network') driver_config_proto = driver_pb2.DriverConfig() driver_config_proto.zigbee_message.type = comm_pb2.ZigBeeMsg.ZigBeeCmdType.Value( "NETWORK_MGMT") driver_config_proto.zigbee_message.network_mgmt_cmd.type = comm_pb2.ZigBeeMsg.NetworkMgmtCmd.NetworkMgmtCmdTypes.Value( "CREATE_NWK") driver_config_proto.zigbee_message.network_mgmt_cmd.permit_join_params.time = 60 self.push(driver_config_proto) return Status.WAITING_FOR_NETWORK_STATUS
def PermitJoin(self): _LOGGER.info('Permitting join') driver_config_proto = driver_pb2.DriverConfig() driver_config_proto.zigbee_message.type = comm_pb2.ZigBeeMsg.ZigBeeCmdType.Value( "NETWORK_MGMT") driver_config_proto.zigbee_message.network_mgmt_cmd.type = comm_pb2.ZigBeeMsg.NetworkMgmtCmd.NetworkMgmtCmdTypes.Value( "PERMIT_JOIN") driver_config_proto.zigbee_message.network_mgmt_cmd.permit_join_params.time = 60 self.push(driver_config_proto) _LOGGER.info('Please reset your zigbee devices') _LOGGER.info('.. Waiting 60s for new devices') return Status.WAITING_FOR_DEVICES
def setEverloopColor(red=0, green=0, blue=0, white=0): config = driver_pb2.DriverConfig() image = [] for led in range(35): ledValue = io_pb2.LedValue() ledValue.blue = blue ledValue.red = red ledValue.green = green ledValue.white = white image.append(ledValue) config.image.led.extend(image) config_socket.send(config.SerializeToString())
def toggle(self): config = driver_pb2.DriverConfig() config.zigbee_message.type = comm_pb2.ZigBeeMsg.ZigBeeCmdType.Value( "ZCL") config.zigbee_message.zcl_cmd.type = comm_pb2.ZigBeeMsg.ZCLCmd.ZCLCmdType.Value( "ON_OFF") config.zigbee_message.zcl_cmd.onoff_cmd.type = comm_pb2.ZigBeeMsg.ZCLCmd.OnOffCmd.ZCLOnOffCmdType.Value( "TOGGLE") config.zigbee_message.zcl_cmd.node_id = self._nodeId config.zigbee_message.zcl_cmd.endpoint_index = self._endpointIndex self.push(config)
def speaking_leds(): driver_config_proto = driver_pb2.DriverConfig() everloop_image = [] for i in range(0, 35): led_value = io_pb2.LedValue() # set red brightness to 100 led_value.white = 20 # append that led configuration to led container everloop_image.append(led_value) # put the image into driver driver_config_proto.image.led.extend(everloop_image) # send the configuration to the driver socket.send(driver_config_proto.SerializeToString()) return None
def set_color_temp(self, color_temp): self._colorTemp = color_temp config = driver_pb2.DriverConfig() config.zigbee_message.type = comm_pb2.ZigBeeMsg.ZigBeeCmdType.Value( "ZCL") config.zigbee_message.zcl_cmd.type = comm_pb2.ZigBeeMsg.ZCLCmd.ZCLCmdType.Value( "COLOR_CONTROL") config.zigbee_message.zcl_cmd.colorcontrol_cmd.type = comm_pb2.ZigBeeMsg.ZCLCmd.ColorControlCmd.ZCLColorControlCmdType.Value( "MOVETOCOLORTEMP") config.zigbee_message.zcl_cmd.colorcontrol_cmd.movetocolortemp_params.color_temperature = color_temp config.zigbee_message.zcl_cmd.colorcontrol_cmd.movetocolortemp_params.transition_time = 10 config.zigbee_message.zcl_cmd.node_id = self._nodeId config.zigbee_message.zcl_cmd.endpoint_index = self._endpointIndex self.push(config)
def set_brightness(self, brightness): self._brightness = brightness config = driver_pb2.DriverConfig() config.zigbee_message.type = comm_pb2.ZigBeeMsg.ZigBeeCmdType.Value( "ZCL") config.zigbee_message.zcl_cmd.type = comm_pb2.ZigBeeMsg.ZCLCmd.ZCLCmdType.Value( "LEVEL") config.zigbee_message.zcl_cmd.level_cmd.type = comm_pb2.ZigBeeMsg.ZCLCmd.LevelCmd.ZCLLevelCmdType.Value( "MOVE_TO_LEVEL") config.zigbee_message.zcl_cmd.level_cmd.move_to_level_params.level = brightness config.zigbee_message.zcl_cmd.level_cmd.move_to_level_params.transition_time = 10 config.zigbee_message.zcl_cmd.node_id = self._nodeId config.zigbee_message.zcl_cmd.endpoint_index = self._endpointIndex self.push(config)
def config_gpio_write(pin, value): """This function sets up a pin for use as an output pin""" # Create a new driver config config = driver_pb2.DriverConfig() # set the pin in the config provided from the function params config.gpio.pin = pin # Set pin mode to output config.gpio.mode = io_pb2.GpioParams.OUTPUT # Set the output of the pin initially config.gpio.value = value # Send configuration to malOS using global sconfig sconfig.send(config.SerializeToString())
def config_socket(): # Define zmq socket context = zmq.Context() # Create a Pusher socket socket = context.socket(zmq.PUSH) # Connect Pusher to configuration socket socket.connect('tcp://{0}:{1}'.format(matrix_ip, imu_port)) # Create a new driver config driver_config_proto = driver_pb2.DriverConfig() # Delay between updates in seconds driver_config_proto.delay_between_updates = 0.05 # Timeout after last ping driver_config_proto.timeout_after_last_ping = 6.0 # Send driver configuration through ZMQ socket socket.send(driver_config_proto.SerializeToString())
def config_gpio_write(pin, value): # Create a new driver config config = driver_pb2.DriverConfig() # set desired pin config.gpio.pin = pin # Set pin mode to output config.gpio.mode = io_pb2.GpioParams.OUTPUT # Set the output of the pin initially config.gpio.value = value%2 # Send driver configuration through ZMQ socket socket.send(config.SerializeToString()) # Wait 2 seconds time.sleep(2) # Increase value and run again value += 1 config_gpio_write(0, value%2)
def __init__(self, numLeds, matrixIp, everloopPort): self._logger = logging.getLogger('SnipsLedControl') self._numLeds = numLeds self._matrixIp = matrixIp self._everloopPort = everloopPort self._driver = driver_pb2.DriverConfig() self._context = zmq.Context() self._socket = self._context.socket(zmq.PUSH) self._colors = self._newArray() ioloop.install() Process(target=register_error_callback, args=(self.everloopErrorCallback, self._matrixIp, self._everloopPort)).start() self.pingSocket() self.updateSocket() self.configSocket(self._numLeds)
def send_servo_command(pin=4): # or local ip of MATRIX creator creator_ip = '127.0.0.1' creator_servo_base_port = 20013 + 32 # Set a base count of 0 count = 0 # Grab a zmq context and set it up as a push socket, then connect context = zmq.Context() socket = context.socket(zmq.PUSH) socket.connect('tcp://{0}:{1}'.format(creator_ip, creator_servo_base_port)) # Create a new driver configuration servo_config = driver_pb2.DriverConfig() # Set a pin that the servo will operate on servo_config.servo.pin = pin # Start the loop of forever while True: # count mod 180 will set the angle of the servo to move to # this will change as the count increments to values of half turns angle = count % 180 # Print out the angle to stdout print('Angle: {0}'.format(angle)) # Set the servo's angle in the config servo_config.servo.angle = angle # since python isn't IO bound like node this will simulate # the event loop, updating the angle all the time but # only updating the servo every 1500000 'ticks' if count % 1500000 == 0: # Print message to stdout print('Sending new config to servo...{0}'.format(count)) # Serialize the config and send it to the driver socket.send(servo_config.SerializeToString()) # Increment the counter count += 1
def config_socket(): # Define zmq socket context = zmq.Context() # Create a Pusher socket socket = context.socket(zmq.PUSH) # Connect Pusher to configuration socket socket.connect('tcp://{0}:{1}'.format(matrix_ip, humidity_port)) # Create a new driver config driver_config_proto = driver_pb2.DriverConfig() # Delay between updates in seconds driver_config_proto.delay_between_updates = 2.0 # Timeout after last ping driver_config_proto.timeout_after_last_ping = 6.0 # Current temperature in Celsius for calibration driver_config_proto.humidity.current_temperature = 23 # Send driver configuration through ZMQ socket socket.send(driver_config_proto.SerializeToString())
def config_gpio_read(pin): """This function sets up a pin for use as an input pin""" # Create a new driver config config = driver_pb2.DriverConfig() # Set 250 miliseconds between updates. config.delay_between_updates = 0.5 # Stop sending updates 2 seconds after pings. config.timeout_after_last_ping = 3.5 # Set the pin to the value provided by the function param config.gpio.pin = pin # Set the pin mode to input config.gpio.mode = io_pb2.GpioParams.INPUT # Send configuration to malOS using global sconfig sconfig.send(config.SerializeToString())
def set_everloop_color(red=0, green=0, blue=0, white=0): """Submit a R,G,B,W value between 0-255""" # or local ip of MATRIX creator creator_ip = '127.0.0.1' # port for everloop driver creator_everloop_base_port = 20013 + 8 # grab zmq context context = zmq.Context() # get socket for config config_socket = context.socket(zmq.PUSH) config_socket.connect('tcp://{0}:{1}'.format(creator_ip, creator_everloop_base_port)) # create a new driver config strut config = driver_pb2.DriverConfig() # initialize an empty list for the "image" or LEDS image = [] # iterate over all 35 LEDS and set the rgbw value of each # then append it to the end of the list/image thing for led in range(35): ledValue = io_pb2.LedValue() ledValue.blue = blue ledValue.red = red ledValue.green = green ledValue.white = white image.append(ledValue) # add the "image" to the config driver config.image.led.extend(image) # send a serialized string of the driver config # to the config socket config_socket.send(config.SerializeToString())
def config_socket(): # Define zmq socket context = zmq.Context() # Create a Pusher socket socket = context.socket(zmq.PUSH) # Connect Pusher to configuration socket socket.connect('tcp://{0}:{1}'.format(matrix_ip, wakeword_port)) # Create a new driver config config = driver_pb2.DriverConfig() # Language Model File config.wakeword.lm_path = LM_PATH # Dictation File config.wakeword.dic_path = DIC_PATH # Desired MATRIX microphone config.wakeword.channel = 8 # Enable verbose option config.wakeword.enable_verbose = False # Send driver configuration through ZMQ socket socket.send(config.SerializeToString()) print('Listening for wakewords')
def config_socket(): """Configure and calibrate the humidity driver""" # Grab the zmq context and set it to push, then connect to it context = zmq.Context() socket = context.socket(zmq.PUSH) socket.connect('tcp://{0}:{1}'.format(creator_ip, humidity_port)) # Create a new driver config driver_config_proto = driver_pb2.DriverConfig() # Set the delay between updates that the driver returns driver_config_proto.delay_between_updates = 2.0 # Stop sending updates if there is no ping for 6 seconds driver_config_proto.timeout_after_last_ping = 6.0 # Calibrate the temperature by taking a real world # measurment from a thermometer and enter it in here # in degrees celcius driver_config_proto.humidity.current_temperature = 23 # Serialize the config and send it to the config socket socket.send(driver_config_proto.SerializeToString())
def config_socket(ledCount): global flag global Color # Define zmq socket context = zmq.Context() # Create a Pusher socket socket = context.socket(zmq.PUSH) # Connect Pusher to configuration socket socket.connect('tcp://{0}:{1}'.format(matrix_ip, everloop_port)) rc = 0 driver_config_proto = driver_pb2.DriverConfig() # Create an empty Everloop image image = [] # For each device LED for led in range(ledCount): # Set individual LED value ledValue = io_pb2.LedValue() ledValue.blue = 10 ledValue.red = 10 ledValue.green = 10 ledValue.white = 0 image.append(ledValue) # Store the Everloop image in driver configuration driver_config_proto.image.led.extend(image) # Send driver configuration through ZMQ socket socket.send(driver_config_proto.SerializeToString()) client = mqtt.Client() client.connect("raspberrypi.local", 1883) client.subscribe("hermes/nlu/intentParsed") client.subscribe("esp/test") client.on_message = on_message client.on_connect = on_connect client.on_publish = on_publish client.on_subscribe = on_subscribe client.on_log = on_log while rc == 0: rc = client.loop() if (flag): # Create a new driver config driver_config_proto = driver_pb2.DriverConfig() # Create an empty Everloop image image = [] # For each device LED if (Color == "red"): for led in range(ledCount): # Set individual LED value ledValue = io_pb2.LedValue() ledValue.blue = 0 ledValue.red = 100 ledValue.green = 0 ledValue.white = 0 image.append(ledValue) elif (Color == "blue"): for led in range(ledCount): # Set individual LED value ledValue = io_pb2.LedValue() ledValue.blue = 100 ledValue.red = 0 ledValue.green = 0 ledValue.white = 0 image.append(ledValue) elif (Color == "green"): client.publish("esp/lock", "Hello") for led in range(ledCount): # Set individual LED value ledValue = io_pb2.LedValue() ledValue.blue = 0 ledValue.red = 0 ledValue.green = 100 ledValue.white = 0 image.append(ledValue) else: for led in range(ledCount): # Set individual LED value ledValue = io_pb2.LedValue() ledValue.blue = 10 ledValue.red = 10 ledValue.green = 10 ledValue.white = 0 image.append(ledValue) # Store the Everloop image in driver configuration driver_config_proto.image.led.extend(image) # Send driver configuration through ZMQ socket socket.send(driver_config_proto.SerializeToString()) #Wait before restarting loop time.sleep(10) # Create a new driver config driver_config_proto = driver_pb2.DriverConfig() # Create an empty Everloop image image = [] # For each device LED for led in range(ledCount): # Set individual LED value ledValue = io_pb2.LedValue() ledValue.blue = 10 ledValue.red = 10 ledValue.green = 10 ledValue.white = 0 image.append(ledValue) # Store the Everloop image in driver configuration driver_config_proto.image.led.extend(image) # Send driver configuration through ZMQ socket socket.send(driver_config_proto.SerializeToString()) flag = False
def construct_config_proto(): driver_config_proto = driver_pb2.DriverConfig() driver_config_proto.delay_between_updates = 2.0 driver_config_proto.timeout_after_last_ping = 6.0 return driver_config_proto
# create hero hero = Hero(22) hero.vel = 0 #create goal goal = Goal() goal.width = 4 #for tracking time start_time = time.time() frame = 0 ####################### led painting happens here #################### while True: # Create a new driver config (for setup purposes) driver_config_proto = driver_pb2.DriverConfig() img.clear_all() # Painting obstacles img.set_led(int(lava.pos), int(lava.r),int(lava.g),int(lava.b),int(lava.w)) img.set_led(int(lava1.pos), int(lava1.r),int(lava1.g),int(lava1.b),int(lava1.w)) # Paint Goal for i_led, v_led in enumerate(goal.rgb_out()): img.set_led(int(goal.pos + i_led), int(v_led[0]), int(v_led[1]), int(v_led[2]), int(v_led[3]) ) # Paint Hero img.set_led(int(hero.pos), int(hero.r),int(hero.g),int(hero.b),int(hero.w)) #####################################################################