viernes, 26 de julio de 2019

USB Serial CDC con PIC16F

Comunicación Serial USB-CDC con PIC16F



Muchas gracias por tu visita a este blog sobre programación de micro-controladores PIC, en esta ocasión quiero compartir un conocimiento respecto al uso de la comunicación serial con la clase CDC del protocolo USB. Como bien saben al día de hoy prácticamente los puertos serial RS232 no están presentes en los ordenadores, ni mucho menos en móviles y tables, porque todo ha sido reemplazado por la comunicación USB, pero este cambio no ha hecho que la comunicación serial asíncrona a niveles TTL/CMOS se pierda y mas todavía si hablamos del mundo de los sistemas embebidos y microcontroladores donde todavía son muy utilizados.

Actualmente existen una infinidad de dispositivos convertidores TTL/RS232 al protocolo USB, y básicamente emulan la comunicación serie en nuestro ordenador asignando un puerto COMxx(Windows) o ttyUSBxx(Linux).

Desde el punto de vista del diseñador electrónico, para obtener conectividad USB en el microcontrolador sera necesario agregar al circuito un chip convertidor como el CP210x, FT232, CH340, PL230x, etc, y así establecer una comunicación segura y transparente con el ordenador. Otra alternativa es buscar un microcontrolador que incluya el hardware necesario para implementar el protocolo en su memoria.

El objetivo de esta entrada es poder implementar la comunicación serial con el ordenador sin hacer uso de un convertir externo, puesto que existen muchos microcontroladores PIC que poseen los recursos para soportar la pila USB haremos uso de un modelo en particular correspondiente a la serie PIC16F creando un programa para enviar información de estado de una entrada digitale y una analógica al ordenador, en el ordenador veremos estos mensajes utilizando una aplicación terminal. También a manera de complemento crearemos una pequeña aplicación en Qt para visualizar los datos USB.


La programación se realizara utilizando el compilador XC8, el entorno de desarrollo MPLABX y la utilidad MMC(Microchip Code Configurator), todo disponible de forma gratuita en la pagina de microchip. Ahí les paso los links oficiales para la descarga de las versiones que utilizo en el ejemplo:

  • XC8 8-bit C Compiler 2.10, para Windows y para Linux
  • Entorno IDE MPLABX 5.20, para Windows y para Linux
  • MMC 3.95, En el siguiente Link explica las formas de instalar
1. Protocolo USB y la Clase CDC


El protocolo USB(Universal Serial Bus) nació con la idea de reemplazar la gran cantidad de conectores relacionados con las computadoras personales, simplificando la conexión con un mayor ancho de banda para la transferencia de datos. Actualmente existen 5 revisiones: USB1.0(1996), USB1.1(1998), USB2.0(2000), USB3.0(2008), USB4.0(2019) que van desde los 12Mbps hasta los 40Gbps.

El protocolo implementa una topologia en estrella con la posibilidad de conectar hasta 127 dispositivos administrados por un solo host, en algunos casos el rol de host se negocia entre dos dispositivos mediante un protocolo conocido como OTG.

El host(Computadora) efectúa la mayor parte de la actividad que requiere el protocolo, normalmente el sistema operativo del ordenador carga los drivers necesarios en forma dinámica cuando se conecta un dispositivo al bus(PIC), y es identificado mediante el par PID(Product ID) / VID(Vendor ID).

USB soporta cuatro modos de transferencia: Control, Interrupción(Interrupt), Masiva(Bulk) e Isócrona(Isochronous), y distribuye la alimentación de 5V a todos los dispositivos sin necesidad de una fuente externa, esto siempre y cuando el dispositivo sea de bajo consumo, aqui la limitacion va de acuerdo a la versión: 500mA(USB2.0) y 900mA(USB3.0).

Los niveles lógicos se representan por la diferencia de al menos 200mV entre las lineas D+ y D-, siendo 1 lógico cuando D- es mayor a D+ y 0 lógico cuando D- es menor a D+. A diferencia de RS‐232 o interfaces serie similares donde el formato de los datos no están definidos, en USB existen varias capas del protocolo que definen el tamaño de los paquetes que se enviaran.

En este punto quiero mencionar que la comprensión de los detalles de este protocolo con respecto a su funcionamiento van mucho mas allá de lo que explica este blog. Si realmente estas interesado en conocer con mayor profundidad este extenso protocolo te recomiendo dar lectura a la documentación oficial de grupo USB-IF que promueve y brinda soporte al estándar.

Como nuestra finalidad es comunicar una computadora(Host) con el PIC(Device), desde el lado del PIC trabajaremos con la utilidad MCC(Mplab Code Configurator) que nos librara de entrar en los detalles que ocurren en niveles inferiores del protocolo.

Una clase USB determina la funcionalidad que tendrá un dispositivo cuando se conecta al bus, hay una lista de clases ya definidas que pueden implementarse en un microcontrolador, y mencionaremos dos que pueden servir para nuestro caso.
  • CDC(Communication Device Class): Utilizado para establecer una comunicación emulando el comportamiento de un puerto serial(RS232, TTL, etc).
  • HID(Human Interface Class): Esta clase permite conectar dispositivos de entrada(ratón, teclado, impresora, etc) a la computadora y simplificar el proceso de instalación.
