NRF2401的驱动文件：




//无线通信模块nrf2401
//版本:        在版本v0中固定发送4个字节数据,这个版本改成了9个数据;
//                可以设置超时时间;
//芯片:        AVR芯片

nrf2401 组件
{
        CONFIG(N8) =                 ACI const 0x00,  //'Config'
        EN_AA(N8) =                 ACI const 0x01,  //'Enable Auto Acknowledgment'
        EN_RXADDR(N8) =                 ACI const 0x02,  //'Enabled RX addresses'
        SETUP_AW(N8) =                 ACI const 0x03,  //'Setup address width'
        SETUP_RETR(N8) =         ACI const 0x04,  //'Setup Auto. Retrans'
        RF_CH(N8) =                 ACI const 0x05,  //'RF channel'
        RF_SETUP(N8) =                 ACI const 0x06,  //'RF setup'
        STATUS(N8) =                 ACI const 0x07,  //'Status'
        OBSERVE_TX(N8) =         ACI const 0x08,  //'Observe TX'
        CD(N8) =                         ACI const 0x09,  //'Carrier Detect'
        RX_ADDR_P0(N8) =         ACI const 0x0A,  //频道0接收数据地址
        RX_ADDR_P1(N8) =         ACI const 0x0B,  //'RX address pipe1'
        RX_ADDR_P2(N8) =         ACI const 0x0C,  //'RX address pipe2'
        RX_ADDR_P3(N8) =         ACI const 0x0D,  //'RX address pipe3'
        RX_ADDR_P4(N8) =         ACI const 0x0E,  //'RX address pipe4'
        RX_ADDR_P5(N8) =         ACI const 0x0F,  //'RX address pipe5'
        TX_ADDR(N8) =                 ACI const 0x10,  //'TX address'
        RX_PW_P0(N8) =                 ACI const 0x11,  //接收频道0接收数据长度
        RX_PW_P1(N8) =                 ACI const 0x12,  //'RX payload width, pipe1'
        RX_PW_P2(N8) =                 ACI const 0x13,  //'RX payload width, pipe2'
        RX_PW_P3(N8) =                 ACI const 0x14,  //'RX payload width, pipe3'
        RX_PW_P4(N8) =                 ACI const 0x15,  //'RX payload width, pipe4'
        RX_PW_P5(N8) =                 ACI const 0x16,  //'RX payload width, pipe5'
        FIFO_STATUS(N8) =         ACI const 0x17,  //'FIFO Status Register'
       
        //SPI(nRF24L01) commands
        READ_REG(N8) =                ACI const 0x00,  //Define read command to register
        WRITE_REG(N8) =                ACI const 0x20,  //Define write command to register
        RD_RX_PLOAD(N8) =        ACI const 0x61,  //Define RX payload register address
        WR_TX_PLOAD(N8) =        ACI const 0xA0,  //Define TX payload register address
        FLUSH_TX(N8) =                ACI const 0xE1,  //Define flush TX register command
        FLUSH_RX(N8) =                ACI const 0xE2,  //Define flush RX register command
        REUSE_TX_PL(N8) =        ACI const 0xE3,  //Define reuse TX payload register command
        NOP(N8) =                        ACI const 0xFF,  //Define No Operation, might be used to read status register
       
        公开 本机地址([N8*5]),        //本机地址
        time_out(N16),
       
        引擎(公开)
        初始化
        {
                CE_ddr = 1,
                CE_port = 0,
                CSN_ddr = 1,
                CSN_port = 1,
                IRQ_ddr = 0,
               
                //spi接口初始化
                spi init[],
               
                set[ CONFIG, 0b0000_1111 ],                //CRC使能，16位CRC校验，上电,接收模式
                set[ EN_AA, 0x01 ],                        //使能接收通道0自动应答
                set[ EN_RXADDR, 0x01 ],                //使能接收通道0
                set[ SETUP_AW, 0x03 ],                //设置地址宽度 5个字节
                set[ SETUP_RETR, 0xff ],                //自动重发延时等待4000us+86us，自动重发15次
                set[ RF_CH, 40 ],                        //选择射频通道40
                set[ RF_SETUP, 0x07 ],                //数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
                status(N8) = get[ STATUS ],                //返回状态寄存器
                write_command[ FLUSH_TX ],
                write_command[ FLUSH_RX ],
                set[ STATUS, status | 0b0111_0000 ],//清除TX_DS或MAX_RT中断标志
               
                //设置超时时间
                time_out = 0xffff,
        }
        引擎(公开)
        工作正常(T)
        {
                set[ RF_CH, 0x03 ],
                如果 get[ RF_CH ] != 0x03,
                        返回 false.
               
                set[ RF_CH, 0x40 ],
                如果 get[ RF_CH ] != 0x40,
                        返回 false.
               
                返回 true,
        }
        引擎(公开)
        转换到正常模式
        {
                c(N8) = get[ CONFIG ],
                c | 0b0000_0010,
                set[ CONFIG, c ],
        }
        引擎(公开)
        转换到掉电模式
        {
                c(N8) = get[ CONFIG ],
                c & 0b1111_1101,
                set[ CONFIG, c ],
        }
        引擎(公开)
        time(N16),
        设置超时时间
        {
                time_out = time,
        }
        引擎(公开)
        设置为接收模式
        {
                CE_port = 0,
               
                //写入接收通道地址
                write_buffer[ WRITE_REG + RX_ADDR_P0, 本机地址, 5 ],
               
                c(N8) = get[ CONFIG ],
                c | 0b0000_0001,
                set[ CONFIG, c ],
                CE_port = 1,
        }
        引擎(公开)
        设置为发射模式
        {
                CE_port = 0,
                c(N8) = get[ CONFIG ],
                c & 0b1111_1110,
                set[ CONFIG, c ],
                CE_port = 1,
        }
        引擎(公开)
        buffer([N8*?]), length(N8), TX_address([N8*?]),
        发射数据
        {
                //接收通道0选择和发送通道相同有效数据宽度
                set[ RX_PW_P0, length ],
               
                CE_port = 0,
               
                //写数据包到TX FIFO
                write_buffer[ WR_TX_PLOAD, buffer, length ],
                //写入发送地址
                write_buffer[ WRITE_REG + TX_ADDR, TX_address, 5 ],
                //为了应答接收设备，接收通道0地址和发送地址相同
                write_buffer[ WRITE_REG + RX_ADDR_P0, TX_address, 5 ],
               
                CE_port = 1,
               
                //等待应答
                反复执行 直到 IRQ_pin == 0, ...
               
                status(N8) = get[ STATUS ],        //返回状态寄存器
                set[ STATUS, status ],          //清除TX_DS或MAX_RT中断标志
                write_command[ FLUSH_TX ],
        }
        引擎(公开)
        buffer([N8*?]), length(N8), is_time_out(T),
        接收到数据(T)
        {
                //接收通道0选择和发送通道相同有效数据宽度
                set[ RX_PW_P0, length ],
               
                times(N16) = 0,
                反复执行 直到 IRQ_pin == 0,
                        如果 is_time_out,
                                times + 1,
                                如果 times == time_out,
                                        返回 false.
                                ...
                        ...
                sta(N8) = get[ STATUS ],
                set[ STATUS, sta ],
                read_buffer[ RD_RX_PLOAD, buffer, length ],
                返回 true,
        }
        //把p_buf缓存中的数据写入到nRF24L01，通常用来写入发射通道数据或接收/发送地址
        引擎()
        reg(N8), p_buf([N8*?]), length(N8),
        write_buffer
        {
                CSN_port = 0,
               
                spi write_byte[ reg ],
                反复执行 初始 i(N8) = 0, 每次 i + 1, 直到 i == length,
                        spi write_byte[ p_buf i ],
                        ...
                CSN_port = 1,
        }
        //写一个命令
        引擎()
        cmd(N8),
        write_command
        {
                CSN_port = 0,
                spi write_byte[ cmd ],
                CSN_port = 1,
        }
        //读取nRF2401某个缓冲区内容
        引擎()
        reg(N8), p_buf([N8*?]), length(N8),
        read_buffer
        {
                CSN_port = 0,
               
                spi write_byte[ reg ],
                反复执行 初始 i(N8) = 0, 每次 i + 1, 直到 i == length,
                        p_buf i = spi read_byte[],
                        ...
                CSN_port = 1,
        }
        //写寄存器
        引擎()
        addr(N8), data(N8),
        set
        {
                CSN_port = 0,
                spi write_byte[ WRITE_REG + addr ],
                spi write_byte[ data ],
                CSN_port = 1,
        }
        //读寄存器
        引擎()
        addr(N8),
        get(N8)
        {
                CSN_port = 0,
                spi write_byte[ READ_REG + addr ],
                data(N8) = spi read_byte[],
                CSN_port = 1,
                返回 data,
        }
       
        公开 link CE_port(N1),
        公开 link CE_ddr(N1),
        公开 link IRQ_pin(N1),
        公开 link IRQ_ddr(N1),
        公开 link CSN_port(N1),
        公开 link CSN_ddr(N1),
       
        //SPI串行接口元件,高位在前,低位在后
        公开 spi 组件
        {
                //初始化
                引擎(公开)
                init
                {
                        SCK_ddr = 1,
                        SCK_port = 0,
                        MOSI_ddr = 1,
                        MOSI_port = 0,
                        MISO_ddr = 0,
                }
                //写一个字节
                引擎(公开)
                data(N8),
                write_byte
                {
                        反复执行 8 次,
                                MOSI_port = data 7(N1),
                                #asm "nop"
                                SCK_port = 1,
                                #asm "nop"
                                SCK_port = 0,
                                data << 1,
                                ...
                }
                //读一个字节
                引擎(公开)
                read_byte(N8)
                {
                        MOSI_port = 0,
                        data(N8),
                        反复执行 8 次,
                                data << 1,
                                SCK_port = 1,
                                #asm "nop"
                                data 0(N1) = MISO_pin,
                                #asm "nop"
                                SCK_port = 0,
                                ...
                        返回 data,
                }
               
                公开 link SCK_port(N1),        //时钟线
                公开 link SCK_ddr(N1),        //时钟线
                公开 link MISO_pin(N1),        //读数据端口
                公开 link MISO_ddr(N1),        //读数据端口
                公开 link MOSI_port(N1),        //写数据端口
                公开 link MOSI_ddr(N1),        //写数据端口
        }
}