//____________________/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; //faz a contagem de quantas barras aparecem em 12345//00:00:00/
int ok_Esp = 0; // 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
{88,92},//0 animação 0 Ajuste(PADRÃO)
{88,92},//1 animação 0
{89,91},//2 animação 1 dormir
{49,51},//3 animação 1
{88,92},//4 animação 2 acordar
{88,92},//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
{97,100},//0 animação 0 Ajuste(PADRÃO)
{97,100},//1 animação 0
{97,100},//2 animação 1 dormir
{97,100},//3 animação 1
{97,100},//4 animação 2 acordar
{97,100},//5 animação 2
{97,100},//6 animação 3 triste
{97,100},//7 animação 3
{97,100}, //8 animação 4 brincar
{97,100}, //9 animação 4
{97,100}, //10 animação 4
{97,100}, //11 animação 4
{97,100}, //12 animação 5 comer-beber
{97,100}, //13 animação 5
{97,100}, //14 animação 6 frio
{97,100}, //15 animação 6
{97,100}, //16 animação 7 calor
{97,100}, //17 animação 7
{97,100}, //18 animação 7
{97,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
/*INFORMAÇÕES DE SERVIÇO:
* Nome: Kin_Kitsune
* senha: 2570
* velocidade: 115200
* versão: linvorV1.8
* enviar a palavra reset/Reset/RESET/ok/Ok/OK para resetar listas de rede wifi
*/
/* ESQUEMA DE CONEXÕES DA CABEÇA
[B.C.D.E.F.G.s.s.a.b.c.d.e.f.g.S.-] Novo
[A.x.+.+.+.+.+.+.+.+.+.+.+.+.+.+.]
Letras de A - G: Olho Esquerdo
Letras de a - g: Olho Direito
S: Servo_motor
s: Speaker, + e -
o: GND/desligado
x: N/D (Sem pinos)
ESQUEMA DE PINOS NO PESCOÇO (Visão de frente a kin)
Potenciometros
[-.S.P2.P1.+] [m.m] - motor do pescoço
[A.B.C.D.E.F.G.a.b.c.d.e.f.g] - leds dos olhos
-: negativo
+: positivo
S; Servo da cabeça
m: motor do pescoço L.R
A - G: olhos Esquerdos
a - g; olhos direitos
P1: potenciometro de controle X (esquerda e direita)
P2: potenciometro de controle Y (Cima e baixo)
ESQUEMA DE PINOS NA PLACA REGULADORA DE TENSÃO
08 Pino emissor de tensão (Energia que alimenta os motores)
09 Pino 12V+
10 pino emissor de tensão (Energia que alimenta a placa de relés)
11 pino emissor de tensão (Energia que alimenta a placa de relés)
12 Gnd
13 Gnd
14 Gnd
15 Gnd
16 Gnd
17 Gnd
*/
//#include "Fr-Var.h"
//#include <VarSpeedServo.h>
#include <Servo.h>
#include "neotimer.h"
Servo Servo1;
//VarSpeedServo 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}; //Portas que controlam motores
int PortasA[12] = {A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15}; //Portas analogicas que não serão utilizadas
int PortasD[10] = {44,45,46,47,48,49,50,51,52,53}; //Portas digitais que não serão utilizadas
#define PtmC A1
#define PtmP A2
#define botton A3
#define servo A0
void setup(){
randomSeed(analogRead(A2));
Serial.begin(115200); //Serial USB
Serial2.begin(115200); //Serial Bluetooth
Serial3.begin(115200); //Serial Esp8266
Servo1.attach(servo);
//Servo1.slowmove(180, 10);
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], !LOW); // 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
}
if (Np >= 0 && Np <= 11){ //define as portas de 0 a 11
pinMode(PortasA[Np], OUTPUT); //define todas as portas de 0 a 11 como entrada
digitalWrite(PortasA[Np],LOW); //define todas as portas de 4 a 7 como desligado
}
if (Np >= 0 && Np <= 9){ //verifica se o NP é maior ou equivalente a 4 e menor/igual 7
pinMode(PortasD[Np], OUTPUT); //define todas as portas de 4 a 7 como saída
digitalWrite(PortasD[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
}
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
}
//____________________/RGB/____________________// (SEM USO)
void RGB() {
if (Type_Animation == 0){
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
validar = 0; // - garante que os horários sejam escritos na posição correta
Recebido = ""; //
Valido = 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 = 0; //Bloqueia o Esp8266 temporáriamente 3
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; //
Valido = 3; //Bloqueia o Esp8266 temporáriamente
validar = 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;
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.print("Ah,oky.. -.-", 0,0);
Delay_B = 5000;
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.print("Ok o-o", 0,0);
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;
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;
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;
Valido = 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; //
}
//-------------------------------------------------//
//____________________/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){
comandos();
}
if (Task_1 == HIGH){
Piscar();
}
if (Task_2 == HIGH){
Observar();
}
if (At_Frame == 1){
Emotes();
}
if (At_Gif == 1){
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
Tempo_A();
}
if (Task_9 == HIGH){ //Ativa o Delay_B
Tempo_B();
}
if (Task_10 == HIGH){ //Ativa o Delay_C
Tempo_C();
}
}
//------------------------------------------------------------//
//____________________/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.slowmove(CodeS[Np], CodeV[Np]);
Servo1.write(CodeS[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 - 2; //cria uma tolerancia minima e guarda em "vMinA"
int vMaxA = ValorX + 2; //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 - 2; //cria uma tolerancia minima e guarda em "vMinA"
int vMaxB = ValorZ + 2; //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()){ //serial3
char Byte = Serial3.read(); //recebe os horários
Recebido += Byte; //guarda o primeiro valor que está em milisegundos -> 12345//00:00:00/ em formato de texto
valorData = Recebido.toInt();
if (Byte == '/'){ //verifica se comando recebeu um bite equivalente a "/" de 12345//00:00:00/
valorData = Recebido.toInt(); //transforma textos que contém números em apenas números e guarda em set
Recebido = ""; //apaga o ultimo texto recebido antes do "/"
if(msg_Esp == 0){ //verifica se o valor em msg_Esp para imprimir apenas o primeiro valor de 12345//00:00:00/
Serial.print("Valor em segundos: ");Serial.println(valorData); // imprime 12345 de 12345//00:00:00/
Serial2.print(valorData); Serial2.print("S");
}
msg_Esp++; //almenta msg_Esp para que não sejam impressos os outros valores de 12345//00:00:00/
if(msg_Esp == 3){ //verifica se msg_Esp alcançou o numero total de barras em 12345//00:00:00/
msg_Esp = 0; //reseta msg_Esp para imprimir o próximo valor
}
}
}
//APAGAR O CODIGO ABAIXO PARA O USO DE EVENTOS
if (Reset == 1){ //verifica se há um novo evento
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++){ //cr R G B
if (comando == RGB_Command[Nc]){
VRGB[Nc] = Mensagem.toInt();
Serial.print("VRGB: "); Serial.print(Nc); Serial.print(" Intensidade: ");Serial.println(VRGB[Nc]);
Mensagem = "";
}
}
if (comando == 'L'){ // define um led
ValorL = Mensagem.toInt();
Serial.print("ValorL: "); Serial.print(ValorL); Serial.println(" Obtido!");
Mensagem = "";
}
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
}
}
}
//---------------------------------------------------------------------//
//____________________/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 count = 0; //conta o numero de barras que aparece em 12345//00:00:00/
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
Serial.println("Config Modew");
while (ok_Esp <= 2){
bot = digitalRead(botton);
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 (Serial.available()){
comando = Serial.read();
Mensagem_A += comando;
//Serial.print(comando);
Serial2.print(comando);
if (Mensagem_A.indexOf("SS") > 0){ //confirma a conexão com a internet
ok_Esp = 1; //guarda a confirmação em ok_Esp
Mensagem_A = ""; //apaga a mensagem
digitalWrite(Portas[23], HIGH); //Liga o Ar
Serial.print("Conexao confirmada");
}
if (comando == '/'){ //verifica se comando recebeu um bite equivalente a "/" de 12345//00:00:00/
int set = Mensagem_A.toInt(); //transforma textos que contém números em apenas números e guarda em set
Mensagem_A = ""; //apaga o ultimo texto recebido antes do "/"
if(count == 0){ //verifica se o valor em count para imprimir apenas o primeiro valor de 12345//00:00:00/
Serial.print("Valor em segundos: ");Serial.println(set); // imprime 12345 de 12345//00:00:00/
}
count++; //almenta count para que não sejam impressos os outros valores de 12345//00:00:00/
if(count == 3){ //verifica se count alcançou o numero total de barras em 12345//00:00:00/
count = 0; //reseta count para imprimir o próximo valor
}
}
}
if (Serial2.available()){ //cancela verificação de conecxão do esp para iniciar sem internet
char Cr = Serial2.read();
Mensagem_B += Cr;
if (Mensagem_B.indexOf("Ok") > 0){
digitalWrite(Portas[23], HIGH); //Liga o Ar
ok_Esp = 2;
}
}
if(bot == HIGH && antBotton == LOW){ //verifica se o botão foi pressionado
bot_confirm = HIGH;// confirma o pressionamento do botão
Delay_PA.set(20);
Delay_PB.set(20);
}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[2], LOW); //desliga um dos leds para indicar que a configuração está acima do limite
}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[2], click_A); //desliga e liga um dos leds para indicar a posição correta
click_A = !click_A; //liga e desliga a cada 500 milisegundos
}
}else{digitalWrite(Portas[2], LOW);} //desliga um dos leds para indicar que a configuração está acima do limite
if (MapA <= vxmin){ //verifica se o MapA é menor ou igual a 49 (abaixo do limite definido em vxmin)
digitalWrite(Portas[1], LOW); //desliga um dos leds para indicar que a configuração está abaixo do limite
}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[1], click_A); //desliga e liga um dos leds para indicar a posição correta
click_A = !click_A; //liga e desliga a cada 500 milisegundos
}
}else {digitalWrite(Portas[1], LOW);} //desliga um dos leds para indicar que a configuração está acima do limite
if(MapB >= vzmax){ //verifica se o MapB é maior ou igual a 176 (acima do limite definido em vzmax)
digitalWrite(Portas[8], LOW); //desliga um dos leds para indicar que a configuração está acima do limite
}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); //desliga e liga um dos leds para indicar a posição correta
click_B = !click_B; //liga e desliga a cada 500 milisegundos
}
}else{digitalWrite(Portas[8], LOW);} //desliga um dos leds para indicar que a configuração está acima do limite
if (MapB <= vzmin){ //verifica se o MapB é menor ou igual a 100 (abaixo do limite definido em vzmin)
digitalWrite(Portas[9], LOW); //desliga um dos leds para indicar que a configuração está abaixo do limite
}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); //desliga e liga um dos leds para indicar a posição correta
click_B = !click_B; //inverte o estado da porta para criara pulsos
}
}else {digitalWrite(Portas[9], LOW);} //desliga um dos leds para indicar que a configuração está abaixo do limite
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
}
}
}
}
}
}
}
//-----------------------------------------------------------//
//____________________/OBSERVAR/______________________//
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(){
/*
if (Delay_4.repeat()){//tempo de animação
if (I_Gif == 0 && N_Gif <= 7){
Display.setCursor(0,0);
Display.draw(Frames[N_Gif], 128, 64);
N_Gif++;
if (N_Gif == 7){I_Gif = 7;}
}
if (I_Gif == 7 && N_Gif >= 0){
Display.setCursor(0,0);
Display.draw(Frames[N_Gif], 128, 64);
N_Gif--;
if (N_Gif == 0){I_Gif = 0;}
}
if (I_Gif >= 8 && F_Gif <= 83){
if (N_Gif <= F_Gif){
Display.setCursor(0,0);
Display.draw(Frames[N_Gif], 128, 64);
N_Gif++;
if (N_Gif == F_Gif && F_Gif != 83){
At_Gif = 0;
Task_4 = LOW;
N_Gif = I_Gif;
Valido = 2;
if(Task_3 == HIGH){
At_Frame = 1;
}
}
}
}
if (N_Gif == 83){
Display.setCursor(0,0);
Display.draw(Frames[N_Gif], 128, 64);
N_Gif++;
}
if (N_Gif == 84){
Display.setCursor(0,0);
Display.draw(Frames[N_Gif], 128, 64);
N_Gif--;
}
}
*/
//APAGUE O CÓDIGO BAIXO APÓS FINALIZAR O CODIGO ACIMA
At_Gif = 0;
Task_4 = LOW;
if(Task_3 == HIGH){
At_Frame = 1;
}
}
//----------------------------------------------------------//