文件IO编程五：调试输出到文本+目录操作

已于 2023-09-03 19:01:56 修改
阅读量94 收藏
点赞数
分类专栏： Linux文件IO编程 文章标签： linux
于 2023-09-03 18:55:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53809203/article/details/132653154
版权

一、将调试打印信息存储到文本中

int XPRINTF(char *text)//2、调试功能 定位到文本中
{
	
	//1、以可写的方式打开log.txt,如果文件不存在则新建，如果存在了追加
	FILE * fp = fopen(LOG_FILE,"ab");
	if(fp == NULL)
	{
		printf("fopen %s error\n",LOG_FILE);
		return -1;
	}
	//2、将传递进来的信息写入到调试文本中 fprintf
	fprintf(fp,"%s",text);
	//3、关闭文件
	fclose(fp);
}

想个办法： 实现 每一次打开软件时，log.txt是从头记录的

//初始化调试文本
int initLog()
{
	//1、打开文本 并且 清空内容 ，如果不存在，新建
	FILE * fp = fopen(LOG_FILE,"wb+");
	if(fp == NULL)
	{
		printf("fopen %s error\n",LOG_FILE);
		return -1;
	}
	//3、关闭文件
	fclose(fp);
}

将这个初始化调试文本函数放在main函数中初始化，即可。

二、目录操作API

效果： 实现一个程序，自动将我们某个指定的目录下所有的bmp图片 加载到 程序中。

思路： 1、打开指定的目录文件  

             2、读取目录，将目录下的每个文件的名字 加载 到  程序中  

             3、关闭目录文件

1、打开目录文件（opendir）

头文件：
    #include <sys/types.h>
    #include <dirent.h>
函数原型：
    DIR *opendir(const char *name);

函数作用：
        打开一个目录
参数：
        name--》你要打开的目录 路径+ 名字
返回值：
        成功返回 目录指针
        失败返回 NULL ，错误被标记(可以使用perror函数打印错误原因)

2、读取目录（readdir）

头文件：
    #include <dirent.h>
函数原型：
    struct dirent *readdir(DIR *dirp);
函数作用：
        读取目录 
参数：        
        dirp --》你要读取哪个目录，将这个目录的目录指针传递进来
返回值：
        成功返回  结构体指针  struct dirent* -->这个结构体指针记录了读取目录下文件的信息
        失败或者 读完了 返回  NULL 

struct dirent {
   ino_t          d_ino;       /* 索引号 */
   off_t          d_off;       /* 偏移量 */
   unsigned short d_reclen;    /* 项的长度 */
   unsigned char  d_type;      /* 文件的类型 */
   char           d_name[256]; /* 文件名 */
};

文件的类型：

       DT_BLK      This is a block device. 块设备文件

       DT_CHR      This is a character device.

       DT_DIR      This is a directory.  目录文件

       DT_FIFO     This is a named pipe (FIFO).

       DT_LNK      This is a symbolic link.

       DT_REG      This is a regular file. 普通文件

       DT_SOCK     This is a UNIX domain socket.

       DT_UNKNOWN  The file type is unknown.

注意： 调用一次    readdir函数，只能返回 该目录下一个文件的信息，如果想要获取这个目录所有的文件信息，可以循环读取

3、关闭目录文件（closedir）

    #include <sys/types.h>

    #include <dirent.h>

    int closedir(DIR *dirp);

4、相关练习

//opendir.c
#include<stdio.h>
#include <sys/types.h>
#include <dirent.h>
#include<string.h>

#define BMP_NUMBER	100  //最大只能支持读取100张图片
#define BMPDIR		"./resource"
//效果：从 指定的目录中读取 所有bmp图片的名字，存储到数组中



int main()
{
	char bmpName[BMP_NUMBER][256]={0};//存储图片的名字
	int bmpCount=0; //记录当前加载进来的bmp图片数量
	int i;
	
	//打开目录
	DIR *dirfp = opendir(BMPDIR);
	if(dirfp == NULL)
	{
		perror("opendir error");
		return -1;
	}
	while(1)
	{
		//读取目录
		struct dirent *info = readdir(dirfp);
		if(info == NULL)//如果读取完了 退出
			break;
		
		printf("d_name:%s\n",info->d_name); //info->d_name  ---1.bmp
		
		//去除 . 和 ..     而且 文件 是 普通 文件
		if(info->d_name[0] != '.' && info->d_type == DT_REG)
		{
			//bmpName[0]---> ./reource/1.bmp
			//将图片的路径 和 名字 拼接起来
			char pathName[256]={0};
			sprintf(pathName,"%s/%s",BMPDIR,info->d_name);
			strcpy(bmpName[bmpCount++],pathName); // info->d_name[256]   char d_name[256] = "1.bmp"
		}
		
	}
	//将存储到数组中所有的图片名字都打印出来
	for(i=0; i<bmpCount; i++)
	{
		printf("bmpName[%d]:%s\n",i,bmpName[i]);
	}
	
	//关闭目录文件
	closedir(dirfp);
	
	return 0;
}

实现 只拷贝 bmp图片文件到数组中，也就是判断当前普通文件是否是bmp图片文件：

#include<stdio.h>
#include <sys/types.h>
#include <dirent.h>
#include<string.h>

#define BMP_NUMBER	100  //最大只能支持读取100张图片
//#define BMPDIR		"./resource"
//效果：从 指定的目录中读取 所有bmp图片的名字，存储到数组中

/*
dirOpt: 在指定的目录dirName下查找后缀名为suffix的所有的文件，并且保存在str这里
参数： 
	dirName：你要操作哪个目录，将这个目录的路径+名字传递进来
	str:读取目录之后，将该目录下所有的文件名存储到这里
	suffix:后缀名 ,注意不需要传递 .进来，比如现在记录bmp图片 传递  "bmp"即可
返回值：
	成功返回 加载的文件的数量
	失败返回 -1
*/
int dirOpt(char *dirName,char (*str)[256],char *suffix) //char bmpName[BMP_NUMBER][256]={0};
{
	int fileCount=0; //记录当前加载进来的bmp图片数量
	int i;
	
	//打开目录
	DIR *dirfp = opendir(dirName);
	if(dirfp == NULL)
	{
		perror("opendir error");
		return -1;
	}
	while(1)
	{
		//读取目录
		struct dirent *info = readdir(dirfp);
		if(info == NULL)//如果读取完了 退出
			break;
		
		printf("d_name:%s\n",info->d_name); //info->d_name  ---1.bmp
		
		//去除 . 和 ..     而且 文件 是 普通 文件
		if(info->d_name[0] != '.' && info->d_type == DT_REG)
		{
			//判断当前普通文件是后缀名为.bmp或者.BMP的图片文件
			//1.txt  2.bmp  3.c  4.h 5.BMP
			//思路：文件名字info->d_name中一定有.bmp  或者.BMP 
			//思考有没有一个这样子的函数：在一个字符串（1.bmp）中判断是否包含另外一个字符串(.bmp)
			/*  char *ret1 = strstr(info->d_name, ".bmp"); //strstr 函数在一个字符串中查找指定的字符串
			 char *ret2 = strstr(info->d_name, ".BMP");
			 if(ret1 != NULL || ret2 != NULL) //strstr 如果找到了返回一个地址，没找到返回NULL */
			int ret1 = strcmp(info->d_name+strlen(info->d_name)-3,suffix);
			//int ret2 = strcmp(info->d_name+strlen(info->d_name)-3,"BMP");
			if(ret1 ==0) //|| ret2 == 0) //strcmp比较两个字符串，如果相同返回0
			 {
				 //bmpName[0]---> ./reource/1.bmp
				//将图片的路径 和 名字 拼接起来
				char pathName[256]={0};
				sprintf(pathName,"%s/%s",dirName,info->d_name);
				strcpy(str[fileCount++],pathName); // info->d_name[256]   char d_name[256] = "1.bmp"
			 }			
		}
		
	}
	//将存储到数组中所有的图片名字都打印出来
	for(i=0; i<fileCount; i++)
	{
		printf("str[%d]:%s\n",i,str[i]);
	}
	
	//关闭目录文件
	closedir(dirfp);
	
	return fileCount;
}


int main()
{
	char bmpName[BMP_NUMBER][256]={0};//存储图片的名字
	int bmpCount = dirOpt("./resource", bmpName,"bmp");
	
	printf("bmpCount:%d\n",bmpCount);
	
	return 0;
}

三、作业

           做一个简单的 电子相册：
            1、在指定的目录下自动加载所有的图片 到 程序中 
            2、在液晶屏上  同时显示 4张 bmp图片 
            3、当点击 某张图片时，放大
            4、当图片放大到全屏时，还可以退出

1、新建项目

2、c_source

3、include

4、res

5、相关代码

（1）main.c

#include "showbmp.h"
#include "ts.h"
#include "debug.h"

#define BMP_NUMBER	4



//字符串拼接 sprintf 
char text[1024]={0};


int main(int argc,char*argv[])
{
	initLog();

	int ts_x,ts_y;
	char bmpName[BMP_NUMBER][256]={0};
	//初始化图片
	int bmpCount = dirOpt("./res",bmpName,"bmp");
	if(bmpCount == -1)
	{
		printf("init bmpdir error\n");
		return -1;
	}
	int bmpFlag = 0;//用来控制图片显示的标志位
	
	XPRINTF("main start.......\n");
	//printf("main start.......\n");
	//初始化
	if(!initLcdAndMmap()) //if(initLcdAndMmap() = false)
	{
		//如果初始化失败
		XPRINTF("initLcdAndMmap error\n");
		//printf("initLcdAndMmap error\n");
		return -1;
	}
	XPRINTF("initLcdAndMmap success.......\n");
	
	
	int indexPos=-1;//你当前点击的缩略图中的位置
	
	while(1)
	{
		showBmp_solv_xy(bmpName[0],100,100);
		showBmp_solv_xy(bmpName[1],500,100);
		showBmp_solv_xy(bmpName[2],100,250);
		showBmp_solv_xy(bmpName[3],500,250);
		ts_func(&ts_x,&ts_y);//触摸屏的代码调用一次，就是表示获取一次坐标，点击一次
		//判断触摸的坐标
		if((ts_x>=100 && ts_x<=(100+200))&& (ts_y >=100 && ts_y<=(100+120)))//在位置0 ---全屏显示 bmpName[0]
		{
			indexPos = 0;
		}
		else if((500<=ts_x && ts_x<=(500+200))&&(100<=ts_y && ts_y<=(100+120)))//在位置1 ---显示 bmpName[1]
		{
			indexPos = 1;
		}
		else if((100<=ts_x && ts_x<=(100+200))&&(250<=ts_y && ts_y<=(250+120)))//在位置2 ---显示 bmpName[2]
		{
			indexPos = 2;
		}
		else if((500<=ts_x && ts_x<=(500+200))&&(250<=ts_y && ts_y<=(250+120)))//在位置3 ---显示 bmpName[3]
		{
			indexPos = 3;
		}
		else{//如果点击的是其他区域,回到开头又重新判断坐标
			XPRINTF("你当前点击的是其他区域......................\n");
			continue;
		}
		showBmp_effect2(bmpName[indexPos]);
		bmpFlag = indexPos;
		while(1)
		{
			ts_func(&ts_x,&ts_y);//触摸屏的代码调用一次，就是表示获取一次坐标，点击一次
			if(ts_x<=400 && ts_y<=240)//左上角
			{
				bmpFlag--;
				
				//如果当前图片是第一张，点击左边时， 应该让其回到最后一张
				if(bmpFlag == -1){
					XPRINTF("当前是第一张，点击左边，回到最后一张\n");
					bmpFlag = BMP_NUMBER -1;
				}
				bzero(text,1024);
				sprintf(text,"left bmpFlag:%d\n",bmpFlag);
				XPRINTF(text);
			}
			else if(ts_x>400 && ts_y<=240){ //右上角
				
				bmpFlag++; //4 
				
				//如果当前图片是最后一张，点击右边时，应该让其回到第一张
				if(bmpFlag == BMP_NUMBER){
					XPRINTF("当前是最后一张，点击右边边，回到第一张\n");
					bmpFlag = 0;
				}
				bzero(text,1024);
				sprintf(text,"right bmpFlag:%d\n",bmpFlag);
				XPRINTF(text);
			}
			else if(ts_y>240) //退出
			{
				break;
			}
			//显示
			int ret = showBmp_effect2(bmpName[bmpFlag]);//bmpName[bmpFlag]---->char bmp[256]  
			if(ret == -1)//显示失败
			{
				bzero(text,1024);
				sprintf(text,"showBmp error %s\n",bmpName[bmpFlag]);
				XPRINTF(text);
			}
			else 
				XPRINTF("-------------showBmp success---------------\n\n");
		}
	}
	
	//解除初始化
	uinitLcd();

	return 0;
}

（2）diropt.c

#include<stdio.h>
#include <sys/types.h>
#include <dirent.h>
#include<string.h>

//效果：从 指定的目录中读取 所有bmp图片的名字，存储到数组中

/*
dirOpt: 在指定的目录dirName下查找后缀名为suffix的所有的文件，并且保存在str这里
参数： 
	dirName：你要操作哪个目录，将这个目录的路径+名字传递进来
	str:读取目录之后，将该目录下所有的文件名存储到这里
	suffix:后缀名 ,注意不需要传递 .进来，比如现在记录bmp图片 传递  "bmp"即可
返回值：
	成功返回 加载的文件的数量
	失败返回 -1
*/
int dirOpt(char *dirName,char (*str)[256],char *suffix) //char bmpName[BMP_NUMBER][256]={0};
{
	int fileCount=0; //记录当前加载进来的bmp图片数量
	int i;
	
	//打开目录
	DIR *dirfp = opendir(dirName);
	if(dirfp == NULL)
	{
		perror("opendir error");
		return -1;
	}
	while(1)
	{
		//读取目录
		struct dirent *info = readdir(dirfp);
		if(info == NULL)//如果读取完了 退出
			break;
		
		printf("d_name:%s\n",info->d_name); //info->d_name  ---1.bmp
		
		//去除 . 和 ..     而且 文件 是 普通 文件
		if(info->d_name[0] != '.' && info->d_type == DT_REG)
		{
			//判断当前普通文件是后缀名为.bmp或者.BMP的图片文件	
			int ret1 = strcmp(info->d_name+strlen(info->d_name)-3,suffix);
			if(ret1 ==0) //strcmp比较两个字符串，如果相同返回0
			 {
				 //bmpName[0]---> ./reource/1.bmp
				//将图片的路径 和 名字 拼接起来
				char pathName[256]={0};
				sprintf(pathName,"%s/%s",dirName,info->d_name);
				strcpy(str[fileCount++],pathName); // info->d_name[256]   char d_name[256] = "1.bmp"
			 }			
		}
		
	}
	//将存储到数组中所有的图片名字都打印出来
	/* for(i=0; i<fileCount; i++)
	{
		printf("str[%d]:%s\n",i,str[i]);
	} */
	
	//关闭目录文件
	closedir(dirfp);
	
	return fileCount;
}

（3）showbmp.c

#include "showbmp.h"
#include "debug.h"

int lcdfd;
int *lcd_p;

extern char text[1024];

//得到bmp图片的宽度
int getBmpWidth(BITMAPINFOHEADER *head)
{
	bzero(text,1024);	
	sprintf(text,"Width:%d\n",head->biWidth);//图像的宽度
	XPRINTF(text);
	return head->biWidth;
}
//得到bmp图片的高度
int getBmpHeight(BITMAPINFOHEADER *head)
{
	bzero(text,1024);
	sprintf(text,"Height:%d\n",head->biHeight);//图像的高度
	XPRINTF(text);
	return head->biHeight;
}
//得到bmp图片的大小
int getBmpSize(BITMAPINFOHEADER *head)
{
	bzero(text,1024);
	sprintf(text,"fileSize:%d\n",head->biSizeImage+54);//文件的大小
	XPRINTF(text);
	return head->biSizeImage+54;
}

