文件IO · 代码纯享版 —— 第2天

最新推荐文章于 2024-07-23 14:18:41 发布
最新推荐文章于 2024-07-23 14:18:41 发布
阅读量71 收藏
点赞数
分类专栏： 文件IO 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49927539/article/details/131608864
版权

文章目录

0010读取图片并在屏幕上绘图

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

#define LCD_H 480
#define LCD_W 800

#define LCD_SIZE (LCD_H * LCD_W)

#define LCD_FILE_PATH "/dev/fb0"

int main(int argc, char const *argv[])
{
    int lcd_fd = open(LCD_FILE_PATH, O_WRONLY);
    if (lcd_fd == -1)
    {
        perror("打开lcd文件失败！");
        return -1;
    }

    int bmp_picture_fd = open("./a1.bmp", O_RDONLY);
    if (bmp_picture_fd == -1)
    {
        perror("打开图片文件失败！");
        return -1;
    }
    // 移动到文件头存放图片宽度的数据之处，读取图片宽度数据
    lseek(bmp_picture_fd, 18, SEEK_SET);

    int picture_w, picture_h;
    if (read(bmp_picture_fd, &picture_w, sizeof(int)) == -1)
    {
        perror("读取图片宽度失败！");
        return -1;
    }
    if (read(bmp_picture_fd, &picture_h, sizeof(int)) == -1)
    {
        perror("读取图片高度失败！");
        return -1;
    }
    printf("图片的宽度为：%d，图片的高度为：%d\n", picture_w, picture_h);

    // 避开文件头，开始读取像素数据
    lseek(bmp_picture_fd, 54, SEEK_SET);
    char picture_color_data_arr[LCD_SIZE * 3];
    if (read(bmp_picture_fd, picture_color_data_arr, LCD_SIZE * 3) == -1)
    {
        perror("读取图片像素数据失败！");
        return -1;
    }

    //     由于bmp是1个像素数据3个字节，而屏幕是1个像素数据4个字节，
    // 所以需要对读取到的像素数据进行3字节转换成4字节，
    // 转换后的数据保存在新数组中。
    int new_picture_color_data_arr[LCD_SIZE];
    for (int y = 0; y < LCD_H; y++)
    {
        for (int x = 0; x < LCD_W; x++)
        {
            // 由于bmp图片的数据是逆序存放的，所以需要进行处理，使其变成顺序存放。
            // 1、bmp图片的像素数据是以BGR的方式存放，而屏幕的像素是以RGB的形式存放
            // 2、bmp的图片像素数据是从下往上排列，而屏幕像素是从上往下排列
            new_picture_color_data_arr[LCD_W * (479 - y) + x] =
                picture_color_data_arr[3 * (LCD_W * y + x) + 0] << 0 |
                picture_color_data_arr[3 * (LCD_W * y + x) + 1] << 8 |
                picture_color_data_arr[3 * (LCD_W * y + x) + 2] << 16;
        }
    }

    if (write(lcd_fd, new_picture_color_data_arr, LCD_SIZE * 4) == -1)
    {
        perror("写入像素数据失败！");
        return -1;
    }

    if (close(lcd_fd) == -1)
    {
        perror("关闭lcd文件失败！");
        return -1;
    }

    if (close(bmp_picture_fd) == -1)
    {
        perror("关闭图片文件失败！");
        return -1;
    }

    return 0;
}

  在secureCRT中的运行结果：
在这里插入图片描述
  在开发板上观察到的运行现象：
在这里插入图片描述

0020验证映射0kb大小的文件无意义

   当映射一个0kb的稀疏文件时，会发生总线错误：

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

int main(int argc, char const *argv[])
{
    umask(0000);

	// 使用mmap映射时，记得给够可读可写权限，否则会提醒权限不够
    int text_fd = open("./text.txt", O_RDWR | O_CREAT, 0777);
    if (text_fd == -1)
    {
        perror("打开lcd文件失败！");
        return -1;
    }

    /* lseek(text_fd, 499, SEEK_SET);
    if (write(text_fd, "*", 1) == -1)
    {
        perror("写入数据失败！");
        return -1;
    } */

    char *mmap_start_p = (char *)mmap(NULL, 500, PROT_READ | PROT_WRITE, MAP_SHARED, text_fd, 0);
    if (mmap_start_p == (char *)MAP_FAILED)
    {
        perror("内存映射失败！");
        return -1;
    }

    char *string = "真是有趣的测试呢！";
    memset(mmap_start_p, 0, 500);
    memcpy(mmap_start_p, string, strlen(string));

    if (close(text_fd) == -1)
    {
        perror("关闭文本文件失败！");
        return -1;
    }
    if (munmap(mmap_start_p, 500) == -1)
    {
        perror("释放映射空间失败！");
        return -1;
    }

    return 0;
}

  在Linux上观察到的运行现象：
在这里插入图片描述
  代码更改为这样就可以成功运行：

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

int main(int argc, char const *argv[])
{
    umask(0000);

    // 使用mmap映射时，记得给够可读可写权限，否则会提醒权限不够
    int text_fd = open("./text.txt", O_RDWR | O_CREAT, 0777);
    if (text_fd == -1)
    {
        perror("打开lcd文件失败！");
        return -1;
    }

    lseek(text_fd, 499, SEEK_SET);
    if (write(text_fd, "*", 1) == -1)
    {
        perror("写入数据失败！");
        return -1;
    }

    char *mmap_start_p = (char *)mmap(NULL, 500, PROT_READ | PROT_WRITE, MAP_SHARED, text_fd, 0);
    if (mmap_start_p == (char *)MAP_FAILED)
    {
        perror("内存映射失败！");
        return -1;
    }

    char *string = "真是有趣的测试呢！";
    memset(mmap_start_p, 0, 500);
    memcpy(mmap_start_p, string, strlen(string));

    if (close(text_fd) == -1)
    {
        perror("关闭文本文件失败！");
        return -1;
    }
    if (munmap(mmap_start_p, 500) == -1)
    {
        perror("释放映射空间失败！");
        return -1;
    }

    return 0;
}

  在Linux上观察到的运行结果：
在这里插入图片描述
  在vscode中打开text.txt文件：
在这里插入图片描述

0030mmap实现将源文件写入到稀疏文件后再提取出来

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

#define EMPTY_FILE_PATH "./empty_file"
#define EMPTY_FILE_SIZE 1048576 * 10
#define MMAP_OFFSET 0
#define DOWNLOAD_MODE "下载"
#define UPLOAD_MODE "上传"
#define OPERATE_DATA_SIZE 1048576

typedef struct file_download_upload_inf
{
    int obj_file_fd;
    int empty_file_fd;
    char *mmap_file_poi;
    int obj_file_size;
    int download_size;
    int upload_size;
} FDUDI, *P_FDUDI;

P_FDUDI Demo_Init();
int Upload_File(P_FDUDI p_fdudi, const char *obj_file_path);
int Download_File(P_FDUDI p_fdudi, const char *obj_file_path);
int Demo_Free(P_FDUDI p_fdudi);

/**
    【业务逻辑】：
        1. 在函数开始处，分配FDUDI结构体的内存空间，用于存储相关信息。
        2. 检查内存分配是否成功，如果分配失败，则返回错误。
        3. 将分配的内存空间清零，以确保结构体的初始状态是整洁的。
        4. 使用access函数检查空洞文件是否存在，如果文件不存在，则进入以下步骤：
            设置文件创建权限掩码为0000，以确保文件创建时具有所需的权限。
            创建空洞文件，并以可读写的方式打开该文件。
            将文件指针设置到文件末尾，以便在后续写入数据时可以扩展文件大小。
            在文件末尾写入一个字节的数据，用于扩展文件大小。
        5. 如果空洞文件存在，则进入以下步骤：
            以可读写的方式打开已存在的空洞文件。
        6. 使用mmap函数将空洞文件映射到内存中，以便后续可以直接对内存进行读写操作。
            设置映射的内存地址为NULL，让系统自动选择合适的地址。
            设置映射的内存大小为空洞文件的大小。
            设置映射的内存权限为可读可写。
            设置映射的内存属性为共享映射，以便多个进程可以共享映射的内存。
            将空洞文件的文件描述符和映射的偏移量作为参数，完成映射操作。
        7. 如果映射失败，则返回错误。
        8. 返回指向FDUDI结构体的指针，表示初始化成功。

    【总结】：
        Demo_Init()函数的业务流程包括分配内存空间、检查空洞文件是否存在、创建或打开空洞文件、将空洞文件映射到内存空间中，并返回指向FDUDI结构体的指针。
 */
P_FDUDI Demo_Init()
{
    // 1. 使用malloc函数申请FDUDI结构体大小的堆空间，并将其赋值给指针p_fdudi
    P_FDUDI p_fdudi = (P_FDUDI)malloc(sizeof(FDUDI));
    if (p_fdudi == (P_FDUDI)NULL)
    {
        // 如果申请堆空间失败，输出错误信息并返回-1
        perror("初始化程序时，申请堆空间失败！");
        return (P_FDUDI)-1;
    }

    // 2. 使用memset函数将p_fdudi指向的内存空间清零
    memset(p_fdudi, 0, sizeof(FDUDI));

    // 3. 检查空洞文件是否存在
    if (access(EMPTY_FILE_PATH, F_OK))
    {
        // 不存在则创建空洞文件
        umask(0000);
        if ((p_fdudi->empty_file_fd = open(EMPTY_FILE_PATH, O_RDWR | O_CREAT, 0777)) == -1)
        {
            perror("打开空洞文件失败！");
            return (P_FDUDI)-1;
        }

        // 将文件指针移动到文件末尾，并写入一个字节的数据，用于创建空洞文件
        lseek(p_fdudi->empty_file_fd, EMPTY_FILE_SIZE - 1, SEEK_SET);
        if (write(p_fdudi->empty_file_fd, "*", sizeof(char)) == -1)
        {
            perror("初始化程序时，写入数据到稀疏文件失败！");
            return (P_FDUDI)-1;
        }
    }
    else
    {
        // 存在则直接打开空洞文件
        if ((p_fdudi->empty_file_fd = open(EMPTY_FILE_PATH, O_RDWR)) == -1)
        {
            // 如果打开失败，输出错误信息并返回-1
            perror("程序初始化时，打开空洞文件失败！");
            return (P_FDUDI)-1;
        }
    }

    // 4. 使用mmap函数将空洞文件映射到内存空间，并将映射到的内存地址赋值给p_fdudi->mmap_file_poi
    if ((p_fdudi->mmap_file_poi = (char *)mmap(NULL,
                                               EMPTY_FILE_SIZE,
                                               PROT_READ | PROT_WRITE,
                                               MAP_SHARED,
                                               p_fdudi->empty_file_fd,
                                               MMAP_OFFSET)) == (char *)MAP_FAILED)
    {
        // 如果映射失败，输出错误信息并返回-1
        perror("映射空洞文件失败！");
        return (P_FDUDI)-1;
    }

    // 5. 返回指向FDUDI结构体的指针p_fdudi
    return p_fdudi;
}

