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

大一电赛：51单片机(状态机编程)——控制外部开关(继电器)达到自定义输出波_51单片机状态机编程方法

作者：花生_TL007 | 2024-04-12 02:37:28

赞

踩

51单片机状态机编程方法

题目来源于某双流一大学第八届“电协杯”电子设计（校赛）

大一C组：自定义信号发生器

队伍名称：摆烂三人组

下文有对相应软件和硬件的实现进行介绍

复盘电赛（软件部分）

读题方面

  • 定时的基础单位是1ms！！！

  • 模式二中自定义输出波，不仅仅是控制每个波在周期的输出占比（时间），还要能够定义三个波的输出顺序（不一定是先输出正弦，后方波，最后三角波）。

  • 不是通过单片机输出波形。

  • 应当软件项目开发前应当画好结构流程图（状态机）再根据状态机线路流程依次封装相应的功能，使逻辑显得更加清晰、缜密，同时开发效率也会大为提高

整个电赛过程吸取的教训

【反思】在这次的软件开发中，因为在初期没有规划好完整的流程图，主函数中的一些代码存在冗余的情况，并且前期开发逻辑混乱，一直在修改代码逻辑，导致浪费了很多时间】

【本次电赛未提前规划流程图造成的不便】在电赛验收的前一天晚上才发现一个非常容易忽略的说明：“定时时间的基本单位为1ms”。虽然在定时器0的模块中只需要把对应的参数由1000ms改为1ms即可实现单位重置，但是前面许多LCD显示的内容都需要要重新编写，因为这些显示内容并没有做整合封装，很不便于修改！！当时为了程序的稳定运行没有对此处做更改，让整个软件在电赛中没有起到得拓展分的作用

软件部分

实现原理：编写51单片机状态机，通过定时器0来控制三个外接引脚(P2^0-P2^2)的高低电平的时间以达到自定义输出波的目的

WARMING

声明在前：

软件中的LCD显示还未改动，还缺少在模式二下输出顺序可选的状态机模块，该代码仅作为思路指引，没有做到完全正确！！！

main.c代码仍然存在多出纰漏亟待修改，请多包含(题主正忙于学习stm32，还没有时间来修正代码，如果这篇文章阅读量大于500，请在评论区踢题主一脚)

  • 使用到的外设：LCD1602显示屏

注意事项：

八位数据线依次接入外部引脚P1^0-P1^7

sbit LCD_RS=P2^6;

sbit LCD_RW=P2^5;

sbit LCD_EN=P2^7

