Un Vistazo a NXC

Autor: Juan Albarran Gutierrez
Competencia: Aprendizaje Autonomo
Palabras Clave: Proyecto Robotica, NXC, Subrutinas, Mutex

Descripcion de la Actividad:

Este fue un repaso antes de la prueba de Programacion de Robots en la cual se enfatiza en la codifcacion y para que sirve cierto comando en NXC.

1. Construya un programa NXC para un robot luchador de Sumo, cuya estrategia de lucha está
definida por las siguientes tareas que corren en paralelo (concurrentemente):
- Avanzar(): Avanza en línea recta a potencia de 50.
- DetectaBorde(): Al detectar un color negro, retrocede 1 segundo y gira aleatoriamente.
- Embestida(): Al detectar un enemigo a menos de 25 cms avanza a máxima potencia.
- Choque(): Al chocar retrocede 1 seg. a máxima potencia
- Retiro(): Al oír un sonido sobre 85 db, se detiene el robot y todas sus tareas.
NOTA: debe usar Mutex cuando corresponda.

//Defino los valores que
#define SOUND 85
#define BLACK 28
#define ATTACK 25
mutex motors;
int status = 1;

task advance(){   
    while(status == 1){
        Acquire(motors);
        OnFwd(OUT_AB,50);
        Release(motors);
    }
}

task detectDot(){
    while(status == 1){
        if(SENSOR(IN_1) == BLACK){
            Acquire(motors);
            OnRev(OUT_AB,100);
            Wait(1000);
            OnFwd(OUT_B,100);
            OnRev(OUT_A,100);
            Wait(Random(1900) + 100);
            Release(motors);
        }
    }
}

task tackle(){
    while(status == 1){
        if(SensorUS(IN_4) == ATTACK){
            Acquire(motors);
            OnFwd(OUT_AB,100);
            Release(motors);
        }
    }
}

task crash(){
    while(status == 1){
        if(SENSOR(IN_2) == 1){
            Acquire(motors);
            OnRev(OUT_AB,100);
            Release(motors);
        }
    }
}

task retreat(){
    while(status == 1){
        if(SENSOR(IN_3) == SOUND){
            status = 0;
            Acquire(motors);
            Off(OUT_AB);
            Release(motors);
        }
    }
}

task main(){
    SetSensorLight(IN_1);
    SetSensorSound(IN_3);
    SetSensorTouch(IN_2);
    SetSensorLowspeed(IN_4);
    Precedes(advance,detectDot,tackle,crash,retreat);
}




2. Implemente un programa en NXC para el siguiente problema.
Un robot se desplaza por una superficie blanca definiendo la trayectoria de un cuadrado. La
superficie blanca posee manchas (espectro de color inferior a 80). Cada vez que detecta una
mancha (lo cual realiza en paralelo), guarda en un Arreglo el valor del color de la mancha. Al
final del recorrido cuadrado, genera un reporte a archivo de las manchas detectadas (ver tabla
ejemplo de un posible reporte)

                      REPORTE DE MANCHAS
              Numero      Color
             ------------------
              1            56
              2            66
              3            36

Especificaciones:
- La Tarea que detecta mancha, llamará a una subrutina GuardaMancha, pasándole como
parámetro el valor del color. Esta subrutina, GuardaMancha, es la que guardará en el Arreglo el
color de la mancha correspondiente.
- El robot detiene su recorrido al finalizar la trayectoria cuadrada. Luego de eso, genera el
reporte al archivo.

Codigo:

#define LIGHT 80
int manchas[10];
int status = 1;
int i;
int luz;
byte punteroArchivo;
byte bytesEscritos;
int tamano = 512;
int banderaprimeralinea = 0;
string buffer;
int lectorlineas = 0;

task trayectoria(){
    int contador = 1;
    do{
        OnFwd(OUT_AB,50);
        Wait(5000);
        OnFwd(OUT_A,50);
        Wait(4000);
        contador++;
    }while(contador <= 4);
    status = 0;
    Off(OUT_AB);
    crearArchivo();
    reportarManchas();
}

sub CreaArchivo(){
    string linea;
    CreateFile("informe.txt",tamano,punteroArchivo); //se crea el archivo
    for(i = 0; i &lt; ArrayLen(manchas); i++){
        if(banderaprimeralinea == 0){
            WriteLnString(punteroArchivo, "Reporte de Manchas",bytesEscritos);
            WriteLnString(punteroArchivo, "Numero   Color",bytesEscritos);
            WriteLnString(punteroArchivo, "--------------",bytesEscritos);
            banderaprimeralinea = 1;
        }
        if(banderaprimeralinea == 1){
            int posActual = i + 1;
            string nmancha = NumToStr(posActual);
            string nmanchaX = NumToStr(manchas[i]);
            linea = nmancha + "      "+ nmanchaX;
            WriteLnString(punteroArchivo,linea,bytesEscritos);
        }
    }
    CloseFile(punteroArchivo);
}

task leerMancha(){
    while(status == 1){
        if(SENSOR(IN_1) == LIGHT){
            guardaMancha(SENSOR(IN_1));
        }
    }
}

sub guardaMancha(int lux){
        manchas[i] = lux;
        i++;
        if(i == 9){
            i = 0;
        }
}

sub reportarManchas(){
  string linea1;
  string linea2;
  string linea3;
  string linea4;
  OpenFileRead("informe.txt", tamano, punteroArchivo);
      while(lectorlineas <= 5){
          ReadLnString(punteroArchivo,buffer);
             switch (lectorlineas){
                case 1 :
                    linea1 = buffer;
                case 2 :
                    linea2 = buffer;
                case 3 :
                    linea3 = buffer;
                case 4 :
                    linea4 = buffer;           
          }        
          lectorlineas++;
  }
  TextOut(2,50,linea1);
  TextOut(2,40,linea2);
  TextOut(2,30,linea3);
  TextOut(2,20,linea4);        
  Wait(30000);
}

task main(){
    SetSensorLight(IN_1);
    Precedes(trayectoria,leerMancha);
}

3.
Para el problema anterior ¿qué ocurre si justo al finalizar el recorrido el robot se detiene
sobre una mancha? Si esto es un problema, ¿qué propone para solucionarlo? (conteste en sus
palabras - no se espera que programe nada).
 
R: Se Solucionaria  agregando un mutex para regular dicha  accion asi que en el momento en que una de los eventos se haya realizado sea el fin de la trayectoria o la lectura de la mancha, se realice sin problemas y luego pasar a concretar la siguiente.


Conclusion

Bueno con esto me dio la base para trabajar con subrutinas, archivos y tareas paralelas. me ha ayudado a comprender un poco mas lo que es la sintaxis en NXC y mas o menos para tratar de imaginar como had e funcionar el robot