驱动代码同一个文件中编写 LED，马达，蜂鸣器，风扇的控制逻辑

已于 2023-07-06 09:37:01 修改
阅读量157 收藏
点赞数
文章标签： 单片机 嵌入式硬件
于 2023-07-05 21:46:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46711630/article/details/131564512
版权

1.应用层代码控制规则

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

int main(int argc, char const *argv[])
{
    int select = 0;
    char buf[128] = {0};
    int fd;
    int key = -1;
    while (1)
    {

        printf("选择你要操作的硬件:1<指示灯>,2<蜂鸣器>,3<马达>,4<风扇>");
        scanf("%d", &select);
        if (select == 1)
        {   
            // 打开LED灯的设备文件
            fd = open("/dev/mychrdev", O_RDWR);
            if (fd < 0)
            {
                printf("打开设备文件失败\n");
                exit(-1);
            }
            // 控制灯的熄灭

            // 控制哪个灯
            int LED = -1;
            /***LED的控制***/
            printf("选择要实现的功能:1<亮灯>,0<熄灯>");
            scanf("%d", &key);
            // 亮灯
            if (key == 1)
            {
                printf("选择要点亮哪个灯:1<LED1>,2<LED2>,3<LED3>");
                scanf("%d", &LED);
                ioctl(fd, LED_ON, &LED);
            }
            // 熄灯
            else if (key == 0)
            {
                printf("选择要熄灭哪个灯:1<LED1>,2<LED2>,3<LED3>");
                scanf("%d", &LED);
                ioctl(fd, LED_OFF, &LED);
            }
        }
        else if (select == 2)
        {
            // 打开蜂鸣器的设备文件
            fd = open("/dev/fengming", O_RDWR);
            if (fd < 0)
            {
                printf("打开设备文件失败\n");
                exit(-1);
            }
            printf("蜂鸣器操作:1<响动>,2<安静>");
            scanf("%d", &key);
            if (key == 1)
            {
                ioctl(fd, FENGMING_ON);
            }
            else if (key == 0)
            {
                ioctl(fd, FENGMING_OFF);
            }
        }
        else if (select == 3)
        {
            fd=-1;
            // 打开mada的设备文件
            fd = open("/dev/mada", O_RDWR);
            if (fd < 0)
            {
                printf("打开设备文件失败\n");
                exit(-1);
            }
            printf("mada操作:1<响动>,2<安静>");
            scanf("%d", &key);
            if (key == 1)
            {
                ioctl(fd, MADA_ON);
            }
            else if (key == 0)
            {
                ioctl(fd, MADA_OFF);
            }
        }
        else if (select == 4)
        {
            fd=-1;
            // 打开风扇的设备文件
            fd = open("/dev/fengshan", O_RDWR);
            if (fd < 0)
            {
                printf("打开设备文件失败\n");
                exit(-1);
            }
            printf("风扇操作:1<响动>,2<安静>");
            scanf("%d", &key);
            if (key == 1)
            {
                ioctl(fd, FENGSHAN_ON);
            }
            else if (key == 0)
            {
                ioctl(fd, FENGSHAN_OFF);
            }
        }
    }

    close(fd);

    return 0;
}

2.head 头文件的封装

#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 PHY_LED1_ADDR 0X50006000
#define PHY_LED2_ADDR    0X50007000
#define PHY_LED3_ADDR 0X50006000
#define PHY_RCC_ADDR    0X50000A28
#define PHY_FENGMING 0x50003000
#define PHY_FENGSHAN  0x50006000
#define PHY_MADA 0x50007000
//定义功能码
#define LED_ON _IOW('l',1,int)//开灯
#define LED_OFF _IOW('l',0,int)//关灯
#define FENGMING_ON _IO('a',1)//蜂鸣器输入高电频
#define FENGMING_OFF _IO('a',0)//蜂鸣器输入低电频
#define MADA_ON _IO('b',1)//马达输入高电频
#define MADA_OFF _IO('b',0)//马达输入低电频
#define FENGSHAN_ON _IO('c',1)//风扇输入高电频
#define FENGSHAN_OFF _IO('c',0)//风扇输入低电频
#endif

3.驱动代码执行运行逻辑

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/device.h>
#include "head.h"
//判断哪个硬件
char sum;
int major;
int major_fm;
int major_md;
int major_fs;
char kbuf[128] = {0};
gpio_t *vir_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;
gpio_t *vir_fengming;
gpio_t *vir_mada;
gpio_t *vir_fengshan;
unsigned int *vir_rcc;
struct class *cls;
struct class *cls_fm;
struct class *cls_md;
struct class *cls_fs;
struct device *dev;


int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
ssize_t mycdev_read(struct file *file, char *ubuf, size_t size, loff_t *lof)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    unsigned long ret;
    // 向用户空间读取拷贝
    if (size > sizeof(kbuf)) // 用户空间期待读取的大小内核满足不了，那就给内核支持的最大大小
        size = sizeof(kbuf);
    ret = copy_to_user(ubuf, kbuf, size);
    if (ret) // 拷贝失败
    {
        printk("copy_to_user filed\n");
        return ret;
    }
    return 0;
}
ssize_t mycdev_write(struct file *file, const char *ubuf, size_t size, loff_t *lof)
{
    unsigned long ret;
    // 从用户空间读取数据
    if (size > sizeof(kbuf)) // 用户空间期待读取的大小内核满足不了，那就给内核支持的最大大小
        size = sizeof(kbuf);
    ret = copy_from_user(&sum, ubuf, size);
    if (ret) // 拷贝失败
    {
        printk("copy_to_user filed\n");
        return ret;
    }


    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    int ret, select;
    // LED指示灯
    if (cmd == LED_ON || cmd == LED_OFF)
    {
        ret = copy_from_user(&select, (void *)arg, sizeof(int));
        if (ret)
        {
            printk("copy_form_user_led flied\n");
            return -EIO;
        }
        switch (cmd)
        {
        case LED_ON:
            switch (select)
            {
            case 1:
                vir_led1->ODR |= (0x1 << 10);
                break;
            case 2:
                vir_led2->ODR |= (0x1 << 10);
                break;
            case 3:
                vir_led3->ODR |= (0x1 << 8);
                break;
            }
            break;
        case LED_OFF:
            switch (select)
            {
            case 1:
                vir_led1->ODR &= (~(0x1 << 10));
                break;
            case 2:
                vir_led2->ODR &= (~(0x1 << 10));
                break;
            case 3:
                vir_led3->ODR &= (~(0x1 << 8));
                break;
            }
        }
    }
    //蜂鸣器控制
    else if(cmd==FENGMING_ON||cmd==FENGMING_OFF)
    {
        printk("蜂鸣器\n");
        if(cmd==FENGMING_ON)
        {
            vir_fengming->ODR|= (1<<6);
        }
        else if(cmd==FENGMING_OFF)
        {
            vir_fengming->ODR &= (~(1<<6));
        }
    }
    //马达的控制
    else if(cmd==MADA_ON||cmd==MADA_OFF)
    {   printk("马达\n");
        if(cmd==MADA_ON)
        {
            vir_mada->ODR |=(1<<6);
        }
        else if(cmd==MADA_OFF)
        {
            vir_mada->ODR &= (~(1<<6));
        }
    }
    //风扇的控制
    else if(cmd==FENGSHAN_ON||cmd==FENGSHAN_OFF)
    {   
        printk("风扇\n");
        if(cmd==FENGSHAN_ON)
        {
            vir_fengshan->ODR |=(1<<9);
            printk("风扇启动\n");
        }
        else if(cmd==FENGSHAN_OFF)
        {
            vir_fengshan->ODR &= (~(1<<9));
        }
    }

    return 0;
}

int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    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;
    }
    /*风扇马达蜂鸣器*/
    vir_fengshan=vir_led1;
    vir_mada=vir_led2;
    vir_fengming=ioremap(PHY_FENGMING,sizeof(gpio_t));
    printk("物理地址映射成功\n");
    // 寄存器的初始化
    // rcc
    (*vir_rcc) |= (3 << 4);
    (*vir_rcc) |= (1<<1);
    // 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));
    //蜂鸣器
    vir_fengming->MODER &= (~(3<<12));
    vir_fengming->MODER |= (1<<12);
    vir_fengming->ODR &=(~(1<<6));
    //马达
    vir_mada->MODER &=(~(3<<12));
    vir_mada->MODER |=(1<<12);
    vir_mada->ODR &=(~(1<<6));
    //风扇
    vir_fengshan->MODER &= (~(3<<18));
    vir_fengshan->MODER |= (1<<18);
    vir_fengshan->ODR &= (~(1<<9));
    printk("寄存器初始化成功\n");

    return 0;
}
// 定义操作方法结构体变量并赋值
struct file_operations fops = {

    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
    .unlocked_ioctl = mycdev_ioctl,
};
static int __init mycdev_init(void)
{
        /****LED灯驱动***/
        // 字符设备驱动注册
        printk("LED灯驱动安装\n");
        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);
        }
        printk("向上提交目录成功\n");
        // 向上提交设备信息
        dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "mychrdev");
        if (IS_ERR(dev))
        {
            printk("向上提交设备信息失败\n");
            return PTR_ERR(dev);
        }
        printk("向上提交设备信息成功\n");
    
        /****蜂鸣器驱动***/
        // 蜂鸣器驱动注册
        
        printk("蜂鸣器驱动安装\n");
        major_fm = register_chrdev(0, "fengming", &fops);
        if (major_fm < 0)
        {
            printk("字符设备驱动注册失败\n");
            return major_fm;
        }
        printk("字符设备驱动注册成功:major_fm=%d\n", major_fm);
        // 向上提交目录
        cls_fm = class_create(THIS_MODULE, "fengming");
        if (IS_ERR(cls_fm))
        {
            printk("向上提交目录失败\n");
            return PTR_ERR(cls_fm);
        }
        printk("向上提交目录成功\n");
        // 向上提交设备信息
        dev = device_create(cls_fm, NULL, MKDEV(major_fm, 0), NULL, "fengming");
        if (IS_ERR(dev))
        {
            printk("向上提交设备信息失败\n");
            return PTR_ERR(dev);
        }
        printk("向上提交设备信息成功\n");
      

    
        /****马达驱动***/
        // 马达驱动注册
       
        printk("马达驱动安装\n");
        major_md = register_chrdev(0, "mada", &fops);
        if (major_md < 0)
        {
            printk("字符设备驱动注册失败\n");
            return major_md;
        }
        printk("字符设备驱动注册成功:major_md=%d\n", major_md);
        // 向上提交目录
        cls_md = class_create(THIS_MODULE, "mada");
        if (IS_ERR(cls_md))
        {
            printk("向上提交目录失败\n");
            return PTR_ERR(cls_md);
        }
        printk("向上提交目录成功\n");
        // 向上提交设备信息
        dev = device_create(cls_md, NULL, MKDEV(major_md, 0), NULL, "mada");
        if (IS_ERR(dev))
        {
            printk("向上提交设备信息失败\n");
            return PTR_ERR(dev);
        }
        printk("向上提交设备信息成功\n");
        

    
        /****风扇驱动驱动***/
        // 字符设备驱动注册
       
        printk("风扇驱动安装\n");
        major_fs = register_chrdev(0, "fengshan", &fops);
        if (major_fs < 0)
        {
            printk("字符设备驱动注册失败\n");
            return major_fs;
        }
        printk("字符设备驱动注册成功:major_fs=%d\n", major_fs);
        // 向上提交目录
        cls_fs = class_create(THIS_MODULE, "fengshan");
        if (IS_ERR(cls_fs))
        {
            printk("向上提交目录失败\n");
            return PTR_ERR(cls_fs);
        }
        printk("向上提交目录成功\n");
        // 向上提交设备信息
        dev = device_create(cls_fs, NULL, MKDEV(major_fs, 0), NULL, "fengshan");
        if (IS_ERR(dev))
        {
            printk("向上提交设备信息失败\n");
            return PTR_ERR(dev);
        }
        printk("向上提交设备信息成功\n");
        
    
        all_led_init();

    return 0;
}
static void __exit mycdev_exit(void)
{
    // 取消地址映射
    iounmap(vir_led1);
    iounmap(vir_led2);
    iounmap(vir_rcc);
    iounmap(vir_fengming);
    // 销毁设备信息
    device_destroy(cls, MKDEV(major, 0));
    device_destroy(cls_fm, MKDEV(major_fm, 0));
    device_destroy(cls_fs, MKDEV(major_fs, 0));
    device_destroy(cls_md, MKDEV(major_md, 0));
    // 销毁目录
    class_destroy(cls);
    class_destroy(cls_fm);
    class_destroy(cls_md);
    class_destroy(cls_fs);
    // 注销字符设备驱动
    unregister_chrdev(major, "mychrdev");
    unregister_chrdev(major_fm, "fengming");
    unregister_chrdev(major_md, "mada");
    unregister_chrdev(major_fs, "fengshan");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

嵌入式大王
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
硬件工程师成长之路（1）——元件基础
云轩阁
01-19 25万+
从电容电阻三极管到屏幕机器视觉详细介绍
智能家居模拟系统
guangyinAA的博客
12-20 965
智能家居模拟系统
C语言温控风机程序,温度控制电风扇单片机c系统proteus仿真.docx
weixin_33664951的博客
05-26 1018
温度控制电风扇单片机c系统proteus仿真.docx摘 要电子技术是根据电子学的原理，运用电子元器件设计和制造某种特定功能的电路以解决实际问题的科学，包括信息电子技术和电力电子技术两大分支。在电气时代的今天，电动机一直在现代化的生产和生活中起着十分重要的作用。据资料统计，现在有的90%以上的动力源自于电动机，电动机与人们的生活息息相关，密不可分。随着现代化步伐的迈进，人们对自动化的需求越来越高，...
编写LED灯的驱动，创建三个设备文件，每个设备文件和一个LED灯绑定，当操作这个设备文件时只能控制设备文件对应的这盏灯
huifeidedapeng的博客
07-06 60
【代码】编写LED灯的驱动，创建三个设备文件，每个设备文件和一个LED灯绑定，当操作这个设备文件时只能控制设备文件对应的这盏灯。
新进半导体推出PWM控制单相H-桥风扇马达驱动芯片
12-03
日前，新进半导体有限公司推出了一款带PWM控制的单相H-桥风扇马达驱动芯片——AM4961。  该款芯片是采用PWM控制可变速的单相无刷直流风扇马达驱动电路，除直接通过改变VTH端电压来调速外，还可外接热敏电阻，来...
BCD推出新款PWM控制单相H-桥风扇马达驱动芯片
12-06
日前，新进半导体有限公司推出了一款带PWM控制的单相H-桥风扇马达驱动芯片--AM4961。该款芯片是采用PWM控制可变速的单相无刷直流风扇马达驱动电路，除直接通过改变VTH 端电压来调速外，还可外接热敏电阻，来控制风扇...
PWM控制蜂鸣器，风扇，马达实验
06-16
总之，“PWM控制蜂鸣器，风扇，马达实验”是一个实践性的学习项目，涵盖了嵌入式系统中的基本控制技术。通过这个项目，学习者将深入理解PWM的工作机制，并能应用到实际的硬件系统中，实现各种控制功能。
凌阳16位变频马达驱动微控制器
12-10
SPMC75系列芯片是由凌阳科技自主设计开发的16位微控制器芯片，其内核采用凌阳科技自主知识产权的µ’nSP微处理器。SPMC75系列芯片集成了变频电机驱动的PWM发生器、多功能捕获比较模块、BLDC电机驱动专用位置侦测...
电源技术中的将马达驱动器连接至PWM源的设计方法
11-03
如何将PWM逻辑信号源连接至电池供电的马达驱动器是我们面临的一道难题。本文介绍了将马达驱动器连接至PWM源的设计方法，其中包括相关方程式与组件选择指南。该方法所采用的电路包括具有精确度与敏感性分析的示例。 ...
BKP备份寄存器和实时时钟笔记
上山的月的博客
07-09 634
一份不错的江科大STM32教学视频笔记，关于STM32的BKP和RTC部分，内容清晰明了，整体架构层次分明。
STM32 系统时钟初始化函数和延时函数
weixin_49155137的博客
07-09 215
如果我们需要得到精确的定时，那么我们可以使用STM32中的定时器(时钟9M，1微秒减9)，例如，SysTick 定时器。SysTick是一个24位的递减计数器，它放在NVIC中，主要目的是为了给操作系统提供一个硬件上的中断(滴答中断)。计数到0 时，SvsTick计数器自动重装初值并继续计数，同时内部的COUNTFLAG标志会置位，触发中断(假如中断使能情况下)。如果我们的程序不使用操作系统，那么SysTick定时器可以用来产生精确的定时。否则超出了LOAD 的范围，高位会被舍去，导致延时不准。
STM32实战篇：按键控制LED
qq_74114817的博客
07-09 79
有两个按键，分别控制两个LED灯。当按键按下后，灯的亮暗状态改变。由图可知，按键一端直接接地，故另一端所对应IO引脚的输入模式应该为。
嵌入式系统中的实时操作系统任务调度策略
qq_38140936的博客
07-09 489
在嵌入式系统中，实时任务调度是确保系统响应性和稳定性的关键方面之一。不同的任务调度策略可以影响系统的性能和实时性。和，并提供相应的代码示例。固定优先级调度是一种基于任务优先级的调度策略，优先级高的任务将在优先级低的任务之前执行。这种策略适用于对实时性要求严格的系统。循环时间片调度是一种轮流分配时间片给每个任务的策略。每个任务在时间片内执行，然后切换到下一个任务。这种调度策略适用于相对较简单的系统，能够提供公平的任务执行机会。当涉及嵌入式开发时，选择适当的通信方式以及对硬件资源的管理是至关重要的。
STM32学习历程（day5）
weixin_60039521的博客
07-09 126
今天学习了OLED屏幕的用法 但是up主是直接给的程序 代码比较繁多 演示了下如何通过OLED调试程序 以及使用断点等、然后就学了EXTI外部中断 以前学习的时候 是通过汇编来学习的 算是了解一点 汇编在这块得自己保存CPU运行时的地址 以及保存现场 恢复现场。但是通过C语言就不要了 编译器都给我们处理好了。
【STM32 ARM】区分MCU,MPU与AP
m0_62599305的博客
07-09 143
在嵌入式系统的世界中，我们经常会听到MCU、MPU和AP这些术语。这些都是微处理器的类型，它们在功能、性能和用途上有所不同。本文将详细介绍这些术语，并通过STM32 ARM架构的例子来解释它们的区别。总的来说，MCU、MPU和AP都是微处理器，但它们在功能、性能和用途上有所不同。理解这些差异可以帮助我们更好地选择适合特定应用的处理器。希望这篇文章能帮助你理解STM32 ARM架构以及MCU、MPU和AP的区别。如果你有任何问题或需要进一步的信息，请随时向我提问。
基于单片机的温控光控智能窗帘设计探讨
最新发布
weixin_45905610的博客
07-10 589
文章使用的核心原件是 AT89C52 单片机，以此为基础进行模块化的设计，在整个设计中通过加入光检测模块和温度检测模块，从而对室内的温度和光照强度进行检测，然后将检测得到的数据传输给单片机，单片机对电机的继电圈的通断进行控制，从而通过电机的正转和反转，从而实现对窗帘开合的设置。并且光检测模块和温度检测模块检测得到的数据可以传输给 LCD 显示器，还可以通过手动控制的方式对窗帘的开合进行设置，从而实现对窗帘开合的多模式的控制。文章使用的单片机的温控光控智能窗帘设计具有很好的抗干扰能力、稳定性，并且具结构简单，
qt writeDatagram 函数详解
xie__jin__cheng的博客
07-09 204
是 Qt 网络编程中的一个函数，它属于QUdpSocket类。这个函数的主要作用是向指定的网络地址和端口发送一个数据报（datagram）。数据报是网络传输中的基本单位，通常用于无连接的网络服务，如 UDP。
stm32使用通用定时器生成pwm
m0_46145044的博客
07-09 62
【代码】stm32使用通用定时器生成pwm。
写一个stm32通过PID算法控制PWM进而控制马达的代码
04-01
抱歉，我是一名AI语言模型，无法编写代码。但我可以给您提供一些思路。 PID控制算法是一种常见的控制算法，可以用于控制PWM输出以控制马达的转速。通常需要先根据实际情况调整PID参数，然后通过读取马达转速以及...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值