可以留个位置我也站站么

PDF资料可以网上找找，但是程序是用我自己杜撰的编程语言写的，呵呵。

======================================================
这是插在电脑USB上的接收板程序：


ACI cpu = ACI cputype mcs51,
ACI 启动 -> 引擎 启动,

导入 组件库 mcs c51 chip,
导入 组件库 software time mcs_24mhz time,

指示灯 定时器 -> 定时器,
导入 组件库 hardware start mcs51 led,

无线收发器 芯片 -> chip,
无线收发器 组件
{
        public link 接口 组件 {} -> nrf2401,
        public link 芯片 组件 {}
       
        nrf2401 CE_port -> 配置器 CE_port,
        nrf2401 IRQ_pin -> 配置器 IRQ_pin,
        nrf2401 CSN_port -> 配置器 CSN_port,
        nrf2401 spi SCK_port -> 配置器 SCK_port,
        nrf2401 spi MISO_pin -> 配置器 MISO_pin,
        nrf2401 spi MOSI_port -> 配置器 MOSI_port,
       
        配置器 芯片 -> 芯片,
        配置器 组件
        {
                public link 芯片 组件 {}
               
                link CE_port(N1) = 芯片 P1 3,
                link IRQ_pin(N1) = 芯片 P1 2,
                link CSN_port(N1) = 芯片 P3 0,
                link SCK_port(N1) = 芯片 P1 0,
                link MISO_pin(N1) = 芯片 P3 1,
                link MOSI_port(N1) = 芯片 P1 1,
        }
        导入 组件库 hardware nrf2401 mcs nrf2401,
}

CH372 定时器 -> 定时器,
CH372 芯片 -> chip,
CH372 组件
{
        public link 接口 组件 {} -> CH372,
        public link 定时器 组件 {}
        public link 芯片 组件 {}
       
        CH372 DATA_port -> 配置器 DATA_port,
        CH372 INT_port -> 配置器 INT_port,
        CH372 WR_port -> 配置器 WR_port,
        CH372 RD_port -> 配置器 RD_port,
        CH372 A0_port -> 配置器 A0_port,
       
        配置器 芯片 -> 芯片,
        配置器 组件
        {
                public link 芯片 组件 {}
               
                link DATA_port(N8) = 芯片 P0,
                link INT_port(N1) = 芯片 P2 7,
                link WR_port(N1) = 芯片 P2 6,
                link RD_port(N1) = 芯片 P2 5,
                link A0_port(N1) = 芯片 P2 4,
        }
        CH372 定时器 -> 定时器,
        导入 组件库 hardware ch372 mcs ch372,
}

//*******************************************************
引擎 指示灯 -> 指示灯,
引擎 定时器 -> 定时器,
引擎 USB控制器 -> CH372 接口,
引擎 无线收发器 -> 无线收发器 接口,

引擎 组件
{
        public link 指示灯 组件 {}
        public link 定时器 组件 {}
        public link USB控制器 组件 {}
        public link 无线收发器 组件 {}
       
        public void 启动()
        {
                指示灯 初始化[],
                指示灯 闪烁[ 3 ],
               
                USB控制器 初始化[],
                如果 !USB控制器 设置工作模式成功[ 2 ], 指示灯 闪烁[ 100 ].
                USB控制器 设置超时时间[ 200 ],
               
                无线收发器 初始化[],
                如果 !无线收发器 工作正常[], 指示灯 闪烁[ 100 ].
                无线收发器 设置超时时间[ 200 ],
                无线收发器 本机地址 0 = 0,
                无线收发器 本机地址 1 = 0x43,
                无线收发器 本机地址 2 = 0x10,
                无线收发器 本机地址 3 = 0x10,
                无线收发器 本机地址 4 = 0x01,
               
                对方地址 0 = 27,
                对方地址 1 = 0x43,
                对方地址 2 = 0x10,
                对方地址 3 = 0x10,
                对方地址 4 = 0x01,
               
                反复执行
                        //无线收发器 设置为发射模式[],
                        //无线收发器 发射数据[ 数据区, 8, 对方地址 ],
                       
                        无线收发器 设置为接收模式[],
                        反复执行 直到 无线收发器 接收到数据[ 数据区, 1, true ], ...
                        USB控制器 发送数据 [ 数据区, 1 ],
                        指示灯 闪烁[ 1 ],
                        ...
        }
        对方地址([N8*5]),
        数据区([N8*8]),
}

===========================================
这个是手持端程序



ACI cpu = ACI cputype mega8,
ACI 启动 -> 引擎 启动,

导入 组件库 avr mega8 chip,

导入 组件库 software time avr_12mhz time,

无线收发器 芯片 -> chip,
无线收发器 组件
{
        public link 接口 组件 {} -> nrf2401,
        public link 芯片 组件 {}
       
        nrf2401 CE_ddr -> 配置器 CE_ddr,
        nrf2401 CE_port -> 配置器 CE_port,
        nrf2401 IRQ_ddr -> 配置器 IRQ_ddr,
        nrf2401 IRQ_pin -> 配置器 IRQ_pin,
        nrf2401 CSN_ddr -> 配置器 CSN_ddr,
        nrf2401 CSN_port -> 配置器 CSN_port,
        nrf2401 spi SCK_ddr -> 配置器 SCK_ddr,
        nrf2401 spi SCK_port -> 配置器 SCK_port,
        nrf2401 spi MISO_ddr -> 配置器 MISO_ddr,
        nrf2401 spi MISO_pin -> 配置器 MISO_pin,
        nrf2401 spi MOSI_ddr -> 配置器 MOSI_ddr,
        nrf2401 spi MOSI_port -> 配置器 MOSI_port,
       
        配置器 芯片 -> 芯片,
        配置器 组件
        {
                public link 芯片 组件 {}
               
                link CE_ddr(N1) = 芯片 DDRD 5,
                link CE_port(N1) = 芯片 PORTD 5,
                link IRQ_ddr(N1) = 芯片 DDRB 0,
                link IRQ_pin(N1) = 芯片 PINB 0,
                link CSN_ddr(N1) = 芯片 DDRB 2,
                link CSN_port(N1) = 芯片 PORTB 2,
                link SCK_ddr(N1) = 芯片 DDRD 6,
                link SCK_port(N1) = 芯片 PORTD 6,
                link MISO_ddr(N1) = 芯片 DDRD 7,
                link MISO_pin(N1) = 芯片 PIND 7,
                link MOSI_ddr(N1) = 芯片 DDRB 1,
                link MOSI_port(N1) = 芯片 PORTB 1,
        }
        导入 组件库 hardware nrf2401 avr nrf2401,
}
指示灯 定时器 -> 定时器,
public 指示灯 组件
{
        public link 定时器 组件 {}
       
        public void 初始化()
        {
                定时器 延时10毫秒[ 50 ],
               
                OUT_DDR = 1,
                OUT_PORT = 0,
        }
        public void 点亮()
        {
                OUT_PORT = 1,
        }
        public void 熄灭()
        {
                OUT_PORT = 0,
        }
        public void 闪烁( (N8)time )
        {
                反复执行 time 次,
                        OUT_PORT = 1,
                        定时器 延时10毫秒[ 5 ],
                        OUT_PORT = 0,
                        定时器 延时10毫秒[ 10 ],
                        ...
        }
        link OUT_PORT(N1) = ACI Wind chip PORTD 3,
        link OUT_DDR(N1) = ACI Wind chip DDRD 3,
}
//*******************************************************
键盘 芯片 -> chip,

键盘 组件
{
        public link 芯片 组件 {}
       
        void 初始化()
        {
                KEY1_ddr = 1,
                KEY1_port = 1,
                KEY2_ddr = 1,
                KEY2_port = 1,
        }
        (T) 按键1按下()
        {
                返回 KEY1_pin == 0,
        }
        (T) 按键2按下()
        {
                返回 KEY2_pin == 0,
        }
        link KEY1_port(N1) = 芯片 PORTB 5,
        link KEY1_ddr(N1) = 芯片 DDRB 5,
        link KEY1_pin(N1) = 芯片 PINB 5,
        link KEY2_port(N1) = 芯片 PORTB 4,
        link KEY2_ddr(N1) = 芯片 DDRB 4,
        link KEY2_pin(N1) = 芯片 PINB 4,
}
//*******************************************************
蜂鸣器 芯片 -> chip,
蜂鸣器 定时器 -> 定时器,

