Resultados da busca - %E5%8D%8E%E5%AE%87%E5%BD%A9%E7%A5%A8%E6%9C%89%E6%89%98%E5%90%97%E3%80%90%E2%94%8B%E7%A8%B3%E5%AE%9A2%E2%92%8F7%E2%92%8F01705%E2%94%8B%E6%89%A3%E3%80%93%E3%80%91
mplos. Se vc não fizer isso, será uma empreitada difícil e ainda poderá não ter bons resultados. Então dedique-se e observe as coisas com a devida atenção.
Vamos então falar dos pontos enumerados que postei e vc respondeu. Então, seguindo a mesma enumeração:
1) ok, acho que ficou claro como os 3 LEDs (verde, vermelho, e amarelo) devem se comportar.
Mas conferindo se realmente entendi: o "verde" indica que o Sistema está funcionando e fica piscando indicando isso, mas pára de piscar quando algum problema é detectado (e claro, volta automaticamente a piscar quando o problema deixa de existir).
O "vermelho" pisca enquanto os Sensores de Pressão indicarem problema.
E o "amarelo" pisca enquanto o Sensor de Umidade indicar problema.
Mas ainda tenho uma questão sobre os níveis de Umidade, porém irei falar sobre isso mais à frente.
Sobre o envio de SMS, no seu código original este envio é feito apenas para problemas nos níveis de Pressão. Mas no post anterior, vc disse que deveria também ser enviado SMS para problemas de Umidade. Então pergunto: afinal, em que situações um SMS deve ser enviado?
2) ok, pelo código já tinha visto que era um Sensor de Pressão com saída analógica (eu só não sabia se era um único Sensor com dois sinais ou se eram dois Sensores independentes cada um com seu sinal). Sobre a parte da aferição, tenho um comentário a fazer, porém só o farei depois que publicar o código (mas não se preocupe porque é tranquilo, e se eu me esquecer disso, por favor me lembre).
Mas há uma consideração sobre a conexão dos Sensores de Pressão, que tem implicação no código. Vou esclarecer parcialmente (posteriormente darei mais detalhes). Veja este trecho do seu código original, onde vc faz as conversões AD para obter os níveis de pressão indicados pelos sensores, conforme mostro na figura a seguir salientado em amarelo:
(clique na figura para "zoom")
Observe que existe um "delay" de 80 mili-segundos entre a conversão AD (função "analogRead") do primeiro Sensor e a conversão do segundo Sensor de Pressão. A pergunta é: porque vc inseriu este "delay"? sem ele vc estava obtendo valores incorretos? Vou explicar porque estou perguntando sobre isso:
Ocorre que se vc não fizer a conexão adequada de um sinal analógico ao Arduino, poderão ocorrer erros nos valores convertidos, especialmente se existir no Sistema mais de um Canal Analógico sendo utilizado (que é o seu caso, pois além dos dois sensores de pressão vc tem também o sensor de Umidade).
Este problema ocorre porque a "impedância AC" do sinal analógico não é baixa o suficiente para permitir que o Conversor AD faça um sample adequado (o problema pode ocorrer mesmo quando a "impedância DC" é baixa, embora neste caso seja mesmo perceptível). Como consequência aparece um erro no valor convertido, quando se troca de um canal para outro (e também ocorre um problema chamado "Injeção de Carga", que os Fabricantes de Chips não gostam de falar porque nem sempre é fácil eliminar e eles não querem admitir ou evidenciar o problema).
Existem essencialmente duas técnicas para se eliminar esses erros (ou reduzi-los de forma que não sejam perceptíveis), e uma delas é fazer algo parecido com o que vc fez, acrescentando algo semelhante ao "delay". A outra forma é conectando adequadamente o sinal analógico, e esta é a forma preferível. Eventualmente inclusive, se utiliza as duas técnicas, se a coisa for muito "braba" (ou por precaução, como sempre faço).
Assim eu te aconselharia a usar a técnica de conectar de forma adequada o sinal dos seus Sensores ao Arduino. No entanto isso exige que vc acrescente um Resistor e um Capacitor em cada sinal. Mas isso fica a seu critério, e eu não posso determinar isso. Caso vc decida usar essa técnica, eu calcularei os Resistores e os Capacitores mais adequados, e mostrarei como vc deve fazer as conexões (é bem simples).
Então pense sobre isso. Mas se vc quiser usar apenas a técnica no código, tranquilo, farei isso mas sem usar o "delay" pois não é com ele que se implementa isso. Aproveito para dizer, que por regra geral, não se deve usar o "delay" fora da função "setup" do Arduino, e posteriormente explicarei porque.
Ainda sobre a Pressão, por favor veja a figura a seguir:
(clique na figura para "zoom")
Na parte marcada em "rosa", ficou claro que a Pressão é calculada em unidades de "bar", sendo esta a unidade que vc exibe no Display LCD. E portanto também fica claro que é esta unidade de pressão que seu Sistema realmente irá trabalhar depois de obter o valor do Sinal dos Sensores de Pressão.
Mas na parte em "verde" na figura, vc faz a conversão para uma outra unidade intermediária, antes de finalmente converter para "bar". Então pergunto: que unidade intermediária é esta? Vc faz isso pra facilitar seu sistema de calibração para cada um dos Sensores? (eu tenho quase certeza que seja isso, mas é melhor perguntar). Pergunto também, porque como eu disse antes, eu irei posteriormente fazer algumas considerações sobre a calibração, e que pode vir a te ajudar nesse processo.
Sobre o Sensor de Umidade, há uma sugestão que eu gostaria de te fazer. Vc não acha que seria mais adequado ter o valor da Umidade sendo diretamente proporcional à Umidade real? Veja: atualmente no seu Sistema, este valor é inversamente proporcional à Umidade real, ou seja, o máximo valor (no caso "1023") se refere à mínima Umidade, enquanto que o mínimo valor que é "0" (zero) se refere à máxima Umidade. Se fosse diretamente proporcional, este valor resultante poderia ser chamado de "Índice de Umidade", e quando seu valor for "0" indicará também a mínima Umidade. Esta forma me parece ter mais sentido. O que vc acha?
Sei que no código vc está usando a forma inversamente proporcional porque é assim que o pessoal usa por aí em blogs e sites na Internet. Eles simplesmente fazem a conversão AD no Arduino sem mais nenhum tratamento e que resulta nesse comportamento. Como vc disse que obteve pedaços de código aqui e ali na Internet, por tabela acabou seguindo esta regra "invertida". Mas pense sobre a sugestão que fiz.
3) sobre o Buzzer, está bem claro como deverá funcionar. Mas tenho uma questão sobre o Buzzer em si. Me parece que vc está usando um "Buzzer passivo", que é aquele que só emite som quando vc gera o sinal de som no Arduino (e seu código faz isso através da função "tone"). Para melhor entender veja a figura a seguir:
(clique na figura para "zoom")
Observe que marquei em "verde", uma informação na plaquinha do Buzzer que diz qual é o nível lógico que "aciona" o Buzzer. Este da figura é o mais comum, e vc pode ver que está marcado na placa que ele é acionado por nível lógico "LOW". É importante saber qual é este nível para o "Buzzer passivo", pois isto permite que efetivamente não seja aplicada tensão sobre o "Buzzer" quando este não está emitindo som. Veja: quando termina a ação da função "tone" (ou quando se usa a função "noTone"), o nível lógico que fica na saída do Arduino é justamente o nível "LOW", e no caso da plaquinha da figura estaríamos aplicando tensão ao Buzzer, embora este não emita som (pois o sinal aplicado é agora estático). Isto força o "piezzo" do Buzzer, e a médio ou longo prazo poderá danificá-lo. Então é melhor evitar isso. Para tal, basta aplicar-se o nível lógico adequado ao Buzzer logo após parar o sinal do som. Já fiz isso no código, porém não sei qual é o nível lógico que liga seu Buzzer. Então por favor, verifique qual é, e se possível coloque aqui uma foto da sua plaquinha Buzzer, para deixarmos claro.
4) sobre as mensagens de SMS, tranquilo, eu imaginava que vc iria ainda ajustar isso adequadamente. Mas lembre-se que o bom-senso nos diz: não deixe para depois o que se pode facilmente fazer agora.
No código irei colocar mensagens que estejam relacionadas a cada alerta, e depois vc altera isso da forma que vc achar mais adequado. O mesmo se aplica para as mensagens exibidas no Display LCD para as Pressões medidas.
Sobre a questão do "auto-teste" tanto para os LEDs quanto para os demais elementos (Buzzer, SMS, etc), é tranquilo de implementar. Mas irei fazer isso somente depois que vc disser que todo o restante está funcionando da forma correta, ok?
Eu ainda tenho uma dúvida sobre as faixas de Umidade que vc usa para sinalizar os alertas (se vc olhar com cuidado seu código original, talvez vc já descubra que dúvida é esta). Mas irei perguntar depois, já que isto praticamente não tem impacto no código.
O código está 99% pronto. Falta apenas esclarecer os pontos aqui mencionados.
Fico no aguardo de um retorno seu sobre estes pontos.
Ah Cabana, por favor, mude o título deste tópico para um que tenha realmente sentido sobre o que vc está implementando, porque este nome que vc colocou, pelo amor de Deus. E ainda é o mesmo nome do seu tópico anterior. Jesus.
Abrçs,
Elcids…
Adicionado por Elcids Chagas ao 19:55 em 29 fevereiro 2020
desativada a interrupção do dimmer também funciona:
Exemplo: if (bufferSerial == "A"){detachInterrupt(0);irsend.send(1,0x2FD48B7,32); attachInterrupt(0, zero_crosss_int, RISING); enviou =1; delay(5);} // código NEC(1) TV para ligar
A conexão serial com a placa é feita pelo modulo BT HC-05.
Grato pelo interesse.
#include <IRLib.h>#include <IRLibMatch.h>#include <IRLibRData.h>#include <IRLibTimer.h>
//definições dimmerint ZERO = 2; // pino de interrupção do zero crossint AC_LOAD = 10; // Output para o Triacvolatile int dimming = 100; // Dimming level (0-128) 0 = ON, 128 = OFFString ValorDimmer;
//definições do Receptor IRIRsend irsend; //instância para enviar IR const int led = 8; // pino do led de indicação de envio IR const int ledIR = 3; //pino do emissor IR
//variaveis do temporizador para temperaturaint savedTime;int totalTime = 0;
//variaveis leitura serialString bufferSerial = "";int numero; //contador para alterar a potencia do dimmerint enviou; //flag para indicar que foi enviado codigo IR
void setup(){Serial.begin(9600);
//irpinMode(led, OUTPUT); // saida led pinMode(ledIR ,OUTPUT); // saída do infravermelho
//dimmerpinMode(ZERO, INPUT);pinMode(AC_LOAD, OUTPUT);// Set AC Load pin as outputattachInterrupt(0, zero_crosss_int, RISING); //zero-crossing - interrupçãonumero = dimming; //inicializa a leitura da serial com o mesmo valor do dimming
//inicia temporizador que atualiza temperaturasavedTime = millis();delay(100);
}
void loop(){ //atualiza temperatura no intervalo de "totaltime" int passedTime = millis() - savedTime; if (passedTime > totalTime) { //temperatura LM35 int sum=0; for (int i = 0; i < 50; i++) sum += analogRead(A5); int media = (sum * 0.48875855) / 50; savedTime = millis(); // totalTime = 5000; //Seta para 5seg } bufferSerial = ""; while (Serial.available()>0) { enviou = 0; char c = Serial.read(); // Lê byte do buffer serial; bufferSerial.concat(c); // Concatena valores delay(5); if (c == '@') break; // se leu o caracter @ sai do loop. Este caracter é enviado pela rotina do celular }
if (bufferSerial.length()>0 && bufferSerial.length()<2 && !enviou) { //verifica se informação que chegou esta entre 1 e 2 caracteres (para futuras implementações)
digitalWrite(led, HIGH); //acende o led indicador de envio de IR / comando
if (bufferSerial == "A"){irsend.send(1,0x2FD48B7,32); enviou =1; delay(5);} // código NEC(1) TV para ligar if (bufferSerial == "B"){irsend.send(1,0x2FD7887,32); enviou =1; delay(5);} // código NEC(1) TV para diminuir o volume if (bufferSerial == "C"){irsend.send(1,0x2FD58A7,32); enviou =1; delay(5);}// código NEC(1) TV para aumentar o volume if (bufferSerial == "D"){irsend.send(1,0x2FDA857,32); enviou =1; delay(5);}// código NEC(1) TV para timer if (bufferSerial == "E"){irsend.send(1,0x2FD08F7,32); enviou =1; delay(5);}// código NEC(1) TV para mute if (bufferSerial == "M"){irsend.send(7,0x34347887,32);enviou =1; delay(5);} // código NECx(7) HTLG para ligar/desligar if (bufferSerial == "N"){irsend.send(7,0x34346897,32);enviou =1; delay(5);} // código NECx(7) HTLG para baixar o volume if (bufferSerial == "O"){irsend.send(7,0x3434e817,32);enviou =1; delay(5);}// código NECx(7) HTLG para aumentar o volume if (bufferSerial == "P"){irsend.send(7,0x343451AE,32);enviou =1; delay(5);}// código NECx(7) HTLG para selecionar o source if (bufferSerial == "Q"){irsend.send(7,0x343459A6,32);enviou =1; delay(5);}// código NECx(7) HTLG para abrir o deck if (bufferSerial == "R"){irsend.send(7,0x343415EA,32);enviou =1; delay(5);} // código NECx(7) HTLG para mudar de estação / seleção - if (bufferSerial == "S"){irsend.send(7,0x3434956A,32);enviou =1; delay(5);} // código NECx(7) HTLG para mudar de estação / seleção + if (bufferSerial == "T"){irsend.send(7,0x343455AA,32);enviou =1; delay(5);}// código NECx(7) HTLG como enter if (bufferSerial == "U"){irsend.send(7,0x343420DF,32);enviou =1; delay(5);}// código NECx(7) HTLG como play if (bufferSerial == "V"){irsend.send(7,0x3434F20D,32);enviou =1; delay(5);}// código NECx(7) HTLG como pause if (bufferSerial == "X"){irsend.send(7,0x3434609F,32);enviou =1; delay(5);} // código NECx(7) HTLG como skip - if (bufferSerial == "Y"){irsend.send(7,0x3434E01F,32);enviou =1; delay(5);}// código NECx(7) HTLG como skip + }
//se o comando possui mais de 2 caracteres então é para o dimmer if (bufferSerial.length()>2){ bufferSerial.trim(); //elimina possiveis espaços if (bufferSerial.substring(0,2) == "#L") numero = numero+5; //incrementa contador do dimmer para diminuir potencia if (bufferSerial.substring(0,2) == "#H") numero = numero-5; //decrementa contador do dimmer para aumentar potencia if (numero >= 15 && numero <= 128) //se contador estiver abaixo ou acima dos limites do dimmer mantém a ultima leitura dimming=numero; else dimming=dimming; } digitalWrite(led, LOW); //apaga o led indicador de envio de IR / comando }
// função disparada pelo zero-crossingvoid zero_crosss_int() {int dimtime = (65*dimming); // For 60Hz =>65 delayMicroseconds(dimtime); // Off cycledigitalWrite(AC_LOAD, HIGH); // triac firingdelayMicroseconds(8.33); // triac On propogation delay 10ms for 60Hz use 8.33)digitalWrite(AC_LOAD, LOW); // triac Off}…
Adicionado por Fernando Souza ao 10:53 em 10 novembro 2014
ada digital que não esteja sendo usado pelo Ethernet Shield, senão conflitos irão ocorrer. Há no mercado uma variedade de implementações do Ethernet Shield, e embora praticamente todas usem o W5100 e tenham um receptáculo para Cartão SD, há quase sempre ligeiras diferenças entre estas implementações. O ideal é que vc tivesse o esquemático do exato modelo do Shield que está usando, para poder conferir quais "pinos" estão livres. Outra possibilidade, é você analisar o código da Lib específica, e por lá descobrir quais pinos são usados.
No entanto, como a maioria delas usa a interface SPI do Arduino, tanto para se comunicar com o W5100 quanto Cartão SD, podemos considerar que há vários sinais digitais do Arduino que estão livres. Eu analisei dois esquemáticos (os quais são sempre desenhados de forma péssima), e pude verificar que certamente o pino digital "7" do Arduino está livre nestes esquemáticos. Então acho que ele poderia ser um boa opção para você usar.
Observe que os "pinos" A0 até A5 do Arduino são originalmente pinos digitais da CPU Atmega328. No entanto evita-se usar estes pinos, porque eles são os únicos pinos que podem ser entradas Analógicas, e caso vc precise dessas entradas, elas estarão disponíveis. Mas são 6 entradas, e mesmo que vc venha a precisar de uma entrada Analógica posteriormente, ainda assim haverá uma ou outra disponível, caso você precise usar uma ou mais delas como pinos digitais.
Na figura a seguir, você pode ver a conexão do seu sensor magnético ao Arduino UNO (no caso ao pino "7"):
Observe que não há resistor externo ligado entre o pino "7" e o 5V do Arduino. Isto significa que você deverá obrigatoriamente configurar a entrada digital "7", como sendo do tipo "INPUT_PULLUP". A linha de código para isso seria:
pinMode ( 7, INPUT_PULLUP );
Mas caso você queira colocar um resistor externo, então a entrada deve ser configurada apenas como "INPUT", e o valor do resistor pode ser de 10k.
Outro ponto importante, é o capacitor de 100 kpF ligado entre o pino "7" e o GND do Arduino. Este capacitor evita que ruídos espúrios possam "enganar" seu alarme. Se vc não tiver um de 100 kpF, pode usar um valor maior, como 220, 330, 470 kpF, e até mesmo 1uF. Use capacitores de cerâmica. Eletrolítico de Alumínio, nem pensar!!!). Não deixe de incluir o capacitor, principalmente se o cabo do seu sensor for relativamente longo. O capacitor deve estar fisicamente o mais próximo possível do Arduino (e não do sensor!!!), preferencialmente quase junto da placa do UNO.
Veja que o que seu programa precisa, é apenas detectar quando a entrada "7" do Arduino, está em "HIGH". Isto porque quando o outro lado do sensor (a parte do imã) está encostada no sensor ligado ao pino "7", a chave está fechada, e portanto o valor lido será "LOW". Ao se afastar o imã, a chave abre, e o valor lido passa a ser "HIGH", indicando que a janela foi aberta.
Como seu perfil indica que vc é da área de Eletrônica, acredito que não será um problema para vc implementar isso, além do próprio programa no Arduino para detectar o acionamento do sensor (que é uma chave simples, apenas magnética), e a sinalização correspondente. Caso tenha, avise aqui que ajudamos você.
Informação final: caso vc precise instalar vários sensores, monitorados pelo mesmo Arduino, mesmo que não existam pinos suficientes sobrando no Arduino, há diversas formas de se fazer isso. Se precisar, também avise aqui que vamos te auxiliar.
Sucesso com sua implementação.
Abrçs,
Elcids
…
Adicionado por Elcids Chagas ao 18:11 em 20 maio 2018
)\Arduino\libraries\Blynk\src/BlynkSimpleEsp8266.h:18,
from C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:19:
C:\Program Files (x86)\Arduino\libraries\Blynk\src/Blynk/BlynkProtocolDefs.h:96:0: warning: "htons" redefined [enabled by default]
#define htons(x) ( ((x)<<8) | (((x)>>8)&0xFF) )
^
In file included from C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1/tools/sdk/lwip2/include/lwip/ip_addr.h:41:0,
from C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1/tools/sdk/include/user_interface.h:30,
from C:\Users\luciano\Documents\Arduino\libraries\WiFiManager/WiFiManager.h:22,
from C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:7:
C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1/tools/sdk/lwip2/include/lwip/def.h:108:0: note: this is the location of the previous definition
#define htons(x) lwip_htons(x)
^
In file included from C:\Program Files (x86)\Arduino\libraries\Blynk\src/Blynk/BlynkApi.h:18:0,
from C:\Program Files (x86)\Arduino\libraries\Blynk\src/BlynkApiArduino.h:14,
from C:\Program Files (x86)\Arduino\libraries\Blynk\src/BlynkSimpleEsp8266.h:18,
from C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:19:
C:\Program Files (x86)\Arduino\libraries\Blynk\src/Blynk/BlynkProtocolDefs.h:97:0: warning: "htonl" redefined [enabled by default]
#define htonl(x) ( ((x)<<24 & 0xFF000000UL) | \
^
In file included from C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1/tools/sdk/lwip2/include/lwip/ip_addr.h:41:0,
from C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1/tools/sdk/include/user_interface.h:30,
from C:\Users\luciano\Documents\Arduino\libraries\WiFiManager/WiFiManager.h:22,
from C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:7:
C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1/tools/sdk/lwip2/include/lwip/def.h:110:0: note: this is the location of the previous definition
#define htonl(x) lwip_htonl(x)
^
In file included from C:\Program Files (x86)\Arduino\libraries\Blynk\src/Blynk/BlynkApi.h:18:0,
from C:\Program Files (x86)\Arduino\libraries\Blynk\src/BlynkApiArduino.h:14,
from C:\Program Files (x86)\Arduino\libraries\Blynk\src/BlynkSimpleEsp8266.h:18,
from C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:19:
C:\Program Files (x86)\Arduino\libraries\Blynk\src/Blynk/BlynkProtocolDefs.h:101:0: warning: "ntohs" redefined [enabled by default]
#define ntohs(x) htons(x)
^
In file included from C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1/tools/sdk/lwip2/include/lwip/ip_addr.h:41:0,
from C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1/tools/sdk/include/user_interface.h:30,
from C:\Users\luciano\Documents\Arduino\libraries\WiFiManager/WiFiManager.h:22,
from C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:7:
C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1/tools/sdk/lwip2/include/lwip/def.h:109:0: note: this is the location of the previous definition
#define ntohs(x) lwip_ntohs(x)
^
In file included from C:\Program Files (x86)\Arduino\libraries\Blynk\src/Blynk/BlynkApi.h:18:0,
from C:\Program Files (x86)\Arduino\libraries\Blynk\src/BlynkApiArduino.h:14,
from C:\Program Files (x86)\Arduino\libraries\Blynk\src/BlynkSimpleEsp8266.h:18,
from C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:19:
C:\Program Files (x86)\Arduino\libraries\Blynk\src/Blynk/BlynkProtocolDefs.h:102:0: warning: "ntohl" redefined [enabled by default]
#define ntohl(x) htonl(x)
^
In file included from C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1/tools/sdk/lwip2/include/lwip/ip_addr.h:41:0,
from C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1/tools/sdk/include/user_interface.h:30,
from C:\Users\luciano\Documents\Arduino\libraries\WiFiManager/WiFiManager.h:22,
from C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:7:
C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1/tools/sdk/lwip2/include/lwip/def.h:111:0: note: this is the location of the previous definition
#define ntohl(x) lwip_ntohl(x)
^
teste2wifi_Mananger_copia:37: error: 'Blynk' does not name a type
teste2wifi_Mananger_copia:38: error: 'Blynk' does not name a type
teste2wifi_Mananger_copia:39: error: 'Blynk' does not name a type
C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino: In function 'void tick()':
C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:117:27: warning: 'BUILTIN_LED' is deprecated (declared at C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1\variants\generic/common.h:78) [-Wdeprecated-declarations]
C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:118:16: warning: 'BUILTIN_LED' is deprecated (declared at C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1\variants\generic/common.h:78) [-Wdeprecated-declarations]
C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino: In function 'void setup()':
C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:134:11: warning: 'BUILTIN_LED' is deprecated (declared at C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1\variants\generic/common.h:78) [-Wdeprecated-declarations]
teste2wifi_Mananger_copia:154: error: 'DynamicJsonBuffer' was not declared in this scope
C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:154:9: note: suggested alternative:
In file included from C:\Users\luciano\Documents\Arduino\libraries\ArduinoJson\src/ArduinoJson/DynamicJsonDocument.hpp:10:0,
from C:\Users\luciano\Documents\Arduino\libraries\ArduinoJson\src/ArduinoJson.hpp:9,
from C:\Users\luciano\Documents\Arduino\libraries\ArduinoJson\src/ArduinoJson.h:9,
from C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:13:
C:\Users\luciano\Documents\Arduino\libraries\ArduinoJson\src/ArduinoJson/Memory/DynamicJsonBuffer.hpp:159:5: note: 'ArduinoJson::Internals::DynamicJsonBuffer'
DynamicJsonBuffer;
^
teste2wifi_Mananger_copia:154: error: expected ';' before 'jsonBuffer'
teste2wifi_Mananger_copia:155: error: 'jsonBuffer' was not declared in this scope
teste2wifi_Mananger_copia:156: error: 'class ArduinoJson::JsonObject' has no member named 'printTo'
teste2wifi_Mananger_copia:157: error: 'class ArduinoJson::JsonObject' has no member named 'success'
C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:213:16: warning: 'BUILTIN_LED' is deprecated (declared at C:\Users\luciano\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.1\variants\generic/common.h:78) [-Wdeprecated-declarations]
teste2wifi_Mananger_copia:219: error: 'DynamicJsonBuffer' was not declared in this scope
C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:219:5: note: suggested alternative:
In file included from C:\Users\luciano\Documents\Arduino\libraries\ArduinoJson\src/ArduinoJson/DynamicJsonDocument.hpp:10:0,
from C:\Users\luciano\Documents\Arduino\libraries\ArduinoJson\src/ArduinoJson.hpp:9,
from C:\Users\luciano\Documents\Arduino\libraries\ArduinoJson\src/ArduinoJson.h:9,
from C:\Users\luciano\Documents\Arduino\teste2wifi_Mananger _ Cópia\teste2wifi_Mananger_copia\teste2wifi_Mananger_copia.ino:13:
C:\Users\luciano\Documents\Arduino\libraries\ArduinoJson\src/ArduinoJson/Memory/DynamicJsonBuffer.hpp:159:5: note: 'ArduinoJson::Internals::DynamicJsonBuffer'
DynamicJsonBuffer;
^
teste2wifi_Mananger_copia:219: error: expected ';' before 'jsonBuffer'
teste2wifi_Mananger_copia:220: error: 'jsonBuffer' was not declared in this scope
teste2wifi_Mananger_copia:228: error: 'class ArduinoJson::JsonObject' has no member named 'printTo'
teste2wifi_Mananger_copia:229: error: 'class ArduinoJson::JsonObject' has no member named 'printTo'
exit status 1'Blynk' does not name a type…
is connected to pin A0 #define BAT_ADC A1 // Battery side voltage divider is connected to pin A1#define CURRENT_ADC A2 // ACS 712 current sensor is connected to pin A2#define TEMP_ADC A3 // LM 35 Temperature is connected to pin A3#define AVG_NUM 10 // number of iterations of the adc routine to average the adc readings#define BAT_MIN 10.5 // minimum battery voltage for 12V system#define BAT_MAX 15.0 // maximum battery voltage for 12V system#define BULK_CH_SP 14.4 // bulk charge set point for sealed lead acid battery // flooded type set it to 14.6V#define FLOAT_CH_SP 13.6 //float charge set point for lead acid battery#define LVD 11.5 //Low voltage disconnect setting for a 12V system#define PWM_PIN 3 // pin-3 is used to control the charging MOSFET //the default frequency is 490.20Hz#define LOAD_PIN 2 // pin-2 is used to control the load#define BAT_RED_LED 5#define BAT_GREEN_LED 6#define BAT_BLUE_LED 7#define LOAD_RED_LED 8#define LOAD_GREEN_LED 9//--------------------------------------------------------------------------------------------------------------------------///////////////////////DECLARATION OF ALL BIT MAP ARRAY FOR FONTS//////////////////////////////////////////////////////////////////--------------------------------------------------------------------------------------------------------------------------
byte solar[8] = //icon for solar panel{ 0b11111,0b10101,0b11111,0b10101,0b11111,0b10101,0b11111,0b00000};byte battery[8] = //icon for battery{ 0b01110,0b11011,0b10001,0b10001,0b10001,0b10001,0b10001,0b11111};
byte energy[8] = // icon for power{ 0b00010,0b00100,0b01000,0b11111,0b00010,0b00100,0b01000,0b00000};/*byte alarm[8] = // icon for alarm{ 0b00000,0b00100,0b01110,0b01110,0b01110,0b11111,0b00000,0b00100};*/byte temp[8] = //icon for termometer{ 0b00100,0b01010,0b01010,0b01110,0b01110,0b11111,0b11111,0b01110};
byte charge[8] = // icon for battery charge{ 0b01010,0b11111,0b10001,0b10001,0b10001,0b01110,0b00100,0b00100,};byte not_charge[8]={ 0b00000,0b10001,0b01010,0b00100,0b01010,0b10001,0b00000,0b00000,};
//--------------------------------------------------------------------------------------------------------------------------///////////////////////DECLARATION OF ALL GLOBAL VARIABLES////////////////////////////////////////////////////////////////////--------------------------------------------------------------------------------------------------------------------------float solar_volt=0;float bat_volt=0;float load_current=0;int temperature=0;int temp_change=0;float system_volt=0;float bulk_charge_sp=0;float float_charge_sp=0;float charge_status=0;float load_status=0;float error=0;float Ep=0;int duty =0;float lvd;float msec=0;float last_msec=0;float elasped_msec=0;float elasped_time=0;float ampSecs = 0;float ampHours=0;float watts=0;float wattSecs = 0;float wattHours=0;
// Set the pins on the I2C chip used for LCD connections:// addr, en,rw,rs,d4,d5,d6,d7,bl,blpolLiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Set the LCD I2C address // In my case 0x27//******************************************************* MAIN PROGRAM START ************************************************void setup(){
Serial.begin(9600);pinMode(BAT_RED_LED,OUTPUT);pinMode(BAT_GREEN_LED,OUTPUT);pinMode(BAT_BLUE_LED,OUTPUT);pinMode(LOAD_RED_LED ,OUTPUT);pinMode(LOAD_GREEN_LED,OUTPUT);pinMode(PWM_PIN,OUTPUT);pinMode(LOAD_PIN,OUTPUT);digitalWrite(PWM_PIN,LOW); // default value of pwm duty cycledigitalWrite(LOAD_PIN,LOW); // default load state is OFFlcd.begin(20,4); // initialize the lcd for 16 chars 2 lines, turn on backlightlcd.backlight(); // finish with backlight on lcd.createChar(1,solar);lcd.createChar(2, battery);lcd.createChar(3, energy);//lcd.createChar(4,alarm);lcd.createChar(5,temp);lcd.createChar(6,charge);lcd.createChar(7,not_charge);lcd.clear();}
void loop(){ read_data(); // read different sensors data from analog pin of arduino system_voltage(); // detect the system voltage according to battery voltage setpoint(); // decide the charge set point according to system voltage charge_cycle(); // pwm charging of battery power(); // calculate the load power and energy load_control(); //control the load led_indication(); // led indica print_data(); // print in serial monitor lcd_display(); // lcd display }//************************************************************ PROGRAM END *************************************************
//------------------------------------------------------------------------------------------------------////////////////// READS AND AVERAGES THE ANALOG INPUTS (SOLRAR VOLTAGE,BATTERY VOLTAGE)//////////////////------------------------------------------------------------------------------------------------------int read_adc(int adc_parameter){ int sum = 0; int sample ; for (int i=0; i<AVG_NUM; i++) { // loop through reading raw adc values AVG_NUM number of times sample = analogRead(adc_parameter); // read the input pin sum += sample; // store sum for averaging delayMicroseconds(50); // pauses for 50 microseconds } return(sum / AVG_NUM); // divide sum by AVG_NUM to get average and return it}//-------------------------------------------------------------------------------------------------------------////////////////////////////////////READ THE DATA////////////////////////////////////////////////////////////////------------------------------------------------------------------------------------------------------------- void read_data(void) { //5V = ADC value 1024 => 1 ADC value = (5/1024)Volt= 0.0048828Volt // Vout=Vin*R2/(R1+R2) => Vin = Vout*(R1+R2)/R2 R1=100 and R2=20 solar_volt = read_adc(SOL_ADC)*0.00488*(120/20); bat_volt = read_adc(BAT_ADC)*0.00488*(120/20); load_current = (read_adc(CURRENT_ADC)*.0488 -25); temperature = read_adc(TEMP_ADC)*0.00488*100; } //------------------------------------------------------------------------------------------------------------/////////////////////////////////POWER AND ENERGY CALCULATION ////////////////////////////////////////////////------------------------------------------------------------------------------------------------------------void power(void)
{msec = millis();elasped_msec = msec - last_msec; //Calculate how long has past since last call of this functionelasped_time = elasped_msec / 1000.0; // 1sec=1000 msecwatts = load_current * bat_volt; //Watts nowampSecs = (load_current*elasped_time); //AmpSecs since last measurementwattSecs = ampSecs * bat_volt; //WattSecs since last measurementampHours = ampHours + ampSecs/3600; // 1 hour=3600sec //Total ampHours since program startedwattHours = wattHours + wattSecs/3600; // 1 hour=3600sec //Total wattHours since program startedlast_msec = msec; //Store 'now' for next time}
//------------------------------------------------------------------------------------------------------------/////////////////////////////////PRINT DATA IN SERIAL MONITOR///////////////////////////////////////////////////------------------------------------------------------------------------------------------------------------ void print_data(void) { delay(100); Serial.print("Solar Panel Voltage: "); Serial.print(solar_volt); Serial.println("V"); Serial.print("Battery Voltage: "); Serial.print(bat_volt); Serial.println("V"); Serial.print("Syestem Voltage: "); Serial.print(system_volt); Serial.println("V"); Serial.print("Charge Set Point:"); Serial.println(bulk_charge_sp); Serial.print("Temperature:"); Serial.print(temperature); Serial.println("C"); Serial.print("Load Current: "); Serial.print(load_current); Serial.println("A"); Serial.print("Power: "); Serial.print(watts); Serial.println("W"); Serial.print("Energy: "); Serial.print(wattHours); Serial.println("WH"); Serial.print("Duty Cycle :"); if (charge_status==1) { Serial.println("99%"); Serial.println("BULK CHARGING"); } else if (charge_status==2) { Serial.print(Ep); Serial.println("%"); Serial.println("FLOAT CHARGING"); } else { Serial.println("0%"); Serial.println("NOT CHARGING"); } if(load_status==1) { Serial.println("LOAD IS CONNECTED"); } else { Serial.println("LOAD IS DISCONNECTED"); } Serial.println("***************************"); }//----------------------------------------------------------------------------------------------------------------------//////////////////////////////////SYSTEM VOLTAGE AUTO DETECT /////////////////////////////////////////////////////////////----------------------------------------------------------------------------------------------------------------------void system_voltage(void){ if ((bat_volt >BAT_MIN) && (bat_volt < BAT_MAX)) { system_volt = 12; } /* else if ((bat_volt > BAT_MIN*2 ) && (bat_volt < BAT_MAX*2)) { system_volt=24; }*/ else if ((bat_volt > BAT_MIN/2 ) && (bat_volt < BAT_MAX/2)) { system_volt=6; } }//--------------------------------------------------------------------------------------------------------------------------- ////////////////////////////////////CHARGE SET POINT /////////////////////////////////////////////////////////////////////////--------------------------------------------------------------------------------------------------------------------------- void setpoint(void){ temp_change =temperature-25.0; // 25deg cel is taken as standard room temperature // temperature compensation = -5mv/degC/Cell // If temperature is above the room temp ;Charge set point should reduced // If temperature is bellow the room temp ;Charge set point should increased if(system_volt ==12) { bulk_charge_sp = BULK_CH_SP-(0.030*temp_change) ; float_charge_sp=FLOAT_CH_SP-(0.030*temp_change) ; lvd =LVD; } else if(system_volt ==6) { bulk_charge_sp = (BULK_CH_SP/2)-(0.015*temp_change) ; float_charge_sp= (FLOAT_CH_SP/2)-(0.015*temp_change) ; lvd=LVD/2; } /* else if (system_volt == 24) { bulk_charge_sp = (BULK_CH_SP*2)-(0.060*temp_change) ; float_charge_sp= (FLOAT_CH_SP*2)-(0.060*temp_change) ; lvd=LVD*2; } */ }//-------------------------------------------------------------------------------------------------------------------------------- ///////////////////////////////////////////////////PWM CHARGE CYCLE @500 HZ ////////////////////////////////////////////////// //-------------------------------------------------------------------------------------------------------------------------------void charge_cycle(void){ if (solar_volt > bat_volt && bat_volt <= bulk_charge_sp) { if (bat_volt <= float_charge_sp) // charging start { charge_status = 1; // indicate the charger is in BULK mode duty= 252.45; analogWrite(PWM_PIN,duty); // 99 % duty cycle // rapid charging } else if (bat_volt >float_charge_sp && bat_volt <= bulk_charge_sp) { charge_status = 2; // indicate the charger is in FLOAT mode error = (bulk_charge_sp - bat_volt); // duty cycle reduced when the battery voltage approaches the charge set point Ep= error *100 ; //Ep= error* Kp // Assume Kp=100 if(Ep < 0) { Ep=0; } else if(Ep>100) { Ep=100; } else if(Ep>0 && Ep <=100) // regulating { duty = (Ep*255)/100; } analogWrite(PWM_PIN,duty); } } else { charge_status=0; // indicate the charger is OFF duty=0; analogWrite(PWM_PIN,duty); }}//----------------------------------------------------------------------------------------------------------------------/////////////////////////////////////////////LOAD CONTROL///////////////////////////////////////////////////////---------------------------------------------------------------------------------------------------------------------- void load_control(){ if (solar_volt < 5 ) // load will on when night{ if(bat_volt >lvd) // check if battery is healthy { load_status=1; digitalWrite(LOAD_PIN, HIGH); // load is ON } else if(bat_volt < lvd) { load_status=0; digitalWrite(LOAD_PIN, LOW); //load is OFF } } else // load will off during day { load_status=0; digitalWrite(LOAD_PIN, LOW); }}
//-------------------------------------------------------------------------------------------------//////////////////////////LED INDICATION//////////////////////////////////////-------------------------------------------------------------------------------------------------void led_indication(void){ battery_led(); //Battery status led indication load_led(); //Load led indication}
//----------------------------------------------------------------------------------------------------------------------/////////////////////////////////////////////BATTERY LED INDICATION///////////////////////////////////////////////////////----------------------------------------------------------------------------------------------------------------------void battery_led(void){ if( (bat_volt > system_volt) && ( bat_volt <bulk_charge_sp)) { leds_off_all(); digitalWrite(BAT_GREEN_LED,LOW); // battery voltage is healthy } else if(bat_volt >= bulk_charge_sp) { leds_off_all(); digitalWrite(BAT_BLUE_LED,LOW); //battery is fully charged } else if(bat_volt < system_volt) { leds_off_all(); digitalWrite(BAT_RED_LED,LOW); // battery voltage low }}//----------------------------------------------------------------------------------------------------------------------/////////////////////////////////////////////LOAD LED INDICATION///////////////////////////////////////////////////////---------------------------------------------------------------------------------------------------------------------- void load_led() { if(load_status==1) { digitalWrite(LOAD_GREEN_LED,HIGH); } else if(load_status==0) { digitalWrite(LOAD_RED_LED,HIGH); } }
//------------------------------------------------------------------------------------------------------//////////////////////// TURN OFF ALL THE LED/////////////////////////////////////////////////////////////------------------------------------------------------------------------------------------------------void leds_off_all(void){ digitalWrite(BAT_RED_LED,HIGH); digitalWrite(BAT_GREEN_LED,HIGH); digitalWrite(BAT_BLUE_LED,HIGH); digitalWrite(LOAD_RED_LED, LOW); digitalWrite(LOAD_GREEN_LED, LOW);}//------------------------------------------------------------------------------------------------------//////////////////////// LCD DISPLAY/////////////////////////////////////////////////////////////------------------------------------------------------------------------------------------------------void lcd_display(){ lcd.setCursor(0, 0); lcd.write(1); lcd.setCursor(2, 0); lcd.print(solar_volt); lcd.print("V"); lcd.setCursor(14, 0); lcd.write(5); lcd.setCursor(16, 0); lcd.print(temperature); lcd.write(0b11011111); lcd.print("C"); lcd.setCursor(0,1); lcd.write(2); lcd.setCursor(2, 1); lcd.print(bat_volt); lcd.print("V"); lcd.setCursor(14, 1); lcd.write(2); if((charge_status==1) | (charge_status== 2)) { lcd.write(6); } else { lcd.write(7); } lcd.setCursor(0,2); lcd.write(3); lcd.setCursor(2,2); lcd.print(load_current); lcd.print("A"); lcd.setCursor(13,2); lcd.print(watts); lcd.print("W"); lcd.setCursor(0,3); lcd.print("Energy:"); lcd.print(wattHours); lcd.print("WH");
}…
om 10 botoes, blz! fiz a montagem e envie o código que foi criado pelo dono do projeto ao Arduino e tudo funcionou perfeitamente, esta aplicação estou usando em minha casa para acionamento de cargas: lampadas tvs e ventiladores e etc... ate aqui tudo tranquilo, acesso pela internet via celular na rede interna e externa tudo perfeito. Agora vou falar o que preciso, eu não sei quase nada de programação da linguagem C++, criei um aplicativo no MIT Inventor 2 e gostaria de usar o meu próprio aplicativo, não sei como criar as regras nos código para enviar para ao arduino é nisso que gostaria da ajuda de meus caros amigos deste conceituado fórum, estou tentando ler algumas coisas sobre este assunto, mais ainda não cheguei a entender, por isso que venho aqui, tentar alguns esclarecimento se possível para acrescentar no desenvolvimento de meus conhecimentos para esta necessidade.
Segue abaixo aplicativo que criei para Android:
tem as duas imagens ON e OFF, pra quando eu clicar ela mudaria a imagem para ON e vise-verso
O aplicativo e o código a baixo é o que eu comprei na PlayStore e está funcionado perfeitamente, gostaria de poder trocar os nomes laterais aos botoes e personalizar de acordo com minhas necessidade. ex colocar o nome do primeiro botão ao invés de ser "A0 OUT 5V" para "GARAGEM" não sei se isto seria melhor, não sei onde estão estas informações no código. agradeço se me for esclarecido estas duvidas.
#include <SPI.h>
#include <String.h>
#include <Ethernet.h>
//-------------------------------------------------------------------
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };//MAC padrão;
IPAddress ip(192, 168, 1, 120);//Define o endereco IPv4(trocar final);
IPAddress gateway(192, 168, 1, 1); //Define o gateway
IPAddress subnet(255, 255, 255, 0); //Define a máscara de rede
EthernetServer server(8090); // Porta de serviço
//-------------------------------------------------------------------
int AA0 = A0;//Arduino analogica A0;
int AA1 = A1;//Arduino analogica A1;
int AA2 = A2;//Arduino analogica A2;
int AA3 = A3;//Arduino analogica A3;
int AA4 = A4;//Arduino analogica A4;
//-------------------------------------------------------------------
int D2 = 2;//Arduino digital D2; int D3 = 3;//Arduino digital D3; int D4 = 4;//Arduino digital D4; int D5 = 5;//Arduino digital D5; int D6 = 6;//Arduino digital D6; //------------------------------------------------------------------- String readString = String(30); // string para buscar dados de endereço boolean statusA0 = false; // Variável para o status do led boolean statusA1 = false; // Variável para o status do led boolean statusA2 = false; // Variável para o status do led boolean statusA3 = false; // Variável para o status do led boolean statusA4 = false; // Variável para o status do led boolean statusD2 = false; // Variável para o status do led boolean statusD3 = false; // Variável para o status do led boolean statusD4 = false; // Variável para o status do led boolean statusD5 = false; // Variável para o status do led boolean statusD6 = false; // Variável para o status do led //-------------------------------------------------------------------- void setup(){ // Inicia o Ethernet //Ethernet.begin(mac, ip); Ethernet.begin(mac, ip, gateway, subnet); server.begin(); //-----------------------Define pino como saída----------------------- pinMode(AA0, OUTPUT); pinMode(AA1, OUTPUT); pinMode(AA2, OUTPUT); pinMode(AA3, OUTPUT); pinMode(AA4, OUTPUT); pinMode(D2, OUTPUT); pinMode(D3, OUTPUT); pinMode(D4, OUTPUT); pinMode(D5, OUTPUT); pinMode(D6, OUTPUT); //--------------------------------------------------------------------- // Inicia a comunicação Serial Serial.begin(9600); }
void loop(){ // 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') { //------------------------------------------------------------------ if(readString.indexOf("a0high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(AA0, HIGH);//Arduino porta digital D2=5V; statusA0 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("a0low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(AA0, LOW);//Arduino porta digital D2=0V; statusA0 = false; } //------------------------------------------------------------------ if(readString.indexOf("a1high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(AA1, HIGH);//Arduino porta digital D2=5V; statusA1 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("a1low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(AA1, LOW);//Arduino porta digital D2=0V; statusA1 = false; } //------------------------------------------------------------------ if(readString.indexOf("a2high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(AA2, HIGH);//Arduino porta digital D2=5V; statusA2 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("a2low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(AA2, LOW);//Arduino porta digital D2=0V; statusA2 = false; } //------------------------------------------------------------------ if(readString.indexOf("a3high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(AA3, HIGH);//Arduino porta digital D2=5V; statusA3 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("a3low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(AA3, LOW);//Arduino porta digital D2=0V; statusA3 = false; } //------------------------------------------------------------------ if(readString.indexOf("a4high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(AA4, HIGH);//Arduino porta digital D2=5V; statusA4 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("a4low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(AA4, LOW);//Arduino porta digital D2=0V; statusA4 = false; } //------------------------------------------------------------------ if(readString.indexOf("d2high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(D2, HIGH);//Arduino porta digital D2=5V; statusD2 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("d2low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(D2, LOW);//Arduino porta digital D2=0V; statusD2 = false; } //------------------------------------------------------------------ if(readString.indexOf("d3high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(D3, HIGH);//Arduino porta digital D2=5V; statusD3 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("d3low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(D3, LOW);//Arduino porta digital D2=0V; statusD3 = false; } //------------------------------------------------------------------ if(readString.indexOf("d4high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(D4, HIGH);//Arduino porta digital D2=5V; statusD4 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("d4low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(D4, LOW);//Arduino porta digital D2=0V; statusD4 = false; } //------------------------------------------------------------------ if(readString.indexOf("d5high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(D5, HIGH);//Arduino porta digital D2=5V; statusD5 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("d5low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(D5, LOW);//Arduino porta digital D2=0V; statusD5 = false; } //------------------------------------------------------------------ if(readString.indexOf("d6high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(D6, HIGH);//Arduino porta digital D2=5V; statusD6 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("d6low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(D6, LOW);//Arduino porta digital D2=0V; statusD6 = false; } //------------------------------------------------------------------ // 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.print("<font size='20'>"); //------------------------------------------------------------------ if (statusA0) { client.print("azeroon");//Ethernet envia para Android; //String apenas letras; } else { client.print("azerooff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusA1) { client.print("aoneon");//Ethernet envia para Android; //String apenas letras; } else { client.print("aoneoff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusA2) { client.print("atwoon");//Ethernet envia para Android; //String apenas letras; } else { client.print("atwooff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusA3) { client.print("athreeon");//Ethernet envia para Android; //String apenas letras; } else { client.print("athreeoff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusA4) { client.print("afouron");//Ethernet envia para Android; //String apenas letras; } else { client.print("afouroff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusD2) { client.print("dtwoon");//Ethernet envia para Android; //String apenas letras; } else { client.print("dtwooff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusD3) { client.print("dthreeon");//Ethernet envia para Android; //String apenas letras; } else { client.print("dthreeoff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusD4) { client.print("dfouron");//Ethernet envia para Android; //String apenas letras; } else { client.print("dfouroff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusD5) { client.print("dfiveon");//Ethernet envia para Android; //String apenas letras; } else { client.print("dfiveoff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusD6) { client.print("dsixon");//Ethernet envia para Android; //String apenas letras; } else { client.print("dsixoff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ //limpa string para a próxima leitura readString=""; // parar cliente client.stop(); } } } } }…
uestão aqui é qual é a natureza do sinal que ele está aquisitando. Ou seja, qual a frequência do sinal que ele está aquisitando via ADC do Due. A amplitude ele já deve ter tratado adequadamente, uma vez que ele já vê o sinal na Serial Plotter da IDE do Arduino. Mas nada sabemos sobre a frequência do sinal.
Conhecendo a frequência do sinal é possível determinar a técnica mais adequada para a aquisição e posterior visualização do sinal aquisitado. E claro, aí entra a Frequência de Nyquist, e conhecendo a mesma é possível determinar qual a menor Taxa de Amostragem para a aquisição, mantendo a qualidade desejada para a reprodução digital do sinal.
Veja: o loop de aquisição do Thiago funciona a "todo vapor", na máxima velocidade que o Due permite (Hardware e Firmware). O ADC do Due tem uma taxa de conversão máxima de 1MHz, ou seja, resulta em 1 Mega sample por segundo. Considerando que o Due utiliza um ARM, e que o Compilador C++ tenha gerado um código com "boa" performance, é quase certo que o loop de conversão gastará para ser executado um tempo igual a 1000 / 1MHz = 1 ms , ou seja, 1 mili-segundo. E isto seria "adequado" para um sinal de no máximo 500kHz e com um Processamento de Sinal também adequado (aplicando técnicas para a reconstituição do sinal). Caso nenhum Processamento de Sinal seja aplicado, como é o caso do Thiago, então temos que reduzir drasticamente a faixa de frequência do sinal, tipo 10 a 20 vezes menor que a Frequência de Nyquist, para que seja algo apresentável na tela do Serial Plotter.
Mas aqui entra o outro problema: cada "println" no loop de "printagem" dos 1000 valores aquisitados, enviará em média, 6 caracteres ASCII para a serial. Desses 6 caracteres, 4 são considerando valores convertidos da ordem de 4 dígitos decimais, ou seja, entre 1000 e 4095 (o ADC do Due tem 12 bits). Não se pode aqui considerar nessa estimativa, valores inferiores a 1000 (que resultariam em 3, 2, ou 1 caracter ASCII para o valor do sample), pois são apenas 1/4 da faixa total, e assim representam 25% da probabilidade (e portanto errôneo considerar isso numa estimativa "grosseira", que é o caso que estou fazendo). Os outros 2 caracteres ASCII, são o "CR" e o "LF" resultantes do "println".
Logo, para cada "println", em média teremos 6 caracteres ASCII sendo enviados pela Serial. Como a taxa da Serial está em 115200, e cada caractere ocupa 10 bits (1 start bit, 8 data, 1 stop bit), o tempo total necessário para o envio de cada valor via Serial, será igual a 6 * 10 / 115200 = 0.00052 segundos, ou 0.52 ms (aproximadamente meio mili-segundo). Então aparentemente, multiplicando esse tempo por 1000, teremos o total gasto para enviar todas as 1000 amostras = 0.52 segundos (cerca de meio segundo).
Infelizmente, a coisa é um pouco pior. Vou explicar porquê. Quando vc "manda" enviar um byte via Serial, o firmware do Due verifica se o TX da UART (Hardware) está livre, e caso esteja, o byte é transferido direto para o Registro do TX da UART. Mas se o TX já está ocupado transmitindo, então o firmware coloca o byte no Queue do TX da Serial, e este byte será automaticamente transmitido quando o TX ficar livre. Ocorre que o Queue do TX da Serial do Due, tem capacidade para 128 bytes, ou seja, 128 caracteres. Uma vez que um byte tenha sido enviado ao TX da UART, esse byte demorará 87us (87 micro-segundos = resultado de 10 / 115200) para ser enviado. Obviamente que todo o loop de envio não demorará mais que esse tempo (lembrando que é um ARM), então certamente o Queue de 128 bytes ficará entupido após algum tempo (perfeitamente calculável, analisando as iterações iniciais), e quando isso ocorre, o firmware do Due empaca (há um teste no código da Serial que causa isso intencionalmente), e então fica aguardando que o Queue fique pelo menos um byte livre. Mas claro, assim que essa "vaga" fica livre no Queue, ele já entope de novo com o próximo byte que estava esperando para entrar neste Queue do TX.
Em suma: após uma quantidade de caracteres um pouco maior que 128, o Queue do TX da Serial ficará permanentemente entupido no loop de envio, no código do Thiago. E aí a função "println" trava pelo tempo de envio de todos os demais caracteres que restam para serem enviados. Lembrando que cada valor "impresso" via "println", irá gerar em média 6 caracteres, resultando um total de 6 mil caracteres para serem enviados. Então os cerca de um pouco mais de 128 bytes necessários para o entupimento do Queue do TX da Serial, e a consequente "lerdeza" na execução do loop onde está o "println", é uma parcela pequena se comparada aos 6 mil caracteres que serão enviados. Ou seja, um grande problema para a descontinuidade da aquisição de samples, se a frequência do sinal aquisitado for tal que o entupimento do Queue cause uma descaracterização do sinal visto no Serial Plotter.
Claro, sempre é possível usar técnicas de contorno. Mas é preciso saber qual a natureza do sinal aquisitado, especificamente sua faixa de frequência.
Abrçs,
Elcids…
Adicionado por Elcids Chagas ao 16:50 em 23 setembro 2020
o o primeiro o modo estaconário, o segundo o modo LDR, e o terceiro entra no modo RTC DS 1302.
A lógica é a seguinte: no modo LDR ele faz a varredura pela diferença entre os LDRs e faz o movimento dos motores de modo a posicionar o módulo em direção ao sol, (essa parte está ok). O modo RTC vai ter 12 posicoes pré determinadas, dependendo apenas da hora do dia (ESSA PARTE É O PROBLEMA), já o modo estacionário vai ficar parado em uma inclinação especifica(ESSA PARTE ESTÀ OK). A idéia por tras disso é a seguinte: a cada hora vou medir corrente e tensão no módulo, e quero comparar a eficiencia dos 3 modos distintos. Estou utilizando Arduino UNO, DVR 8825 controlador de motor de passo LDRs e DS 1302 RTC. O Código está assim por enquanto;
#include <AccelStepper.h>#include <ThreeWire.h>#include <RtcDS1302.h>
// Pinos dos sensores LDR
int ldrLeftTopPin = A2; // amaint ldrLeftBottomPin = A0; // verint ldrRightTopPin = A3; // larint ldrRightBottomPin = A1; // preint limiar = 20; // Valor para corrigir diferença entre os LDR'sint Vel = 500; // Velocidade do motor em passos por segudoint MaxSpeed = 1000; // Velocidade máxima que o motor pode atingirint Acelera = 500; // Aceleração dos motoresint modo = 0;// 0 = Estacionário, 1 = LDR, 2 = DS1302int BUTTON_PIN = 7; // Pino do botãoconst int NUM_MODOS = 3;
// Pinos dos motores de passo#define azimuthDirPin 2#define azimuthStepPin 3#define elevationDirPin 4#define elevationStepPin 5#define motorInterfaceType 1 //Motor com dois fios para cada bobina (2 bobinas)
// Pinos RTC#define DS1302_RST 8#define DS1302_DAT 9#define DS1302_CLK 10
// Instância da ligação e do RTCThreeWire ligacao(DS1302_DAT, DS1302_CLK, DS1302_RST);RtcDS1302<ThreeWire> rtc(ligacao);bool buttonWasPressed = false;bool buttonState = false;bool lastButtonState = false;unsigned long lastDebounceTime = 0;unsigned long debounceDelay = 50;
// Instância da classe AccelStepper para cada motorAccelStepper azimuthStepper(motorInterfaceType, azimuthStepPin, azimuthDirPin);AccelStepper elevationStepper(motorInterfaceType, elevationStepPin, elevationDirPin);
void setup() { // Inicia a comunicação serial Serial.begin(9600); // Velocidade máxima em passos por segundo para ambos os motores azimuthStepper.setMaxSpeed(MaxSpeed); azimuthStepper.setAcceleration(Acelera); elevationStepper.setMaxSpeed(MaxSpeed); elevationStepper.setAcceleration(Acelera); pinMode(BUTTON_PIN, INPUT_PULLUP); // Inicia a comunicação com o RTC rtc.Begin(); // Desabilita a proteção contra escrita para gravar a hora e data if (rtc.GetIsWriteProtected()) { rtc.SetIsWriteProtected(false); }
// Se não estava rodando, começa a funcionar if (!rtc.GetIsRunning()) { rtc.SetIsRunning(true); // Obtém o valor da hora quando o código foi compilado RtcDateTime compiled = RtcDateTime(__DATE__, __TIME__); rtc.SetDateTime(compiled); // Para definir um formato personalizado, você pode fazer o seguinte: // O mês precisa ter 3 letras abreviando o nome do mês em inglês (no exemplo abaixo é fevereiro) //RtcDateTime teste = RtcDateTime("Feb 12 2022", "19:32:45"); //rtc.SetDateTime(teste); }}
void loop() { unsigned long currentMillis = millis(); buttonState = digitalRead(BUTTON_PIN);
if (buttonState != lastButtonState) { lastDebounceTime = currentMillis; }
if ((currentMillis - lastDebounceTime) > debounceDelay) { if (buttonState != buttonWasPressed) { buttonWasPressed = buttonState;
if (buttonWasPressed) { // Botão pressionado, alterna entre os modos modo = (modo + 1) % NUM_MODOS; } } }
lastButtonState = buttonState; switch (modo) { case 0: // Modo Estacionário // Coloque o código para o modo estacionário aqui Serial.print("MODO : " ); // Mostra o valor no monitor serial Serial.println(modo); break;
case 1: // Modo LDR Serial.print("MODO : " ); // Mostra o valor no monitor serial Serial.println(modo); // Leitura dos sensores LDR int ldrLeftTopValue = analogRead(ldrLeftTopPin); int ldrLeftBottomValue = analogRead(ldrLeftBottomPin); int ldrRightTopValue = analogRead(ldrRightTopPin); int ldrRightBottomValue = analogRead(ldrRightBottomPin);
// Calculando as diferenças para ambos os eixos int azimuthDifference = (ldrLeftTopValue - ldrRightTopValue) + (ldrLeftBottomValue - ldrRightBottomValue); int elevationDifference = (ldrLeftTopValue - ldrLeftBottomValue) + (ldrRightTopValue - ldrRightBottomValue); // Ajustando a posição dos motores de passo com base nas diferenças dos sensores if (abs(azimuthDifference) > limiar) { // Limiar de diferença para evitar pequenos movimentos if (azimuthDifference > 0) { // Mova o motor de passo de azimuth para a esquerda azimuthStepper.setSpeed(Vel); azimuthStepper.runSpeed(); // Move o motor } else { // Mova o motor de passo de azimuth para a direita azimuthStepper.setSpeed(-Vel); // (sentido inverso) azimuthStepper.runSpeed(); // Move o motor } }
if (abs(elevationDifference) > limiar) { // Limiar de diferença para evitar pequenos movimentos if (elevationDifference > 0) { // Mova o motor de passo de elevação para cima elevationStepper.setSpeed(Vel); // elevationStepper.runSpeed(); // Move o motor } else { // Mova o motor de passo de elevação para baixo elevationStepper.setSpeed(-Vel); // (sentido inverso) elevationStepper.runSpeed(); // Move o motor } } break; case 2: // Modo DS1302 Serial.print("MODO : " ); // Mostra o valor no monitor serial Serial.println(modo); // Obtem a data e hora e imprime os valores RtcDateTime now = rtc.GetDateTime();
Serial.print(now.Day()); Serial.print("/"); Serial.print(now.Month()); Serial.print("/"); Serial.println(now.Year());
Serial.print(now.Hour()); Serial.print(":"); Serial.print(now.Minute()); Serial.print(":"); Serial.println(now.Second());
// Dia da semana (1 a 7, sendo 1 = segunda e 7 = domingo) Serial.println(now.DayOfWeek()); delay(50); break; }}…