public async Task SensorDecoder_ReflectionBased_ValueSensorDecoder_DecodesPayload()
{
var device = TestFixtureCi.Device12_OTAA;
LogTestStart(device);
await ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWOTAA);
await ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, device.AppEui);
await ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, device.AppKey);
await ArduinoDevice.SetupLora(TestFixtureCi.Configuration);
var joinSucceeded = await 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);
await ArduinoDevice.transferPacketWithConfirmedAsync("4321", 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
// +CMSG: ACK Received
await AssertUtils.ContainsWithRetriesAsync("+CMSG: ACK Received", ArduinoDevice.SerialLogs);
// Find "0000000000000011: message '{"value":1234}' sent to hub" in network server logs
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":4321}}' sent to hub");
TestFixtureCi.ClearLogs();
}
private async Task SendABPMessages(int messages_count, TestDeviceInfo device)
{
await ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWABP);
await ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, null);
await ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, null);
await ArduinoDevice.SetupLora(TestFixtureCi.Configuration);
// Sends 10x unconfirmed messages
for (var i = 0; i < messages_count; ++i)
{
var msg = GeneratePayloadMessage();
Log($"{device.DeviceID}: Sending unconfirmed '{msg}' {i + 1}/{messages_count}");
await ArduinoDevice.transferPacketAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
// After transferPacket: Expectation from serial
// +MSG: Done
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", ArduinoDevice.SerialLogs);
// 0000000000000005: valid frame counter, msg: 1 server: 0
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: valid frame counter, msg:");
// 0000000000000005: decoding with: DecoderValueSensor port: 8
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000005: message '{"value": 51}' sent to hub
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
TestFixtureCi.ClearLogs();
}
// Sends 10x confirmed messages
for (var i = 0; i < messages_count; ++i)
{
var msg = GeneratePayloadMessage();
Log($"{device.DeviceID}: Sending confirmed '{msg}' {i + 1}/{messages_count}");
await 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", ArduinoDevice.SerialLogs);
// 0000000000000005: valid frame counter, msg: 1 server: 0
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: valid frame counter, msg:");
// 0000000000000005: decoding with: DecoderValueSensor port: 8
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000005: message '{"value": 51}' sent to hub
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
TestFixtureCi.ClearLogs();
}
}
public async Task Test_Concentrator_Deduplication_OTAA()
{
Assert.True(this.initializationSucceeded);
var device = TestFixtureCi.GetDeviceByPropertyName("Device31_OTAA");
LogTestStart(device);
await ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWOTAA);
await ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, device.AppEui);
await ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, device.AppKey);
await ArduinoDevice.SetupLora(TestFixtureCi.Configuration);
var joinSucceeded = await ArduinoDevice.setOTAAJoinAsyncWithRetry(LoRaArduinoSerial._otaa_join_cmd_t.JOIN, 20000, 5);
Assert.True(joinSucceeded, "Join failed");
var droppedLog = await TestFixtureCi.SearchNetworkServerModuleAsync(
(log) => log.IndexOf(this.expectedLog, StringComparison.Ordinal) != -1, new SearchLogOptions(this.expectedLog));
Assert.NotNull(droppedLog.MatchedEvent);
// wait 1 second after joined
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_JOIN);
const int MESSAGE_COUNT = 5;
for (var i = 0; i < MESSAGE_COUNT; ++i)
{
Log($"{device.DeviceID}: Sending OTAA confirmed message {i + 1}/{MESSAGE_COUNT}");
var msg = PayloadGenerator.Next().ToString(CultureInfo.InvariantCulture);
await 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", ArduinoDevice.SerialLogs);
// 0000000000000031: message '{"value": 101}' sent to hub
var expectedPayload = $"{{\"value\":{msg}}}";
await TestFixtureCi.AssertIoTHubDeviceMessageExistsAsync(device.DeviceID, expectedPayload, new SearchLogOptions(expectedPayload));
droppedLog = await TestFixtureCi.SearchNetworkServerModuleAsync(
(log) => log.IndexOf(this.expectedLog, StringComparison.Ordinal) != -1, new SearchLogOptions(this.expectedLog));
Assert.NotNull(droppedLog.MatchedEvent);
TestFixtureCi.ClearLogs();
}
}
public async Task Test_ClassC_Send_Message_Using_Function_Endpoint_Should_Be_Received()
{
var device = TestFixtureCi.Device24_ABP;
LogTestStart(device);
await ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWABP);
await ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, null);
await ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, null);
await ArduinoDevice.SetupLora(TestFixtureCi.Configuration);
await ArduinoDevice.setClassTypeAsync(LoRaArduinoSerial._class_type_t.CLASS_C);
// send one confirmed message for ensuring that a basicstation is "bound" to the device
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
var msg = PayloadGenerator.Next().ToString(CultureInfo.InvariantCulture);
Log($"{device.DeviceID}: Sending confirmed '{msg}'");
await ArduinoDevice.transferPacketWithConfirmedAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
TestFixtureCi.ClearLogs();
// Now sending a c2d
var c2d = new LoRaCloudToDeviceMessage()
{
DevEUI = DevEui.Parse(device.DeviceID),
MessageId = Guid.NewGuid().ToString(),
Fport = FramePorts.App23,
RawPayload = Convert.ToBase64String(new byte[] { 0xFF, 0x00 }),
};
TestLogger.Log($"[INFO] Using service API to send C2D message to device {device.DeviceID}");
TestLogger.Log($"[INFO] {JsonConvert.SerializeObject(c2d, Formatting.None)}");
// send message using the SendCloudToDeviceMessage API endpoint
Assert.True(await LoRaAPIHelper.SendCloudToDeviceMessage(device.DevEui, c2d));
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
// 0000000000000024: received cloud to device message from direct method
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: received cloud to device message from direct method");
Assert.Contains(ArduinoDevice.SerialLogs, (l) => l.Contains("PORT: 23; RX: \"FF00\"", StringComparison.Ordinal));
Assert.Contains(ArduinoDevice.SerialLogs, (l) => l.Contains("RXWIN0, RSSI", StringComparison.Ordinal));
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", ArduinoDevice.SerialLogs);
}
public async Task Test_ABP_Mismatch_NwkSKey_And_AppSKey_Fails_Mic_Validation()
{
var device = TestFixtureCi.Device7_ABP;
LogTestStart(device);
var appSKeyToUse = AppSessionKey.Parse("000102030405060708090A0B0C0D0E0F");
var nwkSKeyToUse = NetworkSessionKey.Parse("01020304050607080910111213141516");
Assert.NotEqual(appSKeyToUse, device.AppSKey);
Assert.NotEqual(nwkSKeyToUse, device.NwkSKey);
await ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWABP);
await ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, null);
await ArduinoDevice.setKeyAsync(nwkSKeyToUse, appSKeyToUse, null);
await ArduinoDevice.SetupLora(TestFixtureCi.Configuration);
await ArduinoDevice.transferPacketAsync(GeneratePayloadMessage(), 10);
// wait for serial logs to be ready
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_SENDING_PACKET);
// After transferPacket: Expectation from serial
// +MSG: Done
// await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", this.lora.SerialLogs);
// 0000000000000005: with devAddr 0028B1B0 check MIC failed. Device will be ignored from now on
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DevAddr}: with devAddr {device.DevAddr} check MIC failed");
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
TestFixtureCi.ClearLogs();
// Try with confirmed message
await ArduinoDevice.transferPacketWithConfirmedAsync(GeneratePayloadMessage(), 10);
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_SENDING_PACKET);
// 0000000000000005: with devAddr 0028B1B0 check MIC failed
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DevAddr}: with devAddr {device.DevAddr} check MIC failed");
// wait until arduino stops trying to send confirmed msg
await ArduinoDevice.WaitForIdleAsync();
}
public async Task Test_ABP_Invalid_NwkSKey_Fails_With_Mic_Error()
{
var device = TestFixtureCi.Device8_ABP;
LogTestStart(device);
var nwkSKeyToUse = NetworkSessionKey.Parse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
Assert.NotEqual(nwkSKeyToUse, device.NwkSKey);
await ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWABP);
await ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, null);
await ArduinoDevice.setKeyAsync(nwkSKeyToUse, device.AppSKey, null);
await ArduinoDevice.SetupLora(TestFixtureCi.Configuration);
await ArduinoDevice.transferPacketAsync(GeneratePayloadMessage(), 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
// After transferPacket: Expectation from serial
// +MSG: Done
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", ArduinoDevice.SerialLogs);
// 0000000000000008: with devAddr 0028B1B3 check MIC failed. Device will be ignored from now on
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DevAddr}: with devAddr {device.DevAddr} check MIC failed");
TestFixtureCi.ClearLogs();
// Try with confirmed message
await ArduinoDevice.transferPacketWithConfirmedAsync(GeneratePayloadMessage(), 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
// 0000000000000008: with devAddr 0028B1B3 check MIC failed.
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DevAddr}: with devAddr {device.DevAddr} check MIC failed");
// Before starting new test, wait until Lora drivers stops sending/receiving data
await ArduinoDevice.WaitForIdleAsync();
}
// Verifies that ABP confirmed and unconfirmed messages are working
// Uses Device5_ABP
private async Task Test_ABP_Confirmed_And_Unconfirmed_Message_With_ADR(TestDeviceInfo device)
{
if (device.IsMultiGw)
{
Assert.True(await LoRaAPIHelper.ResetADRCache(device.DevEui));
}
await ArduinoDevice.setDeviceDefaultAsync();
const int MESSAGES_COUNT = 10;
await ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWABP);
await ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, null);
await ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, null);
await ArduinoDevice.SetupLora(TestFixtureCi.Configuration.LoraRegion, LoRaArduinoSerial._data_rate_t.DR3, 4, true);
// for a reason I need to set DR twice otherwise it reverts to DR 0
// await ArduinoDevice.setDataRateAsync(LoRaArduinoSerial._data_rate_t.DR3, LoRaArduinoSerial._physical_type_t.EU868);
// Sends 5x unconfirmed messages
for (var i = 0; i < MESSAGES_COUNT / 2; ++i)
{
var msg = GeneratePayloadMessage();
Log($"{device.DeviceID}: Sending unconfirmed '{msg}' {i + 1}/{MESSAGES_COUNT}");
await ArduinoDevice.transferPacketAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
// After transferPacket: Expectation from serial
// +MSG: Done
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", ArduinoDevice.SerialLogs);
// 0000000000000005: valid frame counter, msg: 1 server: 0
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: valid frame counter, msg:");
// 0000000000000005: decoding with: DecoderValueSensor port: 8
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000005: message '{"value": 51}' sent to hub
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
TestFixtureCi.ClearLogs();
}
// Sends 5x confirmed messages
for (var i = 0; i < MESSAGES_COUNT / 2; ++i)
{
var msg = GeneratePayloadMessage();
Log($"{device.DeviceID}: Sending confirmed '{msg}' {i + 1}/{MESSAGES_COUNT / 2}");
await ArduinoDevice.transferPacketWithConfirmedAsync(msg, 10);
await Task.Delay(2 *Constants.DELAY_BETWEEN_MESSAGES);
// After transferPacketWithConfirmed: Expectation from serial
// +CMSG: ACK Received
await AssertUtils.ContainsWithRetriesAsync("+CMSG: ACK Received", ArduinoDevice.SerialLogs);
// 0000000000000005: valid frame counter, msg: 1 server: 0
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: valid frame counter, msg:");
// 0000000000000005: decoding with: DecoderValueSensor port: 8
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000005: message '{"value": 51}' sent to hub
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
if (device.IsMultiGw)
{
var searchTokenSending = $"{device.DeviceID}: sending message to station with EUI";
var sending = await TestFixtureCi.SearchNetworkServerModuleAsync((log) => log.StartsWith(searchTokenSending, StringComparison.OrdinalIgnoreCase), new SearchLogOptions(searchTokenSending));
Assert.NotNull(sending.MatchedEvent);
var searchTokenAlreadySent = $"{device.DeviceID}: another gateway has already sent ack or downlink msg";
var ignored = await TestFixtureCi.SearchNetworkServerModuleAsync((log) => log.StartsWith(searchTokenAlreadySent, StringComparison.OrdinalIgnoreCase), new SearchLogOptions(searchTokenAlreadySent));
Assert.NotNull(ignored.MatchedEvent);
Assert.NotEqual(sending.MatchedEvent.SourceId, ignored.MatchedEvent.SourceId);
}
TestFixtureCi.ClearLogs();
}
// Sends 10x unconfirmed messages
for (var i = 0; i < MESSAGES_COUNT; ++i)
{
var msg = GeneratePayloadMessage();
Log($"{device.DeviceID}: Sending unconfirmed '{msg}' {i + 1}/{MESSAGES_COUNT / 2}");
await ArduinoDevice.transferPacketAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
// After transferPacket: Expectation from serial
// +MSG: Done
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", ArduinoDevice.SerialLogs);
// 0000000000000005: valid frame counter, msg: 1 server: 0
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: valid frame counter, msg:");
// 0000000000000005: decoding with: DecoderValueSensor port: 8
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000005: message '{"value": 51}' sent to hub
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
TestFixtureCi.ClearLogs();
}
// Starting ADR test protocol
Log($"{device.DeviceID}: Starting ADR protocol");
for (var i = 0; i < 56; ++i)
{
var message = GeneratePayloadMessage();
await ArduinoDevice.transferPacketAsync(message, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", ArduinoDevice.SerialLogs);
}
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: ADR ack request received");
var searchTokenADRRateAdaptation = $"{device.DeviceID}: performing a rate adaptation: DR";
var received = await TestFixtureCi.SearchNetworkServerModuleAsync((log) => log.StartsWith(searchTokenADRRateAdaptation, StringComparison.OrdinalIgnoreCase), new SearchLogOptions(searchTokenADRRateAdaptation));
Assert.NotNull(received.MatchedEvent);
if (device.IsMultiGw)
{
var searchTokenADRAlreadySent = $"{device.DeviceID}: another gateway has already sent ack or downlink msg";
var ignored = await TestFixtureCi.SearchNetworkServerModuleAsync((log) => log.StartsWith(searchTokenADRAlreadySent, StringComparison.OrdinalIgnoreCase), new SearchLogOptions(searchTokenADRAlreadySent));
Assert.NotNull(ignored.MatchedEvent);
Assert.NotEqual(received.MatchedEvent.SourceId, ignored.MatchedEvent.SourceId);
}
// Check the messages are now sent on DR5
for (var i = 0; i < 2; ++i)
{
var message = GeneratePayloadMessage();
await ArduinoDevice.transferPacketAsync(message, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
await AssertUtils.ContainsWithRetriesAsync("+MSG: Done", ArduinoDevice.SerialLogs);
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: LinkADRCmd mac command detected in upstream payload: Type: LinkADRCmd Answer, power: changed, data rate: changed,", $"{device.DevAddr}: LinkADRCmd mac command detected in upstream payload: Type: LinkADRCmd Answer, power: not changed, data rate: changed,");
}
}
// Performs a OTAA join and sends N confirmed and unconfirmed messages
// Expects that:
// - device message is available on IoT Hub
// - frame counter validation is done
// - Message is decoded
private async Task Test_OTAA_Confirmed_And_Unconfirmed_Message_With_Custom_RX1_DR_Offset(TestDeviceInfo device)
{
const int MESSAGES_COUNT = 10;
await ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWOTAA);
await ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, device.AppEui);
await ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, device.AppKey);
await ArduinoDevice.SetupLora(TestFixtureCi.Configuration);
var joinSucceeded = await 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 TestFixtureCi.WaitForTwinSyncAfterJoinAsync(ArduinoDevice.SerialLogs, device.DevEui);
}
// Sends 10x unconfirmed messages
for (var i = 0; i < MESSAGES_COUNT; ++i)
{
Console.WriteLine($"Starting sending OTAA unconfirmed message {i + 1}/{MESSAGES_COUNT}");
TestFixtureCi.ClearLogs();
var msg = PayloadGenerator.Next().ToString(CultureInfo.InvariantCulture);
await 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", ArduinoDevice.SerialLogs);
// 0000000000000004: valid frame counter, msg: 1 server: 0
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: valid frame counter, msg:");
// 0000000000000004: decoding with: DecoderValueSensor port: 8
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000004: message '{"value": 51}' sent to hub
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
// Ensure device payload is available
// Data: {"value": 51}
var expectedPayload = $"{{\"value\":{msg}}}";
await TestFixtureCi.AssertIoTHubDeviceMessageExistsAsync(device.DeviceID, expectedPayload, new SearchLogOptions(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}");
TestFixtureCi.ClearLogs();
var msg = PayloadGenerator.Next().ToString(CultureInfo.InvariantCulture);
await 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 message to station with EUI";
var sending = await TestFixtureCi.SearchNetworkServerModuleAsync((log) => log.StartsWith(searchTokenSending, StringComparison.OrdinalIgnoreCase), new SearchLogOptions(searchTokenSending));
Assert.NotNull(sending.MatchedEvent);
var searchTokenAlreadySent = $"{device.DeviceID}: another gateway has already sent ack or downlink msg";
var ignored = await TestFixtureCi.SearchNetworkServerModuleAsync((log) => log.StartsWith(searchTokenAlreadySent, StringComparison.OrdinalIgnoreCase), new SearchLogOptions(searchTokenAlreadySent));
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", ArduinoDevice.SerialLogs, maxAttempts : 5, interval : TimeSpan.FromSeconds(10));
// 0000000000000004: decoding with: DecoderValueSensor port: 8
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000004: message '{"value": 51}' sent to hub
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
if (ArduinoDevice.SerialLogs.Any(x => x.StartsWith("+CMSG: RXWIN1", StringComparison.Ordinal)))
{
// Expect that the response is done on DR4 as the RX1 offset is 1 on this device.
const string logMessage = "\"Rx1\":{\"DataRate\":4";
await TestFixtureCi.AssertNetworkServerModuleLogExistsAsync(log => log.Contains(logMessage, StringComparison.Ordinal), new SearchLogOptions(logMessage));
}
// Ensure device payload is available
// Data: {"value": 51}
var expectedPayload = $"{{\"value\":{msg}}}";
await TestFixtureCi.AssertIoTHubDeviceMessageExistsAsync(device.DeviceID, expectedPayload, new SearchLogOptions(expectedPayload));
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
}
}
// Performs a OTAA join and sends 1 unconfirmed, 1 confirmed and rejoins
private async Task Test_OTAA_Join_Send_And_Rejoin_With_Custom_RX2_DR(TestDeviceInfo device)
{
await ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWOTAA);
await ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, device.AppEui);
await ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, device.AppKey);
await ArduinoDevice.SetupLora(TestFixtureCi.Configuration);
var joinSucceeded = await 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 TestFixtureCi.WaitForTwinSyncAfterJoinAsync(ArduinoDevice.SerialLogs, device.DevEui);
}
// Sends 1x unconfirmed messages
TestFixtureCi.ClearLogs();
var msg = PayloadGenerator.Next().ToString(CultureInfo.InvariantCulture);
await 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", ArduinoDevice.SerialLogs);
// 0000000000000004: valid frame counter, msg: 1 server: 0
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: valid frame counter, msg:");
// 0000000000000004: decoding with: DecoderValueSensor port: 8
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000004: message '{"value": 51}' sent to hub
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
// Ensure device payload is available
// Data: {"value": 51}
var expectedPayload = $"{{\"value\":{msg}}}";
await TestFixtureCi.AssertIoTHubDeviceMessageExistsAsync(device.DeviceID, expectedPayload, new SearchLogOptions(expectedPayload));
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
TestFixtureCi.ClearLogs();
msg = PayloadGenerator.Next().ToString(CultureInfo.InvariantCulture);
await 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", 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", StringComparison.Ordinal), ArduinoDevice.SerialLogs);
// this test has a custom datarate for RX 2 of 3
const string logMessage2 = "\"Rx2\":{\"DataRate\":3";
await TestFixtureCi.AssertNetworkServerModuleLogExistsAsync(x => x.Contains(logMessage2, StringComparison.Ordinal), new SearchLogOptions(logMessage2));
// 0000000000000004: decoding with: DecoderValueSensor port: 8
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: decoding with: {device.SensorDecoder} port:");
// 0000000000000004: message '{"value": 51}' sent to hub
await TestFixtureCi.AssertNetworkServerModuleLogStartsWithAsync($"{device.DeviceID}: message '{{\"value\":{msg}}}' sent to hub");
// Ensure device payload is available
// Data: {"value": 51}
expectedPayload = $"{{\"value\":{msg}}}";
await TestFixtureCi.AssertIoTHubDeviceMessageExistsAsync(device.DeviceID, expectedPayload, new SearchLogOptions(expectedPayload));
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
// rejoin
await ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWOTAA);
await ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, device.AppEui);
await ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, device.AppKey);
await ArduinoDevice.SetupLora(TestFixtureCi.Configuration);
var joinSucceeded2 = await ArduinoDevice.setOTAAJoinAsyncWithRetry(LoRaArduinoSerial._otaa_join_cmd_t.JOIN, 20000, 5);
Assert.True(joinSucceeded2, "Rejoin failed");
if (device.IsMultiGw)
{
const string joinRefusedMsg = "join refused";
var joinRefused = await TestFixtureCi.AssertNetworkServerModuleLogExistsAsync((s) => s.IndexOf(joinRefusedMsg, StringComparison.Ordinal) != -1, new SearchLogOptions(joinRefusedMsg));
Assert.True(joinRefused.Found);
}
}
public async Task Test_OTAA_Confirmed_Receives_C2D_Message_With_RX_Delay_2()
{
const int messagesToSend = 10;
const int warmUpMessageCount = 2;
var device = TestFixtureCi.Device9_OTAA;
LogTestStart(device);
await ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWOTAA);
await ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, device.AppEui);
await ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, device.AppKey);
await ArduinoDevice.SetupLora(TestFixtureCi.Configuration);
await TestFixture.CleanupC2DDeviceQueueAsync(device.DeviceID);
var joinSucceeded = await ArduinoDevice.setOTAAJoinAsyncWithRetry(LoRaArduinoSerial._otaa_join_cmd_t.JOIN, 20000, 5);
Assert.True(joinSucceeded, "Join failed");
// find the gateway that accepted the join
const string expectedLog = "JoinAccept";
var joinAccept = await TestFixtureCi.SearchNetworkServerModuleAsync((s) => s.IndexOf(expectedLog, StringComparison.OrdinalIgnoreCase) != -1, new SearchLogOptions(expectedLog));
Assert.NotNull(joinAccept);
Assert.NotNull(joinAccept.MatchedEvent);
var targetGw = joinAccept.MatchedEvent.SourceId;
Assert.Equal(device.GatewayID, targetGw);
// wait 1 second after joined
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_JOIN);
// Sends 2x confirmed messages
for (var i = 1; i <= warmUpMessageCount; ++i)
{
var msg = PayloadGenerator.Next().ToString(CultureInfo.InvariantCulture);
Log($"{device.DeviceID}: Sending confirmed '{msg}' {i}/{messagesToSend}");
await ArduinoDevice.transferPacketWithConfirmedAsync(msg, 10);
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
// +CMSG: ACK Received
await AssertUtils.ContainsWithRetriesAsync("+CMSG: ACK Received", ArduinoDevice.SerialLogs);
TestFixtureCi.ClearLogs();
}
// sends C2D - between 10 and 99
var c2dMessageBody = (100 + random.Next(90)).ToString(CultureInfo.InvariantCulture);
var c2dMessage = new LoRaCloudToDeviceMessage()
{
Payload = c2dMessageBody,
Fport = FramePorts.App1,
MessageId = Guid.NewGuid().ToString(),
};
await TestFixtureCi.SendCloudToDeviceMessageAsync(device.DeviceID, c2dMessage);
Log($"Message {c2dMessageBody} sent to device, need to check if it receives");
var foundC2DMessageCount = 0;
var foundReceivePacketCount = 0;
var expectedRxSerial = $"+CMSG: PORT: 1; RX: \"{ToHexString(c2dMessageBody)}\"";
Log($"Expected C2D received log is: {expectedRxSerial}");
var c2dLogMessage = $"{device.DeviceID}: done completing cloud to device message, id: {c2dMessage.MessageId}";
Log($"Expected C2D network server log is: {expectedRxSerial}");
// Sends 8x confirmed messages, stopping if C2D message is found
for (var i = warmUpMessageCount + 1; i <= messagesToSend; ++i)
{
var msg = PayloadGenerator.Next().ToString(CultureInfo.InvariantCulture);
Log($"{device.DeviceID}: Sending confirmed '{msg}' {i}/{messagesToSend}");
await ArduinoDevice.transferPacketWithConfirmedAsync(msg, 10);
await Task.Delay(TimeSpan.FromSeconds(5));
// After transferPacketWithConfirmed: Expectation from serial
// +CMSG: ACK Received
await AssertUtils.ContainsWithRetriesAsync("+CMSG: ACK Received", ArduinoDevice.SerialLogs);
// Check that RXDelay was correctly used
await TestFixtureCi.CheckAnswerTimingAsync(device.RXDelay, device.GatewayID);
// check if c2d message was found
// 0000000000000009: C2D message: 58
var searchResults = await TestFixtureCi.SearchNetworkServerModuleAsync(
(messageBody) =>
{
return(messageBody.StartsWith(c2dLogMessage, StringComparison.OrdinalIgnoreCase));
},
new SearchLogOptions(c2dLogMessage)
{
MaxAttempts = 1
});
// We should only receive the message once
if (searchResults.Found)
{
foundC2DMessageCount++;
Log($"{device.DeviceID}: Found C2D message in log (after sending {i}/{messagesToSend}) {foundC2DMessageCount} times");
EnsureNotSeenTooManyTimes(foundC2DMessageCount);
}
var localFoundCloudToDeviceInSerial = ArduinoDevice.SerialLogs.Contains(expectedRxSerial);
if (localFoundCloudToDeviceInSerial)
{
foundReceivePacketCount++;
Log($"{device.DeviceID}: Found C2D message in serial logs (after sending {i}/{messagesToSend}) {foundReceivePacketCount} times");
EnsureNotSeenTooManyTimes(foundReceivePacketCount);
}
TestFixtureCi.ClearLogs();
await Task.Delay(Constants.DELAY_BETWEEN_MESSAGES);
}
Assert.True(foundC2DMessageCount > 0, $"Did not find '{device.DeviceID}: C2D message: {c2dMessageBody}' in logs");
// checks if log arrived
if (foundReceivePacketCount == 0)
{
if (ArduinoDevice.SerialLogs.Contains(expectedRxSerial))
{
foundReceivePacketCount++;
}
}
Assert.True(foundReceivePacketCount > 0, $"Could not find lora receiving message '{expectedRxSerial}'");
}
private async Task Test_Deduplication_Strategies(string devicePropertyName, string strategy)
{
var device = TestFixtureCi.GetDeviceByPropertyName(devicePropertyName);
LogTestStart(device);
await ArduinoDevice.setDeviceModeAsync(LoRaArduinoSerial._device_mode_t.LWABP);
await ArduinoDevice.setIdAsync(device.DevAddr, device.DeviceID, null);
await ArduinoDevice.setKeyAsync(device.NwkSKey, device.AppSKey, null);
await ArduinoDevice.SetupLora(TestFixtureCi.Configuration);
for (var i = 0; i < 10; i++)
{
var msg = PayloadGenerator.Next().ToString(CultureInfo.InvariantCulture);
await ArduinoDevice.transferPacketWithConfirmedAsync(msg, 10);
await Task.Delay(Constants.DELAY_FOR_SERIAL_AFTER_SENDING_PACKET);
// After transferPacket: Expectation from serial
// +CMSG: ACK Received
await AssertUtils.ContainsWithRetriesAsync("+CMSG: ACK Received", ArduinoDevice.SerialLogs);
var allGwGotIt = await TestFixtureCi.ValidateMultiGatewaySources((log) => log.IndexOf($"deduplication Strategy: {strategy}", StringComparison.OrdinalIgnoreCase) != -1);
if (allGwGotIt)
{
var notDuplicate = "\"IsDuplicate\":false";
var isDuplicate = "\"IsDuplicate\":true";
var notDuplicateResult = await TestFixtureCi.SearchNetworkServerModuleAsync((s) => s.IndexOf(notDuplicate, StringComparison.Ordinal) != -1, new SearchLogOptions(notDuplicate));
var duplicateResult = await TestFixtureCi.SearchNetworkServerModuleAsync((s) => s.IndexOf(isDuplicate, StringComparison.Ordinal) != -1, new SearchLogOptions(isDuplicate));
Assert.NotNull(notDuplicateResult.MatchedEvent);
Assert.NotNull(duplicateResult.MatchedEvent);
Assert.NotEqual(duplicateResult.MatchedEvent.SourceId, notDuplicateResult.MatchedEvent.SourceId);
switch (strategy)
{
case "Mark":
var expectedProperty = "dupmsg";
await TestFixture.AssertIoTHubDeviceMessageExistsAsync(device.DeviceID, expectedProperty, "true", new SearchLogOptions(expectedProperty) { SourceIdFilter = duplicateResult.MatchedEvent.SourceId, TreatAsError = true });
await TestFixture.AssertIoTHubDeviceMessageExistsAsync(device.DeviceID, expectedProperty, "true", new SearchLogOptions(expectedProperty) { SourceIdFilter = notDuplicateResult.MatchedEvent.SourceId, TreatAsError = true });
break;
case "Drop":
var logMsg = $"{device.DeviceID}: duplication strategy indicated to not process message";
var droppedLog = await TestFixtureCi.SearchNetworkServerModuleAsync((log) => log.StartsWith(logMsg, StringComparison.Ordinal), new SearchLogOptions(logMsg) { SourceIdFilter = duplicateResult.MatchedEvent.SourceId });
Assert.NotNull(droppedLog.MatchedEvent);
var expectedPayload = $"{{\"value\":{msg}}}";
await TestFixtureCi.AssertIoTHubDeviceMessageExistsAsync(device.DeviceID, expectedPayload, new SearchLogOptions(expectedPayload) { TreatAsError = true });
break;
default:
throw new SwitchExpressionException();
}
}
TestFixtureCi.ClearLogs();
}
}