【赚周年币】技术帖Week1-Day7——LPC824 Breakout之七、ADC LCD显示

toofree

        【赚周年币】技术帖Week1-Day7——LPC824 Breakout之七、ADC转换，串口同时打印，并同时在 Nokia5110 LCD上显示。
        （标题不能太长，没办法，只好在贴中写全名称）

        以上一贴最后上传压缩包做主工程模板。参见贴子最末尾的附件。
        【赚周年币】技术帖Week1-Day6——LPC824 Breakout之六、30M时钟https://www.cirmall.com/bbs/forum ... 60438&fromuid=17147
        
        在最新的压缩包中“LPC824_Example_Code_Bundle_Keil_r1.0(20170107).rar”，修改了nokia5110 LCD函数名称，并修正了部分Bug。

        本贴使用“Example_ADC_Seqa_Seqb”工程模板，做适当修改。完整工程如下图：
        

        主函数如下，红色部分为修改内容。

1. /*
   
2. ===============================================================================
   
3. Name        : Example_ADC_Seqa_Seqb_main.c
   
4. Author      : $(author)
   
5. Version     :
   
6. Copyright   : $(copyright)
   
7. Description : read the readme
   
8. ===============================================================================
   
9. */
   
10. 
    
11. #include "LPC8xx.h"
    
12. //#include <cr_section_macros.h>
    
13. #include <stdio.h>
    
14. 
    
15. #include "lpc8xx_adc.h"
    
16. #include "lpc8xx_swm.h"
    
17. #include "lpc8xx_syscon.h"
    
18. #include "utilities.h"
    
19. 
    
20. #include "nokia5110.h"
    
21. 
    
22. 
    
23. void setup_debug_uart(void);
    
24. 
    
25. const char promptstring[] = "Choose a sequence to convert:\r\na for sequence a\r\nb for sequence b\r\n";
    
26. 
    
27. volatile uint32_t seqa_buffer[12];
    
28. volatile uint32_t seqb_buffer[12];
    
29. volatile enum {false, true} seqa_handshake, seqb_handshake;
    
30. uint32_t current_seqa_ctrl, current_seqb_ctrl;
    
31. 
    
32. // To use software triggering, define this to '1', otherwise define it to '0' to use hardware triggering.
    
33. #define SOFTWARE_TRIGGER 0
    
34. //#define SOFTWARE_TRIGGER 1
    
35. 
    
36. 
    
37. /*****************************************************************************
    
38. *****************************************************************************/
    
39. int main(void) {
    
40.   unsigned char temp;
    
41.   uint32_t current_clkdiv, val, temp_data, n;
    
42.         uint32_t lcd_n=0;
    
43.         char lcd_chr[20];
    
44. 
    
45.   // Configure the debug uart (see Serial.c)
    
46.   setup_debug_uart();
    
47. 
    
48.   // Step 1. Power up and reset the ADC, and enable clocks to peripherals (see lpc8xx_syscon.h)
    
49.   LPC_SYSCON->PDRUNCFG &= ~(ADC_PD);
    
50.   LPC_SYSCON->PRESETCTRL &= (ADC_RST_N);
    
51.   LPC_SYSCON->PRESETCTRL |= ~(ADC_RST_N);
    
52.   LPC_SYSCON->SYSAHBCLKCTRL |= (ADC | GPIO | SWM);
    
53. 
    
54. //  // Make P0.27 output driving '1'  connect to P0.11 externally.
    
55. //  // Make P0.16 output driving '1', connect to P0.10 externally.
    
56. //  LPC_GPIO_PORT->SET0  = 0x08010000;     // P0.27, P0.16 to '1'
    
57. //  LPC_GPIO_PORT->DIR0 |= 0x08010000;     // P0.27, P0.16 to output
    
58.         
    
59.         // Make P0.15 output driving '1'  connect to P0.11 externally.
    
60.   // Make P0.16 output driving '1', connect to P0.10 externally.
    
61.   LPC_GPIO_PORT->SET0  = 0x00018000;     // P0.15, P0.16 to '1'
    
62.   LPC_GPIO_PORT->DIR0 |= 0x00018000;     // P0.15, P0.16 to output
    
63. 
    
64.   // Step 2. Perform a self-calibration
    
65.   // Choose a CLKDIV divider value that yields about 500 KHz, we will use the SystemCoreClock variable for the calculation.
    
66.   SystemCoreClockUpdate();
    
67.   current_clkdiv = (SystemCoreClock / 500000) - 1;
    
68. 
    
69.   // Start the self-calibration
    
70.   // Calibration mode = true, low power mode = false, CLKDIV = appropriate for 500,000 Hz
    
71.   LPC_ADC->CTRL = ( (1<<ADC_CALMODE) | (0<<ADC_LPWRMODE) | (current_clkdiv<<ADC_CLKDIV) );
    
72. 
    
73.   // Poll the calibration mode bit until it is cleared
    
74.   while (LPC_ADC->CTRL & (1<<ADC_CALMODE));
    
75. 
    
76.   // Step 3. Configure the SWM (see utilities_lib and lpc8xx_swm.h)
    
77.   // ADC1 - ADC6, ADC7, ADC9 - ADC11 pins to be ADC analog functions
    
78.   // We won't use ADC0 or ADC8 because they share pins with the debug uart
    
79.   LPC_SWM->PINENABLE0 &= ~(ADC_1|ADC_2|ADC_3|ADC_4|ADC_5|ADC_6|ADC_7|ADC_9|ADC_10|ADC_11); // Fixed pin analog functions enabled
    
80.   LPC_SWM->PINENABLE0 |= (ADC_0|ADC_8);                                                    // Movable digital functions enabled
    
81. 
    
82.   // Assign the ADC pin trigger functions to pins P0.10 (A seq.) and P0.11 (B seq.)
    
83.   ConfigSWM(ADC_PINTRIG0, P0_10);  // ADC_PINTRIG0 will be for the A sequence
    
84.   ConfigSWM(ADC_PINTRIG1, P0_11);  // ADC_PINTRIG1 will be for the B sequence
    
85. 
    
86.   // Step 4. Configure the ADC for the appropriate analog supply voltage using the TRM register
    
87.   // For a sampling rate higher than 1 Msamples/s, VDDA must be higher than 2.7 V (on the Max board it is 3.3 V)
    
88.   LPC_ADC->TRM &= ~(1<<ADC_VRANGE); // '0' for high voltage
    
89. 
    
90.   // Step 4. Choose a CLKDIV divider value
    
91.   // A fully accurate conversion requires 25 ADC clocks.
    
92.   // A 30 MHz system clock with CLKDIV = 0 results in 1.2 MSPS.
    
93.   // We can use the SystemCoreClock variable to calculate for a desired sample rate in Hz.
    
94.   #define desired_sample_rate 1200000
    
95.   current_clkdiv = (SystemCoreClock / (25 * desired_sample_rate)) - 1;
    
96. 
    
97.   // Calibration mode = false, low power mode = false, CLKDIV = appropriate for desired sample rate.
    
98.   LPC_ADC->CTRL = ( (0<<ADC_CALMODE) | (0<<ADC_LPWRMODE) | (current_clkdiv<<ADC_CLKDIV) );
    
99. 
    
100.   // Step 5. Assign some ADC channels to each sequence
     
101.   // Let sequence A = channels 1, 2, 3, 4, 5, 6
     
102.   // Let sequence B = channels 7, 9, 10, 11
     
103. //  current_seqa_ctrl = ((1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<5)|(1<<6))<<ADC_CHANNELS;
     
104. //  current_seqb_ctrl = ((1<<7)|(1<<9)|(1<<10)|(1<<11))<<ADC_CHANNELS;
     
105.   current_seqa_ctrl = ((1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<5))<<ADC_CHANNELS;
     
106.   current_seqb_ctrl = ((1<<6)|(1<<7)|(1<<9)|(1<<10)|(1<<11))<<ADC_CHANNELS;
     
107. 
     
108.   // Step 6. Select a trigger source for each of the sequences
     
109.   // Let sequence A trigger = ADC pin trigger 0. Connected to an external pin through the switch matrix above.
     
110.   // Let sequence B trigger = ADC pin trigger 1. Connected to an external pin through the switch matrix above.
     
111. #if SOFTWARE_TRIGGER
     
112.   current_seqa_ctrl |= LOGIC_HIGH<<ADC_TRIGGER;    // Use for software-only triggering
     
113.   current_seqb_ctrl |= LOGIC_HIGH<<ADC_TRIGGER;    // Use for software-only triggering
     
114. #else
     
115.   current_seqa_ctrl |= ADC_PINTRIG_0<<ADC_TRIGGER; // Use for hardware triggering
     
116.   current_seqb_ctrl |= ADC_PINTRIG_1<<ADC_TRIGGER; // Use for hardware triggering
     
117. #endif
     
118. 
     
119.   // Step 7. Select positive (1) or negative (0) edge for the hardware trigger
     
120.   // Let sequence A be negative edge triggered
     
121.   // Let sequence B be negative edge triggered
     
122.   current_seqa_ctrl |= 0<<ADC_TRIGPOL;
     
123.   current_seqb_ctrl |= 0<<ADC_TRIGPOL;
     
124. 
     
125.   // Step 8. Choose (1) to bypass, or (0) not to bypass the hardware trigger synchronization
     
126.   // Since our trigger sources are on-chip, system clock based, we may bypass.
     
127.   current_seqa_ctrl |= 1<<ADC_SYNCBYPASS;
     
128.   current_seqb_ctrl |= 1<<ADC_SYNCBYPASS;
     
129. 
     
130.   // Step 9. Choose burst mode (1) or no burst mode (0) for each of the sequences
     
131.   // Let sequences A and B use no burst mode
     
132.   current_seqa_ctrl |= 0<<ADC_BURST;
     
133.   current_seqb_ctrl |= 0<<ADC_BURST;
     
134. 
     
135.   // Step 10. Choose single step (1), or not (0), for each sequence.
     
136.   // Let sequences A and B use no single step
     
137.   current_seqa_ctrl |= 0<<ADC_SINGLESTEP;
     
138.   current_seqb_ctrl |= 0<<ADC_SINGLESTEP;
     
139. 
     
140.   // Step 11. Choose A/B sequence priority
     
141.   // Use default
     
142.   current_seqa_ctrl |= 0<<ADC_LOWPRIO;
     
143. 
     
144.   // Step 12. Choose end-of-sequence mode (1), or end-of-conversion mode (0), for each sequence
     
145.   // Let sequences A and B use end-of-sequence mode
     
146.   current_seqa_ctrl |= 1<<ADC_MODE;
     
147.   current_seqb_ctrl |= 1<<ADC_MODE;
     
148. 
     
149.   // Step 13. Set the low and high thresholds for both sets of threshold compare registers
     
150.   // Note: This step is included for completeness, threshold crossings are not currently used in this example.
     
151.   // Let both low thresholds be (1/3)*0xfff
     
152.   // Let both high thresholds be (2/3)*0xfff
     
153.   #define low_thresh (0xFFF / 3)
     
154.   #define high_thresh ((2 * 0xFFF) / 3)
     
155.   LPC_ADC->THR0_LOW = low_thresh;
     
156.   LPC_ADC->THR1_LOW = low_thresh;
     
157.   LPC_ADC->THR0_HIGH = high_thresh;
     
158.   LPC_ADC->THR1_HIGH = high_thresh;
     
159. 
     
160.   // Step 14. For each channel, choose which pair of threshold registers (0 or 1) conversion results should be compared against.
     
161.   // Note: This step is included for completeness, threshold crossings are not currently used in this example.
     
162.   // For sequence A (channels 1 - 6), compare against threshold register set 0
     
163.   // For sequence B (channels 7, 9, 10, 11), compare against threshold register set 1
     
164.   LPC_ADC->CHAN_THRSEL = (0<<1)|(0<<2)|(0<<3)|(0<<4)|(0<<5)|(0<<6)|(1<<7)|(1<<9)|(1<<10)|(1<<11);
     
165. 
     
166.   // Step 15. Choose which interrupt conditions will contribute to the ADC interrupt/DMA triggers
     
167.   // Only the sequence A and sequence B interrupts are enabled for this example
     
168.   // SEQA_INTEN = true
     
169.   // SEQB_INTEN = true
     
170.   // OVR_INTEN = false
     
171.   // ADCMPINTEN0 - ADCMPEN11 = false
     
172.   LPC_ADC->INTEN = (1<<SEQA_INTEN)  |
     
173.                    (1<<SEQB_INTEN)  |
     
174.                    (0<<OVR_INTEN)   |
     
175.                    (0<<ADCMPINTEN0) |
     
176.                    (0<<ADCMPINTEN1) |
     
177.                    (0<<ADCMPINTEN2) |
     
178.                    (0<<ADCMPINTEN3) |
     
179.                    (0<<ADCMPINTEN4) |
     
180.                    (0<<ADCMPINTEN5) |
     
181.                    (0<<ADCMPINTEN6) |
     
182.                    (0<<ADCMPINTEN7) |
     
183.                    (0<<ADCMPINTEN8) |
     
184.                    (0<<ADCMPINTEN9) |
     
185.                    (0<<ADCMPINTEN10)|
     
186.                    (0<<ADCMPINTEN11);
     
187. 
     
188. 
     
189.   // Write the sequence control word with enable bit set for both sequences
     
190.   current_seqa_ctrl |= 1U<<ADC_SEQ_ENA;
     
191.   LPC_ADC->SEQA_CTRL = current_seqa_ctrl;
     
192. 
     
193.   current_seqb_ctrl |= 1U<<ADC_SEQ_ENA;
     
194.   LPC_ADC->SEQB_CTRL = current_seqb_ctrl;
     
195. 
     
196.   // Enable ADC interrupts in the NVIC
     
197.   NVIC_EnableIRQ(ADC_SEQA_IRQn);
     
198.   NVIC_EnableIRQ(ADC_SEQB_IRQn);
     
199.         
     
200.         Home_Init();
     
201.         NOKIA5110_init();
     
202.   NOKIA5110_clear_screen();
     
203.         
     
204.         NOKIA5110_display_1608_text (0, 0, "LPC824");
     
205.         NOKIA5110_display_8x6_text (0, 2, "ADC Test !");
     
206. 
     
207.   printf("This is a ADC test programme !\r\n");
     
208.         printf("low_thresh: 0x%03X\r\n",low_thresh);
     
209.         printf("high_thresh: 0x%03X\r\n",high_thresh);
     
210. 
     
211.   while(1) {
     
212. 
     
213.     // Prompt user to select a sequence to convert (see utilities_lib)
     
214.     temp = GetConsoleCharacter((const char *)&promptstring);
     
215. 
     
216.     // Accept 'a' only, anything else is sequence B
     
217.     if (temp == 'a') {
     
218.       seqa_handshake = false;
     
219. 
     
220. #if SOFTWARE_TRIGGER
     
221.       // Launch sequence A with software
     
222.       current_seqa_ctrl |= 1<<ADC_START;
     
223.       LPC_ADC->SEQA_CTRL = current_seqa_ctrl;
     
224. #else
     
225.       // Launch sequence A with hardware
     
226.       LPC_GPIO_PORT->CLR0 = 0x00010000;      // Clear P0.16 to '0', creates a falling edge on ADC_PINTRIG0
     
227. #endif
     
228.       // Wait for return from ISR
     
229.       while (!seqa_handshake);
     
230.                         
     
231.                         printf("\r\n");
     
232.                         NOKIA5110_clear_screen();
     
233.                         lcd_n = 0;
     
234.       // Get the data from SRAM and print it to the terminal
     
235.       for (n = 0; n < 12; n++) {
     
236.         val = current_seqa_ctrl;
     
237.         val = (val>>n) & 0x1;    // Shift the current channel of interest into bit 0, see if it's set
     
238.         if (val) {               // If set, get this channel's data from the SRAM array
     
239.           temp_data = (seqa_buffer[n]>>4) & 0x00000FFF;
     
240.           printf("ADC channel %d data was %d\r\n", n, temp_data);        
     
241.                                        
     
242.                                         NOKIA5110_display_8x6_text (0, lcd_n, "ADC");
     
243.                                         sprintf(lcd_chr,"%2d",n);
     
244.                                         NOKIA5110_display_8x6_text (18, lcd_n, lcd_chr);
     
245.                                         NOKIA5110_display_8x6_text (30, lcd_n, ": 0x");
     
246.                                         sprintf(lcd_chr,"%4d",temp_data);
     
247.                                         NOKIA5110_display_8x6_text (54, lcd_n, lcd_chr);
     
248.                                         lcd_n++;
     
249.         }
     
250.       }
     
251.     }
     
252.     else if (temp == 'b'){
     
253.       seqb_handshake = false;
     
254. 
     
255. #if SOFTWARE_TRIGGER
     
256.       // Launch sequence B with software
     
257.       current_seqb_ctrl |= 1<<ADC_START;
     
258.       LPC_ADC->SEQB_CTRL = current_seqb_ctrl;
     
259. #else
     
260.       // Launch sequence B with hardware
     
261.       //LPC_GPIO_PORT->CLR0 = 0x08000000;      // Clear P0.27 to '0', creates a falling edge on ADC_PINTRIG1
     
262.                         LPC_GPIO_PORT->CLR0 = 0x00008000;      // Clear P0.15 to '0', creates a falling edge on ADC_PINTRIG1
     
263. #endif
     
264.       // Wait for return from ISR
     
265.       while (!seqb_handshake);
     
266.                         
     
267.                         printf("\r\n");
     
268.                         NOKIA5110_clear_screen();
     
269.                         lcd_n = 0;
     
270.       // Get the data from SRAM and print it to the terminal
     
271.       for (n = 0; n < 12; n++) {
     
272.         val = current_seqb_ctrl;
     
273.         val = (val>>n) & 0x1;    // Shift the current channel of interest into bit 0, see if it's set
     
274.         if (val) {               // If set, get this channel's data from the SRAM array
     
275.           temp_data = (seqb_buffer[n]>>4) & 0x00000FFF;
     
276.           printf("ADC channel %d data was %d\r\n", n, temp_data);
     
277.                                        
     
278.                                         NOKIA5110_display_8x6_text (0, lcd_n, "ADC");
     
279.                                         sprintf(lcd_chr,"%2d",n);
     
280.                                         NOKIA5110_display_8x6_text (18, lcd_n, lcd_chr);
     
281.                                         NOKIA5110_display_8x6_text (30, lcd_n, ": 0x");
     
282.                                         sprintf(lcd_chr,"%4d",temp_data);
     
283.                                         NOKIA5110_display_8x6_text (54, lcd_n, lcd_chr);
     
284.                                         lcd_n++;
     
285.         }
     
286.       }
     
287.     }
     
288.                 else
     
289.                 {
     
290.                         printf("\r\nInput error, please input again! \r\n");;
     
291.                 }
     
292. 
     
293. 
     
294.     // Put the external pins back to '1'
     
295.     //LPC_GPIO_PORT->SET0 = 0x08010000;      // Set P0.27, P0.16 to '1'
     
296.                 LPC_GPIO_PORT->SET0 = 0x00018000;      // Set P0.15, P0.16 to '1'
     
297.                
     
298.   } // end of while 1        
     
299. 
     
300. } // end of main
     

复制代码

在代码中标注红色时出现问题，全乱了，下面截图说明。选中的蓝色字部分为添加或修改的程序。
        
添加nokia5110 LCD函数库支持


之前默认是\n\r，结果打印不换行，修改成“\r\n”


lcd显示行计数和字符串缓存


原本是P0.27，改为P0.15。因为nokia5110 LCD显示用了5个IO，从P0.24到P0.28。


把ADC6通道从seqa换到了seqb，这样匀一下方便显示


在while之前，对LCD初始化并显示，串口也打印部分信息


在seqa中，每次进入seqa时，清屏LCD


对seqa中通道及电压在LCD上显示。245行有改动，NOKIA5110_display_8x6_text (30, lcd_n, ": ");


改成判断字符'b'，这样程序有效的字符只有'a'和'b'


在seqb中，每次进入seqb时，清屏LCD


同上，281行有改动，NOKIA5110_display_8x6_text (30, lcd_n, ": ");


输入字符除‘a’、'b'外，都显示输入错误提示。


        实验连线，P0.15、P0.16分别与P0.11、P0.10连接，P0.24到P0.28接Nokia5110 LCD。模拟电压是通过LPC824 Lite板卡给提供的，存在干扰，但能看出AD效果来。P0.06接LPC824 Lite的电位器管脚，地线不用连（因为在LPC824 Breakout板上只有一根地线共LCD用了），通过USB共地。
        原理图接线
        

        实物连接，全家福。
        

        下载程序，复位后开始跑程序，串口终端显示。
        
      

         LCD显示
        

        输入'a'+空格，后开始seqa AD转换，结果显示在串口终端和LCD上
        

         LCD显示
        

        输入'b'+空格，后开始seqb AD转换，结果显示在串口终端和LCD上
        

        LCD显示结果
        

        LPC824 Breakout AD转换，结果成功显示在串口终端打印，并成功在LCD上显示。完美收工＾＿^。

        依照惯例， 修改后工程文件打包附上。
         LPC824_Example_Code_Bundle_Keil_r1.0(201701072334).rar (2.34 MB, 下载次数: 46)

2017-1-7 23:35 上传

点击文件名下载附件
201701072334

胤幻1988

讲的挺好的，但是如果把ADC触发的几种模式也写进去就更好了。