ADC TEST

  1 `timescale 1ns / 1ps
  2 //////////////////////////////////////////////////////////////////////////////////
  3 // Company:
  4 // Engineer:
  5 //
  6 // Create Date:    13:33:13 10/23/2015
  7 // Design Name:
  8 // Module Name:    adc_test
  9 // Project Name:
 10 // Target Devices:
 11 // Tool versions:
 12 // Description:
 13 //
 14 // Dependencies:
 15 //
 16 // Revision:
 17 // Revision 0.01 - File Created
 18 // Additional Comments:
 19 //
 20 //////////////////////////////////////////////////////////////////////////////////
 21  module adc_test
 22     (
 23         input sys_clk,
 24         input    sys_rst,
 25
 26         input    [9:0] adc_din,
 27         input  adc_finish,
 28
 29         output adc_enb,
 30         output     adc_samp_en,
 31         output   adc_go,
 32         output     adc_samp,
 33         output     adc_clk,
 34         output    [2:0] adc_M_out,
 35
 36         //inout sda,
 37         //output scl,
 38
 39 //        input            uart_rx,
 40         output         uart_tx
 41 );
 42
 43
 44 reg    [7:0]        tx_data;
 45 reg    tx_en;
 46 wire    tx_done;
 47 uart_tx U1
 48 (
 49     .sys_clk(sys_clk),
 50     .rst(sys_rst),
 51     .tx_en(tx_en),
 52     .tx_data(tx_data),
 53     .tx_done(tx_done),
 54     .tx_pin_out(uart_tx)
 55 );
 56
 57 /*wire [11:0] adc_out;
 58
 59 adc_module U2
 60 (
 61         .sys_clk(sys_clk),//100MHz
 62         .rst_n(sys_rst),
 63
 64         .sda(sda),
 65         .scl(scl),
 66         .data(adc_out)
 67 );
 68
 69 wire  adc_enb_1;
 70
 71 wire [2:0] M_in;
 72
 73 wire [9:0] adc_out1;
 74 adc_test_module U3
 75 (
 76         .sys_clk(sys_clk),
 77         .sys_rst(sys_rst),
 78
 79         .adc_din(adc_din),
 80         .adc_finish(adc_finish),
 81
 82         .adc_enb(adc_enb_1),
 83         .adc_samp_en(adc_samp_en),
 84         .adc_go(adc_go),
 85         .adc_samp(adc_samp),
 86         .adc_clk(adc_clk),
 87
 88         .adc_out(adc_out1),
 89         .M_out(M_in)
 90
 91 );
 92
 93
 94 reg L2H_F1;
 95 reg L2H_F2;
 96 reg L2H_sw;
 97 reg L2H_sw1;
 98 wire L2H_Sig;
 99
100 always @(posedge sys_clk)
101 begin
102     if(sys_rst)begin
103         L2H_F1 <= 1‘b1;
104         L2H_F2 <= 1‘b1;
105     end else begin
106         L2H_F1 <= adc_enb_1;
107         L2H_F2 <= L2H_F1;
108
109     end
110 end
111 assign L2H_Sig = !L2H_F1 & L2H_F2;
112 */
113 reg [2:0] state;
114 reg [7:0] tx_L;
115 reg [7:0] tx_H;
116 reg [7:0] tx_H2;
117 reg tx_start;
118 reg [15:0]delay_cont;
119 reg adc_io;
120 wire [9:0]adc_data;
121 reg [11:0]adc_data0;
122 reg [11:0]adc_data1;
123 //reg [11:0]adc_data2;
124 //reg [11:0]adc_data3;
125 wire [11:0]adc_data5;
126 assign adc_data5 = adc_out;
127 wire [11:0]adc_data4;
128 reg adc_data0_0;
129 //assign adc_data = {~adc_out};
130 reg uart_out = 0;
131 reg [15:0] M_delay = 0;
132 always @(posedge sys_clk)
133 begin
134     if(L2H_F1 & !L2H_F2)begin
135             case(M_in)
136                 3‘d0:begin
137                         adc_data0 <={adc_data[9:0],2‘b00};
138     //                    adc_data0_0 <= adc_data0[2];
139                       end
140                 3‘d1:begin
141                         adc_data1[0] <= {adc_data[0]};
142     //                    adc_data0_0 <=adc_data0[2:2];
143                       end
144                 3‘d3:begin
145                         adc_data1[1] <= {adc_data[0]};
146                         end
147                 3‘d7:begin
148                         adc_data1[2] <= {adc_data[0]};
149                         uart_out <= 1;
150                       end
151             endcase
152     end
153     else begin
154             uart_out <= 0;
155     end
156 end
157 //assign adc_data4 = adc_data0[2] ?  ((!adc_data1[0]) + (!adc_data1[1]) + (!adc_data1[2]))  : (adc_data1[0] + adc_data1[1] + adc_data1[2]);
158 //assign adc_data5 = adc_data4 + adc_data0;
159
160 always @(posedge sys_clk)
161 begin
162     if(sys_rst)begin
163         tx_en        <= 1‘b0;
164         state        <= 3‘d0;
165         tx_start <= 1‘d0;
166         delay_cont <= 16‘d0;
167         adc_io <= 1‘b1;
168     end else begin
169         if(uart_out)begin
170             state <= 3‘d0;
171             delay_cont <= 16‘d0;
172             tx_start <= 1‘d1;
173         end else begin
174             case(state)
175                 3‘d0:
176                     begin
177 //                        adc_data4 <= adc_data0 + adc_data0[2] +  adc_data1[2] + adc_data2[2] + adc_data3[2];
178                         delay_cont <= delay_cont + 16‘d1;
179                         if(delay_cont == 16‘d32000) begin
180                                 delay_cont <= 16‘d0;
181                                 state          <= 3‘d1;
182
183                                 case(adc_data5[3:0])
184                                     4‘d0:  tx_L <= 8‘h30;
185                                     4‘d1:  tx_L <= 8‘h31;
186                                     4‘d2:  tx_L <= 8‘h32;
187                                     4‘d3:  tx_L <= 8‘h33;
188                                     4‘d4:  tx_L <= 8‘h34;
189                                     4‘d5:  tx_L <= 8‘h35;
190                                     4‘d6:  tx_L <= 8‘h36;
191                                     4‘d7:  tx_L <= 8‘h37;
192                                     4‘d8:  tx_L <= 8‘h38;
193                                     4‘d9:   tx_L <= 8‘h39;
194                                     4‘d10:  tx_L <= 8‘h41;
195                                     4‘d11:  tx_L <= 8‘h42;
196                                     4‘d12: tx_L <= 8‘h43;
197                                     4‘d13:  tx_L <= 8‘h44;
198                                     4‘d14:  tx_L <= 8‘h45;
199                                     4‘d15:  tx_L <= 8‘h46;
200                                     default:begin tx_L <= 8‘h58;end
201                                 endcase
202                                 case(adc_data5[7:4])
203                                     4‘d0: begin tx_H <= 8‘h30; end
204                                     4‘d1:begin tx_H <= 8‘h31;end
205                                     4‘d2:begin tx_H <= 8‘h32;end
206                                     4‘d3:begin tx_H <= 8‘h33;end
207                                     4‘d4:begin tx_H <= 8‘h34;end
208                                     4‘d5:begin tx_H <= 8‘h35;end
209                                     4‘d6:begin tx_H <= 8‘h36;end
210                                     4‘d7:begin tx_H <= 8‘h37;end
211                                     4‘d8:begin tx_H <= 8‘h38;end
212                                     4‘d9:begin tx_H <= 8‘h39;end
213                                     4‘d10:begin  tx_H <= 8‘h41;end
214                                     4‘d11:begin  tx_H <= 8‘h42;end
215                                     4‘d12:begin  tx_H <= 8‘h43;end
216                                     4‘d13:begin  tx_H <= 8‘h44;end
217                                     4‘d14:begin  tx_H <= 8‘h45;end
218                                     4‘d15:begin  tx_H <= 8‘h46;end
219                                     default:begin tx_H <= 8‘h58;end
220                                 endcase
221                                 case(adc_data5[11:8])
222                                     4‘d0:  tx_H2 <= 8‘h30;
223                                     4‘d1:  tx_H2 <= 8‘h31;
224                                     4‘d2:  tx_H2 <= 8‘h32;
225                                     4‘d3:  tx_H2 <= 8‘h33;
226                                     4‘d4:  tx_H2 <= 8‘h34;
227                                     4‘d5:  tx_H2 <= 8‘h35;
228                                     4‘d6:  tx_H2 <= 8‘h36;
229                                     4‘d7:  tx_H2 <= 8‘h37;
230                                     4‘d8:  tx_H2 <= 8‘h38;
231                                     4‘d9:   tx_H2 <= 8‘h39;
232                                     4‘d10:  tx_H2 <= 8‘h41;
233                                     4‘d11:  tx_H2 <= 8‘h42;
234                                     4‘d12:  tx_H2 <= 8‘h43;
235                                     4‘d13:  tx_H2 <= 8‘h44;
236                                     4‘d14:  tx_H2 <= 8‘h45;
237                                     4‘d15:  tx_H2 <= 8‘h46;
238                                     default:tx_H2 <= 8‘h58;
239                                 endcase
240                                 adc_io <= 1‘b1;
241                         end else if(delay_cont == 16‘d1000) begin
242                                 adc_io <= 1‘b0;
243                         end else begin
244                             delay_cont <= delay_cont + 16‘d1;
245                         end
246                     end
247
248                 3‘d1:
249                     begin
250                         if(tx_start == 1‘d1)
251                             begin
252                                 tx_en        <= 1‘b1;
253                                 tx_data    <= tx_H2;
254                                 tx_start    <= 1‘d0;
255                             end else if(tx_done) begin
256                                 tx_en        <= 1‘b0;
257                                 tx_start    <= 1‘d1;
258                                 state <= state +3‘d1;
259                             end
260                     end
261                  3‘d2:
262                     begin
263                             if(tx_start == 1‘d1)
264                             begin
265                                 tx_en        <= 1‘b1;
266                                 tx_data    <= tx_H;
267                                 tx_start    <= 1‘d0;
268                             end else if(tx_done) begin
269                                 tx_en        <= 1‘b0;
270                                 tx_start    <= 1‘d1;
271                                 state <= state +3‘d1;
272                             end
273                     end
274                 3‘d3:
275                     begin
276                             if(tx_start == 1‘d1)
277                             begin
278                                 tx_en        <= 1‘b1;
279                                 tx_data    <= tx_L;
280                                 tx_start    <= 1‘d0;
281                             end else if(tx_done) begin
282                                 tx_en        <= 1‘b0;
283                                 tx_start    <= 1‘d1;
284                                 state <= state +3‘d1;
285                             end
286                     end
287                 3‘d4:
288                     begin
289                             if(tx_start == 1‘d1)
290                             begin
291                                 tx_en        <= 1‘b1;
292                                 tx_data    <= 8‘h0A;
293                                 tx_start    <= 1‘d0;
294                             end else if(tx_done) begin
295                                 tx_en        <= 1‘b0;
296                                 tx_start    <= 1‘d1;
297                                 state <= state +3‘d1;
298                             end
299                     end
300                 3‘d5:
301                     begin
302                             if(tx_start == 1‘d1)
303                             begin
304                                 tx_en        <= 1‘b1;
305                                 tx_data    <= 8‘h0d;
306                                 tx_start    <= 1‘d0;
307                             end else if(tx_done) begin
308                                 tx_en        <= 1‘b0;
309                                 tx_start    <= 1‘d1;
310                                 state <= 3‘d6;
311                             end
312                     end
313                  default: state <= 3‘d6;
314             endcase
315          end
316     end
317 end
318 assign adc_enb = adc_io;
319 assign adc_M_out = M_in;
320 endmodule
时间: 2024-10-07 06:41:43

ADC TEST的相关文章

重学STM32---(五)ADC

这两天把外部中断和ADC看了下,个人感觉外部中断不是很难,也就没有把记下来了,毕竟写这个挺浪费时间.ADC是比较复杂的,如果想让完全自由的运用ADC必须经过多次实践可能才可以.由于已经学过库函数,也就打算自己看数据手册写了一个简单的寄存器版的ADC,期间也遇到了很多问题,幸好都解决了. 把这次学习的重点都记下来,以后再看不知是什么感觉O(∩_∩)O哈哈~ 1. 模拟看门狗特性允许应用程序检测输入电压是否超出用户定义的高/低阀值. ADC的输入时钟不得超过14MHz,它是由PCLK2经分频产生.

1.13裸机ADC部分

1.13.1.ADC的引入 1.13.1.1.什么是ADC (1)ADC:analog digital converter ,AD转换,模数转换(也就是模拟转数字) (2)CPU本身是数数字的,而外部世界变量(如电压.温度.高度.压力)都是模拟的,所以需要用CPU来处理这些外部的模拟量的时候就需要做AD转换 1.13.1.2.为什么需要ADC (1)为了用数字技术来处理外部的模拟量 1.13.1.3.关于模拟量和数字量 (1)模拟的就是连续的,显示生活中的时间.电压.高度等都是模拟的(连续分布的

利用STM32CubeMX来生成USB_HID_Mouse工程【添加ADC】(2)【非dma和中断方式】

上回讲到怎么采集一路的adc的数据,这次我们来采集两路的数据. 现在直接修改原先的代码 /* Private variables ---------------------------------------------------------*/ uint16_t AD_Value_Buf[2]; uint16_t AD_X_Value = 0; uint16_t AD_Y_Value = 0; /* USER CODE END PV */ /* USER CODE BEGIN 3 */ fo

STM32F0的多路ADC 无DMA

前段时间几乎用了一下午的时间, 就为了调F0的两路ADC, 一开始想的办法是将采样的连续模式(ADC_ContinuousConvMode)使能, 然后连续拿两个值, 拿完分别返回. 坏处不用说, 看着就傻, 就算你只需要一个ADC通道的值, 也要拿足N个, 比如你一共要拿5个ADC引脚的电压, 那就要全拿, 然后取其中第若干个, 如果你要拿8个做平均, 就要把时间再乘8, 看着就蠢. 但是反复调试发现如果不连续采样, 第一次ok, 但是后面每次就只采后一个通道了, 很奇怪, 结果发现原来是居然

【ADC】ADC初始化的注意事项

ADC的初始化如果没设置好,对于整个系统是有很大的影响的,首先就是拖慢采集速度. 再有就是没打开通道没有检测.那直接看710的ADC初始化代码来理解吧 要用的引脚需要先设置为输入. 27     AD1PCFGH=0XFFFF;                        //选择AN0引脚作为模拟输入28     AD1PCFGL=0XFFF0; 这两个寄存器设置需要注意,0为模拟输入,所以你要多个采集的话就要把那几位置零了 AD1CSSL=0X0001;                  

MAX10 ADC的一些基知识

MAX10 ADC 的一些知识 1.        MAX 10 内部集成的12bit SAR ADC的特点为: a.        采样速率高达1Mhz. b.        模拟通道多达18个,单个ADC多达17个,双ADC器件中有16个双功能ADC通道,2个专用的ADC. c.         提供单端测量功能. d.        双ADC器件的专用模拟输入管脚具备同步测量功能.因两个专用的管脚的封装布线是匹配的.而双功能管脚,两个ADC模块之间的布线延时在同步测量中导致数据失配.另外I

ADC类型总结

1.SAR型 (逐次逼近型) 摘要:逐次逼近寄存器型(SAR)模数转换器(ADC)占据着大部分的中等至高分辨率ADC市场.SAR ADC的采样速率最高可达5Msps,分辨率为8位至18位.SAR架构允许高性能.低功耗ADC采用小尺寸封装,适合对尺寸要求严格的系统. 本文说明了SAR ADC的工作原理,采用二进制搜索算法,对输入信号进行转换.本文还给出了SAR ADC的核心架构,即电容式DAC和高速比较器.最后,对SAR架构与流水线.闪速型以及Σ-Δ ADC进行了对比. 引言 逐次逼近寄存器型(S

STM32 ADC基础与多通道采样

12位ADC是一种逐次逼近型模拟数字数字转换器.它有多达18个通道,可测量16个外部和2个内部信号源.ADC的输入时钟不得超过14MHZ,它是由PCLK2经分频产生.如果被ADC转换的模拟电压低于低阀值或高于高阀值,AWD模拟看门狗状态位被设置. ADC通常要与DMA一起使用 这里只是简单的用库配置ADC 不断扫描来实现ADC的应用. 配置DMA: void DMA_Config(void) { DMA_InitTypeDef DMA_InitStructure;//定义DMA初始化结构体 DM

HAL驱动库学习-ADC

如何使用ADC驱动库 1  实现如下两个函数 a: HAL_ADC_MspInit()使能ADC时钟,设置时钟源, 使能ADC Pin,设置为输入模式,可选 DMA,中断 b:HAL_ADC_MspDeInit() 与 HAL_ADC_MspInit()作用相反,用来关闭ADC,可选 DMA,中断 2  配置ADC参数,详细参数描述参考ADC属性定义.通过HAL_ADC_Init()来加载参数 3  配置ADC通道,包括使用的通道,采样时间等 HAL_ADC_ConfigChannel() 4

[TM4C123单片机实战] 两路ADC检测,短路报警

如果最终得到的数据是两路数据的差值, 我们可以采用ADC的 Difference 工作模式 #include <stdbool.h> #include <stdint.h> #include "inc/hw_memmap.h" #include "driverlib/adc.h" #include "driverlib/gpio.h" #include "driverlib/pin_map.h" #in