ioctl函数的练习和自动创建设备文件的使用--对开发板上的设备进行启动关闭实验

最新推荐文章于 2024-09-18 10:25:00 发布
最新推荐文章于 2024-09-18 10:25:00 发布
阅读量116 收藏
点赞数
文章标签： arm linux 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45576731/article/details/128942250
版权

一共进行了LED灯点亮和蜂鸣器以及马达的启动实验

头文件

#ifndef __HEAD__H__ 
#define __HEAD__H__ 

//GPIO组寄存器封装
typedef struct 
{
    volatile unsigned int MODER;
    volatile unsigned int OTYPER;
    volatile unsigned int OSPEEDR;
    volatile unsigned int PUPDR;
    volatile unsigned int IDR;
    volatile unsigned int ODR;
    volatile unsigned int BSRR;
}gpio_t;

//宏定义物理地址
#define PHY_RCC_ADDR 0x50000A28
//扩展板
#define PHY_LED1_ADDR 0x50006000
#define PHY_LED2_ADDR 0x50007000
#define PHY_LED3_ADDR 0x50006000
//主板 PZ5、6、7
#define PHY_H_RCC_ADDR 0x50000290
#define PHY_H_LED1_ADDR 0x54004000
#define PHY_H_LED2_ADDR 0x54004000
#define PHY_H_LED3_ADDR 0x54004000

//蜂鸣器 PB6
#define PHY_BUZ_ADDR 0x50003000
//马达  PF6
#define PHY_MOT_ADDR 0x50007000

//宏定义功能码
#define LED_ON _IOW('l',1,int)
#define LED_OFF _IOW('l',0,int)
#define LED_H_ON _IOW('l',3,int)
#define LED_H_OFF _IOW('l',2,int)
#define BUZ_ON _IO('l',1)
#define BUZ_OFF _IO('l',0)
#define MOT_ON _IO('l',3)
#define MOT_OFF _IO('l',2)

#endif

应用层代码

#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"


int main(int argc, char const *argv[])
{
    int func,num,op;
    char buf[128]={0};
    //打开设备文件
    int fd = open("/dev/mycdev",O_RDWR);
    if(fd < 0 )
    {
        perror("文件打开失败\n");
        return -1;
    }
    while (1)
    {
        //需要输入有效值
        func = 100;
        printf("请输入: 0(控制拓展板的LED灯亮灭) 1(控制主板的LED灯亮灭) 2(控制蜂鸣器) 3(控制马达) ->");
        scanf("%d",&func);
        //吸收垃圾字符
        while(getchar()!='\n');
        
        //功能选择
        switch (func)
        {    
        //扩展板的LED灯   
        case 0:
            printf("请输入选择哪盏灯: 1(LED1) 2(LED2) 3(LED3)");
            scanf("%d",&num);
            while(getchar()!='\n');
            printf("请输入: 0 (关闭) 1 (开启)");
            scanf("%d",&op);
            while(getchar()!='\n');
            if(1 == op)
                ioctl(fd,LED_ON,&num);//控制IO
            else if(0 == op)
                ioctl(fd,LED_OFF,&num);
            break;
        //主板的LED灯 
        case 1:
            printf("请输入选择哪盏灯: 1(LED1) 2(LED2) 3(LED3)");
            scanf("%d",&num);
            while(getchar()!='\n');
            printf("请输入: 0 (关闭) 1 (开启)");
            scanf("%d",&op);
            while(getchar()!='\n');
            if(1 == op)
                ioctl(fd,LED_H_ON,&num);
            else if(0 == op)
                ioctl(fd,LED_H_OFF,&num);
            break;
        //蜂鸣器
        case 2:
            printf("请输入: 0 (关闭) 1 (开启)");
            scanf("%d",&op);
            while(getchar()!='\n');
            if(1 == op)
                ioctl(fd,BUZ_ON);
            else if(0 == op)
                ioctl(fd,BUZ_OFF);
            break;
        //马达
        case 3:
            printf("请输入: 0 (关闭) 1 (开启)");
            scanf("%d",&op);
            while(getchar()!='\n');
            if(1 == op)
                ioctl(fd,MOT_ON);
            else if(0 == op)
                ioctl(fd,MOT_OFF);
            break;
        default:
            printf("输入有误!");
            while(getchar()!='\n');
            break;
        }
    }
    
    close(fd);
    return 0;
}

内核代码

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

