Sariel.pl

My second LEGO Mindstorms NXT MOC. Features a Bluetooth remote that controls motors connected to another brick with a speed control and a proportional steering.  

Datasheet:

Completion date: 03/03/2012
Power: electric (NXT brick)
Language: ROBOTC
Bricks: 2
Motors: 5 x NXT motor
Sensors: 2 x touch

One of the most interesting features of the NXT brick is that it can create a two-way Bluetooth link with another brick, which is in every way superior to IR link. I wanted to take advantage of this feature by creating a very simple, basic remote allowing to control motors connected to a brick inside a MOC with another brick. The remote was intended for typical wheeled vehicle, hence the drive control with a speed control feature and a proportional steering.

The actual remote is fairly simple, using two NXT motors and two touch sensors. Step-by-step instruction for building it can be found below. In order to work, it requires two-part program: one part is run on the sender brick, and another on the receiver brick. Note that for the bricks to create a Bluetooth link, they need to be first linked manually so that they keep each other in their Bluetooth contact list.

The drive motor, connected to receiver brick’s A port,  can be controlled with a speed control feature by rotating the knob on the remote’s left motor. Note that the movement of the knob is limited mechanically, thanks to which the programs are simpler. There is an option to make the receiver brick beep while on reverse, just like some trucks beep. Note that this is part of the program’s configuration, which is included entirely in the receiver part. Also note that the volume of the receiver brick can be changed remotely by using arrow buttons on the remote.

The steering motor, connected to receiver brick’s B port, is controlled proportionally, meaning that it’s synchronized with the steering wheel and it maintains the same angle. The steering wheel’s movement is also mechanically limited for simplicity. Note that the margin of 10 degrees is defined in the receiver’s configuration to avoid problems with motors’ inertia which are inevitable when the accuracy of synchronization is too high. Such a situation can lead to the receiver’s steering motor going forward and back endlessly, because it has too much inertia to stop exactly at the desired angle.

Finally the additional motor, connected to receiver brick’s C port is controlled by pressing and holding one of the two touch sensors.

Note that the orange button on the sender brick enables and disables sending of the data. This function is initially disabled when program starts, so that the position of the remote’s controls can be adjusted without affecting the receiver brick. Also note that upon disabling, the remote resets all values except volume, meaning that it stops all motors and returns the steering motor to center. However, once enabled, it will sends again the current values, making the receiver’s motors react accordingly. For example the steering motor is synchronized back, meaning that it moves from the central position to the current position of the steering wheel.

Finally, note that the first line of the remote’s display shows current voltage of remote’s and receiver’s battery, allowing to monitor if either of the two bricks is running low on power. The sender program can be aborted by pressing the sender brick’s default exit button twice.

Sender program:

#pragma config(Sensor,S1,touch1,sensorTouch)
#pragma config(Sensor,S2,touch2,sensorTouch)

bool sending = false;
int soundLevel = 1;

task BatLev()
{
  ubyte valueReceived[1];
  valueReceived[0] = 0;
  while(true)
  {
    cCmdMessageRead(valueReceived, 1, 1);
    nxtDisplayCenteredTextLine(0, "BAT: L%3.1f / R%3.1f", nImmediateBatteryLevel / (float) 1000, valueReceived[0] / (float) 10);
    wait1Msec(50);
  }
  return;
}

task Buttons()
{
  nNxtButtonTask  = -2;
  nNxtExitClicks = 2;
  nxtDisplayCenteredTextLine(1, "Not sending...");
  while(true)
  {
    if(nNxtButtonPressed == 3)
    {
      PlaySound(soundBeepBeep);
      if(sending == false){
        sending = true;
        nxtDisplayCenteredTextLine(1, "Sending...");
      }
      else{
        sending = false;
        ubyte valueToReset[5];
        valueToReset[0] = 0;
        valueToReset[1] = 0;
        valueToReset[2] = 0;
        valueToReset[3] = 0;
        valueToReset[4] = soundLevel;
        cCmdMessageWriteToBluetooth(valueToReset, 5, 1);
        nxtDisplayCenteredTextLine(1, "Not sending...");
      }
    }
    else if (nNxtButtonPressed == 1 && soundLevel < 3) soundLevel = soundLevel + 1;
    else if (nNxtButtonPressed == 2 && soundLevel > 0) soundLevel = soundLevel - 1;
  wait1Msec(350);
  }
}

task main()
{
  StartTask(BatLev);
  StartTask(Buttons);
  bFloatDuringInactiveMotorPWM = true;
  btConnect(1, "NXT2"); // connection: port, brick
  while(true)
  {
    ubyte valueToSend[5];
    valueToSend[0] = nMotorEncoder[motorA];
    valueToSend[1] = nMotorEncoder[motorB];
    valueToSend[2] = SensorValue(touch1);
    valueToSend[3] = SensorValue(touch2);
    valueToSend[4] = soundLevel;
    if(sending == true){cCmdMessageWriteToBluetooth(valueToSend, 5, 1);}
    nxtDisplayTextLine(3, "Drive: %d", valueToSend[0]);
    nxtDisplayTextLine(4, "Steering: %d", valueToSend[1]);
    nxtDisplayTextLine(5, "Touch BLUE: %d", valueToSend[2]);
    nxtDisplayTextLine(6, "Touch RED: %d", valueToSend[3]);
    nxtDisplayTextLine(7, "Volume: %d", valueToSend[4]);
    wait1Msec(50);
  }
}
									

Receiver program:

// config start
//bMotorReflected[motorA] = true;
//bMotorReflected[motorB] = true;
//bMotorReflected[motorC] = true;
bool buzzOnRev = true; // buzzing while on reverse
int steerAcc = 10; // steering accuracy margin (degrees)
// config end

task BatLev()
{
  while(true)
  {
    nxtDisplayCenteredTextLine(0, "BAT: L %3.1fV", nImmediateBatteryLevel / (float) 1000);
    ubyte valueToSend[1];
    valueToSend[0] = nImmediateBatteryLevel / (float) 100;
    cCmdMessageWriteToBluetooth(valueToSend, 1, 1);
    wait1Msec(50);
  }
  return;
}

task main()
{
  StartTask(BatLev);
  nVolume = 1; // starting volume
  ubyte valueReceived[5];
  valueReceived[0] = 0;
  valueReceived[1] = 0;
  valueReceived[2] = 0;
  valueReceived[3] = 0;
  valueReceived[4] = 1;

  while(true)
  {
    cCmdMessageRead(valueReceived, 5, 1);
    nxtDisplayTextLine(2, "Drive: %d", valueReceived[0]);
    nxtDisplayTextLine(3, "Steering: %d", valueReceived[1]);
    nxtDisplayTextLine(4, "Touch BLUE: %d", valueReceived[2]);
    nxtDisplayTextLine(5, "Touch RED: %d", valueReceived[3]);
    nxtDisplayTextLine(6, "Volume: %d", valueReceived[4]);
    nVolume = valueReceived[4];

    // motorA (drive)
    motor[motorA] = 0;
    int afactor = valueReceived[0] / 5;
    if (afactor > 1 && afactor < 15)
    {
      afactor = afactor * 10;
      if (afactor > 100) afactor = 100;
      motor[motorA] = afactor;
      if (buzzOnRev == true) ClearSounds();
    }
    else if (afactor > 1 && afactor > 25)
    {
      afactor = (51 - afactor) * -10;
      if (afactor < -100) afactor = -100;
      motor[motorA] = afactor;
      if (buzzOnRev == true) PlaySound(soundException);
    }

    // motorB (steering)
    motor[motorB] = 0;
    int bfactor = valueReceived[1];
    if (bfactor > 1 && bfactor < 75) bfactor = bfactor;
    else if (bfactor > 1 && bfactor > 75) bfactor = (256 - bfactor) * -1;
    nxtDisplayTextLine(7,"Mtr B: %d/%d",nMotorEncoder[motorB], bfactor);

    if (nMotorEncoder[motorB] < (bfactor + steerAcc)) while(nMotorEncoder[motorB] < bfactor) motor[motorB] = 10;
    else if (nMotorEncoder[motorB] > (bfactor - steerAcc)) while(nMotorEncoder[motorB] > bfactor) motor[motorB] = -10;
    else motor[motorB] = 0;

    // motorC
    motor[motorC] = 0;
    if (valueReceived[2] == 1) motor[motorC] = 100;
    else if (valueReceived[3] == 1)motor[motorC] = -100;

    wait1Msec(50);
  }
}
									

Photos:

Video: