Uma vez participando do "Desafio de Robótica" (Palco Galileu), desta vez na 7º edição do evento (CPBR7) a CajuinaLabs vem com força para o evento.

     Como todos os anos todas as peças mínimas necessárias para construir um robô que complete a o desafio proposto.

Itens Fornecidos (Kit de Desenvolvimento):

1x Arduino UNO
2x motores para as rodas (Por sorteio algumas equipes ganham Servo Motores e outras Motores DC)
1x Micro Servo Motor
2x rodas para o robô
1x rodizio de cadeira para ser usado como Terceira Roda (Roda Boba)(Caster)
3x LDR (Sensor de Luminosidade)
2x TCRT5000 (Sensor Óptico Reflexivo muito usado como Sensor de Linha)
1x Sonar (Sensor de Distância)
Pilhas para serem usadas como fonte de Energia (A disposição)
2x Caixa de Bateria (Para montar as pilhas em série e formar uma bateria)
Jumpers para conexões dos sensores (A disposição)
1x Protoboard para prototipação


     Devido a outras tarefas dentro da Campus Party, e pelas regras da competição cada equipe deve ter no mínimo 3 integrantes, eu (AJ Alves e o Joselé) decidimos concorrer por fora, isso significa abrir mão o Kit de Desenvolvimento mas poder formar a equipe apenas nos dois.
     Alguns itens nós já tinhamos, todos os outros consegui comprar com o Adriano da CoolerMaster que me vendeu por um ótimo preço, salvou nossa pele. Nosso Kit ficou então com essa configuração até o momento (30/Qui - 09h):

Lista de Materiais - Parte 1

1x Arduino Mega
1x Sonar (Sensor de Distância)
2x LDR (Sensor de Luminosidade)
1x Micro Servo Motor
2x Servo Motor
1x Circuito Óptico Reflexivo (Tem como base o TCRT5000)


     O CajúRover tem como base um chassi impresso usando uma "Impressora 3D" (Impressora esta ganhada na competição da CPBR6), uma Impressora 3D consiste em nada mais nada menos que imprimir um modelo tri-dimensional que pode ser modelado utilizando qualquer software de modelagem 3D (Blender, 3D MAx, Maia), para isso ela derrete um filamento plastico e vai montando o modelo, o chassi do CajúTruck foi uma adaptação que fizemos utilizando um modelo 3D criado pelo Krux, veja na Imagem 1 o modelo quase por completo.

tri-track-rover_preview_featured.jpg
                                            Imagem 1 - Base do CajúRover


     Como vocês podem ver, o chassi é composto por várias peças, são elas:

Lista de Materiais - Parte 2
608_idler_sprocket_preview_featured.jpg 4x 608 Idler Sprocket, essa engrenagem foi feita para que caiba nela um rolamento 608, que é um rolamento muito fácil de encontrar e barato.
drive_sprocket_preview_featured.jpg2x Drive Sprocket, essa engrenagem deve ser encaixada no suporte do Servo Motor para que o mesmo o faça mover-se.
servo_mount_2_preview_featured.jpg 2x Servo Mount, serve para prender os Servo Motores na base, foi projetada para caber qualquer Servo Motor de tamanho padrão.
tri-track_frame_end_preview_featured.jpg 

2x Track Frame End Segment, monta a base do chassi.
tri-track_frame_middle_preview_featured. 1x Track Frame Middle Segment, monta a base do chassi.

     O Krux ainda modelou as peças que formam a esteira do tanque eu preferi não utilizar elas, caso você queria esses modelos, é só acessar a pagina dele que forneci, eu logo postarei um link que tem todos os modelos tre-dimensionais que utilizei, caso vocês queiram reproduzir o robô, todo o projeto é Open Source. Como vocês verão, minha esteira é feita de EVA, desses comprados em qualquer papelaria.
     Seguem agora as partes adicionais que eu modelei (Usando o Blender):

suport-base.jpg 2x Track Suport Base, como o chassi não possui uma estante para apoiar componentes, sensores, atuadores e todo o mais, essa peça serve para montar uma estante.
base.jpg 1x Track Base, monta um bom suporte para por equipamentos.

     Para baixar todos os modelos apresentados vá em Link Para Download. Adicionalmente são necessários mais alguns itens que são facilmente achados em casas de construção para montar o chassi:

