Final Project¶

Inspiration¶

I really liked the boston dynamics robot dog and I ever the genius think I can make a smaller verison of it. I also have a really fast dog and I want to understand why she is so fast.

For an overall base of what Im going to build this robot off I found this pervious Fab Final Project which was of a more spiderlike robot

Sketch¶

This week I worked on defining my final project idea and started to getting used to the documentation process. My final project is based off my dog on the front page. She is very fast. So fast that I cant keep up with her, but I wanted to see if I could build something to compete with her. The idea for the project is a robot similar to the boston dynamics dog that uses servos to move its limbs.

This is a rough draft of what I think it will look like

This is just an AI generated design to give a better perscpetive becuase I not a good artist

Midterm Review¶

As a part of the midterm, I planed out the rest of the stuff I needed to do for the final and put together my bill of materials for it.

Bill of Materials¶

Gantt Chart¶

Planing¶

For this to project to work I went through several design options, the first idea was to make it a remote control dog using a web server as the controller the next was to try and put ai in it to act like a dog you could interact with through a touch sensor, what I landed on though was making simple versions of both that could be swapped out. This way I could do both versions of the dog I wanted to do, without having to make two models. To acomplish this, I used an esp32s3 for the autonoumus/controlable mode where the only thing the person would need to do is upload a diffrent code to swithc between modes. Once I had this idea in mind, I figured out what my biggest issues were. These issues summed up into one category was legs. This included making them, moving them and probably the biggest challenge balance.

Weekly Assignments¶

2D and 3D Modeling¶

Electronic Production¶

Heres what the two sides looked like in Bantam

This is the parts I put into my F cuts, I left the outline out since when I did try to put the edge cuts on the outline, the tracks went over the edge cuts

PCB and Rivets¶

Heres what my board looks like on the front and back

Heres the machine I used to have current flow to the bottom of the board. I used rivets which were in the holes that I had through hole drilled.

These rivets are really small, so I used tweezers to put them into the holes

Interface¶

Learing about interfaces¶

I have already had previous experience using the esp32 web servers since I had used one for a porject in school a few months prior. Heres a link to that experiance. Because of that, I was able to make an interface quickly for controlling a servo. I used my output board to test out my interface.

I decided to make another web server on httml using the esp32c3 on my output board. Heres what the board looked like for refrence:

Heres what the interface looks like:

Code¶

#include <WiFi.h>
#include <ESP32Servo.h>

const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";

Servo myServo;
const int servoPin = 3;  // Servo on GPIO 3
WiFiServer server(80);

void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);

    while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.println("Connecting to WiFi...");
}

Serial.print("Connected. IP: ");
Serial.println(WiFi.localIP());

myServo.setPeriodHertz(50);  // Standard 50Hz servo
myServo.attach(servoPin, 500, 2400);  // Calibrate for your servo
myServo.write(90);  // Start centered

server.begin();
}

void wagTail() {
for (int i = 0; i < 2; i++) {
myServo.write(60);  // Move to one side
delay(200);
myServo.write(120);  // Move to the other side
delay(200);
}
myServo.write(90);  // Return to center
}

void loop() {
WiFiClient client = server.available();
if (client) {
String req = client.readStringUntil('\r');
client.flush();

if (req.indexOf("angle=") != -1) {
  int angleIndex = req.indexOf("angle=") + 6;
  int angle = req.substring(angleIndex).toInt();
  angle = constrain(angle, 0, 180);
  myServo.write(angle);  // Move servo to mapped angle
}

if (req.indexOf("/wag") != -1) {
  wagTail();
}

String html = R"rawliteral(
  <html><head>
  <style>
    body { text-align: center; font-family: sans-serif; }
    #joystick {
      width: 200px; height: 200px;
      border: 2px solid #555;
      border-radius: 50%;
      margin: 30px auto;
      position: relative;
      touch-action: none;
    }
    #stick {
      width: 50px; height: 50px;
      background: #2196F3;
      border-radius: 50%;
      position: absolute;
      top: 75px; left: 75px;
      touch-action: none;
      cursor: pointer;
    }
    button {
      padding: 10px 20px;
      font-size: 16px;
      margin-top: 20px;
    }
  </style>
  </head><body>
    <h2>ESP32-C3 Servo Joystick</h2>
    <div id="joystick"><div id="stick"></div></div>
    <button onclick="fetch('/wag')">🐶 Wag Tail</button>

    <script>
      const joystick = document.getElementById("joystick");
      const stick = document.getElementById("stick");
      const radius = 100;
      const center = { x: radius, y: radius };
      let dragging = false;

      function updateStick(clientX, clientY) {
        const rect = joystick.getBoundingClientRect();
        const dx = clientX - rect.left - center.x;
        const dy = clientY - rect.top - center.y;
        const dist = Math.min(Math.sqrt(dx * dx + dy * dy), radius - 25);
        const angleRad = Math.atan2(dy, dx);
        const angle360 = (angleRad * 180 / Math.PI + 360) % 360;
        const mapped = Math.round(angle360 / 2);  // 360° → 180°
        fetch("/?angle=" + mapped);

        const x = center.x + dist * Math.cos(angleRad) - 25;
        const y = center.y + dist * Math.sin(angleRad) - 25;
        stick.style.left = `${x}px`;
        stick.style.top = `${y}px`;
      }

      function resetStick() {
        stick.style.left = "75px";
        stick.style.top = "75px";
        fetch("/?angle=90");
      }

      // Mouse
      stick.addEventListener("mousedown", e => { dragging = true; e.preventDefault(); });
      document.addEventListener("mousemove", e => { if (dragging) updateStick(e.clientX, e.clientY); });
      document.addEventListener("mouseup", () => { if (dragging) { dragging = false; resetStick(); } });

      // Touch
      stick.addEventListener("touchstart", e => { dragging = true; e.preventDefault(); });
      document.addEventListener("touchmove", e => { if (dragging) updateStick(e.touches[0].clientX, e.touches[0].clientY); });
      document.addEventListener("touchend", () => { if (dragging) { dragging = false; resetStick(); } });
    </script>
  </body></html>
)rawliteral";

client.print("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
client.print(html);
client.stop();
}
}

Video¶

Test with Simple Code¶

Final Code Test¶

System Intergration¶

Dog Body Design¶

I used Fusion 360 to design my body since I wanted to laser cut test the body and the parameter button would allow me to use the same design for different material. The first model is very simple, it has 5 holes: two on each long side for the legs and then one in the back for the tail. Besides that everything else is part of my press fit design. I made it about the size of a portable charger since thats how Im currently trying to power my electronics and then about double the width of a portable charger to try and account for the pcb. Heres the fusion design:

And heres the first test cut in cardboard:

After seeing how poorly that came out I decided to switch over to a 3D printed. I used calipers to measure the board and its componets to make a 3 part body. The middle would be where all the electronics would be located. I have places for the servo wires to run where they will end up at a open up part of the body for the servo to move. The top part is the cover for the electronics, it covers up all the running wires and PCB, while also having a jetted out slot for the step responce touch point. The bottom part of the body is the holder for the portable charger thats powering the servos and board. Heres the current design I have:

And heres the pieces printed out:

These parts were to big and confusing so I chose to go for a different design in the end

Board Design¶

This week I also worked on designing my board for the final project. I took what I learned from Output and Machine Week to make the board. It has 4 pinheaders that are 3x1 for the legs and another 3x1 for the tail servo. I also have two pinheaders that are 2x1. One is for the external power supply and the other is for the rx and tx pinouts for the step responce. Finally I have the ESP32C3 as my microcontroller as it gives easy access to a web server and I have been using them for all the weeks up to now.

Heres the schematic view:

Heres the PCB Design

Code¶

Web Server and Remote Control¶

To control the Dog, I made 3 unique walking sequences, 1 for going forward, 1 for going left, and 1 for going right. To go forward, the front leg on one side and the back leg on the other would move forward and then pull back while the other two legs move forward. For the

Step Responce¶

For the input on my board, I wanted to have a way to interact with the dog, the answer to me was a type of touch sensor, origanlly this led to me using an ESP32S3 and using its touch pin, but that felt to simple, so I switched over to the C3 and

