int value = 0; //¶¨ÒåÒ»¸ö±äÁ¿£¬ÓÃÓÚ¶ÁÈ¡ADCµÄ½á¹ûÖµ float v = 0.0; //ADC½á¹ûתµçѹ char message[20] = ""; //ÓÃÓÚÆ´½Ó×Ö·û´® HAL_ADCEx_Calibration_Start(&hadc1, ADC_SINGLE_ENDED); HAL_ADC_Start(&hadc1); //ADC²ÉÑùÓëת»» HAL_ADC_PollForConversion(&hadc1,HAL_MAX_DELAY); //¼ì²éÊÇ·ñת»»Íê³É /* USER CODE END 2 */ /* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { value = HAL_ADC_GetValue(&hadc1); //½«ADC½á¹û¶ÁÈ¡µ½valueÖÐ v = (value *3.3/4095 *3.3) ; //½«½á¹ûת»»Îªµçѹ sprintf(message,"ADC: %d %.2fV",HAL_ADC_GetValue(&hadc1),v); HAL_UART_Transmit(&huart2,(uint8_t*)message,strlen(message),HAL_MAX_DELAY); HAL_Delay(500);根据这个代码写ADC的两个通道的代码

时间: 2025-07-14 07:48:32 浏览: 5
<think>好的,用户现在有一个基于STM32 HAL库的单通道ADC代码,想要修改成支持双通道的。我需要先回忆一下STM32的ADC规则组配置方法。根据之前的引用内容,规则通道的转换顺序由SQR1、SQR2、SQR3这三个寄存器控制,每个通道的转换顺序需要在这些寄存器中指定。 首先,用户原来的单通道代码可能只配置了一个通道在规则组的某个位置,比如SQ1。现在要添加第二个通道,就需要在规则组的转换序列中加入第二个通道,比如SQ2的位置。同时,规则通道的总数需要设置为2,这应该是在SQR1寄存器中的L字段设置的。 接下来,配置HAL库中的ADC初始化结构体。原来的代码可能只设置了一个通道的Rank为ADC_REGULAR_RANK_1。现在需要添加第二个通道的配置,将其Rank设为ADC_REGULAR_RANK_2。同时,在初始化时,需要确保ADC的规则序列长度设置为2,也就是修改SQR1中的L[3:0]位为1(因为长度是N-1,所以双通道的话,这里应该设置成1)。 然后,DMA的配置部分。单通道时,DMA可能只传输一个数据,现在双通道需要传输两个数据,所以DMA的缓冲区大小要改为2,并且数据长度应该是半字(16位)。在HAL库中,启动DMA传输的函数调用需要指向一个包含两个元素的数组。 还有需要注意ADC的扫描模式是否启用。单通道可能没有启用扫描模式,但多通道必须启用扫描模式,并且需要使能连续转换模式或者根据需要配置触发方式。此外,如果是使用间断模式的话,规则组计数也需要调整,但一般情况下可能不需要。 最后,用户需要修改数据处理部分,从DMA缓冲区读取两个通道的数据。确保代码中访问的是数组的索引0和1,分别对应两个通道的值。 可能的问题点包括:忘记增加规则序列长度导致只转换第一个通道,DMA缓冲区大小不足导致数据覆盖或错误,或者扫描模式未启用导致无法连续转换多个通道。需要检查这些配置是否正确。</think>### STM32双通道ADC配置步骤 根据您提供的单通道ADC代码,修改为双通道需进行以下关键配置调整: 1. **规则通道配置** - 在`MX_ADC1_Init()`函数中修改规则通道配置: ```c hadc1.Init.NbrOfConversion = 2; // 设置转换通道数为2 ``` - 在通道配置部分增加第二个通道: ```c sConfig.Channel = ADC_CHANNEL_1; // 第一个通道 sConfig.Rank = ADC_REGULAR_RANK_1; // 转换顺序1 HAL_ADC_ConfigChannel(&hadc1, &sConfig); sConfig.Channel = ADC_CHANNEL_2; // 第二个通道 sConfig.Rank = ADC_REGULAR_RANK_2; // 转换顺序2 HAL_ADC_ConfigChannel(&hadc1, &sConfig); ``` 2. **DMA配置调整** ```c __HAL_LINKDMA(&hadc1, DMA_Handle, hdma_adc1); hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; hdma_adc1.Init.Mode = DMA_CIRCULAR; // 循环模式 ``` 3. **数据缓冲区定义** ```c #define ADC_BUF_LEN 2 volatile uint16_t adc_buffer[ADC_BUF_LEN]; // 双通道缓冲区 ``` 4. **启动转换** ```c HAL_ADC_Start_DMA(&hadc1, (uint32_t*)adc_buffer, ADC_BUF_LEN); ``` 关键注意事项: 1. 必须启用扫描模式:`hadc1.Init.ScanConvMode = ENABLE;` 2. 确保时钟配置支持多通道采样时间 3. 通道间采样间隔可通过`SMPR`寄存器配置[^1]
阅读全文

相关推荐

////////////////////////////////////////////////////////////////////////////////// //±¾³ÌÐòÖ»¹©Ñ§Ï°Ê¹Óã¬Î´¾­×÷ÕßÐí¿É£¬²»µÃÓÃÓÚÆäËüÈκÎÓÃ; //ÐÀÞ±µç×Ó // // ÎÄ ¼þ Ãû :yanwu.c // °æ ±¾ ºÅ : v1.0 // ×÷ Õß : ÐÀÞ±µç×Ó // Éú³ÉÈÕÆÚ : 20200101 // ×î½üÐÞ¸Ä : // ¹¦ÄÜÃèÊö :Ö÷º¯Êý // ÐÞ¸ÄÀúÊ· : // ÈÕ ÆÚ : // ×÷ Õß : ÐÀÞ±µç×Ó // ÐÞ¸ÄÄÚÈÝ : ´´½¨Îļþ //°æÈ¨ËùÓУ¬µÁ°æ±Ø¾¿¡£ //Copyright(C) ÐÀÞ±µç×Ó2020/3/16 //All rights reserved //******************************************************************************/. //³ÌÐòÍ·º¯Êý #include <reg52.h> #include <intrins.h> //°üº¬Í·Îļþ //ÏÔʾº¯Êý #include <display.h> //ºê¶¨Òå #define uint unsigned int #define uchar unsigned char //¹Ü½ÅÉùÃ÷ sbit LED_R= P2^2;//ºìµÆ sbit LED_G= P2^0;//ÂÌµÆ sbit FENG = P2^5;//·äÃùÆ÷ //sbit san=P3^4; //·çÉÈ¿ØÖÆ£¨Ñ¡Å䣩 sbit CS = P1^4; sbit Clk = P1^2; sbit DATI = P1^3; sbit DATO = P1^3; //ADC0832Òý½Å //°´¼ü sbit Key1=P2^6; //ÉèÖüü sbit Key2=P2^7; //¼Ó°´¼ü sbit Key3=P3^7; //¼õ°´¼ü bit bdata flag; //±¨¾¯±ê־λ uchar set; //ÉèÖÃ״̬ /*******************************¶¨ÒåÈ«¾Ö±äÁ¿********************************/ unsigned char dat = 0; //ADÖµ unsigned char CH=0; //ͨµÀ±äÁ¿ unsigned int sum=0; //ƽ¾ùÖµ¼ÆËãʱµÄ×ÜÊý unsigned char m=0; //º¯ÊýÉùÃ÷ extern uchar ADC0809(); extern void Key(); //¾Æ¾«º¬Á¿±äÁ¿ uchar temp=0; uchar WARNING=25; //±¨¾¯Öµ /**************************************************************************** º¯Êý¹¦ÄÜ:ADת»»×Ó³ÌÐò Èë¿Ú²ÎÊý:CH ³ö¿Ú²ÎÊý:dat ****************************************************************************/ unsigned char adc0832(unsigned char CH) { unsigned char i,test,adval; adval = 0x00; test = 0x00; Clk = 0; //³õʼ»¯ DATI = 1; _nop_(); CS = 0; _nop_(); Clk = 1; _nop_(); if ( CH == 0x00 ) //ͨµÀÑ¡Ôñ { Clk = 0; DATI = 1; //ͨµÀ0µÄµÚһλ _nop_(); Clk = 1; _nop_(); Clk = 0; DATI = 0; //ͨµÀ0µÄµÚ¶þλ _nop_(); Clk = 1; _nop_(); } else { Clk = 0; DATI = 1; //ͨµÀ1µÄµÚһλ _nop_(); Clk = 1; _nop_(); Clk = 0; DATI = 1; //ͨµÀ1µÄµÚ¶þλ _nop_(); Clk = 1; _nop_(); } Clk = 0; DATI = 1; for( i = 0;i < 8;i++ ) //¶Áȡǰ8λµÄÖµ { _nop_(); adval <<= 1; Clk = 1; _nop_(); Clk = 0; if (DATO) adval |= 0x01; else adval |= 0x00; } for (i = 0; i < 8; i++) //¶ÁÈ¡ºó8λµÄÖµ { test >>= 1; if (DATO) test |= 0x80; else test |= 0x00; _nop_(); Clk = 1; _nop_(); Clk = 0; } if (adval == test) //±È½Ïǰ8λÓëºó8λµÄÖµ£¬Èç¹û²»ÏàͬÉáÈ¥¡£ÈôÒ»Ö±³öÏÖÏÔʾΪÁ㣬Ç뽫¸ÃÐÐÈ¥µô dat = test; nop_(); CS = 1; //ÊÍ·ÅADC0832 DATO = 1; Clk = 1; return dat; } void init() //³õʼ»¯º¯Êý { TMOD=0x01; //¹¤×÷·½Ê½ TL0=0xb0; TH0=0x3c; //¸³³õÖµ£¨12MHz¾§ÕñµÄ50ms£© EA=1; //´ò¿ªÖжÏ×Ü¿ª¹Ø ET0=1; //´ò¿ªÖжÏÔÊÐí¿ª¹Ø TR0=1; //´ò¿ª¶¨Ê±Æ÷¿ª¹Ø } void main() //Ö÷º¯Êý { Init1602();//³õʼ»¯ÏÔʾ init(); //³õʼ»¯¶¨Ê±Æ÷ while(1) //½øÈëÑ­»· { for(m=0;m<50;m++) //¶Á50´ÎADÖµ sum = adc0832(0)+sum; //¶Áµ½µÄADÖµ£¬½«¶Áµ½µÄÊý¾ÝÀÛ¼Óµ½sum temp=sum/50; //Ìø³öÉÏÃæµÄforÑ­»·ºó£¬½«ÀÛ¼ÓµÄ×ÜÊý³ýÒÔ50µÃµ½Æ½¾ùÖµtemp sum=0; //ƽ¾ùÖµ¼ÆËãÍê³Éºó£¬½«×ÜÊýÇåÁã if(set==0) //Ö»ÓÐÔÚ·ÇÉèÖÃ״̬ʱ£¬ Display_1602(temp,WARNING); //²ÅË¢ÐÂÏÔʾʵʱŨ¶ÈÖµ if(temp<WARNING&&set==0) //·ÇÉèÖÃʱµ±Å¨¶ÈֵСÓÚ±¨¾¯ÖµÊ± { flag=0; //±¨¾¯±ê־λÖÃ0£¬²»±¨¾¯ } else if(temp>WARNING&&set==0) //·ÇÉèÖÃʱµ±Å¨¶ÈÖµ´óÓÚ±¨¾¯ÖµÊ± { flag=1; //±¨¾¯±ê־λÖÃ1 } Key(); //ɨÃè°´¼ü } } void Key() //°´¼üº¯Êý { if(Key1==0) //ÉèÖüü°´ÏÂʱ { while(Key1==0); //¼ì²â°´¼üÊÇ·ñÊÍ·Å FENG=0; //·äÃùÆ÷Ïì set++; //ÉèÖÃ״̬±êÖ¾¼Ó flag=0; //Í£Ö¹±¨¾¯ // san=1; //·çÉÈֹͣת¶¯£¨Ñ¡Å䣩 TR0=0; //¶¨Ê±Æ÷Í£Ö¹ } if(set==1) //ÉèÖÃʱ { write_com(0x38);//ÆÁÄ»³õʼ»¯ write_com(0x80+0x40+13);//Ñ¡Öб¨¾¯ÖµµÄλÖà write_com(0x0f);//´ò¿ªÏÔʾ ÎÞ¹â±ê ¹â±êÉÁ˸ write_com(0x06);//µ±¶Á»òдһ¸ö×Ö·ûÊÇÖ¸Õëºóһһλ FENG=1; //·äÃùÆ÷Í£Ö¹ÃùÏì } else if(set>=2) //ÔÙ°´Ò»ÏÂÉèÖüüʱ£¬Í˳öÉèÖà { set=0; //ÉèÖÃ״̬ÇåÁã write_com(0x38);//ÆÁÄ»³õʼ»¯ write_com(0x0c);//´ò¿ªÏÔʾ ÎÞ¹â±ê ÎÞ¹â±êÉÁ˸ FENG=1; //·äÃùÆ÷Í£Ö¹Ïì flag=1; //±¨¾¯±ê־λÖÃ1 TR0=1; //¶¨Ê±Æ÷¿ªÊ¼¼ÆÊ± } if(Key2==0&&set!=0) //µ±ÔÚÉèÖÃ״̬ʱ£¬°´Ï¼Ӽüʱ { while(Key2==0); //°´¼üÊÍ·Å FENG=0; //·äÃùÆ÷ÃùÏì WARNING++; //±¨¾¯ãÐÖµ¼Ó if(WARNING>=255)//ãÐÖµ×î´ó¼Óµ½255 WARNING=0; //ÇåÁã write_com(0x80+0x40+11); //ÔÚãÐÖµµÄλÖÃдÈëÉèÖõÄÊý¾Ý write_data('0'+WARNING/100); //ÏÔʾ°Ù루½«123³ýÒÔ100µÃµ½µÄÉÌÊÇ1£¬¾ÍÊǰÙλÊý¾Ý£©123ΪÀý×Ó write_data('0'+WARNING/10%10);//ÏÔʾʮ루½«123³ýÒÔ10µÃµ½ÉÌÊÇ12£¬½«12³ýÒÔ10µÄÓàÊý¾ÍÊÇʮ룩 write_data('0'+WARNING%10); //ÏÔʾ¸ö루½«123³ýÒÔ10µÄÓàÊý3¾ÍÊǸöλÊý¾Ý£©123ΪÀý×Ó write_com(0x80+0x40+13);//λÖà FENG=1;//·äÃùÆ÷Í£Ö¹ } if(Key3==0&&set!=0) //¼õ°´¼ü×¢ÊͲο¼¼Ó°´¼ü²¿·Ö { while(Key3==0); FENG=0; WARNING--; if(WARNING<=0) WARNING=255; write_com(0x80+0x40+11); write_data('0'+WARNING/100); write_data('0'+WARNING/10%10); write_data('0'+WARNING%10); write_com(0x80+0x40+13);//λÖà FENG=1; } } void time1_int(void) interrupt 1 //¶¨Ê±Æ÷º¯Êý { uchar count; TL0=0xb0; TH0=0x3c; //ÖØÐ¸³³õÖµ count++; //¼ÆÊ±±äÁ¿¼Ó if(count==10)//¶¨Ê±Æ÷¶¨Ê±ÊÇ50ms£¬´Ë´¦¼ÆÊý10´Î£¬ÕýºÃÊÇ500ms£¬ÓÃÓÚ±¨¾¯Ê± µÆÁÁºÍ·äÃùÆ÷Ïì { if(flag==0) //±¨¾¯±ê־Ϊ0ʱ { LED_G=0; //Â̵ÆÁÁ LED_R=1; //ºìµÆÃð FENG=1; //·äÃùÆ÷²»Ïì // san=1; //·çÉȲ»×ª£¨Ñ¡Å䣩 } if(flag==1) //±¨¾¯±ê־λΪ1ʱ { LED_G=1; //Â̵ÆÃð LED_R=0; //ºìµÆÁÁ FENG=0; //·äÃùÆ÷Ïì // san=0; //·çÉÈת¶¯£¨Ñ¡Å䣩 } } if(count==20) //¼ÆÊýµ½20ʱ£¬ÕýºÃÊÇ1000ms£¬¾ÍÊÇ1s£¬ÕâÀï¾ÍÊÇÈõÆÃ𣬷äÃùÆ÷²»Ï죬´Ó¶ø×ö³öÉÁ˸µÄЧ¹û { count=0; //¼Æµ½1sʱ£¬½«countÇåÁ㣬׼±¸ÖØÐ¼ÆÊý if(flag==0) { LED_G=1; LED_R=1; FENG=1; // san=1; //È«²¿¹Ø±Õ } if(flag==1) { LED_G=1; LED_R=1; FENG=1; // san=0; //±¨¾¯Öµ£¬·çÉÈÊÇһֱת¶¯µÄ£¨Ñ¡Å䣩 } } } 修改为下限报警

#include <REG52.h> #define uint unsigned int #define uchar unsigned char //ºê¶¨Òå sbit SET= P3^1; //¶¨Òåµ÷Õû¼ü sbit DEC= P3^2; //¶¨Òå¼õÉÙ¼ü sbit ADD= P3^3; //¶¨ÒåÔö¼Ó¼ü sbit BEEP=P3^6; //¶¨Òå·äÃùÆ÷ sbit ALAM=P1^2; //¶¨Ò嵯¹â±¨¾¯ sbit DQ= P3^7; //¶¨ÒåDS18B20×ÜÏßI/O bit shanshuo_st; //ÉÁ˸¼ä¸ô±êÖ¾ bit beep_st; //·äÃùÆ÷¼ä¸ô±êÖ¾ sbit DIAN = P0^5; //СÊýµã uint x=0; //¼ÆÊýÆ÷ signed char m; //ζÈֵȫ¾Ö±äÁ¿ uchar n; //ζÈֵȫ¾Ö±äÁ¿ uchar set_st=0; //״̬±êÖ¾ signed char shangxian=38; //ÉÏÏÞ±¨¾¯Î¶ȣ¬Ä¬ÈÏֵΪ38 signed char xiaxian=5; //ÏÂÏÞ±¨¾¯Î¶ȣ¬Ä¬ÈÏֵΪ38 //uchar code LEDData[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0xff}; uchar code LEDData[]={0x5F,0x44,0x9D,0xD5,0xC6,0xD3,0xDB,0x47,0xDF,0xD7,0xCF,0xDA,0x9B,0xDC,0x9B,0x8B}; // P0.7-G P0.6-C P0.5-. P0.4-D P0.3-E P0.2-B P0.1-F P0.0-A //============================================================================================ //====================================DS18B20================================================= //============================================================================================ /*****ÑÓʱ×Ó³ÌÐò*****/ void Delay_DS18B20(int num) { while(num--) ; } /*****³õʼ»¯DS18B20*****/ void Init_DS18B20(void) { unsigned char x=0; DQ = 1; //DQ¸´Î» Delay_DS18B20(8); //ÉÔ×öÑÓʱ DQ = 0; //µ¥Æ¬»ú½«DQÀ­µÍ Delay_DS18B20(80); //¾«È·ÑÓʱ£¬´óÓÚ480us DQ = 1; //À­¸ß×ÜÏß Delay_DS18B20(14); x = DQ; //ÉÔ×öÑÓʱºó£¬Èç¹ûx=0Ôò³õʼ»¯³É¹¦£¬x=1Ôò³õʼ»¯Ê§°Ü Delay_DS18B20(20); } /*****¶ÁÒ»¸ö×Ö½Ú*****/ unsigned char ReadOneChar(void) { unsigned char i=0; unsigned char dat = 0; for (i=8;i>0;i--) { DQ = 0; // ¸øÂö³åÐźŠdat>>=1; DQ = 1; // ¸øÂö³åÐźŠif(DQ) dat|=0x80; Delay_DS18B20(4); } return(dat); } /*****дһ¸ö×Ö½Ú*****/ void WriteOneChar(unsigned char dat) { unsigned char i=0; for (i=8; i>0; i--) { DQ = 0; DQ = dat&0x01; Delay_DS18B20(5); DQ = 1; dat>>=1; } } /*****¶ÁȡζÈ*****/ unsigned int ReadTemperature(void) { unsigned char a=0; unsigned char b=0; unsigned int t=0; float tt=0; Init_DS18B20(); WriteOneChar(0xCC); //Ìø¹ý¶ÁÐòÁкŵIJÙ×÷ WriteOneChar(0x44); //Æô¶¯Î¶Èת»» Init_DS18B20(); WriteOneChar(0xCC); //Ìø¹ý¶ÁÐòºÅÁкŵIJÙ×÷ WriteOneChar(0xBE); //¶ÁȡζȼĴæÆ÷ a=ReadOneChar(); //¶ÁµÍ8λ b=ReadOneChar(); //¶Á¸ß8λ t=(b<<8)|a ; t=t*6.25; //·Å´ó10±¶£¨½«Ð¡ÊýµãºóһλÏÔʾ³öÀ´£©Êä³ö²¢ËÄÉáÎåÈë return(t); //·µ»ØÎ¶ÈÖµ } //===================================================================================== //===================================================================================== //===================================================================================== /*****ÑÓʱ×Ó³ÌÐò*****/ void Delay(uint num) { while( --num ); } /*****³õʼ»¯¶¨Ê±Æ÷0*****/ void InitTimer(void) { TMOD=0x1; TH0=0x3c; TL0=0xb0; //50ms£¨¾§Õñ12M£© } /*****¶ÁȡζÈ*****/ void check_wendu(void) { uint a,b,c,d; c=ReadTemperature(); //»ñȡζÈÖµ 23.4 234 a=c/1000; //¼ÆËãµÃµ½Ê®Î»Êý×Ö a=2 b=c/100-a*10;//¼ÆËãµÃµ½¸öλÊý×Ö b=234/10-2*10=23-20=3 m=c/100; //¼ÆËãµÃµ½ÕûÊýλ m=234/10=23 n=c-a*1000-b*100;//¼ÆËãµÃµ½Ð¡Êýλ n=234-2*100-3*10=234-200-30=4 if(m<0){m=0;n=0;} //ÉèÖÃζÈÏÔʾÉÏÏÞ if(m>99){m=99;n=9;} //ÉèÖÃζÈÏÔʾÉÏÏÞ } /*****ÏÔʾ¿ª»ú³õʼ»¯µÈ´ý»­Ãæ*****/ void Disp_init(void) { P0 = ~0x80; //ÏÔʾ---- P2 = 0x00; Delay(800); } /*****ÏÔʾζÈ×Ó³ÌÐò*****/ void Disp_Temperature(void) //ÏÔʾÎÂ¶È { P0 = ~LEDData[n%10]; //ÏÔʾC P2 = 0x7F; Delay(100); P2=0xff; P0=~LEDData[n/10]; //ÏÔʾ¸öλ P2 = 0xDF; Delay(100); P2=0xff; P0 =~LEDData[m%10]; //ÏÔʾʮλ DIAN = 0; //ÏÔʾСÊýµã P2 = 0xF7; Delay(100); P2=0xff; P0 =~LEDData[m/10]; //ÏÔʾ°Ùλ P2 = 0xFD; Delay(100); P2 = 0xff; //¹Ø±ÕÏÔʾ } /*****ÏÔʾ±¨¾¯Î¶È×Ó³ÌÐò*****/ void Disp_alarm(uchar baojing) { P0 =~0x98; //ÏÔʾC P2 = 0x7F; Delay(100); P2=0xff; P0 =~LEDData[baojing%10]; //ÏÔʾʮλ P2 = 0xDF; Delay(100); P2=0xff; P0 =~LEDData[baojing/10]; //ÏÔʾ°Ùλ P2 = 0xF7; Delay(100); P2=0xff; if(set_st==1)P0 =~0xCE; else if(set_st==2)P0 =~0x1A; //ÉÏÏÞH¡¢ÏÂÏÞL±êʾ P2 = 0xFD; Delay(100); P2 = 0xff; //¹Ø±ÕÏÔʾ } /*****±¨¾¯×Ó³ÌÐò*****/ void Alarm() { if(x>=10){beep_st=~beep_st;x=0;} if(((m>=shangxian&&beep_st==1)||(m<xiaxian&&beep_st==1))&&shangxian!=xiaxian) { BEEP=0; ALAM=0; } else { BEEP=1; ALAM=1; } } /*****Ö÷º¯Êý*****/ void main(void) { if(SET==1) { P0=0x50; P2=0x7f; } else if(SET==0) { uint z; InitTimer(); //³õʼ»¯¶¨Ê±Æ÷ EA=1; //È«¾ÖÖжϿª¹Ø TR0=1; ET0=1; //¿ªÆô¶¨Ê±Æ÷0 IT0=1; IT1=1; check_wendu(); check_wendu(); for(z=0;z<300;z++) { Disp_init(); } while(1) { if(SET==0) { Delay(2000); do{}while(SET==0); set_st++;x=0;shanshuo_st=1; if(set_st>2)set_st=0; } if(set_st==0) { EX0=0; //¹Ø±ÕÍⲿÖжÏ0 EX1=0; //¹Ø±ÕÍⲿÖжÏ1 check_wendu(); Disp_Temperature(); Alarm(); //±¨¾¯¼ì²â } else if(set_st==1) { BEEP=1; //¹Ø±Õ·äÃùÆ÷ ALAM=1; EX0=1; //¿ªÆôÍⲿÖжÏ0 EX1=1; //¿ªÆôÍⲿÖжÏ1 if(x>=10){shanshuo_st=~shanshuo_st;x=0;} if(shanshuo_st) {Disp_alarm(shangxian);} } else if(set_st==2) { BEEP=1; //¹Ø±Õ·äÃùÆ÷ ALAM=1; EX0=1; //¿ªÆôÍⲿÖжÏ0 EX1=1; //¿ªÆôÍⲿÖжÏ1 if(x>=10){shanshuo_st=~shanshuo_st;x=0;} if(shanshuo_st) {Disp_alarm(xiaxian);} } } } } /*****¶¨Ê±Æ÷0ÖжϷþÎñ³ÌÐò*****/ void timer0(void) interrupt 1 { TH0=0x3c; TL0=0xb0; x++; } /*****ÍⲿÖжÏ0·þÎñ³ÌÐò*****/ void int0(void) interrupt 0 { EX0=0; //¹ØÍⲿÖжÏ0 if(DEC==0&&set_st==1) { do{ Disp_alarm(shangxian); } while(DEC==0); shangxian--; if(shangxian<xiaxian)shangxian=xiaxian; } else if(DEC==0&&set_st==2) { do{ Disp_alarm(xiaxian); } while(DEC==0); xiaxian--; if(xiaxian<0)xiaxian=0; } } /*****ÍⲿÖжÏ1·þÎñ³ÌÐò*****/ void int1(void) interrupt 2 { EX1=0; //¹ØÍⲿÖжÏ1 if(ADD==0&&set_st==1) { do{ Disp_alarm(shangxian); } while(ADD==0); shangxian++; if(shangxian>99)shangxian=99; } else if(ADD==0&&set_st==2) { do{ Disp_alarm(xiaxian); } while(ADD==0); xiaxian++; if(xiaxian>shangxian)xiaxian=shangxian; } } 编写一个相同功能的程序

/*µ¥Æ¬»ú¾§ÕñƵÂÊÑ¡ÓÃ11.0592MHZ*/ #include "stc15.h" //µ÷ÓÃstc15wµ¥Æ¬»úÍ·Îļþ #include "intrins.h" // #define uchar unsigned char // #define uint unsigned int // //////////////////////////////////IOÃû³Æ¶¨Òå sbit PWM1 = P2^1; //¶æ»ú1Êä³ö¶¨Òå //sbit PWM2 = P2^1; //¶æ»ú2Êä³ö¶¨Òå sbit IR_IN = P5^5; //ºìÍâ´«¸ÐÆ÷ÊäÈ붨Òå ¼ì²âµ½ÎïÌåÊä³öµÍµçƽ sbit RR = P7^3; //½»Í¨µÆºìµÆ¶¨Òå µÍµçÆ½µãÁÁ sbit YY = P7^2; //½»Í¨µÆ»ÆµÆ¶¨Òå µÍµçÆ½µãÁÁ sbit GG = P7^1; //½»Í¨µÆÂ̵ƶ¨Òå µÍµçÆ½µãÁÁ sbit beep = P4^0; //·äÃùÆ÷¶¨Òå ÓÐÔ´·äÃùµÈÓÚµÍµçÆ½·¢Éù //////////////////////////////////±äÁ¿¶¨Òå uint Servo1PwmDat = 750; //̧¸Ë =1700£¬Âä¸Ë = 750 Æô¶¯µ¥Æ¬»úʱ¶æ»úÂä¸ËλÖ㬣¨500-2500£©¶ÔÓ¦½Ç¶È0-180¶È uchar PC_dat; //½ÓÊÕµçÄÔ·¢Ë͹ýµÄ´æ´¢±äÁ¿ //////////////////////////////////ÑÓʱ×Ó³Ì void DelayMs(uint ms) { uint i,j; for(i=0;i<85;i++) for(j=0;j<ms;j++); } //////////////////////////////////´®¿Ú·¢ËÍ×Ó³ÌÐò£¨µ¥Æ¬»ú·¢ËÍÊ®Áù½øÖÆÊý¸øµçÄÔ£© void uart_fa(uchar dat) { SBUF = dat ; while(!TI); TI = 0; } /////////////////////////////////IO¿Ú¡¢¶¨Ê±Æ÷¡¢´®¿ÚͨѶ²¨ÌØÂʳõʼ»¯ void init() { //////////////////////////////////////////IO³õʼ»¯ P0M1 = 0x00; P0M0 = 0x00; //ÉèÖÃΪ׼˫Ïò¿Ú P1M1 = 0x00; P1M0 = 0x00; //ÉèÖÃΪ׼˫Ïò¿Ú P2M1 = 0x00; P2M0 = 0x00; //ÉèÖÃΪ׼˫Ïò¿Ú P3M1 = 0x00; P3M0 = 0x00; //ÉèÖÃΪ׼˫Ïò¿Ú P4M1 = 0x00; P4M0 = 0x00; //ÉèÖÃΪ׼˫Ïò¿Ú P5M1 = 0x00; P5M0 = 0x00; //ÉèÖÃΪ׼˫Ïò¿Ú /////////////////////////////////////////¶æ»úʹÓö¨Ê±Æ÷T0³õʼ TMOD &= 0xF0; //ÉèÖö¨Ê±Æ÷ģʽ TMOD |= 0x01; //ÉèÖö¨Ê±Æ÷ģʽ TL0 = 0x00; //ÉèÖö¨Ê±³õÖµ TH0 = 0x00; //ÉèÖö¨Ê±³õÖµ TF0 = 0; //Çå³ýTF0±êÖ¾ TR0 = 1; //¶¨Ê±Æ÷0¿ªÊ¼¼ÆÊ± E

