terça-feira, 11 de maio de 2021

EX40 - Como Ligar e desligar um motor com Arduino e CADe_SIMU 4.

Neste artigo, usaremos esse recurso como exemplo para dar partida e parar um motor trifásico com dois botões de pressão e leitura do relé térmico. O CADe_SIMU não realiza uma simulação do Arduino. Ele simula contatores, botões, motores e outros componentes disponíveis. O programa Arduino deve ser carregado na placa física e incluir uma biblioteca, que permite a comunicação com o CADe_SIMU. Antes de instalá-la, precisamos adicionar outra biblioteca que ela utiliza. 
No IDE, acesse o Gerenciador de Bibliotecas, procure por < TimerOne >e instale-a. O programa deve ser carregado nesse Arduino e, graças a "biblioteca < #include < PC_SIMU.h > ", pode interagir com CADe_SIMUe os demais componentes simulados. A biblioteca PC_SIMU, pode ser baixada no link: PC_SIMU.h . Após o download, você pode instalar o arquivo ZIP diretamente pelo menu Programas – Incluir Biblioteca ou descompactá-lo e copiar manualmente a pasta com as demais bibliotecas.
O programa Arduino deve ser carregado na placa física e incluir uma biblioteca acima, que permite a comunicação com o CADe_SIMU. Após copiar o exemplo para a IDE, compilamos o código e o carregamos na placa. Chegamos à etapa final. Depois de salvar o programa no Arduino, abra o CADe_SIMU e adicione um componente Arduino UNO na barra de ferramentas de Entrada/Saída. Clique duas vezes nele para abrir sua configuração.
Depois de salvar o programa no Arduino, abra o CADe_SIMU e adicione um componente Arduino UNO na barra de ferramentas de Entrada/Saída . Clique duas vezes nele para abrir sua configuração.
Podemos adicionar um Arduino UNO aos nossos circuitos no CADe_SIMU, que na realidade o Arduino não é simulado, mas que precisamos ter um Arduino real , com o programa que queremos incluir na simulação já carregado e conectado através de uma porta USB.
Neste exemplo vou mostrar um exemplo, aplicado à partida de um motor trifásico.
  • O circuito consiste em um circuito básico de partida e parada para um motor trifásico, cujo esquema pode ser visto na imagem ao lado.
Como você pode ver, o circuito possui um contator K1 que atua no motor trifásico. A bobina deste contator é conectada à saída 2 do Arduino. Dois botões de controle do motor também são conectados ao Arduino: S2 ( entrada 9 ) para ligá-lo e S1 ( entrada 8 ) para pará-lo. 
Como medida de proteção, o motor possui um relé térmico que fecha o contato F ( entrada 10 ) caso ocorra uma sobrecarga , neste caso abriremos o contator e acenderemos a luz de alarme H ( saída 3 ). A condição de alarme permanecerá mesmo que a entrada do relé térmico (entrada 10) seja desativada e só conseguiremos ligar o motor novamente se atuarmos no botão CLEAR ( entrada 11 ).
Lembre-se que os circuitos elétricos do Arduino devem estar sempre fechados pelo GND e 5V do mesmo Arduino no CADe_SIMU.
A configuração do Arduino é mostrada na figura ao lado.
No Arduino, não precisamos construir nenhum circuito. Não precisamos conectar nada às entradas ou saídas; o CADe_SIMU cuidará de todo o controle.
  • Configuração de Entrada/Saída : Nesta seção, devemos informar ao CADe_SIMU como configuramos os pinos do Arduino. 
  • Comunicação: Aqui precisamos informar ao CADe_SIMU qual porta de comunicação (COM) usar para encontrar o Arduino. Geralmente o Arduino aparece entre as portas COM1 e COM4, além disso, verifique a opção "Conectar durante a simulação".
Isso conclui a configuração (pelo menos a mínima), então você pode pressionar o botão OK. Agora, tudo o que resta é adicionar alguns circuitos adicionais para testar a simulação.

O programa
O programa gravado no Arduino que faz esse circuito funcionar é o seguinte:

//Ejemplo Arranque y parada

define MOTOR 2
define PILOTO 3
define STOP 8
define START 9
define TERMICO 10
define CLEAR 11

#include  <PC_SIMU.h>
PC_SIMU Arduino;

