12. Mechanical Design, Machine Design¶
Our goal for these 2 weeks was to work as a group to design and build a functioning machine.
After a few weeks prior of discussing various different directions (including UFO catcher, chimaki maker, etc), we finally decided on an Onigiri (rice ball) shaping machine.
Assignment Goals:
1. Mechanical Design: Design a machine that includes mechanism + actuation + automation + application. Build the mechanical parts, and first operate it manually.
2. Machine Design: Actuate and automate the machine.
Individual documentations:
- Maki
- Shoko
- Midori
Final work:¶
Our Concept and Plan:¶
Our goal was to make an Onigiri (Rice-ball) making machine. We wanted to provide such and such delightful experience (make it easy to enjoy a home-made onigiri even during busy mornings).
Our strategy for the assignment was to focus on making a mound of rice into onigiri shape.
Below will be explored in further iterations:
x To extrude the right/desired amount of rice
x To put salt onto the onigiri
x Wrap it with nori(seaweed)
x Make it food-safe
1. Research¶
Desk Research:
We found that there are already expensive machines in the market.
No FabAcademy student/group had made an onigiri making machine before.
Field Research:
We went to try an onigiri shop in our neighborhood, Konga, which is extremely popular.
We thought these were the keys to this delicious onigiri shop’s great taste:
- The onigiri’s texture: not too tightly molded but not crumbly either, loosely held together by seaweed
- Just the right amount of saltiness
Midori also did some more reading up on an Onigiri magazine, and the key here seemed to be the pressure and speed at which rice is molded.
2. Scoping (Apr 10th)¶
During our first online local session, we drew out a potential onigiri making workflow, and scoped our goal for the assignment. We decided to focus first on 2: shaping the onigiri, and then if we have time, 3: shaping it softly with balloon hands.
3. Ideation and Prototyping¶
April 11th (Fri):
We cooked a big bowl of rice and explored different approaches to shaping the onigiri.
We particularly wanted to see how a balloon hand would work with real rice.
These are the 4 approaches we tried, and the results;
Our conclusion from that day was that in order to shape an onigiri which is not too crumbly (which would be hard for machine to handle) but not too hardly squeezed (which would not taste well), we could either mold the rice in 2 steps, or use a material like silicon mold or balloon to wrap around from the sides.
April 12th (Sat):
We spent the morning considering different mechanisms for shaping the rice.
- Nagano san showed us how filling an air-tight glove with air can potentially achieve an onigiri texture that would taste like it was shaped with real human hands.
.
- We also looked at this Fabricademy documentation on Soft Robotics, as a potential way to achieve the above.
- Nagano san and Rico also suggested using an Iris mechanism to achieve an adjustable triangular mold with just 1 gear.
After a morning of discussion, we agreed that each of us had different priorities/motivations for developing the machine.
But since we have limited time, we agreed to first focus on the basic Onigiri shaping part, and develop our ideal parts if we have time after that.
In the afternoon, Midori had to go attend a wedding. In the meantime, Shoko san and Maki san made a cardboard prototype of their ideal automated machine.
April 13th (Sun):
We decided to spend the morning prototyping different shaping mechanisms, and narrow down on one final approach by noon.
- First, we tested a basic mold: but we found it hard to release the onigiri from the mold without hitting it with hand.
- We also tested Midori’s iris structure: It seemed to work well, and it also had an added benefit of enabling onigiri size adjustment.
We all agreed to proceed with the 2nd iris structure.
In the afternoon, we assembled the outside frame, and tested the motorised mechanism for pressing down the rice from above.
4. Scheduling and Task Allocation¶
The tasks were divided as below.
We had some disagreements about the fairness of task allocation but it was decided this was a fair allocation.
It was later decided by management to break up the group so members would work separately on their assigned tasks.
Below is the rough schedule we initially decided to follow, followed by the actual progress;
| Step | Deadline | Initial Plan | Actual Result |
|---|---|---|---|
| 1. Decide on tasks and overall schedule | 13th (Sun) | Cardboard-prototype various mechanisms and agree on a feasible approach | Completed as planned |
| 2.1 CAD Design - Iris | 16th (Wed) | Midori except for gear, to be designed by Maki | Midori built and actuated everything including gear, but discontinued on 20th due to mechanical difficulty |
| 2.2 CAD Design - Press down mechanism | 17th (Thu) | Shoko | Shoko did CAD design and fabrication |
| 3. Coding | 17th (Thu) | Maki | Maki |
| 4. Fabrication | 18th (Fri) | Share the task according to situation | We each fabricated our assigned designs |
| 5. Assemble and test the mechanism | 19th (Sat) | Maki and Midori | Midori did Iris part, Maki did planB part |
| 6. Automate | 20th (Sun) | Maki and Midori | Midori did Iris part until discontinued, Maki finished planB machine |
| 7. Prepare for presentation (slide and video) | 22nd (Tue) | All together | Shoko |
Mechanism and Machine Design¶
1. Mechanism Design¶
1. Midori: Iris Mechanism¶
See Midori’s documentation here
2. Shoko: Down press Mechanism¶
 |
 |
|---|---|
| cardboard proto | sketch |
 |
 |
| Fusion Model | 3D print |
 |
 |
| press part | top part |
 |
 |