//ÍøÂçÉ豸Çý¶¯ #include "esp8266.h" //Ó²¼þÇý¶¯ #include "delay.h" #include "oled.h" #include "led.h" //C¿â #include <string.h> #include <stdio.h> unsigned char esp8266_buf[buf_len]; unsigned char data_buf[buf_len]; unsigned short esp8266_cnt = 0; unsigned short esp8266_cntPre = 0; extern char Flagout; //========================================================== // º¯ÊýÃû³Æ£º ESP8266_Clear // // º¯Êý¹¦ÄÜ£º Çå¿Õ»º´æ // // Èë¿Ú²ÎÊý£º ÎÞ // // ·µ»Ø²ÎÊý£º ÎÞ // // ˵Ã÷£º //========================================================== void ESP8266_Clear(void) { memset(esp8266_buf, 0, sizeof(esp8266_buf)); esp8266_cnt = 0; } //========================================================== // º¯ÊýÃû³Æ£º ESP8266_Init // // º¯Êý¹¦ÄÜ£º ³õʼ»¯ESP8266 // // Èë¿Ú²ÎÊý£º ÎÞ // // ·µ»Ø²ÎÊý£º ÎÞ // // ˵Ã÷£º //========================================================= void ESP8266_Init(unsigned int bound) { #if Bamfa_USART1 //GPIO¶Ë¿ÚÉèÖà GPIO_InitTypeDef GPIO_InitStructure; USART_InitTypeDef USART_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE); //ʹÄÜUSART1£¬GPIOAʱÖÓ //USART1_TX GPIOA.9 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //¸´ÓÃÍÆÍìÊä³ö GPIO_Init(GPIOA, &GPIO_InitStructure);//³õʼ»¯GPIOA.9 //USART1_RX GPIOA.10³õʼ»¯ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//¸¡¿ÕÊäÈë GPIO_Init(GPIOA, &GPIO_InitStructure);//³õʼ»¯GPIOA.10 //Usart1 NVIC ÅäÖà NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//ÇÀÕ¼ÓÅÏȼ¶3 NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //×ÓÓÅÏȼ¶3 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQͨµÀʹÄÜ NVIC_Init(&NVIC_InitStructure); //¸ù¾ÝÖ¸¶¨µÄ²ÎÊý³õʼ»¯VIC¼Ä´æÆ÷ //USART ³õʼ»¯ÉèÖà USART_InitStructure.USART_BaudRate = bound;//´®¿Ú²¨ÌØÂÊ USART_InitStructure.USART_WordLength = USART_WordLength_8b;//×Ö³¤Îª8λÊý¾Ý¸ñʽ USART_InitStructure.USART_StopBits = USART_StopBits_1;//Ò»¸öֹͣλ USART_InitStructure.USART_Parity = USART_Parity_No;//ÎÞÆæÅ¼Ð£Ñéλ USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//ÎÞÓ²¼þÊý¾ÝÁ÷¿ØÖÆ USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //ÊÕ·¢Ä£Ê½ USART_Init(USART1, &USART_InitStructure); //³õʼ»¯´®¿Ú1 USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//¿ªÆô´®¿Ú½ÓÊÜÖÐ¶Ï USART_Cmd(USART1, ENABLE); //ʹÄÜ´®¿Ú1 #elif Bamfa_USART2 GPIO_InitTypeDef gpio_initstruct; USART_InitTypeDef usart_initstruct; NVIC_InitTypeDef nvic_initstruct; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); //PA2 TXD gpio_initstruct.GPIO_Mode = GPIO_Mode_AF_PP; gpio_initstruct.GPIO_Pin = GPIO_Pin_2; gpio_initstruct.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &gpio_initstruct); //PA3 RXD gpio_initstruct.GPIO_Mode = GPIO_Mode_IN_FLOATING; gpio_initstruct.GPIO_Pin = GPIO_Pin_3; gpio_initstruct.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &gpio_initstruct); usart_initstruct.USART_BaudRate = bound; usart_initstruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None; //ÎÞÓ²¼þÁ÷¿Ø usart_initstruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //½ÓÊպͷ¢ËÍ usart_initstruct.USART_Parity = USART_Parity_No; //ÎÞУÑé usart_initstruct.USART_StopBits = USART_StopBits_1; //1λֹͣλ usart_initstruct.USART_WordLength = USART_WordLength_8b; //8λÊý¾Ýλ USART_Init(USART2, &usart_initstruct); USART_Cmd(USART2, ENABLE); //ʹÄÜ´®¿Ú USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); //ʹÄܽÓÊÕÖÐ¶Ï nvic_initstruct.NVIC_IRQChannel = USART2_IRQn; nvic_initstruct.NVIC_IRQChannelCmd = ENABLE; nvic_initstruct.NVIC_IRQChannelPreemptionPriority = 1; nvic_initstruct.NVIC_IRQChannelSubPriority = 0; NVIC_Init(&nvic_initstruct); #elif Bamfa_USART3 NVIC_InitTypeDef NVIC_InitStructure; GPIO_InitTypeDef GPIO_InitStructure; USART_InitTypeDef USART_InitStructure; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); // GPIOBʱÖÓ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE); USART_DeInit(USART3); //¸´Î»´®? //USART2_TX PB10 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //PB10 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //¸´ÓÃÍÆÍìÊä³ö GPIO_Init(GPIOB, &GPIO_InitStructure); //³õʼ»¯PB10 //USART3_RX PB11 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//¸¡¿ÕÊäÈë GPIO_Init(GPIOB, &GPIO_InitStructure); //³õʼ»¯PB11 USART_InitStructure.USART_BaudRate = bound;//Ò»°ãÉèÖÃΪ9600; USART_InitStructure.USART_WordLength = USART_WordLength_8b;//×Ö³¤Îª8λÊý¾Ý¸ñʽ USART_InitStructure.USART_StopBits = USART_StopBits_1;//Ò»¸öֹͣλ USART_InitStructure.USART_Parity = USART_Parity_No;//ÎÞÆæÅ¼Ð£Ñéλ USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//ÎÞÓ²¼þÊý¾ÝÁ÷¿ØÖÆ USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //ÊÕ·¢Ä£Ê½ USART_Init(USART3, &USART_InitStructure); //³õʼ»¯´®¿Ú 3 USART_Cmd(USART3, ENABLE); //ʹÄÜ´®¿Ú //ʹÄܽÓÊÕÖÐ¶Ï USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//¿ªÆôÖÐ¶Ï NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1 ;//ÇÀÕ¼ÓÅÏȼ¶2 NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //×ÓÓÅÏȼ¶0 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQͨµÀʹÄÜ NVIC_Init(&NVIC_InitStructure); //¸ù¾ÝÖ¸¶¨µÄ²ÎÊý³õʼ»¯VIC¼Ä´æÆ÷ #endif GPIO_InitTypeDef GPIO_InitStructure; RCC_APB2PeriphClockCmd(ESP01S_RST_RCC_CLK, ENABLE); //ʹÄÜA¶Ë¿ÚʱÖÓ GPIO_InitStructure.GPIO_Pin = ESP01S_RST_PIN; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //ÍÆÍìÊä³ö GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//ËÙ¶È50MHz GPIO_Init(ESP01S_RST_PROT, &GPIO_InitStructure); //³õʼ»¯GPIOA GPIO_ResetBits(ESP01S_RST_PROT,ESP01S_RST_PIN);//esp8266µÍµçƽ¸´Î» delay_ms(200); GPIO_SetBits(ESP01S_RST_PROT,ESP01S_RST_PIN); ESP8266_Clear(); OLED_ShowCHinese(0, 3,15);//Õý OLED_ShowCHinese(18,3,16);//ÔÚ OLED_ShowCHinese(36,3,17);//Á¬ OLED_ShowCHinese(54,3,18);//½Ó OLED_ShowString (72,3,"WIFI",16); OLED_ShowString (108,3,"..",16); OLED_ShowCHinese(0, 6, 19);//½ø OLED_ShowCHinese(18,6, 20);//¶È OLED_ShowCHinese(36,6,21);//£º // printf("1. AT\r\n"); OLED_ShowString(44,6,"10%",16); while(ESP8266_SendCmd("AT\r\n","OK")&&Flagout) delay_ms(100); // printf("2. CWMODE\r\n"); OLED_ShowString(44,6,"20%",16); while(ESP8266_SendCmd("AT+CWMODE=3\r\n", "OK")&&Flagout) delay_ms(100); // printf( "3. Á¬½Ó·ÓÉÆ÷¡£\r\n"); OLED_ShowString(44,6,"30%",16); while(ESP8266_SendCmd(ESP8266_WIFI_INFO, "OK")&&Flagout) delay_ms(100); // printf("4. ¿ªÆô͸Ã÷´«Êäģʽ¡£\r\n"); OLED_ShowString(44,6,"30%",16); while(ESP8266_SendCmd("AT+CIPMODE=1\r\n", "OK")&&Flagout) delay_ms(100); // printf( "5. Á¬½Ó°Í·¨ÔÆ¡£\r\n"); OLED_ShowString(44,6,"50%",16); while(ESP8266_SendCmd(ESP8266_ONENET_INFO, "CONNECT")&&Flagout) delay_ms(100); // printf( "6. ½øÈë͸´«Ä£Ê½£¬ÏÂÃæ·¢µÄ¶¼»áÎÞÌõ¼þ´«Êä¡£\r\n"); OLED_ShowString(44,6,"80%",16); while(ESP8266_SendCmd("AT+CIPSEND\r\n", "OK")&&Flagout) delay_ms(100); // printf( "7.¶©ÔÄÖ÷Ìâ¡£\r\n"); OLED_ShowString(44,6,"90%",16); while(ESP8266_SendCmd(ESP8266_TOPIC, "cmd=1&res=1")&&Flagout) delay_ms(100); Flagout=3; // printf("8. ESP8266 ³õʼ»¯Íê³É£¡\r\n"); OLED_ShowString(44,6,"100%",16); Flagout=0; delay_ms(2000); ESP8266_Clear(); OLED_Clear(0); } //========================================================== // º¯ÊýÃû³Æ£º ESP8266_WaitRecive // // º¯Êý¹¦ÄÜ£º µÈ´ý½ÓÊÕÍê³É // // Èë¿Ú²ÎÊý£º ÎÞ // // ·µ»Ø²ÎÊý£º REV_OK-½ÓÊÕÍê³É REV_WAIT-½ÓÊÕ³¬Ê±Î´Íê³É // // ˵Ã÷£º Ñ­»·µ÷Óüì²âÊÇ·ñ½ÓÊÕÍê³É //========================================================== _Bool ESP8266_WaitRecive(void) { if(esp8266_cnt == 0) //Èç¹û½ÓÊÕ¼ÆÊýΪ0 Ôò˵Ã÷ûÓд¦ÓÚ½ÓÊÕÊý¾ÝÖУ¬ËùÒÔÖ±½ÓÌø³ö£¬½áÊøº¯Êý return REV_WAIT; if(esp8266_cnt == esp8266_cntPre) //Èç¹ûÉÏÒ»´ÎµÄÖµºÍÕâ´ÎÏàͬ£¬Ôò˵Ã÷½ÓÊÕÍê±Ï { esp8266_cnt = 0; //Çå0½ÓÊÕ¼ÆÊý return REV_OK; //·µ»Ø½ÓÊÕÍê³É±êÖ¾ } esp8266_cntPre = esp8266_cnt; //ÖÃΪÏàͬ return REV_WAIT; //·µ»Ø½ÓÊÕδÍê³É±êÖ¾ } /************************************************************ * º¯ÊýÃû³Æ£º Usart_SendString * * º¯Êý¹¦ÄÜ£º ´®¿ÚÊý¾Ý·¢ËÍ * * Èë¿Ú²ÎÊý£º USARTx£º´®¿Ú×é * str£ºÒª·¢Ë͵ÄÊý¾Ý * len£ºÊý¾Ý³¤¶È * * ·µ»Ø²ÎÊý£º ÎÞ * * ˵Ã÷£º ************************************************************ */ void Usart_SendString(USART_TypeDef *USARTx, unsigned char *str, unsigned short len) { unsigned short count = 0; for(; count < len; count++) { USART_SendData(USARTx, *str++); //·¢ËÍÊý¾Ý while(USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET); //µÈ´ý·¢ËÍÍê³É } } //========================================================== // º¯ÊýÃû³Æ£º ESP8266_SendCmd // // º¯Êý¹¦ÄÜ£º ·¢ËÍÃüÁî // // Èë¿Ú²ÎÊý£º cmd£ºÃüÁî // res£ºÐèÒª¼ì²éµÄ·µ»ØÖ¸Áî // // ·µ»Ø²ÎÊý£º 0-³É¹¦ 1-ʧ°Ü // // ˵Ã÷£º //========================================================== _Bool ESP8266_SendCmd(char *cmd, char *res) { unsigned char timeOut = 200; Usart_SendString(Bamfa_USART, (unsigned char *)cmd, strlen((const char *)cmd)); while(timeOut--) { if(ESP8266_WaitRecive() == REV_OK) //Èç¹ûÊÕµ½Êý¾Ý { if(strstr((const char *)esp8266_buf, res) != NULL) //Èç¹û¼ìË÷µ½¹Ø¼ü´Ê { ESP8266_Clear(); //Çå¿Õ»º´æ return 0; } } delay_ms(10); } return 1; } //========================================================== // º¯ÊýÃû³Æ£º ESP8266_SendData // // º¯Êý¹¦ÄÜ£º ·¢ËÍÊý¾Ý // // Èë¿Ú²ÎÊý£º data£ºÊý¾Ý // len£º³¤¶È // // ·µ»Ø²ÎÊý£º ÎÞ // // ˵Ã÷£º //========================================================== void ESP8266_SendData(unsigned char *data) { ESP8266_Clear(); //Çå¿Õ½ÓÊÕ»º´æ Usart_SendString(Bamfa_USART, (unsigned char *)data, strlen((const char *)data)); //·¢ËÍÉ豸Á¬½ÓÇëÇóÊý¾Ý } //========================================================== // º¯ÊýÃû³Æ£º USART2_IRQHandler // // º¯Êý¹¦ÄÜ£º ´®¿Ú2ÊÕ·¢ÖÐ¶Ï // // Èë¿Ú²ÎÊý£º ÎÞ // // ·µ»Ø²ÎÊý£º ÎÞ // // ˵Ã÷£º //========================================================== #if Bamfa_USART1 void USART1_IRQHandler(void) { if(USART_GetITStatus(Bamfa_USART, USART_IT_RXNE) != RESET) //½ÓÊÕÖÐ¶Ï { if(esp8266_cnt >= sizeof(esp8266_buf)) esp8266_cnt = 0; //·ÀÖ¹´®¿Ú±»Ë¢±¬ esp8266_buf[esp8266_cnt++] = USART_ReceiveData(Bamfa_USART); } USART_ClearFlag(Bamfa_USART, USART_FLAG_RXNE); } #elif Bamfa_USART2 void USART2_IRQHandler(void) { if(USART_GetITStatus(Bamfa_USART, USART_IT_RXNE) != RESET) //½ÓÊÕÖÐ¶Ï { if(esp8266_cnt >= sizeof(esp8266_buf)) esp8266_cnt = 0; //·ÀÖ¹´®¿Ú±»Ë¢±¬ esp8266_buf[esp8266_cnt++] = USART_ReceiveData(Bamfa_USART); } USART_ClearFlag(Bamfa_USART, USART_FLAG_RXNE); } #elif Bamfa_USART3 void USART3_IRQHandler(void) { if(USART_GetITStatus(Bamfa_USART, USART_IT_RXNE) != RESET) //½ÓÊÕÖÐ¶Ï { if(esp8266_cnt >= sizeof(esp8266_buf)) esp8266_cnt = 0; //·ÀÖ¹´®¿Ú±»Ë¢±¬ esp8266_buf[esp8266_cnt++] = USART_ReceiveData(Bamfa_USART); } USART_ClearFlag(Bamfa_USART, USART_FLAG_RXNE); } #endif 帮我根据以上代码生成流程框图

