Como fazer um anemômetro monitorado por Internet 6

Monitorar o ambiente é sempre uma constante no mundo dos sistemas embarcados. Afinal, quanto mais informações do ambiente se tem conhecimento (informações de temperatura, pressão, umidade do ar, etc.), melhor pode-se entende-lo e, além disso, prevê-lo. Este post vai mostrar um projeto nesta linha: como fazer um anemômetro monitorado por Internet.

Materiais necessários para fazer um anemômetro

Para fazer este projeto, você precisará dos seguintes materiais:

• Uma Placa ESP8266 NodeMCU
• Uma Mini protoboard 170 pontos
• Um Cabo micro USB
• Dois Resistores de 68kOhm / 0,25W
• Uma Mini Turbina Eólica
• Uma fonte 5V/2A (micro-USB)

Este projeto visa medir a velocidade do vento e, além disso, disponibilizar tal medição via Internet. O projeto utiliza como elemento sensor uma mini turbina eólica, um dispositivo capaz de produzir energia elétrica a partir da força do vento. Como placa de desenvolvimento, será utilizado o NodeMCU.
Sendo assim, com poucos componentes é possível fazer um anemômetro com monitoramento pela Internet, permitindo que a velocidade do vento de uma determinada região seja monitorada de qualquer lugar do mundo.

Teoria – relação entre rotação (RPM) e tensão nos terminais de um motor DC

A mini-turbina eólica utiliza como gerador um motor elétrico DC de 6V. Motores (DC ou AC) são máquinas elétricas reversíveis, ou seja, pode-se converter energia elétrica em energia mecânica e vice-versa. Isso significa dizer que, para um motor elétrico girar (ter energia mecânica), basta aplicar energia elétrica, assim como se energia mecânica for aplicada, gera-se energia elétrica. Este princípio rege o funcionamento de geradores elétricos e, além disso, é a base do funcionamento de geradores eólicos de energia elétrica.

Aprofundando mais um pouco, um motor DC tem como modelo elétrico simplificado de sua parte estática visto na figura abaixo.

 

Conclui-se, portanto, que motores DC não são máquinas elétricas ideais, pois em situações onde o motor é alimentado com tensão V, há corrente elétrica circulante i(t) e, consequentemente, há dissipação de potencia ativa no resistor R e de potência reativa no indutor L. Logo, a “energia útil” disponibilizada para geração de movimento (energia mecânica) é sempre menor que a energia elétrica fornecida. Da mesma forma, se girarmos o eixo do motor DC e se houver corrente circulante, o resistor e indutor e resistor irão também “roubar” parte da energia e fazer com seja disponibilizada uma quantidade de energia elétrica menor que a energia mecânica fornecida. Em outras palavras, seja operando como gerador ou motor, o motor DC não possui rendimento de 100%.

Para se fazer um anemômetro no qual a medição de velocidade do vento será obtida em função da velocidade de rotação de seu eixo, não é preciso utilizar a energia elétrica gerada pela mini turbina eólica, e sim somente medir a tensão elétrica V e estabelecermos uma relação com o RPM do motor. Mas como? Veja a seguir.

Imagine a seguinte situação: os pontos onde V é medido são ligados ao ADC do NodeMCU (polo positivo) e ao GND do mesmo (polo negativo). Logo, como um ADC (o ADC do NodeMCU, no caso) apresenta uma impedância de entrada muito alta (afinal, o intuito do ADC é fazer medição de tensões elétricas de sinais, não consumir energia), podemos considerar que a corrente circulante nesta situação será nula. Portanto, não há energia elétrica sendo consumida, tampouco consumo por parte do resistor R e/ou do indutor L. Desta forma, tem-se que Ve = V. Ainda da figura 1, tem-se a relação entre Ve e a rotação (representada pela letra grega ômega, ω). Portanto, a tensão V (e, consequentemente, Ve) varia linearmente com a rotação do motor DC segundo um fator Kv (Ve = Kv.ω), fator este inerente à construção do motor e obtido empiricamente.

