Decoding Payloads

Search…
Decoding Payloads
Introduction
Many of you already know payload decoding from LoRaWAN devices. There, the concept is used to convert the data, usually sent as a simple byte sequence from the sensor, into usable data.
We have decided that we will use this concept for every IoT device, and therefore also for the Particle.io devices.
The advantages are obvious:
Run Code in the Cloud
Thanks to Payload Decoder, you have a piece of code that is called every time a new message comes from the device or platform (Spark status messages).
Advanced Processing
When receiving a message, short operations can be performed, including:
Simple calculations
Conversions of value range or unit
Comparison with historical data from the database of your devices
Your first Payload Decoder
A simple payload decoder for Particle.io Devices looks like this on Datacake:
1
function Decoder(payload, event) {
2
​
3
    var temperature = payload;
4
​
5
    return [
6
        {
7
            field: "TEMPERATURE",
8
            value: temperature
9
        }
10
    ];
11
    
12
}
Copied!
Routing of Data
Payload decoders respond to calls to Particle.Publish() functions in the device firmware. The following code snippet shows the routing for a publish of a simple value (temperature).
Execution
Every time your device calls a Particle.Publish, and it is forwarded via Webhook and Datacake, then the encoder is called accordingly.
In the scope of the decoder you have access to the following elements:
Payload/message data of the Particle.Publish
Event name of the publish
Last measured values via database of the device on Datacake
Example
Code on Device
Let's assume the Code on the Device looks like the following:
1
Particle.publish("temperature", 23.02);
Copied!
Datacake Decoder
The decoder for this message type would look like the following on Datacake:
1
function Decoder(payload, event) {
2
​
3
    if (event == "temperature") {
4
​
5
        var temperature = parseFloat(payload);
6
        
7
        return [
8
            {
9
                field: "TEMPERATURE",
10
                value: temperature
11
            }
12
        ];    
13
    }
14
}
Copied!
Concept
As you can see from the above example, the decoder is used to extract the data format from the Particle.Publish and split it into respective payloads.
The advantage here is clearly that you have a completely free hand in the design of the data format on the device.
You do not need to worry about the structuring of the data but can use the decoders to be able to react flexibly to different formats.
Database Mapping
Now you probably wonder how the database of the device knows how to store the temperature. Decisive for the mapping is the return type of the decoder, more precisely the following:
Returning Data
Payload Decoders must always return Data in the following format:
1
return [
2
    {
3
        field: "TEMPERATURE",
4
        value: temperature
5
    }
6
];    
Copied!
Create Database Field
A corresponding field must be created on the device, whose identifier is identical with the field property of the return dictionary. So in the above example with temperature, we create a field with identifer of the same name. To do this, switch to the configuration of your device and scroll down to the fields section.
There you click on the button "Add Field" to create a new field accordingly.
To learn more about fields, their types and functions, please click on the following link:
Fields
Decoding JSON Data
Since Particle does not tell you in which format you may transmit the data, you can also send a JSON string directly from the device. A corresponding decoder would then look like this:
Code on Device
Let's assume your device firmware is publishing data directly as a JSON-String:
1
Particle.publish("device/data", "{temperature: 23.2, co2: 560, state: 1}"); 
Copied!
Datacake Decoder
A decoder on Datacake would look like the following snippet:
1
function Decoder(payload, event) {
2
​
3
    if (event == "device/data") {
4
​
5
        var data = JSON.parse(payload);
6
        
7
        return [
8
            {
9
                field: "TEMPERATURE",
10
                value: data.temperature
11
            },
12
            {
13
                field: "CO2",
14
                value: data.temperature
15
            },
16
            {
17
                field: "STATE",
18
                value: data.state ? true : false;
19
            }            
20
        ];    
21
    }
22
}
Copied!
Routing Spark Events
A payload decoder can also respond to the appropriate Spark diagnostics and system publishes. For this, only a corresponding webhook must be available.
1
function Decoder(payload, event) {
2
​
3
    // Routing for Spark-Events
4
    
5
    if (event == "spark/device/diagnostics/update") {
6
        
7
        payload = JSON.parse(payload);
8
        
9
        var technology = payload.device.network.cellular.radio_access_technology;
10
        var operator = payload.device.network.cellular.operator;
11
        
12
        return [
13
            {
14
                field: "CELLULAR_TECHNOLOGY",
15
                value: technology
16
            },
17
            {
18
                field: "CELLULAR_OPERATOR",
19
                value: operator
20
            }            
21
        ]; 
22
    }
23
​
24
    if (event == "temperature") {
25
​
26
        var temperature = parseFloat(payload);
27
        
28
        return [
29
            {
30
                field: "TEMPERATURE",
31
                value: temperature
32
            }
33
        ];    
34
    }
35
}
Copied!
Read Database
The decoders allow you to read the current measured values from the database and use them for decoding. This can be useful to e.g.:
Calculate average, minium or maximum values 
Set geofencing and do distance measuring 
Count messages or state changes
It can also be used to pre-sort data and discard irrelevant changes.
Basic example
Measured values can be called directly in the decoder via the global measurements object. This then looks something like the following:
1
function Decoder(payload, event) {
2
​
3
    if (event == "temperature") {
4
​
5
        var temperature = parseFloat(payload);
6
        
7
        // access previous temperature value from database
8
        var oldTemperature = measurements.TEMPERATURE.value;
9
        
10
        if (temperature != oldTemperature) {
11
        
12
            return [
13
                {
14
                    field: "TEMPERATURE",
15
                    value: temperature
16
                }
17
            ];         
18
        }   
19
    }
20
}
Copied!
Returning the Data
You must have noticed that the payload decoders return the data in an appropriate format. This looks like this:
1
return [
2
    {
3
        field: "TEMPERATURE",
4
        value: temperature
5
    }
6
];
Copied!
The reason for this is that we use the appropriate form to address exactly our API and the database behind it.
Record Historical Data
And exactly for this reason, there are additional functions, such as the transmission of a time stamp to be able to import historical data or measurement data sequences. This then looks something like this:
Device Code
Let us now assume that the device measures the temperature every fifteen minutes and transmits it in an array every full hour.
1
Particle.publish("temps", "[23.2, 24.5, 24.9, 25.04]"); 
Copied!
Datacake Decoder
The decoder for such a transmission pattern would then look as follows.
1
function Decoder(payload, event) {
2
​
3
    if (event == "temps") {
4
    
5
        payload = JSON.parse(payload);    
6
        
7
        var time_now = ... // get timestamp
8
    
9
        var temperature_t0 = parseFloat(payload[0]);
10
        var temperature_t1 = parseFloat(payload[1]);
11
        var temperature_t2 = parseFloat(payload[2]);
12
        var temperature_t3 = parseFloat(payload[3]);                        
13
        
14
        return [
15
            {
16
                field: "TEMPERATURE",
17
                value: temperature_t0,
18
                timestamp: time_now - 0
19
            },
20
            {
21
                field: "TEMPERATURE",
22
                value: temperature_t1,
23
                timestamp: time_now - 15
24
            },
25
            {
26
                field: "TEMPERATURE",
27
                value: temperature_t2,
28
                timestamp: time_now - 30
29
            },
30
            {
31
                field: "TEMPERATURE",
32
                value: temperature_t3,
33
                timestamp: time_now - 45
34
            },                                    
35
        ];    
36
    }
37
}
Copied!
Uppercase
Please make sure that when returning the values from the decoder, you specify the identifier for the database this always in capital letters. Otherwise an assignment may not be possible.
Default Decoder
If you create a Particle.io device without a template on the Datacake platform, then this device is already delivered with a basic decoder. This decoder looks like this:
1
/*
2
​
3
Default Decoder for Particle.io Devices
4
Version: 0.1.1
5
(c) Datacake GmbH
6
​
7
*/
8
​
9
function Decoder(payload, event) {
10
    
11
    var decoded = {};    
12
    
13
    // User Functions
14
    
15
    /*
16
    
17
    if (event == "temperature") {
18
    
19
        // payload = JSON.parse(payload) // do this if you send JSON
20
        
21
        decoded.temperature = parseFloat(payload);
22
    
23
    }
24
    
25
    */
26
    
27
    // Particle Diagnostic and Online Status Events
28
    
29
    if (event == "spark/device/diagnostics/update") {
30
        
31
        payload = JSON.parse(payload);
32
        
33
        decoded.cellular_radio_access_technology = payload.device.network.cellular.radio_access_technology;
34
        decoded.cellular_operator = payload.device.network.cellular.operator;
35
        decoded.cellular_signal_strength = payload.device.network.signal.strength;
36
        decoded.cellular_signal_quality = payload.device.network.signal.quality;
37
        
38
    } else if (event == "spark/status") {
39
        
40
        if (payload == "online") {
41
            
42
            decoded.online_status = true;
43
            
44
        } else {
45
            
46
            decoded.online_status = false;
47
        }
48
    }
49
    
50
    // Array where we store the fields that are being sent to Datacake
51
    var datacakeFields = []
52
    
53
    // take each field from decoded and convert them to Datacake format
54
    for (var key in decoded) {
55
        if (decoded.hasOwnProperty(key)) {
56
            datacakeFields.push({field: key.toUpperCase(), value: decoded[key]})
57
        }
58
    }      
59
    
60
    // forward data to Datacake
61
    return datacakeFields;
62
}
Copied!
In the above decoder you can see a so called converter at the end of the code. This takes some typing work from you when writing the decoder. How this works exactly is explained in the next section.
Converter
As mentioned earlier, the Datacake platform expects a decoder to return data in the following format:
1
return [
2
    {
3
        field: "TEMPERATURE",
4
        value: temperature
5
    }
6
];    
Copied!
However, since this is a lot of write effort, there is a method to save some of this effort.
For this we create a simple dictionary and store the data as a simple key-value pair.
1
function Decoder(payload, event) {
2
​
3
    var decoded = {};
4
    
5
    if (event == "temperature") {
6
        
7
        decoded.temperature = parseFloat(payload);
8
    }
9
}
Copied!
A small function at the end of the decoder converts this dictionary automatically into the datacake format.
1
function Decoder(payload, event) {
2
​
3
    var decoded = {};
4
    
5
    if (event == "temperature") {
6
        
7
        decoded.temperature = parseFloat(payload);
8
    }
9
    
10
    // Array where we store the fields that are being sent to Datacake
11
    var datacakeFields = []
12
    
13
    // take each field from decoded and convert them to Datacake format
14
    for (var key in decoded) {
15
        if (decoded.hasOwnProperty(key)) {
16
            datacakeFields.push({field: key.toUpperCase(), value: decoded[key]})
17
        }
18
    }      
19
    
20
    // forward data to Datacake
21
    return datacakeFields;    
22
}
Copied!
Auto Uppercase
Another advantage is that you don't have to worry about capitalization. During the conversion all field names are converted to upper case letters (as required).
Of course, this only makes sense if you work with a high number of messages in the decoder, e.g. if you receive a payload with JSON or many aggregated measurement data.