TWIN_CALLBACKS = 0 SEND_REPORTED_STATE_CALLBACKS = 0 METHOD_CALLBACKS = 0 EVENT_SUCCESS = "success" EVENT_FAILED = "failed" # chose HTTP, AMQP or MQTT as transport protocol PROTOCOL = IoTHubTransportProvider.MQTT # String containing Hostname, Device Id & Device Key in the format: # "HostName=<host_name>;DeviceId=<device_id>;SharedAccessKey=<device_key>" telemetry = Telemetry() if len(sys.argv) < 2: print ( "You need to provide the device connection string as command line arguments." ) telemetry.send_telemetry_data(None, EVENT_FAILED, "Device connection string is not provided") sys.exit(0) def is_correct_connection_string(): m = re.search("HostName=.*;DeviceId=.*;", CONNECTION_STRING) if m: return True else: return False CONNECTION_STRING = sys.argv[1] if not is_correct_connection_string(): print ( "Device connection string is not correct." ) telemetry.send_telemetry_data(None, EVENT_FAILED, "Device connection string is not correct.") sys.exit(0)
class AzureIOTHubDataSender: def __init__(self, connectionString): self.CONNECTION_STRING = connectionString self.MESSAGE_COUNT = 0 self.telemetry = Telemetry() self.client = self.iothubClientInit() if self.client.protocol == IoTHubTransportProvider.MQTT: print ( "IoTHubClient is reporting state" ) reported_state = "{\"newState\":\"standBy\"}" self.client.send_reported_state(reported_state, len(reported_state), self.sendReportedStateCallback, SEND_REPORTED_STATE_CONTEXT) self.telemetry.send_telemetry_data(self.parseIOTHubName(self.CONNECTION_STRING), EVENT_SUCCESS, "IoT hub connection is established") return def iothubClientInit(self): # prepare iothub client client = IoTHubClient(self.CONNECTION_STRING, PROTOCOL) client.set_option("product_info", "HappyPath_RaspberryPi-Python") if client.protocol == IoTHubTransportProvider.HTTP: client.set_option("timeout", TIMEOUT) client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME) # set the time until a message times out client.set_option("messageTimeout", MESSAGE_TIMEOUT) # to enable MQTT logging set to 1 if client.protocol == IoTHubTransportProvider.MQTT: client.set_option("logtrace", 0) # set callback after a message is received client.set_message_callback(self.receiveMessageCallback, RECEIVE_CONTEXT) # if MQTT or MQTT_WS is used -> set device twin callback if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS: client.set_device_twin_callback(self.deviceTwinCallback, TWIN_CONTEXT) client.set_device_method_callback(self.deviceMethodCallback, METHOD_CONTEXT) return client # Sends the given string to the Azure IOT Hub def sendStringToIOTHub(self, messageString): message = IoTHubMessage(messageString) message.message_id = "message_%d" % self.MESSAGE_COUNT message.correlation_id = "correlation_%d" % self.MESSAGE_COUNT self.client.send_event_async(message, self.sendConfirmationCallback, self.MESSAGE_COUNT) status = self.client.get_send_status() print ( "Send status: %s" % status ) self.MESSAGE_COUNT += 1 def receiveMessageCallback(self, message, counter): global RECEIVE_CALLBACKS message_buffer = message.get_bytearray() size = len(message_buffer) print ( "Received Message [%d]:" % counter ) print ( " Data: <<<%s>>> & Size=%d" % (message_buffer[:size].decode("utf-8"), size) ) map_properties = message.properties() key_value_pair = map_properties.get_internals() print ( " Properties: %s" % key_value_pair ) counter += 1 RECEIVE_CALLBACKS += 1 print ( " Total calls received: %d" % RECEIVE_CALLBACKS ) return IoTHubMessageDispositionResult.ACCEPTED def sendConfirmationCallback(self, message, result, user_context): global SEND_CALLBACKS print ( "Confirmation[%d] received for message with result = %s" % (user_context, result) ) map_properties = message.properties() print ( " message_id: %s" % message.message_id ) print ( " correlation_id: %s" % message.correlation_id ) key_value_pair = map_properties.get_internals() print ( " Properties: %s" % key_value_pair ) SEND_CALLBACKS += 1 print ( " Total calls confirmed: %d" % SEND_CALLBACKS ) def deviceTwinCallback(self, update_state, payload, user_context): global TWIN_CALLBACKS print ( "\nTwin callback called with:\nupdateStatus = %s\npayload = %s\ncontext = %s" % (update_state, payload, user_context) ) TWIN_CALLBACKS += 1 print ( "Total calls confirmed: %d\n" % TWIN_CALLBACKS ) def sendReportedStateCallback(self, status_code, user_context): global SEND_REPORTED_STATE_CALLBACKS print ( "Confirmation for reported state received with:\nstatus_code = [%d]\ncontext = %s" % (status_code, user_context) ) SEND_REPORTED_STATE_CALLBACKS += 1 print ( " Total calls confirmed: %d" % SEND_REPORTED_STATE_CALLBACKS ) def deviceMethodCallback(self, method_name, payload, user_context): global METHOD_CALLBACKS,MESSAGE_SWITCH print ( "\nMethod callback called with:\nmethodName = %s\npayload = %s\ncontext = %s" % (method_name, payload, user_context) ) METHOD_CALLBACKS += 1 print ( "Total calls confirmed: %d\n" % METHOD_CALLBACKS ) device_method_return_value = DeviceMethodReturnValue() device_method_return_value.response = "{ \"Response\": \"This is the response from the device\" }" device_method_return_value.status = 200 if method_name == "start": MESSAGE_SWITCH = True print ( "Start sending message\n" ) device_method_return_value.response = "{ \"Response\": \"Successfully started\" }" return device_method_return_value if method_name == "stop": MESSAGE_SWITCH = False print ( "Stop sending message\n" ) device_method_return_value.response = "{ \"Response\": \"Successfully stopped\" }" return device_method_return_value return device_method_return_value def print_last_message_time(self, client): try: last_message = client.get_last_message_receive_time() print ( "Last Message: %s" % time.asctime(time.localtime(last_message)) ) print ( "Actual time : %s" % time.asctime() ) except IoTHubClientError as iothub_client_error: if iothub_client_error.args[0].result == IoTHubClientResult.INDEFINITE_TIME: print ( "No message received" ) else: print ( iothub_client_error ) def parseIOTHubName(self, CONNECTION_STRING): m = re.search("HostName=(.*?)\.", CONNECTION_STRING) return m.group(1)
def is_correct_connection_string(): m = re.search("HostName=.*;DeviceId=.*;", CONNECTION_STRING) if m: return True else: return False CONNECTION_STRING = config.IOT_CONNECTION_STRING if not is_correct_connection_string(): print("Device connection string is not correct.") telemetry.send_telemetry_data( None, EVENT_FAILED, "Device connection string is not correct. Please check your connection string in config.py" ) sys.exit(0) MSG_TXT = "{\"deviceId\": \"" + config.DEVICE_ID + "\",\"timestamp\": \"%s\",\"temperature\": %f,\"humidity\": %f,\"air_pressure\": %f}" GPIO.setmode(GPIO.BCM) GPIO.setup(config.GPIO_PIN_ADDRESS, GPIO.OUT) def receive_message_callback(message, counter): global RECEIVE_CALLBACKS message_buffer = message.get_bytearray() size = len(message_buffer) print("Received Message [%d]:" % counter) print(" Data: <<<%s>>> & Size=%d" %
TWIN_CALLBACKS = 0 SEND_REPORTED_STATE_CALLBACKS = 0 METHOD_CALLBACKS = 0 EVENT_SUCCESS = "success" EVENT_FAILED = "failed" # chose HTTP, AMQP or MQTT as transport protocol PROTOCOL = IoTHubTransportProvider.MQTT # String containing Hostname, Device Id & Device Key in the format: # "HostName=<host_name>;DeviceId=<device_id>;SharedAccessKey=<device_key>" telemetry = Telemetry() if len(sys.argv) < 4: print ( "You need to provide the device <type>, <id>, <connection string> as command line arguments." ) telemetry.send_telemetry_data(None, EVENT_FAILED, "Device connection string is not provided") sys.exit(0) def is_correct_connection_string(): m = re.search("HostName=.*;DeviceId=.*;", CONNECTION_STRING) if m: return True else: return False DEVICE_TYPE = sys.argv[1] DEVICE_ID = sys.argv[2] CONNECTION_STRING = sys.argv[3] if not is_correct_connection_string(): print ( "Device connection string is not correct." ) telemetry.send_telemetry_data(None, EVENT_FAILED, "Device connection string is not correct.")