Problem with terminal error


(dicarva) #1

I’m trying another way to send to node-red. In fact, I’m trying to send the values of payload with this

// Publish a message.
err = cli.Publish(&client.PublishOptions{
	QoS:       mqtt.QoS0,
	TopicName: []byte("hello"),
	Message:   []byte("hi"),
})
if err != nil {
	panic(err)
}

But my problem right now is that I can’t convert the payload value to put in the Message.

Also I can’t do this because with the go program https://github.com/dcarva/ubw_go_script_package/blob/master/gateway.go I can’t add this information [https://github.com/yosssi/gmq] do publish the temperature in my topic.

It returns this error:

./gateway.go:240:29: type client.ConnectOptions is not an expression

and this my code:

`package main

import (
	"os"

	"github.com/spf13/cobra"
	
	"fmt"
        "math/rand"
        "time"

        "github.com/brocaar/lorawan"

        MQTT "github.com/eclipse/paho.mqtt.golang"
        lds "github.com/iegomez/loraserver-device-sim"
	
		"os/signal"

	"github.com/yosssi/gmq/mqtt"
	"github.com/yosssi/gmq/mqtt/client"
)

const (
	ipFlag = "ip"
	portFlag="port"

)

func main() {
	cmd := &cobra.Command{
		Use:          "ui",
		Short:        "Bem-vindo",
		SilenceUsage: true,
	}

	cmd.AddCommand(mainCmd())
	cmd.AddCommand(jardimCmd())

	if err := cmd.Execute(); err != nil {
		os.Exit(1)
	}
}

func mainCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use: "sensor",
		RunE: func(cmd *cobra.Command, args []string) error {
			ip, err := cmd.Flags().GetString(ipFlag)
			
			port, err2 := cmd.Flags().GetString(portFlag)
			
			if err != nil || err2 != nil {
				return err
				return err2
			}

			/*cmd.Println("A porta:", port)
			
			cmd.Println("O IP da gateway:", ip)*/

			var end_ip string
			end_ip=ip+":"+port
			
			var end string
			end="tcp://"+end_ip
			
			cmd.Println(end)
			


	//Connect to the broker
	/*opts := MQTT.NewClientOptions()
	opts.AddBroker(end)
	opts.SetUsername("your-username")
	opts.SetPassword("your-password")
	*/

	/* Create an MQTT Client.
	cli := client.New(&client.Options{
	ErrorHandler: func(err error) {
		fmt.Println(err)
		},
	})  */
			
			
		// Set up channel on which to send signal notifications.
	sigc := make(chan os.Signal, 1)
	signal.Notify(sigc, os.Interrupt, os.Kill)

	// Create an MQTT Client.
	cli := client.New(&client.Options{
		// Define the processing of the error handler.
		ErrorHandler: func(err error) {
			fmt.Println(err)
		},
	})

	// Terminate the Client.
	defer cli.Terminate()

	// Connect to the MQTT Server.
	err = cli.Connect(&client.ConnectOptions{
		Network:  "tcp",
		Address:  "127.0.0.1:1883",
		ClientID: []byte("example-client"),
	})
	if err != nil {
		panic(err)
	}

	// Subscribe to topics.
	err = cli.Subscribe(&client.SubscribeOptions{
		SubReqs: []*client.SubReq{
			&client.SubReq{
				TopicFilter: []byte("hello"),
				QoS:         mqtt.QoS0,
				// Define the processing of the message handler.
				Handler: func(topicName, message []byte) {
					fmt.Println(string(topicName), string(message))
				},
			},
		},
	})
	if err != nil {
		panic(err)
	}

	// Publish a message.
	err = cli.Publish(&client.PublishOptions{
		QoS:       mqtt.QoS0,
		TopicName: []byte("hello"),
		Message:   []byte("temp"),
	})
	if err != nil {
		panic(err)
	}
			
			

///******************************//////////////////////
	/*if token := client.Connect(); token.Wait() && token.Error() != nil {
		fmt.Println("Connection error")
		fmt.Println(token.Error())
	} */

	fmt.Println("Connection established.")

	//Build your node with known keys (ABP).
	nwsHexKey := "3bc0ddd455d320a6f36ff6f2a25057d0"
	appHexKey := "00de01b45b59a4df9cc2b3fa5eb0fe7c"
	devHexAddr := "07262b83"
	devAddr, err := lds.HexToDevAddress(devHexAddr)
	if err != nil {
		fmt.Printf("dev addr error: %s", err)
	}

	nwkSKey, err := lds.HexToKey(nwsHexKey)
	if err != nil {
		fmt.Printf("nwkskey error: %s", err)
	}

	appSKey, err := lds.HexToKey(appHexKey)
	if err != nil {
		fmt.Printf("appskey error: %s", err)
	}

	appKey := [16]byte{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}
	appEUI := [8]byte{0, 0, 0, 0, 0, 0, 0, 2}
	devEUI := [8]byte{0, 0, 0, 0, 0, 0, 0, 2}

	device := &lds.Device{
		DevEUI:  devEUI,
		DevAddr: devAddr,
		NwkSKey: nwkSKey,
		AppSKey: appSKey,
		AppKey:  appKey,
		AppEUI:  appEUI,
		UlFcnt:  0,
		DlFcnt:  0,
	}

	/*
		*	Make up some random values.
		*
		*	These should be decoded at lora-app-server with a proper function.
		* 	For this example, the object should look like this:
			obj : {
				"temperature": {
					"value":((bytes[0]*256+bytes[1])/100),"unit":"°C"
				},
				"pressure": {
					"value":((bytes[2]*16*16*16*16+bytes[3]*256+bytes[4])/100),"unit":"hPa"
				},
				"humidity": {
					"value":((bytes[5]*256+bytes[6])/1024),"unit":"%"
				}
			}
		*
	*/
	rand.Seed(time.Now().UnixNano() / 10000)
	temp := [2]byte{uint8(rand.Intn(25)), uint8(rand.Intn(100))}
	pressure := [3]byte{uint8(rand.Intn(2)), uint8(rand.Intn(20)), uint8(rand.Intn(100))}
	humidity := [2]byte{uint8(rand.Intn(100)), uint8(rand.Intn(100))}



	//Create the payload, data rate and rx info.

	payload := []byte{temp[0], temp[1], pressure[0], pressure[1], pressure[2], humidity[0], humidity[1]}


	//Change to your gateway MAC to build RxInfo.
	gwMac := "b827ebfffeb13d1f"

	//Construct DataRate RxInfo with proper values according to your band (example is for US 915).

        dataRate := &lds.DataRate{
        //      Bandwidth:    500,
                Bandwidth: 125,
                Modulation:   "LORA",
                SpreadFactor: 8,
                BitRate:      0}

        rxInfo := &lds.RxInfo{
                Channel:   0,
                CodeRate:  "4/5",
                CrcStatus: 1,
                DataRate:  dataRate,
		Frequency: 869000000,
                LoRaSNR:   7,
                Mac:       gwMac,
                RfChain:   1,
                Rssi:      -57,
                Size:      23,
                Time:      time.Now().Format(time.RFC3339),
                Timestamp: int32(time.Now().UnixNano() / 1000000000),
	 }

	    //Now send an uplink
        err = device.Uplink(&client.ConnectOptions, lorawan.UnconfirmedDataUp, 1, rxInfo, payload)
        if err != nil {
                fmt.Printf("couldn't send uplink: %s\n", err)
        }

			return nil
		},
	}
	cmd.Flags().String(ipFlag, "127.0.0.1", "How to connect")
	cmd.Flags().String(portFlag, "1883", "How to connect")
	return cmd
}

func jardimCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use: "sensorjardim",
		RunE: func(cmd *cobra.Command, args []string) error {
			ip, err := cmd.Flags().GetString(ipFlag)
			
			port, err2 := cmd.Flags().GetString(portFlag)
			
			if err != nil || err2 != nil {
				return err
				return err2
			}

			/*cmd.Println("A porta:", port)
			
			cmd.Println("O IP da gateway:", ip)*/

			var end_ip string
			end_ip=ip+":"+port
			
			var end string
			end="tcp://"+end_ip
			
			cmd.Println(end)
			


	//Connect to the broker
	opts := MQTT.NewClientOptions()
	opts.AddBroker(end)
	opts.SetUsername("your-username")
	opts.SetPassword("your-password")


	client := MQTT.NewClient(opts)

	if token := client.Connect(); token.Wait() && token.Error() != nil {
		fmt.Println("Connection error")
		fmt.Println(token.Error())
	}

	fmt.Println("Connection established.")

	//Build your node with known keys (ABP).
	nwsHexKey := "783f27d6a19e8701c4fcda7fdcba759e"
	appHexKey := "a5fe469807d274392020163c0764c647"
	devHexAddr := "018a1f94"
	devAddr, err := lds.HexToDevAddress(devHexAddr)
	if err != nil {
		fmt.Printf("dev addr error: %s", err)
	}

	nwkSKey, err := lds.HexToKey(nwsHexKey)
	if err != nil {
		fmt.Printf("nwkskey error: %s", err)
	}

	appSKey, err := lds.HexToKey(appHexKey)
	if err != nil {
		fmt.Printf("appskey error: %s", err)
	}

	appKey := [16]byte{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}
	appEUI := [8]byte{0, 0, 0, 0, 0, 0, 0, 3}
	devEUI := [8]byte{0, 0, 0, 0, 0, 0, 0, 3}

	device := &lds.Device{
		DevEUI:  devEUI,
		DevAddr: devAddr,
		NwkSKey: nwkSKey,
		AppSKey: appSKey,
		AppKey:  appKey,
		AppEUI:  appEUI,
		UlFcnt:  0,
		DlFcnt:  0,
	}

	rand.Seed(time.Now().UnixNano() / 10000)
	temp := [2]byte{uint8(rand.Intn(25)), uint8(rand.Intn(100))}
	pressure := [3]byte{uint8(rand.Intn(2)), uint8(rand.Intn(20)), uint8(rand.Intn(100))}
	humidity := [2]byte{uint8(rand.Intn(100)), uint8(rand.Intn(100))}

	//Create the payload, data rate and rx info.
	payload := []byte{temp[0], temp[1], pressure[0], pressure[1], pressure[2], humidity[0], humidity[1]}

	//Change to your gateway MAC to build RxInfo.
	gwMac := "b827ebfffeb13d1f"

	//Construct DataRate RxInfo with proper values according to your band (example is for US 915).

        dataRate := &lds.DataRate{
        //      Bandwidth:    500,
                Bandwidth: 125,
                Modulation:   "LORA",
                SpreadFactor: 8,
                BitRate:      0}

        rxInfo := &lds.RxInfo{
                Channel:   0,
                CodeRate:  "4/5",
                CrcStatus: 1,
                DataRate:  dataRate,
		Frequency: 869000000,
                LoRaSNR:   7,
                Mac:       gwMac,
                RfChain:   1,
                Rssi:      -57,
                Size:      23,
                Time:      time.Now().Format(time.RFC3339),
                Timestamp: int32(time.Now().UnixNano() / 1000000000),
        }

	    //Now send an uplink
        err = device.Uplink(client, lorawan.UnconfirmedDataUp, 1, rxInfo, payload)
        if err != nil {
                fmt.Printf("couldn't send uplink: %s\n", err)
        }
			
			
			return nil
		},
	}
	cmd.Flags().String(ipFlag, "127.0.0.1", "How to connect")
	cmd.Flags().String(portFlag, "1883", "How to connect")
	return cmd
}