Układ testowy działa w ten sposób: at8 SMD co 1s wysyła komendy "włącz" i "wyłącz" a druga w zależności od odebranej komendy steruje diodą LED.
Biblioteki mam prawdopodobnie z tego forum, nie pamiętam bo to było już jakiś czas temu, wiem jednak że coś musiałem delikatnie przerobić jeśli chodzi o INT0 dla atmegi8- może to tu jest problem.
main.c
[syntax=c]/* e-gadget.header
* main.c
*
* Created on: 2015-04-07
* Modyfied: 2015-04-07 19:45:16
* Author: Nefarious19
*
* Project name: "NRF24"
*
*
*/
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <string.h>
#include <avr/pgmspace.h>
//plik z obsłógą usypiania w różnych trybach
#include <avr/sleep.h>
//#include "usart.h"
#include "SPI.h"
#include "nRF24L01.h"
#include "nRF24L01_memory_map.h"
#define pd3 (1<<PD3)
#define OFFD PORTD |= pd3
#define OND PORTD &= ~pd3
#define pc5 (1<<PC5)
#define OFFL PORTC |= pc5
#define ONL PORTC &= ~pc5
#define TGL PORTC ^= pc5
#define S1_KR1 (1<<PB6)
char buffer_out1[32];
void majne_funkcjon ( void * nRF_RX_buff , uint8_t len );
int main (void)
{
// wyłączamy komparator analogowy bo domyślnie jest włączony po restarcie
ACSR |= (1<<ACD);
DDRC |= pc5;
DDRD |= pd3;
DDRB &= ~S1_KR1;
PORTB |= S1_KR1;
OFFD;
ONL;
//aktywacja i ustawienie trybu POWER-DOWN (najoszczędniejszy) "MCUCR |= ((1<<SM0)|(1<<SM1));"
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
//init_USART(__UBRR);
nRF_init();
sei();
register_nRF_RX_Event_Callback(majne_funkcjon);
nRF_RX_Power_Up(); //Enable in receiving mode
#if TRYB==1
_delay_ms(2000);
#endif
OFFL;
while(1)
{
#if TRYB == 1
OND;
nRF_SendDataToAir( ( uint8_t * ) "Pozdrowienia dla forum ATNEL!" );
if( buffer_out1[0] != 0 )
{
memset(buffer_out1, 0, 32);
}
_delay_ms(1000);
nRF_SendDataToAir( ( uint8_t * ) "Pozdrowienia dla forum ATNEK!" );
if( buffer_out1[0] != 0 )
{
memset(buffer_out1, 0, 32);
}
OFFD;
_delay_ms(1000);
#endif
#if TRYB == 2
//sleep_mode();
nRF_RX_EVENT();
//wejście w stan uśpienia
#endif
}
}
void majne_funkcjon ( void * nRF_RX_buff, uint8_t len )
{
char str1[] = "Pozdrowienia dla forum ATNEL!";
char str2[] = "Pozdrowienia dla forum ATNEK!";
if((strstr( (char *) nRF_RX_buff, str1))!=NULL )
{
ONL;
}
else if((strstr( (char *) nRF_RX_buff, str2))!=NULL )
{
OFFL;
}
}[/syntax]
nRF24L01.h
[syntax=c]/* e-gadget.header
* nRF24L01.h
*
* Created on: 2015-03-07
* Modyfied: 2015-04-13 21:18:47
* Author: Nefarious19
*
* Project name: "NRF24"
*
*This is AVR GCC library for nRF24L01 module, ver. 1.0
*It can be only used by REGISTERED USERS of www.forum.atnel.pl,
*they must only leave this header in they C code.
*
*Library code was based on the libraries from the books:
*
*https://www.sklep.atnel.pl/pl/p/AVR-Microcontrollers-C-Programming-Basics-EN-BOOK-DVD/103
*https://www.sklep.atnel.pl/pl/p/Jezyk-C-Pasja-programowania-mikrokontrolerow-8-bitowych-Wydanie-II-Ksiazka-DVD/104
*
*"
*
*This library uses also some ideas from:
*
*http://gizmosnack.blogspot.com/2013/04/tutorial-nrf24l01-and-avr.html
*http://www.tinkerer.eu/AVRLib/nRF24L01/
*
*
*/
#ifndef NRF24L01_H_
#define NRF24L01_H_
#include "nRF24L01_memory_map.h"
#include <avr/pgmspace.h>
/////////////////////////////////////////////////////////////////////
#define TRYB 1 //
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// PIN ASSIGMENT - PRZYDZIAŁ PINÓW //
/////////////////////////////////////////////////////////////////////////////////////////////////////////
#define IRQ PD2//IRQ PIN
#define CE PB0//CE PIN
#define CSN PB2//Chip select PIN
#define SS PB2//SS set the same as CSN
#define MOSI PB3//MOSI pin
#define MISO PB4//MISO pin
#define SCK PB5//SCK pin
#define SPI_DDR_PORT DDRB//direction port
#define SPI_PORT PORTB//output port
#define SPI_PIN PINB//input port
#define NRF_DDR_PORT DDRC//direction register of port which control nRF power
#define NRF_PORT PORTC//output register of port which control nRF power
#define NRF_PIN PC0//pin on the output register thah controls nRF power
#define NRF_ON NRF_PORT &= ~(1<<NRF_PIN);//turn on nRF
#define NRF_OFF NRF_PORT |= (1<<NRF_PIN);//turn off nRF
#define CSN_HIGH SPI_PORT |= (1<<CSN) //make CSN high macro
#define CSN_LOW SPI_PORT &= ~(1<<CSN)//make CSN low macro
#define CE_HIGH SPI_PORT |= (1<<CE)//make CE high macro
#define CE_LOW SPI_PORT &= ~(1<<CE)//make CE low macro
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//SET TX and RX adresses length//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define TX_ADDRES_LENGTH 5
#define RX_ADDRES_LENGTH 5
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SET maximum payload size ( 1 - 32 bytes )//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define MAXIMUM_PAYLOAD_SIZE 32
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// define using IRQ (1 - use IRQ, 0 - don't use IRQ)//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define USE_IRQ 1
#if USE_IRQ == 1
////////////////////////////////////////////////////////////
// INTERRUPTS CONFIGURATOR - Konfigurator przerwań //
// 1 - interrupt active 1 - przerwanie aktywne //
// 0 - interrupt not active 0 - przerwanie wyłączone //
////////////////////////////////////////////////////////////
#define USE_MAX_RETRANSMISION_IRQ 1
#define USE_END_OF_TRANSMISSION_IRQ 1
#define USE_DATA_READY_TO_READ_IRQ 1
#if USE_MAX_RETRANSMISION_IRQ == 1
#define MAX_RT_MASK (0<<MASK_MAX_RT)
#else
#define MAX_RT_MASK (1<<MASK_MAX_RT)
#endif
#if USE_END_OF_TRANSMISSION_IRQ == 1
#define TX_DS_MASK (0<<MASK_TX_DS)
#else
#define TX_DS_MASK (1<<MASK_TX_DS)
#endif
#if USE_DATA_READY_TO_READ_IRQ == 1
#define RX_DR_MASK (0<<MASK_RX_DR)
#else
#define RX_DR_MASK (1<<MASK_RX_DR)
#endif
#define nRF24L01_CONFIG ( RX_DR_MASK | MAX_RT_MASK | TX_DS_MASK )
#else
#define MAX_RT_MASK (1<<MASK_MAX_RT)
#define TX_DS_MASK (1<<MASK_TX_DS)
#define RX_DR_MASK (1<<MASK_RX_DR)
#define nRF24L01_CONFIG ( RX_DR_MASK | MAX_RT_MASK | TX_DS_MASK )
#endif
///''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// RX and TX event flags
//........................................................................................................................
extern volatile uint8_t TX_flag;
extern volatile uint8_t RX_flag;
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function declarations
//........................................................................................................................
void nRF_RX_EVENT (void); //this function checks if there are data to read and if there is callback function registered.
//if there are data avaliable to read this function sends this data to registered calbback function
void register_nRF_RX_Event_Callback ( void ( * callback )( void * nRF_RX_buff , uint8_t len ) ); //this function is used to register RX_EVENT callback function
void nRF_SendDataToAir( uint8_t * data ); //this function sends data to to another nRF or nRF's. Length of data payload is calculeted by strlen funcion so
//you must send data in ASCII format
uint8_t nRF_Data_Ready(void); //this function is used when IRQ are disabled. It checks if there any data to read
void Initialize_INTERRUPT_For_nRF(void); //this function is used to initlialization of external interrupt for nRF
void nRF_init( void ); //Initialize NRF24l01
void nRF_Config_Register(uint8_t register_name, uint8_t value); //WRITE SOMETHING TO NRF REGISTER
void nRF_SET_Transmitter_Adres(const char * addres); //this function sets transmitter addres
void nRF_SET_Reciver_Addres( uint8_t data_pipe, const char * addres ); //this function sets reciver addres of choosen datapipe
uint8_t nRF_Read_One_Byte_From_Register(uint8_t register_name); //this function returns value of register given by attribute
void nRF_Set_Retransmission_Time_And_Ammount (uint8_t time, uint8_t ammount); //this function sets time beetwen retransmissions and ammount of them
void nRF_TX_Power_Up(void); //this function turns on TX mode
void nRF_RX_Power_Up(void); //this function turns on RX mode
void nRF_Power_Down(void); //this funtion turns on Power_down mode
void nRF_Set_Channel( uint8_t channel ); //this function sets channel ( 0 to 127 )
void nRF_Clear_TX (void); //this function clears TX fifo
void nRF_Clear_RX (void); //this function clears RX fifo
#endif /* NRF24L01_H_ */[/syntax]
nRF24L01.c
[syntax=c]/* e-gadget.header
* nRF24L01.c
*
* Created on:
* Modyfied: 2015-04-13 21:18:47
* Author: Nefarious19
*
* Project name: "NRF24"
*
*This is AVR GCC library for nRF24L01 module, ver. 1.0
*It can be only used by REGISTERED USERS of www.forum.atnel.pl,
*they must only leave this header in they C code.
*
*Library code was written on the basis of:
*
*https://www.sklep.atnel.pl/pl/p/AVR-Microcontrollers-C-Programming-Basics-EN-BOOK-DVD/103
*https://www.sklep.atnel.pl/pl/p/Jezyk-C-Pasja-programowania-mikrokontrolerow-8-bitowych-Wydanie-II-Ksiazka-DVD/104
*
*"
*
*This library uses also some ideas from:
*
*http://gizmosnack.blogspot.com/2013/04/tutorial-nrf24l01-and-avr.html
*http://www.tinkerer.eu/AVRLib/nRF24L01/
*
*
*/
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <string.h>
#include <avr/pgmspace.h>
//#include "usart.h"
#include "SPI.h"
#include "nRF24L01.h"
#include "nRF24L01_memory_map.h"
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// declarations of internal tool functions
//..................................................................................................................
void nRF_Read_Register( uint8_t register_name, uint8_t * buffer_for_registers_content, uint8_t length_of_content ); //reads given ammount of bytes from choosen register
void nRF_Write_Register( uint8_t register_name, uint8_t * buffer_for_registers_content, uint8_t length_of_content ); //writes given ammount of bytes to choosen register
void nRF_Set_Active_DataPipe_And_ACK (uint8_t DataPipe, uint8_t on_or_off, uint8_t ACK_on_or_off ); //This function is used to set active payload/payloads and enable/disable ACK functions
void nRF_Set_PAYLOAD_Width ( uint8_t payload, uint8_t width ); //this function is used to set payload length. Use this function if dynamic payload length is disabled
void nRF_Set_Dynamic_Payload_State_On_Data_Pipe(uint8_t data_pipe_number, uint8_t on_off ); //this function is used to set
void nRF_Set_Data_Speed_And_Reciver_Power(uint8_t Data_rate, uint8_t power); //this function is used to set transmission speed and reciver power
void nRF_Set_State_And_Width_Of_CRC( uint8_t one_or_two_bytes , uint8_t on_or_off); //this function is used to set CRC state and width.
//__________________________________________________________________________________________________________________
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// declaration of global variables which stores values depending on the transmission states
//..................................................................................................................
volatile uint8_t TX_flag; //data sent event flag
volatile uint8_t RX_flag; //data ready event flag
//..................................................................................................................
volatile uint8_t disable_dynamic_payload;
volatile uint8_t payload_width;
volatile uint8_t first_time = 0;
//__________________________________________________________________________________________________________________
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// declaration of the buffer which stores incoming payloads data
//..................................................................................................................
uint8_t nRF_RX_bufffer[MAXIMUM_PAYLOAD_SIZE+1]; //reciver buffer
//__________________________________________________________________________________________________________________
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// callback function declaration
//........................................................................................................................
static void ( * nRF_RX_Event_Callback ) ( void * nRF_RX_buff , uint8_t len );
//________________________________________________________________________________________________________________________
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function which is used to register your own callback function
//........................................................................................................................
void register_nRF_RX_Event_Callback ( void ( * callback )( void * nRF_RX_buff , uint8_t len ) )
{
nRF_RX_Event_Callback = callback; //in this line we give an addres to our callback function
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// recived data event function
//........................................................................................................................
void nRF_RX_EVENT (void)
{
#if USE_IRQ == 0
if ( nRF_Data_Ready() ) RX_flag = 1;
else RX_flag = 0;
#endif
if ( RX_flag )// if RX_flag == 1 then: - jeżeli zmienna RX_flag == 1 to:
{
uint8_t fifo_status; //variable which stores FIFO_STATUS register value
uint8_t len; //variable which stores length of recived payload
uint8_t i; //index variable for loop
uint8_t * wsk; //pointer for first byte of reciver buffer nRF_RX_buffer
RX_flag = 0; //reset the RX_flag
//do...while loop. this loop executes until RX_FIFO is empty
do
{
nRF_Config_Register(STATUS, (1<<RX_DR)); //Reset RX_DR IRQ flag in nRF STATUS register
wsk = nRF_RX_bufffer; //wsk equals to addres of first byte nRF_RX_bufffer
CSN_LOW; //chip select low
SPI_WriteByte(R_RX_PL_WID); //send: read length of payload command
len = SPI_WriteReadByte(NOP);//read length
CSN_HIGH; //chip select high
if ( len > MAXIMUM_PAYLOAD_SIZE ) break; //if len is bigger than maximum payload size then break
CSN_LOW; //chip select low
SPI_WriteByte( R_RX_PAYLOAD ); //read payload command
for (i = 0; i < len; i++) //read data until i < len
{
*wsk++ = SPI_WriteReadByte(NOP);
}
CSN_HIGH; //csn goes high - csn stan wysoki
fifo_status = nRF_Read_One_Byte_From_Register(FIFO_STATUS); //read FIFO_STATUS register
}
while ( ( fifo_status & (1<<RX_EMPTY) ) == 0 ); //if RX_EMPTY bit is LOW then loop must execute.
nRF_Clear_RX();//clear RX_FIFO
nRF_Config_Register(STATUS, (1<<RX_DR)); //Reset RX_DR IRQ flag in nRF STATUS register
if ( len && nRF_RX_Event_Callback ) ( * nRF_RX_Event_Callback )( nRF_RX_bufffer, len ); //if callback function is registered and len is bigger
//than 0 send recived data to your callback function
}
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// INITIALIAZE NRF function
//........................................................................................................................
void nRF_init( void )
{
init_SPI(); //initialize SPI (software or hardware, you must choose it in SPI.h file)
#if USE_IRQ == 1
Initialize_INTERRUPT_For_nRF(); //initialize INTx or PCINTx interrupt for nRF, you must do it on your Own
#endif
NRF_DDR_PORT |= (1<<NRF_PIN); //nRF power control pin is output - pin sterujący zasilaniem nRFa jako wyjście
NRF_OFF; //turn off nRF
_delay_ms(500);
NRF_ON; //turn on nRF
_delay_ms(500);
nRF_SET_Transmitter_Adres(PSTR("ATNEL"));//set transmitter addres
nRF_SET_Reciver_Addres(RX_ADDR_P0, PSTR("ATNEL"));//set reciving addres for datapipe0
nRF_Config_Register( CONFIG, nRF24L01_CONFIG); //Write interrupt masks nRF_CONFIG to CONGIG register of nRF
nRF_Clear_RX(); //Clear RX FIFO
nRF_Clear_TX(); //Clear TX FIFO
nRF_Set_State_And_Width_Of_CRC( ONE_BYTE , ON ); //ON == Enable CRC; OFF == disable CRC, ONE_BYTE or TWO_BYTES - width of CRC;
nRF_Set_Channel(10); //Set channel number
nRF_Set_Active_DataPipe_And_ACK ( ERX_P0, ON, ACK_ON );//Set which datapipe state you want to change, in this case datapipe = 0 (ERX_P0), ON - means enable this datapipe, ACK_ON means to enable ACK for choosen data pipe.
nRF_Set_Retransmission_Time_And_Ammount(WAIT_4000uS , RETR_15_TIMES ); //set time between retransmissions and ammount of retranssmisions
nRF_Set_Data_Speed_And_Reciver_Power(TRANS_SPEED_250kB, RF_PWR_18dB ); //Set transmision speed and reciver power
nRF_Set_Dynamic_Payload_State_On_Data_Pipe( DPL_P0 , ON ); //Enable dynamic payload of choosen datapipe
RX_flag = 1;//Clear RX flag
TX_flag = 0; //Clear TX flag
nRF_Config_Register(STATUS, (1<<TX_DS) | (1<<RX_DR) | (1<<MAX_RT)); //Clear interrupt bits in STATUS register
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to read one byte from register given as attribute of the function
//........................................................................................................................
uint8_t nRF_Read_One_Byte_From_Register(uint8_t register_name)
{
uint8_t data; //temporary variable data is used to store and return value of choosen register
CSN_LOW; //chip select low
SPI_WriteByte( R_REGISTER | (REGISTER_MASK & register_name) ); //send R_REGISTER command with number of choosen register (SEE nRF24L01_memory_map.h)
data = SPI_WriteReadByte(NOP); //write to "data", value from choosen register
CSN_HIGH; //chip select high
return data; //return data
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to write data to the choosen register
//........................................................................................................................
void nRF_Config_Register(uint8_t register_name, uint8_t value)
{
CSN_LOW;//make CSN low
SPI_WriteByte( W_REGISTER | (REGISTER_MASK & register_name) ); //send information to nRF which register you want to write
SPI_WriteByte( value ); //send value that you want write to this register
CSN_HIGH; //make CSN high
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to read data from the choosen register to buffer
//........................................................................................................................
void nRF_Read_Register( uint8_t register_name, uint8_t * buffer_for_registers_content, uint8_t length_of_content )
{
CSN_LOW; //make CSN low
SPI_WriteByte( R_REGISTER | ( REGISTER_MASK & register_name ) ); //send information to nRF which register you want to read
SPI_WriteReadDataBuffer( buffer_for_registers_content, buffer_for_registers_content, length_of_content );//read from nRF given ammount of bytes to the buffer
CSN_HIGH; //make CSN high
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to write data from the buffer to the choosen register
//........................................................................................................................
void nRF_Write_Register( uint8_t register_name, uint8_t * buffer_for_registers_content, uint8_t length_of_content )
{
CSN_LOW;//make CSN low
SPI_WriteByte( W_REGISTER | ( REGISTER_MASK & register_name ) );//send information to nRF which register you want to write
SPI_WriteReadDataBuffer( buffer_for_registers_content, buffer_for_registers_content, length_of_content );//write to nRF given ammount of bytes from the buffer
CSN_HIGH;//make CSN low
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to set transmitter addres.
//........................................................................................................................
void nRF_SET_Transmitter_Adres(const char * addres)
{
char TX_addres[TX_ADDRES_LENGTH];//declaration of TX_addres temporary buffer
for(uint8_t i = 0; i < TX_ADDRES_LENGTH; i++ ) //until i is smaller than TX_ADDRES LENGTH copy data from flash to temporary TX_addres buffer
{
TX_addres[i] = pgm_read_byte(addres++);
}
if( TX_ADDRES_LENGTH > 5 ) nRF_Write_Register(TX_ADDR, (uint8_t *) TX_addres, 5);//if TX_ADDRES_LENGTH is bigger than 5 bytes send only 5 bytes
else if( TX_ADDRES_LENGTH < 3 ) nRF_Write_Register(TX_ADDR, (uint8_t *) TX_addres, 3); //if TX_ADDRES_LENGTH is smaller than 3 bytes send 3 bytes
else nRF_Write_Register(TX_ADDR, (uint8_t *) TX_addres , TX_ADDRES_LENGTH); //else send given by attribute ammount of bytes
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to set transmitter addres.
//........................................................................................................................
void nRF_SET_Reciver_Addres( uint8_t data_pipe, const char * addres )
{
char RX_addres[RX_ADDRES_LENGTH];//declaration of RX_addres temporary buffer
if( data_pipe > RX_ADDR_P5 ) data_pipe = RX_ADDR_P0; //this is a protection. When given by data_pipe variable register addres is smaller
else if( data_pipe < RX_ADDR_P0 ) data_pipe = RX_ADDR_P0;// or bigger than possible value, this condition is setting deffault value
else if( data_pipe > RX_ADDR_P5 ) data_pipe = RX_ADDR_P5;
if ( data_pipe < RX_ADDR_P2 )// data_pipe ix equal to RX_ADDR_P0 or RX_ADDR_P1 write 5 bytes of addres to nRF
{
for(uint8_t i = 0; i < RX_ADDRES_LENGTH; i++ )
{
RX_addres[i] = pgm_read_byte(addres++);
}
if( RX_ADDRES_LENGTH > 5 ) nRF_Write_Register(data_pipe, (uint8_t*)RX_addres, 5);
else if( RX_ADDRES_LENGTH < 3 ) nRF_Write_Register(data_pipe, (uint8_t*) RX_addres, 3);
else nRF_Write_Register(data_pipe, (uint8_t *) RX_addres, RX_ADDRES_LENGTH);
}
else//else send only one byte of addres because first four bytes are the same as the RX_ADDR_P1 first four bytes of addres.
{
RX_addres[0] = pgm_read_byte(addres);
nRF_Config_Register(data_pipe, RX_addres[0]);
}
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to chcecking RX_DR bit in STATUS register. When this bit is HIGH that means tha data are ready
// function used in pooling mode
//........................................................................................................................
uint8_t nRF_Data_Ready(void)
{
CSN_LOW;//make CSN low
uint8_t data = SPI_WriteReadByte(NOP);//send to nRF dummy byte and read STATUS register
CSN_HIGH;//make CSN high
return (data & (1<<RX_DR));//return 0 if data not ready or 1 if data ready
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to set state and width of CRC. First attrbiute of this function is ONE_BYTE or TWO_BYTES,
// second attribute is ON or OFF
//........................................................................................................................
void nRF_Set_State_And_Width_Of_CRC( uint8_t one_or_two_bytes , uint8_t on_or_off)
{
uint8_t config = nRF_Read_One_Byte_From_Register(CONFIG);//read data from congig register and save it to config variable
if ( one_or_two_bytes == ONE_BYTE ) config &= ~(1<<CRCO);//if first given attribute is ONE_BYTE clear CRCO bit
else if ( one_or_two_bytes == TWO_BYTES ) config |= (1<<CRCO);//else if first given attribute is TWO_BYTES set CRCO bit
else config &= ~(1<<CRCO);//else given attribute is diffrent set CRCO low
if (on_or_off == ON) config |= (1<<EN_CRC);//if second attribute is equal to ON, set EN_CRC bit
else if ( on_or_off == OFF ) config &= ~(1<<EN_CRC);//esle reset the EN_CRC bit
nRF_Config_Register(CONFIG, config);//write config content to CONFIG register
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to switch nRF into TX mode
//........................................................................................................................
void nRF_TX_Power_Up(void)
{
CE_LOW;//make CE low
uint8_t config;//declaration of temporary variable
config = nRF_Read_One_Byte_From_Register(CONFIG);//save copy of config regster in config variable
config &= ~(1<<PRIM_RX);//reset PRIM_RX bit
config |= (1<<PWR_UP);//set PWR_UP bit
nRF_Config_Register( CONFIG , config);//write config variable to CONGIG register
CE_HIGH;//make CE high
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to switch nRF into RX mode
//........................................................................................................................
void nRF_RX_Power_Up(void)
{
CE_LOW;//make CE_LOW
uint8_t config;//declaration of config variable
config = nRF_Read_One_Byte_From_Register(CONFIG);//save copy of CONFIG register to config variable
nRF_Config_Register(CONFIG , config | (1<<PWR_UP) | (1<<PRIM_RX) );//set PWR_UP and PRIM_RX bits in config variable ande save it in nRF CONFIG register
CE_HIGH;//make CE_HIGH
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to switch nRF into POWER DOWN mode
//........................................................................................................................
void nRF_Power_Down(void)
{
CE_LOW;//make CE_LOW
uint8_t config;//declaration of config variable
config = nRF_Read_One_Byte_From_Register(CONFIG);//save copy of CONFIG register to config variable
config &= ~((1<<PWR_UP) | (1<<PRIM_RX));//reset PWR_UP and PRIM_RX bits
nRF_Config_Register(CONFIG , config );//save congig variable in CONFIG register
nRF_Clear_RX();//clear RX fifo
nRF_Clear_TX();//clear TX fifo
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to set transmission channel
//........................................................................................................................
void nRF_Set_Channel( uint8_t channel )
{
nRF_Config_Register( RF_CH , 0x7F & channel );//save to nRF RF_CH register channel number (0x7f == 0b01111111 is the mask)
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to clear TX fifo
//........................................................................................................................
void nRF_Clear_TX (void)
{
CSN_LOW;//make CSN low
SPI_WriteByte( FLUSH_TX );//send to nRF FLUSH_TX command what means CLEAR TX FIFO
CSN_HIGH;//make CSN high
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to clear RX fifo
//........................................................................................................................
void nRF_Clear_RX (void)
{
CSN_LOW;//make CSN low
SPI_WriteByte( FLUSH_RX );//send to nRF FLUSH_RX command what means CLEAR RX FIFO
CSN_HIGH;//make CSN high
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to set states of datapipes
// first attribute is DataPipe, you must put here name of datapipe tha you want to enable, this name is ERX_Px where x is number of data pipe (see nRF_Init function)
// second attribute is or_on_off, here you put ON or OFF macro. When you put here ON, the choosen data pipe will be turned ON, if put here OFF, datapipe will be turned off
// third and last parameter is ACK_on_or_off, you must put here macros: ACK_ON or ACK_OFF. This parameter turns ACK_ON or turns ACK_OFF
//........................................................................................................................
void nRF_Set_Active_DataPipe_And_ACK (uint8_t DataPipe, uint8_t on_or_off, uint8_t ACK_on_or_off )
{
uint8_t data = nRF_Read_One_Byte_From_Register(EN_RXADDR);//read data from EN_RXADDR register save it in data variable
if(on_or_off == ON) data |= (DataPipe);//if second attribute is ON, set bit ERX_Px (given by DataPipe parameter)
else if (on_or_off == OFF) data &= ~(DataPipe);//else reset this bit
nRF_Config_Register( EN_RXADDR, data );//save data variable to EN_RXADDR register
data = nRF_Read_One_Byte_From_Register(EN__AA);//read data from EN_AA register and save it in data variable
if(ACK_on_or_off == ACK_ON) data |= (DataPipe);//if third parameter is ACK_ON, enable auto ackonwledgements by setting ENAA_Px bit (this same value as ERX_Px)
else if (ACK_on_or_off == ACK_OFF) data &= ~(DataPipe);//else turn off auto acknowledgments
nRF_Config_Register( EN__AA, data );//save the variable data to EN__AA register
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to send data to another nRF's
// attribute to this function is the pointer to the first byte of transsmision buffer
//........................................................................................................................
void nRF_SendDataToAir( uint8_t * data )
{
#if USE_IRQ == 0
CSN_LOW;//make CSN low
uint8_t data1 = SPI_WriteReadByte(NOP);//send to nRF dummy byte and read STATUS register
CSN_HIGH;//make CSN high
if ( ( data1 & (1<<MAX_RT) ) )//if maximum ammount of retransmissions is achived,
{
CE_LOW;//make CE low
nRF_Clear_TX();//clear TX FIFO
nRF_Config_Register(STATUS, data1 | (1<<MAX_RT) | (1<<TX_DS) );//reset TX_DS and MAX_RT intterrupt flags in STATUS register
return; //return
}
//else if was send or funcion is used for the first time
else if ( ( data1 & (1<<TX_DS)) || (first_time == 0) ) TX_flag = 0;//TX flag = 0
else TX_flag = 1;
first_time = 1;//first_time equals to 1
nRF_Config_Register(STATUS, data1 | (1<<TX_DS));//clear TX_DS int flag
#endif
if(TX_flag == 1) return;//if still is in transmitting mode or function isn't used for the first time, return
TX_flag = 1;//set TX mode flag to one
uint8_t * wsk = data;//wsk pointer is equal to the addres of first byte transmission buffer
uint8_t length;//declare length variable
if(disable_dynamic_payload == 1) length = payload_width;//if nRF_Set_PAYLOAD_Width() was used use the length variable is equal to width parameter of tha function
else length = strlen((char*) data);//else length is equal to the size of transmission buffer
if ( length >= MAXIMUM_PAYLOAD_SIZE ) length = 32;
nRF_TX_Power_Up();//turn on transmission mode
nRF_Clear_TX();//clear TX fifo
CSN_LOW;//make CSN low
SPI_WriteByte(W_TX_PAYLOAD);//send to nRF W_TX_PAYLOAD command what means "Write data to TX FIFO"
for (uint8_t i = 0; i < length; i++ )//until "i" is smaller than "length" send bytes to nRF
{
SPI_WriteByte(*wsk++);
}
CSN_HIGH;//CSN high
CE_HIGH;//start transmision!
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to set payload width
// first attribute of this function is number or RX payload (RX_PW_Px), second one is the width(1-32 bytes)
// use this function only if the dyanmic payloads are turned off
//........................................................................................................................
void nRF_Set_PAYLOAD_Width ( uint8_t payload, uint8_t width )
{
nRF_Config_Register( payload, ( 0x1F & width ) );//config RX_PW_Px with number of bytes
disable_dynamic_payload = 1;//set the disable_dynamic_payload flag
payload_width = width;//global variable payload_width is equal to width given by attribute
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to number of retransmissions and time beetwen each retransmission
// first attribute is WAIT_XXXX_uS and the second is RETR_X_TIMES (see nRF_memory_map.h)
//........................................................................................................................
void nRF_Set_Retransmission_Time_And_Ammount (uint8_t time, uint8_t ammount)
{
nRF_Config_Register( SETUP_RETR, ( time | ammount ) );//write to SETUP_RETR register number of retransmisions and time beetwen them
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to set transmission speed and receiver power
// first attribute is TRANS_SPEED_x and the second is RF_PWR_x (see nRF_memory_map.h)
//........................................................................................................................
void nRF_Set_Data_Speed_And_Reciver_Power(uint8_t Data_rate, uint8_t power)
{
nRF_Config_Register( RF_SETUP, ( Data_rate | power )); //write to RF_SETUP register transmision speed and and receiver power
}
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// function used to set dynamic payloads
// first attribute is DPL_Px (number of receiver payload) and the second is ON or OFF(see nRF_memory_map.h)
//........................................................................................................................
void nRF_Set_Dynamic_Payload_State_On_Data_Pipe(uint8_t data_pipe_number, uint8_t on_off )
{
nRF_Config_Register( DYNPD, data_pipe_number );//save DPL_Px value to DYNPD register
uint8_t feature = nRF_Read_One_Byte_From_Register(FEATURE);//make copy of FEATURE register
if (on_off == ON)feature |= (1<<EN_DPL);//if second attribute is equal to ON
//set bit EN_DPL
if (on_off == OFF)feature &= ~(1<<EN_DPL);//if second attribute is equal to OFF
//reset bit EN_DPL
nRF_Config_Register(FEATURE, feature);//save feature variable to FEATURE register
}
#if USE_IRQ == 1
//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''//
// IRQ INTERRUPT HANDLER section //
//.............................................................................//
//in this function you must put your initialization of external intterup (INTx or PCINTx)
//if you don't use interrupts there is no matter what code is here
void Initialize_INTERRUPT_For_nRF(void)
{
MCUCR = ((1<<ISC11)|(0<<ISC10)|(1<<ISC01)|(0<<ISC00)); // Set external interupt on falling edge
GICR = ((0<<INT1)|(1<<INT0)); // Activate INT0
}
//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// Here is external intterupt handler, if you are using interupts change the name of the vector interrupt ore live the same if you are using the same
//...................................................................................................................................................
ISR(INT0_vect)
{
CSN_LOW;//Chip select LOW
register uint8_t status = SPI_WriteReadByte(NOP);//read STATUS register value
CSN_HIGH;//chip select high
if ( (status & (1<<RX_DR)) )//id data recived
{
status |= (1<<RX_DR);//reset intterupt bit on status variable
nRF_Config_Register(STATUS, status);//save status variable in STATUS register
RX_flag = 1;//RX flag equals to 1
}
if ( status & (1<<TX_DS) )//if data was send
{
status |= (1<<TX_DS);//clear TX_DS bit in status variable
nRF_Config_Register( STATUS, status );//save status variable in STATUS register
TX_flag = 0;//TX_flag = 0
nRF_RX_Power_Up();//enable receiving mode
}
if ( status & (1<<MAX_RT) )//id max of retransmissions was achived
{
status |= (1<<MAX_RT) | (1<<TX_DS);//clear MAX_RT and TX_DS bits in status variable
TX_flag = 0;//clear TX_flag
nRF_RX_Power_Up();//turn on RX mode
nRF_Clear_TX();//clear TX fifo
nRF_Config_Register( STATUS, status );//save variable status to the STATUS register
}
}
#endif[/syntax]
nRF24L01_memory_map.h
[syntax=c]/* e-gadget.header
* nRF24L01_memory_map.h
*
* Created on: 2015-03-07
* Modyfied: 2015-04-13 21:18:47
* Author: Nefarious19
*
* Project name: "NRF24"
*
*This is AVR GCC library for nRF24L01 module, ver. 1.0
*It can be only used by REGISTERED USERS of www.forum.atnel.pl,
*they must only leave this header in they C code.
*
*Library code was based on the libraries from the books:
*
*https://www.sklep.atnel.pl/pl/p/AVR-Microcontrollers-C-Programming-Basics-EN-BOOK-DVD/103
*https://www.sklep.atnel.pl/pl/p/Jezyk-C-Pasja-programowania-mikrokontrolerow-8-bitowych-Wydanie-II-Ksiazka-DVD/104
*
*"
*
*This library uses also some ideas from:
*
*http://gizmosnack.blogspot.com/2013/04/tutorial-nrf24l01-and-avr.html
*http://www.tinkerer.eu/AVRLib/nRF24L01/
*
*
*/
#ifndef NRF24L01_MEMORY_MAP_H_
#define NRF24L01_MEMORY_MAP_H_
/////////////////////////////////////////////
// SWITCHES definitions
/////////////////////////////////////////////
///////////////////
#define ON 1
#define OFF 2
///////////////////
#define TWO_BYTES 2
#define ONE_BYTE 1
///////////////////
#define ACK_ON 1
#define ACK_OFF 2
///////////////////
//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''//
//REGISTERS LIST OF nRF24L01 - SPIS REJESTRÓW MODUŁU nRF24L01//
//,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,//
#define CONFIG 0x00 //CONFIGURATION REGISTER - REJESTR CONFIGURACYJNY
#define EN__AA 0x01 //ENABLE AUTO ACKNOWLEDGEMENT - WŁĄCZ AUTOMATYCZNE POTWIERDZENIE DOTARCIA PAKIETU
#define EN_RXADDR 0x02 //ENABLE RX ADRESSES - WŁĄCZONE ADRESY ODBIORCZE DLA STRUMIENI DANYCH (0 - 5 DATA PIPES)
#define SETUP_AW 0x03 //SETUP ADRESSE WIDTH - USTAL DŁUGOŚC ADRESU (3-5 BAJTÓW) WSPÓLNE DLA KAŻDEGO Z 6 STRUMIENI DANYCH (DATA PIPES)
#define SETUP_RETR 0x04 //SETUP RETRANSMISON - USTAW CZAS PONOWNEJ RETRANSMISJI PAKIETU
#define RF_CH 0x05 //CHANNEL - KANAŁ NA JAKIM JEST NADAWANIE
#define RF_SETUP 0x06 //TRANSMISSION SETTINGS - USTAWIENIA TRANSMISJI
#define STATUS 0x07 //STATUS REGISTER - REJESTR STATUSU
#define OBSERVE_TX 0x08 //TRANSMIT OBSERVE REGISTER - OBSERWACJA STANU NADAWANIA
#define RPD 0x09 //RECIVED POWER DETECTOR - WYKRYWANIE MOCY NADAWANEGO SYGNAŁU
#define RX_ADDR_P0 0x0A //RECEIVER ADDRES FOR DATA PIPE 0 - ADRES ODBIORCZY DLA STRUMIENIA DANYCH NR 0
#define RX_ADDR_P1 0x0B //RECEIVER ADDRES FOR DATA PIPE 1 - ADRES ODBIORCZY DLA STRUMIENIA DANYCH NR 1
#define RX_ADDR_P2 0x0C //RECEIVER ADDRES FOR DATA PIPE 2 - ADRES ODBIORCZY DLA STRUMIENIA DANYCH NR 2
#define RX_ADDR_P3 0x0D //RECEIVER ADDRES FOR DATA PIPE 3 - ADRES ODBIORCZY DLA STRUMIENIA DANYCH NR 3
#define RX_ADDR_P4 0x0E //RECEIVER ADDRES FOR DATA PIPE 4 - ADRES ODBIORCZY DLA STRUMIENIA DANYCH NR 4
#define RX_ADDR_P5 0x0F //RECEIVER ADDRES FOR DATA PIPE 5 - ADRES ODBIORCZY DLA STRUMIENIA DANYCH NR 5
#define TX_ADDR 0x10 //TRANSMITER ADDRES - ADRES NADAWCZY MODUŁU
#define RX_PW_P00x11 //RECEIVER PAYLOAD WIDTH FOR DATA PIPE 0 - DŁUGOŚC ODEBRANEGO PAKIETU ZE STRUMIENIA DANYCH 0
#define RX_PW_P10x12 //RECEIVER PAYLOAD WIDTH FOR DATA PIPE 1 - DŁUGOŚC ODEBRANEGO PAKIETU ZE STRUMIENIA DANYCH 1
#define RX_PW_P20x13 //RECEIVER PAYLOAD WIDTH FOR DATA PIPE 2 - DŁUGOŚC ODEBRANEGO PAKIETU ZE STRUMIENIA DANYCH 2
#define RX_PW_P30x14 //RECEIVER PAYLOAD WIDTH FOR DATA PIPE 3 - DŁUGOŚC ODEBRANEGO PAKIETU ZE STRUMIENIA DANYCH 3
#define RX_PW_P40x15 //RECEIVER PAYLOAD WIDTH FOR DATA PIPE 4 - DŁUGOŚC ODEBRANEGO PAKIETU ZE STRUMIENIA DANYCH 4
#define RX_PW_P50x16 //RECEIVER PAYLOAD WIDTH FOR DATA PIPE 5 - DŁUGOŚC ODEBRANEGO PAKIETU ZE STRUMIENIA DANYCH 5
#define FIFO_STATUS 0x17 //FIFO STATUS - STATUS STOSÓW NADAWCZYCH I ODBIORCZYCH
#define DYNPD 0x1C //DYNAMIC PAYLOAD WIDTH - DYNAMICZNA SZEROKOŚC RAMKI DANYCH
#define FEATURE 0x1D //FEATURE REGISTER - REJESTR Z FICZERAMI
//"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""//
//LIST OF CONFIGURATION BITS IN EACH REGISTER - LISTA BITÓW KONFIGURACYJNYCH W KAŻDYM REJESTRZE//
//.............................................................................................//
// |CONFIG|
#define MASK_RX_DR 6 //1-OFF, 0-ON INTERRUPT ON IRQ IF RECIVED DATA READY - 1-WYŁĄCZ, 0-WŁĄCZ PRZERWANIE NA PINIE IRQ GDY ODEBRANE DANE GOTOWE
#define MASK_TX_DS 5 //1-OFF, 0-ON INTERRUPT ON IRQ IF DATA TRANSMITED SUCCESFULLY - 1-WYŁĄCZ, 0-WŁĄCZ PRZERWANIE NA PINIE IRQ GDY DANE WYSŁANO POMYŚLNIE
#define MASK_MAX_RT 4 //1-OFF, 0-ON INTERRUPT ON IRQ IF MAXIMUM ACCOUNT OF RETRANSMISIONS IS ACHIVED - 1-WYŁĄCZ, 0-WŁĄCZ PRZERWANIE NA PINIE IRQ GDY PRZEKROCZONO MAKSYMALNĄ LICZBE RETRANSMISJI PAKIETU
#define EN_CRC 3 //ENABLE CRC - WŁĄCZ SUME KONTROLNĄ CRC
#define CRCO 2 //CRC ENCHODING SCHEME - IF 0 -> crc == 1 BYTE; IF 1 CRC == 2 BYTES; LICZBA BAJTÓW UMY KONTROLNEJ CRC: JEŻELI 0 -> CRC TO 1 BAJT, JEŻELI 1 -> CRC TO 2 BAJTY
#define PWR_UP 1 //1 - POWER UP, 0 - POWER DOW; 1 - WŁĄCZ MODUŁ, 0 - WYŁĄCZ MODUŁ
#define PRIM_RX 0 //RX/TX CONTROL: 1 - RECEIVING, 0 - TRANSMITING; KONTROLA ODBIÓR/NADAWANIE: 1 - OBIÓR, 0 - NADAWANIE
// |EN_AA|
#define ENAA_P5 (1<<5) //ENABLE AUTO ACKNOWLEDGEMENT DATA PIPE 5 - WŁĄCZ AUTOMATYCZNE POTWIERDZENIA POPRAWNEGO NDANIA/ODBIORU PAKIETU DLA STRUMIENIA DANYCH NR 5
#define ENAA_P4 (1<<4) //ENABLE AUTO ACKNOWLEDGEMENT DATA PIPE 4 - WŁĄCZ AUTOMATYCZNE POTWIERDZENIA POPRAWNEGO NDANIA/ODBIORU PAKIETU DLA STRUMIENIA DANYCH NR 4
#define ENAA_P3 (1<<3) //ENABLE AUTO ACKNOWLEDGEMENT DATA PIPE 3 - WŁĄCZ AUTOMATYCZNE POTWIERDZENIA POPRAWNEGO NDANIA/ODBIORU PAKIETU DLA STRUMIENIA DANYCH NR 3
#define ENAA_P2 (1<<2) //ENABLE AUTO ACKNOWLEDGEMENT DATA PIPE 2 - WŁĄCZ AUTOMATYCZNE POTWIERDZENIA POPRAWNEGO NDANIA/ODBIORU PAKIETU DLA STRUMIENIA DANYCH NR 2
#define ENAA_P1 (1<<1) //ENABLE AUTO ACKNOWLEDGEMENT DATA PIPE 1 - WŁĄCZ AUTOMATYCZNE POTWIERDZENIA POPRAWNEGO NDANIA/ODBIORU PAKIETU DLA STRUMIENIA DANYCH NR 1
#define ENAA_P0 (1<<0) //ENABLE AUTO ACKNOWLEDGEMENT DATA PIPE 0 - WŁĄCZ AUTOMATYCZNE POTWIERDZENIA POPRAWNEGO NDANIA/ODBIORU PAKIETU DLA STRUMIENIA DANYCH NR 0
// |EN_RXADDR|
#define ERX_P5 (1<<5) //ENABLE DATA PIPE 5 - WŁĄCZ STRUMIEŃ DANYCH NR 5
#define ERX_P4 (1<<4) //ENABLE DATA PIPE 5 - WŁĄCZ STRUMIEŃ DANYCH NR 5
#define ERX_P3 (1<<3) //ENABLE DATA PIPE 5 - WŁĄCZ STRUMIEŃ DANYCH NR 5
#define ERX_P2 (1<<2) //ENABLE DATA PIPE 5 - WŁĄCZ STRUMIEŃ DANYCH NR 5
#define ERX_P1 (1<<1) //ENABLE DATA PIPE 5 - WŁĄCZ STRUMIEŃ DANYCH NR 5
#define ERX_P0 (1<<0) //ENABLE DATA PIPE 5 - WŁĄCZ STRUMIEŃ DANYCH NR 5
// |SETUP_AW|
#define AW_3BYTE 1 //ADDRES WIDTH = 3 BYTES; SZEROKOŚC ADRESU = 3 BAJTY
#define AW_4BYTE 2 //ADDRES WIDTH = 4 BYTES; SZEROKOŚC ADRESU = 4 BAJTY
#define AW_5BYTE 3 //ADDRES WIDTH = 5 BYTES; SZEROKOŚC ADRESU = 5 BAJTÓW
// |SETUP_RETR|
//IN THE FIRST HALF OH THIS REGISTER (ARD) WE'RE SETTING TIME BEETWEN RETRANSMISSIONS
#define WAIT_4000uS 0xF0 //4000 microseconds - 4000 mikrosekund
#define WAIT_3750uS 0xE0 //3750 microseconds - 3750 mikrosekund
#define WAIT_3500uS 0XD0 //3500 microseconds - 3500 mikrosekund
#define WAIT_3250uS 0xC0 //3250 microseconds - 3250 mikrosekund
#define WAIT_3000uS 0xB0 //3000 microseconds - 3000 mikrosekund
#define WAIT_2750uS 0xA0 //2750 microseconds - 2750 mikrosekund
#define WAIT_2500uS 0x90 //2500 microseconds - 2500 mikrosekund
#define WAIT_2225uS 0x80 //2250 microseconds - 2250 mikrosekund
#define WAIT_2000uS 0x70 //2000 microseconds - 2000 mikrosekund
#define WAIT_1750uS 0x60 //1750 microseconds - 1750 mikrosekund
#define WAIT_1500uS 0x50 //1500 microseconds - 1500 mikrosekund
#define WAIT_1250uS 0x40 //1250 microseconds - 1250 mikrosekund
#define WAIT_1000uS 0x30 //1000 microseconds - 1000 mikrosekund
#define WAIT_750uS 0x20 //750 microseconds - 750 mikrosekund
#define WAIT_500uS 0x10 //500 microseconds - 500 mikrosekund
#define WAIT_250uS 0x00 //250 microseconds - 250 mikrosekund
//IN THE SECOND HALF OF THIS REGISTER (ARC) WE'RE SETTING NUMBER OF RETRANSMISSIONS
#define RETR_15_TIMES 0x0F //15 RETRANSMISSIONS - 15 RETRANSMISJI
#define RETR_14_TIMES 0x0E//14 RETRANSMISSIONS - 14 RETRANSMISJI
#define RETR_13_TIMES 0x0D //13 RETRANSMISSIONS - 13 RETRANSMISJI
#define RETR_12_TIMES 0x0C//12 RETRANSMISSIONS - 12 RETRANSMISJI
#define RETR_11_TIMES 0x0B//11 RETRANSMISSIONS - 11 RETRANSMISJI
#define RETR_10_TIMES 0x0A//10 RETRANSMISSIONS - 10 RETRANSMISJI
#define RETR_9_TIMES 0x09//9 RETRANSMISSIONS - 9 RETRANSMISJI
#define RETR_8_TIMES 0x08 //8 RETRANSMISSIONS - 8 RETRANSMISJI
#define RETR_7_TIMES 0x07 //7 RETRANSMISSIONS - 7 RETRANSMISJI
#define RETR_6_TIMES 0x06 //6 RETRANSMISSIONS - 6 RETRANSMISJI
#define RETR_5_TIMES 0x05 //5 RETRANSMISSIONS - 5 RETRANSMISJI
#define RETR_4_TIMES 0x04 //4 RETRANSMISSIONS - 4 RETRANSMISJI
#define RETR_3_TIMES 0x03 //3 RETRANSMISSIONS - 3 RETRANSMISJI
#define RETR_2_TIMES 0x02 //2 RETRANSMISSIONS - 2 RETRANSMISJI
#define RETR_1_TIME 0x01 //1 RETRANSMISSIONS - 1 RETRANSMISJI
#define RETR_0_TIMES 0X00 //0 RETRANSMISSIONS - 0 RETRANSMISJI
#define RETR_DISABLED 0X00 //0 RETRANSMISSIONS - 0 RETRANSMISJI
// |RF_SETUP|
#define CONT_WAVE 7 //CONTINOUS CARRIER TRANSMIT - CIĄGŁE NADAWANIE NOŚNEJ
#define RF_DR_LOW 5 //RF DATA RATE LOW - MŁODSZY BIT W DWUBITOWYM "SŁOWIE" DO USTAWIANIA PRĘDKOŚCI TRANSMISJI
#define RF_DR_HIGH 3 //RF DATA RATE HIGH - STARSZY BIT W DWUBITOWYM "SŁOWIE" DO USTAWIANIA PRĘDKOŚCI TRANSMISJI
#define PLL_LOCK 4 //FORCE PLL LOCK SIGNAL. ONLY USED IN TEST
#define RF_PWR_18dB ( (0<<1) | (0<<2) ) //SIGNAL POWER - -18dB
#define RF_PWR_12dB ( (0<<1) | (1<<2) ) //SIGNAL POWER - -12dB
#define RF_PWR_6dB ( (1<<1) | (0<<2) ) //SIGNAL POWER - -6dB
#define RF_PWR_0dB ( (1<<1) | (1<<2) ) //SIGNAL POWER - 08dB
#define TRANS_SPEED_2MB ( (0<<RF_DR_LOW) | (1<<RF_DR_HIGH) ) //TRANSMISION SPEED 2MBITS/SECOND
#define TRANS_SPEED_1MB ( (0<<RF_DR_LOW) | (0<<RF_DR_HIGH) ) //TRANSMISION SPEED 1 MBIT/SECOND
#define TRANS_SPEED_250kB (1<<RF_DR_LOW) //TRANSMISION SPEED 250 KBIT/SECOND
// |STATUS|
#define RX_DR 6 //RECIVED DATA READY - ODEBRANE DANE SĄ GOTOWE
#define TX_DS 5 //TRASMITED DATA SENT - WYSŁANO POPRAWNIE DANE
#define MAX_RT 4 //MAXIMUM ACCOUNT OF RETRANSMISION ACHIVED - OSIAGNIĘTO MAKSYMALNĄ ILOSC RETRANSMISJI
#define TX_FULL 0 //TX FIFO IS FULL - BUFOR NADAWCZY JEST PEŁNY
#define RX_PIPE_0 ( (0<<3) | (0<<2) | (0<<1) )
#define RX_PIPE_1 ( (0<<3) | (0<<2) | (1<<1) )
#define RX_PIPE_3 ( (0<<3) | (1<<2) | (1<<1) )
#define RX_PIPE_4 ( (1<<3) | (0<<2) | (0<<1) )
#define RX_PIPE_5 ( (1<<3) | (0<<2) | (1<<1) )
// |OBSERVE_TX|
#define PLOS_CNT 4//FIRST BIT OF LOST PACKET COUNTER
#define ARC_CNT 0//FIRST BIT OF RETRANSMITTED PACKET COUNTER
// |FIFO_STATUS|
#define TX_REUSE 6 //REUSE TX FIFO PAYLOAD - TO SET THIS BIT USE " REUSE_TX_PAYLOAD "; DATA AVALIABLE IN TX FIFO WILL BE SENT
#define FULL_TX 5 //TX FIFO IS FULL FLAG - FLAGA OZNACZAJĄCA ŻE BUFOR NADAWCZY JEST PEŁNY
#define TX_EMPTY 4 //TX IS EMPTY FLAG - FLAGA OZNACZAJĄCA PUSTY BUFOR NADAWCZY
#define RX_FULL 1 //RX IS FULL FLAG - FLAGA OZNACZAJĄCA ŻE BUFOR ODBIORCZY JEST PEŁNY
#define RX_EMPTY 0 //RX IS EMPTY FLAG - FLAGA OZNACZAJĄCA PUSTY BUFOR ODBIORCZY
// |DYNPD|
#define DPL_P5(1<<5)//DYNAMIC PAYLOAD ON DATAPIPE 5
#define DPL_P4(1<<4)//DYNAMIC PAYLOAD ON DATAPIPE 4
#define DPL_P3(1<<3)//DYNAMIC PAYLOAD ON DATAPIPE 3
#define DPL_P2(1<<2)//DYNAMIC PAYLOAD ON DATAPIPE 2
#define DPL_P1(1<<1)//DYNAMIC PAYLOAD ON DATAPIPE 1
#define DPL_P0(1<<0)//DYNAMIC PAYLOAD ON DATAPIPE 0
// |FEATURE|
#define EN_DPL 2//ENABLE DYNAMIC PAYLOAD
#define EN_ACK_PAY 1//ENABLE PAYLOADS WHICH CAN BE SEND WITH ACK PACKET
#define EN_DYN_ACK 0//ENABLE POSSIBILITY OF USING W_TX_PAYLOAD_NO_ACK COMMAND
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''//
//nRF24L01 COMMAND LIST - LISTA KOMEND MODUŁU nRF24L01 //
//,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,//
#define W_ACK_PAYLOAD 0xA8//WRITE PAYLOAD WITH ACK PACKET (USED IN RECEIVER WHEN YOU WANT RETURN ACK WITH SOME SPECIAL PACKET)
#define R_REGISTER 0x00 //READ REGISTER -- ODCZYTAJ REJESTR
#define W_REGISTER 0x20 //WRITE REGISTER -- ZAPISZ DO REJESTRU
#define REGISTER_MASK 0x1F//CONSTANT USED TO MASKING REGISTERS
#define R_RX_PAYLOAD 0x61 //READ RX PAYLOAD -- ODCZYTAJ DANE Z BUFORA ODBIORCZEGO
#define W_TX_PAYLOAD 0xA0 //WRITE TX PAYLOAD -- ZAPISZ DANE DO BUFORA NADAWCZEGO
#define FLUSH_TX 0xE1 //FLUSH TX - WYCZYŚC BUFOR TX
#define FLUSH_RX 0xE2 //FLUSH RX - WYCZYŚC BUFOR RX
#define REUSE_TX_PL 0xE3 //REUSE TX PAYLOAD - WYSLIJ PONOWNIE DANE Z BUFORA TX
#define W_TX_PAYLOAD_NO_ACK 0xB0//SEND PACKET TO ANOTHER NRF WITHOUT ACK
#define NOP 0xFF //NOP - NIC NIE RÓB - PO WYSŁANIEU TEGO BAJTU NRF ZWRACA REJESTR STATUS
#define R_RX_PL_WID 0x60//READ RX PAYLOAD WIDTH
#endif /* NRF24L01_MEMORY_MAP_H_ */[/syntax]
Wszystko niby działa z tym, że czytałem na forach że takie NRF'y w tej tańszej wersji mają zasięg 100 a nawet do 200m na otwartej przestrzeni a w budynkach to nawet przez trzy płyty zbrojone jest zasięg. Moje dzieło daje radę na max 18m na otwartej przestrzeni w słoneczny dzień, biorąc pod uwagę że mieszkam przy lesie z daleka od zabudowań więc nie powinno być problemu z zakłóceniami.
Proszę więc o sugestię w czym tkwi problem tak słabego zasięgu.Statystyki: Napisane przez Sucyn — 19 cze 2016, o 12:15
]]>
