Uplink Encoding
In my applications the myDevices Cayenne Low power payload(LPP) uplink messages from my *duino devices are decoded by the built in The Things Network(TTN) decoder. I can also see the nicely formatted values in the device data view.
Downlink Encoding
I could successfully download raw data to the device but I found that manually unpacking it on the device was painful.
I really want to send LPP formatted messages to my devices so I could use a standard LPP library. I initially populated the payload fields in the downlink message JSON. The TTN documentation appeared to indicate this was possible.
Initially I tried a more complex data type because I was looking at downloading a location to the device.
I could see nicely formatted values in the device data view but they didn’t arrive at the device. I then tried simpler data type to see if the complex data type was an issue.
At this point I asked a few questions on the TTN forums and started to dig into the TTN source code.
Learning Go on demand
I had a look at the TTB Go code and learnt a lot as I figured out how the “baked in “encoder/decoder worked. I haven’t done any Go coding so it took a while to get comfortable with the syntax. The code my look a bit odd as a Pascal formatter was the closest I could get to Go.
In core/handler/cayennelpp/encoder.go there was
func (e *Encoder) Encode(fields map[string]interface{}, fPort uint8) ([]byte, bool, error) and func (d *Decoder) Decode(payload []byte, fPort uint8) (map[string]interface{}, bool, error)
Which was a positive sign…
Then in core/handler/convert_fields.go there are these two functions
> // ConvertFieldsUp converts the payload to fields using the application's payload formatter
> func (h *handler) ConvertFieldsUp(ctx ttnlog.Interface, _ *pb_broker.DeduplicatedUplinkMessage, appUp *types.UplinkMessage, dev *device.Device) error {
> // Find Application
and
> // ConvertFieldsDown converts the fields into a payload
> func (h *handler) ConvertFieldsDown(ctx ttnlog.Interface, appDown *types.DownlinkMessage, ttnDown *pb_broker.DownlinkMessage, _ *device.Device) error {
Then further down in the second function is this call
var encoder PayloadEncoder
switch app.PayloadFormat {
case application.PayloadFormatCustom:
encoder = &CustomDownlinkFunctions{
Encoder: app.CustomEncoder,
Logger: functions.Ignore,
}
case application.PayloadFormatCayenneLPP:
encoder = &cayennelpp.Encoder{}
default:
return nil
}var encoder PayloadEncoder
switch app.PayloadFormat {
case application.PayloadFormatCustom:
encoder = &CustomDownlinkFunctions{
Encoder: app.CustomEncoder,
Logger: functions.Ignore,
}
case application.PayloadFormatCayenneLPP:
encoder = &cayennelpp.Encoder{}
default:
return nil
}
Which I think calls
// Encode encodes the fields to CayenneLPP
func (e *Encoder) Encode(fields map[string]interface{}, fPort uint8) ([]byte, bool, error) {
encoder := protocol.NewEncoder()
for name, value := range fields {
key, channel, err := parseName(name)
if err != nil {
continue
}
switch key {
case valueKey:
if val, ok := value.(float64); ok {
encoder.AddPort(channel, float32(val))
}
}
}
return encoder.Bytes(), true, nil
}
Then right down at the very bottom of the call stack in keys.go
func parseName(name string) (string, uint8, error) {
parts := strings.Split(name, "_")
if len(parts) < 2 {
return "", 0, errors.New("Invalid name")
}
key := strings.Join(parts[:len(parts)-1], "_")
if key == "" {
return "", 0, errors.New("Invalid key")
}
channel, err := strconv.Atoi(parts[len(parts)-1])
if err != nil {
return "", 0, err
}
if channel < 0 || channel > 255 {
return "", 0, errors.New("Invalid range")
}
return key, uint8(channel), nil
}
At this point I started to hit the limits of my Go skills but with some trial and error I figured it out…
Executive Summary
The downlink payload values are sent as 2 byte floats with a sign bit, 100 multiplier. The fields have to be named “value_X” where X is is a byte value.
Dictionary<string, object> payloadFields = new Dictionary<string, object>(); payloadFields.Add(“value_0”, 0.0); //00-00-00 payloadFields.Add(“value_1”, 1.0); //01-00-64 payloadFields.Add(“value_2”, 2.0); //02-00-C8 payloadFields.Add(“value_3”, 3.0); //03-01-2C payloadFields.Add(“value_4”, 4.0); //04-01-90 payloadFields.Add(“value_0”, -0.0); //00-00-00 payloadFields.Add(“value_1”, -1.0); //01-FF-9C payloadFields.Add(“value_2”, -2.0); //02-FF-38 payloadFields.Add(“value_3”, -3.0); //03-FE-D4 payloadFields.Add(“value_4”, -4.0); //04-FE-70
I could see these arrive on my TinyCLR plus RAK811 device and could manually unpack them
The stream of bytes can be decoded on an Arduino using the electronic cats library (needs a small modification) with code this
byte data[] = {0xff,0x38} ; // bytes which represent -2
float value = lpp.getValue( data, 2, 100, 1);
Serial.print("value:");
Serial.println(value);
It is possible to use the “baked” in Cayenne Encoder/Decoder to send payload fields to a device but I’m not certain is this is quite what myDevices/TTN intended.
