The nrf24l01 used on the boards is probably a counterfeit chip. It
cannot acknowledge received packets (probably a bit flip of the NO_ACK
bit described here:
https://ncrmnt.org/2015/03/13/how-do-i-cost-optimize-nrf24l01/) if the
dynamic packet length is disabled.

weather-sensor/firmware/main.c

 volatile uint8_t executionFlag;
 
 
-static uint8_t messageBuffer[PACKET_LENGTH];
-static PACKET * packet = (PACKET*) messageBuffer;
+
+static PACKET reportPacket;
 
 
 void Enter_Power_Save_Mode(void);
 void Exit_Power_Save_Mode(void);
 
 
-bool Send_Get_Salt_Message(PACKET * packet, uint64_t salt); //TODO: put into own file
-
+/* TODO Notes for power saving:
+ * - Power-save-mode needed -> SM2...0 bits written to 011
+ * - Entering by issuing the SLEEP instruction -> What call in C?
+ *   - Before executing the SLEEP instruction, write bit SE of the SMCR to 1
+ * - Let Timer/Counter2 run with the necessary period and enable an interrupt.
+ *   -> The Global Interrupt Enable bit in SREG has to be set.
+ * - asynchronous/synchronous clock source?
+ * - When waking up
+ *   - Set PRR bits for needed peripherals
+ * - 
+ */
 void Set_Up_Power_Save_Mode(void);
 void Enter_Power_Save_Mode(void);
 
 {
 	struct bme280_data sensorData;
 	uint16_t crc;
-	bool saltReceived = false;
 
 	/* Enable the debug LED */
 	LED_DDR |= (1 << LED_PIN);
 	Set_Up_Power_Save_Mode();
 
 	/* Initialize the salt */
-	salt = 0x0ull;
+	salt = 0xFFFFFFFFFFFFFF00ull;
 	salt |= ownId;
 
-
-	/* TODO: Request a salt from the base station:
-	 * - loop as long as no reply from the base station was received:
-	 *   - send the packet that requests the salt
-	 *   - if no ack is received for the packet go direclty to sleep for 100 ms
-	 *   - if no salt is received within 100 ms send the message again
-	 *   - keep the LED on for the duration to allow the user to see that the device is ready for operation.
-	 */
-	//LED_PORT |= (1 << LED_PIN);
-	do
-	{
-		// TODO: send the GET_SALT message
-		if (Send_Get_Salt_Message(packet, salt) == true)
-		{
-			if (NRF24L01_Receive_Message(messageBuffer, 100 /*ms*/) == true)
-			{
-				saltReceived = true;
-			}
-		}
-		else
-		{
-			/* TODO: enter power save mode instead to make the battery life longer */
-			_delay_ms(100);
-		}
-	} while (saltReceived == false);
-
-
 	/* Delay the change of the operating frequency by the function Enter_Power_Save_Mode for the
 	 * first function pass. If it is changed before the ISP can flash the MCU the clocks of the ISP
 	 * and MCU are mismatched and the flashing will fail.
 			BME280_Get_Measurement(&sensorData);
 
 
-			/* TODO: put the following into a Send_Report function */
-			memset((uint8_t*)packet, 0, PACKET_LENGTH); //Reinitialize the buffer with zeros
+			memset((uint8_t*)&reportPacket, 0, sizeof(reportPacket)); //Reinitialize the buffer with zeros
 
 			salt &= ~(1ull<<63);
-			packet->salt = salt;
-			packet->payload.reportData.packetIdentifier.elementCount = 3;
-			packet->payload.reportData.packetIdentifier.packetType = PACKET_TYPE_REPORT;
+			reportPacket.salt = salt;
+			reportPacket.payload.values.packetIdentifier.elementCount = 3;
+			reportPacket.payload.values.packetIdentifier.packetType = PACKET_TYPE_REPORT;
 
 			/* Fill in the payload */
-			packet->payload.reportData.valueTypeTemperature = VALUE_TYPE_TEMPERATURE;
-			packet->payload.reportData.temperature = sensorData.temperature/10;
-			packet->payload.reportData.valueTypePressure = VALUE_TYPE_PRESSURE;
-			packet->payload.reportData.pressure = sensorData.pressure;
-			packet->payload.reportData.valueTypeHumidity = VALUE_TYPE_HUMIDITY;
-			packet->payload.reportData.humidity = sensorData.humidity * 100/1024;
+			reportPacket.payload.values.valueTypeTemperature = VALUE_TYPE_TEMPERATURE;
+			reportPacket.payload.values.temperature = sensorData.temperature/10;
+			reportPacket.payload.values.valueTypePressure = VALUE_TYPE_PRESSURE;
+			reportPacket.payload.values.pressure = sensorData.pressure;
+			reportPacket.payload.values.valueTypeHumidity = VALUE_TYPE_HUMIDITY;
+			reportPacket.payload.values.humidity = sensorData.humidity * 100/1024;
 
 			/* Calculate the CRC */
-			crc = Calculate_Crc(packet->payload.buffer, PACKET_PAYLOAD_BUFFER_LENGTH);
-			packet->crc = crc;
+			crc = Calculate_Crc(reportPacket.payload.buffer, PACKET_BUFFER_LENGTH);
+			reportPacket.crc = crc;
 
 			/* Encrypt the packet */
 			/* TODO: 
 			 * - increment the salt for every packet
 			 * - Receive salt from the base station
 			 */
-			Encrypt((uint32_t*) packet->payload.buffer,
-			        PACKET_PAYLOAD_BUFFER_LENGTH + sizeof(crc),
+			Encrypt((uint32_t*) &reportPacket.payload.buffer,
+			        PACKET_BUFFER_LENGTH + sizeof(crc),
 			        salt, (uint32_t*) encryptionKey);
 
-			NRF24L01_Send_Message((uint8_t*)packet, PACKET_LENGTH);
+			NRF24L01_Send_Message((uint8_t*)&reportPacket, sizeof(reportPacket));
 
 			_delay_ms(100); /* TODO: only for debugging, remove this later! */
-			//LED_PORT &= ~(1 << LED_PIN);
+			LED_PORT &= ~(1 << LED_PIN);
 
 			cycle = 0;
 		}
 	PRR &= ~(1<<PRSPI); // Enable SPI
 	Initialize_SPI(); // reinitalize SPI
 }
-
-bool Send_Get_Salt_Message(PACKET * packet, uint64_t salt) //TODO: put into own file
-{
-	bool success = false;
-	uint16_t crc;
-
-	memset((uint8_t*)packet, 0, PACKET_LENGTH); //Reinitialize the buffer with zeros
-
-	salt &= ~(1ull<<63); /* Set the most significant bit to 0 to indicate a packet from the device to the base station */
-
-	packet->salt = salt;
-	packet->payload.reportData.packetIdentifier.elementCount = 0;
-	packet->payload.reportData.packetIdentifier.packetType = PACKET_TYPE_GET_SALT;
-
-	/* Calculate the CRC */
-	crc = Calculate_Crc(packet->payload.buffer, PACKET_PAYLOAD_BUFFER_LENGTH);
-	packet->crc = crc;
-
-	Encrypt((uint32_t*) packet->payload.buffer,
-	        PACKET_PAYLOAD_BUFFER_LENGTH + sizeof(crc),
-	        salt, (uint32_t*) encryptionKey);
-
-	success = NRF24L01_Send_Message((uint8_t*)packet, PACKET_LENGTH);
-
-
-	return success;
-}
-
-//bool Read_Salt_Message(PACKET * packet, uint64_t * salt)
-//{
-//	uint16_t crcRemainder = 0xFFFF;
-//	uint64_t baseStationSalt = 0x0;
-//
-//	baseStationSalt = packet->salt;
-////	if (packet->payload.reportData.packetIdentifier != PACKET_TYPE_SALT)
-////	{
-////		return false;
-////	}
-//
-//	return true;
-//}

weather-sensor/firmware/nrf24l01.c

 extern volatile bool nrfInterruptRaised;
 
 void Print_Register_Contents(uint8_t address);
-
 void Send_TX_Flush_Command(void);
-void Send_RX_Flush_Command(void);
 
-static uint8_t Write_One_Byte(uint8_t byte1);
-static uint8_t Write_Two_Bytes(uint8_t byte1, uint8_t byte2);
+static void Write_Two_Bytes(uint8_t byte1, uint8_t byte2);
 static void Write_Byte_And_Buffer(uint8_t byte, uint8_t * buffer, uint8_t length);
 
 /* Startup and initial configuration of the NRF24L01 */
 	_delay_ms(2);
 
 	/* The NRF24L01 is now in the mode Standby-I */
-
-	/* Flush the FIFOs */
-	Send_TX_Flush_Command();
-	Send_RX_Flush_Command();
 }
 
 void Set_NRF24L01_Pins(void)
 	EN_RXADDR_REGISTER enableRxAddressesRegisterContents = {.byte = 0x0};
 	RX_PW_Pn_REGISTER rxPwPnRegisterContents = {.byte = 0x0};
 	EN_AA_REGISTER enAaRegister = {.byte = 0x0};
+	FEATURE_REGISTER featureRegisterContents = {.byte = 0x0};
+	DYNPD_REGISTER dyndpRegisterContents = {.byte = 0x0};
 
 	uint8_t txAddress[5] = {0xB3, 0xB3, 0xB3, 0xB3, 0x00};
-	uint8_t rx1Address[5] = {0xB3, 0xB3, 0xB3, 0xB3, 0x00};
+	uint8_t rx0Address[5] = {0xB3, 0xB3, 0xB3, 0xB3, 0x00};
+	/* 
+	 * - Length of CRC (CRCO in CONFIG)
+	 * - Enable auto acknowledgment (EN_AA)
+	 *   -> Register already set correctly after reset
+	 * - Enable data pipes (EN_RXADDR)?
+	 *   -> Two pipes are already enabled on reset
+	 * - Set up address width (SETUP_AW)
+	 *   -> 3 bytes
+	 * - Automatic Retransmission (SETUP_RETR)
+	 *   -> ARD = 0b0000
+	 *   -> 3 retransmits -> ARC = 0b0011
+	 *   -> Register already set correctly after reset
+	 * - RF Channel (RF_CH)
+	 *   -> RF_CH = 0b1010000
+	 * - RF Setup (RF_SETUP)
+	 *   -> first use reset values, can be fine tuned later
+	 * - Enable dynamic payload length (DYNPD) -> command activate + 0x73, then set bits in FEATURE?
+	 */
+
+	/* Set the address width to 3 bytes */
+	//Write_NRF_Register(0x03, 0x1);
 
 	/* Set the frequency to 1450 MHz */
 	Write_NRF_Register(RF_CH_ADDRESS, 0x32);
 
