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