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

已于 2023-07-06 21:24:41 修改
阅读量264 收藏
点赞数
文章标签： arm开发 嵌入式硬件 c语言
于 2023-07-06 20:27:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yg118/article/details/131584634
版权

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

实验现象

在这里插入图片描述

test.c

#include <stdlib.h>
#include <stdio.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"

void LED_control()
{
    int a, num, fd;
    while (1)
    {
        printf("请输入操作的设备文件:0(LED1) 1(LED2) 2(LED3) 其他字符(重新选择设备文件)>>>");
        scanf("%d", &num);
        switch (num)
        {
        case 0:
            fd = open("/dev/myled0", O_RDWR);
            break;
        case 1:
            fd = open("/dev/myled1", O_RDWR);
            break;
        case 2:
            fd = open("/dev/myled2", O_RDWR);
            break;
        default:
            printf("输入有误，请重新输入！\n");
            break;
        }
        if (!(num == 0 || num == 1 || num == 2))
        {
            continue;
        }
        if (fd < 0)
        {
            printf("打开led设备文件失败\n");
            exit(-1);
        }
        while (1)
        {
            // 从终端读取
            printf("请选择要实现的功能\n");
            printf("0(关灯) 1(开灯) 2(重新选择开关灯功能) 其他字符(重新选择设备文件)>>>");
            scanf("%d", &a);
            if (a == 1) // 开灯
            {
                ioctl(fd, LED_ON, &num);
            }
            else if (a == 0) // 关灯
            {
                ioctl(fd, LED_OFF, &num);
            }
            else if (a == 2)
            {
                continue;
            }
            else
                break;
        }
        close(fd);
    }
}

int main(int argc, char const *argv[])
{
    LED_control();
    return 0;
}

my_chardev.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/device.h>
#include <linux/slab.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_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;
unsigned int *vir_rcc;
// 封装操作方法
int mycdev_open(struct inode *inode, struct file *file)
{
    unsigned int aaa=MINOR(inode->i_rdev);//得到打开的文件对应的设备号
    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(aaa)
   {
       case 0:
           //控制LED1的逻辑
            switch(cmd)
            {
                case LED_ON:
                    vir_led1->ODR |= (0x1 << 10);
                    break;
                case LED_OFF:
                    vir_led1->ODR &= (~(0X1 << 10));
                    break;
            }
           break;   
        case 1:
           //控制LED2的逻辑
           switch(cmd)
            {
                case LED_ON:
                    vir_led2->ODR |= (0x1 << 10);
                    break;
                case LED_OFF:
                    vir_led2->ODR &= (~(0X1 << 10));
                    break;
            }
           break; 
        case 2:
           //控制LED3的逻辑
           switch(cmd)
            {
                case LED_ON:
                    vir_led3->ODR |= (0x1 << 8);
                    break;
                case LED_OFF:
                    vir_led3->ODR &= (~(0X1 << 8));
                    break;
            }
           break; 
   }
    return 0;
}

int all_led_init(void)
{
    // 寄存器地址的映射
    vir_led1 = ioremap(PHY_LED1_ADDR, sizeof(gpio_t));
    if (vir_led1 == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    vir_led2 = ioremap(PHY_LED2_ADDR, sizeof(gpio_t));
    if (vir_led2 == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    vir_led3 = vir_led1;
    vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    if (vir_rcc == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    printk("物理地址映射成功\n");
    // 寄存器的初始化
    // rcc
    (*vir_rcc) |= (3 << 4);
    // led1
    vir_led1->MODER &= (~(3 << 20));
    vir_led1->MODER |= (1 << 20);
    vir_led1->ODR &= (~(1 << 10));
    // led2
    vir_led2->MODER &= (~(3 << 20));
    vir_led2->MODER |= (1 << 20);
    vir_led2->ODR &= (~(1 << 10));
    // led3
    vir_led3->MODER &= (~(3 << 16));
    vir_led1->MODER |= (1 << 16);
    vir_led1->ODR &= (~(1 << 8));
    printk("寄存器初始化成功\n");
 
    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, i;
    // 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), 3, "myled");
        if (ret)
        {
            printk("静态指定设备号失败\n");
            goto out2;
        }
    }
    else // 动态申请设备号
    {
        ret = alloc_chrdev_region(&devno, minor, 3, "myled");
        if (ret)
        {
            printk("动态申请设备号失败\n");
            goto out2;
        }
        major = MAJOR(devno); // 根据设备号得到主设备号
        minor = MINOR(devno); // 根据设备号得到次设备号
    }
    printk("申请设备号成功\n");
    // 4.注册字符设备驱动对象  cdev_add()
    ret = cdev_add(cdev, MKDEV(major, minor), 3);
    if (ret)
    {
        printk("注册字符设备驱动对象失败\n");
        goto out3;
    }
    printk("注册字符设备驱动对象成功\n");
    // 5.向上提交目录
    cls = class_create(THIS_MODULE, "myled");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        ret = -PTR_ERR(cls);
        goto out4;
    }
    printk("向上提交目录成功\n");
    // 6.向上提交设备节点
    for (i = 0; i < 3; i++)
    {
        dev = device_create(cls, NULL, MKDEV(major, i), NULL, "myled%d", i);
        if (IS_ERR(dev))
        {
            printk("向上提交节点信息失败\n");
            ret = -PTR_ERR(dev);
            goto out5;
        }
    }
    printk("向上提交设备节点信息成功\n");
    all_led_init();
    return 0;
out5:
    for (--i; i >= 0; i--)
    {
        // 销毁上面提交的设备信息
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);
out4:
    cdev_del(cdev);
out3:
    unregister_chrdev_region(MKDEV(major, minor), 3);
out2:
    kfree(cdev);
OUT1:
    return ret;
}
static void __exit mycdev_exit(void)
{
    // 1.销毁设备信息  device_destroy
    int i;
    for (i = 0; i < 3; i++)
    {
        device_destroy(cls, MKDEV(major, i));
    }
    // 2.销毁目录  class_destroy
    class_destroy(cls);
    // 3.注销对象  cdev_del()
    cdev_del(cdev);
    // 4.释放设备号   unregister_chrdev_region()
    unregister_chrdev_region(MKDEV(major, minor), 3);
    // 5.释放对象空间  kfree()
    kfree(cdev);
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

head.h

#ifndef __HEAD_H__
#define __HEAD_H__ 
typedef struct{
    volatile unsigned int MODER;   // 0x00
	volatile unsigned int OTYPER;  // 0x04
	volatile unsigned int OSPEEDR; // 0x08
	volatile unsigned int PUPDR;   // 0x0C
	volatile unsigned int IDR;     // 0x10
	volatile unsigned int ODR;     // 0x14
	volatile unsigned int BSRR;    // 0x18
	volatile unsigned int LCKR;    // 0x1C 
	volatile unsigned int AFRL;    // 0x20 
	volatile unsigned int AFRH;    // 0x24
	volatile unsigned int BRR;     // 0x28
	volatile unsigned int res;
	volatile unsigned int SECCFGR; // 0x30
}gpio_t;
#define PHY_LED1_ADDR 0X50006000
#define PHY_LED2_ADDR    0X50007000
#define PHY_LED3_ADDR 0X50006000
#define PHY_RCC_ADDR    0X50000A28
#define GPIOB 0X50003000
#define GPIOE 0X50006000
#define GPIOF 0X50007000
 
 
#define LED_ON _IOW('l',1,int)  //开灯
#define LED_OFF _IOW('l',0,int)//关灯


#endif
Rain_G_G
关注
RK3568笔记三十五：LED驱动开发测试
07-13 984
复用关系寄存器的基地址为 0xFDC20000 ，偏移地址为0x0010所以要操作的地址为基地址+偏移地址=0xFDC20010GPIO 的基地址为 0xFDD60000，偏移地址为 0x000C，所以方向寄存器要操作的地址为基地址+偏移地址=0xFDD6000CGPIO 的基地址为 0xFDD60000，偏移地址为 0x0004，所以数据寄存器要操作的地址为基地址+偏移地址=0xFDD60004。
【ARM】Linux内核驱动之设备树的学习-长文
凉开水白菜的博客
07-31 456
订阅的粉丝可通过PC端文末加我微信，可对文章的内容进行一对一答疑!描述硬件得文本文件，因为语法结构像树所以叫设备树 通过DTC编译dts、dtsi文件编译出dtb文件 所有的设备树文件都存在与下面的路径 二、如何编译设备树？ DTC编译器的源码路径，dtc文件夹下面的dtc执行文件就是我们的设备树编译器（要保证源码已经编译过一次） 如果编译完成还是没有可能是内核版本太低没有引进设备树，或者是配置选项未勾选，可以在.confg文件中查看该选项最简单的设备树源码 编译器编译指令 /home/book/liche
LED流水灯C语言程序
03-12
单片机入门程序，LED流水灯。测试可以直接在电脑上编译使用
流水灯
dxsdcxy
12-23 2614
流水灯实验是第一个实验，比较简单，我总结了两种方法，其实还有更多。 方法一、#include <reg51.h> #include <intrins.h> //左移右移函数头文件 #define GPIO_LED P2 //将P2口另外取名GPIO_LED void Delay10ms(unsigned int); //误差0μs void main(void) { unsigned
简易流水灯
最新发布
m0_66619666的博客
07-19 934
假设LED灯高电平点亮，利用有限状态机理论，设计验证将开发板上集成的led外设依次点亮，从左到右依次点亮（12341234）。将每点亮一个Led灯作为一个状态，那么依次点亮一次可以划分为4个状态，每一个状态执行的动作（输出）点亮对应的led灯，每一个状态持续的时间为：设置为1秒钟。状态之间跳转的条件为：延迟计数器计时到1秒钟。什么是状态机？状态机由状态寄存器和组合逻辑电路构成，能够根据控制信号按照预先设定的状态进行状态转移，是协调相关信号动作,完成特定操作的控制中心。
微处理器与嵌入式设备——Linux下的驱动程序开发
qq_45945307的博客
06-23 726
在本次实验中，我们利用已经设计好的硬件环境，在 Linux系统下，设计了驱动程序和测试程序，利用串口拷贝驱动和测试程序，调用测试程序对驱动进行了测试，实现了输入二进制数和开发板LED 灯之间的二进制对应关系。在实验 2 中，我们使用 uart接口读取串口信息并将其返回到串口，进一步的了解了Linux 下的驱动程序设计方法。通过这次实验，我们掌握了Linux系统下设备驱动程序的作用与编写技巧，掌握Linux驱动程序模块加载和卸载的方法，了解串口驱动的原理和工作方式。
物联网5(驱动开发)
weixin_38614678的博客
04-01 910
介绍用户态和内核态、设备文件、可加载内核模块、字符设备驱动开发、块设备驱动开发
Android APK使用JNI与Linux驱动交互实现LED控制
每个CheckBox都有一个唯一的ID，并且绑定了`onCheckboxClicked`方法，以便在用户交互时触发相应的操作。 在JNI部分，开发者需要编写C/C++代码，实现与Linux驱动的交互。这部分代码会被Java代码调用，通过JNI接口来...
流水灯仿真
01-26
proteus画的流水灯仿真，可用于51单片机程序仿真验证。
流水灯设计与实现
qq_41294540的博客
01-18 1161
module water_led(clk,rst_n,led); input clk; //输入系统时钟 input rst_n; //复位按键 output reg [9:0] led; //10个流水灯 reg [25:0] cnt_1s; //1S的计数器 reg fla...
细数实现流水灯的三种代码形式
热门推荐
hpu_zhn的博客
10-12 4万+
     在上篇博文发出之后，有同学说，程序代码太繁琐了，不如用移位啊，数组啊一步就搞定了。由于是入门，我们当然是一步一步来了。这里我们来看一看实现流水灯的三种代码书写形式： ①顺序赋值式 #include&lt;reg52.h&gt; #define uchar unsigned char #define uint unsigned int sbit LED1 = P2^0; ...
04-流水灯实现
wcsq0523的博客
08-25 661
流水灯实现 文章目录流水灯实现1. 分步赋值法（数组赋值）2. 变量的左移和右移利用左移语句，实现P3口LED挨个点亮利用右移语句，实现P3口LED挨个灭掉3. 变量的循环左移和右移 1. 分步赋值法（数组赋值） 原理： 分步点亮 P3口点亮一个LED后，延迟一段时间，再点亮下一个LED，延迟，以此类推，循环显示8个LED 创建数组，保存点亮LED0~7的8种状态 unsigned char code Buffer[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0
3-C51-流水灯
weixin_43926272的博客
06-23 112
用到的延时函数传1000,为1s。第二种方法,利用C51库函数实现。第三种方法利用数组的方法。第一种:最简单的方法。
第一个Linux驱动-流水灯
系统运维
07-03 368
水平有限，描述不当之处请指出，转载请注明出处http://blog.csdn.net/vanbreaker/article/details/7711695 本节介绍如何利用板载的Led和Linux的内核定时器实现一个简单的流水灯的驱动，所使用的开发板是TQ2440，内核版本2.6.30.4。 程序比较简单，也没涉及到什么机制，直接上代码了！关于定时器的使用模板可以参考&lt;&lt;Linux...
第三讲：IO操作——简单流水灯
Flutter 跨平台技术研究
01-21 651
流水灯其实就是一系列的灯一次点亮的过程，看起来像流动的一样。程序实现起来就是左移或者右移的过程，如果复杂的话则需要进行逻辑判断，例如使用switch分支来实现多个花样的流水灯。这里只给一个简单的流水灯示例，有兴趣的朋友可以回去自己修改移位方式或逻辑方式进行改进。代码如下：#include#define LED P1//sbit LED0 = P1^0;t
STM32学习：①流水灯
夹心狗勾的博客
07-07 912
开发板：ISKBoard处理器：Arm® Cortex®-M4 处理器左端接入了3.3V电源，要使LED发光则需要分别在PC9（红）、PC6（绿）、PB2（蓝）引脚接入低电平，如果要让它熄灭，就需要接入高电平，因此我们可以根据输出电平来控制LED灯的亮灭。
条条大路通罗马---流水灯的多种实现方法
10-22 7882
学习单片机，流水灯项目必做的一个项目，可以说是I/O输出控制的一个非常典型的例子。流水灯一般是指控制单片机的I/O口的电平状态使开发板上的8个小灯依次一个接一个的点亮，流动起来。今天我们总结一下单片机的流水灯的实现方法。
Linux平台驱动下LED字符设备驱动设计与实现
对于多个LED灯的支持，通常需要在驱动中维护一个LED灯数组，并为每个LED灯定义操作函数。这些函数会通过相应的接口来控制硬件上的LED灯。在本案例中，尽管支持多个LED灯，但由于缺乏分层设计，可能在代码的扩展性和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值