ME 608 Drawing Robot

This project was our submission for the first group project in the class ME 608. In this class we were required to create a drawing robot that could process an image that we passed in. To do this we looked at a creation by the user MakersBox. That user heavily inspired our creation from supplies to use. We intended to create a 1 for 1 copy of the components but due to a mishap with 3D printing components we had to improvise, and that process will be detailed below.

Additionally, there is a video attached below that shows our robot in action.

https://youtu.be/3Oc4vCkN5nI

Reference creation:

Drawing Robot for Arduino : 18 Steps (with Pictures) - Instructables

The list of supplies below is what we used to make our robot.

1. Two SparkFun motors with wheels
2. One Arduino Uno board
3. One 180-degree servo motor
4. Tape (duct, masking, or something similar)
5. One sharpie, pen, or other writing implement
6. One breadboard
7. One motor controller
8. Male-Male wires
9. One Battery Pack
10. One computer
11. Matlab
12. Arduino IDE
13. One USB-A Cable
14. One baseboard (to place Arduino and breadboard on)

The first step is to source all the components listed in the supplies section above. A number of those components come as a component in the SparkFun inventors kit -v4.1.2. The items that aren't included in the kit like batteries and tape are things that we leave to the builder to source. Kit link attached here: SparkFun Inventor's Kit - v4.1.2

The next step is to download both the Arduino IDE and MATLAB, as both are necessary for the proper use of the system. The Arduino software is free and can be downloaded onto any computer with the proper hardware capacities. The steps to download it properly are on the Arduino website. MATLAB is a bit harder to come by as it does cost money, but many institutions' offer free access, like universities. You can find the IDE at this link here: www.arduino.cc/en/Main/Software

This step involves acquiring the Arduino Uno and attaching it to the base plate. This is your first and most important component as without the Uno none of the code has a home or hub to run through. To save yourself some trouble later you can plug your Uno into your computer and troubleshoot what COM port it answers to.

The fourth step involves converting the baseplate into the chassis for this drawing robot. The Uno board was attached to the baseplate in the previous step with tape or screws. Tape offers more flexibility, and at this stage we prefer that. the final product would ideally use screws for a more secure fit than tape. The breadboard is also attached to the baseplate.

The wiring diagram is shown for the next few components here. As mentioned in the uno step this is the central hub of the entire system. The wiring diagram shows how to wire the following components: 2x Gearmotors, 1x servo motor, 4x batteries in a battery pack, 1 button. It should be noted that wiring diagram was done in a software called tinkerCAD, that software does not use the same motor driver that we used on the physical robot, you should consult your driver specs for more specific wiring instructions. Other than that all the other components can be wired as shown in the diagram. Between the Arduino code and the wiring diagram, it should be simple to set up and test the system.

The two gear motors are what our wheels attach to, and they are what allow the robot to move around. The wiring diagram shows how to go about wiring the motors, but the full robot images indicate that the gear motors should be tapes to the underside of the base plate in an orientation that allow the wheels to meet the ground.

The servomotor is attached to the front of the baseplate. The wiring diagram indicates how the servomotor is connect to the Arduino. The servomotor is physically attached using tape as indicted in the image of the full robot. There is some adjustment needed to make sure the marker attaches to the servomotor properly, so it just barely touches the paper without impeding movement. The code also starts with the marker facing downward and then moves to the side as it drives around the drawing surface.

The next step is to attach the battery pack to the bottom of the baseplate. This is also done with tape. There is no back wheel on the robot so the battery pack must be placed high enough so that the back of the baseplate can drag along the drawing surface.

%Buckaroo Banzai Drawing Robot MATLAB code

%This code uses an inputted image to create a path from

%said image that will be used to guide the robot's motion

%The code produces an array of coordinates that are inputted

%into the robot's Arduino code

%clears everything

clc; clear; close all;

%set input image file name

imageFile = 'stick.jpg';

%define output dimensions in mm

scaleWidth = 200;

scaleHeight = 200;

%set simplification tolerance (0 to 1 range)

tolerance = 0.01;

%read and convert image to grayscale if RGB

img = imread(imageFile);

