DF_Lab Journal Brian Duong 761765

DF_LAB: Designing Making ABPL90378

Journal Brian Duong

I am currently completing my Masters of Architecture. I have a strong interest in computational design and incorporating parametricism into my workflow whenever possible. I want to explore the possibilities of what architecture can be.

Brian Duong

Preface

Throughout the course of this subject, we undertook research and developed our concept to eventually realise a built prototype by the end. This journal explores my involvement in the project which was heavier on the Grasshopper and digital fabrication side of the project.

1.0_Research

The beginning of our project started with being assigned 3D Printing as our fabrication technique. From here, we explored a number of innovations in the realm of 3D printing. The research conducted in the early stages led to the development of our project later on in the process.

Printing

3D Printing is an additive fabrication method. It generally fuses material together layer by layer to generate a 3-dimensional form. There are a number of different types of 3D printing techniques which use this underlying concept. Some more common ones are:

Fused Deposition Modeling (FDM)

Stereolithography (SLA)

Selective Laser Sintering (SLS)

Multi Jet Fusion (MJF)

Image Source: https://www.3dhubs.com/

Fused Deposition Modeling (FDM)

This type of printing uses a nozzle to extrude heated material out layer by layer until the final three dimensional form is complete.

Advantages

Good for quick prototyping

Variety of printing materials

Innovative processes like nonplanar printing are possible

Cost effective and accessible

Limitations Visible layer lines

Lower level of detail compared to other printing methods

Slow for large scale manufacturing

Support structure is needed

Source:

Image Source: https://www.3dhubs.com/

Stereolithography (SLA)

This printing technology uses a laser that cures a vat of photosensitive resin layer by layer to form a solid three dimensional shape.

Advantages

Higher quality print detail

Smooth finishes are possible

Transparent prints are possible

Limitations

Prints can be brittle

Support structure is needed

More post processing is generally needed

Image Source: https://www.3dhubs.com/

Selective Laser Sintering (SLS)

This type of 3D printing uses a laser to sinter a polymer powder causing it to fuse to form a three dimensional shape.

Advantages

Higher quality print detail

No supports are needed

Good for highly intricate printing

Limitations

Not as accessible as FDM and SLA

Surface finish is porous so may need post processing

Image Source: https://www.3dhubs.com/

Multi Jet Fusion (MJF)

Similar to SLS, it uses a bed of powder which is built up layer by layer. It uses a combination of fusing agent and infrared light to create the three dimensional form.

Advantages

Higher quality print detail

No supports are needed

Good for highly intricate printing

Limitations

Not as accessible as FDM and SLA

Surface finish is porous so may need post processing

Parts can be dyed various colours

Image Source: https://3dprintingindustry.com/

Non-Planar Printing

Typical FDM printing builds up 3D prints layer by layer. Non-planar printing utilises the z-axis to print three dimensionally. This concept can be extended to similar technologies that use extrusion such as clay extruders.

Image Source: https://www.nonplanar.xyz/

Image Source: https://3dwithus.com/creality-cr-30-3d-printer-3dprintmill

3D Print Mill

This technology increases the feasibility of larger scale manufacturing. By printing on a belt, the print area frees up space for more prints to be formed.

Al Bahar Towers, Abu Dhabi

This was the initial inspiration for the articulation element of the facade. It uses a simple mechanism to create a more complex folding motion of the module. Similar qualities inspired our initial ideation and prototype.

Snakebot, Carneige Mellon University

As we started to look into more of the robotic pathways for the project, this research project gave inspiration to articulating joints and modules that were able to articulate off each other with simple motions to produce overall complex movement.

2.0_Ideate

Off the basis of our research, we begun to develop ideas that tried to bring together the fabrication technology, the brief and the site. Within our development, there were ideas of variation, localisation and interaction within the facade.

2.1_Early Ideation

An initial idea that we explored was to have size adjustable panels which reacted to certain parameters in order to increase or decrease shading and views inwards and outwards. We wanted to take advantage of the capabilities of 3D printing, primarily the nature of bespoke parts to create a facade that was made up of irregular panels. In further development, the idea of articulating panels was built upon while irregularity was reduced for feasibility purposes.

2.2_Prototyping

Our first prototype towards generating an array of panels that were able to articulate began with this. The panels consist of smaller segments which, through a system of cables are able to fold open and closed depending on external parameters. A combination of 3D printed parts were used for elements that required bespoke design while consideration for commonly sourced materials were used when possible as a way to simplify future production and fabrication at possible larger scales.

Since the purpose of this prototype was to test the feasibility of the construction as well as set up a framework to expand the system to a larger, modular scale, I opted to use parametric design to allow quick changes to be made throughout the process. This workflow is used throughout the project.

Frame Panel Labelling

The overall structure of the script to generate this form is divided into three sections: the frame, the panel, and labelling. There are a number of elements to consider in each of these sections for the overall module to function as intended.

To begin with, a triangle is used as a base for where the surface of the panel will be located. The edges and centre are obtained from this and lines are drawn between the points to generate the framework for where the structural frame will be.

These base curves are then piped to represent the structural pvc piping that will be used to build the prototype. Additionally, the thinner pipe is used to represent the location of the cable that will be used in the prototype to articulate the folding panels.

Next, the end segments of the curves are taken and additional pipes are created to form the corners of the module which join the pvc pipes together. The pipe solid is subtracted from the corner joints to form the recess for where the pvc pipe will fit into place.

The resulting representation of the base frame is combined into a single geometry in order to later account for when generating the panels.

