SEL-751A

SEL-751A
Relé de Proteção do Alimentador
O Relé de Proteção de Alimentadores SEL-751A é a solução certa para proteção de alimentadores industriais e de concessionárias de serviços públicos, com opções de E/S flexíveis, montagem fácil e configuração rápida.

O SEL-751A oferece proteção completa do alimentador com elementos de sobrecorrente, sobretensão, subcorrente e frequência. Atualize facilmente a proteção sem cortes ou perfurações de recortes existentes, com um fator de forma pequeno e vários adaptadores de montagem. Integre rapidamente a comunicações seriais ou em Ethernet com IEC 61850, comunicações Mirrored Bits e outros protocolos.

Aplicações
Proteção do alimentador –Proteja completamente a distribuição de circuitos radiais e em loop, incluindo sobrecorrente-tempo, sobrecorrente direcional, religação automática, sub/sobretensão, frequência e muito mais.

Atenuação do arco elétrico –Melhora a segurança pessoal com possibilidade de detecção de arco elétrico opcional. O SEL-751A oferece detecção de arco elétrico em sobrecorrente de alta e baixa velocidade. Essa combinação é a solução ideal para velocidade e segurança.

Automação e Controle –Use o SEL-751A em alimentadores e ofereça mais proteção, automação e controle, tudo em um único pacote. Equações de controle SELogic compatíveis com várias aplicações automatizadas sem a necessidade de controladores de automação adicionais. Os botões configuráveis do painel frontal podem substituir os controles de painéis convencionais e simplificar as aplicações e fiações em geral.

Análises de eventos –Realize análises pós-eventos de maneira mais eficaz com os registros detalhados de eventos disponíveis no SEL-751A. Combine informações oscilográficas e digitais para encontrar a causa raiz. Adicione uma fonte de tempo sincronizada por satélite, como os Relógios Sincronizados por Satélite SEL-2401 ou SEL-2407, para o alinhamento conveniente das informações de eventos fornecidas por vários dispositivos.

Consciência situacional –Aumente a consciência situacional e a utilização dos ativos com a medição dos sincrofasores IEEE C37.118. Combine as informações dos sincrofasores de todo o sistema para compreender as tendências do sistema, tomar decisões com base em medições de estado e não em estimativas, e para obter auxílio na análise de pós-eventos.

Confiável em ambientes adversos –Confie no SEL-751A para aplicações de proteção e controle, mesmo em ambientes adversos e perigosos. O SEL-751A foi projetado e testado para atender e superar os requisitos industriais e das concessionárias de serviços públicos. A faixa de temperatura de operação de -40 °C a +85 °C (-40 °F a +185 °F), bem como aprovação de Classe 1 e Zona 2 e o revestimento conformável opcional, significam que este relé proporciona vários anos de serviço confiável.

Personalize a operação dos botões e LEDs do painel frontal ou use a função de trip/religamento do disjuntor padrão.
Personalize as mensagens no visor LCD usando configurações de ponto de exibição orientada por evento.
Crie um sistema de controle integrado com uma variedade de opções de E/S e de comunicação.
Use os recursos programáveis de lógica de controle e integração com um link de comunicação para controle e proteção de subestações remotas.
Use relatórios abrangentes para compreender eventos, programar manutenção, detectar tendências indesejáveis, modificar cargas e atender aos requisitos de informação dos sistemas de supervisão.
Inclua entradas do resistor variável por temperatura (RTD) como parte da integração do sistema ou para proteção de polarização.
Corrija os perigos de arco elétrico com detecção de arco elétrico.
Analise o desempenho do sistema de proteção contra sobrecorrente usando o Gravador de Eventos Sequenciais (SER) integrado.
Use o software acSELerator QuickSet SEL-5030 ou o software Assistente de Relés SEL-5010 para gerenciar as configurações dos relés.
Instale proteção onde for necessário sem compartimentos ou sistemas de ventilação especiais. A certificação Classe 1, Divisão 2 permite o uso do SEL-751A em locais que podem ser adjacentes a gases, vapores ou líquidos perigosos.

https://docplayer.com.br/17498163-Memoria-de-calculo-para-os-ajustes-do-rele-de-protecao-de-alimentador-sel-751a.html

Google adquire a DORA, o aplicativo móvel RPA da Automation Anywhere e o novo laboratório de robótica da NVIDIA

DevOps Research and Assessment (DORA) foi adquirida pelo Google. A aquisição permitirá que a DORA crie melhores experiências de usuário no Google Cloud para desenvolvedores e operações por meio de insights orientados por dados.

“As melhores e mais inovadoras organizações desenvolvem e entregam seus softwares com mais rapidez, confiabilidade e segurança, e com maior qualidade, com alto desempenho em tecnologia”, disse a Dra. Nicole Forsgren, CEO e cientista chefe da DORA. “Estamos entusiasmados por nos unirmos a uma equipe comprometida com o fornecimento de práticas de DevOps apoiadas por pesquisas e esperamos continuar nosso trabalho para entender os principais recursos, medir resultados orientados a valor e otimizar processos para ajudar as equipes a entregar seus softwares à medida que avançam. nuvem.”

A Automation Anywhere lança um aplicativo móvel para a empresa RPA
Robotic Automation (RPA) A Automation Anywhere anunciou um aplicativo móvel para o gerenciamento seguro de bots RPA construídos usando sua plataforma RPA inteligente. Segundo a empresa, o aplicativo irá ampliar o alcance da RPA na empresa.

