Arduino na automação de pequenos negócios

O uso do Arduino em pequenos negócios é uma forma eficaz e acessível de implementar automação personalizada. Com um microcontrolador simples, como o Arduino Uno, é possível monitorar variáveis ambientais, controlar dispositivos elétricos e até registrar dados remotamente, tudo isso com baixo custo e alto grau de customização.

Por que usar Arduino?

Baixo custo: um Arduino Uno custa cerca de R$ 80–90; sensores básicos, como DHT11, custam menos de R$ 10.
Flexibilidade: fácil de integrar com sensores, atuadores, módulos de comunicação (Wi-Fi, GSM, RFID).
Código aberto: ambiente de desenvolvimento gratuito (Arduino IDE) e bibliotecas disponíveis para a maioria dos componentes.
Comunidade ativa: farta documentação, fóruns e tutoriais.

Exemplos técnicos de automação

1. Controle de Iluminação Inteligente com Sensor PIR

Componentes:
- Arduino Uno
- Sensor de movimento PIR (HC-SR501)
- Módulo relé 5V
- Lâmpada 127V ou 220V
Lógica: o sensor PIR detecta movimento. Se houver presença, o Arduino aciona o relé, ligando a luz por um tempo determinado.


int pirPin = 2;
int relePin = 8;
int tempoLuz = 10000; // 10 segundos

void setup() {
  pinMode(pirPin, INPUT);
  pinMode(relePin, OUTPUT);
  digitalWrite(relePin, LOW);
}

void loop() {
  if (digitalRead(pirPin) == HIGH) {
    digitalWrite(relePin, HIGH);
    delay(tempoLuz);
    digitalWrite(relePin, LOW);
  }
}

2. Monitoramento de Temperatura e Umidade com Alerta por SMS

Componentes:
- Arduino Uno ou Nano
- Sensor DHT22 ou DHT11
- Módulo GSM SIM800L
- Fonte 5V externa
Lógica: mede temperatura e umidade a cada X minutos. Se valores passarem de um limite, envia SMS com o alerta.

#include <DHT.h>
#include <SoftwareSerial.h>

#define DHTPIN 2
#define DHTTYPE DHT22 // Troque para DHT11 se utilizar esse modelo
DHT dht(DHTPIN, DHTTYPE);

#define LIMITE_TEMP 30.0

// Configura SoftwareSerial: RX = pino 7, TX = pino 8
SoftwareSerial sim800(7, 8);

void setup() {
  Serial.begin(9600);     // Monitor serial para debug
  sim800.begin(9600);     // Comunicacao com SIM800L
  dht.begin();

  Serial.println("Sistema iniciado. Monitorando temperatura...");
}

void loop() {
  float temp = dht.readTemperature();

  if (isnan(temp)) {
    Serial.println("Falha ao ler temperatura do sensor!");
    delay(2000);
    return;
  }

  Serial.print("Temperatura atual: ");
  Serial.println(temp);

  if (temp > LIMITE_TEMP) {
    sim800.println("AT+CMGF=1");
    delay(1000);
    sim800.println("AT+CMGS="+55XXXXXXXXXXX""); // Substitua pelo número real
    delay(1000);
    sim800.print("Alerta! Temperatura acima do limite: ");
    sim800.print(temp);
    sim800.write(26); // Envia Ctrl+Z para finalizar o SMS

    Serial.println("SMS de alerta enviado!");
    delay(60000); // Aguarda 1 minuto antes de nova verificação/alerta
  } else {
    delay(60000); // Aguarda 1 minuto em temperatura normal
  }
}

3. Controle de Acesso com Cartão RFID (RC522)

Componentes:
- Arduino Uno ou Mega
- Módulo RFID RC522
- Fechadura Eletromagnética
- LED vermelho e verde com resistência 220R cada
- EEPROM (opcional, para armazenar usuários)
Lógica: identifica o cartão pelo número UID. Se for um cartão autorizado, aciona o servo motor para liberar acesso.

#include <SPI.h>           // Biblioteca para comunicação SPI (usada pelo RC522)
#include <MFRC522.h>           // Biblioteca para operar o módulo RFID RC522
#include <EEPROM.h>            // Biblioteca para utilizar a memória EEPROM do Arduino

#define SS_PIN 10              // Pino SDA (SS) do RC522 conectado ao pino digital 10
#define RST_PIN 9              // Pino RST do RC522 conectado ao pino digital 9
#define LED_VERDE 5            // Pino do LED verde indica acesso liberado
#define LED_VERMELHO 4         // Pino do LED vermelho indica acesso negado
#define RELE_PIN 7             // Pino digital onde o relé está conectado para controlar o eletroímã

MFRC522 rfid(SS_PIN, RST_PIN); // Cria o objeto para o leitor RFID

const int UID_LENGTH = 4;      // Quantidade de bytes do UID (normalmente 4 em cartões comuns)
const int EEPROM_ADDR = 0;     // Endereço inicial para armazenamento do UID na EEPROM

void setup() {
  Serial.begin(9600);          // Inicia comunicação serial para depuração
  SPI.begin();                 // Inicia a comunicação SPI
  rfid.PCD_Init();             // Inicializa o RC522

  pinMode(LED_VERDE, OUTPUT);      // Define LED verde como saída
  pinMode(LED_VERMELHO, OUTPUT);   // Define LED vermelho como saída
  pinMode(RELE_PIN, OUTPUT);       // Define pino do relé como saída
  digitalWrite(LED_VERDE, LOW);    // Garante LED verde desligado no início
  digitalWrite(LED_VERMELHO, LOW); // Garante LED vermelho desligado no início
  digitalWrite(RELE_PIN, HIGH);    // Relé desligado (eletroímã/travado, dependendo do módulo)

  // Verifica se o UID já está armazenado na EEPROM. Caso não, cadastra o primeiro cartão apresentado.
  if (!eepromTemUID()) {
    Serial.println("Aproxime o cartão para cadastrá-lo (modo mestre)");
    while (true) {
      // Aguarda até um cartão válido ser lido para cadastramento
      if (rfid.PICC_IsNewCardPresent() && rfid.PICC_ReadCardSerial()) {
        cadastrarCartaoNaEEPROM(); // Salva o UID na EEPROM
        break;
      }
    }
  }
  Serial.println("Sistema pronto para leitura");
}

void loop() {
  // Se não há novo cartão apresentado, encerra retorno ao início do loop
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;

  // Lê e armazena o UID do cartão apresentado
  byte uidLido[UID_LENGTH];
  for (byte i = 0; i < UID_LENGTH; i++) {
    uidLido[i] = rfid.uid.uidByte[i];
  }

  // Compara se UID apresentado é autorizado (igual ao salvo na EEPROM)
  if (autorizado(uidLido)) {
    Serial.println("Acesso liberado!");
    digitalWrite(LED_VERDE, HIGH);   // Acende LED verde
    digitalWrite(RELE_PIN, LOW);     // Aciona relé (linha de controle do eletroímã)
    delay(2000);                     // Mantém por 2 segundos
    digitalWrite(RELE_PIN, HIGH);    // Desaciona relé (volta energia ao eletroímã)
    digitalWrite(LED_VERDE, LOW);    // Apaga LED verde
  } else {
    Serial.println("Acesso negado.");
    digitalWrite(LED_VERMELHO, HIGH); // Acende LED vermelho
    digitalWrite(RELE_PIN, HIGH);     // Garante que o relé está desligado (portão fechado)
    delay(2000);                      // Mantém LED vermelho por 2 segundos
    digitalWrite(LED_VERMELHO, LOW);  // Apaga LED vermelho
  }

  rfid.PICC_HaltA(); // Finaliza comunicação com o cartão, pronto para próxima leitura
}

// Função para cadastrar o UID lido na EEPROM (cartão mestre)
void cadastrarCartaoNaEEPROM() {
  Serial.print("Cartão cadastrado com UID: ");
  for (byte i = 0; i < UID_LENGTH; i++) {
    EEPROM.write(EEPROM_ADDR + i, rfid.uid.uidByte[i]); // Armazena cada byte do UID na EEPROM
    Serial.print(rfid.uid.uidByte[i], HEX);             // Mostra UID cadastrado no Serial Monitor
    Serial.print(" ");
  }
  Serial.println();
}

// Função que compara UID lido com o UID armazenado na EEPROM
bool autorizado(byte uidLido[]) {
  for (byte i = 0; i < UID_LENGTH; i++) {
    if (EEPROM.read(EEPROM_ADDR + i) != uidLido[i]) {
      return false;                        // Se algum byte está diferente, não é autorizado
    }
  }
  return true;                             // Todos os bytes conferem? Cartão autorizado!
}

// Função que verifica se existe algum cartão já cadastrado na EEPROM
bool eepromTemUID() {
  for (byte i = 0; i < UID_LENGTH; i++) {
    if (EEPROM.read(EEPROM_ADDR + i) != 0xFF && EEPROM.read(EEPROM_ADDR + i) != 0x00) {
      return true;                         // Se existe pelo menos um byte diferente de 0x00/0xFF, já há cartão na EEPROM
    }
  }
  return false;                            // Caso contrário, EEPROM está "zerada"
}

Para saber mais sobre Arduino Mega Wifi, confira esse post do nosso blog:

Primeiros passos com o Arduino Mega WiFi

4. Irrigação Automática com Sensor de Umidade do Solo

Componentes:
Lógica: quando o nível de umidade cair abaixo de um valor definido, o Arduino ativa a bomba para irrigação.

int sensorPin = A0;     // Pino do sensor de umidade
int relePin = 7;        // Pino do relé
int limiar = 500;       // Ajuste conforme necessário

void setup() {
  pinMode(relePin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int umidade = analogRead(sensorPin);  // Lê o sensor
  Serial.println(umidade);              // Mostra no Serial

  if (umidade < limiar) {                // Se está abaixo do limite
    digitalWrite(relePin, HIGH);         // Liga a bomba
    delay(10000);                        // Por 10 segundos
    digitalWrite(relePin, LOW);          // Desliga a bomba
  }
  delay(300000);                         // Espera 5 minutos
}

Escalabilidade e Integrações

Integração com IoT: use placas como o ESP8266 ou ESP32 para conectar seus sensores à internet e monitorar dados remotamente via Blynk, MQTT ou HTTP.
Banco de dados: pode enviar dados para uma planilha Google, Firebase ou banco MySQL via API.
Dashboard Web: com ESP32, é possível hospedar uma interface web simples para visualizar leituras em tempo real.

Com Arduino, automatizar processos é mais fácil e acessível do que parece. Seja para economizar tempo, reduzir custos ou inovar no seu dia a dia, um pequeno projeto pode fazer uma grande diferença.

Na Smart Kits, você encontra tudo o que precisa para começar: kits completos, componentes de qualidade e suporte para tirar suas ideias do papel.

Códigos revisados por Emanuel Sousa – Graduando em Engenharia Mecatrônica