The panel is initially generated by using a delaunay mesh to produce the 3 smaller panel segments. Some tolerance is accounted for here.

The existing frame elements are then subtracted from the panels to avoid any intersections between the elements. As well as this the panels are further split into 2 to form the folding seam for each panel.

Next, connection details are created for connecting the panels together. These are generated using a combination of simple pipes and box geometry.

The connecting panel joints are joined to the panels and tolerances are adjusted so that the pieces will fit together well.

The final outcome of geometry are panels with the structural frame. This model represents both the 3D fabricated parts as well as the off the shelf parts.

This geometry represents the 3D fabricated components. In hindsight, opting for a lasercut panel instead of 3D printed would be preferable.

Overall, the fabrication of the prototype module revealed to us a number of considerations that affected the performance of the physical model.

We ran into some issues while putting together the prototype due to some lack of foresight while in the design process of creating it. Some of these include:

Tolerances - the connection joints, although some tolerances were taken into account, some pieces did not have enough tolerance resulting in parts that did not fit well together and required extra sanding and work to be done. This also resulted in cracking of some 3D printed parts with the tighter fits.

Friction - In addition to close tolerances, friction between the rope and the 3D printed parts caused the mechanism to be quite stiff and require a substantial amount of force to move.

Labelling - Although, labelling each part was done, some numbers came out illegible, so we ended up not being able to use them.

The prototype of the module gave us an idea of the challenges that are faced when realising a design and translating it from a digital model to a physical prototype model. Although there were a number of issues with the prototype model, it was still able to capture the concept and mechanical articulation we were intending to accomplish.

3.0_Midsemester

For the midsemester presentation, we shifted our concept and pushed towards are more innovative idea. The purpose of midsemester was to build up our idea to propose the concept which could then further be developed and refined.

3.1_Concept Development

After the first iteration of design, prototyping, review and feedback, we wanted to push our design towards a dynamic facade that would open up more possibilities and opportunities if developed further.

In doing so, we brainstormed and generated a number of ideas with the core concept of expanding the modular system so that we were looking at the facade as a whole as well as incorporating interactive elements within the design.

These are some iterations of module ideas with coordinate like systems that could move panels horizontally and vertically. They, however still lacked a third dimension of movement and control that we were after.

With some guidance we were able to push our design towards a robotics and mechanically articulate concept. The core idea was to use modules that were able to cooperate with each other to morph into various arrangements.

With inspiration from projects such as ‘snakebot’ which uses simple core movements to achieve overall complex articulation, we came up with an idea of folding panels which were able to couple and decouple with neighbouring panels, allowing them to fold out in different arrangements.

With this core idea, we were able to refine it further to react to various environmental conditions as well as interact with dynamic conditions.

3.2_Facade Parametric Model

Generate Panels Organise Panels Transform Panels

This was the initial generation of the panels in the context of the facade on the building. In order to fold out the desired panels, I needed to organise the panels in a rational way that allowed me to select the correct panels to rotate.

For this reason, this script is divided into three main sections: panel generation, panel organisation and panel transformation.

Additionally, this is where I began to build the foundation for generating panels in future scripts, so I tried to create a script that would be robust and flexible enough to be used in future contexts.

The generation of the panels begins with referencing in the area that the panels will fill. I used the area located on building for context.

Since the triangular panels are generated based off the number in the u and v directions of the surface, in order to generate triangles of a particular dimension, the reference area needs to be redrawn to the right dimensions.

In order to do this, I took the existing dimensions of the areas and divided them by the desired height and width of a single panel. This gives

the approximate number of panels in the u and v directions of the surface. This is then rounded and used to generate the new dimensions for the area.

In order to generate the panels, the ‘lunchbox’ plugin is used. This simply requires a surface input as well as the number of panels in the u and v directions, all of which have been established in the previous step.

Additionally, the panels are scaled down slightly to create a gap between panels. Both for aesthetics and to give enough clearance for panels when they fold out.

I then removed the edge panels so that only full sized panels remain in the facade. This keeps the modularity of the facade and each panel can be the same.

I used a simple dispatch pattern based on the area of the panel to remove the half panels.

The next portion of the script relates to arranging the panels in a way that allows me to select panels easily from all the panels.

I did this by sorting the panels by their z-height location and grouping them into each row.

Particular consideration needed to be taken as the two surfaces had differing numbers of panels, so couldn’t be partitioned manually.

Instead, I used a component from ‘lunchbox’ to identify duplicate z-values for the panels and grouped them based on this.

The tagging I used to visualise and verify that the panels were correctly grouped and organised.

Since the panels are arranged into rows, I can simply select every second row to rotate and form this unfolding pattern.

This is one possible configuration of opening panels. With further refinement, we can create a variety of configurations. We can take this further by integrating A.I. into the facade and allowing the panels to consider the environment and the surrounding panels to generate folding patterns.

This is another possible configuration, selecting at random a number of panels to fold out. This type of configuration can demonstrate the ability for panels to fold out along different axes depending on the panel it is connected to.

Overall, this script established the groundwork for generating panels which is useful for the future scripts. As well as this, the script does have limitations in what patterns are achievable. A combination of parametric and manual design would be more flexible when it comes to developing more specific configurations.

3.3_Grasshopper Player Integration

While using Rhino 7, I discovered the added feature, Grasshopper Player, which allows grasshopper scripts to be created and used similar to rhino commands.