#include "control.h" #include "Lidar.h" float Move_X = 0, Move_Z = 0; // Ä¿±êËٶȺÍÄ¿±êתÏòËÙ¶È float PWM_Left, PWM_Right; // ×óÓÒµç»úPWMÖµ float RC_Velocity, RC_Turn_Velocity; // Ò£¿Ø¿ØÖƵÄËÙ¶È u8 Mode = Normal_Mode; // ģʽѡÔñ£¬Ä¬ÈÏÊÇÆÕͨµÄ¿ØÖÆÄ£Ê½ Motor_parameter MotorA, MotorB; // ×óÓÒµç»úÏà¹Ø±äÁ¿ int Servo_PWM = SERVO_INIT; // °¢¿ËÂü¶æ»úÏà¹Ø±äÁ¿ u8 Lidar_Detect = Lidar_Detect_ON; // µç´ÅѲÏßģʽÀ×´ï¼ì²âÕϰ­ÎĬÈÏ¿ªÆô float CCD_Move_X = 0.3; // CCDѲÏßËÙ¶È float ELE_Move_X = 0.3; // µç´ÅѲÏßËÙ¶È u8 Ros_count = 0, Lidar_flag_count = 0; u8 cnt = 0; Encoder OriginalEncoder; // Encoder raw data //±àÂëÆ÷ԭʼÊý¾Ý short Accel_Y, Accel_Z, Accel_X, Accel_Angle_x, Accel_Angle_y, Gyro_X, Gyro_Z, Gyro_Y; int forward_cnt = 800; int left_cnt = 120; int right_cnt = 125; int stop_cnt = 200; int stop_flag = 0; int mode_cnt = 0; int state_cnt = 0; int stop_protect = 0; /************************************************************************** Function: Control Function Input : none Output : none º¯Êý¹¦ÄÜ£º5ms¶¨Ê±ÖжϿØÖƺ¯Êý Èë¿Ú²ÎÊý: ÎÞ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ void forward(){ MotorA.Motor_Pwm = 1999; MotorB.Motor_Pwm = 2040; } void left(){ MotorA.Motor_Pwm = 0; MotorB.Motor_Pwm = 2050; } void right(){ MotorA.Motor_Pwm = 1999; MotorB.Motor_Pwm = 0; } void stop(){ MotorA.Motor_Pwm = 0; MotorB.Motor_Pwm = 0; } void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) { if (htim == &htim5) { Get_KeyVal(); if(mode_cnt == 0) stop(); //ģʽһ if(mode_cnt == 1){ if(forward_cnt > 0){ forward(); forward_cnt--; // if(left_cnt > 0){ // left(); // left_cnt--; // if(right_cnt > 0){ // right(); // right_cnt--; } else{ stop(); } } //ģʽ¶þ else if(mode_cnt == 2){ if(forward_cnt > 0){ forward(); forward_cnt--; } else if(stop_cnt > 0 && forward_cnt == 0){ stop(); stop_cnt--; } else if(stop_cnt == 0 && stop_flag == 0){ forward_cnt = 800; stop_flag = 1; } else{ stop(); } } //ģʽÈý else if(mode_cnt == 3){ if(forward_cnt > 0 && state_cnt == 0){//µÚ1״̬£ºÖ±ÐÐ forward(); forward_cnt--; } else if(right_cnt > 0 && state_cnt == 1){//µÚ2״̬£ºÓÒת right(); right_cnt--; } else if(forward_cnt > 0 && state_cnt == 2){//µÚ3״̬£ºÖ±ÐÐ forward(); forward_cnt--; } else if(left_cnt > 0 && state_cnt == 3){//µÚ4״̬£º×óת left(); left_cnt--; } else if(forward_cnt > 0 && state_cnt == 4){//µÚ5״̬£ºÖ±ÐÐ forward(); forward_cnt--; } else if(left_cnt > 0 && state_cnt == 5){//µÚ6״̬£º×óת left(); left_cnt--; } else if(forward_cnt > 0 && state_cnt == 6){//µÚ7״̬£ºÖ±ÐÐ forward(); forward_cnt--; } else{ if(stop_protect == 0 && stop_cnt == 0){ stop_cnt = 100; stop_protect = 1; } else if(stop_cnt > 0){ stop(); stop_cnt--; } else if(stop_protect == 1 && stop_cnt == 0){ stop_protect = 0; if(state_cnt == 0){//״̬1Çл»×´Ì¬2 state_cnt++; right_cnt = 125; } else if(state_cnt == 1){//״̬2Çл»×´Ì¬3 state_cnt++; forward_cnt = 585; } else if(state_cnt == 2){//״̬3Çл»×´Ì¬4 state_cnt++; left_cnt = 120; } else if(state_cnt == 3){//״̬4Çл»×´Ì¬5 state_cnt++; forward_cnt = 585; } else if(state_cnt == 4){//״̬5Çл»×´Ì¬6 state_cnt++; left_cnt = 120; } else if(state_cnt == 5){//״̬6Çл»×´Ì¬7 state_cnt++; forward_cnt = 585; } } } } Set_Pwm(-MotorA.Motor_Pwm, MotorB.Motor_Pwm); // Çý¶¯µç»ú } } /************************************************************************** Function: Bluetooth_Control Input : none Output : none º¯Êý¹¦ÄÜ£ºÊÖ»úÀ¶ÑÀ¿ØÖÆ Èë¿Ú²ÎÊý: ÎÞ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ void Bluetooth_Control(void) { if (Flag_Direction == 0) Move_X = 0, Move_Z = 0; // Í£Ö¹ else if (Flag_Direction == 1) Move_X = RC_Velocity, Move_Z = 0; // ǰ½ø else if (Flag_Direction == 2) Move_X = RC_Velocity, Move_Z = Pi / 2; // ÓÒǰ else if (Flag_Direction == 3) Move_X = 0, Move_Z = Pi / 2; // ÏòÓÒ else if (Flag_Direction == 4) Move_X = -RC_Velocity, Move_Z = Pi / 2; // ÓÒºó else if (Flag_Direction == 5) Move_X = -RC_Velocity, Move_Z = 0; // ºóÍË else if (Flag_Direction == 6) Move_X = -RC_Velocity, Move_Z = -Pi / 2; // ×óºó else if (Flag_Direction == 7) Move_X = 0, Move_Z = -Pi / 2; // Ïò×ó else if (Flag_Direction == 8) Move_X = RC_Velocity, Move_Z = -Pi / 2; // ×óǰ else Move_X = 0, Move_Z = 0; if (Car_Num == Akm_Car) { // Ackermann structure car is converted to the front wheel steering Angle system target value, and kinematics analysis is pearformed // °¢¿ËÂü½á¹¹Ð¡³µ×ª»»ÎªÇ°ÂÖתÏò½Ç¶È Move_Z = Move_Z * 2 / 10; } Move_X = Move_X / 1000; Move_Z = -Move_Z; // ת»»ÎªËÙ¶ÈתΪm/s } /************************************************************************** Function: PS2_Control Input : none Output : none º¯Êý¹¦ÄÜ£ºPS2ÊÖ±ú¿ØÖÆ Èë¿Ú²ÎÊý: ÎÞ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ void PS2_Control(void) { int LY, RX; // ÊÖ±úADCµÄÖµ int Threshold = 20; // ãÐÖµ£¬ºöÂÔÒ¡¸ËС·ù¶È¶¯×÷ static u8 Key1_Count = 0, Key2_Count = 0; // ÓÃÓÚ¿ØÖƶÁȡҡ¸ËµÄËÙ¶È // ת»¯Îª128µ½-128µÄÊýÖµ LY = -(PS2_LY - 128); // ×ó±ßYÖá¿ØÖÆÇ°½øºóÍË RX = -(PS2_RX - 128); // ÓÒ±ßXÖá¿ØÖÆ×ªÏò if (LY > -Threshold && LY < Threshold) LY = 0; if (RX > -Threshold && RX < Threshold) RX = 0; // ºöÂÔÒ¡¸ËС·ù¶È¶¯×÷ Move_X = (RC_Velocity / 128) * LY; // ËÙ¶È¿ØÖÆ£¬Á¦¶È±íʾËÙ¶È´óС if (Car_Num == Akm_Car) // °¢¿ËÂü³µ×ªÏò¿ØÖÆ£¬Á¦¶È±íʾתÏò½Ç¶È Move_Z = -(RC_Turn_Velocity / 128) * RX; else // ÆäËû³µÐÍתÏò¿ØÖÆ { if (Move_X >= 0) Move_Z = -(RC_Turn_Velocity / 128) * RX; // תÏò¿ØÖÆ£¬Á¦¶È±íʾתÏòËÙ¶È else Move_Z = (RC_Turn_Velocity / 128) * RX; } if (PS2_KEY == PSB_L1) // °´ÏÂ×ó1¼ü¼ÓËÙ£¨°´¼üÔÚ¶¥ÉÏ£© { if ((++Key1_Count) == 20) // µ÷½Ú°´¼ü·´Ó¦ËÙ¶È { PS2_KEY = 0; Key1_Count = 0; if ((RC_Velocity += X_Step) > MAX_RC_Velocity) // ǰ½ø×î´óËÙ¶È800mm/s RC_Velocity = MAX_RC_Velocity; if (Car_Num != Akm_Car) // ·Ç°¢¿ËÂü³µ¿Éµ÷½ÚתÏòËÙ¶È { if ((RC_Turn_Velocity += Z_Step) > MAX_RC_Turn_Bias) // תÏò×î´óËÙ¶È325 RC_Turn_Velocity = MAX_RC_Turn_Bias; } } } else if (PS2_KEY == PSB_R1) // °´ÏÂÓÒ1¼ü¼õËÙ { if ((++Key2_Count) == 20) { PS2_KEY = 0; Key2_Count = 0; if ((RC_Velocity -= X_Step) < MINI_RC_Velocity) // ǰºó×îСËÙ¶È210mm/s RC_Velocity = MINI_RC_Velocity; if (Car_Num != Akm_Car) // ·Ç°¢¿ËÂü³µ¿Éµ÷½ÚתÏòËÙ¶È { if ((RC_Turn_Velocity -= Z_Step) < MINI_RC_Turn_Velocity) // תÏò×îСËÙ¶È45 RC_Turn_Velocity = MINI_RC_Turn_Velocity; } } } else Key2_Count = 0, Key2_Count = 0; // ¶ÁÈ¡µ½ÆäËû°´¼üÖØÐ¼ÆÊý Move_X = Move_X / 1000; Move_Z = -Move_Z; // ËÙ¶ÈMove_XתΪm/s } /************************************************************************** Function: Get_Velocity_From_Encoder Input : none Output : none º¯Êý¹¦ÄÜ£º¶ÁÈ¡±àÂëÆ÷ºÍת»»³ÉËÙ¶È Èë¿Ú²ÎÊý: ÎÞ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ void Get_Velocity_From_Encoder(void) { // Retrieves the original data of the encoder // »ñÈ¡±àÂëÆ÷µÄԭʼÊý¾Ý float Encoder_A_pr, Encoder_B_pr; OriginalEncoder.A = Read_Encoder(Encoder1); OriginalEncoder.B = Read_Encoder(Encoder2); // Decide the encoder numerical polarity according to different car models // ¸ù¾Ý²»Í¬Ð¡³µÐͺžö¶¨±àÂëÆ÷ÊýÖµ¼«ÐÔ switch (Car_Num) { case Akm_Car: Encoder_A_pr = OriginalEncoder.A; Encoder_B_pr = -OriginalEncoder.B; break; case Diff_Car: Encoder_A_pr = OriginalEncoder.A; Encoder_B_pr = -OriginalEncoder.B; break; case Small_Tank_Car: Encoder_A_pr = OriginalEncoder.A; Encoder_B_pr = -OriginalEncoder.B; break; case Big_Tank_Car: Encoder_A_pr = OriginalEncoder.A; Encoder_B_pr = -OriginalEncoder.B; break; } // The encoder converts the raw data to wheel speed in m/s // ±àÂëÆ÷ԭʼÊý¾Ýת»»Îª³µÂÖËÙ¶È£¬µ¥Î»m/s MotorA.Current_Encoder = Encoder_A_pr * Frequency * Perimeter / 60000.0f; // 60000 = 4*500*30 MotorB.Current_Encoder = Encoder_B_pr * Frequency * Perimeter / 60000.0f; // 1560=4*13*30=2£¨Á½Â·Âö³å£©*2£¨ÉÏÏÂÑØ¼ÆÊý£©*»ô¶û±àÂëÆ÷13Ïß*µç»úµÄ¼õËÙ±È // MotorA.Current_Encoder= Encoder_A_pr*CONTROL_FREQUENCY*Akm_wheelspacing//(4*13*30); // MotorB.Current_Encoder= Encoder_B_pr*CONTROL_FREQUENCY*Akm_wheelspacing/Encoder_precision; } /************************************************************************** Function: Drive_Motor Input : none Output : none º¯Êý¹¦ÄÜ£ºÔ˶¯Ñ§Äæ½â Èë¿Ú²ÎÊý: ÎÞ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ // Ô˶¯Ñ§Äæ½â£¬ÓÉxºÍyµÄËٶȵõ½±àÂëÆ÷µÄËÙ¶È,VxÊÇm/s,Vzµ¥Î»ÊǶÈ/s(½Ç¶ÈÖÆ) // °¢¿ËÂü³µVzÊǶæ»úתÏòµÄ½Ç¶È(»¡¶ÈÖÆ) void Get_Target_Encoder(float Vx, float Vz) { float MotorA_Velocity, MotorB_Velocity; float amplitude = 3.5f; // Wheel target speed limit //³µÂÖÄ¿±êËÙ¶ÈÏÞ·ù Move_X = target_limit_float(Move_X, -1.2, 1.2); Move_Z = target_limit_float(Move_Z, -Pi / 3, Pi / 3); if (Car_Num == Akm_Car) // °¢¿ËÂü³µ { // Ackerman car specific related variables //°¢¿ËÂüС³µ×¨ÓÃÏà¹Ø±äÁ¿ float R, ratio = 636.56, AngleR, Angle_Servo; // For Ackerman small car, Vz represents the front wheel steering Angle // ¶ÔÓÚ°¢¿ËÂüС³µVz´ú±íÓÒǰÂÖתÏò½Ç¶È AngleR = Vz; R = Akm_axlespacing / tan(AngleR) - 0.5f * Wheelspacing; // Front wheel steering Angle limit (front wheel steering Angle controlled by steering engine), unit: rad // ǰÂÖתÏò½Ç¶ÈÏÞ·ù(¶æ»ú¿ØÖÆÇ°ÂÖתÏò½Ç¶È)£¬µ¥Î»£ºrad AngleR = target_limit_float(AngleR, -0.49f, 0.32f); // Inverse kinematics //Ô˶¯Ñ§Äæ½â if (AngleR != 0) { MotorA.Target_Encoder = Vx * (R - 0.081f) / R; MotorB.Target_Encoder = Vx * (R + 0.081f) / R; } else { MotorA.Target_Encoder = Vx; MotorB.Target_Encoder = Vx; } // The PWM value of the servo controls the steering Angle of the front wheel // ¶æ»úPWMÖµ£¬¶æ»ú¿ØÖÆÇ°ÂÖתÏò½Ç¶È Angle_Servo = -0.628f * pow(AngleR, 3) + 1.269f * pow(AngleR, 2) - 1.772f * AngleR + 1.573f; Servo_PWM = SERVO_INIT + (Angle_Servo - 1.572f) * ratio; // printf("%d\r\n",Servo_PWM); // Wheel (motor) target speed limit //³µÂÖ(µç»ú)Ä¿±êËÙ¶ÈÏÞ·ù MotorA.Target_Encoder = target_limit_float(MotorA.Target_Encoder, -amplitude, amplitude); MotorB.Target_Encoder = target_limit_float(MotorB.Target_Encoder, -amplitude, amplitude); Servo_PWM = target_limit_int(Servo_PWM, 800, 2200); // Servo PWM value limit //¶æ»úPWMÖµÏÞ·ù } else if (Car_Num == Diff_Car) // ²îËÙС³µ { if (Vx < 0) Vz = -Vz; else Vz = Vz; // Inverse kinematics //Ô˶¯Ñ§Äæ½â MotorA.Target_Encoder = Vx - Vz * Wheelspacing / 2.0f; // ¼ÆËã³ö×óÂÖµÄÄ¿±êËÙ¶È MotorB.Target_Encoder = Vx + Vz * Wheelspacing / 2.0f; // ¼ÆËã³öÓÒÂÖµÄÄ¿±êËÙ¶È // Wheel (motor) target speed limit //³µÂÖ(µç»ú)Ä¿±êËÙ¶ÈÏÞ·ù MotorA.Target_Encoder = target_limit_float(MotorA.Target_Encoder, -amplitude, amplitude); MotorB.Target_Encoder = target_limit_float(MotorB.Target_Encoder, -amplitude, amplitude); } else if (Car_Num == Small_Tank_Car) { if (Vx < 0) Vz = -Vz; else Vz = Vz; MotorA.Target_Encoder = Vx - Vz * Wheelspacing / 2.0f; // ¼ÆËã³ö×óÂÖµÄÄ¿±êËÙ¶È MotorB.Target_Encoder = Vx + Vz * Wheelspacing / 2.0f; // ¼ÆËã³öÓÒÂÖµÄÄ¿±êËÙ¶È // Wheel (motor) target speed limit //³µÂÖ(µç»ú)Ä¿±êËÙ¶ÈÏÞ·ù MotorA.Target_Encoder = target_limit_float(MotorA.Target_Encoder, -amplitude, amplitude); MotorB.Target_Encoder = target_limit_float(MotorB.Target_Encoder, -amplitude, amplitude); } else if (Car_Num == Big_Tank_Car) { if (Vx < 0) Vz = -Vz; else Vz = Vz; MotorA.Target_Encoder = Vx - Vz * Wheelspacing / 2.0f; // ¼ÆËã³ö×óÂÖµÄÄ¿±êËÙ¶È MotorB.Target_Encoder = Vx + Vz * Wheelspacing / 2.0f; // ¼ÆËã³öÓÒÂÖµÄÄ¿±êËÙ¶È MotorA.Target_Encoder = target_limit_float(MotorA.Target_Encoder, -amplitude, amplitude); MotorB.Target_Encoder = target_limit_float(MotorB.Target_Encoder, -amplitude, amplitude); } } /************************************************************************** Function: Get_Motor_PWM Input : none Output : none º¯Êý¹¦ÄÜ£º×ª»»³ÉÇý¶¯µç»úµÄPWM Èë¿Ú²ÎÊý: ÎÞ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ void Get_Motor_PWM(void) { // ¼ÆËã×óÓÒµç»ú¶ÔÓ¦µÄPWM MotorA.Motor_Pwm = Incremental_PI_Left(MotorA.Current_Encoder, MotorA.Target_Encoder); MotorB.Motor_Pwm = Incremental_PI_Right(MotorB.Current_Encoder, MotorB.Target_Encoder); if (Mode == Normal_Mode || Mode == Measure_Distance_Mode) { // Â˲¨£¬Ê¹Æð²½ºÍÍ£Ö¹ÉÔ΢ƽ»¬Ò»Ð© MotorA.Motor_Pwm = Mean_Filter_Left(MotorA.Motor_Pwm); MotorB.Motor_Pwm = Mean_Filter_Right(MotorB.Motor_Pwm); } // ÏÞ·ù MotorA.Motor_Pwm = PWM_Limit(MotorA.Motor_Pwm, PWM_MAX, PWM_MIN); MotorB.Motor_Pwm = PWM_Limit(MotorB.Motor_Pwm, PWM_MAX, PWM_MIN); } /************************************************************************** Function: PWM_Limit Input : IN;max;min Output : OUT º¯Êý¹¦ÄÜ£ºÏÞÖÆPWM¸³Öµ Èë¿Ú²ÎÊý: IN£ºÊäÈë²ÎÊý max£ºÏÞ·ù×î´óÖµ min£ºÏÞ·ù×îСֵ ·µ»Ø Öµ£ºÏÞ·ùºóµÄÖµ **************************************************************************/ float PWM_Limit(float IN, int max, int min) { float OUT = IN; if (OUT > max) OUT = max; if (OUT < min) OUT = min; return OUT; } /************************************************************************** Function: Limiting function Input : Value Output : none º¯Êý¹¦ÄÜ£ºÏÞ·ùº¯Êý Èë¿Ú²ÎÊý£º·ùÖµ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ float target_limit_float(float insert, float low, float high) { if (insert < low) return low; else if (insert > high) return high; else return insert; } int target_limit_int(int insert, int low, int high) { if (insert < low) return low; else if (insert > high) return high; else return insert; } /************************************************************************** Function: Check whether it is abnormal Input : none Output : 1:Abnormal;0:Normal º¯Êý¹¦ÄÜ£ºÒì³£¹Ø±Õµç»ú Èë¿Ú²ÎÊý: ÎÞ ·µ»Ø Öµ£º1£ºÒì³£ 0£ºÕý³£ **************************************************************************/ u8 Turn_Off(void) { u8 temp = Normal; Flag_Stop = KEY2_STATE; // ¶ÁÈ¡°´¼ü2״̬£¬°´¼ü2¿ØÖƵç»úµÄ¿ª¹Ø if (Voltage < 1000) // µç³ØµçѹµÍÓÚ10V¹Ø±Õµç»ú,LEDµÆ¿ìËÙÉÁ˸ LED_Flash(50), temp = Abnormal; else LED_Flash(200); // ÿһÃëÉÁÒ»´Î£¬Õý³£ÔËÐÐ if (Flag_Stop) temp = Abnormal; return temp; } /************************************************************************** Function: Data sliding filtering Input : data Output : Filtered data º¯Êý¹¦ÄÜ£ºÊý¾Ý»¬¶¯Â˲¨ Èë¿Ú²ÎÊý£ºÊý¾Ý ·µ»Ø Öµ£ºÂ˲¨ºóµÄÊý¾Ý **************************************************************************/ float Mean_Filter_Left(float data) { u8 i; float Sum_Data = 0; float Filter_Data; static float Speed_Buf[FILTERING_TIMES] = {0}; for (i = 1; i < FILTERING_TIMES; i++) { Speed_Buf[i - 1] = Speed_Buf[i]; } Speed_Buf[FILTERING_TIMES - 1] = data; for (i = 0; i < FILTERING_TIMES; i++) { Sum_Data += Speed_Buf[i]; } Filter_Data = (s32)(Sum_Data / FILTERING_TIMES); return Filter_Data; } /************************************************************************** Function: Data sliding filtering Input : data Output : Filtered data º¯Êý¹¦ÄÜ£ºÊý¾Ý»¬¶¯Â˲¨ Èë¿Ú²ÎÊý£ºÊý¾Ý ·µ»Ø Öµ£ºÂ˲¨ºóµÄÊý¾Ý **************************************************************************/ float Mean_Filter_Right(float data) { u8 i; float Sum_Data = 0; float Filter_Data; static float Speed_Buf[FILTERING_TIMES] = {0}; for (i = 1; i < FILTERING_TIMES; i++) { Speed_Buf[i - 1] = Speed_Buf[i]; } Speed_Buf[FILTERING_TIMES - 1] = data; for (i = 0; i < FILTERING_TIMES; i++) { Sum_Data += Speed_Buf[i]; } Filter_Data = (s32)(Sum_Data / FILTERING_TIMES); return Filter_Data; } /************************************************************************** Function: Lidar_Avoid Input : none Output : none º¯Êý¹¦ÄÜ£ºÀ×´ï±ÜÕÏģʽ Èë¿Ú²ÎÊý£ºÎÞ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ void Lidar_Avoid(void) { int i = 0; u8 calculation_angle_cnt = 0; // ÓÃÓÚÅжÏ100¸öµãÖÐÐèÒª×ö±ÜÕϵĵã float angle_sum = 0; // ´ÖÂÔ¼ÆËãÕϰ­ÎïλÓÚ×ó»òÕßÓÒ u8 distance_count = 0; // ¾àÀëСÓÚijֵµÄ¼ÆÊý int distance = 350; // É趨±ÜÕϾàÀë,ĬÈÏÊÇ300 if (Car_Num == Akm_Car) distance = 400; // °¢¿ËÂü³µÉ趨ÊÇ400mm else if (Car_Num == Big_Tank_Car) distance = 500; // ´óÂÄ´ø³µÉ趨ÊÇ500mm for (i = 0; i < lap_count; i++) { if ((Dataprocess[i].angle > 310) || (Dataprocess[i].angle < 50)) { if ((0 < Dataprocess[i].distance) && (Dataprocess[i].distance < distance)) // ¾àÀëСÓÚ350mmÐèÒª±ÜÕÏ,Ö»ÐèÒª100¶È·¶Î§ÄÚµã { calculation_angle_cnt++; // ¼ÆËã¾àÀëСÓÚ±ÜÕϾàÀëµÄµã¸öÊý if (Dataprocess[i].angle < 50) angle_sum += Dataprocess[i].angle; else if (Dataprocess[i].angle > 310) angle_sum += (Dataprocess[i].angle - 360); // 310¶Èµ½50¶Èת»¯Îª-50¶Èµ½50¶È if (Dataprocess[i].distance < 200) // ¼Ç¼СÓÚ200mmµÄµãµÄ¼ÆÊý distance_count++; } } } if (calculation_angle_cnt < 8) // СÓÚ8µã²»ÐèÒª±ÜÕÏ£¬È¥³ýһЩÔëµã { if ((Move_X += 0.1) >= Aovid_Speed) // ±ÜÕϵÄËÙ¶ÈÉ趨Ϊ260£¬Öð½¥Ôö¼Óµ½260¿ÉÉÔ΢ƽ»¬Ò»Ð© Move_X = Aovid_Speed; Move_Z = 0; // ²»±ÜÕÏʱ²»ÐèҪתÍä } else // ÐèÒª±ÜÕÏ£¬¼òµ¥µØÅжÏÕϰ­Î﷽λ { if (Car_Num == Akm_Car) // °¢¿ËÂü³µÐÍÓжæ»ú£¬ÐèÒªÌØÊâ´¦Àí { if (distance_count > 8) // ¾àÀëСÓÚ±ÜÕ½¾àÀë Move_X = -Aovid_Speed, Move_Z = 0; // ÍùºóÍË else { if ((Move_X -= 0.1) <= (Aovid_Speed * 0.5)) // ±ÜÕÏʱËٶȽµµ½µÍËÙ0.25 Move_X = Aovid_Speed * 0.5; if (angle_sum > 0) // Õϰ­ÎïÆ«ÓÒ Move_Z = -Pi / 5; // ÿ´ÎתÍä½Ç¶ÈΪPI/5£¬Ö±µ½100¶È·¶Î§ÄÚÎÞÕϰ­Îï¾ÍÍ£Ö¹ else // Æ«×ó Move_Z = Pi / 5; } } else { if (distance_count > 8) // СÓÚ±ÜÕ½¾àÀëµÄʱºò Move_X = -Aovid_Speed, Move_Z = 0; // ÍùºóÍË else { if ((Move_X -= 0.1) <= (Aovid_Speed * 0.5)) // ±ÜÕÏʱËٶȽµµ½µÍËÙ¶È0.15 Move_X = (Aovid_Speed * 0.5); if (angle_sum > 0) // Õϰ­ÎïÆ«ÓÒ { if (Car_Num == Diff_Car) // ÿ´ÎתÍäËÙ¶ÈΪX¶È£¬Ö±µ½100¶È·¶Î§ÄÚÎÞÕϰ­Îï¾ÍÍ£Ö¹ Move_Z = -1; else if (Car_Num == Small_Tank_Car) Move_Z = -1; else Move_Z = -1; } else // Æ«×ó { if (Car_Num == Diff_Car) // ÿ´ÎתÍäËÙ¶ÈΪX¶È£¬Ö±µ½100¶È·¶Î§ÄÚÎÞÕϰ­Îï¾ÍÍ£Ö¹ Move_Z = 1; else if (Car_Num == Small_Tank_Car) Move_Z = 1; else Move_Z = 1; } } } } Move_Z = -Move_Z; } /************************************************************************** Function: Lidar_Follow Input : none Output : none º¯Êý¹¦ÄÜ£ºÀ×´ï¸úËæÄ£Ê½ Èë¿Ú²ÎÊý£ºÎÞ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ float angle1 = 0; // ¸úËæµÄ½Ç¶È u16 mini_distance1; void Lidar_Follow(void) { static u16 cnt = 0; int i; int calculation_angle_cnt = 0; static float angle = 0; // ¸úËæµÄ½Ç¶È static float last_angle = 0; // u16 mini_distance = 65535; static u8 data_count = 0; // ÓÃÓÚÂ˳ýһдÔëµãµÄ¼ÆÊý±äÁ¿ // ÐèÒªÕÒ³ö¸úËæµÄÄǸöµãµÄ½Ç¶È for (i = 0; i < lap_count; i++) { if (100 < Dataprocess[i].distance && Dataprocess[i].distance < Follow_Distance) // 1200·¶Î§ÄÚ¾ÍÐèÒª¸úËæ { calculation_angle_cnt++; if (Dataprocess[i].distance < mini_distance) // ÕÒ³ö¾àÀë×îСµÄµã { mini_distance = Dataprocess[i].distance; angle = Dataprocess[i].angle; } } } if (angle > 180) angle -= 360; // 0--360¶Èת»»³É0--180£»-180--0£¨Ë³Ê±Õ룩 if (angle - last_angle > 10 || angle - last_angle < -10) // ×öÒ»¶¨Ïû¶¶£¬²¨¶¯´óÓÚ10¶ÈµÄÐèÒª×öÅÐ¶Ï { if (++data_count == 60) // Á¬Ðø60´Î²É¼¯µ½µÄÖµ(300msºó)ºÍÉϴεıȴóÓÚ10¶È£¬´Ëʱ²ÅÊÇÈÏΪÊÇÓÐЧֵ { data_count = 0; last_angle = angle; } } else // ²¨¶¯Ð¡ÓÚ10¶ÈµÄ¿ÉÒÔÖ±½ÓÈÏΪÊÇÓÐЧֵ { data_count = 0; last_angle = angle; } if (calculation_angle_cnt < 6) // ÔÚ¸úËæ·¶Î§ÄڵĵãÉÙÓÚ6¸ö { if (cnt < 40) // Á¬Ðø¼ÆÊý³¬40´ÎûÓÐÒª¸úËæµÄµã£¬´Ëʱ²ÅÊDz»ÓøúËæ cnt++; if (cnt >= 40) { Move_X = 0; // ËÙ¶ÈΪ0 Move_Z = 0; } } else { cnt = 0; if (Car_Num == Akm_Car) { if ((((angle > 15) && (angle < 180)) || ((angle > -180) && angle < -15)) && (mini_distance < 500)) // °¢¿¨Âü³µÐÍ´¦Àí³µÍ·²»¶ÔןúËæÎÏ൱ÓÚºó³µÒ»Ñù£¬Ò»´Î²»¶Ô×¼£¬ÄǺóÍËÔÙÀ´¶Ô×¼ { Move_X = -0.20; Move_Z = -Follow_Turn_PID(last_angle, 0); } else { Move_X = Distance_Adjust_PID(mini_distance, Keep_Follow_Distance); // ±£³Ö¾àÀë±£³ÖÔÚ400mm Move_Z = Follow_Turn_PID(last_angle, 0); } } else // ÆäÓà³µÐÍ { if ((angle > 50 || angle < -50) && (mini_distance > 400)) { Move_Z = -0.0298f * last_angle; // ½Ç¶È²î¾à¹ý´óÖ±½Ó¿ìËÙתÏò Move_X = 0; // ²îËÙС³µºÍÂÄ´øÐ¡³µ¿ÉÒÔʵÏÖÔ­µØ×ª¶¯ } else { Move_X = Distance_Adjust_PID(mini_distance, Keep_Follow_Distance); // ±£³Ö¾àÀë±£³ÖÔÚ400mm Move_Z = Follow_Turn_PID(last_angle, 0); // תÏòPID£¬³µÍ·ÓÀÔ¶¶ÔןúËæÎïÆ· } } } Move_Z = target_limit_float(Move_Z, -Pi / 6, Pi / 6); // ÏÞ·ù Move_X = target_limit_float(Move_X, -0.6, 0.6); } /************************************************************************** º¯Êý¹¦ÄÜ£ºÐ¡³µ×ßÖ±Ïßģʽ Èë¿Ú²ÎÊý£ºÎÞ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ void Lidar_along_wall(void) { static u32 target_distance = 0; static int n = 0; u32 distance; u8 data_count = 0; // ÓÃÓÚÂ˳ýһдÔëµãµÄ¼ÆÊý±äÁ¿ for (int i = 0; i < lap_count; i++) { if (Dataprocess[i].angle > 75 && Dataprocess[i].angle < 77) { if (n == 0) { target_distance = Dataprocess[i].distance; // »ñÈ¡µÄµÚÒ»¸öµã×÷ΪĿ±ê¾àÀë n++; } if (Dataprocess[i].distance < target_distance + 100) //+100ÏÞÖÆ»ñÈ¡¾àÀëµÄ·¶Î§Öµ { distance = Dataprocess[i].distance; // »ñȡʵʱ¾àÀë data_count++; } } } // if(data_count <= 0) // Move_X = 0; // Move_X = forward_velocity; // ³õʼËÙ¶È Move_Z = -Along_Adjust_PID(distance, target_distance); if (Car_Num == Akm_Car) { Move_Z = target_limit_float(Move_Z, -Pi / 4, Pi / 4); // ÏÞ·ù } else if (Car_Num == Diff_Car) Move_Z = target_limit_float(Move_Z, -Pi / 5, Pi / 5); // ÏÞ·ù } /************************************************************************** Function: Car_Perimeter_Init Input : none Output : none º¯Êý¹¦ÄÜ£º¼ÆËãС³µ¸÷ÂÖ×ÓµÄÖܳ¤ Èë¿Ú²ÎÊý£ºÎÞ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ void Car_Perimeter_Init(void) { if (Car_Num == Diff_Car || Car_Num == Akm_Car) { Perimeter = Diff_Car_Wheel_diameter * Pi; Wheelspacing = Diff_wheelspacing; } else if (Car_Num == Small_Tank_Car) { Perimeter = Small_Tank_WheelDiameter * Pi; Wheelspacing = Small_Tank_wheelspacing; } else { Perimeter = Big_Tank_WheelDiameter * Pi; Wheelspacing = Big_Tank_wheelspacing; } } /************************************************************************** Function: Ultrasonic_Follow Input : none Output : none º¯Êý¹¦ÄÜ£º³¬Éù²¨¸úËæÄ£Ê½ Èë¿Ú²ÎÊý£ºÎÞ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ void Ultrasonic_Follow(void) // ³¬Éù²¨¸úËæ£¬Ö»Äܵ¥·½Ïò¸úËæ { Move_Z = 0; Read_Distane(); // ¶ÁÈ¡³¬Éù²¨µÄ¾àÀë if (Distance1 < 200) // ¾àÀëСÓÚ200mm£¬Í˺ó { if ((Move_X -= 3) < -210) Move_X = -210; // ¸øÒ»210ºóÍËËÙ¶È } else if (Distance1 > 270 && Distance1 < 750) // ¾àÀëÔÚ270µ½750Ö®¼äÊÇÐèÒª¸úËæÇ°½ø { if ((Move_X += 3) > 210) // ËÙ¶ÈÖð½¥Ôö¼Ó£¬¸øÇ°½øËÙ¶È Move_X = 210; } else { if (Move_X > 0) { if ((Move_X -= 20) < 0) // ËÙ¶ÈÖð½¥¼õµ½0 Move_X = 0; } else { if ((Move_X += 20) > 0) // ËÙ¶ÈÖð½¥¼õµ½0 Move_X = 0; } } } /************************************************************************** Function: Get angle Input : way£ºThe algorithm of getting angle 1£ºDMP 2£ºkalman 3£ºComplementary filtering Output : none º¯Êý¹¦ÄÜ£º»ñÈ¡½Ç¶È Èë¿Ú²ÎÊý£ºway£º»ñÈ¡½Ç¶ÈµÄËã·¨ 1£ºDMP 2£º¿¨¶ûÂü 3£º»¥²¹Â˲¨ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ void Get_Angle(u8 way) { if (way == 1) // DMPµÄ¶ÁÈ¡ÔÚÊý¾Ý²É¼¯Öж϶ÁÈ¡£¬Ñϸñ×ñѭʱÐòÒªÇó { Read_DMP(); // ¶ÁÈ¡¼ÓËÙ¶È¡¢½ÇËÙ¶È¡¢Çã½Ç } else { Gyro_X = (I2C_ReadOneByte(devAddr, MPU6050_RA_GYRO_XOUT_H) << 8) + I2C_ReadOneByte(devAddr, MPU6050_RA_GYRO_XOUT_L); // ¶ÁÈ¡XÖáÍÓÂÝÒÇ Gyro_Y = (I2C_ReadOneByte(devAddr, MPU6050_RA_GYRO_YOUT_H) << 8) + I2C_ReadOneByte(devAddr, MPU6050_RA_GYRO_YOUT_L); // ¶ÁÈ¡YÖáÍÓÂÝÒÇ Gyro_Z = (I2C_ReadOneByte(devAddr, MPU6050_RA_GYRO_ZOUT_H) << 8) + I2C_ReadOneByte(devAddr, MPU6050_RA_GYRO_ZOUT_L); // ¶ÁÈ¡ZÖáÍÓÂÝÒÇ Accel_X = (I2C_ReadOneByte(devAddr, MPU6050_RA_ACCEL_XOUT_H) << 8) + I2C_ReadOneByte(devAddr, MPU6050_RA_ACCEL_XOUT_L); // ¶ÁÈ¡XÖá¼ÓËÙ¶È¼Æ Accel_Y = (I2C_ReadOneByte(devAddr, MPU6050_RA_ACCEL_YOUT_H) << 8) + I2C_ReadOneByte(devAddr, MPU6050_RA_ACCEL_YOUT_L); // ¶ÁÈ¡XÖá¼ÓËÙ¶È¼Æ Accel_Z = (I2C_ReadOneByte(devAddr, MPU6050_RA_ACCEL_ZOUT_H) << 8) + I2C_ReadOneByte(devAddr, MPU6050_RA_ACCEL_ZOUT_L); // ¶ÁÈ¡ZÖá¼ÓËÙ¶È¼Æ // if(Gyro_X>32768) Gyro_X-=65536; //Êý¾ÝÀàÐÍת»» Ò²¿Éͨ¹ýshortÇ¿ÖÆÀàÐÍת»» // if(Gyro_Y>32768) Gyro_Y-=65536; //Êý¾ÝÀàÐÍת»» Ò²¿Éͨ¹ýshortÇ¿ÖÆÀàÐÍת»» // if(Gyro_Z>32768) Gyro_Z-=65536; //Êý¾ÝÀàÐÍת»» // if(Accel_X>32768) Accel_X-=65536; //Êý¾ÝÀàÐÍת»» // if(Accel_Y>32768) Accel_Y-=65536; //Êý¾ÝÀàÐÍת»» // if(Accel_Z>32768) Accel_Z-=65536; //Êý¾ÝÀàÐÍת»» Accel_Angle_x = atan2(Accel_Y, Accel_Z) * 180 / Pi; // ¼ÆËãÇã½Ç£¬×ª»»µ¥Î»Îª¶È Accel_Angle_y = atan2(Accel_X, Accel_Z) * 180 / Pi; // ¼ÆËãÇã½Ç£¬×ª»»µ¥Î»Îª¶È Gyro_X = Gyro_X / 65.5; // ÍÓÂÝÒÇÁ¿³Ìת»»£¬Á¿³Ì¡À500¡ã/s¶ÔÓ¦ÁéÃô¶È65.5£¬¿É²éÊÖ²á Gyro_Y = Gyro_Y / 65.5; // ÍÓÂÝÒÇÁ¿³Ìת»» if (way == 2) { Roll = -Kalman_Filter_x(Accel_Angle_x, Gyro_X); // ¿¨¶ûÂüÂ˲¨ Pitch = -Kalman_Filter_y(Accel_Angle_y, Gyro_Y); } else if (way == 3) { Roll = -Complementary_Filter_x(Accel_Angle_x, Gyro_X); // »¥²¹Â˲¨ Pitch = -Complementary_Filter_y(Accel_Angle_y, Gyro_Y); } } } /************************************************************************** Function: The remote control command of model aircraft is processed Input : none Output : none º¯Êý¹¦ÄÜ£º¶Ôº½Ä£Ò£¿Ø¿ØÖÆÃüÁî½øÐд¦Àí Èë¿Ú²ÎÊý£ºÎÞ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ void Remote_Control(void) { // Data within 1 second after entering the model control mode will not be processed // ¶Ô½øÈ뺽ģ¿ØÖÆÄ£Ê½ºó1ÃëÄÚµÄÊý¾Ý²»´¦Àí static u8 thrice = 200; int Threshold = 100; // limiter //ÏÞ·ù int LX, RY; // static float Target_LX,Target_LY,Target_RY,Target_RX; Remoter_Ch1 = target_limit_int(Remoter_Ch1, 1000, 2000); Remoter_Ch2 = target_limit_int(Remoter_Ch2, 1000, 2000); // Front and back direction of left rocker. Control forward and backward. // ×óÒ¡¸Ëǰºó·½Ïò¡£¿ØÖÆÇ°½øºóÍË¡£ LX = Remoter_Ch2 - 1500; // //Left joystick left and right. Control left and right movement. // //×óÒ¡¸Ë×óÓÒ·½Ïò¡£¿ØÖÆ×óÓÒÒÆ¶¯¡£¡£ // LY=Remoter_Ch2-1500; // Right stick left and right. To control the rotation. // ÓÒÒ¡¸Ë×óÓÒ·½Ïò¡£¿ØÖÆ×Ôת¡£ RY = Remoter_Ch1 - 1500; // if (LX > -Threshold && LX < Threshold) LX = 0; if (RY > -Threshold && RY < Threshold) RY = 0; // if(LX==0) Target_LX=Target_LX/1.2f; // if(LY==0) Target_LY=Target_LY/1.2f; // if(RY==0) Target_RY=Target_RY/1.2f; // //Throttle related //ÓÍÃÅÏà¹Ø // Remote_RCvelocity=RC_Velocity+RX; // if(Remote_RCvelocity<0)Remote_RCvelocity=0; // The remote control command of model aircraft is processed // ¶Ôº½Ä£Ò£¿Ø¿ØÖÆÃüÁî½øÐд¦Àí Move_X = LX; Move_Z = -RY; Move_X = Move_X * 1.3; //*1.3ÊÇΪÁËÀ«´óËÙ¶È if (Car_Num == Akm_Car) Move_Z = Move_Z * (Pi / 8) / 350.0; else Move_Z = Move_Z * 2 * (Pi / 4) / 350.0; // Unit conversion, mm/s -> m/s // µ¥Î»×ª»»£¬mm/s -> m/s Move_X = Move_X / 1000; // ZÖáÊý¾Ýת»¯ #if _4WD if (Move_X < 0) Move_Z = -Move_Z; #endif // Data within 1 second after entering the model control mode will not be processed // ¶Ô½øÈ뺽ģ¿ØÖÆÄ£Ê½ºó1ÃëÄÚµÄÊý¾Ý²»´¦Àí if (thrice > 0) Move_X = 0, Move_Z = 0, thrice--; // Control target value is obtained and kinematics analysis is performed // µÃµ½¿ØÖÆÄ¿±êÖµ£¬½øÐÐÔ˶¯Ñ§·ÖÎö // Get_Target_Encoder(Move_X,Move_Z); } 怎么把OpenMV与STM32串口通信实现二维码/APRILTag码识别及控制的代码加到上述代码中,现在openmv的二维码识别已做好,二维码采用的是Apriltag的36h11类型,id:0表示停止,id:1表示直行,id:2表示左转,id:3表示右转,现在需要再在STM32中修改或添加代码,使其能在接收到openmv识别到的指令后作出相应的动作

