#include "xl2400.h"

Functions
void	XL2400_WriteByte (uint8_t value)

uint8_t	XL2400_ReadByte (void)

void	XL2400_WriteReg (uint8_t reg, uint8_t value)

uint8_t	XL2400_ReadReg (uint8_t reg)

void	XL2400_WriteFromBuf (uint8_t reg, const uint8_t *pBuf, uint8_t len)

void	XL2400_ReadToBuf (uint8_t reg, uint8_t *pBuf, uint8_t len)

void	XL2400_CE_Low (void)

void	XL2400_CE_High (void)

uint8_t	XL2400_SPI_Test (void)

void	XL2400_Init (void)

void	XL2400_SetChannel (uint8_t channel)

void	XL2400_SetTxAddress (uint8_t *address)

void	XL2400_SetRxAddress (uint8_t *address)

void	XL2400_SetPower (uint8_t power)

void	XL2400_Sleep (void)

void	XL2400_WakeUp (void)

uint8_t	XL2400_RxCalibrate (void)

void	XL2400_SetTxMode (void)

void	XL2400_SetRxMode (void)

uint8_t	XL2400_Tx (uint8_t *ucPayload, uint8_t length)

uint8_t	XL2400_Rx (void)

uint8_t	XL2400_ReadStatus (void)

void	XL2400_ClearStatus (void)

void	XL2400_FlushRxTX (void)

void	XL2400_CarrierTest (void)

uint8_t	XL2400_PrintStatus (void)

Variables
__IDATA uint8_t	cbuf [2]

__IDATA uint8_t	xbuf [XL2400_PL_WIDTH_MAX+1]

Function Documentation

◆ XL2400_CarrierTest()

void XL2400_CarrierTest ( void )

Definition at line 343 of file xl2400.c.

{
    XL2400_CE_Low();
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_ANALOG_CFG0, xbuf, 13);
    *(xbuf + 12) |= 0x40;
    *(xbuf + 4) &= ~0x04;
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_ANALOG_CFG0, xbuf, 13);
    XL2400_WriteReg(XL2400_CMD_W_REGISTER | XL2400_REG_TXPROC_CFG, 0x00);
    *(xbuf + 0) = 0x01;
    *(xbuf + 1) = 0x00;
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_RF_SETUP, xbuf, 2);
    XL2400_ClearStatus();
}

◆ XL2400_CE_High()

void XL2400_CE_High ( void )

Definition at line 121 of file xl2400.c.

{
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_CFG_TOP, cbuf, 2);
    *(cbuf + 1) |= 0x40;
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_CFG_TOP, cbuf, 2);
}

◆ XL2400_CE_Low()

void XL2400_CE_Low ( void )

Definition at line 114 of file xl2400.c.

{
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_CFG_TOP, cbuf, 2);
    *(cbuf + 1) &= 0xBF;
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_CFG_TOP, cbuf, 2);
}

◆ XL2400_ClearStatus()

void XL2400_ClearStatus ( void )

Definition at line 330 of file xl2400.c.

{
    XL2400_WriteReg(XL2400_CMD_FLUSH_TX, XL2400_CMD_NOP);
    XL2400_WriteReg(XL2400_CMD_FLUSH_RX, XL2400_CMD_NOP);
    XL2400_WriteReg(XL2400_CMD_W_REGISTER | XL2400_REG_STATUS, 0x70);
}

◆ XL2400_FlushRxTX()

void XL2400_FlushRxTX ( void )

Definition at line 337 of file xl2400.c.

{
    XL2400_WriteReg(XL2400_CMD_FLUSH_TX, XL2400_CMD_NOP);
    XL2400_WriteReg(XL2400_CMD_FLUSH_RX, XL2400_CMD_NOP);
}

◆ XL2400_Init()

void XL2400_Init ( void )

Definition at line 141 of file xl2400.c.