I created a simple script for rotating panels on the facade. In particular, since the panels were scaled down slightly, using normal rotation in Rhino proved to be quite time consuming, so this was a simple way to increase efficiency slightly. The script takes in Rhino parameters with the ‘Get’ components. These ask the user for information when using the grasshopper player command.

The rest of the script does the processing and transformation before baking it back into Rhino.

After asking for the panels to rotate, the script asks for a side to be the rotation axis, and the rotation angle. The script is completed once this information is inputted. Additionally, the baked geometry will be created on whichever layer is selected, allowing the ability to separate the baked geometry from the original geometry.

I think there is possibility and opportunity here to create accessible scripts for those without knowledge in grasshopper, however, there a number of things that need to be considered for a workflow like this to be efficient.

3.4_Midsemester Presentation

The midsemester presentation was where we initially proposed our concept. In order to obtain a presentable configuration, I opted to manually arrange the panels rather than generate a parametric script. This proved to be a time consuming process with limitations on changing the configuration afterwards without affecting a large number of panels.

This matrix of panel configurations illustrates a number of possibilities based off the folding of panels. They range from regular patterns which would propagate across the entire facade, to semi regular patterns which have an element of grouping to them, and finally irregular patterns which do not have any underlying pattern that determines the folding pattern. This also represents the difficulty of each to rationalise from left to right, with irregular patterns being both difficult to rationalise parametrically or manually as well as conceptually.

Image credit: Rowan Johnson

In addition to the conceptual side of the proposal, we also were working on rationalising the mechanism that would connect the panels together. We needed a mechanism that would allow the panels to couple and decouple from each other as well as move the panels themselves.

We decided on a mechanism with an arm with a motor and pin system which could be mirrored easily on all three sides of each panel, meaning each panel could be identical.

The first few weeks challenged us to produce and develop ideas at a rapid pace to reach a point at midsemester where we could look towards the feasibility of producing a built prototype for our project. There were

definitely difficulties in these first few weeks, trying to push to be more innovative while considering the feasibility of some ideas in terms of time constraints and complexity.

I’m pleased at the outcome of midsemester with the direction of our project.

I wanted to challenge myself and push to innovate and I’m thankful that our team was able to align our goals.

4.0_Review

After the midsemester presentation adjustments were made to the concept following feedback. The shift towards the fabrication portion of the project began here.

4.1_Midsemester Review

After receiving feedback from the midsemester presentation, we reviewed our work and produced more rationalised models as we shifted our focus to producing a full size prototype. This required us to rationalise the mechanisms that would be used to articulate the panels. I developed these series of images from the 3D modelled components to illustrate materiality and breakdown of the structure and how each panel module would operate.

Model credit: Ella Huang & Rowan Johnson

We begun to consider the materiality of the panels, settling for aluminium framing and Alucobond for the panels due to their lightweight properties. Additionally, we considered a cable system to anchor the panels to the subframe of the building so that the panels always have a point of connection to the building for both safety reasons and electrical rationalisation.

Model credit: Ella Huang & Rowan Johnson

Image credit: Rowan Johnson

The connection mechanism between the panels was decided to be 3D printed as there are many components necessary to mount the motors and join the panels together. Aside from the motors and 3D printed parts, we tried to use standard off the shelf parts to reduce costs and increase the feasibility of upscaling the prototype.

From the back of the panels, we can see the arrangement of the motors are in such a way that each joining side is connected by a pair of motors and arms. This allows each panel to be identical and arrayed across the facade.

Model credit: Ella Huang & Rowan Johnson

For the physical prototype, ideally we aimed to create a number of panels, both stationary and moving to showcase the ability of the panels to couple, decouple and arrange into various configurations. Due to limitations in physical resources and time, we needed to reduce the number of moving panels. This also reduced the overall complexity, however the built prototype was still highly complex.

This week long period after the midsemester was when we began to focus on moving towards a built prototype and rationalise many of our ideas. I commend the efforts of my team member, Ella, for joining our team during this period and being able to get onboard with our project and integrate into the group with such a short transition.

We faced difficult choices during this week to question the feasibility of our prototype and work out what was possible within the given time period. Personally, I sometimes aim further than what I can achieve, so having team members that can ground me helped in reaching a successful outcome at the end of the project.

5.0_Fabricate

To begin the fabrication process, we needed to create the files and scripts to be fabricated. This occurred in parallel with developing and rationalising the design as we progressed resulting in a number of changes being made to fabrication processes.

5.1_CNC Panel Parametric Script

5.1.1_CNC Panel Parametric Script V1

Geometry Generation Toolpathing

G-Code Generation

The next stage in developing our prototype was to prepare the files for fabricating our panels. Since the design of the panels was still be developed throughout this process, the importance of a parametric workflow is evident here. The ability to change and update parts of the script with changes propagating to the g-code allows for more efficient workflow.

The basic script structure for this is: geometry generation, toolpathing, and g-code generation. As the script gets more complex with each additional update, the base structure remains relatively unchanged.

For our prototype panel, since the panel is to be fabricated from Alucobond, it is necessary to utilise CNC milling to cut the panels, as laser cutting can produce harmful fumes when used with certain materials.

The initial panel geometry is created simply with a triangle. I created the triangle parametrically based on the sheet geometry, however I also added in an option to reference a manually drawn triangle since this was intended for a single panel to be cut.

For the triangular geometry, a simple offset is needed for the toolpath, in order to account for the diameter of the router.

This toolpath is then used to generate the necessary g-code for the CNC router. The framework for the g-code was initially provided and I developed upon it to suit the needs of our CNC panel.

