[驱动开发]ioctl函数选择不同硬件的控制

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

ioctl函数选择不同硬件的控制——LED 蜂鸣器 风扇 马达

//用户程序
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include "head.h"

void led_ctrl()
{
	int a,b;
	int fd_led = open("/dev/myled0",O_RDWR);	
	if(fd_led < 0)
	{
		printf("打开设备文件失败\n");
		exit(-1);
	}
	printf("请输入要控制的灯:1 2 3>>");
	scanf("%d",&b);
	printf("输入控制命令:0熄灭 1开灯>>>");
	scanf("%d",&a);
	switch(a)
	{
	case 1:
		ioctl(fd_led,LED_ON,b);
		break;
	case 0:
		ioctl(fd_led,LED_OFF,b);
		break;
	}
	close(fd_led);
}

void bee_ctrl()
{
	int a;
	int fd_bee = open("/dev/bee",O_RDWR);	
	if(fd_bee < 0)
	{
		printf("打开设备文件失败\n");
		exit(-1);
	}
	printf("输入控制命令:0关闭 1开启>>>");
	scanf("%d",&a);
	switch(a)
	{
	case 1:
		ioctl(fd_bee,BEE_ON);
		break;
	case 0:
		ioctl(fd_bee,BEE_OFF);
		break;
	}
	close(fd_bee);
}

void fan_ctrl()
{
	int a;
	int fd_fan = open("/dev/fan",O_RDWR);	
	if(fd_fan < 0)
	{
		printf("打开设备文件失败\n");
		exit(-1);
	}
	printf("输入控制命令:0关闭 1开启>>>");
	scanf("%d",&a);
	switch(a)
	{
	case 1:
		ioctl(fd_fan,FAN_ON);
		break;
	case 0:
		ioctl(fd_fan,FAN_OFF);
		break;
	}
	close(fd_fan);
}
void motor_ctrl()
{
	int a;
	int fd_motor = open("/dev/motor",O_RDWR);	
	if(fd_motor < 0)
	{
		printf("打开设备文件失败\n");
		exit(-1);
	}
	printf("输入控制命令:0关闭 1开启>>>");
	scanf("%d",&a);
	switch(a)
	{
	case 1:
		ioctl(fd_motor,MOTOR_ON);
		break;
	case 0:
		ioctl(fd_motor,MOTOR_OFF);
		break;
	}
	close(fd_motor);
}
int main(int argc, const char *argv[])
{
	int a;
	while(1)
	{
		printf("请输入要控制的设备:1>LED 2>蜂鸣器 3>风扇 4>马达:");
		scanf("%d",&a);
		switch(a)
		{
		case 1:
			led_ctrl();
			break;
		case 2:
			bee_ctrl();
			break;
		case 3:
			fan_ctrl();
			break;
		case 4:
			motor_ctrl();
			break;
		}
	}
	return 0;
	}

//LED驱动程序

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

char kbuf[128]={0};
gpio_t *vir_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;
unsigned int *vir_rcc;
int major_led; //LED主设备号
int major_fan; //风扇主设备号
int major_bee; //蜂鸣器主设备号
int major_motor; //马达主设备号
struct class *cls_led; //创建struct class类型变量
struct class *cls_fan; 
struct class *cls_bee; 
struct class *cls_motor; 

struct device *dev_led;
int i;
/*********************封装操作方法***************************/
int mycdev_open(struct inode *inode, struct file *file)
{
    //printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
ssize_t mycdev_read(struct file *file, char *ubuf, size_t size, loff_t *lof)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
ssize_t mycdev_write(struct file *file, const char *ubuf, size_t size, loff_t *lof)
{
    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:
				vir_led1->ODR|=(0x1<<10);//LED1开灯
				break;
			case 2:
				vir_led2->ODR|=(0x1<<10);//LED2开灯
				break;
			case 3:
				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,
	.read    =  mycdev_read,
	.write   =  mycdev_write,
	.release =  mycdev_close,
	.unlocked_ioctl = mycdev_ioctl,
};

int led_init(void)
{
	//映射物理寄存器
	vir_led1=ioremap(PHY_LED1_ADDR,sizeof(gpio_t));
	if(vir_led1 == NULL)
	{
		printk("vir_led1寄存器地址映射表失败\n");
		return -ENOMEM;
	}
	vir_led2=ioremap(PHY_LED2_ADDR,sizeof(gpio_t));
	if(vir_led2 == NULL)
	{
		printk("vir_led2寄存器地址映射表失败\n");
		return -ENOMEM;
	}
	vir_led3=ioremap(PHY_LED3_ADDR,sizeof(gpio_t));
	if(vir_led3 == NULL)
	{
		printk("vir_led1寄存器地址映射表失败\n");
		return -ENOMEM;
	}
	
	vir_rcc=ioremap(PHY_RCC,4);
	if(vir_rcc==NULL)
	{
		printk("vir_rcc寄存器地址映射表失败\n");
		return -ENOMEM;
	}
	
	printk("寄存器地址映射成功\n");
	
	//寄存器初始化
    (*vir_rcc) |= (0x3 << 4);//rcc使能
    vir_led1->MODER &= (~(0X3 << 20));//设置为输出
    vir_led1->MODER |= (0x1 << 20);
    vir_led1->ODR &= (~(0x1 << 10));//灭灯
    
	vir_led2->MODER &= (~(0X3 << 20));//设置为输出
    vir_led2->MODER |= (0x1 << 20);
    vir_led2->ODR &= (~(0x1 << 10));//灭灯
 
    vir_led3->MODER &= (~(0X3 << 16));//设置为输出
    vir_led3->MODER |= (0x1 << 16);
    vir_led3->ODR &= (~(0x1 << 8));//灭灯

	printk("硬件寄存器初始化成功\n");
	return 0;
}
static int __init mycdev_init(void)
{
	//字符设备驱动注册
	major_led = register_chrdev(0,"mychrdev_led",&fops);
	if(major_led < 0)
	{
		printk("字符设备驱动注册失败\n");
		return major_led;
	}
	printk("字符设备驱动注册成功major=%d\n",major_led);
 
	//向上提交目录
	cls_led=class_create(THIS_MODULE,"myled");
	if(IS_ERR(cls_led))
	{
		printk("向上提交目录失败\n");
		return -PTR_ERR(cls_led);
	}
	printk("向上提交目录成功\n");

	//向上提交设备节点信息

	for(i=0;i<3;i++)
	{
		dev_led=device_create(cls_led,NULL,MKDEV(major_led,i),NULL,"myled%d",i);
		if(IS_ERR(dev_led))
		{
			printk("向上提交设备节点信息失败\n");
			return -PTR_ERR(cls_led);
		}
	}
	printk("向上提交设备节点信息成功\n");

	//初始化led
	led_init();
    
	return 0;
}

static void __exit mycdev_exit(void)
{
	//取消寄存器地址映射
    iounmap(vir_led1);
    iounmap(vir_led2);
    iounmap(vir_led3);
    iounmap(vir_rcc);
	//销毁设备节点信息
	for(i=0;i<3;i++)
	{
		device_destroy(cls_led,MKDEV(major_led,i));
	}
	//销毁目录信息
	class_destroy(cls_led);
	//字符设备驱动注销
	unregister_chrdev(major_led,"mychrdev_led");
	printk("字符设备驱动注销\n");
}
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/device.h>
#include <linux/io.h>
#include "head.h"

char kbuf[128]={0};
gpio_t *vir_bee;
unsigned int *vir_rcc;
int major_bee; //蜂鸣器主设备号
struct class *cls_bee; 
struct device *dev_bee;
int i;
/*********************封装操作方法***************************/
int mycdev_open(struct inode *inode, struct file *file)
{
    //printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
ssize_t mycdev_read(struct file *file, char *ubuf, size_t size, loff_t *lof)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
ssize_t mycdev_write(struct file *file, const char *ubuf, size_t size, loff_t *lof)
{
    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,
	.read    =  mycdev_read,
	.write   =  mycdev_write,
	.release =  mycdev_close,
	.unlocked_ioctl = mycdev_ioctl,
};

int bee_init(void)
{
	//映射物理寄存器
	vir_bee=ioremap(PHY_BEE_ADDR,sizeof(gpio_t));
	if(vir_bee == NULL)
	{
		printk("vir_bee寄存器地址映射表失败\n");
		return -ENOMEM;
	}
	
	vir_rcc=ioremap(PHY_RCC,4);
	if(vir_rcc==NULL)
	{
		printk("vir_rcc寄存器地址映射表失败\n");
		return -ENOMEM;
	}
	
	printk("寄存器地址映射成功\n");
	
	//寄存器初始化
    (*vir_rcc) |= (0x1 << 1);//rcc使能
    vir_bee->MODER &= (~(0X3 << 12));//设置为输出
    vir_bee->MODER |= (0x1 << 12);
    vir_bee->ODR &= (~(0x1 << 6));//蜂鸣器关闭

	printk("硬件寄存器初始化成功\n");
	return 0;
}
static int __init mycdev_init(void)
{
	//字符设备驱动注册
	major_bee = register_chrdev(0,"mychrdev_bee",&fops);
	if(major_bee < 0)
	{
		printk("字符设备驱动注册失败\n");
		return major_bee;
	}
	printk("字符设备驱动注册成功major=%d\n",major_bee);

	//向上提交目录
	cls_bee=class_create(THIS_MODULE,"mybee");
	if(IS_ERR(cls_bee))
	{
		printk("向上提交目录失败\n");
		return -PTR_ERR(cls_bee);
	}
	printk("向上提交目录成功\n");

	//向上提交设备节点信息
	dev_bee=device_create(cls_bee,NULL,MKDEV(major_bee,9),NULL,"bee");
	if(IS_ERR(dev_bee))
	{
		printk("向上提交设备节点信息失败\n");
		return -PTR_ERR(cls_bee);
	}
	printk("向上提交设备节点信息成功\n");

	//初始化bee
	bee_init();

	return 0;
}

static void __exit mycdev_exit(void)
{
	//取消寄存器地址映射
    iounmap(vir_bee);
    iounmap(vir_rcc);
	//销毁设备节点信息
	device_destroy(cls_bee,MKDEV(major_bee,9));
	//销毁目录信息
	class_destroy(cls_bee);
	//字符设备驱动注销
	unregister_chrdev(major_bee,"mychrdev_bee");
	printk("字符设备驱动注销\n");
}
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/device.h>
#include <linux/io.h>
#include "head.h"

char kbuf[128]={0};
gpio_t *vir_fan;
unsigned int *vir_rcc;
int major_fan; //蜂鸣器主设备号
struct class *cls_fan; 
struct device *dev_fan;
int i;
/*********************封装操作方法***************************/
int mycdev_open(struct inode *inode, struct file *file)
{
    //printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
ssize_t mycdev_read(struct file *file, char *ubuf, size_t size, loff_t *lof)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
ssize_t mycdev_write(struct file *file, const char *ubuf, size_t size, loff_t *lof)
{
    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,
	.read    =  mycdev_read,
	.write   =  mycdev_write,
	.release =  mycdev_close,
	.unlocked_ioctl = mycdev_ioctl,
};

int fan_init(void)
{
	//映射物理寄存器
	vir_fan=ioremap(PHY_FAN_ADDR,sizeof(gpio_t));
	if(vir_fan == NULL)
	{
		printk("vir_fan寄存器地址映射表失败\n");
		return -ENOMEM;
	}
	
	vir_rcc=ioremap(PHY_RCC,4);
	if(vir_rcc==NULL)
	{
		printk("vir_rcc寄存器地址映射表失败\n");
		return -ENOMEM;
	}
	
	printk("寄存器地址映射成功\n");
	
	//寄存器初始化
    (*vir_rcc) |= (0x1 << 4);//rcc使能
    vir_fan->MODER &= (~(0X3 << 18));//设置为输出
    vir_fan->MODER |= (0x1 << 18);
    vir_fan->ODR &= (~(0x1 << 9));//蜂鸣器关闭

	printk("硬件寄存器初始化成功\n");
	return 0;
}
static int __init mycdev_init(void)
{
	//字符设备驱动注册
	major_fan = register_chrdev(0,"mychrdev_fan",&fops);
	if(major_fan < 0)
	{
		printk("字符设备驱动注册失败\n");
		return major_fan;
	}
	printk("字符设备驱动注册成功major=%d\n",major_fan);

	//向上提交目录
	cls_fan=class_create(THIS_MODULE,"myfan");
	if(IS_ERR(cls_fan))
	{
		printk("向上提交目录失败\n");
		return -PTR_ERR(cls_fan);
	}
	printk("向上提交目录成功\n");

	//向上提交设备节点信息
	dev_fan=device_create(cls_fan,NULL,MKDEV(major_fan,9),NULL,"fan");
	if(IS_ERR(dev_fan))
	{
		printk("向上提交设备节点信息失败\n");
		return -PTR_ERR(cls_fan);
	}
	printk("向上提交设备节点信息成功\n");

	//初始化fan
	fan_init();

	return 0;
}

static void __exit mycdev_exit(void)
{
	//取消寄存器地址映射
    iounmap(vir_fan);
    iounmap(vir_rcc);
	//销毁设备节点信息
	device_destroy(cls_fan,MKDEV(major_fan,9));
	//销毁目录信息
	class_destroy(cls_fan);
	//字符设备驱动注销
	unregister_chrdev(major_fan,"mychrdev_fan");
	printk("字符设备驱动注销\n");
}
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/device.h>
#include <linux/io.h>
#include "head.h"

char kbuf[128]={0};
gpio_t *vir_motor;
unsigned int *vir_rcc;
int major_motor; //蜂鸣器主设备号
struct class *cls_motor; 
struct device *dev_motor;
int i;
/*********************封装操作方法***************************/
int mycdev_open(struct inode *inode, struct file *file)
{
    //printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
ssize_t mycdev_read(struct file *file, char *ubuf, size_t size, loff_t *lof)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
ssize_t mycdev_write(struct file *file, const char *ubuf, size_t size, loff_t *lof)
{
    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,
	.read    =  mycdev_read,
	.write   =  mycdev_write,
	.release =  mycdev_close,
	.unlocked_ioctl = mycdev_ioctl,
};

int motor_init(void)
{
	//映射物理寄存器
	vir_motor=ioremap(PHY_MOTOR_ADDR,sizeof(gpio_t));
	if(vir_motor == NULL)
	{
		printk("vir_motor寄存器地址映射表失败\n");
		return -ENOMEM;
	}
	
	vir_rcc=ioremap(PHY_RCC,4);
	if(vir_rcc==NULL)
	{
		printk("vir_rcc寄存器地址映射表失败\n");
		return -ENOMEM;
	}
	
	printk("寄存器地址映射成功\n");
	
	//寄存器初始化
    (*vir_rcc) |= (0x1 << 5);//rcc使能
    vir_motor->MODER &= (~(0X3 << 12));//设置为输出
    vir_motor->MODER |= (0x1 << 12);
    vir_motor->ODR &= (~(0x1 << 6));//马达关闭

	printk("硬件寄存器初始化成功\n");
	return 0;
}
static int __init mycdev_init(void)
{
	//字符设备驱动注册
	major_motor = register_chrdev(0,"mychrdev_motor",&fops);
	if(major_motor < 0)
	{
		printk("字符设备驱动注册失败\n");
		return major_motor;
	}
	printk("字符设备驱动注册成功major=%d\n",major_motor);

	//向上提交目录
	cls_motor=class_create(THIS_MODULE,"mymotor");
	if(IS_ERR(cls_motor))
	{
		printk("向上提交目录失败\n");
		return -PTR_ERR(cls_motor);
	}
	printk("向上提交目录成功\n");

	//向上提交设备节点信息
	dev_motor=device_create(cls_motor,NULL,MKDEV(major_motor,9),NULL,"motor");
	if(IS_ERR(dev_motor))
	{
		printk("向上提交设备节点信息失败\n");
		return -PTR_ERR(cls_motor);
	}
	printk("向上提交设备节点信息成功\n");

	//初始化motor
	motor_init();

	return 0;
}

static void __exit mycdev_exit(void)
{
	//取消寄存器地址映射
    iounmap(vir_motor);
    iounmap(vir_rcc);
	//销毁设备节点信息
	device_destroy(cls_motor,MKDEV(major_motor,9));
	//销毁目录信息
	class_destroy(cls_motor);
	//字符设备驱动注销
	unregister_chrdev(major_motor,"mychrdev_motor");
	printk("字符设备驱动注销\n");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

//头文件
#ifndef __HEAD_H__
#define __HEAD_H__

//封装GPIO寄存器
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
}gpio_t;

//宏定义基地址
#define PHY_LED1_ADDR 0x50006000
#define PHY_LED2_ADDR 0x50007000
#define PHY_LED3_ADDR 0x50006000
#define PHY_RCC 0x50000A28

#define PHY_BEE_ADDR 0x50003000
#define PHY_FAN_ADDR 0x50006000
#define PHY_MOTOR_ADDR 0x50007000

//功能码
#define LED_ON _IOW('l',1,int)
#define LED_OFF _IOW('l',0,int)

#define BEE_ON _IO('b',1)
#define BEE_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

Joycenine
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
高级字符驱动(llseek以及ioctl函数)[参考].pdf
10-12
高级字符驱动(llseek和ioctl函数) ...高级字符驱动是设备驱动程序中的重要组件，通过ioctl函数和llseek函数可以实现设备控制操作和文件读写操作。对高级字符驱动的理解和实现是设备驱动程序开发的关键。
IOCTL_Test.rar_IOCTL__USB 驱动开发 3.2_ioctl_ioctl u_usb ioctl
09-24
在IT行业中，USB驱动开发是操作系统与硬件交互的关键部分，特别是在Windows系统中。"IOCTL (Input/Output Control) Test.rar"这个压缩包文件显然包含了关于如何使用IOCTL进行USB驱动开发的相关资料，特别是针对"3.2 ...
Linux设备驱动开发入门
06-08
Linux设备驱动开发是嵌入式系统领域中的一个重要环节，它涉及到操作系统与硬件之间的交互，使得硬件功能能够被操作系统和应用程序有效利用。本课程主要针对Linux系统，深入浅出地介绍了如何进行驱动程序的开发，包括...
Linux驱动开发相关资料
08-27
4. **驱动编程接口**：Linux提供了丰富的驱动开发接口，如ioctl、read、write、open、release等系统调用，以及注册/卸载驱动、设备探测、中断处理等函数。掌握这些接口的使用是驱动开发的关键。 5. **中断处理**：...
IIC.zip_IIC驱动开发_linux iic
09-24
在实际开发过程中，你可能需要熟悉`i2c-dev.h`头文件，这是IIC驱动开发的关键头文件，提供了许多用于驱动开发的宏和函数声明。同时，使用`i2cdetect`工具检测IIC总线上连接的设备，以及`i2cget`和`i2cset`命令进行...
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第三十六章 Linux驱动初探
BeiJingXunWei的博客
07-19 828
Linux设备驱动会以内核模块的形式出现，因为linux内核的整体架构就非常庞大，包含的组件也非常多，如果把所有的功能都编译到linux内核中会使得内核非常臃肿，为了解决这个问题，更方便地新增和删除功能，linux提供了这样的机制，这种机制被称为模块。单片机开发包括：程序设计（PC端软件编程），程序送往执行（将编程好的软件下载到单片机，需要编程器或者下载线），单片机系统的设计（硬件上设计你需要的任务的执行机构，如控制开关，温度检测，红外传输等等，都是根据你的所需，然后在选择对应的硬件器件）。
PCIe驱动开发（4）— DMA驱动编写与测试
qq_38113006的博客
07-15 581
7、核心：可扩展的共享内存数组结构-分块映射表和数组头
编程之道在明明德在亲民在止于至善
07-17 854
可扩展的共享内存数组结构-分块映射表和数组头
9、核心：共享内存的基础结构和动态增长实现（续）
编程之道在明明德在亲民在止于至善
07-18 488
核心：共享内存的基础结构和动态增长实现
ASP外观专利图像检索平台(源代码+论文).rar
07-21
ASP外观专利图像检索平台(源代码+论文)
C++课程设计：电煤气管理系统【源码+文档】
07-21
C++课程设计：电煤气管理系统【源码+文档】 本程序是一个水电气管理信息系统，能够对高校的水电气费用进行管理, 包括了成员的基本信息，如学号、编号、姓名、成员水电气的用量等。程序的用途包括缴纳水电气费、查询一个同学水电气费用量、查看所有同学的缴费情况、增加学生信息、删除学生信息、退出系统等。在设计时也考虑到学生和教师在用水电气时的不同，学生可以免费使用一定额度的水电气，超过这个额度的以后必须付费，且付费部分水电气费的价格要高于教工的收费标准，该措施的实行是为了鼓励同学们节约资源，以免造成不必要的资源浪费。该软件主要是为了学校的管理人员提供便捷，以更快的完成水电气费用的收缴。该软件本着简洁明了，实用稳定为一体进行设计。 系统将实现以下功能： （1）实现对用户信息的录入； （2）实现水电煤气数据的录入； （3）实现计算并查询用户应缴费用，查询未缴纳费用的名单； （4）实现对人员的删除和添加；
ASP+ACCESS网上动态同学录系统（源代码+论文+系统说明+答辩PPT）.rar
07-21
ASP+ACCESS网上动态同学录系统（源代码+论文+系统说明+答辩PPT）
avaloniassification-mas笔记
07-21
avalonia
ASP+ACCESS学生排课管理系统毕业设计(源代码+论文).rar
07-21
ASP+ACCESS学生排课管理系统毕业设计(源代码+论文)
ASP+ACCESS在线教育系统设计(源代码+论文).rar
07-21
ASP+ACCESS在线教育系统设计(源代码+论文)
中国软件杯A8赛题.zip
07-21
【项目资源】：包含前端、后端、移动开发、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源，毕业设计等各种技术项目的源码。包括C++、Java、python、web、C#、EDA等项目的源码。 【适用人群】：适用于希望学习不同技术领域的初学者或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【附加价值】：项目具有较高的学习借鉴价值，也可直接拿来修改复刻。对于有一定基础或热衷于研究的人来说，可以在这些基础代码上进行修改和扩展，实现其他功能。 【沟通交流】：有任何使用上的问题，欢迎随时与博主沟通，博主会及时解答。鼓励下载和使用，并欢迎大家互相学习，共同进步。
配色识色器软件，易语言编写，非常好用
最新发布
07-21
配色识色器软件版本 编写语言：易语言 数据来源：网络 软件功能： 1、识取颜色并同时输出RGB、CMYK、16进制三种值，也可以RGB、CMYK互转； 2、可添加、导入EXCEL文件（XLS文件，配合附件中的导入工具用）的配色方案（表头：见图）； 3、可点选或搜索配色值进行配色。
java毕设&课设-ASP网络商城的设计与实现(源代码+论文).zip
07-21
计算机毕业设计资源包含（项目部署视频+源码+LW+开题报告等等），所有项目经过助教老师跑通，有问题可以私信博主解决，可以免费帮部署。
每日报告回放.pdf
07-21
每日报告回放

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值