Ola, boa noite. Estou "desenvolvendo" um robozinho, a partir de um comprado já pronto e com um programa-base agindo em 2 motores DC, 1 servo-motor, 1 ultrassom. Só que ele assim costuma se agarrar lateralmente em paredes, etc. Preciso incluir uma rotina para ler 2 sensores-chaves (micro-swiches) tipo bigode-de-gato, para que o robô saia desse "encosto".
Produzí e tentei várias rotinas (uma já veio com o kit do robô, mas usando apenas uma chave), sem sucesso: Ou funcionam os motores+ultrassom, ou as chaves. Testei colocar a minha rotina em vários pontos do sketch. Atualmente dividi essa rotina para ver se funcionavam os dois sensores (2 chaves e o ultrassom). Não deu certo.
Abaixo cópia do sketch mais atual. Este tem 4 páginas em A4, sem espaços entre linhas. Vou copiar aqui é o sketch mesmo, tirado da IDE, ok?

//--------------- Programa JABUTINO sketch 20140510 -----------
#include 
#include

//Instancia o objeto referente aos motores DC
AF_DCMotor motorEsquerdo(1); //Motor esquerdo na conexão "M1"
AF_DCMotor motorDireito(2); //Motor direito na conexão "M2"

//Definições de velocidade em PWM de 0 a 255
const char VEL_MAX = 255;
const char VEL_MIN = 0;
const char VEL_MED = 200;

//Pinos para controle do Ultrassom HC-SR04
//usar as portas analógicas A0 e A1 como digitais
const int pinoTrigger = 14; // A0 = 14
const int pinoEcho = 15; // A1 = 15

//Servo Motor
Servo meuServo;
const int pinoServo = 10; //o pino 10 é o pino de sinal da conexão "SERVO_2"

//Define as posições de calibragem do servo
//Valores para conseguir um melhor alinhamento do servo, cada motor responde de forma diferente.
//Os valores devem variar de 0 a 180 graus, ajuste de acordo com seu motor na tentativa e erro.

const int OLHA_ESQ = 180;
const int OLHA_DIR = 0;
const int OLHA_FRT = 90;

// Pino em que o BUZZER está conectado: 
const int pinoBuzzer = 9;

// PINOS que vão conectar as 2 CHAVES (sensores de colisão):
const int ChaveE = 18;
const int ChaveD = 19;

//Método obrigatório
//Realiza as definições dos pinos e faz a inicialização da biblioteca de servo.

