MSP430+nRF24L01 Program

Source: Internet
Rewritten by: bluefeel
Time: 10-03-13
Unit: Guilin University of Technology
/******************************************************/

#include
#include

#define uchar unsigned char

/***************************************************/
#define TX_ADR_WIDTH 5 // 5-byte width of the send/receive address
#define TX_PLOAD_WIDTH 4 // Data channel effective data width
#define LED P2

uchar code TX_ADDRESS[TX_ADR_WIDTH] = {0x34,0x43,0x10,0x10,0x01}; // Define a static transmit address
uchar RX_BUF[TX_PLOAD_WIDTH];
uchar TX_BUF[TX_PLOAD_WIDTH];
uchar flag;
uchar DATA = 0x01;
uchar bdata sta;
sbit RX_DR = sta^6;
sbit TX_DS = sta^5;
sbit MAX_RT = sta^4;
/***************************************************/

/**************************************************
Function: init_io()

Description:
    Initialize IO
/************************************************/
void init_io(void)
{
    CE = 0; // Standby
    CSN = 1; // SPI disable
    SCK = 0; // SPI clock low
    IRQ = 1; // Interrupt reset
    LED = 0xff; // Turn off the indicator light
}
/***************************************************/

/**************************************************
Function: delay_ms()

Description:
    Delay x milliseconds
/************************************************/
void delay_ms(uchar x)
{
    uchar i, j;
    i = 0;
    for(i=0; i     {
       j = 250;
       while(--j);
       j = 250;
       while(--j);
    }
}
/***************************************************/

/**************************************************
Function: SPI_RW()

Description:
    According to the SPI protocol, write one byte of data to nRF24L01 and
    read one byte from nRF24L01 at the same time
. /**************************************************/
uchar SPI_RW(uchar byte)
{
    uchar i;
    for(i=0; i<8; i++) // Loop 8 times
    {
        MOSI = (byte & 0x80); // byte outputs the highest bit to MOSI
        byte <<= 1; // shift the lower bit to the highest bit
        SCK = 1; // pull SCK high, nRF24L01 reads 1 bit of data from MOSI and outputs 1 bit of data from MISO
        byte |= MISO; // read MISO to the lowest bit of byte
        SCK = 0; // SCK is set low
    }
    return(byte); // return the read byte
}
/******************************************************/

/**************************************************
Function: SPI_RW_Reg()

Description:
    Write data value to register reg
/************************************************/
uchar SPI_RW_Reg(uchar reg, uchar value)
{
    uchar status;
    CSN = 0; // Set CSN low to start data transmission
    status = SPI_RW(reg); // Select register and return status word
    SPI_RW(value); // Then write data to the register
    CSN = 1; // Pull CSN high to end data transmission
    return(status); // Return to status register
}
/******************************************************/

/**************************************************
Function: SPI_Read()

Description:
    Read one byte from register reg
/************************************************/
uchar SPI_Read(uchar reg)
{
    uchar reg_val;
    CSN = 0; // Set CSN low to start data transmission
    SPI_RW(reg); // Select register
    reg_val = SPI_RW(0); // Then read data from this register
    CSN = 1; // Pull CSN high to end data transmission
    return(reg_val); // Return register data
}
/******************************************************/

/**************************************************
Function: SPI_Read_Buf()

Description:
    Read bytes bytes from the reg register, usually used to read the receiving channel
    data or the receiving/sending address./****************************************************/
uchar
SPI_Read_Buf(uchar reg, uchar * pBuf, uchar bytes)
{
    uchar status, i;
    CSN = 0; // Set CSN low to start data transmission
    status = SPI_RW(reg); // Select register and return status word
    for(i=0; i         pBuf[i] = SPI_RW(0); // Read bytes from nRF24L01 one by one
    CSN = 1; // Pull CSN high to end data transmission
    return(status); // Return to status register
}[page]
/******************************************************/

/**************************************************
Function: SPI_Write_Buf()

Description:
    Write the data in the pBuf buffer to the nRF24L01, usually used to write the
    transmit channel data or receive/send address
/**************************************************/
uchar SPI_Write_Buf(uchar reg, uchar * pBuf, uchar bytes)
{
    uchar status, i;
    CSN = 0; // Set CSN low to start data transmission
    status = SPI_RW(reg); // Select register and return status word
    for(i=0; i         SPI_RW(pBuf[i]); // Write to nRF24L01 byte by byte
    CSN = 1; // Pull CSN high to end data transmission
    return(status); // Return to status register
}
/******************************************************/

/******************************************************
Function: RX_Mode()

Description:
    This function sets the nRF24L01 to receive mode, waiting to receive data packets from the transmitting device.
/**************************************************/
void RX_Mode(void)
{
    CE = 0;
    SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // The receiving device receives channel 0 using the same transmit address as the transmitting device
    SPI_RW_Reg(WRITE_REG + EN_AA, 0x01); // Enable automatic response of receiving channel
    0 SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); // Enable receiving channel 0
    SPI_RW_Reg(WRITE_REG + RF_CH, 40); // Select RF channel 0x40
    SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH); // Select the same effective data width for receiving channel 0 as for transmitting channel
    SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07); // Data transmission rate 1Mbps, transmit power 0dBm, low noise amplifier gain
    SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f); // CRC enable, 16-bit CRC check, power on, receiving mode
    CE = 1; // Pull CE high to start the receiving device
}
/******************************************************/

