Final Project

The parts from the list above that were 3D printed were:

• 02_supports
• 03_sliding stopper
• 05_container box
• 06_Slide
• 07_Lid
• 08_back cover
• 09_screw support
• 12_Roller
• 13_Ceiling
• 14_stepper motor mount
• 15_bending

Note: For the "12_Roller" piece, it was necessary to sand it with 220-grit sandpaper and then hot-glue a piece of 220-grit sandpaper onto it to increase the contact surface. This is because this piece is responsible for making the rubber conveyor belt rotate.

The parts to be laser cut are the following:

• 01_side wall
• 04_bottom wall
• 10_main wall
• 11_side wall with holes

The explanation of the vectorizing process is in Week 2 of Fab Academy: (Daniela Barranco - Week 02)

Notes on the entire laser cutting process:

• Operation order: Engraving must be done first, followed by cutting.
• Engraving: It is important to select the "Fill" button at 100%. Additionally, before sending to cut, all components to be cut or engraved must be selected, and it is essential to click the "Group" button.

Microcontroller: Raspberry Pi Pico 2W

Drivers: 8825

The interface was developed in Week 14. To see the full process of how it was made, refer to that week's documentation.

Daniela Barranco - Week 14

#include <AccelStepper.h>                          // Includes the AccelStepper library for non-blocking stepper motor control with acceleration ramps

#include <WiFi.h>                                  // Includes the built-in WiFi driver for the Pico 2W

#include <PubSubClient.h>                          // Includes the MQTT client library used to publish/subscribe to the broker

#include <ArduinoJson.h>                           // Includes the JSON library used to build and parse MQTT payloads

// --- WiFi and MQTT ---

const char* WIFI_SSID     = "Mihotspot";           // Stores the WiFi network name the board will connect to

const char* WIFI_PASSWORD = "12345678";            // Stores the WiFi password for that network

const char* MQTT_BROKER   = "broker.hivemq.com";   // Stores the address of the public MQTT broker used as the message relay

const int   MQTT_PORT     = 1883;                  // Stores the standard TCP port used for MQTT (non-WebSocket)

const char* TOPIC_CONFIG  = "ibero/arquitecturas/config";   // Topic the board subscribes to in order to receive batch configuration

const char* TOPIC_CONTROL = "ibero/arquitecturas/control";  // Topic the board subscribes to in order to receive INICIAR/DETENER commands

const char* TOPIC_SENSOR  = "ibero/arquitecturas/sensor";   // Topic the board publishes to in order to report live progress

#define STEP_PIN      2                            // Maps GPIO 2 to send step pulses to the DRV8825 driver

#define DIR_PIN       1                             // Maps GPIO 1 to set the motor's rotation direction

#define ENABLE_PIN    0                             // Maps GPIO 0 to enable/disable the DRV8825 driver (active-low)

#define Fisic_boton   3                             // Maps GPIO 3 to read the physical push button

#define FULL_STEPS_PER_REV 200                      // Defines the motor's native resolution: 200 full steps per revolution (1.8° per step)

#define MICROSTEP          1                        // Defines the microstepping mode as 1 (full-step mode)

const long  STEPS_RIGHT = (FULL_STEPS_PER_REV * MICROSTEP) / 4.30;  // Calculates the number of steps for the rightward movement

const long  STEPS_LEFT  = (FULL_STEPS_PER_REV * MICROSTEP) / 5.30;  // Calculates the number of steps for the leftward movement

const float MAX_SPEED   = 1000.0;                   // Sets the maximum motor speed in steps per second

const float ACCEL       = 2000.0;                   // Sets the motor's acceleration in steps per second squared

AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);  // Creates the stepper motor object using the 2-wire driver interface

WiFiClient   wifiClient;                            // Creates the underlying TCP client used for the MQTT connection

PubSubClient mqttClient(wifiClient);                // Creates the MQTT client, built on top of the WiFi TCP client

// --- Motor state ---

bool running   = false;                             // Tracks whether the motor sequence is currently active

int  stage     = 0;                                 // Tracks which stage of the cycle is running (0 = right, 1 = left)

bool waiting   = false;                              // Tracks whether the system is currently in the pause between movements

unsigned long waitStart = 0;                         // Stores the timestamp (millis) when the current pause started

// --- Batch counters ---

String lote              = "";                       // Stores the name of the current batch, received from the dashboard

int cristalesPorSerie    = 0;                        // Stores how many crystals make up one series, received from the dashboard

int totalSeries          = 0;                        // Stores the total number of series in the batch, received from the dashboard

int cristalActual        = 0;                        // Counts how many crystals have been completed in the current series

int serieActual          = 1;                        // Tracks which series number is currently in progress

bool configRecibida      = false;                    // Flags whether a valid batch configuration has been received

// --- Physical button debounce ---

bool lastButtonState     = LOW;                      // Stores the raw button reading from the previous loop pass

bool buttonState         = LOW;                      // Stores the debounced (confirmed) button state

bool waitingForRelease   = false;                    // Flags whether the system is waiting for the button to be physically released before accepting a new press

unsigned long lastDebounceTime = 0;                  // Stores the timestamp of the last detected change in button reading

const unsigned long DEBOUNCE_DELAY = 50;             // Defines how many milliseconds to wait before trusting a button state change

// --- Non-blocking MQTT reconnection ---

unsigned long lastReconnectAttempt = 0;              // Stores the timestamp of the last MQTT reconnection attempt

void enableDriver(bool enable) {                     // Defines a function to turn the stepper driver on or off

  digitalWrite(ENABLE_PIN, enable ? LOW : HIGH);     // Writes LOW to enable the driver (active-low) or HIGH to disable it

}

// --- Publish state to dashboard ---

void publicarEstado(const char* estado) {            // Defines a function that publishes the current production state to the dashboard

  StaticJsonDocument<256> doc;                       // Allocates a 256-byte JSON document on the stack

  doc["estado"]              = estado;               // Adds the current state string (e.g. "ensamblando") to the JSON

  doc["cristal_actual"]      = cristalActual;        // Adds the current crystal count to the JSON

  doc["serie_actual"]        = serieActual;          // Adds the current series number to the JSON

  doc["cristales_por_serie"] = cristalesPorSerie;    // Adds the configured crystals-per-series value to the JSON

  doc["total_series"]        = totalSeries;          // Adds the configured total series value to the JSON

  doc["lote"]                = lote;                 // Adds the batch/lot name to the JSON

  char buffer[256];                                  // Declares a character buffer to hold the serialized JSON string

  serializeJson(doc, buffer);                        // Converts the JSON document into a string and stores it in buffer

  mqttClient.publish(TOPIC_SENSOR, buffer);          // Publishes the JSON string to the sensor topic, sending it to the dashboard

  Serial.print("[PUB] ");                            // Prints a label to the Serial Monitor for debugging

  Serial.println(buffer);                            // Prints the published JSON content to the Serial Monitor

}

// --- Shared function: START ---

void iniciarSecuencia() {                            // Defines the function that starts the motor sequence

  if (!running) {                                    // Only starts if the sequence is not already running

    running = true;                                  // Marks the sequence as active

    stage   = 0;                                     // Resets the cycle to stage 0 (right movement)

    waiting = false;                                 // Clears any pending wait state

    stepper.moveTo(stepper.currentPosition() + STEPS_RIGHT);  // Commands the motor to move STEPS_RIGHT steps from its current position

    Serial.println("\n[INFO] Sequence STARTED.");    // Logs that the sequence started

    Serial.println("[MOTOR] Moving RIGHT...");       // Logs that the motor is moving right

  }

}

// --- Shared function: STOP ---

void detenerSecuencia(bool esEmergencia) {           // Defines the function that stops the motor sequence; takes a flag indicating if it's an emergency stop

  if (running) {                                     // Only stops if the sequence is currently running

    running = false;                                 // Marks the sequence as inactive

    waiting = false;                                 // Clears any pending wait state

    stage   = 0;                                     // Resets the cycle stage back to 0

    stepper.setCurrentPosition(stepper.currentPosition());  // Forces the library to treat the current position as the target, halting movement instantly

    if (esEmergencia) {                              // If this stop was triggered remotely (emergency stop)

      publicarEstado("detenido");                    // Publishes a "detenido" status to notify the dashboard

      Serial.println("\n[EMERGENCY STOP] Sequence stopped by emergency command.");  // Logs the emergency stop event

    } else {                                         // If this stop was triggered by the physical button

      Serial.println("\n[INFO] Sequence STOPPED safely.");  // Logs a normal stop event

    }

  }

}

// --- MQTT Callback ---

