The KeSB
Kill Everything what Seems Blue 
We hebben uiteindelijk gekozen om de robot te programmeren in NQC (Not Quite C) met het programma Bricx.
Omdat het programma zelf geen webcam ondersteunt hebben we gebruik moeten maken van Vision Command. De webcam die wordt meegeleverd bij het LEGO-pakket is oud en heeft een lage frame rate (verversing van het beeld). We hebben besloten om hier een andere webcam voor te gebruiken.

Voor het schietmechanisme hebben we lang nagedacht. Een projectlid had een infrarood schijnwerper en deze bleek perfect te zijn voor ons project. Aan het uiteinde van de spanningskabels hebben we een elektronisch lego-blokje geplaatst. Hierdoor is het mogelijk de infrarood schijnwerper via de RCX te besturen. De RCX is het oude model, door problemen met infrarood ontvanger (ze gingen elkaar aansturen) hebben we er folie omheen gedaan.

Doordat we dat zo geregeld hebben met Vision command, zijn er dus korte programma's ontstaan, die zijn verdeeld over verschillende sloten(stukjes geheugen waar een programma op staat). Het nadeel hiervan is dat een programma in een ander slot niet kan communiceren met de webcam. Een heel groot voordeel is dat deze robot op kleur kan zoeken en dus zo de vijand makkelijk kan herkennen, maar aan de andere kant kan hij de tafel rand minder goed detecteren. Ook heeft hij te weinig sloten om de vijand van voren te kunnen herkennen en schieten.

Specificaties:
  • 1x RCX (besturingselement)
  • 2x Rupsbanden
  • 1x Speedlink webcam
  • 1x Infra-rood kanon
Camera en schietmechanisme
De robot maakt gebruik van een Speedlink camera en de infrarood schijnwerper.

Programma:
  • De robot rijdt in willekeurige richting en houdt een aantal dingen in de gaten: Is de tafel nog te zien? Is dit niet het geval, dan zal de robot dit op de volgende manier corrigeren. Het programma springt naar slot 3 (tafel detectie). Dit programma vertelt de robot om achteruit te rijden voor 1 seconden, draait links- of rechtsom en rijdt weer verder. 
    #include "include.nqh";
    //at the edge of the desk, go back
    task main()
    {
      PlaySound(2);
      BACKWARD(75);
      Turn_Random();
      SelectProgram(4);
    }
  • Zie ik de vijand? De robot zoekt d.m.v. een bepaalde kleur zijn tegenstander, in dit geval blauw. De vijand kan links of rechts langs de webcam komen. Wanneer dit gebeurt, draait de robot links of rechts naar zijn tegenstander en begint te schieten.
    #include "include.nqh";
    // Bot is right. turn right
    task main()
    {
      PlaySound(1);
      Turn_Right(15);
      SelectProgram(4);
    }
  •  
  • Ben ik zelf geraakt? Door de felle infrarood kanonnen is het eenvoudig om te detecteren of de robot geraakt is. Helaas heeft deze robot wel last van omgevingslicht zoals direct licht en de felle tafel.
    #include "include.nqh";
      //triggered when hit by light
    task main()
    {
      PlaySound(4);
      // Do nothing (play dead)
    }
Voordelen van NQC
  • Het is flexibeler dan Vision command.
  • Makkelijker aan te passen (voor programmeurs)
  • In NQC kunnen we gebruik maken van alle 5 de programma tegelijkertijd, terwijl we in het Invention of Vision pakket maar 1 slot per keer kunnen gebruiken
Nadelen
  • De webcam is niet toegankelijk in elk programma-slot
  • Alleen geschikt voor programmeurs.

Nu lijkt het programma erg simpel, maar dit zijn slechts functies die aangeroepen worden. wat deze functies doen staat hieronder beschreven.
int turn_time, move_time, move_random, time = 0, not_hit = 1, side = 0;
#define KANON 75
#define ON_KANON OnFwd(OUT_B);
#define OFF_KANON Off(OUT_B);
#define MOTOR_A OUT_A
#define MOTOR_C OUT_C
#define MOTOR_AC OUT_AC
#define FORWARD OnFwd(MOTOR_A);  OnFwd(MOTOR_C);
#define BACKWARD OnRev(MOTOR_A);  OnRev(MOTOR_C);
#define HIT PlaySound(2);

/*
Right:  slot 1
Under:  slot 2
Left:   slot 3
Middle: slot 4
*/

// task main(){}
void Turn_Random() {
     // go a random side  (left/right)
    side = Random(1);
  if (side == 0) {
        Turn_Left(100);
        //Wait(100);
  } else {
        Turn_Right(100);
        //Wait(100);
  }
  Float(MOTOR_AC);
}

void Turn_Around() {
    // keer om
    NotHit();
    if(not_hit == 0) goto end;
       OnFwd(MOTOR_A);
       OnRev(MOTOR_C);
       Wait(100);

    NotHit();
    if(not_hit == 0) goto end;
        Wait(100);

    NotHit();
    if(not_hit == 0) goto end;
        Wait(100);

    NotHit();
    if(not_hit == 0) goto end;
       Wait(100);
    end:;
    Float(MOTOR_AC);
}

void Turn_Left(int wait) {
    // keer links om
    NotHit();
    if(not_hit == 0) goto end;
       OnFwd(MOTOR_A);
       OnRev(MOTOR_C);
       Wait(wait);
    end:;
    Float(MOTOR_AC);
}

void Turn_Right(int wait) {
    // keer rechts om
    NotHit();
    if(not_hit == 0) goto end;
       OnRev(MOTOR_A);
       OnFwd(MOTOR_C);
       Wait(wait);

    NotHit();
    if(not_hit == 0) goto end;
       Wait(wait);
    end:;
    Float(MOTOR_AC);
}

void NotHit() {
     // controleer
    if (SENSOR_2 > KANON) {
       HIT;
       not_hit = 0;
    } else {
       not_hit = 1;
    }
}

void FORWARD(int wait) {
     OnFwd(MOTOR_AC);
     Wait(wait);
}

void BACKWARD(int wait) {
     OnRev(MOTOR_AC);
     Wait(wait);
}

//Fire And Track
//1. infrarood licht aan (schieten)
//2. kijken of ons doel er nog is (andere tank)
//3. zo niet, random rijen (slot 2)
void FAT() {
   //schieten voor 1 seconden
    ON_KANON
    wait(100);

    //controleren of target nog in midden region zit
    //licht + kleur kan niet op 1 region? :(
}