RPI Step Motor controller - Viktor Mihalovic

Project Overview:

The primary goal of the RPI Step Motor Controller project is to automate the process of controlling the height of the Oree R-t model laser arm for laser marking in production. This automation involves automatically scanning a product's serial number, retrieving information from a database, and adjusting the height of the laser arm accordingly. This project was focused on part to manage height of laser arm

Hardware Setup:

Raspberry Pi (Model: [Insert Model]) Oree R-t model laser Step Motor: 57CM22X Microstep Drive: DM542 Controller with display: MC-24MR-4MT-500-FX-A Bottom and top sensors: TL-Q5MC1-Z Software Setup: Programming Language: Python Libraries/Frameworks: RPi.GPIO Software Installed on Raspberry Pi: [List any additional software necessary for the project] Control Algorithm: The control algorithm involves receiving signals from the Raspberry Pi and sending control signals to the Microstep Drive DM542 to adjust the height of the laser arm based on product model information retrieved from the database.

User Interface:

The project currently does not include a user interface. Control signals are sent automatically based on the scanned product serial number and database information.

Testing and Validation:

Testing of the functionality involves:

Challenges and Solutions:

Challenges encountered during development:

Integrating the Raspberry Pi with the Microstep Drive DM542. Ensuring accurate height adjustments based on database information. Solutions:

Using Python for GPIO control on the Raspberry Pi. Implementing specific wiring configurations for proper communication with the Microstep Drive DM542.

Code Explanation:

1. Import necessary libraries

import RPi.GPIO as GPIO import time

1. Set GPIO mode

GPIO.setmode(GPIO.BCM)

class Arm:

   def __init__(self):
       # Initialize GPIO pins and variables
       self.settings()
       self.sensor_down = False
       self.sensor_up = False
       self.buttonUp = False
       self.buttonDown = False
       self.actHeight = -1
       self.check_read_sensors()
       self.numberOfSteps = 0
   
   # Function to initialize GPIO settings
   def settings(self):
       # Define GPIO pins for motor control, sensors, and buttons
       self.motor_direction_pin = 27
       self.motor_step_pin = 22
       self.sensor_down_pin = 23
       self.buttonUpPin = 25
       self.buttonDownPin = 6
       self.sensor_up_pin = 24
       self.delay = 0.000003  # Adjust this delay for motor speed
       self.pulses_per_rev = 5000   # Set pulses per revolution
       # Setup GPIO pins
       GPIO.setup(self.motor_direction_pin, GPIO.OUT)
       GPIO.setup(self.motor_step_pin, GPIO.OUT)
       GPIO.setup(self.sensor_down_pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
       GPIO.setup(self.sensor_up_pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
       GPIO.setup(self.buttonUpPin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
       GPIO.setup(self.buttonDownPin, GPIO.IN, pull_up_down=GPIO.PUD_UP)

   # Function to perform a single step
   def step_once(self):
       self.numberOfSteps += 1
       GPIO.output(self.motor_step_pin, True)
       time.sleep(self.delay)
       GPIO.output(self.motor_step_pin, False)
       time.sleep(self.delay)
   
   # Function to step the motor forward
   def step_forward(self):
       GPIO.output(self.motor_direction_pin, True)
       self.step_once()
       self.actHeight += 0.0008
       
   # Function to step the motor in reverse
   def step_reverse(self):
       GPIO.output(self.motor_direction_pin, False)
       self.step_once()
       self.actHeight -= 0.0008

   # Function to stop the motor
   def stopMotor(self):
       GPIO.output(self.motor_step_pin, False)
       
   # Function to read sensor states
   def check_read_sensors(self):
       self.sensor_down = not GPIO.input(self.sensor_down_pin)
       self.sensor_up = not GPIO.input(self.sensor_up_pin)
       self.buttonUp = not GPIO.input(self.buttonUpPin)
       self.buttonDown = not GPIO.input(self.buttonDownPin)

   # Main function to start height adjustment
   def start(self):
       while True:
           self.check_read_sensors()
           if self.sensor_down and self.buttonDown:
               self.stopMotor()
               print('Hit bottom')
               continue
           if self.sensor_up and self.buttonUp:
               self.stopMotor()
               print('Hit top')
               continue
           if self.buttonUp and self.buttonDown:
               self.stopMotor()
               print('Both Sensors')
               break
           if self.buttonUp:
               self.step_forward()
               print('Forward')
               continue
           if self.buttonDown:
               self.step_reverse()
               print('Backward')
               continue
           self.stopMotor()
       GPIO.cleanup()

   # Function to find the bottom position
   def findBottom(self):
       while not self.sensor_down:
           self.check_read_sensors()
           self.step_reverse()
       self.actHeight = 143
       self.numberOfSteps = 0
   
   # Function to move to a specified height
   def goto(self, height):
       self.check_read_sensors()
       if self.actHeight <= height:
           while round(self.actHeight,2) != round(height,2) and not self.sensor_up:
               self.step_forward()
               self.check_read_sensors()
       else:
           while round(self.actHeight,2) != round(height,2) and not self.sensor_down:
               self.step_reverse()  
               self.check_read_sensors()

1. Main function

if __name__ == "__main__":

   print("Program has started")
   a = Arm()
   a.findBottom()
   print('I am at 0 cm')
   time.sleep(4)
   print('Going up to 480 mm')
   a.goto(480)
   print('I am at 480 mm')
   time.sleep(4)
   print('Going up to 200 mm')
   a.goto(200)
   print('I am at 200 mm')
   time.sleep(4)
   print('Going up to 0 mm')
   a.goto(0)
   print('Stopped at 143 mm due to height limit')
   GPIO.cleanup()

Conclusion:

The RPI Step Motor Controller project successfully achieves the goal of automating the process of controlling the height of the Oree R-t model laser arm. With further improvements and enhancements, it can effectively contribute to the automation of the laser marking process in production.