Can't kill main.py?

[FlydGitHub]

I have code that is runng maim.py now I an stuck as I can't kill main.py. Any comments?

import machine, time, utime, gc
from motor import Motor
from encoder import Encoder

class LineFollower:
def init(self, ir_pin1, ir_pin2, right_motor, left_motor):
self.ir1 = machine.Pin(ir_pin1, machine.Pin.IN, machine.Pin.PULL_UP)
self.ir2 = machine.Pin(ir_pin2, machine.Pin.IN, machine.Pin.PULL_UP)
self.right_motor = right_motor
self.left_motor = left_motor

def follow_line(self, speed=40, duration=None):
    start_time = time.ticks_ms()
    while True:
        ir1_val = self.ir1.value()
        ir2_val = self.ir2.value()

        if ir1_val == 0:
            self.right_motor.set_duty_cycle(speed)
        else:
            self.right_motor.stop()

        if ir2_val == 0:
            self.left_motor.set_duty_cycle(speed)
        else:
            self.left_motor.stop()

        if duration is not None and time.ticks_diff(time.ticks_ms(), start_time) >= duration * 1000:
            break

def stop(self):
    self.right_motor.stop()
    self.left_motor.stop()

class Robot:
def init(self, motor_pins, encoder_pins, ir_pins):
self.right_motor = Motor(*motor_pins[0])
self.left_motor = Motor(*motor_pins[1])
self.right_encoder = Encoder(encoder_pins[0], "Right")
self.left_encoder = Encoder(encoder_pins[1], "Left", self.right_encoder)
self.right_encoder.other_encoder = self.left_encoder
self.line_follower = LineFollower(ir_pins[0], ir_pins[1], self.right_motor, self.left_motor)

def run_pwm(self, right_duty_cycle, left_duty_cycle, duration=None, right_forward=True, left_forward=True):
    self.right_motor.set_direction(right_forward)
    self.left_motor.set_direction(left_forward)
    self.right_motor.set_duty_cycle(right_duty_cycle)
    self.left_motor.set_duty_cycle(left_duty_cycle)
    start_time = time.ticks_ms()
    while time.ticks_diff(time.ticks_ms(), start_time) < duration * 1000:
        utime.sleep_ms(10)
    self.right_motor.stop()
    self.left_motor.stop()

def follow_line(self, speed=40, duration=None):
    self.line_follower.follow_line(speed, duration)

def stop(self):
    self.line_follower.stop()

motor_pins = [(12, 26), (18, 16)]
encoder_pins = [10, 7]
ir_pins = [14, 15]

robot = Robot(motor_pins, encoder_pins, ir_pins)

with open("MotorsLog.txt", "w") as file:
robot.right_encoder.enable_interrupt(file)
robot.left_encoder.enable_interrupt(file)

robot.run_pwm(40, 45, 1)  # Run motors with 40% and 45% duty cycle for 1 second
input("Press Enter to continue…")
robot.run_pwm(40, 40, 1)  # Run motors with 40% and 40% duty cycle for 1 second

robot.right_encoder.disable_interrupt()
robot.left_encoder.disable_interrupt()

utime.sleep_ms(1000)

gc.collect()

Start line following

robot.follow_line(speed=40, duration=1)
robot.stop()

END
motor.py
import machine

class Motor:
def init(self, pin1, pin2, freq=20000):
self.pwm = machine.PWM(machine.Pin(pin1))
self.pwm.freq(freq)
self.direction = machine.Pin(pin2, machine.Pin.OUT)

def set_duty_cycle(self, duty_cycle):
   self.pwm.duty_u16(duty_cycle * 65535 // 100)

def stop(self):
    self.pwm.duty_u16(0)

def set_direction(self, forward=True):
    self.direction.value(forward)

END

encoder.py
import machine, _thread, utime

class Encoder:
def init(self, pin, label, other_encoder=None):
self.pin = machine.Pin(pin, machine.Pin.IN, machine.Pin.PULL_UP)
self.label = label
self.count = 0
self.lock = _thread.allocate_lock()
self.other_encoder = other_encoder

def increment_count(self, pin):
    with self.lock:
        self.count += 1
        timestamp = "{:04d}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}".format(*utime.localtime()[:6])
        print(f"{timestamp} - {self.label} encoder count: {self.count}")

def enable_interrupt(self, trigger=machine.Pin.IRQ_FALLING | machine.Pin.IRQ_RISING):
    self.pin.irq(trigger=trigger, handler=self.increment_count)

def disable_interrupt(self):
    self.pin.irq(handler=None)

[FlydGitHub]

Solved - disconnect motors