USART_TypeDef * DeBugUsart = USART1; //¼ÓÈëÒÔÏ´úÂë,Ö§³Öprintfº¯Êý,¶ø²»ÐèҪѡÔñuse MicroLIB #if 1 #pragma import(__use_no_semihosting) //±ê×¼¿âÐèÒªµÄÖ§³Öº¯Êý struct __FILE { int handle; }; FILE __stdout; //¶¨Òå_sys_exit()ÒÔ±ÜÃâʹÓðëÖ÷»úģʽ void _sys_exit(int x) { x = x; } //ÖØ¶¨Òåfputcº¯Êý int fputc(int ch, FILE *f) { while((DeBugUsart->SR&0X40)==0);//Ñ­»··¢ËÍ,Ö±µ½·¢ËÍÍê±Ï DeBugUsart->DR = (u8) ch; // USART3->DR = (u8) ch; return ch; } #endif UART_HandleTypeDef huart1; UART_HandleTypeDef huart3; //½ÓÊÕ״̬ //bit15£¬ ½ÓÊÕÍê³É±êÖ¾ //bit14£¬ ½ÓÊÕµ½0x0d //bit13~0£¬ ½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿ u16 USART_RX_STA=0; //½ÓÊÕ״̬±ê¼Ç u16 USART3_RX_STA=0; //½ÓÊÕ״̬±ê¼Ç u8 aRxBuffer[RXBUFFERSIZE];//HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å u8 aRxBuffer3[RXBUFFERSIZE];//HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å u8 USART_RX_BUF[USART_REC_LEN]; //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú. u8 USART3_RX_BUF[USART_REC_LEN]; //½ÓÊÕ»º³å,×î´óUSART_REC_LEN¸ö×Ö½Ú. //½ÓÊÕ״̬ //bit15£¬ ½ÓÊÕÍê³É±êÖ¾ //bit14£¬ ½ÓÊÕµ½0x0d //bit13~0£¬ ½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿ extern volatile int led_state,motor1_state,motor2_state; //µÆ¹â £¬ ²½½øµç»ú1£¨´°Á±£©£¬²½½øµç»ú2£¨´°»§£© extern volatile u8 mode; //¹¤×÷ģʽ²ÎÊý 0£»ÊÖ¶¯Ä£Ê½£¬1£º×Ô¶¯Ä£Ê½ 帮我解释一下为什么这样变成,什么是半主机

static float Bias,Pwm,Integral_bias,Last_Bias; int Position_PID (int Encoder,int Target) { Bias=Encoder-Target; //¼ÆËãÆ«²î Integral_bias+=Bias; //Çó³öÆ«²îµÄ»ý·Ö // Pwm=70*Bias*Ratio+0.00*Integral_bias*Ratio+200*(Bias-Last_Bias)*Ratio; //λÖÃʽPID¿ØÖÆÆ÷ Pwm=100*Bias*Ratio+0.00*Integral_bias*Ratio+250*(Bias-Last_Bias)*Ratio; //λÖÃʽPID¿ØÖÆÆ÷ Last_Bias=Bias; //±£´æÉÏÒ»´ÎÆ«²î return Pwm; //ÔöÁ¿Êä³ö } int Position_PID_1 (int Encoder,float Target) { static float Bias,Pwm,Integral_bias,Last_Bias,encoder; encoder=(float)Encoder; Bias=encoder-Target; //¼ÆËãÆ«²î Integral_bias+=Bias; //Çó³öÆ«²îµÄ»ý·Ö // Pwm=90*Bias*Ratio+0.00*Integral_bias*Ratio+250*(Bias-Last_Bias)*Ratio; //λÖÃʽPID¿ØÖÆÆ÷ Pwm=90*Bias*Ratio+0.00*Integral_bias*Ratio+250*(Bias-Last_Bias)*Ratio; //λÖÃʽPID¿ØÖÆÆ÷ Last_Bias=Bias; //±£´æÉÏÒ»´ÎÆ«²î return Pwm; //ÔöÁ¿Êä³ö } int Position_PID_3 (int Encoder,int Target) { static float Bias,Pwm,Integral_bias,Last_Bias; Bias=Encoder-Target; //¼ÆËãÆ«²î Integral_bias+=Bias; //Çó³öÆ«²îµÄ»ý·Ö // Pwm=70*Bias*Ratio+0.00*Integral_bias*Ratio+200*(Bias-Last_Bias)*Ratio; //λÖÃʽPID¿ØÖÆÆ÷ // Pwm=280*Bias*Ratio+0.00*Integral_bias*Ratio+300*(Bias-Last_Bias)*Ratio; //λÖÃʽPID¿ØÖÆÆ÷ Pwm=90*Bias*Ratio+0.00*Integral_bias*Ratio+250*(Bias-Last_Bias)*Ratio; //λÖÃʽPID¿ØÖÆÆ÷ Last_Bias=Bias; //±£´æÉÏÒ»´ÎÆ«²î return Pwm; //ÔöÁ¿Êä³ö } u16 Count_Next=0; static int Angle_Max,Position_Max; static u8 Flag_Back; u16 number=0; //int Count_FZ,Target_Position=10580; /************************************************************************** º¯Êý¹¦ÄÜ£º×Ô¶¯Æð°Ú³ÌÐò Èë¿Ú²ÎÊý£ºint ·µ»Ø Öµ£º **************************************************************************/ void Run(u8 Way) { static float Count_FZ,Target_Position=10450; static float Count_Big_Angle=0.046542; if(Way==2) //ÊÖ¶¯Æð°Ú³ÌÐò { if(Angle_Balance<(ZHONGZHI+200)&&Angle_Balance>(ZHONGZHI-200)) //µ½µ×½Ó½üƽºâλÖà ¼´¿É¿ªÆôƽºâϵͳ { State=1; //µ¹Á¢×´Ì¬ÖÃ1 Way_Turn=0;//Æð°Ú±ê־λÇåÁã } } } /************************************************************************** º¯Êý¹¦ÄÜ£ºÇã½ÇPD¿ØÖÆ Èë¿Ú²ÎÊý£º½Ç¶È ·µ»Ø Öµ£ºÇã½Ç¿ØÖÆPWM **************************************************************************/ int balance_0(float Angle) { float Bias; //Çã½ÇÆ«²î static float Last_Bias,D_Bias,I_Bias; //PIDÏà¹Ø±äÁ¿ int balance; Bias=Angle-ZHONGZHI; I_Bias+=Bias; D_Bias=Bias-Last_Bias; balance=-Balance_KP*Bias- D_Bias*Balance_KD+ I_Bias*Balance_Ratio; Last_Bias=Bias; return balance; //PWM·µ»ØÖµ //Çó³öƽºâµÄ½Ç¶ÈÖÐÖµ ºÍ»úеÏà¹Ø //Îó²î×öÀÛ¼Ó£¬×ö»ý·Ö¶ÔÏó //Çó³öÆ«²îµÄ΢·Ö ½øÐÐ΢·Ö¿ØÖÆ //ʹÓÃλÖÃPIDËã·¨¹«Ê½¸øPWM¸³Öµ£¬Æ½ºâ¿ØÖÆÐèÒª¿ìËÙ·´Ó¦£¬Ê¹ÓÃPD¿ØÖÆËã·¨£¬¼´»ý·Ö²ÎÊýΪÁã //ÉÏ´ÎÎó²îµÈÓÚµ±Ç°Îó²î //º¯Êý·µ»ØÖµÎªÇã½Ç¿ØÖÆPWMÖµ } /************************************************************************** º¯Êý¹¦ÄÜ£ºÎ»ÖÃPD¿ØÖÆ Èë¿Ú²ÎÊý£º±àÂëÆ÷ ·µ»Ø Öµ£ºÎ»ÖÿØÖÆPWM **************************************************************************/ int Position_0(int Encoder) { static float Position_PWM, Last_Position, Position_Bias, Position_Differential; static float Position_Least; Position_Least=Encoder-Position_Zero; //=-???? Position_Bias *=0.8; Position_Bias += Position_Least*0.2; Position_Differential=Position_Bias-Last_Position; Last_Position=Position_Bias; Position_PWM =Position_Bias*Position_KP+Position_Differential*Position_KD; return Position_PWM; //¶¨ÒåλÖÿØÖƱäÁ¿£¬·Ö±ðÐèÒª¶¨Òå¿ØÖÆPWMÖµ¡¢ÉÏÒ»´ÎµÄλÖÃÖµ¡¢µ±Ç°Î»ÖÃÖµ¡¢Î¢·Ö¶ÔÏóÖµ //¶¨ÒåλÖÃÎó²î±äÁ¿ //===»ñȡλÖÃÆ«²îÁ¿£¬¼´Îó²îÁ¿ //Ò»½×µÍͨÂ˲¨Æ÷Ëã·¨ //===Ò»½×µÍͨÂ˲¨Æ÷ //===»ñȡƫ²î±ä»¯ÂÊ£¬µ±Ç°Îó²îÓëÉÏ´ÎÎó²îÇó²î£¬¼´Î¢·Ö¶ÔÏóÖµ //ÉÏ´ÎÎó²îµÈÓÚµ±Ç°Îó²î£¬±£´æÉÏÒ»´ÎµÄÆ«²î //===ʹÓÃλÖÃPIDËã·¨¹«Ê½¸øPWM¸³Öµ£¬ÐèҪλÖÿìËÙ·´Ó¦£¬²ÉÓÃPDËã·¨£¬¼´»ý·Ö²ÎÊýΪÁã //º¯Êý·µ»ØÖµÎªµ¹Á¢°ÚλÖÿØÖÆPWMÖµ } /************************************************************************** º¯Êý¹¦ÄÜ£ºÏÞÖÆPWM¸³Öµ Èë¿Ú²ÎÊý£ºÎÞ ·µ»Ø Öµ£ºÎÞ **************************************************************************/ void Xianfu_Pwm(void) { int Amplitude=6900; //===PWMÂú·ùÊÇ7200 ÏÞÖÆÔÚ6900 if(Moto<-Amplitude) Moto=-Amplitude; if(Moto>Amplitude) Moto=Amplitude; } /************************************************************************** º¯Êý¹¦ÄÜ£ºÒì³£¹Ø±Õµç»ú Èë¿Ú²ÎÊý£ºµçѹ ·µ»Ø Öµ£º1£ºÒì³£ 0£ºÕý³£ **************************************************************************/ u8 Turn_Off(void) { u8 temp; if(Flag_Stop==1||(State==1 && (Angle_Balance<(ZHONGZHI-460)||Angle_Balance>(ZHONGZHI+460)))) //¹Ø±Õµç»ú { Flag_Stop=0; Way_Turn=0; Flag_qb2=0; Angle_Max=0; Position_Max=0; State=0; temp=1; TIM_SetCounter(TIM2,10000);//³õʼ»¯¼ÆÊýÆ÷³õÖµ } else { temp=0; } return temp; } void Encoder_App(void) { if(State == 0) //Æð°Úʱ²ÉÑùÈ¡3´ÎÇ󯽾ù£¬5´ÎÖÜÆÚÌ«³¤ { Angle_Balance=Get_ADC(5); } if(State==1) { Angle_Balance=Get_ADC(20);//´Ë¿ØÖÆÖÜÆÚ²»ÐèÒªÄÇô¶Ì£¬Æð°Ú³É¹¦ºó²ÉÑùÈ¡5´ÎÇ󯽾ùÖµ£¬ } D_Angle_Balance= Angle_Balance-Last_Angle_Balance ; //===»ñȡ΢·ÖÖµ if (State == 0 && Way_Turn ==1) { if(Angle_Balance<(ZHONGZHI+200)&&Angle_Balance>(ZHONGZHI-200)) //µ½µ×½Ó½üƽºâλÖà ¼´¿É¿ªÆôƽºâϵͳ { State=1; //µ¹Á¢×´Ì¬ÖÃ1 Way_Turn=0;//×Ô¶¯Æð°Ú±ê־λÇåÁã Flag_qb=0; //×Ô¶¯Æð°Ú²½ÖèÇåÁã Angle_Max=0; Flag_Back=0; } } if(State==0) { Run(Way_Turn);//Æð°Ú ÓÉÈë¿Ú²ÎÊý¿ØÖÆ 1£º×Ô¶¯Æð°Ú 2£ºÊÖ¶¯Æð°Ú if(Turn_Off()==1) //°´ÏÂÍ£Ö¹¼üʱֹͣµç»ú { Moto_qb=0; } } if(State==1) //Æð°Ú³É¹¦Ö®ºó£¬½øÐе¹Á¢¿ØÖÆ { Balance_Pwm =balance_0(Angle_Balance); //¿ªÆôƽºâ¿ØÖÆ if(Flag_qb2==0) //λÖÿØÖÆÑÓʱÆô¶¯ { if(Angle_Balance<(ZHONGZHI+200)&&Angle_Balance>(ZHONGZHI-200))Count_Position++; // if(Count_Position>20)Flag_qb2=1, Count_Position=0,TIM_SetCounter(TIM2,10000); //ÔÚÆ½ºâλÖõ¹Á¢³¬¹ý300ms ¿ªÆôλÖÿØÖÆ } if(Flag_qb2==1) //¿ªÆôλÖÿØÖÆ { Encoder=TIM_GetCounter(TIM2); //===¸üбàÂëÆ÷λÖÃÐÅÏ¢ if(++Count_P2>=4) Position_Pwm=Position_0(Encoder),Count_P2=0; //===λÖÃPD¿ØÖÆ 25ms½øÐÐÒ»´ÎλÖÿØÖÆ } Moto=Balance_Pwm-Position_Pwm; //===¼ÆËãµç»ú×îÖÕPWM Xianfu_Pwm(); //===PWMÏÞ·ù if(Turn_Off()==1) //°´ÏÂÍ£Ö¹¼ü»òÕßÇã½Ç¹ý´ó±£»¤£¬µç»úÍ£Ö¹ { Moto=0; } if(Moto>7200) Moto=7200; if(Moto<-7200)Moto=-7200; Set_Pwm(Moto); //===¸³Öµ¸øPWM¼Ä´æÆ÷ } Last_Angle_Balance=Angle_Balance; //===±£´æÉÏÒ»´ÎµÄÇã½ÇÖµ } 解释上述代码

/* USER CODE BEGIN Header */ /** ****************************************************************************** * @file usart.c * @brief This file provides code for the configuration * of the USART instances. ****************************************************************************** * @attention * * Copyright (c) 2023 STMicroelectronics. * All rights reserved. * * This software is licensed under terms that can be found in the LICENSE file * in the root directory of this software component. * If no LICENSE file comes with this software, it is provided AS-IS. * ****************************************************************************** */ /* USER CODE END Header */ /* Includes ------------------------------------------------------------------*/ #include "usart.h" /* USER CODE BEGIN 0 */ typedef struct __FILE FILE; extern uint8_t Usart1_ReadBuf[255]; //´®¿Ú1 »º³åÊý×é extern uint8_t Usart1_ReadCount; //´®¿Ú1 ½ÓÊÕ×Ö½Ú¼ÆÊý extern int8_t g_cThisState ;//Õâ´Î״̬ extern uint8_t g_ucUsart2ReceiveData; //±£´æ´®¿Ú¶þ½ÓÊÕµÄÊý¾Ý uint8_t state = 0;//¶¨Ò徲̬static ±äÁ¿ int g_lHW_State = 0;//°ïÖúÊÓ¾õµ÷ÊÔ ÓÃÓÚ±íʾºìÍâ¶Ô¹Ü»òÕßÊÓ¾õÉãÏñͷʶ±ð״̬ uint8_t g_ucaUsart2ReceiveBuffer[10];//±£´æ´®¿Ú½ÓÊÕÓÐЧÊý¾ÝµÄÊý×é uint8_t g_ucUsart2ReceivCounter=0;//´®¿Ú½ÓÊÕ¼ÆÊýÖµ /* USER CODE END 0 */ UART_HandleTypeDef huart1; UART_HandleTypeDef huart2; UART_HandleTypeDef huart3; /* USART1 init function */ void MX_USART1_UART_Init(void) { /* USER CODE BEGIN USART1_Init 0 */ /* USER CODE END USART1_Init 0 */ /* USER CODE BEGIN USART1_Init 1 */ /* USER CODE END USART1_Init 1 */ huart1.Instance = USART1; huart1.Init.BaudRate = 115200; huart1.Init.WordLength = UART_WORDLENGTH_8B; huart1.Init.StopBits = UART_STOPBITS_1; huart1.Init.Parity = UART_PARITY_NONE; huart1.Init.Mode = UART_MODE_TX_RX; huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart1.Init.OverSampling = UART_OVERSAMPLING_16; if (HAL_UART_Init(&huart1) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN USART1_Init 2 */ /* USER CODE END USART1_Init 2 */ } /* USART2 init function */ void MX_USART2_UART_Init(void) { /* USER CODE BEGIN USART2_Init 0 */ /* USER CODE END USART2_Init 0 */ /* USER CODE BEGIN USART2_Init 1 */ /* USER CODE END USART2_Init 1 */ huart2.Instance = USART2; huart2.Init.BaudRate = 115200; huart2.Init.WordLength = UART_WORDLENGTH_8B; huart2.Init.StopBits = UART_STOPBITS_1; huart2.Init.Parity = UART_PARITY_NONE; huart2.Init.Mode = UART_MODE_TX_RX; huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart2.Init.OverSampling = UART_OVERSAMPLING_16; if (HAL_UART_Init(&huart2) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN USART2_Init 2 */ /* USER CODE END USART2_Init 2 */ } /* USART3 init function */ void MX_USART3_UART_Init(void) { /* USER CODE BEGIN USART3_Init 0 */ /* USER CODE END USART3_Init 0 */ /* USER CODE BEGIN USART3_Init 1 */ /* USER CODE END USART3_Init 1 */ huart3.Instance = USART3; huart3.Init.BaudRate = 115200; huart3.Init.WordLength = UART_WORDLENGTH_8B; huart3.Init.StopBits = UART_STOPBITS_1; huart3.Init.Parity = UART_PARITY_NONE; huart3.Init.Mode = UART_MODE_TX_RX; huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart3.Init.OverSampling = UART_OVERSAMPLING_16; if (HAL_UART_Init(&huart3) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN USART3_Init 2 */ /* USER CODE END USART3_Init 2 */ } void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle) { GPIO_InitTypeDef GPIO_InitStruct = {0}; if(uartHandle->Instance==USART1) { /* USER CODE BEGIN USART1_MspInit 0 */ /* USER CODE END USART1_MspInit 0 */ /* USART1 clock enable */ __HAL_RCC_USART1_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); /**USART1 GPIO Configuration PA9 ------> USART1_TX PA10 ------> USART1_RX */ GPIO_InitStruct.Pin = GPIO_PIN_9; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_10; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* USART1 interrupt Init */ HAL_NVIC_SetPriority(USART1_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USART1_IRQn); /* USER CODE BEGIN USART1_MspInit 1 */ /* USER CODE END USART1_MspInit 1 */ } else if(uartHandle->Instance==USART2) { /* USER CODE BEGIN USART2_MspInit 0 */ /* USER CODE END USART2_MspInit 0 */ /* USART2 clock enable */ __HAL_RCC_USART2_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); /**USART2 GPIO Configuration PA2 ------> USART2_TX PA3 ------> USART2_RX */ GPIO_InitStruct.Pin = GPIO_PIN_2; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_3; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* USART2 interrupt Init */ HAL_NVIC_SetPriority(USART2_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USART2_IRQn); /* USER CODE BEGIN USART2_MspInit 1 */ /* USER CODE END USART2_MspInit 1 */ } else if(uartHandle->Instance==USART3) { /* USER CODE BEGIN USART3_MspInit 0 */ /* USER CODE END USART3_MspInit 0 */ /* USART3 clock enable */ __HAL_RCC_USART3_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); /**USART3 GPIO Configuration PB10 ------> USART3_TX PB11 ------> USART3_RX */ GPIO_InitStruct.Pin = GPIO_PIN_10; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_11; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* USART3 interrupt Init */ HAL_NVIC_SetPriority(USART3_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USART3_IRQn); /* USER CODE BEGIN USART3_MspInit 1 */ /* USER CODE END USART3_MspInit 1 */ } } void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle) { if(uartHandle->Instance==USART1) { /* USER CODE BEGIN USART1_MspDeInit 0 */ /* USER CODE END USART1_MspDeInit 0 */ /* Peripheral clock disable */ __HAL_RCC_USART1_CLK_DISABLE(); /**USART1 GPIO Configuration PA9 ------> USART1_TX PA10 ------> USART1_RX */ HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9|GPIO_PIN_10); /* USART1 interrupt Deinit */ HAL_NVIC_DisableIRQ(USART1_IRQn); /* USER CODE BEGIN USART1_MspDeInit 1 */ /* USER CODE END USART1_MspDeInit 1 */ } else if(uartHandle->Instance==USART2) { /* USER CODE BEGIN USART2_MspDeInit 0 */ /* USER CODE END USART2_MspDeInit 0 */ /* Peripheral clock disable */ __HAL_RCC_USART2_CLK_DISABLE(); /**USART2 GPIO Configuration PA2 ------> USART2_TX PA3 ------> USART2_RX */ HAL_GPIO_DeInit(GPIOA, GPIO_PIN_2|GPIO_PIN_3); /* USART2 interrupt Deinit */ HAL_NVIC_DisableIRQ(USART2_IRQn); /* USER CODE BEGIN USART2_MspDeInit 1 */ /* USER CODE END USART2_MspDeInit 1 */ } else if(uartHandle->Instance==USART3) { /* USER CODE BEGIN USART3_MspDeInit 0 */ /* USER CODE END USART3_MspDeInit 0 */ /* Peripheral clock disable */ __HAL_RCC_USART3_CLK_DISABLE(); /**USART3 GPIO Configuration PB10 ------> USART3_TX PB11 ------> USART3_RX */ HAL_GPIO_DeInit(GPIOB, GPIO_PIN_10|GPIO_PIN_11); /* USART3 interrupt Deinit */ HAL_NVIC_DisableIRQ(USART3_IRQn); /* USER CODE BEGIN USART3_MspDeInit 1 */ /* USER CODE END USART3_MspDeInit 1 */ } } /* USER CODE BEGIN 1 */ /** * @brief ÖØ¶¨Ïòprintf (ÖØ¶¨Ïòfputc)£¬ ʹÓÃʱºò¼ÇµÃ¹´Ñ¡ÉÏħ·¨°ô->Target->UseMicro LIB ¿ÉÄÜÐèÒªÔÚCÎļþ¼Ótypedef struct __FILE FILE; °üº¬Õâ¸öÎļþ#include "stdio.h" * @param * @return */ int fputc(int ch,FILE *stream) { HAL_UART_Transmit(&huart1,( uint8_t *)&ch,1,0xFFFF);//huart1¸ü»»ÎªÆäËû´®¿Ú¾Í»áÖØ¶¨Ïòµ½ÆäËû´®¿Ú return ch; } //ÅжϷñ½ÓÊÕÍêÒ»Ö¡Êý¾Ý uint8_t Usart_WaitReasFinish(void) { static uint16_t Usart_LastReadCount = 0;//¼Ç¼ÉϴεļÆÊýÖµ if(Usart1_ReadCount == 0) { Usart_LastReadCount = 0;//Çå³ý¼ÆÊýÖµ return 1;//±íʾûÓÐÔÚ½ÓÊÕÊý¾Ý } if(Usart1_ReadCount == Usart_LastReadCount)//Èç¹ûÕâ´Î¼ÆÊýÖµµÈÓÚÉϴμÆÊýÖµ { Usart1_ReadCount = 0;//½ÓÊÕÍê³ÉÇå³ý¼ÆÊýÖµ Usart_LastReadCount = 0;//Çå³ýÉϴμÆÊýÖµ return 0;//ÒѾ­½ÓÊÕÍê³ÉÁË } Usart_LastReadCount = Usart1_ReadCount;//Õâ´Î¼ÆÊýÖµ¸³Öµ¸øÉϴμÆÊýÖµ return 2;//±íʾÕýÔÚ½ÓÊÜÖÐ } /******************* * @brief ÉãÏñÍ·´®¿ÚЭÒé½âÎöº¯Êý ¿ÉÒÔÁ¬½ÓK210»òopenmvµÈ * @param data:´®¿Ú½ÓÊÕµ½µÄÿ¸ö×Ö½Ú * @return * *******************/ void usartCamera_Receive_Data(uint8_t data) { static uint8_t state = 0;//¶¨Ò徲̬static ±äÁ¿ if(state==0&&data==0xA5) //ÅжϵÚÒ»¸öÊDz»ÊÇÖ¡Í·0xA5 { state=1;//ÊÇÖ¡Í·0xA5 ¸³Öµstate=1 ±íʾ½ÓÊÕÏÂÒ»¸öÊý¾Ý //Êý¾Ý´æ´¢ÔÚÊý×éÖÐ "g_ucUsart2ReceivCounter++",ÕâÀïÊÇÏÈÓúó¼Ó£¬±ÈÈçg_ucUsart2ReceivCounter ³õֵΪ0£¬Ö´ÐÐÕâ¸öÊÇÏÈg_ucaUsart2ReceiveBuffer[0]=data£¬È»ºóg_ucUsart2ReceivCounter++£¬¼´ºóg_ucUsart2ReceivCounter = 1µÄ g_ucaUsart2ReceiveBuffer[g_ucUsart2ReceivCounter++] = data; } else if(state==1&&data==0xA6) //µÚ¶þ¸öÊDz»ÊÇÖ¡Í·0xA6 { state=2;//Èç¹ûµÚ¶þ¸öÊÇÖ¡Í·0xA6 ¸³Öµstate=2 ±íʾ½ÓÊÕÏÂÒ»¸öÊý¾Ý g_ucaUsart2ReceiveBuffer[g_ucUsart2ReceivCounter++] = data;//±£´æÊý¾Ý } else if(state==2)//È»ºóÈ·¶¨¿ªÍ·ÊÇ0XA5 0XA6 ¾Í¿ªÊ¼½ÓÊÕ { g_ucaUsart2ReceiveBuffer[g_ucUsart2ReceivCounter++]=data; if(g_ucUsart2ReceivCounter>9||data==0x5B) state=3; //½ÓÊÕ´óÓÚ9¸ö»òÕß½ÓÊÕµ½Ö¡Î²0X5B ¾ÍÖÃλ״̬Èý } else if(state==3) //״̬Èý { if(g_ucaUsart2ReceiveBuffer[g_ucUsart2ReceivCounter-1] == 0x5B) //È·¶¨ ×îºóÒ»¸öÊDz»ÊÇ0x5B֡β ÊÇ֡β0x5B ¾ÍÈÏΪͨÐÅÕýÈ· ´¦ÀíÊý¾Ý { state = 0; //ÕâÀï¾Í¿ÉÒÔ´¦ÀíÊý¾ÝÁË¡¢´¦ÀíÍê¼ÇµÃÇå¿ÕÊý×éºÍÖØÖñê־λÓë¼ÆÊýÖµ g_ucUsart2ReceivCounter = 0;//ÇåÁã¼ÆÊýÖµ //±ÈÈç¸ù¾ÝÊý¾ÝÉèÖúìÍâÐý×ªÆ«ÒÆ×´Ì¬ //1.ÉèÖÿìËÙ ÂýËÙÓÒ±ß ×ó±ß Êý×Ö´æ´¢µÄ±äÁ¿ÒâÒå: [0]ºÍ[1]:Ö¡Í·¡¢[2]:ÉãÏñÍ·×ó±ßÊýµÚÒ»¸ö¸ÐÐËÈ¤ÇøÓò¡¢[3]:×ó±ßµÚ¶þ¸ö¡¢[4]:×ó±ßµÚÈý¸ö¡¢[5]:×ó±ßµÚËĸö¡¢[6]:×ó±ßµÚÎå¸ö¡¢[7]:֡β if(g_ucaUsart2ReceiveBuffer[6]==0&&g_ucaUsart2ReceiveBuffer[5]==0&&g_ucaUsart2ReceiveBuffer[3]==0&&g_ucaUsart2ReceiveBuffer[2]==0) { g_cThisState=0;//ǰ½ø g_lHW_State=22222;//ÉèÖÃÕâ¸öÏÔʾÔÚOLEDÉÏ·½±ãµ÷ÊÔ Îå¸öÖµ ÒÔ´Ë´Ó×óÏòÓÒ±íʾ ´Ó×óÏòÓÒµÄÎå¸öÇøÓò } if(g_ucaUsart2ReceiveBuffer[6]==0&&g_ucaUsart2ReceiveBuffer[5]==1&&g_ucaUsart2ReceiveBuffer[3]==0&&g_ucaUsart2ReceiveBuffer[2]==0) { g_cThisState=-1;//Ó¦¸ÃÓÒת g_lHW_State=22212; //±íʾÓÒÊýµÚ¶þ¸ö ʶ±ðµ½Ïß } if(g_ucaUsart2ReceiveBuffer[6]==1&&g_ucaUsart2ReceiveBuffer[5]==0&&g_ucaUsart2ReceiveBuffer[3]==0&&g_ucaUsart2ReceiveBuffer[2]==0) {g_cThisState=-2;//¿ìËÙÓÒת g_lHW_State=22221; } if(g_ucaUsart2ReceiveBuffer[6]==1&&g_ucaUsart2ReceiveBuffer[5]==1&&g_ucaUsart2ReceiveBuffer[3]==0&&g_ucaUsart2ReceiveBuffer[2]==0) {g_cThisState=-3;//¿ìËÙÓÒת g_lHW_State=22211; } if(g_ucaUsart2ReceiveBuffer[6]==0&&g_ucaUsart2ReceiveBuffer[5]==0&&g_ucaUsart2ReceiveBuffer[3]==1&&g_ucaUsart2ReceiveBuffer[2]==0) {g_cThisState=1;//Ó¦¸Ã×óת g_lHW_State=21222; } if(g_ucaUsart2ReceiveBuffer[6]==0&&g_ucaUsart2ReceiveBuffer[5]==0&&g_ucaUsart2ReceiveBuffer[3]==0&&g_ucaUsart2ReceiveBuffer[2]==1) {g_cThisState=2;//¿ìËÙ×óת g_lHW_State=12222; } if(g_ucaUsart2ReceiveBuffer[6]==0&&g_ucaUsart2ReceiveBuffer[5]==0&&g_ucaUsart2ReceiveBuffer[3]==1&&g_ucaUsart2ReceiveBuffer[2]==1) {g_cThisState=3;//¿ìËÙ×óת g_lHW_State=11222; } //2.È»ºóÇå¿ÕÊý×é for(int i=0;i<10;i++) g_ucaUsart2ReceiveBuffer[i]=0x00;//Çå¿ÕÊý×é } else //²»ÊÇ֡β˵Ã÷ͨÐÅ´íÎóÖØÐ¿ªÊ¼½ÓÊÕ { state=0; g_ucUsart2ReceivCounter =0; for(int i=0;i<10;i++) g_ucaUsart2ReceiveBuffer[i]=0x00;//Çå¿ÕÊý×é } } else { //ÆäËûÒì³£Çå¿Õ state=0; g_ucUsart2ReceivCounter =0; for(int i=0;i<10;i++) g_ucaUsart2ReceiveBuffer[i]=0x00;//Çå¿ÕÊý×é } } /* UART ´íÎ󻨵÷º¯Êý ´¦Àí´®¿Ú´íÎó */ void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) { if(__HAL_UART_GET_FLAG(huart,UART_FLAG_ORE) != RESET) //ʹÓÃ__HAL_UART_GET_FLAGºê¼ì²éUARTµÄoverrun´íÎó±ê־λÊÇ·ñ±»ÖÃλ¡£Èç¹û·µ»ØÖµ²»µÈÓÚRESET£¬±íʾoverrun´íÎó±ê־λ±»ÖÃ룬¼´·¢ÉúÁËoverrun´íÎó { __HAL_UART_CLEAR_OREFLAG(huart);//ʹÓÃ__HAL_UART_CLEAR_OREFLAGºêÇå³ýUARTµÄoverrun´íÎó±ê־λ HAL_UART_Receive_IT(&huart2,&g_ucUsart2ReceiveData,1); //ʹÓÃHAL¿âº¯ÊýÆô¶¯UART2½ÓÊÕÖжϣ¬²¢ÉèÖýÓÊÕ»º³åÇøµÄ´óСΪ1×Ö½Ú } } /* USER CODE END 1 */ 这个是我的原来代码,你帮我改一下

#include "reg52.h" #include "stdio.h" #define uchar unsigned char #define uint unsigned int #define DB P0//Òº¾§²¢ÐÐÊý¾Ý½Ó¿Ú sbit RS = P1^0;//Òº¾§Ö¸ÁîÊý¾ÝÐźŠsbit RW = P1^1;//Òº¾§¶ÁдÐźŠsbit E = P1^4;//Òº¾§Ê¹ÄÜÐźŠsbit T_IO=P3^4; //clkΪDS1302µÄʱÖÓÐźÅÏß sbit T_CLK=P3^5; //DATΪDS1302µÄI/OÊý¾ÝÏß sbit T_RST=P1^7; //RSTΪDS1302µÄRSTÐźÅÏß sbit OneWire_DQ=P3^7; char mode=0; sbit buzz=P3^6; char yz1=20; char yz2=60; char setmode=0; char T,TShow; char timeset=0; void delay_ms(unsigned int cnt) // { unsigned int x; for( ; cnt>0; cnt--) { for(x=110; x>0; x--);//Èí¼þÑÓʱΪ1MS } } #if 0 void delay_us(unsigned int cnt) // { while(cnt--); } #endif /******************************************************************************* * º¯ Êý Ãû : LcdWriteCom * º¯Êý¹¦ÄÜ : ÏòLCDдÈëÒ»¸ö×Ö½ÚµÄÃüÁî * Êä Èë : u8com * Êä ³ö : ÎÞ *******************************************************************************/ void lcd_wri_com(unsigned char com) //дÈëÃüÁî { E = 0; //ʹÄÜÇåÁã RS = 0; //Ñ¡ÔñдÈëÃüÁî RW = 0; //Ñ¡ÔñдÈë DB = com; delay_ms(1); E = 1; //дÈëʱÐò delay_ms(5); E = 0; } /******************************************************************************* * º¯ Êý Ãû : LcdWriteData * º¯Êý¹¦ÄÜ : ÏòLCDдÈëÒ»¸ö×Ö½ÚµÄÊý¾Ý * Êä Èë : u8dat * Êä ³ö : ÎÞ *******************************************************************************/ void lcd_wri_data(unsigned char dat)//дÈëÊý¾Ý { E = 0; //ʹÄÜÇåÁã RS = 1; //Ñ¡ÔñдÈëÊý¾Ý RW = 0; //Ñ¡ÔñдÈë DB = dat; delay_ms(1); E = 1; //дÈëʱÐò delay_ms(5); E = 0; } /******************************************************************************* * º¯ Êý Ãû : WriString * º¯Êý¹¦ÄÜ : Ë¢ÐÂÆÁÄ»ÏÔʾ * Êä Èë : hang£¬add£¬*p * Êä ³ö : ÎÞ *******************************************************************************/ void wri_string(unsigned char y,unsigned char x,unsigned char *p) { if(y==1)//Èç¹ûÑ¡ÔñµÚÒ»ÐÐ lcd_wri_com(0x80+x);//Ñ¡ÖеØÖ· else lcd_wri_com(0xc0+x);//Ñ¡ÖеØÖ· while(*p) { lcd_wri_data(*p);//дÈëÊý¾Ý p++; } } /******************************************************************************* * º¯ Êý Ãû : lcd_write_char * º¯Êý¹¦ÄÜ : * Êä Èë : * Êä ³ö : ÎÞ *******************************************************************************/ void lcd_write_char(unsigned char y, unsigned char x, unsigned char dat) //ÁÐx=0~15,ÐÐy=0,1 { unsigned char temp_l, temp_h; if(y==1)//Èç¹ûÑ¡ÔñµÚÒ»ÐÐ lcd_wri_com(0x80+x);//Ñ¡ÖеØÖ· else lcd_wri_com(0xc0+x);//Ñ¡ÖеØÖ· temp_l = dat % 10; temp_h = dat / 10; lcd_wri_data(temp_h + 0x30); //convert to ascii lcd_wri_data(temp_l + 0x30); } /*********************¹â±ê¿ØÖÆ***********************/ void lcd1602_guanbiao(unsigned char y, unsigned char x,unsigned char on_off) { if(on_off == 1) //¿ª¹â±ê { if(y==1)//Èç¹ûÑ¡ÔñµÚÒ»ÐÐ lcd_wri_com(0x80+x); else lcd_wri_com(0xc0+x);//½«¹â±êÒÆ¶¯µ½Ãë¸öλ lcd_wri_com(0x0f);//ÏÔʾ¹â±ê²¢ÇÒÉÁ˸ } else { if(y==1)//Èç¹ûÑ¡ÔñµÚÒ»ÐÐ lcd_wri_com(0x80+x); else lcd_wri_com(0xc0+x);//½«¹â±êÒÆ¶¯µ½Ãë¸öλ lcd_wri_com(0x0c); //¹Ø¹â±ê } } void LCD1602_ShowNumber(unsigned char Row,unsigned char Column,int Data,unsigned char Lenght) { char DataC[16]={0}; unsigned char num; num=sprintf(DataC,"%d",Data); if((Lenght-num)>=0) { wri_string(Row,Column,DataC); // for(i=0;i<(Lenght-num);++i) // lcd_wri_data(' '); } } /******************************************************************************* * º¯ Êý Ãû : LcdInit() * º¯Êý¹¦ÄÜ : ³õʼ»¯LCDÆÁ * Êä Èë : ÎÞ * Êä ³ö : ÎÞ *******************************************************************************/ void lcd_init(void) //LCD³õʼ»¯×Ó³ÌÐò { lcd_wri_com(0x38);//Öù¦ÄÜ8λ˫ÐÐ lcd_wri_com(0x0c);//ÏÔʾ¿ª¹Ø¹â±ê lcd_wri_com(0x06);//×Ö·û½øÈëģʽÆÁÄ»²»¶¯×Ö·ûºóÒÆ delay_ms(5);//ÑÓʱ5ms lcd_wri_com(0x01); //ÇåÆÁ } /** * @brief µ¥×ÜÏß³õʼ»¯ * @param ÎÞ * @retval ´Ó»úÏìӦ룬0ΪÏìÓ¦£¬1ΪδÏìÓ¦ */ unsigned char OneWire_Init(void) { unsigned char i; unsigned char AckBit; OneWire_DQ=1; OneWire_DQ=0; i = 247;while (--i); //Delay 500us OneWire_DQ=1; i = 32;while (--i); //Delay 70us AckBit=OneWire_DQ; i = 247;while (--i); //Delay 500us return AckBit; } /** * @brief µ¥×ÜÏß·¢ËÍһλ * @param Bit Òª·¢Ë͵Äλ * @retval ÎÞ */ void OneWire_SendBit(unsigned char Bit) { unsigned char i; OneWire_DQ=0; i = 4;while (--i); //Delay 10us OneWire_DQ=Bit; i = 24;while (--i); //Delay 50us OneWire_DQ=1; } /** * @brief µ¥×ÜÏß½ÓÊÕһλ * @param ÎÞ * @retval ¶ÁÈ¡µÄλ */ unsigned char OneWire_ReceiveBit(void) { unsigned char i; unsigned char Bit; OneWire_DQ=0; i = 2;while (--i); //Delay 5us OneWire_DQ=1; i = 2;while (--i); //Delay 5us Bit=OneWire_DQ; i = 24;while (--i); //Delay 50us return Bit; } /** * @brief µ¥×ÜÏß·¢ËÍÒ»¸ö×Ö½Ú * @param Byte Òª·¢Ë͵Ä×Ö½Ú * @retval ÎÞ */ void OneWire_SendByte(unsigned char Byte) { unsigned char i; for(i=0;i<8;i++) { OneWire_SendBit(Byte&(0x01<<i)); } } /** * @brief µ¥×ÜÏß½ÓÊÕÒ»¸ö×Ö½Ú * @param ÎÞ * @retval ½ÓÊÕµÄÒ»¸ö×Ö½Ú */ unsigned char OneWire_ReceiveByte(void) { unsigned char i; unsigned char Byte=0x00; for(i=0;i<8;i++) { if(OneWire_ReceiveBit()){Byte|=(0x01<<i);} } return Byte; } #define DS18B20_SKIP_ROM 0xCC #define DS18B20_CONVERT_T 0x44 #define DS18B20_READ_SCRATCHPAD 0xBE /** * @brief DS18B20¿ªÊ¼Î¶ȱ任 * @param ÎÞ * @retval ÎÞ */ void DS18B20_ConvertT(void) { OneWire_Init(); OneWire_SendByte(DS18B20_SKIP_ROM); OneWire_SendByte(DS18B20_CONVERT_T); } /** * @brief DS18B20¶ÁÈ¡ÎÂ¶È * @param ÎÞ * @retval ζÈÊýÖµ */ float DS18B20_ReadT(void) { unsigned char TLSB,TMSB; int Temp; float T; OneWire_Init(); OneWire_SendByte(DS18B20_SKIP_ROM); OneWire_SendByte(DS18B20_READ_SCRATCHPAD); TLSB=OneWire_ReceiveByte(); TMSB=OneWire_ReceiveByte(); Temp=(TMSB<<8)|TLSB; T=Temp/16.0; return T; } void get_1302(uchar time[]); void write_ds1302(uchar dat); uchar r_1302(uchar add); void w_1302(uchar add,uchar dat); uchar read_ds1302(void); void init_1302(uchar *time); void change(); char num0; char num1; char num2; char num3; char num4; char num5; char num6; uchar date[14];//±£´æÈÕÆÚ uchar time_1302[7]={0x00,0x00,0x00,0x03,0x07,0x03,0x08}; uchar time0_1302[7]={0x00,0x00,0x00,0x03,0x07,0x03,0x08}; uchar bdata datbyte; sbit datbyte0=datbyte^0; sbit datbyte7=datbyte^7; //DS1302Ïà¹Øº¯Êý /*========================================== D S 1 3 0 2 ³õ ʼ »¯ ===========================================*/ void init_1302(uchar *time) {uchar i, add; //uchar time_bcd[7]; add=0x80;//0дÈ룬1¶Á³ö w_1302(0x8e,0x00); for(i=0;i<7;i++) {w_1302(add,*time); add+=2; time++; } w_1302(0x8e,0x80); } //=========================== // ¶ÁÈ¡µ±Ç°Ê±¼ä //=========================== void get_1302(uchar time[]) {uchar i; uchar add=0x81; w_1302(0x8e,0x00); for(i=0;i<7;i++) { time[i]=r_1302(add); add+=2; } w_1302(0x8e,0x80); } /*================================= DS1302дÈëÒ»¸ö×Ö½Ú£¨ÉÏÉýÑØÓÐЧ£© =================================*/ void write_ds1302(uchar dat) {uchar i; datbyte=dat; for(i=0;i<8;i++) {T_IO=datbyte0; T_CLK=1; T_CLK=0; datbyte=datbyte>>1; } } /*======================================= DS1302¶Áȡһ¸ö×Ö½Ú£¨Ï½µÑØÓÐЧ£© =======================================*/ uchar read_ds1302(void) {uchar i; for(i=0;i<8;i++) {datbyte=datbyte>>1; datbyte7=T_IO; T_CLK=1; T_CLK=0; } return(datbyte); } /*========================================= Ö¸¶¨Î»ÖöÁÈ¡Êý¾Ý =========================================*/ uchar r_1302(uchar add) {uchar temp,dat1,dat2; T_RST=0; T_CLK=0; T_RST=1; write_ds1302(add); temp=read_ds1302(); T_CLK=1; T_RST=0; dat1=temp/16; dat2=temp%16; temp=dat1*10+dat2; return(temp); } /*========================================== Ö¸¶¨Î»ÖÃдÈëÊý¾Ý ==========================================*/ void w_1302(uchar add,uchar dat) { T_RST=0; T_CLK=0; T_RST=1; write_ds1302(add); write_ds1302(dat/10<<4|dat%10); T_CLK=1; T_RST=0; } //DS1302Êýֵת»» void change() { // ʱ ¼ä µÄ ת »» LCD1602_ShowNumber(2,0,time_1302[2]/10,1); LCD1602_ShowNumber(2,1,time_1302[2]%10,1); wri_string(2,2,":"); LCD1602_ShowNumber(2,3,time_1302[1]/10,1); LCD1602_ShowNumber(2,4,time_1302[1]%10,1); wri_string(2,5,":"); LCD1602_ShowNumber(2,6,time_1302[0]/10,1); LCD1602_ShowNumber(2,7,time_1302[0]%10,1); // ÈÕ ÆÚ µÄ ת »» date[0]='2'; date[1]='0'; date[2]=time_1302[6]/10+'0'; date[3]=time_1302[6]%10+'0'; date[4]='/'; date[5]=time_1302[4]/10+'0'; date[6]=time_1302[4]%10+'0'; date[7]='/'; date[8]=time_1302[3]/10+'0'; date[9]=time_1302[3]%10+'0'; date[10]='/'; date[11]=time_1302[5]/10+'0'; date[12]=time_1302[5]%10-1+'0'; date[13]='\0'; } sbit BUTTON0 = P2^0; sbit BUTTON1 = P2^1; sbit BUTTON2 = P2^2; sbit BUTTON3 = P2^3; sbit BUTTON4 = P2^4; sbit BUTTON5 = P2^5; sbit BUTTON6 = P2^6; sbit BUTTON7 = P2^7; unsigned char button0_pressed(void) { if (BUTTON0 == 0) { // °´Å¥°´ÏÂʱΪµÍµçƽ delay_ms(20); // ÑÓʱȥ¶¶¶¯ if (BUTTON0 == 0) { // Ôٴμì²â°´Å¥×´Ì¬ while (!BUTTON0); // µÈ´ý°´Å¥ÊÍ·Å mode++; if(mode==3){mode=0; wri_string(2,0," "); } return 1; // °´Å¥°´Ï } } return 0; // °´Å¥Î´°´Ï } unsigned char button2_pressed(void) { if (BUTTON2 == 0) { // °´Å¥°´ÏÂʱΪµÍµçƽ delay_ms(20); // ÑÓʱȥ¶¶¶¯ if (BUTTON2 == 0) { // Ôٴμì²â°´Å¥×´Ì¬ while (!BUTTON2); // µÈ´ý°´Å¥ÊÍ·Å if(setmode==0){yz2++; LCD1602_ShowNumber(1,7,yz2);} else{yz1++; LCD1602_ShowNumber(2,7,yz1);} return 1; // °´Å¥°´Ï } } return 0; // °´Å¥Î´°´Ï } unsigned char button3_pressed(void) { if (BUTTON3 == 0) { // °´Å¥°´ÏÂʱΪµÍµçƽ delay_ms(20); // ÑÓʱȥ¶¶¶¯ if (BUTTON3 == 0) { // Ôٴμì²â°´Å¥×´Ì¬ while (!BUTTON3); // µÈ´ý°´Å¥ÊÍ·Å if(setmode==0){yz2--; LCD1602_ShowNumber(1,7,yz2);} else{yz1--; LCD1602_ShowNumber(2,7,yz1);} return 1; // °´Å¥°´Ï } } return 0; // °´Å¥Î´°´Ï } unsigned char button4_pressed(void) { if (BUTTON4 == 0) { // °´Å¥°´ÏÂʱΪµÍµçƽ delay_ms(20); // ÑÓʱȥ¶¶¶¯ if (BUTTON4 == 0) { // Ôٴμì²â°´Å¥×´Ì¬ while (!BUTTON4); // µÈ´ý°´Å¥ÊÍ·Å; return 1; // °´Å¥°´Ï } } return 0; // °´Å¥Î´°´Ï } unsigned char button1_pressed(void) { if (BUTTON1 == 0) { // °´Å¥°´ÏÂʱΪµÍµçƽ delay_ms(20); // ÑÓʱȥ¶¶¶¯ if (BUTTON1 == 0) { // Ôٴμì²â°´Å¥×´Ì¬ while (!BUTTON1); // µÈ´ý°´Å¥ÊÍ·Å wri_string(1,0,"MAX: "); wri_string(2,0,"MIN: "); LCD1602_ShowNumber(1,7,yz2); LCD1602_ShowNumber(2,7,yz1); while(1){ button2_pressed(); button3_pressed(); if(button4_pressed()){setmode=1;break;} } while(1){ button2_pressed(); button3_pressed(); if(button4_pressed()){setmode=0;wri_string(1,0," ");wri_string(2,0," ");break;} } delay_ms(1000); return 1; // °´Å¥°´Ï } } return 0; // °´Å¥Î´°´Ï } unsigned char button5_pressed(void) { if (BUTTON5 == 0) { // °´Å¥°´ÏÂʱΪµÍµçƽ delay_ms(20); // ÑÓʱȥ¶¶¶¯ if (BUTTON5 == 0) { // Ôٴμì²â°´Å¥×´Ì¬ while (!BUTTON5); // µÈ´ý°´Å¥ÊÍ·Å timeset++; if(timeset==6){timeset=0;} return 1; // °´Å¥°´Ï } } return 0; // °´Å¥Î´°´Ï } unsigned char button6_pressed(void) { if (BUTTON6 == 0) { // °´Å¥°´ÏÂʱΪµÍµçƽ delay_ms(20); // ÑÓʱȥ¶¶¶¯ if (BUTTON6 == 0) { // Ôٴμì²â°´Å¥×´Ì¬ while (!BUTTON6); // µÈ´ý°´Å¥ÊÍ·Å switch(timeset){ case 0:num0++;time0_1302[6]=num0;init_1302(time0_1302);break; case 1:num1++;time0_1302[5]=num1;init_1302(time0_1302);break; case 2:num2++;time0_1302[4]=num2;init_1302(time0_1302);break; case 3:num3++;time0_1302[3]=num3;init_1302(time0_1302);break; case 4:num4++;time0_1302[2]=num4;init_1302(time0_1302);break; case 5:num5++;time0_1302[1]=num5;init_1302(time0_1302);break; case 6:num6++;time0_1302[0]=num6;init_1302(time0_1302);break; } return 1; // °´Å¥°´Ï } } return 0; // °´Å¥Î´°´Ï } unsigned char button7_pressed(void) { if (BUTTON7 == 0) { // °´Å¥°´ÏÂʱΪµÍµçƽ delay_ms(20); // ÑÓʱȥ¶¶¶¯ if (BUTTON7 == 0) { // Ôٴμì²â°´Å¥×´Ì¬ while (!BUTTON7); // µÈ´ý°´Å¥ÊÍ·Å switch(timeset){ case 0:num0--;time0_1302[6]=num0;init_1302(time0_1302);break; case 1:num1--;time0_1302[5]=num1;init_1302(time0_1302);break; case 2:num2--;time0_1302[4]=num2;init_1302(time0_1302);break; case 3:num3--;time0_1302[3]=num3;init_1302(time0_1302);break; case 4:num4--;time0_1302[2]=num4;init_1302(time0_1302);break; case 5:num5--;time0_1302[1]=num5;init_1302(time0_1302);break; case 6:num6--;time0_1302[0]=num6;init_1302(time0_1302);break; } return 1; // °´Å¥°´Ï } } return 0; // °´Å¥Î´°´Ï } void openbuzz(){ if(T>yz2||T<yz1){ buzz=1; }else{ buzz=0; } } void main(){ int j; buzz=0; lcd_init(); DS18B20_ConvertT(); for (j=0;j<10;j++){ wri_string(1,j,"ZNWDJ"); wri_string(2,j,"0605"); delay_ms(300); wri_string(1,j," "); wri_string(2,j," "); } while(1){ DS18B20_ConvertT(); //ת»»ÎÂ¶È T=DS18B20_ReadT(); //¶ÁÈ¡ÎÂ¶È openbuzz(); get_1302(time_1302); change(); wri_string(1,0,date); button0_pressed(); button1_pressed(); button2_pressed(); button3_pressed(); button4_pressed(); button5_pressed(); button6_pressed(); button7_pressed(); switch(mode){ case 0: TShow=T; LCD1602_ShowNumber(2,10,TShow,2); break; case 1: TShow=T*1.8+32; LCD1602_ShowNumber(2,10,TShow,3); break; case 2: TShow=T; LCD1602_ShowNumber(2,10,TShow,2); TShow=TShow*1.8+32; wri_string(2.11); LCD1602_ShowNumber(2,12,TShow,3); break; } } }画一个矩阵键盘扫描子程序流程图

#include "global.h" // Device heade sbit PWMB_PIN = P0^4; //¶¨ÒåPWMÊä³öÒý½Å¡£ sbit PWMA_PIN = P0^5; //¶¨ÒåPWMÊä³öÒý½Å¡£ static uint16_t PWM_high,PWM_low; //Öмä±äÁ¿£¬Óû§ÇëÎðÐ޸ġ£ /** * @brief Âí´ïGPIO³õʼ»¯ * @param None * @retval None */ static void Motor_GPIO_Init(void) { GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Mode = GPIO_OUT_PP; GPIO_InitStructure.GPIO_Pin = Left_MotoA_Pin | Left_MotoB_Pin | Right_MotoA_Pin | Right_MotoB_Pin | Right_MotoPWM_Pin | Left_MotoPWM_Pin; GPIO_Init(Motor_Port, &GPIO_InitStructure); GPIO_SetBits(Motor_Port, Left_MotoA_Pin | Left_MotoB_Pin | Right_MotoA_Pin | Right_MotoB_Pin | Right_MotoPWM_Pin | Left_MotoPWM_Pin); } void Motor_PWM_Init(void) { TIM_InitTypeDef TIM_InitStructure; //½á¹¹¶¨Òå TIM_InitStructure.TIM_Mode = TIM_16BitAutoReload; //Ö¸¶¨¹¤×÷ģʽ, TIM_16BitAutoReload,TIM_16Bit,TIM_8BitAutoReload,TIM_16BitAutoReloadNoMask TIM_InitStructure.TIM_Polity = PolityLow; //Ö¸¶¨ÖжÏÓÅÏȼ¶, PolityHigh,PolityLow TIM_InitStructure.TIM_Interrupt = ENABLE; //ÖжÏÊÇ·ñÔÊÐí, ENABLE»òDISABLE TIM_InitStructure.TIM_ClkSource = TIM_CLOCK_1T; //Ö¸¶¨Ê±ÖÓÔ´, TIM_CLOCK_1T,TIM_CLOCK_12T,TIM_CLOCK_Ext TIM_InitStructure.TIM_ClkOut = DISABLE; //ÊÇ·ñÊä³ö¸ßËÙÂö³å, ENABLE»òDISABLE TIM_InitStructure.TIM_Value = 65536UL - PWM_DUTY; //³õÖµ, TIM_InitStructure.TIM_Run = ENABLE; //ÊÇ·ñ³õʼ»¯ºóÆô¶¯¶¨Ê±Æ÷, ENABLE»òDISABLE Timer_Inilize(Timer1,&TIM_InitStructure); //³õʼ»¯ Timer0,Timer1,Timer2 Motor_GPIO_Init(); } /**************** ¼ÆËãPWM֨װֵº¯Êý *******************/ static void LoadPWM(uint16_t i) { uint16_t j; j = 65536UL - PWM_DUTY + i; //¼ÆËãPWMµÍµçƽʱ¼ä i = 65536UL - i; //¼ÆËãPWM¸ßµçƽʱ¼ä EA = 0; PWM_high = i; //×°ÔØPWM¸ßµçƽʱ¼ä PWM_low = j; //×°ÔØPWMµÍµçƽʱ¼ä EA = 1; } /********************* Timer1ÖжϺ¯Êý************************/ void timer1_int (void) interrupt 3 { if(PWMB_PIN) { TH1 = (uint8_t)(PWM_high >> 8); //Èç¹ûÊÇÊä³öµÍµçƽ£¬Ôò×°ÔØ¸ßµçƽʱ¼ä¡£ TL1 = (uint8_t)PWM_high; PWMB_PIN = 0; PWMA_PIN = 0; } else { TH1 = (uint8_t)(PWM_low >> 8); //Èç¹ûÊÇÊä³ö¸ßµçƽ£¬Ôò×°ÔØµÍµçƽʱ¼ä¡£ TL1 = (uint8_t)PWM_low; PWMB_PIN = 1; PWMA_PIN = 1; } } /********************* Timer3ÖжϺ¯Êý************************/ /*STC15F2KûÓж¨Ê±Æ÷3*/ //void timer3_int (void) interrupt 19 //{ // // P1 = 0; // if(PWMA_PIN) // { // T3H = (uint8_t)(PWM_high >> 8); //Èç¹ûÊÇÊä³öµÍµçƽ£¬Ôò×°ÔØ¸ßµçƽʱ¼ä¡£ // T3L = (uint8_t)PWM_high; // PWMA_PIN = 0; // } // else // { // T3H = (uint8_t)(PWM_low >> 8); //Èç¹ûÊÇÊä³ö¸ßµçƽ£¬Ôò×°ÔØµÍµçƽʱ¼ä¡£ // T3L = (uint8_t)PWM_low; // PWMA_PIN = 1; // } //} void Motor_Run(uint8_t dir, uint16_t speed) { speed < PWM_HIGH_MIN ? speed = PWM_HIGH_MIN:speed; //Èç¹ûдÈëСÓÚ×îСռ¿Õ±ÈÊý¾Ý£¬ÔòÇ¿ÖÆÎª×îСռ¿Õ±È¡£ speed > PWM_HIGH_MAX ? speed = PWM_HIGH_MAX:speed; //Èç¹ûдÈë´óÓÚ×î´óÕ¼¿Õ±ÈÊý¾Ý£¬ÔòÇ¿ÖÆÎª×î´óÕ¼¿Õ±È¡£ switch (dir) { case FORWARD: LeftMotor_Go(); RightMotor_Go(); LoadPWM(speed); break; case BACKWARDS: LeftMotor_Back(); RightMotor_Back(); LoadPWM(speed); break; case TURNLEFT: LeftMotor_Stop(); RightMotor_Go(); LoadPWM(speed); break; case TURNRIGHT: LeftMotor_Go(); RightMotor_Stop(); LoadPWM(speed); break; case SPINTURNLEFT: LeftMotor_Back(); RightMotor_Go(); LoadPWM(speed); break; case SPINTURNRIGHT: LeftMotor_Go(); RightMotor_Back(); LoadPWM(speed); break; case STOP: LeftMotor_Stop(); RightMotor_Stop(); LoadPWM(speed); break; default: LeftMotor_Stop(); RightMotor_Stop(); break; } }

/** **************************************************************************************************** * @file usart.c * @author ÕýµãÔ­×ÓÍŶÓ(ALIENTEK) * @version V1.1 * @date 2023-06-05 * @brief ´®¿Ú³õʼ»¯´úÂë(Ò»°ãÊÇ´®¿Ú1)£¬Ö§³Öprintf * @license Copyright (c) 2020-2032, ¹ãÖÝÊÐÐÇÒíµç×ӿƼ¼ÓÐÏÞ¹«Ë¾ **************************************************************************************************** * @attention * * ʵÑéÆ½Ì¨:ÕýµãÔ­×Ó Ì½Ë÷Õß F407¿ª·¢°å * ÔÚÏßÊÓÆµ:www.yuanzige.com * ¼¼ÊõÂÛ̳:www.openedv.com * ¹«Ë¾ÍøÖ·:www.alientek.com * ¹ºÂòµØÖ·:openedv.taobao.com * * ÐÞ¸Ä˵Ã÷ * V1.0 20211014 * µÚÒ»´Î·¢²¼ * V1.1 20230605 * ɾ³ýUSART_UX_IRQHandler()º¯ÊýµÄ³¬Ê±´¦ÀíºÍÐÞ¸ÄHAL_UART_RxCpltCallback() **************************************************************************************************** */ #include "./SYSTEM/sys/sys.h" #include "./SYSTEM/usart/usart.h" /* Èç¹ûʹÓÃos,Ôò°üÀ¨ÏÂÃæµÄÍ·Îļþ¼´¿É */ #if SYS_SUPPORT_OS #include "os.h" /* os ʹÓà */ #endif /******************************************************************************************/ /* ¼ÓÈëÒÔÏ´úÂë, Ö§³Öprintfº¯Êý, ¶ø²»ÐèҪѡÔñuse MicroLIB */ #if 1 #if (__ARMCC_VERSION >= 6010050) /* ʹÓÃAC6±àÒëÆ÷ʱ */ __asm(".global __use_no_semihosting\n\t"); /* ÉùÃ÷²»Ê¹ÓðëÖ÷»úģʽ */ __asm(".global __ARM_use_no_argv \n\t"); /* AC6ÏÂÐèÒªÉùÃ÷mainº¯ÊýΪÎÞ²ÎÊý¸ñʽ£¬·ñÔò²¿·ÖÀý³Ì¿ÉÄܳöÏÖ°ëÖ÷»úģʽ */ #else /* ʹÓÃAC5±àÒëÆ÷ʱ, ÒªÔÚÕâÀﶨÒå__FILE ºÍ ²»Ê¹ÓðëÖ÷»úģʽ */ #pragma import(__use_no_semihosting) struct __FILE { int handle; /* Whatever you require here. If the only file you are using is */ /* standard output using printf() for debugging, no file handling */ /* is required. */ }; #endif /* ²»Ê¹ÓðëÖ÷»úģʽ£¬ÖÁÉÙÐèÒªÖØ¶¨Òå_ttywrch\_sys_exit\_sys_command_stringº¯Êý,ÒÔͬʱ¼æÈÝAC6ºÍAC5ģʽ */ int _ttywrch(int ch) { ch = ch; return ch; } /* ¶¨Òå_sys_exit()ÒÔ±ÜÃâʹÓðëÖ÷»úģʽ */ void _sys_exit(int x) { x = x; } char *_sys_command_string(char *cmd, int len) { return NULL; } /* FILE ÔÚ stdio.hÀïÃæ¶¨Òå. */ FILE __stdout; /* ÖØ¶¨Òåfputcº¯Êý, printfº¯Êý×îÖÕ»áͨ¹ýµ÷ÓÃfputcÊä³ö×Ö·û´®µ½´®¿Ú */ int fputc(int ch, FILE *f) { while ((USART1->SR & 0X40) == 0); /* µÈ´ýÉÏÒ»¸ö×Ö·û·¢ËÍÍê³É */ USART1->DR = (uint8_t)ch; /* ½«Òª·¢Ë͵Ä×Ö·û ch дÈëµ½DR¼Ä´æÆ÷ */ return ch; } #endif /***********************************************END*******************************************/ #if USART_EN_RX /* Èç¹ûʹÄÜÁ˽ÓÊÕ */ /* ½ÓÊÕ»º³å, ×î´óUSART_REC_LEN¸ö×Ö½Ú. */ uint8_t g_usart_rx_buf[USART_REC_LEN]; /* ½ÓÊÕ״̬ * bit15£¬ ½ÓÊÕÍê³É±êÖ¾ * bit14£¬ ½ÓÊÕµ½0x0d * bit13~0£¬ ½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿ */ uint16_t g_usart_rx_sta = 0; uint8_t g_rx_buffer[RXBUFFERSIZE]; /* HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å */ UART_HandleTypeDef g_uart1_handle; /* UART¾ä±ú */ /** * @brief ´®¿ÚX³õʼ»¯º¯Êý * @param baudrate: ²¨ÌØÂÊ, ¸ù¾Ý×Ô¼ºÐèÒªÉèÖò¨ÌØÂÊÖµ * @note ×¢Òâ: ±ØÐëÉèÖÃÕýÈ·µÄʱÖÓÔ´, ·ñÔò´®¿Ú²¨ÌØÂʾͻáÉèÖÃÒì³£. * ÕâÀïµÄUSARTµÄʱÖÓÔ´ÔÚsys_stm32_clock_init()º¯ÊýÖÐÒѾ­ÉèÖùýÁË. * @retval ÎÞ */ void usart_init(uint32_t baudrate) { g_uart1_handle.Instance = USART_UX; /* USART1 */ g_uart1_handle.Init.BaudRate = baudrate; /* ²¨ÌØÂÊ */ g_uart1_handle.Init.WordLength = UART_WORDLENGTH_8B; /* ×Ö³¤Îª8λÊý¾Ý¸ñʽ */ g_uart1_handle.Init.StopBits = UART_STOPBITS_1; /* Ò»¸öֹͣλ */ g_uart1_handle.Init.Parity = UART_PARITY_NONE; /* ÎÞÆæÅ¼Ð£Ñéλ */ g_uart1_handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; /* ÎÞÓ²¼þÁ÷¿Ø */ g_uart1_handle.Init.Mode = UART_MODE_TX_RX; /* ÊÕ·¢Ä£Ê½ */ HAL_UART_Init(&g_uart1_handle); /* HAL_UART_Init()»áʹÄÜUART1 */ /* ¸Ãº¯Êý»á¿ªÆô½ÓÊÕÖжϣº±ê־λUART_IT_RXNE£¬²¢ÇÒÉèÖýÓÊÕ»º³åÒÔ¼°½ÓÊÕ»º³å½ÓÊÕ×î´óÊý¾ÝÁ¿ */ HAL_UART_Receive_IT(&g_uart1_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE); } /** * @brief UARTµ×²ã³õʼ»¯º¯Êý * @param huart: UART¾ä±úÀàÐÍÖ¸Õë * @note ´Ëº¯Êý»á±»HAL_UART_Init()µ÷Óà * Íê³ÉʱÖÓʹÄÜ£¬Òý½ÅÅäÖã¬ÖжÏÅäÖà * @retval ÎÞ */ void HAL_UART_MspInit(UART_HandleTypeDef *huart) { GPIO_InitTypeDef gpio_init_struct; if(huart->Instance == USART_UX) /* Èç¹ûÊÇ´®¿Ú1£¬½øÐд®¿Ú1 MSP³õʼ»¯ */ { USART_UX_CLK_ENABLE(); /* USART1 ʱÖÓʹÄÜ */ USART_TX_GPIO_CLK_ENABLE(); /* ·¢ËÍÒý½ÅʱÖÓʹÄÜ */ USART_RX_GPIO_CLK_ENABLE(); /* ½ÓÊÕÒý½ÅʱÖÓʹÄÜ */ gpio_init_struct.Pin = USART_TX_GPIO_PIN; /* TXÒý½Å */ gpio_init_struct.Mode = GPIO_MODE_AF_PP; /* ¸´ÓÃÍÆÍìÊä³ö */ gpio_init_struct.Pull = GPIO_PULLUP; /* ÉÏÀ­ */ gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH; /* ¸ßËÙ */ gpio_init_struct.Alternate = USART_TX_GPIO_AF; /* ¸´ÓÃΪUSART1 */ HAL_GPIO_Init(USART_TX_GPIO_PORT, &gpio_init_struct); /* ³õʼ»¯·¢ËÍÒý½Å */ gpio_init_struct.Pin = USART_RX_GPIO_PIN; /* RXÒý½Å */ gpio_init_struct.Alternate = USART_RX_GPIO_AF; /* ¸´ÓÃΪUSART1 */ HAL_GPIO_Init(USART_RX_GPIO_PORT, &gpio_init_struct); /* ³õʼ»¯½ÓÊÕÒý½Å */ #if USART_EN_RX HAL_NVIC_EnableIRQ(USART_UX_IRQn); /* ʹÄÜUSART1ÖжÏͨµÀ */ HAL_NVIC_SetPriority(USART_UX_IRQn, 3, 3); /* ÇÀÕ¼ÓÅÏȼ¶3£¬×ÓÓÅÏȼ¶3 */ #endif } } /** * @brief Rx´«Ê仨µ÷º¯Êý * @param huart: UART¾ä±úÀàÐÍÖ¸Õë * @retval ÎÞ */ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { if(huart->Instance == USART_UX) /* Èç¹ûÊÇ´®¿Ú1 */ { if((g_usart_rx_sta & 0x8000) == 0) /* ½ÓÊÕδÍê³É */ { if(g_usart_rx_sta & 0x4000) /* ½ÓÊÕµ½ÁË0x0d */ { if(g_rx_buffer[0] != 0x0a) { g_usart_rx_sta = 0; /* ½ÓÊÕ´íÎó,ÖØÐ¿ªÊ¼ */ } else { g_usart_rx_sta |= 0x8000; /* ½ÓÊÕÍê³ÉÁË */ } } else /* »¹Ã»ÊÕµ½0X0D */ { if(g_rx_buffer[0] == 0x0d) { g_usart_rx_sta |= 0x4000; } else { g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0] ; g_usart_rx_sta++; if(g_usart_rx_sta > (USART_REC_LEN - 1)) { g_usart_rx_sta = 0; /* ½ÓÊÕÊý¾Ý´íÎó,ÖØÐ¿ªÊ¼½ÓÊÕ */ } } } } HAL_UART_Receive_IT(&g_uart1_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE); } } /** * @brief ´®¿Ú1ÖжϷþÎñº¯Êý * @param ÎÞ * @retval ÎÞ */ void USART_UX_IRQHandler(void) { #if SYS_SUPPORT_OS /* ʹÓÃOS */ OSIntEnter(); #endif HAL_UART_IRQHandler(&g_uart1_handle); /* µ÷ÓÃHAL¿âÖжϴ¦Àí¹«Óú¯Êý */ #if SYS_SUPPORT_OS /* ʹÓÃOS */ OSIntExit(); #endif } #endif /** **************************************************************************************************** * @file usart.c * @author ÕýµãÔ­×ÓÍŶÓ(ALIENTEK) * @version V1.1 * @date 2023-06-05 * @brief ´®¿Ú³õʼ»¯´úÂë(Ò»°ãÊÇ´®¿Ú1)£¬Ö§³Öprintf * @license Copyright (c) 2020-2032, ¹ãÖÝÊÐÐÇÒíµç×ӿƼ¼ÓÐÏÞ¹«Ë¾ **************************************************************************************************** * @attention * * ʵÑéÆ½Ì¨:ÕýµãÔ­×Ó Ì½Ë÷Õß F407¿ª·¢°å * ÔÚÏßÊÓÆµ:www.yuanzige.com * ¼¼ÊõÂÛ̳:www.openedv.com * ¹«Ë¾ÍøÖ·:www.alientek.com * ¹ºÂòµØÖ·:openedv.taobao.com * * ÐÞ¸Ä˵Ã÷ * V1.0 20211014 * µÚÒ»´Î·¢²¼ * V1.1 20230605 * ɾ³ýUSART_UX_IRQHandler()º¯ÊýµÄ³¬Ê±´¦ÀíºÍÐÞ¸ÄHAL_UART_RxCpltCallback() **************************************************************************************************** */ #include "./SYSTEM/sys/sys.h" #include "./SYSTEM/usart/usart.h" /* Èç¹ûʹÓÃos,Ôò°üÀ¨ÏÂÃæµÄÍ·Îļþ¼´¿É */ #if SYS_SUPPORT_OS #include "os.h" /* os ʹÓà */ #endif /******************************************************************************************/ /* ¼ÓÈëÒÔÏ´úÂë, Ö§³Öprintfº¯Êý, ¶ø²»ÐèҪѡÔñuse MicroLIB */ #if 1 #if (__ARMCC_VERSION >= 6010050) /* ʹÓÃAC6±àÒëÆ÷ʱ */ __asm(".global __use_no_semihosting\n\t"); /* ÉùÃ÷²»Ê¹ÓðëÖ÷»úģʽ */ __asm(".global __ARM_use_no_argv \n\t"); /* AC6ÏÂÐèÒªÉùÃ÷mainº¯ÊýΪÎÞ²ÎÊý¸ñʽ£¬·ñÔò²¿·ÖÀý³Ì¿ÉÄܳöÏÖ°ëÖ÷»úģʽ */ #else /* ʹÓÃAC5±àÒëÆ÷ʱ, ÒªÔÚÕâÀﶨÒå__FILE ºÍ ²»Ê¹ÓðëÖ÷»úģʽ */ #pragma import(__use_no_semihosting) struct __FILE { int handle; /* Whatever you require here. If the only file you are using is */ /* standard output using printf() for debugging, no file handling */ /* is required. */ }; #endif /* ²»Ê¹ÓðëÖ÷»úģʽ£¬ÖÁÉÙÐèÒªÖØ¶¨Òå_ttywrch\_sys_exit\_sys_command_stringº¯Êý,ÒÔͬʱ¼æÈÝAC6ºÍAC5ģʽ */ int _ttywrch(int ch) { ch = ch; return ch; } /* ¶¨Òå_sys_exit()ÒÔ±ÜÃâʹÓðëÖ÷»úģʽ */ void _sys_exit(int x) { x = x; } char *_sys_command_string(char *cmd, int len) { return NULL; } /* FILE ÔÚ stdio.hÀïÃæ¶¨Òå. */ FILE __stdout; /* ÖØ¶¨Òåfputcº¯Êý, printfº¯Êý×îÖÕ»áͨ¹ýµ÷ÓÃfputcÊä³ö×Ö·û´®µ½´®¿Ú */ int fputc(int ch, FILE *f) { while ((USART1->SR & 0X40) == 0); /* µÈ´ýÉÏÒ»¸ö×Ö·û·¢ËÍÍê³É */ USART1->DR = (uint8_t)ch; /* ½«Òª·¢Ë͵Ä×Ö·û ch дÈëµ½DR¼Ä´æÆ÷ */ return ch; } #endif /***********************************************END*******************************************/ #if USART_EN_RX /* Èç¹ûʹÄÜÁ˽ÓÊÕ */ /* ½ÓÊÕ»º³å, ×î´óUSART_REC_LEN¸ö×Ö½Ú. */ uint8_t g_usart_rx_buf[USART_REC_LEN]; /* ½ÓÊÕ״̬ * bit15£¬ ½ÓÊÕÍê³É±êÖ¾ * bit14£¬ ½ÓÊÕµ½0x0d * bit13~0£¬ ½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿ */ uint16_t g_usart_rx_sta = 0; uint8_t g_rx_buffer[RXBUFFERSIZE]; /* HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å */ UART_HandleTypeDef g_uart1_handle; /* UART¾ä±ú */ /** * @brief ´®¿ÚX³õʼ»¯º¯Êý * @param baudrate: ²¨ÌØÂÊ, ¸ù¾Ý×Ô¼ºÐèÒªÉèÖò¨ÌØÂÊÖµ * @note ×¢Òâ: ±ØÐëÉèÖÃÕýÈ·µÄʱÖÓÔ´, ·ñÔò´®¿Ú²¨ÌØÂʾͻáÉèÖÃÒì³£. * ÕâÀïµÄUSARTµÄʱÖÓÔ´ÔÚsys_stm32_clock_init()º¯ÊýÖÐÒѾ­ÉèÖùýÁË. * @retval ÎÞ */ void usart_init(uint32_t baudrate) { g_uart1_handle.Instance = USART_UX; /* USART1 */ g_uart1_handle.Init.BaudRate = baudrate; /* ²¨ÌØÂÊ */ g_uart1_handle.Init.WordLength = UART_WORDLENGTH_8B; /* ×Ö³¤Îª8λÊý¾Ý¸ñʽ */ g_uart1_handle.Init.StopBits = UART_STOPBITS_1; /* Ò»¸öֹͣλ */ g_uart1_handle.Init.Parity = UART_PARITY_NONE; /* ÎÞÆæÅ¼Ð£Ñéλ */ g_uart1_handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; /* ÎÞÓ²¼þÁ÷¿Ø */ g_uart1_handle.Init.Mode = UART_MODE_TX_RX; /* ÊÕ·¢Ä£Ê½ */ HAL_UART_Init(&g_uart1_handle); /* HAL_UART_Init()»áʹÄÜUART1 */ /* ¸Ãº¯Êý»á¿ªÆô½ÓÊÕÖжϣº±ê־λUART_IT_RXNE£¬²¢ÇÒÉèÖýÓÊÕ»º³åÒÔ¼°½ÓÊÕ»º³å½ÓÊÕ×î´óÊý¾ÝÁ¿ */ HAL_UART_Receive_IT(&g_uart1_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE); } /** * @brief UARTµ×²ã³õʼ»¯º¯Êý * @param huart: UART¾ä±úÀàÐÍÖ¸Õë * @note ´Ëº¯Êý»á±»HAL_UART_Init()µ÷Óà * Íê³ÉʱÖÓʹÄÜ£¬Òý½ÅÅäÖã¬ÖжÏÅäÖà * @retval ÎÞ */ void HAL_UART_MspInit(UART_HandleTypeDef *huart) { GPIO_InitTypeDef gpio_init_struct; if(huart->Instance == USART_UX) /* Èç¹ûÊÇ´®¿Ú1£¬½øÐд®¿Ú1 MSP³õʼ»¯ */ { USART_UX_CLK_ENABLE(); /* USART1 ʱÖÓʹÄÜ */ USART_TX_GPIO_CLK_ENABLE(); /* ·¢ËÍÒý½ÅʱÖÓʹÄÜ */ USART_RX_GPIO_CLK_ENABLE(); /* ½ÓÊÕÒý½ÅʱÖÓʹÄÜ */ gpio_init_struct.Pin = USART_TX_GPIO_PIN; /* TXÒý½Å */ gpio_init_struct.Mode = GPIO_MODE_AF_PP; /* ¸´ÓÃÍÆÍìÊä³ö */ gpio_init_struct.Pull = GPIO_PULLUP; /* ÉÏÀ­ */ gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH; /* ¸ßËÙ */ gpio_init_struct.Alternate = USART_TX_GPIO_AF; /* ¸´ÓÃΪUSART1 */ HAL_GPIO_Init(USART_TX_GPIO_PORT, &gpio_init_struct); /* ³õʼ»¯·¢ËÍÒý½Å */ gpio_init_struct.Pin = USART_RX_GPIO_PIN; /* RXÒý½Å */ gpio_init_struct.Alternate = USART_RX_GPIO_AF; /* ¸´ÓÃΪUSART1 */ HAL_GPIO_Init(USART_RX_GPIO_PORT, &gpio_init_struct); /* ³õʼ»¯½ÓÊÕÒý½Å */ #if USART_EN_RX HAL_NVIC_EnableIRQ(USART_UX_IRQn); /* ʹÄÜUSART1ÖжÏͨµÀ */ HAL_NVIC_SetPriority(USART_UX_IRQn, 3, 3); /* ÇÀÕ¼ÓÅÏȼ¶3£¬×ÓÓÅÏȼ¶3 */ #endif } } /** * @brief Rx´«Ê仨µ÷º¯Êý * @param huart: UART¾ä±úÀàÐÍÖ¸Õë * @retval ÎÞ */ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { if(huart->Instance == USART_UX) /* Èç¹ûÊÇ´®¿Ú1 */ { if((g_usart_rx_sta & 0x8000) == 0) /* ½ÓÊÕδÍê³É */ { if(g_usart_rx_sta & 0x4000) /* ½ÓÊÕµ½ÁË0x0d */ { if(g_rx_buffer[0] != 0x0a) { g_usart_rx_sta = 0; /* ½ÓÊÕ´íÎó,ÖØÐ¿ªÊ¼ */ } else { g_usart_rx_sta |= 0x8000; /* ½ÓÊÕÍê³ÉÁË */ } } else /* »¹Ã»ÊÕµ½0X0D */ { if(g_rx_buffer[0] == 0x0d) { g_usart_rx_sta |= 0x4000; } else { g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0] ; g_usart_rx_sta++; if(g_usart_rx_sta > (USART_REC_LEN - 1)) { g_usart_rx_sta = 0; /* ½ÓÊÕÊý¾Ý´íÎó,ÖØÐ¿ªÊ¼½ÓÊÕ */ } } } } HAL_UART_Receive_IT(&g_uart1_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE); } } /** * @brief ´®¿Ú1ÖжϷþÎñº¯Êý * @param ÎÞ * @retval ÎÞ */ void USART_UX_IRQHandler(void) { #if SYS_SUPPORT_OS /* ʹÓÃOS */ OSIntEnter(); #endif HAL_UART_IRQHandler(&g_uart1_handle); /* µ÷ÓÃHAL¿âÖжϴ¦Àí¹«Óú¯Êý */ #if SYS_SUPPORT_OS /* ʹÓÃOS */ OSIntExit(); #endif } #endif /** **************************************************************************************************** * @file usart.c * @author ÕýµãÔ­×ÓÍŶÓ(ALIENTEK) * @version V1.1 * @date 2023-06-05 * @brief ´®¿Ú³õʼ»¯´úÂë(Ò»°ãÊÇ´®¿Ú1)£¬Ö§³Öprintf * @license Copyright (c) 2020-2032, ¹ãÖÝÊÐÐÇÒíµç×ӿƼ¼ÓÐÏÞ¹«Ë¾ **************************************************************************************************** * @attention * * ʵÑéÆ½Ì¨:ÕýµãÔ­×Ó Ì½Ë÷Õß F407¿ª·¢°å * ÔÚÏßÊÓÆµ:www.yuanzige.com * ¼¼ÊõÂÛ̳:www.openedv.com * ¹«Ë¾ÍøÖ·:www.alientek.com * ¹ºÂòµØÖ·:openedv.taobao.com * * ÐÞ¸Ä˵Ã÷ * V1.0 20211014 * µÚÒ»´Î·¢²¼ * V1.1 20230605 * ɾ³ýUSART_UX_IRQHandler()º¯ÊýµÄ³¬Ê±´¦ÀíºÍÐÞ¸ÄHAL_UART_RxCpltCallback() **************************************************************************************************** */ #include "./SYSTEM/sys/sys.h" #include "./SYSTEM/usart/usart.h" /* Èç¹ûʹÓÃos,Ôò°üÀ¨ÏÂÃæµÄÍ·Îļþ¼´¿É */ #if SYS_SUPPORT_OS #include "os.h" /* os ʹÓà */ #endif /******************************************************************************************/ /* ¼ÓÈëÒÔÏ´úÂë, Ö§³Öprintfº¯Êý, ¶ø²»ÐèҪѡÔñuse MicroLIB */ #if 1 #if (__ARMCC_VERSION >= 6010050) /* ʹÓÃAC6±àÒëÆ÷ʱ */ __asm(".global __use_no_semihosting\n\t"); /* ÉùÃ÷²»Ê¹ÓðëÖ÷»úģʽ */ __asm(".global __ARM_use_no_argv \n\t"); /* AC6ÏÂÐèÒªÉùÃ÷mainº¯ÊýΪÎÞ²ÎÊý¸ñʽ£¬·ñÔò²¿·ÖÀý³Ì¿ÉÄܳöÏÖ°ëÖ÷»úģʽ */ #else /* ʹÓÃAC5±àÒëÆ÷ʱ, ÒªÔÚÕâÀﶨÒå__FILE ºÍ ²»Ê¹ÓðëÖ÷»úģʽ */ #pragma import(__use_no_semihosting) struct __FILE { int handle; /* Whatever you require here. If the only file you are using is */ /* standard output using printf() for debugging, no file handling */ /* is required. */ }; #endif /* ²»Ê¹ÓðëÖ÷»úģʽ£¬ÖÁÉÙÐèÒªÖØ¶¨Òå_ttywrch\_sys_exit\_sys_command_stringº¯Êý,ÒÔͬʱ¼æÈÝAC6ºÍAC5ģʽ */ int _ttywrch(int ch) { ch = ch; return ch; } /* ¶¨Òå_sys_exit()ÒÔ±ÜÃâʹÓðëÖ÷»úģʽ */ void _sys_exit(int x) { x = x; } char *_sys_command_string(char *cmd, int len) { return NULL; } /* FILE ÔÚ stdio.hÀïÃæ¶¨Òå. */ FILE __stdout; /* ÖØ¶¨Òåfputcº¯Êý, printfº¯Êý×îÖÕ»áͨ¹ýµ÷ÓÃfputcÊä³ö×Ö·û´®µ½´®¿Ú */ int fputc(int ch, FILE *f) { while ((USART1->SR & 0X40) == 0); /* µÈ´ýÉÏÒ»¸ö×Ö·û·¢ËÍÍê³É */ USART1->DR = (uint8_t)ch; /* ½«Òª·¢Ë͵Ä×Ö·û ch дÈëµ½DR¼Ä´æÆ÷ */ return ch; } #endif /***********************************************END*******************************************/ #if USART_EN_RX /* Èç¹ûʹÄÜÁ˽ÓÊÕ */ /* ½ÓÊÕ»º³å, ×î´óUSART_REC_LEN¸ö×Ö½Ú. */ uint8_t g_usart_rx_buf[USART_REC_LEN]; /* ½ÓÊÕ״̬ * bit15£¬ ½ÓÊÕÍê³É±êÖ¾ * bit14£¬ ½ÓÊÕµ½0x0d * bit13~0£¬ ½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿ */ uint16_t g_usart_rx_sta = 0; uint8_t g_rx_buffer[RXBUFFERSIZE]; /* HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å */ UART_HandleTypeDef g_uart1_handle; /* UART¾ä±ú */ /** * @brief ´®¿ÚX³õʼ»¯º¯Êý * @param baudrate: ²¨ÌØÂÊ, ¸ù¾Ý×Ô¼ºÐèÒªÉèÖò¨ÌØÂÊÖµ * @note ×¢Òâ: ±ØÐëÉèÖÃÕýÈ·µÄʱÖÓÔ´, ·ñÔò´®¿Ú²¨ÌØÂʾͻáÉèÖÃÒì³£. * ÕâÀïµÄUSARTµÄʱÖÓÔ´ÔÚsys_stm32_clock_init()º¯ÊýÖÐÒѾ­ÉèÖùýÁË. * @retval ÎÞ */ void usart_init(uint32_t baudrate) { g_uart1_handle.Instance = USART_UX; /* USART1 */ g_uart1_handle.Init.BaudRate = baudrate; /* ²¨ÌØÂÊ */ g_uart1_handle.Init.WordLength = UART_WORDLENGTH_8B; /* ×Ö³¤Îª8λÊý¾Ý¸ñʽ */ g_uart1_handle.Init.StopBits = UART_STOPBITS_1; /* Ò»¸öֹͣλ */ g_uart1_handle.Init.Parity = UART_PARITY_NONE; /* ÎÞÆæÅ¼Ð£Ñéλ */ g_uart1_handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; /* ÎÞÓ²¼þÁ÷¿Ø */ g_uart1_handle.Init.Mode = UART_MODE_TX_RX; /* ÊÕ·¢Ä£Ê½ */ HAL_UART_Init(&g_uart1_handle); /* HAL_UART_Init()»áʹÄÜUART1 */ /* ¸Ãº¯Êý»á¿ªÆô½ÓÊÕÖжϣº±ê־λUART_IT_RXNE£¬²¢ÇÒÉèÖýÓÊÕ»º³åÒÔ¼°½ÓÊÕ»º³å½ÓÊÕ×î´óÊý¾ÝÁ¿ */ HAL_UART_Receive_IT(&g_uart1_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE); } /** * @brief UARTµ×²ã³õʼ»¯º¯Êý * @param huart: UART¾ä±úÀàÐÍÖ¸Õë * @note ´Ëº¯Êý»á±»HAL_UART_Init()µ÷Óà * Íê³ÉʱÖÓʹÄÜ£¬Òý½ÅÅäÖã¬ÖжÏÅäÖà * @retval ÎÞ */ void HAL_UART_MspInit(UART_HandleTypeDef *huart) { GPIO_InitTypeDef gpio_init_struct; if(huart->Instance == USART_UX) /* Èç¹ûÊÇ´®¿Ú1£¬½øÐд®¿Ú1 MSP³õʼ»¯ */ { USART_UX_CLK_ENABLE(); /* USART1 ʱÖÓʹÄÜ */ USART_TX_GPIO_CLK_ENABLE(); /* ·¢ËÍÒý½ÅʱÖÓʹÄÜ */ USART_RX_GPIO_CLK_ENABLE(); /* ½ÓÊÕÒý½ÅʱÖÓʹÄÜ */ gpio_init_struct.Pin = USART_TX_GPIO_PIN; /* TXÒý½Å */ gpio_init_struct.Mode = GPIO_MODE_AF_PP; /* ¸´ÓÃÍÆÍìÊä³ö */ gpio_init_struct.Pull = GPIO_PULLUP; /* ÉÏÀ­ */ gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH; /* ¸ßËÙ */ gpio_init_struct.Alternate = USART_TX_GPIO_AF; /* ¸´ÓÃΪUSART1 */ HAL_GPIO_Init(USART_TX_GPIO_PORT, &gpio_init_struct); /* ³õʼ»¯·¢ËÍÒý½Å */ gpio_init_struct.Pin = USART_RX_GPIO_PIN; /* RXÒý½Å */ gpio_init_struct.Alternate = USART_RX_GPIO_AF; /* ¸´ÓÃΪUSART1 */ HAL_GPIO_Init(USART_RX_GPIO_PORT, &gpio_init_struct); /* ³õʼ»¯½ÓÊÕÒý½Å */ #if USART_EN_RX HAL_NVIC_EnableIRQ(USART_UX_IRQn); /* ʹÄÜUSART1ÖжÏͨµÀ */ HAL_NVIC_SetPriority(USART_UX_IRQn, 3, 3); /* ÇÀÕ¼ÓÅÏȼ¶3£¬×ÓÓÅÏȼ¶3 */ #endif } } /** * @brief Rx´«Ê仨µ÷º¯Êý * @param huart: UART¾ä±úÀàÐÍÖ¸Õë * @retval ÎÞ */ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { if(huart->Instance == USART_UX) /* Èç¹ûÊÇ´®¿Ú1 */ { if((g_usart_rx_sta & 0x8000) == 0) /* ½ÓÊÕδÍê³É */ { if(g_usart_rx_sta & 0x4000) /* ½ÓÊÕµ½ÁË0x0d */ { if(g_rx_buffer[0] != 0x0a) { g_usart_rx_sta = 0; /* ½ÓÊÕ´íÎó,ÖØÐ¿ªÊ¼ */ } else { g_usart_rx_sta |= 0x8000; /* ½ÓÊÕÍê³ÉÁË */ } } else /* »¹Ã»ÊÕµ½0X0D */ { if(g_rx_buffer[0] == 0x0d) { g_usart_rx_sta |= 0x4000; } else { g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0] ; g_usart_rx_sta++; if(g_usart_rx_sta > (USART_REC_LEN - 1)) { g_usart_rx_sta = 0; /* ½ÓÊÕÊý¾Ý´íÎó,ÖØÐ¿ªÊ¼½ÓÊÕ */ } } } } HAL_UART_Receive_IT(&g_uart1_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE); } } /** * @brief ´®¿Ú1ÖжϷþÎñº¯Êý * @param ÎÞ * @retval ÎÞ */ void USART_UX_IRQHandler(void) { #if SYS_SUPPORT_OS /* ʹÓÃOS */ OSIntEnter(); #endif HAL_UART_IRQHandler(&g_uart1_handle); /* µ÷ÓÃHAL¿âÖжϴ¦Àí¹«Óú¯Êý */ #if SYS_SUPPORT_OS /* ʹÓÃOS */ OSIntExit(); #endif } #endif /** **************************************************************************************************** * @file usart.c * @author ÕýµãÔ­×ÓÍŶÓ(ALIENTEK) * @version V1.1 * @date 2023-06-05 * @brief ´®¿Ú³õʼ»¯´úÂë(Ò»°ãÊÇ´®¿Ú1)£¬Ö§³Öprintf * @license Copyright (c) 2020-2032, ¹ãÖÝÊÐÐÇÒíµç×ӿƼ¼ÓÐÏÞ¹«Ë¾ **************************************************************************************************** * @attention * * ʵÑéÆ½Ì¨:ÕýµãÔ­×Ó Ì½Ë÷Õß F407¿ª·¢°å * ÔÚÏßÊÓÆµ:www.yuanzige.com * ¼¼ÊõÂÛ̳:www.openedv.com * ¹«Ë¾ÍøÖ·:www.alientek.com * ¹ºÂòµØÖ·:openedv.taobao.com * * ÐÞ¸Ä˵Ã÷ * V1.0 20211014 * µÚÒ»´Î·¢²¼ * V1.1 20230605 * ɾ³ýUSART_UX_IRQHandler()º¯ÊýµÄ³¬Ê±´¦ÀíºÍÐÞ¸ÄHAL_UART_RxCpltCallback() **************************************************************************************************** */ #include "./SYSTEM/sys/sys.h" #include "./SYSTEM/usart/usart.h" /* Èç¹ûʹÓÃos,Ôò°üÀ¨ÏÂÃæµÄÍ·Îļþ¼´¿É */ #if SYS_SUPPORT_OS #include "os.h" /* os ʹÓà */ #endif /******************************************************************************************/ /* ¼ÓÈëÒÔÏ´úÂë, Ö§³Öprintfº¯Êý, ¶ø²»ÐèҪѡÔñuse MicroLIB */ #if 1 #if (__ARMCC_VERSION >= 6010050) /* ʹÓÃAC6±àÒëÆ÷ʱ */ __asm(".global __use_no_semihosting\n\t"); /* ÉùÃ÷²»Ê¹ÓðëÖ÷»úģʽ */ __asm(".global __ARM_use_no_argv \n\t"); /* AC6ÏÂÐèÒªÉùÃ÷mainº¯ÊýΪÎÞ²ÎÊý¸ñʽ£¬·ñÔò²¿·ÖÀý³Ì¿ÉÄܳöÏÖ°ëÖ÷»úģʽ */ #else /* ʹÓÃAC5±àÒëÆ÷ʱ, ÒªÔÚÕâÀﶨÒå__FILE ºÍ ²»Ê¹ÓðëÖ÷»úģʽ */ #pragma import(__use_no_semihosting) struct __FILE { int handle; /* Whatever you require here. If the only file you are using is */ /* standard output using printf() for debugging, no file handling */ /* is required. */ }; #endif /* ²»Ê¹ÓðëÖ÷»úģʽ£¬ÖÁÉÙÐèÒªÖØ¶¨Òå_ttywrch\_sys_exit\_sys_command_stringº¯Êý,ÒÔͬʱ¼æÈÝAC6ºÍAC5ģʽ */ int _ttywrch(int ch) { ch = ch; return ch; } /* ¶¨Òå_sys_exit()ÒÔ±ÜÃâʹÓðëÖ÷»úģʽ */ void _sys_exit(int x) { x = x; } char *_sys_command_string(char *cmd, int len) { return NULL; } /* FILE ÔÚ stdio.hÀïÃæ¶¨Òå. */ FILE __stdout; /* ÖØ¶¨Òåfputcº¯Êý, printfº¯Êý×îÖÕ»áͨ¹ýµ÷ÓÃfputcÊä³ö×Ö·û´®µ½´®¿Ú */ int fputc(int ch, FILE *f) { while ((USART1->SR & 0X40) == 0); /* µÈ´ýÉÏÒ»¸ö×Ö·û·¢ËÍÍê³É */ USART1->DR = (uint8_t)ch; /* ½«Òª·¢Ë͵Ä×Ö·û ch дÈëµ½DR¼Ä´æÆ÷ */ return ch; } #endif /***********************************************END*******************************************/ #if USART_EN_RX /* Èç¹ûʹÄÜÁ˽ÓÊÕ */ /* ½ÓÊÕ»º³å, ×î´óUSART_REC_LEN¸ö×Ö½Ú. */ uint8_t g_usart_rx_buf[USART_REC_LEN]; /* ½ÓÊÕ״̬ * bit15£¬ ½ÓÊÕÍê³É±êÖ¾ * bit14£¬ ½ÓÊÕµ½0x0d * bit13~0£¬ ½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿ */ uint16_t g_usart_rx_sta = 0; uint8_t g_rx_buffer[RXBUFFERSIZE]; /* HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å */ UART_HandleTypeDef g_uart1_handle; /* UART¾ä±ú */ /** * @brief ´®¿ÚX³õʼ»¯º¯Êý * @param baudrate: ²¨ÌØÂÊ, ¸ù¾Ý×Ô¼ºÐèÒªÉèÖò¨ÌØÂÊÖµ * @note ×¢Òâ: ±ØÐëÉèÖÃÕýÈ·µÄʱÖÓÔ´, ·ñÔò´®¿Ú²¨ÌØÂʾͻáÉèÖÃÒì³£. * ÕâÀïµÄUSARTµÄʱÖÓÔ´ÔÚsys_stm32_clock_init()º¯ÊýÖÐÒѾ­ÉèÖùýÁË. * @retval ÎÞ */ void usart_init(uint32_t baudrate) { g_uart1_handle.Instance = USART_UX; /* USART1 */ g_uart1_handle.Init.BaudRate = baudrate; /* ²¨ÌØÂÊ */ g_uart1_handle.Init.WordLength = UART_WORDLENGTH_8B; /* ×Ö³¤Îª8λÊý¾Ý¸ñʽ */ g_uart1_handle.Init.StopBits = UART_STOPBITS_1; /* Ò»¸öֹͣλ */ g_uart1_handle.Init.Parity = UART_PARITY_NONE; /* ÎÞÆæÅ¼Ð£Ñéλ */ g_uart1_handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; /* ÎÞÓ²¼þÁ÷¿Ø */ g_uart1_handle.Init.Mode = UART_MODE_TX_RX; /* ÊÕ·¢Ä£Ê½ */ HAL_UART_Init(&g_uart1_handle); /* HAL_UART_Init()»áʹÄÜUART1 */ /* ¸Ãº¯Êý»á¿ªÆô½ÓÊÕÖжϣº±ê־λUART_IT_RXNE£¬²¢ÇÒÉèÖýÓÊÕ»º³åÒÔ¼°½ÓÊÕ»º³å½ÓÊÕ×î´óÊý¾ÝÁ¿ */ HAL_UART_Receive_IT(&g_uart1_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE); } /** * @brief UARTµ×²ã³õʼ»¯º¯Êý * @param huart: UART¾ä±úÀàÐÍÖ¸Õë * @note ´Ëº¯Êý»á±»HAL_UART_Init()µ÷Óà * Íê³ÉʱÖÓʹÄÜ£¬Òý½ÅÅäÖã¬ÖжÏÅäÖà * @retval ÎÞ */ void HAL_UART_MspInit(UART_HandleTypeDef *huart) { GPIO_InitTypeDef gpio_init_struct; if(huart->Instance == USART_UX) /* Èç¹ûÊÇ´®¿Ú1£¬½øÐд®¿Ú1 MSP³õʼ»¯ */ { USART_UX_CLK_ENABLE(); /* USART1 ʱÖÓʹÄÜ */ USART_TX_GPIO_CLK_ENABLE(); /* ·¢ËÍÒý½ÅʱÖÓʹÄÜ */ USART_RX_GPIO_CLK_ENABLE(); /* ½ÓÊÕÒý½ÅʱÖÓʹÄÜ */ gpio_init_struct.Pin = USART_TX_GPIO_PIN; /* TXÒý½Å */ gpio_init_struct.Mode = GPIO_MODE_AF_PP; /* ¸´ÓÃÍÆÍìÊä³ö */ gpio_init_struct.Pull = GPIO_PULLUP; /* ÉÏÀ­ */ gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH; /* ¸ßËÙ */ gpio_init_struct.Alternate = USART_TX_GPIO_AF; /* ¸´ÓÃΪUSART1 */ HAL_GPIO_Init(USART_TX_GPIO_PORT, &gpio_init_struct); /* ³õʼ»¯·¢ËÍÒý½Å */ gpio_init_struct.Pin = USART_RX_GPIO_PIN; /* RXÒý½Å */ gpio_init_struct.Alternate = USART_RX_GPIO_AF; /* ¸´ÓÃΪUSART1 */ HAL_GPIO_Init(USART_RX_GPIO_PORT, &gpio_init_struct); /* ³õʼ»¯½ÓÊÕÒý½Å */ #if USART_EN_RX HAL_NVIC_EnableIRQ(USART_UX_IRQn); /* ʹÄÜUSART1ÖжÏͨµÀ */ HAL_NVIC_SetPriority(USART_UX_IRQn, 3, 3); /* ÇÀÕ¼ÓÅÏȼ¶3£¬×ÓÓÅÏȼ¶3 */ #endif } } /** * @brief Rx´«Ê仨µ÷º¯Êý * @param huart: UART¾ä±úÀàÐÍÖ¸Õë * @retval ÎÞ */ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { if(huart->Instance == USART_UX) /* Èç¹ûÊÇ´®¿Ú1 */ { if((g_usart_rx_sta & 0x8000) == 0) /* ½ÓÊÕδÍê³É */ { if(g_usart_rx_sta & 0x4000) /* ½ÓÊÕµ½ÁË0x0d */ { if(g_rx_buffer[0] != 0x0a) { g_usart_rx_sta = 0; /* ½ÓÊÕ´íÎó,ÖØÐ¿ªÊ¼ */ } else { g_usart_rx_sta |= 0x8000; /* ½ÓÊÕÍê³ÉÁË */ } } else /* »¹Ã»ÊÕµ½0X0D */ { if(g_rx_buffer[0] == 0x0d) { g_usart_rx_sta |= 0x4000; } else { g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0] ; g_usart_rx_sta++; if(g_usart_rx_sta > (USART_REC_LEN - 1)) { g_usart_rx_sta = 0; /* ½ÓÊÕÊý¾Ý´íÎó,ÖØÐ¿ªÊ¼½ÓÊÕ */ } } } } HAL_UART_Receive_IT(&g_uart1_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE); } } /** * @brief ´®¿Ú1ÖжϷþÎñº¯Êý * @param ÎÞ * @retval ÎÞ */ void USART_UX_IRQHandler(void) { #if SYS_SUPPORT_OS /* ʹÓÃOS */ OSIntEnter(); #endif HAL_UART_IRQHandler(&g_uart1_handle); /* µ÷ÓÃHAL¿âÖжϴ¦Àí¹«Óú¯Êý */ #if SYS_SUPPORT_OS /* ʹÓÃOS */ OSIntExit(); #endif } #endif /** **************************************************************************************************** * @file usart.c * @author ÕýµãÔ­×ÓÍŶÓ(ALIENTEK) * @version V1.1 * @date 2023-06-05 * @brief ´®¿Ú³õʼ»¯´úÂë(Ò»°ãÊÇ´®¿Ú1)£¬Ö§³Öprintf * @license Copyright (c) 2020-2032, ¹ãÖÝÊÐÐÇÒíµç×ӿƼ¼ÓÐÏÞ¹«Ë¾ **************************************************************************************************** * @attention * * ʵÑéÆ½Ì¨:ÕýµãÔ­×Ó Ì½Ë÷Õß F407¿ª·¢°å * ÔÚÏßÊÓÆµ:www.yuanzige.com * ¼¼ÊõÂÛ̳:www.openedv.com * ¹«Ë¾ÍøÖ·:www.alientek.com * ¹ºÂòµØÖ·:openedv.taobao.com * * ÐÞ¸Ä˵Ã÷ * V1.0 20211014 * µÚÒ»´Î·¢²¼ * V1.1 20230605 * ɾ³ýUSART_UX_IRQHandler()º¯ÊýµÄ³¬Ê±´¦ÀíºÍÐÞ¸ÄHAL_UART_RxCpltCallback() **************************************************************************************************** */ #include "./SYSTEM/sys/sys.h" #include "./SYSTEM/usart/usart.h" /* Èç¹ûʹÓÃos,Ôò°üÀ¨ÏÂÃæµÄÍ·Îļþ¼´¿É */ #if SYS_SUPPORT_OS #include "os.h" /* os ʹÓà */ #endif /******************************************************************************************/ /* ¼ÓÈëÒÔÏ´úÂë, Ö§³Öprintfº¯Êý, ¶ø²»ÐèҪѡÔñuse MicroLIB */ #if 1 #if (__ARMCC_VERSION >= 6010050) /* ʹÓÃAC6±àÒëÆ÷ʱ */ __asm(".global __use_no_semihosting\n\t"); /* ÉùÃ÷²»Ê¹ÓðëÖ÷»úģʽ */ __asm(".global __ARM_use_no_argv \n\t"); /* AC6ÏÂÐèÒªÉùÃ÷mainº¯ÊýΪÎÞ²ÎÊý¸ñʽ£¬·ñÔò²¿·ÖÀý³Ì¿ÉÄܳöÏÖ°ëÖ÷»úģʽ */ #else /* ʹÓÃAC5±àÒëÆ÷ʱ, ÒªÔÚÕâÀﶨÒå__FILE ºÍ ²»Ê¹ÓðëÖ÷»úģʽ */ #pragma import(__use_no_semihosting) struct __FILE { int handle; /* Whatever you require here. If the only file you are using is */ /* standard output using printf() for debugging, no file handling */ /* is required. */ }; #endif /* ²»Ê¹ÓðëÖ÷»úģʽ£¬ÖÁÉÙÐèÒªÖØ¶¨Òå_ttywrch\_sys_exit\_sys_command_stringº¯Êý,ÒÔͬʱ¼æÈÝAC6ºÍAC5ģʽ */ int _ttywrch(int ch) { ch = ch; return ch; } /* ¶¨Òå_sys_exit()ÒÔ±ÜÃâʹÓðëÖ÷»úģʽ */ void _sys_exit(int x) { x = x; } char *_sys_command_string(char *cmd, int len) { return NULL; } /* FILE ÔÚ stdio.hÀïÃæ¶¨Òå. */ FILE __stdout; /* ÖØ¶¨Òåfputcº¯Êý, printfº¯Êý×îÖÕ»áͨ¹ýµ÷ÓÃfputcÊä³ö×Ö·û´®µ½´®¿Ú */ int fputc(int ch, FILE *f) { while ((USART1->SR & 0X40) == 0); /* µÈ´ýÉÏÒ»¸ö×Ö·û·¢ËÍÍê³É */ USART1->DR = (uint8_t)ch; /* ½«Òª·¢Ë͵Ä×Ö·û ch дÈëµ½DR¼Ä´æÆ÷ */ return ch; } #endif /***********************************************END*******************************************/ #if USART_EN_RX /* Èç¹ûʹÄÜÁ˽ÓÊÕ */ /* ½ÓÊÕ»º³å, ×î´óUSART_REC_LEN¸ö×Ö½Ú. */ uint8_t g_usart_rx_buf[USART_REC_LEN]; /* ½ÓÊÕ״̬ * bit15£¬ ½ÓÊÕÍê³É±êÖ¾ * bit14£¬ ½ÓÊÕµ½0x0d * bit13~0£¬ ½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿ */ uint16_t g_usart_rx_sta = 0; uint8_t g_rx_buffer[RXBUFFERSIZE]; /* HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å */ UART_HandleTypeDef g_uart1_handle; /* UART¾ä±ú */ /** * @brief ´®¿ÚX³õʼ»¯º¯Êý * @param baudrate: ²¨ÌØÂÊ, ¸ù¾Ý×Ô¼ºÐèÒªÉèÖò¨ÌØÂÊÖµ * @note ×¢Òâ: ±ØÐëÉèÖÃÕýÈ·µÄʱÖÓÔ´, ·ñÔò´®¿Ú²¨ÌØÂʾͻáÉèÖÃÒì³£. * ÕâÀïµÄUSARTµÄʱÖÓÔ´ÔÚsys_stm32_clock_init()º¯ÊýÖÐÒѾ­ÉèÖùýÁË. * @retval ÎÞ */ void usart_init(uint32_t baudrate) { g_uart1_handle.Instance = USART_UX; /* USART1 */ g_uart1_handle.Init.BaudRate = baudrate; /* ²¨ÌØÂÊ */ g_uart1_handle.Init.WordLength = UART_WORDLENGTH_8B; /* ×Ö³¤Îª8λÊý¾Ý¸ñʽ */ g_uart1_handle.Init.StopBits = UART_STOPBITS_1; /* Ò»¸öֹͣλ */ g_uart1_handle.Init.Parity = UART_PARITY_NONE; /* ÎÞÆæÅ¼Ð£Ñéλ */ g_uart1_handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; /* ÎÞÓ²¼þÁ÷¿Ø */ g_uart1_handle.Init.Mode = UART_MODE_TX_RX; /* ÊÕ·¢Ä£Ê½ */ HAL_UART_Init(&g_uart1_handle); /* HAL_UART_Init()»áʹÄÜUART1 */ /* ¸Ãº¯Êý»á¿ªÆô½ÓÊÕÖжϣº±ê־λUART_IT_RXNE£¬²¢ÇÒÉèÖýÓÊÕ»º³åÒÔ¼°½ÓÊÕ»º³å½ÓÊÕ×î´óÊý¾ÝÁ¿ */ HAL_UART_Receive_IT(&g_uart1_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE); } /** * @brief UARTµ×²ã³õʼ»¯º¯Êý * @param huart: UART¾ä±úÀàÐÍÖ¸Õë * @note ´Ëº¯Êý»á±»HAL_UART_Init()µ÷Óà * Íê³ÉʱÖÓʹÄÜ£¬Òý½ÅÅäÖã¬ÖжÏÅäÖà * @retval ÎÞ */ void HAL_UART_MspInit(UART_HandleTypeDef *huart) { GPIO_InitTypeDef gpio_init_struct; if(huart->Instance == USART_UX) /* Èç¹ûÊÇ´®¿Ú1£¬½øÐд®¿Ú1 MSP³õʼ»¯ */ { USART_UX_CLK_ENABLE(); /* USART1 ʱÖÓʹÄÜ */ USART_TX_GPIO_CLK_ENABLE(); /* ·¢ËÍÒý½ÅʱÖÓʹÄÜ */ USART_RX_GPIO_CLK_ENABLE(); /* ½ÓÊÕÒý½ÅʱÖÓʹÄÜ */ gpio_init_struct.Pin = USART_TX_GPIO_PIN; /* TXÒý½Å */ gpio_init_struct.Mode = GPIO_MODE_AF_PP; /* ¸´ÓÃÍÆÍìÊä³ö */ gpio_init_struct.Pull = GPIO_PULLUP; /* ÉÏÀ­ */ gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH; /* ¸ßËÙ */ gpio_init_struct.Alternate = USART_TX_GPIO_AF; /* ¸´ÓÃΪUSART1 */ HAL_GPIO_Init(USART_TX_GPIO_PORT, &gpio_init_struct); /* ³õʼ»¯·¢ËÍÒý½Å */ gpio_init_struct.Pin = USART_RX_GPIO_PIN; /* RXÒý½Å */ gpio_init_struct.Alternate = USART_RX_GPIO_AF; /* ¸´ÓÃΪUSART1 */ HAL_GPIO_Init(USART_RX_GPIO_PORT, &gpio_init_struct); /* ³õʼ»¯½ÓÊÕÒý½Å */ #if USART_EN_RX HAL_NVIC_EnableIRQ(USART_UX_IRQn); /* ʹÄÜUSART1ÖжÏͨµÀ */ HAL_NVIC_SetPriority(USART_UX_IRQn, 3, 3); /* ÇÀÕ¼ÓÅÏȼ¶3£¬×ÓÓÅÏȼ¶3 */ #endif } } /** * @brief Rx´«Ê仨µ÷º¯Êý * @param huart: UART¾ä±úÀàÐÍÖ¸Õë * @retval ÎÞ */ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { if(huart->Instance == USART_UX) /* Èç¹ûÊÇ´®¿Ú1 */ { if((g_usart_rx_sta & 0x8000) == 0) /* ½ÓÊÕδÍê³É */ { if(g_usart_rx_sta & 0x4000) /* ½ÓÊÕµ½ÁË0x0d */ { if(g_rx_buffer[0] != 0x0a) { g_usart_rx_sta = 0; /* ½ÓÊÕ´íÎó,ÖØÐ¿ªÊ¼ */ } else { g_usart_rx_sta |= 0x8000; /* ½ÓÊÕÍê³ÉÁË */ } } else /* »¹Ã»ÊÕµ½0X0D */ { if(g_rx_buffer[0] == 0x0d) { g_usart_rx_sta |= 0x4000; } else { g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0] ; g_usart_rx_sta++; if(g_usart_rx_sta > (USART_REC_LEN - 1)) { g_usart_rx_sta = 0; /* ½ÓÊÕÊý¾Ý´íÎó,ÖØÐ¿ªÊ¼½ÓÊÕ */ } } } } HAL_UART_Receive_IT(&g_uart1_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE); } } /** * @brief ´®¿Ú1ÖжϷþÎñº¯Êý * @param ÎÞ * @retval ÎÞ */ void USART_UX_IRQHandler(void) { #if SYS_SUPPORT_OS /* ʹÓÃOS */ OSIntEnter(); #endif HAL_UART_IRQHandler(&g_uart1_handle); /* µ÷ÓÃHAL¿âÖжϴ¦Àí¹«Óú¯Êý */ #if SYS_SUPPORT_OS /* ʹÓÃOS */ OSIntExit(); #endif } #endif /** **************************************************************************************************** * @file usart.c * @author ÕýµãÔ­×ÓÍŶÓ(ALIENTEK) * @version V1.1 * @date 2023-06-05 * @brief ´®¿Ú³õʼ»¯´úÂë(Ò»°ãÊÇ´®¿Ú1)£¬Ö§³Öprintf * @license Copyright (c) 2020-2032, ¹ãÖÝÊÐÐÇÒíµç×ӿƼ¼ÓÐÏÞ¹«Ë¾ **************************************************************************************************** * @attention * * ʵÑéÆ½Ì¨:ÕýµãÔ­×Ó Ì½Ë÷Õß F407¿ª·¢°å * ÔÚÏßÊÓÆµ:www.yuanzige.com * ¼¼ÊõÂÛ̳:www.openedv.com * ¹«Ë¾ÍøÖ·:www.alientek.com * ¹ºÂòµØÖ·:openedv.taobao.com * * ÐÞ¸Ä˵Ã÷ * V1.0 20211014 * µÚÒ»´Î·¢²¼ * V1.1 20230605 * ɾ³ýUSART_UX_IRQHandler()º¯ÊýµÄ³¬Ê±´¦ÀíºÍÐÞ¸ÄHAL_UART_RxCpltCallback() **************************************************************************************************** */ #include "./SYSTEM/sys/sys.h" #include "./SYSTEM/usart/usart.h" /* Èç¹ûʹÓÃos,Ôò°üÀ¨ÏÂÃæµÄÍ·Îļþ¼´¿É */ #if SYS_SUPPORT_OS #include "os.h" /* os ʹÓà */ #endif /******************************************************************************************/ /* ¼ÓÈëÒÔÏ´úÂë, Ö§³Öprintfº¯Êý, ¶ø²»ÐèҪѡÔñuse MicroLIB */ #if 1 #if (__ARMCC_VERSION >= 6010050) /* ʹÓÃAC6±àÒëÆ÷ʱ */ __asm(".global __use_no_semihosting\n\t"); /* ÉùÃ÷²»Ê¹ÓðëÖ÷»úģʽ */ __asm(".global __ARM_use_no_argv \n\t"); /* AC6ÏÂÐèÒªÉùÃ÷mainº¯ÊýΪÎÞ²ÎÊý¸ñʽ£¬·ñÔò²¿·ÖÀý³Ì¿ÉÄܳöÏÖ°ëÖ÷»úģʽ */ #else /* ʹÓÃAC5±àÒëÆ÷ʱ, ÒªÔÚÕâÀﶨÒå__FILE ºÍ ²»Ê¹ÓðëÖ÷»úģʽ */ #pragma import(__use_no_semihosting) struct __FILE { int handle; /* Whatever you require here. If the only file you are using is */ /* standard output using printf() for debugging, no file handling */ /* is required. */ }; #endif /* ²»Ê¹ÓðëÖ÷»úģʽ£¬ÖÁÉÙÐèÒªÖØ¶¨Òå_ttywrch\_sys_exit\_sys_command_stringº¯Êý,ÒÔͬʱ¼æÈÝAC6ºÍAC5ģʽ */ int _ttywrch(int ch) { ch = ch; return ch; } /* ¶¨Òå_sys_exit()ÒÔ±ÜÃâʹÓðëÖ÷»úģʽ */ void _sys_exit(int x) { x = x; } char *_sys_command_string(char *cmd, int len) { return NULL; } /* FILE ÔÚ stdio.hÀïÃæ¶¨Òå. */ FILE __stdout; /* ÖØ¶¨Òåfputcº¯Êý, printfº¯Êý×îÖÕ»áͨ¹ýµ÷ÓÃfputcÊä³ö×Ö·û´®µ½´®¿Ú */ int fputc(int ch, FILE *f) { while ((USART1->SR & 0X40) == 0); /* µÈ´ýÉÏÒ»¸ö×Ö·û·¢ËÍÍê³É */ USART1->DR = (uint8_t)ch; /* ½«Òª·¢Ë͵Ä×Ö·û ch дÈëµ½DR¼Ä´æÆ÷ */ return ch; } #endif /***********************************************END*******************************************/ #if USART_EN_RX /* Èç¹ûʹÄÜÁ˽ÓÊÕ */ /* ½ÓÊÕ»º³å, ×î´óUSART_REC_LEN¸ö×Ö½Ú. */ uint8_t g_usart_rx_buf[USART_REC_LEN]; /* ½ÓÊÕ״̬ * bit15£¬ ½ÓÊÕÍê³É±êÖ¾ * bit14£¬ ½ÓÊÕµ½0x0d * bit13~0£¬ ½ÓÊÕµ½µÄÓÐЧ×Ö½ÚÊýÄ¿ */ uint16_t g_usart_rx_sta = 0; uint8_t g_rx_buffer[RXBUFFERSIZE]; /* HAL¿âʹÓõĴ®¿Ú½ÓÊÕ»º³å */ UART_HandleTypeDef g_uart1_handle; /* UART¾ä±ú */ /** * @brief ´®¿ÚX³õʼ»¯º¯Êý * @param baudrate: ²¨ÌØÂÊ, ¸ù¾Ý×Ô¼ºÐèÒªÉèÖò¨ÌØÂÊÖµ * @note ×¢Òâ: ±ØÐëÉèÖÃÕýÈ·µÄʱÖÓÔ´, ·ñÔò´®¿Ú²¨ÌØÂʾͻáÉèÖÃÒì³£. * ÕâÀïµÄUSARTµÄʱÖÓÔ´ÔÚsys_stm32_clock_init()º¯ÊýÖÐÒѾ­ÉèÖùýÁË. * @retval ÎÞ */ void usart_init(uint32_t baudrate) { g_uart1_handle.Instance = USART_UX; /* USART1 */ g_uart1_handle.Init.BaudRate = baudrate; /* ²¨ÌØÂÊ */ g_uart1_handle.Init.WordLength = UART_WORDLENGTH_8B; /* ×Ö³¤Îª8λÊý¾Ý¸ñʽ */ g_uart1_handle.Init.StopBits = UART_STOPBITS_1; /* Ò»¸öֹͣλ */ g_uart1_handle.Init.Parity = UART_PARITY_NONE; /* ÎÞÆæÅ¼Ð£Ñéλ */ g_uart1_handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; /* ÎÞÓ²¼þÁ÷¿Ø */ g_uart1_handle.Init.Mode = UART_MODE_TX_RX; /* ÊÕ·¢Ä£Ê½ */ HAL_UART_Init(&g_uart1_handle); /* HAL_UART_Init()»áʹÄÜUART1 */ /* ¸Ãº¯Êý»á¿ªÆô½ÓÊÕÖжϣº±ê־λUART_IT_RXNE£¬²¢ÇÒÉèÖýÓÊÕ»º³åÒÔ¼°½ÓÊÕ»º³å½ÓÊÕ×î´óÊý¾ÝÁ¿ */ HAL_UART_Receive_IT(&g_uart1_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE); } /** * @brief UARTµ×²ã³õʼ»¯º¯Êý * @param huart: UART¾ä±úÀàÐÍÖ¸Õë * @note ´Ëº¯Êý»á±»HAL_UART_Init()µ÷Óà * Íê³ÉʱÖÓʹÄÜ£¬Òý½ÅÅäÖã¬ÖжÏÅäÖà * @retval ÎÞ */ void HAL_UART_MspInit(UART_HandleTypeDef *huart) { GPIO_InitTypeDef gpio_init_struct; if(huart->Instance == USART_UX) /* Èç¹ûÊÇ´®¿Ú1£¬½øÐд®¿Ú1 MSP³õʼ»¯ */ { USART_UX_CLK_ENABLE(); /* USART1 ʱÖÓʹÄÜ */ USART_TX_GPIO_CLK_ENABLE(); /* ·¢ËÍÒý½ÅʱÖÓʹÄÜ */ USART_RX_GPIO_CLK_ENABLE(); /* ½ÓÊÕÒý½ÅʱÖÓʹÄÜ */ gpio_init_struct.Pin = USART_TX_GPIO_PIN; /* TXÒý½Å */ gpio_init_struct.Mode = GPIO_MODE_AF_PP; /* ¸´ÓÃÍÆÍìÊä³ö */ gpio_init_struct.Pull = GPIO_PULLUP; /* ÉÏÀ­ */ gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH; /* ¸ßËÙ */ gpio_init_struct.Alternate = USART_TX_GPIO_AF; /* ¸´ÓÃΪUSART1 */ HAL_GPIO_Init(USART_TX_GPIO_PORT, &gpio_init_struct); /* ³õʼ»¯·¢ËÍÒý½Å */ gpio_init_struct.Pin = USART_RX_GPIO_PIN; /* RXÒý½Å */ gpio_init_struct.Alternate = USART_RX_GPIO_AF; /* ¸´ÓÃΪUSART1 */ HAL_GPIO_Init(USART_RX_GPIO_PORT, &gpio_init_struct); /* ³õʼ»¯½ÓÊÕÒý½Å */ #if USART_EN_RX HAL_NVIC_EnableIRQ(USART_UX_IRQn); /* ʹÄÜUSART1ÖжÏͨµÀ */ HAL_NVIC_SetPriority(USART_UX_IRQn, 3, 3); /* ÇÀÕ¼ÓÅÏȼ¶3£¬×ÓÓÅÏȼ¶3 */ #endif } } /** * @brief Rx´«Ê仨µ÷º¯Êý * @param huart: UART¾ä±úÀàÐÍÖ¸Õë * @retval ÎÞ */ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { if(huart->Instance == USART_UX) /* Èç¹ûÊÇ´®¿Ú1 */ { if((g_usart_rx_sta & 0x8000) == 0) /* ½ÓÊÕδÍê³É */ { if(g_usart_rx_sta & 0x4000) /* ½ÓÊÕµ½ÁË0x0d */ { if(g_rx_buffer[0] != 0x0a) { g_usart_rx_sta = 0; /* ½ÓÊÕ´íÎó,ÖØÐ¿ªÊ¼ */ } else { g_usart_rx_sta |= 0x8000; /* ½ÓÊÕÍê³ÉÁË */ } } else /* »¹Ã»ÊÕµ½0X0D */ { if(g_rx_buffer[0] == 0x0d) { g_usart_rx_sta |= 0x4000; } else { g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0] ; g_usart_rx_sta++; if(g_usart_rx_sta > (USART_REC_LEN - 1)) { g_usart_rx_sta = 0; /* ½ÓÊÕÊý¾Ý´íÎó,ÖØÐ¿ªÊ¼½ÓÊÕ */ } } } } HAL_UART_Receive_IT(&g_uart1_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE); } } /** * @brief ´®¿Ú1ÖжϷþÎñº¯Êý * @param ÎÞ * @retval ÎÞ */ void USART_UX_IRQHandler(void) { #if SYS_SUPPORT_OS /* ʹÓÃOS */ OSIntEnter(); #endif HAL_UART_IRQHandler(&g_uart1_handle); /* µ÷ÓÃHAL¿âÖжϴ¦Àí¹«Óú¯Êý */ #if SYS_SUPPORT_OS /* ʹÓÃOS */ OSIntExit(); #endif } #endif (我要使输入的在LCD上面显示应该怎么做)

****************************************************************************** * @file main.c * @author fire * @version V1.0 * @date 2013-xx-xx * @brief Òº¾§ÏÔʾºº×ÖʵÑ飨×Ö¿âÔÚÍⲿFLASH£© ****************************************************************************** * @attention * * ʵÑéÆ½Ì¨:±ü»ð F103-Ö¸ÄÏÕß STM32 ¿ª·¢°å * ÂÛ̳ :http://www.firebbs.cn * ÌÔ±¦ :https://fire-stm32.taobao.com * ****************************************************************************** */ #include "stm32f10x.h" #include "./usart/bsp_usart.h" #include "./lcd/bsp_ili9341_lcd.h" #include "./flash/bsp_spi_flash.h" static void LCD_Test(void); static void Delay ( __IO uint32_t nCount ); void Printf_Charater(void) ; int main(void) { //LCD ³õʼ»¯ ILI9341_Init (); /* USART config */ USART_Config(); printf("\r\n ********** Òº¾§ÆÁÖÐÎÄÏÔʾ³ÌÐò£¨×Ö¿âÔÚÍⲿFLASH£©*********** \r\n"); printf("\r\n Èôºº×ÖÏÔʾ²»Õý³££¬ÇëÔĶÁ¹¤³ÌÖеÄreadme.txtÎļþ˵Ã÷£¬¸ù¾ÝÒªÇó¸øFLASHÖØË¢×ÖÄ£Êý¾Ý\r\n"); //ÆäÖÐ0¡¢3¡¢5¡¢6 ģʽÊʺϴÓ×óÖÁÓÒÏÔʾÎÄ×Ö£¬ //²»ÍƼöʹÓÃÆäËüģʽÏÔʾÎÄ×Ö ÆäËüģʽÏÔʾÎÄ×Ö»áÓоµÏñЧ¹û //ÆäÖÐ 6 ģʽΪ´ó²¿·ÖÒº¾§Àý³ÌµÄĬÈÏÏÔʾ·½Ïò ILI9341_GramScan ( 6 ); Printf_Charater(); while ( 1 ) { LCD_Test(); } } /*ÓÃÓÚ²âÊÔ¸÷ÖÖÒº¾§µÄº¯Êý*/ void LCD_Test(void) { /*ÑÝʾÏÔʾ±äÁ¿*/ static uint8_t testCNT = 0; char dispBuff[100]; testCNT++; LCD_SetFont(&Font8x16); LCD_SetColors(RED,BLACK); ILI9341_Clear(0,0,LCD_X_LENGTH,LCD_Y_LENGTH); /* ÇåÆÁ£¬ÏÔʾȫºÚ */ /********ÏÔʾ×Ö·û´®Ê¾Àý*******/ ILI9341_DispStringLine_EN_CH(LINE(0),"±ü»ð3.2´çLCD²ÎÊý£º"); ILI9341_DispStringLine_EN_CH(LINE(1),"·Ö±æÂÊ£º240x320 px"); ILI9341_DispStringLine_EN_CH(LINE(2),"ILI9341Òº¾§Çý¶¯"); ILI9341_DispStringLine_EN_CH(LINE(3),"XPT2046´¥ÃþÆÁÇý¶¯"); /********ÏÔʾ±äÁ¿Ê¾Àý*******/ LCD_SetTextColor(GREEN); /*ʹÓÃc±ê×¼¿â°Ñ±äÁ¿×ª»¯³É×Ö·û´®*/ sprintf(dispBuff,"ÏÔʾ±äÁ¿£º %d ",testCNT); LCD_ClearLine(LINE(5)); /* Çå³ýµ¥ÐÐÎÄ×Ö */ /*È»ºóÏÔʾ¸Ã×Ö·û´®¼´¿É£¬ÆäËü±äÁ¿Ò²ÊÇÕâÑù´¦Àí*/ ILI9341_DispStringLine_EN_CH(LINE(5),dispBuff); /*******ÏÔʾͼÐÎʾÀý******/ /* »­Ö±Ïß */ LCD_ClearLine(LINE(7));/* Çå³ýµ¥ÐÐÎÄ×Ö */ LCD_SetTextColor(BLUE); ILI9341_DispStringLine_EN_CH(LINE(7),"»­Ö±Ïߣº"); LCD_SetTextColor(RED); ILI9341_DrawLine(50,170,210,230); ILI9341_DrawLine(50,200,210,240); LCD_SetTextColor(GREEN); ILI9341_DrawLine(100,170,200,230); ILI9341_DrawLine(200,200,220,240); LCD_SetTextColor(BLUE); ILI9341_DrawLine(110,170,110,230); ILI9341_DrawLine(130,200,220,240); Delay(0xFFFFFF); ILI9341_Clear(0,16*8,LCD_X_LENGTH,LCD_Y_LENGTH-16*8); /* ÇåÆÁ£¬ÏÔʾȫºÚ */ /*»­¾ØÐÎ*/ LCD_ClearLine(LINE(7)); /* Çå³ýµ¥ÐÐÎÄ×Ö */ LCD_SetTextColor(BLUE); ILI9341_DispStringLine_EN_CH(LINE(7),"»­¾ØÐΣº"); LCD_SetTextColor(RED); ILI9341_DrawRectangle(50,200,100,30,1); LCD_SetTextColor(GREEN); ILI9341_DrawRectangle(160,200,20,40,0); LCD_SetTextColor(BLUE); ILI9341_DrawRectangle(170,200,50,20,1); Delay(0xFFFFFF); ILI9341_Clear(0,16*8,LCD_X_LENGTH,LCD_Y_LENGTH-16*8); /* ÇåÆÁ£¬ÏÔʾȫºÚ */ /* »­Ô² */ LCD_ClearLine(LINE(7)); /* Çå³ýµ¥ÐÐÎÄ×Ö */ LCD_SetTextColor(BLUE); ILI9341_DispStringLine_EN_CH(LINE(7),"»­Ô²"); LCD_SetTextColor(RED); ILI9341_DrawCircle(100,200,20,0); LCD_SetTextColor(GREEN); ILI9341_DrawCircle(100,200,10,1); LCD_SetTextColor(BLUE); ILI9341_DrawCircle(140,200,20,0); Delay(0xFFFFFF); ILI9341_Clear(0,16*8,LCD_X_LENGTH,LCD_Y_LENGTH-16*8); /* ÇåÆÁ£¬ÏÔʾȫºÚ */ } /** * @brief ¼òµ¥ÑÓʱº¯Êý * @param nCount £ºÑÓʱ¼ÆÊýÖµ * @retval ÎÞ */ static void Delay ( __IO uint32_t nCount ) { for ( ; nCount != 0; nCount -- ); } /*"µ±"×Ö·ûµÄ×ÖÄ£16x16 */ unsigned char charater_matrix[] = { /*"µ±",0*/ 0x01,0x00,0x21,0x08,0x11,0x08,0x09,0x10,0x09,0x20,0x01,0x00,0x7F,0xF8,0x00, 0x08, 0x00,0x08,0x00,0x08,0x3F,0xF8,0x00,0x08,0x00,0x08,0x00,0x08,0x7F,0xF8,0x00,0x08, }; /** * @brief ʹÓô®¿ÚÔÚÉÏλ»ú´òÓ¡×ÖÄ£ * ÑÝʾ×ÖÄ£ÏÔʾԭÀí * @retval ÎÞ */ void Printf_Charater(void) { int i,j; unsigned char kk; /*iÓÃ×÷ÐмÆÊý*/ for ( i=0;i<16;i++) { /*jÓÃ×÷Ò»×Ö½ÚÄÚÊý¾ÝµÄÒÆÎ»¼ÆÊý*/ /*Ò»ÐÐÏñËØµÄµÚÒ»¸ö×Ö½Ú*/ for(j=0; j<8; j++) { /*Ò»¸öÊý¾Ýλһ¸öÊý¾ÝλµØ´¦Àí*/ kk = charater_matrix[2*i] << j ; //×óÒÆJλ if( kk & 0x80) { printf("*"); //Èç¹û×î¸ßλΪ1£¬Êä³ö*ºÅ£¬±íʾ±Ê¼£ } else { printf(" "); //Èç¹û×î¸ßλΪ0£¬Êä³ö¿Õ¸ñ£¬±íʾ¿Õ°× } } /*Ò»ÐÐÏñËØµÄµÚ¶þ¸ö×Ö½Ú*/ for(j=0; j<8; j++) { kk = charater_matrix[2*i+1] << j ; //×óÒÆJλ if( kk & 0x80) { printf("*"); //Èç¹û×î¸ßλΪ1£¬Êä³ö*ºÅ£¬±íʾ±Ê¼£ } else { printf(" "); //Èç¹û×î¸ßλΪ0£¬Êä³ö¿Õ¸ñ£¬±íʾ¿Õ°× } } printf("\n"); //Êä³öÍêÒ»ÐÐÏñËØ£¬»»ÐÐ } printf("\n\n"); //Ò»¸ö×ÖÊä³öÍê±Ï } /* ------------------------------------------end of file---------------------------------------- */ 显示屏至少要显示两屏; 一屏:绘制转速的仪表盘界面;仪表盘界面的样式自行确定; 另一屏:绘制柱状图,坐标和曲线图;

大家在看

recommend-type

复盛压缩机选型软件.rar )

