async def main():
# The connection string for a device should never be stored in code. For the sake of simplicity we're using an environment variable here.
conn_str = os.getenv("IOTHUB_DEVICE_CONNECTION_STRING")
proxy_opts = ProxyOptions(
proxy_type=socks.HTTP,
proxy_addr="127.0.0.1",
proxy_port=8888 # localhost
)
# The client object is used to interact with your Azure IoT hub.
device_client = IoTHubDeviceClient.create_from_connection_string(
conn_str, websockets=True, proxy_options=proxy_opts)
# 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"
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()
async def main():
with open("private.json", "r") as read_file:
config = json.load(read_file)
device_client = IoTHubDeviceClient.create_from_connection_string(config["connection-string"])
await device_client.connect()
last_temp = ""
done = False
sample_count = 0
max_samples = 64
while not (done):
temp = "{0:0.1f}".format(get_temp())
print("data", temp)
if temp != last_temp:
last_temp = temp;
data = {}
data['sample'] = temp
json_body = json.dumps(data)
print("Sending message: ", json_body)
sample_count += 1
await device_client.send_message(json_body)
done = (sample_count > max_samples)
time.sleep(30)
await device_client.disconnect()
def create_client():
# Create an IoT Hub client
client = IoTHubDeviceClient.create_from_connection_string(CONNECTION_STRING)
# Define a method request handler
async def method_request_handler(method_request):
if method_request.name == "SetTelemetryInterval":
try:
global INTERVAL
INTERVAL = int(method_request.payload)
except ValueError:
response_payload = {"Response": "Invalid parameter"}
response_status = 400
else:
response_payload = {"Response": "Executed direct method {}".format(method_request.name)}
response_status = 200
else:
response_payload = {"Response": "Direct method {} not defined".format(method_request.name)}
response_status = 404
method_response = MethodResponse.create_from_method_request(method_request, response_status, response_payload)
await client.send_method_response(method_response)
try:
# Attach the method request handler
client.on_method_request_received = method_request_handler
except:
# Clean up in the event of failure
client.shutdown()
raise
return client
async def main():
conn_str = "HostName=5G-IoT-System-For-Emergency-Responders.azure-devices.net;DeviceId=application_device1;SharedAccessKey=x84oYfc8Wm4lL7nfMzNm87X7YmFbC+TtHX4ny+bV8ck="
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
# Connect the device client.
await device_client.connect()
# Send a few messages
count = 0
tempFile = open("/sys/class/thermal/thermal_zone0/temp", "r")
while count < 5:
cpu_temp = tempFile.read()
cpu_temp_float = float(cpu_temp)
tempFile.seek(0)
print("Sending message to Azure IoT...")
msg = Message("Environment sensor")
msg.message_id = uuid.uuid4()
msg.custom_properties["Temperature"] = cpu_temp_float
await device_client.send_message(msg)
print("Message successfully sent:")
print(msg.custom_properties)
count = count + 1
time.sleep(10)
# finally, disconnect
await device_client.disconnect()
sys.exit(0)
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():
# The connection string for a device should never be stored in code. For the sake of simplicity we're using an environment variable here.
# NOTE: connection string must contain ;GatewayHostName=<hostname of your iot edge device>
# make sure your IoT Edge box is setup as a 'transparent gateway' per the IOT Edge documentation
conn_str = os.getenv("IOTHUB_DEVICE_CONNECTION_STRING")
# path to the root ca cert used on your iot edge device (must copy the pem file to this downstream device)
# example: /home/azureuser/edge_certs/azure-iot-test-only.root.ca.cert.pem
ca_cert = os.getenv("IOTEDGE_ROOT_CA_CERT_PATH")
certfile = open(ca_cert)
root_ca_cert = certfile.read()
# The client object is used to interact with your Azure IoT Edge device.
device_client = IoTHubDeviceClient.create_from_connection_string(
connection_string=conn_str, server_verification_cert=root_ca_cert
)
# 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"
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():
conn_str = "<Your device connection string goes here>"
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
await device_client.connect()
last_temp = ""
while True:
temp = "{0:0.1f}".format(get_temp())
print("Temperature", temp)
if temp != last_temp:
last_temp = temp;
data = {}
data['temperature'] = temp
json_body = json.dumps(data)
print("Sending message: ", json_body)
await device_client.send_message(json_body)
twin = await device_client.get_twin()
handle_twin(twin)
time.sleep(1)
await device_client.disconnect()
async def connect(self):
try:
# load the secrets
secrets = Secrets(self.logger)
secrets.init()
self.device_secrets = secrets.get_device_secrets(self.device_name)
print("here secrets")
print(self.device_secrets)
self.device_client = IoTHubDeviceClient.create_from_symmetric_key(
symmetric_key=self.device_secrets["Device"]["Secrets"]
["DeviceSymmetricKey"],
hostname=self.device_secrets["Device"]["Secrets"]
["AssignedHub"],
device_id=self.device_name,
websockets=True)
await self.device_client.connect()
self.logger.info("[DEVICE CLIENT] %s" % self.device_client)
except Exception as ex:
self.logger.error("[ERROR] %s" % ex)
self.logger.error(
"[TERMINATING] We encountered an error creating and connecting the device in the Class::DeviceClient"
)
return None
return
async def main():
# Get the data list from our library
dataList = fileparser.get_data_list_from_wisdm('WISDM_ar_v1.1\\WISDM_ar_v1.1_raw.txt')
# Fetch the connection string from an enviornment variable
conn_str = "HostName=berlinHub.azure-devices.net;DeviceId=subject_33;SharedAccessKey=wMVcHCziLXiH6CQRf/uz8uUnHIiQjkF1yAPKQ9t5iHU="
# Create instance of the device client using the connection string
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
# Connect the device client.
await device_client.connect()
# Loop through the data and send to IoT Hub
for data in dataList:
msg_txt_formatted = MSG_TXT.format(user=data.user, activity=data.activity, timestamp=data.timestamp, x=data.x, y=data.y, z=data.z)
message = Message(msg_txt_formatted)
print( "Sending message: {}".format(message) )
await device_client.send_message(message)
print ( "Message successfully sent" )
time.sleep(MSG_INTERVAL)
await device_client.shutdown()
async def connect(self):
try:
# Get the device secrets from the Secrets section for Devices, this
# is captured and written during provisioning
self.device_secrets = [
x for x in self.secrets["Devices"]
if x["Device"]["Name"] == self.device_name
]
if len(self.device_secrets) > 0:
self.device_client = IoTHubDeviceClient.create_from_symmetric_key(
symmetric_key=self.device_secrets[0]["Device"]["Secrets"]
["DeviceSymmetricKey"],
hostname=self.device_secrets[0]["Device"]["Secrets"]
["AssignedHub"],
device_id=self.device_name,
websockets=True)
await self.device_client.connect()
self.logger.info("[%s] %s" %
(self.class_name_map, self.device_client))
return
except Exception as ex:
self.logger.error("[ERROR] %s" % ex)
self.logger.error(
"[TERMINATING] We encountered an error creating and connecting the device for %s"
% self.class_name_map)
return None
async def connect(self):
deviceClient = IoTHubDeviceClient.create_from_connection_string(
self.connectionString) # iz librarya konstruktor
await deviceClient.connect(
) # await -> ceka do kad se klijent ne spoji na azure
self.device = deviceClient # device klijent spremimo u varijablu da se moze koristiti u cijeloj klasi
self.device.on_message_received = self.azureMessageCallback # callback metoda izjednacena s onom iz libraria (kad prime oni poruku, primimo i mi u svojoj)
async def main():
# The connection string for a device should never be stored in code. For the sake of simplicity we're using an environment variable here.
conn_str = os.getenv("IOTHUB_DEVICE_CONNECTION_STRING")
# The client object is used to interact with your Azure IoT hub.
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
# 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():
connection_string = os.getenv("DEVICE_CONNECTION_STRING")
device_client = IoTHubDeviceClient.create_from_connection_string(
connection_string)
await device_client.connect()
try:
values = list(map(float, sys.argv[1:])) or [42]
payload = []
for value in values:
print("Collecting value:", value)
payload.append({
"DeviceId":
"microsoft-sphere-device",
"ValueId":
"Temperature",
"Value":
value,
"TimeStamp":
datetime.datetime.now(datetime.timezone.utc)
})
await asyncio.sleep(1)
message = json.dumps(payload, default=serialize_datetime)
print("Sending message:", message)
await device_client.send_message(message)
finally:
await device_client.disconnect()
async def main():
# Scenario based values
keep_alive = 15
conn_str = "HostName=localhost;DeviceId=devicemtr;SharedAccessKey=Zm9vYmFy"
device_client = IoTHubDeviceClient.create_from_connection_string(
conn_str, keep_alive=keep_alive)
await device_client.connect()
send_message_task = asyncio.create_task(send_test_message(device_client))
# Run the listener in the event loop
# This can be a STDIN listener as well for user to indicate quitting.
loop = asyncio.get_running_loop()
finished_loops = loop.run_in_executor(None, quitting_listener)
# Wait for count times to reach a certain number indicative of completion
await finished_loops
print(elapsed_times)
try:
send_message_task.cancel()
except asyncio.CancelledError:
print("send message task is cancelled now")
await device_client.disconnect()
async def device_cloud_connection(device_symmetric_key, id_scope, device_id,
provisioning_host):
try:
registration_result = await register_device(device_symmetric_key,
id_scope, device_id,
provisioning_host)
logging.debug(
f"registration result is: !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! {registration_result}"
)
try:
if registration_result.status == 'assigned':
device_client = IoTHubDeviceClient.create_from_symmetric_key(
symmetric_key=device_symmetric_key,
hostname=registration_result.registration_state.
assigned_hub,
device_id=registration_result.registration_state.device_id,
)
logging.debug(f"Trying to connect")
# Connect the client.
await device_client.connect()
logging.info('Device connected successfully')
await device_client.disconnect()
return device_client
else:
logging.debug(
f"returning cloud connection device client value : !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
)
return False
except Exception as e:
logging.warning(f"Error while registering device.. {e} ")
except Exception as e:
logging.error(f"Error connecting to Iot Hub..!!! {e}")
return False
async def main():
# The connection string for a device should never be stored in code. For the sake of simplicity we're using an environment variable here.
conn_str = os.getenv("IOTHUB_DEVICE_CONNECTION_STRING")
# The client object is used to interact with your Azure IoT hub.
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
# connect the client.
await device_client.connect()
# define behavior for receiving a twin patch
# NOTE: this could be a function or a coroutine
def twin_patch_handler(patch):
print("the data in the desired properties patch was: {}".format(patch))
# set the twin patch handler on the client
device_client.on_twin_desired_properties_patch_received = twin_patch_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 receive_cloud_message():
device_client = IoTHubDeviceClient.create_from_connection_string(
DEVICE_CONN_STRING)
await device_client.connect()
async def message_listener(device_client):
while True:
message = await device_client.receive_message()
print("the data in the message received was ")
print(message.data)
await analyze_msg(message.data)
def stdin_listener():
while True:
selection = input("Press Q to quit\n")
if selection == "Q" or selection == "q":
print("Quitting...")
break
asyncio.create_task(message_listener(device_client))
loop = asyncio.get_running_loop()
user_finished = loop.run_in_executor(None, stdin_listener)
await user_finished
await device_client.disconnect()
async def main():
device_client = IoTHubDeviceClient.create_from_connection_string(
"HostName=YOURAZUREACCOUNT.azure-devices.net;DeviceId=Pi_Envirnoment;SharedAccessKey=YOURSHAREDACCESSKEY"
)
await device_client.connect()
async def twin_patch_listener(device_client):
while True:
patch = await device_client.receive_twin_desired_properties_patch(
) # blocking call
print("the data in the desired properties patch was: {}".format(
patch))
def quit_listener():
while True:
selection = input("Press Q to quit\n")
if selection == "Q" or selection == "q":
print("Quitting...")
break
asyncio.create_task(twin_patch_listener(device_client))
loop = asyncio.get_running_loop()
user_finished = loop.run_in_executor(None, quit_listener)
await user_finished
await device_client.disconnect()
async def main():
# The connection string for a device should never be stored in code. For the sake of simplicity we're using an environment variable here.
conn_str = os.getenv("IOTHUB_DEVICE_CONNECTION_STRING")
# The client object is used to interact with your Azure IoT hub.
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
# Connect the client.
await device_client.connect()
node = cellulariot.CellularIoTApp()
node.setupGPIO()
node.disable()
time.sleep(1)
node.enable()
async def sensor_data():
msg = Message("Acceleration: "+str(node.readAccel())+"; "+"Humidity: " + str(node.readHum())+"; "+"Temperature: " + str(node.readTemp())+"; "+"Lux: " + str(node.readLux())+"; "+"ADC1: " + str(node.readAdc(0))+"; "+"ADC2: " + str(node.readAdc(1))+"; "+"ADC3: " + str(node.readAdc(2))+"; "+"ADC4: " + str(node.readAdc(3)))
msg.message_id = uuid.uuid4()
msg.correlation_id = "correlation-1234"
await device_client.send_message(msg)
count = 0
while(True):
await sensor_data()
print("#"+str(count)+" sent data")
count = count+1
time.sleep(1)
def connect(self, transport_type, connection_string, cert):
print("connecting using " + transport_type)
auth_provider = auth.from_connection_string(connection_string)
if "GatewayHostName" in connection_string:
auth_provider.ca_cert = cert
self.client = IoTHubDeviceClient.from_authentication_provider(
auth_provider, transport_type)
async_helper.run_coroutine_sync(self.client.connect())
async def main():
# provision the device
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()
results = await asyncio.gather(register_device())
registration_result = results[0]
# build the connection string
conn_str='HostName=' + registration_result.registration_state.assigned_hub + \
';DeviceId=' + device_id + \
';SharedAccessKey=' + primary_key
# The client object is used to interact with your Azure IoT Central.
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
# connect the client.
print('Connecting')
await device_client.connect()
print('Connected')
# listen for commands
async def command_listener(device_client):
global mode
while True:
method_request = await device_client.receive_method_request()
payload = {'result': True, 'data': method_request.name}
method_response = MethodResponse.create_from_method_request(
method_request, 200, payload
)
await device_client.send_method_response(method_response)
# async loop that controls the lights
async def main_loop():
while True:
telemetry = getTelemetryData()
print(telemetry)
await device_client.send_message(telemetry)
await asyncio.sleep(1)
listeners = asyncio.gather(command_listener(device_client))
await main_loop()
# Cancel listening
listeners.cancel()
# Finally, disconnect
await device_client.disconnect()
async def main():
# The connection string for a device should never be stored in code. For the sake of simplicity we're using an environment variable here.
conn_str = os.getenv("IOTHUB_DEVICE_CONNECTION_STRING")
# The client object is used to interact with your Azure IoT hub.
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
# connect the client.
await device_client.connect()
# Define behavior for handling methods
async def method_request_handler(method_request):
# Determine how to respond to the method request based on the method name
if method_request.name == "method1":
payload = {
"result": True,
"data": "some data"
} # set response payload
status = 200 # set return status code
print("executed method1")
elif method_request.name == "method2":
payload = {"result": True, "data": 1234} # set response payload
status = 200 # set return status code
print("executed method2")
else:
payload = {
"result": False,
"data": "unknown method"
} # set response payload
status = 400 # set return status code
print("executed unknown method: " + method_request.name)
# Send the response
method_response = MethodResponse.create_from_method_request(
method_request, status, payload)
await device_client.send_method_response(method_response)
# Set the method request handler on the client
device_client.on_method_request_received = method_request_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 method calls
await user_finished
# Finally, shut down the client
await device_client.shutdown()
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 send_single_message(message_body):
device_client = IoTHubDeviceClient.create_from_connection_string(
DEVICE_CONN_STRING)
await device_client.connect()
message = Message(json.dumps(message_body),
content_type='application/json')
await device_client.send_message(message)
await device_client.disconnect()
async def InitIoTHubClient():
# Fetch the connection string from an enviornment variable
conn_str = "HostName=sameerIOTHub.azure-devices.net;DeviceId=RaspberryPi;SharedAccessKey=UBPpcMu5Hwb79ZfhnLBLz5vAF01NlndzR9OFH+/CfeA="
# Create instance of the device client using the authentication provider
global device_client
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
# Connect the device client.
await device_client.connect()
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 write_to_hub(source_path, list_of_files, counter, limit,
container_name, dest_folder):
conn_str = env.IOT_HUB_CONN_STRING
# The client object is used to interact with your Azure IoT hub.
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
# Connect the client.
await device_client.connect()
async def send_spectrogram(counter):
sleep_interval = 5
while True:
for f in list_of_files:
payload = json.dumps({
'capturedate': time.time(),
'filename': f,
'finished': 'False'
})
azure_interface = AzureInterface(container_name)
azure_interface.send_to_azure(join_paths([source_path, f]),
dest_folder,
f,
media_file=True)
msg = build_message(payload)
await device_client.send_message(msg)
logger.info("done sending file " + str(f))
counter['count'] += 1
logger.info(counter['count'])
await asyncio.sleep(sleep_interval)
# Define behavior for halting the application
def stdin_listener(counter, limit):
while True:
try:
if counter['count'] == limit:
logger.info('Quitting...')
logger.info('File limit reached %s', str(limit))
break
except EOFError as e:
time.sleep(10000)
tasks = asyncio.gather(send_spectrogram(counter))
# Run the stdin listener in the event loop
loop = asyncio.get_running_loop()
user_finished = loop.run_in_executor(None, stdin_listener, counter, limit)
# Wait for user to indicate they are done listening for method calls
await user_finished
# Cancel tasks
tasks.add_done_callback(lambda r: r.exception())
tasks.cancel()
await device_client.disconnect()
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 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 main():
async def register_device(registration_id):
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
symmetric_key=device_ids_to_keys[registration_id],
)
return await provisioning_device_client.register()
results = await asyncio.gather(register_device(device_id_1),
register_device(device_id_2),
register_device(device_id_3))
clients_to_device_ids = {}
for index in range(0, len(results)):
registration_result = results[index]
print("The complete state of registration result is")
print(registration_result.registration_state)
if registration_result.status == "assigned":
device_id = registration_result.registration_state.device_id
print(
"Will send telemetry from the provisioned device with id {id}".
format(id=device_id))
device_client = IoTHubDeviceClient.create_from_symmetric_key(
symmetric_key=device_ids_to_keys[device_id],
hostname=registration_result.registration_state.assigned_hub,
device_id=registration_result.registration_state.device_id,
)
# Assign the Id just for print statements
device_client.id = device_id
clients_to_device_ids[device_id] = device_client
else:
print("Can not send telemetry from the provisioned device")
# connect all the clients
await asyncio.gather(
*[client.connect() for client in clients_to_device_ids.values()])
# send `messages_to_send` messages in parallel.
await asyncio.gather(*[
send_test_message(i, client)
for i, client in [(i, client) for i in range(1, messages_to_send + 1)
for client in clients_to_device_ids.values()]
])
# disconnect all the clients
await asyncio.gather(
*[client.disconnect() for client in clients_to_device_ids.values()])
