Brawler Crawler + Update to Drift Drafter

The not so friendly neighborhood Robot

Brawler Crawler is the perfect toy for all the people who ever wanted to have a cat without cuteness and snuggly mentality. So if you feel too good and relaxed and your life is just fine - Brawler will change it - it's loud, annoying yet interesting to watch how it kicks and nudges everything which gets detected by its little devil infrared eyes.

Tools

• 3D Printer
• Soldering Iron
• Rubberbands
• Small wood screws
• Basic tools
• Hot glue gun
• Superglue
• Wires
• Cable stripper
• Dremel with wheel for cutting metal
• Drill
• Screwdriver and/or Allen wrench set

Hardware

• Rubber bands
• Coin, roughly 18mm diameter. 5 Euro cent works perfectly.
• Small wood screws M3 x 15
• M3x 20 screws and nuts
• M3 x 40 (or longer) screw and nut
• M6 X 120 screw and 2 nuts
• 6mm Linear Bearing

Electro/Mechanical parts

• 4 Omniwheels
• 4 Nema 17 Stepper Motors
• 4 Stepper brackets
• 4 Longrunner Tb6600 Stepper Driver
• 5 TRCT5000 IR Sensors
• 1 GP2Y0A21YK0F Sharp IRSensor
• 3 Servo MG90S Mikro Servos
• 1 12V 20RPM geared Motor
• 11.1V Lipo Battery or 12 V Wall plug
• 1 DC-DC Stepdown converter
• Arduino Mega
• Mega Sensor Shield
• BarrelJack M/F
• 2 Limit Switches

IF YOU DON'T HAVE ANY EXPERIENCE YOU SHOULD FIND SOMEONE WHO CAN HELP YOU

To build the robot you can be very creative - you can adapt and tweak it, add and reshuffle components.

In the next step, you'll find a link leading to Grabcad where you can download the full assembled robot.
It's highly recommended to download this file to understand how components are placed and build up -additionally if you're keen to build exactly this robot you can simply take all the measurements you need.

CAUTION - ALWAYS KEEP YOUR FAVORITE HOT GLUE GUN AND SUPER GLUE HANDY!!!

First things first.

As previously described please download this file: Brawler Crawler incl. Kicker Full Assembly. Assemble the hardware parts you will need for the kicker, as well as your screwdriver, hot glue gun, and dremel.

Additionally, please download all stl files and print them all. Note: you may need to modify the slot on the gear to suit your coin.

1. Assemble your bearing block, using your linear bearing and four M3 screws. The linear bearing should be tight, you may need a vise or clamp to get it in. Secure the bearing with super glue if it's loose.
2. Assemble the bolt head cover around the head of your M6 bolt. Secure the smaller 3D printed part with super glue.
3. Assemble the linear gear and jaws, using your M3x40 screw as a pin. Insert a small rubber band into the channel on the jaws to keep them shut by default.
4. Slide your M6 bolt into the linear bearing, then attach the kicker head. The plastic should be sandwiched between two M6 nuts.
5. Use your four wood screws to screw the bearing block onto the kicker chassis. Make sure the screws are flush with the underside of the chassis.
6. Use your dremel to grind a slot into the shaft of your DC motor. The slot should be as straight as possible, and only wide enough to fit your coin snugly.
7. Use your dremel to cut approximately 40% of your coin off, leaving a straight edge to insert into the gear.
8. Attach your motor to the kicker chassis with four M3 screws.
9. Insert your linear gear into the channel on the chassis, and snap the jaw wedge in place on top of it.
10. Use hot glue to attach one limit swtich at the back of the chassis, so that it is pressed when the linear gear is fully retracted and the jaws are wedged open.
11. Hot glue the second limit switch so that it is normally pressed, and only comes free when the linear gear is fully extended (grabbing the bolt head and pressed against the bearing block). WARNING: this is a difficult step, but critical to prevent your kicker from damaging itself. You must ensure that the limit switch is reliably pressed by the linear gear, and reliably comes unpressed only when the linear gear is fully extended.
12. Using the holes in the bearing block, thread rubber bands between the screws on the bolt head cover and the screws on the bearing block.
13. Thread a long rubber band through the holes in the jaws and attach it to the screws on the bearing block. This will keep the jaws centered when they snap forwards.
14. WAIT until you've reached the step "wiring the kicker". Once your kicker is wired, CAREFULLY test it with the attached code - keep your finger on the power switch to avoid damaging your kicker. Your goal should be to ensure that the kicker reliably loads, stops, then fires on command and reloads. You may need to adjust your end stops before hot gluing the kicker into the belly of your Brawler Crawler.

To assemble the chassis please open the step file again to understand the assembly.

You don't have to stick to the material or dimensions - if you don't want to tweak the code you probably want to use the same dimensions.

1. Print 4 sensor brackets - be aware you only need to place one bracket on your print bed - copy it one time and then mirror it - you'll end up with 4 brackets for all corners.
2. Print 4 OminWheelHubs - Orientation doesn't matter
3. Insert a little m3 nut and a m3x10 screw into the holes of the hub - used as a setscrew.
   
   OmniWheelsin the step file are not the ones that are used for the real assembly - Have a look at the supply list and follow the link to find the original ones
   
4. If you don't use the same Omni wheels you need to design your own stepper shaft attachment hub.
5. If you do use the same wheels - before you are able to attach the printed hub to the wheels, firstly you have to remove the little plastic part in the middle of the wheel - if removed a little hexagon should be visible.
6. Now you're able to attach the printed hub to the wheel - take 3 little wood screws and screw them throw the plastic rim until the printed hub sits firmly.

STL PRINT FILES:

To wire up the system you should be experienced - a detailed description of the connection will not be provided

To have a better overview of the components pin connection you either look it up in code or follow the list below:

const byte sensorPin = A0; // Sharp Distance Sensor<br>

int EndStopPin_Gripped = 28;
int EndStopPin_Loaded = 27;
int EndStopPin_Fired = 29;
int HBridgePin_IN1 = 11;
int HBridgePin_IN2 = 10;
int HBridgePin_enA = 8;<br>

AccelStepper RightFrontWheel(1, 40, 41); // (Type:driver, STEP, DIR)Stepper1<br>AccelStepper RightBackWheel(1, 20, 21);   // (Type:driver, STEP, DIR) - Stepper2 <br>AccelStepper LeftFrontWheel(1, 44, 45);  // (Type:driver, STEP, DIR)Stepper3
AccelStepper LeftBackWheel(1, 16, 17);  // (Type:driver, STEP, DIR)Stepper4

int S_rr = 22; //Edgedetection ir sensor right rear
int S_lr = 38; //Edgedetection ir sensor left rear<br>int S_rf = 23;//Edgedetection ir sensor right front
int S_lf = 43;//Edgedetection ir sensor left  front<br>

Neck.attach(4);  // attaches the servo on pin  to the servo object
Antenna1.attach(2); // attaches the servo on pin  to the servo object
Antenna2.attach(13); // attaches the servo on pin  to the servo object

AccelStepper RightFrontWheel(1, 40, 41); // (Type:driver, STEP, DIR)-Stepper1
AccelStepper RightBackWheel(1, 20, 21);   // (Type:driver, STEP, DIR)-Stepper2
AccelStepper LeftFrontWheel(1, 44, 45);  // (Type:driver, STEP, DIR)-Stepper3
AccelStepper LeftBackWheel(1, 16, 17);  // (Type:driver, STEP, DIR)-Stepper4

const byte sensorPin = A0; // Sharp Distance Sensor

int S_rr = 22; //Edgedetection ir sensor right rear
int S_lr = 38; //Edgedetection ir sensor left rear
int S_rf = 23;//Edgedetection ir sensor right front
int S_lf = 43;//Edgedetection ir sensor left  front

int EndStopPin_Gripped = 28; 
int EndStopPin_Loaded = 27; 
int EndStopPin_Fired = 29;

int HBridgePin_IN1 = 11;<br>int HBridgePin_IN2 = 10;<br>int HBridgePin_enA = 8;

Read the comments in the code to get a detailed description of how each function works. In general, the code will follow a simple overall structure:

Decide a movement command

Loop through checking sensors and executing that movement command until it becomes invalid.

The command is rendered invalid by edge detection, object detection, or completion of the command timer. Various variables keep track of whether the Brawler Crawler has "seen" a table edge or an object.

Don't expect your brawler crawler to work immediately! It will almost certainly need some testing to work well. Try running it with the Arduino connected to your laptop and the serial print lines uncommented in the code until you understand the code well. It takes some skill and persistence to tell apart and diagnose problems with code, electronics or mechanics.