+	/* Enable dynamic payload length */
+	Send_Activate_Command();
+	featureRegisterContents.bits.EN_DPL = 1; // enable dynamic payload length
+	Write_NRF_Register(FEATURE_ADDRESS, featureRegisterContents.byte);
+
+	/* set dynamic payload length for all data pipes
+	 * When the dynamic payload length is not set the module cannot receive packets from some
+	 * stations. This is probably due to counterfeit NRF24L01+ chips.
+	 */
+	dyndpRegisterContents.bits.DPL_P0 = 1;
+	dyndpRegisterContents.bits.DPL_P1 = 1;
+	dyndpRegisterContents.bits.DPL_P2 = 1;
+	dyndpRegisterContents.bits.DPL_P3 = 1;
+	dyndpRegisterContents.bits.DPL_P4 = 1;
+	dyndpRegisterContents.bits.DPL_P5 = 1;
+	Write_NRF_Register(DYNPD_ADDRESS, dyndpRegisterContents.byte);
+
 	/* Set up the auto retries */
+
+	/* */
 	setupRetrRegisterContents.bits.ARC = 0x3;
 	setupRetrRegisterContents.bits.ARD = 0xF;
 	Write_NRF_Register(SETUP_RETR_ADDRESS, setupRetrRegisterContents.byte);
 	/* Set the TX address */
 	Set_TX_Address(txAddress, MAX_ADDRESS_LENGTH);
 
-	/* Set the address of the RX pipe 0 to the one of the base station to receive acks */
-	Set_RX_P0_Address(txAddress, MAX_ADDRESS_LENGTH);
-
-	/* Set the address of the RX pipe 1 to the own address to receive messages */
-	rx1Address[4] = moduleId; // The last byte of the address corresponds to the Id set by the pin programming
-	Set_RX_P1_Address(rx1Address, MAX_ADDRESS_LENGTH);
-
-	/* Enable the rx addresses for pipe 0 and pipe 1*/
-	enableRxAddressesRegisterContents.bits.ERX_P0 = 1;
-	enableRxAddressesRegisterContents.bits.ERX_P1 = 1;
-	Write_NRF_Register(EN_RXADDR_ADDRESS, enableRxAddressesRegisterContents.byte);
-
-	/* Set the payload witth for pipe 1 */
-	rxPwPnRegisterContents.bits.RX_PW_Pn = 32;
-	Write_NRF_Register(RX_PW_P1_ADDRESS, rxPwPnRegisterContents.byte);
-
-	rxPwPnRegisterContents.bits.RX_PW_Pn = 0;
-	Write_NRF_Register(RX_PW_P0_ADDRESS, rxPwPnRegisterContents.byte); // auto-ack pipe
-	Write_NRF_Register(RX_PW_P2_ADDRESS, rxPwPnRegisterContents.byte); // not used
-	Write_NRF_Register(RX_PW_P3_ADDRESS, rxPwPnRegisterContents.byte); // not used
-	Write_NRF_Register(RX_PW_P4_ADDRESS, rxPwPnRegisterContents.byte); // not used
-	Write_NRF_Register(RX_PW_P5_ADDRESS, rxPwPnRegisterContents.byte); // not used
-
-	/* Enable auto acknowledge for pipe 1 */
-	enAaRegister.bits.ENAA_P0 = 1;
-	enAaRegister.bits.ENAA_P1 = 1;
-	enAaRegister.bits.ENAA_P2 = 1;
-	enAaRegister.bits.ENAA_P3 = 1;
-	enAaRegister.bits.ENAA_P4 = 1;
-	enAaRegister.bits.ENAA_P5 = 1;
-	Write_NRF_Register(EN_AA_ADDRESS, enAaRegister.byte);
+	/* Set the RX_P0 address to the one of the base station to receive acks */
+	Set_RX_P0_Address(rx0Address, MAX_ADDRESS_LENGTH);
 
 
 	PCMSK2 |= (1<<PCINT21); // Set the external interrupt for PD5
 }
 
-bool NRF24L01_Send_Message(uint8_t *buffer, uint8_t length)
+void NRF24L01_Send_Message(uint8_t *buffer, uint8_t length)
 {
-	bool success = false;
 	STATUS_REGISTER statusRegisterContents = {.byte = 0x0};
 	
 	if ((length > 32) || (length == 0))
 	{
-		return success;
+		return;
 	}
 
 	PCICR |= (1<<PCIE2); // Enable the interrupt for the IRQ signal
 	 * induced by the SPI:
 	 * https://forum.mysensors.org/topic/10452/nrf24l01-communication-failure-root-cause-and-solution
 	 */
+	LED_PORT |= (1 << LED_PIN);
 
 	statusRegisterContents.byte = Read_NRF_Status_Register();
 
 	{
 		Send_TX_Flush_Command(); /* Remove the packet from the TX FIFO as it is not done automatically */
 	}
-	else
-	{
-		success = true;
-	}
 	
 
 	/* Reset the interrupts */
 	nrfInterruptRaised = false;
 
 
-	return success;
+	return;
 }
 
-bool NRF24L01_Receive_Message(uint8_t *buffer, uint8_t duration)
+uint8_t Read_NRF_Status_Register(void)
 {
-	uint8_t messageReceived = false;
-	CONFIG_REGISTER configRegisterContents = {.byte = 0x0};
-	STATUS_REGISTER statusRegisterContents = {.byte = 0x0};
-	FIFO_STATUS_REGISTER fifoStatusRegisterContents = {.byte = 0x0};
+	uint8_t registerContents;
 
-	// Enable the receive mode
-	configRegisterContents.byte = Read_NRF_Register(CONFIG_ADDRESS);
-	configRegisterContents.bits.PRIM_RX = 0x1;
-	Write_NRF_Register(CONFIG_ADDRESS, configRegisterContents.byte);
+	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
+	registerContents = SPI_Transfer_Byte(0x00);
+	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
+	return registerContents;
+}
 
-	NRF_CE_PORT |= (1 << NRF_CE_PIN);
 