void setup(void)
{
// Inicializa os motores com velocidade máxima
motorEsquerdo.setSpeed(VEL_MAX);
motorDireito.setSpeed(VEL_MAX);

//atribui os pinos do ultrassom
pinMode(pinoTrigger, OUTPUT);
pinMode(pinoEcho, INPUT);

Serial.begin(9600); /* função provisória, para controle da rotina das chaves.*/
/* define os pinos como entrada ligando um resistor pullup a eles */
pinMode(ChaveE, INPUT_PULLUP); // MUITO IMPORTANTE
pinMode(ChaveD, INPUT_PULLUP);

//inicia o Servo
meuServo.attach(pinoServo);
//Coloca o servo virado para posicao frontal
meuServo.write(OLHA_FRT);

} // fim do setup
//================================================
//Corpo principal do programa, repete infinitamente
void loop()
{
// Inicia andando para frente
   andarpFrente(VEL_MAX);

    // Faz a leitura dos sensores de CHAVES = colisão:
    int lerChaveE = digitalRead(ChaveE);
    int lerChaveD = digitalRead(ChaveD);

        //Enquanto não encontrar um obstáculo a menos de 10cm
          while(medeDistancia() > 10)
          {  delay(100); //Faz uma leitura da distancia a cada 0,1 segundo 
          }

             { // chave Esq:
               if (lerChaveE == HIGH) 
                  { Serial.println("Esquerda");

                    tone(pinoBuzzer, 840); //envia um sinal de 740Hz para o pino 9
                     delay(100); //aguarda 0,1 segundo
                    noTone(pinoBuzzer); //interrompe o som no pino 9
                    girarpDireita(VEL_MED);
                     delay(500); //aguarda 1 segundo
                  }
                else 
                  { // chave Direita:
                    if (lerChaveD == HIGH)
                      { Serial.println("Direita");

                        tone(pinoBuzzer, 840); //envia um sinal de 840Hz para o pino 9
                         delay(100); //aguarda 0,1 segundo
                       noTone(pinoBuzzer); //interrompe o som no pino 9
                      girarpEsquerda(VEL_MED);
                       delay(500); //aguarda 0,5 segundo
                     }
                   } 
          //Se encontrou um obstáculo recua por 1 segundo e pára
             andarpTras(VEL_MED);
             delay(1000);
              pararMotores();

           //Verifica qual lado tem maior distância até um obstáculo
              int esquerda = 0, direita = 0;

              meuServo.write(OLHA_ESQ); //vira o servo para a esquerda
              delay(500); //aguarda o servo completar o movimento
              esquerda = medeDistancia(); //mede a distância na esquerda
                 meuServo.write(OLHA_DIR); //vira o servo para a direita
                 delay(500); //aguarda o servo completar o movimento

              direita = medeDistancia(); //mede a distância na direita
              meuServo.write(OLHA_FRT); //olha pra frente novamente
                 delay(500); //aguarda o servo completar o movimento

              if(esquerda > direita) /*se a distancia do obstáculo na esquerda for maior que na direita
                  vira para esquerda */
                   {
                    girarpEsquerda(VEL_MAX);
                    }
                     else /* se a distância do obstáculo na direita for maior ou igual que na esquerda
                            vira para a direita */
                    {
                      girarpDireita(VEL_MAX);
                     }
                       //Aguarda alguns instantes para o robô virar
                      delay(500); // modifique esse tempo se desejar que ele vire por mais ou menos tempo              // Fim da rotina de obstáculos

             // Inicio da rotina das CHAVES / colisão: // ==> tirado daqui e dividido, para tentar o funcionamento.

              // aguarda minimamente para eliminar ruidos:

                 delay(5);
                    int lerChaveE = LOW; // Garante que a chave Esq estará em LOW.
                     int lerChaveD = LOW; // Garante que a chave Dir estará em LOW.
                 }
             // final da rotina das CHAVES

} // Fim do LOOP

//Utiliza o sensor de Ultrassom HC-SR04 para medir a distância em centímetros
int medeDistancia()
{
//Garante que o pino de Trigger está LOW
digitalWrite(pinoTrigger, LOW);
delayMicroseconds(2);
//cria um pulso de 5 microssegundos no Trigger
digitalWrite(pinoTrigger, HIGH);
delayMicroseconds(5);
digitalWrite(pinoTrigger, LOW);

//aguarda o echo
long microssegundos = pulseIn(pinoEcho, HIGH);
// A velocidade do som é 340 m/s ou aproximadamente 29 microssegundos por centimetro.
// O pulso faz uma viagem de ida e volta do sensor até o obstáculo
// assim, para calcular a distancia temos que dividir esse tempo pela metade
// desta forma...
return int(microssegundos / 29 / 2);
} // Fim do CalcularDistancia

// ======== void's dos motores: =============

//Gira as duas rodas para frente
//Como os motores estão virados para lados opostos eles devem
//girar em sentidos opostos para que as rodas girem na mesma direção

void andarpFrente(char velocidade)
{
motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(FORWARD);
motorDireito.run(BACKWARD);
}

//Gira as duas rodas para trás
//Como os motores estão virados para lados opostos eles devem
//girar em sentidos opostos para que as rodas girem na mesma direção
void andarpTras(char velocidade)
{
motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(BACKWARD);
motorDireito.run(FORWARD);
}

//Gira as duas rodas em sentido inverso, girando no próprio eixo
void girarpEsquerda (char velocidade)
{
motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(BACKWARD);
motorDireito.run(BACKWARD);
}

//Gira as duas rodas em sentido inverso, girando no próprio eixo
void girarpDireita(char velocidade)
{
motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(FORWARD);
motorDireito.run(FORWARD);
}

//Pára os motores definindo os dois pinos Enable em estado Low
void pararMotores()
{
motorEsquerdo.run(RELEASE);
motorDireito.run(RELEASE);
}

Exibições: 3315

Anexos

Responder esta

Respostas a este tópico

Gozado isso Maurílio,

Se a atuação de um micro-switch é indicada na Serial e o som funciona, a próxima instrução seria virar para um lado por 0,5 segundo!.

