Documentação CLP HR2 8I4O

Documentação técnica oficial do CLP HR2 8I4O, o CLP compatível com Arduino Uno fabricado no Brasil pela HR2 Tecnologia: 8 entradas optoacopladas (NPN ou PNP), 4 relés Finder 10 A, alimentação de 9 a 24 Vcc, USB e I2C. Comprar o CLP HR2 8I4O na loja.

Índice

1. Visão geral e ficha técnica
2. Pinagem
3. Ligação elétrica
4. Programação – Arduino IDE e PlatformIO
5. Exemplos de código
6. Perguntas frequentes

Visão geral e ficha técnica

O CLP HR2 8I4O é um controlador lógico programável (CLP) compacto, projetado e fabricado no Brasil pela HR2 Tecnologia. Ele usa o microcontrolador ATmega328P a 16 MHz com bootloader do Arduino Uno: você programa em C/C++ na Arduino IDE ou no PlatformIO, sem software pago e sem licença, e liga direto sensores, botoeiras e cargas de painel.

É a ponte entre o Arduino e o painel elétrico: a mesma programação do Arduino, com entradas optoacopladas, relés Finder de 10 A, bornes de parafuso e alimentação de 9 a 24 Vcc. Disponível com entradas NPN ou PNP.

Principais características

• 8 entradas digitais optoacopladas (PC817): versão NPN (aciona com 0 V) ou PNP (aciona com +V)
• 4 saídas a relé Finder série 36.11, 1 contato reversível (NA + NF), 10 A / 250 Vca
• Alimentação de 9 a 24 Vcc na mesma placa; regulador chaveado interno gera os 5 V da lógica e dos relés
• LEDs indicadores em todas as entradas e saídas, alimentação e comunicação
• USB tipo B (conversor CH340G) para gravação e comunicação serial
• Barramento I2C com conector próprio para expansão (displays, sensores, expansores de I/O)
• Bornes de parafuso para toda a fiação
• Montagem em placa (95 × 70 mm) ou com suporte para trilho DIN 35 mm (105 × 87 mm)

Ficha técnica

Onde usar

• Automação de máquinas pequenas e retrofit de comandos a relé
• Controle de bombas, nível de caixa d'água, portões, iluminação e motores
• Painéis com botoeiras, fins de curso e sensores indutivos/fotoelétricos NPN ou PNP
• Ensino técnico e universitário de automação e microcontroladores: o aluno aprende Arduino e painel no mesmo equipamento
• Protótipos e produtos que precisam sair da protoboard para uma placa robusta, com bornes

Quando ele não é a escolha certa

• Projetos que exigem programação em Ladder / IEC 61131-3 nativa ou certificação de segurança (SIL): use um CLP convencional.
• Cargas acima de 10 A ou motores acima de 0,37 kW: acione por contator.

Versões

O programa é o mesmo nas duas versões: no microcontrolador, a entrada acionada é sempre lida como LOW.

↑ voltar ao índice

Pinagem

O mapa de pinos é igual nas versões NPN e PNP. Use estes números no pinMode(), digitalRead() e digitalWrite() da Arduino IDE.

Entradas e saídas

Na serigrafia da placa as entradas aparecem como IN1 a IN8 (borne X4) e os relés como RL1 a RL4 (Q1 = RL1 … Q4 = RL4).

Outros sinais

Lógica dos sinais

Entradas

pinMode(2, INPUT_PULLUP);      // I1
if (digitalRead(2) == LOW) {   // I1 acionada (NPN ou PNP)
  // ...
}

• Entrada acionada → digitalRead() retorna LOW.
• Entrada livre → digitalRead() retorna HIGH.
• Vale para as duas versões: o optoacoplador faz a inversão.
• Não há debounce em hardware: para botões, faça debounce por software (veja os exemplos).

Saídas

pinMode(A0, OUTPUT);
digitalWrite(A0, HIGH);  // liga o relé Q1
digitalWrite(A0, LOW);   // desliga o relé Q1

• Saída em HIGH → relé energizado (contato NA fecha, NF abre).
• As saídas não têm vínculo de hardware com as entradas: toda a lógica é definida no seu programa.

Constantes prontas para copiar

// CLP HR2 8I4O – mapa de pinos
const uint8_t I1 = 2, I2 = 3, I3 = 4, I4 = 5, I5 = 6, I6 = 7, I7 = 8, I8 = 9;
const uint8_t Q1 = A0, Q2 = A1, Q3 = A2, Q4 = A3;

const uint8_t ENTRADAS[8] = {I1, I2, I3, I4, I5, I6, I7, I8};
const uint8_t SAIDAS[4]   = {Q1, Q2, Q3, Q4};

↑ voltar ao índice

Ligação elétrica

Alimentação

O borne X4 (parte de cima da placa) tem 10 posições: VCC, GND, IN1, IN2 … IN8.

• Fonte 9 a 24 Vcc estabilizada, ligada em VCC (+) e GND (0 V) do X4, respeitando a polaridade.
• 12 V e 24 V são os valores mais comuns em painel; a mesma placa aceita os dois.
• Dimensione a fonte para o CLP mais os sensores alimentados por ela.
• Separe fisicamente os cabos de sinal (entradas) dos cabos de potência (saídas e cargas).

Entradas – versão NPN

Na versão NPN a entrada é acionada quando recebe 0 V (GND).

Sensor indutivo / fotoelétrico NPN de 3 fios (cores padrão IEC 60947-5-2):

Botoeira, fim de curso ou contato seco: ligue o contato entre a entrada (IN1 … IN8) e o GND.

Entradas – versão PNP

Na versão PNP a entrada é acionada quando recebe +V (9 a 24 V).

Sensor indutivo / fotoelétrico PNP de 3 fios:

Botoeira, fim de curso ou contato seco: ligue o contato entre o VCC e a entrada (IN1 … IN8).

Saídas a relé

Cada saída (Q1 … Q4) é um relé Finder 36.11 (RL1 … RL4 na placa) com um contato reversível, em um borne de 3 posições logo abaixo do relé. A ordem dos contatos está desenhada na serigrafia, embaixo de cada borne:

Os contatos são livres de potencial: você pode chavear 127/220 Vca ou tensão contínua, independentemente da alimentação do CLP.

Limites (Finder série 36): NA 10 A / 250 Vca (carga resistiva); NF 5 A; 10 A em 28 Vcc; motor monofásico 230 Vca até 0,37 kW no contato NA.

Cargas indutivas

Motores, solenoides, válvulas e bobinas de contator geram picos de tensão ao desligar. Use sempre supressor junto à carga:

• Carga CC: diodo em antiparalelo com a bobina (ex.: 1N4007), catodo no +.
• Carga CA: varistor (MOV) ou circuito RC (snubber) adequado à tensão da rede.

Cargas maiores que o relé

Para correntes acima de 10 A, motores acima de 0,37 kW ou cargas trifásicas, use um contator: o relé do CLP aciona a bobina do contator, e o contator chaveia a carga.

Boas práticas

• Não deixe entradas usadas soltas: um fio aberto vira antena e gera acionamentos falsos.
• Use cabo blindado em sensores com cabo longo, aterrando a malha de um lado só.
• Em aplicações críticas, ative o watchdog do ATmega328P no firmware (veja os exemplos).

↑ voltar ao índice

Programação – Arduino IDE e PlatformIO

O CLP HR2 8I4O vem com o bootloader do Arduino Uno (Optiboot). Para o computador ele é um Arduino Uno: você grava pela USB, sem programador externo.

Arduino IDE

1. Instale a Arduino IDE (gratuita).
2. Conecte o CLP ao computador com cabo USB tipo B (o mesmo de impressora).
3. Se a porta não aparecer, instale o driver do conversor CH340 (veja abaixo).
4. Selecione a placa: Ferramentas → Placa → Arduino AVR Boards → Arduino Uno.
5. Selecione a porta: Ferramentas → Porta → COMx (Windows) ou /dev/ttyUSB0 (Linux).
6. Abra um dos exemplos e clique em Carregar (seta →).

PlatformIO (VS Code)

Crie um projeto com a placa Arduino Uno ou use este platformio.ini:

[env:clp_hr2_8i4o]
platform = atmelavr
board = uno
framework = arduino
monitor_speed = 9600

Grave com PlatformIO: Upload (seta na barra inferior) e abra o monitor serial com PlatformIO: Serial Monitor.

Driver CH340

O conversor USB-serial da placa é o CH340G.

• Windows 10/11: normalmente instala sozinho pelo Windows Update. Se a porta não aparecer no Gerenciador de Dispositivos, instale o driver do fabricante (WCH).
• Linux: já vem no kernel (ch341). Adicione seu usuário ao grupo dialout.
• macOS: versões recentes já têm o driver; em versões antigas, instale o driver da WCH.

Bibliotecas

Por ser compatível com o Arduino Uno, o CLP aceita as bibliotecas usuais da plataforma AVR:

• Wire – I2C (displays LCD/OLED, RTC, sensores, expansores de I/O como PCF8574/MCP23017)
• Bounce2 – debounce de botões
• avr/wdt.h – watchdog
• Bibliotecas Modbus RTU via serial

Solução de problemas

↑ voltar ao índice

Exemplos de código

Todos os exemplos foram compilados para Arduino Uno e funcionam nas versões NPN e PNP (entrada acionada = LOW). Copie o código para a Arduino IDE, selecione a placa Arduino Uno e carregue.

Cada entrada liga um relé

I1 → Q1, I2 → Q2, I3 → Q3, I4 → Q4. Bom para testar a ligação da placa.

// CLP HR2 8I4O - Exemplo 01: cada entrada liga um relé
// I1 -> Q1, I2 -> Q2, I3 -> Q3, I4 -> Q4
// Funciona nas versões NPN e PNP (entrada acionada = LOW).
// Placa na IDE: Arduino Uno.  https://docs.hr2.com.br

const uint8_t ENTRADAS[4] = {2, 3, 4, 5};      // I1..I4
const uint8_t SAIDAS[4]   = {A0, A1, A2, A3};  // Q1..Q4

void setup() {
  for (uint8_t i = 0; i < 4; i++) {
    pinMode(ENTRADAS[i], INPUT_PULLUP);
    pinMode(SAIDAS[i], OUTPUT);
    digitalWrite(SAIDAS[i], LOW);  // relés desligados na partida
  }
}

void loop() {
  for (uint8_t i = 0; i < 4; i++) {
    bool acionada = (digitalRead(ENTRADAS[i]) == LOW);
    digitalWrite(SAIDAS[i], acionada ? HIGH : LOW);
  }
}

Partida de motor com selo

Comando clássico de painel: botão LIGA (NA), botão DESLIGA (NF) e relé térmico (NF). O relé Q1 aciona a bobina do contator, não o motor direto. Os contatos NF garantem falha segura: se um fio romper, o motor para.

// CLP HR2 8I4O - Exemplo 02: partida direta de motor com selo
// I1 = botão LIGA (contato NA)
// I2 = botão DESLIGA (contato NF  -> parado = entrada acionada)
// I3 = relé térmico / falha (contato NF -> normal = entrada acionada)
// Q1 = bobina do contator do motor
// Q2 = lâmpada de falha
// Entrada acionada = LOW (NPN e PNP).  https://docs.hr2.com.br

const uint8_t BT_LIGA = 2, BT_DESLIGA = 3, TERMICO = 4;  // I1, I2, I3
const uint8_t CONTATOR = A0, LAMP_FALHA = A1;            // Q1, Q2

bool motorLigado = false;

bool acionada(uint8_t pino) { return digitalRead(pino) == LOW; }

void setup() {
  pinMode(BT_LIGA, INPUT_PULLUP);
  pinMode(BT_DESLIGA, INPUT_PULLUP);
  pinMode(TERMICO, INPUT_PULLUP);
  pinMode(CONTATOR, OUTPUT);
  pinMode(LAMP_FALHA, OUTPUT);
}

void loop() {
  // Contatos NF: se o fio romper, a entrada fica livre e o motor para (falha segura).
  bool desligaOk = acionada(BT_DESLIGA);  // NF fechado = não pressionado
  bool termicoOk = acionada(TERMICO);     // NF fechado = sem falha

  if (!desligaOk || !termicoOk) {
    motorLigado = false;                  // desligar tem prioridade
  } else if (acionada(BT_LIGA)) {
    motorLigado = true;                   // selo: fica ligado após soltar o botão
  }

  digitalWrite(CONTATOR, motorLigado ? HIGH : LOW);
  digitalWrite(LAMP_FALHA, termicoOk ? LOW : HIGH);
}

Temporizador

Retardo na ligação (TON) e pulso de tempo fixo (minuteria), usando millis(): o CLP continua lendo as outras entradas enquanto conta o tempo.

// CLP HR2 8I4O - Exemplo 03: temporizador (TON e pulso)
// I1 = sensor; Q1 liga se I1 ficar acionada por 3 s seguidos (retardo na ligação - TON)
// I2 = botão; Q2 liga por 10 s a cada toque (pulso / minuteria)
// Sem delay(): o CLP continua lendo as outras entradas.  https://docs.hr2.com.br

const uint8_t SENSOR = 2, BOTAO = 3;  // I1, I2
const uint8_t Q1 = A0, Q2 = A1;

const unsigned long RETARDO_MS = 3000;
const unsigned long PULSO_MS   = 10000;

unsigned long inicioSensor = 0;
bool sensorAnterior = false;
unsigned long inicioPulso = 0;
bool pulsoAtivo = false;

void setup() {
  pinMode(SENSOR, INPUT_PULLUP);
  pinMode(BOTAO, INPUT_PULLUP);
  pinMode(Q1, OUTPUT);
  pinMode(Q2, OUTPUT);
}

void loop() {
  unsigned long agora = millis();

  // TON: retardo na ligação
  bool sensor = (digitalRead(SENSOR) == LOW);
  if (sensor && !sensorAnterior) inicioSensor = agora;
  sensorAnterior = sensor;
  digitalWrite(Q1, (sensor && agora - inicioSensor >= RETARDO_MS) ? HIGH : LOW);

  // Pulso: cada toque reinicia a contagem
  if (digitalRead(BOTAO) == LOW) {
    inicioPulso = agora;
    pulsoAtivo = true;
  }
  if (pulsoAtivo && agora - inicioPulso >= PULSO_MS) pulsoAtivo = false;
  digitalWrite(Q2, pulsoAtivo ? HIGH : LOW);
}

Debounce de botão

Liga/desliga com um único botão (toggle), com filtro de 30 ms por software.

// CLP HR2 8I4O - Exemplo 04: botão liga/desliga (toggle) com debounce
// Cada toque em I1 inverte o relé Q1. Debounce de 30 ms por software, sem bibliotecas.
// https://docs.hr2.com.br

const uint8_t BOTAO = 2;  // I1
const uint8_t RELE  = A0; // Q1
const unsigned long DEBOUNCE_MS = 30;

bool estavel = false;          // estado filtrado (true = acionado)
bool leituraAnterior = false;
unsigned long ultimaMudanca = 0;
bool saida = false;

void setup() {
  pinMode(BOTAO, INPUT_PULLUP);
  pinMode(RELE, OUTPUT);
}

void loop() {
  bool leitura = (digitalRead(BOTAO) == LOW);
  if (leitura != leituraAnterior) {
    ultimaMudanca = millis();
    leituraAnterior = leitura;
  }
  if (millis() - ultimaMudanca >= DEBOUNCE_MS && leitura != estavel) {
    estavel = leitura;
    if (estavel) saida = !saida;   // borda de subida: botão pressionado
  }
  digitalWrite(RELE, saida ? HIGH : LOW);
}

Nível de caixa d'água

Bomba controlada por duas boias (nível baixo liga, nível alto desliga) e proteção contra bomba seca.

// CLP HR2 8I4O - Exemplo 05: controle de nível de caixa d'água com 2 boias
// I1 = boia de nível BAIXO (acionada = água abaixo do nível baixo)
// I2 = boia de nível ALTO  (acionada = água chegou ao nível alto)
// I3 = boia de proteção do poço/cisterna (acionada = tem água para bombear)
// Q1 = contator da bomba;  Q2 = alarme (bomba sem água)
// Liga a bomba no nível baixo e desliga no alto (histerese).  https://docs.hr2.com.br

const uint8_t BOIA_BAIXA = 2, BOIA_ALTA = 3, BOIA_POCO = 4;  // I1, I2, I3
const uint8_t BOMBA = A0, ALARME = A1;                       // Q1, Q2

bool bombaLigada = false;

bool acionada(uint8_t pino) { return digitalRead(pino) == LOW; }

void setup() {
  pinMode(BOIA_BAIXA, INPUT_PULLUP);
  pinMode(BOIA_ALTA, INPUT_PULLUP);
  pinMode(BOIA_POCO, INPUT_PULLUP);
  pinMode(BOMBA, OUTPUT);
  pinMode(ALARME, OUTPUT);
}

void loop() {
  bool temAguaNoPoco = acionada(BOIA_POCO);

  if (acionada(BOIA_ALTA) || !temAguaNoPoco) bombaLigada = false;
  else if (acionada(BOIA_BAIXA))             bombaLigada = true;

  digitalWrite(BOMBA, bombaLigada ? HIGH : LOW);
  digitalWrite(ALARME, temAguaNoPoco ? LOW : HIGH);
  delay(50);
}

Watchdog

Reinicia o CLP automaticamente se o programa travar e envia o estado de entradas e saídas pela USB (abra o Monitor Serial em 9600 bps).

// CLP HR2 8I4O - Exemplo 06: watchdog e monitor serial
// O watchdog reinicia o CLP se o programa travar por mais de 2 s.
// A cada 1 s envia o estado das entradas e saídas pela USB (9600 bps).
// https://docs.hr2.com.br

#include <avr/wdt.h>

const uint8_t ENTRADAS[8] = {2, 3, 4, 5, 6, 7, 8, 9};  // I1..I8
const uint8_t SAIDAS[4]   = {A0, A1, A2, A3};          // Q1..Q4

unsigned long ultimoEnvio = 0;

void setup() {
  wdt_disable();
  for (uint8_t i = 0; i < 8; i++) pinMode(ENTRADAS[i], INPUT_PULLUP);
  for (uint8_t i = 0; i < 4; i++) pinMode(SAIDAS[i], OUTPUT);
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(9600);
  Serial.println(F("CLP HR2 8I4O - watchdog ativo"));
  wdt_enable(WDTO_2S);
}

void loop() {
  wdt_reset();  // "alimenta" o watchdog a cada volta do loop

  // Lógica da aplicação: I1..I4 -> Q1..Q4
  for (uint8_t i = 0; i < 4; i++)
    digitalWrite(SAIDAS[i], digitalRead(ENTRADAS[i]) == LOW ? HIGH : LOW);

  if (millis() - ultimoEnvio >= 1000) {
    ultimoEnvio = millis();
    Serial.print(F("Entradas I1-I8: "));
    for (uint8_t i = 0; i < 8; i++) Serial.print(digitalRead(ENTRADAS[i]) == LOW ? '1' : '0');
    Serial.print(F("  Saidas Q1-Q4: "));
    for (uint8_t i = 0; i < 4; i++) Serial.print(digitalRead(SAIDAS[i]) ? '1' : '0');
    Serial.println();
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));  // LED D13 pisca: CLP rodando
  }
}

↑ voltar ao índice

Perguntas frequentes

Qual a diferença entre NPN e PNP?

É o tipo de sensor que você vai ligar. Na versão NPN a entrada aciona quando o sensor ou botão a liga ao 0 V (GND); na PNP, quando recebe +V (de 9 a 24 V). Sensores indutivos e fotoelétricos indicam o tipo na etiqueta. O programa é o mesmo nas duas versões.

Funciona em 12 V e em 24 V?

Sim. A mesma placa aceita de 9 a 24 Vcc, incluindo 12 V e 24 V. O regulador interno gera 5 V para o microcontrolador e para os relés.

Preciso de algum software pago?

Não. A programação é feita na Arduino IDE ou no PlatformIO, ambos gratuitos. Selecione a placa Arduino Uno.

O computador não reconhece a porta USB. O que fazer?

Instale o driver do conversor USB-serial CH340 e selecione a porta COM correspondente. Teste também outro cabo USB: alguns cabos só carregam e não transmitem dados. Veja Programação.

Quanto o relé aguenta?

Os relés Finder 36.11 suportam 10 A em 250 Vca (contato NA, carga resistiva), 5 A no contato NF e 10 A em 28 Vcc. Para motores e cargas maiores, use um contator.

Posso usar bibliotecas do Arduino?

Sim. Por ser compatível com o Arduino Uno, aceita as bibliotecas usuais (Bounce2, Wire/I2C, displays, Modbus RTU via serial etc.).

Dá para expandir as entradas e saídas?

Sim, pelo conector I2C (SDA = A4, SCL = A5), com expansores de I/O (PCF8574, MCP23017), displays e sensores I2C.

Dá para programar em Ladder?

Não nativamente. O CLP HR2 8I4O é programado em C/C++ (linguagem do Arduino). Se o projeto exige Ladder/IEC 61131-3 ou certificação de segurança, use um CLP convencional.

Qual a diferença entre as duas versões de montagem?

O circuito é o mesmo. A versão com suporte vem em base para trilho DIN 35 mm (105 × 87 mm), pronta para painel. A versão sem suporte (95 × 70 mm) é para fixação por parafusos ou gabinete próprio.

Ele substitui um Arduino Uno com shield de relés?

Sim, com vantagens para uso em painel: entradas optoacopladas para 9 a 24 V (sem divisor de tensão), relés de 10 A de marca, alimentação direta da fonte do painel, bornes de parafuso e montagem em trilho DIN.

Onde comprar?

Na loja oficial da HR2: www.hr2.net.br/produtos/clp-arduino.

Tem nota fiscal e suporte técnico?

Sim. O CLP é fabricado pela HR2 Tecnologia, com nota fiscal e suporte técnico direto com quem projetou a placa: [email protected] ou WhatsApp (11) 98968-5235.

↑ voltar ao índice

Dúvidas técnicas: [email protected] · WhatsApp (11) 98968-5235. Suporte direto com a equipe que projetou a placa.