// 使能串口中断接收
HAL_UART_Receive_IT(&huart1, (uint8_t*)&DataTemp_UART1, 1);

#include "stdio.h"
int fputc(int ch, FILE *f){
    HAL_UART_Transmit(&huart1, (uint8_t*)&ch, 1, 0XFF);
    return ch;
}

#define UART1BuffLen 200
extern uint8_t DataBuff_UART1[UART1BuffLen];
extern uint32_t DataTemp_UART1;
extern uint16_t DataSTA_UART1;

uint32_t DataTemp_UART1;
uint8_t DataBuff_UART1[UART1BuffLen];
uint16_t DataSTA_UART1;
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  if(huart->Instance == USART1){
    if(DataSTA_UART1 < UART1BuffLen){
        if(DataTemp_UART1 == 0x0A && DataSTA_UART1>0 && DataBuff_UART1[DataSTA_UART1-1]==0X0D){
            printf("USART: %srn", DataBuff_UART1);
            DataSTA_UART1 = 0;
        }
        else{
            if(DataSTA_UART1 == 0){
                memset(DataBuff_UART1, 0, sizeof(DataBuff_UART1));
            }
            DataBuff_UART1[DataSTA_UART1++] = DataTemp_UART1;
        }
    }
    // 使能串口中断接收
    HAL_UART_Receive_IT(&huart1, (uint8_t*)&DataTemp_UART1, 1);
  }
}

RTC_DateTypeDef sDate;
RTC_TimeTypeDef sTime;	
uint8_t second_tmp = 0;


HAL_RTC_GetTime(&hrtc, &sTime, RTC_FORMAT_BIN); // 读取时间
HAL_RTC_GetDate(&hrtc, &sDate, RTC_FORMAT_BIN); // 读取日期
if(second_tmp != sTime.Seconds) { // 读取秒
    second_tmp = sTime.Seconds;
    printf("20%d%d-%d%d-%d%drn", 
           sDate.Year/10%10, sDate.Year%10, 
           sDate.Month/10%10, sDate.Month%10, 
           sDate.Date/10%10, sDate.Date%10);
    printf("%d%d:%d%d:%d%drn", 
           sTime.Hours/10%10, sTime.Hours%10, 
           sTime.Minutes/10%10, sTime.Minutes%10, 
           sTime.Seconds/10%10, sTime.Seconds%10);
}

static void BL8782_PDN_INIT(void)
{
  /*定义一个GPIO_InitTypeDef类型的结构体*/
  GPIO_InitTypeDef GPIO_InitStructure;

  RCC_AHB1PeriphClockCmd ( RCC_AHB1Periph_GPIOB, ENABLE); 							   
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;	
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;   
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; 
  GPIO_Init(GPIOB, &GPIO_InitStructure);	
  
  GPIO_ResetBits(GPIOB,GPIO_Pin_13);  //禁用WiFi模块
}

UINT bw;
retSD = f_mount(&SDFatFS, SDPath, 0);
if(retSD != FR_OK) {
    printf("Mount Error :%drn", retSD);
}
retSD = f_open(&SDFile, "0:/test.txt", FA_CREATE_ALWAYS | FA_WRITE);
if(retSD != FR_OK){
    printf("Open Error :%drn", retSD);
}
retSD = f_write(&SDFile, "abcde", 5, &bw);
if(retSD != FR_OK){
    printf("Write Error :%drn", retSD);
}
f_close(&SDFile);
retSD = f_open(&SDFile, "0:/test.txt", FA_READ);
char buff[10] = {0};
retSD = f_read(&SDFile, buff, 5, &bw);
if(retSD == FR_OK){
    printf("%srn", buff);
}
f_close(&SDFile);

uint8_t temp[100]__attribute__((at(0xD0000000)));   
for(int i=0;i<100;i++){
    temp[i] = i;
}
for(int i=0;i<100;i++){
    printf("%d  ", temp[i]);
}

/*****************************SDRAM使能函数******************************/

/**
  * @brief  对SDRAM芯片进行初始化配置
  * @param  None. 
  * @retval None.
  */
static void USER_SDRAM_ENABLE(void)
{
	FMC_SDRAM_CommandTypeDef Command;
	
  __IO uint32_t tmpmrd =0;
  
  /* Step 1:  Configure a clock configuration enable command */
  Command.CommandMode             = FMC_SDRAM_CMD_CLK_ENABLE;
  Command.CommandTarget           = FMC_SDRAM_CMD_TARGET_BANK2;
  Command.AutoRefreshNumber       = 1;
  Command.ModeRegisterDefinition  = 0;

  /* Send the command */
  HAL_SDRAM_SendCommand(&hsdram1, &Command, SDRAM_TIMEOUT);

  /* Step 2: Insert 100 us minimum delay */ 
  /* Inserted delay is equal to 1 ms due to systick time base unit (ms) */
  HAL_Delay(1);

  /* Step 3: Configure a PALL (precharge all) command */ 
  Command.CommandMode             = FMC_SDRAM_CMD_PALL;
  Command.CommandTarget           = FMC_SDRAM_CMD_TARGET_BANK2;
  Command.AutoRefreshNumber       = 1;
  Command.ModeRegisterDefinition  = 0;

  /* Send the command */
  HAL_SDRAM_SendCommand(&hsdram1, &Command, SDRAM_TIMEOUT);  
  
  /* Step 4: Configure an Auto Refresh command */ 
  Command.CommandMode             = FMC_SDRAM_CMD_AUTOREFRESH_MODE;
  Command.CommandTarget           = FMC_SDRAM_CMD_TARGET_BANK2;
  Command.AutoRefreshNumber       = 4;
  Command.ModeRegisterDefinition  = 0;

  /* Send the command */
  HAL_SDRAM_SendCommand(&hsdram1, &Command, SDRAM_TIMEOUT);
  
  /* Step 5: Program the external memory mode register */
  tmpmrd = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_2          |
                     SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL   |
                     SDRAM_MODEREG_CAS_LATENCY_3           |
                     SDRAM_MODEREG_OPERATING_MODE_STANDARD |
                     SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;
  
  Command.CommandMode             = FMC_SDRAM_CMD_LOAD_MODE;
  Command.CommandTarget           = FMC_SDRAM_CMD_TARGET_BANK2;
  Command.AutoRefreshNumber       = 1;
  Command.ModeRegisterDefinition  = tmpmrd;

  /* Send the command */
  HAL_SDRAM_SendCommand(&hsdram1, &Command, SDRAM_TIMEOUT);
  
  /* Step 6: Set the refresh rate counter */
  /* Set the device refresh rate */
  HAL_SDRAM_ProgramRefreshRate(&hsdram1, REFRESH_COUNT); 
}
/*****************************使能函数结束******************************/

#include "bsp_sdram.h"
MX_FMC_Init();
SDRAM_InitSequence(); 
SDRAM_Test();

C:Users10617STM32CubeRepositoryPacksSTMicroelectronicsX-CUBE-TOUCHGFX4.15.0UtilitiesPC_SoftwareTouchGFXDesignerTouchGFX-4.14.0.msi

#include "app_touchgfx.h"

// 开启LCD
LCD_DisplayOn();
LCD_SetLayerVisible(1,DISABLE);
LCD_SetLayerVisible(0,ENABLE);
LCD_SetTransparency(1,0);
LCD_SetTransparency(0,255);
LCD_SelectLayer(0);
// 显示TouchGFX内容
MX_TouchGFX_Process();

#if 1 
#pragma import(__use_no_semihosting)              
//标准库需要的支持函数                  
struct __FILE  
{  
	int handle;  
};  

FILE __stdout;        
//定义_sys_exit()以避免使用半主机模式     
void _sys_exit(int x)  
{  
	x = x;  
}  
void _ttywrch(int ch)
{
	ch = ch;
}
//重定义fputc函数  
int fputc(int ch, FILE *f) 
{       
	HAL_UART_Transmit(&huart1, (uint8_t*)&ch, 1, 0XFF);
	return ch; 
} 
#endif 

/**********************
 *  STATIC VARIABLES
 **********************/
static __IO uint16_t * my_fb = (__IO uint16_t*) (0xD0000000);

static DMA_HandleTypeDef  DmaHandle;
static int32_t            x1_flush;
//static int32_t            y1_flush;
static int32_t            x2_flush;
static int32_t            y2_fill;
static int32_t            y_fill_act;
static const lv_color_t * buf_to_flush;
static lv_disp_t *our_disp = NULL;

/*********************
 *      INCLUDES
 *********************/
#include "lv_port_disp.h"
#include "bsp_lcd.h"
#include "dma2d.h"
#include "stm32f4xx_hal_dma.h"
#include "dma.h"

static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p)
{
//    int32_t x;
//    int32_t y;
//    for(y = area->y1; y <= area->y2; y++) {
//        for(x = area->x1; x <= area->x2; x++) {
//            /* Put a pixel to the display. For example: */
//            /* put_px(x, y, *color_p)*/
						LCD_FillRect_C(area->x1, area->y1, area->x2-area->x1, area->y2-area->y1, (uint32_t)color_p);
						LCD_DrawPixel(x, y, (uint32_t)color_p->full);
//						LCD_FillRect_C(x, y, 1, 1, (uint32_t)color_p->full);
//            color_p++;
//        }
//    }

    int32_t x1 = area->x1;
    int32_t x2 = area->x2;
    int32_t y1 = area->y1;
    int32_t y2 = area->y2;
    /*Return if the area is out the screen*/
    if(x2 < 0) return;
    if(y2 < 0) return;
    if(x1 > LV_HOR_RES_MAX - 1) return;
    if(y1 > LV_VER_RES_MAX - 1) return;
    /*Truncate the area to the screen*/
    int32_t act_x1 = x1 < 0 ? 0 : x1;
    int32_t act_y1 = y1 < 0 ? 0 : y1;
    int32_t act_x2 = x2 > LV_HOR_RES_MAX - 1 ? LV_HOR_RES_MAX - 1 : x2;
    int32_t act_y2 = y2 > LV_VER_RES_MAX - 1 ? LV_VER_RES_MAX - 1 : y2;
    x1_flush = act_x1;
    //		y1_flush = act_y1;
    x2_flush = act_x2;
    y2_fill = act_y2;
    y_fill_act = act_y1;
    buf_to_flush = color;
    HAL_StatusTypeDef err;
    uint32_t length = (x2_flush - x1_flush + 1);
    #if LV_COLOR_DEPTH == 24 || LV_COLOR_DEPTH == 32
    length *= 2; /* STM32 DMA uses 16-bit chunks so multiply by 2 for 32-bit color */
    #endif
    err = HAL_DMA_Start_IT(&hdma_memtomem_dma2_stream0,(uint32_t)buf_to_flush, (uint32_t)&my_fb[y_fill_act * LV_HOR_RES_MAX + x1_flush], length);
    if(err != HAL_OK) {
        printf("disp_flush %drn",err);
        while(1);	/*Halt on error*/
    }

    lv_disp_flush_ready(disp_drv);
}

lv_init();
lv_port_disp_init();

// 开启LCD
LCD_DisplayOn();
LCD_SetLayerVisible(1,DISABLE);
LCD_SetLayerVisible(0,ENABLE);
LCD_SetTransparency(1,0);
LCD_SetTransparency(0,255);
LCD_SelectLayer(0);
LCD_Clear(LCD_COLOR_BLUE);

/*Create a Label on the currently active screen*/
lv_obj_t * label1 =  lv_label_create(lv_scr_act(), NULL);
/*Modify the Label's text*/
lv_label_set_text(label1, "Hello world!");
/* Align the Label to the center
	 * NULL means align on parent (which is the screen now)
	 * 0, 0 at the end means an x, y offset after alignment*/
lv_obj_align(label1, NULL, LV_ALIGN_CENTER, 0, 0);

#include "bsp_lcd.h"
static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p)
{
  int32_t x;
  int32_t y;
    for(y = area->y1; y <= area->y2; y++) {
      for(x = area->x1; x <= area->x2; x++) {
          LCD_DrawPixel(x, y, (uint32_t)color_p->full);
          color_p++;
      }	
    }
    lv_disp_flush_ready(disp_drv);
}