motors starting in the wrong order

[jeagh]

One last problem and it's driving me crazy. I know the logic is correct. The print statements show that the pen is lifted or lowered in sync with the incoming instructions. The problem is the pen motor is energised after the x and y motors have moved instead of before.

Is there an obvious reason for this or might the problem be elsewhere?

A value of 5 lifts the pen and 0 lowers the pen. I don't know why the code indenting is not displayed correctly here.

from pybricks.hubs import InventorHub
from pybricks.pupdevices import Motor, ColorSensor, UltrasonicSensor
from pybricks.parameters import Button, Color, Direction, Port, Side, Stop
from pybricks.robotics import DriveBase
from pybricks.tools import wait, StopWatch

# Standard MicroPython modules
from usys import stdin, stdout
from uselect import poll

x_motor = Motor(Port.D, Direction.CLOCKWISE)
y_motor = Motor(Port.C, Direction.CLOCKWISE)
z_motor = Motor(Port.A, Direction.CLOCKWISE)

def get_coords(line):
    split_str = line.split()

    # Loop over the split string and find the item that starts with 'X'
    for item in split_str:
        if item.startswith('X'):
            # Extract the value of X by removing the 'X' character
            x_value = item[1:]

        if item.startswith('Y'):
            y_value = item[1:]#-1]  # strip off the trailing ';'

        if item.startswith('Z'):
            z_value = item[1:]

            break
    return (round(float(x_value)), round(float(y_value)), round(float(z_value)))

def pen_up():
    z_motor.track_target(10)
    while not z_motor.done():
        wait(10)

def pen_down():
    z_motor.track_target(0)
    while not z_motor.done():
        wait(10)

# Optional: Register stdin for polling. This allows
# you to wait for incoming data without blocking.
keyboard = poll()
keyboard.register(stdin)

while True:
    # Let the remote program know we are ready for a command.
    stdout.buffer.write(b"rdy")

    # Optional: Check available input.
    
    while not keyboard.poll(0):
        # Optional: Do something here.
        wait(10)
    
    line = stdin.buffer.read(14)

    #print('line = ', line)
    x, y, z = get_coords(line)
    
    #print('x = ', x, ' ', 'y = ', y, ' ', 'z = ', z)
    
    if z == 5:
        pen_up()
        print('pen up')
    else:
        pen_down()
        print('pen down')    

    x_motor.track_target(x * 4)

    y_motor.track_target(y * 4)

    while not x_motor.done() and not y_motor.done():
        wait(10)

[laurensvalk]

Did you mean to use run_target instead of track_target?

[jeagh]

Thank you Laurens for wading through my code.

I thought track_target was the best option, it sounds like I should try run_target instead. Why is track_target the better option in this case?

I'm at this point after more experimenting:

This is what should happen:
The plotter starts at x = 0, y = 0 with the pen up.
Move to 2,2 with the pen up.
Draw to 82,2 with the pen down.

However, the plotter draws to 82, 2 with the pen up and the pen is then lowered once 82,2 is reached.

I've experimented with various delays but still the problem persists. Also, "while not done" does nothing and doesn't seem to be needed because run_target pauses anyway until the target has been reached by default.

So the problem is in the logic but I just cannot see where.

This is the current code which now seems to work 50% of the time correctly. Now I'm wondering if the problem might be that since the pen motor is only moving 10 degrees which seem to make the motor a bit sluggish to get going. Track_target seems to cause the pen motor to be even more sluggish or not even start at all and if it does it moves too late.

If there isn't an obvious logic or code fault then I think this is the end of this project.

x_motor = Motor(Port.D, Direction.CLOCKWISE)
y_motor = Motor(Port.C, Direction.CLOCKWISE)
z_motor = Motor(Port.A, Direction.CLOCKWISE)

coords = [(0,0,5), (2,2,5), (82,2,0), (82,82,0), (2,82,0),
(2,2,0), (13,33,5), (62,33,0), (0,0,5)]

def pen_up():
    z_motor.run_target(500, 10)
    while not z_motor.done():
        wait(10)

def pen_down():
    z_motor.run_target(500, 0)
    while not z_motor.done():
        wait(10)

for x,y,z in coords:
    #print(x,y,z)
    wait(1000) # a delay so I can what's happening
    if z == 5:
        pen_up()
        print('pen up')
    else:
        pen_down()
        print('pen down')    

    x_motor.run_target(500, x * 4)

    y_motor.run_target(500, y * 4)

    while not x_motor.done() and not y_motor.done():
        wait(10)

[laurensvalk]

Have a look at this example. Try running it separately from your plotter project so it's a bit easier to see what is happening:
https://docs.pybricks.com/en/latest/pupdevices/motor.html#waiting-for-two-parallel-actions-to-complete

Notice the use of wait=False: This starts the maneuver while the rest of your program continues. Then you can wait for it to finish by checking the done() state. This could be useful for making the XY motion run in parallel. This seemed to be missing in some of your samples.

For lifting and raising the pen, however, you probably want to leave out the wait argument, so that it defaults to True.

[jeagh]

Thank you again Laurens. I think some of the problem with the pen lift mechanism is mechanical; It's not very ridged.

[jeagh]

At long last I've proven that the problem is mechanical and not software. I mentioned that the motor is sluggish if commanded to only move 10 degrees. Sometimes it moves correctly but often there's a delay before it moves and then it's out of sync with the other motors, even with the while wait loop. That's why I thought track_target was the best option because the motor runs without the start up acceleration but then there's no wait (True or False) option.

Now the problem that I have is how to add gearing to the pen lifter. A 40 degree movement is good but of course this doesn't suit my current pen lifter.