MILK-V WIRINGx - DHT22 e SERVO MOTOR

WiringX é uma biblioteca que permite aos desenvolvedores controlar o GPIO de diversas plataformas com funções genéricas e uniformes. Ao usar o wiringX, o mesmo código será executado em todas as plataformas suportadas pelo wiringX, nativamente.

Demonstração do sensor DHT11

Na placa de desenvolvimento Duo

Link do GitHub: https://github.com/milkv-duo/duo-files/blob/main/duo/hardware/duo-schematic-v1.2.pdf

DHT11, sensor de temperatura e umidade DHT22

Link dfrobotwiki: https://wiki.dfrobot.com.cn/\_SKU_SEN0137\_%E9%AB%98%E7%B2%BE%E5%BA%A6DHT22%E6%B8%A9%E6%B9%BF% E5%BA%A6%E4%BC%A0%E6%84%9F%E5%99%A8

O Sensor de Temperatura e Umidade DHT22 é um sensor versátil e econômico usado para medir temperatura e umidade ambiental. É baseado em saída de sinal digital, fornecendo medições de alta precisão com resolução de temperatura de 0,1 graus Celsius e resolução de umidade de 0,1%. O sensor usa um elemento sensor de umidade capacitivo e um termistor para medir umidade e temperatura, respectivamente. O sensor DHT22 também possui consumo de energia relativamente baixo e pode operar em uma faixa de tensão de 3,3 V a 5 V, tornando-o adequado para projetos alimentados por bateria. Além disso, o sensor oferece estabilidade a longo prazo e alta confiabilidade, tornando-o uma escolha ideal para diversas aplicações, incluindo sistemas HVAC, estações meteorológicas e sistemas de monitoramento da qualidade do ar interno.

Módulo

O módulo DHT22 possui um total de 3 pinos, enquanto o sensor nu DHT22 possui 4 pinos. Ao considerar o módulo com três pinos, dois são pinos de alimentação e um é o pino de dados. Para o sensor de 4 pinos, o pino adicional é um pino NC (Sem Conexão) sem função específica. A pinagem do módulo e do sensor é a seguinte: 

- DADOS: Pino de dados para comunicação de 1 fio.

- GND: Pino terra do módulo.

- VCC: Pino de alimentação do módulo.

- Não utilizado: Este pino não é utilizado neste sensor.

Componentes do módulo sensor DHT22

Além do sensor, o módulo DHT22 na PCB inclui apenas dois componentes: um resistor pull-up e um capacitor de desacoplamento. As marcações dos componentes do módulo DHT22 são as seguintes.

Diagrama de circuito do módulo DHT22

O diagrama esquemático completo do módulo Sensor de Temperatura e Umidade DHT22 é mostrado no diagrama abaixo.

O diagrama esquemático do módulo DHT22 é mostrado acima. Conforme mencionado anteriormente, a placa possui apenas alguns componentes. Os pinos VCC e GND estão conectados diretamente ao sensor DHT22 e o resistor pull-up está conectado ao pino DATA. Capacitores de tântalo e multicamadas fornecem filtragem suficiente. Em algumas PCBs, você pode encontrar um indicador LED como indicador de energia, mas para a maioria das placas de circuito, o LED não está presente.

Perguntas comuns sobre DHT22

P: Em termos simples, o que é DHT22?

R: DHT22 é uma versão mais cara do sensor DHT11 com melhores especificações. Sua faixa de medição de temperatura é de -40 a +125 graus Celsius com precisão de ±0,5 graus, enquanto o DHT11 tem faixa de temperatura de 0 a 50 graus Celsius com precisão de ±2 graus.

P: O DHT22 é analógico ou digital?

R: DHT-22 (também conhecido como AM2302) é um sensor de umidade relativa e temperatura de saída digital.

P: O DHT22 é à prova d'água?

R: Não, não é à prova d'água.

P: Qual é a taxa de amostragem do sensor DHT11?

R: A taxa de amostragem do DHT22 é de 1 Hz.

P: Qual protocolo o DHT22 usa?

R: O sensor DHT22 usa um protocolo proprietário de comunicação de fio único que envia e recebe dados por meio de pulsos temporizados.

Como funciona o DHT22

Se você estiver usando um sensor DHT22 original, ele contém um termistor NTC e um módulo sensor. Porém, a maioria dos sensores disponíveis no mercado são peças não originais e contêm um pequeno sensor, conforme mostra a imagem abaixo.

O elemento sensor de umidade consiste em um substrato absorvente de umidade imprensado entre dois eletrodos. À medida que o substrato absorve umidade, a resistência entre os dois eletrodos diminui. A mudança de resistência entre os eletrodos é proporcional à umidade relativa. Uma umidade relativa mais alta diminui a resistência entre os eletrodos, enquanto uma umidade relativa mais baixa aumenta a resistência. Esta mudança de resistência é medida pelo ADC do MCU integrado e usada para calcular a umidade relativa.

Cada componente DHT22 passa por calibração rigorosa em laboratório, com calibração de umidade extremamente precisa. Os coeficientes de calibração são armazenados como programas na memória OTP para uso no processo de detecção de sinal interno do sensor.

Protocolo de comunicação de fio único DHT22 (one wire)

Um protocolo de comunicação de fio único é usado para comunicação com o DHT22 e o microcontrolador. A amostragem de dados leva aproximadamente 4 milissegundos para ser concluída. Os dados consistem em partes decimais e inteiras e totalizam 40 bits de comprimento, no formato MSB. O formato dos dados é o seguinte: dados RH inteiros de 8 bits + dados RH decimais de 8 bits + dados T inteiros de 8 bits + dados T decimais de 8 bits + soma de verificação de 8 bits. Se a transmissão de dados estiver correta, a soma de verificação deve ser os últimos 8 bits de "dados RH inteiros de 8 bits + dados RH decimais de 8 bits + dados T inteiros de 8 bits + dados T decimais de 8 bits".

Quando o MCU envia o sinal de início, o DHT muda do modo de baixo consumo de energia para o modo de execução e despeja todos os 40 bits de dados no microcontrolador. O microcontrolador lê os dados e calcula a temperatura e a umidade com base nos dados binários.

A imagem acima mostra como funciona a comunicação de dados com o microcontrolador e o DHT22.

Conectando-se à placa de desenvolvimento

DHT22: Fio vermelho para 3V3 (OUT), fio preto para terra, fio verde para GPIOA15.

O diagrama do circuito é o seguinte: O círculo preto representa o DHT22.

O DHT22 deve ser conectado da seguinte forma:

Exemplo de código

Link do GitHub:  https://github.com/milkv-duo/duo-examples

dht22.c:

// Ref: https://github.com/technion/lol_dht22/blob/master/dht22.c
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <wiringx.h>
#define MAXTIMINGS 85
static int DHTPIN = 15;
static int dht22_dat[5] = {0, 0, 0, 0, 0};
static uint8_t sizecvt(const int read)
{
    /* digitalRead() and friends from wiringpi are defined as returning a value
    < 256. However, they are returned as int() types. This is a safety function */

    if (read > 255 || read < 0)
    {
        printf("Invalid data from wiringPi library\n");
        exit(EXIT_FAILURE);
    }
    return (uint8_t)read;
}

