ATNEL tech-forum

Re: Komunikacja nrf24l+ RPI i AVR

2015-09-08T22:30:02+01:00

jaca_76 napisał(a):

(...)

Całkiem niezły kod Kolego
Kolega dobrze kombinuje... 5W mocy 24h/dzień to nie aż tak wiele znowu...

Dzięki za wstawkę kodu do RPi! -gdybym tak miał możliwość nagrodzenia pigułką...

Pozdrawiam! j23 Jarek

Statystyki: Napisane przez j23 — 8 wrz 2015, o 22:30

Re: Komunikacja nrf24l+ RPI i AVR

2015-09-08T21:20:48+01:00

Będąc precyzyjnym: udało się !
Wykorzystałem biblioteki Tinker ze zmianami: usunąłem z main mirf_config a za to po kolei tak jak jest bibliotece na RPi ustawiłem rejestry.
W załaczniku kod w pythonie na RPi
Kod dla AVR:
main.c

[syntax=c]/*
* Transmisja_RS485.c
*
* Created: 2014-12-26 12:19:18
* Author: Jacek
*/

#include
#include
#include
#include
#include
#include
#include
#include
#include "MKUART/mkuart.h"
#include
#include "SSD1306/ssd1306.h"
#include "moje_dane.h"
#include "MIRF/mirf.h"
//#include "NRFL/nrfl_SPI.h"
//#include "NRFL/nRF24L01.h"
#include "MIRF/nRF24L01.h"
#include "I2C_TWI/i2c_twi.h"
volatile int ready_flag=0;
long ldane;
double dane;
char printbuff[6];
char bufor[100];
uint8_t Distance;
uint8_t Thunder_dane;
uint8_t interrupt=0;
uint8_t min_distance=99;
uint8_t config;
uint8_t status;
uint8_t adres;
uint8_t nadaj_buf[5]={1,2,3,4,5};
char buffer_out1[32];
uint8_t TX_adr[5];
uint8_t RX_adr[5];
void show_info(void);
uint8_t ADDRP0[]={0xe7, 0xe7, 0xe7, 0xe7, 0xe7};
uint8_t ADDRP1[]={0xc2, 0xc2, 0xc2, 0xc2, 0xc2};
int main(void)

