Salve ragazzi,
per caso c'è qualcuno che ha un po di confidenza con il modulo nrf24l01?
sto facendo un piccolo progetto con Arduino alcuni sensori ed il cardiofrequenzimetro della polar Wind che come è spiegato bene in questo articolo è possibile leggere i valori del cardio direttamente da arduino con modulo nrf24
sono riuscito a far riconoscere il cardio al mio arduino collegato al modulo RF24 ma ora vorrei mandare il valore letto da arduino ad un altro arduino collegato a sua volta ad un altro modulo rf24 ma purtroppo ho un pò di problemi ad interpretare il codice usato per leggere i valori del cardio e quindi ritrasmettere il tutto
il codice che utilizzo io ed è anche quello utilizzato nell articolo è questo
#include <SPI.h>
#include "nRF24L01.h"
const int chipSelectNotPin = 53;
const int chipEnablePin = 9;
const int addressSize = 2;
const int packetLength = 28 - addressSize;
const int sensorPin = 2; // the number of the LED pin
int pulseState = LOW; // pulseState used to set off the sensor
long previousMillis = 0; // will store last time pulse signal was changed
long pulseIntervalOn = 1;
long pulseIntervalOff = 1000;
void setup(){
Serial.begin(115200);
// initalize the data ready and chip select pins:
pinMode(chipEnablePin, OUTPUT);
pinMode(chipSelectNotPin, OUTPUT);
pinMode(sensorPin, OUTPUT);
// start the SPI library:
SPI.setDataMode(SPI_MODE0);
SPI.setBitOrder(MSBFIRST);
SPI.setClockDivider(SPI_2XCLOCK_MASK);
SPI.begin();
Serial.println("Configuring nRF...");
// 1Mbps
byte lv_rf_setup = 0x0;
write_reg(RF_SETUP,&lv_rf_setup,1);
//Freq channel
byte lv_rf_ch = 73;
write_reg(RF_CH, &lv_rf_ch, 1);
//set address length
byte lv_setup_aw = 0b00;
switch (addressSize){
case 2:
lv_setup_aw = 0b00;
break;
case 3:
lv_setup_aw = 0b01;
break;
case 4:
lv_setup_aw = 0b10;
break;
case 5:
lv_setup_aw = 0b11;
break;
}
write_reg(SETUP_AW, &lv_setup_aw, 1);
//Disable autoretransmit
byte lv_setup_retr = 0x0;
write_reg(SETUP_RETR, &lv_setup_retr, 1);
//Disable Enchanced ShockBurst
byte lv_en_aa = 0x0;
write_reg(EN_AA, &lv_en_aa, 1);
//Disable Pipe 1;
byte lv_rx_pw_p1 = 0x0;
write_reg(RX_PW_P1, &lv_rx_pw_p1, 1);
//Set data length in pipe 0;
byte lv_rx_pw_p0 = packetLength;
write_reg(RX_PW_P0, &lv_rx_pw_p0, 1);
//Set address
byte lv_addr[5];
lv_addr[1] = 0xC6;
lv_addr[0] = 0xA1;
// lv_addr[4] = 0xC6;
// lv_addr[3] = 0xA1;
// lv_addr[2] = 0x01;
// lv_addr[1] = 0xF8;
// lv_addr[0] = 0x11;
write_reg(RX_ADDR_P0, &lv_addr[0], addressSize);
//Flush RX buffer
flush_rx();
//Enable 16bit CRC and power up in RX mode
byte lv_config = (1<<PWR_UP) | (1<<PRIM_RX) | (1<<EN_CRC) | (1<<CRCO);
write_reg(CONFIG, &lv_config, 1);
delay(50);
//Enable nRF
CE_HIGH();
delay(10);
}
void loop(){
byte nrf_status = get_nfr_status();
if ((nrf_status & (1<<RX_DR)) != 0) {
write_reg(STATUS, &nrf_status, (1<<RX_DR));
//1. Read payload
byte ff_status = read_reg(FIFO_STATUS);
while (~ff_status & (1<<RX_EMPTY)){
byte buf[packetLength];
memset(buf,0,sizeof(buf));
read_rx((byte*)(&buf),packetLength);
//8th byte - current HR
Serial.print("HR:");
if (buf[5] < 100) Serial.print(" ");
Serial.print(buf[7-addressSize], DEC);
// Last byte - Avarage HR
Serial.print(" AvgHR:");
if (buf[packetLength-1] < 100) Serial.print(" ");
Serial.print(buf[packetLength-1], DEC);
//Raw packet
Serial.print(" Raw data: ");
for (int i=0; i<packetLength; i++){
if (buf[i] < 0x10) Serial.print("0");
Serial.print(buf[i], HEX);
Serial.print(" ");
}
Serial.println();
ff_status = read_reg(FIFO_STATUS);
}
}
//Send pulse to trigger sensor
unsigned long currentMillis = millis();
if ((pulseState == LOW) && (currentMillis - previousMillis > pulseIntervalOff)) {
previousMillis = currentMillis;
pulseState = HIGH;
digitalWrite(sensorPin, pulseState);
}
if ((pulseState == HIGH) && (currentMillis - previousMillis > pulseIntervalOn)) {
previousMillis = currentMillis;
pulseState = LOW;
digitalWrite(sensorPin, pulseState);
}
}
byte read_reg(byte reg){
byte lv_reg;
CSN_LOW();
SPI.transfer(R_REGISTER | (REGISTER_MASK & reg));
lv_reg = SPI.transfer(NOP);
CSN_HIGH();
return lv_reg;
}
void write_reg(byte reg, byte* value, byte len){
CSN_LOW();
SPI.transfer(W_REGISTER | (REGISTER_MASK & reg));
for (int i = 0; i < len; i++){
SPI.transfer(value[i]);
}
CSN_HIGH();
}
byte get_nfr_status(){
byte lv_status = 0x0;
CSN_LOW();
lv_status = SPI.transfer(NOP);
CSN_HIGH();
return lv_status;
}
void CE_HIGH(){
digitalWrite(chipEnablePin, HIGH);
}
void CE_LOW(){
digitalWrite(chipEnablePin, LOW);
}
void CSN_HIGH(){
digitalWrite(chipSelectNotPin, HIGH);
}
void CSN_LOW(){
digitalWrite(chipSelectNotPin, LOW);
}
void read_rx(byte *rx_buf, int rx_size){
CSN_LOW();
SPI.transfer(R_RX_PAYLOAD);
for (int i=0; i<rx_size; i++){
rx_buf[i] = SPI.transfer(NOP);
}
CSN_HIGH();
}
void flush_rx(){
CSN_LOW();
SPI.transfer(FLUSH_RX);
CSN_HIGH();
}
io invece per far comunicare i miei arduino utilizzo un codice simile a quello che viene mostrato negli esempi delle librerie nrf24 tipo Gettingstarted o pingpair che utilizzano altre dichiarazioni per indicare address, channel etc....