“Estima-se que os indivíduos gastam uma média de quatro horas por dia em seus dispositivos móveis”, disse Abhijit Kakhandiki, vice-presidente sênior de Produtos e Engenharia para Automação em Qualquer Lugar. “A capacidade de controlar bots e gerenciar toda a força de trabalho digital a partir de um dispositivo móvel, sempre de fácil acesso, é um gamechanger”.

NVIDIA abre laboratório de pesquisa em robótica em Seattle A
NVIDIA anunciou que está abrindo um novo laboratório de pesquisa em robótica perto da Universidade de Washington em Seattle. O objetivo do laboratório é conduzir pesquisas de robótica para permitir que uma próxima geração de robôs seja capaz de executar tarefas complexas de manipulação e trabalhar com segurança entre seres humanos.

De acordo com a NVIDIA, cerca de 50 pesquisadores, professores visitantes e estagiários estudarão no laboratório. “No passado, a pesquisa em robótica se concentrava em projetos pequenos e independentes, em vez de sistemas totalmente integrados. Estamos reunindo uma equipe interdisciplinar colaborativa de especialistas em controle e percepção de robô, visão computacional, interação homem-robô e aprendizado profundo ”, disse Dieter Fox, diretor sênior de pesquisa em robótica da NVIDIA e professor da UW Paul G. Allen School of Ciência da Computação e Engenharia.

/* O PROJETO TEM COMO OBJETIVO CONTROLAR UM SISTEMA DE OSMOSE REVERSA CONSTITUÍDA POR 3 BOMBAS, ONDE OS CONTATOS AUXILIARES
DOS SEUS DISJUNTORES DEVEM MANDAR UM SINAL PARA O ARDUINO, O QUAL IRÁ VERIFICAR SE A BOMBA ESTÁ EM FUNCIONAMENTO, CASO
O ARDUINO NÃO RECEBA O SINAL, O DISPLAY INDICARÁ QUE DETERMINADA BOMBA PAROU DE FUNCIONAR. HÁ TAMBÉM DOIS SENSORES BÓIA
QUE INDICARÁ O NÍVEL DO TANQUE. */

 

#include <LiquidCrystal.h>
LiquidCrystal lcd(3, 4, 5, 6, 7, 13);

// DEFINIÇÃO DE ENTRADAS E SAÍDAS DIGITAIS
#define SinalBombaOR 9 // ENTRADA DE SINAL DO CONTATO AUXILIAR DO DISJUNTOR DA BOMBA OR
#define SinalBombaPressOR 10 // ENTRADA DE SINAL DO CONTATO AUXILIAR DO DISJUNTOR DA BOMBA DE PRESSURIZAÇÃO OR
#define SinalBombaPressCME 11 // ENTRADA DE SINAL DO CONTATO AUXILIAR DO DISJUNTOR DA BOMBA DE PRESSURIZAÇÃO CME
#define SinalBoiaInferior 12 // ENTRADA DE SINAL DA BOIA INFERIOR
#define SinalBoiaSuperior 8 // ENTRADA DE SINAL DA BOIA SUPERIOR
#define Sirene A0 // SAÍDA DE SINAL PARA ACIONAR O RELÉ SINALIZADOR DE SOM
#define LuzVermelha A1 // SAÍDA DE SINAL PARA ACIONAR O RELÉ SINALIZADOR DA COR VERMELHA
#define LuzAmarela A2 // SAÍDA DE SINAL PARA ACIONAR O RELÉ SINALIZADOR DA COR AMARELA
#define LuzVerde A3 // SAÍDA DE SINAL PARA ACIONAR O RELÉ SINALIZADOR DA COR VERDE

