def send_iot_hub_message(hub_manager, message_dict, schema): message = json.dumps(message_dict) message = IoTHubMessage(message) message.properties().add("iothub-creation-time-utc", make_time_string()) message.properties().add("iothub-message-schema", schema) adjust_outstanding_sent_message_count(1) hub_manager.client.send_event_async("output2", message, send_confirmation_callback, 0)
def send_event(self, event, properties, send_context): if not isinstance(event, IoTHubMessage): event = IoTHubMessage(bytearray(event, 'utf8')) event.set_content_encoding_system_property('utf-8') event.set_content_type_system_property('application/json') event.properties().add('deviceId', 'RaspberryPi3') if len(properties) > 0: prop_map = event.properties() for key in properties: prop_map.add_or_update(key, properties[key]) self.client.send_event_async(event, send_confirmation_callback, send_context)
def read_and_send_measurements_from_sensehat(sense, hubManager): global SEND_SENSEHAT_CALLBACKS # sense.clear() temperature = sense.get_temperature() temperature_h = sense.get_temperature_from_humidity() temperature_p = sense.get_temperature_from_pressure() humidity = sense.get_humidity() pressure = sense.get_pressure() accelerometer = sense.get_accelerometer_raw() accel = "\"x\":{x:.5f},\"y\":{y:.5f},\"z\":{z:.5f}".format(**accelerometer) print("accelerometer - %s" % accel) timeCreated = datetime.datetime.utcnow().isoformat() MSG_TXT = "{\"temperature\": %.2f,\"temperature_h\": %.2f,\"temperature_p\": %.2f,\"humidity\": %.2f,\"pressure\": %.2f,\"accelerometer\":{%s},\"timeCreated\": \"%s\"}" msg_txt_formatted = MSG_TXT % (temperature, temperature_h, temperature_p, humidity, pressure, accel, timeCreated) print("Sending - :%s\n" % msg_txt_formatted) message = IoTHubMessage(msg_txt_formatted) prop_map = message.properties() prop_map.add("data-type", "sensing") prop_map.add("application", "Custom-vision-service-iot-edge-raspberry-pi-ext") hubManager.send_event_to_output("output2", message, 0) SEND_SENSEHAT_CALLBACKS += 1 print(" Total sensehat messages sent: %d" % SEND_SENSEHAT_CALLBACKS)
def iothub_client_sample_run(): try: if (check_internet() == True): client = iothub_client_init() print("Connecting to IoT Hub") if client.protocol == IoTHubTransportProvider.MQTT: print("IoTHubClient is reporting state") reported_state = "{\"newState\":\"standBy\"}" #client.send_reported_state(reported_state, len(reported_state), send_reported_state_callback, SEND_REPORTED_STATE_CONTEXT) #telemetry.send_telemetry_data(parse_iot_hub_name(), EVENT_SUCCESS, "IoT hub connection is established") #while True: global MESSAGE_COUNT, MESSAGE_SWITCH if MESSAGE_SWITCH: # send a few messages every minute print("IoTHubClient sending %d messages" % MESSAGE_COUNT) #temperature = sensor.read_temperature() humidity_1 = get_humidity_1() temperature_1 = get_temperature_1() distance_1 = get_distance_1() distance_2 = get_distance_2() distance_3 = get_distance_3() distance_4 = get_distance_4() distance_5 = get_distance_5() distance_6 = get_distance_6() distance_7 = get_distance_7() distance_8 = get_distance_8() #distance_9 = get_distance_9() #distance_10 = get_distance_10() msg_txt_formatted = MSG_TXT % ( distance_1, distance_2, distance_3, distance_4, distance_5, distance_6, distance_7, distance_8, distance_8, distance_8) print(msg_txt_formatted) message = IoTHubMessage(msg_txt_formatted) # optional: assign ids message.message_id = "message_%d" % MESSAGE_COUNT message.correlation_id = "correlation_%d" % MESSAGE_COUNT # optional: assign properties prop_map = message.properties() prop_map.add("temperatureAlert", "true") client.send_event_async(message, send_confirmation_callback, MESSAGE_COUNT) print( "IoTHubClient.send_event_async accepted message [%d] for transmission to IoT Hub." % MESSAGE_COUNT) status = client.get_send_status() print("Send status: %s" % status) MESSAGE_COUNT += 1 time.sleep(2) except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) telemetry.send_telemetry_data( parse_iot_hub_name(), EVENT_FAILED, "Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped")
def iothub_client_telemetry_sample_run(): try: client = iothub_client_init() print ( "IoT Hub device sending periodic messages, press Ctrl-C to exit" ) while True: # Build the message with simulated telemetry values. liveReading = LIVE_READING + random.randrange(0, 1000) msg_txt_formatted = MSG_TXT % (liveReading) message = IoTHubMessage(msg_txt_formatted) # Add a custom application property to the message. # An IoT hub can filter on these properties without access to the message body. prop_map = message.properties() if liveReading > 700: prop_map.add("highConsumptionAlert", "true") else: prop_map.add("highConsumptionAlert", "false") # Send the message. print( "Sending message: %s" % message.get_string() ) client.send_event_async(message, send_confirmation_callback, None) time.sleep(1) except IoTHubError as iothub_error: print ( "Unexpected error %s from IoTHub" % iothub_error ) return except KeyboardInterrupt: print ( "IoTHubClient sample stopped" )
def iothub_client_telemetry_sample_run(): try: client = iothub_client_init() print("IoT Hub device sending periodic messages, press Ctrl-C to exit") while True: humidity, temperature = Adafruit_DHT.read_retry(sensor, pin) curdate = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") if humidity is not None and temperature is not None: msg_txt_formatted = MSG_TXT % (curdate, temperature, humidity) message = IoTHubMessage(msg_txt_formatted) # Add a custom application property to the message. # An IoT hub can filter on these properties without access to the message body. prop_map = message.properties() if temperature > 30: prop_map.add("temperatureAlert", "true") else: prop_map.add("temperatureAlert", "false") # Send the message. print("Sending message: %s" % message.get_string()) client.send_event_async(message, send_confirmation_callback, None) else: print('Failed to get reading. Try again!') time.sleep(2) except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped")
def iothub_client_telemetry_sample_run(): try: client = iothub_client_init() print("IoT Hub device sending periodic messages, press Ctrl-C to exit") message_counter = 0 while True: msg_txt_formatted = "Event!" # messages can be encoded as string or bytearray if (message_counter & 1) == 1: message = IoTHubMessage(bytearray(msg_txt_formatted, 'utf8')) else: message = IoTHubMessage(msg_txt_formatted) # optional: assign ids message.message_id = "message_%d" % message_counter message.correlation_id = "correlation_%d" % message_counter # optional: assign properties prop_map = message.properties() generate_message(prop_map, generate_ticket_id(), datetime.now()) client.send_event_async(message, send_confirmation_callback, message_counter) print( "IoTHubClient.send_event_async accepted message [%d] for transmission to IoT Hub." % message_counter) message_counter += 1 sleep(np.random.randint(10)) except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped")
def data_loop(sensor, pin): try: client = iothub_client_init() print("IoT Hub device sending periodic messages, press Ctrl-C to exit") count = 0 while True: # Build the message with simulated telemetry values. humidity, temperature = get_sensor_data(sensor, pin) msg_txt_formatted = MSG_TXT % (temperature, humidity) message = IoTHubMessage(msg_txt_formatted) # Optional due to edgeHub error message.message_id = "message_%d" % count message.correlation_id = "correlation_%d" % count count += 1 # Add a custom application property to the message. # An IoT hub can filter on these properties without access to the message body. prop_map = message.properties() if temperature > 30: prop_map.add("temperatureAlert", "true") else: prop_map.add("temperatureAlert", "false") # Send the message. print("Sending message: %s" % message.get_string()) client.send_event_async(message, send_confirmation_callback, None) time.sleep(1) except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped")
def filter_message(message): message_buffer = message.get_bytearray() size = len(message_buffer) message_str = message_buffer[:size].decode('utf-8') if not message_str: return None message_obj = json.loads(message_str) if message_obj["machine"]["temperature"] > TEMPERATURE_THRESHOLD: print(" Machine temperature : %d exceeds threshold %d" % (message_obj["machine"]["temperature"], TEMPERATURE_THRESHOLD)) filtered_message = IoTHubMessage(message_str) filtered_message.set_content_type_system_property( message.get_content_type_system_property() or "application/json") filtered_message.set_content_encoding_system_property( message.get_content_encoding_system_property() or "utf-8") prop_map = filtered_message.properties() origin_prop_key_value_pair = message.properties().get_internals() for key in origin_prop_key_value_pair: prop_map.add(key, origin_prop_key_value_pair[key]) prop_map.add("MessageType", "Alert") return filtered_message else: return None
def iothub_client_sample_run(): try: client = iothub_client_init() if client.protocol == IoTHubTransportProvider.MQTT: print("IoTHubClient is reporting state") reported_state = "{\"newState\":\"standBy\"}" client.send_reported_state(reported_state, len(reported_state), send_reported_state_callback, SEND_REPORTED_STATE_CONTEXT) if not config.SIMULATED_DATA: sensor = SenseHat() print 'PI SenseHat Object Created' else: # sensor = BME280(address = config.I2C_ADDRESS) sensor = BME280SensorSimulator() telemetry.send_telemetry_data(parse_iot_hub_name(), EVENT_SUCCESS, "IoT hub connection is established") while True: global MESSAGE_COUNT, MESSAGE_SWITCH if MESSAGE_SWITCH: # send a few messages every minute print("IoTHubClient sending %d messages" % MESSAGE_COUNT) temperature = sensor.get_temperature() humidity = sensor.get_humidity() msg_txt_formatted = MSG_TXT % (temperature, humidity) print(msg_txt_formatted) message = IoTHubMessage(msg_txt_formatted) # optional: assign ids message.message_id = "message_%d" % MESSAGE_COUNT message.correlation_id = "correlation_%d" % MESSAGE_COUNT # optional: assign properties prop_map = message.properties() prop_map.add( "temperatureAlert", "true" if temperature > TEMPERATURE_ALERT else "false") client.send_event_async(message, send_confirmation_callback, MESSAGE_COUNT) print( "IoTHubClient.send_event_async accepted message [%d] for transmission to IoT Hub." % MESSAGE_COUNT) status = client.get_send_status() print("Send status: %s" % status) MESSAGE_COUNT += 1 time.sleep(config.MESSAGE_TIMESPAN / 1000.0) except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) telemetry.send_telemetry_data( parse_iot_hub_name(), EVENT_FAILED, "Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped") print_last_message_time(client)
def iothub_client_telemetry_sample_run(): try: client = iothub_client_init() print("IoT Hub device sending periodic messages, press Ctrl-C to exit") while True: # Build the message with simulated telemetry values. temperature = TEMPERATURE + (random.random() * 15) humidity = HUMIDITY + (random.random() * 20) msg_txt_formatted = MSG_TXT % (temperature, humidity) message = IoTHubMessage(msg_txt_formatted) # Add a custom application property to the message. # An IoT hub can filter on these properties without access to the message body. prop_map = message.properties() if temperature > 30: prop_map.add("temperatureAlert", "true") else: prop_map.add("temperatureAlert", "false") # Send the message. print("Sending message: %s" % message.get_string()) client.send_event_async(message, send_confirmation_callback, None) time.sleep(1) except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped")
def iothub_client_telemetry_sample_run(): try: client = iothub_client_init() print ( "IoT Hub device sending periodic messages, press Ctrl-C to exit" ) # Set up the callback method for direct method calls from the hub. client.set_device_method_callback( device_method_callback, None) client.set_message_callback(receive_message_callback, RECEIVE_CONTEXT) while True: # Build the message with simulated telemetry values. temperature = TEMPERATURE + (random.random() * 15) humidity = HUMIDITY + (random.random() * 20) msg_txt_formatted = MSG_TXT % (temperature, humidity) message = IoTHubMessage(msg_txt_formatted) prop_map = message.properties() if temperature > 30: prop_map.add("temperatureAlert", "true") else: prop_map.add("temperatureAlert", "false") # Send the message. print( "Sending message: %s" % message.get_string() ) client.send_event_async(message, send_confirmation_callback, None) time.sleep(INTERVAL) except IoTHubError as iothub_error: print ( "Unexpected error %s from IoTHub" % iothub_error ) return except KeyboardInterrupt: print ( "IoTHubClient sample stopped" )
def create_message(message_counter): AVG_WIND_SPEED = 10.0 MIN_TEMPERATURE = 20.0 MIN_HUMIDITY = 60.0 temperature = MIN_TEMPERATURE + (random.random() * 10) humidity = MIN_HUMIDITY + (random.random() * 20) msg_txt_formatted = MSG_TXT % ( AVG_WIND_SPEED + (random.random() * 4 + 2), temperature, humidity) # messages can be encoded as string or bytearray if (message_counter & 1) == 1: message = IoTHubMessage(bytearray(msg_txt_formatted, 'utf8')) else: message = IoTHubMessage(msg_txt_formatted) # optional: assign ids message.message_id = "message_%d" % message_counter message.correlation_id = "correlation_%d" % message_counter # optional: assign properties prop_map = message.properties() prop_map.add("temperatureAlert", 'true' if temperature > 28 else 'false') return message
def iothub_client_telemetry_sample_run(): try: client = iothub_client_init() print("IoT Hub device sending periodic messages, press Ctrl-C to exit") while True: temperature = sense.get_temperature() humidity = sense.get_humidity() msg_txt_formatted = MSG_TXT % (temperature, humidity) message = IoTHubMessage(msg_txt_formatted) prop_map = message.properties() if temperature > 30: prop_map.add("temperatureAlert", "true") else: prop_map.add("temperatureAlert", "false") print("Sending message: %s" % message.get_string()) client.send_event_async(message, send_confirmation_callback, None) sense.show_message(temperature + " C") time.sleep(1) sense.show_message(humidity + "%") time.sleep(2) except IoTHubError as iothub_error: print("Unexpected error %s from IoT Hub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped")
def iothub_client_sample_run(): try: client = iothub_client_init() if client.protocol == IoTHubTransportProvider.MQTT: print("IoTHubClient is reporting state") reported_state = "{\"newState\":\"standBy\"}" client.send_reported_state(reported_state, len(reported_state), send_reported_state_callback, SEND_REPORTED_STATE_CONTEXT) while True: # send a few messages every minute print("IoTHubClient sending %d messages" % MESSAGE_COUNT) for message_counter in range(0, MESSAGE_COUNT): temperature = MIN_TEMPERATURE + (random.random() * 10) humidity = MIN_HUMIDITY + (random.random() * 20) msg_txt_formatted = MSG_TXT % (AVG_WIND_SPEED + (random.random() * 4 + 2), temperature, humidity) # messages can be encoded as string or bytearray if (message_counter & 1) == 1: message = IoTHubMessage( bytearray(msg_txt_formatted, 'utf8')) else: message = IoTHubMessage(msg_txt_formatted) # optional: assign ids message.message_id = "message_%d" % message_counter message.correlation_id = "correlation_%d" % message_counter # optional: assign properties prop_map = message.properties() prop_map.add("temperatureAlert", 'true' if temperature > 28 else 'false') client.send_event_async(message, send_confirmation_callback, message_counter) print( "IoTHubClient.send_event_async accepted message [%d] for transmission to IoT Hub." % message_counter) # Wait for Commands or exit print("IoTHubClient waiting for commands, press Ctrl-C to exit") status_counter = 0 while status_counter <= MESSAGE_COUNT: status = client.get_send_status() print("Send status: %s" % status) time.sleep(10) status_counter += 1 except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped") print_last_message_time(client)
def iothub_client_telemetry_sample_run(): try: client = iothub_client_init() print("IoT Hub device sending periodic messages, press Ctrl-C to exit") while True: # Build the message with simulated telemetry values. false = random.randrange(0, 30) true = random.randrange(0, 30) supplyOn = bool(TRUE_PROBALITY[true]) fireAlert = bool(FALSE_PROBALITY[false]) temperature = random.random() * TEMEPERATURE msg_txt_formatted = MSG_TXT % (supplyOn, fireAlert, temperature) message = IoTHubMessage(msg_txt_formatted) # Add a custom application property to the message. # An IoT hub can filter on these properties without access to the message body. prop_map = message.properties() if temperature > 70: prop_map.add("extremeHeatAlert", "true") else: prop_map.add("extremeHeatAlert", "false") # Send the message. print("Sending message: %s" % message.get_string()) client.send_event_async(message, send_confirmation_callback, None) time.sleep(1) except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped")
def iothub_client_telemetry_send(self): try: MSG_TXT = '{\"Timestamp\":%.0f,\"DeviceId\":\"%.10s\",\"location\":{\"lon\":%.5f,\"lat\":%.5f},\"Readings\":{\"Temperature\":{\"Internal\":%.2f,\"External\":%.2f}},\"Flow\":{\"In\":%.2f,\"Out\":%.2f},\"Pressure\":%.2f,\"Battery\":%.2f}' #print client.toString() # Build the message with simulated telemetry values. pressure = self.readPressure() flow = self.readFlow() temperature = self.readTemprature() battery = self.checkBattery() msg_txt_formatted = MSG_TXT % (calendar.timegm( time.gmtime()), self.deviceId, float(self.lat), float( self.lon), temperature, temperature * 1.2, flow, flow * 1.354, pressure, battery) message = IoTHubMessage(msg_txt_formatted) # Add a custom application property to the message. # An IoT hub can filter on these properties without access to the message body. prop_map = message.properties() if temperature > 30: prop_map.add("temperatureAlert", "true") else: prop_map.add("temperatureAlert", "false") # Send the message. print("Sending message: %s" % message.get_string()) self.client.send_event_async(message, self.send_confirmation_callback, None) except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped")
def iothub_client_telemetry_sample_run(): # list of taps with starting keg weights taplist = [FULL_KEG_WEIGHT, FULL_KEG_WEIGHT, FULL_KEG_WEIGHT/2, FULL_KEG_WEIGHT/5]; try: client = iothub_client_init() while True: for tap in range(len(taplist)): # 15% change of pouring a 200g-450g beer if (random.random() <= 0.15): amount = random.randint(200, 450) taplist[tap] -= amount if (taplist[tap] < 0): taplist[tap] = FULL_KEG_WEIGHT; # keg magiclly refills when empty temperature = random.random() * 12 # 0-12 C msg_txt_formatted = MSG_TXT % \ (time.time(), DEVICE_ID, tap, temperature, taplist[tap]) message = IoTHubMessage(msg_txt_formatted) prop_map = message.properties() if temperature > 10: prop_map.add("temperatureAlert", "true") else: prop_map.add("temperatureAlert", "false") # Send the message. print( "Sending message: %s" % message.get_string() ) client.send_event_async(message, send_confirmation_callback, None) time.sleep(REPORT_PERIOD_S) except IoTHubError as iothub_error: print ( "Unexpected error %s from IoTHub" % iothub_error ) return except KeyboardInterrupt: print ( "IoTHubClient sample stopped" )
def iothub_client_telemetry_sample_run(): try: client = iothub_client_init() print ( "IoT Hub device sending periodic messages, press Ctrl-C to exit" ) while True: # Build the message with simulated telemetry values. heartrate = ser.readline() heartrate = heartrate.decode("utf8").strip() msg_txt_formatted = MSG_TXT % (int(heartrate)) message = IoTHubMessage(msg_txt_formatted) # Add a custom application property to the message. # An IoT hub can filter on these properties without access to the message body. prop_map = message.properties() if int(heartrate) > 140 and int(heartrate) < 50: prop_map.add("heartrateAlert", "false") else: prop_map.add("heartrateAlert", "true") # Send the message. print( "Sending message: %s" % message.get_string() ) client.send_event_async(message, send_confirmation_callback, None) time.sleep(1) except IoTHubError as iothub_error: print ( "Unexpected error %s from IoTHub" % iothub_error ) return except KeyboardInterrupt: print ( "IoTHubClient sample stopped" )
def main(protocol): try: print ( "\nPython %s\n" % sys.version ) print ( "IoT Hub Client for Python" ) hub_manager = HubManager(protocol) device_client = iothub_client_init() print ( "IoTHubClient sending %d messages" % MESSAGE_COUNT ) message = IoTHubMessage("mridu test message from module!!!!") message_counter = 0 message.message_id = "message_%d" % message_counter message.correlation_id = "correlation_%d" % message_counter # optional: assign properties prop_map = message.properties() prop_map.add("temperatureAlert", 'false') device_client.send_event(message, properties=prop_map, send_context=message_counter) print ( "Starting the IoT Hub Python sample using protocol %s..." % hub_manager.client_protocol) print ( "The sample is now waiting for messages and will indefinitely. Press Ctrl-C to exit. ") while True: time.sleep(1) except IoTHubError as iothub_error: print ( "Unexpected error %s from IoTHub" % iothub_error ) return except KeyboardInterrupt: print ( "IoTHubModuleClient sample stopped" )
def send_to_Hub_callback(strMessage): if strMessage == []: return message = IoTHubMessage(bytearray(strMessage, 'utf8')) prop_map = message.properties() prop_map.add("appid", "scanner") hubManager.send_event_to_output("output1", message, 0) print('sent from send_to_Hub_callback')
def iothub_client(): try: #Initialice Client client = iothub_client_init() print("IoT Device Simulator, press Ctrl-C to exit") #Specifies message format and values msg_txt_formatted = MSG_TXT % INTERFACE_PARAM_A message_counter = 0 inp = 0 while inp != 4: print("Press 1 to send a message to IOT Hub (Simulated message") print("Press 2 to send a picture to IOT Hub (Simulated message") print("Press 4 to EXIT") # messages can be encoded as string or bytearray if (message_counter & 1) == 1: message = IoTHubMessage(bytearray(msg_txt_formatted, 'utf8')) else: message = IoTHubMessage(msg_txt_formatted) # optional: assign ids message.message_id = "message_%d" % message_counter message.correlation_id = "correlation_%d" % message_counter # optional: assign properties prop_map = message.properties() prop_text = "PropMsg_%d" % message_counter prop_map.add("Property", prop_text) inp = int(input()) if inp == 1: #Sends a message to the Hub, reveives confirmation callback, adds counter client.send_event_async(message, send_confirmation_callback, message_counter) print( "IoTHubClient.send_event_async accepted message [%d] for transmission to IoT Hub." % message_counter) if inp == 2: #Sends a file to Azure Storage Blob filename = "hello.jpg" content1 = open(filename, "rb") content = content1.read() #Send and shows confirmation client.upload_blob_async(filename, content, len(content), blob_upload_conf_callback, 1001) #status = client.get_send_status() #print ( "Send status: %s" % status ) message_counter += 1 if inp == 4: break except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped")
def iothub_client_sample_run(): try: client = iothub_client_init() if client.protocol == IoTHubTransportProvider.MQTT: print ( "IoTHubClient is reporting state" ) reported_state = "{\"newState\":\"standBy\"}" client.send_reported_state(reported_state, len(reported_state), send_reported_state_callback, SEND_REPORTED_STATE_CONTEXT) if not config.SIMULATED_DATA: sensor = BME280(address = config.I2C_ADDRESS) else: sensor = BME280SensorSimulator() telemetry.send_telemetry_data(parse_iot_hub_name(), EVENT_SUCCESS, "IoT hub connection is established") while True: global MESSAGE_COUNT,MESSAGE_SWITCH if MESSAGE_SWITCH: # send a few messages every minute print ( "IoTHubClient sending %d messages" % MESSAGE_COUNT ) temperature = sensor.read_temperature() humidity = sensor.read_humidity() timeStamp = time.time() dataValue = 0 if DEVICE_TYPE=="T": dataValue = temperature else : dataValue = humidity msg_txt_formatted = MSG_TXT % ( DEVICE_TYPE, DEVICE_ID, timeStamp, dataValue) print (msg_txt_formatted) message = IoTHubMessage(msg_txt_formatted) # optional: assign ids message.message_id = "message_%d" % MESSAGE_COUNT message.correlation_id = "correlation_%d" % MESSAGE_COUNT # optional: assign properties prop_map = message.properties() prop_map.add("temperatureAlert", "true" if temperature > TEMPERATURE_ALERT else "false") client.send_event_async(message, send_confirmation_callback, MESSAGE_COUNT) print ( "IoTHubClient.send_event_async accepted message [%d] for transmission to IoT Hub." % MESSAGE_COUNT ) status = client.get_send_status() print ( "Send status: %s" % status ) MESSAGE_COUNT += 1 time.sleep(config.MESSAGE_TIMESPAN / 1000.0) except IoTHubError as iothub_error: print ( "Unexpected error %s from IoTHub" % iothub_error ) telemetry.send_telemetry_data(parse_iot_hub_name(), EVENT_FAILED, "Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print ( "IoTHubClient sample stopped" ) print_last_message_time(client)
def iothub_client_sample_run(): try: client = iothub_client_init() if client.protocol == IoTHubTransportProvider.MQTT: print("IoTHubClient is reporting state") reported_state = "{\"newState\":\"standBy\"}" client.send_reported_state(reported_state, len(reported_state), send_reported_state_callback, SEND_REPORTED_STATE_CONTEXT) telemetry.send_telemetry_data(parse_iot_hub_name(), EVENT_SUCCESS, "IoT hub connection is established") while True: #tripWire() global MESSAGE_COUNT, MESSAGE_SWITCH if MESSAGE_SWITCH: # send a few messages every minute print("IoTHubClient sending %d messages" % MESSAGE_COUNT) if tripWire() == 0: lightState = "ON" num = 0 else: lightState = "OFF" num = 1 #humidity = 1.23 #temperature = 4.56 #msg_txt_formatted = MSG_TXT % (temperature,humidity) msg_txt_formatted = MSG_TXT % num print(msg_txt_formatted) message = IoTHubMessage(msg_txt_formatted) message.message_id = "message_%d" % MESSAGE_COUNT message.correlation_id = "correlation_%d" % MESSAGE_COUNT prop_map = message.properties() prop_map.add("Lightstate", lightState) client.send_event_async(message, send_confirmation_callback, MESSAGE_COUNT) print( "IoTHubClient.send_event_async accepted message [%d] for transmission to IoT Hub." % MESSAGE_COUNT) status = client.get_send_status() print("Send status: %s" % status) MESSAGE_COUNT += 1 time.sleep(1) #Brandon except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) telemetry.send_telemetry_data( parse_iot_hub_name(), EVENT_FAILED, "Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: GPIO.cleanup() print("IoTHubClient sample stopped") print_last_message_time(client)
def send_event_to_output(self, message, properties, send_context): event = IoTHubMessage(bytearray(message, 'utf8')) if len(properties) > 0: prop_map = event.properties() for key in properties: prop_map.add_or_update(key, properties[key]) self.client.send_event_async(event, send_confirmation_callback, send_context)
def ncd_send_message(msg, client): print(msg) message = IoTHubMessage(msg) message.type = "Telemetry" message.message_id = "message_0" message.correlation_id = "correlation_0" # # optional: assign properties prop_map = message.properties() client.send_event_async(message, send_confirmation_callback, 0) print ( "IoTHubClient.send_event_async accepted message for transmission to IoT Hub.")
def iothub_client_sample_run(msg): try: client = iothub_client_init() if client.protocol == IoTHubTransportProvider.MQTT: print("IoTHubClient is reporting state") reported_state = "{\"newState\":\"standBy\"}" client.send_reported_state(reported_state, len(reported_state), send_reported_state_callback, SEND_REPORTED_STATE_CONTEXT) x = True while x == True: # send a few messages every minute print("IoTHubClient sending %d messages" % MESSAGE_COUNT) for message_counter in range(0, MESSAGE_COUNT): msg_txt_formatted = msg print "7777777777777777777777777777777777777777777777777777777" print msg_txt_formatted print "8888888888888888888888888888888888888888888888888888888" # messages can be encoded as string or bytearray if (message_counter & 1) == 1: message = IoTHubMessage( bytearray(msg_txt_formatted, 'utf8')) else: message = IoTHubMessage(msg_txt_formatted) # optional: assign ids message.message_id = "message_%d" % message_counter message.correlation_id = "correlation_%d" % message_counter # optional: assign properties prop_map = message.properties() # prop_map.add("temperatureAlert", 'true' if temperature > 28 else 'false') client.send_event_async(message, send_confirmation_callback, 1) print( "IoTHubClient.send_event_async accepted message [%d] for transmission to IoT Hub." % message_counter) print("IoTHubClient waiting for commands, press Ctrl-C to exit") status = client.get_send_status() x = False status_counter = 0 while status_counter <= 0: status = client.get_send_status() print("Send status: %s" % status) time.sleep(1) status_counter += 1 except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped")
def iothub_client_sample_run(): try: client = iothub_client_init() if client.protocol == IoTHubTransportProvider.MQTT: print ( "IoTHubClient is reporting state" ) reported_state = "{\"newState\":\"standBy\"}" client.send_reported_state(reported_state, len(reported_state), send_reported_state_callback, SEND_REPORTED_STATE_CONTEXT) while True: # send a few messages every minute print ( "IoTHubClient sending %d messages" % MESSAGE_COUNT ) for message_counter in range(0, MESSAGE_COUNT): temperature = MIN_TEMPERATURE + (random.random() * 10) humidity = MIN_HUMIDITY + (random.random() * 20) msg_txt_formatted = MSG_TXT % ( AVG_WIND_SPEED + (random.random() * 4 + 2), temperature, humidity) # messages can be encoded as string or bytearray if (message_counter & 1) == 1: message = IoTHubMessage(bytearray(msg_txt_formatted, 'utf8')) else: message = IoTHubMessage(msg_txt_formatted) # optional: assign ids message.message_id = "message_%d" % message_counter message.correlation_id = "correlation_%d" % message_counter # optional: assign properties prop_map = message.properties() prop_map.add("temperatureAlert", 'true' if temperature > 28 else 'false') client.send_event_async(message, send_confirmation_callback, message_counter) print ( "IoTHubClient.send_event_async accepted message [%d] for transmission to IoT Hub." % message_counter ) # Wait for Commands or exit print ( "IoTHubClient waiting for commands, press Ctrl-C to exit" ) status_counter = 0 while status_counter <= MESSAGE_COUNT: status = client.get_send_status() print ( "Send status: %s" % status ) time.sleep(10) status_counter += 1 except IoTHubError as iothub_error: print ( "Unexpected error %s from IoTHub" % iothub_error ) return except KeyboardInterrupt: print ( "IoTHubClient sample stopped" ) print_last_message_time(client)
def send_event(self, event, properties, send_context): if not isinstance(event, IoTHubMessage): event = IoTHubMessage(bytearray(event, 'utf8')) if len(properties) > 0: prop_map = event.properties() for key in properties: prop_map.add_or_update(key, properties[key]) self.client.send_event_async( event, send_confirmation_callback, send_context)
def onHttpRequestSave(): #request.form['rawData'] # Data Sample {'temperature': 'nan', 'humidity': 'nan'} resp = request.get_json() resp['EventTime'] = datetime.datetime.now().strftime("%I:%M%p %B %d, %Y") payload = json.dumps(resp) data_t = strftime("%Y-%m-%dT%H:%M:%S+00:00", gmtime()) #payload = '{ "data": '+payload+', "deviceId": "engine", "time": "'+data_t+'" }' #payload = payload print(payload, file=sys.stderr) print(type(payload),file=sys.stderr) headers = { 'Content-Type': "application/json", 'User-Agent': "PostmanRuntime/7.11.0", 'Accept': "*/*", 'Cache-Control': "no-cache", 'Postman-Token': "0fa806d0-eee9-4960-8984-941eb1d8a340,0f174457-1072-4871-a853-2c2c8224f3f8", 'Host': "us-central1-alwaystuned2019.cloudfunctions.net", 'accept-encoding': "gzip, deflate", 'content-length': "405", 'Connection': "keep-alive", 'cache-control': "no-cache" } response = requests.request("POST", url, data=payload, headers=headers) print(response.text, file=sys.stderr) try: client = iothub_client_init() print ( "IoT Hub device sending periodic messages, press Ctrl-C to exit", file=sys.stderr) message = IoTHubMessage(payload) # Add a custom application property to the message. # An IoT hub can filter on these properties without access to the message body. prop_map = message.properties() # Send the message. print( "Sending message: %s" % message.get_string() , file=sys.stderr) client.send_event_async(message, send_confirmation_callback, None) except IoTHubError as iothub_error: print ( "Unexpected error %s from IoTHub" % iothub_error , file=sys.stderr) return except KeyboardInterrupt: print ( "IoTHubClient sample stopped" , file=sys.stderr) print(resp, file=sys.stderr) return saveData()
def send_event(self, event, properties, send_context): if not isinstance(event, IoTHubMessage): event = IoTHubMessage(bytearray(event, 'utf8')) if len(properties) > 0: prop_map = event.properties() for key in properties: prop_map.add_or_update(key, properties[key]) self.client.send_event_async( event, send_confirmation_callback, send_context)
def composeStartMessage(): msg_unformatted = {"startTime": time.asctime(time.localtime(time.time()))} msg_txt_formatted = json.dumps(msg_unformatted) message = IoTHubMessage(msg_txt_formatted) # optional: assign ids message.message_id = "message_%d" % MESSAGE_COUNT message.correlation_id = "correlation_%d" % MESSAGE_COUNT # optional: assign properties prop_map = message.properties() prop_map.add("startupMessage", "true") prop_map.add("telemetry", "false") return message
def iothub_try(self, json, connection): try: print(json) client = self.iothub_client_init(connection) message_counter = 0 msg_txt_formatted = json # messages can be encoded as string or bytearray #print ( msg_txt_formatted ) if (message_counter & 1) == 1: message = IoTHubMessage(bytearray(msg_txt_formatted, 'utf8')) else: r = randint(0, 9) message = IoTHubMessage(msg_txt_formatted) if r > 7: prop_map = message.properties() prop_map.add("BatteryAlert", 'true') else: prop_map = message.properties() prop_map.add("BatteryAlert", 'false') # optional: assign ids message.message_id = "message_%d" % message_counter message.correlation_id = "correlation_%d" % message_counter client.send_event_async(message, send_confirmation_callback, message_counter) status = client.get_send_status() print("Send status: %s" % status) time.sleep(5) message_counter += 1 except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped")
def iothub_client_sample_run(): global gMQTTClient try: iotHubStopWatch = StopWatch(AZURE_REPORT_TIME) iotHubStopWatch.reset() client = iothub_client_init() if client.protocol == IoTHubTransportProvider.MQTT: print ( "IoTHubClient is reporting state" ) reported_state = "{\"newState\":\"standBy\"}" client.send_reported_state(reported_state, len(reported_state), send_reported_state_callback, SEND_REPORTED_STATE_CONTEXT) count = 1 while True: if (True == iotHubStopWatch.isExpired()): global gSendMessage if gSendMessage: message = IoTHubMessage("JimsFridgeStatus") message.message_id = "message_%d" % count message.correlation_id = "correlation_%d" % count prop_map = message.properties() prop_map.add("FreezerDoor", str(gFreezerDoor)) prop_map.add("FreezerTemp", str(gFreezerTemp)) prop_map.add("FridgeDoor", str(gFridgeDoor)) prop_map.add("FridgeTemp", str(gFridgeTemp)) prop_map.add("BoredTime", str(gBoredTime)) prop_map.add("LockoutTime", str(gLockoutTime)) prop_map.add("DoorTime", str(gDoorTime)) prop_map.add("LastTweet", urllib.quote(gLastTweet)) prop_map.add("WebTweet", gWebTweet) client.send_event_async(message, send_confirmation_callback, count) count = count + 1 status = client.get_send_status() iotHubStopWatch.reset() gMQTTClient.loop() time.sleep(0.01) pass except IoTHubError as iothub_error: print ( "Unexpected error %s from IoTHub" % iothub_error ) return except KeyboardInterrupt: print ( "IoTHubClient sample stopped" ) print_last_message_time(client)
def iothub_client_shared_transport_sample_run(): try: # create transport to share transport = IoTHubTransport(PROTOCOL, IOTHUBNAME, IOTHUBSUFFIX) client1 = iothub_client_init(transport, DEVICE_NAME1, DEVICE_KEY1) client1.set_message_callback(receive_message_callback1, RECEIVE_CONTEXT) client2 = iothub_client_init(transport, DEVICE_NAME2, DEVICE_KEY2) client2.set_message_callback(receive_message_callback2, RECEIVE_CONTEXT) print ( "IoTHubClient has been initialized" ) while True: # send a few messages every minute print ( "IoTHubClient sending %d messages" % MESSAGE_COUNT ) for message_counter in range(0, MESSAGE_COUNT): temperature = MIN_TEMPERATURE + (random.random() * 10) humidity = MIN_HUMIDITY + (random.random() * 20) msg_txt_formatted = MSG_TXT % ( AVG_WIND_SPEED + (random.random() * 4 + 2), temperature, humidity) # messages can be encoded as string or bytearray if (message_counter & 1) == 1: message = IoTHubMessage(bytearray(msg_txt_formatted, 'utf8')) else: message = IoTHubMessage(msg_txt_formatted) # optional: assign ids message.message_id = "message_%d" % message_counter message.correlation_id = "correlation_%d" % message_counter # optional: assign properties prop_map = message.properties() prop_map.add("temperatureAlert", 'true' if temperature > 28 else 'false') if (message_counter % 2) == 0: client1.send_event_async(message, send_confirmation_callback1, message_counter) else: client2.send_event_async(message, send_confirmation_callback2, message_counter) print ( "IoTHubClient.send_event_async accepted message [%d] for transmission to IoT Hub." % message_counter ) # Wait for Commands or exit print ( "IoTHubClient waiting for commands, press Ctrl-C to exit" ) status_counter = 0 while status_counter < MESSAGE_COUNT: status1 = client1.get_send_status() print ( "Send status client1: %s" % status1 ) status2 = client2.get_send_status() print ( "Send status client2: %s" % status2 ) time.sleep(10) status_counter += 1 except IoTHubError as iothub_error: print ( "Unexpected error %s from IoTHub" % iothub_error ) return except KeyboardInterrupt: print ( "IoTHubClient sample stopped" ) print_last_message_time(client1) print_last_message_time(client2)
def iothub_client_run(): try: client = iothub_client_init() if client.protocol == IoTHubTransportProvider.MQTT: print ( "IoTHubClient is reporting state" ) reported_state = "{\"newState\":\"standBy\"}" client.send_reported_state(reported_state, len(reported_state), send_reported_state_callback, SEND_REPORTED_STATE_CONTEXT) telemetry.send_telemetry_data(parse_iot_hub_name(), EVENT_SUCCESS, "IoT hub connection is established") while True: global MESSAGE_COUNT,MESSAGE_SWITCH if MESSAGE_SWITCH: #------------------------------------------------------------------------------------------- # This for loop reads the live data from the weather station and converts some of the data. # ptrraw is the WS pointer to circluar log buffer offset (16 bytes) # ptrhex ptr in Hex little endian # Convert to correct Relative Pressure HPA for location by adding 9.6 # Convert MPS to KPH # Error Handling: # Check for lost connection or null data. If found break from loop and do not send message #------------------------------------------------------------------------------------------- for data, ptr, logged in ws.live_data(): record_time_local = datetime.now().strftime('%Y-%m-%dT%H:%M:%S.%f') print("\n") print(record_time_local) ws_status = data['status'] ws_conn = data['status']['lost_connection'] # Check for lost connection if ws_conn == True: print("Lost Connection to Weather Station") break # Check for Null Data if ws_conn == None: print("No Data Returned From Weather Station") break # if connection OK process the data ptrraw = ptr ptrhex = "%04x" % ptr record_time_utc = data['idx'].strftime('%Y-%m-%d %H:%M:%S') hum_out = data['hum_out'] temp_out = data['temp_out'] hum_in = data['hum_in'] temp_in = data['temp_in'] abs_pres = data['abs_pressure']+9.6 wind_gust = data['wind_gust']*3.6 wind_avg = data['wind_ave']*3.6 wind_dir = data['wind_dir'] wind_pos = wind_direction(wind_dir) rain = data['rain'] msg_txt_formatted = MSG_TXT % ( DeviceID, record_time_local, hum_out, temp_out, hum_in, temp_in, abs_pres, wind_gust, wind_avg, wind_dir, wind_pos, rain) break if ws_conn == False: print ( "IoTHubClient sending %d messages" % MESSAGE_COUNT ) message = IoTHubMessage(msg_txt_formatted) # optional: assign ids message.message_id = "message_%d" % MESSAGE_COUNT message.correlation_id = "correlation_%d" % MESSAGE_COUNT # optional: assign properties prop_map = message.properties() prop_map.add("temperatureAlert", "true" if temp_out > TEMPERATURE_ALERT else "false") client.send_event_async(message, send_confirmation_callback, MESSAGE_COUNT) print ( "IoTHubClient.send_event_async accepted message [%d] for transmission to IoT Hub." % MESSAGE_COUNT ) status = client.get_send_status() print ( "Send status: %s" % status ) MESSAGE_COUNT += 1 time.sleep(config.MESSAGE_TIMESPAN / 1000.0) except IoTHubError as iothub_error: print ( "Unexpected error %s from IoTHub" % iothub_error ) telemetry.send_telemetry_data(parse_iot_hub_name(), EVENT_FAILED, "Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print ( "IoTHubClient stopped" ) print_last_message_time(client)