跳转到主要内容

通过部分帧缓冲降低内存使用率

本节以时钟应用为例，解释了如何配置和使用部分帧缓冲区，以牺牲一些性能为代价来降低对内存的需求。

下面是在STM32L4R9Discovery评估套件上运行的应用的视频

完整帧缓冲内存​

帧缓冲区通常是一个大型内存数组，其存储空间足以容纳显示屏上的所有可用像素数据。 If you are running on a 24-bit display with a resolution of 480 x 272, a full-size frame buffer holds 480 x 272 x 3 bytes = 391,680 bytes.

一些应用可能有2（“双重缓冲”）甚至3个帧缓冲区。 The total memory requirement in these cases would then be 783,360 and 1,175,040 bytes.

在绘制UI的任何部分时，TouchGFX向帧缓冲区写入像素值，在所有绘制操作完成后，帧缓冲区被传输到显示屏。 通常会将整个帧缓冲区传输到显示屏，即使只更新了UI的一部分。 在传输前，通常可以将帧缓冲分成许多小块进行更新。

更新1、更新2、更新3、……、更新N，传输至显示屏

在某些情况下，特别是在没有外部RAM的低成本解决方案中，帧缓冲区必须足够小，使内部RAM能满足帧缓冲和应用其余部分对内存的需求。 部分帧缓冲区在这种情况下十分有用。

部分帧缓冲内存​

部分帧缓冲区使TouchGFX应用能够在几个小于完整大小的帧缓冲区之上运行。 帧缓冲区的数量和大小是可配置的。 此技术可大幅降低应用的内存空间要求，但也带来了一些限制：

  • 部分帧缓冲区只能在具有内置存储器的显示屏上工作。 这些显示屏通常是DSI显示屏或具有并行总线连接（DBI A/B型，8080/6800）或SPI总线连接的显示屏。
  • 复杂应用可能发生撕裂。

完全帧缓冲区能存储显示屏上每一个像素的显示数据，与此不同，部分帧缓冲区通常只覆盖部分区域。 In the clock example used in this article, three frame buffers of 11,700 bytes each are used. This results in a memory footprint for frame buffers of 35,100 bytes.

当应用需要更新UI的某一部分时，TouchGFX将选择配置的部分帧缓冲区中的一个，在该部分帧缓冲中完成其绘图操作，并将该部分传输到显示屏。 对需要渲染的所有UI区域重复此操作 - 这将更新和传输数据的方式变更为：

更新1、传输1、更新2、传输2、更新3、传输3、……、更新N、传输N

在某些情况下，可以在更新下一个缓冲区的同时进行一个部分帧缓冲区的传输。

显示屏画面撕裂​

相比于使用完全帧缓冲区，在使用部分帧缓冲区时，TouchGFX会尽快传输更新过的UI部分。 由于显示屏需要定期刷新，在最多16 ms后（就60 fps显示屏而言），显示屏将在其屏幕上显示接收到的更新。 因此，在所有更新传输完毕之前，对显示屏的最初更新可能会被用户注意到。

如果绘图操作和传输的完整序列需要花费较长时间才能完成（> 16 ms），则用户很可能会看到上一帧与一些新的更新的组合。 这被称为画面撕裂，是不期望发生的。 因此，部分帧缓冲区不适合使用复杂动画、需要长时间渲染的应用。

显示屏更新示例​

在讨论如何在应用中配置部分帧缓冲区之前，我们先来看一个具体示例，该示例是一个数字时钟，用移动的圆弧来代表秒数。 绿色圆弧每秒移动6度，一分钟完成一整圈。 用如下图所示的四个控件构建UI：

以下是更新数字时钟和圆弧的代码：

MainView.cpp
void MainView::handleTickEvent()
{
  ticks++;
  if (ticks == 10)
  {
      ticks = 0;
      secs += 1;
      if (secs == 60)  //increment minutes
      {
        secs = 0;
        min += 1;
        if (min == 60) //increment hours
        {
          min = 0;
          hour += 1;
          if (hour == 24)
          {
            hour = 0;
          }
        }
        //Only update digital clock when minutes or hours change
        digitalClock.setTime24Hour(hour, min, secs);
      }
    //Always update seconds
    circleSeconds.updateArc(secs*6 - 20, secs*6);
  }
}

下图所示为在圆弧接近顶点和数字时钟更新时前几秒更新的区域（灰色矩形）。 在前两帧中，只有秒数在变化（58和59秒）。 在第三帧中，秒数达到60，小时和分钟文本更新：

上面第三幅图像中更新的矩形为154 x 60像素、 20 x 12像素和33 x 8像素。 在使用标准帧缓冲区时，这些矩形会被存入完整帧缓冲区中（覆盖之前的像素），完整帧缓冲区随后被传输到显示屏。 在使用部分帧缓冲区时，这三个矩形会被存入它们自己的小帧缓冲区中，随后立即被传输到显示屏并显示。

配置部分帧缓冲区​

TouchGFX需通过下面的步骤来使用部分帧缓冲区：

  1. 创建帧缓冲区分配器对象，并分配存储空间
  2. 配置TouchGFX HAL类以使用该分配器
  3. 写入代码以将缓冲区传输至显示屏

步骤1和2由TouchGFX Generator通过STM32CubeMX自动生成，而步骤3是一个专用驱动程序，用于将像素数据传输至显示屏。

以上配置生成以下代码：

TouchGFXGeneratedHAL.cpp
// Block Allocator for Partial Framebuffer strategy
static ManyBlockAllocator<1920, /* block size */
                          3,    /* number of blocks */
                          2     /* bytes per pixel */
                          > blockAllocator;

该帧缓冲区分配器分配3个块，每个1920字节。 TouchGFX HAL被自动配置为使用部分帧缓冲策略，并使用Block Allocator。

TouchGFXGeneratedHAL.cpp
void TouchGFXGeneratedHAL::initialize()
{
    HAL::initialize();

    registerEventListener(*(Application::getInstance()));
    enableLCDControllerInterrupt();
    enableInterrupts();
    // Partial framebuffer strategy
    setFrameBufferAllocator(&blockAllocator);
    setFrameRefreshStrategy(HAL::REFRESH_STRATEGY_PARTIAL_FRAMEBUFFER);
}

使用此配置，TouchGFX将分配小的帧缓冲区，并在其中绘制UI。 现在，只需将小的帧缓冲区传输到显示屏。

Lets first see the position and size of the two frame buffers allocated to draw the small circle updates (second image above) (assuming 24Bpp):

矩形xy宽度高度像素
矩形1112562214308像素 = 924字节
矩形2153422911319像素 = 957字节

这些矩形都很小，可以放入由帧缓冲区分配器分配的块中。

在上面的第三幅图中，更新了3个矩形：小矩形更新圆圈，较大的矩形覆盖文本：

矩形xy宽度高度像素
矩形1126512012240像素 = 720字节
矩形216542338264像素 = 792字节
矩形3118165154609,240 pixels = 27,720 bytes

同样地，矩形1和2很小，可以放入由帧缓冲区分配器分配的块中，但帧缓冲区3过大。 This rectangle is to large and will be split into multiple rectangles that each can fit into the frame buffers (11,700 bytes).

这里即将更新的第3个矩形太大，无法直接存入最后第3个缓冲区块。 在这种情况下，TouchGFX将等待第一个块传输完毕，然后重复使用第一个块。

将帧缓冲区传输到屏幕​

当需要重新绘制某个矩形区域时，TouchGFX将从FrameBufferAllocator分配帧缓冲区。 在绘制完成后，TouchGFX将调用此方法：

void HAL::flushFrameBuffer(const Rect& rect);

在HAL子类中，此函数可以被重写，以便将帧缓冲区传输至屏幕。 为了让部分帧缓冲发挥作用，需要用到此特殊实现。 下面几节将描述如何对搭载SPI显示屏的 STM32G071评估套件和搭载DSI显示屏的STM32L4R9Discovery评估套件进行相关配置。

将帧缓冲区传输到X-NUCLEO-GFX01M1 SPI显示屏​

