Machine Design

This week we’re building a machine together. Samson, Pieter and I are assisted by the Fablab interns Maria and Ella.

Here are Pieter’s and Samson’s documentation pages on this week:

• Pieter’s week 10 documentation
• Samson’s week 10 documentation
• Link to the group assignment page for this week

Brainstorm

On Thursday morning after Saco’s lecture we started by checking everyones availability in the coming two weeks since our calendars are quite a ‘gatenkaas’ (cheese with holes) as we call it in Dutch. After that we started a brainstorm session. Inspired by the bowl of Easter chocolate eggs and Pieter’s frustration that he has to get up to grab some chocolate instead of it coming to him automatically, Samson’s passion for animatronics and my love for chicken, we quickly decided on a chicken ornithopter that can lay chocolate eggs.

Our first goal is to make it fly, and to be able to control its flight, so that is our primary focus. Since there is a pretty good chance that it’s going to be trickier than we hope, we have some back-up ideas to bring our chicken to life. Some possible spirals:

• Flying/flapping for short distances (like a real chicken)
• Walking (think Theo Jansen’s strandbeesten)
• Bopping its head
• Screaming chicken sounds
• Laying chocolate Easter eggs

We gave ourselves the deadline of Tuesday the 4th at the end of the day to make our chicken fly.

Ornithopter: first iteration

In Fusion, I made a first sketch of an ornithopter body based on designs in this instructable (t’s not a very clear instructable). There is space for a DC motor and a slot for wings to be attached through the body.

First iteration:

Then I sketched out some wings and reinforcement to attach to the gear system.

I placed the separate parts on a drawing and exported as DXF to lasercut. The body is made from 2.8mm plywood and the wing from paper; we’re going to use a different material for the wings so this is just for prototyping purposes.

In the meantime, Ella and Maria worked on a staggered crank prototype to attach to the DC motor, to make the wings flap simultaneously. This is what that looks like:

This is the assembled prototype; the crank mechanism is not attached to the wings because the motor and wings are too close together.

The wings ‘fly’ calmly when moving the ornithopter up and down:

As a reflection on the first day: we kind of all started like chicken without a head after dividing the tasks. I didn’t know what mechanism Ella and Maria were developing and I just started making a sketch without discussing with them. That’s obviously not very smart.

On Friday I continued with the mechanical design, with a goal of having a way to attach the wings to the DC motor and having them move up and down simultaneously. I also wanted to make a prototype of the body of the chicken, because the ornithopter from Thursday was looking too much like an ornithopter. I needed the chicken as a motivation and inspiration.

Chicken design

To make the body of the chicken, I used this 3D model of a chicken from Thingiverse. Then I sliced it in Slicer for Fusion360 with interlocked slices. I moved some of the slices around so there would be enough space for wings to flap freely.

I exported the plans and loaded them into Lightburn. I used a material thickness of 3mm, but the material that I ended up using was about 2.7mm thick so I used a combined offset and kerf offset of 0.25mm. The slots were still too wide so we used hot glue to keep the chicken together. This is what the chicken looks like assembled and with the prototype of the wings on the inside:

Here an impression of the future flying chicken:

Mechanical design

We decided against the staggered crank mechanism, because it didn’t feel very reliable and stable. Samson sent me this example of a simple flapping mechanism with a bunch of gears:

I looked at it with Saco, and he said that it was kind of overkill: there are four gears and they transfer the motion from motor gear to bottom gear, bottom gear to right wing gear, and right wing gear to left wing gear. Saco advised to only use the gear on the motor and the bottom to make it simpler. What it comes down to then is to make a single gear crank:

Gears

So what we needed was a set of gears. I downloaded this OpenSCAD parametric gear maker from Thingiverse to make them. The kind of gear that we need is a spur gear.

This is the information provided on the Thingiverse page:

To make a pair of spur gears mesh, they must have the same circular pitch and pressure angle. Look in the console window and you will see the pitch radius of each gear produced. The axes of two gears must be separated by the sum of their pitch radii to mesh correctly. Use the backlash option to allow for the gears to work with printing inaccuracies.

These are the settings used to create the small gear attached to the motor:

