Home
Accesso / Registrazione
 di 

Arduino e nRF24L01+

5 risposte [Ultimo post]
ritratto di remigio
Offline
Ultima visita:
17 ore 36 min fa
Utente dal: 06/02/2014
Messaggi: 1
Utente PREMIUM

Ciao a tutti,

 

sono nuovo del forum e, oltre a salutare tutti i partecipanti, scrivo per chiedere qualche drittta sull'interfacciamento di Arduino (e dell'ATMEGA328 in generale) con il modulo wireless nRF24L01. Preciso che non è da molto che "lavoro" con l'elettronica ma è un mondo che mi affascina e sto sperimentando.

Tornando al mio problemino, ho una scheda Arduino Uno e ho costruito una versione standalone con il solo ATMEGA328 per fare esperimenti di comunicazione wireless; ho collegato due moduli nRF24 alle due schede, ho scaricato la libreria RF24 e caricato lo sketch "Getting started" su entrambi i microcontrollori. Quello che succede è che l'arduino "ufficiale" si mette regolarmente in ascolto in attesa del payload mentre la scheda artigianale riceve dei falsi input che vedo sulla seriale e di conseguenza invia una risposta; se metto questa scheda in modalità TX la scheda invia il pacchetto e ovviamente riceve una risposta ma assolutamente fittizia visto che l'altra scheda (Arduino) non riceve nulla. Penso si tratti di qualche interferenza sul circuito artigianale ma non sono riuscito a capire dove intervenire. Qualcuno sa darmi un suggerimento su cosa indagare?

 

Ringrazio in anticipo.

ritratto di Giorgio B.
Offline
Titolo: User++
Utente++
Ultima visita:
20 ore 25 min fa
Utente dal: 06/02/2013
Messaggi: 80
Utente PREMIUM
Qualche foto? Uno schema per

Qualche foto?
Uno schema per vedere i collegamenti?
Se carichi altri sketch che fa?
Con LED blink funziona?

ritratto di luisella
Offline
Titolo: User
Utente
Ultima visita:
6 settimane 4 giorni fa
Utente dal: 23/07/2014
Messaggi: 3
sono anch'io nuova del forum

sono anch'io nuova del forum e saluto tutti.
ho un problema simile: ho una scheda Arduino DUE e una MICRO
ho collegato le due schede ai due moduli RF24L01 e all'inizio mi sembrava funionare, perché con l'esempio GettingStarted e impostando un modulo come TX e l'altro come RX vedevo che il modulo RX riceveva numeri sempre diversi, ma non corrispondenti ai millisecondi inviati dal TX, dei numeri molto + grandi (non so quale decodifica bisogna usare), ma poi ad un certo punto non mi ha + funzionato, adesso infatti il modulo RX riceve sempre lo stesso numero enorme e sempre lo stesso, che corrisponde all'incirca a 255 alla quarta potenza.
ho provato anche ad utilizzare i pin mosi, miso e sck dell'SCPI su Arduino DUE, ma non cambia nulla.
Invece su Arduino MICRO bisogna usare i pin mosi, miso e sck e non i pin 11, 12 e 13
non so + cosa fare
qualcuno ha qualche idea in proposito, avete forse testato con Arduino Micro ?
grazie
luisella

ritratto di Piero Boccadoro
Offline
Titolo: Moderator
Moderatore
Ultima visita:
8 ore 48 min fa
Utente dal: 28/06/2011
Messaggi: 900
Utente PREMIUM
Se ci dici "non so quale

Se ci dici "non so quale decodifica bisogna usare" mi viene da dedurre che tu stia ricevendo semplicemente dei dati grezzi.
Per capire meglio che dati dovresti ricevere, dovremmo vedere il codice.
Questo numero cresce sempre? Quanto velocemente?

Più informazioni riesce a dare (e non vale solo per te) più possiamo farci un'idea chiara di che cosa sta succedendo.

ritratto di luisella
Offline
Titolo: User
Utente
Ultima visita:
6 settimane 4 giorni fa
Utente dal: 23/07/2014
Messaggi: 3
il codice è quello che ho

il codice è quello che ho copiato dagli esempi forniti dalle librerie RF24 sul sito ManiacBug, il GettingStarted, che invio :

/*
Copyright (C) 2011 J. Coliz

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation.
*/

/**
* Example for Getting Started with nRF24L01+ radios.
*
* This is an example of how to use the RF24 class. Write this sketch to two
* different nodes. Put one of the nodes into 'transmit' mode by connecting
* with the serial monitor and sending a 'T'. The ping node sends the current
* time to the pong node, which responds by sending the value back. The ping
* node can then see how long the whole cycle took.
*/

#include
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

//
// Hardware configuration
//

// Set up nRF24L01 radio on SPI bus plus pins 9 & 10

RF24 radio(9,10);

//
// Topology
//

// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };

//
// Role management
//
// Set up role. This sketch uses the same software for all the nodes
// in this system. Doing so greatly simplifies testing.
//

// The various roles supported by this sketch
typedef enum { role_ping_out = 1, role_pong_back } role_e;

// The debug-friendly names of those roles
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};

// The role of the current running sketch
role_e role = role_pong_back;

void setup(void)
{
//
// Print preamble
//

Serial.begin(57600);
printf_begin();
printf("\n\rRF24/examples/GettingStarted/\n\r");
printf("ROLE: %s\n\r",role_friendly_name[role]);
printf("*** PRESS 'T' to begin transmitting to the other node\n\r");

//
// Setup and configure rf radio
//

radio.begin();

// optionally, increase the delay between retries & # of retries
radio.setRetries(15,15);

// optionally, reduce the payload size. seems to
// improve reliability
//radio.setPayloadSize(8);

//
// Open pipes to other nodes for communication
//

// This simple sketch opens two pipes for these two nodes to communicate
// back and forth.
// Open 'our' pipe for writing
// Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading)

//if ( role == role_ping_out )
{
//radio.openWritingPipe(pipes[0]);
radio.openReadingPipe(1,pipes[1]);
}
//else
{
//radio.openWritingPipe(pipes[1]);
//radio.openReadingPipe(1,pipes[0]);
}

//
// Start listening
//

radio.startListening();

//
// Dump the configuration of the rf unit for debugging
//

radio.printDetails();
}

void loop(void)
{
//
// Ping out role. Repeatedly send the current time
//

if (role == role_ping_out)
{
// First, stop listening so we can talk.
radio.stopListening();

// Take the time, and send it. This will block until complete
unsigned long time = millis();
printf("Now sending %lu...",time);
bool ok = radio.write( &time, sizeof(unsigned long) );

if (ok)
printf("ok...");
else
printf("failed.\n\r");

// Now, continue listening
radio.startListening();

// Wait here until we get a response, or timeout (250ms)
unsigned long started_waiting_at = millis();
bool timeout = false;
while ( ! radio.available() && ! timeout )
if (millis() - started_waiting_at > 200 )
timeout = true;

// Describe the results
if ( timeout )
{
printf("Failed, response timed out.\n\r");
}
else
{
// Grab the response, compare, and send to debugging spew
unsigned long got_time;
radio.read( &got_time, sizeof(unsigned long) );

// Spew it
printf("Got response %lu, round-trip delay: %lu\n\r",got_time,millis()-got_time);
}

// Try again 1s later
delay(1000);
}

//
// Pong back role. Receive each packet, dump it out, and send it back
//

if ( role == role_pong_back )
{
// if there is data ready
if ( radio.available() )
{
// Dump the payloads until we've gotten everything
unsigned long got_time;
bool done = false;
while (!done)
{
// Fetch the payload, and see if this was the last one.
done = radio.read( &got_time, sizeof(unsigned long) );

// Spew it
printf("Got payload %lu...",got_time);

// Delay just a little bit to let the other unit
// make the transition to receiver
delay(20);
}

// First, stop listening so we can talk
radio.stopListening();

// Send the final one back.
radio.write( &got_time, sizeof(unsigned long) );
printf("Sent response.\n\r");

// Now, resume listening so we catch the next packets.
radio.startListening();
}
}

//
// Change roles
//

if ( Serial.available() )
{
char c = toupper(Serial.read());
if ( c == 'T' && role == role_pong_back )
{
printf("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK\n\r");

// Become the primary transmitter (ping out)
role = role_ping_out;
radio.openWritingPipe(pipes[0]);
radio.openReadingPipe(1,pipes[1]);
}
else if ( c == 'R' && role == role_ping_out )
{
printf("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK\n\r");

// Become the primary receiver (pong back)
role = role_pong_back;
radio.openWritingPipe(pipes[1]);
radio.openReadingPipe(1,pipes[0]);
}
}
}
// vim:cin:ai:sts=2 sw=2 ft=cpp

ritratto di luisella
Offline
Titolo: User
Utente
Ultima visita:
6 settimane 4 giorni fa
Utente dal: 23/07/2014
Messaggi: 3
cerco di dare + info

cerco di dare + info possibili:
sto usando un Arduino DUE e un Arduino MICRO
ho acquistato la coppia di Transceiver della Nordic e sto seguendo il sito http://arduino-info.wikispaces.com/Nrf24L01-2.4GHz-HowTo come riferimento.
Ho scaricato le librerie che suggerisce in quel sito e sto usando i pin
9 e 10 come CE e CSN.
Per quanto riguarda i collegamenti con i pin MISO, MOSI e SCK su Arduino DUE mi sembra che sia indifferente usare i pin 12, 11, e 13 (vado a memoria, ma come spiega il sito di cui sopra) oppure i pin ICSP di Arduino DUE.
Invece per Arduino MICRO ho dovuto usare i pin dedicati MOSI, MISO e SCK e poi il 9 e il 10 per CE e CSN.
L'alimentazione per i transceiver è quella che prelevo dal pin 3,3 dei due arduini e poi il pin GND è stato collegato al GND dei due arduini corrispondentemente.
Per poco sembrava funzionare, anche se i numeri che il ricevitore riceveva erano enormi e non corrispondenti ai millisecondi che il trasmettitore inviava.
Poi ultimamente non funziona proprio più. L'impressione che ho è che mi pare sia la parte collegata ad Arduino MICRO che non va, sia come RX, sia come TX.
Scusate se mi sono dilungata parecchio, ma ho cercato di essere + dettagliata possibile.
GRAZIE MILLE per l'aiuto .

 

 

Login   
 Twitter Facebook LinkedIn Youtube Google RSS

Chi è online

Ci sono attualmente 2 utenti e 60 visitatori collegati.

Ultimi Commenti