Robô Paulinho

O Robô Paulinho foi criado pelos alunos do Colégio Poeta Manuel Bandeira, sua estrutura física é de peças de computador quebrado e suas rodas são CDs. O mecanismo que faz seu movimento são dois motores servos hackeados, a decisão de escolher o motor servo veio por facilitar o uso de um motor continuo já com um jogo de engrenagens interna ao qual é feita sua caixa de redução.
O Paulinho usa o protocolo de comunicação PSIU para se comunicar com as pessoas, segue o código de firmware

/******************************************************************                          PSIU PROTOCOL
 * Copyright (C) Ricardo Mariz and Robolivre.org 2012  * This is a free software: you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation, either version 3 of the License, or * (at your option) any later version. *  * PSIU PROTOOCOL is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. *  * You should have received a copy of the GNU General Public License along * with this program.  If not, see <http://www.gnu.org/licenses/>. *                          * data:  02/03/2012 * Projeto realizado com fundos do Conselho Nacional de Desenvolvimento Científico e Tecnológico (CNPQ)                                                       Alguns exemplos de comandos que irao funcionar nessa versao:
MNERIM 034 parafrente 100 PC 02123MNERIM 032 paratras 100 PC 01919MNERIM 035 giradireita 100 PC 02217MNERIM 036 giraesquerda 100 PC 02338MNERIM 035 quantoscomandos PC 02514MNERIM 034 exibecomando 1 PC 02225?? 029 qualseunome PC 01755
******************************************************************/
#include   
Servo servo01, servo02;
char nome[] = "PAULINHO";char caractere, checkSum[6], tamanho[4], bufferComando[20], bufferParametro[20], remetente[20];int contByte = 0, soma = 0;long icheckSum;  
//VARIAVEIS AUXILIARESint validouComando = 0, comandoOk = 0 , criaRemetente = 0;int qntInt, qntFloat, qntChar, numComando;int perguntaNome = 0;int posicao = 0;

//PONTEIROS PARA A CRIACAO DOS VETORES COM OS PARAMETROS DOS COMANDOSint *parametroInt;float *parametroFloat;char *parametroChar;

//DEFINE QUANTIDADE DE COMANDOS DO MICROCONTROLADOR#define qntComandos 8
//ESTRUTURA DE COMANDO
struct{  char nome[15];  int parametro1, parametro2, parametro3;
} comando[qntComandos]; //Vetor com a quantidade de comandos.


void setup(){  
Serial.begin(9600);  
pinMode(2, OUTPUT);  
pinMode(3, OUTPUT);  
pinMode(4, OUTPUT);  
pinMode(5, OUTPUT);    //LISTA DE COMANDOS PREVIAMENTE DECLARADOS    
//Aqui eh declarado os comandos que o microcontrolador aceitara.    
strcpy(comando[0].nome , "parafrente");  
comando[0].parametro1 = 1;  
comando[0].parametro2 = 0;  
comando[0].parametro3 = 0;    
strcpy(comando[1].nome , "paratras");  
comando[1].parametro1 = 1;  
comando[1].parametro2 = 0;  
comando[1].parametro3 = 0;       
strcpy(comando[2].nome , "giradireita");  
comando[2].parametro1 = 1;  
comando[2].parametro2 = 0;  
comando[2].parametro3 = 0;        
strcpy(comando[3].nome , "giraesquerda");  
comando[3].parametro1 = 1;  
comando[3].parametro2 = 0;  
comando[3].parametro3 = 0;    
strcpy(comando[4].nome , "quantoscomandos");  
comando[4].parametro1 = 0;  
comando[4].parametro2 = 0;  
comando[4].parametro3 = 0;    
strcpy(comando[5].nome , "exibecomando");  
comando[5].parametro1 = 1;  
comando[5].parametro2 = 0;  
comando[5].parametro3 = 0;      
strcpy(comando[6].nome, "qualseunome");  
comando[6].parametro1 = 0;  
comando[6].parametro2 = 0;  
comando[6].parametro3 = 0;    
servo01.attach(9);  
servo02.attach(3);}