Electronics¶

For my project, I wanted to make the dog portable, but I realized that to provide the correct amount of power, I could use the UCB-C port on the ESP32C3. To solve this, I used a trigger module with another USB-C port to provide power to the board. The board houses my ESP32C3, 5 servos, two wires for step responce, a resistor and capacitor. Heres a block diagram of all the wiring:

PCB¶

For my final project I knew that the board needed to be double sided, the issue was that the fab lab had gone through all the double sided pcbs during machine week. My solution was simple, I took a single sided pcb and milled both sides of the board as two different pieces. This meant they were the same size and had the holes in the same place. Once they were both milled this is what they looked like side by side:

After looking at them and test lining them up I was able to see through both holes to the other side. Once that was acomplished, I used hot glue to press the boards together. Afterwards, I soldered a wire through the holes so that the boards were connected. Finally I soldered on the pinheaders for all my external electronics. This is what both sides looked like:

Now that the board was finished I was able to plug in all my servos into the board and the once very messy breadboard filled with wires became this:

Heres a wide view of the servos connected to the board:

I made a new design with large holes in vacant areas of the board for screws so the board is locked into the body of the dog. Heres what the new design looks like:

I made another design later with a surface mount resistor and capacitor for the step responce. Heres the schematic view:

And heres the PCB design:

3D Prints¶

Body¶

After making one press fit moc design and one 3d print moc design, I decided that I would use screws to hold all the componets together, First I designed the upper part of the body that would house the pcb, I used calipers to find the points for where the screws should go and this is what that part looked like, from thier I designed the rest of the body with screw holes on the ends of it for the next part. Heres what the first part looked like:

After the pcb holder was made, I worked on the part bellow that would hold the Trigger Module and Portable Charger. This is where the screw holes on top came into play as they were spaced out far enough so that the power supply could be put snuggly in between the coulums where the screws would go. Their are 5 colums, two on the left, two on the right, one in the back, and in the front is a holster for the Trigger Moudle that doubles as the last part to keep the portable charger in place. Besides that, it has holes in the corners on it to secure the lid ontop of the body. I didnt make anything to hold the servos in at the time but I found a fix later on. Heres what the final design for it looked like:

Finally was the lid which I designed using the size of the protbale charger holder. I then made it 2.4 inches tall to allow room for the electronics. I also added the same screw holes to the same areas where they are. Finally I shelled the rest of the body, and added holes for the servos and this is what it looked like:

Heres what the body looks assembled without the lid:

Other 3D Printed Elements¶

Legs¶

To make the legs, I took a 3d file of a servo, and removed everything except for the gear part and then, I traced it and made a cut. Thankfully it was centered on the middle, so I was able to then design a leg similar to the ones on a Boston Dynamic Dog, and exturde it. Heres what the final file looked like:

After printing the first test leg, I realized that the servo file I had used, had been made around a bigger servo, so I messed with the scaling a bit until I arrived at 80% its origanl size which fit very well. I might even say too well, as I am not able to remove them from the servos anymore. Heres what the final product looked like on a servo:

Servo Holder¶

Something I forgot to acount for when designing the body was how I was going to hold the servos. Looking back at it though, I glad I was able to design the servo holsters seperatly, since it allowed me to make multiples tests before making the final design, I used calipers to make the holder almost press fit so that the servo wouldnt move, and then added extinsions on each sides for screws to put the body together. Heres what the final file looked like:

Heres what the servo holder looked like holding a servo very well:

Tail¶

With having a fifth servo, I needed to design a different

Revising my Project¶

Overview¶

The day before I was to present my project, it shatered. To clairfy, while trying to force a leg onto a servo, I pressed to hard and the base of the print broke. I saw this as a sign, my project was subpar, it was large and janky. I accepted I was not going to pass the next day and began to plan.

New Electronics¶

Servo Shield:¶

Something I foolishly ignored last time was to use a servo shield. It would have allowed for a safer and stronger servo connection to my microcontroller but I had forgotten the suggestion that Mr. Dubik had given me a few weeks prior and made a board without one. For my new design I built my robot around the sheild

New Board¶

For my new board design, I took the knowledge from making other boards to come up with my design. The servo shield I had was designed to be used with an arduino uno, but I had grown accustom to using XIAO-ESP32C3 microcontrollers so I made a board that used a ESP32C3 for commanding that could plug into the servo shield. To do this, I first made my footprint for my board by just making the pin headers for my ESP32C3, a 2x1 for the power, a 7x1 for one side and a 4x1 for the other. This would allow me to use all of the digital pins on the ESP32C3 if I wanted to.

Afterwards I went to the schematic editor and added in a schematic of an arduino uno so I could line up the pin headers to where they needed to go. This worked so well that on my first attempt at testing it, the pin headers on the sheild easily slid into the female pinheaers I had on my board. Heres what the design looked like with the arduino outline:

Milling and Soldering¶

Milling has always been a big part of my fab journey. It has been good and bad, so when it came time to mill I knew it could go either way. Thankfully though, I ran into no issues while milling and was able to get a clean looking board after my first attempt at milling it. Afterwards I soldered on the female pinheaders and it came out looking like this:

Once that was done I got the servo shield and pressed the two together getting this:

Fusion360¶

Inspiration¶

When designing my legs and case in my first go around with this project, I had been using the boston dynaimcs dog as reference. I know now that this was not the best choice as it is a much larger and complex piece of machineray then what I was trying to make. To rectify this I started looking at smaller scale projects and came across Nymmble. It is a small scale cat robot that has many similarities to the boston dynamic dog. I looked deeply into it for inspieration and came to the conclusion I would use 2 servos per leg and would also screw the servos in this time for extra security.

Legs¶

For the legs I looked at how the geniuses at Nymble had made the legs and I noticed how they used two servos for each leg to give it a more realistic motion. I designed my lower part of the legs with a slot for the servo and then a middle piece to hold both servos gears. The other servo would be mounted to the case that would hold the electronices. Heres what the lower piece looks like:

Heres what the middle joint part looks like:

Heres a video of the working together:

Case¶

I was not able to start designing the case until I had a general idea of how large the electronics were going to be. After finishing the design of the shield board combination, I was able to start. First I designed the right and left side of the case. I took the mesurment of the width of the sheild and then added room for the servos to be pressed in. After taking all these mesurments I came up with a good design and added tabs for press fit. It came out looking like this in fusion:

For the front and back of the case I similarly took mesumrents of the sheild and servos and added a place for the tabs to the bottom and a place for the tabs on the side of the left and right pieces. Heres what it looks like in fusion:

Finally I made the top and bottom pieces of the case. These were similar to the front/back piece as they had space for the tabs. They are near idential except the bottom piece has an open middle area to activate power and easy access to the wires. Heres what they both look like:

Coding¶

One Leg¶

Two Legs¶

No External Power Source¶

All Four Legs¶

Final Project Requeirements¶

What does it do?¶

Its a quadroped robot that is controled using a web server that can be interacted with through a copper board that has step responce imbeded into it

Who’s done what beforehand?¶

This Fab Final Project by Karam Kharis is similar to mine but he made his more spiderlike as his final product

What did you design?¶

I desgined a pcb where the ESP32C3 would send signals to the servos, the leg attachment on the servos and the body that all of the electornics are put in. The PCB was designed in KiCAD and the Body and Leg were designed in Fusion360

What sources did you use?¶

What materials and components were used?¶

I used a double sided PCB, Bambu PLA and Servos for a majority of the project

Where did they come from?¶

The PLA came from the Bambu Website, the servos came from _ and the Double Sided PCB came from _

How much did they cost?¶

The project curretly will cost $46.44 dollars. This acounts for the board, microcontroller, servos, and power trigger. Since I’m using PLA and Wood thats at the Lab in a unique amount, I dont know how to add that to the cost

What parts and systems were made?¶

What processes were used?¶

I have milled to make the board, an interface to control the robot, addatice manufacuting to make the body and legs along with 3D design to create them.

What questions were answered?¶

What worked? What didn’t?¶

How was it evaluated?¶

What are the implications?¶