mirror
/
esp32-ogn-tracker
kopia lustrzana https://github.com/pjalocha/esp32-ogn-tracker
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
esp32-ogn-tracker/main/lorawan.h

339 wiersze
17 KiB
C++
Czysty Bezpośredni odnośnik Wina Historia

#ifndef __LORAWAN_H__
#define __LORAWAN_H__
#include <stdint.h>
#ifdef WITH_ESP32
#include "nvs.h"
#endif
#include "LoRaMacCrypto.h"
#include "rfm.h"
class LoRaWANnode
{ public:
static const uint8_t Chans = 8;
static const size_t UsedBytes = 112; // [bytes] actually used
static const size_t SaveBytes = 128; // [bytes] round up and including CRC32
static const size_t SaveWords = SaveBytes/4;
union
{ uint8_t Byte[SaveBytes];
uint32_t Word[SaveWords];
struct
{ uint64_t AppEUI; // from application registration: Application identification
uint8_t AppKey[16]; // from device registration: application encryption/decryption key
uint64_t DevEUI; // Device identification (MAC)
uint32_t DevNonce; // unique counter kept by the device for Join-Requests
// the four items above need to be kept stored permanently per each device
// the other elements below are obtained when join-accept is received from the LoRaWAN network
uint8_t NetSesKey[16]; // from Join-Accept: Network Session Key
uint8_t AppSesKey[16]; // from Join-Accept: App Session Key
uint32_t JoinNonce; // from Join-Accept: unique must not be reused
uint32_t HomeNetID; // from Join-Accept: Home Network ID
uint32_t DevAddr; // from Join-Accept: Device Address
uint8_t DLsetting; // from Join-Accept: DownLink configuration: OptNeg:1 | RX1 data rate offset:3 | RX2 data rate:4
uint8_t RxDelay; // from Join-Accept: RFU:4 | Del:4 Del=1..15s for the RX1, RX2 delay is Del+1
uint8_t State; // 0:disconencted, 1:join-request sent, 2:join-accept received, 3:uplink-packet sent
uint8_t Chan; // [0..7] Current channel being used
uint32_t UpCount; // [seq] Uplink frame counter: reset when joining the network
uint32_t DnCount; // [seq] Downlink frame counter: reset when joining the network
uint32_t TxCount; // [packets] transmitted to the network
uint32_t LastTx; // [sec] last transmission
uint32_t RxCount; // [packets] received from the network
uint32_t LastRx; // [sec] when last heard from the network
int8_t RxSNR; // [0.25dB] SNR on receive (can be negative)
int8_t RxRSSI; // [dBm] signal strength
union
{ uint8_t Flags;
struct
{ bool RxACK :1; // received ACK
bool TxACK :1; // ACK to be transmitted
bool RxPend:1; // more frames pending for reception
bool Enable:1; // Enable/disable operation
bool SaveReq:1; // Request to save the node state
} ;
} ;
uint8_t RxSilent; // count non-receptions <- 112 bytes up to (and including) this point
uint32_t LastSaved; // [sec] when saved to EEPROM or other permament storage
uint8_t Dummy[8]; // just to fill up the space, could be used later
uint32_t CRC32; // 128 bytes up to here: fits into 1kbit EEPROM
} ;
} ;
// uint8_t TxMAC[16];
// uint8_t TxMACs;
static const size_t MaxPacketSize = 63; // [bytes]
uint8_t Packet[MaxPacketSize]; // generic packet for storage/processing
uint8_t TxBattLevel; // battery level to be transmitted in the DevStatusAns
uint8_t TxOptLen;
uint8_t TxOpt[15]; // MAC commands/options to be transmitted
public:
LoRaWANnode() { Reset(); TxOptLen=0; TxBattLevel=0xFF; }
void Reset(void)
{ State=0; DevNonce=0; JoinNonce=0;
LastTx=0; TxCount=0; LastRx=0; RxCount=0; RxSilent=0; Flags=0; LastSaved=0;
setCRC(); }
void Reset(uint64_t MAC, uint8_t *NewKey=0)
{ AppEUI=0x70B3D57ED0035895; // set OGN application
DevEUI=MAC; // set DevEUI from MAC
if(NewKey) memcpy(AppKey, NewKey, 16); // set the AppKey
Reset(); } // reset to not-joined state
void Disconnect(void)
{ State=0; RxSilent=0; }
uint32_t calcCRC(void) const
{ uint32_t Sum=0x87654321; // start the sum with some magic
for(size_t Idx=0; Idx<SaveWords; Idx++)
Sum+=Word[Idx]; // sum all the Words
return Sum; } // return the Sum
bool goodCRC(void) const { return calcCRC()==0; }
void setCRC(void) { CRC32=0; CRC32 = CRC32-calcCRC(); }
uint8_t incrChan(uint8_t Step=1)
{ Chan+=Step; if(Chan>=Chans) Chan-=Chans; return Chan; }
int Save(FILE *File) { return fwrite(this, sizeof(LoRaWANnode), 1, File); } // save to a file
int Save(const char *FileName) // save to a file
{ FILE *File=fopen(FileName, "wb"); if(File==0) return 0;
int Written=Save(File); fclose(File); return Written; }
// int Restore(FILE *File) { return fread(this, sizeof(LoRaWANnode), 1, File); }
// int Restore(const char *FileName)
// { FILE *File=fopen(FileName, "rb"); if(File==0) return 0;
// int Read=Restore(File); fclose(File); return Read; }
static int ReadHex(uint8_t *Data, int Len, const char *Inp) // read Len bytes from a hex string
{ int Bytes=0;
for( ; Bytes<Len; )
{ int8_t H = Read_Hex1(*Inp++); if(H<0) break;
int8_t L = Read_Hex1(*Inp++); if(L<0) break;
Data[Bytes++] = (H<<4) | L; }
return Bytes; }
// int readAppEUI(const char *Inp) { return ReadHex(&AppEUI, 8, Inp); }
int readAppKey(const char *Inp) { return ReadHex(AppKey,16, Inp); } // read key from the hex string
// int readDevEUI(const char *Inp) { return ReadHex(&DevEUI, 8, Inp); }
template<class Type>
static Type readInt(const uint8_t *Inp, int Len=sizeof(Type))
{ int Idx=Len-1;
Type Value = Inp[Idx];
for( ; Idx>0; )
{ Idx--; Value<<=8; Value|=Inp[Idx]; }
return Value; }
template<class Type>
static int writeInt(uint8_t *Out, Type Value, int Len=sizeof(Type), bool Rev=0)
{ if(Rev)
{ for( int Idx=Len; Idx>0; )
{ Out[--Idx] = Value; Value>>=8; }
}
else
{ for(int Idx=0; Idx<Len; )
{ Out[Idx++] = Value; Value>>=8; }
}
return Len; }
int getJoinRequest(uint8_t *Req)
{ Req[0] = 0x00; // MHDR, Join-Request: 000 000 00
memcpy(Req+1, &AppEUI, 8); // AppEUI
memcpy(Req+9, &DevEUI, 8); // DevEUI
DevNonce++; // increment DevNonce for a new request
Req[17] = DevNonce; // DevNonce
Req[18] = DevNonce>>8;
uint32_t MIC=0;
LoRaMacJoinComputeMic(Req, 19, AppKey, &MIC); // compute MIC
memcpy(Req+19, &MIC, 4); // append MIC
State=1; // State: Join-Request sent
return 23; } // 23 bytes packet length
int getJoinRequest(uint8_t **Req) { int Len=getJoinRequest(Packet); *Req = Packet; return Len; }
int procJoinAccept(const RFM_LoRa_RxPacket &RxPacket)
{ int Ret=procJoinAccept(RxPacket.Byte, RxPacket.Len); if(Ret<0) return Ret;
RxSNR = RxPacket.SNR; // store the SNR of the join-accept
RxRSSI = RxPacket.RSSI; // store the RSSI
return Ret; }
int procJoinAccept(const uint8_t *PktData, int PktLen) // process Join-Accept packet (5sec after Join-Request)
{ if(PktLen<13) return -1;
uint8_t Type = PktData[0]>>5; if(Type!=1) return -1;
Packet[0] = PktData[0];
LoRaMacJoinDecrypt(PktData+1, PktLen-1, AppKey, Packet+1); // decrypt the Join-Accept packet
uint32_t MIC=0;
LoRaMacJoinComputeMic(Packet, PktLen-4, AppKey, &MIC); // Compute MIC
if(memcmp( Packet+PktLen-4, &MIC, 4)) return -1; // Compare with the packet
LoRaMacJoinComputeSKeys(AppKey, Packet+1, DevNonce, NetSesKey, AppSesKey); // derive Network Session and Application Session keys
JoinNonce = readInt<uint32_t>(Packet+1, 3); // this should be not smaller than the previous one
HomeNetID = readInt<uint32_t>(Packet+4, 3);
DevAddr = readInt<uint32_t>(Packet+7, 4);
DLsetting = Packet[11];
RxDelay = Packet[12];
State = 2; // State = accepted on network
UpCount = 0;
DnCount = 0xFFFFFFFF;
TxOptLen = 0;
#ifdef WITH_PRINTF
printf("Accept[%d] ", PktLen-4);
for(int Idx=0; Idx<PktLen-4; Idx++)
printf("%02X", Packet[Idx]);
printf(" HomeNetID:%06X, DevAddr:%08X, DL:%02X, RxDelay:%02X\n", HomeNetID, DevAddr, DLsetting, RxDelay);
printf("NetSesKey: "); PrintHex(NetSesKey, 16); printf("\n");
printf("AppSesKey: "); PrintHex(AppSesKey, 16); printf("\n");
#endif
return 0; }
int getDataPacket(uint8_t *Packet, const uint8_t *Data, int DataLen, uint8_t Port=1, bool Confirm=0)
{ if(State<2) return 0; // not joined to the network yet
uint8_t Type = Confirm?0x04:0x02; // request confirmation or not ?
int PktLen=0;
Packet[PktLen++] = Type<<5; // packet-type
PktLen+=writeInt(Packet+PktLen, DevAddr, 4); // Device Address
uint8_t Ctrl=0x00; // Frame Control
if(TxACK) { Ctrl|=0x20; TxACK=0; } // if there is ACK to be transmitted
Packet[PktLen++] = Ctrl | TxOptLen; // Frame Control: ADR | ADR-ACK-Req | ACK | ClassB | FOptsLen[4]
PktLen+=writeInt(Packet+PktLen, UpCount, 2); // uplink frame counter
for(int Idx=0; Idx<TxOptLen; Idx++) // add options, MAC replies
Packet[PktLen++]=TxOpt[Idx];
TxOptLen=0;
Packet[PktLen++] = Port; // port
LoRaMacPayloadEncrypt(Data, DataLen, AppSesKey, DevAddr, 0, UpCount, Packet+PktLen); PktLen+=DataLen; // copy+encrypt user data
uint32_t MIC=0;
LoRaMacComputeMic(Packet, PktLen, NetSesKey, DevAddr, 0x00, UpCount, &MIC); // calc. MIC
// uint8_t MIC2[4];
// Tiny.Calculate_MIC(Packet, MIC2, PktLen, UpCount, 0x00);
// printf("Data packet MIC: %08X <=> %02X%02X%02X%02X\n", MIC, MIC2[3], MIC2[2], MIC2[1], MIC2[0]);
memcpy(Packet+PktLen, &MIC, 4); PktLen+=4; // append MIC
UpCount++; State=3; return PktLen; } // return the packet size
int getDataPacket(uint8_t **Pkt, const uint8_t *Data, int DataLen, uint8_t Port=1, bool Confirm=0)
{ int Len=getDataPacket(Packet, Data, DataLen, Port, Confirm); *Pkt = Packet; return Len; }
int procRxData(const RFM_LoRa_RxPacket &RxPacket)
{ int Ret=procRxData(RxPacket.Byte, RxPacket.Len); if(Ret<0) return Ret;
RxSNR += (RxPacket.SNR-RxSNR+1)/2; // average the SNR
RxRSSI += (RxPacket.RSSI-RxRSSI+1)/2; // average the RSSI
return Ret; }
int procRxData(const uint8_t *PktData, int PktLen)
{ if(PktLen<12) return -1;
uint8_t Type = PktData[0]>>5; // Frame Type
if(Type!=3 && Type!=5) return -1; // Frame Type: 3=unconfirmed data downlink, 5=confirmed data downlink
uint32_t Addr=readInt<uint32_t>(PktData+1, 4); // device address
if(Addr!=DevAddr) return 0; // check if packet is for us (it could be for somebody else)
uint8_t Ctrl = PktData[5]; // Frame Control: ADR | RFU | ACK | FPending | FOptLen[4]
uint32_t Count = readInt<uint32_t>(PktData+6, 2); // download counter
int16_t CountDiff = Count-DnCount; // how many we have missed ?
if(CountDiff<=0) return -1; // attempt to reuse the counter: drop this packet
uint32_t MIC=0;
LoRaMacComputeMic(PktData, PktLen-4, NetSesKey, Addr, 0x01, Count, &MIC);
// printf("RxData: %08X\n", MIC);
if(memcmp(PktData+PktLen-4, &MIC, 4)) return -1; // give up if MIC does not match
uint8_t OptLen = Ctrl&0x0F; // Options: how many bytes
uint8_t DataOfs = 8 + OptLen; // where the port byte should be
if(OptLen) procRxOpt(PktData+8, OptLen); // process the options (these are not encrypted)
uint8_t DataLen = PktLen-DataOfs-4; // number of bytes of the user data field
if(DataLen) // if non-zero
{ Packet[0] = PktData[DataOfs]; // copy port number
LoRaMacPayloadDecrypt(PktData+DataOfs+1, DataLen-1, AppSesKey, Addr, 0x01, Count, Packet+1); } // decrypt and copy the user data
#ifdef WITH_PRINTF
printf("RxData: [%d] ", DataLen);
for(int Idx=0; Idx<DataLen; Idx++)
printf("%02X", Packet[Idx]);
printf("\n");
#endif
DnCount += CountDiff; // update the download sequence counter
if(Ctrl&0x40) RxACK=1; // we got ACK to our ACK request
if(Type==5) TxACK=1; // if ACK requested
RxPend = Ctrl&0x10; // is there more data pending to be received on next round ?
State=2;
// if(DataLen==0)
// { Packet[0]=0x00; DataLen++; // copy MAC commands to user buffer for debug
// for(uint8_t Idx=0; Idx<OptLen; Idx++)
// { Packet[DataLen++] = PktData[8+Idx]; }
// }
return DataLen; }
void procRxOpt(const uint8_t *Opt, uint8_t OptLen) // process the options
{ if(OptLen==0) return;
for(uint8_t Idx=0; Idx<OptLen; Idx++)
{ uint8_t Cmd=Opt[Idx];
if(Cmd==0x03) // LinkADRReq
{ TxOpt[TxOptLen++]=0x03; // LinkADRAns
TxOpt[TxOptLen++]=0x00; // negative 0x00 or positive 0x07 on all requested changes ?
Idx+=4; continue; } // skip the actual data for this command
if(Cmd==0x06) // DevStatusReq
{ TxOpt[TxOptLen++]=0x06; // DevStatusAns
TxOpt[TxOptLen++]=TxBattLevel; // battery level: 0=ext. power, 1..254=level, 255=not available
TxOpt[TxOptLen++]=(RxSNR>>2)&0x3F; // Rx SNR
continue; }
break; }
// #ifdef WITH_PRINTF
printf("RxOpt: [%d] ", OptLen);
for(int Idx=0; Idx<OptLen; Idx++)
printf("%02X", Opt[Idx]);
printf(" => [%d] ", TxOptLen);
for(int Idx=0; Idx<TxOptLen; Idx++)
printf("%02X", TxOpt[Idx]);
printf("\n");
// #endif
}
// { Format_String(CONS_UART_Write, "LoRaWAN Opt: ");
// for(uint8_t Idx=0; Idx<Len; Idx++)
// Format_Hex(CONS_UART_Write, Opt[Idx]);
// Format_String(CONS_UART_Write, "\n"); }
int WriteToFile(const char *Name)
{ FILE *File = fopen(Name, "wb"); if(File==0) return -1;
int Written = fwrite(this, 1, SaveBytes, File);
fclose(File); return Written; }
int ReadFromFile(const char *Name)
{ FILE *File = fopen(Name, "rb"); if(File==0) return -1;
int Read = fread(this, 1, SaveBytes, File);
fclose(File); return Read; }
#ifdef WITH_ESP32
esp_err_t WriteToNVS(const char *Name="LoRaWAN", const char *NameSpace="TRACKER")
{ nvs_handle Handle;
esp_err_t Err = nvs_open(NameSpace, NVS_READWRITE, &Handle);
if(Err!=ESP_OK) return Err;
Err = nvs_set_blob(Handle, Name, this, SaveBytes);
if(Err==ESP_OK) Err = nvs_commit(Handle);
nvs_close(Handle);
return Err; }
esp_err_t ReadFromNVS(const char *Name="LoRaWAN", const char *NameSpace="TRACKER")
{ nvs_handle Handle;
esp_err_t Err = nvs_open(NameSpace, NVS_READWRITE, &Handle);
if(Err!=ESP_OK) return Err;
size_t Size=0;
Err = nvs_get_blob(Handle, Name, 0, &Size); // get the Size of the blob in the Flash
if( (Err==ESP_OK) && (Size<=SaveBytes) )
Err = nvs_get_blob(Handle, Name, this, &Size); // read the Blob from the Flash
nvs_close(Handle);
return Err; }
#endif // WITH_ESP32
#ifdef RTLSDR_API
int Read(RTLSDR &SDR) { return SDR.readEEPROM(Byte, 0x80, SaveBytes); }
int Write(RTLSDR &SDR) { return SDR.writeEEPROM(Byte, 0x80, SaveBytes); }
#endif
bool isFF(void)
{ for(size_t Idx=0; Idx<SaveBytes; Idx++)
{ if(Byte[Idx]!=0xFF) return 0; }
return 1; }
} ;
#endif // __LORAWAN_H__
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik