21ic电子技术开发论坛 › 单片机与嵌入式系统 › 国民技术MCU › 【N32G430开发板试用】可视呼叫门铃演示样机 ...
返回列表 发新帖我要提问

[活动专区] 【N32G430开发板试用】可视呼叫门铃演示样机

[复制链接]
2235|11
 楼主| xld0932 发表于 2022-7-25 19:57 | 显示全部楼层 |阅读模式
N32G430, 可视门铃
本帖最后由 xld0932 于 2023-7-19 13:24 编辑

@安小芯    @21小跑堂


概述
基于N32G430C8L7-STB开发板搭配外围功能模块实现可视呼叫门铃的功能演示。通过板载的按键检测实现门铃呼叫、开锁功能；当按键呼叫按键后，通过摄像头将门口景象以静态图片的形式显示在TFT显示屏上，同时播放门铃音乐；当按键开锁按键后，在TFT显示屏上显示开锁提示。功能描述虽然简单，但使用的MCU外设技术点不少哦，涉及到了GPIO、SPI、I2S、DMA、UART、FLASH、RTC等，主要是想通过实现这个演示样机的功能来熟悉国民MCU产品，最后为了完成上述功能还需要在标准板的基础上再画一块实现上述功能的扩展板。


软件功能
  • 通过板载的按键实现模拟门铃呼叫按键、开锁的功能；
  • 通过USART2与RS485模块连接，RS485模块连接到远端的门口摄像头，通过发送指令的形式抓拍图片，再通过指令回传图片数据；
  • 通过SPI接口连接SPI接口的TFT显示屏，显示相关信息（**、开锁提示、摄像头图片、音频文件等）；
  • 通过SPI接口连接SPI FLASH存储模块，在存储模块中存放GBK中文字库、**图片数据等信息；通过PC端的SecureCRT软件与N32G430C8L7-STB板载的USART1进行通讯，将资源文件通过Xmodem协议下载到SPI FLASH存储模块中；
  • 通过I2S接口连接CS4344音频模块，通过音频线将CS4344模块与音箱相连接；


系统框图
由于N32G430C8L7芯片资源只带有64KB的FLASH和16KB的SRAM空间，所以需要扩展SPI FLASH来存放一些资源文件；在系统中使用I2S来播放WAV文件，为了达到播放音频流畅的效果，WAV文件的读取使用了双缓存结合DMA的实现方式，所以占用了部分的SRAM空间；对于RS485摄像头回传的图片数据是JPEG格式的，所以在实现方案中我们使用了TJPGD3软件解码库，将JPEG格式的图片数据进行解析，并显示到TFT显示屏上，对于软件解码JPEG图片需要占用不少的SRAM的空间，这样留给摄像头图片读回存放的空间就已经不够用了，所以为了解决这个问题，我们想到将摄像头读回的JPEG图片数据暂存在MCU内部FLASH空间，这样就解决了SRAM空间不足的问题了！
系统框图.jpg


硬件准备
  • N32G430C8L7-STB开发板
  • N32G430C8L7-STB_EBK功能扩展板（RS485模块、CS4344模块、SPI FLASH模块、TFT显示屏）
  • RS485接口摄像头
  • 音箱
  • 相关数据连接线
硬件环境.jpg


N32G430C8L7-STB_EBK功能扩展板
原理图
扩展板原理图.png

PCB-2D正面图
扩展板PCB.png

焊接成品
扩展板成品图.jpg


资源文件
GBK中文字库存放在SPI FLASH起始地址为0的位置、音频文件存放在SPI FLASH起始地址为0x100000的位置、**等图片信息存放在SPI FLASH起始地址为0x200000的位置；在下载资源到SPI FLASH时，需要将config.h文件中宏定义修改为如下所示：
下载配置.png

然后打开PC端的SecureCRT软件下载资源文件，输入的命令为XMODEM 1 XXXXX，其中1表示PC端将数据下传到MCU，经MCU将数据写入到SPI FLASH，第二个参数是指令下载的起始地址；XMODEM协议在传输时带有校验和重传机制，所以在出现ERROR后不用担心数据丢失或者数据不正确，如下图所示：
下载资源.png

在TFT初始显示界面上有两个**显示，如果这些图片存放在MCU FLASH空间会导致后面的功能代码空间不足，所以就存放在SPI FLASH存储了；在取模时需要结合代码的实现来设定，如下所示：
取模1.jpg 取模2.jpg

其中勾选了包含图像头数据为了获取图片的宽度、高度信息，方便程序中排版显示。


