控制LED灯，蜂鸣器，风扇，马达

最新推荐文章于 2024-07-09 17:58:15 发布
最新推荐文章于 2024-07-09 17:58:15 发布
阅读量133 收藏
点赞数
文章标签： linux stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qianyaner_/article/details/131562585
版权

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

#define ON _IOW('l',1,int*)
#define OFF _IOW('l',0,int*)


#endif

led.c

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

// 存储主设备号
int major;

// 存放class_create与device_create函数创建的空间首地址
struct class *cls;
struct device *dev;

// 存储虚拟空间地址
gpio_t *vir_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;
int *vir_rcc;

// 封装操作方法函数
int led_open(struct inode *inode, struct file *file)
{
    return 0;
}
long led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    // 存放从用户空间传过来的数据
    int buf;
    int ret = copy_from_user(&buf, (void *)arg, 4);
    if (ret)
    {
        printk("拷贝用户空间传过来的数据失败\n");
        return -EIO;
    }
    switch (cmd)
    {
    case OFF: // 关灯
        switch (buf)
        {
        case 1: // led1
            vir_led1->odr &= (~(0x1 << 10));
            break;
        case 2: // led2
            vir_led2->odr &= (~(0x1 << 10));
            break;
        case 3: // led3
            vir_led3->odr &= (~(0x1 << 8));
            break;
        }
        break;
    case ON: // 开灯
        switch (buf)
        {
        case 1: // led1
            vir_led1->odr |= (0x1 << 10);
            break;
        case 2: // led2
            vir_led2->odr |= (0x1 << 10);
            break;
        case 3: // led3
            vir_led3->odr |= (0x1 << 8);
            break;
        }
        break;
    default:
        break;
    }
    return 0;
}
int led_close(struct inode *inode, struct file *file)
{
    return 0;
}

// 声明操作方法结构体变量并初始化
struct file_operations fops =
    {
        .open = led_open,
        .unlocked_ioctl = led_ioctl,
        .release = led_close,
};

static int __init led_init(void)
{
    int i;

    // 注册字符设备驱动
    major = register_chrdev(0, "led", &fops);
    if (major < 0)
    {
        printk("注册字符设备驱动失败\n");
        return -EIO;
    }
    printk("注册字符设备驱动成功\n");

    // 自动生成设备节点
    // 向上提交目录
    cls = class_create(THIS_MODULE, "led");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    printk("向上提交目录成功\n");

    // 向上提交设备信息
    for (i = 0; i < 3; i++)
    {
        dev = device_create(cls, NULL, MKDEV(major, i), NULL, "led%d", i);
        if (IS_ERR(dev))
        {
            printk("向上提交设备信息失败\n");
            return -PTR_ERR(dev);
        }
    }
    printk("向上提交设备信息成功\n");

    // 物理地址映射
    vir_led1 = ioremap(GPIOE, sizeof(gpio_t));
    if (vir_led1 == NULL)
    {
        printk("led1相关寄存器物理地址映射失败\n");
        return -EIO;
    }
    vir_led2 = ioremap(GPIOF, sizeof(gpio_t));
    if (vir_led2 == NULL)
    {
        printk("led2相关寄存器物理地址映射失败\n");
        return -EIO;
    }
    vir_led3 = vir_led1;
    vir_rcc = ioremap(RCC, 4);
    if (vir_rcc == NULL)
    {
        printk("rcc相关寄存器物理地址映射失败\n");
        return -EIO;
    }
    printk("寄存器物理地址映射成功\n");

    // 寄存器初始化
    // rcc寄存器使能
    (*vir_rcc) |= (0x3 << 4);
    // 设置为输出
    // led1
    vir_led1->moder &= (~(0x3 << 20));
    vir_led1->moder |= (0x1 << 20);
    // led2
    vir_led2->moder &= (~(0x3 << 20));
    vir_led2->moder |= (0x1 << 20);
    // led3
    vir_led3->moder &= (~(0x3 << 16));
    vir_led3->moder |= (0x1 << 16);
    // 默认为灯灭
    vir_led1->odr &= (~(0x1 << 10)); // led1
    vir_led2->odr &= (~(0x1 << 10)); // led2
    vir_led3->odr &= (~(0x1 << 8));  // led3
    printk("寄存器初始化成功\n");
    printk("LED灯设备安装成功\n");

    return 0;
}

