devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

stm32与openmv的相互发送与接收（基于标准库）_openmv与stm32连接

作者：Cpp五条 | 2024-06-12 10:02:19

赞

踩

openmv与stm32连接

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

        前段时间参加电赛校赛的时候题目是做21年f题智能送药小车，在openmv与stm32通信中遇到了些困难，通过看一些大佬们的文章与例程，我总结出了一套实用性不错的通信协议代码，一方面是对自己的知识进行总结，另一方面也可以将其提供给有需要的同学，如有理解错误，欢迎大佬们的指正。

提示：以下是本篇文章正文内容，下面案例可供参考

一、硬件连接

我所用到的材料如下: 四针IIC OLED，OpenMV4 7h(OV7725)，STM32F103C8T6最小系统板，数据线N条，LED灯模块(OpenMV的数据线只能用官方自带的)，杜邦线若干。

下图以Arduino为例把主控TXD与openmv的P5连接，RXD与openmv的P4连接，在STM32端：USART_TX—PA9 -----USART_RX—PA10。（用的是32的USART1）

四针IIC OLED连接：

SDA--PB9，SCL--PB8；GND，VCC（3.3V）正常接入就好；

 

二、数据包传输

这里采用的数据包传输方式是固定包长，含包头包尾方式（即为第一种），帧头帧尾不固定，可自定义，图示帧头帧尾分别为0xfe与0xef；代码呈现的分别是0xb3，0xb5，下图为图解原理：

三、openmv发送stm32端接收

1.openmv端（发送函数）

这里是根据当时做送药小车的模板匹配所用的主要发送程序，完整程序会在文末呈现。

代码如下（示例）：

  1.  
  2. #最初加载匹配
  3. def FirstFindTemplate(template):
  4.     R = img.find_template(template, 0.8, step=1, roi=(40, 0, 70, 40), search=SEARCH_EX)   #只检测中间的
  5.     return R
  6.  
  7. def FirstFindedNum(R, Finded_Num):     #第一个参数是模板匹配的对象，第二个是它所代表的数字
  8.    global Find_Task
  9.    global find_flag
  10.    img.draw_rectangle(R, color=(225, 0, 0))
  11.  
  12.    LoR = 0
  13.    find_flag = 1
  14.    Num = Finded_Num
  15.    FH = bytearray([0xb3,0xb3,Num, LoR,Find_Task,0x5b])
  16.    uart.write(FH)
  17.    print("目标病房号：", Num)
  18.  
  19.  
  20.  
  21.

 这里的FirstFindTemplate(template)函数是用于识别，识别成功后返回R值，主函数在调用FirstFindedNum(R, Finded_Num)时会将R值传输进去，识别到之后进行框选，然后bytearray([, , ,])组合uart.write()将打包好的参数进行发送。

2.stm32端（接收函数）

代码如下（示例）：这里先省略初始化以及变量定义的程序，文末补全

串口中断服务函数：

  1. void USART1_IRQHandler(void)                	//串口1中断服务程序
  2. 	{
  3. 	u8 com_data;
  4. #if SYSTEM_SUPPORT_OS 		//如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
  5. 	OSIntEnter();    
  6. #endif
  7. 	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
  8. 		{
  9. 			USART_ClearFlag(USART1,USART_FLAG_RXNE);
  10.       com_data = USART1->DR;
  11. 			Openmv_Receive_Data(com_data);     //openmv数据处理函数
  12. 			Openmv_Data();		                 //openmv数据处理函数		
  13.  		
  14.      } 
  15. #if SYSTEM_SUPPORT_OS 	//如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
  16. 	OSIntExit();  											 
  17. #endif
  18. }

 常规串口中断程序，串口接收到数据后查询标志位，查询完成后清除并开始将数据读取处理。

数据读取函数：

  1. void Openmv_Receive_Data(int16_t data)//接收Openmv传过来的数据
  2. {
  3. 	static u8 state = 0;
  4. 	if(state==0&&data==0xb3)//第一个帧头
  5. 	{
  6. 		state=1;
  7. 		openmv[0]=data;
  8. 	}
  9. 	else if(state==1&&data==0xb3)//第二个帧头
  10. 	{
  11. 		state=2;
  12. 		openmv[1]=data;
  13. 	}
  14. 	else if(state==2)//第一个有效数据
  15. 	{
  16. 		state=3;
  17. 		openmv[2]=data;
  18. 	}
  19. 	else if(state==3)//第二个有效数据
  20. 	{
  21. 		state = 4;
  22. 		openmv[3]=data;
  23. 	}
  24.   else if(state==4)//第三个有效数据
  25. 	{
  26. 		state = 5;
  27. 		openmv[4]=data;
  28. 	} 
  29. 	else if(state==5)		//检测是否接受到结束标志，检测接收帧尾
  30. 	{
  31.         if(data == 0x5B)
  32.         {
  33.             state = 0;
  34.             openmv[5]=data;
  35.             Openmv_Data();
  36.         }
  37.         else if(data != 0x5B)
  38.         {
  39.             state = 0;
  40.             for(i=0;i<6;i++)
  41.             {
  42.                 openmv[i]=0x00;
  43.             }           
  44.         }
  45. 	}    
  46. 	else
  47. 		{
  48. 			state = 0;
  49.             for(i=0;i<6;i++)
  50.             {
  51.                 openmv[i]=0x00;
  52.             }
  53. 		}
  54. }

 先解析帧头（我这里用了两个帧头，一个也可以，但是与openmv那边一定要相同），再解析有效数据，有效数据接受完传递到openmv[i]数据缓存区后调用Openmv_Data()对数据进行处理，最后解析帧尾。

数据处理函数：

  1. void Openmv_Data(void)//处理Openmv接收的数据
  2. {
  3.     TargerNum=openmv[2];
  4.     LoR=openmv[3];
  5. 	Find_Task =openmv[4];
  6. }

 这里被调用是为了将openmv端的数据传递给变量进行储存，方便在main函数对变量进行打印。

 main函数oled屏幕显示调用：

  1. extern int16_t TargerNum;          
  2. extern int16_t Find_Task;          
  3. extern int16_t LoR;
  4.  
  5.  
  6. int main(void)
  7. {
  8.  
  9. 	Usart1_Init(115200);	
  10. 	OLED_Init();
  11. 	OLED_ShowString(1,1,"TargerNum:");
  12. 	OLED_ShowString(2,1,"LoR:");
  13. 	OLED_ShowString(3,1,"Find_Task: ");
  14.  
  15.  
  16. 	while (1)
  17. 	{
  18. 		OLED_ShowNum(1,11,TargerNum,2);
  19. 		OLED_ShowNum(2,5,LoR,2);
  20. 		OLED_ShowNum(3,11,Find_Task,2);
  21.         
  22.     }
  23. }

3.实物调试

程序实现效果，当openmv识别到数字后，会通过调用串口发送函数将数据包发送到stm32主控，如图示：

 此时已识别数字1并框选

oled这边也接收到了数字TargetNum为1，Find_Task为1，LoR暂时未用不需要理会。

注：数据是以16进制发送过来，但是这里oled是以10进制的形式打印，因为只是1-8数字，所以不会太大影响。

 

四、stm32发送openmv端接收

1.stm32端（发送函数） 

这里数据位逐位发送，与openmv接收端解析函数相匹配。