本节将讨论STM32G071 nucleo板和X-Nucleo-GFX01M1扩展板的TouchGFX应用模板。 此扩展板（MB1642B）包含一个2.2” 240x320 SPI显示屏和一个 64-Mbit SPI NOR Flash。

Nucleo-G071RB和X-Nucleo-GFX01M1扩展板

在此TouchGFX应用模板中，我们使用了框架中的一个C++类来帮助管理部分帧缓冲块。 这样可以使代码更简洁。

使用TouchGFX Generator来构建TouchGFX应用模板。 点击 此处阅读更多相关内容

最重要的部分是flushFrameBuffer函数：

TouchGFXGeneratedHAL.cpp
void TouchGFXGeneratedHAL::flushFrameBuffer(const touchgfx::Rect& rect)
{
    HAL::flushFrameBuffer(rect);
    // Try transmitting a block
    PartialFrameBufferManager::tryTransmitBlock();
}

这里我们只需调用PartialFrameBufferManager框架类来获取发送的块。

在TouchGFXGeneratedHAL::endFrame函数中，我们也调用 PartialFrameBufferManager来获取已发送的任何剩余帧缓冲块：

TouchGFXGeneratedHAL.cpp
void TouchGFXGeneratedHAL::endFrame()
{
    // We must guard the next frame until we're done transferring all blocks over our display interface
    // through either a semaphore if user is running an OS or a simple variable if not
    PartialFrameBufferManager::transmitRemainingBlocks();

    HAL::endFrame();
    touchgfx::OSWrappers::signalRenderingDone();
}

PartialFrameBufferManager使用三个函数与显示屏驱动程序代码进行交互。 这些必须在TouchGFX应用模板中实现：

TouchGFXGeneratedHAL.cpp
/**
 * Check if a Frame Buffer Block is beeing transmitted.
 */
__weak int transmitActive()
{
    return touchgfxDisplayDriverTransmitActive();
}

/**
 * Check if a Frame Buffer Block ending at bottom may be sent.
 */
__weak int shouldTransferBlock(uint16_t bottom)
{
    return touchgfxDisplayDriverShouldTransferBlock(bottom);
}

/**
 * Transmit a Frame Buffer Block.
 */
__weak void transmitBlock(const uint8_t* pixels, uint16_t x, uint16_t y, uint16_t w, uint16_t h)
{
    touchgfxDisplayDriverTransmitBlock(pixels, x, y, w, h);
}

以上代码将调用转发到MB1642B驱动程序代码中的C函数。

MB1642BDisplayDriver.c
int touchgfxDisplayDriverTransmitActive(void)
{
  return IsTransmittingBlock_;
}

void touchgfxDisplayDriverTransmitBlock(const uint8_t* pixels, uint16_t x, uint16_t y, uint16_t w, uint16_t h)
{
  Display_Bitmap((uint16_t*)pixels, x, y, w, h);
}

此驱动程序代码的实现高度依赖于使用的显示屏。 对于MB1642B模块，这包含两个GPIO，用于控制SPI芯片选择和数据/指令模式。

使用易失性uint8t变量*IsTransmittingBlock*表示发送状态。 在开始发送时，此变量置为1，并在DMA回调中置为0：

