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

NRF24l01 Nordic Semiconductor radio

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.

Remarques pour les enseignants

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 ?

Solution

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).

Solution

#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.

Remarque

On utilisera A0 et A1 pour les deux axes du Joystick. Ces entrées sont compatibles avec le branchement du futur NRF24L01.

Solution

#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).

Solution

#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).

Solution

#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

Cet article est issu de Wikiversity. Le texte est sous licence Creative Commons - Attribution - Partage dans les Mêmes. Des conditions supplémentaires peuvent s'appliquer aux fichiers multimédias.