public async Task Test_OTAA_Confirmed_And_Unconfirmed_Message()
{
const int MESSAGES_COUNT = 10;
var device = this.TestFixture.Device4_OTAA;
LogTestStart(device);
await this.ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWOTAA);
await this.ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, device.AppEUI);
await this.ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, device.AppKey);
await this.ArduinoDevice.SetupLora(this.TestFixture.Configuration.LoraRegion);
var joinSucceeded = await this.ArduinoDevice.setOTAAJoinAsyncWithRetry(LoRaArduinoSerial._otaa_join_cmd_t.JOIN, 20000, 5);
Assert.True(joinSucceeded, "Join failed");
// wait 1 second after joined
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_JOIN);
// Sends 10x unconfirmed messages
for (var i = 0; i < MESSAGES_COUNT; ++i)
{
Console.WriteLine($"Starting sending OTTA unconfirmed message {i+1}/{MESSAGES_COUNT}");
this.TestFixture.ClearLogs();
var msg = PayloadGenerator.Next().ToString();
await this.ArduinoDevice.transferPacketAsync(msg, 10);
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_SENDING_PACKET);
// After transferPacket: Expectation from serial
// +MSG: Done
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", this.ArduinoDevice.SerialLogs);
// 0000000000000004: valid frame counter, msg: 1 server: 0
await this.TestFixture.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: valid frame counter, msg:");
// 0000000000000004: decoding with: DecoderValueSensor port: 8
await this.TestFixture.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000004: message '{"value": 51}' sent to hub
await this.TestFixture.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
// Ensure device payload is available
// Data: {"value": 51}
var expectedPayload = $"{{\"value\":{msg}}}";
await this.TestFixture.AssertIoTHubDeviceMessageExistsAsync(device.DeviceID, expectedPayload);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
}
// Sends 10x confirmed messages
for (var i = 0; i < MESSAGES_COUNT; ++i)
{
Console.WriteLine($"Starting sending OTTA confirmed message {i+1}/{MESSAGES_COUNT}");
this.TestFixture.ClearLogs();
var msg = PayloadGenerator.Next().ToString();
await this.ArduinoDevice.transferPacketWithConfirmedAsync(msg, 10);
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_SENDING_PACKET);
// After transferPacketWithConfirmed: Expectation from serial
// +CMSG: ACK Received
await AssertUtils.ContainsWithRetriesAsync("+CMSG: ACK Received", this.ArduinoDevice.SerialLogs);
// 0000000000000004: decoding with: DecoderValueSensor port: 8
await this.TestFixture.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000004: message '{"value": 51}' sent to hub
await this.TestFixture.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
// Ensure device payload is available
// Data: {"value": 51}
var expectedPayload = $"{{\"value\":{msg}}}";
await this.TestFixture.AssertIoTHubDeviceMessageExistsAsync(device.DeviceID, expectedPayload);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
}
}
public async Task Test_OTAA_Join_Send_And_Rejoin_With_Custom_RX2_DR()
{
var device = this.TestFixtureCi.Device20_OTAA;
this.LogTestStart(device);
await this.ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWOTAA);
await this.ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, device.AppEUI);
await this.ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, device.AppKey);
await this.ArduinoDevice.SetupLora(this.TestFixtureCi.Configuration.LoraRegion);
var joinSucceeded = await this.ArduinoDevice.setOTAAJoinAsyncWithRetry(LoRaArduinoSerial._otaa_join_cmd_t.JOIN, 20000, 5);
Assert.True(joinSucceeded, "Join failed");
// wait 1 second after joined
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_JOIN);
// Sends 10x unconfirmed messages
this.TestFixtureCi.ClearLogs();
var msg = PayloadGenerator.Next().ToString();
await this.ArduinoDevice.transferPacketAsync(msg, 10);
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_SENDING_PACKET);
// After transferPacket: Expectation from serial
// +MSG: Done
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", this.ArduinoDevice.SerialLogs);
// 0000000000000004: valid frame counter, msg: 1 server: 0
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: valid frame counter, msg:");
// 0000000000000004: decoding with: DecoderValueSensor port: 8
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000004: message '{"value": 51}' sent to hub
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
// Ensure device payload is available
// Data: {"value": 51}
var expectedPayload = $"{{\"value\":{msg}}}";
await this.TestFixtureCi.AssertIoTHubDeviceMessageExistsAsync(device.DeviceID, expectedPayload);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
this.TestFixtureCi.ClearLogs();
msg = PayloadGenerator.Next().ToString();
await this.ArduinoDevice.transferPacketWithConfirmedAsync(msg, 10);
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_SENDING_PACKET);
// After transferPacketWithConfirmed: Expectation from serial
// +CMSG: ACK Received
await AssertUtils.ContainsWithRetriesAsync("+CMSG: ACK Received", this.ArduinoDevice.SerialLogs);
// Checking than the communication occurs on DR 4 and RX2 as part of preferred windows RX2 and custom RX2 DR
await AssertUtils.ContainsWithRetriesAsync(x => x.StartsWith("+CMSG: RXWIN2"), this.ArduinoDevice.SerialLogs);
await this.TestFixtureCi.AssertNetworkServerModuleLogExistsAsync(x => x.Contains($"\"datr\":\"SF9BW125\""), null);
// 0000000000000004: decoding with: DecoderValueSensor port: 8
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000004: message '{"value": 51}' sent to hub
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
// Ensure device payload is available
// Data: {"value": 51}
expectedPayload = $"{{\"value\":{msg}}}";
await this.TestFixtureCi.AssertIoTHubDeviceMessageExistsAsync(device.DeviceID, expectedPayload);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
await this.ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWOTAA);
await this.ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, device.AppEUI);
await this.ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, device.AppKey);
await this.ArduinoDevice.SetupLora(this.TestFixtureCi.Configuration.LoraRegion);
var joinSucceeded2 = await this.ArduinoDevice.setOTAAJoinAsyncWithRetry(LoRaArduinoSerial._otaa_join_cmd_t.JOIN, 20000, 5);
Assert.True(joinSucceeded2, "Rejoin failed");
}
public async Task Test_ABP_Confirmed_And_Unconfirmed_Message()
{
const int MESSAGES_COUNT = 10;
var device = this.TestFixtureCi.Device5_ABP;
this.LogTestStart(device);
await this.ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWABP);
await this.ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, null);
await this.ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, null);
await this.ArduinoDevice.SetupLora(this.TestFixtureCi.Configuration.LoraRegion);
// Sends 10x unconfirmed messages
for (var i = 0; i < MESSAGES_COUNT; ++i)
{
var msg = PayloadGenerator.Next().ToString();
this.Log($"{device.DeviceID}: Sending unconfirmed '{msg}' {i + 1}/{MESSAGES_COUNT}");
await this.ArduinoDevice.transferPacketAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
// After transferPacket: Expectation from serial
// +MSG: Done
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", this.ArduinoDevice.SerialLogs);
// 0000000000000005: valid frame counter, msg: 1 server: 0
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: valid frame counter, msg:");
// 0000000000000005: decoding with: DecoderValueSensor port: 8
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000005: message '{"value": 51}' sent to hub
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
this.TestFixtureCi.ClearLogs();
}
// Sends 10x confirmed messages
for (var i = 0; i < MESSAGES_COUNT; ++i)
{
var msg = PayloadGenerator.Next().ToString();
this.Log($"{device.DeviceID}: Sending confirmed '{msg}' {i + 1}/{MESSAGES_COUNT}");
await this.ArduinoDevice.transferPacketWithConfirmedAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
// After transferPacketWithConfirmed: Expectation from serial
// +CMSG: ACK Received
await AssertUtils.ContainsWithRetriesAsync("+CMSG: ACK Received", this.ArduinoDevice.SerialLogs);
// 0000000000000005: valid frame counter, msg: 1 server: 0
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: valid frame counter, msg:");
// 0000000000000005: decoding with: DecoderValueSensor port: 8
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000005: message '{"value": 51}' sent to hub
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
this.TestFixtureCi.ClearLogs();
}
}
public async Task Test_ABP_Wrong_DevAddr_Is_Ignored(string devAddrToUse)
{
var device = this.TestFixtureCi.Device6_ABP;
this.LogTestStart(device);
Assert.NotEqual(devAddrToUse, device.DevAddr);
await this.ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWABP);
await this.ArduinoDevice.setIdAsync(devAddrToUse, device.DeviceID, null);
await this.ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, null);
await this.ArduinoDevice.SetupLora(this.TestFixtureCi.Configuration.LoraRegion);
await this.ArduinoDevice.transferPacketAsync(PayloadGenerator.Next().ToString(), 10);
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_SENDING_PACKET);
// After transferPacket: Expectation from serial
// +MSG: Done
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", this.ArduinoDevice.SerialLogs);
if (devAddrToUse.StartsWith("02"))
{
// 02060708: device is not our device, ignore message
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync(
$"{devAddrToUse}: device is not our device, ignore message",
$"{devAddrToUse}: device is not from our network, ignoring message");
}
else
{
// 05060708: device is using another network id, ignoring this message
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync(
$"{devAddrToUse}: device is using another network id, ignoring this message");
}
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
this.TestFixtureCi.ClearLogs();
// Try with confirmed message
await this.ArduinoDevice.transferPacketWithConfirmedAsync(PayloadGenerator.Next().ToString(), 10);
// wait for serial logs to be ready
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_SENDING_PACKET);
// After transferPacketWithConfirmed: Expectation from serial
// +CMSG: ACK Received -- should not be there!
Assert.DoesNotContain("+CMSG: ACK Received", this.ArduinoDevice.SerialLogs);
if (devAddrToUse.StartsWith("02"))
{
// 02060708: device is not our device, ignore message
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync(
$"{devAddrToUse}: device is not our device, ignore message",
$"{devAddrToUse}: device is not from our network, ignoring message");
}
else
{
// 05060708: device is using another network id, ignoring this message
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync(
$"{devAddrToUse}: device is using another network id, ignoring this message");
}
}
private async Task Test_OTAA_Unconfirmed_Send_And_Receive_C2D_Mac_CommandsImplAsync(TestDeviceInfo device, string c2dMessageBody)
{
const int MaxAttempts = 5;
const int UnconfirmedMsgCount = 2;
// Sends 2x unconfirmed messages
for (var i = 1; i <= UnconfirmedMsgCount; ++i)
{
var msg = PayloadGenerator.Next().ToString();
this.Log($"{device.DeviceID}: Sending unconfirmed '{msg}' {i}/{UnconfirmedMsgCount}");
await this.ArduinoDevice.transferPacketAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", this.ArduinoDevice.SerialLogs);
this.TestFixtureCi.ClearLogs();
}
var c2dMessage = new LoRaCloudToDeviceMessage()
{
Fport = 1,
Payload = c2dMessageBody,
MacCommands = new MacCommand[]
{
new DevStatusRequest(),
}
};
await this.TestFixtureCi.SendCloudToDeviceMessageAsync(device.DeviceID, c2dMessage);
this.Log($"Message {c2dMessageBody} sent to device, need to check if it receives");
var macCommandReceivedMsg = $"{device.DeviceID}: cloud to device MAC command DevStatusCmd received";
var foundMacCommandReceivedMsg = false;
var deviceMacCommandResponseMsg = $": DevStatusCmd mac command detected in upstream payload: Type: DevStatusCmd Answer, Battery Level:";
var foundDeviceMacCommandResponseMsg = false;
// Sends 5x unconfirmed messages, stopping if assertions succeeded
for (var i = 1; i <= MaxAttempts; ++i)
{
var msg = PayloadGenerator.Next().ToString();
this.Log($"{device.DeviceID}: Sending unconfirmed '{msg}' {i}/{MaxAttempts}");
await this.ArduinoDevice.transferPacketAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", this.ArduinoDevice.SerialLogs);
// check if c2d message was found
if (!foundMacCommandReceivedMsg)
{
var searchResults = await this.TestFixtureCi.SearchNetworkServerModuleAsync(
(messageBody) =>
{
return(messageBody.StartsWith(macCommandReceivedMsg));
},
new SearchLogOptions
{
Description = macCommandReceivedMsg,
MaxAttempts = 1
});
// We should only receive the message once
if (searchResults.Found)
{
foundMacCommandReceivedMsg = true;
this.Log($"{device.DeviceID}: Found Mac C2D message in log (after sending {i}/{MaxAttempts}) ? {foundMacCommandReceivedMsg}");
}
}
if (!foundDeviceMacCommandResponseMsg)
{
var macSearchResults = await this.TestFixtureCi.SearchNetworkServerModuleAsync(
(messageBody) =>
{
return(messageBody.Contains(deviceMacCommandResponseMsg, StringComparison.InvariantCultureIgnoreCase));
},
new SearchLogOptions
{
Description = deviceMacCommandResponseMsg,
MaxAttempts = 1
});
// We should only receive the message once
if (macSearchResults.Found)
{
foundDeviceMacCommandResponseMsg = true;
this.Log($"{device.DeviceID}: Found Mac Command reply in log (after sending {i}/{MaxAttempts}) ? {foundDeviceMacCommandResponseMsg}");
}
}
this.TestFixtureCi.ClearLogs();
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
if (foundDeviceMacCommandResponseMsg && foundMacCommandReceivedMsg)
{
break;
}
}
Assert.True(foundMacCommandReceivedMsg, $"Did not find in network server logs: '{macCommandReceivedMsg}'");
Assert.True(foundDeviceMacCommandResponseMsg, $"Did not find in network server logs: '{deviceMacCommandResponseMsg}'");
}
public async Task Test_OTAA_Confirmed_And_Unconfirmed_Message_With_Custom_RX1_DR_Offset(string devicePropertyName)
{
var device = this.TestFixtureCi.GetDeviceByPropertyName(devicePropertyName);
const int MESSAGES_COUNT = 10;
this.LogTestStart(device);
await this.ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWOTAA);
await this.ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, device.AppEUI);
await this.ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, device.AppKey);
await this.ArduinoDevice.SetupLora(this.TestFixtureCi.Configuration.LoraRegion);
var joinSucceeded = await this.ArduinoDevice.setOTAAJoinAsyncWithRetry(LoRaArduinoSerial._otaa_join_cmd_t.JOIN, 20000, 5);
Assert.True(joinSucceeded, "Join failed");
// wait 1 second after joined
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_JOIN);
if (device.IsMultiGw)
{
await this.TestFixtureCi.WaitForTwinSyncAfterJoinAsync(this.ArduinoDevice.SerialLogs, device.DeviceID);
}
// Sends 10x unconfirmed messages
for (var i = 0; i < MESSAGES_COUNT; ++i)
{
Console.WriteLine($"Starting sending OTAA unconfirmed message {i + 1}/{MESSAGES_COUNT}");
this.TestFixtureCi.ClearLogs();
var msg = PayloadGenerator.Next().ToString();
await this.ArduinoDevice.transferPacketAsync(msg, 10);
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_SENDING_PACKET);
// After transferPacket: Expectation from serial
// +MSG: Done
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", this.ArduinoDevice.SerialLogs);
// 0000000000000004: valid frame counter, msg: 1 server: 0
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: valid frame counter, msg:");
// 0000000000000004: decoding with: DecoderValueSensor port: 8
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000004: message '{"value": 51}' sent to hub
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
// Ensure device payload is available
// Data: {"value": 51}
var expectedPayload = $"{{\"value\":{msg}}}";
await this.TestFixtureCi.AssertIoTHubDeviceMessageExistsAsync(device.DeviceID, expectedPayload);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
}
// Sends 10x confirmed messages
for (var i = 0; i < MESSAGES_COUNT; ++i)
{
Console.WriteLine($"Starting sending OTAA confirmed message {i + 1}/{MESSAGES_COUNT}");
this.TestFixtureCi.ClearLogs();
var msg = PayloadGenerator.Next().ToString();
await this.ArduinoDevice.transferPacketWithConfirmedAsync(msg, 10);
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_SENDING_PACKET);
if (device.IsMultiGw)
{
// multi gw, make sure one ignored the message
var searchTokenSending = $"{device.DeviceID}: sending a downstream message";
var sending = await this.TestFixtureCi.SearchNetworkServerModuleAsync((log) => log.StartsWith(searchTokenSending, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(sending.MatchedEvent);
var searchTokenAlreadySent = $"{device.DeviceID}: another gateway has already sent ack or downlink msg";
var ignored = await this.TestFixtureCi.SearchNetworkServerModuleAsync((log) => log.StartsWith(searchTokenAlreadySent, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(ignored.MatchedEvent);
Assert.NotEqual(sending.MatchedEvent.SourceId, ignored.MatchedEvent.SourceId);
}
// After transferPacketWithConfirmed: Expectation from serial
// +CMSG: ACK Received
await AssertUtils.ContainsWithRetriesAsync("+CMSG: ACK Received", this.ArduinoDevice.SerialLogs, maxAttempts : 5, interval : TimeSpan.FromSeconds(10));
// 0000000000000004: decoding with: DecoderValueSensor port: 8
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000004: message '{"value": 51}' sent to hub
await this.TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
if (this.ArduinoDevice.SerialLogs.Where(x => x.StartsWith("+CMSG: RXWIN1")).Count() > 0)
{
// Expect that the response is done on DR4 as the RX1 offset is 1 on this device.
await this.TestFixtureCi.AssertNetworkServerModuleLogExistsAsync(log => log.Contains("\"datr\":\"SF8BW125\""), null);
}
// Ensure device payload is available
// Data: {"value": 51}
var expectedPayload = $"{{\"value\":{msg}}}";
await this.TestFixtureCi.AssertIoTHubDeviceMessageExistsAsync(device.DeviceID, expectedPayload);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
}
}
public async Task C2D_When_Device_Has_Preferred_Windows_2_Should_Receive_In_2nd_Window()
{
var device = this.TestFixtureCi.Device21_ABP;
this.LogTestStart(device);
// Setup LoRa device properties
await this.ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWABP);
await this.ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, device.AppEUI);
await this.ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, device.AppKey);
// Setup protocol properties
await this.ArduinoDevice.SetupLora(this.TestFixture.Configuration.LoraRegion);
// Sends 2x unconfirmed messages
for (var i = 1; i <= 2; ++i)
{
var msg = PayloadGenerator.Next().ToString();
this.Log($"{device.DeviceID}: Sending unconfirmed '{msg}' {i}/10");
await this.ArduinoDevice.transferPacketAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", this.ArduinoDevice.SerialLogs);
this.TestFixture.ClearLogs();
}
// sends C2D - between 10 and 99
var c2dMessageBody = (100 + random.Next(90)).ToString();
var msgId = Guid.NewGuid().ToString();
await this.TestFixtureCi.SendCloudToDeviceMessage(device.DeviceID, msgId, c2dMessageBody, new Dictionary <string, string>()
{
{ FportPropertyName, "1" },
{ ConfirmedPropertyName, "true" },
});
this.Log($"Message {c2dMessageBody} sent to device, need to check if it receives");
var foundC2DMessage = false;
var foundReceivePacket = false;
var foundReceivePacketInRX2 = false;
var expectedRxSerial1 = $"+MSG: PORT: 1; RX: \"{this.ToHexString(c2dMessageBody)}\"";
var expectedRxSerial2 = $"+MSG: RXWIN2";
var expectedUDPMessageV1 = $"{device.DevAddr}: ConfirmedDataDown";
var expectedUDPMessageV2 = $"{device.DeviceID}: C2D message: {c2dMessageBody}, id: {msgId}, fport: 1, confirmed: True";
this.Log($"Expected C2D received log is: {expectedRxSerial1} and {expectedRxSerial2}");
this.Log($"Expected UDP log starting with: {expectedUDPMessageV1} or {expectedUDPMessageV2}");
// Sends 8x confirmed messages, stopping if C2D message is found
for (var i = 3; i <= 10; ++i)
{
var msg = PayloadGenerator.Next().ToString();
this.Log($"{device.DeviceID}: Sending unconfirmed '{msg}' {i}/10");
await this.ArduinoDevice.transferPacketAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", this.ArduinoDevice.SerialLogs);
// check if c2d message was found
if (!foundC2DMessage)
{
var searchResults = await this.TestFixture.SearchNetworkServerModuleAsync(
(messageBody) =>
{
return(messageBody.StartsWith(expectedUDPMessageV1) || messageBody.StartsWith(expectedUDPMessageV2));
},
new SearchLogOptions
{
Description = $"{expectedUDPMessageV1} or {expectedUDPMessageV2}",
MaxAttempts = 1,
});
// We should only receive the message once
if (searchResults.Found)
{
this.Log($"{device.DeviceID}: Found C2D message in log (after sending {i}/10)");
foundC2DMessage = true;
}
}
if (!foundReceivePacket)
{
if (this.ArduinoDevice.SerialLogs.Contains(expectedRxSerial1))
{
this.Log($"{device.DeviceID}: Found serial log message {expectedRxSerial1} in log (after sending {i}/10)");
foundReceivePacket = true;
}
}
if (!foundReceivePacketInRX2)
{
if (this.ArduinoDevice.SerialLogs.Any(x => x.StartsWith(expectedRxSerial2)))
{
this.Log($"{device.DeviceID}: Found serial log message {expectedRxSerial2} in log (after sending {i}/10)");
foundReceivePacketInRX2 = true;
}
}
if (foundReceivePacket && foundReceivePacketInRX2 && foundC2DMessage)
{
this.Log($"{device.DeviceID}: Found all messages in log (after sending {i}/10)");
break;
}
this.TestFixture.ClearLogs();
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
}
Assert.True(foundC2DMessage, $"Did not find {expectedUDPMessageV1} or {expectedUDPMessageV2} in logs");
// checks if serial received the message
if (!foundReceivePacket)
{
foundReceivePacket = this.ArduinoDevice.SerialLogs.Contains(expectedRxSerial1);
}
Assert.True(foundReceivePacket, $"Could not find lora receiving message '{expectedRxSerial1}'");
// checks if serial received the message in RX2
if (!foundReceivePacketInRX2)
{
foundReceivePacketInRX2 = this.ArduinoDevice.SerialLogs.Any(x => x.StartsWith(expectedRxSerial2));
}
Assert.True(foundReceivePacketInRX2, $"Could not find lora receiving message '{expectedRxSerial2}'");
}
[InlineData(224, nameof(IntegrationTestFixtureCi.Device19_ABP))] // >= 224 is reserved
public async Task C2D_Using_Invalid_FPort_Should_Be_Ignored(byte fport, string devicePropertyName)
{
var device = this.TestFixtureCi.GetDeviceByPropertyName(devicePropertyName);
this.LogTestStart(device);
// Setup LoRa device properties
await this.ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWABP);
await this.ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, device.AppEUI);
await this.ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, device.AppKey);
// Setup protocol properties
await this.ArduinoDevice.SetupLora(this.TestFixtureCi.Configuration.LoraRegion);
// Sends 2x unconfirmed messages
for (var i = 1; i <= 2; ++i)
{
var msg = PayloadGenerator.Next().ToString();
this.Log($"{device.DeviceID}: Sending unconfirmed '{msg}' {i}/10");
await this.ArduinoDevice.transferPacketAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", this.ArduinoDevice.SerialLogs);
this.TestFixtureCi.ClearLogs();
}
// sends C2D - between 10 and 99
var c2dMessageBody = (100 + random.Next(90)).ToString();
var c2dMessage = new Message(Encoding.UTF8.GetBytes(c2dMessageBody))
{
MessageId = Guid.NewGuid().ToString(),
};
c2dMessage.Properties[FportPropertyName] = fport.ToString();
await this.TestFixtureCi.SendCloudToDeviceMessage(device.DeviceID, c2dMessage);
this.Log($"Message {c2dMessageBody} sent to device");
// Following log will be generated in case C2D message has invalid fport:
// "<device-id>: invalid fport '<fport>' in C2D message '<message-id>'
var foundC2DInvalidFPortMessage = false;
// Serial port will print the following once the message is received
var expectedRxSerial = $"RX: \"{this.ToHexString(c2dMessageBody)}\"";
this.Log($"Expected C2D contains: {expectedRxSerial}");
// Sends 8x unconfirmed messages, stopping if C2D message is found
for (var i = 3; i <= 10; ++i)
{
var msg = PayloadGenerator.Next().ToString();
this.Log($"{device.DeviceID}: Sending unconfirmed '{msg}' {i}/10");
await this.ArduinoDevice.transferPacketAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", this.ArduinoDevice.SerialLogs);
// ensure c2d message is not found
// 0000000000000016: C2D message: 58
var c2dLogMessage = $"{device.DeviceID}: C2D message: {c2dMessageBody}";
var searchC2DMessageLogResult = await this.TestFixtureCi.SearchNetworkServerModuleAsync(
(messageBody) =>
{
return(messageBody.StartsWith(c2dLogMessage));
},
new SearchLogOptions
{
Description = c2dLogMessage,
MaxAttempts = 1
});
Assert.False(searchC2DMessageLogResult.Found, $"Message with fport {fport} should not be forwarded to device");
// ensure log with error is found
if (!foundC2DInvalidFPortMessage)
{
var invalidFportLog = $"{device.DeviceID}: invalid fport '{fport}' in C2D message '{c2dMessage.MessageId}'";
var searchInvalidFportLog = await this.TestFixtureCi.SearchNetworkServerModuleAsync(
(messageBody) =>
{
return(messageBody.StartsWith(invalidFportLog));
},
new SearchLogOptions
{
Description = invalidFportLog,
MaxAttempts = 1
});
foundC2DInvalidFPortMessage = searchInvalidFportLog.Found;
}
// Should not contain in the serial the c2d message
Assert.DoesNotContain(this.ArduinoDevice.SerialLogs, log => log.Contains(expectedRxSerial, StringComparison.InvariantCultureIgnoreCase));
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
this.TestFixtureCi.ClearLogs();
}
Assert.True(foundC2DInvalidFPortMessage, "Invalid fport message was not found in network server log");
}
public async Task Test_OTAA_Confirmed_Receives_C2D_Message()
{
var device = this.TestFixtureCi.Device9_OTAA;
this.LogTestStart(device);
await this.ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWOTAA);
await this.ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, device.AppEUI);
await this.ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, device.AppKey);
await this.ArduinoDevice.SetupLora(this.TestFixtureCi.Configuration.LoraRegion);
var joinSucceeded = await this.ArduinoDevice.setOTAAJoinAsyncWithRetry(LoRaArduinoSerial._otaa_join_cmd_t.JOIN, 20000, 5);
Assert.True(joinSucceeded, "Join failed");
// wait 1 second after joined
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_JOIN);
// Sends 2x confirmed messages
for (var i = 1; i <= 2; ++i)
{
var msg = PayloadGenerator.Next().ToString();
this.Log($"{device.DeviceID}: Sending confirmed '{msg}' {i}/10");
await this.ArduinoDevice.transferPacketWithConfirmedAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
// +CMSG: ACK Received
await AssertUtils.ContainsWithRetriesAsync("+CMSG: ACK Received", this.ArduinoDevice.SerialLogs);
this.TestFixtureCi.ClearLogs();
}
// sends C2D - between 10 and 99
var c2dMessageBody = (100 + random.Next(90)).ToString();
await this.TestFixtureCi.SendCloudToDeviceMessage(device.DeviceID, c2dMessageBody, new Dictionary <string, string> {
{ FportPropertyName, "1" }
});
this.Log($"Message {c2dMessageBody} sent to device, need to check if it receives");
var foundC2DMessage = false;
var foundReceivePacket = false;
var expectedRxSerial = $"+CMSG: PORT: 1; RX: \"{this.ToHexString(c2dMessageBody)}\"";
this.Log($"Expected C2D received log is: {expectedRxSerial}");
// Sends 8x confirmed messages, stopping if C2D message is found
for (var i = 3; i <= 10; ++i)
{
var msg = PayloadGenerator.Next().ToString();
this.Log($"{device.DeviceID}: Sending confirmed '{msg}' {i}/10");
await this.ArduinoDevice.transferPacketWithConfirmedAsync(msg, 10);
await Task.Delay(TimeSpan.FromSeconds(5));
// After transferPacketWithConfirmed: Expectation from serial
// +CMSG: ACK Received
await AssertUtils.ContainsWithRetriesAsync("+CMSG: ACK Received", this.ArduinoDevice.SerialLogs);
// check if c2d message was found
// 0000000000000009: C2D message: 58
var c2dLogMessage = $"{device.DeviceID}: C2D message: {c2dMessageBody}";
var searchResults = await this.TestFixtureCi.SearchNetworkServerModuleAsync(
(messageBody) =>
{
return(messageBody.StartsWith(c2dLogMessage));
},
new SearchLogOptions
{
Description = c2dLogMessage,
MaxAttempts = 1
});
// We should only receive the message once
if (searchResults.Found)
{
this.Log($"{device.DeviceID}: Found C2D message in log (after sending {i}/10) ? {foundC2DMessage}");
Assert.False(foundC2DMessage, "Cloud to Device message should have been detected in Network Service module only once");
foundC2DMessage = true;
}
var localFoundCloudToDeviceInSerial = this.ArduinoDevice.SerialLogs.Contains(expectedRxSerial);
if (localFoundCloudToDeviceInSerial)
{
Assert.False(foundReceivePacket, "Cloud to device message should have been received only once");
foundReceivePacket = true;
}
this.TestFixtureCi.ClearLogs();
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
}
Assert.True(foundC2DMessage, $"Did not find '{device.DeviceID}: C2D message: {c2dMessageBody}' in logs");
// checks if log arrived
if (!foundReceivePacket)
{
foundReceivePacket = this.ArduinoDevice.SerialLogs.Contains(expectedRxSerial);
}
Assert.True(foundReceivePacket, $"Could not find lora receiving message '{expectedRxSerial}'");
}