• 基于mini2440简易计算器

    基于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 ",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 ",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=(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]!='')  
    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=rADCDAT0&0x3ff;//读x坐标  
    38.     ydata=rADCDAT1&0x3ff;//读y坐标  
    39.       
    40.     Uart_Printf(" Xdata=%04d, Ydata=%04d ", 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=0  
    9. #define XdataClear xdata=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 ",X,Y);  
    120.         inte=0;  
    121.         }  
    122.   
    123. }  

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

     

     
  • 相关阅读:
    iOS开发拓展篇—音频处理（音乐播放器2）
    iOS开发拓展篇—音频处理（音乐播放器1）
    iOS开发拓展篇—UIDynamic(捕捉行为)
    iOS开发拓展篇—UIDynamic(重力行为+碰撞检测)
    iOS开发拓展篇—UIDynamic(简单介绍)
    iOS开发拓展篇—封装音频文件播放工具类
    iOS开发拓展篇—音乐的播放
    iOS开发拓展篇—音效的播放
    iOS开发拓展篇—静态库
    (转)Android Studio系列教程一下载与安装 背景Android Studio VS Eclipse准备下载创建HelloWorld项目
  • 原文地址：https://www.cnblogs.com/liuchengchuxiao/p/4200101.html
Copyright © 2020-2023  润新知