Calculadoras de valor do transformador de corrente (CT) OpenEnergyMonitor

Essas calculadoras são projetadas para ajudá-lo a determinar os valores dos componentes necessários para o (s) transformador (es) de corrente usado (s) no projeto Open Energy Monitor . Vá dar uma olhada!

Por favor, note que estas calculadoras não levam em consideração a permeabilidade do núcleo e o valor do core AL. Use por sua conta e risco.

Atualização de novembro de 2017: Fórmulas fixas exibidas abaixo de cada calculadora para reduzir pela metade a voltagem do sistema como foi originalmente planejado.


Tensão do sistema: Volts
Para monitores de energia baseados em arduinos de 5V (principalmente os mais antigos), digite 5 acima


Resistor de carga

Calcula o valor do resistor de sobrecarga a ser usado em uma corrente Max RMS do transformador de 
corrente:Amps
Relação atual da volta do sensor:: 1
valor do resistor calculado:Ohms
Fórmula:
burden_resistor = (system_voltage / 2.0) / ((I_RMS * 1.414) / ct_turns)


Corrente máxima

Calcula a corrente máxima que você pode razoavelmente esperar medir usando um transformador de corrente 
Valor do resistor de carga:Ohms
Relação atual da volta do sensor:: 1
corrente máxima calculada de RMS:Amps
Fórmula:
I_RMS = (((system_voltage / 2.0) / burden_resistor) * Turns) * 0.707


O sensor atual gira

Calcula uma estimativa do número de voltas que um transformador de corrente precisaria. 
Valor do resistor de carga:Ohms
Max RMS atual:Amps
O sensor atual gira:
Fórmula:
turns = (I_RMS * 1.414) / ((system_voltage / 2.0) / burden_resistor)

Cálculo Online de Cores de Resistores

Calculadora de código Da Cor Do Resistor

Entre com as cores das faixas do resistor e obtenha seu valor em Ohm�s ( Ω )

Preto
Marron
Vermelho
Laranja
Amarelo
Verde
Azul
Violeta
Cinza
Branco

Preto
Marron
Vermelho
Laranja
Amarelo
Verde
Azul
Violeta
Cinza
Branco

Preto
Marron
Vermelho
Laranja
Amarelo
Verde
Azul
Violeta
Cinza
Branco
Dourado
Prateado

Dourado
Prateado
Nenhum


Valor Da Resist�ncia:

 

Valores padrão de resistores (comercial):

Tabela de resistores comerciais usado na eletrônica:

1 marrom preto dourado
1,2 marrom vermelho dourado
1,5 marrom verde dourado
1,8 marrom cinza dourado
2,2 vermelho vermelho Dourado
2,7 Vermelho Violeta dourado
3,3 laranja laranja dourado
3,9 laranja branco dourado
4,7 amarelo violeta dourado
5,6 verde azul dourado
6,8 azul cinza dourado
8,2 cinza vermelho dourado
9,1 branco marrom dourado
10 marrom preto preto
12 marrom vermelho preto
15 marrom verde preto
18 marrom cinza preto
22 vermelho vermelho preto
27 vermelho violeta preto
33 laranja laranja preto
39 laranja branco preto
47 amarelo violeta preto
56 verde azul preto
68 azul cinza preto
82 cinza vermelho preto
91 branco marrom preto
100 marrom preto marrom
120 Marrom Vermelho Marrom
150 Marrom Verde Marrom
180 Marrom Cinza Marrom
220 Vermelho Vermelho Marrom
270 Vermelho Violeta Marrom
330 Laranja Laranja Marrom
390 Laranja Branco marrom
470 Amarelo Violeta Marrom
560 Verde Azul Marrom
680 Azul Cinza Marrom
820 Cinza Vermelho Marrom
910 Branco Marrom Marrom
1000 ou 1K Marrom Preto Vermelho
1200 ou 1K2 Marrom Vermelho Vermelho
1500 ou 1K5 Marrom Verde Vermelho
1800 ou 1K8 Marrom Cinza Vermelho
2200 ou 2K2 Vermelho Vermelho Vermelho
2700 ou 2K7 Vermelho Violeta Vermelho
3300 ou 3K3 Laranja Laranja Vermelho
3900 ou 3K9 Laranja Branco Vermelho
4700 ou 4K7 Amarelo Violeta Vermelho
5600 ou 5K6 Verde Azul Vermelho
6800 ou 6K8 Azul Cinza Vermelho
8200 ou 8K2 Cinza Vermelho Vermelho
9100 ou 9K1 Branco Marrom Vermelho
10000 ou 10K Marrom Preto laranja
12000 ou 12K Marrom Vermelho Laranja
15000 ou 15K Marrom Verde Laranja
18000 ou 18K Marrom Cinza Laranja
22000 ou 22K Vermelho Vermelho Laranja
27000 ou 27K Vermelho Violeta Laranja
33000 ou 33K Laranja Laranja Laranja
39000 ou 39K Laranja branco Laranja
47000 ou 47K Amarelo Violeta Laranja
56000 ou 56K Verde Azul Laranja
68000 ou 68K Azul Cinza Laranja
82000 ou 82K Cinza Vermelho Laranja
91000 ou 91K Branco Marrom Laranja
100000 ou 100K Marrom Preto Amarelo
120000 ou 120K Marrom Vermelho Amarelo
150000 ou 150K Marrom Verde Amarelo
180000 ou 180K Marrom Cinza Amarelo
220000 ou 220K Vermelho Vermelho Amarelo
270000 ou 270K Vermelho Violeta Amarelo
330000 ou 330K Laranja Laranja Amarelo
390000 ou 390K Laranja Branco Amarelo
470000 ou 470K Amarelo Violeta Amarelo
560000 ou 560K Verde Azul Amarelo
680000 ou 680k Azul Cinza Amarelo
820000 ou 820K Cinza Vermelho Amarelo
910000 ou 910K Branco Marrom Amarelo
1000000 ou 1M Marrom Preto Verde
1200000 ou 1M2 Marrom Vermelho Verde
1500000 ou 1M5 Marrom Verde Verde
1800000 ou 1M8 Marrom Cinza Verde
2200000 ou 2M2 Vermelho Vermelho Verde
2700000 ou 2M7 Vermelho Violeta Verde
3300000 ou 3M3 Laranja Laranja Verde
3900000 ou 3M9 Laranja Branco Verde
4700000 ou 4M7 Amarelo Violeta Verde
5600000 ou 5M6 Verde Azul Verde
6800000 ou 6M8 Azul Cinza Verde
8200000 ou 8M2 Cinza Vermelho Verde
9100000 ou 9M1 Branco Marrom Verde
10000000 ou 10M Marrom Preto Azul
12000000 ou 12M Marrom Vermelho Azul
15000000 ou 15M Marrom Verde Azul
18000000 ou 18M Marrom Cinza Azul
22000000 ou 22M Vermelho Vermelho Azul
Calculadora online de c�digo de Cores de Resistor

Resistores em série


Um circuito de associação em série de resistores, é um circuito em que os resistores (resistências) estão dispostos em uma cadeia, de modo que a corrente tem apenas um caminho a seguir. A corrente é a mesma através de cada resistência. A resistência total do circuito é encontrado simplesmente somando os valores de resistência dos resistores:
Resistores em série: R = R 1 + R 2 + R 3 + …
Resistores em s�rie

Um circuito em s�rie � mostrado acima. A corrente passa atrav�s de cada resistor, por sua vez. Se os valores das tr�s resistências s�o os seguintes:
Com uma bateria de 10 V, por V = IR a corrente total no circuito � a seguinte:
I = V / I = 10/20 = 0,5 A. A corrente atrav�s de cada resist�ncia seria 0,5 A.

 

Resistores em paralelo

 

Em uma associa��o em paralelo de resistores � um circuito em que as resistências s�o dispostos lado a lado. Nesse caso a tens�o em todos os resistores � igual, mas a soma das correntes que atravessam os resistores � igual � resist�ncia do resistor. Ent�o a resistência equivalente de uma associação em paralelo � sempre menor que o resistor de menor resistência da associa��o.

A resistência total de um conjunto de resistores em paralelo � encontrado somando-se os rec�procos dos valores das resistências e, em seguida, tomar o recíproco do total:

resistência equivalente de resistores em paralelo: 1 / R = 1 / R 1 + 1 / R 2 + 1 / R 3 + …

Resistores em paralelo
Um circuito paralelo � mostrado acima. Neste caso, a corrente fornecida pela bateria divide-se, e a quantidade que passa por cada resistor depende da resist�ncia. Se os valores das três resistências s�o os seguintes:
Com uma bateria de 10 V, por V = IR a corrente total no circuito � a seguinte: I = V / I = 10/2 = 5 A.

