On start-up the sensor sends a Get_Salt-message to the base station. The
base station responds and sends the salt, which the sensor uses from
there on.

weather-sensor/firmware/encryption.c

 
 		/* Setup for next block */
 		currentCipherBlock = previousCipherBlock;
-		if (previousCipherBlock != (uint8_t*) data + LENGTH_OF_BLOCK)
+		if (previousCipherBlock != (uint8_t*) data)
 		{
 			previousCipherBlock -= LENGTH_OF_BLOCK;
 		}

weather-sensor/firmware/main.c

 #include "bme280_interface.h"
 #include "bme280_defs.h"
 #include "pin_programming.h"
-#include "crc.h"
-#include "encryption.h"
+#include "radio.h"
 
 
 
 uint8_t ownId;
-const uint8_t encryptionKey[16] = {0x9e, 0x37, 0x79, 0xb9, 0x9b, 0x97, 0x73, 0xe9, 0xb9, 0x79, 0x37, 0x9e, 0x6b, 0x69, 0x51, 0x56}; /* TODO: use exernal file with the keys */
 uint64_t salt;
 
 char bool_case = 0;
 volatile uint8_t executionFlag;
 
 
-
-static PACKET reportPacket;
+static uint8_t messageBuffer[PACKET_LENGTH];
+static PACKET * packet = (PACKET*) messageBuffer;
 
 
 void Enter_Power_Save_Mode(void);
 void Exit_Power_Save_Mode(void);
 
 
-/* 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);
 
 int main (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 = 0xFFFFFFFFFFFFFFFFull;
-	salt &= ~ownId;
+	salt = 0x0ull;
+	salt |= ownId;
+
+
+	/* Request a salt from the base station */
+	LED_PORT |= (1 << LED_PIN);
+	do
+	{
+		if (Send_Get_Salt_Message(packet, &salt) == true)
+		{
+			memset(messageBuffer, 0x0F, 32);
+			if (NRF24L01_Receive_Message(messageBuffer, 100 /*ms*/) == true)
+			{
+				_delay_ms(10);
+				saltReceived = Read_Salt_Message(packet, &salt);
+			}
+		}
+		else
+		{
+			/* TODO: enter power save mode instead to make the battery life longer */
+			_delay_ms(100);
+		}
+	} while (saltReceived == false);
+	LED_PORT &= ~(1 << LED_PIN);
+
+	salt &= 0xFFFFFFFFFFFFFF00ull;
+	salt |= ownId;
+
 
 	/* 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
 			/* Get measurement and send it */
 			BME280_Get_Measurement(&sensorData);
 
+			/* Send the report */
+			Send_Report_Message(packet, &salt, &sensorData);
 
-			memset((uint8_t*)&reportPacket, 0, sizeof(reportPacket)); //Reinitialize the buffer with zeros
-
-			salt &= ~(1ull<<55);
-			reportPacket.salt = salt;
-			reportPacket.payload.values.packetIdentifier.elementCount = 3;
-			reportPacket.payload.values.packetIdentifier.packetType = PACKET_TYPE_REPORT;
-
-			/* Fill in the payload */
-			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(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*) &reportPacket.payload.buffer,
-			        PACKET_BUFFER_LENGTH + sizeof(crc),
-			        salt, (uint32_t*) encryptionKey);
-
-			NRF24L01_Send_Message((uint8_t*)&reportPacket, sizeof(reportPacket));
-
+			LED_PORT |= (1 << LED_PIN);
 			_delay_ms(100); /* TODO: only for debugging, remove this later! */
 			LED_PORT &= ~(1 << LED_PIN);
 
 	PRR &= ~(1<<PRSPI); // Enable SPI
 	Initialize_SPI(); // reinitalize SPI
 }
+

weather-sensor/firmware/makefile

 CFLAGS = -DF_CPU=1000000UL -D BME280_32BIT_ENABLE -I BME280_driver -mmcu=atmega88p -Os -flto -Wall -Wextra -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums
-DEPS = spi.h nrf24l01.h nrf24l01_definitions.h bme280_interface.h BME280_driver/bme280.h led.h pin_programming.h crc.h encryption.h
+DEPS = spi.h nrf24l01.h nrf24l01_definitions.h bme280_interface.h BME280_driver/bme280.h led.h pin_programming.h crc.h encryption.h radio.h
 
 all: main.hex
 
 	rm -f obj/*.o
 
 flash: main.hex
-	sudo avrdude -c buspirate -b 115200 -P /dev/ttyUSB1 -p m88p -v -U flash:w:main.hex
+	sudo avrdude -c buspirate -b 115200 -P /dev/ttyUSB0 -p m88p -v -U flash:w:main.hex
 
 obj/%.o: %.c $(DEPS)
 	avr-gcc -c $< -o $@ $(CFLAGS)
 obj/%.o: BME280_driver/%.c $(DEPS)
 	avr-gcc -c $< -o $@ $(CFLAGS)
 
-main: obj/main.o obj/spi.o obj/nrf24l01.o obj/bme280_interface.o obj/bme280.o obj/pin_programming.o obj/crc.o obj/encryption.o
+main: obj/main.o obj/spi.o obj/nrf24l01.o obj/bme280_interface.o obj/bme280.o obj/pin_programming.o obj/crc.o obj/encryption.o obj/radio.o
 	avr-gcc $^ -o $@ $(CFLAGS)
 
 main.hex: main

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 void Write_Two_Bytes(uint8_t byte1, uint8_t byte2);
+static uint8_t Write_One_Byte(uint8_t byte1);
+static uint8_t 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 */
 
 void Configure_Transmission(uint8_t moduleId)
 {
+	SETUP_RETR_REGISTER setupRetrRegisterContents = {.byte = 0x0};
+	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};
-	SETUP_RETR_REGISTER setupRetrRegisterContents = {.byte = 0x0};
 
 	uint8_t txAddress[5] = {0xB3, 0xB3, 0xB3, 0xB3, 0x00};
-	uint8_t rx0Address[5] = {0xB3, 0xB3, 0xB3, 0xB3, 0x20};
-	/* 
-	 * - 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);
+	uint8_t rx1Address[5] = {0xB3, 0xB3, 0xB3, 0xB3, 0x00};
 
 	/* Set the frequency to 1450 MHz */
 	Write_NRF_Register(RF_CH_ADDRESS, 0x32);
 	featureRegisterContents.bits.EN_DPL = 1; // enable dynamic payload length
 	Write_NRF_Register(FEATURE_ADDRESS, featureRegisterContents.byte);
 
-	/* */
-	setupRetrRegisterContents.bits.ARC = 0x3;
-	setupRetrRegisterContents.bits.ARD = 0xF;
-	Write_NRF_Register(SETUP_RETR_ADDRESS, setupRetrRegisterContents.byte);
-
-	/* set dynamic payload length for all data pipes */ // TODO: only pipe 0 is currently in use -> don't set the other values
+	/* 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_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);
 
-	rx0Address[4] = moduleId; // The last byte of the address corresponds to the Id set by the pin programming
-	Set_RX_P0_Address(rx0Address, 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);
+
+	/* Flush FIFOs */
+	Send_TX_Flush_Command();
+	Send_RX_Flush_Command();
 
 
 	PCMSK2 |= (1<<PCINT21); // Set the external interrupt for PD5
 }
 
-void NRF24L01_Send_Message(uint8_t *buffer, uint8_t length)
+bool NRF24L01_Send_Message(uint8_t *buffer, uint8_t length)
 {
+	bool success = false;
 	STATUS_REGISTER statusRegisterContents = {.byte = 0x0};
 	
 	if ((length > 32) || (length == 0))
 	{
-		return;
+		return success;
 	}
 
 	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;
+	return success;
 }
 
-uint8_t Read_NRF_Status_Register(void)
+bool NRF24L01_Receive_Message(uint8_t *buffer, uint8_t duration)
 {
-	uint8_t registerContents;
+	uint8_t messageReceived = false;
+	CONFIG_REGISTER configRegisterContents = {.byte = 0x0};
+	STATUS_REGISTER statusRegisterContents = {.byte = 0x0};
+	FIFO_STATUS_REGISTER fifoStatusRegisterContents = {.byte = 0x0};
 
-	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;
-}
+	PCICR |= (1<<PCIE2); // Enable the interrupt for the IRQ signal
 
+	// Enable the receive mode
+	configRegisterContents.byte = Read_NRF_Register(CONFIG_ADDRESS);
+	configRegisterContents.bits.PRIM_RX = 0x1;
+	Write_NRF_Register(CONFIG_ADDRESS, configRegisterContents.byte);
 