代码实现
代码部分仅摘录了部分，完整的功能代码可以下载文末的软件工程源代码附件。

摄像头相关部分
复制
  1. void CAMERA_RxHandler(void)
    

  2. {
    

  3.     static uint8_t  RxStart   = 0;
    

  4.     static uint16_t RxIndex   = 0;
    

  5.     static uint8_t  RxBuffer[600];
    

  6.     static uint32_t RxLength  = 0;
    


  7. 

  8.     if(QUEUE_EMPTY(QUEUE_CAMERA_IDX) == 0)
    

  9.     {
    

  10.         uint8_t RxData = QUEUE_READ(QUEUE_CAMERA_IDX);
    


  11. 

  12.         if(RxStart == 0)
    

  13.         {
    

  14.             if(RxData == CAMERA_START)
    

  15.             {
    

  16.                 RxStart = 1;
    

  17.                 RxIndex = 0;
    


  18. 

  19.                 memset(RxBuffer, 0, sizeof(RxBuffer));
    


  20. 

  21.                 RxBuffer[RxIndex++] = RxData;
    

  22.             }
    

  23.         }
    

  24.         else
    

  25.         {
    

  26.             if(RxIndex == 1)
    

  27.             {
    

  28.                 RxBuffer[RxIndex++] = RxData;
    

  29.             }
    

  30.             else
    

  31.             {
    

  32.                 RxBuffer[RxIndex++] = RxData;
    


  33. 

  34.                 switch(RxBuffer[1])
    

  35.                 {
    

  36.                     case CAMERA_CMD_H:
    

  37.                         if((RxIndex ==  4) && (RxBuffer[RxIndex-1] == CAMERA_END))
    

  38.                         {
    

  39.                             RxStart = 0;
    

  40.                         }
    

  41.                         break;
    


  42. 

  43.                     case CAMERA_CMD_R:
    

  44.                         if((RxIndex == 10) && (RxBuffer[RxIndex-1] == CAMERA_END))
    

  45.                         {
    

  46.                             RxStart = 0;
    


  47. 

  48.                             CAMERA_PictureSize   = RxBuffer[6];
    

  49.                             CAMERA_PictureSize <<= 8;
    

  50.                             CAMERA_PictureSize  |= RxBuffer[5];
    

  51.                             CAMERA_PictureSize <<= 8;
    

  52.                             CAMERA_PictureSize  |= RxBuffer[4];
    

  53.                             CAMERA_PictureSize <<= 8;
    

  54.                             CAMERA_PictureSize  |= RxBuffer[3];
    


  55. 

  56.                             CAMERA_PacketTotal   = RxBuffer[8];
    

  57.                             CAMERA_PacketTotal <<= 8;
    

  58.                             CAMERA_PacketTotal  |= RxBuffer[7];
    


  59. 

  60.                             CAMERA_CMD_Running = 0;
    

  61.                         }
    

  62.                         break;
    


  63. 

  64.                     case CAMERA_CMD_E:
    

  65.                         if((RxIndex ==  4) && (RxBuffer[RxIndex-1] == CAMERA_END))
    

  66.                         {
    

  67.                             RxStart = 0;
    

  68.                         }
    

  69.                         break;
    


  70. 

  71.                     case CAMERA_CMD_F:
    

  72.                         if(CAMERA_PacketIndex < CAMERA_PacketTotal)
    

  73.                         {
    

  74.                             RxLength = CAMERA_PACKET_SIZE;
    

  75.                         }
    

  76.                         else
    

  77.                         {
    

  78.                             RxLength = CAMERA_PictureSize % CAMERA_PACKET_SIZE;
    

  79.                         }
    


  80. 

  81.                         if(RxIndex == (RxLength + 9))
    

  82.                         {
    

  83.                             RxStart = 0;
    


  84. 

  85.                             uint16_t PacketIndex = 0;
    

  86.                             uint16_t PictureSize = 0;
    

  87.                             uint32_t SRAM_Offset = 0;
    


  88. 

  89.                             PacketIndex   = RxBuffer[4];
    

  90.                             PacketIndex <<= 8;
    

  91.                             PacketIndex  |= RxBuffer[3];
    


  92. 

  93.                             PictureSize   = RxBuffer[6];
    

  94.                             PictureSize <<= 8;
    

  95.                             PictureSize  |= RxBuffer[5];
    


  96. 

  97.                             SRAM_Offset = (PacketIndex - 1) * CAMERA_PACKET_SIZE;
    


  98. 

  99.                             if(((PacketIndex - 1) % 4) == 0)
    

  100.                             {
    

  101.                                 FLASH_Unlock();
    

  102.                                 FLASH_One_Page_Erase(0x0800A000 + SRAM_Offset);
    

  103.                                 FLASH_Lock();
    

  104.                             }
    


  105. 

  106.                             FLASH_Unlock();
    


  107. 

  108.                             for(uint16_t i = 0; i < PictureSize; i+=4)
    

  109.                             {
    

  110.                                 FLASH_Word_Program(i+SRAM_Offset+0x0800A000, *((uint32_t *)(&RxBuffer[i+7])));
    

  111.                             }
    


  112. 

  113.                             FLASH_Lock();
    


  114. 

  115.                             CAMERA_CMD_Running = 0;
    

  116.                         }
    

  117.                         break;
    


  118. 

  119.                     case CAMERA_CMD_D: break;
    

  120.                     case CAMERA_CMD_I: break;
    

  121.                     case CAMERA_CMD_Q: break;
    

  122.                     default:
    

  123.                         break;
    

  124.                 }
    

  125.             }
    

  126.         }
    

  127.     }
    

  128. }


