Micro contrôleurs AVR/Travail pratique/Télécommande NRF24L01 pour Robot
Le but de ce TP est de partir d'un châssis existant de robot composé d'une carte de puissance (de type L298N) et d'une carte de commande qui sera composée d'un Arduino Nano placé sur une plaque à essai et qui sera connecté au L298N et au composant radio NRF24L01.
L'objectif de ce TP est donc de faire réaliser une télécommande (sur plaque à essais). Cela nécessite un Joystick qui fait partie des périphériques Arduino que l'on peut trouver pour quelques Euros. La partie robotique sera elle réalisée avec un châssis de votre choix,des moteurs de votre choix, un L298N et pour finir le module NRF24L01. Tous ces modules sont extrêmement bon marchés.
Nous vous présenterons le matériel que nous avons utilisé mais vous devez adapter le matériel à votre budget.
Introduction
Nous allons dans ce TP réaliser une télécommande pour un robot à l'aide du circuit NRFL01. C'est un composant qui est fabriqué par une entreprise norvégienne Nordic Semiconductor qui permet de transmettre des données par liaison radio. Le gros intérêt de ce composant est son prix (6 € pour 10 pièces en Chine). Son concurrent le plus connu, XBee, frôle plutôt les 20€, même en Chine.
Ce composant NRF24L01 est un module radio intégrant tout le nécessaire pour émettre et recevoir des données sur la gamme de fréquences de 2.4GHz (comme le WiFi ou le Bluetooth) en utilisant le protocole de communication propriétaire de Nordic nommé "ShockBurst".
L'intérêt de ce TP est une révision assez importante des concepts présentés dans ce cours. D'autre part, comme le composant NRF24L01 est relativement configurable, vous serez amené à lire un peu de sa documentation. Il vous sera ainsi possible de le configurer correctement pour un fonctionnement particulier : un émetteur et un récepteur.
Ce TP consiste donc à réaliser logiciellement et matériellement deux parties qui communiquent. Mettre en œuvre les deux parties simultanément n'est pas spécialement simple. Ainsi les enseignants intéressés par ce TP devront fournir une partie réceptive opérationnelle qui sort ce qu'elle reçoit sur la liaison série. Cela permettra de valider la partie émission lorsqu'elle sera opérationnelle.
La partie châssis sera laissée à l'initiative des enseignants. Nous avons utilisé nous-même un châssis robot assez volumineux, mais vous pouvez utiliser un châssis de dimension plus restreinte.
Vous pouvez concevoir ces deux parties avec des plaques à essais pour laisser les étudiants câbler (complètement ou partiellement).
Vous pouvez aussi remplacer le châssis Robot par quelque chose de plus simple : deux servomoteurs ou tout autre idée.
Il existe des librairies sur Internet pour réaliser ce TP. Nous proposons ici de construire complètement l'ensemble. Le code qui en résultera ne sera pas adaptable à d'autres architectures car trop dépendant du matériel ! Nous avons par exemple réussi à faire fonctionner la librairie MIRF sans changement avec un ARM Texas Instrument dans l'environnement Energia ! Le code de ce TP ne sera pas aussi général.
Nous allons donc commencer par la partie révision qui utilise donc des chapitres précédents de ce livre.
Liaison série
La difficulté de vérifier que ce qui est envoyé est bien ce qui est reçu nécessite l'utilisation d'une liaison série. Elle est évidemment disponible si vous utilisez une programmation de type Arduino (avec un setup() et un loop()). Mai rappelons encore une fois qu'il est possible d'utiliser l'environnement Arduino pour faire du C standard : il suffit d'écrire un main(). Dès qu'un main() est détecté dans un programme l'environnement sait qu'il doit travailler sans les librairies Arduino. Nous n'aurons donc pas accès au "Serial.print()" de l'Arduino. Dans ce chapitre nous allons donc écrire des fonctions RS232 simples. Nous aurons besoin de celles-ci essentiellement pour déboguer.
Voir aussi le chapitre correspondant dans ce cours.
Réalisation d'une transmission série à 9600 bauds
La transmission série n'a pas besoin d'être rapide puisqu'elle servira seulement à vérifier le bon fonctionnement de chacune des parties : émetteur (la télécommande) et récepteur le robot. C'est pour cela qu'on a choisi 9600 bauds. Cette valeur peut naturellement être augmentée.
Réalisation de l'initialisation de la liaison série
Le code donné ailleurs dans dans ce cours sera notre point de départ :
#include <avr/io.h>
#define F_CPU 16000000 // 16 MHz oscillator.
#define BaudRate 9600
#define MYUBRR (F_CPU / 16 / BaudRate ) - 1
void serialInit(void) {
//Serial Initialization
/*Set baud rate 9600 */
UBRR0H = (unsigned char)(MYUBRR>>8);
UBRR0L = (unsigned char) MYUBRR;
/* Enable receiver and transmitter */
UCSR0B = (1<<RXEN0)|(1<<TXEN0);
/* Frame format: 8data, No parity, 1stop bit */
UCSR0C = (3<<UCSZ00);
}
Exercice 1
Pouvez-vous écrire la configuration du registre UCSR0C de manière plus traditionnelle en désignant tous les bits configurés à 1 ?
UCSR0C = ((1<<UCSZ01) | (1<<UCSZ00)); // seulement deux bits à configurer
Les deux bits UCSZ01 et UCSZ00 sont configurés à 1.
Sous-programme d'émission d'un octet
Nous donnons le programme un peu modifié de la section sur la liaison série. On utilise les macros présentées ici qui à priori sont plus faciles à utiliser pour les étudiants.
#include <avr/sfr_defs.h>
void serialWrite(uint8_t DataOut)
{
loop_until_bit_is_set(UCSR0A,UDRE0); // wait while NOT ready to transmit
UDR0 = DataOut;
}
Transformation d'un octet en décimal
La liaison série est supposée envoyer des caractères affichables. Si vous prenez un octet venant de n'importe quoi et que vous l'envoyez sur la liaison série vous risquez d'avoir une surprise. C'est pour cela que dans le chapitre sur la liaison série a été développé le sous-programme suivant :
void usart_puts_hexa(uint8_t val) {
uint8_t tab[2];
tab[0] = val >> 4; //poids fort
tab[1] = val & 0x0F; //poids faible
if (tab[0] < 10) tab[0] += '0'; else tab[0] += '7';
if (tab[1] < 10) tab[1] += '0'; else tab[1] += '7';
serialWrite(tab[0]); // poids fort en premier
serialWrite(tab[1]); // puis poids faible
}
qui transforme un octet en sa valeur hexadécimale.
Exercice 2
Les étudiants ayant des difficultés (normales) avec l'hexadécimal, nous allons plutôt utiliser le décimal.
- Écrire un sous-programme d'affichage d'un octet en décimal en s'inspirant (vaguement) de l'écriture hexadécimale.
- Écrire un sous-programme d'affichage de deux octets (uint16_t) en décimal. On rappelle pour ceux qui se poseraient la question de savoir pourquoi deux octets, que les valeurs données par le convertisseur analogique numérique (donc le joystick) sont sur deux octets (10 bits pour être exact).
#include <avr/io.h>
#include <avr/sfr_defs.h>
#include <util/delay.h>
#define F_CPU 16000000 // 16 MHz oscillator.
#define BaudRate 9600
#define MYUBRR (F_CPU / 16 / BaudRate ) - 1
void serialInit(void) {
//Serial Initialization
/*Set baud rate 9600 */
UBRR0H = (unsigned char)(MYUBRR>>8);
UBRR0L = (unsigned char) MYUBRR;
/* Enable receiver and transmitter */
UCSR0B = (1<<RXEN0)|(1<<TXEN0);
/* Frame format: 8data, No parity, 1stop bit */
UCSR0C = ((1<<UCSZ01)|(1<<UCSZ00)); // seulement deux bits à configurer
}
void serialWrite(uint8_t DataOut) {
loop_until_bit_is_set(UCSR0A,UDRE0); // while NOT ready to transmit
UDR0 = DataOut;
}
void serialWrite8Deci(uint8_t DataOut) {
uint8_t tab[3];
tab[0] = DataOut / 100 + '0';
tab[1] = ((DataOut / 10) % 10) + '0';
tab[2] = (DataOut % 10) + '0';
serialWrite(tab[0]); // centaine
serialWrite(tab[1]); // dizaine
serialWrite(tab[2]); // unité
}
void serialWrite16Deci(uint16_t DataOut) {
uint8_t tab[4]; // on se limite à 4 car CAN ne dépasse pas 1023
tab[0] = DataOut / 1000 + '0';
tab[1] = ((DataOut / 100) % 10) + '0';
tab[2] = ((DataOut /10)% 10) + '0';
tab[3] = (DataOut % 10) + '0';
serialWrite(tab[0]); // millier
serialWrite(tab[1]); // centaine
serialWrite(tab[2]); // dizaine
serialWrite(tab[3]); // unité
}
void usart_puts_hexa(uint8_t val) {
uint8_t tab[2];
tab[0] = val >> 4; //poids fort
tab[1] = val & 0x0F; //poids faible
if (tab[0] < 10) tab[0] += '0'; else tab[0] += '7';
if (tab[1] < 10) tab[1] += '0'; else tab[1] += '7';
serialWrite(tab[0]); // poids fort en premier
serialWrite(tab[1]); // puis poids faible
}
int main() {
uint16_t cmpt=987;
// setup
serialInit();
// loop
while (1) {
cmpt++;
serialWrite16Deci(cmpt);serialWrite(0x0D);serialWrite(0x0A);
_delay_ms(1000);
}
}
Conversion Analogique Numérique
La télécommande est réalisée avec une manette joystick qui donne une information analogique. Plus exactement, deux informations analogiques, une pour l'axe x et une pour l'axe y.
La conversion analogique numérique a déjà été traitée dans ce livre au chapitre 11.
Vous pouvez aussi trouver sur Internet un tutoriel pour utiliser un joystick 2 axes. Il est programmé en langage Arduino mais nous voulons nous l'utiliser en langage C.
Exercice 3
Cherchez un code d'utilisation du convertisseur analogique/numérique dans le au chapitre 11 et transformez le simplement en deux sous-programmes :
- void ADC_Init(void)
- uint16_t ADC_get(uint8_t channel)
On pourra naturellement câbler un joystick pour des tests qui pourront être validés par la liaison série déjà réalisée.
On utilisera A0 et A1 pour les deux axes du Joystick. Ces entrées sont compatibles avec le branchement du futur NRF24L01.
#include <avr/io.h>
#include <avr/sfr_defs.h>
#include <util/delay.h>
#define F_CPU 16000000 // 16 MHz oscillator.
#define BaudRate 9600
#define MYUBRR (F_CPU / 16 / BaudRate ) - 1
void serialInit(void) {
//Serial Initialization
/*Set baud rate 9600 */
UBRR0H = (unsigned char)(MYUBRR>>8);
UBRR0L = (unsigned char) MYUBRR;
/* Enable receiver and transmitter */
UCSR0B = (1<<RXEN0)|(1<<TXEN0);
/* Frame format: 8data, No parity, 1stop bit */
UCSR0C = ((1<<UCSZ01)|(1<<UCSZ00)); // seulement deux bits à configurer
}
void serialWrite(uint8_t DataOut) {
loop_until_bit_is_set(UCSR0A,UDRE0); // while NOT ready to transmit
UDR0 = DataOut;
}
void serialWrite8Deci(uint8_t DataOut) {
uint8_t tab[3];
tab[0] = DataOut / 100 + '0';
tab[1] = ((DataOut / 10) % 10) + '0';
tab[2] = (DataOut % 10) + '0';
serialWrite(tab[0]); // centaine
serialWrite(tab[1]); // dizaine
serialWrite(tab[2]); // unité
}
void serialWrite16Deci(uint16_t DataOut) {
uint8_t tab[4]; // on se limite à 4 car CAN ne dépasse pas 1023
tab[0] = DataOut / 1000 + '0';
tab[1] = ((DataOut / 100) % 10) + '0';
tab[2] = ((DataOut /10)% 10) + '0';
tab[3] = (DataOut % 10) + '0';
serialWrite(tab[0]); // millier
serialWrite(tab[1]); // centaine
serialWrite(tab[2]); // dizaine
serialWrite(tab[3]); // unité
}
void ADC_Init(void) {
// Choose AVCC pin for the comparison voltage
ADMUX = (1 << REFS0) ;
// Start the ADC unit,
// set the conversion cycle 16 times slower than the duty cycle
ADCSRA = (1 << ADEN) | (1 << ADPS2);
}
uint16_t ADC_get(uint8_t channel) {
// Choose channel in the multiplexer
ADMUX &= 0xF0; // (MUX3,MUX2,MUX1,MUX0) = (0,0,0,0)
ADMUX |= (channel & 0x0F) << MUX0; //on veut channel<16
// on lance la conversion
ADCSRA |= (1 << ADSC);
// on attend qu'elle soit finie
loop_until_bit_is_clear(ADCSRA, ADSC);
// ici le bit ADSC vient de passer à 0
return ADC;
}
int main() {
uint16_t joystick_x,joystick_y;
// setup
serialInit();
ADC_Init();
// loop
while (1) {
joystick_x = ADC_get(0);
joystick_y = ADC_get(1);
serialWrite16Deci(joystick_x);
serialWrite(' ');serialWrite('-');serialWrite(' ');
serialWrite16Deci(joystick_y);
serialWrite(0x0D);serialWrite(0x0A);
_delay_ms(1000);
}
}
Notez que la relation entre le numéro de channel et le nombre à mettre dans le multiplexeur de sélection ne sont pas toujours identiques (voir l'Arduino Leonardo).
Liaison SPI
La liaison SPI ne nous est pas inconnue non plus. Il nous faudra cependant écrire des fonctions plus pratiques que celles qui ont été faites dans le chapitre 7. Nous allons partir d'un code donné et l'adapter au problème qui nous intéresse, à savoir, l'écriture et la lecture des registres du NRF24L01.
Exercice 4
Reprendre le code du chapitre 7 en transformant la boucle d'attente en choisissant entre loop_until_bit_is_set et loop_until_bit_is_clear. On en profitera pour changer SS en CSN (du NRF24L01) qui pour nous sera en broche 8 Arduino (PB0).
#include <avr/io.h>
#include <avr/sfr_defs.h>
#include <util/delay.h>
//SPI init
void SPIMasterInit(void) {
//set MOSI, SCK and CSN as output
DDRB |= (1<<PB3)|(1<<PB5)|(1<<PB0);
//set CSN to high
PORTB |= (1<<PB0);
//enable master SPI at clock rate Fck/16
SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
}
//master send function
void SPIMasterSend(uint8_t data){
//select slave
//CSN to LOW
PORTB &= ~(1<<PB0);
//send data
SPDR=data;
//wait for transmition complete
loop_until_bit_is_set(SPSR, SPIF);
//CSN to high
PORTB |= (1<<PB0);
}
Le code donné en correction n'est plus utilisable de manière générale puisque SS (Slave Select) est utilisé sur PB0 de manière systématique. Par contre vous pouvez l'adapter facilement pour un autre positionnement de SS. Nous avons choisi PB0 comme nous aurions pu utiliser n'importe quelle autre broche ! On rappelle que seule l'utilisation du SPI en esclave impose une broche précise pour le SPI.
Exercice 5
Nous allons maintenant continuer à spécialiser le SPI pour réaliser le protocole SPI du NRF24L01. L'architecture vue du SPI est la suivante :
- des registres caractérisés par une adresse dans lesquels on peut écrire une ou plusieurs valeurs et que l'on peut lire aussi bien sûr.
- des instructions
Ainsi le logiciel capable d'utiliser aura les possibilités suivantes :
- Écriture d'instructions. Les instructions ont des valeurs très particulières qui ne peuvent pas être des adresses de registres. La manipulation de ces données peut se faire avec le code de l'exercice 4 : void SPIMasterSend(uint8_t data)
- Écriture d'une seule donnée (octet) dans la majorité des registres du NRF24L01. Un registre est caractérisé par une adresse (sur un octet et une valeur sur un octet. En clair, il serait intéressant d'avoir un sous-programme de prototype uint8_t SPI_NRF24_Reg(uint8_t reg, uint8_t value) capable d'écrire "value" dans le registre d'adresse "reg".
- Écriture d'une donnée pouvant atteindre 32 octets comme les adresses de réception et d'émission, mais aussi des données à transmettre. Un prototype du type uint8_t SPI_NRF24_Write_Buf(uint8_t reg, uint8_t *pBuf, uint8_t bytes) serait parfait.
- Lecture d'un ensemble de données pouvant atteindre 32 octets ayant comme prototype uint8_t SPI_NRF24_Read_Buf(uint8_t reg, uint8_t *pBuf, uint8_t bytes)
- Compléter ce code avec un sous-programme d'écriture de deux octets (pour écriture dans les registres)
- Compléter ce code avec écriture d'un nombre d'octets passé en paramètre. (Écriture dans le registre de gestion des adresses)
- Compléter ce code avec la lecture d'un nombre d'octets passé en paramètre. (Lecture des données envoyées).
#include <avr/io.h>
#include <avr/sfr_defs.h>
#include <util/delay.h>
//********** On spécialise le SPI pour le NRF24L01 ***********
// ne gère pas CSN
uint8_t SPI_NRF24_RW(uint8_t data) {
SPDR=data;
loop_until_bit_is_set(SPSR, SPIF);
return SPDR;
}
uint8_t SPI_NRF24_Reg(uint8_t reg, uint8_t value) {
uint8_t status;
//CSN to LOW
PORTB &= ~(1<<PB0);
status = SPI_NRF24_RW(reg);
SPI_NRF24_RW(value);
//CSN to high
PORTB |= (1<<PB0);
return(status);
}
uint8_t SPI_NRF24_Read_Buf(uint8_t reg, uint8_t *pBuf, uint8_t bytes)
{
uint8_t status1,uchar_ctr;
//CSN to LOW
PORTB &= ~(1<<PB0);
status1 = SPI_NRF24_RW(reg);
for(uchar_ctr=0;uchar_ctr<bytes;uchar_ctr++)
pBuf[uchar_ctr] = SPI_NRF24_RW(0);
//CSN to high
PORTB |= (1<<PB0);
return(status1);
}
uint8_t SPI_NRF24_Write_Buf(uint8_t reg, uint8_t *pBuf, uint8_t bytes)
{
uint8_t status1,uchar_ctr;
//CSN to LOW
PORTB &= ~(1<<PB0);
status1 = SPI_NRF24_RW(reg);
for(uchar_ctr=0; uchar_ctr<bytes; uchar_ctr++) //
SPI_NRF24_RW(*pBuf++);
//CSN to high
PORTB |= (1<<PB0);
return(status1); //
}
L'idée générale de ces codes consiste à positionner le SS (ou CSN pour NRF24) en 0 à faire autant de transmissions que n'cessaire et à repasser SS à 1.
Nous allons comencer par réaliser la programmation de la carte de commande du Robot avec le NRF24L01 car nous pensons qu'il est plus facile pour l'enseignant de réaliser une télécommande qui servira tour à tour à chacun des binômes pour les essais. Une fois que tout sera fonctionnel avec cette télécommande, les étudiants pourront se lancer dans la réalisation et la programmation de leur propre télécommande.
Réalisation et programmation de la carte de commande du robot
Il suffit donc de spécialiser encore un peu le code du SPI pour pour résoudre l'ensemble des problèmes pour réaliser une réception. Deux sous-programmes particuliers sont donc à réaliser :
- un sous-programme d'initialisation du NRF24L01 en mode réception
- un sous-programme de réception des données
Exercice 6
Réalisation et programmation de la télécommande
Tout est prêt maintenant pour réaliser le code de la télécommande. On a du code pour faire
- une conversion analogique numérique
- gérer une liaison série
- gérer du SPI
Il suffit donc de spécialiser encore un peule code du SPI pour pour résoudre l'ensemble des problèmes pour réaliser une transmission.
Exercice 7
On vous demande de réaliser un sous-programme capable d'initialiser complètement le NRF24L01 en émission et un sous-programme d'émission de données.
Documentation NRF24L01
Le composant NRF24L01 est caractérisé par un ensemble de registres de configuration. On accède à ces registres à travers le protocole SPI qui est le seul protocole disponible sur ce composant.
Registre de configuration
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 00 CONFIG Registre de configuration Réservé 7 0 R/W '0' seulement autorisé MASK_RX_DR 6 0 R/W masque d'interruption par RX_DR 1 : interruption non reflectée
0 : refléchie RX_DR active basse sur la broche IRQ
MASK_TX_DS 5 0 R/W masque d'interruption par RX_DS 1 : interruption non reflectée
0 : refléchie RX_DR active basse sur la broche IRQ
MASK_MAX_RT 4 0 R/W masque d'interruption par RX_DT 1 : interruption non reflectée
0 : refléchie RX_DR active basse sur la broche IRQ
EN_CRC 3 1 R/W autorise le CRC. Forcé à 1 si un bit de EN_AA est à 1 CRCO 2 0 R/W Schéma d'encodage de CRC 0 : 1 octet
1 : 2 octets
PWR_UP 1 0 R/W 1 : en action 0 : éteint
PRIM_RX 0 0 R/W contrôle RX/TX 1 : PRX
0 : PTX
Gestion de l'accusé de réception
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 01 EN_AA Enhanced ShockBurstTM desactiver cette fonction pour être compatible nrf2401 Réservé 7:6 00 R/W '00' seulement autorisé ENAA_P5 5 1 R/W accusé de réception autorisé pour canal 5 ENAA_P4 4 1 R/W accusé de réception autorisé pour canal 4 ENAA_P3 3 1 R/W accusé de réception autorisé pour canal 3 ENAA_P2 2 1 R/W accusé de réception autorisé pour canal 2 ENAA_P1 1 1 R/W accusé de réception autorisé pour canal 1 ENAA_P0 0 1 R/W accusé de réception autorisé pour canal 0
Gestion de l'autorisation des adresses de réception
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 02 EN_RXADDR Autoriser l'adresse de réception Réservé 7:6 00 R/W '00' seulement autorisé ERX_P5 5 1 R/W autorisation pour canal 5 ERX_P4 4 1 R/W autorisation pour canal 4 ERX_P3 3 1 R/W autorisation pour canal 3 ERX_P2 2 1 R/W autorisation pour canal 2 ERX_P1 1 1 R/W autorisation pour canal 1 ERX_P0 0 1 R/W autorisation pour canal 0
Gestion de la largeur commune des adresses de réception et d'émission
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 03 SETUP_AW définition de la taille de l'adresse pour tous les canaux Réservé 7:2 000000 R/W '000000' seulement autorisé AW 1:0 11 R/W Largeur d'adresse d'émission/réception 00 : illégal
01 : 3 octets
10 : 4 octets
11 : 5 octets
Gestion de la retransmission automatique
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 04 SETUP_RETR réglage de retransmission automatique ARD 7:4 0000 R/W délai retransmission 0000 : attente de 250 us
0001 : attente de 500 us
....
1111 : attente de 4000 us
ARC 3:0 0011 R/W nombre de retransmissions 0000 : pas de retransmission
0001 : jusqu'à une retransmission en cas d'échec
....
1111 : jusqu'à 15 retransmissions en cas d'échec
Gestion du canal radio fréquence
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 05 RF_CH canal RF Reserved 7 0 R/W alloué à 0 seulement RF_CH 6:0 0000010 R/W réglage des fréquences des canaux
Registre de configuration RF
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 06 RF_SETUP Registre de configuration RF CONT_WAVE 7 0 R/W autorise l'émission continue de la porteuse Réservée 6 0 R/W Seulement '0' autorisé RF_DR_LOW 5 0 R/W positionne le débit à 250 kbps PLL_LOCK 4 0 R/W Force le verrouillage de la PLL (seulement pour les tests) RF_DR_HIGH 3 1 R/W Combiné à RF_DR_LOW permet éventuellement de changer le débit de transmission RF_PWR 2:1 11 R/W Gère la puissance d'émission en sortie 00 : -18 dBm
01 : -12 dBm
10 : -6 dBm
11 : 0 dBm
Obsolète 0 0 R/W Ne pas utiliser
- Élément de la liste à puces
Registre de statut
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 07 STATUS Une écriture SPI dans ce registre permet de retrouver son contenu en série sur la broche MISO Réservé 7 0 R/W Seul un 0 est possible RX_DR 6 0 R/W Mis à '1' quand une donnée arrive dans le FIFO de réception TX_DS 5 0 R/W Mis à '1' quand une donnée est émise MAX_RT 4 0 R/W Si ce bit est à 1 il faut le remettre à 0 pour continuer toute utilisation. La mise à 0 se fait en écrivant un 1. RX_P_NO 3:1 111 R Numéro du canal correspondant à la réception dans RX_FIFO 000 - 101 : unméro du canal
110 : non utilisé
111 : RX_FIFO vide
TX_FULL 0 0 R Drapeau pour remplissage du FIFO de réception 1 : FIFO rempli
0 : Possibilité d'utiliser le FIFO
Registre d'observation de la transmission
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 08 OBSERVE_TX Registre d'observation de la transmission PLOS_CNT 7:4 0 R Compte les paquets perdus. Ce compteur est limité à 15 et rest à 15 jusqu'à une initialisation par écriture dans RF_CH ARC_CNT 3:0 0 R Compteur de paquets retransmis. Ce compteur est automatiquement réinitialisé à 0 lors d'une transmission d'un nouveau paquet
Registre de détection de la porteuse
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 09 RPD Registre de détection de la porteuse Réservé 7:1 0000000 R Ne pas utiliser RPD 0 0 R
Registres de gestion des adresses de réception pour les canaux
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 0A RX_ADDR_P0 39:0 0xE7E7E7E7E7 R/W Adresse de réception du canal 0 0B RX_ADDR_P1 39:0 0xC2C2C2C2C2 R/W Adresse de réception du canal 1 0C RX_ADDR_P2 7:0 0xC3 R/W Adresse de réception du canal 2 (bits 39:8 égaux à canal 1) 0D RX_ADDR_P3 7:0 0xC4 R/W Adresse de réception du canal 3 (bits 39:8 égaux à canal 1) 0E RX_ADDR_P4 7:0 0xC5 R/W Adresse de réception du canal 4 (bits 39:8 égaux à canal 1) 0F RX_ADDR_P5 7:0 0xC6 R/W Adresse de réception du canal 5 (bits 39:8 égaux à canal 1)
Registres de gestion de l'adresse de transmission pour les canaux
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 10 TX_ADDR 39:0 0xE7E7E7E7E7 R/W Adresse de transmission. Positionner l'adresse RX_ADDR_P0 à cette valeur pour automatiser le Enhanced ShockBurstTM
Configuration du nombre d'octets utiles dans une trame
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 11 RX_PW_P0 Réservé 7:6 00 R/W Seuls 00 sont autorisés RX_PW_P0 5:0 0 R/W nombre d'octets utilisables pour un envoi/réception (1 à 32 octets) 0 : canal non utilisé
1 : 1 octet
...
32 : 32 octets
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 12 RX_PW_P1 Réservé 7:6 00 R/W Seuls 00 sont autorisés RX_PW_P1 5:0 0 R/W nombre d'octets utilisables pour un envoi/réception (1 à 32 octets) 0 : canal non utilisé
1 : 1 octet
...
32 : 32 octets
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 13 RX_PW_P2 Réservé 7:6 00 R/W Seuls 00 sont autorisés RX_PW_P2 5:0 0 R/W nombre d'octets utilisables pour un envoi/réception (1 à 32 octets) 0 : canal non utilisé
1 : 1 octet
...
32 : 32 octets
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 14 RX_PW_P3 Réservé 7:6 00 R/W Seuls 00 sont autorisés RX_PW_P3 5:0 0 R/W nombre d'octets utilisables pour un envoi/réception (1 à 32 octets) 0 : canal non utilisé
1 : 1 octet
...
32 : 32 octets
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 15 RX_PW_P4 Réservé 7:6 00 R/W Seuls 00 sont autorisés RX_PW_P4 5:0 0 R/W nombre d'octets utilisables pour un envoi/réception (1 à 32 octets) 0 : canal non utilisé
1 : 1 octet
...
32 : 32 octets
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 16 RX_PW_P5 Réservé 7:6 00 R/W Seuls 00 sont autorisés RX_PW_P5 5:0 0 R/W nombre d'octets utilisables pour un envoi/réception (1 à 32 octets) 0 : canal non utilisé
1 : 1 octet
...
32 : 32 octets
Registre de statut du FIFO
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 17 FIFO_STATUS Registre de statut du FIFO Réservé 7 0 R/W Seul un 0 est possible TX_REUSE 6 0 R TX_FULL 5 0 R Mis à '1' quand le FIFO de transmission est plein TX_EMPTY 4 0 R Si ce bit est à 1 le FIFO de transmission est vide Réservé 3:2 00 R/W Seulement 00 est autorisé RX_FULL 1 0 R Mis à '1' quand le FIFO de réception est plein RX_EMPTY 0 0 R Si ce bit est à 1 le FIFO de réception est vide
Gestion dynamique des longueurs de paquets
- NRF24L01+
Adresse (hexa) Mnémonique Bit Valeur de reset Type Description 1C DYNPD Autorise la gestion dynamique des longueurs de paquets Réservé 7:6 00 R/W '00' seulement autorisé DPL_P5 5 0 R/W autorise une longueur dynamique pour canal 5 DPL_P4 4 0 R/W autorise une longueur dynamique pour canal 4 DPL_P3 3 0 R/W autorise une longueur dynamique pour canal 3 DPL_P2 2 0 R/W autorise une longueur dynamique pour canal 2 DPL_P1 1 0 R/W autorise une longueur dynamique pour canal 1 DPL_P0 0 0 R/W autorise une longueur dynamique pour canal 0
Les instructions SPI pour NRF24L01
- NRF24L01+
Nom de l'instruction Instruction binaire Nombre d'octets Opération R_REGISTER 000A AAAA 1 à 5 octets Poids fort en premier Lit le registre d'adresse A AAAA W_REGISTER 001A AAAA 1 à 5 octets Poids fort en premier Écrit dans le registre d'adresse A AAAA R_RX_PAYLOAD 0110 0001 1 à 32 octets Poids fort en premier Lit le registre de réception jusqu'à 32 octets W_TX_PAYLOAD 1010 0000 1 à 32 octets Poids fort en premier Écrit dans le registre de réception jusqu'à 32 octets FLUSH_TX 1110 0001 0 Vide le FIFO de transmission (utilisé en TX mode seulement) FLUSH_RX 1110 0010 0 Vide le FIFO de réception (utilisé en RX mode seulement) REUSE_TX_PL 1110 0011 0 Utilisé pour les circuits PTX NOP 1111 1111 0 Pas d'opération
Voir aussi
- communiquer sans fil avec un module nrf24l01 la bibliotheque mirf et une carte arduino genuino
- nrf24l01 FPGA (VHDL) Lien innactif depuis 2020
- GitHub librairie en c
- GitHub librairie MIRF pour Arduino
- Librairie Mirf en C
- WIKI:NRF24L01-Mirf
- (GitHub) Librairie NRFLite qui comme son nom l'indique est légère