void mqttCallback(char* topic, byte* payload, unsigned int length) {  // Defines the function that runs automatically whenever a subscribed message arrives

  StaticJsonDocument<256> doc;                       // Allocates a 256-byte JSON document to hold the parsed payload

  DeserializationError err = deserializeJson(doc, payload, length);  // Attempts to parse the incoming payload as JSON

  if (err) return;                                   // Exits the function early if the JSON could not be parsed

  if (String(topic) == TOPIC_CONFIG) {               // Checks if the message arrived on the config topic

    lote              = doc["lote"].as<String>();    // Extracts and stores the lot name from the JSON

    cristalesPorSerie = doc["cristales_por_serie"];  // Extracts and stores the crystals-per-series value

    totalSeries       = doc["total_series"];         // Extracts and stores the total series value

    cristalActual     = 0;                           // Resets the crystal counter for the new batch

    serieActual       = 1;                           // Resets the series counter for the new batch

    configRecibida    = true;                        // Marks that a valid configuration has been received

    Serial.println("[CONFIG] Batch configuration received.");  // Logs that a configuration arrived

    Serial.print("         Lot: ");          Serial.println(lote);              // Prints the received lot name

    Serial.print("         Crystals/series: "); Serial.println(cristalesPorSerie);  // Prints the received crystals-per-series value

    Serial.print("         Total series: "); Serial.println(totalSeries);       // Prints the received total series value

  }

  else if (String(topic) == TOPIC_CONTROL) {         // Checks if the message arrived on the control topic

    String comando = doc["comando"].as<String>();    // Extracts the command string from the JSON

    if (comando == "INICIAR") {                      // Checks if the command is to start

      if (configRecibida) {                          // If a configuration is already loaded

        cristalActual = 0;                           // Resets the crystal counter before starting

        serieActual   = 1;                           // Resets the series counter before starting

      }

      iniciarSecuencia();                            // Calls the function that starts the motor sequence

    } else if (comando == "DETENER") {                // Checks if the command is to stop

      detenerSecuencia(true);                        // Calls the stop function, flagged as an emergency stop

      waitingForRelease = false;                     // Clears the button release-wait flag, since this stop came from MQTT, not the button

      lastButtonState   = LOW;                       // Resets the last button reading

      buttonState       = LOW;                       // Resets the debounced button state

    }

  }

}

// --- WiFi ---

void connectWiFi() {                                  // Defines the function that connects the board to WiFi

  Serial.print("[WiFi] Connecting to ");              // Prints a label before the network name

  Serial.println(WIFI_SSID);                          // Prints the network name being connected to

  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);                // Starts the WiFi connection attempt with the given credentials

  int intentos = 0;                                    // Declares a counter for connection attempts

  while (WiFi.status() != WL_CONNECTED && intentos < 40) {  // Loops until connected or 40 attempts (20 seconds) have passed

    delay(500);                                        // Waits half a second between checks

    Serial.print(".");                                 // Prints a dot to show progress

    intentos++;                                        // Increments the attempt counter

  }

  Serial.println();                                    // Prints a newline after the dots

  if (WiFi.status() == WL_CONNECTED) {                 // Checks if the connection succeeded

    Serial.print("[WiFi] Connected. IP: ");            // Prints a success label

    Serial.println(WiFi.localIP());                    // Prints the IP address assigned to the board

  } else {                                              // If the connection failed

    Serial.println("[WiFi] Connection failed. Check SSID/password.");  // Prints a failure message

  }

}

// --- Non-blocking MQTT reconnection ---

bool reconnectMQTT() {                                 // Defines a function that attempts a single MQTT reconnection

  String clientId = "pico2w_crystal_" + String(random(0xffff), HEX);  // Builds a random unique client ID for this connection attempt

  if (mqttClient.connect(clientId.c_str())) {          // Tries to connect to the broker with that client ID

    mqttClient.subscribe(TOPIC_CONFIG);                // Subscribes to the config topic on success

    mqttClient.subscribe(TOPIC_CONTROL);               // Subscribes to the control topic on success

    Serial.println("[MQTT] Connected and subscribed."); // Logs that the connection and subscriptions succeeded

    return true;                                       // Returns true to indicate success

  }

  return false;                                         // Returns false if the connection attempt failed

}

void setup() {                                          // Runs once when the board powers on

  Serial.begin(115200);                                 // Opens the Serial Monitor connection at 115200 baud

  delay(1000);                                          // Waits one second to let the Serial Monitor stabilize

  pinMode(ENABLE_PIN, OUTPUT);                          // Configures the driver enable pin as an output

  pinMode(Fisic_boton, INPUT);                          // Configures the button pin as an input (relies on external pull-down)

  enableDriver(true);                                   // Enables the stepper driver immediately

  stepper.setMaxSpeed(MAX_SPEED);                        // Applies the maximum speed setting to the stepper object

  stepper.setAcceleration(ACCEL);                        // Applies the acceleration setting to the stepper object

  Serial.println("═══════════════════════════════════════");  // Prints a visual divider

  Serial.println("   CRYSTAL_CUT_V4 - Raspberry Pi Pico 2W");  // Prints the project title

  Serial.println("═══════════════════════════════════════");  // Prints another visual divider

  connectWiFi();                                         // Calls the function to connect to WiFi

  mqttClient.setServer(MQTT_BROKER, MQTT_PORT);          // Configures the MQTT client with the broker address and port

  mqttClient.setCallback(mqttCallback);                  // Registers mqttCallback as the function to run on incoming messages

  reconnectMQTT();                                       // Performs the initial MQTT connection attempt

  Serial.println("[INFO] System ready. Waiting for commands...");  // Logs that setup is complete

}