int major;
struct class * cls;
struct device * dev;
//定义一些变量来保存物理地址映射的虚拟地址
unsigned int *vir_rcc;
unsigned int *vir_h_rcc;
gpio_t *vir_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;
gpio_t *vir_h_led1;
gpio_t *vir_h_led2;
gpio_t *vir_h_led3;
gpio_t *vir_buz;
gpio_t *vir_mot;

int kbuf[128]={0};

int mydev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
ssize_t mydev_read(struct file *file, char *ubuf, size_t size, loff_t *off)
{
    int ret;
    if(size > sizeof(kbuf))
    {
        size=sizeof(kbuf);
    }
    //将数据传给用户层
    ret = copy_to_user(ubuf,kbuf,size);
    if(ret)
    {
        printk("copy_to_user failed\n");
    }
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}

//IO控制函数
long mydev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    int op,ret;
    switch (cmd)
    {
    //开灯
    case LED_ON:
        //从用户空间获取数据
        ret = copy_from_user(&op,(void*)arg, sizeof(int));
        if(ret)
        {
            printk("copy_from_user failed\n");
            return -ENOMEM;
        }
        //选择那一盏灯
        switch (op)
        {
        case 1:
            vir_led1->ODR |= (1 << 10);
            break;
        case 2:
            vir_led2->ODR |= (1 << 10);
            break;
        case 3:
            vir_led3->ODR |= (1 << 8);
            break;   
        
        default:
            break;
        }
        break;
    //关灯
    case LED_OFF:
        ret = copy_from_user(&op,(void*)arg, sizeof(int));
        if(ret)
        {
            printk("copy_from_user failed\n");
            return -ENOMEM;
        }
        switch (op)
        {
        case 1:
            vir_led1->ODR &= (~(1 << 10));
            break;
        case 2:
            vir_led1->ODR &= (~(1 << 10));
            break;
        case 3:
            vir_led1->ODR &= (~(1 << 8));
            break;   
        
        default:
            break;
        }
        break;
    case LED_H_ON:
        ret = copy_from_user(&op,(void*)arg, sizeof(int));
        if(ret)
        {
            printk("copy_from_user failed\n");
            return -ENOMEM;
        }
        switch (op)
        {
        case 1:
            vir_h_led1->ODR |= (1 << 5);
            break;
        case 2:
            vir_h_led2->ODR |= (1 << 6);
            break;
        case 3:
            vir_h_led3->ODR |= (1 << 7);
            break;   
        default:
            break;
        }
        break;
    case LED_H_OFF:

        ret = copy_from_user(&op,(void*)arg, sizeof(int));
        if(ret)
        {
            printk("copy_from_user failed\n");
            return -ENOMEM;
        }
        switch (op)
        {
        case 1:
            vir_h_led1->ODR &= (~(1 << 5));
            break;
        case 2:
            vir_h_led2->ODR &= (~(1 << 6));
            break;
        case 3:
            vir_h_led3->ODR &= (~(1 << 7));
            break;   
        
        default:
            break;
        }
        break;
    case BUZ_ON:
        vir_buz->ODR |= (1 << 6);
        break;
    case BUZ_OFF:
        vir_buz->ODR &= (~(1 << 6));
        break;
    case MOT_ON:
        vir_mot->ODR |= (1 << 6);
        break;
    case MOT_OFF:
        vir_mot->ODR &= (~(1 << 6));
        break;
    }
    
    return 0;
}