//初始化液晶屏 和 内存映射
bool initLcdAndMmap()
{
	XPRINTF("initLcdAndMmap start.......\n");
	//1、打开液晶屏文件  
	lcdfd = open("/dev/fb0",O_RDWR);
	if(lcdfd == -1)
	{
		XPRINTF("open lcd error");//perror将错误的原因打印出来
		return false;
	}
	//将液晶屏文件 通过内存映射mmap的方式 映射到虚拟内存空间的某一块空间上，得到这一块内存的起始地址，后续我们操作这片内存空间，就相当于直接操作液晶屏文件
	lcd_p = mmap(NULL, //你要映射的内存空间的起始地址，为NULL系统自动给你分配
		 800*480*4,//你要映射的内存空间的大小
		 PROT_READ|PROT_WRITE,//映射的权限 
		 MAP_SHARED,//1、进程共享  2、对应的文件会同步发生变化 	
		 lcdfd,//映射液晶屏文件
		 0//偏移量 ，默认为0
		);
	if(lcd_p == MAP_FAILED)	
	{
		XPRINTF("mmap lcd error\n");
		return false;
	}
	
	return true;
}
//解除初始化
void uinitLcd()
{
	//解除映射
	munmap(lcd_p, 800*480*4);
	//5、关闭液晶屏文件、bmp图片文件	
	close(lcdfd);
}

/*
showBmp:在(0,0)的位置上显示一张800*480的图片
返回值：
		成功返回 0
		失败返回 -1
*/
int showBmp(char *bmpPath)
{
	bzero(text,1024);
	sprintf(text,"showBmp bmpPath:%s\n",bmpPath);
	XPRINTF(text);
	int i,j;
	int tempbuf[800*480];
	int lcdbuf[800*480];
	
	//2、打开bmp图片文件  
	int bmpfd = open(bmpPath,O_RDONLY);
	if(bmpfd == -1)
	{
		XPRINTF("open bmpfile error");//perror将错误的原因打印出来
		return -1;
	}
	
	//读取bmp图片的文件头 + 信息头数据
	BITMAPFILEHEADER fileHead;
	BITMAPINFOHEADER infoHead;
	
	read(bmpfd,&fileHead,14);//读取14个字节
	read(bmpfd,&infoHead,40);//读取40个字节
	
	//判断是否宽度等于 800 
	if(BMP_WIDTH != getBmpWidth(&infoHead))
	{
		XPRINTF("你要打印的图片宽度 不等于 800 请重新修改图片 error\n");
		//5、bmp图片文件	
		close(bmpfd);
		return -1;
	}
	//判断是否高度等于 480
	if(BMP_HEIGHT != getBmpHeight(&infoHead))
	{
		XPRINTF("你要打印的图片高度 不等于 480 请重新修改图片 error\n");
		//5、bmp图片文件	
		close(bmpfd);
		return -1;
	}
	
	//3、读取bmp图片的数据
	char bmpbuf[800*480*3]={0};
	read(bmpfd,bmpbuf,800*480*3);
	//将bmp图片每个像素点的 B G R -->A R G  B
	for(i=0,j=0; i<800*480;i++,j+=3)
	{
		tempbuf[i] = 0x00<<24 | bmpbuf[j+2]<<16 | bmpbuf[j+1]<<8 | bmpbuf[j];
	}
	//上下180度颠倒 
	for(j=0; j<480; j++)
	{
		for(i=0; i<800; i++)
		{
			lcd_p[j*800+i] = tempbuf[(479-j)*800+i];
		}
	}
	
	close(bmpfd);
	
	return 0;
}

