开启辅助访问

amobbs.com 阿莫电子技术论坛

登录 注册 找回密码
搜索
amobbs.com 阿莫电子技术论坛»论坛首页 › 操作系统 › Linux › linux2.6.32下的的nrf24l01接收问题求解
bottom↓
返回列表 发新帖
回复: 2

linux2.6.32下的的nrf24l01接收问题求解

[复制链接]
lanxin

出0入0汤圆
发表于 2012-7-21 21:32:32 | 显示全部楼层 |阅读模式
以前做过在51单片机下的nrf24l01,可以相互通信，看到有人用单片加nrf24l01发射，用arm+nrf24l01接收，就把以前的51单片机接收程序移植到了Linux下，但是一直有问题，编译可以通过，就是接收不到数据，现在就是连NRF24L01模块不接收也觉得是接收到数据，接上去模块也是一样的效果，现附上部分程序，大家帮分析一下
应用程序：
app-nrf24l01
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <errno.h>

unsigned char RxBuf[32]={0x00};

int main(void)
{
     int fd = -1;

    int flag;
    int count;
    int i=0;

    fd = open("/dev/NRF24L01", O_RDWR);

    if(fd < 0)
    {
      perror("Can't open /dev/nrf24l01 \n");
        exit(1);
    }
    printf("open /dev/nrf24l01 success \n");
    while(1)
    {

        flag = read(fd, &RxBuf , sizeof(RxBuf));
         
        printf("read %d\n",flag);
                for(i=0;i<flag;i++)
                {
                        printf("%x ",RxBuf[i]);
                }
        printf("\n");
                usleep(1000*1000);
    }
    close(fd);
}

头文件
#ifndef _NRF24L01_H_
#define _NRF24L01_H_

#include <linux/init.h>
#include <linux/fs.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/miscdevice.h>
#include <asm/uaccess.h>
#include <mach/regs-gpio.h>

#include <linux/gpio.h>
#include <linux/poll.h>
#include <mach/hardware.h>

#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/irq.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/cdev.h>
#include <linux/sched.h>
#include <linux/errno.h>

#include <asm/io.h>
//#include <mach/gpio.h>
#include <linux/ioctl.h>

#include <mach/map.h>
#include <linux/types.h>
#include <linux/mm.h>
#include <linux/moduleparam.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/list.h>
#include <linux/pci.h>
#include <asm/irq.h>
#include <asm/atomic.h>
#include <asm/unistd.h>

#define DEVICE_NAME "NRF24L01"

#define NRF_MAJOR        0                //动态
#define NRF_MINOR        0

/* 引脚相关定义 */
/*#define CE S3C2410_GPF(0)
#define CE_OUTP S3C2410_GPIO_OUTPUT
#define CSN S3C2410_GPF(1)
#define CSN_OUTP S3C2410_GPIO_OUTPUT
#define SCK S3C2410_GPF(2)
#define SCK_OUTP S3C2410_GPIO_OUTPUT
#define MOSI S3C2410_GPF(3)
#define MOSI_OUTP S3C2410_GPIO_OUTPUT
#define MISO S3C2410_GPF(4)
#define MISO_INP S3C2410_GPIO_INPUT
#define IRQ S3C2410_GPF(5)
#define IRQ_INP S3C2410_GPIO_INPUT */
#define CE S3C2410_GPF(0)
#define CE_OUTP S3C2410_GPIO_OUTPUT
#define CSN S3C2410_GPF(1)
#define CSN_OUTP S3C2410_GPIO_OUTPUT
#define SCK S3C2410_GPF(2)
#define SCK_OUTP S3C2410_GPIO_OUTPUT
#define MOSI S3C2410_GPF(3)
#define MOSI_OUTP S3C2410_GPIO_OUTPUT
#define MISO S3C2410_GPF(4)
#define MISO_INP S3C2410_GPIO_INPUT
#define IRQ S3C2410_GPF(5)
#define IRQ_INP S3C2410_GPIO_INPUT



//NRF24L01端口定义

