The algorith used is for the CRC-16-CCITT, also known as CRC-KERMIT.

weather-sensor/firmware/.gitignore

@@ -1,5 +1,6 @@
 main
 *.hex
+*.o
 
 
 *.swp

weather-sensor/firmware/bme280_interface.c

@@ -1,5 +1,6 @@
 #include <avr/io.h>
 #include <util/delay.h>
+#include <string.h>
 
 #include "spi.h"
 #include "bme280.h"
@@ -58,6 +59,7 @@ void Set_BME280_Pins(void)
 /* Get one measurement in forced mode */
 void BME280_Get_Measurement(struct bme280_data * data)
 {
+	memset(data, 0, sizeof(struct bme280_data));
 	bme280_set_sensor_mode(BME280_FORCED_MODE, &deviceStructure);
 	deviceStructure.delay_ms(req_delay);
 	bme280_get_sensor_data(BME280_ALL, data, &deviceStructure);

weather-sensor/firmware/crc.c

@@ -0,0 +1,53 @@
+#include <stdint.h>
+#include <avr/pgmspace.h>
+
+const uint16_t crcTable[256] PROGMEM =
+{
+	0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
+	0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
+	0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
+	0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
+	0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
+	0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
+	0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
+	0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
+	0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
+	0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
+	0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
+	0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
+	0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
+	0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
+	0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
+	0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
+	0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
+	0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
+	0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
+	0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
+	0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
+	0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
+	0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
+	0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
+	0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
+	0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
+	0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
+	0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
+	0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
+	0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
+	0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
+	0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
+};
+
+
+uint16_t Calculate_Crc(const uint8_t *buffer, uint8_t size)
+{
+	uint16_t crc = 0;
+	const uint8_t * tempPointer = buffer;
+
+	for (uint8_t i = 0; i < size; i++)
+	{
+		crc = (crc >> 8) ^ pgm_read_word(&crcTable[ (crc ^ (uint16_t) *tempPointer) & 0x00FF ]);
+		tempPointer++;
+	}
+
+	return crc;
+}

weather-sensor/firmware/crc.h

@@ -0,0 +1,5 @@
+#ifndef CRC_H
+#define CRC_H
+
+uint16_t Calculate_Crc(const uint8_t *buffer, uint8_t size);
+#endif

weather-sensor/firmware/encryption.c

@@ -0,0 +1,118 @@
+#include <stdint.h>
+
+#define LENGTH_OF_BLOCK 8
+
+void xxtea_Encrypt(uint32_t * data, uint8_t dataLength, const uint32_t key[4]);
+void xxtea_Decrypt(uint32_t * data, uint8_t dataLength, const uint32_t key[4]);
+
+/* The data packets are encrypted using the xxtea algorithm. */
+void Encrypt(uint32_t * data, uint8_t dataLength, uint64_t salt, const uint32_t key[4])
+{
+	/* This function assumes that the dataLength is a multiple of the length of the
+	 * salt (8)
+	 *
+	 * The data is encrypted using cipher block chaining:
+	 * (https://upload.wikimedia.org/wikipedia/commons/8/80/CBC_encryption.svg)
+	 */
+
+	uint8_t i;
+	uint8_t * previousCipherBlock = (uint8_t*) &salt;
+	uint8_t * currentPlaintextBlock = (uint8_t*) data;
+
+	for (i = 0; i < dataLength/LENGTH_OF_BLOCK; i++)
+	{
+		/* XOR of current plain text block and previous cipher block */
+		//for (j = 0; j < LENGTH_OF_BLOCK; j++)
+		//{
+		//	currentPlaintextBlock[j] ^= previousCipherBlock[j];
+		//}
+		*((uint64_t*) currentPlaintextBlock) ^= *((uint64_t*) previousCipherBlock);
+
+		/* Encrypt the block */
+		xxtea_Encrypt((uint32_t*) currentPlaintextBlock, LENGTH_OF_BLOCK, key);
+
+		/* Setup for next block */
+		previousCipherBlock = currentPlaintextBlock;
+		currentPlaintextBlock += LENGTH_OF_BLOCK;
+	}
+
+}
+
+
+void Decrypt(uint32_t * data, uint8_t dataLength, uint64_t salt, const uint32_t key[4])
+{
+	/* This function assumes that the dataLength is a multiple of the length of the
+	 * salt (8)
+	 *
+	 * The data is encrypted using cipher block chaining:
+	 * (https://upload.wikimedia.org/wikipedia/commons/2/2a/CBC_decryption.svg)
+	 */
+
+	/* The data is decrypted from back to front as front to back cannot be done in
+	 * place
+	 */
+	uint8_t i;
+	uint8_t * previousCipherBlock = (uint8_t*) data + dataLength - 2 * LENGTH_OF_BLOCK;
+	uint8_t * currentCipherBlock = (uint8_t*) data + dataLength - LENGTH_OF_BLOCK;
+
+	for (i = dataLength/LENGTH_OF_BLOCK; i > 0; i--)
+	{
+		/* Decrypt the block */
+		xxtea_Decrypt((uint32_t*) currentCipherBlock, LENGTH_OF_BLOCK, key);
+
+		/* XOR of the decrypted block with cipher block in front of it */
+		*((uint64_t*) currentCipherBlock) ^= *((uint64_t*) previousCipherBlock);
+
+		/* Setup for next block */
+		currentCipherBlock = previousCipherBlock;
+		if (previousCipherBlock != (uint8_t*) data + LENGTH_OF_BLOCK)
+		{
+			previousCipherBlock -= LENGTH_OF_BLOCK;
+		}
+		else
+		{
+			previousCipherBlock = (uint8_t*) &salt;
+		}
+	}
+}
+
+void xxtea_Encrypt(uint32_t * data, uint8_t dataLength, const uint32_t key[4])
+{
+    uint32_t sum = 0, z, y, e;
+    uint8_t i = 6 + 52/(dataLength/4), r;
+    const int16_t n = dataLength / 4 - 1;
+
+    z = data[n]; // left neighbour for the first round
+    do {
+        // cycle
+        sum += 0x9e3779b9ul;
+        e = (sum >> 2) & 3;
+        for (r = 0; r <= n; r++) {
+            // round
+            y = data[(r+1) % (n + 1)]; // right neighbour
+            data[r] += ((z>>5 ^ y<<2) + (y>>3 ^ z<<4)) ^ ((sum^y) + (key[(r^e) & 3] ^ z));
+            z = data[r]; // left neighbour for the next round
+        }
+    } while (--i);
+}
+
+void xxtea_Decrypt(uint32_t * data, uint8_t dataLength, const uint32_t key[4])
+{
+    uint32_t sum, z, y, e;
+    int16_t i = 6 + 52/(dataLength/4), r;
+    const int16_t n = dataLength / 4;
+
+    sum = (uint32_t) ((uint64_t) (6 + 52/(dataLength/4)) * 0x9e3779b9ul);
+    y = data[0];
+    do {
+        // cycle
+        e = sum >> 2;
+        for (r = n-1; r >= 0; --r) {
+            // round
+            z = data[(r+n-1) % n];
+            data[r] -= ((z>>5 ^ y<<2) + (y>>3 ^ z<<4)) ^ ((sum^y) + (key[(r^e) & 3] ^ z));
+            y = data[r];
+        }
+        sum -= 0x9e3779b9;
+    } while (--i);
+}

weather-sensor/firmware/encryption.h

@@ -0,0 +1,8 @@
+#ifndef ENCRYPTION_H
+#define ENCRYPTION_H
+
+
+void Encrypt(uint32_t * data, uint8_t dataLength , uint64_t salt, const uint32_t key[4]);
+void Decrypt(uint32_t * data, uint8_t dataLength, uint64_t salt, const uint32_t key[4]);
+
+#endif

weather-sensor/firmware/led.h

@@ -0,0 +1,8 @@
+#ifndef LED_H
+#define LED_H
+
+#define LED_DDR   DDRD
+#define LED_PORT  PORTD
+#define LED_PIN   PD3
+
+#endif

weather-sensor/firmware/main.c

@@ -6,20 +6,23 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 
+#include "led.h"
 #include "spi.h"
 #include "nrf24l01.h"
 #include "nrf24l01_definitions.h"
 #include "bme280_interface.h"
 #include "bme280_defs.h"
+#include "pin_programming.h"
+#include "crc.h"
+#include "encryption.h"
 
 
 
-/* Debug LED: */
-#define LED_DDR   DDRD
-#define LED_PORT  PORTD
-#define LED_PIN   PD3
-
+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;
 int timer = 0;
@@ -27,10 +30,16 @@ int timer_max = 0;
 
 volatile uint8_t cycle = 0;
 
+volatile bool nrfInterruptRaised;
+
 volatile uint8_t interruptCounter;
 volatile uint8_t executionFlag;
 
 
+
+static PACKET reportPacket;
+
+
 void Enter_Power_Save_Mode(void);
 void Exit_Power_Save_Mode(void);
 
@@ -50,23 +59,28 @@ void Set_Up_Power_Save_Mode(void);
 void Enter_Power_Save_Mode(void);
 
 
-ISR( TIMER2_COMPA_vect )
+ISR(TIMER2_COMPA_vect)
 {
 	/* Do nothing as the interrupt is only used to wake up the MCU. */
 }
 
+ISR(PCINT2_vect)
+{
+	nrfInterruptRaised = true;
+}
+
 int main (void)
 {
 	struct bme280_data sensorData;
-//	uint8_t testRegisterContent = 0x0A;
-//	uint8_t registerContent[5];
-//	char registerContentString[30];
-//	uint8_t lengthRead;
-	uint8_t temp = 0;
+	uint16_t crc;
 
 	/* Enable the debug LED */
 	LED_DDR |= (1 << LED_PIN);
 
+	/* Get the own ID */
+	Configure_Pin_Programming_Pins();
+	ownId = Get_Own_Identifier();
+
 	/* Initialize the SPI */
 	Initialize_SPI();
 
@@ -75,12 +89,15 @@ int main (void)
 	// The NRF24L01 is now in the mode Standby-I.
 
 	/* Configure the transmission parameters (Enhanced ShockBurst)*/
-	Configure_Transmission();
+	Configure_Transmission(ownId);
 
 	/* Initialize the BME280 */
 	Initialize_BME280();
 	Set_Up_Power_Save_Mode();
 
+	/* Initialize the salt */
+	salt = 0xFFFFFFFFFFFFFFFFull;
+	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
@@ -101,18 +118,40 @@ int main (void)
 
 			/* Get measurement and send it */
 			BME280_Get_Measurement(&sensorData);
-			NRF24L01_Send_Message((uint8_t*)&sensorData, sizeof(sensorData));
-
-			if (temp == 0)
-			{
-				LED_PORT |= (1 << LED_PIN);
-				temp = 1;
-			}
-			else
-			{
-				temp = 0;
-				LED_PORT &= ~(1 << LED_PIN);
-			}
+
+
+			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));
+
+			_delay_ms(100); /* TODO: only for debugging, remove this later! */
+			LED_PORT &= ~(1 << LED_PIN);
 
 			cycle = 0;
 		}