{

i2cSetBitrate(100);
USART_Init(__UBRR);
mirf_init();
ssd1306_Init(SSD1306_SWITCHCAPVCC, REFRESH_MIN);
sei();
_delay_ms(50);
ssd1306_puts(2,5,"START1.",1,1,0);
ssd1306_display();
mirf_config_register(SETUP_RETR,0xFF);
mirf_config_register(STATUS,(0< mirf_config_register(RF_CH,0x09);
mirf_config_register(RF_SETUP,0x07);
mirf_config_register(EN_AA,0xFF);
mirf_config_register(FEATURE,(1< mirf_config_register(DYNPD,0x3f);
mirf_set_RADDR(ADDRP1);
mirf_set_TADDR(ADDRP1);
mirf_config_register(RX_PW_P0,32);
mirf_set_RADDR1(ADDRP0);
mirf_config_register(EN_RXADDR,3);

_delay_ms(50);
show_info();
while(1){

uart_puts("send..");
_delay_ms(30);
mirf_send(nadaj_buf,5);

}
}

void show_info(){

mirf_read_register(STATUS,RX_adr,1);
uart_puts("STATUS ");
uart_putint(RX_adr[0],16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

mirf_read_register(RX_ADDR_P0,RX_adr,5);
uart_puts("RX_ADDR_P0 ");
for(uint8_t i = 0; i < 5 ; i++ ) //until i is smaller than TX_ADDRES LENGTH copy data from flash to temporary TX_addres buffer
{
uart_putint(RX_adr[i],16);
uart_putc(' ');

}

mirf_read_register(RX_ADDR_P1,RX_adr,5);
uart_puts("RX_ADDR_P1 ");
for(uint8_t i = 0; i < 5 ; i++ ) //until i is smaller than TX_ADDRES LENGTH copy data from flash to temporary TX_addres buffer
{
uart_putint(RX_adr[i],16);
uart_putc(' ');

}

uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

mirf_read_register(TX_ADDR,RX_adr,5);
uart_puts("TX_adr ");
for(uint8_t i = 0; i < 5 ; i++ ) //until i is smaller than TX_ADDRES LENGTH copy data from flash to temporary TX_addres buffer
{
uart_putint(RX_adr[i],16);
uart_putc(' ');

}
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

mirf_read_register(EN_AA,RX_adr,1);
uart_puts("EN_AA ");
uart_putint(RX_adr[0],16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

mirf_read_register(EN_RXADDR,RX_adr,1);
uart_puts("EN_RXADDR ");
uart_putint(RX_adr[0],16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

mirf_read_register(RF_CH,RX_adr,1);
uart_puts("RF_CH ");
uart_putint(RX_adr[0],16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

mirf_read_register(RF_SETUP,RX_adr,1);
uart_puts("RF_SETUP ");
uart_putint(RX_adr[0],16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

mirf_read_register(CONFIG,RX_adr,1);
uart_puts("CONFIG ");
uart_putint(RX_adr[0],16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

mirf_read_register(DYNPD,RX_adr,1);
uart_puts("DYNPD ");
uart_putint(RX_adr[0],16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

mirf_read_register(FEATURE,RX_adr,1);
uart_puts("FEATURE ");
uart_putint(RX_adr[0],16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)
}[/syntax]

mirf.c

[syntax=c]/*
Copyright (c) 2007 Stefan Engelke

Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use, copy,
modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

$Id$
*/

#include "mirf.h"
#include "nRF24L01.h"
#include "spi.h"
#include
#include
#include
#include "../MKUART/mkuart.h"
// Defines for setting the MiRF registers for transmitting or receiving mode
#define TX_POWERUP mirf_config_register(CONFIG, mirf_CONFIG | ( (1<#define RX_POWERUP mirf_config_register(CONFIG, mirf_CONFIG | ( (1<

// Flag which denotes transmitting mode
volatile uint8_t PTX;

void mirf_init()
// Initializes pins ans interrupt to communicate with the MiRF module
// Should be called in the early initializing phase at startup.
{
// Define CSN and CE as Output and set them to default
DDRB |= ((1< mirf_CE_lo;
mirf_CSN_hi;

#if defined(__AVR_ATmega8__)
// Initialize external interrupt 0 (PD2)
MCUCR = ((1< GICR = ((0<#endif // __AVR_ATmega8__

#if defined(__AVR_ATmega168__)
// Initialize external interrupt on port PD6 (PCINT22)
DDRB &= ~(1< PCMSK2 = (1< PCICR = (1<#endif // __AVR_ATmega168__

#if defined(__AVR_ATmega644P__)
// Initialize external interrupt on port PD6 (PCINT22)
EIMSK|=(1<EICRA|=(1<#endif // __AVR_ATmega644P__
// Initialize spi module
spi_init();
}
void mirf_config()
// Sets the important registers in the MiRF module and powers the module
// in receiving mode
{
// Set RF channel
mirf_config_register(RF_CH,mirf_CH);

// Set length of incoming payload
mirf_config_register(RX_PW_P0, mirf_PAYLOAD);

// Start receiver
PTX = 0; // Start in receiving mode
RX_POWERUP; // Power up in receiving mode
mirf_CE_hi; // Listening for pakets
}

void mirf_set_RADDR(uint8_t * adr)
// Sets the receiving address
{
mirf_CE_lo;
mirf_write_register(RX_ADDR_P0,adr,5);
mirf_CE_hi;
}

void mirf_set_RADDR1(uint8_t * adr)
// Sets the receiving address
{
mirf_CE_lo;
mirf_write_register(RX_ADDR_P1,adr,5);
mirf_CE_hi;
}

void mirf_set_TADDR(uint8_t * adr)
// Sets the transmitting address
{
mirf_write_register(TX_ADDR, adr,5);
}

#if defined(__AVR_ATmega8__)
SIGNAL(SIG_INTERRUPT0)
#endif // __AVR_ATmega8__
#if defined(__AVR_ATmega168__)
SIGNAL(SIG_PIN_CHANGE2)
#endif // __AVR_ATmega168__
#if defined(__AVR_ATmega644P__)
ISR(INT2_vect)
#endif // __AVR_ATmega8__
// Interrupt handler
{
uint8_t status;
// If still in transmitting mode then finish transmission
if (PTX) {

// Read MiRF status
mirf_CSN_lo; // Pull down chip select
status = spi_fast_shift(NOP); // Read status register
mirf_CSN_hi; // Pull up chip select

mirf_CE_lo; // Deactivate transreceiver
RX_POWERUP; // Power up in receiving mode
mirf_CE_hi; // Listening for pakets
PTX = 0; // Set to receiving mode

// Reset status register for further interaction
mirf_config_register(STATUS,(1< }
}

extern uint8_t mirf_data_ready()
// Checks if data is available for reading
{
if (PTX) return 0;
uint8_t status;
// Read MiRF status
mirf_CSN_lo; // Pull down chip select
status = spi_fast_shift(NOP); // Read status register
mirf_CSN_hi; // Pull up chip select
return status & (1<}

extern void mirf_get_data(uint8_t * data)
// Reads mirf_PAYLOAD bytes into data array
{
mirf_CSN_lo; // Pull down chip select
spi_fast_shift( R_RX_PAYLOAD ); // Send cmd to read rx payload
spi_transfer_sync(data,data,mirf_PAYLOAD); // Read payload
mirf_CSN_hi; // Pull up chip select
mirf_config_register(STATUS,(1<}

void mirf_config_register(uint8_t reg, uint8_t value)
// Clocks only one byte into the given MiRF register
{
mirf_CSN_lo;
spi_fast_shift(W_REGISTER | (REGISTER_MASK & reg));
spi_fast_shift(value);
mirf_CSN_hi;
}

void mirf_read_register(uint8_t reg, uint8_t * value, uint8_t len)
// Reads an array of bytes from the given start position in the MiRF registers.
{
mirf_CSN_lo;
spi_fast_shift(R_REGISTER | (REGISTER_MASK & reg));
spi_transfer_sync(value,value,len);
mirf_CSN_hi;
}

void mirf_write_register(uint8_t reg, uint8_t * value, uint8_t len)
// Writes an array of bytes into inte the MiRF registers.
{
mirf_CSN_lo;
spi_fast_shift(W_REGISTER | (REGISTER_MASK & reg));
spi_transmit_sync(value,len);
mirf_CSN_hi;
}

void mirf_send(uint8_t * value, uint8_t len)
// Sends a data package to the default address. Be sure to send the correct
// amount of bytes as configured as payload on the receiver.
{
while (PTX) {} // Wait until last paket is send

mirf_CE_lo;

PTX = 1; // Set to transmitter mode
TX_POWERUP; // Power up

mirf_CSN_lo; // Pull down chip select
spi_fast_shift( FLUSH_TX ); // Write cmd to flush tx fifo
mirf_CSN_hi; // Pull up chip select

mirf_CSN_lo; // Pull down chip select
spi_fast_shift( W_TX_PAYLOAD ); // Write cmd to write payload
spi_transmit_sync(value,len); // Write payload
mirf_CSN_hi; // Pull up chip select

mirf_CE_hi; // Start transmission
}[/syntax]

mirf.h

[syntax=c]/*
Copyright (c) 2007 Stefan Engelke

Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use, copy,
modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

$Id$
*/

#ifndef _MIRF_H_
#define _MIRF_H_

#include
// Mirf settings
#define mirf_CH 9
#define mirf_PAYLOAD 5
#define mirf_CONFIG ( (1<
// Pin definitions for chip select and chip enabled of the MiRF module
#define CE PB1
#define CSN PB0

// Definitions for selecting and enabling MiRF module
#define mirf_CSN_hi PORTB |= (1<#define mirf_CSN_lo PORTB &= ~(1<#define mirf_CE_hi PORTB |= (1<#define mirf_CE_lo PORTB &= ~(1<
// Public standart functions
extern void mirf_init();
extern void mirf_config();
extern void mirf_send(uint8_t * value, uint8_t len);
extern void mirf_set_RADDR(uint8_t * adr);
extern void mirf_set_RADDR1(uint8_t * adr);
extern void mirf_set_TADDR(uint8_t * adr);
extern uint8_t mirf_data_ready();
extern void mirf_get_data(uint8_t * data);

// Public extended functions
extern void mirf_config_register(uint8_t reg, uint8_t value);
extern void mirf_read_register(uint8_t reg, uint8_t * value, uint8_t len);
extern void mirf_write_register(uint8_t reg, uint8_t * value, uint8_t len);

#endif /* _MIRF_H_ */[/syntax]

nRF24L01.h

[syntax=c]/*
Copyright (c) 2007 Stefan Engelke

Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use, copy,
modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

$Id$
*/

/* Memory Map */
#define CONFIG 0x00
#define EN_AA 0x01
#define EN_RXADDR 0x02
#define SETUP_AW 0x03
#define SETUP_RETR 0x04
#define RF_CH 0x05
#define RF_SETUP 0x06
#define STATUS 0x07
#define OBSERVE_TX 0x08
#define CD 0x09
#define RX_ADDR_P0 0x0A
#define RX_ADDR_P1 0x0B
#define RX_ADDR_P2 0x0C
#define RX_ADDR_P3 0x0D
#define RX_ADDR_P4 0x0E
#define RX_ADDR_P5 0x0F
#define TX_ADDR 0x10
#define RX_PW_P0 0x11
#define RX_PW_P1 0x12
#define RX_PW_P2 0x13
#define RX_PW_P3 0x14
#define RX_PW_P4 0x15
#define RX_PW_P5 0x16
#define FIFO_STATUS 0x17
#define DYNPD 0x1C //DYNAMIC PAYLOAD WIDTH - DYNAMICZNA SZEROKOŚC RAMKI DANYCH
#define FEATURE 0x1D //FEATURE REGISTER - REJESTR Z FICZERAMI
/* Bit Mnemonics */
#define MASK_RX_DR 6
#define MASK_TX_DS 5
#define MASK_MAX_RT 4
#define EN_CRC 3
#define CRCO 2
#define PWR_UP 1
#define PRIM_RX 0
#define ENAA_P5 5
#define ENAA_P4 4
#define ENAA_P3 3
#define ENAA_P2 2
#define ENAA_P1 1
#define ENAA_P0 0
#define ERX_P5 5
#define ERX_P4 4
#define ERX_P3 3
#define ERX_P2 2
#define ERX_P1 1
#define ERX_P0 0
#define AW 0
#define ARD 4
#define ARC 0
#define PLL_LOCK 4
#define RF_DR 3
#define RF_PWR 1
#define LNA_HCURR 0
#define RX_DR 6
#define TX_DS 5
#define MAX_RT 4
#define RX_P_NO 1
#define TX_FULL 0
#define PLOS_CNT 4
#define ARC_CNT 0
#define TX_REUSE 6
#define FIFO_FULL 5
#define TX_EMPTY 4
#define RX_FULL 1
#define RX_EMPTY 0
#define EN_DPL 2
/* Instruction Mnemonics */
#define R_REGISTER 0x00
#define W_REGISTER 0x20
#define REGISTER_MASK 0x1F
#define R_RX_PAYLOAD 0x61
#define W_TX_PAYLOAD 0xA0
#define FLUSH_TX 0xE1
#define FLUSH_RX 0xE2
#define REUSE_TX_PL 0xE3
#define NOP 0xFF[/syntax]

Statystyki: Napisane przez jaca_76 — 8 wrz 2015, o 21:20

Re: Komunikacja nrf24l+ RPI i AVR

2015-09-06T09:30:38+01:00

Hmm
Więc potrafię przesłać dane pomiędzy AVR a AVR jak i pomiędzy RPI a RPI, oczywiście jak widać potrafię oczytać i ustawiać rejestry NRFa na obydwóch urządzeniach.
Niestety próba wysłania danych z AVR do RPI nie działa. Adresy ustawiłem jak na działającym przykładzie dla RPi.
Program się nie zatrzymuje w żadnym miejscu, według mnie gdzieś jest błąd w konfiguracji lub kolejności wykonywanych ustawień . Ja nie potrafię go znaleźć .

Sprawdziłem też co się dzieje ze rejestrem status, najpierw ma ustawienia domyślne a po chwili ustawia bit MAX_RT czyli osiągnął maksymalną wartość prób wysłania .

Statystyki: Napisane przez jaca_76 — 6 wrz 2015, o 09:30

Re: Komunikacja nrf24l+ RPI i AVR

2015-09-06T08:54:52+01:00

kicajek napisał(a):

jest mało precyzyjnym określeniem problemu przed którym stanąłeś.
Piszę to niejako dla Twojego dobra, bo tylko precyzyjne określenie problemu zachęca do pomocy; dwa długaśne kody troszkę straszą.

Ja tylko mogę dodać, że to bardzo mądra i cenna podpowiedź. Nic więcej dodać nic ująć.

Statystyki: Napisane przez mirekk36 — 6 wrz 2015, o 08:54

Re: Komunikacja nrf24l+ RPI i AVR

2015-09-06T07:55:03+01:00

Witam
Ja co prawda nie wiem, ale dla kolegów którzy chcieliby pomóc to:

jaca_76 napisał(a):

... potrafię skomunikować RPi z RPi jak i AVR z AVR ale do RPi z AVR to nie mam już pomysłów...

Statystyki: Napisane przez kicajek — 6 wrz 2015, o 07:55

Komunikacja nrf24l+ RPI i AVR

2015-09-05T23:35:08+01:00

Witam
Próbuję od kilku dni próbuje uruchomić komunikację pomiędzy Rpi a AVR za pomocą NRF24L+.
Obecnie używam biblioteki z tego forum ale testowałem także z Tinker.
Dodam że potrafię skomunikować RPi z RPi jak i AVR z AVR ale do RPi z AVR to nie mam już pomysłów.
Bardzo proszę o pomoc.

Tak wygląda RPi jako odbiornik:

STATUS = 0x0e RX_DR=0 TX_DS=0 MAX_RT=0 RX_P_NO=7 TX_FULL=0
RX_ADDR_P0-1 = 0x4156525452 0x4156525243
RX_ADDR_P2-5 = 0xc3 0xc4 0xc5 0xc6
TX_ADDR = 0x4156525452
RX_PW_P0-6 = 0x20 0x20 0x00 0x00 0x00 0x00
EN_AA = 0x3f
EN_RXADDR = 0x03
RF_CH = 0x09
RF_SETUP = 0x07
CONFIG = 0x0b
DYNPD/FEATURE = 0x3f 0x04
Data Rate = 1MBPS
Model = nRF24l01+
CRC Length = 8 bits
PA Power = PA_HIGH

A tak AVR jako nadanik:
RX_ADDR_P0 41 56 52 52 43 RX_ADDR_P1 43 43 52 54 52
TX_adr 41 56 52 52 43
EN_AA 3f
EN_RXADDR 3
RF_CH 9
RF_SETUP 7
CONFIG a
DYNPD 3f
FEATURE 4

Kod dla AVR (main.c):
[syntax=c]/*
* Transmisja_RS485.c
*
* Created: 2014-12-26 12:19:18
* Author: Jacek
*/

#include
#include
#include
#include
#include
#include
#include
#include
#include "MKUART/mkuart.h"
#include
#include "SSD1306/ssd1306.h"
#include "moje_dane.h"
#include "NRFL/nrfl_SPI.h"
#include "NRFL/nRF24L01.h"
#include "NRFL/nRF24L01_memory_map.h"
#include "I2C_TWI/i2c_twi.h"
volatile int ready_flag=0;
long ldane;
double dane;
char printbuff[6];
char bufor[100];
uint8_t Distance;
uint8_t Thunder_dane;
uint8_t interrupt=0;
uint8_t min_distance=99;
uint8_t config;
uint8_t status;
uint8_t adres;
void majne_funkcjon ( void * nRF_RX_buff , uint8_t len );
char buffer_out1[32];
char TX_adr[5];
char RX_adr[5];
void show_info(void);
int main(void)

{
//SPI_Init();
i2cSetBitrate(100);
USART_Init(__UBRR);
ssd1306_Init(SSD1306_SWITCHCAPVCC, REFRESH_MIN);
sei();
nRF_init();
_delay_ms(55);
nRF_TX_Power_Up();
_delay_ms(55);
register_nRF_RX_Event_Callback(majne_funkcjon);
status= nRF_Read_One_Byte_From_Register(CONFIG);
ssd1306_put_int(75,55,status,1,1,0);
_delay_ms(10);
ssd1306_display();
status=0;
show_info();
while(1)
{

nRF_SendDataToAir( ( uint8_t * ) "AAAAAAAAA" );
_delay_ms(300);

}

}

void majne_funkcjon ( void * nRF_RX_buff, uint8_t len )
{
ssd1306_puts(5,20,"Odebrano:",1,1,0);
ssd1306_put_int(60,20,len,1,1,0);
ssd1306_display();

}

void show_info(){
nRF_Read_Register(RX_ADDR_P0,RX_adr,5);
uart_puts("RX_ADDR_P0 ");
for(uint8_t i = 0; i < 5 ; i++ ) //until i is smaller than TX_ADDRES LENGTH copy data from flash to temporary TX_addres buffer
{
uart_putint(RX_adr[i],16);
uart_putc(' ');

}

nRF_Read_Register(RX_ADDR_P1,RX_adr,5);
uart_puts("RX_ADDR_P1 ");
for(uint8_t i = 0; i < 5 ; i++ ) //until i is smaller than TX_ADDRES LENGTH copy data from flash to temporary TX_addres buffer
{
uart_putint(RX_adr[i],16);
uart_putc(' ');

}

uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

nRF_Read_Register(TX_ADDR,RX_adr,5);
uart_puts("TX_adr ");
for(uint8_t i = 0; i < 5 ; i++ ) //until i is smaller than TX_ADDRES LENGTH copy data from flash to temporary TX_addres buffer
{
uart_putint(RX_adr[i],16);
uart_putc(' ');

}
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

status= nRF_Read_One_Byte_From_Register(EN_AA);
uart_puts("EN_AA ");
uart_putint(status,16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

status= nRF_Read_One_Byte_From_Register(EN_RXADDR);
uart_puts("EN_RXADDR ");
uart_putint(status,16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

status= nRF_Read_One_Byte_From_Register(RF_CH);
uart_puts("RF_CH ");
uart_putint(status,16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

status= nRF_Read_One_Byte_From_Register(RF_SETUP);
uart_puts("RF_SETUP ");
uart_putint(status,16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

status= nRF_Read_One_Byte_From_Register(CONFIG);
uart_puts("CONFIG ");
uart_putint(status,16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

status= nRF_Read_One_Byte_From_Register(DYNPD);
uart_puts("DYNPD ");
uart_putint(status,16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)

status= nRF_Read_One_Byte_From_Register(FEATURE);
uart_puts("FEATURE ");
uart_putint(status,16);
uart_putc('\r');// wyślij znak CR (enter)
uart_putc('\n');// wyślij znak LF (nowa linia)
}[/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
#include
#include
#include
#include

#include "nrfl_SPI.h"
#include "nRF24L01.h"
#include "nRF24L01_memory_map.h"
#include "../SSD1306/ssd1306.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
//__________________________________________________________________________________________________________________

//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// deklaracja moich zmiennych
//..................................................................................................................
uint64_t P_addres[2]={0x4156525452,0x4156525243};

//__________________________________________________________________________________________________________________

//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// 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< 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< nRF_Clear_RX(); //clear RX_FIFO
nRF_Config_Register(STATUS, (1< 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_nrfl_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_Config_Register( CONFIG, nRF24L01_CONFIG); //Write interrupt masks nRF_CONFIG to CONGIG register of nRF //Clear TX FIFO
nRF_Set_Retransmission_Time_And_Ammount(WAIT_4000uS , RETR_15_TIMES ); //set time between retransmissions and ammount of retranssmisions
nRF_Set_Channel(9); //Set channel number
nRF_Config_Register( RX_PW_P0, 32);
nRF_Config_Register( RX_PW_P1, 32);
nRF_Set_Data_Speed_And_Reciver_Power(TRANS_SPEED_1MB, RF_PWR_0dB ); //Set transmision speed and reciver power
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_Active_DataPipe_And_ACK ( ERX_P1, ON, ACK_ON );
nRF_Set_Active_DataPipe_And_ACK ( ERX_P0, ON, ACK_ON );
// nRF_Set_Dynamic_Payload_State_On_Data_Pipe( DPL_P1 , ON ); //Enable dynamic payload of choosen datapipe
// nRF_Set_Dynamic_Payload_State_On_Data_Pipe( DPL_P0 , ON );
nRF_Config_Register( DYNPD, 63);
nRF_SET_Reciver_Addres(RX_ADDR_P0, PSTR("AVRRC"));
nRF_SET_Transmitter_Adres(PSTR("AVRRC")); //set transmitter addres
nRF_SET_Reciver_Addres(RX_ADDR_P1, PSTR("CCRTR")); //set reciving addres for datapipe0 !zmiana na takie same adresy1

//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_Clear_RX(); //Clear RX FIFO
nRF_Clear_TX();

RX_flag = 1; //Clear RX flag
TX_flag = 0; //Clear TX flag

nRF_Config_Register(STATUS, (1<
}

//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// 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< }

//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// 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< else if ( one_or_two_bytes == TWO_BYTES ) config |= (1< else config &= ~(1<
if (on_or_off == ON) config |= (1< else if ( on_or_off == OFF ) config &= ~(1<
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< config |= (1<
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< 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< 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< {
CE_LOW; //make CE low
nRF_Clear_TX(); //clear TX FIFO
nRF_Config_Register(STATUS, data1 | (1< return; //return
}
//else if was send or funcion is used for the first time
else if ( ( data1 & (1<
else TX_flag = 1;

first_time = 1; //first_time equals to 1
nRF_Config_Register(STATUS, data1 | (1<
#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)|0x01)); //write to RF_SETUP register transmision speed and and receiver power DODAŁEM |0x01
}

//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// 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< //set bit EN_DPL
if (on_off == OFF) feature &= ~(1< //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)
{
EIMSK|=(1< EICRA|=(1< }

//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// 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(INT2_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< {
status |= (1< nRF_Config_Register(STATUS, status); //save status variable in STATUS register
RX_flag = 1; //RX flag equals to 1
}

if ( status & (1< {
status |= (1< 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< {
status |= (1< 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

//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// moja funkcja openWritingPipe
//...................................................................................................................................................
//Note that the NRF24L01(+)
// expects it LSB first.
void openWritingPipe(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++);
}
nRF_Write_Register(RX_ADDR_P0, (uint8_t *) TX_addres, 5);
nRF_Write_Register(TX_ADDR, (uint8_t *) TX_addres, 5);
}[/syntax]

Statystyki: Napisane przez jaca_76 — 5 wrz 2015, o 23:35