void loop() {                                            // Runs continuously after setup()

  // --- Maintain MQTT connection ---

  if (!mqttClient.connected()) {                         // Checks if the MQTT connection has dropped

    unsigned long now = millis();                        // Reads the current timestamp

    if (now - lastReconnectAttempt > 5000) {              // Checks if at least 5 seconds have passed since the last attempt

      lastReconnectAttempt = now;                         // Updates the timestamp of this attempt

      if (reconnectMQTT()) lastReconnectAttempt = 0;       // Attempts to reconnect; resets the timer if successful

    }

  } else {                                                 // If MQTT is connected

    mqttClient.loop();                                    // Processes incoming MQTT messages and maintains the connection

  }

  // --- Physical button ---

  bool reading = digitalRead(Fisic_boton);                // Reads the current raw state of the physical button

  if (waitingForRelease) {                                 // Checks if the system is waiting for the button to be released

    if (reading == LOW) {                                  // If the button has been physically released

      waitingForRelease = false;                           // Clears the release-wait flag

      lastButtonState   = LOW;                              // Resets the last button reading

      buttonState       = LOW;                              // Resets the debounced button state

      lastDebounceTime  = millis();                          // Records the current time as the new debounce reference

    }

    stepper.run();                                          // Still runs the stepper engine even while waiting for release

    return;                                                 // Exits the loop early, skipping the rest of the logic this pass

  }

  if (reading != lastButtonState) {                         // Checks if the raw reading changed since the last pass

    lastDebounceTime = millis();                            // Resets the debounce timer whenever the reading changes

  }

  if ((millis() - lastDebounceTime) > DEBOUNCE_DELAY) {     // Checks if the reading has been stable longer than the debounce delay

    if (reading != buttonState) {                            // Checks if this stable reading differs from the last confirmed state

      buttonState = reading;                                 // Updates the confirmed button state

      if (buttonState == HIGH) {                              // Checks if the confirmed state is a press (HIGH)

        if (!running) {                                       // If the motor sequence is currently stopped

          if (configRecibida) {                                // If a valid batch configuration exists

            cristalActual = 0;                                 // Resets the crystal counter before starting

            serieActual   = 1;                                 // Resets the series counter before starting

          }

          iniciarSecuencia();                                  // Starts the motor sequence

        } else {                                                // If the motor sequence is currently running

          detenerSecuencia(false);                             // Stops the sequence, flagged as a normal (non-emergency) stop

          waitingForRelease = true;                             // Sets the flag so the next press requires a full release first

        }

      }

    }

  }

  lastButtonState = reading;                                  // Stores this pass's raw reading for comparison on the next pass

  if (!running) {                                              // If the motor sequence is not active

    stepper.run();                                              // Still calls run() to let any pending deceleration finish

    return;                                                     // Exits the loop early, skipping the state machine below

  }

  // --- State machine ---

  if (waiting) {                                                // Checks if the system is currently in the pause between movements

    if (millis() - waitStart >= 15000) {                        // Checks if 15 seconds have elapsed since the pause started

      waiting = false;                                          // Ends the pause

      stage++;                                                  // Advances to the next stage

      if (stage > 1) stage = 0;                                 // Wraps the stage back to 0 after stage 1

      if (stage == 0) {                                         // If the new stage is 0 (about to move right again)

        cristalActual++;                                        // Counts the just-completed cycle as one finished crystal

        Serial.print("[CRYSTAL] ");                             // Prints a label

        Serial.print(cristalActual);                            // Prints the updated crystal count

        Serial.print("/");                                      // Prints a separator

        Serial.print(cristalesPorSerie);                        // Prints the target crystals per series

        Serial.print(" — Series: ");                            // Prints a label

        Serial.print(serieActual);                               // Prints the current series number

        Serial.print("/");                                      // Prints a separator

        Serial.println(totalSeries);                            // Prints the total number of series

        if (configRecibida && cristalActual >= cristalesPorSerie) {  // Checks if the current series is now complete

          publicarEstado("serie_completa");                      // Publishes a "series complete" status to the dashboard

          Serial.print("[SERIES] Series ");                      // Prints a label

          Serial.print(serieActual);                              // Prints the completed series number

          Serial.println(" completed.");                          // Prints the rest of the message

          if (serieActual >= totalSeries) {                       // Checks if that was the last series in the batch

            publicarEstado("lote_completo");                      // Publishes a "batch complete" status to the dashboard

            Serial.println("[BATCH] Batch completed. Motor stopping.");  // Logs that the batch finished

            running       = false;                                // Stops the motor sequence

            waiting       = false;                                // Clears the wait state

            stage         = 0;                                    // Resets the stage

            configRecibida = false;                                // Clears the configuration, requiring a new one before the next batch

            stepper.setCurrentPosition(stepper.currentPosition()); // Halts the motor instantly at its current position

            return;                                                 // Exits the loop early since the batch is done

          } else {                                                  // If more series remain

            serieActual++;                                          // Advances to the next series

            cristalActual = 0;                                      // Resets the crystal counter for the new series

            publicarEstado("ensamblando");                          // Publishes an "assembling" status to the dashboard

          }

        } else if (configRecibida) {                                // If the series is not yet complete but a config exists

          publicarEstado("ensamblando");                            // Publishes an "assembling" status to the dashboard

        }

        stepper.moveTo(stepper.currentPosition() + STEPS_RIGHT);   // Commands the motor to move right again to start the next cycle

        Serial.println("[MOTOR] Moving RIGHT...");                  // Logs that the motor is moving right

      } else if (stage == 1) {                                      // If the new stage is 1 (move left)

        stepper.moveTo(stepper.currentPosition() - STEPS_LEFT);     // Commands the motor to move left

        Serial.println("[MOTOR] Moving LEFT...");                   // Logs that the motor is moving left

      }

    }

  } else {                                                           // If the system is not currently in a pause

    if (stepper.distanceToGo() == 0) {                                // Checks if the motor has finished its current movement

      waiting   = true;                                               // Enters the pause state

      waitStart = millis();                                           // Records the timestamp when the pause started

      Serial.println("[MOTOR] Position reached. Waiting 15 seconds..."); // Logs that the motor reached its target and is pausing

    }

  }

  stepper.run();                                                      // Generates the actual step pulses needed to follow the motion profile, called every loop pass

}

#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>

const char* WIFI_SSID     = "Mihotspot";
const char* WIFI_PASSWORD = "12345678";
const char* MQTT_BROKER   = "broker.hivemq.com";
const int   MQTT_PORT     = 1883;
const char* TOPIC_CONFIG  = "ibero/arquitecturas/config";
const char* TOPIC_CONTROL = "ibero/arquitecturas/control";
const char* TOPIC_SENSOR  = "ibero/arquitecturas/sensor";

WiFiClient   wifiClient;
PubSubClient mqttClient(wifiClient);

void publicarEstado(const char* estado) { ... }
void mqttCallback(char* topic, byte* payload, unsigned int length) { ... }
void connectWiFi() { ... }
bool reconnectMQTT() { ... }

// Inside setup():
connectWiFi();
mqttClient.setServer(MQTT_BROKER, MQTT_PORT);
mqttClient.setCallback(mqttCallback);
reconnectMQTT();

// Inside loop():
if (!mqttClient.connected()) { ... reconnectMQTT(); ... }
else { mqttClient.loop(); }