ARM驱动蜂鸣器，风扇，LED灯

已于 2022-10-11 23:18:37 修改
阅读量347 收藏 2
点赞数
文章标签： 驱动开发
于 2022-10-11 23:17:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yayyy4/article/details/127273773
版权

1.Makefile编译文件
make arch=arm modname=myled

make arch=arm modname=mybeep

make arch=arm modname=myfan

2.交叉编译工具链编译test.c文件

arm-linux-gnueabihf-gcc test.c

3.复制myled.ko，myfan.ko，mybeep.ko和a.out文件到nfs/rootfs文件中

4.insmod 三个文件，执行a.out

5.代码

mybeep.h文化

#ifndef __MYBEEP_H__
#define __MYBEEP_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;
    volatile unsigned int LCKR;
    volatile unsigned int AFRL;
} gpio_b;
#define PHY_BEEP_ADDR 0X50003000
 
#define PHY_RCC_ADDR 0X50000A28
 
#define BEEP_ON _IO('a', 1)
#define BEEP_OFF _IO('a', 0)
 
#endif

mybeep.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 "myled.h"
#include "myfan.h"
#include "mybeep.h"
#define CNAME "mybeep"
 
int major;           //定义变量接受主设备号
char kbuf[128] = {}; //定义数组用于存放和用户之间拷贝的数据
 
gpio_t *vir_beep;
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 BEEP_ON:
        vir_beep->ODR |= (1 << 6);
        break;
    case BEEP_OFF:
        vir_beep->ODR &= ~(1 << 6);
        break;
    default:
        printk("功能码错误\n");
        break;
    }
    return 0;
}
 
int beep_init(void)
{
    //进行物理地址的映射
    vir_beep = ioremap(PHY_BEEP_ADDR, sizeof(gpio_b));
    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");
 
    //寄存器的初始化
    vir_beep->MODER &= ~(3 << 12);
    vir_beep->MODER |= (1 << 12);
    vir_beep->ODR &= ~(1 << 6);
 
    (*vir_rcc) |= (1 << 1);
 
    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("蜂鸣器设备驱动注册失败\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, "mybeep");
    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);
    printk(KERN_ERR "kernel unload\n");
}
 
module_init(demo_init);
module_exit(demo_exit);
 
MODULE_LICENSE("GPL");

myfan.h文件

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

mybeep.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 "myled.h"
#include "mybeep.h"
#include "myfan.h"
#define CNAME "myfan"
 
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");
 
    //寄存器的初始化
    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("风扇设备驱动注册失败\n");
        return major;
    }
    printk("风扇设备驱动注册成功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, "myfan");
    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");

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=2,
    LED3=3
};

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

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,
};
//一些内核中的宏定义和变量的定义我们需要通过vi -t追
//如果追不到。需要给内核创建索引：ctags -R
//或者在内核目录下执行make tags
//入口函数，当驱动安装的时候执行


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)
{
    //static,限制当前函数只能在本文件使用
    // int 函数返回值类型
    //__init声明此驱动的入口函数在内存中的位置是.init.text段
    //#define __init        __section(".init.text")
        //动态注册字符设备驱动
    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);
	//__exit声明此驱动的入口函数在内存中的位置是.exit.text段
           //#define __exit          __section(".exit.text")

}
//module_init和module_exit是内核提供的宏
//告诉内核驱动的出口函数和出口函数的地址
module_init(demo_init);
module_exit(demo_exit);
//声明遵循GPL开源协议
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"myled.h"
#include"myfan.h"
#include"mybeep.h"

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

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

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

    int fd3=open("dev/myfan",O_RDWR);
    if(fd<0)
    {

        printf("打开FAN设备文件失败\n");
        exit(-1);
    }
    printf("FAN设备文件打开成功\n");
    
    int choice;
    int which;
    while(1)
    {
	    printf("请选择控制任务    1:LED 2:BEEP 3:FAN\n");
	    scanf("%d",&choice);
	    getchar();
	    if(choice == 1)
	    {
	        printf("请输入控制命令:   1:开灯 0:关灯\n");
            	fgets(buf,sizeof(buf),stdin);
		buf[strlen(buf)-1]='\0';
	    	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);
	    	}
	    }
	    else if(choice == 2)
	    {
		printf("请输入控制命令:   1:开蜂鸣器 0:关蜂鸣器\n");
		fgets(buf, sizeof(buf), stdin);
            	buf[strlen(buf) - 1] = '\0';
            	if(buf[0] == '1')
		{
                	ioctl(fd2,BEEP_ON);
		}
            	else
		{
                	ioctl(fd2,BEEP_OFF);
		}
	    }
	    else if(choice == 3)
	    {
		printf("请输入控制命令:   1:开风扇 0:关风扇\n");
           	fgets(buf, sizeof(buf), stdin);
            	buf[strlen(buf) - 1] = '\0';
            	if(buf[0] == '1')
		{
			ioctl(fd3,FAN_ON);
		}
		else
		{
                	ioctl(fd3,FAN_OFF);
		}
	    }
    }
    close(fd);
    close(fd2);
    close(fd3);
    return 0;
}

