找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 5290|回复: 5
收起左侧

STC15W4K32S4单片机ADC读取 串口收发 设定定时器的代码与Proteus仿真图

[复制链接]
ID:867327 发表于 2021-1-3 13:46 | 显示全部楼层 |阅读模式
文件夹 e:\dpj\20210101
目标 STC15W4K32S4
proteus 新建单片机 串口 分压调节电压源 更改单片机主频为11059200
虚拟串口软件安装及配置
单片机使用COM4 串口调试器使用COM3 波特率 115200
ADC读取电压数据正常 P1.0 P1.1
串口通讯测试正常 ADC 通过可变电阻调节电压后 模拟量变化发送串口
串口通讯测试正常 中断接收<>之间字符,回送  因地址空间,字符个数<10
程序运行时间以protues左下角的运行时间为准  见截图
定时器设置及中断处理 以1ms为周期,每3000ms在串口发送字符
串口命令设置定时器发送数据到串口的时间间隔 <后的第一个字符为A 第二个为数字 表示间隔秒数
仿真原理图如下(STC15W4K32S4单片机proteus仿真工程文件可到本帖附件中下载)
运行画面.jpg

单片机源程序如下:
  1. /*---------------------------------------------------------------------*/
  2. /* --- STC MCU Limited ------------------------------------------------*/
  3. /* --- STC15F4K60S4 系列 定时器1用作串口1的波特率发生器举例------------*/
  4. /* 如果要在程序中使用此代码,请在程序中注明使用了STC的资料及程序        */
  5. /* 如果要在文章中应用此代码,请在文章中注明使用了STC的资料及程序        */
  6. /*---------------------------------------------------------------------*/

  7. //本示例在Keil开发环境下请选择Intel的8058芯片型号进行编译
  8. //若无特别说明,工作频率一般为11.0592MHz

  9. #include        "STC15Fxxxx.H"
  10. //#include "reg51.h"
  11. #include <stdio.h>

  12. typedef unsigned char BYTE;
  13. typedef unsigned int WORD;
  14. //typedef unsigned int u16;  //对数据类型进行声明定义
  15. //typedef unsigned char u8;

  16. #define FOSC 11059200L          //系统频率
  17. #define BAUD 115200             //串口波特率

  18. #define NONE_PARITY     0       //无校验
  19. #define ODD_PARITY      1       //奇校验
  20. #define EVEN_PARITY     2       //偶校验
  21. #define MARK_PARITY     3       //标记校验
  22. #define SPACE_PARITY    4       //空白校验

  23. #define PARITYBIT NONE_PARITY   //定义校验位
  24. /* STC15Fxxxx.H中已定义
  25. //sfr P0M1 = 0x93;
  26. //sfr P0M0 = 0x94;
  27. //sfr P1M1 = 0x91;
  28. //sfr P1M0 = 0x92;
  29. //sfr P2M1 = 0x95;
  30. //sfr P2M0 = 0x96;
  31. //sfr P3M1 = 0xb1;
  32. //sfr P3M0 = 0xb2;
  33. //sfr P4M1 = 0xb3;
  34. //sfr P4M0 = 0xb4;
  35. //sfr P5M1 = 0xC9;
  36. //sfr P5M0 = 0xCA;
  37. //sfr P6M1 = 0xCB;
  38. //sfr P6M0 = 0xCC;
  39. //sfr P7M1 = 0xE1;
  40. //sfr P7M0 = 0xE2;

  41. //sfr AUXR  = 0x8e;               //辅助寄存器

  42. //sfr P_SW1   = 0xA2;             //外设功能切换寄存器1
  43. */
  44. #define S1_S0 0x40              //P_SW1.6
  45. #define S1_S1 0x80              //P_SW1.7

  46. #define ADC_POWER   0x80            //ADC电源控制位
  47. #define ADC_FLAG    0x10            //ADC完成标志
  48. #define ADC_START   0x08            //ADC起始控制位
  49. #define ADC_SPEEDLL 0x00            //540个时钟
  50. #define ADC_SPEEDL  0x20            //360个时钟
  51. #define ADC_SPEEDH  0x40            //180个时钟
  52. #define ADC_SPEEDHH 0x60            //90个时钟

  53. //sbit P22 = P2^2;
  54. unsigned int ch;a,b;
  55. unsigned int dd=0;
  56. unsigned int cc=0;
  57. unsigned int cc0=0;
  58. unsigned int cc1=0;
  59. unsigned int cc00=0;
  60. unsigned int cc01=0;
  61. unsigned int cc10=0;
  62. unsigned int cc11=0;
  63. unsigned int time0count0 = 0 ;
  64. unsigned int time0count1 = 0 ;
  65. unsigned int time0count = 3000 ;
  66. bit busy;
  67. char receivechar = 0;
  68. int receive_count = 0;
  69. int received = 0;
  70. WORD receivestr[10];

  71. void InitUart();
  72. void InitADC();
  73. void Timer0Init();
  74. void SendData(BYTE dat);
  75. void SendString(char *s);
  76. void serial_put_uint(unsigned int number);
  77. void Delay(WORD n);
  78. //void ShowResult(BYTE ch);
  79. unsigned int GetADCResultint(BYTE ch);
  80. void main()
  81. {
  82.         int initreceivestrcount=0;
  83.         unsigned int tt0=0,tt1=0;
  84. //                unsigned int d1,d2,d3,i;
  85.         unsigned int i=0;
  86.         if (i == 0 )                //初始化tt0 tt1 P0 -P7 数据
  87.         {
  88.                 /*
  89.                 例如将P1M0=0X60和P1M1=0X00译成bai二进制代码是
  90.                 P1M0=0110 0000,duP1M1=0000 0000.
  91.                 按照I/O口工作模式设置zhi规定
  92.                 都为0时为准双向口(dao传统8051单片机zhuanI/O口模式)
  93.                 为0,1时为推挽(shu强上拉输出),
  94.                 为1,0时为高阻(仅输入),
  95.                 为1,1时为开漏(内部上拉断开,须外加上拉电阻)
  96.                 你选择的是P1M0和P1M1所以针对的是P1口的操作,
  97.                 将两个二进制代码一位位的比较可知:P1.0~P1.4及P1.7都为0,
  98.                 故这些I/O口设置的是标准状态;P1.5和P1.6为高阻态
  99.                 (P1M0上的第六位和第七位都为1,P1M1上的第六位和第七位都是0。1,0时为高阻)
  100.                 */
  101.                 tt0=16640;
  102.                 tt1=tt0/256;
  103.                 P0M0 = 0x00;
  104.                 P0M1 = 0x00;
  105.                 P1M0 = 0x00;
  106.                 P1M1 = 0x03;
  107.                 P2M0 = 0x00;
  108.                 P2M1 = 0x00;
  109.                 P3M0 = 0x00;
  110.                 P3M1 = 0x00;
  111.                 P4M0 = 0x00;
  112.                 P4M1 = 0x00;
  113.                 P5M0 = 0x00;
  114.                 P5M1 = 0x00;
  115.                 P6M0 = 0x00;
  116.                 P6M1 = 0x00;
  117.                 P7M0 = 0x00;
  118.                 P7M1 = 0x00;
  119.         }
  120.         InitUart();                     //初始化串口
  121.         //printf ("20200102 第一次调试  a  1 取左字节   a %d A/256=A %d   C51\n" , tt0,tt1 ); /* ?? "Hello C51 " */
  122.         SendString("20200102 第二次调试 \r\n");
  123.         initreceivestrcount=0;
  124.         while (initreceivestrcount<10)                //初始化 receivestr
  125.         {
  126.                 receivestr[initreceivestrcount]=0;
  127.                 initreceivestrcount = initreceivestrcount + 1 ;
  128.         }
  129.         //printf ("Hello");  //printf 不能使用 编译通过 不能仿真运行
  130.         InitADC();                      //初始化ADC
  131.         Timer0Init();  //定时器0初始化
  132.         /* 除法测试
  133.                 //printf ("Hello  ADC 第y次调试 a  1 加代码a %d A/256=A %d   C51\n" , tt0,tt1 );  
  134. //                sprintf(str," receive %d \r\n",receivechar);
  135. //                SendString(str);
  136. //                sprintf(str," d1 %d a \r\n",tt0);
  137. //                SendString(str);
  138. //                sprintf(str,"  d2 %d  a \r\n",tt1);
  139. //                SendString(str);
  140. //                sprintf(str,"  d3 %d a \r\n",d3);
  141. //                SendString(str);
  142.         */
  143.     SendString("c STC15W4kS32\r\n Uart Test !\r\n");
  144.     while(1)
  145.                 {

  146.                         if (received == 1)                // 在串口接收预定义字符后回送  20210103 增加控制定时显示功能
  147.                         {
  148.                                 /*  除法测试及sprintf
  149. //                                SendString("\r\n");
  150. //                                d1 = receivechar;
  151. //                                d2 = d1 ;
  152. //                                d3=d2*256;
  153. //                                d3=d1-d3;
  154. //                                sprintf(str," receive %d a\r\n",receivechar);
  155. //                                SendString(str);
  156. //                                sprintf(str," d1 %d b \r\n",d1);
  157. //                                SendString(str);
  158. //                                sprintf(str,"  d2 %d  c \r\n",d2);
  159. //                                SendString(str);
  160. //                                sprintf(str,"  d3 %d d \r\n",d3);
  161. //                                SendString(str);
  162. //                                SendString(receivestr);receivechar
  163.                                 */
  164.                                 serial_put_uint(receivechar);
  165.                                 SendString(" start ");
  166.                                 //serial_put_uint(11);
  167.                                 for (i=0;i<receive_count;i++)
  168.                                 {
  169.                                         SendData(receivestr[i]);
  170.                                 }
  171.                                 SendString(" COUNT= ");
  172.                                 serial_put_uint(receive_count);
  173.                                 receive_count = 0 ;
  174.                                 if (receivestr[1] == 65 )
  175.                                 {
  176.                                         time0count = ( receivestr[2] - 48 ) * 1000 ;
  177.                                         SendString(" \r\n  串口设定 time0   ");                                                                                                
  178.                                         serial_put_uint(time0count/1000);
  179.                                         SendString(" 秒定时  ");        
  180.                                 }                                       
  181.                                 SendString(" \r\n");
  182.                                 received = 0 ;
  183.                         }
  184.                         if (time0count0 != time0count1)                         // 串口设定的秒定时
  185.                         {
  186.                                 SendString(" time0   ");                                                                                                
  187.                                 serial_put_uint(time0count/1000);
  188.                                 SendString(" 秒定时 执行 ");                                                                                                
  189.                                 serial_put_uint(time0count0);
  190.                                 SendString(" \r\n ");               
  191.                                 time0count1 = time0count0;
  192.                         }                                
  193.                         b=b+1;
  194.                         dd=0;
  195.                         cc00 = GetADCResultint(dd);                 //读取ADC 0 P1.0 数据
  196.                         if (cc01 != cc00)                         // ADC 0 P1.0 数据变化发送串口
  197.                         {
  198.                                 SendString(" ADC ");                                                                                                
  199. //                                serial_put_uint(b);
  200.                                 SendString(" ch ");                                                                                                
  201.                                 serial_put_uint(dd);
  202.                                 SendString(" new ");                                                                                                
  203.                                 serial_put_uint(cc00);
  204.                                 SendString("  old ");                                                                                                
  205.                                 serial_put_uint(cc01);
  206.                                 SendString(" end \r\n");                                                                                                
  207.                                 //printf ("  ADC %d  ch %d :0x  %x 0d %d  \n", b,dd,cc00,cc01 );
  208.                                 cc01 = cc00;
  209.                         }
  210.                         dd=1;
  211.                         cc10 = GetADCResultint(dd);                        //读取ADC 1 P1.1 数据
  212.                         if (cc11 != cc10)                                // ADC 1 P1.1 数据变化发送串口
  213.                         {
  214.                                 SendString(" ADC ");                                                                                                
  215. //                                serial_put_uint(b);
  216.                                 SendString(" ch ");                                                                                                
  217.                                 serial_put_uint(dd);
  218.                                 SendString(" new ");                                                                                                
  219.                                 serial_put_uint(cc10);
  220.                                 SendString("  old ");                                                                                                
  221.                                 serial_put_uint(cc11);
  222.                                 SendString(" end \r\n");                                                                                                
  223.                                 //printf ("  ADC  %d ch %d :0x  %x 0d00 %d  \n", b,dd,cc10,cc11 );
  224.                                 cc11=cc10;
  225.                         }
  226.                         dd=0;
  227.                         if  (b>10000) b=0;

  228.                 }
  229. }

  230. /*******************************************************************************
  231. * 函 数 名         : Timer0Init
  232. * 函数功能                   : 定时器0初始化
  233. * 输    入         : 无
  234. * 输    出         : 无
  235. *******************************************************************************/
  236. void Timer0Init()
  237. {
  238.         TMOD|=0X01;//选择为定时器0模式,工作方式1,仅用TR0打开启动。

  239.         TH0=0XFC;        //给定时器赋初值,定时1ms
  240.         TL0=0X18;        
  241.         ET0=1;//打开定时器0中断允许
  242.         EA=1;//打开总中断
  243.         TR0=1;//打开定时器                        
  244. }
  245. /*----------------------------
  246. 初始化串口
  247. ----------------------------*/
  248. void InitUart()
  249. {
  250. //    ACC = P_SW1;
  251. //    ACC &= ~(S1_S0 | S1_S1);    //S1_S0=0 S1_S1=0
  252. //    P_SW1 = ACC;                //(P3.0/RxD, P3.1/TxD)
  253.    
  254. //  ACC = P_SW1;
  255. //  ACC &= ~(S1_S0 | S1_S1);    //S1_S0=1 S1_S1=0
  256. //  ACC |= S1_S0;               //(P3.6/RxD_2, P3.7/TxD_2)
  257. //  P_SW1 = ACC;  
  258. //  
  259. //  ACC = P_SW1;
  260. //  ACC &= ~(S1_S0 | S1_S1);    //S1_S0=0 S1_S1=1
  261. //  ACC |= S1_S1;               //(P1.6/RxD_3, P1.7/TxD_3)
  262. //  P_SW1 = ACC;  

  263. #if (PARITYBIT == NONE_PARITY)
  264.     SCON = 0x50;                //8位可变波特率
  265. #elif (PARITYBIT == ODD_PARITY) || (PARITYBIT == EVEN_PARITY) || (PARITYBIT == MARK_PARITY)
  266.     SCON = 0xda;                //9位可变波特率,校验位初始为1
  267. #elif (PARITYBIT == SPACE_PARITY)
  268.     SCON = 0xd2;                //9位可变波特率,校验位初始为0
  269. #endif

  270.     AUXR = 0x40;                //定时器1为1T模式
  271.     TMOD = 0x00;                //定时器1为模式0(16位自动重载)
  272.     TL1 = (65536 - (FOSC/4/BAUD));   //设置波特率重装值
  273.     TH1 = (65536 - (FOSC/4/BAUD))>>8;
  274.     TR1 = 1;                    //定时器1开始启动
  275.     ES = 1;                     //使能串口中断
  276.     EA = 1;
  277.         
  278.         
  279.         
  280. //    SCON = 0x5a;                //设置串口为8位可变波特率
  281. //#if URMD == 0
  282. //    T2L = (65536 - (FOSC/4/BAUD));
  283. //    T2H = (65536 - (FOSC/4/BAUD)) >> 8;
  284. //    AUXR = 0x14;                //T2为1T模式, 并启动定时器2
  285. //    AUXR |= 0x01;               //选择定时器2为串口1的波特率发生器
  286. //#elif URMD == 1
  287. //    AUXR = 0x40;                //定时器1为1T模式
  288. //    TMOD = 0x00;                //定时器1为模式0(16位自动重载)
  289. //    TL1 = (65536 - (FOSC/4/BAUD));
  290. //    TH1 = (65536 - (FOSC/4/BAUD)) >> 8;
  291. //    TR1 = 1;                    //定时器1开始启动
  292. //#else
  293. //    TMOD = 0x20;                //设置定时器1为8位自动重装载模式
  294. //    AUXR = 0x40;                //定时器1为1T模式
  295. //    TH1 = TL1 = (256 - (FOSC/32/BAUD));
  296. //    TR1 = 1;
  297. //#endif
  298. }

  299. /*----------------------------
  300. 初始化ADC
  301. ----------------------------*/
  302. void InitADC()
  303. {
  304.                 P1M0 =1;
  305.                 P1M1 =0;
  306.                 P1 = 0Xff;
  307.     P1ASF = 0xff;                   //设置P1口为AD口
  308.     ADC_RES = 0;                    //清除结果寄存器
  309.     ADC_RESL = 0;                    //清除结果寄存器
  310.     ADC_CONTR = ADC_POWER | ADC_SPEEDLL;
  311.     Delay(2);                       //ADC上电并延时
  312. }

  313. /*----------------------------
  314. 读取ADC结果 20210101 注释GetADCResult 用GetADCResultint代替
  315. ----------------------------*/

  316. unsigned int GetADCResultint(BYTE ch)
  317. {
  318.                 unsigned int ret=0;
  319.     ADC_CONTR = ADC_POWER | ADC_SPEEDLL | ch | ADC_START;
  320.     _nop_();                        //等待4个NOP
  321.     _nop_();
  322.     _nop_();
  323.     _nop_();
  324.     while (!(ADC_CONTR & ADC_FLAG));//等待ADC转换完成
  325.     ADC_CONTR &= ~ADC_FLAG;         //Close ADC
  326.                 ret = ADC_RES*4 + ADC_RESL;
  327.     return ret;                 //返回ADC结果
  328. }


  329. /*----------------------------
  330. UART 中断服务程序
  331. -----------------------------*/
  332. void Uart() interrupt 4
  333. {

  334.     if (RI)
  335.     {
  336.         RI = 0;                 //清除RI位
  337.         receivechar = SBUF;              //P0显示串口数据
  338.                         if  ( receivechar == 60 ) receive_count = 0 ;
  339.                         if ((receive_count<9) && ( receivechar != 62 )&&(received == 0 ))
  340.                         {
  341.                                 receivestr[receive_count] = receivechar;
  342.                                 receivestr[receive_count+1] = 0;
  343.                                 receive_count = receive_count + 1 ;
  344.                                 
  345.                         }
  346.                         else
  347.                         {
  348.                                 received = 1;
  349. //                                while (initreceivestrcount<10)
  350. //                                {
  351. //                                        receivestr[initreceivestrcount]=0;
  352. //                                        initreceivestrcount = initreceivestrcount + 1 ;
  353. //                                }
  354.                                 
  355.                         }
  356. //                        SendData(receivechar);
  357. //        P22 = RB8;              //P2.2显示校验位
  358.     }
  359.                         
  360.     if (TI)
  361.     {
  362.         TI = 0;                 //清除TI位
  363.         busy = 0;               //清忙标志
  364.     }
  365. }

  366. void Timer0() interrupt 1
  367. {
  368.         static u16 itime0;
  369.         TH0=0XFC;        //给定时器赋初值,定时1ms
  370.         TL0=0X18;
  371.         itime0++;
  372.         if(itime0==time0count)
  373.         {
  374.                 itime0=0;
  375.                 time0count0 = time0count0 + 1;        
  376.                 if ( time0count0 > 20 ) time0count0 = 0;
  377.         }        
  378. }

  379. /*----------------------------
  380. 发送串口数据
  381. ----------------------------*/
  382. void SendData(BYTE dat)
  383. {
  384.     while (busy);               //等待前面的数据发送完成
  385.     ACC = dat;                  //获取校验位P (PSW.0)
  386. //    if (P)                      //根据P来设置校验位
  387. //    {
  388. //#if (PARITYBIT == ODD_PARITY)
  389. //        TB8 = 0;                //设置校验位为0
  390. //#elif (PARITYBIT == EVEN_PARITY)
  391. //        TB8 = 1;                //设置校验位为1
  392. //#endif
  393. //    }
  394. //    else
  395. //    {
  396. //#if (PARITYBIT == ODD_PARITY)
  397. //        TB8 = 1;                //设置校验位为1
  398. //#elif (PARITYBIT == EVEN_PARITY)
  399. //        TB8 = 0;                //设置校验位为0
  400. //#endif
  401. //    }
  402.     busy = 1;
  403.     SBUF = ACC;                 //写数据到UART数据寄存器
  404. }

  405. /*----------------------------
  406. 发送字符串
  407. ----------------------------*/
  408. void SendString(char *s)
  409. {
  410. //        EA = 0 ;
  411. //        ES = 0 ;
  412.         while (*s)                  //检测字符串结束标志
  413.         {
  414.                         SendData(*s++);         //发送当前字符
  415.         }
  416. //        EA = 1 ;
  417. //        ES = 1 ;
  418. }
  419. void serial_put_uint(unsigned int number)
  420. {
  421.       unsigned int i;
  422.       unsigned int nTmp;
  423. //        *s++ =num/10 +'0';
  424. //*s++=num%10 +'0';
  425. //*s =0;
  426.         
  427.      //感觉这写法怪怪的吗?干嘛不for(i=1;i<5;i++) 因为这样不需要使用库函数pow()
  428.      for(i=10000;i>=1;i=i/10)
  429.       {
  430.             nTmp = number/i;
  431.                                                 if(nTmp >=1 ) SendData((unsigned char)(nTmp%10 + 0x30));
  432.       }
  433. }

  434. /*----------------------------
  435. 软件延时
  436. ----------------------------*/
  437. void Delay(WORD n)
  438. {
  439.     WORD x;

  440.     while (n--)
  441.     {
  442.         x = 5000;
  443.         while (x--);
  444.     }
  445. }
复制代码
51hei.png
所有资料51hei提供下载:
20210103a.rar (580.92 KB, 下载次数: 228)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

回复

使用道具 举报

ID:328014 发表于 2021-1-3 14:23 | 显示全部楼层
好东东,可惜我用Proteus8.8居然打不开这个工程文件,楼主是用的8.9吗?
回复

使用道具 举报

ID:867327 发表于 2021-1-3 16:48 | 显示全部楼层
Proteus8.10
回复

使用道具 举报

ID:996527 发表于 2022-3-25 12:50 | 显示全部楼层
厉害,可惜我版本太低打不开
回复

使用道具 举报

ID:192215 发表于 2022-5-16 10:30 | 显示全部楼层
楼主遇没遇到过打开后LCD白屏问题
回复

使用道具 举报

ID:1058975 发表于 2023-1-30 18:49 | 显示全部楼层
不错,参考一下 STC 定时器
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表