Lo siguiente se basa en 51 microcomputadoras de un solo chip, el código es simplificado y no tiene sentido, directamente en el código. (Si necesita otros microcontroladores como STM32, puede confiar en mí en privado)
/ ********************************************** ************
Archivo de encabezado NRF24L01
*********************************************** ************* /
#ifndef _NRF24L01_H_
#define _NRF24L01_H_
#include <reg52.h>
#define uchar unsigned char
#define uint unsigned int
#define TX_ADDR_WITDH 5 // Establezca el ancho de la dirección de envío en 5 bytes
#define RX_ADDR_WITDH 5 // Establezca el ancho de la dirección de recepción en 5 bytes
#define TX_DATA_WITDH 1 // Ancho de los datos de envío
#define RX_DATA_WITDH 1 // Ancho de los datos de recepción
/ * ** **************** Registro de comandos ************************** /
#define R_REGISTER 0x00 // Leer registro de configuración
#define W_REGISTER 0x20 // Escribir registro de configuración
#define R_RX_PAYLOAD 0x61 // Leer datos válidos de RX
#define W_TX_PAYLOAD 0xa0 // Escribir datos válidos de TX
#define FLUSH_TX 0xe1 // Borrar registro
TXFIFO #define FLUSH ClearRX 0xe2 // Registro RXFIFO
/ ****************** dirección de registro ********************* ***** /
#define CONFIG 0x00 // Registro de configuración
#define EN_AA 0x01 // Habilitar respuesta automática
#define EN_RXADDR 0x02 // Canal de recepción habilitar 0-5 canales
#define SETUP_RETR 0x04 // Establezca retransmisión automática
#define RF_CH 0x05 // Ajuste del canal RF
#define RF_SETUP 0x06 // Registro RF
#define STATUS 0x07 // Registro de estado
#define RX_ADDR_P0 0x0a // Dirección de recepción del canal de datos 0
#define TX_ADDR 0x10 / Enviar dirección
#define RX_PW_P0 0x11 // Configuración de ancho de datos del canal P0
/ ******************** Definición de función NRF24L01 ********* ** ************* /
uchar NRFACK (); // Función de retardo
void NRF24L01Int (); // Función de inicialización
NRF24L01 uchar NRFSPI (fecha uchar); // sincronización SPI
uchar NRFReadReg (uchar RegAddr) ; // Función de registro de 1 byte de lectura SPI
uchar NRFWriteReg (RegAddr de uchar, fecha de uchar); // Función de registro de 1 byte de escritura de SPI
uchar NRFReadRxDate (uchar RegAddr, uchar * RxDate, uchar DateLen); // SPI lee datos
RXFIFO uchar NRFWriteTxDate (uchar RegAddr, uchar * TxDate, uchar DateLen); // SPI escribe datos en TXFIFO *
void NRFSetchar; / NRF está configurado para enviar modo y enviar datos
uchar NRFCheckACK (); // usado para enviar modo para recibir señal de respuesta
void NRFSetRXMode (); // NRF está configurado para recibir modo y recibir datos
void NRFGetDate (); // recibir datos
/ ********************** Definición de pin NRF24L01 *********************** /
sbit CE = P2 ^ 7; // terminal de selección de modo RX / TX
sbit IRQ = P2 ^ 4; // terminal de interrupción enmascarable
sbit CSN = P2 ^ 2; // terminal de selección de chip SPI // es SS
sbit MOSI = P2 ^ 3; // Salida maestra SPI Terminal de entrada esclava
sbit MISO = P2 ^ 5; // Entrada maestra SPI Terminal de salida esclava
sbit SCLK = P2 ^ 6; // Terminal de reloj SPI
/ ********************** NRF24L01 definición de variable *********************** ** /
uchar RevTempDate [2]; // Recibir el
código uchar del búfer de datos TxAddr [] = {0x34,0x43,0x10,0x10,0x01}; // Enviar dirección
/ ************* ** ******* NRF24L01 indicador de estado ************************ /
uchar bdata sta; // indicador de estado
sbit RX_DR = sta ^ 6; // Recibir bandera completa
sbit TX_DS = sta ^ 5; // Enviar bandera completa
sbit MAX_RT = sta ^ 4; // Recibir bandera de longitud máxima
/ ***************** * ***************************************
nombre de la función: void NRFDelay (uint t)
la función función: Función de retardo
Descripción del parámetro:
**************************************** ************** /
void NRFDelay (uint t)
{ uint x, y; para (x = t; x> 0; x--) para (y = 110; y> 0 ; y--); }
/ ********************************************** ********
Nombre de la función: void NRF24L01Int ()
Función: Función de inicialización NRF24L01
Descripción del parámetro:
************************** * ****************************** /
void NRF24L01Int ()
{ NRFDelay (2); // Retardo de encendido CE = 0 ; // Establecer en modo de recepción CSN = 1; // Desactivar la selección de chip SCLK = 0; // Bajar la línea de señal del reloj IRQ = 1; // Desactivar la habilitación de interrupciones } / ********* ** ********************************************* Nombre de la función : Función uchar NRFSPI (fecha uchar) Función: sincronización SPI Descripción del parámetro: ********************************* ** ******************** / uchar NRFSPI (fecha uchar) { uchar i;
for (i = 0; i <8; i ++) // Loop 8 veces, envía datos de 8 bits, envía y recibe datos de mayor a menor
{ if (date & 0x80) // data is 1 MOSI = 1; else MOSI = 0 ; fecha << = 1; // Mueve un bit a la izquierda SCLK = 1; // Tira hacia arriba de la línea de señal del reloj si (MISO) // nRF24L01 lee datos de 1 bit de MOSI y genera datos de 1 bit de la fecha de MISO | = 0x01; // Leer MISO al bit más bajo del byte SCLK = 0; // Bajar la línea de señal del reloj } return (date); // Devolver el byte leído } / *********** ** ******************************************* Nombre de la función: uchar Función de función NRFReadReg (uchar RegAddr) : Registro de lectura SPI Función de 1 byte Descripción del parámetro: Dirección de registro RegAddr ***************************** ************************** /
uchar NRFReadReg (uchar RegAddr)
{ uchar BackDate; // Definir usado para almacenar temporalmente los datos recibidos CSN = 0; // Iniciar secuencia NRFSPI (RegAddr); // Escribir dirección de registro BackDate = NRFSPI (0x00); // Escribir para leer registro Comando CSN = 1; // Cerrar secuencia return (BackDate); // Devolver datos } / **************************** *************************** Nombre de la función: uchar NRFWriteReg (uchar RegAddr, uchar date) Función: Registro de escritura SPI Parámetro de función de 1 byte Descripción : Dirección de registro RegAddr, fecha para escribir los datos ************************************** ******************* / uchar NRFWriteReg (uchar RegAddr, uchar date) { uchar BackDate; // Definir usado para almacenar temporalmente los datos recibidos CSN = 0; // Iniciar secuencia
BackDate = NRFSPI (RegAddr); // Escribir dirección de registro
NRFSPI (fecha); // Escribir datos
CSN = 1; // Cerrar secuencia
return (BackDate); // Devolver datos
}
/ ******** ** ******************************************
Nombre de función: uchar NRFReadRxDate ( uchar RegAddr, uchar * RxDate, uchar DateLen)
Función: SPI lee datos RXFIFO
Descripción del parámetro: dirección de registro RegAddr, * datos de lectura RxDate, longitud de datos DateLen
********* ********** ************************************ /
uchar NRFReadRxDate (uchar RegAddr, uchar * RxDate, uchar DateLen )
{
uchar BackDate, i;
CSN = 0; // Secuencia de inicio
BackDate = NRFSPI (RegAddr); // Escriba la dirección del registro para leer
(i = 0; i <DateLen; i ++) // Leer datos
{
RxDate [i] = NRFSPI (0);
}
CSN = 1; // Cerrar secuencia
retorno (BackDate); // Estado de retorno
}
/ ******************** ************************************
Nombre de la función: uchar NRFReadRxDate (uchar RegAddr, uchar * RxDate, uchar DateLen)
Función: SPI escribe datos en TXFIFO.
Descripción del parámetro: dirección de registro RegAddr, * RxDate datos enviados, longitud de datos DateLen
********************** ** ********************************* /
uchar NRFWriteTxDate (uchar RegAddr, uchar * TxDate, uchar DateLen)
{ uchar BackDate , i; CSN = 0; // Iniciar secuencia BackDate = NRFSPI (RegAddr); // Escribir la dirección que se escribirá en el registro para (i = 0; i <DateLen; i ++) // Escribir datos { NRFSPI (* TxDate ++ );
}
CSN = 1; // Cerrar secuencia
return (BackDate); // Devolver estado
}
/ **************************** ***************************
Nombre de la función: void NRFSetTxMode (uchar * TxDate)
Función: NRF está configurado para enviar modo y enviar
parámetro de datos descripción:
********************************************** * ******** /
void NRFSetTxMode (uchar * TxDate)
{
CE = 0;
NRFWriteTxDate (W_REGISTER + TX_ADDR, TxAddr, TX_ADDR_WITDH); // Comando de registro de escritura + comando de habilitación de dirección P0 + dirección de envío + ancho de dirección
NRFWriteTxDate (W_REGISTER + RX_ADDR_P0, TxAddr, TX_ADDR_WITDH); // Para responder al dispositivo receptor, la dirección del canal receptor 0 es la misma que la dirección de envío
NRFWriteTxDate (W_TX_PAYLOAD, TxDate, TX_DATA_WITDH); // Escribir datos
/ *** *** La siguiente configuración de registro ************** /
NRFWriteReg (W_REGISTER + EN_AA, 0x01); // Habilita la respuesta automática del canal de recepción 0
NRFWriteReg (W_REGISTER + EN_RXADDR, 0x01); // Habilita el canal de recepción 0
NRFWriteReg (W_REGISTER + SETUP_RETR, 0x0a); // Espera para retransmisión automática 86us, y retransmite automáticamente 10 veces
NRFWriteReg (W_REGISTER + RF_CH, 0x40); // Seleccione el canal RF 0x40
NRFWriteReg (W_REGISTER + RF_SETUP, 0x07); // Velocidad de transmisión de datos 1 Mbps, potencia de transmisión 0dBm, ganancia de amplificador de bajo ruido
NRF_WriteReg ( CONFIG, 0x0e); // Habilitación de CRC, verificación de CRC de 16 bits, encendido
CE = 1;
NRFDelay (5); // Retraso, asegúrese de que el modo de configuración tenga efecto
}
/ ******** ** *******************************************
Nombre de función: uchar NRFCheckACK ( )
Función: Se utiliza para recibir la señal de respuesta en el modo de envío
Descripción del parámetro:
****************************** ***** ********************* /
uchar NRFCheckACK ()
{
sta = NRFReadReg (R_REGISTER + STATUS); // Regresar al registro de estado
si (TX_DS || MAX_RT) // Enviar interrupción completa
{ NRFWriteReg (W_REGISTER + STATUS, 0xff); // Borrar el indicador de interrupción TX_DS o MAX_RT CSN = 0; // Secuencia de inicio NRFSPI (FLUSH_TX); // Se usa para borrar TXFIFO CSN = 1; // Se cierra la secuencia return (0); // La transmisión de datos es exitosa, regresa 0 } else return (1); // Datos no enviados correctamente, devuelva 1 } / ************************************** ** ************** Nombre de la función: void NRFSetRXMode () Rol de la función: NRF está configurado para recibir el modo y recibir datos Descripción del parámetro:
*********************************************** ******* /
void NRFSetRXMode ()
{ CE = 0; NRFWriteTxDate (W_REGISTER + RX_ADDR_P0, TxAddr, TX_ADDR_WITDH); // El dispositivo receptor recibe el canal 0 usando la misma dirección de envío que el dispositivo emisor NRFWriteReg (W_REGATER + , 0x01); // Habilitar la respuesta automática del canal de recepción 0 NRFWriteReg (W_REGISTER + EN_RXADDR, 0x01); // Habilitar el canal de recepción 0 NRFWriteReg (W_REGISTER + RF_CH, 0x40); // Seleccionar el canal de RF 0x40 NRFWriteReg (W_REGISTER + RXIT_PWDATA) ; // El canal de recepción 0 selecciona el mismo ancho de datos efectivo que el canal de transmisión NRFWriteReg (W_REGISTER + RF_SETUP, 0x07); // Velocidad de transmisión de datos 1Mbps, potencia de transmisión 0dBm, ganancia del amplificador de bajo ruido NRFWriteReg (W_REGISTER + CONFIG, 0x0f); / / Habilitar CRC, verificación CRC de 16 bits, encendido, modo de recepción CE = 1;
NRFDelay (5); // Retraso, asegúrese de que el modo de configuración tenga efecto
}
/ ****************************** ** ***********************
Nombre de la función: void NRFGetDate ()
Función: Recibir datos
Descripción del parámetro:
*********** * ******************************************* /
void NRFGetDate ( )
{ sta = NRFReadReg (R_REGISTER + STATUS); // Leer el registro de estado después de enviar datos if (RX_DR) // Determinar si se reciben datos { CE = 0; // Standby NRFReadRxDate (R_RX_PAYLOAD, RevTempDate, RX_DATA_WITDH); // El esclavo RXFIFO lee los datos NRFWriteReg (W_REGISTER + STATUS, 0xff); // Después de recibir los datos, RX_DR, TX_DS, MAX_PT se establecen en 1 y la bandera de interrupción se borra escribiendo 1 CSN = 0; // Iniciar secuencia
NRFSPI (FLUSH_RX); // Se usa para borrar FIFO
CSN = 1; // Cerrar secuencia
}
}
#endif
Página de función principal
/ ********************************************** ************
Terminal de llamada del sistema de llamada de sala inalámbrico
Explicación complementaria:
********************************************* **************** /
#include <reg52.h>
#include <NRF24L01.h>
/ ************************** Definición de pin ******************** * ******* /
sbit key_1 = P3 ^ 0; // Ocho botones de llamada
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; // indicador LED de trabajo
/ *************** *** *************************************
Nombre de la función: void scan ()
función función: detección de teclas y procesamiento
Descripción del parámetro:
**************************************** *** *********** /
void scan ()
{ if (P3! = 0xff) // Hay un botón de llamada para presionar { if (key_1 == 0) // Si el pabellón 1 llama a { NRFSetTxMode ( "1"); // Enviar datos
while (NRFCheckACK ()); // Compruebe si la transmisión está completa
}
if (key_2 == 0) // Si el pabellón 2 llama
{ NRFSetTxMode ("2"); // Enviar datos while (NRFCheckACK ()); // Verificar si la transmisión está completa } if (key_3 == 0) // Si el pabellón 3 llama a { NRFSetTxMode ("3"); // Enviar datos while (NRFCheckACK ()); // Verificar si la transmisión está completa } if ( key_4 == 0) // Si el Ward No. 4 llama a { NRFSetTxMode ("4"); // Enviar datos while (NRFCheckACK ()); // Verificar si la transmisión está completa } if (key_5 == 0) // Si el Distrito No. 5 llama {
NRFSetTxMode ("5"); // Enviar datos
while (NRFCheckACK ()); // Verificar si la transmisión se completó
}
if (key_6 == 0) // Si el pabellón 6 llama
{ NRFSetTxMode ("6"); // Enviar datos while (NRFCheckACK ()); // Verificar si la transmisión está completa } if (key_7 == 0) // Si el pabellón 7 llama { NRFSetTxMode ("7"); // Enviar datos while (NRFCheckACK ()); // Verifica si la transmisión se completó } if (key_8 == 0) // Si el pupilo No. 8 llama a { NRFSetTxMode ("8"); // Envía datos while (NRFCheckACK ()); // Verifica si la transmisión se completa } } }
/ ********************************************** *******
Nombre de la función: void main ()
Función de la función: Función principal
Descripción del parámetro:
************************** **************************** /
void main ()
{ NRF24L01Int (); // NRF24L01 inicializar while (1) // Bucle infinito { scan () ; // LED de detección y procesamiento de teclas = ~ led; // LED indicador de trabajo } }