Sometimes it’s difficult to sort through the ocean of sellers on Aliexpress to find a trustworthy store with good prices.
I buy and use quite a lot of fabric gift bags, and this is the best seller I have found so far for consistently low prices on good quality bags in bulk. They actually respond to messages, and ship with tracked e-packet. They don’t sponsor me in any way, I just use affiliate links. Hopefully this helps you save some money if you have a project coming up and need a lot of bags.
This is a simple Excel dollar cost averaging table for managing crypto and other trades, feel free to use it if you find it helpful.
You can use this table to track your trades, and it will automatically calculate your average purchase price as well as minimum sale price in order to take profit.
Enter your tokens in the left column, followed by the quantity you purchased and the cost per unit. The table will calculate your total purchase price and DCA, outputting everything at the bottom right. You can easily modify the formulas to adjust fee percentages, etc.
Simple Arduino Temperature, Moisture and Light Monitor
Recently I planted some succulent seeds indoors, and had to put them in a miniature greenhouse so that they could sprout. I wanted a way to keep an eye on the temperature, moisture and ambient light in the greenhouse, so I whipped this up. It outputs realtime measurements to an LCD. If you’ve seen my ProGrow project, this is a simplified version without any data storage or relays.
Parts
I used an old scrap 3D print for the frame; it’s just a block of plastic that I screwed everything to. The electronic parts used are:
A quick overview of each component and why I’m using it:
Arduino Nano
Extremely low cost (<$3)
Ready to go ATMega328p board with voltage regulators and USB
Lots of expansion opportunities
Arduino Expansion Board
Makes life easier for prototyping/wiring with the Nano
FC-113 + 16×2 LCD
Cheap and easy to use LCD combo
Only requires two analog pins for communication, easy to set up
Photoresistor module
Works just like a photoresistor with an analog signal, but it also has a digital output
Has an indicator LED and potentiometer for the digital output
DHT11 Temperature/Humidity Module
Very cheap, easy to use and decently accurate
DHT22 is a better version with higher accuracy, but is more expensive
BME280 is far superior to DHT11/DHT22, but is more expensive
Connecting everything to the Arduino
The DHT11 module has 4 pins, but only three are used:
Vcc to +5V
Signal to Digital Pin 5
Gnd to Gnd
The photoresistor module I am using also has 4 pins, and only three are used. The analog output of the module is used over the digital output. You can get the same functionality with just a resistor and a photoresistor.
Vcc to +5V
Aout to Analog pin 1
Gnd to Gnd
The LCD module is connected to the FC 113. The FC 113 is connected in the following manner:
Vcc to +5V
SCL to Analog pin 5
SDA to Analog pin 4
Gnd to Gnd
The arduino nano can be powered through USB with 5V, or through the Vin pin with 7V-12V.
Programming
Programming the Arduino for this is pretty straightforward. All the Arduino has to do is take a measurement from the DHT11 and photoresistor, and then output them to the display.
There are libraries available for the DHT sensor, and the FC 113 module, so the whole process is straightforward.
Before starting
You need two libraries to make things easier, one for the DHT11 and one for the FC 113.
//Temp/Humidity/Light Monitor V0.1 #include //Import LcrystalI2C for FC 113 + LCD module #include //Import DHT for DHT11 temperature/humidity sensor int tempSensor = 5; //Digital pin 5 for temperature sensor int lightSensor = A1; //Analog pin 1 for light sensor dht DHT; //Sets up dht11 as DHT
First I include the required libraries. Then, I establish pin 5 for the temperature sensor and analog pin 1 for the light sensor. Finally, I set up an object called DHT to handle data from the DHT11 sensor.
Setup
void setup(){ Serial.begin(9600); //Establishes serial at 9600 lcd.init(); //Initialize the lcd lcd.backlight(); //Initialize LCD backlight lcd.clear(); //Clear LCD Serial.print(analogRead(lightSensor)); //Print currently photoresistor value to serial; for troubleshooting purposes }
The setup just consists of initializing the LCD module, and printing a simple message to the serial monitor as an optional self-check.
Loop
void loop(){ DHT.read11(tempSensor); //Reads information from tempSensor(pin 5), stores in DHT lcd.setCursor(0,0); //Sets cursor of LCD to very first position lcd.print("H: "); //Prints H: , for humidity lcd.print(DHT.humidity); //Outputs humidity lcd.setCursor(0,1); //Sets cursor of LCD to first position, second line lcd.print("T: "); //Prints T: , for temperature lcd.print(DHT.temperature); //Outputs temperature lcd.print(" C"); //Prints C for celcius delay(4000); //Delays for approximately 4 seconds lcd.clear(); //Clears the LCD lcd.setCursor(0,0); //Resets cursor to first position lcd.print("Lux: "); //Prints Lux, for light level lcd.print(analogRead(lightSensor)); //Outputs lux value delay(4000); //Delays for 4 seconds before looping }
The loop starts by reading the DHT11 sensor, and storing the values in the DHT object. Then, it outputs the information to the LCD. It delays for a few seconds, and then it reads the light sensor. It continues in a loop like this, reading and then outputting. You can adjust the delay to change how often the display updates the values, and you could take it one step further by implementing a button so that the display only updates when you push a button.
I’ve been working on a new remote controlled tank in my spare time. My goal with this project is to make a cheap, printable RC tank kit. This post goes back and forth between talking about the tank, and a basic tutorial on how the components and code work together.
Currently it’s a working prototype. The tank uses an Arduino Nano clone (ATmega328) as the primary board. An L298n H-Bridge is used to control the left and right motors independently, allowing it to quickly turn or revese. It uses the HC-06 Bluetooth module to receive commands. The power comes from two 18650 batteries that are connected in series.
Hardware:
I purchased the majority of the hardware from Aliexpress, because it’s so cheap. The links below are to the stores that I used, but you can find the same parts on many websites other than Aliexpress.
2x 18650 Battery – I took mine from an old laptop, wired them in series for 7V+
1x 500mA Polyfuse – Optional, put between power source and VIN
I salvaged some steel weights from an old set of window blinds, and super-glued them to the base to add some weight.
Frame:
The frame of the tank was printed as a solid piece. There are four mounting spots for wheels. The two at the front are designed so that small bearings will slot into them, so that the front wheels spin freely. The other two of the mounts are designed to hold the gearbox motors. I made a T-shape in the center of the frame so that I can mount a breadboard on top of the frame. The frame design leaves much to be desired, it’s much too thin and flexible.
This slideshow requires JavaScript.
The front and rear wheels have teeth that are spaced out, so that they catch on the inside of the cable-chain tracks. The teeth are tapered slightly to keep the tracks aligned, and there is a guard on the front wheels to ensure that they stay on. The battery holder has holes in the sides and bottom so that wires can pass through. Screws hold the wheels in place.
Schematic:
The Arduino and L298N are powered using two 18650 batteries. These are fairly common rechargeable batteries, with an output around 3.7V. I wired my batteries in series. My schematic says 7.2V, that’s a typo, it’s really 7.4V+. I use the VIN pin on the Arduino Nano to power the chip.
The 5V output on the Arduino powers the HC-06 module. Make sure that you’re using an HC-06 module with a breakout board like mine, so that it is 5V tolerant. This is because the raw HC-06 chip is NOT 5V tolerant.
Pins 2 and 3 are connected to the HC-06, and pins 4 through 7 are connected to the L298N. On the L298N, pins ENA and ENB are used for PWM control of the outputs, so that you can achieve finer speed control. I don’t utilize these, so they are set high.
Code:
There are only two main components to control other than the Arduino itself, they are the HC-06 and the L298n. The HC-06 is going to receive data from an external source, and then pass it to the Arduino. Then the Arduino will make a decision, and send signals to the L298N to turn on the motors.
There is a link at the bottom to download the full code, or read through and copy/paste the example blocks.
Startup:
The program imports the SoftwareSerial library, and establishes pins for motor control. A char named btData is used to handle incoming Bluetooth data. Then pins 2 and 3 are declared as RX and TX using SoftwareSerial.
//SoftwareSerial library is included so that we can utilize pins 2 and 3 for the HC-06
#include <SoftwareSerial.h> //Pins 4, 5, 6, 7 used for motors.
const int motorRF = 4; //RF = Right motor, Forward direction
const int motorRR = 5; //RR = Right motor, Reverse direction
const int motorLF = 6; //LF = Left motor, Forward direction
const int motorLR = 7; //LR = Left motor, Reverse direction
char btData; //char used for bluetooth data - receives commands like "1", "2", "a", etc.
SoftwareSerial HC06(2,3); //RX, TX - Pins 2 and 3 used for HC-06 Module
Setup:
Serial communication is set up, and a string saying “Hello” is sent as a self-check. Then digital pins 4, 5, 6 and 7 are declared as outputs, in order to send signals to the L298n.
void setup() {
HC06.begin(9600); //Begin serial at 9600 baud as "HC06"
HC06.println("Hello."); //Sends "Hello." through serial, to acknowledge startup
pinMode(motorRF, OUTPUT); //Sets pins 4 through 7 to OUTPUTs, to control the L298N
pinMode(motorRR, OUTPUT);
pinMode(motorLF, OUTPUT);
pinMode(motorLR, OUTPUT);
}
Loop:
The loop works by cycling until data is available at the HC-06 module. When data is received, it enters the loop and then makes decisions. In this case, I use the numbers 1 through 4 to control the state of the L298N. When a ‘1’ is received, the Arduino sets pins 4 and 6 to HIGH, so that the L298N enables the outputs in a manner that turns both motors forwards. I use a delay function, so that it keeps the motor on for a second.
void loop() {
//Loops until data is sent to HC06
if (HC06.available()){ //When data is available in the HC06, do this
HC06.println("Reading."); //Prints "Reading." through serial, to acknowledge incoming data
btData = HC06.read(); //Reads "HC06" and stores the value into the char "btData"
if (btData=='1'){ //If the HC-06 receives a 1, do this
HC06.println("Forward."); //Sends "Forward." through serial, to acknowledge that a 1 was received
digitalWrite(motorRF, HIGH); //Activates the motors so that the tank moves forwards
digitalWrite(motorLF, HIGH);
delay(1000); //Delays for approximately one second
}
if (btData=='2'){ //If the HC-06 receives a 2, do this
HC06.println("Reverse."); //Sends "Reverse." through serial, to acknowledge that a 1 was received
digitalWrite(motorRR, HIGH); //Activates the motors so that the tank moves backwards
digitalWrite(motorLR, HIGH);
delay(1000); //Delays for approximately one second
}
if (btData=='3'){ //If the HC-06 receives a 3, do this
HC06.println("Left."); //Sends "Left." through serial, to acknowledge that a 1 was received
digitalWrite(motorRF, HIGH); //Activates the motors so that the tank rotates left
digitalWrite(motorLR, HIGH);
delay(1000); //Delays for approximately one second
}
if (btData=='4'){ //If the HC-06 receives a 4, do this
HC06.println("Right."); //Sends "Right." through serial, to acknowledge that a 1 was received
digitalWrite(motorLF, HIGH); //Activates the motors so that the tank rotates right
digitalWrite(motorRR, HIGH);
delay(1000); //Delays for approximately one second
}
digitalWrite(motorLF, LOW); //Turns all of the motors off, by setting everything to LOW
digitalWrite(motorLR, LOW);
digitalWrite(motorRF, LOW);
digitalWrite(motorRR, LOW);
}
}
I use the mobile app Bluetooth Electronics to connect to and send commands to my HC-06 module. I like using my phone since I can follow the car around. You can also use PuTTy, or another program to send serial commands to the HC-06 from a laptop or desktop.
The HC-06 becomes available for pairing when it is powered on. Pair your device with it, using the default password of “1234“. Once your device is paired with the HC-06, you’ll be able to connect to it using your program of choice.
To connect to it using Bluetooth Electronics, make sure that you’ve paired your device with the HC-06 and then open Bluetooth Electronics. Click “connect” at the top, and select your HC-06 from the list. Assuming you wired it correctly and it’s paired, you will now be able to send commands to it through the app. The app makes it incredibly simple to create a customized GUI for sending commands to the tank.
Future Design Ideas
I plan on making a lot of changes to this tank. I’m going to redesign the majority of the frame and the connection points on the wheels so that they are stronger. I want to increase the number of batteries to 3, so that it’s capable of higher speeds. The battery holder design is a little bit too short, requiring tape to stay closed, so I’ll fix that in the next revision.
I am working on a standalone program so that the project can be controlled in an easier manner. Instead of having it drive for predetermined lengths of time according to command-line strings, I plan on having a GUI with realtime feedback. There are a lot of options for making a program like this. I have been experimenting with python to some success, but I might resort to using one of the many application builders that are available. For right now, the Bluetooth Electronics app meets all of my requirements so I’ll continue down that path until I need more complicated functionality.
A great upgrade for the system would be to use an ESP8266. It would provide greater control options, and it would lower the cost and footprint. The extreme simplicity of the Arduino and HC-06 combination make it very easy to use and adapt, so I am going to continue using it for this project. Plus, I have a bunch of Nanos and HC modules sitting in a drawer collecting dust; it’s about time I turned them into something. My next RC vehicle project will hopefully utilize wifi.
Earlier today I was experimenting with multiple shades/colors and materials using my Prusa i3 Mk2s. I have some black PETG from Fused Filaments, and some natural NextPage PLA. I wanted to see if I could combine them, so I tried to make a minimalistic business card.
Designing The Card
I used 3DS Max to design this card. Virtually every 3D modeling software has tools that let you follow the basic steps that I outline here. I tried to keep it as simple as possible. The basic design idea is split into two parts –
solid background in one color or material
raised features like text/border/design in another color or material
This slideshow requires JavaScript.
Base:
I made the base of the card by creating a 90mmX50mmX0.4mm rectangle. I chamfered the edges so that it would be more comfortable to hold.
Text:
I made a text spline and then extruded it to be 0.4mm thick. Then I positioned it on top of the base.
I find that Arial Round MT Bold is a great font to use for 3D printing, because it has nice corners and good legibility.
Border:
I made an outline of the edge of the card, and positioned it on top of the base like I did with the text. It is 0.4mm thick, like the text.
Printing
I sliced the model using the latest version of Prusa3D Slic3r. I used the following settings on my Prusa i3 Mk2S:
100 micron layers (0.4mm standard Optimal setting)
215C 1st layer
205C PLA layers ( 2nd to 4th layer )
240C PETG layers ( 5th to 8th layer )
I uploaded the model to the Slic3r ColorPrint webpage and used their tool to modify the G-Code. I simply set it to request a color change after completing the background. When I inserted the PETG, I had to make sure to adjust the temperature to 240C using the tune option on the LCD panel.
Design Thoughts
I thought that it would be best to use my natural PLA for the background, and the PETG for text to get a sharp contrast. The opposite would work well, but I thought that the transparency of the natural PLA would be nice as a background. The PETG also requires a printing temperature of ~240C, so it has no problem adhering to a PLA surface. Printing PLA onto PETG might have adhesion problems, because of the lower printing temperature of PLA.
There was minor stringing with the PETG because I was using my standard PLA settings, and only changed the temperature during the color change. It still turned out quite nice considering how little effort I put into it. I started by printing one card, and then I printed six cards at once. Both batches turned out nice.
The cards are pretty flexible but still firm with a 0.4mm base and 0.4mm border. The text gives a really nice tactile feedback when you run your fingers across it. I’m going to try printing them with a base thickness of 0.6mm instead of 0.4mm. The 90mmX50mm size profile is standard, but you could go any direction with the shape or size or design. There’s so many options.
The PETG lettering stuck firmly to the PLA. I twisted, bent and crushed one of the cards and it didn’t break or lose letters. I had to use a knife to peel the letters off, and they were pretty stubborn. The borders didn’t stick as well as the letters, though. I was able to peel the border off of two cards with my fingernails. Perhaps it was too thin.
I am going to experiment with further modifying G-Code, so that I don’t have to manually adjust the temperature after a material switch. Maybe I should pick up some black PLA so I that I don’t have to fuss with temperatures.
I’ve been severely neglecting the ProGrow the past couple of weeks. The cat grass died a while ago, but I’m planning on planting some catnip in the future. Right now, I’m going to try to focus on getting some wireless functionality into it. I have an ESP8266 module that is capable of adding Wifi to the system, but I also have an HC-06 Bluetooth module. I’m going to test out the Bluetooth for now, so that I can send commands to it from my phone or PC.
Progrow Front – Feb 16 2017
Progrow Side – Feb 16 2017
Progrow Side – Feb 16 2017. HC-06 visible in the top right
The HC-06 and HC-05
The HC-06 and HC-05 are inexpensive and easy to use Bluetooth modules. The 05 and 06 are virtually the same, but the HC-06 is only capable of acting as a slave, while the HC-05 is capable of acting as a master/slave. The blue board in the picture above is a breakout board with a voltage regulator for the primary chip.
Adding the HC-06
It’s incredibly easy to wire up the HC-06. All I had to do to connect it to my Arduino UNO was:
VCC to 5V
GND to GND
TX to Pin 2
RX to Pin 3
If your module has a breakout board attached, then it will be 5V tolerant. If it is a bare module, you’ll need to make a voltage divider in order to provide 3.3V to the chip.
Connecting with the HC-06
I’m using the library SoftwareSerial to utilize my digital pins 2 and 3 as RX/TX, instead of 0 and 1. This is because when you have something connected to pins 0 and 1, and try to upload to the board via USB, it can cause a communication issue. At least it did that for me.
All I had to do was include the SoftwareSerial library, and then initialize pins 2 and 3 using:
SoftwareSerial HC06(2,3); //RX, TX
That way I can use “HC06” for serial functions on different pins. It has to go before the setup function.
I’m using a Bluetooth dongle on my PC to send commands to the HC-06. I can connect to it with the Windows Bluetooth interface, using the default password of 1234. I’m using PuTTY to connect to the COM port that is associated with sending data to the HC-06, and then I send commands through the PuTTY terminal.
I can read data that is sent to the HC-06 using:
btData = HC06.read();
Then I can use a simple if statement to make decisions based on whatever value I sent to the module. For example:
if (btData=='1'){
displayData(); //displays all sensor values on screen
}
What’s Bluetooth needed for?
Right now I use the Bluetooth to issue basic commands wirelessly. I can send commands to the ProGrow from my computer using Putty. I can have the system output to the display, water the plant, write to the SD card, change the automatic sample delay and force a measurement.
What’s next?
I want to use an HC-05 module instead, which will give me many more connectivity options.
I am going to design new cases for all of the modules. My goal is to create a single box that will house all of the primary components, instead of having them distributed across the front or side of the container. I also want to get some catnip planted.
This is a rough list of the parts that I have used to make the first few ProGrow prototypes. Everything that I have used for the ProGrow prototypes has been purchased through AliExpress, because I’m super cheap. There are many alternative parts that you can use and find on your own that will achieve the same or better results. I’ll try to explore some alternative options. You can use this as a guide for what sort of modules you might want for your own personal projects.
Parts List:
Main board:
An Atmega 328P development board is used as the main controller in the ProGrow. It’s basically an Arduino UNO clone. Any Atmega based development board should be able to do the same job. You could also potentially use an ESP8266 for integrated wireless function, but that is a different story.
I use a simple acrylic enclosure on the Arduino UNO to make it easier to mount it to stuff. I have also had great success using a 3D printed UNO case, so I’ll include a link to that if you want to print one for yourself.
I use a green LED display from RobotDyn as my primary means of display and system monitoring. They’ve got all sorts of display types, modules and boards available, so I’ll include a link to their store page.
I use the DHT22 as my air sensor. It’s capable of fairly accurate temperature and humidity measurements using the DHT library. It interfaces painlessly with the Arduino using only one GPIO for data, so it has a lot of function in a small footprint.
You can also use the DHT11 as an alternative. The only differences are that the DHT11 is cheaper and slightly less accurate.
You can use the DHT library that is accessible through the Arduino IDE.
I use the dirt cheap soil moisture sensors that you can find online. The ones from Aliexpress are less than a dollar, and they have worked fine for me for almost a year now. It’s always good to buy extra at these prices, though.
I use the sensors analog output with the Arduino, so that I can have the arduino make decisions based on the moisture value.
Some of the modules have the ability to be set so that they will output a logic high when at a certain moisture threshold. If the description doesn’t say it, you can look for this functionality by looking for a potentiometer on the board that connects to the sensor. You can do the same thing with programming, though.
I use a relay module to control the water pump in the ProGrow. A relay module is a bit overkill for such a small DC pump, but it allows a lot of expansion opportunities and interfacing it with the Arduino is dead simple. I went with a prebuilt module, since I could just sticky-tape it right onto my project. You can buy relays of all shapes and sizes on Aliexpress.
I use a simple submersible DC pump to move water into the container for the ProGrow. Any pump will work, as long as you can control it using the relay and Arduino.
I use 170-point breadboards for handling the circuitry for the ProGrow. I love them because they make it very easy it to attach basic circuits to your prototypes.
There are all shapes, sizes and price points available online.
I use the cheapest, simplest push buttons that I could find. They slot into a board, and go clickity-click! You can find them anywhere, in all sorts of shapes and sizes and colors. I use momentary push buttons.
I’m going to describe the basic process I go through to design and then 3D print a vase using 3DS Max. The basic techniques can be applied to many different modeling programs.
Step 1:
Navigate to the splines section and select the Star tool.
Step 2:
Place a star spline with your desired dimensions and number of points. The filet option can be used to smooth the edges.
Step 3:
Select the star. Select Extrude from the Modifier List. Enter the desired height. Use 1 vertical segment for this example, with the rest of the settings at default.
Step 4:
Select the star. Right click, and select Convert To: Editable Poly
Step 5:
Select the top face of the object, and twist it.
Step 6:
With the top face still selected, shrink it to your desired size to create a taper.
Step 7:
Export the model as an STL from 3DS Max, and import it into your slicing program. I use Slic3r and repetier host.
To use vase mode, you have to have:
1 External Perimeter
0 Top Layers
Spiral vase mode enabled (obviously)
I find that using 3 bottom layers is fine, but you can use more to make it less tippy.
Step 8:
Once the model is sliced, print it using your printer and desired settings. I printed this one using transparent purple PLA from AMZ3D. It came out alright; I should have printed a bit slower.
You can download the model on Thingiverse:
http://www.thingiverse.com/thing:2105789
Thanks for reading! I hope you learned something. Have a great day.
Last night I was pretty bored, so I decided to build a simple robot car. I’ve only put a few hours of work into it so far, but it drives and steers! Sort of.
This slideshow requires JavaScript.
Parts used:
1x Arduino Nano
1x LiPo Battery
2x TIP120 Transistor
1x Servo Motor
1x DC Motor Gearbox
2x 2k Resistors
1x Breadboard
4x Wheels
The TIP120 transistor was only used because I had a bag of them within arms reach. The TIP120 works fine for this application, but it is inefficient and has lots of drawbacks. A FQP30n06l is much better for this application.
Schematic:
Code:
Literally all this code does is make the car accelerate gradually and wiggle the steering.
#include <Servo.h>
Servo steering;
int driveMotor = 3; //Digital 3 used for TIP120 on drive motor
int steerMotor = 6; //Digital 6 used for TIP120 on steering servo
void setup() {
steering.attach(9); //Attach the Servo motor to digital PWM pin 9
}
void loop() {
analogWrite(steerMotor, 255); //Turns the TIP120 on for the steering servo
steering.write(90); //Sets the steering to 90 deg
delay(250); //Waits a bit, for the servo to get to place
analogWrite(steerMotor, 0); //Turns off the TIP120 to the servo
analogWrite(driveMotor, 255); //Turns on the drive motor
for (int i=80; i<=255; i++){
delay(25);
analogWrite(driveMotor, i); //Gradually accelerates by switching TIP120, starting at 80/255
}
delay(250);
analogWrite(driveMotor, 0); //Turns off the drive motor
analogWrite(steerMotor, 255); //Turns the TIP120 on for the steering servo
steering.write(45); //Sets the steering to 45 deg
delay(250); //Waits a bit, for the servo to get to place
steering.write(135); //Sets the steering to 135 deg
delay(500); //Waits a bit, for the servo to get to place
analogWrite(steerMotor, 0); //Turns off the TIP120 for the steering servo
}
Design:
The body of the vehicle is a 94:1 gearbox and the DC motor that drive the rear wheels. I attached a breadboard to the top of the gearbox to hold the circuitry. The servo motor responsible for steering is mounted on the front of the gearbox, and a 3D printed bracket holds the front wheels to the servo horn. It’s a pretty poor steering system, to be honest. I used zip ties and double-sided tape to keep everything stuck together.
The front wheels are some old attempts at Emmets Bearings that I found in my failed print bin. They spin well, but are awfully ugly. I designed the rear wheels myself using 3DS Max.
The obvious next step is to add a dedicated supply for the Arduino, so that the car is completely independent. It also needs basic wireless control; I’ll likely use IR. It also needs an actual frame and some proper wiring… and a lot more. It’s a work in progress.
3D Printed Integrated Circuit HolderI spend way too much time on Aliexpress in the middle of the night. As a result, I’ve amassed a huge collection of assorted ICs. Who can resist a pack of 20 ICs for $1 with free shipping? Not me, that’s who. I enjoy making models and I have a 3D printer, so took a crack at solving the problem by designing and 3D printing my own IC organizer.
I designed it so that each compartment would hold a single 8-pin IC, and to use as little plastic as possible. Compartments can be added or removed to hold as many ICs as needed, and can be positioned into whatever configuration is desired.
I started by creating a basic design, which was just a box that was slightly larger than a standard 8-pin IC. More boxes were used to create the rough profile of an IC. Then I subtracted the IC profile from the original box using the Advanced Boolean tool. I added a notch to each side of the holder to make it easier to add or remove ICs. Then I copy and pasted the individual holder until I had as many as I desired.
Printing involved exporting the model as an STL through 3DS Max. I imported it into Repetier Host, sliced the model using Slic3r and then I printed it on my Kossel Delta.
Here’s a video of the entire process, from initial design to 3D printing to being used.
I used the following printer settings:
0.4mm nozzle width
0.3mm layer height
200C nozzle temperature
103% extrusion multiplier
Better bonding and surface finish at 103%, but reduced dimensional accuracy