https://translate.google.com.br/translate?

sl=auto&tl=pt&js=y&prev=_t&hl=pt-BR&ie=UTF-8&u=http%3A%2F
%2Freal2electronics.blogspot.com.br%2F2011%2F09%2Farduino-adcmuestreo-alta-velocidad.html&edit-text=&act=url

L o valor do pino analgico especificado. A placa Arduino contm um canal 6 (8

canais no Mini e Nano, 16 na mega), 10-bit conversor analgico-digital. Isso significa
que ele ir mapear tenses de entrada entre 0 e 5 volts em valores inteiros entre 0 e
1023. Isto produz uma resoluo entre as leituras de: 5 volts / 1024 unidades ou, 0,0049
volts (4,9 mV) por unidade. O alcance ea resoluo de entrada pode ser alterado usando
analogReference ().
Demora cerca de 100 microssegundos (0,0001 s) para ler uma entrada analgica, ento a
taxa mxima de leitura cerca de 10.000 vezes por segundo.
Sintaxe

analogRead (pino)

ADC Arduino: amostragem de alta velocidade

O objetivo deste mini-tutorial configurar o conversor analgico-digital mdulo mais

rpido do que o padro configurado no Arduino, aps os diferentes testes foram feitos
neste post frum Arduino entre aero_yo, CesarCarlos e um servidor. Por sua vez, amplia
o tutorial anterior graficamente os dados recebidos do Arduino em tempo real usando o
software livre KST publicado anteriormente aqui .
Programa Arduino usa principalmente C e microcontroladores diretamente registros,
tentando obter o mximo desempenho.
Como pode ser visto na folha de dados, Atmel recomenda que a velocidade do clock
ADC entre 50-200 kHz, para uma resoluo de 10 bits. O nosso Arduino oscilador (16
MHz), tambm alimenta o mdulo de conversor, que passa atravs de um divisor de
frequncia (divisor).
Prescaler disse configurada com trs bits do registo ADCSRA. As combinaes nos
permitem dividir por 2, 4,8,16,32,64 e 128.
Por exemplo, um divisor de 64 nos daria uma frequncia de alimentao a 250 kHz
ADC (16 MHz / 64 = 250 kHz), que um pouco acima da recomendao.
Voc pode trabalhar em freqncias mais altas, mas a perda de resoluo, que o que
fazemos aqui. Ele vai trabalhar com uma resoluo de 8 bits, para ter maiores taxas de
converso e, por sua vez, minimizar o tempo necessrio para enviar os dados

convertidos atravs de srie de dispor dele o mais rpido possvel (sem ter que ir at
assembler).
A converso normal, custa 13 ciclos de relgio, e usar uma nica entrada analgica (5).
O resultado gerado aps a converso armazenado em ADCH e regitros LCAD, mas
apenas 8 bits que voc quer, basta ler o registo ADCH (justificados esquerda).
Este resultado da converso (ADC) sero enviados via serial (UART), sem converter os
dados para ASCII, para minimizar os tempos mximos de programa.
Um script em Python (gratuito e multiplataforma macio) ser responsvel pela coleta
disse byte, fazer milivolts e armazenadas em um arquivo. Especificamente, a escrita
usada a seguinte:
Cdigo:
#!

/ Usr / bin / env python

srie de importao
sys importao
serial.Serial ser = ('/ dev / ttyUSB0', 1000000);
enquanto 1:
tente:
n = ser.read ();
n = ord (n) * 5000/255; #Convierto MV
impresso n;
exceto KeyboardInterrupt:
ser.close ();
sys.exit (0)

Para usar esse cdigo, voc precisa instalar o python e biblioteca PySerial. Como voc
pode ver, estamos trabalhando para 1Mbps. Ele tem de mudar o nome da porta serial
onde temos conectado nossa Arduino, por exemplo, no caso do Windows, "COM3 ''
COM4 ', etc.
Ou seja, mudar a linha do formulrio ser = serial.Serial ("COM2", 1000000);
Se voc tem esse script em um arquivo, por exemplo chamado adquisicion.py,
executado a partir do terminal:

./adquisicion.py >> mifichero.csv

O arquivo que contm o script deve ter permisses de execuo (Linux).
Quando queremos terminar a execuo do script na imprensa terminal de CTRL + C.
Este script foi testado no Ubuntu e Windows em execuo em ambos perfeitamente.
No Arduino, o programa necessrio o seguinte:
// -----------------------------------------------// Aquisio rpida
// Por: Igor R.
// 03/09/2011
// ------------------------------------------------

#define CHRONO 0
void setup ()
{
Serial comear (1000000) ;. // 1 Mbps
//
//
//
//
//
//
//
//
//
//
//
//

Prescaler
ADPS2 - ADPS1 - ADPS0 - Diviso Fator
0-0 - 0 -> 2
0-0 - 1 -> 2
0 - 1 - 0 -> 4
0 - 1 - 1 -> 8
1-0 - 0 -> 16
1-0 - 1 -> 32
1 - 1-0 -> 64
1-1 - 1 -> 128
Definir a Prescaler = 16 (Hz 11.793,57 115200)
Definir a Prescaler = 16 (Hz 66.418,71 1000000)

bitWrite (ADCSRA, ADPS2,1);

bitWrite (ADCSRA, ADPS1,0);
bitWrite (ADCSRA, ADPS0,0);
// Entrada Analgica A5
ADMUX = (1 << ADLAR) | (0 << REFS1) | (1 << REFS0) | (0 << MUX3) | (1
<< MUX2) | (0 << MUX1) | (1 << MUX0) ;
}
void loop ()
{
#if CHRONO == 1
MeasureTime ();
for (;;)
{
}
#else
int i;
for (;;)
{
while ((UCSR0A & (1 << UDRE0))!);
AnalogReadFast UDR0 = ();
i ++;
if (i == - 1);
}
#Acabar se
}
// Leia ADC
int analogReadFast ()
{
ADCSRA | = (1 << ADSC);

// ADSC apagada quando os acabamentos de converso

enquanto (bit_is_set (ADCSRA, ADSC));
retornar ADCH;
}
// Funo Chrono
Vazio MeasureTime ()
{
int no assinado i = 1;
tStart longo no assinado;
no assinado TEND longo;
// -------------------------------------------// CHRONO
Tincio = micros ();
for (;;)
{
while ((UCSR0A & (1 << UDRE0))!);
AnalogReadFast UDR0 = ();
i ++;
if (i == 1000) quebrar;
}
Tendem = micros ();
// END CHRONO
// -------------------------------------------. Serial comear (115.200);
atraso (100);
. Println srie ("");
Impresso de srie ("tStart =.");
. Println Serial (tStart);
Impresso de srie ("Tendem =.");
. Println Serial (Tendncia);
Impresso de srie ("Pontos =.");
. Println srie (i);
Impresso de srie ("Frecuecy =.");
Impresso de srie ((float) 1000000000,0 / ((float) tenderam (float)
tStart).);
. Println srie ("Hz");
}

Ele observa que o programa tem a varivel CHRONO. Para operao normal, enviando
constantemente o valor adquirido deve ser zero (0). Quando ajustado para 1 (uma), o
que torna ejectuar o cdigo usado para adquirir e enviar srie para 1000 vezes e
cronometrando o resultado. Tal resultado pode ser lido via console serial Arduino,
porque embora tenhamos configurou a porta para 1 Mbps, quando o tempo termina, o
resultado enviado para 115.200 bps.
Transmitir a 1Mbps, e um divisor 16 da ADC, eu recebo 66.417,71 frequncia Hz (cerca
de 66,5 kHz). importante ter a coragem de clculos frecuenciales ou ter as unidades a
tempo.

Em suma, temos de ter carregado no programa Arduino acima, executar o script python
gravar a sada no arquivo desejado, lanar o KST e abra o arquivo. Os dados sero
atualizados em "tempo real".
Em seguida, alguns screenshots delineando os passos usando Ubuntu (clique para
ampliar imagens):
Passo 1:

Passo 2:

Passo 3:

Passo 4:

Passo 5:

E agora s esperar para ver como os grficos sero atualizados com os dados recebidos
do nosso Arduino. No exemplo abaixo, a captura de dados da onda de seno de a corrente
elctrica (de um transformador), que pode ser visto o resultado do PSD (Densidade de
Energia Espectral):

Abaixo est o esboo de conexo entre a rede eo Arduino atravs de um transformador:

As resistncias divisoras de tenso criadas com 1K, adicionar um deslocamento de 2.5V

no sinal sinusoidal a partir do transformador. A sada do transformador um seno 12V
CA, de modo que adicionar este deslocamento para obter o sinal para a nossa Arduino.
O segundo divisor criada usando um potencimetro ajustado para ter a amplitude do
sinal entre 0 e 5 volts (centrado sobre 2.5V).
Cuidado com esta montagem, o que pode ser perigoso.

Como outro exemplo, 4 kHz tom gerado pela placa de som, graas ao Audacity . Quero
dizer, eu usei a placa de som como um gerador de ondas (conect-lo ADC
microcontrolador). Audacity si tem uma ferramenta de anlise de frequncia, para que
voc possa facilmente ver como os resultados devem estar em KST Arduino.

Ela deve ter um estgio de filtragem para evitar a suavizao.

Voc chegou a visitar o frum postar o original eo outro post , onde poder encontrar
diversos testes criados por aero_yo e CesarCarlos, como medidas de harmnicos de uma
guitarra, capturando a luz de uma lmpada incandescente por uma frequncia LDR
medida esvoaar de uma abelha, microfone aquisio, etc.

O microcontrolador Arduino apresenta um nico de 10 bit ADC aproximao

sucessiva. Antes da ADC existe um multiplexer analgico que permite
enviar, para o ADC, os sinais de diferentes pinos e fontes (mas apenas um
de cada vez).
Sucessiva ADC aproximao significa que a ADC leva 13 ciclos de relgio
para completar a converso (e 25 ciclos de clock para a primeira
converso). No um sinal de relgio dedicado para o ADC que
"calculada" do relgio principal do Arduino; isso ocorre porque o ADC um
pouco lento e no pode manter-se com o ritmo das outras partes do
microcontrolador. Ela exige uma freqncia de clock de entrada entre 50
kHz e 200 kHz para obter uma resoluo mxima. Se for necessria uma
resoluo menor do que 10 bits, a freqncia de clock de entrada para o
ADC pode ser superior a 200 kHz para obter uma taxa de amostragem mais
elevada.
Mas como taxas muito mais elevadas que podemos usar? H um par de
bons guias sobre a ADC no Aberto da Msica Labs que eu sugiro para ler:

http://www.openmusiclabs.com/learning/digital/atmega-adc/

http://www.openmusiclabs.com/learning/digital/atmega-adc/in-depth/

Visto que meu propsito obter um osciloscpio rpido eu decidi limitar a

preciso de 8-bits. Isso tem vrios bnus:
1. o buffer de dados pode armazenar mais dados;

2. voc no perca 6-bits de RAM por datum;

3. o ADC pode adquirir rapidamente.
O prescaler nos permite dividir a frequncia, por alguns fatores, definindo os
bits ADPS0-1-2 do registo ADCSRA. Vendo o enredo da preciso do Open
Music Labs artigo, podemos ver que, para 8-bits de preciso a freqncia
poderia ir at 1,5 MHz, que bom! Mas uma vez que a capacidade de mudar
o fator divisor permite-nos alterar a taxa de aquisio, podemos us-lo
tambm para mudar a escala de tempo do osciloscpio.
H uma boa caracterstica sobre os registros de sada: podemos decidir o
ajuste de bits de converso, definindo o bit ADLAR no registo ADMUX. Se for
0 so ajustados direita e vice-versa (veja a imagem). Desde que eu queria
preciso de 8-bits de eu defini-lo como um para que eu pudesse ler apenas
o registo ADCH e ignorar o LCAD.
Eu decidi ter apenas um canal de entrada para evitar ter de mudar de canal
e para trs em cada converso.
Uma ltima coisa sobre o ADC, tem diferentes modos de cada um com uma
fonte de disparo diferente de funcionamento:

Modo Free Running

Comparador Analgico

Interrupo externa Request 0

Timer / Counter0 Compare Jogo A

Timer / Counter0 Overflow

Timer / counter1 Compare Jogo B

Timer / counter1 Overflow

Timer / counter1 Captura de Eventos

Eu estava interessado no modo de corrida livre que um modo no qual o

ADC converte continuamente a entrada e gera uma interrupo no final de
cada converso (vector associado: ADC_vect).