2022-10-11使用ioctl函数实现LED灯，蜂鸣器，风扇的驱动工作

最新推荐文章于 2023-03-08 20:43:34 发布
最新推荐文章于 2023-03-08 20:43:34 发布
阅读量226 收藏
点赞数 1
分类专栏： C 文章标签： 驱动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58344947/article/details/127269500
版权

首先是led灯的头文件部分

myled.h

#ifndef __MYLED_H__
#define __MYLED_H__

    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_LED1_ADDR 0X50006000
    #define PHY_LED2_ADDR 0X50007000
    #define PHY_LED3_ADDR   0X50006000
    #define PHY_RCC_ADDR  0X50000A28 
    enum LED
    {
        LED1=1,
        LED2,
        LED3
    };

#define LED_ON _IO('a',1)
#define LED_OFF _IO('a',0)
#define LedON _IOW('a',1,int)
#define LedOFF _IOW('a',0,int)


#endif

然后是 myled.c的驱动文件

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/ioctl.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include"myled.h"
#define CNAME  "myled"

int major;//定义变量接收主设备号
char kbuf[128]={};//定义数组用于存放和用户之间拷贝的数据
gpio_t *vir_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;
unsigned int *vir_rcc;
struct class *cls;//句柄
struct device *dev;
//对应的是open()
int mycdev_open(struct inode *inode, struct file *file)
{
      printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
      return 0;
}
//read()
ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    //size参数是用户期待读到的字节长度
    int ret;
    if(size>sizeof(kbuf))
    size=sizeof(kbuf);
    ret=copy_to_user(ubuf,kbuf,size);
    if(ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
     
       return size;
}
//write()
ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    if(size>sizeof(kbuf))
    size=sizeof(kbuf);
    ret=copy_from_user(kbuf,ubuf,size);
    if(ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
    /*if(kbuf[0]=='1')//开灯
        vir_led1->ODR |= (1<<10);
    else if(kbuf[0]=='2')
        vir_led2->ODR |= (1 << 10);
    else if(kbuf[0]=='3')
       vir_led3->ODR |= (1 << 8);
    else//关灯
    {
        vir_led1->ODR &= ~(1<<10);
        vir_led2->ODR&= ~(1 << 10);
       vir_led3->ODR &= ~(1 << 8);
    }*/
       return size;
}
//close()
 long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
    int ret,which;
    switch(cmd)
    {
        case LedON:
            ret=copy_from_user(&which,(void *)arg,sizeof(int));
            if(ret)
            {
                printk("用户向内核拷贝数据失败\n");
                return -EIO;
            }
            switch(which)
            {
                case LED1:
                 vir_led1->ODR |= (1<<10);
                 break;
                case LED2:
                 vir_led2->ODR |= (1<<10);
                 break;
                case LED3:
                 vir_led3->ODR |= (1<<8);
                 break;
            }
            break;
        case LedOFF:
            ret=copy_from_user(&which,(void *)arg,sizeof(int));
            if(ret)
            {
                printk("用户向内核拷贝数据失败\n");
                return -EIO;
            }
            switch(which)
            {
                case LED1:
                 vir_led1->ODR &= ~(1<<10);
                 break;
                case LED2:
                vir_led2->ODR &= ~(1<<10);
                 break;
                case LED3:
                 vir_led3->ODR &= ~(1<<8);
                 break;
            }
            break;
        default:
            printk("功能码错误\n");
            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,
    .read=mycdev_read,
    .write=mycdev_write,
    .unlocked_ioctl=ioctl,
    .release=mycdev_close,
};
int all_led_init(void)
{
    //进行物理地址的映射
    vir_led1=ioremap(PHY_LED1_ADDR,sizeof(gpio_t));
    if(vir_led1==NULL)
    {
        printk("vir_led1 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led1 映射成功\n");
   vir_led2=ioremap(PHY_LED2_ADDR,sizeof(gpio_t));
    if(vir_led2==NULL)
    {
        printk("vir_led2 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led2 映射成功\n");
    vir_led3=ioremap(PHY_LED3_ADDR,sizeof(gpio_t));
    if(vir_led3==NULL)
    {
        printk("vir_led3 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led3 映射成功\n");
    vir_rcc=ioremap(PHY_RCC_ADDR,4);
    if(vir_rcc==NULL)
    {
        printk("vir_rcc 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_rcc 映射成功\n");
    //寄存器的初始化
    //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);

    (*vir_rcc) |= (3<<4);
    return 0;
}
//入口函数，当驱动安装的时候执行
static int __init demo_init(void)
{
    
    //动态注册字符设备驱动
    major=register_chrdev(0,CNAME,&fops);
    if(major<0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n",major);
    //向上提交节点目录
    cls=class_create(THIS_MODULE,"LED");
    if(IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return PTR_ERR(cls);
    }
     printk("向上提交目录成功\n");
     //创建设备节点
     dev=device_create(cls,NULL,MKDEV(major,0),NULL,"myled");
     if(IS_ERR(dev))
     {
        printk("创建节点失败\n");
        return PTR_ERR(dev);
     }
     printk("创建节点成功\n");
    //寄存器的初始化
    all_led_init();
   
    return 0;
}

//出口函数，卸载驱动的时候执行
static void __exit demo_exit(void)
{
    //销毁节点
    device_destroy(cls,MKDEV(major,0));
    //销毁目录
    class_destroy(cls);
    //取消映射
    iounmap(vir_led1);
    iounmap(vir_led2);
    iounmap(vir_led3);
    iounmap(vir_rcc);

    //注销字符设备驱动
    unregister_chrdev(major,CNAME);
   
}
module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL");

然后是蜂鸣器的头文件部分

beep.h

#ifndef __BEEP_H__
#define __BEEP_H__

    
    #define PHY_BEEP_ADDR 0X50003000
    //#define PHY_LED2_ADDR 0X50007000
    //#define PHY_LED3_ADDR   0X50006000
    #define PHY_RCC_ADDR  0X50000A28 
   /* enum LED
    {
        LED1=1,
        LED2,
        LED3
    };*/

#define BEEP_ON _IO('a',1)
#define BEEP_OFF _IO('a',0)
//#define BEEPON _IOW('a',1,int)
//#define BEEPOFF _IOW('a',0,int)


#endif

然后是蜂鸣器的驱动部分代码

beep.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/ioctl.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include"beep.h"
#include "/home/ubuntu/Linux驱动/day3/myled.h"

#define CNAME  "beep"

int major;//定义变量接收主设备号
char kbuf[128]={};//定义数组用于存放和用户之间拷贝的数据
gpio_t *vir_beep;
//gpio_t *vir_led2;
//gpio_t *vir_led3;
unsigned int *vir_rcc;
struct class *cls;//句柄
struct device *dev;
//对应的是open()
int mycdev_open(struct inode *inode, struct file *file)
{
      printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
      return 0;
}
//read()
ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    //size参数是用户期待读到的字节长度
    int ret;
    if(size>sizeof(kbuf))
    size=sizeof(kbuf);
    ret=copy_to_user(ubuf,kbuf,size);
    if(ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
     
       return size;
}

int mycdev_close(struct inode *inode, struct file *file)
{
      printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
       return 0;
}
//write()
ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    if(size>sizeof(kbuf))
    size=sizeof(kbuf);
    ret=copy_from_user(kbuf,ubuf,size);
    if(ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
    /*if(kbuf[0]=='1')//开灯
        vir_led1->ODR |= (1<<10);
    else if(kbuf[0]=='2')
        vir_led2->ODR |= (1 << 10);
    else if(kbuf[0]=='3')
       vir_led3->ODR |= (1 << 8);
    else//关灯
    {
        vir_led1->ODR &= ~(1<<10);
        vir_led2->ODR&= ~(1 << 10);
       vir_led3->ODR &= ~(1 << 8);
    }*/
       return size;
}
//close()
 
 long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
 
    switch (cmd)
    {
    case BEEP_ON:
        vir_beep->ODR |= (1 << 6);
        break;
    case BEEP_OFF:
        vir_beep->ODR &= ~(1 << 6);
        break;
    default:
        printk("功能码错误\n");
        break;
    }
    return 0;
}



//操作方法结构体的初始化
struct file_operations fops=
{
    .open=mycdev_open,
    .read=mycdev_read,
    .write=mycdev_write,
    .unlocked_ioctl=ioctl,
    .release=mycdev_close,
};
int beep_init(void)
{
    //进行物理地址的映射
    vir_beep=ioremap(PHY_BEEP_ADDR,sizeof(gpio_t));
    if(vir_beep==NULL)
    {
        printk("vir_beep 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_beep 映射成功\n");
  
    
    vir_rcc=ioremap(PHY_RCC_ADDR,4);
    if(vir_rcc==NULL)
    {
        printk("vir_rcc 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_rcc 映射成功\n");
    //寄存器的初始化
    //beep
    vir_beep->MODER &= ~(3<<12);
    vir_beep->MODER |= (1<<12);
    vir_beep->ODR &= ~(1<<6);

    (*vir_rcc) |= (3<<4);
    return 0;
}
//入口函数，当驱动安装的时候执行
static int __init demo_init(void)
{
    
    //动态注册字符设备驱动
    major=register_chrdev(0,CNAME,&fops);
    if(major<0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n",major);
    //向上提交节点目录
    cls=class_create(THIS_MODULE,"beep");
    if(IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return PTR_ERR(cls);
    }
     printk("向上提交目录成功\n");
     //创建设备节点
     dev=device_create(cls,NULL,MKDEV(major,0),NULL,"beep");
     if(IS_ERR(dev))
     {
        printk("创建节点失败\n");
        return PTR_ERR(dev);
     }
     printk("创建节点成功\n");
    //寄存器的初始化
    beep_init();
   
    return 0;
}

//出口函数，卸载驱动的时候执行
static void __exit demo_exit(void)
{
    //销毁节点
    device_destroy(cls,MKDEV(major,0));
    //销毁目录
    class_destroy(cls);
    //取消映射
    iounmap(vir_beep);
    
    iounmap(vir_rcc);

    //注销字符设备驱动
    unregister_chrdev(major,CNAME);
   
}
module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL");

后面是风扇的头文件部分

fan.c

#ifndef __FAN_H__
#define __FAN_H__

#define PHY_FAN_ADDR 0X50006000
#define PHY_RCC_ADDR 0X50000A28
 
#define FAN_ON _IO('a', 1)
#define FAN_OFF _IO('a', 0)
 
#endif

风扇的驱动函数部分

fan.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/device.h>
#include <linux/ioctl.h>
#include "fan.h"
#include "/home/ubuntu/Linux驱动/day3/myled.h"
#define CNAME "fan"
 
int major;           //定义变量接受主设备号
char kbuf[128] = {}; //定义数组用于存放和用户之间拷贝的数据
 
gpio_t *vir_fan;
 
unsigned int *vir_rcc;
struct class *cls; //句柄
struct device *dev;
 
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    if (size > sizeof(kbuf))
    {
        size = sizeof(kbuf);
    }
 
    ret = copy_to_user(ubuf, kbuf, size);
    if (ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
    return size;
}
ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    if (size > sizeof(kbuf))
    {
        size = sizeof(kbuf);
    }
    ret = copy_from_user(kbuf, ubuf, size);
    if (ret)
    {
        printk("数据从用户向内核拷贝失败\n");
        return -EIO;
    }
    return size;
}
long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
        case FAN_ON:
            vir_fan->ODR |= (1 << 9);
            break;
        case FAN_OFF:
            vir_fan->ODR &= ~(1 << 9);
            break;
        default:
            printk("功能码错误\n");
            break;
    }
    return 0;
}
 
int fan_init(void)
{
    //进行物理地址的映射
    vir_fan = ioremap(PHY_FAN_ADDR, sizeof(gpio_t));
    if (vir_fan == NULL)
    {
        printk("vir_fan 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_fan 映射成功\n");
    
    vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    if (vir_rcc == NULL)
    {
        printk("vir_rcc 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_rcc 映射成功\n");
 
    //寄存器的初始化
    // fan
    vir_fan->MODER &= ~(3 << 18);
    vir_fan->MODER |= (1 << 18);
    vir_fan->ODR &= ~(1 << 9);
 
 
    (*vir_rcc) |= (1 << 4);
 
    return 0;
}
 
struct file_operations fops =
    {
        .open = mycdev_open,
        .read = mycdev_read,
        .write = mycdev_write,
        .unlocked_ioctl = ioctl,
        .release = mycdev_close,
};
 
static int __init demo_init(void)
{
    //注册字符设备驱动
    major = register_chrdev(0, CNAME, &fops);
    if (major < 0)
    {
        printk("fan设备驱动注册失败\n");
        return major;
    }
    printk("fan设备驱动注册成功major=%d\n", major);
 
    //向上提交目录
    cls = class_create(THIS_MODULE, "FAN");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return PTR_ERR(cls);
    }
    printk("向上提交目录成功\n");
 
    //向上创建设备节点
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "fan");
    if (IS_ERR(dev))
    {
        printk("向上创建设备节点失败\n");
        return PTR_ERR(dev);
    }
    printk("向上创建设备节点成功\n");
 
    fan_init();
 
    return 0;
}
 
static void __exit demo_exit(void)
{
 
    //销毁节点
    device_destroy(cls, MKDEV(major, 0));
    //销毁目录
    class_destroy(cls);
 
    //取消物理内存映射
    iounmap(vir_fan);
    iounmap(vir_rcc);
    //注销字符设备驱动
    unregister_chrdev(major, CNAME);
    printk(KERN_ERR "kernel unload\n");
}
 
module_init(demo_init);
module_exit(demo_exit);
 
MODULE_LICENSE("GPL");

最后是应用层的实现代码（三个器件一起初始化使用）

test.c

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include <sys/ioctl.h>
#include"/home/ubuntu/Linux驱动/day3/beep/beep.h"
#include"/home/ubuntu/Linux驱动/day3/myled.h"
#include"/home/ubuntu/Linux驱动/day3/fan/fan.h"


int main(int argc, char const *argv[])
{
    char buf[128]={};
    int fd=open("/dev/myled",O_RDWR);
    int which;
    if(fd<0)
    {

        printf("led打开设备文件失败\n");
        exit(-1);
    }
    printf("led设备文件打开成功\n");

    int fd2 = open("/dev/beep", O_RDWR);
    if (fd2 < 0)
    {
        printf("beep设备文件打开失败\n");
        exit(-1);
    }
    printf("beep设备文件打开成功\n");

    int fd3 = open("/dev/fan", O_RDWR);
    if (fd3 < 0)
    {
        printf("fan设备文件打开失败\n");
        exit(-1);
    }
    printf("fan设备文件打开成功\n");

    int flag;

    //在终端输入
    while(1)
    {
       printf("请输入控制命令:1:led 2:beep 3:fan\n");
       scanf("%d",&flag);
       getchar();
    if(flag == 1)
    {
        printf("请输入控制命令1：开灯 0：关灯\n");
        bzero(buf,sizeof(buf));
        fgets(buf,sizeof(buf),stdin);
        printf("请输入要操作的灯：1->LED1 ， 2->LED2 ， 3->LED3\n");
        scanf("%d",&which);
        getchar();
        //吃掉换行符
        buf[strlen(buf)-1]='\0';
        if(buf[0]=='1')
        ioctl(fd,LedON,&which);
        else
        ioctl(fd,LedOFF,&which);
        bzero(buf,sizeof(buf));
    
    } 
    else if(flag ==2)   
    {
    printf("请输入操作指令：1：开启蜂鸣器  0：关闭蜂鸣器\n");
    bzero(buf,sizeof(buf));
    fgets(buf,sizeof(buf),stdin);
    //吃掉换行符
    buf[strlen(buf)-1]='\0';
    if(buf[0]=='1')
    ioctl(fd2,BEEP_ON);
    else
    ioctl(fd2,BEEP_OFF);
    bzero(buf,sizeof(buf));
    
    }
    else if (flag ==3)
    {
        printf("请输入操作指令：1：开启风扇  0：关闭\n");
        bzero(buf,sizeof(buf)); //清除残留数据
        fgets(buf,sizeof(buf),stdin);
        //吃掉换行符
        buf[strlen(buf)-1]='\0';
        if(buf[0]=='1')
        ioctl(fd3,FAN_ON);
        else
        ioctl(fd3,FAN_OFF);    

        bzero(buf,sizeof(buf));

    }
    
    
    
    }
    close(fd);
    close(fd2);
    close(fd3);
    return 0;
}

某C编程代诗
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
触摸按键控制LED灯实验
qq_45565330的博客
11-15 477
触摸按键控制LED灯实验
zynq的linux驱动10-ioctl架构来控制led灯
01-31
zynq的linux驱动10-ioctl架构来控制led灯
Driver：LED灯操作、内核空间和用户空间的数据交互、ioctl函数、设备文件安装与销毁
Hello, New World!
03-04 1303
1、LED灯操作 用户空间执行open时，led1亮；执行close时，led1灭。 电路原理图：     led1 ---> GPIOC12 如何控制：     cpu datasheet 特殊功能寄存器 在linux下操作GPIO管脚有两种方式：     1)像裸板开发一样通过'指针 + 位操作'来完成特殊功能寄存器的设置。         问题在于：/* 要将特殊功能寄存
编写LED混杂设备驱动：静态映射，如何用Linux内核里的gpio_request(),gpio_set_value()等函数，ioctl函数
欧阳海宾
08-16 5464
如何用Linux内核里的gpio_request(),gpio_set_value()等函数编写LED驱动          步骤一：打开Linux内核源代码里的Documentation文件夹下的gpio.txt文档          文档里介绍了要用到的头文件和gpio函数介绍，用到的头文件是 #include 步骤二：打开Linux sourceindight工程搜索gpio.
#ARM开发# 点亮LED和操作蜂鸣器
zer1123的博客
07-06 3529
实例：Mini2451_Led_s  （文件名） 设备：ARM实验板 PC机 编译环境：KEIL4   MiniTools 实验前准备：   实验板接通电源（不需要打开），连接电脑。打开MiniTools，按住实验板最边上的按钮同时开机，如显示没有连接成功，查看驱动是否安装完全，已经安装驱动的就可以直接显示connected。此时可以从Minitools中把 . bin
嵌入式Linux驱动开发初级-字符设备驱动基IO模型
found_1的博客
03-08 119
嵌入式Linux驱动开发初级-字符设备驱动基IO模型
用Qt控制开发板led和蜂鸣器
05-26
linux系统下，用Qt实现 ARM开发板 LED灯的控制，以及蜂鸣器不同频率的响应。代码相对简单，条理清晰，适合初学者学习借鉴。
ioctl-sample.zip_io driver_ioctl_ioctl kb m_过滤驱动_过滤驱动程序
09-24
比较简单的io控制的过滤驱动程序示例代码，值得读一读。
ioctl_driver:有关如何编写Linux驱动程序的示例
05-13
IOCTL驱动程序 关于如何为Linux创建IOCTL驱动程序的简单示例。 这可以用于简单的测试目的： 从内核模式访问特殊寄存器以在用户模式下获得结果。 例如，CP15处理器的Arm寄存器。 访问某些内存映射区域 ... 此仓库...
ioctl函数的使用
07-19
ioctl函数的使用ioctl函数的使用ioctl函数的使用ioctl函数的使用ioctl函数的使用
arm控制蜂鸣器的蜂鸣程序
12-03
这个程序时ARM7TDMIPLC2106的芯片，控制蜂鸣器的蜂鸣实验，该蜂鸣器时利用低电平出发方式进行的。
【STM32】控制LED灯和蜂鸣器的按键实验
weixin_63726869的博客
05-18 1万+
介绍了如何通过STM32开发板的按键控制LED灯和蜂鸣器的状态。
day03
mailong
06-16 157
回顾： 1.linux设备驱动开发相关   1.1.设备驱动两大核心       操作硬件       提供接口   1.2.linux设备驱动分类           字符设备驱动           块设备驱动           网络设备驱动   1.3.linux系统理念       一切皆文件       字符设备文件       块设备文
第十七节 控制蜂鸣器（GPIO 子系统）
picassocao的博客
02-07 1097
控制蜂鸣器（GPIO 子系统）
I.MX6ULL ARM驱动开发--- pinctrl 和 gpio 子系统的蜂鸣器驱动
qq_41455322的博客
08-23 670
I.MX6ULL ARM驱动开发--- pinctrl 和 gpio 子系统的蜂鸣器驱动
【嵌入式系统开发】Keil 实现LED灯闪烁 详细教程及完整代码
热门推荐
m0_52474147的博客
08-27 3万+
在Keil MDK 4.74上编写一段程序，控制LPC1114微控制器的GPIO引脚PIO1_9上的LED灯亮（低电平亮）。进一步利用Delay_1s(void)函数实现定时1s，使LED灯状态反转，再延时1s，使LED灯状态反转，如此一直循环，实现LED灯闪烁。提示：主程序可以在Keil自带例程MCB1114/Blinky上修改，不一定要新建工程项目，但要删掉多余的代码和文件。............
ARM练习：通过PWM来控制蜂鸣器的发声
wst1529210144的博客
12-02 2894
ARM练习：通过PWM来控制蜂鸣器的发声
ARM裸机--PWM蜂鸣器
weixin_44836536的博客
01-16 830
1、查看蜂鸣器电路图连接 2、查看核心板引脚连接 3、GPD0引脚控制寄存器设置为TOUT_2模式 4、PWM定时器相关寄存器设置 5、绑定寄存器地址和访问寄存器设置 //绑定寄存器地址 #define GPD0CON 0xE020_00A0 #define TCFG0 0xE250_0000 #define TCFG1 0xE250_0004 #define TCON 0xE250_0008 #define TCNTB2 0xE250_0024 #defin...
用ioctl函数打开蜂鸣器
最新发布
05-26
要使用ioctl函数打开蜂鸣器，需要先打开蜂鸣器设备文件并获取其文件描述符，然后使用ioctl函数发送特定的命令。 以下是一个简单的示例代码，假设蜂鸣器设备文件为/dev/buzzer： ```c #include <stdio.h> #include <fcntl.h> #include <sys/ioctl.h> #include <linux/kd.h> int main(void) { int fd = open("/dev/buzzer", O_WRONLY); if (fd < 0) { perror("open"); return 1; } // 发送KIOCSOUND命令，打开蜂鸣器并发出声音 ioctl(fd, KIOCSOUND, 440); // 等待一段时间 sleep(1); // 关闭蜂鸣器 ioctl(fd, KIOCSOUND, 0); close(fd); return 0; } ``` 在上面的示例代码中，我们使用了ioctl函数发送KIOCSOUND命令，其中第二个参数是命令码，第三个参数则是频率（单位为赫兹）。当频率为0时，蜂鸣器将关闭。 注意，此示例代码仅适用于Linux系统，并且需要以root权限运行。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值