TFT相关部分
复制
  1. void LCD_ShowEN(uint16_t X, uint16_t Y, char ch)
    

  2. {  
    

  3.     uint8_t  Data  = 0;
    

  4.     uint16_t Color = 0;
    


  5. 

  6.     for(uint8_t i = 0; i < 16; i++)
    

  7.     {
    

  8.         Data = ASCII_1608[ch - 32][i];
    


  9. 

  10.         for(uint8_t j = 0; j < 8; j++)
    

  11.         {
    

  12.             if((Data >> j) & 0x01) Color = LCD_Forecolor;
    

  13.             else                   Color = BACKCOLOR;
    


  14. 

  15.             LCD_DrawPoint(X+j, Y+i, Color);
    

  16.         }
    

  17.     }
    

  18. }
    


  19. 

  20. void LCD_ShowCN(uint16_t StartX, uint16_t StartY, const char *str)
    

  21. {
    

  22.     uint8_t Buffer[32];
    

  23.     uint8_t Array[16][16];
    

  24.     uint8_t Point[16][16];
    


  25. 

  26.     memset(Buffer, 0xFF, sizeof(Buffer));
    


  27. 

  28.     SPI_FLASH_GetGBK(str, Buffer);
    


  29. 

  30.     for(uint8_t i = 0; i < 8; i++)
    

  31.     {
    

  32.         for(uint8_t j = 0; j < 4; j++)
    

  33.         {
    

  34.             uint8_t Data = Buffer[i*4+j];
    


  35. 

  36.             for(uint8_t k = 0; k < 4; k++)
    

  37.             {
    

  38.                 if(Data & (0x08 >> (k-0)))  Array[i*2+0][j*4+k-0] = 1;
    

  39.                 else                        Array[i*2+0][j*4+k-0] = 0;
    

  40.             }
    


  41. 

  42.             for(uint8_t k = 4; k < 8; k++)
    

  43.             {
    

  44.                 if(Data & (0x80 >> (k-4)))  Array[i*2+1][j*4+k-4] = 1;
    

  45.                 else                        Array[i*2+1][j*4+k-4] = 0;
    

  46.             }
    

  47.         }
    

  48.     }
    


  49. 

  50.     for(uint8_t i = 0; i < 16; i++)
    

  51.     {
    

  52.         for(uint8_t j = 0; j < 16; j++)
    

  53.         {
    

  54.             Point[i][j] = Array[j][15-i];
    

  55.         }
    

  56.     }
    


  57. 

  58.     for(uint8_t i = 0; i < 16; i++)
    

  59.     {
    

  60.         for(uint8_t j = 0; j < 16; j++)
    

  61.         {
    

  62.             if(Point[15-i][j])
    

  63.             {
    

  64.                 LCD_DrawPoint(StartX+i, StartY+j, LCD_Forecolor);
    

  65.             }
    

  66.             else
    

  67.             {
    

  68.                 LCD_DrawPoint(StartX+i, StartY+j, BACKCOLOR);
    

  69.             }
    

  70.         }
    

  71.     }
    

  72. }
    


  73. 

  74. void LCD_ShowLOG(uint16_t StartX, uint16_t StartY, const char *str)
    

  75. {
    

  76.     while(*str != '\0')
    

  77.     {
    

  78.         if(*str < 0x7F)
    

  79.         {
    

  80.             if(StartX > (LCD_WIDTH  - 8))
    

  81.             {
    

  82.                 StartX = 0; StartY += 16;
    

  83.             }
    


  84. 

  85.             if(StartY > (LCD_HEIGHT - 16))
    

  86.             {
    

  87.                 StartX = 0; StartY = 0;
    


  88. 

  89.                 LCD_ClearScreen(BACKCOLOR);
    

  90.             }
    


  91. 

  92.             LCD_ShowEN(StartX, StartY, *str);
    


  93. 

  94.             StartX += 0x08;
    

  95.             str    += 0x01;
    

  96.         }
    

  97.         else
    

  98.         {
    

  99.             if(StartX > (LCD_WIDTH  - 16))
    

  100.             {
    

  101.                 StartX = 0; StartY += 16;
    

  102.             }
    


  103. 

  104.             if(StartY > (LCD_HEIGHT - 16))
    

  105.             {
    

  106.                 StartX = 0; StartY = 0;
    


  107. 

  108.                 LCD_ClearScreen(BACKCOLOR);
    

  109.             }
    


  110. 

  111.             LCD_ShowCN(StartX, StartY,  str);
    


  112. 

  113.             StartX += 0x10;
    

  114.             str    += 0x02;
    

  115.         }
    

  116.     }
    

  117. }
    


  118. 

  119. void LCD_DrawImage(void)
    

  120. {
    

  121.     uint16_t StartX = 0, StartY = 0;
    

  122.     uint16_t Width  = 0, Height = 0, Index = 0;
    

  123.     uint32_t Address = 0, Offset = 0, Length = 0;
    


  124. 

  125.     uint8_t  Buffer[200];
    


  126. 


  127. 

  128.     Address = 0x20204C;
    

  129.     Offset  = 0;
    

  130.     Length  = 0x001A84;
    

  131.     Index   = 8;
    


  132. 

  133.     SPI_FLASH_FastRead(Address + Offset, Buffer, 8);
    


  134. 

  135.     Width    = Buffer[2];
    

  136.     Width  <<= 8;
    

  137.     Width   |= Buffer[3];
    


  138. 

  139.     Height   = Buffer[4];
    

  140.     Height <<= 8;
    

  141.     Height  |= Buffer[5];
    


  142. 

  143.     StartX = (240 - Width ) / 2;
    

  144.     StartY = 30;
    


  145. 

  146.     LCD_SetAddress(StartX, StartY, StartX + Width - 1, StartY + Height - 1);
    


  147. 

  148.     GPIO_Pins_Set(GPIOB, GPIO_PIN_11);
    


  149. 

  150.     do
    

  151.     {
    

  152.         SPI_FLASH_FastRead(Address + Offset + Index, Buffer, sizeof(Buffer));
    


  153. 

  154.         for(uint8_t i = 0; i < sizeof(Buffer); i++)
    

  155.         {
    

  156.             if(Index++ < Length)
    

  157.             {
    

  158.                 LCD_SPI_WriteByte(Buffer[i]);
    

  159.             }
    

  160.         }
    

  161.     }while(Index < Length);
    


  162. 


  163. 

  164.     Address = 0x200000;
    

  165.     Offset  = 0;
    

  166.     Length  = 0x00204C;
    

  167.     Index   = 8;
    


  168. 

  169.     SPI_FLASH_FastRead(Address + Offset, Buffer, 8);
    


  170. 

  171.     Width    = Buffer[2];
    

  172.     Width  <<= 8;
    

  173.     Width   |= Buffer[3];
    


  174. 

  175.     Height   = Buffer[4];
    

  176.     Height <<= 8;
    

  177.     Height  |= Buffer[5];
    


  178. 

  179.     StartX = (240 - Width ) / 2;
    

  180.     StartY = 255;
    


  181. 

  182.     LCD_SetAddress(StartX, StartY, StartX + Width - 1, StartY + Height - 1);
    


  183. 

  184.     GPIO_Pins_Set(GPIOB, GPIO_PIN_11);
    


  185. 

  186.     do
    

  187.     {
    

  188.         SPI_FLASH_FastRead(Address + Offset + Index, Buffer, sizeof(Buffer));
    


  189. 

  190.         for(uint8_t i = 0; i < sizeof(Buffer); i++)
    

  191.         {
    

  192.             if(Index++ < Length)
    

  193.             {
    

  194.                 LCD_SPI_WriteByte(Buffer[i]);
    

  195.             }
    

  196.         }
    

  197.     }while(Index < Length);
    

  198. }


