Forem: Henrique Machado Broseghini

Jornada para me tornar um DevOps Jr

Henrique Machado Broseghini — Mon, 30 Jan 2023 21:57:29 +0000

O começo

A Comunidade e o DevOpsDay Vitoria

No inicio eu estudava e trabalhava com frontend, mas fui muito bem abraçado e acolhido pela comunidade DevOps, costumo dizer que fui adotado por eles, mas sinto que a palavra que defini essa comunidade é ACOLHIMENTO.

Sempre me senti um pouco sozinho no meio da TI por não conhecer pessoas com mesmos ideais que eu. E estar com eles me traz muito uma sensação que estou em um ambiente de amizade e seguro.

Sempre gostei de ensinar, tanto que comecei meu blog e fiz o Arduino4Noobs junto com a comunidade He4rt, e fazendo parte de movimentos sociais como o nucleo de tecnologia do MTST, onde ensinamos programação e temos diversos projetos para ajudar e facilitar a vida dos acampados.

No meio disso tudo fui ficando cada vez mais próximo do Jeferson o badtux_, fizemos o bonde o MTST, fui para o DevOpsDay Vitoria, que ai está um ponto importante, pois sinto que depois desse evento minha vida mudou completamente.

Eu estava a muitos meses sem sair de casa devido a depressão, mas estar no DevOpsDay, me deu muito mais energia, vi como somos muito queridos, conheci pessoas super importantes para mim, e recebi os melhores abraços.

Depois de algum tempo comecei minha mentoria com o Jef e virei embaixador LINUXtips e com todo esse esfôrço e dedicação junto com o Jef consegui a minha vaga como Analista DevOps na SPIRITSEC.

E o melhor e o que mais gosto disso tudo, foi que conheci pessoas que hoje são meus amigos e que tenho um imenso carinho e admiração.

Entrando na SpiritSec

A primeira Semana

Comecei na Spiritsec dia 18/01/2023. Nessa Primeira semana aprendi muitas coisas novas e consegui aplicar muitos conhecimentos adquiridos com os cursos da Linuxtips. Trabalhar junto do Gleydson ( criador do Guia Foca ), Michelle, Gian e Mateus tornam esse inicio de carreira muito mais tranquilo, me dando confiança e animo nos novos desafios.

Estou feliz com minha evolução e como consigo ver uma grande crescimento profissional e pessoal junto com a SpiritSec

Acionamento do motor de acordo com a hora.

Henrique Machado Broseghini — Mon, 25 Apr 2022 22:05:07 +0000

Deixarei o repositório do projeto aberto para que vocês possam utilizar também.

Bibliotecas adicionadas:

#include <NTPClient.h>

O NTP(Protocolo de Tempo para Redes), é o padrão que permite a sincronização dos relógios dos dispositivos de uma rede. Além do protocolo de comunicação em si, o NTP define uma série de algoritmos utilizados para consultar os servidores, calcular a diferença de tempo e estimar um erro, escolher as melhores referências e ajustar o relógio local.

Associações entre dispositivos:

Permanentes: são criadas por uma configuração ou comando e mantidas sempre. Este é o tipo de associação recomendável para se trabalhar em aplicações do dia a dia.

Priorizáveis: são específicas da versão 4 do NTP e criadas por uma configuração ou comando, podem ser desfeitas no caso de haver um servidor melhor, ou depois de um certo tempo.

Efêmeras ou transitórias: são criadas por solicitação de outro dispositivo NTP e podem ser desfeitas em caso de erro ou depois de um certo tempo.

Estou utilizando a permanente.

Resolvi utilizar esse método pois, ao tentar fazer usando a biblioteca ctime, que gera uma struct com os dados de dias e horas não estava funcionando.

Ao ser utilizado junto ao esp32 ele não recebia a hora, pois essa estrutura recebe a hora do computador em que esta sendo executado.

Por esse motivo decidi receber as informações direto via internet.

Pelo site NTP.br, e usando o link dentro da função timeClient.

Código para acionamento do motor:

void ligaHora(void) {
    WiFiUDP ntpUDP;
    NTPClient timeClient(ntpUDP, "a.st1.ntp.br", -3 * 3600, 6000);
    int horas = timeClient.getHours();
    int minutos = timeClient.getMinutes()+ 10;

    Serial.printf("\nHora: %i ", horas);
    Serial.printf("\nMinutos: %i ", minutos);

    if ((horas == 7 && minutos == 0)) {
        digitalWrite(PIN_LED, HIGH);
        Serial.println("\nAcendeu");
        delay(9000);
        digitalWrite(PIN_LED, LOW);
        delay(60000);
    };
}

Dentro da função timeClient, é passado como parâmetro, o, o site em será pego as informações, a mudança de fuso horário.

Logo em seguida é criado as variáveis inteiras horas e minutos recebendo respectivamente seus valores pela função getHours e getMinute. Somei mais 10 (dez) nos minutos, para diminuir a diferença entra a hora adquirida com a hora local. Pode ter está diferença de acordo com o servidor.

Imprimo os mesmos para ter uma noção de como estão.

Logo em seguida faço o código que ira acionar o motor. Quando o horario for igual a 7 horas e 0 minutos, ele ligará e desligara depois de 9 segundos. Ficará em espera por 1 (um) minuto para que não se acione novamente.

Chamo a função ligaHora dentro da função loop:

void loop() {
    VerificaConexoesWiFIEMQTT();

    MQTT.loop();
    ligaHora();

    delay(2000);
}

Essa função loop chama as outras funçãos de verificação, mqtt e ligar o motor a cada 2 (dois) segundos.

Programação do ESP32 - Liga/desliga motor

Henrique Machado Broseghini — Wed, 22 Dec 2021 23:42:07 +0000

Github do projeto

Todo o código esta disponível em meu github.

PlatformIO IDE no VS code

Para programar o ESP32 doit-devkit-v1(modelo) eu utilizei a extensão PlatformIO no VS code.

Broker rodando no Raspberry

Código embarcado no ESP32

Utilizei a linguagem C++ para a programação, no inicio do código importei as bibliotecas.

// Bibliotecas necessárias
#include <Arduino.h>
#include "WiFi.h"
#include "PubSubClient.h"

A importação do Arduino.h é necessária pois estou utilizando o PlatformIO.

Depois defini as variáveis que irei utilizar.

#define PIN_LED 25 // Pino usado no ESP-32

#define TOPICO_SUBSCRIBE_LED "topico_liga_desliga_led" // Nome do Tópico, pode ser qualquer nome
#define ID_MQTT "esp32_mqtt" // ID do seu MQTT

const char* SSID = "Nome_Rede_Wifi";
const char* PASSWORD = "sua_senha";

const char* BROKER_MQTT = "Endereço do MQTT Broker";
int BROKER_PORT = 1883;//porta_do_broker

WiFiClient espClient;
PubSubClient MQTT(espClient);

//Declarando funções
void initMQTT(void);
void mqtt_callback(char* topic, byte* payload, unsigned int length);
void reconnectMQTT(void);
void reconnectWiFi(void);
void VerificaConexoesWiFIEMQTT(void);

/* Função: inicializa e conecta-se na rede WI-FI desejada */
void initWiFi(void) 
{
    delay(10);
    Serial.println("------Conexao WI-FI------");
    Serial.print("Conectando-se na rede: ");
    Serial.println(SSID);
    Serial.println("Aguarde");

    reconnectWiFi();
}

/* Função: inicializa parâmetros de conexão MQTT(endereço do broker, porta e seta função de callback) */
void initMQTT(void) 
{
    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)
}

A função mqtt_callback roda a lógica principal da aplicação, fazendo com que o motor seja iniciado e desligado após 9 segundos. com o sinal enviado via celular para o broker MQTT, que esta no raspberry.

