驱动灯、风扇、蜂鸣器、马达

最新推荐文章于 2024-11-01 12:24:48 发布
最新推荐文章于 2024-11-01 12:24:48 发布
阅读量98 收藏
点赞数
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huifeidedapeng/article/details/131564430
版权

应用程序

​
#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 a,b,c,d,e;
    char buf[128]={0};
    int fd=open("/dev/mychrdev0",O_RDWR);
    if(fd<0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    int fd1=open("/dev/fan",O_RDWR);
    if(fd1<0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    int fd2=open("/dev/bee",O_RDWR);
    if(fd2<0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    int fd3=open("/dev/motor",O_RDWR);
    if(fd3<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_ON,&b);
        }
        else if(a==0)//关灯
        {
            ioctl(fd,LED_OFF,&b);
        }
        
        printf("请选择要实现的功能\n");
        printf("0(关风扇) 1(开风扇)>");
        scanf("%d",&c);
        if(c==1)//开风扇
        {
            ioctl(fd1,FAN_ON);
        }
        else if(c==0)//关风扇
        {
            ioctl(fd1,FAN_OFF);
        }
        
        printf("请选择要实现的功能\n");
        printf("0(关马达) 1(开马达)>");
        scanf("%d",&d);
        if(d==1)//开马达
        {
            ioctl(fd3,MOTOR_ON);
        }
        else if(d==0)//关马达
        {
            ioctl(fd3,MOTOR_OFF);
        }

        printf("请选择要实现的功能\n");
        printf("0(关蜂鸣器) 1(开蜂鸣器)>");
        scanf("%d",&e);
        if(e==1)//开蜂鸣器
        {
            ioctl(fd2,BEE_ON);
        }
        else if(e==0)//关蜂鸣器
        {
            ioctl(fd2,BEE_OFF);
        }
    }
    
    close(fd);
    close(fd1);
    close(fd2);
    close(fd3);
    return 0;
}

​

头文件

#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_FAN_ADDR 0X50006000
#define PHY_BEE_ADDR 0X50003000
#define PHY_MOTOR_ADDR 0X50007000

#define PHY_RCC_ADDR    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 BEE_ON _IO('b',1)  //开蜂鸣器
#define BEE_OFF _IO('b',0)//蜂鸣器
#define MOTOR_ON _IO('m',1)  //开马达
#define MOTOR_OFF _IO('m',0)//关马达
#endif

灯驱动

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.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_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;
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_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 LED_OFF: // 关灯
        switch (which)
        {
        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;
    }
    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,
};

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;
    }
    printk("物理地址映射成功\n");
    // 寄存器的初始化
    // rcc
    (*vir_rcc) |= (3 << 4);
    // 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));
    printk("寄存器初始化成功\n");

    return 0;
}

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);
        }
    }
    // 寄存器映射以及初始化
    all_led_init();

    return 0;
}
static void __exit mycdev_exit(void)
{
    int i;
    // 取消地址映射
    iounmap(vir_led1);
    iounmap(vir_led2);
    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");

风扇驱动

#include <linux/init.h>
#include <linux/module.h>
#include<linux/fs.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_fan;
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)
{
    switch(cmd)
    {
        case FAN_ON://开
            vir_fan->ODR |=(0x1<<9);
            break;
        case FAN_OFF://关
            vir_fan->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,
};

int all_fan_init(void)
{
    //寄存器地址的映射
    vir_fan=ioremap(PHY_FAN_ADDR,sizeof(gpio_t));
    if(vir_fan==NULL)
    {
        printk("ioremap filed：%d\n",__LINE__);
        return -ENOMEM;
    }

    vir_rcc=ioremap(PHY_RCC_ADDR,4);
    if(vir_rcc==NULL)
    {
        printk("ioremap filed：%d\n",__LINE__);
        return -ENOMEM;
    }
    printk("物理地址映射成功\n");
    //寄存器的初始化
    //rcc
    (*vir_rcc) |= (1<<4);
    //fan
    vir_fan->MODER &= (~(3<<18));
    vir_fan->MODER |= (1<<18);
    vir_fan->ODR &= (~(1<<9));
    printk("寄存器初始化成功\n");

    return 0;
}

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);
    }
    
    //寄存器映射以及初始化
    all_fan_init();

    return 0;
}
static void __exit mycdev_exit(void)
{
    //取消地址映射
    iounmap(vir_fan);
    iounmap(vir_rcc);
    //销毁设备节点信息
    device_destroy(cls,MKDEV(major,0));
    //销毁目录信息
    class_destroy(cls);
    //注销字符设备驱动
    unregister_chrdev(major,"fan");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

蜂鸣器驱动

#include <linux/init.h>
#include <linux/module.h>
#include<linux/fs.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_bee;
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)
{
    switch(cmd)
    {
        case BEE_ON://开
            vir_bee->ODR |=(0x1<<6);
            break;
        case BEE_OFF://关
            vir_bee->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,
};

int all_bee_init(void)
{
    //寄存器地址的映射
    vir_bee=ioremap(PHY_BEE_ADDR,sizeof(gpio_t));
    if(vir_bee==NULL)
    {
        printk("ioremap filed：%d\n",__LINE__);
        return -ENOMEM;
    }

    vir_rcc=ioremap(PHY_RCC_ADDR,4);
    if(vir_rcc==NULL)
    {
        printk("ioremap filed：%d\n",__LINE__);
        return -ENOMEM;
    }
    printk("物理地址映射成功\n");
    //寄存器的初始化
    //rcc
    (*vir_rcc) |= (1<<1);
    //bee
    vir_bee->MODER &= (~(3<<12));
    vir_bee->MODER |= (1<<12);
    vir_bee->ODR &= (~(1<<6));
    printk("寄存器初始化成功\n");

    return 0;
}

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);
    }
    
    //寄存器映射以及初始化
    all_bee_init();

    return 0;
}
static void __exit mycdev_exit(void)
{
    //取消地址映射
    iounmap(vir_bee);
    iounmap(vir_rcc);
    //销毁设备节点信息
    device_destroy(cls,MKDEV(major,0));
    //销毁目录信息
    class_destroy(cls);
    //注销字符设备驱动
    unregister_chrdev(major,"bee");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

马达驱动

#include <linux/init.h>
#include <linux/module.h>
#include<linux/fs.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_motor;
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)
{
    switch(cmd)
    {
        case MOTOR_ON://开
            vir_motor->ODR |=(0x1<<6);
            break;
        case MOTOR_OFF://关
            vir_motor->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,
};

int all_motor_init(void)
{
    //寄存器地址的映射
    vir_motor=ioremap(PHY_MOTOR_ADDR,sizeof(gpio_t));
    if(vir_motor==NULL)
    {
        printk("ioremap filed：%d\n",__LINE__);
        return -ENOMEM;
    }

    vir_rcc=ioremap(PHY_RCC_ADDR,4);
    if(vir_rcc==NULL)
    {
        printk("ioremap filed：%d\n",__LINE__);
        return -ENOMEM;
    }
    printk("物理地址映射成功\n");
    //寄存器的初始化
    //rcc
    (*vir_rcc) |= (1<<5);
    //fan
    vir_motor->MODER &= (~(3<<12));
    vir_motor->MODER |= (1<<12);
    vir_motor->ODR &= (~(1<<6));
    printk("寄存器初始化成功\n");

    return 0;
}

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);
    }
    
    //寄存器映射以及初始化
    all_motor_init();

    return 0;
}
static void __exit mycdev_exit(void)
{
    //取消地址映射
    iounmap(vir_motor);
    iounmap(vir_rcc);
    //销毁设备节点信息
    device_destroy(cls,MKDEV(major,0));
    //销毁目录信息
    class_destroy(cls);
    //注销字符设备驱动
    unregister_chrdev(major,"motor");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

huifeidedapeng
关注
驱动实验（LED/蜂鸣器/风扇）
crispy715的博客
10-11 420
驱动day3
驱动蜂鸣器，风扇与马达
Huge_Whale的博客
02-28 247
编写基于A7核驱动蜂鸣器，风扇，马达的代码
编写蜂鸣器/风扇/马达驱动代码
qq_54344539的博客
02-28 506
编写蜂鸣器/风扇/马达驱动代码
PWM方波驱动风扇，蜂鸣器，马达工作
m0_68004652的博客
10-23 532
PWM方波实验
蜂鸣器、风扇、震动马达
laoKdx的博客
09-21 1063
基于ARM实现蜂鸣器、风扇以及震动马达工作
PWM实现蜂鸣器、马达、风扇
m0_59181734的博客
09-21 383
PWM实现蜂鸣器、马达、风扇。
编写蜂鸣器/风扇/马达代码
weixin_46323325的博客
02-28 646
编写蜂鸣器/风扇/马达代码
stm32 马达，风扇，蜂鸣器
m0_72777834的博客
09-21 371
stm32
驱动流水灯，风扇，蜂鸣器，震动马达
qq_65394904的博客
02-08 210
【代码】驱动流水灯，风扇，蜂鸣器，震动马达。
20230428驱动蜂鸣器马达和风扇
qq_38175059的博客
04-28 118
驱动蜂鸣器马达和风扇
PWM实验（控制蜂鸣器，风扇，马达）
yayyy4的博客
10-03 3330
arm
ARM--PWM实验（蜂鸣器、马达、风扇）
crispy715的博客
09-21 560
arm
驱动：代码实现蜂鸣器和led灯点亮
m0_73943160的博客
02-08 768
LED灯单独点亮以及蜂鸣器
arduino小车电机不转_一文解析—电机驱动设计方案
weixin_39753791的博客
10-22 3503
24V无刷直流 (BLDC) 电机正弦波驱动，应用于空气净化器风扇此参考设计是用于无刷直流 (BLDC) 电机的经济实惠型、小尺寸 (SFF)、三相正弦电机驱动，在 24V 时的功率高达 50W。此板接受 24V 输入并提供三路电机输出，从而以正弦方式驱动 BLDC 电机。在通过 IR(红外)传感器接受速度命令之后，使用微控制器 (MCU)(在本设计中为 MSP430G2303)从外部关闭速度环路...
第二届新生程序设计竞赛热身赛(C语言）
weixin_73947887的博客
10-31 1093
XP迷失在X星球，他醒来时已经很久很久很久没有吃过东西了。他突然发现身边有一张地图，上面有X星球上每一个食物供给点的位置。太好了，XP跳了起来。他决定先把肚子填饱再去寻找其他伙伴。现在已知XP的位置(X, Y)，以及他的行走速度N（米/分钟），请问他需要多久才能到达最近的食物供给点。
C语言 | Leetcode C语言题解之第521题最长特殊序列I
m0_59237910的博客
10-31 587
C语言 | Leetcode C语言题解之第521题最长特殊序列I
【数据结构二叉树】补充：C实现二叉树的层次遍历
qq_43359515的博客
11-01 382
数据结构中对于二叉树的遍历方式，主要有4种，除了层次遍历，还有先序遍历、中序遍历和后序遍历。关于先序遍历、中序遍历和后序遍历的算法实现过程，可以参考二叉树的先序遍历、中序遍历和后序遍历欢迎大家一起留言讨论~
电子商务之价格优化算法：梯度下降：机器学习在价格优化中的角色.docx
最新发布
11-05
电子商务之价格优化算法：梯度下降：机器学习在价格优化中的角色.docx
ToadforOracle与Oracle数据库版本兼容性教程.docx
11-05
ToadforOracle与Oracle数据库版本兼容性教程.docx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值