/// <summary>
/// Prepare the Mac Commands to be sent in the downstream message.
/// </summary>
static ICollection <MacCommand> PrepareMacCommandAnswer(
string devEUI,
IEnumerable <MacCommand> requestedMacCommands,
IEnumerable <MacCommand> serverMacCommands,
Rxpk rxpk,
LoRaADRResult loRaADRResult)
{
var macCommands = new Dictionary <int, MacCommand>();
if (requestedMacCommands != null)
{
foreach (var requestedMacCommand in requestedMacCommands)
{
switch (requestedMacCommand.Cid)
{
case CidEnum.LinkCheckCmd:
{
if (rxpk != null)
{
var linkCheckAnswer = new LinkCheckAnswer(rxpk.GetModulationMargin(), 1);
if (macCommands.TryAdd((int)CidEnum.LinkCheckCmd, linkCheckAnswer))
{
Logger.Log(devEUI, $"answering to a MAC command request {linkCheckAnswer.ToString()}", LogLevel.Information);
}
}
break;
}
}
}
}
if (serverMacCommands != null)
{
foreach (var macCmd in serverMacCommands)
{
if (macCmd != null)
{
try
{
if (!macCommands.TryAdd((int)macCmd.Cid, macCmd))
{
Logger.Log(devEUI, $"could not send the cloud to device MAC command {macCmd.Cid}, as such a property was already present in the message. Please resend the cloud to device message", LogLevel.Error);
}
Logger.Log(devEUI, $"cloud to device MAC command {macCmd.Cid} received {macCmd}", LogLevel.Information);
}
catch (MacCommandException ex)
{
Logger.Log(devEUI, ex.ToString(), LogLevel.Error);
}
}
}
}
// ADR Part.
// Currently only replying on ADR Req
if (loRaADRResult?.CanConfirmToDevice == true)
{
const int placeholderChannel = 25;
LinkADRRequest linkADR = new LinkADRRequest((byte)loRaADRResult.DataRate, (byte)loRaADRResult.TxPower, placeholderChannel, 0, (byte)loRaADRResult.NbRepetition);
macCommands.Add((int)CidEnum.LinkADRCmd, linkADR);
Logger.Log(devEUI, $"performing a rate adaptation: DR {loRaADRResult.DataRate}, transmit power {loRaADRResult.TxPower}, #repetition {loRaADRResult.NbRepetition}", LogLevel.Information);
}
return(macCommands.Values);
}
public async Task Perform_NbRep_Adaptation_When_Needed()
{
uint deviceId = 31;
var currentDR = LoRaDataRate.SF8BW125;
var currentLsnr = -20;
var messageCount = 20;
uint payloadFcnt = 0;
const uint InitialDeviceFcntUp = 1;
const uint ExpectedDeviceFcntDown = 4;
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(deviceId, gatewayID: ServerConfiguration.GatewayID),
frmCntUp: InitialDeviceFcntUp);
var loraDevice = CreateLoRaDevice(simulatedDevice);
LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()))
.ReturnsAsync((Message)null);
var reportedNbRep = 0;
LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()))
.Callback <TwinCollection, CancellationToken>((t, _) =>
{
if (t.Contains(TwinProperty.NbRep))
{
reportedNbRep = (int)t[TwinProperty.NbRep];
}
})
.ReturnsAsync(true);
using var cache = EmptyMemoryCache();
using var loraDeviceCache = CreateDeviceCache(loraDevice);
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, cache, LoRaDeviceApi.Object, LoRaDeviceFactory, loraDeviceCache);
// Send to message processor
using var messageProcessor = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
payloadFcnt = await InitializeCacheToDefaultValuesAsync(payloadFcnt, simulatedDevice, messageProcessor);
// ****************************************************
// First part send messages with spaces in fcnt to simulate wrong network connectivity
// ****************************************************
// send a message with a fcnt every 4.
for (var i = 0; i < messageCount; i++)
{
payloadFcnt = await SendMessage(currentLsnr, currentDR, payloadFcnt + 3, simulatedDevice, messageProcessor, FrameControlFlags.Adr);
}
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrlFlags: FrameControlFlags.AdrAckReq | FrameControlFlags.Adr);
var radioMetadata = new RadioMetadata(TestUtils.TestRegion.GetDataRateIndex(currentDR), Hertz.Mega(868.1), new RadioMetadataUpInfo(0, 0, 0, 0, currentLsnr));
using var request = CreateWaitableRequest(radioMetadata, payload);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
// Expectations
// 1. Message was sent to IoT Hub
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
Assert.True(request.ProcessingSucceeded);
Assert.NotNull(request.ResponseDownlink);
Assert.Equal(2, DownstreamMessageSender.DownlinkMessages.Count);
var downlinkMessage = DownstreamMessageSender.DownlinkMessages[1];
var payloadDataDown = new LoRaPayloadData(downlinkMessage.Data);
// We expect a mac command in the payload
Assert.Equal(5, payloadDataDown.Frmpayload.Span.Length);
var decryptedPayload = payloadDataDown.Serialize(simulatedDevice.NwkSKey.Value);
Assert.Equal(FramePort.MacCommand, payloadDataDown.Fport);
Assert.Equal((byte)Cid.LinkADRCmd, decryptedPayload[0]);
var linkAdr = new LinkADRRequest(decryptedPayload);
Assert.Equal(3, reportedNbRep);
Assert.Equal(3, linkAdr.NbRep);
Assert.Equal(3, loraDevice.NbRep);
// ****************************************************
// Second part send normal messages to decrease NbRep
// ****************************************************
// send a message with a fcnt every 1
for (var i = 0; i < messageCount; i++)
{
payloadFcnt = await SendMessage(currentLsnr, currentDR, payloadFcnt, simulatedDevice, messageProcessor, FrameControlFlags.Adr);
}
payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrlFlags: FrameControlFlags.AdrAckReq | FrameControlFlags.Adr);
using var secondRequest = CreateWaitableRequest(radioMetadata, payload);
messageProcessor.DispatchRequest(secondRequest);
Assert.True(await secondRequest.WaitCompleteAsync());
// Expectations
// 1. Message was sent to IoT Hub
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
Assert.True(secondRequest.ProcessingSucceeded);
Assert.NotNull(secondRequest.ResponseDownlink);
Assert.Equal(3, DownstreamMessageSender.DownlinkMessages.Count);
downlinkMessage = DownstreamMessageSender.DownlinkMessages[2];
payloadDataDown = new LoRaPayloadData(downlinkMessage.Data);
// We expect a mac command in the payload
Assert.Equal(5, payloadDataDown.Frmpayload.Span.Length);
decryptedPayload = payloadDataDown.Serialize(simulatedDevice.NwkSKey.Value);
Assert.Equal(FramePort.MacCommand, payloadDataDown.Fport);
Assert.Equal((byte)Cid.LinkADRCmd, decryptedPayload[0]);
linkAdr = new LinkADRRequest(decryptedPayload);
Assert.Equal(2, reportedNbRep);
Assert.Equal(2, linkAdr.NbRep);
Assert.Equal(2, loraDevice.NbRep);
// in case no payload the mac is in the FRMPayload and is decrypted with NwkSKey
Assert.Equal(payloadDataDown.DevAddr, loraDevice.DevAddr);
Assert.False(payloadDataDown.IsConfirmed);
Assert.Equal(MacMessageType.UnconfirmedDataDown, payloadDataDown.MessageType);
// 4. Frame counter up was updated
Assert.Equal(payloadFcnt, loraDevice.FCntUp);
// ****************************************************
// Third part send normal messages to decrease NbRep to 1
// ****************************************************
// send a message with a fcnt every 1
for (var i = 0; i < messageCount; i++)
{
payloadFcnt = await SendMessage(currentLsnr, currentDR, payloadFcnt, simulatedDevice, messageProcessor, FrameControlFlags.Adr);
}
payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrlFlags: FrameControlFlags.AdrAckReq | FrameControlFlags.Adr);
using var thirdRequest = CreateWaitableRequest(radioMetadata, payload);
messageProcessor.DispatchRequest(thirdRequest);
Assert.True(await thirdRequest.WaitCompleteAsync());
// Expectations
// 1. Message was sent to IoT Hub
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
Assert.True(thirdRequest.ProcessingSucceeded);
Assert.NotNull(thirdRequest.ResponseDownlink);
Assert.Equal(4, DownstreamMessageSender.DownlinkMessages.Count);
downlinkMessage = DownstreamMessageSender.DownlinkMessages[3];
payloadDataDown = new LoRaPayloadData(downlinkMessage.Data);
// We expect a mac command in the payload
Assert.Equal(5, payloadDataDown.Frmpayload.Span.Length);
decryptedPayload = payloadDataDown.Serialize(simulatedDevice.NwkSKey.Value);
Assert.Equal(FramePort.MacCommand, payloadDataDown.Fport);
Assert.Equal((byte)Cid.LinkADRCmd, decryptedPayload[0]);
linkAdr = new LinkADRRequest(decryptedPayload);
Assert.Equal(1, reportedNbRep);
Assert.Equal(1, linkAdr.NbRep);
Assert.Equal(1, loraDevice.NbRep);
// 5. Frame counter down is updated
Assert.Equal(ExpectedDeviceFcntDown, loraDevice.FCntDown);
Assert.Equal(ExpectedDeviceFcntDown, payloadDataDown.Fcnt);
}
/// <summary>
/// Prepare the Mac Commands to be sent in the downstream message.
/// </summary>
private static ICollection <MacCommand> PrepareMacCommandAnswer(
IEnumerable <MacCommand> requestedMacCommands,
IEnumerable <MacCommand> serverMacCommands,
LoRaRequest loRaRequest,
LoRaADRResult loRaADRResult,
ILogger logger)
{
var cids = new HashSet <Cid>();
var macCommands = new List <MacCommand>();
if (requestedMacCommands != null)
{
foreach (var requestedMacCommand in requestedMacCommands)
{
switch (requestedMacCommand.Cid)
{
case Cid.LinkCheckCmd:
case Cid.Zero:
case Cid.One:
case Cid.LinkADRCmd:
if (loRaRequest != null)
{
var linkCheckAnswer = new LinkCheckAnswer(checked ((byte)loRaRequest.Region.GetModulationMargin(loRaRequest.RadioMetadata.DataRate, loRaRequest.RadioMetadata.UpInfo.SignalNoiseRatio)), 1);
if (cids.Add(Cid.LinkCheckCmd))
{
macCommands.Add(linkCheckAnswer);
logger.LogInformation($"answering to a MAC command request {linkCheckAnswer}");
}
}
break;
case Cid.DutyCycleCmd:
case Cid.RXParamCmd:
case Cid.DevStatusCmd:
case Cid.NewChannelCmd:
case Cid.RXTimingCmd:
case Cid.TxParamSetupCmd:
default:
break;
}
}
}
if (serverMacCommands != null)
{
foreach (var macCmd in serverMacCommands)
{
if (macCmd != null)
{
try
{
if (cids.Add(macCmd.Cid))
{
macCommands.Add(macCmd);
}
else
{
logger.LogError($"could not send the cloud to device MAC command {macCmd.Cid}, as such a property was already present in the message. Please resend the cloud to device message");
}
logger.LogInformation($"cloud to device MAC command {macCmd.Cid} received {macCmd}");
}
catch (MacCommandException ex) when(ExceptionFilterUtility.True(() => logger.LogError(ex.ToString())))
{
// continue
}
}
}
}
// ADR Part.
// Currently only replying on ADR Req
if (loRaADRResult?.CanConfirmToDevice == true)
{
const int placeholderChannel = 25;
var linkADR = new LinkADRRequest((byte)loRaADRResult.DataRate, (byte)loRaADRResult.TxPower, placeholderChannel, 0, (byte)loRaADRResult.NbRepetition);
macCommands.Add(linkADR);
logger.LogInformation($"performing a rate adaptation: DR {loRaADRResult.DataRate}, transmit power {loRaADRResult.TxPower}, #repetition {loRaADRResult.NbRepetition}");
}
return(macCommands);
}
public async Task Perform_TXPower_Adaptation_When_Needed()
{
uint deviceId = 44;
var messageCount = 21;
uint payloadFcnt = 0;
const uint InitialDeviceFcntUp = 9;
const uint InitialDeviceFcntDown = 0;
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(deviceId, gatewayID: ServerConfiguration.GatewayID),
frmCntUp: InitialDeviceFcntUp);
var loraDevice = CreateLoRaDevice(simulatedDevice);
LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()))
.ReturnsAsync((Message)null);
var reportedDR = DR0;
var reportedTxPower = 0;
LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()))
.Callback <TwinCollection, CancellationToken>((t, _) =>
{
if (t.Contains(TwinProperty.DataRate))
{
reportedDR = (DataRateIndex)(int)(object)t[TwinProperty.DataRate].Value;
}
if (t.Contains(TwinProperty.TxPower))
{
reportedTxPower = t[TwinProperty.TxPower].Value;
}
})
.ReturnsAsync(true);
using var cache = EmptyMemoryCache();
using var loraDeviceCache = CreateDeviceCache(loraDevice);
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, cache, LoRaDeviceApi.Object, LoRaDeviceFactory, loraDeviceCache);
// Send to message processor
using var messageProcessor = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
payloadFcnt = await InitializeCacheToDefaultValuesAsync(payloadFcnt, simulatedDevice, messageProcessor);
// ****************************************************
// First part gives very good connectivity and ensure we set power to minimum and DR increase to 5
// ****************************************************
// set to very good lsnr and DR3
float currentLsnr = 20;
var currentDR = LoRaDataRate.SF9BW125;
// todo add case without buffer
for (var i = 0; i < messageCount; i++)
{
payloadFcnt = await SendMessage(currentLsnr, currentDR, payloadFcnt, simulatedDevice, messageProcessor, FrameControlFlags.Adr);
}
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrlFlags: FrameControlFlags.AdrAckReq | FrameControlFlags.Adr);
var radioMetadata = new RadioMetadata(TestUtils.TestRegion.GetDataRateIndex(currentDR), Hertz.Mega(868.1), new RadioMetadataUpInfo(0, 0, 0, 0, currentLsnr));
using var request = CreateWaitableRequest(radioMetadata, payload);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
Assert.NotNull(request.ResponseDownlink);
Assert.Equal(2, DownstreamMessageSender.DownlinkMessages.Count);
var downlinkMessage = DownstreamMessageSender.DownlinkMessages[1];
var payloadDataDown = new LoRaPayloadData(downlinkMessage.Data);
// We expect a mac command in the payload
Assert.Equal(5, payloadDataDown.Frmpayload.Span.Length);
var decryptedPayload = payloadDataDown.Serialize(simulatedDevice.NwkSKey.Value);
Assert.Equal(FramePort.MacCommand, payloadDataDown.Fport);
Assert.Equal((byte)Cid.LinkADRCmd, decryptedPayload[0]);
var linkAdr = new LinkADRRequest(decryptedPayload);
Assert.Equal(DR5, linkAdr.DataRate);
Assert.Equal(DR5, loraDevice.DataRate);
Assert.Equal(DR5, reportedDR);
Assert.Equal(7, linkAdr.TxPower);
Assert.Equal(7, loraDevice.TxPower);
Assert.Equal(7, reportedTxPower);
Assert.Equal(payloadDataDown.DevAddr, loraDevice.DevAddr);
Assert.False(payloadDataDown.IsConfirmed);
Assert.Equal(MacMessageType.UnconfirmedDataDown, payloadDataDown.MessageType);
// 4. Frame counter up was updated
Assert.Equal(payloadFcnt, loraDevice.FCntUp);
// 5. Frame counter down is updated
Assert.Equal(InitialDeviceFcntDown + 1, loraDevice.FCntDown);
Assert.Equal(InitialDeviceFcntDown + 1, payloadDataDown.Fcnt);
// ****************************************************
// Second part reduce connectivity and verify the DR stay to 5 and power set to max
// ****************************************************
currentLsnr = -50;
// DR5
currentDR = LoRaDataRate.SF7BW125;
// todo add case without buffer
for (var i = 0; i < messageCount; i++)
{
payloadFcnt = await SendMessage(currentLsnr, currentDR, payloadFcnt, simulatedDevice, messageProcessor, FrameControlFlags.Adr);
}
payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrlFlags: FrameControlFlags.AdrAckReq | FrameControlFlags.Adr);
var radioMetadataWithDatr5 = new RadioMetadata(TestUtils.TestRegion.GetDataRateIndex(currentDR), Hertz.Mega(868.1), new RadioMetadataUpInfo(0, 0, 0, 0, currentLsnr));
using var secondRequest = CreateWaitableRequest(radioMetadataWithDatr5, payload);
messageProcessor.DispatchRequest(secondRequest);
Assert.True(await secondRequest.WaitCompleteAsync());
Assert.NotNull(secondRequest.ResponseDownlink);
Assert.Equal(3, DownstreamMessageSender.DownlinkMessages.Count);
downlinkMessage = DownstreamMessageSender.DownlinkMessages[2];
payloadDataDown = new LoRaPayloadData(downlinkMessage.Data);
// We expect a mac command in the payload
Assert.Equal(5, payloadDataDown.Frmpayload.Span.Length);
decryptedPayload = payloadDataDown.Serialize(simulatedDevice.NwkSKey.Value);
Assert.Equal(FramePort.MacCommand, payloadDataDown.Fport);
Assert.Equal((byte)Cid.LinkADRCmd, decryptedPayload[0]);
linkAdr = new LinkADRRequest(decryptedPayload);
Assert.Equal(DR5, linkAdr.DataRate);
Assert.Equal(DR5, loraDevice.DataRate);
Assert.Equal(DR5, reportedDR);
Assert.Equal(0, linkAdr.TxPower);
Assert.Equal(0, loraDevice.TxPower);
Assert.Equal(0, reportedTxPower);
Assert.Equal(payloadDataDown.DevAddr, loraDevice.DevAddr);
Assert.False(payloadDataDown.IsConfirmed);
Assert.Equal(MacMessageType.UnconfirmedDataDown, payloadDataDown.MessageType);
// 4. Frame counter up was updated
Assert.Equal(payloadFcnt, loraDevice.FCntUp);
// 5. Frame counter down is updated
Assert.Equal(InitialDeviceFcntDown + 2, loraDevice.FCntDown);
Assert.Equal(InitialDeviceFcntDown + 2, payloadDataDown.Fcnt);
// Expectations
// 1. Message was sent to IoT Hub
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
Assert.True(secondRequest.ProcessingSucceeded);
}
public async Task Perform_Rate_Adapatation_When_Possible(uint deviceId, int count, DataRateIndex expectedDR, int expectedTXPower, int expectedNbRep, uint initialDeviceFcntUp)
{
uint payloadFcnt = 0;
const uint InitialDeviceFcntDown = 0;
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(deviceId, gatewayID: ServerConfiguration.GatewayID),
frmCntUp: initialDeviceFcntUp);
var loraDevice = CreateLoRaDevice(simulatedDevice);
LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()))
.ReturnsAsync((Message)null);
LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
using var cache = EmptyMemoryCache();
using var loraDeviceCache = CreateDeviceCache(loraDevice);
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, cache, LoRaDeviceApi.Object, LoRaDeviceFactory, loraDeviceCache);
// Send to message processor
using var messageProcessor = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
// In this case we want to simulate a cache failure, so we don't initialize the cache.
if (deviceId != 12)
{
payloadFcnt = await InitializeCacheToDefaultValuesAsync(payloadFcnt, simulatedDevice, messageProcessor);
}
else
{
var payloadInt = simulatedDevice.CreateConfirmedDataUpMessage("1234", fcnt: payloadFcnt);
using var requestInt = CreateWaitableRequest(TestUtils.GenerateTestRadioMetadata(), payloadInt);
messageProcessor.DispatchRequest(requestInt);
Assert.True(await requestInt.WaitCompleteAsync(-1));
payloadFcnt++;
}
for (var i = 0; i < count; i++)
{
var payloadInt = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrlFlags: FrameControlFlags.Adr);
using var requestInt = CreateWaitableRequest(TestUtils.GenerateTestRadioMetadata(), payloadInt);
messageProcessor.DispatchRequest(requestInt);
Assert.True(await requestInt.WaitCompleteAsync(-1));
payloadFcnt++;
}
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrlFlags: FrameControlFlags.AdrAckReq | FrameControlFlags.Adr);
using var request = CreateWaitableRequest(TestUtils.GenerateTestRadioMetadata(), payload);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
// Expectations
// 1. Message was sent to IoT Hub
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
Assert.NotNull(request.ResponseDownlink);
Assert.True(request.ProcessingSucceeded);
Assert.Equal(2, DownstreamMessageSender.DownlinkMessages.Count);
var downlinkMessage = DownstreamMessageSender.DownlinkMessages[1];
var payloadDataDown = new LoRaPayloadData(downlinkMessage.Data);
// in this case we expect a null payload
if (deviceId == 11)
{
Assert.Equal(0, payloadDataDown.Frmpayload.Span.Length);
}
else
{
// We expect a mac command in the payload
Assert.Equal(5, payloadDataDown.Frmpayload.Span.Length);
var decryptedPayload = payloadDataDown.Serialize(simulatedDevice.NwkSKey.Value);
Assert.Equal(FramePort.MacCommand, payloadDataDown.Fport);
Assert.Equal((byte)Cid.LinkADRCmd, decryptedPayload[0]);
var linkAdr = new LinkADRRequest(decryptedPayload);
Assert.Equal(expectedDR, linkAdr.DataRate);
Assert.Equal(expectedDR, loraDevice.DataRate);
Assert.Equal(expectedTXPower, linkAdr.TxPower);
Assert.Equal(expectedTXPower, loraDevice.TxPower);
Assert.Equal(expectedNbRep, linkAdr.NbRep);
Assert.Equal(expectedNbRep, loraDevice.NbRep);
}
// in case no payload the mac is in the FRMPayload and is decrypted with NwkSKey
Assert.Equal(payloadDataDown.DevAddr, loraDevice.DevAddr);
Assert.False(payloadDataDown.IsConfirmed);
Assert.Equal(MacMessageType.UnconfirmedDataDown, payloadDataDown.MessageType);
// 4. Frame counter up was updated
Assert.Equal(payloadFcnt, loraDevice.FCntUp);
// 5. Frame counter down is updated
Assert.Equal(InitialDeviceFcntDown + 1, loraDevice.FCntDown);
Assert.Equal(InitialDeviceFcntDown + 1, payloadDataDown.Fcnt);
}
public async Task Perform_DR_Adaptation_When_Needed(uint deviceId, float currentLsnr, string currentDRString, DataRateIndex expectedDR, int expectedTxPower)
{
var currentDR = LoRaDataRate.Parse(currentDRString);
var messageCount = 21;
uint payloadFcnt = 0;
const uint InitialDeviceFcntUp = 9;
const uint ExpectedDeviceFcntDown = 0;
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(deviceId, gatewayID: ServerConfiguration.GatewayID),
frmCntUp: InitialDeviceFcntUp);
var loraDevice = CreateLoRaDevice(simulatedDevice);
LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()))
.ReturnsAsync((Message)null);
var twinDR = DR0;
var twinTxPower = 0;
LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>(), It.IsAny <CancellationToken>()))
.Callback <TwinCollection, CancellationToken>((t, _) =>
{
if (t.Contains(TwinProperty.DataRate))
{
twinDR = t[TwinProperty.DataRate];
}
if (t.Contains(TwinProperty.TxPower))
{
twinTxPower = (int)t[TwinProperty.TxPower];
}
})
.ReturnsAsync(true);
using var cache = EmptyMemoryCache();
using var loraDeviceCache = CreateDeviceCache(loraDevice);
using var deviceRegistry = new LoRaDeviceRegistry(ServerConfiguration, cache, LoRaDeviceApi.Object, LoRaDeviceFactory, loraDeviceCache);
// Send to message processor
using var messageProcessor = new MessageDispatcher(
ServerConfiguration,
deviceRegistry,
FrameCounterUpdateStrategyProvider);
payloadFcnt = await InitializeCacheToDefaultValuesAsync(payloadFcnt, simulatedDevice, messageProcessor);
for (var i = 0; i < messageCount; i++)
{
payloadFcnt = await SendMessage(currentLsnr, currentDR, payloadFcnt, simulatedDevice, messageProcessor, FrameControlFlags.Adr);
}
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrlFlags: FrameControlFlags.AdrAckReq | FrameControlFlags.Adr);
var radioMetadata = new RadioMetadata(TestUtils.TestRegion.GetDataRateIndex(currentDR), Hertz.Mega(868.1), new RadioMetadataUpInfo(0, 0, 0, 0, currentLsnr));
using var request = CreateWaitableRequest(radioMetadata, payload);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
// Expectations
// 1. Message was sent to IoT Hub
LoRaDeviceClient.VerifyAll();
LoRaDeviceApi.VerifyAll();
Assert.True(request.ProcessingSucceeded);
Assert.NotNull(request.ResponseDownlink);
var downlinkMessage = DownstreamMessageSender.DownlinkMessages[1];
var payloadDataDown = new LoRaPayloadData(downlinkMessage.Data);
// We expect a mac command in the payload
if (deviceId == 221)
{
// In this case, no ADR adaptation is performed, so the message should be empty
Assert.Equal(0, payloadDataDown.Frmpayload.Span.Length);
Assert.Equal(0, payloadDataDown.Fopts.Span.Length);
}
else
{
Assert.Equal(5, payloadDataDown.Frmpayload.Span.Length);
var decryptedPayload = payloadDataDown.Serialize(simulatedDevice.NwkSKey.Value);
Assert.Equal(FramePort.MacCommand, payloadDataDown.Fport);
Assert.Equal((byte)Cid.LinkADRCmd, decryptedPayload[0]);
var linkAdr = new LinkADRRequest(decryptedPayload);
Assert.Equal(expectedDR, linkAdr.DataRate);
Assert.Equal(expectedDR, loraDevice.DataRate);
Assert.Equal(expectedDR, twinDR);
Assert.Equal(expectedTxPower, linkAdr.TxPower);
Assert.Equal(expectedTxPower, loraDevice.TxPower);
Assert.Equal(expectedTxPower, twinTxPower);
// in case no payload the mac is in the FRMPayload and is decrypted with NwkSKey
Assert.Equal(payloadDataDown.DevAddr, loraDevice.DevAddr);
Assert.False(payloadDataDown.IsConfirmed);
Assert.Equal(MacMessageType.UnconfirmedDataDown, payloadDataDown.MessageType);
// 4. Frame counter up was updated
Assert.Equal(payloadFcnt, loraDevice.FCntUp);
// 5. Frame counter down is updated
Assert.Equal(ExpectedDeviceFcntDown + 1, loraDevice.FCntDown);
Assert.Equal(ExpectedDeviceFcntDown + 1, payloadDataDown.Fcnt);
}
}
public async Task Perform_NbRep_Adaptation_When_Needed()
{
uint deviceId = 31;
string currentDR = "SF8BW125";
int currentLsnr = -20;
int messageCount = 20;
uint payloadFcnt = 0;
const uint InitialDeviceFcntUp = 1;
const uint ExpectedDeviceFcntDown = 4;
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(deviceId, gatewayID: this.ServerConfiguration.GatewayID),
frmCntUp: InitialDeviceFcntUp);
var loraDevice = this.CreateLoRaDevice(simulatedDevice);
this.LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
this.LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()))
.ReturnsAsync((Message)null);
int reportedNbRep = 0;
this.LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>()))
.Callback <TwinCollection>((t) =>
{
if (t.Contains(TwinProperty.NbRep))
{
reportedNbRep = (int)t[TwinProperty.NbRep];
}
})
.ReturnsAsync(true);
var deviceRegistry = new LoRaDeviceRegistry(this.ServerConfiguration, this.NewNonEmptyCache(loraDevice), this.LoRaDeviceApi.Object, this.LoRaDeviceFactory);
// Send to message processor
var messageProcessor = new MessageDispatcher(
this.ServerConfiguration,
deviceRegistry,
this.FrameCounterUpdateStrategyProvider);
payloadFcnt = await this.InitializeCacheToDefaultValuesAsync(payloadFcnt, simulatedDevice, messageProcessor);
// ****************************************************
// First part send messages with spaces in fcnt to simulate wrong network connectivity
// ****************************************************
// send a message with a fcnt every 4.
for (int i = 0; i < messageCount; i++)
{
payloadFcnt = await this.SendMessage(currentLsnr, currentDR, payloadFcnt + 3, simulatedDevice, messageProcessor, (byte)((int)LoRaTools.LoRaMessage.FctrlEnum.ADR));
}
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrl: (byte)((int)LoRaTools.LoRaMessage.FctrlEnum.ADRAckReq + (int)LoRaTools.LoRaMessage.FctrlEnum.ADR));
var rxpk = payload.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey, lsnr: currentLsnr, datr: currentDR).Rxpk[0];
var request = this.CreateWaitableRequest(rxpk);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
// Expectations
// 1. Message was sent to IoT Hub
this.LoRaDeviceClient.VerifyAll();
this.LoRaDeviceApi.VerifyAll();
Assert.True(request.ProcessingSucceeded);
Assert.NotNull(request.ResponseDownlink);
Assert.Equal(2, this.PacketForwarder.DownlinkMessages.Count);
var downlinkMessage = this.PacketForwarder.DownlinkMessages[1];
var payloadDataDown = new LoRaPayloadData(Convert.FromBase64String(downlinkMessage.Txpk.Data));
// We expect a mac command in the payload
Assert.Equal(5, payloadDataDown.Frmpayload.Span.Length);
var decryptedPayload = payloadDataDown.PerformEncryption(simulatedDevice.NwkSKey);
Array.Reverse(decryptedPayload);
Assert.Equal(0, payloadDataDown.Fport.Span[0]);
Assert.Equal((byte)CidEnum.LinkADRCmd, decryptedPayload[0]);
var linkAdr = new LinkADRRequest(decryptedPayload);
Assert.Equal(3, reportedNbRep);
Assert.Equal(3, linkAdr.NbRep);
Assert.Equal(3, loraDevice.NbRep);
// ****************************************************
// Second part send normal messages to decrease NbRep
// ****************************************************
// send a message with a fcnt every 1
for (int i = 0; i < messageCount; i++)
{
payloadFcnt = await this.SendMessage(currentLsnr, currentDR, payloadFcnt, simulatedDevice, messageProcessor, (byte)((int)LoRaTools.LoRaMessage.FctrlEnum.ADR));
}
payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrl: (byte)((int)LoRaTools.LoRaMessage.FctrlEnum.ADRAckReq + (int)LoRaTools.LoRaMessage.FctrlEnum.ADR));
rxpk = payload.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey, lsnr: currentLsnr, datr: currentDR).Rxpk[0];
request = this.CreateWaitableRequest(rxpk);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
// Expectations
// 1. Message was sent to IoT Hub
this.LoRaDeviceClient.VerifyAll();
this.LoRaDeviceApi.VerifyAll();
Assert.True(request.ProcessingSucceeded);
Assert.NotNull(request.ResponseDownlink);
Assert.Equal(3, this.PacketForwarder.DownlinkMessages.Count);
downlinkMessage = this.PacketForwarder.DownlinkMessages[2];
payloadDataDown = new LoRaPayloadData(Convert.FromBase64String(downlinkMessage.Txpk.Data));
// We expect a mac command in the payload
Assert.Equal(5, payloadDataDown.Frmpayload.Span.Length);
decryptedPayload = payloadDataDown.PerformEncryption(simulatedDevice.NwkSKey);
Assert.Equal(0, payloadDataDown.Fport.Span[0]);
Assert.Equal((byte)CidEnum.LinkADRCmd, decryptedPayload[0]);
linkAdr = new LinkADRRequest(decryptedPayload);
Assert.Equal(2, reportedNbRep);
Assert.Equal(2, linkAdr.NbRep);
Assert.Equal(2, loraDevice.NbRep);
// in case no payload the mac is in the FRMPayload and is decrypted with NwkSKey
Assert.Equal(payloadDataDown.DevAddr.ToArray(), LoRaTools.Utils.ConversionHelper.StringToByteArray(loraDevice.DevAddr));
Assert.False(payloadDataDown.IsConfirmed);
Assert.Equal(LoRaMessageType.UnconfirmedDataDown, payloadDataDown.LoRaMessageType);
// 4. Frame counter up was updated
Assert.Equal(payloadFcnt, loraDevice.FCntUp);
// ****************************************************
// Third part send normal messages to decrease NbRep to 1
// ****************************************************
// send a message with a fcnt every 1
for (int i = 0; i < messageCount; i++)
{
payloadFcnt = await this.SendMessage(currentLsnr, currentDR, payloadFcnt, simulatedDevice, messageProcessor, (byte)((int)LoRaTools.LoRaMessage.FctrlEnum.ADR));
}
payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrl: (byte)((int)LoRaTools.LoRaMessage.FctrlEnum.ADRAckReq + (int)LoRaTools.LoRaMessage.FctrlEnum.ADR));
rxpk = payload.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey, lsnr: currentLsnr, datr: currentDR).Rxpk[0];
request = this.CreateWaitableRequest(rxpk);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
// Expectations
// 1. Message was sent to IoT Hub
this.LoRaDeviceClient.VerifyAll();
this.LoRaDeviceApi.VerifyAll();
Assert.True(request.ProcessingSucceeded);
Assert.NotNull(request.ResponseDownlink);
Assert.Equal(4, this.PacketForwarder.DownlinkMessages.Count);
downlinkMessage = this.PacketForwarder.DownlinkMessages[3];
payloadDataDown = new LoRaPayloadData(Convert.FromBase64String(downlinkMessage.Txpk.Data));
// We expect a mac command in the payload
Assert.Equal(5, payloadDataDown.Frmpayload.Span.Length);
decryptedPayload = payloadDataDown.PerformEncryption(simulatedDevice.NwkSKey);
Assert.Equal(0, payloadDataDown.Fport.Span[0]);
Assert.Equal((byte)CidEnum.LinkADRCmd, decryptedPayload[0]);
linkAdr = new LinkADRRequest(decryptedPayload);
Assert.Equal(1, reportedNbRep);
Assert.Equal(1, linkAdr.NbRep);
Assert.Equal(1, loraDevice.NbRep);
// 5. Frame counter down is updated
Assert.Equal(ExpectedDeviceFcntDown, loraDevice.FCntDown);
Assert.Equal(ExpectedDeviceFcntDown, payloadDataDown.GetFcnt());
}
public async Task Perform_Rate_Adapatation_When_Possible(uint deviceId, int count, int expectedDR, int expectedTXPower, int expectedNbRep, uint initialDeviceFcntUp)
{
uint payloadFcnt = 0;
const uint InitialDeviceFcntDown = 0;
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(deviceId, gatewayID: this.ServerConfiguration.GatewayID),
frmCntUp: initialDeviceFcntUp);
var loraDevice = this.CreateLoRaDevice(simulatedDevice);
this.LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
this.LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()))
.ReturnsAsync((Message)null);
this.LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>()))
.ReturnsAsync(true);
var deviceRegistry = new LoRaDeviceRegistry(this.ServerConfiguration, this.NewNonEmptyCache(loraDevice), this.LoRaDeviceApi.Object, this.LoRaDeviceFactory);
// Send to message processor
var messageProcessor = new MessageDispatcher(
this.ServerConfiguration,
deviceRegistry,
this.FrameCounterUpdateStrategyProvider);
// In this case we want to simulate a cache failure, so we don't initialize the cache.
if (deviceId != 12)
{
payloadFcnt = await this.InitializeCacheToDefaultValuesAsync(payloadFcnt, simulatedDevice, messageProcessor);
}
else
{
var payloadInt = simulatedDevice.CreateConfirmedDataUpMessage("1234", fcnt: payloadFcnt);
var rxpkInt = payloadInt.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey).Rxpk[0];
var requestInt = this.CreateWaitableRequest(rxpkInt);
messageProcessor.DispatchRequest(requestInt);
Assert.True(await requestInt.WaitCompleteAsync(-1));
payloadFcnt++;
}
for (int i = 0; i < count; i++)
{
var payloadInt = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrl: (byte)((int)LoRaTools.LoRaMessage.FctrlEnum.ADR));
var rxpkInt = payloadInt.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey).Rxpk[0];
var requestInt = this.CreateWaitableRequest(rxpkInt);
messageProcessor.DispatchRequest(requestInt);
Assert.True(await requestInt.WaitCompleteAsync(-1));
payloadFcnt++;
}
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrl: (byte)((int)LoRaTools.LoRaMessage.FctrlEnum.ADRAckReq + (int)LoRaTools.LoRaMessage.FctrlEnum.ADR));
var rxpk = payload.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey).Rxpk[0];
var request = this.CreateWaitableRequest(rxpk);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
// Expectations
// 1. Message was sent to IoT Hub
this.LoRaDeviceClient.VerifyAll();
this.LoRaDeviceApi.VerifyAll();
Assert.NotNull(request.ResponseDownlink);
Assert.True(request.ProcessingSucceeded);
Assert.Equal(2, this.PacketForwarder.DownlinkMessages.Count);
var downlinkMessage = this.PacketForwarder.DownlinkMessages[1];
var payloadDataDown = new LoRaPayloadData(Convert.FromBase64String(downlinkMessage.Txpk.Data));
// in this case we expect a null payload
if (deviceId == 11)
{
Assert.Equal(0, payloadDataDown.Frmpayload.Span.Length);
}
else
{
// We expect a mac command in the payload
Assert.Equal(5, payloadDataDown.Frmpayload.Span.Length);
var decryptedPayload = payloadDataDown.PerformEncryption(simulatedDevice.NwkSKey);
Assert.Equal(0, payloadDataDown.Fport.Span[0]);
Assert.Equal((byte)CidEnum.LinkADRCmd, decryptedPayload[0]);
var linkAdr = new LinkADRRequest(decryptedPayload);
Assert.Equal(expectedDR, linkAdr.DataRate);
Assert.Equal(expectedDR, loraDevice.DataRate);
Assert.Equal(expectedTXPower, linkAdr.TxPower);
Assert.Equal(expectedTXPower, loraDevice.TxPower);
Assert.Equal(expectedNbRep, linkAdr.NbRep);
Assert.Equal(expectedNbRep, loraDevice.NbRep);
}
// in case no payload the mac is in the FRMPayload and is decrypted with NwkSKey
Assert.Equal(payloadDataDown.DevAddr.ToArray(), LoRaTools.Utils.ConversionHelper.StringToByteArray(loraDevice.DevAddr));
Assert.False(payloadDataDown.IsConfirmed);
Assert.Equal(LoRaMessageType.UnconfirmedDataDown, payloadDataDown.LoRaMessageType);
// 4. Frame counter up was updated
Assert.Equal(payloadFcnt, loraDevice.FCntUp);
// 5. Frame counter down is updated
Assert.Equal(InitialDeviceFcntDown + 1, loraDevice.FCntDown);
Assert.Equal(InitialDeviceFcntDown + 1, payloadDataDown.GetFcnt());
}
public async Task Perform_TXPower_Adaptation_When_Needed()
{
uint deviceId = 44;
int messageCount = 21;
uint payloadFcnt = 0;
const uint InitialDeviceFcntUp = 9;
const uint InitialDeviceFcntDown = 0;
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(deviceId, gatewayID: this.ServerConfiguration.GatewayID),
frmCntUp: InitialDeviceFcntUp);
var loraDevice = this.CreateLoRaDevice(simulatedDevice);
this.LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
this.LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()))
.ReturnsAsync((Message)null);
int reportedDR = 0;
int reportedTxPower = 0;
this.LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>()))
.Callback <TwinCollection>((t) =>
{
if (t.Contains(TwinProperty.DataRate))
{
reportedDR = t[TwinProperty.DataRate].Value;
}
if (t.Contains(TwinProperty.TxPower))
{
reportedTxPower = t[TwinProperty.TxPower].Value;
}
})
.ReturnsAsync(true);
var deviceRegistry = new LoRaDeviceRegistry(this.ServerConfiguration, this.NewNonEmptyCache(loraDevice), this.LoRaDeviceApi.Object, this.LoRaDeviceFactory);
// Send to message processor
var messageProcessor = new MessageDispatcher(
this.ServerConfiguration,
deviceRegistry,
this.FrameCounterUpdateStrategyProvider);
payloadFcnt = await this.InitializeCacheToDefaultValuesAsync(payloadFcnt, simulatedDevice, messageProcessor);
// ****************************************************
// First part gives very good connectivity and ensure we set power to minimum and DR increase to 5
// ****************************************************
// set to very good lsnr and DR3
float currentLsnr = 20;
string currentDR = "SF9BW125";
// todo add case without buffer
for (int i = 0; i < messageCount; i++)
{
payloadFcnt = await this.SendMessage(currentLsnr, currentDR, payloadFcnt, simulatedDevice, messageProcessor, (byte)((int)LoRaTools.LoRaMessage.FctrlEnum.ADR));
}
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrl: (byte)((int)LoRaTools.LoRaMessage.FctrlEnum.ADRAckReq + (int)LoRaTools.LoRaMessage.FctrlEnum.ADR));
var rxpk = payload.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey, lsnr: currentLsnr, datr: currentDR).Rxpk[0];
var request = this.CreateWaitableRequest(rxpk);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
Assert.NotNull(request.ResponseDownlink);
Assert.Equal(2, this.PacketForwarder.DownlinkMessages.Count);
var downlinkMessage = this.PacketForwarder.DownlinkMessages[1];
var payloadDataDown = new LoRaPayloadData(Convert.FromBase64String(downlinkMessage.Txpk.Data));
// We expect a mac command in the payload
Assert.Equal(5, payloadDataDown.Frmpayload.Span.Length);
var decryptedPayload = payloadDataDown.PerformEncryption(simulatedDevice.NwkSKey);
Assert.Equal(0, payloadDataDown.Fport.Span[0]);
Assert.Equal((byte)CidEnum.LinkADRCmd, decryptedPayload[0]);
var linkAdr = new LinkADRRequest(decryptedPayload);
Assert.Equal(5, linkAdr.DataRate);
Assert.Equal(5, loraDevice.DataRate);
Assert.Equal(5, reportedDR);
Assert.Equal(7, linkAdr.TxPower);
Assert.Equal(7, loraDevice.TxPower);
Assert.Equal(7, reportedTxPower);
Assert.Equal(payloadDataDown.DevAddr.ToArray(), LoRaTools.Utils.ConversionHelper.StringToByteArray(loraDevice.DevAddr));
Assert.False(payloadDataDown.IsConfirmed);
Assert.Equal(LoRaMessageType.UnconfirmedDataDown, payloadDataDown.LoRaMessageType);
// 4. Frame counter up was updated
Assert.Equal(payloadFcnt, loraDevice.FCntUp);
// 5. Frame counter down is updated
Assert.Equal(InitialDeviceFcntDown + 1, loraDevice.FCntDown);
Assert.Equal(InitialDeviceFcntDown + 1, payloadDataDown.GetFcnt());
// ****************************************************
// Second part reduce connectivity and verify the DR stay to 5 and power set to max
// ****************************************************
currentLsnr = -50;
// DR5
currentDR = "SF7BW125";
// todo add case without buffer
for (int i = 0; i < messageCount; i++)
{
payloadFcnt = await this.SendMessage(currentLsnr, currentDR, payloadFcnt, simulatedDevice, messageProcessor, (byte)((int)LoRaTools.LoRaMessage.FctrlEnum.ADR));
}
payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrl: (byte)((int)LoRaTools.LoRaMessage.FctrlEnum.ADRAckReq + (int)LoRaTools.LoRaMessage.FctrlEnum.ADR));
rxpk = payload.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey, lsnr: currentLsnr, datr: currentDR).Rxpk[0];
request = this.CreateWaitableRequest(rxpk);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
Assert.NotNull(request.ResponseDownlink);
Assert.Equal(3, this.PacketForwarder.DownlinkMessages.Count);
downlinkMessage = this.PacketForwarder.DownlinkMessages[2];
payloadDataDown = new LoRaPayloadData(Convert.FromBase64String(downlinkMessage.Txpk.Data));
// We expect a mac command in the payload
Assert.Equal(5, payloadDataDown.Frmpayload.Span.Length);
decryptedPayload = payloadDataDown.PerformEncryption(simulatedDevice.NwkSKey);
Assert.Equal(0, payloadDataDown.Fport.Span[0]);
Assert.Equal((byte)CidEnum.LinkADRCmd, decryptedPayload[0]);
linkAdr = new LinkADRRequest(decryptedPayload);
Assert.Equal(5, linkAdr.DataRate);
Assert.Equal(5, loraDevice.DataRate);
Assert.Equal(5, reportedDR);
Assert.Equal(0, linkAdr.TxPower);
Assert.Equal(0, loraDevice.TxPower);
Assert.Equal(0, reportedTxPower);
Assert.Equal(payloadDataDown.DevAddr.ToArray(), LoRaTools.Utils.ConversionHelper.StringToByteArray(loraDevice.DevAddr));
Assert.False(payloadDataDown.IsConfirmed);
Assert.Equal(LoRaMessageType.UnconfirmedDataDown, payloadDataDown.LoRaMessageType);
// 4. Frame counter up was updated
Assert.Equal(payloadFcnt, loraDevice.FCntUp);
// 5. Frame counter down is updated
Assert.Equal(InitialDeviceFcntDown + 2, loraDevice.FCntDown);
Assert.Equal(InitialDeviceFcntDown + 2, payloadDataDown.GetFcnt());
// Expectations
// 1. Message was sent to IoT Hub
this.LoRaDeviceClient.VerifyAll();
this.LoRaDeviceApi.VerifyAll();
Assert.True(request.ProcessingSucceeded);
}
public async Task Perform_DR_Adaptation_When_Needed(uint deviceId, float currentLsnr, string currentDR, int expectedDR, int expectedTxPower)
{
int messageCount = 21;
uint payloadFcnt = 0;
const uint InitialDeviceFcntUp = 9;
const uint ExpectedDeviceFcntDown = 0;
var simulatedDevice = new SimulatedDevice(
TestDeviceInfo.CreateABPDevice(deviceId, gatewayID: this.ServerConfiguration.GatewayID),
frmCntUp: InitialDeviceFcntUp);
var loraDevice = this.CreateLoRaDevice(simulatedDevice);
this.LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null))
.ReturnsAsync(true);
this.LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>()))
.ReturnsAsync((Message)null);
int twinDR = 0;
int twinTxPower = 0;
this.LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>()))
.Callback <TwinCollection>((t) =>
{
if (t.Contains(TwinProperty.DataRate))
{
twinDR = t[TwinProperty.DataRate];
}
if (t.Contains(TwinProperty.TxPower))
{
twinTxPower = (int)t[TwinProperty.TxPower];
}
})
.ReturnsAsync(true);
var deviceRegistry = new LoRaDeviceRegistry(this.ServerConfiguration, this.NewNonEmptyCache(loraDevice), this.LoRaDeviceApi.Object, this.LoRaDeviceFactory);
// Send to message processor
var messageProcessor = new MessageDispatcher(
this.ServerConfiguration,
deviceRegistry,
this.FrameCounterUpdateStrategyProvider);
payloadFcnt = await this.InitializeCacheToDefaultValuesAsync(payloadFcnt, simulatedDevice, messageProcessor);
for (int i = 0; i < messageCount; i++)
{
payloadFcnt = await this.SendMessage(currentLsnr, currentDR, payloadFcnt, simulatedDevice, messageProcessor, (byte)((int)LoRaTools.LoRaMessage.FctrlEnum.ADR));
}
var payload = simulatedDevice.CreateUnconfirmedDataUpMessage("1234", fcnt: payloadFcnt, fctrl: (byte)((int)LoRaTools.LoRaMessage.FctrlEnum.ADRAckReq + (int)LoRaTools.LoRaMessage.FctrlEnum.ADR));
var rxpk = payload.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey, lsnr: currentLsnr, datr: currentDR).Rxpk[0];
var request = this.CreateWaitableRequest(rxpk);
messageProcessor.DispatchRequest(request);
Assert.True(await request.WaitCompleteAsync());
// Expectations
// 1. Message was sent to IoT Hub
this.LoRaDeviceClient.VerifyAll();
this.LoRaDeviceApi.VerifyAll();
Assert.True(request.ProcessingSucceeded);
Assert.NotNull(request.ResponseDownlink);
var downlinkMessage = this.PacketForwarder.DownlinkMessages[1];
var payloadDataDown = new LoRaPayloadData(Convert.FromBase64String(downlinkMessage.Txpk.Data));
// We expect a mac command in the payload
if (deviceId == 221)
{
// In this case, no ADR adaptation is performed, so the message should be empty
Assert.Equal(0, payloadDataDown.Frmpayload.Span.Length);
Assert.Equal(0, payloadDataDown.Fopts.Span.Length);
}
else
{
Assert.Equal(5, payloadDataDown.Frmpayload.Span.Length);
var decryptedPayload = payloadDataDown.PerformEncryption(simulatedDevice.NwkSKey);
Assert.Equal(0, payloadDataDown.Fport.Span[0]);
Assert.Equal((byte)CidEnum.LinkADRCmd, decryptedPayload[0]);
var linkAdr = new LinkADRRequest(decryptedPayload);
Assert.Equal(expectedDR, linkAdr.DataRate);
Assert.Equal(expectedDR, loraDevice.DataRate);
Assert.Equal(expectedDR, twinDR);
Assert.Equal(expectedTxPower, linkAdr.TxPower);
Assert.Equal(expectedTxPower, loraDevice.TxPower);
Assert.Equal(expectedTxPower, twinTxPower);
// in case no payload the mac is in the FRMPayload and is decrypted with NwkSKey
Assert.Equal(payloadDataDown.DevAddr.ToArray(), LoRaTools.Utils.ConversionHelper.StringToByteArray(loraDevice.DevAddr));
Assert.False(payloadDataDown.IsConfirmed);
Assert.Equal(LoRaMessageType.UnconfirmedDataDown, payloadDataDown.LoRaMessageType);
// 4. Frame counter up was updated
Assert.Equal(payloadFcnt, loraDevice.FCntUp);
// 5. Frame counter down is updated
Assert.Equal(ExpectedDeviceFcntDown + 1, loraDevice.FCntDown);
Assert.Equal(ExpectedDeviceFcntDown + 1, payloadDataDown.GetFcnt());
}
}
