【编写LED驱动，创建三个设备文件，每一个设备文件和一个LED灯绑定，当操作这个设备文件时只能控制对应的这盏灯】

最新推荐文章于 2023-07-27 08:53:07 发布
最新推荐文章于 2023-07-27 08:53:07 发布
阅读量150 收藏
点赞数
文章标签： 底层驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41589574/article/details/131586515
版权

作业：

编写LED驱动，创建三个设备文件，每一个设备文件和一个LED灯绑定，当操作这个设备文件时只能控制对应的这盏灯。
1.将GPIO的相关寄存器封装成结构体 --------> head.h
2.LED相关驱动文件 --------> led.c
led0 ------> LED1
led1 ------> LED2
led2 ------> LED3
3.应用层测试文件 --------> test.c

head.h

#ifndef __HEAD_H__
#define __HEAD_H__
 
//定义寄存器组织结构体
typedef struct{
    unsigned int moder;
    unsigned int otyper;
    unsigned int ospeedr;
    unsigned int pupdr;
    unsigned int idr;
    unsigned int odr;
}gpio_t;
//定义GPIOE和GPIOF
#define GPIOE 0X50006000 //LED1 PE10  LED3 PE8
#define GPIOF 0X50007000 //LED2 PF10
//#define GPIOB 0X50003000
#define RCC 0X50000A28

#define LED_ON _IOW('l',1,int)
#define LED_OFF _IOW('l',0,int)

#endif

test.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/ioctl.h>
#include "head.h"

int main(int argc, char const *argv[])
{
    int a, b;
    char buf[128] = {0};
    int fd_led1 = open("/dev/led0", O_RDWR);
    if (fd_led1 < 0)
    {
        printf("打开LED1设备文件失败\n");
        exit(-1);
    }
    int fd_led2 = open("/dev/led1", O_RDWR);
    if (fd_led2 < 0)
    {
        printf("打开LED2设备文件失败\n");
        exit(-1);
    }
    int fd_led3 = open("/dev/led2", O_RDWR);
    if (fd_led3 < 0)
    {
        printf("打开LED3设备文件失败\n");
        exit(-1);
    }

    while (1)
    {
        // 从终端读取
        printf("请选择LED1灯功能\n");
        printf("0(关) 1(开)>");
        scanf("%d", &a);
        printf("请输入要控制的灯\n");
        printf("0(LED1) 1(LED2) 2(LED3)>");
        scanf("%d", &b);
        if (a == 1) // 开灯
        {
			switch (b)
			{
			case 0:
           	    ioctl(fd_led1, LED_ON, b);
				break;
			case 1:
           	    ioctl(fd_led2, LED_ON, b);
				break;
			case 2:
           	    ioctl(fd_led3, LED_ON, b);
				break;
			}
        }
        else if (a == 0) // 关灯
        {			
			switch (b)
			{
			case 0:
           	    ioctl(fd_led1, LED_OFF, b);
				break;
			case 1:
           	    ioctl(fd_led2, LED_OFF, b);
				break;
			case 2:
           	    ioctl(fd_led3, LED_OFF, b);
				break;
			}
        }
    }
    close(fd_led1);
    close(fd_led2);
    close(fd_led3);
    return 0;
}

led0.c

#include <linux/init.h>
#include <linux/module.h>
#include<linux/fs.h>
#include<linux/device.h>
#include<linux/cdev.h>
#include<linux/slab.h>
#include<linux/io.h>
#include "head.h"

struct cdev *cdev; 		//字符设备空间首地址
unsigned int major=500; //静态申请设备号
unsigned int minor=0;//次设备号的起始值
dev_t devno; 		//动态申请设备号
struct class *cls;  //接收注册结构体的地址
struct device *dev; //设备号

gpio_t *vir_gpioe;
gpio_t *vir_gpiof;
unsigned int *vir_rcc;