weather-sensor/firmware/makefile

@@ -1,14 +1,24 @@
+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
+
 all: main.hex
 
 clean:
 	rm -f main.hex
 	rm -f main
+	rm -f obj/*.o
 
 flash: main.hex
-	sudo avrdude -c buspirate -b 115200 -P /dev/ttyUSB0 -p m88p -v -U flash:w:main.hex
+	sudo avrdude -c buspirate -b 115200 -P /dev/ttyUSB1 -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: main.c spi.c spi.h nrf24l01.c nrf24l01.h nrf24l01_definitions.h bme280_interface.c bme280_interface.h BME280_driver/bme280.c BME280_driver/bme280.h
-	avr-gcc main.c spi.c nrf24l01.c bme280_interface.c BME280_driver/bme280.c -I BME280_driver -o main -mmcu=atmega88p -Os -Wall -Wextra -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -DF_CPU=1000000UL -D BME280_32BIT_ENABLE
+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
+	avr-gcc $^ -o $@ $(CFLAGS)
 
 main.hex: main
 	avr-objcopy -O ihex -R .eeprom main main.hex

weather-sensor/firmware/nrf24l01.c

@@ -4,20 +4,24 @@
 #include <stdio.h>
 #include <stdbool.h>
 
+#include "led.h" // TODO: for debugging
 #include "spi.h"
 #include "nrf24l01.h"
 #include "nrf24l01_definitions.h"
 
 /* TODO
- * - Build a state machine that tracks the mode the NRF is set to
- * - Configuration of NRF24L01 and startup
- * - Send and Receive functions
- * - Interrupt handling for Send and Receive
+ * - Send functions
+ * - Interrupt handling for Send
  */
 
+extern volatile bool nrfInterruptRaised;
+
 void Print_Register_Contents(uint8_t address);
 void Send_TX_Flush_Command(void);
 
+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 */
 void Initialize_NRF24L01(void)
 {
@@ -51,13 +55,21 @@ void Set_NRF24L01_Pins(void)
 
 	/* Ensure that the CE pin is set to 0*/
 	NRF_CE_PORT &= ~(1 << NRF_CE_PIN);
+
+	/* Set the interrupt pin */
+	/* TODO: PCINT21 -> PCINT2 */
+	NRF_IRQ_DDR &= ~(1 << NRF_IRQ_PIN); // Set the pin as input
+	NRF_IRQ_PORT |= (1 << NRF_IRQ_PORT); // Enable the pullup for the pin
 }
 
-void Configure_Transmission(void)
+void Configure_Transmission(uint8_t moduleId)
 {
 	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)
@@ -93,7 +105,7 @@ void Configure_Transmission(void)
 	setupRetrRegisterContents.bits.ARD = 0xF;
 	Write_NRF_Register(SETUP_RETR_ADDRESS, setupRetrRegisterContents.byte);
 
-	/* set dynamic payload length for all data pipes */
+	/* set dynamic payload length for all data pipes */ // TODO: only pipe 0 is currently in use -> don't set the other values
 	dyndpRegisterContents.bits.DPL_P0 = 1;
 	dyndpRegisterContents.bits.DPL_P1 = 1;
 	dyndpRegisterContents.bits.DPL_P2 = 1;
