smart-home/weather-sensor/firmware/nrf24l01.c

#include <stdint.h>
#include <avr/io.h>
#include <util/delay.h>
#include <stdio.h>
#include <stdbool.h>

#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
 */

void Print_Register_Contents(uint8_t address);
void Send_TX_Flush_Command(void);

/* Startup and initial configuration of the NRF24L01 */
void Initialize_NRF24L01(void)
{
	CONFIG_REGISTER configRegisterContents = {.byte = 0x0};

	/* Configure the AVR pins for the nrf24l01 */
	/* Set up the NRF24L01 */
	NRF_CE_DDR |= (1 << NRF_CE_PIN);
	NRF_CSN_DDR |= (1 << NRF_CSN_PIN);

	/* Set the chip select pin to not selected */
	NRF_CSN_PORT |= (1 << NRF_CSN_PIN);

	/* Ensure that the CE pin is set to 0*/
	NRF_CE_PORT &= ~(1 << NRF_CE_PIN);

	/* Wait more than 10.3 ms to make sure the nrf24l01 is running */
	_delay_ms(11);

	/* Write the PWR_UP bit of the CONFIG register (EN_CRC is also set) */
	configRegisterContents.bits.EN_CRC = 0x1;
	configRegisterContents.bits.PWR_UP = 0x1;
	Write_NRF_Register(CONFIG_ADDRESS, configRegisterContents.byte);

	/* Wait more than 1.5 ms for the change to take effect */
	_delay_ms(2);

	/* The NRF24L01 is now in the mode Standby-I */
}

void Configure_Transmission(void)
{
	FEATURE_REGISTER featureRegisterContents = {.byte = 0x0};
	DYNPD_REGISTER dyndpRegisterContents = {.byte = 0x0};
	SETUP_RETR_REGISTER setupRetrRegisterContents = {.byte = 0x0};
	/* 
	 * - 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);

	/* */
	setupRetrRegisterContents.bits.ARC = 0x3;
	setupRetrRegisterContents.bits.ARD = 0xF;
	Write_NRF_Register(SETUP_RETR_ADDRESS, setupRetrRegisterContents.byte);

	/* set dynamic payload length for all data pipes */
	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 the TX address */
	Set_TX_Address(0x123456);

	Set_RX_P0_Address(0x123456);
	

	// TODO: set addresses for all data pipes
}

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;
	}

	Write_Message_To_TX_FIFO(length, buffer);

	/* Set CE = 1 for more than 10 us */
	NRF_CE_PORT |= (1 << NRF_CE_PIN);
	_delay_us(15);
	NRF_CE_PORT &= ~(1 << NRF_CE_PIN);


	do
	{
		_delay_ms(1);
		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));

	/* Reset the interrupts */
	statusRegisterContents.byte = Read_NRF_Status_Register();
	statusRegisterContents.bits.TX_DS = 1;
	statusRegisterContents.bits.MAX_RT = 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];


	lengthRead = Read_NRF_Register(address, registerContent);

	registerContentString[0] = '\0';
	for (uint8_t i = 0; i < lengthRead; i++)
	{
		sprintf(registerContentString, "%s0x%x ", registerContentString, registerContent[i]);
	}
}




/* 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;

	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;
}

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))
	{
		numberOfBytes = 5;
	}
	else
	{
		numberOfBytes = 1;
	}

	/* First write the address */
	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);


	SPI_Transfer_Byte(address);

	/* 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);
	}

	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);

	return numberOfBytes;
}

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);
}

// TODO: clean up functions
void Send_Activate_Command(void)
{
	/* First write the write command with the address */
	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
	SPI_Transfer_Byte(0x50);

	/* Write the data byte */
	SPI_Transfer_Byte(0x73);

	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
}

void Send_TX_Flush_Command(void)
{
	/* First write the write command with the address */
	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);

	SPI_Transfer_Byte(0xE1);

	SPI_Stop_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);
}



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);
}

void Set_TX_Address(uint32_t txAddress)
{
	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);
}

void Set_RX_P0_Address(uint32_t rxAddress)
{
	uint8_t * buffer = (uint8_t*) &rxAddress;

	SPI_Start_Transmission(&NRF_CSN_PORT, NRF_CSN_PIN);

	SPI_Transfer_Byte(RX_ADDR_P0_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);
}

//TODO: only write the used bytes into the address registers & add generic write functions