通过ioctl函数选择不同硬件的控制，LED 蜂鸣器 马达 风扇

最新推荐文章于 2024-06-27 14:28:17 发布
最新推荐文章于 2024-06-27 14:28:17 发布
阅读量72 收藏
点赞数
文章标签： 驱动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_76485417/article/details/131564204
版权

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;
#define GPIOB 0x50003000
#define GPIOE 0x50006000
#define GPIOF 0x50007000
#define RCC 0X50000A28

#define LED_ON _IOW('l',1,int)  //开灯
#define LED_OFF _IOW('l',0,int)//关灯

#define FAN_ON _IO('f',1)  //开
#define FAN_OFF _IO('f',0)//关

#define MOTOR_ON _IO('m',1)  //开
#define MOTOR_OFF _IO('m',0)//关

#define BEE_ON _IO('b',1)  //开
#define BEE_OFF _IO('b',0)//关
#endif

bee.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 "head.h"

struct class *cls;
struct device *dev;
int major; // 用于保存主设备号
char kbuf[128] = {0};
gpio_t *vir_gpioe;
unsigned int *vir_rcc;
gpio_t *vir_gpiof;
gpio_t *vir_gpiob;
// 封装操作方法
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case BEE_ON: // 开蜂鸣器
        vir_gpiob->ODR |= (0x1 << 6);
        break;
    case FAN_OFF: // 关蜂鸣器
        vir_gpiob->ODR &= (~(0x1 << 6));
        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)
{
    // 字符设备驱动注册
    major = register_chrdev(0, "bee", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "bee");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备节点信息
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "bee");
    if (IS_ERR(dev))
    {
        printk("向上提交节点信息失败\n");
        return -PTR_ERR(dev);
    }
    // 映射物理地址
    vir_gpioe = ioremap(GPIOE, sizeof(gpio_t));
    if (vir_gpioe == NULL)
    {
        printk("MODER寄存器映射失败\n");
        return -EFAULT;
    }
    vir_gpiob = ioremap(GPIOB, sizeof(gpio_t));
    if (vir_gpiob == 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");
    (*vir_rcc) |= (0x3 << 4);
    (*vir_rcc) |= (0x1 << 1);
    // 寄存器初始化bee
    vir_gpiob->MODER &= (~(0x3 << 12));
    vir_gpiob->MODER |= (0x1 << 12);
    vir_gpioe->ODR &= (~(0x1 << 6));
    printk("硬件寄存器初始化成功\n");
    return 0;
}
static void __exit mycdev_exit(void)
{
    // 取消寄存器地址映射
    iounmap(vir_gpioe);
    iounmap(vir_rcc);
    iounmap(vir_gpiof);
    iounmap(vir_gpiob);
    // 销毁设备节点信息
    device_destroy(cls, MKDEV(major, 0));
    // 销毁字符设备驱动
    class_destroy(cls);
    // 字符设备驱动的注销
    unregister_chrdev(major, "bee");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

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 "head.h"

struct class *cls;
struct device *dev;
int major; // 用于保存主设备号
char kbuf[128] = {0};
gpio_t *vir_gpioe;
unsigned int *vir_rcc;
gpio_t *vir_gpiof;
// 封装操作方法
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case FAN_ON: // 开风扇
        vir_gpioe->ODR |= (0x1 << 9);
        break;
    case FAN_OFF: // 关风扇
        vir_gpioe->ODR &= (~(0x1 << 9));
        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)
{
    // 字符设备驱动注册
    major = register_chrdev(0, "fan", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "fan");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备节点信息
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "fan");
    if (IS_ERR(dev))
    {
        printk("向上提交节点信息失败\n");
        return -PTR_ERR(dev);
    }
    // 映射物理地址
    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");
    (*vir_rcc) |= (0x3 << 4);
    // 寄存器初始化fan
    vir_gpioe->MODER &= (~(0x3 << 18));
    vir_gpioe->MODER |= (0x1 << 18);
    vir_gpioe->ODR &= (~(0x1 << 9));
    printk("硬件寄存器初始化成功\n");
    return 0;
}
static void __exit mycdev_exit(void)
{
    // 取消寄存器地址映射
    iounmap(vir_gpioe);
    iounmap(vir_rcc);
    iounmap(vir_gpiof);
    // 销毁设备节点信息
    device_destroy(cls, MKDEV(major, 0));
    // 销毁字符设备驱动
    class_destroy(cls);
    // 字符设备驱动的注销
    unregister_chrdev(major, "fan");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

led.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 "head.h"


struct class *cls;
struct device *dev;
int major;
char kbuf[128] = {0};
gpio_t *vir_gpioe;
gpio_t *vir_gpiof;
unsigned int *vir_rcc;
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    int which;
    //通过拷贝函数获取ioctl第三个参数对应空间的数值
    int ret=copy_from_user(&which,(void *)arg,4);
    if(ret)
    {
        printk("拷贝用户空间数据失败\n");
        return -EIO;
    }
    //进行功能控制
    switch (cmd)
    {
    case LED_ON: // 开灯
        switch (which)
        {
        case 1: // LED1
            vir_gpioe->ODR |= (0x1 << 10);
            break;
        case 2: // LED2
            vir_gpiof->ODR |= (0x1 << 10);
            break;
        case 3: // LED3
            vir_gpioe->ODR |= (0x1 << 8);
            break;
        }
        break;
    case LED_OFF: // 关灯
        switch (which)
        {
        case 1:
            vir_gpioe->ODR &= (~(0X1 << 10));
            break;
        case 2:
            vir_gpiof->ODR &= (~(0X1 << 10));
            break;
        case 3:
            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 i;
    // 字符设备驱动注册
    major = register_chrdev(0, "mychrdev", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功:major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "mychrdev");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备节点信息
    // 为三盏灯创建三个设备文件
    for (i = 0; i < 3; i++)
    {
        dev = device_create(cls, NULL, MKDEV(major, i), NULL, "mychrdev%d", i);
        if (IS_ERR(dev))
        {
            printk("向上提交设备节点信息失败\n");
            return -PTR_ERR(dev);
        }
    }
    // 寄存器映射以及初始化
    

    // 寄存器地址的映射
    vir_gpioe = ioremap(GPIOE, sizeof(gpio_t));
    if (vir_gpioe == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    vir_gpiof = ioremap(GPIOF, sizeof(gpio_t));
    if (vir_gpiof == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    
    vir_rcc = ioremap(RCC, 4);
    if (vir_rcc == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    printk("物理地址映射成功\n");
    // 寄存器的初始化
    // rcc
    (*vir_rcc) |= (3 << 4);
    // led1
    vir_gpioe->MODER &= (~(3 << 20));
    vir_gpioe->MODER |= (1 << 20);
    vir_gpioe->ODR &= (~(1 << 10));
    // led2
    vir_gpiof->MODER &= (~(3 << 20));
    vir_gpiof->MODER |= (1 << 20);
    vir_gpiof->ODR &= (~(1 << 10));
    // led3
    vir_gpioe->MODER &= (~(3 << 16));
    vir_gpioe->MODER |= (1 << 16);
    vir_gpioe->ODR &= (~(1 << 8));
    printk("寄存器初始化成功\n");

    return 0;
}
    


static void __exit mycdev_exit(void)
{
    int i;
    // 取消地址映射
    iounmap(vir_gpioe);
    iounmap(vir_gpiof);
    iounmap(vir_rcc);
    // 销毁设备节点信息
    for (i = 0; i < 3; i++)
    {
        device_destroy(cls, MKDEV(major, i));
    }
    // 销毁目录信息
    class_destroy(cls);
    // 注销字符设备驱动
    unregister_chrdev(major, "mychrdev");

}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

motor.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 "head.h"

struct class *cls;
struct device *dev;
int major; // 用于保存主设备号
char kbuf[128] = {0};
gpio_t *vir_gpioe;
unsigned int *vir_rcc;
gpio_t *vir_gpiof;
// 封装操作方法
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case MOTOR_ON: // 开马达
        vir_gpiof->ODR |= (0x1 << 6);
        break;
    case MOTOR_OFF: // 关马达
        vir_gpiof->ODR &= (~(0x1 << 6));
        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)
{
    // 字符设备驱动注册
    major = register_chrdev(0, "motor", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "motor");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备节点信息
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "motor");
    if (IS_ERR(dev))
    {
        printk("向上提交节点信息失败\n");
        return -PTR_ERR(dev);
    }
    // 映射物理地址
    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");
    (*vir_rcc) |= (0x3 << 4);
    // 寄存器初始化fan
    vir_gpiof->MODER &= (~(0x3 << 12));
    vir_gpiof->MODER |= (0x1 << 12);
    vir_gpiof->ODR &= (~(0x1 << 6));
    printk("硬件寄存器初始化成功\n");
    return 0;
}
static void __exit mycdev_exit(void)
{
    // 取消寄存器地址映射
    iounmap(vir_gpioe);
    iounmap(vir_rcc);
    iounmap(vir_gpiof);
    // 销毁设备节点信息
    device_destroy(cls, MKDEV(major, 0));
    // 销毁字符设备驱动
    class_destroy(cls);
    // 字符设备驱动的注销
    unregister_chrdev(major, "motor");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

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, c, d, e;
    char buf[128] = {0};
    int fd_led = open("/dev/led0", O_RDWR);
    if (fd_led < 0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    int fd_fan = open("/dev/fan", O_RDWR);
    if (fd_fan < 0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    int fd_motor = open("/dev/motor", O_RDWR);
    if (fd_motor < 0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    int fd_bee = open("/dev/bee", O_RDWR);
    if (fd_bee < 0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }

    while (1)
    {
        // 从终端读取
        printf("请选择灯功能\n");
        printf("0(关灯) 1(开灯)>");
        scanf("%d", &a);
        printf("请输入要控制的灯\n");
        printf("1(LED1) 2(LED2) 3(LED3)>");
        scanf("%d", &b);
        if (a == 1) // 开灯
        {
            ioctl(fd_led, LED_ON, &b);
        }
        else if (a == 0) // 关灯
        {
            ioctl(fd_led, LED_OFF, &b);
        }
        printf("请选择风扇的功能\n");
        printf("0(关) 1(开)>");
        scanf("%d", &c);
        if (c == 1) // 开风扇
        {
            ioctl(fd_fan, FAN_ON);
        }
        else if (c == 0) // 关风扇
        {
            ioctl(fd_fan, FAN_OFF);
        }
        printf("请选择马达的功能\n");
        printf("0(关) 1(开)>");
        scanf("%d", &e);
        if (e == 1) // 开马达
        {
            ioctl(fd_motor, MOTOR_ON);
        }
        else if (e == 0) // 关马达
        {
            ioctl(fd_motor, MOTOR_OFF);
        }
        printf("请选择蜂鸣器的功能\n");
        printf("0(关) 1(开)>");
        scanf("%d", &d);
        if (d == 1) // 开蜂鸣器
        {
            ioctl(fd_bee, BEE_ON);
        }
        else if (d == 0) // 关蜂鸣器
        {
            ioctl(fd_bee, BEE_OFF);
        }
    }
    close(fd_led);
    close(fd_fan);
    close(fd_motor);
    close(fd_bee);
    return 0;
}

是你
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
用Qt控制开发板led和蜂鸣器
05-26
在本文中，我们将深入探讨如何在Linux系统下利用Qt框架来控制ARM开发板上的LED灯和蜂鸣器。Qt是一个跨平台的应用程序开发框架，广泛应用于GUI编程，同时也能用于非图形化的系统交互，比如设备控制。对于硬件控制，Qt...
zynq的linux驱动10-ioctl架构来控制led灯
01-31
在Zynq平台上，通过ioctl接口，我们可以编写用户空间应用程序来控制硬件资源，比如LED灯。 首先，我们需要在驱动程序中定义ioctl命令。在C语言中，ioctl命令通常用`#define`来定义，例如： ```c #define MY_LED_ON...
驱动-＞通过ioctl函数实现灯\蜂鸣器和风扇的选择
qq_45711204的博客
10-11 182
通过ioctl函数实现灯\蜂鸣器和风扇的选择
通过ioctl函数实现灯\蜂鸣器和风扇的工作选择
weixin_55430573的博客
10-11 382
通过ioctl函数实现灯\蜂鸣器和风扇的工作选择。
2023.2.8作业【ioctl函数控制六个LED和蜂鸣器、蜂鸣器】
MisakaMikotto的博客
02-08 399
作业
10.11 通过ioctl函数实现灯\蜂鸣器\风扇\马达的工作选择
wjm_ACGN的博客
10-11 122
通过ioctl函数实现灯\蜂鸣器\风扇\马达的工作选择
2023/7/5 ioctl控制led 马达 蜂鸣器 风扇
weixin_43643216的博客
07-05 250
【代码】2023/7/5 ioctl控制led 马达 蜂鸣器 风扇。
实现通过ioctl函数控制led灯，马达，蜂鸣器。风扇
guagua21的博客
07-05 90
test.c 应用程序代码。
ioctl实现功能的控制风扇、蜂鸣器、马达、LED灯，编写四个硬件驱动，一个应用程序控制4个硬件
2301_76545681的博客
06-14 155
【代码】ioctl实现功能的控制风扇、蜂鸣器、马达、LED灯，编写四个硬件驱动，一个应用程序控制4个硬件。
驱动代码同一个文件中编写 LED，马达，蜂鸣器，风扇的控制逻辑
weixin_46711630的博客
07-05 156
进一步完善驱动执行代码的封装，使用了ioctl函数以及使用udev方式的自动设备文件安装
驱动 控制开发版3盏灯、蜂鸣器、风扇、马达
liangqifan_的博客
07-05 174
在这后面分别输入01 02 03 04 05 06分别关闭了6个设备。分别输入01 02 03 04 05 06后的现象。输入141516后的现象。
Beep_LED_DIO.rar_Windows CE蜂鸣器
09-14
3. **蜂鸣器控制**：通过设置I/O端口的特定位，驱动程序可以打开或关闭蜂鸣器。例如，将特定端口位设置为1，蜂鸣器会发声；设置为0，则停止发声。 4. **中断处理**：如果蜂鸣器支持中断，驱动程序还需要注册中断...
pingan.rar_祝你平安_蜂鸣器
09-19
这些函数允许程序员精确地控制蜂鸣器的频率（即音高）和持续时间（即音长），从而构造出音乐的节奏和旋律。 "嗡鸣器奏乐(祝你平安)"这个程序可能使用了一种叫做MIDI（Musical Instrument Digital Interface）的技术...
C语言21：用for语句控制蜂鸣器鸣笛次数.rar
11-29
这些代码可能会更具体地展示如何根据不同的硬件环境来编写`beep()`函数，或者如何在不同操作系统下模拟蜂鸣器的行为。 在深入学习这个主题时，还需要理解操作系统是如何管理硬件资源的，比如在Windows中使用Beep...
Spring Boot中的事件驱动开发
06-27 972
Spring Boot为事件驱动开发提供了便捷的支持，通过ApplicationEvent和ApplicationListener机制，我们可以轻松实现事件的发布和监听。我们可以自定义事件并发布，自定义监听器来处理这些事件。通过本文的介绍，我们了解了Spring Boot中的事件驱动开发，包括自定义事件、发布事件和监听事件的实现方式。在实际开发中，我们可以根据具体需求灵活运用事件驱动开发模式，提升系统的设计质量和开发效率。事件驱动架构的核心思想是将事件的发布者和事件的处理者解耦，通过事件总线来传递事件。
windows USB 设备驱动开发-总章
苏洛坷的博客
06-27 1237
windows usb驱动开发
MindeNLP+MusicGen-音频提示生成
最新发布
07-03
MindeNLP+MusicGen-音频提示生成
WNM2027-VB一款SOT23封装N-Channel场效应MOS管
07-03
SOT23；N—Channel沟道,20V；6A；RDS(ON)=24mΩ@VGS=4.5V,VGS=8V；Vth=0.45~1V；
用ioctl函数打开蜂鸣器
05-26
要使用ioctl函数打开蜂鸣器，需要先打开蜂鸣器设备文件并获取其文件描述符，然后使用ioctl函数发送特定的命令。 以下是一个简单的示例代码，假设蜂鸣器设备文件为/dev/buzzer： ```c #include #include #include...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值