Inaccuracy from Low Voltage

[NabeelZ-KA]

Hello!!
I'm currently working with PyBricks V2.0.0 for the EV3 for the WRO competition. A high degree of accuracy is needed.

This is the first competition we use PyBricks in, since we usually use EV3-G. In EV3-G, we still faced problems with the robot becoming less accurate, and not moving correctly (moving not straight and not going the full length) over time as the charge decreased. However, this problem has been exasperated with PyBricks, where once the battery is lower than ~8.26 volts it starts going haywire (our maximum for the battery is ~8.41 volts after a full charge). This happens over the span of ~15 minutes and we have to charge again. This is most likely not a programing issue (as stated in a previous thread).

Here is our main movement function for example:

   def accelerate(self, target_speed, rotations, direction=1, increment=5, Kp = -1, Ki = -1, Kd = -1):
        if (Kp < 0):
            Kp = self.Kp * Kp / -1
        if (Ki < 0):
            Ki = self.Ki * Ki / -1
        if (Kd < 0):
            Kd = self.Kd * Ki / -1

        self.gyro.reset_angle(0)
        self.motor_right.reset_angle(0)
        self.motor_left.reset_angle(0)
        p = 0
        i = 0
        d = 0
        speed = 0
        lastError = 0
        targetPosition = rotations * direction * 360

        if direction == 1:
            condition = lambda:  (self.motor_right.angle() + self.motor_left.angle()) / 2 < targetPosition
        else:
            condition = lambda:  (self.motor_right.angle() + self.motor_left.angle()) / 2 > targetPosition

        while condition():
            error = self.gyro.speed()
            p = error
            i = i + error
            d = error - lastError
            correction = p * Kp + i * Ki + d * Kd
            if ((abs(self.motor_right.angle()) / targetPosition) > 0.95):
                speed -= increment
            else:
                if speed < target_speed:
                    speed += increment
                    if speed > target_speed:
                        speed = target_speed

            self.drive.drive(speed * direction, max(-100, (min(100, correction))) * direction * -1)
            lastError = error
            wait(5)
        self.gyro.reset_angle(0)
        self.drive.stop()
        self.motor_right.reset_angle(0)
        self.motor_left.reset_angle(0)
        self.motor_right.hold()
        self.motor_left.hold()
        wait(150)

Please, how can we mitigate this?

[laurensvalk]

If you are going to build your own PID controller, you might want to use the dc method on the motors directly. The drive method is already a PID controller, so adding your own on top doesn't usually work as intended.

[NabeelZ-KA]

But that can't be the entire issue with the charge, right? Is there any way to fix that?

[laurensvalk]

It's hard to say. If you have two aggressively tuned PID controllers then battery level matters.

In a month or so we should have a big update for EV3 that should make the motors work a lot better, but this might not be in time for your WRO match.

[NabeelZ-KA]

Not to sound stupid or anything, but how big of a difference would this make? And what is the maximum amount of time could it take to release, because we don't have much time till we start coding for FLL. Also the normal DriveBase drive isn't that accurate which is why we made our own PID.

[NabeelZ-KA]

Also would using newer (less supported) firmware be more accurate? And possible more charge efficient?

[laurensvalk]

It looks like you might want to use the gyro angle for the error, not the speed, right? Speed is already a "D" term. Taking another derivative as in your code can easily lead to instability. So it becomes "sensitive to going haywire" when other small things change, like the battery level.

So rather than tweaking things around the edges, perhaps consider taking a step back and analyze what you would like to code. Then carefully test the function that you wrote, using only one movement at a time and verify that it does what you expect. When that is all good, you can begin putting multiple moves together in a big program.