Remove tx functions

* removed tx rx functions
* Added buffered IO support
* Updated the readme
* Updated version numbers

Author: DerekGn

README.md

@@ -93,30 +93,7 @@ Transmit a packet of data with a specific transmit timeout. The transmit control
 rfmUsbDevice.Transmit(new List<byte>() { 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA }, 1000);
 ```
 
-## Transmit And Receive
-
-Transmit a packet and wait for a response with the default transmit and receive timeouts.
-
-```csharp
-// Transmit data and wait for a response with the default 
-var response = rfmUsbDevice.TransmitReceive(new List<byte>() { 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA });
-```
-
-Transmit a packet and wait for a response with the default receive timeouts and a specified transmit timeout.
-
-```csharp
-// Transmit data and wait for
-var response = rfmUsbDevice.TransmitReceive(new List<byte>() { 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA }, 1000);
-```
-
-Transmit a packet and wait for a response with a specified transmit and receive timeouts.
-
-```csharp
-// Transmit data and wait for
-var response = rfmUsbDevice.TransmitReceive(new List<byte>() { 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA }, 1000, 1000 );
-```
-
-## Irqs
+## Interrupts
 
 Set the Dio pin Irq mask.
 
@@ -150,3 +127,94 @@ if ((rfmUsbDevice.Irq & Irq.PayloadReady) == Irq.PayloadReady)
     // Process packet
 }
 ```
+
+## Buffered Read And Writes
+
+The maximum message size supported by direct read and write of the FIFO is limited to 64 bytes. To support message transmission and reception up to a maximum size of X bytes the RfmUsb IO buffer must be used.
+
+### Receive IO Buffer
+
+The steps required to receive a message via the IO buffer.
+
+* Configure the RfmUsb radio
+* Set the Dio mapping for **Dio0** to **DioMapping1** to capture the **PayloadReady** Irq
+* Set the Dio mapping for **Dio1** to **DioMapping2** to capture the **FifoNotEmpty** Irq
+* Setup the **PacketFormat** to either fixed or variable length
+* Set **PayloadLength** to 0xFF
+* Enable the IO buffer via the **BufferedIoEnable** setting
+* Set the radio **Mode** to **RX**
+* Wait for the **PayloadReady** Irq
+* Read the message bytes to the IO buffer via the **Stream**
+
+```csharp
+// Configure the radio
+InitialiseRadioOpenThings(SerialPort, BaudRate);
+
+// Attach event handlers
+AttachEventHandlers(console);
+
+// Enable DIO0 to capture payload ready IRQ 
+rfmUsbDevice.SetDioMapping(Dio.Dio0, DioMapping.DioMapping1);
+// Enable DIO1 to capture fifo level IRQ for buffered read
+rfmUsbDevice.SetDioMapping(Dio.Dio1, DioMapping.DioMapping2);
+// Set the Irq mask
+rfmUsbDevice.DioInterruptMask = DioIrq.Dio0 | DioIrq.Dio1;
+// Enable the Buffered Io
+rfmUsbDevice.BufferedIoEnable = true;
+// Set the the payload length to 0xFF
+rfmUsbDevice.PayloadLength = 0xFF;
+// Set the mode to rx
+rfmUsbDevice.Mode = Mode.Rx;
+
+// Wait for Irq signal
+SignalSource signalSource = WaitForSignal();
+
+if (signalSource == SignalSource.Irq)
+{
+    if ((rfmUsbDevice.IrqFlags & Rfm69IrqFlags.PayloadReady) == Rfm69IrqFlags.PayloadReady)
+    {
+        rfmUsbDevice.Mode = Mode.Standby;
+
+        byte[] payload = new byte[rfmUsbDevice.Stream.Length];
+
+        // Read the stream
+        rfmUsbDevice.Stream.Read(payload, 0, payload.Length);
+
+        // Process the payload
+        // .............
+```
+
+### Transmit IO Buffer
+
+The steps required to transmit a message via the IO buffer.
+
+* Configure the RfmUsb radio
+* Setup the **PacketFormat** to either fixed or variable length
+* Enable the IO buffer via the **BufferedIoEnable** setting
+* Set the radio **Mode** to **TX**
+* Write the message bytes to the IO buffer via the **Stream**
+
+```csharp
+// Configure the radio
+InitialiseRadioOpenThings(SerialPort, BaudRate);
+
+// Attach event handlers
+AttachEventHandlers(console);
+
+// Enable DIO0 to capture payload ready IRQ 
+rfmUsbDevice.SetDioMapping(Dio.Dio0, DioMapping.DioMapping0);
+// Set the Irq mask
+rfmUsbDevice.DioInterruptMask = DioIrq.Dio0;
+// Enable the Buffered Io
+rfmUsbDevice.BufferedIoEnable = true;
+// Set the the payload length to 0xFF
+rfmUsbDevice.PayloadLength = 0xFF;
+// Set the mode to TX
+rfmUsbDevice.Mode = Mode.Tx;
+
+// Prepare payload
+byte[] payload = new byte[10];
+
+// Write the stream
+rfmUsbDevice.Stream.Write(payload, 0, payload.Length);
+```

RfmUsb.Net.IntTests/GlobalSuppressions.cs

@@ -0,0 +1,8 @@
+// This file is used by Code Analysis to maintain SuppressMessage
+// attributes that are applied to this project.
+// Project-level suppressions either have no target or are given
+// a specific target and scoped to a namespace, type, member, etc.
+
+using System.Diagnostics.CodeAnalysis;
+
+[assembly: SuppressMessage("Naming", "VSSpell001:Spell Check", Justification = "<Pending>", Scope = "namespace", Target = "~N:RfmUsb.Net.IntTests")]

RfmUsb.Net.IntTests/Rfm69Tests.cs

@@ -22,6 +22,9 @@
 * SOFTWARE.
 */
 
+
+// Ignore Spelling: Lna Bw Aes Rssi Dagc Dcc Dio Fei Irq Initalise
+
 using FluentAssertions;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -35,7 +38,7 @@ public class Rfm69Tests : RfmTestCommon
 
         public Rfm69Tests()
         {
-            _rfm69 = _serviceProvider.GetService<IRfm69>();
+            _rfm69 = _serviceProvider.GetService<IRfm69>() ?? throw new NullReferenceException($"Unable to resolve {nameof(IRfm69)}");
             RfmBase = _rfm69;
         }
 
@@ -131,7 +134,7 @@ public void TestDccFreqAfc(DccFreq expected)
         [DataRow(DioIrq.Dio3)]
         [DataRow(DioIrq.Dio4)]
         [DataRow(DioIrq.Dio5)]
-        public void TestDioInterrupMask(DioIrq expected)
+        public void TestDioInterruptMask(DioIrq expected)
         {
             TestAssignedValue(expected, () => _rfm69.DioInterruptMask, (v) => _rfm69.DioInterruptMask = v);
         }
@@ -269,15 +272,15 @@ public void TestIntermediateMode(IntermediateMode expected)
         }
 
         [TestMethod]
-        public void TestListenCoefficentIdle()
+        public void TestListenCoefficientIdle()
         {
-            TestRange(() => _rfm69.ListenCoefficentIdle, (v) => _rfm69.ListenCoefficentIdle = v);
+            TestRange(() => _rfm69.ListenCoefficientIdle, (v) => _rfm69.ListenCoefficientIdle = v);
         }
 
         [TestMethod]
-        public void TestListenCoefficentRx()
+        public void TestListenCoefficientRx()
         {
-            TestRange(() => _rfm69.ListenCoefficentRx, (v) => _rfm69.ListenCoefficentRx = v);
+            TestRange(() => _rfm69.ListenCoefficientRx, (v) => _rfm69.ListenCoefficientRx = v);
         }
 
         [TestMethod]
@@ -367,7 +370,7 @@ public void TestSequencer()
         [TestMethod]
         public void TestSetAesKey()
         {
-            _rfm69.Sync = new List<byte> { 0xAA, 0x55, 0xAA, 0x55 };
+            _rfm69.SetAesKey(new List<byte> { 0xAA, 0x55, 0xAA, 0x55 });
         }
 
         [TestMethod]

RfmUsb.Net.IntTests/Rfm9xFskTests.cs

@@ -35,7 +35,7 @@ public class Rfm9xFskTests : RfmTestCommon
 
         public Rfm9xFskTests()
         {
-            _rfm9x = _serviceProvider.GetService<IRfm9x>();
+            _rfm9x = _serviceProvider.GetService<IRfm9x>() ?? throw new NullReferenceException($"Unable to resolve {nameof(IRfm9x)}");
             RfmBase = _rfm9x;
         }
 
@@ -325,7 +325,7 @@ public void TestPreambleDetectorSize(PreambleDetectorSize expected)
         [TestMethod]
         public void TestPreambleDetectorTotal()
         {
-            TestRange<byte>(() => _rfm9x.PreambleDetectorTotalerance, (v) => _rfm9x.PreambleDetectorTotalerance = v, 0, 0x0F);
+            TestRange<byte>(() => _rfm9x.PreambleDetectorTolerance, (v) => _rfm9x.PreambleDetectorTolerance = v, 0, 0x0F);
         }
 
         [TestMethod]

RfmUsb.Net.IntTests/Rfm9xLoraTests.cs

@@ -35,7 +35,7 @@ public class Rfm9xLoraTests : RfmTestBase
 
         public Rfm9xLoraTests()
         {
-            _rfm9x = _serviceProvider.GetService<IRfm9x>();
+            _rfm9x = _serviceProvider.GetService<IRfm9x>() ?? throw new NullReferenceException($"Unable to resolve {nameof(IRfm9x)}");
             RfmBase = _rfm9x;
         }
 

RfmUsb.Net.IntTests/RfmTestBase.cs

@@ -26,6 +26,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using RfmUsb.Net.Exceptions;
 using RfmUsb.Net.Ports;
 using Serilog;
 using Serilog.Core;
@@ -68,6 +69,67 @@ public RfmTestBase()
 
         public TestContext TestContext { get; set; }
 
+        [TestMethod]
+        public void TestReadStreamDisabled()
+        {
+            // Arrange
+            var bytes = new byte[1];
+
+            RfmBase.BufferedIoEnable = false;
+
+            // Act
+            Action action = () => RfmBase.Stream.Read(bytes);
+
+            // Assert
+            action.Should().Throw<RfmUsbBufferedIoNotEnabledException>();
+        }
+
+        [TestMethod]
+        public void TestReadStreamEnabled()
+        {
+            // Arrange
+            var bytes = new byte[10];
+
+            RfmBase.BufferedIoEnable = true;
+
+            // Act
+            RfmBase.Stream.Read(bytes);
+        }
+
+        [TestMethod]
+        public void TestWriteStreamDisabled()
+        {
+            // Arrange
+            var bytes = new byte[1];
+            var rand = new Random();
+
+            rand.NextBytes(bytes);
+
+            RfmBase.BufferedIoEnable = false;
+
+            // Act
+            Action action = () => RfmBase.Stream.Write(bytes);
+
+            // Assert
+            action.Should().Throw<RfmUsbBufferedIoNotEnabledException>();
+        }
+
+        [TestMethod]
+        [Ignore]
+        public void TestWriteStreamEnabled()
+        {
+            // Arrange
+            var bytes = new byte[100];
+            var rand = new Random();
+
+            rand.NextBytes(bytes);
+
+            RfmBase.BufferedIoEnable = true;
+
+            // Act
+            RfmBase.Stream.Write(bytes);
+        }
+
         internal static IEnumerable<byte> RandomSequence()
         {
             Random r = new Random();

RfmUsb.Net.IntTests/RfmTestCommon.cs

@@ -24,7 +24,6 @@
 
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using RfmUsb.Net.Exceptions;
 
 namespace RfmUsb.Net.IntTests
 {
@@ -69,6 +68,12 @@ public void TestBroadcastAddress()
             TestRange(() => RfmBase.BroadcastAddress, (v) => RfmBase.BroadcastAddress = v);
         }
 
+        [TestMethod]
+        public void TestBufferedIoEnable()
+        {
+            TestRangeBool(() => RfmBase.BufferedIoEnable, (v) => RfmBase.BufferedIoEnable = v);
+        }
+
         [TestMethod]
         public void TestCrcAutoClearOff()
         {
@@ -348,6 +353,7 @@ public void TestSerialNumber()
         {
             Read(() => RfmBase.SerialNumber);
         }
+
         [TestMethod]
         public void TestSync()
         {
@@ -376,71 +382,6 @@ public void TestTemperatureValue()
         }
 
         [TestMethod]
-        [Ignore]
-        public void TestTransmit()
-        {
-            RfmBase.Transmit(new List<byte>() { 0x00, 0x01, 0x02 });
-        }
-
-        [TestMethod]
-        [Ignore]
-        public void TestTransmitReceive()
-        {
-            Action action = () => RfmBase.TransmitReceive(new List<byte>() { 0x00, 0x01, 0x02 });
-
-            action
-                .Should()
-                .Throw<RfmUsbTransmitException>()
-                .WithMessage("Packet transmission failed: [TX Timeout]");
-        }
-
-        [TestMethod]
-        [Ignore]
-        public void TestTransmitReceiveTxRxTimeout()
-        {
-            Action action = () => RfmBase.TransmitReceive(new List<byte>() { 0x00, 0x01, 0x02 }, 1000, 1000);
-
-            action
-                .Should()
-                .Throw<RfmUsbTransmitException>()
-                .WithMessage("Packet transmission failed: [TX Timeout]");
-        }
-
-        [TestMethod]
-        [Ignore]
-        public void TestTransmitReceiveTxTimeout()
-        {
-            Action action = () => RfmBase.TransmitReceive(new List<byte>() { 0x00, 0x01, 0x02 }, 1000);
-
-            action
-                .Should()
-                .Throw<RfmUsbTransmitException>()
-                .WithMessage("Packet transmission failed: [TX Timeout]");
-        }
-
-        [TestMethod]
-        [Ignore]
-        public void TestTransmitWithCountAndInterval()
-        {
-            RfmBase.Transmit(new List<byte>() { 0x00, 0x01, 0x02 }, 1, 100);
-        }
-
-        [TestMethod]
-        [Ignore]
-        public void TestTransmitWithCountAndIntervalAndTimeout()
-        {
-            RfmBase.Transmit(new List<byte>() { 0x00, 0x01, 0x02 }, 1, 100, 1000);
-        }
-
-        [TestMethod]
-        [Ignore]
-        public void TestTransmitWithTxCount()
-        {
-            RfmBase.Transmit(new List<byte>() { 0x00, 0x01, 0x02 }, 1);
-        }
-
-        [TestMethod]
-        [Ignore]
         public void TestTxStartCondition()
         {
             TestRangeBool(() => RfmBase.TxStartCondition, (v) => RfmBase.TxStartCondition = v);