static async Task <Tuple <ModuleClient, ModuleConfig> > InitModuleClient(TransportType transportType) { ITransportSettings[] GetTransportSettings() { switch (transportType) { case TransportType.Mqtt: case TransportType.Mqtt_Tcp_Only: case TransportType.Mqtt_WebSocket_Only: return(new ITransportSettings[] { new MqttTransportSettings(transportType) }); default: return(new ITransportSettings[] { new AmqpTransportSettings(transportType) }); } } ITransportSettings[] settings = GetTransportSettings(); ModuleClient moduleClient = await ModuleClient.CreateFromEnvironmentAsync(settings).ConfigureAwait(false); await moduleClient.OpenAsync().ConfigureAwait(false); Console.WriteLine("TemperatureFilter - Opened module client connection"); ModuleConfig moduleConfig = await GetConfiguration(moduleClient).ConfigureAwait(false); Console.WriteLine($"Using TemperatureThreshold value of {moduleConfig.TemperatureThreshold}"); Console.WriteLine("Successfully initialized module client."); return(new Tuple <ModuleClient, ModuleConfig>(moduleClient, moduleConfig)); }
public async Task StartAsync(CancellationToken cancellationToken) { using (LogContext.PushProperty("FunctionId", nameof(StartAsync))) { Log.Information("Opening Edge Module Connection"); await ModuleClient.OpenAsync(); Log.Information("Initializing InfluxDBRecorder"); await TimeSeriesRecorder.InitializeAsync(); Log.Information("Beginning to Process Messages"); await ModuleClient.SetInputMessageHandlerAsync("telemetry", new MessageHandler( async(message, e) => { Log.Information("Processing message.."); var telemetryJson = Encoding.UTF8.GetString(message.GetBytes()); try { await TimeSeriesRecorder.RecordMessageAsync(telemetryJson); } catch (Exception ex) { Log.Error(ex, $"Error for message {telemetryJson}"); } return(await Task.FromResult(MessageResponse.Completed)); } ), ModuleClient); } }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { // create client instance try{ MqttClient client = new MqttClient("localhost"); // register to message received client.MqttMsgPublishReceived += client_MqttMsgPublishReceived; string clientId = Guid.NewGuid().ToString(); client.Connect(clientId); // subscribe to the topic "/home/temperature" with QoS 2 client.Subscribe(new string[] { "/messages" }, new byte[] { MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE }); } catch (Exception ex) { Console.WriteLine("Cannot connect to MQTT broker"); Console.WriteLine("Exception: " + ex.Message + ex); } //init module client AmqpTransportSettings amqpSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only); ITransportSettings[] settings = { amqpSetting }; moduleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await moduleClient.OpenAsync(); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init(bool debug = false) { #if DEBUG while (debug && !Debugger.IsAttached) { Console.WriteLine("Module waiting for debugger to attach..."); await Task.Delay(1000); } ; #endif MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); // Register callback to be called when a message is received by the module await ioTHubModuleClient.SetInputMessageHandlerAsync("compressMessage", CompressMessage, ioTHubModuleClient); await ioTHubModuleClient.SetInputMessageHandlerAsync("decompressMessage", DecompressMessage, ioTHubModuleClient); }
static async Task InitModuleClient(TransportType transportType) { ITransportSettings[] GetTransportSettings() { switch (transportType) { case TransportType.Mqtt: case TransportType.Mqtt_Tcp_Only: case TransportType.Mqtt_WebSocket_Only: return(new ITransportSettings[] { new MqttTransportSettings(transportType) }); default: return(new ITransportSettings[] { new AmqpTransportSettings(transportType) }); } } ITransportSettings[] settings = GetTransportSettings(); ModuleClient moduleClient = await ModuleClient.CreateFromEnvironmentAsync(settings).ConfigureAwait(false); await moduleClient.OpenAsync().ConfigureAwait(false); await moduleClient.SetMethodHandlerAsync("HelloWorldMethod", HelloWorldMethod, null).ConfigureAwait(false); Console.WriteLine("Successfully initialized module client."); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { AmqpTransportSettings amqpSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only); ITransportSettings[] settings = { amqpSetting }; Console.WriteLine("ENV: " + JsonConvert.SerializeObject(Environment.GetEnvironmentVariables())); // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); var moduleTwin = await ioTHubModuleClient.GetTwinAsync(); Console.WriteLine("Init value: "); Console.WriteLine(JsonConvert.SerializeObject(moduleTwin)); var moduleTwinCollection = moduleTwin.Properties.Desired; try { Console.WriteLine("Props: " + JsonConvert.SerializeObject(moduleTwinCollection)); await OnDesiredPropertiesUpdate(moduleTwinCollection, ioTHubModuleClient); } catch (Exception e) { Console.WriteLine($"Property not exist: {e}"); } await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, ioTHubModuleClient); runningThread = Task.Run(() => GenerateData(ioTHubModuleClient)); // Attach a callback for updates to the module twin's desired properties. //GenerateData(ioTHubModuleClient); // Register a callback for messages that are received by the module. //await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", GenerateData, ioTHubModuleClient); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); // Get environment variables scoped for this module _edgeDeviceId = Environment.GetEnvironmentVariable(DeviceIdVariableName); _edgeModuleId = Environment.GetEnvironmentVariable(ModuleIdVariableName); _iothubHostName = Environment.GetEnvironmentVariable(IotHubHostnameVariableName); _gatewayHostName = Environment.GetEnvironmentVariable(GatewayHostnameVariableName); // Initialize leaf device cache _leafDevices = new MemoryDeviceRepository(); // Register callback to be called when a message is received by the module await ioTHubModuleClient.SetMethodHandlerAsync(ItmCallbackMethodName, DeviceRegistered, ioTHubModuleClient); await ioTHubModuleClient.SetInputMessageHandlerAsync(ItmMessageInputName, PipeMessage, ioTHubModuleClient); }
private void InitializeClient() { // If the client reports Connected status, it is already in operational state. if (s_connectionStatus != ConnectionStatus.Connected && _moduleConnectionStrings.Any()) { lock (_initLock) { _logger.LogDebug($"Attempting to initialize the client instance, current status={s_connectionStatus}"); // If the module client instance has been previously initialized, then dispose it. // The s_wasEverConnected variable is required to store if the client ever reported Connected status. if (s_wasEverConnected && s_connectionStatus == ConnectionStatus.Disconnected) { s_moduleClient?.Dispose(); s_wasEverConnected = false; } s_moduleClient = ModuleClient.CreateFromConnectionString(_moduleConnectionStrings.First(), _transportType); s_moduleClient.SetConnectionStatusChangesHandler(ConnectionStatusChangeHandler); s_moduleClient.OperationTimeoutInMilliseconds = (uint)s_operationTimeout.TotalMilliseconds; } try { // Force connection now s_moduleClient.OpenAsync().GetAwaiter().GetResult(); _logger.LogDebug($"Initialized the client instance."); } catch (UnauthorizedException) { // Handled by the ConnectionStatusChangeHandler } } }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { // Use Mqtt as it is more reliable than ampq MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); wrappedModuleClient = new WrappedModuleClient(ioTHubModuleClient); Logger.LogInfo("IoT Hub module client initialized."); // get module twin settings var moduleTwin = await ioTHubModuleClient.GetTwinAsync(); await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, ioTHubModuleClient); // Attach a callback for updates to the module twin's desired properties. await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null); // Register callback to be called when a message is received by the module await ioTHubModuleClient.SetInputMessageHandlerAsync(TrackerModule.TelemetryInputName, ProcessTelemetry, ioTHubModuleClient); // Register callback to be called when a message is received by the module await ioTHubModuleClient.SetInputMessageHandlerAsync(TrackerModule.BalloonInputName, ProcessBalloonData, ioTHubModuleClient); }
static async Task CallDirectMethodAsync() { try { var varEnvs = System.Environment.GetEnvironmentVariables(); foreach (System.Collections.DictionaryEntry varEnv in varEnvs) { Console.WriteLine($"Variable: key '{varEnv.Key}', value '{varEnv.Value}'"); } var deviceId = System.Environment.GetEnvironmentVariable("IOTEDGE_DEVICEID"); Console.WriteLine($"deviceId: {deviceId}"); // MethodRequest request = new MethodRequest("MethodA", Encoding.UTF8.GetBytes("{ \"Message\": \"Hello\" }")); string message = "{ \"TimeOut_mns\": " + timeOut_mns.ToString() + " }"; MethodRequest request = new MethodRequest("NotifyTimeOut", Encoding.UTF8.GetBytes(message)); MqttTransportSettings mqttSetting = new MqttTransportSettings(Microsoft.Azure.Devices.Client.TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); var response = await ioTHubModuleClient.InvokeMethodAsync(deviceId, "MQTTClientModule", request).ConfigureAwait(false); Console.WriteLine($"Received response with status {response.Status}"); } catch (Exception ex) { Console.WriteLine(); Console.WriteLine($"Error : {ex.Message}"); } }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages /// </summary> static async Task <ModuleClient> Init(bool debug = false) { //This debug code enables code execution to pause while you attach the debugger //See instructions in the Main method to pass true to the debug variable. //Otherwise, when debugging, some code will run before you can attach the debugger. #if DEBUG while (debug && !Debugger.IsAttached) { Log.Verbose("Module waiting for debugger to attach..."); await Task.Delay(1000); } ; #endif MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Log.Information("IoT Hub Heartbeat module client on {deviceId} initialized", deviceId); // Register callback to be called when a message is received by the module await ioTHubModuleClient.SetMethodDefaultHandlerAsync(AckMessage, ioTHubModuleClient); return(ioTHubModuleClient); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); // Register callback to be called when a message is received by the module await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient); httpClient = new HttpClient { BaseAddress = new Uri(Environment.GetEnvironmentVariable("LOCAL_EVENT_GRID_URI")) }; httpClient.DefaultRequestHeaders.Add("aeg-sas-key", Environment.GetEnvironmentVariable("EVENT_GRID_SAS_KEY")); topicName = Environment.GetEnvironmentVariable("TOPIC_NAME"); enpointUrl = Environment.GetEnvironmentVariable("WEBHOOK_URL"); edgeHubOutputName = Environment.GetEnvironmentVariable("EDGEHUB_OUTPUT_NAME"); cloudEventGridSasKey = Environment.GetEnvironmentVariable("CLOUD_EVENTGRID_SAS_KEY"); //cloudEventGridTopicName = Environment.GetEnvironmentVariable("CLOUD_EVENTGRID_TOPIC"); cloudEventGridEnpointUrl = Environment.GetEnvironmentVariable("CLOUD_EVENTGRID_ENDPOINT"); await CreateEventGridWebHookSubscriptionAsync(); await CreateEventGridEdgeHubSubscriptionAsync(); await CreateCloudEventGridSubscriptionAsync(); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); // Register callback to be called when a message is received by the module // await ioTHubModuleClient.SetImputMessageHandlerAsync("input1", PipeMessage, iotHubModuleClient); // Read TemperatureThreshold from Module Twin Desired Properties // var moduleTwin = await ioTHubModuleClient.GetTwinAsync(); // var moduleTwinCollection = moduleTwin.Properties.Desired; // try { // temperatureThreshold = moduleTwinCollection["TemperatureThreshold"]; // } catch(ArgumentOutOfRangeException e) { // Console.WriteLine($"Property TemperatureThreshold not exist: {e.Message}"); // } // Attach callback for Twin desired properties updates //await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(onDesiredPropertiesUpdate, null); // Register callback to be called when a message is received by the module await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", FilterMessages, ioTHubModuleClient); Console.WriteLine("Done setting up callbacks."); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); // Read the TemperatureThreshold value from the module twin's desired properties var moduleTwin = await ioTHubModuleClient.GetTwinAsync(); await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, ioTHubModuleClient); // Attach a callback for updates to the module twin's desired properties. await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null); // Register callback to be called when a message is received by the module await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient); InitFileWatcher(); DisplayImage(logoImagePath); Console.WriteLine("Successfully initialized ScreenshotWatcher module."); }
static async Task <int> MainAsync() { Logger.LogInformation("DirectMethodReceiver Main() started."); IConfiguration configuration = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("config/appsettings.json", optional: true) .AddEnvironmentVariables() .Build(); TransportType transportType = configuration.GetValue("ClientTransportType", TransportType.Amqp_Tcp_Only); ModuleClient moduleClient = await ModuleUtil.CreateModuleClientAsync( transportType, ModuleUtil.DefaultTimeoutErrorDetectionStrategy, ModuleUtil.DefaultTransientRetryStrategy, Logger); (CancellationTokenSource cts, ManualResetEventSlim completed, Option <object> handler) = ShutdownHandler.Init(TimeSpan.FromSeconds(5), null); await moduleClient.OpenAsync(); await moduleClient.SetMethodHandlerAsync("HelloWorldMethod", HelloWorldMethodAsync, null, cts.Token); await cts.Token.WhenCanceled(); completed.Set(); handler.ForEach(h => GC.KeepAlive(h)); Logger.LogInformation("DirectMethodReceiver Main() finished."); return(0); }
/// <summary> /// Initializes the ModuleClient. /// </summary> static void Init() { MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only) { RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true }; ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime var mcTask = ModuleClient.CreateFromEnvironmentAsync(settings); mcTask.Wait(); s_moduleClient = mcTask.Result; s_moduleClient.OpenAsync().Wait(); // Read configuration from Module Twin Task <Twin> twinTask = s_moduleClient.GetTwinAsync(); twinTask.Wait(); Twin twin = twinTask.Result; OnDesiredPropertiesUpdate(twin.Properties.Desired, null); s_moduleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null); Console.WriteLine("IoT Hub module client initialized."); }
/// <summary> /// Initializes the ModuleClient /// </summary> static async Task Init() { AmqpTransportSettings amqpSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only); ITransportSettings[] settings = { amqpSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); var moduleTwin = await ioTHubModuleClient.GetTwinAsync(); var moduleTwinCollection = moduleTwin.Properties.Desired; desiredPropertiesData = new DesiredPropertiesData(moduleTwinCollection); // callback for updating desired properties through the portal or rest api await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null); // as this runs in a loop we don't await await SendData(ioTHubModuleClient); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { AmqpTransportSettings amqpSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only); ITransportSettings[] settings = { amqpSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module Client initialized."); // Execute callback function during Init for Twin desired properties var twin = await ioTHubModuleClient.GetTwinAsync(); await onDesiredPropertiesUpdate(twin.Properties.Desired, ioTHubModuleClient); //Register the desired property callback await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(onDesiredPropertiesUpdate, ioTHubModuleClient); //start the main thread that will do the real job of the module var thread = new Thread(() => mainThreadBody(ioTHubModuleClient)); thread.Start(); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { // the module client is in charge of sending messages in the context of this module (VehicleTelemetry) ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(TransportType.Mqtt); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); // Register callback to be called when a message is received by this module await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient); //the device client is responsible for managing device twin information at the device level //obtaining the device connection string is currently not supported by DeviceClient //TODO: 7 - set device connection string for the device client //ioTHubDeviceClient = DeviceClient.CreateFromConnectionString("<connectionstring>"); await ioTHubDeviceClient.SetDesiredPropertyUpdateCallbackAsync(onDesiredPropertiesUpdateAsync, null); var twin = await ioTHubDeviceClient.GetTwinAsync(); var desired = twin.Properties.Desired; await UpdateReportedPropertiesFromDesired(desired); await GenerateMessage(ioTHubModuleClient); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { string connectionString = Environment.GetEnvironmentVariable("AZURE_STORAGE_CONNECTION_STRING"); Console.WriteLine($"{connectionString}"); ContainerClient = new BlobContainerClient(connectionString, "samplecontainer"); try { await ContainerClient.CreateIfNotExistsAsync(); } catch (RequestFailedException ex) { Console.WriteLine($"{ex}"); } MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); #pragma warning disable 4014 MainLoop(ioTHubModuleClient); #pragma warning restore 4014 }
public static async Task <TestModule> CreateAndConnect(string connectionString, ITransportSettings[] settings) { ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(connectionString, settings); await moduleClient.OpenAsync(); return(new TestModule(moduleClient)); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); // Read the Humidity value from the module twin's desired properties var moduleTwin = await ioTHubModuleClient.GetTwinAsync(); var moduleTwinCollection = moduleTwin.Properties.Desired; try { humidityFilter = moduleTwinCollection["Humidity"]; } catch (ArgumentOutOfRangeException e) { Console.WriteLine($"Property Humidity does not exist: {e.Message}"); } // Attach a callback for updates to the module twin's properties. await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null); // Register callback to be called when a message is received by the module await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", FilterHumidityMessage, ioTHubModuleClient); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime IoTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await IoTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); // Register callback to be called when a message is received by the module //await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient); //initialize Raspberry _raspberryPins = new Pins(); _raspberryPins.ConnectGpio(); _raspberryPins.LoopGpioPins(); _paradox1738 = new Paradox1738(); _paradox1738.ParadoxSecurity(); _paradox1738.IRSensorsReading(); //Receive Netatmo data _receiveNetatmoData = new ReceiveNetatmoData(); _receiveNetatmoData.ReceiveData(); //read from ome temperature sensors _homeTemperature = new HomeTemperature(); _homeTemperature.ReadTemperature(); //Starting schedulers _co2Scheduler = new Co2(); _co2Scheduler.CheckCo2Async(); _saunaHeating = new SaunaHeating(); _saunaHeating.CheckHeatingTime(); _heatingScheduler = new Heating(); _heatingScheduler.ReduceHeatingSchedulerAsync(); //Receive IoTHub commands _receiveData = new ReceiveData(); _receiveData.ReceiveCommandsAsync(); //query WiFiProbes _wiFiProbes = new WiFiProbes(); _wiFiProbes.QueryWiFiProbes(); //shelly's TelemetryDataClass.isOutsideLightsOn = await Shelly.GetShellyState(Shelly.OutsideLight); SomeoneAtHome.CheckLightStatuses(); //Send data to IoTHub _sendData = new SendTelemetryData(); _sendData.SendTelemetryEventsAsync(); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); // Attach callback for Twin desired properties updates await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(onDesiredPropertiesUpdate, ioTHubModuleClient); // Execute callback method for Twin desired properties updates var twin = await ioTHubModuleClient.GetTwinAsync(); await onDesiredPropertiesUpdate(twin.Properties.Desired, ioTHubModuleClient); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); var thread = new Thread(() => ThreadBody(ioTHubModuleClient)); thread.Start(); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("Proxy module client initialized."); // Register callback to be called when a direct method message is received by the module await ioTHubModuleClient.SetMethodHandlerAsync("GetDeviceIdFromDirectMethod", DelegateDirectMethod, ioTHubModuleClient); // Register callback to be called when a message is received by the module await ioTHubModuleClient.SetInputMessageHandlerAsync("MessageFromConverter", DelegateMessageEvents, ioTHubModuleClient); // Read the Threshold value from the module twin's desired properties var moduleTwin = await ioTHubModuleClient.GetTwinAsync(); //await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, ioTHubModuleClient); // Attach a callback for updates to the module twin's desired properties. await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null); }
static async Task <ModuleClient> InitModuleClient(TransportType transportType) { ITransportSettings[] GetTransportSettings() { switch (transportType) { case TransportType.Mqtt: case TransportType.Mqtt_Tcp_Only: return(new ITransportSettings[] { new MqttTransportSettings(TransportType.Mqtt_Tcp_Only) }); case TransportType.Mqtt_WebSocket_Only: return(new ITransportSettings[] { new MqttTransportSettings(TransportType.Mqtt_WebSocket_Only) }); case TransportType.Amqp_WebSocket_Only: return(new ITransportSettings[] { new AmqpTransportSettings(TransportType.Amqp_WebSocket_Only) }); default: return(new ITransportSettings[] { new AmqpTransportSettings(TransportType.Amqp_Tcp_Only) }); } } ITransportSettings[] settings = GetTransportSettings(); ModuleClient moduleClient = await ModuleClient.CreateFromEnvironmentAsync(settings).ConfigureAwait(false); await moduleClient.OpenAsync().ConfigureAwait(false); Log.Information("Successfully initialized module client."); return(moduleClient); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); var connectionString = Environment.GetEnvironmentVariable("STORAGE_CONNECTION_STRING"); var containerName = Environment.GetEnvironmentVariable("RESULT_CONTAINER_NAME"); var storageAccount = CloudStorageAccount.Parse(connectionString); var cloudBlobClient = storageAccount.CreateCloudBlobClient(); cloudBlobContainer = cloudBlobClient.GetContainerReference(containerName); await cloudBlobContainer.CreateIfNotExistsAsync(); http = new HttpRouter(new string[] { "http://+:80/" }); http.Register("/caption", SetCaption); http.Register("/video/start", StartRecording); http.Register("/video/end", EndRecording); http.Register("/photo", TakePhoto); http.Start(); await Task.CompletedTask; }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); // Read TemperatureThreshold from Module Twin Desired Properties var moduleTwin = await ioTHubModuleClient.GetTwinAsync(); var moduleTwinCollection = moduleTwin.Properties.Desired; try { await DoTwinUpdate(moduleTwin.Properties.Desired, ioTHubModuleClient); } catch (ArgumentOutOfRangeException e) { Console.WriteLine($"Error setting desired properties: {e.Message}"); } // Attach callback for Twin desired properties updates await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, ioTHubModuleClient); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings).ConfigureAwait(false); await ioTHubModuleClient.OpenAsync().ConfigureAwait(false); Console.WriteLine("IoT Hub module client initialized."); // Read the TemperatureThreshold value from the module twin's desired properties var moduleTwin = await ioTHubModuleClient.GetTwinAsync().ConfigureAwait(false); await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, ioTHubModuleClient); // Attach a callback for updates to the module twin's desired properties. await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null).ConfigureAwait(false); // Register a callback for messages that are received by the module. await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", FilterMessagesAsync, ioTHubModuleClient).ConfigureAwait(false); await ioTHubModuleClient.SetMethodHandlerAsync(heartbeat, HeartbeatAsync, null).ConfigureAwait(false); Console.WriteLine("Set Heartbeat Method Handler:HeartbeatAsync."); }
/// <summary> /// Initializes the ModuleClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init() { AmqpTransportSettings amqpSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only); ITransportSettings[] settings = { amqpSetting }; // Open a connection to the Edge runtime ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); // Read the TemperatureThreshold value from the module twin's desired properties var moduleTwin = await ioTHubModuleClient.GetTwinAsync(); // Execute callback function during Init for Twin desired properties await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, ioTHubModuleClient); // Attach a callback for updates to the module twin's desired properties. await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null); // Register a callback for messages that are received by the module. await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", FilterMessages, ioTHubModuleClient); }