-/* 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 ((address == 0x0A) ||
-	    (address == 0x0B) ||
-	    (address == 0x10))
+	NRF_CE_PORT |= (1 << NRF_CE_PIN);
+
+	_delay_ms(10);
+	while ((nrfInterruptRaised == false) && (duration > 0))
 	{
-		numberOfBytes = 5;
-	}
-	else
+		_delay_ms(1);
+		duration --;
+	};
+
+	if (nrfInterruptRaised == true) // check if a message was received
 	{
-		numberOfBytes = 1;
+		/* A message was received */
+
+		statusRegisterContents.byte = Read_NRF_Status_Register();
+
+		fifoStatusRegisterContents.byte = Read_NRF_Register(FIFO_STATUS_ADDRESS);
+		if (fifoStatusRegisterContents.bits.RX_EMPTY != 1)
+		{
+			messageReceived = true;
+		}
+
+		nrfInterruptRaised = false;
 	}
 
-	/* First write the address */
-	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
+	// Set the NRF to standby
+	NRF_CE_PORT &= ~(1 << NRF_CE_PIN);
 
+	configRegisterContents.byte = Read_NRF_Register(CONFIG_ADDRESS);
+	configRegisterContents.bits.PRIM_RX = 0x0;
+	Write_NRF_Register(CONFIG_ADDRESS, configRegisterContents.byte);
 
-	SPI_Transfer_Byte(address);
+	PCICR &= ~(1<<PCIE2); // Disable the interrupt for the IRQ signal
 
-	/* Read the register bytes */
-	for (uint8_t i = 0; i < numberOfBytes; i++)
+	if (messageReceived == true)
 	{
-		/* Write dummy data to shift in the register content */
-		registerContents[i] = SPI_Transfer_Byte(0x0);
+		Read_Message_From_RX_FIFO(PACKET_LENGTH, buffer); /* TODO: only possible after CE = 0? */
 	}
 
-	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
+	/* 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);
+
+	return messageReceived;
+}
+
+uint8_t Read_NRF_Status_Register(void)
+{
+	uint8_t registerContents;
 
-	return numberOfBytes;
+	registerContents = Write_One_Byte(0x0);
+	return registerContents;
 }
 
-#endif
+
+uint8_t Read_NRF_Register(uint8_t address)
+{
+	uint8_t registerContents;
+
+	registerContents = Write_Two_Bytes(address, 0x0);
+
+	return registerContents;
+}
 
 void Write_NRF_Register(uint8_t address, uint8_t registerContents)
 {
 	Write_Two_Bytes(0x50, 0x73);
 }
 
-static void Write_Two_Bytes(uint8_t byte1, uint8_t byte2)
+void Send_TX_Flush_Command(void)
+{
+	Write_One_Byte(FLUSH_TX_COMMAND);
+}
+
+void Send_RX_Flush_Command(void)
 {
+	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);
 
-	SPI_Transfer_Byte(byte1);
-	SPI_Transfer_Byte(byte2);
+	registerContents = SPI_Transfer_Byte(byte1);
 
 	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
+	return registerContents;
 }
 
-void Send_TX_Flush_Command(void)
+static uint8_t Write_Two_Bytes(uint8_t byte1, uint8_t byte2)
 {
-	/* First write the write command with the address */
+	uint8_t registerContents = 0;
 	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
 
-	SPI_Transfer_Byte(0xE1);
+	SPI_Transfer_Byte(byte1);
+	registerContents = SPI_Transfer_Byte(byte2);
 
 	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(0xA0, buffer, length);
+	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);
 }
 
 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_BUFFER_LENGTH 22
+#define PACKET_LENGTH 32
+
+#define PACKET_PAYLOAD_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 * registerContents);
+uint8_t Read_NRF_Register(uint8_t address);
 void Write_NRF_Register(uint8_t address, uint8_t registerContents);
 void Send_Activate_Command(void);
-
-void NRF24L01_Send_Message(uint8_t *buffer, uint8_t length);
+bool NRF24L01_Send_Message(uint8_t *buffer, uint8_t length);
+bool NRF24L01_Receive_Message(uint8_t *buffer, uint8_t duration);
 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_SALT = 0,
-	PACKET_TYPE_REPORT = 1,
-	PACKET_TYPE_GET_VALUES = 2,
-	PACKET_TYPE_VALUES = 3,
+	PACKET_TYPE_GET_SALT = 0,
+	PACKET_TYPE_SALT = 1,
+	PACKET_TYPE_REPORT = 2,
+	PACKET_TYPE_GET_VALUES = 3,
+	PACKET_TYPE_VALUES = 4,
 } PACKET_TYPE;
 
 typedef enum
 			uint8_t valueTypeHumidity;
 			uint16_t humidity;
 			uint8_t unused[10];
-		} values;
-		uint8_t buffer[PACKET_BUFFER_LENGTH];
+		} 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];
 	}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 0x61
+
 /* Register bits definitions */
 /* CONFIG*/
 typedef union

weather-sensor/firmware/pin_programming.c

 #include <avr/io.h>
 #include <stdint.h>
+#include <util/delay.h>
 
 #include "pin_programming.h"
 
 	PIN_PROG_2_DDR &= ~(1 << PIN_PROG_2_PIN);
 	PIN_PROG_3_DDR &= ~(1 << PIN_PROG_3_PIN);
 
-	/* Enable pull-ups */ // TODO: enable once the boards have been fixed!
+	/* Enable pull-ups */
 	PIN_PROG_1_PORT |= (1 << PIN_PROG_1_PIN);
 	PIN_PROG_2_PORT |= (1 << PIN_PROG_2_PIN);
 	PIN_PROG_3_PORT |= (1 << PIN_PROG_3_PIN);
+
+	_delay_us(20);
 }
 
 uint8_t Get_Own_Identifier(void)

weather-sensor/firmware/radio.c

+#include <string.h>
+#include "radio.h"
+#include "encryption.h"
+#include "crc.h"
+
+const uint8_t encryptionKey[16] = {0x9e, 0x37, 0x79, 0xb9, 0x9b, 0x97, 0x73, 0xe9, 0xb9, 0x79, 0x37, 0x9e, 0x6b, 0x69, 0x51, 0x56}; /* TODO: use exernal file with the keys */
+
+bool Send_Message(PACKET * packet, uint64_t * salt);
+
+bool Send_Get_Salt_Message(PACKET * packet, uint64_t * salt) //TODO: put into own file
+{
+	memset((uint8_t*)packet, 0, PACKET_LENGTH); //Reinitialize the buffer with zeros
+
+	packet->payload.reportData.packetIdentifier.elementCount = 0;
+	packet->payload.reportData.packetIdentifier.packetType = PACKET_TYPE_GET_SALT;
+
+	return Send_Message(packet, salt);
+}
+
+bool Send_Report_Message(PACKET * packet, uint64_t * salt, struct bme280_data * sensorData)
+{
+	packet->payload.reportData.packetIdentifier.elementCount = 3;
+	packet->payload.reportData.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;
+
+	return Send_Message(packet, salt);
+}
+
+bool Send_Message(PACKET * packet, uint64_t * salt)
+{
+	bool success;
+
+	uint16_t crc;
+	(*salt) &= ~(1ull<<63); /* Set the most significant bit to 0 to indicate a packet from the device to the base station */
+
+	packet->salt = *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);
+
+	/* Increment salt */
+	(*salt) += (1 << 8);
+
+	return success;
+}
+
+bool Read_Salt_Message(PACKET * packet, uint64_t * salt)
+{
+	uint16_t crcRemainder = 0xFFFF;
+	uint64_t baseStationSalt = 0x0;
+
+
+	/* TODO: check that the packet originated from the base station by checking the id */
+
+	baseStationSalt = packet->salt;
+	Decrypt((uint32_t*)packet->payload.buffer,
+	        PACKET_PAYLOAD_BUFFER_LENGTH + sizeof(packet->crc),
+	        baseStationSalt,
+	        (uint32_t*) encryptionKey);
+
+	crcRemainder = Calculate_Crc(packet->payload.buffer,
+	                             PACKET_PAYLOAD_BUFFER_LENGTH + sizeof(packet->crc));
+	if (crcRemainder != 0)
+	{
+		return false;
+	}
+
+	if ((packet->payload.saltData.packetIdentifier.packetType != PACKET_TYPE_SALT) ||
+	    (packet->payload.saltData.packetIdentifier.elementCount != 0))
+	{
+		return false;
+	}
+
+	memcpy((uint8_t*)salt, packet->payload.saltData.salt, 7);
+	*salt = (*salt) << 8;
+
+	return true;
+}

weather-sensor/firmware/radio.h

+#ifndef RADIO_H
+#define RADIO_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "bme280_defs.h"
+#include "nrf24l01.h"
+
+bool Send_Get_Salt_Message(PACKET * packet, uint64_t * salt); //TODO: put into own file
+bool Read_Salt_Message(PACKET * packet, uint64_t * salt);
+bool Send_Report_Message(PACKET * packet, uint64_t * salt, struct bme280_data * sensorData);
+
+#endif