Added custom JS decoder.

README.md

@@ -52,7 +52,6 @@ log_level = "info"
   bandwith = 125
   spread_factor = 10
   bit_rate = 0
-  BitRateS = "0"
 
 [rx_info]
   channel = 0
@@ -66,6 +65,11 @@ log_level = "info"
 [raw_payload]
   payload = "ff00"
   use_raw = false
+	script = "\n// Encode encodes the given object into an array of bytes.\n//  - fPort contains the LoRaWAN fPort number\n//  - obj is an object, e.g. {\"temperature\": 22.5}\n// The function must return an array of bytes, e.g. [225, 230, 255, 0]\nfunction Encode(fPort, obj) {\n\treturn [\n      obj[\"Flags\"],\n      obj[\"Battery\"],\n      obj[\"Light\"],\n    ];\n}\n"
+  use_encoder = true
+  max_exec_time = 500
+  js_object = "{\n \"Flags\": 0,\n \"Battery\": 65,\n \"Light\": 54\n}"
+  fport = 2
 
 [[encoded_type]]
   name = "Flags"
@@ -102,7 +106,7 @@ When OTAA is set and the device is joined, uponinitialization the program will t
 
 ### Data
 
-The data to be sent may be presented as a hex string representation of the raw bytes, or using our encoding method (which then needs to be decoded accordingly at `lora-app-server`). As a reference, this is how we encode our data:
+The data to be sent may be presented as a hex string representation of the raw bytes, using a JS object and a decoding function to extract a bytes array from it, or using our encoding method (which then needs to be decoded accordingly at `lora-app-server`). As a reference, this is how we encode our data:
 
 ```go
 func GenerateFloat(originalFloat, maxValue float32, numBytes int32) []byte {
@@ -143,7 +147,11 @@ func GenerateInt(originalInt, numBytes int32) []byte {
 }
 ```
 
-Values may be added using the `Add encoded type` button and setting the options.
+When using our encoding method, values may be added using the `Add encoded type` button and setting the options.  
+
+To use your own custom JS encoder, click the "Use encoder" checkbox and the "Open decoder" button to open the form:
+
+![](images/encoder.png?raw=true)
 
 #### MAC Commands
 

control.go

@@ -183,3 +183,16 @@ func beginFCtrl() {
 	imgui.SameLine()
 	imgui.Checkbox("FPending##FCtrl-FPending", &fCtrl.FPending)
 }
+
+func beginControl() {
+	//imgui.SetNextWindowPos(imgui.Vec2{X: 400, Y: 25})
+	//imgui.SetNextWindowSize(imgui.Vec2{X: 780, Y: 250})
+	imgui.Begin("Control")
+	imgui.Text("FCtrl")
+	imgui.Separator()
+	beginFCtrl()
+	imgui.Text("MAC Commands")
+	beginMACCommands()
+	imgui.Separator()
+	imgui.End()
+}

data.go