void loop(){  
servo01.write(111);  
servo02.write(106);  
if ( verificarComando() == 1 )   {    
processaComando(bufferComando, parametroInt, parametroFloat, parametroChar);     
zerarVariaveis();      
}  
}



int verificarComando(){
 while (Serial.available() > 0) {
   caractere = Serial.read();   //NOME, OS PRIMEIROS BYTES     
if(posicao == 0)   {           
if ( ((nome[contByte] == caractere) || (caractere == '?')) && (caractere != 32))     {       
contByte++; // Se o caractere vindo da Serial for igual ao caractere do nome o contador (contByte) eh  incrementado em 1.     
}else  if (caractere == 32)     {       
posicao = 1;       
contByte = 0;        
}     
soma = soma + caractere;         
}          // BYTES DE TAMANHO     else if (posicao == 1)    {     
if(caractere != 32)     {      
tamanho[contByte] = caractere;      
contByte++;     
}     else     {      
posicao = 2;      
contByte = 0;     
}     
soma = soma + caractere;   
}                     //BYTES DE COMANDO       
else if(posicao == 2) //VERIFICA SE O BYTE EH DE COMANDO   {        
if (validouComando == 0) //Verifica se ja validou o comando     {             
if (caractere != 32) //32 = Espaco no ASCII       {           
bufferComando[contByte] = caractere;           
contByte++;         
}             else //Se o caractere for espaco, o nome do comando ja esta no buffer.       {         
int i;                  
for(i = 0; i < qntComandos; i++) //Aqui usamos a variavel qntComandos declarada no comeco do programa para checar os comandos existentes.         {           
if(!strcmp(bufferComando, comando[i].nome))   //Compara a string no buffer com a lista dos comandos definidos, se bater ele aloca dinamicamente variaveis para os parametros.           
{             //Aloca dinamicamente espaco para colocar os parametros dos comandos             
// e valida o comando.             
parametroInt = (int*)malloc(comando[i].parametro1 * sizeof(int));              
qntInt = comando[i].parametro1; 
//Pega a quantidade parametros inteiro da funcao                          
parametroFloat = (float*)malloc(comando[i].parametro2 * sizeof(float));             
qntFloat = comando[i].parametro2;//Pega a quantidade de parametros float da funcao.                          parametroChar = (char*)malloc(comando[i].parametro3 * sizeof(char));             
qntChar = comando[i].parametro3; //Idem aos de cima.                          
comandoOk = 1; //O comando eh valido             
numComando = i; //Guarda o numero do comando definido na lista de comandos.                            }              }                  
if(comandoOk) //Se o comando for valido continua com a verificacao.         {           
validouComando = 1; // Comando valido.           
contByte = 0;                      
if ( ( qntInt == 0) && ( qntFloat == 0) && (qntChar == 0) ) // SE EXISTIR PARAMETROS PARA SEREM LIDOS, O COMANDO NAO TA OK!           {             
posicao = 3;           
}                              
}                  else //Se o comando nao for OK zeraremos as variaveis de soma e contagem de byte para iniciar de novo o processo.         
{           
soma = 0;           
contByte = 0;            
limpabuffer(bufferComando);                     
}       
}    
        }        else if (validouComando == 1) //Se o comando ja foi validado, pegaremos os parametros    
{
      if (caractere != 32) //32 = CARACTERE "ESPACO" no ASCII       {           
bufferParametro[contByte] = caractere;           
contByte++;  
     }              
else //Se o caractere eh 32 (espaco), ja esta armazenado no bufferParametro o valor do parametro. Armazenaremos nos vetores correspondente.       {         
if (qntInt > 0) //Checa a quantidade de inteiros que a funcao ainda tem para receber.    
     {           
parametroInt[comando[numComando].parametro1 - qntInt] = atoi(bufferParametro);           
qntInt--; //Subtrai quando o parametro for adicionado ao vetor.
         }                  
else if (qntFloat > 0) //Checa a quantidade de float que a funcao ainda tem para receber.         {           parametroFloat[comando[numComando].parametro2 - qntFloat] = atof(bufferParametro);           qntFloat--;         }                  else if (qntChar > 0) //Checa a quantidade de float que a funcao ainda tem para receber. 
        {           
parametroChar[comando[numComando].parametro3 - qntChar] = bufferParametro[comando[numComando].parametro3 - qntChar];
           qntChar--;
         }                         
//Se acabou os parametros, prossegue na mensagem.                 
if( (qntInt == 0) && (qntFloat == 0) && (qntChar == 0))   //Checa se nao falta mais parametros a ser guardados.                
{             
validouComando = 0; //Espera o proximo comando no proximo frame.            
comandoOk = 1;            
posicao = 3;        
    }
           contByte = 0;           
//limpabuffer(bufferParametro);    //**NAO SEI A UTILIDADE DISSO AINDA.  
                         }              
  }   
 soma = soma + caractere;               
}      
//REMETENTE          
else if (posicao == 3)  {    
if(caractere != 32){      
remetente[contByte] = caractere;      
contByte++;    
}        else{      
posicao = 4;      
contByte = 0;  
  }    soma = soma + caractere; 
       }              
//5 BYTES DE CHECKSUM      
else if (posicao == 4)   {      
checkSum[contByte] = caractere;          
contByte++;             
// CHECAGEM FINAL COM O CHECKSUM       
if (contByte == 5)      {       
icheckSum = atol(checkSum);                
if (icheckSum == soma)  //SE O CHECKSUM BATER MANDAMOS O NOME DA FUNCAO E SEUS PARAMETROS      {            
return 1;      
}      else      {         
Serial.println("CHECKSUM NAO BATEU!");         
zerarVariaveis();         
return 0;      }                                      
   }            
 }      
 }                
}    
void processaComando ( char* comandoRecebido, int* parametroInt, float* parametroFloat, char* parametroChar){  
char resposta[20];    
if (!(strcmp(comandoRecebido,"parafrente")))   {     
servo01.write(10);     
servo02.write(180);     
delay(parametroInt[0]*10);     
servo01.write(111);     
servo02.write(106);          
strcpy(resposta, "sucesso");     
enviarMensagem(remetente, comandoRecebido, resposta);                  
}     else if (!(strcmp(comandoRecebido,"paratras")))   {     
servo01.write(180);     
servo02.write(10);     
delay(parametroInt[0]*10);     
servo01.write(111);     
servo02.write(106);          
strcpy(resposta, "sucesso");     
enviarMensagem(remetente, comandoRecebido, resposta);  
 }      else if (!(strcmp(comandoRecebido,"giradireita")))   {     
servo01.write(10);     
servo02.write(10);     
delay(parametroInt[0]*10);     
servo01.write(111);     
servo02.write(106);          
strcpy(resposta, "sucesso");     
enviarMensagem(remetente, comandoRecebido, resposta);  
}   else if (!(strcmp(comandoRecebido,"giraesquerda")))   {     
servo01.write(180);     
servo02.write(180);     
delay(parametroInt[0]*10);     
servo01.write(111);     
servo02.write(106);          
strcpy(resposta, "sucesso");          
enviarMensagem(remetente, comandoRecebido, resposta); 
  }      else if (!(strcmp(comandoRecebido,"quantoscomandos")))   {     
char* resposta = "";     
itoa(qntComandos, resposta, 10);      
enviarMensagem(remetente, comandoRecebido, resposta); 
       }       else if (!(strcmp(comandoRecebido,"exibecomando")))   {     
char resposta[30];     
char aux[2];     
int qntInt, qntFloat, qntChar;     
        strcpy(resposta, comando[parametroInt[0] - 1].nome);         
qntInt = comando[parametroInt[0] -1].parametro1;     
qntFloat = comando[parametroInt[0] -1].parametro2;     
qntChar = comando[parametroInt[0] -1].parametro3;  
     itoa(qntInt, aux, 10);     
strcat(resposta, " ");     
strcat(resposta, aux);
     itoa(qntFloat, aux, 10);     
strcat(resposta, " ");     
strcat(resposta, aux);                  
itoa(qntChar, aux, 10);     
strcat(resposta, " ");     
strcat(resposta, aux);          
enviarMensagem(remetente, comandoRecebido, resposta);    }       
else if (!(strcmp(comandoRecebido,"qualseunome")))   {     enviarMensagem(remetente, comandoRecebido, NULL);  
 } 
}
void enviarMensagem(char* remetente, char* comando, char* resposta){  
int soma = 0, i;  
int itamanho = 3 + 5 + 1; // 3 BYTES DO TAMANHO, 5 BYTES DO CHECKSUM, 1 BYTE DE ESPAÇO  
char tamanho[3], nomeAux[20];  
strcpy(nomeAux, nome);  
if (resposta != NULL) 
strcat(resposta," ");  
strcat(comando," ");  
strcat(remetente," ");  
strcat(nomeAux," ");    
itamanho = itamanho + strlen(remetente) + strlen(comando) + strlen(resposta) + strlen(nomeAux);  
itoa(itamanho, tamanho, 10);      
for (i = 0; i < strlen(remetente); i++)  {    
soma = soma +  remetente[i];  
}    
for (i = 0; i < strlen(comando); i++)  {    
soma = soma + comando[i]; 
 }      
for (i = 0; i < strlen(resposta); i++)  {    
soma = soma + resposta[i]; 
 }      
for (i = 0; i < strlen(nomeAux); i++)  {    
soma = soma + nomeAux[i]; 
 }      
for (i = 0; i < strlen(tamanho); i++)  {    
soma = soma + tamanho[i]; 
 }   
    Serial.print(remetente);  
if ( strlen(tamanho) < 3)  {    
Serial.print("0");    soma += 48;  
}  Serial.print(tamanho);  
Serial.print(" ");  
soma += 32;  
Serial.print(comando);  
if (resposta != NULL) Serial.print(resposta);  
Serial.print(nomeAux);  
if(soma < 10000) Serial.print("0");  
Serial.println(soma);  }
//Funcao para limpar os buffers. (Avaliarei depois a eficiencia disso)  
void limpabuffer(char buffer[20]){ int i;  for (i = 0; i < 20; i++) {  
buffer[i] = NULL; 
}
}

void  zerarVariaveis(){         //Apos executar o comando zera todos os valores e comeca tudo de novo.      
 soma = 0;       
contByte = 0;        
validouComando = 0;       
limpabuffer(bufferComando);       
limpabuffer(bufferParametro);       
limpabuffer(remetente);       
comandoOk = 0;       
criaRemetente = 0;       
perguntaNome = 0;       
posicao = 0;            
}



Estrutura Física do Paulinho 
Servo servo01, servo02;
char nome[] = "PAULINHO";char caractere, checkSum[6], tamanho[4], bufferComando[20], bufferParametro[20], remetente[20];int contByte = 0, soma = 0;long icheckSum;  
//VARIAVEIS AUXILIARESint validouComando = 0, comandoOk = 0 , criaRemetente = 0;int qntInt, qntFloat, qntChar, numComando;int perguntaNome = 0;int posicao = 0;
//PONTEIROS PARA A CRIACAO DOS VETORES COM OS PARAMETROS DOS COMANDOSint *parametroInt;float *parametroFloat;char *parametroChar;
//DEFINE QUANTIDADE DE COMANDOS DO MICROCONTROLADOR#define qntComandos 8
//ESTRUTURA DE COMANDO
struct{  char nome[15];  int parametro1, parametro2, parametro3;
} comando[qntComandos]; //Vetor com a quantidade de comandos.

void setup(){  
Serial.begin(9600);  
pinMode(2, OUTPUT);  
pinMode(3, OUTPUT);  
pinMode(4, OUTPUT);  
pinMode(5, OUTPUT);    //LISTA DE COMANDOS PREVIAMENTE DECLARADOS    
//Aqui eh declarado os comandos que o microcontrolador aceitara.    
strcpy(comando[0].nome , "parafrente");  
comando[0].parametro1 = 1;  
comando[0].parametro2 = 0;  
comando[0].parametro3 = 0;    
strcpy(comando[1].nome , "paratras");  
comando[1].parametro1 = 1;  
comando[1].parametro2 = 0;  
comando[1].parametro3 = 0;       
strcpy(comando[2].nome , "giradireita");  
comando[2].parametro1 = 1;  
comando[2].parametro2 = 0;  
comando[2].parametro3 = 0;        
strcpy(comando[3].nome , "giraesquerda");  
comando[3].parametro1 = 1;  
comando[3].parametro2 = 0;  
comando[3].parametro3 = 0;    
strcpy(comando[4].nome , "quantoscomandos");  
comando[4].parametro1 = 0;  
comando[4].parametro2 = 0;  
comando[4].parametro3 = 0;    
strcpy(comando[5].nome , "exibecomando");  
comando[5].parametro1 = 1;  
comando[5].parametro2 = 0;  
comando[5].parametro3 = 0;      
strcpy(comando[6].nome, "qualseunome");  
comando[6].parametro1 = 0;  
comando[6].parametro2 = 0;  
comando[6].parametro3 = 0;    
servo01.attach(9);  
servo02.attach(3);}

void loop(){  
servo01.write(111);  
servo02.write(106);  
if ( verificarComando() == 1 )   {    
processaComando(bufferComando, parametroInt, parametroFloat, parametroChar);     
zerarVariaveis();      
}  
}


int verificarComando(){
 while (Serial.available() > 0) {
   caractere = Serial.read();   //NOME, OS PRIMEIROS BYTES     
if(posicao == 0)   {           
if ( ((nome[contByte] == caractere) || (caractere == '?')) && (caractere != 32))     {       
contByte++; // Se o caractere vindo da Serial for igual ao caractere do nome o contador (contByte) eh  incrementado em 1.     
}else  if (caractere == 32)     {       
posicao = 1;       
contByte = 0;        
}     
soma = soma + caractere;         
}          // BYTES DE TAMANHO     else if (posicao == 1)    {     
if(caractere != 32)     {      
tamanho[contByte] = caractere;      
contByte++;     
}     else     {      
posicao = 2;      
contByte = 0;     
}     
soma = soma + caractere;   
}                     //BYTES DE COMANDO       
else if(posicao == 2) //VERIFICA SE O BYTE EH DE COMANDO   {        
if (validouComando == 0) //Verifica se ja validou o comando     {             
if (caractere != 32) //32 = Espaco no ASCII       {           
bufferComando[contByte] = caractere;           
contByte++;         
}             else //Se o caractere for espaco, o nome do comando ja esta no buffer.       {         
int i;                  
for(i = 0; i < qntComandos; i++) //Aqui usamos a variavel qntComandos declarada no comeco do programa para checar os comandos existentes.         {           
if(!strcmp(bufferComando, comando[i].nome))   //Compara a string no buffer com a lista dos comandos definidos, se bater ele aloca dinamicamente variaveis para os parametros.           
{             //Aloca dinamicamente espaco para colocar os parametros dos comandos             
// e valida o comando.             
parametroInt = (int*)malloc(comando[i].parametro1 * sizeof(int));              
qntInt = comando[i].parametro1; 
//Pega a quantidade parametros inteiro da funcao                          
parametroFloat = (float*)malloc(comando[i].parametro2 * sizeof(float));             
qntFloat = comando[i].parametro2;//Pega a quantidade de parametros float da funcao.                          parametroChar = (char*)malloc(comando[i].parametro3 * sizeof(char));             
qntChar = comando[i].parametro3; //Idem aos de cima.                          
comandoOk = 1; //O comando eh valido             
numComando = i; //Guarda o numero do comando definido na lista de comandos.                            }              }                  
if(comandoOk) //Se o comando for valido continua com a verificacao.         {           
validouComando = 1; // Comando valido.           
contByte = 0;                      
if ( ( qntInt == 0) && ( qntFloat == 0) && (qntChar == 0) ) // SE EXISTIR PARAMETROS PARA SEREM LIDOS, O COMANDO NAO TA OK!           {             
posicao = 3;           
}                              
}                  else //Se o comando nao for OK zeraremos as variaveis de soma e contagem de byte para iniciar de novo o processo.         
{           
soma = 0;           
contByte = 0;            
limpabuffer(bufferComando);                     
}       
}    
        }        else if (validouComando == 1) //Se o comando ja foi validado, pegaremos os parametros    
{
      if (caractere != 32) //32 = CARACTERE "ESPACO" no ASCII       {           
bufferParametro[contByte] = caractere;           
contByte++;  
     }              
else //Se o caractere eh 32 (espaco), ja esta armazenado no bufferParametro o valor do parametro. Armazenaremos nos vetores correspondente.       {         
if (qntInt > 0) //Checa a quantidade de inteiros que a funcao ainda tem para receber.    
     {           
parametroInt[comando[numComando].parametro1 - qntInt] = atoi(bufferParametro);           
qntInt--; //Subtrai quando o parametro for adicionado ao vetor.
         }                  
else if (qntFloat > 0) //Checa a quantidade de float que a funcao ainda tem para receber.         {           parametroFloat[comando[numComando].parametro2 - qntFloat] = atof(bufferParametro);           qntFloat--;         }                  else if (qntChar > 0) //Checa a quantidade de float que a funcao ainda tem para receber. 
        {           
parametroChar[comando[numComando].parametro3 - qntChar] = bufferParametro[comando[numComando].parametro3 - qntChar];
           qntChar--;
         }                         
//Se acabou os parametros, prossegue na mensagem.                 
if( (qntInt == 0) && (qntFloat == 0) && (qntChar == 0))   //Checa se nao falta mais parametros a ser guardados.                
{             
validouComando = 0; //Espera o proximo comando no proximo frame.            
comandoOk = 1;            
posicao = 3;        
    }
           contByte = 0;           
//limpabuffer(bufferParametro);    //**NAO SEI A UTILIDADE DISSO AINDA.  
                         }              
  }   
 soma = soma + caractere;               
}      
//REMETENTE          
else if (posicao == 3)  {    
if(caractere != 32){      
remetente[contByte] = caractere;      
contByte++;    
}        else{      
posicao = 4;      
contByte = 0;  
  }    soma = soma + caractere; 
       }              