此款为官方专用,简单的压缩机可以选择。SRL型的没有,暂时不能使用请谨慎选择
recommend-type

多模态生理数据预测状态-飞行员

对应文章https://blog.csdn.net/devshilei/article/details/135049559中的图片以及logo
recommend-type

cubase 5 机架 好用方便的机架文件,内含效果器插件

cubase 5 机架 好用方便的机架文件,内含效果器插件
recommend-type

ISO 6469-3-2021 电动道路车辆 - 安全规范 - 第 3 部分:电气安全.docx

国际标准,txt格式 本文件规定了电力推进系统电压 B 级电路和电动道路车辆导电连接辅助电力系统的电气安全要求。 它规定了保护人员免受电击和热事故的电气安全要求。 它没有为制造、维护和维修人员提供全面的安全信息。 注 1: 碰撞后的电气安全要求在 ISO 6469-4 中有描述。 注 2:ISO 17409 描述了电动道路车辆与外部电源的导电连接的电气安全要求。 注 3: 外部磁场无线功率传输的特殊电气安全要求 在 ISO 19363 中描述了电力供应和电动车辆。 注 4 摩托车和轻便摩托车的电气安全要求在 ISO 13063 系列中有描述。 2 引用标准 以下文件在文中的引用方式是,其部分或全部内容构成本文件的要求。对于注明日期的参考文献,只有引用的版本适用。对于未注明日期的引用,引用文件的最新版本 (包括任何修订) 适用。 ISO 17409: 电动道路车辆。导电动力传输。安全要求 ISO 20653,道路车辆 - 保护程度 (IP 代码)- 电气设备防异物、水和接触的保护 IEC 60664 (所有部件) 低压系统内设备的绝缘配合 IEC 60990:2016,接触电流和保护导体
recommend-type

中国检查徽章背景的检察机关PPT模板

这是一套中国检查徽章背景的,检察机关PPT模板。第一PPT模板网提供精美军警类幻灯片模板免费下载; 关键词:蓝天白云、华表、彩带、中国检查徽章PPT背景图片,中国检查院工作汇报PPT模板,蓝色绿色搭配扁平化幻灯片图表,.PPTX格式;

最新推荐

recommend-type

§1.1-MATLAB操作界面.ppt

§1.1-MATLAB操作界面.ppt
recommend-type

英语-信息化教学设计.doc

英语-信息化教学设计.doc
recommend-type

数据库管理规范.doc

数据库管理规范.doc
recommend-type

GSM-R网络系统在武九电气化铁路无线通信中的应用.docx

GSM-R网络系统在武九电气化铁路无线通信中的应用.docx
recommend-type

b2c购物网站设计开题报告.doc

b2c购物网站设计开题报告.doc
recommend-type

全面解析SOAP库包功能与应用

从给定的文件信息中,我们可以提取到的核心知识点主要集中在“SOAP”这一项技术上,由于提供的信息量有限,这里将尽可能详细地解释SOAP相关的知识。 首先,SOAP代表简单对象访问协议(Simple Object Access Protocol),是一种基于XML的消息传递协议。它主要用于在网络上不同应用程序之间的通信。SOAP定义了如何通过HTTP和XML格式来构造消息,并规定了消息的格式应遵循XML模式。这种消息格式使得两个不同平台或不同编程语言的应用程序之间能够进行松耦合的服务交互。 在分布式计算环境中,SOAP作为一种中间件技术,可以被看作是应用程序之间的一种远程过程调用(RPC)机制。它通常与Web服务结合使用,Web服务是使用特定标准实现的软件系统,它公开了可以通过网络(通常是互联网)访问的API。当客户端与服务端通过SOAP进行通信时,客户端可以调用服务端上特定的方法,而不需要关心该服务是如何实现的,或者是运行在什么类型的服务器上。 SOAP协议的特点主要包括: 1. **平台无关性**:SOAP基于XML,XML是一种跨平台的标准化数据格式,因此SOAP能够跨越不同的操作系统和编程语言平台进行通信。 2. **HTTP协议绑定**:虽然SOAP协议本身独立于传输协议,但是它通常与HTTP协议绑定,这使得SOAP能够利用HTTP的普及性和无需额外配置的优势。 3. **消息模型**:SOAP消息是交换信息的载体,遵循严格的结构,包含三个主要部分:信封(Envelope)、标题(Header)和正文(Body)。信封是消息的外壳,定义了消息的开始和结束;标题可以包含各种可选属性,如安全性信息;正文则是实际的消息内容。 4. **错误处理**:SOAP提供了详细的错误处理机制,可以通过错误码和错误信息来描述消息处理过程中的错误情况。 5. **安全性和事务支持**:SOAP协议可以集成各种安全性标准,如WS-Security,以确保消息传输过程中的安全性和完整性。同时,SOAP消息可以包含事务信息,以便于服务端处理事务性的业务逻辑。 在描述中提到的“所有库包”,这可能意味着包含了SOAP协议的实现、相关工具集或库等。由于信息不足,这里的“库包”具体指的是什么并不清楚,但可以理解为与SOAP相关的软件开发工具包(SDK)或框架,它们使得开发者可以更加方便地创建SOAP消息,处理SOAP请求和响应,以及实现Web服务。 至于“压缩包子文件的文件名称列表”中只有一个单词“soap”,这可能表明实际文件内容仅有一个与SOAP相关的文件,或者是一个压缩包文件的名称为“soap”。由于缺乏更详尽的文件列表,无法进一步分析其可能的内容。 综上所述,SOAP作为一种实现Web服务的技术标准,通过HTTP和XML实现系统间的通信。它支持跨平台、跨语言的服务调用,并具备强大的安全性和错误处理机制。在具体应用中,开发者可能需要用到与之相关的库包或工具集来开发和部署Web服务。
recommend-type

编程语言选择指南:为不同项目量身定制的编程语言策略

# 摘要 选择合适的编程语言对于软件项目的成功至关重要。本文首先探讨了编程语言选择的重要性,并对不同分类和特点的编程语言进行了详尽分析,重点介绍了静态与动态类型、解释型与编译型、面向对象与函数式编程语言的区别和应用场景。接着,文章根据项目需求详细讨论了如何选择适合的编程语言,包括功能需求、性能考量、开发效率和团队技能等关键因素。通过实践案例分析,本文进一步探讨了不同
recommend-type

手写vue2的插件vue-router

<think>我们正在手写一个简化版的vue-router插件,用于Vue2。主要步骤:1.定义一个类VueRouter,包含路由映射、当前路由状态等。2.实现install方法,用于Vue.use()安装插件,在install方法中:-混入beforeCreate生命周期钩子,在组件创建时初始化router。-全局注册router-view和router-link组件。3.实现路由映射:将路由配置转换为路径与组件的映射表。4.监听hashchange事件(或者使用history模式,这里以hash模式为例)来响应路由变化。5.实现router-view组件,根据当前路由渲染对应组件。6.实现
recommend-type

《软件工程:实践者的方法》第6版课件解析

根据提供的文件信息,我们可以推断出以下知识点: 1. 课程名称:“SOFTWARE ENGINEERING A practitioner's approach 6e”,表明这是关于软件工程的课程教材,第6版,针对实践者的教学方法。 2. 版本信息:由于标题中明确指出是第6版(6e),我们知道这是一系列教科书或课件的最新版本,这意味着内容已经根据最新的软件工程理论和实践进行了更新和改进。 3. 课程类型:课程是针对“practitioner”,即实践者的,这表明教材旨在教授学生如何将理论知识应用于实际工作中,注重解决实际问题和案例学习,可能包含大量的项目管理、需求分析、系统设计和测试等方面的内容。 4. 适用范围:文件描述中提到了“仅供校园内使用”,说明这个教材是专为教育机构内部学习而设计的,可能含有某些版权保护的内容,不允许未经授权的外部使用。 5. 标签:“SOFTWARE ENGINEERING A practitioner's approach 6e 软件工程”提供了关于这门课程的直接标签信息。标签不仅重复了课程名称,还强化了这是关于软件工程的知识。软件工程作为一门学科,涉及软件开发的整个生命周期,从需求收集、设计、编码、测试到维护和退役,因此课程内容可能涵盖了这些方面。 6. 文件命名:压缩包文件名“SftEng”是“SOFTWARE ENGINEERING”的缩写,表明该压缩包包含的是软件工程相关的教材或资料。 7. 关键知识点:根据标题和描述,我们可以推测课件中可能包含的知识点有: - 软件工程基础理论:包括软件工程的定义、目标、原则和软件开发生命周期的模型。 - 需求分析:学习如何获取、分析、记录和管理软件需求。 - 系统设计:涉及软件架构设计、数据库设计、界面设计等,以及如何将需求转化为设计文档。 - 实现与编码:包括编程语言的选择、代码编写规范、版本控制等。 - 测试:软件测试的原则、方法和测试用例的设计。 - 项目管理:时间管理、团队协作、风险管理、成本估算等与软件项目成功相关的管理活动。 - 质量保证:软件质量模型、质量度量和质量控制措施。 - 维护和演化:软件部署后如何进行持续维护、升级和系统退役。 - 软件工程的新兴领域:包括敏捷开发方法、DevOps、用户体验设计等现代软件开发趋势。 8. 版权和使用限制:由于是专供校园内使用的教材,课件可能包含版权声明和使用限制,要求用户在没有授权的情况下不得对外传播和用于商业用途。 综上所述,这门课程的课件是为校园内的学生和教职员工设计的,关于软件工程的全面教育材料,覆盖了理论知识和实践技巧,并且在版权方面有所限制。由于是最新版的教材,它很可能包含了最新的软件工程技术和方法论。
recommend-type

QUARTUS II 13.0全攻略:新手到专家的10个必备技能

# 摘要 本文旨在详细介绍QUARTUS II 13.0软件的使用,包括其安装、FPGA基础、项目设置、设计流程、高级功能应用