Home Forum MICROCONTROLLORI Arduino e nRF24L01+

Questo argomento contiene 5 risposte, ha 4 partecipanti, ed è stato aggiornato da  luisella 2 mesi, 2 settimane fa.

Stai vedendo 6 articoli - dal 1 a 6 (di 6 totali)
  • Autore
    Articoli
  • #60581

    remigio
    Membro

    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.

    #75480

    Giorgio B.
    Membro

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

    #75767

    luisella
    Membro

    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

    #75791

    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.

    #75794

    luisella
    Membro

    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

    #75795

    luisella
    Membro

    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 .

Stai vedendo 6 articoli - dal 1 a 6 (di 6 totali)

Devi aver eseguito l’accesso per poter rispondere a questa discussione.