For a description of what the team at CMU is working on in Spring 2025, check out this document!

Goals of this page:

• Not to try and cover theory or industry standard, but to break the problem into first principles just enough to give context to the quantifiable parameters

• Also an opportunity to frame the problem wide enough to set the tone of thinking of these machines from the ground up (aligned with goal, don't think of industry as immutable)

• Exhaustive list of industry methods and examples

• Quantifiable end user parameters with descriptions + standardized tests

Background

Overview

A photolithography stepper is a machine that exposes a pattern of light onto a layer of photoresist chemical on the wafer, then ‘steps’ over to the next pattern. Before each exposure, it must align with previous patterns on the wafer so that each layer of the device is in the correct position relative to the previous. The accuracy with which it can do this is called “alignment accuracy”. Alignment accuracy and optical resolution are the two most important metrics of a stepper’s performance.

There are 2 main components of our stepper: the light source and optics, and then the mechanical micropositioning stage that moves the chip itself. Alignment accuracy is a function of both the mechanical micropositioning stage and the reliability of the projector’s optomechanical components.

Masked vs. Maskless Lithography Systems

Commercial lithography machines use photomasks to create the image, typically made of chrome on glass. Instead, our Maskless Photolithography Stepper uses a DLP projector to create a pattern. This allows us to change patterns instantly, opening the option up for advanced techniques like tiling (making a circuit larger than one exposure field).

Quantifiable Parameters

Functional Specifications: The End Product

Patterning Machine Specifications:

The goal function of the Hacker Fab is to never debug the same thing twice.

We operate under different constraints from the semiconductor fab industry. This allows us to curb a lot of complexity.

Goals:

1. Low cost

2. Create the simplest designs possible

   1. Increase reliability

   2. Reduce manufacturing complexity

3. Minimal danger

4. Small size

5. No cleanroom

6. Highly sourcable materials

7. High literacy in understanding working principles of tools and processes

8. End-to-end custom - from sand to NAND

   1. Make the wafers

   2. Design the tools

   3. Design the processes

   4. Design the IC

   5. Package the chip

Non-Goals:

1. Reuse of existing fab equipment

The 1970s vs. Now

On Open-Source Hardware

Who we are looking for, how we grow, how to get support

Design Constraints

On Improvement

Central to the Hacker Fab is fast turnaround hardware development - it’s in the name. This means extremely fast hardware prototyping, and with that comes the need for iteration. The careful design constraints placed on all projects and focus on documentation enables someone else to iterate on anything developed in the Hacker Fab. Improvement to a V1, V2, Vn of a design means

1. Directly improving upon a tool’s functionality

   1. Precision

   2. Reliability

   3. Throughput

   4. New features

   5. Safety

But there are other equally important ways to improve a design. Every tool version should try to be:

1. Easier to manufacture than the last

   1. Reduce number of tools required to manufacture

   2. Reduce # of vendors, lead time, BOM length

2. Better documented than the last

   1. Tool specs as close to first principles as possible

   2. Every tool spec should have a standardized test for others to verify performance

   3. Explain working principles to the detail of variables we can control (no more, no less). Referenced sources.

3. More “closed-loop” than the last

   1. In-situ sensors

   2. Calibration software should be more generalizable (“now you can use any camera…any piezo with draw distance in range X to Y…”)

On Cleanliness

On Process Node

On Education

Where to Start

TBD

Introduction

The SW needed for this project can be broken down into the following subsections.

Pattern Capture

KLayout

OpenROAD

CAM Translator

Computer-Aided Manufacturing software translates a 3D design into G-code instructions that a CNC machine (in this case laser burner) can understand, essentially "slicing" the design into smaller, machinable steps.

This SW takes a file with the desired mask (Pattern Capture Output) as an input and translates it into a set of machine instructions.

Burner Firmware

This software runs on the micro-controller that drives all the HW. It is responsible for taking sensor inputs and driving all output motors and lasers. This device also has an interface which can transmit all the data to/from the user.

Device Driver

This software is responsible for general control of the laser burner from the PC side.

Graphical User Interface

This SW is responsible for the user facing interface which gives the user full control of the burner.

• uniformity

• deposition rate

• deposition precision (between runs)

• etch rate

• selectivity

• uniformity

• anisotropy

• effect on photoresist?

Links and Videos

Simple MOSFET intro video (5 min)

Sam’s Youtube video overview (5 min)

• Nearly identical to what we do

• What our work was based on

Device Physics Overview (30 min)

• Electrons, bandgap, etc.

Before we had transistors, we had lightbulbs (18 min)

• Then we moved to silicon

• This stuff is regularly communicated as complex magic, and requires the permission of billionaires to work on it. We are starting from 1960’s level complexity and working our way up to modern complexity.

The creation of the blue LED (30 min)

• Extremely well told story of the man who figured out how to manufacture blue LEDs

• We are not the first people to claim that innovation in the semiconductor industry requires intimate knowledge of the fabrication tools

Fabublox (∞)

• A fantastic tool being developed by friends at MIT. Overview of many processes, with each being a linear recipe

• Make an account, and go to “fabubase” in menu

• Check out our Hacker fab process, as well as others

• Go through and try to recreate our process from scratch without cheating. See how far you get, and write down things that don’t make sense (1 hour)

How do these things even make computers?

• How we turn sand to intelligence

• Making logic gates from transistors (13 min)

Transistor → logic gates → basic logic circuitry (timers, counters, latches, shift registers, etc.) → architecture abstractions that people made up over decades → CPU

TinyTapeout Video Example: Making ASIC

• Application Specific Integrated Circuits

Not all transistors are created equal

Below: ideal transistor IV curve vs. our first curves.

These both exhibit transistor-like characteristics. Looking back at the Veritasium video about how the first computers were made with lightbulbs - a transistor really boils down to a repeatable switching action. When we look at our curve on the right, we see multiple issues:

• The curves don’t go through the origin, they start with a voltage offset

  • This means that when we apply a voltage to the gate (open the valve to allow current through), current doesn’t run through the drain to the source until we apply ~3V to the drain/source connection.

• The lines are all squiggly?

So we try to debug this by finding literature that debugged something similar, or often we simply design and run more experiments. Skim through pages 172-176 (bottom corner number, not pdf page number) of this document. Their transistors have very similar issues to ours. When you read this document, the answers are behind a huge layer of jargon and acronyms that make the barrier to entry for understanding extremely high.

In reality here is what it is saying:

• Our source-drain is dominated by an aluminum metal-to-silicon Schottky junction instead of doping

Put simply, we just directly connected an electrical characteristic (IV curve) to a physical process parameter. We now have an exact experiment to try over the next week:

• Less metal annealing

• More Si02 etch before metal deposition (to ensure metal contacts Si instead of SiO2)

Right now it takes about 8 hours of work + waiting overnight to turn a blank wafer into one with NMOS transistors on it. Then we go to the probe station, test it, organize the data, look at the graphs, and think. That’s how long it takes to verify each new experiment. With each machine, script, or management tool we create, we push to significantly decrease this iteration cycle.

We've only made NMOS devices so far, but there are so many more things to be made. That means our process data corresponds to NMOS only, but most process steps can be generalized to any process if documented properly.

Each unique device can also use different materials entirely, which requires different machines.

• What metal are we depositing?

• What does the doping profile look like?

• etc.

intro.

Our Goals:

1. Make integrated circuit prototyping as fast as 3D printing

2. Make DIY version of every nanofabrication tool

3. Get there with collaborative open source hardware

Right now we use factories and tools that are optimized to manufacture at scale to do our integrated circuit prototyping. There does not exist a set of machines that enable rapid tape-out of semiconductor devices on a budget, nor are there sufficient resources to make/modify fab tools from the ground up.

Nanofabrication is often communicated as complex magic, where every machine is immutable. We believe that innovation in the industry requires a thorough understanding of these machines from first principles, which will lead us to simpler solutions. Even on machines and processes of magnitudes less complexity than modern industry, there are designs worth sharing.

The use of low-cost, abundant, and fast-turn-around hardware serves a larger purpose than making the fab cheaper. These design constraints are what enable others to recreate, modify, and contribute to our work. The simpler the better.

working on the hacker fab.

You don't need prior nanofabrication experience to create meaningful contributions.

You do need to read the Required Reading.

You don't need to recreate the entire fab to contribute, although you can.

We communicate entirely over Discord.

this website.

This page is a home for all shared documentation. There are enough resources here to turn an empty room into one that fabricates simple IC's in a matter of months.

Many pages are works-in-progress. It is natural for individual contributors' work-in-progress notes to exist on google drive, notion, etc. Links to these exist at the top of each page, however these notes move to Gitbook as soon as possible.

Any contributor can submit change requests with a free Gitbook account. All of this is on Github, but formatted nicely here on Gitbook. You can contribute directly through Github as well.

For the most up-to-date status on everything, join the Discord.

fab toolkit.

Here is a list of all the tools built or bought necessary to make our devices.

Every build contains:

• BOM

• Links to Design Files

• Links to Code

• First Principles Understanding of Machine Design (WIP)

fabrication tools.

verification / metrology tools.

chemicals.

background and licensing.

The Hacker Fab was inspired by Sam Zeloof.

The Hacker Fab was started by Elio Bourcart, Alexander Hakim, and Sam Zeloof.

The first Hacker Fab was opened at Carnegie Mellon University.

The Hacker Fab is run entirely by independent contributors.

We like making hardware, fast

The Way we Source Parts

Organized List of Sellers

To do, for now search our Purchase Tracker

Link to General Lab Equipment BOM

BOM of each machine is included in separate build documents.

Simplified View of Process

See Fabublox for Interactive View

Alternatively: See Google Sheets for Comprehensive Example with all Parameter Values (Chip 336 Shown Below)

Introduction

This is the project page for a lithography system based on repurposing Blu-Ray drives. The initial goal is to reach a feature size of at least 500nm (2x the Blu-ray laser spot size). As a stretch goal, we would like to also use the sled and spindle motors as high speed nano-positioners and to spin coat and cure photo-resin.

Project Status

Right now, the first project for this technology (Lithography Spinner V1) is in the research/idea stage. See work in progress page for details on upcoming tasks if you want to contribute.

Background

Our design was based on Sam Zeloof and Huygens Optics’ versions of this tool. Sam repurposed a vertical microscope for structure and laid out optics experimentally with a 5x reduction objective, whereas Huygens built his own horizontal structure, and used more involved optics with a 20x reduction. We took the middle road by combining a scratch built structure with ThorLabs optical and optomechanical components to ensure alignment. We use a 10x objective for demagnification. We also opted for a different mechanical XYZ stage.

Hardware Specs

Related Links

Patterning SOP

Litho Stepper Software

Tools Required for Manufacturing

• Water jet capable of cutting ¼” aluminum plate

• Manual milling machine and small end mill

• Drill

• Screwdriver and metric allen key sets

• Glass scribe (tungsten carbide or diamond)

• 3+ large C clamps or similar.

Bill of Materials

Link to spreadsheet - edit sheet then update or copy table here

Total Cost: $5,820.10

The complete list of ThorLabs parts is in the second sheet in the Stepper BOM. To order all of these at once, download the third sheet as a CSV and upload it to ThorLabs Upload Cart.

Design File Summary

Link to GitHub repository

Most of the water jet components can be cut from a single 12” square aluminum plate. Water jet layout.SLDASM provides the pattern for this. The base needs a separate 18”x6” plate.

Build Instructions

The following steps do not need to be completed in order, except for the last three sections (assembling the structure, stepper, and alignment).

Fabricate the structural parts

1. Export “Water jet layout.sldasm” and “base.sldprt” to the appropriate 2D vector format for your water jet (likely .DXF).

2. Water jet these two files, following the instructions for your specific machine. A CNC router may also work.

3. 1. Be aware that the “base” part takes up the full 6”x18” plate, so no need to cut the outside edges. You may need to adjust the kerf settings so your water jet cuts on the inside of each hole.

4. Countersink all the holes on the bottom of the base plate.

5. 3D print the projector coupler with default settings.

6. Cut the angle iron into three 80 mm long pieces and one 60 mm long piece using a saw.

7. Cut the slot in the adjustable bracket using a 4mm or slightly larger endmill (3/16” works). None of the dimensions of the slot need to be precise. The holes in all the brackets will be drilled during the assembly process.

Assemble the optics

1. Open “_optics_assem.sldasm” for reference during assembly. The cutaway view may be helpful.

2. Unscrew the set screw on the cage cube to remove the filter mount. Insert the beamsplitter into the mount so that the text on the beamsplitter reads forwards when viewed from the projector.

3. Bolt the two filter holders together using four M3x20 or similar screws and washers.

1. Use SM1 locking rings to mount the UV bandpass and red longpass filters in the two filter holders. Make sure the filters are inserted in the correct direction. Label the filter holders “red” and “UV”.

2. Screw together the rest of the optics, paying attention to the direction of the tube lenses.

1. Use calipers to adjust the length of the vertical SM2 tube so that the distance between the tube lens and the camera flange is exactly 134.3 mm. This value is calculated by subtracting the standard C-mount flange focal distance (17.526 mm) from the TTL-200A tube lens’ working distance (151.8 mm).

Prepare the projector

1. Unscrew all available philips screws in the projector.

2. Use a small flathead screwdriver to pry open and remove the top projector housing. This takes some rough handling.

3. Remove the front foot by removing the metal pin as shown below, then unscrewing the foot out while pushing the tabs in.

1. Unscrew the three screws that hold the stock lens assembly to the projector and remove the lens.

1. Remove the plastic half-lens cover and cut the top housing as shown above.

1. Unscrew and detach the lamp assembly (screw circled).

1. Cut the Thorlabs UV-pass hot mirror to the same width as the stock hot mirror.

   1. Use a scribe to mark the correct width on both sides of the UV-pass hot mirror.

   2. Use a straightedge to scribe a deep groove in the hot mirror. Use a lot of force and several passes.

   3. Apply bending pressure to the hot mirror with the groove facing away from you until it breaks.

Assemble the structure

The following steps will benefit from having two or more helpers. In the images below, the red arrows indicate applied pressure for ensuring parts are correctly mated. Green arrows indicate clamps. Yellow dots indicate tightened fasteners. For all drilling steps use the largest drill bit available that freely fits inside the holes for the brackets.

1. Put the projector back plate and triangle bracket into their slots in the base. Apply pressure as shown so that both parts are flat against the base and in the corner of their grooves.

1. While maintaining pressure, place one 80mm bracket between the triangle and the back plate and clamp it to the triangle.

1. With the clamp still attached, drill through the bracket using the holes in the triangle for alignment. Use M5 nuts and bolts to fasten the two parts together. Put the nuts on the outside to avoid interference with the projector.

1. Return the parts to their previous position, apply pressure, and clamp the bracket to the back plate.

1. With the parts still clamped, drill two holes and fasten. Depending on the size of your drill, it may be necessary to unbolt the triangle first.

1. Clamp the other 80 mm bracket to the back plate. Clamp the 60 mm bracket to the triangle. Ensure the brackets lay flush on the base.

1. Drill into the brackets using the holes in the back plate and triangle for alignment. Fasten with any protruding screws on the outside to avoid interfering with the projector.

1. Place the assembly back into the grooves on the base, again pushing them into the corner. Clamp both brackets to the base.

1. Flip the base upside down and use the holes on the bottom to drill into the brackets.

1. Attach all three brackets and plates.

1. Use three M4 screws to attach the support arm. Use a straightedge to ensure that the top edges of the support arm and back plate are parallel.

1. Clamp and drill holes in the adjustable bracket. Make sure the top surface of the bracket is flush with the support arm.

1. Structure is complete and ready for further assembly.

Assemble the stepper

1. Screw the manual XYZR stage into the base plate using countersunk screws.

1. Screw the 3D printed projector coupler into the projector with three M3x? screws.

2. Push the optics onto the projector coupler. You may need to temporarily detach the vertical parts of the optics assembly. This part was designed iteratively and may not fit perfectly because the true position of the DLP chip inside the projector is unknown. In that case, it can be modified or removed as needed.

1. Attach the cube adjuster to the cage cube with 4-40 screws. Attach the cube adjuster to the adjustable bracket with M3 screws and washers on both sides.

1. Screw the camera onto the C-mount threads at the top of the optics.

Alignment

1. Go to this link and install the correct Amscope software for the camera MU2003-BI and your operating system.

2. Connect the camera to your computer with a USB 3.0 cable.

3. Connect the projector to your computing using an HDMI cable.

4. Put in the UV filter. Remove the red filter.

5. Turn on the projector.

6. Open AmScope. Select the camera in “camera list”. If everything is working an image should appear (might be black).

7. Place a flat mirror-like object on the stage. This can be a bare silicon chip.

8. Adjust the height of the microscope objective to approximately 16 mm.

9. Focus the image using the Z-axis on the stage. You should see your projected screen. Try projecting some patterns to test the focus.

10. Adjust the lens tube coupler so that the projected image is square inside the camera frame.

Default configuration Without objective

1. Unscrew and remove the microscope objective. You may still see an image. This is because if the two tube lenses are in the correct positions they will perfectly focus the collimated light between them. We will use this to our advantage by translating the entire optical assembly towards/away from the projector until the image is focused. When this step is complete, we know that the first tube lens is 151.8 mm from the DLP chip.

1. We can also use the no-objective configuration to check the stage’s orthogonality relative to the vertical axis of the optics. When aligned, the image will be centered in the camera frame. Any offset (shown below) can be fixed by adjusting the structure in the angles labeled A and B above. This correction fixes the planarity of the focal plane, visible in the images below. Rotation in A moves the image vertically and rotation in B moves the image horizontally in the camera frame.

To add: details about how to mechanically execute alignment, including shims.

No objective, before alignment

With objective, before alignment. Non-uniform focus is apparent in the top left corner.

No objective, after alignment. The projected image (purple) is centered in the camera frame.

With objective, after alignment. Focus is much more uniform.

Validation and Characterization

Demonstrate the operation of the hardware and characterize its performance for a specific application.

• Highlight a relevant use case.

• If possible, characterize performance of the hardware over operational parameters.

• Create a bulleted list describing the capabilities (and limitations) of the hardware. For example, load and operation time, spin speed, coefficient of variation, accuracy, precision, etc

Safety

Wear UV-blocking glasses whenever light leakage from the projector is possible.

Appendix

Introduction

The Lithography Spinner V1 plans to use the Blu-Ray disc assembly from a Play Station 5 (KEM-497AAA) to drive the whole system. They are readily available and can be found for $30-$70 in most places.

Typically a single IC is used to drive these modules but most vendors wont sell chips to individuals. So the plan is to design a discrete controller board to manage all the HW and write our own controller SW.

Want to work on something? Plan a task add your name next to it!

1. Download Klayout from their websites and follow the instructions to install the software

2. After it is successfully installed, open the Klayout editor

1. To create a new layout File>>New Layout

1. Set the initial layer(s) that you need. The current hacker fab process would require 5 layers which are substrate, poly, active, contact, and aluminum. This is just for getting started, you can always add new layers later if you need to do so.

The layers will be shown in the upper right corner.

1. Go to View>>Layer Toolbox to open the layer toolbox so that you can adjust the order of the layers and the texture of the layers based on your preference.

Double-click the layer to hide it. If you are drawing on a hidden layer, the following tip will show up.

1. To create a new layer, go to Edit>>Layer>>New Layer

1. Scroll your mouse to adjust the size of the grid

The grid can also be hidden through View>>Show Grid. When you need to export the masks as screenshots, the mask needs to be hidden.

1. Klayout has the following tools to draw the shapes. Press “shift” to draw straight lines.

1. Draw the rough shape of an object then adjust it to be the exact size by pressing “Q” to edit its property.

1. Mask Exporting (method 1):

   1. Go to Display>>Zoom Fit to maximize the size of the mask on the screenshot

1. Rename and sort the order of the layers according to the order of the fabrication steps. In this case, the easiest way is to sort them by name (0:substrate, 1:poly gate, 2:active layer, 3:contact hole, 4:aluminum)

1. To make the masks compatible with the lithography stepper, adjust the size of the substrate layer (layer 0 in this case) to be proportional to its resolution (3840x2160). In this set of masks, the size of the substrate layer is set to be 384x216. Under this setting, the actual size of the pattern coming from the stepper is 2.5 times the designed size.

2. Adjust the color and texture of the mask to be blue/red/black accordingly to make them compatible with the red focusing and UV focusing.

1. Hide or show certain layers based on the property of the mask and take screenshots via File>>Screenshot and save the mask.

2. Corp the screenshots since the exported screenshot would normally have white sides.

1. Mask Exporting (method 2):

   1. Set up steps are the same as Step 10 a. to c. steps.

   2. Go to Macros>>Macro Development to write Maros in Klayout

1. Select “Python” and change the Macro Template to “Plain Python file”

1. Paste the following code into the Python file you just created. 1

lv = pya.LayoutView.current()
ly = pya.CellView.active().layout()


# top cell bounding box in micrometer units
bbox = ly.top_cell().dbbox()


# compute an image size having the same aspect ratio than 
# the bounding box
w = 3840
h = int(0.5 + w * bbox.height() / bbox.width())


lv.save_image_with_options('/your_directory/your_picture_name.png', w, h, 0, 0, 0, bbox, True)

1. Change the path to the folder where you want your images to be saved. Note that if the name of your folder or file starts with a number, it will give you the following error message.

1. The .png file of your mask will be saved in black and white. Be sure to adjust the color and texture of the mask to be blue/red/black accordingly to make them compatible with the red focusing and UV focusing.

Reference:

Appendix 1. Klayout user guides

Klayout user manual from their websites:

Shorter one for getting started with basic functions:

Appendix 2. Masks for an NMOS enhancement load inverter

Project Specification

Datasheets

This page contains topics that are good to know if you want to contribute to this project.

Optical

Mechanical

Material

Relevant Works

Future Improvements

Here is a of the most recent spin coater V1 build at CMU. More build info to come soon!

• Collect all necessary measurements of the current spin-coater to create the new 3D model.

• Finalize an updated 3D model that includes the servo mount and any necessary adjustments to the lid design.

• Order required components, including a servo motor, necessary mounting brackets, and plastic material for a redesigned lid.

• Cut and prepare the new lid, ensuring proper fit and clearance for rotation

• Assemble all components and build the initial prototype.

• Conduct preliminary functionality tests, focusing on servo movement and integration with the claw mechanism.

• Optimize servo rotation angles and positioning to maximize clearance while minimizing occupied space.

• Conduct final system tests to verify smooth automation and reliable lid operation.

• Implement necessary refinements and finalize the design for long-term use.

List of improvements over

1. Only requires a 3D printer (no machining)

2. Only requires vacuum pump 1/5th the size

3. 1/2 the height

4. Easier to assemble

5. More reliable excess liquid collection

   1. Easier cleaning

   2. Less motor stalling from dried residue

   3. Less residue on window for better visibility

6. Better user interface

   1. Replace touchscreen with potentiometers

   2. Put power button on top so entire operation with 1 hand is possible

   3. Top swinging window becomes flush with side wall and snaps into place

Vacuum Chamber Assembly

After purchasing and receiving all parts outlined in the , follow the step-by-step process to assemble the vacuum chamber.

1. Assemble the chamber frame and plates

(i) Wrap an O-ring around each plate to ensure the chamber has a tight vacuum seal.

(ii) Screw in each plate with 8 bolts into the frame as shown in the following image.

Note: Plan where you want each plate to be (i.e. top, bottom, side) depending on your setup

2. Attach feedthroughs and/or blank flanges

Each opening must be covered and sealed for the vacuum to exist. Therefore, each opening needs a feedthrough in it or a blank flange to cover it. Ensure that each part has the correct dimension to properly fit in its corresponding port.

(i) Pair up the feedthrough/flange with its matching O-ring and clamp.

(ii) Layer the parts in the following order. Starting from the bottom closest to the plate place the O-ring, flange/feedthrough, and clamp. Then attach all necessary screws tightly. Repeat this process for all openings.

3. Turn a face into a door and attach feet

(i) Screw in the hinge into two adjacent plates where you want the door to be.

(ii) Attach knobs on opposite side of hinge to open and close the door securely.

(iii) Attach feet to the bottom of the chamber to minimize vibration.

Final product

Pumping down the Vacuum Chamber

1. Attach the turbo pump to the chamber

Connect the turbo pump (Hi-Cube 80) to the KF-40 plate using the corresponding KF-40 flange and O-ring. Since the turbo pump has a lip that makes it difficult to tighten the screws, we recommend using hex shaped 10-32 x 5/8" screws and tightening with a wrench.

2. Connect the pressure gauge

The Pfeiffer MPT 200 Gauge has a KF-25 connection port. To optimize the 6 plates we chose, an adapter from KF-25 to KF-16 is needed to connect the pressure gauge to the vacuum chamber. Attach using a KF-16 flange to the plate and a KF-25 clamp to connect the adapter to the pressure gauge.

Implement Heating Parts

Heating the vacuum chamber is necessary for two reasons. First, high temperatures of approximately 1200˚C are needed to evaporate the aluminum and perform the thermal evaporation process. Second, heating the chamber allows it to bakeout, meaning that the water trapped inside evaporates allowing the vacuum to achieve a lower pressure.

Our setup consists of two parts: the crucible and the substrate heater.

Crucible Set-Up

The crucible is comprised of the following parts:

Next, connect a power supply to the external end of the power feedthroughs to heat up the crucible.

Finally, attach the thermal breakout board and arduino to the thermocouple to read the temperature values.

If you already have a stepper built and you're looking for information on how to operate the tool, check out our !

Hardware Specs

Hardware Description

Our design was based on and ’ versions of this tool, which is essentially a projector connected to a microscope. We use a 10x objective for demagnification and a mechanical XYZ stage for positioning.

Stepper version 2 has greatly improved mechanical performance over V1 while using the same DLP chip from Texas Instruments. Several factors led to this improvement:

1. Instead of an off the shelf projector with a flimsy plastic housing, we switched to the . This allows for a more robust physical connection to the projector housing, thus eliminating vibrations. It also has much better documentation.

2. By swapping to a finite conjugate microscope objective, the optical path length is reduced from ~250 to 160 mm. This reduces the moment of inertia of the optics subassembly, therefore also reducing vibration.

3. Swapping to LEDs instead of the broad spectrum mercury lamp removes the need to constantly swap filters, which introduced random perturbations from touching the optics. We replaced the stock blue LED with a 410 nm LED mounted on a custom PCB. The PCB design files can be found .

4. Mounting the projector horizontally means less structure is needed.

Tools Required

• M3 and M4 taps

• 3D printer

• Pick-and-place machine

• Reflow oven

• Solder paste (preferably a syringe)

• Calipers

Bill of Materials

Total Cost: $3,062.28 (doesn't include computer and peripherals)

*Upload this CSV file to Thorlabs for all the optomechanical parts + beamsplitter.

Design File Summary

Note: the OnShape folder is organized poorly because it was our first time using it. Won't happen again, we promise!

Build Instructions

Provide detailed, step-by-step construction instructions for the submitted hardware:

• Include all necessary information for reproducing it.

• Explain and (when possible) characterize design decisions. Include any design alternatives you created.

• Use visual instructions such as schematics, images and videos.

• Clearly reference design files and component parts described in the Design file summary and the Bill of materials summary

• Highlight any potential safety concerns.

• Tips and tricks to simplify the assembly process

• Possible errors that might occur during assembly and how to rectify them

Get the Metal Parts Made

Option 1: Water Jet

The Base Plate is 15" long, so double check that your water jet is large enough.

When downloading the Adapter Plate DXF for water jetting, go to Config > Water jet to get the hole sizes right for tapping. The 2.2mm holes are clearance for M2, and the 2.5mm holes are M3 tapped and countersunk.

Option 2: CNC Shop

Option 3: Manual Machining

Adapter plate: This should be manually machineable but we haven't tried.

Solder the UV LED PCB

We used 410 nm UV LEDs on this PCB. We found that two LEDs in series is sufficient to produce enough UV light for patterning. We also found connectors that are compatible with the cable in the TI DLP dev kit.

When assembling the UV LED PCB, it is easiest to use a solder syringe to carefully deposit the paste onto the LED pads and connector pads. If you try to use a stencil mask, it is very easy to smear the paste, so this is not recommended.

Once the paste is applied, you can use a pick and place machine to align the components with their pads. Keep in mind that you need to use a nozzle that is small enough to pick up the LEDs. Finally, you can put the PCB into a reflow oven to solder the components to the board.

You can test by applying 6V (limit to 1A) across the LED leads, but be sure to wear UV-protective glasses, as the LEDs will be bright! Once you are confident that the PCB works, you can now replace the blue LED PCB in the TI DLP dev kit with our new UV LED PCB. To see the UV light, simply look at the leds through your phone's camera, as the sensors see it as purple light.

Disassemble the TI DLP dev kit

Taking pictures after every step is key to ensuring you can put it back together properly.

1. Test the projector before we completely take it apart :)

1. Unplug all the connectors and remove the top PCB by unscrewing the standoffs.

1. Remove the side PCB.

1. Unscrew and remove the shroud by sliding it away from the rest of the optics.

1. Unscrew and remove the heatsink for the front-most LED, which should be the blue one.

1. Disconnect the LED PCB from the cable. Heat it slightly on a hot plate or with a hot air gun to soften the adhesive and remove the black plastic housing.

2. Glue the black plastic piece to the DIY UV LED PCB, connect it to the blue cable, and reattach it to the optics housing. Put the heatsink back as well.

1. Unscrew the projection lens. That one makes things bigger, but we're trying to make things smaller. It's got to go.

1. Screw on the adapter plate with four countersunk M2 screws.

1. Reassemble the rest of the projector, including the shroud and the PCBs.

Assemble the Optics

1. Start with the beamsplitter cube. Unscrew the set screws, remove the holder, and clip in the beamsplitter. The text ("Thorlabs") should be facing the microscope objective and camera when the holder is reinserted. Keep track of this during assembly and fix it later if necessary.

1. Assemble the DLP tube. From left to right, the parts in the first picture are 0.3" lens tube (SM1L03), 0.5" lens tube coupler (SM1CPL05), 0.5" adjustable lens tube (SM1V05), and 0.5" lens tube (SM1L05). You may want to remove any internal lens rings. The adjustable lens tube allows axial length adjustment and the coupler allows rotation about the optical axis.

1. Screw the DLP tube into the beamsplitter cube. The correct orientation is shown above, and the arrow points to the side of the beamsplitter with the text (and optical coating).

2. Assemble the camera tube, which similarly constructed. The parts are 1" lens tube (SM1L10), 1" lens tube coupler (SM1CPL10), 1" adjustable lens tube (SM1V10), another 1" lens tube (SM1L10), and C-mount SM1 adapter (SM1A9) (last two shown below).

1. Make sure this camera tube is 82.3 mm long. We calculate this number by subtracting the various component lengths from the standard microscope objective back focal length of 160mm: 160 - 17.5 (c-mount camera) - 22.1 (objective tube) - 38.1 (beamsplitter cube).

1. Screw on the C-mount SM1 adapter (SM1A9) to the camera and the 1" lens tube. Adjust the lens tube coupler to align the camera with the beamsplitter cube.

1. Assemble the objective tube, which consists of a 0.5" lens tube (SM1L05), a 0.3" lens tube (SM1L03) an SM1 to RMS adapter (SM1A3), and the microscope objective.

1. Temporarily loosen the top lens tube coupler in order to finally screw the entire assembly into the projector.

3D Print and Assemble the Stage

Print all of the parts in the table below. Black PLA is fine. You may need to re-orient them so they print well. The stepper mounts will all need small supports in the motor flange. The X and Y axes need other supports as well.

1. Unscrew all the, micrometers, L-stops and stage locks from the micrometer stage. Separate the X, Y and Z axes. Throughout the assmebly process we will be replacing the stock screws with ~4mm longer ones as we reattach the various components to the stage. All 3d printed mounts are 4mm thick at the screw holes. Have your M2.5 screw kit handy!

1. Press fit the three sliding shaft couplers onto the three micrometer handles until the knurled surface is fully covered. They should fit with significant force and maybe gentle hammering. Be careful - the micrometer handles may have different diameters so you may need to modify the CAD and reprint to get a correct fit.

1. The shaft couplers should slide on the motor shafts with zero slop. Modify dimensions and re-print if this is not the case. Graphite lubricant may help decrese sliding friction, and the fit will get looser after repeated axial movement as the steel deforms and smooths the plastic.

1. Screw the motor, coupler, and micrometer into the X axis motor mount as shown. Doing this step before attaching to the rest of the stage takes advantage of the slop in the micrometer mounting screws and aids alignment.

1. Slide the Y axis motor mount onto the Y axis. You will need to remove some screws and push the stage to allow it to slide on.

1. Attach the motor. Don't screw down the micrometer mount yet.

1. While pushing the stage so the micrometer isn't touching the stop, fasten the micrometer mount. This avoids preloading the micrometer/motor assembly and improves shaft alignment.

1. Reattach the X axis micrometer stop as well. You may need to adjust the screw length to get it to fit.

1. Insert the Z axis motor mount to the Z axis. The easiest way to do this is to insert it upside down from the opposite side, then flip it while pushing the stage up, then slide it back so the holes line up. Basically it takes some fiddling.

1. As with the other stages, attach the motor first, then secure the mounts. Tighten the set screw at the green arrow. Make sure the micrometer is flush with the mount at the yellow arrow. Again pushing upwards at the red arrow eliminates prelaod from the spring inside the stage and helps alignment.

1. Tighten down the Z axis mount.

1. Attach the X axis motor mount to the stage with the screws at the red arrows.

1. Add additional screws on the X and Y axes to make sure the mounts are solidly attached. Ignore the spring in the above image.

1. Attach the right angle bracket to the theta stage and the top of the Z stage.

1. Screw the chip vacuum chuck onto the theta stage. The stage is finished.

Mechanical Integration

1. Bolt the XYZ stage to the base plate using short screws so they don't protrude out the bottom. Ensure the stage is aligned with the tapped holes by pushing it forward while screwing it down.

2. Screw in the four alignment screws for the projector. They don't need to go in all the way.

1. Push the projector and optics against the four screws to ensure alignment.

1. Plug in everything: power for the projector, locking USB cable for the camera, USB cable for the stage, power for the stage, HDMI for the projector, power for the pump, and vacuum tube for the chuck. Do not power the stage arduino shield without the motors connected, or you will burn out the drivers.

Install Software and Flash Firmware (WIP)

To install and run the software, you will need a Windows system that has two USB ports. The rest of this section describes how to install the following dependencies:

1. Arduino GRBL firmware

2. Python version 3.10 and Python libraries

3. FLIR Blackfly S Camera Drivers & Viewer

After these are installed, you may clone and instantiate the stepper repository on your device. Optionally, you can develop your own driver for the Flir camera to allow a GUI-integrated live camera preview of the stage. Instructions for such are included below as well.

Arduino GRBL Installation

1. Install Arduino IDE.

1. To test that the installation was successful, open Arduino IDE and open the serial monitor. You should see text indicating that a version of GRBL is running on your Arduino.

Python Version 3.10

At the time of development the latest Python version the Flir Spinnaker SDK supports is version 3.10. As such, you must install libraries and run the software for/from this version.

3. Import necessary libraries with pip

   • pip install pillow, serial, opencv-python

   • TKinter should be bundled with the 3.10 download, but if not found, it must be installed with local package manager: not pip

   • PIL / Pillow -> pip install pillow

   • Serial -> pip install serial

   • cv2 -> pip install opencv-python

   • Do not install camera library with pip, as it will conflict with the Flir python library

FLIR Blackfly S Drivers & Viewer Installation

(WIP)

Stepper GUI Installation

1. Open git terminal to the location where you want the Stepper GUI software to be downloaded. Then, run the following commands:

• git clone https://github.com/hacker-fab/stepper .

• cd stepper

1. If you have access to the private Flir camera submodule repository, then also enter the following commands:

• git submodule init

• git submodule update

  Otherwise, disable the camera in the software. To do this, go to the stepper/litho/scripts/config.py file and toggle the necessary flags at the top (i.e. RUN_WITH_CAMERA = False). (Or, if are using a different camera, update config.py to select your camera instead. The camera must implement the CameraModule interface.)

1. Run the software.

• py -3.10 ./litho/scripts/Lithographer.py

1. Run lithographer.py with Python 3.10:

   • py -3.10 ./litho/scripts/Lithographer.py

Optional: Flir Spinnaker SDK (for software developers)

The Stepper V2 build uses a Teledyne Flir camera and custom software written for it. The Stepper software uses the Flir Spinnaker SDK to integrate a live camera preview of the stepper's stage. Since the SDK and its derivative software are closed-source components, we currently do not possess the legal authority to grant access to our custom Flir camera driver to third parties. The following steps describe how to install the Flir Spinnaker SDK and how to develop your own driver. Please carefully review all terms, agreements, and licensing requirements. Follow the steps below.

3. Decompress your download if necessary. Open the README.txt file in the (decompressed) download and follow the installation instructions inside.

4. Test that the installation was successful by running an example program. To do this, first make sure your Flir camera is connected. Then, open git terminal in the "Examples" folder. Then, choose any example .py script and run it by entering py -3.10 NameOfYourScript.py. Ensure that the program output reports connection and communication with your Flir camera.

5. • def __init__(self)

   • def setStreamCaptureCallback(self, callback)

   • def streamImageReady(self); returns True if live image is available

   • def getStreamCaptureImage(self); returns a tuple of (numpy ND image array, shape of that array, and an image format string ("rgb888" or "mono8")), or False if the image is invalid

   • def isOpen(self); returns True if the camera is active

   • def open(self); returns True on success

   • def close(self); returns True on success

   • def startStreamCapture(self); returns True on success

   • def stopStreamCapture(self); returns True on success

   • a Flir image event handler

   We also suggest optimizing live preview performance by selecting a low-overhead color processing scheme and by displaying only the most recently acquired image (i.e. newest first). The Flir SDK code examples show how you might do this.

6. In config.py, assign "camera" to an instance of your FlirCamera class. For instance:

RUN_WITH_CAMERA: bool = True # set to True to test camera preview 
RUN_WITH_STAGE: bool = False # set to True if controlling the stage from GUI
if(RUN_WITH_CAMERA):
  # ...
  import camera.flir.flir_camera as flir # in camera/flir/flir_camera.py...
  camera = flir.FlirCamera() # instantiate a FlirCamera
  # the camera variable is imported and used by the remaining stepper code.

Final Alignment (WIP)

Once the stepper is connected to a computer and the live camera feed is visible, proceed with final alignment. The goal is to adjust the tube length between the DLP housing and the beamsplitter cube such that both the projected image and the chip are in focus.

1. Place a chip with a visible pattern on it. Cracked glass or extremely dirty chips are good options.

2. Project a mostly red image with some fine marks for determining focus.

3. Using the Z axis (focus) of the stage, focus onto the chip surface. Disregard the projected pattern for now.

1. Loosen the clamp that connects the two parts of the DLP-beamsplitter tube so that they freely rotate. (update picture)

2. Loosen the locking ring on the adjustable lens tube.

3. Screw the adjustable lens tube in/out while periodically checking to see if the projected image gets more or less in focus. You may need to push the optics into the coupler to ensure planarity.

4. Once both images are in focus at the same time, tighten the locking ring on the adjustable lens tune as well as the coupler. (insert image)

Safety

Appendix

This page documents the current work being done on patterning systems and the goals of that work. If you want to start a new project or research related to patterning, add it here so we can keep track of what's being done!

Backlash Improvements

The current design for stepper v2 involves having the micrometer-motor couplers slide along the shaft of the motor. This leads to wear in the 3D print and prevents the use of a rigid connection, leading to the coupler eventually becoming loose. This can cause ~30º of backlash in the rotation, which corresponds to about 15 microns.

Mounting the motors on the stage that they move, rather than on a (relatively) fixed stage allows for using a rigid coupling without significant modification to other parts of the design. These fixes should be applicable to any fab with an existing v2 stage. This is a major enabler for .

This may require redesigning the stage to be mounted upright, or the stage to be turned sideways.

The WIP CAD files are available on and more information can be found .

Absolute Positioning

In order to enable many features like automated or computer-assisted patterning, it must be possible to consistently refer to positions on a die. This requires being able to determine the absolute position of the stage.

There has been some experimentation with using inductive sensors for determining the stage position, though calibrating and mounting the sensors is difficult. The accuracy for a properly calibrated and mounted sensor may be sufficient, though. (TODO: Link inductive sensor notes once those get merged)

Currently, a design using simple limit switches is being developed (though blocked on ).

Cost Reductions

The current optics system is not physically capable of handling the projector's resolution, i.e. some amount of detail is wasted in the optics system. This means that we can use a lower resolution (read: cheaper) projector.

Lastly, there are other components in the optics system itself that we believe can be modified/replaced to further reduce the cost. The ThorLabs components cost at least $700, but many of those parts such as tubes and flanges could be replaced by 3D-printed parts. We will have to test to see if heat generated by the stepper becomes an issue, but this would provide a significant reduction in cost.

Altogether, we believe that we can bring the cost of the stepper below $2000 - perhaps even $1500.

For a description of what the team at CMU is working on in Spring 2025, check out !

Bill of Materials

A complete list of parts and components used in making the DIY ALD system can be found .

Introduction

We are building a low cost Atomic Layer Deposition machine for the Hacker Fab to achieve improved gate dielectrics, which will help us achieve our goal of a 10 micron CMOS process as well as improve our capability in performing thin-film research. Our design work on it will be all open source, and we hope other labs can use our work to make their own ALDs at a fraction of the cost of commercial alternatives. We are building our ALD to fit 4" wafers so that it can be brought into the nanofab, which will help us lower the barrier to entry for researching thin film deposition and new materials. Although 4" is much larger than anything we are currently using in the Hacker Fab at CMU, this larger size will make it useful to a larger audience.

Our work thus far has been focused on machine design, largely drawing from two papers on “DIY” ALD machines; ” by Michael Lubitz, and “” by Pamburayi Mpofu. Each of these papers describes their machine design followed by some process development where they describe the settings (ie. temperatures and precursors deposition times) used in their initial depositions.

This document will present the current proposed machine design plan and the work completed to date for our vertically aligned, cold-walled reaction chamber ALD machine for the Hacker Fab.

Precursor Selection

Oxide of interest

For the current system we aim to deposit Indium-Tin Oxide. Indium Tin Oxide (ITO) is a versatile material widely recognized for its excellent electrical conductivity and optical transparency. These properties make ITO a promising candidate for advanced applications, particularly as a channel material in thin-film transistors (TFTs). Its high carrier mobility and tunable electrical characteristics offer significant potential for improving TFT performance in display technologies and flexible electronics. Additionally, ITO thin films are of great interest in materials and thin-film research due to their unique combination of metallic and semiconducting properties. This makes them an ideal system for exploring novel deposition techniques, optimizing film uniformity, and investigating structure-property relationships.

The precursors for the metals were chosen based on their feasibility to react with water vapor as the oxidizer. The precursors chosen are Trimethyl Indium (TMIn) for Indium and Tetrakis(dimethylamino) Tin (TDMASn) for Tin with Nitrogen carrier gas. They have been shown to be used for ALD and CVD processes with water as the oxidizer in literature. As a starting point our aim would be to reproduce the results achieved in [Zhang et al.]. The process parameters highlighted in the paper are as follows (substrate temperature: -225C):

Safety Considerations

Most precursors and specifically metal organic precursors used for CVD and ALD processes tend to be pyrophoric (i.e. thermally unstable and spontaneously ignite on exposure to air) thus necessitating safety measures.

Material Considerations

Compatibility with the precursors and byproducts produced during reaction are important to consider when selecting components for the delivery system. For our given precursors the chemical groups for which we checked compatibility are: 1) ability to handle pyrophoric materials, 2) ability to resist corrosion due to water vapor, 3) compatibility with methane (by product of TMIn reaction with water) and dimethylamine gas (by product of TDMASn reaction with water)