static int read_dht22_dat()
{
    uint8_t laststate = HIGH;
    uint8_t counter = 0;
    uint8_t j = 0, i;

    dht22_dat[0] = dht22_dat[1] = dht22_dat[2] = dht22_dat[3] = dht22_dat[4] = 0;

    // pull pin down for 18 milliseconds
    pinMode(DHTPIN, PINMODE_OUTPUT);
    digitalWrite(DHTPIN, HIGH);
    // delay(500);
    delayMicroseconds(500000);
    digitalWrite(DHTPIN, LOW);
    // delay(20);
    delayMicroseconds(20000);
    // prepare to read the pin
    pinMode(DHTPIN, PINMODE_INPUT);

    // detect change and read data
    for (i = 0; i < MAXTIMINGS; i++)
    {
        counter = 0;
        while (sizecvt(digitalRead(DHTPIN)) == laststate)
        {
            counter++;
            delayMicroseconds(2);
            if (counter == 255)
            {
                break;
            }
        }
        laststate = sizecvt(digitalRead(DHTPIN));

        if (counter == 255)
            break;

        // ignore first 3 transitions
        if ((i >= 4) && (i % 2 == 0))
        {
            // shove each bit into the storage bytes
            dht22_dat[j / 8] <<= 1;
            if (counter > 16)
                dht22_dat[j / 8] |= 1;
            j++;
        }
    }

    // check we read 40 bits (8bit x 5 ) + verify checksum in the last byte
    // print it out if data is good
    if ((j >= 40) &&
        (dht22_dat[4] == ((dht22_dat[0] + dht22_dat[1] + dht22_dat[2] + dht22_dat[3]) & 0xFF)))
    {
        float t, h;
        h = (float)dht22_dat[0] * 256 + (float)dht22_dat[1];
        h /= 10;
        t = (float)(dht22_dat[2] & 0x7F) * 256 + (float)dht22_dat[3];
        t /= 10.0;
        if ((dht22_dat[2] & 0x80) != 0)
            t *= -1;
        printf("Humidity = %.2f %% Temperature = %.2f *C \n", h, t);
        return 1;
    }
    else
    {
        printf("Data not good, skip\n");
        return 0;
    }
}

int main()
{
    // Duo:     milkv_duo
    // Duo256M: milkv_duo256m
    // DuoS:    milkv_duos
    if (wiringXSetup("milkv_duo", NULL) == -1)
    {
        wiringXGC();
        return -1;
    }

    if (wiringXValidGPIO(DHTPIN) != 0)
    {
        printf("Invalid GPIO %d\n", DHTPIN);
    }

    while (1)
    {
        read_dht22_dat();
        delayMicroseconds(1500000);
    }

    return 0;
}

Makefile:

TARGET=dht22

ifeq (,$(TOOLCHAIN_PREFIX))
$(error TOOLCHAIN_PREFIX is not set)
endif

ifeq (,$(CFLAGS))
$(error CFLAGS is not set)
endif

ifeq (,$(LDFLAGS))
$(error LDFLAGS is not set)
endif

CC = $(TOOLCHAIN_PREFIX)gcc
CFLAGS += -I$(SYSROOT)/usr/include
LDFLAGS += -L$(SYSROOT)/lib
LDFLAGS += -L$(SYSROOT)/usr/lib
LDFLAGS += -lwiringx

SOURCE = $(wildcard *.c)
OBJS = $(patsubst %.c,%.o,$(SOURCE))

$(TARGET): $(OBJS)
	$(CC) -o $@ $(OBJS) $(LDFLAGS)

%.o: %.c
	$(CC) $(CFLAGS) -o $@ -c $<

.PHONY: clean
clean:
	@rm *.o -rf
	@rm $(OBJS) -rf
	@rm $(TARGET)

Ambiente de Build no UBUNTU 20.04 (WSL)

Você também pode usar Ubuntu instalado em uma máquina virtual, Ubuntu instalado via WSL no Windows ou sistemas baseados em Ubuntu usando Docker.

• Instale as ferramentas que compilam dependências.

  sudo apt-get install wget git make
  
  
  
  

• Obtenha exemplo de código-fonte

  git clone https://github.com/milkv-duo/duo-examples.git
  

• Preparar ambiente de compilação

  cd duo-examples
  source envsetup.sh
  
  
  

  Na primeira vez que você o adquirir, o pacote SDK necessário será baixado automaticamente, com aproximadamente 180 MB de tamanho. Depois de baixado, ele será extraído automaticamente para o diretório duo-examples com o nome duo-sdk. Na próxima vez, se o diretório já existir, ele não será baixado novamente.