#define CE_OUT s3c2410_gpio_cfgpin(CE, CE_OUTP)          //数据线设置为输出
#define CE_UP s3c2410_gpio_pullup(CE, 1)                     //打开上拉电阻
#define CE_L s3c2410_gpio_setpin(CE, 0)                         //拉低数据线电平
#define CE_H s3c2410_gpio_setpin(CE, 1)                         //拉高数据线电平


#define SCK_OUT s3c2410_gpio_cfgpin(SCK, SCK_OUTP)            //数据线设置为输出
#define SCK_UP        s3c2410_gpio_pullup(SCK, 1)       //打开上拉电阻
#define SCK_H s3c2410_gpio_setpin(SCK, 1)                   //拉高数据线电平
#define SCK_L s3c2410_gpio_setpin(SCK, 0)                  //拉高数据线电平

#define MISO_IN s3c2410_gpio_cfgpin(MISO, MISO_INP)         //数据线设置为输出
#define MISO_UP s3c2410_gpio_pullup(MISO, 1)             //打开上拉电阻
#define MISO_STU s3c2410_gpio_getpin(MISO)                 //数据状态
  
#define IRQ_IN s3c2410_gpio_cfgpin(IRQ, IRQ_INP)        //数据线设置为输出
#define IRQ_UP s3c2410_gpio_pullup(IRQ, 1)                //打开上拉电阻
#define IRQ_L s3c2410_gpio_setpin(IRQ, 0)                //拉低数据线电平
#define IRQ_H s3c2410_gpio_setpin(IRQ, 1)                //拉高数据线电平


#define MOSI_OUT s3c2410_gpio_cfgpin(MOSI, MOSI_OUTP)        //数据线设置为输出
#define MOSI_UP s3c2410_gpio_pullup(MOSI, 1)               //打开上拉电阻
#define MOSI_L s3c2410_gpio_setpin(MOSI, 0)            //拉低数据线电平
#define MOSI_H s3c2410_gpio_setpin(MOSI, 1)                   //拉高数据线电平


#define CSN_OUT s3c2410_gpio_cfgpin(CSN, CSN_OUTP)          //数据线设置为输出
#define CSN_UP s3c2410_gpio_pullup(CSN, 1)                 //打开上拉电阻
#define CSN_L s3c2410_gpio_setpin(CSN, 0)                //拉低数据线电平
#define CSN_H s3c2410_gpio_setpin(CSN, 1)                //拉高数据线电平



//NRF24L01

#define TX_ADR_WIDTH    5           // 5 uints TX address width
#define RX_ADR_WIDTH    5           // 5 uints RX address width
#define TX_PLOAD_WIDTH  32         // 20 uints TX payload
#define RX_PLOAD_WIDTH  32          // 20 uints TX payload
//***************************************NRF24L01寄存器指令*******************************************************
#define READ_REG        0x00          // 读寄存器指令
#define WRITE_REG       0x20         // 写寄存器指令
#define RD_RX_PLOAD     0x61          // 读取接收数据指令
#define WR_TX_PLOAD     0xA0          // 写待发数据指令
#define FLUSH_TX        0xE1         // 冲洗发送 FIFO指令
#define FLUSH_RX        0xE2          // 冲洗接收 FIFO指令
#define REUSE_TX_PL     0xE3          // 定义重复装载数据指令
#define NOP             0xFF          // 保留
//***************SPI(nRF24L01)寄存器地址***********************************
#define CONFIG          0x00  // 配置收发状态，CRC校验模式以及收发状态响应方式
#define EN_AA           0x01  // 自动应答功能设置
#define EN_RXADDR       0x02  // 可用信道设置
#define SETUP_AW        0x03  // 收发地址宽度设置
#define SETUP_RETR      0x04  // 自动重发功能设置
#define RF_CH           0x05  // 工作频率设置
#define RF_SETUP        0x06  // 发射速率、功耗功能设置
#define STATUS          0x07  // 状态寄存器
#define OBSERVE_TX      0x08  // 发送监测功能
#define CD              0x09  // 地址检测           
#define RX_ADDR_P0      0x0A  // 频道0接收数据地址
#define RX_ADDR_P1      0x0B  // 频道1接收数据地址
#define RX_ADDR_P2      0x0C  // 频道2接收数据地址
#define RX_ADDR_P3      0x0D  // 频道3接收数据地址
#define RX_ADDR_P4      0x0E  // 频道4接收数据地址
#define RX_ADDR_P5      0x0F  // 频道5接收数据地址
#define TX_ADDR         0x10  // 发送地址寄存器
#define RX_PW_P0        0x11  // 接收频道0接收数据长度
#define RX_PW_P1        0x12  // 接收频道0接收数据长度
#define RX_PW_P2        0x13  // 接收频道0接收数据长度
#define RX_PW_P3        0x14  // 接收频道0接收数据长度
#define RX_PW_P4        0x15  // 接收频道0接收数据长度
#define RX_PW_P5        0x16  // 接收频道0接收数据长度
#define FIFO_STATUS     0x17  // FIFO栈入栈出状态寄存器设置
#endif








阿莫论坛20周年了！感谢大家的支持与爱护！！

一只鸟敢站在脆弱的枝条上歇脚，它依仗的不是枝条不会断，而是自己有翅膀，会飞。
回复

   举报本楼层   

lanxin

出0入0汤圆
 楼主| 发表于 2012-7-21 21:33:11 | 显示全部楼层
驱动程序
#include "NRF24L01.h"
typedef unsigned int uint16;
typedef unsigned char uint8;

int devmajor = NRF_MAJOR;
int devminor = NRF_MINOR;

dev_t dev = 0;

struct NRF_dev
{
        struct cdev cdev;
};

struct NRF_dev *NRF_devices;
struct class *nrf_class;                //自动创建结点

uint8  TxBuf[32]={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
0x08,0x09,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,
0x19,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x30,0x31
};
uint8 RxBuf[32]={0x00};

uint8 TX_ADDRESS[TX_ADR_WIDTH] = { 0x34, 0x43, 0x10, 0x10, 0x01 };        //本地地址
uint8 RX_ADDRESS[RX_ADR_WIDTH] = { 0x34, 0x43, 0x10, 0x10, 0x01 };        //接收地址
/* 打开计数 */
uint open_count = 0;

//状态标志
uint8 sta;
int get_data=0;
unsigned char flag = 0;

#define RX_DR 6
#define TX_DS 5
#define MAX_RT 4

uint8 SPI_RW(uint8 uchar);
uint8 SPI_Read(uint8 reg);
uint8 SPI_RW_Reg(uint8 reg, uint8 value);
uint8 SPI_Read_Buf(uint8 reg, uint8 *pBuf, uint8 uchars);
uint8 SPI_Write_Buf(uint8 reg, uint8 * pBuf, uint8 uchars);
void SetRX_Mode(void);
unsigned char nRF24L01_RxPacket(unsigned char *rx_buf);
unsigned char nRF24L01_TxPacket(unsigned char *tx_buf);
uint8 init_NRF24L01(void);
static ssize_t nrf24l01_write(struct file *filp,const char *buffer, size_t count,loff_t *ppos);
static ssize_t nrf24l01_read(struct file * filp,char *buffer,size_t count,loff_t *ppos);
static int nrf24l01_open(struct inode *node, struct file *file);
static int nrf24l01_release(struct inode *node, struct file *file);
static void __exit nrf24l01_exit(void);
static int __init nrf24l01_init(void);
/**********************************************************/
//函数：uint SPI_RW(uint uchar)
//功能：NRF24L01的SPI写时序
/**********************************************************/
uint8 SPI_RW(uint8 uchar)
{
        uint8 bit_ctl;

        for (bit_ctl = 0; bit_ctl < 8;bit_ctl++)
        {
                if(uchar & 0x80)
                        MOSI_H;
                else
                        MOSI_L;
                ndelay(20);
                uchar <<= 1;        //Shift next bit into MSB
               
                SCK_H;                //Set SCK high
                ndelay(60);
                uchar |= MISO_STU;  //Capture current MISO bit
                SCK_L;
                ndelay(70);
        }
        return uchar;
}

/*******************************************/
// 函数：uint8 SPI_Read(uint8 reg)
// 功能：NRF24L01的SPI时序
/*******************************************/
uint8 SPI_Read(uint8 reg)
{
        uint8 reg_val;

        CSN_L;                        // CSN low, initialize SPI communication...
        ndelay(60);
        SPI_RW(reg);                // Select register to read from..
        reg_val = SPI_RW(0);        // ..then read registervalue
        CSN_H;                        // CSN high, terminate SPI communication
        ndelay(60);
        return (reg_val);        // return register value

}
/*******************************************/
//功能：NRF24L01的读写寄存器函数
/*******************************************/
uint8 SPI_RW_Reg(uint8 reg, uint8 value)
{
        uint8 status;

        CSN_L;                        // CSN low, init SPI transaction
        ndelay(140);
        status = SPI_RW(reg);        // select register
        SPI_RW(value);                // ..and write value to it..
        CSN_H;                        // CSN high again
        ndelay(60);
        return (status);        // return nRF24L01 status uint8
}
/************************************************************************/  
//函数：uint8 SPI_Read_Buf(uint8 reg, uint8 *pBuf, uint8 uchars)
//功能: 用于读数据,reg：为寄存器地址,pBuf：为待读出数据地址,uchars：读出数据的个数
/************************************************************************/
uint8 SPI_Read_Buf(uint8 reg, uint8 *pBuf, uint8 uchars)
{
        uint8 status, uchar_ctr;

        CSN_L;                        // Set CSN low, init SPI tranaction
        ndelay(140);
        status = SPI_RW(reg);        // Select register to write to and read status uint8
        for (uchar_ctr = 0; uchar_ctr < uchars; uchar_ctr++)
        {
                pBuf[uchar_ctr] = SPI_RW(0);
        }
        CSN_H;
        ndelay(60);
        return (status);        // return nRF24L01 status uint8
}
/************************************************************************/  
//函数：uint8 SPI_Write_Buf(uint8 reg, uint8 *pBuf, uint8 uchars)
//功能: 用于写数据：为寄存器地址，pBuf：为待写入数据地址，uchars：写入数据的个数
/************************************************************************/
uint8 SPI_Write_Buf(uint8 reg, uint8 *pBuf, uint8 uchars)
{
        uint8 status, uchar_ctr;

        CSN_L;                        //SPI使能
        ndelay(140);
        status = SPI_RW(reg);
        printk(KERN_WARNING"status = %x\n",status);
        for (uchar_ctr = 0; uchar_ctr < uchars; uchar_ctr++)        //
        {
                SPI_RW(*pBuf++);
                ndelay(30);
        }
        CSN_H;                        //关闭SPI
        ndelay(60);
        return (status);        //
}
/************************************************************************/  
//函数：void SetRX_Mode(void)
//功能：数据接收配置
/************************************************************************/   
void SetRX_Mode(void)
{
        CE_L;
        ndelay(60);
        SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);   // IRQ收发完成中断响应,16位CRC,主接收
        CE_H;
        udelay(150);
}
/************************************************************************/
//函数：unsigned char nRF24L01_RxPacket(unsigned char* rx_buf )
//功能：数据读取后放如rx_buf接收缓冲区中
/************************************************************************/
unsigned char nRF24L01_RxPacket(unsigned char *rx_buf)
{
        unsigned char revale = 0;
        sta = SPI_Read(STATUS);        // 读取状态寄存其来判断数据接收状况
        printk(KERN_WARNING" SPI_Read sta = %x\n",sta);
        if (sta & 0x40)        // 判断是否接收到数据
        {
         printk(KERN_WARNING"222");
                CE_L;                //StandBy I模式
                //udelay(150);
                SPI_Read_Buf(RD_RX_PLOAD, rx_buf, RX_PLOAD_WIDTH);       
                // read receive payload from RX_FIFO buffer
                {printk(KERN_WARNING"rx=%d",rx_buf[9]);}
                printk("\n");
                revale = 1;        //读取数据完成标志
        }
        SPI_RW_Reg(WRITE_REG + STATUS, sta);       
        //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志
        return revale;
}
/************************************************************************/  
//函数：unsigned char nRF24L01_TxPacket(unsigned char * tx_buf)
//功能：发送 tx_buf中数据
/************************************************************************/
unsigned char nRF24L01_TxPacket(unsigned char *tx_buf)
{
        CE_L;                        //StandBy I模式
        ndelay(60);
   SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);
   SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // 装载接收端地址
   SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH);             // 装载数据
   printk(KERN_WARNING"nRF24L01_TxPacket write tx_buf=%s\n",tx_buf);
   
   SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);                    //使能自动应答，通道0
   SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);                //
   SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x1f);               //自动重发延时500+86us
   SPI_RW_Reg(WRITE_REG + RF_CH, 0);                      //
   SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);   
   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);                  // IRQ收发完成中断响应，16位CRC，主发送
    udelay(2000);
        CE_H;                        //置高CE，激发数据发送
        udelay(50);
        CE_L;