Em suma: é sim possível medir a rotação do motor DC que opera como gerador (caso da mini turbina eólica) com base apenas na tensão medida nos seus terminais!

Teoria – obtenção da constante do motor (Kv)

Conforme visto no tópico anterior, para fazer um anemômetro é  necessário ter conhecimento da constante do motor (Kv) é o único elemento que falta para ser possível a medição do RPM do motor (e, mais a frente, transformar isto em velocidade do vento). Há duas maneiras para a determinação de tal constante:

1. Com base nos dados fornecidos do motor pelo fabricante / fornecedor
   Normalmente, fabricantes de motores / geradores fornecem dados e/ou curvas que permitem obter pares de dados de tensão de alimentação (ou geração) e RPM correspondente. Neste caso, a constante é calculada pela razão entre uma tensão de alimentação válida e seu RPM correspondente.
2. Com base em processo empírico
   Apesar do método anterior funcionar muito bem, ele se baseia em dados de fabricantes que executaram os testes e medições com o motor/gerador em vazio, ou seja, sem nenhuma carga mecânica no eixo do motor/gerador. Neste caso, quando se deseja obter um valor de constante adequado a uma situação especial de uso de um motor ou gerador (ou seja, quando se busca máxima exatidão na determinação da constante), deve-se fazer o processo de alimentação de motor com tensão elétrica conhecida, medição do RPM correspondente e, assim, fazer o cálculo da constante. Nesta linha de pensamento, pode-se ainda fazer várias medições de RPM (uma para cada tensão elétrica distinta) e, utilizando métodos como regressões lineares, determinar uma constante ainda mais condizente com a situação real.

Por questões de não se querer tirar o foco do projeto e não carregar este post com muita teoria (e torná-lo denso), optarei pela maneira número 1 para fazer um anemômetro. Neste caso, segundo a página da loja virtual da mini turbina eólica, tem-se que, quando a tensão nos terminais do motor é 5,5V, a rotação do motor é igual a 6000RPM. Logo, a constante Kv é igual a:

 

Kv = V/ω = 5,5/6000 = 0,0009 V/RPM

Portanto, o RPM da mini turbina eólica pode ser obtido pela seguinte relação:

ω = Vmedido / 0,0009  ∴  ω = Vmedido * 1111,11 [RPM]

Teoria – transformando RPM em velocidade do vento

Para transformar o RPM em velocidade do vento, deve-se olhar a mini turbina eólica “de cima”, conforme mostra figura abaixo.

Considerando a figura e alguns tópicos de física, tem-se que a velocidade tangencial Vel em função do raio R (em metros) da turbina e da sua rotação (velocidade ângular) ω é:

Vel = ω.R

No caso deste projeto, a velocidade tangencial (Vel) é a velocidade do vento que desejamos saber.

No tópico anterior, determinamos a rotação da mini turbina eólica em função da medição da tensão nos terminais da mesma. Logo:

Vel = ω.R -> Vel = Vmedido * 1111,11 * R [m / min]  ∴  Vel = Vmedido * 18,52 * R [m/s]

Ainda, do site da loja virtual, temos que o diâmetro das pás montadas da mini turbina eólica é 10cm. Portanto:

Vel = Vmedido * 18,52 * R [m/s]   ∴  Vel  = 0,926 * Vmedido [m/s]

Portanto, tudo que precisamos saber para determinar a velocidade do vento é a tensão elétrica medida em seus terminais!

Circuito esquemático

O circuito esquemático do projeto “como fazer um anemômetro monitorado por internet” pode ser visto na figura abaixo.
Observação: a aplicação do divisor de tensão resistivo entre a entrada do ADC e a mini turbina eólica é decorrente do ADC do NodeMCU suportar, no máximo, 3,3V.

 

 

Prática / código-fonte – monitoramento da velocidade do vento via Internet

Para monitorar a velocidade do vento via Internet, iremos considerar que o monitoramento será feito usando o bom e velho MQTT. Se você não tem muita familiaridade com MQTT no NodeMCU, veja este nosso post aqui do blog. Sendo assim, o código-fonte do projeto completo pode ser visto abaixo. Leia atentamente os comentários para o máximo entendimento do software.

//Projeto: fazer um anemômetro feito com mini turbina eólica e NodeMCU
//Autores: MakerHero e Pedro Bertoeti
#include <ESP8266WiFi.h>  //essa biblioteca já vem com a IDE. Portanto, não é preciso baixar nenhuma biblioteca adicional
#include <PubSubClient.h> // Importa a Biblioteca PubSubClient
 
//defines
#define SSID_REDE     " "  //coloque aqui o nome da rede que se deseja conectar
#define SENHA_REDE    " "  //coloque aqui a senha da rede que se deseja conectar

  
//defines de id mqtt e tópicos para publicação e subscribe
#define TOPICO_SUBSCRIBE "MQTTFFAnemometroEnvia"     //tópico MQTT de escuta
#define TOPICO_PUBLISH   "MQTTFFAnemometroRecebe"    //tópico MQTT de envio de informações para Broker
                                                  //IMPORTANTE: recomendamos fortemente alterar os nomes
                                                  //            desses tópicos. Caso contrário, há grandes
                                                  //            chances de você controlar e monitorar o NodeMCU
                                                  //            de outra pessoa.
#define ID_MQTT  "AnemometroIoT"       //id mqtt (para identificação de sessão)
                                       //IMPORTANTE: este deve ser único no broker (ou seja, 
                                       //            se um client MQTT tentar entrar com o mesmo 
                                       //            id de outro já conectado ao broker, o broker 
                                       //            irá fechar a conexão de um deles).
  
//constantes e variáveis globais
const char* BROKER_MQTT = "iot.eclipse.org"; //URL do broker MQTT que se deseja utilizar
int BROKER_PORT = 1883;                      // Porta do Broker MQTT
WiFiClient client;
WiFiClient clientMQTT;
PubSubClient MQTT(clientMQTT); // Instancia o Cliente MQTT passando o objeto clientMQTT
  
//prototypes
float FazLeituraTensao(void);
void initWiFi(void);
void initMQTT(void);
void reconectWiFi(void); 
void mqtt_callback(char* topic, byte* payload, unsigned int length);
void VerificaConexoesWiFIEMQTT(void); 
 
/*
 * Implementações
 */

//Função: inicializa e conecta-se na rede WI-FI desejada
//Parâmetros: nenhum
//Retorno: nenhum
void initWiFi() 
{
    delay(10);
    Serial.println("------Conexao WI-FI------");
    Serial.print("Conectando-se na rede: ");
    Serial.println(SSID_REDE);
    Serial.println("Aguarde");
    reconectWiFi();
}

//Função: inicializa parâmetros de conexão MQTT(endereço do 
//        broker, porta e seta função de callback)
//Parâmetros: nenhum
//Retorno: nenhum
void initMQTT() 
{
    MQTT.setServer(BROKER_MQTT, BROKER_PORT);   //informa qual broker e porta deve ser conectado
    MQTT.setCallback(mqtt_callback);            //atribui função de callback (função chamada quando qualquer informação de um dos tópicos subescritos chega)
}

//Função: função de callback 
//        esta função é chamada toda vez que uma informação de 
//        um dos tópicos subescritos chega)
//Parâmetros: nenhum
//Retorno: nenhum
void mqtt_callback(char* topic, byte* payload, unsigned int length) 
{
    //coloque aqui o tratamento que desejar fazer às mensagens MQTT recebidas
}

//Função: reconecta-se ao broker MQTT (caso ainda não esteja conectado ou em caso de a conexão cair)
//        em caso de sucesso na conexão ou reconexão, o subscribe dos tópicos é refeito.
//Parâmetros: nenhum
//Retorno: nenhum
void reconnectMQTT() 
{
    while (!MQTT.connected()) 
    {
        Serial.print("* Tentando se conectar ao Broker MQTT: ");
        Serial.println(BROKER_MQTT);
        if (MQTT.connect(ID_MQTT)) 
        {
            Serial.println("Conectado com sucesso ao broker MQTT!");
            MQTT.subscribe(TOPICO_SUBSCRIBE); 
        } 
        else
        {
            Serial.println("Falha ao reconectar no broker.");
            Serial.println("Havera nova tentatica de conexao em 2s");
            delay(2000);
        }
    }
}

//Função: reconecta-se ao WiFi
//Parâmetros: nenhum
//Retorno: nenhum
void reconectWiFi() 
{
    //se já está conectado a rede WI-FI, nada é feito. 
    //Caso contrário, são efetuadas tentativas de conexão
    if (WiFi.status() == WL_CONNECTED)
        return;

    WiFi.begin(SSID_REDE, SENHA_REDE); // Conecta na rede WI-FI

    while (WiFi.status() != WL_CONNECTED) 
    {
        delay(100);
        Serial.print(".");
    }

    Serial.println();
    Serial.print("Conectado com sucesso na rede ");
    Serial.print(SSID_REDE);
    Serial.println("IP obtido: ");
    Serial.println(WiFi.localIP());
}

//Função: verifica o estado das conexões WiFI e ao broker MQTT. 
//        Em caso de desconexão (qualquer uma das duas), a conexão
//        é refeita.
//Parâmetros: nenhum
//Retorno: nenhum
void VerificaConexoesWiFIEMQTT(void)
{
    if (!MQTT.connected()) 
        reconnectMQTT(); //se não há conexão com o Broker, a conexão é refeita

     reconectWiFi(); //se não há conexão com o WiFI, a conexão é refeita
}
  
//Função: faz a leitura da tensão nos terminais da mini turbina eolica
//Parâmetros: nenhum
//Retorno: tensão (0.0 - 5.5V)
float FazLeituraTensao(void)
{
    int ValorADC;
    float TensaoMedida;

     ValorADC = analogRead(0);   
     Serial.print("[Leitura ADC] ");
     Serial.println(ValorADC);

     //Quanto maior o numero lido do ADC, maior a tensao.
     //Sendo assim, calcula-se a tensão medida por:
     //
     //   Valor lido                       Tensão medida no ADC
     //      _    1024                        _ 3.3V
     //      |                                |
     //      |                                |
     //      -   ValorADC                     - TensaoMedida
     //      |                                |
     //      |                                |
     //     _|_  0                           _|_ 0
     //
     //   (TensaoMedida-0) / (3.3-0)  =  (ValorADC - 0) / (1024 - 0)
     //      Logo:
     //      TensaoMedida = (3.3/1024)*ValorADC

     TensaoMedida = (3.3/1024.0)*ValorADC;

     //Devido ao divisor de tensao, a tensao real corresponde ao dobro da calculada
     TensaoMedida = TensaoMedida*2;
     
     Serial.print("[Tensao medida] ");
     Serial.print(TensaoMedida);
     Serial.println("V");

     return TensaoMedida;
}
void setup()
{  
    Serial.begin(9600);
    initWiFi();
    initMQTT();
    Serial.println("Planta IoT com ESP8266 NodeMCU");
}

//loop principal
void loop()
{
    float TensaoMedida;
    float VelVentoMedida;
    int VelVentoMedidaTruncada_KmPorHora;
    char MsgVelVentoMQTT[100];

    VerificaConexoesWiFIEMQTT(); 

    TensaoMedida = FazLeituraTensao();
    VelVentoMedida = 0.926*TensaoMedida;
    VelVentoMedidaTruncada_KmPorHora = (int)(VelVentoMedida*3.6);

    Serial.print("[Velocidade do vento] ");
    Serial.print(VelVentoMedidaTruncada_KmPorHora);       
    Serial.println("km/h");
    
    //envia a velocidade do vento (em m/s) via MQTT
    sprintf(MsgVelVentoMQTT,"- Velocidade do vento: %d km/h",VelVentoMedidaTruncada_KmPorHora);
    MQTT.publish(TOPICO_PUBLISH, MsgVelVentoMQTT);

    //aguarda 1 segundo até o proximo envio
    delay(250);
}

Gostou deste post sobre como construir um anemômetro utilizando a mini turbina eólica? Deixe seu comentário logo abaixo.