Optaremos por utilizar CDC y mas propiamente la subclase ACM(Abstract Control Layer) que brinda mejor soporte de dispositivos y la mayoría de los sistemas operativos incorporan su funcionalidad sin necesidad de utilizar archivos(drivers) adicionales. En Windows un dispositivo CDC conectado aparece como un puerto serie COMx, y en linux se crea el vinculo raíz /dev/ttyACMx.

2. Microcontrolador PIC16F145x

Actualmente microchip ofrece un amplio numero de microcontroladores que soportan la comunicación USB, en todas las gamas de 8, 16 y 32 bits. En particular he optado en utilizar el PIC16F1455 que junto al PIC16F1454 son de los microcontroladores que menos componentes externos requieren para funcionar y ademas su disponibilidad en encapsulado de 14-pines me hacen pensar en lo simple y económico que resulta la implementación del protocolo USB.
Veamos un resumen de las características de este PIC que es relativamente nuevo y forma parte de los productos que utilizan la tecnología XLP(Xtreme Low Power).

- Voltaje de operación 2.3V a 5.5V
- Frecuencia máxima 48MHz
- Memoria de programa FLASH 14Kbytes
- Memoria de datos RAM 1Kbytes
- Memoria de datos EEPROM 128bytes
- Puertos USB compatible para V2.0
- Módulos TMR0/1/2, PWM1/2, MSSP, EUSART

Adicionalmente el PIC16F1455 cuenta con:

- Modulo Comparador 2 canales
- Modulo CWG de 4 fuentes
- Modulo FVR de tres ajustes
- Modulo ADC de 10-bits
- Modulo DAC de 5-bits

Como les comentaba son muchas las cualidades que posee este microcontrolador, y si revisas la hoja de datos encontraras aun mas elementos como ser el sensor de temperatura incorporado.

El circuito utilizado para trabajar con el ejemplo de este blog es muy simple y puede montarse en un protoboard pequeño, el único inconveniente dependiendo de tu país sera contar con el microcontrolador PIC, aquí en mi cuidad la única manera de obtener uno es mediante compra de tiendas en linea como Digi-Key o Mouser.



Al ser un circuito de bajo consumo(menos que 0.5A) este se alimentara directamente del puerto USB, un potenciómetro POT1 se utilizara como entrada analógica, un pulsador BUT1 como entrada digital. El LED1 sera una salida que indica actividad del PIC y el LED2 indicara si esta establecida la comunicación USB.



Una vez montado el circuito en el protoboard, conectamos el programador de PIC(Pickit3) y creamos un proyecto MPLABX con el programa del microcontrolador, para conectar y probar la funcionalidad del puerto USB utilice un cable de teléfono cortado a la mitad, un extremo se conectara a la computadora y el otro directo al protoboard tal como como se ve en la siguiente imagen.


3. Configuración MPLABX y MCC
Ahora llego la hora de trabajar en el programa del PIC, y como primer paso crearemos un proyecto nuevo configurando los recursos a utilizar.
Recuerda que deberás tener instalado en tu PC la aplicación MPLABX y el compilador XC8, así una vez abierto el IDE seleccionas en el menú principal Tools->Plugins->Available Plugins la utilidad MPLAB Code Configurator para que empiece su instalación, asegurate de estar conectado a internet. Luego finalizada la instalación es probable que te pida reiniciar el IDE, y luego cuando vuelves a arrancar podrás verificar en Tools->Plugins->Installed si la utilidad esta instalada.


Aquí creamos un nuevo proyecto seleccionando como dispositivo el PIC16F1455 y el compilador XC8, luego seleccionamos en el menú Tools->Embedded->MPLAB Code Configurator, que nos abrirá una pantalla de asistencia para realizar la configuración inicial de los recursos que se utilizaran en el PIC, básicamente ajustaremos los fusibles, el oscilador y puertos.

La configuración de los fusibles lo hacemos desde la pestaña System Module->Registers, donde desactivamos el circuito de reinicio Reset MLCR seleccionando el pin como una entrada digital


El oscilador se ajusta también en la mista pestaña, con los valores seleccionados trabajaremos con el oscilador integrado a una frecuencia de 48MHz/3 que son 16MHz y un ciclo de instrucción de 0.25uS.


En el visor de pines Pin Manager seleccionamos la configuración de entrada o salida para cada pin, los pines de la comunicación USB DAT+ y DAT- se configuran automáticamente.


Con la pestaña Pin Module, definimos los nombres de cada pin y demas opciones, aquí debemos habilitar la resistencia pull-up del pin RA5 donde se conectara el pulsador BUT1, esta habilitación es individual en cada pin y se necesita también habilitar la opción en todo el puerto con el bit nWPUEN en Module->Register.

.

Ahora buscamos y agregamos los módulos TMR0, ADC y USB de la ventana Device Resources




Una vez agregado revisamos en la lista de periféricos del proyecto y procedemos a configurar cada unos de estos módulos.


Con el modulo TMR0, se busca generar una interrupción cada 1mS que servirá como base de tiempo para el programa principal.



En el modulo ADC ajustamos la referencia 5V y el tiempo de adquisición, para medir la variación de voltaje en la entrada POT1


El modulo USB se basa en una librería MLA modificada para configurar las opciones de la clase CDC, lo único que cambie aquí fue el String del producto.


Finalmente se procede a generar el código con la pestaña Generate, creando toda la estructura lógica de nuestro proyecto, muchos de estos archivos no se tocaran y solo se trabajara en el archivo main.c


4. Programando la comunicación USB
En la estructura del proyecto trabajamos solo con el archivo main.c, para elaborar un programa que realice lo siguiente:
  • Destellar el LED1 cada segundo
  • Indicar a través del LED2 si se estableció la conexión USB
  • Verificar si el pulsador BUT1 es presionado, en caso de ser así enviar un mensaje vía USB con un valor que indique su estado.
  • Leer el voltaje POT1 y si hay una diferencia con un lectura previa, enviar un mensaje vía USB con un valor que indique su magnitud.
El código del programa principal se detalla mas abajo, en el archivo muchas lineas ya fueron insertadas por el configurador MCC cuando se genero el proyecto, por eso adicione unicamente las variables y procedimientos APPTask y USBTask.
  • APPTask es responsable de las entradas BUT1, POT1 y el LED1 haciendo control de los cambios conforme a los procedimientos descritos anteriormente.
  • USBTask es responsable de la conectividad USB con el Host(PC), y dependiendo del estado enviara como mensaje las variables que fueron registradas en APPTask.
    main.c

#include "mcc_generated_files/mcc.h"
#include <string.h>
#include <stdio.h>
static uint8_t writeBuffer[64]; //Declaracion del buffer de salida
volatile char adcOK = 0, butOK = 0; //Banderas de control
volatile char butval, adcval; //Variables de lectura
void APPTasks(); //Prototipo del procedimiento APP
void USBTasks(void); //Prototipo del procedimiento USB
void main(void) //Programa principal
{
    SYSTEM_Initialize(); //Inicializa Puertos, Perifericos, etc
    INTERRUPT_GlobalInterruptEnable(); //Activa las interrupciones
    INTERRUPT_PeripheralInterruptEnable();
    ADC_SelectChannel(POT1); //Selecciona el canal de captura ADC
    TMR0_SetInterruptHandler(APPTasks); //Asigna la tarea ISR cada 1ms
    while(1)
    {
        USBTasks(); //Ajecucion continua del procedimiento USB
    }
}

void APPTasks() //Procedimiento APP cada 1mS via ISR
{
    unsigned int val;
    static unsigned int but1cnt = 0, led1cnt = 0, adc1cnt = 0;
    //Inicio del Control para LED1
    led1cnt ++;
    if(led1cnt > 499) //cada 500ms
    {
        LED1_Toggle(); //Destella led
        led1cnt = 0;
    }

    //Inicio del Control para BUT1
     val = BUT1_GetValue(); //Lectura del pulsador BUT
    if(val != butval) //Solo si BUT cambia de estadoT
    {
         but1cnt ++;
        if(but1cnt > 300) //si mantiene por 300ms
        {
            butval = !butval; //Actuliza estado BUT
            butOK = 1; //Indica cambio de estado BUT
        }
    }
    else but1cnt = 0;

    //Inicio de Control para ADC
    adc1cnt ++;
    if(adc1cnt == 199) ADC_StartConversion(); //inicia en 200ms
    if((adc1cnt > 399) && ADC_IsConversionDone()) //Espera 200ms
    {
         val = (ADC_GetConversionResult() >> 6) / 10; //Lectura valor
        if(val != adcval) //Si valor es diferente
       {
            adcval = val;
            adcOK = 1; //indica cambio de valor POT
        }
        adc1cnt = 0;
    }
}

void USBTasks(void) //Procedimiento que atiende a CDC-USB
{
    if( USBGetDeviceState() < CONFIGURED_STATE ) return;
     LED2_SetHigh(); //Activa LED1 cuendo USB esta configurado
    if(USBUSARTIsTxTrfReady()) //Si el Buffer de salida esta libre
    {
        if(butOK) //Verifica si hay cambio de estado BUT
        {
            butOK = 0;
            sprintf((char *) writeBuffer, "B:%u\n", butval);
            putUSBUSART(writeBuffer,4); //Envia mensaje
        }
        if(adcOK) //Verifica si hay cambio de estado POT
        {
            adcOK = 0;
            sprintf((char *) writeBuffer, "V:%03u\n", adcval);
            putUSBUSART(writeBuffer,6); //Envia mensaje
        }
    }
     CDCTxService(); //Procesa servicio USB
}


Una vez terminada la edición se procede a compilar y cargar el programa al microcontrolador, aquí hago uso de un programador Pickit3

5. Conectado al puerto USB

Ya con el programa cargado en el PIC16F1455, vamos a conectarlo a un puerto USB de la computadora, si todo marcha bien el LED1 estaría destellando y el LED2 se mantendrá encendido. Utilizando el comando lsusb de linux podemos ver como el sistema operativo ha reconocido nuestro dispositivo USB, ver imagen:





En linux todos los dispositivos están enlazados al sistema de archivos en la raiz /dev y el puerto serie de nuestro PIC sera accesible a través de /dev/ttyACMx, esto es similar al puerto COMx creado en Windows. Entonces podemos utilizar un programa terminal para enviar y recibir información del dispositivo serial, yo utilizo una aplicación HTerm que esta disponible de forma gratuita para ambos sistemas operativos. Al conectar esta aplicación con el puerto asignado al PIC nos mostrara en pantalla la siguientes información:



Aquí podemos observar los dos tipos de mensaje que enviá el PIC, uno indica el estado del pulsador BUT (B:0) y otro el resultado de la conversión del POT (V:048), recordar ademas que cada mensaje se enviá solo si hay cambio con respecto al ultimo dato, esto para no enviar la misma información todo el tiempo.

6. Recepción del mensaje en QT

Esta parte del blog es opcional ya que el objetivo de la comunicación PIC - PC ya se cumplió, entonces aquí trabajare en crear una aplicación monitor de los datos que enviá el PIC, donde asumiré que ya se cuenta con el conocimiento y experiencia base en la programación orientada a objetos y C++. Para eso utilizare QT que al ser una cross-platform disponible para diferentes S.O, me posibilita su instalación y funcionamiento en mi pc linux(Debian v11), en particular trabajare con la versión QT5 y el asistente QTCreator 12, donde creare el proyecto CDC_PICMonitor.

Ya con el proyecto creado y configurado adicionare un formulario visual mainwindow.ui en la que insertare los siguientes elementos(objetos visuales):
un checkbox para conectar y desconectar la recepción del puerto, un textEdit para mostrar el valor del BUT y otro textEdit_2 para mostrar el valor del POT, adicional hay unos labels que indican la funcionalidad de cada elemento.

QT cuenta con la clase QSerial y la misma se debe agregar al proyecto adicionando QT += serialport en el archivo de proyecto CDC_PICMonitor.pro, y partir de aquí trabajare solo con los archivos del programa principal que son:

mainwindow.h

#include <QMainWindow>
#include <QtSerialPort>
QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE
class MainWindow : public QMainWindow
{
    Q_OBJECT
    public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
    private slots:
    void readSerialPort(); //Procedimiento que atendera la recepcion
    void on_checkBox_stateChanged(int arg1);
    private:
    Ui::MainWindow *ui;
    QSerialPort *port;
};

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    port = new QSerialPort(); //Instancia a la clase
    connect(port, SIGNAL(readyRead()), this, SLOT(readSerialPort()));
}
MainWindow::~MainWindow()
{
    delete ui;
}
void MainWindow::readSerialPort() //Cuerpo del Procedimiento
{
    QByteArray databytes;
    if(port->canReadLine()) //Si hay mensaje recibido
    {
        databytes = port->readLine(); //Recibe el mensaje
        QString msg(databytes);
        if(msg.at(0) == 'B') //Si el mensaje es del BUT
        {

            ui->lineEdit_2->setText(msg.remove(0,2)); //Actualiza
        }
        if(msg.at(0) == 'V') //Si el mensaje es del POT
        {
            ui->lineEdit->setText(msg.remove(0,2)); //Actualiza
        }
    }
}
void MainWindow::on_checkBox_stateChanged(int arg1)
{
    if(ui->checkBox->isChecked())
    {
        port->setPortName("/dev/ttyACM0");
        port->setBaudRate(port->Baud9600, port->Input);
        port->setFlowControl(port->NoFlowControl);
        if(port->open(QIODevice::ReadOnly)) //Abre el puerto para lectura
            ui->statusbar->showMessage("Puerto Conectado", 0);
        else
            ui->statusbar->showMessage("Error de conexion", 0);

    }
    else
    {
        if(port->isOpen())
        {
            port->close();
            ui->statusbar->showMessage("Puerto Desconectado", 5000);
        }
    }
}

Finalizada la edición y previa compilación de este programa, lo corremos y conectamos nuestro circuito PIC al ordenador, luego hacemos click en conectar para ver como se muestra la información del BUT y POT en las casillas textEdit.



7. Visualización con QML

QML es un lenguaje muy utilizado para crear interfaces graficas y forma parte del framework de QT dando posibilidad de ejecutarlo hasta en un dispositivo móvil. Como un pequeño ejemplo agregaremos a nuestro proyecto CDC_PICMonitor un formulario QML con dos elementos gráficos que nos mostraran la información enviada por el PIC.

Agregamos al proyecto un archivo QML con nombre QMView1.qml y en este archivo en la vista de edición escribimos el siguiente código base.

