Mechanical / Machine Design

For the transport mechanics, I acquired:

• A stepper motor
• A threaded rod
• A connector to couple the stepper with the rod
• Nnuts to match then rod
• A switch to detect start

First, I designed and 3D printed a box with a hole to hold the nuts in place, to see if that would create the sliding motion I had in mind. It took a couple of iterations to get the guiding nuts to fit properly. I ended up embedding smaller nuts within the print (see top of the model in figure 2) by pausing the print and dropping them in. These allow attaching an arm to the carriage, which should push the pans.

Adjusting the base frame and adding bars to attach parts, we discovered that although the extrusion parts look similar, their slots varied slightly, making it difficult to find combinations at actually fit.

Next, I started modeling a part to attach the stepper motor to the frame. However, I realised it would be more effective to design small part to slide on the extrusions so we could use zip ties.

I created the above by downing a step-file from the aluminium extrusion product page, converting that to an stl-file in FreeCAD (because OpenSCAD does not support step-files), and using that to subtract from a foot print. Well, it was a slightly fatter version I created using the minkowski function.

• rail step-file
• rail stl-file
• fatter variant

For the end of the rail I created simple stop to hold the rod in its place using the same footprint trick to make it attachable to the rail.

With the mechanics (literally) tied down on the frame, it was time to work on the electronics. First, I reproduced the stepper motor experiment we did as a group in week 10 on a breadboard; an RP2040, a Pololu DRV8825 Stepper Motor Driver, a stepper motor, a workbench power supply and drv8825.py.

The motor was very noisy. Increasing the step frequency from 200Hz to 1kHz helped but then it started skipping. I used Leo's and Henk's documentation to try and set the current limit on the driver board but could not get it stable. Following the video on the Pololu product page, I only read 12V with the multimeter on the ground and potentiometer instead of the 1V I should have been reading. Frustrated, I started swapping out parts to see if that helped. I ended up using a lighter stepper motor which ran smoothly.

With it stable, I started designing a PCB to hookup everything, including a switch and connectors for I²C. The stepper driver is already on a PCB with stacking pins soldered onto it. Unfortunately, there is no "socket" for this in the FabLib but there is a through hole footprint. I used that to carefully place pin sockets on the PCB for fitting the driver board onto our board. This does violate some design rules because the pin sockets are very close together and they seem to overlap, but (like the XIAO socket footprint) they do not in practice.

The first thing I implemented was homing: the carriage needs to run back to the start point, which is detected by pressing a switch. The driver library I used allows sending commands to the stepper, such as "take 200 steps" (a full revolution), and returns immediately (it uses a hardware timer to run the motor).

I allowed stopping the motor under certain some conditions (switch pressed in our case) by changing the library to add a callback in the timer event handler to allow the code to stop the motor. Below is the change I made:

--- drv8825.orig.py
+++ drv8825.py
@@ -87,6 +87,7 @@
                  microstep_pins=None,
                  sleep_pin=None,
                  reset_pin=None,
+                 timer_callback=None,
                  timer_id=-1,
                  steps_per_revolution=200):
         """
@@ -99,6 +100,7 @@
         <timer_id>  (number) timer to use for step timing, the default
                     value -1 (last timer) usually works on most boards
         <steps_per_revolution> (number) Full steps for 360 degrees revolution
+        <timer_callback> (function) called at the start of the internal timer callback
         Notes: - <step_pin> is mandatory.
                - other pins are optional (presumably fixed wired)
                - instances of DRV8825 are started enabled.
@@ -126,6 +128,10 @@
         self._actual_pos = 0                    # actual position
         self._target_pos = 0                    # target position

+        self.timer_callback = None
+        if timer_callback is not None:
+            self.timer_callback = timer_callback
+
     def enable(self):
         """ Enable the DRV8825
             When pins for sleep and reset are not specified
@@ -169,6 +175,9 @@
         self._timer.deinit()                    # (running or not)
         self._timer_running = False

+    def is_running(self):
+        return self._timer_running == True
+
     def resolution(self, microsteps=1):
         """ method to set step number of microsteps per full step
             <microsteps> supported values: 1,2,4,8,16,32
@@ -195,14 +204,22 @@
             self._actual_pos -= 1
             self._step_pin.off()

+    def set_timer_callback(self, f):
+        self.timer_callback = f
+
     def _timer_callback(self, t):
         """ determine if stepping action opportune
             if true perform one step forward or backward
         """
-        if self._free_run_mode != 0:
-            self.one_step(1 if self._free_run_mode > 0 else -1)
-        elif self._target_pos != self._actual_pos:  # target not reached yet
-            self.one_step(1 if self._target_pos > self._actual_pos else -1)
+
+        if self.timer_callback is not None:
+            self.timer_callback(self)
+
+        if self._timer_running == True: # not stopped by timer_callback
+            if self._free_run_mode != 0:
+                self.one_step(1 if self._free_run_mode > 0 else -1)
+            elif self._target_pos != self._actual_pos:  # target not reached yet
+                self.one_step(1 if self._target_pos > self._actual_pos else -1)

     def steps(self, steps, microsteps=1, stepfreq=200):
         """  move stepper motor a number of steps:

With the above changes in place, I implemented the home function which runs the carriage backward until the switch is pressed and then forward until it is released. At the start point, it sets the global variable stepper_position to 0.

stepper_position = None

def stop_on_sw_0(stepper):
    if home_sw.value() == 0:
        stepper.stop()

def stop_on_sw_1(stepper):
    if home_sw.value() == 1:
        stepper.stop()

def wait_until_stepper_done(stepper):
    while stepper.is_running():
        sleep_ms(100)

def home():
    global stepper_position

    stepper = DRV8825(PIN_STEP, direction_pin=PIN_DIR, timer_callback=stop_on_sw_0)
    stepper.freerun(stepfreq=-1000)
    wait_until_stepper_done(stepper)

    stepper = DRV8825(PIN_STEP, direction_pin=PIN_DIR, timer_callback=stop_on_sw_1)
    stepper.freerun(stepfreq=1000)
    wait_until_stepper_done(stepper)

    stepper_position = 0

I ran it to the end of the track, keeping track of the steps. I found it takes roughly 96880 steps for 600mm. This allowed me to write a goto function.

TRACK_LENGTH_STEPS = 96880
TRACK_LENGTH_MM = 600
STEPS_PER_MM = int(TRACK_LENGTH_STEPS / TRACK_LENGTH_MM)

def goto(position_in_mm):
    global stepper_position
    new_position = STEPS_PER_MM * position_in_mm

    if stepper_position is None:
        home()

    steps = new_position - stepper_position
    stepper = DRV8825(PIN_STEP, direction_pin=PIN_DIR)
    stepper.steps(steps, stepfreq=1000)
    wait_until_stepper_done(stepper)

    stepper_position = new_position

We connected all the boards to the peripherals and started test runs.

After a lot of tweaks, we settled on 6 seconds of batter dispension and 20 minutes of baking time. It is far from perfect..