engineer4ever 님의 블로그

#define CAM_DMA_SIZE     (240*320)

OV9655_ReadID(&ov9655_id);
OV9655_QVGAConfig();
HAL_DCMI_Start_DMA(&hdcmi, DCMI_MODE_CONTINUOUS, (uint32_t)pBuf, CAM_DMA_SIZE/2);

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	ts_trigger = 1;
}

	BSP_SDRAM_Initialization(REFRESH_COUNT);
	HAL_LTDC_SetAddress(&hltdc, pBuf, 0);
	status = BSP_TS_Init(480,272);
	if(status == 0) printf("Touch Init OK\r\n");
	else printf("Touch Init Error : %d\r\n", status);

	while (1)
	{
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		if(ts_trigger == 1)
		{
			ts_trigger = 0;
			if(BSP_TS_GetState(&TS_State)==0){
				x=TS_State.touchX[0];
				y=TS_State.touchY[0];
				printf("TS_x = %d , TS_y=%d \r\n",x,y);
				uint32_t rng_val = HAL_RNG_GetRandomNumber(&hrng);
				if(x < 240)
				{
					if(y < 136) buf_rect(pBuf, 0,240,0,136,rng_val & 0xffff);
					else buf_rect(pBuf, 0,240,136,272,rng_val & 0xffff);
				}
				else
				{
					if(y < 136) buf_rect(pBuf, 240,480,0,136,rng_val & 0xffff);
					else buf_rect(pBuf, 240,480,136,272,rng_val & 0xffff);
				}
			}
			HAL_Delay(10);
		}
	}
	/* USER CODE END 3 */

MCU

/* USER CODE BEGIN 0 */

void buf_rect(uint16_t  *pBuf, uint32_t start_x, uint32_t stop_x,
              uint32_t start_y,uint32_t stop_y,uint16_t color)
{
    for(uint32_t j=start_y; j<stop_y; j++)
    {
        for(uint32_t i=start_x; i<stop_x; i++)
        {
            *(pBuf + j*480 + i) = (uint16_t)color;
        }
    }
}

/* USER CODE BEGIN 1 */
    uint16_t  *pBuf = (uint16_t *)0xC0000000;
/* USER CODE END 1 */

/* USER CODE BEGIN 2 */
    BSP_SDRAM_Initialization_sequence(REFRESH_COUNT);
    HAL_LTDC_SetAddress(&hltdc, pBuf, 0);  // Reconfigure the frame buffer Address
/* USER CODE END 2 */

	while (1)
	{
	/* USER CODE END WHILE */
	
	/* USER CODE BEGIN 3 */
		uint32_t rng_val = HAL_RNG_GetRandomNumber(&hrng);
		printf("RNG_val = 0x%08lx \r\n",rng_val);
		buf_rect(pBuf, 0,240,0,136,rng_val & 0xffff);  	rng_val >>= 16;
		buf_rect(pBuf, 240,480,0,136,rng_val & 0xffff);
	
		rng_val = HAL_RNG_GetRandomNumber(&hrng);
		printf("RNG_val = 0x%08lx \r\n",rng_val);
		buf_rect(pBuf, 0,240,136,272,rng_val & 0xffff);  	rng_val >>= 16;
		buf_rect(pBuf, 240,480,136,272,rng_val & 0xffff);
		HAL_Delay(500);
	}
	/* USER CODE END 3 */

void BSP_SDRAM_Initialization(uint32_t RefreshCount)
{
  __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_BANK1;
  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_BANK1;
  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_BANK1;
  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_1          |
                     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_BANK1;
  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, RefreshCount); 
}

/* USER CODE BEGIN PV */
/* Private variables ---------------------------------------------------------*/
#define SDRAM_ADDRESS 0xC0000000

/* USER CODE BEGIN 2 */
BSP_SDRAM_Initialization(REFRESH_COUNT);