蜂鸣器 组件
{
        public link 芯片 组件 {}
        public link 定时器 组件 {}
       
        void 初始化()
        {
                PORT_ddr = 1,
                PORT = 0,
        }
        public void 嘀嘀响( (N8)n )
        {
                反复执行 n 次,
                        嘀响[],
                        定时器 延时100毫秒[ 1 ],
                        ...
        }
        void 嘀响()
        {
                反复执行 200 次,
                        PORT = 1,
                        延时1毫秒[],
                        PORT = 0,
                        延时1毫秒[],
                        ...
        }
        void 延时1毫秒()
        {
                反复执行 20 次,
                        反复执行 10 次, ...
                        ...
        }
        link PORT(N1) = 芯片 PORTC 5,
        link PORT_ddr(N1) = 芯片 DDRC 5,
}
//*******************************************************
引擎 指示灯 -> 指示灯,
引擎 定时器 -> 定时器,
引擎 蜂鸣器 -> 蜂鸣器,
引擎 键盘 -> 键盘,
引擎 无线收发器 -> 无线收发器 接口,

引擎 组件
{
        public link 指示灯 组件 {}
        public link 定时器 组件 {}
        public link 蜂鸣器 组件 {}
        public link 键盘 组件 {}
        public link 无线收发器 组件 {}
       
        public void 启动()
        {
                指示灯 初始化[],
                蜂鸣器 初始化[],
                键盘 初始化[],
               
                无线收发器 初始化[],
                如果 !无线收发器 工作正常[], 指示灯 闪烁[ 100 ].
                无线收发器 设置超时时间[ 200 ],
                无线收发器 本机地址 0 = 27,
                无线收发器 本机地址 1 = 0x43,
                无线收发器 本机地址 2 = 0x10,
                无线收发器 本机地址 3 = 0x10,
                无线收发器 本机地址 4 = 0x01,
               
                对方地址 0 = 0,
                对方地址 1 = 0x43,
                对方地址 2 = 0x10,
                对方地址 3 = 0x10,
                对方地址 4 = 0x01,
               
                指示灯 闪烁[ 3 ],
                蜂鸣器 嘀嘀响[ 3 ],
               
                按键1上次按下(T) = false,
                按键2上次按下(T) = false,
                反复执行
                        有键按下(T) = false,
                       
                        按键1本次按下(T) = 键盘 按键1按下[],
                        按键2本次按下(T) = 键盘 按键2按下[],
                       
                        如果 按键1本次按下 && !按键1上次按下,
                                数据区 0 = 1,
                                有键按下 = true.
                       
                        如果 按键2本次按下 && !按键2上次按下,
                                数据区 0 = 2,
                                有键按下 = true.
                       
                        按键1上次按下 = 按键1本次按下,
                        按键2上次按下 = 按键2本次按下,
                       
                        如果 有键按下,
                                无线收发器 设置为发射模式[],
                                无线收发器 发射数据[ 数据区, 1, 对方地址 ],
                                无线收发器 设置为接收模式[],
                                蜂鸣器 嘀嘀响[ 1 ],
                                指示灯 闪烁[ 1 ].
                       
                        如果 无线收发器 接收到数据[ 数据区, 8, true ],
                                蜂鸣器 嘀嘀响[ 数据区 0 ].
                        ...
        }
        对方地址([N8*5]),
        数据区([N8*8]),
}

这是CH372驱动文件：



//********************************************
//类型:                CH372元件
//单片机:                MCS
//晶振:                24MHz

CH372 组件
{
        公开 link 定时器 组件 {}
       
        link 虚拟类型 BASE {} -> ACI Cloud base,
       
        set_timeout(N16),
       
        GET_IC_VER(N8) =                ACI const 0x01,
        ENTER_SLEEP(N8) =                ACI const 0x03,
        RESET_ALL(N8) =                ACI const 0x05,
        CHECK_EXIST(N8) =                ACI const 0x06,
        CHK_SUSPEND(N8) =                ACI const 0x0b,
        SET_USB_ID(N8) =                ACI const 0x12,
        SET_USB_MODE(N8) =        ACI const 0x15,
        GET_STATUS(N8) =                ACI const 0x22,
        UNLOCK_USB(N8) =                ACI const 0x23,
        READ_DATA(N8) =                ACI const 0x27,
        READ_DATA_UNLOCK(N8) =        ACI const 0x28,
        WRITE_DATA1(N8) =                ACI const 0x2a,
        WRITE_DATA2(N8) =                ACI const 0x2b,
       
        引擎(公开)
        初始化
        {
                端口初始化[],
               
                //发送CH372硬件复位命令
                写命令[ RESET_ALL ],
                定时器 延时10毫秒[ 10 ],
        }
        引擎()
        端口初始化
        {
                DATA_port = 0xff,
               
                WR_port = 1,
                RD_port = 1,
                A0_port = 1,
                INT_port = 1,
        }
        引擎(公开)
        mode_index(N8),
        设置工作模式成功(T)
        {
                //设置CH372工作在模式-mode_index
                写命令[ 0x15 ],
                写数据[ mode_index ],
                定时器 延时10毫秒[ 1 ],
               
                //判断模式设置是否成功
                如果 读数据[] != 0x51,
                        返回 false,
                否则
                        返回 true.
        }
        引擎(公开)
        t(N16),
        设置超时时间
        {
                set_timeout = t,
        }
        引擎(公开)
        Buf([N8*?]), length(N8),
        发送数据
        {
                写命令[ WRITE_DATA2 ],
                写数据[ length ],
               
                反复执行 length 次,初始 i(N8) = 0,每次 i + 1,
                        写数据[ Buf i ],
                        ...
               
                反复执行 直到 INT_port == 0, ...
                写命令[ GET_STATUS ],
                d0(N8) = 读数据[],
                写命令[ UNLOCK_USB ],
        }
        引擎(公开)
        Buf([N8*?]), length(BASE N8), is_timeout(T),
        接收到数据(T)
        {
                timeout(N16) = 0,
                //等待USB命令
                反复执行 直到 INT_port == 0,
                        如果 is_timeout,
                                如果 timeout == set_timeout, 返回 false.
                                timeout + 1,
                                ...
                        ...
               
                写命令[ GET_STATUS ],
                temp(N8) = 读数据[],
               
                写命令[ READ_DATA ],
                length = 读数据[],
               
                反复执行 length 次,初始 i(N8) = 0, 每次 i + 1,
                        Buf i = 读数据[],
                        ...
                       
                写命令[ UNLOCK_USB ],
                返回 true,
        }
        引擎()
        cmd(N8),
        写命令
        {
                #asm "nop"
                #asm "nop"
                DATA_port = cmd,
                A0_port = 1,
                WR_port = 0,
                WR_port = 1,
        }
        引擎()
        data(N8),
        写数据
        {
                #asm "nop"
                #asm "nop"
                DATA_port = data,
                A0_port = 0,
                WR_port = 0,
                WR_port = 1,
        }
        引擎()
        读数据(N8)
        {
                DATA_port = 0xff,
                A0_port = 0,
                RD_port = 0,
                data(N8) = DATA_port,
                RD_port = 1,
                返回 data,
        }
        公开 link DATA_port(N8),
        公开 link INT_port(N1),
        公开 link WR_port(N1),
        公开 link RD_port(N1),
        公开 link A0_port(N1),
}

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),        //写数据端口
        }
}

horalxi 发表于 2012-5-16 10:59
决定采用您的方案，正在研究资料。
还是希望楼主能提供点资料。

注意在无线模块的初始化一定要加上这句:

write_command( FLUSH_TX );
write_command( FLUSH_RX );

网上好多版本的初始化是没有这两句的或者是不全的,虽然也能正常工作,但是断电再复位就容易出问题.