驱动作业 2 ioctl

最新推荐文章于 2024-09-09 10:52:37 发布
最新推荐文章于 2024-09-09 10:52:37 发布
阅读量134 收藏
点赞数
文章标签： 开发语言 arm开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/clqm123456/article/details/131925817
版权

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 PHY_LED1_ADDR 0X50006000
#define PHY_LED2_ADDR 0X50007000
#define PHY_LED3_ADDR 0X50006000
#define PHY_RCC_ADDR  0X50000A28
#define PHY_BEEP_ADDR 0x50003000
#define PHY_HOUSE_ADDR 0x50007000
#define PHY_FAN_ADDR 0x50006000

//功能码
//LED
#define LED_ON _IOW('l',1,int)
#define LED_OFF _IOW('l',0,int)
//house
#define HOUSE_ON _IO('h',1)
#define HOUSE_OFF _IO('h',0)
//beep
#define BEEP_ON _IO('b',1)
#define BEEP_OFF _IO('b',0)
//fan
#define FAN_ON _IO('f',1)
#define FAN_OFF _IO('f',0)
#endif

beep_driver

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

int beep_major;


gpio_t *vir_beep;

unsigned int *vir_rcc;


struct class *beep_cls;
struct device *beep_dev;


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 BEEP_ON:
            vir_beep->ODR |= (0x1 << 6);
            break;
    case BEEP_OFF:
            vir_beep->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 beep_init(void) //PB6
{
    vir_beep = ioremap(PHY_BEEP_ADDR,sizeof(gpio_t));
    if (vir_beep == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    //寄存器初始化
    vir_beep->MODER &= (~(3 << 12));
    vir_beep->MODER |= (1 << 12);
    vir_beep->ODR &= (~(1 << 6));
    printk("蜂鸣器初始化完成\n");
    return 1;
}
 

int register_dev(char *name)
{
    int major;
    major = register_chrdev(0, name, &fops);
    if (major < 0)
    {
        printk("%s设备驱动注册失败\n",name);
        return major;
    }
    printk("%s设备驱动注册成功:%s_major=%d\n",name,name,major);
    return major;
}

struct class* class_t(char* name)
{
    struct class* cls;
    // 向上提交目录
    cls = class_create(THIS_MODULE, name);
    if (IS_ERR(cls))
    {
        printk("向上提交%s目录失败\n",name);
        return NULL;
    }
    printk("向上提交%s目录信息成功\n",name);
    return cls;
}
static int __init mycdev_init(void)
{
    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);
    (*vir_rcc) |= (0x1 << 1);
    // 字符设备驱动注册
    beep_major=register_dev("beep");

    //上交目录
    beep_cls=class_t("mybeep");

    // 向上提交设备节点信息
    beep_dev = device_create(beep_cls, NULL, MKDEV(beep_major, 0), NULL, "mybeep0");
    if (IS_ERR(beep_dev))
    {
        printk("向上提交设备节点信息失败\n");
        return -PTR_ERR(beep_dev);
    }
    printk("向上提交设备节点成功\n");
    // 寄存器映射以及初始化
    beep_init();

    return 0;
}
static void __exit mycdev_exit(void)
{
    // 取消地址映射
    iounmap(vir_rcc);
    //销毁节点信息

    // 注销字符设备驱动
    unregister_chrdev(beep_major, "beep");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

led.c

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

int led_major;

char kbuf[128] = {0};
gpio_t *vir_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;

unsigned int *vir_rcc;
struct class *led_cls;
struct device *led_dev;

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 LED_ON:
        switch (arg)
        {
        case 1:                           // LED1
            vir_led1->ODR |= (0x1 << 10); // LED1开灯
            break;
        case 2:                           // LED2
            vir_led2->ODR |= (0x1 << 10); // LED2开灯
            break;
        case 3:                          // LED3
            vir_led3->ODR |= (0x1 << 8); // LED3开灯
            break;
        }
        break;
    case LED_OFF:
        switch (arg)
        {
        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)
{
    // led寄存器地址的映射
    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);
    (*vir_rcc) |= (0x1 << 2);
    // 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;
}

int register_dev(char *name)
{
    int major;
    major = register_chrdev(0, name, &fops);
    if (major < 0)
    {
        printk("%s设备驱动注册失败\n",name);
        return major;
    }
    printk("%s设备驱动注册成功:%s_major=%d\n",name,name,major);
    return major;
}

struct class* class_t(char* name)
{
    struct class* cls;
    // 向上提交目录
    cls = class_create(THIS_MODULE, name);
    if (IS_ERR(cls))
    {
        printk("向上提交%s目录失败\n",name);
        return NULL;
    }
    printk("向上提交%s目录信息成功\n",name);
    return cls;
}
static int __init mycdev_init(void)
{
    // 字符设备驱动注册
    led_major=register_dev("led");
    //上交目录
    led_cls=class_t("myled");
    // 向上提交设备节点信息
    led_dev = device_create(led_cls, NULL, MKDEV(led_major, 0), NULL, "myled0");
    if (IS_ERR(led_dev))
    {
        printk("向上提交设备节点信息失败\n");
        return -PTR_ERR(led_dev);
    }
    printk("向上提交设备节点成功\n");
    // 寄存器映射以及初始化
    all_led_init();
    return 0;
}
static void __exit mycdev_exit(void)
{
    // 取消地址映射
    iounmap(vir_led1);
    iounmap(vir_led2);
    iounmap(vir_rcc);
    //销毁节点信息

    // 注销字符设备驱动
    unregister_chrdev(led_major, "led");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

fan_driver

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

int fan_major;


char kbuf[128] = {0};
gpio_t *vir_fan;

unsigned int *vir_rcc;

struct class *fan_cls;
struct device *fan_dev;


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 fan_init(void) //PE9
{
    vir_fan = ioremap(PHY_FAN_ADDR,sizeof(gpio_t));
    if (vir_fan == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    vir_fan->MODER &= (~(3 << 18));
    vir_fan->MODER |= (1 << 18);
    vir_fan->ODR &= (~(1 << 9));
    printk("风扇初始化完成\n");
    return 1;
}


int register_dev(char *name)
{
    int major;
    major = register_chrdev(0, name, &fops);
    if (major < 0)
    {
        printk("%s设备驱动注册失败\n",name);
        return major;
    }
    printk("%s设备驱动注册成功:%s_major=%d\n",name,name,major);
    return major;
}

struct class* class_t(char* name)
{
    struct class* cls;
    // 向上提交目录
    cls = class_create(THIS_MODULE, name);
    if (IS_ERR(cls))
    {
        printk("向上提交%s目录失败\n",name);
        return NULL;
    }
    printk("向上提交%s目录信息成功\n",name);
    return cls;
}
static int __init mycdev_init(void)
{
    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);
    (*vir_rcc) |= (0x1 << 2);
    // 字符设备驱动注册
    fan_major=register_dev("fan");

    //上交目录
    fan_cls=class_t("myfan");

    // 向上提交设备节点信息
    fan_dev = device_create(fan_cls, NULL, MKDEV(fan_major, 0), NULL, "myfan0");
    if (IS_ERR(fan_dev))
    {
        printk("向上提交设备节点信息失败\n");
        return -PTR_ERR(fan_dev);
    }
    printk("向上提交设备节点成功\n");
    // 寄存器映射以及初始化
    fan_init();
    return 0;
}
static void __exit mycdev_exit(void)
{
    // 取消地址映射
    iounmap(vir_rcc);
    //销毁节点信息

    // 注销字符设备驱动
    unregister_chrdev(fan_major, "fan");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

horse_driver

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

int house_major;

char kbuf[128] = {0};
gpio_t *vir_house;

unsigned int *vir_rcc;
struct class *house_cls;
struct device *house_dev;

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 HOUSE_ON:
            vir_house->ODR |= (0x1 << 6);
            break;
    case HOUSE_OFF:
            vir_house->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 house_init(void) //PF6
{
    vir_house = ioremap(PHY_HOUSE_ADDR,sizeof(gpio_t));
    if (vir_house == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    vir_house->MODER &= (~(3 << 12));
    vir_house->MODER |= (1 << 12);
    vir_house->ODR &= (~(1 << 6));
    printk("马达初始化完成\n");
    return 1;
}


int register_dev(char *name)
{
    int major;
    major = register_chrdev(0, name, &fops);
    if (major < 0)
    {
        printk("%s设备驱动注册失败\n",name);
        return major;
    }
    printk("%s设备驱动注册成功:%s_major=%d\n",name,name,major);
    return major;
}

struct class* class_t(char* name)
{
    struct class* cls;
    // 向上提交目录
    cls = class_create(THIS_MODULE, name);
    if (IS_ERR(cls))
    {
        printk("向上提交%s目录失败\n",name);
        return NULL;
    }
    printk("向上提交%s目录信息成功\n",name);
    return cls;
}

static int __init mycdev_init(void)
{
    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);
    (*vir_rcc) |= (0x1 << 2);
    // 字符设备驱动注册
    house_major=register_dev("house");

    //上交目录
    house_cls=class_t("myhouse");

    // 向上提交设备节点信息
    
    house_dev = device_create(house_cls, NULL, MKDEV(house_major, 0), NULL, "myhouse0");
    if (IS_ERR(house_dev))
    {
        printk("向上提交设备节点信息失败\n");
        return -PTR_ERR(house_dev);
    }
    printk("向上提交设备节点成功\n");
    // 寄存器映射以及初始化
    house_init();
    return 0;
}
static void __exit mycdev_exit(void)
{
    // 取消地址映射
    iounmap(vir_rcc);
    //销毁节点信息

    // 注销字符设备驱动
    unregister_chrdev(house_major, "house");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

main.c

#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;
    int b;
    int fd_led=open("/dev/myled0",O_RDWR);
    int fd_beep=open("/dev/mybeep0",O_RDWR);
    int fd_fan=open("/dev/myfan0",O_RDWR);
    int fd_house=open("/dev/myhouse0",O_RDWR);
    int choose;
    while(1)
    {
        printf("请输入选择的设备 LED->1 BEEP->2 FAN->3 HOSUE->4\n");
        scanf("%d",&choose);
        switch(choose)
        {
            case 1:
                    printf("请输入指令\n");
                    printf("0(关灯) 1(开灯)\n");
                    printf("请输入>");
                    scanf("%d",&a);
                    printf("请选择哪个灯\n");
                    scanf("%d",&b);
                    switch(a)
                    {
                        case 1:
                            ioctl(fd_led,LED_ON,b);//开灯
                            break;
                        case 0:
                            ioctl(fd_led,LED_OFF,b);
                            break;
                    }
                    break;
            case 2:
                    printf("请输入指令 0 叫 1 不叫\n");
                    scanf("%d",&a);
                    switch(a)
                    {
                        case 0:
                            ioctl(fd_beep,BEEP_ON);
                            break;
                        case 1:
                            ioctl(fd_beep,BEEP_OFF);
                            break;
                    }
                    break;
            case 3:
                    printf("请输入指令 0 转 1 不转\n");
                    scanf("%d",&a);
                    switch(a)
                    {
                        case 0:
                            ioctl(fd_fan,FAN_ON);
                            break;
                        case 1:
                            ioctl(fd_fan,FAN_OFF);
                            break;
                    }
                    break;
            case 4:
                    printf("请输入指令 0 震动 1 不震\n");
                    scanf("%d",&a);
                    switch(a)
                    {
                        case 0:
                            ioctl(fd_house,HOUSE_ON);
                            break;
                        case 1:
                            ioctl(fd_house,HOUSE_OFF);
                            break;
                    }
                    break;
        }
    }
    close(fd_led);
    close(fd_beep);
    close(fd_fan);
    close(fd_house);

    return 0;
}

clqm123456
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
驱动调度实验
07-07
设备驱动接口（如Linux的ioctl函数）是应用程序与驱动程序交互的桥梁。 7. **中断驱动I/O和DMA（直接存储器访问）**：中断驱动I/O由硬件中断触发，减轻CPU负担；DMA允许设备直接与内存交换数据，无需CPU参与，提高...
WinCE5.0打印机驱动
05-07
2. IRQL（Interrupt Request Level）：驱动程序必须管理中断请求级别，确保在正确的时间处理中断，以保持系统的稳定性和响应性。 3. IOCTL（Input/Output Control）：这是驱动程序与应用程序通信的主要方式。应用...
DAY15. WDT实验作业
08-08
2. **设置超时时间**： - 在设置完频率后，你需要设置 WDT 的超时时间。在这个实验中，目标是 5 秒，所以需要将这个时间转换为 WDT 能理解的单位（如秒或其倍数）。 - 同样通过 `ioctl` 调用设置超时时间，使用...
DAY16. 轮询与中断作业
08-16
轮询与中断作业"这个主题中，我们将深入探讨这两种方法，并结合实际例子——通过轮询检测Key3按键状态来控制LED2的亮灭，来理解它们的工作原理。 首先，轮询（Polling）是一种主动检查硬件状态的方法。在我们的...
2015西电嵌入式大作业题目
03-14
### 2015西电嵌入式大作业题目解析 #### 1. JTAG接口在嵌入式开发中的作用 JTAG（Joint Test Action Group）接口是一种国际标准测试协议，主要用于芯片内部测试及对系统中安装的集成电路进行测试。在嵌入式系统...
一个php快速项目搭建框架源码，带一键CURD等功能
jiyc2008的博客
08-26 6689
框架易于功能扩展，代码维护，方便二次开发，帮助开发者简单高效降低二次开发成本，满足专注业务深度开发的需求。百度网盘下载。
嵌入式24千兆电口+4万兆光口管理型三层交换机RTL9301模块
QQ42142951的专栏
09-04 1242
支持 AAA（认证、授权、计费），支持RADIUS协议、TACASC+;支持 CLI（Telnet、SSH V1/V2、本地串口）;嵌入式RTL9301模块可以支持4口万兆上联+24口千兆三层管理型以太网交换机，也就是最多可以提供24个10/100/1000自适应电口、4个10 Gb SFP +端口、1个console口、1个USB串口。支持端口速率、双工、流控、最大帧长配置;支持多实例、支持聚合接口;IPv6:支持 IPv6 Ping、IPv6 Traceroute、IPv6 Telnet;
【ARM compiler】生成ELF文件中包含了那些内容
Emdoorelec的博客
09-09 782
用于了解ARM compiler生成的ELF文件中存储的内容进行了解
ARM----时钟
mutou8541的博客
09-06 708
时钟频率可以是由晶振提供的，我们需要高频率，但是外部接高的晶振会不稳定，所有使用PLL（锁相环）来放大频率。其实在配置的时候我们要先配置HCLK .PCLK，因为先配置FCLK的时候，频率太高，会烧坏后面的电路，所以先配置好分频，在区配置主频。外部晶振提供12M频率，由MPLL来进行放大，具有放大多少怎么配置，由PDIV、MDIV、SDIV，来决定。6.由FCLK的大小来查手册看MDIV ,PDIV, SDIV的值（用来配置FCLK的大小）这是手册上面，通过OM2和OM3的引脚的电位来设置时钟源。
ARM微处理器编程模型与linux驱动开发
m0_61229395的博客
09-04 3087
它是一个独立的黑盒子，使某个特定的 硬件可以响应一个定义良好的内部编程接口，同时完成隐藏设备的工作。在顶层的Makefile会读取config文件(默认的是.config), 根据.config文件的配置选项编译内核，顶层Makefile会递归的遍历每一个子目录下的Makefile文件(编译各个目录下的的目标文件)抢占优先级的级别高于响应优先级。0：用户模式，1：快速中断模式，2：中断模式，3：管理模式，4：中止模式，5：未定义模式，6：系统模式，7：Monnitor模式，8：hypervisor模式。
ARM编程模型、指令集、ARM汇编语言程序设计
y123344778899的博客
09-03 603
在之后的演示当中，我们大多数将采用ARM指令集。
秒达开源多功能中文工具箱源码：自部署 全开源 轻量级跨平台 GPT级支持+高效UI+Docker
最新发布
09-09
【秒达开源】多功能中文工具箱源码发布：自部署、全开源、轻量级跨平台，GPT级支持+高效UI，Docker/便携版任选，桌面友好+丰富插件生态 这是一款集大成之作，专为追求高效与便捷的用户量身打造。它不仅支持完全自部署，还实现了彻底的开源，确保每一位开发者都能深入了解其内核，自由定制与扩展。 【秒达开源工具箱】以其轻量级的架构设计，实现了在各类设备上的流畅运行，包括ARMv8架构在内的全平台支持，让您无论身处何地，都能享受到同样的便捷体验。我们深知用户需求的多样性，因此特别引入了类似GPT的智能支持功能，让您的操作更加智能、高效。 与此同时，我们注重用户体验，将高效UI与工具箱功能高度集成，使得界面简洁直观，操作流畅自然。为了满足不同用户的部署需求，我们还提供了Docker映像和便携式版本，让您可以根据实际情况灵活选择。 值得一提的是，我们的工具箱还支持桌面版应用，让您在PC端也能享受到同样的强大功能。此外，我们还建立了丰富的开源插件库，不断扩展工具箱的功能边界，让您的工具箱永远保持最新、最全。 【秒达开源】多功能中文工具箱，作为一款永远的自由软件，我们承诺将持续更新、优化，为
双极 AMI 的加扰以及 B8ZS 和 HDB3 加扰simulink.rar
09-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。
C项目开发资源.docx
09-09
对于C/C++项目开发，有许多资源和工具可以帮助开发者提高效率、保证代码质量以及实现项目的自动化构建和部署。以下是一些具体的资源和工具： 1. **集成开发环境(IDE)**: - **CLion**: 专为C和C++开发设计的跨平台IDE，提供了代码分析、调试、版本控制集成等功能。 - **Eclipse CDT**: 基于Eclipse的C/C++开发工具，支持代码补全、调试和项目管理。 - **Visual Studio**: Windows平台上功能强大的IDE，提供了丰富的C++开发支持。 - **Code::Blocks**: 开源的C/C++ IDE，体积小且可定制。 - **KDevelop**: 另一个功能丰富的开源IDE，主要针对Linux平台。 2. **代码编辑器**: - **Visual Studio Code**: 通过C/C++扩展插件，如C/C++插件包，提供智能感知、代码调试等功能。 - **Sublime Text**: 轻量级的文本编辑器，支持大量插件，包括C/C++编译和语法高亮。 3. **编译
基于ssm的在线购物系统的设计与实现设计与实现.docx
09-09
基于ssm的在线购物系统的设计与实现设计与实现.docx
python-对Excel数据处理做可视化分析.zip
09-09
灵敏度分析
logisim-hust-20200118.zip
09-09
logisim-hust-20200118.zip
springboot小说阅读平台的设计毕业论文.docx
09-09
springboot小说阅读平台的设计毕业论文.docx
混合动力汽车动态规划算法理论油耗计算与视频教学，使用matlab编写快速计算程序，整个工程结构模块化，可以快速改为串联，并联，混
09-09
混合动力汽车动态规划算法理论油耗计算与视频教学，使用matlab编写快速计算程序，整个工程结构模块化，可以快速改为串联，并联，混联等。 控制量可以快速扩展为档位，转矩，转速等。 状态量一般为SOC，目标函数可设置为油耗，电耗，以及换挡频次等加权。 程序清晰易调，输出结果定量统计和图表详尽。 DP为混合动力汽车燃油经济性提供了一种极限油耗的方法，利用DP能够得到特定构型在特定工况条件下的极限油耗，为基于规则的控制策略制定和不同规则的制定提供了理论参考和对比指标。 可提供技术指导支持。 DP动态规划初始化文件利用结构体定义各个部件参数，例如发动机，发电机，电机，变速箱，工况，减速器，电池等部件。 能够方便的修改不同部件参数，进行定制开发。 DP动态规划结果后处理程序，绘制多个控制量，状态量等分析图。 另外还绘制发动机工作点，发动机工作时间MAP等。 不同工作模式的电机工作点。 出图丰富，可直接用于lunwen出版。 录制串联动态规划算法理论讲解与代码分析教学视频，方便快速学习与程序理解。 可提供串联，并联（包括P2和P4），混联等构型动态规划程序。
V4L2驱动开发指南
V4L2驱动会处理特定的ioctl命令，例如设置视频格式、配置输入输出等。开发者需要定义并实现这些命令的处理函数。 四、输入和输出 这部分介绍了如何处理视频输入和输出，包括视频标准（如PAL、NTSC）的设置，以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值