-	while ((nrfInterruptRaised == false) && (duration > 0))
-	{
-		_delay_ms(1);
-		duration --;
-	};
+/* TODO: rewrite the read register function if it is needed (remove the read operations for the 5-byte registers)*/
+#if 0
+uint8_t Read_NRF_Register(uint8_t address, uint8_t * registerContents)
+{
+	/* TODO: simplify this function, as the registers with more than one byte are accessed with other functions */
+	uint8_t numberOfBytes = 0;
 
-	if (nrfInterruptRaised == true) // check if a message was received
+	if ((address == 0x0A) ||
+	    (address == 0x0B) ||
+	    (address == 0x10))
+	{
+		numberOfBytes = 5;
+	}
+	else
 	{
-		/* A message was received */
-
-		LED_PORT |= (1 << LED_PIN);
-		statusRegisterContents.byte = Read_NRF_Status_Register();
-		if (statusRegisterContents.bits.RX_DR == 1)
-		{
-			fifoStatusRegisterContents.byte = Read_NRF_Status_Register();
-			if (fifoStatusRegisterContents.bits.RX_EMPTY != 1)
-			{
-				Read_Message_From_RX_FIFO(PACKET_LENGTH, buffer); /* TODO: only possible after CE = 0? */
-				messageReceived = true;
-			}
-		}
-
-		nrfInterruptRaised = false;
+		numberOfBytes = 1;
 	}
 
-	// Set the NRF to standby
-	NRF_CE_PORT &= ~(1 << NRF_CE_PIN);
+	/* First write the address */
+	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
 
-	configRegisterContents.byte = Read_NRF_Register(CONFIG_ADDRESS);
-	configRegisterContents.bits.PRIM_RX = 0x0;
-	Write_NRF_Register(CONFIG_ADDRESS, configRegisterContents.byte);
 
-	/* Reset the interrupts */
-	statusRegisterContents.bits.TX_DS = 1;
-	statusRegisterContents.bits.MAX_RT = 1;
-	statusRegisterContents.bits.RX_DR = 1;
-	Write_NRF_Register(STATUS_ADDRESS, statusRegisterContents.byte);
+	SPI_Transfer_Byte(address);
 
-	return messageReceived;
-}
+	/* Read the register bytes */
+	for (uint8_t i = 0; i < numberOfBytes; i++)
+	{
+		/* Write dummy data to shift in the register content */
+		registerContents[i] = SPI_Transfer_Byte(0x0);
+	}
 
-uint8_t Read_NRF_Status_Register(void)
-{
-	uint8_t registerContents;
+	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
 
-	registerContents = Write_One_Byte(0x0);
-	return registerContents;
+	return numberOfBytes;
 }
 
-
-uint8_t Read_NRF_Register(uint8_t address)
-{
-	uint8_t registerContents;
-
-	registerContents = Write_Two_Bytes(address, 0x0);
-
-	return registerContents;
-}
+#endif
 
 void Write_NRF_Register(uint8_t address, uint8_t registerContents)
 {
 	Write_Two_Bytes(0x50, 0x73);
 }
 
-void Send_TX_Flush_Command(void)
-{
-	Write_One_Byte(FLUSH_TX_COMMAND);
-}
-
-void Send_RX_Flush_Command(void)
+static void Write_Two_Bytes(uint8_t byte1, uint8_t byte2)
 {
-	Write_One_Byte(FLUSH_RX_COMMAND);
-}
-
-static uint8_t Write_One_Byte(uint8_t byte1)
-{
-	uint8_t registerContents = 0;
 	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
 
-	registerContents = SPI_Transfer_Byte(byte1);
+	SPI_Transfer_Byte(byte1);
+	SPI_Transfer_Byte(byte2);
 
 	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
-	return registerContents;
 }
 
-static uint8_t Write_Two_Bytes(uint8_t byte1, uint8_t byte2)
+void Send_TX_Flush_Command(void)
 {
-	uint8_t registerContents = 0;
+	/* First write the write command with the address */
 	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
 
-	SPI_Transfer_Byte(byte1);
-	registerContents = SPI_Transfer_Byte(byte2);
+	SPI_Transfer_Byte(0xE1);
 
 	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
-	return registerContents;
 }
 
 
 
 void Write_Message_To_TX_FIFO(uint8_t length, uint8_t * buffer)
 {
-	Write_Byte_And_Buffer(W_TX_PAYLOAD_COMMAND, buffer, length);
-}
-
-void Read_Message_From_RX_FIFO(uint8_t length, uint8_t * buffer)
-{
-	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
-
-	SPI_Transfer_Byte(R_RX_PAYLOAD_COMMAND);
-
-	/* Write the data byte */
-	for (uint8_t i = 0; i < length; i ++)
-	{
-		buffer[i] = SPI_Transfer_Byte(0x0);
-	}
-
-	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
+	Write_Byte_And_Buffer(0xA0, buffer, length);
 }
 
 void Set_TX_Address(uint8_t * txAddress, uint8_t length)
 	Write_Byte_And_Buffer(RX_ADDR_P0_ADDRESS | 0x20, rxAddress, length);
 }
 
