domanda sul tubo nRF24L01


9

Sto guardando attraverso il codice di esempio trovato qui . So che ci sono 6 pipe che il modulo nRF24L01 può usare ma ho cercato su Internet le designazioni degli indirizzi e non sono riuscito a trovare nulla. Più precisamente sulla riga 37, esiste un riferimento per dove l'autore sta ottenendo 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL?

Grazie.


1
Hai guardato la scheda tecnica dell'IC radio? Che certamente ha più informazioni sugli indirizzi di pipe.

1
Controlla il documento API RF24 per openReadingPipe()qui: maniacbug.github.io/RF24/… menziona che puoi usare qualsiasi valore per l'ultimo byte dell'indirizzo.
jfpoilpret,

Quindi ho esaminato la documentazione ma non menziona come viene scelto l'indirizzo della pipe. Dice solo che dovrebbero condividere i primi 32 bit. Ad esempio 0xF0F0F0F0 (XX), 0x conta come un byte? O è F0F0F0F0 i 32 bit che contano? Inoltre, importa se non è F0F0F0F0 purché i tubi condividano quei 32 bit? Che ne dici degli ultimi due byte significativi (XX)? Anche quelli sono arbitrari?
Alex H,

Il 0x...prefisso è solo per dire che il valore è in esadecimale. Questo perché 99 in decimale è diverso da 99 in esadecimale, anche se sembrano uguali. Quindi invece usiamo 0x99.
Gerben,

2
Il codice che stai utilizzando supporta solo 1 pipe. L'nRF24L01 ha 2 tubi unici (0 e 1). Ha anche 4 pipe aggiuntive (2, 3, 4 e 5), dove è possibile impostare solo il byte meno significativo. Gli altri byte saranno gli stessi del secondo pipe (1).
Gerben,

Risposte:


5

Come la maggior parte delle persone ha pubblicato, i valori per la pipe sono arbitrari, ma devono seguire le regole per l'API:

I tubi 1-5 devono condividere i primi 32 bit. Solo il byte meno significativo dovrebbe essere univoco, ad es

Prima di rispondere alla tua domanda, penso che sia necessaria una spiegazione sui valori esadecimali e decimali.

L'esadecimale a 40 bit è una rappresentazione numerica della base 16. Un decimale è della base 10. Quindi è possibile convertire un valore esadecimale in decimale. Poiché questo non rientra nella portata della domanda, puoi cercare su Google come convertire da uno all'altro. Ci sono alcuni convertitori online:

Convertitore da esadecimale a decimale

Vedrai quando converti il ​​valore esadecimale in decimale, che è solo una rappresentazione numerica. Quando si converte, si rilascia 0xe LL. Come indicato, 0xindica che il valore è un valore esadecimale e LLsignifica tipo Long Long .

Quindi, per rispondere alla tua domanda, usa un convertitore per trovare un numero esadecimale come:

F0F0F0F0A1
F0F0F0F0A2
F0F0F0F0B4
F0F0F0F0E9

Basta cambiare le ultime 2 cifre (bit meno significativo):

Pipes 1-5 should share the first 32 bits. Only the least significant byte should be unique, e.g.
   openReadingPipe(1,0xF0F0F0F0AA);
   openReadingPipe(2,0xF0F0F0F066);

Aggiungi il 0xeLL

0xF0F0F0F0A1LL
0xF0F0F0F0A2LL
0xF0F0F0F0B4LL
0xF0F0F0F0E9LL

Tutto dovrebbe funzionare.

Non sono un esperto di hex, come sto imparando, quindi se non sono corretto, per favore qualcuno mi corregga.

Infine, la scheda tecnica nRF24L01 sottolinea quanto segue che la scelta dell'indirizzo non è completamente arbitraria:

Nota: gli indirizzi in cui il livello cambia solo una volta (ovvero 000FFFFFFF) possono spesso essere rilevati nel rumore e possono dare un falso rilevamento, che può dare un tasso di errore del pacchetto aumentato. Anche gli indirizzi come continuazione del preambolo (attivazione / disattivazione basso) aumentano il tasso di errore dei pacchetti.


