High Speed Motor Control

Overview

The project suggested was to design a system for high speed motor control using the PIC 32. To demonstrate the motor control, a two degree of freedom (2-DOF) parallelogram robot arm was designed to follow paths specified in a MATLAB gui.

Team Members

Sam, Ryan and Daniel with their robot.

• Sam Bobb (Electrical Engineering senior, left)
• Daniel Cornew (Mechanical Engineering junior, right)
• Ryan Deeter (Mechanical Engineering junior, middle)

Mechanical Design

Theory of Parallelogram Design

Equations of Motion

Commanding the arm is much easier for a user to do in x- and y- coordinates than in motor angles or encoder counts. Therefore, equations were required that would translate x- and y- coordinates into angles from horizontal and then into encoder counts. Equations to express the reverse (encoder counts to angles to x- and y- coordinates) were also needed to evaluate the accuracy of the execution with respect to the command path.

$x=L\cos(\theta _{1})\ +\cos(\theta _{1}+\alpha )$

$y=L\sin(\theta _{1})\ +\sin(\theta _{1}+\alpha )$

$\alpha =cos^{-1}\left({\frac {x^{2}+y^{2}-L^{2}-(2L)^{2}}{2L^{2}}}\right)$

$\theta _{1}={\frac {-(2L\sin(\alpha ))x+(L+2L\cos(\alpha ))y}{(2L\sin(\alpha ))y+(L+2L\cos(\alpha ))x}}$

$\theta _{2}=\theta _{1}+\alpha \,$

Note: $\alpha \,$ is used to calculate $\theta _{1,2}\,$ in the MATLAB code and is not ever sent to the PIC.

Materials and Construction

The Motors are mounted into right-angle pieces of aluminum via screws in the face-plate of the motors. Each right angle has a slot milled into its base, and there is a flat aluminum base that also has a slot milled into it. The right angles are secured to this base with bolts, nuts, and lock washers. This slotted construction allows the position of the motors to be adjusted in order to ensure free movement of the arms.

Attached to each motor is a carbon fiber arm. These arms are 1/2 inch thick carbon-nomex-carbon layups. (Nomex is a material that provides rigidity to carbon fiber.) Each arm has an aluminum block with a hole and set screw for mounting epoxied to one end. One of these carbon fiber arms has a bearing mounted in it 10 inches away from the motor shaft, and the other has a pin mounted at the same distance.

There are two other component to the parallelogram assembly. One is a 22 inch by 1/2 inch length of carbon-nomex-carbon. This piece has one pin mounted 1 inch away from one end, and another pin mounted 10 inches away from that. The other piece is a 12 inch long piece of aluminum that has been bent into a 1 inch by in inch U-shape. This piece has two ball-bearing epoxied into it 10 inches apart.

The longer piece of carbon has the pin closest to its end press fit into the ball bearing mounted into the motor arm. The U-shaped piece of aluminum has on ball bearing slid onto the other motor arm, and secured with a snap ring. The remaining ball bearing is then slid onto the reaming pin in the long piece of carbon and secured with a snap ring.

The position of the motors relative to one another in then adjusted unit the arms move freely, and then fastened in place.

Electrical Design

Overview

Encoders for position feedback.

Optical break sensor on each arm to establish absolute position

Components

Electrical Components Needed.	Data Sheets
row 1, cell 1	row 1, cell 2
row 2, cell 1	row 2, cell 2

GUI

The GUI was programmed in MATLAB using the "guide" function. The GUI code calls the other MATLAB functions and is rather small as far as the amount of new code in contains.

[insert screenshot of gui]

Usage

The GUI is made up of four main sections that allow a user to control the path and motor control parameters of the arm and plot the results.

The first section is the "Path" section, which allows users to specify the type of path the arm will follow. There are currently three path choices: "go to," "circle," and "trace." The "go to" path allows the user to specify a point that the arm will go to from its current position in five seconds. The "circle" path is determined through five values. The first two are the (x, y) of the center of the circle. The next two are coefficients on sin and cosine terms that are effectively the radii [CHECK THIS WITH SAM}. The last value is the time in seconds for the arm to complete the circle. In the final path, "trace," users input four (x, y) positions and the arm moves from the first to the fourth and back to the first with two seconds in between points. The GUI could easily be changed so that the user specifies (x, y, t) and controls the time between points, but this would require velocity-based failure checking in the code to ensure that the user did not give a command that was dangerous to the arm.

The section just to the right of the "Path" section allows for further manipulation of the path and motor control. A checkbox controls whether or not the specified path loops (note: "go to" cannot loop). Beneath the checkbox is a section labeled "PID Control" and it lets users adjust the coefficients kp (proportional), ki (integral) and kd (derivative) on the fly by pressing the "Update" button.

The section on the far right is used to communicate between MATLAB and the PIC. A COM port is specified for communication. The "Connect" button opens the COM port, and the "Disconnect" button closes it. The "Start" button runs whichever path is specified in the "Path" section, and "Pause" pauses the path (note: to unpause, click the "Start" button again while paused).