{
    // Analog config
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_ANALOG_CFG0, xbuf, 13);
    *(xbuf + 4) &= ~0x04;
    *(xbuf + 12) |= 0x40;
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_ANALOG_CFG0, xbuf, 13);
    // Switch to software CE control, wake up RF
    XL2400_WakeUp();
    // Enable Auto ACK Pipe 0
    XL2400_WriteReg(XL2400_CMD_W_REGISTER | XL2400_REG_EN_AA, 0x3F);
    // Enable Pipe 0
    XL2400_WriteReg(XL2400_CMD_W_REGISTER | XL2400_REG_EN_RXADDR, 0x3F);
    // Address Width, 5 bytes
    XL2400_WriteReg(XL2400_CMD_W_REGISTER | XL2400_REG_SETUP_AW, 0xAF);
    // Retries and interval
    XL2400_WriteReg(XL2400_CMD_W_REGISTER | XL2400_REG_SETUP_RETR, 0x33);
    // RF Data Rate 1Mbps
    XL2400_WriteReg(XL2400_CMD_W_REGISTER | XL2400_REG_RF_SETUP, 0x22);
    // Number of bytes in RX payload, pipe 0 and pipe 1
    *(cbuf + 0) = XL2400_PLOAD_WIDTH;
    *(cbuf + 1) = XL2400_PLOAD_WIDTH;
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_RX_PW_PX, cbuf, 2);
    // Dynamic payload width: off
    XL2400_WriteReg(XL2400_CMD_W_REGISTER | XL2400_REG_DYNPD, 0x00);
    // Other features
    //bit7&6=00 return status when send register address
    //bit5=0 long data pack off
    //bit4=1 FEC off
    //bit3=1 FEATURE on
    //bit2=0 Dynamic length off
    //bit1=0 ACK without payload
    //bit0=0 W_TX_PAYLOAD_NOACK off
    XL2400_WriteReg(XL2400_CMD_W_REGISTER | XL2400_REG_FEATURE, 0x18);
    // Enable RSSI
    *(cbuf + 0) = 0x10;
    *(cbuf + 1) = 0x00;
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_RSSI, cbuf, 2);
}

◆ XL2400_PrintStatus()

uint8_t XL2400_PrintStatus ( void )

Definition at line 357 of file xl2400.c.

{
    uint8_t i, status;
 
    UART1_TxString("Bytes from low to high: 0,1,2,3,...\r\n[Config]");
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_CFG_TOP, xbuf, 3);
    for (i = 0; i < 3; i++) {
        UART1_TxHex(*(xbuf + i));
    }
 
    UART1_TxString("  [EN_AA]");
    UART1_TxHex(XL2400_ReadReg(XL2400_CMD_R_REGISTER | XL2400_REG_EN_AA));
 
    UART1_TxString("  [EN_RxAddr]");
    UART1_TxHex(XL2400_ReadReg(XL2400_CMD_R_REGISTER | XL2400_REG_EN_RXADDR));
 
    UART1_TxString("  [AddrWidth]");
    UART1_TxHex(XL2400_ReadReg(XL2400_CMD_R_REGISTER | XL2400_REG_SETUP_AW));
 
    UART1_TxString("  [Retry]");
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_SETUP_RETR, xbuf, 4);
    for (i = 0; i < 4; i++) {
        UART1_TxHex(*(xbuf + i));
    }
 
    UART1_TxString("\r\n[RF_Channel]");
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_RF_CH, xbuf, 3);
    for (i = 0; i < 3; i++) {
        UART1_TxHex(*(xbuf + i));
    }
 
    UART1_TxString("  [RF_Setup]");
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_RF_SETUP, xbuf, 2);
    for (i = 0; i < 2; i++) {
        UART1_TxHex(*(xbuf + i));
    }
 
    UART1_TxString("  [Observe_Tx]");
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_OBSERVE_TX, xbuf, 4);
    for (i = 0; i < 4; i++) {
        UART1_TxHex(*(xbuf + i));
    }
 
    UART1_TxString("  [RSSI]");
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_RSSI, xbuf, 2);
    for (i = 0; i < 2; i++) {
        UART1_TxHex(*(xbuf + i));
    }
 
    UART1_TxString("\r\n[TxAddr]  ");
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_TX_ADDR, xbuf, 5);
    for (i = 0; i < 5; i++) {
        UART1_TxHex(*(xbuf + i));
    }
 
    UART1_TxString("\r\n[RxAddrP0]");
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_RX_ADDR_P0, xbuf, 5);
    for (i = 0; i < 5; i++) {
        UART1_TxHex(*(xbuf + i));
    }
    UART1_TxString(" [RxAddrP1]");
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_RX_ADDR_P1, xbuf, 5);
    for (i = 0; i < 5; i++) {
        UART1_TxHex(*(xbuf + i));
    }
    UART1_TxString(" [RxAddrP2-P5]");
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_RX_ADDR_P2_P5, xbuf, 4);
    for (i = 0; i < 4; i++) {
        UART1_TxHex(*(xbuf + i));
    }
 
    UART1_TxString("\r\n[RxPloadWidth_P0-P5]");
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_RX_PW_PX, xbuf, 6);
    for (i = 0; i < 6; i++) {
        UART1_TxHex(*(xbuf + i));
    }
 
    UART1_TxString("\r\n[FIFO_Status]");
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_FIFO_STATUS, xbuf, 3);
    for (i = 0; i < 3; i++) {
        UART1_TxHex(*(xbuf + i));
    }
    UART1_TxString("  [DynPloadWidth]");
    UART1_TxHex(XL2400_ReadReg(XL2400_CMD_R_REGISTER | XL2400_REG_DYNPD));
    UART1_TxString("  [Feature]");
    UART1_TxHex(XL2400_ReadReg(XL2400_CMD_R_REGISTER | XL2400_REG_FEATURE));
 
    status = XL2400_ReadStatus();
    UART1_TxString("\r\n[Status]");
    UART1_TxHex(status);
    UART1_TxString("\r\n\r\n");
    return status;
}

