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

最新推荐文章于 2024-07-23 14:18:41 发布
最新推荐文章于 2024-07-23 14:18:41 发布
阅读量65 收藏
点赞数
文章标签： 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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
蜂鸣器驱动_Ｃ５１_驱动蜂鸣器_
10-02
在电子工程领域，驱动蜂鸣器是常见的任务之一，特别是在微控制器编程中。STC89C51是一款广泛应用的8位单片机，属于51系列，它具有丰富的I/O端口，非常适合用于控制外部设备，如蜂鸣器。本篇文章将详细探讨如何使用...
51单片机驱动无源蜂鸣器
08-09
本篇文章主要探讨如何使用51单片机驱动无源蜂鸣器，以实现特定的音频输出功能。无源蜂鸣器不同于有源蜂鸣器，它需要外部提供振荡信号才能工作。在给定的例题中，任务是控制8个发光二极管按照设定的时间间隔流动，并...
8550驱动蜂鸣器电路图分析
07-16
而8550最大可提供1A的输出电流，足以驱动蜂鸣器。所以，我们用GPIO口来控制8550的导通与截止，从而来控制蜂鸣器。 当向P0.7写入逻辑1时，P0.7输出高电平（+3.3V），8550的基极电流为0，此时Q1处于截止状态，电源不...
单片机驱动蜂鸣器原理与设计
08-04
本实验例程就实现倒车警示功能，通过实验板上的蜂鸣器发出警示音，同时通过实验板上P1.2和P1.5上的两个黄色发光二极管来发出黄色警示灯。 3、“叮咚”电子门铃实验程序 常见的家用电子门铃在有客人来访时候，如果...
单片机学习之蜂鸣器驱动
01-20
从而发出声音，要用单片机控制蜂鸣器发出不同频率的声音，采用无源的蜂鸣器，如果用有源蜂鸣器，可以会因为二种不同频率声音（有源蜂鸣器本身固有发音频率与单片机驱动频率）互相叠加，造成效果混乱、发音不清。...
贸易常见付款方式D/P，D/A，T/T，L/C
王小磊
07-23 511
D/P付款交单代收行必须在进口商付清货款后，才可将商业单据交给进口方D/ADocumentsagainstAcceptance承兑交单出口人的交单以进口人在汇票上承兑为条件，一般承兑时会注明具体付款的日期T/T电汇汇出行应汇款人申请，拍发加押电报给在另一国家的分行或代理行（即汇入行），指示解付一定金额给收款人L/C信用证银行根据进口人（买方）的请求，开给出口人（卖方）的一种保证承担支付货款责任的书面凭证。
b050闲置图书分享-springboot+vue+elementui.zip（可运行源码+sql文件+文档）
07-23
本次开发的闲置图书分享平台实现了收货地址管理、字典管理、公告管理、留言板管理、图书管理、图书收藏管理、图书评价管理、图书订单管理、用户管理、管理员管理等功能。系统用到了关系型数据库中王者MySql作为系统的数据库，有效的对数据进行安全的存储，有效的备份，对数据可靠性方面得到了保证。并且程序也具备程序需求的所有功能，使得操作性还是安全性都大大提高，让闲置图书分享平台更能从理念走到现实，确确实实的让人们提升信息处理效率。 管理图书的数据，此页面主要实现图书的增加、修改、删除、查看的功能。公告信息管理页面提供的功能操作有：新增公告，修改公告，删除公告操作。公告类型管理页面显示所有公告类型，在此页面既可以让管理员添加新的公告信息类型，也能对已有的公告类型信息执行编辑更新，失效的公告类型信息也能让管理员快速删除。
《大学生职业生涯规划与就业指导》大一阶段课程作业
最新发布
07-24
《大学生职业生涯规划与就业指导》大一阶段课程作业
开题报告潮汕特产直销系统 已通过开题答辩的.doc
07-23
随着互联网的高速发展，人们的生活方式发生了翻天覆地的变化，在过去，人们想要购买很远地方的东西会非常麻烦，因为是通信和交通都不是十分的方便，而现在网络购物成为了人们日常生活中不可或缺的一部分。在这样的背景下，互联网与传统行业的融合已经成为了一种不可阻挡的趋势。对于中国特色的潮汕特产来说，这一趋势也带来了巨大的变革和发展机遇[1]。
Python性能优化：掌握性能分析工具的实战指南
07-23
Python是一种广泛使用的高级编程语言，由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年。Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进来区分代码块，而不是使用大括号或关键词）。这使得Python被认为是一种易于学习的语言，同时具备强大的功能，适合初学者和经验丰富的程序员。 Python的主要特点包括： 1. **易于学习**：Python有相对较少的关键字，结构简单，和一个明确定义的语法。 2. **易于阅读**：Python代码定义的清晰度使得它像可执行伪代码。 3. **易于维护**：Python的成功在于它的源代码是相当容易维护的。 4. **广泛的标准库**：Python的标凑库很庞大，包含用于互联网通信、网络通信、数据压缩、加密、系统管理等的模块。 5. **跨平台**：Python可以在多种操作系统上运行，包括但不限于Windows、Mac OS X、Linux等。 6. **解释型语言**：Python是一种解释型语言，这意味着开发过程中没有编译步骤。 7. **动态类型系统**：Python不会在编写
Android学习系列之gradle实战
07-23
Android学习系列之gradle实战
RFC 3261中文版技术文档
07-23
**标题与描述解析** 标题"RFC 3261 中文文档"指的是互联网请求评论（Request for Comments）3261的中文版本。RFC 3261是互联网工程任务组（IETF）发布的一个重要标准，它定义了SIP（Session Initiation Protocol，会话初始协议）的核心规范。SIP是一种用于建立、修改和终止多媒体通信会话的协议，广泛应用于VoIP（Voice over IP，IP语音）和统一通信系统中。 描述同样简洁明了，只强调了这是RFC 3261的中文翻译，意味着对于中文读者来说，这个文档提供了一个理解SIP协议的中文语言资源。 **标签解析** "RFC3261 中文"标签进一步确认了文档的内容，表明这是关于RFC 3261的中文资料，便于搜索和分类。 **压缩包子文件的文件名称列表** 文件名为"RFC3261 中文.mht"，这是一个单一网页文件，通常包含HTML、图像和其他资源，用于保存完整的网页内容。用户可以通过打开这个文件来查看RFC 3261的中文翻译。 **SIP协议详述** SIP协议是基于文本的，其设计类似于HTTP
嵌入式LinuxC语言程序设计基础教程第8章函数解读.doc
07-23
嵌入式
DirectShow滤镜：字幕叠加功能（含注解说明）
07-23
DirectShow Transform Filter最典型的例子，带注释，难度不大，学习必备 博客对应文章http://blog.csdn.net/leixiaohua1020/article/details/12498975。内容来源于网络分享，如有侵权请联系我删除。另外如果没有积分的同学需要下载，请私信我。
b069牙科就诊管理系统-springboot+vue+elementui.zip（可运行源码+sql文件+文档）
07-23
牙科就诊管理系统利用当下成熟完善的SSM框架，使用跨平台的可开发大型商业网站的Java语言，以及最受欢迎的RDBMS应用软件之一的Mysql数据库进行程序开发。实现了用户在线查看数据。管理员管理病例管理、字典管理、公告管理、药单管理、药品管理、药品收藏管理、药品评价管理、药品订单管理、牙医管理、牙医收藏管理、牙医评价管理、牙医挂号管理、用户管理、管理员管理等功能。牙科就诊管理系统的开发根据操作人员需要设计的界面简洁美观，在功能模块布局上跟同类型网站保持一致，程序在实现基本要求功能时，也为数据信息面临的安全问题提供了一些实用的解决方案。可以说该程序在帮助管理者高效率地处理工作事务的同时，也实现了数据信息的整体化，规范化与自动化。 管理员在后台主要管理病例管理、字典管理、公告管理、药单管理、药品管理、药品收藏管理、药品评价管理、药品订单管理、牙医管理、牙医收藏管理、牙医评价管理、牙医挂号管理、用户管理、管理员管理等。 牙医列表页面，此页面提供给管理员的功能有：查看牙医、新增牙医、修改牙医、删除牙医等。公告信息管理页面提供的功能操作有：新增公告，修改公告，删除公告操作。公告类型管理页面显示所有公告类型，在此页面既可以让管理员添加新的公告信息类型，也能对已有的公告类型信息执行编辑更新，失效的公告类型信息也能让管理员快速删除。药品管理页面，此页面提供给管理员的功能有：新增药品,修改药品,删除药品。药品类型管理页面，此页面提供给管理员的功能有：新增药品类型,修改药品类型,删除药品类型。
2014年4月-2023年11月上市公司ESG数据（秩鼎）（月度数据）.xlsx
07-23
2014年4月-2023年上市公司秩鼎ESG评级数据 1、时间：2014年4月-2023年11月 2、来源:秩鼎数据 3、指标：证券代码、SC、评级日期、ESG评级、ESG等级、ESG得分、E评级、E等级、E得分、S评级、S等级、S得分、G评级、G等级、G得分、总市值(亿元)、流通市值(亿元)、市盈率(TTM)、ESG标准正态、E标准正态、S标准正态、G标准正态、三者标准差、证券简称、 4、范围：上市公司
Sequator执行文件
07-23
Sequator.exe。内容来源于网络分享，如有侵权请联系我删除。另外如果没有积分的同学需要下载，请私信我。
wireless.sh执行脚本
07-23
openwrt执行脚本配置网络
本文利用随机森林模型对房价数据进行预处理， 基于 XGBoost对房价进行预测；通过对比实验，发现优化后的 XGBoost模型在
07-23
1.本文首先对数据集进行了特征工程，根据相关性对部分特征进行了剔除。 其他的特征工程还包括分类变量的编码方式的探讨以及对连续变量的标准化。 2.随后对数据集做进一步处理，连续变量的缺失值以平均值填充，并进行标 准化；分类变量的缺失值以出现最多的类别等方式进行填充，使用 Ordinal Encoder 进行编码。使用 Random Forest Regressor 进行特征选择，输出特征重要 性，为 XGBoost模型的训练做准备。 3.使用 XGBoost 进行预测，数据选择之前使用随机森林输出的特征重要性的 前 30 作为特征变量；最后将问题转换为分类问题，预测房价的高和低。 本文做的比较好的方面在于对于过多的特征采取了使用随机森林模型进行 筛选，这使得后续使用 XGBoost 时训练时间大幅减小。在实际训练当中，使用 随机森林的效果明显好于 XGBoost，这是本文的一个缺陷。另一方面，直接将回 归任务转化为分类任务意义不大，如何评定该地的房价是高还是低是一件比较主 观的事情，不同的划分标准对于模型的表现具有很大的影响。
风扇蜂鸣器PWM工作原理
10-10
风扇蜂鸣器的PWM（脉宽调制）工作原理是通过改变信号的高电平和低电平持续时间的比例来控制设备的输出功率。PWM信号是一个周期性的方波信号，其中高电平部分代表工作时间，低电平部分代表空闲时间。 在风扇中使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值