As correntes individuais tamb�m pode ser encontrado usando I = V / R. A tens�o em cada resist�ncia � de 10 V, de modo que:
I 1 = 10/8 = 1,25 A
I 2 = 10/8 = 1,25 A
I 3 = 10/4 = 2,5 A

SENSOR ULTRASÔNICO JSN-SR04T

O JSN-SR04T é um sensor de distância ultra-sônico à prova d’água, fácil de usar, com uma faixa de 25 a 450 cm. Se você está planejando construir um sistema de medição do nível de água ou se você precisa fazer outras medições de distância fora, então este é o sensor que você precisa!

Eu incluí um diagrama de fiação e códigos de exemplo para que você possa começar a experimentar seu sensor.

 

O que este artigo cobre

Informações sobre o sensor

O sensor vem com um cabo de 2,5 m de comprimento que se conecta a uma placa de fuga que controla o sensor e faz todo o processamento do sinal. Note que apenas o sensor e o cabo em si são à prova d’água, se você colocar água na placa de fuga, coisas ruins acontecerão.

Um sensor de distância ultra-sônico funciona enviando ondas de ultra-som. Essas ondas de ultra-som são refletidas de volta por um objeto e o sensor ultrassônico as detecta. Ao cronometrar quanto tempo passou entre enviar e receber as ondas sonoras, você pode calcular a distância entre o sensor e um objeto.

Distância (cm) = Velocidade do som (cm / µs) × Tempo (µs) / 2

Onde Tempo  é o tempo entre enviar e receber as ondas sonoras em microssegundos.

Então, quais são as diferenças entre este sensor e o HC-SR04? A principal diferença, além de ser à prova d’água, é que este sensor usa apenas um transdutor ultrassônico. Este transdutor serve tanto como transmissor quanto receptor das ondas de ultra-som.

Para mais informações sobre como os sensores ultrassônicos funcionam, você pode conferir o artigo no HC-SR04 abaixo. Neste artigo, o princípio de funcionamento é explicado com muito mais detalhes.

JSN-SR04T Especificações

Tensão operacional 5V
Corrente de operação 30mA
Corrente quiescente 5mA
Freqüência 40 kHz
Faixa de medição 25 a 450 cm
Resolução 2 mm
Ângulo de medição 45 a 75 graus
Dimensões do sensor Cabo de 23,5 x 20 mm, 2,5 m de comprimento
Dimensões do PCB 41 x 28,5 mm
Orifício de montagem 18 mm

Para mais informações, você pode conferir a folha de dados aqui.

Componentes

* Nota: os links acima são afiliados, o que significa – sem nenhum custo adicional para você – se você comprar algo usando eles, você está ajudando a apoiar o meu trabalho neste site. Meus humildes agradecimentos (eu realmente agradeço)! 

Ao comprar o sensor, você pode encontrar a versão atualizada,  JSN-SR04T-2.0 . Essa versão mais recente funciona exatamente da mesma forma, mas alguns usuários encontraram problemas ao usar os sensores em uma voltagem mais baixa. Esta versão mais recente está classificada para 3 a 5 V.

Usar um pulso de gatilho mais longo de pelo menos 20 µs em vez de 10 µs parece ajudar se você estiver tendo leituras defeituosas.

Fiação – Conectando o JSN-SR04T ao Arduino UNO

O diagrama de fiação / esquema abaixo mostra como conectar o sensor JSN-SR04T ao Arduino. A placa de desagregação da JSN-SR04T possui a mesma pinagem que a HC-SR04, portanto, pode ser usada como substituta imediata. O cabo do sensor em si pode ser conectado ao conector na parte de trás da placa de fuga.

JSN-SR04T com diagrama de fiação do Arduino

Os exemplos de código abaixo usam os pinos digitais 2 e 3 para o gatilho e o pino de eco, mas é claro que você pode mudar isso para qualquer pino digital desejado.

Conexões JSN-SR04T

JSN-SR04T Arduino
5V 5V
Trig Pino 2
Eco Pino 3
GND GND

Exemplo de código para o JSN-SR04T com Arduino

Agora que você conectou o sensor, é hora de conectar o Arduino ao computador e fazer o upload de algum código. O sensor pode ser usado sem uma biblioteca do Arduino. Mais tarde, mostrarei um exemplo com a biblioteca NewPing, que torna o código muito mais curto.

Você pode fazer o upload do seguinte código de exemplo para o seu Arduino usando o  Arduino IDE . Em seguida, vou explicar como o código funciona. (Este código também funciona para o JSN-SR04T-2.0).

/* JSN-SR04T Ultrasonic Distance Sensor with Arduino Example Code. More info: https://www.makerguides.com */

//Define Trig and Echo pin
#define trigPin 2
#define echoPin 3

//Define variables
long duration;
int distance;

void setup()
{
//Define inputs and outputs
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);

//Begin Serial communication
Serial.begin(9600); // Starts the serial communication at a baudrate of 9600
}

void loop()
{
//Clear the trigPin by setting it LOW
digitalWrite(trigPin, LOW);
delayMicroseconds(5);

//Trigger the sensor by setting the trigPin high for 10 microseconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

//Read the echoPin. pulseIn() returns the duration (length of the pulse) in microseconds.
duration = pulseIn(echoPin, HIGH);
// Calculate the distance
distance= duration*0.034/2;

//Print the distance on the Serial Monitor (Ctrl+Shift+M)
Serial.print("Distance = ");
Serial.print(distance);
Serial.println(" cm");
delay(100);
}

Se houver a necessidade de leitura de mais sensores, isso pode ser feito facilmente com a biblioteca NewPing. Basta criar duas ou mais instâncias da classe NewPing e adicionar um gatilho e um eco adicionais:

#define trigPin 2 
#define echoPin 3 
#define trigPin2 4 
#define echoPin2 5

Sonar NewPing (trigPin, echoPin, MAX_DISTANCE); 
Sonar 2 de NewPing (trigPin2, echoPin2, MAX_DISTANCE);

Agora, se você quiser ler o primeiro sensor, você pode usar o sonar.ping_cm () e o segundo sensor sonar2.ping_cm ().

 

DOWNLOAD DA BIBLIOTECA NEW PING

 

FONTE: https://www.makerguides.com/jsn-sr04t-arduino-tutorial/

 

wiringpi.com

Sobre

WiringPi é uma biblioteca de acesso GPIO baseada em PIN escrita em C para os dispositivos SoC BCM2835, BCM2836 e BCM2837 usados ​​em todos os Raspberry Pi. versões. É lançado sob alicença LGPLv3 da  GNU e é utilizável em C, C ++ e RTB (BASIC), assim como em muitos outros idiomas com invólucros adequados (Veja abaixo). Ele foi projetado para ser familiar a pessoas que usaram osistema de “ fiação ” Arduino 1 e é destinado ao uso por programadores C / C ++ experientes. Não é uma ferramenta de aprendizado de novatos.

O WiringPi é desenvolvido diretamente em um Raspberry Pi executando Raspbian de 32 bits. Eu não suporto nenhuma outra plataforma, compilação cruzada ou sistemas operacionais. Ele foi portado para outras plataformas, outros sistemas operacionais e alguns são cross compiling, no entanto, este autor não mantém esses sistemas. Se você está tentando usar wiringPi em uma plataforma diferente do Raspberry Pi com Raspbian então você deve contatar a pessoa que fez o porto e não eu.

O original Raspberry Pi Modelo A e B versão B1 era um computador de placa única de US $ 35 com um conector GPIO (General Purpose Input / Output) de 26 pinos e isso transporta um conjunto de sinais e barramentos. Existem 8 pinos digitais de E / S para fins gerais – estes podem ser programados como saídas digitais ou entradas. Dois desses pinos (em Pi de 40 pinos, apenas um em Pi de 26 pinos) também podem ser designados para saída PWM de hardware. Além disso, há uma interface I2C de 2 fios e uma interface SPI de 4 fios (com uma segunda linha de seleção, totalizando 5 pinos) e a serial UART com mais 2 pinos.

Ao longo dos anos, houve algumas atualizações:

  • O modelo original B com o conector GPIO de 26 pinos.
  • O modelo B, Revision 1.1 Raspberry Pi tem um adicional de 4 linhas GPIO em um conector separado que você tem que soldar na placa.
  • O modelo A é essencialmente o mesmo que o modelo B v1.1, mas sem o hub USB e o conector ethernet.
  • O modelo A + e B + Raspberry Pi representa 2 anos de pesquisa, desenvolvimento e testes e agora possui um único conector GPIO de 40 pinos com 28 pinos GPIO utilizáveis ​​e 4 soquetes USB. (Sem USB ou Ethernet no A +)
  • O modelo B v2 possui um processador quad-core Arm A7 com 1GB de RAM. O mesmo GPIO.
  • O modelo Zero é um Pi A + reduzido (1GHz). Conector GPIO de 40 pinos e muito pouco mais. $ 5 de preço.
  • O modelo B v3 possui um processador quad-core Arm A8 (64 bits) com a mesma RAM e GPIO do modelo 2, mas também possui Wi-Fi e Bluetooth integrados. Ainda o mesmo preço de US $ 35.
  • O modelo Zero-W adiciona o Wi-Fi on-board, o Bluetooth e o conector da câmera Pi ao modelo existente da placa Zero.

As interfaces I2C, SPI e UART também podem ser usadas como pinos de E / S de finalidade geral quando não estão sendo usados ​​em seus modos de barramento, fornecendo um total de 8 + 2 + 5 + 2 = 17 pinos de E / S no conector P1 ( mais mais 4 no conector P5 em uma Revisão 2 Pi) e 28 pinos de E / S nas placas B + e versões 2 e 3 (embora 2 sejam reservados para a interface HAT I2C, mas podem ser usados ​​como GPIOs normais se não forem usados Placa HAT)

O WiringPi inclui um utilitário de linha de comando gpio que pode ser usado para programar e configurar os pinos do GPIO. Você pode usar isso para ler e escrever os pinos e até usá-lo para controlá-los a partir de scripts de shell.

WiringPi é extensível e módulos são fornecidos para ampliar o cabeamentoPi para usar dispositivos de interface analógica no Gertboard, e usar os populareschips de expansão GPIO MCP23x17 / MCP23x08 (I2C 7 SPI), bem como módulos que permitirão blocos de até 4 × 74 × 595 registros de deslocamento para serem encadeados juntos para um valor adicional de 32 bits de saída como uma única unidade. (Você pode ter vários blocos de 4 74x595s, se necessário) Um dos módulos de extensão permite que você use um ATmega (por exemplo, Arduino ou Gertboard) como mais expansão GPIO também – através da porta serial do Pi.

Além disso, você pode escrever facilmente seus próprios módulos de extensão para integrar seus próprios dispositivos periféricos à fiaçãoPi, conforme necessário.

O WiringPi suporta leitura e escrita analógicas, e embora não exista nenhum hardware analógico nativo em um Pi por padrão, os módulos são fornecidos para suportar os chips analógicos Gertboards e outros dispositivos A / D e D / A podem ser implementados com relativa facilidade.

NOTA:

Faça o download da fiação aqui

Existe uma versão do wiringPi hospedada no Github. Não use esta versão do wiringPi . Ele existe apenas para facilitar a construção dos wrappers Ruby e Python que foram escritos por Gadgetoid. Você também pode encontrar outras versões do wiringPi no github – todas elas foram bifurcadas e alteradas para suportar diferentes plataformas de hardware.

A fiação dev devLib

devLib é um conjunto de rotinas de bibliotecas implementadas usando o wiringPi para facilitar o acesso a alguns periféricos populares. Os dispositivos suportados incluem exibições de LCD de caracteres (com base nos chips Hitachi HD44780U) e gráficos – por exemplo, as exibições comuns de 128 × 64 pixels com o chip de driver genérico 12864H. O chip de clock do DS1302 RTC, sensores baseados nos chips Maxdetect (por exemplo, RHT003), as placas de interface Gertboard e PiFace e assim por diante.

Recursos de WiringPi

PiFace

O WiringPi também suporta totalmente a placa PiFace . Veja esta página para mais detalhes.

Gertboard

O WiringPi suporta totalmente o Gertboard. Veja esta página para mais detalhes.

Outros recursos de fiaçãoPi:

Informações adicionais podem ser encontradas nas páginas do Raspberry Pi Wiki .


1 Arduino é realmente duas coisas; uma é uma plataforma de hardware, o outro software e parte do software é um pacote chamado Fiação . A fiação é o núcleo da entrada e saída para o Arduino, então eu pensei que seria bom replicar essa funcionalidade (ou um bom subconjunto utilizável com as extensões do Raspberry Pi) no Raspberry Pi.

Módulo Ultrassônico JSN-SR04T WAVGAT À Prova D’ Água

Características:

O tamanho pequeno, fácil de usar
Baixa tensão, baixo consumo de energia
Alta precisão
Forte anti-jamming
Integrado com sonda de fio fechado à prova d’ água, adequado para molhado, duras ocasiões de medição

Especificação:

Tensão de funcionamento: DC 5 V
Estática atual de trabalho: 5mA
Corrente de trabalho: 30mA
Freqüência de emissão acústica: 40 KHz
Fiação: + 5 V (positiva); Trig (controle); Echo (receber); GND (cátodo)

Conexão com arduino:
5 V: 5 V Suply
Trig: D12
Echo: D13
GND: GND

Aplicação:

Distância Horizontal messurement
Desvio de obstáculos, controle automático
Controle de tráfego
Segurança, controle industrial

 

 

/* 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
}

Módulo GPS Skylab SKM53

Este módulo opera com 5V e assim que é energizado começa a transmitir coordenadas no pino TXD (mas só serão válidas após o tempo de fix) , repetindo a cada 1s. A baudrate é 9600bps. O pino RXD só tem utilidade se você quiser reconfigurar o módulo, por isso você pode deixá-lo desconectado.

Teste básico

(não requer que o GPS esteja vendo satélites)

No Arduino Mega

Atenção: qualquer exemplo que você pegar na internet que use a biblioteca Newsoftserial poderá não funcionar no Mega. Nesse modelo de arduino, use as portas seriais reais.

Ligue o TXD do GPS no pino RX1 do Mega

Rode o sketch (não é preciso mudar nada) Examples -> Communication -> MultiserialMega

Algo assim deve aparecer no Serial Monitor (repete-se a cada 1s):

$GPRMC,204433.215,V,,,,,0.00,0.00,131013,,,N*48
$GPGGA,204434.215,,,,,0,0,,,M,,M,,*4B
$GPGSA,A,1,,,,,,,,,,,,,,,*1E
$GPGSV,1,1,01,09,,,23*70

 

No Arduino UNO

Instale a biblioteca NewSoftSerial

Ligue o TXD do GPS no pino 2 do Arduino.

Rode o seguinte sketch, ligeiramente adaptado do exemplo TwoPortReceive

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <SoftwareSerial.h>
SoftwareSerial portOne(2,3);
void setup()
{
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}
// Start each software serial port
portOne.begin(9600);
}
void loop()
{
// By default, the last intialized port is listening.
// when you want to listen on a port, explicitly select it:
portOne.listen();
Serial.println("Recebido do GPS:");
// while there is data coming in, read it
// and send to the hardware serial port:
while (portOne.available() &gt; 0) {
char inByte = portOne.read();
Serial.write(inByte);
}
delay(1000);
Serial.println("");
Serial.println("");
}

Algo assim deve aparecer no Serial Monitor (repete-se a cada 1s):

 

Recebido do GPS:
$GPGGA,210946.907,,,,,0,0,,,M,,M,,*4E
$GPGSA,A,1,,,,,,,,,,,,,,

Teste completo

Não faça este teste se sua instalação não tiver passado ainda no teste básico.

Neste teste o GPS precisa ver os satélites. Para isso você precisa estar num local que tenha visão direta para o céu e o lado da antena do GPS precisa estar voltado para cima.

Em um Arduino UNO

Instale a biblioteca TinyGPS (documentação e download da v13). Requer NewsoftSerial.

Conecte o TXD do GPS ao pino 4 do UNO.

Carregue o exemplo Examples -> TinyGPS -> test_with_gps_device

Mude a linha

ss.begin(4800);

para

ss.begin(9600);

Faça o upload do sketch.

Em um Arduino Mega

Instale a biblioteca TinyGPS (documentação e download da v13).

Conecte o TXD do GPS a RX1 do Mega.

Atenção: Os exemplos do TinyGPS usam a biblioteca Newsoftserial, que tem certos problemas para funcionar no Mega. Por isso eu fiz ligeiras modificações no exemplo para usar uma porta serial real do Mega.

Faça o upload do seguinte sketch:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#include <TinyGPS.h>
/* Exemplo test_with_gps_device modificado para usar a porta serial 1
do Arduino Mega.
Jefferson Ryan - Automalabs - 13/10/2013
*/
TinyGPS gps;
static void smartdelay(unsigned long ms);
static void print_float(float val, float invalid, int len, int prec);
static void print_int(unsigned long val, unsigned long invalid, int len);
static void print_date(TinyGPS &gps);
static void print_str(const char *str, int len);
void setup()
{
Serial.begin(115200);
Serial1.begin(9600);
Serial.print("Testing TinyGPS library v. ");
Serial.println(TinyGPS::library_version());
Serial.println("by Mikal Hart");
Serial.println();
Serial.println("Sats HDOP Latitude  Longitude  Fix  Date       Time     Date Alt    Course Speed Card  Distance Course Card  Chars Sentences Checksum");
Serial.println("          (deg)     (deg)      Age                      Age  (m)    --- from GPS ----  ---- to London  ----  RX    RX        Fail");
Serial.println("-------------------------------------------------------------------------------------------------------------------------------------");
}
void loop()
{
float flat, flon;
unsigned long age, date, time, chars = 0;
unsigned short sentences = 0, failed = 0;
static const double LONDON_LAT = 51.508131, LONDON_LON = -0.128002;
print_int(gps.satellites(), TinyGPS::GPS_INVALID_SATELLITES, 5);
print_int(gps.hdop(), TinyGPS::GPS_INVALID_HDOP, 5);
gps.f_get_position(&flat, &flon, &age);
print_float(flat, TinyGPS::GPS_INVALID_F_ANGLE, 10, 6);
print_float(flon, TinyGPS::GPS_INVALID_F_ANGLE, 11, 6);
print_int(age, TinyGPS::GPS_INVALID_AGE, 5);
print_date(gps);
print_float(gps.f_altitude(), TinyGPS::GPS_INVALID_F_ALTITUDE, 7, 2);
print_float(gps.f_course(), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
print_float(gps.f_speed_kmph(), TinyGPS::GPS_INVALID_F_SPEED, 6, 2);
print_str(gps.f_course() == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(gps.f_course()), 6);
print_int(flat == TinyGPS::GPS_INVALID_F_ANGLE ? 0xFFFFFFFF : (unsigned long)TinyGPS::distance_between(flat, flon, LONDON_LAT, LONDON_LON) / 1000, 0xFFFFFFFF, 9);
print_float(flat == TinyGPS::GPS_INVALID_F_ANGLE ? TinyGPS::GPS_INVALID_F_ANGLE : TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
print_str(flat == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON)), 6);
gps.stats(&chars, &sentences, &failed);
print_int(chars, 0xFFFFFFFF, 6);
print_int(sentences, 0xFFFFFFFF, 10);
print_int(failed, 0xFFFFFFFF, 9);
Serial.println();
smartdelay(1000);
}
static void smartdelay(unsigned long ms)
{
unsigned long start = millis();
do
{
while (Serial1.available())
gps.encode(Serial1.read());
} while (millis() - start < ms);
}
static void print_float(float val, float invalid, int len, int prec)
{
if (val == invalid)
{
while (len-- > 1)
Serial.print('*');
Serial.print(' ');
}
else
{
Serial.print(val, prec);
int vi = abs((int)val);
int flen = prec + (val < 0.0 ? 2 : 1); // . and -
flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
for (int i=flen; i<len; ++i)
Serial.print(' ');
}
smartdelay(0);
}
static void print_int(unsigned long val, unsigned long invalid, int len)
{
char sz[32];
if (val == invalid)
strcpy(sz, "*******");
else
sprintf(sz, "%ld", val);
sz[len] = 0;
for (int i=strlen(sz); i<len; ++i)
sz[i] = ' ';
if (len > 0)
sz[len-1] = ' ';
Serial.print(sz);
smartdelay(0);
}
static void print_date(TinyGPS &gps)
{
int year;
byte month, day, hour, minute, second, hundredths;
unsigned long age;
gps.crack_datetime(&year, &month, &day, &hour, &minute, &second, &hundredths, &age);
if (age == TinyGPS::GPS_INVALID_AGE)
Serial.print("********** ******** ");
else
{
char sz[32];
sprintf(sz, "%02d/%02d/%02d %02d:%02d:%02d ",
month, day, year, hour, minute, second);
Serial.print(sz);
}
print_int(age, TinyGPS::GPS_INVALID_AGE, 5);
smartdelay(0);
}
static void print_str(const char *str, int len)
{
int slen = strlen(str);
for (int i=0; i<len; ++i)
Serial.print(i<slen ? str[i] : ' ');
smartdelay(0);
}

 

 

Se seu GPS estiver enxergando os satélites, a saída será parecida com isto (eu dividi em duas partes porque não cabia na tela e alterei as coordenadas por privacidade):

 

Testing TinyGPS library v. 13
by Mikal Hart
Sats HDOP Latitude  Longitude  Fix  Date       Time     Date Alt
          (deg)     (deg)      Age                      Age  (m)
**** **** ********* ********** **** ********** ******** **** ******
9    91   8.022881 34.324093 83   10/13/2013 22:18:40 95   20.00
9    91   8.022881 34.324093 89   10/13/2013 22:18:41 102  20.00
9    91   8.022881 34.324093 101  10/13/2013 22:18:42 113  20.00
9    91   8.022881 34.324093 122  10/13/2013 22:18:43 135  20.00
9    91   8.022881 34.324093 134  10/13/2013 22:18:44 148  20.00
Course Speed Card  Distance Course Card  Chars Sentences Checksum
from GPS   to London    RX    RX        Fail
****** ***** ***   *******  ****** ***   39    0         1
60.25  0.00  ENE   7418     22.79  NNE   502   2         1
60.25  0.00  ENE   7418     22.79  NNE   944   4         1
60.25  0.00  ENE   7418     22.79  NNE   1393  6         1
60.25  0.00  ENE   7418     22.79  NNE   1850  8         1
60.25  0.00  ENE   7418     22.79  NNE   2299  10        1
Se seu GPS não estiver enxergando os satélites, a saída de TinyGPS será parecida com isto (eu dividi em duas partes porque não cabia na tela):
Testing TinyGPS library v. 13
by Mikal Hart
Sats HDOP Latitude  Longitude  Fix  Date       Time     Date Alt
          (deg)     (deg)      Age                      Age  (m)
**** **** ********* ********** **** ********** ******** **** ******
**** **** ********* ********** **** ********** ******** **** ******
**** **** ********* ********** **** ********** ******** **** ******
**** **** ********* ********** **** ********** ******** **** ******
**** **** ********* ********** **** ********** ******** **** ******
Course Speed Card  Distance Course Card  Chars Sentences Checksum
from GPS   to London    RX    RX        Fail
****** ***** ***   *******  ****** ***   0        0         0
****** ***** ***   *******  ****** ***   136    0         0
****** ***** ***   *******  ****** ***   272    0         0
****** ***** ***   *******  ****** ***   408   0         0
****** ***** ***   *******  ****** ***   544   0         0

 

Note que o valor de Chars RX está incrementando em passos fixos (no caso, 136). Isso siginifica que a biblioteca está recebendo dados do GPS, mas não há coordenadas válidas nesses dados. Se Chars RX não estiver incrementando verfique todas as conexões.

Se você realmente precisar reconfigurar esse GPS, o documento MTK NMEA Packet User Manual (link para download no fim do texto) pode ser o que você precisa. Eu não testei, não aconselho seu uso e não dou garantias. Se você mexer nas configurações considere minha garantia finalizada. Estou fornecendo o arquivo apenas para sua conveniência.

 

http://www.automalabs.com.br/download/SkyNav_SKM53_Datasheet.pdf

http://www.automalabs.com.br/download/PMTK_Protocol.pdf

 

Fonte: http://www.automalabs.com.br/modulo-gps-skylab-skm53/#comment-2321

 

Leitor de cédulas para deficientes visuais

Trabalho de conclusão de curso
apresentado à Faculdade de Americana,
como requisito parcial para a obtenção
do título de Bacharel em Engenharia
Elétrica.
Orientador: Professor MSc. Alysson
Fernandes Mazoni

 

 

RESUMO
O objetivo deste trabalho é o desenvolvimento de um leitor de cédulas
de dinheiro para deficientes visuais que fosse prático e utilizasse componentes
de baixo custo. O projeto utiliza o Arduino como microcontrolador e um sensor
de cores para a distinção dos valores das cédulas. No estudo foi possível
identificar que diversos aspectos podem influenciar na identificação das notas,
como por exemplo, a distância que as medições são realizadas e a
luminosidade do ambiente. Assim foi desenvolvida uma padronização para as
medidas e uma calibração para toná-las confiáveis. Através dos resultados
obtidos foi possível comprovar que o leitor de cédulas identifica corretamente
os valores das notas.
Palavras-chave: Deficientes visuais, Leitor de cédulas, Sensor de cores, Arduino.

 

 

Fonte: http://aplicacao.vestibularfam.com.br:881/pergamumweb/vinculos/000002/00000228.pdf

