static void DMA2D_Config(void)
{
/* Configure the DMA2D Mode, Color Mode and output offset */
Dma2dHandle.Init.Mode = DMA2D_M2M_BLEND;
Dma2dHandle.Init.ColorMode = DMA2D_RGB565;
Dma2dHandle.Init.OutputOffset = 0x0;
/* DMA2D Callbacks Configuration */
Dma2dHandle.XferCpltCallback = TransferComplete;
Dma2dHandle.XferErrorCallback = TransferError;
/* Foreground Configuration */
Dma2dHandle.LayerCfg[1].AlphaMode = DMA2D_REPLACE_ALPHA;
Dma2dHandle.LayerCfg[1].InputAlpha = 0x7F;
Dma2dHandle.LayerCfg[1].InputColorMode = CM_RGB565;
Dma2dHandle.LayerCfg[1].InputOffset = 0x0;
/* Background Configuration */
Dma2dHandle.LayerCfg[0].AlphaMode = DMA2D_REPLACE_ALPHA;
Dma2dHandle.LayerCfg[0].InputAlpha = 0x7F;
Dma2dHandle.LayerCfg[0].InputColorMode = CM_RGB565;
Dma2dHandle.LayerCfg[0].InputOffset = 0x0;
Dma2dHandle.Instance = DMA2D;
/* DMA2D Initialisation */
if(HAL_DMA2D_Init(&Dma2dHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
HAL_DMA2D_ConfigLayer(&Dma2dHandle, 0);
HAL_DMA2D_ConfigLayer(&Dma2dHandle, 1);
}
static void DMA2D_Config(void)
{
HAL_StatusTypeDef hal_status = HAL_OK;
/* Configure the DMA2D Mode, Color Mode and output offset */
Dma2dHandle.Init.Mode = DMA2D_M2M_PFC; /* DMA2D mode Memory to Memory with Pixel Format Conversion */
Dma2dHandle.Init.ColorMode = DMA2D_ARGB4444; /* DMA2D Output color mode is ARGB4444 (16 bpp) */
Dma2dHandle.Init.OutputOffset = 0x0; /* No offset in output */
/* DMA2D Callbacks Configuration */
Dma2dHandle.XferCpltCallback = TransferComplete;
Dma2dHandle.XferErrorCallback = TransferError;
/* Foreground layer Configuration : layer 1 */
Dma2dHandle.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
Dma2dHandle.LayerCfg[1].InputAlpha = 0xFF; /* Alpha fully opaque */
Dma2dHandle.LayerCfg[1].InputColorMode = CM_ARGB8888; /* Layer 1 input format is ARGB8888 (32 bpp) */
Dma2dHandle.LayerCfg[1].InputOffset = 0x0; /* No offset in input */
Dma2dHandle.Instance = DMA2D;
/* DMA2D Initialization */
hal_status = HAL_DMA2D_Init(&Dma2dHandle);
OnError_Handler(hal_status != HAL_OK);
hal_status = HAL_DMA2D_ConfigLayer(&Dma2dHandle, 1);
OnError_Handler(hal_status != HAL_OK);
}
/**
* @brief Converts a camera buffer line of format RGB565
* to a LCD display frame buffer line in format ARGB8888 using DMA2D service.
* @param pSrc: Pointer to source buffer
* @param pDst: Pointer to destination buffer
* @param xSize: Buffer width
* @retval None
*/
static void ConvertCameraLineRgb565ToLcdLineARGB8888(void *pSrc, void *pDst, uint32_t xSize)
{
HAL_StatusTypeDef hal_status = HAL_OK;
/* Configure the DMA2D Mode, Color Mode and output offset */
hdma2d_camera.Init.Mode = DMA2D_M2M_PFC;
hdma2d_camera.Init.ColorMode = DMA2D_ARGB8888;
hdma2d_camera.Init.OutputOffset = 0;
/* Foreground Configuration */
hdma2d_camera.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d_camera.LayerCfg[1].InputAlpha = 0xFF;
hdma2d_camera.LayerCfg[1].InputColorMode = DMA2D_RGB565;
hdma2d_camera.LayerCfg[1].InputOffset = 0;
hdma2d_camera.Instance = DMA2D;
/* DMA2D Initialization */
if (HAL_DMA2D_Init(&hdma2d_camera) == HAL_OK)
{
if (HAL_DMA2D_ConfigLayer(&hdma2d_camera, 1) == HAL_OK)
{
if (HAL_DMA2D_Start(&hdma2d_camera, (uint32_t)pSrc, (uint32_t)pDst, xSize, 1) == HAL_OK)
{
/* Polling For DMA transfer */
hal_status = HAL_DMA2D_PollForTransfer(&hdma2d_camera, 10);
ASSERT(hal_status != HAL_OK);
}
}
}
}
/**
* @brief Converts a camera buffer line of format RGB565
* to a LCD display frame buffer column in format ARGB8888 using DMA2D service.
* This handles the rotation of 90 degrees hour direction of camera buffer.
* @param pSrc: Pointer to source buffer
* @param pDst: Pointer to destination buffer
* @param xSize: Buffer width
* @param lineStridePixels: line stride in pixels unit
* @retval None
*/
static void ConvertCameraLineRgb565ToLcdColumnARGB8888(void *pSrc, void *pDst, uint32_t xSize, uint32_t lineStridePixels)
{
HAL_StatusTypeDef hal_status = HAL_OK;
/* Configure the DMA2D Mode, Color Mode and output offset */
hdma2d_eval.Init.Mode = DMA2D_M2M_PFC;
hdma2d_eval.Init.ColorMode = DMA2D_ARGB8888;
hdma2d_eval.Init.OutputOffset = lineStridePixels;
/* Foreground Configuration */
hdma2d_eval.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d_eval.LayerCfg[1].InputAlpha = 0xFF;
hdma2d_eval.LayerCfg[1].InputColorMode = DMA2D_RGB565;
hdma2d_eval.LayerCfg[1].InputOffset = 0;
hdma2d_eval.Instance = DMA2D;
/* DMA2D Initialization */
if (HAL_DMA2D_Init(&hdma2d_eval) == HAL_OK)
{
if (HAL_DMA2D_ConfigLayer(&hdma2d_eval, 1) == HAL_OK)
{
/* xSize x 1 = size in pixels to copy */
/* Width = 1, Height = xSize */
if (HAL_DMA2D_Start(&hdma2d_eval, (uint32_t)pSrc, (uint32_t)pDst, 1, xSize) == HAL_OK)
{
/* Polling For DMA transfer */
hal_status = HAL_DMA2D_PollForTransfer(&hdma2d_eval, 10);
BSP_TEST_APPLI_ASSERT(hal_status != HAL_OK);
}
}
}
}
/**
* @brief Converts a line to an ARGB8888 pixel format.
* @param pSrc: Pointer to source buffer
* @param pDst: Output color
* @retval None
*/
static void LCD_LL_ConvertLineToARGB8888(void *pSrc, void *pDst)
{
static DMA2D_HandleTypeDef hdma2d_eval;
/* Enable DMA2D clock */
__HAL_RCC_DMA2D_CLK_ENABLE();
/* Configure the DMA2D Mode, Color Mode and output offset */
hdma2d_eval.Init.Mode = DMA2D_M2M_PFC;
hdma2d_eval.Init.ColorMode = DMA2D_ARGB8888;
hdma2d_eval.Init.OutputOffset = 0;
/* Foreground Configuration */
hdma2d_eval.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d_eval.LayerCfg[1].InputAlpha = 0xFF;
hdma2d_eval.LayerCfg[1].InputColorMode = CM_RGB565;
hdma2d_eval.LayerCfg[1].InputOffset = 0;
hdma2d_eval.Instance = DMA2D;
/* DMA2D Initialization */
if(HAL_DMA2D_Init(&hdma2d_eval) == HAL_OK)
{
if(HAL_DMA2D_ConfigLayer(&hdma2d_eval, 1) == HAL_OK)
{
if (HAL_DMA2D_Start(&hdma2d_eval, (uint32_t)pSrc, (uint32_t)pDst, BSP_LCD_GetXSize(), 1) == HAL_OK)
{
/* Polling For DMA transfer */
HAL_DMA2D_PollForTransfer(&hdma2d_eval, 10);
}
}
}
}
/**
* @brief Converts a RGB565 camera frame buffer line (width = 320 pixels)
* into a ARGB8888 LCD Frame buffer line (of same width 320 pixels).
* @param pSrc: Pointer to source buffer in Camera frame buffer (camera frame buffer line)
* @param pDst: Pointer to destination buffer in LCD frame buffer (LCD frame buffer line)
* @param xSize: Buffer width
* @retval None
*/
static void LCD_LL_ConvertLineToARGB8888(void *pSrc, void *pDst, uint32_t xSize)
{
DMA2D_HandleTypeDef hdma2d_eval;
/* Configure the DMA2D Mode, Color Mode and output offset */
hdma2d_eval.Init.Mode = DMA2D_M2M_PFC;
hdma2d_eval.Init.ColorMode = DMA2D_ARGB8888; /* Output color out of PFC */
hdma2d_eval.Init.OutputOffset = 0;
/* Foreground Configuration */
hdma2d_eval.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d_eval.LayerCfg[1].InputAlpha = 0xFF; /* fully opaque */
hdma2d_eval.LayerCfg[1].InputColorMode = CM_RGB565;
hdma2d_eval.LayerCfg[1].InputOffset = 0;
hdma2d_eval.Instance = DMA2D;
/* DMA2D Initialization */
if(HAL_DMA2D_Init(&hdma2d_eval) == HAL_OK)
{
if(HAL_DMA2D_ConfigLayer(&hdma2d_eval, 1) == HAL_OK)
{
if (HAL_DMA2D_Start(&hdma2d_eval, (uint32_t)pSrc, (uint32_t)pDst, xSize, 1) == HAL_OK)
{
/* Polling For DMA transfer */
HAL_DMA2D_PollForTransfer(&hdma2d_eval, 10);
}
}
}
else
{
while(1);
}
}
static void DMA2D_Config(void)
{
/* Configure the DMA2D Mode, Color Mode and output offset */
Dma2dHandle.Init.Mode = DMA2D_M2M_PFC;
Dma2dHandle.Init.ColorMode = DMA2D_ARGB4444;
Dma2dHandle.Init.OutputOffset = 0x0;
/* DMA2D Callbacks Configuration */
Dma2dHandle.XferCpltCallback = TransferComplete;
Dma2dHandle.XferErrorCallback = TransferError;
/* Foreground Configuration */
Dma2dHandle.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
Dma2dHandle.LayerCfg[1].InputAlpha = 0xFF;
Dma2dHandle.LayerCfg[1].InputColorMode = CM_ARGB8888;
Dma2dHandle.LayerCfg[1].InputOffset = 0x0;
Dma2dHandle.Instance = DMA2D;
/* DMA2D Initialisation */
if(HAL_DMA2D_Init(&Dma2dHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
if(HAL_DMA2D_ConfigLayer(&Dma2dHandle, 1) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
}
/**
* @brief DMA2D configuration.
* @note This function Configure tha DMA2D peripheral :
* 1) Configure the transfer mode : memory to memory
* 2) Configure the output color mode as ARGB4444
* 3) Configure the transfer from FLASH to SRAM
* 4) Configure the data size : 150x150 (pixels)
* @retval
* None
*/
static void DMA2D_Config(void)
{
/* Configure the DMA2D Mode, Color Mode and output offset */
Dma2dHandle.Init.Mode = DMA2D_M2M; /* DMA2D Mode memory to memory */
Dma2dHandle.Init.ColorMode = DMA2D_ARGB4444; /* Output color mode is ARGB4444 : 16 bpp */
Dma2dHandle.Init.OutputOffset = 0x0; /* No offset in output */
/* DMA2D Callbacks Configuration */
Dma2dHandle.XferCpltCallback = TransferComplete;
Dma2dHandle.XferErrorCallback = TransferError;
/* Foreground Configuration : Layer 1 */
Dma2dHandle.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
Dma2dHandle.LayerCfg[1].InputAlpha = 0xFF; /* Fully opaque */
Dma2dHandle.LayerCfg[1].InputColorMode = CM_ARGB4444; /* Background layer format is ARGB4444 : 16 bpp */
Dma2dHandle.LayerCfg[1].InputOffset = 0x0; /* No offset in input */
Dma2dHandle.Instance = DMA2D;
/* DMA2D Initialisation */
if(HAL_DMA2D_Init(&Dma2dHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
if(HAL_DMA2D_ConfigLayer(&Dma2dHandle, 1) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
}
/**
* @brief Fills a buffer.
* @param LayerIndex: Layer index
* @param pDst: Pointer to destination buffer
* @param xSize: Buffer width
* @param ySize: Buffer height
* @param OffLine: Offset
* @param ColorIndex: Color index
* @retval None
*/
static void LL_FillBuffer(uint32_t LayerIndex, void *pDst, uint32_t xSize, uint32_t ySize, uint32_t OffLine, uint32_t ColorIndex)
{
/* Register to memory mode with ARGB8888 as color Mode */
hDma2dHandler.Init.Mode = DMA2D_R2M;
if(hLtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_RGB565)
{ /* RGB565 format */
hDma2dHandler.Init.ColorMode = DMA2D_RGB565;
}
else
{ /* ARGB8888 format */
hDma2dHandler.Init.ColorMode = DMA2D_ARGB8888;
}
hDma2dHandler.Init.OutputOffset = OffLine;
hDma2dHandler.Instance = DMA2D;
/* DMA2D Initialization */
if(HAL_DMA2D_Init(&hDma2dHandler) == HAL_OK)
{
if(HAL_DMA2D_ConfigLayer(&hDma2dHandler, LayerIndex) == HAL_OK)
{
if (HAL_DMA2D_Start(&hDma2dHandler, ColorIndex, (uint32_t)pDst, xSize, ySize) == HAL_OK)
{
/* Polling For DMA transfer */
HAL_DMA2D_PollForTransfer(&hDma2dHandler, 10);
}
}
}
}
/**
* @brief Converts a line to an ARGB8888 pixel format.
* @param pSrc: Pointer to source buffer
* @param pDst: Output color
* @param xSize: Buffer width
* @param ColorMode: Input color mode
* @retval None
*/
static void LL_ConvertLineToARGB8888(void *pSrc, void *pDst, uint32_t xSize, uint32_t ColorMode)
{
/* Configure the DMA2D Mode, Color Mode and output offset */
hDma2dHandler.Init.Mode = DMA2D_M2M_PFC;
hDma2dHandler.Init.ColorMode = DMA2D_ARGB8888;
hDma2dHandler.Init.OutputOffset = 0;
/* Foreground Configuration */
hDma2dHandler.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hDma2dHandler.LayerCfg[1].InputAlpha = 0xFF;
hDma2dHandler.LayerCfg[1].InputColorMode = ColorMode;
hDma2dHandler.LayerCfg[1].InputOffset = 0;
hDma2dHandler.Instance = DMA2D;
/* DMA2D Initialization */
if(HAL_DMA2D_Init(&hDma2dHandler) == HAL_OK)
{
if(HAL_DMA2D_ConfigLayer(&hDma2dHandler, 1) == HAL_OK)
{
if (HAL_DMA2D_Start(&hDma2dHandler, (uint32_t)pSrc, (uint32_t)pDst, xSize, 1) == HAL_OK)
{
/* Polling For DMA transfer */
HAL_DMA2D_PollForTransfer(&hDma2dHandler, 10);
}
}
}
}
/**
* @brief Converts a line to an ARGB8888 pixel format.
* @param pSrc: Pointer to source buffer
* @param pDst: Output color
* @param xSize: Buffer width
* @param ColorMode: Input color mode
* @retval None
*/
static void CopyPicture(uint32_t *pSrc, uint32_t *pDst, uint16_t x, uint16_t y, uint16_t xsize, uint16_t ysize)
{
uint32_t destination = (uint32_t)pDst + (y * 800 + x) * 4;
uint32_t source = (uint32_t)pSrc;
/*##-1- Configure the DMA2D Mode, Color Mode and output offset #############*/
hdma2d.Init.Mode = DMA2D_M2M;
hdma2d.Init.ColorMode = DMA2D_ARGB8888;
hdma2d.Init.OutputOffset = 800 - xsize;
/*##-2- DMA2D Callbacks Configuration ######################################*/
hdma2d.XferCpltCallback = NULL;
/*##-3- Foreground Configuration ###########################################*/
hdma2d.LayerCfg[0].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d.LayerCfg[0].InputAlpha = 0xFF;
hdma2d.LayerCfg[0].InputColorMode = CM_ARGB8888;
hdma2d.LayerCfg[0].InputOffset = 0;
hdma2d.Instance = DMA2D;
/* DMA2D Initialization */
if(HAL_DMA2D_Init(&hdma2d) == HAL_OK)
{
if(HAL_DMA2D_ConfigLayer(&hdma2d, 0) == HAL_OK)
{
if (HAL_DMA2D_Start(&hdma2d, source, destination, xsize, ysize) == HAL_OK)
{
/* Polling For DMA transfer */
HAL_DMA2D_PollForTransfer(&hdma2d, 100);
}
}
}
}
static void DMA2D_Config(void)
{
/* Configure the DMA2D Mode, Color Mode and output offset */
Dma2dHandle.Init.Mode = DMA2D_M2M_BLEND; /* DMA2D mode Memory to Memory with Blending */
Dma2dHandle.Init.ColorMode = DMA2D_RGB565; /* output format of DMA2D */
Dma2dHandle.Init.OutputOffset = 0x0; /* No offset in output */
/* DMA2D Callbacks Configuration */
Dma2dHandle.XferCpltCallback = TransferComplete;
Dma2dHandle.XferErrorCallback = TransferError;
/* Foreground layer Configuration */
Dma2dHandle.LayerCfg[1].AlphaMode = DMA2D_REPLACE_ALPHA;
Dma2dHandle.LayerCfg[1].InputAlpha = 0x7F; /* 127 : semi-transparent */
Dma2dHandle.LayerCfg[1].InputColorMode = CM_RGB565;
Dma2dHandle.LayerCfg[1].InputOffset = 0x0; /* No offset in input */
/* Background layer Configuration */
Dma2dHandle.LayerCfg[0].AlphaMode = DMA2D_REPLACE_ALPHA;
Dma2dHandle.LayerCfg[0].InputAlpha = 0x7F; /* 127 : semi-transparent */
Dma2dHandle.LayerCfg[0].InputColorMode = CM_RGB565;
Dma2dHandle.LayerCfg[0].InputOffset = 0x0; /* No offset in input */
Dma2dHandle.Instance = DMA2D;
/* DMA2D Initialisation */
if(HAL_DMA2D_Init(&Dma2dHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Apply DMA2D Foreground configuration */
HAL_DMA2D_ConfigLayer(&Dma2dHandle, 1);
/* Apply DMA2D Background configuration */
HAL_DMA2D_ConfigLayer(&Dma2dHandle, 0);
}
/**
* @brief Prepares the picture to be saved in microSD.
* @param None
* @retval None
*/
static void Prepare_Picture(void)
{
uint32_t addrSrc = LCD_FRAME_BUFFER;
uint32_t addrDst = CONVERTED_FRAME_BUFFER;
static DMA2D_HandleTypeDef hdma2d_eval;
uint32_t lineCnt = 0;
/* Configure the DMA2D Mode, Color Mode and output offset : used to convert ARGB8888 to RGB888 */
/* used in BMP file format */
hdma2d_eval.Init.Mode = DMA2D_M2M_PFC;
hdma2d_eval.Init.ColorMode = DMA2D_RGB888; /* DMA2D Output format */
hdma2d_eval.Init.OutputOffset = 0;
/* Foreground Configuration */
hdma2d_eval.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d_eval.LayerCfg[1].InputAlpha = 0xFF;
hdma2d_eval.LayerCfg[1].InputColorMode = DMA2D_ARGB8888; /* DMA2D input format */
hdma2d_eval.LayerCfg[1].InputOffset = 70; /* skip 70 pixels on left when reading addrSrc : the left margin */
hdma2d_eval.Instance = DMA2D;
/* Go to start of last drawing pad useful line from LCD frame buffer */
addrSrc += ((BSP_LCD_GetYSize() - 70 - 1) * BSP_LCD_GetXSize() * ARGB8888_BYTE_PER_PIXEL);
/* Copy and Convert picture from LCD frame buffer in ARGB8888 to Converted frame buffer in
* RGB888 pixel format for all the useful lines of the drawing pad */
for(lineCnt=0; lineCnt < (BSP_LCD_GetYSize() - 80); lineCnt++)
{
/* DMA2D Initialization */
if(HAL_DMA2D_Init(&hdma2d_eval) == HAL_OK)
{
if(HAL_DMA2D_ConfigLayer(&hdma2d_eval, 1) == HAL_OK)
{
if (HAL_DMA2D_Start(&hdma2d_eval, addrSrc, addrDst,
(BSP_LCD_GetXSize() - 80), 1) == HAL_OK)
{
/* Polling For DMA transfer */
HAL_DMA2D_PollForTransfer(&hdma2d_eval, 10);
}
}
}
/* Increment the destination address by one line RGB888 */
addrDst += ((BSP_LCD_GetXSize() - 80) * RGB888_BYTE_PER_PIXEL);
/* Decrement the source address by one line */
addrSrc -= (BSP_LCD_GetXSize() * ARGB8888_BYTE_PER_PIXEL);
}
}
/* DMA2D init function */
void MX_DMA2D_Init(void)
{
hdma2d.Instance = DMA2D;
hdma2d.Init.Mode = DMA2D_M2M;
hdma2d.Init.ColorMode = DMA2D_ARGB8888;
hdma2d.Init.OutputOffset = 0;
hdma2d.LayerCfg[1].InputOffset = 0;
hdma2d.LayerCfg[1].InputColorMode = CM_ARGB8888;
hdma2d.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d.LayerCfg[1].InputAlpha = 0;
HAL_DMA2D_Init(&hdma2d);
HAL_DMA2D_ConfigLayer(&hdma2d, 1);
}
/**
* @brief Prepares the picture to be Saved in USB.
* @param None
* @retval None
*/
static void PicturePrepare(void)
{
static DMA2D_HandleTypeDef hdma2d_eval;
uint32_t addrSrc = LCD_BG_LAYER_ADDRESS + ((LcdResX - CameraResX) / 2 * ARGB8888_BYTE_PER_PIXEL);
uint32_t addrDst = CONVERTED_FRAME_BUFFER;
uint32_t lineCnt = 0;
/* Configure the DMA2D Mode, Color Mode and output offset */
hdma2d_eval.Init.Mode = DMA2D_M2M_PFC;
hdma2d_eval.Init.ColorMode = DMA2D_RGB888; /* Output color mode at the output of DMA2D operation */
hdma2d_eval.Init.OutputOffset = 0;
/* Foreground Configuration */
hdma2d_eval.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d_eval.LayerCfg[1].InputAlpha = 0xFF;
hdma2d_eval.LayerCfg[1].InputColorMode = DMA2D_ARGB8888;
hdma2d_eval.LayerCfg[1].InputOffset = 0;
hdma2d_eval.Instance = DMA2D;
/* Go to last line of camera image in LCD BG frame buffer in order to start building BMP file */
/* As BMP file encoding starts with last line down to the first */
addrSrc += (LcdResY - ((LcdResY - CameraResY) / 2) - 1 ) * LcdResX * ARGB8888_BYTE_PER_PIXEL;
/* Convert picture line by line to RGB888 pixel format */
for(lineCnt = 0; lineCnt < CameraResY; lineCnt++)
{
/* DMA2D Initialization */
if(HAL_DMA2D_Init(&hdma2d_eval) == HAL_OK)
{
if(HAL_DMA2D_ConfigLayer(&hdma2d_eval, 1) == HAL_OK)
{
if (HAL_DMA2D_Start(&hdma2d_eval, addrSrc, addrDst, CameraResX, 1) == HAL_OK)
{
/* Polling For DMA transfer */
HAL_DMA2D_PollForTransfer(&hdma2d_eval, 10);
}
}
}
/* Manage the source and destination buffers */
addrDst += (CameraResX * RGB888_BYTE_PER_PIXEL);
addrSrc -= (LcdResX * ARGB8888_BYTE_PER_PIXEL);
}
}
/**
* @brief Prepares the picture to be Saved in USB Disk.
* @param None
* @retval None
*/
static void Prepare_Picture(void)
{
static DMA2D_HandleTypeDef hdma2d_eval;
uint32_t address1 = CONVERTED_FRAME_BUFFER;
uint32_t address2 = LCD_FRAME_BUFFER_LAYER0;
uint32_t index = 0;
/* Configure the DMA2D Mode, Color Mode and output offset */
hdma2d_eval.Init.Mode = DMA2D_M2M_PFC;
hdma2d_eval.Init.ColorMode = DMA2D_RGB888;
hdma2d_eval.Init.OutputOffset = 0;
/* Foreground Configuration */
hdma2d_eval.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d_eval.LayerCfg[1].InputAlpha = 0xFF;
hdma2d_eval.LayerCfg[1].InputColorMode = DMA2D_ARGB8888;
hdma2d_eval.LayerCfg[1].InputOffset = 60;
hdma2d_eval.Instance = DMA2D;
/* Bypass the bitmap header */
address2 += ((BSP_LCD_GetXSize() * (BSP_LCD_GetYSize() - 61) + 60) * 4);
/* Convert picture to RGB888 pixel format */
for(index=0; index < (BSP_LCD_GetYSize() - 60); index++)
{
/* DMA2D Initialization */
if(HAL_DMA2D_Init(&hdma2d_eval) == HAL_OK)
{
if(HAL_DMA2D_ConfigLayer(&hdma2d_eval, 1) == HAL_OK)
{
if (HAL_DMA2D_Start(&hdma2d_eval, address2, address1, (BSP_LCD_GetXSize() - 60), 1) == HAL_OK)
{
/* Polling For DMA transfer */
HAL_DMA2D_PollForTransfer(&hdma2d_eval, 10);
}
}
}
/* Increment the source and destination buffers */
address1 += ((BSP_LCD_GetXSize() - 60)*3);
address2 -= BSP_LCD_GetXSize()*4;
}
}
/**
* @brief Copy and convert the blended image (LAYER_SIZE_X, LAYER_SIZE_Y) of format ARGB4444
* to LCD frame buffer area centered in WVGA resolution.
* The area of copy is of size (LAYER_SIZE_X, LAYER_SIZE_Y) in ARGB8888.
* @param pSrc: Pointer to source buffer : blended image buffer start here
* @param pDst: Pointer to destination buffer LCD frame buffer center area start here
* @param xSize: Buffer width (LAYER_SIZE_X here)
* @param ySize: Buffer height (LAYER_SIZE_Y here)
* @retval LCD Status : LCD_OK or LCD_ERROR
*/
static uint8_t CopyBlendedBufferToLcdFrameBuffer(void *pSrc, void *pDst, uint32_t xSize, uint32_t ySize)
{
DMA2D_HandleTypeDef hdma2d_eval;
HAL_StatusTypeDef hal_status = HAL_OK;
uint8_t lcd_status = LCD_ERROR;
/* Configure the DMA2D Mode, Color Mode and output offset */
hdma2d_eval.Init.Mode = DMA2D_M2M_PFC;
hdma2d_eval.Init.ColorMode = DMA2D_ARGB8888; /* Output color out of PFC */
/* Output offset in pixels == nb of pixels to be added at end of line to come to the */
/* first pixel of the next line : on the output side of the DMA2D computation */
hdma2d_eval.Init.OutputOffset = (LcdResX - LAYER_SIZE_X);
/* Foreground Configuration */
hdma2d_eval.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d_eval.LayerCfg[1].InputAlpha = 0xFF; /* fully opaque */
hdma2d_eval.LayerCfg[1].InputColorMode = CM_ARGB4444;
hdma2d_eval.LayerCfg[1].InputOffset = 0;
hdma2d_eval.Instance = DMA2D;
/* DMA2D Initialization */
if(HAL_DMA2D_Init(&hdma2d_eval) == HAL_OK)
{
if(HAL_DMA2D_ConfigLayer(&hdma2d_eval, 1) == HAL_OK)
{
if (HAL_DMA2D_Start(&hdma2d_eval, (uint32_t)pSrc, (uint32_t)pDst, xSize, ySize) == HAL_OK)
{
/* Polling For DMA transfer */
hal_status = HAL_DMA2D_PollForTransfer(&hdma2d_eval, 10);
if(hal_status == HAL_OK)
{
/* return good status on exit */
lcd_status = LCD_OK;
}
}
}
}
return(lcd_status);
}
static void DMA2D_Config(void)
{
HAL_StatusTypeDef hal_status = HAL_OK;
/* Register to memory mode with ARGB8888 as colorMode */
Dma2dHandle.Init.Mode = DMA2D_R2M;
Dma2dHandle.Init.ColorMode = DMA2D_ARGB8888;
Dma2dHandle.Init.OutputOffset = 0x0;
Dma2dHandle.XferCpltCallback = TransferComplete;
Dma2dHandle.XferErrorCallback = TransferError;
Dma2dHandle.Instance = DMA2D;
/* DMA2D Initialization */
hal_status = HAL_DMA2D_Init(&Dma2dHandle);
OnError_Handler(hal_status != HAL_OK);
hal_status = HAL_DMA2D_ConfigLayer(&Dma2dHandle, 1);
OnError_Handler(hal_status != HAL_OK);
}
/* DMA2D init function */
static void MX_DMA2D_Init(void)
{
hdma2d.Instance = DMA2D;
hdma2d.Init.Mode = DMA2D_M2M;
hdma2d.Init.ColorMode = DMA2D_OUTPUT_RGB565;
hdma2d.Init.OutputOffset = 0;
hdma2d.LayerCfg[0].InputOffset = 0;
hdma2d.LayerCfg[0].InputColorMode = DMA2D_INPUT_RGB565;
hdma2d.LayerCfg[0].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d.LayerCfg[0].InputAlpha = 0;
if (HAL_DMA2D_Init(&hdma2d) != HAL_OK)
{
RT_ASSERT(RT_NULL);
}
if (HAL_DMA2D_ConfigLayer(&hdma2d, 0) != HAL_OK)
{
RT_ASSERT(RT_NULL);
}
}
/**
* Actually zeroes the VIDEO RAM.. normally
*/
void clear_screen(void)
{
pos_curseur = 0;
//memset((void*)0xD0000000, 0, (size_t)800*480*2);
HAL_DMA2D_DeInit(&Dma2dHandle);
Dma2dHandle.Init.Mode = DMA2D_R2M;
Dma2dHandle.Init.ColorMode = DMA2D_RGB565;
Dma2dHandle.Init.OutputOffset = 0x0;
Dma2dHandle.LayerCfg[0].AlphaMode = DMA2D_NO_MODIF_ALPHA;
Dma2dHandle.LayerCfg[0].InputAlpha = 0xFF;
Dma2dHandle.LayerCfg[0].InputColorMode = CM_RGB565;
Dma2dHandle.LayerCfg[0].InputOffset = 0x0;
Dma2dHandle.Instance = DMA2D;
HAL_DMA2D_Init(&Dma2dHandle);
HAL_DMA2D_ConfigLayer(&Dma2dHandle, 0);
HAL_DMA2D_Start(&Dma2dHandle, BLACK, (uint32_t)LCD_BUFFER_START, LCD_WIDTH, LCD_HEIGHT);
HAL_DMA2D_PollForTransfer(&Dma2dHandle, 200);
}
/**
* @brief Fills a buffer.
* @param LayerIndex: Layer index
* @param pDst: Pointer to destination buffer
* @param xSize: Buffer width
* @param ySize: Buffer height
* @param OffLine: Offset
* @param ColorIndex: Color index
* @retval None
*/
static void LL_FillBuffer(uint32_t LayerIndex, void *pDst, uint32_t xSize, uint32_t ySize, uint32_t OffLine, uint32_t ColorIndex)
{
/* Register to memory mode with ARGB8888 as color Mode */
hdma2d_eval.Init.Mode = DMA2D_R2M;
hdma2d_eval.Init.ColorMode = DMA2D_ARGB8888;
hdma2d_eval.Init.OutputOffset = OffLine;
hdma2d_eval.Instance = DMA2D;
/* DMA2D Initialization */
if(HAL_DMA2D_Init(&hdma2d_eval) == HAL_OK)
{
if(HAL_DMA2D_ConfigLayer(&hdma2d_eval, LayerIndex) == HAL_OK)
{
if (HAL_DMA2D_Start(&hdma2d_eval, ColorIndex, (uint32_t)pDst, xSize, ySize) == HAL_OK)
{
/* Polling For DMA transfer */
HAL_DMA2D_PollForTransfer(&hdma2d_eval, 10);
}
}
}
}
/* DMA2D init function */
static void MX_DMA2D_Init(void)
{
hdma2d.Instance = DMA2D;
hdma2d.Init.Mode = DMA2D_M2M_PFC;
hdma2d.Init.ColorMode = DMA2D_OUTPUT_ARGB8888;
hdma2d.Init.OutputOffset = 0;
hdma2d.LayerCfg[1].InputOffset = 0;
hdma2d.LayerCfg[1].InputColorMode = DMA2D_INPUT_RGB888;
hdma2d.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d.LayerCfg[1].InputAlpha = 255;
if (HAL_DMA2D_Init(&hdma2d) != HAL_OK)
{
Error_Handler();
}
if (HAL_DMA2D_ConfigLayer(&hdma2d, 1) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Configure LED1, LED2, LED3 and LED4 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/*##-1- Configure the DMA2D Mode, Color Mode and output offset #############*/
Dma2dHandle.Init.Mode = DMA2D_M2M;
Dma2dHandle.Init.ColorMode = DMA2D_ARGB8888;
Dma2dHandle.Init.OutputOffset = 0x0;
/*##-2- DMA2D Callbacks Configuration ######################################*/
Dma2dHandle.XferCpltCallback = TransferComplete;
Dma2dHandle.XferErrorCallback = TransferError;
/*##-3- Foreground Configuration ###########################################*/
Dma2dHandle.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
Dma2dHandle.LayerCfg[1].InputAlpha = 0xFF;
Dma2dHandle.LayerCfg[1].InputColorMode = CM_ARGB4444;
Dma2dHandle.LayerCfg[1].InputOffset = 0x0;
Dma2dHandle.Instance = DMA2D;
/*##-4- DMA2D Initialisation ###############################################*/
if(HAL_DMA2D_Init(&Dma2dHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
if(HAL_DMA2D_ConfigLayer(&Dma2dHandle, 1) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-5- Start DMA2D transfer ###############################################*/
if(HAL_DMA2D_Start_IT(&Dma2dHandle, (uint32_t)&aBufferInput, (uint32_t)&aBufferResult, 16, 32) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-6- Check transfer correctness #########################################*/
if(Buffercmp(aBufferInput, aBufferResult, 256) == ERROR)
{
/* KO */
/* Turn on LD2 */
BSP_LED_On(LED2);
}
else
{
/* OK */
/* Turn on LD4 */
BSP_LED_On(LED4);
}
while (1)
{
}
}
/**
* @brief Converts a line to an ARGB8888 pixel format.
* @param pSrc: Pointer to source buffer
* @param pDst: Output color
* @param xSize: Buffer width
* @param ColorMode: Input color mode
* @retval None
*/
static void LL_DrawPicture(uint32_t *pSrc, int32_t xyPos)
{
uint32_t inputOffset = 0;
uint32_t outputOffset = 0;
uint32_t pDst = LAYER0_ADDRESS;
uint32_t width = 0, height = 0;
uint32_t source = (uint32_t)pSrc;
/* draw_method == VERTICAL_SLIDER */
if(draw_method == VERTICAL_SLIDER)
{
width = 800;
if(xyPos < 0)
{
source = (uint32_t)pSrc + (-xyPos)*800*4;
height = (480 + xyPos);
inputOffset = 0;
outputOffset = 0;
}
else
{
pDst = LAYER0_ADDRESS + (xyPos)*800*4;
height = 480 - xyPos;
inputOffset = 0;
outputOffset = 0;
}
}
else /* draw_method == HORIZONTAL_SLIDER */
{
height = 480;
if(xyPos < 0)
{
source = (uint32_t)pSrc + (-xyPos)*4;
width = (800 + xyPos);
inputOffset = -xyPos;
outputOffset = -xyPos;
}
else
{
pDst = LAYER0_ADDRESS + (xyPos)*4;
width = 800 - xyPos;
inputOffset = xyPos;
outputOffset = xyPos;
}
}
/*##-1- Configure the DMA2D Mode, Color Mode and output offset #############*/
hdma2d.Init.Mode = DMA2D_M2M_PFC;
hdma2d.Init.ColorMode = DMA2D_ARGB8888;
hdma2d.Init.OutputOffset = outputOffset;
/*##-2- DMA2D Callbacks Configuration ######################################*/
hdma2d.XferCpltCallback = NULL;
/*##-3- Foreground Configuration ###########################################*/
hdma2d.LayerCfg[1].AlphaMode = DMA2D_REPLACE_ALPHA;
hdma2d.LayerCfg[1].InputAlpha = 0xFF;
hdma2d.LayerCfg[1].InputColorMode = CM_ARGB8888;
hdma2d.LayerCfg[1].InputOffset = inputOffset;
hdma2d.Instance = DMA2D;
/* DMA2D Initialization */
if(HAL_DMA2D_Init(&hdma2d) == HAL_OK)
{
if(HAL_DMA2D_ConfigLayer(&hdma2d, 1) == HAL_OK)
{
if (HAL_DMA2D_Start(&hdma2d, source, (uint32_t)pDst, width, height) == HAL_OK)
{
/* Polling For DMA transfer */
HAL_DMA2D_PollForTransfer(&hdma2d, 500);
}
}
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* Enable the CPU Cache */
CPU_CACHE_Enable();
/* STM32F7xx HAL library initialization:
- Configure the Flash ART accelerator on ITCM interface
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 216 MHz */
SystemClock_Config();
/* Configure LED1, LED2, LED3 and LED4 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/*##-1- Configure the DMA2D Mode, Output Color Mode and output offset #############*/
Dma2dHandle.Init.Mode = DMA2D_M2M; /* Mode Memory To Memory */
Dma2dHandle.Init.ColorMode = DMA2D_ARGB4444; /* Output color mode is ARGB4444 : 16 bpp */
Dma2dHandle.Init.OutputOffset = 0x0; /* No offset on output */
/*##-2- DMA2D Callbacks Configuration ######################################*/
Dma2dHandle.XferCpltCallback = TransferComplete;
Dma2dHandle.XferErrorCallback = TransferError;
/*##-3- Foreground Layer Configuration ###########################################*/
Dma2dHandle.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA; /* Keep original Alpha from ARGB4444 input */
Dma2dHandle.LayerCfg[1].InputAlpha = 0xFF; /* Fully opaque */
Dma2dHandle.LayerCfg[1].InputColorMode = CM_ARGB4444; /* Input color is ARGB4444 : 16 bpp */
Dma2dHandle.LayerCfg[1].InputOffset = 0x0; /* No offset in input */
Dma2dHandle.Instance = DMA2D;
/*##-4- DMA2D Initialisation ###############################################*/
if(HAL_DMA2D_Init(&Dma2dHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Configure Foreground layer (ie layer 1) */
if(HAL_DMA2D_ConfigLayer(&Dma2dHandle, 1) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-5- Start DMA2D transfer ###############################################*/
if(HAL_DMA2D_Start_IT(&Dma2dHandle,
(uint32_t)&aBufferInput, /* Source memory buffer */
(uint32_t)&aBufferResult, /* Destination memory buffer */
LAYER_SIZE_X, /* Width of the 2D memory transfer in pixels */
LAYER_SIZE_Y) /* Height of the 2D memory transfer in lines */
!= HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-6- Wait for the end of the transfer ###################################*/
/* Before starting a new transfer, you need to check the current state of
the peripheral; if it’s busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_DMA2D_GetState(&Dma2dHandle) != HAL_DMA2D_STATE_READY)
{
}
/*##-7- Check transfer correctness #########################################*/
if(Buffercmp(aBufferInput,
aBufferResult,
((LAYER_SIZE_X * LAYER_SIZE_Y * LAYER_NB_BYTES_PER_PIXEL) / 4)) == ERROR)
{
/* KO */
/* Turn on LED2 */
BSP_LED_On(LED2);
}
else
{
/* OK */
/* Turn on LED4 */
BSP_LED_On(LED4);
}
while (1) { ; }
}