como fazer um anemômetro

Como fazer um anemômetro monitorado por Internet Deixe um comentário

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:

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.

Motor para fazer um anemômetro

 

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.

Pás para fazer um anemômetro

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.

 

Circuito como fazer um anemômetro

 

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: FilipeFlop 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);
}

Como fazer um anemômetro

Gostou deste post sobre como construir um anemômetro utilizando a mini turbina eólica? Deixe seu comentário logo abaixo. Em caso de dúvidas, caso queira trocar uma ideia, ou até mesmo dividir seu projeto, acesse nosso Fórum!

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *