Startseite>Programmierbezogen>AI-Quellcode
Herunterladen

Lorawan Serialisierungs-/Deserialisierungsbibliothek für das Dings Network

Mit dieser vollständig einheitlich getesteten Bibliothek können Sie Ihre Daten auf der Arduino-Seite codieren und auf der TTN-Seite dekodieren. Es bietet sowohl einen C-basierten Encoder als auch einen JavaScript-basierten Decoder.

Seit Version 2.2.0 gibt es auch einen Encoder für die TTN -Seite.

Zusamenfassend

Codierung auf Arduino, Decodierung in TTN

Arduino Seite: 

# include " LoraMessage.h "

LoraMessage message;

message
    .addUnixtime( 1467632413 )
    .addLatLng(- 33.905052 , 151.26641 );

lora_send_bytes (message.getBytes(), message.getLength());
delete message;

TTN Seite: 

 function decodeUplink ( input )
{
    // decoder function according to https://www.thethingsindustries.com/docs/integrations/payload-formatters/javascript/uplink/
    // input has the following structure:
    // {
    //   "bytes": [1, 2, 3], // FRMPayload (byte array)
    //   "fPort": 1
    // }
    var data = decode ( input . bytes , [ unixtime , latLng ] , [ 'time' , 'coords' ] ) ;
    return { data : data }
}

// include content from src/decoder.js:
var bytesToInt = function ( bytes ) {
  var i = 0 ;
  for ( var x = 0 ; x < bytes . length ; x ++ ) {
    i |= + ( bytes [ x ] << ( x * 8 ) ) ;
  }
  return i ;
} ;
...

Codierung in TTN

TTN Seite: 

 // include src/encoder.js
var bytes = encode ( [ timestamp , [ latitude , longitude ] ] , [ unixtime , latLng ] ) ;
// bytes is of type Buffer

Mit der Convenience -Klasse 

 // include src/encoder.js
// include src/LoraMessage.js
var bytes = new LoraMessage ( encoder )
    . addUnixtime ( 1467632413 )
    . addLatLng ( - 33.905052 , 151.26641 )
    . addBitmap ( true , true , false , true )
    . getBytes ( ) ;
// bytes = <Buffer 1d 4b 7a 57 64 a6 fa fd 6a 24 04 09 d0>

und dann wie gewohnt dekodieren: 

 var result = decoder . decode (
    bytes ,
    [ decoder . unixtime , decoder . latLng , decoder . bitmap ] ,
    [ 'time' , 'coords' , 'heaters' ]
) ;
// result =
// { time: 1467632413,
//  coords: [ -33.905052, 151.26641 ],
//  heaters:
//   { a: true,
//     b: true,
//     c: false,
//     d: true,
//     e: false,
//     f: false,
//     g: false,
//     h: false } }

Allgemeine Verwendung

Unix -Zeit (4 Bytes)

Serialisiert/deserialisiert eine Unix -Zeit (Sekunden) 

# include " LoraEncoder.h "

byte buffer[ 4 ];
LoraEncoder encoder (buffer);
encoder.writeUnixtime( 1467632413 );
// buffer == {0x1d, 0x4b, 0x7a, 0x57}

und dann in der TTN -Frontend die folgende Methode verwenden: 

 unixtime ( input . bytes . slice ( x , x + 4 ) ) // 1467632413

GPS -Koordinaten (8 Bytes)

Serialisiert/deserialisiert die Koordinaten (Breitengrad/Länge) mit einer Präzision von 6 Dezimalstellen. 

# include " LoraEncoder.h "

byte buffer[ 8 ];
LoraEncoder encoder (buffer);
encoder.writeLatLng(- 33.905052 , 151.26641 );
// buffer == {0x64, 0xa6, 0xfa, 0xfd, 0x6a, 0x24, 0x04, 0x09}

und dann in der TTN -Frontend die folgende Methode verwenden: 

 latLng ( input . bytes . slice ( x , x + 8 ) ) // [-33.905052, 151.26641]

Nicht signiert 8 -Bit -Ganzzahl (1 Byte)

Serialisiert/deserialisiert eine nicht signierte 8 -Bit -Ganzzahl. 

# include " LoraEncoder.h "

byte buffer[ 1 ];
LoraEncoder encoder (buffer);
uint8_t i = 10 ;
encoder.writeUint8(i);
// buffer == {0x0A}

und dann in der TTN -Frontend die folgende Methode verwenden: 

 uint8 ( input . bytes . slice ( x , x + 1 ) ) // 10

Nicht signierte 16 -Bit -Ganzzahl (2 Bytes)

Serialisiert/deserialisiert eine nicht signierte 16 -Bit -Ganzzahl. 

# include " LoraEncoder.h "

byte buffer[ 2 ];
LoraEncoder encoder (buffer);
uint16_t i = 23453 ;
encoder.writeUint16(i);
// buffer == {0x9d, 0x5b}

und dann in der TTN -Frontend die folgende Methode verwenden: 

 uint16 ( input . bytes . slice ( x , x + 2 ) ) // 23453

Unsigned 32 -Bit -Ganzzahl (4 Bytes)

Serialisiert/deserialisiert eine nicht signierte 32 -Bit -Ganzzahl. 

# include " LoraEncoder.h "

byte buffer[ 4 ];
LoraEncoder encoder (buffer);
uint32_t i = 2864434397 ;
encoder.writeUint32(i);
// buffer == {0xdd, 0xcc, 0xbb, 0xaa}

und dann in der TTN -Frontend die folgende Methode verwenden: 

 uint32 ( input . bytes . slice ( x , x + 4 ) ) // 2864434397

Temperatur (2 Bytes)

Serialisiert/deserialisiert einen Temperaturwert zwischen -327,68 und +327,67 (inklusive) mit einer Präzision von 2 Dezimalstellen. 

# include " LoraEncoder.h "

byte buffer[ 2 ];
LoraEncoder encoder (buffer);
encoder.writeTemperature(- 123.45 );
// buffer == {0xcf, 0xc7}

und dann in der TTN -Frontend die folgende Methode verwenden: 

 temperature ( input . bytes . slice ( x , x + 2 ) ) // -123.45

Luftfeuchtigkeit (2 Bytes)

Serialisiert/deserialisiert eine Feuchtigkeitsablesung zwischen 0 und 100 (inklusive) mit einer Präzision von 2 Dezimalstellen. 

# include " LoraEncoder.h "

byte buffer[ 2 ];
LoraEncoder encoder (buffer);
encoder.writeHumidity( 99.99 );
// buffer == {0x0f, 0x27}

und dann in der TTN -Frontend die folgende Methode verwenden: 

 humidity ( input . bytes . slice ( x , x + 2 ) ) // 99.99

Full Float (4 Bytes)

Serialisiert/deserialisiert einen vollen 4-Byte-Float. 

# include " LoraEncoder.h "

byte buffer[ 4 ];
LoraEncoder encoder (buffer);
encoder.writeRawFloat( 99.99 );
// buffer == {0xe1, 0xfa, 0xc7, 0x42}

und dann in der TTN -Frontend die folgende Methode verwenden: 

 rawfloat ( input . bytes . slice ( x , x + 4 ) ) // 99.99

Bitmap (1 Byte)

Serialisiert/deserialisiert eine Bitmap, die zwischen 0 und 8 verschiedenen Flags enthält. 

# include " LoraEncoder.h "

byte buffer[ 1 ];
LoraEncoder encoder (buffer);
encoder.writeBitmap( true , false , false , false , false , false , false , false );
// buffer == {0x80}

und dann in der TTN -Frontend die folgende Methode verwenden: 

 bitmap ( input . bytes . slice ( x , x + 1 ) ) // { a: true, b: false, c: false, d: false, e: false, f: false, g: false, h: false }

Zusammensetzung

Auf der Arduino -Seite

Mit dem Decoder können Sie mehr als einen Wert in ein Byte -Array schreiben: 

# include " LoraEncoder.h "

byte buffer[ 19 ];
LoraEncoder encoder (buffer);

