Linux下2.4G无线模块驱动程序_NRF24L01

最新推荐文章于 2024-11-29 13:31:32 发布
最新推荐文章于 2024-11-29 13:31:32 发布
阅读量2.7k 收藏 5
点赞数
分类专栏： 嵌入式 文章标签： 嵌入式 NRF24L01 SPI OK6410 linux
Linux下2.4G无线模块驱动程序_NRF24L01  2010-07-28 23:17:12

分类： LINUX

NRF24L01使用的SPI协议通信，这里直接用IO口模拟SPI。而根据Datasheet所示，NRF24L01的SPI接速率为0~8Mbps，因此需要在读写时序上加上适当的延时。
驱动程序：nrf24l01.c
 

#include <linux/config.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 <linux/devfs_fs_kernel.h>

#include <asm/uaccess.h>
#include <asm/hardware.h>
#include <asm/arch/regs-gpio.h>

typedef unsigned int uint16 ;
typedef unsigned char uint8 ;

/*
//和引脚相关的宏定义
#define CE S3C2410_GPF3
#define CE_OUTP S3C2410_GPF3_OUTP
#define SCK S3C2410_GPF4
#define SCK_OUTP S3C2410_GPF4_OUTP
#define MISO S3C2410_GPG3
#define MISO_INP S3C2410_GPG3_INP
#define IRQ S3C2410_GPG0
#define IRQ_OUTP S3C2410_GPG0_OUTP
#define MOSI S3C2410_GPG5
#define MOSI_OUTP S3C2410_GPG5_OUTP
#define CSN S3C2410_GPG6
#define CSN_OUTP S3C2410_GPG6_OUTP
*/

//和引脚相关的宏定义

#define CSN S3C2410_GPF3
#define CSN_OUTP S3C2410_GPF3_OUTP
#define MOSI S3C2410_GPF4
#define MOSI_OUTP S3C2410_GPF4_OUTP
#define IRQ S3C2410_GPG3
#define IRQ_INP S3C2410_GPG3_INP
#define MISO S3C2410_GPG0
#define MISO_INP S3C2410_GPG0_INP
#define SCK S3C2410_GPG5
#define SCK_OUTP S3C2410_GPG5_OUTP
#define CE S3C2410_GPG6
#define CE_OUTP S3C2410_GPG6_OUTP

#define DEVICE_NAME "NRF24L01" //设备名称，在可以 /proc/devices 查看

#define NRF24L01_MAJOR 241 //主设备号

#define TxBufSize 32

uint8 TxBuf[TxBufSize]={
 0x01,0x02,0x03,0x4,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,0x32,
};

//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_L s3c2410_gpio_setpin(SCK, 0) //拉低数据线电平 

#define SCK_H s3c2410_gpio_setpin(SCK, 1) //拉高数据线电平 


#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 uint8s TX address width

#define RX_ADR_WIDTH 5 // 5 uint8s RX address width

#define TX_PLOAD_WIDTH 32 // 20 uint8s TX payload

#define RX_PLOAD_WIDTH 32 // 20 uint8s TX payload

uint8 const TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01}; //本地地址

uint8 const RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01}; //接收地址



//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栈入栈出状态寄存器设置


 

uint8 init_NRF24L01(void);

uint8 SPI_RW(uint8 tmp);

uint8 SPI_Read(uint8 reg);

void SetRX_Mode(void);

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);

unsigned char nRF24L01_RxPacket(unsigned char* rx_buf);

void nRF24L01_TxPacket(unsigned char * tx_buf);

//全局变量

uint8 opencount = 0;


//

uint8 sta; //状态标志

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

 

//NRF24L01初始化

uint8 init_NRF24L01(void)
{
/*
    CE_UP;
    SCK_UP;
    MISO_UP;
    IRQ_UP;
    MOSI_UP;
    CSN_UP; 
*/

    MISO_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 ，主接收


    mdelay(1000);
    nRF24L01_TxPacket(TxBuf);
    SPI_RW_Reg(WRITE_REG+STATUS,0XFF); 
    printk("test 1 \n");
    mdelay(1000);
/*
    nRF24L01_TxPacket(TxBuf);
    SPI_RW_Reg(WRITE_REG+STATUS,0XFF); 
    printk("test 2 \n");
    mdelay(1000);
    nRF24L01_TxPacket(TxBuf);
    SPI_RW_Reg(WRITE_REG+STATUS,0XFF); 
    printk("test 3 \n");
    mdelay(1000);
    nRF24L01_TxPacket(TxBuf);
    SPI_RW_Reg(WRITE_REG+STATUS,0XFF); 
    printk("test 4 \n");
    mdelay(1000);
*/
    return (1);
}


