• STM32H7B0 HAL库中关于DMA的注意事项以及DCMI调试遇到的问题及解决方法

    先总结总结问题

    问题1：MX_DCMI_Init();放到  MX_DMA_Init();后

    问题2：DMA缓存缓存要放到SRAM中__align(32) uint32_t buffer[65535] __attribute((at(0X24040000)));

    问题3：IO复用问题，DCMI数据口可以复用到其他IO口，要注意配置

    问题4：摄像头时钟配置，不能过快，也不能过慢，过快采集不过来，过慢JPEG会传一半停止

    问题5：上位机字节序，JPG由FF D8开头,FF D9结尾

    解决上面5个问题，STM32H7 DCMI就可以轻松使用

    由于需要用到摄像头，用IO驱动的话会比较慢，这里使用的STM32H7B0中的DCMI接口，由于DMA用的比较少，在这里卡了3天，期间各种测试，从硬件到软件，接用IO读OV2640，可以读到数据，确定硬件没有问题，DCMI的DMA一直进错误中断Transfer Error Interrupt management

    网上说是内存地址问题，DMA不能访问直接访问DTCM，也改成SRAM了，也会进入错误中断

    DMA1等都不能访问DTCM

    最终发现把    MX_DCMI_Init();放到  MX_DMA_Init();即可正常传输数据

     Several peripheral DMA handle pointers point to the same DMA handle.
         Be aware that there is only one channel to perform all the requested DMAs.干扰项，删掉就行不用管，我开始还以为这里需要配置什么东西，就保留最上边一行 

    删完就像这样就可以

     

    缓存放到SRAM放到中

    __align(32) uint32_t buffer[65535] __attribute((at(0X24040000)));

    开启缓存对于DCMI没有影响，开不开都可以正常运行

    static void CPU_CACHE_Enable(void)
    {
        SCB_EnableICache();//使能I-Cache
      SCB_EnableDCache();//使能D-Cache   
        SCB->CACR|=1<<2;   //强制D-Cache透写,如不开启,实际使用中可能遇到各种问题    
    }

    启动采集代码

    1. void StartOV2640()
    2. {
    3. 		int i =0;
    4. 		__HAL_DCMI_ENABLE_IT(&hdcmi, DCMI_IER_FRAME_IE);                                               	//使用帧中断
    5.     memset(buffer, 0, 65535);                                        					//把接收BUF清空
    6.     HAL_DCMI_Start_DMA(&hdcmi, DCMI_MODE_SNAPSHOT, (uint32_t)buffer, 65535); 	//启动拍照
    7. }
    8.  
    9.  
    10. void HAL_DCMI_FrameEventCallback(DCMI_HandleTypeDef *hdcmi)
    11. {
    12. 	  int i =0;
    13. 	  HAL_DCMI_Suspend(hdcmi); // 拍照完成，挂起 DCMI
    14. 	  HAL_DCMI_Stop(hdcmi);    // 拍照完成，停止 DMA传输
    15.     int pictureLength = 65535;
    16.     while (pictureLength > 0)     //循环计算出接收的JPEG的大小
    17.     {
    18.         if (buffer[pictureLength - 1] != 0x00000000)
    19.         {
    20.           break;
    21.         }
    22.         pictureLength--;
    23.     }
    24. 		jpeglen = pictureLength * 4;
    25. 		getPicture = 1;
    26. }

    配置IO也要注意一下D0,D1,D3可以复用到其他IO，一定不要弄错，配置完要对着IO检查一遍，频率使用也很重要，我这里用到的频率如下

    单片机主频280M

    摄像头主频8M

    摄像头分频配置

    SCCB_WR_Reg(0XFF,0X00);

    SCCB_WR_Reg(0XD3,0XF);

    SCCB_WR_Reg(0XFF,0X01);

    SCCB_WR_Reg(0X11,0X7);

     

    开启中断

    DMA配置，不要修改

     NVIC给个优先级

    摄像头时钟,这个可以自由发挥，和摄像头分频配置一起可以有多重组合

    样张

    上位机软件用C#写的，关键部分代码

    1. private const int count = 200 * 1024;
    2. private byte[] buffer = new byte[count];
    3. private int offset = 0;
    4. private int length = 0;
    5. private bool isData = false;
    6. public void DataCallBack(Object sender, SerialDataReceivedEventArgs e)
    7. {
    8.     try
    9.     {
    10.         if (isData==false)
    11.         {
    12.             var data = _serialPort.ReadLine();
    13.             if (!string.IsNullOrEmpty(data) && data.Length > 0)
    14.             {
    15.                 if(data.IndexOf("jpeg data size:")>=0)
    16.                 {
    17.                     var lengthStr = data.Split(':');
    18.                     if(lengthStr != null && lengthStr.Length>1)
    19.                     {
    20.                         length = int.Parse(lengthStr[1]);
    21.                         if (length > count)
    22.                         {
    23.  
    24.                         }
    25.                         else
    26.                         {
    27.                             isData = true;
    28.                         }
    29.                     }
    30.                     Console.WriteLine(data);
    31.                 }
    32.                 else
    33.                 {
    34.                     Console.WriteLine(data);
    35.                 }
    36.             }
    37.         }
    38.         else
    39.         {
    40.             int thisLength = _serialPort.Read(buffer, offset, length - offset);
    41.             offset = offset + thisLength;
    42.             if(offset >= length)
    43.             {
    44.                 Console.WriteLine($"接收完一张图片,offset:{offset},length:{length}");
    45.                 string path = Directory.GetCurrentDirectory();
    46.                 DirectoryCheak(path + "\\out\\");
    47.                 bool ispictrue = false;
    48.                 if (false)//bmp
    49.                 {
    50.                     //bmp
    51.                     if (false)
    52.                     {
    53.                         //RGB888
    54.                         System.Drawing.Bitmap formBitmap = new System.Drawing.Bitmap(96, 96);
    55.                         for (int i = 0; i < 96; i++)
    56.                         {
    57.                             for (int j = 0; j < 96; j++)
    58.                             {
    59.                                 formBitmap.SetPixel(i, j, System.Drawing.Color.FromArgb(buffer[i * j + j], buffer[i * j + j + 1], buffer[i * j + j + 2]));
    60.                             }
    61.                         }
    62.                         formBitmap.Save(path + "\\out\\" + DateTime.Now.ToString("yyyyMMdd-HHmmss.fff") + ".bmp");
    63.                     }
    64.                     else
    65.                     {
    66.                         //RGB565
    67.                         List data = new List();
    68.                         for (int i = 0; i < length; i += 2)
    69.                         {
    70.                             UInt16 thisData = (UInt16)((buffer[i] << 8) | buffer[i + 1]); ;
    71.                             data.Add(thisData);
    72.                         }
    73.                         System.Drawing.Bitmap formBitmap = new System.Drawing.Bitmap(96, 96);
    74.                         for (int i = 0; i < 96; i++)
    75.                         {
    76.                             for (int j = 0; j < 96; j++)
    77.                             {
    78.                                 byte red = (byte)((data[i * j + j] >> 11) << 3); //5位 移动3位
    79.                                 byte green = (byte)(((data[i * j + j] << 5) >> 10) << 2); //6位 移动2位
    80.                                 byte blue = (byte)(((data[i * j + j] << 11) >> 11) << 3); //5位 移动3位 
    81.                                 formBitmap.SetPixel(i, j, System.Drawing.Color.FromArgb(red, green, blue));
    82.                             }
    83.                         }
    84.                         formBitmap.Save(path + "\\out\\" + DateTime.Now.ToString("yyyyMMdd-HHmmss.fff") + ".bmp");
    85.                     }
    86.                 }
    87.                 else
    88.                 {
    89.                     List<byte> data = new List<byte>();
    90.                     for (int i = 1; i < length; i++)
    91.                     {
    92.                         //Console.WriteLine($"i:{i},length:{length}");
    93.                         if (ispictrue == true)
    94.                         {
    95.                             data.Add(buffer[i]);
    96.                         }
    97.                         else if ((buffer[i - 1] == 0xFF) && (buffer[i] == 0xd8))
    98.                         {
    99.                             ispictrue = true;
    100.                             data.Add(buffer[i - 1]);
    101.                             data.Add(buffer[i]);
    102.                         }
    103.                         //if((buffer[i - 1] == 0xFF) && (buffer[i] == 0xd9))
    104.                         //{
    105.                         //    data.Add(buffer[i - 1]);
    106.                         //    data.Add(buffer[i]);
    107.                         //    ispictrue = false;
    108.                         //    break;
    109.                         //}
    110.                     }
    111.                     WriteFileUsingBinaryWriter(path + "\\out\\", DateTime.Now.ToString("yyyyMMdd-HHmmss.fff") + ".jpg", data.ToArray(), data.Count());
    112.                 }
    113.                 offset = 0;
    114.                 length = 0;
    115.                 isData = false;
    116.                   
    117.             }
    118.         }
    119.     }
    120.     catch (Exception ex)
    121.     {
    122.         Console.WriteLine("串口解析出错" + ex.ToString());
    123.     }
    124. }
    125.  
    126. public void WriteFileUsingBinaryWriter(string path,string fileName,byte[] data,int length)
    127. {
    128.     var outputStream = File.Create(path + fileName);
    129.     using (var writer = new BinaryWriter(outputStream))
    130.     {
    131.         writer.Write(data, 0, length);
    132.     }
    133. }
    134.  
    135. /// 
    136. /// 效验文件夹，没有就创建
    137. /// 
    138. private void DirectoryCheak(string path)
    139. {
    140.     if (false == System.IO.Directory.Exists(path))
    141.     {
    142.         System.IO.Directory.CreateDirectory(path);
    143.     }
    144. }
    145.  
    146. private void OpenSerialPort_Click(object sender, RoutedEventArgs e)
    147. {
    148.     try
    149.     {
    150.         _serialPort = new SerialPort();
    151.  
    152.         _serialPort.PortName = SerialPort.Text;
    153.         _serialPort.BaudRate = int.Parse(SerialBaudRate.Text);
    154.         _serialPort.Parity = Parity.None;
    155.         _serialPort.DataBits = 8;
    156.         _serialPort.StopBits = StopBits.One;
    157.         _serialPort.ReadTimeout = 10000;//单位毫秒
    158.         _serialPort.WriteTimeout = 10000;//单位毫秒
    159.  
    160.         //设置串口字节接收缓冲值，通常为1
    161.         //获得接收后，触发事件处理
    162.         _serialPort.ReceivedBytesThreshold = 1;
    163.         _serialPort.DataReceived += new SerialDataReceivedEventHandler(DataCallBack);
    164.  
    165.  
    166.         _serialPort.Open();//Console.WriteLine(serialPort.IsOpen.ToString());
    167.         OpenSerialPort.IsEnabled = false;
    168.         CloseSerialPort.IsEnabled = true;
    169.     }
    170.     catch (Exception ex)
    171.     {
    172.         MessageBox.Show("串口打开失败" + ex.ToString());
    173.         //System.Environment.Exit(0);//退出应用程序
    174.     }
    175. }
    176.  
    177. private void CloseSerialPort_Click(object sender, RoutedEventArgs e)
    178. {
    179.     try
    180.     {
    181.         if (_serialPort.IsOpen == true)
    182.         {
    183.             _serialPort.Close();
    184.             OpenSerialPort.IsEnabled = true;
    185.             CloseSerialPort.IsEnabled = false;
    186.         }
    187.     }
    188.     catch (Exception ex)
    189.     {
    190.         MessageBox.Show("串口关闭失败" + ex.ToString());
    191.         System.Environment.Exit(0);//退出应用程序
    192.     }
    193. }

    单片机关键部分代码

    1. /* USER CODE BEGIN Header */
    2. /**
    3.   ******************************************************************************
    4.   * @file    dcmi.c
    5.   * @brief   This file provides code for the configuration
    6.   *          of the DCMI instances.
    7.   ******************************************************************************
    8.   * @attention
    9.   *
    10.   * Copyright (c) 2022 STMicroelectronics.
    11.   * All rights reserved.
    12.   *
    13.   * This software is licensed under terms that can be found in the LICENSE file
    14.   * in the root directory of this software component.
    15.   * If no LICENSE file comes with this software, it is provided AS-IS.
    16.   *
    17.   ******************************************************************************
    18.   */
    19. /* USER CODE END Header */
    20. /* Includes ------------------------------------------------------------------*/
    21. #include "dcmi.h"
    22.  
    23. /* USER CODE BEGIN 0 */
    24. #include 
    25. #include 
    26.  
    27. __align(32) uint32_t buffer[65535] __attribute((at(0X24040000)));
    28.  
    29. unsigned char getPicture = 0;
    30. unsigned int jpeglen = 0;
    31. //unsigned int recvOk = 0;
    32.  
    33. /* USER CODE END 0 */
    34.  
    35. DCMI_HandleTypeDef hdcmi;
    36. DMA_HandleTypeDef hdma_dcmi_pssi;
    37.  
    38. /* DCMI init function */
    39. void MX_DCMI_Init(void)
    40. {
    41.  
    42.   /* USER CODE BEGIN DCMI_Init 0 */
    43.  
    44.   /* USER CODE END DCMI_Init 0 */
    45.  
    46.   /* USER CODE BEGIN DCMI_Init 1 */
    47.  
    48.   /* USER CODE END DCMI_Init 1 */
    49.   hdcmi.Instance = DCMI;
    50.   hdcmi.Init.SynchroMode = DCMI_SYNCHRO_HARDWARE;
    51.   hdcmi.Init.PCKPolarity = DCMI_PCKPOLARITY_RISING;
    52.   hdcmi.Init.VSPolarity = DCMI_VSPOLARITY_LOW;
    53.   hdcmi.Init.HSPolarity = DCMI_HSPOLARITY_LOW;
    54.   hdcmi.Init.CaptureRate = DCMI_CR_ALL_FRAME;
    55.   hdcmi.Init.ExtendedDataMode = DCMI_EXTEND_DATA_8B;
    56.   hdcmi.Init.JPEGMode = DCMI_JPEG_ENABLE;
    57.   hdcmi.Init.ByteSelectMode = DCMI_BSM_ALL;
    58.   hdcmi.Init.ByteSelectStart = DCMI_OEBS_ODD;
    59.   hdcmi.Init.LineSelectMode = DCMI_LSM_ALL;
    60.   hdcmi.Init.LineSelectStart = DCMI_OELS_ODD;
    61.   if (HAL_DCMI_Init(&hdcmi) != HAL_OK)
    62.   {
    63.     Error_Handler();
    64.   }
    65.   /* USER CODE BEGIN DCMI_Init 2 */
    66. 	//printf("MX_DCMI_Init ok\r\n");
    67.   /* USER CODE END DCMI_Init 2 */
    68.  
    69. }
    70.  
    71. void HAL_DCMI_MspInit(DCMI_HandleTypeDef* dcmiHandle)
    72. {
    73.  
    74.   GPIO_InitTypeDef GPIO_InitStruct = {0};
    75.   if(dcmiHandle->Instance==DCMI)
    76.   {
    77.   /* USER CODE BEGIN DCMI_MspInit 0 */
    78. 	 //printf("if(dcmiHandle->Instance==DCMI)\r\n");
    79.   /* USER CODE END DCMI_MspInit 0 */
    80.     /* DCMI clock enable */
    81.     __HAL_RCC_DCMI_CLK_ENABLE();
    82.  
    83.     __HAL_RCC_GPIOE_CLK_ENABLE();
    84.     __HAL_RCC_GPIOA_CLK_ENABLE();
    85.     __HAL_RCC_GPIOB_CLK_ENABLE();
    86.     __HAL_RCC_GPIOD_CLK_ENABLE();
    87.     /**DCMI GPIO Configuration
    88.     PE4     ------> DCMI_D4
    89.     PE5     ------> DCMI_D6
    90.     PE6     ------> DCMI_D7
    91.     PA4     ------> DCMI_HSYNC
    92.     PA6     ------> DCMI_PIXCLK
    93.     PB13     ------> DCMI_D2
    94.     PA9     ------> DCMI_D0
    95.     PA10     ------> DCMI_D1
    96.     PD3     ------> DCMI_D5
    97.     PB7     ------> DCMI_VSYNC
    98.     PE1     ------> DCMI_D3
    99.     */
    100.     GPIO_InitStruct.Pin = GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_1;
    101.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    102.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    103.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    104.     GPIO_InitStruct.Alternate = GPIO_AF13_DCMI;
    105.     HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
    106.  
    107.     GPIO_InitStruct.Pin = GPIO_PIN_4|GPIO_PIN_6|GPIO_PIN_9|GPIO_PIN_10;
    108.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    109.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    110.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    111.     GPIO_InitStruct.Alternate = GPIO_AF13_DCMI;
    112.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    113.  
    114.     GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_7;
    115.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    116.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    117.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    118.     GPIO_InitStruct.Alternate = GPIO_AF13_DCMI;
    119.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    120.  
    121.     GPIO_InitStruct.Pin = GPIO_PIN_3;
    122.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    123.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    124.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    125.     GPIO_InitStruct.Alternate = GPIO_AF13_DCMI;
    126.     HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
    127.  
    128.     /* DCMI DMA Init */
    129.     /* DCMI_PSSI Init */
    130.     hdma_dcmi_pssi.Instance = DMA1_Stream0;
    131.     hdma_dcmi_pssi.Init.Request = DMA_REQUEST_DCMI_PSSI;
    132.     hdma_dcmi_pssi.Init.Direction = DMA_PERIPH_TO_MEMORY;
    133.     hdma_dcmi_pssi.Init.PeriphInc = DMA_PINC_DISABLE;
    134.     hdma_dcmi_pssi.Init.MemInc = DMA_MINC_ENABLE;
    135.     hdma_dcmi_pssi.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
    136.     hdma_dcmi_pssi.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
    137.     hdma_dcmi_pssi.Init.Mode = DMA_NORMAL;
    138.     hdma_dcmi_pssi.Init.Priority = DMA_PRIORITY_VERY_HIGH;
    139.     hdma_dcmi_pssi.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
    140.     hdma_dcmi_pssi.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;
    141.     hdma_dcmi_pssi.Init.MemBurst = DMA_MBURST_SINGLE;
    142.     hdma_dcmi_pssi.Init.PeriphBurst = DMA_PBURST_SINGLE;
    143.     if (HAL_DMA_Init(&hdma_dcmi_pssi) != HAL_OK)
    144.     {
    145.       Error_Handler();
    146.     }
    147.  
    148.     /* Several peripheral DMA handle pointers point to the same DMA handle.
    149.      Be aware that there is only one channel to perform all the requested DMAs. */
    150.     __HAL_LINKDMA(dcmiHandle,DMA_Handle,hdma_dcmi_pssi);
    151.  
    152.     /* DCMI interrupt Init */
    153.     HAL_NVIC_SetPriority(DCMI_PSSI_IRQn, 2, 0);
    154.     HAL_NVIC_EnableIRQ(DCMI_PSSI_IRQn);
    155.   /* USER CODE BEGIN DCMI_MspInit 1 */
    156. 		
    157. 		HAL_GPIO_WritePin(GPIOC,GPIO_PIN_14,GPIO_PIN_SET);
    158. 		HAL_Delay(100);
    159. 		HAL_GPIO_WritePin(GPIOC,GPIO_PIN_14,GPIO_PIN_RESET);
    160. 		//printf("HAL_DCMI_MspInit ok\r\n");
    161.   /* USER CODE END DCMI_MspInit 1 */
    162.   }
    163. }
    164.  
    165. void HAL_DCMI_MspDeInit(DCMI_HandleTypeDef* dcmiHandle)
    166. {
    167.  
    168.   if(dcmiHandle->Instance==DCMI)
    169.   {
    170.   /* USER CODE BEGIN DCMI_MspDeInit 0 */
    171.  
    172.   /* USER CODE END DCMI_MspDeInit 0 */
    173.     /* Peripheral clock disable */
    174.     __HAL_RCC_DCMI_CLK_DISABLE();
    175.  
    176.     /**DCMI GPIO Configuration
    177.     PE4     ------> DCMI_D4
    178.     PE5     ------> DCMI_D6
    179.     PE6     ------> DCMI_D7
    180.     PA4     ------> DCMI_HSYNC
    181.     PA6     ------> DCMI_PIXCLK
    182.     PB13     ------> DCMI_D2
    183.     PA9     ------> DCMI_D0
    184.     PA10     ------> DCMI_D1
    185.     PD3     ------> DCMI_D5
    186.     PB7     ------> DCMI_VSYNC
    187.     PE1     ------> DCMI_D3
    188.     */
    189.     HAL_GPIO_DeInit(GPIOE, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_1);
    190.  
    191.     HAL_GPIO_DeInit(GPIOA, GPIO_PIN_4|GPIO_PIN_6|GPIO_PIN_9|GPIO_PIN_10);
    192.  
    193.     HAL_GPIO_DeInit(GPIOB, GPIO_PIN_13|GPIO_PIN_7);
    194.  
    195.     HAL_GPIO_DeInit(GPIOD, GPIO_PIN_3);
    196.  
    197.     /* DCMI DMA DeInit */
    198.     HAL_DMA_DeInit(dcmiHandle->DMA_Handle);
    199.  
    200.     /* DCMI interrupt Deinit */
    201.     HAL_NVIC_DisableIRQ(DCMI_PSSI_IRQn);
    202.   /* USER CODE BEGIN DCMI_MspDeInit 1 */
    203. 		HAL_GPIO_WritePin(GPIOC,GPIO_PIN_14,GPIO_PIN_SET);
    204. 		HAL_Delay(100);
    205. 		HAL_GPIO_WritePin(GPIOC,GPIO_PIN_14,GPIO_PIN_RESET);
    206. 	  printf("HAL_DCMI_MspDeInit ok\r\n");
    207.   /* USER CODE END DCMI_MspDeInit 1 */
    208.   }
    209. }
    210.  
    211. /* USER CODE BEGIN 1 */
    212.  
    213.  
    214. void StartOV2640()
    215. {
    216. 		int i =0;
    217. 		__HAL_DCMI_ENABLE_IT(&hdcmi, DCMI_IER_FRAME_IE);                                               	//使用帧中断
    218.     memset(buffer, 0, 65535);                                        					//把接收BUF清空
    219.     HAL_DCMI_Start_DMA(&hdcmi, DCMI_MODE_SNAPSHOT, (uint32_t)buffer, 65535); 	//启动拍照
    220. }
    221.  
    222.  
    223. void HAL_DCMI_FrameEventCallback(DCMI_HandleTypeDef *hdcmi)
    224. {
    225. 	  int i =0;
    226. 	  HAL_DCMI_Suspend(hdcmi); // 拍照完成，挂起 DCMI
    227. 	  HAL_DCMI_Stop(hdcmi);    // 拍照完成，停止 DMA传输
    228.     int pictureLength = 65535;
    229.     while (pictureLength > 0)     //循环计算出接收的JPEG的大小
    230.     {
    231.         if (buffer[pictureLength - 1] != 0x00000000)
    232.         {
    233.           break;
    234.         }
    235.         pictureLength--;
    236.     }
    237. 		jpeglen = pictureLength * 4;
    238. 		getPicture = 1;
    239. }
    240. /* USER CODE END 1 */

    单片机代码

    1. /* USER CODE BEGIN Header */
    2. /**
    3.   ******************************************************************************
    4.   * @file           : main.c
    5.   * @brief          : Main program body
    6.   ******************************************************************************
    7.   * @attention
    8.   *
    9.   * Copyright (c) 2022 STMicroelectronics.
    10.   * All rights reserved.
    11.   *
    12.   * This software is licensed under terms that can be found in the LICENSE file
    13.   * in the root directory of this software component.
    14.   * If no LICENSE file comes with this software, it is provided AS-IS.
    15.   *
    16.   ******************************************************************************
    17.   */
    18. /* USER CODE END Header */
    19. /* Includes ------------------------------------------------------------------*/
    20. #include "main.h"
    21. #include "adc.h"
    22. #include "dcmi.h"
    23. #include "dma.h"
    24. #include "rtc.h"
    25. #include "usart.h"
    26. #include "gpio.h"
    27.  
    28. /* Private includes ----------------------------------------------------------*/
    29. /* USER CODE BEGIN Includes */
    30. #include 
    31. #include "ov2640.h"
    32. #include "ov5640.h"
    33. #include 
    34. /* USER CODE END Includes */
    35.  
    36. /* Private typedef -----------------------------------------------------------*/
    37. /* USER CODE BEGIN PTD */
    38.  
    39. /* USER CODE END PTD */
    40.  
    41. /* Private define ------------------------------------------------------------*/
    42. /* USER CODE BEGIN PD */
    43. /* USER CODE END PD */
    44.  
    45. /* Private macro -------------------------------------------------------------*/
    46. /* USER CODE BEGIN PM */
    47.  
    48. /* USER CODE END PM */
    49.  
    50. /* Private variables ---------------------------------------------------------*/
    51.  
    52. /* USER CODE BEGIN PV */
    53.  
    54. /* USER CODE END PV */
    55.  
    56. /* Private function prototypes -----------------------------------------------*/
    57. void SystemClock_Config(void);
    58. /* USER CODE BEGIN PFP */
    59.  
    60. /* USER CODE END PFP */
    61.  
    62. /* Private user code ---------------------------------------------------------*/
    63. /* USER CODE BEGIN 0 */
    64.  
    65. #define OV2640_JPEG_WIDTH	 1600	//JPEG拍照的宽度	
    66. #define OV2640_JPEG_HEIGHT 1200		//JPEG拍照的高度
    67.  
    68. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    69. PUTCHAR_PROTOTYPE
    70. {
    71. 		USART1->TDR = ch;
    72. 		while(!(USART1->ISR& USART_ISR_TXE_TXFNF_Msk)) 
    73. 		{;}
    74. 		 return ch;
    75. }
    76.  
    77. static void CPU_CACHE_Enable(void)
    78. {
    79. 	SCB_EnableICache();//使能I-Cache
    80.   SCB_EnableDCache();//使能D-Cache   
    81. 	SCB->CACR|=1<<2;   //强制D-Cache透写,如不开启,实际使用中可能遇到各种问题	
    82. }
    83.  
    84. void Send(uint8_t *pData)
    85. {
    86. 	uint32_t i = 0;
    87. 	printf("jpeg data size:%d\r\n",jpeglen);//串口打印JPEG文件大小	
    88. 	HAL_Delay(1000);		
    89. 	for(i = 0;i < jpeglen;i++)
    90. 	{
    91. 		//printf("%02x\t",pData[i]);
    92. 		printf("%c",pData[i]);
    93. 	}
    94. 	HAL_Delay(1000);		
    95. 	printf("\r\n");
    96. }
    97.  
    98. /* USER CODE END 0 */
    99.  
    100. /**
    101.   * @brief  The application entry point.
    102.   * @retval int
    103.   */
    104. int main(void)
    105. {
    106.   /* USER CODE BEGIN 1 */
    107. 	uint32_t i = 0;
    108. 	uint32_t index = 1;
    109. 	//CPU_CACHE_Enable();
    110.   /* USER CODE END 1 */
    111.  
    112.   /* MCU Configuration--------------------------------------------------------*/
    113.  
    114.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    115.   HAL_Init();
    116.  
    117.   /* USER CODE BEGIN Init */
    118.  
    119.   /* USER CODE END Init */
    120.  
    121.   /* Configure the system clock */
    122.   SystemClock_Config();
    123.  
    124.   /* USER CODE BEGIN SysInit */
    125. 	HAL_Delay(5000);
    126. 	//__enable_irq();
    127.   /* USER CODE END SysInit */
    128.  
    129.   /* Initialize all configured peripherals */
    130.   MX_GPIO_Init();
    131.   MX_RTC_Init();
    132.   MX_USART1_UART_Init();
    133.   MX_USART2_UART_Init();
    134.   MX_DMA_Init();
    135.   MX_ADC1_Init();
    136.   MX_USART3_UART_Init();
    137.   /* USER CODE BEGIN 2 */
    138. 	HAL_Delay(100);
    139. 	MX_DCMI_Init();
    140. 		
    141. 	HAL_GPIO_WritePin(GPIOA,GPIO_PIN_7,GPIO_PIN_SET);
    142. 	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_6,GPIO_PIN_SET);
    143. 	
    144. 	HAL_Delay(1000);
    145. 	
    146. 	
    147. //	HAL_DCMI_DeInit(&hdcmi);
    148. //  PY_DCMI_Full_Init();
    149. 	
    150.   /* USER CODE END 2 */
    151.  
    152.   /* Infinite loop */
    153.   /* USER CODE BEGIN WHILE */
    154.   while (1)
    155.   {
    156. 		printf("OV2640 初始化!cam:%d\r\n",index);
    157. 		while(OV2640_Init(index))			
    158. 		{
    159. 			printf("OV2640 错误!cam:%d\r\n",index);
    160. 		}
    161. 		printf("OV2640 成功!cam:%d\r\n",index);
    162. 		HAL_Delay(1000);
    163. 		if(1)
    164. 		{
    165. 			OV2640_JPEG_Mode();	//切换为JPEG模式 
    166. 			printf("切换为JPEG模式 !\r\n");
    167. 			OV2640_OutSize_Set(OV2640_JPEG_WIDTH,OV2640_JPEG_HEIGHT); 
    168. 			printf("设置图像大小 !\r\n");
    169. 			SCCB_WR_Reg(0XFF,0X00);
    170. 			SCCB_WR_Reg(0XD3,0X10);
    171. 			SCCB_WR_Reg(0XFF,0X01);
    172. 			SCCB_WR_Reg(0X11,0X8); 
    173. 		}
    174. 		if(0)
    175. 		{
    176. 			OV2640_RGB565_Mode();			//RGB565模式
    177. 			printf("RGB565模式 !\r\n");
    178. 			OV2640_OutSize_Set(OV2640_JPEG_WIDTH,OV2640_JPEG_HEIGHT); 
    179. 			printf("设置图像大小 !\r\n");
    180. 			SCCB_WR_Reg(0XFF,0X00);		
    181. 			SCCB_WR_Reg(0XD3,0X12);	//设置PCLK分频
    182. 			SCCB_WR_Reg(0XFF,0X01);
    183. 			SCCB_WR_Reg(0X11,0X1);	//设置CLK分频	
    184. 		}
    185. 		printf("开始工作\r\n");
    186. 		HAL_Delay(100);
    187. 		//Get_Photo();
    188. 		//DCMI_Start();
    189. 		StartOV2640();
    190. 		HAL_Delay(1000);		
    191. 		while(1)
    192. 		{
    193. 			if(getPicture==1)
    194. 			{
    195. 				Send((uint8_t *)buffer);
    196. 				break;
    197. 			}
    198. 			else
    199. 			{
    200. 				//printf("adc start\r\n");
    201. 				//GetValue();
    202. 				//printf("adc end\r\n");
    203. 				HAL_Delay(10);
    204. 				HAL_GPIO_WritePin(GPIOC,GPIO_PIN_14,GPIO_PIN_SET);
    205. 				HAL_Delay(10);
    206. 				HAL_GPIO_WritePin(GPIOC,GPIO_PIN_14,GPIO_PIN_RESET);
    207. 			}	
    208. 			//printf("jpeg haven't finished\r\n");		
    209. 		}	
    210. 		if(index>3)
    211. 		{
    212. 			index = 1;
    213. 		}
    214. 		else
    215. 		{
    216. 			index++;
    217. 		}
    218.  
    219.     /* USER CODE END WHILE */
    220.  
    221.     /* USER CODE BEGIN 3 */
    222.   }
    223.   /* USER CODE END 3 */
    224. }
    225.  
    226. /**
    227.   * @brief System Clock Configuration
    228.   * @retval None
    229.   */
    230. void SystemClock_Config(void)
    231. {
    232.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    233.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
    234.  
    235.   /** Supply configuration update enable
    236.   */
    237.   HAL_PWREx_ConfigSupply(PWR_LDO_SUPPLY);
    238.  
    239.   /** Configure the main internal regulator output voltage
    240.   */
    241.   __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE0);
    242.  
    243.   while(!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {}
    244.  
    245.   /** Macro to configure the PLL clock source
    246.   */
    247.   __HAL_RCC_PLL_PLLSOURCE_CONFIG(RCC_PLLSOURCE_HSI);
    248.  
    249.   /** Initializes the RCC Oscillators according to the specified parameters
    250.   * in the RCC_OscInitTypeDef structure.
    251.   */
    252.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI|RCC_OSCILLATORTYPE_LSI;
    253.   RCC_OscInitStruct.HSIState = RCC_HSI_DIV1;
    254.   RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    255.   RCC_OscInitStruct.LSIState = RCC_LSI_ON;
    256.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    257.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
    258.   RCC_OscInitStruct.PLL.PLLM = 4;
    259.   RCC_OscInitStruct.PLL.PLLN = 35;
    260.   RCC_OscInitStruct.PLL.PLLP = 2;
    261.   RCC_OscInitStruct.PLL.PLLQ = 2;
    262.   RCC_OscInitStruct.PLL.PLLR = 2;
    263.   RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_3;
    264.   RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
    265.   RCC_OscInitStruct.PLL.PLLFRACN = 0;
    266.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    267.   {
    268.     Error_Handler();
    269.   }
    270.  
    271.   /** Initializes the CPU, AHB and APB buses clocks
    272.   */
    273.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
    274.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2
    275.                               |RCC_CLOCKTYPE_D3PCLK1|RCC_CLOCKTYPE_D1PCLK1;
    276.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    277.   RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
    278.   RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV1;
    279.   RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
    280.   RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
    281.   RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
    282.   RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
    283.  
    284.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_7) != HAL_OK)
    285.   {
    286.     Error_Handler();
    287.   }
    288.   HAL_RCC_MCOConfig(RCC_MCO1, RCC_MCO1SOURCE_HSI, RCC_MCODIV_8);
    289. }
    290.  
    291. /* USER CODE BEGIN 4 */
    292.  
    293. /* USER CODE END 4 */
    294.  
    295. /**
    296.   * @brief  This function is executed in case of error occurrence.
    297.   * @retval None
    298.   */
    299. void Error_Handler(void)
    300. {
    301.   /* USER CODE BEGIN Error_Handler_Debug */
    302. 	printf("Error_Handler\r\n");
    303.   /* User can add his own implementation to report the HAL error return state */
    304.   __disable_irq();
    305. 	HAL_Delay(1000);		
    306.   while (1)
    307.   {
    308.   }
    309.   /* USER CODE END Error_Handler_Debug */
    310. }
    311.  
    312. #ifdef  USE_FULL_ASSERT
    313. /**
    314.   * @brief  Reports the name of the source file and the source line number
    315.   *         where the assert_param error has occurred.
    316.   * @param  file: pointer to the source file name
    317.   * @param  line: assert_param error line source number
    318.   * @retval None
    319.   */
    320. void assert_failed(uint8_t *file, uint32_t line)
    321. {
    322.   /* USER CODE BEGIN 6 */
    323.   /* User can add his own implementation to report the file name and line number,
    324.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
    325.   /* USER CODE END 6 */
    326. }
    327. #endif /* USE_FULL_ASSERT */

  • 相关阅读:
    SQL sever中的索引
    electron + vue3 + ts 打包后安装打开白屏解决
    TeXLive 2023安装教程
    MySQL篇之SQL优化
    OpenAI变天：也许会有另一个OpenAI要崛起？
    HCIA网络基础7-VRP和命令行基础
    精准用户画像！商城用户分群2.0！⛵
    一个bug引发的对大端小端的深入思考
    《Vue.js实战》第7章答案
    python 装饰器
  • 原文地址：https://blog.csdn.net/g313105910/article/details/126894008