Lista de Materiais - Parte 3
8x Parafusos do M3 de 15mm
4x Parafusos do M3 de 20mm
8x Parafusos do M3 de 35mm
24x Porcas do M3
24x Arruelas do M3
4x Parafusos do M4 de 16mm
4x Porcas do M4
8x  Arruelas do M4
2x Pedaços de 160mm do M8 (Uma barra do M8 tem 1m, então você pode cortar)
20x Porcas do M8
16x Arruelas do M8
1x Folha de EVA (Para fazer a esteira do tanque)

     Lembrando que M3, M4 e M8 são referências para comprimentos e espaçamentos de parafusos. A montagem do chassi é muito intuitiva e fácil como vocês puderam analisar nas Figura 2, 3, 4, 5 e 6.

                DSC03115.JPG

                                           Figura 2 - Base do chassi montada

               DSC03118.JPG

       Servo Motores são projetados para receber um sinal de controle e mover-se precisamente para uma posição X, os Servo Motores das rodas devem passar primeiramente por um processo de HAKEAMENTO, você pode aprender como fazer isso aqui mesmo no robolivre.org, LINK, feito isso seus servos irão girar continuamente.

                                          Figura 4 - Servos montados

                                DSC03121.JPG

                                          Figura 5 -  base e servos conectados

           DSC03132.JPG

                                            Figura 6 - chassi completo

     Na Arena de Desenvolvimento (Workshop 1) existem várias ferramentas que auxiliam no desenvolvimento dos robôs (Furadeira, Retifica, Multímetros, Chaves de Fenda, Alicates, ...), há também muita sucata eletrônica de onde se pode extrair muito material útil, fui lá vasculhar (30/Qui -11h) e encontrei diversos fios que servirão para montar a parte elétrica, alguns LEDs e um Buzzer (Emite sinais Sonoros):

     DSC03133.JPGDSC03134.JPGDSC03135.JPGDSC03136.JPGDSC03137.JPG

                                              Figura 7 - Arena de Desenvolvimento

Lista de Materiais - Parte 4
2x - LED}
1x - Buzzer (Emite sinais Sonoros)

       Até então só mostrei como montar os Servo Motores das rodas no chassi, mostrei onde você vai aprender a hakear os mesmos, agora vou mostrar como controlar Servo Motores utilizando o Arduino.

       O Arduino IDE já vem com uma biblioteca chamada "Servo" que permite facilmente controlar Servo Motores, sejam eles normal ou hakeados, vejam na Figura 8 como fazer a ligação de um Servo Motor no Arduino, todo Servo Motor possui 3 fios, um para Tensão (VCC) outro para Terra (GND) e o último para Sinal. Outro fator importante é conhecer bem seu equipamento, Servos geralmente trabalham com tensão entre 4.5V e 6V, mas variam muito o quanto de corrente usam, outra coisa a se atentar é qual fio é qual, uma ligação errada no seu servo motor é o suficiente para danificar permanentemente ele.

                                             servo-arduino.jpeg

                                       Figura 8 - Servo Motor ligado ao Arduino

       Eu não usarei a ligação do fio de VCC e GND dos servos como mostrado na Figura 8, puxarei a energia de um regulador de tensão externo, para evitar sobrecarregar e até danificar o arduino, no final mostrarei como montarei o circuito. 

     É a hora de montar o sensores de luz. Primeiramente, para montar um sensor de luminosidade você deve entender o que é e como funciona um LDR.
Como o próprio nome já diz, o LDR é um resistor que dependendo da intensidade de luz que insidie sobre ele, varia sua resistência, para fazer o Arduino medir essa "quantidade de luz" temos que fazer um Divisor de voltagem: Colocar dois resistores em serie (Um fixo e Um LDR) e medir a voltagem entre os dois.
                                                  volt-div.png
     Como mostrado na imagem acima, o R1 é o LDR e o R2 é um resistor fixo, como o Arduino trabalha com 5v, por segurança escolhei um resistor de 10KR para ser o R2 (Mas pode ser bem menos,  por exemplo 500R, como você verá na programação isso tem um impacto). Resumindo, o VCC de 5V vai no LDR o LDR se liga no R2 e o R2 vai no GND, entre os dois, um fio se liga em alguma das portas analógicas do Arduino. Para determinar a voltagem (Que irá variar de acordo com a quantidade de luz sobre o LDR) podemos usar a formula da imagem. Mais detalhes serão dados em breve na montagem do código.

Como conectar na placa:

                                           ldr-arduino.jpeg

     Por ironia do destino meu circuito inteiro necessitaria de mais corrente que meu regulador de tensão LM7805 poderia fornecer, então tive que cortar alguns componentes como, LEDS e o Buzzer, para ficar bem enxuto.

     Montando os sensores ópticos. Este sensor é composto basicamente por um LED emissor de infravermelho (Luz que nesta frequência [Hz] não é visível a olho nu)  e um fototransistor responsável por filtrar a luz natural e captar ou não sinais de infravermelho. Ele possui um escudo que separa o emissor do receptor e dependendo da reflexibilidade da superfície ele é capaz de detectar a cor (Em uma escala PRETO e BRANCO) dessa superfície em questão.

     Este circuito é apenas um exemplo de montagem e uso deste sensor, você pode alterar sua configuração para se adequar a certas situações ou especificações, sempre seguindo o que foi especificado no DATASHEET.

                   content_tcrt5000-schema.jpg

     Assim o último a ser ligado foi o servo motor, veja como conectar o sonar ao Arduino:

                                                  sonar-arduino.png 

                 

O sonar que recebemos possui duas caixas que é bem mais confiável de se trabalhar usaremos uma como ECHO e outra como TRIGGER: O de TRIGGER irá emitir a onde sonora, e o de ECHO para receber o pulso, e então calcular a distância pelo tempo de propagação do som.

Por fim o código:

/*
* CajúRover of CajuinaLabs (Desafio Robótica Livre - CPBR7 from robolivre.org)
*/
#include <Servo.h> // Instanciando a biblioteca para trabalhar com Servo Motores

const byte RODA_DIREITA_PIN = 6; // Pino da roda direita
const byte RODA_ESQUERDA_PIN = 8; // Pino da roda esquerda
const byte CABECA_PIN = 10; // Pino da cabeça

// indices para saber qual direção pertence a qual posição no array
const byte SONAR_ESQUERDA = 0;
const byte SONAR_FRENTE_ESQUERDA = 1;
const byte SONAR_FRENTE = 2;
const byte SONAR_FRENTE_DIREITA = 3;
const byte SONAR_DIREITA = 4;

const byte VALOR_MIN_INDICE = 0;
const byte VALOR_ZERO_INDICE = 1;
const byte VALOR_MAX_INDICE = 2;

const byte RODA_DIREITA_VELOCIDADES[3] = {0, 90, 180};
const byte RODA_ESQUERDA_VELOCIDADES[3] = {150, 90, 30};

byte velocidadeRodaDireita = RODA_DIREITA_VELOCIDADES[VALOR_ZERO_INDICE];
byte velocidadeRodaEsquerda = RODA_ESQUERDA_VELOCIDADES[VALOR_ZERO_INDICE];

byte porcentagemDobraRodaDireita, porcentagemDobraRodaEsquerda = 0;

Servo rodaDireita, rodaEsquerda, cabeca;

const byte LED_VERMELHO_PIN = 22; // Pino do LED vermelho
const byte LED_VERDE_PIN = 23; // Pino do LED verde

boolean foraDaLinha = false;

const byte BUZZER_PIN = 12; // Pino do Buzzer

const byte SONAR_NUM_LEITURAS = 5; // Num de leituras para fazer uma media, evitar ruidos
const byte ECHO_PIN = 51;
const byte INIT_PIN = 50;
const byte PERIODO_SONAR = 20;
unsigned long distancias[5] = {10, 10, 10, 10, 10}; // Cinco direções cinco distancias em cm
const long CHECAR_DISTANCIA_A_CADA = 1000;
const byte CONSTANTE_CONVERTER_PARA_CM = 58;

const byte LDR_NUM_LEITURAS = 10; // Num de leituras para fazer uma media, evitar ruidos
const byte PERIODO_LDR = 10;

const byte LDR_DIREITA_INDEX = 0;
const byte LDR_ESQUERDA_INDEX = 1;
const byte LDR_CABECA_INDEX = 2;

const byte LDR_DIREITA_PIN = 0;
const byte LDR_ESQUERDA_PIN = 1;
const byte LDR_CABECA_PIN = 15;
const long CHECAR_LUMINOSIDADE_A_CADA = 2000;
const int LDR_DIREITO_LIMITES[2] = {400, 600};
const int LDR_ESQUERDO_LIMITES[2] = {950, 1023};

unsigned int luminosidades[3] = {512, 512, 512};

const byte OPTICO_REFLEXIVO_DIREITO_PIN = 4;
const byte OPTICO_REFLEXIVO_CENTRAL_PIN = 3;
const byte OPTICO_REFLEXIVO_ESQUERDO_PIN = 2;

const long CHECAR_OPTICOS_A_CADA = 250;

unsigned long ultimaLeituraDeDistancia, ultimaLeituraDeLuminosidade, ultimaLeituraOpticos;

// Função de configuração do Arduino
void setup(){
Serial.begin(9600);

rodaDireita.attach(RODA_DIREITA_PIN); // Configurando a roda direita
rodaEsquerda.attach(RODA_ESQUERDA_PIN); // Configurando a roda esquerda
cabeca.attach(CABECA_PIN); // Configurando a roda esquerda

pinMode(LED_VERMELHO_PIN, OUTPUT); // Configurando o pino como saída
pinMode(LED_VERDE_PIN, OUTPUT); // Configurando o pino como saída

pinMode(BUZZER_PIN, OUTPUT); // Configurando o pino como saída

posicionarCabeca(SONAR_FRENTE);

pinMode(INIT_PIN, OUTPUT); // Configurando o pino como saída
pinMode(ECHO_PIN, INPUT); // Configurando o pino como entrada

pinMode(OPTICO_REFLEXIVO_DIREITO_PIN, INPUT); // Configurando o pino como entrada
pinMode(OPTICO_REFLEXIVO_CENTRAL_PIN, INPUT); // Configurando o pino como entrada
pinMode(OPTICO_REFLEXIVO_ESQUERDO_PIN, INPUT); // Configurando o pino como entrada

ultimaLeituraDeDistancia, ultimaLeituraDeLuminosidade, ultimaLeituraOpticos = millis();

delay(3000);
acionarMotores(50);
Serial.println("Starting...");
}

// Função iterativa do Arduino
void loop(){
if(millis() - ultimaLeituraDeDistancia > CHECAR_DISTANCIA_A_CADA){
tratarDistancia(lerDistancia());
ultimaLeituraDeDistancia = millis();
}

if(millis() - ultimaLeituraDeLuminosidade > CHECAR_LUMINOSIDADE_A_CADA){
//tratarLuminosidade();
ultimaLeituraDeLuminosidade = millis();
}

if(millis() - ultimaLeituraOpticos > CHECAR_OPTICOS_A_CADA){
// tratarOpticos();
ultimaLeituraOpticos = millis();
}
}

void acionarMotores(int velocidade){
if(velocidade < -100 || velocidade > 100){
velocidade = 0;
}
velocidadeRodaDireita = RODA_DIREITA_VELOCIDADES[VALOR_ZERO_INDICE] + ((RODA_DIREITA_VELOCIDADES[VALOR_MAX_INDICE] - RODA_DIREITA_VELOCIDADES[VALOR_ZERO_INDICE]) * ((float) velocidade / 100.0));
velocidadeRodaEsquerda = RODA_ESQUERDA_VELOCIDADES[VALOR_ZERO_INDICE] + ((RODA_ESQUERDA_VELOCIDADES[VALOR_MAX_INDICE] - RODA_ESQUERDA_VELOCIDADES[VALOR_ZERO_INDICE]) * ((float) velocidade / 100.0));

imprimirVelocidades();
}

void fazerCurva(int angulo){
if(angulo < -100 || angulo > 100){
angulo = 0;
}

if(angulo < 0){
angulo = angulo * -1;
porcentagemDobraRodaDireita = 0;
porcentagemDobraRodaEsquerda = (RODA_ESQUERDA_VELOCIDADES[VALOR_MAX_INDICE] - RODA_ESQUERDA_VELOCIDADES[VALOR_ZERO_INDICE]) * (1- ((float) angulo / 100.0));
}else if(angulo > 0){
porcentagemDobraRodaDireita = (RODA_DIREITA_VELOCIDADES[VALOR_MAX_INDICE] - RODA_DIREITA_VELOCIDADES[VALOR_ZERO_INDICE]) * (1- ((float) angulo / 100.0));
porcentagemDobraRodaEsquerda = 0;
}else{
porcentagemDobraRodaDireita = 0;
porcentagemDobraRodaEsquerda = 0;
}

imprimirVelocidades();
}

void imprimirVelocidades(){
rodaDireita.write(velocidadeRodaDireita + porcentagemDobraRodaDireita);
rodaEsquerda.write(velocidadeRodaEsquerda + porcentagemDobraRodaEsquerda);
}

void posicionarCabeca(byte position){
switch(position){
case SONAR_ESQUERDA :
cabeca.write(180);
break;
case SONAR_FRENTE_ESQUERDA :
cabeca.write(135);
break;
case SONAR_FRENTE :
cabeca.write(90);
break;
case SONAR_FRENTE_DIREITA :
cabeca.write(45);
break;
case SONAR_DIREITA :
cabeca.write(0);
break;
}
}