| rice test | assembly |
files
See Shoko’s documentation here
3. Maki: Plan B Mold Mechanism¶
2. Machine Actuation¶
1. Electronics¶
2. Final Codes¶
/*
Onigiri Make Controller Version 2
*/
#include <AccelStepper.h>
int x;
const int cncc_en = 8; // Pin for enable control CNCC
const int a_step = 2; // Pressing Part (X axis)
const int a_dir = 5; // Direction for A
const int b_step = 3; // Basement part 1 (Y axis)
const int b_dir = 6; //
//const int c_step = 4; // Basement part 1 (Z axis)
//const int c_dir = 7; //
const char sel_a ='a'; // Pressing
const char sel_b ='b'; // Basement
//const char sel_c ='c'; // 1 stepper moter in Basement
const char sel_all ='z'; // All
// Setting values for
int step_num = 200; // step number
int delay_time = 500; // Delay time
int step_num_a = 1600; // step number for Pressing (Ideal : 1600)
int delay_time_a = 750; // Delay time for Pressing
int maxspeed_a = 1000; // Max speed setting
int accel_a = 500; // Accelaration setting
int step_num_b = 300; // step number for Basement <- Basement setting
int delay_time_b = 1600; // Delay time for Basement
int maxspeed_b = 200; // Max speed setting
int accel_b = 200; // Accelaration setting
//Small step number
int step_num_L = 100; // step number
int delay_time_L = 1000; // Delay time
// AccelStepper
AccelStepper stepperA(1,a_step , a_dir);
AccelStepper stepperB(1,b_step , b_dir);
void setup() {
// Arduino pin setting
pinMode(cncc_en,OUTPUT); // Enable
pinMode(a_step,OUTPUT); // step setting for Pressing part
pinMode(a_dir,OUTPUT); // Direction for A
pinMode(b_step,OUTPUT); // Step setting for Basement1 part
pinMode(b_dir,OUTPUT); // Direction for B
// pinMode(c_step,OUTPUT); // Step setting for Basement2 part
// pinMode(c_dir,OUTPUT); // Direction for B
digitalWrite(cncc_en,LOW); // Set Enable Driver move by low
// AccelStepper
stepperA.setMaxSpeed(maxspeed_a); // For A(Steps/sec)
stepperA.setAcceleration(accel_a); // (Steps/sec²)
stepperB.setMaxSpeed(maxspeed_b); // For B(Steps/sec)
stepperB.setAcceleration(accel_b); // (Steps/sec²)
Serial.begin(9600);
// Serial.println("Which tool do you want to use?(1:Pressing 2:Basement):");
}
void loop() {
Serial.println("Which tool do you want to use?(a:Pressing b:Basement z:All(Not yet)):");
int step_val;
while (Serial.available() == 0) {
delay(100);
}
char key = Serial.read();
Serial.println(key);
if (key == 'a') {
up_down_loop(stepperA, step_num_a);
} else if (key == 'b') {
up_down_loop(stepperB, step_num_b);
} else if (key == 'z') {
move_control(a_step, a_dir);
delay(1000);
move_control(b_step, b_dir);
} else {
Serial.println("Invalid tool selection.");
}
}
void up_down_loop(AccelStepper& stepper, int smotor) {
char go = ' ';
int step_val = 0;
while (true) {
Serial.println("What do you want? (u:up d:down x:exit):");
while (Serial.available() == 0) {
delay(100);
}
go = Serial.read();
if (go == '\n' || go == '\r') continue;
Serial.println(go);
if (go == 'u') {
step_val = smotor;
} else if (go == 'd') {
step_val = -smotor;
} else if (go == 'x') {
Serial.println("Exiting operation.");
break; // 終了
} else {
Serial.println("Invalid input.");
continue;
}
// move motor
stepper.moveTo(stepper.currentPosition() + step_val);
while (stepper.distanceToGo() != 0) {
stepper.run();
}
}
}
/*
parameter: pin no, direction pin no, High/low
*/
void step_move(int move_pin, int dir_pin, float dir){
digitalWrite(dir_pin ,dir); // Set Dir High 正転/逆転
for(x = 0; x < step_num ; x++) // step_numステップ分繰り返す
{
digitalWrite(move_pin, HIGH);
delayMicroseconds(delay_time);
digitalWrite(move_pin, LOW);
delayMicroseconds(delay_time);
}
delay(1000);
}
/*
Control up/down or clockwise/counter clockwise
parameter (Port No, Direction No)
*/
void move_control(int port_no, int port_dir){
int UP_mode;
int DOWN_mode;
int st_n;
int dl_t;
char go = ' ';
// Set direction (As Pressing and shaping rotation are opposite )
if(port_no == a_step){
UP_mode = HIGH;
DOWN_mode = LOW;
}else if(port_no == b_step){
UP_mode = LOW;
DOWN_mode = HIGH;
}
Serial.println("What do you want?(u:up d:Down l:Low steps x:exit):");
while(go != 'x'){
if (Serial.available()){
go= Serial.read();
// Ignore line break and unnecessary characters
if (go == '\n' || go == '\r') {
continue;
}
Serial.println(go);
}
if(go == 'u'){
step_move(port_no, port_dir, UP_mode);
}else if(go == 'd'){
step_move(port_no, port_dir, DOWN_mode);
}else if(go == 'l'){
step_num = step_num_L;
}else if(go == 'x'){
return;
}
go = ' ';
delay(1000);
}
}
Final Design and Reflections, Key Learnings:¶
Final Design:
¶
Simple Machine::
Discontinued Iris mechanism:
Reflections, Key Learnings:
¶
- Did we work and communicate effectively as a team?
- How did we design, plan and build a machine?
- How did we analyse and solve problems?
- What are possible opportunities for improvements in the project