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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 单片机DIY制作 › STM32电阻检测仪制作资料 含源码(参加校赛作品分享)
返回列表 发新帖
查看: 6681|回复: 4
收起左侧

STM32电阻检测仪制作资料 含源码(参加校赛作品分享)

[复制链接]
ID:275479 发表于 2018-6-2 18:20 | 显示全部楼层 |阅读模式
参考正点原子的T9拼音输入和输入捕获来做的测占空比和触摸屏，通过被测电阻影响555定时器的产生的方波占空比来测量电阻，仅需要一个555定时器，不需要选择电路，即可测量0-10M的电阻，并且精度能达到2%。在实际的制作中还有很多的注意事项，大家可以不断摸索尝试。

制作出来的实物图如下：
UL3E[(}KEPI]ZIMC1NL8NX6.jpg NS1`2E50[_QE`@U~%)K_XM2.jpg

电路原理图如下：
-62641effcb942d15.png

STM32单片机源程序如下:
  1. #include "sys.h"
  2. #include "delay.h"
  3. #include "usart.h"
  4. #include "led.h"                           
  5. #include "lcd.h"  
  6. #include "key.h"      
  7. #include "malloc.h"
  8. #include "sdio_sdcard.h"  
  9. #include "w25qxx.h"   
  10. #include "ff.h"  
  11. #include "exfuns.h"   
  12. #include "text.h"  
  13. #include "pyinput.h"
  14. #include "touch.h"        
  15. #include "string.h"            
  16. #include "usmart.h"     
  17. #include "timer.h"
  18. #include <math.h>

  20. //数字表
  21. const u8* kbd_tbl[12]={"1","2","3","4","5","6","7","8","9",".","0","确认",};
  22. //字符表
  23. const u8* kbs_tbl[9]={" "," "," "," "," "," "," "," "," ",};

  25. u16 kbdxsize;        //虚拟键盘按键宽度
  26. u16 kbdysize;        //虚拟键盘按键高度


  29. extern u16  TIM5CH1_CAPTURE_STA;        //输入捕获状态                 
  30. extern u16  countH,countL;                                          
  31. extern u16        TIM5CH1_CAPTURE_VAL,TIM5CH1_CAPTURE_VAL1;        //输入捕获值        
  32. long double res,res1;
  33. long double x1,x2,x3,x4,x5,x6,x7;


  36. //加载键盘界面
  37. //x,y:界面起始坐标
  38. void py_load_ui(u16 x,u16 y)
  39. {
  40.         u16 i;
  41.         POINT_COLOR=RED;
  42.         LCD_DrawRectangle(x,y,x+kbdxsize*3,y+kbdysize*4);                                                   
  43.         LCD_DrawRectangle(x,y,x+kbdxsize*3,y+kbdysize*1);                                                   
  44.         LCD_DrawRectangle(x,y,x+kbdxsize*3,y+kbdysize*2);
  45.         LCD_DrawRectangle(x,y,x+kbdxsize*3,y+kbdysize*3);
  46.         LCD_DrawRectangle(x,y,x+kbdxsize*1,y+kbdysize*4);
  47.         LCD_DrawRectangle(x,y,x+kbdxsize*2,y+kbdysize*4);
  48.         POINT_COLOR=BLUE;
  49.         for(i=0;i<12;i++)
  50.         {
  51.                 Show_Str_Mid(x+(i%3)*kbdxsize,y+4+kbdysize*(i/3),(u8*)kbd_tbl[i],16,kbdxsize);               
  52. //                Show_Str_Mid(x+(i%3)*kbdxsize,y+kbdysize/2+kbdysize*(i/3),(u8*)kbs_tbl[i],16,kbdxsize);               
  53.         }                                                              
  54. }
  55. //按键状态设置
  56. //x,y:键盘坐标
  57. //key:键值（0~8）
  58. //sta:状态，0，松开；1，按下；
  59. void py_key_staset(u16 x,u16 y,u8 keyx,u8 sta)
  60. {                  
  61.         u16 i=keyx/3,j=keyx%3;
  62.         printf("%d   %d  %d\r\n",keyx,i,j);
  63.         if(keyx>12)return;
  64.         if(sta)LCD_Fill(x+j*kbdxsize+1,y+i*kbdysize+1,x+j*kbdxsize+kbdxsize-1,y+i*kbdysize+kbdysize-1,GREEN);
  65.         else LCD_Fill(x+j*kbdxsize+1,y+i*kbdysize+1,x+j*kbdxsize+kbdxsize-1,y+i*kbdysize+kbdysize-1,WHITE);
  66.         Show_Str_Mid(x+j*kbdxsize,y+4+kbdysize*i,(u8*)kbd_tbl[keyx],16,kbdxsize);               
  67.         Show_Str_Mid(x+j*kbdxsize,y+kbdysize/2+kbdysize*i,(u8*)kbs_tbl[keyx],16,kbdxsize);                 
  68. }
  69. //得到触摸屏的输入
  70. //x,y:键盘坐标
  71. //返回值：按键键值（1~9有效；0,无效）
  72. u8 py_get_keynum(u16 x,u16 y)
  73. {
  74.         u16 i,j;
  75.         static u8 key_x=0;//0,没有任何按键按下；1~9，1~9号按键按下
  76.         u8 key=0;
  77.         tp_dev.scan(0);                  
  78.         if(tp_dev.sta&TP_PRES_DOWN)                        //触摸屏被按下
  79.         {        
  80.                 for(i=0;i<4;i++)
  81.                 {
  82.                         for(j=0;j<3;j++)
  83.                         {
  84.                                  if(tp_dev.x[0]<(x+j*kbdxsize+kbdxsize)&&tp_dev.x[0]>(x+j*kbdxsize)
  85.                                         &&tp_dev.y[0]<(y+i*kbdysize+kbdysize)&&tp_dev.y[0]>(y+i*kbdysize))
  86.                                 {        
  87.                                         key=i*3+j+1;         
  88.                                         break;                           
  89.                                 }
  90.                         }
  91.                         if(key)
  92.                         {           
  93.                                 if(key_x==key)key=0;
  94.                                 else
  95.                                 {
  96.                                         py_key_staset(x,y,key_x-1,0);
  97.                                         key_x=key;
  98.                                         py_key_staset(x,y,key_x-1,1);
  99.                                 }
  100.                                 break;
  101.                         }
  102.                 }  
  103.         }else if(key_x)
  104.         {
  105.                 py_key_staset(x,y,key_x-1,0);
  106.                 key_x=0;
  107.         }
  108. //        printf( "%d  \r\n",key_x);
  109.         return key;
  110. }
  111.                                                            
  112. //显示结果.
  113. //index:0,表示没有一个匹配的结果.清空之前的显示
  114. //   其他,索引号        
  115. void py_show_result(u8 index)
  116. {
  117.          LCD_ShowNum(30+144,125,index,1,16);                 //显示当前的索引
  118.         LCD_Fill(30+40,125,30+40+48,130+16,WHITE);        //清除之前的显示
  119.          LCD_Fill(30+40,145,lcddev.width,145+48,WHITE);//清除之前的显示   
  120.         if(index)
  121.         {
  122. //                 Show_Str(30+40,125,200,16,t9.pymb[index-1]->py,16,0);         //显示拼音
  123. //                Show_Str(30+40,145,lcddev.width-70,48,t9.pymb[index-1]->pymb,16,0);//显示对应的汉字
  124. //               
  125.         }
  126. }


  129. int main(void)
  130. {         
  131.          u16 i,flag;
  132.          u16 i1,j1;
  133.          u8 lcd_id[12];                        //存放LCD ID字符串
  134.          u8 buf[12]={0};
  135.          double temp=0, temp1=0;
  136. //                double f;
  137. long double duty,duty1,pingjun;                          
  138.         u8 result_num;
  139.         u8 cur_index;
  140.         u8 key;
  141.         u8 inputstr[7];                //最大输入6个字符+结束符
  142.         u8 inputlen;                //输入长度         
  143.         uart_init(115200);                 //串口初始化为115200
  144.         delay_init();                     //延时函数初始化         
  145.         LED_Init();                                          //初始化与LED连接的硬件接口        
  146.         KEY_Init();                                        //初始化按键
  147.         LCD_Init();                                           //初始化LCD         
  148.   NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
  149.                  
  150.          TIM5_Cap_Init(0XFFFF,1-1);        //以72Mhz的频率计数
  151.          
  152.         
  153.         usmart_dev.init(72);                //初始化USMART

  155.    
  156.         W25QXX_Init();                                //初始化W25Q128
  157.         tp_dev.init();                                //初始化触摸屏
  158.          my_mem_init(SRAMIN);                //初始化内部内存池
  159.         exfuns_init();                                //为fatfs相关变量申请内存  
  160.          f_mount(fs[0],"0:",1);                 //挂载SD卡
  161.          f_mount(fs[1],"1:",1);                 //挂载FLASH.
  162.          POINT_COLOR=RED;      
  163.          while(font_init())                         //检查字库
  164.         {            
  165.                 LCD_ShowString(30,50,200,16,16,"Font Error!");
  166.                 delay_ms(200);                                 
  167.                 LCD_Fill(30,50,240,66,WHITE);//清除显示            
  168.         }
  169. RESTART:
  170.          POINT_COLOR=RED;      
  171.         Show_Str(30,5,200,16,"被测阻值大小：",16,0);                                             
  172.                              

  174.         Show_Str(30,65,200,16,"输入目标阻值:       ",16,0);
  175.          Show_Str(30,85,200,16,"输入目标误差:         ",16,0);

  177.         if(lcddev.id==0X5310){kbdxsize=86;kbdysize=43;}//根据LCD分辨率设置按键大小
  178.         else if(lcddev.id==0X5510||lcddev.id==0X1963){kbdxsize=140;kbdysize=70;}
  179.         else {kbdxsize=60;kbdysize=40;}
  180.         py_load_ui(30,150);
  181.         memset(inputstr,0,7);        //全部清零
  182.         inputlen=0;                                //输入长度为0
  183.         result_num=0;                        //总匹配数清零
  184.         cur_index=0;                        
  185.         

  187.         while(1)
  188.         {
  189.                
  190.                         
  191.                 for(i=0;i<30;i++)
  192.                 {
  193.                         tp_dev.scan(0);
  194.                 while((TIM5CH1_CAPTURE_STA&0X0400)==0&&(tp_dev.sta&TP_PRES_DOWN)==0)
  195.                 {
  196.                 }
  197.                  if(TIM5CH1_CAPTURE_STA&0X0400)//成功捕获到了一次上升沿
  198.                 {
  199.                         TIM_Cmd(TIM5,DISABLE );         //停止使能定时器5               
  200.                         temp=countH&0XFFFF;
  201.                         temp*=65536;//溢出时间总和
  202.                         temp+=TIM5CH1_CAPTURE_VAL;//得到总的高电平时间
  203.                         temp1=countL&0XFFFF;
  204.                         temp1*=65536;//溢出时间总和
  205.                         temp1+=TIM5CH1_CAPTURE_VAL1;//得到总的高电平时间
  206.                         duty=temp/(temp+temp1);        
  207.                         
  208.                         }
  209.                 pingjun=pingjun+duty;
  210.                 TIM5CH1_CAPTURE_STA=0x0000;//开启下一次捕获        
  211.     TIM_Cmd(TIM5,ENABLE );         //使能定时器5               
  212.                 countH=0;
  213.                 countL=0;         
  214.                                 if(duty>0.998)               
  215.                                 {
  216.                                 i=i+30;
  217.          pingjun=duty*30;                                       
  218.                                 }
  219.                                 
  220.                 }
  221.                 TIM_Cmd(TIM5,ENABLE );         //停止使能定时器5        
  222.                   duty1=pingjun/30;
  223.                 pingjun=0;
  224.                         x1=duty1;x2=duty1;x3=duty1;        x4=duty1;        x5=duty1;        x6=duty1;        x7=duty1;
  225.                         x1=pow(x1,1);x2=pow(x2,2);x3=pow(x3,3);x4=pow(x4,4);x5=pow(x5,5);
  226.                         x6=pow(x6,6);x7=pow(x7,7);                        
  227.                         POINT_COLOR=RED;
  228.                         if(0.5<duty1&&duty1<0.73)
  229.                         {
  230.                         res=  -14302041012.00000000000000000000 *x6
  231.                                 + 58769808162.38000000000000000000 *x5
  232.                                 - 100611696743.20400000000000000000* x4
  233.                                 + 91852454672.19220000000000000000 *x3
  234.                                 - 47163395469.91170000000000000000 *x2
  235.                                 + 12914204844.35510000000000000000 *x1
  236.                                 - 1473223936.77019000000000000000 ;
  237.                                 if(res<0)
  238.                                 {res=0;}
  239.                                 if(res<10&&res>0)
  240.                                 {
  241.                                 sprintf((char*)buf,"%s%.0f%s ","00",res,"         ohm   ");
  242.                                 }
  243.                                 
  244.                                 else if(res>10&&res<100)
  245.                                 {sprintf((char*)buf,"%.1f%s ",res,"         ohm   ");}
  246.                                 else
  247.                                 sprintf((char*)buf,"%.0f%s ",res,"           ohm   ");//将LCD ID打印到lcd_id数组。               
  248.                         }
  249.                         
  250.                                 else if(0.73<duty1&&duty1<0.88)
  251.                         {
  252.                                 x1=duty1;x2=duty1;x3=duty1;        x4=duty1;        x5=duty1;        x6=duty1;        x7=duty1;
  253.                         x1=pow(x1,1);x2=pow(x2,2);x3=pow(x3,3);x4=pow(x4,4);x5=pow(x5,5);
  254.                         x6=pow(x6,6);x7=pow(x7,7);
  255.                                 res= 50576272.31250000000000000000* x6
  256.                                 - 253686059.69843800000000000000 *x5 +
  257.                                 528819351.78510700000000000000 *x4 -
  258.                                 586296731.32720000000000000000 *x3 +
  259.                                 364607758.57319900000000000000 *x2 -
  260.                                 120587778.49805700000000000000* x1 +
  261.                                 16570759.99618540000000000000 ;     
  262.                                 if(res>930&&res<1000)
  263.                                 res+=6;        
  264.                                 sprintf((char*)buf,"%.0f%s ",res,"          ohm   ");
  265.                                 if(res>=1000)
  266.                                 {
  267.                                         res=res/1000;
  268.                                         sprintf((char*)buf,"%.2f%s ",res,"    K  ohm   ");
  269.                                 }
  270.                         }
  271.                         else if(0.88<duty1&&duty1<0.985)
  272.                         {
  273.                                 res = 9886588.40917969000000000000
  274.                                 *x6 - 54523063.81499820000000000000 *x5
  275.                                 + 125263597.49274900000000000000 *x4
  276.                                 - 153457525.82975900000000000000 *x3
  277.                                 + 105728501.67596900000000000000 *x2
  278.                                 - 38842842.27736880000000000000 *x1 +
  279.                                 5944747.37332069000000000000 ;
  280.                                 res=res*10;
  281.                                  if(res>10&&res<100)
  282.                                          sprintf((char*)buf,"%.1f%s ",res,"    K  ohm   ");
  283.                                  else
  284.          sprintf((char*)buf,"%.2f%s ",res,"    K  ohm   ");
  285.                         }                        
  286.                         else if(0.9850<duty1&&duty1<0.9980)
  287.                         {
  288.                                 res   = 80085557347.37500000000000000000 *x5
  289.                                 - 395505919886.63800000000000000000 *x4
  290.                                 + 781284983275.76300000000000000000 *x3
  291.                                 - 771673654310.73900000000000000000 *x2
  292.                                 + 381088259432.87600000000000000000 *x1
  293.                                 - 75279225837.53090000000000000000 ;
  294.         res=res*10;
  295.                                 if(res>20&&res<25)
  296.                                 {res=res-1;}
  297.                                 if(res>30&&res<40)
  298.                                 {res=res+1;}
  299.                                 if(res>55&&res<58)
  300.                                 {res=res-1;}
  301.                                 if(res>58&&res<87)
  302.                                 {res=res-2;}
  303.         if(res>87&&res<92)
  304.                                 {res=res-1;}
  305.                                 printf( "%d  \r\n",duty1);
  306.                                 printf( "%d  \r\n",res);
  307.         sprintf((char*)buf,"%.1f%s ",res,"    K  ohm   ");
  308.                         }
  309.                         else if(duty1>0.9980)
  310.                         {
  311.                                 duty1=duty1*1000-999;
  312.                         x1=duty1;
  313.                         x2=duty1;
  314.                         x3=duty1;
  315.                         x4=duty1;
  316.                         x5=duty1;
  317.                         x6=duty1;
  318.                         x7=duty1;
  319.                         x1=pow(x1,1);x2=pow(x2,2);x3=pow(x3,3);x4=pow(x4,4);x5=pow(x5,5);
  320.                         x6=pow(x6,6);x7=pow(x7,7);
  321.                                 res = 451698.02975654600000000000 *x5
  322.                                 - 1949941.77138209000000000000 *x4
  323.                                 + 3364145.37781321000000000000* x3
  324.                                 - 2899364.16821244000000000000* x2
  325.                                 + 1248232.03533619000000000000* x1
  326.                                 - 214750.16957818900000000000 ;
  327.          sprintf((char*)buf,"%.2f%s ",res,"    M  ohm   ");
  328.                         }                                                                                                         
  329.                
  330.   

  332.                 key=py_get_keynum(30,150);
  333.                 if(key)
  334.                 {
  335.                         if(key==1)//删除
  336.                         {
  337.                                 if(inputlen)inputlen--;
  338.                                 inputstr[inputlen]='\0';//添加结束符
  339.                         }else
  340.                         {
  341.                                 inputstr[inputlen]=key+'0';//输入字符
  342.                                 if(inputlen<7)inputlen++;
  343.                         }
  344.                         if(inputstr[0]!=NULL)
  345.                         {
  346.                                 key=t9.getpymb(inputstr);        //得到匹配的结果数
  347.                                 if(key)//有部分匹配/完全匹配的结果
  348.                                 {
  349.                                         result_num=key&0X7F;        //总匹配结果
  350.                                         cur_index=1;                        //当前为第一个索引
  351.                                         if(key&0X80)                           //是部分匹配
  352.                                         {
  353.                                                 inputlen=key&0X7F;        //有效匹配位数
  354.                                                 inputstr[inputlen]='\0';//不匹配的位数去掉
  355.                                                 if(inputlen>1)result_num=t9.getpymb(inputstr);//重新获取完全匹配字符数
  356.                                         }  
  357.                                 }else                                                 //没有任何匹配
  358.                                 {                                          
  359.                                         inputlen--;
  360.                                         inputstr[inputlen]='\0';
  361.                                 }
  362.                         }else
  363.                         {
  364.                                 cur_index=0;
  365.                                 result_num=0;
  366.                         }
  367. //                        LCD_Fill(30+40,105,30+40+48,110+16,WHITE);        //清除之前的显示
  368. //                        LCD_ShowNum(30+144,105,result_num,1,16);         //显示匹配的结果数
  369. //                        Show_Str(30+40,105,200,16,inputstr,16,0);        //显示有效的数字串                 
  370. //                         py_show_result(cur_index);                                        //显示第cur_index的匹配结果
  371.                 }         
  372.                 key=KEY_Scan(0);

  374.                 if(result_num)        //存在匹配的结果        
  375.                 {        
  376.                         switch(key)
  377.                         {
  378.                                  case KEY1_PRES://下翻
  379.                                            if(cur_index>1)cur_index--;
  380.                                         else cur_index=result_num;
  381.                                         py_show_result(cur_index);        //显示第cur_index的匹配结果
  382.                                         break;
  383.                                 case KEY0_PRES://清除输入
  384.                                          LCD_Fill(30+40,145,lcddev.width,145+48,WHITE);        //清除之前的显示   
  385.                                         goto RESTART;                                                     
  386.                         }            
  387.                 }
  388.                 LCD_ShowString(30,35,210,24,24, (u8 *)buf);
  389.                 TIM5CH1_CAPTURE_STA=0x0000;//开启下一次捕获        

  391.     TIM_Cmd(TIM5,ENABLE );         //使能定时器5               
  392.                 countH=0;
  393.                 countL=0;        

  395.   }                                                                                                                                                      
  396. }
复制代码

全部资料51hei下载地址：
电阻检测.rar (1.83 MB, 下载次数: 119)

评分

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

查看全部评分

回复

使用道具 举报

ID:404837 发表于 2018-10-2 13:23 | 显示全部楼层
不错不错
回复

使用道具 举报

ID:433680 发表于 2018-12-4 11:54 | 显示全部楼层
不错不错得! VERY good!
回复

使用道具 举报

ID:246896 发表于 2019-10-29 15:41 | 显示全部楼层
下载学习
回复

使用道具 举报

ID:637789 发表于 2019-11-7 22:23 | 显示全部楼层
太棒了吧
那个Xsc1是个啥
那个555VIRTUAL 是个啥
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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