/* Função: função de callback */
void mqtt_callback(char* topic, byte* payload, unsigned int length) 
{
    String msg;

    /* obtém a string do payload recebido */
    for(int i = 0; i < length; i++) 
    {
       char c = (char)payload[i];
       msg += c;
    }

    Serial.print("Chegou a seguinte mensagem via MQTT: ");
    Serial.println(msg);

    if (msg.equals("1"))
    {
        digitalWrite(PIN_LED, HIGH);
        Serial.print("LED aceso mediante comando MQTT");
        delay(9000);
        digitalWrite(PIN_LED, LOW);
    }

}

Caso o subscriber não consiga se conectar com o broker ele fica tentando se conectar ate que haja exito.

/* Função: reconecta-se ao broker MQTT */
void reconnectMQTT(void) 
{
    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_LED); 
        } 
        else
        {
            Serial.println("Falha ao reconectar no broker.");
            Serial.println("Haverá nova tentativa de conexão em 2s");
            delay(2000);
        }
    }
}

Estas funções verificam se há conexão com o Wifi e ao Broker MQTT.

A função VerificaConexoesWiFIEMQTT chama as funções reconnectMQTT e reconnectWiFi.

/* Função: verifica o estado das conexões WiFI e ao broker MQTT. */
void VerificaConexoesWiFIEMQTT(void)
{
    if (!MQTT.connected()) 
        reconnectMQTT();

     reconnectWiFi();
}

/* Função: reconecta-se ao WiFi */
void reconnectWiFi(void) 
{
    if (WiFi.status() == WL_CONNECTED)
        return;

    WiFi.begin(SSID, PASSWORD); 

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

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

O setup é a primeira coisa que o programa roda assim que é iniciado, definindo o Serial, o pino como saída é setado inicialmente como desligado, depois chamando as funções initWiFi e initMQTT.

void setup() {
  Serial.begin(115200);

  pinMode(PIN_LED, OUTPUT);
  digitalWrite(PIN_LED,LOW);

  initWiFi();

  initMQTT();
}

A função loop fica chamando periodicamente à cada 2 segundos as funções VerificaConexoesWiFIEMQTT, MQTT.loop

void loop() {
    VerificaConexoesWiFIEMQTT();

    MQTT.loop();
    delay(2000);
}

Configurações do PlatformIO

[env:esp32doit-devkit-v1]
platform = espressif32
board = esp32doit-devkit-v1
framework = arduino
monitor_speed = 115200
upload_speed = 921600
upload_port = COM3 ; Porta serial do seu computador
lib_deps = knolleary/PubSubClient@^2.8 ; biblioteca necessárias para o uso do MQTT

A porta serial você pode encontra no Gerenciador de Dispositivos, o meu no caso esta na porta 3 (COM3), lembre-se de instalar o drive da placa para que seu computador reconheça o dispositivo.

Exemplo do funcionamento do ESP32

O exemplo foi feito na protoboard e com led, acendendo e apagando após 9 segundos.

Construção do recipiente da ração automática.

Henrique Machado Broseghini — Mon, 22 Nov 2021 03:41:21 +0000

O que foi utilizado:

Placa de alumínio para:

Encaixe do cano no alimentador
Hastes de suporte para o cano

Alimentador

Motor
Eixo de rosca helicoidal
Caixa de aço inoxidável

Cano de 1,20 metro aproximadamente

Especificações do Motor:

O motor utilizado foi um de 12V com um rotação de 90 RPM, que é também usado em vidros de carro. Tendo uma capacidade de ate 50Kg.

Funcionamento da comedouro:

O recipiente tem um motor que em seu eixo há uma rosca helicoidal, com seu giro faz que a ração caia no pote de ração.

Preparação do encaixe:

Primeiramente cortei uma placa de alumínio aproximadamente 17.5cm X 15.0cm, para encaixar na parte superior do comedouro fiz alguns furos em sua superfície para facilitar o corte.

Depois de fazer o corte utilizando um serrinha, ela ficou dessa maneira, para a passagem da ração.

Utilizando o mesmo material da placa de aço, fiz as hastes de suporte para o cano, dobrando, cortando e furando para o encaixe dos parafusos.

Ficando desta maneira o encaixe do cano com a placa e o suporte.

Você pode ver o funcionamento do alimentador nesse link do vídeo no meu twitter.

Servidor MQTT-Mosquitto em Raspberry pi 3 B+

Henrique Machado Broseghini — Mon, 30 Aug 2021 17:16:06 +0000

Instalação do Ubuntu Server no Raspberry

Para a instalação é necessário a formatação do seu cartão SD, no meu caso eu utilizei o SD Card Formatter. Também devemos ter a imagem do Ubuntu Server. Tendo completado essas duas etapas tenha instalado em seu computador um software que escreve a imagem em seu cartão SD, temos o balenaetcher que é bastante utilizado, mas eu optei em utilizar o Raspberry Pi Imager, feito isso basta você escrever a imagem utilizando algum desses softwares citados.

Configuração do Ubuntu Server

Se você planeja deixar o seu raspberry em uma conexão Wi-fi deve seguir esses passos:

Primeiro abra o diretório do cartão SD em seu computador e ache a pasta “system-boot” e encontre o arquivo network-config. Abra esse arquivo em algum editor de texto remova os "#", que fazem com que a linha seja lida como um comentário.

Mude os valores do wifi network name, para o nome da sua rede wifi e o wifi password para sua senha. Como no exemplo abaixo:

Caso você vá utilizar seu raspberry com o cabo de rede, pode pular a parte de cima.

Tendo feito alguma dessas etapas você já pode colocar o cartão SD em seu raspberry. Conectando em um monitor e com teclado basta ligar o seu raspberry e logar no server com o login e senha padrão: ubuntu.

Para uma conexão via SSH faça o download do Putty e do angry ip scanner ou o network scanner no android, para obter o IP do seu raspberry.

Instalação do Docker no Ubuntu Server

Para esse projeto eu escolhi utilizar o docker para estar "virtualizando" a imagem do mosquitto, para que futuramente eu possa utilizar um cluster com 3 (três) raspberrys para ter uma orquestração utilizando Kubernetes. Para poder colocar em pratica oque aprendi com o curso DESCOMPLICANDO DOCKER da Linuxtips.

Para a instalação:

$ sudo apt-get update
$ sudo apt-get install docker-ce docker-ce-cli containerd.io

Para testar se a instalação foi bem sucedida digite: docker version.

Baixando imagem do Mosquitto e inicialização do container

Para baixar o imagem basta você digitar: docker pull eclipse-mosquitto, com isso basta digitar docker image ls para ver todas as imagens digite e selecionar a mosquitto, digitando docker container run <"ID da imagem">.

Com isso o seu container estará em execução e pronto para ser configurado para comunicação com seu arduino.

Projeto de automação de ração e água.

Henrique Machado Broseghini — Wed, 25 Aug 2021 19:28:29 +0000

Nesse primeiro post pretendo mostrar somente minhas ideias e mais para frente ir mostrando mais código e prototipagem. Deixarei o repositório do projeto aberto para que vocês possam ir vendo a evolução do projeto.

Principais ideias:

Com o Arduino

ÁGUA:

Para o sistema de reabastecimento de água, tenho como ideia principal o uso de uma válvula solenoide junto com um rele. Sendo reabastecida de acordo com a hora marcada. E também pelo app do celular para uma ativação a qualquer momento.

COMIDA:

Para o sistema de ração, pensei em um tubo ou cano com um sistema em espiral dentro. Essa espiral ira girar com a ajuda de um motor que será controlado pelo arduino. Sendo ativado duas vezes ao dia de acordo com a hora marcada, ou via app para uma ativação instantânea.

Com o Raspberry:

Servidor - MOSQUITTO:

Estará rodando no raspberry pi 3 B+, utilizando Docker para que futuramente eu possa estar fazendo um cluster (que é uma das ideias de automação residencial).

Aplicativo:

A prototipação esta sendo feita pelo Figma e o app será feito em Kotlin, ainda estou estudando sobre o desenvolvimento mobile. A comunicação do app com o arduino será feita com um servidor MQTT.