◆ XL2400_ReadByte()

uint8_t XL2400_ReadByte ( void )

Emulate SPI Read on GPIO pins

Definition at line 48 of file xl2400.c.

{
    uint8_t i = 0, RxData;
 
    XL2400_DATA_IN();
    XL2400_CLK_LOW();
    for (i = 0; i < 8; i++)
    {
        RxData = RxData << 1;
        XL2400_CLK_HIGH();
        if (XL2400_DATA_READ())
        {
            RxData |= 0x01;
        }
        else
        {
            RxData &= 0xfe;
        }
        XL2400_CLK_LOW();
    }
    XL2400_CLK_LOW();
    return RxData;
}

◆ XL2400_ReadReg()

uint8_t XL2400_ReadReg ( uint8_t reg )

Definition at line 80 of file xl2400.c.

{
    uint8_t reg_val;
    XL2400_NSS_LOW();
    XL2400_WriteByte(reg);
    reg_val = XL2400_ReadByte();
    XL2400_NSS_HIGH();
    return reg_val;
}

◆ XL2400_ReadStatus()

uint8_t XL2400_ReadStatus ( void )

Definition at line 325 of file xl2400.c.

{
    return XL2400_ReadReg(XL2400_CMD_R_REGISTER | XL2400_REG_STATUS);
}

◆ XL2400_ReadToBuf()

void XL2400_ReadToBuf	(	uint8_t	reg,
		uint8_t *	pBuf,
		uint8_t	len
	)

Definition at line 102 of file xl2400.c.

{
    uint8_t ctr;
    XL2400_NSS_LOW();
    XL2400_WriteByte(reg);
    for (ctr = 0; ctr < len; ctr++)
    {
        pBuf[ctr] = XL2400_ReadByte();
    }
    XL2400_NSS_HIGH();
}

◆ XL2400_Rx()

uint8_t XL2400_Rx ( void )

Definition at line 306 of file xl2400.c.