MEMORY
{
RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 320K
FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 1024K
SDRAM (xrw)      : ORIGIN = 0xC0000000, LENGTH = 8M
}

  /* Uninitialized data section */
  . = ALIGN(4);
  .bss :
  {
    /* This is used by the startup in order to initialize the .bss secion */
    _sbss = .;         /* define a global symbol at bss start */
    __bss_start__ = _sbss;
    *(.bss)
    *(.bss*)
    *(COMMON)

    . = ALIGN(4);
    _ebss = .;         /* define a global symbol at bss end */
    __bss_end__ = _ebss;
  } >SDRAM

  .bss_sdram :
  {
  . = ALIGN(8);
  
  	_sbss_sdram = .; 
  	*USER* (.bss .bss* COMMON)
  	
  	. = ALIGN(8);
  } >SDRAM
  
  /* Uninitialized data section into "RAM" Ram type memory */
  . = ALIGN(4);
  .bss :
  {
    /* This is used by the startup in order to initialize the .bss section */
    _sbss = .;         /* define a global symbol at bss start */
    __bss_start__ = _sbss;
    *(.bss)
    *(.bss*)
    *(COMMON)

    . = ALIGN(4);
    _ebss = .;         /* define a global symbol at bss end */
    __bss_end__ = _ebss;
  } >RAM

.bss_sdram      0x0c010000        0x4
                0x0c010000                _sbss_sdram = .
 *USER*(.bss .bss* COMMON)
 .bss.flag_filter
                0x0c010000        0x4 USER\temp.o
                0x0c010000                flag_filter
                0x0c010004                _ebss_sdram = .
                0x0c010004                . = ALIGN (0x4)

.bss            0x20000074      0x1fc
                0x20000074                _sbss = .
                0x20000074                __bss_start__ = _sbss
 *(.bss)

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_GFXSIMULATOR_Init();
  MX_USART1_UART_Init();
  MX_RTC_Init();
  MX_TIM6_Init();
  MX_TIM2_Init();
  /* USER CODE BEGIN 2 */
  HAL_TIM_Base_Start_IT(&htim2);
  HAL_TIM_OC_Start_IT(&htim2, TIM_CHANNEL_1);
  /* USER CODE END 2 */

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance == htim2.Instance)
	{
		HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_SET);
	}
}

void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance == htim2.Instance)
	{
		HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_RESET);
	}
}

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_GFXSIMULATOR_Init();
  MX_USART1_UART_Init();
  MX_RTC_Init();
  MX_TIM6_Init();
  MX_TIM2_Init();
  /* USER CODE BEGIN 2 */
  HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_1);
  HAL_TIM_PWM_Start_IT(&htim2, TIM_CHANNEL_1);
  /* USER CODE END 2 */

void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim)
{
	  if(htim->Instance == htim2.Instance)
	  {
		  HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
	  }
}

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_GFXSIMULATOR_Init();
  MX_USART1_UART_Init();
  MX_RTC_Init();
  MX_TIM6_Init();
  MX_TIM2_Init();
  /* USER CODE BEGIN 2 */
  HAL_TIM_Base_Start_IT(&htim2);
  HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_1);
  HAL_TIM_PWM_Start_IT(&htim2, TIM_CHANNEL_1);
  /* USER CODE END 2 */

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance == htim2.Instance)
	{
		HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_SET);
	}
}
void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim)
{
	  if(htim->Instance == htim2.Instance)
	  {
		  HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_RESET);
	  }
}

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_RTC_Init();
  MX_GFXSIMULATOR_Init();
  MX_USART1_UART_Init();
  MX_TIM6_Init();
  /* USER CODE BEGIN 2 */
  HAL_TIM_Base_Start_IT (&htim6);
  /* USER CODE END 2 */

void TIM6_DAC_IRQHandler(void)
{
  /* USER CODE BEGIN TIM6_DAC_IRQn 0 */

  /* USER CODE END TIM6_DAC_IRQn 0 */
  HAL_TIM_IRQHandler(&htim6);
  /* USER CODE BEGIN TIM6_DAC_IRQn 1 */
  HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
  /* USER CODE END TIM6_DAC_IRQn 1 */
}

#define RX_MAX    1

uint8_t rcv_data[RX_MAX];

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  HAL_UART_Receive_DMA(&huart1, rcv_data, RX_MAX);

  while (1)
  {
	  HAL_Delay(50);

	  if(rcv_data[0])
	  {
  		  printf("Rx OK = %c\r\n", rcv_data[0]);
  		  rcv_data[0] = 0x00;
  	  }

  	  if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_ORE))
  	  {
  		  printf("UART1 Overrun Error occurred.\r\n");
  		  __HAL_UART_CLEAR_IT(&huart1,UART_CLEAR_OREF);
  	  }
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }