public async Task Subscribe(string subtopic)
{
var topicFilters = new MqttTopicFilterBuilder()
.WithTopic(GetTopic(subtopic))
.Build();
await client.SubscribeAsync(topicFilters);
}
public override async Task StartAsync(CancellationToken cancellationToken)
{
await ConnectClient(cancellationToken);
_logger.LogInformation($"MQTT Create Client (User:'******', Topic:'{_brokerConfig.Topic}')");
var topicFilter = new MqttTopicFilterBuilder()
.WithTopic(_brokerConfig.Topic)
.WithAtLeastOnceQoS()
.Build();
var subscritionChannel = await this.mqttClient.SubscribeAsync(topicFilter);
// Hier werden die Antworten zu dem Treiber per 'Publish' verschickt
var subscriptionStatement = this.observableStatement.Subscribe(
async statement =>
await Publish(
client: mqttClient,
topic: statement.Topic,
jobId: statement.JobId,
payload: statement.Message,
qos: MqttQualityOfServiceLevel.AtLeastOnce,
cancellationToken: cancellationToken
)
);
// Hier kommen die Messages vom Treiber an und werden an 'HandleMessage' geroutet
this._disposables = new CompositeDisposable(
new[] { subscriptionStatement });
await base.StartAsync(cancellationToken);
}
/// <summary>
/// client 成功连接到 server
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
private async Task Connected(MqttClientConnectedEventArgs e)
{
try
{
List <MqttTopicFilter> listTopic = new List <MqttTopicFilter>();
if (listTopic.Count() <= 0)
{
foreach (string topic in topicsSubs)
{
var topicFilterBulder = new MqttTopicFilterBuilder().WithTopic(topic).Build();
listTopic.Add(topicFilterBulder);
Console.WriteLine("Connected >>Subscribe " + topic);
}
}
// 订阅主题
await mqttClient.SubscribeAsync(listTopic.ToArray());
Console.WriteLine("Connected >>Subscribe Success");
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
ClientConnectedEvent?.Invoke();
}
public static async Task SubscribeMQTT(List <string> topicList)
{
foreach (string topic in topicList)
{
if (topic != "")
{
var topicFilter = new MqttTopicFilterBuilder()
.WithAtLeastOnceQoS()
.WithTopic(topic)
.Build();
await mqttClient.SubscribeAsync(topicFilter);
}
}
mqttClient.UseApplicationMessageReceivedHandler(e =>
{
MqttMessageEventArgs messageReceivedEventArgs = new()
{
Topic = e.ApplicationMessage.Topic,
Message = System.Text.Encoding.Default.GetString(e.ApplicationMessage.Payload),
};
MqttMessageReceived?.Invoke(null, messageReceivedEventArgs);
Debug.WriteLine("Received Message int topic: " + e.ApplicationMessage.Topic + " : " + System.Text.Encoding.Default.GetString(e.ApplicationMessage.Payload));
});
return;
}
protected override async Task OnInitializedAsync()
{
this.mqttClientOptions = new MqttClientOptionsBuilder()
.WithClientId("ClientId")
.WithTcpServer("mybroker.com", 8883)
.WithCredentials("Username", "Password")
.WithTls(new MqttClientOptionsBuilderTlsParameters
{
UseTls = true,
SslProtocol = SslProtocols.Tls12
})
.WithCleanSession()
.Build();
var factory = new MqttFactory();
this.mqttClient = factory.CreateMqttClient();
await this.mqttClient.ConnectAsync(this.mqttClientOptions);
this.mqttClient.UseApplicationMessageReceivedHandler(e =>
{
this.LastData = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
});
var topic = new MqttTopicFilterBuilder().WithTopic("my/topic").Build();
await this.mqttClient.SubscribeAsync(topic);
}
public MqttClientSubscribeOptionsBuilder WithTopicFilter(MqttTopicFilterBuilder topicFilterBuilder)
{
if (topicFilterBuilder == null)
{
throw new ArgumentNullException(nameof(topicFilterBuilder));
}
return(WithTopicFilter(topicFilterBuilder.Build()));
}
public static async Task SubscribeAsync(string topic, int qos = 1)
{
var topicFilter = new MqttTopicFilterBuilder()
.WithQualityOfServiceLevel((MQTTnet.Protocol.MqttQualityOfServiceLevel)qos)
.WithTopic(topic)
.Build();
await _client.SubscribeAsync(topicFilter);
}
public async Task Subscribe(string topic, int qos = 0)
{
var subscribe = new MqttTopicFilterBuilder().WithTopic(topic);
subscribe.WithAtMostOnceQoS();
var topicfilter = subscribe.Build();
dicSubscribe.AddOrUpdate(topic, topicfilter, (k, v) => topicfilter);
await mqttClient.SubscribeAsync(topicfilter);
}
private static MqttTopicFilterBuilder GetTopicBuilder(string[] topics)
{
var topicBuilder = new MqttTopicFilterBuilder();
topics.ToList().ForEach(topic =>
{
topicBuilder.WithTopic(topic);
});
return(topicBuilder);
}
private async Task HandleConnected(MqttClientConnectedEventArgs e)
{
Logger.Info($"Connection to MQTT server (source) {Options.Server} established");
Logger.Info($"Attempting to subscribe to {Options.Topics.Result}");
MqttTopicFilter topicFilter = new MqttTopicFilterBuilder().WithTopic(Options.Topics.Result).Build();
await MqttClient.SubscribeAsync(topicFilter);
Logger.Info($"Succesfully subscribed to {Options.Topics.Result}");
}
public MqttClientService(IMqttClient mqttClient, IMqttClientOptions options, string[] topics)
{
_mqttClient = mqttClient;
_options = options;
MqttTopicFilterBuilder topicFilterBuilder = new MqttTopicFilterBuilder();
for (int i = 0; i < topics.Length; i++)
{
topicFilterBuilder.WithTopic(topics[i]);
}
_topicFilter = topicFilterBuilder.Build();
}
public MqttClientSubscribeOptionsBuilder WithTopicFilter(Action <MqttTopicFilterBuilder> topicFilterBuilder)
{
if (topicFilterBuilder == null)
{
throw new ArgumentNullException(nameof(topicFilterBuilder));
}
var internalTopicFilterBuilder = new MqttTopicFilterBuilder();
topicFilterBuilder(internalTopicFilterBuilder);
return(WithTopicFilter(internalTopicFilterBuilder));
}
private async Task SubscribeAsync(string topic)
{
var tfb = new MqttTopicFilterBuilder()
.WithTopic(topic)
.WithAtMostOnceQoS();
var build = tfb.Build();
var opts = new MqttClientSubscribeOptionsBuilder()
.WithTopicFilter(build);
await this.Client.SubscribeAsync(opts.Build(), CancellationToken.None);
this._logger.LogInformation($"Subscribed to: {topic}");
}
/// <summary>
/// connect event handler
/// </summary>
/// <param name="e"></param>
private void ConnectHandler(MqttClientConnectedEventArgs e)
{
if (MqttClientConnectResultCode.Success == e.AuthenticateResult.ResultCode)
{
ActiveMQ_MQTT_Settings.Trace(m_strConsumerClientID + " Connect ActiveMQ success.");
MqttTopicFilter mqttTopicFilter = new MqttTopicFilterBuilder()
.WithTopic(ActiveMQ_MQTT_Settings.s_strTopic)
.WithExactlyOnceQoS()
.Build();
m_mqttConsumer.SubscribeAsync(mqttTopicFilter);
}
else
{
ActiveMQ_MQTT_Settings.Trace(m_strConsumerClientID + "Connect ActiveMQ failed, error code: " + e.AuthenticateResult.ResultCode.ToString());
Reconnect();
}
}
private async Task ManagedClient_Connected(MqttClientConnectedEventArgs e)
{
List <MqttTopicFilter> filters = new List <MqttTopicFilter>();
foreach (string topic in Topics)
{
MqttTopicFilter filter = new MqttTopicFilterBuilder().WithQualityOfServiceLevel((MQTTnet.Protocol.MqttQualityOfServiceLevel)QoS).WithTopic(topic).Build();
filters.Add(filter);
}
await mqtt_client.SubscribeAsync(filters.ToArray());
if (ClientConnected != null)
{
await ClientConnected.Invoke();
}
await OnConnected();
}
/// <summary>
/// 订阅自定义topic。系统topic由SDK自动订阅，此接口只能用于订阅自定义topic
/// </summary>
/// <param name="topic">自定义Topic</param>
public void SubscribeTopic(string topic)
{
try
{
List <MqttTopicFilter> listTopic = new List <MqttTopicFilter>();
var topicFilterBulderPreTopic = new MqttTopicFilterBuilder().WithTopic(string.Format(CommonTopic.PRE_TOPIC, deviceId) + topic).Build();
listTopic.Add(topicFilterBulderPreTopic);
connection.SubscribeTopic(listTopic);
//// rawMessageListenerDic.Add(topic, rawMessageListener);
}
catch (Exception ex)
{
Log.Error("SDK.Error: Subscribe topic fail, the topic is " + topic);
}
}
/// <summary>
/// 和平台建立连接，此接口为阻塞调用，超时时长20s。连接成功时，SDK会自动向平台订阅系统定义的topic。
/// </summary>
/// <returns>0表示连接成功，其他表示连接失败</returns>
public int Connect()
{
int ret = connection.Connect();
if (ret != 0)
{
return(ret);
}
List <MqttTopicFilter> listTopic = new List <MqttTopicFilter>();
var topicFilterBulderMsgDown = new MqttTopicFilterBuilder().WithTopic(string.Format(CommonTopic.TOPIC_SYS_MESSAGES_DOWN, deviceId)).Build();
listTopic.Add(topicFilterBulderMsgDown);
var topicFilterBulderCommand = new MqttTopicFilterBuilder().WithTopic(string.Format(CommonTopic.TOPIC_SYS_COMMAND, deviceId)).Build();
listTopic.Add(topicFilterBulderCommand);
var topicFilterBulderShadowGetResponse = new MqttTopicFilterBuilder().WithTopic(string.Format(CommonTopic.TOPIC_SYS_SHADOW_GET_RESPONSE, deviceId)).Build();
listTopic.Add(topicFilterBulderShadowGetResponse);
var topicFilterBulderPropertiesSet = new MqttTopicFilterBuilder().WithTopic(string.Format(CommonTopic.TOPIC_SYS_PROPERTIES_SET, deviceId)).Build();
listTopic.Add(topicFilterBulderPropertiesSet);
var topicFilterBulderPropertiesGet = new MqttTopicFilterBuilder().WithTopic(string.Format(CommonTopic.TOPIC_SYS_PROPERTIES_GET, deviceId)).Build();
listTopic.Add(topicFilterBulderPropertiesGet);
var topicFilterBulderEventsDown = new MqttTopicFilterBuilder().WithTopic(string.Format(CommonTopic.TOPIC_SYS_EVENTS_DOWN, deviceId)).Build();
listTopic.Add(topicFilterBulderEventsDown);
connection.SubscribeTopic(listTopic);
return(ret);
}
static async Task Main(string[] args)
{
var configRoot = new ConfigurationBuilder()
.AddJsonFile("config.json")
.Build();
var config = configRoot.Get <Configuration>();
var mqttConfig = config.Mqtt;
var devices = config.Devices.Select(x => new UnifiDevice {
Config = x, Name = x.Name ?? x.Host, Effect = "white", State = false
}).ToList();
_devices = devices;
var options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(new MqttClientOptionsBuilder()
.WithTcpServer(mqttConfig.Host)
.WithCredentials(mqttConfig.Username, mqttConfig.Password)
.WithWillMessage(new MqttApplicationMessage {
Topic = "homeassistantunifiled/bridge/state", Payload = Encoding.UTF8.GetBytes("offline")
})
.Build())
.Build();
var mqttClient = new MqttFactory().CreateManagedMqttClient();
var filterBuilder = new MqttTopicFilterBuilder();
foreach (var device in devices)
{
var deviceConfig = device.Config;
device.SshClient = new SshClient(deviceConfig.Host, deviceConfig.Port, deviceConfig.Username, deviceConfig.Password);
device.SshClient.Connect();
Console.WriteLine($"Connected to {deviceConfig.Host}");
await mqttClient.SubscribeAsync($"homeassistant/light/{device.Name}/set");
await mqttClient.SubscribeAsync($"homeassistant/light/{device.Name}/effect");
}
mqttClient.UseApplicationMessageReceivedHandler(MessageReceived);
await mqttClient.StartAsync(options);
await mqttClient.PublishAsync($"homeassistantunifiled/bridge/state", "online", MqttQualityOfServiceLevel.ExactlyOnce, true);
foreach (var device in devices)
{
var lightConfig = new HomeAssistantDiscovery()
{
UniqueId = device.Name,
Name = device.Name,
Device = new HomeAssistantDevice
{
Name = device.Name,
Identifiers = new List <string>
{
device.Name,
device.Config.Host
}
},
TopicBase = $"homeassistant/light/{device.Name}",
CommandTopic = "~/set",
EffectList = new List <string>
{
"white",
"blue"
},
EffectTopic = "~/effect",
AvailabilityTopic = "homeassistantunifiled/bridge/state",
Retain = true
};
var configJson = JsonConvert.SerializeObject(lightConfig);
await mqttClient.PublishAsync($"homeassistant/light/{device.Name}/config", configJson, MqttQualityOfServiceLevel.ExactlyOnce, true);
}
int i = 0;
while (true)
{
foreach (var device in _devices)
{
var client = device.SshClient;
if (!client.IsConnected)
{
client.Connect();
Console.WriteLine($"Connected to {client.ConnectionInfo.Host}");
}
if (i % 6 == 0)
{
SetDeviceState(device);
}
}
Thread.Sleep(10000);
i++;
}
}
static void Main(string[] args)
{
DotNetEnv.Env.Load();
String ttnServer = System.Environment.GetEnvironmentVariable("ttnServer");
String ttnSClientId = System.Environment.GetEnvironmentVariable("ttnSClientId");
String ttnAppId = System.Environment.GetEnvironmentVariable("ttnAppId");
String ttnAppPassword = System.Environment.GetEnvironmentVariable("ttnAppPassword");
String azureFunctionUrl = System.Environment.GetEnvironmentVariable("azureFunctionUrl");
String azureFunctionPath = System.Environment.GetEnvironmentVariable("azureFunctionPath");
String adtModelId = System.Environment.GetEnvironmentVariable("adtModelId");
Console.WriteLine("test" + ttnSClientId);
var options = new MqttClientOptionsBuilder()
.WithClientId(ttnSClientId)
.WithTcpServer(ttnServer, 8883)
.WithCredentials(ttnAppId, ttnAppPassword)
.WithTls()
.WithCleanSession()
.Build();
var mqttClient = factory.CreateMqttClient();
Console.WriteLine("Attempting Connection");
mqttClient.ConnectAsync(options, CancellationToken.None);
mqttClient.UseConnectedHandler(async e =>
{
Console.WriteLine("### CONNECTED WITH SERVER ###");
var topic = new MqttTopicFilterBuilder().WithTopic($"{ttnAppId}/devices/+/up").Build();
Console.WriteLine(topic.ToString());
// Subscribe to a topic
await mqttClient.SubscribeAsync(topic);
Console.WriteLine("### SUBSCRIBED ###");
});
mqttClient.UseApplicationMessageReceivedHandler(async e =>
{
if (debug)
{
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();
}
dynamic json = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(e.ApplicationMessage.Payload));
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(azureFunctionUrl);
var measurements = new
{
temperature = 25.6,
pressure = 75,
humidity = 13.5
};
var content = JObject.FromObject(new
{
hardware_serial = json.dev_id,
payload_fields = measurements,
modelId = adtModelId
});
var response = await client.PostAsync(azureFunctionPath,
new StringContent(JsonConvert.SerializeObject(content),
Encoding.UTF8, "application/json"));
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
}
});
Console.ReadKey();
}