Como você diz que os motores param, para isso seria necessário sair do "while" para então encontrar uma instrução pararMotores, só que antes dessa deveria andar para trás pela instrução andarpTras(VEL_MED)o que também não acontece!!!!.

Eu até dei uma procurada aqui, pois agora que percebí que os micros estão ligados em pinos analógicos com pull up, mas aparentemente isso é totalmente possível nos ATMega e com as indicações funcionando confirma isso.

Putz, como o fluxo estaria saindo do "while" ? Estaria realmente saindo ? Mesmo que estivesse saindo pela atuação bem próxima do ultrasom, porque a marcha a ré não funciona ???

Hummmm ...

Se o ultrasom for atuado (< 10 cm) antes que qualquer micro o seja, a lógica restante está funcionando ?

Sinceramente não estou enxergando um motivo para não funcionar.

Por acaso você não tem outra ligação elétrica nos micros além dos pinos 18 e 19 ?

Bom, os pinos 18 e 19 foram escolhidos por mim. Mas posso colocar em 16 e 17, já que o 13 e o 14 estão ocupados com o ultrassom - mas nada impede de inverter, né? Colocar as chaves no 14 e 15, ultrassom no 18 e 19, ou mesmo ali vizinho os 16 e 17. O que achas? Se de tudo ficar muito difícil, posso usar o Mega no lugar do Uno, né? Ficaria até melhor, mais completo - mesmo pq ainda faltam o LDR, os 2 LEDs brancos (faróis ou setas) e os LEDs verde e vermelho- no Uno não dá!-. Mas aí os pinos têm que mudar alguma coisa, né?

Fiz a inversão das chaves/ pinos, corrigi o sketch, mas não deu resultado nenhum.

Toda a parte do ultrassom funciona, até que se pressiona a chave.

Anexo, os 3 arquivos da biblioteca AF_DCMotor.

Ah, havia dito que a biblioteca era do fabricante do robozinho, mas não é não. É da Adafruit Motor shield library

Anexos

Maurílio,

Não acho que os pinos 18 e 19 (A4 e A5) sejam o problema porque você relata que ocorre a indicação na serial e há tone quando um dos micros é acionado.

Considerando que você está rodando um sketch como o que discutimos antes:

//Corpo principal do programa, repete infinitamente