gear (number_of_teeth=12,
circular_pitch=100,
	gear_thickness = 10,
	rim_thickness = 10,
	hub_thickness = 10,
	circles=0, bore_diameter=2);

And these are the settings used to create the big gear:

gear (number_of_teeth=120,
circular_pitch=100,
	gear_thickness = 2,
	rim_thickness = 2,
	hub_thickness = 2,
	circles=8, bore_diameter=2);

The pitch has to be the same for both of them. The number of teeth on the big gear is 10 times bigger than the number of teeth on the small gear attached to the motor, which means that for one revolution of the big gear, the small gear has to make ten revolutions. Like this we can mechanically change the speed of flapping which is very useful for our DC motor (6000 RPM is a bit much).

I printed them on the Prusa MK3S with PLA. Note that the bore diameter that I used was too small; I had to use a drill for the big gear to make the screw fit, and heat and force (and Saco’s help) for the small gear to make it fit onto the motor shaft.

Ornithopter: second iteration

Now that the crank mechanism was clearer, I made a new design for the body. Saco advised to sandwich the motor and to get rid of the plane shape of the body as we’re not going to use it. I tried adapting the previous design but in the end I just started over since it was easier.

I had to lasercut it a couple of times because each time I forgot to add a small measurement, but finally I got a perfect press-fit that could be assembled with the gears. The gear is attached with an M3 bolt and a couple of washers and a nut. I also lasercut a bigger spacer from 3mm acrylic that was a bit wider to make the gear more stable.

Then I needed a way to attach the arms to the gears and to the wings. The arms are currently attached with an M2 bolt and desperation, and it has to be more stable. I made a new front plate in Fusion with a an array of circles as possible joint positions.

Here it is assembled:

I looked at this image from this tutorial with various crank mechanisms with Maria, and we figured that the top right one was closest to what we were trying to achieve. To get something similar, I drew two small rectangles with circles directly in Lightburn that could function as the cranks, and two long rectangles with circles that would be the wing supports (the rockers).

When assembling I realized I only needed one crank. I tried various assembly combinations then drilled two holes in the front plate because I needed them to be further apart. This is the final assembly:

And here I taped the mechanism to the inside of the chicken:

Intermediate reflection

Mechanisms like these only start to make sense once I have them in my hands; that’s why sketching them is pretty useless for me. Since I was combining example mechanisms I didn’t have a clear idea of how it was going to actually work until the final step. There are plenty of ways to make a flapping mechanism and I was looking into the best option while making. On Friday evening I eventually figured out how this single gear mechanism actually was going to work, and that it was pretty simple; in my head it was way more complicated to get the wings to flap at the exact same time.

To do

• The distance between the big gear and small gear is a little too much, and you can see it’s still a little wobbly. The front plate’s bottom hole has to be slightly higher (about a mm) and bigger because I used an M4 bolt.
• The crank can be a little longer, so it can be attached to the bottom hole in the gear. If it’s connected there, you can lasercut a bigger spacer so the gear wobbles less
• Test if the speed of the flapping is okay now: if it’s too fast, we can make a big gear with more teeth, but that also means the gear will be bigger and the front plate will be taller. Instead of mechanical speed control, we can also use PWM

Sources

• https://www.instructables.com/Opensource-Ornithopter-Prototype-Arduino-Powered-a/
• https://hackaday.com/2018/05/11/scratch-built-ornithopter-heres-how-i-flapped-my-way-to-flight/
• https://www.instructables.com/make-an-ornithopterchirothopter/
• https://github.com/dantiel/arduino-flight-controller
• http://fab.cba.mit.edu/classes/863.17/EECS/people/akaspar/project/
• http://fabacademy.org/2018/labs/fablabbeijing/students/dian-song/finalproject.html
• https://www.youtube.com/watch?v=G9SVLQmqO4E

Starting over

On Tuesday we continued working on the flying chicken, but we weren’t really working together as a group. I continued on improving my single gear mechanism while Pieter continued with his own version he started on the day before, and Samson worked on the wings.

My gears were somewhat working but the motor had to work really hard because there was too much resistance, even with a bearing. It was really easy to stop the motor with your finger, so it wouldn’t be enough torque to make a wing flap let alone flap fast enough for flight.

We had set a deadline for Tuesday afternoon to have something flying, and we were not going to make it at all. Tension was building up as we were not communicating and it made the project frustrating. We didn’t have a clear vision of what we were doing and we were just continuing stubbornly with what we wanted but weren’t sure was going to work. We sat down together with Henk to decide on what to do now. The weight budget and battery troubles turned it into a really complicated and technical project, and we are no experts on mechanical design yet.

New idea

Easter egg shooting machine

At this point we could decide to continue, or we could start over. The only thing that would be lost if we wouldn’t make an ornithopter is the flying mechanism research we have done, but it hasn’t really gotten us into flight yet. We decided to start over and head back to the drawing table. One of the other ideas we had on Thursday was an Easter Egg shooting machine. This is a machine that would allow us to work more in spirals and to divide tasks easily. We (finally) made a sketch together:

We divided the tasks for Tuesday and Wednesday:

• I worked on an egg dispenser with a servo motor
• Samson worked on the shooting mechanism with DC motors
• Pieter worked on the rotating platform with a stepper motor

We had all kinds of wild ideas to control the shooting of the eggs, but Henk warned us to work in spirals and to focus on making something work first. So we decided to first make the machine work with buttons, and see if we can use different sensors (like actuating it by waving at it with an ultrasonic sensors) or Bluetooth after we have a working machine (spoiler: we didn’t have the time). We tried to involve each other more in the things we were working on this time and focus on actually working together.

Servo egg dispenser

Mechanical design

To dispense the eggs, we figured we needed a reservoir for the Easter eggs. We figured a bowl or a funnel could work so we looked around the lab what could work. I found a transparent acrylic tube that could function as our egg reservoir, so I started from there. To make the ‘door’ open for the eggs I used a SG92R micro servo. For the prototype for the egg dispenser I quickly sketched some circles in fusion with a cut-out for the servo, and at the end of the day I had a first mechanical prototype for the egg dispenser:

The next day, we were all together again. Samson mounted the DC motors and ramp on a heavy piece of wood and I made a holder for the acrylic tube that could fit above the ramp. It’s a simple design in Fusion:

Here you can see them together:

Programming the dispenser

I used an Arduino Mini Pro since it’s smaller than an Arduino Uno, fits on a breadboard and has plenty of pins available. This is the pin-out:

I adapted a basic Arduino code to figure out the timing for the servo opening and closing, so it would let out one egg.

#include <Servo.h>

int servoPin = 6;
int servoPos = 0;
Servo myServo;

void setup() {
  Serial.begin(9600);
  myServo.attach(servoPin);
}
void loop() {
  for (servoPos = 180; servoPos >= 110; servoPos--) {
    myServo.write(servoPos);
    delay(3);
  }
  for (servoPos = 110; servoPos <= 180; servoPos++) {
    myServo.write(servoPos);
    delay(3);
  }
}

Here you can see it working:

Now it opens and closes just fine letting one egg out, but the next problem presents: the eggs easily find equilibrium above the dispensing hole. When they are all balanced above the hole, no eggs come out.

I first tried to make a cardboard funnel like this:

But that didn’t help; then I tried to make a structure inspired by the marble calendar with rings and metal wire but that didn’t work either (mostly because I didn’t do it very well). After multiple tries the next attempt was a bunch of donut shaped spacers and stacked them together. What this does is basically just moving the problem up, but as long as there are eggs in the ‘tube’ it’s dispensings eggs pretty OK so for this spiral it’s fine.

Actuation: button

The next step was to add a button to the mix. This will function as the input for the servo, and later to get the whole system going. These were my reference images for the wiring of the button:

It’s working, but the timing of the servo has to be adjusted.

This is the updated code used:

#include <Servo.h>

int servoPin = 6;
int servoPos = 0;
Servo myServo;

int inputPin = 7;  // pushbutton pin

void setup() {
  Serial.begin(9600);
  myServo.attach(servoPin);
  pinMode(inputPin, INPUT);  //declare pushbutton as input
}
void loop() {
  int val = digitalRead(inputPin);  //read input value
  if (val == HIGH)  //check for input is HIGH
  {
    for (servoPos = 180; servoPos >= 110; servoPos--) {
      myServo.write(servoPos);
      delay(3);
    }
    for (servoPos = 110; servoPos <= 180; servoPos++) {
      myServo.write(servoPos);
      delay(3);
    }
  }
}