代码如下（示例）：

  1. void Usart1_Sendata(u8 * str)
  2. {	
  3. 	u8 i = 0;
  4. 	USART_SendData(USART1,0x0d);
  5. 	while( USART_GetFlagStatus(USART1,USART_FLAG_TC)!= SET);
  6. 	
  7. 	for(i = 0;i < 2;i++)
  8. 	{
  9. 		USART_SendData(USART1,str[i]);
  10. 		while( USART_GetFlagStatus(USART1,USART_FLAG_TC)!= SET);
  11. 	}
  12.  
  13. 	USART_SendData(USART1,0x5b);
  14. 	while( USART_GetFlagStatus(USART1,USART_FLAG_TC)!= SET);
  15. }
  16.  
  17.  
  18. int main(void)
  19. {
  20. 	NVIC_Config();
  21. 	Usart1_Init(115200);	
  22. 	Find_Task=1;
  23. 	TargerNum=3;
  24. 	u8 send_buff[2] = {TargerNum,Find_Task};
  25.  
  26. 	while (1)
  27. 	{
  28. 		Usart1_Sendata(send_buff);      
  29.     }
  30. }
  31.  
  32.

 首先解析第一位数据是否为帧头，同时判断发送标志位是否已经检测到，完成后进行有效数据位发送，这里用for循环，使用库函数USART_SendData(USART1,str[i])，将数据发送出去，同时检测标志位，完成后发送帧尾。

而主函数部分是数组内数据进行反复发送。

2.openmv端（接收函数）

这里对stm32那边的数据包进行解析实际上同上方的原理大同小异，这里的数据长度可以自行更改，但是需要发送端和接收端的接收和发送函数相匹配，包括数据缓存区长度也要符合。

代码如下（示例）：

  1. ########串口接收数据函数处理#########
  2. def Receive_Prepare():      #data
  3.     global state
  4.     global x
  5.     global tx_flag
  6.     global data
  7.     global Find_Task
  8.     global Target_Num
  9.     if state==0:
  10.         data[0]=uart.readchar()
  11.         if data[0] == 0x0d:#帧头
  12.             state = 1
  13.         else:
  14.             state = 0
  15.             rx_buff.clear()
  16.     elif state==1:
  17.         data[1]=uart.readchar()
  18.         #rx_buff.append(data)
  19.         Target_Num=data[x+1]
  20.         state = 2
  21.     elif state==2:
  22.         data[2]=uart.readchar()
  23.         #rx_buff.append(data)
  24.         Find_Task=data[x+2]
  25.         state = 3
  26.     elif state == 3:
  27.         data[4]=uart.readchar()
  28.         if data[4] == 0x5b:
  29.             tx_flag = int(data[0])
  30.             state = 4
  31.     elif state == 4:
  32.         state=0
  33.  
  34.     else:
  35.         state = 0
  36.         rx_buff.clear()
  37.  
  38.  
  39.

3.openmv主函数调用

  1. while (True):
  2.     clock.tick()
  3.     img = sensor.snapshot()# 镜头初始化
  4.         if(uart.any()>0):
  5.            Receive_Prepare()
  6.     print(clock.fps(),Find_Task, Target_Num)

这里的if(uart.any()>0):是检测是否有数据传输进来，有的话就执行。

调用接收函数Receive_Prepare()，把Find_Task, Target_Num在串行终端中打印出来。

4.openmv调试展示

这里我们用ide自带的串行终端进行观察调试结果

可以看到，此时的openmv端接收到数字Find_Task为1，TargetNum为3，LoR暂时未用不需要理会。

注：这里接收/发送有点小问题，如果不断的接收打印，数据会变成13，1，通信时请注意；可能通信协议有点小毛病，希望大佬们可以指正。

 

五、完整代码1（openmv发送stm32端接收）

（如果上面看的一头雾水可以试试看完全部程序，也方便梳理）

1.openmv发送

  1. import time, image,sensor,math,pyb,ustruct
  2. from image import SEARCH_EX, SEARCH_DS
  3. from pyb import Pin, Timer,LED
  4.  
  5. #从imgae模块引入SEARCH_EX和SEARCH_DS。使用from import仅仅引入SEARCH_EX,
  6. #SEARCH_DS两个需要的部分，而不把image模块全部引入。
  7.  
  8.  
  9. sensor.reset()
  10.  
  11. # Set sensor settings
  12. sensor.set_contrast(1)
  13. sensor.set_gainceiling(16)
  14. # Max resolution for template matching with SEARCH_EX is QQVGA
  15. sensor.set_framesize(sensor.QQVGA)
  16. # You can set windowing to reduce the search image.
  17.  
  18. sensor.set_pixformat(sensor.GRAYSCALE)
  19.  
  20. sensor.set_windowing(0, 40, 160, 40)  #观察窗口  后面ROI设置也会以这个为新的基准
  21.  
  22. rx_buff=[]
  23. state = 0
  24. tx_flag = 0
  25.  
  26. # Load template.
  27. # Template should be a small (eg. 32x32 pixels) grayscale image.
  28. #加载模板图片
  29.  
  30. template01 = image.Image("/1.pgm")
  31. template02 = image.Image("/2.pgm")
  32. template03 = image.Image("/3.pgm")
  33. template04 = image.Image("/4.pgm")
  34. template05 = image.Image("/5.pgm")
  35. template06 = image.Image("/6.pgm")
  36. template07 = image.Image("/7.pgm")
  37. template08 = image.Image("/8.pgm")
  38.  
  39.  
  40.  
  41. uart = pyb.UART(3, 115200, timeout_char = 1000)     #定义串口1变量
  42. blue_led = LED(2)
  43.  
  44. Find_Task =1       #1
  45. Target_Num =0
  46.  
  47.  
  48. #####  FindTask == 1 时使用
  49. #最初加载匹配
  50. def FirstFindTemplate(template):
  51.     R = img.find_template(template, 0.8, step=1, roi=(40, 0, 70, 40), search=SEARCH_EX)   #只检测中间的
  52.     return R
  53.  
  54. def FirstFindedNum(R, Finded_Num):     #第一个参数是模板匹配的对象，第二个是它所代表的数字
  55.    global Find_Task
  56.    global find_flag
  57.    img.draw_rectangle(R, color=(225, 0, 0))
  58.  
  59.    #本来中值是80的，但返回值是框边缘，所以减去15就好  小于65是在左边，大于65是在右边
  60.    LoR = 0
  61.    find_flag = 1
  62.    Num = Finded_Num
  63.    FH = bytearray([0xb3,0xb3,Num, LoR,Find_Task,0x5b])
  64.    uart.write(FH)
  65.    print("目标病房号：", Num)
  66.  
  67.  
  68.  
  69.  
  70. clock = time.clock()
  71. # Run template matching
  72. while (True):
  73.     clock.tick()
  74.     img = sensor.snapshot()# 镜头初始化
  75.  
  76.     # find_template(template, threshold, [roi, step, search])
  77.     # ROI: The region of interest tuple (x, y, w, h).
  78.     # Step: The loop step used (y+=step, x+=step) use a bigger step to make it faster.
  79.     # Search is either image.SEARCH_EX for exhaustive search or image.SEARCH_DS for diamond search
  80.     #
  81.     # Note1: ROI has to be smaller than the image and bigger than the template.
  82.     # Note2: In diamond search, step and ROI are both ignored.
  83.  
  84.     if Find_Task == 1:
  85.  
  86.        #进行模板匹配
  87.         r01 = FirstFindTemplate(template01)
  88.         r02 = FirstFindTemplate(template02)
  89.         r03 = FirstFindTemplate(template03)
  90.         r04 = FirstFindTemplate(template04)
  91.         r05 = FirstFindTemplate(template05)
  92.         r06 = FirstFindTemplate(template06)
  93.         r07 = FirstFindTemplate(template07)
  94.         r08 = FirstFindTemplate(template08)
  95.  
  96.         #判断哪个模板匹配成功，并将成功匹配的相应数据发送给主控
  97.         if r01:
  98.              FirstFindedNum(r01, 1)
  99.         elif r02:
  100.              FirstFindedNum(r02,2)
  101.         elif r03:
  102.              FirstFindedNum(r03,3)
  103.         elif r04:
  104.              FirstFindedNum(r04,4)
  105.         elif r05:
  106.              FirstFindedNum(r05,5)
  107.         elif r06:
  108.              FirstFindedNum(r06,6)
  109.         elif r07:
  110.              FirstFindedNum(r07,7)
  111.         elif r08:
  112.              FirstFindedNum(r08,8)
  113.         else:
  114.              FH = bytearray([0x2C,0x12,0x00, 0x00, 0x00, 0x00,0x5B])
  115.              uart.write(FH)
  116.  
  117.  
  118.     else: time.sleep_ms(100)
  119.  
  120.     print(clock.fps(),Find_Task, Target_Num)
  121.  
  122.

多出来的数据位不需要那么多的话可以选择对代码进行删减，或者直接当成0x00发送，不会有太大影响。

2.stm32端接收

usart1.c

  1. #include "usart1.h"
  2.  
  3. //char TargerNum='0';
  4. int openmv[6];//stm32接收数据数组
  5. int16_t TargerNum;          
  6. int16_t Find_Task;          
  7. int16_t LoR;
  8. int i;
  9. /**
  10.  * 函数名：Usart1_Init
  11.  * 描述：串口1初始化
  12.  * 输入：Bound-波特率
  13.  * 输出：无
  14.  */
  15.  
  16.  
  17. void Usart1_Init(uint32_t Bound)
  18. {
  19. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
  20. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
  21. 	GPIO_InitTypeDef GPIO_InitStructure;
  22. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  23. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  24. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  25. 	GPIO_Init(GPIOA,&GPIO_InitStructure);
  26. 	
  27. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  28. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  29. 	GPIO_Init(GPIOA,&GPIO_InitStructure);
  30.  
  31. 	
  32. 	USART_InitTypeDef USART_InitStructure;
  33. 	USART_InitStructure.USART_BaudRate = Bound;
  34. 	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  35. 	USART_InitStructure.USART_StopBits = USART_StopBits_1;
  36. 	USART_InitStructure.USART_Parity = USART_Parity_No;
  37. 	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  38. 	USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
  39. 	USART_Init(USART1,&USART_InitStructure);
  40. 	
  41. 	NVIC_InitTypeDef NVIC_InitStructure;
  42. 	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
  43. 	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  44. 	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  45. 	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  46. 	NVIC_Init(&NVIC_InitStructure);
  47. 	
  48. 	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
  49. 	USART_Cmd(USART1,ENABLE);
  50. }
  51.  
  52. void Openmv_Data(void)//处理Openmv接收的数据
  53. {
  54.     TargerNum=openmv[2];
  55.     LoR=openmv[3];
  56. 	Find_Task =openmv[4];
  57. }
  58.  
  59. void Openmv_Receive_Data(int16_t data)//接收Openmv传过来的数据
  60. {
  61. 	static u8 state = 0;
  62. 	if(state==0&&data==0xb3)//第一个帧头
  63. 	{
  64. 		state=1;
  65. 		openmv[0]=data;
  66. 	}
  67. 	else if(state==1&&data==0xb3)//第二个帧头
  68. 	{
  69. 		state=2;
  70. 		openmv[1]=data;
  71. 	}
  72. 	else if(state==2)//第一个有效数据
  73. 	{
  74. 		state=3;
  75. 		openmv[2]=data;
  76. 	}
  77. 	else if(state==3)//第二个有效数据
  78. 	{
  79. 		state = 4;
  80. 		openmv[3]=data;
  81. 	}
  82.   else if(state==4)//第三个有效数据
  83. 	{
  84. 		state = 5;
  85. 		openmv[4]=data;
  86. 	} 
  87. 	else if(state==5)		//检测是否接受到结束标志，检测接收帧尾
  88. 	{
  89.         if(data == 0x5B)
  90.         {
  91.             state = 0;
  92.             openmv[5]=data;
  93.             Openmv_Data();
  94.         }
  95.         else if(data != 0x5B)
  96.         {
  97.             state = 0;
  98.             for(i=0;i<6;i++)
  99.             {
  100.                 openmv[i]=0x00;
  101.             }           
  102.         }
  103. 	}    
  104. 	else
  105. 		{
  106. 			state = 0;
  107.             for(i=0;i<6;i++)
  108.             {
  109.                 openmv[i]=0x00;
  110.             }
  111. 		}
  112. }
  113.  
  114.  
  115. void USART_SendByte(USART_TypeDef* USARTx, char  str)
  116. {
  117.  
  118. 		USART_SendData(USARTx, str);//发送单个字符
  119.  
  120. 		while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);//判断是否发送完成
  121.  
  122. 	
  123.  
  124. }
  125.  
  126.  
  127.  
  128. void USART1_IRQHandler(void)                	//串口1中断服务程序
  129. 	{
  130. 	u8 com_data;
  131. #if SYSTEM_SUPPORT_OS 		//如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
  132. 	OSIntEnter();    
  133. #endif
  134. 	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
  135. 		{
  136. 			USART_ClearFlag(USART1,USART_FLAG_RXNE);
  137.       com_data = USART1->DR;
  138. 			Openmv_Receive_Data(com_data);     //openmv数据处理函数
  139. 			Openmv_Data();		                 //openmv数据处理函数		
  140.  		
  141.      } 
  142. #if SYSTEM_SUPPORT_OS 	//如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
  143. 	OSIntExit();  											 
  144. #endif
  145. } 
  146.

 usart1.h

  1. #ifndef __USART1_H
  2. #define __USART1_H
  3. #include "stm32f10x.h"                  // Device header
  4. #include "sys.h"
  5.  
  6.  
  7.  
  8. void Usart1_Init(uint32_t Bound);
  9.  
  10.  
  11. #endif
  12.  
  13.

oled.c

  1. #include "stm32f10x.h"
  2. #include "OLED_Font.h"
  3. #include "stdio.h"
  4.  
  5. /*引脚配置*/
  6. #define OLED_W_SCL(x)		GPIO_WriteBit(GPIOB, GPIO_Pin_8, (BitAction)(x))
  7. #define OLED_W_SDA(x)		GPIO_WriteBit(GPIOB, GPIO_Pin_9, (BitAction)(x))
  8.  
  9. /*引脚初始化*/
  10. void OLED_I2C_Init(void)
  11. {
  12.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
  13. 	
  14. 	GPIO_InitTypeDef GPIO_InitStructure;
  15.  	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
  16. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  17. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
  18.  	GPIO_Init(GPIOB, &GPIO_InitStructure);
  19. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  20.  	GPIO_Init(GPIOB, &GPIO_InitStructure);
  21. 	
  22. 	OLED_W_SCL(1);
  23. 	OLED_W_SDA(1);
  24. }
  25.  
  26. /**
  27.   * @brief  I2C开始
  28.   * @param  无
  29.   * @retval 无
  30.   */
  31. void OLED_I2C_Start(void)
  32. {
  33. 	OLED_W_SDA(1);
  34. 	OLED_W_SCL(1);
  35. 	OLED_W_SDA(0);
  36. 	OLED_W_SCL(0);
  37. }
  38.  
  39. /**
  40.   * @brief  I2C停止
  41.   * @param  无
  42.   * @retval 无
  43.   */
  44. void OLED_I2C_Stop(void)
  45. {
  46. 	OLED_W_SDA(0);
  47. 	OLED_W_SCL(1);
  48. 	OLED_W_SDA(1);
  49. }
  50.  
  51. /**
  52.   * @brief  I2C发送一个字节
  53.   * @param  Byte 要发送的一个字节
  54.   * @retval 无
  55.   */
  56. void OLED_I2C_SendByte(uint8_t Byte)
  57. {
  58. 	uint8_t i;
  59. 	for (i = 0; i < 8; i++)
  60. 	{
  61. 		OLED_W_SDA(Byte & (0x80 >> i));
  62. 		OLED_W_SCL(1);
  63. 		OLED_W_SCL(0);
  64. 	}
  65. 	OLED_W_SCL(1);	//额外的一个时钟，不处理应答信号
  66. 	OLED_W_SCL(0);
  67. }
  68.  
  69. /**
  70.   * @brief  OLED写命令
  71.   * @param  Command 要写入的命令
  72.   * @retval 无
  73.   */
  74. void OLED_WriteCommand(uint8_t Command)
  75. {
  76. 	OLED_I2C_Start();
  77. 	OLED_I2C_SendByte(0x78);		//从机地址
  78. 	OLED_I2C_SendByte(0x00);		//写命令
  79. 	OLED_I2C_SendByte(Command); 
  80. 	OLED_I2C_Stop();
  81. }
  82.  
  83. /**
  84.   * @brief  OLED写数据
  85.   * @param  Data 要写入的数据
  86.   * @retval 无
  87.   */
  88. void OLED_WriteData(uint8_t Data)
  89. {
  90. 	OLED_I2C_Start();
  91. 	OLED_I2C_SendByte(0x78);		//从机地址
  92. 	OLED_I2C_SendByte(0x40);		//写数据
  93. 	OLED_I2C_SendByte(Data);
  94. 	OLED_I2C_Stop();
  95. }
  96.  
  97. /**
  98.   * @brief  OLED设置光标位置
  99.   * @param  Y 以左上角为原点，向下方向的坐标，范围：0~7
  100.   * @param  X 以左上角为原点，向右方向的坐标，范围：0~127
  101.   * @retval 无
  102.   */
  103. void OLED_SetCursor(uint8_t Y, uint8_t X)
  104. {
  105. 	OLED_WriteCommand(0xB0 | Y);					//设置Y位置
  106. 	OLED_WriteCommand(0x10 | ((X & 0xF0) >> 4));	//设置X位置高4位
  107. 	OLED_WriteCommand(0x00 | (X & 0x0F));			//设置X位置低4位
  108. }
  109.  
  110. /**
  111.   * @brief  OLED清屏
  112.   * @param  无
  113.   * @retval 无
  114.   */
  115. void OLED_Clear(void)
  116. {  
  117. 	uint8_t i, j;
  118. 	for (j = 0; j < 8; j++)
  119. 	{
  120. 		OLED_SetCursor(j, 0);
  121. 		for(i = 0; i < 128; i++)
  122. 		{
  123. 			OLED_WriteData(0x00);
  124. 		}
  125. 	}
  126. }
  127.  
  128. /**
  129.   * @brief  OLED显示一个字符
  130.   * @param  Line 行位置，范围：1~4
  131.   * @param  Column 列位置，范围：1~16
  132.   * @param  Char 要显示的一个字符，范围：ASCII可见字符
  133.   * @retval 无
  134.   */
  135. void OLED_ShowChar(uint8_t Line, uint8_t Column, char Char)
  136. {      	
  137. 	uint8_t i;
  138. 	OLED_SetCursor((Line - 1) * 2, (Column - 1) * 8);		//设置光标位置在上半部分
  139. 	for (i = 0; i < 8; i++)
  140. 	{
  141. 		OLED_WriteData(OLED_F8x16[Char - ' '][i]);			//显示上半部分内容
  142. 	}
  143. 	OLED_SetCursor((Line - 1) * 2 + 1, (Column - 1) * 8);	//设置光标位置在下半部分
  144. 	for (i = 0; i < 8; i++)
  145. 	{
  146. 		OLED_WriteData(OLED_F8x16[Char - ' '][i + 8]);		//显示下半部分内容
  147. 	}
  148. }
  149.  
  150. /**
  151.   * @brief  OLED显示字符串
  152.   * @param  Line 起始行位置，范围：1~4
  153.   * @param  Column 起始列位置，范围：1~16
  154.   * @param  String 要显示的字符串，范围：ASCII可见字符
  155.   * @retval 无
  156.   */
  157. void OLED_ShowString(uint8_t Line, uint8_t Column, char *String)
  158. {
  159. 	uint8_t i;
  160. 	for (i = 0; String[i] != '\0'; i++)
  161. 	{
  162. 		OLED_ShowChar(Line, Column + i, String[i]);
  163. 	}
  164. }
  165.  
  166. /**
  167.   * @brief  OLED次方函数
  168.   * @retval 返回值等于X的Y次方
  169.   */
  170. uint32_t OLED_Pow(uint32_t X, uint32_t Y)
  171. {
  172. 	uint32_t Result = 1;
  173. 	while (Y--)
  174. 	{
  175. 		Result *= X;
  176. 	}
  177. 	return Result;
  178. }
  179.  
  180. /**
  181.   * @brief  OLED显示数字（十进制，正数）
  182.   * @param  Line 起始行位置，范围：1~4
  183.   * @param  Column 起始列位置，范围：1~16
  184.   * @param  Number 要显示的数字，范围：0~4294967295
  185.   * @param  Length 要显示数字的长度，范围：1~10
  186.   * @retval 无
  187.   */
  188. void OLED_ShowNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
  189. {
  190. 	uint8_t i;
  191. 	for (i = 0; i < Length; i++)							
  192. 	{
  193. 		OLED_ShowChar(Line, Column + i, Number / OLED_Pow(10, Length - i - 1) % 10 + '0');
  194. 	}
  195. }
  196.  
  197. /**
  198.   * @brief  OLED显示数字（十进制，带符号数）
  199.   * @param  Line 起始行位置，范围：1~4
  200.   * @param  Column 起始列位置，范围：1~16
  201.   * @param  Number 要显示的数字，范围：-2147483648~2147483647
  202.   * @param  Length 要显示数字的长度，范围：1~10
  203.   * @retval 无
  204.   */
  205. void OLED_ShowSignedNum(uint8_t Line, uint8_t Column, int32_t Number, uint8_t Length)
  206. {
  207. 	uint8_t i;
  208. 	uint32_t Number1;
  209. 	if (Number >= 0)
  210. 	{
  211. 		OLED_ShowChar(Line, Column, '+');
  212. 		Number1 = Number;
  213. 	}
  214. 	else
  215. 	{
  216. 		OLED_ShowChar(Line, Column, '-');
  217. 		Number1 = -Number;
  218. 	}
  219. 	for (i = 0; i < Length; i++)							
  220. 	{
  221. 		OLED_ShowChar(Line, Column + i + 1, Number1 / OLED_Pow(10, Length - i - 1) % 10 + '0');
  222. 	}
  223. }
  224.  
  225. /**
  226.   * @brief  OLED显示数字（十六进制，正数）
  227.   * @param  Line 起始行位置，范围：1~4
  228.   * @param  Column 起始列位置，范围：1~16
  229.   * @param  Number 要显示的数字，范围：0~0xFFFFFFFF
  230.   * @param  Length 要显示数字的长度，范围：1~8
  231.   * @retval 无
  232.   */
  233. void OLED_ShowHexNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
  234. {
  235. 	uint8_t i, SingleNumber;
  236. 	for (i = 0; i < Length; i++)							
  237. 	{
  238. 		SingleNumber = Number / OLED_Pow(16, Length - i - 1) % 16;
  239. 		if (SingleNumber < 10)
  240. 		{
  241. 			OLED_ShowChar(Line, Column + i, SingleNumber + '0');
  242. 		}
  243. 		else
  244. 		{
  245. 			OLED_ShowChar(Line, Column + i, SingleNumber - 10 + 'A');
  246. 		}
  247. 	}
  248. }
  249.  
  250. /**
  251.   * @brief  OLED显示数字（二进制，正数）
  252.   * @param  Line 起始行位置，范围：1~4
  253.   * @param  Column 起始列位置，范围：1~16
  254.   * @param  Number 要显示的数字，范围：0~1111 1111 1111 1111
  255.   * @param  Length 要显示数字的长度，范围：1~16
  256.   * @retval 无
  257.   */
  258. void OLED_ShowBinNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
  259. {
  260. 	uint8_t i;
  261. 	for (i = 0; i < Length; i++)							
  262. 	{
  263. 		OLED_ShowChar(Line, Column + i, Number / OLED_Pow(2, Length - i - 1) % 2 + '0');
  264. 	}
  265. }
  266.  
  267. /**
  268.   * @brief  OLED初始化
  269.   * @param  无
  270.   * @retval 无
  271.   */
  272. void OLED_Init(void)
  273. {
  274. 	uint32_t i, j;
  275. 	
  276. 	for (i = 0; i < 1000; i++)			//上电延时
  277. 	{
  278. 		for (j = 0; j < 1000; j++);
  279. 	}
  280. 	
  281. 	OLED_I2C_Init();			//端口初始化
  282. 	
  283. 	OLED_WriteCommand(0xAE);	//关闭显示
  284. 	
  285. 	OLED_WriteCommand(0xD5);	//设置显示时钟分频比/振荡器频率
  286. 	OLED_WriteCommand(0x80);
  287. 	
  288. 	OLED_WriteCommand(0xA8);	//设置多路复用率
  289. 	OLED_WriteCommand(0x3F);
  290. 	
  291. 	OLED_WriteCommand(0xD3);	//设置显示偏移
  292. 	OLED_WriteCommand(0x00);
  293. 	
  294. 	OLED_WriteCommand(0x40);	//设置显示开始行
  295. 	
  296. 	OLED_WriteCommand(0xA1);	//设置左右方向，0xA1正常 0xA0左右反置
  297. 	
  298. 	OLED_WriteCommand(0xC8);	//设置上下方向，0xC8正常 0xC0上下反置
  299.  
  300. 	OLED_WriteCommand(0xDA);	//设置COM引脚硬件配置
  301. 	OLED_WriteCommand(0x12);
  302. 	
  303. 	OLED_WriteCommand(0x81);	//设置对比度控制
  304. 	OLED_WriteCommand(0xCF);
  305.  
  306. 	OLED_WriteCommand(0xD9);	//设置预充电周期
  307. 	OLED_WriteCommand(0xF1);
  308.  
  309. 	OLED_WriteCommand(0xDB);	//设置VCOMH取消选择级别
  310. 	OLED_WriteCommand(0x30);
  311.  
  312. 	OLED_WriteCommand(0xA4);	//设置整个显示打开/关闭
  313.  
  314. 	OLED_WriteCommand(0xA6);	//设置正常/倒转显示
  315.  
  316. 	OLED_WriteCommand(0x8D);	//设置充电泵
  317. 	OLED_WriteCommand(0x14);
  318.  
  319. 	OLED_WriteCommand(0xAF);	//开启显示
  320. 		
  321. 	OLED_Clear();				//OLED清屏
  322. }
  323.  
  324.  
  325.

oled.h 

  1. #ifndef __OLED_H
  2. #define __OLED_H
  3.  
  4. void OLED_Init(void);
  5. void OLED_Clear(void);
  6. void OLED_ShowChar(uint8_t Line, uint8_t Column, char Char);
  7. void OLED_ShowString(uint8_t Line, uint8_t Column, char *String);
  8. void OLED_ShowNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
  9. void OLED_ShowSignedNum(uint8_t Line, uint8_t Column, int32_t Number, uint8_t Length);
  10. void OLED_ShowHexNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
  11. void OLED_ShowBinNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
  12.  
  13. #endif
  14.  
  15.  
  16.

oled_Font.h

  1. #ifndef __OLED_FONT_H
  2. #define __OLED_FONT_H
  3.  
  4. /*OLED字模库，宽8像素，高16像素*/
  5. const uint8_t OLED_F8x16[][16]=
  6. {
  7. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  8. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//  0
  9. 	
  10. 	0x00,0x00,0x00,0xF8,0x00,0x00,0x00,0x00,
  11. 	0x00,0x00,0x00,0x33,0x30,0x00,0x00,0x00,//! 1
  12. 	
  13. 	0x00,0x10,0x0C,0x06,0x10,0x0C,0x06,0x00,
  14. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//" 2
  15. 	
  16. 	0x40,0xC0,0x78,0x40,0xC0,0x78,0x40,0x00,
  17. 	0x04,0x3F,0x04,0x04,0x3F,0x04,0x04,0x00,//# 3
  18. 	
  19. 	0x00,0x70,0x88,0xFC,0x08,0x30,0x00,0x00,
  20. 	0x00,0x18,0x20,0xFF,0x21,0x1E,0x00,0x00,//$ 4
  21. 	
  22. 	0xF0,0x08,0xF0,0x00,0xE0,0x18,0x00,0x00,
  23. 	0x00,0x21,0x1C,0x03,0x1E,0x21,0x1E,0x00,//% 5
  24. 	
  25. 	0x00,0xF0,0x08,0x88,0x70,0x00,0x00,0x00,
  26. 	0x1E,0x21,0x23,0x24,0x19,0x27,0x21,0x10,//& 6
  27. 	
  28. 	0x10,0x16,0x0E,0x00,0x00,0x00,0x00,0x00,
  29. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//' 7
  30. 	
  31. 	0x00,0x00,0x00,0xE0,0x18,0x04,0x02,0x00,
  32. 	0x00,0x00,0x00,0x07,0x18,0x20,0x40,0x00,//( 8
  33. 	
  34. 	0x00,0x02,0x04,0x18,0xE0,0x00,0x00,0x00,
  35. 	0x00,0x40,0x20,0x18,0x07,0x00,0x00,0x00,//) 9
  36. 	
  37. 	0x40,0x40,0x80,0xF0,0x80,0x40,0x40,0x00,
  38. 	0x02,0x02,0x01,0x0F,0x01,0x02,0x02,0x00,//* 10
  39. 	
  40. 	0x00,0x00,0x00,0xF0,0x00,0x00,0x00,0x00,
  41. 	0x01,0x01,0x01,0x1F,0x01,0x01,0x01,0x00,//+ 11
  42. 	
  43. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  44. 	0x80,0xB0,0x70,0x00,0x00,0x00,0x00,0x00,//, 12
  45. 	
  46. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  47. 	0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,//- 13
  48. 	
  49. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  50. 	0x00,0x30,0x30,0x00,0x00,0x00,0x00,0x00,//. 14
  51. 	
  52. 	0x00,0x00,0x00,0x00,0x80,0x60,0x18,0x04,
  53. 	0x00,0x60,0x18,0x06,0x01,0x00,0x00,0x00,/// 15
  54. 	
  55. 	0x00,0xE0,0x10,0x08,0x08,0x10,0xE0,0x00,
  56. 	0x00,0x0F,0x10,0x20,0x20,0x10,0x0F,0x00,//0 16
  57. 	
  58. 	0x00,0x10,0x10,0xF8,0x00,0x00,0x00,0x00,
  59. 	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//1 17
  60. 	
  61. 	0x00,0x70,0x08,0x08,0x08,0x88,0x70,0x00,
  62. 	0x00,0x30,0x28,0x24,0x22,0x21,0x30,0x00,//2 18
  63. 	
  64. 	0x00,0x30,0x08,0x88,0x88,0x48,0x30,0x00,
  65. 	0x00,0x18,0x20,0x20,0x20,0x11,0x0E,0x00,//3 19
  66. 	
  67. 	0x00,0x00,0xC0,0x20,0x10,0xF8,0x00,0x00,
  68. 	0x00,0x07,0x04,0x24,0x24,0x3F,0x24,0x00,//4 20
  69. 	
  70. 	0x00,0xF8,0x08,0x88,0x88,0x08,0x08,0x00,
  71. 	0x00,0x19,0x21,0x20,0x20,0x11,0x0E,0x00,//5 21
  72. 	
  73. 	0x00,0xE0,0x10,0x88,0x88,0x18,0x00,0x00,
  74. 	0x00,0x0F,0x11,0x20,0x20,0x11,0x0E,0x00,//6 22
  75. 	
  76. 	0x00,0x38,0x08,0x08,0xC8,0x38,0x08,0x00,
  77. 	0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x00,//7 23
  78. 	
  79. 	0x00,0x70,0x88,0x08,0x08,0x88,0x70,0x00,
  80. 	0x00,0x1C,0x22,0x21,0x21,0x22,0x1C,0x00,//8 24
  81. 	
  82. 	0x00,0xE0,0x10,0x08,0x08,0x10,0xE0,0x00,
  83. 	0x00,0x00,0x31,0x22,0x22,0x11,0x0F,0x00,//9 25
  84. 	
  85. 	0x00,0x00,0x00,0xC0,0xC0,0x00,0x00,0x00,
  86. 	0x00,0x00,0x00,0x30,0x30,0x00,0x00,0x00,//: 26
  87. 	
  88. 	0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,
  89. 	0x00,0x00,0x80,0x60,0x00,0x00,0x00,0x00,//; 27
  90. 	
  91. 	0x00,0x00,0x80,0x40,0x20,0x10,0x08,0x00,
  92. 	0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x00,//< 28
  93. 	
  94. 	0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00,
  95. 	0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x00,//= 29
  96. 	
  97. 	0x00,0x08,0x10,0x20,0x40,0x80,0x00,0x00,
  98. 	0x00,0x20,0x10,0x08,0x04,0x02,0x01,0x00,//> 30
  99. 	
  100. 	0x00,0x70,0x48,0x08,0x08,0x08,0xF0,0x00,
  101. 	0x00,0x00,0x00,0x30,0x36,0x01,0x00,0x00,//? 31
  102. 	
  103. 	0xC0,0x30,0xC8,0x28,0xE8,0x10,0xE0,0x00,
  104. 	0x07,0x18,0x27,0x24,0x23,0x14,0x0B,0x00,//@ 32
  105. 	
  106. 	0x00,0x00,0xC0,0x38,0xE0,0x00,0x00,0x00,
  107. 	0x20,0x3C,0x23,0x02,0x02,0x27,0x38,0x20,//A 33
  108. 	
  109. 	0x08,0xF8,0x88,0x88,0x88,0x70,0x00,0x00,
  110. 	0x20,0x3F,0x20,0x20,0x20,0x11,0x0E,0x00,//B 34
  111. 	
  112. 	0xC0,0x30,0x08,0x08,0x08,0x08,0x38,0x00,
  113. 	0x07,0x18,0x20,0x20,0x20,0x10,0x08,0x00,//C 35
  114. 	
  115. 	0x08,0xF8,0x08,0x08,0x08,0x10,0xE0,0x00,
  116. 	0x20,0x3F,0x20,0x20,0x20,0x10,0x0F,0x00,//D 36
  117. 	
  118. 	0x08,0xF8,0x88,0x88,0xE8,0x08,0x10,0x00,
  119. 	0x20,0x3F,0x20,0x20,0x23,0x20,0x18,0x00,//E 37
  120. 	
  121. 	0x08,0xF8,0x88,0x88,0xE8,0x08,0x10,0x00,
  122. 	0x20,0x3F,0x20,0x00,0x03,0x00,0x00,0x00,//F 38
  123. 	
  124. 	0xC0,0x30,0x08,0x08,0x08,0x38,0x00,0x00,
  125. 	0x07,0x18,0x20,0x20,0x22,0x1E,0x02,0x00,//G 39
  126. 	
  127. 	0x08,0xF8,0x08,0x00,0x00,0x08,0xF8,0x08,
  128. 	0x20,0x3F,0x21,0x01,0x01,0x21,0x3F,0x20,//H 40
  129. 	
  130. 	0x00,0x08,0x08,0xF8,0x08,0x08,0x00,0x00,
  131. 	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//I 41
  132. 	
  133. 	0x00,0x00,0x08,0x08,0xF8,0x08,0x08,0x00,
  134. 	0xC0,0x80,0x80,0x80,0x7F,0x00,0x00,0x00,//J 42
  135. 	
  136. 	0x08,0xF8,0x88,0xC0,0x28,0x18,0x08,0x00,
  137. 	0x20,0x3F,0x20,0x01,0x26,0x38,0x20,0x00,//K 43
  138. 	
  139. 	0x08,0xF8,0x08,0x00,0x00,0x00,0x00,0x00,
  140. 	0x20,0x3F,0x20,0x20,0x20,0x20,0x30,0x00,//L 44
  141. 	
  142. 	0x08,0xF8,0xF8,0x00,0xF8,0xF8,0x08,0x00,
  143. 	0x20,0x3F,0x00,0x3F,0x00,0x3F,0x20,0x00,//M 45
  144. 	
  145. 	0x08,0xF8,0x30,0xC0,0x00,0x08,0xF8,0x08,
  146. 	0x20,0x3F,0x20,0x00,0x07,0x18,0x3F,0x00,//N 46
  147. 	
  148. 	0xE0,0x10,0x08,0x08,0x08,0x10,0xE0,0x00,
  149. 	0x0F,0x10,0x20,0x20,0x20,0x10,0x0F,0x00,//O 47
  150. 	
  151. 	0x08,0xF8,0x08,0x08,0x08,0x08,0xF0,0x00,
  152. 	0x20,0x3F,0x21,0x01,0x01,0x01,0x00,0x00,//P 48
  153. 	
  154. 	0xE0,0x10,0x08,0x08,0x08,0x10,0xE0,0x00,
  155. 	0x0F,0x18,0x24,0x24,0x38,0x50,0x4F,0x00,//Q 49
  156. 	
  157. 	0x08,0xF8,0x88,0x88,0x88,0x88,0x70,0x00,
  158. 	0x20,0x3F,0x20,0x00,0x03,0x0C,0x30,0x20,//R 50
  159. 	
  160. 	0x00,0x70,0x88,0x08,0x08,0x08,0x38,0x00,
  161. 	0x00,0x38,0x20,0x21,0x21,0x22,0x1C,0x00,//S 51
  162. 	
  163. 	0x18,0x08,0x08,0xF8,0x08,0x08,0x18,0x00,
  164. 	0x00,0x00,0x20,0x3F,0x20,0x00,0x00,0x00,//T 52
  165. 	
  166. 	0x08,0xF8,0x08,0x00,0x00,0x08,0xF8,0x08,
  167. 	0x00,0x1F,0x20,0x20,0x20,0x20,0x1F,0x00,//U 53
  168. 	
  169. 	0x08,0x78,0x88,0x00,0x00,0xC8,0x38,0x08,
  170. 	0x00,0x00,0x07,0x38,0x0E,0x01,0x00,0x00,//V 54
  171. 	
  172. 	0xF8,0x08,0x00,0xF8,0x00,0x08,0xF8,0x00,
  173. 	0x03,0x3C,0x07,0x00,0x07,0x3C,0x03,0x00,//W 55
  174. 	
  175. 	0x08,0x18,0x68,0x80,0x80,0x68,0x18,0x08,
  176. 	0x20,0x30,0x2C,0x03,0x03,0x2C,0x30,0x20,//X 56
  177. 	
  178. 	0x08,0x38,0xC8,0x00,0xC8,0x38,0x08,0x00,
  179. 	0x00,0x00,0x20,0x3F,0x20,0x00,0x00,0x00,//Y 57
  180. 	
  181. 	0x10,0x08,0x08,0x08,0xC8,0x38,0x08,0x00,
  182. 	0x20,0x38,0x26,0x21,0x20,0x20,0x18,0x00,//Z 58
  183. 	
  184. 	0x00,0x00,0x00,0xFE,0x02,0x02,0x02,0x00,
  185. 	0x00,0x00,0x00,0x7F,0x40,0x40,0x40,0x00,//[ 59
  186. 	
  187. 	0x00,0x0C,0x30,0xC0,0x00,0x00,0x00,0x00,
  188. 	0x00,0x00,0x00,0x01,0x06,0x38,0xC0,0x00,//\ 60
  189. 	
  190. 	0x00,0x02,0x02,0x02,0xFE,0x00,0x00,0x00,
  191. 	0x00,0x40,0x40,0x40,0x7F,0x00,0x00,0x00,//] 61
  192. 	
  193. 	0x00,0x00,0x04,0x02,0x02,0x02,0x04,0x00,
  194. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//^ 62
  195. 	
  196. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  197. 	0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,//_ 63
  198. 	
  199. 	0x00,0x02,0x02,0x04,0x00,0x00,0x00,0x00,
  200. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//` 64
  201. 	
  202. 	0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,
  203. 	0x00,0x19,0x24,0x22,0x22,0x22,0x3F,0x20,//a 65
  204. 	
  205. 	0x08,0xF8,0x00,0x80,0x80,0x00,0x00,0x00,
  206. 	0x00,0x3F,0x11,0x20,0x20,0x11,0x0E,0x00,//b 66
  207. 	
  208. 	0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00,
  209. 	0x00,0x0E,0x11,0x20,0x20,0x20,0x11,0x00,//c 67
  210. 	
  211. 	0x00,0x00,0x00,0x80,0x80,0x88,0xF8,0x00,
  212. 	0x00,0x0E,0x11,0x20,0x20,0x10,0x3F,0x20,//d 68
  213. 	
  214. 	0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,
  215. 	0x00,0x1F,0x22,0x22,0x22,0x22,0x13,0x00,//e 69
  216. 	
  217. 	0x00,0x80,0x80,0xF0,0x88,0x88,0x88,0x18,
  218. 	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//f 70
  219. 	
  220. 	0x00,0x00,0x80,0x80,0x80,0x80,0x80,0x00,
  221. 	0x00,0x6B,0x94,0x94,0x94,0x93,0x60,0x00,//g 71
  222. 	
  223. 	0x08,0xF8,0x00,0x80,0x80,0x80,0x00,0x00,
  224. 	0x20,0x3F,0x21,0x00,0x00,0x20,0x3F,0x20,//h 72
  225. 	
  226. 	0x00,0x80,0x98,0x98,0x00,0x00,0x00,0x00,
  227. 	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//i 73
  228. 	
  229. 	0x00,0x00,0x00,0x80,0x98,0x98,0x00,0x00,
  230. 	0x00,0xC0,0x80,0x80,0x80,0x7F,0x00,0x00,//j 74
  231. 	
  232. 	0x08,0xF8,0x00,0x00,0x80,0x80,0x80,0x00,
  233. 	0x20,0x3F,0x24,0x02,0x2D,0x30,0x20,0x00,//k 75
  234. 	
  235. 	0x00,0x08,0x08,0xF8,0x00,0x00,0x00,0x00,
  236. 	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//l 76
  237. 	
  238. 	0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x00,
  239. 	0x20,0x3F,0x20,0x00,0x3F,0x20,0x00,0x3F,//m 77
  240. 	
  241. 	0x80,0x80,0x00,0x80,0x80,0x80,0x00,0x00,
  242. 	0x20,0x3F,0x21,0x00,0x00,0x20,0x3F,0x20,//n 78
  243. 	
  244. 	0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,
  245. 	0x00,0x1F,0x20,0x20,0x20,0x20,0x1F,0x00,//o 79
  246. 	
  247. 	0x80,0x80,0x00,0x80,0x80,0x00,0x00,0x00,
  248. 	0x80,0xFF,0xA1,0x20,0x20,0x11,0x0E,0x00,//p 80
  249. 	
  250. 	0x00,0x00,0x00,0x80,0x80,0x80,0x80,0x00,
  251. 	0x00,0x0E,0x11,0x20,0x20,0xA0,0xFF,0x80,//q 81
  252. 	
  253. 	0x80,0x80,0x80,0x00,0x80,0x80,0x80,0x00,
  254. 	0x20,0x20,0x3F,0x21,0x20,0x00,0x01,0x00,//r 82
  255. 	
  256. 	0x00,0x00,0x80,0x80,0x80,0x80,0x80,0x00,
  257. 	0x00,0x33,0x24,0x24,0x24,0x24,0x19,0x00,//s 83
  258. 	
  259. 	0x00,0x80,0x80,0xE0,0x80,0x80,0x00,0x00,
  260. 	0x00,0x00,0x00,0x1F,0x20,0x20,0x00,0x00,//t 84
  261. 	
  262. 	0x80,0x80,0x00,0x00,0x00,0x80,0x80,0x00,
  263. 	0x00,0x1F,0x20,0x20,0x20,0x10,0x3F,0x20,//u 85
  264. 	
  265. 	0x80,0x80,0x80,0x00,0x00,0x80,0x80,0x80,
  266. 	0x00,0x01,0x0E,0x30,0x08,0x06,0x01,0x00,//v 86
  267. 	
  268. 	0x80,0x80,0x00,0x80,0x00,0x80,0x80,0x80,
  269. 	0x0F,0x30,0x0C,0x03,0x0C,0x30,0x0F,0x00,//w 87
  270. 	
  271. 	0x00,0x80,0x80,0x00,0x80,0x80,0x80,0x00,
  272. 	0x00,0x20,0x31,0x2E,0x0E,0x31,0x20,0x00,//x 88
  273. 	
  274. 	0x80,0x80,0x80,0x00,0x00,0x80,0x80,0x80,
  275. 	0x80,0x81,0x8E,0x70,0x18,0x06,0x01,0x00,//y 89
  276. 	
  277. 	0x00,0x80,0x80,0x80,0x80,0x80,0x80,0x00,
  278. 	0x00,0x21,0x30,0x2C,0x22,0x21,0x30,0x00,//z 90
  279. 	
  280. 	0x00,0x00,0x00,0x00,0x80,0x7C,0x02,0x02,
  281. 	0x00,0x00,0x00,0x00,0x00,0x3F,0x40,0x40,//{ 91
  282. 	
  283. 	0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,
  284. 	0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,//| 92
  285. 	
  286. 	0x00,0x02,0x02,0x7C,0x80,0x00,0x00,0x00,
  287. 	0x00,0x40,0x40,0x3F,0x00,0x00,0x00,0x00,//} 93
  288. 	
  289. 	0x00,0x06,0x01,0x01,0x02,0x02,0x04,0x04,
  290. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//~ 94
  291. };
  292.  
  293. #endif
  294.  
  295.  
  296.

 