//5 BYTES DE CHECKSUM      
else if (posicao == 4)   {      
checkSum[contByte] = caractere;          
contByte++;             
// CHECAGEM FINAL COM O CHECKSUM       
if (contByte == 5)      {       
icheckSum = atol(checkSum);                
if (icheckSum == soma)  //SE O CHECKSUM BATER MANDAMOS O NOME DA FUNCAO E SEUS PARAMETROS      {            
return 1;      
}      else      {         
Serial.println("CHECKSUM NAO BATEU!");         
zerarVariaveis();         
return 0;      }                                      
   }            
 }      
 }                
}    
void processaComando ( char* comandoRecebido, int* parametroInt, float* parametroFloat, char* parametroChar){  
char resposta[20];    
if (!(strcmp(comandoRecebido,"parafrente")))   {     
servo01.write(10);     
servo02.write(180);     
delay(parametroInt[0]*10);     
servo01.write(111);     
servo02.write(106);          
strcpy(resposta, "sucesso");     
enviarMensagem(remetente, comandoRecebido, resposta);                  
}     else if (!(strcmp(comandoRecebido,"paratras")))   {     
servo01.write(180);     
servo02.write(10);     
delay(parametroInt[0]*10);     
servo01.write(111);     
servo02.write(106);          
strcpy(resposta, "sucesso");     
enviarMensagem(remetente, comandoRecebido, resposta);  
 }      else if (!(strcmp(comandoRecebido,"giradireita")))   {     
servo01.write(10);     
servo02.write(10);     
delay(parametroInt[0]*10);     
servo01.write(111);     
servo02.write(106);          
strcpy(resposta, "sucesso");     
enviarMensagem(remetente, comandoRecebido, resposta);  
}   else if (!(strcmp(comandoRecebido,"giraesquerda")))   {     
servo01.write(180);     
servo02.write(180);     
delay(parametroInt[0]*10);     
servo01.write(111);     
servo02.write(106);          
strcpy(resposta, "sucesso");          
enviarMensagem(remetente, comandoRecebido, resposta); 
  }      else if (!(strcmp(comandoRecebido,"quantoscomandos")))   {     
char* resposta = "";     
itoa(qntComandos, resposta, 10);      
enviarMensagem(remetente, comandoRecebido, resposta); 
       }       else if (!(strcmp(comandoRecebido,"exibecomando")))   {     
char resposta[30];     
char aux[2];     
int qntInt, qntFloat, qntChar;     
        strcpy(resposta, comando[parametroInt[0] - 1].nome);         
qntInt = comando[parametroInt[0] -1].parametro1;     
qntFloat = comando[parametroInt[0] -1].parametro2;     
qntChar = comando[parametroInt[0] -1].parametro3;  
     itoa(qntInt, aux, 10);     
strcat(resposta, " ");     
strcat(resposta, aux);
     itoa(qntFloat, aux, 10);     
strcat(resposta, " ");     
strcat(resposta, aux);                  
itoa(qntChar, aux, 10);     
strcat(resposta, " ");     
strcat(resposta, aux);          
enviarMensagem(remetente, comandoRecebido, resposta);    }       
else if (!(strcmp(comandoRecebido,"qualseunome")))   {     enviarMensagem(remetente, comandoRecebido, NULL);  
 } 
}
void enviarMensagem(char* remetente, char* comando, char* resposta){  
int soma = 0, i;  
int itamanho = 3 + 5 + 1; // 3 BYTES DO TAMANHO, 5 BYTES DO CHECKSUM, 1 BYTE DE ESPAÇO  
char tamanho[3], nomeAux[20];  
strcpy(nomeAux, nome);  
if (resposta != NULL) 
strcat(resposta," ");  
strcat(comando," ");  
strcat(remetente," ");  
strcat(nomeAux," ");    
itamanho = itamanho + strlen(remetente) + strlen(comando) + strlen(resposta) + strlen(nomeAux);  
itoa(itamanho, tamanho, 10);      
for (i = 0; i < strlen(remetente); i++)  {    
soma = soma +  remetente[i];  
}    
for (i = 0; i < strlen(comando); i++)  {    
soma = soma + comando[i]; 
 }      
for (i = 0; i < strlen(resposta); i++)  {    
soma = soma + resposta[i]; 
 }      
for (i = 0; i < strlen(nomeAux); i++)  {    
soma = soma + nomeAux[i]; 
 }      
for (i = 0; i < strlen(tamanho); i++)  {    
soma = soma + tamanho[i]; 
 }   
    Serial.print(remetente);  
if ( strlen(tamanho) < 3)  {    
Serial.print("0");    soma += 48;  
}  Serial.print(tamanho);  
Serial.print(" ");  
soma += 32;  
Serial.print(comando);  
if (resposta != NULL) Serial.print(resposta);  
Serial.print(nomeAux);  
if(soma < 10000) Serial.print("0");  
Serial.println(soma);  }
//Funcao para limpar os buffers. (Avaliarei depois a eficiencia disso)  
void limpabuffer(char buffer[20]){ int i;  for (i = 0; i < 20; i++) {  
buffer[i] = NULL; 
}
}
void  zerarVariaveis(){         //Apos executar o comando zera todos os valores e comeca tudo de novo.      
 soma = 0;       
contByte = 0;        
validouComando = 0;       
limpabuffer(bufferComando);       
limpabuffer(bufferParametro);       
limpabuffer(remetente);       
comandoOk = 0;       
criaRemetente = 0;       
perguntaNome = 0;       
posicao = 0;            
}