WAV相关部分
复制
  1. uint8_t WAV_DecodeFile(WAV_TypeDef *pWav, uint32_t Address)
    

  2. {
    

  3.     ChunkRIFF_TypeDef *WAV_RIFF;
    

  4.     ChunkFMT_TypeDef  *WAV_FMT ;
    

  5.     ChunkFACT_TypeDef *WAV_FACT;
    

  6.     ChunkDATA_TypeDef *WAV_DATA;
    


  7. 

  8.     uint8_t WAV_HeadBuffer[512];
    


  9. 

  10.     SPI_FLASH_FastRead(Address, WAV_HeadBuffer, 512);
    


  11. 

  12.     /* 获取RIFF块 */
    

  13.     WAV_RIFF = (ChunkRIFF_TypeDef *)WAV_HeadBuffer;
    


  14. 

  15.     /* 是WAV格式文件 */
    

  16.     if(WAV_RIFF->Format == 0x45564157)
    

  17.     {
    

  18.         /* 获取FMT块 */
    

  19.         WAV_FMT  = (ChunkFMT_TypeDef *)(WAV_HeadBuffer+12);
    


  20. 

  21.         /* 读取FACT块 */
    

  22.         WAV_FACT = (ChunkFACT_TypeDef *)(WAV_HeadBuffer+12+8+WAV_FMT->ChunkSize);
    


  23. 

  24.         if((WAV_FACT->ChunkID == 0x74636166) || (WAV_FACT->ChunkID == 0x5453494C))
    

  25.         {
    

  26.             /* 具有FACT/LIST块的时候(未测试) */
    

  27.             pWav->DataStart=12+8+WAV_FMT->ChunkSize+8+WAV_FACT->ChunkSize;
    

  28.         }
    

  29.         else
    

  30.         {
    

  31.             pWav->DataStart=12+8+WAV_FMT->ChunkSize;
    

  32.         }
    


  33. 

  34.         /* 读取DATA块 */
    

  35.         WAV_DATA = (ChunkDATA_TypeDef *)(WAV_HeadBuffer+pWav->DataStart);
    


  36. 

  37.         /* 解析成功 */
    

  38.         if(WAV_DATA->ChunkID == 0x61746164)
    

  39.         {
    

  40.             pWav->AudioFormat   = WAV_FMT->AudioFormat;     /* 音频格式 */
    

  41.             pWav->nChannels     = WAV_FMT->NumOfChannels;   /* 通道数 */
    

  42.             pWav->SampleRate    = WAV_FMT->SampleRate;      /* 采样率 */
    

  43.             pWav->BitRate       = WAV_FMT->ByteRate*8;      /* 得到位速 */
    

  44.             pWav->BlockAlign    = WAV_FMT->BlockAlign;      /* 块对齐 */
    

  45.             pWav->BitsPerSample = WAV_FMT->BitsPerSample;   /* 位数,16/24/32位 */
    


  46. 

  47.             pWav->DataSize      = WAV_DATA->ChunkSize;      /* 数据块大小 */
    

  48.             pWav->DataStart     = pWav->DataStart+8;        /* 数据流开始的地方 */
    


  49. 

  50.             printf("\r\npWav->AudioFormat   : %d", pWav->AudioFormat);
    

  51.             printf("\r\npWav->nChannels     : %d", pWav->nChannels);
    

  52.             printf("\r\npWav->SampleRate    : %d", pWav->SampleRate);
    

  53.             printf("\r\npWav->BitRate       : %d", pWav->BitRate);
    

  54.             printf("\r\npWav->BlockAlign    : %d", pWav->BlockAlign);
    

  55.             printf("\r\npWav->BitsPerSample : %d", pWav->BitsPerSample);
    

  56.             printf("\r\npWav->DataSize      : %d", pWav->DataSize);
    

  57.             printf("\r\npWav->DataStart     : %d", pWav->DataStart);
    


  58. 

  59.             WAV_Offset   = pWav->DataStart + Address;
    

  60.             WAV_DataSize = pWav->DataSize;
    

  61.         }
    

  62.     }
    


  63. 

  64.     return 0;
    

  65. }
    


  66. 

  67. void WAV_PrepareData(void)
    

  68. {
    

  69.     if(WAV_NextIndex == 0)
    

  70.     {
    

  71.         SPI_FLASH_FastRead(WAV_Offset + WAV_TxLength, WAV_DataBuffer[0], WAV_BUFFER_SIZE);
    

  72.     }
    

  73.     else
    

  74.     {
    

  75.         SPI_FLASH_FastRead(WAV_Offset + WAV_TxLength, WAV_DataBuffer[1], WAV_BUFFER_SIZE);
    

  76.     }
    


  77. 

  78.     WAV_TxLength += WAV_BUFFER_SIZE;
    


  79. 

  80.     if(WAV_TxLength > WAV_DataSize) WAV_PlayEnded = 1;
    

  81. }
    


  82. 

  83. void WAV_PlayHandler(void)
    

  84. {
    

  85.     if(WAV_PlayEnded == 0)
    

  86.     {
    

  87.         CS4344_I2S_DMA_Transfer((uint16_t *)&WAV_DataBuffer[WAV_NextIndex][0], (WAV_BUFFER_SIZE / 2));
    

  88.     }
    

  89.     else
    

  90.     {
    

  91.         DMA_Channel_Disable(DMA_CH1);
    


  92. 

  93.         printf("\r\nWAV Play Finish!\r\n");     WAV_PlayState = 0;
    

  94.     }
    


  95. 

  96.     if(WAV_NextIndex == 0) WAV_NextIndex = 1;
    

  97.     else                   WAV_NextIndex = 0;
    

  98. }
    


  99. 

  100. void WAV_PlaySong(void)
    

  101. {
    

  102.     WAV_TypeDef WaveFile;
    


  103. 

  104.     if(WAV_PlayState == 0)
    

  105.     {
    

  106.         if(WAV_DecodeFile(&WaveFile, 0x100000) == 0)
    

  107.         {
    

  108.             if((WaveFile.BitsPerSample == 16) && (WaveFile.nChannels == 2) &&
    

  109.                (WaveFile.SampleRate  > 44000) && (WaveFile.SampleRate < 48100))
    

  110.             {
    

  111.                 WAV_NextIndex = 0;
    

  112.                 WAV_PlayEnded = 0;
    

  113.                 WAV_TxLength  = 0;
    

  114.                 WAV_PlayState = 1;
    


  115. 

  116.                 printf("\r\n");
    

  117.                 printf("\r\nWAV Data Size : %d, Data Start : 0x%08x", WAV_DataSize, WAV_Offset);
    

  118.                 printf("\r\n");
    


  119. 

  120.                 WAV_PrepareData();
    

  121.                 WAV_PlayHandler();
    

  122.             }
    

  123.             else
    

  124.             {
    

  125.                 printf("\r\nWAV File Format Error!\r\n"); return;
    

  126.             }
    

  127.         }
    

  128.         else
    

  129.         {
    

  130.             printf("\r\nNo WAV File!\r\n"); return;
    

  131.         }
    

  132.     }
    

  133.     else
    

  134.     {
    

  135.         printf("\r\nThe Song Is Not Over Yet!\r\n");
    

  136.     }
    

  137. }


