Micro contrôleurs AVR/Travail pratique/Télécommande NRF24L01 pour Robot

Une page de Wikiversité, la communauté pédagogique libre.
Aller à la navigation Aller à la recherche

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[modifier | modifier le wikicode]

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.


Nous allons donc commencer par la partie révision qui utilise donc des chapitres précédents de ce livre.

Liaison série[modifier | modifier le wikicode]

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()). Mais rappelons encore une fois qu'il est possible d'utiliser l'environnement Arduino pour faire du C standard : il suffit d'écrire un main() en lieu et place du setup() et du loop(). Ainsi, dès qu'un main() est détecté dans un programme l'environnement sait qu'il doit travailler sans les librairies Arduino. Nous n'avons alors plus 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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

Le code donné ailleurs 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[modifier | modifier le wikicode]

Pouvez-vous écrire la configuration du registre UCSR0C de manière plus traditionnelle en désignant tous les bits configurés à 1 ?

Sous-programme d'émission d'un octet[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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

Conversion Analogique Numérique[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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.

Liaison SPI[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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

Le code donné en correction n'est plus utilisable de manière générale puisque SS (Slave Select) est utilisé sur PD7 de manière systématique. Par contre vous pouvez l'adapter facilement pour un autre positionnement de SS. Nous avons choisi PD7 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 (PB2 pour l'ATMega 328).


Exercice 5[modifier | modifier le wikicode]

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 qui sont des valeurs sur 3 bits de poids fort qui définissent le type d'action :
    • R_REGISTER 0x00 : lecture d'un registre
    • W_REGISTER 0x20 : écriture dans un registre

Les 5 bits de poids faible représentent alors l'adresse du registre.

Ainsi l'envoi de 0x21 comme première donnée précise qu'il s'agit d'une écriture à cause du 0x20 et dans le registre EN_AA qui a l'adresse 1. Cette donnée doit être immédiatement suivie par la valeur que l'on souhaite écrire dans le registre EN_AA.

Ainsi le logiciel capable d'utiliser le NRF24L01 aura les possibilités suivantes :

  • Écriture d'une seule donnée (octet) dans la majorité des registres du NRF24L01. Un registre est caractérisé par une adresse (sur 5 bits et une valeur sur un octet. En clair, il serait intéressant d'avoir un sous-programme de prototype uint8_t SPI_NRF24_W_Reg(uint8_t reg, uint8_t value) capable d'écrire "value" dans le registre d'adresse "reg".
  • Lecture de la valeur d'un registre de prototype uint8_t SPI_NRF24_R_Reg(uint8_t 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_W_Reg_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_R_Ref_Buf(uint8_t reg, uint8_t *pBuf, uint8_t bytes)

Écrire les sous-programmes correspondant en les testant deux par deux : le test de SPI_NRF24_Reg qui écrit dans un registre se fera avec SPI_NRF24_Read qui doit lire le même registre pour confirmer l'exécution correcte de l'écriture. De même pour les écritures/lectures multiples.

Nous allons commencer 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[modifier | modifier le wikicode]

Il suffit donc de spécialiser encore un peu le code du SPI 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

Cette partie est délicate car elle nécessite la réalisation de l'émetteur pour les tests. Nous allons donc commencer par décrire matériellement une télécommande et donner un programme fonctionnel. Ce programme nécessite l'installation d'une librairie MIRF qui n'est probablement pas la librairie la plus à jour mais qui est facilement utilisable (voir par exemple : communiquer sans fil avec un module nrf24l01 et la bibliotheque mirf).

Télécommande : réalisation matérielle simplifiée[modifier | modifier le wikicode]

Télécommande BNR24L01 pour robot

Nous avons la chance de posséder une télécommande achetée avec un kit robotique. Pour ceux qui n'ont pas cette chance, il vous faut en fabriquer une. Nous rappelons encore une fois que pour tester le fonctionnement correct de la carte de commande du Robot il faut fournir aux étudiants une télécommande fonctionnelle (même si vous décidez plus tard d'en faire réaliser une avec sa programmation dans ce TP). Nous allons montrer dans cette section comment on peut envisager cela de manière très simple.

Une image de ce qu'il y a à réaliser est donnée ci-contre. Elle montre l'utilisation d'un Arduino Nano (circuit de taille inférieure à l'Arduino UNO) très pratique à utiliser dans ce genre de situation. On lui ajoute un joystick et naturellement un NRF24L01.

Télécommande : réalisation logicielle[modifier | modifier le wikicode]

On rappelle qu'ici, ce qui est donné, est un programme fonctionnel de télécommande utilisant la bibliothèque MIRF que l'on se refusera d'utiliser plus tard lorsque les étudiants auront à faire ce travail. Ce programme doit réaliser les fonctions suivantes :

  • une conversion analogique numérique (sur 10 bits) pour chacun des axes
  • une concaténation des deux valeurs sur 10 bits en deux nombres de 16 bits, soit 32 bits stockés dans un long
  • envoi par NRF24L01 des 4 octets

Nous donnons le programme source dans la boîte déroulante ci-dessous :

Exercice 6[modifier | modifier le wikicode]

L'objectif de cet exercice est de réaliser une communication fonctionnelle entre la télécommande donnée et votre crircuit. Pour cela vous réaliserez :

  • un sous-programme capable de passer le NRF24 en mode réception :
// passage en mode reception du NRF24
void SetRX_Mode(void);
  • un sous-programme capable d'écrire dans un registre "reg" une valeur "value" :
// lecture des 32 bits reçus si c'est le cas
uint8_t nRF24L01_RxPacket(uint8_t* rx_buf);

Indications pour l'exercice 6 pour setRX_Mode[modifier | modifier le wikicode]

Il va vous falloir rentrer dans la documentation pour réaliser cet exercice.

Commençons par documenter le sous-programme setRX_Mode. Voilà les opérations qu'il doit exécuter pour être compatible avec la télécomande et sa bibliothèque MIRF :

  • utiliser la définition de certaines constantes en les disposant en début de programme ou mieux dans un fichier .h
  • passage de CE (PB0) en sortie
  • passage de CE à 0
  • écriture dans RX_ADDR_P1 de l'adresse de réception qui se trouve dans le tableau RX_ADDRESS
uint8_t RX_ADDRESS[RX_ADR_WIDTH]={'s','e','r','v','1'}; //receive address
  • écriture dans RX_ADDR_P1 de l'adresse d'émission qui se trouve dans le tableau TX_ADDRESS
uint8_t TX_ADDRESS[TX_ADR_WIDTH]={0x34,0x43,0x10,0x10,0x01};  //send address
  • écriture dans le registre RF_CH de la valeur 1
  • écriture dans le registre RX_PW_P0 de la valeur 4 (4 octets reçus)
  • écriture dans le registre RX_PW_P1 de la valeur 4 (4 octets envoyés)
  • mise en route de la réception : écriture dans le registre CONFIG des bits EN_CRC,PWR_UP et PRIM_RX (valeur 0x0B en tout)
  • passage de CE à 1
  • écriture dans le registre STATUS des bits TX_DS et MAX_RT
  • écriture de l'instruction flushRx avec un SPIMasterSend

Indications pour l'exercice 6 pour nRF24L01_RxPacket[modifier | modifier le wikicode]

La réception d'un pacquet se fait de la manière suivante :

  • obtention du statut avec SPI_NRF24_R_Reg_Buf qui doit lire le registre R_RX_PAYLOAD
  • écriture dans statut du bit RX_DR pour dire que la lecture a été faite


Nous sommes arrivés au point où nous avons une télécommande et une carte de réception fonctionnelle. Il nous faut maintenant étudier comment nous allons prendre les données envoyées par la télécommande et les convertir en deux valeurs de MLI pour transformer les ordres de la télécommande en vitesse de rotation du moteur droit et du moteur gauche.

Exercice 7[modifier | modifier le wikicode]

Réception radio pour commander les moteurs du Robot

Notre objectif maintenant est d'ajouter la partie du code destinée à gérer le pwm à partir des données qui nous arrivent du circuit NRF24L01. La correction de l'exercice 6 fournit le moyen d'obtenir les deux données du joystick

  • joystick_y = (rx_buffer[1]<<8)+rx_buffer[0];
  • joystick_x = (rx_buffer[3]<<8)+rx_buffer[2];

rx_buffer[] est un tableau d'octets qui est automatiquement rempli par le programme avec les données en provenance de la radio.

Notre problème va consister à trouver à partir de ces deux données deux autres données :

  • int16_t pwm qui dépend de joystick_y et qui consiste à transformer uint16_t joystick_y en int16_t pwm, autrement dit un nombre non signé en un nombre signé. Le problème de cette transformation est que le zéro du joystick n'est pas un point mais plutôt un intervalle. Vous allez mesurer un point mais si vous faites la mesure plus tard vous en obtiendrez un autre. Vous prenez donc le point qui vous semble le mieux et vous le retranchez à la valeur joystick_y ce qui fera un nombre signé dépendant de votre avancement ou recul de votre joystick (à l'incertitude près sur le zéro). Ce problème du zéro sera géré plus tard.
  • int16_t deltaPWM qui dépend de joystick_x et qui représente d'une manière peu rigoureuse une rotation. Il sera lui aussi transformé en nombre signé en lui retranchant le zéro du joystick sur l'axe des x avec les mêmes difficultés que pour la conversion précédente.

Vient ensuite une série de tests sur les variables que l'on vient de calculer : pwm et deltaPWM :

Tableau des tests
pwm > 30 pwm < -30 deltaPWM > 30 deltaPWM < -30 cas Dpwm
1 0 0 0 0x08 Dpwm=0
0 1 0 0 0x04 Dpwm=0
0 0 1 0 0x02 Dpwm=100
0 0 0 1 0x01 Dpwm=-100
1 0 1 0 0x0A Dpwm = deltaPWM
1 0 0 1 0x09 Dpwm = deltaPWM
0 1 1 0 0x06 Dpwm = -deltaPWM
0 1 0 1 0x05 Dpwm = -deltaPWM
  • Les tests de type >30 ou <-30 permettent de gérer l'intervalle autour du 0 pour le joystick.
  • "cas" est une variable qui permet de gérer numériquement un switch, c'est une sortie du tableau. Sa valeur est la valeur hexadécimale des 4 entrées.
  • Dpwm est aussi un calcul réalisé avec deltaPWM. Nous l'avons limité à 100 (sur 255) pour éviter de trop importantes vitesse du robot. Les deux valeurs +100 et -100 qui apparaissent dans le tableau sont liés au fait que nous voulions que pour aucun avancement ou recul le robot tourne avec sa vitesse maximale.
  • Ces deux sorties vont permettre de gérer le calcul des deux PWM, un pour le moteur droit pwmD et un pour le moteur gauche pwmG.

1°) Écrire' la gestion du pwm avec le timer0. Les broches 0C0A et OC0B du timer 0 portent respectivement le numéro 6/PD6 et 5/PD5.

2°) Écrire la partie de programme qui prend pwmD et pwmG et calcule les valeurs à envoyer sur le L298D sachant que ces deux données peuvent être positives (avancement) ou négatives (recul): void deplaceToi(int16_t pwmD, int16_t pwmG).

3°) Écrire la partie de programme qui calcule cas, Dpwm, pwm, pwmD et pwmG. Pour laisser de la place en RAM, les variables deltaPWM et Dpwm seront fusionnées en une seule variable.

Réalisation et programmation de la télécommande[modifier | modifier le wikicode]

Nous avons déjà présenté la télécommande de manière matérielle et nous redonnons son schéma de principe. Nous rappelons que la télécommande utilisée pour la communication avec la carte de commande du robot utilisait la bibliothèque MIRF et qu'ici nous allons remplacer ce code par notre propre code.

Télécommande BNR24L01 pour robot

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 peu le code du SPI pour résoudre l'ensemble des problèmes pour réaliser une transmission.

Exercice 8[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]