標(biāo)題: HT66F3185單片機(jī)TM1621顯示控制程序 [打印本頁(yè)]
作者: haha13    時(shí)間: 2023-7-29 17:24
標(biāo)題: HT66F3185單片機(jī)TM1621顯示控制程序
1，1621顯示控制數(shù)字
2，通過HT66F3185,直接驅(qū)動(dòng)顯示屏。

  1. #include "Smg.h"

  3. //--------聲音------光標(biāo)-----
  4. uchar Sound_Flag,Cursor_Flag,Manual_falg;

  6. /********************從高位寫入數(shù)據(jù)*************************/
  7. void Write_Data_H(uchar Data, uchar Cnt)           //Data的高cnt位寫入TM1621，高位在前
  8. {
  9.         uchar i;
  10.         for(i=0;i<Cnt;i++)
  11.         {
  12.                 WRITE=0;
  13.                 if(Data&0x80) DATA=1;               
  14.                 else DATA=0;
  15.                 WRITE=1;
  16.                 Data<<=1;
  17.         }
  18.         WRITE=1;
  19.         DATA=1;
  20. }
  21. /********************從低位寫入數(shù)據(jù)*************************/
  22. void Write_Data_L(uchar Data,uchar Cnt)        //Data 的低cnt位寫入TM1621，低位在前
  23. {
  24.         unsigned char i;
  25.         for(i=0;i<Cnt;i++)
  26.         {
  27.                    WRITE=0;
  28.                   if(Data&0x01) DATA=1;  
  29.                    else DATA=0;
  30.                 WRITE=1;
  31.                 Data>>=1;
  32.         }
  33.         WRITE=1;
  34.         DATA=1;
  35. }

  37. /********************寫入控制命令*************************/
  38. void WriteCmd(uchar Cmd)
  39. {
  40.         CS=0;
  41.         Write_Data_H(0x80,4);     //寫入命令標(biāo)志100
  42.         Write_Data_H(Cmd,8);      //寫入命令數(shù)據(jù)
  43.         CS=1;
  44. }

  46. void WriteOneData(uchar Addr, uchar Data)
  47. {
  48.         CS=0;
  49.         Write_Data_H(0xa0,3);     
  50.         Write_Data_H(Addr<<2,6);
  51.         Write_Data_L(Data,4);     
  52.         CS=1;
  53. }


  56. /*******************TM1621初始化**********************/
  57. void Init_Tm1621()
  58. {
  59.         //uchar i;
  60.         
  61.         CS_T = 0;        
  62.         WRITE_T         = 0;        
  63.         DATA_T = 0;        
  64.         
  65.         CS=1;
  66.         WRITE=1;
  67.         DATA=1;        
  68.         
  69.         WriteCmd(BIAS);                 //1/3偏壓 4公共口
  70.         WriteCmd(RC);                         //內(nèi)部RC振蕩
  71.         WriteCmd(SYSDIS);                 //關(guān)系統(tǒng)振蕩器和LCD偏壓發(fā)生器
  72.         WriteCmd(WDTDIS);                 //禁止看門狗
  73.         WriteCmd(SYSEN);                 //打開系統(tǒng)振蕩器
  74.         WriteCmd(LCDON);                 //開LCD偏壓
  75.         
  76.         Sound_Flag=1;
  77.         Manual_falg=0;
  78. }


  81. const uchar Smg_Buf[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0,0x40,0x38};

  83. //----------------------------0----1----2----3----4----5----6----7----8----9---滅-
  84. const uchar Smg_Buf_Front[]={0x0f,0x06,0x0b,0x0f,0x06,0x0d,0x0d,0x07,0x0f,0x0f,0,0x40,0x38};
  85. const uchar Smg_Buf_After[]={0x0a,0x00,0x0c,0x04,0x06,0x06,0x0e,0x00,0x0e,0x06,0,0x40,0x38};

  87. //-----------------------------0----1----2----3----4----5----6----7----8----9---滅-
  88. const uchar Smg_Buf_Front1[]={0x0a,0x00,0x06,0x04,0x0c,0x0c,0x0f,0x00,0x0f,0x0c,0,0x04,0x38};
  89. const uchar Smg_Buf_After1[]={0x0f,0x06,0x0d,0x0f,0x06,0x0b,0x0b,0x0e,0x0f,0x0f,0,0x00,0x38};


  92. void Disp_Data(uint TEMP,uint TEMP_S,uint TEMP_T,uchar L_M_S_B,uchar MODE)
  93. {
  94.         uchar i;
  95.         if(MODE==0)
  96.         {               
  97.                 for(i=0;i<32;i++)
  98.                 {
  99.                         WriteOneData(i,0);
  100.                 }
  101.                
  102.         }
  103.         else if(MODE==1)
  104.         {
  105.                 for(i=0;i<32;i++)
  106.                 {
  107.                         WriteOneData(i,0xff);
  108.                 }
  109.         }
  110.         else if(MODE == 2)
  111.         {
  112.         
  113.                 Show_Top(L_M_S_B);
  114.                 Show_num(TEMP);
  115.                 Show_num2(TEMP_S);
  116.                 Show_num3(TEMP_T);
  117.                
  118.                 Cursor_Flag=1;
  119.         }else if(MODE == 3)
  120.         {
  121.                 Show_Top(L_M_S_B);
  122.                 //Sound_Flag=1;
  123.                 Cursor_Flag=1;
  124.                
  125.                 Show_num(TEMP);
  126.                 Show_num2(TEMP_S);
  127.                 Show_num3(TEMP_T);
  128.                
  129.         }else
  130.         {
  131.                 Show_Top(L_M_S_B);
  132.                 //Sound_Flag=1;
  133.                 Cursor_Flag=1;
  134.                
  135.                 Show_num(TEMP);
  136.                 Show_num2(TEMP_S);
  137.                 Show_num3(TEMP_T);
  138.         }
  139. }

  141. void Show_num(uint TEMP)
  142. {
  143.         uchar ge,sh,ba,tem;
  144.         
  145.         if(TEMP == 10001)
  146.         {
  147.                 WriteOneData(7,Smg_Buf_Front[0]);
  148.                
  149.                 if(Sound_Flag == 1)
  150.                 {
  151.                         tem=Smg_Buf_After[0];
  152.                         tem |= 0x01;
  153.                         WriteOneData(8,tem);        
  154.                 }else
  155.                 {
  156.                         WriteOneData(8,Smg_Buf_After[0]);         
  157.                 }
  158.                 //WriteOneData(8,Smg_Buf_After[0]);
  159.                
  160.                 WriteOneData(9,Smg_Buf_Front[0]);
  161.                 WriteOneData(10,Smg_Buf_After[0]);
  162.                
  163.                 WriteOneData(11,Smg_Buf_Front[0]);
  164.                 WriteOneData(12,Smg_Buf_After[0]+0x01);
  165.                
  166.                 WriteOneData(13,Smg_Buf_Front[0]);
  167.                 WriteOneData(14,Smg_Buf_After[0]+0x01);
  168.                
  169.         }else
  170.         {
  171.                 ge = TEMP%10;        
  172.                 sh = TEMP%100/10;        
  173.                 ba = TEMP%1000/100;
  174.                
  175.                 //ge
  176.                 WriteOneData(7,Smg_Buf_Front[ge]);
  177.                
  178.                 if(Sound_Flag == 1)
  179.                 {
  180.                         tem=Smg_Buf_After[ge];
  181.                         tem |= 0x01;
  182.                         WriteOneData(8,tem);        
  183.                 }else
  184.                 {
  185.                         WriteOneData(8,Smg_Buf_After[ge]);         
  186.                 }
  187.                
  188.                
  189.                 //sh
  190.                 if(ba == 0)
  191.                 {
  192.                         if(sh == 0)
  193.                         {
  194.                                 WriteOneData(9,0x00);
  195.                                 WriteOneData(10,0x00);        
  196.                         }else
  197.                         {
  198.                                 WriteOneData(9,Smg_Buf_Front[sh]);
  199.                                 WriteOneData(10,Smg_Buf_After[sh]);
  200.                         }               
  201.                 }else
  202.                 {
  203.                         WriteOneData(9,Smg_Buf_Front[sh]);
  204.                         WriteOneData(10,Smg_Buf_After[sh]);
  205.                 }
  206.                
  207.                
  208.                 //ba
  209.                
  210.                 if(ba == 0)
  211.                 {
  212.                         WriteOneData(11,0x00);
  213.                         WriteOneData(12,0x00);
  214.                 }else
  215.                 {
  216.                         WriteOneData(11,Smg_Buf_Front[ba]);
  217.                         WriteOneData(12,Smg_Buf_After[ba]);         
  218.                 }
  219.                
  220.                 //去掉千位
  221.                 WriteOneData(13,0x00);
  222.                 WriteOneData(14,0x01);        
  223.                
  224.                 }
  225. }

  227. void Show_num2(uint TEMP)
  228. {
  229.         uchar ge,sh,ba;
  230.         
  231.         if(TEMP == 10000)
  232.         {
  233.                 WriteOneData(21,Smg_Buf_Front1[11]);
  234.                 WriteOneData(22,Smg_Buf_After1[11]);
  235.                
  236.                 WriteOneData(19,Smg_Buf_Front1[11]);
  237.                 WriteOneData(20,Smg_Buf_After1[11]);
  238.                
  239.                 WriteOneData(17,Smg_Buf_Front1[11]);
  240.                 WriteOneData(18,Smg_Buf_After1[11]);
  241.                
  242.                 WriteOneData(15,Smg_Buf_Front1[11]+0x01);
  243.                 WriteOneData(16,Smg_Buf_After1[11]);
  244.                
  245.         }else if(TEMP == 10001)
  246.         {
  247.                 WriteOneData(21,Smg_Buf_Front1[0]);
  248.                 WriteOneData(22,Smg_Buf_After1[0]);
  249.                
  250.                 WriteOneData(19,Smg_Buf_Front1[0]);
  251.                 WriteOneData(20,Smg_Buf_After1[0]);
  252.                
  253.                 WriteOneData(17,Smg_Buf_Front1[0]+0x01);
  254.                 WriteOneData(18,Smg_Buf_After1[0]);
  255.                
  256.                 WriteOneData(15,Smg_Buf_Front1[0]+0x01);
  257.                 WriteOneData(16,Smg_Buf_After1[0]);
  258.         
  259.         }else
  260.         {
  261.                 ge = TEMP%10;        
  262.                 sh = TEMP%100/10;        
  263.                 ba = TEMP%1000/100;
  264.                
  265.                 //ge
  266.                 WriteOneData(21,Smg_Buf_Front1[ge]);
  267.                 WriteOneData(22,Smg_Buf_After1[ge]);
  268.                
  269.                 //sh
  270.                 WriteOneData(19,Smg_Buf_Front1[sh]);
  271.                 WriteOneData(20,Smg_Buf_After1[sh]);
  272.                
  273.                 //ba
  274.                 WriteOneData(17,Smg_Buf_Front1[ba]);
  275.                 WriteOneData(18,Smg_Buf_After1[ba]);
  276.                
  277.                 //去掉千位
  278.                 WriteOneData(15,0x01);
  279.                 WriteOneData(16,0x00);        
  280.         }
  281. }

  283. void Show_num3(uint TEMP)
  284. {
  285.         uchar ge,sh,ba;
  286.         
  287.         if(TEMP == 10000)
  288.         {
  289.                 WriteOneData(23,Smg_Buf_Front[0]);
  290.                 WriteOneData(24,Smg_Buf_After[0]+0x01);
  291.                
  292.                 WriteOneData(25,Smg_Buf_Front[10]);
  293.                 WriteOneData(26,Smg_Buf_After[10]+0x01);
  294.                         
  295.                 WriteOneData(27,Smg_Buf_Front[10]);
  296.                 WriteOneData(28,Smg_Buf_After[10]);
  297.                
  298.                 WriteOneData(29,Smg_Buf_Front[10]);
  299.                 WriteOneData(30,Smg_Buf_After[10]+0x01);
  300.                
  301.         }else if(TEMP == 10001)
  302.         {
  303.                 WriteOneData(23,Smg_Buf_Front[0]);
  304.                 WriteOneData(24,Smg_Buf_After[0]+0x01);
  305.                
  306.                 WriteOneData(25,Smg_Buf_Front[0]);
  307.                 WriteOneData(26,Smg_Buf_After[0]+0x01);
  308.                         
  309.                 WriteOneData(27,Smg_Buf_Front[0]);
  310.                 WriteOneData(28,Smg_Buf_After[0]+0x01);
  311.                
  312.                 WriteOneData(29,Smg_Buf_Front[0]);
  313.                 WriteOneData(30,Smg_Buf_After[0]+0x01);        
  314.         }else
  315.         {
  316.                 ge = TEMP%10;        
  317.                 sh = TEMP%100/10;        
  318.                 ba = TEMP%1000/100;
  319.                
  320.                 WriteOneData(23,Smg_Buf_Front1[ge]);
  321.                 WriteOneData(24,Smg_Buf_After1[ge]);
  322.                
  323.                 WriteOneData(25,Smg_Buf_Front1[sh]);
  324.                 WriteOneData(26,Smg_Buf_After1[sh]);
  325.                         
  326.                 WriteOneData(27,Smg_Buf_Front1[ba]);
  327.                 WriteOneData(28,Smg_Buf_After1[ba]);
  328.         }
  329.                
  330. }

  332. void Show_Top(uchar L_M_S_B)
  333. {
  334.         if(Manual_falg ==1)
  335.         {
  336.                 WriteOneData(6,0x01);               
  337.         }else
  338.         {
  339.                 WriteOneData(6,L_M_S_B);
  340.         }
  341.         
  342.         
  343.         if(Cursor_Flag == 1)
  344.         {
  345.                 WriteOneData(31,0x01);        
  346.         }else if(Cursor_Flag == 2)
  347.         {
  348.                 WriteOneData(31,0x02);
  349.         }else if(Cursor_Flag == 3)
  350.         {
  351.                 WriteOneData(31,0x04);
  352.         }else
  353.         {
  354.                 WriteOneData(31,0x08);
  355.         }                        
  356. }
復(fù)制代碼
原理圖:無
仿真:無
Smg.c和Smg.h 2個(gè)文件下載: smg.zip (4.05 KB, 下載次數(shù): 14)




歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1