void acenderLEDs(){
digitalWrite(LED_VERMELHO_PIN, HIGH);
digitalWrite(LED_VERDE_PIN, HIGH);
}

void apagarLEDs(){
digitalWrite(LED_VERMELHO_PIN, LOW);
digitalWrite(LED_VERDE_PIN, LOW);
}

void acionarLEDs(boolean naLinha){
if(naLinha){
digitalWrite(LED_VERMELHO_PIN, LOW);
digitalWrite(LED_VERDE_PIN, HIGH);
}else{
digitalWrite(LED_VERMELHO_PIN, HIGH);
digitalWrite(LED_VERDE_PIN, LOW);
}
}

void ligarBuzzer(){
tone(BUZZER_PIN, 1500); // Ligando o buzzer com uma frequencia de 1500 hz.
}

void desligarBuzzer(){
noTone(BUZZER_PIN); // Desligando o buzzer.
}

unsigned long lerDistancia(){
unsigned long leituras = 0;
// Fazer uma iteração do tamanho desejado para tirar a média
for (byte leitura = 0; leitura < SONAR_NUM_LEITURAS; leitura++) {
digitalWrite(INIT_PIN, HIGH); // Enviando um pulso deve durar 10us
delayMicroseconds(10); // Esperando os 10us
digitalWrite(INIT_PIN, LOW); // Encerrando o envio do pulso

// Procurando por um retorno do pulso
unsigned long tempoDoPulso = pulseIn(ECHO_PIN, HIGH);
// distancia = tempoDoPulso / CONSTANTE_CONVERTER_PARA_CM para converter para cm.
leituras += tempoDoPulso / CONSTANTE_CONVERTER_PARA_CM;

delay(PERIODO_SONAR); // Aguardar um periodo para a próxima iteração
}

return leituras / SONAR_NUM_LEITURAS;
}

void pegarLuminosidades(){
luminosidades[LDR_DIREITA_INDEX] = 0;
luminosidades[LDR_ESQUERDA_INDEX] = 0;
luminosidades[LDR_CABECA_INDEX] = 0;
for (byte leitura = 0; leitura < LDR_NUM_LEITURAS; leitura++) {
luminosidades[LDR_DIREITA_INDEX] += analogRead(LDR_DIREITA_PIN);
luminosidades[LDR_ESQUERDA_INDEX] += analogRead(LDR_ESQUERDA_PIN);
luminosidades[LDR_CABECA_INDEX] += analogRead(LDR_CABECA_PIN);
delay(PERIODO_LDR); // Aguardar um periodo para a próxima iteração
}
luminosidades[LDR_DIREITA_INDEX] = (((luminosidades[LDR_DIREITA_INDEX] / LDR_NUM_LEITURAS) - LDR_DIREITO_LIMITES[0]) * 100) / (LDR_DIREITO_LIMITES[1] - LDR_DIREITO_LIMITES[0]);
luminosidades[LDR_ESQUERDA_INDEX] = (((luminosidades[LDR_ESQUERDA_INDEX] / LDR_NUM_LEITURAS) - LDR_ESQUERDO_LIMITES[0]) * 100) / (LDR_ESQUERDO_LIMITES[1] - LDR_ESQUERDO_LIMITES[0]);
luminosidades[LDR_CABECA_INDEX] = luminosidades[LDR_CABECA_INDEX] / LDR_NUM_LEITURAS;
}

void acelerar(){
velocidadeRodaDireita = velocidadeRodaDireita + 5;
if(velocidadeRodaDireita > RODA_DIREITA_VELOCIDADES[VALOR_MAX_INDICE]){
velocidadeRodaDireita = RODA_DIREITA_VELOCIDADES[VALOR_MAX_INDICE];
}
velocidadeRodaEsquerda = velocidadeRodaEsquerda - 5;
if(velocidadeRodaEsquerda < RODA_ESQUERDA_VELOCIDADES[VALOR_MAX_INDICE]){
velocidadeRodaEsquerda = RODA_ESQUERDA_VELOCIDADES[VALOR_MAX_INDICE];
}
}

void girar(int sentido, unsigned long tempo){
if(sentido < 0){
rodaDireita.write(100);
rodaEsquerda.write(80);
}else if(sentido > 0){
rodaDireita.write(80);
rodaEsquerda.write(100);
}
delay(tempo);
}

