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)
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)
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)
def cloud_to_device_listener(self):
"""Listens in a seperate thread to incoming cloud-to-device requests.
Can fire methods on the Raspberry Pi locally, e.g. `self.start_fan` or `self.set_telemetry_interval`
"""
while True:
method_request = self.client.receive_method_request()
print(
f"\nMethod callback called with:\nmethodName = {method_request.name}\npayload = {method_request.payload}"
)
# Case switch for different methods that can be called from the cloud
if method_request.name == "start_fan":
response_status, response_payload = self.start_fan()
elif method_request.name == "set_telemetry_interval":
response_status, response_payload = self.set_telemetry_interval(
**method_request.payload)
else:
response_payload = {
"Response":
"Direct method {} not defined".format(method_request.name)
}
response_status = 404
method_response = MethodResponse(method_request.request_id,
response_status,
payload=response_payload)
self.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)
def device_method_listener(device_client):
global message_interval
while True:
# Receive method
changed = False
method_request = device_client.receive_method_request()
print ('methodName = {}, payload = {}'.format(method_request.name, method_request.payload))
if method_request.name == "SetTelemetryInterval":
try:
message_interval = int(method_request.payload)
response_payload = {"Response": "Executed direct method {}".format(method_request.name)}
response_status = 200
changed = True
except ValueError:
response_payload = {"Response": "Invalid parameter"}
response_status = 400
else:
response_payload = {"Response": "Direct method {} not defined".format(method_request.name)}
response_status = 404
# Response method
method_response = MethodResponse(method_request.request_id, response_status, payload=response_payload)
device_client.send_method_response(method_response)
# Report
if changed:
reported_patch = {"telemetryInterval": message_interval}
device_client.patch_twin_reported_properties(reported_patch)
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))
def device_method_listener(device_client):
global INTERVAL
while True:
method_request = device_client.receive_method_request()
print(
"\nMethod callback called with:\nmethodName = {method_name}\npayload = {payload}"
.format(method_name=method_request.name,
payload=method_request.payload))
if method_request.name == "SetTelemetryInterval":
try:
INTERVAL = int(method_request.payload)
except ValueError:
response_payload = {"Response": "Invalid parameter"}
response_status = 400
else:
response_payload = {
"Response":
"Executed direct method {}".format(method_request.name)
}
response_status = 200
else:
response_payload = {
"Response":
"Direct method {} not defined".format(method_request.name)
}
response_status = 404
method_response = MethodResponse(method_request.request_id,
response_status,
payload=response_payload)
device_client.send_method_response(method_response)
def device_method_listener(device_client):
while True:
method_request = device_client.receive_method_request()
if method_request.name == "TakePicture":
try:
#Example how to read the payload content
#payload = method_request.payload
take_picture(camera_instance)
send_telemetry(device_client)
except ValueError:
response_payload = {"Response": "Invalid parameter"}
response_status = 400
else:
response_payload = {
"Response":
"Executed direct method {}".format(method_request.name)
}
response_status = 200
else:
response_payload = {
"Response":
"Direct method {} not defined".format(method_request.name)
}
response_status = 404
method_response = MethodResponse(method_request.request_id,
response_status,
payload=response_payload)
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})
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 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)
def device_method_listener(device_client):
while True:
method_request = device_client.receive_method_request()
print (
"\nMethod callback called with:\nmethodName = {method_name}\npayload = {payload}".format(
method_name=method_request.name,
payload=method_request.payload
)
)
# On appelle la bonne méthode qui correspond à l'action
if method_request.name == "CloseBlinds":
try:
room = method_request.payload
close_blinds(room)
except ValueError:
response_payload = {"Response": "Invalid parameter"}
response_status = 400
else:
response_payload = {"Response": "Executed direct method {}".format(method_request.name)}
response_status = 200
elif method_request.name == "OpenBlinds":
try:
room = method_request.payload
open_blinds(room)
except ValueError:
response_payload = {"Response": "Invalid parameter"}
response_status = 400
else:
response_payload = {"Response": "Executed direct method {}".format(method_request.name)}
response_status = 200
elif method_request.name == "IncreaseTemp":
try:
room = method_request.payload
increase_temp(room)
except ValueError:
response_payload = {"Response": "Invalid parameter"}
response_status = 400
else:
response_payload = {"Response": "Executed direct method {}".format(method_request.name)}
response_status = 200
elif method_request.name == "DecreaseTemp":
try:
room = method_request.payload
decrease_temp(room)
except ValueError:
response_payload = {"Response": "Invalid parameter"}
response_status = 400
else:
response_payload = {"Response": "Executed direct method {}".format(method_request.name)}
response_status = 200
else:
response_payload = {"Response": "Direct method {} not defined".format(method_request.name)}
response_status = 404
method_response = MethodResponse(method_request.request_id, response_status, payload=response_payload)
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)
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 wait_for_method_and_return_response(self, methodName, requestAndResponse):
# receive method request
logger.info("Waiting for method request")
request = await self.client.receive_method_request(methodName)
logger.info("Method request received")
# verify name and payload
expected_name = methodName
expected_payload = requestAndResponse.request_payload["payload"]
if request.name == expected_name:
if request.payload == expected_payload:
logger.info("Method name and payload matched. Returning response")
resp_status = requestAndResponse.status_code
resp_payload = requestAndResponse.response_payload
else:
logger.info("Request payload doesn't match")
logger.info("expected: " + expected_payload)
logger.info("received: " + request.payload)
resp_status = 500
resp_payload = None
else:
logger.info("Method name doesn't match")
logger.info("expected: '" + expected_name + "'")
logger.info("received: '" + request.name + "'")
resp_status = 404
resp_payload = None
# send method response
response = MethodResponse(
request_id=request.request_id, status=resp_status, payload=resp_payload
)
await self.client.send_method_response(response)
logger.info("Method response sent")
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))
def direct_method_listener(module_client, param_lock):
while True:
try:
print("waiting for method invocation...")
methodRequest = module_client.receive_method_request()
print("received method invocation - '{}'({})".format(
methodRequest.name, methodRequest.payload))
response = {}
response_status = 200
if methodRequest.name == "ShowText":
stShowText(methodRequest.payload, param_lock)
elif methodRequest.name == "ShowImage":
stShowImage(methodRequest.payload, param_lock)
elif methodRequest.name == "SetOptions":
stSetOptions(methodRequest.payload, param_lock)
elif methodRequest.name == "Clear":
stClear(methodRequest.payload, param_lock)
else:
response['message'] = "bad method name"
response_status = 404
response = MethodResponse(methodRequest.request_id,
response_status,
payload=response)
module_client.send_method_response(response)
except Exception as error:
print("exception happens - {}".format(error))
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)
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 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)