if size(img, 3) == 3

img = rgb2gray(img);

end

%binarize image and resize for faster processing

bw = imbinarize(img, 'adaptive', 'ForegroundPolarity', 'dark');

bw = imresize(bw, 0.4);

%detect edges

edges = edge(bw, 'Canny');

%extract boundaries and pick the longest one

[B, ~] = bwboundaries(edges, 'noholes');

[~, idx] = max(cellfun(@length, B));

boundary = B{idx};

%normalize boundary coordinates to range [0,1]

normX = boundary(:,2) / size(bw,2);

normY = boundary(:,1) / size(bw,1);

normBoundary = [normX normY];

%simplify path using reducepoly

normSimplified = reducepoly(normBoundary, tolerance);

%convert normalized coordinates back to pixel positions

xPix = normSimplified(:,1) * size(bw,2);

yPix = normSimplified(:,2) * size(bw,1);

%scale to mm and flip Y-axis to match physical coordinate space

x = xPix * (scaleWidth / size(bw,2));

y = scaleHeight - yPix * (scaleHeight / size(bw,1));

path = [x y];

%display binary image with original and simplified paths

figure;

imshow(bw); hold on;

plot(boundary(:,2), boundary(:,1), 'b:', 'LineWidth', 1);

plot(xPix, yPix, 'r-', 'LineWidth', 2);

legend('Original Boundary','Simplified Path');

title('Simplified Path Overlaid on Edge Image');

%plot final path in physical dimensions (mm)

figure;

plot(path(:,1), path(:,2), 'k-o', 'LineWidth', 1.5);

axis equal; grid on;

xlabel('X (mm)');

ylabel('Y (mm)');

title('Final Drawing Path in mm');

%print path array for direct copy into Arduino sketch

fprintf('\n=== Copy into Arduino Sketch ===\n');

fprintf('const float path[][2] PROGMEM = {\n');

for i = 1:size(path,1)

comma = ',' * (i < size(path,1));

fprintf(' {%.2f, %.2f}%s\n', path(i,1), path(i,2), comma);

end

fprintf('};\nconst int pathLen = %d;\n', size(path,1));

The commented code above allows for an image like the first stick man to be passed in as a JPEG before creating an rendering of it and passing out a useable path that has coordinates that the Arduino code uses.

//Buckaroo Banzai Drawing Robot

//This is the arduino code for the drawing robot. A path from the MATLAB code is inputted

//and guides the robot's motion

//Chat was used to help with coding the robot's motion along an inputted path

//needed libraries

#include <avr/pgmspace.h>

#include <math.h>

// define pins for the button and motor control (PWM and direction)

const int buttonPin = 7;

const int motorL_pwm = 3;

const int motorL_in1 = 8;

const int motorL_in2 = 5;

const int motorR_pwm = 11;

const int motorR_in1 = 13;

const int motorR_in2 = 12;

// constants for how long to rotate or drive forward per unit angle/distance

const float ROTATE_SCALE = 250.0;

const float FORWARD_SCALE = 5.0;

const int MOVE_SPEED = 200;

// track current position and orientation of the robot

float currX = 0;

float currY = 0;

float currTheta = 0;

bool hasDrawn = false;

// array of (x, y) coordinates stored in flash memory to define the path

//this is where MATLAB output is copy and pasted

const float path[][2] PROGMEM = {

{13.59, 134.92},

{99.46, 109.21},

{98.91, 136.51},

{79.35, 139.37},

{61.96, 146.98},

{51.63, 158.41},

{50.00, 167.94},

{56.52, 180.63},

{67.93, 188.57},

{84.78, 193.97},

{108.15, 194.92},

{138.59, 184.76},

{148.37, 173.65},

{150.00, 163.81},

{143.48, 151.43},

{132.61, 143.81},

{101.63, 136.51},

{101.63, 109.52},

{186.96, 133.97},

{101.63, 107.62},

{101.63, 73.97},

{134.78, 26.03},

{100.54, 72.70},

{66.30, 25.71},

{99.46, 74.60},

{99.46, 107.30},

{13.59, 134.92}

};

