Resultados da busca - %E3%80%90%E2%94%83%E6%80%BB%E4%BB%A32%E2%92%8F7%E2%92%8F01705%5B%EF%BC%B1%5D%E3%80%91%E3%80%91%E6%81%92%E8%BE%BE%E5%A8%B1%E4%B9%902%E6%8F%90%E7%8E%B0%E5%A5%BD%E4%B9%85%E5%88%B0
r o Uno por um Mega, mas o clock é o mesmo... sei não... mas tentar não custa, né?
Veja o sketch como ficou com os LEDs doidões:
//--JABUTINO sobre TANQUE 20140606 pinos invertidos OK -#include <Servo.h>#include <AFMotor.h>
//Instancia o objeto referente aos motores DCAF_DCMotor motorEsquerdo(1); //Motor esquerdo na conexão "M1"AF_DCMotor motorDireito(2); //Motor direito na conexão "M2"
//Definições de velocidade em PWM de 0 a 255const char VEL_MAX = 255;const char VEL_MIN = 0;const char VEL_MED = 150;
//Pinos para controle do Ultrassom HC-SR04//usar as portas analógicas A0 e A1 como digitaisconst int pinoTrigger = 18; // A0 = 14const int pinoEcho = 19; // A1 = 15
//Servo MotorServo meuServo;const int pinoServo = 10; //o pino 10 é o pino de sinal da conexão "SERVO_2"
const int ledEsq = 16; // LED Esquerdo conectado ao pino digital 16const int ledDir = 17; // LED Direito conectado ao pino digital 17
/*Define as posições de calibragem do servo. Valores para conseguir um melhor alinhamento do servo, cada motor responde de forma diferente.Os valores devem variar de 0 a 180 graus, ajuste de acordo com seu motor na tentativa e erro.*/
const int OLHA_ESQ = 180;const int OLHA_DIR = 10;const int OLHA_FRT = 85;
const int pinoBuzzer = 9;
const int pinoChaveEsq = 14;const int pinoChaveDir = 15;
/*Método obrigatório: Define tipos dos pinos e inicializa a biblioteca de servo.*/
void setup(void){ // Inicializa os motores com velocidade máximamotorEsquerdo.setSpeed(VEL_MAX);motorDireito.setSpeed(VEL_MAX); //atribui os pinos do ultrassompinMode(pinoTrigger, OUTPUT);pinMode(pinoEcho, INPUT);
Serial.begin(9600); /* função provisória, para controle da rotina das chaves.*/ /* define os pinos como entrada ligando um resistor pullup a eles */pinMode(pinoChaveEsq, INPUT_PULLUP); // MUITO IMPORTANTEpinMode(pinoChaveDir, INPUT_PULLUP);
pinMode(ledEsq, OUTPUT);pinMode(ledDir, OUTPUT);
//inicia o ServomeuServo.attach(pinoServo); //Coloca o servo virado para posicao frontal:meuServo.write(OLHA_FRT);}// =============//Corpo principal, repete infinitamente:void loop(){// Inicia andando para frente andarpFrente(VEL_MAX);
//Enquanto não encontrar um obstáculo a menos de 10cm: while (medeDistancia()>10) { // Lê a Chave Esquerda: if (digitalRead(pinoChaveEsq) == HIGH) { // Serial.println("Esquerda"); //tone(pinoBuzzer, 740); //envia 740Hz para o pino 9 //delay(100); //aguarda 0,1 segundo //noTone(pinoBuzzer); //interrompe o som. girarpDireita(VEL_MED); delay(800); //aguarda 0,8 segundo andarpFrente(VEL_MAX); } else // Lê chave Direita: if (digitalRead(pinoChaveDir)== HIGH) { //Serial.println("Direita"); //tone(pinoBuzzer, 840); //envia 840Hz para o pino 9 //delay(100); //aguarda 0,1 segundo //noTone(pinoBuzzer); //interrompe o som. girarpEsquerda(VEL_MED); delay(800); //aguarda 0,8 segundo p/ virar andarpFrente(VEL_MAX); } else delay(100); //Faz uma leitura da distância a cada 0,1 segundo } // aguarda minimamente para eliminar ruidos das chaves: delay(5); //Se encontrou um obstáculo recua por 1 segundo e pára: andarpTras(VEL_MED); delay(1000); pararMotores();
//Verifica qual lado tem maior distância até um obstáculo: int esquerda = 0, direita = 0; meuServo.write(OLHA_ESQ); //vira o servo para a esquerda delay(500); //aguarda o servo completar o movimento
esquerda = medeDistancia(); //mede a distância na esquerda meuServo.write(OLHA_DIR); //vira o servo para a direita delay(500); //aguarda o servo completar o movimento
direita = medeDistancia(); //mede a distância na direita meuServo.write(OLHA_FRT); //olha pra frente novamente delay(500); //aguarda o servo completar o movimento
if(esquerda > direita) /*se dist do obst esquerda for maior que direita vira para esquerda */ { pisca_LED_Esq(); girarpEsquerda(VEL_MAX); } else /* se dist do obst direita for maior ou igual que esquerda vira para a direita */ { pisca_LED_Dir(); girarpDireita(VEL_MAX); } //Aguarda alguns instantes para o robô virar delay(500); //<< modifique esse tempo se desejar que ele vire por mais ou menos tempo // Fim da rotina de obstáculos} // Fim do LOOP
//Utiliza o sensor de Ultrassom HC-SR04 para medir a distância em centímetrosint medeDistancia() { digitalWrite(pinoTrigger, LOW); //Garante que o pino de Trigger está LOW. delayMicroseconds(2); //cria um pulso de 5 microssegundos no Trigger: digitalWrite(pinoTrigger, HIGH); delayMicroseconds(5); digitalWrite(pinoTrigger, LOW);
//aguarda o echo: long microssegundos = pulseIn(pinoEcho, HIGH);/* A velocidade do som é 340 m/s ou aproximadamente 29 microssegundos por centimetro. O pulso faz uma viagem de ida e volta do sensor até o obstáculo. assim, para calcular a distância temos que dividir esse tempo pela metade. Então...*/ return int(microssegundos/29/2); } // Fim do medeDistancia
// = void's dos motores e dos LED: ====
/*Gira as 2 rodas para frente. Como os motores estão virados para lados opostos eles devemgirar em sentidos opostos para que as rodas girem na mesma direção.*/void andarpFrente(char velocidade) { motorEsquerdo.setSpeed(velocidade); motorDireito.setSpeed(velocidade); motorEsquerdo.run(FORWARD); motorDireito.run(BACKWARD); }
/*Gira as 2 rodas para trás. Como os motores estão virados para lados opostos eles devemgirar em sentidos opostos para que as rodas girem na mesma direção.*/void andarpTras(char velocidade) { motorEsquerdo.setSpeed(velocidade); motorDireito.setSpeed(velocidade); motorEsquerdo.run(BACKWARD); motorDireito.run(FORWARD); }
//Gira as duas rodas em sentido inverso, girando no próprio eixo.void girarpEsquerda (char velocidade) { motorEsquerdo.setSpeed(velocidade); motorDireito.setSpeed(velocidade); motorEsquerdo.run(BACKWARD); motorDireito.run(BACKWARD); }
//Gira as 2 rodas em sentido inverso, girando no próprio eixo.void girarpDireita(char velocidade) { motorEsquerdo.setSpeed(velocidade); motorDireito.setSpeed(velocidade); motorEsquerdo.run(FORWARD); motorDireito.run(FORWARD); }
//Pára os motores definindo os 2 pinos Enable em estado LOW.void pararMotores() { motorEsquerdo.run(RELEASE); motorDireito.run(RELEASE); } void pisca_LED_Esq(){ for (int x=0; x<3; x++) {digitalWrite(ledEsq, HIGH); // liga o LED delay(300); // Espera 0,3 segundo digitalWrite(ledEsq, LOW); // Desliga o LED delay(300); } }void pisca_LED_Dir(){ for (int y=0; y<3; y++) {digitalWrite(ledDir, HIGH); // liga o LED delay(300); // Espera 0,3 segundo digitalWrite(ledDir, LOW); // Desliga o LED delay(300); } }
…
, 10, 11, 12); //Inicializamos la libreria con el numero de los pines a utilizar
int rele = 6;int buzzer = 5; //Alarmeint ahoras = 0; //Variable a mostrar por LCD de las horasint aminutos = 0; //Variable a mostrar por LCD de los minutosint asegundos = 0; //Variable a mostrar por LCD de los segundosint segundostotal = 0; //Tiempo totalint msg= 0; //Barrera para el mensaje de bienvenida
int start = A1; //Pulsador de arranqueint empieza = 1024; // Variable para almacenaje del pulsador de arranque
int buth = A5; //Pulsador de Horasint butm = A4; //Pulsador de Minutosint buts = A3; //Pulsador de segundos
int varbuth = 0; //Variable para almacenar el valor del pulsador de horasint varbutm = 0; //Variable para almacenar el valor del pulsador de minutosint varbuts = 0; //Variable para almacenar el valor del pulsador de segundos
void setup(){ lcd.begin(16, 2); // Configuramos el numero de columnas y filas del LCD. pinMode(buzzer, OUTPUT); //Pin de alarma --> Salida pinMode(buth, INPUT); //Pin de pulsador de horas --> Entrada pinMode(butm, INPUT); //Pin de pulsador de minutos --> Entrada pinMode(buts, INPUT); //Pin de pulsador de segundos --> Entrada pinMode(start, INPUT); //Pin de pulsador de arranque --> Entrada msg = 0; //Barrera del mensaje de bienvenida empieza = 1024; //Barrera de arranque varbuth = 1; //Barrera de horas varbutm = 1; //Barrera de minutos varbuts = 1; //Barrera de segundos Serial.begin(9600);}
void loop(){ if(msg==0) //Mostramos el mensaje de bienvenida solo una vez { lcd.setCursor(0,0); lcd.print("Temporizador con"); lcd.setCursor(1,1); lcd.print("Arduino + LCD"); delay(2500); msg = 1; lcd.clear(); } //------------------------------------------------------------------------------------------------- // LECTURA DE LOS BOTONES Y ELECCIÓN DEL TIEMPO, NO SALE DEL BUCLE HASTA PULSAR // EL BOTON DE ARRANQUE //------------------------------------------------------------------------------------------------- do { varbuth = analogRead(buth); //Leemos boton de horas varbutm = analogRead(butm); //Leemos boton de minutos varbuts = analogRead(buts); //Leemos boton de segundos if(varbuth > 0) //Si el boton ha sido pulsado, aumentamos las horas en una unidad { ahoras = ahoras + 1 ; delay(250); } if(varbutm > 0) //Si el boton ha sido pulsado, aumentamos los minutos en una unidad { aminutos = aminutos + 1; if(aminutos == 60) aminutos = 0; delay(250); } if(varbuts > 0) //Si el boton ha sido pulsado, aumentamos los segundos en una unidad { asegundos = asegundos + 1; if(asegundos == 60) asegundos = 0; delay(250); } lcd.setCursor(0,0); lcd.print("Elige el tiempo"); //Muestra mensaje y las HH:MM:SS que vayamos aumentando lcd.setCursor(4,1);
if (ahoras < 10) lcd.print("0"); // Si las horas son menor que 10, pone un "0" delante. lcd.print(ahoras); // Sin este codigo, se muestra asi: H:M:S (1:M:S) lcd.print(":");
if (aminutos < 10) lcd.print("0"); // Si los minutos son menor que 10, pone un "0" delante. lcd.print(aminutos); // Sin este codigo, se muestra asi: H:M:S (H:1:S)
lcd.print(":"); if (asegundos < 10) lcd.print("0"); // Si los segundos son menor que 10, pone un "0" delante. lcd.print(asegundos); // Sin este codigo, se muestra asi: H:M:S (H:M:1) } while(analogRead(start) == 0); // Se repite el menu de elegir tiempo hasta que pulsemos el boton de arranque. } if(segundos > 0 )digitalWrite(rele, HIGH); //Se o tempo for maior que 0 segundos inicia o rele segundostotal = segundos + (minutos * 60) + (horas * 60 * 60); //Converte o tempo selecionado em segundos!! while (segundostotal > 0) { segundostotal = asegundos + (aminutos * 60) + (ahoras * 60 * 60); //Convierte el tiempo elegido en segundos!! //------------------------------------------------------------------------------------------------- // UNA VEZ PULSADO EL BOTON DE ARRANQUE Y ACUMULADO EL TIEMPO, ENTRA EN EL SIGUIENTE WHILE // Y NO FINALIZA HASTA TERMINAR LA CUENTA. //-------------------------------------------------------------------------------------------------
while (segundostotal > 0) { delay (1000); //Descontamos en periodos de 1 segundo segundostotal--; ahoras = ((segundostotal / 60)/ 60); //Convertimos los segundos totales en horas aminutos = (segundostotal / 60) % 60; //Convertimos los segundos totales en minutos asegundos = segundostotal % 60; //Convertimos los segundos totales en periodos de 60 segundos
lcd.setCursor(0,0); lcd.print("Tiempo restante"); //Mostramos mensaje de tiempo restante
lcd.setCursor(4,1); if (ahoras < 10) lcd.print("0"); // Si las horas son menor que 10, pone un "0" delante. lcd.print(ahoras); // Sin este codigo, se muestra asi: H:M:S (1:M:S) lcd.print(":");
if (aminutos < 10) lcd.print("0"); // Si los minutos son menor que 10, pone un "0" delante. lcd.print(aminutos); // Sin este codigo, se muestra asi: H:M:S (H:1:S)
lcd.print(":"); if (asegundos < 10) lcd.print("0"); // si el valor de segundo esta por debajo de 9 (unidad) antepone un cero lcd.print(asegundos); // Sin este codigo, se muestra asi: H:M:S (H:M:1) if (segundostotal == 0) //Si finaliza el tiempo { while(1) //Bucle infinito mostrando mensaje y haciendo parpadear un led { lcd.clear(); lcd.setCursor(5,0); lcd.print("Tiempo"); lcd.setCursor(3,1); lcd.print("Finalizado"); digitalWrite(rele, LOW); //Ao finalizar o processo desliga o rele Inicio = 0; contagem = 0; sonarTono(TONO_ERROR,TIME_INTERVAL); exit(0); } } } }
//------------------------------------ // SONAR TONO //------------------------------------ void sonarTono(int tono, int duracion) { tone(buzzer,tono,duracion); delay(duracion); }…
Adicionado por Iuri Moriya ao 16:09 em 3 maio 2017
ROR 600#define TIME_INTERVAL 3000
LiquidCrystal lcd(7, 8, 9, 10, 11, 12); //Inicializamos la libreria con el numero de los pines a utilizar
int rele = 6;int buzzer = 5; //Alarmeint ahoras = 0; //Variable a mostrar por LCD de las horasint aminutos = 0; //Variable a mostrar por LCD de los minutosint asegundos = 0; //Variable a mostrar por LCD de los segundosint segundostotal = 0; //Tiempo totalint msg= 0; //Barrera para el mensaje de bienvenida
int start = A1; //Pulsador de arranqueint empieza = 1024; // Variable para almacenaje del pulsador de arranque
int buth = A5; //Pulsador de Horasint butm = A4; //Pulsador de Minutosint buts = A3; //Pulsador de segundos
int varbuth = 0; //Variable para almacenar el valor del pulsador de horasint varbutm = 0; //Variable para almacenar el valor del pulsador de minutosint varbuts = 0; //Variable para almacenar el valor del pulsador de segundos
void setup(){ lcd.begin(16, 2); // Configuramos el numero de columnas y filas del LCD. pinMode(buzzer, OUTPUT); //Pin de alarma --> Salida pinMode(buth, INPUT); //Pin de pulsador de horas --> Entrada pinMode(butm, INPUT); //Pin de pulsador de minutos --> Entrada pinMode(buts, INPUT); //Pin de pulsador de segundos --> Entrada pinMode(start, INPUT); //Pin de pulsador de arranque --> Entrada msg = 0; //Barrera del mensaje de bienvenida empieza = 1024; //Barrera de arranque varbuth = 1; //Barrera de horas varbutm = 1; //Barrera de minutos varbuts = 1; //Barrera de segundos Serial.begin(9600);}
void loop(){ if(msg==0) //Mostramos el mensaje de bienvenida solo una vez { lcd.setCursor(0,0); lcd.print("Temporizador con"); lcd.setCursor(1,1); lcd.print("Arduino + LCD"); delay(2500); msg = 1; lcd.clear(); } //------------------------------------------------------------------------------------------------- // LECTURA DE LOS BOTONES Y ELECCIÓN DEL TIEMPO, NO SALE DEL BUCLE HASTA PULSAR // EL BOTON DE ARRANQUE //------------------------------------------------------------------------------------------------- do { varbuth = analogRead(buth); //Leemos boton de horas varbutm = analogRead(butm); //Leemos boton de minutos varbuts = analogRead(buts); //Leemos boton de segundos if(varbuth > 0) //Si el boton ha sido pulsado, aumentamos las horas en una unidad { ahoras = ahoras + 1 ; delay(250); } if(varbutm > 0) //Si el boton ha sido pulsado, aumentamos los minutos en una unidad { aminutos = aminutos + 1; if(aminutos == 60) aminutos = 0; delay(250); } if(varbuts > 0) //Si el boton ha sido pulsado, aumentamos los segundos en una unidad { asegundos = asegundos + 1; if(asegundos == 60) asegundos = 0; delay(250); } lcd.setCursor(0,0); lcd.print("Elige el tiempo"); //Muestra mensaje y las HH:MM:SS que vayamos aumentando lcd.setCursor(4,1);
if (ahoras < 10) lcd.print("0"); // Si las horas son menor que 10, pone un "0" delante. lcd.print(ahoras); // Sin este codigo, se muestra asi: H:M:S (1:M:S) lcd.print(":");
if (aminutos < 10) lcd.print("0"); // Si los minutos son menor que 10, pone un "0" delante. lcd.print(aminutos); // Sin este codigo, se muestra asi: H:M:S (H:1:S)
lcd.print(":"); if (asegundos < 10) lcd.print("0"); // Si los segundos son menor que 10, pone un "0" delante. lcd.print(asegundos); // Sin este codigo, se muestra asi: H:M:S (H:M:1) } while(analogRead(start) == 0); // Se repite el menu de elegir tiempo hasta que pulsemos el boton de arranque. } if(segundos > 0 )digitalWrite(rele, HIGH); //Se o tempo for maior que 0 segundos inicia o rele segundostotal = segundos + (minutos * 60) + (horas * 60 * 60); //Converte o tempo selecionado em segundos!! while (segundostotal > 0) { segundostotal = asegundos + (aminutos * 60) + (ahoras * 60 * 60); //Convierte el tiempo elegido en segundos!! //------------------------------------------------------------------------------------------------- // UNA VEZ PULSADO EL BOTON DE ARRANQUE Y ACUMULADO EL TIEMPO, ENTRA EN EL SIGUIENTE WHILE // Y NO FINALIZA HASTA TERMINAR LA CUENTA. //-------------------------------------------------------------------------------------------------
while (segundostotal > 0) { delay (1000); //Descontamos en periodos de 1 segundo segundostotal--; ahoras = ((segundostotal / 60)/ 60); //Convertimos los segundos totales en horas aminutos = (segundostotal / 60) % 60; //Convertimos los segundos totales en minutos asegundos = segundostotal % 60; //Convertimos los segundos totales en periodos de 60 segundos
lcd.setCursor(0,0); lcd.print("Tiempo restante"); //Mostramos mensaje de tiempo restante
lcd.setCursor(4,1); if (ahoras < 10) lcd.print("0"); // Si las horas son menor que 10, pone un "0" delante. lcd.print(ahoras); // Sin este codigo, se muestra asi: H:M:S (1:M:S) lcd.print(":");
if (aminutos < 10) lcd.print("0"); // Si los minutos son menor que 10, pone un "0" delante. lcd.print(aminutos); // Sin este codigo, se muestra asi: H:M:S (H:1:S)
lcd.print(":"); if (asegundos < 10) lcd.print("0"); // si el valor de segundo esta por debajo de 9 (unidad) antepone un cero lcd.print(asegundos); // Sin este codigo, se muestra asi: H:M:S (H:M:1) if (segundostotal == 0) //Si finaliza el tiempo { while(1) //Bucle infinito mostrando mensaje y haciendo parpadear un led { lcd.clear(); lcd.setCursor(5,0); lcd.print("Tiempo"); lcd.setCursor(3,1); lcd.print("Finalizado"); digitalWrite(rele, LOW); //Ao finalizar o processo desliga o rele Inicio = 0; contagem = 0; sonarTono(TONO_ERROR,TIME_INTERVAL); exit(0); } } } }
//------------------------------------ // SONAR TONO //------------------------------------ void sonarTono(int tono, int duracion) { tone(buzzer,tono,duracion); delay(duracion); }…
Adicionado por Iuri Moriya ao 15:43 em 3 maio 2017
oop ( serial monitor) e se iniciam corretamente. Não sou programador, e tenho aprendido por aqui mesmo. (Obs: algumas bibliotecas se referem a módulos chineses alternativos que tenho e são um pouco diferente dos demais módulos - DHT11, COMPASS HMC5883 ). Ainda não comprei o motor com pás para medir a velocidade do vento, e o sensor de chuva. Mas já deixo instalado o sensor sônico para o pluviômetro, pode ser usado com cartão SD( o meus queimei por descuido, mas estava nesta programação, retirei) e o conjunto ficará em um balão amarado, que subirá aos poucos, poderá girar em seu eixo e inclinar conforme o vento. Também poderá ser usado em drones, por quem quiser usar o projeto.
Por favor vejam que o foco inicial é saber como testar no setup() se eles estão ok.
Atenção: Qualquer um que usar balões deve ter autorização de manejo de acordo com o estado e instituição de ensino, não deve realizar qualquer teste em condições de céu nublado ou chuva sem tomar orientação sobre os riscos, não me responsabilizo pelas tentativas de teste que causem risco de morte e contravenção da lei dos balões RJ.
// Marcelo da Silva Santos (Designer, esp. animador, estudante de engenharia mecanica)// Estacao meteriologica feita em casa / HOME MADE Meteriologoc station prototype// Portugues - Brasil - BR_pt (Lingua).// Rio de Janeiro 22:09 / Sexta-feira / 09 / Agosto / 2019.// 1.0v Dados livres. Obg a todos / FreeData. Tks Everybody!// Rascunho na memoria do uno / UNO Sketch memory 88%...!!! :(
#include <Ultrasonic.h>#define pino_trigger A0#define pino_echo A1Ultrasonic ultrasonic(pino_trigger, pino_echo);float cmMsec, inMsec;long microsec = ultrasonic.timing();//----------------------------------------------------------------------------------#include <dht.h>#define pinoDHT11 9dht sensorDHT11;//----------------------------------------------------------------------------------#include <Adafruit_Sensor.h> #include <Adafruit_BMP280.h> float PressaoDoDia;int Atm = 0; Adafruit_BMP280 bmp; //----------------------------------------------------------------------------------
#include <Wire.h>#include <MechaQMC5883.h>MechaQMC5883 qmc; int x, y, z; int azimuth;
//----------------------------------------------------------------------------------//#include <SD.h>
//Sd2Card SDcard;//SdVolume volume;
//const int chipSelect = 10; //----------------------------------------------------------------------------------#include <DS3232RTC.h>
const int MPU=0x68; int AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ;
long ContadorLoop = 0; // CONTADOR DE LOOP(Tipo de Timer primitivo).int Ciclos =0; // contador de ciclos cheios do contador de loop.//----------------------------------------------------------------------------------
void setup(){ Serial.begin(9600); Wire.begin(); setSyncProvider(RTC.get); Wire.beginTransmission(MPU); Wire.write(0x6B); Wire.write(0); Wire.endTransmission(true); cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM); inMsec = ultrasonic.convert(microsec, Ultrasonic::IN); if(!Serial) // 1 { Serial.println("Erro ao iniciar Serail! Verifique as conexões."); Serial.println("Verifique o Modulo, conexoes e reinicie o Arduino..."); Serial.print("Erro no Loop: "); Serial.println(ContadorLoop); } else { Serial.println("Serial iniciado!"); Serial.print("Inicio no Loop: "); Serial.println(ContadorLoop); } if(!bmp.begin(0x76)) // 2 { Serial.println("Sensor BMP280 não foi identificado! Verifique as conexões."); Serial.println("Verifique o Modulo, conexoes e reinicie o Arduino..."); Serial.print("Erro no Loop: "); Serial.println(ContadorLoop); } else { Serial.println("Sensor BMP280 foi identificado!");Serial.print("Inicio no Loop: "); Serial.println(ContadorLoop); } if(timeStatus() != timeSet) // 3 { Serial.println("Impossivel sincronismo com RTC"); Serial.println("Verifique o Modulo, conexoes e reinicie o Arduino..."); Serial.print("Erro no Loop: "); Serial.println(ContadorLoop); } else { Serial.println("RTC Esta definindo o tempo do sistema"); Serial.println("Módulo RTC foi identificado!"); Serial.print("Inicio no Loop: "); Serial.println(ContadorLoop); } if(!MPU, 0x6B) // 4 { Serial.println("Impossivel sincronismo com MPU6050"); Serial.println("Verifique o Modulo, conexoes e reinicie o Arduino..."); Serial.print("Erro no Loop: "); Serial.println(ContadorLoop); } else { Serial.println("Sincronismo com MPU6050, ok!"); Serial.print("Inicio no Loop: "); Serial.println(ContadorLoop); } if(inMsec=0) // 5 { Serial.println("Nenhum pulso detectado de Ultrasonico!"); Serial.println("Esperando para teste, sincronismo com Ultrasonic"); delay(2500); Serial.println("Novo teste iniciado!"); cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM); inMsec = ultrasonic.convert(microsec, Ultrasonic::IN); if((inMsec=0) && (cmMsec=0 )) { Serial.println("Impossivel sincronismo com Ultrasonic"); Serial.println("Verifique o Modulo, conexoes e reinicie o Arduino..."); Serial.print("Erro no Loop: "); Serial.println(ContadorLoop); } else { Serial.println("Detectado sincronismo com Ultrasonic no segundo teste!"); } } else { Serial.println("Sincronismo com Ultrasonic, ok!"); Serial.print("Inicio no Loop: "); Serial.println(ContadorLoop); } sensorDHT11.read11(pinoDHT11); if((sensorDHT11.humidity=0) && ((sensorDHT11.temperature)=0)) // 6 { sensorDHT11.read11(pinoDHT11); delay(2500); if((sensorDHT11.humidity=0) && ((sensorDHT11.temperature)=0)) { Serial.println("Impossivel sincronismo com DHT_11"); Serial.println("Verifique o Modulo, conexoes e reinicie o Arduino..."); Serial.print("Erro no Loop: "); Serial.println(ContadorLoop); } else { Serial.println("Sincronismo com DHT_11, ok!"); Serial.print("Inicio no Loop: "); Serial.println(ContadorLoop); } } else { Serial.println("Sincronismo com DHT_11, ok!"); Serial.print("Inicio no Loop: "); Serial.println(ContadorLoop); } if((x=-1) && ( y=-1)) // 7 { x=0; y=0; z=0; delay(2500); if((x=-1) && (y=-1)) { Serial.println("Impossivel sincronismo com Bussola!"); Serial.println("Verifique o Modulo, conexoes e reinicie o Arduino..."); Serial.print("Erro no Loop: "); Serial.println(ContadorLoop); } else { Serial.println("Sincronismo com a Busola na segundo teste, ok!"); Serial.print("Inicio no Loop: "); Serial.println(ContadorLoop); } } else { Serial.println("Sincronismo com a bussola, ok!"); Serial.print("Inicio no Loop: "); Serial.println(ContadorLoop); }}
void loop(){ Serial.println("----------------------------------------------------------------------------------"); // ________________________ RTC ___________________________________________________________________________________________________ digitalClockDisplay(); // _______________________ DHT 11 _________________________________________________________________________________________________ sensorDHT11.read11(pinoDHT11); // _______________________ BMP 280 ________________________________________________________________________________________________ PressaoDoDia = 1013,25; // pressao ao nivel do mar, // ajustar este valor pela internet no mesmo dia. // _______________________ BUSSOLA ________________________________________________________________________________________________ qmc.read(&x, &y, &z,&azimuth); // _______________________ MPU 6050 _______________________________________________________________________________________________ Wire.beginTransmission(MPU); Wire.write(0x3B); Wire.endTransmission(false); Wire.requestFrom(MPU,14,true); AcX=Wire.read()8|Wire.read(); //0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L) AcY=Wire.read()8|Wire.read(); //0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L) AcZ=Wire.read()8|Wire.read(); //0x3F (ACCEL_ZOUT_H) & 0x40 (ACCEL_ZOUT_L) Tmp=Wire.read()8|Wire.read(); //0x41 (TEMP_OUT_H) & 0x42 (TEMP_OUT_L) GyX=Wire.read()8|Wire.read(); //0x43 (GYRO_XOUT_H) & 0x44 (GYRO_XOUT_L) GyY=Wire.read()8|Wire.read(); //0x45 (GYRO_YOUT_H) & 0x46 (GYRO_YOUT_L) GyZ=Wire.read()8|Wire.read(); //0x47 (GYRO_ZOUT_H) & 0x48 (GYRO_ZOUT_L) // _____________________________ Escrevendo no Serial _____________________________________________________________________________ if (ContadorLoop>0) { Serial.println("Iniciando Sistema, preparando CAIXA PRETA!"); Serial.print("INICIO DE Loop: "); Serial.println(ContadorLoop); Serial.println("-----------------------------Ultrasonic--------------------------------------------"); Serial.print("Distancia em cm: "); Serial.print(cmMsec); Serial.print(" - Distancia em polegadas: "); Serial.println(inMsec); Serial.println("-----------------------------DHT11------------------------------------------------"); Serial.print("Umidade: "); Serial.print(sensorDHT11.humidity); Serial.print("%"); Serial.print(" - Temperatura_1: "); Serial.print(sensorDHT11.temperature,0); Serial.println("C"); Serial.println("----------------------------BMP 280-----------------------------------------------"); Serial.print("Temperatura_2: "); Serial.print(bmp.readTemperature()); Serial.print(" *C (Grau Celsius)"); Serial.print(" - Pressao: "); Serial.print(bmp.readPressure()); Serial.print(" Pa (Pascal)"); Serial.print(" - Atmosfera: "); Atm = (((bmp.readPressure())/PressaoDoDia),1); Serial.println(Atm); Serial.println("-----------------------------Bussola----------------------------------------------"); Serial.print("x: "); Serial.print(x); Serial.print(" - y: "); Serial.print(y); Serial.print(" - z: "); Serial.print(z); Serial.print(" ROTACAO EM RELACAO AO NORTE: "); Serial.print(azimuth); Serial.println(); Serial.println("-----------------------------MPU 6050---------------------------------------------"); Serial.print("AcX = "); Serial.print(AcX); Serial.print(" | AcY = "); Serial.print(AcY); Serial.print(" | AcZ = "); Serial.print(AcZ); Serial.print(" | Tmp = "); Serial.print(Tmp/340.00+36.53); Serial.print(" | GyX = "); Serial.print(GyX); Serial.print(" | GyY = "); Serial.print(GyY); Serial.print(" | GyZ = "); Serial.println(GyZ); Serial.println("----------------------------------------------------------------------------------"); } if (ContadorLoop >=2147483646) { ContadorLoop=0; Ciclos=Ciclos+1; Serial.println(ContadorLoop); Serial.println(Ciclos); } Serial.print("FIM DE Loop: "); Serial.println(ContadorLoop); Serial.println("----------------------------------------------------------------------------------"); Serial.println(" "); Serial.println(" "); ContadorLoop = ContadorLoop + 1; } // _____________________________ Escrevendo no Serial Fim _________________________________________________________________________
void digitalClockDisplay(){ Serial.print(hour()); printDigits(minute()); printDigits(second()); Serial.print(' '); Serial.print(day()); Serial.print(' '); Serial.print(month()); Serial.print(' '); Serial.print(year()); Serial.println();}
void printDigits(int digits){ Serial.print(':'); if(digits < 10) { Serial.print('0'); Serial.print(digits); }}…
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
//variavel para fim de curso 2int state1 = 0;//variavel para botao 1int state2 = 0;//variavel para botao 2int state3 = 0;//variavel para botao 3int a = 0;//variavel de controleint b = 0;//variave2 de controleint c = 0;//variave3 de controle
void setup(){ Serial.begin(9600); pinMode(8,OUTPUT);//porta em que esta o motor de passos pinMode(9,OUTPUT);//porta em que esta o motor de passos pinMode(10,OUTPUT);//porta em que esta o motor de passos pinMode(11,OUTPUT);//porta em que esta o motor de passos } void loop(){ // utilizei entradas analogicas para os botões e fins de curso, pois as portas digitais são muito sensiveis valor1 = analogRead(fdc1); valor2 = analogRead(fdc2); state1 = analogRead(botao1); state2 = analogRead(botao2); state3 = analogRead(botao3); delay(500); if(state1 > 600 && state1 < 700){ Serial.println(111111);//para exibir quando for realizado a condição a = 1; abrir(); delay(500); } if(state2 > 600 && state2 < 700){ Serial.println(222222);//para exibir quando for realizado a condição b = 1; fechar(); delay(500); } if(state3 > 600 && state3 < 700){ Serial.println(333333);//para exibir quando for realizado a condição c = 1; automatico(); delay(500); }} void abrir(){ //Executa para abrir a persiana while(a){ digitalWrite(8, HIGH); //Logica mais simples para funcionamento do motor de passos sentido horario delay(10); digitalWrite(8, LOW); digitalWrite(9, HIGH); delay(10); digitalWrite(9, LOW); digitalWrite(10, HIGH); delay(10); digitalWrite(10, LOW); digitalWrite(11, HIGH); delay(10); digitalWrite(11, LOW); Serial.println(1);//para visualizar o funcionamento na tela valor1 = analogRead(fdc1);//fazer leitura para verificar condição valor2 = analogRead(fdc2);//fazer leitura para mudar valor state2 = analogRead(botao2);//fazer leitura para verificar condição state3 = analogRead(botao3);//fazer leitura para verificar condição if(state2 > 600 && state2 < 700)//Quando o botão é acionado ele fica com um valor de 650 na porta { a = 0; b = 1; c = 0; fechar(); } if(state3 > 600 && state3 < 700)//Quando o botão é acionado ele fica com um valor de 650 na porta { a = 0; b = 0; c = 1; automatico(); } if(valor1 > 600 && valor1 <700)//Quando o fim de curso é acionado ele fica com um valor de 650 na porta { state1 = 0; state2 = 0; state3 = 0; return; } } } void fechar(){ //Executa para fechar a persiana while(b){ digitalWrite(11, HIGH); //Logica mais simples para funcionamento do motor de passos sentido anti-horario delay(10); digitalWrite(11, LOW); digitalWrite(10, HIGH); delay(10); digitalWrite(10, LOW); digitalWrite(9, HIGH); delay(10); digitalWrite(9, LOW); digitalWrite(8, HIGH); delay(10); digitalWrite(8, LOW); Serial.println(2);//para visualizar o funcionamento na tela valor1 = analogRead(fdc1);//fazer leitura para mudar valor valor2 = analogRead(fdc2);//fazer leitura para verificar condição state1 = analogRead(botao1);//fazer leitura para verificar condição state3 = analogRead(botao3);//fazer leitura para verificar condição if (state1 > 600 && state1 < 700)//Quando o botão é acionado ele fica com um valor de 650 na porta { a = 1; b = 0; c = 0; abrir(); } if(state3 > 600 && state3 < 700)//Quando o botão é acionado ele fica com um valor de 650 na porta { a = 0; b = 0; c = 1; automatico(); } if(valor2 > 600 && valor2 < 700)//Quando o fim de curso é acionado ele fica com um valor de 650 na porta { state1 = 0; state2 = 0; state3 = 0; return; } } } void automatico(){//Executa para ficar no modo automatico a persiana while(c){ int val=analogRead(sensor); Serial.println(val); if(val < 300){ //se o sensor estiver com valor abaixo de 300 digitalWrite(11, HIGH); //Logica mais simples para funcionamento do motor de passos sentido anti-horario delay(10); digitalWrite(11, LOW); digitalWrite(10, HIGH); delay(10); digitalWrite(10, LOW); digitalWrite(9, HIGH); delay(10); digitalWrite(9, LOW); digitalWrite(8, HIGH); delay(10); digitalWrite(8, LOW); Serial.println(3);//para visualizar o funcionamento na tela int val=analogRead(sensor); } if(val > 700){ //se o sensor estiver com valor acima de 700 digitalWrite(8, HIGH); //Logica mais simples para funcionamento do motor de passos sentido horario delay(10); digitalWrite(8, LOW); digitalWrite(9, HIGH); delay(10); digitalWrite(9, LOW); digitalWrite(10, HIGH); delay(10); digitalWrite(10, LOW); digitalWrite(11, HIGH); delay(10); digitalWrite(11, LOW); Serial.println(4);//para visualizar o funcionamento na tela int val=analogRead(sensor); } if(val <= 700 && val >= 300){//se o sensor não estiver com nenhuma das duas condições delay(1000); //esperar 1 segundo para fazer verificação } valor1 = analogRead(fdc1); //fazer leitura para verificar condição valor2 = analogRead(fdc2); //fazer leitura para verificar condição state1 = analogRead(botao1);//fazer leitura para verificar condição state2 = analogRead(botao2);//fazer leitura para verificar condição if (state1 > 600 && state1 < 700)//Quando o botão é acionado ele fica com um valor de 650 na porta { a = 1; b = 0; c = 0; abrir(); } if(state2 > 600 && state2 < 700)//Quando o botão é acionado ele fica com um valor de 650 na porta { a = 0; b = 1; c = 0; fechar(); } if(valor1 > 600 && valor1 < 700) //Quando o fim de curso é acionado ele fica com um valor de 650 na porta { state1 = 0; state2 = 0; state3 = 0; return; } if(valor2 > 600 && valor2 < 700) //Quando o fim de curso é acionado ele fica com um valor de 650 na porta { state1 = 0; state2 = 0; state3 = 0; return; } } }…
. Por isso, acho que, TALVEZ, sua dificuldade seja MUITO introdutória, pois existem 999999999999 vídeos que falam sobre isso. Entretanto, ninguém é dono do saber e, qualquer pessoa quando não sabe por onde começar, costuma perguntar a alguém, e da mesma forma, a ideia do fórum é ajudar a todos, então vamos lá. :)
Primeiro vamos do básico
- O Arduino possui 18 portas digitais (sendo que 5 delas também são analógicas - A0 até A5).
- As portas digitais realizam leituras ou escritas, enviando/recebendo um "ALTO/HIGH/'1'/5v" ou "Baixo/LOW/'0'/0v". Lembrando que a corrente máxima de saída é de 40ma, mas costumo ver o pessoal contraindicando o uso com esta corrente.
- As portas analógicas, quando definidas por código para este serviço, servem apenas para a leitura, oferecendo uma escala de 0 á 1023. (0 = 0v, 1023 = 5v).
Na programação do Arduino, temos 2 funções principais:
- Setup (configuração inicial)
- Loop (aqui o código fica girando eternamente).
Como seu objetivo é acionar 4 relés através de 4 botões, você pode utilizar 4 pinos digitais para LEITURA, e mais 4 pinos digitais para ESCRITA. Para isso, vamos definir na função "SETUP" a configuração dos pinos.
pinMode(4, INPUT); // Define o pino 4 como entrada.
pinMode(5, INPUT); // Define o pino 5 como entrada.
pinMode(6, INPUT); // Define o pino 6 como entrada.
pinMode(7, INPUT); // Define o pino 7 como entrada.
pinMode(8, OUTPUT); // Define o pino 8 como SAIDA.
pinMode(9, OUTPUT); // Define o pino 9 como SAIDA.
pinMode(10, OUTPUT); // Define o pino 10 como SAIDA.
pinMode(11, OUTPUT); // Define o pino 11 como SAIDA.
Como temos 4 pinos de saida, por padrão define-se a situação dele como "ALTO/BAIXO" a depender da ação desejada.
No seu caso, como deseja iniciar com tudo desligado, adicionaríamos mais esta linha:
digitalWrite(8, LOW); //Define como "Baixo/LOW/'0'/0v" o pino 8
digitalWrite(9, LOW); //Define como "Baixo/LOW/'0'/0v" o pino 8
digitalWrite(10, LOW); //Define como "Baixo/LOW/'0'/0v" o pino 8
digitalWrite(11, LOW); //Define como "Baixo/LOW/'0'/0v" o pino 8
A titulo de debug, você pode iniciar a serial:
Serial.begin(9600);
======== Aqui finalizam as configurações iniciais. =========
Agora vamos para a parte da função do Loop. O primeiro passo é ler os valores das entradas digitais e atribuir uma ação, para isso iremos utilizar a seguinte chamada:
if (digitalRead(4) == HIGH) { //Aqui criamos uma condição para "quando o pino 4 estiver 'alto')
digitalWrite(8, HIGH) // caso a condição seja verdadeira, definimos o pino 8 como ALTO.
Serial.println("botão 4 ON"); // visualiza no serial monitor a informação quando esta for verdadeira.
} // concluir a condição inicial
else { // Caso a condição seja falsa, ocorre uma ação diferente
digitalWrite(8, LOW) // Neste caso, o pino 8 ficará como baixo
Serial.println("botão 4 OFF"); // visualiza no serial monitor a informação quando esta for verdadeira.
} // finaliza a condição falsa
Observe que o mesmo irá ocorrer para todos os outros pinos.
Observe também que, desta forma, os pinos só ficarão como ALTOS enquanto a entrada estiver recebendo tensão. Logo, se seu botão for um pushbutton (daqueles que ele só fica habilitado enquanto estiver pressionado), será necessário que ele fique sempre pressionado para a entrada ficar em alto.
obs- Caso seja necessário que o botão se comporte como um interruptor, será necessário adaptar o código ou trocar o botão.
Sabendo disso, o próximo passo é ligar os fios e os botões. Aqui não tem mistério.
1- Os botões costumam ter 2 pinos.
2- Ligue o +5v a um destes pinos, e o outro ligue numa entrada digital. Repita o processo para todos os botões/pinos.
obs- A ligação de +5v pode ser feita de botão para botão também, entretanto, o segundo pino do botão não pode ser ligado aos outros. Cada botão deverá ir separadamente para uma entrada digital (neste caso, as entradas 4 á 7).
obs2- se quiser pode colocar um resistor para cada entrada digital, talvez promova alguma segurança (alguém aqui saberá lhe informar melhor, pois os testes que fiz, para este fim, foram muito curtos).
O próximo passo, dependerá do seu rele. Pois tem uns módulos cheio de wifi/usb/uhf/vhf/gps/nasa/dragonballZ/etc.. Se for os modelos simples de 5v, basta ligar a saída digital (8~11) na entrada de sinal de cada um deles, e o GND conectado ao Arduíno.
Ouvi falar que o relé tem um retorno... não tenho certeza. Mas qualquer vídeo que fala sobre módulos de rele irá apontar isso (pois posso estar me confundindo).
No rele, você tem: "saida normalmente aberto", "saida normalmente fechado", "entrada para alimentação". A diferença entre eles é a seguinte:
- Quando o arduino der um sinal baixo/low, o "normalmente aberto" irá fazer a ponte entre a entrada e a lampada.- Quando o arduino der um sinal alto/HIGH, o "normalmente fechado" é que irá fazer a ponte.
(obs: Alguns reles trabalham de forma inversa)
Sendo assim, você conecta o positivo (ou GND) ao rele, e o outro direto na outra ponta (positivo ou GND) (é bom realizar uma pesquisa, pois não sei se os relés funcionam como transistores (NPN/PNP).
obs- não esqueça que os relés costumam ser alimentados por uma fonte secundária.
Edit: Precisei realizar algumas edições, logo, está concluído agora: 21:15h kkkkk…
Adicionado por tiago merces ao 22:03 em 22 agosto 2020