The g-code portion of the script is broken up into the appropriate components which make up the g-code in general. The starting and ending g-code does not typically change here and are used to prepare and end the fabrication job.

will follow. Special consideration needs to be taken for the height of the router as well.

In particular, the bulk of the g-code is constructed from the points taken from the toolpathing. The start point, curve points and end points are used to generate a list of points that the CNC router

I used NC Viewer to view the g-code to verify that the toolpath was correct. This helped with visualising any errors that might be present in the g-code.

The prototype initial CNC milled Alucobond panel turned out well. It was light weight even with the aluminium angles attached. Further development and detailing of the panel can be considered from here.

5.1.2_CNC Panel Parametric Script V2

Geometry Generation

Toolpathing

G-Code Generation

After cutting a single panel, we were satisfied with the outcome. I began to develop the script further in order to be able to cut multiple panels on a single sheet of Alucobond.

The general structure of the script remained the same, with the most change occurring in the geometry generation portion of the script.

Since I did not have information on the size of the Alucobond panels available, I added the flexibility of manipulating the size of the input sheet as well as the orientation that the panels could be cut in.

The main change in this script is generating the array of panels to be cut. I took elements from a previous script for the facade to generate the triangular panels.

Adapting previously created script helped in speeding up the scripting process and allowed me to add in additional functionality and work on the details.

From this script onwards, there are no referenced geometry, allowing the script to be completely contained within grasshopper. The sheet is created with the appropriate size, then offset to provide a safe cut area on the sheet.

Similar to previous, the rectangle area is redrawn to fit the correct number of panels at the correct size.

Once the rectangular area is created, the area is used to generate the triangular panels with the component from ‘lunchbox’

The half panels are removed and we are left with the panels to be cut. It is also noted that the panel array is larger than the actual panels since they will be scaled down to the correct size, in order to cleanly cut each panel individually from each other.

The curves are then generated from the smaller panels, these have been offset from the panel array. Since the offset is measured from the edge of the panel, the dimensions of the panels are not quite the right size. This will be addressed in future iterations.

In addition to the horizontal orientation of the panels on the sheet, a vertical orientation can also be used. Which orientation is more efficient depends on the size of the panel used which is why I allowed both to be options.

I used a simple stream gate component to pick between the two orientations.

Once the geometry is created, the curve points for the toolpathing are determined as well. Additionally, the start and end points of these panels were adjusted based off feedback from the initial CNC test panel.

The router cuts counterclockwise around the panel, so to ensure minimal movement from the vibrations, it is advisable to have the start and end points located at the towards the end of a straight edge rather than at a corner of the panel.

Overall, the g-code for this script has some minor adjustments to streamline the input information. The points are divided into start/end points and toolpath points as it is necessary to separate them. The g-code script is also organised so that the bulk of the g-code is combined before adding on the start and end g-code. This helps with the dealing with the data structure when multiple panels are introduced.

Again, the g-code is viewed in NC Viewer to identify any errors in the code. We can also see the path of the router when it is not cutting the material which is useful information to note when looking for shorter path routes.

5.1.3_CNC Panel Parametric Script V3

Geometry Generation

Toolpathing

G-Code Generation

After further development of the panels, we decided to add folded flaps to the panels to improve the aesthetics of the panel. This requires some additional geometry generation in the script as well as some additional alterations to the g-code in order to route the seams where the Alucobond panel will be folded.

The folded flap geometry is created based off the triangular panel geometry. Additionally, mounting holes for the aluminium angles are also added here.

The g-code here needed to be altered to accommodate the varying routing needed. The code is divided further into the type of routing that is required. In this case: drill holes, seam curves and cur curves.

For each of these, tool changes are needed, which are added to the g-code between each routing code module.

The script within the groups are relatively unchanged from the previous iterations, requiring a start/end point and toolpath points to generate the code.

This is a preview of two panels with the CNC routing path. The cut curve is the last to be routed as it dislodges the panel from the sheet, which is why the drill holes and seam curves should be routed first.

5.1.4_CNC Panel Parametric Script V4

Toolpathing

Geometry Generation

G-Code Generation

Further development of the panel design requires adjustment of the script. With this update, additional elements are added to the geometry generation portion of the code. Mainly, cutouts for where the mechanical arms are needed in the folded flap area to allow for when the panels fold up.

Additionally, corner rebates are also required to allow space along the edge where the side flaps fold up and meet.

This portion of the script illustrates the generation of the geometry for the mounting holes, folded flaps, arm cutouts and corner rebates.

In general the geometry is made from simple components, but there is some consideration in ensuring that changes in values and measurements will adjust the geometries accordingly. This is especially important due to the constant changes and updates that occur with the panel design.

As the geometry gets more complex, so does the g-code and tool routing. There is more chance of errors being present in the code, which means more care is needed to ensure that the g-code and toolpathing work the way they are intended. The parametric nature of the script allows for quick adjustments during the fabrication process.

5.1.5_CNC Panel Parametric Script V5

Geometry Generation

Toolpathing

G-Code Generation

The final iteration of the script adds some detailing to the geometry, primarily for CNC milling consideration. Any inner corners require a dogbone since there’s a radius on the routing piece. This is especially important to take into consideration as the flaps will be folded up after milling.

Additionally, minor changes have been made to values and measurements in parallel to the design as well as further organising the script to make it easier to work with.

The sheet dimensions determine the number of panels that can be created in both the horizontal and vertical orientation, this information is relayed back and presented when changing the sheet dimensions.

This portion of the script has remained primarily unchanged from earlier iterations. One main addition is the panel spacing option which gives direct control over the gap between panels, allowing it to be adjusted more easily.

This is incorporated into the triangular panel dimension when generating the array, then scaled down afterwards to form the gap.

The vertical orientation portion of the script has been updated to redraw the rectangular area in the correct orientation. This allows the two orientations to be more easily compared.

To obtain the correct size for the panel itself, either a scale component or an offset component could be used. I opted to use an offset component. Since the distance is measured perpendicular off the edge and I wanted to control the length along the edge, I used some trigonometric ratios to achieve the correct length output.

Overall, this part of the geometry generation script has remained the same from the previous iteration.

Points for the dogbones are taken from the corner points of the triangular panel. The interior corners of the arm cutouts don’t require a dogbone since a radius on the inner corner won’t affect the operation of the panels.

This is the final iteration of the g-code script, built upon the previous iterations of the script, it deals with the complex inputs and different tooling required for particular routing paths.

This portion of the g-code script is to create the mounting holes which attach the aluminium angles. The points at which the mounting holes are located are taken as input. The x and y coordinates are then used to locate the position in a two dimensional plane. The z-axis is controlled manually by providing the cut depth, in this case, -0.2mm to ensure the router passes completely through the material. This information is formatted into the correct g-code format and start point and end points are determined to move the router rapidly between drill points.

The seam curves are used to allow the Alucobond panel to fold, since it has a thickness of 3.0mm, the cut depth needs to be above this. Additionally, a v-shaped router is used to create the 45° cut angle that is needed to fold the joint.

The script here is divided further into the: start point above and in the material, toolpath points, and end point in and above the material. This allows for more control with the depth of the cut and movement of the router between each panel.

The corner rebate is a pocket route, however due to the size of the area that needs routing, only two passes are needed, hence a simple offset is used to generate the toolpath.

Similar to the seam curves, start points, curve points and end points are used to generate the necessary g-code.

The last cut to be made is the cut curves, which dislodges the panel from the sheet material. Again, there are minor changes to this script as it is similar to the previous two portions. The only difference here is the z-axis depth that is specified as the material needs to be cut through completely.

The final g-code contains a large number of code lines and more complex toolpathing, resulting in the toolpath illustrated above. This is due to the complexity of each panel as well as the number of panels being cut.

The fabricated panel was cut for the prototype with no major errors in measurements or tolerances which is a positive outcome considering the complexity of the script and the constant design changes that were made to accommodate the other fabricated parts.

Grasshopper scripting is one of my stronger areas, which is why I took on much of the parametric aspects of the project. In general, working alongside a changing design and developing a script for the purpose of digital fabrication forced me to organise my workflow in a better way to allow easier changes along the way.

In general I try to make my scripts as robust and flexible as possible.

Although overcomplicating some aspects, I think this helped when it came to using parts of the script in other areas or adapting it to other uses.

Consideration for the workflow and accounting for future possibilities with the script was something I found to be important here.

6.0_Machinate

Alongside the fabrication files being prepared, we were also further developing and rationalising the connection detail between panels. A portion of our project was centred around the articulation of the panels and the use of an Arduino and motors to control the panels.

6.1_Prototype Model

The final prototype needed to be resolved in order for the digital fabrication to be coordinated alongside manual fabrication. This model illustrates the structural frame, subframe, panels and connections between the panels. This information is necessary to determine number of components that are required to build the prototype.

The final prototype was intended to be completed as illustrated in the model above. This outcome was achieved with the final built prototype resembling the planned model quite closely.

6.2_Panel Connection Detailing

The base model for the 3D printed mounting components and motors were created in Fusion 360 by my team member, Rowan. I took this model into Rhino and contextualised it, as well as created the aluminium angle that it was to be mounted to.

Here, one side of the connectors can be seen in context with the aluminium angles as well as the CNC milled Alucobond panels.

The panel flaps are folded up to form the sides of the panels. The arm cutouts can be seen here allowing space for the connection arms to move when the panels fold.

This is a full model focusing on the connection between two panels. The aluminium angles are also bolted together in addition to being riveted to the panels. This is to allow a mounting point for the cable system that anchors the panels to the subframe.

6.3_Arm Connection Redesign

From the initial arm design created by my team member, Rowan, adjustments needed to be made to the length of them to coincide with the built prototype panel spacing. In addition to that, I also adjusted the shape so that it would be able to clear the arm cutouts of the panels more and allow for greater angles of folding.

6.4.1_Subframe Fabrication

This is an illustration of the mild steel square section members that would be needed to create the subframe. Each colour indicates identical members that would be able to be cut the same way.

Toolpathing

Labelling

G-Code Generation

To create the subframe, we initially wanted to use mild steel square sections. In order to weld the pieces together, a CNC milled jig would be needed. This script is for the generation of the g-code for the jig.

The outline curves for the pocket are referenced in to grasshopper and offset to form the pocketing toolpath. This can then be used to generate the g-code.

Labels are created from the referenced steel members, separating them by shape. There 7 unique shapes that the steel members would need to be cut to.

The g-code for this pocketing script was considerably messier with the combination of adding in the labelling. There are easier tools to create g-code for pocketing, however I wanted to have an attempt at creating it using basic grasshopper script.

The intended outcome for this CNC milled panel was to house the steel members to be welded as illustrated above. This did not end up being used due to the complexity and high chance of tolerance errors. Instead we decided to use metal laser cutting to produce the subframe.

6.4.2_Revised Subframe Fabrication

We decided to use lasercut 2.0mm mild steel sheet for the subframe to reduce the complexity of fabrication and since the intention was for the subframe to be a mounting frame for the panels, connecting it to the structural frame, the mild steel sheet would be adequate.

For fabrication, I prepared the lasercut file with the necessary cut lines.

The resulting subframe would be bolted to the structural frame and since the maximum, sheet size of the mild steel was 1200mm x 1200mm, the subframe needed to be split into two parts. This would then be welded together to increase rigidity of the frame.

Much of the Arduino work to get the panels moving and the prototype to articulate was done by my team member, Rowan. Although I would’ve liked to learn more with dealing with the electronics and looking at the coding side of the project, I realise that I needed to entrust work to my other team members as the amount of work that needed to be completed was too much to be taken on by any one person.

7.0_Animate

In addition to the physical prototype, we were developing the overall concept in the context of the building. In order to better illustrate our concept, I produced a number of animations to showcase the mechanical articulation of the facade.

7.1.1_Unfolding Facade Animation - Facade Configuration

In order to create the animation for the unfolding facade, I needed the configuration that the panels would be in its unfolded state. This configuration was developed by my team member, Ella. I then used this to reference into grasshopper and build the animation.

In addition to the overall unfolding animation, I wanted to show the unfolding at the connection detail level.

Single Panel Unfold Group Panel Unfold

I discovered that grasshopper can generate animations using a slider which takes screenshots of the viewport as the slider value increases. In order to get multiple elements moving, I needed a way to connect all the elements to a single animation control slider.

The animation script is divided into two main parts: the single panel unfold and the group panel unfold.

Each panel that was moving needed to be referenced into grasshopper and grouped into the appropriate brep container.

This process was quite time consuming but I tried to keep the script as organised as possible to easily locate the panels.

The single panel unfold portion of the script refers to panels that directly hinge off the frame. These were referenced in and grouped based on the angle that the panel folded out by.

The foldout angles varied between 5° to 70° with increments of 5°, resulting in 14 groups of panels that needed to be referenced.

Once the appropriate panels are referenced, they are rotated along the horizontal axis at the appropriate angle. This process is repeated for each group of single panels.

The other input comes from the animation control slider which inputs an increasing angle value into the python component before being converted to radians and adjusting the panel position.

The python script is used to regulate the values coming through the input to control the output value.

This script simply takes in two inputs, ‘input’ is the animation slider which contains values between 0 and 70. The second input, ‘max’ describes the upper most value that can be outputted from the script.

This means that any value between zero and the ‘max’ value will simply output the ‘input’ value. Whereas any value above the ‘max’ value will output the ‘max’ value, limiting the range of values that will be input into the rotation component.

Since I wanted the panels to move at the same speed and stop when they reach the desired angle, I didn’t use a remap value component, which could be used to achieve that effect.

Similar to the single panel unfold, the group panel unfold needed to be separated into manageable groups.

I grouped the panels according to the unfolding surface it was part of, resulting in 6 groups of unfolding panels. These also differed in the number of panels that hinged off each other, so the script needed to adjust to this.

As shown, these three panel groups are grouped accordingly within the script since each row of panels needs to reference off each other for each rotation.

The first row of panels in the group can be seen rotated here. In this case there is only a single panel that is referenced. Additionally, the panel is rotated by a specific amount.

The second row of panels is then rotated. In addition to these panels, the first row of panels also needs to be rotated in reference to the second row axis of rotation.

Again, there is a specific angle that this row rotates to.

This process is repeated for the third row. As long as the previous rows are rotated with the next row, the panels will fold out as intended.

The last row follows the same script, rotating the referenced panels as well as the previously rotated rows.

This process can be expanded depending on the number of rows/panels that need to be folded out. Additional script just needs to be applied, and the python component needs to be adjusted.

In order to translate the animation slider to the group panel unfold, I created a python script to regulate the values. The effect created is similar to assigning periods along a timeline. I wanted each panel row to fold out completely before the next row folds out. To accomplish this, essentially the control slider needed to be divided into the various sliders controlling the panel rows.

The python script takes in a number of inputs, ‘input’ is the animation control slider that has been remapped to the total angle that the group panel folds out to. This is so that the group panels unfold over the same time period as the single panels.

Boundaries between each smaller slider need to be established, this is taken from the specific angles that each row rotates to (in1... in4). ‘bound1’ to ‘bound4’ takes the cumulative sum of these to determine the boundary points.

Each output (out1... out4) has three states. Either ‘0’ when the slider is at a value before the boundary period, ‘input’ when the value is within the boundary period, or ‘in*’ (max value) when the value is after the boundary period.

The desired outcome is illustrated below. These individual slider values are used to then rotate each row of panels. This process is repeated for all the group panels.

7.1.2_Unfolding Facade Animation - Connection Detail

In addition to the overall configuration unfolding facade, I created this script to animate the connection detail at a closer scale.

I separated the animation into the locking pin mechanism and the actual folding mechanism.

Locking Pins

Folding Mechanism

The initial animation is of the locking pin mechanism. The rotating gear, gear rack and axis of rotation are referenced in and simply connected to a series of components to rotate and move the pieces.

In order to rotate the gear and move the gear rack at the same speed, a remap value component is used.

The second portion of the animation is the folding of the panel. The panel that will be moving is referenced. In addition to this, the gear and rack are rotated as well. The axes of rotation are also referenced in as curves.

For this particular joint, there are 2 axes of rotation at either end of the arms. The model shows the panel in its folded orientation.

Similar to the previous animation with rotating multiple rows of panels, first the panel itself is rotated.

The rotated panel is then rotated with the arm a second time to reach the final position. Unlike the previous folding animation, I want both rotations to occur at the same time, therefore they are simply connected to the animation slider directly.

Once I generated the animations for the overall configuration and the detailed connection, I compiled the footage together using Adobe Premiere Pro and overlaid additional graphics and information. I also ensured the animation started and ended with the same frame so that the animation could loop.

7.1.3_Unfolding Facade Animation - Final Animation

The final animation of the unfolding facade turned out well and clearly illustrated the motion of the facade. I was pleased with the outcome given my recent undertaking of animating in grasshopper and basic knowledge of Adobe Premiere Pro. I hope to continue to animate more work in future.

I think that animation and motion adds another layer of information when communicating ideas that stationary drawings cannot convey as well.

7.2.1_Interactive Facade Animation - Animation Script

Panel Geometry

Moving Points Transform Panels

The next script, I created to animate the interactive element of the facade of the ground floor of the building. The concept is that panels would fold open when people are within a certain proximity to them, allowing sight lines into the building.

In order to represent people moving across the facade, I used a number of points that move horizontally.

Overall, the script consists of moving these points, the panel geometry and rotating the panels in relation to the points.

The first part of this script is to reference in the panels. The top 4 rows of panels are stationary while the bottom 4 will be the panels that interact with passerbys. In addition to the panels, the framing behind was also modelled to add another element of detail.

This portion of the code proved to be the most challenging to achieve the desired outcome. It uses a combination of previous python components to regulate the single input animation slider and divide it into the outputs which transform the points horizontally.

Since I wanted the points to move at different times and some to start moving while others were still moving, I needed to define some boundaries that begin to output a value when the threshold value is reached.

In addition to this, these values are directed into a limiter python component which essentially determines the length of the slider output that is fed into the transform components.

The next portion of the script rotates the panel a certain amount depending on the distance away from a point.

Since there are multiple points, all the distances are merged and sorted, taking the lowest value, so that the only the distance to the closest point is considered.

Further manipulation with a graph mapper can also give more control to the remapped values, however at this scale the effect is not as prominent, as discovered through some experimentation.

This value is then remapped to the appropriate rotation angle.

Again, the animation created in grasshopper was overlaid with footage of walking silhouettes to represent the interaction with the facade. Similar to the previous animation, I ensured that the animation was able to loop.

7.2.2_Interactive Facade Animation - Final Animation

I think the interactive facade animation turned out quite nicely. For improvements, I would want to try to achieve a smoother animation of the folding facade, but overall the concept is still understood.

8.0_Assembly

The final portion of the project was to physically realise the prototype. All our preparation and design of parts culminated to assembling the built physical prototype.

After all the fabrication files were created and sent in to be fabricated, we needed to focus on all the other components necessary to construct our prototype. Due to the nature and design of our prototype, there were a large number of parts that were required. These are the servo motors and 3D printed mounts that were intended for the prototype. This is also after altering the design to reduce the number of parts needed as there were limits to the number of motors available.

While we worked on the smaller modular components of the prototype, we also needed to prepare the mild steel square sections for welding to create the structural frame that our panels would attach to. Here, we cut the steel sections to length and removed the paint to expose the steel underneath in order for them to be welded. Thanks to Darcy and Danny, these steel members were welded together and ready to be cleaned up.

We begun to also process the aluminium angles, cutting them to length. In total we had 72 aluminium angle sections, 3 for each panel for a total of 24 panels. We were also printing out all the necessary 3D components in order to have them available in time for assembling.

Photo Credit: Rowan Johnson

We also sent in 18 of the aluminium angles to be CNC milled with holes and cutouts for mounting the motors. I manually drilled the panel mounting holes on each of the 72 aluminium angles using a jig to speed up the process as well as keep the drilling relatively accurate. A test fit of the aluminium angles on a prototype Alucobond panel showed that the angles lined up with the panels.

The holes that were CNC milled ended up being slightly larger than anticipated but we were still able to use the self tapping screws from the other side of the angle to secure the 3D printed pieces in place.

We then began the process of assembling each of the aluminium angles and 3D printed parts. Additionally, we needed to change the way the small servo motor was mounted resulting in additional holes to be drilled manually into the aluminium angle, using the 3D printed part as a guide.

The larger servo motors needed to be attached to the 3D printed mount before the mount was attached to the aluminium angle. The smaller servo motors were also attached to the aluminium angle. Both of these were attached using M2 nuts and bolts, which were quite difficult to work with but eventually we became accustomed to working with the small pieces.

These are the aluminium angles with most of the components attached. The pin housing and anchor bolts still need to be attached at this point before the angles are riveted to the panel, at which point any changes will be much more difficult to make.

Once the aluminium angles were complete, we folded up all the Alucobond panels and laid them out in the correct positions on the subframe. Once all of the panels are in position, they can be labelled and the aluminium angles can also be positioned.

Photo Credit: Ella Huang

While the panels were being assembled, the welded structural frame was also cleaned up. The welds were ground flat and the entire frame was painted black with an enamel paint to protect it from rust and for aesthetic purposes.

We didn’t prefabricate a way to attach the stationary panels to the subframe. So in order to attach them, we created brackets with the leftover aluminium angles. These are riveted to the aluminium angles which will then be used to bolt to the subframe. In hindsight, ideally we should have accounted for these brackets while fabricating the subframe.

Photo Credit: Ella Huang