Specific choices:

• Stainless Steel Tubing

• Aflas O-rings - conventionally used Viton O-rings are incompatible with dimethylamine

• Aluminum vacuum chamber

• Stainless steel bellow hose

• Vacuum pump - Although the vacuum pump manufacturer warns against using the pump with pyrophoric gases, this caution can be safely disregarded in our case. Since we will be working with extremely dilute concentrations of these gases, the risk of combustion or hazardous reactions is significantly minimized. The low concentration ensures that the gases remain well within safe limits, allowing for the pump's use without compromising safety or performance.

Sourcing Precursors

DIY Substrate Heater

The goal of the DIY substrate heater is to develop a cost-effective, replicable ALD wafer heater to support thin-film deposition processes for materials research. Commercial solutions for wafer heating are often prohibitively expensive, making this tool an accessible alternative for Hacker Fab and other researchers. Existing solutions do not meet specific size, temperature, or vacuum compatibility requirements at an affordable price. By designing this tool, we contribute an open-source option tailored for ALD processes. This supports the open-source nature of Hacker Fab by enabling other researchers or users to replicate and build their own wafer heaters. It allows for a more cost-effective approach to ALD, contributing to the open-source knowledge base by providing detailed, replicable build instruction.

Heating Element Setup

• Use 22-gauge nichrome wire to create a heating coil.

• Arrange the wire in a zigzag pattern to cover the area of the heating plate (approximately 4.5-inch diameter).

• Place the nichrome wire between two boron nitride plates (each 0.1-inch thick). Boron nitride provides electrical insulation while allowing efficient heat transfer.

Construction of Heating Plate

• Mount the heating element (nichrome wire and boron nitride assembly) onto an aluminum disk (4.5-inch diameter, 0.1-inch thick). The aluminum disk acts as a heat spreader, ensuring uniform heat distribution to the wafer.

• Secure the boron nitride plates with aluminum bolts to ensure tight contact and structural integrity.

• Ensure that the wire ends extend outside the assembly for electrical connections.

Assembly and Connections

• Position the aluminum plate so that it faces upward, serving as the surface for the wafer.

• Connect the nichrome wire ends to a DC power supply. This power supply should allow adjustable voltage (up to 30V), which will control the current and regulate the temperature of the nichrome wire.

• Attach a thermocouple to the aluminum plate for temperature monitoring. This will help ensure the wafer reaches and maintains the target temperature (300°C).

Operation

• Gradually increase the voltage on the DC power supply to heat the nichrome wire. Use the thermocouple reading to fine-tune the voltage for achieving the desired temperature.

Specifications

• Temperature Range: 300°C to 500°C

