//____________________/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[] = {0,0}; //Obtem o ultimo valor em ValorX / ValorY / ValorZ para
int valorAnteriorX[] = {0,0}; //colocar-la na posição em que estava antes da função
int valorAnteriorZ[] = {0,0}; //"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.
// define o valor minimo, caso o motor chegue nesse valor, será desligado imediatamente
int vxmin = 90; // Controle X do pescoço
int vxmax = 180; // -
int vymin = 10; // Controle Y da cabeça
int vymax = 180; // -
int vzmin = 80; // Controle Y do pescoço
int vzmax = 180; // -
int ValorX = 130; // valores que Guardam a memória de posicionamento dos servos
int ValorY = 105; //
int ValorZ = 80; //
int VXA = 0; //guarda o estado anterior do Servo X
int VYA = 0; //guarda o estado anterior do servo Y
int VZA = 0; //guarda o estado anterior da estrutura do pescoço: servo Z
// x y z
int Velocidades[] = {255,30,50}; // guarda as velocidades escolhidas pelo usiário e pelo sistema
// 10 20 30 40 50 60 70 80 90 100
// 180 = Esquerda e 90 = Direita 90 100 110 120 130 140 150 160 170 180
// Servo motor com adaptação extrutural X
int CodeC[20][2] = { //Codenadas para motor/pescoço
//valor/velocidade
{130,92},//0 animação 0 Ajuste(PADRÃO)
{130,92},//1 animação 0
{90, 91},//2 animação 1 dormir
{140,51},//3 animação 1
{130,92},//4 animação 2 acordar
{130,92},//5 animação 2
{114,116},//6 animação 3 triste
{114,116},//7 animação 3
{90,71}, //8 animação 4 brincar
{90,91}, //9 animação 4
{99,101}, //10 animação 4
{90,91}, //11 animação 4
{90,91}, //12 animação 5 comer-beber
{90,91}, //13 animação 5
{90,51}, //14 animação 6 frio
{90,51}, //15 animação 6
{90,91}, //16 animação 7 calor
{90,91}, //17 animação 7
{90,91}, //18 animação 7
{90,91} //19 animação 7
};
// 10 20 30 40 50 60 70 80 90 100 110
// 180 = Baixo e 80 = cima 80 90 100 110 120 130 140 150 160 170 180
// Servo motor com adaptação extrutural Y
int CodeP[20][2] = { //Codenadas para extrutura do pescoço
//valor/velocidade
{130,100},//0 animação 0 Ajuste(PADRÃO)
{80,100},//1 animação 0
{130,100},//2 animação 1 dormir
{180,100},//3 animação 1
{130,70},//4 animação 2 acordar
{80,100},//5 animação 2
{110,100},//6 animação 3 triste
{110,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[20][2] = {
//Valor/velocidade
{142,10}, //ajuste
{180,15},
{150,30}, //dormir
{180,20},
{155,10}, //acordar
{110,15},
{125,50}, //triste
{165,20},
{155,20}, //brincar
{110,20},
{155,20},
{110,20},
{105,100}, //comer-beber
{180,20},
{150,50}, //frio
{180,50},
{142,150}, //calor
{105,15},
{180,15},
{142,50}
};
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 ServoS;
Servo ServoC;
Servo ServoP;
//VarSpeedServo ServoS;
//VarSpeedServo ServoC;
//VarSpeedServo ServoP;
//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 servoC A1 //controle X do pescoço
#define servoP A2 //controle Y do pescoço
#define botton A3 //botão generico
#define servo A0 //controle Y da cabeça
void setup(){
randomSeed(analogRead(A2));
Serial.begin(115200); //Serial USB
Serial2.begin(115200); //Serial Bluetooth
Serial3.begin(115200); //Serial Esp8266
ServoS.attach(servo);
ServoC.attach(servoC);
ServoP.attach(servoP);
ServoS.write(120);
ServoC.write(130);
ServoP.write(80);
//ServoS.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(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
}
//____________________/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 = 0; //
F_Frame = 1; // - centraliza a cabeça em ambos os motores
N_Frame = 0; //
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(){
for (int Nf = I_Frame; Nf <= F_Frame; Nf++){ //Cria um laço que repete de forma programada
if (N_Frame == Nf){ //Executa o programa diversas vezes apenas no frame atual
if (Delay_0A.repeat()){
ServoS.write(CodeS[Nf][0]);
ServoC.write(CodeC[Nf][0]);
ServoP.write(CodeP[Nf][0]);
//ServoS.slowmove(CodeS[Nf][0], CodeS[Nf][0]);
//ServoC.slowmove(CodeS[Nf][0], CodeS[Nf][0]);
//ServoP.slowmove(CodeS[Nf][0], CodeS[Nf][0]);
N_Frame++;
digitalWrite(Portas[23], HIGH);
}
}
}
if (N_Frame == F_Frame){
At_Frame = 0;
N_Frame = 0;
digitalWrite(Portas[23], LOW);
}
}
//---------------------------------------------------------------//
//____________________/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){
if (ValorX >= vxmin && ValorX <= vxmax)
ServoC.write(ValorX);
//ServoC.slowmove(ValorX, Velocidade[0]);
Task_5 = HIGH;
Delay_0B.repeatReset();
VXA = ValorX;
}
if (ValorZ != VZA){
if (ValorZ >= vzmin && ValorZ <= vzmax)
ServoP.write(ValorZ);
//ServoP.slowmove(ValorZ, Velocidade[2]);
Task_5 = HIGH;
Delay_0B.repeatReset();
VZA = ValorZ;
}
if (ValorY != VYA){
if (ValorY >= vymin && ValorY <= vymax)
ServoS.write(ValorY);
//ServoS.slowmove(ValorS, Velocidade[1]);
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[0] = 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[0] = 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[0] = 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);
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
}else{ //entra em modo de configuração manual caso não tenha sido apertado
}
antBotton = bot; //guarda o estado anterior do botão
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.
if (N_Frame == Np){ //verifica em qual frame o emote parou para dar continuidade/inicialização
if (Delay_0A.repeat()){ //aguarda 3 segundos em milis segundos antes de passar o próximo frame
ServoS.write(CodeS[Np][0]);
ServoC.write(CodeC[Np][0]);
ServoP.write(CodeP[Np][0]);
//ServoS.slowmove(CodeS[Np][0], CodeS[Np][1]);
//ServoC.slowmove(CodeC[Np][0], CodeC[Np][1]);
//ServoP.slowmove(CodeP[Np][0], CodeP[Np][1]);
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.
if (N_Frame == Np){ //verifica em qual frame o emote parou para dar continuidade/inicialização
if (Delay_0A.repeat()){ //aguarda 3 segundos em milis segundos antes de passar o próximo frame
ServoS.write(CodeS[Np][0]);
ServoC.write(CodeC[Np][0]);
ServoP.write(CodeP[Np][0]);
//ServoS.slowmove(CodeS[Np][0], CodeS[Np][1]);
//ServoC.slowmove(CodeC[Np][0], CodeC[Np][1]);
//ServoP.slowmove(CodeP[Np][0], CodeP[Np][1]);
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[0] = ValorY; //guarda os valores da ultima posição que a cabeça esteve
valorAnteriorX[0] = ValorX; //guarda os valores da ultima posição que a cabeça esteve
valorAnteriorZ[0] = ValorZ; //guarda os valores da ultima posição que a cabeça esteve
valorAnteriorY[1] = Velocidades[1];
valorAnteriorX[1] = Velocidades[0];
valorAnteriorZ[1] = Velocidades[2];
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 VelX = random(10, 150); //escolhe um valor aleatório velocidade
int VelY = random(10, 150); //-
int VelZ = random(10, 150); //-
Velocidades[0] = VelX; // Guarda o valor da ultima velocidade para obter-lo novamente depois
Velocidades[1] = VelY; // -
Velocidades[2] = VelZ; // -
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
int VelX = random(10, 150); //escolhe um valor aleatório velocidade
int VelY = random(10, 150); //-
int VelZ = random(10, 150); //-
Velocidades[0] = VelX; // Guarda o valor da ultima velocidade para obter-lo novamente depois
Velocidades[1] = VelY; // -
Velocidades[2] = VelZ; // -
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
Velocidades[1] = valorAnteriorY[1]; //desvolve as antiga velocidade de operação dos servos
Velocidades[0] = valorAnteriorX[1]; //-
Velocidades[2] = valorAnteriorZ[1]; //-
ValorX = valorAnteriorX[0]; //Envia para ValorX a antiga posição da cabeça
ValorY = valorAnteriorY[0]; //Envia para ValorY a antiga posição da cabeça
ValorZ = valorAnteriorZ[0]; //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;
}
}
//----------------------------------------------------------//