# Página Inicial

Blog

<figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FyKCpIOwTSLaoaVfg9v8I%2Fpivot-5.png?alt=media&amp;token=8b48ec11-087c-4160-ae39-26621a16ea7b" alt="" width="375"><figcaption></figcaption></figure>

{% content-ref url="/pages/2VHSLBNujwWq4NwQaifz" %}
[Pivô de irrigação - Telemetria e Comando](/projetos/pivo-de-irrigacao-telemetria-e-comando)
{% endcontent-ref %}

{% content-ref url="/pages/-M3HLqXVjsbOQKaglsT-" %}
[ESP32 Prometheus](/esp32-prometheus)
{% endcontent-ref %}


# ESP32 Prometheus

Utilizando Prometheus com ESP32

![](https://gblobscdn.gitbook.com/assets%2F-M15s4TnAJw6r_zYzKkX%2F-M3HLnucrqfFIB7ZmE3Q%2F-M3HMGF5p5p4hbrZabpI%2Fdashboard-v1.png?alt=media\&token=8e621170-e22f-44cb-9ba9-64e4bf0e25b9)

### Introdução

Em diversos projetos envolvendo sensoriamento, se faz necessário o monitoramento dos dispositivos conectados na rede. Dessa forma, necessitamos utilizar ou desenvolver sistemas capazes de suprir essa demanda para poder analisar e monitorar qualquer anomalia que possa ocorrer na comunicação dos devices.

Com um sistema implementado e com a coleta de algumas métricas ,podemos por exemplo detectar reboots inesperados, temperatura interna elevada, perca de pacotes devido a oscilação do sinal wifi e etc. Tais métricas serão abordadas em um tópico futuro.

Nesse artigo, você aprenderá como desenvolver um sistema para monitoramento do ESP32 utilizando serviços de código aberto e gratuitos denominados Prometheus e Grafana.

Portanto, por meio desse artigo você aprenderá:

* Coletar métricas do ESP32
* Montar as métricas no formato do prometheus
* Expor as métricas coletadas através do webserver&#x20;
* Instalar o Grafana
* Instalar o Prometheus
* Integrar o Prometheus com ESP32
* Criar a dashboard de monitoramento

Agora, iniciaremos a apresentação completa do desenvolvimento do projeto Monitorando o ESP32 com Prometheus através do Grafana.

### Desenvolvendo o projeto *Monitorando o ESP32 com Prometheus através do Grafana*

Antes de botarmos a mão na massa, a fim de se ter uma clareza melhor sobre o problema que queremos resolver, observe abaixo o diagrama de fluxo que iremos implementar nesse projeto.

![Figura 1 - Diagrama de fluxo](https://github.com/douglaszuqueto/esp32-prometheus/raw/master/.github/diagrama-v2.png)

Basicamente esse diagrama pode ser dividido em 3 partes, sendo elas:

* 1 - Prometheus => ESP32
* 2 - Grafana => Prometheus
* 3 - Usuário => Grafana

Agora que demos uma pincelada sobre o fluxo que iremos implementar, seguimos para os materiais que serão necessários para o desenvolvimento do projeto.

### Materiais necessários

Como requisitos básicos para o desenrolar do projeto de monitoramento, precisaremos dos itens citados a seguir:

* 01 x ESP32
* 01 x Raspberry(ou qualquer outra SBC compatível / servidor)

A Raspberry será onde ficará hospedado os serviços necessários para rodar o projeto. Já o ESP32 será o "core" da aplicação, é com ele que conseguiremos coletar as métricas que serão abordadas no tópico abaixo.

### Métricas monitoradas

Monitorar algumas métricas de nossos dispositivos IoT são de suma importância, portanto veja na lista abaixo o que será monitorado.

* Uptime
* Temperatura interna
* Boot counter
* WiFi RSSI
* Memória total/utilizada
* Memória flash total/utilizada

Tendo uma noção das métricas que serão monitoradas, podemos ir para o próximo tópico onde iremos tratar sobre os dois serviços que serão utilizados no projeto.

### Serviços

Os serviços serão instalados levando-se em consideração o uso de uma Raspberry PI. Caso deseja fazer em outro ambiente que seja baseado em Linux, os procedimentos serão bem parecidos :)

Na sequência abordaremos o Prometheus, o primeiro serviço que será utilizado neste projeto.

#### Prometheus

Banco de dados focado em séries temporais - TSDB(Time Series Database), muito utilizado em ecossistemas IoT.

Exemplos de TSDB's:

* InfluxDB
* TimescaleDB
* Prometheus

Já ouviu o famoso ditado: "Dividir para conquistar", pois então.. temos um banco de dados, mas como conseguiremos observar as métricas de forma gráfica? É ai que o Grafana entra na jogada!

#### Grafana

Serviço para compor dashboards elegantes de monitoramento de forma simples, a qual possui suporte a múltiplos banco de dados(datasources).

Ex: Prometheus, MySQL, PostgreSQL, dentre outros.

Agora que sabemos um pouco mais sobre os serviços que utilizaremos neste projeto, podemos partir para a criação das métricas no prometheus.

### Métricas no Prometheus

Para estar criando métricas e integrando ao prometheus, você precisa ter uma noção base dos tipos compatíveis e como cada métrica é montada respeitando o layout do serviço.

#### Tipos

Como não temos nenhum cliente prometheus para o ESP32, se faz necessário montar manualmente as métricas, e dentre os tipos disponíveis do Prometheus, os mais acessíveis para se implementar são os citados logo abaixo.

* Counter - apenas incremento
* Gauge - semelhante ao counter porém pode aumentar e diminuir

Exemplos:

* Counter: contador de boot
* Gauge: temperatura interna

Para implementação dessas métricas, temos que seguir um padrão determinado pelo prometheus, veja na sequência como deve ser esse modelo.

#### Layout

O prometheus segue a risca um formato para que as métricas expostas se tornem válida. Então ele impõe uma estrutura e consequentemente precisamos nos adaptar a ela.

Abaixo segue um exemplo referente a uma métrica que será coletada:

```
# esp32_uptime Uptime total do ESP32
# TYPE esp32_uptime gauge
esp32_uptime 23899
```

Primeira e segunda linhas são referentes a comentários envolvendo o nome da métrica, seu tipo e descrição.

Já a última linha, envolve o nome da métrica e seu devido valor.

Como podemos ver, o formato é muito simples e fácil de ser implementado manualmente conforme necessidade(exemplo do projeto).

#### Função para abstrair a métrica a ser montada

A fim de não repetir muito código e concatenação de strings para formatar as métricas no formato prometheus, foi criado uma simples função para deixar o processo mais simples.

```c
void setMetric(String *p, String metric, String value) {
  *p += "# " + metric + "\n";
  *p += "# TYPE " + metric + " gauge\n";
  *p += "" + metric + " ";
  *p += value;
  *p += "\n";
}
```

Utilizando a função:

```c
String p = "";

String uptime = String(millis());

setMetric(&p, "esp32_uptime", uptime);
```

Agora que já temos uma noção dos tipos de métricas aplicáveis, quais métricas serão monitoradas e principalmente o formato que devemos seguir, colocaremos a mão na massa começando com o firmware da nosso hardware.

#### Firmware

Baixe o [repositório](https://github.com/douglaszuqueto/esp32-prometheus/archive/master.zip) e faça o upload do firmware localizado na pasta **esp32-prometheus**.

*Obs:* Antes de fazer o upload não esqueça de configurar as credenciais da rede wifi como também o IP estático do esp de acordo com sua rede.

Depois de efetuar o upload e o firmware estiver rodando, você pode acessar o webserver através da seguinte url: <http://IP_ESP:80/metrics>.

Ao acessar, você deverá observar o seguinte resultado:

```
# esp32_uptime
# TYPE esp32_uptime gauge
esp32_uptime 7152784
# esp32_wifi_rssi
# TYPE esp32_wifi_rssi gauge
esp32_wifi_rssi -34
# esp32_heap_size
# TYPE esp32_heap_size gauge
esp32_heap_size 342316
# esp32_free_heap
# TYPE esp32_free_heap gauge
esp32_free_heap 262444
# esp32_sketch_size
# TYPE esp32_sketch_size gauge
esp32_sketch_size 728592
# esp32_flash_size
# TYPE esp32_flash_size gauge
esp32_flash_size 3145728
# esp32_available_size
# TYPE esp32_available_size gauge
esp32_available_size 2417136
# esp32_temperature
# TYPE esp32_temperature gauge
esp32_temperature 46.11
# esp32_boot_counter
# TYPE esp32_boot_counter gauge
esp32_boot_counter 7
```

O resultado acima nada mais é que o layout do prometheus já implementado, observe que cada métrica que será monitorada corresponde à um bloco de 3 linhas.

Agora que já temos o firmware rodando no esp32, podemos seguir em frente com a preparação da raspberry para hospedar o prometheus juntamente com o grafana.

### Instalação dos serviços

Antes de iniciarmos com a instalação propriamente dita, vamos criar uma pasta onde os serviços ficarão armazenados na raspberry.

*Obs:* Certifique-se que você está logado com o usuário padrão da raspberry - usuário **pi**.

```bash
# 1º
mkdir services

# 2º
cd services

# 3º => /home/pi/services
pwd
```

Pronto! Podemos proceder com a instalação do Grafana.

#### Grafana

```bash
# 1º
wget https://dl.grafana.com/oss/release/grafana_6.6.2_armhf.deb

# 2º Efetuando a instalação
sudo dpkg -i grafana_6.6.2_armhf.deb

# 3º Habilitando o grafana para iniciar automaticamente ao iniciar a raspberry
sudo systemctl enable grafana-server 

# 4º Iniciando o serviço
sudo systemctl start grafana-server 

# 3º Visualizando o status
sudo systemctl status grafana-server
```

Tudo ok?! Hora de instalar o prometheus, nosso último serviço.

#### Prometheus

```bash
# 1º
wget https://github.com/prometheus/prometheus/releases/download/v2.16.0/prometheus-2.16.0.linux-armv7.tar.gz

# 2º
tar zxvf prometheus-2.16.0.linux-armv7.tar.gz

# 3º 
mv prometheus-2.16.0.linux-armv7 prometheus

# 4º 
cd prometheus

# 5º => /home/pi/services/prometheus
pwd

# 6º Criação do serviço do prometheus para se integrar ao systemd assim como o grafana já está
echo "
[Unit]
Description=Prometheus Server
Documentation=https://prometheus.io/docs/introduction/overview/
After=network-online.target

[Service]
User=pi
Restart=on-failure
ExecStart=/home/pi/services/prometheus/prometheus \
  --config.file=/home/pi/services/prometheus/prometheus.yml \
  --storage.tsdb.path=/home/pi/services/prometheus/data \
  --web.enable-lifecycle \
  --web.enable-admin-api

[Install]
WantedBy=multi-user.target
" | sudo tee > /etc/systemd/system/prometheus.service

# 4º
sudo systemctl daemon-reload

# 5º
sudo systemctl enable prometheus 

# 6º
sudo systemctl start prometheus 

# 7º
sudo systemctl status prometheus
```

Todas instalações feitas. Caso queira validar tudo que foi feito, atente-se ao próximo tópico.

### Teste dos serviços instalados

Se tudo deu certo na instalação dos serviços, você poderá fazer os acessos conforme instruções abaixo:

* Grafana

<http://IP_RASP:3000>

User: admin

Pass: admin

* Prometheus

<http://IP_RASP:9090>

Rodou tudo certinho? Olha que beleza!

Agora já temos todos serviços essenciais rodando em nosso embarcado. Nos tópicos a seguir serão de suma importância, serão neles que toda a integração final ocorrerá.

### Configuração dos serviços

Com o Grafana e Prometheus instalados, seguiremos com o procedimento de configuração dos serviços.

#### Prometheus

Para integrarmos o esp32 com o prometheus, precisamos executar simples passos. Veja abaixo como você deverá fazer isso.

```bash
# 1º
cd /home/pi/services/prometheus

# 2º
cat prometheus.yml
```

Com o último comando acima, você deverá ver em seu terminal o arquivo de configuração abaixo:

```yaml
# my global config
global:
  scrape_interval:     15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
  evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
  # scrape_timeout is set to the global default (10s).

# Alertmanager configuration
alerting:
  alertmanagers:
  - static_configs:
    - targets:
      # - alertmanager:9093

# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
rule_files:
  # - "first_rules.yml"
  # - "second_rules.yml"

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: 'prometheus'

    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.

    static_configs:
    - targets: ['localhost:9090']
```

É nesse arquivo que todas configurações são declaradas. Então temos que dizer para esse arquivo qual *URL* o prometheus deverá ir para requisitar as métricas que estão 'hospedadas' no esp32.

Portanto abre o arquivo *prometheus.yml* e adicione as seguintes configurações no final do arquivo para assim termos o esp32 integrado.

```yaml
  # ESP32
  - job_name: 'esp32'
    scrape_interval: 5s
    static_configs:
    - targets: ['IP_ESP:80']
```

*Obs:* Tente respeitar a indentação do arquivo. A declaração acima deve estar alinhada com **- job\_name:** que encontra-se logo acima.

Finalizando a configuração:

```bash
# 1º - Comando HTTP para recarregar o arquivo de configuração que foi editado no passo acima
curl -X POST 127.0.0.1:9090/-/reload
```

Caso queira validar que o Prometheus continua funcionando normalmente e coletando as métricas do esp32, navegue até a url: <http://IP_RASP:9090/targets>.

Se tiver sucesso, você terá uma tela como a da imagem abaixo mostrando um **"State UP"**.

![Figura 2 - Prometheus](https://github.com/douglaszuqueto/esp32-prometheus/raw/master/.github/prometheus-v1.png)

Agora temos parte do diagrama de fluxo implementado. O prometheus já está apto a recolher as métricas do esp32 dentre o intervalo de 5 segundos.

Com o prometheus já salvando os dados, resta adicionar a dashboard para começar o monitoramento do device.

#### Grafana

Por default, o grafana vem 'zerado', e como queremos pegar os dados salvos do prometheus, é necessário a criação/configuração de um datasource.

**Adicionando datasource**

Navegue até o menu **Configuration** > **Datasources** > *Add data source*.

Na tela, basicamente você precisa configurar apenas a variável **URL** localizada na seção *HTTP* com o IP da sua Raspberry.

Ex: <http://192.168.0.150:9090>

![Figura 3 - Grafana Datasources](https://github.com/douglaszuqueto/esp32-prometheus/raw/master/.github/grafana-datasource-v1.png)

Com o datasource criado, já podemos importar a dashboard que foi especialmente desenvolvida para este projeto.

**Importando a dashboard**

Copie o conteúdo do arquivo json localizado [aqui](https://github.com/douglaszuqueto/esp32-prometheus/blob/master/.github/dashboard-v1.json).

No grafana vá até a opção **Create(+)** > **Import**, cole o conteúdo copiado e clique em *load*. Na tela seguinte você pode alterar o nome da dashboard como também seu identificador - pode manter o mesmo em ambos!

![Figura 4 - Grafana import](https://github.com/douglaszuqueto/esp32-prometheus/raw/master/.github/grafana-import-v1.png)

Como foi visto, eu entreguei uma dashboard pronta para ser utilizada, ela é totalmente customizável. Como forma de estudo, recomendo que veja como cada painel foi configurado.

Para não se estender muito neste projeto, deixarei um bônus para que você possa ter um gostinho de como criar alguns painéis.

### Bônus

Como bônus, será demonstrado como você pode adicionar outros painéis com as devidas métricas oriundas do prometheus.

Passos básicos:

Com a dashboard aberta, clique em **Add Panel**, logo na sequência, **Add Query**.

Observe a tela na figura abaixo:

![Figura 5 - Adicionando paínel](https://github.com/douglaszuqueto/esp32-prometheus/raw/master/.github/grafana-add-panel-v2.png)

Por padrão, na metade superior será apresentado um gráfico vazio e na parte inferior é onde você fará as configurações.

Na retângulo 1 basicamente temos 4 principais menus, sendo eles:

* Queries
* Visualization
* General
* Alert

Queries é o menu que fará o link com o datasource - no nosso caso se trata do prometheus.

Nesse menu, temos um campo(retângulo 3) onde iremos inserir a respectiva query de consulta ao prometheus. Ela retornará os dados para que os mesmos sejam utilizados no gráfico.

Exemplo:

```
esp32_temperature{instance="$instance"}
```

Basicamente estamos requisitando a temperatura do esp filtrando pela "instância", que é o ip do esp. Essa instância é genérica, ou seja, você pode alterar(select localizado no topo da dashboard) entre os devices que estão integrados ao prometheus.

Logo que a query é colocada no campo, o gráfico já é preenchido.

Veja abaixo como criar um *gauge* e uma *table*.

#### Criando um *Gauge*

Baseando-se no exemplo acima, vamos navegar até o menu *Visualization* e trocar o gráfico por *Gauge*. E é isso, automaticamente o componente será mudado e preenchido com os valores, tudo isso devido ao datasource já estar configurado e com a query preenchida.

#### Criando uma *Table*

Ainda com o exemplo anterior, apenas mude para o componente *Table*, percebe que o mesmo processo ocorre. Agora temos uma tabela de histórico das temperaturas :)

### Conclusão

Portanto, a partir do desenvolvimento desse projeto, foi possível montar um sistema simples e eficaz para monitoramento do ESP32 utilizando projetos de código aberto.

Dentre as inúmeras formas de realizar tal monitoramento, essa talvez, seja uma das formas mais simples. Pois se faz necessário apenas um pouco de conhecimento para encaixar as peças.

Foi obtido um resultado bem satisfatório, e com a dashboard pronta, você pode aproveitar para estudar como cada componente foi configurado, e assim, aprender a criar suas próprias dashboards de acordo com seu gosto e necessidades.

Fizemos um uso simples das tecnologias, porém, pode se avançar bastante, incluindo sistemas de alerta via email, telegram dentre outros tipos que já são embarcados nas tecnologias utilizadas.

### Referências

* [Firmware para ESP32 com suporte a integração com WebService e configuração via WiFiManager](https://github.com/douglaszuqueto/esp32-http-firmware)
* [Comunicação remota utilizando RPC e ESP32](https://github.com/douglaszuqueto/esp32-rpc)
* [ESP8266 Prometheus Exporter for DS18B20 OneWire Temperature Sensors](https://github.com/theoretick/esp8266_prometheus_exporter_for_ds18b20_temperature_sensors)
* [Example - Hello Server](https://github.com/espressif/arduino-esp32/blob/master/libraries/WebServer/examples/HelloServer/HelloServer.ino)
* [Example - WiFiClientStaticIP](https://github.com/espressif/arduino-esp32/blob/master/libraries/WiFi/examples/WiFiClientStaticIP/WiFiClientStaticIP.ino)
* [ESP32 internal temperature](https://github.com/espressif/arduino-esp32/issues/2422)


# Pivô de irrigação - Telemetria e Comando

Projeto Telemetria e Comando de Pivô Central de Irrigação

<figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2F9LYeRMPQY4uOpqFw4eFr%2Fpivot-1.png?alt=media&amp;token=6fb379a3-5236-47f0-841b-47733dcaa879" alt="" width="563"><figcaption><p>Pivô de Irrigação</p></figcaption></figure>

Segue abaixo todos os posts:

{% content-ref url="/pages/1MtZpXMqNY4lJIQGSDqV" %}
[Introdução](/projetos/pivo-de-irrigacao-telemetria-e-comando/introducao)
{% endcontent-ref %}

{% content-ref url="/pages/Fjy40b7VXjbRTDWdEwD3" %}
[Elétrica](/projetos/pivo-de-irrigacao-telemetria-e-comando/eletrica)
{% endcontent-ref %}

{% content-ref url="/pages/vIlyj1jrTSaDdS8XnRTB" %}
[Funcionamento lógico](/projetos/pivo-de-irrigacao-telemetria-e-comando/funcionamento-logico)
{% endcontent-ref %}

{% content-ref url="/pages/71JQfwxNugzfxIKxgJt9" %}
[Plataforma](/projetos/pivo-de-irrigacao-telemetria-e-comando/plataforma)
{% endcontent-ref %}

{% content-ref url="/pages/ILHJtyd9G4yhZNsRQA59" %}
[Módulo de Telemetria](/projetos/pivo-de-irrigacao-telemetria-e-comando/modulo-de-telemetria)
{% endcontent-ref %}


# Introdução

Pivô de Irrigação - Telemetria e Comando: Introdução

<figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FmcrgUylOwjRsg908bTgK%2Fpivot-capa.jpeg?alt=media&amp;token=9fc79dc3-5e1c-46f6-9ff7-9ea6fb3fcb64" alt="" width="375"><figcaption><p>Pivô de Irrigação</p></figcaption></figure>

**💡 Qual o projeto que mais lhe deu orgulho de desenvolver mas ao mesmo tempo foi o mais complexo? 💬💬**\
\
🎯 O meu, foi controlar esse "bichão" do #Agro, vulgo #Pivô Central de Irrigação!\
\
Esse, infelizmente foi o projeto que não deu certo, mas trouxe muitos aprendizados 🙌\
\
O objetivo do projeto era atuar tanto na coleta e monitoramento da telemetria como também no comando do pivô.\
\
O projeto era constituído de 3 módulos (placas).\
\
✅️ Módulo de potência\
✅️ Módulo de telemetria\
✅️ Módulo GPS\
\
🔶️ O módulo de potência era responsável pela comunicação com a camada de potência do pivô (contatores).\
\
🔶️ O módulo de telemetria era conectado no módulo de potência e a comunicação ocorreria via relês. A comunicação com a nuvem se dava pela conectividade WiFi e protocolo MQTT.\
\
🔶️ Já o módulo GPS era instalado na ponta do Pivô, onde se comunicava via LoRa P2P com o módulo de telemetria, que ficava no centro do pivô.\
\
O projeto foi desenvolvido durante 2 anos, e passei por todas as fases, desde a PoC, MVP e produto final.\
\
Durante a fase da PoC e MVP, toda infraestrutura foi feita na plataforma TagoIO, desde a gestão dos Dispositivos até a aplicação final com a dashboard que mostrava a telemetria em tempo real, assim como toda a parte de comando do pivô.\
\
Já no produto final, continuamos com a TagoIO, entretanto, usando apenas os serviços de Broker MQTT e Device Management. Para a aplicação final, foi desenvolvida a própria plataforma - Web e Mobile.\
\
E ai, o que achou?!\
Querem mais posts relatando em detalhes toda tecnologia envolvida no processo como também o funcionamento do pivô? Deixe nos comentários 💭


# Elétrica

Pivô de Irrigação - Telemetria e Comando: Elétrica

<figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FJR1nUijlOxFWtYVLb8O5%2Fpivot-2.jpeg?alt=media&amp;token=e3290f06-6aa1-4a95-99ef-5514e56b9a47" alt="" width="375"><figcaption><p>Pivô de Irrigação</p></figcaption></figure>

**🚀 Dando sequência à série do projeto de controle e telemetria do** [**#Pivô**](https://www.linkedin.com/feed/hashtag/?keywords=piv%C3%B4\&highlightedUpdateUrns=urn%3Ali%3Aactivity%3A7272762106100219904) **Central de** [**#Irrigação**](https://www.linkedin.com/feed/hashtag/?keywords=irriga%C3%A7%C3%A3o\&highlightedUpdateUrns=urn%3Ali%3Aactivity%3A7272762106100219904)\
\
O funcionamento do pivô central é relativamente "simples", assim como a elétrica, conforme pode ser observado na imagem em anexo. Claro, que toda a montagem exige cuidados e conhecimento - mas os profissionais da área, tiram isso de letra. Para os amantes da eletrônica, o painel é quase uma obra de arte 😁\
\
No que tange a parte elétrica, se faz necessário poucos componentes para o devido funcionamento do pivô, tais como:\
\
🔶️ Chave geral\
🔶️ Disjuntores\
🔶️ Transformador\
🔶️ Contatores auxiliares\
🔶️ Contatores de potência\
🔶️ Chaves seletoras\
🔶️ Pressostato\
🔶️ Segurança\
\
No projeto, sempre se prezou pela simplicidade, não só de montagem, mas principalmente pela facilidade de manutenção. Isso se estendia desde a elétrica e o hardware até mesmo à nossa plataforma. Estava no DNA: menos é mais!\
\
O operador na roça, quer algo simples e intuitivo, que, em poucos cliques, permita observar o estado dos pivôs, bem como operá-los.\
\
Sobre o operação propriamente dita, o pivô pode ser operado de duas formas:\
\
✅️️ Modo Manual: Operador precisa ir até o centro do pivô para configurá-lo e ligá-lo\
✅️️ Modo Rede: Operador pode controlar remotamente através do aplicativo.\
\
Referente à parte do Aplicativo, era possível coletar e comandar os seguintes parâmetros/variáveis:\
\
🎯 Telemetria\
\
✅️ Direção (avanço ou reverso)\
✅️ Modo (seco ou água)\
✅️ Percentímetro (velocidade/lâmina d'água)\
✅️ Segurança\
✅️ Tensão\
✅️ Pressão\
✅️ Motobomba\
✅️ Status\
✅️ GPS\
\
🎯 Comando\
\
✅️ Modo (seco ou água)\
✅️ Direção (avanço ou reverso)\
✅️ Percentímetro (velocidade/lâmina d'água)\
✅️ Comando(ligar ou desligar)


# Funcionamento lógico

Pivô de Irrigação - Telemetria e Comando: Funcionamento lógico

<figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2F9LYeRMPQY4uOpqFw4eFr%2Fpivot-1.png?alt=media&amp;token=6fb379a3-5236-47f0-841b-47733dcaa879" alt="" width="375"><figcaption><p>Pivô de Irrigação</p></figcaption></figure>

O pivô, quando controlado pelo aplicativo, segue determinadas tarefas de acordo com o comando recebido - mas basicamente o que as diferencia num geral, é apenas o modo - se é seco, ou água.

O comando enviado pelo aplicativo basicamente se resume em 4 parâmetros, sendo eles:

✅️ Direção (avanço ou reverso) ✅️ Modo (seco ou água) ✅️ Percentímetro (velocidade/lâmina d'água) ✅ Comando (iniciar ou parar)

São comandos binários, 0 ou 1, ou 0 a 100

Quando o pivô recebe o pacote, o microcontrolador interpreta, valida as informações e em seguida começa a lógica de acionamento que irá variar entre o contexto de modo seco ou água.

🌞 Modo Seco: é verificado a segurança do pivô, e caso esteja tudo certo, é acionado o contator da direção e posteriormente o percentímetro entra em ação.

🌧 Modo Água: também é verificado a segurança, logo após é acionado o contator para chamar a bomba(pode ser por fio ou via rádio). Assim que á bomba é ligada, entra-se no estágio de pressurização, consequentemente se tem uma tarefa que fica lendo o valor do sensor de pressão, e assim que chegar em determinado valor, o contator de direção é acionado e também o percentímetro.

Observe que ambas as tarefas são parecidas, o que as diferencia é apenas a chamada de bomba/pressurização, que em modo seco ela é ignorada.

Depois, com o pivô rodando, as tarefas de segurança e pressurização(apenas água) ficam sendo executadas o tempo todo.

Em caso de qualquer anomalia, o sistema de segurança é acionado e o pivô para imediatamente - seja por desalinhamento, falha na pressurização e etc.

⁉️ Saiba mais

✅ Segurança: Todo pivô tem um sistema de segurança - que é o principal e o mais crucial, pois é através dele que o pivô para imediatamente em caso de alguma anomalia(geralmente por desalinhamento) para não tombar.

Tem alguns sistemas no mercado, mas o mais comum é um fio que percorre todos os lances do pivô até a última torre e retorna o sinal em outro fio. Faz-se a leitura e com isso se verifica se está tudo ok(1) ou se está com problema(0), por exemplo.

✅ Percentímetro: equipamento responsável pelo controle de velocidade do pivô.

Resumidamente, é um timer, que conta o tempo e faz o acionamento do contator para o pivô andar. Se a velocidade é definida em 50%, o contator ficará acionado durante 30 segundos, e os 30 restantes ficará desligado.

O percentímetro é crucial para o funcionamento, principalmente em modo água, pois é com base na velocidade que se sabe a lâmina d'água aplicada.

.

💡Tem mais curiosidades sobre o funcionamento lógico do pivô? Deixe nos comentários.


# Plataforma

Pivô de Irrigação - Telemetria e Comando: Plataforma

<figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FxGe0y907reJGpKNyx8QM%2Fpivot-edit-1-8-pages-images-0.png?alt=media&amp;token=7efc4ef2-75e4-4d8c-86a3-cfbcd31a4d55" alt=""><figcaption></figcaption></figure>

<div><figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FxGe0y907reJGpKNyx8QM%2Fpivot-edit-1-8-pages-images-0.png?alt=media&amp;token=7efc4ef2-75e4-4d8c-86a3-cfbcd31a4d55" alt=""><figcaption></figcaption></figure> <figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FNE0P8BrFeOAO3qbiQrYQ%2Fpivot-edit-1-8-pages-images-1.jpg?alt=media&amp;token=47306722-babe-4849-be05-db84f7d5f510" alt=""><figcaption></figcaption></figure> <figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FWfyvErevQMio7bxiBty1%2Fpivot-edit-1-8-pages-images-2.jpg?alt=media&amp;token=fe64e200-b28d-47d7-9fda-e3b344b7adf6" alt=""><figcaption></figcaption></figure> <figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FOtLaX8TnPfj1EoK5T9lU%2Fpivot-edit-1-8-pages-images-3.jpg?alt=media&amp;token=ed1fa509-2046-437c-9167-77260b4463dd" alt=""><figcaption></figcaption></figure> <figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FXTw7OIdoSXS9uhzFdK0f%2Fpivot-edit-1-8-pages-images-4.jpg?alt=media&amp;token=d2a5ab91-c8c1-42e4-b334-c049f0f8cc6f" alt=""><figcaption></figcaption></figure> <figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FalhK90BL2tVRjTMQOUpy%2Fpivot-edit-1-8-pages-images-5.jpg?alt=media&amp;token=67ac99a0-1b91-49ce-94bd-8bcf853bb2a5" alt=""><figcaption></figcaption></figure> <figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FoqWmi08nrkoYOKlayHeE%2Fpivot-edit-1-8-pages-images-6.jpg?alt=media&amp;token=e7e3f39d-3135-4de6-98e1-e6403253ab76" alt=""><figcaption></figcaption></figure> <figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FnxvdTjm20B4V8X1k9g7K%2Fpivot-edit-1-8-pages-images-7.jpg?alt=media&amp;token=7cb8c69d-0175-4908-840e-ea64987ad270" alt=""><figcaption></figcaption></figure></div>

**🎯 Plataforma desenvolvida para Controle e Telemetria de** [**#Pivô**](https://www.linkedin.com/feed/hashtag/?keywords=piv%C3%B4\&highlightedUpdateUrns=urn%3Ali%3Aactivity%3A7273460766383489024) **Central de** [**#Irrigação**](https://www.linkedin.com/feed/hashtag/?keywords=irriga%C3%A7%C3%A3o\&highlightedUpdateUrns=urn%3Ali%3Aactivity%3A7273460766383489024)**.**\
\
Nas imagens em anexo, a plataforma de aplicação, onde permitia ter a telemetria do Pivô em tempo real, assim como comandá-lo remotamente.\
\
O projeto era dividido em 4 partes, sendo elas:\
\
🔶 Device Management(TagoIO): responsável por oferecer o Broker MQTT, como também a gestão do dispositivo(dados, payload parser e etc).\
\
🔶 DataSync: responsável por receber os dados(telemetria, alertas e GPS) encaminhados pela TagoIO e sincronizar internamente com o banco de dados e posterior processamento das regras de negócio.\
\
🔶 API: responsável por servir uma interface rest para o App e WebApp\
\
🔶 APP: Aplicativo final do usuário\
\
📌 Stack\
\
✅ Linguagem Go(Golang)\
✅ GRPC / GRPC Gateway\
✅ Protocolo MQTT\
✅ Banco de dados PostgreSQL\
✅ Redis\
✅ RabbitMQ\
✅ ReactJS\
✅ Material UI(MUI)


# Módulo de Telemetria

Pivô de Irrigação - Telemetria e Comando: Módulo de Telemetria

<figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FyKCpIOwTSLaoaVfg9v8I%2Fpivot-5.png?alt=media&amp;token=8b48ec11-087c-4160-ae39-26621a16ea7b" alt="" width="375"><figcaption><p>Pivô de Irrigação</p></figcaption></figure>

**📌 O que é:**

O módulo de telemetria que vai instalado na ponta do pivô(última torre), tem como objetivo em sua grande maioria, coletar as coordenadas geográficas obtidas pelo GPS e encaminhar para a base. Com essa informação, sabe-se o ângulo de onde o pivô se encontra.

Essa informação somada com as configurações do pivô, podem auxiliar em ações como:

✔️ Plotagem da posição no APP ✔️ Paradas por ângulo - irrigar até posição X ✔️ Desligar o canhão(para não molhar a estrada por exemplo)

Geralmente essa comunicação ocorre via RF(LoRa, ZigBee e etc) P2P(ponta a ponta) com a base do pivô.

Porém, alguns dispositivos podem funcionar em modo standalone, coletando outras informações como:

✅️ GPS \
✅️ Pressão\
✅️ Tensão

🔶 Com base no GPS, calcula-se o ângulo do pivô, além disso é possível saber se o pivô está rodando em modo avanço ou reverso.

🔶 Com o sensor de pressão, sabe-se se o pivô está rodando em modo seco ou água.

🔶 Com a tensão, sabemos se o pivô está energizado como também o valor médio da tensão.

Esse tipo de dispositivo é extremamente útil, quando o cliente não quer gastar muito para por automação no painel para ter toda telemetria e comando. Muitas vezes ele só quer saber se o pivô está rodando.

Sobre a conectividade, esse dispositivo pode se comunicar por:

✅️ LoRa / Zigbee \
✅️ LoRaWAN \
✅️ NB-IOT / 4G / 5G \
✅️ Satélite


# Individualização de Água e Gás

Projeto individualização de água e gás para condomínios

<figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FzjiBPQMwihwiF3Xk3WKX%2FCo%CC%81pia%20de%20water.png?alt=media&amp;token=b07dfb29-1476-448d-a93f-716a0026e930" alt="" width="563"><figcaption><p>Projeto individualização de água e gás para condomínios</p></figcaption></figure>

<div><figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FzjiBPQMwihwiF3Xk3WKX%2FCo%CC%81pia%20de%20water.png?alt=media&amp;token=b07dfb29-1476-448d-a93f-716a0026e930" alt="" width="563"><figcaption></figcaption></figure> <figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2Fi8LzYrmK3VCpxALLm5kO%2F2.png?alt=media&amp;token=e2c03b2d-4d5c-41ce-9275-a9b47216d6d7" alt="" width="563"><figcaption></figcaption></figure> <figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FhN4UlfDrFGwISl6tR5NR%2F3.png?alt=media&amp;token=4faad651-640f-45cc-a06e-119b400bcfac" alt="" width="563"><figcaption></figcaption></figure> <figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FJtudO6WnJtOvei6zH4nI%2F4.png?alt=media&amp;token=ae3c6ba5-7f15-4835-9c6c-1d040e99129b" alt="" width="563"><figcaption></figcaption></figure> <figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FerctRMpzrAQ0CcCQajUa%2F5.png?alt=media&amp;token=587f1a9c-c388-45a3-9a13-beb90829a565" alt="" width="563"><figcaption></figcaption></figure></div>

{% content-ref url="/pages/w7fBF8qiGqKFgJSo7pDx" %}
[Introdução](/projetos/individualizacao-de-agua-e-gas/introducao)
{% endcontent-ref %}

{% content-ref url="/pages/OggAThuGg7gc1fwCURMR" %}
[Dashboard administrativa](/projetos/individualizacao-de-agua-e-gas/dashboard-administrativa)
{% endcontent-ref %}

{% content-ref url="/pages/6VuUm4D7CKRwAToyAeRs" %}
[Dashboard usuário](/projetos/individualizacao-de-agua-e-gas/dashboard-usuario)
{% endcontent-ref %}


# Introdução

Projeto individualização de água e gás para condomínios

<figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2FV4g7VmeHh9eHXO0xl2lk%2F1.png?alt=media&amp;token=715d555c-f7fc-4372-8171-100eacfeb7d6" alt="" width="375"><figcaption><p>Projeto individualização de água e gás para condomínios</p></figcaption></figure>

Hoje, estou dando início ao desenvolvimento de mais um projeto - desafiador por sinal!\
\
O projeto já passou por todas fases de dimensionamento e viabilidade, e agora dou o start no provisionamento dos devices, configuração, testes de conectividade, integração com a plataforma e escrita do Payload Parser.\
\
Para a fase da PoC, será usado:\
\
✅ TX121 da [BottomUP Technology](https://www.linkedin.com/company/bottomup-technology/)\
✅ Conectividade NB-IOT(TIM/NEO) da [VIRTUEYES IoT Solutions](https://www.linkedin.com/company/virtueyes/)\
✅ Plataforma IoT [TagoIO](https://www.linkedin.com/company/tagoio/)\
✅ [Cloudflare](https://www.linkedin.com/company/cloudflare/) Workers\
✅ VPS da [DigitalOcean](https://www.linkedin.com/company/digitalocean/)\
\
Com o device já testado, dou inicio na estruturação das regras de negócio(Analysis) e Dashboards Administrativas e para o usuário final.\
\
Vem muitos desafios pela frente, mas também muita tecnologia - incluindo muito EdgeComputing com TagoCore e Cloudflare Workers. Aguarde!\
\
.\
\
Precisa tirar seu projeto do papel? Eu posso te ajudar! Entre em contato 🎯


# Dashboard administrativa

Projeto individualização de água e gás para condomínios

<figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2F4qaVM8DaUhvB27rokpOe%2F3.png?alt=media&amp;token=1524647d-8e18-42e3-9ac4-7adf5d872f16" alt="" width="375"><figcaption><p>Projeto individualização de água e gás para condomínios</p></figcaption></figure>

Como mencionado no post anterior, para esta fase da PoC e MVP do projeto, será utilizado o TX121 da BottomUP com conectividade NB-IOT que contém uma entrada pulsada.

O device será configurado para enviar a sua telemetria 2 vezes ao dia - mais que suficiente para estes contextos de medição. Com isso, consigo diminuir os custos operacionais com infraestrutura e principalmente, prolongar a vida útil da bateria, que deverá durar alguns anos.

📌 Quais as variáveis encaminhadas pelo dispositivo TX121:

✔️ IMEI \
✔️ ICCID\
✔️ PL1 - contador de pulsos \
✔️ AN1 - entrada analógica 1 \
✔️ AN2 - entrada analógica 2 \
✔️ Versão do Firmware \
✔️ Bateria \
✔️ RSSI \
✔️ TX Time - tempo de transmissão

📌 Quais variáveis que serão utilizadas para o projeto:

✅ PL1 \
✅ Bateria \
✅ RSSI

Hoje, conforme a imagem em anexo, desenvolvi o primeiro Template / Dashboard na TagoIO, com o objetivo de ter uma gestão administrativa do device - onde terá os dados técnicos como nível e histórico da Bateria e RSSI, como também o consumo acumulado do mês em metros cúbicos.

O próximo passo será desenvolver a dashboard do cliente final, que será parecida, porém no lugar das informações técnicas terá o histórico do consumo diário como também o mensal.

Até o próximo post 🙏 🇧🇷🇧🇷🇧🇷


# Dashboard usuário

Projeto individualização de água e gás para condomínios

<figure><img src="https://3338773088-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M15s4TnAJw6r_zYzKkX%2Fuploads%2Fi8LzYrmK3VCpxALLm5kO%2F2.png?alt=media&amp;token=e2c03b2d-4d5c-41ce-9275-a9b47216d6d7" alt="" width="375"><figcaption><p>Projeto individualização de água e gás para condomínios</p></figcaption></figure>

No post anterior, trouxe um overview de como ficou a dashboard administrativa do device TX121, trazendo uma abordagem mais técnica focada na gestão do mesmo.\
\
Já, para a dashboard do cliente, terá 3 widgets, sendo eles:\
\
✅ Consumo acumulado do mês\
✅ Histórico diário do mês corrente\
✅ Histórico mensal do ano corrente\
\
Então, será através dessa dashboard que o cliente final do apartamento terá acesso, seja via Web ou também via Aplicativo.\
\
Próximos passos serão em decorrer de criar um ecossistema administrativo na plataforma para gerir:\
\
✔️ Condomínios\
✔️ Apartamentos\
✔️ Hidrômetros\
✔️ Usuários\
\
⁉️ Curiosidades\
\
Uma das grandes vantagens que considero na Plataforma IoT TagoIO é o módulo de Analysis.\
\
Através desse módulo, podemos escrever praticamente qualquer regra de negócio para compor o projeto/produto.\
\
Análises, basicamente é um código que você escreve em JavaScript/TypeScript que é executado pelo próprio runtime da plataforma ou também de forma externa. Cada análise é trigada através de alguma ação - trarei mais detalhes em posts futuros.\
\
Ter essa flexibilidade em uma plataforma é fundamental para atender desde pequenos até grandes projetos em diferentes contextos e regras de negócio.\
\
Até o momento, o projeto conta com 2 análises - 1 para compor o histórico diário e outra para o histórico mensal.\
\
Em ambos casos, é criada uma Action(outro módulo da plataforma) do tipo Cron(que será o gatilho), onde uma análise é executada todo dia às 00:00 para processar o relatório diário, e a outra executada todo início do mês para compor o relatório mensal.


# Monitor de Energia

{% hint style="warning" %}
Em construção
{% endhint %}


# Monitor Geração Solar

{% hint style="warning" %}
Em construção
{% endhint %}


# Monitor de pressão

{% hint style="warning" %}
Em construção
{% endhint %}


# Monitor Temperatura e Umidade

{% hint style="warning" %}
Em construção
{% endhint %}


# Acionamento remoto de cargas

{% hint style="warning" %}
Em construção
{% endhint %}