//函数：uint8 SPI_RW(uint8 tmp)

//功能：NRF24L01的SPI写时序tmp

uint8 SPI_RW(uint8 tmp)
{
    uint8 bit_ctr;

    for(bit_ctr=0 ;bit_ctr<8 ;bit_ctr++) // output 8-bit

    {
 if(tmp & 0x80) // output 'tmp', MSB to MOSI

     MOSI_H;
 else
     MOSI_L;
  
        tmp <<= 1; // shift next bit into MSB..


        SCK_H; // Set SCK high..

 ndelay(60);

        tmp |= MISO_STU; // capture current MISO bit

        SCK_L; // ..then set SCK low again

 ndelay(60);
    }
    return(tmp); // return read tmp 

}

 

//函数：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(60);
    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,uint8_ctr;
    
    CSN_L; // Set CSN low, init SPI tranaction

    ndelay(60);
    status = SPI_RW(reg); // Select register to write to and read status uint8

    
    for(uint8_ctr=0;uint8_ctr<uchars;uint8_ctr++)
    {
        pBuf[uint8_ctr] = SPI_RW(0); // 

        ndelay(20);
    }
    
    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,uint8_ctr;
    
    CSN_L; //SPI使能 

    ndelay(60);
    status = SPI_RW(reg); 
    for(uint8_ctr=0; uint8_ctr<uchars; uint8_ctr++) //

    {
        SPI_RW(*pBuf++);
     ndelay(20);
    }
    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 ，主接收

    //udelay(1);

    CE_H;
    udelay(130);
}

 

//函数：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); // 读取状态寄存其来判断数据接收状况

    if(sta & (1<<RX_DR)) // 判断是否接收到数据

    {
        CE_L; //SPI使能

     udelay(50);
        SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer

        revale =1; //读取数据完成标志

    }
    SPI_RW_Reg(WRITE_REG+STATUS,sta); //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志

    return revale;
}


//函数：void nRF24L01_TxPacket(unsigned char * tx_buf)

//功能：发送 tx_buf中数据

void nRF24L01_TxPacket(unsigned char * tx_buf)
{
    CE_L; //StandBy I模式 

    ndelay(60);
    SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // 装载接收端地址

    SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH); // 装载数据 

    SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e); // IRQ收发完成中断响应，16位CRC，主发送

    CE_H; //置高CE，激发数据发送

    udelay(10);
}

//文件的写函数

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(TxBuf);
    SPI_RW_Reg(WRITE_REG+STATUS,0XFF); 
    printk("OK! \n");
    return(10);
}

//的读函数

static ssize_t nrf24l01_read(struct file *filp, char *buffer,
              size_t count, loff_t *ppos)
{
    nRF24L01_TxPacket(TxBuf);
    SPI_RW_Reg(WRITE_REG+STATUS,0XFF);
    printk("read \n");

    return (10);
}

static int nrf24l01_open(struct inode *node, struct file *file)
{
  uint8 flag = 0;

  if(opencount == 1)
    return -EBUSY;
  
  flag = init_NRF24L01();

  mdelay(100);
  if(flag == 0)
    {
      printk("uable to open device!\n");
      return -1;
    }
  else
   {
      opencount++;
      printk("device opened !\n");
      return 0;
   }
}