LCD1602.c
  1. #include <REG52.H>
  2.  
  3. //引脚配置：
  4. sbit LCD_RS=P2^6;
  5. sbit LCD_RW=P2^5;
  6. sbit LCD_EN=P2^7;
  7. #define LCD_DataPort P1
  8.  
  9. //函数定义：
  10. /**
  11.   * @brief  LCD1602延时函数，12MHz调用可延时1ms
  12.   * @param  无
  13.   * @retval 无
  14.   */
  15. void LCD_Delay()
  16. {
  17.     unsigned char i, j;
  18.  
  19.     i = 2;
  20.     j = 239;
  21.     do
  22.     {
  23.         while (--j);
  24.     } while (--i);
  25. }
  26.  
  27. /**
  28.   * @brief  LCD1602写命令
  29.   * @param  Command 要写入的命令
  30.   * @retval 无
  31.   */
  32. void LCD_WriteCommand(unsigned char Command)
  33. {
  34.     LCD_RS=0;
  35.     LCD_RW=0;
  36.     LCD_DataPort=Command;
  37.     LCD_EN=1;
  38.     LCD_Delay();
  39.     LCD_EN=0;
  40.     LCD_Delay();
  41. }
  42.  
  43. /**
  44.   * @brief  LCD1602写数据
  45.   * @param  Data 要写入的数据
  46.   * @retval 无
  47.   */
  48. void LCD_WriteData(unsigned char Data)
  49. {
  50.     LCD_RS=1;
  51.     LCD_RW=0;
  52.     LCD_DataPort=Data;
  53.     LCD_EN=1;
  54.     LCD_Delay();
  55.     LCD_EN=0;
  56.     LCD_Delay();
  57. }
  58.  
  59. /**
  60.   * @brief  LCD1602设置光标位置
  61.   * @param  Line 行位置，范围：1~2
  62.   * @param  Column 列位置，范围：1~16
  63.   * @retval 无
  64.   */
  65. void LCD_SetCursor(unsigned char Line,unsigned char Column)
  66. {
  67.     if(Line==1)
  68.     {
  69.         LCD_WriteCommand(0x80|(Column-1));
  70.     }
  71.     else if(Line==2)
  72.     {
  73.         LCD_WriteCommand(0x80|(Column-1+0x40));
  74.     }
  75. }
  76.  
  77. /**
  78.   * @brief  LCD1602初始化函数
  79.   * @param  无
  80.   * @retval 无
  81.   */
  82. void LCD_Init()
  83. {
  84.     LCD_WriteCommand(0x38);//八位数据接口，两行显示，5*7点阵
  85.     LCD_WriteCommand(0x0c);//显示开，光标关，闪烁关
  86.     LCD_WriteCommand(0x06);//数据读写操作后，光标自动加一，画面不动
  87.     LCD_WriteCommand(0x01);//光标复位，清屏
  88. }
  89.  
  90. /**
  91.   * @brief  在LCD1602指定位置上显示一个字符
  92.   * @param  Line 行位置，范围：1~2
  93.   * @param  Column 列位置，范围：1~16
  94.   * @param  Char 要显示的字符
  95.   * @retval 无
  96.   */
  97. void LCD_ShowChar(unsigned char Line,unsigned char Column,char Char)
  98. {
  99.     LCD_SetCursor(Line,Column);
  100.     LCD_WriteData(Char);
  101. }
  102.  
  103. /**
  104.   * @brief  在LCD1602指定位置开始显示所给字符串
  105.   * @param  Line 起始行位置，范围：1~2
  106.   * @param  Column 起始列位置，范围：1~16
  107.   * @param  String 要显示的字符串
  108.   * @retval 无
  109.   */
  110. void LCD_ShowString(unsigned char Line,unsigned char Column,char *String)
  111. {
  112.     unsigned char i;
  113.     LCD_SetCursor(Line,Column);
  114.     for(i=0;String[i]!='\0';i++)
  115.     {
  116.         LCD_WriteData(String[i]);
  117.     }
  118. }
  119.  
  120. /**
  121.   * @brief  返回值=X的Y次方
  122.   */
  123. int LCD_Pow(int X,int Y)
  124. {
  125.     unsigned char i;
  126.     int Result=1;
  127.     for(i=0;i<Y;i++)
  128.     {
  129.         Result*=X;
  130.     }
  131.     return Result;
  132. }
  133.  
  134. /**
  135.   * @brief  在LCD1602指定位置开始显示所给数字
  136.   * @param  Line 起始行位置，范围：1~2
  137.   * @param  Column 起始列位置，范围：1~16
  138.   * @param  Number 要显示的数字，范围：0~65535
  139.   * @param  Length 要显示数字的长度，范围：1~5
  140.   * @retval 无
  141.   */
  142. void LCD_ShowNum(unsigned char Line,unsigned char Column,unsigned int Number,unsigned char Length)
  143. {
  144.     unsigned char i;
  145.     LCD_SetCursor(Line,Column);
  146.     for(i=Length;i>0;i--)
  147.     {
  148.         LCD_WriteData(Number/LCD_Pow(10,i-1)%10+'0');
  149.     }
  150. }
  151.  
  152. /**
  153.   * @brief  在LCD1602指定位置开始以有符号十进制显示所给数字
  154.   * @param  Line 起始行位置，范围：1~2
  155.   * @param  Column 起始列位置，范围：1~16
  156.   * @param  Number 要显示的数字，范围：-32768~32767
  157.   * @param  Length 要显示数字的长度，范围：1~5
  158.   * @retval 无
  159.   */
  160. void LCD_ShowSignedNum(unsigned char Line,unsigned char Column,int Number,unsigned char Length)
  161. {
  162.     unsigned char i;
  163.     unsigned int Number1;
  164.     LCD_SetCursor(Line,Column);
  165.     if(Number>=0)
  166.     {
  167.         LCD_WriteData('+');
  168.         Number1=Number;
  169.     }
  170.     else
  171.     {
  172.         LCD_WriteData('-');
  173.         Number1=-Number;
  174.     }
  175.     for(i=Length;i>0;i--)
  176.     {
  177.         LCD_WriteData(Number1/LCD_Pow(10,i-1)%10+'0');
  178.     }
  179. }
  180.  
  181. /**
  182.   * @brief  在LCD1602指定位置开始以十六进制显示所给数字
  183.   * @param  Line 起始行位置，范围：1~2
  184.   * @param  Column 起始列位置，范围：1~16
  185.   * @param  Number 要显示的数字，范围：0~0xFFFF
  186.   * @param  Length 要显示数字的长度，范围：1~4
  187.   * @retval 无
  188.   */
  189. void LCD_ShowHexNum(unsigned char Line,unsigned char Column,unsigned int Number,unsigned char Length)
  190. {
  191.     unsigned char i,SingleNumber;
  192.     LCD_SetCursor(Line,Column);
  193.     for(i=Length;i>0;i--)
  194.     {
  195.         SingleNumber=Number/LCD_Pow(16,i-1)%16;
  196.         if(SingleNumber<10)
  197.         {
  198.             LCD_WriteData(SingleNumber+'0');
  199.         }
  200.         else
  201.         {
  202.             LCD_WriteData(SingleNumber-10+'A');
  203.         }
  204.     }
  205. }
  206.  
  207. /**
  208.   * @brief  在LCD1602指定位置开始以二进制显示所给数字
  209.   * @param  Line 起始行位置，范围：1~2
  210.   * @param  Column 起始列位置，范围：1~16
  211.   * @param  Number 要显示的数字，范围：0~1111 1111 1111 1111
  212.   * @param  Length 要显示数字的长度，范围：1~16
  213.   * @retval 无
  214.   */
  215. void LCD_ShowBinNum(unsigned char Line,unsigned char Column,unsigned int Number,unsigned char Length)
  216. {
  217.     unsigned char i;
  218.     LCD_SetCursor(Line,Column);
  219.     for(i=Length;i>0;i--)
  220.     {
  221.         LCD_WriteData(Number/LCD_Pow(2,i-1)%2+'0');
  222.     }
  223. }
