将结构体数组存放到char *pBuf=(char *)0x90000000;

在C语言中，`char *pBuf=(char*)0x90000000;`这样的语句定义了一个指向存储区起始地址0x90000000的字符型指针。这里`0x90000000`通常是一个假设的内存地址，用于演示目的。

如果你有一个结构体数组，例如：

typedef struct {
   int field1;
   char field2[50];
} MyStruct;

MyStruct structsArray[10]; // 结构体数组

如果你想将这个结构体数组拷贝到`pBuf`所指向的内存区域，你需要先计算出整个数组占用的字节数，然后按顺序将每个结构体成员的数据复制过去。这是一个示例过程：

size_t structsSize = sizeof(MyStruct) * sizeof(structsArray);
memcpy(pBuf, structsArray, structsSize); // 使用memcpy函数来复制数据

// 现在pBuf指向的就是结构体数组的副本

注意，这需要确保`pBuf`指向的内存足够大，能够容纳整个数组的大小，并且实际操作前应检查内存是否可用，避免未定义行为或内存溢出。

相关问题

基于keil软件STM32F103RCT6控制带字库的LCD12864显示存放在二维数组的汉字，满屏后自动向上滚动，直到显示完毕后可采样翻页的方式查看以往显示信息，示例代码

好的，以下是基于Keil软件的STM32F103RCT6控制带字库的LCD12864显示存放在二维数组的汉字，满屏后自动向上滚动的示例代码：

#include "stm32f10x.h"
#include "lcd12864.h"
#include "font8x16.h"
#include "chinese.h"

#define ROW_MAX 4    // LCD最大行数
#define COL_MAX 16   // LCD最大列数

uint8_t g_Row = 0;    // 当前行数
uint8_t g_Col = 0;    // 当前列数
uint8_t g_Page = 0;   // 当前页数
uint8_t g_TotalPage = 0;   // 总页数
uint8_t g_Buffer[ROW_MAX][COL_MAX];   // 显示缓冲区

void LCD12864_PrintChar(uint8_t x, uint8_t y, uint8_t ch)
{
    uint8_t i, j;
    uint8_t temp;

    // 计算汉字在汉字库数组中的位置
    uint32_t index = (uint32_t)(ch - HZK_START) * HZK_SIZE;

    // 逐列显示汉字
    for (i = 0; i < 16; i++)
    {
        temp = Chinese_Font[index + i];
        for (j = 0; j < 8; j++)
        {
            if (temp & 0x80)
                LCD12864_SetPixel(x + j, y + i, 1);
            else
                LCD12864_SetPixel(x + j, y + i, 0);
            temp <<= 1;
        }
    }
}

void LCD12864_PrintString(uint8_t x, uint8_t y, uint8_t *str)
{
    while (*str)
    {
        if (g_Col >= COL_MAX)    // 超过最大列数，换行
        {
            g_Row++;
            if (g_Row >= ROW_MAX)    // 超过最大行数，滚屏
            {
                g_Row = ROW_MAX - 1;
                LCD12864_ScrollUp();
                if (g_Page < g_TotalPage)    // 还有下一页
                    g_Page++;
                else
                    g_Page = 0;
                LCD12864_ClearRow(0);
                LCD12864_GotoXY(0, 0);
            }
            g_Col = 0;
        }

        if (*str < 0x80)    // ASCII字符
        {
            LCD12864_PrintChar(x + g_Col * 8, y + g_Row * 16, *str);
            g_Col++;
        }
        else    // 汉字
        {
            if (g_Col + 2 <= COL_MAX)    // 汉字需要2列
            {
                LCD12864_PrintChar(x + g_Col * 8, y + g_Row * 16, *str);
                LCD12864_PrintChar(x + (g_Col + 1) * 8, y + g_Row * 16, *(str + 1));
                g_Col += 2;
            }
            else    // 超出最大列数，换行
            {
                g_Row++;
                if (g_Row >= ROW_MAX)    // 超过最大行数，滚屏
                {
                    g_Row = ROW_MAX - 1;
                    LCD12864_ScrollUp();
                    if (g_Page < g_TotalPage)    // 还有下一页
                        g_Page++;
                    else
                        g_Page = 0;
                    LCD12864_ClearRow(0);
                    LCD12864_GotoXY(0, 0);
                }
                LCD12864_PrintChar(x + g_Col * 8, y + g_Row * 16, *str);
                LCD12864_PrintChar(x + (g_Col + 1) * 8, y + g_Row * 16, *(str + 1));
                g_Col = 2;
            }
            str++;    // 跳过下一个字符
        }
        str++;
    }
}

void LCD12864_PrintBuffer()
{
    uint8_t i, j;
    uint8_t *pBuf;

    pBuf = g_Buffer[g_Page];
    for (i = 0; i < ROW_MAX; i++)
    {
        for (j = 0; j < COL_MAX; j++)
        {
            if (*pBuf < 0x80)    // ASCII字符
            {
                LCD12864_PrintChar(j * 8, i * 16, *pBuf);
                pBuf++;
            }
            else    // 汉字
            {
                LCD12864_PrintChar(j * 8, i * 16, *pBuf);
                LCD12864_PrintChar((j + 1) * 8, i * 16, *(pBuf + 1));
                pBuf += 2;
            }
        }
    }
}

int main()
{
    uint8_t i, j;
    uint8_t ch = 0x80;    // 字符从第一个汉字开始
    uint8_t str[50];

    // 初始化LCD12864
    LCD12864_Init();

    // 计算总页数
    g_TotalPage = (HZK_NUM * HZK_SIZE) / (ROW_MAX * COL_MAX);

    // 填充显示缓冲区
    for (i = 0; i < ROW_MAX; i++)
    {
        for (j = 0; j < COL_MAX; j++)
        {
            if (ch < HZK_START + HZK_NUM * HZK_SIZE)    // 汉字库中还有汉字
            {
                g_Buffer[0][i * COL_MAX + j] = ch;
                ch += 2;
            }
            else    // 汉字库中汉字已经全部显示完毕，填充ASCII字符
            {
                g_Buffer[0][i * COL_MAX + j] = 'A' + i * COL_MAX + j;
            }
        }
    }

    // 显示第一页
    LCD12864_PrintBuffer();

    while (1)
    {
        // 采样翻页
        if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0)    // 按键按下
        {
            while (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0);    // 等待按键释放
            if (g_Page < g_TotalPage)    // 还有下一页
            {
                g_Page++;
                LCD12864_ClearRow(0);
                LCD12864_GotoXY(0, 0);
                LCD12864_PrintBuffer();
            }
            else    // 已经到最后一页，返回第一页
            {
                g_Page = 0;
                LCD12864_ClearRow(0);
                LCD12864_GotoXY(0, 0);
                LCD12864_PrintBuffer();
            }
        }

        // 向显示缓冲区添加新的内容
        sprintf((char *)str, "Test %d ", g_Col);
        LCD12864_PrintString(0, 0, str);
        for (i = 0; i < strlen((char *)str); i++)
            g_Buffer[g_Page][g_Row * COL_MAX + g_Col++] = str[i];
        delay_ms(500);
    }
}

该示例代码实现了将汉字存放在二维数组中，满屏后自动向上滚动，并且可以采样翻页的方式查看以往显示信息。具体实现过程为：

1. 定义LCD最大行数和列数，以及当前行数、列数和页数。

2. 定义显示缓冲区，用来存放当前页的所有字符。

3. 实现LCD12864_PrintChar函数，用于在LCD上显示一个汉字。

4. 实现LCD12864_PrintString函数，用于在LCD上显示一个字符串。

5. 在main函数中，初始化LCD12864，并计算总页数。

6. 填充显示缓冲区，先显示汉字，再显示ASCII字符。

7. 显示第一页。

8. 在循环中，采样翻页，按下按键后判断是否还有下一页，有则显示下一页，否则返回第一页。

9. 向显示缓冲区添加新的内容，先调用LCD12864_PrintString函数在LCD上显示新的字符串，再将其添加到显示缓冲区中。

需要注意的是，该示例代码中的LCD12864驱动和字库文件需要自己实现或者调用第三方库。此外，示例代码中使用了一个delay_ms函数，需要根据实际情况实现。