Fonte: http://www.faculdadedeamericana.com.br/revista/index.php/TCC/article/view/167/158

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/

Como usar 5V Relay no Arduino

Arduino é uma placa de prototipagem baseada em microcontroladores que funciona com uma pequena energia DC. Um Relé é um dispositivo que ajuda os microcontroladores (ou placas baseadas em microcontroladores) como o Arduino para ligar ou desligar aparelhos domésticos diferentes, como motores, luzes, aquecedores de água, televisão e ventiladores etc.

Hoje, o Arduino está sendo usado para uma ampla gama de aplicações, como LEDs de controle, temperatura de monitoramento, dados de registro e ativação de motores etc. Outra tarefa importante que pode ser realizada pelo Arduino é controlar um relé de 5V para operar aparelhos e dispositivos de alta tensão AC .

 

A família de microcontroladores Arduino, como UNO, Nano e Mega, etc. pode ser programada para controlar um relé de 5V simples, ou seja, ligue ou desligue no caso de pressionar um botão, lendo o valor da temperatura de um termistor ou apenas configurando um cronômetro predefinido.

 

Neste projeto, veremos um circuito simples onde um Arduino UNO controlará um relé de 5V, que por sua vez será uma lâmpada.

Nota: Utilizamos o Arduino UNO neste projeto, pois é mais popular do que outras placas Arduino e iniciantes em eletrônicos podem usá-lo facilmente. Se você tiver qualquer outro quadro como Arduino Nano ou Arduino Mega, você pode usá-lo sem qualquer incômodo.

Cuidado: Vamos conectar 240V Alimentação de rede (ou 110V dependendo de onde você mora) para o módulo de relé 5V para ligar uma lâmpada. Você deve ser muito cuidadoso e cauteloso ao usar a rede elétrica. Se você tem até a menor dúvida sobre a ligação, não hesite em obter ajuda de um profissional.

Diagrama de circuito

Vejamos o diagrama de circuito para o projeto. Embora tenhamos usado um módulo de retransmissão 5V, as conexões neste diagrama de circuito descreverão a configuração completa.

Usando 5V Relay on Arduino Circuit Diagram

Componentes Necessários 

  • Arduino UNO (ou qualquer outro quadro Arduino)
  • Relé 5V
  • Diodo 1N4007
  • BC547 – Transistor NPN
  • LED vermelho (pode ser usado como LED aceso)
  • LED verde (pode ser usado como um LED de relé ON)
  • 2 x 1K Ohm Resistors (1/4 W – para LEDs vermelhos e verdes)
  • Luminária
  • Fios para conexão de componentes de tensão CC
  • Fios para conexão de rede CA e lâmpada

Descrição do Circuito

Vejamos agora como o circuito foi projetado. A primeira coisa é que usamos um relé de 5V neste projeto. Isso torna mais fácil, pois o Arduino pode ligar o relé diretamente. Se você usou um relé de 12V como usamos neste projeto Arduino Relay Control , você precisa usar uma fonte de alimentação separada para o relé.

Chegando ao design do circuito, é muito simples, pois usamos um módulo de relé de 5V e não os componentes individuais. Embora o diagrama de circuito explique as conexões detalhadas, praticamente não precisamos fazer todas as conexões.

A maioria dos módulos de relé (seja 5V ou 12V) virá com a conexão acima mencionada e, portanto, tudo o que você precisa é fornecer energia ao módulo de relé, ou seja, 5V e GND e conectar o sinal de controle do Arduino ao pino de controle na placa de relé.

Chegando à parte da carga, ou seja, a lâmpada, o fio quente da rede elétrica está conectado a um terminal da lâmpada. Outro terminal da lâmpada está conectado ao contato normalmente aberto (NO) do relé 5V. Finalmente, o fio neutro da rede elétrica está conectado ao contato comum (COMM) do relé.

Um pequeno sensor de luz na forma de LDR (Light Dependent Resistor) é usado para ligar ou desligar a luz automaticamente. A saída do sensor LDR é dada ao pino de entrada analógica A0.

Descrição do Componente

Retransmissão

A vantagem de usar um relé de 5V neste projeto é que a fonte de alimentação para o relé pode ser diretamente fornecida pela própria placa Arduino UNO. Vejamos agora alguns conceitos básicos de um relé. Um relé é um tipo de switch que atua como uma interface entre microcontroladores e AC Loads.

Retransmissão

Um único relé Single Pole – Single Throw (SPST), como o usado neste projeto, consiste em 5 Terminais: 5V, GND, Normalmente Abertos (NO), Normalmente Fechar (NC) e Comum (COMM). Uma vez que precisamos controlar este relé com a ajuda do Arduino, um transistor é usado com um pino adicional chamado Pin de controle no módulo de retransmissão.

Pinos do relé 5VTrabalho do Projeto

Um projeto simples, no qual Arduino UNO controla um relé de 5V, é explicado aqui. O funcionamento do projeto baseia-se no funcionamento do Relé e na capacidade do Arduino para controlar o relé. Vamos discutir o funcionamento do projeto.

Como mencionado anteriormente, ao conectar Arduino com módulo de retransmissão de 5V, pretendemos operar uma carga CA como uma lâmpada. Em vez de usá-lo diretamente, nós criamos uma pequena aplicação onde um LDR é usado para detectar a intensidade da luz e ligar e desligar automaticamente o relé.

Sob condições normais de iluminação, a saída do LDR estará na faixa de 80 – 90 (o intervalo é 0 – 255). Quando as condições de iluminação ficam escuras (pode ser feito cobrindo o LDR com mão), a saída do LDR irá pular para 130 – 140. Essa condição pode ser usada para disparar o Relé 5V e ligar a luz.

Vantagens e desvantagens

Vantagens: a vantagem principal e importante de conectar um relé de 5V com o Arduino é que ele pode ser alimentado pelo próprio Arduino.

Desvantagens : um relé baseado em transistor pode não ser ideal para uso prolongado, pois sempre haverá ruído na bobina do relé. Uma opção adequada será usar isolamento adicional como um opto-isolador ou eliminando completamente o relé eletromecânico e substituindo-o pelo relé de estado sólido.

Aplicações

  • Interfacing a 5V Relay with Arduino abre a porta para uma grande quantidade de aplicações. Embora a principal tarefa do relé seja controlar uma carga, como esse relé está sendo operado pelo Arduino torna um projeto interessante.
  • Algumas das técnicas e métodos com os quais podemos controlar o relé são: Bluetooth, controle de infravermelhos (IR), Transmissor de RF – Par de Receptor ou mesmo usando a Internet.
  • A Arduino Home Automatica requer a combinação de Arduino e muitos módulos de relé (dependendo do número de cargas).

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

 

 

 

Fonte: http://www.electronicshub.org/use-5v-relay-arduino/

Ligação ao Arduino dispositivos de Delphi através de uma porta serial COM simples.

Arduino com Delphi XE8 ~ LiquidCrystal e Temperatura

 

Ligação ao Arduino dispositivos de Delphi através de uma porta serial COM simples.

> Função

  • LED On / Off controle do interruptor
  • Leia Temperatura do sensor
  • Enviar mensagem para LiquidCrystal

Código Completo para Download: Projeto Delphi e Código Arduino.

 

 

 

Fonte: http://c2design5sh.blogspot.com.br/2015/08/iot-arduino-with-delphi-xe8.html

 

 

 

 

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

Sistemas Operacionais de Tempo Real – Timers

Introdução

Estava desenvolvendo algumas idéias para um novo artigo técnico, quando encontrei perdida, no fundo de uma gaveta virtual, uma biblioteca de rotinas em C que desenvolvi há algum tempo. É uma preciosidade!!! Eu mesmo já utilizei essas funções em vários projetos. Estou aqui disponibilizando esse material para você.

Vou contar um pouco a história dessa biblioteca. Houve uma época em que o meu trabalho era focado em projetos de desenvolvimento de sistemas dedicados baseados em processadores da família 8051. Desenvolvemos uma célula de carga digital, um sistema de monitoramento ambiental, um mini CLP, um sistema de monitoramento e controle de um processo químico, sistema de controle de elevadores etc. Daí surgiu a ideia de elaborar funções e rotinas padronizadas, pois quase todos esses sistemas tinham alguma coisa em comum, como por exemplo teclas, displays etc. e deveriam operar em tempo real. O objetivo foi diminuir o tempo gasto para o desenvolvimento de um novo projeto. Antes de prosseguir, recomendo a leitura do artigo Sistemas Operacionais de Tempo Real – Introdução, onde são abordados alguns conceitos que serão aplicados neste artigo.

É necessário apresentar aqui alguns esclarecimentos a respeito da filosofia usada na elaboração dessas rotinas. Eu parti do princípio de que os nossos sistemas são de tempo real e que realizam periodicamente algumas funções rotineiras, tais como verificar um teclado, atualizar displays, administrar LEDs de sinalização, realizar medidas, etc. Outras ações são tomadas por demanda, ou seja, apenas quando ocorrem. Essas demandas podem ser periódicas ou assíncronas (aleatórias). Daí já reconhecemos o primeiro elemento a ser implementado no nosso Sistema Operacional: um temporizador (Timer). Para quem não sabe, os processadores tradicionais da família 8051 têm apenas 2 temporizadores, enquanto outras versões oferecem pelo menos mais um. Antes de continuar, acho interessante recordarmos a arquitetura dos microcontroladores da família MCS-51 e os modos de operação dos seus temporizadores. Na parte final desse artigo será desenvolvido um pequeno exemplo prático, cujo código poderá ser compilado e simulado.

TIMERS da família MCS-51

Para ilustrar o que será abordado aqui, vamos nos referenciar aos microcontroladores de fabricação da ATMEL, com a arquitetura baseada no 8051, cujo documento completo você pode consultar aqui: ATMEL 8051 Microcontrollers Hardware Manual. Na Figura 1 podemos observar a arquitetura interna de um microcontrolador AT89S8253, que continua sendo produzido, mostrando em destaque o bloco dos temporizadores.

Timers - Diagrama em blocos da arquitetura interna de um microcontrolador
Figura 1: Diagrama em blocos da arquitetura interna de um microcontrolador AT89S8253

 

Sem entrar nos detalhes referentes aos contadores / temporizadores Timer 0 e Timer 1 dessa família de microcontroladores, basta dizer que eles podem ser programados para funcionarem em 4 modos distintos de operação:

  • Modo 0: O temporizador é configurado como um contador de 13 bits, que pode receber um valor inicial e conta para cima. Na transição do valor limite superior 0x1FFF para  0x0000, é acionado um flag de sinalização;
  • Modo 1: Similar ao modo 0, porém é configurado o contador para 16 bits;
  • Modo 2: O temporizador é configurado como um contador de 8 bits, com um registro de 8 bits associado para recarregar o valor inicial automaticamente. Na transição, é acionado um flag;
  • Modo 3: Nesse modo de operação, o Timer 0 opera como 2 contadores distintos de 8 bits, enquanto o Timer 1 nesse modo de operação permite que se congele a contagem.

Convenções para o uso dos Timers

Para o objetivo de projetar uma biblioteca com rotinas padronizadas, foi definido que o Timer 0 seria o temporizador padrão do sistema e o Timer 1 também poderia ser usado para isso, se acaso não fosse necessário usá-lo para gerar baud-rate da comunicação serial.

O período de interrupção do temporizador deve ser o maior possível e baixo o suficiente para atender às necessidades prioritárias do sistema. Para que se entenda o motivo disso, observe o seguinte exemplo:

Suponhamos que:

  • Um microcontrolador que, por restrições de sua arquitetura e do oscilador (clock) utilizado, possa executar no máximo 10.000 instruções por segundo;
  • Uma rotina de interrupção provocada pelo temporizador execute 20 instruções na média a cada interrupção.

Se numa hipótese absurda o temporizador for dimensionado para gerar 500 interrupções por segundo, a rotina de interrupção vai consumir todo o tempo disponível para executar as instruções do microcontrolador (500 x 20 = 10.000)! Se por exemplo esse número puder cair para 50 interrupções por segundo, sem prejudicar a operação do sistema, a rotina de interrupção vai consumir apenas 10% do total disponível (1.000), deixando os outros 90% para as demais atividades do microprocessador.

A compreensão do que foi ilustrado nesse exemplo é fundamental. As rotinas que são executadas com maior frequência devem ser otimizadas para serem executadas no menor tempo possível e na menor frequência possível também. Voltando ao exemplo das 500 interrupções, se acaso a rotina de interrupção executasse apenas 18 instruções ao invés das 20, já sobrariam 1.000 instruções por segundo que poderiam ser executadas por outras atividades. Em muitos casos isso é suficiente. Note que para esse exemplo em particular, só analisamos uma das soluções possíveis para viabilizar a operação do sistema. Poderia-se também lançar mão de outros recursos, como por exemplo aumentar a frequência do oscilador do microcontrolador.

Assim a frequência da interrupção do nosso timer deve ser dimensionada de modo que:

  • A função que deverá ser executada com maior frequência possa ser atendida pelas interrupções do timer no menor tempo necessário para isso (e maior possível), definindo assim as especificações do timer de referência do sistema;
  • Outras temporizações mais lentas sejam realizadas como múltiplos da interrupção do timer e implementadas por meio de temporizadores virtuais de software.

Um temporizador virtual de software é uma estrutura no programa em que a cada temporizador é associado um valor inicial, que se traduz num número inteiro de interrupções do Timer 0, e um flag de sinalização. A cada interrupção do Timer 0, o temporizador de software é decrementado e testado se zero. Se for zero, é ligado o flag para avisar que a contagem de software foi terminada e o temporizador é reinicializado para o seu valor inicial. O tratamento do final de contagem é realizado no programa principal, testando-se o flag e reinicializando-o depois.

O timer de referência deverá funcionar no modo 2 de operação. Observe que a programação do Timer 0 depende da frequência de clock do microcontrolador, do fator de divisão do clock, que nas CPUs tradicionais do MCS-51 é de 12 vezes, e da frequência requerida de interrupção. Um último limitante é que o valor inicial do Timer nessa configuração é de no máximo 255 (8 bits). Na biblioteca também foi desenvolvido um padrão para a programação do Timer 1, especialmente se não for usado para gerar baud-rate.

Detalhes da Biblioteca em C

O código em C a seguir foi desenvolvido para o compilador KEIL C51 μVision, na versão de avaliação. Se você quiser testar o programa exemplo que desenvolveremos no final deste artigo, recomendo que você baixe e instale esse programa.  O arquivo de biblioteca com os trechos de código em C para a utilização dos timers de forma padronizada está dividido em segmentos. O primeiro segmento define uma série de constantes, que podem ser ajustadas conforme as especificações do projeto. Veja o trecho do código a seguir.

Nesse código há alguns parâmetros que precisam ser alterados, conforme o projeto:

  • #define   FREQUENCIA_DO_CLOCK_DA_CPU 12.0e+6 // Hz —->  12 MHz, por exemplo.

Inicializar essa constante com o valor do clock do seu microcontrolador.

  • #define   FATOR_DE_ESCALA_CLOCK_TIMER    12.0f     // Divide o clock por 12

Valor do pre-scaler.

  • #define   FREQUENCIA_DE_INTERRUPCAO_TIMER_0 5e+3  // Hz —- > 5 kHz, por exemplo.

Define a frequência da interrupção do timer.

São apenas esses três parâmetros que devem ser inicializados. Não é necessário alterar outras partes do código!

O segundo segmento da biblioteca refere-se às inicializações dos timers, conforme o modo de operação, e os comandos para iniciar a operação do temporizador. Observe que nesse segmento é mostrada a rotina principal (void main(void)) e indicado onde devem ser inseridos os trechos do código.

O terceiro segmento mostra como são definidas as rotinas de interrupção.

EXEMPLO

A seguir vamos desenvolver o nosso programa de exemplo. Nesse programa, será programado o Timer 0 no modo 2 de operação, com o microcontrolador operando com um clock de 4 MHz e uma frequência de interrupção de 1,5 kHz. Confira o código no quadro abaixo.

Se você quiser simular o programa exemplo acima e explorá-lo um pouco mais, siga os seguintes passos:

  • Instale o KEIL C51 μVision;
  • Baixe o arquivo Testa_Timer.zip;
  • Instale os arquivos de Testa_Timer.zip num diretório para testes;
  • Navegue até o diretório de testes e acione o arquivo Testa_Timer.uvproj (2 “clickes”)  (Figura 2).

Timers - Arquivos no diretório de teste
Figura 2: Arquivos no diretório de teste

Nesse instante deverá abrir o programa Keil e a tela deverá ser a retratada na Figura 3. Esse painel permite navegar no código em C, editá-lo e compilá-lo. Não é necessário fazer isso para realizar a simulação, mas você poderá posteriormente alterar alguns parâmetros do código e testar o programa com as novas alterações.

Timers - Programa Keil pronto com o programa exemplo carregado
Figura 3: Programa Keil pronto com o programa exemplo carregado

A seguir coloque o programa no modo de Debug (Figura 4, Figura 5 e Figura 6) para que se possa iniciar a simulação.

timers - Selecionando o modo Debug do programa
Figura 4: Selecionando o modo Debug do programa

Antes de entrar no modo de depuração, aparece na tela a mensagem da Figura 4. “Clicke” no  “OK” para continuar.

Timers - Aviso de que no modo de avaliação, o código fica limitado a 2K
Figura 5: Aviso de que no modo de avaliação, o código fica limitado a 2K

timers - Modo Debug de operação
Figura 6: Modo Debug de operação

 

Observe que já estão destacados os painéis de monitoramento do Timer 0 e do Port 3, cujo bit 1 deverá ser alternado a cada término de contagem do temporizador de software. As duas variáveis principais (bFlagTimerDeSoftware e nTimerDeSoftware) poderão ser monitoradas na janela Watch 1 durante a simulação.

É possível utilizar as teclas de função F11 para executar o programa passo a passo ou F5 entrar em execução. Recomendo que você inicie a simulação utilizando o passo  a passo para poder observar detalhadamente como que funciona o mecanismo de operação desse programa.

Resumo

Neste artigo técnico foram apresentados alguns conceitos relativos à utilização de temporizadores de hardware de um microcontrolador associados a temporizadores de software para a implementação de arquiteturas de software típicas de  sistemas operacionais de tempo real. Também foi apresentada e explicada uma biblioteca padronizada para a utilização dos timers de microcontroladores da família MCS-51, codificada em C, para ser compilada no programa da Keil. Depois foi desenvolvido um programa exemplo para que você possa simular o que foi apresentado e observar os detalhes dessa implementação.

Este artigo é o segundo da série de artigos que abordam algumas funções comuns em projetos de sistemas embarcados de tempo real. Confira os demais artigos (em breve).

Sistemas Operacionais de Tempo Real

Bibliotecas de funções e rotinas padronizadas em linguagem C para MCS-51

  • Timers (este artigo) – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso dos Timers do MCS-51;
  • Displays de 7 segmentos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso em displays de 7 segmentos;
  • Teclados Matriciais – É apresentada uma biblioteca desenvolvida em linguagem C para varredura, leitura, debounce, identificação da tecla acionada e desvio para a rotina de tratamento. A forma como as rotinas foram escritas, permitem sua fácil reutilização em outros projetos;
  • Periféricos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso de alguns periféricos, tais como conversores A/D, sensor de temperatura e memórias seriais.

Fonte: https://www.embarcados.com.br/rtos-timers/

Curso de programação em Arduíno para automação -EMENTA

Já pensou em projetar a sua própria casa do futuro, desenvolver um braço robótico ou sistemas de automação para as mais diversas aplicações, sejam elas industriais, residenciais, ou por diversão ? Controlar a iluminação e ventilação de seu quarto usando seu smartphone ! Nós como fãs do software livre não poderíamos deixar de ministrar um curso de programação para Hardware Livre utilizando a plataforma de prototipagem eletrônica Arduíno.

Para realizar este curso são necessários alguns pré-requisitos como ter noções de lógica de programação e conhecimentos básicos de HTML , ter noções de eletrônica.

Tópicos abordados neste treinamento :

  • Introdução
  • Conhecendo a plataforma Arduíno.
  • Base da programação em Arduíno.
  • Estrutura de comentários.
  • Funções base.
  • Pinmode.
  • Entrada e saída de dados 1
  • Portas digitais.
  • Portas Analógicas.
  • Tempo.
  • Bibliotecas.
  • #INCLUDE.
  • #DEFINE.
  • Variáveis.
  • Classe de variáveis.
  • Tipos de dados e modificadores.
  • Funções.
  • Operadores de comparação.
  • Operadores booleanos.
  • Operadores de incremento e decremento.
  • Estruturas de controle de fluxo.
  • Comandos If, Else, For.
  • Comandos Switch Case, While, Do While.
  • Comunicação serial.
  • Operadores matemáticos.
  • Trigonometria.
  • Entrada e saída de dados 2
  • Sinais PWN.
  • PulseIn  – pino, valor, tempo de resposta.
  • Shields para Arduíno e seu uso.
  • Sensores para Arduíno e seu uso.
  • Projetos em Arduíno.
  • Comandando um motor de passo.
  • Programação Ponte H
  • Conectando e configurando display lcd .
  • Projeto de Automação Residêncial.

A carga horária total deste curso é de 40 horas.

FONTE: http://www.linuxforce.com.br/curso-de-arduino-para-automacao/

Do Paper Circuit à programação de Arduino com Scratch: uma sequência didática para aprendizagem do conteúdo de energia nos anos iniciais do Ensino Fundamental

Some content on this page was disabled on December 22, 2017 as a result of a DMCA takedown notice from Elaine Silva Rocha Sobreira. You can learn more about the DMCA here:

https://en.support.wordpress.com/copyright-and-the-dmca/

Programação, Robótica e Música Para Baixinhos

Exemplo de ensino da programação e robótica em sala de aula. Evidentemente que o primeiro protótipo lhe dará um trabalhão para fazer, porém depois de pronto, você possui matéria para meio ano letivo, nesse pequeno e encantador brinquedinho Cover. A didática fica por sua conta. Quem tiver o interesse em desenvolver esse projeto com Raspberry PI + Arduino Mega + Arduino Nano, estamos aí…

Não esqueça, o Youtube é uma rede Social.

CONTROLANDO ARDUINO COM APLICAÇÕES EM DELPHI

Uma dica para quem quiser obter comunicação entre arduino e o delphi, para desenvolver interfaces que possibilita controlar o arduino através dodelphi, desenvolver aplicações para projetos de automação e outros projetos. Para conseguir esta comunicação com o delphi será necessário ainstalação do componente TComPort, pois é este componente que lhe dará todo suporte para que você consiga obter a comunicação quanto ao envioe o recebimento de dados com arduino.Para instalar o componente TComPort, é preciso fazer o download do componente no LINK: http://www.cuin.com.br/wp-content/uploads/2013/05/COMPONENTE.rar 
Instalando o componente utilizarei a versão Delphi 7:1º Passo:
Depois de baixar o componente, salve ele em uma pasta de preferencia a pasta que você utiliza pra salvar outros componentes.
2º Passo:
 Abra o delphi é necessário encerrar as aplicações abertas para isto clique em FILE e clique em CLOSE ALL

Projeto Valkyrie

Você pode usá-lo para automação residencial, bem como controlar dispositivos como braço robo, robôs etc. Valkyrie está ligado à IOT usando Wi-Fi, BLE, Bluetooth clássico, UHF RF Transceiver e XBee, usando o protocolo universal chamado V-API. Este é Valkyrie o caminho futuro do gesto e voz controle.

Características do projeto Valkyrie:

  • processamento de movimento em tempo real inovadora
  • serviço de controle de voz
  • detecção de controle por gestos inteligentes
  • aplicações para smartphones
  • funcionalidade de Bem-Estar
  • API aberta para desenvolvedores
  • Várias interfaces de comunicação

Luva: Projeto Valkyrie é destinado a completar o desafio “SpaceGlove”. Para os 2 dias que trabalharam nesse projeto nós fizemos uma luva de couro e material elástico que é confortável para o uso diário e trabalha cerca de 70 horas em modo de transmissão de energia integral.

Com essa luva, fizemos experiências para controlar muitos dos dispositivos domésticos padrão (lâmpadas, luzes, aquecedor de fã, tiras de luz LED, TV, caixa de configuração) com gestos baseados tais como slide, de cima para baixo, para baixo-up etc Depois que fizemos um serviço que está transmitindo dados a partir da luva a um iPhone, e nós temos modificado a base de dados gesto, e acrescentou gestos personalizados. Com precisão de 10% que têm distinguido com sucesso 16 gestos diferentes e adicionou suporte para mais de 60.

Centro de controle: . Para controlar muitas interfaces precisamos de um centro de controle que está repetindo sinais recebidos a partir de qualquer das interfaces de comunicação e enviá-lo para as outras interfaces
As seguintes interfaces são suportados:

  • Wi-fi
  • Bluetooth Low Energy
  • Classi Bluetooth
  • XBee (ZigBee)
  • 433 MHz transceptor de rádio, e
  • comunicação USB

 Nós integramos muitas bibliotecas e de comunicação único e universal e implementou-lo em um V-API (Valkyrie API). A ideia na V-API é que é pode ser usado com qualquer tipo de dispositivos e usando o protocolo universal você pode facilmente escrever os códigos para a comunicação. O V-API é explicado em detalhes no slide 17 da documentação de hardware e firmware incluídos nos recursos.

Luva das posições dos sensores e descrições:

AccGyro

force-sensor graphic

heart-rate-sensor