void diminuirVelocidadeRodaDireita(){
velocidadeRodaDireita = velocidadeRodaDireita - 10;
if(velocidadeRodaDireita < RODA_DIREITA_VELOCIDADES[VALOR_MIN_INDICE]){
velocidadeRodaDireita = RODA_DIREITA_VELOCIDADES[VALOR_MIN_INDICE];
}
}

void diminuirVelocidadeRodaEsquerda(){
velocidadeRodaEsquerda = velocidadeRodaEsquerda + 10;
if(velocidadeRodaEsquerda > RODA_ESQUERDA_VELOCIDADES[VALOR_MIN_INDICE]){
velocidadeRodaEsquerda = RODA_ESQUERDA_VELOCIDADES[VALOR_MIN_INDICE];
}
}

void tratarDistancia(unsigned long distancia){
Serial.println(distancia);
if(distancia < 8){
acionarMotores(0);
posicionarCabeca(SONAR_ESQUERDA);
unsigned long distEsquerda = lerDistancia();
posicionarCabeca(SONAR_DIREITA);
unsigned long distDireita = lerDistancia();
posicionarCabeca(SONAR_FRENTE);

if(distEsquerda > distDireita){
girar(-1, 1000);
}else{
girar(1, 1000);
}

tratarDistancia(lerDistancia());
}else if(distancia < 60){
acionarMotores(10);

tratarLuminosidade();
}else{
acionarMotores(40);
}
}

void tratarLuminosidade(){
posicionarCabeca(SONAR_FRENTE_ESQUERDA);
delay(1000);
pegarLuminosidades();
unsigned int vEsquerda1 = luminosidades[LDR_CABECA_INDEX];

posicionarCabeca(SONAR_ESQUERDA);
delay(1000);
pegarLuminosidades();
unsigned int vEsquerda2 = luminosidades[LDR_CABECA_INDEX];

posicionarCabeca(SONAR_FRENTE_DIREITA);
delay(1000);
pegarLuminosidades();
unsigned int vDireita1 = luminosidades[LDR_CABECA_INDEX];

posicionarCabeca(SONAR_DIREITA);
delay(1000);
pegarLuminosidades();
unsigned int vDireita2 = luminosidades[LDR_CABECA_INDEX];

posicionarCabeca(SONAR_FRENTE);

if((vEsquerda1 + vEsquerda2) / 2 < (vDireita1 + vDireita1) / 2){ // Ligação inv
Serial.print("rod dir: ");
velocidadeRodaDireita = 130;
}else{
Serial.print("rod esq: ");
velocidadeRodaEsquerda = 60;
}
imprimirVelocidades();
delay(1500);
}

void tratarOpticos(){
int valorDireito = analogRead(OPTICO_REFLEXIVO_DIREITO_PIN);
int valorCentral = analogRead(OPTICO_REFLEXIVO_CENTRAL_PIN);
int valorEsquerdo = analogRead(OPTICO_REFLEXIVO_ESQUERDO_PIN);

if(valorCentral > 0){
acionarMotores(40);
}
if(valorDireito > 0){
velocidadeRodaEsquerda = 60;
imprimirVelocidades();
}
if(valorEsquerdo > 0){
velocidadeRodaDireita = 130;
imprimirVelocidades();
}
delay(1000);
}

void imprimirValoresDaLuminosidade(){
Serial.print("Luminosidades: d: ");
Serial.print(luminosidades[LDR_DIREITA_INDEX]);
Serial.print(", e: ");
Serial.println(luminosidades[LDR_ESQUERDA_INDEX]);
}

void imprimirValoresDasVelocidades(){
Serial.print("vrd: ");
Serial.print(velocidadeRodaDireita);
Serial.print(", pdrd: ");
Serial.print(porcentagemDobraRodaDireita);
Serial.print(", vre: ");
Serial.print(velocidadeRodaEsquerda);
Serial.print(", pdre: ");
Serial.println(porcentagemDobraRodaEsquerda);
}





Atividades recentes

  • Henrique  Braga ForestiDesafio CPBR7 - CajúRover
    Henrique Braga Foresti

    Vocês estão per­dendo pon­tos, as posta­gens devem ser fre­quentes, mostrando o desen­volvi­mento do pro­jeto desde a partida.

    • AJ

      AJ Alves Quinta, 30.01.2014 15:56:

      Opa, mas vamos cor­rer con­tra o pre­juizo, demor­amos para encon­trar as peças, tive que vas­cul­har a Cam­pus, até que achei o Alexan­dre da CoolerMaster.