It can be a good idea to test your Brawler Crawler on a board laying on the floor until you're confident that the edge detection is working properly!

Once you are satisfied, unleash your Brawler Crawler on the world!

Drift Drafter:

The Drift Drafter is a high-precision autonomous robot that can create drawings on a flat surface. It is an improvement of the robotic platform developed for the “Brawler Crawler” useless machine, utilizing mecanum wheels for omnidirectional movement. A built-in ink reservoir, pump, and swappable end effector allow for a variety of drawing/marking applications. Machine Vision and Deep Learning were explored via a Jetson Nano and webcam mounted on the robot, but remain as a topic for further investigation.

The motion control of the Drift Drafter is handled by an Arduino Mega using the AccelStepper library. The Arduino programming interprets motion commands in the form of a direction, distance, and boolean value for paint deposition. These commands either come from an external source via serial connection, are selected from a pre-set list, or are procedurally generated by the Arduino. Four edge detection sensors allow the robot to be aware of the limits of the drawing space, obstacles in the environment, and (potentially) previous lines that it has drawn.

High-level motion control and environmental sensing was attempted using a Jetson Nano, a small computer manufactured by NVIDIA for machine vision and deep learning applications. A neural network was trained using Tensorflow to recognize objects and gestures in a webcam video stream. ROS was used to stream motion commands and movement confirmation between the Jetson Nano and Arduino. However, technical difficulties with the more complex computing environment prevented our team from fully implementing robotic drawing based on machine vision. This remains as a topic of great interest for future work.

Drift Drafter differs in a more sophisticated chassis and an integrated drawing unit.
At this stage, the paint reservoir is not been used so far, meaning the peristaltic pump for pumping paint into a fillable brush has not been integrated into the code.

If you already made it this far - I'm sure you will accomplish this part by yourself with your
outstanding maker spirit :)

Please download this file to generate your Step Files for Printing: Drifty Drafter STEP

The assembly is designed as butt joints meant to be glued together.
There is no distinct order to do so just open the Step- file, there you have a perfect self-explanatory overview.

////////////STEPPER////////////////////////////
AccelStepper RightFrontWheel(1, 20, 21); // (Type:driver, STEP, DIR) Stepper1
AccelStepper RightBackWheel(1, 44, 45);   // Stepper2
AccelStepper LeftFrontWheel(1, 18, 19);  // Stepper3
AccelStepper LeftBackWheel(1, 42, 43);  // Stepper4
AccelStepper Pivot(1, 40, 41);          //Stepper5
AccelStepper PenLift(AccelStepper::FULL4WIRE, 26, 29, 28, 27);//Stepper6

//////////////Edgededetection///////////////////
int LF_Edge =37;
int LB_Edge =36;
int RF_Edge =35;
int RB_Edge =34;

/////////////////IR Sensor PivotPosition///////////
int PivotPos = 22; / Homing Sensor

/////////////////IR Front///////////////////
int FrontIR = A0;

///////////perstaltic Pump//////////
int IN3 = 33;
int IN4 = 32;
int ENB = 30;

This was our first drawing using the Drift Drafter. The way the robot behavior was relatively simple, It would go in a random direction (0 to 360 deg) for a random distance (100 to 500 mm) with a 50% change of drawing while moving. if the movement was completed without running into and edge the process would repeat. If an edge was detected then the robot would stop and go a direction 180 degrees from the direction it was going plus a random amount (-30 to 30 deg).

In this drawing the Drift Drafter would draw a square in a random direction (0 to 360 deg) that was a random size (100 to 400 mm) and for each segment of the square would have a 80% chance of drawing a line.

This drawing was a continuation of the screen saver drawing where we refined the code and changed the behavior slightly. Instead of going a random distance (100 to 500mm) the Drift Drafter would go until it ran into an edge or obstacle regardless of the distance. We also added additional obstacles on the paper for the robot to bounce off of. We ran this process multiple times with different orientations and starting points for the robot.

Unlike the other example drawings this one was not generative but instead used an imported array of vectors to draw a preprogrammed path. We generated the path using Rhino and Grasshopper then stored the information in the Arduino code in three lists. The first for Angles, the second for Distances and the last for if the robot was drawing. the Arduino code then ran through the lists and produced a linear move based off each index.