Week 7
AI prompt:
“Now need to generate an image when she started week 7, and she works with cnc machine, cutting her final project game board. It will be 1mx1m square, with labyrinth walls. The board has 10 NFC tags, and a car with nfc reader needs to collect that coins-tags, and when collect one, into lcd print "1/10" on the LCD, after collecting another "2/10" and when collect all 10 coins print "Win" on the LCD. The LCD timer needs to display the time and needs to collect all the coins within that time.”
computer-controlled machining
For the group assignment, we first discussed and documented the safety rules for using the CNC machine during the computer-controlled machining process. These rules included properly fixing the material to the machine bed, checking the tool and holder before starting, wearing safety equipment, keeping a safe distance during machining, and always being ready to stop the machine in case of emergency. Understanding these safety procedures is essential to prevent accidents and damage to the machine.
After documenting the safety rules, we performed a test cutting process to observe how the CNC machine works and to verify that the toolpaths and machine settings were correct.
We decided to include some parts of my individual assignment in the testing process, since they were good examples and also helped me move forward with my own project 😊.
One of the tests included joint connections, to check how the parts fit together. One case tested a tight-fit joint, where the pieces are intentionally difficult to insert, while another tested a self-locking joint, where the parts connect using their shapes without additional adjustments.
We also performed another test from my individual assignment: creating a grid structure using different types of fillets. One version used a normal fillet, while the other used a dog-bone fillet, which is commonly used in CNC machining to allow square internal corners.
All of these tests were cut on 12 mm thick plywood.
Additionally, we tested the labyrinth walls for the maze, which were cut from 6 mm plywood. This was also a joint test, but for a different material thickness.
Below are the final results of the tests.
For the individual assignment, I planned to manufacture the game board for my Final Project using a CNC machine.
For this purpose, I separated the parts of the labyrinth that I designed in OpenSCAD. The following components are required:
1. Bottom Base Plate
The first part is the bottom section, where the car will drive and where the entire labyrinth will be assembled. From the previous full OpenSCAD code, I separated the floor section with holes, and additionally added side joints to attach the walls.
It should be noted that I will cut this part from a 12 mm thick material, therefore the parameter is defined as: board_height = 12;
Below is the image of this part and the corresponding code.
board_x = 5;
board_y = 5;
board_z = 0;
board_length = 1000;
board_width = 1000;
board_height = 12;
wall_j_width = 6;
wall_j_length = 6;
wall_j_height = 12;
cell_size = board_length/10;// it's equal to car width/length(will be fine if car be quadrat)
module board(x, y, z, length, width, height) {
translate([x, y, z])
color("orange")
cube([length, width, height]);
}
module set_board_nets(x, y, z, length, width, height) {
for(i = [board_x + cell_size : cell_size/2 : (board_length)]) {
for(j = [board_y + cell_size : cell_size/2 : board_width]){
translate([i, j, 0])
color("red")
cube([length, width, height]);
}
}
}
module BoardWithNets() {
difference() {
board(board_x, board_y, board_z, board_length, board_width, board_height);
set_board_nets(board_x, board_y, board_z+2, wall_j_width, wall_j_length, wall_j_height);
}
}
module joint(tx, ty, coefficient1, coefficient2, coefficient3) {
translate([tx, ty, 0]) color("black") cube([board_height * coefficient1, board_height * coefficient2, board_height * coefficient3]);
}
projection(cut = false) {
union() {
BoardWithNets();
// Loop through regarding wich count joints I want to set side of my board, If I want to 3 joint need to set loop 1/4, 2/4, 3/4. if I want to 5 joint need to set this loop 1/6, 2/6, 3/6, 4/6, 5/6
for (pos = [1/5, 2/5, 3/5, 4/5]) {
offset = board_length * pos- board_height * 4;
// Bottom & Top sides
joint(board_x + offset, board_y - board_height, 8, 1, 1);
joint(board_x + offset, board_y + board_width, 8, 1, 1);
// Left & Right sides
joint(board_x - board_height, board_y + offset, 1, 8, 1);
joint(board_x + board_length, board_y + offset, 1, 8, 1);
}
}
}2. Side Wall Sectionse
Next, I separated the side wall elements, which are attached to the base.
For these walls, I added joints, and the number of joints is defined parametrically. Using the loop: for (pos = [1/3, 2/3])
I define how many joints should be placed. In this case, there are 2 joints.
If I wanted 4 joints, the loop could be modified as: for (pos = [1/5, 2/5, 3/5, 4/5])
These wall parts will also be cut from 12 mm thick material.
Below is the image and the code for this part.
board_x = 5;
board_y = 5;
board_z = 0;
board_length = 1000;
board_width = 1000;
board_height = 12;
board_wall_length = 160;
board_wall_width = 1000;
board_wall_height = 12;
//board_wall_heaight = 90;
board_wall_j_width = 6;
board_wall_j_length = 6;
board_wall_j_height = 12;
wall_j_width = 6;
wall_j_length = 6;
wall_j_height = 12;
wall_height = 60;
kerf = 0.2;
cell_size = board_length/10;// it's equal to car width/length(will be fine if car be quadrat)
module board(x, y, z, length, width, height) {
translate([x, y, z])
color("orange")
cube([length , width, height]);
}
module set_board_nets(x, y, z, length, width, height) {
for(i = [board_x + cell_size : cell_size/2 : (board_length)]) {
for(j = [board_y + cell_size : cell_size/2 : board_width]){
translate([i, j, 0])
color("red")
cube([length, width, height]);
}
}
}
module BoardWithNets() {
difference() {
board(board_x, board_y, board_z, board_wall_length, board_width, board_height);
set_board_nets(board_x, board_y, board_z+2, wall_j_width, wall_j_length, wall_j_height);
}
}
module joint(tx, ty) {
translate([tx, ty, 0]) color("black") cube([board_height-0.3, board_height * 8, board_height]);
}
projection(cut = false) {
union(){
// joints inner wall
difference() {
board(board_x, board_y, board_z, board_wall_length, board_width, board_height);
for (pos = [1/5, 2/5, 3/5, 4/5]) {
offset = board_length * pos - board_height * 4;
joint(board_x + board_wall_length/2 - board_height, board_y + offset);
}
translate([board_x+board_wall_length/8, board_y + board_wall_width/2 - 20, 0])
cube([10, 10, board_height]);
translate([board_x+board_wall_length/8, board_y + board_wall_width/2 +10, 0])
cube([10, 10, board_height]);
}
// Top and Bottom walls combined into one loop
for (y_pos = [board_y - board_wall_height, board_y + board_width]) {
difference() {
// The Wall
translate([board_x, y_pos, 0])
color("black") cube([board_wall_length, board_wall_height, board_wall_height]);
// The Cuts
for (pos = [1/3, 2/3]) {
offset_x = board_wall_length * pos - board_height * 2 + board_height / 2;
translate([board_x + offset_x, y_pos, 0])
cube([board_height * 2.5, board_height, board_height]);
}
}
}
}
}3. Wall with Joint Receivers
This wall is the receiving part for the joints.
The number of joint slots is defined using the same parametric logic as before.
2 pieces should be cut from each of these walls.
Below is the image and the code.
board_x = 5;
board_y = 5;
board_z = 0;
board_length = 1000;
board_width = 1000;
board_height = 12;
board_wall_length = 160;
board_wall_width = 1000;
board_wall_height = 12;
board_wall_j_width = 6;
board_wall_j_length = 6;
board_wall_j_height = 12;
wall_j_width = 6;
wall_j_length = 6;
wall_j_height = 12;
wall_height = 60;
cell_size = board_length/10;// it's equal to car width/length(will be fine if car be quadrat)
module board(x, y, z, length, width, height) {
translate([x, y, z])
color("orange")
cube([length , width, height]);
}
module set_board_nets(x, y, z, length, width, height) {
for(i = [board_x + cell_size : cell_size/2 : (board_length)]) {
for(j = [board_y + cell_size : cell_size/2 : board_width]){
translate([i, j, 0])
color("red")
cube([length, width, height]);
}
}
}
module BoardWithNets() {
difference() {
board(board_x, board_y, board_z, board_wall_length, board_width, board_height);
set_board_nets(board_x, board_y, board_z+2, wall_j_width, wall_j_length, wall_j_height);
}
}
module joint(tx, ty) {
translate([tx, ty, 0]) color("black") cube([board_height - 0.3, board_height * 8, board_height]);
}
projection(cut = false) {
union() {
// Main board with side slots cut out
difference() {
board(board_x, board_y, board_z, board_wall_length, board_width, board_height);
for (pos = [1/5, 2/5, 3/5, 4/5]) {
offset = board_length * pos - board_height * 4;
joint(board_x + board_wall_length/2 - board_height, board_y + offset);
}
}
// Add the top and bottom joints (tabs)
for (y_pos = [board_y - board_wall_height, board_y + board_width]) {
for (pos = [1/3, 2/3]) {
//offset = board_wall_length * pos - board_height*2 + board_height/2;
offset = board_wall_length * pos - board_height*2 + board_height/2;
translate([board_x + offset, y_pos, 0])
color("black")
cube([board_height * 2.5, board_height, board_height]);
}
}
}
}4. Labyrinth Walls
Finally, these are the labyrinth wall pieces.
In total, 64 wall elements must be cut.
My design logic is the following:
- The entire board is divided into 4 quarters.
- In each quarter, 16 walls are placed randomly.
- Therefore, for four quarters we need:
4 × 16 wall pieces = 64 walls
These walls will be cut from 6 mm thick material.
Below is the image and the corresponding code.
board_x = 5;
board_y = 5;
board_z = 0;
board_length = 1000;
board_width = 1000;
board_height = 12;
wall_j_width = 6;
wall_j_length = 6;
wall_j_height = 12;
wall_height = 60;
cell_size = board_length/10;// it's equal to car width/length(will be fine if car be quadrat)
projection(cut = false) {
union() {
//wall
cube([wall_height, cell_size, wall_j_length]);
translate([-wall_j_height, cell_size/2,0])
//joint
cube([wall_j_height, wall_j_length, wall_j_width]);
}
}All the files created in OpenSCAD must be rendered and then exported in DXF format.
From our FabLab, I took a 1500 mm × 1500 mm wood sheet. I divided it into two sections: 1100 mm × 1500 mm and 400 mm × 1500 mm.
I placed the larger piece on the CNC machine, fixed it securely, and then moved to the VCarve software to arrange the parts. During this process, I also considered the fixing areas by placing 60 mm diameter circular safety zones to protect the CNC machine.
Except for the holes, all other parts are cut using a 6 mm milling bit. For this reason, I saved my design in two separate files, so that after changing the milling bit I can load the second file and continue the process.
I selected the outer vectors and the joint sections and applied the Profile Toolpath command to cut them.
Then, by clicking on the created Profile, I opened the settings panel. Here it is necessary to select the correct milling bit size (6 mm) from the Tool → Select option.
I set Machine Vectors to Outside so that the corner edges are cut correctly and the dimensions of the design remain accurate.
Using the Add Tabs to Toolpath option, I added tabs to keep the pieces attached to the main board so that they do not detach during the cutting process.
After pressing Calculate, the green arcs indicate the positions of the added tabs.
And here is the process of selecting the milling bit (mill).
And here is the 6 mm milling bit with its holder, as well as the holder for the 3 mm milling bit.
For the joints, I again create a Profile Toolpath. By clicking on the created profile, I configure the settings as shown in the image below.
Then I save the profiles created for the joints and the side parts together in one place.
Now I apply the same settings for the slots, only changing the mill size to 3.175 mm, and then I save the file.
Here are photos from the cutting process.
And here are photos from the polishing process.
Then I placed the smaller wood(400mmx1500mm) piece on the CNC machine and started the cutting process.
VCarve-i process for my maze walls.
Push it into the CNC machine.
ays procesy krkneci 5 angam
mshakum em 70 wall
final procy
During Week 7 – Computer-Controlled Machining, I learned how to design and manufacture large physical objects using a CNC machine. The main goal was to understand the complete workflow, starting from parametric design to toolpath generation and physical fabrication.
First, I designed the parts of my Final Project game board using OpenSCAD, creating a parametric labyrinth structure. I separated the design into several components such as the base plate, side walls with joints, joint receivers, and multiple internal labyrinth walls. This parametric approach allowed me to easily control dimensions, joint positions, and the number of elements.
Next, I exported the models to DXF format and prepared them in VCarve for machining. I arranged the parts on the wood sheet, defined safe fixing zones, and created Profile Toolpaths. I also learned how to correctly configure cutting parameters such as tool diameter, outside vector cutting, and tabs to keep the parts attached during machining.
During the machining process, I used two different milling bits: a 6 mm mill for larger cuts and a 3.175 mm mill for smaller slots and precise areas. After setting up the CNC machine and fixing the material, I successfully performed the cutting process.
As a result, I produced all the wooden components required for assembling the labyrinth board of my final project. This week helped me better understand the relationship between digital design, machining parameters, and real-world fabrication constraints.
Individual assignment
AI prompt:
“and generate a new image when finished, week 7 " computer-controlled machining" The board is ready for the game.”