The dispenser working together with the DC motor and slide system:

Then after this the servo for the egg dispenser broke (we heard it make sound, but there was no movement), so I had to take the assembly apart again to replace the servo. I hot glued everything so I just used appropriate violence. The servo’s top got loose so the gears on the inside didn’t interlock anymore, so that’s why it stopped working.

For the next iteration with a brand new servo, I had to made new spacers for the bottom of the egg reservoir. To protect the servo from falling apart in the future I added some duct tape around the top. You can still see some hot glue desperation in the assembly of the reservoir.

Building a system

DC motors and relay

The next day my focus was on integrating the separate motors into one system, using an Arduino Mini Pro and a breadboard, and on powering the individual parts separate from a power bench. Samson’s DC motors were connected directly to the power bench so I started with connecting them to a relay so they could be powered with a 12V USB adapter. The relay is the component getting a high or low signal from the Arduino pin it’s connected to and transfering this to the motors: when it’s high the DC motors receive 12V, when it’s low they’re off.

This is how they have to be wired:

The power supply that we’re using has a male jack output. I grabbed a female connector from the electronics corner to solder wires, to the relay and ground like above (below the positive and negative as a note to self).

Before and after soldering:

Stepper motor

For the stepper we’re using an A4988 stepper motor driver. To wire the stepper motor I copied the wiring that Pieter used which corresponds to this:

The relay is only necessary for the DC motors, because the stepper motor driver has integrated power regulation. This means you can just solder the power and ground directly to the 12V power supply.

I used this code to test the stepper motor on the Arduino Pro Mini:

/*   
 *   Basic example code for controlling a stepper without library
 *      
 *   by Dejan, https://howtomechatronics.com
 */

// defines pins
#define stepPin 9
#define dirPin 8
 
void setup() {
  // Sets the two pins as Outputs
  pinMode(stepPin,OUTPUT); 
  pinMode(dirPin,OUTPUT);
}
void loop() {
  digitalWrite(dirPin,HIGH); // Enables the motor to move in a particular direction
  // Makes 200 pulses for making one full cycle rotation
  for(int x = 0; x < 800; x++) {
    digitalWrite(stepPin,HIGH); 
    delayMicroseconds(700);    // by changing this time delay between the steps we can change the rotation speed
    digitalWrite(stepPin,LOW); 
    delayMicroseconds(700); 
  }
  delay(1000); // One second delay
  
  digitalWrite(dirPin,LOW); //Changes the rotations direction
  // Makes 400 pulses for making two full cycle rotation
  for(int x = 0; x < 1600; x++) {
    digitalWrite(stepPin,HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin,LOW);
    delayMicroseconds(500);
  }
  delay(1000);
}

To keep the breadboard organized I added some labels to the wires and I tried to keep the wires that had to cross the breadboard short, but it still looked like a mess. In the photo you can also see the cardboard box that I made with makercase.

Actuation: joystick

The code above was working just fine, so now we needed a way to control the direction the stepper would move in. We first thought of a stepper motor platform that would rotate back and forth and would stop and fire an egg when triggered; however we imagined it would be very hard to actually aim it at yourself when it’s a couple of meters away and you have to time exactly when to stop the machine. We thought it would also be cool to be able to steer the platform yourself, so that’s what I worked on next. I first wanted to use two buttons for clockwise and counterclockwise motion, but when looking through the button box I found this amazing joystick and its wiring (it took a while before I figured out what kind of joystick it was). It’s a digital 8 way joystick.

I used this Youtube video as a reference on how to work with it in Arduino (the link is timestamped to the code I used). Here you can see the motors, button and joystick forming a system together; the stepper still has to be attached to the rotating platform, but that doesn’t matter for the code. The DC and stepper motors are powered with a 12V USB power supply, the rest is powered via my computer for now.

This is the code used:

#include <Servo.h>

int servoPin = 6;
int servoPos = 0;
int servoPin2 = 10;
int pos = 0;
Servo myServo1;
Servo myServo2;

int dcPin = 5;

int inputPin = 7;  // input pin for pushbutton

