async def register_device(device_symmetric_key, id_scope, device_id,
provisioning_host):
try:
id_scope = id_scope
registration_id = device_id
symmetric_key = device_symmetric_key
provisioning_host = provisioning_host
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
symmetric_key=symmetric_key,
)
registration_result = await provisioning_device_client.register()
logging.debug(f'Registration result: {registration_result.status}')
except exceptions.CredentialError:
logging.warning("Credential Error")
return False
except exceptions.ConnectionFailedError:
logging.warning("Connection Failed Error")
return False
except exceptions.ConnectionDroppedError: # error if the key is wrong
logging.warning("Connection Dropped Error")
return False
except exceptions.ClientError: # error if the device is blocked
logging.warning("ClientError")
return False
except Exception:
logging.warning("Unknown Exception")
return False
return registration_result
async def main():
provisioning_host = "global.azure-devices-provisioning.net"
id_scope = "{Scope Here}"
registration_id = "{Device Name Here}"
symmetric_key = "{Master Key Here}"
device_key = derive_device_key(registration_id,symmetric_key)
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
symmetric_key=device_key
)
registration_result = await provisioning_device_client.register()
#print(registration_result)
print("The Provision Status is :", registration_result.status)
print("The Provisioned ID is: ", registration_result.registration_state.device_id)
iot_hub_name = registration_result.registration_state.assigned_hub
print("The Assigned IoT Hub is: ", registration_result.registration_state.assigned_hub)
print("The eTag is :", registration_result.registration_state.etag)
connectiont_String_raw = "HostName={iot_hub_name}.azure-devices.net;DeviceId={registration_id};SharedAccessKey={device_key}"
connectiont_String = connectiont_String_raw.format(iot_hub_name = iot_hub_name, registration_id = registration_id, device_key = device_key)
print("The Connection String is :", connectiont_String)
async def register_device():
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host='global.azure-devices-provisioning.net',
registration_id=device_id,
id_scope=id_scope,
symmetric_key=primary_key)
return await provisioning_device_client.register()
async def __register_device(self):
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host='global.azure-devices-provisioning.net',
registration_id=self.device_id,
id_scope=self.scope,
symmetric_key=self.key,
)
return await provisioning_device_client.register()
async def provision_device(provisioning_host, id_scope, registration_id, symmetric_key, model_id):
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
symmetric_key=symmetric_key,
)
provisioning_device_client.provisioning_payload = {"modelId": model_id}
return await provisioning_device_client.register()
async def register_device():
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
symmetric_key=symmetric_key,
)
return await provisioning_device_client.register()
async def result_from_register(registration_id, symmetric_key):
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=PROVISIONING_HOST,
registration_id=registration_id,
id_scope=ID_SCOPE,
symmetric_key=symmetric_key,
)
return await provisioning_device_client.register()
async def main():
# provisions the device to IoT Central-- this uses the Device Provisioning Service behind the scenes
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
symmetric_key=symmetric_key,
)
registration_result = await provisioning_device_client.register()
print("The complete registration result is")
print(registration_result.registration_state)
if registration_result.status == "assigned":
print(
"Your device has been provisioned. It will now begin sending telemetry."
)
device_client = IoTHubDeviceClient.create_from_symmetric_key(
symmetric_key=symmetric_key,
hostname=registration_result.registration_state.assigned_hub,
device_id=registration_result.registration_state.device_id,
)
# Connect the client.
await device_client.connect()
# Send the current temperature as a telemetry message
async def send_telemetry():
print("Sending telemetry for temperature")
while True:
current_temp = random.randrange(
10, 50) # Current temperature in Celsius (randomly generated)
# Send a single temperature report message
temperature_msg = {"temperature": current_temp}
msg = Message(json.dumps(temperature_msg))
msg.content_encoding = "utf-8"
msg.content_type = "application/json"
print("Sent message")
await device_client.send_message(msg)
await asyncio.sleep(8)
send_telemetry_task = asyncio.create_task(send_telemetry())
# Run the stdin listener in the event loop
loop = asyncio.get_running_loop()
user_finished = loop.run_in_executor(None, stdin_listener)
# Wait for user to indicate they are done listening for method calls
await user_finished
send_telemetry_task.cancel()
# Finally, shut down the client
await device_client.disconnect()
async def register_device():
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=credentials.provisioning_host,
registration_id=credentials.registration_id,
id_scope=credentials.id_scope,
symmetric_key=credentials.symmetric_key)
registration_result = await provisioning_device_client.register()
print(f'Registration result: {registration_result.status}')
return registration_result
async def main():
# Connect to IoT Central and request the connection details for the device
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host="global.azure-devices-provisioning.net",
registration_id=device_id,
id_scope=id_scope,
symmetric_key=primary_key)
registration_result = await provisioning_device_client.register()
# Build the connection string - this is used to connect to IoT Central
conn_str="HostName=" + registration_result.registration_state.assigned_hub + \
";DeviceId=" + device_id + \
";SharedAccessKey=" + primary_key
# The client object is used to interact with Azure IoT Central.
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
# Connect the client.
timestamp = datetime.strptime(datetime.now().strftime('%Y-%m-%d %H:%M %S'), '%Y-%m-%d %H:%M %S')
print(timestamp, end='')
print(" Connecting ...")
await device_client.connect()
timestamp = datetime.strptime(datetime.now().strftime('%Y-%m-%d %H:%M %S'), '%Y-%m-%d %H:%M %S')
print(timestamp, end='')
print(" Connected!")
# Start the command listener
timestamp = datetime.strptime(datetime.now().strftime('%Y-%m-%d %H:%M %S'), '%Y-%m-%d %H:%M %S')
print(timestamp, end='')
print(" Start Listening ...")
listener1 = asyncio.gather(light_listener(device_client))
listener2 = asyncio.gather(temp_listener(device_client))
# async loop
async def main_loop():
while True:
await asyncio.sleep(60)
listener1 = asyncio.gather(light_listener(device_client))
listener2 = asyncio.gather(temp_listener(device_client))
# Run the async main loop forever
try:
await main_loop()
except KeyboardInterrupt:
# Cancel listening
listener1.cancel()
listener2.cancel()
finally:
# Finally, disconnect
await device_client.disconnect()
timestamp = datetime.strptime(datetime.now().strftime('%Y-%m-%d %H:%M %S'), '%Y-%m-%d %H:%M %S')
print(timestamp, end='')
print(" Disconnected!")
GPIO.cleanup()
async def connect_device(device_context):
connection_retry_count = 1
device_context["connected"] = False
while (not device_context["connected"]) and (connection_retry_count < 3):
device_context["device_symmetric_key"] = derive_device_key(
device_context["device_id"], group_symmetric_key)
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=device_context["device_id"],
id_scope=scope_id,
symmetric_key=device_context["device_symmetric_key"],
websockets=True)
# DPS payload contains the model_id of the leaf device and the gateway identity to connect them to
provisioning_device_client.provisioning_payload = (
'{{"iotcModelId":"{}", "iotcGateway":{{"iotcGatewayId": "{}" }}}}'
).format(leaf_model_identity, gateway_id)
device_context["registration_result"] = None
try:
device_context[
"registration_result"] = await provisioning_device_client.register(
)
except exceptions.CredentialError:
print("Credential Error")
except exceptions.ConnectionFailedError:
print("Connection Failed Error")
except exceptions.ConnectionDroppedError: # error if the key is wrong
print("Connection Dropped Error")
except exceptions.ClientError as inst: # error if the device is blocked
print("ClientError")
except Exception:
print("Unknown Exception")
if device_context["registration_result"] != None:
print("The complete registration result is {}".format(
device_context["registration_result"].registration_state))
if device_context["registration_result"].status == "assigned":
device_context[
"device_client"] = IoTHubDeviceClient.create_from_symmetric_key(
symmetric_key=device_context["device_symmetric_key"],
hostname=device_context["registration_result"].
registration_state.assigned_hub,
device_id=device_context["device_id"],
websockets=True)
# connect to IoT Hub
try:
await device_context["device_client"].connect()
device_context["connected"] = True
except:
print("Connection failed, retry {} of 3".format(
connection_retry_count))
connection_retry_count = connection_retry_count + 1
async def main():
# Connect to IoT Central and request the connection details for the device
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host="global.azure-devices-provisioning.net",
registration_id=device_id,
id_scope=id_scope,
symmetric_key=primary_key)
registration_result = await provisioning_device_client.register()
# Build the connection string - this is used to connect to IoT Central
conn_str="HostName=" + registration_result.registration_state.assigned_hub + \
";DeviceId=" + device_id + \
";SharedAccessKey=" + primary_key
# The client object is used to interact with Azure IoT Central.
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
# Connect the client.
print("Connecting")
await device_client.connect()
print("Connected")
# async loop that sends the telemetry
async def main_loop():
while True:
# Get the telemetry to send
telemetry = await get_telemetry()
print("Telemetry:", telemetry)
# Send the telemetry to IoT Central
await device_client.send_message(telemetry)
# Wait for a minute so telemetry is not sent to often
await asyncio.sleep(60)
# Event handler for a key being releases
def on_release(key):
global report_high_sound
# If the key that was pressed and released is the space bar,
# flag that next time a high sound value should be reported
if key == keyboard.Key.space:
print("Space pressed - will report high sound level next cycle")
report_high_sound = True
# Listen for keyboard key release events
listener = keyboard.Listener(on_release=on_release)
listener.start()
# Run the async main loop forever
await main_loop()
# Finally, disconnect
await device_client.disconnect()
async def result_from_register(registration_id, device_cert_file, device_key_file):
x509 = X509(cert_file=device_cert_file, key_file=device_key_file, pass_phrase=device_password)
provisioning_device_client = ProvisioningDeviceClient.create_from_x509_certificate(
provisioning_host=PROVISIONING_HOST,
registration_id=registration_id,
id_scope=ID_SCOPE,
x509=x509,
)
return await provisioning_device_client.register()
async def register_device():
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
symmetric_key=symmetric_key,
)
properties = {"House": "Gryffindor", "Muggle-Born": "False"}
wizard_a = Wizard("Harry", "Potter", properties)
provisioning_device_client.provisioning_payload = wizard_a
return await provisioning_device_client.register()
async def main():
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
symmetric_key=symmetric_key,
)
registration_result = await provisioning_device_client.register()
print("The complete registration result is")
print(registration_result.registration_state)
async def register_device(device_id, device_key):
"""Uses the Azure IoT Device Provisioning service to provision a device using the given key.
This returns details on the device registration, including the IoT Hub used by IoT Central.
The IoT Hub is then used to connect.
"""
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host='global.azure-devices-provisioning.net',
registration_id=device_id,
id_scope=ID_SCOPE,
symmetric_key=device_key)
return await provisioning_device_client.register()
async def result_from_register(registration_id, device_cert_file, device_key_file, protocol):
x509 = X509(cert_file=device_cert_file, key_file=device_key_file, pass_phrase=device_password)
protocol_boolean_mapping = {"mqtt": False, "mqttws": True}
provisioning_device_client = ProvisioningDeviceClient.create_from_x509_certificate(
provisioning_host=PROVISIONING_HOST,
registration_id=registration_id,
id_scope=ID_SCOPE,
x509=x509,
websockets=protocol_boolean_mapping[protocol],
)
return await provisioning_device_client.register()
async def result_from_register(registration_id, symmetric_key, protocol):
# We have this mapping because the pytest logs look better with "mqtt" and "mqttws"
# instead of just "True" and "False".
protocol_boolean_mapping = {"mqtt": False, "mqttws": True}
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=PROVISIONING_HOST,
registration_id=registration_id,
id_scope=ID_SCOPE,
symmetric_key=symmetric_key,
websockets=protocol_boolean_mapping[protocol],
)
return await provisioning_device_client.register()
async def register_device():
x509 = X509(
cert_file=os.getenv("X509_CERT_FILE"),
key_file=os.getenv("X509_KEY_FILE"),
pass_phrase=os.getenv("PASS_PHRASE"),
)
provisioning_device_client = ProvisioningDeviceClient.create_from_x509_certificate(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
x509=x509,
)
await provisioning_device_client.register()
async def main():
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
symmetric_key=symmetric_key,
)
properties = {"House": "Gryffindor", "Muggle-Born": "False"}
wizard_a = Wizard("Harry", "Potter", properties)
provisioning_device_client.provisioning_payload = wizard_a
registration_result = await provisioning_device_client.register()
print("The complete registration result is")
print(registration_result.registration_state)
async def main():
# register the gateway device
gateway_key = derive_device_key(gateway_id, group_symmetric_key)
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=gateway_id,
id_scope=scope_id,
symmetric_key=gateway_key,
websockets=True)
provisioning_device_client.provisioning_payload = (
'{{"iotcModelId":"{}"}}').format(gateway_model_id)
gateway_reg_result = None
try:
gateway_reg_result = await provisioning_device_client.register()
except exceptions.CredentialError:
print("Credential Error")
except exceptions.ConnectionFailedError:
print("Connection Failed Error")
except exceptions.ConnectionDroppedError: # error if the key is wrong
print("Connection Dropped Error")
except exceptions.ClientError as inst: # error if the device is blocked
print("ClientError")
except Exception:
print("Unknown Exception")
if gateway_reg_result != None:
print("The complete gateway registration result is {}".format(
gateway_reg_result.registration_state))
# register the leaf devices and relate them to the gateway
max_devices = 3
for x in range(1, max_devices + 1):
device_id = leaf_device_prefix + str(x)
device_list[device_id] = {}
device_list[device_id]["device_id"] = device_id
await connect_device(device_list[device_id])
#
# Do something interesting here while the devices are connected
#
# finally, disconnect - won't get here because no good termination
print("Disconnecting all devices from IoT Hub")
for device_id in device_list:
await device_list[device_id]["device_client"].disconnect()
async def main():
x509 = X509(
cert_file=os.getenv("X509_CERT_FILE"),
key_file=os.getenv("X509_KEY_FILE"),
pass_phrase=os.getenv("PASS_PHRASE"),
)
provisioning_device_client = ProvisioningDeviceClient.create_from_x509_certificate(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
x509=x509,
)
registration_result = await provisioning_device_client.register()
print("The complete registration result is")
print(registration_result.registration_state)
if registration_result.status == "assigned":
print("Will send telemetry from the provisioned device")
device_client = IoTHubDeviceClient.create_from_x509_certificate(
x509=x509,
hostname=registration_result.registration_state.assigned_hub,
device_id=registration_result.registration_state.device_id,
)
# Connect the client.
await device_client.connect()
async def send_test_message(i):
print("sending message #" + str(i))
msg = Message("test wind speed " + str(i))
msg.message_id = uuid.uuid4()
msg.correlation_id = "correlation-1234"
msg.custom_properties["count"] = i
msg.custom_properties["tornado-warning"] = "yes"
await device_client.send_message(msg)
print("done sending message #" + str(i))
# send `messages_to_send` messages in parallel
await asyncio.gather(*[send_test_message(i) for i in range(1, messages_to_send + 1)])
# finally, disconnect
await device_client.disconnect()
else:
print("Can not send telemetry from the provisioned device")
async def main():
# This should ony be done once for every Device
# vlaues from rest call - Create device
provisioning_host = "global.azure-devices-provisioning.net"
id_scope = "*************"
deviceId = "*********************"
primarykey = "*******************"
# Provision device
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=deviceId,
id_scope=id_scope,
symmetric_key=primarykey,
)
registration_result = await provisioning_device_client.register()
print(registration_result)
# Creating a client for sending data
if registration_result.status == "assigned":
print("Provisioned the device")
device_client = IoTHubDeviceClient.create_from_symmetric_key(
symmetric_key=primarykey,
hostname=registration_result.registration_state.assigned_hub,
device_id=registration_result.registration_state.device_id,
)
# Connect the client.
await device_client.connect()
msgData = '{"PeriodFrom":"2020-10-16T07:49:00Z","PeriodTo":"2020-10-16T07:50:00Z","AveragePowerConsumptionInKW":0.0,"AveragePowerGenerationInKW":27.0}'
msg = Message(msgData,
message_id=None,
content_encoding="utf-8",
content_type="application/json",
output_name=None)
await device_client.send_message(msg)
print("Send message to AssetHUB")
await device_client.disconnect()
async def main():
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
symmetric_key=symmetric_key,
)
properties = {"House": "Gryffindor", "Muggle-Born": "False"}
wizard_a = Wizard("Harry", "Potter", properties)
provisioning_device_client.provisioning_payload = wizard_a
registration_result = await provisioning_device_client.register()
print("The complete registration result is")
print(registration_result.registration_state)
if registration_result.status == "assigned":
print("Will send telemetry from the provisioned device")
device_client = IoTHubDeviceClient.create_from_symmetric_key(
symmetric_key=symmetric_key,
hostname=registration_result.registration_state.assigned_hub,
device_id=registration_result.registration_state.device_id,
)
# Connect the client.
await device_client.connect()
async def send_test_message(i):
print("sending message #" + str(i))
msg = Message("test wind speed " + str(i))
msg.message_id = uuid.uuid4()
await device_client.send_message(msg)
print("done sending message #" + str(i))
# send `messages_to_send` messages in parallel
await asyncio.gather(
*[send_test_message(i) for i in range(1, messages_to_send + 1)])
# finally, disconnect
await device_client.disconnect()
else:
print("Can not send telemetry from the provisioned device")
async def main():
# Connect to IoT Central and request the connection details for the device
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host="global.azure-devices-provisioning.net",
registration_id=device_id,
id_scope=id_scope,
symmetric_key=key)
registration_result = await provisioning_device_client.register()
# Build the connection string - this is used to connect to IoT Central
conn_str="HostName=" + registration_result.registration_state.assigned_hub + \
";DeviceId=" + device_id + \
";SharedAccessKey=" + key
# The client object is used to interact with Azure IoT Central.
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
# Connect the client.
print("Connecting")
await device_client.connect()
print("Connected")
# async loop that sends the telemetry
async def main_loop():
while True:
# Get the telemetry to send
telemetry = await get_telemetry()
print("Telemetry:", telemetry)
# Send the telemetry to IoT Central
await device_client.send_message(telemetry)
# Wait for a minute so telemetry is not sent to often
await asyncio.sleep(60)
# Run the async main loop forever
await main_loop()
# Finally, disconnect
await device_client.disconnect()
async def provision_device(provisioning_host, id_scope, registration_id,
symmetric_key, model_id):
provisioning_device_client = None
try:
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
symmetric_key=symmetric_key,
)
provisioning_device_client.provisioning_payload = {"modelId": model_id}
return await provisioning_device_client.register()
except exceptions.ClientError as ex:
print(f'[Exception] : Provisioning client raised error. {ex}')
return None
except Exception as ex:
print(f'[Exception] : Exception during provisioning {ex}')
return None
async def main():
# Function for sending message
async def send_test_message():
print("Sending telemetry message from device " + device_id)
body_dict = {}
body_dict['Temperature'] = random.randrange(76, 80, 1)
body_dict['Humidity'] = random.randrange(40, 60, 1)
body_dict['Location'] = '28.424911, -81.468962'
body_json = json.dumps(body_dict)
print(body_json)
msg = Message(body_json)
msg.message_id = uuid.uuid4()
msg.correlation_id = "correlation-1234"
msg.contentEncoding = "utf-8",
msg.contentType = "application/json",
await device_client.send_message(msg)
print("Done sending message")
# update the reported properties
async def update_device_twin(device_client, led_manager):
reported_properties = {}
for i in range(8):
key = 'led' + str(i + 1) + '_status'
reported_properties[key] = led_manager.leds[i].status
key = 'led' + str(i + 1) + '_blink'
reported_properties[key] = led_manager.leds[i].blink
key = 'led' + str(i + 1) + '_r'
reported_properties[key] = led_manager.leds[i].r
key = 'led' + str(i + 1) + '_g'
reported_properties[key] = led_manager.leds[i].g
key = 'led' + str(i + 1) + '_b'
reported_properties[key] = led_manager.leds[i].b
await device_client.patch_twin_reported_properties(reported_properties)
print("Updated Device Twin's reported properties:")
printjson(reported_properties)
# define behavior for receiving a twin patch
async def twin_patch_listener(device_client, led_manager):
while True:
patch = await device_client.receive_twin_desired_properties_patch(
) # blocking call
print("Received new device twin's desired properties:")
printjson(patch)
for i in range(8):
led_status = led_manager.leds[i].status
led_blink = led_manager.leds[i].blink
led_r = led_manager.leds[i].r
led_g = led_manager.leds[i].g
led_b = led_manager.leds[i].b
key = 'led' + str(i + 1) + '_status'
if key in patch:
led_status = patch[key]
key = 'led' + str(i + 1) + '_blink'
if key in patch:
led_blink = patch[key]
key = 'led' + str(i + 1) + '_r'
if key in patch:
led_r = patch[key]
key = 'led' + str(i + 1) + '_g'
if key in patch:
led_g = patch[key]
key = 'led' + str(i + 1) + '_b'
if key in patch:
led_b = patch[key]
led_manager.set_led(i, led_status, led_r, led_g, led_b,
led_blink)
await update_device_twin(device_client, led_manager)
async def direct_methods_listener(device_client, led_manager):
while True:
method_request = (await device_client.receive_method_request()
) # Wait for unknown method calls
# Check which method was involked
if (method_request.name == "TurnLedsOff"):
# Turn all leds off
led_manager.set_all_leds_off()
response_payload = {
"result": True,
"data": "Leds are all off"
} # set response payload
response_status = 200 # set return status code
print("Executed method " + method_request.name)
elif (method_request.name == "ScrollLeds"):
# Set leds colors and start scrolling
led_manager.set_all_leds_off()
led_manager.set_all_leds_color(255, 255, 255)
led_manager.start_scrolling()
response_payload = {
"result": True,
"data": "Leds are now scrolling"
} # set response payload
response_status = 200 # set return status code
print("Executed method " + method_request.name)
else:
# Respond
response_payload = {
"result": True,
"data": "unknown method"
} # set response payload
response_status = 200 # set return status code
print("Executed unknown method: " + method_request.name)
method_response = MethodResponse.create_from_method_request(
method_request, response_status, response_payload)
await device_client.send_method_response(method_response
) # send response
# Schedule tasks for Methods and twins updates
led_listeners = asyncio.gather(led_manager.scroll_leds_task(),
led_manager.update_leds_task())
# Thread pool Executor to execute async functions in sync task
# pool = concurrent.futures.ThreadPoolExecutor()
device_id = registration_id
print("Connecting device " + device_id)
# Connect the client.
print("Provisioning device to Azure IoT...")
led_manager.set_all_leds_color(0, 255, 0)
led_manager.start_scrolling()
# registration using DPS
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
symmetric_key=symmetric_key)
registration_result = await provisioning_device_client.register()
led_manager.set_all_leds_off()
if registration_result.status == "assigned":
print("Device successfully registered. Creating device client")
# Create device client from the above result
device_client = IoTHubDeviceClient.create_from_symmetric_key(
symmetric_key=symmetric_key,
hostname=registration_result.registration_state.assigned_hub,
device_id=registration_result.registration_state.device_id,
)
else:
led_manager.set_led(0, true, 255, 0, 0, true)
print("Provisioning of the device failed.")
sys.exit()
# Connect the client.
print("Connecting to Azure IoT...")
led_manager.set_all_leds_color(0, 0, 255)
led_manager.start_scrolling()
await device_client.connect()
print("Device is connected to Azure IoT")
led_manager.set_all_leds_off()
# Update Device Twin reported properties
await update_device_twin(device_client, led_manager)
# Schedule tasks for Methods and twins updates
iothub_listeners = asyncio.gather(
direct_methods_listener(device_client, led_manager),
twin_patch_listener(device_client, led_manager))
# define behavior for halting the application
def stdin_listener():
pool = concurrent.futures.ThreadPoolExecutor()
while True:
print(
"To control the leds from Azure IoT, you can send the following commands through Direct Methods: TurnLedsOff, ScrollLeds"
)
selection = input(
"Commands: \n Q: quit\n S: Send a telemetry message\n")
if selection == "Q" or selection == "q":
print("Quitting...")
break
elif selection == "S" or selection == "s":
# send 8 messages one after the other with a sleep
result = pool.submit(asyncio.run, send_test_message()).result()
loop = asyncio.get_running_loop()
user_finished = loop.run_in_executor(None, stdin_listener)
# Wait for user to indicate they are done listening for messages
await user_finished
# Cancel listening
led_listeners.cancel()
iothub_listeners.cancel()
# finally, disconnect
await device_client.disconnect()
async def provision_devices(self, Id):
# First up we gather all of the needed provisioning meta-data and secrets
try:
self.id_device = Id
self.namespace = self.config["Device"]["NameSpace"]
self.device_default_component_id = self.config["Device"][
"DefaultComponentId"]
self.device_name_prefix = self.config["Device"]["DeviceNamePrefix"]
self.device_name = self.device_name_prefix.format(
id=self.id_device)
self.device_default_component_id = self.config["Device"][
"DefaultComponentId"]
# Load all our cache data
self.load_caches()
# this is our working device for things we provision in this session
self.device_to_provision = self.create_device_to_provision()
self.logger.info(
"************************************************")
self.logger.info("[%s] DEVICE TO PROVISION" % self.class_name_map)
self.logger.info(pprint.pformat(self.device_to_provision))
self.logger.info(
"************************************************")
# Azure IoT Central SDK Call to create the provisioning_device_client
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=self.secrets.get_provisioning_host(),
registration_id=self.device_to_provision["Device"]["Name"],
id_scope=self.secrets.get_scope_id(),
symmetric_key=self.device_to_provision["Device"]["Secrets"]
["DeviceSymmetricKey"],
websockets=True)
# Azure IoT Central SDK call to set the payload and provision the device
provisioning_device_client.provisioning_payload = '{"iotcModelId":"%s"}' % (
self.device_to_provision["Device"]["DefaultComponentId"])
registration_result = await provisioning_device_client.register()
self.logger.info("[%s] RESULT %s" %
(self.class_name_map, registration_result))
self.logger.info(
"[%s] DEVICE SYMMETRIC KEY %s" %
(self.class_name_map, self.device_to_provision["Device"]
["Secrets"]["DeviceSymmetricKey"]))
self.device_to_provision["Device"]["Secrets"][
"AssignedHub"] = registration_result.registration_state.assigned_hub
# Add Capabilities/Interfaces
#for node in self.config["Nodes"]:
#self.device_to_provision["Device"]["Capabilities"].append(node["InterfaceInstanceName"])
# Update Secrets Cache Data for Devices
existing_device = [
x for x in self.secrets_cache_data["Devices"] if x["Device"]
["Name"] == self.device_to_provision["Device"]["Name"]
]
if len(existing_device) == 0:
self.secrets_cache_data["Devices"].append(
self.device_to_provision)
else:
index = 0
for device in self.secrets_cache_data["Devices"]:
if device["Device"]["Name"] == self.device_to_provision[
"Device"]["Name"]:
self.secrets_cache_data["Devices"][index][
"Device"] = self.device_to_provision["Device"]
break
else:
index = index + 1
# Update Full Device Information to the Secrets file.
# IMPORTANT: This hides the secrets in file in .gitignore
self.secrets.update_file_device_secrets(
self.secrets_cache_data["Devices"])
# Hide secrets from device cache file
self.device_to_provision["Device"]["Secrets"] = None
existing_device = [
x for x in self.devices_cache_data["Devices"] if x["Device"]
["Name"] == self.device_to_provision["Device"]["Name"]
]
if len(existing_device) == 0:
self.devices_cache_data["Devices"].append(
self.device_to_provision)
index = 0
for device in self.devices_cache_data["Devices"]:
if device["Device"]["Name"] == self.device_to_provision[
"Device"]["Name"]:
self.devices_cache_data["Devices"][index][
"Device"] = self.device_to_provision["Device"]
break
else:
index = index + 1
self.devices_cache.update_file(self.devices_cache_data)
self.logger.info(
"************************************************")
self.logger.info("[%s] SUCCESS:" % self.class_name_map)
self.logger.info(pprint.pformat(self.device_to_provision))
self.logger.info(
"************************************************")
return
except Exception as ex:
self.logger.error("[ERROR] %s" % ex)
self.logger.error(
"[TERMINATING] We encountered an error in provision_devices()")
async def main():
# Connect to IoT Central and request the connection details for the device
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host="global.azure-devices-provisioning.net",
registration_id=device_id,
id_scope=id_scope,
symmetric_key=primary_key)
registration_result = await provisioning_device_client.register()
# Build the connection string - this is used to connect to IoT Central
conn_str="HostName=" + registration_result.registration_state.assigned_hub + \
";DeviceId=" + device_id + \
";SharedAccessKey=" + primary_key
# The client object is used to interact with Azure IoT Central.
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
# Connect the client.
print("Connecting")
await device_client.connect()
print("Connected")
# Asynchronously wait for commands from IoT Central
# If the TooLoud command is called, handle it and output to the console
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(
"TooLoud")
# Log that the command was received
print()
print("#########################")
print("Too Loud Command received")
print("#########################")
print()
# 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 loop that sends the telemetry
async def main_loop():
while True:
# Get the telemetry to send
telemetry = await get_telemetry()
print("Telemetry:", telemetry)
# Send the telemetry to IoT Central
await device_client.send_message(telemetry)
# Wait for a minute so telemetry is not sent to often
await asyncio.sleep(60)
# Event handler for a key being releases
def on_release(key):
global report_high_sound
# If the key that was pressed and released is the space bar,
# flag that next time a high sound value should be reported
if key == keyboard.Key.space:
print("Space pressed - will report high sound level next cycle")
report_high_sound = True
# Listen for keyboard key release events
listener = keyboard.Listener(on_release=on_release)
listener.start()
# Start the command listener
command_listeners = asyncio.gather(command_listener(device_client))
# Run the async main loop forever
await main_loop()
# Cancel listening
command_listeners.cancel()
# Finally, disconnect
await device_client.disconnect()
async def auth_and_connect(self):
if self._isConnected:
return
model_id = self._modelDev.model_id()
auth_conf = self._modelConfig.auth_props()
if auth_conf.get(ModelConfigBase.IOTHUB_DEVICE_DPS_AUTH_MODE):
print ("auth.mode", auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_AUTH_MODE] )
if self._modelConfig.is_x509_mode():
x509 = X509(
cert_file=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_X509_CERT],
key_file=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_X509_KEY],
pass_phrase=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_X509_PASS],
)
provisioning_device_client = ProvisioningDeviceClient.create_from_x509_certificate(
provisioning_host=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_ENDPOINT],
registration_id=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_DEVICE_ID],
id_scope=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_ID_SCOPE],
x509=x509,
)
else:
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_ENDPOINT],
registration_id=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_DEVICE_ID],
id_scope=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_ID_SCOPE],
symmetric_key=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_DEVICE_KEY]
)
provisioning_device_client.provisioning_payload = {
"modelId": model_id
}
try:
registration_result = await provisioning_device_client.register()
if registration_result.status != "assigned":
print("Could not provision device.")
return ErrorCode.AuthenticationFailed
else:
print("Device was assigned")
except:
print("Connection error.")
return ErrorCode.ConnectionFailed
registration_state = registration_result.registration_state
print(registration_state.assigned_hub)
print(registration_state.device_id)
if self._modelConfig.is_x509_mode():
x509 = X509(
cert_file=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_X509_CERT],
key_file=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_X509_KEY],
pass_phrase=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_X509_PASS],
)
device_client = IoTHubDeviceClient.create_from_x509_certificate(
x509=x509,
hostname=registration_state.assigned_hub,
device_id=registration_state.device_id,
product_info=model_id,
connection_retry=False
)
else:
device_client = IoTHubDeviceClient.create_from_symmetric_key(
symmetric_key=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_DEVICE_KEY],
hostname=registration_state.assigned_hub,
device_id=registration_state.device_id,
product_info=model_id,
connection_retry=False
)
await device_client.connect()
twin = await device_client.get_twin()
if 'desired' in twin:
desiredProps = twin['desired']
del (desiredProps)['$version']
for name in iter(desiredProps):
self._modelDev.set_prop(name, desiredProps[name])
del (twin['reported'])['$version']
props = self._modelDev.props()
if props != twin['reported']:
await device_client.patch_twin_reported_properties(props)
device_client.on_method_request_received = self._method_request_handler
device_client.on_twin_desired_properties_patch_received = self._twin_patch_handler
device_client.on__message_received = self._message_received_handler
self._clientHandle = device_client
self._isConnected = True
return ErrorCode.Success