LCD1602.h
  1. #ifndef __LCD1602_H__
  2. #define __LCD1602_H__
  3.  
  4. //用户调用函数：
  5. void LCD_Init();
  6. void LCD_ShowChar(unsigned char Line,unsigned char Column,char Char);
  7. void LCD_ShowString(unsigned char Line,unsigned char Column,char *String);
  8. void LCD_ShowNum(unsigned char Line,unsigned char Column,unsigned int Number,unsigned char Length);
  9. void LCD_ShowSignedNum(unsigned char Line,unsigned char Column,int Number,unsigned char Length);
  10. void LCD_ShowHexNum(unsigned char Line,unsigned char Column,unsigned int Number,unsigned char Length);
  11. void LCD_ShowBinNum(unsigned char Line,unsigned char Column,unsigned int Number,unsigned char Length);
  12.  
  13. #endif

  • 同时使用到了定时器0

Timer0.c
  1. #include <REGX52.H>
  2.  
  3. /**
  4.   * @brief  定时器0初始化，1毫秒@12.000MHz
  5.   * @param  无
  6.   * @retval 无
  7.   */
  8. void Timer0_Init(void)
  9. {
  10.     TMOD &= 0xF0;        //设置定时器模式
  11.     TMOD |= 0x01;        //设置定时器模式
  12.     TL0 = 0x18;        //设置定时初值
  13.     TH0 = 0xFC;        //设置定时初值
  14.     TF0 = 0;        //清除TF0标志
  15.     TR0 = 1;        //定时器0开始计时
  16.     ET0=1;
  17.     EA=1;
  18.     PT0=0;
  19. }
Timer0.h
  1. #ifndef __TIMER0_H__
  2. #define __TIMER0_H__
  3.  
  4. void Timer0_Init(void);
  5.  
  6. #endif

以及用于矩阵键盘的软件消抖Delay

Delay.c
  1. void Delay(unsigned int xms)
  2. {
  3.     unsigned char i, j;
  4.     while(xms--)
  5.     {
  6.         i = 2;
  7.         j = 239;
  8.         do
  9.         {
  10.             while (--j);
  11.         } while (--i);
  12.     }
  13. }
Delay.h
  1. #ifndef __DELAY_H__
  2. #define __DELAY_H__
  3.  
  4. void Delay(unsigned int xms);
  5.  
  6. #endif

主函数控制管脚高低电平输出

软件控制流程图
main.c封装代码框架

//矩阵键盘-键值判断

uchar MatrixKey();

//输出电平模块

void Main_Otp();//控制输出引脚

void Out_Ctl_P0(uchar opt);//控制输出

//模式判断-状态机

