Se requiere utilizar el transceptor inalámbrico nrf24L01 y el microcontrolador stc89C51 para implementar el programa del transceptor inalámbrico. Un extremo controla y el otro extremo muestra.

#include

typedef unsigned char uchar;

typedef unsigned char uint;

//******************************************Definición de puerto IO*** ************************************

sbit MISO =P2^4;

bit MOSI =P1^3;

bit SCK =P1^4

bit CE =P1^5

bit; CSN =P1^6;

bit IRQ =P3^2

//*********************; * **************** Código de tubo digital 0-9** ************************* *** *************

uchar seg[10]={0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90} ; // 0~~9 código de segmento

uchar TxBuf[32]=

{

0x08,0x02,0x03,0x4,0x05,0x06,0x07 ,0x08,

0x09,0x01,0x02,0x03,0x04,0x05,0x06,0x07,

0x08, 0x09,0x01,0x02,0x03,0x04,0x05,0x06,

0x07,0x08,0x09,0x00,0x01,0x02,0x03,0x04

};

//********** *** *************** ******* Botón************************ ****** *******************

bit KEY1=P2^0;

bit KEY2=P2 ^1;

/************************ ************* Selección de broca de tubería digital ****** ********************************************** *

bit led0=P1^0;

bit led1=P1^1;

bit led2=P1^2;

/sbit led3 =P1^3;

//****************************** ******* **********NRF24L01********************************* *********

#define TX_ADR_WIDTH 5 // 5 uints ancho de dirección TX

#define RX_ADR_WIDTH 5 // 5 uints ancho de dirección RX

#define TX_PLOAD_WIDTH 32 // 20 uints de carga útil TX válida

#define RX_PLOAD_WIDTH 32 // 20 uints de carga útil RX

uint const TX_

DIRECCIÓN[TX_ADR_WIDTH]= {0x34, 0x43,0x10,0x10,0x01};//Dirección local

uint const RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};//Recibir Dirección

//****************************************** NRF24L01 Instrucciones de registro************************************************ * *******

#define READ_REG 0x00 //Leer comando de registro

#define WRITE_REG 0x20 //WRITE_REG 0x20 //Escribir comando de registro

#define RD_RX_PLOAD 0x61 // Leer comando de datos recibidos

#define WR_TX_PLOAD 0xA0 // Escribir comando de datos pendientes

#define FLUSH_TX 0xE1 // Enviar comando FIFO de vaciado

#definidoefine FLUSH_TX 0xE1 // Vaciar el comando FIFO de envío

#define FLUSH_TX 0xE1 // Vaciar el comando FIFO de envío

#define FLUSH_RX 0xE2 // Vaciar el comando FIFO de recepción

#define REUSE_TX_PL 0xE3 //Definir comando de carga de datos repetidos

#define NOP 0xFF //Reservado

//********** ** ************ ************Dirección de registro SPI(nRF24L01)***************** ***** **********************************

#define CONFIG 0x00 / /Configurar estado de envío/recepción, modo de verificación CRC y modo de respuesta de estado de envío/recepción

#define EN_AA 0x01 //Configuración de la función de respuesta automática

#define EN_RXADDR 0x02 //Canal disponible settings

#define SETUP_AW 0x03 // Enviar/recibir ancho de dirección.

Configuración del ancho de la dirección de envío/recepción

#define SETUP_RETR 0x04 // Configuración de la función de retransmisión automática

#define RF_CH 0x05 // Configuración de la frecuencia de trabajo

#define RF_SETUP 0x06 // Configuración de la función de velocidad de transmisión y consumo de energía

#define STATUS 0x07 // Registro de estado

#define OBSERVE_TX 0x08 // Función de monitoreo de transmisión

#define CD 0x09 // Detección de dirección

#define RX_ADDR_P0 0x0A // Dirección de recepción de datos del canal 0

#define RX_ADDR_P1 0x0B // Dirección de recepción de datos del canal 1

# define RX_ADDR_P20x0C // Dirección de recepción de datos del canal 2

#define RX_ADDR_P3 0x0D // Dirección de recepción de datos del canal 3

#define RX_ADDR_P4 0x0E // Dirección de recepción de datos del canal 4

#define RX_ADDR_P5 0x0A // Dirección de recepción de datos del canal 4

#define RX_ADDR_P5 0x0B // Dirección de recepción de datos del canal 4

#define RX_ADDR_P5 0x0F // Dirección de recepción de datos del canal 5

}

/************************************ ************************************************* ***** **********************

/* Función: uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars )

/* Función: utilizada para escribir datos: dirección de registro, pBuf: dirección de datos a escribir, uchars: número de datos a escribir

/****** ****** ****** **************************************** ********** **************************************** *****/