@@ -103,35 +115,26 @@ void Configure_Transmission(void)
 	Write_NRF_Register(DYNPD_ADDRESS, dyndpRegisterContents.byte);
 
 	/* Set the TX address */
-	Set_TX_Address(0x123456);
+	Set_TX_Address(txAddress, MAX_ADDRESS_LENGTH);
 
-	Set_RX_P0_Address(0x123456);
-	
+	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);
 
-	// TODO: set addresses for all data pipes
+
+	PCMSK2 |= (1<<PCINT21); // Set the external interrupt for PD5
 }
 
 void NRF24L01_Send_Message(uint8_t *buffer, uint8_t length)
 {
-	bool transmissionFinished = false;
-
 	STATUS_REGISTER statusRegisterContents = {.byte = 0x0};
-	uint32_t timeout = 0;
-	/* TODO:
-	 * - if needed: PRIM_RX = 0
-	 * - Set CE = 1 for more than 10 us
-	 * - Wait until the transmission is finished
-	 * - Read number of retries for debug purposes
-	 * - Check if the FIFO is empty -> if not, flush it
-	 * - reset the interupts of the STATUS
-	 */
 	
-	/* TODO: messages with more than 32 byte length */
 	if ((length > 32) || (length == 0))
 	{
 		return;
 	}
 
+	PCICR |= (1<<PCIE2); // Enable the interrupt for the IRQ signal
+
 	Write_Message_To_TX_FIFO(length, buffer);
 
 	/* Set CE = 1 for more than 10 us */
@@ -139,73 +142,35 @@ void NRF24L01_Send_Message(uint8_t *buffer, uint8_t length)
 	_delay_us(15);
 	NRF_CE_PORT &= ~(1 << NRF_CE_PIN);
 
+	while (nrfInterruptRaised == false); // Wait until the transmission is complete
+	/* An interrupt instead of polling the status register is used to avoid transmission errors
+	 * 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();
+
 
-	do
+	if (statusRegisterContents.bits.MAX_RT == 1)
 	{
-		_delay_ms(1);
-		/* TODO: instead of polling the status register use the IRQ to spawn an interrupt as the
-		 * constant polling may induce transmission errors:
-		 * https://forum.mysensors.org/topic/10452/nrf24l01-communication-failure-root-cause-and-solution
-		 */
-		statusRegisterContents.byte = Read_NRF_Status_Register();
-
-		if (statusRegisterContents.bits.TX_DS == 1)
-		{
-			transmissionFinished = true;
-		}
-
-		if (statusRegisterContents.bits.MAX_RT == 1)
-		{
-			transmissionFinished = true; //TODO: indicate failure
-
-			Send_TX_Flush_Command(); /* Remove the packet from the TX FIFO as it is not done automatically */
-		}
-		
-		timeout ++; // TODO: this should work without the time out, as MAX_RT should be triggered if no ACK is received
-	} while ((transmissionFinished == false) && (timeout < 0xFF));
+		Send_TX_Flush_Command(); /* Remove the packet from the TX FIFO as it is not done automatically */
+	}
+	
 
 	/* Reset the interrupts */