int mycdev_open(struct inode *inode, struct file *file)
{
	unsigned int aaa = MINOR(inode->i_rdev);  	//得到次设备号aaa
	file->private_data = (void *)aaa;

    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	unsigned int aaa = (int)file->private_data;    //次设备号
    // 功能控制
    switch (cmd)
    {
    case LED_ON:
        switch (aaa)
        {
        case 0:
            vir_gpioe->odr |= (0x1 << 10);
            break;
        }
        break;
    case LED_OFF:
        switch (aaa)
        {
        case 0:
            vir_gpioe->odr &= (~(0x1 << 10));
            break;
        }
        break;
    }
    return 0;
}

int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

// 定义操作方法结构体变量并赋值
struct file_operations fops = {

    .open = mycdev_open,
    .unlocked_ioctl = mycdev_ioctl,
    .release = mycdev_close,
};

static int __init mycdev_init(void)   //寄存器地址映射和初始化
{
    int ret; 				//ret返回错误码 

	// 映射物理地址
    vir_gpioe = ioremap(GPIOE, sizeof(gpio_t));
    if (vir_gpioe == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }

    vir_rcc = ioremap(RCC, 4);
    if (vir_rcc == NULL)
    {
        printk("RCC寄存器映射失败\n");
        return -EFAULT;
    }

    vir_gpiof = ioremap(GPIOF, sizeof(gpio_t));
    if (vir_gpiof == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }
    printk("寄存器映射成功\n");

    //1.分配字符设备驱动对象空间  cdev_alloc
    cdev=cdev_alloc(); 		//字符设备空间首地址
    if(cdev==NULL)
    {
        printk("申请字符设备驱动对象空间失败\n");
        ret=-EFAULT;
        goto out1;
    }
    printk("字符设备驱动对象申请成功\n");

    //2.字符设备驱动对象部分初始化  cdev_init
    cdev_init(cdev,&fops);

    //3.申请设备号  register_chrdev_region/alloc_chrdev_region
    if(major>0)//静态申请设备号
    {
        ret=register_chrdev_region(MKDEV(major,minor),1,"led0"); //设备号需要是组合出来的,次设备数量，设备文件名
        if(ret)
        {
            printk("静态指定设备号失败\n");
            goto out2;
        }
    }
    else//动态申请设备号
    {
        ret=alloc_chrdev_region(&devno,minor,1,"led0");   //动态申请设备号，次设备号，设备数量，文件名
         if(ret)
        {
            printk("动态申请设备号失败\n");
            goto out2;
        }
        major=MAJOR(devno); 	//根据设备号得到主设备号
        minor=MINOR(devno); 	//根据设备号得到次设备号
    }
    printk("申请设备号成功\n");

    //4.注册字符设备驱动对象  cdev_add()
    ret=cdev_add(cdev,MKDEV(major,minor),1); //字符设备，设备号，设备数量
    if(ret)
    {
        printk("注册字符设备驱动对象失败\n");
        goto out3;
    }
    printk("注册字符设备驱动对象成功\n");

    //5.向上提交目录
    cls=class_create(THIS_MODULE,"led0"); //指向自身的指针，文件名
    if(IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        ret=-PTR_ERR(cls);
        goto out4;
    }
    printk("向上提交目录成功\n");

    //6.向上提交设备节点
    dev=device_create(cls,NULL,MKDEV(major,0),NULL,"led0"); //创建设备节点
    if(IS_ERR(dev))
    {
        printk("向上提交节点信息失败\n");
        ret=-PTR_ERR(dev);
        goto out5;
    }
    printk("向上提交设备节点信息成功\n");

     (*vir_rcc) |= (0x3 << 4);
    // 寄存器初始化led1
    vir_gpioe->moder &= (~(0x3 << 20));
    vir_gpioe->moder |= (0x1 << 20);
    vir_gpioe->odr &= (~(0x1 << 10));
    printk("LED1硬件寄存器初始化成功\n");
    return 0;

out5:
    //销毁上面提交的设备信息
    device_destroy(cls,MKDEV(major,0));
    class_destroy(cls);
out4:
    cdev_del(cdev);
out3:
    unregister_chrdev_region(MKDEV(major,minor),1);
out2:
    kfree(cdev);
out1:
    return ret;
}
static void __exit mycdev_exit(void)
{
    //1.销毁设备信息  device_destroy
    device_destroy(cls,MKDEV(major,0));
    //2.销毁目录  class_destroy
    class_destroy(cls);
    //3.注销对象  cdev_del()
    cdev_del(cdev);
    //4.释放设备号   unregister_chrdev_region()
    unregister_chrdev_region(MKDEV(major,minor),1);
    //5.释放对象空间  kfree()
    kfree(cdev);

	// 取消寄存器地址映射
    iounmap(vir_gpioe);
    iounmap(vir_rcc);
    iounmap(vir_gpiof);
    // 销毁设备节点信息
	device_destroy(cls, MKDEV(major, 0));
	// 销毁字符设备驱动
    class_destroy(cls);
    // 字符设备驱动的注销
    unregister_chrdev(major, "led0");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

led1.c

#include <linux/init.h>
#include <linux/module.h>
#include<linux/fs.h>
#include<linux/device.h>
#include<linux/cdev.h>
#include<linux/slab.h>
#include<linux/io.h>
#include "head.h"

struct cdev *cdev; 		//字符设备空间首地址
unsigned int major=500; //静态申请设备号
unsigned int minor=1;//次设备号的起始值
dev_t devno; 		//动态申请设备号
struct class *cls;  //接收注册结构体的地址
struct device *dev; //设备号

gpio_t *vir_gpioe;
gpio_t *vir_gpiof;
unsigned int *vir_rcc;

int mycdev_open(struct inode *inode, struct file *file)
{
	unsigned int aaa = MINOR(inode->i_rdev);  	//得到次设备号aaa
	file->private_data = (void *)aaa;

    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	unsigned int aaa = (int)file->private_data;    //次设备号
    // 功能控制
    switch (cmd)
    {
    case LED_ON:
        switch (aaa)
        {
        case 1:
            vir_gpiof->odr |= (0x1 << 10);
            break;
        }
        break;
    case LED_OFF:
        switch (aaa)
        {
        case 1:
            vir_gpiof->odr &= (~(0x1 << 10));
            break;
        }
        break;
    }
    return 0;
}

int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

// 定义操作方法结构体变量并赋值
struct file_operations fops = {

    .open = mycdev_open,
    .unlocked_ioctl = mycdev_ioctl,
    .release = mycdev_close,
};

static int __init mycdev_init(void)   //寄存器地址映射和初始化
{
    int ret; 				//ret返回错误码

	// 映射物理地址
    vir_gpioe = ioremap(GPIOE, sizeof(gpio_t));
    if (vir_gpioe == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }

    vir_rcc = ioremap(RCC, 4);
    if (vir_rcc == NULL)
    {
        printk("RCC寄存器映射失败\n");
        return -EFAULT;
    }

    vir_gpiof = ioremap(GPIOF, sizeof(gpio_t));
    if (vir_gpiof == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }
    printk("寄存器映射成功\n");

    //1.分配字符设备驱动对象空间  cdev_alloc
    cdev=cdev_alloc(); 		//字符设备空间首地址
    if(cdev==NULL)
    {
        printk("申请字符设备驱动对象空间失败\n");
        ret=-EFAULT;
        goto out1;
    }
    printk("字符设备驱动对象申请成功\n");

    //2.字符设备驱动对象部分初始化  cdev_init
    cdev_init(cdev,&fops);

    //3.申请设备号  register_chrdev_region/alloc_chrdev_region
    if(major>0)//静态申请设备号
    {
        ret=register_chrdev_region(MKDEV(major,minor),1,"led1"); //设备号需要是组合出来的,次设备数量，设备文件名
        if(ret)
        {
            printk("静态指定设备号失败\n");
            goto out2;
        }
    }
    else//动态申请设备号
    {
        ret=alloc_chrdev_region(&devno,minor,1,"led1");   //动态申请设备号，次设备号，设备数量，文件名
         if(ret)
        {
            printk("动态申请设备号失败\n");
            goto out2;
        }
        major=MAJOR(devno); 	//根据设备号得到主设备号
        minor=MINOR(devno); 	//根据设备号得到次设备号
    }
    printk("申请设备号成功\n");

    //4.注册字符设备驱动对象  cdev_add()
    ret=cdev_add(cdev,MKDEV(major,minor),1); //字符设备，设备号，设备数量
    if(ret)
    {
        printk("注册字符设备驱动对象失败\n");
        goto out3;
    }
    printk("注册字符设备驱动对象成功\n");

    //5.向上提交目录
    cls=class_create(THIS_MODULE,"led1"); //指向自身的指针，文件名
    if(IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        ret=-PTR_ERR(cls);
        goto out4;
    }
    printk("向上提交目录成功\n");

    //6.向上提交设备节点
    dev=device_create(cls,NULL,MKDEV(major,1),NULL,"led1"); //创建设备节点
    if(IS_ERR(dev))
    {
        printk("向上提交节点信息失败\n");
        ret=-PTR_ERR(dev);
        goto out5;
    }
    printk("向上提交设备节点信息成功\n");

     (*vir_rcc) |= (0x3 << 4);
    // 寄存器初始化led1
    vir_gpiof->moder &= (~(0x3 << 20));
    vir_gpiof->moder |= (0x1 << 20);
    vir_gpiof->odr &= (~(0x1 << 10));
    printk("LED2硬件寄存器初始化成功\n");
    return 0;

out5:
    //销毁上面提交的设备信息
    device_destroy(cls,MKDEV(major,1));
    class_destroy(cls);
out4:
    cdev_del(cdev);
out3:
    unregister_chrdev_region(MKDEV(major,minor),1);
out2:
    kfree(cdev);
out1:
    return ret;
}
static void __exit mycdev_exit(void)
{
    //1.销毁设备信息  device_destroy
    device_destroy(cls,MKDEV(major,1));
    //2.销毁目录  class_destroy
    class_destroy(cls);
    //3.注销对象  cdev_del()
    cdev_del(cdev);
    //4.释放设备号   unregister_chrdev_region()
    unregister_chrdev_region(MKDEV(major,minor),1);
    //5.释放对象空间  kfree()
    kfree(cdev);

	// 取消寄存器地址映射
    iounmap(vir_gpioe);
    iounmap(vir_rcc);
    iounmap(vir_gpiof);
    // 销毁设备节点信息
	device_destroy(cls, MKDEV(major, 1));
	// 销毁字符设备驱动
    class_destroy(cls);
    // 字符设备驱动的注销
    unregister_chrdev(major, "led1");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

led2.c

#include <linux/init.h>
#include <linux/module.h>
#include<linux/fs.h>
#include<linux/device.h>
#include<linux/cdev.h>
#include<linux/slab.h>
#include<linux/io.h>
#include "head.h"

struct cdev *cdev; 		//字符设备空间首地址
unsigned int major=500; //静态申请设备号
unsigned int minor=2;//次设备号的起始值
dev_t devno; 		//动态申请设备号
struct class *cls;  //接收注册结构体的地址
struct device *dev; //设备号

gpio_t *vir_gpioe;
gpio_t *vir_gpiof;
unsigned int *vir_rcc;

int mycdev_open(struct inode *inode, struct file *file)
{
	unsigned int aaa = MINOR(inode->i_rdev);  	//得到次设备号aaa
	file->private_data = (void *)aaa;

    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	unsigned int aaa = (int)file->private_data;    //次设备号
    // 功能控制
    switch (cmd)
    {
    case LED_ON:
        switch (aaa)
        {
        case 2:
            vir_gpioe->odr |= (0x1 << 8);
            break;
        }
        break;
    case LED_OFF:
        switch (aaa)
        {
        case 2:
            vir_gpioe->odr &= (~(0x1 << 8));
            break;
        }
        break;
    }
    return 0;
}

int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

// 定义操作方法结构体变量并赋值
struct file_operations fops = {

    .open = mycdev_open,
    .unlocked_ioctl = mycdev_ioctl,
    .release = mycdev_close,
};

static int __init mycdev_init(void)   //寄存器地址映射和初始化
{
    int ret; 				//ret返回错误码 

	// 映射物理地址
    vir_gpioe = ioremap(GPIOE, sizeof(gpio_t));
    if (vir_gpioe == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }

    vir_rcc = ioremap(RCC, 4);
    if (vir_rcc == NULL)
    {
        printk("RCC寄存器映射失败\n");
        return -EFAULT;
    }

    vir_gpiof = ioremap(GPIOF, sizeof(gpio_t));
    if (vir_gpiof == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }
    printk("寄存器映射成功\n");

    //1.分配字符设备驱动对象空间  cdev_alloc
    cdev=cdev_alloc(); 		//字符设备空间首地址
    if(cdev==NULL)
    {
        printk("申请字符设备驱动对象空间失败\n");
        ret=-EFAULT;
        goto out1;
    }
    printk("字符设备驱动对象申请成功\n");

    //2.字符设备驱动对象部分初始化  cdev_init
    cdev_init(cdev,&fops);

    //3.申请设备号  register_chrdev_region/alloc_chrdev_region
    if(major>0)//静态申请设备号
    {
        ret=register_chrdev_region(MKDEV(major,minor),1,"led2"); //设备号需要是组合出来的,次设备数量，设备文件名
        if(ret)
        {
            printk("静态指定设备号失败\n");
            goto out2;
        }
    }
    else//动态申请设备号
    {
        ret=alloc_chrdev_region(&devno,minor,1,"led2");   //动态申请设备号，次设备号，设备数量，文件名
         if(ret)
        {
            printk("动态申请设备号失败\n");
            goto out2;
        }
        major=MAJOR(devno); 	//根据设备号得到主设备号
        minor=MINOR(devno); 	//根据设备号得到次设备号
    }
    printk("申请设备号成功\n");

    //4.注册字符设备驱动对象  cdev_add()
    ret=cdev_add(cdev,MKDEV(major,minor),1); //字符设备，设备号，设备数量
    if(ret)
    {
        printk("注册字符设备驱动对象失败\n");
        goto out3;
    }
    printk("注册字符设备驱动对象成功\n");

    //5.向上提交目录
    cls=class_create(THIS_MODULE,"led2"); //指向自身的指针，文件名
    if(IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        ret=-PTR_ERR(cls);
        goto out4;
    }
    printk("向上提交目录成功\n");

    //6.向上提交设备节点
    dev=device_create(cls,NULL,MKDEV(major,2),NULL,"led2"); //创建设备节点
    if(IS_ERR(dev))
    {
        printk("向上提交节点信息失败\n");
        ret=-PTR_ERR(dev);
        goto out5;
    }
    printk("向上提交设备节点信息成功\n");

     (*vir_rcc) |= (0x3 << 4);
    // 寄存器初始化led1
    vir_gpioe->moder &= (~(0x3 << 16));
    vir_gpioe->moder |= (0x1 << 16);
    vir_gpioe->odr &= (~(0x1 << 8));
    printk("LED1硬件寄存器初始化成功\n");
    return 0;

out5:
    //销毁上面提交的设备信息
    device_destroy(cls,MKDEV(major,2));
    class_destroy(cls);
out4:
    cdev_del(cdev);
out3:
    unregister_chrdev_region(MKDEV(major,minor),1);
out2:
    kfree(cdev);
out1:
    return ret;
}
static void __exit mycdev_exit(void)
{
    //1.销毁设备信息  device_destroy
    device_destroy(cls,MKDEV(major,2));
    //2.销毁目录  class_destroy
    class_destroy(cls);
    //3.注销对象  cdev_del()
    cdev_del(cdev);
    //4.释放设备号   unregister_chrdev_region()
    unregister_chrdev_region(MKDEV(major,minor),1);
    //5.释放对象空间  kfree()
    kfree(cdev);

	// 取消寄存器地址映射
    iounmap(vir_gpioe);
    iounmap(vir_rcc);
    iounmap(vir_gpiof);
    // 销毁设备节点信息
	device_destroy(cls, MKDEV(major, 2));
	// 销毁字符设备驱动
    class_destroy(cls);
    // 字符设备驱动的注销
    unregister_chrdev(major, "led2");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

实验结果

在这里插入图片描述

Ding-HL
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux LED字符设备驱动，基于平台驱动的LED字符设备驱动，支持多个LED灯，没有体现分层设计思想
03-04
基于平台驱动的基本的LED字符设备驱动，支持多个LED灯，整个驱动分为两部分，一部分定义资源led_dev.c，一部分定义操作led_drv.c，未体现Linux驱动分层设计思想
一个最基本的Linux LED字符设备驱动，支持多个LED灯
03-02
一个最基本的Linux LED字符设备驱动，纯字符设备驱动，不适用任何框架，支持多个LED灯。
设备文件、设备文件节点 、设备 、设备驱动 区别
jinchengzhou的专栏
06-16 5986
1.设备 Linux下的设备通常分为三类，字符设备，块设备和网络设备。 见的字符设备有鼠标、键盘、串口、控制台等。 常见的块设备有各种硬盘、flash磁盘、RAM磁盘等。 在Linux里一个网络设备也可以叫做一个网络接口，如eth0，应用程序是通过Socket而不是设备节点来访问网络设备，在系统里根本就不存在网络设备节点。 网络接口没有像字符设备和块设备一样的设备号，只有一个唯一的名字，
设备与驱动的关系以及设备号、设备文件
weixin_34255793的博客
03-21 293
Linux设备分类Linux下的设备通常分为三类，字符设备，块设备和网络设备。 字符设备 一个字符设备是一种字节流设备，对设备的存取只能按顺序按字节的存取而不能随机访问，字符设备没有请求缓冲区，所有的访问请求都是按顺序执行的。Linux下的大多设备都是字符设备。应用程序是通过字符设备节点来访问字符设备的。设备节点一般都由mknod命令都创建在/dev目录下，下面的例子显示了串口设备的设备节点。...
Linux设备驱动程序和设备文件
qhh0205
01-14 6324
Linux设备驱动程序和设备文件 设备驱动程序 一个设备驱动程序是一个管理着系统与某种特定硬件之间交互作用的程序。驱动程序在设备可理解的硬件指令和内核使用的固定编程接口之间起转换作用。驱动程序层的存在有助于内核合理地保持设备独立性。 在大多数情况下，设备驱动程序是内核的组成部分，它们不是用户进程。不过，一个驱动程序可以从内核里，也可以从用户空间进行访问。对设备的用户级访问往往要通过位于/
编写LED灯的驱动，创建三个设备文件，每个设备文件和一个LED灯绑定，当操作这个设备文件时只能控制设备文件对应的这盏灯
Yg118的博客
07-06 198
【代码】编写LED灯的驱动，创建三个设备文件，每个设备文件和一个LED灯绑定，当操作这个设备文件时只能控制设备文件对应的这盏灯。
驱动_编写三个文件设备，每个设备文件绑定一个LED灯，当操作这个设备文件时只能控制设备文件对应的这盏灯
lsw2604190117的博客
07-26 139
【代码】驱动_编写三个文件设备，每个设备文件绑定一个LED灯，当操作这个设备文件时只能控制设备文件对应的这盏灯。
编写LED驱动，创建三个设备文件，每个设备文件绑定一个设备
weixin_60693863的博客
07-26 160
【代码】编写LED驱动，创建三个设备文件，每个设备文件绑定一个设备。
编写LED驱动，创建三个设备文件，每个设备文件绑定一个设备，应用程序测试
qq_59539828的博客
07-27 92
【代码】编写LED驱动，创建三个设备文件，每个设备文件绑定一个设备，应用程序测试。
编写LED灯的驱动，创建三个设备文件，每个设备文件和LED灯绑定，当操作这个设备文件时只能控制设备对应的这盏灯
m0_59681498的博客
07-06 160
【代码】编写LED灯的驱动，创建三个设备文件，每个设备文件和LED灯绑定，当操作这个设备文件时只能控制设备对应的这盏灯。
[驱动开发]编写LED驱动，创建三个设备文件
weixin_63807948的博客
07-26 135
【代码】[驱动开发]编写LED驱动，创建三个设备文件。
Linux LED字符设备驱动，基于平台驱动的LED字符设备驱动，支持多个LED灯，体现Linux驱动的分层设计思想
03-04
整个驱动分为三个部分，板级驱动(led_dev.c)定义板级资源，芯片级驱动(led_imx6ull.c)定义了芯片相关的结构和操作，系统级驱动(leddrv.c)定义了字符设备相关的接口。更改硬件只需要替换led_dev.c，更换芯片需要替换...
单片机驱动一个LED闪烁ppt课件.ppt
10-27
单片机驱动一个LED闪烁是单片机程序设计的基础知识点之一，本节课件将引导学生学习单片机驱动LED闪烁的原理和实现方法。 知识点1：单片机的I/O口可以直接驱动一些器件 单片机的I/O口可以直接驱动一些器件，如LED、...
点亮一个LED灯.zip
07-01
仿真 工程文件 教学视频 点亮一个LED灯 小亮的物联网之路出品更多有趣好玩的单片机实验在小亮的物联网之路微信公众号上
合信TP-i系列HMI触摸屏CAD图.zip
最新发布
06-25
合信TP-i系列HMI触摸屏CAD图
Mysql 数据库操作技术 简单的讲解一下
06-25
讲解数据库操作方面的基础知识，基于Mysql的，不是Oracle
flickr8k-test-gt.json
06-25
flickr8k数据集的flickr8k_test_gt.json文件
基于SSM+Vue的新能源汽车在线租赁管理系统（免费提供全套java开源毕业设计源码+数据库+开题报告+论文+ppt+使用说明）
06-25
随着科学技术的飞速发展，社会的方方面面、各行各业都在努力与现代的先进技术接轨，通过科技手段来提高自身的优势，新能源汽车在线租赁当然也不能排除在外。新能源汽车在线租赁是以实际运用为开发背景，运用软件工程开发方法，采用SSM技术构建的一个管理系统。整个开发过程首先对软件系统进行需求分析，得出系统的主要功能。接着对系统进行总体设计和详细设计。总体设计主要包括系统总体结构设计、系统数据结构设计、系统功能设计和系统安全设计等；详细设计主要包括模块实现的关键代码，系统数据库访问和主要功能模块的具体实现等。最后对系统进行功能测试，并对测试结果进行分析总结，及时改进系统中存在的不足，为以后的系统维护提供了方便，也为今后开发类似系统提供了借鉴和帮助。 本新能源汽车在线租赁采用的数据库是Mysql，使用SSM框架开发。在设计过程中，充分保证了系统代码的良好可读性、实用性、易扩展性、通用性、便于后期维护、操作方便以及页面简洁等特点。 关键词：新能源汽车在线租赁，SSM框架，Mysql 数据库
写一个linux设备驱动程序，点亮LED灯
05-16
以下是一个简单的Linux设备驱动程序，用于点亮LED灯。该程序使用了GPIO子系统和字符设备框架。 ```c #include <linux/kernel.h> #include <linux/module.h> #include <linux/fs.h> #include <linux/gpio.h> #include <asm/uaccess.h> #define LED_PIN 17 // 在树莓派上，GPIO17对应的针脚可以用来控制LED灯 static int led_value = 0; // LED灯的状态，0表示关闭，1表示打开 static dev_t dev_num; // 设备号 static struct class *dev_class; // 设备类别 static struct device *dev; // 设备 // 打开设备 static int led_open(struct inode *inode, struct file *file) { return 0; } // 从设备中读取数据 static ssize_t led_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) { return 0; } // 向设备中写入数据 static ssize_t led_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { char kbuf; // 从用户空间中读取一个字节的数据 if (copy_from_user(&kbuf, buf, 1)) return -EFAULT; // 根据读取的数据来控制LED灯 if (kbuf == '0') { gpio_set_value(LED_PIN, 0); led_value = 0; } else if (kbuf == '1') { gpio_set_value(LED_PIN, 1); led_value = 1; } return 1; } // 关闭设备 static int led_release(struct inode *inode, struct file *file) { return 0; } // 设备操作函数 static struct file_operations led_fops = { .owner = THIS_MODULE, .open = led_open, .read = led_read, .write = led_write, .release = led_release, }; // 初始化设备驱动程序 static int __init led_init(void) { int ret; // 申请GPIO资源 ret = gpio_request(LED_PIN, "LED"); if (ret < 0) { printk(KERN_ERR "Failed to request GPIO %d: %d\n", LED_PIN, ret); return ret; } // 设置GPIO方向为输出 ret = gpio_direction_output(LED_PIN, 0); if (ret < 0) { printk(KERN_ERR "Failed to set GPIO %d direction: %d\n", LED_PIN, ret); gpio_free(LED_PIN); return ret; } // 注册字符设备驱动程序 ret = alloc_chrdev_region(&dev_num, 0, 1, "led"); if (ret < 0) { printk(KERN_ERR "Failed to allocate device number: %d\n", ret); gpio_free(LED_PIN); return ret; } // 创建设备类别 dev_class = class_create(THIS_MODULE, "led"); if (IS_ERR(dev_class)) { printk(KERN_ERR "Failed to create device class\n"); unregister_chrdev_region(dev_num, 1); gpio_free(LED_PIN); return PTR_ERR(dev_class); } // 创建设备 dev = device_create(dev_class, NULL, dev_num, NULL, "led"); if (IS_ERR(dev)) { printk(KERN_ERR "Failed to create device\n"); class_destroy(dev_class); unregister_chrdev_region(dev_num, 1); gpio_free(LED_PIN); return PTR_ERR(dev); } // 注册设备操作函数 cdev_init(&led_cdev, &led_fops); ret = cdev_add(&led_cdev, dev_num, 1); if (ret < 0) { printk(KERN_ERR "Failed to add device to kernel: %d\n", ret); device_destroy(dev_class, dev_num); class_destroy(dev_class); unregister_chrdev_region(dev_num, 1); gpio_free(LED_PIN); return ret; } printk(KERN_INFO "LED device driver initialized\n"); return 0; } // 卸载设备驱动程序 static void __exit led_exit(void) { // 删除字符设备 cdev_del(&led_cdev); // 销毁设备 device_destroy(dev_class, dev_num); // 销毁设备类别 class_destroy(dev_class); // 释放设备号 unregister_chrdev_region(dev_num, 1); // 释放GPIO资源 gpio_free(LED_PIN); printk(KERN_INFO "LED device driver unloaded\n"); } module_init(led_init); module_exit(led_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Your Name"); MODULE_DESCRIPTION("LED device driver"); ``` 在上述代码中，我们使用`gpio_request()`函数来申请GPIO资源，并使用`gpio_direction_output()`函数将GPIO设置为输出模式。在`led_write()`函数中，我们根据用户空间中读取的数据来控制LED灯的状态。在`led_init()`函数中，我们先申请GPIO资源，然后创建字符设备，并将其注册到内核中。在`led_exit()`函数中，我们释放了GPIO资源，并删除了字符设备。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值