基于Linux系统下的S5PV210实现远程控制LED和蜂鸣器

最新推荐文章于 2023-03-05 18:16:32 发布
最新推荐文章于 2023-03-05 18:16:32 发布
阅读量523 收藏 5
点赞数
文章标签： linux c语言 socket 驱动程序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43947512/article/details/116588187
版权 
1，实现两个设备驱动：蜂鸣器，led灯
2，写一个服务器程序接收客户端命令，根据命令操作不同的设备
3，实现一个客户端程序，向服务器发送命令，控制设备

/*
home_work_client.c
使用select多路复用实现TCP双向通信服务器端代码
实现一个客户端程序，向服务器发送命令，控制设备
*/
#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>
#include <sys/time.h>
#include <unistd.h>
int main(int argc,char *argv[])
{
	if(argc!=3){
		perror("argc error");
		exit(1);
	}
	int socket_fd = socket(AF_INET,SOCK_STREAM,0);//ipv4协议，流式套接字
	if(socket_fd==-1){//创建流式套接字失败
		perror("socket error");
		exit(1);
	}
	int on=1;//端口可以重复使用
	setsockopt(socket_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
	char ch[100]={};
	struct sockaddr_in server_addr;//连接服务器
	server_addr.sin_family = AF_INET;//ipv4协议
	server_addr.sin_port = htons(atoi(argv[2]));//服务器端口号
	server_addr.sin_addr.s_addr = inet_addr(argv[1]);//服务器主机号	
	int connect_ret = connect(socket_fd,(struct sockaddr *)&server_addr,sizeof(server_addr));
	if(connect_ret==-1){
		perror("connect error");
		exit(1);		
	}
	fd_set send_set;
	while(1){
		FD_ZERO(&send_set);//清空集合
		FD_SET(0,&send_set);//添加0文件描述符
		FD_SET(socket_fd,&send_set);//添加socket_fd文件描述符
		select(socket_fd+1,&send_set,NULL,NULL,NULL);//监测文件描述符
		if(FD_ISSET(0,&send_set)){//判断标准输入
			bzero(ch,sizeof(ch));
			gets(ch);
			send(socket_fd,ch,strlen(ch),0);//发送数据		
		}
		if(FD_ISSET(socket_fd,&send_set)){//判断接收文件描述符
			bzero(ch,sizeof(ch));
			int recv_ret = recv(socket_fd,ch,sizeof(ch),0);//接收数据
			if(recv_ret==0){
				break;
			}
			printf("%s\n",ch);			
		}
	}
	return 0;
}

/*
home_work_server.c
*/
#include "link.h"
#define	LED_ALL_ON	    _IO('L', 0x01)
#define	LED_ALL_OFF	    _IO('L',0x02)
#define	LED_NUM_ON	    _IOW('L', 0x03, int)
#define	LED_NUM_OFF	    _IOW('L',0x04,int)
#define	Buzzer_ON			_IO('B',0x05)
#define	Buzzer_OFF	        _IO('B',0x06)
int main(int argc,char *argv[])
{
	if(argc!=3){
		perror("argc error");
		exit(1);
	}
	char ch[100] = {};//接收缓冲区
	char buf[100] = {};//发送缓冲区
	char ch_head[100]={};//字符串头
	char ch_cmd[100]={};//字符串命令
	char ch_num[100]={};//字符串数据
	char ch_count=0;
	char head_count=0;
	char cmd_count=0;
	char num_count=0;
	int send_fd;//服务器发送的客户端文件描述符
	int socket_fd = socket(AF_INET,SOCK_STREAM,0);//ipv4协议，流式套接字
	if(socket_fd==-1){//创建流式套接字失败
		perror("socket error");
		exit(1);
	}
    int fd = open("/dev/hello2",O_RDWR);
    if(fd<0){
		perror("open error");
		exit(-1);
    }
	int on=1;//端口可以重复使用
	setsockopt(socket_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
	
	struct sockaddr_in server_addr;
	server_addr.sin_family = AF_INET;//iPv4
	server_addr.sin_port = htons(atoi(argv[2]));//服务器端口号
	server_addr.sin_addr.s_addr = inet_addr(argv[1]);//服务器IP地址
	int bind_ret = bind(socket_fd,(struct sockaddr *)&server_addr,sizeof(server_addr));
	if(bind_ret==-1){
		perror("bind error");
		exit(1);
	}
	listen(socket_fd,5);//监听套接字
	plink Describe_Link;//套接字文件描述符链表
	plink temp_link;
	int temp_fd;
	fd_set recv_set;//创建集合
	int accept_ret;//连接后的文件描述符
	int Max_nfds = socket_fd;//起始最大文件描述符值
	int ret;
	Init_Link(&Describe_Link);//初始化文件描述符链表
	while(1){
		FD_ZERO(&recv_set);//清空集合
		FD_SET(0,&recv_set);//添加0文件描述符
		FD_SET(socket_fd,&recv_set);//添加socket_fd文件描述符
		
		display(Describe_Link,&recv_set);//遍历链表，添加所有文件描述符
		select(Max_nfds+1,&recv_set,NULL,NULL,NULL);//阻塞等待
		if(FD_ISSET(socket_fd,&recv_set)){//有客户端请求连接
			accept_ret = accept(socket_fd,NULL,NULL);//获取新的套接字文件描述符
			printf("%d is connnect...\n",accept_ret);
			Insert_Link_Head(Describe_Link,accept_ret);//头插到链表中
			Max_nfds = Find_Link_Node(Describe_Link,0);//更新新的最大文件描述符
			//printf("Max_nfds = %d\n",Max_nfds);
		}
		if(FD_ISSET(0,&recv_set)){
			bzero(buf,sizeof(buf));//清空缓冲区
			bzero(ch,sizeof(ch));
			gets(ch);//输入请按这个格式输入4:hello 客户端名字：内容
			sscanf(ch,"%d:%s",&send_fd,buf);//指定客户端发送数据
			send(send_fd,buf,strlen(buf),0);
		}
		temp_link = Describe_Link->next;
		while(temp_link != Describe_Link){//遍历链表，监测所有套接字文件描述符
			if(FD_ISSET(temp_link->data,&recv_set)){
				bzero(ch,sizeof(ch));
				ret = recv(temp_link->data,ch,sizeof(ch),0);
				if(ret == 0){
					temp_fd = temp_link->data;//保存套接字文件描述符
					Del_Link_Data(Describe_Link,temp_link->data);//删除该套接字文件
					//display_value(Describe_Link);
					close(temp_fd);//关闭客户端对应的文件描述符，释放资源，下次再有客户端连接可以使用该文件描述符
					break;
				}
				bzero(ch_head,sizeof(ch_head));
				bzero(ch_cmd,sizeof(ch_cmd));
				bzero(ch_num,sizeof(ch_num));
				printf("%d:%s\n",temp_link->data,ch);
				while(ch[ch_count] != '\0'){
					while(ch[ch_count]!=':'){
						ch_head[head_count++]=ch[ch_count++];
					}
					ch_count++;
					while(ch[ch_count]!=':'){
						ch_cmd[cmd_count++]=ch[ch_count++];
					}
					ch_count++;
					while(ch[ch_count] != '\0')
						ch_num[num_count++]=ch[ch_count++];
					break;
				}
				ch_count=0;
				head_count=0;
				cmd_count=0;
				num_count=0;
				printf("%s--%s--%s\n",ch_head,ch_cmd,ch_num);
				if(strcasecmp(ch_head,"led")==0){
					if(strcasecmp(ch_cmd,"on")==0){
						ioctl(fd,LED_NUM_ON,atoi(ch_num));
						printf("LED_NUM_ON\n");
					}else if(strcasecmp(ch_cmd,"off")==0){
						ioctl(fd,LED_NUM_OFF,atoi(ch_num));
						printf("LED_NUM_OFF\n");
					}else if(strcasecmp(ch_cmd,"allon")==0){
						ioctl(fd,LED_ALL_ON);
						printf("LED_ALL_ON\n");
					}else if(strcasecmp(ch_cmd,"alloff")==0){
						ioctl(fd,LED_ALL_OFF);
						printf("LED_ALL_OFF\n");
					}
				}else if(strcasecmp(ch_head,"buzzer")==0){
					if(strcasecmp(ch_cmd,"on")==0){
						ioctl(fd,Buzzer_ON);
						printf("Buzzer_ON\n");
					}else if(strcasecmp(ch_cmd,"off")==0){
						ioctl(fd,Buzzer_OFF);
						printf("Buzzer_OFF\n");
					}
				}
			}
			temp_link = temp_link->next;
		}
	}
	 close(fd);
	return 0;
}


/*
led_dev.c
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <asm/io.h>
#include <linux/delay.h>
#include <asm/uaccess.h>
#include <linux/slab.h>
#include <linux/virtio.h>
#include <linux/gpio.h>

#define	LED_ALL_ON			_IO('L', 0x01)
#define	LED_ALL_OFF			_IO('L',0x02)
#define	LED_NUM_ON			_IOW('L', 0x03, int)
#define	LED_NUM_OFF			_IOW('L',0x04,int)
#define	Buzzer_ON			_IO('B',0x05)
#define	Buzzer_OFF	        _IO('B',0x06)

#define	GPD0_BASE	0xE02000A0//蜂鸣器基地址
#define	GPC0_BASE	0xE0200060//LED基地址
//定义设备对象
typedef struct s5pv210_led_dev{
	unsigned int major;
	struct class *class;
	struct device *device;	
}s5pv210_led_dev_t,*s5pv210_led_dev_p;
//定义全局实例化对象指针
s5pv210_led_dev_p	Led_Dev;

unsigned	int *gpd_conf;//蜂鸣器控制寄存器
unsigned int *gpd_data;//蜂鸣器数据寄存器
unsigned int *gpc0_conf;//LED控制寄存器
unsigned int *gpc0_data;//LED数据寄存器


// 3.实现操作设备接口
int led_open(struct inode *inode, struct file * filp)
{
	printk("-----------^_^ %s---------------\n",__FUNCTION__);
/*
	//蜂鸣器初始化
	*gpd_conf &= ~(0xf<<4);
	*gpd_conf |= 0x01<<4;//配置输出模式
	*gpd_data &= ~(0x01<<1);//蜂鸣器不响
	//LED初始化
	*gpc0_conf &=~(0xff<<12);
	*gpc0_conf |= 0x11<<12;//配置为输出模式
	*gpc0_data	&=	~(0x03<<3);//led灭	
*/
	return 0;
}
int led_close (struct inode *inode, struct file *filp)
{
	printk("-----------^_^ %s---------------\n",__FUNCTION__);
	*gpd_data &= ~(0x01<<1);//蜂鸣器不响
	*gpc0_data	&=	~(0x03<<3);//led灭	
	return 0;
}
ssize_t led_write (struct file *filp, const char __user *buf, size_t size, loff_t *flags)
{
	int value;
	int ret;
	printk("-----------^_^ %s---------------\n",__FUNCTION__);
	//应用层数据转为内核空间数据
	ret	=	copy_from_user(&value, buf, size);  
	if(ret>0){
		printk("--------copy_from_user error------\n");
		return -EINVAL;
	}
	//根据value的值控制蜂鸣器
#if 0
	if(value==1){// 1蜂鸣器响
		*gpd_data |= 0x01<<1;
	}else if(value==2){// 2蜂鸣器不响
		*gpd_data &= ~(0x01<<1);
	}else if(value==3){//led1亮
		*gpc0_data	&=	~(0x03<<3);//led灭	
		*gpc0_data	|= 0x01<<3;
	}else if(value==4){
		*gpc0_data	&=	~(0x03<<3);//led灭	
		*gpc0_data	|= 0x01<<4;		
	}
#else
	switch(value){
		case 1://蜂鸣器响
			*gpd_data |= 0x01<<1;
			break;
		case 2://蜂鸣器灭
			*gpd_data &= ~(0x01<<1);
			break;
		case 3://led1亮
			*gpc0_data	&=	~(0x03<<3);//led灭	
			*gpc0_data	|= 0x01<<3;			
			break;
		case 4://led2亮
			*gpc0_data	&=	~(0x03<<3);//led灭	
			*gpc0_data	|= 0x01<<4;	
			break;
		default :
			break;
	}
#endif
	return size;
}
long led_ioctl (struct file *filp, unsigned int cmd, unsigned long arg)
{
	int led_num = arg+2;
	printk("-----------^_^ %s---------------\n",__FUNCTION__);	
	switch(cmd){
		case LED_ALL_ON://开所有灯
			//*gpc0_data	|=	0x03<<3;
			gpio_request(S5PV210_GPC0(3),"gpc0_3");
			gpio_direction_output(S5PV210_GPC0(3),1);
			gpio_free(S5PV210_GPC0(3));
			gpio_request(S5PV210_GPC0(4),"gpc0_3");
			gpio_direction_output(S5PV210_GPC0(4),1);
			gpio_free(S5PV210_GPC0(4));
			break;
		case LED_ALL_OFF://关所有灯
			//*gpc0_data	&=	~(0x03<<3);//led灭
			gpio_request(S5PV210_GPC0(3),"gpc0_3");
			gpio_direction_output(S5PV210_GPC0(3),0);
			gpio_free(S5PV210_GPC0(3));
			gpio_request(S5PV210_GPC0(4),"gpc0_3");
			gpio_direction_output(S5PV210_GPC0(4),0);
			gpio_free(S5PV210_GPC0(4));
			break;
		case LED_NUM_ON://开某个灯
			if(led_num!=3 && led_num!=4){
				printk("--------parameter error------\n");
				return -EINVAL;
			}
			gpio_request(S5PV210_GPC0(led_num),"gpc0_3/4");
			gpio_direction_output(S5PV210_GPC0(led_num),1);
			gpio_free(S5PV210_GPC0(led_num));
			//*gpc0_data	|= 0x01<<led_num;	
			break;
		case LED_NUM_OFF://关闭某个灯
			if(led_num!=3 && led_num!=4){
				printk("--------parameter error------\n");
				return -EINVAL;
			}
			gpio_request(S5PV210_GPC0(led_num),"gpc0_3/4");
			gpio_direction_output(S5PV210_GPC0(led_num),0);
			gpio_free(S5PV210_GPC0(led_num));
			//*gpc0_data	&=	~(0x01<<led_num);//led灭
			break;
		case Buzzer_ON://开蜂鸣器
			gpio_request(S5PV210_GPD0(1), "gpd0_1");
			gpio_direction_output(S5PV210_GPD0(1),1);
			gpio_free(S5PV210_GPD0(1));
			break;
		case Buzzer_OFF://关闭蜂鸣器
			gpio_request(S5PV210_GPD0(1), "gpd0_1");
			gpio_direction_output(S5PV210_GPD0(1),0);
			gpio_free(S5PV210_GPD0(1));			
			break;
		default :
			printk("--------parameter error------\n");
			break;
	}
	return 0;
}
const struct file_operations fops = {
	.open 						= 		led_open,
	.release					=		led_close,
	.write						=		led_write,
	.unlocked_ioctl				=		led_ioctl,
};
//模块加载函数
static int __init led_drv_init(void)
{
	int ret;
	printk("--------%s------\n",__FUNCTION__);
	//申请实例化对象空间
	Led_Dev = kzalloc(sizeof(s5pv210_led_dev_t), GFP_KERNEL);
	
	if(IS_ERR(Led_Dev)){
		printk("--------kzalloc error------\n");
		return -ENOMEM;
	}
	
	// 1.动态申请设备号
	Led_Dev->major= register_chrdev(0, "led_drv", &fops);
	if(Led_Dev->major<0){
		printk("--------register_chrdev error------\n");
		goto err_kfree;
	}
	printk("Led_Dev->major=%d\n",Led_Dev->major);
	// 2.创建设备节点
	Led_Dev->class= class_create(THIS_MODULE, "led_class");
	if(IS_ERR(Led_Dev->class)){
		printk("--------class_create error------\n");
		ret=PTR_ERR(Led_Dev->class);
		goto err_unregister_chrdev;
	}
	Led_Dev->device=device_create(Led_Dev->class, NULL, MKDEV(Led_Dev->major, 5), NULL, "hello2");
	if(IS_ERR(Led_Dev->device)){
		printk("--------device_create error------\n");
		ret = PTR_ERR(Led_Dev->device);
		goto err_destorry_class;
	}
	// 4.硬件初始化---地址映射
	//蜂鸣器地址映射
	gpd_conf = ioremap(GPD0_BASE, 8);
	if(IS_ERR(gpd_conf)){
		printk("--------ioremap error------\n");
		ret = PTR_ERR(gpd_conf);
		goto err_device_destory;
	}
	gpd_data = gpd_conf+1;
	//LED地址映射
	gpc0_conf = ioremap(GPC0_BASE, 8);
	if(IS_ERR(gpc0_conf)){
		printk("--------ioremap error------\n");
		ret = PTR_ERR(gpc0_conf);
		goto err_iounmap;
	}
	gpc0_data = gpc0_conf+1;
	
	return 0;
err_iounmap:
	iounmap(gpd_conf);
err_device_destory:
	device_destroy(Led_Dev->class, MKDEV(Led_Dev->major, 5));
err_destorry_class:
	class_destroy(Led_Dev->class);
err_unregister_chrdev:
	unregister_chrdev(Led_Dev->major, "led_drv");
err_kfree:
	kfree(Led_Dev);
	return ret;
	
}
//模块卸载函数
static void __exit led_drv_exit(void)
{
	printk("--------%s------\n",__FUNCTION__);
	iounmap(gpc0_conf);
	iounmap(gpd_conf);
	device_destroy(Led_Dev->class, MKDEV(Led_Dev->major, 5));
	class_destroy(Led_Dev->class);
	unregister_chrdev(Led_Dev->major, "led_drv");
	kfree(Led_Dev);
}
//注册和认证
module_init(led_drv_init);
module_exit(led_drv_exit);
MODULE_LICENSE("GPL");



/*
link.c
*/
#include "link.h"
/*
头指针初始化
*/
void Init_Link(plink *P_Link)
{
	*P_Link = (plink)malloc(sizeof(link));
	if(*P_Link==NULL){
		printf("*P_Link malloc error %s\n",__FUNCTION__);
		return;
	}
	(*P_Link)->next = *P_Link;
}
/*
创建新节点
*/
plink Creat_Node(datatype d)
{
	plink P_Link = (plink)malloc(sizeof(link));
	if(P_Link==NULL){
		printf("Creat_Node malloc error %s\n",__FUNCTION__);
		return;
	}
	P_Link->data = d;
	P_Link->next = P_Link;
	return P_Link;
}
/*
头插法，添加在第一个元素前面
*/
void Insert_Link_Head(plink head,datatype data)
{
	if(head == NULL){
		return ;
	}
	plink node = Creat_Node(data);
	if(node == NULL){
		printf("Creat_Node malloc error %s\n",__FUNCTION__);
	}
	node->next = head->next;
	head->next = node;
}
/*
尾插法，添加在最后一个元素后面
*/
void Insert_Link_Tail(plink head,datatype data)
{
	if(head == NULL){
		return ;
	}
	plink p = head->next;
	while(p->next != head){
		p = p->next;
	}
	plink node = Creat_Node(data);
	if(node == NULL){
		printf("Creat_Node malloc error %s\n",__FUNCTION__);
	}
	node->next = p->next;
	p->next = node;
}
/*
删除一个节点
*/
void Del_Link_Data(plink head,datatype data)
{
	if(head==NULL){
		return;
	}
	plink p = head;
	plink old_node;
	while(p->next!=head){
		if(p->next->data == data){
			old_node=p->next;
			p->next = p->next->next;
			old_node->next = NULL;
			free(old_node);
			continue;
		}
		p = p->next;
	}
}
/*
修改一个节点
*/
void Updata_Link(plink head,datatype Old_data,datatype New_data)
{
	if(head==NULL){
		return;
	}
	plink p = head;
	plink old_node;
	while(p->next!=head){
		if(p->next->data == Old_data){
			old_node=p->next;
			plink New_node=Creat_Node(New_data);
			if(New_node == NULL){
				return;
			}
			New_node->next=p->next->next;
			p->next = New_node;
			old_node->next = NULL;
			free(old_node);
			continue;
		}
		p = p->next;
	}
}
/*
	查询
*/
datatype Find_Link_Node(plink head,datatype data)
{
	if(head==NULL){
		return;
	}
	
	plink p = head->next;
	while(p!=head){
		if(p->data > data){
			data = p->data;
		}
		p = p->next;
	}
	return data;
}
/*
遍历
*/
void display(plink head,fd_set *recv_set)
{
	if(head == NULL){
		return ;
	}
	plink p = head->next;
	while(p!=head){
		FD_SET(p->data,recv_set);//添加每一个文件描述符到集合中
		p = p->next;
	}
}
/*
遍历链表中的值
*/
void display_value(plink head)
{
	if(head == NULL){
		return ;
	}
	plink p = head->next;
	while(p!=head){
		printf("%d\n",p->data);
		p = p->next;
	}
}

/*
link.h
*/
#ifndef __LINK___
#define __LINK___
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
typedef int datatype;
typedef struct linklist{
	datatype data;//数据域
	struct linklist *next;//指向下一个节点
}link,*plink;

extern void Init_Link(plink *P_Link);
extern void Insert_Link_Head(plink head,datatype data);
extern void display(plink head,fd_set *recv_set);
extern void Insert_Link_Tail(plink head,datatype data);
extern void Del_Link_Data(plink head,datatype data);
extern void Updata_Link(plink head,datatype Old_data,datatype New_data);
extern datatype Find_Link_Node(plink head,datatype data);
extern void display_value(plink head);
#endif

/*
Makefile
*/
KERNEL_DIR = /home/zzz/fs210/kerner/linux-3.0.8

CUR_DIR = $(shell pwd)

MYAPP=home_work_server

all:
		make -C	$(KERNEL_DIR)	M=$(CUR_DIR)	modules
		arm-none-linux-gnueabi-gcc -o $(MYAPP)		link.c $(MYAPP).c
		gcc -o home_work_client	link.c home_work_client.c
clean:
		make -C	$(KERNEL_DIR)	M=$(CUR_DIR)	clean
		rm -rf $(MYAPP)
		rm -rf home_work_client
install:
		cp *.ko	$(MYAPP) 	/opt/rootfs/drv_module
obj-m += led_drv.o
5789113
关注
linux驱动学习笔记---s5pv210(一)
moonright
08-06 744
1,解压内核源码 tar -xvf linux-3.0.8.tar.bz2 2，内核的编译步骤：     a，设置交叉工具链--目标文件运行在arm处理上， 修改Makefile          195 ARCH            ?= arm          196 CROSS_COMPILE   ?= arm-none-linux-gnueabi-                  ...
S5PV210的Linux-2.6.35内核移植
07-14
S5PV210的Linux-2.6.35内核移植，很不错的资料，需要的下载哈。 PDF密码：s5pv210
嵌入式linux启动过程分析,嵌入式Linux裸机开发（二）——S5PV210启动过程分析
weixin_35915828的博客
05-08 298
嵌入式Linux裸机开发(二)——S5PV210启动过程分析一、iROM启动方式简介友善之臂Smart210开发板的SoC为三星S5PV210，S5PV210采用iROM启动方式进行启动，通过查阅三星官方S5PV210文档s5pv210_irom_applicationnote_preliminary可知，iROM启动方式支持从MoviNAND/iNand, MMC/SD Card ,pure N...
s5pv210 linux,S5PV210-零基础体验uboot
weixin_39645003的博客
05-25 158
三星官方生产的S5PV210芯片，同时他们自己也会做一个开发板卖给给他们的用户，一般都很贵，几W，这个开发板就做smdkv210uboot获得的三种途径：uboot官方、SOC官方、具体开发板的官方BSP：board support package (板级支持包，一般由开发板供应商来提供)，如果想在linux底下进行编译并且分析的东西，一定要在linux的源生目录底下解压去做，不能在Windows...
s5pv210 用汇编点亮led灯
2203_75553710的博客
02-24 525
一，分析硬件工作原理 二， 分析原理图 三， 分析数据手册 四， 找到相关的SFR（特殊功能寄存器） 五， 写代码设置寄存器得到想要的效果
基于S5PV210的Linux内核移植.pdf
09-06
本文主要介绍了将Linux内核移植到基于S5PV210处理器的嵌入式系统中的方法和步骤。该方法包括搭建基于Cortex-A8的Linux开发环境、Linux内核的配置和编译、内核移植的步骤等。 Linux内核移植的方法和步骤： 1. 搭建...
基于S5PV210的智能家居系统设计
08-30
本文主要探讨了一种创新的智能家居系统设计，该系统基于S5PV210芯片，利用先进的Linux2.6.30内核构建嵌入式系统平台，实现了高效的人机交互和远程控制功能。S5PV210处理器是一款高性能的ARM Cortex-A8芯片，它为智能...
基于S5PV210芯片的驾驶员情绪感知系统设计
04-16
针对交通领域驾驶员安全问题，提出一种基于S5PV210芯片的驾驶员情绪感知系统设计方法。采用S5PV210芯片处理器，加载linux2.6.30内核，由USB工业相机获取驾驶员人脸图像，利用一种基于稀疏表示的表情特征数值分类方法...
用 S5PV210 学习 Linux （一） 刷机（一）
最新发布
woyingle8866的博客
03-05 354
用 S5PV210 学习 Linux （一） 刷机
NodeMCU连接MQTT服务器，APP远程查看数据并控制LED、蜂鸣器和继电器
05-06
NodeMCU连接MQTT服务器，APP远程查看数据并控制LED、蜂鸣器和继电器。压缩文件内含word详细操作步骤！！！
linux clock()_linux系统移植
weixin_39746241的博客
11-25 227
文章目录内核的下载生成配置文件编译解决错误启动内核配置u-boot的环境变量编译内核并启动注意点网络支持SD/MMC支持设备树的其它修改点击下方阅读原文可访问文中超链接内核的下载还是和u-boot移植的步骤差不多，首先是要选择一个版本，然后下载镜像，确保能够正确编译成功。对于版本的选择，因为我是学习用，所以选择较新的版本，我看了一下目前版本比较新且是稳定版的是5.7.8版本，所以决定采用...
s5pv210-linux5.17移植
gq213的专栏
05-04 754
当初学习用的开发板吃灰很久了，最近移植了5.17版本kernel，学习巩固一下相关知识。 为了更深入的了解整个系统，参考uboot，自己写了spl的代码，仅用于引导kernel。根文件系统使用buildroot制作。 源码放到github和gitee。 spl: GitHub - gq213/spl-s5pv210Contribute to gq213/spl-s5pv210 development by creating an account on GitHub.ht...
S5PV210 | S5PV210上进行Linux开发
I_feige的博客
03-24 1026
S5PV210 | S5PV210上进行Linux开发 准备工作 开发板： 交叉编译工具链： S5PV210 | 安装交叉编译工具链（toolchain） 项目代码： https://gitee.com/x210bv3s/qt_x210v3s_160307 编译rootfs需要的dl文件： https://download.csdn.net/download/I_feige/75540238 dl目录是buildroot的默认下载目录，buildroot会根据你的配置从网上自动下载你需要的工具
s5pv210 linux内核移植,S5PV210(TQ210)学习笔记——内核移植与文件系统构建之二
weixin_39548776的博客
05-01 335
由于之前做过2440和6410，鉴于时间原因，这里暂时跨过其他模块的裸机驱动和uboot移植，直接进入内核移植及驱动开发方面的学习。三 设置uboot启动参数我的nfs根目录为/nfsroot，我的根文件系统目录是在该目录之下的，即/nfsroot/rootfs目录，故uboot启动参数设置如下：noinitrd console=ttySAC0 root=:/nfsroot/rootfs rw i...
S5PV210学习笔记——(1) 点亮LED
m0_57198657的博客
10-04 484
5.1第一个程序——点亮LED 5.1.1相关寄存器 由原理图，我们这里可以看到三个LED是由GPJ0_3、GPJ0_4、GPJ0_5控制的，来看一下GPJ0的相关寄存器 在手册中可以找到2.2.1节可以找到GPJ0的相关寄存器，点灯我们用到的就是GPJ0CON、GPJ0DAT两个而已 ​ 5.1.1.1 GPJ0控制寄存器 GPJ0CON, R/W, Address = 0xE020_0240 由寄存器介绍可以得知这个寄存器每四个位用来控制对应引脚的模式，...
S5PV210 构建最小linux系统（2）---->Uboot移植
qq_15506653的博客
11-08 344
S5PV210 构建最小linux系统（2）—->Uboot移植 1.u-boot官网下载最新版本u-bootftp下载地址：ftp://ftp.denx.de/pub/u-boot/ 下载版本：u-boot-2017.11-rc4.tar.bz2 2.修改顶层Makefile文件搜索 CROSS_COMPILE # set default to nothing for native builds
S5PV210控制蜂鸣器
weixin_33725807的博客
06-03 550
S5PV210带有一个蜂鸣器，十分吵闹，本章将学习如何控制蜂鸣器。 相关引脚： 蜂鸣器的操作十分简单，原理跟操作LED一样，通过控制GPDO_O这个引脚就可以达到控制蜂鸣器的目的。 1. start.Sstart.S做了下面3件事：第一步 关看门狗；第二步 设置栈，以便调用C函数；第三步 调用main函数；2. buzzer.c完整代码如下： /*buzzer.c*/#define GPD0CO...
linux照明控制软件,基于ARM-Linux的城市景观照明控制平台设计
weixin_32110907的博客
05-10 174
摘要：随着城市建设的高速发展,人们对于城市环境的要求越来越高.其中,城市的景观照明已成为展示城市风采,增添城市魅力的重要标志. 对于目前城市景观照明的研究主要存在两方面不足.一方面,国内外大多控制系统是以单体建筑照明系统为主,对于城市级,网络化的景观照明研究很少.另一方面,目前城市景观照明的控制模式大部分采用定时控制等落后控制模式.随着景观照明使用范围和数量不断增加,将各个景观照明体有效的控制,组...
S5PV210芯片驱动的矿用本安显示控制器设计与优化
本文主要探讨了基于S5PV210芯片的矿用本安型显示控制器的设计与实现。S5PV210是一款高性能的嵌入式处理器，其Cortex-A8架构具备高效能和低功耗特性，特别适合于对实时性和便携性有高要求的应用场景，如矿井中的存储...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值