Cnosos refactorizado y documentado; bug constructor Robot arreglado

Author: AlvarTapia

Codigo/RobotAlgoritmica/Cnosos.cpp

@@ -86,10 +86,15 @@ byte Cnosos::siguiente() {
 byte Cnosos::lee_numero() {
   byte x = 0;
   for (byte i = 0; i < BITS; i++) {
+    //Desplaza el numero a la izquierda.
+    //Si x = 0, despues de la operacion x = 0
+    //Si x = 0b1, despues de la operacion x = 0b10
     x = x << 1;
+    //Si encuentra un cruce, suma 1 a x
     if(siguiente() == 1){
       x++;
     }
+    //Si no encuentra un cruce, como ya se introduce un 0, dejalo como esta
   }
   return x;
 }
@@ -100,76 +105,114 @@ byte Cnosos::lee_numero() {
  * Este metodo no sabe desde que parte del nodo empieza, por lo que
  * crucesEncontrados es menor o igual que el grado.
  */
-byte lee_nodo_A(Cnosos* cn, byte &etiq) {
+byte lee_nodo_A(Cnosos* cn, byte &id) {
   byte crucesEncontrados = 0;  // caminos contados desde la entrada
-  while (cn->siguiente()){
+  //Mientras siguiente() encuentre cintas cruzadas
+  while (cn->siguiente() == 1){
     crucesEncontrados++;
   }
 
-  etiq = cn->lee_numero();
+  //Cuando siguiente() encuentre un hueco en la cinta
+  //Empieza a leer el identificador
+  id = cn->lee_numero();
 
+  //Devuelve los cruces que haya encontrado
   return crucesEncontrados;
 }
 
 /*
- * Despues de lee_nodo_A sabemos que estamos detras del identificador de nodo.
+ * Despues de lee_nodo_A sabemos que el robot esta detras del identificador de nodo.
  *
  * Calcula el grado del nodo (numero aristas), y lo devuelve por referencia.
- * Calcula la arista desde la que ha empezado contando desde despues de la etiqueta
- *  (Si ha empezado lee_nodo() 2 aristas despues del identificador, entrada = 2).
  * El identificador leido en lee_nodo_A debe ser el mismo que el leido en lee_nodo_B.
+ * Calcula la arista desde la que ha empezado contando desde despues de la etiqueta, con la ayuda de crucesEncontrados.
+ *  (Si ha empezado lee_nodo() 2 aristas despues del identificador, entrada = 2).
  */
-void lee_nodo_B(Cnosos* cn, byte crucesEncontrados, byte &grado, byte &entrada,
-                        byte etiq) {
+void lee_nodo_B(Cnosos* cn, byte crucesEncontrados, byte id,
+                byte &grado, byte &entrada) {
+  //Calcula el grado del nodo
   grado = 0;
-  while (cn->siguiente()){
+  while (cn->siguiente() == 1){
     grado++;
   }
 
+  // Calcula el cruce por el que ha entrado el robot
   entrada = grado - crucesEncontrados + 1;
 
-  if (etiq != cn->lee_numero()){
+  //Si el id leido es distinto del recibido por argumentos
+  if (id != cn->lee_numero()){
+    //Salta error
     cn->error();
   }
 }
 
 /*
  * Despues de dos vueltas al nodo, devuelve por referencia
  * el identificador del nodo, el grado del nodo,
- * y cuantos cruces debe saltarse para llegar desde el final del identificador
- * al cruce por el que ha empezado a investigar el nodo.
+ * y cuantos cruces debe saltarse el robot para llegar desde el final del identificador
+ * al cruce por el que el robot ha empezado a investigar el nodo.
  */
 void Cnosos::lee_nodo(byte &etiq, byte &grado, byte &entrada) {
   byte aux = lee_nodo_A(this, etiq);
-  lee_nodo_B(this, aux, grado, entrada, etiq);
+  lee_nodo_B(this, aux, etiq, grado, entrada);
 }
 
 /*
- *
+ * Dos giros a la izquierda.
  */
 void Cnosos::sal_aqui() {
-  sal_izq();
-  if (this->siguiente()){
-    sal_izq();
+  this->sal_izq();
+  if (this->siguiente() == 1){
+    this->sal_izq();
+  }else{
+    this->error();
   }
-  else error();
 }
 
-void Cnosos::sal(byte i, byte grado, byte pos) {
-  while (pos != i) {
-    pos++;
-    if (pos == grado + 1) {
-      if (this->siguiente()) error();
+void Cnosos::sal(byte aristaATomar, byte grado, byte posicionInicial) {
+  //Arista saltado representa los cruces que el robot se ha saltado hasta el momento.
+  //Si las aristas estan identificadas en el intervalo {1..n},
+  //el robot puede haberse saltado {0..n} aristas al recorrer el perimetro del nodo,
+  //siendo "0" el tramo entre el identificador y la primera arista,
+  //y "n" el tramo entre la ultima arista y el identificador.
+  byte aristaSaltada = posicionInicial;
+  
+  //Mientras la arista que el robot se ha saltado no sea la arista anterior a la que se quiere tomar:
+  while (aristaSaltada != aristaATomar - 1) {
+    //Si la arista actual supera o iguala el grado:
+    //Esta en la zona de identificadores
+    if (aristaSaltada >= grado) {
+      //Si no encuentra el identificador, error
+      if (this->siguiente() == 1) {
+        error();
+      }
+      //Descarta el identificador, no lo necesitamos ahora
       lee_numero();
-      pos = 1;
+      //La arista actual es 0 (no nos hemos saltado ninguna)
+      aristaActual = 0;
+    }else{
+      //El robot no esta en zona de identificadores
+      //Si encuentra un identificador, error
+      if (this->siguiente() == 0){
+       this->error();
+      }
+      //El robot acaba de saltarse un cruce
+      //La arista actual aumenta en 1
+      aristaActual++;
     }
-    if (!this->siguiente()) error();
   }
-  sal_aqui();
+
+  //Si se ha salido del bucle, es que se quiere tomar el siguiente cruce.
+  //El robot toma el siguiente cruce.
+  if (this->siguiente() == 1){
+    this->sal_aqui();
+  }else{
+    this->error();
+  }
 }
 
 void Cnosos::sal_izq() {
-  //TODO
+  //TODO probar en vivo
   robot.rotaIzda();
   robot.alante();
   robot.rotaIzda();
@@ -189,8 +232,9 @@ void Cnosos::luce_numero(byte n) {
 // Necesita modulo Morse inicializado para que suene/luzca
 // Necesita modulo Bluetooth inicializado para mandar mensajes
 void Cnosos::error() {
-  robot.BLUETOOTH.enviaLinea("¡ERROR!");
+  robot.para();
   while (true){
+    robot.BLUETOOTH.enviaLinea("¡ERROR!");
     robot.MORSE.sos();
   }
 }

Codigo/RobotAlgoritmica/Cnosos.h

@@ -14,71 +14,104 @@
 #include "robot.h"
 
 class Cnosos {
-  //TODO
+  /// Redefiniciones de metodos que se usaran a lo largo de la clase.
+  // Reducen y hacen mas intuitivo el codigo.
   #define SENSOR_IZDA robot.SIGUELINEAS.readIzda()
   #define SENSOR_CENTRO robot.SIGUELINEAS.readCentro()
   #define SENSOR_DCHA robot.SIGUELINEAS.readDcha()
-  //TODO
+
+  /// Cada vez que tiene que procesar una entrada, el robot "pensara" (se quedara quieto) este numero de milisegundos.
   #define TIEMPO_PENSAR 500
   private:
-    //TODO
+    /// Guarda la configuracion del robot que se va a usar en este objeto.
     Robot robot;
-    //TODO
+    /// Numero de bits que usaran los nodos para identificarse.
     byte BITS;
   public:
-    //Constructores
+    //Constructor
     /**
-     * TODO
-     * @param
-     * @param
+     * Constructor de la libreria Cnosos.
+     * No necesita inicializarse, dado que los parametros ya deberian estar inicializados.
+     * @param Robot a controlar
+     *    Objeto Robot con el que se va a trabajar.
+     *    Se espera que el Robot este inicializado, asi como su Siguelineas.
+     *    Si se necesita debuggear o que el robot se comunique con el usuario, 
+     *    es necesario inicializar o el modulo Morse o el modulo Bluetooth.
+     * @param Numero bits en las etiquetas
+     *    Numero de bits que se usaran para identificar cada nodo del mapa.
+     *    Se espera que el tamaño del parametro sea adecuado, dado que si se utiliza el valor maximo (255),
+     *    se podrian identificar 2^255 nodos, que son mas de 10^76 nodos.
+     *    Por defecto, se utilizaran 3 marcas para el identificador de cada nodo.
      */
     Cnosos(Robot, byte = 3);
     //Destructor
 
 
     //Funciones
     /**
-     * TODO
+     * Avanza por la linea hasta encontrar un hueco en la cinta o una cinta atravesada. Sobrepasa el indicador.
+     * @return 0 si ha encontrado un hueco en la cinta, 1 si ha encontrado una cinta atravesada.
      */
     byte siguiente();
 
     /**
-     * TODO
+     * Lee un identificador de nodo.
+     * Este metodo supone que se acaba de cruzar el marcador de comienzo del identificador.
+     * Por defecto, ese marcador es un hueco en la cinta.
      */
     byte lee_numero();
 
     /**
-     * TODO
+     * Recorre dos veces el perimetro del nodo para obtener gran cantidad de datos.
+     * El robot quedara despues del identificador del nodo.
+     * @param[out] Identificador del nodo
+     *    Devuelve el numero que identifica a este nodo.
+     * @param[out] Grado del nodo
+     *    Devuelve el grado (o el numero de cruces) que tiene este nodo.
+     * @param[out] Cruce por el que ha entrado el robot al nodo
+     *    Devuelve el numero del cruce por el que ha entrado el nodo.
+     *    Si el robot empezo a recorrer el nodo justo detras del identificador, este numero sera 0,
+     *    si se empezo detras del primer cruce sera 1... 
+     *    asi hasta 'grado', que significaria que el robot 
+     *    ha empezado a recorrer el nodo antes del identificador.
      */
     void lee_nodo(byte&, byte&, byte&);
 
     /**
-     * TODO
-     */
-    byte calcula_entrada(byte, byte);
-
-    /**
-     * TODO
+     * En cuanto se encuentre un cruce, toma ese cruce y el robot pasa al siguiente nodo.
      */
     void sal_aqui();
 
     /**
-     * TODO
+     * Toma un cruce en concreto desde la posicion en la que este el robot.
+     * @param Cruce a tomar
+     *    Numero del cruce que se quiere tomar, siendo 1 el primer cruce de la etiqueta.
+     * @param Grado del nodo
+     *    Ultimo cruce que puede tomar el robot.
+     *    Tambien representa el grado (o el numero de cruces) que hay en el nodo.
+     * @param Cruce actual
+     *    Indica cual es el ultimo cruce que el robot se ha saltado.
+     *    Por defecto, se considera que el robot esta justo detras de la etiqueta,
+     *    por lo que no se ha saltado ningun cruce (este valor es 0).
      */
-    void sal(byte, byte, byte);
+    void sal(byte, byte, byte = 0);
 
     /**
-     * TODO
+     * Toma una salida a la izquierda.
      */
     void sal_izq();
 
     /**
-     * TODO
+     * Comunica un numero al usuario por medio de modulos.
+     * Necesita tener inicializado el modulo Morse o el modulo Bluetooth para comunicarse con el usuario.
+     * @param Numero a comunicar
+     *    Envia este numero, ya sea con el mismo numero de pitidos, o con un mensaje Bluetooth.
      */
     void luce_numero(byte);
 
     /**
-     * TODO
+     * Se ha encontrado un suceso inesperado. Se para y grita SOS.
+     * Necesita tener inicializado el modulo Morse o el modulo Bluetooth para comunicarse con el usuario.
      */
     void error();
 };

Codigo/RobotAlgoritmica/robot.cpp

@@ -14,7 +14,7 @@
 
 #include "robot.h"
 
-//Constructor
+//Constructores
 Robot::Robot(byte pinIzdaAlante, byte pinIzdaAtras, byte pinDchaAlante, byte pinDchaAtras,
              byte pinVelIzda, byte pinVelDcha,
              byte tiempoArranque) {
@@ -29,6 +29,9 @@ Robot::Robot(byte pinIzdaAlante, byte pinIzdaAtras, byte pinDchaAlante, byte pin
 
   TIEMPO_ARRANQUE = tiempoArranque;
 }
+Robot::Robot(){
+  Robot(255, 255, 255, 255, 255, 255, 0);
+}
 //Destructores
 
 

Codigo/RobotAlgoritmica/robot.h

@@ -93,7 +93,7 @@ class Robot {
     //Destructores
 
 
-	//Inicializar
+  	//Inicializar
     /**
      * Inicializa los pines para que el robot pueda alimentar los motores.
      */
@@ -145,7 +145,7 @@ class Robot {
     void maxVelocidad();
 
 
-	//Cambios de direccion
+	  //Cambios de direccion
     /**
      * El robot deja de alimentar los motores de la izquierda para poder girar a la izquierda.
      * Permite girar mientras el robot va marcha atras.
@@ -155,7 +155,7 @@ class Robot {
      */
     void giraIzda(byte = VELOCIDAD_GIRO);
 
-	/**
+	  /**
      * El robot deja de alimentar los motores de la derecha para poder girar a la derecha.
      * Permite girar mientras el robot va marcha atras.
      * @param Velocidad

Codigo/RobotAlgoritmica/siguelineas.h

@@ -69,19 +69,19 @@ class Siguelineas {
     //Funciones
     /**
      * Accede al sensor izquierdo y devuelve su lectura.
-     * @return true si hay una linea debajo del sensor izquierdo.
+     * @return TRUE si hay una linea debajo del sensor izquierdo.
      */
     bool readIzda();
 
     /**
      * Accede al sensor central y devuelve su lectura.
-     * @return true si hay una linea debajo del sensor central.
+     * @return TRUE si hay una linea debajo del sensor central.
      */
      bool readCentro();
 
     /**
      * Accede al sensor derecho y devuelve su lectura.
-     * @return true si hay una linea debajo del sensor derecho.
+     * @return TRUE si hay una linea debajo del sensor derecho.
      */
      bool readDcha();
 };