驱动demo

已于 2024-04-11 13:52:51 修改
阅读量104 收藏
点赞数
分类专栏： uboot/内核 文章标签： 驱动开发
于 2023-11-09 16:42:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59665492/article/details/134315408
版权

PWM驱动

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/miscdevice.h>
//#include <linux/uaccess.h>
//#include <linux/slab.h> 
#include <linux/pwm.h>


#define PWM_CMD_WRITE		0x01
#define PWM_CMD_READ		0x03
#define PWM_CMD_CLOSE		0x05

#define PWM_PERIOD			100000
#define PWM_MAX_NUM			12

typedef unsigned int		UINT32;
typedef struct hiPWM_DATA_S
{
	UINT32 pwm_chn;
	UINT32 clk_div;
//	UINT32 reload;
   	UINT32  ui_prd;                              ///< Base period, how many PWM clock per period, 2 ~ 255
	UINT32  ui_rise;                             ///< Rising at which clock
	UINT32  ui_fall;                             ///< Falling at which clock	
	UINT32  ui_on_cycle;                   ///< Output cycle, 0 ~ 65535	
	UINT32  ui_inv;    
} PWM_DATA_S;


static int s_pwm_id_list[PWM_MAX_NUM];
static struct pwm_device *s_pwm_dev_list[PWM_MAX_NUM]; 

static int
PWM_Open(struct inode *inode, struct file *filp)
{
	return 0;
}

static int
PWM_Close(struct inode *inode, struct file *filp)
{
	return 0;
}

void PWM_DRV_Write(unsigned long channel, unsigned long base_period, unsigned long rising, unsigned long falling, unsigned long clk_div, unsigned long inv, unsigned long cycle)
{
	int pwm_id = 0;
	static struct pwm_device *pwm_dev; 
	struct pwm_state state;
	
	pwm_id = (int)channel;
	
	if ((pwm_id >= 1) && (pwm_id <= PWM_MAX_NUM) && (-1 == s_pwm_id_list[pwm_id - 1]))
	{
		pwm_dev = pwm_request(pwm_id, "pwm");
		if (IS_ERR(pwm_dev)) 
		{
			printk("申请PWM通道%d失败\n", pwm_id);
			return;
		}
		s_pwm_dev_list[pwm_id - 1] = pwm_dev;
		s_pwm_id_list[pwm_id - 1] = 1;
	}
	else
	{
		pwm_dev = s_pwm_dev_list[pwm_id - 1];
	}
	
	memset(&state, 0, sizeof(state));
	state.period = PWM_PERIOD; //set pwm parameter
	state.duty_cycle = 90000;
	state.polarity = PWM_POLARITY_NORMAL;

	state.enabled = 0;
	pwm_apply_state(pwm_dev, &state); //disable firstly

	if (falling)
	{
		state.enabled = 1;
		pwm_apply_state(pwm_dev, &state); //apply setting
	}
	else
	{
		state.enabled = 0;
		pwm_apply_state(pwm_dev, &state); //apply setting
	}
}

void PWM_DRV_Exit(void)
{
	int i = 0;
	for(i = 0; i < PWM_MAX_NUM;++i)
	{
		if (-1 == s_pwm_id_list[i])
			continue;
		
		pwm_disable(s_pwm_dev_list[i]);
		pwm_free(s_pwm_dev_list[i]);
		s_pwm_id_list[i] = -1;
	}
}

static long
PWM_Ioctl(struct file *filp, unsigned int req, unsigned long arg)
{
	switch (req) 
	{
		case PWM_CMD_WRITE: 
		{
			PWM_DATA_S st_pwm;
			if(copy_from_user(&st_pwm, (PWM_DATA_S __user *)arg, sizeof(PWM_DATA_S)))
			{
				return -EFAULT;
			}
			PWM_DRV_Write(st_pwm.pwm_chn,st_pwm.ui_prd,st_pwm.ui_rise,st_pwm.ui_fall,st_pwm.clk_div,st_pwm.ui_inv,st_pwm.ui_on_cycle);
			break;
		}
		case PWM_CMD_READ: 
		{	
			break;
		}
		case PWM_CMD_CLOSE:
		{
			PWM_DATA_S st_pwm;
			int pwm_id = 0;
			pwm_id = (int)st_pwm.pwm_chn;
			if(copy_from_user(&st_pwm, (PWM_DATA_S __user *)arg, sizeof(PWM_DATA_S)))
			{
				return -EFAULT;
			}	
			if ((pwm_id >= 1) && (pwm_id <= PWM_MAX_NUM) && (1 == s_pwm_id_list[pwm_id - 1]))
			{
				pwm_disable(s_pwm_dev_list[pwm_id - 1]);
				pwm_free(s_pwm_dev_list[pwm_id - 1]);
				s_pwm_id_list[pwm_id - 1] = -1;
		
				s_pwm_id_list[pwm_id - 1] = -1;
			}
			
			break;
		}
		default:
		{
			return -1;
		}
	}
	return 0;
}


static struct file_operations drv_fops = {
	.owner		= THIS_MODULE,
	.open		= PWM_Open,
	.release	= PWM_Close,
	.unlocked_ioctl = PWM_Ioctl,
};

static struct miscdevice misc_dev = {
	.minor	= MISC_DYNAMIC_MINOR,
	.name	= "pwm",
	.fops	= &drv_fops,
};

static int __init my_init(void)
{
	int ret;
	int i;
	
	for (i = 0; i < PWM_MAX_NUM; ++i)
	{
		s_pwm_id_list[i] = -1;
	}
	
	ret = misc_register(&misc_dev);
	if (ret < 0)
	{
		printk("drv init\n");
		return -1;
	}
	
	printk("pwm(build time:%s_%s) load successfully\n", __DATE__, __TIME__ );
	
	return 0;
}

static void __exit my_exit(void)
{
	PWM_DRV_Exit();
	
	misc_deregister (&misc_dev);
	
	printk("pwm(build time:%s_%s) exit successfully\n", __DATE__, __TIME__ );
	return;
}

module_init(my_init);
module_exit(my_exit);
MODULE_AUTHOR("SHJ");
MODULE_LICENSE("GPL");

test

#include "stdio.h"
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <unistd.h>


typedef unsigned int           UINT32;
typedef struct hiPWM_DATA_S
{
	UINT32 pwm_chn;
	UINT32 clk_div;
//	UINT32 reload;
   	UINT32  ui_prd;                              ///< Base period, how many PWM clock per period, 2 ~ 255
	UINT32  ui_rise;                             ///< Rising at which clock
	UINT32  ui_fall;                             ///< Falling at which clock	
	UINT32  ui_on_cycle;                   ///< Output cycle, 0 ~ 65535	
	UINT32  ui_inv;    
} PWM_DATA_S;

#define PWM_CMD_WRITE      0x01
#define PWM_CMD_READ       0x03
#define PWM_CMD_CLOSE 	   0x05


int main(int argc,char* argv[])
{
	static int s_pwm_fd = 0;
	PWM_DATA_S st_pwm_data;
	
	
	st_pwm_data.pwm_chn = 4;
	st_pwm_data.ui_prd = 0;
	st_pwm_data.ui_rise = 0;
	st_pwm_data.ui_fall = 0;
	st_pwm_data.clk_div = 0;
	st_pwm_data.ui_inv = 0;
	st_pwm_data.ui_on_cycle = 0;
	
	s_pwm_fd = open("/dev/pwm",O_RDWR);
	if(s_pwm_fd<=0)
	{
		printf("open failure!\n");
		return -1;
	}
	
	for (int i = 0; i < 30; ++i)
	{
		printf("red open\n");
		st_pwm_data.pwm_chn = 4;
		st_pwm_data.ui_fall = 1;
		int s32_ret = ioctl(s_pwm_fd, PWM_CMD_WRITE, &st_pwm_data); 
		if(s32_ret < 0)
		{
			printf("PWM_CMD_WRITE failure\n");
		}
		
		usleep(1000 * 50);
		
		printf("red close\n");
		st_pwm_data.pwm_chn = 4;
		st_pwm_data.ui_fall = 0;
		s32_ret = ioctl(s_pwm_fd, PWM_CMD_WRITE, &st_pwm_data); 
		if(s32_ret < 0)
		{
			printf("PWM_CMD_WRITE failure\n");
		}
		
		usleep(1000 * 50);
		
		printf("blue open\n");
		st_pwm_data.pwm_chn = 5;
		st_pwm_data.ui_fall = 1;
		s32_ret = ioctl(s_pwm_fd, PWM_CMD_WRITE, &st_pwm_data); 
		if(s32_ret < 0)
		{
			printf("PWM_CMD_WRITE failure\n");
		}
		
		usleep(1000 * 50);
		
		printf("blue close\n");
		st_pwm_data.ui_fall = 0;
		s32_ret = ioctl(s_pwm_fd, PWM_CMD_WRITE, &st_pwm_data); 
		if(s32_ret < 0)
		{
			printf("PWM_CMD_CLOSE failure\n");
		}
		
		usleep(1000 * 50);
		printf("-------------------------------------\n");
		
	}
	
	
	return 0;
}

Makefile

# 专用于编译.ko的Makefile
# 需要找到当前运行内核对应的根Makefile
KERNEL := /home/work/sourcecode/kernel/


obj-m := pwm.o
myko := pwm.ko

all:
	make -C $(KERNEL) M=`pwd` modules
install:
	adb remount
	adb push $(myko) /system/lib/modules/
clean:
	make -C $(KERNEL) M=`pwd` clean

GPIO驱动

#ifndef __GPIO_H__
#define __GPIO_H__

#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif /* __cplusplus */





#define DRV_NAME "gpio"
#define DRV_VERS "c01b01"


typedef struct
{
	unsigned char name[32];
	unsigned char version[32];
	unsigned char build_time[64];
}drv_ver_info_st;

typedef enum
{
	out = 0,
	input,
}direction_e;

typedef struct
{
	unsigned int 	gpio_id;			/*gpio id*/
	unsigned char 	direction;			/*配置gpio引脚的方向 0：输出；1：输入*/
	unsigned char	input_valu;			/*读取gpio的输入值*/
	unsigned char	output_valu;		/*配置gpio的输出值*/
	unsigned char	gpio_name[32];		/*gpio的名字*/
}gpio_attr_st;


#define IOC_MAGIC 'g'

//driver version info
#define GPIO_GET_DRV_INFO		_IOR(IOC_MAGIC,0x00, drv_ver_info_st)

#define GPIO_REQUEST			_IOW(IOC_MAGIC,0x01,gpio_attr_st)
#define GPIO_FERR				_IOW(IOC_MAGIC,0x02,gpio_attr_st)

#define GPIO_DIRECTION_SET		_IOW(IOC_MAGIC,0x03,gpio_attr_st)
#define GPIO_DIRECTION_GET		_IOR(IOC_MAGIC,0x04,gpio_attr_st)

#define GPIO_VALU_SET			_IOW(IOC_MAGIC,0x05,gpio_attr_st)
#define GPIO_VALU_GET			_IOR(IOC_MAGIC,0x06,gpio_attr_st)



#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* __cplusplus */

#endif	/* __GPIO_H__ */





#include <asm/uaccess.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/fcntl.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/spi/spi.h>
#include <linux/proc_fs.h>
#include <linux/workqueue.h>
#include <linux/interrupt.h>
#include <linux/time.h>
#include <linux/gpio.h>

#if 0
int gpio_request(unsigned gpio, const char *label);
void gpio_free(unsigned gpio);
int gpio_direction_input(unsigned gpio);
int gpio_direction_output(unsigned gpio, int value);
int gpio_get_value(unsigned int gpio);
void gpio_set_value(unsigned int gpio, int value);
int gpio_to_irq(unsigned int gpio);
#endif

#include "gpio.h"


static DEFINE_MUTEX(gpio_lock);


