//____________________/COMUNICANÇÂO/______________________//
// 12345//00:00:00/
// 180A 180B 180C 180D
int TextXy[] = {0,0}; //coordenadas para imprimir caracteres recebidos do Esp8266
String Recebido; // Recebe mensagens do Esp8266
String Mensagem; // Recebe mensagens e comandos do Hc-06
unsigned long int valorData = 27555; //Guarda o valor das horas em segundos recebido pelo Esp8266;
int msg_Esp = 0; //Valida a mensagem recebida pelo Esp8266 se tiver exatamente 16 caracteres
int ok_Esp = 1; // Valida a inicialização do programa e indica se há ou não internet no esp8266 e bloqueia no inicio de um evento
int Reset = 1; // inicia/reinicia um evento ao iniciar o sistema ou em um horário específico
int Chances = 0; //permite a kin virar-se para uma direção aleatória se tiver o valor 4
int VrA = 0; //verificação de duas etapas utilizado em "Emotes", garantem que ambos os motores cumpram as atividades
int VrB = 0; //
int valorAnteriorY; //Obtem o ultimo valor em ValorX / ValorY / ValorZ para
int valorAnteriorX; //colocar-la na posição em que estava antes da função
int valorAnteriorZ; //"Observation()".
unsigned long Valor1; //valores utilizados para verificação dos horários
unsigned long Valor2; //
unsigned long Valor3; //
unsigned long Valor4; //
char comando;
char Ctrl[9] = {'.','W','E','Q','S','C','Z','D','A'}; //caracteres de comando
char resposta[] = {'F','Y','N'}; //Possiveis respostas para uma solicitação
//____________________/EVENTOS/______________________//
unsigned long Hora[17][2] = { //valor em segundos
{0, 27000}, // 0 1 00:00 a 07:30 dormir
{27000, 30000},// 1 2 07:30 a 08:20 Acordar
{30000, 34200},// 2 3 08:20 a 09:30 Café da manhã
{34200, 40200},// 3 4 09:30 a 11:10 Aleatório
{40200, 45000},// 4 5 11:10 a 12:30 Aleatório
{45000, 48600},// 5 6 12:30 a 13:30 Estudo
{48600, 51000},// 6 7 13:30 a 14:10 Almoço
{51000, 56400},// 7 8 14:10 a 15:40 Aleatório
{56400, 58200},// 8 9 15:40 a 16:10 Aleatório
{58200, 61200},// 9 10 16:10 a 17:00 Lanche
{61200, 65400},// 10 11 17:00 a 18:10 Aleatório
{65400, 67200},// 11 12 18:10 a 18:40 Aleatório
{67200, 69000},// 12 13 18:40 a 19:10 Janta
{69000, 72660},// 13 14 19:10 a 20:11 Aleatório
{72660, 77400},// 14 15 20:11 a 21:30 Aleatório
{77400, 81300},// 15 16 21:30 a 22:35 Lanche
{81300, 86399} // 16 17 22:35 a 23:59 Dormir
};
unsigned long D_Hora[17][2] = { //guarda valores em segundos para resetar tarefas
//
{1, 2}, // 1
{27001, 27002},// 2
{30001, 30002},// 3
{34201, 34202},// 4
{40201, 40202},// 5
{45001, 45002},// 6
{48601, 48602},// 7
{51001, 51002},// 8
{56401, 56402},// 9
{58201, 58202},// 10
{61201, 61202},// 11
{65401, 65402},// 12
{67201, 67202},// 13
{69001, 69002},// 14
{72661, 72662},// 15
{77401, 77402},// 16
{81301, 81302} // 17
};
int Num_Event = 99; //Obtem um numero expecífico para iniciar um evento
int Confirmar = 3; //Recebe um valor caso um pedido seja confirmado, recusado ou pendente
int Solicitado = 0; //inicia uma solicitação em alguns eventos
//Rseume todos os numeros que executam uma mesma ação no robô
int Comer[5] = {2,6,9,12,15};
int aleatorio[8] = {3,4,7,8,10,11,13,14};
int dormir[2] = {0, 17};
boolean Task_0; //ativa comandos
boolean Task_1; //ativa a função piscar
boolean Task_2; //ativa a função Observar
boolean Task_3; //ativa a função Emotes pela função "VideoAnimation"; pode ser ativado com "At_Frame = 1"
boolean Task_4; //ativa a função VideoAnimation pela função "Emotes"; pode ser ativada com "At_Gif = 1"
boolean Task_5; //ativa o Cooler
boolean Task_6; //ativa os leds frontal aleatório
boolean Task_7; //ativa os leds frontal arco_iris
boolean Task_8; //ativa o Delay_A
boolean Task_9; //ativa o Delay_B
boolean Task_10;//ativa o Delay_C
//____________________/RGB/______________________//
int ordemRGB = 0; //controla a ordem de cores quando há o efeito arco iris
int Type_Animation = 3;
int ValorL = 0;// define qual dos 3 leds rgb serão alterados
int VRGB[] = {0,0,0}; // Led's rgb de comando
int EstadoAnteriorRgb[3][3] = {
{0,0,0},
{0,0,0},
{0,0,0}
};
char RGB_Command[] = {'B', 'G', 'R'}; //comandos
int ValorRed1 = 0 ;
int ValorGreen1 = 0 ;
int ValorBlue1 = 0 ;
int ValorRed2 = 0 ;
int ValorGreen2 = 0 ;
int ValorBlue2 = 0 ;
int ValorRed3 = 0 ;
int ValorGreen3 = 0 ;
int ValorBlue3 = 0 ;
//____________________/EMOTES/______________________//
int At_Frame = 0; //Utilizado para Iniciar uma animação de Emotes após a animação de vídeo
int I_Frame = 0; //Indica o inicio de um emote expecífico.
int F_Frame = 1; //Indica o final de um emote expecífico.
int N_Frame = 0; //Indica em qual ponto o emote está para que o emote continue corretamente.
int click_A = LOW; //USADO PARA CRIAR PULSOS NO MOTOR X DO PESCOÇO
int click_B = LOW; //USADO PARA CRIAR PULSOS NO MOTOR QUE MOVE A ESTRUTURA DO PESCOÇO
int MapA; // Guarda os valores obtidos no potenciometro da cabeça
int MapB; // Guarda os valores obtidos no potenciometro do pescoço
int vxmin = 74; // define o valor minimo, caso o motor chegue nesse valor, será desligado imediatamente
int vxmax = 121; // define o valor máximo, caso o motor chegue nesse valor, será desligado imediatamente
int vymin = 105; //
int vymax = 180; //
int vzmin = 50; //
int vzmax = 101; //
int ValorX = 90; // valores que controlam o pescoço pelo controle
int ValorY = 180; //
int ValorZ = 99; //
int VXA = 90; // guarda o estado anterior do motor X
int VYA = 180; // guarda o estado anterior do servo Y
int VZA = 99; // guarda o estado anterior da estrutura do pescoço Z
//MOTOR DO PESCOÇO Max 120 Min 50 centro = 90;
int CodeM[20][2] = { //Codenadas para motor/pescoço
//Min/Max
{89,91},//0 animação 0 Ajuste(PADRÃO)
{90,95},//1 animação 0
{89,91},//2 animação 1 dormir
{49,51},//3 animação 1
{89,91},//4 animação 2 acordar
{89,91},//5 animação 2
{114,116},//6 animação 3 triste
{114,116},//7 animação 3
{69,71}, //8 animação 4 brincar
{89,91}, //9 animação 4
{99,101}, //10 animação 4
{89,91}, //11 animação 4
{89,91}, //12 animação 5 comer-beber
{89,91}, //13 animação 5
{49,51}, //14 animação 6 frio
{49,51}, //15 animação 6
{89,91}, //16 animação 7 calor
{89,91}, //17 animação 7
{89,91}, //18 animação 7
{89,91} //19 animação 7
};
int CodEx[20][2] = { //Codenadas para extrutura do pescoço
//Min/Max
{98,100},//0 animação 0 Ajuste(PADRÃO)
{98,100},//1 animação 0
{98,100},//2 animação 1 dormir
{98,100},//3 animação 1
{98,100},//4 animação 2 acordar
{98,100},//5 animação 2
{98,100},//6 animação 3 triste
{98,100},//7 animação 3
{98,100}, //8 animação 4 brincar
{98,100}, //9 animação 4
{98,100}, //10 animação 4
{98,100}, //11 animação 4
{98,100}, //12 animação 5 comer-beber
{98,100}, //13 animação 5
{98,100}, //14 animação 6 frio
{98,100}, //15 animação 6
{98,100}, //16 animação 7 calor
{98,100}, //17 animação 7
{98,100}, //18 animação 7
{98,100} //19 animação 7
};
// 180 = baixo; 105 = cima;
//Codenadas do servo/pescoço de 180 a 105
int CodeS[] = {
142,180, //ajuste
150,180, //dormir
155,110, //acordar
125,165, //triste
155,110,155,110, //brincar
105,180, //comer-beber
150,180, //frio
142,105,180,142 //calor
};
int CodeV[]= { //Guarda as velocidades do servo-motor no pescoço
10,15, // ajuste
30,20, // dormir
10,15, // acordar
50,20, // triste
20,20,20,20, // brincar
100,20, // comer-beber //erro
50,50, // frio
150,15,15,50 //calor //erro
};
int Motor[13][16] = {
//Motor Direção Acessórios
{1,1,1,1, 0,0,0,0}, //Nada 0
{0,1,1,1, 0,0,0,0}, //Frente 1
{0,1,1,1, 1,0,0,0}, //Frente + direita 2
{0,1,1,1, 0,1,0,0}, //Frente + esquerda 3
{1,0,1,1, 0,0,0,0}, //Ré 4
{1,0,1,1, 1,0,0,0}, //Ré + direita 5
{1,0,1,1, 0,1,0,0}, //Ré + Esquerda 6
{1,1,1,1, 1,0,0,0}, //Direita 7
{1,1,1,1, 0,1,0,0}, //Esquerda 8
{1,1,1,1, 0,0,0,0}, //Nada 9
{1,1,1,1, 0,0,1,0}, //Movea cabeça: Direita 10
{1,1,1,1, 0,0,0,0}, //Nada 11
{1,1,1,1, 0,0,0,1}, //Movea cabeça: Esquerda 12
// X X
};
//____________________/ANIMAÇÃO DE VÍDEO/______________________//
int At_Gif = 0; //Utilizado para Iniciar uma animação de vídeo após a animação de gestos
int I_Gif = 0; //Indica o inicio de uma animação de gif
int N_Gif = 0; //Indica o ponto frame atual do gif
int F_Gif = 0; //Indica o Final de uma animação de gif
//Variável para controle de gifs
int INF[3][9] = { // Inicio / Numero atual / Fim
//F F T B C L S L F
{0, 8, 25, 32, 38, 47, 52, 58, 62}, // Inicio
{0, 8, 25, 32, 38, 47, 52, 58, 62}, // Numero atual
{7,24, 31, 37, 46, 52, 57, 61, 84}, // FInal
};
//____________________/OLHOS/______________________//
int olhos[30][14] = {
// Direito Esquerdo
// a b c d e f g A B C D E F G
{1,1,0,0,1,1,1, 0,0,1,1,1,1,1}, //pacifica -------0 X = Eventos
{1,1,0,0,1,1,1, 1,1,0,0,1,1,1}, //pacifica_D -----1 X
{0,0,1,1,1,1,1, 0,0,1,1,1,1,1}, //pacifica_E -----2 X
{1,1,0,1,1,1,1, 1,0,1,1,1,1,1}, //cansada --------3 X
{1,0,1,1,1,1,1, 1,0,1,1,1,1,1}, //cansada_D ------4 X
{1,1,0,1,1,1,1, 1,1,0,1,1,1,1}, //cansada_E ------5 X
{1,1,0,0,0,1,1, 1,0,1,1,1,0,1}, //sede -----------6 X
{0,0,1,1,1,0,1, 1,0,1,1,1,0,1}, //sede_D ---------7 X
{1,1,0,1,0,1,1, 1,1,0,0,0,1,1}, //sede_E ---------8 X
{0,1,1,0,1,1,0, 0,1,1,0,1,1,0}, //fome -----------9 X
{0,0,0,0,1,1,0, 0,0,0,0,1,1,0}, //brincar --------10 X
{1,1,0,0,0,0,0, 0,0,1,1,0,0,0}, //frio -----------11 X
{0,1,0,0,0,1,0, 1,0,1,0,1,0,0}, //calor ----------12 X
{0,0,0,0,1,0,1, 0,0,0,0,0,1,1}, //boando ---------13
{0,1,1,0,0,0,0, 0,1,1,0,0,0,0}, //olho_fechado-1 -14 X comum
{1,1,1,0,0,0,0, 0,1,1,1,0,0,0}, //olho_fechado-2 -15 X cansado
{0,1,0,0,0,0,0, 0,0,1,0,0,0,0}, //triste ---------16
{1,0,0,0,1,1,1, 0,0,0,1,1,1,1}, //feliz ----------17
{1,0,0,0,1,1,1, 1,0,0,0,1,1,1}, //feliz_D --------18
{0,0,0,1,1,1,1, 0,0,0,1,1,1,1}, //feliz_E --------19
{1,0,1,0,0,1,1, 0,1,0,1,1,0,1}, //gentil ---------20
{0,1,0,1,1,0,1, 0,1,0,1,1,0,1}, //gentil_D -------21
{1,0,1,0,0,1,1, 1,0,1,0,0,1,1}, //gentil_E -------22
{0,0,0,0,1,1,1, 0,0,0,0,1,1,1}, //brava ----------23
{0,0,0,1,1,1,0, 0,0,0,1,1,1,0}, //brava_D --------24
{1,0,0,0,1,1,0, 1,0,0,0,1,1,0}, //brava_E --------25
{1,1,1,0,0,1,1, 0,1,1,1,1,0,1}, //corada ---------26
{0,1,1,1,1,0,1, 0,1,1,1,1,0,1}, //corada_D -------27
{1,1,1,0,0,1,1, 1,1,1,0,0,1,1}, //corada_E -------28
{0,0,0,0,0,0,0, 0,0,0,0,0,0,0} //Desligado ------29
};
int Number = 0; //usado atualmente na função "Piscar"
int Number1 = 0; //usado atualmente na função "Observar" para mudar a posição dos olhos
int Number_Eye = 0; //Guarda a posição atual para uma expressão dos olhos
int Eye_Memory = 0; //Guarda a posição padrão escolhida no evento atual (Utilizado na função "vigilante").
int Eyes_Closed = 14; //Guarda a posição na qual o olho se fechará com um formato diferente, por exemplo: 14, 15, 16
#include "neotimer.h"
#include <Servo.h>
Servo Servo1;
Neotimer Delay_RGB = Neotimer(120); //tempo que conmtrola as luzes rgb
Neotimer Delay_PA = Neotimer(50); //tempo que controlam os pulsos de energia do motor
Neotimer Delay_PB = Neotimer(50); //tempo que controlam os pulsos de energia do motor
Neotimer Delay_0A = Neotimer(3000); //tempo de finalização para cada pose
Neotimer Delay_0B = Neotimer(5000); //Tempo para desligar ventiladores em caso de ausencia
Neotimer Delay_1 = Neotimer(3000);//Inicia a função "Piscar"
Neotimer Delay_2 = Neotimer(1000);//Inicia a função "Observation"
Neotimer Delay_4 = Neotimer(50); //Utilizado na função "Video_Animation"
Neotimer Delay_A = Neotimer(60000); //Tempo para escolha do anfitrião
Neotimer Delay_B = Neotimer(60000); //Tempo de reação durante o Evento
Neotimer Delay_C = Neotimer(60000); //Tempo de reação após a conclusão do evento
// olho_D olho_E B1 G1 R1 B2 G2 R2 B3 G3 R3 CL
int Portas[24] = {33,34,35,36,37,38,39, 26,27,28,29,30,31,32, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
// motor/pescç direção/pescç
int PortasM[16] = {42,43,41,40, 22,23,24,25};
#define PtmC A1
#define PtmP A2
#define servo A0
#define botton A3
void setup(){
randomSeed(analogRead(A3));
Serial.begin(115200); //Serial USB
Serial2.begin(115200); //Serial Bluetooth
Serial3.begin(115200); //Serial Esp8266
//Display.begin(SSD1306_128X64);
Servo1.attach(servo);
Servo1.write(90);
for ( int Np = 0; Np <= 23; Np++) { //cria um loop que se repete 24 vezes
pinMode(Portas[Np], OUTPUT); //define todas as portas de leds como saida
digitalWrite(Portas[Np], LOW); //deixa todas as portas de leds desligadas
if (Np <= 7 && Np <= 3 ){ //verifica se o NP é menor ou equivalente a 3 e menor/igual a 7
pinMode(PortasM[Np], OUTPUT); //define todas as portas de 0 a 3 como saída
digitalWrite(PortasM[Np],HIGH); // define todas as portas de 0 a 3 como desligadas (em estado invertido)
}
if (Np <= 7 && Np >= 4 ){ //verifica se o NP é maior ou equivalente a 4 e menor/igual 7
pinMode(PortasM[Np], OUTPUT); //define todas as portas de 4 a 7 como saída
digitalWrite(PortasM[Np],LOW); //define todas as portas de 4 a 7 como desligado
}
}
pinMode(PtmC, INPUT);
pinMode(PtmP, INPUT);
pinMode(botton, INPUT);
Conect(); // verifica se há conexão com a internet
delay(3000);
}
void loop(){
Bloqueio(); //bloqueia algumas funções de acordo com eventos
Serial_2(); //verifica se recebeu algum comando via Bluetooth
RGB();
int map2 = analogRead(PtmP); // Atualiza a todo instante o valor atual do potenciometro
MapB = map(map2, 0, 1023, 0, 180); //mapeia o potenciometro deixando-o mais preciso
int map1 = analogRead(PtmC); // Atualiza a todo instante o valor atual do potenciometro
MapA = map(map1, 0, 1023, 0, 180); //mapeia o potenciometro deixando-o mais preciso
}
//____________________/AÇÕES PARA CONECT/____________________//
void Conect(){
for (int Ng = 0; Ng <= 13; Ng++){
digitalWrite(Portas[Ng], !olhos[14][Ng]); //fecha os olhos
}
N_Frame = I_Frame; //define o "Numero atual" como "Inicio"
int Px = 0; // sem uso
int Py = 0; // sem uso
String Mensagem_A;
String Mensagem_B;
int vMinA; //obtem o valor minimo de tolerancia para algum movimento expecífico
int vMaxA; //obtem um valor máximo de tolerancia para algum movimento expecífico
int vMinB; //
int vMaxB; //
int antBotton; //guarda o valor anterior do botão
int bot_confirm = LOW; //confirma os ajustes manuais quando o botão é apertado
int bot; //obtem os valores digitais do botão
while (ok_Esp <= 2){ //fecha um loop até que receba uma resposta se conexão
bot = digitalRead(botton); //obtem o valor digital do botão
int map2 = analogRead(PtmP); // Atualiza a todo instante o valor atual do potenciometro da estrutura
MapB = map(map2, 0, 1023, 0, 180); //mapeia o potenciometro deixando-o mais preciso
int map1 = analogRead(PtmC); // Atualiza a todo instante o valor atual do potenciometro da cabeça
MapA = map(map1, 0, 1023, 0, 180); //mapeia o potenciometro deixando-o mais preciso
if(bot == HIGH && antBotton == LOW){ //verifica se o botão foi pressionado
bot_confirm = HIGH;// confirma o pressionamento do botão
Delay_PA.set(50);
Delay_PB.set(50);
}else{ //entra em modo de configuração manual caso não tenha sido apertado
if (bot_confirm == LOW){ //desativa o modo ajuste manual e inicia a configuração automatica
Delay_PA.set(500);
Delay_PB.set(500);
vMinA = CodeM[1][0]; //obtem os valores maximos e minimos
vMaxA = CodeM[1][1];
vMinB = CodEx[1][0];
vMaxB = CodEx[1][1];
if(MapA >= vxmax){ //verifica se o MapA é maior ou igual a 121 (acima do limite definido em vxmax)
digitalWrite(Portas[1], LOW); //desliga um sentido do motor caso passe de 125 (acima do limite definido em vxmax)
}else if(MapA < vMinA){ //verifica se o MapA tem um valor menor que o desejado e o aumenta
if (Delay_PA.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(Portas[1], click_A); //Obtem um estado alternativo de click_A
click_A = !click_A; //liga e desliga a cada 500 milisegundos
}
}else{digitalWrite(Portas[1], LOW);} //desliga um setido do motor caso MapA seja maior que o valor desejado
if (MapA <= vxmin){ //verifica se o MapA é menor ou igual a 49 (abaixo do limite definido em vxmin)
digitalWrite(Portas[2], LOW); //desliga um sentido do motor caso fique menor ou igual a 55 (abaixo do limite definido em vxmin)
}else if(MapA > vMaxA){ //verifica se o MapA tem um valor maior que o desejado e diminui
if (Delay_PA.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(Portas[2], click_A); //Obtem um estado alternativo de click_A
click_A = !click_A; //inverte o estado da porta para criara pulsos
}
}else {digitalWrite(Portas[2], LOW);} //desliga um setido do motor caso MapA seja menor que o valor desejado
if(MapB >= vzmax){ //verifica se o MapB é maior ou igual a 176 (acima do limite definido em vzmax)
digitalWrite(Portas[8], LOW); //desliga um sentido do motor caso passe de 175 (acima do limite definido em vzmax)
}else if(MapB < vMinB){ //verifica se o MapB tem um valor menor que o desejado e o aumenta
if (Delay_PB.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(Portas[8], click_B); //Obtem um estado alternativo de click_B
click_B = !click_B; //liga e desliga a cada 500 milisegundos
}
}else{digitalWrite(Portas[8], LOW);} //desliga um setido do motor caso MapB seja maior que o valor desejado
if (MapB <= vzmin){ //verifica se o MapB é menor ou igual a 100 (abaixo do limite definido em vzmin)
digitalWrite(Portas[9], LOW); //desliga um sentido do motor caso fique menor ou igual a 100 (abaixo do limite definido em vzmin)
}else if(MapB > vMaxB){ //verifica se o MapB tem um valor maior que o desejado e diminui
if (Delay_PB.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(Portas[9], click_B); //Obtem um estado alternativo de click_B
click_B = !click_B; //inverte o estado da porta para criara pulsos
}
}else {digitalWrite(Portas[9], LOW);} //desliga um setido do motor caso MapB seja menor que o valor desejado
if(MapB >= vMinB && MapB <= vMaxB){ //verifica se o MapB está dentre as condições escolhidas
digitalWrite(Portas[8], LOW); //desliga ambos os sentidos do motor X
digitalWrite(Portas[9], LOW); //
VrB = 1; //confirma a finalização da atividade de um dos motores
}else{VrB = 0;}
if(MapA >= vMinA && MapA <= vMaxA){
digitalWrite(Portas[1], LOW); //desliga ambos os sentidos do motor X
digitalWrite(Portas[2], LOW); //
VrA = 1; //confirma a finalização da atividade de um dos motores
}else{VrA = 0;}
if(VrA == 1 && VrB == 1){ //verifica a confirmação dos motores para passar o próximo frame
///???
}
}
}
antBotton = bot;
if (ok_Esp == 1 && bot_confirm == HIGH){ //Inicia os ajustes de posição da cabeça após verificar o esp8266
for (int Np = I_Frame; Np <= F_Frame; Np++){// define o numero de posições da Kin.
vMinA = CodeM[Np][0];
vMaxA = CodeM[Np][1];
vMinB = CodEx[Np][0];
vMaxB = CodEx[Np][1];
if (N_Frame == Np){ //verifica em qual frame o emote parou para dar continuidade/inicialização
if(MapA >= vxmax){ //verifica se o MapA é maior ou igual a 121 (acima do limite definido em vxmax)
digitalWrite(PortasM[7], LOW); //desliga um sentido do motor caso passe de 125 (acima do limite definido em vxmax)
}else if(MapA < vMinA){ //verifica se o MapA tem um valor menor que o desejado e o aumenta
if (Delay_PA.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[7], click_A); //Obtem um estado alternativo de click_A
click_A = !click_A; //liga e desliga a cada 500 milisegundos
}
}else{digitalWrite(PortasM[7], LOW);} //desliga um setido do motor caso MapA seja maior que o valor desejado
if (MapA <= vxmin){ //verifica se o MapA é menor ou igual a 49 (abaixo do limite definido em vxmin)
digitalWrite(PortasM[6], LOW); //desliga um sentido do motor caso fique menor ou igual a 55 (abaixo do limite definido em vxmin)
}else if(MapA > vMaxA){ //verifica se o MapA tem um valor maior que o desejado e diminui
if (Delay_PA.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[6], click_A); //Obtem um estado alternativo de click_A
click_A = !click_A; //inverte o estado da porta para criara pulsos
}
}else {digitalWrite(PortasM[6], LOW);} //desliga um setido do motor caso MapA seja menor que o valor desejado
if(MapB >= vzmax){ //verifica se o MapB é maior ou igual a 176 (acima do limite definido em vzmax)
digitalWrite(PortasM[2], !LOW); //desliga um sentido do motor caso passe de 175 (acima do limite definido em vzmax)
}else if(MapB < vMinB){ //verifica se o MapB tem um valor menor que o desejado e o aumenta
if (Delay_PB.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[2], click_B); //Obtem um estado alternativo de click_B
click_B = !click_B; //liga e desliga a cada 500 milisegundos
}
}else{digitalWrite(PortasM[2], !LOW);} //desliga um setido do motor caso MapB seja maior que o valor desejado
if (MapB <= vzmin){ //verifica se o MapB é menor ou igual a 100 (abaixo do limite definido em vzmin)
digitalWrite(PortasM[3], !LOW); //desliga um sentido do motor caso fique menor ou igual a 100 (abaixo do limite definido em vzmin)
}else if(MapB > vMaxB){ //verifica se o MapB tem um valor maior que o desejado e diminui
if (Delay_PB.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[3], click_B); //Obtem um estado alternativo de click_B
click_B = !click_B; //inverte o estado da porta para criara pulsos
}
}else {digitalWrite(PortasM[3], !LOW);} //desliga um setido do motor caso MapB seja menor que o valor desejado
Servo1.write(CodeS[Np]); //controla o servo-motor no pescoço
// Servo1.slowmove(CodeS[Np], CodeV[Np]);
if(MapB >= vMinB && MapB <= vMaxB){ //verifica se o MapB está dentre as condições escolhidas
digitalWrite(PortasM[2], !LOW); //desliga ambos os sentidos do motor X
digitalWrite(PortasM[3], !LOW); //
VrB = 1; //confirma a finalização da atividade de um dos motores
}else{VrB = 0;}
if(MapA >= vMinA && MapA <= vMaxA){
digitalWrite(PortasM[6], LOW); //desliga ambos os sentidos do motor X
digitalWrite(PortasM[7], LOW); //
VrA = 1; //confirma a finalização da atividade de um dos motores
}else{VrA = 0;}
if(VrA == 1 && VrB == 1){ //verifica a confirmação dos motores para passar o próximo frame
if (Delay_0A.repeat()){ //aguarda 3 segundos em milis segundos antes de passar o próximo frame
VrA = 0; //reinicia a confirmação VrA para próximo frame
VrB = 0; //reinicia a confirmação VrB para próximo frame
N_Frame++; //atualiza o Frame
ok_Esp = 4;
digitalWrite(Portas[23], LOW); //desliga o ar após o processo
}
}
}
}
}
if (ok_Esp == 2 && bot_confirm == HIGH){ //Inicia os ajustes sem a verificação do esp8266, possivelmente bloqueando o modo wifi
for (int Np = I_Frame; Np <= F_Frame; Np++){// define o numero de posições da Kin.
vMinA = CodeM[Np][0];
vMaxA = CodeM[Np][1];
vMinB = CodEx[Np][0];
vMaxB = CodEx[Np][1];
if (N_Frame == Np){ //verifica em qual frame o emote parou para dar continuidade/inicialização
if(MapA >= vxmax){ //verifica se o MapA é maior ou igual a 121 (acima do limite definido em vxmax)
digitalWrite(PortasM[7], LOW); //desliga um sentido do motor caso passe de 125 (acima do limite definido em vxmax)
}else if(MapA < vMinA){ //verifica se o MapA tem um valor menor que o desejado e o aumenta
if (Delay_PA.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[7], click_A); //Obtem um estado alternativo de click_A
click_A = !click_A; //liga e desliga a cada 500 milisegundos
}
}else{digitalWrite(PortasM[7], LOW);} //desliga um setido do motor caso MapA seja maior que o valor desejado
if (MapA <= vxmin){ //verifica se o MapA é menor ou igual a 49 (abaixo do limite definido em vxmin)
digitalWrite(PortasM[6], LOW); //desliga um sentido do motor caso fique menor ou igual a 55 (abaixo do limite definido em vxmin)
}else if(MapA > vMaxA){ //verifica se o MapA tem um valor maior que o desejado e diminui
if (Delay_PA.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[6], click_A); //Obtem um estado alternativo de click_A
click_A = !click_A; //inverte o estado da porta para criara pulsos
}
}else {digitalWrite(PortasM[6], LOW);} //desliga um setido do motor caso MapA seja menor que o valor desejado
if(MapB >= vzmax){ //verifica se o MapB é maior ou igual a 176 (acima do limite definido em vzmax)
digitalWrite(PortasM[2], !LOW); //desliga um sentido do motor caso passe de 175 (acima do limite definido em vzmax)
}else if(MapB < vMinB){ //verifica se o MapB tem um valor menor que o desejado e o aumenta
if (Delay_PB.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[2], click_B); //Obtem um estado alternativo de click_B
click_B = !click_B; //liga e desliga a cada 500 milisegundos
}
}else{digitalWrite(PortasM[2], !LOW);} //desliga um setido do motor caso MapB seja maior que o valor desejado
if (MapB <= vzmin){ //verifica se o MapB é menor ou igual a 100 (abaixo do limite definido em vzmin)
digitalWrite(PortasM[3], !LOW); //desliga um sentido do motor caso fique menor ou igual a 100 (abaixo do limite definido em vzmin)
}else if(MapB > vMaxB){ //verifica se o MapB tem um valor maior que o desejado e diminui
if (Delay_PB.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[3], click_B); //Obtem um estado alternativo de click_B
click_B = !click_B; //inverte o estado da porta para criara pulsos
}
}else {digitalWrite(PortasM[3], !LOW);} //desliga um setido do motor caso MapB seja menor que o valor desejado
Servo1.write(CodeS[Np]); //controla o servo-motor no pescoço
//Servo1.slowmove(CodeS[Np], CodeV[Np]);
if(MapB >= vMinB && MapB <= vMaxB){ //verifica se o MapB está dentre as condições escolhidas
digitalWrite(PortasM[2], !LOW); //desliga ambos os sentidos do motor X
digitalWrite(PortasM[3], !LOW); //
VrB = 1; //confirma a finalização da atividade de um dos motores
}else{VrB = 0;}
if(MapA >= vMinA && MapA <= vMaxA){
digitalWrite(PortasM[6], LOW); //desliga ambos os sentidos do motor X
digitalWrite(PortasM[7], LOW); //
VrA = 1; //confirma a finalização da atividade de um dos motores
}else{VrA = 0;}
if(VrA == 1 && VrB == 1){ //verifica a confirmação dos motores para passar o próximo frame
if (Delay_0A.repeat()){ //aguarda 3 segundos em milis segundos antes de passar o próximo frame
VrA = 0; //reinicia a confirmação VrA para próximo frame
VrB = 0; //reinicia a confirmação VrB para próximo frame
N_Frame++; //atualiza o Frame
ok_Esp = 3;
digitalWrite(Portas[23], LOW); //desliga o ar após o processo
}
}
}
}
}
}
}
//-----------------------------------------------------------//
//____________________/FUNÇÃO PISCAR/____________________//
void Piscar(){
if (Delay_1.repeat()){
Delay_1 = 500; //deine um curto tempo para piscar
Number++;
if (Number == 1){
for (int Ng = 0; Ng <= 13; Ng++){
digitalWrite(Portas[Ng], !olhos[Eyes_Closed][Ng]);
}
Number++;
}
if (Number == 3){
for (int Ng = 0; Ng <= 13; Ng++){
digitalWrite(Portas[Ng], !olhos[Number_Eye][Ng]);
}
Number = 0;
int set1 = random(5, 13);
Delay_1 = set1 * 1000;
Serial.println("Piscar: ok");
}
}
}
//-------------------------------------------------------//
//____________________/OPÇÕES DE BLOQUEIO/____________________//
void Bloqueio(){
if (ok_Esp != 3){ //Impede que eventos diários iniciem em ordem de horários(PADRÃO)
Serial_3();
}
if (Task_0 == HIGH){ //desativa o recebimento de comandos
comandos();
}
if (Task_1 == HIGH){ //bloqueia aa animação padrão de piscar
Piscar();
}
if (Task_2 == HIGH){ //bloqueia a animação padrão de olhar
Observar();
}
if (At_Frame == 1){ //ativa os emotes através de 'video_animations'
Emotes();
}
if (At_Gif == 1){ //ativa as animações de vídeo através de "emotes"
Video_Animations();
}
if (Task_5 == HIGH){ // ativa o ventilador
digitalWrite(Portas[23], HIGH);
}else{
digitalWrite(Portas[23], LOW);
}
if (Task_8 == HIGH){ //Ativa o "Delay_A" de eventos
Tempo_A();
}
if (Task_9 == HIGH){ //Ativa o "Delay_B" de eventos
Tempo_B();
}
if (Task_10 == HIGH){ //Ativa o "Delay_C" de eventos
Tempo_C();
}
}
//------------------------------------------------------------//
//____________________/RGB/____________________//
void RGB() {
if (Type_Animation == 0){ //desliga todos osa leds da coleira
for (int I = 14; I <= 22; I++){
analogWrite(Portas[I], 0);
}
Type_Animation = 99;
}
if (Type_Animation == 1){ //opção de escolha de cores
for (int Nl = 0; Nl <= 2; Nl++){ //cria opções entre os leds rgb
if (ValorL == Nl){ //verifica qual opção foi escolhida
if (VRGB[Nl] != 0){ //verifica se houve mudança de comando
int Multiplo[] = {0, 3, 6};
int Info = 14;
Info = Info + Nl; // Nl = 0 a 2
Info + Multiplo[Nl];
for (int I = 0; I <= 2; I++){
EstadoAnteriorRgb[Nl][I] = VRGB[I];
analogWrite(Portas[Info], EstadoAnteriorRgb[Nl][I]);
}
VRGB[Nl] = 0;
}
}
}
} else if (Type_Animation == 2){ //Modo padrão do sistema: Arco-iris
Delay_RGB.set(10);
if (ordemRGB == 0){
if (Delay_RGB.repeat()){
if (ValorGreen1 < 255){
ValorGreen1 = ValorGreen1 + 5;
analogWrite(Portas[15], ValorGreen1);
}
if ((ValorGreen2 < 255)&&(ValorGreen1 > 40)){
ValorGreen2 = ValorGreen2 + 5;
analogWrite(Portas[18], ValorGreen2);
}
if ((ValorGreen3 < 255)&&(ValorGreen2 > 40)){
ValorGreen3 = ValorGreen3 + 5;
analogWrite(Portas[21], ValorGreen3);
}
if (ValorGreen3 == 255){
ordemRGB = 1;
}
}
}
if (ordemRGB == 1){
if (Delay_RGB.repeat()){
if (ValorRed1 > 0){
ValorRed1 = ValorRed1 - 5;
analogWrite(Portas[16], ValorRed1);
}
if ((ValorRed2 > 0)&&(ValorRed1 < 210)){
ValorRed2 = ValorRed2 - 5;
analogWrite(Portas[19], ValorRed2);
}
if ((ValorRed3 > 0)&&(ValorRed2 < 210)){
ValorRed3 = ValorRed3 - 5;
analogWrite(Portas[22], ValorRed3);
}
if (ValorRed3 == 0){
ordemRGB = 2;
}
}
}
if (ordemRGB == 2){
if (Delay_RGB.repeat()){
if (ValorBlue1 < 255){
ValorBlue1 = ValorBlue1 + 5;
analogWrite(Portas[14], ValorBlue1);
}
if ((ValorBlue2 < 255)&&(ValorBlue1 > 40)){
ValorBlue2 = ValorBlue2 + 5;
analogWrite(Portas[17], ValorBlue2);
}
if ((ValorBlue3 < 255)&&(ValorBlue2 > 40)){
ValorBlue3 = ValorBlue3 + 5;
analogWrite(Portas[20], ValorBlue3);
}
if (ValorBlue3 == 255){
ordemRGB = 3;
}
}
}
if (ordemRGB == 3){
if (Delay_RGB.repeat()){
if (ValorGreen1 > 0){
ValorGreen1 = ValorGreen1 - 5;
analogWrite(Portas[15], ValorGreen1);
}
if ((ValorGreen2 > 0)&&(ValorGreen1 < 210)){
ValorGreen2 = ValorGreen2 - 5;
analogWrite(Portas[18], ValorGreen2);
}
if ((ValorGreen3 > 0)&&(ValorGreen2 < 210)){
ValorGreen3 = ValorGreen3 - 5;
analogWrite(Portas[21], ValorGreen3);
}
if (ValorGreen3 == 0){
ordemRGB = 4;
}
}
}
if (ordemRGB == 4){
if (Delay_RGB.repeat()){
if (ValorRed1 < 255){
ValorRed1 = ValorRed1 + 5;
analogWrite(Portas[16], ValorRed1);
}
if ((ValorRed2 < 255)&&(ValorRed1 > 40)){
ValorRed2 = ValorRed2 + 5;
analogWrite(Portas[19], ValorRed2);
}
if ((ValorRed3 < 255)&&(ValorRed2 > 40)){
ValorRed3 = ValorRed3 + 5;
analogWrite(Portas[22], ValorRed3);
}
if (ValorRed3 == 255){
ordemRGB = 5;
}
}
}
if (ordemRGB == 5){
if (Delay_RGB.repeat()){
if (ValorBlue1 > 0){
ValorBlue1 = ValorBlue1 - 5;
analogWrite(Portas[14], ValorBlue1);
}
if ((ValorBlue2 > 0)&&(ValorBlue1 < 210)){
ValorBlue2 = ValorBlue2 - 5;
analogWrite(Portas[17], ValorBlue2);
}
if ((ValorBlue3 > 0)&&(ValorBlue2 < 210)){
ValorBlue3 = ValorBlue3 - 5;
analogWrite(Portas[20], ValorBlue3);
}
if (ValorBlue3 == 0){
ordemRGB = 0;
}
}
}
} else if (Type_Animation == 3){ //Modo padrão do sistema: Escolhas aleatórias
Delay_RGB.set(150);
if (Delay_RGB.repeat()){
int LRed = random(0, 256);
int LGreen = random(0, 256);
int LBlue = random(0, 256);
int Number2 = random (1, 4);
if (Number2 == 1){
analogWrite(Portas[16], LRed);
analogWrite(Portas[15], LGreen);
analogWrite(Portas[14], LBlue);
}
if (Number2 == 2){
analogWrite(Portas[19], LRed);
analogWrite(Portas[18], LGreen);
analogWrite(Portas[17], LBlue);
}
if (Number2 == 3){
analogWrite(Portas[22], LRed);
analogWrite(Portas[21], LGreen);
analogWrite(Portas[20], LBlue);
}
}
} else if (Type_Animation == 4){ //Modo de fita pulsante com opção de escolha de cores/tempos/luminosidade
}
}
//------------------------------------------------------------//
//____________________/EVENTOS/____________________//???
void Brevia(){
// o leitor passará uma unica vez em Brévia,
//aqui será definido toda a programação de uma
//brévia antes do mesmo iniciar.
/*if (I_Frame != 2 && F_Frame != 3){ //Dormir OK
for(int Ne = 0; Ne <= 1; Ne++){
if (Num_Event == dormir[Ne]){
Number_Eye = 3; //
Eye_Memory = 3; // - define os olhos para o sono
Eyes_Closed = 15; //
Delay_4.set(1000);// define o tempo da animação de vídeo atual
msg_Esp = 0; // - garante que os horários sejam escritos na posição correta
Recebido = ""; //
ok_Esp = 3;// bloqueia mensagens do Esp8266
I_Gif = 52; //
N_Gif = 52; // - animação de vídeo do sol se pondo
F_Gif = 57; //
Delay_A = 60000; //
Quantidade_A = 1; // - aguarda 1 Minuto para iniciar o evento dormir caso seja ignorado
Delay_A.repeatReset();
Solicitado = 1; //pede uma confirmação do evento
At_Gif = 1; //ativa a função de vídeo
Display.clrScr();
Display.setFont(SmallFont);
int set = random(0,5);
if(set == 0){
Display.print("Hora de dormir?", 0,0);
}else if (set == 1){
Display.print("Estou com sono... -.- zZ", 0,0);
}else if (set == 2){
Display.print("Vamos Dormir?", 0,0);
}else if (set == 3){
Display.print("Estou cansada.. -.-'", 0,0);
}else if (set == 4){
Display.print("Descansarei um pouco, Ok? -w-", 0,0);
}
Display.update();
for (int Ng = 0; Ng <= 8; Ng++){ //desativa e ativa algumas funções
Tasks[Ng][0] = Tasks[Ng][1];
}
}
}
}
*/
if (Num_Event == 1){ //Acordar OK
for (int Ng = 0; Ng <= 13; Ng++){
digitalWrite(Portas[Ng], !olhos[16][Ng]);
}
Serial.println("Brevia: ok");
At_Gif = 1;// inicia aimação de vídeo
I_Frame = 4; //
F_Frame = 5; // - centraliza a cabeça em ambos os motores
N_Frame = 4; //
ok_Esp = 3; //Bloqueia o Esp8266 temporáriamente
msg_Esp = 0; // - garante que os horários sejam escritos na posição correta
Recebido = ""; //
I_Gif = 47; //
N_Gif = 47; // - animação de vídeo amanhecer
F_Gif = 52; //
Task_0 = LOW; //desativa os comandos
Task_1 = LOW; //Função piscar desligada
Task_2 = LOW; //função Observar desligada
Task_3 = HIGH; //ativa os emotes após uma animação de vídeo
Task_4 = LOW; // DESLIGADO *inicia uma animação de vídeo após um emote*
Task_5 = HIGH; //Refrigeração
Task_6 = LOW; //leds no pescoço
Task_7 = LOW; //leds no pescoço
Delay_A = 5000; //define o primeiro tempo para 5 segundos
Task_8 = HIGH; //ativa ocronometro de 5 segundos
}
/* for (int Na = 0; Na <= 4; Na++){ //Comer
if (Num_Event == Comer[Na]){
Number_Eye = 6; //
Eye_Memory = 6; // - (= =)
Eyes_Closed = 14; // - olho fechado padrão
I_Frame = 12; //
F_Frame = 13; // - centraliza a cabeça em ambos motores, após isso abaixa
N_Frame = 12; //
ok_Esp = 3; //Bloqueia o Esp8266 temporáriamente
msg_Esp = 0; // - garante que os horários sejam escritos na posição correta
Recebido = ""; //
Solicitado = 1; //pede uma confirmação do evento
Display.clrScr();
Display.setFont(SmallFont);
int set = random(0,5);
if (set == 0){
Display.print("Estou com fome -.-'", 0,0);
}
if (set == 1){
Display.print("E o aomosso, cade? o-o", 0,0);
}
if (set == 2){
Display.print("Tem algo pra comer? 'u'", 0,0);
}
if (set == 3){
Display.print("Já ta na hora do aomosso? -w-", 0,0);
}
if (set == 4){
Display.print("O que tem de bom pra comer? 'w'", 0,0);
}
Display.update();
Delay_A = 5000;
Quantidade_A = 1;
Delay_A.repeatReset();
}
} */
}
void Tempo_A(){
if (Delay_A.repeat()){ // cancela um eventos, exceto alguns
/*
for(int Ne = 0; Ne <= 1; Ne++){
if (Num_Event == dormir[Ne]){//Dormir OK
Solicitado = 0;
Confirmar = 1;
Eventos();
}
}*/
if (Num_Event == 1){//acordar OK
Task_8 = LOW;
Serial.println("Tempo_A: ok");
Eventos();
}
/* for (int Na = 0; Na <= 4; Na++){//Comer OK
if (Num_Event == Comer[Na]){
Cancelado();
}
}*/
}
}
void Cancelado(){
for(int Ne = 0; Ne <= 1; Ne++){ //Dormir OK
if (Num_Event == dormir[Ne]){
int set = random(0,2);
if (set == 0){
Number_Eye = 16; //
Eye_Memory = 16; // - Olhos tristes
Eyes_Closed = 29; //
//Display.clrScr();
//Display.setFont(SmallFont);
//Display.print("Ah,oky.. -.-", 0,0);
//Display.update();
Delay_B = 5000;
//Delay_B.repeatReset();
I_Frame = 6; //
N_Frame = 6; // - move a cabeça para direita e para baixo
F_Frame = 7; //
I_Gif = 25; //
N_Gif = 25; // - Animação de vídeo coração partido
F_Gif = 31; //
Task_2 = LOW;
}
if (set == 1){
Number_Eye = 23; //
Eye_Memory = 23; // - Olhos Raivosos
Eyes_Closed = 14; //
// Display.clrScr();
//Display.setFont(SmallFont);
//Display.print("Ok o-o", 0,0);
//Display.update();
Delay_A = 60000;
// Delay_A.repeatReset();
Task_0 = LOW;
Task_5 = HIGH;
}
}
}
for(int Ne = 0; Ne <= 4; Ne++){ //Comer
if (Num_Event == Comer[Ne]){
}
}
}
void Tempo_B() {
if (Delay_B.repeat()){ //Tempo após a conclusão de um evento ou durante o evento
/*
for (int Na = 2; Na <= 3; Na++){//Recusados
if (Confirmar == Na){
for(int Ne = 0; Ne <= 1; Ne++){//Dormir_OK
if (Num_Event == dormir[Ne]){
Display.clrScr();
Display.update();
Delay_C = 30000; //Define um tempo para execução da reação: triste
Quantidade_C = 1; //Define uma quantidade de repetições
Quantidade_B = 0;
Delay_C.repeatReset(); //Ativa a função "Delay_C"
Delay_4.set(500);// tempo de animação
At_Gif = 1; //Ativa a videoAnimation
At_Frame = 1; //Ativa os Emotes
}
}
}
}
if (Confirmar == 1) {
for(int Ne = 0; Ne <= 1; Ne++){//Dormir OK
if (Num_Event == dormir[Ne]){
Display.clrScr();
Display.update();
At_Gif = 1;
At_Frame = 1;
Quantidade_B = 0;
Delay_C.set(30000);
Quantidade_C = 1;
Delay_C.repeatReset();
}
}
for (int Na = 0; Na <= 4; Na++){ //Comer
if (Num_Event == Comer[Na]){
Concluir();
}
}
}*/
if (Num_Event == 1){//acordar OK
Task_9 = LOW;
Serial.println("Tempo_B: ok");
Concluir();
}
}
}
void Eventos(){
// o leitor passará uma unica vez em eventos,
//aqui será definido toda a programação de um novo
//evento quando o mesmo for confirmado pelo anfitrião
for(int Na = 0; Na <= 1; Na++){//Dormir OK
if (Num_Event == dormir[Na]){
Eyes_Closed = 14; //Define estado do olho fechado
I_Frame = 2; //
F_Frame = 3; // - vira a cabeça para a esquerda e para baixo
N_Frame = 2; //
Delay_4.set(50);// define o tempo da animação de vídeo atual
ok_Esp = 3;// bloqueia mensagens do Esp8266
I_Gif = 0; //
N_Gif = 0; // - animação de vídeo frame_mono
F_Gif = 7; //
Delay_B = 5000;
// Delay_B.repeatReset();
Task_5 = HIGH; //liga o ar
//Display.clrScr();
//Display.setFont(SmallFont);
int set = random(0,5);
/*if(set == 0){
Display.print("Ate Amanha! 'u'", 0,0);
}else if (set == 1){
Display.print("Boa Noite -. - zzz", 0,0);
}else if (set == 2){
Display.print("Durma Bem -w- zz", 0,0);
}else if (set == 3){
Display.print("Ba Noite! 'w'", 0,0);
}else if (set == 4){
Display.print("Bons Sonhos ~w~", 0,0);
}
Display.update(); */
}
}
if (Num_Event == 1){ //Acordar OK
int set = random(0,2);
if (set == 0){
Number_Eye = 0; //
Eye_Memory = 0; // - define os olhos para padrão
Eyes_Closed = 14; //
Serial.println("Olhos comuns escolhidos");
//Display.clrScr();
//Display.setFont(SmallFont);
//Display.print("Ola! Bom dia! 'w'", 0,0);
}else{
Number_Eye = 3; //
Eye_Memory = 3; // - define os olhos para o sono
Eyes_Closed = 15; //
Serial.println("Olhos com sono escolhidos");
// Display.clrScr();
// Display.setFont(SmallFont);
// Display.print("Oii! Bom dia! -w-'", 0,0);
}
for (int Ng = 0; Ng <= 13; Ng++){
digitalWrite(Portas[Ng], !olhos[Eye_Memory][Ng]); //altera os zoio
}
// Display.update();
Serial.println("eventos: ok");
At_Frame = 1;// inicia aimação de emote
I_Frame = 0; //
F_Frame = 1; // - emote de ajuste
N_Frame = 0; //
ok_Esp = 4; //Desbloqueia o Esp8266
Task_0 = LOW; //desativa os comandos
Task_1 = HIGH; //Função piscar desligada
Task_2 = HIGH; //função Observar desligada
Task_3 = LOW; //ativa os emotes após uma animação de vídeo
Task_4 = LOW; // DESLIGADO *inicia uma animação de vídeo após um emote*
Task_5 = HIGH; //Refrigeração
Task_6 = LOW; //leds no pescoço
Task_7 = LOW; //leds no pescoço
Delay_B = 10000; //define o segundo tempo para 10 segundos
Task_9 = HIGH; //ativa o cronometro do segundo tempo
}
for (int Na = 0; Na <= 4; Na++){ //Comer
if (Num_Event == Comer[Na]){
Number_Eye = 6;
Eye_Memory = 6;
Eyes_Closed = 14;
I_Gif = 38; //
N_Gif = 38; // - animação: comer
F_Gif = 46; //
ok_Esp = 3;
I_Frame = 12; //
F_Frame = 13; // - centraliza a cabeça em ambos motores, após isso abaixa
N_Frame = 12; //
}
}
}
void Tempo_C() { // ???
/*
if (Delay_C.repeat()){ //Tempo após a conclusão de um evento
for (int Na = 2; Na <= 3; Na++){//Recusados
if (Confirmar == Na){
for (int Na = 0; Na <= 1; Na++){ //dormir ok
if (Num_Event == dormir[Na]){
Quantidade_C = 0;
Concluir();
}
}
}
}
for (int Na = 0; Na <= 1; Na++){ //dormir ok
if (Num_Event == dormir[Na]){
Quantidade_C = 0;
Display.clrScr();
Display.update();
At_Gif = 0;
At_Frame = 0;
Quantidade_B = 0;
Confirmar = 3;
Task_3 = LOW;
Task_4 = LOW;
ok_Esp = 4;
for (int Ng = 0; Ng <= 13; Ng++){
digitalWrite(Portas[Ng], olhos[Eyes_Closed][Ng]); //fecha os zoios
}
}
}*/
}
void Concluir(){
Task_0 = HIGH; //desativa os comandos
Task_1 = HIGH; //Função piscar desligada
Task_2 = HIGH; //função Observar desligada
Task_3 = LOW; //ativa os emotes após uma animação de vídeo
Task_4 = LOW; // DESLIGADO *inicia uma animação de vídeo após um emote*
Task_5 = LOW; //Refrigeração
Task_6 = LOW; //leds no pescoço
Task_7 = LOW; //leds no pescoço
Serial.println("Evento concluido!");
Number_Eye = 0; //
Eye_Memory = 0; // - define os olhos para padrão
Eyes_Closed = 14; //
// Display.clrScr();
// Display.update();
msg_Esp = 0; // - garante que os horários sejam escritos na posição correta
Recebido = ""; //
ok_Esp = 4; //desbloqueia o Esp8266
At_Gif = 0; // garantem que todas as funções estejam desligadas
At_Frame = 0; //
}
//-------------------------------------------------//
//____________________/AÇÕES PARA EMOTES/____________________//
void Emotes(){
// cria emotes que controlam a posição da cabeça e das patas de acordo com o evento atual
int vMinA;
int vMaxA;
int vMinB;
int vMaxB;
for (int Np = I_Frame; Np <= F_Frame; Np++){// define o numero de posições da Kin.
vMinA = CodeM[Np][0];
vMaxA = CodeM[Np][1];
vMinB = CodEx[Np][0];
vMaxB = CodEx[Np][1];
if (N_Frame == Np){ //verifica em qual frame o emote parou para dar continuidade/inicialização
if(MapA >= vxmax){ //verifica se o MapA é maior ou igual a 121 (acima do limite definido em vxmax)
digitalWrite(PortasM[7], LOW); //desliga um sentido do motor caso passe de 125 (acima do limite definido em vxmax)
}else if(MapA < vMinA){ //verifica se o MapA tem um valor menor que o desejado e o aumenta
if (Delay_PA.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[7], click_A); //Obtem um estado alternativo de click_A
click_A = !click_A; //liga e desliga a cada 500 milisegundos
}
}else{digitalWrite(PortasM[7], LOW);} //desliga um setido do motor caso MapA seja maior que o valor desejado
if (MapA <= vxmin){ //verifica se o MapA é menor ou igual a 49 (abaixo do limite definido em vxmin)
digitalWrite(PortasM[6], LOW); //desliga um sentido do motor caso fique menor ou igual a 55 (abaixo do limite definido em vxmin)
}else if(MapA > vMaxA){ //verifica se o MapA tem um valor maior que o desejado e diminui
if (Delay_PA.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[6], click_A); //Obtem um estado alternativo de click_A
click_A = !click_A; //inverte o estado da porta para criara pulsos
}
}else {digitalWrite(PortasM[6], LOW);} //desliga um setido do motor caso MapA seja menor que o valor desejado
if(MapB >= vzmax){ //verifica se o MapB é maior ou igual a 176 (acima do limite definido em vzmax)
digitalWrite(PortasM[2], !LOW); //desliga um sentido do motor caso passe de 175 (acima do limite definido em vzmax)
}else if(MapB < vMinB){ //verifica se o MapB tem um valor menor que o desejado e o aumenta
if (Delay_PB.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[2], click_B); //Obtem um estado alternativo de click_B
click_B = !click_B; //liga e desliga a cada 500 milisegundos
}
}else{digitalWrite(PortasM[2], !LOW);} //desliga um setido do motor caso MapB seja maior que o valor desejado
if (MapB <= vzmin){ //verifica se o MapB é menor ou igual a 100 (abaixo do limite definido em vzmin)
digitalWrite(PortasM[3], !LOW); //desliga um sentido do motor caso fique menor ou igual a 100 (abaixo do limite definido em vzmin)
}else if(MapB > vMaxB){ //verifica se o MapB tem um valor maior que o desejado e diminui
if (Delay_PB.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[3], click_B); //Obtem um estado alternativo de click_B
click_B = !click_B; //inverte o estado da porta para criara pulsos
}
}else {digitalWrite(PortasM[3], !LOW);} //desliga um setido do motor caso MapB seja menor que o valor desejado
Servo1.write(CodeS[Np]); //controla o servo-motor no pescoço
//Servo1.slowmove(CodeS[Np], CodeV[Np]);
if(MapB >= vMinB && MapB <= vMaxB){ //verifica se o MapB está dentre as condições escolhidas
digitalWrite(PortasM[2], !LOW); //desliga ambos os sentidos do motor X
digitalWrite(PortasM[3], !LOW); //
VrB = 1; //confirma a finalização da atividade de um dos motores
}
if(MapA >= vMinA && MapA <= vMaxA){
digitalWrite(PortasM[6], LOW); //desliga ambos os sentidos do motor X
digitalWrite(PortasM[7], LOW); //
VrA = 1; //confirma a finalização da atividade de um dos motores
}
if(VrA == 1 && VrB == 1){ //verifica a confirmação dos motores para passar o próximo frame
if (Delay_0A.repeat()){ //aguarda 3 segundos em milis segundos antes de passar o próximo frame
VrA = 0; //reinicia a confirmação VrA para próximo frame
VrB = 0; //reinicia a confirmação VrB para próximo frame
N_Frame++; //atualiza o Frame
}
}
}
}
if (N_Frame == F_Frame){
Task_3 = LOW;
Task_5 = LOW;
digitalWrite(Portas[23], LOW);//desliga o ar
if (Task_4 == HIGH){ //inicia uma animação de vídeo após o emote
At_Gif = 1;
}
}
}
//---------------------------------------------------------------//
//____________________/OPÇÕES DE CONTROLE/____________________//???
void comandos(){
for (int Nc = 1; Nc <= 8; Nc++){ //cria um loop que se repete 8 vezes, e obtem um valor a cada repetição
if (comando == Ctrl[Nc]){ //verifica se comando é igual a um dos caracteres em Ctrl[]
for (int Nf = 0; Nf <= 7; Nf++){ ////cria um loop que se repete 7 vezes, e obtem um valor a cada repetição
if(Nf <= 1){
digitalWrite(PortasM[Nf], Motor[Nc][Nf]); //altera apenas os estados dos motores que faz a kin se locomover
}
if(Nf >= 4 && Nf <= 5){
digitalWrite(PortasM[Nf], Motor[Nc][Nf]); //altera apenas os estados dos motores que faz a kin se locomover
}
}
}else{
digitalWrite(PortasM[0], HIGH); //desliga ambos os sentidos do motor de locomoção (inversamente)
digitalWrite(PortasM[1], HIGH); //desliga ambos os sentidos do motor de locomoção (inversamente)
digitalWrite(PortasM[4], LOW); //desliga ambos os sentidos do motor de direção de locomoção
digitalWrite(PortasM[5], LOW); //desliga ambos os sentidos do motor de direção de locomoção
}
}
if (Solicitado == 1){ //obtem uma resposta para poder ou não iniciar um evento
for (int Ne = 0; Ne <= 2; Ne++){
if (comando == resposta[Ne]){
Confirmar = Ne;
}
}
if (Confirmar == 1){
Solicitado = 0;
Confirmar = 3;
Eventos();
}
if (Confirmar == 0){
Delay_A.repeatReset();
Eye_Memory = 13;
Eyes_Closed = 16;
Task_2 = LOW;
Number_Eye = 13;
}
}
if (ValorX != VXA){//verifica se houve mudança de comandos
// cria emotes que controlam a posição da cabeça e das patas de acordo com o evento atual
int vMinA = ValorX - 1; //cria uma tolerancia minima e guarda em "vMinA"
int vMaxA = ValorX + 1; //cria uma tolerancia máxima e guarda em "vMaxA"
if(MapA >= vxmax){ //verifica se o MapA é maior ou igual a 121 (acima do limite definido em vxmax)
digitalWrite(PortasM[7], LOW); //desliga um sentido do motor caso passe de 125 (acima do limite definido em vxmax)
}else if(MapA < vMinA){ //verifica se o MapA tem um valor menor que o desejado e o aumenta
if (Delay_PA.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[7], click_A); //Obtem um estado alternativo de click_A
click_A = !click_A; //liga e desliga a cada 500 milisegundos
Task_5 = HIGH; //ativa o ventilador
Delay_0B.repeatReset(); //reinicia o tempo de atividade do ventilador
}
}else{digitalWrite(PortasM[7], LOW);} //desliga um setido do motor caso MapA seja maior que o valor desejado
if (MapA <= vxmin){ //verifica se o MapA é menor ou igual a 49 (abaixo do limite definido em vxmin)
digitalWrite(PortasM[6], LOW); //desliga um sentido do motor caso fique menor ou igual a 55 (abaixo do limite definido em vxmin)
}else if(MapA > vMaxA){ //verifica se o MapA tem um valor maior que o desejado e diminui
if (Delay_PA.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[6], click_A); //Obtem um estado alternativo de click_A
click_A = !click_A; //inverte o estado da porta para criar pulsos
Task_5 = HIGH; //ativa o ventilador
Delay_0B.repeatReset(); //reinicia o tempo de atividade do ventilador
}
}else {digitalWrite(PortasM[6], LOW);} //desliga um setido do motor caso MapA seja menor que o valor desejado
if(MapA >= vMinA && MapA <= vMaxA){ //verifica se MapA está dentre os valores de tolerancia
digitalWrite(PortasM[6], LOW); //desliga ambos os sentidos do motor X do pescoço
digitalWrite(PortasM[7], LOW); //desliga ambos os sentidos do motor X do pescoço
VXA = ValorX; //guarda o valor atual em VXA para que o comando não se repita
}
}
if (ValorZ != VZA){//verifica se houve mudança de comandos
// cria emotes que controlam a posição da cabeça e das patas de acordo com o evento atual
int vMinB = ValorZ - 1; //cria uma tolerancia minima e guarda em "vMinA"
int vMaxB = ValorZ + 1; //cria uma tolerancia máxima e guarda em "vMaxA"
if(MapB >= vzmax){ //verifica se o MapB é maior ou igual a 176 (acima do limite definido em vzmax)
digitalWrite(PortasM[2], !LOW); //desliga um sentido do motor caso passe de 175 (acima do limite definido em vzmax)
}else if(MapB < vMinB){ //verifica se o MapB tem um valor menor que o desejado e o aumenta
if (Delay_PB.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[2], click_B); //Obtem um estado alternativo de click_B
click_B = !click_B; //liga e desliga a cada 500 milisegundos
Task_5 = HIGH; //ativa o ventilador
Delay_0B.repeatReset(); //reinicia o tempo de atividade do ventilador
}
}else{digitalWrite(PortasM[2], !LOW);} //desliga um setido do motor caso MapB seja maior que o valor desejado
if (MapB <= vzmin){ //verifica se o MapB é menor ou igual a 100 (abaixo do limite definido em vzmin)
digitalWrite(PortasM[3], !LOW); //desliga um sentido do motor caso fique menor ou igual a 100 (abaixo do limite definido em vzmin)
}else if(MapB > vMaxB){ //verifica se o MapB tem um valor maior que o desejado e diminui
if (Delay_PB.repeat()){ //repete a função a cada 500 milisegundos
digitalWrite(PortasM[3], click_B); //Obtem um estado alternativo de click_B
click_B = !click_B; //inverte o estado da porta para criar pulsos
Task_5 = HIGH; //ativa o ventilador
Delay_0B.repeatReset(); //reinicia o tempo de atividade do ventilador
}
}else {digitalWrite(PortasM[3], !LOW);} //desliga um setido do motor caso MapB seja menor que o valor desejado
if(MapB >= vMinB && MapB <= vMaxB){ //verifica se MapB está dentre os valores de tolerancia
digitalWrite(PortasM[2], !LOW); //desliga ambos os sentidos do motor Z do pescoço
digitalWrite(PortasM[3], !LOW); //desliga ambos os sentidos do motor Z do pescoço
VZA = ValorZ; //guarda o valor atual em VZA para que o comando não se repita
}
}
if (ValorY != VYA){
if (ValorY >= vymin && ValorY <= vymax)
Servo1.write(ValorY);
Task_5 = HIGH;
Delay_0B.repeatReset();
VYA = ValorY;
}
if (Delay_0B.repeat(1)){//desliga o ventilador após 5 segundos de inatividade
Task_5 = LOW;
}
}
//------------------------------------------------------------//
//____________________/AÇÕES PARA ESP8266/____________________// <- REATIVE O SELETOR DE EVENTOS AQUI
void Serial_3(){
if (Serial3.available()){
char Byte = Serial3.read(); //recebe os horários
// Display.print(Byte, TextXy[0], 0); //escreve no display
Recebido += Byte; //guarda o primeiro valor que está em milisegundos -> 12345//00:00:00/ em formato de texto
valorData = Recebido.toInt(); // transforma-o em valor numérico e guarda na variável "valorData"
msg_Esp++; // aumenta 1 valor a cada caractere recebido, o máximo são 16 por vez
TextXy[0] = msg_Esp;
}
if (msg_Esp == 16){ //verifica se há 16 caracteres escritos e limpa o display para atualizar o que esta escrito
// Display.printNumI(MapA, 0, 8);
//Display.update();
msg_Esp = 0;
TextXy[0] = 0;
Recebido = "";
}
//APAGAR O CODIGO ABAIXO PARA O USO DE EVENTOS
if (Reset == 1){ //verifica se há um novo evento
Serial.println("Reset: ok");
Reset = 0;
valorData = 0;
Num_Event = 1; //guarda o evento atual
Brevia();
}
//DESMARCAR CODIGO ABAIXO PARA O USO DE EVENTOS
/*for (int Nt = 0; Nt <= 16; Nt++){
Valor1 = Hora[Nt][0];
Valor2 = Hora[Nt][1];
Valor3 = D_Hora[Nt][0];
Valor4 = D_Hora[Nt][1];
if(valorData >= Valor1 && valorData < Valor2){ //Verifica se o horário atual está dentre os horários de eventos
if(valorData >= Valor3 && valorData < Valor4){ //Verifica se o horário atual esta exatamente no início de um evento novo
Reset = 1; //Reseta as tarefas para começar um novo evento
valorData = 0;
// Serial.println("Tarefa Resetada");
}
if (Reset == 1){ //verifica se há um novo evento
Reset = 0;
valorData = 0;
//Serial.print("Valor da coluna = ");Serial.println(Nt);
Num_Event = Nt; //guarda o evento atual
Brevia();
}
}
}
*/
}
//------------------------------------------------------------//
//____________________/AÇÕES PARA MODULO BLUETOOTH/____________________//
void Serial_2(){
if (Serial.available()){
comando = Serial.read();
Mensagem += comando;
if (comando == 'T'){ // define um led
Type_Animation = Mensagem.toInt();
Serial.print("Tipo de animação: "); Serial.print(Type_Animation); Serial.println(" iniciado!");
Mensagem = "";
ordemRGB = 0; //reseta a animação
ValorRed1 = 0 ; //Limpa todas as cores
ValorGreen1 = 0 ;
ValorBlue1 = 0 ;
ValorRed2 = 0 ;
ValorGreen2 = 0 ;
ValorBlue2 = 0 ;
ValorRed3 = 0 ;
ValorGreen3 = 0 ;
ValorBlue3 = 0 ;
}
for (int Nc = 0; Nc <= 2; Nc++){ //cria um loop que se repete 3 vezes
if (comando == RGB_Command[Nc]){ // verifica se o comando recebido contém as letras "R""G""B" após um valor numérico: 255R 200G 100B
VRGB[Nc] = Mensagem.toInt(); //obtém o valor numérico e guarda o mesmo em uma das colunas de VRGB[];
Serial.print("VRGB: "); Serial.print(Nc); Serial.print(" Intensidade: ");Serial.println(VRGB[Nc]); //imprime o valor obtido por garantia de funcionamento
Mensagem = ""; //apaga o comando recebido para que um novo comando possa ser executado
}
}
if (comando == 'L'){ // define um led
ValorL = Mensagem.toInt(); //obtém um texto numérico e o transforma em um valor numérico e guarda em ValorL
Serial.print("ValorL: "); Serial.print(ValorL); Serial.println(" Obtido!"); //imprime o valor obtido por garantia de funcionamento
Mensagem = ""; //apaga o comando recebido para que um novo comando possa ser executado
}
if (comando == 'X'){ //Valores que alteram a posição da cabeça para direita/esquerda
ValorX = Mensagem.toInt();//obtém um texto numérico e o transforma em um valor numérico e guarda em ValorX
valorAnteriorX = ValorX; //guarda o valor de "ValorX" em valorAnteriorX
Serial.print("ValorX: "); Serial.print(ValorX); Serial.println(" Obtido!"); //imprime o valor obtido por garantia de funcionamento
Mensagem = ""; //apaga o comando recebido para que um novo comando possa ser executado
}
if(comando == 'Y'){ //Valores que alteram a posição da cabeça para cima/baixo
ValorY = Mensagem.toInt();//obtém um texto numérico e o transforma em um valor numérico e guarda em ValorY
valorAnteriorY = ValorY; //guarda o valor de "ValorY" em valorAnteriorY
Serial.print("ValorY: "); Serial.print(ValorY); Serial.println(" Obtido!"); //imprime o valor obtido por garantia de funcionamento
Mensagem = ""; //apaga o comando recebido para que um novo comando possa ser executado
}
if(comando == 'H'){ //Valores que alteram a posição da estrutura do pescoço para frente/tras
ValorZ = Mensagem.toInt();//obtém um texto numérico e o transforma em um valor numérico e guarda em ValorZ
valorAnteriorZ = ValorZ; //guarda o valor de "ValorZ" em valorAnteriorZ
Serial.print("ValorZ: "); Serial.print(ValorZ); Serial.println(" Obtido!"); //imprime o valor obtido por garantia de funcionamento
Mensagem = ""; //apaga o comando recebido para que um novo comando possa ser executado
}
}
}
//---------------------------------------------------------------------//
//____________________/OBSERVAR/______________________// Adicionar movimentos aleatórios
void Observar(){
if (Delay_2.repeat()){ //repete os comandos dentro dele a cada 5 segundos após um periodo de espera
if (Chances == 0){
Chances = random(1, 5); //escolhe um numero de 1 a 4 e guarda o valor em "Chances"
valorAnteriorY = ValorY; //guarda os valores da ultima posição que a cabeça esteve
valorAnteriorX = ValorX; //guarda os valores da ultima posição que a cabeça esteve
valorAnteriorZ = ValorZ; //guarda os valores da ultima posição que a cabeça esteve
Serial.print("VLX_Guardado = "); Serial.println(ValorX); //imprime os valores X da antiga posição
Serial.print("VLY_Guardado = "); Serial.println(ValorY); //imprime os valores Y da antiga posição
Serial.print("VLZ_Guardado = "); Serial.println(ValorZ); //imprime os valores Y da antiga posição
Serial.print("Chances: "); Serial.println(Chances); //imprime o valor que foi guardado em "Chances"
}
Delay_2.set(5000); //define o tempo da animação dos olhos para 5 segundos em milis
Number1++; //altera a posição dos "FRAMES" a cada 5 segundos
if (Number1 == 1){// FRAME 1
int eye = random(1,3); // escolhe entre 1 e 2 para decidir se começará olhando para esquerda/direita
Number_Eye = Eye_Memory + eye; //guarda em "Number_Eye" o valor do olhar memorizado e adiciona um valor escolhido;
for (int Ng = 0; Ng <= 13; Ng++){ //cria um loop que se repete 14 vezes
digitalWrite(Portas[Ng], !olhos[Number_Eye][Ng]); //Altera o estado de cada porta mudando o desenho nos olhos
}
if (Chances == 4 && Task_0 == HIGH){ //verifica se "Chances" é igual a 4 e se os comandos estão ativos
//escolhe um valor dentre os limites definiddos em vxmin e vymax, com uma limitação de 2 para que não escolha um valor limitado
int PosicaoX = random(vxmin + 2, vxmax - 2); //escolhe e guarda um valor que move o motor do pescoço em PosicaoX
int PosicaoY = random(vymin + 2, vymax - 2); //escolhe e guarda um valor que move o Servo do pescoço em PosicaoY
int PosicaoZ = random(vzmin + 35, vzmax - 2); //escolhe e guarda um valor que move o Servo do pescoço em PosicaoZ
int mov = random(0,4); //esccolhe um valor de 0 a 3
ValorX = PosicaoX; //guarda o valor escolhido em ValorX, fazendo o pescoço se mover para direita/esquerda
ValorY = PosicaoY; //guarda o valor escolhido em ValorY, fazendo o pescoço se mover para cima/baixo
if (mov == 2){ //verifica se mov equivale a 2
ValorZ = PosicaoZ; //guarda o valor escolhido em ValorZ, fazendo o pescoço se mover para frente/tras
}
Serial.print("VLX_escolhidoA = "); Serial.println(ValorX); //imprime quais valores X foram escolhidos pelo random
Serial.print("VLY_escolhidoA = "); Serial.println(ValorY); //imprime quais valores Y foram escolhidos pelo random
Serial.print("VLZ_escolhidoA = "); Serial.println(ValorZ); //imprime quais valores Z foram escolhidos pelo random
}
Number1++; //impede que o frame atual se repita e aguarda mais 5 segundos em milis
}
if (Number1 == 3){ // FRAME 2
int eye = random(1,3); // escolhe entre 1 e 2 para decidir se começará olhando para esquerda/direita
Number_Eye = Eye_Memory + eye; //guarda em "Number_Eye" o valor do olhar memorizado e adiciona um valor escolhido;
for (int Ng = 0; Ng <= 13; Ng++){ //cria um loop que se repete 14 vezes
digitalWrite(Portas[Ng], !olhos[Number_Eye][Ng]); //Altera o estado de cada porta mudando o desenho nos olhos
}
if (Chances == 4 && Task_0 == HIGH){ //verifica se "Chances" é igual a 4 e se os comandos estão ativos
digitalWrite(PortasM[6], LOW); //garante que ambos os sentidos de rotação do motor esteja desligado
digitalWrite(PortasM[7], LOW); //garante que ambos os sentidos de rotação do motor esteja desligado
digitalWrite(PortasM[2], !LOW); //garante que ambos os sentidos de rotação do motor esteja desligado
digitalWrite(PortasM[3], !LOW); //garante que ambos os sentidos de rotação do motor esteja desligado
//escolhe um valor dentre os limites definiddos em vxmin e vymax, com uma limitação de 2 para que não escolha um valor limitado
int PosicaoX = random(vxmin + 2, vxmax - 2); //escolhe e guarda um valor que move o motor do pescoço em PosicaoX
int PosicaoY = random(vymin + 2, vymax - 2); //escolhe e guarda um valor que move o Servo do pescoço em PosicaoY
int PosicaoZ = random(vzmin + 35, vzmax - 2); //escolhe e guarda um valor que move o Servo do pescoço em PosicaoZ
int mov = random(0,4); //esccolhe um valor de 0 a 3
ValorX = PosicaoX; //guarda o valor escolhido em ValorX, fazendo o pescoço se mover para direita/esquerda
ValorY = PosicaoY; //guarda o valor escolhido em ValorY, fazendo o pescoço se mover para cima/baixo
if (mov == 2){ //verifica se mov equivale a 2
ValorZ = PosicaoZ; //guarda o valor escolhido em ValorZ, fazendo o pescoço se mover para frente/tras
}
Serial.print("VLX_escolhidoB = "); Serial.println(ValorX); //imprime quais valores X foram escolhidos pelo random
Serial.print("VLY_escolhidoB = "); Serial.println(ValorY); //imprime quais valores Y foram escolhidos pelo random
Serial.print("VLZ_escolhidoB = "); Serial.println(ValorZ); //imprime quais valores Z foram escolhidos pelo random
}
Number1++; //impede que o frame atual se repita e aguarda mais 5 segundos em milis
}
if (Number1 == 5){ // FRAME 3
Number_Eye = Eye_Memory; //guarda em "Number_Eye" o valor do olhar memorizado
for (int Ng = 0; Ng <= 13; Ng++){ //cria um loop que se repete 14 vezes
digitalWrite(Portas[Ng], !olhos[Number_Eye][Ng]); //Altera o estado de cada porta mudando o desenho nos olhos
}
if (Chances == 4 && Task_0 == HIGH){ //verifica se "Chances" é igual a 4 e se os comandos estão ativos
digitalWrite(PortasM[6], LOW); //garante que ambos os sentidos de rotação do motor esteja desligado
digitalWrite(PortasM[7], LOW); //garante que ambos os sentidos de rotação do motor esteja desligado
digitalWrite(PortasM[2], !LOW); //garante que ambos os sentidos de rotação do motor esteja desligado
digitalWrite(PortasM[3], !LOW); //garante que ambos os sentidos de rotação do motor esteja desligado
ValorX = valorAnteriorX; //Envia para ValorX a antiga posição da cabeça
ValorY = valorAnteriorY; //Envia para ValorY a antiga posição da cabeça
ValorZ = valorAnteriorZ; //Envia para ValorZ a antiga posição da cabeça
Serial.print("VLX_reset = "); Serial.println(ValorX); //imprime o valor em que a cabeça esteve antes
Serial.print("VLY_reset = "); Serial.println(ValorY); //imprime o valor em que a cabeça esteve antes
Serial.print("VLZ_reset = "); Serial.println(ValorZ); //imprime o valor em que a cabeça esteve antes
}
int set1 = random(10, 31); //guarda em set1 um valor de 10 a 30 segundos
int Valor = set1 * 1000; //transforma o valor de set1 em milisegundos e guarda em "Valor"
Number1 = 0; //redefine "Number1" para ser usado novamente
Chances = 0; //redefine "Chances" para ser usado novamente
Serial.println("Observar: Ok"); //imprime a confirmação da finalização de "Observation"
Serial.print("Proximo tempo:"); Serial.println(Valor); //imprime qual será o tempo de espera para que tudo se repita
Delay_2.set(Valor); //define o tempo escolhido em milisegundos
}
}
}
//--------------------------------------------------------//
//____________________/Video_Animations/____________________// Alterar comandos para nova biblioteca
void Video_Animations(){
At_Gif = 0;
Task_4 = LOW;
if(Task_3 == HIGH){
At_Frame = 1;
}
}
//----------------------------------------------------------//