Pular para o conteúdo principal

Grove- I2C ADC

O Grove - I2C ADC é um módulo ADC de precisão de 12 bits baseado no ADC121C021. Ele ajuda você a aumentar a precisão dos valores coletados de sensores analógicos, fornecendo uma tensão de referência constante. Como seu endereço é alterável, você pode usar até 9 I2C ADCs ao mesmo tempo, no máximo. Por outro lado, este módulo fornece função de suspensão automática, o que reduz consideravelmente o consumo de energia.

Adquira agora 🖱️

Versão​

VersãoEndereço I2C padrão
Grove - I2C ADC v1.0/v1.10x55
Grove - I2C ADC v1.20x50

Recursos​

  • Baixo consumo de energia
  • Alta precisão
  • Modo de desligamento automático
  • Endereço alterável
dica

Para mais detalhes sobre os módulos Grove, consulte o Grove System

Especificações​

ItemTípicoUnidade
Tensão de trabalho5.0VCC
Resolução12Bit
Taxa de amostragem188.9ksps
Dimensão40X20mm

Plataformas compatíveis​

ArduinoRaspberry Pi
cuidado

As plataformas mencionadas acima como suportadas são uma indicação da compatibilidade teórica ou de software do módulo. Na maioria dos casos, fornecemos apenas bibliotecas de software ou exemplos de código para a plataforma Arduino. Não é possível fornecer bibliotecas de software / código de demonstração para todas as possíveis plataformas de MCU. Portanto, os usuários precisam escrever suas próprias bibliotecas de software.

Visão geral de hardware​

J1: usado para conectar à interface IIC do Arduino como interface de saída do Grove - I2C ADC.

J2: usado para conectar o sensor analógico como interface de entrada do Grove - I2C ADC.

U1: CI ADC121C021, Conversor Analógico-Digital de 12 bits

A área da linha preta é usada para definir o endereço IIC. ADDR0 e ADDR1 são enviados conectados a L. Você pode alterá-los para "H" ou flutuante com uma pequena modificação na placa (flutuante significa nem conectado a "H" nem conectado a "L"). Encontre detalhes na Referência.

Primeiros Passos​

Com Arduino​

O Grove - I2C ADC possui duas interfaces: soquete de entrada (J2) e soquete de saída (J1). Conecte um sensor analógico ao seu soquete de entrada e conecte o I2C ADC ao Arduino/Seeeduino também através de cabos Grove.

Pegando o Grove - Gas Sensor como exemplo, vamos aprender agora como ler dados do sensor usando o Grove - I2C ADC. A instalação de hardware deve ser assim:

Agora você pode ler o valor do sensor de gás usando o código abaixo.

#include <Wire.h>

#define ADDR_ADC121             0x50 // For v1.0 & v1.1, I2C address is 0x55

#define V_REF 3.00

#define REG_ADDR_RESULT         0x00
#define REG_ADDR_ALERT          0x01
#define REG_ADDR_CONFIG         0x02
#define REG_ADDR_LIMITL         0x03
#define REG_ADDR_LIMITH         0x04
#define REG_ADDR_HYST           0x05
#define REG_ADDR_CONVL          0x06
#define REG_ADDR_CONVH          0x07

unsigned int getData;
float analogVal=0;         // convert
void init_adc()
{
  Wire.beginTransmission(ADDR_ADC121);        // transmit to device
  Wire.write(REG_ADDR_CONFIG);                // Configuration Register
  Wire.write(0x20);
  Wire.endTransmission();  
}

void read_adc()     //unsigned int *data
{


    Wire.beginTransmission(ADDR_ADC121);        // transmit to device
    Wire.write(REG_ADDR_RESULT);                // get result
    Wire.endTransmission();

    Wire.requestFrom(ADDR_ADC121, 2);           // request 2byte from device
    delay(1);
    if(Wire.available()<=2)
    {
      getData = (Wire.read()&0x0f)<<8;
      getData |= Wire.read();
    }
    Serial.print("getData:");
    Serial.println(getData);
    delay(5);
    Serial.print("The analog value is:");
    Serial.print(getData*V_REF*2/4096); 
    Serial.println("V");
}
void setup()
{
  Serial.begin(9600);
  Wire.begin();
  init_adc();
}

void loop()
{  read_adc();//adcRead);
   delay(50);
}

No código acima, definimos o Vref como 3,0 V, que é determinado pelo módulo I2C ADC. Essa tensão de referência é mais precisa do que a gerada pelo microcontrolador. E você pode torná-la ainda mais precisa medindo a tensão entre VA e GND e usando esse valor para substituir 3,00 no código acima.

Agora você pode enviar o código.

Depois, abra o monitor serial e leia os valores:

note

O endereço do Grove - I2C ADC é alterável, o que significa que você pode redefinir seu endereço. Isso requer alguma modificação de hardware na placa. Se você está pensando em usar mais de um I2C ADC ao mesmo tempo, siga as instruções na parte de Referência abaixo para fazer isso. O número máximo de I2C ADCs que podem ser usados simultaneamente é 9, mas há apenas 4 soquetes I2C no Grove - Base Shield V1.2, então, se você quiser usar mais de 4 I2C ADCs, use um Grove - I2C Hub para criar mais soquetes I2C.

Com Beaglebone Green​

Para começar a editar programas que estão no BBG, você pode usar o Cloud9 IDE. Como um exercício simples para se familiarizar com o Cloud9 IDE, criar uma aplicação simples para piscar um dos 4 LEDs programáveis pelo usuário no BeagleBone é um bom começo.

Se esta é a primeira vez que você usa o Cloud9 IDE, siga este link.

Passo 1: Defina o soquete Grove - UART como um soquete Grove - GPIO, simplesmente siga este link.

Passo 2: Clique no "+" no canto superior direito para criar um novo arquivo.

Passo 3: Copie e cole o código a seguir na nova aba

from Adafruit_I2C import Adafruit_I2C
import time

ADDR_ADC121 = 0x50

REG_ADDR_RESULT = 0x00
REG_ADDR_ALERT = 0x01
REG_ADDR_CONFIG = 0x02
REG_ADDR_LIMITL = 0x03
REG_ADDR_LIMITH = 0x04
REG_ADDR_HYST = 0x05
REG_ADDR_CONVL = 0x06
REG_ADDR_CONVH = 0x07

i2c = Adafruit_I2C(ADDR_ADC121)           

class I2cAdc:
    def __init__(self):
        i2c.write8(REG_ADDR_CONFIG, 0x20)

    def read_adc(self):
        "Read ADC data 0-4095."
        data_list = i2c.readList(REG_ADDR_RESULT, 2)
        #print 'data list', data_list
        data = ((data_list[0] & 0x0f) << 8 | data_list[1]) & 0xfff
        return data

if __name__ == '__main__':
    # Connect the Grove - I2C ADC to I2C Grove port of Beaglebone Green.
    adc = I2cAdc()
    while True:
        print 'sensor value ', adc.read_adc()
        time.sleep(.2)

Passo 4: Salve o arquivo clicando no ícone de disco e dando ao arquivo um nome com a extensão .py.

Passo 5: Conecte o Grove I2C ADC ao soquete Grove I2C no BBG.

Passo 6: Execute o código. Você verá que o terminal exibe o valor AD a cada 2 segundos.

Referência​

Configuração de endereço I2C​

O I2C do ADC possui um endereço de hardware de sete bits que é determinado por ADR0 e ADR1. ADR0 e ADR1 são conectados a L dentro da placa por padrão. Mas você pode alterá-los. Por exemplo, use uma faca para cortar a conexão entre L e ADR0 (como mostrado na figura abaixo), então você coloca o estado de ADR0 como flutuante (conectado a nada). E se você soldar ADR0 e H dessa vez, então você faz o valor de ADR0 ser H.

Você pode encontrar a relação entre o endereço de hardware I2C e os valores de ADR0 e ADR1 na tabela a seguir.

Endereço escravo [A6 - A0]

Estado de entrada de ADR0 e ADR1

ADR1

ADR0

1010000(0x50)

Flutuante

Flutuante

1010001(0x51)

Flutuante

L

1010010(0x52)

Flutuante

H

1010100(0x54)

L

Flutuando

1010101(default 0x55)

L

L

1010110(0x56)

L

H

1011000(0x58)

H

Flutuando

1011001(0x59)

H

L

1011010(0x5A)

H

H

Quanto o I2C ADC aumenta a precisão?​

Aqui está um experimento que fazemos para dar a você uma ideia de quanto o I2C ADC aumenta a precisão de um sensor analógico. Primeiro, vamos verificar os valores coletados diretamente pela porta analógica no Arduino/Seeeduino de um Grove - Gas Sensor(MQ5)

Fazemos o upload do código abaixo para obter os dados.

    /*
     * Grove - Gas Sensor(MQ5)  
     *
     * The Gas Sensor detect the related Gas density, 
     * Arduino get the result by analogread. the gas Density is 
     * 0~1, larger the output is, the denser the gas.
     * Connect the Sensor to A0 in this demo;
     * 
     *  By: https://www.seeedstudio.com
    */
    #define Vref 4.95
    void setup() {
      Serial.begin(9600);
    }

    void loop() {
      float vol;
      int sensorValue = analogRead(A0);
      vol=(float)sensorValue/1023*Vref;
      Serial.print("The sensorValue is ");
      Serial.println(sensorValue);
      Serial.print("The analog value is ");
      Serial.print(vol);
      Serial.println("V");
      delay(100);
    }

O resultado é:

Por padrão, Vref é gerado pelo Arduino, que teoricamente é 5V. Mas, na verdade, é um valor flutuante, o que resulta no desvio dos dados finais. Esse tipo de imprecisão é evitado ao usar o Grove - I2C ADC, porque ele fornece 3,0V exatos como Vref. Para comparação, na mesma condição, os valores do sensor coletados pelo circuito com o Grove - I2C ADC no osciloscópio são mostrados abaixo:

Para descobrir qual resultado está mais próximo da condição real, aqui usamos um multímetro para medir a tensão entre o pino SIG e o pino GND do sensor.

Visualizador de Esquemático Online​

Recursos​

Projeto​

BeagleBone Green Temperature Monitor on Artik Cloud Publica valores do Grove Temperature Sensor coletados por um BeagleBone Green na Artik Cloud.

Suporte Técnico & Discussão de Produto​

Obrigado por escolher nossos produtos! Estamos aqui para oferecer diferentes tipos de suporte para garantir que sua experiência com nossos produtos seja a mais tranquila possível. Oferecemos vários canais de comunicação para atender a diferentes preferências e necessidades.

Loading Comments...