// メッセージを送信する。
func Publish(client *MQTT.Client, topic string, qos byte, retain bool, message string) {
token := client.Publish(topic, qos, retain, message)
if token.Wait() && token.Error() != nil {
fmt.Printf("Publish error: %s\n", token.Error())
}
}
func loop(reader io.Reader, client *MQTT.Client) {
channel := make(chan data.SensorData)
scanner := bufio.NewScanner(reader)
go func() {
for scanner.Scan() {
line := strings.SplitN(scanner.Text(), ":", 2)
if nil == sensors.Sensors[line[0]] {
jww.DEBUG.Println(scanner.Text())
} else {
d := sensors.Sensors[line[0]].Parse(line[0], line[1])
channel <- d
}
}
close(channel)
}()
for data := range channel {
topic := "/gowx/sample"
buf := new(bytes.Buffer)
encoder := json.NewEncoder(buf)
encoder.Encode(data)
payload := buf.Bytes()
if token := client.Publish(topic, 0, false, payload); token.Wait() && token.Error() != nil {
jww.ERROR.Println("Failed to send message.", token.Error())
}
jww.DEBUG.Printf("Publishing %s -> %s\n", topic, buf.Bytes())
}
}
func (d *Device) reportEvent(client *MQTT.Client) {
for {
time.Sleep(3 * time.Second)
event := protocol.Event{}
params, err := tlv.MakeTLVs([]interface{}{"hello event."})
if err != nil {
fmt.Println(err)
return
}
event.Params = params
event.Head.No = 1
event.Head.SubDeviceid = 1
event.Head.ParamsCount = uint16(len(params))
payload, err := event.Marshal()
if err != nil {
fmt.Println(err)
return
}
client.Publish("e", 1, false, payload)
}
}
func setupSubscriptions(client *mqtt.Client, wg *sync.WaitGroup) {
if topicFiltersString != "" {
wg.Add(numberMessagesExpected)
topicFilters := strings.Split(topicFiltersString, ",")
for _, filter := range topicFilters {
client.Subscribe(filter, qos, func(client *mqtt.Client, msg mqtt.Message) {
if !msg.Retained() || !ignoreRetained {
payload := bytes.NewBuffer(msg.Payload()).String()
if ignorePayload {
fmt.Printf("r:%v, t:%v, s:%v\n", msg.Retained(), msg.Topic(), len(payload))
} else {
infoF("r:%v, t:%v, s:%v", msg.Retained(), msg.Topic(), len(payload))
fmt.Printf("%v\n", payload)
}
wg.Done()
} else {
info("ignoring retained msg")
}
})
}
infoF("waiting for %v msgs.", numberMessagesExpected)
} else {
info("No subscriptions...")
}
}
func (m *MQTTClient) SubscribeOnConnect(client *MQTT.Client) {
log.Infof("client connected")
if len(m.Subscribed) > 0 {
token := client.SubscribeMultiple(m.Subscribed, m.onMessageReceived)
token.Wait()
if token.Error() != nil {
log.Error(token.Error())
}
}
}
func publishMessage(client *mqtt.Client) {
if pubTopic != "" {
token := client.Publish(pubTopic, qos, false, pubMessage)
token.WaitTimeout(10 * time.Second)
if token.Error() != nil {
infoF("FATAL: Could not publish: %v", token.Error())
os.Exit(-1)
}
} else {
info("nothing to publish")
}
}
func (b *Broker) SubscribeOnConnect(client *MQTT.Client) {
log.Infof("client connected")
b.connected = true
if b.Subscribed.Length() > 0 {
// subscribe
token := client.SubscribeMultiple(b.Subscribed.List(), b.onMessageReceived)
token.Wait()
if token.Error() != nil {
log.Error(token.Error())
}
}
}
// メッセージを受信する。
func Subscribe(client *MQTT.Client, topic string, qos byte) *SubscribeResult {
var result *SubscribeResult = &SubscribeResult{}
result.Count = 0
var handler MQTT.MessageHandler = func(client *MQTT.Client, msg MQTT.Message) {
result.Count++
if Debug {
fmt.Printf("Received message : topic=%s, message=%s\n", msg.Topic(), msg.Payload())
}
}
token := client.Subscribe(topic, qos, handler)
if token.Wait() && token.Error() != nil {
fmt.Printf("Subscribe error: %s\n", token.Error())
}
return result
}
func SendData(client *MQTT.Client, endChan chan struct{}) {
ticker := time.NewTicker(1 * time.Second)
for {
select {
case <-endChan:
return
case <-ticker.C:
var p Payload
p.DataPoints.Load1, p.DataPoints.Load5, p.DataPoints.Load15 = getLoadAvg()
p.DataPoints.CPUTemp = getCPUTemp(host.CPUTempFile())
p.Timestamp = time.Now()
payloadBytes, err := json.Marshal(p)
if err == nil {
client.Publish(config.PubTopic, 0, false, payloadBytes)
} else {
fmt.Println(err.Error())
}
}
}
}
func (d *Device) reportStatus(client *MQTT.Client) {
payloadHead := protocol.DataHead{
Flag: 0,
Timestamp: uint64(time.Now().Unix() * 1000),
}
param := []interface{}{uint8(1)}
params, err := tlv.MakeTLVs(param)
if err != nil {
fmt.Println(err)
return
}
sub := protocol.SubData{
Head: protocol.SubDataHead{
SubDeviceid: uint16(1),
PropertyNum: uint16(1),
ParamsCount: uint16(len(params)),
},
Params: params,
}
status := protocol.Data{
Head: payloadHead,
SubData: []protocol.SubData{},
}
status.SubData = append(status.SubData, sub)
payload, err := status.Marshal()
if err != nil {
fmt.Println(err)
return
}
client.Publish("s", 1, false, payload)
}
// Brokerとの接続を切断する。
func Disconnect(client *MQTT.Client) {
client.Disconnect(10)
}
func makeHandler(c *MQTT.Client, cmd string) func(event lirc.Event) {
return func(event lirc.Event) {
c.Publish("/lights/set", 0, false, cmd)
}
}
// Brokerとの接続を切断する。
func Disconnect(client *MQTT.Client) {
client.ForceDisconnect()
}
