public static IManagedMqttClient UseDisconnectedHandler(this IManagedMqttClient client, Action <MqttClientDisconnectedEventArgs> handler) { if (client == null) { throw new ArgumentNullException(nameof(client)); } if (handler == null) { return(client.UseDisconnectedHandler((IMqttClientDisconnectedHandler)null)); } return(client.UseDisconnectedHandler(new MqttClientDisconnectedHandlerDelegate(handler))); }
public MqttService( IOptions <MqttOptions> mqttOptions, ILogger <MqttService> logger, DeviceState deviceState, IServiceScopeFactory serviceScopeFactory) { _mqttOptions = mqttOptions.Value; _logger = logger; _deviceState = deviceState; _serviceScopeFactory = serviceScopeFactory; _client = new MqttFactory().CreateManagedMqttClient(); _client.UseApplicationMessageReceivedHandler(e => { HandleMqttMessage(e); }); _client.UseConnectedHandler(e => { HandleMqttConnected(e); }); _client.UseDisconnectedHandler(e => { HandleMqttDisconnected(e); }); }
public bool TryConnect() { lock (_syncRoot) { if (IsConnected) { // prevent duplicated concurrent re-connection return(true); } if (!_mqttClient.IsStarted) { _logger.LogInformation("Mqtt Client is trying to connect"); _mqttClient.StartAsync(_clientOptions).Wait(); _mqttClient.UseConnectedHandler(e => { _logger.LogInformation("MQTT Server connected!"); }); _mqttClient.UseDisconnectedHandler((e) => { _logger.LogError("MQTT Server disconnected: " + e?.Exception?.Message); }); } return(_mqttClient.IsConnected); } }
private async void OnStarted() { var brokerSettings = _configuration.GetSection("BrokerSettings").Get <BrokerSettings>(); var options = new ManagedMqttClientOptionsBuilder() .WithAutoReconnectDelay(TimeSpan.FromSeconds(5)) .WithClientOptions(new MqttClientOptionsBuilder() .WithClientId(_serviceSettings.NodeId) .WithTcpServer(brokerSettings.Host, brokerSettings.Port) .WithCredentials(brokerSettings.Username, brokerSettings.Password) .WithCleanSession(false) .Build()) .Build(); _client.UseConnectedHandler(handler => { _logger.LogInformation("Connected successfully with MQTT Brokers."); }); _client.UseDisconnectedHandler(handler => { _logger.LogWarning("Disconnected from MQTT Brokers."); }); await _client.StartAsync(options); _timer = new Timer(HandleTimerCallback, null, TimeSpan.Zero, TimeSpan.FromMilliseconds(_serviceSettings.TimeSpan)); }
public static async Task ConnectAsync() { var clientId = Guid.NewGuid().ToString(); var mqttURI = "localhost"; var mqttUser = "******"; var mqttPassword = "******"; var mqttPort = 1883; var messageBuilder = new MqttClientOptionsBuilder() .WithClientId(clientId) .WithCredentials(mqttUser, mqttPassword) .WithTcpServer(mqttURI, mqttPort) .WithCleanSession(); var options = messageBuilder .Build(); var managedOptions = new ManagedMqttClientOptionsBuilder() .WithAutoReconnectDelay(TimeSpan.FromSeconds(5)) .WithClientOptions(options) .Build(); await client.StartAsync(managedOptions); client.UseConnectedHandler(e => { Console.WriteLine("Connected successfully with MQTT Brokers."); }); client.UseDisconnectedHandler(e => { Console.WriteLine("Disconnected from MQTT Brokers."); }); }
public MqttSink(MqttSinkOptions options, IManagedMqttClient client) : base(options) { MqttClient = client; Topics = options.Topics.ToList(); Options = options; var builder = new MqttClientOptionsBuilder() .WithTcpServer(options.Server, options.Port); if (options.Password != null && options.Username != null) { builder = builder.WithCredentials(options.Username, options.Password); } var clientOptions = builder.Build(); MqttClientOptions = new ManagedMqttClientOptionsBuilder() .WithPendingMessagesOverflowStrategy(MQTTnet.Server.MqttPendingMessagesOverflowStrategy.DropOldestQueuedMessage) .WithClientOptions(clientOptions) .WithMaxPendingMessages(1).WithAutoReconnectDelay(TimeSpan.FromSeconds(10)).Build(); MqttClient.UseDisconnectedHandler(HandleDisconnected); MqttClient.UseConnectedHandler(HandleConnected); client.StartAsync(MqttClientOptions).Wait(); Next.Subscribe(payload => { Publish(payload).Wait(); }); }
private static async Task ConnectAsync() { string mqttUri = configuration["mqttServerIp"]; //const string mqttUri = "localhost"; var mqttUser = configuration["mqttUser"]; var mqttPassword = configuration["mqttPassword"]; var mqttPort = Convert.ToInt32(configuration["mqttPort"]); Console.WriteLine($"MQTT Server:{mqttUri} Username:{mqttUser} ClientID:{clientId}"); var messageBuilder = new MqttClientOptionsBuilder() .WithClientId(clientId) .WithCredentials(mqttUser, mqttPassword) .WithTcpServer(mqttUri, mqttPort) .WithKeepAlivePeriod(new TimeSpan(0, 0, 30)) .WithCleanSession(); var options = messageBuilder .Build(); var managedOptions = new ManagedMqttClientOptionsBuilder() .WithAutoReconnectDelay(TimeSpan.FromSeconds(2)) .WithClientOptions(options) .Build(); await client.StartAsync(managedOptions); client.UseConnectedHandler(e => { Console.WriteLine("Connected successfully with MQTT Brokers."); }); client.UseDisconnectedHandler(e => { new MqttClientDisconnectedHandlerDelegate(e => MqttClient_Disconnected(e)); Console.WriteLine("Disconnected from MQTT Brokers.Client Was Connected " + e.ClientWasConnected); }); client.UseApplicationMessageReceivedHandler(e => { try { var topic = e.ApplicationMessage.Topic; if (!string.IsNullOrWhiteSpace(topic)) { var payload = HelperFunctions.GetPayload(e.ApplicationMessage.Payload); Console.WriteLine($"Topic: {topic}. Message Received: {JsonConvert.SerializeObject(payload, Formatting.Indented)}"); var platoonId = topic.Replace("platooning/" + clientId + "/", "").Split("/").Last(); if (payload.Maneuver == 2) { _ = SubscribeAsync($@"platooning/broadcast/{platoonId}/#"); Console.WriteLine("Client SubscribeAsync as " + "platooning/broadcast/" + platoonId + "/#"); } } } catch (Exception ex) { Console.WriteLine(ex.Message, ex); } }); }
static void Main(string[] args) { WebClient webclient = new WebClient(); Console.WriteLine("Started mqtt influx exporter"); Task.Run(async() => { await ConnectAsync(); client.UseConnectedHandler(e => { Console.WriteLine("Connected successfully with MQTT Brokers."); }); client.UseDisconnectedHandler(e => { Console.WriteLine("Disconnected from MQTT Brokers."); }); client.UseApplicationMessageReceivedHandler(e => { try { string topic = e.ApplicationMessage.Topic; if (string.IsNullOrWhiteSpace(topic) == false) { string payload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload); if (Environment.GetEnvironmentVariable("LOG_MQTT").ToLower() == "true") { Console.WriteLine($"Topic: {topic}. Message Received: {payload}"); } string[] topicParts = topic.Split("/"); // "temperature, type="weather", device="mcu12390u0adaksnjl", value=25.23, timestamp (optional, nanosecond unix time) string influxPayload = topicParts[2] + ",type=" + topicParts[1] + ",device=" + topicParts[3] + " value=" + payload; string url = Environment.GetEnvironmentVariable("INFLUXDB_URL"); if (string.IsNullOrEmpty(url)) { url = "http://192.168.10.31:8086/write?db=iot"; } var response = webclient.UploadString(url, influxPayload); //Console.WriteLine(response); } } catch (Exception ex) { Console.WriteLine(ex.Message, ex); } }); // Subscribe to channels _ = SubscribeAsync("iot/weather/+/+", 1); }); // Prevent immediate exit _quitEvent.WaitOne(); }
/// <summary> /// Starts the MQTT Client. /// </summary> /// <returns></returns> public async Task Start() { if (managedMqttClient != null) { return; } managedMqttClient = new MqttFactory().CreateManagedMqttClient(); IMqttClientOptions mqttClientOptions = new MqttClientOptionsBuilder() .WithTcpServer(host, tcpPort) .WithCredentials(user, pass) .Build(); ManagedMqttClientOptions managedMqttClientOptions = new ManagedMqttClientOptionsBuilder() .WithClientOptions(mqttClientOptions) .Build(); managedMqttClient.UseApplicationMessageReceivedHandler(e => { IngestMessage(e.ApplicationMessage); return(Task.CompletedTask); }); managedMqttClient.UseConnectedHandler(e => { OnStatusUpdate(this, "MQTT connected."); }); managedMqttClient.UseDisconnectedHandler(e => { if (e.ClientWasConnected) { OnStatusUpdate(this, "MQTT disconnected."); } else { OnStatusUpdate(this, "MQTT failed to connect."); } }); managedMqttClient.ConnectingFailedHandler = new ConnectingFailedHandlerDelegate(e => { OnError(this, "MQTT connection failed: " + e.Exception.FlattenMessages()); }); await managedMqttClient.StartAsync(managedMqttClientOptions); string topic = "rtl_433/+/devices/#"; OnStatusUpdate(this, "Will subscribe to topic \"" + topic + "\""); await managedMqttClient.SubscribeAsync(topic); }
public async Task StartAsync(CancellationToken cancellationToken) { _logger.LogInformation("MQTT background Service is starting "); await this.ConnectAsync(); if (_client.IsStarted) { _logger.LogInformation("client is started"); } _client.UseConnectedHandler(ConnectHandler); _client.UseDisconnectedHandler(DisconnectHandler); _client.UseApplicationMessageReceivedHandler(MessageRecievedHandler); await _client.SubscribeAsync("ESP/TOLLCOLLECTION"); }
public void Setup() { client.UseApplicationMessageReceivedHandler(e => { Console.WriteLine(""); Console.WriteLine("### RECEIVED APPLICATION MESSAGE ###"); Console.WriteLine($"+ Topic = {e.ApplicationMessage.Topic}"); Console.WriteLine($"+ Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}"); Console.WriteLine($"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}"); Console.WriteLine($"+ Retain = {e.ApplicationMessage.Retain}"); Console.WriteLine(); // Task.Run(() => client.PublishAsync("hello/world")); if (e.ApplicationMessage.Topic == "master/start") { if (!recording) { recording = true; publish("\nStart Signal received", "master/response"); _recorder.record(); } } else if (e.ApplicationMessage.Topic == "master/stop") { if (recording) { recording = false; publish("\nStop Signal received", "master/response"); _recorder.stop(); } } }); client.UseDisconnectedHandler(e => { Console.WriteLine("Attempting to Connect to " + MasterIP); Console.WriteLine("\nDisconnected from MQTT Broker!"); connected = false; }); client.UseConnectedHandler(c => { Console.WriteLine("\nConnected to MQTT Broker @ " + MasterIP + ":" + MasterPort + "!"); connected = true; }); }
private void Connect() { var clientOptions = new MqttClientOptionsBuilder() .WithClientId("DeconzToMqtt2") .WithTcpServer(_hostname) .WithWillMessage(new MqttApplicationMessageBuilder() .WithRetainFlag(true) .WithTopic("tele/deconztomqtt/LWT") .WithPayload("offline") .Build()); if (!string.IsNullOrWhiteSpace(_username)) { clientOptions.WithCredentials(_username, _password); } var managedOptions = new ManagedMqttClientOptionsBuilder() .WithAutoReconnectDelay(TimeSpan.FromSeconds(5)) .WithClientOptions(clientOptions); var factory = new MqttFactory(new MqttNetLogger(_logProvider)); _client = factory.CreateManagedMqttClient(); _client.UseDisconnectedHandler(async e => { _logger.Warn("Disconnected from MQTT server. Try reconnect..."); }); _client.UseConnectedHandler(async e => { _logger.Info("Connected to MQTT server"); await _client.PublishAsync(new MqttApplicationMessageBuilder() .WithRetainFlag(true) .WithTopic("tele/deconztomqtt/LWT") .WithPayload("online") .Build()); }); _logger.Info("Connecting to MQTT server '{0}'", _hostname); _client.StartAsync(managedOptions.Build()).Wait(_cancelationToken.Token); }
private static IManagedMqttClient SetupConnectionHandler(this IManagedMqttClient mqttClient, ManagedMqttClientOptions options) { // Handle disconnection mqttClient.UseDisconnectedHandler(async e => { Console.WriteLine("### DISCONNECTED FROM SERVER ###"); await Task.Delay(TimeSpan.FromSeconds(5)); try { await mqttClient.StartAsync(options); } catch { Console.WriteLine("### RECONNECTING FAILED ###"); } }); return(mqttClient); }
public void Create(ConnectionOptions options, Credentials credentials, string topic) { //configure options var mqttClientOptions = new MqttClientOptionsBuilder() .WithClientId(credentials.UserName) .WithTcpServer(options.IpAddress, options.Port) .WithCredentials(credentials.Login, credentials.Password) .WithCleanSession() .Build(); var mqttManagedMqttClientOptions = _options = new ManagedMqttClientOptionsBuilder() .WithAutoReconnectDelay(TimeSpan.FromSeconds(5)) .WithClientOptions(mqttClientOptions) .Build(); // Create a new MQTT client. _client = new MqttFactory().CreateManagedMqttClient(); //handlers _client.UseConnectedHandler(e => { OnConnected?.Invoke(e); //subscribing to a topic if (!string.IsNullOrEmpty(topic)) { _topic = topic; _client.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).Build()).Wait(); } }); _client.UseDisconnectedHandler(e => { OnDisconnected?.Invoke(e); }); _client.UseApplicationMessageReceivedHandler(e => { OnMessageReceived?.Invoke(e); }); }
public static IManagedMqttClient ConfigureMqttEvents(this IManagedMqttClient mqttClient, IServiceProvider serviceProvider, CancellationToken cancellationToken) { MqttEvents mqttEvents = serviceProvider.GetService <MqttEvents>(); if (mqttEvents == null) { throw new InvalidOperationException($"Unable to find {nameof(MqttEvents)} service. Did you forget to call {nameof(ServiceCollectionExtensions.AddMqttEvents)}()?"); } mqttClient.UseDisconnectedHandler(async args => { await mqttEvents.InvokeDisconnectHandler(args, cancellationToken); }); mqttClient.UseConnectedHandler(async args => { await mqttEvents.InvokeConnectHandler(args, cancellationToken); }); return(mqttClient); }
/// <summary> /// Constructor /// </summary> public Logic(ILogger <Logic> logger, IOptions <Config> config, IHostEnvironment hostEnvironment) { _logger = logger; _config = config.Value; _hostEnvironment = hostEnvironment; _mqttClient = new MqttFactory().CreateManagedMqttClient(); _mqttClient.UseApplicationMessageReceivedHandler(MqttClientOnApplicationMessageReceived); _mqttClient.UseConnectedHandler(async e => { _logger.LogInformation("Connected to MQTT server"); await _mqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(_config.Mqtt.ShutdownTopic) .Build()); }); _mqttClient.UseDisconnectedHandler(e => { if (e.Exception != null && !e.ClientWasConnected) { _logger.LogError(e.Exception, "Unable to connect to MQTT server"); } if (e.Exception != null && e.ClientWasConnected) { _logger.LogError("Disconnected from connect to MQTT server with error", e.Exception); } if (e.Exception == null && e.ClientWasConnected) { _logger.LogInformation("Disconnected from MQTT server"); } }); _timeoutTimer = new Timer(_config.TimeoutSeconds * 1000); _timeoutTimer.Elapsed += async(sender, args) => { _timeoutTimer.Stop(); InitiateShutdown(); }; }
public async Task ConnectAsync() { try { _mqttClient.UseConnectedHandler(e => { _logger.LogInformation("Connected to Mqtt Broker"); }); _mqttClient.UseDisconnectedHandler(e => { if (e.Exception != null) { _logger.LogWarning("Disconnected from Mqtt Broker", e.Exception); } }); _mqttClient.UseApplicationMessageReceivedHandler(async e => { try { var topic = e.ApplicationMessage.Topic; if (!string.IsNullOrWhiteSpace(topic)) { var payload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload); _logger.LogInformation($"Topic: {topic}. Message Received: {payload}"); await OnReceived(topic, payload); } } catch (Exception ex) { _logger.LogError(ex.Message, ex); } }); await _mqttClient.StartAsync(_managedOptions); } catch (Exception e) { _logger.LogError("Failed to start Mqtt Client", e); throw; } }
public MqttService(IHubContext <DevicesHub> hubContext) { _hubContext = hubContext; var messageBuilder = new MqttClientOptionsBuilder().WithClientId(clientId) /*.WithCredentials(mqttUser, mqttPassword)*/.WithTcpServer(mqttURI, mqttPort).WithCleanSession(); var options = mqttSecure ? messageBuilder .WithTls() .Build() : messageBuilder .Build(); var managedOptions = new ManagedMqttClientOptionsBuilder().WithAutoReconnectDelay(TimeSpan.FromSeconds(5)) .WithClientOptions(options) .Build(); client = new MqttFactory().CreateManagedMqttClient(); client.StartAsync(managedOptions); client.UseConnectedHandler(ClientConnectedHandler); client.UseDisconnectedHandler(ClientDisconnectedHandler); client.UseApplicationMessageReceivedHandler(ClientMessageReceivedHandler); }
public MqttListenerService(IManagedMqttClient client, IManagedMqttClientOptions options, IConfiguration configuration, IServiceId serviceId, ILogger <MqttListenerService> logger, IPointsOfSaleService posService, IServiceProvider serviceProvider, IPosTopicClassifier posTopicClassifier) { if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } if (serviceId == null) { throw new ArgumentNullException(nameof(serviceId)); } _client = client ?? throw new ArgumentNullException(nameof(client)); _options = options ?? throw new ArgumentNullException(nameof(options)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _posService = posService ?? throw new ArgumentNullException(nameof(posService)); _posTopicClassifier = posTopicClassifier ?? throw new ArgumentNullException(nameof(posTopicClassifier)); _client.UseApplicationMessageReceivedHandler(OnMqttMessageReceived); _client.UseConnectedHandler(args => OnConnectedHandler(args)); _client.UseDisconnectedHandler(args => OnDisconnectedHandler(args)); _messageHandlers = serviceProvider.GetServices <IMqttMessageHandler>().ToArray(); }
public Logic(ILogger <Logic> logger, IHostEnvironment hostEnvironment) { _logger = logger; _hostEnvironment = hostEnvironment; var fileName = Path.Combine(_hostEnvironment.ContentRootPath, "config.yml"); Directory.CreateDirectory(Path.Combine(_hostEnvironment.ContentRootPath, "tokens")); if (!File.Exists(fileName)) { throw new FileNotFoundException("Config file not found", fileName); } var yaml = File.ReadAllText(fileName); using (var input = new StringReader(yaml)) { var deserializer = new DeserializerBuilder() .WithNamingConvention(CamelCaseNamingConvention.Instance) .IgnoreUnmatchedProperties() .Build(); _config = deserializer.Deserialize <Config>(input); } _mqttSubscriptions = new List <MqttSubscription>(); _mqttClient = new MqttFactory().CreateManagedMqttClient(); _mqttClient.UseApplicationMessageReceivedHandler(MqttClientOnApplicationMessageReceived); _mqttClient.UseConnectedHandler(e => { _logger.LogInformation("Connected to MQTT server"); }); _mqttClient.UseDisconnectedHandler(e => { if (e.Exception != null && !e.ClientWasConnected) { _logger.LogError(e.Exception, "Unable to connect to MQTT server"); } if (e.Exception != null && e.ClientWasConnected) { _logger.LogError("Disconnected from connect to MQTT server with error", e.Exception); } if (e.Exception == null && e.ClientWasConnected) { _logger.LogInformation("Disconnected from MQTT server"); } }); _requestPolicy = Policy .Handle <FlurlHttpException>(r => r.Call.HttpStatus == HttpStatusCode.Unauthorized) .RetryAsync(1, async(exception, i) => { var call = (exception as FlurlHttpException)?.Call; if (!(call?.FlurlRequest is FlurlApiRequest req)) { return; } _logger.LogError("Access forbidden", exception); _logger.LogInformation($"Authenticating for api {req.Api.Name}"); await ExecuteAuthentication(req.Api); }); }
private async void but_start_ClickAsync(object sender, EventArgs even) { but_Stop_Click(null, null); var factory = new MqttFactory(); mqttClient = factory.CreateManagedMqttClient(); var mqttClientOptions = new MqttClientOptionsBuilder() .WithClientId(txt_ClientID.Text?.Trim()) .WithTcpServer(txt_Address.Text?.Trim(), int.Parse(txt_Port.Text?.Trim())) .WithCredentials(txt_UserName.Text, txt_Password.Text); if (checkBox1.Checked) { if (!File.Exists(txt_ca_file.Text)) { MessageBox.Show($"没有找到文件:{txt_ca_file.Text}"); return; } if (!File.Exists(txt_pfx_file.Text)) { MessageBox.Show($"没有找到文件:{txt_pfx_file.Text}"); return; } var caCert = X509Certificate.CreateFromCertFile(txt_ca_file.Text); var clientCert = new X509Certificate2(txt_pfx_file.Text); mqttClientOptions = mqttClientOptions.WithTls(new MqttClientOptionsBuilderTlsParameters() { UseTls = true, SslProtocol = System.Security.Authentication.SslProtocols.Tls12, CertificateValidationHandler = (o) => { return(true); }, Certificates = new List <X509Certificate>() { caCert, clientCert } }); } var options = new ManagedMqttClientOptionsBuilder() .WithAutoReconnectDelay(TimeSpan.FromSeconds(5)) .WithClientOptions(mqttClientOptions.Build()) .Build(); await mqttClient.StartAsync(options); mqttClient.UseDisconnectedHandler(e => { WriteLine_1("### 服务器断开连接 ###"); }); mqttClient.UseApplicationMessageReceivedHandler(e => { WriteLine_1("### 收到消息 ###"); WriteLine_1($"+ Topic = {e.ApplicationMessage.Topic}"); try { WriteLine_1($"+ Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}"); } catch { } WriteLine_1($"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}"); WriteLine_1($"+ Retain = {e.ApplicationMessage.Retain}"); WriteLine_1(); }); mqttClient.UseConnectedHandler(e => { WriteLine_1("### 连接到服务 ###"); but_Start.Enabled = false; but_Subscribe.Enabled = true; but_Publish.Enabled = true; but_Stop.Enabled = true; }); }
/// <summary> /// Initialize /// </summary> /// <param name="mqttHost"></param> /// <param name="mqttPort"></param> /// <param name="mqttRootTopic"></param> /// <param name="callbackAddress"></param> /// <param name="callbackPort"></param> /// <param name="bridgeUrl"></param> /// <param name="token"></param> /// <param name="hashToken"></param> /// <param name="infoInterval"></param> private void Initialize(string mqttHost, int?mqttPort, string mqttRootTopic, string callbackAddress, int?callbackPort, string bridgeUrl, string token, bool hashToken, int?infoInterval) { _mqttRootTopic = !string.IsNullOrEmpty(mqttRootTopic) ? mqttRootTopic : "nukibridge"; _mqttHost = !string.IsNullOrEmpty(mqttHost) ? mqttHost : "localhost"; _mqttPort = mqttPort ?? 1883; _bridgeUrl = !string.IsNullOrEmpty(bridgeUrl) ? bridgeUrl : NukiBridgeClient.DiscoverBridge(); _bridgeToken = token; if (string.IsNullOrEmpty(_bridgeUrl) || string.IsNullOrEmpty(_bridgeToken)) { throw new Exception("No Bridge_URL and/or Bridge_Token defined"); } _hashToken = hashToken; // Setup MQTT _mqttClient = new MqttFactory().CreateManagedMqttClient(); _mqttClient.UseApplicationMessageReceivedHandler(e => MqttClientOnApplicationMessageReceived(e)); _mqttClient.UseConnectedHandler(e => { Log.Information("MQTT: Connected"); SubscribeTopic("discover"); SubscribeTopic("reset"); SubscribeTopic("reboot"); SubscribeTopic("fw-upgrade"); }); _mqttClient.UseDisconnectedHandler(e => { if (e.ClientWasConnected) { Log.Warning($"MQTT: Disconnected ({e.Exception?.Message ?? "clean"})"); } else { Log.Error($"MQTT: Unable to connect ({e.Exception?.Message ?? "clean"})"); } }); _nukiBridgeClient = new NukiBridgeClient(_bridgeUrl, _bridgeToken, _hashToken); // Setup callback _callbackAddress = callbackAddress ?? LocalIpAddress().ToString(); _callbackPort = callbackPort ?? 8080; _httpListener = new HttpListener { Prefixes = { $"http://+:{_callbackPort}/" } }; _devices = new List <Device>(); // Prevent info interval being set to 0 if ((infoInterval ?? 0) == 0) { infoInterval = 300; } // Setup info interval _infoTimer = new Timer((infoInterval ?? 300) * 1000); _infoTimer.Elapsed += async(sender, args) => { _infoTimer.Stop(); await PublishBridgeInfo(); _infoTimer.Start(); }; }
public static async Task ConnectAsync() { string clientId = Guid.NewGuid().ToString(); string mqttURI = "127.0.0.1"; string mqttUser = "******"; string mqttPassword = "******"; int mqttPort = 1883; bool mqttSecure = false; var messageBuilder = new MqttClientOptionsBuilder() .WithClientId(clientId) .WithCredentials(mqttUser, mqttPassword) .WithTcpServer(mqttURI, mqttPort) .WithProtocolVersion(MqttProtocolVersion.V500) //.WithTls() .WithCleanSession(); var options = mqttSecure ? messageBuilder.WithTls().Build() : messageBuilder.Build(); var managedOptions = new ManagedMqttClientOptionsBuilder() .WithAutoReconnectDelay(TimeSpan.FromSeconds(5)) .WithClientOptions(options) .Build(); client = new MqttFactory().CreateManagedMqttClient(); await client.StartAsync(managedOptions); client.UseConnectedHandler(e => { Console.WriteLine("Connected successfully with MQTT Brokers."); }); await SubscribeAsync("+/+/+/+"); //await SubscribeAsync("let/me/in/pep"); Console.WriteLine(client.IsStarted + " " + client.IsConnected); client.UseDisconnectedHandler(e => { Console.WriteLine("Disconnected from MQTT Brokers." + e.ClientWasConnected + " " + e?.AuthenticateResult?.ReasonString); }); client.UseApplicationMessageReceivedHandler(e => { try { string topic = e.ApplicationMessage.Topic; if (string.IsNullOrWhiteSpace(topic) == false) { string payload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload); Console.WriteLine($"Topic: {topic}. Message Received: {payload}"); } } catch (Exception ex) { Console.WriteLine(ex.Message, ex); } }); }
/// <summary> /// Create a rx mqtt client based on a <see cref="IManagedMqttClient"/>. /// </summary> /// <param name="managedMqttClient">The manged mqtt client.</param> /// <param name="logger">The mqtt net logger.</param> /// <remarks> /// Use the <see cref="MqttFactoryExtensions.CreateRxMqttClient(IMqttFactory)"/> or /// <see cref="MqttFactoryExtensions.CreateRxMqttClient(IMqttFactory, IMqttNetLogger)"/> /// factory methods to crate the client. /// </remarks> /// <exception cref="ArgumentNullException"></exception> public RxMqttClient(IManagedMqttClient managedMqttClient, IMqttNetLogger logger) { InternalClient = managedMqttClient ?? throw new ArgumentNullException(nameof(managedMqttClient)); if (logger == null) { throw new ArgumentNullException(nameof(logger)); } this.logger = logger.WithSource(nameof(RxMqttClient)); topicSubscriptionCache = new Dictionary <string, IObservable <MqttApplicationMessageReceivedEventArgs> >(); var cancelationSubject = new Subject <Unit>(); ConnectedEvent = CrateFromHandler <MqttClientConnectedEventArgs>(observer => { managedMqttClient.UseConnectedHandler(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ConnectedHandler = null)); }); DisconnectedEvent = CrateFromHandler <MqttClientDisconnectedEventArgs>(observer => { managedMqttClient.UseDisconnectedHandler(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.DisconnectedHandler = null)); }); ConnectingFailedEvent = CrateFromHandler <ManagedProcessFailedEventArgs>(observer => { managedMqttClient.ConnectingFailedHandler = new ConnectingFailedHandlerDelegate(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ConnectingFailedHandler = null)); }); SynchronizingSubscriptionsFailedEvent = CrateFromHandler <ManagedProcessFailedEventArgs>(observer => { managedMqttClient.SynchronizingSubscriptionsFailedHandler = new SynchronizingSubscriptionsFailedHandlerDelegate(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.SynchronizingSubscriptionsFailedHandler = null)); }); ApplicationMessageProcessedEvent = CrateFromHandler <ApplicationMessageProcessedEventArgs>(observer => { managedMqttClient.ApplicationMessageProcessedHandler = new ApplicationMessageProcessedHandlerDelegate(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ApplicationMessageReceivedHandler = null)); }); ApplicationMessageSkippedEvent = CrateFromHandler <ApplicationMessageSkippedEventArgs>(observer => { managedMqttClient.ApplicationMessageSkippedHandler = new ApplicationMessageSkippedHandlerDelegate(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ApplicationMessageReceivedHandler = null)); }); Connected = Observable .Create <bool>(observer => { var connected = ConnectedEvent.Subscribe(_ => observer.OnNext(true)); var disconnected = DisconnectedEvent.Subscribe(_ => observer.OnNext(false)); return(new CompositeDisposable(connected, disconnected)); }) .TakeUntil(cancelationSubject) // complete on dispose .Prepend(IsConnected) // start with current state .Append(false) // finish with false .Replay(1) // replay last state on subscribe .RefCount(); // count subscriptions and dispose source observable when no subscription applicationMessageReceived = CrateFromHandler <MqttApplicationMessageReceivedEventArgs>(observer => { managedMqttClient.UseApplicationMessageReceivedHandler(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ApplicationMessageReceivedHandler = null)); }); IObservable <T> CrateFromHandler <T>(Func <IObserver <T>, IDisposable> func) { return(Observable.Create(func) .TakeUntil(cancelationSubject) // complete on dispose .Publish() // publish from on source observable .RefCount()); // count subscriptions and dispose source observable when no subscription } cleanUp = Disposable.Create(() => { cancelationSubject.OnNext(Unit.Default); // complete all observers cancelationSubject.Dispose(); try { managedMqttClient.Dispose(); } catch { } }); }
private static async Task ConnectAsync() { const string mqttUri = "localhost"; var mqttUser = "******"; var mqttPassword = "******"; var mqttPort = 1883; Console.WriteLine($"MQTT Server:{mqttUri} Username:{mqttUser} ClientID:{leadvehicle}"); var messageBuilder = new MqttClientOptionsBuilder() .WithClientId(leadvehicle) .WithCredentials(mqttUser, mqttPassword) .WithTcpServer(mqttUri, mqttPort) .WithKeepAlivePeriod(new TimeSpan(0, 0, 30)) .WithCleanSession(); var options = messageBuilder .Build(); var managedOptions = new ManagedMqttClientOptionsBuilder() .WithAutoReconnectDelay(TimeSpan.FromSeconds(5)) .WithClientOptions(options) .Build(); await client.StartAsync(managedOptions); client.UseConnectedHandler(e => { Console.WriteLine("Connected successfully with MQTT Brokers."); }); client.UseApplicationMessageReceivedHandler(e => { Console.WriteLine("Connected UseApplicationMessageReceivedHandler with MQTT Brokers." + e.ApplicationMessage); }); client.UseDisconnectedHandler(e => { new MqttClientDisconnectedHandlerDelegate(e => MqttClient_Disconnected(e)); Console.WriteLine("Disconnected from MQTT Brokers.Client Was Connected " + e.ClientWasConnected); }); client.UseApplicationMessageReceivedHandler(e => { try { var topic = e.ApplicationMessage.Topic; if (!string.IsNullOrWhiteSpace(topic)) { var stringpayload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload); var bitArray = new BitArray(e.ApplicationMessage.Payload); var payload = HelperFunctions.GetPayload(e.ApplicationMessage.Payload); var py = HelperFunctions.ToBitString(new BitArray(e.ApplicationMessage.Payload), 0, 61); Console.WriteLine($"Topic: {topic}. Message Received: {py}"); var followingVehicle = topic.Replace("platooning/" + leadvehicle + "/", ""); if (payload.Maneuver == 1 && !string.IsNullOrWhiteSpace(followingVehicle)) { payload.Maneuver = 2; var message = new BitArray(61); message.Set(0, false); message.Set(1, true); message.Set(2, false); _ = PublishAsync("platooning/" + followingVehicle + "/" + leadvehicle + "/" + platoonId, Encoding.ASCII.GetString(HelperFunctions.BitArrayToByteArray(message))); } } } catch (Exception ex) { Console.WriteLine(ex.Message, ex); } }); }
internal MqttClientMeasure(Rainmeter.API api) { ParentMeasures.Add(this); ParentRainmeterApis.Add(api); this.Rainmeter = api; this.Name = api.GetMeasureName(); Skin = api.GetSkin(); DebugLevel = (ushort)api.ReadInt("DebugLevel", 0); Server = api.ReadString("Server", "localhost"); Port = (ushort)api.ReadInt("Port", 1883); RetryInterval = (ushort)api.ReadDouble("RetryInterval", 5.0); ClientId = api.ReadString("ClientId", Guid.NewGuid().ToString()); Username = api.ReadString("Username", ""); Password = new SecureString(); foreach (char ch in api.ReadString("Password", "")) { Password.AppendChar(ch); } /* Mqtt Server Bangs */ OnConnectBangs = SplitBangs(api.ReadString("OnConnect", "")); OnDisconnectBangs = SplitBangs(api.ReadString("OnConnect", "")); OnReloadBangs = SplitBangs(api.ReadString("OnReload", "")); OnMessageBangs = SplitBangs(api.ReadString("OnMessage", "")); MqttClient = Factory.CreateManagedMqttClient(); /* Setup Event Handlers */ MqttClient.UseConnectedHandler(e => { if (!MqttClientMeasure.ParentRainmeterApis.Contains(Rainmeter)) { return; } Log(API.LogType.Notice, "Connected to " + Server + " : " + Port); if (OnConnectBangs.Length > 0) { Log(API.LogType.Notice, "Executing OnConnect Bangs"); ExecuteBangs(OnConnectBangs); } }); MqttClient.UseApplicationMessageReceivedHandler(e => { if (!MqttClientMeasure.ParentRainmeterApis.Contains(Rainmeter)) { return; } e.GetType(); String topic = e.ApplicationMessage.Topic; String payload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload); try { Debug("### RECEIVED APPLICATION MESSAGE ###", 3); Debug($" >> Topic = {e.ApplicationMessage.Topic}", 4); Debug($" >> Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}", 4); Debug($" >> QoS = {e.ApplicationMessage.QualityOfServiceLevel}", 5); Debug($" >> Retain = {e.ApplicationMessage.Retain}", 5); if (Topics.Contains(topic)) { Topics[topic] = payload; Log(API.LogType.Notice, "Received update for " + topic); } else { Topics.Add(topic, payload); Log(API.LogType.Warning, "Received payload for unknown topic " + topic); } if (OnMessageBangs.Length > 0) { Log(API.LogType.Notice, "Executing OnMessage Bangs"); ExecuteBangs(OnMessageBangs); } } catch { // Error Application } }); MqttClient.UseDisconnectedHandler(e => { if (!MqttClientMeasure.ParentRainmeterApis.Contains(Rainmeter)) { return; } Log(API.LogType.Error, e.Exception?.Message); Log(API.LogType.Error, e.AuthenticateResult?.ReasonString); Log(API.LogType.Error, e.ClientWasConnected.ToString()); if (!MqttClient.IsConnected) { Log(API.LogType.Warning, "Lost previous connection to " + Server + " : " + Port); } if (OnDisconnectBangs.Length > 0) { Log(API.LogType.Notice, "Executing OnDisconnect Bangs"); ExecuteBangs(OnDisconnectBangs); } }); try { Log(API.LogType.Warning, "Connecting to " + Server + " : " + Port + "..."); ConnectAsync(Server, Port, Username, Password, ClientId).Wait(); } catch (Exception ex) { Log(API.LogType.Error, "Exception trying to connect: " + ex); return; } }
private static async Task ConnectAsync() { //const string mqttUri = "mqttbroker.westeurope.azurecontainer.io"; string mqttUri = configuration["mqttServerIp"]; var mqttUser = configuration["mqttUser"];; var mqttPassword = configuration["mqttPassword"];; var mqttPort = Convert.ToInt32(configuration["mqttPort"]); Console.WriteLine($"MQTT Server:{mqttUri} Username:{mqttUser} ClientID:{leadvehicle}"); var messageBuilder = new MqttClientOptionsBuilder() .WithClientId(leadvehicle) .WithCredentials(mqttUser, mqttPassword) .WithTcpServer(mqttUri, mqttPort) .WithKeepAlivePeriod(new TimeSpan(0, 0, 30)) .WithCleanSession(); var options = messageBuilder .Build(); var managedOptions = new ManagedMqttClientOptionsBuilder() .WithAutoReconnectDelay(TimeSpan.FromSeconds(2)) .WithClientOptions(options) .Build(); await client.StartAsync(managedOptions); client.UseConnectedHandler(e => { Console.WriteLine("Connected successfully with MQTT Brokers."); }); client.UseApplicationMessageReceivedHandler(e => { Console.WriteLine("Connected UseApplicationMessageReceivedHandler with MQTT Brokers." + e.ApplicationMessage); }); client.UseDisconnectedHandler(e => { new MqttClientDisconnectedHandlerDelegate(e => MqttClient_Disconnected(e)); Console.WriteLine("Disconnected from MQTT Brokers.Client Was Connected " + e.ClientWasConnected); }); client.UseApplicationMessageReceivedHandler(e => { try { var topic = e.ApplicationMessage.Topic; if (!string.IsNullOrWhiteSpace(topic)) { var stringpayload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload); var bitArray = new BitArray(e.ApplicationMessage.Payload); var payload = HelperFunctions.GetPayload(e.ApplicationMessage.Payload); var py = HelperFunctions.ToBitString(new BitArray(e.ApplicationMessage.Payload), 0, bitcount); Console.WriteLine($"Topic: {topic}. Message Received: {py}"); var followingVehicle = topic.Split('/'); var key = ConsoleKey.A; if (key == ConsoleKey.A) { if (payload.Maneuver == 1 && !string.IsNullOrWhiteSpace(followingVehicle[2])) { payload.Maneuver = 2; var message = new BitArray(bitcount); message.Set(0, false); message.Set(1, true); message.Set(2, false); var pubtopic = "platooning/" + followingVehicle[2] + "/" + leadvehicle + "/" + platoonId; _ = PublishAsync( pubtopic, Encoding.ASCII.GetString(HelperFunctions.BitArrayToByteArray(message))); Console.WriteLine($"Publish Topic: {pubtopic}. Message Received: {Encoding.ASCII.GetString(HelperFunctions.BitArrayToByteArray(message))}"); } } else if (key == ConsoleKey.R) { if (payload.Maneuver == 1 && !string.IsNullOrWhiteSpace(followingVehicle[2])) { payload.Maneuver = 3; var message = new BitArray(bitcount); message.Set(0, false); message.Set(1, true); message.Set(2, true); _ = PublishAsync( "platooning/" + followingVehicle[2] + "/" + leadvehicle + "/" + platoonId, Encoding.ASCII.GetString(HelperFunctions.BitArrayToByteArray(message))); } } } } catch (Exception ex) { Console.WriteLine(ex.Message, ex); } }); }