首页 > 代码库 > 基于mini2440简易计算器

基于mini2440简易计算器

2024-10-22 10:08:38   212人阅读

基于mini2440简易计算器使用的是数组实现,并非逆波兰式,因此功能不够强大,仅供驱动学习,以及C语言基础编程学习之用.有时间读者可以用逆波兰式来实现强大功能计算器,原理也很简单,建议读《c程序设计第二版》里面有算法的代码.读者自行研究.此程序基于电子相册的改进,触摸屏,LCD,字符现实,数字输入等等

    mini2440  索尼X35   LCD液晶屏 

 

 主函数部分:

  1. #include "def.h"  
  2. #include "option.h"  
  3. #include "2440addr.h"  
  4. #include "profile.h"  
  5. #include "mmu.h"  
  6.   
  7.   
  8. extern U32 X,Y;  
  9.   
  10. extern void BMP_display(int x0,int y0,int x1,int y1,const U8 *bmp);  
  11.   
  12. extern void CLK_init(void);  
  13. extern void LCD_IO_init(void);  
  14. extern void LCD_POWER(void);  
  15. extern void LCD_init(void);  
  16. extern void LCD_on(void);  
  17. extern void LCD_off(void);  
  18. extern void Tc_calibrate(void);  
  19. extern void input(void);  
  20. extern void Touch_Init(void);  
  21. extern void word(int x,int y,char* string);  
  22.   
  23. extern unsigned char gImage[];  //extern引用外部数组，计算器界面  
  24.   
  25. void Main(void)  
  26. {  
  27.   
  28.     rGPBCON=(1<<0);  
  29.     rGPBDAT=(0<<0);//关闭蜂鸣器  
  30.   
  31.     CLK_init();  
  32.     LCD_POWER();  
  33.     LCD_IO_init();  
  34.     LCD_init();  
  35.     LCD_on();  
  36.     Touch_Init();  
  37.     MMU_Init(); //初始化MMU，解决中断向量表入口与内存地址不一致问题，地址重映射  
  38.       
  39.     BMP_display(0, 0, 240,320, gImage); //显示计算器界面  240×320屏  
  40.       
  41.     while(1)  
  42.     {   
  43.         Tc_calibrate();  
  44.         input();  
  45.     }  
  46.       
  47. } 

 计算器的输入及其计算部分,结合触摸屏,利用数组实现字符和数字的存储等:

 pasting

  1. #include "def.h"  
  2. #include "2440addr.h"  
  3.   
  4. #define touch_p  (X>0&&X<42&&Y>0&&Y<80)         //定义触摸屏按键区域  
  5. #define touch_0  (X>0&&X<42&&Y>80&&Y<160)  
  6. #define touch_e  (X>0&&X<42&&Y>160&&Y<240)  
  7. #define touch_a  (X>0&&X<42&&Y>240&&Y<320)  
  8.   
  9. #define touch_1  (X>42&&X<84&&Y>0&&Y<80)  
  10. #define touch_2  (X>42&&X<84&&Y>80&&Y<160)  
  11. #define touch_3  (X>42&&X<84&&Y>160&&Y<240)  
  12. #define touch_s  (X>42&&X<84&&Y>240&&Y<320)  
  13.   
  14. #define touch_4  (X>84&&X<126&&Y>0&&Y<80)  
  15. #define touch_5  (X>84&&X<126&&Y>80&&Y<160)  
  16. #define touch_6  (X>84&&X<126&&Y>160&&Y<240)  
  17. #define touch_m  (X>84&&X<126&&Y>240&&Y<320)  
  18.   
  19. #define touch_7  (X>126&&X<168&&Y>0&&Y<80)  
  20. #define touch_8  (X>126&&X<168&&Y>80&&Y<160)  
  21. #define touch_9  (X>126&&X<168&&Y>160&&Y<240)  
  22. #define touch_d  (X>126&&X<168&&Y>240&&Y<320)  
  23.   
  24. #define touch_c  (X>168&&X<196&&Y>240&&Y<320)  
  25.   
  26. #define white 0xffffff  
  27. #define B_off rGPBDAT=(0<<0) //?????  
  28. #define B_on  rGPBDAT=(1<<0) //?????  
  29.   
  30. extern U32 X,Y;  
  31. extern unsigned char gImage[];  //extern????????  
  32.   
  33. extern Draw_REC(int x,int y,int x1,int y1,U32 color);  
  34. extern void BMP_display(int x0,int y0,int x1,int y1,const U8 *bmp);  
  35. extern void Draw_ASCII(U32 x,U32 y,U32 color,const unsigned char ch[]);  
  36. extern void word(int x,int y,char* string);  
  37. extern void Main(void);  
  38.   
  39. char op,opf;//用于何种元算的分拣操作符  
  40. int Num1,Num2;//参与运算两个数  
  41. int F1,F2;//答案  
  42. char num[10000];//用于显示的字符数组  
  43. int num1[100],num2[100];//保存输入数字的数组  
  44. int n[100],t[100]; //提取答案的各个位  
  45. int n1=0,n2=0;//用于输入数字分拣操作符   
  46. int len=0,len1=0;//用于计算答案的位数  
  47. int i=0,j=0,k=0,a=0;  
  48.   
  49. /**********************************  
  50. *清除各个标志函数 
  51. **********************************/  
  52. void Clear_f(void)  
  53. {  
  54.     int b=0,c=0;  
  55.       
  56.     for(c=0;c<10000;c++)  
  57.     {  
  58.         num[c]=‘ ‘;  
  59.     }  
  60.     for(b=0;b<100;b++)  
  61.     {  
  62.         num1[b]=0;  
  63.         num2[b]=0;  
  64.         n[b]=0;  
  65.         t[b]=0;  
  66.     }  
  67.     op=0;opf=0;  
  68.     Num1=0;Num2=0;  
  69.     F1=0;F2=0;  
  70.     n1=0;n2=0;  
  71.     len=0;len1=0;  
  72.     i=0;j=0;k=0;a=0;  
  73. }  
  74. /**********************************  
  75. *四则运算函数 
  76. **********************************/  
  77. void Calc(int *Num_1,int *Num_2,int *f)  
  78. {  
  79.     switch(op)  //分拣操作符  
  80.     {  
  81.     case‘n‘:    //无运算或等号  
  82.         *f = *f;  
  83.         break;  
  84.     case ‘+‘:   //加  
  85.         *f = *Num_1+*Num_2;  
  86.         break;  
  87.     case ‘-‘:   //减  
  88.         *f = *Num_1-*Num_2;  
  89.         break;  
  90.     case ‘*‘:    //乘  
  91.         *f =*Num_1*(*Num_2);  
  92.         break;  
  93.     case ‘/‘:    //除  
  94.         *f = *Num_1/(*Num_2);  
  95.         break;  
  96.     }     
  97. }  
  98.   
  99. /**********************************  
  100. *延迟函数 
  101. **********************************/  
  102. void delay(int times)  
  103. {  
  104.     int i;  
  105.     for(;times>0;times--)  
  106.     for(i=0;i<400;i++);  
  107. }  
  108.   
  109. /**********************************  
  110. *界面输入函数 
  111. **********************************/  
  112. void input(void)  
  113. {  
  114.     int flag=0;  
  115.       
  116.     int numb[10]={0,1,2,3,4,5,6,7,8,9};  
  117.     char nums[10]={‘0‘,‘1‘,‘2‘,‘3‘,‘4‘,‘5‘,‘6‘,‘7‘,‘8‘,‘9‘};      
  118.       
  119.     if(op==‘+‘||op==‘-‘||op==‘*‘||op==‘/‘) flag=1;  
  120.     else flag=0;  
  121.     if(flag==0)//无运算符  
  122.     {  
  123.         if(touch_0)   
  124.         {  
  125.             num[i]=‘0‘;  //用于屏幕显示图像 0  
  126.             num1[i]=0;   //用于计算  
  127.             i++;  
  128.             n1++;  
  129.             Draw_REC(0,80,42,160,white);   
  130.             B_on;         //按下‘0‘键，蜂鸣器响一声  
  131.             delay(1000);  
  132.             B_off;  
  133.             BMP_display(0,0,240,320,gImage);  
  134.         }  
  135.         else if(touch_1)  
  136.         {  
  137.             num[i]=‘1‘;  
  138.             num1[i]=1;  
  139.             i++;  
  140.             n1++;  
  141.             Uart_Printf("n1=%4d\n",n1);  
  142.             Draw_REC(42,0,84,80,white);  
  143.             B_on;  
  144.             delay(1000);  
  145.             B_off;  
  146.             BMP_display(0,0,240,320,gImage);  
  147.         }  
  148.         else if(touch_2)   
  149.         {  
  150.             num[i]=‘2‘;  
  151.             num1[i]=2;  
  152.             i++;  
  153.             n1++;  
  154.             Draw_REC(42,80,84,160,white);  
  155.             B_on;  
  156.             delay(1000);  
  157.             B_off;  
  158.             BMP_display(0,0,240,320,gImage);  
  159.         }  
  160.         else if(touch_3)   
  161.         {  
  162.             num[i]=‘3‘;  
  163.             num1[i]=3;  
  164.             i++;  
  165.             n1++;  
  166.             Draw_REC(42,160,84,240,white);  
  167.             B_on;  
  168.             delay(1000);  
  169.             B_off;  
  170.             BMP_display(0,0,240,320,gImage);  
  171.         }  
  172.         else if(touch_4)  
  173.         {  
  174.             num[i]=‘4‘;  
  175.             num1[i]=4;  
  176.             i++;  
  177.             n1++;  
  178.             Draw_REC(84,0,126,80,white);  
  179.             B_on;  
  180.             delay(1000);  
  181.             B_off;  
  182.             BMP_display(0,0,240,320,gImage);  
  183.         }  
  184.         else if(touch_5)  
  185.         {  
  186.             num[i]=‘5‘;  
  187.             num1[i]=5;  
  188.             i++;  
  189.             n1++;  
  190.             Draw_REC(84,80,126,160,white);  
  191.             B_on;  
  192.             delay(1000);  
  193.             B_off;  
  194.             BMP_display(0,0,240,320,gImage);  
  195.         }  
  196.         else if(touch_6)   
  197.         {  
  198.             num[i]=‘6‘;  
  199.             num1[i]=6;  
  200.             i++;  
  201.             n1++;  
  202.             Draw_REC(84,160,126,240,white);  
  203.             B_on;  
  204.             delay(1000);  
  205.             B_off;  
  206.             BMP_display(0,0,240,320,gImage);  
  207.         }  
  208.         else if(touch_7)  
  209.         {  
  210.             num[i]=‘7‘;  
  211.             num1[i]=7;  
  212.             i++;  
  213.             n1++;  
  214.             Draw_REC(126,0,168,80,white);  
  215.             B_on;  
  216.             delay(1000);  
  217.             B_off;  
  218.             BMP_display(0,0,240,320,gImage);  
  219.         }  
  220.         else if(touch_8)   
  221.         {  
  222.             num[i]=‘8‘;  
  223.             num1[i]=8;  
  224.             i++;  
  225.             n1++;  
  226.             Draw_REC(126,80,168,160,white);  
  227.             B_on;  
  228.             delay(1000);  
  229.             B_off;  
  230.             BMP_display(0,0,240,320,gImage);  
  231.         }  
  232.         else if(touch_9)  
  233.         {  
  234.             num[i]=‘9‘;  
  235.             num1[i]=9;  
  236.             i++;  
  237.             n1++;  
  238.             Draw_REC(126,160,168,240,white);  
  239.             B_on;  
  240.             delay(1000);  
  241.             B_off;  
  242.             BMP_display(0,0,240,320,gImage);  
  243.         }  
  244.           
  245.     }  
  246.     else   //加减乘除，以及第二个运算数字  
  247.     {  
  248.         if(touch_0)   
  249.         {  
  250.             num[i]=‘0‘;  
  251.             num2[j]=0;  
  252.             i++;  
  253.             j++;  
  254.             n2++;  
  255.             Draw_REC(0,80,42,160,white);  
  256.             B_on;  
  257.             delay(1000);  
  258.             B_off;  
  259.             BMP_display(0,0,240,320,gImage);  
  260.         }  
  261.         else if(touch_1)  
  262.         {  
  263.             num[i]=‘1‘;  
  264.             num2[j]=1;  
  265.             i++;  
  266.             j++;  
  267.             n2++;  
  268.             Draw_REC(42,0,84,80,white);  
  269.             B_on;  
  270.             delay(1000);  
  271.             B_off;  
  272.             BMP_display(0,0,240,320,gImage);  
  273.         }  
  274.         else if(touch_2)   
  275.         {  
  276.             num[i]=‘2‘;  
  277.             num2[j]=2;  
  278.             i++;  
  279.             j++;  
  280.             n2++;  
  281.             Draw_REC(42,80,84,160,white);  
  282.             B_on;  
  283.             delay(1000);  
  284.             B_off;  
  285.             BMP_display(0,0,240,320,gImage);  
  286.         }  
  287.         else if(touch_3)   
  288.         {  
  289.             num[i]=‘3‘;  
  290.             num2[j]=3;  
  291.             i++;  
  292.             j++;  
  293.             n2++;  
  294.             Draw_REC(42,160,84,240,white);  
  295.             B_on;  
  296.             delay(1000);  
  297.             B_off;  
  298.             BMP_display(0,0,240,320,gImage);  
  299.         }  
  300.         else if(touch_4)  
  301.         {  
  302.             num[i]=‘4‘;  
  303.             num2[j]=4;  
  304.             i++;  
  305.             j++;  
  306.             n2++;  
  307.             Draw_REC(84,0,126,80,white);  
  308.             B_on;  
  309.             delay(1000);  
  310.             B_off;  
  311.             BMP_display(0,0,240,320,gImage);  
  312.         }  
  313.         else if(touch_5)  
  314.         {  
  315.             num[i]=‘5‘;  
  316.             num2[j]=5;  
  317.             i++;  
  318.             j++;  
  319.             n2++;  
  320.             Draw_REC(84,80,126,160,white);  
  321.             B_on;  
  322.             delay(1000);  
  323.             B_off;  
  324.             BMP_display(0,0,240,320,gImage);  
  325.         }  
  326.         else if(touch_6)   
  327.         {  
  328.             num[i]=‘6‘;  
  329.             num2[j]=6;  
  330.             i++;  
  331.             j++;  
  332.             n2++;  
  333.             Draw_REC(84,160,126,240,white);  
  334.             B_on;  
  335.             delay(1000);  
  336.             B_off;  
  337.             BMP_display(0,0,240,320,gImage);  
  338.         }  
  339.         else if(touch_7)  
  340.         {  
  341.             num[i]=‘7‘;  
  342.             num2[j]=7;  
  343.             i++;  
  344.             j++;  
  345.             n2++;  
  346.             Draw_REC(126,0,168,80,white);  
  347.             B_on;  
  348.             delay(1000);  
  349.             B_off;  
  350.             BMP_display(0,0,240,320,gImage);  
  351.         }  
  352.         else if(touch_8)   
  353.         {  
  354.             num[i]=‘8‘;  
  355.             num2[j]=8;  
  356.             i++;  
  357.             j++;  
  358.             n2++;  
  359.             Draw_REC(126,80,168,160,white);  
  360.             B_on;  
  361.             delay(1000);  
  362.             B_off;  
  363.             BMP_display(126,80,168,160,gImage);  
  364.         }  
  365.         else if(touch_9)  
  366.         {  
  367.             num[i]=‘9‘;  
  368.             num2[j]=9;  
  369.             i++;  
  370.             j++;  
  371.             n2++;  
  372.             Draw_REC(126,160,168,240,white);  
  373.             B_on;  
  374.             delay(1000);  
  375.             B_off;  
  376.             BMP_display(0,0,240,320,gImage);  
  377.         }  
  378.     }  
  379.       
  380.     if(touch_p)   
  381.     {  
  382.         op=‘.‘;  
  383.         num[i]=‘.‘;  
  384.         i++;  
  385.         Draw_REC(0,0,42,80,white);  
  386.         B_on;  
  387.         delay(1000);  
  388.         B_off;  
  389.         BMP_display(0,0,240,320,gImage);  
  390.     }  
  391.     else if(touch_e)  
  392.     {  
  393.         opf=‘=‘;  
  394.         //num[i]=‘=‘;  
  395.         //i++;  
  396.         Draw_REC(0,160,42,240,white);  
  397.         B_on;  
  398.         delay(1000);  
  399.         B_off;  
  400.         BMP_display(0,0,240,320,gImage);  
  401.     }  
  402.     else if(touch_a)  
  403.     {  
  404.         op=‘+‘;  
  405.         num[i]=‘+‘;  
  406.         i++;  
  407.         Draw_REC(0,240,42,320,white);  
  408.         B_on;  
  409.         delay(1000);  
  410.         B_off;  
  411.         BMP_display(0,0,240,320,gImage);;  
  412.     }  
  413.     else if(touch_s)  
  414.     {  
  415.         op=‘-‘;  
  416.         num[i]=‘-‘;  
  417.         i++;  
  418.         Draw_REC(42,240,84,320,white);  
  419.         B_on;  
  420.         delay(1000);  
  421.         B_off;  
  422.         BMP_display(0,0,240,320,gImage);  
  423.     }  
  424.     else if(touch_m)  
  425.     {  
  426.         op=‘*‘;  
  427.         num[i]=‘*‘;  
  428.         i++;  
  429.         Draw_REC(84,240,126,320,white);  
  430.         B_on;  
  431.         delay(1000);  
  432.         B_off;  
  433.         BMP_display(0,0,240,320,gImage);  
  434.     }  
  435.     else if(touch_d)  
  436.     {  
  437.         op=‘/‘;  
  438.         num[i]=‘/‘;  
  439.         i++;  
  440.         Draw_REC(126,240,168,320,white);  
  441.         B_on;  
  442.         delay(1000);  
  443.         B_off;  
  444.         BMP_display(0,0,240,320,gImage);  
  445.     }  
  446.     else if(touch_c)  
  447.     {  
  448.         Draw_REC(168,240,196,320,white);  
  449.         B_on;  
  450.         delay(1000);  
  451.         B_off;  
  452.         BMP_display(0,0,240,320,gImage);  
  453.         Clear_f();  
  454.     }  
  455.       
  456.     switch(n1)   //合成第一个运算数  
  457.     {  
  458.     case 1:Num1=num1[0];break;  
  459.     case 2:Num1=num1[0]*10+num1[1];break;  
  460.     case 3:Num1=num1[0]*100+num1[1]*10+num1[2];break;  
  461.     case 4:Num1=num1[0]*1000+num1[1]*100+num1[2]*10+num1[3];break;  
  462.     case 5:Num1=num1[0]*10000+num1[1]*1000+num1[2]*100+num1[3]*10+num1[4];break;  
  463.     case 6:Num1=num1[0]*100000+num1[1]*10000+num1[2]*1000+num1[3]*100+num1[4]*10+num1[5];break;  
  464.     }  
  465.       
  466.     switch(n2)    //合成第二个运算数  
  467.     {  
  468.     case 1:Num2=num2[0];break;  
  469.     case 2:Num2=num2[0]*10+num2[1];break;  
  470.     case 3:Num2=num2[0]*100+num2[1]*10+num2[2];break;  
  471.     case 4:Num2=num2[0]*1000+num2[1]*100+num2[2]*10+num2[3];break;  
  472.     case 5:Num2=num2[0]*10000+num2[1]*1000+num2[2]*100+num2[3]*10+num2[4];break;  
  473.     case 6:Num2=num2[0]*100000+num2[1]*10000+num2[2]*1000+num2[3]*100+num2[4]*10+num2[5];break;  
  474.     }  
  475.       
  476.     word(210,2,num); //在LCD屏幕上显示算式  
  477.     X=0;  
  478.     Y=0;  
  479.       
  480.     if(opf==‘=‘)     //如果按下等号  
  481.     {  
  482.         Calc(&Num1,&Num2,&F1); //进行运算  
  483.         num[i]=‘=‘;    //在屏幕显示等号  
  484.         F2=F1;  
  485.         while(F2>0)  
  486.         {   
  487.             t[a++]=F2%10; //把答案中个各位数字提取出来，放到数组中  
  488.             F2=F2/10;  
  489.             len++;  
  490.         }  
  491.         len1=len;  
  492.         a=0;  
  493.         while(len1--)  
  494.         {  
  495.             n[len1]=t[a++]; //答案中各位转移到数组n中  
  496.         }  
  497.           
  498.         switch(len)  
  499.         {  
  500.         case 1:            //答案是一位数  
  501.             {  
  502.                 for(k=0;k<10;k++)  
  503.                 {if(numb[k]==n[0]) num[i+1]=nums[k];};break;  
  504.             }  
  505.         case 2:            //答案是两位数  
  506.             {  
  507.                 for(k=0;k<10;k++)  
  508.                 {if(numb[k]==n[0]) num[i+1]=nums[k];}  
  509.                 for(k=0;k<10;k++)  
  510.                 {if(numb[k]==n[1]) num[i+2]=nums[k];};break;  
  511.             }  
  512.         case 3:            //答案是三位数  
  513.             {  
  514.                 for(k=0;k<10;k++)  
  515.                 {if(numb[k]==n[0]) num[i+1]=nums[k];}  
  516.                 for(k=0;k<10;k++)  
  517.                 {if(numb[k]==n[1]) num[i+2]=nums[k];}  
  518.                 for(k=0;k<10;k++)  
  519.                 {if(numb[k]==n[2]) num[i+3]=nums[k];};break;  
  520.             }  
  521.         case 4:  
  522.             {  
  523.                 for(k=0;k<10;k++)  
  524.                 {if(numb[k]==n[0]) num[i+1]=nums[k];}  
  525.                 for(k=0;k<10;k++)  
  526.                 {if(numb[k]==n[1]) num[i+2]=nums[k];}  
  527.                 for(k=0;k<10;k++)  
  528.                 {if(numb[k]==n[2]) num[i+3]=nums[k];}  
  529.                 for(k=0;k<10;k++)  
  530.                 {if(numb[k]==n[3]) num[i+4]=nums[k];};break;  
  531.             }  
  532.         case 5:  
  533.             {  
  534.                 for(k=0;k<10;k++)  
  535.                 {if(numb[k]==n[0]) num[i+1]=nums[k];}  
  536.                 for(k=0;k<10;k++)  
  537.                 {if(numb[k]==n[1]) num[i+2]=nums[k];}  
  538.                 for(k=0;k<10;k++)  
  539.                 {if(numb[k]==n[2]) num[i+3]=nums[k];}  
  540.                 for(k=0;k<10;k++)  
  541.                 {if(numb[k]==n[3]) num[i+4]=nums[k];}  
  542.                 for(k=0;k<10;k++)  
  543.                 {if(numb[k]==n[4]) num[i+5]=nums[k];};break;  
  544.             }  
  545.         }  
  546.         word(210,2,num); //在屏幕上显示运算后的算式与答案  
  547.         Uart_Printf("Num1=%4d, Num2=%4d,F1=%4d\n",Num1,Num2,F1);  
  548.         op=0;  
  549.         opf=0;  
  550.     }  
  551. }  

 LCD驱动部分:

  1. #define  GLOBAL_CLK 1  
  2. #include "def.h"  
  3. #include "option.h"  
  4. #include "2440addr.h"  
  5. #include "profile.h"  
  6.   
  7. #define LCD_WIDTH 240   //屏幕宽度    
  8. #define LCD_HEIGHT 320  //屏幕高度  
  9. #define CLKVAL 8        //时钟信号  索尼X35  LCD屏  
  10.   
  11. //垂直同步信号的脉宽、后肩和前肩  
  12. #define VSPW (9-1)  
  13. #define VBPD (2-1)  
  14. #define VFPD (5-1)  
  15.   
  16. //水平同步信号的脉宽、后肩和前肩  
  17. #define HSPW (5-1)  
  18. #define HBPD (26-1)  
  19. #define HFPD (1-1)  
  20.   
  21. //显示尺寸  
  22. #define HOZVAL (LCD_WIDTH-1)  
  23. #define LINEVAL (LCD_HEIGHT-1)  
  24.   
  25. //定义显示缓存，volatile声明编译不对此进行优化，直接读取原始地址   
  26. volatile unsigned short LCD_BUFFER[LCD_HEIGHT][LCD_WIDTH];    
  27.   
  28. //声明为静态函数，仅在本文件可见，其他文件不能使用该函数  
  29.   
  30. /**********************************  
  31. *时钟初始化 
  32. **********************************/  
  33. void CLK_init(void)  
  34. {     
  35.     rMPLLCON &= ~0xFFFFF;  
  36.     rMPLLCON |= (92<<12)|(1<<4)|1;  //初始化FCLK为400M  
  37.     rCLKDIVN = (2<<1)|1;  //HCLK = FCLK/4 = 100M,     PCLK = HCLK/2 = 50M  
  38.       
  39.     FCLK = 400000000;     //400MHz  
  40.     HCLK = 100000000;     //100MHz  
  41.     PCLK = 50000000;      //50MHz  
  42.     UCLK = 48000000;      //48MHz  
  43.    
  44.     rGPHCON = 0xa0;  //TXD[0]端口输出   RXD[0]端口接收  
  45.     rGPHUP  = 0x7ff; //禁止上拉电阻  
  46.     Uart_Init(0,115200);  
  47.     Uart_Select(0);  
  48.  }  
  49.   
  50.   
  51. /**********************************  
  52. *LCD端口初始化 
  53. **********************************/  
  54. void LCD_IO_init(void)  
  55. {  
  56.     rGPCUP=0xff;    //GPC口上拉电阻不可用  
  57.     rGPCCON=0xaaaa02aa;//GPC8-15设置为VD, VM,VFRAME,VLINE,VCLK,LEND  
  58.   
  59.     rGPDUP=0xff;    //GPD口上拉电阻不可用  
  60.     rGPDCON=0xaaaaaaaa; //GPD0-15设置为VD  
  61. }  
  62.   
  63. /**********************************  
  64. *LCD电源管理 
  65. **********************************/  
  66. void LCD_POWER(void)  
  67. {  
  68.     rGPGUP=(1<<4);  
  69.     rGPGCON=(3<<8);       //GPG4设置为LCD_PWREN  
  70.     rLCDCON5=(1<<3);  //Enable PWREN signal  
  71. }  
  72.   
  73. /**********************************  
  74. *LCD开启 
  75. **********************************/  
  76. void LCD_on(void)  
  77. {  
  78.     rLCDCON1 |=1;   //利用LCDCON1控制相关参数实现开启LCD   
  79. }  
  80.   
  81. /**********************************  
  82. *LCD关闭 
  83. **********************************/  
  84. void LCD_off(void)  
  85. {  
  86.     rLCDCON1 &=~1;   //利用LCDCON1控制相关参数实现关闭LCD    
  87. }  
  88.   
  89. /**********************************  
  90. *LCD初始化 
  91. **********************************/  
  92. void LCD_init(void)  
  93. {  
  94.     CLK_init();  
  95.     LCD_POWER();  
  96.     LCD_IO_init();  
  97.     LCD_on();  
  98.       
  99.     rLCDCON1 = (CLKVAL<<8) | (3<<5) | (12<<1) | (0<<0);   
  100.     rLCDCON2 = (VBPD<<24) | (LINEVAL<<14) | (VFPD<<6) | (VSPW);   
  101.     rLCDCON3 = (HBPD<<19) | (HOZVAL<<8) | (HFPD);   
  102.     rLCDCON4 = HSPW;   
  103.     rLCDCON5 = (1<<11) | (1<<9) | (1<<8) | (1<<6) | (1<<3)|(0<<1)|(1);  
  104.       
  105.       
  106.     /*显存起始地址[30:22]保存到LCDSADDR1[29:21],显存始地址[21:1]位  
  107.     保存到LCDSADDR1[20:0],显存结束地址[21:1]保存到LCDSADDR2[20:0]*/  
  108.     rLCDSADDR1=(((U32)LCD_BUFFER>>22)<<21)|(((U32)LCD_BUFFER&0x3fffff)>>1);  
  109.     rLCDSADDR2=(((U32)LCD_BUFFER+LCD_WIDTH*LCD_HEIGHT*2)>>1)&0x1fffff;      
  110.     rLCDSADDR3=LCD_WIDTH; //设置虚拟屏设置为屏幕宽度,没有可以不设置   
  111.       
  112.     rTPAL=0; //临时调色板不可用  
  113.     rLCDINTMSK |=3; //屏蔽 LCD 中断    
  114.     rTCONSEL &=~(0x17);//LCC3600,LPC3600不可用  
  115. }

 GUI部分,字符,图片处理函数等

  1. #include "def.h"  
  2. #include "Font_libs.h"   
  3.   
  4. #define LCD_WIDTH 240   //屏幕宽度  
  5. #define LCD_HEIGHT 320  //屏幕高度  
  6.   
  7. //定义显示缓存，volatile声明编译不对此进行优化，直接读取原始地址   
  8. extern volatile unsigned short LCD_BUFFER[LCD_HEIGHT][LCD_WIDTH];  
  9.   
  10. /**********************************  
  11. *刷新背景颜色  
  12. **********************************/  
  13. void LCD_clear(U32 color)  
  14. {  
  15.     U32 x,y;  
  16.     for(y=0;y<LCD_HEIGHT;y++)  
  17.     {  
  18.         for(x=0;x<LCD_WIDTH;x++)  
  19.         {  
  20.             LCD_BUFFER[y][x]=color;  
  21.         }  
  22.     }  
  23. }  
  24.   
  25. /**********************************  
  26. *BMP数组图片显示 
  27. **********************************/  
  28. void BMP_display(int x0,int y0,int x1,int y1,const U8 *bmp)  
  29. {  
  30.     int x,y,p=0;  
  31.     U32 data;  
  32.     for(y=0;y<y1;y++)  
  33.     {  
  34.         for(x=0;x<x1;x++)  
  35.         {  
  36.             data=http://www.mamicode.com/(bmp[p]<<8|bmp[p+1]);
  37.             if((x0+x)<LCD_WIDTH && (y0+y)<LCD_HEIGHT)  
  38.                 LCD_BUFFER[y0+y][x0+x]=data;  
  39.             p=p+2;  
  40.         }  
  41.     }  
  42. }  
  43.   
  44. /**********************************  
  45. *绘制像素点 
  46. **********************************/  
  47. void PutPixel(U32 x,U32 y,U32 c )  
  48. {  
  49.     LCD_BUFFER[y][x]=c;  
  50. }  
  51.   
  52. /**********************************  
  53. *绘制大小为16×16的中文字符  
  54. **********************************/  
  55. void Draw_Text16(U32 x,U32 y,U32 color,const unsigned char ch[])  
  56. {  
  57.     unsigned short int i,j;  
  58.     unsigned char mask,buffer;  
  59.     for(i=0;i<16;i++)  
  60.     {  
  61.         mask = 0x80;                   //掩码  
  62.         buffer=ch[i*2];                //提取一行的第一个字节  
  63.         for(j=0;j<8;j++)  
  64.         {                    
  65.             if(buffer&mask)  
  66.             {  
  67.                 PutPixel(x+j,y+i,color);        //为笔画上色  
  68.             }  
  69.             mask=mask>>1;                   
  70.         }  
  71.           
  72.         mask=0x80;                  //掩码复位  
  73.         buffer=ch[i*2+1];         //提取一行的第二个字节  
  74.         for(j=0;j<8;j++)  
  75.         {                    
  76.             if(buffer&mask)  
  77.             {  
  78.                 PutPixel(x+j+8,y+i,color);           //为笔画上色   
  79.             }  
  80.             mask=mask>>1;                    
  81.         }  
  82.     }  
  83. }  
  84.   
  85. /**********************************  
  86. *绘制大小为8×16的ASCII码  
  87. **********************************/  
  88. void Draw_ASCII(U32 x,U32 y,U32 color,const unsigned char ch[])  
  89. {                                    //ch[]为16个元素中，第一个元素的地址  
  90.     unsigned short int i,j;            
  91.     unsigned char mask,buffer;  
  92.     for(i=0;i<16;i++)    //__ASCII中连续16个元素组成一个字符图像  
  93.     {  
  94.       mask=0x80;  
  95.         buffer=ch[i];    //16个元素其中的一个  
  96.         for(j=0;j<8;j++)   //每一个元素占8位  
  97.         {                    
  98.             if(buffer&mask)  
  99.             {  
  100.                 PutPixel(x-i,y+j,color);  
  101.             }  
  102.             mask=mask>>1;                    
  103.         }  
  104.     }  
  105. }  
  106.   
  107. /**********************************  
  108. *绘制中文字符或ASCII 
  109. **********************************/  
  110. void word(int x,int y,char* string)  
  111. {  
  112.     int i,j=0;  
  113.     unsigned char qh,wh;  
  114.     const unsigned char *mould;  
  115.     int length=0;  
  116.       
  117.     while(string[length]!=‘\0‘)  
  118.     {length++;}  
  119.       
  120.     for(i=0;i<=length-1;i++)  
  121.         {  
  122.             if(string[i]&0x80)        //中文字符   
  123.             {  
  124.                 qh=string[i]-0xa0;            //区号  
  125.                 wh=string[i+1]-0xa0;          //位号  
  126.                 mould=& __CHS[((qh-1)*94+wh-1)*32 ];  
  127.                 Draw_Text16(x+j,y,0xffffff,mould);  
  128.                 j+=16;//每写完一个右移16个像素   
  129.                 i++;  
  130.             }  
  131.             else  //ASCII码字符  
  132.             {  
  133.                 mould=&__ASCII[string[i]*16];  
  134.                 Draw_ASCII(x,y+j,0xffffff,mould);  
  135.                 j+=8;      //每写完一个右移8个像素   
  136.             }  
  137.         }  
  138. }  
  139.   
  140. /**********************************  
  141. *画直线  
  142. **********************************/  
  143. void Draw_Line(int x1,int y1,int x2,int y2,U32 color)  
  144. {  
  145.     int dx,dy,e;  
  146.     dx=x2-x1;   
  147.     dy=y2-y1;  
  148.       
  149.     if(dx>=0)  
  150.     {  
  151.         if(dy >= 0) // dy>=0  
  152.         {  
  153.             if(dx>=dy) // 1/8 octant  
  154.             {  
  155.                 e=dy-dx/2;  
  156.                 while(x1<=x2)  
  157.                 {  
  158.                     PutPixel(x1,y1,color);  
  159.                     if(e>0){y1+=1;e-=dx;}      
  160.                     x1+=1;  
  161.                     e+=dy;  
  162.                 }  
  163.             }  
  164.             else        // 2/8 octant  
  165.             {  
  166.                 e=dx-dy/2;  
  167.                 while(y1<=y2)  
  168.                 {  
  169.                     PutPixel(x1,y1,color);  
  170.                     if(e>0){x1+=1;e-=dy;}      
  171.                     y1+=1;  
  172.                     e+=dx;  
  173.                 }  
  174.             }  
  175.         }  
  176.         else           // dy<0  
  177.         {  
  178.             dy=-dy;   // dy=abs(dy)  
  179.   
  180.             if(dx>=dy) // 8/8 octant  
  181.             {  
  182.                 e=dy-dx/2;  
  183.                 while(x1<=x2)  
  184.                 {  
  185.                     PutPixel(x1,y1,color);  
  186.                     if(e>0){y1-=1;e-=dx;}      
  187.                     x1+=1;  
  188.                     e+=dy;  
  189.                 }  
  190.             }  
  191.             else        // 7/8 octant  
  192.             {  
  193.                 e=dx-dy/2;  
  194.                 while(y1>=y2)  
  195.                 {  
  196.                     PutPixel(x1,y1,color);  
  197.                     if(e>0){x1+=1;e-=dy;}      
  198.                     y1-=1;  
  199.                     e+=dx;  
  200.                 }  
  201.             }  
  202.         }     
  203.     }  
  204.     else //dx<0  
  205.     {  
  206.         dx=-dx;     //dx=abs(dx)  
  207.         if(dy >= 0) // dy>=0  
  208.         {  
  209.             if(dx>=dy) // 4/8 octant  
  210.             {  
  211.                 e=dy-dx/2;  
  212.                 while(x1>=x2)  
  213.                 {  
  214.                     PutPixel(x1,y1,color);  
  215.                     if(e>0){y1+=1;e-=dx;}      
  216.                     x1-=1;  
  217.                     e+=dy;  
  218.                 }  
  219.             }  
  220.             else        // 3/8 octant  
  221.             {  
  222.                 e=dx-dy/2;  
  223.                 while(y1<=y2)  
  224.                 {  
  225.                     PutPixel(x1,y1,color);  
  226.                     if(e>0){x1-=1;e-=dy;}      
  227.                     y1+=1;  
  228.                     e+=dx;  
  229.                 }  
  230.             }  
  231.         }  
  232.         else           // dy<0  
  233.         {  
  234.             dy=-dy;   // dy=abs(dy)  
  235.   
  236.             if(dx>=dy) // 5/8 octant  
  237.             {  
  238.                 e=dy-dx/2;  
  239.                 while(x1>=x2)  
  240.                 {  
  241.                     PutPixel(x1,y1,color);  
  242.                     if(e>0){y1-=1;e-=dx;}      
  243.                     x1-=1;  
  244.                     e+=dy;  
  245.                 }  
  246.             }  
  247.             else        // 6/8 octant  
  248.             {  
  249.                 e=dx-dy/2;  
  250.                 while(y1>=y2)  
  251.                 {  
  252.                     PutPixel(x1,y1,color);  
  253.                     if(e>0){x1-=1;e-=dy;}      
  254.                     y1-=1;  
  255.                     e+=dx;  
  256.                 }  
  257.             }  
  258.         }     
  259.     }  
  260. }  
  261.   
  262. /************************************************************** 
  263. 在LCD屏幕上画一个矩形 
  264. **************************************************************/  
  265. void Draw_REC(int x1,int y1,int x2,int y2,U32 color)  
  266. {  
  267.     Draw_Line(x1,y1,x2,y1,color);  
  268.     Draw_Line(x2,y1,x2,y2,color);  
  269.     Draw_Line(x1,y2,x2,y2,color);  
  270.     Draw_Line(x1,y1,x1,y2,color);  
  271. }  
  272.   
  273. /**********************************  
  274. *画圆函数  
  275. **********************************/  
  276. void Draw_Circular(U32 c)  
  277. {  
  278.     int x,y ;  
  279.     int tempX,tempY;  
  280.     int radius=80;  
  281.     int SquareOfR=radius*radius;  
  282.       
  283.     for( y=0;y<LCD_WIDTH;y++ )  
  284.     {  
  285.         for( x=0; x<LCD_HEIGHT;x++ )  
  286.         {  
  287.             if(y<=120&&x<=160)  
  288.             {  
  289.                 tempY=120-y;  
  290.                 tempX=160-x;                          
  291.             }  
  292.             else if(y<=120&&x>=160)  
  293.             {  
  294.                 tempY=120-y;  
  295.                 tempX=x-160;                          
  296.             }  
  297.             else if(y>=120&& x<=160)  
  298.             {  
  299.                 tempY=y-120;  
  300.                 tempX=160-x;  
  301.             }  
  302.             else  
  303.             {  
  304.                 tempY=y-120;  
  305.                 tempX=x-160;  
  306.             }  
  307.               
  308.             if ((tempY*tempY+tempX*tempX)<=SquareOfR)  
  309.                 LCD_BUFFER[y][x] =c;  
  310.         }  
  311.     }  
  312. }  
  313. void Draw_X(int x,int y,U32 color)  
  314.     {  
  315.         Draw_Line(x-20,y,x+20,y,color);  
  316.         Draw_Line(x,y-20,x,y+20,color);  
  317.     }  
  318.     

触摸屏的ADC驱动部分:

  1. #include "def.h"  
  2. #include "mmu.h"  
  3. #include "2440addr.h"  
  4. #include "2440lib.h"  
  5.   
  6. #define PRSCVL 9  
  7.   
  8. volatile int xdata, ydata;  
  9.   
  10. int inte=1;  
  11.   
  12. void __irq Adc_Tc_Handler(void);  
  13.   
  14. void Touch_Init(void)  
  15. {  
  16.     rADCCON=((1<<14)|(PRSCVL<<6));    //A/D分频时钟有效，其值为9  
  17.     rADCTSC=0xd3;  //光标按下中断信号,YM有效，YP无效，XM有效，XP无效，XP上拉电阻，普通ADC转换，等待中断模式  
  18.     rADCDLY=50000; //正常转换模式转换延时大约为(1/3.6864M)*50000=13.56ms  
  19.       
  20.     rINTSUBMSK &=~(1<<9);//TC中断使能  
  21.     rINTMSK &=~(1<<31);//ADC总中断使能  
  22.       
  23.     pISR_ADC=(int)Adc_Tc_Handler;//指向中断向量表  
  24.       
  25. }  
  26.   
  27. void __irq Adc_Tc_Handler(void)  
  28. {  
  29.   
  30.     rADCTSC|=(1<<3)|(1<<2); //XP上拉电阻无效, 自动连续测量X坐标和Y坐标.  
  31.     rADCCON|=(1<<0);//ADC转换开始  
  32.   
  33.     while(rADCCON&(1<<0));//检测ADC转换是否开始且ADCCON[0]自动清0  
  34.     while(!(rADCCON&(1<<15))); //检测ADCCON[15]是否为1,ADC转换是否结束,(必须)  
  35.     while(!(rINTPND&(1<<31)));//检测ADC中断是否已请求  
  36.       
  37.     xdata=http://www.mamicode.com/rADCDAT0&0x3ff;//读x坐标  
  38.     ydata=http://www.mamicode.com/rADCDAT1&0x3ff;//读y坐标  
  39.       
  40.     Uart_Printf("\nXdata=http://www.mamicode.com/%04d, Ydata=%04d/n", xdata, ydata);  
  41.   
  42.     rSUBSRCPND|=(1<<9);  
  43.     rSRCPND|=(1<<31);  
  44.     rINTPND|=(1<<31);  
  45.       
  46.     rADCTSC =0xd3;     //ADC等待中断模式    
  47.     rADCTSC|=(1<<8);  //ADCTSC[8]=1,设置抬起中断信号  
  48.       
  49.     while(!(rSUBSRCPND&(1<<9)));  //检测触屏抬起中断是否已请求   
  50.   
  51.     rADCTSC &=~(1<<8);//ADCTSC[8]=0光标按下中断信号  
  52.     rSUBSRCPND|=(1<<9);  
  53.     rSRCPND|=(1<<31);  
  54.     rINTPND|=(1<<31);  
  55.     inte=1;  
  56. }  

 触摸屏矫正及其计算部分(三点矫正):

  1. #include "def.h"  
  2. #include "2440addr.h"  
  3. #include "2440lib.h"  
  4.   
  5. #define LCD_CALIBRATE 0  //1时打开触摸屏校验  
  6. #define BLACK (0x000000)  //黑色  
  7. #define WHITE (0xffffff)  //白色  
  8. #define YdataClear ydata=http://www.mamicode.com/0  
  9. #define XdataClear xdata=http://www.mamicode.com/0  
  10.   
  11. extern volatile int xdata, ydata;  
  12. extern int inte;  
  13.   
  14. extern void LCD_clear(U32 n);  
  15. extern void Draw_X(int x,int y,U32 color);  
  16. extern void CLK_init(void);  
  17. extern void LCD_IO_init(void);  
  18. extern void LCD_POWER(void);  
  19. extern void LCD_init(void);  
  20. extern void LCD_on(void);  
  21. extern void LCD_off(void);  
  22. extern void Touch_Init(void);  
  23.   
  24. U32 X,Y;  
  25. float x0,y0,x1,y1,x2,y2;  
  26. float xt,yt;  
  27. float K = -281780, A = -0.293846, B = 0.000568, C = 271.255585, D = 0.007808, E = 0.400951, F = -54.646889;
  28.   
  29. //读取TC坐标  
  30. void Touch_GetAdXY(float *x,float *y)  
  31. {  
  32.     *x=xdata;  
  33.     *y=ydata;  
  34. }  
  35.   
  36. //矫正参数A,B,C,D,E,F,K的计算  
  37. void Calculate_P(float xt0,float yt0,float xt1,float yt1,float xt2,float yt2)  
  38. {  
  39.     float xd0=160,yd0=40,xd1=40,yd1=180,xd2=260,yd2=200;  
  40.     K=(xt0-xt2)*(yt1-yt2)-(xt1-xt2)*(yt0-yt2);  
  41.     A=((xd0-xd2)*(yt1-yt2)-(xd1-xd2)*(yt0-yt2))/K;  
  42.     B=((xt0-xt2)*(xd1-xd2)-(xd0-xd2)*(xt1-xt2))/K;  
  43.     C=(yt0*(xt2*xd1-xt1*xd2)+yt1*(xt0*xd2-xt2*xd0)+yt2*(xt1*xd0-xt0*xd1))/K;  
  44.     D=((yd0-yd2)*(yt1-yt2)-(yd1-yd2)*(yt0-yt2))/K;  
  45.     E=((xt0-xt2)*(yd1-yd2)-(yd0-yd2)*(xt1-xt2))/K;  
  46.     F=(yt0*(xt2*yd1-xt1*yd2)+yt1*(xt0*yd2-xt2*yd0)+yt2*(xt1*yd0-xt0*yd1))/K;  
  47. }  
  48.   
  49. //数据的矫正  
  50. void Tc_Correct(float xt,float yt)  
  51. {  
  52.     X=(U32)(A*xt+B*yt+C);  
  53.     Y=(U32)(D*xt+E*yt+F);  
  54. }  
  55.   
  56. //触摸屏矫正函数  
  57. void Tc_calibrate(void)  
  58. {  
  59. #if LCD_CALIBRATE==1  
  60.   
  61.     CLK_init();  
  62.     LCD_POWER();  
  63.     LCD_IO_init();  
  64.     LCD_init();  
  65.     LCD_on();  
  66.     Touch_Init();  
  67.       
  68.     LCD_clear(BLACK);//全屏显示黑色  
  69.   
  70.     //位置1  
  71.     Draw_X(160,40,WHITE);  
  72.     YdataClear;  
  73.     XdataClear;  
  74.     while(1)  
  75.     {     
  76.         Touch_GetAdXY(&x0,&y0);//读取坐标位置  
  77.         if((252<y0)&&(y0<256))//按键按下  
  78.         {  
  79.             Draw_X(160,40,BLACK);  
  80.             break;  
  81.         }  
  82.     }  
  83.       
  84.     //位置2  
  85.     Draw_X(40,180,WHITE);  
  86.     YdataClear;  
  87.     XdataClear;  
  88.     while(1)  
  89.     {  
  90.         Touch_GetAdXY(&x1,&y1);//读取坐标位置  
  91.         if((702<y1)&&(y1<706))//按键按下  
  92.         {  
  93.         Draw_X(40,180,BLACK);  
  94.             break;  
  95.         }  
  96.     }  
  97.       
  98.     //位置3  
  99.     Draw_X(260,200,WHITE);  
  100.     YdataClear;  
  101.     XdataClear;  
  102.     while(1)  
  103.     {  
  104.         Touch_GetAdXY(&x2,&y2);//读取坐标位置  
  105.         if((762<y2)&&(y2<764))//按键按下  
  106.         {  
  107.         Draw_X(260,200,BLACK);  
  108.             break;  
  109.         }  
  110.     }  
  111.       
  112.     Calculate_P(x0,y0,x1,y1,x2,y2);  
  113.       
  114. #endif  
  115.         if(inte)  
  116.         {  
  117.         Touch_GetAdXY(&xt,&yt);//读取坐标位置  
  118.         Tc_Correct(xt,yt);  
  119.         Uart_Printf("X=%4d, Y=%4d\n",X,Y);  
  120.         inte=0;  
  121.         }  
  122.   
  123. }  

 

      Font_libs.h  http://download.csdn.net/detail/lc123yx/8322405

 

基于mini2440简易计算器


联系
我们