static int set_direction(gpio_attr_st *p_gpio_attr_info)
{
	int ret = -1;
	if(p_gpio_attr_info->direction == 1)
	{
		ret = gpio_direction_input(p_gpio_attr_info->gpio_id);
	}
	else
	{
		ret = gpio_direction_output(p_gpio_attr_info->gpio_id, p_gpio_attr_info->output_valu);
	}
	return ret;
}

static long fops_ioctl(struct file *file,unsigned int cmd, unsigned long __user arg)
{
	int ret = 0;

	mutex_lock(&gpio_lock);
	//if(!mutex_trylock(&gpio_lock))
	//{
	//	printk("\n============ gpio_ioctl busy =========\n");
	//	return -EBUSY;
	//}
	
	switch(cmd)
	{
		case GPIO_GET_DRV_INFO:
		{
			char str_tmp[24] = {0};
			if(copy_to_user(((drv_ver_info_st __user *)arg)->name, DRV_NAME, sizeof(DRV_NAME)))
				goto exit;
			if(copy_to_user(((drv_ver_info_st __user *)arg)->version, DRV_VERS, sizeof(DRV_VERS)))
				goto exit;
			sprintf( str_tmp, "%s-%s", __DATE__, __TIME__ );
			if(copy_to_user(((drv_ver_info_st __user *)arg)->build_time, str_tmp, sizeof(str_tmp)))
				goto exit;
			break;
		}
		case GPIO_REQUEST:
		{
			gpio_attr_st gpio_attr_info;
			if( copy_from_user(&(gpio_attr_info), (gpio_attr_st __user *)arg, sizeof(gpio_attr_st)))
			{
				goto exit;
			}
			ret = gpio_request(gpio_attr_info.gpio_id, gpio_attr_info.gpio_name);
			if(ret != 0)
			{
				goto exit;
			}
			break;
		}
		case GPIO_FERR:
		{
			gpio_attr_st gpio_attr_info;
			if( copy_from_user(&(gpio_attr_info), (gpio_attr_st __user *)arg, sizeof(gpio_attr_st)))
			{
				goto exit;
			}
			gpio_free(gpio_attr_info.gpio_id);
			break;
		}
		case GPIO_DIRECTION_SET:
		{
			gpio_attr_st gpio_attr_info;
			if( copy_from_user(&(gpio_attr_info), (gpio_attr_st __user *)arg, sizeof(gpio_attr_st)))
			{
				return -EFAULT;
			}
			ret = set_direction(&gpio_attr_info);
			
			break;
		}
		case GPIO_DIRECTION_GET:
		{
			gpio_attr_st gpio_attr_info;

			goto exit;//不支持
			
			if( copy_from_user(&(gpio_attr_info), (gpio_attr_st __user *)arg, sizeof(gpio_attr_st)))
			{
				goto exit;
			}
			//ret = gpiod_get_direction(gpio_attr_info.gpio_id);
			if(copy_to_user((gpio_attr_st __user *)arg, &gpio_attr_info, sizeof(gpio_attr_info)))
			{
				goto exit;
			}
			break;
		}
		case GPIO_VALU_SET:
		{
			gpio_attr_st gpio_attr_info;
			if( copy_from_user(&(gpio_attr_info), (gpio_attr_st __user *)arg, sizeof(gpio_attr_st)))
			{
				goto exit;
			}
			
			ret = set_direction(&gpio_attr_info);
			//printk(" gpio_attr_info.gpio_id = %d , gpio_attr_info.output_valu = %d \n",gpio_attr_info.gpio_id, gpio_attr_info.output_valu);
			gpio_set_value(gpio_attr_info.gpio_id, gpio_attr_info.output_valu);
			
			break;
		}
		case GPIO_VALU_GET:
		{
			gpio_attr_st gpio_attr_info;
			if( copy_from_user(&(gpio_attr_info), (gpio_attr_st __user *)arg, sizeof(gpio_attr_st)))
			{
				goto exit;
			}
			
			ret = set_direction(&gpio_attr_info);
			
			gpio_attr_info.input_valu = gpio_get_value(gpio_attr_info.gpio_id);

			if(copy_to_user((gpio_attr_st __user *)arg, &gpio_attr_info, sizeof(gpio_attr_info)))
			{
				goto exit;
			}
			
			break;
		}
		default:
		{
			printk("unkonw cmd:0x%x\n", cmd );
			goto exit;
		}
	}

	mutex_unlock(&gpio_lock);
	return ret;
	
exit:
	
	mutex_unlock(&gpio_lock);
	
	return -EFAULT;
}




int fops_open(struct inode* inode, struct file* file)
{
	//pwm_base_clk_update();
	return 0 ;
}

int  fops_close(struct inode* inode, struct file* file)
{
	return 0;
}


static const struct file_operations drv_fops = {
	.owner=THIS_MODULE,
	.open=fops_open,
	.release=fops_close,
	.unlocked_ioctl=fops_ioctl,
};

static struct miscdevice misc_dev = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "gpio",
	.fops = &drv_fops,
};

static int __init mod_init(void)
{
	int ret;

	ret = misc_register(&misc_dev);
	if (ret < 0)
	{
		printk("drv init\n");
		return -1;
	}
	printk("gpio.ko(ver:%s, build time:%s_%s) load successfully\n", DRV_VERS, __DATE__, __TIME__ );
	return 0;
}

static void __exit mod_exit(void)
{
/*把以前fclose里面的zoom/focus stop挪到此处，因为测试程序会多次open, close此驱动，改到此处后，将不再影响到lv8044的寄存器值。Jimmy Feb17th2016*/
	printk("gpio(ver:%s, build time:%s_%s) exit successfully\n", DRV_VERS, __DATE__, __TIME__ );	

	misc_deregister(&misc_dev);
	
	printk("gpio(ver:%s, build time:%s_%s) exit successfully\n", DRV_VERS, __DATE__, __TIME__ );
	return;
}


module_init(mod_init);
module_exit(mod_exit);

MODULE_DESCRIPTION("gpio driver");
MODULE_LICENSE("GPL");
//MODULE_AUTHOR("gpio");

test

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <pthread.h>

#include "gpio.h"


#define LOG_INFO(fmt,args...)   ({printf("info: %s(%d) %s:",__FILE__, __LINE__, __func__);printf(fmt"\r\n" ,##args);})
#define SN_GOTO(express, go, fmt, ...) \
do \
{\
	if(!(express)) \
	{ \
		LOG_INFO(fmt, ##__VA_ARGS__); \
		goto go; \
	} \
}while(0)



	
int main(int argc ,char * argv[])
{
	int s32Ret;
	int fd = -1;
	
	fd = open("/dev/gpio",O_RDWR);
	SN_GOTO(fd >=0, _Exit_GPIO_FD, "ioctl GPIO open failed !");

	
	gpio_attr_st stGpioAttr;
	memset(&stGpioAttr, -1,sizeof(gpio_attr_st));
	
	
	LOG_INFO(" ----- argc %d\n", argc);
		
	
	int _u32GpioNum = 0;
	//READ
	if (argc == 1)
	{
		stGpioAttr.gpio_id = _u32GpioNum;
		stGpioAttr.direction = 1; //1 为读
		sprintf((char*)stGpioAttr.gpio_name,"gpio%d", _u32GpioNum);
	
		s32Ret = ioctl(fd, GPIO_REQUEST, &stGpioAttr);
		SN_GOTO(s32Ret >=0, _Exit_GPIO_FD, "ioctl GPIO_REQUEST failed!");

		s32Ret = ioctl(fd, GPIO_DIRECTION_SET, &stGpioAttr);
		SN_GOTO(s32Ret >=0, _Exit_GPIO_FD, "ioctl GPIO_DIRECTION_SET failed!");
		usleep(10*1000);
		
		s32Ret = ioctl(fd, GPIO_VALU_GET, &stGpioAttr);
		SN_GOTO(s32Ret >=0, _Exit_GPIO_FD, "ioctl GPIO_VALU_GET failed!");
		usleep(10*1000);
		
		LOG_INFO(" ----- read %d\n", stGpioAttr.input_valu);
		
		s32Ret = ioctl(fd, GPIO_FERR, &stGpioAttr);
		SN_GOTO(s32Ret >=0, _Exit_GPIO_FD, "ioctl GPIO_DIRECTION_SET failed!");
			
	}
	else
	{
		stGpioAttr.gpio_id = _u32GpioNum;
		stGpioAttr.direction = 0; //0 为写
		sprintf((char*)stGpioAttr.gpio_name,"gpio%d", _u32GpioNum);
		
		
		//stGpioAttr.output_valu = 1;
		//stGpioAttr.output_valu = atoi(argv[1]);
		
		//LOG_INFO(" ----- write %d\n", stGpioAttr.output_valu);

		s32Ret = ioctl(fd, GPIO_REQUEST, &stGpioAttr);
		SN_GOTO(s32Ret >=0, _Exit_GPIO_FD, "ioctl GPIO_REQUEST failed!");
		
		stGpioAttr.output_valu = 1;
		s32Ret = ioctl(fd, GPIO_DIRECTION_SET, &stGpioAttr);
		SN_GOTO(s32Ret >=0, _Exit_GPIO_FD, "ioctl GPIO_DIRECTION_SET failed!");
		usleep(10*1000);
		
		
		
		
		//引脚拉低
		stGpioAttr.output_valu = 0;
		s32Ret = ioctl(fd, GPIO_VALU_SET, &stGpioAttr);
		SN_GOTO(s32Ret >=0, _Exit_GPIO_FD, "ioctl GPIO_VALU_GET failed!");
		usleep(10*1000);
		
		
		
		
		
		s32Ret = ioctl(fd, GPIO_FERR, &stGpioAttr);
		SN_GOTO(s32Ret >=0, _Exit_GPIO_FD, "ioctl GPIO_DIRECTION_SET failed!");
		
	}
	
	
	
_Exit_GPIO_FD:
			
	if(fd)	
	{	
		close(fd);
		//fd = NULL;
	}
	return 0;
}

Makefile

CROSS_COMPILE = arm-buildroot-linux-uclibcgnueabihf-

ifeq (${ISVP_ENV_KERNEL_DIR}, )
	ISVP_ENV_KERNEL_DIR = ../kernel
endif

KDIR := ${ISVP_ENV_KERNEL_DIR}


all: modules gpio_test



.PHONY: modules clean

GPIO_HAL_NAME := gpio
GPIO_TEST := gpio_test
$(MODULE_NAME)-objs := gpio.o
obj-m := $(GPIO_HAL_NAME).o
#obj-m := $(GPIO_TEST).o 

modules:
	@$(MAKE) -C $(KDIR)  M=$(shell pwd) $@

gpio_test:
	$(CROSS_COMPILE)gcc -o gpio_test gpio_test.c

clean:
	@rm -rf *.o *~ .depend .*.cmd  *.mod.c .tmp_versions *.ko *.symvers modules.order
	@rm gpio_test

keep754
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RK3568开发笔记-pwm调试
flypig has a dream！
11-18 2675
PWM即脉冲宽度调制，是英文“Pulse Width ModulaTIon”的缩写，简称脉宽调制，是利用微处理器的数字输出来对模拟电路进行控制的一种非常有效的技术，广泛应用在从测量、通信到功率控制与变换的许多领域中。PWM控制技术就是对脉冲的宽度进行调制的技术，即通过对一系列脉冲的宽度进行调制，来等效的获得所需要的波形(含形状和幅值)。PWM是一种对模拟信号电平进行数字编码的方法。通过高分辨率计数器的使用，方波的占空比被调制用来对一个具体模拟信号的电平进行编码。本文主要介绍RK3568平台PWM使用方法。
Linux 块设备驱动 demo
u011981341的博客
04-28 430
最近在学习块设备驱动的一些东西，所以想着还是自己整两个块设备驱动耍耍，听说有三种模式[免费chatgpt说的]，具体是不是我也不晓得。1：单队列（Single Queue，简称sq）模式。这里主要是把函数和框架熟悉一下，并未真正采用多队列。2：多队列（Multiqueue，简称mq）模式。
驱动读写demo
weixin_47707022的博客
03-24 274
远古代码却有用
全志V3S开发板驱动示例(linux demo驱动开发)
li_man_man_man的博客
07-30 3707
本文描述了基于全志V3S开发板的简单驱动程序和测试应用程序的设计流程。我们设计的驱动程序和测试程序极其简单，适合初学者上手学习。本次硬件设计是基于V3S开发板全志V3S处理器，该处理器集成了一个1.2GHz工作主频的单ARMCortexTM-A7核，芯片内部集成了64MBDRAM存储器。本次软件设计是基于linux3.4。设计的步骤依次是步骤一编写一个demo_driver.c的驱动程序。步骤二编写makefile文件。步骤三编写一个demo_app.c的应用程序。步骤四。.........
Ubuntu 18.04 驱动demo
汽车电子软件领域知识分享
09-10 818
文章目录1. 编译内核2. 驱动demo2.1 驱动程序2.2 Makefile2.3 测试程序3. USB驱动demo3.1 驱动程序3.2 Makefile3.3 测试程序4. 参考资料 注意：如果是编写的驱动在本机系统上用，则不必编译内核；如果是要在其他的系统上用，要编译成功目标机的内核版本。如果是第一种场景，则直接跳过章节1 1. 编译内核 首先查看一下内核版本 qpp@qpp-virtual-machine:$ uname -r 5.4.0-72-generic 这是我的内核版本。 安装编
GD32F4xx USB cdc host驱动demo
03-29
标题中的“GD32F4xx USB CDC Host驱动demo”是指基于GD32F4系列微控制器（MCU）的USB设备类（CDC）主机驱动程序的示例代码。GD32F4xx系列是由GD Microsystems推出的高性能 Arm Cortex-M4 内核的单片机，具有高速浮点...
英飞凌培训资料+驱动demo
03-09
针对这些领域的开发工作，英飞凌提供了丰富的培训资料和驱动demo，以帮助工程师更好地理解和使用其芯片。本压缩包中的资源主要围绕英飞凌的TC3xx和TC264系列微控制器展开，涵盖了驱动开发、系统启动、MCAL...
字符文件驱动demodemo
最新发布
11-02
字符文件驱动demodemo
基于ROS1的华腾工业摄像头驱动Demo
01-14
在这个基于ROS1的华腾工业摄像头驱动Demo中，我们将深入探讨如何在Ubuntu系统上配置和使用ROS来驱动华腾工业摄像头，并通过Topic发布图像数据。 首先，要理解ROS的工作原理，它由节点(Node)、话题(Topic)、服务...
基于ROS1的海康工业相机驱动Demo
01-11
在这个“基于ROS1的海康工业相机驱动Demo”中，我们将探讨如何在Ubuntu操作系统上利用ROS1来驱动海康工业相机，并实时发布获取的图像数据。 首先，我们需要了解ROS1的基本概念。ROS1是由一系列包（package）、节点...
windows官方驱动开发demo源代码
10-15
windows下的各种驱动开发官方样例源代码，包含多种驱动开发样例，有usb类的，有打印驱动类的等等
PWM的基本原理及其应用实例
热门推荐
skywalker_leo的专栏
01-09 4万+
脉宽调制(PWM)是利用微处理器的数字输出来对模拟电路进行控制的一种非常有效的技术，广泛应用在从测量、通信到功率控制与变换的许多领域中。 模拟电路        模拟信号的值可以连续变化，其时间和幅度的分辨率都没有限制。9V电池就是一种模拟器件，因为它的输出电压并不精确地等于9V，而是随时间发生变化，并可取任何实数值。与此类似，从电池吸收的电流也不限定在一组可能的取值范围之内。模拟信号与数字信
pwm设备驱动
layuetian2011的博客
07-13 1424
前文有说到软件侧背光的控制过程, 通常的背光,硬件层都是通过pwm来调节的. 本文理下pwm驱动, pwm也和设备驱动模型一样的思路,分控制器host设备和具体的device驱动,其中驱动又分设备驱动层和驱动核心层. pwm设备相当于资源的提供者(supplier),背光相当于pwm的消费者(customer) 本文重点放在pwm设备端(包括设备,以及这个平台设备本身对应的驱动) pwm本质上是一种通信协议,类似于i2c,spi,usb, 平台设备驱动(分核心层和host device driver层)的意
sys文件系统调节lcd背光
cqxcool66的博客
06-24 1116
sys的位置 /sys/class/backlight/lcd_backlight@0 cat max_brightness //获取最大的亮度：100 cat actual_brightness //获取实际的亮度：80 echo 100 > brightness //设置亮度为100 echo 80 > brightness //设置亮度为80 驱动位置： /drivers/pwm/pwm-imx.c //imx的和cpu相关的pwm操作。 /drivers/pwm/core.c /dr
学习PWM的一些总结
渣渣屋
07-24 997
（1）TIM_CtrlPWMOutputs(TIM_TypeDef* TIMx, FunctionalState NewState) 这个函数，只有定时器TIM1 8 15 16 17使用时才调用； （2）TIMx_CRx中APRE:对时钟的控制寄存器进行操作 是其自动重装载(的)预装载允许位（1：自动重装载之前会先进行访问预装载寄存器 0：不会） （3）TIMx_CCMRx中OCxPE
Linux pwm_fan 风扇驱动
这个地瓜真是甜啊
04-21 7001
PWM_FAN、四线风扇、LINUX驱动解析
Linux应用开发【第十一章】PWM编程应用开发
韦东山嵌入式专栏
12-13 5005
文章目录11 PWM编程应用开发11.1 PWM概述11.1.1 PWM的参数说明11.2 用户层查看PWM11.3 PWM的SYSFS使用11.4 PWM应用编程11.4.1 修改设备树11.4.2 修改配置文件11.4.3 添加驱动11.4.4 运行测试 11 PWM编程应用开发 11.1 PWM概述 ​ PWM，英文名Pulse Width Modulation，是脉冲宽度调制缩写，它是通过对一系列脉冲的宽度进行调制，等效出所需要的波形（包含形状以及幅值），对模拟信号电平进行数字编码，也就是说通过调
Android 驱动程序Demo及流程
Venscor技术养成之路
07-28 5502
很久前就想了解驱动程序的想法，这里现做一个简单的开始，从demo做起，看到Android驱动程序的基本运行流程，这对漏洞分析、检测和挖掘都是必要的。同样，本篇基本也是自己学习过程的记录，无干货。本篇大多数内容来自Linux设备驱动之Ioctl控制。一、用户层不管是漏洞检测，还是poc中，我们见到最多的函数就是ioctl()函数，这个函数就是用户层调用内核程序的接口。/* fd:文件描述符 cmd:控
主设备号和次设备号
weixin_45519751的博客
09-13 1799
Linux的设备管理是和文件系统紧密结合的，各种设备都以文件的形式存放在/dev目录下，称为设备文件。应用程序可以打开、关闭和读写这些设备文件，完成对设备的操作，就像操作普通的数据文件一样。为了管理这些设备，系统为设备编了号，每个设备号又分为主设备号和次设备号。主设备号用来区分不同种类的设备，而次设备号用来区分同一类型的多个设备。对于常用设备，Linux有约定俗成的编号，如硬盘的主设备号是3。 一个字符设备或者块设备都有一个主设备号和次设备号。主设备号和次设备号统称为设备号。主设备号用来表示一个特定的驱动程
vxbus驱动demo
08-24
总之，vxbus驱动Demo是一个用于演示vxbus驱动框架的示例程序，通过它我们可以学习到如何使用vxbus驱动来编写设备驱动程序，从而更好地理解和掌握VxWorks系统中的设备管理技术。 ### 回答3： VXBUS驱动演示是一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值