def FW_updater_listener(device_client): while True: method_request = device_client.receive_method_request("FW_Update") fw_info_from_method = method_request.payload print( str(datetime.datetime.now()), "Received Firmware Upgrade Request: Version" + str(fw_info_from_method) + ", Initialiazing...") time.sleep(2) if fw_info >= fw_info_from_method: payload = { "result": False, "data": ("The Firmware Version Now is " + str(fw_info) + ", Update Cancelled") } status = 403 # set return status code print( str(datetime.datetime.now()), "The Firmware Version is Latest, Firmware Upgrade Cancelled") method_response = MethodResponse.create_from_method_request( method_request, status, payload) # send response device_client.send_method_response(method_response) if fw_info < fw_info_from_method: payload = { "result": True, "data": ("The Firmware Version Now is " + str(fw_info) + ", Update Task Now Begin...") } status = 200 # set return status code method_response = MethodResponse.create_from_method_request( method_request, status, payload) # send response device_client.send_method_response(method_response) print(str(datetime.datetime.now()), "Step 1: New Firmware Version " + str(fw_info_from_method), "is Set, Firmware Downloading...") time.sleep(2) print(str(datetime.datetime.now()), "Step 2: Downloading Success, Validation Firmware file...") time.sleep(2) print( str(datetime.datetime.now()), "Step 3: Firmware Validation Passed, Start Firmware Upgrading..." ) time.sleep(2) print(str(datetime.datetime.now()), "Step 4: Upgrading Sucessful, Rebooting Device...") time.sleep(2) print(str(datetime.datetime.now()), "Step 5: Device Successful Reconnected !!!")
async def method_handler(method_request): if method_request.name == "get_data": print("Received request for data") method_response = MethodResponse.create_from_method_request( method_request, 200, "some data") await client.send_method_response(method_response) else: print("Unknown method request received: {}".format( method_request.name)) method_response = MethodResponse.create_from_method_request( method_request, 400, None) await client.send_method_response(method_response)
async def direct_method_handler(method_request): print(f'executing direct method: {method_request.name}({method_request.payload})') if method_request.name == 'speak_to_me': # speaks the message via the Raspberry Pi onboard sound # plug in a pair of headphones to the 3.5mm jack to hear # uses espeak, install on the Pi with 'sudo apt install espeak' os.system(f'espeak "{method_request.payload}"') # send response - echo back the sent text message method_response = MethodResponse.create_from_method_request(method_request, 200, method_request.payload) else: # send bad request status code method_response = MethodResponse.create_from_method_request(method_request, 400, 'unknown command') await client.send_method_response(method_response)
def method_listener(device_client): while True: method_request = device_client.receive_method_request( "Write_Value") # Wait for method1 calls decoded_method = method_request.payload print(type(decoded_method)) print("Writing message to RTU:", decoded_method) #判断数据类型执行写入操作 if isinstance(decoded_method, dict): tty_client.write(json.dumps(decoded_method).encode()) elif isinstance(decoded_method, int): tty_client.write(decoded_method) elif isinstance(decoded_method, float): byte = pack('d', decoded_method) tty_client.write(byte) else: tty_client.write(decoded_method.encode()) payload = { "result": True, "data": "Write to RTU Successfully" } # set response payload status = 200 # set return status code method_response = MethodResponse.create_from_method_request( method_request, status, payload) device_client.send_method_response(method_response) # send response
async def method_request_handler(method_request): payload = { "result": True, "data": "There is no direct method current." } # set response payload status = 200 # set return status code print("invoked method: " + method_request.name) if method_request.name == "ShellCommandExecute": if "command" in method_request.payload and "args" in method_request.payload: commandStr = method_request.payload["command"] argsStr = method_request.payload["args"] proc = subprocess.run("{} {}".format(commandStr, argsStr), shell=True, stdout=PIPE) payload = {"result": str(proc.stdout)} else: payload = { "request": "bad payload. command and args are necessary!" } status = 400 print("invoked method: " + method_request.name) # Send the response method_response = MethodResponse.create_from_method_request( method_request, status, payload) await module_client.send_method_response(method_response)
async def command_listener(device_client): # Loop forever waiting for commands while True: # Wait for commands from IoT Central method_request = await device_client.receive_method_request("TooBright" ) # Log that the command was received timestamp = datetime.strptime( datetime.now().strftime('%Y-%m-%d %H:%M %S'), '%Y-%m-%d %H:%M %S') print(timestamp, end='') print(" Too Bright Command handled") # Asynchronously light the LED # This will be run in the background, so the result can # be returned to IoT Central straight away, not 10 seconds later asyncio.gather(light_led(LED1, 10)) # IoT Central expects a response from a command, saying if the call # was successful or not, so send a success response payload = {"result": True} # Build the response method_response = MethodResponse.create_from_method_request( method_request, 200, payload) # Send the response to IoT Central await device_client.send_method_response(method_response)
async def command_handler(method_request): print("Message received:", method_request.name) print("Message payload:", method_request.payload) # Determine how to respond to the command based on the IoT Hub direct method method name # which is the same as the IoT Central command name if method_request.name == "On": # For an On request, set the color based on the payload await set_color(method_request.payload) print("executed on") elif method_request.name == "Off": # For an Off request, set the color to 000000, which turns the pixels off await set_color("000000") print("executed off") else: print("Received unknown method: " + method_request.name) # Method calls have to return a response so IoT Central knows it was handled correctly, # So send a 200 response to show we handled this payload = {"result": True} status = 200 # Send the response method_response = MethodResponse.create_from_method_request(method_request, status, payload) await device_client.send_method_response(method_response)
async def process_request(self, command_request): try: if command_request.name == "turnValveOn": user_command_handler=turn_valve_on_handler create_user_response_handler=turn_valve_on_response elif command_request.name == "turnValveOff": user_command_handler=turn_valve_off_handler create_user_response_handler=turn_valve_off_response else: print ("Unknown command: {0}".format(command_request.name)) return print ("Processing command: {0}".format(command_request.name)) values = {} if command_request.payload: values = command_request.payload await user_command_handler(self.__iot_device, values) response_status = 200 response_payload = await create_user_response_handler(self.__iot_device, self.__device_client, values) command_response = MethodResponse.create_from_method_request( command_request, response_status, response_payload ) await self.__device_client.send_method_response(command_response) except Exception as e: print("responding to the {command} command failed with {excep}".format(command=command_request.name, excep=e))
async def execute_command_listener( device_client, method_name, user_command_handler, create_user_response_handler ): while True: if method_name: command_name = method_name else: command_name = None command_request = await device_client.receive_method_request(command_name) print("Command request received with payload") print(command_request.payload) values = {} if not command_request.payload: print("Payload was empty.") else: values = command_request.payload await user_command_handler(values) response_status = 200 response_payload = create_user_response_handler(values) command_response = MethodResponse.create_from_method_request( command_request, response_status, response_payload ) try: await device_client.send_method_response(command_response) except Exception: print("responding to the {command} command failed".format(command=method_name))
async def command_listener(device_client): while True: method_request = await device_client.receive_method_request() print('Call made to', method_request.name) payload = method_request.payload print('payload', payload) try: parsed = json.loads(payload) payload = parsed except: pass print('parsed payload', payload) await set_color(payload) response_payload = {'result': True, 'data': payload} method_response = MethodResponse.create_from_method_request( method_request, 200, response_payload ) await device_client.send_method_response(method_response) # Write the color back as a property # encode the data as base64 as arrays are not supported in device twins json_string = json.dumps(payload) encoded = base64.b64encode(json_string.encode("utf-8")).decode('ascii') patch = {'encoded_color' : encoded} print('Patch:', patch) await device_client.patch_twin_reported_properties(patch)
async def method_request_handler(method_request): # Determine how to respond to the method request based on the method name if method_request.name == "method1": payload = { "result": True, "data": "some data" } # set response payload status = 200 # set return status code print("executed method1") elif method_request.name == "method2": payload = {"result": True, "data": 1234} # set response payload status = 200 # set return status code print("executed method2") else: payload = { "result": False, "data": "unknown method" } # set response payload status = 400 # set return status code print("executed unknown method: " + method_request.name) # Send the response method_response = MethodResponse.create_from_method_request( method_request, status, payload) await device_client.send_method_response(method_response)
async def command_listener(device_client): while True: method_request = await device_client.receive_method_request() print('Call made to', method_request.name) colour = method_request.payload print('payload', colour) if isinstance(colour, dict): colour = colour['colour'] print('payload2', colour) set_colour(colour) payload = {'result': True, 'data': colour} method_response = MethodResponse.create_from_method_request( method_request, 200, payload ) await device_client.send_method_response(method_response) # Write the colour back as a property await device_client.patch_twin_reported_properties({'colour':colour})
def cloud_message_listener_thread(device_client, loop, device_name): async def receive_data(request): global RECEIVED_MESSAGES logging.info(f"device name {device_name} is : {request.payload}") RECEIVED_MESSAGES += 1 logging.debug(f"mac_device_client details: {mac_device_client}") request.payload["mac"] = device_name.replace('_', ':') logging.debug(f"updated request payload: {request.payload}") await applicationDataRouter.application_data_router( request.payload, mac_appname_dict, routing_app_table) #send payload to application data router logging.info(f"Total response published {RECEIVED_MESSAGES}") while True: try: #Receive data from cloud method_request = loop.run_until_complete( device_client.receive_method_request()) # Wait for commands logging.info( f"Method request name from Iot Central: {method_request.name}") except Exception as e: logging.warning(f"error wile receiving message from cloud: {e}") try: #creating a response to be sent to Iot Hub response = MethodResponse.create_from_method_request( method_request, status=202) loop.run_until_complete( device_client.send_method_response(response)) # send response except Exception as e: logging.warning(f"Unable to send response to cloud: {e}") loop.run_until_complete(receive_data(method_request))
async def direct_method_handler(device_client): while not terminate: method_request = ( await device_client.receive_method_request() ) # Wait for unknown method calls print("executing direct method: %s(%s)" % (method_request.name, method_request.payload)) method_response = None if method_request.name == "echo": # send response - echo back the payload method_response = MethodResponse.create_from_method_request(method_request, 200, method_request.payload) else: # send bad request status code method_response = MethodResponse.create_from_method_request(method_request, 400, "unknown command") await device_client.send_method_response(method_response)
def method2_listener(device_client): while True: method_request = device_client.receive_method_request("method2") # Wait for method2 calls payload = {"result": True, "data": 1234} # set response payload status = 200 # set return status code print("executed method2") method_response = MethodResponse.create_from_method_request(method_request, status, payload) device_client.send_method_response(method_response) # send response
async def method_handler_shutdown(self, method_request): """Handle a shutdown request.""" logger.debug("Shutting down because of method request, id: %s", method_request.request_id) await self.send_method_response( MethodResponse.create_from_method_request( method_request, 200, payload={"shutdown": True})) self.shutdown_flag = True
def generic_method_listener(device_client): while True: method_request = device_client.receive_method_request() # Wait for unknown method calls payload = {"result": False, "data": "unknown method"} # set response payload status = 400 # set return status code print("executed unknown method: " + method_request.name) method_response = MethodResponse.create_from_method_request(method_request, status, payload) device_client.send_method_response(method_response) # send response
async def execute_listener( device_client, component_name=None, method_name=None, user_command_handler=None, create_user_response_handler=None, ): """ Coroutine for executing listeners. These will listen for command requests. They will take in a user provided handler and call the user provided handler according to the command request received. :param device_client: The device client :param component_name: The name of the device like "sensor" :param method_name: (optional) The specific method name to listen for. Eg could be "blink", "turnon" etc. If not provided the listener will listen for all methods. :param user_command_handler: (optional) The user provided handler that needs to be executed after receiving "command requests". If not provided nothing will be executed on receiving command. :param create_user_response_handler: (optional) The user provided handler that will create a response. If not provided a generic response will be created. :return: """ while True: if component_name and method_name: command_name = component_name + "*" + method_name elif method_name: command_name = method_name else: command_name = None command_request = await device_client.receive_method_request( command_name) print("Command request received with payload") print(command_request.payload) values = pnp_helper.retrieve_values_dict_from_payload(command_request) if user_command_handler: await user_command_handler(values) else: print("No handler provided to execute") if method_name: response_status = 200 else: response_status = 404 if not create_user_response_handler: response_payload = pnp_helper.create_command_response_payload( method_name) else: response_payload = create_user_response_handler(values) command_response = MethodResponse.create_from_method_request( command_request, response_status, response_payload) try: await device_client.send_method_response(command_response) except Exception: print("responding to the {command} command failed".format( command=method_name))
async def command_listener(device_client): global mode while True: method_request = await device_client.receive_method_request() payload = {'result': True, 'data': method_request.name} method_response = MethodResponse.create_from_method_request( method_request, 200, payload ) await device_client.send_method_response(method_response)
async def blink_command(request): print('Received synchronous call to blink') response = MethodResponse.create_from_method_request( request, status=200, payload={ 'description': f'Blinking LED every {request.payload} seconds' }) await device_client.send_method_response(response) # send response print(f'Blinking LED every {request.payload} seconds')
async def method_handler(method_request): if method_request.name == "get_data": print("Received request for data") method_response = MethodResponse.create_from_method_request( method_request, 200, "some data") await module_client.send_method_response(method_response) elif method_request.name == "shutdown": print("Received request to shut down") method_response = MethodResponse.create_from_method_request( method_request, 200, None) await module_client.send_method_response(method_response) # Setting this event will cause client shutdown finished.set() else: print("Unknown method request received: {}".format( method_request.name)) method_response = MethodResponse.create_from_method_request( method_request, 400, None) await module_client.send_method_response(method_response)
async def coffeeoff_listener(device_client): while True: print("Wait for next coffeeoff method call") method_request = await device_client.receive_method_request( "coffeeoff") response = requests.get(url="http://myStrom-Coffee/relay?state=0") payload = {"result": response.ok} status = 200 method_response = MethodResponse.create_from_method_request( method_request, status, payload) await device_client.send_method_response(method_response) print("Executed coffeeoff")
async def pump_water_command(device_client, method_request): # method_request = await device_client.receive_method_request( # "pump_water" # ) # Wait for method1 calls water_plant() payload = {"result": True} # set response payload status = 200 # set return status code method_response = MethodResponse.create_from_method_request( method_request, status, payload) await device_client.send_method_response(method_response)
async def get_plant_metrics_command(device_client, method_request): # method_request = await device_client.receive_method_request( # "get_plant_metrics" # ) # Wait for method1 calls readings = get_readings() payload = {"result": True, "data": readings} # set response payload status = 200 # set return status code print("Sending plant metrics to IoT Hub") method_response = MethodResponse.create_from_method_request( method_request, status, payload) await device_client.send_method_response(method_response)
def generic_method_listener(device_client): while True: method_request = (device_client.receive_method_request() ) # Wait for unknown method calls # set response payload payload = {"result": False, "data": "Unrecognized Method"} status = 400 # set return status code print(str(datetime.datetime.now()), "Receiving Unknown Method: " + method_request.name) method_response = MethodResponse.create_from_method_request( method_request, status, payload) # send response device_client.send_method_response(method_response)
async def failure_request_listener(device_client_PyPi): while True: # 1). wait for unknown method call method_request = (await device_client_PyPi.receive_method_request()) print("executed unknown method: " + method_request.name) # 2). set response payload & return status code payload = {"result": False, "data": "unknown method"} status = 400 # 3). send response method_response = MethodResponse.create_from_method_request( method_request, status, payload) await device_client_PyPi.send_method_response(method_response)
def method_request_handler(method_request): if method_request.name == "reboot": payload = {"result": True, "data": "some data"} status = 200 ## RESENDING ANSWER method_response = MethodResponse.create_from_method_request( method_request, status, payload) device_client.send_method_response(method_response) print("executed reboot") ## SEND REPORTED PROPERTY TO TWIN reported_properties = {"bootstatus": "ok"} device_client.patch_twin_reported_properties(reported_properties) else: payload = {"result": False, "data": "unknown method"} status = 400 ## RESENDING ANSWER method_response = MethodResponse.create_from_method_request( method_request, status, payload) device_client.send_method_response(method_response) print("executed unknown method: " + method_request.name)
async def method_request_handler(method_request): print("Received message") print(method_request.payload) status = 400 # set return status code if method_request.name == 'invokeDetectedObjectsMessage': print("Calling function to output detectedObjects message") status = await send_detectedObjects_message(method_request.payload) else: print('Message received on unknown input route') print("Sent detectedObjects message") method_response = MethodResponse.create_from_method_request(method_request, status) await module_client.send_method_response(method_response)
async def method1_listener(module_client): while True: method_request = await module_client.receive_method_request( "method1") # Wait for method1 calls print("Message received : %s " % method_request.payload) payload = { "result": True, "data": "some data" } # set response payload status = 200 # set return status code print("executed method1") method_response = MethodResponse.create_from_method_request( method_request, status, payload) await module_client.send_method_response(method_response ) # send response
async def command_listener(device_client): while True: method_request = await device_client.receive_method_request('needs_watering') needs_watering = method_request.payload print('Needs watering:', needs_watering) payload = {'result': True} if needs_watering: led.on() else: led.off() method_response = MethodResponse.create_from_method_request( method_request, 200, payload ) await device_client.send_method_response(method_response)