//在(0,0)的位置上显示一张800*480切割4倍后的200*120的图片
int showBmp_solv(char *bmpPath)
{
	int i,j;
	int tempbuf[800*480];
	int lcdbuf[800*480];
	int minbuf[200*120];
	
	//2、打开bmp图片文件  
	int bmpfd = open(bmpPath,O_RDONLY);
	if(bmpfd == -1)
	{
		XPRINTF("open bmpfile error");//perror将错误的原因打印出来
		return -1;
	}
	
	//读取bmp图片的文件头 + 信息头数据
	BITMAPFILEHEADER fileHead;
	BITMAPINFOHEADER infoHead;
	
	read(bmpfd,&fileHead,14);//读取14个字节
	read(bmpfd,&infoHead,40);//读取40个字节
	
	//判断是否宽度等于 800 
	if(BMP_WIDTH != getBmpWidth(&infoHead))
	{
		XPRINTF("你要打印的图片宽度 不等于 800 请重新修改图片 error\n");
		//5、bmp图片文件	
		close(bmpfd);
		return -1;
	}
	//判断是否高度等于 480
	if(BMP_HEIGHT != getBmpHeight(&infoHead))
	{
		XPRINTF("你要打印的图片高度 不等于 480 请重新修改图片 error\n");
		//5、bmp图片文件	
		close(bmpfd);
		return -1;
	}
	
	//3、读取bmp图片的数据
	char bmpbuf[800*480*3]={0};
	read(bmpfd,bmpbuf,800*480*3);
	//将bmp图片每个像素点的 B G R -->A R G  B
	for(i=0,j=0; i<800*480;i++,j+=3)
	{
		tempbuf[i] = 0x00<<24 | bmpbuf[j+2]<<16 | bmpbuf[j+1]<<8 | bmpbuf[j];
	}
	//上下180度颠倒 
	for(j=0; j<480; j++)
	{
		for(i=0; i<800; i++)
		{
			lcdbuf[j*800+i] = tempbuf[(479-j)*800+i];
		}
	}
	//切割算法 
	//思路：每隔4行取一行像素，在每一行中，每4个像素点取一个像素点
	//将lcdbuf --> 800*480  切割成  200*120 存储到 minbuf
	for(j=0; j<120; j++)
	{
		for(i=0; i<200; i++)
		{
			minbuf[j*200+i] = lcdbuf[j*4*800+i*4]; //i == 0 4 8 12 16
		}
	}
	//切割之后的数据存储在 minbuf ---200*120
	//显示 ，赋值到 lcd_p
	for(j=0; j<120; j++)
	{
		for(i=0; i<200; i++)
		{
			lcd_p[j*800+i] = minbuf[j*200+i];
		}
	}
	
	close(bmpfd);
}
//在(posX,posY)的位置上显示一张800*480切割4倍后的200*120的图片
//
int showBmp_solv_xy(char *bmpPath,int posX,int posY)
{
	int i,j;
	int tempbuf[800*480];
	int lcdbuf[800*480];
	int minbuf[200*120];
	
	//2、打开bmp图片文件  
	int bmpfd = open(bmpPath,O_RDONLY);
	if(bmpfd == -1)
	{
		XPRINTF("open bmpfile error");//perror将错误的原因打印出来
		return -1;
	}
	
	//读取bmp图片的文件头 + 信息头数据
	BITMAPFILEHEADER fileHead;
	BITMAPINFOHEADER infoHead;
	
	read(bmpfd,&fileHead,14);//读取14个字节
	read(bmpfd,&infoHead,40);//读取40个字节
	
	//判断是否宽度等于 800 
	if(BMP_WIDTH != getBmpWidth(&infoHead))
	{
		XPRINTF("你要打印的图片宽度 不等于 800 请重新修改图片 error\n");
		//5、bmp图片文件	
		close(bmpfd);
		return -1;
	}
	//判断是否高度等于 480
	if(BMP_HEIGHT != getBmpHeight(&infoHead))
	{
		XPRINTF("你要打印的图片高度 不等于 480 请重新修改图片 error\n");
		//5、bmp图片文件	
		close(bmpfd);
		return -1;
	}
	
	//3、读取bmp图片的数据
	char bmpbuf[800*480*3]={0};
	read(bmpfd,bmpbuf,800*480*3);
	//将bmp图片每个像素点的 B G R -->A R G  B
	for(i=0,j=0; i<800*480;i++,j+=3)
	{
		tempbuf[i] = 0x00<<24 | bmpbuf[j+2]<<16 | bmpbuf[j+1]<<8 | bmpbuf[j];
	}
	//上下180度颠倒 
	for(j=0; j<480; j++)
	{
		for(i=0; i<800; i++)
		{
			lcdbuf[j*800+i] = tempbuf[(479-j)*800+i];
		}
	}
	//切割算法 
	//思路：每隔4行取一行像素，在每一行中，每4个像素点取一个像素点
	//将lcdbuf --> 800*480  切割成  200*120 存储到 minbuf
	for(j=0; j<120; j++)
	{
		for(i=0; i<200; i++)
		{
			minbuf[j*200+i] = lcdbuf[j*4*800+i*4]; //i == 0 4 8 12 16
		}
	}
	//切割之后的数据存储在 minbuf ---200*120
	//显示 ，赋值到 lcd_p
	//在指定的位置(posX,posY)上显示
	for(j=0; j<120; j++)
	{
		for(i=0; i<200; i++)
		{
			//lcd_p[posY*800+posX+j*800+i] = minbuf[j*200+i];
			lcd_p[(posY+j)*800+i+posX] = minbuf[j*200+i];
		}
	}
	
	close(bmpfd);
}
/*
showBmp_effects1：动态效果显示一张图片
*/
int showBmp_effects1(char *bmpPath)
{
	bzero(text,1024);
	sprintf(text,"showBmp bmpPath:%s\n",bmpPath);
	XPRINTF(text);
	int i,j;
	int tempbuf[800*480];
	int lcdbuf[800*480];
	int buf[800*480];
	
	//2、打开bmp图片文件  
	int bmpfd = open(bmpPath,O_RDONLY);
	if(bmpfd == -1)
	{
		XPRINTF("open bmpfile error");//perror将错误的原因打印出来
		return -1;
	}
	
	//读取bmp图片的文件头 + 信息头数据
	BITMAPFILEHEADER fileHead;
	BITMAPINFOHEADER infoHead;
	
	read(bmpfd,&fileHead,14);//读取14个字节
	read(bmpfd,&infoHead,40);//读取40个字节
	
	//判断是否宽度等于 800 
	if(BMP_WIDTH != getBmpWidth(&infoHead))
	{
		XPRINTF("你要打印的图片宽度 不等于 800 请重新修改图片 error\n");
		//5、bmp图片文件	
		close(bmpfd);
		return -1;
	}
	//判断是否高度等于 480
	if(BMP_HEIGHT != getBmpHeight(&infoHead))
	{
		XPRINTF("你要打印的图片高度 不等于 480 请重新修改图片 error\n");
		//5、bmp图片文件	
		close(bmpfd);
		return -1;
	}
	
	//3、读取bmp图片的数据
	char bmpbuf[800*480*3]={0};
	read(bmpfd,bmpbuf,800*480*3);
	//将bmp图片每个像素点的 B G R -->A R G  B
	for(i=0,j=0; i<800*480;i++,j+=3)
	{
		tempbuf[i] = 0x00<<24 | bmpbuf[j+2]<<16 | bmpbuf[j+1]<<8 | bmpbuf[j];
	}
	//上下180度颠倒 
	for(j=0; j<480; j++)
	{		
		for(i=0; i<800; i++)
		{
			buf[j*800+i] = tempbuf[(479-j)*800+i];
		}
	}
	//动态效果 ，延时显示
	for(j=0; j<480; j++)
	{
		usleep(1000);//通过微妙级别的延时 让数据分时显示
		for(i=0; i<800; i++)
		{
			lcd_p[j*800+i] = buf[j*800+i];
		}
	}
	
	close(bmpfd);
	
	return 0;
}