uint SPI_Write_Buf(uchar reg, uchar * pBuf, uchar uchars)

{

uint status,uchar_ctr

CSN = 0; //Habilitar SPI

estado = SPI_RW(reg);

Retraso(10);

for( uchar_ctr=0; uchar_ctr

SPI_RW(*pBuf++);

CSN = 1; // Cerrar SPI

return(status);

}

/* ********************************* ********** **************************************** *********** ******/

/* Función: void SetTX_Mode( void)

/* Función: Configuración de recepción de datos

/***** **************************************** ****

************************************************** * *

void SetTX_Mode(void)

{

CE=0;

SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e); / Respuesta de interrupción de finalización de transmisión/recepción IRQ, CRC de 16 bits, transmisión principal

CE = 1

inerDelay_us(300);

}

/********************************************* ** ********************************************** ** ** *****/

/*Función: unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)

/*Función: leer los datos y luego colocarlos en el rx_buf de recepción búfer

/****************************************** *** ************************************************* **** **********/

carácter sin firmar nRF24L01_RxPacket(carácter sin firmar* rx_buf)

{

carbón sin firmar revale= 0;

SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f); // Respuesta de interrupción de finalización de transmisión/recepción IRQ, CRC de 16 bits, recepción principal

CE=1;

inerDelay_us (300);/ /406us

sta=SPI_Read(STATUS); // Lee el registro de estado para determinar el estado de recepción de datos

if(RX_DR) // Determina si los datos se ha recibido

{

CE = 0;

SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH // Lee la carga útil de recepción del búfer RX_FIFO

revale = 1; // Leer indicador de finalización de datos

}

SPI_RW_Reg(WRITE_REG+STATUS,sta); //Después de recibir datos, RX_DR, TX_DS, MAX_PT; el nivel alto se establece en 1, escriba 1 para borrar el indicador de interrupción

return revale;

}

/********** ******** * ******************************************* ********** **************************************** **

/*Función: void nRF24L01_TxPacket( unsigned char * tx_buf)

/*Función: Enviar los datos en tx_buf

/***** ******************* ******************************* ********************** ********** ********************** *******/

void nRF24L01_TxPacket(carácter sin firmar *t

x_buf)

{

CE=0; //Modo StandBy I

SPI_Write_Buf( WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);

SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH); // Cargar datos

SPI_RW _Reg(WRITE_REG + CONFIG, 0x0e); // Respuesta de interrupción de finalización de transmisión/recepción de IRQ, 16 bits CRC, la estación maestra envía

CE=1; // Establece CE en nivel alto para estimular el envío de datos

inerDelay_us(50);

CE=0

}

//

void anjian(void)

{

if(KEY1== 0 )

{

inerDelay_us(50);

led0=~led0;

if(KEY1==0)

{

nRF24L01_TxPacket(TxBuf);

Retraso(20000);

SPI_RW_Reg(WRITE_REG+STATUS,0XFF);

CLAVE1=1;

}

}

}

/******* **************************** función principal********************* *** ****************************************

nulo principal( void )

{

uchar i=0;

uchar TxBuf[32];

led0=0;

led1=0;

led2=0;

//nRF24L01_TxPacket(TxBuf); //Transmitir datos del buffer Tx

Retraso(6000)

while(1)

{

//SPI_RW();

init_NRF24L01();

SetTX_Mode();

anjian();

nRF24L01_TxPacket(TxBuf); // Transmite datos del buffer Tx

if(TX_DS)

{

led1=~led1; //El LED de 8 bits muestra el estado actual. La interrupción de transmisión de ESTADO debe estar habilitada. bit5 = 1, la luz está apagada.

bit5 = 1 luz apagada

Retraso(100);

SPI_RW_Reg(WRITE_REG + STATUS,sta);

}

if( MAX_RT) //Si es un tiempo de espera de envío

{

led2=~led2; //Tiempo de espera de envío LED de 8 bits bit4 = 1 luz apagada

Retraso ( 150);

SPI_RW_Reg(WRITE_REG + STATUS,sta);

}

}

//nRF24L01_TxPacket(TxBuf); //Transmitir datos del búfer de Tx

if(MAX_RT) Transmitir datos del búfer de Tx

SPI_RW_Reg(WRITE_REG+STATUS,0XFF);

}