{
    uint8_t i, status, rxplWidth;
    status = XL2400_ReadStatus();
    if (status & RX_DR_FLAG)
    {
        XL2400_CE_Low();
        rxplWidth = XL2400_ReadReg(XL2400_CMD_R_RX_PL_WID);
        XL2400_ReadToBuf(XL2400_CMD_R_RX_PAYLOAD, xbuf, rxplWidth);
        XL2400_WriteReg(XL2400_CMD_W_REGISTER | XL2400_REG_STATUS, status);
        // UART1_TxChar('>');
        // for (i = 0; i < rxplWidth; i++)
        // {
        //     UART1_TxHex(*(xbuf + i));
        // }
    }
    return status;
}

◆ XL2400_RxCalibrate()

uint8_t XL2400_RxCalibrate ( void )

Definition at line 236 of file xl2400.c.

{
    uint8_t i, j;
    for (i = 0; i < 10; i++)
    {
        SYS_Delay(2);
        XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_ANALOG_CFG3, cbuf, 2);
        *(cbuf + 1) |= 0x90;
        *(cbuf + 1) &= ~0x20;
        XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_ANALOG_CFG3, cbuf, 2);
        *(cbuf + 1) |= 0x40;
        XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_ANALOG_CFG3, cbuf, 2);
        SYS_Delay(1);
        XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_FIFO_STATUS, cbuf, 2);
 
        if (*(cbuf + 1) & 0x20)
        {
            j = *(cbuf + 1) << 3;
            XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_ANALOG_CFG3, cbuf, 2);
            *(cbuf + 1) &= 0x8F;
            *(cbuf + 1) |= 0x20;
            *(cbuf + 0) &= 0x07;
            *(cbuf + 0) |= j;
            XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_ANALOG_CFG3, cbuf, 2);
            return HAL_OK;
        }
    }
    return HAL_ERROR;
}

◆ XL2400_SetChannel()

void XL2400_SetChannel ( uint8_t channel )

Definition at line 181 of file xl2400.c.

{
    if (channel > 80) channel = 80;
    // AFC reset
    XL2400_WriteReg(XL2400_CMD_W_REGISTER | XL2400_REG_ANALOG_CFG0, 0x06);
    // AFC on
    XL2400_WriteReg(XL2400_CMD_W_REGISTER | XL2400_REG_ANALOG_CFG0, 0x0E);
    // Frequency(MHz) 2400:0x960 -> 2480:0x9B0
    *(cbuf + 0) = 0x60 + channel;
    *(cbuf + 1) = 0x09;
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_RF_CH, cbuf, 2);
    // AFC Locked
    *(cbuf + 1) |= 0x20;
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_RF_CH, cbuf, 2);
}

◆ XL2400_SetPower()

void XL2400_SetPower ( uint8_t power )

Definition at line 208 of file xl2400.c.

{
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_RF_CH, xbuf, 3);
    *(xbuf + 2) = power;
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_RF_CH, xbuf, 3);
}

◆ XL2400_SetRxAddress()

void XL2400_SetRxAddress ( uint8_t * address )

Definition at line 203 of file xl2400.c.

{
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_RX_ADDR_P1, address, 5);
}

◆ XL2400_SetRxMode()

void XL2400_SetRxMode ( void )

Definition at line 275 of file xl2400.c.

{
    XL2400_CE_Low();
    XL2400_ClearStatus();
    XL2400_WriteReg(XL2400_CMD_W_REGISTER | XL2400_REG_CFG_TOP, 0x7F);
    // XL2400_RxCalibrate();
    XL2400_CE_High();
    SYS_Delay(1);
}

◆ XL2400_SetTxAddress()

void XL2400_SetTxAddress ( uint8_t * address )

Definition at line 197 of file xl2400.c.

{
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_TX_ADDR, address, 5);
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_RX_ADDR_P0, address, 5);
}

◆ XL2400_SetTxMode()

void XL2400_SetTxMode ( void )

Definition at line 266 of file xl2400.c.

{
    XL2400_CE_Low();
    XL2400_ClearStatus();
    XL2400_WriteReg(XL2400_CMD_W_REGISTER | XL2400_REG_CFG_TOP, 0x7E);
    XL2400_RxCalibrate();
    SYS_Delay(2);
}

