久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费

 找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 2353|回復(fù): 3
打印 上一主題 下一主題
收起左側(cè)

單片機(jī)程序中pwm信號讀取不出來，求解救！

[復(fù)制鏈接]
跳轉(zhuǎn)到指定樓層
樓主
ID:250933 發(fā)表于 2017-11-19 00:05 | 只看該作者 回帖獎勵 |倒序?yàn)g覽 |閱讀模式
51單片機(jī)中斷中pwm的信號讀取不出來，無法和count比較
  1. #include<reg52.h>
  2. #include "control.h"
  3. #include "12864.h"
  4. #define uchar unsigned char
  5. #define uint unsigned int
  6. #define keydata P1
  7. sbit A1=P2^2;
  8. sbit A2=P2^3;
  9. sbit ENA=P2^4;
  10. signed int count=0;
  11. signed char pwm=0;
  12. signed char anjian=0;
  13. uchar numshi=0;
  14. uchar numge=0;
  15. void delayms(unsigned int xms)
  16. {
  17.         unsigned int i,j;
  18.         for(i=0;i<xms;i++)
  19.                 for(j=0;j<110;j++);
  20. }

  22. void pwm_dis()
  23. {
  24.         numshi=pwm/10;
  25.         numge=pwm%10;
  26.         write_12864_data(0x30+numshi);
  27.         write_12864_data(0x30+numge);      
  28. }

  30. void anjian_dis()
  31. {
  32.         numshi=anjian/10;
  33.         numge=anjian%10;
  34.         write_12864_data(0x30+numshi);
  35.         write_12864_data(0x30+numge);      
  36. }
  37. void keyscan()
  38. {
  39.                 unsigned char dat=0;
  40.                 unsigned char num=0;
  41.                         keydata=0xfe;
  42.                         dat=keydata;
  43.                         dat=dat&0xf0;
  44.                         while(dat!=0xf0)
  45.                                 {
  46.                                         delayms(5);
  47.                                         dat=keydata;
  48.                                         dat=dat&0xf0;
  49.                                         while(dat!=0xf0)
  50.                                         {
  51.                                                 dat=keydata;
  52.                                         switch(dat)
  53.                                                 {
  54.                                                         case 0xee:num=1;
  55.                                                                 break;
  56.                                                         case 0xde:num=2;
  57.                                                                 break;
  58.                                                         case 0xbe:num=3;
  59.                                                                 break;
  60.                                                         case 0x7e:num=4;
  61.                                                                 break;
  62.                                                 }
  63.                                         while(dat!=0xf0)
  64.                                                 {
  65.                                                         dat=keydata;
  66.                                                         dat=dat&0xf0;
  67.                                                 }
  68.                                                
  69.                                         }
  70.                                 }

  72.                         keydata=0xfd;
  73.                         dat=keydata;
  74.                         dat=dat&0xf0;
  75.                         while(dat!=0xf0)
  76.                                 {
  77.                                         delayms(5);
  78.                                         dat=keydata;
  79.                                         dat=dat&0xf0;
  80.                                         while(dat!=0xf0)
  81.                                         {
  82.                                                 dat=keydata;
  83.                                         switch(dat)
  84.                                                 {
  85.                                                         case 0xed:num=5;
  86.                                                                 break;
  87.                                                         case 0xdd:num=6;
  88.                                                                 break;
  89.                                                         case 0xbd:num=7;
  90.                                                                 break;
  91.                                                         case 0x7d:num=8;
  92.                                                                 break;
  93.                                                 }
  94.                                         while(dat!=0xf0)
  95.                                                 {
  96.                                                         dat=keydata;
  97.                                                         dat=dat&0xf0;
  98.                                                 }
  99.                                                
  100.                                         }
  101.                                 }


  104.                         keydata=0xfb;
  105.                         dat=keydata;
  106.                         dat=dat&0xf0;
  107.                         while(dat!=0xf0)
  108.                                 {
  109.                                         delayms(5);
  110.                                         dat=keydata;
  111.                                         dat=dat&0xf0;
  112.                                         while(dat!=0xf0)
  113.                                         {
  114.                                                 dat=keydata;
  115.                                         switch(dat)
  116.                                                 {
  117.                                                         case 0xeb:num=9;
  118.                                                                 break;
  119.                                                         case 0xdb:num=10;
  120.                                                                 break;
  121.                                                         case 0xbb:num=11;
  122.                                                                 break;
  123.                                                         case 0x7b:num=12;
  124.                                                                 break;
  125.                                                 }
  126.                                         while(dat!=0xf0)
  127.                                                 {
  128.                                                         dat=keydata;
  129.                                                         dat=dat&0xf0;
  130.                                                 }
  131.                                        
  132.                                         }
  133.                                 }


  136.                         keydata=0xf7;
  137.                         dat=keydata;
  138.                         dat=dat&0xf0;
  139.                         while(dat!=0xf0)
  140.                                 {
  141.                                         delayms(5);
  142.                                         dat=keydata;
  143.                                         dat=dat&0xf0;
  144.                                         while(dat!=0xf0)
  145.                                         {
  146.                                                 dat=keydata;
  147.                                         switch(dat)
  148.                                                 {
  149.                                                         case 0xe7:num=13;
  150.                                                                 break;
  151.                                                         case 0xd7:num=14;
  152.                                                                 break;
  153.                                                         case 0xb7:num=15;
  154.                                                                 break;
  155.                                                         case 0x77:num=16;
  156.                                                                 break;
  157.                                                 }
  158.                                         while(dat!=0xf0)
  159.                                                 {
  160.                                                         dat=keydata;
  161.                                                         dat=dat&0xf0;
  162.                                                 }
  163.                                                
  164.                                         }
  165.                                 }
  166.                
  167.                
  168.       
  169.                 switch(num)
  170.                 {
  171.                         case 1:        write_12864_addr(1,3);
  172.                                 pwm=0;
  173.                                 pwm_dis();
  174.                                 break;
  175.                 case 2:        write_12864_addr(1,3);
  176.                                 pwm=10;
  177.                                 pwm_dis();
  178.                                 break;
  179.                 case 3:write_12864_addr(1,3);
  180.                                 pwm=20;
  181.                                 pwm_dis();
  182.                                 break;
  183.                 case 4:write_12864_addr(1,3);
  184.                                 pwm=30;
  185.                                 pwm_dis();
  186.                                 break;
  187.                 case 5:write_12864_addr(1,3);
  188.                                 pwm=40;
  189.                                 pwm_dis();
  190.                                 break;
  191.                 case 6:write_12864_addr(1,3);
  192.                                 pwm=50;
  193.                                 pwm_dis();
  194.                                 break;
  195.                 case 7:write_12864_addr(1,3);
  196.                                 pwm=60;
  197.                                 pwm_dis();
  198.                                 break;
  199.                 case 8:write_12864_addr(1,3);
  200.                                 pwm=70;
  201.                                 pwm_dis();
  202.                                 break;

  204.                 case 9:        write_12864_addr(1,3);
  205.                                 pwm=80;
  206.                                 pwm_dis();
  207.                                 break;
  208.                 case 10:        write_12864_addr(1,3);
  209.                                 pwm=90;
  210.                                 pwm_dis();
  211.                               
  212.                                 break;
  213.                 case 11:write_12864_addr(1,3);
  214.                        
  215.                                 pwm=99;
  216.                                 pwm_dis();
  217.                                 break;
  218.                 case 12:write_12864_addr(1,3);
  219.                        
  220.                                 pwm=35;
  221.                                 pwm_dis();
  222.                                 break;
  223.                 case 13:write_12864_addr(1,3);
  224.                        
  225.                                 pwm=pwm+5;
  226.                                 pwm_dis();
  227.                                 break;
  228.                 case 14:write_12864_addr(1,3);
  229.                        
  230.                                 pwm=pwm-5;
  231.                                 pwm_dis();
  232.                                 break;
  233.                 case 15:write_12864_addr(1,3);
  234.                                 pwm=pwm+1;
  235.                                 pwm_dis();
  236.                                 break;
  237.                 case 16:write_12864_addr(1,3);
  238.                                 pwm=pwm-1;
  239.                                 pwm_dis();
  240.                                 break;


  243.         }
  244.       

  246.       
  247. }

  249. void keyscan_1()
  250. {
  251.                 unsigned char dat=0;
  252.                 unsigned char num=0;
  253.                         keydata=0xfe;
  254.                         dat=keydata;
  255.                         dat=dat&0xf0;
  256.                         while(dat!=0xf0)
  257.                                 {
  258.                                         delayms(5);
  259.                                         dat=keydata;
  260.                                         dat=dat&0xf0;
  261.                                         while(dat!=0xf0)
  262.                                         {
  263.                                                 dat=keydata;
  264.                                         switch(dat)
  265.                                                 {
  266.                                                         case 0xee:num=1;
  267.                                                                 break;
  268.                                                         case 0xde:num=2;
  269.                                                                 break;
  270.                                                         case 0xbe:num=3;
  271.                                                                 break;
  272.                                                         case 0x7e:num=4;
  273.                                                                 break;
  274.                                                 }
  275.                                         while(dat!=0xf0)
  276.                                                 {
  277.                                                         dat=keydata;
  278.                                                         dat=dat&0xf0;
  279.                                                 }
  280.                                                
  281.                                         }
  282.                                 }

  284.                         keydata=0xfd;
  285.                         dat=keydata;
  286.                         dat=dat&0xf0;
  287.                         while(dat!=0xf0)
  288.                                 {
  289.                                         delayms(5);
  290.                                         dat=keydata;
  291.                                         dat=dat&0xf0;
  292.                                         while(dat!=0xf0)
  293.                                         {
  294.                                                 dat=keydata;
  295.                                         switch(dat)
  296.                                                 {
  297.                                                         case 0xed:num=5;
  298.                                                                 break;
  299.                                                         case 0xdd:num=6;
  300.                                                                 break;
  301.                                                         case 0xbd:num=7;
  302.                                                                 break;
  303.                                                         case 0x7d:num=8;
  304.                                                                 break;
  305.                                                 }
  306.                                         while(dat!=0xf0)
  307.                                                 {
  308.                                                         dat=keydata;
  309.                                                         dat=dat&0xf0;
  310.                                                 }
  311.                                                
  312.                                         }
  313.                                 }


  316.                         keydata=0xfb;
  317.                         dat=keydata;
  318.                         dat=dat&0xf0;
  319.                         while(dat!=0xf0)
  320.                                 {
  321.                                         delayms(5);
  322.                                         dat=keydata;
  323.                                         dat=dat&0xf0;
  324.                                         while(dat!=0xf0)
  325.                                         {
  326.                                                 dat=keydata;
  327.                                         switch(dat)
  328.                                                 {
  329.                                                         case 0xeb:num=9;
  330.                                                                 break;
  331.                                                         case 0xdb:num=10;
  332.                                                                 break;
  333.                                                         case 0xbb:num=11;
  334.                                                                 break;
  335.                                                         case 0x7b:num=12;
  336.                                                                 break;
  337.                                                 }
  338.                                         while(dat!=0xf0)
  339.                                                 {
  340.                                                         dat=keydata;
  341.                                                         dat=dat&0xf0;
  342.                                                 }
  343.                                        
  344.                                         }
  345.                                 }


  348.                         keydata=0xf7;
  349.                         dat=keydata;
  350.                         dat=dat&0xf0;
  351.                         while(dat!=0xf0)
  352.                                 {
  353.                                         delayms(5);
  354.                                         dat=keydata;
  355.                                         dat=dat&0xf0;
  356.                                         while(dat!=0xf0)
  357.                                         {
  358.                                                 dat=keydata;
  359.                                         switch(dat)
  360.                                                 {
  361.                                                         case 0xe7:num=13;
  362.                                                                 break;
  363.                                                         case 0xd7:num=14;
  364.                                                                 break;
  365.                                                         case 0xb7:num=15;
  366.                                                                 break;
  367.                                                         case 0x77:num=16;
  368.                                                                 break;
  369.                                                 }
  370.                                         while(dat!=0xf0)
  371.                                                 {
  372.                                                         dat=keydata;
  373.                                                         dat=dat&0xf0;
  374.                                                 }
  375.                                                
  376.                                         }
  377.                                 }
  378.                
  379.                
  380.       
  381.                 switch(num)
  382.                 {
  383.                 case 1:        write_12864_addr(3,7);
  384.                                 anjian=0;
  385.                                 anjian_dis();
  386.                                 break;
  387.                 case 2:        write_12864_addr(3,7);
  388.                                 anjian=10;
  389.                                 anjian_dis();
  390.                                 break;
  391.                 case 3:write_12864_addr(3,7);
  392.                                 anjian=20;
  393.                                 anjian_dis();
  394.                                 break;
  395.                 case 4:write_12864_addr(3,7);
  396.                                 anjian=30;
  397.                                 anjian_dis();
  398.                                 break;
  399.                 case 5:write_12864_addr(3,7);
  400.                                 anjian=40;
  401.                                 anjian_dis();
  402.                                 break;
  403.                 case 6:write_12864_addr(3,7);
  404.                                 anjian=50;
  405.                                 anjian_dis();
  406.                                 break;
  407.                 case 7:write_12864_addr(3,7);
  408.                                 anjian=60;
  409.                                 anjian_dis();
  410.                                 break;
  411.                 case 8:write_12864_addr(3,7);
  412.                                 anjian=anjian+1;
  413.                                 anjian_dis();
  414.                                 break;
  415.                 case 9:        write_12864_addr(3,7);
  416.                                 anjian=anjian+2;
  417.                                 anjian_dis();
  418.                                 break;
  419.                 case 10:        write_12864_addr(3,7);
  420.                                 anjian=anjian+3;
  421.                                 anjian_dis();                              
  422.                                 break;
  423.                 case 11:write_12864_addr(3,7);                       
  424.                                 anjian=anjian+4;
  425.                                 anjian_dis();
  426.                                 break;
  427.                 case 12:write_12864_addr(3,7);                       
  428.                                 anjian=anjian+5;
  429.                                 anjian_dis();
  430.                                 break;
  431.                 case 13:write_12864_addr(3,7);                       
  432.                                 anjian=anjian+6;
  433.                                 anjian_dis();
  434.                                 break;
  435.                 case 14:write_12864_addr(3,7);                       
  436.                                 anjian=anjian+7;
  437.                                 anjian_dis();

  439.                                 break;
  440.                 case 15:write_12864_addr(3,7);
  441.                                 anjian=anjian+8;
  442.                                 anjian_dis();
  443.                                 break;
  444.                 case 16:write_12864_addr(3,7);
  445.                                 anjian=anjian+9;
  446.                                 anjian_dis();
  447.                                 break;


  450.         }
  451.       

  453. }


  456. void timer1() interrupt 3
  457. {
  458.       

  460.         TH1=(65535-1000)/256;
  461.         TL1=(65535-1000)%256;
  462.         count++;
  463.         if(count=100)
  464.         {
  465.         count=0;
  466.         }
  467.         if(count<=pwm)
  468.         {
  469.                 ENA=1;
  470.                 A1=0;
  471.                 A2=1;
  472.         }
  473.         else
  474.         {
  475.                 ENA=0;
  476.                 A1=0;
  477.                 A2=1;
  478.         }

  480.                 TR1=1;


  483. }
復(fù)制代碼




分享到:  QQ好友和群QQ好友和群 QQ空間QQ空間 騰訊微博騰訊微博 騰訊朋友騰訊朋友
收藏收藏 分享淘帖 頂頂 踩踩
回復(fù)

使用道具 舉報

沙發(fā)
ID:250933 發(fā)表于 2017-11-19 00:19 | 只看該作者
頂 求解救
回復(fù)

使用道具 舉報

板凳
ID:213173 發(fā)表于 2017-11-19 06:44 | 只看該作者
你寫的這程序中既沒有主程序main(),也沒有初始化定時器，怎么能夠跑得起來？

評分

參與人數(shù) 1黑幣 +20 收起 理由
admin + 20 回帖助人的獎勵！

查看全部評分

回復(fù)

使用道具 舉報

地板
ID:250933 發(fā)表于 2017-11-19 10:35 | 只看該作者
wulin 發(fā)表于 2017-11-19 06:44
你寫的這程序中既沒有主程序main(),也沒有初始化定時器，怎么能夠跑得起來？

這是子程序之一，這個子程序的pwm信號讀不出來，你幫我看看，是不是switc好  case 函數(shù)有問題  謝謝啦
回復(fù)

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規(guī)則

手機(jī)版|小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術(shù)交流QQ群281945664

Powered by 單片機(jī)教程網(wǎng)

快速回復(fù) 返回頂部 返回列表
主站蜘蛛池模板： 女人牲交视频一级毛片 | 国产重口老太伦 | 欧美一级免费片 | 综合精品久久久 | 日本在线精品视频 | 天堂在线免费视频 | 欧美 日韩 综合 | 成人一区二区在线 | 亚洲免费视频在线观看 | 久久久综合网 | 久久综合影院 | 国产免费一区二区 | 欧美综合久久久 | 精精国产视频 | 老妇激情毛片免费 | 永久精品 | 欧美一级黑人aaaaaaa做受 | 日韩中文字幕免费在线观看 | 精品日韩在线 | 无毛av | 999视频在线播放 | 国产在线精品一区二区三区 | 免费国产成人av | 日韩在线视频网址 | 欧美日韩1区2区 | 亚洲精品一区二区在线观看 | 成人一区av偷拍 | 国产成人一区二区三区电影 | 欧美精品一区三区 | 一区二区三区av夏目彩春 | 中文字幕av网站 | av日日操| 亚洲 中文 欧美 | 中文一区| 欧美精品一区在线发布 | 亚洲入口 | 欧美一级淫片免费视频黄 | ririsao久久精品一区 | 男女啪啪网址 | 狠狠入ady亚洲精品经典电影 | 日韩av在线免费 |