static int nrf24l01_release(struct inode *node, struct file *file)
{
  opencount--;
  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 int __init nrf24l01_init(void)
{
    int ret;

    printk("Initial driver for NRF24L01......................\n");
    ret = register_chrdev(NRF24L01_MAJOR, DEVICE_NAME, &nrf24l01_fops);
    mdelay(10);
    if (ret < 0)
    {
        printk(DEVICE_NAME " can't register major number\n");
        return ret;

    }
    else
    {
        printk(DEVICE_NAME " register success\n");
 return 0;
    }
}

static void __exit nrf24l01_exit(void)
{
    unregister_chrdev(NRF24L01_MAJOR, DEVICE_NAME);
    printk("NRF24L01 unregister success \n");
}


module_init(nrf24l01_init);
module_exit(nrf24l01_exit);
MODULE_AUTHOR("hjf");
MODULE_DESCRIPTION("nrf24l01 driver");
MODULE_LICENSE("GPL");

测试程序：test.c


 

#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 TxBuf[32] = {0x00};

int main(void)

{

    int fd = -1;

    int count = 1;
 

    //fd = open("/dev/nrf24l01", 0);


    fd = open("/dev/nrf24l01", O_RDWR); //打开nrf24l01为可读写文件


    if(fd < 0)

    {

        perror("Can't open /dev/nrf24l01 \n");

        exit(1);

    }

    printf("open /dev/nrf24l01 success \n");

    while(count <= 5)
    {

        write(fd, &TxBuf , sizeof(TxBuf));

        printf("Sending %d time \n", count);

        usleep(100*1000);
            
        count++;
    }

    close(fd);
}

2.4G驱动程序及资料
02-25
2.4G基本驱动 已经使用过，是一些基本的操作函数
Linux下驱动2.4G无线模块(NRF24L01)
s3c44b0x的专栏
04-04 2832
Linux下驱动2.4G无线模块(NRF24L01)   2010-02-06 11:29:45|  分类： linux驱动 |  标签： |字号大中小 订阅         NRF24L01使用的SPI协议通信，这里并没有用到s3c2440自带的SPI功能，而是直接用IO口模拟SPI。而根
嵌入式linux中nRF24L01驱动(主控板tiny4412)
青石玄霄
02-09 3072
一直想整理下15年的一些知识，终于，久违了的第一篇。 或许网上有博主写过nRF24L01驱动，如果认为侵权，请与我联系。 接触nRF24L01是因为毕业设计，需要利用这个无线模块来接受数据，所以在代码中只有接受的部分，发送的框架也有，里面的代码根据功能自己实现。 与网上其他资料一样，本人没有使用linux下自带的SPI子系统，用的是IO模拟的方式来控制这个无线模块。说实话，我一开始研究的时候
2.4G无线模块程序
01-18
TI公司cc2500无线模块程序，包括芯片寄存器配置，SPI程序。
2.4G无线通信应用程序
02-06
开发环境为STM32F103ZET6，使用编译器为Keil,程序可作为模板例程学习，也可以根据这个程序搭建工程，程序具有很好的可移植性及工程应用性
nrf.rar_ nrf_linux 24L01_nRF_nRF2401_nrf linux
09-19
从标签“_nrf linux_24l01 nrf nrf2401 nrf_linux”可以推断出，内容可能涵盖了nRF系列芯片、24L01芯片在Linux环境下的开发和应用，包括但不限于驱动开发、编程接口（API）、无线通信协议等。 压缩包内的文件...
24L01无线模块单机测试.rar_24L01无线模块单机测试_24l01测试
09-24
24L01无线模块是一种基于Nordic Semiconductor的NRF24L01+芯片的低成本、低功耗的2.4GHz无线通信模块。这种模块广泛应用于各种物联网(IoT)设备，如智能家居、遥控器、传感器网络等，因其简单易用和低成本而备受青睐...
基于ARM11的嵌入式Linux中nRF24L01驱动的实现.pdf
09-06
论文作者首先介绍了nRF24L01芯片的性能特性和Linux系统下字符设备驱动开发的基本流程，然后详细阐述了如何利用GPIO接口模拟SPI时序，实现对nRF24L01的读写操作，从而驱动该无线模块。 系统设计部分，论文涵盖了硬件...
imx6ul_linux_nrf24l01_spi.rar_spi linux_imx6ul_imx6ul spi nrf24
10-03
imx6ul_linux_nrf24l01_spi.rar是为了在Linux系统下使用imx6ul和nrf24l01芯片而创建的驱动程序包。通过SPI接口，Linux系统与imx6ul芯片和nrf24l01模块之间建立通信连接。该驱动程序包提供了一组API，可以轻松地在...
NRF24L01驱动程序
12-19
NRF24L01驱动程序是为无线通信模块NRF24L01设计的一套软件接口，它使得单片机如STC或51系列能够与NRF24L01进行有效通信，实现无线数据传输。NRF24L01是一款低成本、低功耗的2.4GHz射频收发器，广泛应用于短距离无线...
2.4G无线收发程序.rar
07-29
STm32单片机的无线通信NRF24L01 是 NORDIC 公司最近生产的一款无线通信通信芯片，采用 FSK 调制，内部 集成 NORDIC 自己的 Enhanced Short Burst 协议。可以实现点对点或是 1 对 6 的无线通信。 无线通信速度可以达到 2M（bps）。NORDIC 公司提供通信模块的 GERBER 文件，可以直 接加工生产。嵌入式工程师或是单片机爱好者只需要为单片机系统预留 5 个 GPIO，1 个中 断输入引脚，就可以很容易实现无线通信的功能，非常适合用来为 MCU 系统构建无线通信 功
嵌入式Linux中nRF24L01用户模式驱动设计.pdf
09-06
嵌入式Linux中nRF24L01用户模式驱动设计.pdf
2.4G无线通信协议程序及说明
05-24
在网上看到的一款基于nrf24l01芯片实现的自组网套件，芯片基于stm32f103c8t6，有上位机！
2.4G/5G双频无线抓包网卡驱动
03-05
产品介绍，型号B58-01： 本产品为使用Ralink芯片研发的一款5G/2.4G网卡，支持Omnipeek软件，可以抓-取802.11 ac/b/g/n数据，可以抓5G和2.4G数据，300Mbps，可用于802.11无线数据分析，WiFi调试开发人员必备！ 功能说明：使用本网卡不需要实际的建立连接就可以抓到802.11无线数据，支持无线空口抓包，可用于研究开发WiFi协议了解无线连接过程，监控无线网络等，是WiFi工程师的研发好伴侣，购买网卡提供驱动以及相关教程。 注意：经测试Omnipeek软件支持Win7，Windows XP 系统，Win8暂时无法支持，Win8.1部分电脑支持；
2.4G无线配对流程
03-18
简写定义: MDA ( MPR Default Address ): 默认地址，值为: 0x39 0x26 0x04 0x08 0x11 MMA ( MPR Matched Address ): 配对响应的随机地址，由机顶盒随机生成发送给遥控器 RMR (Remote Match Request): 配对请求包 TMR (TVBox Match Response): 配对响应包 RMC (Remote Match confirm): 配对确认包
linux下的nrf24l01驱动程序
个人工作学习笔记
03-05 1981
文件名：nrf24l01.c 功能:linux下的nrf24l01驱动程序 #include #include #include #include #include #include #include #include #include #include #include typedef unsigned int uint16 ; typedef unsigned char
nrf24l01linux下的驱动程序
linuxembe的专栏
07-13 1817
最近太多的网友发邮件给我要nrf24l01的驱动程序 现在贴出来供需要的人参考 /******************************************************************************* * 此驱动程序是linux下nrf24l01的设备驱动程序，驱动程序由两部分组成： * 1、nrf24l01.c * 2、nrf24l01.h ，li
Linux环境下nRF24L01 C语言编程实战指南
最新发布
weixin_33240461的博客
11-29 778
本文还有配套的精品资源，点击获取 简介：本项目通过Linux环境下的C语言编程，帮助开发者深入理解和掌握nRF24L01无线通信芯片的工作原理和技术实现。项目包括对nRF24L01的基本特性和SPI通信协议的学习，编写Linux内核驱动以实现硬件抽象层，以及在用户空间编写C语言程序来与驱动交互，实现无线通信功能。学习材料包括详尽的nRF24L01技术文档和实践案例，适合嵌入...
内核源码学习：Linux 2.4内核API（十一）转
weixiuc的专栏
11-25 1293
skb_append追加一个缓冲区void skb_append (struct sk_buff * old, struct sk_buff * newsk)old为插入之前的缓冲区，newsk为要插入的缓冲区把一个数据包放在链表中给定的包之前。该函数持有链表锁，并且是原子操作。一个缓冲区不能同时放在两个链表中。skb_unlink
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值