◆ XL2400_Sleep()

void XL2400_Sleep ( void )

Definition at line 215 of file xl2400.c.

{
    XL2400_CE_Low();
    XL2400_ClearStatus();
 
    *(xbuf + 0) = 0x7C;
    *(xbuf + 1) = 0x82;
    *(xbuf + 2) = 0x03;
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_CFG_TOP, xbuf, 3);
}

◆ XL2400_SPI_Test()

uint8_t XL2400_SPI_Test ( void )

Definition at line 128 of file xl2400.c.

{
    uint8_t i;
    const uint8_t *ptr = (const uint8_t *)XL2400_TEST_ADDR;
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_TX_ADDR, ptr, 5);
    XL2400_ReadToBuf(XL2400_CMD_R_REGISTER | XL2400_REG_TX_ADDR, xbuf, 5);
    for (i = 0; i < 5; i++) {
        UART1_TxHex(*(xbuf + i));
        if (*(xbuf + i) != *ptr++) return HAL_ERROR;
    }
    return HAL_OK;
}

◆ XL2400_Tx()

uint8_t XL2400_Tx	(	uint8_t *	ucPayload,
		uint8_t	length
	)

Definition at line 285 of file xl2400.c.

{
    uint8_t y = 100, status = 0;
    XL2400_ClearStatus();
    XL2400_WriteFromBuf(XL2400_CMD_W_TX_PAYLOAD, ucPayload, length);
    XL2400_CE_High();
    // Retry until timeout
    while (y--)
    {
        SYS_DelayUs(100);
        status = XL2400_ReadStatus();
        // If TX successful or retry timeout, exit
        if ((status & (MAX_RT_FLAG | TX_DS_FLAG)) != 0)
        {
            break;
        }
    }
    XL2400_CE_Low();
    return status;
}

◆ XL2400_WakeUp()

void XL2400_WakeUp ( void )

Definition at line 226 of file xl2400.c.

{
    *(xbuf + 0) = 0x7E;
    *(xbuf + 1) = 0x82;
    *(xbuf + 2) = 0x0B;
    XL2400_WriteFromBuf(XL2400_CMD_W_REGISTER | XL2400_REG_CFG_TOP, xbuf, 3);
    XL2400_CE_Low();
    XL2400_ClearStatus();
}

◆ XL2400_WriteByte()

void XL2400_WriteByte ( uint8_t value )

Emulate SPI Write on GPIO pins

Definition at line 23 of file xl2400.c.

{
    uint8_t i = 0;
    XL2400_CLK_LOW();
    XL2400_DATA_OUT();
    for (i = 0; i < 8; i++)
    {
        XL2400_CLK_LOW();
        if (value & 0x80)
        {
            XL2400_DATA_HIGH();
        }
        else
        {
            XL2400_DATA_LOW();
        }
        XL2400_CLK_HIGH();
        value = value << 1;
    }
    XL2400_CLK_LOW();
}

◆ XL2400_WriteFromBuf()

void XL2400_WriteFromBuf	(	uint8_t	reg,
		const uint8_t *	pBuf,
		uint8_t	len
	)

Definition at line 90 of file xl2400.c.

{
    uint8_t ctr;
    XL2400_NSS_LOW();
    XL2400_WriteByte(reg);
    for (ctr = 0; ctr < len; ctr++)
    {
        XL2400_WriteByte(*pBuf++);
    }
    XL2400_NSS_HIGH();
}

◆ XL2400_WriteReg()

void XL2400_WriteReg	(	uint8_t	reg,
		uint8_t	value
	)

Definition at line 72 of file xl2400.c.

{
    XL2400_NSS_LOW();
    XL2400_WriteByte(reg);
    XL2400_WriteByte(value);
    XL2400_NSS_HIGH();
}

Variable Documentation

◆ cbuf

__IDATA uint8_t cbuf[2]

Definition at line 17 of file xl2400.c.

◆ xbuf

__IDATA uint8_t xbuf[XL2400_PL_WIDTH_MAX+1]