As aplicações móveis: Nós desenvolvemos 2 aplicações de interface com o centro de comando (e a luva) – uma para Android e um para iOS. O aplicativo Android usa apenas o serviço de detecção de voz usando o google agora pesquisar e se o comando é reconhecido que envia a solicitação HTTP POST para o nosso serviço on-line (imp elétrica). O serviço Android está trabalhando no telefone, bem como no relógio Android. O aplicativo iOS suporta serviço feito sob encomenda Reconhecimento de voz, controle de automação residencial usando a voz ou entrada directa na aplicação, e informações da estação meteorológica. O nosso serviço de bem-estar está verificando a sua frequência cardíaca automaticamente a cada 30 minutos ou continuamente enquanto você está treinando. Ele também pode contar seus passos e detectar sua qualidade de sono. O aplicativo também pode ser usado para upload de novo firmware para a luva e para criar mais gestos de ser reconhecidos pela luva e ligá-los para executar uma variedade de ações.

iPhoneScreens

No momento, temos uma luva totalmente funcional, a aplicação iOS com todas as propriedades que precisamos, controles remotos para computadores (luva agindo como dispositivo HID), controle de telefone embora o serviço HID BLE, controle de casa inteligente com os hábitos e gestos já implementadas, controle robo braço, controle de jogo de computador, controle rover / carro gesto, controle remoto da TV inteligente e muitos mais por causa do protocolo V-API universal que pode ser usado em muitos lugares.

Q & A:

  • Não há gravidade no espaço aberto – podemos usar um transmissor magnético para determinar o ponto “zero” no espaço e usá-lo para calibrar e sentir a gravidade pseudo e velocidade angular.

  • É difícil usar a maioria dos dispositivos de comunicação GHz no espaço – É por isso que nós temos transceptores de 433 MHz  no Centro de Controle. As bandas de VHF e UHF são capazes de penetrar na atmosfera terrestre e transmitir a comunicação de baixo ruído da terra para o espaço. Isto é usado pelos radioamadores para fazer QSOs utilizando as estações espaciais internacionais como repetidor.

  • velocidade de dados de baixo se o dispositivo controlado é muito longe da terra – não há muito que possamos fazer sobre isso, então decidimos fazer macros personalizadas (por exemplo, se você está controlando braço robótico), você faz o movimento uma vez com a mão então este é enviado para o braço robótico, que memoriza o movimento e fazê-lo pelo comando. Por exemplo no vídeo temos usado este sistema para agarrar a caixa e movê-lo algumas polegadas atrás.
  • Conexão cai enquanto controla algo – Se não há nenhuma conexão para 300 ms, a operação pára até que a ligação não for retomada.
  • Carregar – estamos considerando o carregamento sem fio, porque com as novas tecnologias no carregamento sem fio é possível cobrar 800 mAh por menos de 40 min.
  • Consumo de energia – é 13 – 15 mA no modo de transmissão.
  • você pode usar dispositivos externos (como celulares com Android, Bluetooth Joystic) para controlar dispositivos periféricos Control Center – Sim, pode-V API é um protocolo universal para comunicação, todos os relatórios recebidos são repetidos para as outras interfaces de comunicação.

Imagens da luva feita durante os 2 dias do desafio Apps Space: sistema de sensor de pressão real.

IMG_2025_photoshop

 

Desenvolvimento futuro

  • Para tornar totalmente funcional Aplicativo para Android
  • Para adicionar mais sensores para a estação de controle
  • Para melhorar e tornar as bibliotecas V-API claramente legíveis para C, C ++, C #, Java, Java Script, Objective C
  • A cooperar com muitas universidades e outras instituições de ciência em todo o worlд
  • Para tornar a placa de circuito impresso flexível para a luva
  • Para desenvolver personalizados Bluetooth Serviços de Energia baixa para ser fácil de usar por desenvolvedores Android / iOS
  • Para adicionar mais documentação e estabelecer centro de suporte para suportar os desenvolvedores usando o nosso V-API
  • Para fazer algumas variações a luva por exemplo, negócios, esporte, casual e fazer o hardware para ser fácil mutável
  • Testes oficiais
  • Lançamento do projeto (Se começarmos em 2015/06/01 até o final de setembro ’15 teremos um produto)

 

https://open.nasa.gov/innovation-space/valkyrie/

O ESP8266+Arduino Mega como WebServer

Depois de testar o modulo com vários comandos AT (vale a pena dar uma sapeada no arquivo anexo, bem legal!), parti para fazer o modulo funcionar como Web Server. Partido que tinha aprendido, principalmante com um tutorial do blog FILIPEFLOP:

http://blog.filipeflop.com/wireless/esp8266-arduino-tutorial.html

O Circuito:

 

Webservercircuit

 

O código:

/*************************************************************************

* Web Server with ESP8266

* Based on: FILIPEFLOP http://blog.filipeflop.com/wireless/esp8266-arduino-tutorial.html

* Adapted by Marcelo Jose Rovai

**************************************************************************/

#define esp8266 Serial2

#define CH_PD 4

#define speed8266 115200 // This is the speed that worked with my ESP8266

#define DEBUG true

void setup()

{

  esp8266.begin (speed8266);

  Serial.begin(9600);

  reset8266(); // Pin CH_PD needs a reset before start communication

  sendData(“AT+RST\r\n”, 2000, DEBUG); // reset

  sendData(“AT+CWJAP=\”ROVAI TIMECAP\”,\”mjr747@1\”\r\n”, 2000, DEBUG); //Connect network

  delay(3000);

  sendData(“AT+CWMODE=1\r\n”, 1000, DEBUG);

  sendData(“AT+CIFSR\r\n”, 1000, DEBUG); // Show IP Adress

  sendData(“AT+CIPMUX=1\r\n”, 1000, DEBUG); // Multiple conexions

  sendData(“AT+CIPSERVER=1,80\r\n”, 1000, DEBUG); // start comm port 80

}

void loop()

{

  if (esp8266.available()) // check if 8266 is sending data

  {

    if (esp8266.find(“+IPD,”))

    {

      delay(300);

      int connectionId = esp8266.read() – 48;

      String webpage = “<head><meta http-equiv=””refresh”” content=””3″”>”;

      webpage += “</head><h1><u>MJRoBot ==> WebServer (ESP8266) </u></h1><h2>Arduino Pin: “;

      webpage += “D8 status ==> “;

      int a = digitalRead(8);

      webpage += a;

      webpage += “<h2>Arduino Pin: D9 status ==> “;

      int b = digitalRead(9);

      webpage += b;

      webpage += “<h2>Arduino Pin: A0 data ===> “;

      int c = analogRead(0);

      webpage += c;

      webpage += “</h2>”;

      String cipSend = “AT+CIPSEND=”;

      cipSend += connectionId;

      cipSend += “,”;

      cipSend += webpage.length();

      cipSend += “\r\n”;

      sendData(cipSend, 1000, DEBUG);

      sendData(webpage, 1000, DEBUG);

      String closeCommand = “AT+CIPCLOSE=”;

      closeCommand += connectionId; // append connection id

      closeCommand += “\r\n”;

      sendData(closeCommand, 3000, DEBUG);

    }

  }

}

/*************************************************/

 // Send AT commands to module

String sendData(String command, const int timeout, boolean debug)

{

  String response = “”;

  esp8266.print(command);

  long int time = millis();

  while ( (time + timeout) > millis())

  {

    while (esp8266.available())

    {

      // The esp has data so display its output to the serial window

      char c = esp8266.read(); // read the next character.

      response += c;

    }

  }

  if (debug)

  {

    Serial.print(response);

  }

  return response;

}

/*************************************************/

// Reset funtion to accept communication

void reset8266 ()

{

  pinMode(CH_PD, OUTPUT);

  digitalWrite(CH_PD, LOW);

  delay(300);

  digitalWrite(CH_PD, HIGH);

}

A web Page:

Note que o endereço da pagina é o segundo IP que aparece no Serial monitor com o comando AT+CIFSR na fase de Set-up (veja a copia do Serial monitor abaixo): 

+CIFSR:STAIP,”10.0.1.2″

Webserverpage

A saída no Serial Monitor:

1. A conexão com o modulo esp8266

 

SerialConxion

2. A comunicação:

SerialOngoingcomm

Eu fiz um pequeno vídeo para dar uma visão do WebServer funcionando:

ESP8266 como webserver

Documento legal com dicas de comandos AT para configurar o esp8266:

ESP8266_WiFi_Module_Quick_Start_Guide_v_1.0.4.pdf

Fonte:  http://labdegaragem.com/profiles/blogs/o-esp8266-como-webserver-usando-o-mega?xg_source=msg_mes_network