//____________________/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 convertidas 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
byte Necessidades[] = {0, 0, 0, 0, 0, 0, 0}; //alterna seu valor ao receber um comando como: 6N 5N 4N
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; //recebe um Caractere alfabetico e/ou numerico atravéz do modulo bluetooth
char Ctrl[] = {'.', 'W', 'S', 'D', 'A'}; //caracteres de comando
// outros:
//velocidade dos motores: 0-255ve 0-255vd
//posição X do pescoço: 40-160X
//posição Y da cabeça: 20-180Y
//posição Y do pescoço: 65-180H
//olhos abertos: 00O
//olhos fechados: 00o
//posições limitadas/ilimitadas: T/t
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 Aleatório
{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, 16};
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
//____________________/EMOTES/______________________//
int At_Frame = 0; //Utilizado para Iniciar uma animação de Emotes após a animação de vídeo
// 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
// 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
// 180 = baixo; 105 = cima;
//Codenadas do servo/pescoço de 180 a 105
int limite = HIGH; //permnite ou não com que o robo se movimente para posições exessivas (desativar essa opção pode resultar em danos nos mecanismos)
// define o valor minimo, caso o motor chegue nesse valor, será desligado imediatamente
int vxmin = 40; // Controle X do pescoço
int vxmax = 160; // -
int vymin = 20; // Controle Y da cabeça
int vymax = 180; // -
int vzmin = 65; // Controle Z do pescoço
int vzmax = 180; // -
int ValorX = 90; // valores que Guardam a memória de posicionamento dos servos
int ValorY = 150; //
int ValorZ = 65; //
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
int Velocidades[] = {20, 20, 20}; // guarda as velocidades escolhidas pelo usiário e pelo sistema
int ComandVel = 255; //obtem um valor numerico em Serial_2 e guarda em Velocidades[]
int Repeticoes = 3; //guarda um numero de 3 a 10 com a finalidade se fazer a kin se mover de 3 a 10 vezes de forma aleatória
// 0 finaliza emotes
// 1 comando de tempo
// 2 comando de expressão do olho aberto
// 3 comando de servos-motores
// 4 controle de motores
// 5 comando de expressão dos olhos fechados
int Pcomand[] = {2, 0}; //controla o cursor de comandos {tipo de animação , etapas da animação}
int Rcomand = 1; //usado no comando de delay
int MotorC = 0;
int Motor[] = {100, 100}; //controla a força dos motores[velocidade do motor, tempo em milisegundo que o motor ficará ligado]
//____________________/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 P O
{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 P O
{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 P O
{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, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1}, //estatico ---------13 P
{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 P O
{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 P O
{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 P O
{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 P o
{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
// X = Olhos usados em eventos
// P = funcionam na função piscar
};
int olhosP[] = {0, 3, 6, 17, 13, 20, 23, 26};
int olhosO[] = {0, 3, 6, 17, 20, 23, 26}; //olhos que tem animação de observação,
//e ativam a função "Observar" caso Eye_Memory seja igual a um deles
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[] = {1, 0}; //Guarda a posição atual para uma expressão dos olhos {A , B}
//A = um valor que dará prioridade a um olhar diferente: piscar / Observar / estático
//B = guarda o valor do olhar que ficou em segundo plano
int Eye_Memory = 0; //Guarda a posição padrão escolhida no evento atual (Utilizado também na função "Observar").
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
[A.B.C.D.E.F.G.s.s.D1.D2.SC.SE.SB.SD.SN.S] Novo
[x.x.+.+.+.+.+.+.+. -. -. -. -. -. -. -.-]
// olhos A B C D E F G D1.D2.CL.SE.SC.SD.SB.SN
//int Portas[] = {33,34,35,36,37,38,39, 26,27,11,29,28,31,30,32};
[B.C.D.E.F.G.s.s.a.b.c.d.e.f.g.S.o] antigo
[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
[SN.SB.SD.SE.SC.D2.D1.G.F.E.D.C.B.A] - 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_comand = Neotimer(0); //comando de tempo para emotes
Neotimer Delay_0A = Neotimer(50); //tempo de retardo da desativação dos motores de locomoção
Neotimer Delay_0B = Neotimer(10000); //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_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
// olhos A B C D E F G D1.D2. SE.SC.SD.SB.SN
//int Portas[] = {33,34,35,36,37,38,39, 26,27,11,29,28,31,30,32};
int Portas[] = {28, 29, 30, 31, 32, 33, 34, 26, 27, 11, 35, 36, 37, 38, 39};
// motores ND Velocidade
//int PortasM[] = {42,43,41,40, 22,23,24,25, 8,9}; //Portas que controlam motores
int PortasM[] = {6, 7, 8, 9, 42, 43, 41, 40, 22, 23}; //Portas que controlam motores mod
int bot_tsp = LOW; //confirma os ajustes manuais quando o botão é apertado(usado atualmente para verificação de transporte)
#define servo A0 //controle Y da cabeça
#define servoC A1 //controle X do pescoço
#define servoP A2 //controle Y do pescoço
#define botton A3 //botão generico
void setup() {
randomSeed(analogRead(A7));
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.slowmove(150, 10);
//ServoC.slowmove(90, 10);
//ServoP.slowmove(65, 10);
ServoS.write(150);
ServoC.write(90);
ServoP.write(65);
for ( int Np = 0; Np <= 14; Np++) { //cria um loop que se repete 9 vezes
if (Np <= 9) {
pinMode(Portas[Np], OUTPUT); //define todas as portas de leds como saida
digitalWrite(Portas[Np], LOW); //deixa todas as portas de leds desligadas
} else {
pinMode(Portas[Np], INPUT); //define as portas restantes como entradas
}
if (Np <= 9) { //verifica se o NP é menor ou equivalente a 7
pinMode(PortasM[Np], OUTPUT); //define todas as portas de 0 a 7 como saída
digitalWrite(PortasM[Np], LOW); // define todas as portas de 0 a 7 como desligadas
}
}
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
Olhos(); //faz impressões continuas nos olhos
}
//____________________/Olhos/____________________//
void Olhos() {
int set;
if (Number_Eye[0] == 1) {
digitalWrite(Portas[7], HIGH); //ativa o olho Direito
for (int i = 0; i <= 6; i++) { //laço que se repete 7 vezes
int set = i; //guarda em set o valor de " i "
digitalWrite(Portas[i], olhos[Eyes_Closed][set]);////imprime um olho fechado no olho direito
digitalWrite(Portas[i], olhos[29][set]);//desliga o olho atual para imprimir o desenho do olho direito
}
digitalWrite(Portas[7], LOW); //desliga o olho direito
digitalWrite(Portas[8], HIGH); //ativa o olho esquerdo
for (int i = 0; i <= 6; i++) { //laço que se repete 7 vezes
int set = i + 7; //guarda em set o valor de " i " somado com 7
digitalWrite(Portas[i], olhos[Eyes_Closed][set]);//imprime um olho fechado no olho esquerdo
digitalWrite(Portas[i], olhos[29][set]);//desliga o olho atual para imprimir o desenho do olho esquerdo
}
digitalWrite(Portas[8], LOW); //desliga o olho esquerdo
} else if (digitalRead(Portas[11]) == HIGH) { //verifica se os sensores na cabeça foram acionados
digitalWrite(Portas[7], HIGH); //ativa o olho Direito
for (int i = 0; i <= 6; i++) { //laço que se repete 7 vezes
int set = i; //guarda em set o valor de " i "
digitalWrite(Portas[i], olhos[17][set]);////imprime um olho feliz no olho direito
digitalWrite(Portas[i], olhos[29][set]);//desliga o olho atual para imprimir o desenho do olho direito
}
digitalWrite(Portas[7], LOW); //desliga o olho dirteito
digitalWrite(Portas[8], HIGH); //ativa o olho esquerdo
for (int i = 0; i <= 6; i++) { //laço que se repete 7 vezes
int set = i + 7; //guarda em set o valor de " i " somado com 7
digitalWrite(Portas[i], olhos[17][set]);//imprime um olho feliz no olho esquerdo
digitalWrite(Portas[i], olhos[29][set]);//desliga o olho atual para imprimir o desenho do olho esquerdo
}
digitalWrite(Portas[8], LOW); //desliga o olho esquerdo
} else if (digitalRead(Portas[13]) == HIGH) { //verifica se os sensores abaixo da cabeça estão ativos
digitalWrite(Portas[7], HIGH); //ativa o olho Direito
for (int i = 0; i <= 6; i++) { //laço que se repete 7 vezes
int set = i; //guarda em set o valor de " i "
digitalWrite(Portas[i], olhos[20][set]);////imprime um olhar gentil no olho direito
digitalWrite(Portas[i], olhos[29][set]);//desliga o olho atual para imprimir o desenho do olho direito
}
digitalWrite(Portas[7], LOW); //desliga o olho dirteito
digitalWrite(Portas[8], HIGH); //ativa o olho esquerdo
for (int i = 0; i <= 6; i++) { //laço que se repete 7 vezes
int set = i + 7; //guarda em set o valor de " i " somado com 7
digitalWrite(Portas[i], olhos[20][set]);//imprime um olhar gentil no olho esquerdo
digitalWrite(Portas[i], olhos[29][set]);//desliga o olho atual para imprimir o desenho do olho esquerdo
}
digitalWrite(Portas[8], LOW); //desliga o olho esquerdo
} else {
if (digitalRead(Portas[10]) == HIGH) { //verifica se o sensor do olho direito, está ativado para fechar o olho direito
digitalWrite(Portas[7], HIGH); //ativa o olho Direito
for (int i = 0; i <= 6; i++) { //laço que se repete 7 vezes
set = i; //guarda em set o valor de " i "
digitalWrite(Portas[i], olhos[14][set]);////imprime um olho fechado no olho direito
digitalWrite(Portas[i], olhos[29][set]);//desliga o olho atual para imprimir o desenho do olho esquerdo
}
digitalWrite(Portas[7], LOW); //desliga o olho dirteito
} else { //mantém o olho aberto na configuração desejada caso o sensor não esteja ativo
digitalWrite(Portas[7], HIGH); //ativa o olho Direito
for (int i = 0; i <= 6; i++) { //laço que se repete 7 vezes
set = i; //guarda em set o valor de " i "
digitalWrite(Portas[i], olhos[Number_Eye[1]][set]);//imnprime um desenho de Number_eye no olho direito
digitalWrite(Portas[i], olhos[29][set]);//desliga o olho atual para imprimir o desenho do outro olho
}
digitalWrite(Portas[7], LOW); //desliga o olho direito
}
if (digitalRead(Portas[12]) == HIGH) { //verifica se o sensor esquerdo está ativo para fechar o olho esquerdo
digitalWrite(Portas[8], HIGH); //ativa o olho esquerdo
for (int i = 0; i <= 6; i++) { //laço que se repete 7 vezes
set = i + 7; //guarda em set o valor de " i " somando com 7
digitalWrite(Portas[i], olhos[14][set]);//imprime um olho fechado no olho esquerdo
digitalWrite(Portas[i], olhos[29][set]);//desliga o olho atual para imprimir o desenho do outro olho
}
digitalWrite(Portas[8], LOW); //desliga o olho esquerdo
} else {
digitalWrite(Portas[8], HIGH); //desliga o olho direito
for (int i = 0; i <= 6; i++) { //laço que se repete 7 vezes
set = i + 7; //guarda em set o valor de " i " somando com 7
digitalWrite(Portas[i], olhos[Number_Eye[1]][set]);//imnprime um desenho de Number_eye no olho esquerdo
digitalWrite(Portas[i], olhos[29][set]);//desliga o olho atual para imprimir o desenho do outro olho
}
digitalWrite(Portas[8], LOW); //desliga o olho esquerdo
}
}
}
//-------------------------------------------------------//
//____________________/EVENTOS/____________________//???
void Brevia() {
//inicia um pedido para alguma necessidade
//faz um jesto desmostrando que necessita de algo de acordo com as necessidades existentes
//agudarda até um certo periodo de tempo até que o usuário faça algo sobre o pedido
//inicia a função Eventos, Cancelado e/ou Concluir de acordo com o evento e a escolha do usuário
for (int Ne = 0; Ne <= 1; Ne++) {
if (Num_Event == dormir[Ne]) { //inicial de evento para dormir
//aqui kin dara uma indicação de que esta com sono como:
//enviando uma mensagem ao controle do usuário
//alterando sua expressão dos Olhos
//alterando a sua velocidade de movimento
//tentar tirar um cochilo a cada 30 segundos de inatividade
//tempo para abrir os olhos ao piscar é maior a cada vez que pisca
Serial.println("Estou com sono, Preciso Dormir..."); //envia a mensagem para via serial
Serial2.println("Estou com sono, Preciso Dormir..."); //envia a mensagem via bluetooth
Eye_Memory = 3;// faz com que a expressão padrão da kin seja de cansaço
Number_Eye[1] = 3; //guarda o mesmo valor no atuador para que seja feito o desenho da expresão
Eyes_Closed = 15; //faz com que a expressão dos olhos quando fechados sejam de cansaço
for (int Nv = 0; Nv <= 2; Nv++) {
Velocidades[Nv] = 5; //diminui as velocidades dos 3 servos
}
}
}
}
void Cancelado() {
//faz um jesto aleatório de tristeza/descepção ou sem nenhuma reação de acordo com o evento caso o usuario recuse-
//o pedido solicitado ou ignore
//evento será finalizado por aqui até que um novo inicie novamente
}
void Eventos() {
//pode fazer um jesto diferente de acordo com o evento
//aguarda a confirmação do recebimento da finalização do evento
}
void Concluir() {
//faz um jesto feliz ou neutro de acordo com o evento confirmando que a solicitação esta concluida
}
//-------------------------------------------------//
//____________________/FUNÇÃO PISCAR/____________________//
void Piscar() {
if (Delay_1.repeat()) {
Delay_1 = 500; //deine um curto tempo para piscar
Number++; //soma 1 ponto e guarda em "Number"
if (Number == 1) { //verifica se "Number" recebeu um ponto
Number_Eye[0] = 1; //guarda um ponto em Number_Eye[0] para os olhos serem fechados
Number++; //soma 1 ponto e guarda em "Number"
}
if (Number == 3) { //Verifica se "Number" tem 3 pontos guardados
Number_Eye[0] = 0; //zera o valor de "Number_Eye[0]" para que os olhos se abram
Number = 0; //zera os valores de "Number" para que o evento se repita
int set1 = random(5, 13); //escolhe um numero de 5 a 12 para definir um tempo de contagem em milisegundos
Delay_1 = set1 * 1000; //multiplica o valor escolhido por 1000 milisegundos e guarda em Delay_1
//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) {
for (int i = 0; i <= 7; i++) { //laço que se repete 9 vezes
if (Eye_Memory == olhosP[i]) { //verifica se Eye_Memory é igual a um dos valores de olhosP[]
Piscar(); //executa o programa da animação dos olhos
}
}
}
if (Task_2 == HIGH) {
for (int i = 0; i <= 6; i++) { //laço que se repete 9 vezes
if (Eye_Memory == olhosO[i]) { //verifica se Eye_Memory é igual a um dos valores de olhosO[]
Observar(); //executa o programa da animação dos olhos
}
}
}
if (At_Frame == 1) {
Emotes();
}
if (Task_5 == HIGH) { // ativa o ventilador
digitalWrite(Portas[9], HIGH);
} else {
digitalWrite(Portas[9], LOW);
}
}
//------------------------------------------------------------//
//____________________/AÇÕES PARA EMOTES/____________________//
void Emotes() {
/*
o que deve acontecer aqui:
ao iniciar, a barra de leitura pode começar da linha em que esteve durante a programação
o sistema deverá saber em qual linha está e qual o comando que está naquela linha
deverá executar o comando e aumentar o valor de Pcomand[1] para passar para o próximo comando do codigo
os comandos finalizarão assim que chegar em qualquer linha de código que esteja sem nenhum comando = 0
*/
// 1 1 1 1 1
// 0,1 2 3 4 5 6 7 8 9 10,11,12,13,14,15,16,17,18,19, 20,21,22,23,24,25,26,27,28,29
int linhas[11][23] = {{3, 3, 3, 2, 1, 3, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // dormir (solicitado); linhas principais que guardarão os comandos. numero do comando: 0
{2, 1, 2, 3, 3, 3, 1, 3, 1, 3, 3, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // dormir (confirmação)
{3, 3, 3, 2, 1, 3, 3, 2, 1, 3, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // acordar
{3, 3, 3, 2, 1, 3, 3, 2, 1, 3, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // acordar em modo de transporte
{3, 3, 3, 2, 5, 1, 2, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // mal-estar
{3, 3, 3, 2, 1, 3, 3, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Fome / sede (solicitado)
{3, 3, 3, 1, 2, 1, 3, 3, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Fome / sede (Confirmação)
{3, 3, 3, 2, 1, 3, 3, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // calor (Alternativa A)
{3, 3, 3, 1, 3, 3, 2, 1, 3, 3, 2, 1, 3, 3, 2, 1, 3, 3, 2, 1, 2, 3, 0}, // calor (Alternativab B)
{3, 3, 3, 2, 1, 3, 1, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // frio
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} // Entediada
};
int Eyes[10][23] = {{0, 0, 0, 15, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // dormir (solicitado); guardam os tipos de olhares do robô. comando: 2
{17, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // dormir (confirmação)
{0, 0, 0, 15, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // acordar
{0, 0, 0, 15, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // acordar em modo de transporte
{0, 0, 0, 16, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // mal-estar
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Fome / sede (Olhos definidos pelo sistema) (solicitado)
{0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Fome / sede (Confirmação)
{0, 0, 0, 14, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // calor
{0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 15, 0, 0, 0, 8, 0, 0, 0, 15, 0, 12, 0, 0}, // calor (Alternativab B)
{0, 0, 0, 6, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} // frio
};
int EyesClose[10][23] = {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // dormir (solicitado); guardam os tipos de expressões com olhos fechados. comando: 5
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // dormir (confirmação)
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // acordar
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // acordar em modo de transporte
{0, 0, 0, 0, 29, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // mal-estar
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Fome / sede (Olhos definidos pelo sistema) (solicitado)
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Fome / sede (Confirmação)
{0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // calor
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // calor (Alternativab B)
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} // frio
};
int Tempo[10][23] = {{0, 0, 0, 0, 5000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // dormir (solicitado); tempos de espera para um novo comando em milisegundos 1
{0, 1000, 0, 0, 0, 0, 10000, 0, 5000, 0, 0, 30000, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // dormir (confirmação)
{0, 0, 0, 0, 10000, 0, 0, 0, 10000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // acordar
{0, 0, 0, 0, 10000, 0, 0, 0, 10000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // acordar em modo de transporte
{0, 0, 0, 0, 0, 5000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // mal-estar
{0, 0, 0, 0, 5000, 0, 0, 1500, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Fome / sede (solicitado)
{0, 0, 0, 6000, 0, 20000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Fome / sede (Confirmação)
{0, 0, 0, 0, 10000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,}, // calor
{0, 0, 0, 3000, 0, 0, 0, 5000, 0, 0, 0, 1500, 0, 0, 0, 5000, 0, 0, 0, 2000, 0, 0, 0}, // calor (Alternativab B)
{0, 0, 0, 0, 3000, 0, 500, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} // frio
};
int velocidade[10][23] = {{2, 5, 5, 0, 0, 20, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // dormir (solicitado); velocidade dos servos motores 3
{0, 0, 0, 30, 50, 5, 0, 100, 0, 30, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // dormir (confirmação)
{10, 2, 5, 0, 0, 50, 5, 0, 0, 10, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // acordar
{10, 2, 5, 0, 0, 50, 5, 0, 0, 10, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // acordar em modo de transporte
{20, 10, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // mal-estar
{30, 5, 255, 0, 0, 30, 5, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Fome / sede (solicitado)
{5, 5, 5, 0, 0, 0, 10, 10, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Fome / sede (Confirmação)
{5, 10, 2, 0, 0, 15, 10, 5, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // calor
{255, 255, 255, 0, 10, 20, 0, 0, 10, 20, 0, 0, 10, 20, 0, 0, 10, 20, 0, 0, 0, 30, 0}, // calor (Alternativab B)
{255, 255, 255, 0, 0, 20, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} // frio
};
int srv[10][23] = {{1, 2, 3, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // dormir (solicitado); servo motor escolhido de 1 - 3 3
{0, 0, 0, 1, 2, 3, 0, 3, 0, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // dormir (confirmação)
{1, 2, 3, 0, 0, 1, 3, 0, 0, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // acordar
{1, 2, 3, 0, 0, 1, 3, 0, 0, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // acordar em modo de transporte
{1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // mal-estar
{1, 2, 3, 0, 0, 1, 2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Fome / sede (solicitado)
{1, 2, 3, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Fome / sede (Confirmação)
{1, 2, 3, 0, 0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // calor
{1, 2, 3, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 0, 1, 0}, // calor (Alternativab B)
{1, 2, 3, 0, 0, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} // frio
};
// servos:
// 1 eixo Ycabeça
// 2 eixo X pescoço
// 3 eixo Y pescoço
int angulo[10][23] = {{180, 130, 65, 0, 0, 90, 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // dormir (solicitado); angulo de giro do servo 3
{0, 0, 0, 140, 160, 180, 0, 150, 0, 180, 180, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // dormir (confirmação)
{150, 90, 130, 0, 0, 180, 65, 0, 0, 140, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // acordar OK
{150, 90, 180, 0, 0, 180, 180, 0, 0, 140, 180, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // acordar em modo de transporte
{170, 160, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // mal-estar
{180, 160, 130, 0, 0, 140, 130, 0, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Fome / sede (solicitado)
{110, 130, 165, 0, 0, 0, 180, 130, 90, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Fome / sede (Confirmação)
{10, 130, 130, 0, 0, 150, 130, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // calor
{150, 130, 95, 0, 120, 90, 0, 0, 150, 130, 0, 0, 120, 180, 0, 0, 150, 130, 0, 0, 0, 180, 0}, // calor (Alternativab B)
{140, 130, 80, 0, 0, 180, 0, 180, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} // frio
};
while (At_Frame == 1) { //enquanto At_Frame for igual a um será executado apenas comandos de emotes
if (linhas[Pcomand[0]][Pcomand[1]] == 0) { //finaliza o modo de comandos automatico
//select = 0;
At_Frame = 0; // desativa a função de emote
Pcomand[1] = 0; //reseta Pcomand[1] para executar um novo emote
}
if (linhas[Pcomand[0]][Pcomand[1]] == 1) { //verifica se o comando é um delay
if (Rcomand == 1) { //programa de configuração de tempo
Delay_comand.set(Tempo[Pcomand[0]][Pcomand[1]]); //verifica o valor guardado em Tempo[][] adiciona no Neotimer: Delay_Comand
Delay_comand.repeatReset(); //reseta a repetição do delay para que o programa espere um tempo enquanto faz outras
Rcomand = 0; //altera o valor de Rcomand para o programa de configuração não se repetir
}
if (Delay_comand.repeat(1)) { //laço que se repete uma vez após um tempo determinado
Rcomand = 1; //permite que outro comando de tempo seja configurado
Pcomand[1]++;
}
}
if (linhas[Pcomand[0]][Pcomand[1]] == 2) { //verifica se o comando muda o olhar
Eye_Memory = Eyes[Pcomand[0]][Pcomand[1]]; //guarda um valor de Eyes em set
Number_Eye[1] = Eye_Memory;
Pcomand[1]++;
}
if (linhas[Pcomand[0]][Pcomand[1]] == 3) { //controle de servos
if (srv[Pcomand[0]][Pcomand[1]] == 1) {
ServoS.write(angulo[Pcomand[0]][Pcomand[1]]);
//ServoS.slowmove(angulo[Pcomand[0]][Pcomand[1]], velocidade[Pcomand[0]][Pcomand[1]]);
}
if (srv[Pcomand[0]][Pcomand[1]] == 2) {
ServoC.write(angulo[Pcomand[0]][Pcomand[1]]);
//ServoC.slowmove(angulo[Pcomand[0]][Pcomand[1]], velocidade[Pcomand[0]][Pcomand[1]]);
}
if (srv[Pcomand[0]][Pcomand[1]] == 3) {
ServoP.write(angulo[Pcomand[0]][Pcomand[1]]);
//ServoP.slowmove(angulo[Pcomand[0]][Pcomand[1]], velocidade[Pcomand[0]][Pcomand[1]]);
}
Pcomand[1]++; //aumenta seu valor para poder executar o próximo programa
}
if (linhas[Pcomand[0]][Pcomand[1]] == 4) { //controle de motores
/* MotorC = Motor[Pcomand[0]]; //diz ao sistema qual comando enviar ao motores
if (MotorC == 1){ //frente + direita
for(int i = 0; i <= 7; i++){
digitalWrite(PortasM[i], Motor[2][i]);
}
} else if (MotorC == 2){ //frente + esquerda
for(int i = 0; i <= 7; i++){
digitalWrite(PortasM[i], Motor[3][i]);
}
} else if (MotorC == 3){ //frente
for(int i = 0; i <= 7; i++){
digitalWrite(PortasM[i], Motor[1][i]);
}
} else if (MotorC == 4){ //ré + Direita
for(int i = 0; i <= 7; i++){
digitalWrite(PortasM[i], Motor[5][i]);
}
} else if (MotorC == 5){ //ré + esquerda
for(int i = 0; i <= 7; i++){
digitalWrite(PortasM[i], Motor[6][i]);
}
} else if (MotorC == 6){ //ré
for(int i = 0; i <= 7; i++){
digitalWrite(PortasM[i], Motor[4][i]);
}
} else if (MotorC == 7){ //direita
for(int i = 0; i <= 7; i++){
digitalWrite(PortasM[i], Motor[7][i]);
}
} else if (MotorC == 8){ //Esquerda
for(int i = 0; i <= 7; i++){
digitalWrite(PortasM[i], Motor[8][i]);
}
} else { //desligado
for(int i = 0; i <= 7; i++){
digitalWrite(PortasM[i], Motor[0][i]);
}
} */
Pcomand[1]++;
}
if (linhas[Pcomand[0]][Pcomand[1]] == 5) { // escolha de olhos fechados
Eyes_Closed = EyesClose[Pcomand[0]][Pcomand[1]]; //guarda um valor de Eyes em set
Pcomand[1]++;
}
Olhos(); //executa a função que faz com que os olhos funcionem
}
}
//---------------------------------------------------------------//
//____________________/OPÇÕES DE CONTROLE/____________________//???
void comandos() {
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[1] = 13;
}
}
if (ValorX != VXA) {
if (limite == LOW) {
ServoC.write(ValorX); //envia o novo comando para o servo-motor
Serial.print("VelocidadeX: "); Serial.println(Velocidades[1]);
//ServoC.slowmove(ValorX, Velocidades[1]);
Task_5 = HIGH; //Ativa a porta que liga/desliga a energia dos Servos-motores
Delay_0B.repeatReset(); //reseta o contador de tempo em que ficará ligado os servos-motores
VXA = ValorX; //guarda o novo valor De VAlorX em VXA para que o comando não se repita
} else if (ValorX >= vxmin && ValorX <= vxmax) { //verifica se ValorX esta dentre os limites do sistema caso os limites estejam ativos
ServoC.write(ValorX); //envia o novo comando para o servo-motor
Serial.print("VelocidadeX: "); Serial.println(Velocidades[1]);
//ServoC.slowmove(ValorX, Velocidades[1]);
Task_5 = HIGH; //Ativa a porta que liga/desliga a energia dos Servos-motores
Delay_0B.repeatReset(); //reseta o contador de tempo em que ficará ligado os servos-motores
VXA = ValorX; //guarda o novo valor De VAlorX em VXA para que o comando não se repita
}
}
if (ValorZ != VZA) {
if (limite == LOW) {
ServoP.write(ValorZ); //envia o novo comando para o servo-motor
Serial.print("VelocidadeZ: "); Serial.println(Velocidades[2]);
//ServoP.slowmove(ValorZ, Velocidades[2]);
Task_5 = HIGH; //Ativa a porta que liga/desliga a energia dos Servos-motores
Delay_0B.repeatReset(); //reseta o contador de tempo em que ficará ligado os servos-motores
VZA = ValorZ; //guarda o novo valor De VAlorZ em VZA para que o comando não se repita
} else if (ValorZ >= vzmin && ValorZ <= vzmax) { //verifica se ValorZ esta dentre os limites do sistema caso os limites estejam ativos
ServoP.write(ValorZ); //envia o novo comando para o servo-motor
Serial.print("VelocidadeZ: "); Serial.println(Velocidades[2]);
//ServoP.slowmove(ValorZ, Velocidades[2]);
Task_5 = HIGH; //Ativa a porta que liga/desliga a energia dos Servos-motores
Delay_0B.repeatReset(); //reseta o contador de tempo em que ficará ligado os servos-motores
VZA = ValorZ; //guarda o novo valor De VAlorZ em VZA para que o comando não se repita
}
}
if (ValorY != VYA) { //verifica se um novo valor foi colocado em ValorY
if (limite == LOW) { //verifica se os limites de posições estão desligado
ServoS.write(ValorY); //envia o novo comando para o servo-motor
Serial.print("VelocidadeY: "); Serial.println(Velocidades[0]); //imprime o valor da velocidade que foi enviada ao servo-motor
//ServoS.slowmove(ValorY, Velocidades[0]);
Task_5 = HIGH; //Ativa a porta que liga/desliga a energia dos Servos-motores
Delay_0B.repeatReset(); //reseta o contador de tempo em que ficará ligado os servos-motores
VYA = ValorY; //guarda o novo valor De VAlorY em VYA para que o comando não se repita
} else if (ValorY >= vymin && ValorY <= vymax) { //verifica se ValorY esta dentre os limites do sistema caso os limites estejam ativos
ServoS.write(ValorY); //envia o novo comando para o servo-motor
Serial.print("VelocidadeY: "); Serial.println(Velocidades[0]); //imprime o valor da velocidade que foi enviada ao servo-motor
//ServoS.slowmove(ValorY, Velocidades[0]);
Task_5 = HIGH; //Ativa a porta que liga/desliga a energia dos Servos-motores
Delay_0B.repeatReset(); //reseta o contador de tempo em que ficará ligado os servos-motores
VYA = ValorY; //guarda o novo valor De VAlorY em VYA para que o comando não se repita
}
}
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(); //tranforma os caracteres do texto salvo "12345" em um numero e guarda esse valor em ValorData
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 valorData
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++; //aumenta 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]; //guarda em Valor1 os valores do inicio de um horário
Valor2 = Hora[Nt][1]; //guarda em Valor2 o valor final de um horário
Valor3 = D_Hora[Nt][0]; //guarda em Valor3 o primeiro segundo de um horário especifico
Valor4 = D_Hora[Nt][1]; //guarda em Valor4 o segundo 'Segundo' de um horario
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()) { //recebe comandos Via bluetooth
comando = Serial.read();
Mensagem += comando;
/*for (int Nc = 0; Nc <= 4; Nc++){ //cria um loop que se repete 4 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 <= 3; Nf++){ ////cria um loop que se repete 5 vezes, e obtem um valor a cada repetição
digitalWrite(PortasM[Nf], Motor[Nc][Nf]); //altera apenas os estados dos motores que faz a kin se locomover
Delay_0A.repeatReset();
}
comando = "";
}
} //////////////////////////////////////////////////////////////////////
if (comando == 'W'){ //recebe o comando
VelM[0] = Mensagem.toInt(); //guarda o valor desse comando
if (VelM >= 0 && VelM <= 90){ //verifica se o valor guardado esta dentre os limites de ativação
Motor[0] = VelM; //guarda o valor obtido para mover o sentido direito do motor direito
EN1 = map(MotorD[0], 0, 90, 0, 100);
}
if (VelM >= 91 && VelM <= 180){ //verifica se o valor guardado esta dentre os limites de ativação
Motor[1] = VelM; //guarda o valor obtido para mover o sentido esquerdo do motor direito
EN1 = map(MotorD[0], 91, 180, 0, 100);
}
int test = map(MotorD[0], 91, 180, 0, 100);
int test1 = map(0, 90, 0, 100);
Mensagem = "";
digitalWrite(PortasM[10], HIGH);
}
if (test >= 1 && test <= 100){
if(Delay_Generic.repeat()){//inicia a cada valor escolhido para controle de velocidade
digitalWrite(PortasM[0], !PortasM[0]); //inverte o estado da porta em determinado tempo para mudar a velocidade
}
} else if (test <= 0){
digitalWrite(PortasM);
}////////////////////////////////////////////////////////////////////// */
/* ao enviar o comando W, ambos os motores serão habilitados a velocidade deverá ser considerada para ambos
os sentidos de cada motor.
1. velocidade 255 ecolhida para motor direito
2. velocidade 100 escolhida para motor esquerdo
3. comando W ativo (Frente), apenas habilita a porta para que os motores comecem a girar no sentido já escolhido
4. pegar os valores obtidos e colocar-los apenas nas portas que fazem o robo ir para frente
*/
switch (comando) {
case 'W': { //frente
digitalWrite(PortasM[8], HIGH); //habilita os motores e só mantém habilitado enquanto estiver
digitalWrite(PortasM[9], HIGH); //recebendo o mesmo comando
analogWrite(PortasM[0], Motor[0]); //Envia o valor da velocidade para controle de um dos sentidos
analogWrite(PortasM[1], 0); //de cada motor e só altera quando outro comando de controle
analogWrite(PortasM[2], Motor[0]); //de motor é enviado
analogWrite(PortasM[3], 0); //
Mensagem = "";
Delay_0A.repeatReset(); //reseta o valor de tempo
break; //finaliza a função switch
}
case 'Q': { //frente + Esquerda
digitalWrite(PortasM[8], HIGH); //habilita os motores e só mantém habilitado enquanto estiver
digitalWrite(PortasM[9], HIGH); //recebendo o mesmo comando
analogWrite(PortasM[0], 100); //Envia o valor da velocidade para controle de um dos sentidos
analogWrite(PortasM[1], 0); //de cada motor e só altera quando outro comando de controle
analogWrite(PortasM[2], 255); //de motor é enviado
analogWrite(PortasM[3], 0); //
Mensagem = "";
Delay_0A.repeatReset(); //reseta o valor de tempo
break; //finaliza a função switch
}
case 'E': { //frente + direita
digitalWrite(PortasM[8], HIGH); //habilita os motores e só mantém habilitado enquanto estiver
digitalWrite(PortasM[9], HIGH); //recebendo o mesmo comando
analogWrite(PortasM[0], 255); //Envia o valor da velocidade para controle de um dos sentidos
analogWrite(PortasM[1], 0); //de cada motor e só altera quando outro comando de controle
analogWrite(PortasM[2], 100); //de motor é enviado
analogWrite(PortasM[3], 0); //
Mensagem = "";
Delay_0A.repeatReset(); //reseta o valor de tempo
break; //finaliza a função switch
}
case 'S': { //ré
digitalWrite(PortasM[8], HIGH); //habilita os motores e só mantém habilitado enquanto estiver
digitalWrite(PortasM[9], HIGH); //recebendo o mesmo comando
analogWrite(PortasM[0], 0); //Envia o valor da velocidade para controle de um dos sentidos
analogWrite(PortasM[1], Motor[0]); //de cada motor e só altera quando outro comando de controle
analogWrite(PortasM[2], 0); //de motor é enviado
analogWrite(PortasM[3], Motor[0]); //
Mensagem = "";
Delay_0A.repeatReset(); //reseta o valor de tempo
break;
}
case 'Z': { //ré + esquerda
digitalWrite(PortasM[8], HIGH); //habilita os motores e só mantém habilitado enquanto estiver
digitalWrite(PortasM[9], HIGH); //recebendo o mesmo comando
analogWrite(PortasM[0], 0); //Envia o valor da velocidade para controle de um dos sentidos
analogWrite(PortasM[1], 255); //de cada motor e só altera quando outro comando de controle
analogWrite(PortasM[2], 0); //de motor é enviado
analogWrite(PortasM[3], 100); //
Mensagem = "";
Delay_0A.repeatReset(); //reseta o valor de tempo
break;
}
case 'C': { //ré + direita
digitalWrite(PortasM[8], HIGH); //habilita os motores e só mantém habilitado enquanto estiver
digitalWrite(PortasM[9], HIGH); //recebendo o mesmo comando
analogWrite(PortasM[0], 0); //Envia o valor da velocidade para controle de um dos sentidos
analogWrite(PortasM[1], 100); //de cada motor e só altera quando outro comando de controle
analogWrite(PortasM[2], 0); //de motor é enviado
analogWrite(PortasM[3], 255); //
Mensagem = "";
Delay_0A.repeatReset(); //reseta o valor de tempo
break;
}
case 'A': {// esquerda
digitalWrite(PortasM[8], HIGH); //habilita os motores e só mantém habilitado enquanto estiver
digitalWrite(PortasM[9], HIGH); //recebendo o mesmo comando
analogWrite(PortasM[0], 0); //Envia o valor da velocidade para controle de um dos sentidos
analogWrite(PortasM[1], Motor[0]); //de cada motor e só altera quando outro comando de controle
analogWrite(PortasM[2], Motor[0]); //de motor é enviado
analogWrite(PortasM[3], 0); //
Mensagem = "";
Delay_0A.repeatReset(); //reseta o valor de tempo
break;
}
case 'D': { //Direita
digitalWrite(PortasM[8], HIGH); //habilita os motores e só mantém habilitado enquanto estiver
digitalWrite(PortasM[9], HIGH); //recebendo o mesmo comando
analogWrite(PortasM[0], Motor[0]); //Envia o valor da velocidade para controle de um dos sentidos
analogWrite(PortasM[1], 0); //de cada motor e só altera quando outro comando de controle
analogWrite(PortasM[2], 0); //de motor é enviado
analogWrite(PortasM[3], Motor[0]); //
Mensagem = "";
Delay_0A.repeatReset(); //reseta o valor de tempo
break;
}
default : {
//if (Delay_0B.repeat()){
//digitalWrite(PortasM[8], LOW); //desabilita os motores e só mantém habilitado enquanto estiver
//digitalWrite(PortasM[9], LOW); //recebendo um mesmo comando
//}
break;
}
}
if (Mensagem.indexOf("vm") > 0) { //recebe a velocidade que controla o motor Esquerdo "Velocidade do Motor"
int Valor = Mensagem.toInt(); //transforma obtem o valor numerico de Mensagem e guarda em VelE
Motor[0] = Valor;
//analogWrite(PortasM[8], velE);
Serial.print("Velocidad dos motores: "); Serial.println(Valor);
Mensagem = "";
}
if (Mensagem.indexOf("vc") > 0) { //recebe a velocidade que controla o motor direito "Velocidade de Comando"
int Valor = Mensagem.toInt(); //transforma obtem o valor numerico de Mensagem e guarda em VelE
Motor[1] = Valor;
Delay_0A = Motor[1] + 10;
//analogWrite(PortasM[9], velD);
Serial.print("velocidade de comando: "); Serial.println(Valor);
Mensagem = "";
}
if (Mensagem.indexOf("Tl") > 0) { //ativa o limitador de posicionamento do pescoço do robô "Trava ligada"
limite = HIGH;
Mensagem = "";
}
if (Mensagem.indexOf("Td") > 0) { //desativa o limitador de posicionamento do pescoço do robô "Trava Desligada"
limite = LOW;
Mensagem = "";
}
if (comando == 'V') { //define a velocidade dos servos
ComandVel = Mensagem.toInt();
Velocidades[0] = ComandVel;
Velocidades[1] = ComandVel;
Velocidades[2] = ComandVel;
Serial.print("Velocidades: "); Serial.print(ComandVel); Serial.println(" Obtidas!");
Mensagem = "";
}
if (comando == 'O') { //define um desenho para os olhos quando abertos
Eye_Memory = Mensagem.toInt();
Serial.print("olhos: "); Serial.println(Eye_Memory); Serial.println(" Obtidos!");
Mensagem = "";
Number_Eye[1] = Eye_Memory;
}
if (comando == 'o') { //define um desenho para os olhos quando fechados
Eyes_Closed = Mensagem.toInt();
Serial.print("olhos Fechados: "); Serial.print(Eyes_Closed); Serial.println(" Obtidos!");
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
}
}
if (Delay_0A.repeat(1)) {
digitalWrite(PortasM[8], LOW); //desabilita os motores e só mantém habilitado enquanto estiver
digitalWrite(PortasM[9], LOW); //recebendo um mesmo comando
}
}
//---------------------------------------------------------------------//
//____________________/AÇÕES PARA CONECT/____________________//
void Conect() {
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 = HIGH; //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) {
Olhos();
bot = digitalRead(botton);
if (Serial3.available()) { //Serial3 controle do Esp8266
comando = Serial3.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
bot_confirm = HIGH;
Number_Eye[0] = 0; //faz com que os olhos se abram
Mensagem_A = ""; //apaga a mensagem
digitalWrite(Portas[9], HIGH); //ativa os servos
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++; //aumenta 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[9], HIGH); //Ativa os servos
ok_Esp = 2;
Number_Eye[0] = 0; //faz com que os olhos se abram
bot_confirm = HIGH; //inicia os comandos de posicionamento
}
}
if (bot == LOW && antBotton == HIGH) { //verifica se o botão foi pressionado
Number_Eye[0] = 0; //faz com que os olhos se abram
bot_confirm = HIGH;// confirma o pressionamento do botão
ok_Esp = 2; // inicia Kin de forma manual offline
bot_tsp = HIGH; //inicia as configurações para o modo de transporte
Pcomand[0] = 3; //altera o valor de Pcomand[0] para posicionar o pescoço no modo de transporte
ValorZ = 180; // guarda o valor da posição em que ficará o pescoço
digitalWrite(Portas[9], HIGH); //Ativa os servos
antBotton = bot; //guarda o estado anterior do botão
}
/*
o que deve acontecer aqui:
ao iniciar, a barra de escrita pode começar da linha em que esteve durante a programação
o sistema deverá saber em qual linha está e qual o comando que está naquela linha
deverá executar o comando e aumentar o valor de Pcomand[1] para passar para o próximo comando
do codigo os comandos finalizará assim que chegar em qualquer linha de código que esteja sem nenhum comando = 0
*/
if (bot_confirm == HIGH) {
At_Frame = 1; //define o valor de at_frame para executar os comandos de "Emotes()"
Emotes(); //executa os comandos de "Emotes()"
if (ok_Esp == 1 ) { //finaliza os ajustes de posição da cabeça e verifica se o esp está conectado
bot_confirm == LOW;
Pcomand[1] = 0; //reinicia Pcomand[1] para poder iniciar um novo emote
Task_1 = HIGH; // Ativa o modo piscar
Task_2 = HIGH; // ativa o modo Observar
Task_0 = HIGH; // ativa os comandos
ok_Esp = 4;
}
if (ok_Esp == 2 ) { //finaliza os ajustes sem a verificação do esp8266, possivelmente bloqueando o modo wifi
bot_confirm == LOW;
Pcomand[1] = 0; //reinicia Pcomand[1] para poder iniciar um novo emote
Task_1 = HIGH; // Ativa o modo piscar
Task_2 = HIGH; // ativa o modo Observar
Task_0 = HIGH; // ativa os comandos
ok_Esp = 3;
}
}
}
}
//-----------------------------------------------------------//
//____________________/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(3, 5); //escolhe um numero de 1 a 4 e guarda o valor em "Chances"
Repeticoes = random(3, 11); //escolheum numero de 3 a 10 e guarda o valor em "Repeticoes"
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[0];
valorAnteriorX[1] = Velocidades[1];
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"
Serial.print("Numero de repeticoes: "); Serial.println(Repeticoes);
}
int Set = random(1, 6); //escolhe um valor numerico de 1 a 5
Delay_2.set(Set * 1000); //define um tempo aleatório entre 1 a 5 segundos de espera para cada frame
Serial.print("Tempo para proximo frame = "); Serial.println(Set * 1000);
//Number1++; //altera a posição dos "FRAMES" a cada tempo passado
if (Number1 >= 0 && Number1 <= Repeticoes) { // FRAME que repete
int eye = random(0, 3); // escolhe entre 0 e 2 para decidir se começará olhando para esquerda, direita ou para o centro do seu campo de visão
Number_Eye[1] = Eye_Memory + eye; //guarda em "Number_Eye" o valor do olhar memorizado e adiciona um valor escolhido;
if (Chances == 4 && Task_0 == HIGH) { //verifica se "Chances" é igual a 4 e se os comandos estão ativos
int PosicaoX; //escolhe e guarda um valor que move o motor do pescoço em PosicaoX
int PosicaoY; //escolhe e guarda um valor que move o Servo do pescoço em PosicaoY
int PosicaoZ; //escolhe e guarda um valor que move o Servo do pescoço em PosicaoZ
int mov; //esccolhe um valor de 0 a 3
int VelX; //escolhe um valor aleatório velocidade
int VelY; //-
int VelZ; //-
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
if (bot_tsp == HIGH) { //verifica se a kin esta sendo transportada ou não
//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
PosicaoX = random(vxmin + 35, vxmax - 35); //escolhe e guarda um valor que move o motor do pescoço em PosicaoX
PosicaoY = random(vymin + 2, vymax - 30); //escolhe e guarda um valor que move o Servo do pescoço em PosicaoY
PosicaoZ = random(vzmin + 105, vzmax - 0); //escolhe e guarda um valor que move o Servo do pescoço em PosicaoZ
mov = random(0, 4); //esccolhe um valor de 0 a 3
VelX = random(10, 150); //escolhe um valor aleatório velocidade
VelY = random(10, 150); //-
VelZ = random(10, 150); //-
} else {
//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
PosicaoX = random(vxmin + 2, vxmax - 2); //escolhe e guarda um valor que move o motor do pescoço em PosicaoX
PosicaoY = random(vymin + 2, vymax - 30); //escolhe e guarda um valor que move o Servo do pescoço em PosicaoY
PosicaoZ = random(vzmin + 20, vzmax - 50); //escolhe e guarda um valor que move o Servo do pescoço em PosicaoZ
mov = random(0, 4); //esccolhe um valor de 0 a 3
VelX = random(10, 150); //escolhe um valor aleatório velocidade
VelY = random(10, 150); //-
VelZ = random(10, 150); //-
}
Velocidades[1] = VelX; // Guarda o valor da ultima velocidade para obter-lo novamente depois
Velocidades[0] = 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 && bot_tsp == LOW) { //verifica se mov equivale a 2 para poder mover Servo Y do pescoço
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
Serial.print("Repeticao atual: "); Serial.println(Number1);
}
if (Number1 > Repeticoes) { // FRAME 3
Number_Eye[1] = Eye_Memory; //guarda em "Number_Eye" o valor do olhar memorizado
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[0] = valorAnteriorY[1]; //desvolve as antiga velocidade de operação dos servos
Velocidades[1] = 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: ???
//----------------------------------------------------------//