/**************************************************
Function: TX_Mode()

Description:
    This function sets nRF24L01 to transmit mode (CE=1 for at least 10us),
    starts transmitting after 130us, and after data transmission is completed, the transmitting module automatically switches to receive
    mode and waits for the response signal.
/******************************************************/
void TX_Mode(uchar * BUF)
{
    CE = 0;
    SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH); // Write transmit address
    SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // In order to respond to the receiving device, the receiving channel 0 address is the same as the transmit address
    SPI_Write_Buf(WR_TX_PLOAD, BUF, TX_PLOAD_WIDTH); // Write data packet to TX FIFO
    SPI_RW_Reg(WRITE_REG + EN_AA, 0x01); // Enable receive channel 0 to automatically respond
    SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); // Enable receive channel 0
    SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x0a); // Automatic retransmission delay wait 250us+86us, automatic retransmission 10 times
    SPI_RW_Reg(WRITE_REG + RF_CH, 40); // Select RF channel 0x40
    SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07); // Data transmission rate 1Mbps, transmission power 0dBm, low noise amplifier gain
    SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e); // CRC enable, 16-bit CRC check, power-on
    CE = 1;
}
/******************************************************/

/**************************************************
Function: Check_ACK()

Description:
    Check whether the receiving device has received the data packet, and set whether to resend if no acknowledgement
    signal .
/************************************************/
uchar Check_ACK(bit clear)
{
    while(IRQ);
    sta = SPI_RW(NOP); // Return to status register
    if(MAX_RT)
        if(clear) // Whether to clear TX FIFO, if not clear, resend after resetting the MAX_RT interrupt flag
            SPI_RW(FLUSH_TX);
    SPI_RW_Reg(WRITE_REG + STATUS, sta); // Clear TX_DS or MAX_RT interrupt flag
    IRQ = 1;
    if(TX_DS)
        return(0x00);
    else
        return(0xff);
}
/******************************************************/

/**************************************************
Function: CheckButtons()

Description:
    Check if a button is pressed. If pressed, send a byte of data.
/******************************************************/
void CheckButtons()
{
    P3 |= 0x00;
    if(!(P3 & 0x01)) // Read P3^0 status
    {
        delay_ms(20);
        if(!(P3 & 0x01)) // Read P3^0 status
        {
            TX_BUF[0] = ~DATA; // Data is sent to the buffer
            TX_Mode(TX_BUF); // Set nRF24L01 to transmit mode and send data
            LED = ~DATA; // Data is sent to LED for display
            Check_ACK(1); // Wait for transmission to complete and clear TX FIFO
            delay_ms(250);
            delay_ms(250);
            LED = 0xff; // Turn off LED
            RX_Mode(); // Set to receive mode
            while(!(P3 & 0x01));
            DATA <<= 1;
            if(!DATA)
                DATA = 0x01;
        }
    }
}
/******************************************************/

/******************************************************
Function: main()

Description:
    Main function
/******************************************************/
void main(void)
{
    init_io(); // Initialize IO
    RX_Mode(); // Set to receive modewhile
    (1)
    {
        CheckButtons(); // Button scan
        sta = SPI_Read(STATUS); // Read status registerif
        (RX_DR) // Determine whether data is received
        {
            SPI_Read_Buf(RD_RX_PLOAD, RX_BUF, TX_PLOAD_WIDTH); // Read data from RX FIFOflag
            = 1;
        }
        SPI_RW_Reg(WRITE_REG + STATUS, sta); // Clear RX_DS interrupt flagif
        (flag) // Acceptance completed
        {
            flag = 0; // Clear flagLED
            = RX_BUF[0]; // Data is sent to LED displaydelay_ms
            (250);
            delay_ms(250);
            LED = 0xff; // Turn off LED
        }
    }
}
/******************************************************/