The final section of the GUI is the "Graphs" section. This section plots the path of the arm in either "theta vs t" or "x vs y," as selected by the radio buttons. Plotted in COLOR is the path that the PIC tried to execute, and the COLOR plot shows the actual path of the arm, for comparison. INCLUDE SOMETHING ABOUT THE GET DATA AND CONTINUOUS LOG BUTTONS!

Code

Using MATLAB's "guide" function when creating GUIs makes for rather straightforward coding. When a component is added to the GUI (be it a button, text field, etc.), MATLAB adds a block of code to an automatically generated m-file. These blocks are functions, which means that programming them requires the use of handles. Here is an example:

   function xCoor_Callback(hObject, eventdata, handles)
   % hObject    handle to xCoor (see GCBO)
   % eventdata  reserved - to be defined in a future version of MATLAB
   % handles    structure with handles and user data (see GUIDATA)
   if get(handles.goToButton, 'Value') == 1
       xCoor = get(hObject, 'String');
   end

This block of code is for the x-coordinate of the "Go To" path option. The if statement utilizes handles so that the "Go To" button's function can be accessed from the x-coordinate function. This block sets the x-coordinate of the "Go To" command to the user specified value in the GUI if the "Go To" button is selected.

Code

Overview

There are two main applications: the C code that runs on the PIC and the MATLAB code that runs on a PC. The two applications communicate by sending command packets over a serial connection. The packets consist of a string of 16-bit integers. The first integer identifies the command and the following integers carry the parameters. This table shows the available commands.

Commands

Command	Identifying Integer	Description	Number of following ints	Syntax for following ints
C_HOLD	0	Hold arm in home position	2	[ x_position y_position ]
C_FLOAT	1	Stop and float motors	1	[ true = 1 ]
C_RUN	2	Run path	1	[ true = 1 ]
C_CONTROL_CONFIG	3	Send new control parameters	14	[ KPnum1 KPden1 KDnum1 KDden1 KInum1 KIden1 Kslope1 KPnum2 KPden2 KDnum2 KDden2 KInum2 KIden2 Kslope2 ]
C_LOG_CONFIG	4	Send new logging parameters (unimplemented)	0	--
C_SET_PATH	5	Send new path points	variable	[ n time1 theta11 theta21 time2 theta12 theta22 time3 theta13 theta23 ... timen theta1n theta2n ]
C_SEND_LOG	6	Asks the PIC to send logged data	0	--
C_LOOP	7	Sets the looping option	1	0 = run once, 1 = loop the path
C_STARTSTOP	8	start and stop (unimplemented)	0	--
C_GOTO	9	Tells the arm to goto a certain X,Y	2	[ X Y ]
C_PAUSE	10	Stop and hold at current location	0	--

For example, the vector that MATLAB sends to move the arm to X = 15, Y = -10 would be: [9 15 -10].

PIC C Code

Media:2dof-arm-v3-PIC.zip

This code runs on the PIC 32 and handles the motor control, control loop, logging, and serial interface. On start up, the PIC runs the initialization routines, and then waits for the user to move the arm through each of the optical break sensors. When a break is detected on one of the sensors, the position of the corresponding arm is set to zero. This allows an absolute position to be established for each arm. Once the procedure is complete, the PIC waits for commands from the PC.

Initialization

• mInitAllLEDs() -- sets up the on board LEDs
• initPWMandIO() -- sets up digital IO pins for motors and more LEDs, sets up two analog to digital converters for the optical break sensors, configures the PWM modules and assigns them to Timer 3, and configures Timer3 at 20kHz
• initEncoder() -- Sets up Timers 1, 2, 4, and 5 as external counters for the encoders.
• initUART2(pbClk) -- Sets up UART2 for serial communication.

Timed loop (2 kHz)

What happens

Serial Interrupt

What happens

MATLAB Code

Media:2dof-arm-v3-matlab.zip

The MATLAB library consists of functions for each of the commands that can be sent to the PIC and some helper functions. When one of the callback functions from the GUI runs, it pulls parameters from the interface, assembles them, and passes them to the proper command functions.

Within the arm command functions, MATLAB uses the fwrite function to write data to the serial port. The int16 option ensures that MATLAB breaks each number into a 16 bit integer and sends it as two bytes out the serial port. The PIC will then reassemble these two bytes as a 16 bit integer.

Example MATLAB procedure

Suppose the user wants move the arm to X = 15, Y = -10. The following happens:

1. The user opens the GUI by running me333gui from the MATLAB command line
2. The user puts the proper COM port in the COM port text box and clicks Connect
3. The function Connect_Callback runs. This function pulls the text from COMport text box and sends it to the arm_connect function. The serial port is now open. The handle for the serial port object is stored in the UserData field.
4. The user puts the desired X and Y in the goto X and Y text boxes, selects the GoTo radio button, and clicks Start.
5. The function startButton_Callback. This function checks which of the mode radio buttons are selected. If GoTo is selected, it reads from the X and Y boxes, and calls the arm_goto function with the COM port handle and the X and Y from the text box.
6. The arm receives the command and executes the move.

Results

It was awesome.

Acknowledgements

We would like to acknowledge Professor Lynch, Nick Marchuk and Andy Long for their instruction and guidance throughout this project.