DIY Plastic Recycler for 3d Printing Filament

Howdy Everyone! My name's Jacob Caillouet. I'm a Junior at Baton Rouge Magnet High School and recently I started having a problem~

I have too many failed 3D prints!

At first, I remedied this via sending tubs of failed print off to 3D printed waste recycling companies~

Yet it slowly became apparent that even this solution felt too wasteful- Between the truck's emissions, packaging, and unknown material losses- I couldn't bear the unknown. Even so, who was even buying these recycled rolls?

This train of thought brought me to a grand project idea! Why not close the sustainability loop myself? So, in this Instructable, I'm going to go through the process, design, code, construction, and underlying principles that made this project a reality for me

Just as a disclaimer- this is not going to be a weekend project, it will take you a while to get done~ not exactly sure how long but it will.

I figured I would place this entry into make it spin, as it emphasizes how screw extrusion, which makes use of rotational motion, is important in the extrusion of plastic granules in industrial/ hobbyist settings.

Many of the parts in this project are sourced from random machines that I have modified (yes, I save these components in a box and then use them when I have the chance, somewhat normal until you find the random hunks of metal and fried stepper motors), so they most likely won't even be for sale. It is for this reason that this Instructable will mostly lay the groundwork for the concepts, requirements, skills, and design that it would take to make such a project, supplemented by the example of my very own recycler.

That being said, underneath is a list of components that I used when making my recycler, read carefully, as it will most likely give you an idea of the components necessary for such a project:

KEY Parts:

1. 12V DC motor w. Hall Encoder ; Gear Reduction Motor, DC 12V High Geared Motor Reduction Motor with Encoder Srong Self Locking, Motor (20RPM): Amazon.com: Tools & Home Improvement I had bought the 30 RPM

