Arduino-Controlled 3D Printer Enclosure.

Arduino-Controlled 3D Printer Enclosure is a student engineering portfolio project documenting a temperature-responsive fan-control prototype for a 3D printer enclosure, followed by an independent SolidWorks extension to package the controller electronics. The project combines Arduino firmware, analog temperature sensing, MOSFET-switched fan actuation, a user-adjustable temperature threshold, a status display, and mechanical design documentation.

Project author and electrical lead: Youngbin Myung (Western University). The original thermal-control prototype was a group project (January–April 2025); the later SolidWorks electronics-enclosure work was an independent extension (2026). The two phases are distinguished throughout this page.

Source repository: Arduino-Controlled-3D-Printer-Enclosure on GitHub

The original 2025 group-built electrical prototype has two linked items of visual evidence:

• Photograph of the physical electrical prototype — a photograph hosted with the GitHub project, showing the group-phase electrical hardware rather than the later 2026 SolidWorks housing.
• Video: working-system demonstration — the demonstration recording linked in the repository. This video is externally hosted.

These records supplement the original firmware and circuit diagram as evidence of physical electrical integration and qualitative system operation. They are not a substitute for calibrated temperature-response measurements, repeated trials, or measured fan-speed data.

The original team project explored automatic control of the temperature inside a 3D printer enclosure. Rather than relying on a fixed fan command, the Arduino monitors the enclosure temperature, compares it with a user-adjustable threshold, and changes the fan command in response. The objective was to integrate a sensor, microcontroller, switching circuit, user input, and monitoring interface into a functioning electromechanical prototype.

The later independent work addressed a separate mechanical-design question: how the controller hardware could be packaged in a serviceable electronics enclosure with access to connections, a removable lid, and drawings that communicate the intended assembly. The CAD enclosure houses the controller hardware; the LM35 sensing location and cooling fans belong to the main printer enclosure. These should not be confused.

This page is a technical record of the documented work, not a claim of certified temperature accuracy, print-quality improvement, fume extraction effectiveness, or a production-ready device.

The documented signal path is:

1. The LM35 measures temperature associated with the main printer enclosure and sends its analog output to Arduino A0.
2. A 10 kΩ potentiometer provides an adjustable temperature threshold to Arduino A1.
3. The Arduino averages the analog readings and computes a target PWM fan command from the relationship between measured temperature and the selected threshold.
4. Arduino pin D3 commands an N-channel MOSFET, which switches the external DC fan load.
5. The LCD and serial interface report temperature, selected threshold, and commanded fan percentage.

Circuit reference: Tinkercad schematic. The schematic uses a TMP36 symbol as a visual stand-in; the repository identifies the actual documented sensor as an LM35. The two parts must not be treated as interchangeable without checking their electrical characteristics and conversion equations.

Circuit illustration (GitHub): View the Tinkercad schematic. The electrical schematic is linked rather than displayed as a local Appropedia file.

Figure source: GitHub circuit illustration. This is not an independently verified electrical safety drawing.

The original controller code is available as fan_controller.ino. Its documented behavior is summarized here rather than reproducing the entire listing.

• The LM35 temperature input at A0 and the potentiometer input at A1 are each averaged over 20 ADC samples.
• The potentiometer sets a temperature threshold across 25–40 °C.
• At or below the selected threshold, the target fan command is zero.
• Above the threshold, the target fan command increases over the next 10 °C; the active command is constrained within the documented 80–255 PWM range.
• A smoothing accumulator with a documented coefficient of 0.1 is applied before rounding the command for analogWrite().
• The LCD and 9600-baud serial monitor display measured temperature, threshold, and commanded fan percentage.

The software is a threshold-based variable-speed controller, not a PID controller. The output percentage represents the commanded PWM level, not measured fan speed. The system does not include documented RPM feedback or a quantitative closed-loop thermal-response characterization.

• Arduino sketch
• Control-logic notes
• Engineering design decisions

The following is a functional component summary, not a verified purchasing list. Exact component models, quantities, ratings, and any retained pricing should be checked against the repository bill of materials and the hardware notes before attempting reproduction.

Component-list illustration (GitHub): View the Tinkercad component list. Verify actual parts, quantities and ratings against the repository bill of materials.

Component source: GitHub component list.

Reproduction note: Verify the fan supply voltage and current, MOSFET suitability, grounding, connector ratings, sensor pinout, and protective provisions before powering a physical build. Do not assume that the Arduino I/O pin can supply fan power. The repository does not establish this page as an independently verified electrical safety or manufacturing guide.

After the group prototype, Youngbin independently modelled an electronics/control enclosure in SolidWorks. This was not part of the 2025 group deliverable. Its documented design characteristics include:

• Base envelope approximately 120 × 85 × 35 mm, with approximately 2.5 mm walls and R3 external corner treatment.
• Mounting bosses/standoffs and space for an Arduino Uno R3-style controller reference model.
• Access provisions for USB-B, power, and routed sensor/fan cabling.
• A guided sliding lid using rail/groove geometry, rather than a claimed snap-fit.
• Lid dimensions approximately 116 × 80.5 × 1.6 mm, with a front pull feature and rear travel-limiting geometry.
• Separate OPEN and CLOSED assembly configurations using configuration-specific mates, plus an exploded assembly view.