-	statusRegisterContents.byte = Read_NRF_Status_Register();
 	statusRegisterContents.bits.TX_DS = 1;
 	statusRegisterContents.bits.MAX_RT = 1;
+	statusRegisterContents.bits.RX_DR = 1;
 	Write_NRF_Register(STATUS_ADDRESS, statusRegisterContents.byte);
-}
-
-void Print_Register_Contents(uint8_t address)
-{
-	uint8_t registerContent[5];
-	uint8_t lengthRead;
-	char registerContentString[30];
 
+	PCICR &= ~(1<<PCIE2); // Disable the interrupt for the IRQ signal
+	nrfInterruptRaised = false;
 
-	lengthRead = Read_NRF_Register(address, registerContent);
 
-	registerContentString[0] = '\0';
-	for (uint8_t i = 0; i < lengthRead; i++)
-	{
-		sprintf(registerContentString, "%s0x%x ", registerContentString, registerContent[i]);
-	}
+	return;
 }
 
-
-
-
-/* Send a message:
- * - Set PRIM_RX = 0 and add one message to the TX-FIFO
- * - Set CE=1 for more than 10 us
- * - The NRF takes 130 us to enter the TX Mode
- * - An Interrupt is generated once the 
- * - 
- */
-
-
-/* Set the NRF to RX Mode */
-
-/* Disable the RX Mode */
-
-
-
-
 uint8_t Read_NRF_Status_Register(void)
 {
 	uint8_t registerContents;
@@ -216,6 +181,9 @@ uint8_t Read_NRF_Status_Register(void)
 	return registerContents;
 }
 
+
+/* 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 */
@@ -250,28 +218,24 @@ uint8_t Read_NRF_Register(uint8_t address, uint8_t * registerContents)
 	return numberOfBytes;
 }
 
+#endif
+
 void Write_NRF_Register(uint8_t address, uint8_t registerContents)
 {
-	/* First write the write command with the address */
-	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
-
-	SPI_Transfer_Byte(address | 0x20);
-
-	/* Write the data byte */
-	SPI_Transfer_Byte(registerContents);
-
-	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
+	Write_Two_Bytes(address | 0x20, registerContents);
 }
 
-// TODO: clean up functions
 void Send_Activate_Command(void)
 {
-	/* First write the write command with the address */
+	Write_Two_Bytes(0x50, 0x73);
+}
+
+static void Write_Two_Bytes(uint8_t byte1, uint8_t byte2)
+{
 	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
-	SPI_Transfer_Byte(0x50);
 
-	/* Write the data byte */
-	SPI_Transfer_Byte(0x73);
+	SPI_Transfer_Byte(byte1);
+	SPI_Transfer_Byte(byte2);
 
 	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
 }