// VARIAVÉIS GLOBAIS
float vazao = 0; // VARIÁVEL PARA ARMAZENAR O VALOR EM L/MIN
int contaPulso; // VARIÁVEL PARA A QUANTIDADE DE PULSOS
int leituraBombaOR = 0; // VARIAVEL PARA ARMAZENAMENTO DE ESTADO
int leituraPressOR = 0; // VARIAVEL PARA ARMAZENAMENTO DE ESTADO
int leituraPressCME = 0; // VARIAVEL PARA ARMAZENAMENTO DE ESTADO
int leituraBoiaInferior = 0; // VARIAVEL PARA ARMAZENAMENTO DE ESTADO
int leituraBoiaSuperior = 0; // VARIAVEL PARA ARMAZENAMENTO DE ESTADO
bool mostra = false; // Libera tela de vazao
bool flag = false; // Controle para evitar repetição de dispaly
unsigned long tempo = 0; // Tempo de milis()
unsigned long ciclo = 500; // Tempo de liberação de display
//————————————————————————-
void setup()
{
// PORTAS DE ENTRADA DE SINAL
Serial.begin(9600);
pinMode(SinalBombaOR, INPUT_PULLUP); // PULLUP INVERTE A LOGICA DA PORTA
pinMode(SinalBombaPressOR, INPUT_PULLUP); // PULLUP INVERTE A LOGICA DA PORTA
pinMode(SinalBombaPressCME, INPUT_PULLUP); // PULLUP INVERTE A LOGICA DA PORTA
pinMode(SinalBoiaInferior, INPUT_PULLUP); // PULLUP INVERTE A LOGICA DA PORTA
pinMode(SinalBoiaSuperior, INPUT_PULLUP); // PULLUP INVERTE A LOGICA DA PORTA
pinMode(2, INPUT); // ENTRADA DO PULSO DO SENSOR DE VAZAO
attachInterrupt(0, incpulso, RISING); // CONFIGURA O PINO 2(INTERRUPÇÃO 0)

// PORTAS DE SAÍDA DE SINAL PARA ACIONAMENTO DO RELÉ (SE ATIVA NO ESTADO LOW)
pinMode(Sirene, OUTPUT);
pinMode(LuzVermelha, OUTPUT);
pinMode(LuzAmarela, OUTPUT);
pinMode(LuzVerde, OUTPUT);

// CONFIGURA OS RELÉS PARA FICAREM INICIALMENTE DESLIGADOS
digitalWrite(Sirene, HIGH);
digitalWrite(LuzVermelha, HIGH);
digitalWrite(LuzAmarela, HIGH);
digitalWrite(LuzVerde, HIGH);

// INICIALIZAÇÃO DO LCD
lcd.begin(16, 2);
lcd.setCursor(0, 0);
lcd.print(“Monitoramento da”);
lcd.setCursor(1, 1);
lcd.print(“Osmose Reversa”);
delay(1000);
tempo = millis(); // Inicializa tempo
}
//————————————————————————-
void tela_vazao ()
{
mostra = true; // Trava mostra seguida
vazao = (contaPulso / 5.5) / 2; // CONVERTE PARA L/MIN /2 pois usei 500ms
lcd.setCursor (6, 1); // Posiciona cursor
lcd.print(vazao); // ESCREVE NO DISPLAY O VALOR DA VAZAO
contaPulso = 0; // ZERA A VARIÁVEL
}
//————————————————————————-
void loop ()
{
// LEITURA DOS SINAIS NAS PORTAS DIGITAIS(D9 À D13)
leituraBombaOR = digitalRead(SinalBombaOR);
leituraPressOR = digitalRead(SinalBombaPressOR);
leituraPressCME = digitalRead(SinalBombaPressCME);
leituraBoiaInferior = digitalRead(SinalBoiaInferior);
leituraBoiaSuperior = digitalRead(SinalBoiaSuperior);
/*
bombaOR pressOR pressCME inferior superior
HIGH LOW LOW LOW LOW Defeito Bomba OR
LOW HIGH LOW LOW LOW Defeito Bomba Press OR
LOW LOW HIGH LOW LOW Defeito Bomba Press CME
LOW LOW LOW HIGH LOW TANQUE VAZIO
LOW LOW LOW LOW LOW TANQUE ENCHENDO
LOW LOW LOW LOW HIGH TANQUE CHEIO
*/
if ((millis() – tempo) >= ciclo) // Tempo de display
{
tempo = millis(); // Recupera millis()
flag = false; // Libera display
mostra = false; // Libera tela vazao
}

if (leituraBombaOR == HIGH) // SE O SINAL DA BOMBA OR ESTIVER 0VCC
{
if (flag == false) // Se display liberado
{
digitalWrite(Sirene, LOW); // SIRENE ALARMA INDICANDO FALHA NO SISTEMA DA OSMOSE
digitalWrite(LuzVermelha, LOW); // LUZ VERMELHA INDICANDO FALHA NO SISTEMA DA OSMOSE
lcd.clear(); // LIMPA O DISPLAY E, EM SEGUIDA, MOSTRA A FALHA DO SISTEMA
lcd.setCursor (3, 0);
lcd.print (“Defeito na”);
lcd.setCursor (4, 1);
lcd.print (“Bomba OR”);
flag = true; // Trava display
}
}

if (leituraPressOR == HIGH ) // SE O SINAL DA BOMBA DE PRESSURIZAÇÃO OR ESTIVER 0VVC
{
if (flag == false) // Se display liberado
{
digitalWrite(Sirene, LOW); // SIRENE ALARMA INDICANDO FALHA NO SISTEMA DA OSMOSE
digitalWrite(LuzVermelha, LOW); // LUZ VERMELHA INDICANDO FALHA NO SISTEMA DA OSMOSE
lcd.clear(); // LIMPA O DISPLAY E, EM SEGUIDA, MOSTRA A FALHA DO SISTEMA
lcd.setCursor (3, 0);
lcd.print (“Defeito na”);
lcd.setCursor (1, 1);
lcd.print (“Bomba Press OR”);
flag = true; // Trava display
}
}

if (leituraPressCME == HIGH) // SE O SINAL DA BOMBA DE PRESSURIZAÇÃO CME ESTIVER 0VCC
{
if (flag == false) // Se display liberado
{
digitalWrite(Sirene, LOW); // SIRENE ALARMA INDICANDO FALHA NO SISTEMA DA OSMOSE
digitalWrite(LuzVermelha, LOW); // LUZ VERMELHA INDICANDO FALHA NO SISTEMA DA OSMOSE
lcd.clear(); // LIMPA O DISPLAY E, EM SEGUIDA, MOSTRA A FALHA DO SISTEMA
lcd.setCursor (3, 0);
lcd.print (“Defeito na”);
lcd.setCursor (0, 1);
lcd.print (“Bomba Press CME”);
flag = true; // Trava display
}
}

if (leituraBoiaInferior == HIGH ) // SE O SINAL DA BOIA INFERIOR E SUPERIOR ESTIVEREM BAIXO
{
if (flag == false) // Se display liberado
{
digitalWrite(Sirene, LOW); // SIRENE ALARMA INDICANDO FALHA NO SISTEMA DA OSMOSE
digitalWrite(LuzVermelha, LOW); // LUZ VERMELHA INDICANDO FALHA NO SISTEMA DA OSMOSE
lcd.clear(); // LIMPA O DISPLAY E, EM SEGUIDA, MOSTRA A FALHA DO SISTEMA
lcd.setCursor (4, 0);
lcd.print (“Atencao”);
lcd.setCursor (2, 1);
lcd.print (“Tanque Vazio”);
flag = true; // Trava display
}
}

if (leituraBombaOR == LOW && leituraPressOR == LOW && leituraPressCME == LOW && leituraBoiaInferior == LOW && leituraBoiaSuperior == LOW) // SE O SINAL DA BOIA SUPERIOR ESTIVER BAIXO
{
if (flag == false) // Se display liberado
{
digitalWrite(Sirene, HIGH); // SIRENE DESATIVADA INDICANDO QUE NÃO HÁ FALHAS NO SISTEMA DA OSMOSE
digitalWrite(LuzAmarela, LOW); // LUZ AMARELA INDICA QUE O TANQUE DE ÁGUA ESTÁ ENCHENDO
lcd.clear(); // LIMPA O DISPLAY E, EM SEGUIDA, MOSTRA A INFORMAÇÃO DO SISTEMA
lcd.setCursor (0, 0);
lcd.print (“Tanque Enchendo”);
flag = 1;
lcd.setCursor(0, 1);
lcd.print(“Vazao “);
lcd.setCursor(12, 1);
lcd.print(“L/mn”); // ESCREVE L/MIN
flag = true; // Trava display
}
if ( mostra == false)
tela_vazao(); // ESCREVE O VALOR DA VAZAO
}

if ( leituraBoiaSuperior == HIGH) // SE O SINAL DA BOIA INFERIOR E SUPERIOR ESTIVEREM ALTO
{
if (flag == false) // Se display liberado
{
digitalWrite(Sirene, HIGH); // SIRENE DESATIVADA INDICANDO QUE NÃO HÁ FALHAS NO SISTEMA DA OSMOSE
digitalWrite(LuzVerde, LOW); // LUZ VERDE INDICA QUE O TANQUE DE ÁGUA ESTÁ CHEIO
lcd.clear(); // LIMPA O DISPLAY E, EM SEGUIDA, MOSTRA A INFORMAÇÃO DO SISTEMA
lcd.setCursor (4, 0);
lcd.print (“Atencao”);
lcd.setCursor (2, 1);
lcd.print (“Tanque Cheio”);
flag = true; // Trava display
}
}
} // FIM DO VOID LOOP
//————————————————————————-
void incpulso ()
{
contaPulso++; // INCREMENTA A VARIÁVEL DE PULSOS
}

Plataforma UiPath

A plataforma RPA possui três produtos principais:

  • UiPath Studio – uma ferramenta avançada que permite projetar processos de automação de maneira visual, através de diagramas.
  • UiPath Robot – executa os processos construídos no Studio, como um humano faria. Os robôs podem trabalhar sem supervisão (executar sem supervisão humana em qualquer ambiente, seja ele virtual ou não) ou como assistentes (um ser humano aciona o processo).
  • UiPath Orchestrator – um aplicativo da web que permite implantar, agendar, monitorar e gerenciar robôs e processos, enquanto o tratamento de exceções de negócios está disponível por meio de filas de trabalho centralizadas.

Neste tutorial, você aprenderá muitas informações básicas sobre os três aplicativos apresentados acima e as palavras-chave usadas com eles.

Tipos de fluxo de trabalho e atividades

Vários tipos de fluxos de trabalho estão disponíveis no Studio (sequências, fluxogramas e processos de negócios transacionais) que ajudam a criar seu fluxo de trabalho de automação de acordo com suas necessidades.

Para criar esses fluxos de trabalho, você precisa de atividades (ações que você usa para automatizar aplicativos, como clicar e digitar). Cerca de 300 dessas atividades existem e permitem que você interaja com navegadores da Web, aplicativos de área de trabalho, PDFs, imagens, bancos de dados, terminais, planilhas do Excel, contas de e-mail e muitos outros, além de criar facilmente solicitações HTTP e SOAP.

Funcionalidade do Gravador

A maneira mais fácil de criar fluxos de trabalho é usando o recurso de registro. Quatro tipos de gravações estão disponíveis: Basic , Desktop , Web e Citrix . Os dois primeiros podem ajudá-lo a automatizar os aplicativos de desktop, enquanto os outros permitem que você lide adequadamente com aplicativos da Web e ambientes virtuais.

Variáveis ​​e Funções .Net

Uma variável permite que você armazene um valor, mas apenas de um determinado tipo. Além destes, as funções Net também pode ser usado para melhorar a sua automação, como .trim que remove os espaços do início e final de uma string, ou .ToStringque transforma um certo tipo de variável em uma string.

Robôs e orquestrador

Os robôs, os executores do UiPath, podem interagir com uma grande quantidade de aplicativos ao mesmo tempo. Um exemplo é fornecido no vídeo.

O orquestrador, a peça final do quebra-cabeça, é usado para gerenciar vários robôs implantados. Esse tipo de ambiente geralmente é encontrado em grandes empresas, que precisam automatizar muitos processos de negócios. A primeira coisa que você precisa fazer neste aplicativo da Web é registrar seu (s) robô (s). Depois disso, você precisa agrupá-los em um ambiente.

Os fluxos de trabalho publicados nessa plataforma precisam estar vinculados a um ambiente e, a partir daí, você começa a executar: seja agora ou com base em um agendamento definido de maneira personalizada. 
Você pode executar um processo em um ou vários robôs, um número específico deles ou em todos os robôs agrupados em um ambiente.

Ativos e Filas

Como os robôs podem precisar compartilhar informações, um tipo especial de variáveis ​​é introduzido no orquestrador, ativos. Eles permitem que você armazene informações (incluindo credenciais) no banco de dados do aplicativo da Web, para que seja fácil alterar um valor que é usado em vários processos, e vários robôs podem ter acesso a ele.

O UiPath também faz uso de filas de trabalho para distribuir a carga de um processo transacional entre vários robôs. Eles podem ser programados para começar antes ou depois de uma determinada data, e informações detalhadas contidas em cada item da fila podem ser visualizadas.

Logs, Auditoria, Alertas e Outros 

Na guia Registros, você pode ver facilmente como os Robôs foram executados, quais tarefas foram concluídas ou se falharam. Além disso, todas as etapas realizadas pelo usuário podem ser auditadas e os alertas são enviados por e-mail para todos aqueles que possuem as permissões necessárias.

Finalmente, o gerenciamento de funções está disponível, juntamente com outros recursos interessantes, como a importação de usuários de um grupo do Active Directory, a divisão de processos de automação entre equipes por meio de vários inquilinos e a exibição de informações em gráficos precisos.

 

 

Fonte:  https://www.uipath.com/developers/video-tutorials/introduction-to-uipath

Arduino Based Home Automation Usando TV Remote

A Arduino Based Home Automation usando TV Remote é um projeto simples, onde um controle remoto de TV antigo é usado para controlar diferentes aparelhos.

Home Automation é um conceito em que um único dispositivo é usado para controlar muitos aspectos de uma casa, como ligar ou desligar aparelhos diferentes, monitoramento de temperatura, alarmes de incêndio, portas de garagem etc. Neste projeto, um controle remoto é usado para controlar (simplesmente ON e OFF) vários aparelhos ou dispositivos, conseguindo assim um sistema de automação residencial simples.

Os controles remotos são um dos dispositivos comumente encontrados em quase todas as casas. Eles nos ajudam a operar um aparelho como TV, Ar-condicionado, VCR, etc. A principal característica de um controle remoto é que ele é específico para um dispositivo. Por exemplo, uma unidade de controle remoto de TV só pode ser usada para essa TV correspondente.

Mas neste projeto, nós criamos uma automação doméstica baseada em Arduino usando TV Remote, onde um único controle remoto é usado para controlar 4 dispositivos diferentes (possível controlar mais dispositivos). O projeto é baseado no Arduino UNO e mais detalhes do projeto são mencionados abaixo.

Diagrama de circuito

Componentes necessários

  • Arduino UNO board
  • TSOP 1738 IR Remote Control Receiver
  • 1 KΩ Resistor X 4
  • 2N2222 NPN Transistor X 4
  • 1N4007 Diodo X 4
  • 12 V Relé X 4
  • Controle remoto
  • Placa de prototipagem (Painel de pão)
  • Fios de conexão
  • 12 V Fonte de alimentação

Descrição do Componente

Arduino UNO

Arduino UNO forma a principal parte controladora do circuito. A UNO tem 13 pinos de E / S digitais e, portanto, é possível controlar 13 dispositivos diferentes ao mesmo tempo. Se o requisito é controlar mais número de dispositivos, placas como Arduino Mega podem ser usadas.

TSOP1738

TSOP1738 é um módulo receptor para controles remotos IR com uma freqüência portadora de 38 KHz. Consiste em um detector de foto e demodulador de sinal em uma única embalagem e a saída pode ser usada diretamente por um microcontrolador.

Placa de relé de 4 canais

Um relé ajuda a controlar um aparelho grande com a ajuda de um microcontrolador. Neste projeto, uma placa de relé de 4 canais é usada para controlar quatro cargas.

Os componentes necessários, como o LED de alimentação, o transistor de comutação, o resistor de limitação de corrente de base, o relé no LED, o diodo flyback e os cabeçalhos macho para conexões de alimentação e entrada já estão incorporados na placa.

 

Cuidado : devemos ter muito cuidado ao usar um relé com alimentação de rede CA.

Controle remoto

Um mini controle remoto padrão é usado neste projeto para fornecer as várias entradas de chave. O controle remoto possui todas as teclas numéricas, volume para cima, baixo, canal para baixo, menu e algumas teclas adicionais.

 

Como projetar a automação residencial baseada em Arduino usando o circuito remoto da TV?

A partir do diagrama de circuito, é claro que o design do circuito é muito simples e requer muita conexão. O design do circuito é explicado abaixo.

O componente principal do projeto é o receptor TSOP1738. É um dispositivo de três pinos, onde os três pinos são GND, VS e OUTPUT. O pino VS está conectado à fonte de 5V. O pino de saída está conectado ao Pino 11 (ou a qualquer outro pino digital) do Arduino UNO.

Estamos usando um módulo de retransmissão de 4 canais neste projeto para controlar 4 cargas diferentes. Uma vez que a placa possui todos os componentes necessários, como transistores, LEDs, etc., tudo o que precisamos fazer é conectar as 4 entradas na placa de relé a 4 pinos de E / S digitais da Arduino. Uma conexão mais detalhada pode ser encontrada no diagrama de circuito.