main.c

  1. #include "stm32f10x.h"                  // Device header
  2. #include "MyConfig.h"
  3. //#include "stdio.h"
  4.  
  5. extern int16_t TargerNum;          
  6. extern int16_t Find_Task;          
  7. extern int16_t LoR;
  8.  
  9.  
  10. int main(void)
  11. {
  12.  
  13. 	Usart1_Init(115200);	
  14. 	OLED_Init();
  15. 	OLED_ShowString(1,1,"TargerNum:");
  16. 	OLED_ShowString(2,1,"LoR:");
  17. 	OLED_ShowString(3,1,"Find_Task: ");
  18.  
  19.  
  20. 	while (1)
  21. 	{
  22. 		OLED_ShowNum(1,11,TargerNum,2);
  23. 		OLED_ShowNum(2,5,LoR,2);
  24. 		OLED_ShowNum(3,11,Find_Task,2);
  25.         
  26.     }
  27. }

 六、完整代码2（stm32端发送openmv接收）

1.stm32端

  1. #include "stm32f10x.h"                  // Device header
  2. #include "MyConfig.h"
  3. //#include "stdio.h"
  4. uint8_t RoadLineCheck[2] = {0,0};
  5. uint8_t RoadLine;
  6. extern int16_t TargerNum;          
  7. extern int16_t Find_Task;          
  8. extern int16_t LoR;
  9. void Usart1_Sendata(u8 * str)
  10. {	
  11. 	u8 i = 0;
  12. 	
  13. 	USART_SendData(USART1,0x0d);
  14. 	while( USART_GetFlagStatus(USART1,USART_FLAG_TC)!= SET);
  15. 	
  16. 	for(i = 0;i < 2;i++)
  17. 	{
  18. 		USART_SendData(USART1,str[i]);
  19. 		while( USART_GetFlagStatus(USART1,USART_FLAG_TC)!= SET);
  20. 	}
  21.  
  22. 	USART_SendData(USART1,0x5b);
  23. 	while( USART_GetFlagStatus(USART1,USART_FLAG_TC)!= SET);
  24. }
  25.  
  26.  
  27. int main(void)
  28. {
  29. 	NVIC_Config();
  30. 	Usart1_Init(115200);	
  31. 	Find_Task=2;
  32. 	u8 send_buff[2] = {TargerNum,Find_Task};
  33.  
  34. 	while (1)
  35. 	{
  36.         Usart1_Sendata(send_buff);
  37.     }
  38. }

2.openmv端

  1. import time, image,sensor,math,pyb,ustruct
  2. from image import SEARCH_EX, SEARCH_DS
  3. from pyb import Pin, Timer,LED
  4.  
  5. #从imgae模块引入SEARCH_EX和SEARCH_DS。使用from import仅仅引入SEARCH_EX,
  6. #SEARCH_DS两个需要的部分，而不把image模块全部引入。
  7.  
  8.  
  9. sensor.reset()
  10.  
  11. # Set sensor settings
  12. sensor.set_contrast(1)
  13. sensor.set_gainceiling(16)
  14. # Max resolution for template matching with SEARCH_EX is QQVGA
  15. sensor.set_framesize(sensor.QQVGA)
  16. # You can set windowing to reduce the search image.
  17.  
  18. sensor.set_pixformat(sensor.GRAYSCALE)
  19.  
  20. sensor.set_windowing(0, 40, 160, 40)  #观察窗口  后面ROI设置也会以这个为新的基准
  21.  
  22. rx_buff=[]
  23. state = 0
  24. tx_flag = 0
  25.  
  26. x = 0
  27.  
  28. Find_Task =1       #1
  29. Target_Num =0
  30. data = [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00]
  31.  
  32.  
  33. uart = pyb.UART(3, 115200, timeout_char = 1000)     #定义串口1变量
  34. blue_led = LED(2)
  35.  
  36.  
  37. ########串口接收数据函数处理#########
  38. def Receive_Prepare():      #data
  39.     global state
  40.     global x
  41.     global tx_flag
  42.     global data
  43.     global Find_Task
  44.     global Target_Num
  45.     if state==0:
  46.         data[0]=uart.readchar()
  47.         if data[0] == 0x0d:#帧头
  48.             state = 1
  49.         else:
  50.             state = 0
  51.             rx_buff.clear()
  52.     elif state==1:
  53.         data[1]=uart.readchar()
  54.         Target_Num=data[x+1]
  55.         state = 2
  56.     elif state==2:
  57.         data[2]=uart.readchar()
  58.         Find_Task=data[x+2]
  59.         state = 3
  60.     elif state == 3:
  61.         data[4]=uart.readchar()
  62.         if data[4] == 0x5b:
  63.             state = 4
  64.     elif state == 4:
  65.         state=0
  66.  
  67.     else:
  68.         state = 0
  69.         rx_buff.clear()
  70.  
  71.  
  72.  
  73.  
  74.  
  75. clock = time.clock()
  76. # Run template matching
  77. while (True):
  78.     clock.tick()
  79.     img = sensor.snapshot()# 镜头初始化
  80.     if(uart.any()>0):
  81.        Receive_Prepare()
  82.  
  83.     print(clock.fps(),Find_Task, Target_Num)
  84.  
  85.

总结

这里对文章进行总结：

个人认为这套代码比较通俗易懂，稍微读懂一点直接移植就好（可能需要根据实际略微修改）。

要移植的话最好选择完整代码这边

stm32端用的是串口1，openmv端用的是串口3；
固定包长并不是只能三个或者两个数据位，是代码编写设置好的不超过缓存区的数据位是自定义的，只是运用的时候会根据设置好的数据位发送/接收。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/707630
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号