Resultados da busca - %E6%9D%8F%E5%BD%A9%E5%B9%B3%E5%8F%B0170%E5%88%B01840%E5%88%86%E5%88%AB%E4%BB%A3%E8%A1%A8%E4%BB%80%E4%B9%88%E6%84%8F%E6%80%9D?%E3%80%90%E2%94%83%E8%81%94%E7%B3%BB%EF%BC%9217431(%E6%89%A3)%E3%80%91%E3%80%91
ial, e também saber se está passando corrente ou não no circuito, caso esteja envia para serial se L1 está ou não Ligado, até aqui tudo bem!
2- Problema, quando vou ligar a Lampada acionando S1 por exemplo, preciso persistir várias vezes pressionando o Pushbutton para conseguir ligar ou desligar, acredito que esse problema está relacionado ao comando de delay ou DEBOUNCE_DELAY que está na programação, estive verificando também que é melhor utilizar o Millis ou uma biblioteca TimerOne, porem já quebrei a cabeça tentando implementar uma das duas funções e não estou conseguindo, seria ótimo se tiverem uma dica para eu conseguir acertar esse problema, Agradeço desde-já!
segue o Código:
//Saídasint E0 = 2;int E1 = 3;int E2 = 4;int E3 = 5;int E4 = 6;int E5 = 7;int E6 = 8;int E7 = 9;int E8 = 10;int E9 = 11;int E10 = 12;int E11 = 13;int E12 = 14;int E13 = 15;int E14 = 16;int E15 = 17;
//Entradasconst int S1 = 20;const int S2 = 21;const int S3 = 22;const int S4 = 23;const int S5 = 24;const int S6 = 25;const int S7 = 26;const int S8 = 27;const int S9 = 28;const int S10 = 29;const int S11 = 30;const int S12 = 31;const int S13 = 32;const int S14 = 33;const int S15 = 34;const int S16 = 35;
//Sensoresint pinoSensor = A0;
//Variaveis que recebe os dadosint sensorValue_aux = 0;//receberá os dados do sensorfloat valorSensor = 0;float valorCorrente = 0;float voltsporUnidade = 0.004887586; //5 dividido por 1023float sensibilidade = 0.066;int tensao = 127;int dado; //variável que receberá os dados da porta serial
//Ajuste de Debounce "S1"const long DEBOUNCE_DELAY0 = 100;int leitura_anterior0 = 1; int leitura_anterior_db0 = 1;long time_ultimo_debounce0 = 0;int debounce_0 = 1;
//Ajuste de Debounce "S2"const long DEBOUNCE_DELAY1 = 100;int leitura_anterior1 = 1; int leitura_anterior_db1 = 1;long time_ultimo_debounce1 = 0;int debounce_1 = 1;
void setup(){ Serial.begin(9600);//frequência da porta serial //Saídas pinMode(E0,OUTPUT); pinMode(E1,OUTPUT); pinMode(E2,OUTPUT); pinMode(E3,OUTPUT); pinMode(E4,OUTPUT); pinMode(E5,OUTPUT); pinMode(E6,OUTPUT); pinMode(E7,OUTPUT); pinMode(E8,OUTPUT); pinMode(E9,OUTPUT); pinMode(E10,OUTPUT); pinMode(E11,OUTPUT); //Entradas pinMode(S1,INPUT); pinMode(S2,INPUT); pinMode(S3,INPUT); pinMode(S4,INPUT); pinMode(S5,INPUT); pinMode(S6,INPUT); pinMode(S7,INPUT); pinMode(S8,INPUT); pinMode(S9,INPUT); pinMode(S10,INPUT); pinMode(S11,INPUT); pinMode(S12,INPUT); pinMode(S13,INPUT); pinMode(S14,INPUT); pinMode(S15,INPUT); pinMode(S16,INPUT); //Sensores pinMode(pinoSensor, INPUT);
} void loop(){ botao_0();}void botao_0(){ int leitura_atual0 = digitalRead(S1); if (leitura_atual0 != leitura_anterior0 ) { time_ultimo_debounce0 = millis(); debounce_0 = 0; } if ( (millis() - time_ultimo_debounce0) > DEBOUNCE_DELAY0 ) { debounce_0 = 0; } if (debounce_0 = 1){ if (leitura_atual0 == 0 && leitura_anterior_db0 == 1){ digitalWrite(E1, !digitalRead(E1)); } leitura_anterior_db0 = leitura_atual0; } leitura_anterior0 = leitura_atual0;
for(int i=10000; i>0; i--){ sensorValue_aux=(analogRead(pinoSensor) -511); valorSensor += pow(sensorValue_aux,2);}valorSensor = (sqrt(valorSensor/ 10000)) * voltsporUnidade;valorCorrente = (valorSensor/sensibilidade);
if(valorCorrente <= 0.095){ valorCorrente = 0; } valorSensor = 0; //Serial.println(valorCorrente); if(valorCorrente > 0.00){ Serial.println("L1: Ligado"); }else { Serial.println("L1: Desligado"); }
botao_1();}void botao_1(){int leitura_atual1 = digitalRead(S2); if (leitura_atual1 != leitura_anterior1 ) { time_ultimo_debounce1 = millis(); debounce_1 = 0; } if ( (millis() - time_ultimo_debounce1) > DEBOUNCE_DELAY1 ) { debounce_1 = 0; } if (debounce_1 = 1){ if (leitura_atual1 == 0 && leitura_anterior_db1 == 1){ digitalWrite(E2, !digitalRead(E2)); } leitura_anterior_db1 = leitura_atual1; } leitura_anterior1 = leitura_atual1;
delay(10); if(Serial.available() > 0){ //verifica se existe comunicação com a porta serial dado = Serial.read();//lê os dados da porta serial switch(dado){ case 1: digitalWrite(E0,HIGH); break; case 2: digitalWrite(E0,LOW); break; case 3: digitalWrite(E1,HIGH); break; case 4: digitalWrite(E1,LOW); break;
case 5: digitalWrite(E2,HIGH); break; case 6: digitalWrite(E2,LOW); break;
case 7: digitalWrite(E3,HIGH); break; case 8: digitalWrite(E3,LOW); break;
case 9: digitalWrite(E4,HIGH); break; case 10: digitalWrite(E4,LOW); break;
case 11: digitalWrite(E5,HIGH); break; case 12: digitalWrite(E5,LOW); break;
case 13: digitalWrite(E6,HIGH); break; case 14: digitalWrite(E6,LOW); break;
case 15: digitalWrite(E7,HIGH); break; case 16: digitalWrite(E7,LOW); break;
case 17: digitalWrite(E8,HIGH); break; case 18: digitalWrite(E8,LOW); break;
case 19: digitalWrite(E9,HIGH); break; case 20: digitalWrite(E9,LOW); break;
case 21: digitalWrite(E10,HIGH); break; case 22: digitalWrite(E10,LOW); break;
case 23: digitalWrite(E11,HIGH); break; case 24: digitalWrite(E11,LOW); break;
case 25: digitalWrite(E0,HIGH); digitalWrite(E1,HIGH); digitalWrite(E2,HIGH); digitalWrite(E3,HIGH); digitalWrite(E4,HIGH); digitalWrite(E5,HIGH); digitalWrite(E6,HIGH); digitalWrite(E7,HIGH); digitalWrite(E8,HIGH); digitalWrite(E9,HIGH); digitalWrite(E10,HIGH); digitalWrite(E11,HIGH); break; case 26: digitalWrite(E0,LOW); digitalWrite(E1,LOW); digitalWrite(E2,LOW); digitalWrite(E3,LOW); digitalWrite(E4,LOW); digitalWrite(E5,LOW); digitalWrite(E6,LOW); digitalWrite(E7,LOW); digitalWrite(E8,LOW); digitalWrite(E9,LOW); digitalWrite(E10,LOW); digitalWrite(E11,LOW); break;
} }}
…
gateway[] = { 192,168,1, 1 }; // ip do roteadorbyte subnet[] = { 255, 255, 0, 0 }; // String que representa o estado dos dispositivoschar Luz[7] = "0000L#"; EthernetServer server(80); // Cria o servidor na porta 8081EthernetServer server2(80); // String onde é guardada as msgs recebidaschar msg[7] = "0000L#";
float loadA = 0.173; //kgint analogvalA = 159; // Leitura analógico tomado com uma carga sobre a célula de carga
float loadB = 1.035; // kg int analogvalB = 834; // Leitura analógico tomado com uma carga sobre a célula de carga
// Carregar o esboço de novo, e confirmar , que a partir da saída serial lendo agora quilos está correta , usando suas cargas conhecidos
float analogValueAverage = A3;float analogValueAverage2 = A3;
// Quantas vezes fazemos leituras ?long time = 0; // int timeBetweenReadings = 200; // Nós queremos uma leitura a cada 200 ms;
float load;
float analogToLoad(float analogval){
// Usando um mapa - função personalizada, porque a função arduino mapa padrão utiliza apenas int
float load = mapfloat(analogval, analogvalA, analogvalB, loadA, loadB); return load;}
float mapfloat(float x, float in_min, float in_max, float out_min, float out_max){ return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;}
const int bot1 = A4;const int bot2 = A4;
boolean PrimeiroBotao; boolean SegundoBotao; void setup() { Ethernet.begin(mac, ip, gateway, subnet); server.begin(); pinMode(bot1,OUTPUT);pinMode(bot2,OUTPUT);}
void botao1(){
EthernetClient client = server.available(); int analogValue = analogRead(A3);
// Executando média - Nós suavizamos as leituras um pouco
analogValueAverage = 0.99*analogValueAverage + 0.01*analogValue;
load = analogToLoad(analogValueAverage);
// SE receber um caracter... if (client) { // guarda o caracter na string 'msg' msg[1]=msg[2]; msg[2]=msg[3]; msg[3]=msg[4]; msg[4]=msg[5]; msg[5]=msg[6]; msg[6] = client.read(); if (msg[6]=='#') { switch(msg[5]) { case 'R': // Se receber o comando 'R#' envia de volta o status dos // dispositivos. (Que é a string 'Luz') client.write(Luz); break;
case 'A': digitalWrite(bot1, HIGH); PrimeiroBotao = true;
break; }
} }
if ( load > 0.250 && load < 0.500 && PrimeiroBotao == true ) { digitalWrite(bot1, LOW); PrimeiroBotao == false; }
}
void botao2(){
EthernetClient client = server.available(); int analogValue = analogRead(A3);
// Executando média - Nós suavizamos as leituras um pouco
analogValueAverage = 0.99*analogValueAverage + 0.01*analogValue;
load = analogToLoad(analogValueAverage2); // SE receber um caracter... if (client) { // guarda o caracter na string 'msg' msg[1]=msg[2]; msg[2]=msg[3]; msg[3]=msg[4]; msg[4]=msg[5]; msg[5]=msg[6]; msg[6] = client.read(); if (msg[6]=='#') { switch(msg[5]) { case 'R': // Se receber o comando 'R#' envia de volta o status dos // dispositivos. (Que é a string 'Luz') client.write(Luz); break; case 'B': digitalWrite(bot2, HIGH); SegundoBotao = true; break; }
} }
if( load > 0.500 && SegundoBotao == true ) { digitalWrite(bot2, LOW); SegundoBotao == false; } }
void loop() {
botao1();
botao2();}…
Adicionado por Luiz Felipe ao 18:50 em 24 novembro 2015
uivo. Porém não consigo setar esses valores (o ip por exemplo) como sendo o valor a ser utilizado pelo shield.Codigo do Sketch:
########include <SPI.h>#include <Ethernet.h>#include <SD.h>#include <IniFile.h>
#define SD_SELECT 4#define ETHERNET_SELECT 10
EthernetServer server(80);
void setup() { Serial.begin(9600); while (!Serial) { ; }
//Sketch do ini pinMode(SD_SELECT, OUTPUT); digitalWrite(SD_SELECT, HIGH); // disable SD card
pinMode(ETHERNET_SELECT, OUTPUT); digitalWrite(ETHERNET_SELECT, HIGH); // disable Ethernet
const size_t bufferLen = 80; char buffer[bufferLen];
const char *filename = "/net.ini"; SPI.begin(); if (!SD.begin(SD_SELECT)) while (1) Serial.println("SD.begin() failed");
IniFile ini(filename); if (!ini.open()) { Serial.print("Ini file "); Serial.print(filename); Serial.println(" does not exist"); // Cannot do anything else while (1) ; } Serial.println("Ini file exists"); if (!ini.validate(buffer, bufferLen)) { Serial.print("ini file "); Serial.print(ini.getFilename()); Serial.print(" not valid: "); while (1) ; }
if (ini.getValue("network", "ip", buffer, bufferLen)) { Serial.print("section 'network' has an entry 'ip' with value "); Serial.println(buffer); } else { Serial.print("Could not read 'ip' from section 'network', error was "); //printErrorMessage(ini.getError()); } //fim do ini byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xEE }; byte ip[] = { 192, 168, 1, 24 }; Ethernet.begin(mac, ip); server.begin(); Serial.print("server is at "); Serial.println(Ethernet.localIP());}
void loop() {
EthernetClient client = server.available(); if (client) { Serial.println("new client"); boolean currentLineIsBlank = true; while (client.connected()) { if (client.available()) { char c = client.read(); Serial.write(c); if (c == '\n' && currentLineIsBlank) {
} if (c == '\n') { currentLineIsBlank = true; } else if (c != '\r') { currentLineIsBlank = false; } } } delay(1); client.stop(); Serial.println("client disconnected"); Ethernet.maintain(); }}
#####Dados do INI#####[network]mac = 01:23:45:67:89:AB# hash comment, leading spaces belowgateway = 192, 168, 1, 1# extraneous spaces before and after key and valueip = 192, 168, 1, 24#######Anexo o print do retorno na serial.O problema esta sendo em como colocar o valor do BUFFER no lugar do ip que está fixo no codigo.O Sketch não monta nada para o browser, estou apenas testando a configuração do shield mesmo.
Abraços e obrigado.…
usuário da rede via navegador de internet.
O problema é que os valores que o Raspberry Pi mostra no navegador são valores que estavam em seu buffer, ou seja, não está mostrando a leitura do Arduino em tempo real :(
Já tentei apagar o buffer antes de enviar a leitura para o HTML com o comando "serialFromArduino.flushInput()" e também já tentei usar "serialFromArduino.readline(1)", mas quando faço isso não dá tempo de gravar todas as variáveis e mandar pro HTML pra serem exibidas o que gera erro no browser. Tentei usar o "time.sleep(1)" para dar tempo de carregar os dados, mas parece que esse comando impede que o RaspberryPi grave os valores nesse espaço de tempo. Não sei o que fazer para resolver esse problema,se alguém consegui me ajudar ficarei muito grato.
Segue os programas:
ARDUINO
void setup() {
// inicializa comunicacao serial a 9600 bps:
Serial.begin(9600);
// configura os 14 canais digitais como entrada:
for (int canalDigital = 0; canalDigital < 14; canalDigital++) {
pinMode(canalDigital, INPUT);
}
}
// leitura das entradas em loop:
void loop() {
// le todas entradas analogicas:
for (int canalAnalogico = 0; canalAnalogico < 6; canalAnalogico++) {
int leituraSensor = analogRead(canalAnalogico);
// envia todas leituras analogicas:
Serial.print(leituraSensor);
Serial.print(",");
}
// le todas entradas digitais:
for (int canalDigital = 0; canalDigital < 13; canalDigital++) {
int leituraSensor = digitalRead(canalDigital);
// envia todas leituras digitais:
Serial.print(leituraSensor);
Serial.print(",");
}
// ultima leitura separado para dizer ao raspberry e a string terminou:
Serial.print(digitalRead(13));
Serial.println(",");
delay(1); // atraso entre as leituras para dar estabilidade
}
PROGRAMA EM PYTHON
# configuracao para receber do arduino e mandar para HTML
from flask import Flask, render_template, request
import serial
app = Flask(__name__)
port = "/dev/ttyACM0"
serialFromArduino = serial.Serial(port,9600)
serialFromArduino.flushInput()
# inicio do programa
@app.route("/")
def main():
# salva a string q o arduino mandou e entrada
entrada = serialFromArduino.readline()
# divide a string usando a virgula como referencia
dados = entrada.split(',')
# salva os 6 valores analogicos e 14 digitais em 20 variaveis
A0 = int(dados[0])
A1 = int(dados[1])
A2 = int(dados[2])
A3 = int(dados[3])
A4 = int(dados[4])
A5 = int(dados[5])
D0 = int(dados[6])
D1 = int(dados[7])
D2 = int(dados[8])
D3 = int(dados[9])
D4 = int(dados[10])
D5 = int(dados[11])
D6 = int(dados[12])
D7 = int(dados[13])
D8 = int(dados[14])
D9 = int(dados[15])
D10 = int(dados[16])
D11 = int(dados[17])
D12 = int(dados[18])
D13 = int(dados[19])
# manda os valores salvos para o template HTML
templateData = {
'A0' : A0,
'A1' : A1,
'A2' : A2,
'A3' : A3,
'A4' : A4,
'A5' : A5,
'D0' : D0,
'D1' : D1,
'D2' : D2,
'D3' : D3,
'D4' : D4,
'D5' : D5,
'D6' : D6,
'D7' : D7,
'D8' : D8,
'D9' : D9,
'D10' : D10,
'D11' : D11,
'D12' : D12,
'D13' : D13,
}
return render_template('main.html', **templateData)
if __name__ == "__main__":
app.run(host='0.0.0.0', port=80, debug=True)
HTML
<!DOCTYPE html>
<head>
<title>TITULO</title>
</head>
<body>
<p>Valor analógico A0: {{ A0 }}</p>
<p>Valor analógico A1: {{ A1 }}</p>
<p>Valor analógico A2: {{ A2 }}</p>
<p>Valor analógico A3: {{ A3 }}</p>
<p>Valor analógico A4: {{ A4 }}</p>
<p>Valor analógico A5: {{ A5 }}</p>
<p>Valor digital 0: {{ D0 }}</p>
<p>Valor digital 1: {{ D1 }}</p>
<p>Valor digital 2: {{ D2 }}</p>
<p>Valor digital 3: {{ D3 }}</p>
<p>Valor digital 4: {{ D4 }}</p>
<p>Valor digital 5: {{ D5 }}</p>
<p>Valor digital 6: {{ D6 }}</p>
<p>Valor digital 7: {{ D7 }}</p>
<p>Valor digital 8: {{ D8 }}</p>
<p>Valor digital 9: {{ D9 }}</p>
<p>Valor digital 10: {{ D10 }}</p>
<p>Valor digital 11: {{ D11 }}</p>
<p>Valor digital 12: {{ D12 }}</p>
<p>Valor digital 13: {{ D13 }}</p>
</body>
</html>…
Adicionado por Odail Cardoso ao 17:37 em 12 janeiro 2015