http://blog.nettigo.pl/post/100531579628/modem-radiowy-nrf24l01-programowanie udało mi się przesyłać dane. Ostatecznie chcę komunikować się między dwoma AVRami. Teraz chcę aby odbiornik był dalej na Arduino, a nadajnik chcę uruchomić na ATMega8. Korzystam z tego poradnika dla AVRów: http://gizmosnack.blogspot.com/2013/04/tutorial-nrf24l01-and-avr.html. Ustawiłem chyba wszystkie parametry przesyłu na takie same po stronie AVRa i Arduino, jednak transmisja nie chce dojść do skutku. I moja prośba jest taka czy ktoś by mi pomógł rozwiązać ten problem. Może ma ktoś gotowy program na Atmegę8. Sporo szukałem w sieci, jednak nie znalazłem odpowiadających mi informacji.
W załączniku znajduje się pełny kod programu AVRa. Projekt w Atmel Studio.
Program dla Atmegi8:
[syntax=c]#include <avr/io.h>
#include <stdio.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include "nRF24L01.h"
#include "uart.h"
void InitSPI(void)
{
DDRB |= (1<<DDB5) | (1<<DDB3) | (1<<DDB2) |(1<<DDB1);//ustawienie wyjść
SPCR |= (1<<SPE) | (1<<MSTR);//włączanie SPI, jako master
SETBIT(PORTB, 2);//CSN IR_High to start with, nothing to be sent to the nRF yet!
CLEARBIT(PORTB, 1);//CE low to start with, nothing to send/receive yet!
}
char WriteByteSPI(unsigned char cData)
{
SPDR = cData;
while(!(SPSR & (1<<SPIF)));//odczekanie na przesłanie danych
return SPDR;
}
uint8_t GetReg(uint8_t reg)
{
_delay_us(10);//make sure last command was a while ago...
CLEARBIT(PORTB, 2); //CSN low - nRF starts to listen for command
_delay_us(10);
WriteByteSPI(R_REGISTER + reg); //R_Register = set the nRF to reading mode, "reg" = this registry will be read back
_delay_us(10);
reg = WriteByteSPI(NOP);//Send NOP (dummy byte) once to receive back the first byte in the "reg" register
_delay_us(10);
SETBIT(PORTB, 2);//CSN Hi - nRF goes back to doing nothing
return reg;
}
uint8_t *WriteToNrf(uint8_t ReadWrite, uint8_t reg, uint8_t *val, uint8_t antVal)
{
//"ReadWrite" ("W" or "R"), "reg" (the register), "*val" (an array with the package) & "antVal" (number of integers in the package)
if (ReadWrite == W) //if "W" then you want to write to the nRF (read mode "R" == 0x00, so skipping that one)
{
reg = W_REGISTER + reg; // Add the "write" bit to the "reg"
}
//Create an array to be returned at the end
//Static uint8_t is needed to be able to return an array (notice the "*" to the left of the function: *WriteToNrf())
static uint8_t ret[32];
_delay_us(10);//make sure last command was a while ago...
CLEARBIT(PORTB, 2);//CSN low - nRF starts to listen for command
_delay_us(10);
WriteByteSPI(reg);//set the nRF to Write or read mode of "reg"
_delay_us(10);
for(int i=0; i<antVal; i++)
{
if (ReadWrite == R && reg != W_TX_PAYLOAD) //Did you want to read a registry?
{
ret[i]=WriteByteSPI(NOP);//Send dummy bytes to read out the data
_delay_us(10);
}
else
{
WriteByteSPI(val[i]);//Send the commands to the nRF once at a time
_delay_us(10);
}
}
SETBIT(PORTB, 2);//CSN Hi - nRF goes back to doing nothing
return ret;//return the array
}
void nrf24L01_init(void)
{
_delay_ms(100); //allow radio to reach power down if shut down
uint8_t val[5]; //An array av integers to send to the *WriteToNrf function
//EN_AA - (enable auto-acknowledgments) - Transmitter gets automatic response from receiver when successful transmission!
//Only works if Transmitter has identical RF_Adress on its channel ex: RX_ADDR_P0 = TX_ADDR
val[0] = 0x01;//set value
WriteToNrf(W, EN_AA, val, 1);//W=write mode, EN_AA=register to write to, val=data to write, 1=number of data bytes
val[0] = 0x2F;//0b0010 1111 "2" sets it up to 750uS delay between every retry (at least 500us at 250kbps and if payload >5bytes in 1Mbps,
//and if payload >15byte in 2Mbps) "F" is number of retries (1-15, now 15)
WriteToNrf(W, SETUP_RETR, val, 1);
//Choose number of enabled data pipes (1-5)
val[0] = 0x01;
WriteToNrf(W, EN_RXADDR, val, 1); //enable data pipe 0
//RF_Adress width setup (how many bytes is the receiver address, the more the merrier 1-5)
val[0] = 0x03;//0b0000 0011 = 5 bytes RF_Adres
WriteToNrf(W, SETUP_AW, val, 1);
//RF channel setup - choose frequency 2,400-2,527GHz 1MHz/step
val[0] = 0x01;//0b0000 0001 = 2,401GHz (same on TX and RX)
WriteToNrf(W, RF_CH, val, 1);
//RF setup - choose power mode and data speed
val[0] = 0x07;//0000 0111 bit 3="0" 1Mbps=longer range, bit 2-1 power mode ("11"=-0dB ; "00"=-18dB)
WriteToNrf(W, RF_SETUP, val, 1);
//RX RF_Adress setup 5 byte - Set Receiver address (set RX_ADDR_P0 = TX_ADDR if EN_AA is enabled!!!)
for(uint8_t i=0; i<5; i++)
{
val[i] = 0x12;//0x12 x 5 to get a long and secure address
}
WriteToNrf(W, RX_ADDR_P0, val, 5); //since we choose pipe 0 on EN_RXADDR we give this address to that channel
//Here you can give different addresses to different channels(if they are enabled in EN_RXADDR) to listen on several different transmitters)
//TX RF_Adress setup 5 byte - Set Transmitter address (not used in a receiver but can be set anyway)
for(uint8_t i=0; i<5; i++)
{
val[i] = 0x12;//0x12 x 5 - same on the Receiver chip and the RX-RF_Address above if EN_AA is enabled!
}
WriteToNrf(W, TX_ADDR, val, 5);
//Payload Width Setup - 1-32byte (how many bytes to send per transmission)
val[0] = 32;//Send 32 bytes per package this time (same on receiver and transmitter)
WriteToNrf(W, RX_PW_P0, val, 1);
//CONFIG reg setup - Now it's time to boot up the nrf and choose if it's suppose to be a transmitter or receiver
val[0] = 0x1E;//0b0001 1110 - bit 0="0":transmitter bit 0="1":receiver, bit 1="1":power up,
//bit 4="1":mask_Max_RT i.e. IRQ-interrupt is not triggered if transmission failed.
WriteToNrf(W, CONFIG, val, 1);
//device need 1.5ms to reach standby mode (CE=low)
_delay_ms(100);
}
void transmit_payload(uint8_t * W_buff)
{
WriteToNrf(R, FLUSH_TX, W_buff, 0);//Sends 0xE1 to flush the registry from old data! W_buff[] is only there because an array has to be called with an array...
WriteToNrf(R, W_TX_PAYLOAD, W_buff, 5); //Sends the data in W_buff to the nrf
//Why Flush_TX and W_TX_Payload is sent with an "R" instead of "W" is because they are on the highest byte-level in the nRF (see datasheet below)!
//sei(); //Enable global interrupt (if interrupt is used)
_delay_ms(10);//needs a 10ms delay to work after loading the nrf with the payload for some reason
SETBIT(PORTB, 1);//CE high - transmit the data!
_delay_us(20);//delay at least 10us!
CLEARBIT(PORTB, 1);//CE low - stop transmitting
_delay_ms(10);//long delay again before proceeding.
}
int main(void)
{
uart_init();
InitSPI();
nrf24L01_init();
uint8_t W_buffer[32];
for (int i=0; i<32; i++)
{
W_buffer[i]=0x93;
}
while (1)
{
uart_putc(GetReg(STATUS));
transmit_payload(W_buffer);
_delay_ms(1000);
}
}[/syntax]
Program Arduino:
[syntax=cpp]#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(9, 10);
byte rxAddr[5];
void setup() {
for(int i=0; i<5; i++)
{
rxAddr[i] = 0x12;
}
while (!Serial);
Serial.begin(9600);
radio.begin();
radio.setChannel(1);
radio.openReadingPipe(0, rxAddr);
radio.startListening();
}
void loop() {
if (radio.available())
{
char text[32] = {0};
radio.read(&text, sizeof(text));
Serial.println(text);
}
}[/syntax]Statystyki: Napisane przez fgfd — 13 cze 2016, o 19:17
]]>