KEY相关部分
复制
  1. void KEY_Init(void)
    

  2. {
    

  3.     GPIO_InitType GPIO_InitStructure;
    


  4. 

  5.     RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOA);
    


  6. 

  7.     GPIO_Structure_Initialize(&GPIO_InitStructure);
    

  8.     GPIO_InitStructure.Pin       = GPIO_PIN_0;
    

  9.     GPIO_InitStructure.GPIO_Mode = GPIO_MODE_INPUT;
    

  10.     GPIO_InitStructure.GPIO_Pull = GPIO_NO_PULL;
    

  11.     GPIO_Peripheral_Initialize(GPIOA, &GPIO_InitStructure);
    


  12. 

  13.     GPIO_Structure_Initialize(&GPIO_InitStructure);
    

  14.     GPIO_InitStructure.Pin       = GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6;
    

  15.     GPIO_InitStructure.GPIO_Mode = GPIO_MODE_INPUT;
    

  16.     GPIO_InitStructure.GPIO_Pull = GPIO_PULL_UP;
    

  17.     GPIO_Peripheral_Initialize(GPIOA, &GPIO_InitStructure);
    


  18. 

  19.     TASK_Append(TASK_ID_KEY, KEY_Scan, 10);
    

  20. }
    


  21. 

  22. void KEY_Handler(char *Name, uint8_t State, uint8_t Value)
    

  23. {
    

  24.     if(strcmp(Name, "WAKEUP") == 0)
    

  25.     {
    

  26.         if(State == 0)
    

  27.         {
    

  28.             CAMERA_TakePhoto();
    


  29. 

  30.             for(uint16_t i = 1; i <= CAMERA_PacketTotal; i++)
    

  31.             {
    

  32.                 CAMERA_GetPacket(i);
    

  33.             }
    


  34. 

  35.             CAMERA_DrawImage();
    


  36. 

  37. #if ENABLE_WAV
    

  38.             WAV_PlaySong();
    

  39. #endif
    

  40.         }
    

  41.     }
    


  42. 

  43.     if(strcmp(Name, "KEY3") == 0)
    

  44.     {
    

  45.         if(State == 1)
    

  46.         {
    

  47.             LCD_SetForecolor(FORECOLOR);
    

  48.             LCD_ShowLOG(76, 230, "正在开门...");
    

  49.         }
    

  50.         else
    

  51.         {
    

  52.             LCD_SetForecolor(FORECOLOR);
    

  53.             LCD_ShowLOG(76, 230, "           ");
    

  54.         }
    

  55.     }
    

  56. }
    


  57. 

  58. void KEY_SubScan(uint8_t *State, uint8_t *Count, uint8_t Value, uint8_t Active, char *Name)
    

  59. {
    

  60.     if(*State == 0)
    

  61.     {
    

  62.         if(Value == Active) *Count += 1;
    

  63.         else                *Count  = 0;
    


  64. 

  65.         if(*Count > 5)
    

  66.         {
    

  67.             *Count = 0; *State = 1;
    

  68.             printf("\r\n%s Pressed", Name); KEY_Handler(Name, 1, false);
    

  69.         }
    

  70.     }
    

  71.     else
    

  72.     {
    

  73.         if(Value != Active) *Count += 1;
    

  74.         else                *Count  = 0;
    


  75. 

  76.         if(*Count > 5)
    

  77.         {
    

  78.             *Count = 0; *State = 0;
    

  79.             printf("\r\n%s Release", Name); KEY_Handler(Name, 0, true);
    

  80.         }
    

  81.     }
    

  82. }
    


  83. 

  84. void KEY_Scan(void)
    

  85. {
    

  86.     static uint8_t KeyState[4] = {0, 0, 0, 0};
    

  87.     static uint8_t KeyCount[4] = {0, 0, 0, 0};
    


  88. 

  89.     KEY_SubScan(&KeyState[0], &KeyCount[0], GPIO_Input_Pin_Data_Get(GPIOA, GPIO_PIN_0), PIN_SET,   "WAKEUP");
    

  90.     KEY_SubScan(&KeyState[1], &KeyCount[1], GPIO_Input_Pin_Data_Get(GPIOA, GPIO_PIN_4), PIN_RESET, "KEY1");
    

  91.     KEY_SubScan(&KeyState[2], &KeyCount[2], GPIO_Input_Pin_Data_Get(GPIOA, GPIO_PIN_5), PIN_RESET, "KEY2");
    

  92.     KEY_SubScan(&KeyState[3], &KeyCount[3], GPIO_Input_Pin_Data_Get(GPIOA, GPIO_PIN_6), PIN_RESET, "KEY3");
    

  93. }