• Teste de compilação

  Tome hello-world como exemplo, entre no diretório hello-world e execute make

  cd hello-world
  make
  
  
  

  Após a compilação ser bem-sucedida, envie o programa executável gerado  helloworld para o dispositivo Duo através da porta de rede ou da rede RNDIS. Por exemplo, o método RNDIS suportado pelo firmware padrão , o IP do Duo é 192.168.42.1, o nome de usuário é root e a senha é milkv

  scp helloworld root@192.168.42.1:/root/
  

  Após o envio com sucesso, execute ./helloworld no terminal logado via ssh ou porta serial, e ele irá imprimir Hello, World!

  [root@milkv]~# ./helloworld
  Hello, World!

  Neste ponto, nosso ambiente de compilação e desenvolvimento está pronto para uso.

Procedimento de Operação

Em seguida, compile-o. Tomando dht22 como exemplo, entre no diretório do exemplo e simplesmente execute make

cd dht22
make it

Faça um relatório de erros e forneça-o. Após compilar com sucesso, você obterá o programa executável df9gms. Conforme mostrado na figura abaixo.

Em seguida, carregue df9gms no caminho raiz da placa de desenvolvimento e digite ./dht22 para executá-lo. A captura de tela da execução bem-sucedida é mostrada abaixo

DF9GMS 180

Informação de hardware

Pinos da placa de desenvolvimento Duo

GitHub: https://github.com/milkv-duo/duo-files/blob/main/duo/hardware/duo-schematic-v1.2.pdf

DF9GMS 180

Micro Servo DF9GMS da DFRobot, este servo possui uma caixa transparente ABS de alta resistência com conjunto interno de engrenagens de náilon de alta precisão, circuito de controle de precisão e motor de copo oco leve e de última geração, resultando em um peso de apenas 9g para este mini servo, enquanto o torque de saída atinge incríveis 1,6kg/cm.

Especificações técnicas:

Tensão operacional: 4,8V

Torque: 1,6kg/cm (4,8V)

Velocidade: 0,14 segundos/60 graus (4,8V)

Temperatura operacional: -30 a +60 graus Celsius

Largura da banda morta: 0,5 milissegundos

Tamanho físico: 23x12,2x29mm

Peso: 9g

Composição e Princípio de Funcionamento do Micro Servo

Diagrama de conexão

• Hardware

o 1 x placa de controle Arduino UNO

o 1 x micro servo DF9GMS

o Vários fios Dupont

o Cinza - GND, vermelho - VCC, amarelo - linha de sinal

conectado à  placa de desenvolvimento

DF9GMS: fio vermelho conectado ao VSYS, fio marrom conectado ao terra, fio laranja conectado ao GPIO19.

Diagrama de circuito mostrado abaixo: o círculo roxo representa DF9GMS.

O DF9GMS deve ser conectado da seguinte forma:

Exemplo de código

Link do GitHub:  https://github.com/milkv-duo/duo-examples

df9gms.c:

#include <stdio.h>
#include <unistd.h>
#include <wiringx.h>
/*
Duo
------------------------------------------
PWM operation at a fixed frequency clock of 100MHz, writing Period in units of nanoseconds.
	DF9GMS 360-degree PWM Duty Cycle 
	------------------------------------------ 
	0.4ms - 1.4ms CW deceleration 
	1.5ms Stop 
	1.6ms - 3ms CCW acceleration 
*/
static int PWM_PIN = 4; // PWM5@GP4

int main()
{
    long i;

    // Duo:     milkv_duo
    // Duo256M: milkv_duo256m
    // DuoS:    milkv_duos
    if(wiringXSetup("milkv_duo", NULL) == -1) {
        wiringXGC();
        return -1;
    }

    wiringXPWMSetPeriod(PWM_PIN, 20000000);  // 20ms
    wiringXPWMSetDuty(PWM_PIN, 1500000);     // 1.5ms stop
    wiringXPWMSetPolarity(PWM_PIN, 0);       // 0-normal, 1-inversed
    wiringXPWMEnable(PWM_PIN, 1);            // 1-enable, 0-disable

    delayMicroseconds(1000000); // 1s

    for (i = 10000; i< 3000000; i += 10000) // 10 us 
    {
        wiringXPWMSetDuty(PWM_PIN, i);
        printf("Duty: %ld\n", i);
        delayMicroseconds(50000); // 50ms
    }

    wiringXPWMSetDuty(PWM_PIN, 1500000);    // 1.5ms stop

    return 0;
}

Makefile:

TARGET=df9gms

ifeq (,$(TOOLCHAIN_PREFIX))
$(error TOOLCHAIN_PREFIX is not set)
endif

ifeq (,$(CFLAGS))
$(error CFLAGS is not set)
endif

ifeq (,$(LDFLAGS))
$(error LDFLAGS is not set)
endif

CC = $(TOOLCHAIN_PREFIX)gcc

CFLAGS += -I$(SYSROOT)/usr/include

LDFLAGS += -L$(SYSROOT)/lib
LDFLAGS += -L$(SYSROOT)/usr/lib
LDFLAGS += -lwiringx

SOURCE = $(wildcard *.c)
OBJS = $(patsubst %.c,%.o,$(SOURCE))

$(TARGET): $(OBJS)
	$(CC) -o $@ $(OBJS) $(LDFLAGS)

%.o: %.c
	$(CC) $(CFLAGS) -o $@ -c $<

.PHONY: clean
clean:
	@rm *.o -rf
	@rm $(OBJS) -rf
	@rm $(TARGET)

Ambiente de Build no UBUNTU 20.04 (WSL)Ubuntu20.04

Você também pode usar Ubuntu instalado em uma máquina virtual, Ubuntu instalado via WSL no Windows ou sistemas baseados em Ubuntu usando Docker.

• Instale as ferramentas que compilam dependências.

  sudo apt-get install wget git make
  

• Obtenha exemplo de código-fonte

  git clone https://github.com/milkv-duo/duo-examples.git
  

• Preparar ambiente de compilação

  cd duo-examples
  source envsetup.sh

  Na primeira vez que você o adquirir, o pacote SDK necessário será baixado automaticamente, com aproximadamente 180 MB de tamanho. Depois de baixado, ele será extraído automaticamente para o diretório duo-examples com o nome duo-sdk. Na próxima vez, se o diretório já existir, ele não será baixado novamente.

• Teste de compilação

  Tome hello-world como exemplo, entre no diretório hello-world e execute make

  cd hello-world
  make

  Após a compilação ser bem-sucedida, envie o programa executável gerado helloworld para o dispositivo Duo através da porta de rede ou da rede RNDIS. Por exemplo, o método RNDIS suportado pelo firmware padrão , o IP do Duo é 192.168.42.1, o nome de usuário é root e a senha é milkv

  scp helloworld root@192.168.42.1:/root/
  

  Após o envio com sucesso, execute ./helloworld no terminal logado via ssh ou porta serial, e ele irá imprimir Hello, World!

  [root@milkv]~# ./helloworld
  Hello, World!

  Neste ponto, nosso ambiente de compilação e desenvolvimento está pronto para uso.

Procedimento de Operação

Em seguida, compile-o. Tomando df9gms como exemplo, entre no diretório do exemplo e simplesmente execute make

cd df9gms
make it

Faça um relatório de erros e forneça-o. Após compilar com sucesso, você obterá o programa executável df9gms. Conforme mostrado na figura abaixo.

Em seguida, carregue df9gms no caminho raiz da placa de desenvolvimento e digite ./df9gms para executá-lo. A captura de tela da execução bem-sucedida é mostrada abaixo

Questões: suporte@smartcore.com.br

Referências

Introduction | Milk-V (milkv.io)
Instalar o WSL | Microsoft Learn

Introduction | Milk-V (milkv.io)

Sobre a SMARTCORE

A SMARTCORE FORNECE CHIPS E MÓDULOS PARA IOT, COMUNICAÇÃO WIRELESS, BIOMETRIA, CONECTIVIDADE, RASTREAMENTO E AUTOMAÇÃO. NOSSO PORTFÓLIO INCLUI MODEM 2G/3G/4G/NB-IOT, SATELITAL, MÓDULOS WIFI, BLUETOOTH, GPS, SIGFOX, LORA, LEITOR DE CARTÃO, LEITOR QR CCODE, MECANISMO DE IMPRESSÃO, MINI-BOARD PC, ANTENA, PIGTAIL, BATERIA, REPETIDOR GPS E SENSORES.