Go Down

Topic: Lectura de sonar HC-SR04 (Read 1 time) previous topic - next topic

surbyte

Quote
Tu crees que haciendo Abat y Abi mas veloces la medicion del sonar ya no sera nula?
No claro que no.
Una cosa no tiene que ver con la otra.
Yo me alarmo por el código en general, no por la rutina del ultrasónico.

A ver si podemos trabajar de un modo sistemático, de lo contrario desde acá se hace dificil aconsejarte al menos para mi.

En procedimiento o rutina void JATORRItikAP() tienes este llamado al sonar.

 
Code: [Select]
distancia = SONAR(angelua);
  Serial.print("Neurtuta: ");
  Serial.print(distancia);


Funciona?

Establece por favor en cada caso si lo hace o no.

Como has tomado códigos de uno y otro lado, pixy descartemos porque sabemos que esta bien pero el otro código en lo personal me resulta complicado de seguir.

Entonces empecemos de nuevo si me permites la sugerencia porque con este código yo no voy a aconsejarte porque desde el comienzo al no poder entender o tener que traducir cada línea (tarea que te corresponde a ti si es que lo entiendes) prefiero comenzar por otro lado.

Tenemos un ROVER que tiene una camara pixy que detecta objetos, un sonar que le dirá cuando deterse luego que un objeto es identificado.
Y claro el movimiento adelante, atras, izquierda, derecha y stop.
Esto ultimo esta hecho muchas veces y como ahi es donde veo estan los problemas es que prefiero rehacer las cosas con ALGO entendible.

Espero tu comentario.

Si estas de acuerdo, te propongo que hagas un detalle aunque se lee en el código de como son las conexiones a tus drivers. Solo para que el novato que lea esto lo entienda mejor.
Y de paso lo explicas un poco.


liskarra0

La llamada al sonar esta bien, entra en su subrutina.  El problema es que da lectura 0. En el momento de realizar duracion=pulseIn ese resultado es 0. La variable duración da 0. Pero las llamadas y todos los demas movimientos que reaiza con los motores funcionan bien.

El único problema es que al conectar la camara Pixy2 la lectura obtenida desde el pulseIn es 0. Y por eso luego al compararlo con la distancia mínima se para. Porque cree que hay un objeto.

He estado indagando por internet y creo que se podria probar a crear una funcion que haga lo mismo que pulseIn mediante digitalWrite y micro().  Como lo ves? Podria llegar a funcionar?

surbyte

Perdona por mi respuesta pero parece que no lees lo que he escrito antes.

Quote
O sea es algo poco preciso.
Usas micros() y tendras mejor precisión ni hablar con Timers.
Tanto ELEspanol como yo te dijismos como hacerlo.
Ahora. Solo estas reinventando la rueda. Existen librerías para manejar el sensor que obviamente desconoces.

NewPing es la librería mas usada pero hay otras.

liskarra0

Obviamente leo lo que escribís. ElEspañol me hizo pensar en que el problema esta ahi. Pero solo preguntaba que si se podia sustituirlo por un digitalwrite.

Por otro lado, si que conocia newping pero preferí hacerlo sin librerías. Es mas preciso hacerlo con la NewPing y crees que asi funcionaria?

surbyte

#19
Dec 11, 2019, 09:30 pm Last Edit: Dec 11, 2019, 09:37 pm by surbyte
Porque no te autorespondes probando con NewPing y vemos que resulta?

Porqué en la rutina del sonar mueves el servo?

Code: [Select]
long SONAR( int angelua) // Subrutina del sonar
{

   servoMotor.attach(10);         // <== Porque lo defines a cada momento?
   long duracion, distancia ;
   
   servoMotor.write(angelua);   // <== esto no debería estar acá y lo anterior menos
   delay(50);
   digitalWrite(52,HIGH);
   digitalWrite(trigPin, LOW);        // Nos aseguramos de que el trigger está desactivado
   delayMicroseconds(2);              // Para asegurarnos de que el trigger esta LOW
   digitalWrite(trigPin, HIGH);       // Activamos el pulso de salida
   delayMicroseconds(10);             // Esperamos 10µs. El pulso sigue active este tiempo
   digitalWrite(trigPin, LOW);        // Cortamos el pulso y a esperar el echo
   duracion = pulseIn(echoPin, HIGH) ;
   distancia = duracion / 2 / 29.1  ;
   //Serial.println(String(distancia) + " cm.") ;

   return distancia;
}



Observa los comentarios que hago para el servo.

ElEspanol

#20
Dec 11, 2019, 10:08 pm Last Edit: Dec 11, 2019, 10:09 pm by ElEspanol
Yo también uso newping.h, que yo sepa no bloquea o al menos tiene un timeout muy corto, porque puedes indicar una distancia máxima.

liskarra0

Vale, mañana probare a usar el NewPing. No lo he hecho antes porque hasta mañana no tengo acceso al material.  Por eso preguntaba...

Lo del servo lo hago cada vez que entra para que vaya al angulo deseado que se quiere analizar la distancia. Cierto es que la definición no deberia estar ahi y que lo otro se puede poner en otro sitio.

surbyte

#22
Dec 11, 2019, 10:15 pm Last Edit: Dec 11, 2019, 10:19 pm by surbyte
Ya lo tengo casi hecho. Un momento y te lo paso.

Pregunta:

Code: [Select]
AF_DCMotor traseraDerecha(    1,MOTOR12_64KHZ); // Rueda trasera derecha

Significa que esta conectado al pin 1? Si es asi busca otro pin porque el 1 esta afectado al monitor Serie y por eso tal vez falle el código.

Como creo que ese era el problema te dejo el código hasta donde llegué. Espero funcione.
Debes instalar NewPing desde el Gestor de librerías.

Code: [Select]
#include <AFMotor.h>
#include <Servo.h>
#include <Pixy2.h>
#include <NewPing.h>   // https://bitbucket.org/teckel12/arduino-new-ping/downloads/

#define led          46
#define TRIGGER_PIN  50  // Arduino pin tied to trigger pin on the ultrasonic sensor.
#define ECHO_PIN     48  // Arduino pin tied to echo pin on the ultrasonic sensor.
#define MAX_DISTANCE 200 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance.
   
// PI-ren ezarpena
#define PI 3.141592
     
int encoderPos=0;
AF_DCMotor delanteraIzquierda(4,MOTOR34_64KHZ); // Rueda delantera izquierda
AF_DCMotor delanteraDerecha(  3,MOTOR34_64KHZ); // Rueda delantera derecha
AF_DCMotor traseraDerecha(    1,MOTOR12_64KHZ); // Rueda trasera derecha
AF_DCMotor traseraIzquierda(  2,MOTOR12_64KHZ); // Rueda trasera izquierda
Servo servoMotor;
Pixy2 pixy;

void setup() {
  Serial.begin(9600);

  pinMode(led, OUTPUT);
  pinMode(52,OUTPUT);
  attachInterrupt(2, interrupcion, FALLING);
  pixy.init();                    // Inicializacion de la camara Pixy2
  servoMotor.attach(10);          // aca defino al servo.
}

void loop() {
  Serial.println("ITXAROTEN");
  pixy.ccc.getBlocks();     //Lee los datos de la cámara
 
  if (pixy.ccc.numBlocks) { // Averigua si se ha detectado algo
      while(pixy.ccc.blocks[0].m_signature) {
          case 1: Abat();  // Ir a un lugar
                  break;
          case 2: Abi();   Ir a dos lugares
                  break;
          case 3: digitalWrite(30,HIGH);
                  break;
      }
  }
}

void interrupcion() {
  encoderPos++;
}

void JATORRItikAP() {
 
  int angulo;     // angulo del servo
  int aldaketa;   // variable para cambiar el angulo
  double minimoa; // distancia mínima para colision

  // establecer velocidades
  fijoVelocidades(100);

  long distancia;
  distancia=0;
  encoderPos=0;
  angulo=90;
  aldaketa=-5;
  delay(1000);
 
  do   {
      //moverse
      muevoRuedas(FORWARD);
      // Serial.println(encoderPos);
      distancia = SONAR(angulo);
      Serial.print("Medido: ");
      Serial.print(distancia);
      minimoa = distanciaMinimaColision(angulo);
      Serial.print(" DMIN: ");
      Serial.println(minimoa);

      if (distancia < minimoa) {
          muevoRuedas(RELEASE);
          do {
              distancia = SONAR(angulo);
              Serial.print("RIESGO!");
              Serial.print(" DMIN: ");
              Serial.print(minimoa);
              Serial.print(" VERDADERO: ");
              Serial.println(distancia);
          } while(distancia<minimoa);
          muevoRuedas(FORWARD); // hacia adelante
      }
      angulo = angulo + aldaketa;       // actualizar variable del angulo
       
      if (angulo == 155) {
         aldaketa = -5;
         angulo = 145;
      }
      if(angulo == 40) {
         aldaketa = 5;
         angulo = 40;
      }
  } while(encoderPos <= 405);

  //Parar
  muevoRuedas(RELEASE);
}

void OpticaA1() {
  int angulo;
  int aldaketa;
  long distancia;
  double minimoa;
  minimoa =0;
  distancia=0;
  angulo=90;
  aldaketa=-5;
  encoderPos=0;
  // Establecer las velocidades
  fijoVelocidades(100);
  delay(1000);
  do
  {
  //Mugitzen hasi
  muevoRuedas(FORWARD);

  distancia = SONAR(angulo);
  minimoa = distanciaMinimaColision(angulo);

  if (distancia<minimoa) {
      muevoRuedas(RELEASE);
      do {
          distancia = SONAR(angulo);
      } while(distancia<minimoa);
      muevoRuedas(FORWARD);
   }
   angulo=angulo+aldaketa;
  } while(encoderPos<=405);

  //Detener
  muevoRuedas(RELEASE);
}

void OpticaA2() {
  int angulo;
  int aldaketa;
  long distancia;
  double minimoa;
  minimoa   = 0;
  distancia = 0;
  angulo    = 90;
  aldaketa  = -5;
  encoderPos = 0;
  // Establecer las velocidades
  fijoVelocidades(100);
  delay(1000);
  do   {
        //Mugitzen hasi
        muevoRuedas(FORWARD);
        distancia = SONAR(angulo);
        minimoa =distanciaMinimaColision(angulo);

        if(distancia<minimoa)
         {
           muevoRuedas(RELEASE);
           do
           {
            distancia = SONAR(angulo);
           }while(distancia<minimoa);
           muevoRuedas(FORWARD);
         }
         angulo=angulo+aldaketa;
  } while(encoderPos<=560);

  //Detener
  muevoRuedas(RELEASE);
}

void Abat() {
  JATORRItikAP();
  Girando();
  OpticaA1();
  delay(5000);
  ContraGirando();
  OpticaA1();
  Girando2();
  JATORRItikAP();
  ContraGirando();
}

void Abi() {
  JATORRItikAP();
}

void ContraGirando() { // Para girar 360° el Rover

  //Establecer las velocidades
  fijoVelocidades(120);
  encoderPos=0;
  delay(1000);
  do {
      // Empieza a moverte
      traseraIzquierda.run(FORWARD);
      delanteraIzquierda.run(FORWARD);
      traseraDerecha.run(BACKWARD);
      delanteraDerecha.run(BACKWARD);
      Serial.print(encoderPos);
  } while(encoderPos<=135);

  // Detener
  muevoRuedas(RELEASE);
}

void Girando2() { // Para girar 90 grados el. Rover
  // Establecer las velocidades
  fijoVelocidades(120);
  encoderPos=0;
  delay(1000);
  do {
      //Mugitzen hasi
      traseraIzquierda.run(FORWARD);
      delanteraIzquierda.run(FORWARD);
      traseraDerecha.run(BACKWARD);
      delanteraDerecha.run(BACKWARD);
      Serial.print(encoderPos);
  }while(encoderPos<=60);

  // Detener
  muevoRuedas(RELEASE);
}

void Girando() { // Para girar 90°. Rover

  //Establecer las velocidades
  fijoVelocidades(120);
  encoderPos=0;
  delay(1000);
  do {
      // Empieza a moverte
      traseraIzquierda.run(BACKWARD);
      delanteraIzquierda.run(BACKWARD);
      traseraDerecha.run(FORWARD);
      delanteraDerecha.run(FORWARD);
      Serial.print(encoderPos);
  }while(encoderPos<=60);

  // Detener
  muevoRuedas(RELEASE);
}


long SONAR( int angulo) // Subrutina del sonar
{
  long tmp;

  unsigned int uS = sonar.ping();     // Send ping, get ping time in microseconds (uS).
 
  //Serial.print(uS / US_ROUNDTRIP_CM); // Convert ping time to distance in cm and print result (0 = outside set distance range)
  tmp = uS / US_ROUNDTRIP_CM;
  return tmp
}

void muevoRuedas(byte tmp) {
  traseraIzquierda.run(tmp); // Hacia delante
  traseraDerecha.run(tmp);
  delanteraDerecha.run(tmp);
  delanteraIzquierda.run(tmp);
}

void fijoVelocidades(int tmp) {
  traseraIzquierda.setSpeed(tmp);
  traseraDerecha.setSpeed(tmp);
  delanteraIzquierda.setSpeed(tmp);
  delanteraDerecha.setSpeed(tmp);
}

float distanciaMinimaColision(int angulo) {       // subrutina para calcular distancia minima de colision

  float radianetan;
  float minimo;

  radianetan=0;
  minimo=0;

  if (angulo < 90)  {
      radianetan = angulo*(2*PI/360); // angulos a radianes
      minimo=(7.5/cos(radianetan))+0.5; // Distancia minima kalkuloa + 0.5 margen de seguridad
  }
  if (angulo > 90) {
      radianetan = angulo*(2*PI/360);
      minimo=(-7.5/cos(radianetan))+0.5;
  }
  if (angulo == 90) {
      minimo=25; // 90º cos()-a error,
  }

  // limitar la distancia mínima
  if (minimo>25) {
      minimo=25;
  }

  return minimo;
}

ElEspanol

Posicionar el servo antes de medir distancia esta mal hecho.

Primero el delay(50) a lo mejor no es suficiente para llegar a la posición correcta. Y el delay por si esta mal. Nunca uses delay, solo existen pocas excepciones. Tu caso es ninguna de ellas.

Hay una librería que se llama mobatools.h, esta muchísimo mejor que la original servos.h
En esta puedes enterarte si el servo aún se mueve. Y hacer la medición de distancia cuando ya no se mueve el servo.

liskarra0

Code: [Select]
AF_DCMotor traseraDerecha(    1,MOTOR12_64KHZ); // Rueda trasera derecha

Significa que esta conectado al pin 1? Si es asi busca otro pin porque el 1 esta afectado al monitor Serie y por eso tal vez falle el código.

Ese 1 significa que ese motor esta conectado a uno de los 4 conexiones que tiene el adafruit motorshield. Por eso cada rueda tiene un número del 1 al 4

liskarra0

Posicionar el servo antes de medir distancia esta mal hecho.

Primero el delay(50) a lo mejor no es suficiente para llegar a la posición correcta. Y el delay por si esta mal. Nunca uses delay, solo existen pocas excepciones. Tu caso es ninguna de ellas.

Hay una librería que se llama mobatools.h, esta muchísimo mejor que la original servos.h
En esta puedes enterarte si el servo aún se mueve. Y hacer la medición de distancia cuando ya no se mueve el servo.
Okey, gracias. Intentare probar esto que me dices. Me parece un punto muy importante a tener en cuenta.

surbyte

Igualmente no tiene nada que ver el uso de Servos con que tu ultrasonico no reporte la lectura.

liskarra0

#27
Dec 12, 2019, 05:58 pm Last Edit: Dec 12, 2019, 06:04 pm by Liskarra0
Buenas,

He probado a usar la libreria NewPing para la lectura del sonar, y al igual que pasaba antes, sin camara todo va genial, pero con ella la lectura del sonar es 0.

He depurado el codigo como me lo habeis recomendado. A ver si asi podeis ayudarme a saber que pasa.

Code: [Select]


#include <NewPing.h>
#include <AFMotor.h>
#include <Servo.h>
#include <Pixy2.h>


// SONARRAREN PINAK
     #define trigPin 50 // Arduino pin tied to trigger pin on the ultrasonic sensor.     
     #define echoPin 48    // Arduino pin tied to echo pin on the ultrasonic sensor.
     #define led 46
   
// PI-ren ezarpena
     #define PI 3.1415926535897932384626433832795
     
int encoderPos=0;
AF_DCMotor aurezk(4,MOTOR34_64KHZ); // Aurreko ezkerreko gurpila
AF_DCMotor auresk(3,MOTOR34_64KHZ); // Aurreko eskumako gurpila
AF_DCMotor atzesk(1,MOTOR12_64KHZ); // Atzeko ezkerreko gurpila
AF_DCMotor atzezk(2,MOTOR12_64KHZ); // Atzeko eskumako gurpila
Servo servoMotor;
NewPing sonar(trigPin,echoPin,500);
Pixy2 pixy; // Pixy objetuaren deklarazioa



void setup()
{
           Serial.begin(9600); // Open serial monitor at 115200 baud to see ping results.
           pinMode(trigPin, OUTPUT);
           pinMode(echoPin, INPUT);
           pinMode(led, OUTPUT);
           pinMode(52,OUTPUT);
           digitalWrite(52,HIGH);
           attachInterrupt(2, interrupcion, FALLING);
           servoMotor.attach(10);     
           pixy.init(); // Kamera hasierarazi 
}

void loop()
{
  Serial.println("ITXAROTEN");
  pixy.ccc.getBlocks(); //Leer datos de la cámara
  if(pixy.ccc.numBlocks) // Chequear si detecta algún objeto
  {
     
    if(pixy.ccc.blocks[0].m_signature==1)
    {
      Abat(); // Ir a A1
    }
    else if(pixy.ccc.blocks[0].m_signature==2)
    {
      Abi();   // Ir a A2
    }
    else if(pixy.ccc.blocks[0].m_signature==3)
    {
      digitalWrite(30,HIGH);
    }
   
  }
}


 void interrupcion() // Interrupcion del encoder para saber cuanta distancia anda
 {
  encoderPos++;
 }


void JATORRItikAP() // Subrutina para ir a A'
{
 
int angelua; // angulo
int aldaketa; // cambio
double minimoa; // distancia minima
long distancia; // distancia medida

abiadurak(100); // Poner velocidades
distancia=0;
encoderPos=0;
angelua=90;
aldaketa=-5;

itxaron(1000); // Esperar 1000 milisegundos

do
{
aurrerantza(); // Ir hacia delante

distancia=SONAR(angelua); // Medir distancia mediante sonar
minimoa=kalminimoa(angelua); // Calcular distancia minima para colision

Serial.print("Angelua: ");
Serial.print(angelua);
Serial.print(" Distantzia minimoa: ");
Serial.print(minimoa);
Serial.print(" Distantzia erreala: ");
Serial.println(distancia);

  if(distancia<minimoa) // Mirar si la distancia real es inferior a la real y si es asi parar los motores
      {
        gelditu(); // Parar
        do
        {
          distancia=SONAR(angelua); // Medir distancia

          Serial.print("ARRISKUA! ");
          Serial.print("Angelua: ");
          Serial.print(angelua);
          Serial.print(" Distantzia minimoa: ");
          Serial.print(minimoa);
          Serial.print(" Distantzia erreala: ");
          Serial.println(distancia);

        }while(distancia<minimoa); // Medir distancia mientras la real sea inferior a la minima
        aurrerantza(); // Avanzar
      }
  angelua=angelua+aldaketa; // Actualizar variable del angulo

 
  if(angelua==155)
  {
    aldaketa=-5;
    angelua=145;
   
  }
  if(angelua==25)
  {
    aldaketa=5;
    angelua=35;
  }

}while(encoderPos<=405); // Comparar lo andado con la distancia que queremos que recorra

gelditu();// parar
}


void APtikA1() // Los programas de movimiento son totalmente identicos excepto en la distancia que se quiere recorrer
{
int angelua;
int aldaketa;
long distancia;
double minimoa;
minimoa=0;
distancia=0;
angelua=90;
aldaketa=-5;
encoderPos=0;
abiadurak(100);
itxaron(1000);
do
{
//Mugitzen hasi
aurrerantza();
distancia=SONAR(angelua);
minimoa=kalminimoa(angelua);

if(distancia<minimoa)
  {
    gelditu();
    do
    {
     distancia=SONAR(angelua);
    }while(distancia<minimoa);
    aurrerantza();
  }
  angelua=angelua+aldaketa;
}while(encoderPos<=405);

//Gelditu
gelditu();
}

void APtikA2() // A'-tik A2-era joateko azpiprograma
{
int angelua;
int aldaketa;
long distancia;
double minimoa;
minimoa=0;
distancia=0;
angelua=90;
aldaketa=-5;
encoderPos=0;
// Abiadurak ezarri
abiadurak(100);
itxaron(1000);
do
{
//Mugitzen hasi
aurrerantza();
distancia=SONAR(angelua);
minimoa=kalminimoa(angelua);

if(distancia<minimoa)
  {
    gelditu();
    do
    {
     distancia=SONAR(angelua);
    }while(distancia<minimoa);
    aurrerantza();

  }
  angelua=angelua+aldaketa;
}while(encoderPos<=560);

//Gelditu
gelditu();
}


void Abat() // Rutina para ir a A1
{
  JATORRItikAP();
  BIRAKETA();
  APtikA1();
  itxaron(5000);
  KONTRABIRAKETA();
  APtikA1();
  BIRAKETA2();
  JATORRItikAP();
  KONTRABIRAKETA();
}

void Abi() // Rutina para ir a A2
{
  JATORRItikAP();
  BIRAKETA();
  APtikA2();
  itxaron(5000); // Itxaroteko, gero kamara bidez objeturik ez dagoenenan gertatuko da.
  KONTRABIRAKETA();
  APtikA2();
  BIRAKETA2();
  JATORRItikAP();
  KONTRABIRAKETA();
}

void KONTRABIRAKETA() // Realizar el giro 360º
{
 
  //Abiadurak ezarri
abiadurak(120);
encoderPos=0;


itxaron(1000);
do{
//Mugitzen hasi
atzezk.run(FORWARD);
aurezk.run(FORWARD);
atzesk.run(BACKWARD);
auresk.run(BACKWARD);
Serial.print(encoderPos);
}while(encoderPos<=135);

gelditu();
}


void BIRAKETA2() // Rutina para girar 90º
{


abiadurak(120); // Establecer velocidades
encoderPos=0;
itxaron(1000);
do{

//Mugitzen hasi
atzezk.run(FORWARD);
aurezk.run(FORWARD);
atzesk.run(BACKWARD);
auresk.run(BACKWARD);
Serial.print(encoderPos);
}while(encoderPos<=60);

//Gelditu
gelditu();

}

void BIRAKETA() // Rutina para girar 90º
{

//Abiadurak ezarri
abiadurak(120);
encoderPos=0;
itxaron(1000);
do{
//Mugitzen hasi
atzezk.run(BACKWARD);
aurezk.run(BACKWARD);
atzesk.run(FORWARD);
auresk.run(FORWARD);
Serial.print(encoderPos);
}while(encoderPos<=60);

//Gelditu
gelditu();

}

long SONAR( int angelua) // Subrutina del sonar
{   

           
            long distancia=0 ;
           
            servoMotor.write(angelua);
            itxaron(50);

            distancia= sonar.ping_cm();
            Serial.println(distancia);
           
            return distancia;
}


float kalminimoa(int angelua) // Subrutina para calcular la distancia minima a colision

{
float radianetan;
float minimo;

radianetan=0;
minimo=0;


  if(angelua<90)
{
radianetan=angelua*(2*PI/360); // Pasar el angulo a radianes
minimo=(7.5/cos(radianetan))+1
; // Distantzia minima+ 1 seguridad
}
  if(angelua>90)
{
radianetan=angelua*(2*PI/360);
minimo=(-7.5/cos(radianetan))+1;

}
if (angelua==90)
{
  minimo=25; // Cos de 90º es 0 por eso se establece a mano
}

// Si la distancia minima da muy alta se limita a 25
if (minimo>25)
{
  minimo=25;
}

  return minimo; //Distantzia minimoa itzuli.
}


void abiadurak(int v) //Subrutina para establecer velocidades
{
  atzezk.setSpeed(v);
  atzesk.setSpeed(v);
  aurezk.setSpeed(v);
  auresk.setSpeed(v);
}

void gelditu() //Subrutina para parar
{
  atzezk.run(RELEASE);
  atzesk.run(RELEASE);
  auresk.run(RELEASE);
  aurezk.run(RELEASE);
}

void aurrerantza() //Subrutina para avanzar
{
  atzezk.run(FORWARD); // Aurrerantza
  atzesk.run(FORWARD);
  auresk.run(FORWARD);
  aurezk.run(FORWARD);
}

void itxaron(int t) // Subrutina para esperar, simular un delay()
{
  unsigned long A=0;
  unsigned long B=0;
  B=millis();
  do{
    A=millis();
  }while(A<t+B);
 
}


surbyte

Gracias, porque eso quiere decir que todo el trabajo que me tomé rehaciendo tu código y hasta traduciendolo no sirvió de nada ni para que lo leas.

Vaya que desilusión.

liskarra0

Perdona pero si he leído tu código, y analizado cada cosa que has hecho ahí. Pero una vez analizado tu código he intentado hacerlo por mi mismo también y entender cada cosa que ponía.

Si te fijas son prácticamente identicos excepto la función de newping que yo utilizo una que directamente da la medida en cm. También he probado la que tu utilizas pero también da error.

Ademas le he añadido una función que hace de delay() implementada por millis() para poder esperar sin bloquear el procesador.

Pero en todo momento he dejado de valorar tu trabajo y esfuerzo. Y lo he leído y apreciado mucho cada cosa que has hecho y te lo agradezco.

Una vez dicho esto, se os ocurre que puede pasar? Que es lo que esta interfiriendo en las mediciones del sonar si no es el pulsein?

Go Up