RXM简易框架代码

rxm.h文件

#ifndef __RX_M_H__
#define __RX_M_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//最大驱动数量
#define RXM_MAX_DRVCOUNT 		30

//放入到某个段
#define SECTION(x)                  __attribute__((section(x)))

//不被编译器优化
#define RX_USED                     __attribute__((used))

//初始化函数模板
typedef void (*init_fn_t)(void);


//-1失败，>=0成功
typedef struct 
{
	
	int (*rxm_r1)(int fd);//读函数,1个字节
	
	int (*rxm_w1)(int fd,int buf);//写函数
	
	int (*rxm_r)(int fd,void *buf,int len);//读函数
	
	int (*rxm_w)(int fd,void *buf,int len);//写函数
	
	int (*rxm_wr)(int fd,void *sendbuf,int sendlen,void *recbuf);//发送接受函数
	
	int (*rxm_ls)(int fd,int pos);//偏移
	
	int (*rxm_io)(int fd,int mode,int value);//模式控制
		
}rxm_drv;


///
//
//
//
//
//
//
//
//下面是导出函数



//加入初级初始化段的函数(驱动初始化)
#define DRV_INIT(fn) RX_USED const init_fn_t __rx_init_##fn SECTION(".drv.1.") = fn
//加入初级初始化段的函数(API初始化)
#define API_INIT(fn) RX_USED const init_fn_t __rx_init_##fn SECTION(".api.1.") = fn



//注册驱动R1
extern  int rxm_reg_r1(unsigned char fd,int (*func)(int fd));
//注册驱动W1
extern  int rxm_reg_w1(unsigned char fd,int (*func)(int fd,int buf));
//注册驱动R
extern  int rxm_reg_r(unsigned char fd,int (*func)(int fd,void *buf,int len));
//注册驱动W
extern  int rxm_reg_w(unsigned char fd,int (*func)(int fd,void *buf,int len));
//注册驱动WR
extern  int rxm_reg_wr(unsigned char fd,int (*func)(int fd,void *sendbuf,int sendlen,void *recbuf));
//注册驱动LS
extern  int rxm_reg_ls(unsigned char fd,int (*func)(int fd,int pos));
//注册驱动IO
extern  int rxm_reg_io(unsigned char fd,int (*func)(int fd,int mode,int value));



//读取设备1字节
extern int rxm_r1(unsigned char fd);
//写入设备1字节
extern int rxm_w1(unsigned char fd, int buf);
//读取设备
extern int rxm_r(unsigned char fd, void *buf, int nbytes);
//写入设备
extern int rxm_w(unsigned char fd, void *buf, int nbytes);
//发送接受
extern int rxm_wr(unsigned char fd, void *sendbuf,int sendlen,void *recbuf);
//写入偏移
extern int rxm_ls(unsigned char fd, int pos);
//写控制命令
extern int rxm_io(unsigned char fd,int mode, int value);




typedef struct 
{
	void (*func)(void);//函数指针
  unsigned short maxcount;//计算后的计数器数值
	unsigned short curcount;//当前计数器
}rxm_tim;



//定时器服务需要定时器10ms调用一次
void rxm_time_server(void);
//设置定时触发函数
extern int rxm_addtim(int time,void (*func)(void));
//硬件延时函数
extern void rxm_delay(int time);



typedef struct
{
	void*  base;//基地址
	char*  flag;//是否有数据基地址
	unsigned int unit_size;//队列元素大小
	unsigned int fifo_size;//队列大小
	unsigned int fifo_start;
	unsigned int fifo_end;
	unsigned int fifo_count;
}RXM_FIFO;


//创建一个队列
extern RXM_FIFO* Create_FIFO(int unitsize,int fifosize);

//压入一个数据
extern void PUSH_FIFO(RXM_FIFO* fifo,void* data);

//弹出一个数据
extern void* POP_FIFO(RXM_FIFO* fifo);

//获取队列的大小
extern unsigned int FIFO_Count(RXM_FIFO* fifo);


#endif

rxm.c文件

#include "rxm.h"


#define DRV_INIT_START(fn) RX_USED const init_fn_t __rx_init_##fn SECTION(".drv.0.end") = fn

#define DRV_INIT_END(fn) RX_USED const init_fn_t __rx_init_##fn SECTION(".drv.1.end") = fn

#define API_INIT_START(fn) RX_USED const init_fn_t __rx_init_##fn SECTION(".api.0.end") = fn

#define API_INIT_END(fn) RX_USED const init_fn_t __rx_init_##fn SECTION(".api.1.end") = fn

static void RxDrv_InitStart(void){}

static void RxDrv_InitEnd(void){}

DRV_INIT_START(RxDrv_InitStart);		

DRV_INIT_END(RxDrv_InitEnd);	

static void RxApi_InitStart(void){}

static void RxApi_InitEnd(void){}

API_INIT_START(RxApi_InitStart);		

API_INIT_END(RxApi_InitEnd);	


//初始化所有注册的驱动
void RxDrv_Init(void)
{
	const init_fn_t *fn_ptr;
	for (fn_ptr = &__rx_init_RxDrv_InitStart; fn_ptr <= &__rx_init_RxDrv_InitEnd; fn_ptr++)
	{
			(*fn_ptr)();
	}
}

//初始化所有注册的Api
void RxApi_Init(void)
{
	const init_fn_t *fn_ptr;
	for (fn_ptr = &__rx_init_RxApi_InitStart; fn_ptr <= &__rx_init_RxApi_InitEnd; fn_ptr++)
	{
			(*fn_ptr)();
	}
}


//驱动设备表
rxm_drv rxm_list[RXM_MAX_DRVCOUNT];



int rxm_reg_r1(unsigned char fd,int (*func)(int fd))
{
	if(fd<RXM_MAX_DRVCOUNT)
	{
			rxm_list[fd].rxm_r1=func;
			return fd;
	}
	return -1;
}

int rxm_reg_w1(unsigned char fd,int (*func)(int fd,int buf))
{
	if(fd<RXM_MAX_DRVCOUNT)
	{
			rxm_list[fd].rxm_w1=func;
			return fd;
	}
	return -1;
}


int rxm_reg_r(unsigned char fd,int (*func)(int fd,void *buf,int len))
{
	if(fd<RXM_MAX_DRVCOUNT)
	{
			rxm_list[fd].rxm_r=func;
			return fd;
	}
	return -1;
}

int rxm_reg_w(unsigned char fd,int (*func)(int fd,void *buf,int len))
{
	if(fd<RXM_MAX_DRVCOUNT)
	{
			rxm_list[fd].rxm_w=func;
			return fd;
	}
	return -1;
}


int rxm_reg_wr(unsigned char fd,int (*func)(int fd,void *sendbuf,int sendlen,void *recbuf))
{
	if(fd<RXM_MAX_DRVCOUNT)
	{
			rxm_list[fd].rxm_wr=func;
			return fd;
	}
	return -1;
	
}


int rxm_reg_ls(unsigned char fd,int (*func)(int fd,int pos))
{
	if(fd<RXM_MAX_DRVCOUNT)
	{
			rxm_list[fd].rxm_ls=func;
			return fd;
	}
	return -1;
}


int rxm_reg_io(unsigned char fd,int (*func)(int fd,int mode,int value))
{
	if(fd<RXM_MAX_DRVCOUNT)
	{
			rxm_list[fd].rxm_io=func;
			return fd;
	}
	return -1;
}




int rxm_r1(unsigned char fd)
{
	if(fd< RXM_MAX_DRVCOUNT)
	{
		if( rxm_list[fd].rxm_r1!=NULL)
		{
			return rxm_list[fd].rxm_r1(fd);
		}
	}
	return -1;
}


int rxm_w1(unsigned char fd, int buf)
{
	if(fd< RXM_MAX_DRVCOUNT)
	{
		if( rxm_list[fd].rxm_w1 !=NULL)
		{
			return rxm_list[fd].rxm_w1(fd,buf);
		}
	}
	return -1;
}


int rxm_r(unsigned char fd, void *buf, int nbytes)
{
	if(fd< RXM_MAX_DRVCOUNT)
	{
		if( rxm_list[fd].rxm_r !=NULL)
		{
			return rxm_list[fd].rxm_r(fd,buf,nbytes);
		}
	}
	return -1;
}


int rxm_w(unsigned char fd, void *buf, int nbytes)
{
	if(fd< RXM_MAX_DRVCOUNT)
	{
		if( rxm_list[fd].rxm_w !=NULL)
		{
			return rxm_list[fd].rxm_w(fd,buf,nbytes);
		}
	}
	return -1;
}


int rxm_wr(unsigned char fd, void *sendbuf,int sendlen,void *recbuf)
{
	if(fd< RXM_MAX_DRVCOUNT)
	{
		if( rxm_list[fd].rxm_wr !=NULL)
		{
			return rxm_list[fd].rxm_wr(fd,sendbuf,sendlen,recbuf);
		}
	}
	return -1;
}


int rxm_ls(unsigned char fd, int pos)
{
	if(fd< RXM_MAX_DRVCOUNT)
	{
		if( rxm_list[fd].rxm_ls !=NULL)
		{
			return rxm_list[fd].rxm_ls(fd,pos);
		}
	}
	return -1;
}


