def publish_message(): """ It publishes messages to the IoT hub every 4 seconds. """ con0 = "HostName=TalkingChalkz.azure-devices.net;DeviceId=dev_00;SharedAccessKey=UJ/C3PxH8S/dx/+uY6BuBEuBzyfKoPhk/btkGgG1y2c=" client0 = IoTHubDeviceClient.create_from_connection_string(con0, websockets=True) con1 = "HostName=TalkingChalkz.azure-devices.net;DeviceId=dev_01;SharedAccessKey=3lE82lIMlEoJg1zvN9J8FFUxBxEeKNi+kJ1ZUad3igQ=" client1 = IoTHubDeviceClient.create_from_connection_string(con1, websockets=True) con2 = "HostName=TalkingChalkz.azure-devices.net;DeviceId=dev_02;SharedAccessKey=5mbx9W1uxKd/aK6pDEKQuHaOcMkMkKwBqPRj/Ri051w=" client2 = IoTHubDeviceClient.create_from_connection_string(con2, websockets=True) # Connect the device client client0.connect() client1.connect() client2.connect() while (True): try: dev = random.choice(devs) profile = random.choice(profiles) #Generating the message to send msg = { 'dev_id': dev, 'profile_id': profile, 'hrate': '72', 'timestamp': '123' } message = json.dumps(msg) # Send the message print("Sending message...") if (dev == "dev_00"): client0.send_message(message) elif (dev == "dev_01"): client1.send_message(message) elif (dev == "dev_02"): client2.send_message(message) print("Message successfully sent!") print(message) time.sleep(4) except KeyboardInterrupt: print("IoTHubClient stopped") return except: print("Unexpected error") time.sleep(4) # finally, disconnect client0.disconnect() client1.disconnect() client2.disconnect()
def __init__(self, msg_stack: deque): self.conn = db_access.create_connection() self.msg_stack = msg_stack conn_str = "REMOVED" self.device_client: IoTHubDeviceClient = IoTHubDeviceClient.create_from_connection_string(conn_str) threading.Thread.__init__(self)
def iothub_client_telemetry_sample_run(): lat = LATITUDE long = LONGITUDE distance = DISTANCE try: client = IoTHubDeviceClient.create_from_connection_string( CONNECTION_STRING) while True: # simulate telemetry values to be transmitted speed = SPEED + random.random() * 50 # make engine tempertaure a function of speed engine_temperature = ENGINE_TEMP + random.random() * speed # simulate movement by changing location lat = lat + random.random() * 0.00001 long = long + random.random() * 0.00001 # calculate distance travelled distance = distance + haversine_distance(LATITUDE, LONGITUDE, lat, long) # format the message message = Message( MESSAGE.format(speed=speed, engine_temperature=engine_temperature, lat=lat, long=long, distance=distance)) # send message every 5 seconds print("Sending message: {}".format(message)) client.send_message(message) print("Message successfully sent") time.sleep(5) except KeyboardInterrupt: print("IoTHubClient sample stopped")
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) print("IoTHub Device Client Recurring Telemetry Sample") print("Press Ctrl+C to exit") try: # Connect the client. device_client.connect() # Send recurring telemetry i = 0 while True: i += 1 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" print("sending message #" + str(i)) device_client.send_message(msg) time.sleep(2) except KeyboardInterrupt: print("User initiated exit") except Exception: print("Unexpected exception!") raise finally: device_client.shutdown()
def connect_client(): try: client = IoTHubDeviceClient.create_from_connection_string( CONNECTION_STRING) return client except KeyboardInterrupt: print("Stopped!")
def __init__( self, telemetry_interval: int = 3, fan_session_duration: int = 10, connection_string: str = os.getenv("CONNECTION_STRING_IOT_DEVICE"), ): """Abstract Raspberry Pi interface definition that is inherited by both simulated and real Raspberry Pi implementations. Args: telemetry_interval (int, optional): Interval in seconds at which the Raspberry pi should send telemetry to the cloud. Defaults to 3. fan_session_duration (int, optional): Time in seconds that the fan should turn on if the temperature is above a certain level. Defaults to 10. connection_string (str, optional): Connection string for the device to connect with Azure IoThub. Defaults to os.getenv("CONNECTION_STRING_IOT_DEVICE"). """ # Connection string for the device to connect with Azure IoThub. self.connection_string = connection_string # Interval in seconds at which the Raspberry pi should send telemetry to the cloud. self.telemetry_interval = telemetry_interval # Time in seconds that the fan should stay on if it is too warm. self.fan_session_duration = fan_session_duration # Inidicator for if the fan is currently turned on self.fan_active = False # Time that the fan should turn off again, if on. self.fan_stoptime = datetime.datetime(1970, 1, 1) # create a IoTHub client for the device to interact with. self.client = IoTHubDeviceClient.create_from_connection_string( self.connection_string)
def start(self): try: self.registry_manager = IoTHubRegistryManager(CONNECTION_server) os.system( 'az iot hub device-identity create --device-id %s --hub-name pathak' % (self.id)) print("ID of the client created = %s" % (self.id)) print("Connecting the Python IoT Hub") self.CONNECTION_STRING = os.popen( "az iot hub device-identity show-connection-string --device-id %s --hub-name pathak -o table" % (self.id)).read() self.CONNECTION_STRING = self.CONNECTION_STRING.split()[-1] client = IoTHubDeviceClient.create_from_connection_string( self.CONNECTION_STRING) except Exception as e: print("Problems with IOT HUB") os._exit(0) print("Connected") self.uploader = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.uploader.bind(('', 0)) self.UPLOAD_PORT = self.uploader.getsockname()[1] self.uploader.listen(5) print('Listening on the upload port %s' % self.UPLOAD_PORT) message_listener_thread = threading.Thread( target=self.message_listener, args=(client, )) message_listener_thread.daemon = True message_listener_thread.start() self.cli()
def envia_iothub(dados): flag = 2 #CONNECTION_STRING = "HostName=mdwcopel.azure-devices.net;DeviceId=pythondevice;SharedAccessKey=PzCUFs423r12S9qGKOu74hqwRYR+2LlOCGAssUYv9Fo=" #CONNECTION_STRING = "HostName=HemsHub.azure-devices.net;DeviceId=Hemsd;SharedAccessKey=L3YBChE5GvupNPT2ILsQbpU58Du71yEeEmohUFeiBWE=" try: with open('/etc/iotedge/config.yaml', 'r') as searchfile: for line in searchfile: if 'device_connection_string' in line: string_teste = line.partition( "device_connection_string: ")[2] #print (string_teste) string_teste = string_teste.replace("\"", "") CONNECTION_STRING = string_teste client = IoTHubDeviceClient.create_from_connection_string( CONNECTION_STRING) client.connect() #print ( "IoT Hub device sending periodic messages, press Ctrl-C to exit" ) # Send the message. print("Enviando mensagem para IoTHub: " + str(dados)) client.send_message(str(dados)) print("Enviada com sucesso!") time.sleep(1) client.disconnect() flag = 2 except Exception as e: print("IoTHubClient sample stopped") reenviar(dados) return flag return flag
def iothub_client_init(): # Create an IoT Hub client print("Connecting to " + "'" + CONNECTION_STRING + "'") global client client = IoTHubDeviceClient.create_from_connection_string( CONNECTION_STRING) return client
def iothub_client_init(): # Create an IoT Hub client global _client _client = IoTHubDeviceClient.create_from_connection_string(CONNECTION_STRING, auto_connect=True) try: def device_method_handler(method_request): _led.blink(on_time=0.1, off_time=0.1) print ( "\nMethod callback called with:\nmethodName = {method_name}\npayload = {payload}".format( method_name=method_request.name, payload=method_request.payload ) , flush=True ) cb = _callbackSelector.get(method_request.name, lambda _: ({"Response" : "Not Defined"}, 404)) response_payload, response_status = cb(method_request.payload) method_response = MethodResponse.create_from_method_request(method_request, response_status, payload=response_payload) print("\nResponse:\nPayload: {pl}\nStatus: {st}".format(pl=response_payload, st=response_status), flush=True) _client.send_method_response(method_response) _led.on() _client.on_method_request_received = device_method_handler _client.connect() _led.on() except: _client.shutdown() _client = None _led.off()
def __init__(self, connection_string): self._client = IoTHubDeviceClient.create_from_connection_string( connection_string) self._client.connect() self._q = queue.Queue() self._thread = threading.Thread(target=self._loop, daemon=True) self._thread.start()
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) self.client.connect()
def sendToAzure(topic, message): try: client1 = IoTHubDeviceClient.create_from_connection_string( CONNECTION_STRING_1) client2 = IoTHubDeviceClient.create_from_connection_string( CONNECTION_STRING_2) print("Sending message: {}".format(message)) message = message.encode('utf8') if topic == "sensors/s1": print("Sending to S1") client1.send_message(message) if topic == "sensors/s2": print("Sending to S2") client2.send_message(message) print("Message successfully sent") except KeyboardInterrupt: print("IoTHubBridge sample stopped")
def sendToAzure(device, message): try: client = IoTHubDeviceClient.create_from_connection_string(device) print("Sending message: {}".format(message)) message = message.encode('utf8') client.send_message(message) print("Message successfully sent") except KeyboardInterrupt: print("IoTHubBridge sample stopped")
def __init__(self, port, baudrate, name, reconnect_period, update_period, connection_string): self.name = name try: # modbus client self.mb_client = modbus_rtu.RtuMaster( serial.Serial(port=port, baudrate=baudrate, bytesize=8, parity='N', stopbits=1, xonxoff=0)) self.mb_client.set_timeout(5.0) self.mb_client.set_verbose(True) except Exception as e: logging.error(str(e)) try: # azure iothub client self.iothub_client = IoTHubDeviceClient.create_from_connection_string( connection_string) except Exception as e: logging.error(str(e)) self.reconnect_period = reconnect_period self.update_period = update_period # number of float elements self.float_ele_number = 12 # number of uint8_t elements self.char_ele_number = 8 # number of short(uint16_t) elements self.short_ele_number = 1 # analog input values (in Volt) self.vin = [0] * self.float_ele_number # digital io inout status (0 -> off 1 -> flash 2-> on) self.din = [0] * self.char_ele_number # board card address self.address = 0 # data length (in word) to be read self.word2read = self.float_ele_number * 2 + self.char_ele_number / 2 + self.short_ele_number # original data from modbus self.original_list = [0] * int(self.word2read) # machine status self.status = 0 self.status_old = 0 # weld status self.weld_status = 0 self.weld_status_old = 0 # weld values self.weld_voltage = [0] * 4 self.weld_current = [0] * 4
def __init__(self, connection): self.guid = str(uuid.uuid4()) self.client = IoTHubDeviceClient.create_from_connection_string( connection) self.vid = cv2.VideoCapture(0) # maximum number of frames between saving images self.frame_cap = 1000 # maximum number of images to save before recycling self.image_cap = 10 # for iteration, should be set to 0 self.frame_no = 0 self.image_no = 0 self.images_path = os.path.join('assets','images')
def send_message(message): ''' Sends a message to the Azure Iot Hub. The function requires that the message has an attribute 'hub_endpoint' which contains the corresponding device url of the Azure Iot Hub. ''' # Definitly not the most performant way of communicating with the hub but # should work for device simulation and keeps the code very simple device_hub_url = message.get('hub_endpoint') msgjson = json.dumps(message) msg = Message(msgjson) client = IoTHubDeviceClient.create_from_connection_string(device_hub_url) client.send_message(msg) client.disconnect()
def iothub_client_init(self): global logger # Create an IoT Hub client device_client = IoTHubDeviceClient.create_from_connection_string( CONNECTION_STRING) while True: try: device_client.connect() #connect client break except: logger.error("Azure Connection failed connecting.....") time.sleep(5) #retry return device_client
def iothub_client_sample_run(): try: client = IoTHubDeviceClient.create_from_connection_string( CONNECTION_STRING_DEVICE) message_listener_thread = threading.Thread(target=message_listener, args=(client, )) message_listener_thread.daemon = True message_listener_thread.start() while True: time.sleep(1000) except KeyboardInterrupt: print("IoT Hub C2D Messaging device sample stopped")
def __init__(self): # The device connection string to authenticate the device with your IoT hub. # Using the Azure CLI: # az iot hub device-identity show-connection-string --hub-name {YourIoTHubName} --device-id MyNodeDevice --output table self.CONNECTION_STRING = "HostName=su-MSA.azure-devices.net;DeviceId=MyPythonDevice;SharedAccessKey=ZqigHWDCQ696rya1jI24fA9X3/RAtgbIqkN6WEo0ROc=" # Define the JSON message to send to IoT Hub. self.DISTANCE = 250.0 self.INTENSITY = 255 self.MSG_TXT = '{{"Distance": {distance}, "Intensity": {intensity}}}' #, "Intruder image": {intruder_img}}}' self.INTERVAL = 1 # Create an IoT Hub client self.client = IoTHubDeviceClient.create_from_connection_string( self.CONNECTION_STRING)
def main(): print("IoT Hub Quickstart #1 - Simulated device") print("Press Ctrl-C to exit") # Instantiate the client. Use the same instance of the client for the duration of # your application client = IoTHubDeviceClient.create_from_connection_string(CONNECTION_STRING) # Run Sample try: run_telemetry_sample(client) except KeyboardInterrupt: print("IoTHubClient sample stopped by user") finally: # Upon application exit, shut down the client print("Shutting down IoTHubClient") client.shutdown()
def iothub_client_telemetry_run(): try: client = IoTHubDeviceClient.create_from_connection_string(CONNECTION_STRING) print ( "IoT Hub device sending periodic messages, press Ctrl-C to exit" ) while True: message = getReadings() # Send the message. print( "Sending message: {}".format(message) ) client.send_message(message) print( "Message sent" ) time.sleep(INTERVAL) except KeyboardInterrupt: print ( "IoTHubClient sample stopped" )
def init(connection_string, methods): if connection_string is "": print("Missing connection string!") return 0 client = IoTHubDeviceClient.create_from_connection_string( connection_string, websockets=True) # connect the client. while connect(client) == False: time.sleep(10) print("Starting listening for direct methods of type [{}]...".format( ', '.join(methods.keys()))) # Run method listener threads in the background device_method_thread = threading.Thread(target=device_method_listener, args=(client, methods)) device_method_thread.daemon = True device_method_thread.start()
def iothub_client_init(): derived_device_key = devicekey.derive_device_key(device_id, group_symmetric_key) registration_result = registerdevice.register_device( device_id, derived_device_key) print(registration_result) print("The status was :-") print(registration_result.status) print("The etag is :-") print(registration_result.registration_state.etag) print("\n") if registration_result.status == "assigned": print("Will send telemetry from the provisioned device with id {id}". format(id=device_id)) device_client = IoTHubDeviceClient.create_from_symmetric_key( symmetric_key=derived_device_key, hostname=registration_result.registration_state.assigned_hub, device_id=registration_result.registration_state.device_id, ) return device_client
def create_client(): # Create an IoT Hub client client = IoTHubDeviceClient.create_from_connection_string( CONNECTION_STRING) # Define a method request handler 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) 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
def __init__(self, base_dir, config_path): with open(os.path.join(base_dir, config_path), "r") as f: self.forza_config = json.load(f) self._init_logger() self._setup_udp_socket() self.telemetry_manager = TelemetryManager( self.forza_config["device"]["output_fname"], self.forza_config["device"]["telemetry_format_fname"] ) self.send_ip = self.forza_config["device"]["send_ip"] self.send_port = self.forza_config["device"]["send_port"] # Get the connection string # TODO(): Risk: the file is saved on the disk in plain text conn_str_fname = os.path.join(base_dir, self.forza_config["iothub"]["conn_str_fname"]) self.conn_str = open(conn_str_fname, 'r').read() # Create instance of the device client using the authentication provider self.device_client = IoTHubDeviceClient.create_from_connection_string(self.conn_str) self.device_client.connect()
def run(): try: speed: float = 0.0 #initialises direction to a random number since _generate_direction needs something to start with direction: float = random.uniform(0, 360) #establish connection client: IoTHubDeviceClient = IoTHubDeviceClient.create_from_connection_string( CONNECTION_STRING) print("Sending messages, press Ctrl-c to exit") while True: #update wind speed and direction speed = _generate_speed() direction = _generate_direction(direction, speed) #create and send message message: str = '{"wind_speed":' + str( speed) + ',"wind_direction":' + str(direction) + '}' print("sending: " + message) client.send_message(message) #message is actually sent here print("sent") time.sleep(1) except KeyboardInterrupt: #when Ctrl-c is pressed allow the function to finish so the program can stop running print("Stopped")
def aux_iothub_client_init(): client = IoTHubDeviceClient.create_from_connection_string( AUX_CONNECTION_STRING) return client
def iothub_client_init(): # Create an IoT Hub client client = IoTHubDeviceClient.create_from_connection_string( CONNECTION_STRING) return client
'wind_direction': pld[2], 'wind_intensity': pld[3], 'rain': pld[4] } messaggio = json.dumps(mess) print(dev + " sent " + messaggio) if (dev == "foggia_2"): hubClient1.send_message(messaggio) elif (dev == "rome_2"): hubClient2.send_message(messaggio) print("Message forwarded to the hub") if __name__ == "__main__": #initialize the gateway and connect to the hub from 2 possible devices (fogia_2 and rome_2) hubClient1 = IoTHubDeviceClient.create_from_connection_string( connection_string1, websockets=True) hubClient1.connect() hubClient2 = IoTHubDeviceClient.create_from_connection_string( connection_string2, websockets=True) hubClient2.connect() #initialize the gateway and connect to the broker via MQTT brokerClient = mqtt.Client("PythonGateway", mqtt.MQTTv311) brokerClient.on_connect = on_connect brokerClient.on_disconnect = on_disconnect brokerClient.on_message = on_message brokerClient.connect(brokerAddress, brokerPort) brokerClient.loop_forever() #finally disconnect