Gerenciador de consumo de energia elétrica e água com sistema supervisório web/remoto – Parte 3

Esta é a terceira parte da série de artigos que descrevem um projeto de um Gerenciador de consumo de energia elétrica e água com sistema supervisório web/remoto. A série é composta de três artigos, sendo eles:

• Parte 1 – Introduzir o leitor sobre o que consiste o projeto e apresentar o que será utilizado em seu decorrer;
• Parte 2 – Apresentar o desenvolvimento de hardwares e a montagem dos mesmos;
• Parte 3 – Abordar sobre o desenvolvimento de software bare metal e a solução remota utilizada, nesse caso um aplicativo mobile Android que gerencia o sistema.

Este artigo tem como base o TCC de Engenharia Elétrica dos alunos da Faculdade Politécnica de Jundiaí, formados em 2014, são eles: Jefferson dos Santos Abrahão, Neandro Anzolini, Sérgio Luiz Marchi e Vinicius de Almeida.

Pré-requisitos

Devido à abrangência deste projeto, para uma boa compreensão dos conteúdos desta série de artigos são desejados os seguintes pré-requisitos:

• Conhecimento de linguagem de programação C;
• Conhecimento em desenvolvimento de sistemas embarcados em geral;
• Conhecimento de hardware e utilização prévia de Arduino e suas Shields;
• Conhecimento das variáveis de medição de energia elétrica e consumo de água.

No que consiste esta parte do projeto?

Esta parte do projeto consiste na explanação do software bare metal desenvolvido e da solução encontrada para exibir remotamente os dados.

Os Melhores Treinamentos sobre Sistemas embarcados e IoT

Cursos com professores qualificados para acelerar sua carreira e projetos

MATRÍCULE-SE AGORA

Visão geral do Software

O software foi desenvolvido através do kit Arduino Mega 2560 e a linguagem de programação utilizada foi C/C++. Basicamente, o software é dividido em duas partes, setup e loop.

O primeiro é responsável pela configuração do hardware e inicialização de parâmetros que serão tratados e utilizados no decorrer do programa, tais como variáveis, memórias, configuração da ethernet, configuração do bluetooth, definição dos GPIOs, entre outros.

/*---------------------------------------------------------------------------------
*   Executa a configuração do hardware de acordo com a configuração desejada
*
*   Entradas :
*   Saídas :
*       - NENHUMA
*
* Permite parametrizar o hardware da maneira que desejar
*--------------------------------------------------------------------------------*/
void setup() 
{
    // initialize the pushbutton pin as an input:
    pinMode(SELK,    INPUT); 
    pinMode(LEFTK,   INPUT);
    pinMode(RIGHTK,  INPUT);
    pinMode(UPK,     INPUT);
    pinMode(DOWNK,   INPUT);
    pinMode(RETURNK, INPUT);
    pinMode(ONOFFK,  INPUT); 
    pinMode(RESETK,  INPUT); 
    pinMode(RSTPin,  INPUT); 
    pinMode(2, INPUT);

	attachInterrupt(0, incpulso, RISING);                 // Configura o pino 2(Interrupção 0) para trabalhar como interrupção

    //Inicializa a serial
    Serial.begin (9600);

    //Inicializa os valores da memória
    Potencia_acumulada = EEPROM.read(AreaPot);
    ConsumoAgua = EEPROM.read(AreaAgua);

    //Inicializa a Lib de medição
	emon1.voltage(8, 182, 1.7);                            // Voltage: input pin, calibration, phase_shift
    emon1.current(9, 17.1);                                // Current: input pin, calibration.

	//Inicializa o Bluetooth
    pinMode(RxD, INPUT);                                   // Configurando o pino D6 do Arduino (pinoRxD)
                                                           // Como uma ENTRADA digital.
    pinMode(TxD, OUTPUT);                                  // Configurando o pino D7 do Arduino (pinoTxD)
                                                           // Como uma SAÍDA digital.
    ConfiguraBluetooth();                                  // C'riando uma função para configuração do
                                                           // Bluetooth.
     //Ethernet
    pinMode(53,  OUTPUT);                                  // Precisa configurar esse pino para que a comunicação SPI funcione corretamente
	ConectaEthernet();                                     // Conecta a Ethernet Shield
}

O loop é responsável pela execução das ações a serem tomadas pelo software. Neste projeto em específico foi designado que a sequência básica do loop é de execução da tela de inicialização, ou seja, “hello word” do software através de uma mensagem no display. Após essa execução o programa entra em modo de gerenciamento, que nada mais é que a varredura dos sensores conectados ao módulo e envia sequencialmente para a página web, para a serial nativa do Arduino e para o aplicativo android via bluetooth.

/*---------------------------------------------------------------------------------
*   Rotina principal do software
*
*   Entradas :
*   Saídas :
*       - NENHUMA
*
* Executa o que tiver dentro desta função o tempo todo em forma de loop
*--------------------------------------------------------------------------------*/
void loop()
{
    ExecutaTelaInicial();

    ExecutaModoGerenciamento();
}

Neste estágio de gerenciamento, além de enviar os dados aos periféricos já devidamente calculados, o módulo executa a varredura do teclado. A rotina de varredura do teclado lê cada GPIO referente às teclas e caso alguma tecla seja acionada retorna um valor indicando qual foi acionada. Nesta rotina em específico, caso a tecla ENTRA seja pressionada o módulo sai do modo de gerenciamento e entra no setup. Neste momento até a entrada de algum parâmetro os dados param de serem calculados e enviados aos periféricos. Caso a tecla RETURN seja pressionada, o módulo entra na tela de amostragem de tensão. Importante ressaltar que independente da função que está sendo amostrada no display, todas as grandezas estão sendo calculadas e enviadas aos demais periféricos.

Foram criadas telas de parametrização com o intuito de auxiliar o usuário caso ele não queira ficar na tela de gerenciamento, ou seja, para o caso de querer monitorar no display uma grandeza em específico, há essa possibilidade. O setup de programação foi dividido em dois grupos, Energia e Água, e subdivididos em tensão, corrente, potencias ativa, reativa e aparente, fator de potência e consumo de energia pelo lado de Energia e fluxo e consumo de água pelo lado de Água.

Além disso, há a rotina que monta a página web em html e envia os dados para que o shield W5100 envie o pacote TCP/IP para a rede e, também, a rotina que envia um buffer próprio para o módulo HC-05 bluetooth e também para a serial.

Há duas funções especificas que são bem importantes para o conjunto, a primeira delas é o desligamento do display, ou sleep mode, que apaga as informações do display mas continua mandando as mesmas para os periféricos. E a segunda é a função de reset, que uma vez apertado o botão surgem duas opções: ou reset do terminal, que faz o reset da placa via software; ou o reset das variáveis, que zera os valores de consumo de energia e água, uma vez que estes parâmetros não zeram com o desligamento do gerenciador.

Comunicação com a Shiled Bluetooth

A configuração da shield é feita na inicialização do Arduino, onde são definidos os parâmetros, tais como número do PIN, condições de pareamento, nome do dispositivo, entre outros.

Para facilitar a implementação da camada de aplicação Android, foi definido um protocolo próprio. Trata-se de um protocolo que inicia com STX, que sinaliza que iniciará a transmissão dos dados, e termina com ETX, que indica que o buffer termina nesse momento. Como separador entre dados foram utilizadas vírgulas.