• Material Compatibility: The heating element is designed to be compatible with a 4-inch wafer and is placed between aluminum and Boron Nitride plates.

• Voltage: The heater operates with a maximum input voltage of 30V.

• Power Requirements: The heater needs a stable DC power source capable of delivering sufficient current to reach the target temperature.

• Thermal Uniformity: The temperature should be uniformly distributed across the wafer, verified using a laser thermometer to ensure consistent heat application during ALD processes.

• Size: The heating element is sized to fit a 4-inch wafer, ensuring full coverage.

Voltage and temperature data

Select Vacuum-Compatible Feedthroughs

Feedthroughs are specialized components designed to pass electrical, thermal, or other signals through a vacuum boundary. For your heater, an electrical feedthrough is required.

Key Features:

• Vacuum Compatibility: Ensure it is leak-tight, rated for the vacuum level (e.g., high vacuum or ultra-high vacuum).

• Temperature Compatibility: The feedthrough must withstand high temperatures near the heater.

• Electrical Capacity: Rated for the current and voltage requirements of the nichrome wire.

Common Materials:

• Metal-to-ceramic seal feedthroughs: These use materials like stainless steel and alumina ceramics for high durability and vacuum compatibility.

• Glass-to-metal seals: Suitable for lower voltage and current applications.

Vendors:

Feedthroughs are available from companies such as:

• MDC Vacuum

• Kurt J. Lesker

• Conax Technologies

• Allectra

Mounting the Feedthrough:

• Install the feedthrough into a flange on the vacuum chamber (e.g., CF, KF, or ISO flange systems).

• Use O-ring seals (Viton or Buna-N) for lower vacuum applications or indium gaskets for ultra-high vacuum.

Wire Connections

• Inside the Chamber:

  • Connect the nichrome wire to the internal terminals of the feedthrough using vacuum-compatible connectors (e.g., nickel or stainless steel).

  • Ensure insulation with high-temperature, vacuum-compatible materials such as ceramic or polyimide.

• Outside the Chamber:

  • Connect the power supply to the external terminals of the feedthrough.

  • Use shielded cables if electromagnetic interference is a concern.

Detailed Instructions for Assembling the Substrate Heater Component

Materials Required

• Nichrome wire (22-gauge)

• Boron nitride plates (2, 4-inch diameter, 0.1-inch thick)

• Aluminum disk (1, 4-inch diameter, 0.1-inch thick)

• Thermocouple

• Bolts and nuts (compatible with boron nitride and aluminum plates)

• Insulating washers (if needed, for vacuum compatibility)

• DC power supply

• Wire connectors

• Heat-resistant adhesive (optional for securing wires)

Assembly Steps

Step 1: Preparation

• Cut the wire to the appropriate length (as per your design, typically around 14 inches).

Step 2: Setting up the Heating Element

• Wire Arrangement:

  • Lay one boron nitride plate flat on a stable surface.

  • Arrange the nichrome wire in a zigzag pattern across the surface, ensuring even coverage. Leave wire ends long enough to extend outside the assembly for electrical connections.

• Layering:

  • Place the second boron nitride plate on top of the first, sandwiching the nichrome wire between them. Ensure the plates align perfectly.

Step 3: Mounting onto Aluminum Plate

• Place the boron nitride and nichrome assembly onto the aluminum disk.

• Align the pre-drilled bolt holes in all three layers (aluminum, boron nitride plates).

• Insert bolts through the assembly, using insulating washers if needed to maintain electrical isolation.

• Secure the bolts with nuts, tightening evenly to ensure good thermal contact without over

Step 4: Electrical Connections

• Attach the thermocouple to the aluminum plate using thermal paste or tape for accurate temperature monitoring.

• Use a multimeter to check for electrical continuity and verify there are no short circuits.

• Attach the nichrome wire ends to the wire connectors and connect them to the DC

Step 5: Final Assembly

• Seal the feedthroughs to maintain vacuum integrity.

• Route wires for the power supply and thermocouple through vacuum chamber feedthroughs.

• Use vacuum-compatible connectors.

• Position the entire assembly inside the vacuum chamber

Future Testing Tasks

• Initial Power Testing:

  • Gradually increase the voltage while monitoring the temperature using the thermocouple.

  • Record the time required to reach target temperatures (e.g., 400°C, 500°C).

• Thermal Uniformity Testing:

  • Use a thermocouples to verify uniform heat distribution across the aluminum plate.

• Vacuum Compatibility:

  • Test the system under vacuum conditions to ensure no leaks in the feedthroughs and proper operation of the heater.

• Optimization of Wire Length and Voltage:

  • Experiment with different lengths of nichrome wire to find the optimal balance between power efficiency and heating uniformity.

• Long-Term Durability Testing:

  • Run the heater for extended periods to evaluate its stability and reliability.

• Temperature Controller Integration:

  • Test the system with a PID temperature controller to automate heating and maintain stable temperatures during operation.

• Documentation of Results:

  • Plot temperature vs. time, power vs. temperature, and voltage vs. temperature graphs based on experimental data.

  • Note any issues or observations to refine the design.

Challenges

• Wire Placement: Achieving uniform heating is dependent on precise placement of the nichrome wire.

• Vacuum Constraints: The vacuum environment imposes limitations on assembly and temperature uniformity

• Optimization of Power and Heating Time: There is a need to balance the wire length for optimal performance. A longer wire enhances heating uniformity but consumes more power and increases the time required to reach the target temperature.

Future Improvements

• Alternative Materials: Testing circular mica heaters or other heating elements for improved thermal response times.

• Optimization Studies: Verifying whether the aluminum disk is essential. Direct placement of the wafer on boron nitride could simplify the design without compromising functionality.

• Enhanced Efficiency: Refining nichrome wire routing to minimize heat loss and enhance system efficiency.

• Parameter Tuning: Finding the sweet spot between nichrome wire length and power consumption to maximize performance while minimizing energy usage and heating time.

Delivery System

System Design

For the delivery system we chose VCR connections for the gas lines in our vacuum system to ensure a reliable, leak-tight seal, essential for maintaining system integrity. These metal-to-metal sealing connections are ideal for ultra-high vacuum (UHV) and high-purity gas applications, reducing the risk of leaks, outgassing, and contamination. Their robust design and reusability also made them a practical choice for our setup, where frequent assembly and disassembly are required. We use a two-stage regulator at the carrier gas cylinder as it ensures consistent and precise pressure control, reducing the high-pressure gas from the source to a stable, manageable level for downstream components. This stability is essential for maintaining uniform gas flow in the system. The gas at the correct pressure is then delivered through a mass flow controller that regulates the flow rate of gases entering the system, providing precise control to meet process requirements. It ensures accurate delivery of gases to the precursor manifold. We are receiving a precursor manifold having three Swagelok ALD3 valves donated by the Claire & John Bertucci Nanotechnology Laboratory at CMU. The precursor manifold serves as a distribution hub, directing gases to valves. It includes multiple inlets for the precursor bubblers and an outlet to lead to the chamber, enabling the mixing or isolation of various precursors before delivery to the reaction chamber. The ALD valves in the manifold are high-speed, precise valves that control the pulsed delivery of precursors into the vacuum chamber. These valves are critical for achieving the sequential gas flows required in ALD processes. The line finally leads to the vacuum chamber designed to be a cross-flow reactor.

Components requiring connection for delivery line:

• Chamber precursor inlet: KF25 flange fitting

• Precursor Manifold:

  • Inlet: ¼” female VCR

  • Outlet: ¼” male VCR connector

• MFC inlet and outlet: ⅛” NPT female connectors

• Dual stage regulator: reduces cylinder pressure (~2000 psi) to operating pressure for Mass Flow Controller (<70 psi)

Control Systems

Components/Hardware Requiring Control

Parts to be controlled:

1. Mass Flow Controller - Controls the amount of carrier gas flowing through the tubing per time. Requires an analog signal 0-10Vdc and power supply of 12-24 Vdc, 250mA

2. ALD valves - Controls the duration for which precursors are open to the carrier gas line. Works on a pneumatic valve that is actuated by solenoids. Requires N2 gas input for pneumatic actuation and square wave signal of 24 Vdc with wave width equal to valve open time.

1. Delivery line and substrate heaters - Controls the temperature of the gas lines and substrate holder surface. Requires control of voltage and current being delivered to the heating element to modulate based on reading from the thermocouple.

2. Throttle Valve - Controls the pressure of the vacuum chamber by modulating the evacuation rate of the pump based on current pressure.

Outline of controls

Control parts using LabVIEW and RaspberryPi (given the number of different signals and components we decided to use a Pi instead of using an Arduino)

RaspberryPi is great for handling low-level hardware tasks, such as controlling valves, relays, and sensors. It can read analog or digital signals, control actuators (e.g., motors or heating elements), and interact with sensors that LabVIEW can’t interface with directly.

Progress

The ALD valves are controlled based on their status in a truth table, where each row corresponds to a specific step of the ALD cycle. The truth table defines the ON/OFF state of each valve, with True indicating the valve is ON and False indicating it is OFF. The appropriate row of the table is accessed dynamically, depending on the current step of the cycle.

To implement this control, a relay board is used to interface the ALD valves with a 24V DC wall adapter. The relay board switches the power supply to the valves according to the truth table commands, ensuring precise timing and coordination for each step of the ALD process. For depositing Indium Tin Oxide (ITO), which requires two metal precursors, the ALD valve operation is determined by the desired ratio of the two precursors. To achieve this, a sequential block is used to calculate the current cycle number in the ALD process. Based on the cycle number and the specified precursor ratio, the sequential logic selects which metal precursor valve to open. This setup allows for reliable and automated control of the gas delivery system during operation.

To control the heating elements, temperature data is collected from thermocouples at a specified sampling rate and frequency using a DAQ (Data Acquisition) system. The measured temperature readings are averaged to calculate a mean temperature, which provides a stable input for feedback control. The mean measured temperature and the target temperature are then fed into a PID (Proportional-Integral-Derivative) controller. The PID computes the required voltage adjustment to maintain the target temperature by supplying the appropriate voltage to the resistive heating elements. This feedback loop ensures precise temperature control, critical for maintaining process stability and uniformity during operation.

We are still in the process of testing this and are currently figuring out how to use DAQ hats on Raspberry Pi to collect the data at a given frequency.

Challenges

Vacuum Chamber + Vacuum Pump

Motivation

The vacuum chamber and the vacuum pump are the foundation of the ALD machine, providing the controlled environment necessary for thin-film deposition on the 4 inch diameter wafer. Initially, the idea of machining the vacuum chamber in-house was considered, but quickly decided against due to the precision needed to manufacture a reliable vacuum chamber, and given that the ALD machine project is on a quickly-moving timeline, This project addresses these gaps with a cost-effective and adaptable design, which was easily outsourced and purchased, for academic and research settings.

Technical Requirements

• Vacuum Pump Range: The vacuum pump and chamber should be able to reach mTorr levels of vacuum to reach precursor baseline pressures.

• Temperature Requirements: The vacuum chamber should be able to withstand temperatures up to 500°C, in order to align with precursor pressures and thermal evaporation benchmarks, and to keep the wafer at 300°C

• Vacuum Chamber Material: Aluminum for affordability and compatibility with high vacuum and temperature conditions.

• Port Configurations: Modular design to accommodate multiple gas inlets and precursor integration.

Design Process

With the technical requirements in mind and once the precursors were selected (and ITO was decided upon), the design process for the vacuum pump and vacuum chamber evolved quickly over the first half of the semester. Originally, the vacuum chamber had a technical requirement of being made of only stainless steel, avoiding aluminum due to concerns about compatibility with the gases. Eventually, aluminum was reconsidered to be a vacuum chamber material option, after double-checking its compatibility with the gases.

Vacuum Pump Selection + Design Choices

For the vacuum pump, extensive research was conducted to identify a pump capable of maintaining the desired vacuum range without overloading the budget. It was necessary to ensure compatibility with the fact that it would be used with gases as well. Despite initial hesitation due to the high cost of some components, we finalized the order for the Edwards nXDS6i Dry Scroll Vacuum Pump, as it has been used for other DIY ALD machines in the past and is known to be reliable for these purposes. This step was crucial to ensuring the entire vacuum system could function as intended without compromising the ALD process's precision.

Vacuum Chamber Selection + Design Choices

A major milestone was sourcing the 9x9x9 modular vacuum chamber from Ideal Vacuum, initially inspired by using the 6x6x6 Ideal Vacuum chamber that’s used for the thermal evaporator. We noticed that the inside temperatures of the thermal evaporator reach even higher temperatures than needed for ALD, even though on the Ideal Vacuum site, the specs say it isn’t rated for that high of a temperature. This milestone, though, was guided by its versatility, as the modular port placements allowed for customizable configurations. Additionally, this chamber offered a practical balance between cost and performance, addressing both budget constraints and functional needs. To further refine this selection, the 9x9x9 pre-selected component kits were compared with the individual necessary components (with itemized lists of those individual components), weighing the trade-offs between cost savings and assembly complexity. All individual components ordered are listed in the BOM shown in the Appendix.

As shown in the BOM for vacuum chamber components, the 6 sides to the modular vacuum chamber from Ideal Vacuum which were ordered, with reasoning as to why, were:

1. One (1) plate with a viewing window and door hinge, to easily place and remove the 4” diameter wafer.

2. One (1) plate with four (4) KF16 inlets in order to connect the pressure gauge, temperature probe, and electrical lead. Each of those three components connected to the ALD account for one KF16 inlet, leaving a single KF16 inlet covered by a blank flange, and reserved for if future leads are needed.

3. Two (2) plates with single, centered KF25 inlets, to be placed on the top and bottom of the cube, with the top inlet being the gas inlet, or the gas entering the vacuum chamber, and the bottom outlet being the vacuum chamber’s connection to the dry scroll vacuum pump and throttle, or where the gas will exit the chamber. This top-to-bottom placement is to prompt laminar flow of the gases and increase chances of even deposition throughout the wafer. The gas flow is depicted below.

4. Two (2) blank plates

Vacuum Chamber + Vacuum Pump Baseline Test

As of the end of the Fall 2024 semester, the vacuum chamber has been fully assembled, using only parts provided by Ideal Vacuum including Viton o-rings and o-ring fittings, and connected to the pressure gauge and vacuum pump. It’s important to note that this vacuum chamber assembly is only temporary, as Viton is not compatible with the gases used for the Hacker Fab ALD machine. A baseline vacuum test was conducted with the Viton o-rings overnight to see how much of a vacuum could be achieved with the standard assembly, and a rough vacuum of <100 mTorr was achieved. There are numerous reasons as to why the vacuum chamber wasn’t able to reach the single digits of the mTorr range during this baseline test, such as the fact that the pressure gauge we used was powered by a cord rated for half of the required voltage to power the pressure gauge.

Vacuum Chamber O-ring Material Compatibility

Since incompatible Viton o-rings were included with the hardware kit for assembling the Ideal Vacuum chamber, Aflas is currently being considered as a possible replacement option, due to its compatibility and temperature rating. Extreme Viton could also be considered, as it’s also compatible, but for o-ring replacement testing, only Aflas materials have been ordered. Since the extra large o-rings that are used to seal the vacuum chamber plates themselves (not the feedthrough ports) are so specific in dimension that they would need to be custom-made, which is a costly to schedule and budget, Aflas cording with similar thickness was ordered and can be cut to size. Aflas o-rings for KF16 and KF25 fittings were also ordered from McMaster to eventually replace in the vacuum chamber. The efficiency of replacing the Viton seals with Aflas cording and slightly smaller Aflas o-rings has yet to be determined and tested.

Next Steps

• Replace incompatible Viton o-rings with Aflas o-rings to ensure compatibility and improve system reliability.

• Conduct a new baseline vacuum test using Aflas o-rings for comparison with initial tests conducted with Viton o-rings.

• Install a KF25 elbow-shaped connector to reduce the tubing bending radius and prevent stress on connections.

Future Improvements

• Design some type of stand below the vacuum chamber to incorporate additional space beneath it, allowing better accommodation of stiff tubing leading to the vacuum pump, if KF25 elbow connector still leaves a tight fit.

• Explore alternative compatible sealing solutions or materials to simplify the process of replacing the Viton o-rings, if the Aflas cording and current Aflas o-rings are insufficient in reaching vacuum specs.

• Optimize the vacuum chamber setup to ensure sustained performance at rough vacuum levels (<100 mTorr).

Precursor Delivery Storage

Motivation

Safe and efficient storage and handling of ALD precursors are critical to ensuring consistent thin-film deposition. An existing precursor storage solution for the specific requirements of Hacker Fab’s ALD machine doesn’t exist on the market, at least not at any reasonable price point. While other DIY ALD machines don’t include any housing for the precursor ampoules at all, and are simply attached to only the ALD valves and tubing themselves, those same DIY ALD machines normally don’t handle pyrophoric precursors. Since the Hacker Fab ALD Machine is for ITO deposition purposes, and the precursors aren’t as inert, designing a precursor delivery storage, which the gases can travel through, and be directly connected to an exhaust, is a good preventative measure to take (to minimize risk with possible combustion/flames).

Technical Requirements

• Storage Capacity: Holds the precursor manifold with three ALD valves and three gas ampoules. Potentially has room to store the mass flow controller at some point when incorporated:

• Inlets and outlets: Contains holes to attach proper fittings for an exhaust connection, carrier gas inlet, and a gas outlet.

• Materials: Made out of aluminum for precursor compatibility.

• Miscellaneous: Ampoules should be easy to access in order to for simpler replacement when necessary.

Design Process

The precursor storage design process began by defining the requirements for safely and efficiently housing three precursors, each with dedicated gas lines and secure connections to the vacuum chamber. Aluminum was selected as a precursor delivery storage material for its corrosion resistance and ease of machining, ensuring compatibility with the chemicals and the system's operational conditions.

The initial design concepts, shown below, were sketched to visualize how the ampoules would be held and integrated into the vacuum chamber setup. These sketches evolved into more detailed CAD models (shown below), created in SolidWorks, with a focus on designing for sheet metal fabrication, since that would be the most cost effective. The flat pattern designs incorporated fold lines for easy assembly, allowing the components to be cut using waterjet or manual machining methods.

Initial conceptual design sketches of the precursor delivery storage system

Initial CAD screenshots of the precursor delivery storage system assembly (left), and an example of one of the components from the assembly folded and unfolded (right)

Since the TechSpark makerspace's water jet was out of order, we considered outsourcing the water jetting for the sheet metal. An initial quote from Atomatic for waterjet cutting parts at $130 per piece (ridiculously overpriced) prompted a pivot to sourcing 5052 Aluminum sheet metal with a thickness of 0.05”, from McMaster-Carr, since 5052 Aluminum is an easy-to-bend metal. I was able to begin the fabrication and assembly process and complete fabrication of 3 components, leaving the door and manifold shelf to be fabricated and assembled next semester. Using the CAD designs as a rough guide, and adding a few extra inches in every direction to ensure there was enough space, I cut the sheet metal to size using either the shearer or the bandsaw. I then bent right angles where necessary using the bending machine at Techspark, and then holes were drilled and parts were riveted together manually using aluminum rivets. While this reduced costs drastically while maintaining functionality, the fabrication and assembly process (mainly the manual riveting) was extremely time consuming and physically exhausting.

Images of the fabrication and assembly process of the first few components of the storage assembly

Due to time constraints, we weren't able to complete the entire assembly, but believe that this is for the best, as I’m sure many design improvements will be implemented next semester. One example of this is for redesigning the shelf which holds the manifold and ampoules. Next semester’s ALD team should consider whether or not the heating block is either usable (we don’t know if it’s programmable currently), or if heating tape would suffice. Due to the heating block’s heft (it’s made out of solid metal), it would be beneficial to consider removing it if possible. Shown below are a few quick sketches of possible shelf redesigns depending on if the manifold’s heater block is incorporated or not.

Conceptual sketches displaying the various options for shelving manifold, ALD valves, and precursor ampoules

Next Steps

• Complete the remaining assembly for the precursor delivery storage system, addressing any precision or alignment issues from the manual fabrication process.

• Evaluate the usability and efficiency of the manifold's heating block in the current setup to determine its suitability for sustained operation.

• Investigate alternative heating solutions, such as heating tape, to replace the manifold's heating block if it proves impractical due to its weight or solid metal construction.

Future Improvements

• Refine the design for easier replication and modularity, considering lessons learned during manual fabrication.

• Reassess shelf configurations in the precursor storage system to accommodate potential design changes stemming from heating block decisions.

• Incorporate design elements that improve manufacturing precision and reduce the labor-intensive nature of assembly.

References

Z. Zhang et al., "Atomically Thin Indium-Tin-Oxide Transistors Enabled by Atomic Layer Deposition," in IEEE Transactions on Electron Devices, vol. 69, no. 1, pp. 231-236, Jan. 2022, doi: 10.1109/TED.2021.3129707.

For a description of what the team at CMU is working on in Spring 2025, check out !

To learn more about the hardware and software involved, refer:

Software

Probing the Chip

Connections

1. If not using the tester adapter, connect W2 to the Gate probe and W1 to the Drain probe.

2. The Source and Body probes must be connected to GND.

3. The +1 & -1 connections should be connected around the drain resistor.

4. +2 should be connected to the Drain terminal.

To-do:

Add images with the connections, more specifics.

• simple mechanical probe manipulator

• needs 4 probes (show where each of them are used)

• high level: we can relate all the process parameters to electrical characteristics

• all the tests we can do

  • what they tell us, how many probes needed, etc.

  • example pictures, resulting curves

• lots of great diagrams from Anirud, Icey, Ahmet, Joel working docs we can update with

Semiconductor Parameter Analyzer

Not all transistors are created equal. There is an immense amount of information within the electrical characteristics of the device that helps with optimizing the manufacturing process (Read Peter Van Zant Chapter 14). Below is an example of an ideal IV curve from a textbook, and the first IV curves taken in the Hacker Fab. While our curves aren’t perfect, they do exhibit transistor-like-characteristics 🙂.

IV curves are not the only tests that can be done with a parameter analyzer. With enough data, trends in these different curves can be directly associated with process parameters.

Probe stations are traditionally heavy desktop machines that hold probe manipulators. The purpose of the probe station itself is to precisely move the tungsten probe in order to make contact with the contacts of the device. This typically means moving 3 individual probes to the gate, source, and drain contacts, and another to contact bulk.

Probe Station + simple diagram of contact locations

These probes are attached to the back of the Semiconductor Parameter Analyzer - precision instruments consisting of multiple SMUs (Source Measure Units) and a built-in computer to control them and store readings. Source Measure Units are glorified power supplies with built-in voltmeters and ammeters - they are very precise instruments that are able to supply voltage or current through the probes, and simultaneously read voltage or current.

• get pure aluminum

• mixed with SI

• need thermal evaporator

Overview

The Hacker Fab database was built on the Django framework using Python, with HTML and CSS serving as the front-end. The code in this Github repository. The purpose of the database is to store data related to chip fabrication in our labs and use the results to refine our process parameters. It is crucial that we maintain a comprehensive and functional data store in order to develop new processes and to help new Hacker Fabs begin fabrication.

The database was created in Spring 2024 with the ability to create new chips, add process parameters to each chip, and query back results from the database. The front-end had simple styling, although they were not reflected in the production website due to issues with certification. The motivation for our improvements in Fall 2024 was increasing the intuitive usability of the website, as well as adding more functionality for the user. hi

Design Choices

Web Hosting Platform

The website hosting options up for consideration were Amazon Web Services (AWS), Google Cloud Platform (GCP), and Microsoft Azure. AWS was ultimately chosen because it had the longest free period and we had the most experience working with it. We use EC2 because it has the most flexible options and high availability in many geographic regions. The website is not very compute-heavy, so we chose a small instance to keep costs down.

Model/Schema Changes

The code has a model-view-controller (MVC) structure. Each fabrication process is described as a model (in models.py), with each field representing a process parameter or documentation artifact. This translates to each process being stored as a separate table within the database. This semester, the models were updated to constrain parameters to specific data types in order to maintain consistency and correctness in the database. For instance, temperature was stored as a decimal value, duration as a positive integer, and material type as a string. Some models and fields were renamed as well in order to clarify their meaning. We worked closely with the process development teams to understand which fields should be included or what new models should be added. Relevant Django documentation: Models

In order to allow the user to interface with the database, there are input and search forms based on the models (in forms.py). As of this semester, the input forms require certain parameters that are measurable and critical to the fabrication process, as well as prefilled default values for standardized parameters in our primary NMOS process. The search forms do not have any required fields, since we should be able to search process data for every chip and parameter value. This semester, the search forms were also updated with input fields that would provide users with the ability to perform searches given a specified range of values. The labels to these forms were also refined to be more readable and include units to aid in correct input. Relevant Django documentation: Forms based on models

User Interface

We identified that a non-intuitive workflow and lack of visual cohesion were affecting the usability of our website. One major change was the inclusion of “chip pages” that show every process done to a chip and eventually will allow for edits to the data associated with it. Previously, the only way to see that data was to search the database by chip number. This process was not intuitive because users are usually working with a single chip at a time, so it made more sense to have a centralized location to view that relevant information.

A change for the search page was the use of horizontal tables to display data for a process. In other words, for a single entry, each column represents a certain field in that entry, and each row is a distinct entry (previously, the first column was the field name, the second column was the value, and additional fields for a given entry were displayed in their own row). The horizontal table display makes it much easier for users to distinguish between different entries for chip information and process parameters. Furthermore, we modified the search page to display all filter categories to the user under an umbrella “Advanced Search” dropdown. This allows the user to see all the search options at once instead of having to submit a process. Lastly, to make it easier for users to interpret the data that is presented to them in the search page, we added functionality that allows users to group the search results either by the process types they have selected, or by the chip number.

The chip creation page will also have the option to use a “chip profile” or “chip default” that prefills parameter values associated with an established process, such as the NMOS process we use for class labs.

An important addition to the Patterning process in particular is the ability to add multiple patterns in the same step and click on a gray rectangle to approximately note the location of that pattern. This way, it is easier to record the application of multiple patterns at the same time as well as locate a specific pattern when returning to the chip.

Main Controller

The different web pages in our website are served by their own controller functions which are located in views.py. We designed the backend architecture to have a separate function that serves each unique web page. This design allows us to modularize our backend logic and isolate functionality to those specific pages so that they can be as customizable as possible. If similar logic is used across different web pages, we put this logic in helper functions to avoid having duplicated code. The different controller functions for each page serve the main functionality of our website. Routes between the addresses to these pages and the functions that serve them are specified in urls.py. The controller links the different HTML pages together, performs the database operations, and interfaces with the backend. It determines what form to display based on what process the user selected, saves the form data and passes it to the database after cleaning, displays search queries by the user, and renders the web pages.

Main Controller: Querying Data

As our website serves to display database entries to our users, a crucial functionality is querying data (related to process parameters and chip information) and rendering it on the page. These are the different pages where data querying is critical:

When a user performs a search for data, they can enter specific filters to narrow down their results. These filters are passed to our controller when the user fills out a search form filled with parameter values. In our controller, we use Django’s Q() objects from their database querying library to create and execute SQL queries. This simplifies the process of extracting data from our database since we just need to create a Q() object using the filters specified by the user then apply the filter on our models. This querying is done in the function filter_form(). Data querying is one of the most computationally intensive components of our database; hence, it can be considered as a bottleneck. Querying data for a single model (i.e. process type, user profile, etc.) has a worst case complexity of O(M), where M represents the number of rows that exist for a particular model in our database (the total number of unique entries of that model stored in our database). In the search page, the user is able to conduct a search to retrieve data from multiple process types. In this case, the worst case complexity for the search is O(P*M), where P represents the number of different processes the user has selected, and M represents the number of rows that exist for a particular model in our database.

The code in views.py is responsible for passing the data from the query result to the html files so that they can be displayed on the web page. There is an important detail that developers should take note of when implementing any functions that return queried results to users. We have implemented a specific data format to pass to the html page in order to standardize the design of the html pages and controller function outputs. When an html page is rendered, views.py provides it a context, which contains data (variables) that are required by or will be displayed in the html page. The html page expects the queried data provided in the context to be an array of arrays of dictionaries. Since Django’s querying library returns the queried data to us in the form of a QuerySet, we must convert the QuerySet into an array of dictionaries using Django’s model_to_dict() function found in their forms.models library. Each dictionary represents a single entry in the database. The keys correspond to the column names, which map to the corresponding value for that column. Each array of dictionaries within the outer array corresponds to a grouping of data. This enables us to group data based on the process types so that they can be displayed on the page with the correct column headers. This data structure is depicted below.

!!!!!!!!!!!!!!!!!!!!!!!!!! System architecture for interfacing with tools (the spincoater for now) !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

SEE this link for better formatting: https://docs.google.com/document/d/1SrD66bqmS1xxs2jt_WWSY7eLr6vyDJxIB4dbMdbxkws/edit?tab=t.0#heading=h.ai1m6262yla9

System Architecture

1. AWS Server Purpose: Centralized management of the job queue and storage of job-related data. Components: API Gateway: To handle incoming API requests from the Raspberry Pi and the primary web application. Lambda Functions (or EC2-based backend): Job Queue API: Handles enqueueing, dequeuing, and querying of jobs. Job Status API: Updates job status upon completion. DynamoDB (or RDS): Job Queue Table: Stores queued jobs with parameters, states (pending, in progress, completed), timestamps, and priority levels. Job Log Table: Stores historical job execution logs. S3: Optional for storing any job-related resources or output files.

2. Raspberry Pi Purpose: Acts as a client to fetch, run, and manage jobs locally. Major advantage of Raspberry PI: Runs full GUI linux distro that can directly connect to CMU WIFI or ethernet. Components: Job Fetching Service: Runs every 5 seconds (via a cron job or background service). Sends an API request to the AWS server to check for the next job. Receives and dequeues a job (if available). UI Module: Displays the job details on a connected screen. Allows the user to manually start the job or view progress. Supports initiating a new job via the UI. Job Execution Module: Sends job parameters to the microcontroller (spin coater controller for this semester) for execution. The Raspberry PI is physically connected to the spin coater microcontroller using jumper wires. This will replace the buttons that are currently used as input. Monitors job progress and completion. Job Completion Handler: Sends a POST request to the AWS server with job status and result details after execution.

Data Flow Job Creation: The primary way that jobs will be created is through the hacker fab website. The hacker fab website will call the appropriate API call to manage the jobs database. The implementation of this is out of the initial scope for my project. For testing purposes for this semester, I will use POSTMAN to send API calls to the AWS jobs database. Users can also create new jobs directly via the Raspberry Pi UI. This allows for redundancy in the case that the machine needs to be controlled without the database. There will be an option to run the job immediately or to send it to the database to be added to the queue. Job Queue Management: The AWS server maintains a centralized queue of jobs. The Raspberry Pi fetches and dequeues jobs by querying the API. Only jobs for the specific machine are dequeued. Job Execution: The Raspberry Pi receives the job and displays it on the connected UI. Upon user interaction (manual start) or automatically (if set), the job is run on the spin coater (or other device in the future) Job Completion: After execution, the Raspberry Pi sends the success/failure status to the AWS server, updating the job's record in the database.

Technical Details AWS Backend API Gateway Endpoints from AWS for raspberry PI: GET /jobs/next: Fetch the next job from the queue. POST /jobs/completion: Update job completion details. API Gateway Endpoints from AWS for web application: POST /jobs: Enqueue a new job. The request has the machine name, input parameters, priority. The response will have the job_id of the newly created job, or error. GET /jobs_by_id: The request includes the job_id(s) for which you will get details. All data for that row of the table will then be returned. NOTE: you can pass a list of job_ids to get multiple rows of data at the same time. GET /jobs_by_machine: The request includes the machine name. All jobs that are in the database (regardless of status) will be returned. Job Queue Table Schema: job_id (Primary Key) machine (the machine to run the job on. E.g. spin coater) status (Pending/In Progress/Completed/Failed) input_parameters (JSON for variable parameters) output_parameters (JSON for results from the machine) timestamp (Queued timestamp) priority (Optional for prioritized execution) Raspberry Pi Software Language: Python for compatibility with Pi and microcontroller communication. UI Framework: Tkinter. Lightweight GUI API Client: Fetches jobs and sends completion status using requests library. Microcontroller Interface This will vary significantly depending on the tool we are attempting to automate. This code will be modularized and will be one of the only things that will need to be modified when adding a new tool to the system. Job Execution Commands: Defined in a simple protocol (e.g., JSON commands). These commands are then parsed and used to control the microcontroller. For example, for the spin coater, the output from the I/O ports of the raspberry pi can be connected to where the buttons are on the spin coater microcontroller and simulate the button presses. There might also be an even simpler way to connect the raspberry pi to the spin coater microcontroller after talking to someone familiar with the spin coater.

Basic raspberry PI hardware setup:

Raspberry PI 5 with case and heatsink. Jumper wires connect GPIO pins to external device. See image attached.

To control the Raspberry PI 5 GPIO ports, use the gpiod python package (see screenshot below). It is critical to use gpiochip4.

AWS Configuration for jobs queue:

This is the jobs queue that the tools (right now only the spincoater) pull from. Jobs are enqueued from the primary web application.

The API gateway routes are configured as follows:

The dynamo DB is configured with default settings. job_id is the primary key.

The majority of the logic is in the lambda function. The python code is as follows (subject to change):

import boto3
import json
import uuid
import time
import logging
from decimal import Decimal

# Set up logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)

dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table("JobQueue")

def lambda_handler(event, context):
    """
    Handles API requests for different endpoints.
    """
    logger.info("Received event: %s", json.dumps(event, indent=2, default=decimal_serializer))

    # Extract HTTP method and route
    route = event.get("routeKey", "")
    method = event["requestContext"]["http"]["method"]
    body = json.loads(event.get("body", "{}"))  # Parse JSON body safely

    logger.info("Processing route: %s with method: %s", route, method)

    # Routing based on the request
    if route == "GET /jobs/next" and method == "GET":
        return get_next_job()
    elif route == "POST /job_completion" and method == "POST":   # Ensure correct endpoint
        return update_job_completion(body)
    elif route == "POST /jobs" and method == "POST":
        return enqueue_job(body)
    elif route == "GET /jobs_by_id" and method == "GET":
        return get_jobs_by_id(event)
    elif route == "GET /jobs_by_machine" and method == "GET":
        return get_jobs_by_machine(event)
    else:
        logger.warning("Invalid request received: %s", route)
        return {"statusCode": 400, "body": json.dumps({"message": "Invalid request"})}

# **Helper Function to Convert Decimal to Native Python Types**
def decimal_serializer(obj):
    if isinstance(obj, Decimal):
        return int(obj) if obj % 1 == 0 else float(obj)
    raise TypeError(f"Object of type {obj.__class__.__name__} is not JSON serializable")

# **1️⃣ Function to Update Job Completion (Completed or Failed)**
def update_job_completion(body):
    job_id = body.get("job_id", "-1")
    logger.info("Received job completion request: %s", body)

    # **Check if job_id is missing, invalid, or set to "-1"**
    if not job_id or not isinstance(job_id, str) or len(job_id) < 8 or job_id == "-1":
        logger.error("Invalid job_id received: %s", job_id)
        return {"statusCode": 400, "body": json.dumps({"message": "Invalid or missing job_id"})}

    # Retrieve the job from DynamoDB to verify it exists
    response = table.get_item(Key={"job_id": job_id})
    if "Item" not in response:
        logger.error("Job ID not found: %s", job_id)
        return {"statusCode": 410, "body": json.dumps({"message": f"Job ID {job_id} not found"})}

    output_parameters = body.get("output_parameters", {})
    status = body.get("status", "").capitalize()
 
    if status not in ["Completed", "Failed"]:
        logger.error("Invalid status received: %s", status)
        return {"statusCode": 400, "body": json.dumps({"message": "Invalid status, must be 'Completed' or 'Failed'"})}

    timestamp = int(time.time())
    table.update_item(
        Key={"job_id": job_id},
        UpdateExpression="SET #s = :s, output_parameters = :o, #t = :t",
        ExpressionAttributeNames={"#s": "status", "#t": "timestamp"},
        ExpressionAttributeValues={":s": status, ":o": output_parameters, ":t": timestamp}
    )

    logger.info("Job %s updated to %s", job_id, status)
    return {"statusCode": 200, "body": json.dumps({"message": f"Job {job_id} marked as {status}."})}

# **2️⃣ Function to Add a New Job**
def enqueue_job(body):
    job_id = str(uuid.uuid4())
    machine = body.get("machine", "unknown")
    input_parameters = body.get("input_parameters", {})
    priority = body.get("priority", 1)
    timestamp = int(time.time())
    logger.info("Adding new job with ID: %s", job_id)

    table.put_item(Item={
        "job_id": job_id,
        "machine": machine,
        "status": "Pending",
        "input_parameters": input_parameters,
        "output_parameters": {},
        "timestamp": timestamp,
        "priority": priority
    })

    return {"statusCode": 200, "body": json.dumps({"message": "Job added", "job_id": job_id})}

# **3️⃣ Function to Get the Next Pending Job and Mark It "In Progress", Then Return Updated Data**
def get_next_job():
    logger.info("Fetching next job from queue")
    response = table.scan(
        FilterExpression="#s = :s",
        ExpressionAttributeNames={"#s": "status"},
        ExpressionAttributeValues={":s": "Pending"}
    )

    jobs = response.get("Items", [])
    if not jobs:
        logger.warning("No pending jobs found")
        return {"statusCode": 404, "body": json.dumps({"message": "No pending jobs found"})}

    jobs.sort(key=lambda x: x.get("priority", 1), reverse=True)
    next_job = jobs[0]
    logger.info("Next job selected: %s", next_job["job_id"])

    table.update_item(
        Key={"job_id": next_job["job_id"]},
        UpdateExpression="SET #s = :s, #t = :t",
        ExpressionAttributeNames={"#s": "status", "#t": "timestamp"},
        ExpressionAttributeValues={":s": "In Progress", ":t": int(time.time())}
    )

    updated_job = table.get_item(Key={"job_id": next_job["job_id"]}).get("Item", {})
    logger.info("Updated job details: %s", updated_job)

    return {"statusCode": 200, "body": json.dumps(updated_job, default=decimal_serializer)}