/**
    【业务逻辑】：
        1. 使用memset函数将p_fdudi->mmap_file_poi指向的内存空间清零，以确保初始化状态。
        2. 使用open函数以只读方式打开需要上传的文件，获取文件的文件描述符obj_fd。
        3. 使用lseek函数将obj_fd指向的文件指针移动到文件末尾，并通过返回值获取文件大小，将文件大小保存在p_fdudi->obj_file_size中。
        4. 将字符串"ok"拷贝到new_mmap_poi指向的内存空间中，表示上传开始，将new_mmap_poi指针向后移动2个字节。
        5. 将p_fdudi->obj_file_size的内容拷贝到new_mmap_poi指向的内存空间中，表示上传文件大小，将new_mmap_poi指针向后移动sizeof(int)个字节。
        6. 使用lseek函数将obj_fd指向的文件指针移动到文件开头。
        7. 输出即将上传的文件的路径和大小。
        8. 进入循环，每次循环读取OPERATE_DATA_SIZE个字节的文件数据到file_data数组中。
            如果读取失败，输出错误信息并返回-1。
            如果读取结束，输出上传成功的信息，跳出循环。
            如果读取成功，将file_data中的数据拷贝到new_mmap_poi指向的内存空间中，将new_mmap_poi指针向后移动读取的字节数，增加上传字节数p_fdudi->upload_size。
        9. 使用close函数关闭obj_fd指向的文件。
        10. 返回0表示上传成功。

    【总结】：
        Upload_File()函数的业务流程包括清零内存空间、打开文件并获取文件大小、拷贝数据到内存空间、读取文件数据并写入内存空间，最后关闭文件。
 */
int Upload_File(P_FDUDI p_fdudi, const char *obj_file_path)
{
    // 1. 使用memset函数将p_fdudi->mmap_file_poi指向的内存空间清零
    memset(p_fdudi->mmap_file_poi, 0, EMPTY_FILE_SIZE);

    // 2. 使用open函数以只读方式打开需要上传的文件
    int obj_fd = open(obj_file_path, O_RDONLY);
    if (obj_fd == -1)
    {
        perror("打开需要上传的文件失败！");
        return -1;
    }

    // 3. 使用lseek函数获取需要上传的文件的大小，并将其保存在p_fdudi->obj_file_size中
    p_fdudi->obj_file_size = lseek(obj_fd, 0, SEEK_END);

    // 4. 将"ok"两个字节的数据拷贝到new_mmap_poi指向的内存空间中，并将new_mmap_poi指针向后移动2个字节
    char *new_mmap_poi = p_fdudi->mmap_file_poi;
    memcpy(new_mmap_poi, "ok", 2);
    new_mmap_poi += 2;

    // 5. 将p_fdudi->obj_file_size的内容拷贝到new_mmap_poi指向的内存空间中，并将new_mmap_poi指针向后移动sizeof(int)个字节
    memcpy(new_mmap_poi, &p_fdudi->obj_file_size, sizeof(int));
    new_mmap_poi += sizeof(int);

    // 6. 使用lseek函数将obj_fd指向的文件指针移动到文件开头
    lseek(obj_fd, 0, SEEK_SET);

    // 7. 输出即将上传的文件的路径和大小
    printf("即将上传的文件为：%s\n其大小为:%d\n\n", obj_file_path, p_fdudi->obj_file_size);

    // 8. 定义一个大小为OPERATE_DATA_SIZE的字符数组file_data，用于存储从文件中读取的数据
    char file_data[OPERATE_DATA_SIZE];
    while (1)
    {
        // 9. 使用memset函数将file_data数组清零
        memset(file_data, 0, OPERATE_DATA_SIZE);

        // 10. 使用read函数从obj_fd指向的文件中读取最多OPERATE_DATA_SIZE个字节的数据到file_data数组中
        int read_ret = read(obj_fd, file_data, OPERATE_DATA_SIZE);
        if (read_ret == -1)
        {
            perror("读取上传文件失败！");
            return -1;
        }
        else if (read_ret == 0)
        {
            printf("上传成功！总共上传字节数：%d\n", p_fdudi->upload_size);
            break;
        }
        else
        {
            // 如果读取成功，将file_data中的数据拷贝到new_mmap_poi指向的内存空间中，并将new_mmap_poi指针向后移动read_ret个字节
            memcpy(new_mmap_poi, file_data, read_ret);
            new_mmap_poi += read_ret;
            p_fdudi->upload_size += read_ret;
        }
    }

    // 11. 使用close函数关闭obj_fd指向的文件
    if (close(obj_fd) == -1)
    {
        perror("关闭上传文件失败！");
        return -1;
    }

    // 12. 返回0表示上传成功
    return 0;
}

/**
    【业务逻辑】：
        1. 定义下载掩码数组dowmload_mask，并将p_fdudi->mmap_file_poi指向的内存空间中的前两个字节拷贝到dowmload_mask中。
        2. 将new_mmap_poi指针向后移动2个字节。
        3. 如果下载掩码不为"ok"，则输出无下载文件的信息，并返回0。
        4. 将new_mmap_poi指向的内存空间中的sizeof(int)个字节的数据拷贝到p_fdudi->obj_file_size中，并将new_mmap_poi指针向后移动sizeof(int)个字节。
        5. 输出即将下载的文件大小和路径。
        6. 设置文件创建权限掩码为0000，以确保文件创建时具有所需的权限。
        7. 使用open函数创建或打开文件，并获取文件描述符obj_fd。
        8. 定义一个大小为OPERATE_DATA_SIZE的字符数组file_data，用于存储将要写入文件的数据。
        9. 循环将内存空间中的数据写入文件，每次循环写入OPERATE_DATA_SIZE个字节的数据，直到写入完成。
            清零file_data数组，并将new_mmap_poi指向的内存空间中的数据拷贝到file_data数组中。
            使用write函数将file_data中的数据写入obj_fd指向的文件中。
            将new_mmap_poi指针向后移动OPERATE_DATA_SIZE个字节，增加下载字节数p_fdudi->download_size。
        10. 如果文件大小不是OPERATE_DATA_SIZE的整数倍，处理剩余的数据。
            计算剩余数据的字节数。
            将new_mmap_poi指向的内存空间中的数据拷贝到file_data数组中。
            使用write函数将file_data中的数据写入obj_fd指向的文件中。
            增加下载字节数p_fdudi->download_size。
        11. 输出下载成功的信息，包括总共下载的字节数。
        12. 使用close函数关闭obj_fd指向的文件。
        13. 返回0表示下载成功。

    【总结】：
        Download_File()函数的业务流程包括拷贝掩码、判断下载掩码、拷贝文件大小、创建或打开文件、循环写入文件数据、处理剩余数据，最后关闭文件。
 */
int Download_File(P_FDUDI p_fdudi, const char *obj_file_path)
{
    // 1. 定义下载掩码数组dowmload_mask，并将p_fdudi->mmap_file_poi指向的内存空间中的前两个字节拷贝到dowmload_mask中
    char dowmload_mask[3] = "\0";
    char *new_mmap_poi = p_fdudi->mmap_file_poi;
    memcpy(dowmload_mask, new_mmap_poi, 2);

    // 2. 将new_mmap_poi指针向后移动2个字节
    new_mmap_poi += 2;
    // 3. 如果下载掩码不为"ok"，则输出无下载文件的信息，并返回0
    if (strcmp(dowmload_mask, "ok") != 0)
    {
        printf("无下载文件\n");
        return 0;
    }

    // 4. 将new_mmap_poi指向的内存空间中的sizeof(int)个字节的数据拷贝到p_fdudi->obj_file_size中，并将new_mmap_poi指针向后移动sizeof(int)个字节
    memcpy(&p_fdudi->obj_file_size, new_mmap_poi, sizeof(int));
    new_mmap_poi += sizeof(int);

    // 5. 输出即将下载的文件大小和路径
    printf("即将下载数据为 %d 个字节数据，保存到 %s 文件中\n", p_fdudi->obj_file_size, obj_file_path);

    // 6. 设置文件创建权限掩码为0000，以确保文件创建时具有所需的权限
    umask(0000);
    // 7. 使用open函数创建或打开文件，并获取文件描述符obj_fd
    int obj_fd = open(obj_file_path, O_WRONLY | O_CREAT | O_EXCL, 0777);
    if (obj_fd == -1)
    {
        perror("下载文件的文件描述符创建失败！");
        return -1;
    }

    // 8. 定义一个大小为OPERATE_DATA_SIZE的字符数组file_data，用于存储将要写入文件的数据
    char file_data[OPERATE_DATA_SIZE];
    // 9. 循环将内存空间中的数据写入文件，每次循环写入OPERATE_DATA_SIZE个字节的数据，直到写入完成
    for (int lp = 0; lp < p_fdudi->obj_file_size / OPERATE_DATA_SIZE; lp++)
    {
        // 清零file_data数组，并将new_mmap_poi指向的内存空间中的数据拷贝到file_data数组中
        memset(file_data, 0, OPERATE_DATA_SIZE);
        memcpy(file_data, new_mmap_poi, OPERATE_DATA_SIZE);

        // 使用write函数将file_data中的数据写入obj_fd指向的文件中
        if (write(obj_fd, file_data, OPERATE_DATA_SIZE) == -1)
        {
            perror("写入数据失败！");
            return -1;
        }
        // 将new_mmap_poi指针向后移动OPERATE_DATA_SIZE个字节，增加下载字节数p_fdudi->download_size
        new_mmap_poi += OPERATE_DATA_SIZE;
        p_fdudi->download_size += OPERATE_DATA_SIZE;
    }

    // 10. 如果文件大小不是OPERATE_DATA_SIZE的整数倍，处理剩余的数据
    if (p_fdudi->obj_file_size % OPERATE_DATA_SIZE != 0)
    {
        // 计算剩余数据的字节数
        int skip = p_fdudi->obj_file_size % OPERATE_DATA_SIZE;
        // 将new_mmap_poi指向的内存空间中的数据拷贝到file_data数组中
        memcpy(file_data, new_mmap_poi, skip);

        // 使用write函数将file_data中的数据写入obj_fd指向的文件中
        if (write(obj_fd, file_data, skip) == -1)
        {
            perror("写入剩余数据失败！");
            return -1;
        }
        // 增加下载字节数p_fdudi->download_size
        p_fdudi->download_size += skip;
    }

    // 11. 输出下载成功的信息，包括总共下载的字节数
    printf("下载成功！总共下载 %d 个字节数据。\n", p_fdudi->download_size);

    // 12. 使用close函数关闭obj_fd指向的文件
    if (close(obj_fd) == -1)
    {
        // 如果关闭文件失败，输出错误信息并返回-1
        perror("关闭下载文件失败！");
        return -1;
    }
    // 13. 返回0表示下载成功
    return 0;
}

/**
    【业务逻辑】：
        1. 使用close函数关闭空洞文件描述符p_fdudi->empty_file_fd。
        2. 使用munmap函数释放映射空间p_fdudi->mmap_file_poi。
        3. 使用free函数释放p_fdudi指向的内存空间。
        4. 返回0表示释放成功。

    【总结】：
        Demo_Free()函数的业务流程包括关闭空洞文件描述符、释放映射空间和释放内存空间。
 */
int Demo_Free(P_FDUDI p_fdudi)
{
    if (close(p_fdudi->empty_file_fd) == -1)
    {
        perror("关闭空洞文件失败！");
        return -1;
    }

    if (munmap(p_fdudi->mmap_file_poi, EMPTY_FILE_SIZE) == -1)
    {
        perror("释放映射空间失败！");
        return -1;
    }

    free(p_fdudi);

    return 0;
}

int main(int argc, char const *argv[])
{
    if (argc != 3)
    {
        printf("命令行参数有误！");
        return -1;
    }

    P_FDUDI p_fdudi = Demo_Init();
    if (p_fdudi == (P_FDUDI)-1)
    {
        printf("初始化失败！");
        return -1;
    }

    if (strcmp(argv[1], DOWNLOAD_MODE) == 0)
    {
        Download_File(p_fdudi, argv[2]);
    }
    else if (strcmp(argv[1], UPLOAD_MODE) == 0)
    {
        Upload_File(p_fdudi, argv[2]);
    }
    else
    {
        printf("输入命令有误（非“上传”“下载”），请重新输入\n");
    }

    if (Demo_Free(p_fdudi) == -1)
    {
        printf("释放资源失败！\n");
        return -1;
    }

    return 0;
}

  在Linux上观察到的运行现象：
在这里插入图片描述

0040使用mmap进行内存映射显示图片

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

#define LCD_DEV_PATH "/dev/fb0"
#define LCD_PIEXL_SIZE 4
#define BMP_PIEXL_SIZE 3
#define MMAP_OFFSET 0

typedef struct lcd_dis_inf
{
    int lcd;
    int *mmap_star_poi;
    int lcd_w;
    int lcd_h;
} LCD_INF_STR, *LCD_INF_POI;

LCD_INF_POI Lcd_Dis_Init();

LCD_INF_POI Lcd_Dis_Init()
{
    LCD_INF_POI lcd_inf_poi = (LCD_INF_POI)malloc(sizeof(LCD_INF_STR));
    if (lcd_inf_poi == (LCD_INF_POI)NULL)
    {
        perror("申请堆空间失败！");
        return (LCD_INF_POI)-1;
    }

    memset(lcd_inf_poi, 0, sizeof(LCD_INF_STR));

    lcd_inf_poi->lcd_w = 800;
    lcd_inf_poi->lcd_h = 480;

    if ((lcd_inf_poi->lcd = open(LCD_DEV_PATH, O_RDWR)) == -1)
    {
        perror("打开lcd失败！");
        return (LCD_INF_POI)-1;
    }

    if ((lcd_inf_poi->mmap_star_poi = mmap(NULL,
                                           lcd_inf_poi->lcd_w * lcd_inf_poi->lcd_h * LCD_PIEXL_SIZE,
                                           PROT_READ | PROT_WRITE,
                                           MAP_SHARED,
                                           lcd_inf_poi->lcd,
                                           MMAP_OFFSET)) == MAP_FAILED)
    {
        perror("映射失败！");
        return (LCD_INF_POI)-1;
    }
    return lcd_inf_poi;
}

/**
    【业务逻辑】：
        1. 在函数开始处，打开图片。
        2. 检查图片是否成功打开，如果打开失败，则输出错误信息并返回-1。
        3. 获取图片的宽度和高度。
        4. 读取图片的宽度和高度，如果读取失败，则输出错误信息并返回-1。
        5. 输出即将显示的图片的路径、宽度和高度。
        6. 设置读取图片像素点时的偏移量。
        7. 计算每行像素点的字节数。
        8. 为存储像素点的数组分配内存。
        9. 读取图片的像素点数据，如果读取失败，则输出错误信息并返回-1。
        10. 将读取到的像素点数据存储到映射的内存中。
        11. 关闭图片。
        12. 检查关闭图片是否成功，如果关闭失败，则输出错误信息并返回-1。
        13. 返回0，表示函数执行成功。

    【参数说明】：
        - lcd_inf_poi：指向LCD_INF_POI结构体的指针，用于存储LCD相关信息。
        - bmp_path：指向字符串的指针，表示图片的路径。

    【总结】：
        该函数的业务流程包括打开图片、获取图片的宽度和高度、读取图片的像素点数据并存储到映射的内存中，最后关闭图片。
 */
int Lcd_Dising(LCD_INF_POI lcd_inf_poi, const char *bmp_path)
{
    // 打开指定路径下的图片文件
    int bmp = open(bmp_path, O_RDONLY);
    if (bmp == -1)
    {
        perror("打开图片失败！");
        return -1;
    }

    // 读取图片的宽度和高度信息
    lseek(bmp, 18, SEEK_SET);
    int bmp_w, bmp_h;
    if (read(bmp, &bmp_w, sizeof(int)) == -1)
    {
        perror("读取图片宽度失败");
        return -1;
    }
    if (read(bmp, &bmp_h, sizeof(int)) == -1)
    {
        perror("读取图片高度失败");
        return -1;
    }
    printf("读取到图片的名称为：%s, 宽为：%d，高为：%d\n", bmp_path, bmp_w, bmp_h);

    // 定位到图片数据的起始位置
    lseek(bmp, 54, SEEK_SET);

    // 计算每行像素点字节对齐的字节数
    int skip;
    if (bmp_w * 3 % 4 == 0)
    {
        skip = 0;
    }
    else
    {
        skip = 4 - (bmp_w * 3 % 4);
    }

    // 读取图片的像素点数据
    char rgb[bmp_w * bmp_h * BMP_PIEXL_SIZE + bmp_h * skip];
    if (read(bmp, rgb, bmp_w * bmp_h * BMP_PIEXL_SIZE + bmp_h * skip) == -1)
    {
        perror("读取图片像素点失败！");
        return -1;
    }

    // 将图片的像素点数据写入LCD屏幕的内存映射区域
    for (int y = 0, n = 0; y < bmp_h; y++)
    {
        for (int x = 0; x < bmp_w; x++, n += 3)
        {
            /** 其实也相当于(800 * y + )
             *  lcd_inf_poi->mmap_star_poi相当于LCD屏幕的内存映射区域的起始地址不用管
             *  lcd_inf_poi->lcd_w * (bmp_h - 1 - y) + x可看成：(800 * y + x)
             *  至于(bmp_h - 1 - y)，那是因为位图的行是从下到上的，跟屏幕的从上到下不一样，需要进行校正
             */
            *(lcd_inf_poi->mmap_star_poi +
              lcd_inf_poi->lcd_w * (bmp_h - 1 - y) + x) =
                rgb[n] << 0 |
                rgb[n + 1] << 8 |
                rgb[n + 2] << 16;
        }
        // 跳过本行字节对齐部分，下一个循环直接进入下一行
        // 如果不跳过字节对齐这部分，那么下一行颜色数据将会写入到本行中
        n += skip;
    }

    // 关闭图片文件
    if (close(bmp) == -1)
    {
        perror("关闭图片失败！");
        return -1;
    }
    return 0;
}

/**
 * 【业务逻辑】：
 *  1. 在函数开始处，关闭显示器。
 *  2. 检查关闭显示器是否成功，如果失败，则打印错误信息并返回-1。
 *  3. 释放映射空间。
 *  4. 检查释放映射空间是否成功，如果失败，则打印错误信息并返回-1。
 *  5. 释放lcd_inf_poi指向的内存空间。
 *  6. 返回0。
 *
 * 【参数说明】：
 *  - 参数1：lcd_inf_poi，指向LCD_INF_POI结构体的指针。
 * 
 * 【注意事项】：
 *  - 注意事项1：需要确保lcd_inf_poi指向的内存空间是通过malloc函数分配的，否则会导致错误。
 *
 * 【总结】：
 *  该函数的业务流程包括关闭显示器、释放映射空间和释放内存空间。
 *   如果关闭显示器或释放映射空间失败，则会打印错误信息并返回-1，否则返回0表示执行成功。
 */
int Lcd_Dis_Free(LCD_INF_POI lcd_inf_poi)
{
    if (close(lcd_inf_poi->lcd) == -1)
    {
        perror("关闭lcd文件失败！");
        return -1;
    }

    if (munmap(lcd_inf_poi->mmap_star_poi,
               lcd_inf_poi->lcd_w * lcd_inf_poi->lcd_h * LCD_PIEXL_SIZE) == -1)
    {
        perror("释放映射空间失败!");
        return -1;
    }

    free(lcd_inf_poi);

    return 0;
}

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("命令行参数错误！\n");
        return -1;
    }

    LCD_INF_POI lcd_inf_poi = Lcd_Dis_Init();
    if (lcd_inf_poi == (LCD_INF_POI)-1)
    {
        printf("显示初始化失败！\n");
        return -1;
    }

    if (Lcd_Dising(lcd_inf_poi, argv[1]) == -1)
    {
        printf("显示图片失败！\n");
        return -1;
    }

    if (Lcd_Dis_Free(lcd_inf_poi) == -1)
    {
        printf("释放资源失败！\n");
        return -1;
    }

    return 0;
}

  在secureRTC上观察到的运行现象：
在这里插入图片描述
  在开发板上观察到的运行现象：
在这里插入图片描述

_李筱夜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
十天学会51单片机——第二部分（用proteus仿真
04-15
在“十天学会51单片机”的过程中，通过每天的实践和仿真，你将逐步掌握51单片机的基本操作，如读取和设置IO口、使用定时器、中断处理等。Proteus的仿真功能让你无需物理设备就能快速验证代码和电路设计，提高了学习...
第2章-文件操作——源码.7z
06-21
"第2章-文件操作——源码.7z"是一个压缩包文件，其中包含了关于文件操作的源代码，可能是某个教程或项目的一部分。这个压缩包可能包含了各种示例，用于解释如何在不同的编程环境中处理文件。 在描述中提到的"很实用...
系统编程之文件IO（八）——缓冲区的设置
一个电子信息嵌入式的学习笔记
04-17 1884
缓冲区的设置
边学边记——C语言 文件IO
lil_ghost_的博客
08-10 1052
硬盘 / 磁盘：存储数据的硬件（持久性 -- 断电后数据依然存在），作为数据的持久化存储。内存条：吞吐量更大的存储硬件（易逝性 -- 断电后数据消失），作为数据处理的中间缓冲带。硬盘是一个整体，就是一个存储数据的介质（并不管存储的是什么数据）。硬盘硬件层面上数据的读写是以扇区作为单位的 -- 通常是512B。.........
文件操作 —— IO
m0_72161237的博客
04-02 1531
文本文件里存储的数据，就是遵守 ASCII 或者其他字符集编码(例如 utf8)，所得到的文件，本质上存的是字符(不仅仅是 char)直接使用笔记本（是按照文本的方式来解析现实的）开某个文件，如果看到的内容能看懂就是文本文件；：从给定的某个目录（一定要明确，基准目录是什么），一层一层往下找，这个过程得到的路径。进行初始化，这个路径指向的文件，可以是真实存在的，也可以是不存在的。文件系统操作例如创建文件，删除文件，重命名文件，创建文件...：从盘符开始，一层一层往下找，这个过程，得到的路径。
【Linux篇】第九篇——基础IO（系统文件IO+文件描述符+重定向+文件系统+软硬链接）
weixin_58450087的博客
03-29 3106
⭐️这篇博客就要开始聊一聊Linux中基础IO相关知识，IO相信大家都不陌生，我们在C/C++中对文件进行读写的操作，也就是文件IO，这篇博客我也会带大家回顾一下。这篇博客还会介绍系统中的文件IO调用的接口，还有文件系统相关的内容和概念，文件描述符等相关知识的分享。 目录C语言文件IO介绍C语言文件操作库函数的简单使用C语言默认打开的三个流系统文件IO系统调用接口的介绍open C语言文件IO介绍 C语言文件操作库函数的简单使用 C语言的专栏中有专门讲到这一块知识，这里会介绍一些，更细节的内容可以参.
java人的第二个项目————图书管理系统（IO版）
热门推荐
秋雨绵绵
11-23 1万+
引言 各位小伙伴大家好，今天跟大家分享一个小项目，图书管理系统（基于IO流实现），这个项目集成了java几乎基础的知识，值得一练，下面我将跟大家一起回顾与分享一下在该项目的心得与注意的点。 目录 一、项目概述 长期以来，人们使用传统的人工方式管理图书馆的日常业务，其操作流程比较烦琐。在借书时，读者首先将要借的书和借阅证交给工作人员，然后工作人员将每本书的信息卡片和读者的借阅证放在一个小格栏里，最后在借阅证和每本书贴的借阅条上填写借阅信息。在还书时，读者首先将要还的书交给工作人员，工作人员根据图.
java自动化之自动化框架项目（第二天-读取数据文件并封装对象）代码
02-28
本项目旨在教你如何利用Java技术实现这一目标，特别是针对第二天的学习内容——从数据文件中读取信息并将其封装到对象中。 1. **数据文件读取**： 在自动化测试中，我们经常需要从CSV、Excel或JSON等格式的数据...
Java面向对象第2版代码.zip
07-03
《Java面向对象编程第二版》是一本深入探讨Java编程中面向对象特性的教材。这个压缩包包含了一系列章节的源代码示例，旨在帮助学习者更好地理解和应用Java的面向对象概念。下面将对这些章节涉及的知识点进行详细阐述...
实例005——使用C++实现格式化数据的IO.zip
01-14
5. **文件IO**：C++的`<fstream>`库允许我们打开、读写和关闭文件。`std::ifstream`用于读取文件，`std::ofstream`用于写入文件，而`std::fstream`两者皆可。例如，`std::ifstream inputFile("example.txt");`打开名...
贸易常见付款方式D/P，D/A，T/T，L/C
王小磊
07-23 577
D/P付款交单代收行必须在进口商付清货款后，才可将商业单据交给进口方D/ADocumentsagainstAcceptance承兑交单出口人的交单以进口人在汇票上承兑为条件，一般承兑时会注明具体付款的日期T/T电汇汇出行应汇款人申请，拍发加押电报给在另一国家的分行或代理行（即汇入行），指示解付一定金额给收款人L/C信用证银行根据进口人（买方）的请求，开给出口人（卖方）的一种保证承担支付货款责任的书面凭证。
c++课程设计-产品入库管理操作系统.rar
07-24
基于C语言、C++、C#的课程\毕业设计，可供学习参考。
在iOS中展示汉字的Unicode与UTF-8编码方式
07-24
在iOS开发中，显示汉字涉及到了字符编码的重要概念，包括Unicode和UTF-8。这两个术语在计算机科学领域中是至关重要的，特别是在处理多语言文本时。让我们深入了解一下这两个概念及其在iOS中的应用。 Unicode是一个字符集，它定义了世界上几乎所有的文字和符号的数字表示，包括汉字。它的目标是为每个字符提供一个唯一的数字，使得任何语言的文字都可以用统一的方式处理。Unicode的最新版本已经包含了超过140,000个字符，涵盖了从古代象形文字到现代表情符号的各种文字系统。 Unicode本身并不规定如何存储这些数字，这就引出了编码格式的概念。UTF-8就是一种广泛使用的Unicode编码方式。UTF代表“Unicode Transformation Format”，它是一种变长的编码方案，根据字符的不同，可以使用1到4个字节来表示一个Unicode字符。 在iOS中，字符串类`NSString`和`NSMutableString`都是基于Unicode的，这意味着它们内部存储的是Unicode字符。当你在代码中创建或处理汉字字符串时，实际上是在处理Unicode字符序列。例如
c语言课程设计-产品管理系统.rar
07-24
基于C语言、C++、C#的课程\毕业设计，可供学习参考。
笔试题库或面试经验资源，备战秋招季.docx
07-24
备战秋招季，准备笔试题库和面试经验是非常重要的。以下是一些资源和建议，帮助你更好地准备： ### 1. **在线学习平台** - **LeetCode**: 提供了大量的编程题目，是准备技术面试的首选平台。 - **牛客网**: 有很多公司的笔试和面试题，还有讨论区可以交流经验。 - **LintCode**: 类似于LeetCode，也提供了大量的编程题目。 - **HackerRank**: 提供了各种难度的编程挑战，涵盖数据结构、算法等领域。 ### 2. **书籍资源** - **《剑指Offer》**: 经典的面试书籍，包含了大量的面试题目和解题思路。 - **《编程之美》**: 介绍了一些有趣的编程问题和解决方案。 - **《算法导论》**: 算法领域的经典教材，适合深入学习算法原理。 ### 3. **视频教程** - **YouTube**: 搜索相关的编程面试教程，很多技术大牛会分享他们的经验和解题技巧。 - **Bilibili**: 同样有很多优质的编程和面试教程。 ### 4. **模拟面试** - **Pramp**: 提供免费的模拟面试服务，可以和其
JNI基础与实现指南.zip
07-24
JNI基础与实现指南
基于Springboot和Vue的网上图书商城源码 网上图书商城代码（98分期末优秀大作业）
最新发布
07-24
网上图书商城源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
手写数字识别-深度学习
07-24
最经典的卷积神经网络。实现手写数字识别
java+ssm+mysql医院远程诊断系统(源码+lw+ppt)
07-24
以JSP为开发技术，实现了一个医院远程诊断系统。医院远程诊断系统的主要使用者分为管理员；个人中心、用户管理、医生管理、医生信息管理、医生预约管理、我的收藏管理、交流论坛、系统管理，医生；个人中心、医生信息管理、医生预约管理、系统管理，用户；个人中心、医生信息管理、医生预约管理、交流论坛、我的收藏管理，前台首页；首页、医生信息、论坛信息、我的、跳转到后台、客服等功能。通过这些功能模块的设计，基本上实现了整个医院远程诊断系统的过程。 具体在系统设计上，采用了B/S的结构，同时，也使用JSP技术在动态页面上进行了设计，后台上采用Mysql数据库
java——修改txt文件中某一行的内容
05-30
你可以使用Java的IO流和字符串操作来修改txt文件中某一行的内容。具体步骤如下： 1. 创建一个File对象来表示要修改的txt文件。 2. 创建一个BufferedReader对象来读取txt文件内容。 3. 创建一个StringBuilder对象来...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值