驱动开发——day3

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

test.c

#include "head.h"
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main(int argc, char const* argv[])
{
    int fd, beepfd, fanfd, motorfd;
    int a;
    int n;
    int f;
    char buf[128] = { 0 };
    // 打开LED
    fd = open("/dev/mychrdev0", O_RDWR);
    if (fd < 0) {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    beepfd = open("/dev/mychrdev3", O_RDWR);
    if (beepfd < 0) {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    fanfd = open("/dev/mychrdev4", O_RDWR);
    if (fanfd < 0) {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    motorfd = open("/dev/mychrdev4", O_RDWR);
    if (motorfd < 0) {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    while (1) {
        printf("请选择要控制的硬件\n");
        printf("0(LED灯) 1(蜂鸣器) 2(马达) 3(风扇)");
        scanf("%d", &a);
        switch (a) {
        case 0: // LED灯
            printf("请选择要实现的功能\n");
            printf("0(关灯) 1(开灯)");
            scanf("%d", &f);
            printf("请选择要控制的LED灯\n");
            printf("1(LED1) 2(LED2) 3(LED3)");
            scanf("%d", &n);
            if (f == 1) {
                ioctl(fd, LED_ON, &n);
            } else if (f == 0) {
                ioctl(fd, LED_OFF, &n);
            }
            break;
        case 1: // 蜂鸣器

            printf("请输入要实现的功能\n");
            printf("0(关闭) 1(启动)");
            scanf("%d", &f);
            if (f == 1) {
                ioctl(beepfd, BUZZER_ON);
            } else if (f == 0) {
                ioctl(beepfd, BUZZER_OFF);
            }
            break;
        case 2: // 马达

            printf("请输入要实现的功能\n");
            printf("0(关闭) 1(启动)");
            scanf("%d", &f);
            if (f == 1) {
                ioctl(motorfd, MOTOR_ON);
            } else if (f == 0) {
                ioctl(motorfd, MOTOR_OFF);
            }
            break;
        case 3: // 风扇

            printf("请输入要实现的功能\n");
            printf("0(关闭) 1(启动)");
            scanf("%d", &f);
            if (f == 1) {
                ioctl(fanfd, FAN_ON);
            } else if (f == 0) {
                ioctl(fanfd, FAN_OFF);
            }
            break;
        default:
            break;
        }
    }
    close(fd);
    return 0;
}

mychrdev_led.c:

#include "head.h"
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/uaccess.h>
static int __init mycdev_init(void);
int major; // 用于保存主设备号
char kbuf[128] = { 0 };
gpio_t* led1;
gpio_t* led2;
gpio_t* led3;
gpio_t* buzzer;
unsigned int* 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;
}
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->ODR |= (0x1 << 10);
            break;
        case 2:
            led2->ODR |= (0x1 << 10);
            break;
        case 3:
            led3->ODR |= (0x1 << 8);
            break;
        default:
            break;
        }
        break;
    case LED_OFF: // 关灯
        switch (which) {
        case 1:
            led1->ODR &= (~(0x1 << 10));
            break;
        case 2:
            led2->ODR &= (~(0x1 << 10));
            break;
        case 3:
            led3->ODR &= (~(0x1 << 8));
            break;
        default:
            break;
        }
        break;

    default:
        break;
    }
    return 0;
}
// 定义操作方法结构体变量并完成初始化
struct file_operations fops = {
    .open = mycdev_open,
    .unlocked_ioctl = mycdev_ioctl,
    .release = mycdev_close,
};
int all_led_init(void)
{
    // 映射结构体物理寄存器
    led1 = ioremap(GPIOE, sizeof(gpio_t));
    if (led1 == NULL) {
        printk("led1结构体映射表失败\n");
        return -EFAULT;
    }
    led2 = ioremap(GPIOF, sizeof(gpio_t));
    if (led2 == NULL) {
        printk("led2结构体映射表失败\n");
        return -EFAULT;
    }
    led3 = ioremap(GPIOE, sizeof(gpio_t));
    if (led3 == NULL) {
        printk("led3结构体映射表失败\n");
        return -EFAULT;
    }

    rcc = ioremap(RCC, 4);
    if (rcc == NULL) {
        printk("rcc寄存器地址映射表失败\n");
        return -EFAULT;
    }

    // led1寄存器初始化
    (*rcc) |= (0x1 << 4);
    led1->MODER &= (~(0x3 << 20));
    led1->MODER |= (0x1 << 20);
    led1->ODR &= (~(0x1 << 10));
    // led2初始化
    led2->MODER &= (~(0x3 << 20));
    led2->MODER |= (0x1 << 20);
    led2->ODR &= (~(0x1 << 10));
    // led3初始化
    led3->MODER &= (~(0x3 << 16));
    led3->MODER |= (0x1 << 16);
    led3->ODR &= (~(0x1 << 8));

    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();
    printk("硬件寄存器初始化成功\n");
    return 0;
}
static void __exit mycdev_exit(void)
{
    int i;
    // 取消结构体映射
    iounmap(led1);
    iounmap(led2);
    iounmap(led3);
    iounmap(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");

mychrdev_fan.c

#include "head.h"
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/uaccess.h>
static int __init mycdev_init(void);
int major; // 用于保存主设备号
char kbuf[128] = { 0 };
gpio_t* led1;
gpio_t* led2;
gpio_t* led3;
gpio_t* buzzer;
gpio_t* fan;
unsigned int* 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;
}
long mycdev_ioctl(struct file* file, unsigned int cmd, unsigned long arg)
{

    switch (cmd) {

    case FAN_ON:
        fan->ODR |= (0x1 << 9);
        break;
    case FAN_OFF:
        fan->ODR &= (~(0x1 << 9));

    default:
        break;
    }
    return 0;
}
// 定义操作方法结构体变量并完成初始化
struct file_operations fops = {
    .open = mycdev_open,
    .unlocked_ioctl = mycdev_ioctl,
    .release = mycdev_close,
};
int all_led_init(void)
{
    // 映射结构体物理寄存器

    rcc = ioremap(RCC, 4);
    if (rcc == NULL) {
        printk("rcc寄存器地址映射表失败\n");
        return -EFAULT;
    }

    // 风扇初始化
    (*rcc) |= (0x1 << 4);
    fan = ioremap(GPIOE, sizeof(gpio_t));
    if (fan == NULL) {
        printk("fan结构体映射表失败\n");
        return -EFAULT;
    }
    fan->MODER &= (~(0x3 << 18));
    fan->MODER |= (0x1 << 18);

    return 0;
}
static int __init mycdev_init(void)
{

    major = register_chrdev(0, "mychrdev_fan", &fops);
    if (major < 0) {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "mychrdev4");
    if (IS_ERR(cls)) {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备结点信息
    // 为蜂鸣器创建设备文件

    dev = device_create(cls, NULL, MKDEV(major, 4), NULL, "mychrdev4");
    if (IS_ERR(dev)) {
        printk("向上提交设备结点信息失败\n");
        return -PTR_ERR(dev);
    }

    // 寄存器映射初始化
    all_led_init();
    printk("硬件寄存器初始化成功\n");
    return 0;
}
static void __exit mycdev_exit(void)
{

    // 取消结构体映射
    iounmap(fan);

    iounmap(rcc);
    // 销毁设备结点信息

    device_destroy(cls, MKDEV(major, 4));

    // 销毁目录信息
    class_destroy(cls);
    // 字符设备驱动的注销
    unregister_chrdev(major, "mychrdev");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

mychrdev_buzzer.c

#include "head.h"
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/uaccess.h>
static int __init mycdev_init(void);
int major; // 用于保存主设备号
char kbuf[128] = { 0 };
gpio_t* led1;
gpio_t* led2;
gpio_t* led3;
gpio_t* buzzer;
unsigned int* 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;
}
long mycdev_ioctl(struct file* file, unsigned int cmd, unsigned long arg)
{

    switch (cmd) {

    case BUZZER_ON:
        buzzer->ODR |= (0x1 << 6);
        break;
    case BUZZER_OFF:
        buzzer->ODR &= (~(0x1 << 6));
    default:
        break;
    }
    return 0;
}
// 定义操作方法结构体变量并完成初始化
struct file_operations fops = {
    .open = mycdev_open,
    .unlocked_ioctl = mycdev_ioctl,
    .release = mycdev_close,
};
int all_led_init(void)
{
    // 映射结构体物理寄存器

    rcc = ioremap(RCC, 4);
    if (rcc == NULL) {
        printk("rcc寄存器地址映射表失败\n");
        return -EFAULT;
    }

    // 蜂鸣器初始化
    (*rcc) |= (0x1 << 1);
    buzzer = ioremap(GPIOB, sizeof(gpio_t));
    if (buzzer == NULL) {
        printk("buzzer结构体映射表失败\n");
        return -EFAULT;
    }
    buzzer->MODER &= (~(0x3 << 12));
    buzzer->MODER |= (0x1 << 12);

    return 0;
}
static int __init mycdev_init(void)
{

    major = register_chrdev(0, "mychrdev_buzzer", &fops);
    if (major < 0) {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "mychrdev3");
    if (IS_ERR(cls)) {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备结点信息
    // 为蜂鸣器创建设备文件

    dev = device_create(cls, NULL, MKDEV(major, 3), NULL, "mychrdev3");
    if (IS_ERR(dev)) {
        printk("向上提交设备结点信息失败\n");
        return -PTR_ERR(dev);
    }

    // 寄存器映射初始化
    all_led_init();
    printk("硬件寄存器初始化成功\n");
    return 0;
}
static void __exit mycdev_exit(void)
{

    // 取消结构体映射
    iounmap(buzzer);

    iounmap(rcc);
    // 销毁设备结点信息

    device_destroy(cls, MKDEV(major, 3));

    // 销毁目录信息
    class_destroy(cls);
    // 字符设备驱动的注销
    unregister_chrdev(major, "mychrdev");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

mychrdev_motor.c:

#include "head.h"
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/uaccess.h>
static int __init mycdev_init(void);
int major; // 用于保存主设备号
char kbuf[128] = { 0 };
gpio_t* led1;
gpio_t* led2;
gpio_t* led3;
gpio_t* buzzer;
gpio_t* fan;
gpio_t* motor;
unsigned int* 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;
}
long mycdev_ioctl(struct file* file, unsigned int cmd, unsigned long arg)
{

    switch (cmd) {

    case MOTOR_ON:
        motor->ODR |= (0x1 << 6);
        break;
    case MOTOR_OFF:
        motor->ODR &= (~(0x1 << 6));
        break;
    default:
        break;
    }
    return 0;
}
// 定义操作方法结构体变量并完成初始化
struct file_operations fops = {
    .open = mycdev_open,
    .unlocked_ioctl = mycdev_ioctl,
    .release = mycdev_close,
};
int all_led_init(void)
{
    // 映射结构体物理寄存器

    rcc = ioremap(RCC, 4);
    if (rcc == NULL) {
        printk("rcc寄存器地址映射表失败\n");
        return -EFAULT;
    }

    // 马达初始化
    (*rcc) |= (0x1 << 5);
    motor = ioremap(GPIOF, sizeof(gpio_t));
    if (motor == NULL) {
        printk("motor结构体映射表失败\n");
        return -EFAULT;
    }
    motor->MODER &= (~(0x3 << 12));
    motor->MODER |= (0x1 << 12);

    return 0;
}
static int __init mycdev_init(void)
{

    major = register_chrdev(0, "mychrdev_motor", &fops);
    if (major < 0) {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "mychrdev5");
    if (IS_ERR(cls)) {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备结点信息
    // 为蜂鸣器创建设备文件

    dev = device_create(cls, NULL, MKDEV(major, 5), NULL, "mychrdev5");
    if (IS_ERR(dev)) {
        printk("向上提交设备结点信息失败\n");
        return -PTR_ERR(dev);
    }

    // 寄存器映射初始化
    all_led_init();
    printk("硬件寄存器初始化成功\n");
    return 0;
}
static void __exit mycdev_exit(void)
{

    // 取消结构体映射
    iounmap(motor);

    iounmap(rcc);
    // 销毁设备结点信息

    device_destroy(cls, MKDEV(major, 5));

    // 销毁目录信息
    class_destroy(cls);
    // 字符设备驱动的注销
    unregister_chrdev(major, "mychrdev");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

head.h

#ifndef __HEAD_H__
#define __HEAD_H__
typedef struct {
    volatile unsigned int MODER; // 0x00
    volatile unsigned int OTYPER; // 0x04
    volatile unsigned int OSPEEDR; // 0x08
    volatile unsigned int PUPDR; // 0x0C
    volatile unsigned int IDR; // 0x10
    volatile unsigned int ODR; // 0x14
    volatile unsigned int BSRR; // 0x18
    volatile unsigned int LCKR; // 0x1C
    volatile unsigned int AFRL; // 0x20
    volatile unsigned int AFRH; // 0x24
    volatile unsigned int BRR; // 0x28
    volatile unsigned int res;
    volatile unsigned int SECCFGR; // 0x30

} gpio_t;
#define RCC 0x50000A28 // AHB4

#define GPIOA 0x50002000
#define GPIOB 0x50003000
#define GPIOC 0x50004000
#define GPIOD 0x50005000
#define GPIOE 0x50006000
#define GPIOF 0x50007000
#define GPIOG 0x50008000
#define GPIOH 0x50009000
#define GPIOI 0x5000A000
#define GPIOJ 0x5000B000
#define GPIOK 0x5000C000
#define GPIOZ 0x54004000
#define LED_ON _IO('l', 1)
#define LED_OFF _IO('l', 0)
#define BUZZER_ON _IO('b', 1)
#define BUZZER_OFF _IO('b', 0)
#define FAN_ON _IO('f', 1)
#define FAN_OFF _IO('f', 0)
#define MOTOR_ON _IO('m', 1)
#define MOTOR_OFF _IO('m', 0)
#endif

三只小鸹貔
关注
华清远见嵌入式学习——驱动开发——day9
qq_54502935的博客
02-23 1011
【代码】华清远见嵌入式学习——驱动开发——day9。
day2 驱动开发 c语言
weixin_66726984的博客
07-24 656
这样写会造成无法处理内核页面请求的虚拟地址内部错误，没找到解决方法。
Day1 鸿蒙开发——开发准备
outsider76557的博客
03-06 732
华为鸿蒙DevEco Studio是面向全场景的一站式集成开发环境,，在鸿蒙官网下载或升级操作系统开发工具DevEco Studio最新版本，SDK配置和下载，2.1支持Mac、Windows操作系统。下载完成后，双击下载的“deveco-studio-xxxx.exe”，进入DevEco Studio安装向导。为你提供包括HarmonyOS SDK、DevEco Studio、DevEco Service等开发、调试、测试功能的服务，让开发效率进一步提升，同时享受顺滑的开发体验。
操作系统——day4
m0_57005796的博客
01-28 1409
Linux全景图 Linux内核 Linux的基本思想：一切都是文件，每个文件都有确定的用途，包括用户数据、命令、配置参数、硬件设备。支持多用户，各个用户对于自己的文件有自己特殊的权利，保证各个用户之间相互不影响，Linux可以使多个程序同时并独立地运行 五大重要组件：系统、进程、内存、储存、网络，每个组件分成了许多模块 模块之间的通信，主要是函数调用 Darwin-XNU内核 Darwin使用了微内核和相应的固件来支持不同的处理器平台，并提供操作系统原始的基础服务 它由两套内核组成，Mach层与BSD层，
循环驱动作业——kettle开发34
java程序员的蜕变之路
06-12 1164
我们通过变量传参来完成某个日期的数据转换。但可能因程序或者网络原因导致某个时间段的数据抽取失败。常见导致kettle作业失败的原因大概分为三大类，数据源异常、数据库异常、程序异常。因此面对这些异常时，怎么快速恢复批量数据，就需要利用循环来处理，指定含条件的数据，如恢复2023年1月6日至2023年2月02日的数据等等。
嵌入式Linux驱动开发——RTC实时时钟驱动
weixin_43917518的博客
05-28 1322
RTC实时时钟驱动 RTC实时时钟为操作系统提供一个可靠的时间，并且在断电的情况下，RTC实时时钟也可以通过电池供电，一直运行下去。在计算机系统中，经常会用到RTC实时时钟。例如，手机在关机模式下，仍然能够保证时间的正确性，就是因为RTC实时时钟可以在很小的耗电量下工作。在嵌入式系统中，RTC设备是一种常用的设备，所以学会写RTC实时时钟驱动程序是一件非常重要的工作。 **RTC实时时钟的概念：**RTC的英文全称是Real-Time Clock，一般称为RTC实时时钟。实时时钟（RTC）单元可以在系统电源
嵌入式学习——硬件（Linux内核驱动编程中断、队列、ADC）——day60
qq_47798402的博客
07-05 314
1.按键（中断处理）——混杂设备驱动。3. ADC中断队列——混杂设备驱动。2. 按键队列——混杂设备驱动。
rt-thread rtc设备驱动开发
weixin_42734533的博客
07-19 2330
参考/rt-thread/components/drivers/rtc/下的RTC的设备驱动框架源码，了解RTC设备类封装的函数及相关接口体。综上，针对某一操作，传递至设备框架层的函数能够有效调用驱动层的函数，驱动层的函数调用设备SDK衍生出的函数，进而实现对硬件的操作。同理，从设备驱动框架层到IO设备管理接口层，又是上层对下层的一次抽象。​ 在RT-Thread中，I/O设备管理层和驱动设备框架层已完成封装，若新增设备驱动到I/O设备框架时，一般只需要结合硬件设备提供的SDK对设备驱动层进行驱动开发。
Harmony在线教育app平台开发开发日志——day1
C_J_W_的博客
06-06 541
鸿蒙系统实训打卡
嵌入式学习——硬件（Linux内核驱动编程platform、内核定时器、DS18B20）——day61
qq_47798402的博客
07-06 225
2. 内核定时器驱动——（3秒延时）1. platform驱动框架。1.1 设备device。1.2 驱动driver。
#太原理工大学机器人团队#51单片机20天学习打卡——Day3
01-20
【51单片机基础知识】 51单片机是微控制器的一种，因其内核为Intel的8051而得名，广泛应用于嵌入式...这种自我驱动的学习方式，既锻炼了独立解决问题的能力，也培养了团队协作精神，对于提升整体技术水平非常有益。
JAVA EE NZ2001 ——Day39——java EE学习 通宵达旦，终于弄好了数据库连接的相关总结、作业以及笔记
12-14
在Java EE开发中，数据库连接是至关重要的环节，它允许应用程序与数据库进行交互，执行查询、更新等操作。本文将详细讲解如何在Java中建立数据库连接，并通过示例代码展示如何查询用户表并将数据封装到列表中。我们...
windows驱动开发——锁、死锁、以及同步
dayenglish的专栏
07-02 4734
表格当中描述的是常用的同步机制，这些机制的相关属性以及他们在windows系统下面的实现。
【xilinx-versal】【Petalinux】I2C驱动开发问题记录
最新发布
联系方式：927632640
10-09 59
调试中发现系统起来后无I2C设备。仔细查找后发现没有配置versal的I2C控制器。
FOC电机驱动开发踩坑记录
mengjiexu_cn的博客
09-26 688
2. 低压区域采样，优点是对应器件的电压承受能力要求低，缺点是需要精确控制采样的时间，采样时间必须在H桥的下臂导通时进行采样，否则采样不到正确的电流；常用的无感FOC控制算法有滑膜控制器、龙博格观测器，基本都是靠观测器加锁相环来实现对转子角度位置的估计，但是都会有一些问题，滑膜控制器的问题是可能会出现电机震荡，可以通过调整参数的大小来降低震荡的幅度但一定会有。电机的三相电流采样有3种采样的方法，1种是3相电流全部采样，好处是能采到三相的实时真实电流，缺点是成本是最高的；
Linux驱动开发(速记版)--热插拔
荒野
10-05 736
讯为 RK3568
King3399（ubuntu文件系统）驱动模块编译简明教程
scd
10-03 1020
文章主要介绍King3399（ubuntu文件系统）驱动模块编译过程，涉及交叉编译工具以及驱动模块的加载与卸载
用于去噪幅度dMRI的Matlab工具箱.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
APP报毒全自动处理系统源码
10-09
APP报毒全自动处理系统源码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值