import QtQuick 2.0
import QtQuick.Controls 2.3
import QtQuick.Extras 1.4
Rectangle
{
    id: rectangle1
    x: 0
    y: 0
    width: 500
    height: 300
    color: "#000000"
}

Esto crea un rectangulo de 500 x 300 pixels con fondo negro, sobre este rectangulo en la vista de diseño agregamos un componente Gauge y un Status Indicator, el primero lo utilizaremos para ver la magnitud del POT y el segundo para el estado del BUT, tambien adicionare un texto de referencia para indicar el nombre del programa.


Ya con esto pasare dar una toque personalizado a cada elemento, agregando las siguientes lineas al archivo QMLView1, dejando como resultado lo siguiente:

import QtQuick 2.0
import QtQuick.Controls 2.3
import QtQuick.Extras 1.4
Rectangle
{
    id: rectangle1
    x: 0
    y: 0
    width: 500
    height: 300
    color: "#000000"

    Text {
        id: element
        x: 156
        y: 14
        color: "#ffffff"
        text: qsTr("CDC PIC MONITOR")
        font.bold: false
        fontSizeMode: Text.FixedSize
        font.pixelSize: 18
    }

    Gauge {
        objectName: "pot1"
        id: gauge
        x: 4
        y: 200
        width: 492
        height: 74
        orientation: 1
        maximumValue: 100
        value: 50
    }

    StatusIndicator {
        objectName: "but1"
        id: statusIndicator
        x: 299
        y: 84
        width: 84
        height: 70
        color: "#30ff00"
        active: false
    }
   
    Text {
        id: element1
        x: 308
        y: 63
        width: 66
        height: 15
        color: "#ffffff"
        text: qsTr("PULSADOR")
        font.pixelSize: 12
    }
   
    Text {
        id: element2
        x: 17
        y: 174
        color: "#f4f1f1"
        text: qsTr("ADC PULSADOR")
        font.pixelSize: 12
    }

}


Con esta plantilla basica pasaremos a enlazar los elementos id:"pot1" y "but1" a nuestro proyecto CDC_PICMonitor, adicionaremos las siguientes lineas a los archivos:

CDC_PICMonitor.pro

QT       += core gui serialport quick

mainwindows.h

#include <QQuickView>
private:
    QQuickView *qv1;
    QObject *pot1, *but1;


En el archivo mainwindows.cpp modificaremos el constructor principal y el procedimiento readSerialPort quedando en lo siguiente:

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    port = new QSerialPort();
    connect(port, SIGNAL(readyRead()), this, SLOT(readSerialPort()));
    qv1 = new QQuickView();
    qv1->setSource(QUrl::fromLocalFile("../CDC_PICMonitor/QMView1.qml"));
    qv1->show();
    pot1 = qv1->findChild<QObject*>("pot1");
    but1 = qv1->findChild<QObject*>("but1");
}

void MainWindow::readSerialPort()
{
    QByteArray databytes;
    if(port->canReadLine())
    {
        databytes = port->readLine();
        QString msg(databytes);
        if(msg.at(0) == 'B')
        {

            ui->lineEdit_2->setText(msg.remove(0,2));
            if(msg.at(0) == '1') but1->setProperty("active", false);
            else but1->setProperty("active", true);
            return;
        }
        if(msg.at(0) == 'V')
        {
            ui->lineEdit->setText(msg.remove(0,2));
            pot1->setProperty("value", msg.toInt());
        }
    }
}

Luego compilamos y ejecutamos el codigo. Observaremos los valores en los elementos graficos de la ventana QML.


8. Conclusiones

Dejo un video que resume toda la creacion del proyecto en MPABX



Aqui dejo los enlaces para que puedas descargar los proyectos creados con MPLAB y QT para en este blog, como usuario de linux comentar que ambos proyectos estan comprimidos en gzip y es probable que necesites modifcar algunas referencias si quieres compilarlos en Windows:
Proyecto MPLABX cdc16f
Proyecto QT5 CDC_PICMonitor

La utilidad MCC al momento de trabajar este ejemplo implementa solo la clase CDC como un lite statck del protocolo USB, si quieres utilizar otras clases como ser HID, MSC, ADC o incluso una personalizada débes utilizar las librerias MLA, hay bastante informacion con ejemplos en la documentacion de microchip.

Algo interesante de trabajar con la subclase ACM es que la codificación de linea es automatica, gracias a esto el protocolo se ajusta a cualquier velocidad(baudios) de la aplicación PC o terminal.

Sin mas que mencionar agradezco tu visita al blog y espero que el ejemplo visto pueda ser útil en tu formación y el proyecto que desarrollas.
Atte. Pablo Zárate Arancibia
email: pablinza@me.com/pablinzte@gmail.com
@pablinzar
Santa Cruz de la Sierra - Bolivia

jueves, 6 de junio de 2019

Temperatura y Humedad con DHT-11/22

Sensor Humedad/Temperatura DHT con PIC

Fig1. Circuito con Sensor DHT11

Muchas gracias por tu visita a este blog relacionado con la programación de micro-controladores PIC, en esta entrada quiero mostrarles como utilizar los sensores DHT para medir la humedad relativa y temperatura ambiental que nos servirán para implementar aplicaciones y/o estaciones de información meteorología.

El objetivo de esta entrada es realizar la lectura adecuada del sensor DHT con un microcontrolador PIC16F en la que se establece una comunicación serial asíncrona por un solo cable, con un protocolo similar a 1-Wire conforme a las especificaciones técnicas del sensor.

La programación del microcontrolador PIC se lleva a cabo con el software  de diseño  MPLABX  y el compilador de lenguaje C para PIC XC8, ambos disponibles en la pagina de microchip de forma gratuita. Aquí dejo los enlaces de las versiones utilizadas para nuestro ejemplo:   
 
Acerca del Sensor DHT

Es un sensor digital para medir la Humedad relativa y Temperatura ambiental, cuenta con un procesador interno que realiza la medición de un elemento capacitivo y un termistor, proporcionando el resultado a través de una señal digital. La interfaz de comunicación con el PIC utiliza una linea bidireccional en modo half-duplex. Seguidamente describiremos los dos modelos identificados como DHT11 y DHT22 que trabajan entre 3.3 a 5.0V y poseen un encapsulado y disposición de pines compatible con las siguientes diferencias  técnicas:


Fig2. Descripción de pines DHT11/22

  • DHT11: Trabaja con un rango de medición de temperatura de 0 a 50 °C con una exactitud de ±2.0 y 1°C de precisión y el rango de medición para la humedad relativa es de 20% a 80% con una exactitud del 5% y 1% de precisión. En ambos casos el resultado esta conformado por 16-bit siendo un byte para el valor entero y el otro byte para el decimal, pero este modelo posee una resolución de 8-bit por que únicamente se emplea la parte entera del resultado. Los ciclos de lectura debe ser como mínimo 2 segundos.

  • DHT22: El rango de  medición de temperatura es de  -40°C a 80 °C con exactitud de ±0.5 °C y precisión de 0.1°C. El rango de humedad es de 0 a 100% RH con exactitud del 2% y precisión del 0.1%. El resultado de ambas mediciones esta conformado por 16-bit,  el tiempo entre lecturas debe ser de 2 segundos.

A simple vista podemos destacar que la principal diferencia entre ambos modelos es el rango de operación y la exactitud pero también hay diferencias en el proceso para establecer la comunicación con el sensor y el resultado de una medición, además que los ciclos de lectura en un DHT22 son mas lentos (2 a 5 segundos) debido a su mayor precisión en el resultado.


Protocolo de comunicación DHT

Como ya mencionamos previamente el voltaje de operación nominal para estos sensores es de 5V, pero pueden trabajar a menor voltaje 3.3V considerando que la distancia entre el sensor y el MCU sera mucho menor, adames en el pin de comunicación SDA(DATA) es necesario adicionar una resistencia en modo pull-up de 4.7k con la que es posible conectar a una distancia de 30 metros, una resistencia de mayor reduce esta distancia de conexión, también es recomendable agregar una capacitor de 100nF entre VDD y GND  para un mejor filtrado en el voltaje de alimentación, la figura 3 muestra la conexión necesaria entre el sensor y el MCU.


Fig3. Conexión entre el Sensor y el MCU
 

Para establecer la comunicación bidireccional a través de la linea SDA(DATA) el microcontrolador (MCU) utilizara un pin configurado como salida al momento de establecer un nivel bajo en SDA y como entrada tri-state para leer los niveles de SDA, utilizando el siguiente procedimiento de señalización y su respectiva temporización:

Fig4. Protocolo de comunicación MCU - Sensor
 
  • Señal de Establecimiento (Start signal): Normalmente la linea SDA se encuentra en un estado ALTO, entonces en esta etapa el MCU establece la linea SDA en nivel BAJO por un tiempo de 1ms(DHT22) o 18ms(DHT11) para luego liberar la linea a su estado inicial es decir un nivel ALTO.

  • Señal de Respuesta (Response signal): En esta etapa el MCU tiene configurado el pin como entrada tri-state esperando a que el sensor coloque la linea SDA en nivel BAJO como respuesta al Start Signal, la duración este cambio sera al menos 80us y luego el sensor libera la linea SDA por un tiempo mínimo de 80us. A partir de este momento el sensor empezar a enviar los datos de la ultima medición efectuada.

  • Datos (Data transfer): En esta etapa el MCU mantiene el pin como entrada tr-state para recibir los 40-bits de datos por parte del sensor, cada bit se interpretara conforme a la siguiente regla de tiempos:

    • (Bit 0) Nivel BAJO por 50us y ALTO por 25 a 28us.

    • (Bit 1) Nivel BAJO por 50us y ALTO por 70us.

Una vez completado el procedimiento de comunicación, el resultado de 40 bits recibidos del sensor mantienen el formato de campos que se muestra en la figura 5, donde los dos bytes mas significativos representan el valor de la humedad, los siguientes dos bytes corresponden a la temperatura y finalmente el ultimo byte se utiliza para verificar error de paridad y es un resultado de sumar los cuatro primeros bytes del dato.

 
Fig5. Trama con los datos recibidos del sensor
 
El MCU deberá procesar la trama de datos recibido de acuerdo al modelo del sensor, conforme a los siguiente ejemplo:
Trama de 40-bit recibidos del sensor DHT11
 <00110101><00000000>  <00011000><00000000><01001101> 
      RHint          RHdec              TEint        TEdec       Paridad    
 
Para verificar si hay error de paridad, bastara sumando los cuatro primeros bytes de la trama y si este resultado es igual al ultimo byte nos indicaría que no hay error en los datos. Para obtener el valor de Humedad relativa solo cambiamos la representación del primer byte que es un numero entero a su equivalente decimal.
<00110101> = 35h = 53 %
Para obtener el valor de Temperatura aplicamos al byte 3 el paso anterior, es decir.
<00011000> = 18h = 24 °C.
Otro ejemplo considerando ahora la respuesta del un sensor DHT22 es la siguiente Trama.  
Trama de 40-bit recibidos del sensor DHT22
 <00000010><10010010>  <00000001><00001101><01001101> 
      RHint          RHdec              TEint        TEdec       Paridad    
La verificacion del error de paridad es similar al caso anterior, en cuanto los demás datos para obtener la humedad relativa se puede efectuar el siguiente calculo tomando los dos bytes (16-bit) juntos.
<00000010 10010010> = 292h, entonces cada dígito 2 * 256 + 9 * 16 + 2 = 658 / 10 = 65.8 %
La temperatura se obtiene aplicando el siguiente calculo.
 <00000001 00001101> =10Dh = 1 * 256 + 0 * 16 + 13 =  269 / 10 = 26.9 °C.
 
Un punto a tomar en cuenta con el modelo DHT22, es a temperaturas bajo cero el primer bit correspondiente al campo de temperatura (TEint) indica el signo del resultado, en tal sentido el MCU deberá efectuar la verificacion correspondiente para la correcta interpretación de la magnitud.

Esquema del Circuito PIC16F
El circuito que utilizaremos para la prueba de este sensor se muestran en la figura 6, en primera instancia hay únicamente un sensor DHT conectado al pin RB4 y un modulo convertidor USB/UART a los pines de comunicación del modulo UART a fin de enviar los recibidos del sensor y mostrar los valores de temperatura y humedad considerando los cálculos que vimos previamente.
 
 
Fig6. Esquema del circuito PIC
Notara que en el esquema del circuito no se observa la resistencia pull-up que requiere la linea SDA del sensor, esto es así porque activaremos la resistencia interna que posee el pin del MCU, el circuito tampoco la etapa de alimentación y reinicio que necesita el PIC16F, dando por hecho que ya están implementadas estas conexiones. Finalmente el diodo LED1 servirá para indicar el funcionamiento adecuado del programa mediante un destello por cada segundo. 
 
Programación del PIC
A fin de facilitar el uso de este sensor utilizaremos un grupo de funciones incluidas en la librería dht.c/dht.h que forman parte de los ficheros del proyecto MPLABX.
Antes de describir las funciones que utilizaremos con el sensor, se deberán personalizar en el archivo de cabecera dht.h las siguientes definiciones:
#define _XTAL_FREQ 8000000
/* USER PORT DEFINITION */
#define DHT_PORT    PORTB  
//Puerto asociado al Sensor
#define DHT_TRIS    TRISB  
//Registro de Configuración del Puerto
#define DHT_DEV1 0x10      
//Mascara del pin RB4 conectado al DHT 
/* END USER PORT DEFINITION */ 

Ahora mostraremos la lista de los procedimientos que podemos utilizar para hacer uso de este sensor:

DHTSetup(devmask): Este procedimiento configura los pines definidos en la cabecera para su posterior uso con el sensor DHT, el pin colocar por defecto la linea SDA en nivel ALTO. Siendo posible iniciar uno o mas pines a los que se conectara un sensor, por ejemplo:

DHTSetup(DHT_DEV1); //Configura un pin DHT
DHTSetup(DHT_DEV1|DHT_DEV2|DHT_DEV3);
//Configura tres pines DHT

DHTStart(devmask, type): Es una función que establece el pulso de inicio y retorna uno (1) al finalizar el pulso ya cuando el nivel de la linea SDA es ALTO. Es importante recalcar que esta función debe llamarse consecutivamente hasta que devuelva un uno (1) y luego de esto recién iniciar la lectura del sensor.

DHTRead(devmask, type, dst): Esta es la función encargada de recibir los 40-bits del sensor DHT, el resultado estará almacenado en la dirección dado por el parámetro dst (puntero a byte) y retorna uno (1) solo si la verificacion de paridad es correcta. Debe tomar en cuenta que esta función es bloqueante y se deberia evitar interrupciones mientras se ejecuta. A continuación veremos el siguiente ejemplo de uso.

if(DHTStart(DHT_DEV1, DHT11)) //Emite pulso de inicio DHT11
{
     INTCONbits.GIE = 0;
//Desactiva interrupción global
    res = DHTRead(DHT_DEV1, DHT11, buffer); //Lectura de los 40-bits
    INTCONbits.GIE = 1; //Activa interrupción global
    if(res) //Valido solo si la paridad es correcta
    {
        //Se procesan los datos almacenados en buffer 
        printf("Raw Hu=%X%X Te=%X%X\r\n",buffer[0],buffer[1],buffer[2],buffer[3]);  
     }
}

DHTUpdate(type, src): Este procedimiento es el encargado de procesar el resultado de 40-bits de una lectura previa, y obtener los valores de humedad relativa y temperatura en el sistema decimal, para esto la librería utiliza una estructura de datos DHT con los siguientes campos:

typedef struct
{
    uint8_t tem;
//Temperatura parte entera
    uint8_t temr;
//Temperatura parte decimal (fracción)
    uint8_t hum;
//Humedad parte entera
    uint8_t humr;
//Humedad parte decimal
} DHT_t;

 
El uso del procedimiento es bastante simple y se refleja en el siguiente ejemplo:
if(DHTStart(DHT_DEV1, DHT11))
{
    INTCONbits.GIE = 0;
    if(DHTRead(DHT_DEV1, DHT11, buffer))
    {
      printf("Raw Hu=%X%X Te=%X%X\r\n",buffer[0],buffer[1],buffer[2],buffer[3]);
      DHTUpdate(DHT11, buffer);
      printf("Final Hu=%u Te=%u\r\n",DHT.hum, DHT.tem);
    }
    INTCONbits.GIE = 1;
}

Si el código descrito previamente se ejecuta de manera continua con un periodo mayor a los dos segundos, el resultado que obtenemos conectando un terminal serie desde nuestro ordenador sera como muestra la figura 7.
 
Fig7. Resultado de la lectura de un sensor DHT11

Un programa completo para llevar a cabo la lectura del sensor DHT11 con intervalos de dos segundos, tendría la siguiente estructura:

void main(void)
{
    MCUSetup();
    DHTSetup(DHT_DEV1);
    while(1)
    {
        if(tickms)
//Valida cada ms
        {
            tickms = 0;
            taskLED();
//Destellar LED
           
taskDHT(); //Lectura y envío datos Sensor
        }
    }
}

Donde la tarea para efectuar la lectura taskDHT que es llamada continuamente cada un milisegundo, controlara su estado de ejecución a través del siguiente código:

void taskDHT(void) //Periodo de ejecución 1ms
{
    static uint8_t state = 0;
    static uint16_t cnt = 0;
    uint8_t res;
    cnt++;
    switch(state)
    {
            case 0:
//Lectura y muestra del sensor DEV1
            if(DHTStart(DHT_DEV1, DHT11))
            {
                INTCONbits.GIE = 0;
                res = DHTRead(DHT_DEV1, DHT11, buffer);
                INTCONbits.GIE = 1;
                if(res)
//Si paridad es correcta
                {
                    DHTUpdate(DHT11, buffer);
                    print("Final Hu=");
                    printByte(DHT.hum);
                    print("% Te=");
                    printByte(DHT.tem);
                    print("\'C\r\n");                  
                }
                state = 1;
//próxima espera
            }
            break;
        case 1:
//Espera nuevo ciclo dos segundos
            if(cnt == 2000)
            {
                cnt = 0;
                state = 0;
            }
            break;   
    }
}

Una vez compilado y preparado el código en el PIC, se llevaran a cabo las conexiones del circuito incluido la comunicación con una terminal serial desde el ordenado (PC), entonces el resultado que nos arrojara el MCU sera el que se muestra en la figura 8.

Fig8. Datos obtenidos del sensor DHT11

Los procedimientos que se mostraron con antelación son parte del archivo principal main.c que contiene el proyecto, este archivo contiene código adicional que no se ha detallando en la presente publicación, por esta razón dejo el enlace para que puedas descargarlo y analizar con mas detalles desde el IDE MPLABX. <Proyecto DHT11 con PIC16>

Si quieres ver como compilar e implementar los proyectos de este blog, elaborados con MPLABX mira este vídeo.<Compilando proyectos MPLABX> 

Mas abajo de dejo el enlace de  vídeo de mi canal en el que se realiza una practica utilizando mas de un sensor DHT.

 
Conclusiones y Recomendaciones

Luego de hacer la demostración del programa podemos concluir que podemos implementar fácilmente cualquiera de estos dos sensores.
Una desventaja con estos sensores es la velocidad de las lecturas y el tiempo de espera para realizar una lectura nueva que es mayor a dos segundos, aunque en muchos casos puede no ser un inconveniente debido a que la Temperatura y Humedad relativa son variables que no cambian de forma rápida.

Sin mas que mencionar agradezco tu visita al blog y espero que el ejemplo visto pueda ser útil en tu formación y el proyecto que desarrollas.

Atentamente, Pablo Zárate Arancibia  email: pablinza@me.com / pablinzte@gmail.com, @pablinzar

Santa Cruz de la Sierra - Bolivia