#define dirPin 8
#define stepPin 9

int leftPin = 16;
int rightPin = 15;
int upPin = 14;
int downPin = 17;

int leftValue = 0;
int rightValue = 0;
int upValue = 0;
int downValue = 0;


void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  myServo1.attach(servoPin);
  myServo2.attach(servoPin2);
  pinMode(inputPin, INPUT);  //declare pushbutton as input
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  pinMode(leftPin, INPUT_PULLUP);
  pinMode(rightPin, INPUT_PULLUP);
  pinMode(upPin, INPUT_PULLUP);
  pinMode(downPin, INPUT_PULLUP);
  pinMode(dcPin, OUTPUT);

}
void loop() {
  // put your main code here, to run repeatedly:
  int val = digitalRead(inputPin);  //read input value
  if (val == HIGH)   { //check for input is HIGH
    digitalWrite(dcPin, HIGH);   // turn the RELAY on
    delay(3000);                     // wait for a second

    for (servoPos = 115; servoPos >= 30; servoPos--) {
      myServo1.write(servoPos);
      delay(3);
    }
    for (servoPos = 30; servoPos <= 115; servoPos++) {
      myServo1.write(servoPos);
      delay(3);
    }
    delay(20);

    for (pos = 0; pos <= 120; pos += 1) { // goes from 0 degrees to 180 degrees
      // in steps of 1 degree
      myServo2.write(pos);              // tell servo to go to position in variable 'pos'
      delay(50);                       // waits 15ms for the servo to reach the position
    }

    for (pos = 120; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
      myServo2.write(pos);              // tell servo to go to position in variable 'pos'
      delay(15);                       // waits 15ms for the servo to reach the position
    }
  }
  digitalWrite(dcPin, LOW);    // turn the RELAY off

  leftValue = digitalRead(leftPin);
  rightValue = digitalRead(rightPin);
  upValue = digitalRead(upPin);
  downValue = digitalRead(downPin);

  Serial.println(leftValue);
  Serial.println(rightValue);
  Serial.println(upValue);
  Serial.println(downValue);


  if (leftValue ==  LOW) {
    digitalWrite(dirPin, HIGH); // Enables the motor to move in a particular direction

    digitalWrite(stepPin, HIGH);
    delayMicroseconds(700);    // by changing this time delay between the steps we can change the rotation speed
    digitalWrite(stepPin, LOW);
    delayMicroseconds(700);
  }
  if (rightValue ==  LOW) {
    digitalWrite(dirPin, LOW); //Changes the rotations direction
    // Makes 400 pulses for making two full cycle rotation
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }
}

As you can see in the video the DC motors have to run for a bit longer because they shut off before launching the egg. We tried to add a delay before shutting it off, but that actually made the entire system not work anymore (it took a while before we figured out that the delay was the problem). On Friday I wasn’t in the lab but Samson and Pieter continued working on the rotating platform and on finetuning the code. Then it was the Easter weekend already when I went to Brussels; on the train back I worked on the group documentation.

Bringing everything together

On Tuesday it was me and Pieter in the lab; Pieter worked on the video to present our machine and process while I worked on bringing the parts of the machine together and making the machine look good. Right now it’s a working system, but it’s not an elegant machine. The stepper motor platform is working, so now we have to move everything from the prototype platform to the fancy rotating platform.

Slide

The first thing I did was to design a new slide in Fusion to replace the cardboard prototype. I took measurements from Samson’s slide and made a sketch:

‘De Legbatterij’

In Fusion I turned it into this slide; this was also the moment that we had to come up with a name, because I figured we could laser cut it out of the side. After some great suggestions from Maria (the Scrambler 2000) Pieter suggested ‘de legbatterij’, which is Dutch for a battery cage for chicken (side note: they’re luckily illegal in the Netherlands). We liked the reference to electronics and to chicken, and in the context of our egg shooter, it gives the suggestion of a chicken that broke free and took power of her own life while weaponizing her eggs.

The slide had to be made 10mm higher because the stepper motor pushing the egg to the DC motors was too high for the previous version. I reused the platform that Samson made for the DC motors but glued a new lasercut rectangle with two small holes for the shafts to the top, to stop the DC motors from sliding up because of the vibrations each time they were running. I used the same scrap OSB wood as a spacer for the motor platform and the rotating platform.

Box for actuation

I had made another parametric press-fit box with makercase, this time making a box with round corners. In Lightburn I added two circles to the top: one for the button and one for the joystick. Pieter finished laser cutting it while I worked on the slide and platform for the DC motors. I wanted to make a really long cable between the button box and the canon but Henk said it really was not our priority and a waste of materials. As a compromise I reused the longest wires I could find in the wires box. The box can be seen in the picture above.

Replacing the egg reservoir

Since the tube wasn’t really doing much as an egg reservoir (the equilibrium above the hole problem was still unresolved) we decided to get rid of it. I cut off most of the tube and replaced it with the chicken I made with Ella and Maria a week earlier while we were still working on the flying chicken. Now we’re full circle back to the chicken:

Cable management

I drilled a hole in the platform so I could route the cables to the breadboard that was hidden between the rotating and stationary platform. It’s hidden under the slide so you don’t see it when you operate the machine. The cable management itself is based on the principle ‘out of sight, out of mind’.

Testing the assembly

After rerouting all of the wires, a lot of soldering and triple checking all connections, iterating on angles and heights and a lot of glue it was time to test again (Ella in the danger zone). Ella was holding the DC platform in place to check its position. After this I screwed it onto the rotating platform because the current position was working.

A finished machine

The machine settled in its new home position, replacing the Easter egg bowl that caused Pieter so much frustration:

She fits right in:

On Wednesday morning we were all together again and we shot the final shots for our video. I added a cable cover for the front of the DC motor platform, made from paper (visible in the video). I finished the group documentation and helped Samson with the slide.

Video

This is the final video, beautifully edited by Pieter:

Slide

Slide made by Samson:

Files

These are the parts I designed for the Scrambler:

• Slide (Fusion Archive file)
• Chicken holder and egg dispenser (Fusion Archive file)

And these for the ornithopter:

• Lasercut plans for chicken (3mm)
• Ornithopter frame version 1 and two - STEP files

Lecture notes

Saco’s lecture

Machine: a device that uses power to perform actions to achieve tasks

Basic parts of a machine:

• structural components
• mechanism
• actuators
• sensors
• controllers

Functional Breakdown Structure (FBS)

• what does it have to do?
• which functionality do you need for that?
• what can be combined and what has to be separated? Product Breakdown Structure (PBS)
• what does it look like?
• what parts and (sub)systems do you need?
• how can the machine be built?

kinematic coupling 3 legs > stable 4 legs > not so much (think wobbling tables) > overdetermined

(In)accuracy

• play/hysteresis
• stiffness
• error chain & force loops
• shapes: perpendicularity, flatness, parallel, symmetry etc
• position

resolution vs accuracy ability to show/produce details vs ability to be correct or exact

Movement control

• cam-followers (for example wedge shape cam, think ‘scraping for gold’ artwork mechanism)
• slot-followers
• linkage mechanism
• step sequence control

Neil’s lecture

Mechanical design

• Kinematic coupling: designed to exactly constrain the part in question, providing precision and certainty of location

• Maxwell (6 contact points because of spheres) & Kelvin kinematic coupling:

• There is many many many kinds of nuts
• Rapid prototyping of rapid prototyping machines
• Rivets are great for joints
• Metal extrusion that are T-slotted are great for frames
• Magnets are fun for panels that you want to remove easily
• Involute gear is the most common gear, moves smoothly and continuously (opposite to )
• Cycloidal gears are easier to mill
• Helical gears

• Herringbone gears

• Belts to transmit forces, flexible transversely but you can’t stretch them; has teeth
• Kevlar thread (stronger than steel) > you need a sprocket
  • Capstan drive (see 3D printed modular things beehive axes)
• Chains: for way heavier forces (like a motorcycle)
• Threaded rods
• Treadless rods with a screw shaft

• Harmoic drives > often used for robot joints

• Linkages are cool
  • https://digital.library.cornell.edu/collections/kmoddl
• Pantographs: amplifying motion
• Hangprinter
• Look at all of the mechanisms

Machine design https://www.youtube.com/@thang010146 PID: proportional integral derivative