@@ -290,51 +254,30 @@ void Send_TX_Flush_Command(void)
 
 void Write_Message_To_TX_FIFO(uint8_t length, uint8_t * buffer)
 {
-	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
-
-	/* Issue the write command: */
-	SPI_Transfer_Byte(0xA0);
-
-	/* Write the data bytes */
-	for (uint8_t i = 0; i < length; i++)
-	{
-		SPI_Transfer_Byte(buffer[i]);
-	}
-
-	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
+	Write_Byte_And_Buffer(0xA0, buffer, length);
 }
 
-void Set_TX_Address(uint32_t txAddress)
+void Set_TX_Address(uint8_t * txAddress, uint8_t length)
 {
-	uint8_t * buffer = (uint8_t*) &txAddress;
-
-	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
-
-	SPI_Transfer_Byte(TX_ADDR_ADDRESS | 0x20);
-	/* Write the data byte */
-	for (uint8_t i = 0; i < 4; i ++)
-	{
-		SPI_Transfer_Byte(buffer[i]);
-	}
-	SPI_Transfer_Byte(0x0);
-
-	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
+	Write_Byte_And_Buffer(TX_ADDR_ADDRESS | 0x20, txAddress, length);
 }
 
-void Set_RX_P0_Address(uint32_t rxAddress)
+void Set_RX_P0_Address(uint8_t * rxAddress, uint8_t length)
 {
-	uint8_t * buffer = (uint8_t*) &rxAddress;
+	Write_Byte_And_Buffer(RX_ADDR_P0_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_Transfer_Byte(RX_ADDR_P0_ADDRESS | 0x20);
+	SPI_Transfer_Byte(byte);
 
 	/* Write the data byte */
-	for (uint8_t i = 0; i < 4; i ++)
+	for (uint8_t i = 0; i < length; i ++)
 	{
 		SPI_Transfer_Byte(buffer[i]);
 	}
-	SPI_Transfer_Byte(0x0);
 
 	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
 }

weather-sensor/firmware/nrf24l01.h

@@ -1,7 +1,7 @@
 #ifndef NRF24L01_H
 #define NRF24L01_H
 
-
+#define PACKET_BUFFER_LENGTH 22
 
 /* AVR I/O pin definionts */
 #define NRF_CE_DDR   DDRD
@@ -12,13 +12,15 @@
 #define NRF_CSN_PORT  PORTD
 #define NRF_CSN_PIN   PD6
 
-#define NRF_IRQ_DDR   DDRD
-#define NRF_IRQ_PORT  PORTD
-#define NRF_IRQ_PIN   PD5
+#define NRF_IRQ_DDR     DDRD
+#define NRF_IRQ_PORT    PORTD
+#define NRF_IRQ_PIN     PD5
+#define NRF_IRQ_PORTIN  PIND
+
 
 void Initialize_NRF24L01(void);
 void Set_NRF24L01_Pins(void);
-void Configure_Transmission(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);
 void Write_NRF_Register(uint8_t address, uint8_t registerContents);
@@ -26,7 +28,49 @@ void Send_Activate_Command(void);
 
 void NRF24L01_Send_Message(uint8_t *buffer, uint8_t length);
 void Write_Message_To_TX_FIFO(uint8_t length, uint8_t * buffer);
-void Set_TX_Address(uint32_t txAddress);
-void Set_RX_P0_Address(uint32_t rxAddress);
+void Set_TX_Address(uint8_t * txAddress, uint8_t length);
+void Set_RX_P0_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;
+
+typedef enum
+{
+	VALUE_TYPE_TIME = 0,
+	VALUE_TYPE_TEMPERATURE = 1,
+	VALUE_TYPE_PRESSURE = 2,
+	VALUE_TYPE_HUMIDITY = 3,
+} VALUE_TYPES;
+
+typedef struct __attribute__((packed)) BITFIELD_PACKET_COUNT_ELEMENT
+{
+	uint8_t packetType : 5;
+	uint8_t elementCount : 3;
+} BITFIELD_PACKET_COUNT_ELEMENT;
+
+typedef struct __attribute__((packed)) PACKET
+{
+	uint64_t salt; /* 1 byte device id, 7 bytes remainder */
+	union {
+		struct {
+			BITFIELD_PACKET_COUNT_ELEMENT packetIdentifier;
+			uint8_t valueTypeTemperature;
+			int16_t temperature;
+			uint8_t valueTypePressure;
+			uint32_t pressure;
+			uint8_t valueTypeHumidity;
+			uint16_t humidity;
+			uint8_t unused[10];
+		} values;
+		uint8_t buffer[PACKET_BUFFER_LENGTH];
+	}payload;
+	uint16_t crc;
+} PACKET;
+
 
 #endif

weather-sensor/firmware/nrf24l01_definitions.h

@@ -1,6 +1,7 @@
 #ifndef NRF24L01_DEFINITIONS_H
 #define NRF24L01_DEFINITIONS_H
 
+#define MAX_ADDRESS_LENGTH 5
 
 /* NRF24L01 register mnemonic definitions */
 #define CONFIG_ADDRESS 0x0

weather-sensor/firmware/pin_programming.c

@@ -0,0 +1,54 @@
+#include <avr/io.h>
+#include <stdint.h>
+
+#include "pin_programming.h"
+
+/* Pin definitions */
+
+
+#define PIN_PROG_1_DDR     DDRB
+#define PIN_PROG_1_PORT    PORTB
+#define PIN_PROG_1_PIN     PB6
+#define PIN_PROG_1_PORTIN  PINB
+
+#define PIN_PROG_2_DDR     DDRB
+#define PIN_PROG_2_PORT    PORTB
+#define PIN_PROG_2_PIN     PB7
+#define PIN_PROG_2_PORTIN  PINB
+
+#define PIN_PROG_3_DDR     DDRD
+#define PIN_PROG_3_PORT    PORTD
+#define PIN_PROG_3_PIN     PD4
+#define PIN_PROG_3_PORTIN  PIND
+
+
+
+void Configure_Pin_Programming_Pins(void)
+{
+	/* Set pins as input */
+	PIN_PROG_1_DDR &= ~(1 << PIN_PROG_1_PIN);
+	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!
+	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);
+}
+
+uint8_t Get_Own_Identifier(void)
+{
+	/* The upper four bits of the ID are the module ID while the lower four bits are the serial
+	 * number set by the pin programming.
+	 * Switch 3 corresponds to bit 0
+	 * Switch 2 corresponds to bit 1
+	 * Switch 1 corresponds to bit 2
+	 */
+	uint8_t id = (MODULE_ID_SENSOR << 4);
+
+	id |= ((((PIN_PROG_3_PORTIN & (1 << PIN_PROG_3_PIN)) == 0) << 0) | \
+	       (((PIN_PROG_2_PORTIN & (1 << PIN_PROG_2_PIN)) == 0) << 1) | \
+	       (((PIN_PROG_1_PORTIN & (1 << PIN_PROG_1_PIN)) == 0) << 2));
+
+	return id;
+}