1. 10mm to 6mm Flexible Shaft Coupling ; MECCANIXITY Aluminum Shaft Coupling 6mm to 10mm Flexible Spider Coupling L50mm x D40mm Coupler Jaw Spider Shaft Joint Connector for 3D Printers DIY Encoder CNC Router Milling Machine: Amazon.com: Industrial & Scientific (Side note, it was incredibly difficult to find a clamp shaft coupler that was actually the diameter listed, this one wasn't even 10mm, I had to widen the hole with a drill press from our school.)

1. 1/2" OD 5/8" ID Aluminum Pipe; No link for this one, Aluminum was a risky choice but I needed a metal I could process (I lack any access to welding equipment)

1. 5/8" OD Drill ; I don't have a link for this one, it was picked up @ a home depot and the packaging is lost to time.

1. 1/2" Silicon Wrapped Fiberglass Insulation ; Amazon.com: YAMAKATO 1/2" ID Heat Shielded Fire Thermo Armor Fire Sleeve Silicone Coated Fiberglass Heat Protection w/ 3 Clamps for Automotive Hose Lines & Electrical Wiring (Black, 5FT） : Automotive (Optimally grab something wider than this, it was a pain to attach

1. 1/2" OD Female NPT Brass Compression Fitting; 3 Pcs Brass Compression Union Connector, 1/2" Tube OD to 1/2" Female NPT Compression Tube Fitting for Oil, Gas, and Non-potable Water: Amazon.com: Industrial & Scientific (This was such a pain, Matching the threading on the nozzle and fitting was awful)

1. Filastruder 1/2" Male NPT Plastic Nozzle; Nozzle/Die - Filastruder (I had to contact Filastruder support to make sure this was the correct thread I heavily recommend this nozzle to virtually everyone attempting to complete a project like this, it was difficult to find an adequate nozzle anywhere but here.)

1. 3D Printer Heating Cartridges and Thermistors; Amazon.com: HzdaDeve Heat Cartridge Heating Tube 24V 40W Thermistor Temp Sensor for Flsun SR/QQ-S Pro/Q5 Hotend Kit Hot End Parts Print Head Replacement Extruder Upgraded Version PT100 Volcano 3D Printer (4 Pack) : Industrial & Scientific (while doing this project, I thought I could get away with running a few of these I had lying around as an alternative to a heating coil. I do NOT recommend this to anyone, I get very inconsistent heating and end up sucking 6.8A to run all four [It works, yet inefficiently])

1. L298N H Motor bridges ; Amazon.com: BOJACK L298N Motor DC Dual H-Bridge Motor Driver Controller Board Module Stepper for Arduino Intelligent Car Power UNO MEGA R3 Mega2560 with 4pcs : Electronics (I had around 4 of these lying around and considering they all had substantial heatsinks attached, I managed to use them for literally every actuator on this project, also not recommended, as I do use one to drive the stepper motor responsible for the tractoring of filament out of the nozzle- this means I lack the advanced logic capabilities of current stepper motor drivers and therefore A: Manually limit current not through Vref, but instead PWM switching of the H bridges. B: Lack micro stepping, making the whole stepper quite loud.

1. Arduino MEGA 2560 ; I shouldn't have to link this one
2. Raspberry PI Model 4 B

(In another life I would've used an ESP32 or some other microcontroller with an Analog to Digital Converter, PWM and higher data storage capabilities. I have a little knack for control theory, so after designing my control architecture to predict the plastic's temperature from simulation results; I had realized that the algorithm used [A combination of an LPV system & and Kalman Filter State prediction] went over the possible data storage by about 256% How I hadn't noticed this while designing is literally anyone's guess, I don't even know how I finished it before realizing.

None of what I said there had to actually make sense, A single Arduino board would probably work sufficiently with minimal control logic.)

1. A couple of these components are also just harvested from my FLSUN SR, more specifically the whole end tractor. The whole setup is literally the old extruder flipped on its side. I can't really give the components list for this thing because I'm not fully sure what's inside it. Y'all might have luck just purchasing your own 3D printer extruder for this section too.

Miscellaneous parts:

1. Like a bajillion jumper cables; I would probably recommend creating a PCB because of the bad hair day y'all witnessed on the cover there.

1. Two switch buttons/ Potentiometer; maybe not fully necessary yet they help with manual speed control of the stepper motor, in a later version will be done via PID controller variable speed traitoring to harbor consistent extrusion width. (That would also have to come with a true stepper driver for micro stepped smoothening.)

1. Lots of hobby resistors; I had to make quite a thick voltage divider to run the fan that blows on the Heater heatsinks

1. Fans for cooling; pretty straightforward. I am absolutely unable to provide a link for the one I used to cool the heater and dc motor H bridges, as it was gutted from my mini-PC after replacing the cooling.

1. PTFE Tubing; optimally in the ID of the filament you want to extrude, or wider if used for intake.

1. Wooden Plank; Used as a baseplate for all of the 3D printed mounts to slide together

1. 3D printer Filament TPU & PLA; TPU used to ensure flexible coupling, PLA used for structural doodads

1. PTFE tape

Tools:

1. Alan Wrench Set
2. Various Phillips Screwdrivers
3. Hot Glue Gun
4. High Heat - Heat Epoxy, I used some JB weld 550F epoxy
5. Multimeter
6. Soldering iron
7. Breadboard
8. 3D Printer, In my case an FLSUN SR
9. Calculator??
10. Digital Calipers for modelling
11. Needle Nose Tweezers for electronics
12. Wire Strippers
13. Lots of Coffee

There are plenty of different recycler designs to choose from, and many different plastics to recycle!

Take a moment to think about which requirements these plastics/recycling methods require!

For example, my project uses screw extrusion of tiny plastic shreds!

-> In screw extrusion, plastic is pushed along an ever-compressing screw- heated up so that the pellets start mushy from the heat, and then ultimately "liquified" by the heat generated from viscosity and friction!

(liquified in quotes as the plastic is pushed past glass transition temperature, yet probably left under melting in order to minimize thermal degradation)

I like how contraptions like this highlight the importance of rotary motion in manufacturing, like this mechanism does a job which on first glance would be most easily done with linear motion, now is modified to do so more cheaply through rotational mechanics!

There are plenty of other ways for this to be extruded, however screw extrusion is exceptionally important in almost all of plastics manufacturing! It's a clear demonstration of how rotational motion is used in industrial plastic settings- something like a piston or gantry push (which is also technically rotationally important) would produce uneven waves of plastic shooting out the nozzle, screw extrusion is able to provide consistent flow! Screw Extrusion really is the goat.

-> Some other types of homemade recyclers will use an empty bottle that is spun, cut, and pushed through an extruder to create filament (Listen I've done way less research into these cut me some slack)

Key Challenges:

1. As mentioned before, in order to minimize the plastic product lost while travelling through the extruder, research the type of plastic(s) you want to design this extruder for, look up the DTG (Digital Thermogravimetric analyzes material losses under heat) curves on each type of plastic you want to use and design for temperatures above the glass transition (i.e, where it begins to soften) yet below the melting temperature (complete liquidation)
2. Heating. Optimally use coil heaters you can wrap around the pipe itself in order to evenly heat the pipe
3. Don't worry about compression! Actual screw extrusion screws cost LOTS of money- you can easily opt to use a drill screw and simply crank up the heat!
4. Drill Torque. Pick a motor that's capable of spinning that drill with adequate torque to push all plastic out of the way- preferably a gear motor as it's easy to make a small motor spin fast and then mechanically reduce in preference of torque
5. Curiously, Drill Concentric(icity?). Likely, your drill may not be completely concentric on the coupler or not completely aligned to the shaft when mounted. How do you get around this? Flexible coupling! more in the example on this.
6. More on Material Quality. Random, non-plastic particulates can and probably will invade your plastic melt. introducing impurities like these into your plastic drastically reduces lifespan of your recycled material, and to counteract this, you may need a filter to weed out certain particulates.

This step is not completely necessary, however, when carrying out my own projects I like to create a simulated model of my setup that can be used to analyze energy flows, potential faults, model strengths, and moving renders of the end product in action

To do so, I tend to use MATLAB and Simulink (more specifically SimScape) to create a simulated model of my plant, the environment also significantly assists in the design of control architecture and debugging on actual hardware.

After spending a day getting the energy flows just right and inserting real parameters the model began to behave like the real system-

A secondary goal with this approach for me was to use a linearized version of the model at different points to create an LPV system -> Doing so would let me feed said data into a Kalman filter, which will be used to filter the thermistor data in addition to predicting the temperature of the plastic melt for better control over thermal degradation.

Now here, I'll go through the process I used to create my screw extrusion (extruder?)

For starters, I decided to go with PLA- seeing as it was biodegradable, I didn't see much of an issue putting it through so much heating

I started by building a CAD model of the extruder in Inventor Professional, visualizing how the part would come together is the most important step.

In the picture above, I created reference geometry of the Aluminum pipe, Brass Nozzle, Compression Fitting, Drill, 12V DC Motor, Coupler, and PFTE I intended to use as an entry chute.

Knowing How everything came together helped me imagine how I'd mount everything and enunciated certain design issues/ requirements. In my case, I had to determine how I'd keep the motor and tube at an appropriate distance as to not drill at the nozzle, how to prevent nonconcentric rotations from tearing away at the tube, and how to properly level each component.

In the end, I came up with the design above, Key features include:

1. Flexible compression shaft coupler to reduce issues of rotational misalignment

1. Flexible TPU tube to PLA mount to reduce issues of translational misalignment

In tandem, those two will minimize any shaft misalignment from letting the drill grind away at the aluminum tube

1. Adequate PLA spacer helping to thermally isolate the coupler and tube, the spacer also doubles as a mount to hold the PTFE Tubes I plan to use as a hopper system

1. PLA Tube Mount to restrict the movement of the TPU mount & provide drill holes to insert screws and rigidly attach to a wooden baseplate

1. PLA Motor Mount which slots into the Tube Mount allowing for proper spacing (with the coupler spacer) and rigid mounting of the motor.

Before I could 3D print these parts, I first had to assemble the components like those in the reference geometry photo, doing so required some more creative thinking:

Most of that thinking had already been done with the parts selection, so It wasn't thaat hard.

1. I started by cutting down the aluminum to the correct length specified in the reference geometry, I then added an arc like slot to have an opening for the hopper, and then finally furbished the brass compression coupling - to really make sure it had a good seal, I even applied heat epoxy to the clamp to make sure nothing would leak.
2. Next, I took the flexible coupling and used a drill press to resize the 10mm hole as perpendicular to the surface as possible (and widen as it was not manufactured to the listed size)
3. Screwing the drill and motor's shafts together wasn't at all too difficult
4. Now for the risky part, the OD of my tube is roughly 1/2". (I do not recommend this size, pick something closer to the filastruder nozzle die) and the OD of the pipe insulation was mistakenly, also 1/2". I wrap the insulation around the whole pipe; I opted to 3D print a conical plastic sleeve I could ram up the insulation tube with the pipe inside. I would then slowly pull the pipe out of the sleeve and push the insulation down as it went, the insulation would quickly snap down to the 1/2" size, and wrap snugly around the pipe and compression fitting. I wanted to double layer, but the second piece tore so I wrapped the whole thing in PTFE tape to keep it together.

With Parts together, I could safely begin to 3D print the associated mounts and couplings.

Roughly (1hr, 30 mins later), I was able to assemble these beautiful Parts into the semi-finished Extruder.

semi finished? What's missing?

Electronics!

Electricity is the magic that'll turn this little gizmo into a plastic extruding behemoth!

With the Mechanical Construction done, I had to begin work on the motor / heater logic, and this is where my inner nerd shall truly shine.

------ MOTOR LOGIC -------------------------------

The first part of this setup that must be connected is the 12V DC motor responsible for rotating the drill and moving the plastic granules.

To do so I first whipped up a mount that could slot the Arduino and L298N double H bridge motor drivers, letting me wire the components together with a degree of organization

Ultimately, the Motor Control plan was to use the incremental hall encoder to gauge rotor speed in RPM. I would then feed this back to a PID controller which would spit out the PWM voltage to a pin connected to the H bridge. Because I never intended to run said motor in reverse, the other pin for the driver would be connected to ground, guaranteeing zero input.

What does that mean though? Lets define some vocabulary:

1. Rotor; Rotating part of the motor

1. PID Control; Proportional Integral Derivative control, in essence it is a formula that allows for control of a plant (real world thing being actuated on, I.E, a motor controlling a robot, robot is the plant) with one measurement to create a desired output, minimal knowledge on how the plant converts one to another (A classic example could be well, a motor. by measuring the incremental pulses of the encoder [measurement] and determining the motor's rpm from that- we can then find the difference between the desired target and the current measurement, by feeding said data into the PID controller we can tune the controller parameters [kP, kI, and kD -> think konstant, Proportional/Integral/Derivative]

1. H Bridge; a collection of MOSFETS (Metal Oxide Semi-Conductor Field Effect Transistors) which is a fancy way to say an electronically activated switch controlled through voltage, the H bridge gets it's name because it's a set of four connected in an H like orientation, which allows for components in the middle of the H to have voltage driven from both directions (allowing for a dc motor to run both ways) (the L298N is an H bridge [yet technically it's two])

1. PWM; Pulse width modulation. Basically, rather than finding out a way to change the voltage out through analog means (i.e an electrically actuated potentiometer) we send a square wave of voltage up and down but like really quickly, effectively making the voltage the mean of the blank full square waves over time.

First order of business here was to screw down the H bridge; I wired in the power from my 24V supply, connected Logic pins, and then (tried) to organize cables.

-- in this case I connected logic pins IN1 and IN2 to the board (arbitrarily grounding one) and supplied the 12V+ supply joint to the V+ prong on the supply.

But Jacob? Why supply 24V to a motor with a 12V rating? Thank you for observing, on the code end of the project we limit the PWM pulse to 50% of logic voltage, ensuring that only half of the supply's voltage reaches the motor at any given time!

Next up was the hall effect encoder;

In it's most basic form, a hall effect *sensor* senses magnetic fields and emits a digital output voltage when one is nearby, by creating a magnetic wheel with sections magnetized permanently and others not at all, we can achieve the same effect as a mechanical quadrature encoder with less friction and slotting!

1. Quadrature; 4X resolution encoder, achieved via two wires which effectively sense the ups and downs of each encoder slot, interperting this information in the code allows us to either count rising pulses on one end (1X resolution), rising on both sensors (2X resolution) or rising and falling on both sensors (4X resolution). the two sensors should be out of phase by 90* when encoder is rotated.

Hooking it up was also quite easy, encoder power was delivered by passing a 5V supply from the Arduino board into the positive terminal of the encoder (yes, hall effect sensors are polar 🫢) and then hooking the negative terminal to ground. Next up were the signal pins. each one would pulse a square wave each time a magnetized slot passed over its respective sensor- determine which phase is phase A and phase B (by observing which phase overlaps first in clockwise/counterclockwise rotation. The signal pins must be connected to the boards hardware interrupt pins. The Arduino has only one core, making it unable to handle multithreading/simultaneous computation-> The interrupt pins allow the Arduino to handle code for them during digital input regardless of the main Arduino rate, making them optimal in ensuring the encoders do not miss steps.

Now for the programming. We need to read the RPM of the encoder, and to do such a thing we can use a simple conversion factor.

If we know our pulses per revolution, then we can derive that into rotations, if we know the time between two function calls of rpm (which should be running in the background constantly) we can determine the pulses per second.

Knowing pulses per second makes this nothing but a unit conversion (see photo above [I'm so sorry y'all, I just realized it was missing, I have added it now.])

(you will probably take seconds passed through micros() or millis(), knowing this, incorporate the conversion to seconds as well, along with gear ratios in case you want output shaft RPM)

With RPM in hand, we can go down the command line, now we find the error from our desired RPM and our current RPM, knowing this- we can feed this data into our PID controller. In my case, I tuned mine to output a 0 12000 mV signal, ultimately this became pointless in a later portion of the project. (Tune your controllers for 0 to 255 uint8 signal 💔)

Next we just sent this data (after linearly interpolating [map()] down to 0 - 127 <-member' cuz of thuh 24V supp🌾) to a PWM signal and we were able to hold stable RPM!

Tuning a PID controller allows for lots of robust(ness?) in output, remember how we mounted the tube and shafts using flexible coupling? to allow the pipe and shaft to sway along with the non-concentric shaft? While a mechanical solution like this does alleviate a lot of the issues, it will still leave spots during that rotation that require a little higher push than others. PID is a feedback controller, using previous states to help determine new ones. If we were to use a feedforward controller (NO feedback) then that may just look like sending constant voltages to the motor, changed by an operator through intuition on the system) The feedback portion allows the controller to act autonomously w/o operator intervention and maintain a (mostly) constant target. (unless we change the desired target mid run but dur)

That's all fine and dandy, motor control done, now for heating!

-------HEATING CONTROL ---------

The setup here is mostly the same, albeit slight differences

This section will also most likely be much shorter, as much of the concepts were explained in the previous section

Wiring;

Easy enough, for heating, and consequently temperature sensing, I opted to use standard 3D printer heating elements and thermistors

** DISCLAIMER** PLEASE DO NOT BE LIKE ME, I hooked up my heating elements mistakenly in the same way as the motor, limiting output at 12V instead of 24V- I realized I had done this like yesterday, and I do NOT have time to fix it, as it would require creating new mounts for another L298N (or simply hooking up independent MOSFET's)********************************************************************

An H bridge was absolutely NOT necessary for ANY of these components, I simply used them because of the pre-attached heatsink, optimized PWM handling, and screw holes. I literally just had these lying about. Also the rest of this step will be written under the guise that my supply is 12V, because of the previously mentioned screw-up

Using the second L298N I hooked up two heating elements to each output. The current limit on each output is ~2A and at max Voltage(12not24) each heating element sucks up roughly 0.85A, which makes it barely appropriate to attach 2 on each channel

-> We connect positive to 1 motor channel, and then negative to the other (as if there's polarity on these things 🙄)

-> To connect logic pins, one pin (per channel) is connected to a PWM on the Arduino, the other logic pin is connected to Arduino ground.

Now for Thermistors

A thermistor is nothing more than a resistor which changes in resistance as temperature increases

Thermistors can either increase or decrease in resistance whilst temperature changes- the technical doodad stuff doesn't matter right now. For now, we need a way to measure the voltage from an analog pin on the board.

The MEGA2650 I'm using has a 3.3V and 5V output, for this, we'll use the 3.3V as it's more regulated.

To determine voltage on an analog pin, we're going to create a voltage divider circuit, 3.3V will run to and through the thermistor, which will then link to an analog pin on the board, and simultaneously feed into a fixed resistance resistor, down to ground. (This is done b/c we can't just feed the 3.3V straight to A0 though the thermistor, as the current would have nowhere to go)

I'll explain how using this setup will allow us to measure temperature in the programming section.

Programming;

Simple enough for the heater, just PWM when we want to change how we heat.

For the thermistor, we first need to do some math:

analogRead(); gives us a value from 0 to 1023, the voltage divider + Thermistor causes the voltage at our analog pin to fluctuate based off of a combination of the thermistor and fixed resistor.

Overview | Thermistor | Adafruit Learning System

[aV is the analog read value, 0 - 1023]

In essence deriving the formula leaves us with this: ohms = (aV * Known ) / (Supp - aV);

this means we don't have to even know the exact input voltage to gauge ohms.

A second formula is then needed to map resistance to temperature.

A picture linked above shows an exponential relationship to temperature and resistance, so, using the following formula that link can be made:

(yes this is just my ripped code, no it will probably not work for your device.)

Note that this outputs temperature in KELVINS [K]

Beta = 3950;

FixedR = 100000;

Ambient = 298.15

Rinf = FixedR*e^(-Beta/Ambient); [e, the natural number, to the power of -Beta/298.15

T = Beta/(ln(Ohms/Rinf)); [ln, natural log]

Your Fixed Resistance should be close to the ambient temperature resistance of the thermistor.

Ambient should also be in [K]

Beta is often found on the thermistors manufacturing sheet.

Okay, sweet, we have temperature now. This means we can plug it straight into a PID controller and regulate temperature at our thermistors right? Right! Yet mine did this process a little differently.

------- Plastic Melt Prediction -------

Okay I'm about to throw a lot of words at you, but basically; I was able to discretize the simulated model of our plant (SimScape creates a network of differential equations, something that isn't exactly normally solvable on an Arduino) by Linearizing [Linear model in that it follows superposition principle; the system is time invariant and summated inputs equal the same output as the independent input's respective outputs summated. Linearizing causes the model to lose a lot of the behavior, specifically in thermal transfers. To solve this we take multiple linearized points in the model and then interpolate between each models "states". For clarification, a linearized model is an LTI, Linear Time Invariant System~ an LTI is in the state space representation which holds A,B,C and D matricies (With A defining certain model characteristics). A full explanation of state space isn't completely necessary, so I've tried to inform you of some vocabulary. Taking these interpolated states we can feed them (the whole LPV model) into the Kalman filter. Kalman filter is a state space filter which in essence refines the judgement of a state space model based off of inputted measurements. By creating an LPV of our simulated model~ we could then feed in measurements on certain states to refine the judgement on all other states, ultimately resulting in an algorithm to predict the Temperature of our plastic (A state inside the LPV) from the measurements of our system (Technically LPV output) and inputs (In this case controller voltages)

this didn't really work ☹️

I'm in too deep to back out now but y'all should just regulate temperature based off of multiple thermistors in multiple locations and keep barrel temp consistent throughout.

-----COOLANT FAN------

Last minute addition but I also used this tiny little fan gutted from my mini PC a while ago to cool the L298N H bridges, especially the one with both heaters attached. Optimally you should space one heater out to one chip at a time, to help with spreading the heat out.

For this I voltage divided down to 5V 0.15A on the additional channel from the Drill Motor H bridge

Then hooked logic pins up, one to ground, other one to a digital output.

----------ARDUINO->RASPI->ARDU|NO UART SERIAL COMMUNICATION----------

Most likely a non necessary step.

Going back to the Plastic Prediction, an Algorithm like that was unable to fit on the Arduino's EEPROM, forcing me to get creative.

Thinking fast, I borrowed a RASPI model 4 B from a friend and started work getting the two devices to communicate to one another over serial.

The idea was to have the Arduino be the IO of the system, handling actuators, analog to digital conversion etc. The Raspi would communicate with the Arduino over serial, and behave like the brains. I didn't feel comfortable creating a mount for the Raspi considering I didn't actually own it, so none was ever made.

This took longer than expected, Simulink handles UART streams in chunks of data, not packets- so while I encrypted my data over protocol, the Serial Out would only send the first half of the newly encrypted data and then splice in the latter half of the previous sent. In other words, the writes and reads did not match up properly, and this was difficult to catch. Once I did, all it took was creating a packet buffer, which would parse data over the previous few sends together into completed packets to then be decoded.

Now that you have your extruder done, in one way or another, you need a way to take the melted filament from the nozzle die and keep it a consistent length, relative to that of your standard filament of choice.

There are a variety of ways to do this, however, a common Industry method sends the filament across a length of some sort of cooling structure- that being fans or water cooling, whatever floats your boat 😀

The filament at the end of such a tube should be firm yet mushy, this Plastic Mush should be able to be pulled like taffy. The Plastic Mush is then often stretched by a specially controlled tractor which will wind the filament faster or slower to maintain a consistent extruded width.

Most of the emphasis was placed on the extruder thus far, and that's because it's undoubtedly the most important in our system.

This section will be brief; detailing how the resulted Plastic Melt is cooled to mush and shaped to a consistent diameter.

----- CONSTRUCTION--------------------------------------------------------

The typical tractor approach was not available to me, so I had to improvise. Considering the deadline for this project (Jan 14th) was approaching soon I had to make something quite unremarkable.

Rather than measuring the diameter of the extruded filament I instead sent it through a tube of PFTE which was roughly the desired diameter, I then drilled clip mounts for the PTFE to slot into and then feed straight into a recycled 3D printer extruder.

The extruder was ripped from the old Bowden tube system on my FLSUN SR and I saved the whole assembly for a use case such as this.

I also created a new mount for another L298N H bridge.

-> Using an H bridge is not a recommended method. This leaves very barebones stepper control compared to a real stepper motor driver, not only am I not allowed to micro step, I also end up manually voltage (and by extension, current) limiting the stepper using the same PWM trick I used on the DC motor, only this time it's very wasteful as I have to spend a whopping FOUR PWM pins to drive one stepper. But You know what I said, I js have them lying around 🥲

----- WIRING ------------------------------------------------------------------

Somewhat described above, I originally intended to have fans blow on the PTFE guide to encourage more heat transfer, but I didn't have any lying around and I was running out of time 🥲🥲🥲🥲🥲

Power to the L298N was driven as per usual, and all logic pins were signaled via PWM to prevent current overflows on the respective channels. The outs on each channel were then connected back to the phase pins on the stepper.

I also set up two push buttons onto digital input pins on input pullup to act like clicker buttons for manually adjusting stepper speed.

------ CODING ------------------------------------------------------------------

When I mean barebones, I mean BAREBONES, these sections aren't even allotted to full steps because of how quick they were in comparison.

Absolutely nothing special. I configured the basic Arduino Stepper library to interact with Simulink code generation and modified the library to be non-blocking.

I then ran the command to step constantly, however step itself would only progress if enough time had passed since the previous step to maintain an RPM.

Said RPM is incremented or decremented by a button on the small breadboard.

Either you were just following along with my example, or you learned a thing/two about the process of extruding 3D printer filament, I'm just glad you stopped by and gave this a read!

Oh hey, one more thing:

You may be wondering, how do I even get my prints into tiny granules like that could fit into a recycler like this?

I took inspiration from this instructable Low Cost Plastic Shredder : 6 Steps (with Pictures) - Instructables made by joshmt2012. I hope you take a look!

This final step is a note for the judges whom have to sift through ~30 entries.

I'm not entirely sure if it'd be rude to point out some of the recycler's features and how'd they provide merit to different contest requirements, but I'd like to do so to try and present this project it its fullest extent.

1: Make It Spin.

I believe this Project/Instructable follows the contest's requirements because it places an emphasis on how rotary motion is essential in manufacturing processes/recycling

2: Sustainability.

The project was thought up of, created for, and presented in a way to attempt and reduce the wastes generated from 3D printing. Moreover, it is a tool created to ensure the sustainable creation of all other 3D printed crafts!

3: Autodesk software involvement

Inventor professional was used for this project on an educational license.

It was exclusively used to model, conceptualize, and render models to 3D print.