设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 单片机仿真论坛 › STC15W4K32S4单片机ADC读取 串口收发 设定定时器的代码 ...
返回列表 发新帖
查看: 6850|回复: 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. /*---------------------------------------------------------------------*/

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

  11. #include        "STC15Fxxxx.H"
  12. //#include "reg51.h"
  13. #include <stdio.h>

  15. typedef unsigned char BYTE;
  16. typedef unsigned int WORD;
  17. //typedef unsigned int u16;  //对数据类型进行声明定义
  18. //typedef unsigned char u8;

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

  23. #define NONE_PARITY     0       //无校验
  24. #define ODD_PARITY      1       //奇校验
  25. #define EVEN_PARITY     2       //偶校验
  26. #define MARK_PARITY     3       //标记校验
  27. #define SPACE_PARITY    4       //空白校验

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

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

  50. //sfr P_SW1   = 0xA2;             //外设功能切换寄存器1
  51. */
  52. #define S1_S0 0x40              //P_SW1.6
  53. #define S1_S1 0x80              //P_SW1.7

  55. #define ADC_POWER   0x80            //ADC电源控制位
  56. #define ADC_FLAG    0x10            //ADC完成标志
  57. #define ADC_START   0x08            //ADC起始控制位
  58. #define ADC_SPEEDLL 0x00            //540个时钟
  59. #define ADC_SPEEDL  0x20            //360个时钟
  60. #define ADC_SPEEDH  0x40            //180个时钟
  61. #define ADC_SPEEDHH 0x60            //90个时钟

  63. //sbit P22 = P2^2;
  64. unsigned int ch;a,b;
  65. unsigned int dd=0;
  66. unsigned int cc=0;
  67. unsigned int cc0=0;
  68. unsigned int cc1=0;
  69. unsigned int cc00=0;
  70. unsigned int cc01=0;
  71. unsigned int cc10=0;
  72. unsigned int cc11=0;
  73. unsigned int time0count0 = 0 ;
  74. unsigned int time0count1 = 0 ;
  75. unsigned int time0count = 3000 ;
  76. bit busy;
  77. char receivechar = 0;
  78. int receive_count = 0;
  79. int received = 0;
  80. WORD receivestr[10];

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

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

  241.                 }
  242. }

  244. /*******************************************************************************
  245. * 函 数 名         : Timer0Init
  246. * 函数功能                   : 定时器0初始化
  247. * 输    入         : 无
  248. * 输    出         : 无
  249. *******************************************************************************/
  250. void Timer0Init()
  251. {
  252.         TMOD|=0X01;//选择为定时器0模式，工作方式1，仅用TR0打开启动。

  254.         TH0=0XFC;        //给定时器赋初值，定时1ms
  255.         TL0=0X18;        
  256.         ET0=1;//打开定时器0中断允许
  257.         EA=1;//打开总中断
  258.         TR0=1;//打开定时器                        
  259. }
  260. /*----------------------------
  261. 初始化串口
  262. ----------------------------*/
  263. void InitUart()
  264. {
  265. //    ACC = P_SW1;
  266. //    ACC &= ~(S1_S0 | S1_S1);    //S1_S0=0 S1_S1=0
  267. //    P_SW1 = ACC;                //(P3.0/RxD, P3.1/TxD)
  268.    
  269. //  ACC = P_SW1;
  270. //  ACC &= ~(S1_S0 | S1_S1);    //S1_S0=1 S1_S1=0
  271. //  ACC |= S1_S0;               //(P3.6/RxD_2, P3.7/TxD_2)
  272. //  P_SW1 = ACC;  
  273. //  
  274. //  ACC = P_SW1;
  275. //  ACC &= ~(S1_S0 | S1_S1);    //S1_S0=0 S1_S1=1
  276. //  ACC |= S1_S1;               //(P1.6/RxD_3, P1.7/TxD_3)
  277. //  P_SW1 = ACC;  

  279. #if (PARITYBIT == NONE_PARITY)
  280.     SCON = 0x50;                //8位可变波特率
  281. #elif (PARITYBIT == ODD_PARITY) || (PARITYBIT == EVEN_PARITY) || (PARITYBIT == MARK_PARITY)
  282.     SCON = 0xda;                //9位可变波特率,校验位初始为1
  283. #elif (PARITYBIT == SPACE_PARITY)
  284.     SCON = 0xd2;                //9位可变波特率,校验位初始为0
  285. #endif

  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.     ES = 1;                     //使能串口中断
  293.     EA = 1;
  294.         
  295.         
  296.         
  297. //    SCON = 0x5a;                //设置串口为8位可变波特率
  298. //#if URMD == 0
  299. //    T2L = (65536 - (FOSC/4/BAUD));
  300. //    T2H = (65536 - (FOSC/4/BAUD)) >> 8;
  301. //    AUXR = 0x14;                //T2为1T模式, 并启动定时器2
  302. //    AUXR |= 0x01;               //选择定时器2为串口1的波特率发生器
  303. //#elif URMD == 1
  304. //    AUXR = 0x40;                //定时器1为1T模式
  305. //    TMOD = 0x00;                //定时器1为模式0(16位自动重载)
  306. //    TL1 = (65536 - (FOSC/4/BAUD));
  307. //    TH1 = (65536 - (FOSC/4/BAUD)) >> 8;
  308. //    TR1 = 1;                    //定时器1开始启动
  309. //#else
  310. //    TMOD = 0x20;                //设置定时器1为8位自动重装载模式
  311. //    AUXR = 0x40;                //定时器1为1T模式
  312. //    TH1 = TL1 = (256 - (FOSC/32/BAUD));
  313. //    TR1 = 1;
  314. //#endif
  315. }

  317. /*----------------------------
  318. 初始化ADC
  319. ----------------------------*/
  320. void InitADC()
  321. {
  322.                 P1M0 =1;
  323.                 P1M1 =0;
  324.                 P1 = 0Xff;
  325.     P1ASF = 0xff;                   //设置P1口为AD口
  326.     ADC_RES = 0;                    //清除结果寄存器
  327.     ADC_RESL = 0;                    //清除结果寄存器
  328.     ADC_CONTR = ADC_POWER | ADC_SPEEDLL;
  329.     Delay(2);                       //ADC上电并延时
  330. }

  332. /*----------------------------
  333. 读取ADC结果 20210101 注释GetADCResult 用GetADCResultint代替
  334. ----------------------------*/

  336. unsigned int GetADCResultint(BYTE ch)
  337. {
  338.                 unsigned int ret=0;
  339.     ADC_CONTR = ADC_POWER | ADC_SPEEDLL | ch | ADC_START;
  340.     _nop_();                        //等待4个NOP
  341.     _nop_();
  342.     _nop_();
  343.     _nop_();
  344.     while (!(ADC_CONTR & ADC_FLAG));//等待ADC转换完成
  345.     ADC_CONTR &= ~ADC_FLAG;         //Close ADC
  346.                 ret = ADC_RES*4 + ADC_RESL;
  347.     return ret;                 //返回ADC结果
  348. }


  351. /*----------------------------
  352. UART 中断服务程序
  353. -----------------------------*/
  354. void Uart() interrupt 4
  355. {

  357.     if (RI)
  358.     {
  359.         RI = 0;                 //清除RI位
  360.         receivechar = SBUF;              //P0显示串口数据
  361.                         if  ( receivechar == 60 ) receive_count = 0 ;
  362.                         if ((receive_count<9) && ( receivechar != 62 )&&(received == 0 ))
  363.                         {
  364.                                 receivestr[receive_count] = receivechar;
  365.                                 receivestr[receive_count+1] = 0;
  366.                                 receive_count = receive_count + 1 ;
  367.                                 
  368.                         }
  369.                         else
  370.                         {
  371.                                 received = 1;
  372. //                                while (initreceivestrcount<10)
  373. //                                {
  374. //                                        receivestr[initreceivestrcount]=0;
  375. //                                        initreceivestrcount = initreceivestrcount + 1 ;
  376. //                                }
  377.                                 
  378.                         }
  379. //                        SendData(receivechar);
  380. //        P22 = RB8;              //P2.2显示校验位
  381.     }
  382.                         
  383.     if (TI)
  384.     {
  385.         TI = 0;                 //清除TI位
  386.         busy = 0;               //清忙标志
  387.     }
  388. }

  390. void Timer0() interrupt 1
  391. {
  392.         static u16 itime0;
  393.         TH0=0XFC;        //给定时器赋初值，定时1ms
  394.         TL0=0X18;
  395.         itime0++;
  396.         if(itime0==time0count)
  397.         {
  398.                 itime0=0;
  399.                 time0count0 = time0count0 + 1;        
  400.                 if ( time0count0 > 20 ) time0count0 = 0;
  401.         }        
  402. }

  404. /*----------------------------
  405. 发送串口数据
  406. ----------------------------*/
  407. void SendData(BYTE dat)
  408. {
  409.     while (busy);               //等待前面的数据发送完成
  410.     ACC = dat;                  //获取校验位P (PSW.0)
  411. //    if (P)                      //根据P来设置校验位
  412. //    {
  413. //#if (PARITYBIT == ODD_PARITY)
  414. //        TB8 = 0;                //设置校验位为0
  415. //#elif (PARITYBIT == EVEN_PARITY)
  416. //        TB8 = 1;                //设置校验位为1
  417. //#endif
  418. //    }
  419. //    else
  420. //    {
  421. //#if (PARITYBIT == ODD_PARITY)
  422. //        TB8 = 1;                //设置校验位为1
  423. //#elif (PARITYBIT == EVEN_PARITY)
  424. //        TB8 = 0;                //设置校验位为0
  425. //#endif
  426. //    }
  427.     busy = 1;
  428.     SBUF = ACC;                 //写数据到UART数据寄存器
  429. }

  431. /*----------------------------
  432. 发送字符串
  433. ----------------------------*/
  434. void SendString(char *s)
  435. {
  436. //        EA = 0 ;
  437. //        ES = 0 ;
  438.         while (*s)                  //检测字符串结束标志
  439.         {
  440.                         SendData(*s++);         //发送当前字符
  441.         }
  442. //        EA = 1 ;
  443. //        ES = 1 ;
  444. }
  445. void serial_put_uint(unsigned int number)
  446. {
  447.       unsigned int i;
  448.       unsigned int nTmp;
  449. //        *s++ =num/10 +'0';
  450. //*s++=num%10 +'0';
  451. //*s =0;
  452.         
  453.      //感觉这写法怪怪的吗？干嘛不for(i=1;i<5;i++) 因为这样不需要使用库函数pow()
  454.      for(i=10000;i>=1;i=i/10)
  455.       {
  456.             nTmp = number/i;
  457.                                                 if(nTmp >=1 ) SendData((unsigned char)(nTmp%10 + 0x30));
  458.       }
  459. }

  461. /*----------------------------
  462. 软件延时
  463. ----------------------------*/
  464. void Delay(WORD n)
  465. {
  466.     WORD x;

  468.     while (n--)
  469.     {
  470.         x = 5000;
  471.         while (x--);
  472.     }
  473. }
复制代码
51hei.png
所有资料51hei提供下载:
20210103a.rar (580.92 KB, 下载次数: 243)

评分

参与人数 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 定时器
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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