RFM69 hat library h WWWWWWWWoo

Again, while doing some stress testing I noticed an odd message go past in the Visual Studio output window. I had multiple devices sending addressed messages (both individual and broadcast) to the Adafruit RFM69 HCW Radio Bonnet, on my Windows 10 IoT Core device while it was sending a message every 5 seconds.

Received From 102 a 15 byte message Hello World:161
23:42:33.343 RegIrqFlags2 01100110
23:42:33.356 RegIrqFlags1 11011001
23:42:33.374 Address 0X99 10011001
Received From 153 a 15 byte message Hello World:106
23:42:33.761 RegIrqFlags2 01100110
23:42:33.774 RegIrqFlags1 11011001
23:42:33.791 Address 0X66 01100110
Received From 102 a 15 byte message Hello World:162
The thread 0xd20 has exited with code 0 (0x0).
23:42:34.500 RegIrqFlags2 01100110
23:42:34.501 Send-hello world 11:42:34 PM
23:42:34.520 RegIrqFlags1 11011001
23:42:34.545 Send-Done
23:42:34.551 Address 0X10 00010000
Received From 16 a 15 byte message h    WWWWWWWWoo
23:42:34.686 RegIrqFlags2 00001000
23:42:34.701 RegIrqFlags1 10110000
23:42:34.715 Transmit-Done
Transmit-Done
23:42:34.902 RegIrqFlags2 01100110
23:42:34.915 RegIrqFlags1 11011001
23:42:34.931 Address 0X66 01100110
Received From 102 a 15 byte message Hello World:163
23:42:35.626 RegIrqFlags2 01100110
23:42:35.640 RegIrqFlags1 11011001
23:42:35.659 Address 0X99 10011001
Received From 153 a 15 byte message Hello World:108
23:42:36.042 RegIrqFlags2 01100110
23:42:36.055 RegIrqFlags1 11011001
23:42:36.073 Address 0X66 01100110

The RegIrqFlags2 CrcOk (bit 1) was set and the message was corrupt.

RegIrqFlags2 bit flags from SX1231 datasheet

I have added code to check the CRC on inbound messages if this functionality is enabled. So the library can be used with CRCs disabled I have added a flag to the OnDataReceivedEventArgs class to indicate whether the CRC on the inbound message was OK.

