lora serialization
v.3.3.1
Esta biblioteca totalmente probada por unidad le permite codificar sus datos en el lado Arduino y decodificarlo en el lado TTN. Proporciona un codificador basado en C y un decodificador basado en JavaScript.
Desde la versión 2.2.0 también hay un codificador para el lado TTN.
Side Arduino:
# include " LoraMessage.h "
LoraMessage message;
message
.addUnixtime( 1467632413 )
.addLatLng(- 33.905052 , 151.26641 );
lora_send_bytes (message.getBytes(), message.getLength());
delete message;TTN Side:
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 ;
} ;
...TTN Side:
// include src/encoder.js
var bytes = encode ( [ timestamp , [ latitude , longitude ] ] , [ unixtime , latLng ] ) ;
// bytes is of type Buffer // 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>Y luego decodificando como de costumbre:
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 } } Serializa/deserializa un tiempo UNIX (segundos)
# include " LoraEncoder.h "
byte buffer[ 4 ];
LoraEncoder encoder (buffer);
encoder.writeUnixtime( 1467632413 );
// buffer == {0x1d, 0x4b, 0x7a, 0x57}y luego en el frontend TTN, use el siguiente método:
unixtime ( input . bytes . slice ( x , x + 4 ) ) // 1467632413Serializa/deserializa coordenadas (latitud/longitud) con una precisión de 6 decimales.
# include " LoraEncoder.h "
byte buffer[ 8 ];
LoraEncoder encoder (buffer);
encoder.writeLatLng(- 33.905052 , 151.26641 );
// buffer == {0x64, 0xa6, 0xfa, 0xfd, 0x6a, 0x24, 0x04, 0x09}y luego en el frontend TTN, use el siguiente método:
latLng ( input . bytes . slice ( x , x + 8 ) ) // [-33.905052, 151.26641]Serializa/deserializa un entero de 8 bits sin firmar.
# include " LoraEncoder.h "
byte buffer[ 1 ];
LoraEncoder encoder (buffer);
uint8_t i = 10 ;
encoder.writeUint8(i);
// buffer == {0x0A}y luego en el frontend TTN, use el siguiente método:
uint8 ( input . bytes . slice ( x , x + 1 ) ) // 10Serializa/deserializa un entero de 16 bits sin firmar.
# include " LoraEncoder.h "
byte buffer[ 2 ];
LoraEncoder encoder (buffer);
uint16_t i = 23453 ;
encoder.writeUint16(i);
// buffer == {0x9d, 0x5b}y luego en el frontend TTN, use el siguiente método:
uint16 ( input . bytes . slice ( x , x + 2 ) ) // 23453Serializa/deserializa un entero sin firmar de 32 bits.
# include " LoraEncoder.h "
byte buffer[ 4 ];
LoraEncoder encoder (buffer);
uint32_t i = 2864434397 ;
encoder.writeUint32(i);
// buffer == {0xdd, 0xcc, 0xbb, 0xaa}y luego en el frontend TTN, use el siguiente método:
uint32 ( input . bytes . slice ( x , x + 4 ) ) // 2864434397Serializa/deserializa una lectura de temperatura entre -327.68 y +327.67 (inclusive) con una precisión de 2 decimales.
# include " LoraEncoder.h "
byte buffer[ 2 ];
LoraEncoder encoder (buffer);
encoder.writeTemperature(- 123.45 );
// buffer == {0xcf, 0xc7}y luego en el frontend TTN, use el siguiente método:
temperature ( input . bytes . slice ( x , x + 2 ) ) // -123.45Serializa/deserializa una lectura de humedad entre 0 e 100 (inclusive) con una precisión de 2 decimales.
# include " LoraEncoder.h "
byte buffer[ 2 ];
LoraEncoder encoder (buffer);
encoder.writeHumidity( 99.99 );
// buffer == {0x0f, 0x27}y luego en el frontend TTN, use el siguiente método:
humidity ( input . bytes . slice ( x , x + 2 ) ) // 99.99Serializa/deserializa un flotador completo de 4 bytes.
# include " LoraEncoder.h "
byte buffer[ 4 ];
LoraEncoder encoder (buffer);
encoder.writeRawFloat( 99.99 );
// buffer == {0xe1, 0xfa, 0xc7, 0x42}y luego en el frontend TTN, use el siguiente método:
rawfloat ( input . bytes . slice ( x , x + 4 ) ) // 99.99Serializa/deserializa un mapa de bits que contiene entre 0 y 8 banderas diferentes.
# include " LoraEncoder.h "
byte buffer[ 1 ];
LoraEncoder encoder (buffer);
encoder.writeBitmap( true , false , false , false , false , false , false , false );
// buffer == {0x80}y luego en el frontend TTN, use el siguiente método:
bitmap ( input . bytes . slice ( x , x + 1 ) ) // { a: true, b: false, c: false, d: false, e: false, f: false, g: false, h: false } El decodificador le permite escribir más de un valor en una matriz de bytes:
# 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
}
*/ LoraMessageHay una clase de conveniencia que representa un Loramessage que puede agregar lecturas a:
# 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
*/decode El método decode le permite especificar una máscara para el búfer de bytes entrante (que fue generado por esta biblioteca) y aplicar las funciones de decodificación en consecuencia.
decode ( byte Array , mask Array [ , mapping Array ] ) Pegar todo, desde src/decoder.js en el método del decodificador y use así:
function ( bytes ) {
// code from src/decoder.js here
return decode ( bytes , [ latLng , unixtime ] , [ 'coords' , 'time' ] ) ;
} Esto mapea el tampón de bytes entrante de 12 bytes a una secuencia de una secuencia latLng (8 bytes) y una secuencia unixtime (4 bytes) y asigna la primera a una coords clave y la segunda a un time clave.
Puede usar: 64 A6 FA FD 6A 24 04 09 1D 4B 7A 57 para pruebas, y dará como resultado:
{
"coords" : [
-33.905052 ,
151.26641
],
"time" : 1467632413
}Configure su decodificador en la consola:
El método Decode ya realiza la mayoría de las transformaciones necesarias, por lo que en la mayoría de los casos puede pasar los datos a través de:
yarnyarn run test:cyarn testyarn coverage (ver coverage/lcov-report )El CI comenzará una vez que cree una solicitud de extracción automáticamente.
Agregue la dependencia lora-serialization al archivo main/idf_component.yml en su proyecto ESP-IDF:
dependencies:
lora-serialization:
git: https://github.com/thesolarnomad/lora-serialization.git
Así como a las main/CMakeLists.txt
idf_component_register( ...
REQUIRES .... lora-serialization
)