The Arduino model included in the CAD assembly is a packaging reference, and its original source/license is not established in the repository. No authorship claim is made for that reference model.

Mechanical reference materials:

• Mechanical design notes
• Native SolidWorks part and assembly files
• SolidWorks images

Three retained drawing sets document the planned parts and assembly:

The repository retains the native SolidWorks drawings and browser-viewable PDF exports. See the drawing index for source and export filenames.

Design status: These are CAD and drawing deliverables. Physical fabrication, connector fit checks, lid clearance verification, manufacturing tolerances, and production readiness are not demonstrated by the retained evidence. In particular, no specific GD&T scheme, material selection, surface finish, or validated production tolerances are claimed.

The lead image at the top of this page shows the closed configuration: a control-electronics enclosure with the sliding lid seated and front connector cutouts visible. The four additional views below show how the lid and base interact. The screenshots represent CAD design, not photographs of fabricated hardware.

• 2026 independent SolidWorks electronics-enclosure design
• 
  Open configuration: the lid slides outward along guides, exposing the controller
• 
  Exploded assembly: Arduino Uno reference, enclosure base, and separate sliding lid
• 
  Base: mounting bosses, connector openings, cable pass-through, and lid guides
• 
  Lid: the flat sliding panel and its front pull feature

Original SolidWorks screenshots: GitHub image folder. The Arduino board is a CAD packaging reference, not a claim of authorship of the board model.

The original electrical prototype was operated and observed during integration and troubleshooting. Retained evidence includes the Arduino sketch, circuit illustration, component references, a prototype photograph, and a working-system demonstration.

Prototype evidence: The physical-prototype photograph and demonstration video are linked near the top of the page. They are externally hosted rather than uploaded to Appropedia.

• Source repository and project overview
• Circuit illustration
• Hosted prototype photograph
• Working-system demonstration
• Testing and limitations notes

• Implementation of an Arduino program with analog input sampling and PWM fan commands.
• Electrical/sensor integration and qualitative operation of the prototype.
• Use of local and serial feedback to observe values while troubleshooting.
• Creation of independent mechanical CAD, assembly representations, and drawing exports.

• A retained calibration or independently verified temperature-accuracy dataset.
• Controlled thermal-response measurements or quantified temperature stability.
• Fan RPM feedback, airflow performance, or ventilation effectiveness.
• Experimental repeatability or statistical uncertainty results.
• Fabrication and physical fit validation of the 2026 electronics enclosure.

Accordingly, this page makes no quantitative performance or safety claims. This distinction is important for anyone considering adaptation or replication of the design.

The steps below are a recommended workflow derived from the documented architecture, not a claim that a complete step-by-step build protocol has already been experimentally verified.

1. Review the Arduino sketch, circuit illustration, hardware notes, and component bill of materials together.
2. Confirm the physical LM35 pinout and the supply/reference assumptions in the firmware. Do not wire according to the substitute TMP36 picture without correction.
3. Select a suitable independently powered fan and appropriately rated MOSFET/driver, using a common electrical reference as required by the actual circuit.
4. Connect the potentiometer, sensor, status display, and fan driver according to a verified schematic. Perform continuity and power checks before applying power.
5. Upload the firmware to a compatible Arduino Uno using the Arduino IDE; review its library requirements in the actual source file.
6. Use serial and LCD outputs to inspect temperature and threshold readings. Check that fan command changes in the expected direction when measured temperature crosses the threshold.
7. Before relying on the system, compare the temperature readings against a reference instrument and log repeated temperature/time trials.
8. If fabricating the independent CAD enclosure, verify board mounting, connector access, thermal management, cable routing, and sliding-lid clearance using measured physical components.

The most valuable next steps are to obtain a temperature calibration dataset, measure temperature-versus-time with repeatable initial conditions, record commanded PWM alongside actual fan behavior, and compare trial-to-trial variability. On the mechanical side, fabricating the enclosure and recording measured fit/clearance results would turn the existing CAD package into a validated prototype.

Any future release intended for community replication should also include verified electrical power specifications, a complete parts/cost table, photographs of assembly steps, an explicit licensing statement for files that may be reused, and attribution for original group work and third-party CAD assets.

Phase 1: Original multidisciplinary group project, January–April 2025. Youngbin Myung served as Electrical Lead; this page does not claim sole authorship of the complete group project.

Phase 2: Independent SolidWorks electronics-packaging and drawing extension, 2026. The Arduino reference CAD model incorporated into the assembly is not represented as original work.

Repository: Complete GitHub portfolio and files

Image attribution: The five CAD screenshots document Youngbin's independently developed 2026 enclosure geometry. An Arduino Uno reference model is shown in some assemblies; its model source and license have not been established, so its authorship is not claimed. The linked 2025 circuit illustration and prototype photo relate to group work and are not included in the image package. Verify rights and permissions before uploading collaborative or third-party imagery.

Licensing note: Public visibility of a GitHub repository is not itself a grant of an open-source reuse license. Before redistributing CAD models, group photographs, or third-party materials on Appropedia, verify ownership, permission, and any applicable license terms. The text of this Appropedia page is distinct from the licensing of the linked source assets.

• Arduino
• 3D printing
• Open source hardware