Estrutura Física do Paulinho 

O Paulinho é divido principalmente em 4 partes, sendo elas: 
- Plataforma Superior (onde foi usado uma placa de nylon cortada e com alguns furos.)
       *Dimensões (10 cm X 8 cm) e com 4 furos posicionados à 3 cm da borda de maior comprimento, e a 1 cm da borda de menor comprimento, os furos estão espaçados de aproximadamente 2 cm.

- Plataforma Inferior (também feita de nylon)
        *Dimensões (15 cm x 4 cm) com 8 furos,sendo os mais externos, dispostos à 1 cm da borda de maior comprimento e a 1 cm da borda de menor comprimento, e os mais internos, estão espaçados de 3 cm.

- Suportes Laterais dos Servos Motores
    Possui formado parecido com um 'L', foi feita utilizando-se de placas de metal reciclado do CD-ROM, e com as dimensões descritas pelas imagem abaixo.
   Obs.: Os furos para a fixação do servo motor nos suportes, irá depender to tamanho do servo que está sendo utilizado, no nosso, caso usamos o Mini Servo 9G, mas você pode utilizar outros modelos, apenas tomando cuidado para fazer os furos na posição em que o seu motor seja bem fixado.

 Suporte Lateral visto de outros ângulos: 

-Fixador do Suporte Lateral
     Feito do mesmo material dos Suportes Laterais, os fixadores (como o próprio nome já diz) , auxilia na melhor fixação dos motores nas plataformas Superior e Inferior. O fixador é um retângulo metálico, com as dimensões de 1,5 cm X 5 cm , com furos á 0,5 cm da maior borda e a 0,5 cm da menor borda.

Montagem das Peças 

PASSO 1: 

Colocamos os parafusos maiores na plataforma superior do paulinho.


PASSO 2 :

Fixamos as porcas para fixar a plataforma superior.


3 - PASSO: 


Colocamos mais 4 porcas na outra extremidade dos outros parafusos, mas não enroscamos até o final, pois elas servirão para colocar o suporte inferior do Paulinho.



PASSO 4:

Colocamos a plataforma inferior, e com mais 4 outras porcas fixamos ela.



Abaixo, temos uma foto de como deve ficar as plataformas depois de serem unidas.




PASSO 5:

Na plataforma superior do Paulinho, colocamos o Arduino, e analisando ele, podemos perceber que ele tem algumas aberturas que servem para serem parafusadas no robô, nesse caso, famos fixar o arduino no Paulinho usando parafusos bem pequenos. 


PASSO 6:

Após fixado o arduino, vamos agora prender os Suportes Laterais dos Servor Motores que devem ficar como na foto abaixo. 




PASSO 7:

Agora, com muito cuidado, colocamos os Servo Motores, que nesse caso, como dito anteriormente, foram os mini servos 9G e prendemos os servo motores no suporte com parafusos.







Segue abaixo mais algumas imagens de como prender os Servos colocando o fixador de suporte lateral.