Mapear un laberinto.

#1
Alguien que me diga como mapear un laberinto utilizando un sensor ultrasonico para que no choque y no se que mas Hardware para poder reconocer que ya a pasado por estos lugares y lograr recordar por donde paso para ir de regreso. Quiero hacer este proyecto solo que mucho mas grande por su puesto, pienso utilizar el pic18f4620 que tiene una capacidad de 32Kbits de programa y e de 40MGH

https://www.youtube.com/watch?v=nO2zqGwzsj0
 
#2
Lo de memorizar los lugares donde ya se paso, parece mas un trabajo de software, creo se puede hacer con una estructura tipo pila que "apile" los "pasos rectos" dados y si no se encuetra salida se saquen de la pila y se retorne en sentido contrario a el último cruce y repita el proceso hasta encontrar la salida.
Solo es una idea espero no confundir...
 
#3
Efectivamente... mapear un laberinto solo es cuestion de software, la idea es simple, conforme el robot avanza va creando una matriz del laberinto en la memoria, para poder ir resolviendo por descarte en que zonas ya paso y cuales le falta por explorar, hasta encontrar la salida
 
#4
StrySG me puedes dar documentos lo que sea para yo poder guardar información en lo que tu dises llamar "apile" o los "pasos rectos"

Chico3001, como crear la matriz del laberinto en la memoria.

Pues yo quiero aserlo usando lenguaje C con el compilador CCS C, aunque a hora solo tengo conosimiento del lenguaje PBP (Pic Basic PRo).

Nesecito documentos o tutoriales que me puedan alludar en la creación de Apile y Matriz en la memoria del pic.

Gracias por dar luz a este proyecto.
 
#5
A decir pila me refiero a una estructura informática, esto te servirá:
https://es.wikipedia.org/wiki/Pila_(informática)
La idea es que se tenga un vector, que siga el concepto de pila, esto significa que si se coloca un dato estará en la cima de la pila (del vector) y este será el primero en ser sacado, los demás no pueden sacarse hasta que no estén en la cima de la pila.
Entonces, por ejemplo si un robot avanza debería guardar en su memoria cuanto ha avanzado por eso digo cuantos "pasos" ha dado. Los pasos meterlos en una "pila" para que se registre cuantos pasos ha dado .
Debería el robot también detectar cruces, si hay curces decidir por que camino ir, y si no encuentra salida volver al último curce sacando los n datos (pasos grabados) de la pila hasta el último cruce. Repetir este proceso hasta que se encuentre la salida, y en este punto la pila tendrá grabada la solución al laberinto también.

Para hacer eso necesitas programar esa etructura pila en lenguaje C, seguramente encontrarás muchas ya hechas si buscas mejor. También necesitarás algo para contar los "pasos" o la distancia que recorre el robot cada cierto tiempo.
 
#6
Gracias StrySG por tomarte la molestia, estoy leyendo todo lo que encuentre en Wikipedia para saber sobre esto. Por si por casualidad tendrás proyectos en C con el compilador CCS C par que yo pueda aprender la estructura de la sintaxis. De cualquier manera ya estoy agradecido por esta valiosa información. Saludos.
 
#7
No uso CCS pero aquí un ejemplo genérico:

PHP:
#include <stdio.h>
#include <stdlib.h>

#define SIZE 200  /*tamaño de la pila*/

void push(int i);
int pop(void);

int  *tos, *p1, stack[SIZE]; 
/*    stack[] es el vector que contiene los datos */
int main(void)
{
  int value;

  tos = stack; /* tos points to the top of stack */
  p1 = stack; /* initialize p1 */
  // --- sólo para probar la pila ---
  do {
    printf("Enter value: ");
    scanf("%d", &value);

    if(value != 0) push(value);
    else printf("value on top is %d\n", pop());
  } while(value != -1);
  //----------------------------------------
}

void push(int i)
{
  p1++;   //aumenta el número de elementos
  if(p1 == (tos+SIZE)) 
    printf("Stack Overflow.\n");   //pila llena
  *p1 = i;   //coloca dato en la pila "apilar"
}

int pop(void)
{
  if(p1 == tos) 
    printf("Stack Underflow.\n");  //pila vacía
  p1--;
  return *(p1+1);  //saca dato de la pila "desapilar"
}
Esta es una pila de números enteros, pero puedes modificarla.
La pila estará vacia al empezar el laberinto, podrías usar un código que te convenga para identificar cruces y direcciones por ejemplo:
0xAA = paso hacia adelante
0xFF = cruce
0x0E = giro a la izquierda (cuando se encuentre cruce)
0xE0 = giro a la derecha (cuando se encuentre cruce)
Según el robot avance grabas en la pila los códigos de arriba (u otros) para que se registre lo que hizo y si no se encuentra salida haga los pasos contrarios hasta encontrar 0xFF, para tomar otros camino.
Para que el robot resuleva el laberinto no es obligatorio que uses una pila, podrías usar un vector que vaya registrando el recorrido de tu robot.
 
#8
Que lenguajes dominas para la realización del sistema PILA o por medio de Vector.
Gracias por tu ejemplo, lo entendería mejor en PBP ya que aun no domino C.
Saludos.
 
#9
Seguro encontrarás la estructura pila para Basic es simple.
Parece que la forma que sugerí funcionará para encontrar salida al laberinto pero seguro hay que aumentar algo o usar otro enfoque para evitar que el robot tome dos o más veces el mismo camino hasta encontrar la salida.
 

Temas similares

Arriba