PIC18 Robot - Travelling exact distance straight using two wheel encoders problems

Question

(EDIT: Added TMR0 & TMR1 set-up code)

I have a small robot vehicle controlled by a PIC18f4585. It has two wheels (ball bearing on the front) as well as two rotary encoders. The following function is supposed to travel a specified distance in inches perfectly straight. It travels straight enough, the problem is the distance. the travelled distance has an error of up to 2cm. I was just wondering whether anyone else could see an error I have missed.

Additional info: The PIC is clocked at 40MHz. I am counting the encoder ticks using TMR0 and TMR1 in 8-bit mode.

Any help/suggestions would be greatly appreciated, thanks.

TMR CONFIG:

TRISAbits.TRISA4 = IO_INPUT; 
    OpenTimer0( TIMER_INT_OFF &
            T0_8BIT &
            T0_SOURCE_EXT &
            T0_EDGE_RISE &
            T0_PS_1_1   );

TRISCbits.TRISC0 = IO_INPUT;
OpenTimer1( TIMER_INT_OFF &
        T1_8BIT_RW &
        T1_SOURCE_EXT &
        T1_PS_1_1 & 
        T1_OSC1EN_OFF &
        T1_SYNC_EXT_ON  );

MOVE STRAIGHT FUNCTION:

void moveForwardDistance(double distance, int power)
{
int tickGoal = distance * 5.13348;      //This seems to get ~the correct distance

int masterPower = power;
int slavePower = power;
int error = 0;
int kp = 50;            //error factor
int totalTicks = 0;     //used to keep track of total ticks

resetEncoder();

while(totalTicks < tickGoal)
{
    SetRightMotor(masterPower);
    SetLeftMotor(slavePower);

    error = TMR1L - TMR0L;
    slavePower = power + (error / kp);

    resetEncoder();
    DelayMs(100);
    totalTicks += TMR1L;
}
SetRightMotor(0);
SetLeftMotor(0);

DelayS(1);
}

Answer 1

Sounds like you are missing encoder ticks when your CPU is busy with other tasks.

Your Robot is executing code in a loop and the loop times are approximately constant so you are missing the same number of ticks (roughly) in each loop. You've calibrated this error out of your system.

However, occasionally, you get unlucky and the loop runs longer and you miss more ticks than average.

It is impossible to decode/debug/double-check your firmware with the snippet provided since the register-level configuration of the hardware input capture unit is omitted. I'd look there.

Answer 2

The example you cited in your comments is just wrong. Sorry, but that happens sometimes.

Conceptually, what you are trying to do is transfer the value from the 8-bit hardware counter to a 16-bit (or more) software counter. The problem with this is that the hardware counter can advance by one tick at any time, including between when you read it and when you reset it.

The example code has many problems with implementing this transfer, and clearing the hardware counter before adding it to the software counter is just the most egregious of them. Reading the hardware counter multiple times is another problem, and allowing an arbitrary amount of time to elapse between reading and clearing is another.

Ideally, you'd like to have zero time between the reading and the clearing, but this is not going to be possible. The next best thing would be to write a function (possibly in assembly language) that reads both counters, resets them in the fewest instructions absolutely possible, and then saves the values read in the first step into variables that the rest of the program can use.

In C, this function would look something like this:

unsigned char tmr0_value;
unsigned char tmr1_value;

void read_and_reset_timers (void)
{
   register unsigned char tmr0_temp;
   register unsigned char tmr1_temp;

   /* Read the two timers into CPU registers and reset them
    * as quickly as absolutely possible.
    */
   tmr0_temp = TMR0L;
   TMR0L = 0;
   tmr1_temp = TMR1L;
   TMR1L = 0;

   /* Now, write the values to global variables.
    * It is less critical how long this takes.
    */
   tmr0_value = tmr0_temp;
   tmr1_value = tmr1_temp;
}

You would then use this in your main loop like this:

void moveForwardDistance (double distance, int power)
{
  int tickGoal = distance * 5.13348;      //This seems to get ~the correct distance

  int masterPower = power;
  int slavePower = power;
  int error = 0;
  int kp = 50;            //error factor
  int totalTicks = 0;     //used to keep track of total ticks

  read_and_reset_timers();

  while (totalTicks < tickGoal) {
    SetRightMotor (masterPower);
    SetLeftMotor (slavePower);

    read_and_reset_timers();
    error = tmr1_value - tmr0_value;
    totalTicks += tmr1_value;
    slavePower = power + (error / kp);

    DelayMs(100);
  }

  SetRightMotor(0);
  SetLeftMotor(0);

  DelayS(1);
}