public async Task processMessage(byte[] message, string connectionString)
{
LoRaMessage loraMessage = new LoRaMessage(message);
if (!loraMessage.processed)
{
Console.WriteLine($"Skip message Reason: Processed attribyte eq 'False'");
}
else
{
Console.WriteLine($"Processing message from device: {BitConverter.ToString(loraMessage.payloadMessage.devAddr)}");
Shared.loraKeysList.TryGetValue(BitConverter.ToString(loraMessage.payloadMessage.devAddr), out LoraKeys loraKeys);
if (loraMessage.CheckMic(testKey))
{
string decryptedMessage = null;
try
{
decryptedMessage = loraMessage.DecryptPayload(testKey);
}
catch (Exception ex)
{
Console.WriteLine($"Failed to decrypt message: {ex.Message}");
}
if (string.IsNullOrEmpty(decryptedMessage))
{
return;
}
Console.WriteLine($"Sending message '{decryptedMessage}' to hub...");
int hubSendCounter = 1;
while (HubRetryCount != hubSendCounter)
{
try
{
sender = new IoTHubSender(connectionString, testDeviceId);
await sender.sendMessage(decryptedMessage);
hubSendCounter = HubRetryCount;
}
catch (Exception ex)
{
Console.WriteLine($"Failed to send message: {ex.Message}");
hubSendCounter++;
}
}
}
else
{
Console.WriteLine("Check MIC failed! Message will be ignored...");
}
}
}
static void Main(string[] args)
{
byte[] leadingByte = StringToByteArray("0205DB00AA555A0000000101");
string inputJson = "{\"rxpk\":[{\"tmst\":3121882787,\"chan\":2,\"rfch\":1,\"freq\":868.500000,\"stat\":1,\"modu\":\"LORA\",\"datr\":\"SF7BW125\",\"codr\":\"4/5\",\"lsnr\":7.0,\"rssi\":-16,\"size\":20,\"data\":\"QEa5KACANwAIXiRAODD6gSCHMSk=\"}]}";
byte[] messageraw = leadingByte.Concat(Encoding.Default.GetBytes(inputJson)).ToArray();
LoRaMessage message = new LoRaMessage(messageraw);
Console.WriteLine("decrypted " + (message.DecryptPayload("2B7E151628AED2A6ABF7158809CF4F3C")));
Console.WriteLine("mic is valid: " + message.CheckMic("2B7E151628AED2A6ABF7158809CF4F3C"));
Console.Read();
}
static void Main(string[] args)
{
//Section testing different kind of decryption.
byte[] leadingByte = StringToByteArray("0205DB00AA555A0000000101");
string inputJson = "{\"rxpk\":[{\"tmst\":3121882787,\"chan\":2,\"rfch\":1,\"freq\":868.500000,\"stat\":1,\"modu\":\"LORA\",\"datr\":\"SF7BW125\",\"codr\":\"4/5\",\"lsnr\":7.0,\"rssi\":-16,\"size\":20,\"data\":\"QEa5KACANwAIXiRAODD6gSCHMSk=\"}]}";
byte[] messageraw = leadingByte.Concat(Encoding.Default.GetBytes(inputJson)).ToArray();
LoRaMessage message = new LoRaMessage(messageraw);
Console.WriteLine("decrypted " + (message.DecryptPayload("2B7E151628AED2A6ABF7158809CF4F3C")));
Console.WriteLine("mic is valid: " + message.CheckMic("2B7E151628AED2A6ABF7158809CF4F3C"));
// join message
string joinInputJson = "{\"rxpk\":[{\"tmst\":286781788,\"chan\":0,\"rfch\":1,\"freq\":868.100000,\"stat\":1,\"modu\":\"LORA\",\"datr\":\"SF12BW125\",\"codr\":\"4/5\",\"lsnr\":11.0,\"rssi\":-17,\"size\":23,\"data\":\"AEZIZ25pc2lSj4gAAAAAer5VEV5aL4c=\"}]}";
//byte[] joinBytes = StringToByteArray("00DC0000D07ED5B3701E6FEDF57CEEAF00C886030AF2C9");
byte[] messageJoinraw = leadingByte.Concat(Encoding.Default.GetBytes(joinInputJson)).ToArray();
LoRaMessage joinMessage = new LoRaMessage(messageJoinraw);
//Console.WriteLine("decrypted " + (joinMessage.DecryptPayload("2B7E151628AED2A6ABF7158809CF4F3C")));
Console.WriteLine("mic is valid: " + joinMessage.CheckMic("2B7E151628AED2A6ABF7158809CF4F3C"));
////section building up a low level message for the concentrator
// LoRaPayloadJoinAccept joinAcceptPayload = new LoRaPayloadJoinAccept("FF08F5", "2B7E151628AED2A6ABF7158809CF4F3C", StringToByteArray("00000000"));
//var tmp = joinAcceptPayload.getFinalMessage(Encoding.Default.GetBytes("1234"));
// Console.WriteLine(Convert.ToBase64String(tmp));
// listener.Send(tmp, tmp.Length);
////Section running the server to monitor LoRaWan messages, working for upling msg
//UdpServer udp = new UdpServer();
// udp.RunServer(true);
//Console.Read();
////Section testing correct build up of message, NOT WORKING
//LoRaPayloadJoinAccept joinAccept = new LoRaPayloadJoinAccept("FF08F5", "2B7E151628AED2A6ABF7158809CF4F3C", StringToByteArray("00000000"));
//LoRaMessage message = new LoRaMessage(joinAccept, LoRaMessageType.JoinAccept, new byte[] { 0x01 });
//Console.Write(message.loraMetadata.rawB64data);
//Console.Write(message.physicalPayload);
//Console.Read();
Console.Read();
Console.Read();
}
private async Task <byte[]> ProcessLoraMessage(LoRaMessage loraMessage)
{
bool validFrameCounter = false;
byte[] udpMsgForPktForwarder = new byte[0];
string devAddr = BitConverter.ToString(loraMessage.payloadMessage.devAddr).Replace("-", "");
Message c2dMsg = null;
Cache.TryGetValue(devAddr, out LoraDeviceInfo loraDeviceInfo);
if (loraDeviceInfo == null)
{
loraDeviceInfo = await LoraDeviceInfoManager.GetLoraDeviceInfoAsync(devAddr);
Logger.Log(loraDeviceInfo.DevEUI, $"processing message, device not in cache", Logger.LoggingLevel.Info);
Cache.AddToCache(devAddr, loraDeviceInfo);
}
else
{
Logger.Log(loraDeviceInfo.DevEUI, $"processing message, device in cache", Logger.LoggingLevel.Info);
}
if (loraDeviceInfo.IsOurDevice)
{
//either there is no gateway linked to the device or the gateway is the one that the code is running
if (String.IsNullOrEmpty(loraDeviceInfo.GatewayID) || loraDeviceInfo.GatewayID.ToUpper() == GatewayID.ToUpper())
{
if (loraMessage.CheckMic(loraDeviceInfo.NwkSKey))
{
if (loraDeviceInfo.HubSender == null)
{
loraDeviceInfo.HubSender = new IoTHubSender(loraDeviceInfo.DevEUI, loraDeviceInfo.PrimaryKey);
}
UInt16 fcntup = BitConverter.ToUInt16(((LoRaPayloadStandardData)loraMessage.payloadMessage).fcnt, 0);
//check if the frame counter is valid: either is above the server one or is an ABP device resetting the counter (relaxed seqno checking)
if (fcntup > loraDeviceInfo.FCntUp || (fcntup == 1 && String.IsNullOrEmpty(loraDeviceInfo.AppEUI)))
{
//save the reset fcnt for ABP (relaxed seqno checking)
if (fcntup == 1 && String.IsNullOrEmpty(loraDeviceInfo.AppEUI))
{
_ = loraDeviceInfo.HubSender.UpdateFcntAsync(fcntup, 0, true);
}
validFrameCounter = true;
Logger.Log(loraDeviceInfo.DevEUI, $"valid frame counter, msg: {fcntup} server: {loraDeviceInfo.FCntUp}", Logger.LoggingLevel.Info);
byte[] decryptedMessage = null;
try
{
decryptedMessage = loraMessage.DecryptPayload(loraDeviceInfo.AppSKey);
}
catch (Exception ex)
{
Logger.Log(loraDeviceInfo.DevEUI, $"failed to decrypt message: {ex.Message}", Logger.LoggingLevel.Error);
}
Rxpk rxPk = ((UplinkPktFwdMessage)loraMessage.loraMetadata.fullPayload).rxpk[0];
dynamic fullPayload = JObject.FromObject(rxPk);
string jsonDataPayload = "";
uint fportUp = (uint)((LoRaPayloadStandardData)loraMessage.payloadMessage).fport[0];
fullPayload.port = fportUp;
fullPayload.fcnt = fcntup;
if (String.IsNullOrEmpty(loraDeviceInfo.SensorDecoder))
{
jsonDataPayload = Convert.ToBase64String(decryptedMessage);
fullPayload.data = jsonDataPayload;
}
else
{
Logger.Log(loraDeviceInfo.DevEUI, $"decoding with: {loraDeviceInfo.SensorDecoder} port: {fportUp}", Logger.LoggingLevel.Info);
jsonDataPayload = LoraDecoders.DecodeMessage(decryptedMessage, fportUp, loraDeviceInfo.SensorDecoder);
fullPayload.data = JObject.Parse(jsonDataPayload);
}
fullPayload.eui = loraDeviceInfo.DevEUI;
fullPayload.gatewayid = GatewayID;
//todo check what the other ts are if milliseconds or seconds
fullPayload.edgets = (long)((startTimeProcessing - new DateTime(1970, 1, 1)).TotalMilliseconds);
string iotHubMsg = fullPayload.ToString(Newtonsoft.Json.Formatting.None);
await loraDeviceInfo.HubSender.SendMessageAsync(iotHubMsg);
Logger.Log(loraDeviceInfo.DevEUI, $"sent message '{jsonDataPayload}' to hub", Logger.LoggingLevel.Info);
loraDeviceInfo.FCntUp = fcntup;
}
else
{
validFrameCounter = false;
Logger.Log(loraDeviceInfo.DevEUI, $"invalid frame counter, msg: {fcntup} server: {loraDeviceInfo.FCntUp}", Logger.LoggingLevel.Info);
}
//start checking for new c2d message, we do it even if the fcnt is invalid so we support replying to the ConfirmedDataUp
//todo ronnie should we wait up to 900 msec?
c2dMsg = await loraDeviceInfo.HubSender.ReceiveAsync(TimeSpan.FromMilliseconds(20));
byte[] bytesC2dMsg = null;
byte[] fport = null;
byte[] fctl = new byte[1] {
32
};
//check if we got a c2d message to be added in the ack message and preprare the message
if (c2dMsg != null)
{
//check if there is another message
var secondC2dMsg = await loraDeviceInfo.HubSender.ReceiveAsync(TimeSpan.FromMilliseconds(20));
if (secondC2dMsg != null)
{
//put it back to the queue for the next pickup
_ = loraDeviceInfo.HubSender.AbandonAsync(secondC2dMsg);
//set the fpending flag so the lora device will call us back for the next message
fctl = new byte[1] {
48
};
}
bytesC2dMsg = c2dMsg.GetBytes();
fport = new byte[1] {
1
};
if (bytesC2dMsg != null)
{
Logger.Log(loraDeviceInfo.DevEUI, $"C2D message: {Encoding.UTF8.GetString(bytesC2dMsg)}", Logger.LoggingLevel.Info);
}
//todo ronnie implement a better max payload size by datarate
//cut to the max payload of lora for any EU datarate
if (bytesC2dMsg.Length > 51)
{
Array.Resize(ref bytesC2dMsg, 51);
}
Array.Reverse(bytesC2dMsg);
}
//if confirmation or cloud to device msg send down the message
if (loraMessage.loRaMessageType == LoRaMessageType.ConfirmedDataUp || c2dMsg != null)
{
//check if we are not too late for the 1 and 2 window
if (((DateTime.UtcNow - startTimeProcessing) <= TimeSpan.FromMilliseconds(1900)))
{
//increase the fcnt down and save it to iot hub twins
loraDeviceInfo.FCntDown++;
Logger.Log(loraDeviceInfo.DevEUI, $"down frame counter: {loraDeviceInfo.FCntDown}", Logger.LoggingLevel.Info);
//Saving both fcnts to twins
_ = loraDeviceInfo.HubSender.UpdateFcntAsync(loraDeviceInfo.FCntUp, loraDeviceInfo.FCntDown);
var _datr = ((UplinkPktFwdMessage)loraMessage.loraMetadata.fullPayload).rxpk[0].datr;
uint _rfch = ((UplinkPktFwdMessage)loraMessage.loraMetadata.fullPayload).rxpk[0].rfch;
double _freq = ((UplinkPktFwdMessage)loraMessage.loraMetadata.fullPayload).rxpk[0].freq;
uint txDelay = 0;
//if we are already longer than 900 mssecond move to the 2 second window
//uncomment to force second windows usage
//Thread.Sleep(901);
if ((DateTime.UtcNow - startTimeProcessing) > TimeSpan.FromMilliseconds(900))
{
if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("RX2_DATR")))
{
Logger.Log(loraDeviceInfo.DevEUI, $"using standard second receive windows", Logger.LoggingLevel.Info);
//using EU fix DR for RX2
_freq = 869.525;
_datr = "SF12BW125";
}
//if specific twins are set, specify second channel to be as specified
else
{
_freq = double.Parse(Environment.GetEnvironmentVariable("RX2_FREQ"));
_datr = Environment.GetEnvironmentVariable("RX2_DATR");
Logger.Log(loraDeviceInfo.DevEUI, $"using custom DR second receive windows freq : {_freq}, datr:{_datr}", Logger.LoggingLevel.Info);
}
txDelay = 1000000;
}
long _tmst = ((UplinkPktFwdMessage)loraMessage.loraMetadata.fullPayload).rxpk[0].tmst + txDelay;
Byte[] devAddrCorrect = new byte[4];
Array.Copy(loraMessage.payloadMessage.devAddr, devAddrCorrect, 4);
Array.Reverse(devAddrCorrect);
//todo mik check what is the A0
LoRaPayloadStandardData ackLoRaMessage = new LoRaPayloadStandardData(StringToByteArray("A0"),
devAddrCorrect,
fctl,
BitConverter.GetBytes(loraDeviceInfo.FCntDown),
null,
fport,
bytesC2dMsg,
1);
ackLoRaMessage.PerformEncryption(loraDeviceInfo.AppSKey);
ackLoRaMessage.SetMic(loraDeviceInfo.NwkSKey);
byte[] rndToken = new byte[2];
Random rnd = new Random();
rnd.NextBytes(rndToken);
//todo ronnie should check the device twin preference if using confirmed or unconfirmed down
LoRaMessage ackMessage = new LoRaMessage(ackLoRaMessage, LoRaMessageType.ConfirmedDataDown, rndToken, _datr, 0, _freq, _tmst);
udpMsgForPktForwarder = ackMessage.physicalPayload.GetMessage();
//confirm the message to iot hub only if we are in time for a delivery
if (c2dMsg != null)
{
_ = loraDeviceInfo.HubSender.CompleteAsync(c2dMsg);
Logger.Log(loraDeviceInfo.DevEUI, $"complete the c2d msg to IoT Hub", Logger.LoggingLevel.Info);
}
}
else
{
PhysicalPayload pushAck = new PhysicalPayload(loraMessage.physicalPayload.token, PhysicalIdentifier.PUSH_ACK, null);
udpMsgForPktForwarder = pushAck.GetMessage();
_ = loraDeviceInfo.HubSender.UpdateFcntAsync(loraDeviceInfo.FCntUp, null);
//put back the c2d message to the queue for the next round
_ = loraDeviceInfo.HubSender.AbandonAsync(c2dMsg);
Logger.Log(loraDeviceInfo.DevEUI, $"too late for down message, sending only ACK to gateway", Logger.LoggingLevel.Info);
}
}
//No ack requested and no c2d message we send the udp ack only to the gateway
else if (loraMessage.loRaMessageType == LoRaMessageType.UnconfirmedDataUp && c2dMsg == null)
{
PhysicalPayload pushAck = new PhysicalPayload(loraMessage.physicalPayload.token, PhysicalIdentifier.PUSH_ACK, null);
udpMsgForPktForwarder = pushAck.GetMessage();
if (validFrameCounter)
{
_ = loraDeviceInfo.HubSender.UpdateFcntAsync(loraDeviceInfo.FCntUp, null);
}
}
}
else
{
Logger.Log(loraDeviceInfo.DevEUI, $"with devAddr {devAddr} check MIC failed. Device will be ignored from now on", Logger.LoggingLevel.Info);
loraDeviceInfo.IsOurDevice = false;
}
}
else
{
Logger.Log(loraDeviceInfo.DevEUI, $"ignore message because is not linked to this GatewayID", Logger.LoggingLevel.Info);
}
}
else
{
Logger.Log(devAddr, $"device with devAddr {devAddr} is not our device, ignore message", Logger.LoggingLevel.Info);
}
Logger.Log(loraDeviceInfo.DevEUI, $"processing time: {DateTime.UtcNow - startTimeProcessing}", Logger.LoggingLevel.Info);
return(udpMsgForPktForwarder);
}