Once all the components on the aluminium angles were complete, we were able to rivet them to the panels. We opted for white rivets to keep them inconspicuous. We did begin to run into tolerance issues with some aluminium angles since the panel mounting holes were drilled by hand. These were easily resolved by widening the mounting hole to increase the tolerance as well as grinding down the length of the aluminium angle so they wouldn’t intersect with each other.

Once we had two complete panels, we did a test with the motion of the motors and determined that although the panels did move, it was not as controlled as we would have liked. This could be due to the tolerances in the pins holding the arms in place, or the strength of the motors not being great enough to lift the panel. With all the components attached to the panel, it is not as light as we would have hoped which could be a possibility as to why the motors are not operating as expected.

Photo Credit: Ella Huang

Here, we begun attaching the subframe to the structural frame. This required drilling holes through the structural frame so we attach the frame using bolts. Since the subframe had pre-drilled holes for the structural frame connection, we just needed to line up the frame and drill the holes through. Once the subframe was bolted to the structural frame, we had the subframe welded together since it was in two pieces, to increase the rigidity of the subframe.

The lack of foresight meant that when it came to attaching the panels to the subframe, we needed to estimate where the hole needed to be in the subframe to match up with the bracket underneath. Given the circumstances, in hindsight, instead of pre-drilling the holes in the brackets, we could have drilled through the subframe into the bracket, making it easier to mount. Each panel took about 15-20 minutes to mount onto the subframe. Since there were 24 panels in total, we ended up spending roughly 6 hours mounting the panels onto the subframe. There was quite some back and forth as well when the holes didn’t match up. We would need to redrill and refit the panel. This process was by far the most time consuming and tedious, which could have been avoided.

Photo Credit: Ella Huang

When it came to attaching the moving panels, these tended to be easier since the margin for error was larger. The panels were mounted by cables that run through the subframe. A clamp is placed on the other side to stop panel from falling. Ideally, a motorised system could anchor the cable, but due to time and resource constraints we decided to simplify the system.

Photo Credit: Ella Huang

Once all the panels were attached to the subframe, we could turn the entire piece over to attach onto the structural frame.

M6 bolts were used to attach the subframe to the frame. We also ran into some intersection issues with some bolts holding in the panels intersecting with the structural frame. This was due to the error margin when drilling the panel mounting holes by hand. We resolved this by removing the bolts as we determined that some stationary panels were still rigid with only two bolts holding it to the subframe.

Once all the panels were in place and the frame was attached, wiring of the motors on the moving panels could be done. These all connected to an Arduino which controlled the motion of the panels. The panels had the room to move to the desired configuration, however issues with the motors meant that the panels were not able to completely move on their own.

Photo Credit: Ella Huang

This period of making was intensive, tiring but also enjoyable and satisfying. The final outcome of the prototype, although it had its flaws, played its role in conveying our concept. As well as that, completing the built prototype was an overall rewarding experience.

9.0_Final Outcome

Image Credit: Ella Huang

What we managed to achieve within the time period we were given is thanks to the work put in by all the members in my team and the support we received from around us.

I was very pleased with the work we ended up producing, both digitally and physically. Throughout the project, it felt like we ran into hurdles and challenges every other day, but we managed to pull together and finish at a standard I think we are all proud of.

10.0_Reflection

When I began this subject, I was interested in the fabrication and articulation aspect of the project. As we progressed through the subject and developed our project, I found that the subject was much more hands on than I initially expected. I wanted to challenge myself with new experiences which I definitely accomplished by the end of the subject.

There were many challenges along the way, from short deadlines, team member changes and fabrication troubleshooting, but we managed to complete the prototype and presentation to a standard we were satisfied with despite all the hurdles throughout the subject.

In hindsight, I would’ve liked to explore more of the opportunities possible with 3D printing but given the direction our project was heading in, it was difficult to incorporate in a meaningful way.

10.1_Acknowledgements

First and foremost, I want to thank my team members, Rowan Johnson and Ella Huang, for putting in the time, effort and dedication to get this project complete. There were many aspects of the project that couldn’t have been done by just one person. Especially thankful for the fact we were able to work well together and be productive considering the reallocation of team members up until mid semester.

Thank you to Darcy and Danny, our tutors, for guiding us in the right direction and pushing us to challenge our design and concept and develop it into an innovative project, as well as helping us along the way with fabrication.

Thanks to the guys at Fablab and Robotics for providing us with the tools and skills to construct and complete our built prototype.

3DPrintMill 3D Printer. (2021). Retrieved 1 March 2021, from https://www.creality.com/goods-detail/creality-3dprintmill-3d-printer

HP MJF vs. SLS: A 3D printing technology comparison | 3D Hubs. (2021). Retrieved 1 March 2021, from https://www.3dhubs.com/knowledgebase/hp-mjf-vs-sls-3d-printing-technology-comparison/

Introduction to FDM 3D printing | 3D Hubs. (2021). Retrieved 1 March 2021, from https://www.3dhubs.com/knowledge-base/introduction-fdm3d-printing/

Introduction to SLA 3D printing | 3D Hubs. (2021). Retrieved 1 March 2021, from https://www.3dhubs.com/knowledge-base/introduction-sla-3dprinting/

Introduction to SLS 3D printing | 3D Hubs. (2021). Retrieved 1 March 2021, from https://www.3dhubs.com/knowledge-base/introduction-sls-3dprinting/ Nonplanar (2021). Retrieved 1 March 2021, from https://www.nonplanar.xyz/

Any images or work in this journal without listed credits are produced by myself.