ssize_t mydev_write(struct file *file, const char *ubuf, size_t size, loff_t *off)
{
    int ret;
    if(size > sizeof(kbuf))
    {
        size=sizeof(kbuf);
    }
    //从用户空间获取数据
    ret = copy_from_user(kbuf,ubuf,size);
    if(ret)
    {
        printk("copy_to_user failed\n");
        return -EIO;
    }

    return 0;
}
int mydev_close (struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
struct file_operations fops=
{
    .open=mydev_open,
    .read=mydev_read,
    .write=mydev_write,
    .release=mydev_close,
    .unlocked_ioctl=mydev_ioctl,
};

//初始化
int all_init(void)
{
    //地址映射
    //RCC
    vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    if(NULL ==vir_rcc)
    {
        printk("rcc寄存器映射失败\n");
        return -ENOMEM;
    }
    printk("rcc寄存器映射成功\n");
    vir_h_rcc = ioremap(PHY_H_RCC_ADDR, 4);
    if(NULL ==vir_h_rcc)
    {
        printk("h_rcc寄存器映射失败\n");
        return -ENOMEM;
    }
    printk("h_rcc寄存器映射成功\n");

    //LED
    vir_led1 = ioremap(PHY_LED1_ADDR, sizeof(gpio_t));
    if(NULL ==vir_led1)
    {
        printk("led1寄存器映射失败\n");
        return -ENOMEM;
    }
    printk("led1寄存器映射成功\n");

    vir_led2 = ioremap(PHY_LED2_ADDR, sizeof(gpio_t));
    if(NULL ==vir_led2)
    {
        printk("led2寄存器映射失败\n");
        return -ENOMEM;
    }
    printk("led2寄存器映射成功\n");

    vir_led3 = ioremap(PHY_LED3_ADDR, sizeof(gpio_t));
    if(NULL ==vir_led3)
    {
        printk("led3寄存器映射失败\n");
        return -ENOMEM;
    }
    printk("led3寄存器映射成功\n");

    vir_h_led1 = ioremap(PHY_H_LED1_ADDR, sizeof(gpio_t));
    if(NULL ==vir_led1)
    {
        printk("h_led1寄存器映射失败\n");
        return -ENOMEM;
    }
    printk("h_led1寄存器映射成功\n");

    vir_h_led2 = ioremap(PHY_H_LED2_ADDR, sizeof(gpio_t));
    if(NULL ==vir_h_led2)
    {
        printk("h_led2寄存器映射失败\n");
        return -ENOMEM;
    }
    printk("h_led2寄存器映射成功\n");

    vir_h_led3 = ioremap(PHY_H_LED3_ADDR, sizeof(gpio_t));
    if(NULL ==vir_h_led3)
    {
        printk("h_led3寄存器映射失败\n");
        return -ENOMEM;
    }
    printk("h_led3寄存器映射成功\n");

    vir_buz = ioremap(PHY_BUZ_ADDR, sizeof(gpio_t));
    if(NULL ==vir_buz)
    {
        printk("buz寄存器映射失败\n");
        return -ENOMEM;
    }
    printk("buz寄存器映射成功\n"); 

    vir_mot = ioremap(PHY_MOT_ADDR, sizeof(gpio_t));
    if(NULL ==vir_mot)
    {
        printk("mot寄存器映射失败\n");
        return -ENOMEM;
    }
    printk("mot寄存器映射成功\n"); 


    //寄存器初始化
    //RCC
    (*vir_rcc) |= (3 << 4);
    (*vir_rcc) |= (1 << 1);
    (*vir_h_rcc) |= (1 << 0);

    //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_led3->MODER) |= (1 << 16);
    (vir_led3->ODR) &= (~(1<<8));

    //H_LED1
    (vir_h_led1->MODER) &= (~(3 << 10));
    (vir_h_led1->MODER) |= (1 << 10);
    (vir_h_led1->ODR) &= (~(1<<5));

    //H_LED2
    (vir_h_led2->MODER) &= (~(3 << 12));
    (vir_h_led2->MODER) |= (1 << 12);
    (vir_h_led2->ODR) &= (~(1<<6));

    //H_LED3
    (vir_h_led3->MODER) &= (~(3 << 14));
    (vir_h_led3->MODER) |= (1 << 14);
    (vir_h_led3->ODR) &= (~(1<<7));

    //buz
    (vir_buz->MODER) &= (~(3 << 12));
    (vir_buz->MODER) |= (1 << 12);
    (vir_buz->ODR) &= (~(1<<6));

    //mot
    (vir_mot->MODER) &= (~(3 << 12));
    (vir_mot->MODER) |= (1 << 12);
    (vir_mot->ODR) &= (~(1<<6));

    printk("寄存器初始化成功\n");
    return 0;
}

//入口函数
static int __init mycdev_init(void)
{
    major=register_chrdev(0,"mychrdev",&fops);
    printk("字符设备注册成功major=%d\n",major);
    
    //提交目录信息
    cls = class_create(THIS_MODULE,"mycdev");
    if(IS_ERR(cls))
    {
        printk("提交目录信息失败\n");
        return PTR_ERR(cls);
    }
    printk("提交目录信息成功\n");

    //提交设备节点
    dev = device_create(cls,NULL,MKDEV(major,0),NULL,"mycdev");
    if(IS_ERR(dev))
    {
        printk("提交设备节点信息失败\n");
        return PTR_ERR(cls);
    }
    printk("提交设备节点信息成功\n");


    //寄存器初始化
    all_init();
    return 0;
}

// 出口函数
static void __exit mycdev_exit(void)
{
    // int i;
    //取消地址映射
    iounmap(vir_rcc);
    iounmap(vir_led1);
    iounmap(vir_led2);
    iounmap(vir_led3);
    iounmap(vir_h_led1);
    iounmap(vir_h_led2);
    iounmap(vir_h_led3);
    iounmap(vir_buz);
    iounmap(vir_mot);

    //销毁设备文件
    device_destroy(cls,MKDEV(major,0));
    
    //销毁目录信息
    class_destroy(cls);
    
    //取消注册
    unregister_chrdev(major,"mychrdev");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");//遵循开源协议
J学生
关注
Linux——Linux系统编程之字符设备控制（字符类led、ADC转换器操作实践）
数字世界 万物互联
12-10 470
0 引言 上一博文中总结了文件的I/O操作，演示示例也只是自建个文件，进行数据的读写。这里，我们看下如何利用文件I/O进行字符设备的操作。这里没有给出如何具体写字符设备的驱动，而是利用开发板已经带有的两个字符设备，直接操作练习感知下。 1 Linux设备分类 Linux的设备根据类型可以分成三类，如下表所示，一个设备可以属于多种类型，像USB wifi，USB接口属于字符设备，也能上网，也属于网络设备。 字符设备 块设备 网络设备 1）应用程序按字节/字符来读写数据，通...
Linux之设备控制接口(ioctl)
风间琉璃的博客
09-22 3488
ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。对I/O通道进行管理，就是对设备的一些特性进行控制。虽然在文件操作结构体struct file_operations中有很多对应的设备操作函数，但是有些命令是实在找不到对应的操作函数,拓展一些file_operations给出的接口中没有的自定义功能，则需要使用到ioctl()函数。如CD-ROM的驱动，想要一个弹出光驱的操作，这种操作并不是所有的字符设备都需要的，所以文件操作结构体也不会有对应的函数操作。
Driver：LED灯操作、内核空间和用户空间的数据交互、ioctl函数、设备文件安装与销毁
Hello, New World!
03-04 1317
1、LED灯操作 用户空间执行open时，led1亮；执行close时，led1灭。 电路原理图：     led1 ---> GPIOC12 如何控制：     cpu datasheet 特殊功能寄存器 在linux下操作GPIO管脚有两种方式：     1)像裸板开发一样通过'指针 + 位操作'来完成特殊功能寄存器的设置。         问题在于：/* 要将特殊功能寄存
RK3568驱动指南｜第四篇 高级字符设备进阶－第36章 封装驱动API接口实验
BeiJingXunWei的博客
09-11 189
相信经过前面两个章节的学习已经能够熟练的使用ioctl函数了，在本章节会进行两个实验，每个实验的要完成的任务如下所示：实验一：通过ioctl对定时器进行控制，分别实现打开定时器、关闭定时器和设置定时时间的功能。实验二：对实验一的应用程序进行封装，从而让应用编程人员更好的对设备进行编程。
A53字符设备驱动学习的第一天
相信你可以的-博客
03-08 227
今天第一天学习字符设备驱动，自学有点蒙，还是听老师讲解的有点进度 1.嵌入式Linux设备驱动的概念 设备驱动是在内核中用来控制硬件的驱动程序，在带有操作系统的嵌入式系统中 驱动的作用: 就是管理对应的硬件，为用户提供操作硬件的方法(也叫做接口) | 应用程序 | 原理：应用程序中首先运行我们写的程序，然后调用相关的 ----------...
【RL-TCPnet网络教程】第19章 RL-TCPnet之BSD Socket服务器
Simon223的博客
08-15 787
第19章      RL-TCPnet之BSD Socket服务器 本章节为大家讲解RL-TCPnet的BSD Socket，学习本章节前，务必要优先学习第18章的Socket基础知识。有了这些基础知识之后，再搞本章节会有事半功倍的效果。另外RL-TCPnet的socket仅支持UDP协议和TCP协议，我们本章节仅讲解了TCP协议方式的BSD Socket。 本章教程含STM32F407开发板...
【RL-TCPnet网络教程】第20章 RL-TCPnet之BSD Socket客户端
Simon223的博客
08-17 432
第20章      RL-TCPnet之BSD Socket客户端 本章节为大家讲解RL-TCPnet的BSD Socket，学习本章节前，务必要优先学习第18章的Socket基础知识。有了这些基础知识之后，再搞本章节会有事半功倍的效果。另外RL-TCPnet的socket仅支持UDP协议和TCP协议，我们本章节仅讲解了TCP协议方式的BSD Socket。 本章教程含STM32F407开发板...
RK3568开发板C应用编程手册目录
mucheni的博客
03-21 664
系统编程指的是在Linux操作系统下对应用程序进行的编程，也叫做应用编程，编写好的应用程序运行在Linux操作系统的用户空间，通过直接或间接的调用系统调用 API 完成相应的功能和逻辑。前16章为基础知识部分，会对系统编程的知识点进行分类讲解，在讲解之后会有着对应的实验，而17-27章为实际应用部分，对系统编程基础知识和开发板软件部分进行了整合，可以巩固我们学到的知识，为本手册的重点。本教程为RK3568开发板的教程系列手册，旨在帮助用户对于应用编程进行入门学习，适用于 Linux 应用编程初学者。
【瑞芯微RV1126(板端摄像头图像数据采集)】②使用v4l2视频设备驱动框架采集图像数据，按键拍照并显示
海风的博客
07-21 2436
本系列的目的是，不仅仅将能够进行图片推理的模型部署于板端，还提供了两种摄像头数据采集的方法，集成到自己的深度学习推理代码之后，可以根据应用场景的不同实现按键控制拍照推理或者是实时推理并显示。本系列第一篇：本系列第二篇：本文本系列第三篇：在本系列第三篇博客中，最后我有提到，读取摄像头数据来进行实时推理或者拍照推理，在那里提供了两种思路：①按照这系列的第一篇博客，搭建环境，调用opencv的高级函数采集图像数据；
LED照明
汽车以太网和SOA
02-15 4230
LED照明
navicate远程linux上的pgsql提示密码失败
记录、分享、合作、共赢
09-14 351
2、postgresql.conf文件中，修改listen_addresses。3、重启pgsql，例如：systemctl restart pgsql。1、pg_hba.conf文件中，ipv4下面的内容改成。4、如果问题还在，检查firewalld防火墙，执行。5、再次尝试连接，成功！
【Linux】uImage头部信息详细解析
W__winter的博客
09-16 1557
【代码】【Linux】uImage头部信息详细解析。
Linux Kernel Makefiles 编译标志详解
最新发布
m0_66404702的博客
09-18 472
ccflags-yccflags-y用于定义C编译器的编译选项，这些选项仅对当前Makefile文件有效。例如，如果你需要为特定的源文件添加宏定义，可以在Makefile中使用ccflags-y。asflags-y类似于ccflags-y，但asflags-y是为汇编器定义的选项。这些选项仅影响汇编过程，适用于需要特殊汇编指令或宏定义的场景。ldflags-yldflags-y用于定义链接器的选项，控制链接过程中的行为，如指定库文件的路径或链接时使用的特殊选项。
linux-网络相关概念
zdd56789的博客
09-17 624
linux-网络相关概念
linux-进程管理-进程查看与控制
Flying_Fish_roe的博客
09-18 577
进程是操作系统中执行中的程序。Linux 将每个运行的程序看作是一个进程，每个进程都有唯一的进程ID (PID)。在 Linux 系统中，进程管理是非常重要的，它能够帮助系统管理员和用户查看、管理、优化系统资源的使用情况。Linux 提供了丰富的命令来查看和控制进程，例如pstophtopkill等等。这些命令允许用户监控和控制系统中运行的进程，以确保系统资源的合理使用，并避免进程阻塞或占用过多资源。在 Linux 系统中，进程管理是非常关键的操作。通过使用pstophtop。
Linux3-cp,mv,rm,*
2301_80339607的博客
09-15 324
复制文件：cp test1.txt test2.txt，把当前目录下的test1.txt文件复制一份到当前目录下，并命名为text.txt。例如cp -r test1 test2，把当前目录下的test1文件夹复制一份到当前目录下，并命名为text2。强制删除：选项-f(force)，普通用户用不到，root用户使用，所以如果要使用需要先切换为root用户。(在test目录下)删除文件夹：带选项-r，例如rm -r test2。(在test1目录下)删除文件：rm test3.txt。
Linux IoTCL设备控制接口详解与 ioctl函数应用
设备控制接口（Ioctl）在Linux内核驱动程序中扮演着至关重要的角色，它是设备驱动程序与用户空间应用程序之间进行高级设备管理的关键机制。Ioctl函数的原型定义为`int(*ioctl)(struct inode*, struct file*, ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值