这是我大三时的课程设计，设计要求如下：

1.时栅传感器模拟器：通过输入两路时间和空间的信号。

(1) 设计一路正弦载波信号模拟信号输出 sina * cos(wt)

(2) 设计一路余弦信号模拟信号输出     cosa *sin(wt)
    (3) 设计两路信号的合成模拟信号输出   sin(wt+a)
2. 设计数据采集模块。(要求整周期采样)

3.  ARM硬件接口电路设计:显示路和键盘电路

4. 软件设计：数字相关算法求解角度、显示、按键、A/D.
5.  proteus仿真和实做。希望对大家有用！

仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）
image.png
LPC2138单片机源程序如下:
  1. #include  "config.h"
  2. //#include  "LPC21xx.h"
  3. #include "math.h"
  5. //#define Fpclk 12000000
  6. //typedef unsigned char  uint8;                   /* defined for unsigned 8-bits integer variable         无符号8位整型变量  */
  7. //typedef signed   char  int8;                    /* defined for signed 8-bits integer variable                有符号8位整型变量  */
  8. //typedef unsigned short uint16;                  /* defined for unsigned 16-bits integer variable         无符号16位整型变量 */
  9. //typedef signed   short int16;                   /* defined for signed 16-bits integer variable                 有符号16位整型变量 */
  10. //typedef unsigned int   uint32;                  /* defined for unsigned 32-bits integer variable         无符号32位整型变量 */
  11. //typedef signed   int   int32;                   /* defined for signed 32-bits integer variable                 有符号32位整型变量 */
  12. //typedef float          fp32;                    /* single precision floating point variable (32bits) 单精度浮点数（32位长度） */
  13. //typedef double         fp64;                    /* double precision floating point variable (64bits) 双精度浮点数（64位长度） */
  14. #define IO_RS   0x1000000
  15. #define IO_RW   0x2000000
  16. #define IO_EN   0x4000000
  17. #define LED 0X01
  18. #define KEY1 (IO0PIN&(1<<20))
  19. #define KEY2 (IO0PIN&(1<<21))   
  20.       
  21. int32  k=0,ADC_Data,tt1,tt2;
  22. uint32 A=1,FG1=1,FG2=2;
  23. uint32 a,i,h,j,p,q,m,n,u,v;
  24. double c,s,data_1=0,data_2=0,data_3=0,data_4=0;
  25. double x,y,PI=3.141592653589793238462643383279502;
  26. int32 Buffer[256];
  28. double SINCE[19]={
  29. 0.0000,0.0872,0.1736,0.2588,0.3420,0.4226,
  30. 0.5000,0.5736,0.6428,0.7071,0.7660,0.8192,
  31. 0.8660,0.9063,0.9397,0.9659,0.9848,0.9962,
  32. 1.0000,
  33. };
  35. double COSCE[19]={
  36. 1.0000,0.9962,0.9848,0.9659,0.9397,0.9063,
  37. 0.8660,0.8192,0.7660,0.7071,0.6428,0.5736,
  38. 0.5000,0.4226,0.3420,0.2588,0.1736,0.0872,
  39. 0.0000,
  40. };
  41.         
  42. const int16 sindata[]={
  43. 0x80,0x83,0x86,0x89,0x8c,0x8f,0x92,0x95,
  44. 0x98,0x9b,0x9e,0xa1,0xa4,0xa7,0xaa,0xad,
  45. …………
  46. …………限于本文篇幅 余下代码请从51黑下载附件…………
  48. 0xfc,0xfd,0xfd,0xfe,0xfe,0xfe,0xfe,0xfe,
  49. };
  51. #define RS_1    IO1SET=(IO_RS&0xFFFFFFFF)
  52. #define RS_0    IO1CLR=(IO_RS&0xFFFFFFFF)
  53. #define RW_1    IO1SET=(IO_RW&0xFFFFFFFF)
  54. #define RW_0    IO1CLR=(IO_RW&0xFFFFFFFF)
  55. #define EN_1    IO1SET=(IO_EN&0xFFFFFFFF)
  56. #define EN_0    IO1CLR=(IO_EN&0xFFFFFFFF)
  59. void delayms(unsigned int t)
  60. {
  61.         unsigned char u,v;
  62.         for(u=0;u<100;u++)
  63.          for(v=0;v<81;v++);
  64. }
  66. void LCD_write_com(unsigned char com)              //LCD写入命令函数
  67. {
  68.         RS_0;
  69.         RW_0;
  70.         EN_1;
  71.         IO1SET=com<<16;
  72.         delayms(5);
  73.         EN_0;
  74.         IO1CLR=0xFF0000;
  75. }
  77. void LCD_write_data(unsigned char data)           //写入数据函数
  78. {
  79.         RS_1;
  80.   RW_0;
  81.   EN_1;
  82.   IO1SET=data<<16;
  83.         delayms(5);        
  84.   EN_0;
  85.         IO1CLR=0xFF0000;
  86. }
  88. void LCD_clear()                                  //LCD清屏函数
  89. {
  90.         LCD_write_com(0x01);
  91.         delayms(5);
  92. }
  94. void LCD_write_char(unsigned char x,unsigned char y,unsigned char s)    //写入字符函数
  95. {     
  96. if (y == 0)
  97.          {     
  98.          LCD_write_com(0x80+x);     
  99.          }   
  100. else
  101.          {     
  102.          LCD_write_com(0xC0+x);     
  103.          }        
  104. LCD_write_data(s);  
  105. }
  107. void LCD_write_string(unsigned char x,unsigned char y,unsigned char *s)   //写入字符串函数
  108. {     
  109. if (y == 0)
  110.          {     
  111.          LCD_write_com(0x80 + x);     //表示第一行
  112.          }
  113. else
  114.          {      
  115.          LCD_write_com(0xC0 + x);      //表示第二行
  116.          }        
  117. while (*s)
  118.          {     
  119.     LCD_write_data( *s);     
  120.     s++;     
  121.          }
  122. }
  124. void LCD_init()      //LCD初始化
  125. {
  126.         LCD_write_com(0x38);          //显示模式设置
  127.         delayms(5);
  128.         LCD_write_com(0x38);
  129.         delayms(5);
  130.         LCD_write_com(0x38);
  131.         delayms(5);
  132.         LCD_write_com(0x38);        
  133.         LCD_write_com(0x08);               //显示关闭
  134.         LCD_write_com(0x01);         //清屏
  135.         LCD_write_com(0x06);         //显示光标移动设置
  136.         delayms(5);
  137.         LCD_write_com(0x0C);         //显示开及光标设置
  138.   
  139. }
  140. /*
  141. void  UART0Init(uint32 bps)
  142. {  
  143.     uint16 Fdiv;
  144.     PINSEL0 = (PINSEL0 & (~0x0F)) | 0x05;        
  145.     U0LCR = 0x83;                                                        
  146.     Fdiv = (Fpclk / 16) / bps;                        
  147.     U0DLM = Fdiv / 256;                                                        
  148.     U0DLL = Fdiv % 256;                                                
  149.     U0LCR = 0x03;
  150. }
  151. */
  152.    void __irq IRQ_Timer0 (void)
  153. {   
  154. //            for(i=0;i<256;i++)
  155. //            {         
  156. //                                y=COSCE[a];
  157. //                                x=SINCE[a];
  158. //                                s=(y*sindata[i]);
  159. //                                c=(x*cosdata[i]);
  160. //                                
  161. //                                sindata[i]=sin(2.0*acos(-1.0)/256*i);
  162. //                                cosdata[i]=cos(2.0*acos(-1.0)/256*i);
  163. //                                
  164. //                                h=(s*0x1ff+0x1ff);
  165. //                                h=s+c;
  166. //                                DACR=((sindata[i]<<6))|(1<<16);
  167. //                                for(j=0;j<0x20;j++);
  168.         
  169.                         if((IO0PIN&KEY1)==0)
  170.        {
  171.                            if(FG1!=(A-5))
  172.                            {
  173.                                FG1=A;A+=5;i=0;
  174.                                            if(A>360) A=0;
  175.                            }
  176.                          }
  177.                         
  178.       if((IO0PIN&KEY1)!=0){ FG1=1; }
  179.                           a=A*180/PI;
  180.                   if((IO0PIN&KEY2)==0)
  181.        {
  182.                              if(FG2!=(A+5))
  183.                          {FG2=A;A-=5;i=0;
  184.                          if(A>360)A=0;}
  185.                          }
  186.                         if((IO0PIN&KEY2)!=0){ FG2=1; }
  187.                         if(A<=90)   a=A/5;
  188.                         if(A>90&A<=180)  a=36-A/5;
  189.                         if(A>180&A<270)  a=A/5-36;
  190.                         if(A>=270&A<360) a=72-A/5;
  191.                         
  192.                         y=COSCE[a];
  193.                   x=SINCE[a];
  194.                         s=(y*sindata[i]);
  195.                         c=(x*cosdata[i]);
  196.                         
  197. //                        sindata[i]=sin(2.0*acos(-1.0)/256*i);
  198. //                        cosdata[i]=cos(2.0*acos(-1.0)/256*i);
  199.                         
  200. //                        h=(s*0x1ff+0x1ff);
  201.                         h=s+c;
  202.                         DACR=((h<<6))|(1<<16);
  203.                         for(j=0;j<0x20;j++);
  204.       
  205.                
  206.                         AD0CR = (AD0CR&0x00FFFF00)|0x01|(1 << 24);        // 设置AD0.0，并进行第一次转换
  207.                         while( (AD0DR&0x80000000)==0 );                    // 等待转换结束
  208.                         ADC_Data = AD0DR;                                                        // 读取ADC结果
  209.                         ADC_Data = (ADC_Data>>6) & 0x3FF;           // 提取AD转换值
  211.                         
  212.                         Buffer[i]=ADC_Data;
  213.            
  214.            LCD_write_char(9,0,A/100%10+0X30);
  215.            LCD_write_char(10,0,A/10%10+0X30);
  216.            LCD_write_char(11,0,A%10+0X30);
  218.                 for(u=0;u<256;u++)
  219.                 {
  220.                         data_1 = data_1 +(Buffer[u]-0x7f)*(cosdata[u]-0x7f)/256;//-5170)*PI/128;
  221.                         data_2 = data_2 +(Buffer[u]-0x7f)*(sindata[u]-0x7f)/256;//-5170)*PI/128;        
  222.                 }
  223.                         data_4 = atan(data_1 /data_2)*180/acos(-1.0);
  224.                         tt1=data_4*10;//1;
  225.                         
  226.                         if(A>90&A<180)   tt1=1800-tt1;
  227.                         if(A>180&A<270)  tt1=1800+tt1;  
  228.                         if(A>270&A<360)  tt1=3600-tt1;  
  229.                
  230.                         LCD_write_char(9,1,tt1/1000%10+0X30);        
  231.                         LCD_write_char(10,1,tt1/100%10+0X30);
  232.                         LCD_write_char(11,1,tt1/10%10+0X30);
  233.                         LCD_write_char(12,1,'.');
  234.                         LCD_write_char(13,1,tt1%10+0X30);
  235.            
  237. //        LCD_write_char(6,1,tt2/1000%10+0X30);        
  238. //        LCD_write_char(7,1,tt2/100%10+0X30);
  239. //    LCD_write_char(8,1,tt2/10%10+0X30);
  240. //    LCD_write_char(9,1,'.');
  241. //        LCD_write_char(10,1,tt2%10+0X30);
  242.     i++;
  243.     if(i>=256) i=0;
  244.           T0IR = 0x02;                                /* 清除中断标志                                                                        */
  245.           VICVectAddr = 0x00;                        /* 通知VIC中断处理结束                                                        */
  246. //}
  247. }
  249. void  Time0Init(void)
  250. {  
  251.            T0TC   = 0;                              // 定时器T0初始化
  252.            T0PR = 10;              // 设置定时器0分频为100分频，得120000Hz
  253.     T0MCR = 0x03<<3;                // 匹配通道MR1匹配中断并复位TC
  254.           T0MR0 = Fpclk/12000;          // MR0比较值（0.5秒定时值）
  255.           T0MR1 = Fpclk/1200;          // MR1比较值（0.5秒定时值）
  256.     T0EMR = 0x30;                    // 设置定时器0的MR0匹配输出，输出方式为翻转
  257.           T0TCR = 0x03;           // 启动并复位T0TC
  258.           T0TCR = 0x01;      
  259.     T0IR = 0x02;
  261.    /* 设置定时器0中断IRQ */
  262.    VICIntSelect = 0x00;                                        // 所有中断通道设置为IRQ中断
  263.    VICVectCntl0 = 0x20 | 0x04;                         // 分配定时器0中断到通道0(最高优先级)
  264.    VICVectAddr0 = (uint32)IRQ_Timer0;         // 设置中断服务程序地址向量
  265.    VICIntEnable = (1<<4);                    // 使能定时器0中断
  266. //   IRQEnable();                                                 // 使能IRQ中断
  267. }
  269. int  main(void)
  270. {            
  271.     PINSEL0|=0x00000000;               
  272.            PINSEL1 |= 0x01400000;
  273.           PINSEL1 = (PINSEL1&(~(0x03<<18))) | (0x02<<18); // P0.25 连接Aout
  274. //    UART0Init(9600);
  275.     IO0DIR|=0X01;                                                
  276.           IO1DIR|=0x07ff0000;
  277.            LCD_init();                                                               
  278.           Time0Init();
  279.     AD0CR = (1 << 0)                    |        
  280.            ((Fpclk / 1000000 - 1) << 8) |         
  281.            (0 << 16)                    |        
  282.            (0 << 17)                    |         
  283.            (1 << 21)                    |                 
  284.            (0 << 22)                    |                 
  285.            (1 << 24)                    |                 
  286.            (0 << 27);                                                        
  287.     delayms(10);                                                               
  288.     ADC_Data = AD0DR;
  290.           LCD_write_string(0,0,"in:");
  291.           LCD_write_string(0,1,"out:");               
  292.         
  293.     while(1)
  294.     {
  295. //                   y=COSCE[a];
  296. //                                x=SINCE[a];
  297. //                                s=(y*sindata[i]);
  298. //                                c=(x*cosdata[i]);
  299.                                 
  300. //                                sindata[i]=sin(2.0*acos(-1.0)/256*i);
  301. //                                cosdata[i]=cos(2.0*acos(-1.0)/256*i);
  302.                                 
  303. ……………………
  305. …………限于本文篇幅 余下代码请从51黑下载附件…………