-void Set_RX_P1_Address(uint8_t * rxAddress, uint8_t length)
-{
-	Write_Byte_And_Buffer(RX_ADDR_P1_ADDRESS | 0x20, rxAddress, length);
-}
-
 static void Write_Byte_And_Buffer(uint8_t byte, uint8_t * buffer, uint8_t length)
 {
 	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
 
 	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
 }
+
+//TODO: only write the used bytes into the address registers & add generic write functions

weather-sensor/firmware/nrf24l01.h

 #ifndef NRF24L01_H
 #define NRF24L01_H
 
-#define PACKET_LENGTH 32
-
-#define PACKET_PAYLOAD_BUFFER_LENGTH 22
+#define PACKET_BUFFER_LENGTH 22
 
 /* AVR I/O pin definionts */
 #define NRF_CE_DDR   DDRD
 void Set_NRF24L01_Pins(void);
 void Configure_Transmission(uint8_t moduleId);
 uint8_t Read_NRF_Status_Register(void);
-uint8_t Read_NRF_Register(uint8_t address);
+uint8_t Read_NRF_Register(uint8_t address, uint8_t * registerContents);
 void Write_NRF_Register(uint8_t address, uint8_t registerContents);
 void Send_Activate_Command(void);
-bool NRF24L01_Send_Message(uint8_t *buffer, uint8_t length);
-bool NRF24L01_Receive_Message(uint8_t *buffer, uint8_t duration);
+
+void NRF24L01_Send_Message(uint8_t *buffer, uint8_t length);
 void Write_Message_To_TX_FIFO(uint8_t length, uint8_t * buffer);
-void Read_Message_From_RX_FIFO(uint8_t length, uint8_t * buffer);
 void Set_TX_Address(uint8_t * txAddress, uint8_t length);
 void Set_RX_P0_Address(uint8_t * rxAddress, uint8_t length);
-void Set_RX_P1_Address(uint8_t * rxAddress, uint8_t length);
 
 typedef enum
 {
-	PACKET_TYPE_GET_SALT = 0,
-	PACKET_TYPE_SALT = 1,
-	PACKET_TYPE_REPORT = 2,
-	PACKET_TYPE_GET_VALUES = 3,
-	PACKET_TYPE_VALUES = 4,
+	PACKET_TYPE_SALT = 0,
+	PACKET_TYPE_REPORT = 1,
+	PACKET_TYPE_GET_VALUES = 2,
+	PACKET_TYPE_VALUES = 3,
 } PACKET_TYPE;
 
 typedef enum
 			uint8_t valueTypeHumidity;
 			uint16_t humidity;
 			uint8_t unused[10];
-		} reportData;
-
-		struct {
-			BITFIELD_PACKET_COUNT_ELEMENT packetIdentifier;
-			uint8_t salt[7];
-			uint8_t unused[14];
-		} saltData;
-
-		struct {
-			BITFIELD_PACKET_COUNT_ELEMENT packetIdentifier;
-			uint8_t unused[21];
-		} getSaltData;
-
-		uint8_t buffer[PACKET_PAYLOAD_BUFFER_LENGTH];
+		} values;
+		uint8_t buffer[PACKET_BUFFER_LENGTH];
 	}payload;
 	uint16_t crc;
 } PACKET;

weather-sensor/firmware/nrf24l01_definitions.h

 #define DYNPD_ADDRESS 0x1C
 #define FEATURE_ADDRESS 0x1D
 
-/* Commands */
-#define FLUSH_TX_COMMAND 0xE1
-#define FLUSH_RX_COMMAND 0xE2
-#define W_TX_PAYLOAD_COMMAND 0xA0
-#define R_RX_PAYLOAD_COMMAND 0xA1
-
 /* Register bits definitions */
 /* CONFIG*/
 typedef union