return 1;
}
/************************************************************************/
//初始化函数
/************************************************************************/
uint8 init_NRF24L01(void)
{
        udelay(100);
        MISO_UP;
        //CE_UP;
        //CSN_UP;
        //SCK_UP;
        //MOSI_UP;
        IRQ_UP;

        CE_OUT;
        CSN_OUT;
        SCK_OUT;
        MOSI_OUT;
        MISO_IN;
        IRQ_IN;

        udelay(500);
        CE_L;                        // chip enable
        ndelay(60);
        CSN_H;                        // Spi disable  
        ndelay(60);
        SCK_L;                        // Spi clock line init high
        ndelay(60);
        SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    // 写本地地址       
        SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); // 写接收端地址
        SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);     //频道0自动，ACK应答允许       
        SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); //允许接收地址只有频道0，如果需要多频道可以参考Page21  
        SPI_RW_Reg(WRITE_REG + RF_CH, 0);                 //设置信道工作为2.4GHZ，收发必须一致
        SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为32字节
        SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);             //设置发射速率为1MHZ，发射功率为最大值0dB
        SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);             // IRQ收发完成中断响应，16位CRC，主接收

        printk("nrf24l01_init success \n");
        mdelay(1000);
        return 1;

}
/************************************************************************/

/************************************************************************/
static ssize_t nrf24l01_write(struct file *filp,const char *buffer, size_t count,loff_t *ppos)
{
        if(copy_from_user(&TxBuf,buffer,count))
        {
                printk("Can't Send Data !");
                return -EFAULT;
        }
        nRF24L01_TxPacket(buffer);
        SPI_RW_Reg(WRITE_REG+STATUS,sta);
        printk("Send Data OK \n");
        return count;
}
/************************************************************************/

/************************************************************************/  
static ssize_t nrf24l01_read(struct file * filp,char *buffer,size_t count,loff_t *ppos)
{
        int flag,AB=0;
        mdelay(200);
        SPI_RW_Reg(WRITE_REG+STATUS,0XFF);
        init_NRF24L01();
        SetRX_Mode();
        AB=nRF24L01_RxPacket(RxBuf);
        printk("AB=%d",AB);
        printk("\n");
        flag=copy_to_user(buffer,&RxBuf,count);
                {printk(KERN_WARNING"a=%d",RxBuf[9]);}
                printk("\n");
        SPI_RW_Reg(WRITE_REG+STATUS,0XFF);
   if(flag>0)
        {
        printk(KERN_WARNING"11\n");
           return -EFAULT;
   }
        return count;
       
}
/************************************************************************/

/************************************************************************/  
static int nrf24l01_open(struct inode *node, struct file *file)
{
        if (open_count == 1)
                return -EBUSY;

        flag=init_NRF24L01();
        mdelay(200);
       
        if (flag == 0) {
                printk("unable to open device!\n");
                return -1;
        } else {
                open_count++;
                printk("NRF24L01 device opened!\n");
                return 0;
        }
}
/************************************************************************/

/************************************************************************/  
static int nrf24l01_release(struct inode *node, struct file *file)
{
        open_count--;
        printk(DEVICE_NAME "released !\n");
        return 0;
}
/************************************************************************/

/************************************************************************/  
static struct file_operations nrf24l01_fops = {
        .owner = THIS_MODULE,
        .open = nrf24l01_open,
        .write = nrf24l01_write,
        .read = nrf24l01_read,
        .release = nrf24l01_release,
};
/************************************************************************/

/************************************************************************/
static void __exit nrf24l01_exit(void)
{
        if(NRF_devices)
        {
                cdev_del(&NRF_devices->cdev);
                kfree(NRF_devices);
        }
        device_destroy(nrf_class,MKDEV(devmajor,0));
        class_destroy(nrf_class);
        unregister_chrdev_region(dev,1);
        printk(KERN_WARNING"NRF24L01 unregister success \n");
}
/************************************************************************/

/************************************************************************/
static int __init nrf24l01_init(void)
{
        int ret;
        if(devmajor)
        {
                dev = MKDEV(devmajor,devminor);
                ret = register_chrdev_region(dev,1,DEVICE_NAME);
        }
        else
        {
                ret = alloc_chrdev_region(&dev,devminor,1,DEVICE_NAME);  
                devmajor = MAJOR(dev);
        }
        if (ret < 0) {
                printk(DEVICE_NAME " Can't register major number\n");
                return ret;
        }
        printk(KERN_WARNING"NRF24L01 get major %d\n",devmajor);
        NRF_devices = kmalloc(sizeof(struct NRF_dev),GFP_KERNEL);

        if(!NRF_devices)
        {
                ret = -ENOMEM;
                goto fail;
        }

        memset(NRF_devices,0,sizeof(struct NRF_dev));

        cdev_init(&NRF_devices->cdev,&nrf24l01_fops);
        NRF_devices->cdev.owner = THIS_MODULE;
        NRF_devices->cdev.ops = &nrf24l01_fops;
        ret = cdev_add(&NRF_devices->cdev,dev,1);
        if(ret)
        {
                printk(KERN_WARNING"Error        %d  adding DEMO\n",ret);
        }
        /*动态创建结点；静态方法:mknod /dev/name c major minor*/
        nrf_class = class_create(THIS_MODULE,DEVICE_NAME);
        if(IS_ERR(nrf_class))
        {
                printk("Err:failed in creating class \n");
                return -1;
        }
       
        device_create(nrf_class,NULL,MKDEV(devmajor,0),NULL,DEVICE_NAME);

        return 0;

fail:
        nrf24l01_exit();
        return ret;
}



module_init(nrf24l01_init);
module_exit(nrf24l01_exit);
MODULE_AUTHOR("lanxin");
MODULE_DESCRIPTION("NRF24L01 Driver For Mini2440");
MODULE_LICENSE("GPL");
回复

   举报本楼层   

lanxin

出0入0汤圆
 楼主| 发表于 2012-7-21 21:34:56 | 显示全部楼层
lanxin 发表于 2012-7-21 21:33
驱动程序
#include "NRF24L01.h"
typedef unsigned int uint16;

上电运行就是打印出来样的结果（不管加不加模块都一样，试过了模块是好的，一个单片机发送一个，一个单片在接收，是通的）
# ./app-nrf24l01
status = f0
status = f0
nrf24l01_init success
NRF24L01 device opened!
open /dev/nrf24l01 success
status = f0
status = f0
nrf24l01_init success
SPI_Read sta = f0
222
rx=240
AB=1
a=240
read 32
f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0 f0
回复

   举报本楼层   

返回列表 发新帖
回帖提示： 反政府言论将被立即封锁ID 。在按“提交”前，请自问一下：我这样表达会给举报吗，会给自己惹麻烦吗？ 另外：尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。【本论坛不允许直接上传手机拍摄图片，浪费大家下载带宽和论坛服务器空间，请压缩后（图片小于1兆）才上传。压缩方法可以在微信里面发给自己（不要勾选“原图），然后下载，就能得到压缩后的图片】。另外，手机版只能上传图片，要上传附件需要切换到电脑版（不需要使用电脑，手机上切换到电脑版就行，页面底部）。
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子技术论坛 ( 粤ICP备2022115958号, 版权所有：东莞阿莫电子贸易商行 创办于2004年 (公安交互式论坛备案：44190002001997 ) )

GMT+8, 2024-5-20 18:14

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

快速回复 返回顶部 返回列表