encoder.writeUnixtime( 1467632413 );
encoder.writeLatLng(- 33.905052 , 151.26641 );
encoder.writeUint8( 10 );
encoder.writeUint16( 23453 );
encoder.writeUint32( 2864434397 );
encoder.writeTemperature( 80.12 );
encoder.writeHumidity( 99.99 );
encoder.writeRawFloat( 99.99 );
encoder.writeBitmap( true , false , false , false , false , false , false , false );
/* buffer == {
    0x1d, 0x4b, 0x7a, 0x57, // Unixtime
    0x64, 0xa6, 0xfa, 0xfd, 0x6a, 0x24, 0x04, 0x09, // latitude,longitude
    0x0A, // Uint8
    0x9d, 0x5b, // Uint16
    0xdd, 0xcc, 0xbb, 0xaa, // Uint32
    0x1f, 0x4c, // temperature
    0x0f, 0x27, // humidity
    0xe1, 0xfa, 0xc7, 0x42, // 4-byte float
    0x80 // bitmap
}
*/

Convenience -Klasse LoraMessage

Es gibt eine Convenience -Klasse, die eine Loramessage darstellt, zu der Sie Lesungen hinzufügen können: 

# include " LoraMessage.h "

LoraMessage message;

message
    .addUnixtime( 1467632413 )
    .addLatLng(- 33.905052 , 151.26641 )
    .addUint8( 10 )
    .addUint16( 23453 )
    .addUint32( 2864434397 )
    .addTemperature( 80.12 )
    .addHumidity( 99.99 )
    .addRawFloat( 99.99 )
    .addBitmap( false , false , false , false , false , false , true , false );

send (message.getBytes(), message.getLength());
/*
getBytes() == {
    0x1d, 0x4b, 0x7a, 0x57, // Unixtime
    0x64, 0xa6, 0xfa, 0xfd, 0x6a, 0x24, 0x04, 0x09, // latitude,longitude
    0x0A, // Uint8
    0x9d, 0x5b, // Uint16
    0xdd, 0xcc, 0xbb, 0xaa, // Uint32
    0x1f, 0x4c, // temperature
    0x0f, 0x27, // humidity
    0xe1, 0xfa, 0xc7, 0x42, // 4-byte float
    0xfd // Bitmap
}
and
getLength() == 28
*/

Zusammensetzung in der TTN -Decoder -Frontend mit der decode -Methode

Mit der decode können Sie eine Maske für den eingehenden Bytepuffer (der in dieser Bibliothek generiert wurde) angeben und entsprechende Decodierungsfunktionen anwenden. 

 decode ( byte Array , mask Array [ , mapping Array ] )

Beispiel

Fügen Sie alles von src/decoder.js in die Decoder -Methode ein und verwenden Sie wie folgt: 

 function ( bytes ) {
    // code from src/decoder.js here
    return decode ( bytes , [ latLng , unixtime ] , [ 'coords' , 'time' ] ) ;
}

Dies ordnet den eingehenden Bytepuffer von 12 Bytes auf eine Sequenz von einer latLng (8 -Bytes) und einer unixtime (4 -Bytes) -Sequenz ab und ordnet den ersten zu einem coords und dem zweiten zu einer time .

Sie können verwenden: 64 A6 FA FD 6A 24 04 09 1D 4B 7A 57 zum Testen und es wird zu: 

{
  "coords" : [
    -33.905052 ,
    151.26641
  ],
  "time" : 1467632413
}
Beispiel -Decoder in der TTN -Konsole

Richten Sie Ihren Decoder in der Konsole ein:

Beispielwandler in der TTN -Konsole

Die Decode -Methode führt bereits die meisten der erforderlichen Transformationen durch. In den meisten Fällen können Sie die Daten einfach übergeben:

Entwicklung

  • Installieren Sie die Abhängigkeiten über yarn
  • Führen Sie die Unit -Tests (c) über yarn run test:c
  • Führen Sie die Unit -Tests (JavaScript) über yarn test aus
  • Überprüfen Sie die Abdeckung (JavaScript) über yarn coverage (siehe coverage/lcov-report ).

Der CI beginnt, sobald Sie automatisch eine Pull -Anfrage erstellt haben.

Installation

ESP-IDF

Fügen Sie die Abhängigkeit lora-serialization zur main/idf_component.yml Datei in Ihrem ESP-IDF-Projekt hinzu: 

 dependencies:
  lora-serialization:
    git: https://github.com/thesolarnomad/lora-serialization.git

Sowie zum main/CMakeLists.txt 

 idf_component_register( ...
                        REQUIRES .... lora-serialization
                      )
Expandieren
Zusätzliche Informationen
Ähnliche Anwendungen
Empfohlen für Sie
Ähnliche Nachrichten Alle