MB1642BDisplayDriver.c
void MB1642BDisplayDriver_DMACallback(void)
{
  /* Transfer Complete Interrupt management ***********************************/
  if ((0U != (DMA1->ISR & (DMA_FLAG_TC1))) && (0U != (hdma_spi1_tx.Instance->CCR & DMA_IT_TC)))
  {
    /* Disable the transfer complete and error interrupt */
    __HAL_DMA_DISABLE_IT(&hdma_spi1_tx, DMA_IT_TE | DMA_IT_TC);

    /* Clear the transfer complete flag */
    __HAL_DMA_CLEAR_FLAG(&hdma_spi1_tx, DMA_FLAG_TC1);

    IsTransmittingBlock_ = 0;

    ...

    // Signal Transfer Complete to TouchGFX
    DisplayDriver_TransferCompleteCallback();

在上文中可以看到，DMA回调也调用传输完成回调。 此函数在生成的HAL类中实现：

TouchGFXGeneratedHAL.cpp
extern "C"
void DisplayDriver_TransferCompleteCallback()
{
    // After completed transmission start new transfer if blocks are ready.
    PartialFrameBufferManager::tryTransmitBlockFromIRQ();
}

此处对PartialFrameBufferManager的调用使之开始新的传输（如可能）。

将帧缓冲区传输到DSI显示屏​

STM32L4R9Discovery评估套件使用DSI显示屏。 普通HAL类称为STM32HAL_DSI（位于STM32HAL_DSI.cpp中）。

我们重写HAL::flushFrameBuffer方法，以便通知FrameBufferAllocator某个块已绘制完成：

TouchGFXHAL.hpp
void TouchGFXHAL::flushFrameBuffer(const Rect& rect)
{
    frameBufferAllocator->markBlockReadyForTransfer();
    HAL::flushFrameBuffer(rect); //call normal implementation
}

当块可以进行传输时，FrameBufferAllocator子类ManyBlockAllocator将调用全局函数FrameBufferAllocatorSignalBlockDrawn()。 此方法必须在BSP层实现：

TouchGFXGeneratedHAL.cpp
void FrameBufferAllocatorSignalBlockDrawn()
  {
    if (!dsiIsTransferring)
    {
      sendBlock();
    }
  }

此函数调用sendBlock函数，除非DSI上已经在进行传输。 对于TouchGFX绘制的第一个块，不存在这种情况，因此开始传输。 如果在DSI传输仍在运行时完成了另一个块的绘制，块将保持“准备传输状态”，并将继续另一个空闲块（如可用）的绘制。

当DSI传输完成时，我们必须首先释放已传输的块，以便将其重复用于另一个矩形，然后检查下一个块是否可以开始传输。 这些全部在ER中断中完成：

TouchGFXHAL.cpp
__irq void DSI_IRQHandler(void) {
  if (__HAL_DSI_GET_FLAG(&hdsi, DSI_IT_ER))
  {
    // End-of-refresh interrupt. 表示最后一次DSI传输已完成
    __HAL_DSI_CLEAR_FLAG(&hdsi, DSI_IT_ER);
    if (dsiIsTransferring)
    {
      HAL::getInstance()->getFrameBufferAllocator()->freeBlockAfterTransfer();
      dsiIsTransferring = 0;
    }
    sendBlock(); //transfer next block if availble
  }

函数sendBlock更为复杂。 下面我们配置LTDC和DSI外设，以便传输帧缓冲。 我们还将配置显示屏，以便将传输的数据放入显示屏存储器中的正确位置。 这部分代码依赖于特定的显示屏。 请检查显示屏数据手册了解指令规范。

TouchGFXHAL.cpp
static void sendBlock()
{
    FrameBufferAllocator* fbAllocator = HAL::getInstance()->getFrameBufferAllocator();

    //Is a block ready for transfer?
    if (fbAllocator->hasBlockReadyForTransfer())
    {
        Rect transfer_rect;
        const uint8_t* src = fbAllocator->getBlockForTransfer(transfer_rect);
        dsiIsTransferring = 1;

        //1. Setup LTDC and layer address and dimension
        //2. Configure display active area
        //3. Start DSI

        __HAL_DSI_WRAPPER_DISABLE(&hdsi);

        //1: Setup LTDC
        LTDC_Layer1->CFBAR = (uint32_t)src;

        const uint32_t width = transfer_rect.width;
        const uint32_t height = transfer_rect.height;

        LTDC->AWCR = ((width + 1) << 16) | (height + 1);
        LTDC->TWCR = ((width + 1 + 1) << 16) | (height + 1 + 1);

        const uint16_t layer_x0 = 2 + 0;
        const uint16_t layer_x1 = 2 + width - 1;
        LTDC_Layer1->WHPCR = (layer_x1 << 16) | layer_x0;

        const uint16_t layer_y0 = 2 + 0;
        const uint16_t layer_y1 = 2 + height - 1;
        LTDC_Layer1->WVPCR = (layer_y1 << 16) | layer_y0;

        LTDC_Layer1->CFBLR = ((width * 3) << 16) | (width * 3 + 3);
        LTDC_Layer1->CFBLNR = height;

        LTDC->SRCR = (uint32_t)LTDC_SRCR_IMR;

        //2: Configure display
        const int16_t x = transfer_rect.x + 4;
        const int16_t x2 = transfer_rect.x + 4 + width - 1;
        uint8_t InitParam1[4] = { (uint8_t)(x >> 8), (uint8_t)(x & 0xFF), (uint8_t)(x2 >> 8), (uint8_t)(x2 & 0xFF)};
        HAL_DSI_LongWrite(&hdsi, 0, DSI_DCS_LONG_PKT_WRITE, 4, DSI_SET_COLUMN_ADDRESS, InitParam1);

        const int16_t y = transfer_rect.y;
        const int16_t y2 = transfer_rect.y + height - 1;
        uint8_t InitParam2[4] = { (uint8_t)(y >> 8), (uint8_t)(y & 0xFF), (uint8_t)(y2 >> 8), (uint8_t)(y2 & 0xFF) };
        HAL_DSI_LongWrite(&hdsi, 0, DSI_DCS_LONG_PKT_WRITE, 4, DSI_SET_PAGE_ADDRESS, InitParam2);

        //3: Start DSI transfer
        __HAL_DSI_WRAPPER_ENABLE(&hdsi);
        HAL_DSI_Refresh(&hdsi);
    }
}

将帧缓冲区传输到SPI显示屏​

将矩形传输到显示屏的原理与DSI的相同，但在细节上存在一些差异。

首先，当矩形区域绘制完成时，如果当前没有进行任何传输，则立即开始传输：

TouchGFXHAL.cpp
void TouchGFXHAL::flushFrameBuffer(const touchgfx::Rect& rect)
{
    HAL::flushFrameBuffer(rect);
    frameBufferAllocator->markBlockReadyForTransfer();
    //start transfer if not running already!
    if (!LCDManager_IsTransmittingData())
    {
        touchgfx::Rect r;
        const uint8_t* pixels = frameBufferAllocator->getBlockForTransfer(r);
        LCDManager_SendFrameBufferBlockWithPosition((uint8_t*)pixels, r.x, r.y, r.width, r.height);
    }
}

LCDManager_SendFrameBufferBlockWithPosition函数使用SPI DMA方式进行传输，将数据发给显示屏。

当传输完成时，SPI传输完成中断会调用完成回调函数：

TouchGFXHAL.cpp
void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi)
{
    UNUSED(hspi);
    LCD_CS_HIGH();
    isTransmittingData = 0;

    //Change to SPI datasize to 8 bit from 16 bit
    heval_Spi.Instance->CR2 &= ~(SPI_DATASIZE_16BIT - SPI_DATASIZE_8BIT);

    //signal transfer complete
    LCDManager_TransferComplete();
}

LCDManager_TransferComplete函数发起新的传输：

TouchGFXHAL.cpp
void LCDManager_TransferComplete()
{
    touchgfx::startNewTransfer();
}

void startNewTransfer()
{
    FrameBufferAllocator* fba = HAL::getInstance()->getFrameBufferAllocator();
    fba->freeBlockAfterTransfer();
    blockIsTransferred = true;

    if (fba->hasBlockReadyForTransfer())
    {
        touchgfx::Rect r;
        const uint8_t* pixels = fba->getBlockForTransfer(r);
        LCDManager_SendFrameBufferBlockWithPosition((uint8_t*)pixels, r.x, r.y, r.width, r.height);
    }
}

结论​

在本文中，我们讨论了对于显示屏具有集成帧缓冲存储器的平台而言，部分帧缓冲区策略如何降低其存储空间要求。

配置和设置部分帧缓冲的方法在所有平台上都是一样的，但向显示屏发送块内容的方法并不相同。 我们看到，对于基于LTDC/DSI的平台（STM32L4R9-DISCO），我们能够重新配置LTDC层，以使下一个帧缓冲块适合通过DSI进行传输，而在没有LCD控制器（STM32G071）的平台上，我们能够使用SPI向显示屏发送帧缓冲块。