void loop()
{
while(medeDistancia() > 10)
{
//Enquanto não encontrar um obstáculo a menos de 10cm
andarpFrente(VEL_MAX);

if (digitalRead(ChaveE) == HIGH)
{
Serial.println("Esquerda");
tone(pinoBuzzer, 840); //envia um sinal de 740Hz para o pino 9
delay(100); //aguarda 0,1 segundo
noTone(pinoBuzzer); //interrompe o som no pino 9
girarpDireita(VEL_MED);
delay(500); //aguarda 0,5 segundo
}
else if (digitalRead(ChaveD) == HIGH) //lê Chave Direita
{
Serial.println("Direita");
tone(pinoBuzzer, 840); //envia um sinal de 840Hz para o pino 9
delay(100); //aguarda 0,1 segundo
noTone(pinoBuzzer); //interrompe o som no pino 9
girarpEsquerda(VEL_MED);
delay(500); //aguarda 0,5 segundo
}
delay(100); //Faz uma leitura da distancia a cada 0,1 segundo
}

//Se encontrou um obstáculo recua por 1 segundo e pára
andarpTras(VEL_MED);
delay(1000);
pararMotores();
... (continua)

=> Não tem nada demais, é apenas para confirmar aquela questão de ter ficado dois "while" e a leitura dos micros ficarem diretas, sem variáveis.

Dessa forma, como você relata, os motores param e nada mais os reacionam, certo!.

Bem, aparentemente está havendo algum problema nos comandos virar à esquerda e/ou virar à direita que estão dentro dos "if´s" de verificação dos micros, logo após a indicação da serial e o tone!!. Não vejo outra possibilidade.

Tente rodar um sketch simples, para verificação do acionamento dos motores (se é que já não fez isso, claro), sem desligar nada do que está ligado atualmente, algo como

loop()

{

      andarpFrente(VEL_MAX);

      delay(1000);

      girarpDireita(VEL_MAX);

      delay(500);

      andarpFrente(VEL_MAX);

      delay(1000);

      girarpEsquerda(VEL_MAX);

      delay(500);

      andarpFrente(VEL_MAX)

      delay(500);

      pararMotores();

      delay(10000);

}

Isso seria para verificar o acionamento dos motores / driver. Se não houver "comutação" entre retas e rotações há alguma errada na parte elétrica. Se as "comutações" derem certo, então teremos que apelar para os universitários !!!.

Wilmar

Já tinha feito, rs... mais de uma vez, até, em versões diferentes de testes. Como dito antes, tudo funciona, menos as funções de motor exceto da de parar, em definitivo, mas detectando distâncias e as chaves, buzzer_nando e indicando qual a chave pressionada.

Pois é... socorros universitários.

Não houve erro nenhum. Motores obedeceram direitinho os comandos.

Só que houve uma falha de escrita na última linha de "andarpFrente", acusada pela IDE, rs... devidamente corrigida, rs...

A quem vamos recorrer agora? Só você está me ajudando, dentre os vários locais/ sites/ grupos, foruns que pedi ajuda. Se negam pq não querem "dar de presente" a coisa. É... mas acho que vou usar de artifício, lá no Arduino Brasil (Facebook). Vou lançar de novo, cópia daqui (sem o seu texto, claro) como desafio. Será que cola?

Maurílio,

Bem, se os motores operam corretamente fazendo as curvas, então parece que realmente o problema possa estar no software, mas não enxergo onde.

Acredito que a pouca ajuda seja devido à necessidade de analisar o seu código para emitir alguma opinião. Como eu gosto e também estou construindo um robô fica mais fácil e rápido entender o que cada parte deve fazer.

Eu vou montar um protótipo do seu robô, simulando essa lógica do ultrasom x micros e até amanhã te respondo se achei algum problema com ela.

Wilmar

Estava a ponto de lhe dar ciência: Tirei os println, o buzzer (só com as "//"). Aí  ele não para mais qdo pressiona as chaves. Reduzi o tempo de espera para ele se desviar, mas vou tentar voltar aos 500 novamente, até onde der. Pus só 100, só para teste, rs. Mas ainda está meio esquisito. Estou remontando o servo, um pouco mais alto, usando um distanciador, e vou tentar de novo. Os parafusos e o distanciadores estão me faltando, rs... um mundo de coisas que tenho em estoque e me falta o que preciso, rs... Ontem fui dormir já eram 2 h de hoje, rs... Preciso fazer isso antes de dar o ar das graças pq o robô ainda está operando estrando, escolhendo o lado errado para seguir. Devido ao espaço em que o coloquei, tive de por o ultrassom de ponta-cabeça. Teoricamente não havia diferença, j´q que o servo continua na posição normal. Reduzi o ângulo de manobra do servo: em vez de 0-90-180, passei para 20-90-160 graus. A caixinha de acrílico anda se quebrado nos pontos mais finos (menos corpo no comprimento (rasgos maiores)).

Maurílio,

Eu entendí que com a "retirada" dos print´s e tone´s da parte de tratamento dos microswitches o problema do robô parar e não andar mais depois de um micro pressionado foi resolvido.

É isso mesmo ?

Se for isso, aparentemente o problema estaria com o uso da Serial ?!? , p. ex. se você tiver alguma coisa conectada nos pinos D0 e/ou D1. Haveria conflito da Serial justamente no momento em que um micro é pressionada, pois haveria execução da instrução print (que é a primeira na lógica do programa)!.

Wilmar

Consegui!

Acedrtei o arame de proteção (para não agarrar fisicamente sem solução), deixando só 3/4 da lingua das chaves para fora, a fim de escorregar e acionar as chaves.

O engraçado é que tive de inverter a direção do desvio, mandando virar para o mesmo lado da chave acionada.

O Sketch ficou assim:

//--------------- Programa JABUTINO sketch 201405129 -----------
#include <Servo.h>
#include <AFMotor.h>

//Instancia o objeto referente aos motores DC
AF_DCMotor motorEsquerdo(1); //Motor esquerdo na conexão "M1"
AF_DCMotor motorDireito(2); //Motor direito na conexão "M2"

//Definições de velocidade em PWM de 0 a 255
const char VEL_MAX = 255;
const char VEL_MIN = 0;
const char VEL_MED = 150;

//Pinos para controle do Ultrassom HC-SR04
//usar as portas analógicas A0 e A1 como digitais
const int pinoTrigger = 18; // A0 = 14
const int pinoEcho = 19; // A1 = 15

//Servo Motor
Servo meuServo;
const int pinoServo = 10; //o pino 10 é o pino de sinal da conexão "SERVO_2"

//Define as posições de calibragem do servo
//Valores para conseguir um melhor alinhamento do servo, cada motor responde de forma diferente.
//Os valores devem variar de 0 a 180 graus, ajuste de acordo com seu motor na tentativa e erro.

const int OLHA_ESQ = 180;
const int OLHA_DIR = 10;
const int OLHA_FRT = 85;

const int pinoBuzzer = 9;

const int pinoChaveEsq = 14;
const int pinoChaveDir = 15;

/*Método obrigatório: Define tipos dos pinos e inicializa a biblioteca de servo.*/

void setup(void)
{
// Inicializa os motores com velocidade máxima
motorEsquerdo.setSpeed(VEL_MAX);
motorDireito.setSpeed(VEL_MAX);

//atribui os pinos do ultrassom
pinMode(pinoTrigger, OUTPUT);
pinMode(pinoEcho, INPUT);

Serial.begin(9600); /* função provisória, para controle da rotina das chaves.*/
/* define os pinos como entrada ligando um resistor pullup a eles */
pinMode(pinoChaveEsq, INPUT_PULLUP); // MUITO IMPORTANTE
pinMode(pinoChaveDir, INPUT_PULLUP);

//inicia o Servo
meuServo.attach(pinoServo);
//Coloca o servo virado para posicao frontal:
meuServo.write(OLHA_FRT);
} // fim do setup
//================================================
//Corpo principal do programa, repete infinitamente
void loop()
{
// Inicia andando para frente
andarpFrente(VEL_MAX);

//Enquanto não encontrar um obstáculo a menos de 10cm:
while (medeDistancia()>10)
{ // Lê a Chave Esquerda:
if (digitalRead(pinoChaveEsq) == HIGH)
{ // Serial.println("Esquerda");
//tone(pinoBuzzer, 740); //envia 740Hz para o pino 9
//delay(100); //aguarda 0,1 segundo
//noTone(pinoBuzzer); //interrompe o som.
girarpEsquerda(VEL_MED);
delay(800); //aguarda 0,5 segundo
andarpFrente(VEL_MAX);
}
else
// Lê chave Direita:
if (digitalRead(pinoChaveDir)== HIGH)
{ //Serial.println("Direita");
//tone(pinoBuzzer, 840); //envia 840Hz para o pino 9
//delay(100); //aguarda 0,1 segundo
//noTone(pinoBuzzer); //interrompe o som.
girarpDireita(VEL_MED);
delay(800); //aguarda 0,5 segundo p/ virar
andarpFrente(VEL_MAX);
}
else
delay(100); //Faz uma leitura da distância a cada 0,1 segundo
}
// aguarda minimamente para eliminar ruidos das chaves:
delay(5);

//Se encontrou um obstáculo recua por 1 segundo e pára:
andarpTras(VEL_MED);
delay(1000);
pararMotores();

//Verifica qual lado tem maior distância até um obstáculo:
int esquerda = 0, direita = 0;

meuServo.write(OLHA_ESQ); //vira o servo para a esquerda
delay(500); //aguarda o servo completar o movimento

esquerda = medeDistancia(); //mede a distância na esquerda
meuServo.write(OLHA_DIR); //vira o servo para a direita
delay(500); //aguarda o servo completar o movimento

direita = medeDistancia(); //mede a distância na direita
meuServo.write(OLHA_FRT); //olha pra frente novamente
delay(500); //aguarda o servo completar o movimento

if(esquerda > direita) /*se a distancia do obstáculo na esquerda for maior que na direita
vira para esquerda */
{
girarpEsquerda(VEL_MAX);
}
else /* se a distância do obstáculo na direita for maior ou igual que na esquerda
vira para a direita */
{
girarpDireita(VEL_MAX);
}
//Aguarda alguns instantes para o robô virar
delay(500); // modifique esse tempo se desejar que ele vire por mais ou menos tempo

// Fim da rotina de obstáculos
} // Fim do LOOP

//Utiliza o sensor de Ultrassom HC-SR04 para medir a distância em centímetros
int medeDistancia()
{
digitalWrite(pinoTrigger, LOW); //Garante que o pino de Trigger está LOW.
delayMicroseconds(2);
//cria um pulso de 5 microssegundos no Trigger:
digitalWrite(pinoTrigger, HIGH);
delayMicroseconds(5);
digitalWrite(pinoTrigger, LOW);

//aguarda o echo:
long microssegundos = pulseIn(pinoEcho, HIGH);
/* A velocidade do som é 340 m/s ou aproximadamente 29 microssegundos por centimetro.
O pulso faz uma viagem de ida e volta do sensor até o obstáculo.
assim, para calcular a distância temos que dividir esse tempo pela metade.
Então...*/
return int(microssegundos/29/2);
} // Fim do medeDistancia

// ======== void's dos motores: =============

/*Gira as duas rodas para frente. Como os motores estão virados para lados opostos eles devem
girar em sentidos opostos para que as rodas girem na mesma direção.*/
void andarpFrente(char velocidade)
{ motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(FORWARD);
motorDireito.run(BACKWARD);
}

/*Gira as duas rodas para trás. Como os motores estão virados para lados opostos eles devem
girar em sentidos opostos para que as rodas girem na mesma direção.*/
void andarpTras(char velocidade)
{ motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(BACKWARD);
motorDireito.run(FORWARD);
}

//Gira as duas rodas em sentido inverso, girando no próprio eixo.
void girarpEsquerda (char velocidade)
{ motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(BACKWARD);
motorDireito.run(BACKWARD);
}

//Gira as duas rodas em sentido inverso, girando no próprio eixo.
void girarpDireita(char velocidade)
{ motorEsquerdo.setSpeed(velocidade);
motorDireito.setSpeed(velocidade);
motorEsquerdo.run(FORWARD);
motorDireito.run(FORWARD);
}

//Pára os motores definindo os dois pinos Enable em estado LOW.
void pararMotores()
{ motorEsquerdo.run(RELEASE);
motorDireito.run(RELEASE);
}

Maurílio,

Fiz um rascunho da resposta dos testes que fiz aqui e quando fui postar ví que você já fez alguns progressos. O texto abaixo não considera isso.

Eu ontem montei um circuito simulando o seu robô, para testar a lógica do programa.

Utilizei um UNO, um ultrasom HC-SR04, um servo pequeno, dois microswitches e como não tenho um driver como o seu, utilizei dois led´s de um shield + um buzzer (independente do seu) para feedback das ações andar para frente, ré, rotacionar e parar, além da atuação dos micros.

Eu utilizei a mesma definição de pinos do seu sketch, inclusive os dos motores (que
ficaram sem uso aqui), mas com a biblioteca e a lógica deles operando normalmente.

Para os Leds e o buzzer que incluí, utilizei as portas A2 e A3 sem uso no seu sketch e a D2 sem uso no shield dos motores.

No software eu utilizei a versão com aquelas alterações que propus (mantendo toda a
lógica), exceto pelos pinos dos led´s e buzzer acrescentados e alterei as rotinas dos
motores, adicionando comandos para os led´s / buzzer, além de alguns outros print´s.
Absolutamente nenhuma linha do seu sketch foi eliminada.

Depois de uns ajustes, tudo funcionou conforme previsto na lógica!.
É efetuado as rotações quando um dos micros é pressionado e quando o ultrasom fica <= 10 cm ele dá ré, para, mede as distâncias nas laterais, decide para onde rotacionar, rotaciona e, em ambos os casos, volta a andar de frente!

Hummmm...

Bem, não é problema de lógica.

Agora estava analisando o que poderia estar causando o problema no seu robô, mas
sinceramente não consigo enxergar nada.

Bem, vou ler o seu novo relato, mas fiquei pensando bastante nesse shield dos motores, porque é a única coisa não conectada aqui!.

Wilmar

Praticamente a lógica do sketch não foi alterada né Maurílio.

A questão de ter que inverter o lado de rotação deve ser os micros com seus respectivos lados esquerdo e direito ligados em pinos trocados na lógica do programa. Isso é comum, porque a gente fica meio confuso com muito fio pra lá e pra cá, hehe.

Ué... conferi aqui as ligações das micro-chaves e está ok (parece, rs): A esquerda no pino 14 e Direita no pino 15. Mas os pinos das chaves (conexão, aquele que vem das chaves, estavam invertidas as cores.

 Me passa seu sketch aí, que eu vou comparar e ver se consigo melhorar cá. Pode ser? 

RSS

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço