async def main(): hostname = os.getenv("HOSTNAME") # The device that has been created on the portal using X509 CA signing or Self signing capabilities device_id = os.getenv("DEVICE_ID") x509 = X509( cert_file=os.getenv("X509_CERT_FILE"), key_file=os.getenv("X509_KEY_FILE"), pass_phrase=os.getenv("X509_PASS_PHRASE"), ) # The client object is used to interact with your Azure IoT hub. device_client = IoTHubDeviceClient.create_from_x509_certificate( hostname=hostname, device_id=device_id, x509=x509) # 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["tornado-warning"] = "yes" msg.content_encoding = "utf-8" msg.content_type = "application/json" 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, shut down the client await device_client.shutdown()
async def main(): hostname = os.getenv("HOSTNAME") # The device having a certain module that has been created on the portal # using X509 CA signing or Self signing capabilities device_id = os.getenv("DEVICE_ID") module_id = os.getenv("MODULE_ID") x509 = X509( cert_file=os.getenv("X509_CERT_FILE"), key_file=os.getenv("X509_KEY_FILE"), pass_phrase=os.getenv("PASS_PHRASE"), ) module_client = IoTHubModuleClient.create_from_x509_certificate( hostname=hostname, x509=x509, device_id=device_id, module_id=module_id ) # Connect the client. await module_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["tornado-warning"] = "yes" await module_client.send_message(msg) print("done sending message #" + str(i)) await asyncio.gather(*[send_test_message(i) for i in range(1, messages_to_send + 1)]) # finally, disconnect await module_client.disconnect()
async def main(): hostname = IOTHUB_HOSTNAME device_id = IOTHUB_DEVICE_ID x509 = X509(cert_file=X509_CERT_FILE, key_file=X509_KEY_FILE, pass_phrase=X509_PASS_PHRASE) # Create the Device Client. device_client = IoTHubDeviceClient.create_from_x509_certificate( hostname=hostname, device_id=device_id, x509=x509) # Connect the client. await device_client.connect() # get the Storage SAS information from IoT Hub. blob_name = "fakeBlobName12" storage_info = await device_client.get_storage_info_for_blob(blob_name) result = {"status_code": -1, "status_description": "N/A"} # Using the Storage Blob V12 API, perform the blob upload. try: upload_result = await upload_via_storage_blob(storage_info) if upload_result.error_code: result = { "status_code": upload_result.error_code, "status_description": "Storage Blob Upload Error", } else: result = {"status_code": 200, "status_description": ""} except ResourceExistsError as ex: if ex.status_code: result = { "status_code": ex.status_code, "status_description": ex.reason } else: print("Failed with Exception: {}", ex) result = {"status_code": 400, "status_description": ex.message} pp = pprint.PrettyPrinter(indent=4) pp.pprint(result) if result["status_code"] == 200: await device_client.notify_blob_upload_status( storage_info["correlationId"], True, result["status_code"], result["status_description"]) else: await device_client.notify_blob_upload_status( storage_info["correlationId"], False, result["status_code"], result["status_description"], ) # Finally, disconnect await device_client.disconnect()
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(): 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(): hostname = os.getenv("HOSTNAME") # The device that has been created on the portal using X509 CA signing or Self signing capabilities device_id = os.getenv("DEVICE_ID") x509 = X509( cert_file=os.getenv("X509_CERT_FILE"), key_file=os.getenv("X509_KEY_FILE"), pass_phrase=os.getenv("PASS_PHRASE"), ) # The client object is used to interact with your Azure IoT hub. device_client = IoTHubDeviceClient.create_from_x509_certificate( hostname=hostname, device_id=device_id, x509=x509 ) await device_client.connect() # Define behavior for receiving a message # NOTE: this could be a function or a coroutine def message_received_handler(message): print("the data in the message received was ") print(message.data) print("custom properties are") print(message.custom_properties) # Set the message received handler on the client device_client.on_message_received = message_received_handler # Define behavior for halting the application def stdin_listener(): while True: selection = input("Press Q to quit\n") if selection == "Q" or selection == "q": print("Quitting...") break # 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 messages await user_finished # Finally, disconnect await device_client.disconnect()
async def main(): hostname = os.getenv("IOTHUB_HOSTNAME") device_id = os.getenv("IOTHUB_DEVICE_ID") x509 = X509( cert_file=os.getenv("X509_CERT_FILE"), key_file=os.getenv("X509_KEY_FILE"), pass_phrase=os.getenv("PASS_PHRASE"), ) device_client = IoTHubDeviceClient.create_from_x509_certificate( hostname=hostname, device_id=device_id, x509=x509) # device_client = IoTHubModuleClient.create_from_connection_string(conn_str) # Connect the client. await device_client.connect() # await device_client.get_storage_info_for_blob("fake_device", "fake_method_params") # get the storage sas blob_name = "fakeBlobName12" storage_info = await device_client.get_storage_info_for_blob(blob_name) # upload to blob connection = http.client.HTTPSConnection(hostname) connection.connect() # notify iot hub of blob upload result # await device_client.notify_upload_result(storage_blob_result) storage_blob_result = await storage_blob(storage_info) pp = pprint.PrettyPrinter(indent=4) pp.pprint(storage_blob_result) connection.close() await device_client.notify_blob_upload_status( storage_info["correlationId"], True, 200, "fake status description") # Finally, disconnect await device_client.disconnect()
import time import uuid from azure.iot.device import IoTHubModuleClient, Message, X509 hostname = os.getenv("HOSTNAME") # The device having a certain module that has been created on the portal # using X509 CA signing or Self signing capabilities # The <device_id>\<module_id> should be the common name of the certificate device_id = os.getenv("DEVICE_ID") module_id = os.getenv("MODULE_ID") x509 = X509( cert_file=os.getenv("X509_CERT_FILE"), key_file=os.getenv("X509_KEY_FILE"), pass_phrase=os.getenv("PASS_PHRASE"), ) module_client = IoTHubModuleClient.create_from_x509_certificate( hostname=hostname, x509=x509, device_id=device_id, module_id=module_id) module_client.connect() # send 5 messages with a 1 second pause between each message for i in range(1, 6): 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["tornado-warning"] = "yes"
async def main(): hostname = os.getenv("HOSTNAME") # The device that has been created on the portal using X509 CA signing or Self signing capabilities device_id = os.getenv("DEVICE_ID") x509 = X509( cert_file=os.getenv("X509_CERT_FILE"), key_file=os.getenv("X509_KEY_FILE"), pass_phrase=os.getenv("PASS_PHRASE"), ) # The client object is used to interact with your Azure IoT hub. device_client = IoTHubDeviceClient.create_from_x509_certificate( hostname=hostname, device_id=device_id, x509=x509) # define behavior for receiving a message async def message_listener(device_client): while True: message = await device_client.receive_message() # blocking call print("the data in the message received was ") print(message.data) print("custom properties are") print(message.custom_properties) # define behavior for halting the application def stdin_listener(): while True: selection = input("Press Q to quit\n") if selection == "Q" or selection == "q": print("Quitting...") break # Schedule task for message listener asyncio.create_task(message_listener(device_client)) # 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 messages await user_finished # Finally, disconnect await device_client.disconnect() # if __name__ == "__main__": # asyncio.run(main()) # # CONNECTION_STRING = os.getenv("CONNECTION_STRING", "nostring") # PATH_TO_FILE = r"[/pythoniot/azure.pdf]" # # try: # os.environ["CONNECTION_STRING"] # except KeyError: # print ("Please set the connection string via docker environment") # sys.exit(1) # # # async def store_blob(blob_info, file_name): # try: # sas_url = "https://{}/{}/{}{}".format( # blob_info["hostName"], # blob_info["containerName"], # blob_info["blobName"], # blob_info["sasToken"] # ) # # print("\nUploading file: {} to Azure Storage as blob: {} in container {}\n".format(file_name, blob_info["blobName"], blob_info["containerName"])) # # # Upload the specified file # with BlobClient.from_blob_url(sas_url) as blob_client: # with open(file_name, "rb") as f: # result = blob_client.upload_blob(f, overwrite=True) # return (True, result) # # except FileNotFoundError as ex: # # catch file not found and add an HTTP status code to return in notification to IoT Hub # ex.status_code = 404 # return (False, ex) # # except AzureError as ex: # # catch Azure errors that might result from the upload operation # return (False, ex) # # async def main(): # try: # print ( "IoT Hub file upload sample, press Ctrl-C to exit" ) # # conn_str = CONNECTION_STRING # file_name = PATH_TO_FILE # blob_name = os.path.basename(file_name) # # device_client = IoTHubDeviceClient.create_from_connection_string(conn_str) # # # Connect the client # await device_client.connect() # # # Get the storage info for the blob # storage_info = await device_client.get_storage_info_for_blob(blob_name) # # # Upload to blob # success, result = await store_blob(storage_info, file_name) # # if success == True: # print("Upload succeeded. Result is: \n") # print(result) # print() # # await device_client.notify_blob_upload_status( # storage_info["correlationId"], True, 200, "OK: {}".format(file_name) # ) # # else : # # If the upload was not successful, the result is the exception object # print("Upload failed. Exception is: \n") # print(result) # print() # # await device_client.notify_blob_upload_status( # storage_info["correlationId"], False, result.status_code, str(result) # ) # # except Exception as ex: # print("\nException:") # print(ex) # # except KeyboardInterrupt: # print ( "\nIoTHubDeviceClient sample stopped" ) # # finally: # # Finally, disconnect the client # await device_client.disconnect() # # # if __name__ == "__main__": # asyncio.run(main()) # #loop = asyncio.get_event_loop() # #loop.run_until_complete(main()) # #loop.close()
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
TEMPERATURE = 20.0 HUMIDITY = 60 MSG_TXT = '{{"temperature": {temperature},"humidity": {humidity}}}' # The connection string for a device should never be stored in code. # For the sake of simplicity we are creating the X509 connection string # containing Hostname and Device Id in the following format: # "HostName=<iothub_host_name>;DeviceId=<device_id>;x509=true" #hostname = "arm-iot.azure-devices.net;SharedAccessKeyName=device;SharedAccessKey=vw7ID6nS8gIS4wyyhmtp6EOZmGnesU" hostname = 'arm-iot.azure-devices.net' # The device that has been created on the portal using X509 CA signing or Self signing capabilities device_id = "ArmDevice" x509 = X509( cert_file= "/home/minhthuc/Desktop/work-space/control-arm/azure-iot-sdk-c/azure-iot-sdk-c/tools/CACertificates/certs/azure-iot-test-only.chain.ca.ArmDevice.cert.pem", key_file= "/home/minhthuc/Desktop/work-space/control-arm/azure-iot-sdk-c/azure-iot-sdk-c/tools/CACertificates/private/new-device.key.pem", pass_phrase="1234", ) # The client object is used to interact with your Azure IoT hub. device_client = IoTHubDeviceClient.create_from_x509_certificate( hostname=hostname, device_id=device_id, x509=x509) # Connect the client. device_client.connect() # send 5 messages with a 1 second pause between each message for i in range(1, 6): temperature = TEMPERATURE + (random.random() * 15) humidity = HUMIDITY + (random.random() * 20) msg_txt_formatted = MSG_TXT.format(temperature=temperature, humidity=humidity)
async def main(): global device_client global device_symmetric_key random.seed() dps_registered = False connected = False connection_retry_count = 1 x509 = None while (not connected): # and (connection_retry_count < 3): if use_cached_credentials and os.path.exists('dpsCache.json'): dps_cache = read_dps_cache_from_file() if dps_cache[2] == device_id: dps_registered = True else: os.remove('dpsCache.json') continue else: if use_x509: # register the device using the X509 certificate current_path = os.path.dirname(os.path.abspath(__file__)) x509 = X509(cert_file=os.path.join(current_path, x509_public_cert_file), key_file=os.path.join(current_path, x509_private_cert_file), pass_phrase=x509_pass_phrase) provisioning_device_client = ProvisioningDeviceClient.create_from_x509_certificate( provisioning_host=provisioning_host, registration_id=device_id, id_scope=id_scope, x509=x509, websockets=use_websockets) else: # use symmetric key if use_group_symmetric_key: # use group symmetric key to generate a device symmetric key device_symmetric_key = derive_device_key( device_id, group_symmetric_key) provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key( provisioning_host=provisioning_host, registration_id=device_id, id_scope=id_scope, symmetric_key=device_symmetric_key, websockets=use_websockets) provisioning_device_client.provisioning_payload = '{"iotcModelId":"%s"}' % ( model_identity) registration_result = None try: 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") dps_cache = (device_symmetric_key, registration_result.registration_state.assigned_hub, registration_result.registration_state.device_id) if use_cached_credentials: write_dps_cache_to_file(dps_cache) print("The complete registration result is %s" % (registration_result.registration_state)) if registration_result.status == "assigned": dps_registered = True if dps_registered: if use_x509: # create device client on IoT Hub using the X509 certificate device_client = IoTHubDeviceClient.create_from_x509_certificate( x509=x509, hostname=registration_result.registration_state. assigned_hub, device_id=registration_result.registration_state.device_id, ) else: # create device client on IoT Hub using a device symmetric key device_client = IoTHubDeviceClient.create_from_symmetric_key( symmetric_key=dps_cache[0], hostname=dps_cache[1], device_id=dps_cache[2], websockets=use_websockets) # connect to IoT Hub try: await device_client.connect() connected = True except: print("Connection failed, retry %d of 3" % (connection_retry_count)) if os.path.exists('dpsCache.json'): os.remove('dpsCache.json') dps_registered = False connection_retry_count = connection_retry_count + 1 # add desired property listener twin_listener = asyncio.create_task(twin_patch_handler(device_client)) # add direct method listener direct_method_listener = asyncio.create_task( direct_method_handler(device_client)) # add C2D listener c2d_listener = asyncio.create_task(message_listener(device_client)) # add tasks to send telemetry (every 5 seconds) and reported properties (every 20, 25, 30 seconds respectively) telemetry_loop = asyncio.create_task(send_telemetry(device_client, 5)) reported_loop1 = asyncio.create_task( send_reportedProperty(device_client, "text", "string", 20)) reported_loop2 = asyncio.create_task( send_reportedProperty(device_client, "boolean", "bool", 25)) reported_loop3 = asyncio.create_task( send_reportedProperty(device_client, "number", "number", 30)) keyboard_loop = asyncio.get_running_loop().run_in_executor( None, keyboard_monitor, [twin_listener, direct_method_listener, c2d_listener]) #awit the tasks ending before exiting try: await asyncio.gather(twin_listener, c2d_listener, direct_method_listener, telemetry_loop, reported_loop1, reported_loop2, reported_loop3, keyboard_loop) except asyncio.CancelledError: pass # ignore the cancel actions on twin_listener and direct_method_listener # finally, disconnect print("Disconnecting from IoT Hub") await device_client.disconnect()