@@ -0,0 +1,271 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+
+	"github.com/inkyblackness/imgui-go"
+	"github.com/pkg/errors"
+	log "github.com/sirupsen/logrus"
+
+	"time"
+
+	"github.com/robertkrimen/otto"
+)
+
+type encodedType struct {
+	Name     string  `toml:"name"`
+	Value    float64 `toml:"value"`
+	MaxValue float64 `toml:"max_value"`
+	MinValue float64 `toml:"min_value"`
+	IsFloat  bool    `toml:"is_float"`
+	NumBytes int     `toml:"num_bytes"`
+	//String representations.
+	ValueS    string `toml:"-"`
+	MinValueS string `toml:"-"`
+	MaxValueS string `toml:"-"`
+	NumBytesS string `toml:"-"`
+}
+
+//rawPayload holds optional raw bytes payload (hex encoded).
+type rawPayload struct {
+	Payload     string `toml:"payload"`
+	UseRaw      bool   `toml:"use_raw"`
+	Script      string `toml:"script"`
+	UseEncoder  bool   `toml:"use_encoder"`
+	MaxExecTime int    `toml:"max_exec_time"`
+	Obj         string `toml:"js_object"`
+	FPort       int    `toml:"fport"`
+	FPortS      string `toml:"-"`
+}
+
+var openScript bool
+var defaultScript = `
+// Encode encodes the given object into an array of bytes.
+//  - fPort contains the LoRaWAN fPort number
+//  - obj is an object, e.g. {"temperature": 22.5}
+// The function must return an array of bytes, e.g. [225, 230, 255, 0]
+function Encode(fPort, obj) {
+	return [];
+}
+`
+
+func beginDataForm() {
+	//imgui.SetNextWindowPos(imgui.Vec2{X: 400, Y: 285})
+	//imgui.SetNextWindowSize(imgui.Vec2{X: 780, Y: 355})
+	imgui.Begin("Data")
+	imgui.Text("Raw data")
+	imgui.PushItemWidth(150.0)
+	imgui.InputTextV("Raw bytes in hex", &config.RawPayload.Payload, imgui.InputTextFlagsCharsHexadecimal, nil)
+	imgui.SameLine()
+	imgui.Checkbox("Send raw", &config.RawPayload.UseRaw)
+	imgui.SameLine()
+	imgui.Checkbox("Use encoder", &config.RawPayload.UseEncoder)
+	imgui.SameLine()
+	if imgui.Button("Open encoder") {
+		openScript = true
+	}
+	imgui.InputTextV(fmt.Sprintf("fPort    ##fport"), &config.RawPayload.FPortS, imgui.InputTextFlagsCharsDecimal|imgui.InputTextFlagsCallbackAlways, handleInt(config.RawPayload.FPortS, 10, &config.RawPayload.FPort))
+	imgui.SliderInt("X", &interval, 1, 60)
+	imgui.SameLine()
+	imgui.Checkbox("Send every X seconds", &repeat)
+	if !running {
+		if imgui.Button("Send data") {
+			go run()
+		}
+	}
+	if repeat && running {
+		if imgui.Button("Stop") {
+			running = false
+		}
+	}
+
+	imgui.Separator()
+
+	imgui.Text("Encoded data")
+	if imgui.Button("Add encoded type") {
+		et := &encodedType{
+			Name:      "New type",
+			ValueS:    "0",
+			MaxValueS: "0",
+			MinValueS: "0",
+			NumBytesS: "0",
+		}
+		config.EncodedType = append(config.EncodedType, et)
+		log.Println("added new type")
+	}
+
+	for i := 0; i < len(config.EncodedType); i++ {
+		delete := false
+		imgui.Separator()
+		imgui.InputText(fmt.Sprintf("Name     ##%d", i), &config.EncodedType[i].Name)
+		imgui.SameLine()
+		imgui.InputTextV(fmt.Sprintf("Bytes    ##%d", i), &config.EncodedType[i].NumBytesS, imgui.InputTextFlagsCharsDecimal|imgui.InputTextFlagsCallbackAlways, handleInt(config.EncodedType[i].NumBytesS, 10, &config.EncodedType[i].NumBytes))
+		imgui.SameLine()
+		imgui.Checkbox(fmt.Sprintf("Float##%d", i), &config.EncodedType[i].IsFloat)
+		imgui.SameLine()
+		if imgui.Button(fmt.Sprintf("Delete##%d", i)) {
+			delete = true
+		}
+		imgui.InputTextV(fmt.Sprintf("Value    ##%d", i), &config.EncodedType[i].ValueS, imgui.InputTextFlagsCharsDecimal|imgui.InputTextFlagsCallbackAlways, handleFloat64(config.EncodedType[i].ValueS, &config.EncodedType[i].Value))
+		imgui.SameLine()
+		imgui.InputTextV(fmt.Sprintf("Max value##%d", i), &config.EncodedType[i].MaxValueS, imgui.InputTextFlagsCharsDecimal|imgui.InputTextFlagsCallbackAlways, handleFloat64(config.EncodedType[i].MaxValueS, &config.EncodedType[i].MaxValue))
+		imgui.SameLine()
+		imgui.InputTextV(fmt.Sprintf("Min value##%d", i), &config.EncodedType[i].MinValueS, imgui.InputTextFlagsCharsDecimal|imgui.InputTextFlagsCallbackAlways, handleFloat64(config.EncodedType[i].MinValueS, &config.EncodedType[i].MinValue))
+		if delete {
+			if len(config.EncodedType) == 1 {
+				config.EncodedType = make([]*encodedType, 0)
+			} else {
+				copy(config.EncodedType[i:], config.EncodedType[i+1:])
+				config.EncodedType[len(config.EncodedType)-1] = &encodedType{}
+				config.EncodedType = config.EncodedType[:len(config.EncodedType)-1]
+			}
+		}
+	}
+	imgui.Separator()
+	beginScript()
+	imgui.End()
+}
+
+func beginScript() {
+	if openScript {
+		imgui.OpenPopup("JS encoder")
+		openScript = false
+	}
+	imgui.SetNextWindowPos(imgui.Vec2{X: (float32(windowWidth) / 2) - 370.0, Y: (float32(windowHeight) / 2) - 200.0})
+	imgui.SetNextWindowSize(imgui.Vec2{X: 740, Y: 600})
+	if imgui.BeginPopupModal("JS encoder") {
+		imgui.Text(`If "Use encoder" is checked, you may write a function that accepts a JS object`)
+		imgui.Text(`and returns a byte array that'll be used as the raw bytes when sending data.`)
+		imgui.Text(`The function must be named Encode and accept a port and JS object.`)
+		imgui.InputTextMultilineV("##encoder-function", &config.RawPayload.Script, imgui.Vec2{X: 710, Y: 300}, imgui.InputTextFlagsAllowTabInput, nil)
+		imgui.Separator()
+		imgui.Text("JS object:")
+		imgui.InputTextMultilineV("##encoder-object", &config.RawPayload.Obj, imgui.Vec2{X: 710, Y: 140}, 0, nil)
+		if imgui.Button("Clear##encoder-cancel") {
+			config.RawPayload.Script = defaultScript
+			imgui.CloseCurrentPopup()
+		}
+		imgui.SameLine()
+		if imgui.Button("Close##encoder-close") {
+			imgui.CloseCurrentPopup()
+		}
+		imgui.EndPopup()
+	}
+}
+
+// EncodeToBytes encodes the payload to a slice of bytes.
+// Taken from github.com/brocaar/lora-app-server.
+func EncodeToBytes() (b []byte, err error) {
+	defer func() {
+		if caught := recover(); caught != nil {
+			err = fmt.Errorf("%s", caught)
+		}
+	}()
+
+	script := config.RawPayload.Script + "\n\nEncode(fPort, obj);\n"
+
+	vm := otto.New()
+	vm.Interrupt = make(chan func(), 1)
+	vm.SetStackDepthLimit(32)
+	var jsonData interface{}
+	err = json.Unmarshal([]byte(config.RawPayload.Obj), &jsonData)
+	if err != nil {
+		log.Errorf("couldn't unmarshal object: %s", err)
+		return nil, err
+	}
+	log.Debugf("JS object: %v", jsonData)
+	vm.Set("obj", jsonData)
+	vm.Set("fPort", config.RawPayload.FPort)
+
+	go func() {
+		time.Sleep(time.Duration(config.RawPayload.MaxExecTime) * time.Millisecond)
+		vm.Interrupt <- func() {
+			panic(errors.New("execution timeout"))
+		}
+	}()
+
+	var val otto.Value
+	val, err = vm.Run(script)
+	if err != nil {
+		return nil, errors.Wrap(err, "js vm error")
+	}
+	if !val.IsObject() {
+		return nil, errors.New("function must return an array")
+	}
+
+	var out interface{}
+	out, err = val.Export()
+	if err != nil {
+		return nil, errors.Wrap(err, "export error")
+	}
+
+	return interfaceToByteSlice(out)
+}
+
+// Taken from github.com/brocaar/lora-app-server.
+func interfaceToByteSlice(obj interface{}) ([]byte, error) {
+	if obj == nil {
+		return nil, errors.New("value must not be nil")
+	}
+
+	if reflect.TypeOf(obj).Kind() != reflect.Slice {
+		return nil, errors.New("value must be an array")
+	}
+
+	s := reflect.ValueOf(obj)
+	l := s.Len()
+
+	var out []byte
+	for i := 0; i < l; i++ {
+		var b int64
+
+		el := s.Index(i).Interface()
+		switch v := el.(type) {
+		case int:
+			b = int64(v)
+		case uint:
+			b = int64(v)
+		case uint8:
+			b = int64(v)
+		case int8:
+			b = int64(v)
+		case uint16:
+			b = int64(v)
+		case int16:
+			b = int64(v)
+		case uint32:
+			b = int64(v)
+		case int32:
+			b = int64(v)
+		case uint64:
+			b = int64(v)
+			if uint64(b) != v {
+				return nil, fmt.Errorf("array value must be in byte range (0 - 255), got: %d", v)
+			}
+		case int64:
+			b = int64(v)
+		case float32:
+			b = int64(v)
+			if float32(b) != v {
+				return nil, fmt.Errorf("array value must be in byte range (0 - 255), got: %f", v)
+			}
+		case float64:
+			b = int64(v)
+			if float64(b) != v {
+				return nil, fmt.Errorf("array value must be in byte range (0 - 255), got: %f", v)
+			}
+		default:
+			return nil, fmt.Errorf("array value must be an array of ints or floats, got: %T", el)
+		}
+
+		if b < 0 || b > 255 {
+			return nil, fmt.Errorf("array value must be in byte range (0 - 255), got: %d", b)
+		}
+
+		out = append(out, byte(b))
+	}
+
+	return out, nil
+}