//____________________/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 validar = 0; //Valida a mensagem recebida pelo Esp8266 se tiver exatamente 16 caracteres
int Valido = 1; // Valida a inicialização do programa e indica se há ou não internet no esp8266 e bloqueia no inicio de um evento
int Reset = 1; // inicia/reinicia um evento ao iniciar o sistema ou em um horário específico
int Chances = 0; //permite a kin virar-se para uma direção aleatória se tiver o valor 4
int valorAnteriorServo; //Obtem o ultimo valor em ValorX / ValorY para
int valorAnteriorPescoco; //colocar-la na posição em que estava
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 = LOW; //USADO PARA CRIAR PULSOS NO MOTOR
int Map; // Guarda os valores obtidos no potenciometro
int ValorX = 90; // valores que controlam o pescoço pelo controle
int ValorY = 180; //
int VXA = 90; // guarda o ultimo valor recebido pelo controle
int VYA = 180; //
//MOTOR DO PESCOÇO Max 120 Min 50 centro = 90;
int CodeM[20][2] = { //Codenadas para motor/pescoço
//Min/Max
{89,91},//0 animação 0 Ajuste(PADRÃO)
{90,95},//1 animação 0
{89,91},//2 animação 1 dormir
{49,51},//3 animação 1
{89,91},//4 animação 2 acordar
{89,91},//5 animação 2
{114,116},//6 animação 3 triste
{114,116},//7 animação 3
{69,71}, //8 animação 4 brincar
{89,91}, //9 animação 4
{99,101}, //10 animação 4
{89,91}, //11 animação 4
{89,91}, //12 animação 5 comer-beber
{89,91}, //13 animação 5
{49,51}, //14 animação 6 frio
{49,51}, //15 animação 6
{89,91}, //16 animação 7 calor
{89,91}, //17 animação 7
{89,91}, //18 animação 7
{89,91} //19 animação 7
};
// 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[21][16] = {
//Motor Direção Acessórios
{0,0,0,0, 0,0,0,0, 0,0,0,0,0,0,0,0}, //Nada 0
{1,0,1,0, 0,0,0,0, 0,0,0,0,0,0,0,0}, //Frente 1
{1,0,1,0, 1,0,0,0, 0,0,0,0,0,0,0,0}, //Frente + direita 2
{1,0,1,0, 0,1,0,0, 0,0,0,0,0,0,0,0}, //Frente + esquerda 3
{0,1,0,1, 0,0,0,0, 0,0,0,0,0,0,0,0}, //Ré 4
{0,1,0,1, 1,0,0,0, 0,0,0,0,0,0,0,0}, //Ré + direita 5
{0,1,0,1, 0,1,0,0, 0,0,0,0,0,0,0,0}, //Ré + Esquerda 6
{0,0,0,0, 1,0,0,0, 0,0,0,0,0,0,0,0}, //Direita 7
{0,0,0,0, 0,1,0,0, 0,0,0,0,0,0,0,0}, //Esquerda 8
{0,0,0,0, 0,0,0,0, 1,0,0,0,0,0,0,0}, //Desconhecido 9
{0,0,0,0, 0,0,0,0, 0,1,0,0,0,0,0,0}, //Desconhecido 10
{0,0,0,0, 0,0,0,0, 0,0,1,0,0,0,0,0}, //Desconhecido 11
{0,0,0,0, 0,0,0,0, 0,0,0,1,0,0,0,0}, //Desconhecido 12
{0,0,0,0, 0,0,0,0, 0,0,0,0,1,0,0,0}, //Desconhecido 13
{0,0,0,0, 0,0,0,0, 0,0,0,0,0,1,0,0}, //Desconhecido 14
{0,0,0,0, 0,0,0,0, 0,0,0,0,0,0,1,0}, //Desconhecido 15
{0,0,0,0, 0,0,0,0, 0,0,0,0,0,0,0,1}, //Desconhecido 16
{0,0,0,0, 0,0,0,0, 0,0,0,0,0,0,0,0}, //Nada 17
{0,0,0,0, 0,0,1,0, 0,0,0,0,0,0,0,0}, //Movea cabeça: Direita 18
{0,0,0,0, 0,0,0,0, 0,0,0,0,0,0,0,0}, //Nada 19
{0,0,0,0, 0,0,0,1, 0,0,0,0,0,0,0,0}, //Movea cabeça: Esquerda 20
// 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"
int Number_Eye = 0; //Guarda a posição atual para uma expressão dos olhos
int Eye_Memory = 0; //Guarda a posição padrão escolhida no evento atual (Utilizado na função "vigilante").
int Eyes_Closed = 14; //Guarda a posição na qual o olho se fechará com um formato diferente, por exemplo: 14, 15, 16
#include "neotimer.h"
#include <Servo.h>
Servo Servo1;
Neotimer Delay_RGB = Neotimer(120); //tempo que conmtrola as luzes rgb
Neotimer Delay_0 = Neotimer(500); //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] = {38,40,42,44,46,48,50, 39,41,43,45,47,49,51, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
// motor direção Acessórios
int PortasM[16] = {30,31,32,33, 24,25,22,23, 26,27,28,29,34,35,36,37};
#define Ptm A0
#define servo A1
void setup(){
randomSeed(analogRead(A3));
Serial.begin(115200); //Serial USB
Serial2.begin(115200); //Serial Bluetooth
Serial3.begin(115200); //Serial Esp8266
//Display.begin(SSD1306_128X64);
Servo1.attach(servo);
Servo1.write(90);
for ( int Np = 0; Np <= 23; Np++) { //define todas as portas de leds como saída
pinMode(Portas[Np], OUTPUT);
digitalWrite(Portas[Np], LOW);
if (Np < 17){ //define todas as portas de motores como saída até a porta 17/18
pinMode(PortasM[Np], OUTPUT);
digitalWrite(PortasM[Np],LOW);
}
}
pinMode(Ptm, INPUT);
Conect(); // verifica se há conexão com a internet
delay(3000);
//define as cores dos leds
analogWrite(Portas[14], 0); //b
analogWrite(Portas[15], 24); //g - led 1
analogWrite(Portas[16], 120); //r
analogWrite(Portas[17], 0); //b
analogWrite(Portas[18], 24); //g - led 2
analogWrite(Portas[19], 120); //r
analogWrite(Portas[20], 0); //b
analogWrite(Portas[21], 24); //g - led 2
analogWrite(Portas[22], 120); //r
}
void loop(){
Bloqueio(); //bloqueia algumas funções de acordo com eventos
Serial_2(); //verifica se recebeu algum comando via Bluetooth
RGB();
int mip = analogRead(Ptm); // Atualiza a todo instante o valor atual do potenciometro
Map = map(mip, 0, 1023, 0, 180); //mapeia o potenciometro deixando-o mais preciso
}
//____________________/AÇÕES PARA CONECT/____________________//
void Conect(){
for (int Ng = 0; Ng <= 13; Ng++){
digitalWrite(Portas[Ng], !olhos[15][Ng]); //fecha os olhos
}
N_Frame = I_Frame; //define o "Numero atual" como "Inicio"
int Px = 0; // sem uso
int Py = 0; // sem uso
String Mensagem_A;
String Mensagem_B;
int vMin; //obtem o valor minimo de tolerancia para algum movimento expecífico
int vMax; //obtem um valor máximo de tolerancia para algum movimento expecífico
while (Valido <= 2){ //fecha um loop até que receba uma resposta se conexão
RGB();
int mip = analogRead(Ptm); // Atualiza a todo instante o valor atual do potenciometro
Map = map(mip, 0, 1023, 0, 180); //mapeia o potenciometro deixando-o mais preciso
if (Valido == 1){ //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.
vMin = CodeM[Np][0]; //adiciona um valor minimo de tolerância para um movimento
vMax = CodeM[Np][1]; //adiciona um valor máximo de tolerância para um movimento
if (N_Frame == Np){
if(Map >= 121){
digitalWrite(PortasM[7], LOW); //desliga um sentido dos motores caso passe de 125 (acima do limite: 120)
}else if(Map < vMin){
if (Delay_0.repeat()){
digitalWrite(PortasM[7], CLICK);
CLICK = !CLICK; //inverte o estado da porta para criar pulsos
}
}else{digitalWrite(PortasM[7], LOW);}
if (Map <= 49){
digitalWrite(PortasM[6], LOW); //desliga um sentido dos motores caso fique menor ou igual a 55 (abaixo do limite: 50)
}else if(Map > vMax){
if (Delay_0.repeat()){
digitalWrite(PortasM[6], CLICK);
CLICK = !CLICK; //inverte o estado da porta para criar pulsos
}
}else {digitalWrite(PortasM[6], LOW);}
Servo1.write(CodeS[Np]);
if(Map >= vMin && Map <= vMax){ //verifica se map está entre os parametros de tolerância para passar para o próximo movimento
digitalWrite(PortasM[6], LOW); //desliga um dos sentidos de rotação do motor
digitalWrite(PortasM[7], LOW); //desliga um dos sentidos de rotação do motor
if (Delay_0A.repeat()){ //espera alguns segundos antes de passar o próximo movimento
N_Frame++; //passa para o próximo comando de movimento
// Serial.print("ok");
}
}
}
}
if (N_Frame == F_Frame){// verifica se todos os movimentos foram concluidos
Valido = 4; //finaliza o loop infinito com indicativo de que há internet
Type_Animation = 0; //desliga a animação de cores
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 ;
digitalWrite(Portas[23], LOW); //desliga o ar após o processo
}
}
if (Valido == 2){ //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.
vMin = CodeM[Np][0]; //adiciona um valor minimo de tolerância para um movimento
vMax = CodeM[Np][1]; //adiciona um valor máximo de tolerância para um movimento
if (N_Frame == Np){
if(Map >= 121){
digitalWrite(PortasM[7], LOW); //desliga um sentido dos motores caso passe de 125 (acima do limite: 120)
}else if(Map < vMin){
if (Delay_0.repeat()){
digitalWrite(PortasM[7], CLICK);
CLICK = !CLICK;
}
}else{digitalWrite(PortasM[7], LOW);}
if (Map <= 49){
digitalWrite(PortasM[6], LOW); //desliga um sentido dos motores caso fique menor ou igual a 55 (abaixo do limite: 50)
}else if(Map > vMax){
if (Delay_0.repeat()){
digitalWrite(PortasM[6], CLICK);
CLICK = !CLICK; //inverte o estado da porta para criara pulsos
}
}else {digitalWrite(PortasM[6], LOW);}
Servo1.write(CodeS[Np]);
if(Map >= vMin && Map <= vMax){
digitalWrite(PortasM[6], LOW);
digitalWrite(PortasM[7], LOW);
if (Delay_0A.repeat()){
N_Frame++;
// Serial.print("ok");
}
}
}
}
if (N_Frame == F_Frame){
Valido = 3;
Type_Animation = 0; //desliga a animação de cores
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 ;
digitalWrite(Portas[23], LOW); //desliga o ar após o processo
}
}
}
}
//-----------------------------------------------------------//
//____________________/FUNÇÃO PISCAR/____________________//
void Piscar(){
if (Delay_1.repeat()){
Delay_1 = 500; //deine um curto tempo para piscar
Number++;
if (Number == 1){
for (int Ng = 0; Ng <= 13; Ng++){
digitalWrite(Portas[Ng], !olhos[Eyes_Closed][Ng]);
}
Number++;
}
if (Number == 3){
for (int Ng = 0; Ng <= 13; Ng++){
digitalWrite(Portas[Ng], !olhos[Number_Eye][Ng]);
}
Number = 0;
int set1 = random(5, 13);
Delay_1 = set1 * 1000;
Serial.println("Piscar: ok");
}
}
}
//-------------------------------------------------------//
//____________________/OPÇÕES DE BLOQUEIO/____________________//
void Bloqueio(){
if (Valido != 3){ //Impede que eventos diários iniciem em ordem de horários(PADRÃO)
Serial_3();
}
if (Task_0 == HIGH){ //desativa o recebimento de comandos
comandos();
}
if (Task_1 == HIGH){ //bloqueia aa animação padrão de piscar
Piscar();
}
if (Task_2 == HIGH){ //bloqueia a animação padrão de olhar
Observar();
}
if (At_Frame == 1){ //ativa os emotes através de 'video_animations'
Emotes();
}
if (At_Gif == 1){ //ativa as animações de vídeo através de "emotes"
Video_Animations();
}
if (Task_5 == HIGH){ // ativa o ventilador
digitalWrite(Portas[23], HIGH);
}else{
digitalWrite(Portas[23], LOW);
}
if (Task_8 == HIGH){ //Ativa o "Delay_A" de eventos
Tempo_A();
}
if (Task_9 == HIGH){ //Ativa o "Delay_B" de eventos
Tempo_B();
}
if (Task_10 == HIGH){ //Ativa o "Delay_C" de eventos
Tempo_C();
}
}
//------------------------------------------------------------//
//____________________/RGB/____________________//
void RGB() {
if (Type_Animation == 0){ //desliga todos osa leds da coleira
for (int I = 14; I <= 22; I++){
analogWrite(Portas[I], 0);
}
Type_Animation = 99;
}
if (Type_Animation == 1){ //opção de escolha de cores
for (int Nl = 0; Nl <= 2; Nl++){ //cria opções entre os leds rgb
if (ValorL == Nl){ //verifica qual opção foi escolhida
if (VRGB[Nl] != 0){ //verifica se houve mudança de comando
int Multiplo[] = {0, 3, 6};
int Info = 14;
Info = Info + Nl; // Nl = 0 a 2
Info + Multiplo[Nl];
for (int I = 0; I <= 2; I++){
EstadoAnteriorRgb[Nl][I] = VRGB[I];
analogWrite(Portas[Info], EstadoAnteriorRgb[Nl][I]);
}
VRGB[Nl] = 0;
}
}
}
} else if (Type_Animation == 2){ //Modo padrão do sistema: Arco-iris
Delay_RGB.set(10);
if (ordemRGB == 0){
if (Delay_RGB.repeat()){
if (ValorGreen1 < 255){
ValorGreen1 = ValorGreen1 + 5;
analogWrite(Portas[15], ValorGreen1);
}
if ((ValorGreen2 < 255)&&(ValorGreen1 > 40)){
ValorGreen2 = ValorGreen2 + 5;
analogWrite(Portas[18], ValorGreen2);
}
if ((ValorGreen3 < 255)&&(ValorGreen2 > 40)){
ValorGreen3 = ValorGreen3 + 5;
analogWrite(Portas[21], ValorGreen3);
}
if (ValorGreen3 == 255){
ordemRGB = 1;
}
}
}
if (ordemRGB == 1){
if (Delay_RGB.repeat()){
if (ValorRed1 > 0){
ValorRed1 = ValorRed1 - 5;
analogWrite(Portas[16], ValorRed1);
}
if ((ValorRed2 > 0)&&(ValorRed1 < 210)){
ValorRed2 = ValorRed2 - 5;
analogWrite(Portas[19], ValorRed2);
}
if ((ValorRed3 > 0)&&(ValorRed2 < 210)){
ValorRed3 = ValorRed3 - 5;
analogWrite(Portas[22], ValorRed3);
}
if (ValorRed3 == 0){
ordemRGB = 2;
}
}
}
if (ordemRGB == 2){
if (Delay_RGB.repeat()){
if (ValorBlue1 < 255){
ValorBlue1 = ValorBlue1 + 5;
analogWrite(Portas[14], ValorBlue1);
}
if ((ValorBlue2 < 255)&&(ValorBlue1 > 40)){
ValorBlue2 = ValorBlue2 + 5;
analogWrite(Portas[17], ValorBlue2);
}
if ((ValorBlue3 < 255)&&(ValorBlue2 > 40)){
ValorBlue3 = ValorBlue3 + 5;
analogWrite(Portas[20], ValorBlue3);
}
if (ValorBlue3 == 255){
ordemRGB = 3;
}
}
}
if (ordemRGB == 3){
if (Delay_RGB.repeat()){
if (ValorGreen1 > 0){
ValorGreen1 = ValorGreen1 - 5;
analogWrite(Portas[15], ValorGreen1);
}
if ((ValorGreen2 > 0)&&(ValorGreen1 < 210)){
ValorGreen2 = ValorGreen2 - 5;
analogWrite(Portas[18], ValorGreen2);
}
if ((ValorGreen3 > 0)&&(ValorGreen2 < 210)){
ValorGreen3 = ValorGreen3 - 5;
analogWrite(Portas[21], ValorGreen3);
}
if (ValorGreen3 == 0){
ordemRGB = 4;
}
}
}
if (ordemRGB == 4){
if (Delay_RGB.repeat()){
if (ValorRed1 < 255){
ValorRed1 = ValorRed1 + 5;
analogWrite(Portas[16], ValorRed1);
}
if ((ValorRed2 < 255)&&(ValorRed1 > 40)){
ValorRed2 = ValorRed2 + 5;
analogWrite(Portas[19], ValorRed2);
}
if ((ValorRed3 < 255)&&(ValorRed2 > 40)){
ValorRed3 = ValorRed3 + 5;
analogWrite(Portas[22], ValorRed3);
}
if (ValorRed3 == 255){
ordemRGB = 5;
}
}
}
if (ordemRGB == 5){
if (Delay_RGB.repeat()){
if (ValorBlue1 > 0){
ValorBlue1 = ValorBlue1 - 5;
analogWrite(Portas[14], ValorBlue1);
}
if ((ValorBlue2 > 0)&&(ValorBlue1 < 210)){
ValorBlue2 = ValorBlue2 - 5;
analogWrite(Portas[17], ValorBlue2);
}
if ((ValorBlue3 > 0)&&(ValorBlue2 < 210)){
ValorBlue3 = ValorBlue3 - 5;
analogWrite(Portas[20], ValorBlue3);
}
if (ValorBlue3 == 0){
ordemRGB = 0;
}
}
}
} else if (Type_Animation == 3){ //Modo padrão do sistema: Escolhas aleatórias
Delay_RGB.set(150);
if (Delay_RGB.repeat()){
int LRed = random(0, 256);
int LGreen = random(0, 256);
int LBlue = random(0, 256);
int Number2 = random (1, 4);
if (Number2 == 1){
analogWrite(Portas[16], LRed);
analogWrite(Portas[15], LGreen);
analogWrite(Portas[14], LBlue);
}
if (Number2 == 2){
analogWrite(Portas[19], LRed);
analogWrite(Portas[18], LGreen);
analogWrite(Portas[17], LBlue);
}
if (Number2 == 3){
analogWrite(Portas[22], LRed);
analogWrite(Portas[21], LGreen);
analogWrite(Portas[20], LBlue);
}
}
} else if (Type_Animation == 4){ //Modo de fita pulsante com opção de escolha de cores/tempos/luminosidade
}
}
//------------------------------------------------------------//
//____________________/EVENTOS/____________________//???
void Brevia(){
// o leitor passará uma unica vez em Brévia,
//aqui será definido toda a programação de uma
//brévia antes do mesmo iniciar.
/*if (I_Frame != 2 && F_Frame != 3){ //Dormir OK
for(int Ne = 0; Ne <= 1; Ne++){
if (Num_Event == dormir[Ne]){
Number_Eye = 3; //
Eye_Memory = 3; // - define os olhos para o sono
Eyes_Closed = 15; //
Delay_4.set(1000);// define o tempo da animação de vídeo atual
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; //
Valido = 3; //Bloqueia o Esp8266 temporáriamente
validar = 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;
Serial.println("Tempo_A: ok");
Eventos();
}
/* for (int Na = 0; Na <= 4; Na++){//Comer OK
if (Num_Event == Comer[Na]){
Cancelado();
}
}*/
}
}
void Cancelado(){
for(int Ne = 0; Ne <= 1; Ne++){ //Dormir OK
if (Num_Event == dormir[Ne]){
int set = random(0,2);
if (set == 0){
Number_Eye = 16; //
Eye_Memory = 16; // - Olhos tristes
Eyes_Closed = 29; //
//Display.clrScr();
//Display.setFont(SmallFont);
//Display.print("Ah,oky.. -.-", 0,0);
//Display.update();
Delay_B = 5000;
//Delay_B.repeatReset();
I_Frame = 6; //
N_Frame = 6; // - move a cabeça para direita e para baixo
F_Frame = 7; //
I_Gif = 25; //
N_Gif = 25; // - Animação de vídeo coração partido
F_Gif = 31; //
Task_2 = LOW;
}
if (set == 1){
Number_Eye = 23; //
Eye_Memory = 23; // - Olhos Raivosos
Eyes_Closed = 14; //
// Display.clrScr();
//Display.setFont(SmallFont);
//Display.print("Ok o-o", 0,0);
//Display.update();
Delay_A = 60000;
// Delay_A.repeatReset();
Task_0 = LOW;
Task_5 = HIGH;
}
}
}
for(int Ne = 0; Ne <= 4; Ne++){ //Comer
if (Num_Event == Comer[Ne]){
}
}
}
void Tempo_B() {
if (Delay_B.repeat()){ //Tempo após a conclusão de um evento ou durante o evento
/*
for (int Na = 2; Na <= 3; Na++){//Recusados
if (Confirmar == Na){
for(int Ne = 0; Ne <= 1; Ne++){//Dormir_OK
if (Num_Event == dormir[Ne]){
Display.clrScr();
Display.update();
Delay_C = 30000; //Define um tempo para execução da reação: triste
Quantidade_C = 1; //Define uma quantidade de repetições
Quantidade_B = 0;
Delay_C.repeatReset(); //Ativa a função "Delay_C"
Delay_4.set(500);// tempo de animação
At_Gif = 1; //Ativa a videoAnimation
At_Frame = 1; //Ativa os Emotes
}
}
}
}
if (Confirmar == 1) {
for(int Ne = 0; Ne <= 1; Ne++){//Dormir OK
if (Num_Event == dormir[Ne]){
Display.clrScr();
Display.update();
At_Gif = 1;
At_Frame = 1;
Quantidade_B = 0;
Delay_C.set(30000);
Quantidade_C = 1;
Delay_C.repeatReset();
}
}
for (int Na = 0; Na <= 4; Na++){ //Comer
if (Num_Event == Comer[Na]){
Concluir();
}
}
}*/
if (Num_Event == 1){//acordar OK
Task_9 = LOW;
Serial.println("Tempo_B: ok");
Concluir();
}
}
}
void Eventos(){
// o leitor passará uma unica vez em eventos,
//aqui será definido toda a programação de um novo
//evento quando o mesmo for confirmado pelo anfitrião
for(int Na = 0; Na <= 1; Na++){//Dormir OK
if (Num_Event == dormir[Na]){
Eyes_Closed = 14; //Define estado do olho fechado
I_Frame = 2; //
F_Frame = 3; // - vira a cabeça para a esquerda e para baixo
N_Frame = 2; //
Delay_4.set(50);// define o tempo da animação de vídeo atual
Valido = 3;// bloqueia mensagens do Esp8266
I_Gif = 0; //
N_Gif = 0; // - animação de vídeo frame_mono
F_Gif = 7; //
Delay_B = 5000;
// Delay_B.repeatReset();
Task_5 = HIGH; //liga o ar
//Display.clrScr();
//Display.setFont(SmallFont);
int set = random(0,5);
/*if(set == 0){
Display.print("Ate Amanha! 'u'", 0,0);
}else if (set == 1){
Display.print("Boa Noite -. - zzz", 0,0);
}else if (set == 2){
Display.print("Durma Bem -w- zz", 0,0);
}else if (set == 3){
Display.print("Ba Noite! 'w'", 0,0);
}else if (set == 4){
Display.print("Bons Sonhos ~w~", 0,0);
}
Display.update(); */
}
}
if (Num_Event == 1){ //Acordar OK
int set = random(0,2);
if (set == 0){
Number_Eye = 0; //
Eye_Memory = 0; // - define os olhos para padrão
Eyes_Closed = 14; //
Serial.println("Olhos comuns escolhidos");
//Display.clrScr();
//Display.setFont(SmallFont);
//Display.print("Ola! Bom dia! 'w'", 0,0);
}else{
Number_Eye = 3; //
Eye_Memory = 3; // - define os olhos para o sono
Eyes_Closed = 15; //
Serial.println("Olhos com sono escolhidos");
// Display.clrScr();
// Display.setFont(SmallFont);
// Display.print("Oii! Bom dia! -w-'", 0,0);
}
for (int Ng = 0; Ng <= 13; Ng++){
digitalWrite(Portas[Ng], !olhos[Eye_Memory][Ng]); //altera os zoio
}
// Display.update();
Serial.println("eventos: ok");
At_Frame = 1;// inicia aimação de emote
I_Frame = 0; //
F_Frame = 1; // - emote de ajuste
N_Frame = 0; //
Valido = 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; //
Valido = 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();
validar = 0; // - garante que os horários sejam escritos na posição correta
Recebido = ""; //
Valido = 4; //desbloqueia o Esp8266
At_Gif = 0; // garantem que todas as funções estejam desligadas
At_Frame = 0; //
}
//-------------------------------------------------//
//____________________/AÇÕES PARA EMOTES/____________________//
void Emotes(){
// cria emotes que controlam a posição da cabeça e das patas de acordo com o evento atual
int vMin;
int vMax;
for (int Np = I_Frame; Np <= F_Frame; Np++){// define o numero de posições da Kin.
vMin = CodeM[Np][0];
vMax = CodeM[Np][1];
if (N_Frame == Np){
if(Map >= 121){
digitalWrite(PortasM[7], LOW); //desliga um sentido dos motores caso passe de 125 (acima do limite: 120)
}else if(Map < vMin){
if (Delay_0.repeat()){
digitalWrite(PortasM[7], CLICK);
CLICK = !CLICK;
}
}else{digitalWrite(PortasM[7], LOW);}
if (Map <= 49){
digitalWrite(PortasM[6], LOW); //desliga um sentido dos motores caso fique menor ou igual a 55 (abaixo do limite: 50)
}else if(Map > vMax){
if (Delay_0.repeat()){
digitalWrite(PortasM[6], CLICK);
CLICK = !CLICK; //inverte o estado da porta para criara pulsos
}
}else {digitalWrite(PortasM[6], LOW);}
Servo1.write(CodeS[Np]);
if(Map >= vMin && Map <= vMax){
digitalWrite(PortasM[6], LOW);
digitalWrite(PortasM[7], LOW);
if (Delay_0A.repeat()){
N_Frame++;
// Serial.print("ok");
}
}
}
}
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++){ //Controla os motores de "passo"
if (comando == Ctrl[Nc]){ //verifica se comando é igual a um dos caracteres em Ctrl[]
for (int Nf = 0; Nf <= 5; Nf++){
digitalWrite(PortasM[Nf], Motor[Nc][Nf]); //Liga os motores em ordens distintas
}
}else{
for (int Nf = 0; Nf <= 5; Nf++){
digitalWrite(PortasM[Nf], Motor[0][Nf]); //desliga todos os motores
}
}
}
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 vMin = ValorX - 1; //valor minimo
int vMax = ValorX + 1; //valor maximo
if(Map >= 121){
digitalWrite(PortasM[7], LOW); //desliga um sentido dos motores caso passe de 125 (acima do limite: 120)
}else if(Map < vMin){
if (Delay_0.repeat()){
digitalWrite(PortasM[7], CLICK);
CLICK = !CLICK; //inverte o estado da porta para criar pulsos
Task_5 = HIGH;
Delay_0B.repeatReset();
}
}else{digitalWrite(PortasM[7], LOW);}
if (Map <= 49){
digitalWrite(PortasM[6], LOW); //desliga um sentido dos motores caso fique menor ou igual a 55 (abaixo do limite: 50)
}else if(Map > vMax){
if (Delay_0.repeat()){
digitalWrite(PortasM[6], CLICK);
CLICK = !CLICK; //inverte o estado da porta para criar pulsos
Task_5 = HIGH;
Delay_0B.repeatReset();
}
}else {digitalWrite(PortasM[6], LOW);}
if(Map >= vMin && Map <= vMax){
digitalWrite(PortasM[6], LOW);
digitalWrite(PortasM[7], LOW);
VXA = ValorX;
}
}
if (ValorY != VYA){
if (ValorY >= 105 && ValorY <= 180)
Servo1.write(ValorY);
Task_5 = HIGH;
Delay_0B.repeatReset();
VYA = ValorY;
}
if (Delay_0B.repeat(1)){//desliga o ventilador após 5 segundos de inatividade
Task_5 = LOW;
}
}
//------------------------------------------------------------//
//____________________/AÇÕES PARA ESP8266/____________________// <- REATIVE O SELETOR DE EVENTOS AQUI
void Serial_3(){
if (Serial3.available()){
char Byte = Serial3.read(); //recebe os horários
// Display.print(Byte, TextXy[0], 0); //escreve no display
Recebido += Byte; //guarda o primeiro valor que está em milisegundos -> 12345//00:00:00/ em formato de texto
valorData = Recebido.toInt(); // transforma-o em valor numérico e guarda na variável "valorData"
validar++; // aumenta 1 valor a cada caractere recebido, o máximo são 16 por vez
TextXy[0] = validar;
}
if (validar == 16){ //verifica se há 16 caracteres escritos e limpa o display para atualizar o que esta escrito
// Display.printNumI(Map, 0, 8);
//Display.update();
validar = 0;
TextXy[0] = 0;
Recebido = "";
}
//APAGAR O CODIGO ABAIXO PARA O USO DE EVENTOS
if (Reset == 1){ //verifica se há um novo evento
Serial.println("Reset: ok");
Reset = 0;
valorData = 0;
Num_Event = 1; //guarda o evento atual
Brevia();
}
//DESMARCAR CODIGO ABAIXO PARA O USO DE EVENTOS
/*for (int Nt = 0; Nt <= 16; Nt++){
Valor1 = Hora[Nt][0];
Valor2 = Hora[Nt][1];
Valor3 = D_Hora[Nt][0];
Valor4 = D_Hora[Nt][1];
if(valorData >= Valor1 && valorData < Valor2){ //Verifica se o horário atual está dentre os horários de eventos
if(valorData >= Valor3 && valorData < Valor4){ //Verifica se o horário atual esta exatamente no início de um evento novo
Reset = 1; //Reseta as tarefas para começar um novo evento
valorData = 0;
// Serial.println("Tarefa Resetada");
}
if (Reset == 1){ //verifica se há um novo evento
Reset = 0;
valorData = 0;
//Serial.print("Valor da coluna = ");Serial.println(Nt);
Num_Event = Nt; //guarda o evento atual
Brevia();
}
}
}
*/
}
//------------------------------------------------------------//
//____________________/AÇÕES PARA MODULO BLUETOOTH/____________________//
void Serial_2(){
if (Serial.available()){
comando = Serial.read();
Mensagem += comando;
if (comando == 'T'){ // define um led
Type_Animation = Mensagem.toInt();
Serial.print("Tipo de animação: "); Serial.print(Type_Animation); Serial.println(" iniciado!");
Mensagem = "";
ordemRGB = 0; //reseta a animação
ValorRed1 = 0 ; //Limpa todas as cores
ValorGreen1 = 0 ;
ValorBlue1 = 0 ;
ValorRed2 = 0 ;
ValorGreen2 = 0 ;
ValorBlue2 = 0 ;
ValorRed3 = 0 ;
ValorGreen3 = 0 ;
ValorBlue3 = 0 ;
}
for (int Nc = 0; Nc <= 2; Nc++){ //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'){ //valor que move o pescoço da direita para esquerda
ValorX = Mensagem.toInt();
valorAnteriorPescoco = ValorX;
Serial.print("ValorX: "); Serial.print(ValorX); Serial.println(" Obtido!");
Mensagem = "";
}
if(comando == 'Y'){ // valor que move o pescoço de cima para baixo
ValorY = Mensagem.toInt();
valorAnteriorServo = ValorY;
Serial.print("ValorY: "); Serial.print(ValorY); Serial.println(" Obtido!");
Mensagem = "";
}
}
}
//---------------------------------------------------------------------//
//____________________/OBSERVAR/______________________// Adicionar movimentos aleatórios
void Observar(){
if (Delay_2.repeat()){
if (Chances == 0){
Chances = random(1, 8);
valorAnteriorServo = ValorY; // valores da ultima posição que a cabeça esteve
valorAnteriorPescoco = ValorX;
Serial.print("ValorX0 = "); Serial.println(ValorX);
Serial.print("ValorY0 = "); Serial.println(ValorY);
Serial.print("Chances: "); Serial.println(Chances);
}
Delay_2.set(5000);
Number1++;
if (Number1 == 1){
Number_Eye = Eye_Memory + 1;
for (int Ng = 0; Ng <= 13; Ng++){
digitalWrite(Portas[Ng], !olhos[Number_Eye][Ng]);
}
if (Chances == 4 && Task_0 == HIGH){
int PosicaoX = random(50, 121); //move o motor do pescoço
int PosicaoY = random(105, 181); //move o servo do pescoço
ValorX = PosicaoX;
ValorY = PosicaoY;
Serial.print("ValorX1 = "); Serial.println(ValorX);
Serial.print("ValorY1 = "); Serial.println(ValorY);
}
Number1++;
}
if (Number1 == 3){
Number_Eye = Eye_Memory + 2;
for (int Ng = 0; Ng <= 13; Ng++){
digitalWrite(Portas[Ng], !olhos[Number_Eye][Ng]);
}
if (Chances == 4 && Task_0 == HIGH){
int PosicaoX = random(50, 121); //move o motor do pescoço
int PosicaoY = random(105, 181); //move o servo do pescoço
digitalWrite(PortasM[6], LOW);
digitalWrite(PortasM[7], LOW);
ValorX = PosicaoX;
ValorY = PosicaoY;
Serial.print("ValorX2 = "); Serial.println(ValorX);
Serial.print("ValorY2 = "); Serial.println(ValorY);
}
Number1++;
}
if (Number1 == 5){
Number_Eye = Eye_Memory;
for (int Ng = 0; Ng <= 13; Ng++){
digitalWrite(Portas[Ng], !olhos[Number_Eye][Ng]);
}
if (Chances == 4 && Task_0 == HIGH){
digitalWrite(PortasM[6], LOW);
digitalWrite(PortasM[7], LOW);
ValorX = valorAnteriorPescoco;
ValorY = valorAnteriorServo;
Serial.print("ValorX3 = "); Serial.println(ValorX);
Serial.print("ValorY3 = "); Serial.println(ValorY);
}
int set1 = random(10, 31); //define um tempo aleatório
int Valor = set1 * 1000;
Number1 = 0;
Chances = 0; //reseta as chances
Serial.println("Observar: Ok");
Serial.print("Proximo tempo:"); Serial.println(Valor);
Delay_2.set(Valor);
}
}
}
//--------------------------------------------------------//
//____________________/Video_Animations/____________________// Alterar comandos para nova biblioteca
void Video_Animations(){
At_Gif = 0;
Task_4 = LOW;
if(Task_3 == HIGH){
At_Frame = 1;
}
}
//----------------------------------------------------------//