//在(0,0)的位置上显示一张800*480的图片
int showBmp_effect2(char *bmpPath)//中间上下展开
{
	int i,j,k;
	int tempbuf[800*480];
	//int lcdbuf[800*480];
	
	//2、打开bmp图片文件  
	int bmpfd = open(bmpPath,O_RDONLY);
	if(bmpfd == -1)
	{
		perror("open bmpfile error");//perror将错误的原因打印出来
		printf("没有该图片\n");
		return -1;
	}
	
	//读取bmp图片的文件头 + 信息头数据
	BITMAPFILEHEADER fileHead;
	BITMAPINFOHEADER infoHead;
	
	read(bmpfd,&fileHead,14);//读取14个字节
	read(bmpfd,&infoHead,40);//读取40个字节
	
	//判断是否宽度等于 800 
	if(BMP_WIDTH != getBmpWidth(&infoHead))
	{
		printf("你要打印的图片宽度 不等于 800 请重新修改图片 error\n");
		//5、bmp图片文件	
		close(bmpfd);
		return -1;
	}
	//判断是否高度等于 480
	if(BMP_HEIGHT != getBmpHeight(&infoHead))
	{
		printf("你要打印的图片高度 不等于 480 请重新修改图片 error\n");
		//5、bmp图片文件	
		close(bmpfd);
		return -1;
	}
	
	//3、读取bmp图片的数据
	char bmpbuf[800*480*3]={0};
	read(bmpfd,bmpbuf,800*480*3);
	//将bmp图片每个像素点的 B G R -->A R G  B
	for(i=0,j=0; i<800*480;i++,j+=3)
	{
		tempbuf[i] = 0x00<<24 | bmpbuf[j+2]<<16 | bmpbuf[j+1]<<8 | bmpbuf[j];
	}
	//上下180度颠倒 
	for(j=240,k=241; j>=0,k<480; j--,k++)
	{
		usleep(10000);
		for(i=0; i<800; i++)
		{
			lcd_p[j*800+i] = tempbuf[(479-j)*800+i];
			lcd_p[k*800+i] = tempbuf[(479-k)*800+i];
		}
	}
	close(bmpfd);
}

（4）showbmp.h

#ifndef __SHOWBMP_H_
#define __SHOWBMP_H_

#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include <sys/mman.h>
#include <stdbool.h>

#define UINT  unsigned short
#define DWORD unsigned  int
#define LONG unsigned  int
#define WORD unsigned short

#define BMP_WIDTH 	800
#define BMP_HEIGHT 	480


//前面14个字节 文件信息头
typedef struct tagBITMAPFILEHEADER{
	UINT bfType;  //2
	DWORD bfSize; //DWORD 4
	UINT bfReserved1; //2
	UINT bfReserved2; //2
	DWORD bfOffBits; //DWORD 4
}BITMAPFILEHEADER;

//40个字节 位图信息头
typedef struct tagBITMAPINFOHEADER{ /* bmih */
	DWORD biSize; //DWORD 4
	LONG biWidth; //4  图像的宽度
	LONG biHeight;//4  图像的高度
	WORD biPlanes; //2
	WORD biBitCount;//2 
	DWORD biCompression; //DWORD 4
	DWORD biSizeImage; //DWORD 4
	LONG biXPelsPerMeter;//4
	LONG biYPelsPerMeter;//4
	DWORD biClrUsed; //DWORD 4
	DWORD biClrImportant; //DWORD 4
}BITMAPINFOHEADER;

extern int lcdfd;
extern int *lcd_p;


int getBmpWidth(BITMAPINFOHEADER *head);
int getBmpHeight(BITMAPINFOHEADER *head);
int getBmpSize(BITMAPINFOHEADER *head);
bool initLcdAndMmap();
void uinitLcd();
int showBmp(char *bmpPath);
int showBmp_solv(char *bmpPath);
int showBmp_solv_xy(char *bmpPath,int posX,int posY);


#endif

（5）ts.c

#include "ts.h"
#include "debug.h"


extern char text[1024];