boolean AlarmaTermico;

void setup() {

    pinMode(MOTOR, OUTPUT);   //Salida Motor
    pinMode(PILOTO, OUTPUT);  //Indicador Error

    digitalWrite(MOTOR, 0);   //Arranca motor parado
    digitalWrite(PILOTO, 0);  //Arranca lampara apagada

    pinMode (STOP, INPUT);    //Entrada pulsador STOP
    pinMode (START, INPUT);   //Entrada pulsador START
    pinMode (TERMICO, INPUT); //Entrada contacto aux relé térmico
    pinMode (CLEAR, INPUT);   //Entrada CLEAR de alarma

    AlarmaTermico = false;

    Arduino.INI(); 

}

void loop() {

    //Ver pulsador START
    if (digitalRead (START) && (AlarmaTermico==false)) {
        digitalWrite(MOTOR, 1);
    }  

    //Ver pulsador STOP
    if (digitalRead (STOP)) {
        digitalWrite(MOTOR, 0);
    }     

    //Ver contacto del térmico
    if (digitalRead (TERMICO)) {
        digitalWrite (MOTOR,0);
        digitalWrite (PILOTO,1);
        AlarmaTermico = true;
    }
    
    //Ver pulsador de CLEAR
    if (digitalRead (CLEAR)) {
        digitalWrite (PILOTO,0);
        AlarmaTermico = false;
    }
}
Vamos analisar como esse código funciona:
  1. No início temos algumas definições ( define ) de entradas e saídas, que podemos alterar se modificarmos o circuito.
  2. Então, nas linhas 10 e 11 incluímos a biblioteca PC_SIMU , essencial para comunicar com o CADe_SIMU e então criamos o objeto Arduino.
  3. Na linha 13 definimos a variável AlarmaTermico , do tipo booleana, que indicará se o relé térmico foi acionado devido a uma sobrecarga no motor.
  4. Na função de configuração , as entradas e saídas são definidas com pinMode , e as saídas são inicializadas com zero . Também inicializamos a variável ThermalAlarm como false e chamamos o método INI do objeto Arduino para inicializar a comunicação.
  5. Na função de loop , o status das entradas é verificado e as ações são tomadas de acordo:
  6. Na linha 36, ​​se START for pressionado e não houver condição de sobrecarga , acionamos a saída do contator para dar partida no motor.
  7. Na linha 41, se STOP for pressionado , desativamos a saída do contator e paramos o motor.
  8. Na linha 46, se o contato auxiliar do relé térmico fechar porque houve sobrecarga, paramos o motor, acendemos a luz de alarme e colocamos a variável AlarmaTermico em true , indicando a falha.
  9. Por fim, na linha 53, se CLEAR for pressionado , "limpamos" a falha desligando a luz do alarme e configurando ThermalAlarm como false , para que o motor esteja pronto para ser ligado novamente.
Este é apenas um programa de teste, para mostrar as possibilidades de incluir um Arduino UNO em nossas simulações com CADe_SIMU.

Operação
Aqui você pode ver o circuito em operação:
Certamente alguns se perguntarão como pode funcionar um programa Arduino no qual tomamos decisões com base nos valores de entrada, se não há nada conectado a eles .
Neste caso, não é necessário conectar nada às entradas porque a biblioteca PC_SIMU pega a informação que o CADe_SIMU envia quando agimos em uma entrada no simulador e faz o Arduino acreditar que a entrada foi ativada no nível de hardware.
Você pode tentar ativar as entradas da placa, neste caso conectando um cabo, por exemplo, entre 5V e a entrada 9 (START). Você verá que no CADe_SIMU o motor dá partida, mas o botão START conectado a essa entrada não mostra atividade. Isso ocorre porque o fluxo de informações, neste caso, é unidirecional, e o CADe_SIMU está recebendo apenas informações sobre o que está acontecendo nas saídas do Arduino.
Espero que este exemplo tenha ajudado você a entender melhor como usar o Arduino no CADe_SIMU e a construir seus próprios circuitos. Se tiver alguma sugestão ou dúvida, fique à vontade para deixar nos comentários.

O diagrama elétrico está disponível em: 25_11_03_Triturador_Arduino_SRG (PDF).

O código fonte  está disponível em: 25_11_03_Código_Triturador_Arduino_SRG (PDF).

Referência: Ernesto Tolocka

© Direitos de autor. 2023: Gomes; Sinésio Raimundo. Última atualização: 20/11/2023

sexta-feira, 7 de maio de 2021

Aula 19 - Programação Arduino - Conectando o Arduino UNO com o CADe_SIMU 4


A versão 4 do CADe_SIMU nos permite incluir um Arduino no circuito para que ele possa interagir com os elementos simulados. O CADe_SIMU não realiza uma simulação do Arduino. O que o CADe_SIMU faz é...comunicar com um Arduino real que deve ser conectado ao PC onde o simulador está sendo executado, utilizando o cabo correspondente. O programa Arduino deve ser carregado na placa física e incluir uma biblioteca, que permite a comunicação com o CADe_SIMU. Antes de instalá-la, precisamos adicionar outra biblioteca que ela utiliza. 
No IDE, acesse o Gerenciador de Bibliotecas, procure por < TimerOne >e instale-a.
O programa deve ser carregado nesse Arduino e, graças a "biblioteca < #include < PC_SIMU.h > ", pode interagir com CADe_SIMUe os demais componentes simulados. A biblioteca PC_SIMU, pode ser baixada no link: PC_SIMU.h .
Após o download, você pode instalar o arquivo ZIP diretamente pelo menu Programas – Incluir Biblioteca ou descompactá-lo e copiar manualmente a pasta com as demais bibliotecas.
Como você pode ver, esta biblioteca faz referência ao programa PC_SIMU , o simulador que pode funcionar em conjunto com o CADe_SIMU. O PC_SIMU já interage com o Arduino e alguns PLCs há várias versões, uma funcionalidade que só recentemente foi transferida para o CADe_SIMU.
  • Se tudo funcionou corretamente, deveríamos conseguir ver ambas as bibliotecas já instaladas em Programa:  PC_SIMU e TimerOne, conforme figura ao lado.
O programa Arduino deve ser carregado na placa física e incluir uma biblioteca acima, que permite a comunicação com o CADe_SIMU.
Após copiar o exemplo para a IDE, compilamos o código e o carregamos na placa. Chegamos à etapa final. Depois de salvar o programa no Arduino, abra o CADe_SIMU e adicione um componente Arduino UNO na barra de ferramentas de Entrada/Saída. Clique duas vezes nele para abrir sua configuração.
Depois de salvar o programa no Arduino, abra o CADe_SIMU e adicione um componente Arduino UNO na barra de ferramentas de Entrada/Saída . Clique duas vezes nele para abrir sua configuração.
Podemos adicionar um Arduino UNO aos nossos circuitos no CADe_SIMU, que na realidade o Arduino não é simulado, mas que precisamos ter um Arduino real , com o programa que queremos incluir na simulação já carregado e conectado através de uma porta USB.
Agora vamos ver como usar essa biblioteca em nosso programa Arduino. Vamos escrever algo bem simples: a função típica "Piscar" que faz um LED piscar, só que desta vez vamos usá-la para acionar algo diferente no CADe_SIMU.

//Prueba Cade-SIMU y Arduino #define Salida 2 #include <PC_SIMU.h> PC_SIMU Arduino; void setup() { pinMode(Salida, OUTPUT); digitalWrite(Salida, 0); Arduino.INI(); } void loop() { digitalWrite(Salida, 1); delay(2000); digitalWrite(Salida, 0); delay(2000); }

Como você pode ver, o programa é muito simples. O pino 2 é definido como uma saída no arquivo de configuração e, em seguida, alternado a cada dois segundos em um loop . A linha 5 é importante , pois inclui a biblioteca PC_SIMU . A linha 7 cria um objeto Arduino da classe PC_SIMU e a linha 12 , dentro do arquivo de configuração , chama o método INI desse objeto para inicializá-lo e, assim, habilitar a comunicação entre o Arduino e o CADe_SIMU.
Após copiar o exemplo para a IDE, compilamos o código e o carregamos na placa .
Chegamos à etapa final. Depois de salvar o programa no Arduino, abra o CADe_SIMU e adicione um componente Arduino UNO na barra de ferramentas de Entrada/Saída . Clique duas vezes nele para abrir sua configuração.
Aqui estão alguns pontos que devemos revisar:
  • Configuração de Entrada/Saída : Nesta seção, devemos informar ao CADe_SIMU como configuramos os pinos do Arduino. Neste programa de exemplo, usamos apenas o pino 2 , configurado como saída,.
  • Comunicação: Aqui precisamos informar ao CADe_SIMU qual porta de comunicação (COM) usar para encontrar o Arduino. Geralmente entre as portas COM1 e COM4. Além disso, verifique a opção "Conectar durante a simulação".
Isso conclui a configuração  mínima, então você pode pressionar o botão OK. Agora, tudo o que resta é adicionar alguns circuitos adicionais ao pino 2 para testar a simulação.
Lembre-se de que a simulação no CADe_SIMU é realizada no nível lógico ; ou seja, os componentes podem ter um de dois valores discretos (ligado/desligado, ligado/desligado, etc.) e os valores de tensão ou corrente não são simulados. Portanto, podemos ativar a bobina de um contator diretamente com uma saída do Arduino, algo que não é possível na realidade.
Além disso, certifique-se de fechar o circuito elétrico dos pinos do Arduino ao pino GND da mesma placa .
Referência: Ernesto Tolocka

© Direitos de autor. 2023: Gomes; Sinésio Raimundo. Última atualização: 04/11/2025

terça-feira, 4 de maio de 2021

Aula 18 - Programação Arduino - Fluxograma

Um exemplo rápido de utilização do Arduino poderia ser a indicação de temperatura alta - LED Vermelho, ou baixa - LED Verde, de um sistema de refrigeração que ao detectar a temperatura, através de um sensor  - DHT - caso esteja maior que 32 graus, para isto, haverá um sensor de temperatura inserido em determinado ponto e este enviará dados, a cada 5 segundos, para o Arduino, que irá indicar esta duas condições. 
Dentro da programação desenvolvida podemos ler (receber) estes valores e, dependendo o valor lido, enviar um comando para que determinado componente externo seja ativado, neste caso o sistema de irrigação.
Para a estrutura deste tutorial será utilizado como exemplo o modelo padrão o Arduino Uno R3.
Assim que escrevemos um código, utilizando a linguagem C, na IDE do Arduino, e este é carregado para o Arduino, todo o processo escrito dentro do algoritmo é executado enquanto houver uma alimentação de energia. Os sensores, shields e demais componentes conectados a ele também são alimentados à partir da placa. Desse modo, o Arduino pode ficar, constantemente, lendo os valores recebidos por estes instrumentos e reagindo às ações de acordo com a programação e lógica que foi aplicado à ele com o algoritmo escrito e carregado em seu sistema.
Segue abaixo um exemplo de fluxograma e pseudocódigo para um programa possível em Arduino. 
Fluxograma de um programa para acender um LED em Arduino de acordo com a temperatura indicada por um sensor.
Neste modelo acima, após o início do Arduino, o processo que ficará em execução será o seguinte:
  • Leitura da temperatura que está na porta analógica A03 e armazenamento do valor lido na variável “Temp”
  • Verificação do valor armazenado em “Temp” se este é maior ou igual a 32.
  • Caso o valor lido seja maior ou igual a 32, será aceso o LED verde na porta digital 5 e apagado o LED vermelho na porta digital 4.
  • Caso o valor lido seja menor que 32, será aceso o LED vermelho na porta digital 4 e apagado o LED verde na porta digital 5.
  • Após esta etapa é requisitado uma pausa de 5 segundos e refeito todo o processo.

© Direitos de autor. 2021: Gomes; Sinésio Raimundo. Última atualização: 10/10/2025 

terça-feira, 27 de abril de 2021

Aula 17 - Programação Arduino com display LCD 16×02 com módulo I2C

Vamos utilizar o display LCD 16×2 com módulo I2C no Arduino.
O módulo I2C para display LCD 16×2 ou 20×4 tem como principal função simplificar as conexões e facilitar a utilização de displays LCD ao microcontrolador.
O módulo I2C deve ser acoplado ao display LCD por meio da conexão dos seus 16 pinos, conforme ilustra a figura 01.
No centro do módulo I2C, está o chip PCF8574, um expansor de 8 bits que converte os dados I2C de um microcontrolador nos dados paralelos exigidos pelo display LCD.
Na parte lateral, o módulo I2C conta com quatro pinos para conexão com o Arduino ou qualquer outro microcontrolador que suporte o protocolo de comunicação I2C. Estes quatro pinos são: GND, VCC, SDA e SCL. O pino SDA (do inglês, Serial Data) é o responsável pela transferência e recebimento de dados. Por sua vez, o pino SCL (do inglês, Serial Clock) é utilizado para temporização.
O módulo I2C conta também com dois pinos para controle da luz de fundo do visor do display, que se encontram conectados por um jumper, por padrão. Assim, a luz de fundo estará sempre ligada. Você pode remover este jumper para desligar a luz de fundo do display.
Além disto, a placa conta com um pequeno trimpot para fazer ajustes finos no contraste do display e um barramento para configuração do endereço I2C.
A figura 02 detalha as partes que compõem o módulo I2C para display LCD 16×2 ou 20×4.
O barramento de configuração do endereço possui três jumpers de solda (A0, A1 e A2) ou pads de solda, usados para codificar o endereço. Acima de cada pad há uma conexão de aterramento (GND). Para alterar o endereço, basta conectar qualquer pad ao pino GND localizado acima deles, soldando-os. 
A figura 3 mostra um modelo de como mudar endereço por meio de soldagem em um display e demonstra todas as conexões e endereços hexadecimais possíveis.

Ligação dos componentes
Inicialmente, certifique-se de que a sua placa Arduino esteja desligada. Em seguida monte o circuito da Figura 4 utilizando o Módulo I2C e os jumpers macho-fêmea.
Ao montar o circuito observe os seguintes pontos:
  • O GND do módulo I2C deve ser conectado ao pino GND do Arduino;
  • O módulo I2C opera com uma tensão de alimentação de 5V. Deste modo, conecte o VCC ao pino 5V do Arduino;
  • Nas placas Arduino UNO, os pinos associados ao I2C são A4 (SDA) e A5 (SCL).
Na utilização do código, utilizaremos o endereço I2c do nosso módulo. Como existem diferentes endereços é necessário conhecer qual o nosso está cadastrado, para isso basta fazer o upload do código abaixo na Arduino IDE.
#include <Wire.h>
void setup()
{
Wire.begin();
Serial.begin(9600);
while (!Serial);
Serial.println("\nI2C Scanner");
}
void loop()
{
byte error, address;
int nDevices;
nDevices = 0;
for(address = 1; address < 127; address++ )
{
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
Serial.print("Endereço I2C encontrado: 0x");
if (address<16)
Serial.print("0 ");
Serial.println(address,HEX);
nDevices++;
}
else if (error==4)
{
Serial.print("ERRO ");
if (address<16)
Serial.print("0");
Serial.println(address,HEX);
}
}
if (nDevices == 0)
Serial.println("Nenhum endereço i2C encontrado ");
else
Serial.println(" Feito !");
delay(5000);
}
Com o código compilado, poderemos ter acesso ao endereço I2C do módulo no monitor serial, no nosso caso foi encontrado o endereço 0x3F, mostrado na figura ao 05.
Após a montagem do circuito, vamos programação do Sketch no Arduino IDE. Nesse projeto, vamos utilizar o Display 16×02 com módulo I2C para exibir inicialmente as mensagens:

“Prof. Sinesio Gomes”
“ Projetos 2025 ”

Para fazer a comunicação do modulo I2C o Arduino, vamos utilizar a biblioteca Wire.h que já se encontra instalada com o Arduino IDE. Para incluí-la ao sketch acesse o seguinte caminho: Sketch>Incluir Biblioteca> Wire.
Vamos usar também a biblioteca LiquidCrystal_I2C.h que permite controlar displays I2C com funções exatamente semelhantes à biblioteca LiquidCrystal. Para instalá-la, abra o Gerenciador de Bibliotecas através do caminho: Ferramentas>Gerenciar Bibliotecas… ou por meio do atalho Ctrl+Shift+I. Em seguida, busque por LiquidCrystal I2C e clique em instalar, conforme a figura 05.