uint OverFLoat(uint num);//防止数据溢出：将修改时间的范围控制在0-9s

void Mod_Single();//模式一单波的输出与停止

void Mod_Multi();//模式二三波混合输出

//状态机-主控系统

void Main_Ctl(); //统帅整个状态机的状态判断（由按键决定状态的走向）

void Init_System();//初始化整个系统

  • Main_Ctl()判断处于那个模式下，将工作分配给 Mod_Single()与Mod_Multi()

  • Mod_Single()与Mod_Multi()都会在调节时间的时候去调用防溢出函数OverFLoat

  • 主函数main会调用一个【(按键）状态机判断模块】Main_Ctl()与

【引脚高低电平输出的模块】Main_Otp()

  • 将模式一、二的相关时间，键值，状态等参数均封装在sta这个结构体供全局是使用

相应参数介绍：

外部引脚P2^0-P2^2：分别对应继电器的三个开关，在通过这三个开关分别连接到三个波的电路上

flag_singleOK是模式一中完成

flag_allOK是模式二中完成三个波的各自输出时间

main.c
  1. /**
  2.  * @file main.c
  3.  * @author jUicE_g2R(qq:3406291309)
  4.  * 
  5.  * @brief 通过按键状态机实现两个模式下三个外接引脚的高低电平输出
  6.  * @用途：控制C组中三种不同波形的输出
  7.  * 
  8.  * @version 0.1
  9.  *                     0.1：通过按键控制状态机输出电平
  10.  *                     0.2：PC端通过UART串口通信控制状态机输出电平
  11.  * 
  12.  * @date 2023-3-6(the Latest Correct Time)
  13.  * 
  14.  * @code(state)     已完成两种模式的调试
  15.  * 
  16.  * @copyright Copyright (c) 2023
  17.  */
  18. #include <REG52.H>
  19. #include "Timer0.h"
  20. #include "Delay.h"
  21. #include "LCD1602.h"
  22.  
  23. #define uint unsigned int
  24. #define uchar unsigned char
  25.  
  26. sbit opt1=P2^0;             //小灯测试演示波输出
  27. sbit opt2=P2^1;
  28. sbit opt3=P2^2;
  29.  
  30. #define Keys P3             //矩阵键盘总控键
  31.  
  32. //记录波形输入
  33. struct state
  34. {
  35.     //值Val
  36.     uchar wave_val;             //波值
  37.     uchar key_val;          //矩阵键盘键值
  38.     //控制状态
  39.     uchar flag_singleOK;
  40.     uchar flag_otp;           //是否输出波
  41.     uchar flag_free;          //是否进入自由模式
  42.     uchar flag_allOK;            //确定
  43.  
  44.     //模式一----输出时间与停止时间
  45.     uint wave_otp_t;
  46.     uint wave_stop_t;
  47.     //模式二----各波输出的时间0-9
  48.     uint wave_t1;
  49.     uint wave_t2;
  50.     uint wave_t3;
  51.     
  52.     //输出判断flag声明
  53.     uchar flag1_process;
  54.     uchar flag2_process;
  55.  
  56. } sta={1,0,0,1,0,0,1,1,1,1,1,0,0};
  57.  
  58. /*-----------子函数声明------------*/
  59. //矩阵键盘-键值判断
  60. uchar MatrixKey();
  61. //输出电平模块
  62. void Main_Otp();
  63. void Out_Ctl_P0(uchar opt);
  64.  
  65. //模式判断-状态机
  66. uint OverFLoat(uint num);
  67. void Mod_Single();
  68. void Mod_Multi();
  69. //状态机-主控系统
  70. void Main_Ctl();
  71. void Init_System();
  72.  
  73. //主函数
  74. int main(void)
  75. {
  76.     Init_System();
  77.     while(1)
  78.     {
  79.         Main_Otp();
  80.         
  81.         Main_Ctl();
  82.     } 
  83. }
  84.  
  85. uchar hex[5]={0,0xE,0xD,0xB,0x7};
  86. /*-------------矩阵键盘      检测算法------------*/
  87. uchar MatrixKey()
  88. {
  89.     uchar row, colu, value, value_temp, i;
  90.     uchar rank;               //矩阵键盘键号
  91.  
  92.     Keys=0x0f;//矩阵键盘初始化
  93.     if(Keys!=0x0f)
  94.     {
  95.         Delay(10);//软件消抖
  96.         if(Keys!=0x0f)
  97.         {
  98.             row=Keys;
  99.             Keys=0xf0;
  100.             colu=Keys;
  101.             value=row+colu;
  102.             
  103.             rank=0;
  104.             value_temp=value%16;
  105.             for( i=1;i<=4;i++)
  106.             {    
  107.                 if(value_temp==hex[i])
  108.                 rank=(i-1)*4;
  109.             }
  110.             
  111.             value_temp=value/16;                
  112.             for( i=1;i<=4;i++)
  113.             {    
  114.                 if(value_temp==hex[i])
  115.                 rank+=i;
  116.             }
  117.             while(Keys==0xFF);
  118.         }
  119.         while(Keys!=0xf0);
  120.     }
  121.     else
  122.     {
  123.         rank=0;
  124.     }
  125.     return rank;
  126. }
  127.  
  128.  
  129. /*------------电平输出控制-----------*/
  130. void Out_Ctl_P0(uchar opt)    
  131. {
  132.     switch (opt)
  133.     {
  134.         case 0:
  135.             opt1=0;
  136.             opt2=0;
  137.             opt3=0;
  138.         case 1:
  139.             opt1=1;
  140.             opt2=0;
  141.             opt3=0;
  142.             break;
  143.         case 2:
  144.             opt1=0;
  145.             opt2=1;
  146.             opt3=0;
  147.             break;
  148.         case 3:
  149.             opt1=0;
  150.             opt2=0;
  151.             opt3=1;
  152.         default:
  153.             break;
  154.     }
  155. }
  156.  
  157. void Main_Otp()         //引脚输出
  158. {
  159.     if(sta.flag_singleOK==1)
  160.     {
  161.         switch (sta.flag1_process)
  162.         {
  163.             case 1:         //输出
  164.                 Out_Ctl_P0(sta.wave_val);
  165.                 break;
  166.             case 2:         //停止
  167.                 opt1=0;
  168.                 opt2=0;
  169.                 opt3=0;
  170.                 break;
  171.             default:
  172.                 break;
  173.         }
  174.     }
  175.  
  176.     if(sta.flag_allOK==1)
  177.     {
  178.         switch (sta.flag2_process)
  179.         {
  180.             case 1:         //输出一号波
  181.                 opt1=1;
  182.                 opt2=0;
  183.                 opt3=0;
  184.                 break;
  185.             case 2:         //输出二号波
  186.                 opt1=0;
  187.                 opt2=1;
  188.                 opt3=0;
  189.                 break;
  190.             case 3:         //输出三号波
  191.                 opt1=0;
  192.                 opt2=0;
  193.                 opt3=1;
  194.                 break;
  195.             default:
  196.                 break;
  197.         }
  198.     }
  199.     if(sta.flag_otp==0)
  200.     {
  201.         LCD_ShowString(1,4,"STOP");
  202.     }
  203. }
  204.  
  205. uint OverFLoat(uint num)
  206. {
  207.     if(num>9)
  208.     {
  209.         num=0;
  210.     }
  211.     else if(num<0)
  212.     {
  213.         num=9;
  214.     }
  215.     return num;
  216. }
  217.  
  218. /*-----------------键值处理-----------------*/
  219. void Mod_Single()         //单项调试
  220. {
  221.     static uchar wave_temp=1;
  222.     static uchar flag_OKTemp=0;
  223.     static uchar i=1;
  224.     uchar wave_t;
  225.  
  226.     if(sta.key_val==4&i==3)             //选定波，输出以及停止时间后输出
  227.     {
  228.         i=1;        //重置
  229.         sta.flag_singleOK=1;
  230.         LCD_ShowString(1,12,"allOK");
  231.         LCD_ShowString(1,4,"OPT_");
  232.     }
  233.     else
  234.     {
  235.         switch (sta.key_val)
  236.         {
  237.             case 1:
  238.                 wave_temp++;
  239.                 if(wave_temp>3)
  240.                 {
  241.                     wave_temp=1;
  242.                 }
  243.                 LCD_ShowNum(1,2,wave_temp,1);//显示波号
  244.                 sta.wave_val=wave_temp;      //记录wave号：便于停止波后重启时波保持停止前的输出状态
  245.                 break;
  246.  
  247.             case 2:            //是否输出波
  248.                 sta.flag_otp++;
  249.                 if((sta.flag_otp)>1)
  250.                 {
  251.                     sta.flag_otp=0;
  252.                 }
  253.  
  254.                 if(sta.flag_otp==0)   //停止输出波
  255.                 {
  256.                     sta.flag_singleOK=0;
  257.                 }
  258.                 break;
  259.             case 4:
  260.                 i++;
  261.                 flag_OKTemp=1;
  262.                 break;
  263.  
  264.             case 6:     //输出时间
  265.                 flag_OKTemp=0;
  266.                 switch (i)
  267.                 {
  268.                     case 2:
  269.                         wave_t=sta.wave_otp_t+1;
  270.                         sta.wave_otp_t=OverFLoat(wave_t);
  271.                         LCD_ShowNum(1,9,sta.wave_otp_t,1);
  272.                         break;
  273.                     case 3:
  274.                         wave_t=sta.wave_stop_t+1;
  275.                         sta.wave_stop_t=OverFLoat(wave_t);
  276.                         LCD_ShowNum(1,11,sta.wave_stop_t,1);
  277.                         break;
  278.                     default:
  279.                         break;
  280.                 }
  281.                 break;
  282.  
  283.             case 7:     //停止时间
  284.                 flag_OKTemp=0;
  285.                 switch (i)
  286.                 {
  287.                     case 2:
  288.                         wave_t=sta.wave_otp_t-1;
  289.                         sta.wave_otp_t=OverFLoat(wave_t);
  290.                         LCD_ShowNum(1,9,sta.wave_otp_t,1);
  291.                         break;
  292.                     case 3:
  293.                         wave_t=sta.wave_stop_t-1;
  294.                         sta.wave_stop_t=OverFLoat(wave_t);
  295.                         LCD_ShowNum(1,11,sta.wave_stop_t,1);
  296.                         break;
  297.                     default:
  298.                         break;
  299.                 }
  300.                 break;
  301.             default:
  302.                 break;
  303.         }
  304.  
  305.         if(flag_OKTemp==0)
  306.         {
  307.             LCD_ShowString(1,15,"no");
  308.         }
  309.         else
  310.         {
  311.             LCD_ShowString(1,15,"OK");
  312.         }
  313.     } 
  314.     
  315. }
  316.  
  317.  
  318. void Mod_Multi()         //自由模式
  319. {
  320.     static uchar flag_OKTemp=0;
  321.     uint wave_t;
  322.     static uchar i=0;           //调好三个波的时间就可以输出了
  323.  
  324.     if(i==3&&sta.key_val==4)       //切换到第三个波且确定时，开始输出波
  325.     {
  326.         i=1;        //重置
  327.         sta.flag_allOK=1;       //可以输出波了
  328.         sta.flag_otp=1;         //引脚高电平输出
  329.         LCD_ShowString(1,12,"allOK");
  330.         LCD_ShowString(1,4,"OPT_");
  331.     }
  332.     else        //选择波以及波输出时间
  333.     {
  334.         switch (sta.key_val)
  335.         {
  336.             case 4:     //每个波形时间确定键
  337.                 flag_OKTemp=1;
  338.                 i++;
  339.                 break;
  340.             case 5:     //切波:在确定的条件下才能切波
  341.                 if(flag_OKTemp==1)
  342.                 {
  343.                     sta.wave_val++;
  344.                     if(sta.wave_val>3)
  345.                     {
  346.                         sta.wave_val=1;
  347.                     }
  348.                     flag_OKTemp=0;                      //重置OK值
  349.                     LCD_ShowNum(1,2,sta.wave_val,1);    //切换的波的波号显示
  350.                 }
  351.                 break;
  352.  
  353.             case 6:     //增加波的时间
  354.                 flag_OKTemp=0;
  355.                 switch (sta.wave_val)
  356.                 {
  357.                     case 1:
  358.                         wave_t=sta.wave_t1+1;
  359.                         sta.wave_t1=OverFLoat(wave_t);
  360.                         LCD_ShowNum(2,4,sta.wave_t1,1);
  361.                         break;
  362.                     case 2:
  363.                         wave_t=sta.wave_t2+1;
  364.                         sta.wave_t2=OverFLoat(wave_t);
  365.                         LCD_ShowNum(2,9,sta.wave_t2,1);
  366.                         break;
  367.                     case 3:
  368.                         wave_t=sta.wave_t3+1;
  369.                         sta.wave_t3=OverFLoat(wave_t);
  370.                         LCD_ShowNum(2,14,sta.wave_t3,1);
  371.                         break;
  372.                     default:
  373.                         break;
  374.                 }
  375.                 break;
  376.  
  377.             case 7:     //减少波的时间
  378.                 flag_OKTemp=0;
  379.                 switch (sta.wave_val)
  380.                 {
  381.                     case 1:
  382.                         wave_t=sta.wave_t1-1;
  383.                         sta.wave_t1=OverFLoat(wave_t);
  384.                         LCD_ShowNum(2,4,sta.wave_t1,1);
  385.                         break;
  386.                     case 2:
  387.                         wave_t=sta.wave_t2-1;
  388.                         sta.wave_t2=OverFLoat(wave_t);
  389.                         LCD_ShowNum(2,9,sta.wave_t2,1);
  390.                         break;
  391.                     case 3:
  392.                         wave_t=sta.wave_t3-1;
  393.                         sta.wave_t3=OverFLoat(wave_t);
  394.                         LCD_ShowNum(2,14,sta.wave_t3,1);
  395.                         break;
  396.                     default:
  397.                         break;
  398.                 }
  399.                 break;
  400.             default:
  401.                 break;
  402.         }
  403.         if(flag_OKTemp==0)
  404.         {
  405.             LCD_ShowString(1,15,"no");
  406.         }
  407.         else
  408.         {
  409.             LCD_ShowString(1,15,"OK");
  410.         }
  411.  
  412.     }
  413.     
  414. }
  415.  
  416. void Main_Ctl()             //主控模块
  417. {
  418.     uchar wave_temp=1;
  419.  
  420.     sta.key_val=MatrixKey();            //获取矩阵键值
  421.     if(sta.key_val!=0)                  //没有键按下就不进入判断
  422.     {
  423.         if(sta.flag_free==1)
  424.         {
  425.             if(sta.key_val==2)             //在自由模式下任何情况都可以退出
  426.             {
  427.                 sta.flag_otp=0;       //停止输出波
  428.                 sta.flag_free=0;      //退出自由调节模式
  429.                 LCD_ShowChar(2,16,'S');         //还原到单项操作
  430.                 LCD_ShowString(1,15,"no");
  431.             }
  432.             else
  433.             {
  434.                 Mod_Multi();
  435.             }
  436.         }
  437.         else if(sta.flag_free==0)          //单项输出波
  438.         {
  439.             LCD_ShowChar(2,16,'S');         //更改模式
  440.             if(sta.flag_otp==0)            //进入停止输出才能调至自由调整模式
  441.             {
  442.                 if(sta.key_val==3)         //进入自由调整模式
  443.                 {
  444.                     sta.flag_free=1;       //此时波形已经停止输出 
  445.                     LCD_ShowChar(2,16,'M');          //更改模式
  446.                     LCD_ShowString(1,4,"STOP");
  447.                     LCD_ShowString(1,8,"       ");
  448.                     Timer0_Init();                   //重置定时器0
  449.                     
  450.                     //输出初始化
  451.                     opt1=0;
  452.                     opt2=0;
  453.                     opt3=0;
  454.                 }
  455.             }
  456.             else if(sta.flag_otp==1)      //输出波
  457.             {
  458.                 Mod_Single();
  459.             }
  460.         }
  461.     } 
  462. }
  463.  
  464. void Init_System()      //初始化系统
  465. {
  466.     Timer0_Init();      //定时器初始化
  467.     /*屏幕初始化*/
  468.     LCD_Init();
  469.  
  470.     //第一行演示：    |W1            S|
  471.     LCD_ShowChar(1,1,'W');        //表示所处的波形
  472.     LCD_ShowNum(1,2,1,1);         //波号
  473.     LCD_ShowString(1,4,"STOP");
  474.     LCD_ShowChar(2,16,'S');       //模式
  475.     //第二行演示：   |W1 1 W2 2 W3 3 no|
  476.     LCD_ShowChar(2,1,'W');
  477.     LCD_ShowNum(2,2,1,1);
  478.     LCD_ShowChar(2,3,':');
  479.  
  480.     LCD_ShowChar(2,6,'W');
  481.     LCD_ShowNum(2,7,2,1);
  482.     LCD_ShowChar(2,8,':');
  483.     
  484.     LCD_ShowChar(2,11,'W');
  485.     LCD_ShowNum(2,12,3,1);
  486.     LCD_ShowChar(2,13,':');
  487.  
  488.     LCD_ShowString(1,15,"no");
  489.  
  490.     LCD_ShowChar(1,10,'|');
  491.     /*引脚输出输出初始化*/
  492. //    Out_Ctl_P0(0);     //初始化输出端口
  493.     opt1=0;
  494.     opt2=0;
  495.     opt3=0;
  496. }
  497.  
  498. /*定时器中断函数*/
  499. void Timer0_Routine() interrupt 1
  500. {
  501.     static int T0cot1=0;
  502.     static int T0cot2=0;
  503.  
  504.     TL0 = 0x18;        //设置定时初值
  505.     TH0 = 0xFC;        //设置定时初值
  506.     if(sta.flag_otp==1)     //控制停止输出波
  507.     {
  508.         //控制输出波flag
  509.         if(sta.flag_singleOK==1)
  510.         {    
  511.             if(T0cot1==0)
  512.             {
  513.                 sta.flag1_process=1;
  514.             }
  515.             else if(T0cot1==1*sta.wave_otp_t)
  516.             {
  517.                 sta.flag1_process=2;
  518.             }
  519.             T0cot1++;
  520.             //重置循化
  521.             if(T0cot1>1*(sta.wave_otp_t+sta.wave_stop_t))
  522.             {
  523.                 T0cot1=0;
  524.             }
  525.         }
  526.  
  527.         if(sta.flag_allOK==1)
  528.         {
  529.             //控制输出波flag
  530.             if (T0cot2==0)
  531.             {
  532.                 sta.flag2_process=1;
  533.             }    
  534.             else if(T0cot2==1*sta.wave_t1)
  535.             {
  536.                 sta.flag2_process=2;
  537.             }
  538.             else if(T0cot2==1*(sta.wave_t1+sta.wave_t2))
  539.             {
  540.                 sta.flag2_process=3;
  541.             }
  542.  
  543.             T0cot2++;
  544.             if(T0cot2>1*(sta.wave_t1+sta.wave_t2+sta.wave_t3))        //重置，循环
  545.             {
  546.                 T0cot2=0;
  547.             }
  548.         }
  549.     }
  550. }

硬件部分

  • 波形产生分析

正弦波发生电路

采用文式桥振荡电路为基础产生正弦波，组成为：放大电路、反馈网络、选频网络、稳幅环节

放大电路：

文氏电桥振荡器采用的是同相放大器，当信号较小时，二极管不导通，放大倍数为A=1+（RP2+R1）/R8

当信号较大时，二极管导通，放大倍数为A=1+（RP2+r）/R8，r为R1所对应的匹配电阻。

反馈网络：

反馈是将输出信号的全部或一部分返回至输入，使输入信号改变,而负反馈是引起输入信号减小的一种反馈方式。同向放大器引入负反馈，使得输出信号与输入信号比值稳定。

选频网路：

RC带通滤波器，该电路由高通和低通滤波器组合而成，其中RP1=RP4,C1=C2,频率为f=1/(2πRC)。

f=1/（2*Π*RC）（RP1 = RP4，C1 = C2），f=1/（2*Π*RP1*C2）。

稳幅环节：

文氏电桥的起振条件是：|AF|>1；但文氏电桥的稳幅条件确是：|AF|=1。利用二极管的非线性自动调节负反馈的强弱来控制输出电压的恒定。振荡过程中D1、D2将交替导通和截止，总有一个处于正向导通状态的二极管与R3并联，由于二极管正向电阻rd随ud增大而下降，因此负反馈随振幅上升而增强，也就是说A随振幅增大而下降，直到满足振幅平衡条件为止。

图中RP1和RP4可调节频率，RP2可调节放大倍数。

方波发生电路

利用下行滞回比较器输出方波，滞回比较器的输入电压逐渐增大或者减小时，有两个不相等的阈值，其传输特性具有滞回曲线的形状，因此具有很强的抗干扰能力。

uo=土Uz,

RP3调节放大倍数。

三角波发生电路

利用集成运放构成积分器，然后对方波信号进行运算产生三角波。

R7是防止积分电路饱和的反馈电阻，它的大小需要比R1大两个数量级，这样就不会影响积分波形,R7越大三角波越往上。RP3和R5与E1的值决定三角波斜率，因此调节RP3可以改变三角波的幅值。

  • 软件与硬件桥接——电路开关设计

用继电器模块作为开关，对电路三种输出波形进行控制。由于继电器模块触发电压为3.3V~5V，进而可用控制单片机引脚输出的高低电平的方法来控制继电器的开关，从而实现对输出波形的智能化控制

三位一体原理图

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

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

  

闽ICP备14008679号