weather-sensor/firmware/pin_programming.h

@@ -0,0 +1,13 @@
+#ifndef PIN_PROGRAMMING_H
+#define PIN_PROGRAMMING_H
+
+typedef enum
+{
+	MODULE_ID_BASE_STATION = 1,
+	MODULE_ID_DISPLAY      = 2,
+	MODULE_ID_SENSOR       = 3
+} MODULE_ID;
+
+void Configure_Pin_Programming_Pins(void);
+uint8_t Get_Own_Identifier(void);
+#endif

weather-sensor/hardware/weather_station_sensor.sch

@@ -914,7 +914,7 @@ LED
 Wire Wire Line
 	6050 4500 6150 4500
 Text Notes 2850 7250 0    50   ~ 0
-TODO: other diode in 0603 package
+TODO: change diode to 0804 package
 $Comp
 L Device:D_Zener D1
 U 1 1 5E5B4A6A
@@ -941,4 +941,8 @@ F 5 "https://www.digikey.com/products/en?keywords=587-5869-1-ND%20" H 3700 6300
 	1    3700 6300
 	1    0    0    -1  
 $EndComp
+Text Notes 7350 6250 0    50   ~ 0
+TODO: connect pins 4,5,6 to\nground instead of vcc
+Text Notes 9600 1600 0    50   ~ 0
+TODO: remove copper plating in the\nradiation direction of the antenna
 $EndSCHEMATC