Embedded Programming

The intention of my project for this week is to make a conveyor belt, because since the "Crystal-Inator" is a production process, it needs to go through several stages. In this first phase of development, I solely focused on having the motor that will turn the belt advance for a certain distance and stop for 5 seconds, which would be the time used to carry out the corresponding process.

My advisor's code

              // Testing Driver, Stepper Motors, and ESP32
              // This code manages a stepper motor using a driver like the A4988.

              #define x_paso 15   // Defines the STEP pin for the X-axis motor
              #define x_dire 2    // Defines the DIR (Direction) pin for the X-axis motor
              #define x_habi 4    // Defines the ENABLE pin for the X-axis motor

              // Global Variables
              int retardo = 3000; // Delay in microseconds. A lower number makes the rotation faster.
              int tiempo = 220;   // The number of steps the motor will take (effectively the duration of the turn).

              // Setup runs once when the board is powered on
              void setup() {
                // Set all motor control pins as OUTPUT so the ESP32 can send signals to the driver
                pinMode(x_paso, OUTPUT); 
                pinMode(x_dire, OUTPUT); 
                pinMode(x_habi, OUTPUT);     
              }    

              void loop() {
                // Logic: 1 and 0 are Boolean states for the DIR pin. 
                // Direction 1 (HIGH) usually results in clockwise rotation, while 
                // Direction 0 (LOW) results in counter-clockwise rotation, 
                // depending on how the motor wires are connected to the driver.
                giro(x_paso, x_dire, x_habi, 1); 
                delay(500); // Short pause before changing direction
                giro(x_paso, x_dire, x_habi, 0); 
                delay(500);
              }

              /**
              * void giro: This is a custom function created to avoid repeating code. 
              * It receives four parameters: the Step pin, the Direction pin, the Enable pin, 
              * and the desired direction (0 or 1). This allows you to control any motor 
              * using the same logic block.
              */
              void giro(int paso_, int dire_, int habi_, int dir) { 
                
                // digitalWrite(habi_, LOW): Most drivers are "Active Low." 
                // Sending a LOW signal enables the driver so it can energize the motor coils.
                digitalWrite(habi_, LOW);   

                // Check which direction was requested
                if(dir == 0) { 
                  digitalWrite(dire_, LOW); // Set the physical direction pin to LOW
                  
                  // for(int i=0; i < tiempo; i++): This is a loop that repeats the instructions inside.
                  // It starts with 'i' at 0, and as long as 'i' is less than 'tiempo' (220), 
                  // it executes the code and then adds 1 to 'i' (i++). 
                  // This effectively tells the motor to take exactly 220 pulses (steps).
                  for(int i = 0; i < tiempo; i++) {  
                    
                    // Creating a Pulse:
                    digitalWrite(paso_, HIGH);   // Send a HIGH signal to trigger the start of a step.
                    delayMicroseconds(retardo);  // Wait to maintain the signal (defines speed).
                    digitalWrite(paso_, LOW);    // Send a LOW signal to complete the square wave pulse.
                    delayMicroseconds(retardo);  // Wait before the next pulse.
                  }
                }

                if(dir == 1) { 
                  digitalWrite(dire_, HIGH); // Set the physical direction pin to HIGH
                  for(int i = 0; i < tiempo; i++) {   
                    digitalWrite(paso_, HIGH);      
                    delayMicroseconds(retardo);          
                    digitalWrite(paso_, LOW);       
                    delayMicroseconds(retardo);  
                  }
                }

                // digitalWrite(habi_, HIGH): This disables the driver after the movement is done.
                // When HIGH, the driver stops sending current to the motor. This prevents 
                // the motor and driver from overheating while idle, but the motor 
                // will "let go" and can be turned easily by hand.
                digitalWrite(habi_, HIGH);   
              }
            

// Test for Driver, Stepper Motors, and ESP32
// This version is optimized for a conveyor belt that rotates in one direction.

#define x_paso 15   // Defines the STEP pin for the X-axis motor
#define x_dire 2    // Defines the DIR (Direction) pin for the X-axis motor
#define x_habi 4    // Defines the ENABLE pin for the X-axis motor

// Global Variables
int retardo = 3000;         // Delay in microseconds; a lower number makes the rotation faster
int pasos_por_vuelta = 200; // Standard for 1.8-degree motors (360° / 1.8° = 200 steps)

// Setup runs once when the board is powered on
void setup() {
  // Configures the pins as OUTPUT to send control signals to the motor driver
  pinMode(x_paso, OUTPUT);
  pinMode(x_dire, OUTPUT);
  pinMode(x_habi, OUTPUT);

  // The Enable pin is set to LOW once to keep the driver always active
  // This prevents the motor from losing its position or "letting go" between turns
  digitalWrite(x_habi, LOW); 

  // The direction is fixed to HIGH at the start because the motor moves continuously in one direction
  // You can change HIGH to LOW here if you need to reverse the fixed rotation sense
  digitalWrite(x_dire, HIGH); 
}     

void loop() {
  // This 'for' loop executes exactly 200 steps to complete one full rotation
  // 'int i = 0' starts the counter, 'i < pasos_por_vuelta' sets the limit, 
  // and 'i++' adds one step per cycle until the turn is complete
  for(int i = 0; i < pasos_por_vuelta; i++){
    // Creating a Step Pulse:
    digitalWrite(x_paso, HIGH);    // Switches the step pin to HIGH to initiate a physical step
    delayMicroseconds(retardo);   // Maintains the HIGH state for a specific duration (defines speed)
    digitalWrite(x_paso, LOW);     // Switches the step pin to LOW to complete the pulse cycle
    delayMicroseconds(retardo);   // Wait time before the next pulse begins
  }
  
  // After completing a full turn (200 steps), the motor stops for 5000 milliseconds
  // This 5-second pause represents the time needed to carry out the corresponding process
  delay(5000); 
}

/* * NOTE ON CODE EVOLUTION:
 * The original 'giro' function and LED control (pin 33) were removed
 * because the conveyor belt now follows a simpler, one-direction continuous path.
 * All logic is integrated into the loop to ensure predictable movement and timing.
 */