Ce qui suit est basé sur 51 micro-ordinateur monopuce, le code est simplifié et sans bêtises, directement sur le code. (Si vous avez besoin d'autres microcontrôleurs tels que STM32, vous pouvez me faire confiance en privé)
/ ************************************************* ************
Fichier d'en-tête NRF24L01
************************************************** ************* /
#ifndef _NRF24L01_H_
#define _NRF24L01_H_
#include <reg52.h>
#define uchar unsigned char
#define uint unsigned int
#define TX_ADDR_WITDH 5 // Définit la largeur de l'adresse d'envoi sur 5 octets
#define RX_ADDR_WITDH 5 // Définit la largeur de l'adresse de réception sur 5 octets
#define TX_DATA_WITDH 1 // Largeur d'envoi des données
#define RX_DATA_WITDH 1 // Largeur de réception des données
/ * ** **************** Registre de commande *************************** /
#define R_REGISTER 0x00 // Lire le registre de configuration
#define W_REGISTER 0x20 // Ecrire le registre de configuration
#define R_RX_PAYLOAD 0x61 // Lire les données valides RX
#define W_TX_PAYLOAD 0xa0 // Ecrire les données valides TX
#define FLUSH_TX 0xe1 // Effacer le registre
TXFIFO #define FLUSH_RX 0xe2 // Effacer Registre RXFIFO
/ ****************** adresse du registre ********************** ***** /
#define CONFIG 0x00 // Registre de configuration
#define EN_AA 0x01 // Activation de la réponse automatique
#define EN_RXADDR 0x02 // Activation du canal de réception 0-5 canaux
#define SETUP_RETR 0x04 // Etablissement de la retransmission automatique
#define RF_CH 0x05 // Réglage du canal RF
#define RF_SETUP 0x06 // Registre RF
#define STATUS 0x07 // Registre d'état
#define RX_ADDR_P0 0x0a // Adresse de réception du canal de données 0
#define TX_ADDR 0x10 / / Adresse d'envoi
#define RX_PW_P0 0x11 // Réglage de la largeur des données du canal P0
/ ********************* Définition de la fonction NRF24L01 ********* ** ************* /
uchar NRFACK (); // Delay function
void NRF24L01Int (); // NRF24L01 initialization function
uchar NRFSPI (uchar date); // SPI timing
uchar NRFReadReg (uchar RegAddr) ; // SPI read register 1 byte function
uchar NRFWriteReg (uchar RegAddr, uchar date); // SPI write register 1 byte function
uchar NRFReadRxDate (uchar RegAddr, uchar * RxDate, uchar DateLen); // SPI lit les données
RXFIFO uchar NRFWriteTxDate (uchar RegAddr, uchar * TxDate, uchar DateLen); // SPI écrit les données vers
TXDIFX * voxMid (NRFS) / NRF est réglé pour envoyer le mode et envoyer des données
uchar NRFCheckACK (); // utilisé pour envoyer le mode pour recevoir le signal de réponse
void NRFSetRXMode (); // NRF est réglé pour recevoir le mode et recevoir des données
void NRFGetDate (); // recevoir des données
/ ********************** Définition de la broche NRF24L01 ************************ /
sbit CE = P2 ^ 7; // Terminal de sélection de mode RX / TX
sbit IRQ = P2 ^ 4; // Terminal d'interruption masquable
sbit CSN = P2 ^ 2; // Terminal de sélection de puce SPI // est SS
sbit MOSI = P2 ^ 3; // Borne d'entrée esclave de sortie maître SPI
sbit MISO = P2 ^ 5; // Borne de sortie esclave d'entrée maître SPI
sbit SCLK = P2 ^ 6; // Borne d'horloge SPI
/ ********************** Définition de la variable NRF24L01 ************************ ** /
uchar RevTempDate [2]; // Recevoir le tampon de données
uchar code TxAddr [] = {0x34,0x43,0x10,0x10,0x01}; // Envoyer l'adresse
/ ************* ** ******* Indicateur d'état NRF24L01 ************************** /
uchar bdata sta; // indicateur d'état
sbit RX_DR = sta ^ 6; // Recevoir l'indicateur complet
sbit TX_DS = sta ^ 5; // Envoyer l'indicateur complet
sbit MAX_RT = sta ^ 4; // Recevoir l'indicateur de longueur maximale
/ ***************** * ***************************************
nom de la fonction: NRFDelay void (uint t)
fonction fonction: Fonction de
temporisation Description du paramètre:
********************************************* ************** /
void NRFDelay (uint t)
{ uint x, y; for (x = t; x> 0; x--) for (y = 110; y> 0 ; y--); }
/ ************************************************* ********
Nom de la fonction: void NRF24L01Int ()
Fonction: fonction d'initialisation NRF24L01
Description du paramètre:
************************** * ****************************** /
void NRF24L01Int ()
{ NRFDelay (2); // Délai de mise sous tension CE = 0 ; // Mettre en mode réception CSN = 1; // Désactiver la sélection de puce SCLK = 0; // Dérouler la ligne de signal d'horloge IRQ = 1; // Désactiver l'activation d'interruption } / ********* ** ********************************************** Nom de la fonction : rôle de la fonction uchar NRFSPI (date uchar) : synchronisation SPI Description du paramètre: *********************************** ** ******************** / uchar NRFSPI (date uchar) { uchar i;
for (i = 0; i <8; i ++) // Boucle 8 fois, envoie des données 8 bits, envoie et reçoit des données de haut en bas
{ if (date & 0x80) // les données sont 1 MOSI = 1; sinon MOSI = 0 ; date << = 1; // Déplacement d'un bit vers la gauche SCLK = 1; // Tirage vers le haut de la ligne de signal d'horloge si (MISO) // nRF24L01 lit les données 1 bit de MOSI et sort les données 1 bit de la date MISO | = 0x01; // Lire MISO jusqu'au bit le plus bas de l'octet SCLK = 0; // Réduire la ligne du signal d'horloge } return (date); // Renvoyer l'octet lu } / *********** ** ******************************************** Nom de la fonction: uchar Fonction NRFReadReg (uchar RegAddr): fonction de registre de lecture SPI 1 octet Description du paramètre: adresse de registre RegAddr ******************************** **** ************************** /
uchar NRFReadReg (uchar RegAddr)
{ uchar BackDate; // Définir utilisé pour stocker temporairement les données reçues CSN = 0; // Démarrer la séquence NRFSPI (RegAddr); // Écrire l'adresse du registre BackDate = NRFSPI (0x00); // Écrire dans le registre de lecture Commande CSN = 1; // Fermer le retour de la séquence (BackDate); // Renvoyer les données } / ****************************** *************************** Nom de la fonction: uchar NRFWriteReg (uchar RegAddr, uchar date) Rôle de la fonction: Registre d'écriture SPI Paramètre de fonction 1 octet Description : Adresse du registre RegAddr, date à laquelle les données doivent être écrites ****************************************** ******************* / uchar NRFWriteReg (uchar RegAddr, uchar date) { uchar BackDate; // Définir utilisé pour stocker temporairement les données reçues CSN = 0; // Démarrer la séquence
BackDate = NRFSPI (RegAddr); // Ecrire l'adresse du registre
NRFSPI (date); // Ecrire les données
CSN = 1; // Fermer le
retour de la séquence (BackDate); // Renvoyer les données
}
/ ******** ** ********************************************
Nom de la fonction: uchar NRFReadRxDate ( uchar RegAddr, uchar * RxDate, uchar DateLen)
Fonction: SPI lit les données RXFIFO
Description du paramètre: Adresse de registre RegAddr, * RxDate lu les données, DateLen longueur des données
********* ********** ************************************* /
uchar NRFReadRxDate (uchar RegAddr, uchar * RxDate, uchar DateLen )
{
uchar BackDate, i;
CSN = 0; // Démarrer la séquence
BackDate = NRFSPI (RegAddr); // Ecrire l'adresse de registre à lire
pour (i = 0; i <DateLen; i ++) // Lire les données
{
RxDate [i] = NRFSPI (0);
}
CSN = 1; // Fermer le
retour de séquence (BackDate); // Retourner l'état
}
/ ******************** *************************************
Nom de la fonction: uchar NRFReadRxDate (uchar RegAddr, uchar * RxDate, uchar DateLen)
Fonction: SPI écrit des données dans TXFIFO.
Description du paramètre: adresse du registre RegAddr, * données RxDate envoyées, longueur des données DateLen
********************** ** ********************************* /
uchar NRFWriteTxDate (uchar RegAddr, uchar * TxDate, uchar DateLen)
{ uchar BackDate , i; CSN = 0; // Démarrer la séquence BackDate = NRFSPI (RegAddr); // Ecrire l'adresse à écrire dans le registre pour (i = 0; i <DateLen; i ++) // Ecrire des données { NRFSPI (* TxDate ++ );
}
CSN = 1; // Fermer le
retour de la séquence (BackDate); // Retour de l'état
}
/ ****************************** ***************************
Nom de la fonction: void NRFSetTxMode (uchar * TxDate) Rôle de la
fonction: NRF est configuré pour envoyer le mode et envoyer le
paramètre de données description:
************************************************ * ******** /
void NRFSetTxMode (uchar * TxDate)
{
CE = 0;
NRFWriteTxDate (W_REGISTER + TX_ADDR, TxAddr, TX_ADDR_WITDH); // Commande de registre d'écriture + commande d'activation d'adresse P0 + adresse d'envoi + largeur d'adresse
NRFWriteTxDate (W_REGISTER + RX_ADDR_P0, TxAddr, TX_ADDR_WITDH); // Pour répondre à l'appareil récepteur, l'adresse du canal de réception 0 est la même que l'adresse d'envoi
NRFWriteTxDate (W_TX_PAYLOAD, TxDate, TX_DATA_WITDH); // Ecrire des données
/ *** *** La configuration de registre suivante ************** /
NRFWriteReg (W_REGISTER + EN_AA, 0x01); // Activer la réponse automatique du canal de réception 0
NRFWriteReg (W_REGISTER + EN_RXADDR, 0x01); // Activer le canal de réception 0
NRFWriteReg (W_REGISTER + SETUP_RETR, 0x0a); // Retard de retransmission automatique Attendre 250us + 86us, et retransmet automatiquement 10 fois
NRFWriteReg (W_REGISTER + RF_CH, 0x40); // Sélectionnez le canal RF 0x40
NRFWriteReg (W_REGISTER + RF_SETUP, 0x07); // Taux de transmission de données 1 Mbps, puissance de transmission 0 dBm, gain d'amplificateur à faible bruit
NRFWriteReg (W_REGISTER + CONFIG, 0x0e); // Activation CRC, vérification CRC 16 bits, mise sous tension
CE = 1;
NRFDelay (5); // Délai, assurez-vous que le mode de réglage prend effet
}
/ ******** ** ********************************************
Nom de la fonction: uchar NRFCheckACK ( )
Fonction: Utilisé pour recevoir le signal de réponse en mode émission
Description du paramètre:
********************************* ***** ********************* /
uchar NRFCheckACK ()
{
sta = NRFReadReg (R_REGISTER + STATUS); // Retour au registre d'état
if (TX_DS || MAX_RT) // Envoi d'interruption complète
{ NRFWriteReg (W_REGISTER + STATUS, 0xff); // Effacer l'indicateur d'interruption TX_DS ou MAX_RT CSN = 0; // Démarrer la séquence NRFSPI (FLUSH_TX); // Utilisé pour effacer TXFIFO CSN = 1; // Fermer la séquence return (0); // La transmission des données est réussie, return 0 } else return (1); // Les données n'ont pas été envoyées avec succès, renvoyez 1 } / ******************************************* ** ************** Nom de la fonction: void NRFSetRXMode () Rôle de la fonction: NRF est réglé pour recevoir le mode et recevoir des données Description du paramètre:
************************************************** ******* /
void NRFSetRXMode ()
{ CE = 0; NRFWriteTxDate (W_REGISTER + RX_ADDR_P0, TxAddr, TX_ADDR_WITDH); // L'appareil récepteur reçoit le canal 0 en utilisant la même adresse d'envoi que l'appareil émetteur NRFWriteReg (W_REGISTER + EN_AA , 0x01); // Activer la réponse automatique du canal de réception 0 NRFWriteReg (W_REGISTER + EN_RXADDR, 0x01); // Activer le canal de réception 0 NRFWriteReg (W_REGISTER + RF_CH, 0x40); // Sélectionner le canal RF 0x40 NRFWriteReg (W_REGISTER + RX_PW_P0, TX_DATA_DATA) ; // Le canal de réception 0 sélectionne la même largeur de données effective que le canal de transmission NRFWriteReg (W_REGISTER + RF_SETUP, 0x07); // Taux de transmission de données 1 Mbps, puissance d'émission 0 dBm, gain d'amplificateur à faible bruit NRFWriteReg (W_REGISTER + CONFIG, 0x0f); / / CRC activé, contrôle CRC 16 bits, mise sous tension, mode de réception CE = 1;
NRFDelay (5); // Retard, assurez-vous que le mode de réglage prend effet
}
/ ******************************** ** ***********************
Nom de la fonction: void NRFGetDate ()
Fonction: Recevoir des données
Description du paramètre:
*********** * ********************************************* /
void NRFGetDate ( )
{ sta = NRFReadReg (R_REGISTER + STATUS); // Lire le registre d'état après l'envoi des données if (RX_DR) // Déterminer si les données sont reçues { CE = 0; // Standby NRFReadRxDate (R_RX_PAYLOAD, RevTempDate, RX_DATA_WITDH); // L'esclave RXFIFO lit les données NRFWriteReg (W_REGISTER + STATUS, 0xff); // Après avoir reçu les données, RX_DR, TX_DS, MAX_PT sont tous mis à 1 et l'indicateur d'interruption est effacé en écrivant 1 CSN = 0; // Démarrer la séquence
NRFSPI (FLUSH_RX); // Utilisé pour effacer FIFO
CSN = 1; // Fermer la séquence
}
}
#endif
Page principale des fonctions
/ ************************************************* ************
Terminal d'appel du système d'appel de quartier sans fil
Explication supplémentaire:
************************************************* **************** /
#include <reg52.h>
#include <NRF24L01.h>
/ ************************** Définition de la broche ******************** * ******* /
sbit key_1 = P3 ^ 0; // Huit boutons d'appel
sbit key_2 = P3 ^ 1;
sbit key_3 = P3 ^ 2;
sbit key_4 = P3 ^ 3;
sbit key_5 = P3 ^ 4;
sbit key_6 = P3 ^ 5;
sbit key_7 = P3 ^ 6;
sbit key_8 = P3 ^ 7;
sbit led = P1 ^ 1; // indicateur de travail LED
/ *************** *** **************************************
Nom de la fonction:
fonction de fonction void scan () : détection de clé et traitement
Description des paramètres:
******************************************** *** *********** /
void scan ()
{ if (P3! = 0xff) // Il y a un bouton d'appel pour appuyer sur { if (key_1 == 0) // Si le quartier 1 appelle { NRFSetTxMode ( "1"); // Envoyer des données
while (NRFCheckACK ()); // Vérifie si la transmission est terminée
}
if (key_2 == 0) // Si le quartier 2 appelle
{ NRFSetTxMode ("2"); // Envoie des données while (NRFCheckACK ()); // Vérifier si la transmission est terminée } if (key_3 == 0) // Si le quartier 3 appelle { NRFSetTxMode ("3"); // Envoyer les données while (NRFCheckACK ()); // Vérifier si la transmission est terminée } if ( key_4 == 0) // Si le quartier n ° 4 appelle { NRFSetTxMode ("4"); // Envoie des données while (NRFCheckACK ()); // Vérifie si la transmission est terminée } if (key_5 == 0) // Si le quartier n ° 5 appelle {
NRFSetTxMode ("5"); // Envoyer des données
while (NRFCheckACK ()); // Vérifier si la transmission est terminée
}
if (key_6 == 0) // Si le quartier 6 appelle
{ NRFSetTxMode ("6"); // Send Data while (NRFCheckACK ()); // Vérifie si la transmission est terminée } if (key_7 == 0) // Si le quartier 7 appelle { NRFSetTxMode ("7"); // Envoie des données while (NRFCheckACK ()); // Vérifier si la transmission est terminée } if (key_8 == 0) // Si le service n ° 8 appelle { NRFSetTxMode ("8"); // Envoi des données pendant (NRFCheckACK ()); // Vérifier si la transmission est terminé } } }
/ ************************************************* *******
Nom de la fonction: void main ()
Rôle de la fonction: Fonction principale
Description du paramètre:
**************************** **************************** /
void main ()
{ NRF24L01Int (); // NRF24L01 initialiser while (1) // Boucle infinie { scan (); // LED de détection et de traitement des touches = ~ led; // indicateur de travail LED } }