static void __exit led_exit(void)
{
    int i;
    // 字符设备驱动注销
    unregister_chrdev(major, "led");
    // 销毁设备节点信息
    for (i = 0; i < 3; i++)
    {
        device_destroy(cls, MKDEV(major, i));
    }
    // 销毁目录
    class_destroy(cls);
    // 取消物理地址映射
    iounmap(vir_led1);
    iounmap(vir_led2);
    iounmap(vir_rcc);
    printk("取消地址映射成功\n");
    printk("LED灯设备安装成功\n");
}

module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");

breeze.c

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

// 存储主设备号
int major;

// 存放class_create与device_create函数创建的空间首地址
struct class *cls;
struct device *dev;

// 存储虚拟空间地址
gpio_t *vir_breeze;
int *vir_rcc;

// 封装操作方法函数
int breeze_open(struct inode *inode, struct file *file)
{
    return 0;
}
long breeze_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case OFF:
        vir_breeze->odr &= (~(0x1 << 6));
        break;
    case ON:
        vir_breeze->odr |= (0x1 << 6);
        break;
    }
    return 0;
}
int breeze_close(struct inode *inode, struct file *file)
{
    return 0;
}

// 声明操作方法结构体变量并初始化
struct file_operations fops =
    {
        .open = breeze_open,
        .unlocked_ioctl = breeze_ioctl,
        .release = breeze_close,
};

static int __init breeze_init(void)
{
    // 注册字符设备驱动
    major = register_chrdev(0, "breeze", &fops);
    if (major < 0)
    {
        printk("注册字符设备驱动失败\n");
        return -EIO;
    }
    printk("注册字符设备驱动成功\n");

    // 自动生成设备节点
    // 向上提交目录
    cls = class_create(THIS_MODULE, "breeze");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    printk("向上提交目录成功\n");

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

    // 物理地址映射
    vir_breeze = ioremap(GPIOB, sizeof(gpio_t));
    if (vir_breeze == NULL)
    {
        printk("breeze相关寄存器物理地址映射失败\n");
        return -EIO;
    }
    vir_rcc = ioremap(RCC, 4);
    if (vir_rcc == NULL)
    {
        printk("rcc相关寄存器物理地址映射失败\n");
        return -EIO;
    }
    printk("寄存器物理地址映射成功\n");

    // 寄存器初始化
    // rcc寄存器使能
    (*vir_rcc) |= (0x1 << 1);
    // 设置为输出
    vir_breeze->moder &= (~(0x3 << 12));
    vir_breeze->moder |= (0x1 << 12);

    // 默认蜂鸣器不响
    vir_breeze->odr &= (~(0x1 << 6));
    printk("寄存器初始化成功\n");
    printk("蜂鸣器设备安装成功\n");

    return 0;
}

static void __exit breeze_exit(void)
{
    // 字符设备驱动注销
    unregister_chrdev(major, "breeze");
    // 销毁设备节点信息
    device_destroy(cls, MKDEV(major, 0));
    // 销毁目录
    class_destroy(cls);
    // 取消物理地址映射
    iounmap(vir_breeze);
    iounmap(vir_rcc);
    printk("取消地址映射成功\n");
    printk("蜂鸣器设备安装成功\n");
}

module_init(breeze_init);
module_exit(breeze_exit);
MODULE_LICENSE("GPL");

fan.c

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


// 存储主设备号
int major;

// 存放class_create与device_create函数创建的空间首地址
struct class *cls;
struct device *dev;

// 存储虚拟空间地址
gpio_t *vir_fan;
int *vir_rcc;

// 封装操作方法函数
int fan_open(struct inode *inode, struct file *file)
{
    return 0;
}
long fan_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case OFF:
        vir_fan->odr &= (~(0x1 << 9));
        break;
    case ON:
        vir_fan->odr |= (0x1 << 9);
        break;
    }
    return 0;
}
int fan_close(struct inode *inode, struct file *file)
{
    return 0;
}

// 声明操作方法结构体变量并初始化
struct file_operations fops =
    {
        .open = fan_open,
        .unlocked_ioctl = fan_ioctl,
        .release = fan_close,
};

static int __init fan_init(void)
{
    // 注册字符设备驱动
    major = register_chrdev(0, "fan", &fops);
    if (major < 0)
    {
        printk("注册字符设备驱动失败\n");
        return -EIO;
    }
    printk("注册字符设备驱动成功\n");

    // 自动生成设备节点
    // 向上提交目录
    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, "fan0");
    if (IS_ERR(dev))
    {
        printk("向上提交设备信息失败\n");
        return -PTR_ERR(dev);
    }
    printk("向上提交设备信息成功\n");

    // 物理地址映射
    vir_fan = ioremap(GPIOE, sizeof(gpio_t));
    if (vir_fan == NULL)
    {
        printk("fan相关寄存器物理地址映射失败\n");
        return -EIO;
    }
    vir_rcc = ioremap(RCC, 4);
    if (vir_rcc == NULL)
    {
        printk("rcc相关寄存器物理地址映射失败\n");
        return -EIO;
    }
    printk("寄存器物理地址映射成功\n");

    // 寄存器初始化
    // rcc寄存器使能
    (*vir_rcc) |= (0x1 << 4);
    // 设置为输出
    vir_fan->moder &= (~(0x3 << 18));
    vir_fan->moder |= (0x1 << 18);

    // 默认蜂鸣器不响
    vir_fan->odr &= (~(0x1 << 9));
    printk("寄存器初始化成功\n");
    printk("风扇设备安装成功\n");

    return 0;
}

static void __exit fan_exit(void)
{
    // 字符设备驱动注销
    unregister_chrdev(major, "fan");
    // 销毁设备节点信息
    device_destroy(cls, MKDEV(major, 0));
    // 销毁目录
    class_destroy(cls);
    // 取消物理地址映射
    iounmap(vir_fan);
    iounmap(vir_rcc);
    printk("取消地址映射成功\n");
    printk("风扇设备卸载成功\n");
}

module_init(fan_init);
module_exit(fan_exit);
MODULE_LICENSE("GPL");

motor.c

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

// 存储主设备号
int major;

// 存放class_create与device_create函数创建的空间首地址
struct class *cls;
struct device *dev;

// 存储虚拟空间地址
gpio_t *vir_motor;
int *vir_rcc;

// 封装操作方法函数
int motor_open(struct inode *inode, struct file *file)
{
    return 0;
}
long motor_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
    case OFF:
        vir_motor->odr &= (~(0x1 << 6));
        break;
    case ON:
        vir_motor->odr |= (0x1 << 6);
        break;
    }
    return 0;
}
int motor_close(struct inode *inode, struct file *file)
{
    return 0;
}

// 声明操作方法结构体变量并初始化
struct file_operations fops =
    {
        .open = motor_open,
        .unlocked_ioctl = motor_ioctl,
        .release = motor_close,
};

static int __init motor_init(void)
{
    // 注册字符设备驱动
    major = register_chrdev(0, "motor", &fops);
    if (major < 0)
    {
        printk("注册字符设备驱动失败\n");
        return -EIO;
    }
    printk("注册字符设备驱动成功\n");

    // 自动生成设备节点
    // 向上提交目录
    cls = class_create(THIS_MODULE, "motor");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    printk("向上提交目录成功\n");

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

    // 物理地址映射
    vir_motor = ioremap(GPIOF, sizeof(gpio_t));
    if (vir_motor == NULL)
    {
        printk("motor相关寄存器物理地址映射失败\n");
        return -EIO;
    }
    vir_rcc = ioremap(RCC, 4);
    if (vir_rcc == NULL)
    {
        printk("rcc相关寄存器物理地址映射失败\n");
        return -EIO;
    }
    printk("寄存器物理地址映射成功\n");

    // 寄存器初始化
    // rcc寄存器使能
    (*vir_rcc) |= (0x1 << 5);
    // 设置为输出
    vir_motor->moder &= (~(0x3 << 12));
    vir_motor->moder |= (0x1 << 12);

    // 默认蜂鸣器不响
    vir_motor->odr &= (~(0x1 << 6));
    printk("寄存器初始化成功\n");
    printk("马达设备安装成功\n");

    return 0;
}

static void __exit motor_exit(void)
{
    // 字符设备驱动注销
    unregister_chrdev(major, "motor");
    // 销毁设备节点信息
    device_destroy(cls, MKDEV(major, 0));
    // 销毁目录
    class_destroy(cls);
    // 取消物理地址映射
    iounmap(vir_motor);
    iounmap(vir_rcc);
    printk("马达设备卸载成功\n");
}

module_init(motor_init);
module_exit(motor_exit);
MODULE_LICENSE("GPL");

test.c

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

// LED灯控制函数
void led_func(void)
{
    int num, l;
    int fd = open("/dev/led0", O_RDWR);
    if (fd < 0)
    {
        printf("打开文件失败\n");
        return;
    }

    printf("控制第几盏灯，1(led1) 2(led2) 3(led3) >");
    scanf("%d", &num);
    printf("0(关灯) 1(开灯) >");
    scanf("%d", &l);
    if (l == 0)
    {
        ioctl(fd, OFF, &num);
    }
    else if (l == 1)
    {
        ioctl(fd, ON, &num);
    }

    close(fd);
}

// 蜂鸣器控制函数
void breeze_func(void)
{
    int l;
    int fd = open("/dev/breeze0", O_RDWR);
    if (fd < 0)
    {
        printf("打开文件失败\n");
        return;
    }

    printf("0(关闭) 1(启动) >");
    scanf("%d", &l);
    if (l == 0)
    {
        ioctl(fd, OFF);
    }
    else if (l == 1)
    {
        ioctl(fd, ON);
    }

    close(fd);
}

// 风扇控制函数
void fan_func(void)
{
    int l;
    int fd = open("/dev/fan0", O_RDWR);
    if (fd < 0)
    {
        printf("打开文件失败\n");
        return;
    }

    printf("0(关闭) 1(启动) >");
    scanf("%d", &l);
    if (l == 0)
    {
        ioctl(fd, OFF);
    }
    else if (l == 1)
    {
        ioctl(fd, ON);
    }

    close(fd);
}

// 马达控制函数
void motor_func(void)
{
    int l;
    int fd = open("/dev/motor0", O_RDWR);
    if (fd < 0)
    {
        printf("打开文件失败\n");
        return;
    }

    printf("0(关闭) 1(启动) >");
    scanf("%d", &l);
    if (l == 0)
    {
        ioctl(fd, OFF);
    }
    else if (l == 1)
    {
        ioctl(fd, ON);
    }

    close(fd);
}

int main(int argc, const char *argv[])
{
    int dev;
    while (1)
    {
        printf("请输入要控制的设备 1(LED灯) 2(蜂鸣器) 3(风扇) 4(马达) >");
        scanf("%d", &dev);
        switch (dev)
        {
        case 1:
            led_func();
            break;
        case 2:
            breeze_func();
            break;
        case 3:
            fan_func();
            break;
        case 4:
            motor_func();
            break;
        default:
            printf("输入错误\n");
        }
    }
    return 0;
}

qianyaner_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
驱动实验（LED/蜂鸣器/风扇）
crispy715的博客
10-11 327
驱动day3
用Qt控制开发板led和蜂鸣器
05-26
在本文中，我们将深入探讨如何在Linux系统下利用Qt框架来控制ARM开发板上的LED灯和蜂鸣器。Qt是一个跨平台的应用程序开发框架，广泛应用于GUI编程，同时也能用于非图形化的系统交互，比如设备控制。对于硬件控制，Qt...
2023/7/5 ioctl控制led 马达 蜂鸣器 风扇
weixin_43643216的博客
07-05 252
【代码】2023/7/5 ioctl控制led 马达 蜂鸣器 风扇。
ioctl控制LED、蜂鸣器、风扇、马达
weixin_60693863的博客
07-25 179
【代码】ioctl控制LED、蜂鸣器、风扇、马达。
驱动 控制开发版3盏灯、蜂鸣器、风扇、马达
liangqifan_的博客
07-05 179
在这后面分别输入01 02 03 04 05 06分别关闭了6个设备。分别输入01 02 03 04 05 06后的现象。输入141516后的现象。
驱动流水灯，风扇，蜂鸣器，震动马达
qq_65394904的博客
02-08 146
【代码】驱动流水灯，风扇，蜂鸣器，震动马达。
驱动-＞通过ioctl函数实现灯\蜂鸣器和风扇的选择
qq_45711204的博客
10-11 185
通过ioctl函数实现灯\蜂鸣器和风扇的选择
ioctl实现功能的控制风扇、蜂鸣器、马达、LED灯，编写四个硬件驱动，一个应用程序控制4个硬件
2301_76545681的博客
06-14 156
【代码】ioctl实现功能的控制风扇、蜂鸣器、马达、LED灯，编写四个硬件驱动，一个应用程序控制4个硬件。
通过ioctl函数实现灯\蜂鸣器和风扇的工作选择
weixin_55430573的博客
10-11 382
通过ioctl函数实现灯\蜂鸣器和风扇的工作选择。
驱动代码同一个文件中编写 LED，马达，蜂鸣器，风扇的控制逻辑
weixin_46711630的博客
07-05 157
进一步完善驱动执行代码的封装，使用了ioctl函数以及使用udev方式的自动设备文件安装
嵌入式--蜂鸣器控制实验.docx
01-09
嵌入式--蜂鸣器控制实验 本实验的主要目的是了解 ARM 处理器 PWM 接口的处理机制，并掌握在 S3C2440A 平台下进行 PWM 接口应用编程。实验中使用 Sinosys-EA2440 实验箱和 PC 机，通过脉冲宽度调制（PWM）技术对蜂鸣...
led.rar_51系列LED灯闪烁后蜂鸣器响起
09-14
本文将深入探讨“51系列LED灯闪烁后蜂鸣器响起”的相关知识点，这通常涉及到单片机编程、IO口控制以及定时器的应用。 首先，51系列单片机，如AT89C51，拥有多个可编程输入/输出（I/O）端口，用于控制外部设备，如...
LED灯带控制器原理图
01-19
led灯带控制器是一种发光二极管，是一种能够将电能转化为可见光的固态的半导体器件，它可以直接把电转化为光。电流通过导线作用于半导体，... 　led灯控制器线路图由电源电路、脉冲发生器、控制电路和LED显示电路组成
【linux/shell】linux如何去除字符串中空格
qq_35902025的博客
07-06 412
linux如何去除字符串中空格 tr命令可以用来替换或删除字符 sed是一个流编辑器，可以用来处理文本
RedHat运维-LinuxSELinux基础4-端口绑定SELinux上下文
a15735748145a的博客
07-06 635
12. 将60001/tcp端口上的SELinux上下文由http_port_t调整为gopher_port_t的方法是______________________；13. 将60002/tcp端口上的SELinux上下文由gopher_port_t调整为ssh_port_t的方法是______________________；14. 将60003/tcp端口上的SELinux上下文由ssh_port_t调整为http_port_t的方法是_______________________；
Linux_实现简易日志系统
安权_code的博客
07-07 974
在Linux下实现一个日志系统，该日志系统主要用于打印和记录程序的格式化信息，还可以对信息做分析处理，比如把信息分为五种类型：正常运行信息、测试信息，警告信息，错误信息、致命信息，当然还可以显示信息产生的具体时间，并且能够对这些信息进行存档归类。
Linux x86_64平台指令替换函数 text_poke_smp/bp
小立仔
07-05 908
Linux x86_64平台指令替换函数 text_poke_smp/bp简介
linux积累-core文件是干啥的
最新发布
hebtu666
07-09 556
核心转储（core dump）文件是一个程序崩溃时所产生的文件，它记录了程序崩溃时的内存状态，包括程序计数器和寄存器内容等信息。此外，如果程序是在特定的库或者环境中运行时崩溃的，你可能还需要安装那些库的调试符号，并在调试器中设置相应的环境变量。： 当你有了核心转储文件后，你可以使用像GDB（GNU调试器）这样的调试器来分析它。首先，你需要确保你有相应的程序的带调试符号的可执行文件。： 根据调试器提供的信息，你可以检查源代码中可能导致问题的部分，例如无效的指针引用、数组越界或其他违反程序逻辑的操作。
外部中断控制led灯和蜂鸣器
01-03
以下是使用外部中断控制LED灯和蜂鸣器的示例代码： 1. 首先，需要初始化LED和蜂鸣器的引脚以及外部中断的引脚。这可以通过调用相应的初始化函数来完成。 ```python # 引脚初始化 def pin_init(): # 初始化LED引脚...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值