Makefile文件

modname ?= demo
arch ?= arm

ifeq ($(arch),arm)
KERNELDIR := /home/ymp/fsmp1a/linux-stm32mp-5.10.61-stm32mp-r2-r0/linux-5.10.61
else
KERNELDIR := /lib/modules/$(shell uname -r)/build
endif
PWD:=$(shell pwd)
all:
        make -C $(KERNELDIR) M=$(PWD) modules
clean:
        make -C $(KERNELDIR) M=$(PWD) clean
obj-m:=$(modname).o
~

yayyy4
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2022-10-11使用ioctl函数实现LED灯，蜂鸣器，风扇的驱动工作
m0_58344947的博客
10-11 242
首先是led灯的头文件部分。然后是蜂鸣器的驱动部分代码。然后是蜂鸣器的头文件部分。后面是风扇的头文件部分。最后是应用层的实现代码（三个器件一起初始化使用）然后是 myled.c的驱动文件。
Driver：LED灯操作、内核空间和用户空间的数据交互、ioctl函数、设备文件安装与销毁
Hello, New World!
03-04 1307
1、LED灯操作 用户空间执行open时，led1亮；执行close时，led1灭。 电路原理图：     led1 ---> GPIOC12 如何控制：     cpu datasheet 特殊功能寄存器 在linux下操作GPIO管脚有两种方式：     1)像裸板开发一样通过'指针 + 位操作'来完成特殊功能寄存器的设置。         问题在于：/* 要将特殊功能寄存
编写LED混杂设备驱动：静态映射，如何用Linux内核里的gpio_request(),gpio_set_value()等函数，ioctl函数
欧阳海宾
08-16 5496
如何用Linux内核里的gpio_request(),gpio_set_value()等函数编写LED驱动          步骤一：打开Linux内核源代码里的Documentation文件夹下的gpio.txt文档          文档里介绍了要用到的头文件和gpio函数介绍，用到的头文件是 #include 步骤二：打开Linux sourceindight工程搜索gpio.
#ARM开发# 点亮LED和操作蜂鸣器
zer1123的博客
07-06 3551
实例：Mini2451_Led_s  （文件名） 设备：ARM实验板 PC机 编译环境：KEIL4   MiniTools 实验前准备：   实验板接通电源（不需要打开），连接电脑。打开MiniTools，按住实验板最边上的按钮同时开机，如显示没有连接成功，查看驱动是否安装完全，已经安装驱动的就可以直接显示connected。此时可以从Minitools中把 . bin
嵌入式Linux驱动开发初级-字符设备驱动基IO模型
found_1的博客
03-08 126
嵌入式Linux驱动开发初级-字符设备驱动基IO模型
STM32实现三个灯的流水，蜂鸣器和风扇隔5秒运行一次
最新发布
06-07
在这个项目中，我们关注的是如何使用STM32来控制三个LED灯的流水效果、蜂鸣器以及风扇，使它们每隔5秒轮流工作一次。这涉及到硬件接口编程、定时器配置、中断服务以及GPIO（通用输入输出）操作等基础知识。 首先，...
STM32单片机风扇控制系统设计程序代码.zip
05-06
而温度高报警使用led和三极管驱动后的蜂鸣器来提醒，最后呢，温度一开始使用ds18b20来检测，移植了驱动代码，但发现读取失败，最后看代码也是发现了问题，里边还是会读取io电平，于是这个不能用。查找了资料后，最后...
单片机温度控制器
01-09
报警器可以是声音报警（蜂鸣器）、灯光报警或者无线信号发送到移动端。 7. **电源管理**：为整个系统提供稳定的工作电压，可能需要DC-DC转换器或稳压器来保证单片机和其他组件的正常运行。 在设计智能温度控制器时...
第十章 STM32综合实验 基于ARM的单片机应用及实践STM32案例式教学课件.ppt
06-06
底板包括AT24C02 EEPROM、核心板接口、SD卡接口、W25Q16 16M FLASH、电源指示灯、DC6~16V电源输入、电源接口、电源开关、TFT屏模块接口、NRF24L01模块接口、RS485总线接口、AD模块、DS18B20接口、3*3矩阵键盘、独立...
21163家庭语音控制.zip
02-25
标题“21163家庭语音控制.zip”和描述中提到的内容主要涉及到一个基于单片机的智能家居系统，该系统能够通过语音指令控制LED灯、风扇、继电器和蜂鸣器的开关操作。这个项目的核心技术和知识点主要包括以下几个方面：...
arm控制蜂鸣器的蜂鸣程序
12-03
这个程序时ARM7TDMIPLC2106的芯片，控制蜂鸣器的蜂鸣实验，该蜂鸣器时利用低电平出发方式进行的。
触摸按键控制LED灯实验
qq_45565330的博客
11-15 494
触摸按键控制LED灯实验
【STM32】控制LED灯和蜂鸣器的按键实验
weixin_63726869的博客
05-18 1万+
介绍了如何通过STM32开发板的按键控制LED灯和蜂鸣器的状态。
day03
mailong
06-16 166
回顾： 1.linux设备驱动开发相关   1.1.设备驱动两大核心       操作硬件       提供接口   1.2.linux设备驱动分类           字符设备驱动           块设备驱动           网络设备驱动   1.3.linux系统理念       一切皆文件       字符设备文件       块设备文
第十七节 控制蜂鸣器（GPIO 子系统）
picassocao的博客
02-07 1125
控制蜂鸣器（GPIO 子系统）
I.MX6ULL ARM驱动开发--- pinctrl 和 gpio 子系统的蜂鸣器驱动
qq_41455322的博客
08-23 696
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 3031
ARM练习：通过PWM来控制蜂鸣器的发声
arm中驱动蜂鸣器播放音乐
05-25
在ARM中驱动蜂鸣器播放音乐，可以通过PWM（脉冲宽度调制）来实现。以下是一个简单的实现步骤： 1. 配置PWM模块：设置PWM的频率、占空比等参数。 2. 配置GPIO模块：设置蜂鸣器所连接的GPIO引脚为PWM输出引脚。 3. 将音乐数据转换为PWM占空比：将音乐数据转换为PWM占空比，例如将音乐中的每个音符对应到PWM占空比的不同值上。 4. 将PWM占空比输出到GPIO引脚：将PWM占空比输出到GPIO引脚，即可驱动蜂鸣器播放音乐。 需要注意的是，以上步骤只是一个简单的示例，具体实现还需要根据具体的硬件平台和音乐格式进行相应的调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值