Vamos entender a lógica de programação desse projeto a partir dos seguintes passos:
1. Incluir as bibliotecas:
Foram incluídas as bibliotecas Wire.h para fazer a comunicação com o I2C e LiquidCrystal_I2C.h para controlar displays I2C.
2. Definir as constantes:
No código definiremos 3 constantes. A constante “col” que se refere ao número de colunas utilizadas no Display, a constante “lin” que se refere ao número de linhas utilizadas no display e a constante “ende” que se refere ao endereço o qual o display se encontra, no nosso caso encontramos 0x3F, se o seu for diferente, substitua pelo endereço encontrado.
3. Criar objeto do tipo LiquidCrystal_I2C
Em seguida, criaremos o objeto lcd, do tipo LiquidCrystal_I2C, e informamos o endereço, número de counas e linhas do display, no seguinte formato: LiquidCrystal lcd(<endereço>, <coluna>, <linha>);
4. Função setup();
No setup(), inicializaremos a exibição do display LCD usando a função init(). A função clear() será usada para limpar o buffer de exibição. A função backlight deve ser utilizada para ativar a luz de fundo do display.
Para iniciar a escrita no display LCD precisamos colocar o cursor na posição na coluna 0 e linha 0. Para isso, usaremos a função lcd.setCursor(0, 0);. A partir daí, escreveremos a primeira parte do texto, que será feita a partir da função lcd.print (“Prof. Sinesio Gomes”);
Para escrever a segunda linha do texto, posicionaremos o cursor para a posição linha 1 e coluna 0 com a função lcd.setCursor(0, 1);. Daí, escreveremos o texto com a função lcd.print(“ Projetos 2025 ”);
5. Função loop()
No loop, chamaremos a função que desliga o display lcd.noDisplay() e liga o display lcd.display();.
Desta forma, o Sketch do projeto ficará da seguinte maneira, para o display 20x4:

#include <Wire.h> // Biblioteca utilizada para fazer a comunicação com o I2C
#include <LiquidCrystal_I2C.h> // Biblioteca utilizada para fazer a comunicação com o display 20x4
#define col 20 // Serve para definir o numero de colunas do display utilizado
#define lin 4 // Serve para definir o numero de linhas do display utilizado
#define ende 0x3F // Serve para definir o endereço do display.
LiquidCrystal_I2C lcd(ende,col,lin); // Chamada da funcação LiquidCrystal para ser usada com o I2C
void setup() //Incia o display
{
lcd.init(); // Serve para iniciar a comunicação com o display já conectado
lcd.backlight(); // Serve para ligar a luz do display
lcd.clear(); // Serve para limpar a tela do display
}
void loop()
{
lcd.setCursor(1,0); // Coloca o cursor do display na coluna 1 e linha 1
lcd.print("SENAI Henrique Lupo"); // Comando de saída com a mensagem que deve aparecer na coluna 2 e linha 1.
lcd.setCursor(1, 1); //Coloca o cursor do display na coluna 1 e linha 2
lcd.print("2EL - SEDUC - EEBA"); // Comando de saida com a mensagem que deve aparecer na coluna 2 e linha 2
lcd.setCursor(1,2); //Coloca o cursor do display na coluna 1 e linha 1
lcd.print("Prof. Sinésio Gomes"); // Comando de saida com a mensagem que deve aparecer na coluna 2 e linha 3
lcd.setCursor(1 ,3); //Coloca o cursor do display na coluna 1 e linha 2
lcd.print(" Projetos 2025 "); // Comando de saida com a mensagem que deve aparecer na coluna 2 e linha 4
delay(3000); // delay de 5 segundos com todas as mensagens na tela
lcd.clear(); // Limpa o display até o loop ser reiniciado
}
Após a transferência do código, o display exibirá as mensagens:
"SENAI Henrique Lupo"
"2EL - SEDUC - EEBA"
“Prof. Sinesio Gomes”
“ Projetos 2025 ”
OBSERVAÇÃO: Caso seu display não exiba as mensagens após a transferência do código, ajuste o contraste do display.
O módulo I2C para display LCD 16×2 ou 20×4 possui um pequeno trimpot de ajuste do contraste do display, conforme Figura 8. Para aumentar o contraste do display basta girar o trimpot no sentido anti-horário. Por sua vez, para diminuir o contraste gire no sentido horário.

O manual com diagrama elétrico da placa do LCD I2C está disponìvel em: 25_0-10_10 LCD Display I2C .

© Direitos de autor. 2021: Gomes; Sinésio Raimundo. Última atualização: 10/10/2025