const int pathLen = 27;

// set all motor control pins as outputs

void initMotors() {

pinMode(motorL_in1, OUTPUT);

pinMode(motorL_in2, OUTPUT);

pinMode(motorR_in1, OUTPUT);

pinMode(motorR_in2, OUTPUT);

}

// initialize serial, button input, and motor pins

void setup() {

Serial.begin(9600);

pinMode(buttonPin, INPUT_PULLUP);

initMotors();

Serial.println("Ready. Press button to begin drawing.");

}

// waits for button press, then runs the drawing path once

void loop() {

if (!hasDrawn && digitalRead(buttonPin) == LOW) {

Serial.println("Drawing started...");

drawPath();

hasDrawn = true;

Serial.println("Drawing complete.");

}

delay(100);

}

// moves to the first point, then sequentially follows each path point

void drawPath() {

float x, y;

memcpy_P(&x, &path[0][0], sizeof(float));

memcpy_P(&y, &path[0][1], sizeof(float));

moveTo(x, y);

delay(200);

for (int i = 1; i < pathLen; i++) {

memcpy_P(&x, &path[i][0], sizeof(float));

memcpy_P(&y, &path[i][1], sizeof(float));

moveTo(x, y);

delay(50);

}

}

// calculates rotation and distance to next point, then performs motion

void moveTo(float x, float y) {

float dx = x - currX;

float dy = y - currY;

float targetTheta = atan2(dy, dx);

float dTheta = normalizeAngle(targetTheta - currTheta);

float dist = sqrt(dx * dx + dy * dy);

rotateBy(dTheta);

driveForward(dist);

currX = x;

currY = y;

currTheta = targetTheta;

Serial.print("Moved to: ");

Serial.print(x); Serial.print(", ");

Serial.print(y); Serial.print(" | Heading: ");

Serial.println(currTheta * 180.0 / PI);

}

// rotates robot in-place for specified angle (in radians)

void rotateBy(float angleRad) {

int dir = (angleRad > 0) ? 1 : -1;

int duration = abs(angleRad) * ROTATE_SCALE;

analogWrite(motorL_pwm, MOVE_SPEED);

analogWrite(motorR_pwm, MOVE_SPEED);

if (dir > 0) {

digitalWrite(motorL_in1, LOW);

digitalWrite(motorL_in2, HIGH);

digitalWrite(motorR_in1, LOW);

digitalWrite(motorR_in2, HIGH);

} else {

digitalWrite(motorL_in1, HIGH);

digitalWrite(motorL_in2, LOW);

digitalWrite(motorR_in1, HIGH);

digitalWrite(motorR_in2, LOW);

}

delay(duration);

stopMotors();

}

// drives both motors forward for a given distance (in mm)

void driveForward(float distanceMM) {

int duration = distanceMM * FORWARD_SCALE;

analogWrite(motorL_pwm, MOVE_SPEED);

analogWrite(motorR_pwm, MOVE_SPEED);

digitalWrite(motorL_in1, HIGH);

digitalWrite(motorL_in2, LOW);

digitalWrite(motorR_in1, LOW);

digitalWrite(motorR_in2, HIGH);

delay(duration);

stopMotors();

}

// immediately stops the motors by setting PWM to zero

void stopMotors() {

analogWrite(motorL_pwm, 0);

analogWrite(motorR_pwm, 0);

}

// ensures the angle is within the standard radian bounds

float normalizeAngle(float angle) {

while (angle > PI) angle -= 2 * PI;

while (angle < -PI) angle += 2 * PI;

return angle;

}

The code above takes the information from the MATLAB script to instruct the robot on where to move on the paper.

The next step after initializing the code in both MATLAB and Arduino is to set up a large piece of paper. Ensure that the paper is taped down to avoid the robot moving the paper around. Input a simple shape into the MATLAB and Arduino scripts and watch the robot. Take note of any improper movements or errors.

The final step is to take the notes from the previous step and adjust the parameters in the code that affect the movement of the gear motors. This is ultimately as far as our group got in the creation of our drawing robot. You can watch a video that shows the last two steps through the embedded YouTube video on this site.