运行效果 & 演示视频
https://www.bilibili.com/video/BV1XG4y1i7wr?vd_source=c2d3413b74687345dfc8205a8d735598
待机显示界面.jpg


附件
软件工程源代码： VideoDoorPhone_20220724.zip (473.49 KB, 下载次数: 53)
功能扩展板原理图： Schematic_N32G430C8L7-STB_EBK_CAMERA_2022-07-25.pdf (92.98 KB, 下载次数: 19)


其它
在调试SPI接口时，MCU资源只配备了2路SPI，其中一路我们需要当I2S使用，那剩下的那一路就需要驱动SPI FLASH和SPI接口的TFT显示屏，这样就需要不同的CS引脚来控制；我们将CS引脚配置为硬件控制和软件控制方式的时候，代码实现是不同的，在软件控制时需要特别注意，具体参考如下代码：
复制
  1. void LCD_InitSPI2(void)
    

  2. {
    

  3.     GPIO_InitType GPIO_InitStructure;
    

  4.     SPI_InitType  SPI_InitStructure;
    


  5. 

  6.     RCC_APB2_Peripheral_Clock_Enable(RCC_APB2_PERIPH_SPI2);
    

  7.     RCC_AHB_Peripheral_Clock_Enable( RCC_AHB_PERIPH_GPIOB);
    


  8. 

  9. #if 1
    

  10.     GPIO_Structure_Initialize(&GPIO_InitStructure);
    

  11.     GPIO_InitStructure.Pin       = GPIO_PIN_12;
    

  12.     GPIO_InitStructure.GPIO_Mode = GPIO_MODE_OUT_PP;
    

  13.     GPIO_Peripheral_Initialize(GPIOB, &GPIO_InitStructure);
    


  14. 

  15.     GPIO_Structure_Initialize(&GPIO_InitStructure);
    

  16.     GPIO_InitStructure.Pin            = GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15;
    

  17.     GPIO_InitStructure.GPIO_Mode      = GPIO_MODE_AF_PP;
    

  18.     GPIO_InitStructure.GPIO_Alternate = GPIO_AF1_SPI2;
    

  19.     GPIO_Peripheral_Initialize(GPIOB, &GPIO_InitStructure);
    

  20. #else
    

  21.     GPIO_Structure_Initialize(&GPIO_InitStructure);
    

  22.     GPIO_InitStructure.Pin            = GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15;
    

  23.     GPIO_InitStructure.GPIO_Mode      = GPIO_MODE_AF_PP;
    

  24.     GPIO_InitStructure.GPIO_Alternate = GPIO_AF1_SPI2;
    

  25.     GPIO_Peripheral_Initialize(GPIOB, &GPIO_InitStructure);
    

  26. #endif
    


  27. 

  28.     SPI_I2S_Reset(SPI2);
    


  29. 

  30.     SPI_Initializes_Structure(&SPI_InitStructure);
    

  31.     SPI_InitStructure.DataDirection  = SPI_DIR_DOUBLELINE_FULLDUPLEX;
    

  32.     SPI_InitStructure.SpiMode        = SPI_MODE_MASTER;
    

  33.     SPI_InitStructure.DataLen        = SPI_DATA_SIZE_8BITS;
    

  34.     SPI_InitStructure.CLKPOL         = SPI_CLKPOL_LOW;
    

  35.     SPI_InitStructure.CLKPHA         = SPI_CLKPHA_FIRST_EDGE;
    

  36.     SPI_InitStructure.NSS            = SPI_NSS_SOFT;
    

  37.     SPI_InitStructure.BaudRatePres   = SPI_BR_PRESCALER_8;
    

  38.     SPI_InitStructure.FirstBit       = SPI_FB_MSB;
    

  39.     SPI_InitStructure.CRCPoly        = 7;
    

  40.     SPI_Initializes(SPI2, &SPI_InitStructure);
    


  41. 

  42. #if 1
    

  43.     SPI_NSS_Config(SPI2, SPI_NSS_SOFT);
    

  44.     SPI_Set_Nss_Level(SPI2, SPI_NSS_HIGH);
    

  45. #else
    

  46.     SPI_NSS_Config(SPI2, SPI_NSS_HARD);
    

  47.     SPI_SS_Output_Enable(SPI2);
    

  48. #endif
    


  49. 

  50.     SPI_ON(SPI2);
    

  51. }

另外就是在实现I2S功能时，也特别感谢国民技术和王工的支持！！！

回复

收藏2 举报

相关帖子
maqianqu 发表于 2022-8-16 22:14 | 显示全部楼层
这个没有功能代码吗   
回复

收藏2 举报

 楼主| xld0932 发表于 2022-8-17 08:54 | 显示全部楼层
maqianqu 发表于 2022-8-16 22:14
这个没有功能代码吗

不是有上传附件嘛……完整的软件工程代码呀，怎么说没有呢？
回复

收藏2 举报

 楼主| xld0932 发表于 2022-8-24 15:12 | 显示全部楼层
回复

收藏2 举报

uptown 发表于 2022-9-3 17:23 | 显示全部楼层
可以实现图片的传输吗
回复

收藏2 举报

adolphcocker 发表于 2022-9-3 20:33 | 显示全部楼层
这个看着比较高端了。   
回复

收藏2 举报

timfordlare 发表于 2022-9-3 20:52 | 显示全部楼层
语音的传输使用压缩算法了吗   
回复

收藏2 举报

 楼主| xld0932 发表于 2022-9-4 20:14 | 显示全部楼层
timfordlare 发表于 2022-9-3 20:52
语音的传输使用压缩算法了吗

语音是通过I2S接口实现的，音频文件（WAV文件）存放在SPI FLASH中，通过MCU的SPI接口读取SPI FLASH中的音频数据进行软件解码，然后通过I2S接口传输音频数据，进行播放的……
回复

收藏2 举报

janewood 发表于 2022-12-5 21:16 | 显示全部楼层
这个图像是怎么传输呢？              
回复

收藏2 举报

claretttt 发表于 2022-12-5 21:56 | 显示全部楼层
楼主做的这个可视化门铃确实很棒。
回复

收藏2 举报

alvpeg 发表于 2022-12-6 12:50 | 显示全部楼层
使用的是什么音频模块？              
回复

收藏2 举报

wwppd 发表于 2022-12-6 15:41 | 显示全部楼层
能不能实现远程wifi通信呢              
回复

收藏2 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

xld0932 Image
个人签名：King.Xu

77

主题

3023

帖子

38

粉丝
快速回复 在线客服 返回列表 返回顶部