potresti anche menzionare che quei tubi si riferiscono solo alla funzione "6 multi-ricevitore" (vedi scheda tecnica nordica p39-40). per impostazione predefinita sono abilitati solo i pipe di dati 0 e 1.

@bersch - È rilevante? L'OP stava chiedendo come vengono scelti i valori dei tubi where the author is getting 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL?, ad esempio , non come vengono utilizzati i tubi.
PhillyNJ,

Per scegliere i valori, è necessario sapere che per impostazione predefinita sono presenti una pipe di scrittura e una pipe di lettura. Nella modalità multi-ricevitore c'è una scrittura e fino a 5 pipe di lettura. Descrivi solo le pipe di lettura. Finora non l'ho verificato, ma credo che se si sceglie la pipe di lettura e scrittura che condivide i primi 32 bit, fallirà.

Dal mio test, i valori sono arbitrari a condizione che la tua pipe 0 e 1 siano gli stessi sul trasmettitore e sul ricevitore
PhillyNJ,

Vedo. Per quanto mi riguarda, non ho verificato la funzione multi-ricevitore. Uso ogni chip per trasmettere e ricevere.

2

I valori 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LLsono valori arbitrari e definiscono gli indirizzi dei mittenti e dei destinatari con cui parlare.

Se si utilizza la libreria Mirf

Mirf.setRADDR((byte *)"serv1");

possono anche essere stringhe come serv1.

RF24 usi

write_register(RX_ADDR_P0, &value, 5);
write_register(TX_ADDR, &value, 5);

1

C'è qualcosa che tutti dimenticano di dirti:

I tubi sul ricevitore devono essere accorciati dopo il primo

const uint64_t pipe01 = 0xE8E8F0F0A1LL;
const uint64_t pipe02 = 0xA2LL;  
const uint64_t pipe03 = 0xA3LL;
const uint64_t pipe04 = 0xA4LL;
const uint64_t pipe05 = 0xA5LL;
const uint64_t pipe06 = 0xA6LL;

radio.openReadingPipe(1, pipe01);  
radio.openReadingPipe(2, pipe02);
radio.openReadingPipe(3, pipe03);
radio.openReadingPipe(4, pipe04);
radio.openReadingPipe(5, pipe05);

I tubi sul trasmettitore dovrebbero essere

const uint64_t pipe01 = 0xE8E8F0F0A1LL;
const uint64_t pipe02 = 0xE8E8F0F0A2LL;  
const uint64_t pipe03 = 0xE8E8F0F0A3LL;
const uint64_t pipe04 = 0xE8E8F0F0A4LL;
const uint64_t pipe05 = 0xE8E8F0F0A5LL;
const uint64_t pipe06 = 0xE8E8F0F0A6LL;

uint64_t setPipeToSend = pipe01; // or pipe02 or pipe03 or pipe04 or pipe05
radio.openWritingPipe(setPipeToSend );

Se vuoi sapere quale messaggio di pipe è arrivato, usa

  uint8_t someVariable;
    if (radio.available(&someVariable))
    {
       Serial.print("pipe number ");
       Serial.printLn(someVariable);
    }

Anche la pipe numero 6 viene utilizzata per ricevere messaggi di riconoscimento .

Inoltre, il codice di inizializzazione deve avere radio.enableDynamicPayloads(); Questo funziona bene per me:

    radio.begin();
    //radio.setChannel(0x57); //if set should be the same at the both sides
    radio.setPALevel(RF24_PA_LOW);  // "LOW" is more stable mode
    radio.enableAckPayload(); //for autoanswers
    radio.openWritingPipe(pipe01); //for sending
    //link pipe numbers to the pipe addresses
    //radio.openReadingPipe(1, pipe01); // I use pipe01 for sending
    radio.openReadingPipe(2, pipe02);
    radio.openReadingPipe(3, pipe03);
    radio.openReadingPipe(4, pipe04);
    radio.openReadingPipe(5, pipe05);
    radio.enableDynamicPayloads(); //must have for multi pipe receiving
    radio.startListening();  //start listening

In bocca al lupo...


che cosa è pipedefinito come nel tuo esempio?
x29a

1
Ho modificato il codice. Puoi usare una di queste 'pipe' per l'invio, ma non dimenticare (come me) di escludere quella pipe dalla lettura.
Faig,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.