//////////////////////////////////////
// DEFININDO AS PINAGENS DO ARDUINO //
//////////////////////////////////////
//pino 12 ativa módulo 1 ativa o relé principal de energia do teto solar
//pino 11 ativa módulo 2 ativa os 2 relés secundários para acionar o teto solar
//pino 9 recebe sinal botão 1 fecha teto e levanta o teto
//pino 8 recebe sinal botão 2 abre o teto e abaixa o teto
//pino 7 recebe sinal alarme trava fecha o teto e desliga o arduino mesmo sinal que vem do som.
//pino 6 recebe sinal alarme destrava abre o teto e liga o arduino sinal que vem do módulo do teto solar
//pino 5 recebe sinal do botão para resetar o teto
int rele_principal = 6; //ativa o relé principal que envia 12V + para um dos relés secundários e ativa o motor do teto solar
int rele_secundario = 5; //ativa os 2 relés secundários para inverter a polaridade do motor do teto solar
int botao_abre_abaixa = 8; //recebe o sinal do botão do teto solar
int botao_fecha_levanta = 4; //recebe o sinal do botão do teto solar
int alarme_trava = 7; //recebe sinal para travar (fechar o teto ou abaixar o teto, deixando travado o módulo dentro de um loop eterno até o arduino ser desligado pelo temporizador)
int alarme_destrava = 3; //recebe sinal para abrir o teto totalmente quando acionado o botão auxiliar do alarme
int reseta_teto = 9; //botão de emergência para resetar a posição do teto caso de algum travamento do sistema ou dos módulos.
//declarando os loops externos do sistema
void teto_reseta(); //função de resetamento do teto solar, ele no final retornará para o loop do teto fechado.
void teto_fecha(); //função de fechamento do teto solar
void teto_fechado(); //função loop interno
void teto_levanta(); // função de levantamento do teto solar
void teto_abre(); //função de abertura total do teto solar
void teto_aberto(); //função do teto solar aberto
void teto_abaixa(); //função do teto solar abaixando
void teto_desliga(); //função para que o arduino fique preso dentro até o relé temporizador desliga-lo, assim tornando mais seguro o sistema do teto solar.
///////////
// SETUP //
///////////
void setup()
{
//ATIVANDO E DECLARANDO OS PINOS E SEU ATRIBUTO E SUA FUNCIONALIDADE
pinMode (botao_abre_abaixa, INPUT_PULLUP); //botão do teto com função de abrir e abaixar configurado para entrada de energia e com resistência interna do arduino
pinMode (botao_fecha_levanta, INPUT_PULLUP); //botão do teto com função de fechar e levantar configurado para entrada de energia e com resistência interna do arduino
pinMode (reseta_teto, INPUT_PULLUP); //botão extra para acionar o teto em caso de problemas de código ou remover bateria com o teto aberto ou levantado
pinMode (alarme_trava, INPUT); //entrada de energia quando o alarme positron é acionado para trancar o carro
pinMode (alarme_destrava, INPUT); //entrada de energia quando o alarme está desligado e quando é acionado o botão auxiliar do controle
pinMode (rele_secundario, OUTPUT); //saída de energia do arduino para acionar o relé principal.
pinMode (rele_principal, OUTPUT); //saída de energia do arduino para acionar os 2 relés secundários, para fazer a troca de polaridade do teto solar. (inversão dos pólos)
delay (3000); ///temporizamento do código só para não sobrecarregar demais o carro.
}
////////////
// LOOP //
////////////
void loop(){
//Inciando com o teto fechado - posição 0
//ler sinal dos botões e alarme
// Este loop funciona normal, porém ele não volta mais caso o botão auxiliar ou qualquer outro botão seja acionado, o loop será feito na função Teto_Fechado();
//Tive que criar esta função teto_fechado(), porque quando eu acionava o botão auxiliar do alarme e depois eu fechava o
//teto ele voltava a abrir o teto novamente porque o pino alarme_trava() estava constantemente energizado e isso me gerou um problema, mas agora foi resolvido com uma função a mais no código
if (digitalRead (botao_fecha_levanta) == HIGH){ //Se acionar o botão 1
teto_levanta();
}
else if (digitalRead (botao_abre_abaixa) == HIGH){ //Se acionar o botão 2
teto_abre();
}
else if (digitalRead (alarme_destrava) == HIGH){ //Se acionar o botão auxiliar do controle do alarme
teto_abre();
}
else if (digitalRead (alarme_trava) == LOW){ //Se acionar o alarme para trancar o carro
delay(5000);
teto_desliga();
}
else if (digitalRead (reseta_teto) == HIGH){ //Se caso de algum problema do teto estar fora da posição quando liga o arduino
teto_reseta();
}
else{
delay(100); //Se não for feito nada ele retornará o loop inicial.
}
}
//////////////////////
// FUNÇÕES EXTERNAS //
//////////////////////
void teto_abre(){ //botão 2 acionado ou o auxiliar do teto acionado.
digitalWrite(rele_secundario, HIGH); //envia energia para ativar os relés de inverão de polaridade
digitalWrite(rele_principal, HIGH); // envia energia para ativar o relé que envia carga para 1 dos reles secundários.
delay(8000); // 8 segundos para o teto abrir a primeira parte
digitalWrite(rele_principal, LOW); // desativa o relé para destravar o teto
delay(100); // 0,1 segundos só para o motor do teto destravar
digitalWrite(rele_principal, HIGH); // re-ativa o relé para continuar a abertura completa do teto
delay(3000); // 3 segundos para finalizar a abertura total do teto solar.
digitalWrite(rele_principal, LOW); //desliga primeiro o principal
digitalWrite(rele_secundario, LOW); // depois desliga os 2 reles secundarios.
delay(200); // 0,2 só para dar um tempo para destravar o motor do teto solar mesmo.
teto_aberto(); // agora vai para a próxima função
}
void teto_aberto(){
if (digitalRead(botao_fecha_levanta) == HIGH){ //Se acionar o botão 1 o teto fechará
teto_fecha();
}
else if (digitalRead(alarme_trava) == LOW){ //Se acionar o alarme do carro o teto fechará
delay(5000);
teto_fecha();
}
else if (digitalRead (reseta_teto) == HIGH){ //Se acionar o botão de resetar o teto ele resetará o teto deixando na posição fechado independente onde o teto esteja.
teto_reseta();
}
else{
delay(100);
teto_aberto(); //caso nada seja feito retornará neste evento mesmo. (loop interno)
}
}
void teto_fecha(){ //fechamento do teto - teto solar se encontra totalmente aberto
digitalWrite(rele_principal, HIGH); //Aciona o relé principal
delay(10000); //10 segundos para fechar o teto
digitalWrite(rele_principal, LOW); //desativa o relé
delay(200); //tempo para dar uma relaxada no sistema hehehehe
teto_fechado(); //vai para a função
}
void teto_fechado(){ // Esta função é o Loop principal do sistema, aqui eu ignoro a varredura do botão auxiliar do alarme.
if (digitalRead (botao_fecha_levanta) == HIGH){ //Se acionar o botão 1 o teto irá levantar
teto_levanta();
}
else if (digitalRead (botao_abre_abaixa) == HIGH){ //Se acionar o botão 2 o teto irá abrir
teto_abre();
}
else if (digitalRead (alarme_trava) == LOW){ //Se trancar o carro o teto irá para a função desligar
delay(5000);
teto_desliga();
}
else if (digitalRead (reseta_teto) == HIGH){ //Se acionar o botão de resetar teto
teto_reseta();
}
else{
delay(100);
teto_fechado(); //aqui ele retorna pro início desta função.
}
}
void teto_levanta(){
digitalWrite(rele_principal, HIGH);
delay(3000);
digitalWrite(rele_principal, LOW);
delay(200);
teto_levantado();
}
void teto_levantado(){
if (digitalRead (botao_abre_abaixa) == HIGH){
teto_abaixa();
}
else if (digitalRead(alarme_trava) == LOW){
delay(5000);
teto_abaixa();
}
else if (digitalRead (reseta_teto) == HIGH){
teto_reseta();
}
else{
delay(100);
teto_levantado();
}
}
void teto_abaixa(){
digitalWrite(rele_secundario, HIGH);
digitalWrite(rele_principal, HIGH);
delay(3000);
digitalWrite(rele_principal, LOW);
digitalWrite(rele_secundario, LOW);
delay(200);
teto_fechado();
}
void teto_reseta(){ //esta função só serve para caso de remoção da bateria com teto aberto, ou queima de fusível e deixe o teto na metade do caminho.
//ele simplesmente vai ignorar a posição atual do teto solar, vai fechar o teto 2 vezes como se estivesse aberto totalmente e vai abaixar o teto. deixando na posição fechado.
delay(5000);
digitalWrite(rele_principal, HIGH);
delay(10000);
digitalWrite(rele_principal, LOW);
delay(200);
digitalWrite(rele_principal, HIGH);
delay(4000);
digitalWrite(rele_principal, LOW);
delay(200);
digitalWrite(rele_secundario, HIGH);
digitalWrite(rele_principal, HIGH);
delay(4000);
digitalWrite(rele_principal, LOW);
digitalWrite(rele_secundario, LOW);
delay(3000);
teto_fechado();
}
void teto_desliga(){ //Função de segurança, aqui o alarme acionado tranca o carro e o arduino ficará preso neste loop até o relé temporizador desligar o arduino.
delay(50000); //50 segundos, prefiro deixar um delay mais pequeno para não dar alguma pala (bug)
teto_desliga(); // função retorna para o início desta função.
}
