Resultados da busca - %E3%80%90%E2%94%8B%E5%A5%BD%E8%AE%A1%E5%88%922%E2%92%8F7%E2%92%8F01705%7B%E6%89%A3%E3%80%93%E3%80%91%E5%8D%8E%E5%AE%87%E5%A8%B1%E4%B9%90%E5%A5%96%E9%87%91%E6%98%AF%E5%A4%9A%E5%B0%91
duino (Atmega328), porém como a funcionalidade delas parece genérica (ou seja, vc pode conectar a uma infinidade de fontes de sinais diferentes), e portanto podem conter "spikes" originários de outros equipamentos externos ao seu circuito, estarei provendo uma proteção também genérica. Essa proteção genérica é bem efetiva, mas claro não é "indestrutível", e dependendo do que vc ligue ali (por exemplo um sinal que tenha energia bem alta, e não estou falando de tensão, e sim de energia!!!), pode ser necessário uma proteção mais "reforçada", usando opto-acopladores por exemplo).
Assim, segue a sugestão de proteção na figura a seguir (clique na figura para "zoom"):
Note que seu circuito original do "SCT-013", está na região "amarelo claro" da figura, e veja que mantive as referências dos componentes exatamente como estava no seu circuito original (R21, R22, etc).
Na região "azul claro", está o circuito de proteção para "A3", contra eventuais sinais danosos vindos do sensor SCT (que podem ocorrer se vc "abrir" o sensor, ou se ocorrer um distúrbio na rede elétrica induzindo um "spike" muito alto no secundário do sensor).
Observe que vc pode eliminar "R102" e "R103". Neste caso, "R102" seria substituído por um "curto", e "R103" não seria montado. Mas acho de bom senso vc manter os dois, pois dará flexibilidade maior ao seu sistema (além de prover um loop fechado para o circuito de polarização do sensor).
Já na região "rosa claro", está o circuito de proteção para uma entrada digital. Observe que é bem parecido com o anterior, e o que mudam são os valores dos resistores, que agora são adequados para sinais digitais.
Sobre esse circuito para a entrada digital, você não deve montar "R203" se estiver usando a configuração "INPUT_PULLUP" para a entrada. Só monte "R203" se vc estiver usando a configuração "INPUT" apenas.
Já "R202" pode ser eliminado (substituído por um "curto"), mas ele provém uma proteção adicional para a entrada, então se vc o manter será mais eficiente a proteção.
Veja que no circuito que publiquei acima, desenhei o circuito de proteção para apenas uma entrada digital. Mas cada entrada deve ter seu próprio circuito individual.
No geral: preste atenção aos valores dos componentes que coloquei nos circuitos de proteção (se tiver alguma dúvida sobre os valores, pergunte). Para "R101" e "R201", se possível use resistores de 1/4 W (250 mW). Já os demais resistores podem ser de 1/8 W ou menor ainda.
Uma sugestão adicional: vi que vc está usando o 74HC595. Se for possível, use o 74HC594, que possui a mesma pinagem do "595". A diferença, é que vc pode prover um circuito de "PUC" (Power Up Clear). Isso vai impedir que seus Relés acionem acidentalmente quando vc ligar a alimentação do Sistema. A única diferença na pinagem entre o "594" e o "595", é o pino "13", que no "595" tem a função "OE#", enquanto no "594" tem a função "RCLR#" (também chamado de "PCLR#"). Este circuito é mostrado a seguir:
Observe que se vc tiver vários "594", precisa ter apenas um circuito "PUC" para todos eles, conectando a saída do "PUC" ao pino "13" de todos os "594".
Caso queira comparar, seguem os circuitos lógicos do "594" e "595" (veja que marquei a diferença dos sinais do pino "13"):
Infelizmente, o pessoal por aí afora viciou no "595", e usa o mesmo em circuitos onde o "594" é uma opção melhor (devido ao "PUC"). O que ocorre é que o "595" foi projetado para aplicações de barramento "tri-state", o que não é o caso de 99,9% dos casos que tenho visto por aí em tudo que é lugar. Vai ser difícil aprenderem sobre isso.
Espero ter ajudado.
Abrçs,
Elcids
…
Adicionado por Elcids Chagas ao 21:14 em 4 fevereiro 2019
rir o valor dos resistores, procurei a imagem no Google, e encontrei o site onde a mesma foi postado (infelizmente vc não disse onde). Lá havia uma lista de componentes, e o link para o datasheet (que anexei ao final do post). Os valores dos componentes listados no site, são razoáveis e corretos para esse sensor. Usa um capacitor eletrolítico de alumínio, mas isso não é problema, já que a frequência é a da rede elétrica (60Hz), o que garante que o eletrolítico de alumínio funcione corretamente. Mas vc pode melhorar isso, se colocar um capacitor cerâmico entre 100kpF e 1uF, ligado em paralelo com o eletrolítico.
Dito isto, há duas observações principais sobre seu circuito:
1) os dois resistores que vc desenhou, estão com o valor inadequado de 100 kohm. No site "original" são de 10 kohm. Estes dois resistores são usados para criar um "GND Virtual" de 2,5V, que funciona como um "bias" para a escala analógica do Conversor A/D do Arduino (na figura original está conectado à entrada analógica "A1"). Para isso, os dois resistores devem ter o mesmo valor. Logo mesmo com os 100 kohm que vc desenhou, acaba funcionando, mas não é a melhor solução em termos de estabilidade (pois a impedância equivalente é alta). Já com os resistores originais do site, 10 kohm, a estabilidade é 10 vezes maior, pois a impedância equivalente é 10 vezes mais baixa. Então aconselho usar 10 kohm.
2) a conexão ao "P2" segundo o datasheet do sensor, é mostrada na figura a seguir (retirei do datasheet e colori para ficar fácil referenciar):
Observe que a saída de sinal é entre a ponta do P2 que no seu desenho é o "Left", e o "terra" que no seu desenho tem três designações "Ground"/"SLEEVE"/"TERRA". Então segundo estas informações, a conexão que vc fez está correta.
Mas mais uma coisa importante: a saída de sinal resultante, tem um "spam" de cerca de 1V. Ou seja, para a variação total de 100A, a faixa de conversão do A/D do Arduino será de 1V. Não olhei o código do programa que vc deve ter obtido do site, mas certamento está fazendo a conversão correta do canal analógico. Como para o canal analógico o "zero" é o 2,5V, e como o "spam" é de cerca de 1V, a variação irá de 2V a 3V, para a faixa de 100A.
O "spam" calculei assim: no datasheet, o fundo de escala indicado na saída do sensor, é de 33mA, conforme a figura a seguir:
Logo, como o resistor de carga que está sendo usado é de 33 ohm, a variação de tensão (o "spam"), será: 33ohm x 33mA = 1,089 Volts. Ou seja, cerca de 1V.
Portanto, para dobrar a resolução (e portanto a "qualidade" da medição), vc pode mudar o resistor para 68 ohm, dobrando assim o spam para cerca de 2,2V. Claro que se fizer isso, deve reajustar os cálculos feitos no código do Arduino. Segundo o datasheet, há diodos de proteção dentro do sensor, e estes poderiam limitar o "spam", mas acredito que a tensão de condução destes diodos sejam bem mais acima desses 2,2V resultantes, e não ocorreria esta limitação.
Dica importante: leia com atenção a observação no final do datasheet sobre o uso do sensor, a qual mostro na figura a seguir, pois isso é importante para não "fritar" seu Arduino (pois nenhuma proteção mais rigorosa está sendo feita), e pra não ter risco de choques elétricos perigosos na saída do sensor (cuidado a ser tomado com qualquer sensor deste tipo).
Espero ter ajudado. Fique à vontade para quaisquer dúvidas que eu possa esclarecer.
Abrçs,
Elcids
datasheet do sensor: SCT-013-datasheet.pdf…
Adicionado por Elcids Chagas ao 18:41 em 31 janeiro 2019
ondutividade, o que tens é justamente isso, um sensor de condutividade do solo, e não de umidade.
O parâmetro de acionamento teria que ser na base do setpoint mesmo, que não é muito, digamos, cientifico.
Eu trabalharia com um HS-HR31 ou um HS-1101. O problema é que fora feitos pra trabalhar no máximo 95% de umidade, não sei como se comportariam no solo encharcado. Ai tem que estudar um encapsulamento que permita uma leitura direta.
---edit---
Sensor ideal encontrado:
"
Dew sensor---------------Model: HDS05
High quality & precision!
HDS05 the dew sensor is a kind of switching-mode element and only sensitive to high-humidity, working under DC. It's used to protect equipments from dew because its high precision and quick response.
1. Features:
*Small, light *High sensitivity under high-humidity circumstance
*Switching function
*Quick response * Anti-pollution *Excellent reliability and stability
2. Technical specification:
Working voltage
0.8V DC
Working temperature range
0-100Celsius
Working relative humidity range
0-100%RH
Dimensions
8*10*0.7mm
Resistance
75%RH, 10K ohm(average)
93%RH, 100K ohm(average)
95%RH, 200K ohm(min)
http://www.satistronics.com/myfiles/file/Module/HDS05.pdf
…
s o próprio EMI gerado pelo circuito, é mais de 90% provocado pelo overshoot (intensidade e frequência). E certamente esse EMI será um imenso problema em equipamentos comerciais (se for muito alto, nem será aprovado em ensaios de certificação).
Então agora podemos abrir o jogo um pouco mais, assim colaborando com outros que venham aqui no LDG procurando informação relacionada.
Vamos resumir as coisas assim:
1) o chaveamento da corrente em L2, gera impulsos de tensão que tendem a ser os impulsos unitários, porém estes são do mundo real (tem amplitude limitada e a largura do pulso não é zero). Estes impulsos nada mais são portanto, do que "pacotes" de energia que que são enfiados pela guela do capacitor na saída do seu Conversor DC/DC. Cada novo impulso acrescenta um novo pacote de carga "dQ" ao Capacitor de saída, o que por sua vez se traduz num delta de tensão. Sem uma carga resistiva na saída, com o passar do tempo, a tensão sobre esse Capacitor tenderá a alcançar praticamente quase o mesmo valor do impulso, e isto ocorre porque simplesmente estamos pegando um "pacote" de carga "dQ", e jogando em cima de um valor de capacitância de saída muito alto (no seu caso, C4 de 2000uF), e pela equação V = Q/C, pode-se calcular não somente o degrau de tensão dV, mas a própria tensão final sobre o Capacitor após cada novo impulso.
2) mas ao termos uma carga resistiva na saída, parte de cada "dQ" é também usado para alimentar esta carga resistiva, o que implica que esta carga resistiva atua justamente como o "outro lado do cabo de guerra", e assim "trabalha" no sentido de reduzir a tensão sobre o Capacitor de saída. Ao final das contas, espera-se que a taxa de impulsos por segundo, seja suficiente para equilibrar esse cabo de guerra, fazendo com que a tensão sobre o Capacitor se estabilize em torno de um valor médio (na realidade, ela acaba oscilando em torno do valor médio, e este é o ripple real na saída). A taxa de impulsos é a própria frequência de chaveamento, e ela acaba por bombear impulsos de "dQ" para o Capacitor de saída. Maior taxa (frequência), compensação mais rápida. Menor taxa, compensação mais lenta. Um algorítimo de controle de malha fechada, então nada mais faz do que ajustar essa taxa para que a saída tenha o comportamento de tensão esperado: quase constante para uma tensão DC, ou em "arco" crescente ou decrescente para uma saída senoidal. Claro que neste último caso, você poderá variar a própria tensão de entrada (como vc mencionou que já o fez), e assim terá também uma variável a mais na sua equação, que será a intensidade de cada pacote de energia "dQ", e assim tendo um maior controle sob o comportamento da tensão de saída.
3) o fato de ser Buck, Boost, é apenas o resultado da manipulação da intensidade e frequência dos pacotes "dQ", já que estes acrescentam energia ao Capacitor de saída, determinando a tensão sobre este capacitor, ou seja, simplesmente um resultado da conversão V = Q/C, considerando que parte da energia acumulada no Capacitor de saída está sendo drenada por uma carga resistiva (formando o "cabo de guerra" entre consumo e "bombeamento" de energia).
4) e o fato de ser saída positiva ou negativa, é apenas a configuração de como vc direciona os impulsos "dQ" para o Capacitor de saída, ou seja: determinado pela polaridade do Diodo na saída (no seu circuito, D2), que é o elemento chave nisto. Obviamente a polaridade do Capacitor deverá estar de acordo com a tensão resultante desse direcionamento.
5) as diversas configurações mostradas no "slyu036" da Texas, nada mais são do que uma exploração das possíveis variações do que foi descrito acima, inclusive recombinando os circuitos e aplicando o controle adequado ao chaveamento para se obter as características de conversão DC/DC desejadas.
6) uma pequena parte do "dQ" do impulso, acaba injetando energia em um "inesperado" Circuito Tanque LC, composto pelo próprio Indutor do chaveamento de corrente e pela capacitância parasítica existente ali, resultando na oscilação amortecida de alta frequência determinada por Freq = 1/(2*Pi*raiz(LC)). Observe que qualquer chaveamento da corrente do Indutor, irá provocar o impulso de tensão, devido ao Ldi/dt, e havendo alguma capacitância parasítica formando um Circuito Tanque LC, certamente existirá o overshoot senoidal amortecido, na frequencia natural do tanque LC.
7) sempre haverá dois overshoots, pois o indutor é chaveado duas vezes em cada ciclo do seu PWM. Em um dos edges do PWM, a capacitância parasítica do Diodo formará com o Indutor, o circuito tanque LC, resultando em um overshoot. No edge seguinte, será a capacitância parasítica entre Gate e Dreno do MOSFET que se juntará ao Indutor para formar o tanque LC, e um overshoot com outra frequencia e intensidade ocorrerá.
8) e finalmente: como capacitores também são elementos de acoplamento de tensão, uma capacitância parasítica entre dois pontos, acoplará o overshoot no outro nó correspondente ao outro lado desse capacitor. É por isso Dário, que no seu próprio sinal PWM também acaba aparecendo o overshoot (mesma frequência, mas com outra intensidade, que pode ser calculada por um divisor de tensão com impedâncias imaginárias).
Agora sobre o tratamento:
1) observe que estes circuitos procuram usar diodos do tipo "Schottky", pois estes além de serem rápidos tem uma menor "capacitância de barreira" que os diodos "PN" convencionais. Os "Schottky" também tem uma menor resistência de corpo (BULK), o que diminui as perdas por efeito Joule. Observe que nos APNs, vc sempre verá diodos "Schottky" sendo usados (naquela plaquinha da China, também).
2) observe qual a capacitância parasítica intrínseca entre Dreno e Gate do MOSFET, e claro ela deve ser a menor possível, e se deve tomar o cuidado para não acrescentar circuitos ali que causem aumento significativo dessa capacitância entre Dreno e Gate. Observe também que devido ao proprio liga/desliga do MOSFET, capacitâncias parasíticas entre Dreno e Source também podem injetar um "dQ" no Dreno, causando também um overshoot. Logo, a chave aqui, é escolher MOSFETs que tenham sido projetados para chaveamento em circuitos conversores DC/DC de alta frequência, pois certamente suas capacitâncias terão valores menores. Usar MOSFETs originalmente projetados apenas para um ON/OFF convencional, poderá ser um tiro no pé.
3) o Capacitor Eletrolítico de Alumínio de alto valor usado como parte essencial do conversor DC/DC, não irá amenizar o overshoot na saída, porque este tipo de Capacitor tem também uma alta indutância equivalente (ESI), e portanto não filtra a alta frequência do overshoot. Para esta tarefa, sempre se deve usar em paralelo com o Eletrolítico de Alumínio (no seu caso o "C4" de 2000uF), ou um Capacitor de Tântalo ou um de Cerâmico, os quais tem uma baixa indutância equivalente. Veja que nos datasheets desses conversores DC/DC integrados, sempre é especificado o acréscimo de um Capacitor de Tântalo ou do tipo Cerâmico, justamente pelo motivo delineado. Usar combinação de Tântalo e Cerâmico, também é uma ótima alternativa, principalmente em termos de custo e eficiência.
4) usar técnicas pontuais caso seja realmente necessário, como os "snubers" do artigo que vc citou (o do Marcin Walczak). Mas antes disso, deve-se obrigatoriamente aplicar as técnicas convencionais citadas acima (todas devem ser usadas, sem exceção). Caso o overshoot ainda resulte ser acima do mínimo aceitável para sua aplicação, então parte-se para aplicar técnicas pontuais e especializadas.
Fico por aqui, pois um pouco mais disso vai me dar overshoot.
Mas claro, se houver algo mais que eu possa ajudar e esteja ao meu alcance, vamos em frente.
Abrçs,
Elcids…
Adicionado por Elcids Chagas ao 5:46 em 14 março 2019
subMenu4_1(), void subMenu4_2(), void subMenu4_3(), mas aparenta que a função while(1) não permite, tentei de tudo, agradeço muito a ajuda, segue abaixo o codigo.
#include <LiquidCrystal.h> //Biblioteca para o display LCD
// --- Mapeamento de Hardware --- #define butUp 12 //Botão para selecionar tela acima no digital 12 #define butDown 11 //Botão para selecionar tela abaixo no digital 11 #define butP 13 //Botão de ajuste mais no digital 10 #define butM 9 //Botão de ajuste menos no digital 9 #define select 8 //Botão de seleção no digital 8 #define Lamp1 A0 //Saída para lâmpada 1 no A0 (será usado como digital) #define Lamp2 A1 //Saída para lâmpada 2 no A1 (será usado como digital)
// --- Protótipo das Funções Auxiliares ---
void changeMenu(); //Função para modificar o menu atual
void dispMenu(); //Função para mostrar o menu atual void data_hora(); //Função do menu1, data e hora void temperatura(); //Função do menu2, temperatura void lights(); //Função do menu3, acionamento de lampadas void menu4(); //Função do menu4
void dispSubMenu4(); //Função do sub menu4 void readSelect(char option); //Função de Leitura do botão select para seleção de subMenus void subMenu4_1(); //Função para subMenu4_1 void subMenu4_2(); //Função para subMenu4_2 void subMenu4_3(); //Função para subMenu4_3
// --- Variáveis Globais --- char menu = 0x01; //Variável para selecionar o menu char subMenu4 = 0x01; //Variável para selecionar subMenu no menu4 char set1 = 0x00, set2 = 0x00; //Controle das lâmpadas boolean t_butUp, t_butDown, t_butP, t_butM, t_select; //Flags para armazenar o estado dos botões
// --- Hardware do LCD --- LiquidCrystal disp(7, //RS no digital 7 6, //EN no digital 6 5, //D4 no digital 5 4, //D5 no digital 4 3, //D6 no digital 3 2); //D7 no digital 2
// --- Configurações Iniciais --- void setup()
{
disp.begin(16,2); //Inicializa LCD 16 x 2
//Entrada para os botões (digitais 8 a 12) com pull-ups internos
pinMode(butUp, INPUT_PULLUP); pinMode(butDown, INPUT_PULLUP); pinMode(butP, INPUT_PULLUP); pinMode(butM, INPUT_PULLUP); pinMode(select, INPUT_PULLUP); pinMode(Lamp1, OUTPUT); //Configura saída para lâmpada 1 pinMode(Lamp2, OUTPUT); //Configura saída para lâmpara 2 t_butUp = 0x00; //limpa flag do botão Up t_butDown = 0x00; //limpa flag do botão Down t_butP = 0x00; //limpa flag do botão P t_butM = 0x00; //limpa flag do botão M t_select = 0x00; //limpa flag do botão select digitalWrite(Lamp1, LOW); //Lâmpada 1 inicia apagada digitalWrite(Lamp2, LOW); //Lâmpada 2 inicia apagada
} //end setup
// --- Loop Infinito --- void loop()
{ changeMenu(); dispMenu();
} //end loop
// --- Desenvolvimento das Funções Auxiliares --- void changeMenu() //Modifica o menu atual
{
if(!digitalRead(butUp)) t_butUp = 0x01; //Botão Up pressionado? Seta flag if(!digitalRead(butDown)) t_butDown = 0x01; //Botão Down pressionado? Seta flag if(digitalRead(butUp) && t_butUp) //Botão Up solto e flag setada?
{ //Sim...
t_butUp = 0x00; //Limpa flag disp.clear(); //Limpa display menu++; //Incrementa menu if(menu > 0x04) menu = 0x01; //Se menu maior que 4, volta a ser 1
} //end butUp
if(digitalRead(butDown) && t_butDown) //Botão Down solto e flag setada?
{ //Sim...
t_butDown = 0x00; //Limpa flag disp.clear(); //Limpa display menu--; //Decrementa menu if(menu < 0x01) menu = 0x04; //Se menu menor que 1, volta a ser 4
} //end butDown
} //end changeMenu
void dispMenu() //Mostra o menu atual
{
switch(menu) //Controle da variável menu {
case 0x01: //Caso 1
data_hora(); //Chama a função de relógio break; //break
case 0x02: //Caso 2
temperatura(); //Chama a função do termômetro break; //break
case 0x03: //Caso 3
lights(); //Chama função para acionamento de lâmpadas break; //break
case 0x04: //Caso 4
menu4(); //Chama função para o menu4 break; //break } //end switch menu
} //end dispMenu
void data_hora() //Data e Hora (menu1)
{ disp.setCursor(0,0); //Posiciona cursor na coluna 1, linha 1
disp.print("Data e Hora"); //Imprime mensagem
disp.setCursor(0,1); //Posiciona cursor na coluna 1, linha 2
// Desenvolver uma função de data e hora... disp.print("27/08/15 15:14"); //Mostrador (apenas ilustrativo......)
} //end data_hora
void temperatura() //Temperatura (menu2) { disp.setCursor(0,0); //Posiciona cursor na coluna 1, linha 1
disp.print("Temperatura"); //Imprime mensagem
disp.setCursor(1,1); //Posiciona cursor na coluna 2, linha 2
disp.print("25 Celsius"); //Mostrador (apenas ilustrativo......)
} //end temperatura()
void lights() //Acionamento de lâmpadas (menu3)
{ disp.setCursor(0,0); //Posiciona cursor na coluna 1, linha 1
disp.print("Acionar Lampadas"); //Imprime mensagem do menu 3 if(!digitalRead(butP)) t_butP = 0x01; //Botão P pressionado? Seta flag
if(!digitalRead(butM)) t_butM = 0x01; //Botão M pressionado? Seta flag if(digitalRead(butP) && t_butP) //Botão P solto e flag setada? { //Sim...
t_butP = 0x00; //Limpa flag set1++; //Incrementa set1 if(set1 > 2) set1 = 0x01; //Se maior que 2, volta a ser 1
switch(set1) //Controle do set1 {
case 0x01: //Caso 1
disp.setCursor(0,1); //Posiciona cursor na coluna 1, linha 2
disp.print("L1 on "); //Imprime mensagem
digitalWrite(Lamp1, HIGH); //Liga lâmpada 1
break; //Break
case 0x02: //Caso 2
disp.setCursor(0,1); //Posiciona cursor na coluna 1, linha 2
disp.print("L1 off"); //Imprime mensagem
digitalWrite(Lamp1, LOW); //Desliga lâmpada 1
break; //Break } //end switch set1 } //end butP
if(digitalRead(butM) && t_butM) //Botão D solto e flag setada?
{ //Sim...
t_butM = 0x00; //Limpa flag set2++; //Incrementa set2 if(set2 > 2) set2 = 0x01; //Se maior que 2, volta a ser 1
switch(set2) //Controle do set2
{
case 0x01: //Caso 1
disp.setCursor(8,1); //Posiciona cursor na coluna 8, linha 2
disp.print("L2 on "); //Imprime mensagem
digitalWrite(Lamp2, HIGH); //Liga lâmpada 2
break; //Break
case 0x02: //Caso 2
disp.setCursor(8,1); //Posiciona cursor na coluna 8, linha 2
disp.print("L2 off"); //Imprime mensagem
digitalWrite(Lamp2, LOW); //Liga lâmpada 1
break; //Break } //end switch set1 } //end butM
} //end lights
void menu4() //Função genérica para um quarto menu...
{
disp.setCursor(0,0); //Posiciona cursor na coluna 1, linha 1
disp.print("Menu 4"); //Imprime mensagem
dispSubMenu4();
} //end menu4
void dispSubMenu4() //Mostra o sub menu atual para o menu 4
{ if(!digitalRead(butP)) t_butP = 0x01; //Botão P pressionado? Seta flag
if(!digitalRead(butM)) t_butM = 0x01; //Botão M pressionado? Seta flag if(digitalRead(butP) && t_butP) //Botão P solto e flag setada?
{ //Sim...
t_butP = 0x00; //Limpa flag subMenu4++; //incrementa subMenu4 if(subMenu4 > 3) subMenu4 = 0x01; //se maior que 3, volta a ser 1 } //end butP
if(digitalRead(butM) && t_butM) //Botão D solto e flag setada?
{ //Sim...
t_butM = 0x00; //Limpa flag subMenu4--; //decrementa subMenu4 if(subMenu4 < 1) subMenu4 = 0x03; //se menor que 1, volta a ser 3 } //end butM switch(subMenu4) //Controle da variável subMenu
{
case 0x01: //Caso 1
disp.setCursor(1,1); //Posiciona cursor na coluna 2, linha 2
disp.print("Sub Menu 01"); readSelect(1); //Lê botão select com parâmetro 1
break; //break
case 0x02: //Caso 2
disp.setCursor(1,1); //Posiciona cursor na coluna 2, linha 2
disp.print("Sub Menu 02");
readSelect(2); //Lê botão select com parâmetro 2
break; //break
case 0x03: //Caso 2
disp.setCursor(1,1); //Posiciona cursor na coluna 2, linha 2
disp.print("Sub Menu 03");
readSelect(3); //Lê botão select com parâmetro 3
break; //break } //end switch menu
} //end dispMenu
void readSelect(char option) //Leitura do botão select para seleção de subMenus
{
if(!digitalRead(select)) t_select = 0x01; //Botão select pressionado? Seta flag if(digitalRead(select) && t_select) //Botão select solto e flag setada?
{ //Sim...
t_select = 0x00; //Limpa flag
switch(option) {
case 0x01: subMenu4_1(); break; case 0x02: subMenu4_2(); break; case 0x03: subMenu4_3(); break;
} //end switch option } //end if
} //end readSelect
void subMenu4_1()
{
while(1)
{
disp.setCursor(0,0); //Posiciona cursor na coluna 1, linha 1
disp.print("Tarefa 1"); //Imprime mensagem
disp.setCursor(0,1); //Posiciona cursor na coluna 1, linha 2
disp.print("Em funcionamento"); //Mostrador (apenas ilustrativo......)
}
} //end subMenu4_1
void subMenu4_2()
{
while(1)
{
disp.setCursor(0,0); //Posiciona cursor na coluna 1, linha 1
disp.print("Tarefa 2"); //Imprime mensagem
disp.setCursor(0,1); //Posiciona cursor na coluna 1, linha 2
disp.print("Em funcionamento"); //Mostrador (apenas ilustrativo......)
}
} //end subMenu4_2
void subMenu4_3()
{
while(1)
{
disp.setCursor(0,0); //Posiciona cursor na coluna 1, linha 1
disp.print("Tarefa 3"); //Imprime mensagem
disp.setCursor(0,1); //Posiciona cursor na coluna 1, linha 2
disp.print("Em funcionamento"); //Mostrador (apenas ilustrativo......)
}
} //end subMenu4_3…
Adicionado por Ricardo Gomes ao 21:36 em 6 junho 2017
byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x9B, 0x36 }; // Endereço Macbyte ip[] = { 192, 168, 0, 110 }; // Endereço de Ip da sua RedeEthernetServer server(8090); // Porta de serviço
int area = 2;int sala = 3;int escritorio = 5;int trava = 6;int portao = 7;String readString = String(30); // string para buscar dados de endereço
// para o optacoplador Áreaconst int analogArea = A0;int sensorArea = 0;String statusArea;
// para o optacoplador Salaconst int analogSala = A1;int sensorSala = 0;String statusSala;
// para o optacoplador Escritórioconst int analogEscritorio = A2;int sensorEscritorio = 0;String statusEscritorio;
boolean statusPortao = false; // Variável para o status do portão
void setup(){ // Inicia o Ethernet Ethernet.begin(mac, ip); // Define os pinos como saída pinMode(area, OUTPUT); pinMode(sala, OUTPUT); pinMode(escritorio, OUTPUT); pinMode(trava, OUTPUT); pinMode(portao, OUTPUT); // Inicia a comunicação Serial Serial.begin(9600); }
void loop(){ //Verifica o status do sensor da Área sensorArea = analogRead(analogArea); if (sensorArea >=300) { statusArea = ("lampada area ligada"); } else { statusArea = ("lampada area desligada"); } //Verifica o status do sensor da Sala sensorSala = analogRead(analogSala); if (sensorSala >=300) { statusSala = ("lampada sala ligada"); } else { statusSala = ("lampada sala desligada"); } //Verifica o status do sensor do Escritório sensorEscritorio = analogRead(analogEscritorio); if (sensorEscritorio >=300) { statusEscritorio = ("lampada escritorio ligada"); } else { statusEscritorio = ("lampada escritorio desligada"); } // Criar uma conexão de cliente EthernetClient client = server.available(); if (client) { while (client.connected()) { if (client.available()) { char c = client.read(); // ler caractere por caractere vindo do HTTP if (readString.length() < 30) { // armazena os caracteres para string readString += (c); } //se o pedido HTTP terminou if (c == '\n') { // vamos verificar se a lâmpada da área deve ser ligada // Se a string possui o texto L=Ligar if(readString.indexOf("LigarArea")>=0) { // A lâmpada vai ser ligada digitalWrite(area, HIGH); } // Se a string possui o texto L=Desligar if(readString.indexOf("DesligarArea")>=0) { // A lâmpada vai ser desligada digitalWrite(area, LOW); } { // vamos verificar se a lâmpada da sala deve ser ligada // Se a string possui o texto L=Ligar if(readString.indexOf("LigarSala")>=0) { // A lâmpada vai ser ligada digitalWrite(sala, HIGH); } // Se a string possui o texto L=Desligar if(readString.indexOf("DesligarSala")>=0) { // A lâmpada vai ser desligada digitalWrite(sala, LOW); } { // vamos verificar se a lâmpada do escritório deve ser ligada // Se a string possui o texto L=Ligar if(readString.indexOf("LigarEscritorio")>=0) { // A lâmpada vai ser ligada digitalWrite(escritorio, HIGH); } // Se a string possui o texto L=Desligar if(readString.indexOf("DesligarEscritorio")>=0) { // A lâmpada vai ser desligada digitalWrite(escritorio, LOW); } { // vamos verificar se o portão deve abrir // Se a string possui o texto L=Ligar if(readString.indexOf("LigarPortao")>=0) { // O portão vai ser aberto digitalWrite(portao, HIGH); delay (1000); digitalWrite(portao, LOW); statusPortao = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("DesligarPortao")>=0) { // O portão vai ser fechado digitalWrite(portao, HIGH); delay (1000); digitalWrite(portao, LOW); statusPortao = false; } { // vamos verificar se a trava deve ser aberta // Se a string possui o texto L=Ligar if(readString.indexOf("LigarTrava")>=0) { // A trava vai ser aberta digitalWrite(trava, HIGH); delay (2000); digitalWrite(trava, LOW); }
// dados HTML de saída começando com cabeçalho padrão client.println("HTTP/1.1 200 OK"); client.println("Content-Type: text/html"); client.println(); client.println("<font size='20'>"); // aqui vai imprimir o conteúdo da string client.print("<h5>"); client.print(statusArea); client.print("</h5>"); // aqui vai imprimir o conteúdo da string client.print("<h5>"); client.print(statusSala); client.print("</h5>"); // aqui vai imprimir o conteúdo da string client.print("<h5>"); client.print(statusEscritorio); client.print("</h5>"); client.println("<font size='20'>"); if (statusPortao) { client.print("<h5>"); client.println("PortaoAberto"); client.print("<h5>"); } else { client.print("<h5>"); client.println("PortaoFechado"); client.print("<h5>"); } //limpa string para a próxima leitura readString=""; // parar cliente client.stop(); } } } }}}} }}
Só que eu fiz o aplicativo android no App inventor segue as fotos:
Essa é a tela, que ja mudei varias vezes
Esses são os blocos da lógica
Caso se interesse dê uma olhada nas video aulas do androi e arduino no you tube:
https://www.youtube.com/user/TecnoEduardo
O Eduardo explica tudo sobre android e arduino.
…