Trabalho da Arduino baseado em automação residencial usando TV Remote

A automação residencial é um conceito de demanda onde um único dispositivo controlará diferentes aparelhos de uma casa. Além disso, diferentes aspectos como temperatura, umidade, segurança etc. também podem ser monitorados usando esse dispositivo.

Neste projeto, um sistema de automação residencial simples, no qual o sistema controla 4 aparelhos diferentes com a ajuda de um controle remoto de TV. O trabalho do projeto é explicado aqui.

O principal componente do projeto é TSOP1738 IR Receiver Module. Este módulo possui um receptor de foto incorporado, filtro de passagem de banda e desmodulador e a saída do módulo pode ser prontamente lida por um microcontrolador.

TSOP1738 suporta uma freqüência portadora de 38 KHz. Assim, a freqüência portadora da fonte, ou seja, o controle remoto deve estar na faixa de 38 KHz para que ele se desmodule.

Primeiro, descodificaremos os dados do controle remoto usando TSOP1738 e Arduino UNO. Para isso, precisamos usar uma biblioteca especial chamada “IRremote”. Precisamos baixar esta biblioteca em https://github.com/z3t0/Arduino-IRremote e colocá-la na pasta bibliotecas do Arduino.

O próximo passo é decodificar os dados de cada tecla do controle remoto. Para isso, vamos usar algumas funções na biblioteca “IRremote”. O programa a seguir nos ajudará a decodificar os dados de cada chave do controle remoto. NOTA: O seguinte programa é um esboço de exemplo da biblioteca “IRremote”.

#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup() {
Serial.begin(9600);
irrecv.enableIRIn();
}
void loop() {
if (irrecv.decode(&results)) {
Serial.println(results.value, HEX);
irrecv.resume();
}
delay(100);
}

https://gist.githubusercontent.com/elktros/59298a69a71bb16cac9c879d08677e9b/raw/9513ce93ca53c42f0b31d98b260c3d0123f0c3f3/Arduino%20based%20Home%20Automation%20using%20TV%20Remote%20

Quando este esboço é executado no Arduino, podemos monitorar os dados no terminal serial para cada tecla pressionada no controle remoto. A seguinte imagem mostra os valores de HEX descodificados das teclas 1 a 9, 0 e a tecla de energia, respectivamente.

 

Quando este esboço é executado no Arduino, podemos monitorar os dados no terminal serial para cada tecla pressionada no controle remoto. A seguinte imagem mostra os valores de HEX descodificados das teclas 1 a 9, 0 e a tecla de energia, respectivamente.

 

#include <IRremote.h>
const int RECV_PIN=11;
IRrecv irrecv(RECV_PIN);
decode_results results;
#define IN1 3
#define IN2 4
#define IN3 5
#define IN4 6
bool i=false;
bool j=false;
bool k=false;
bool l=false;
bool m=false;
void setup()
{
Serial.begin(9600);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
irrecv.enableIRIn();
irrecv.blink13(true);

}
void loop()
{
if (irrecv.decode(&results))
{
Serial.println(results.value,HEX);
delay(100);
/////////////////////////
if(results.value==0x40BD00FF)
{
i=!i;
digitalWrite(IN1, i);

}
////////////////////////
if(results.value==0x40BD807F)
{
j=!j;
digitalWrite(IN2, j);

// delay(200);
}
if(results.value==0x40BD40BF)
{
k=!k;
digitalWrite(IN3, k);

// delay(200);
}
//////////////////////////////
if(results.value==0x40BDC03F)
{
l=!l;
digitalWrite(IN4, l);

// delay(200);
}
//////////////////////
if(results.value==0x40BD28D7)
{
m=!m;
digitalWrite(IN1, m);
digitalWrite(IN2, m);
digitalWrite(IN3, m);
digitalWrite(IN4, m);

// delay(200);
}
irrecv.resume(); // Receive the next value
//delay(100);
}
}

 

Aplicação

  • Um projeto simples, onde uma automação residencial baseada em Arduino usando TV Remote é projetada aqui, que usa o Arduino UNO, o Relay e o antigo Remote TV.
  • O projeto é demonstrado com 4 cargas, mas pode ser aumentado para ainda mais cargas.
  • Como o dispositivo de controle é um controle remoto de TV, o projeto do projeto é muito simples e a aplicação também é muito fácil.

Vídeo de construção e saída

 

Link: http://www.electronicshub.org/arduino-based-home-automation-using-tv-remote/

AUTOMAÇÃO NO CULTIVO DE MICROALGAS

Título: AUTOMAÇÃO NO CULTIVO DE MICROALGAS
Autores: SANTOS, Cainã Santana dos
COSTA, Tiago Marcelino Ferreira da
Palavras Chave: Automação
Arduino
Biodiesel
Microalgas
Engenharia de Controle e Automação
Data: 1-Ago-2017
Resumo: Grande poluição causada pelo uso de combustíveis fósseis e o alto custo de extração e tratamento deste tipo de combustível tem levado à busca por encontrar fontes alternativas de combustíveis por causa da grande poluição causada pelo uso de combustíveis fósseis e do alto custo de extração e tratamento deste tipo de combustível. O cultivo de microalgas tem aumentado para pesquisas cujo o objetivo é produzir o biodiesel, por não causar danos ao meio ambiente, por ser economicamente mais viável e ocupar menos espaço para ser produzidos. Diante do exposto, este trabalho teve como objetivo elaborar um processo de automação de medição e supervisão do processo de produção de microalga Chlorella minutissima para a produção de biodiesel. Para tal, foi elaborado um sensor para executar leituras de absorbância do meio de cultivo no laboratório de Qualidade, Meio Ambiente e Bioenergia – USP. Os cultivos são realizados em triplicata, em fotobiorreatores de acrílico com 40 l de capacidade. Um pequeno volume do meio de cultivo é periodicamente drenado, por meio de uma bomba esguicho de água de 12 V, para dentro do sensor. O aparato é constituído dentro de uma caixa metálica e no interior desta caixa passa um tubo de PVC de 1/2” que recebe aberturas nos 2 lados onde são alocados 2 quadrados de vidro de 1 cm2 para o encaixe, de um lado, do Led RGB como emissor de luz que trabalha nos comprimentos de onda das cores vermelha (690 nm) e verde (540 nm) e, do outro lado, o LDR como coletor .As informações geradas pelos dispositivos são processadas pelo microcontrolador Arduino ATmega integrado com shild Ethernet W5100, com sensor de temperatura DS18B20 e um módulo de sensor de pH para solução, e são exibidas em um supervisório. Desta forma, a monitoração da evolução do processo de cultivo das microalgas pode ser visualizada remotamente. Foram realizados três analises, duas contendo uma quantidade de microalgas e uma somente de água, a solução de água se mostrou 0% de absorbância e outras duas demostrou valores mais significativos.
URI: http://hdl.handle.net/123456789/496
Aparece nas Colecções: Engenharia de Controle e Automação

Sensor de temperatura DS18B20

O sensor DS18B20 utiliza o protocolo de comunicação 1-Wire. Este protocolo permite a conexão de inúmeros dispositivos numa mesma rede, utilizando apenas 1 fio para a troca de dados.

O sensor DS18B20 fornece temperaturas entre -55°C e 125°C com uma precisão de ±0.5°C no intervalo de -10°C to +85°C. Vide datasheet. Ele é identificado na rede 1-Wire a partir de um código único de 64 bits.

Na figura acima são observados os seus pinos no encapsulamento TO92. Nota-se que o pino GND corresponde ao terra, VDD a 5V e no pino DQ é fornecida a informação de temperatura.
 Um microcontrolador pode ler informações deste sensor utilizando um único fio e resistor de pull-up, sendo normalmente utilizado um resistor de 4k7 ohms.

No circuito abaixo observa-se a conexão do sensor com uma placa arduino, sendo que foi escolhida a porta digital 2 do arduino para a leitura do sensor.

ds18b20_schem
Com este circuito, é possível monitorar as temperaturas amostradas pelo sensor utilizando o código  abaixo. As bibliotecas OneWire e DallasTemperature podem ser obtidas aqui. Basta descompactar as bibliotecas no diretório “libraries” do ambiente arduino.
#include "OneWire.h"
#include "DallasTemperature.h"


#define ONE_WIRE_BUS 2       // sensor conectado na porta digital 2


OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

void setup() {
Serial.begin(9600);
sensors.begin();
}

void loop() {
sensors.requestTemperatures();

Serial.print(“Temperatura no sensor 1 : “); // pode haver mais
Serial.println(sensors.getTempCByIndex(0)); // do que um sensor
}

Para verificar as temperaturas amostradas, basta pressionar a tecla “Serial Monitor” no ambiente de programação arduino e visualizar uma tela similar à figura abaixo:

ds18b20Janela

Arduino: Leitura do sensor DS18S20 e DS18B20

1

Demonstração de leitura do sensor DS18S20 e DS18B20 utilizando o arduino. Esses sensor utiliza a comunicação 1-Wire, que possui vantagens em releção ao I2C, pois permite a integração de vários sensores utilizando apenas um fio.
Eu utilizei a biblioteca OneWire, que pode ser baixada aqui.
Funções principais da biblioteca OneWire:
OneWire ds( pin ); – Cria o objeto onewire e define o pino a ser utilizado.
ds.search( addr );  – recupera o endereço de todos no barramento.
ds.reset(); – reset no barramento.
ds.select( addr ); – seleciona o sensor.
ds.write( byte ); – envia um byte ao sensor.
ds.read() – lê um byte do sensor.

DOWNLOAD:
Arquivo de simulação do Proteus: DS18x20_Arduino.DSN;

CóDIGO-FONTE:
2
#include <LiquidCrystal.h>
#include <OneWire.h>

OneWire ds(2); // pino 2
LiquidCrystal lcd(13,12,11,10,9,8);

void setup(void) {
lcd.begin(16,2);
lcd.print(“DS18S20: “);
lcd.setCursor(0,1);
lcd.print(“DS18B20: “);
}

void loop(void) {
byte i = 0;
byte data[9];
byte addr[8];
int temp;
boolean type;

//recupera o endereço dos sensores e armazena em “addr”
if(!ds.search(addr)){
return;
}

switch(addr[0]){
case 0x10: type = 1; break;//DS18S20
case 0x22: type = 0; break;//DS1822
case 0x28: type = 0; break;//DS18B20
default: break;
}

ds.reset();//sinal de reset
ds.select(addr);//envia o endereço do sensor
ds.write(0x44);//inicializa conversao de temperatura
delay(750);//espera 750ms para calcular a temperatura

ds.reset();//sinal de reset
ds.select(addr);//envia o endereço do sensor atual
ds.write(0xBE);//inicia a leitura do scratchpad ( 9 bytes )

//Leitura
for ( i = 0; i < 9; i++) {
data[i] = ds.read();
}

if(!type){//DS18B20 ou DS1822

lcd.setCursor(9,1);

if((data[1]>>7)==1){//verifica se a temperatura é negativa
data[1] = ~data[1];
data[0] = (~data[0]) + 1;
lcd.print(“-“);
}
else{
lcd.print(“+”);
}
temp = (data[1]<<4) | (data[0]>>4);
lcd.print(temp);
lcd.print(“.”);
temp = (data[0] & 0x0F) * 625;//casas decimais
if(temp>625){
lcd.print(temp);
}
else{
lcd.print(“0”);
lcd.print(temp);
}
}
else{//DS18S20

lcd.setCursor(9,0);

if((data[1]>>7)==1){//verifica se a temperatura é negativa
data[0] = ~data[0];
lcd.print(“-“);
}
else{
lcd.print(“+”);
}
temp = data[0]>>1;
lcd.print(temp);
lcd.print(“.”);
lcd.print((data[0] & 0x01)*5);//casa decimal

}
lcd.print(” “);
lcd.write(223);//imprime o caracter (°)
lcd.print(“C “);
}

3
UTILIZANDO APENAS UM SENSOR

Caso utilize apenas um sensor no barramento, não há necessidade de fazer a procurar do endereço ROM do dispositivo, pois o mesmo nem será usado.

Ao invés disso envie o comando SKIP ROM(0xCC).
Veja o código como ficou, utilizando apenas o DS18B20:
2
#include <LiquidCrystal.h>
#include <OneWire.h>

OneWire ds(2); // pino 2
LiquidCrystal lcd(13,12,11,10,9,8);

void setup(void) {
lcd.begin(16,2);
lcd.print(“DS18S20: “);
}

void loop(void) {
byte data[9];
int temp;

ds.reset();//sinal de reset
ds.write(0xCC);//skip rom
ds.write(0x44);//inicia conversão de temperatura
delay(750);//espera 750ms para calcular a temperatura
ds.reset();//sinal de reset
ds.write(0xCC);//skip rom
ds.write(0xBE);//inicia a leitura do scratchpad ( 9 bytes )

//Leitura
for (byte i = 0; i < 9; i++) {
data[i] = ds.read();
}
lcd.setCursor(9,0);

if((data[1]>>7)==1){//verifica se a temperatura é negativa
data[1] = ~data[1];
data[0] = (~data[0]) + 1;
lcd.print(“-“);
}
else{
lcd.print(“+”);
}
temp = (data[1]<<4) | (data[0]>>4);
lcd.print(temp);
lcd.print(“.”);
temp = (data[0] & 0x0F) * 625;
if(temp>625){
lcd.print(temp);
}
else{
lcd.print(“0″);
lcd.print(temp);
}
lcd.print(” “);
lcd.write(223);//imprime o caracter (°)
lcd.print(“C “);
}

3

RECUPERANDO O ENDEREÇO ROM
Caso você queira saber o endereço ROM do sensor, é preciso enviar o comando READ ROM(0x33). Veja que so poderá ter apenas um sensor no barramento, para que não ocorra uma colisão de dados.

Você verá no monitor serial algo do tipo: 10 30 C5 B8 0 0 0 C3;
o código em azul: indica a familia do sensor (0x10 – DS18S20, 0x28 – DS18B20, 0x22 – DS1822)
o código em verde: é o número serial (possui 6 bytes, do menos significativo ao mais significativo)
o código em vermelho: é o CRC(verificador de redundância cíclica), usado para a verificar se os dados enviados ao arduino não possuem erros.

Veja o código:
2
#include <OneWire.h>

OneWire ds(2); // pino 2

void setup(void) {
Serial.begin(9600);
}

void loop(void) {
byte i = 0;
byte data[8];
int temp;

ds.reset();//sinal de reset
ds.write(0x33);//read rom

//Leitura
for ( i = 0; i < 8; i++) {
data[i] = ds.read();
Serial.print(data[i], HEX);
Serial.print(” “);
}

Serial.println();

delay(100);
}

3
EXEMPLO COM DS18S20 E POSSUINDO SEU ENDEREÇO ROM
2
#include <OneWire.h>

OneWire ds(2); // pino 2

void setup(void) {
Serial.begin(9600);
}

void loop(void) {
byte data;
byte signal;
int temp;
byte addr[8]={0x10,0x30,0xC5,0xC8,0,0,0,0xC3};//endereço rom do ds18s20

ds.reset();//sinal de reset
ds.select(addr);//envia o endereço rom
ds.write(0x44);//inicia a conversão da temperatura
delay(750);
ds.reset();//sinal de reset
ds.select(addr);//envia o endereço rom
ds.write(0xBE);//leitura da temperatura
data = ds.read();//byte 0 – temperatura
signal = ds.read();//byte 1 – sinal de negativo/positivo
if(signal){//se a temp. for negativa
data = (~data);
Serial.print(“-“);
}
Serial.print(data>>1);
Serial.print(“.”);
Serial.print((data & 0x01)*5);
Serial.println();

delay(100);
}

3
Ligação do Sensor DS18S20 e DS18B20:
DS18B20 - 2 sensores