int rxm_io(unsigned char fd,int mode, int value)
{
	if(fd< RXM_MAX_DRVCOUNT)
	{
		if( rxm_list[fd].rxm_io !=NULL)
		{
			return rxm_list[fd].rxm_io(fd,mode,value);
		}
	}
	return -1;
}



//定时触发函数
rxm_tim tim[RXM_MAX_DRVCOUNT];
//当前定时触发函数数量
int timcount=0;

//立即触发函数
rxm_tim timzero[RXM_MAX_DRVCOUNT];
int timezerocount=0;


int dcount=0;

//定时器服务
void rxm_time_server(void)
{
	int i=0;
	for(i=0;i<timcount;i++)
	{
		if(tim[i].curcount>0)
		{
			tim[i].curcount--;
		}
	}
	
	if(dcount>0)
	{
		dcount--;
	}
	
}


//注册定时触发
int rxm_addtim(int time,void (*func)(void))
{ 
	if(timcount<10)
	{
		if(func!=NULL)
		{
			if(time==0)
			{
				timzero[timezerocount].func=func;
				timzero[timezerocount].maxcount=0;
				timzero[timezerocount].curcount=0;
				timezerocount++;
			}
			else
			{
				tim[timcount].func=func;
				tim[timcount].maxcount=time/10;
				tim[timcount].curcount=time/10;
				timcount++;
			}
			return 0;
		}
	}
	return -1;
}


void Init_Tim()
{
	int i=0;
		//初始化定时函数结构体
	for(i=0;i<RXM_MAX_DRVCOUNT;i++)
	{
		tim[i].curcount=0xFFFF;
		timzero[i].curcount=0xFFFF;
	}
}

void rxm_delay(int time)
{
	dcount=time/10;
	while(dcount>0);
}

int main(void)
{
	int i=0;
	Init_Tim();
	RxDrv_Init();
	RxApi_Init();

	for (;;)
	{
		
		//立即触发函数
		for(i=0;i<timezerocount;i++)
		{
				timzero[i].func();//触发函数
		}
		
		//延时触发函数
		for(i=0;i<timcount;i++)
		{
			if(tim[i].curcount==0)
			{
				tim[i].curcount=tim[i].maxcount;
				tim[i].func();//触发函数
			}
		}
		
	}
}




RXM_FIFO* Create_FIFO(int unitsize,int fifosize)
{
	void* dataspace =(void*)malloc(unitsize*fifosize);
	char* flagspace =(char*)malloc(fifosize);
	RXM_FIFO* fifo =(void*)malloc(sizeof(RXM_FIFO));
	
	memset(dataspace,0,unitsize*fifosize);
	memset(flagspace,0,fifosize);
	memset(fifo,0,sizeof(RXM_FIFO));
	
	fifo->base=dataspace;
	fifo->flag=flagspace;
	fifo->fifo_start=0;
	fifo->fifo_end=0;
	fifo->fifo_size=fifosize;
	fifo->unit_size=unitsize;
	fifo->fifo_count=0;
	return fifo;
}


void PUSH_FIFO(RXM_FIFO* fifo,void* data)
{
	if(fifo!=NULL)
	{
		unsigned char* fifodata = fifo->base;
		char* flagdata = fifo->flag;
		int end =fifo->fifo_end;
		
		if(flagdata[end]==0)
		{
			flagdata[end]=1;
			fifodata=fifodata+fifo->fifo_end*fifo->unit_size;
			memcpy(fifodata,data,fifo->unit_size);
			
			if(end<(fifo->fifo_size-1))
			{
				end++;
			}
			else
			{
				end=0;
			}
			fifo->fifo_end=end;
			fifo->fifo_count++;
		}
	}
}

void* POP_FIFO(RXM_FIFO* fifo)
{
	static unsigned char data[256];
	if(fifo!=NULL)
	{
		unsigned char* fifodata = fifo->base;
		char* flagdata = fifo->flag;
		int start =fifo->fifo_start;
		
		if(flagdata[start]==1)
		{
			flagdata[start]=0;
			fifodata=fifodata+fifo->fifo_start*fifo->unit_size;
			memcpy(data,fifodata,fifo->unit_size);
			
			if(start<(fifo->fifo_size-1))
			{
				start++;
			}
			else
			{
				start=0;
			}
			fifo->fifo_start=start;
			fifo->fifo_count--;
			return data;
		}
	}
	return NULL;
}

unsigned int FIFO_Count(RXM_FIFO* fifo)
{
	if(fifo!=NULL)
	{
		return fifo->fifo_count;
	}
	return 0;
}