/*触摸屏代码*/
int ts_func(int *x,int *y)
{
	XPRINTF("ts_func 请用手触摸屏幕.......\n");
	//1）打开触摸屏设备文件 ---
	int tsfd = open("/dev/input/event0",O_RDWR);
	if(tsfd == -1)
	{
		XPRINTF("open /dev/input/event0 error\n");
		return -1;
	}
	
	while(1)
	{
		//2)分析 触摸屏的数据是什么数据类型？？？
		//输入子系统计算完结果之后会将这个结果存储在结构体中
		struct input_event info;
		
		//3）读取触摸屏数据 --如果你没有用手触摸屏幕，当前会阻塞在这里
		read(tsfd,&info,sizeof(struct input_event));
		
		//判断当前发生的是触摸屏事件,接着判断触发的是X轴事件
		if(info.type == EV_ABS && info.code == ABS_X)
			*x = info.value;
		//判断当前发生的是触摸屏事件,接着判断触发的是Y轴事件
		if(info.type == EV_ABS && info.code == ABS_Y)
			*y = info.value;
		
		//松开的时候，才进行打印  type:1 code:330 value:0
		if(info.type == EV_KEY && info.code == BTN_TOUCH &&  info.value == 0){
			
			//如果你的板子是黑色的，那么需要进行坐标转换(1024,600) ---(800,480)
			//*x = (*x *1.0)/1024 * 800 ;
			//*y = (*y *1.0)/600  * 480 ;
			bzero(text,1024);
			sprintf(text,"(%d,%d)\n",*x,*y);
			XPRINTF(text);
			break;
		}
	}
	
	//5）关闭触摸屏文件
	close(tsfd);
}

（6）ts.h

#ifndef __TS_H_
#define __TS_H_

#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include <sys/mman.h>
#include <stdbool.h>
#include <linux/input.h>//触摸屏头文件

extern int ts_func(int *x,int *y);

#endif

（7）debug.c

#include "debug.h"

//初始化调试文本
int initLog()
{
	//1、打开文本 并且 清空内容 ，如果不存在，新建
	FILE * fp = fopen(LOG_FILE,"wb+");
	if(fp == NULL)
	{
		printf("fopen %s error\n",LOG_FILE);
		return -1;
	}
	//3、关闭文件
	fclose(fp);
}

#ifdef DEBUG //开启调试功能

#ifndef DEBUG_TEXT
int XPRINTF(char *text) //1、调试功能 定位到屏幕终端
{
	printf("%s",text);
}
#else 
	
int XPRINTF(char *text)//2、调试功能 定位到文本中
{
	
	//1、以可写的方式打开log.txt,如果文件不存在则新建，如果存在了追加
	FILE * fp = fopen(LOG_FILE,"ab");
	if(fp == NULL)
	{
		printf("fopen %s error\n",LOG_FILE);
		return -1;
	}
	//2、将传递进来的信息写入到调试文本中 fprintf
	fprintf(fp,"%s",text);
	//3、关闭文件
	fclose(fp);
}
#endif

#else 
int XPRINTF(char *text)
{
	
}
#endif

（8）debug.h

#ifndef __DEBUG_H_
#define __DEBUG_H_

#include<stdio.h>
#include <strings.h>

#define LOG_FILE	"./log.txt"

#define DEBUG //是否开启调试功能  调试的总开关
//#define DEBUG_TEXT //如果定义了该宏   将调试信息输出文本中  

extern int XPRINTF(char *text);

extern int initLog();

#endif

（9）Makefile

CC = arm-linux-gcc
TARGET = bin/main
C_SOURCE = $(wildcard c_source/*.c)
INCLUDE_PATH = -I ./include

$(TARGET):$(C_SOURCE)
	$(CC) $^  -o  $@ $(INCLUDE_PATH)

.PHONY:clean	
	
clean:
	$(RM) $(TARGET)

阿哈、小吴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编程语言发展史之：编程语言的未来趋势
禅与计算机程序设计艺术
09-25 5177
编程语言”这个概念在近几年间已经成为现代科技领域的一个热门话题。它从诞生到今天已经经历了几百年的历史，各个编程语言都各不相同，但其中的共同点无疑就是可以实现一些程序功能。而“未来趋势”，则指的是这一系列编程语言的演进方向以及各自适应该方向的理念、方法和工具。那么，编程语言的未来是如何确立的呢？对于编程语言来说，如何走向成熟并取得成功，将是一个至关重要的问题。为了给读者提供一个深入浅出的理解，本文从编程语言的历史开始，一步步阐述编程语言发展的脉络。
Java 8章 IO 编程题
SmacUL的博客
11-28 1696
题目一利用DataInputStream类和BufferedInputStream类编写一个程序，实现从键盘读入一个字符串，在显示器上显示前两个字符的Unicode码以及后面的所有字符。结果请输入字符串 asdfjkl 字符一的Unicode码：97 字符二的Unicode码：115 d f j k l思路DataInputStream 类继承自 FilterInputStr
C++Qt开发——文件操作
m0_60259116的博客
11-12 2081
C++Qt开发——文件操作
[Python基础16]文件输入输出流[IO操作]
周小董
06-08 1401
本节内容如下： 什么是IO 文件内容操作 操作文本文件 操作二进制文件 内存IO 初步认识io模块 目录和文件的操作 初步认识os模块 文件的创建、重命名、删除 目录的创建、重命名、删除 序列化操作 1. 什么是IO IO：Input/Output~输入/输出的意思 任何编程语言，核心都是对数据的处理，对数据的处理一般情况下就是指代数据的输入和输出 常规情况下...
UEFI开发探索23 – File IO(文件读写)
09-19 3397
(请保留-> 作者: 罗冰) Option ROM的开发中，很少用到文件读写。因此，在最早开发的过程中，我没有仔细研究过文件处理相关的Protocol。 倒是在编写显示图片例程的时候，涉及到了一些。我直接使用了UDK中的例子，改造了显示BMP的函数，函数内部封装了文件读取。 接下来我准备用几篇博客，演示如何显示图片。UEFI画图的程序，在之前的博客中已经讨论演示过了。下面需要做的，是解...
5W字穿透 ELK（史上最全）：elasticsearch +logstash+kibana
架构师尼恩
09-26 4355
Elasticsearch 是一个分布式的开源搜索和分析引擎，在的基础上开发而成。Lucene 是开源的搜索引擎工具包，Elasticsearch 充分利用Lucene，并对其进行了扩展，使存储、索引、搜索都变得更快、更容易， 而最重要的是， 正如名字中的“ elastic ”所示， 一切都是灵活、有弹性的。而且，应用代码也不是必须用Java 书写才可以和Elasticsearc兼容，完全可以通过JSON 格式的HTTP 请求来进行索引、搜索和管理Elasticsearch 集群。
Unix/Linux操作系统分析实验三 文件操作算法： 实现在/proc目录下添加文件
weixin_45720714的博客
01-28 2963
本文章用于记录自己所学的内容，方便自己回顾复习。 实验内容 内容一：编写一个内核模块，在/proc文件系统中增加一个目录hello，并在这个目录中增加一个文件world，文件的内容为hello world。 /proc 文件系统简介： /proc 文件系统是Linux上的一种虚拟文件系统，存储的是当前内核运行状态的一系列特殊文件，用户可以通过这些文件查看有关系统硬件及当前正在运行进程的信息，甚至可以更改其中某些文件来改变内核的运行状态。最初开发 /proc 文件系统是为了提供有关系统中进程的...
shell编程范例之文件操作
longerzone的专栏
11-08 2693
by falcon 2007-11-5     这一周我们来探讨文件操作。在日常学习和工作中，我们总是在不断的和各种文件打交道，这些文件包括普通的文本文件，可以执行的程序文件，带有控制字符的文 档、存放各种文件的目录文件、网络套接字文件、设备文件等。这些文件又具有诸如属主、大小、创建和修改日期等各种属性。文件对应文件系统的一些数据块，对 应磁盘等存储设备的一片连续空间，对应于显示设备却是一
Java 文件操作
热门推荐
路漫漫其修远兮，吾将上下而求索。
06-06 3万+
11.3 I/O类使用 由于在IO操作中，需要使用的数据源有很多，作为一个IO技术的初学者，从读写文件开始学习IO技术是一个比较好的选择。因为文件是一种常见的数据源，而且读写文件也是程序员进行IO编程的一个基本能力。本章IO类的使用就从读写文件开始。 11.3.1 文件操作 文件(File)是 最常见的数据源之一，在程序中经常需要将数据存储到文件中，例如图片文件、声音文件等数据文件，
C#记录（八）：保存数据到txt文本
xqw19891201的博客
04-09 4478
一、获取当前路径 转载https://www.cnblogs.com/shiyh/p/10573405.html //获取模块的完整路径。 2 string path1 = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName; ...
文件IO编程总结
08-06
本文将围绕“文件IO编程”这一主题，详细讲解相关知识点，帮助初学者快速掌握文件IO的基本概念、常用方法以及实践技巧。 首先，我们需要了解文件在操作系统中的基本概念。文件是数据的持久化存储形式，它包含了一...
Linux 文件IO编程-模拟登陆系统
08-26
本项目"Linux 文件IO编程-模拟登陆系统"旨在通过实践，让开发者深入理解如何利用C语言进行文件操作，并结合Linux图形库curses实现一个简单的用户交互界面。下面将详细介绍这个项目涉及的关键知识点。 1. 文件IO编程...
极简Java五：IO流
06-18
在Java编程语言中，IO（Input/Output）流是一组用于处理输入输出操作的类和接口，它们构成了Java的核心部分，对于任何与数据传输相关的应用都至关重要。在本篇文章中，我们将深入探讨Java中的IO流，包括其概念、分类...
dumpio2curl：解析Apache 2.4 dumpio日志
02-05
dumpio2curl是一个用Perl编写的脚本，它的主要功能是将这些复杂的dumpio日志转换成更易于理解和操作的curl命令。Perl是一种强大的文本处理语言，非常适合处理这种结构化但又复杂的数据。通过这个工具，你可以快速地...
Java IO commons-io-2.5.jar
04-02
Java IO 是Java编程语言中处理输入/输出流的重要部分，它是连接程序与外部世界的桥梁，允许数据在程序和外部资源之间流动。`commons-io-2.5.jar` 是Apache Commons项目的一部分，它提供了一系列增强和扩展了Java标准...
Linux中的常见命令——用户管理命令
最新发布
qq_45569925的博客
08-27 686
默认创建用户的时候会在home文件夹下创建一个与用户同名的文件夹【该用户的主目录】，也可以在创建用户的时候设置该用户主目录的名称。【输入的密码是不在控制台显示的，输入完之后直接按回车键即可】使用wgh用户查看root下的文件。【此时的用户是没有密码的】给创建的用户设置密码。查看某个用户是否存在。
Linux基础知识（一、什么是Linux）
心寒的博客
08-26 1258
什么是Linux Linux创始人
虚拟内存和linux（操作系统八股文part1）
linjixia的博客
08-24 1347
八股之虚拟内存和Linux部分的笔记。
linux 系统性能调优技巧
m0_50641264的博客
08-27 535
【代码】linux 系统性能调优技巧。
Linux文件IO编程：open与close函数详解
本文档主要介绍了在嵌入式Linux环境下进行文件I/O编程的基本...本文档为学习嵌入式Linux应用程序开发提供了详细的指导，涵盖了从系统安装、文件操作到编程和调试的各个方面，是嵌入式Linux应用开发者的宝贵参考资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值