/*---------------------------------------------------------------------------------
*   Prepara e envia o buffer via Bluetooth
*
*   Entradas :
*   Saídas :
*       - NENHUMA
*
*--------------------------------------------------------------------------------*/
void PreparaEnviaBufferBluetooth()
{
    int i, j = 0;

    memset(BufBlu, 0, sizeof(BufBlu));  //Clear array

    //Make output string
    BufBlu[0] = STX;  //STX
    strcat(BufBlu, ",");
    strcat(BufBlu, dtostrf(Tensao_rms, 3, 2, RascBuf)); 
    strcat(BufBlu, ",");
    strcat(BufBlu, dtostrf(Corrente_rms, 3, 2, RascBuf));
	strcat(BufBlu, ",");
    strcat(BufBlu, dtostrf(Potencia_Ativa, 3, 2, RascBuf));
    strcat(BufBlu, ",");
    strcat(BufBlu, dtostrf(Potencia_Aparente, 3, 2, RascBuf));
    strcat(BufBlu, ",");
    strcat(BufBlu, dtostrf(Potencia_reativa, 3, 2, RascBuf));
    strcat(BufBlu, ",");
    strcat(BufBlu, dtostrf(Fator_Potencia, 3, 2, RascBuf));
    strcat(BufBlu, ",");
    strcat(BufBlu, dtostrf(Potencia_acumulada, 3, 2, RascBuf));
    strcat(BufBlu, ",");
    strcat(BufBlu, dtostrf(VazaoAgua, 3, 2, RascBuf));
    strcat(BufBlu, ",");
    strcat(BufBlu, dtostrf(ConsumoAgua, 3, 2, RascBuf));
	strcat(BufBlu, ",");

    for(i = 0; i < sizeof(BufBlu); i++)
    {
        if(BufBlu[i] == ',')
            j++;

        //if(BufBlu[i] == '\0')
        //    BufBlu[i] = 0x30;

        if(j == 10)
		{
            BufBlu[i+1] = ETX;
            break;
        }
    }

    SerialBluetooth.println(BufBlu);  //imprimindo o dado via Bluetooth

    Serial.println(BufBlu);           //Imprimindo no serial monitor o array
}

Desenvolvimento do aplicativo

O aplicativo desenvolvido para este projeto foi criado a partir do Eclipse com ADT (Android Development Tools), ou seja, uma IDE para desenvolvimento com plugin com ferramentas para desenvolver Android. A linguagem de programação utilizada para o desenvolvimento do aplicativo foi Java, porém em alguns pontos foi necessário programar em XML.

O processo para se desenvolver um aplicativo é composto por árvores, e para esta aplicação é feita por três etapas, são elas: o desenvolvimento da tela e do ícone de atalho; o desenvolvimento da árvore principal; e o desenvolvimento do serviço de bluetooth, que roda em background, não sendo visível aos olhos do usuário final.

A etapa de desenvolvimento da tela consiste em designar a disposição dos dados a serem mostrados na tela e do botão que executa a conexão com a placa. O ícone, necessariamente, precisa possuir extensão PNG e ter dimensões 64×64 pixels. Neste projeto foi desenvolvido um ícone que transmitisse a mensagem de um gerenciador de consumo de energia e água.

A árvore principal tem a função de intermediar se o botão de conexão foi pressionado e solicitar a estrutura de serviço que execute a conexão propriamente dita. Outra função desta árvore é receber os dados tratados e direcioná-los à tela na ordem devida. Basicamente ela tem a função de gerenciar as atividades como um todo.

Já o serviço de bluetooth tem a função de estabelecer a conexão com o shield, realizar a paridade, receber os dados, tratá-los um a um segundo o protocolo que está sendo enviado e direcioná-los a estrutura principal para que ela envie para a tela. Para tanto, é extremamente importante que a aplicação conheça com quem está falando e como estão vindo os dados, por isso no capítulo de comunicação com o Shield Bluetooth foi explicado sobre o protocolo que é enviado. Sem um protocolo previamente conhecido e passível de interpretação, não é possível realizar o tratamento dos dados recebidos.

Produto gerado

O protótipo foi batizado de CEA01BE (Controle Energia e Água 01 Bluetooth e Ethernet).

Vídeo demonstrativo do projeto

Download

Código-fonte do software bare metal

Código-fonte do aplicativo Android

Conclusão e agradecimentos

Este projeto consistiu desde seu início num trabalho acadêmico voltado para uma situação sobre a qual o consumidor final tem pouco controle, ou seja, o acompanhamento “real time” de seus consumos. Estamos estudando atualmente na migração desse projeto para algo vendável. Gostaria de deixar meus agradecimentos aos parceiros deste projeto: Jefferson dos Santos Abrahão, Neandro Anzolini e Sérgio Marchi. E também ao Pedro Bertoleti que nos auxiliou muito no desenvolvimento do aplicativo Android.