private readonly Object Rfm9XRegFifoLock = new object();
...
private void ProcessPayloadReady(RegIrqFlags1 irqFlags1, RegIrqFlags2 irqFlags2)
{
	byte? address = null;
	byte numberOfBytes;
	byte[] messageBytes;

	lock (Rfm9XRegFifoLock)
	{
		// Read the length of the buffer if variable length packets
		if (PacketFormat == RegPacketConfig1PacketFormat.VariableLength)
		{
			numberOfBytes = RegisterManager.ReadByte((byte)Rfm69HcwDevice.Registers.RegFifo);
		}
		else
		{
			numberOfBytes = PayloadLength;
		}

		// Remove the address from start of the payload
		if (AddressingEnabled)
		{
			address = RegisterManager.ReadByte((byte)Rfm69HcwDevice.Registers.RegFifo);

			Debug.WriteLine("{0:HH:mm:ss.fff} Address 0X{1:X2} {2}", DateTime.Now, address, Convert.ToString((byte)address, 2).PadLeft(8, '0'));
			numberOfBytes--;
		}

		// Allocate a buffer for the payload and read characters from the Fifo
		messageBytes = new byte[numberOfBytes];

		for (int i = 0; i < numberOfBytes; i++)
		{
			messageBytes[i] = RegisterManager.ReadByte((byte)Rfm69HcwDevice.Registers.RegFifo);
		}
	}
...
public void SendMessage(byte[] messageBytes)
{
#region Guard conditions
#endregion

	lock (Rfm9XRegFifoLock)
	{
		SetMode(RegOpModeMode.StandBy);

		if (PacketFormat == RegPacketConfig1PacketFormat.VariableLength)
		{
			RegisterManager.WriteByte((byte)Registers.RegFifo, (byte)messageBytes.Length);
		}

		foreach (byte b in messageBytes)
		{
			this.RegisterManager.WriteByte((byte)Registers.RegFifo, b);
		}

		SetMode(RegOpModeMode.Transmit);
	}
}

I can most probably reduce the duration which I hold the lock for but that will require some more stress testing.

RFM69 hat library Hello Woooooooo

While doing some stress testing I noticed an odd message go past in the Visual Studio output window. I had multiple devices sending addressed messages (both individual and broadcast) to the Adafruit RFM69 HCW Radio Bonnet, on my Windows 10 IoT Core device while it was sending a message every 5 seconds.

Received From 153 a 13 byte message Hello World:7
18:43:56.544 RegIrqFlags2 01100110
18:43:56.558 RegIrqFlags1 11011001
18:43:56.575 Address 0X66 01100110
Received From 102 a 15 byte message Hello World:162
The thread 0x254 has exited with code 0 (0x0).
18:43:57.699 Send-hello world 6:43:57 PM
18:43:57.699 RegIrqFlags2 01100110
18:43:57.731 RegIrqFlags1 10000000
18:43:57.747 Address 0X66 01100110
18:43:57.765 Send-Done
Received From 102 a 15 byte message Hello Woooooooo
18:43:57.987 RegIrqFlags2 00001000
18:43:58.003 RegIrqFlags1 10110000
18:43:58.017 Transmit-Done
Transmit-Done
18:43:58.825 RegIrqFlags2 01100110
18:43:58.838 RegIrqFlags1 11011001
18:43:58.857 Address 0X66 01100110
Received From 102 a 15 byte message Hello World:164
18:43:59.966 RegIrqFlags2 01100110
18:43:59.979 RegIrqFlags1 11011001
18:43:59.998 Address 0X66 01100110

The odd thing was that the RegIrqFlags2 CrcOk (bit 1) was set but the message was still corrupt.

RegIrqFlags2 bit flags from SX1231 datasheet

After looking at the code I think the problem was the reading of the received message bytes from the device FIFO and the writing of bytes of message to be transmitted into the device FIFO overlapped. To stop this occurring again I have added code to synchronise access (using a Lock) to the FIFO.

private readonly Object Rfm9XRegFifoLock = new object();
...
private void ProcessPayloadReady(RegIrqFlags1 irqFlags1, RegIrqFlags2 irqFlags2)
{
	byte? address = null;
	byte numberOfBytes;
	byte[] messageBytes;

	lock (Rfm9XRegFifoLock)
	{
		// Read the length of the buffer if variable length packets
		if (PacketFormat == RegPacketConfig1PacketFormat.VariableLength)
		{
			numberOfBytes = RegisterManager.ReadByte((byte)Rfm69HcwDevice.Registers.RegFifo);
		}
		else
		{
			numberOfBytes = PayloadLength;
		}

		// Remove the address from start of the payload
		if (AddressingEnabled)
		{
			address = RegisterManager.ReadByte((byte)Rfm69HcwDevice.Registers.RegFifo);

			Debug.WriteLine("{0:HH:mm:ss.fff} Address 0X{1:X2} {2}", DateTime.Now, address, Convert.ToString((byte)address, 2).PadLeft(8, '0'));
			numberOfBytes--;
		}

		// Allocate a buffer for the payload and read characters from the Fifo
		messageBytes = new byte[numberOfBytes];

		for (int i = 0; i < numberOfBytes; i++)
		{
			messageBytes[i] = RegisterManager.ReadByte((byte)Rfm69HcwDevice.Registers.RegFifo);
		}
	}
...
public void SendMessage(byte[] messageBytes)
{
#region Guard conditions
#endregion

	lock (Rfm9XRegFifoLock)
	{
		SetMode(RegOpModeMode.StandBy);

		if (PacketFormat == RegPacketConfig1PacketFormat.VariableLength)
		{
			RegisterManager.WriteByte((byte)Registers.RegFifo, (byte)messageBytes.Length);
		}

		foreach (byte b in messageBytes)
		{
			this.RegisterManager.WriteByte((byte)Registers.RegFifo, b);
		}

		SetMode(RegOpModeMode.Transmit);
	}
}

The code has been running for a day without any corrupted messages so the lock appears to be working. I can most probably reduce the duration which I hold the lock for but that will require some more stress testing.

RFM69 hat library Part12E

Enums and Masks – RegDIOMapping1 & RegDIOMapping2

The RFM69CW/RFM69HCW module (based on the Semtech SX1231/SX1231H) has configurable digital outputs (RegDIOMapping1 & RegDIOMapping2) . Which I use to trigger interrupts on my Windows 10 IoT Core or Arduino devices. Currently (Sep 2019) the library only supports the mapping of the digital outputs D0 & D1 when the RFM69 is in Packet Mode.

RegiDIOMapping0 & RegDIOMapping2 settings for DIO thru DIO5

I added some additional constants and enumerations for the other settings configured in RegDioMapping1 & RegDioMapping2.

// RegDioMapping1 & RegDioMapping2 Packet Mode Table 22 pg48
// DIO 0 Bits 7&6 of RegDioMapping1
[Flags]
public enum Dio0Mapping
{
	// Sleep
	// Standby
	// Frequency Synthesis
	// Reserved 00-10
	FrequencySynthesisPllLock = 0b11000000,
	ReceiveCrcOk = 0b00000000,
	ReceivePayloadReady = 0b01000000,
	ReceiveSyncAddress = 0b10000000,
	ReceiveRssi = 0b11000000,
	TransmitPacketSent = 0b00000000,
	TransmitTxReady = 0b01000000,
	// Reserved 10
	PllLock = 0b11000000
}
const Dio0Mapping Dio0MappingDefault = 0x00;

// DIO 1 Bits 5&4 of RegDioMapping1
public enum Dio1Mapping
{
	SleepFifoLevel = 0b00000000,
	SleepFifoFull = 0b00010000,
	SleepFifoNotEmpty = 0b00100000,
	// Reserved 11
	StandByFifoLevel = 0b00000000,
	StandByFifoFull = 0b00010000,
	StandByFifoNotEmpty = 0b00100000,
	FrequencySynthesisFifoLevel = 0b00000000,
	FrequencySynthesisFifoFull = 0b00010000,
	FrequencySynthesisFifoNotEmpty = 0b00100000,
	FrequencySynthesisPllLock = 0b00110000,
	ReceiveFifoLevel = 0b00000000,
	ReceiveFifoFull = 0b00010000,
	ReceiveFifoNotEmpty = 0b00100000,
	ReceiveTimeout = 0b00110000,
	TransmitFifoLevel = 0b00000000,
	TransmitFifoFull = 0b00010000,
	TransmitFifoNotEmpty = 0b00100000,
	TransmitPllLock = 0b00110000,
}
const Dio1Mapping Dio1MappingDefault = 0x00;

// DIO 2 Bits 3&2 of RegDioMapping1
public enum Dio2Mapping
{
}
const Dio2Mapping Dio2MappingDefault = 0x00;

// DIO 2 Bits 1&0 of RegDioMapping1
public enum Dio3Mapping
{
}
const Dio3Mapping Dio3MappingDefault = 0x00;

// DIO 2 Bits 7&6 of RegDioMapping2
public enum Dio4Mapping
{
}
const Dio4Mapping Dio4MappingDefault = 0x00;

// DIO 2 Bits 5&4 of RegDioMapping2
public enum Dio5Mapping
{
}
const Dio5Mapping Dio5MappingDefault = 0x00;

// RegDioMapping2 Bits 2-0
public enum ClockOutDioMapping : byte
{
	FXOsc = 0b00000000,
	FXOscDiv2 = 0b00000001,
	FXOscDiv4 = 0b00000010,
	FXOscDiv8 = 0b00000011,
	FXOscDiv16 = 0b00000100,
	FXOscDiv32 = 0b00000101,
	RC = 0b00000110,
	Off = 0b00000111,
}
public const ClockOutDioMapping ClockOutDioMappingDefault = ClockOutDioMapping.Off;

I also added some code to the initialise method to set the RegDioMapping1 & RegDioMapping1 only if the values were not the defaults.

public void Initialise(RegOpModeMode modeAfterInitialise,
	bool sequencer = RegOpModeSequencerDefault,
	bool listen = RegOpModeListenDefault,
	BitRate bitRate = BitRateDefault,
	ushort frequencyDeviation = frequencyDeviationDefault,
	double frequency = FrequencyDefault,
	AfcLowBeta afcLowBeta = AfcLowBetaDefault,
	ListenModeIdleResolution listenModeIdleResolution = ListenModeIdleResolutionDefault, ListenModeRXTime listenModeRXTime = ListenModeRXTimeDefault, ListenModeCriteria listenModeCrieria = ListenModeCriteriaDefault, ListenModeEnd listenModeEnd = ListenModeEndDefault,
	byte listenCoefficientIdle = ListenCoefficientIdleDefault,
	byte listenCoefficientReceive = ListenCoefficientReceiveDefault,
	bool pa0On = pa0OnDefault, bool pa1On = pa1OnDefaut, bool pa2On = pa2OnDefault, byte outputpower = OutputpowerDefault,
	PaRamp paRamp = PaRampDefault,
	bool ocpOn = OcpOnDefault, byte ocpTrim = OcpTrimDefault,
	LnaZin lnaZin = LnaZinDefault, LnaCurrentGain lnaCurrentGain = LnaCurrentGainDefault, LnaGainSelect lnaGainSelect = LnaGainSelectDefault,
	byte dccFrequency = DccFrequencyDefault, RxBwMant rxBwMant = RxBwMantDefault, byte RxBwExp = RxBwExpDefault,
	byte dccFreqAfc = DccFreqAfcDefault, byte rxBwMantAfc = RxBwMantAfcDefault, byte bxBwExpAfc = RxBwExpAfcDefault,
	Dio0Mapping dio0Mapping = Dio0MappingDefault,
	Dio1Mapping dio1Mapping = Dio1MappingDefault,
	Dio2Mapping dio2Mapping = Dio2MappingDefault,
	Dio3Mapping dio3Mapping = Dio3MappingDefault,
	Dio4Mapping dio4Mapping = Dio4MappingDefault,
	Dio5Mapping dio5Mapping = Dio5MappingDefault,
	ClockOutDioMapping clockOutDioMapping = ClockOutDioMappingDefault,
	ushort preambleSize = PreambleSizeDefault,
	RegSyncConfigFifoFileCondition? syncFifoFileCondition = null, byte? syncTolerance = null, byte[] syncValues = null,
	RegPacketConfig1PacketFormat packetFormat = RegPacketConfig1PacketFormat.FixedLength,
	RegPacketConfig1DcFree packetDcFree = RegPacketConfig1DcFreeDefault,
	bool packetCrc = PacketCrcOnDefault,
	bool packetCrcAutoClear = PacketCrcAutoClearDefault,
	byte payloadLength = PayloadLengthDefault,
	byte? addressNode = null, byte? addressbroadcast = null,
	TxStartCondition txStartCondition = TxStartConditionDefault, byte fifoThreshold = FifoThresholdDefault,
	byte interPacketRxDelay = InterPacketRxDelayDefault, bool autoRestartRx = AutoRestartRxDefault,
	byte[] aesKey = null
	)
...
	// RegDioMapping1
	if ((dio0Mapping != Dio0MappingDefault) ||
	    (dio1Mapping != Dio1MappingDefault) ||
	    (dio2Mapping != Dio2MappingDefault) ||
	    (dio3Mapping != Dio3MappingDefault))
	{
		byte regDioMapping1Value = (byte)dio0Mapping;

		regDioMapping1Value |= (byte)dio1Mapping;
		regDioMapping1Value |= (byte)dio2Mapping;
		regDioMapping1Value |= (byte)dio3Mapping;

		RegisterManager.WriteByte((byte)Registers.RegDioMapping1, regDioMapping1Value);
	}

	// RegDioMapping2
	if ((dio4Mapping != Dio4MappingDefault) ||
		 (dio5Mapping != Dio5MappingDefault) ||
		 (clockOutDioMapping != ClockOutDioMappingDefault ))
	{
		byte regDioMapping2Value = (byte)dio4Mapping;

		regDioMapping2Value |= (byte)dio5Mapping;
		regDioMapping2Value |= (byte)clockOutDioMapping;

		RegisterManager.WriteByte((byte)Registers.RegDioMapping2, regDioMapping2Value);
	}

I had several failed attempts at defining suitable enumerations for configuring the RegDioMapping1 & RegDioMapping2 registers. I initially started with an enumeration for each Mode (Sleep, StandBy etc.) but the implementation was quite complex. The initial version only supports DIO0 & DIO1 as most of the shields I have, only DIO0 adn/or DIO1 are connected.