While lockdown has prevented me from being able to get back to many woodworking projects this year, I did manage to cut a few offcuts to size and sand them in order to fashion a stand for a bamboo tray. The idea being for it to be a temporary table or drinks stand in our small patch of outside space.
The construction is a simple X-frame, with horizontal bars at each of the four points - 2 to support the tray, 2 to act as feet. These are joined to the X-frame using a 3D-printed bracket - the SCAD file for this is up on GitHub.
In order to stop the frame from spreading out and collapsing under the weight of the tray and it's contents, the feet were joined with some denim fabric, courtesy of an old pair of jeans. This allows the stand to be folded up, but providing plenty of rigidity during use.
Sewing things other than leather is a pretty new thing to me, my only prior sewing-related project being the lanyard I made a while back. So I'm the first to admit it's not the neatest work, but it does the job, so can't complain.
With the benefit of hindsight, the hinges allowed a bit too much flexibility, allowing the cross-bars to roll. The fabric on the feet alleviates this at the bottom. On the top, the base of the tray has a small lip which helps latch onto the cross-bars - whilst they still roll, it's impact is minimised and the tray/table works fine.
Showing posts with label 3D Printing. Show all posts
Showing posts with label 3D Printing. Show all posts
Tuesday, 26 May 2020
Thursday, 30 April 2020
Yarn slack winder
This is another of the lockdown projects where I'm trying to keep myself occupied during the Covid-19 lockdown by challenging myself to a project per week, using only materials from my workshop junk bin.
Background
I don't crochet or knit, but my partner does, and I often end up watching TV whilst having been delegated to idly unwinding a ball of wool.
So, apparently, when crocheting or knitting, it's important to make sure that there's some slack between the workpiece and the ball of yarn. This usually means stopping every so often to pull more yarn from the ball. It can lead to inconsistent tension in the workpiece, making the work uneven.
This gave me an idea to create a yarn dispenser that could be hands-free, and unwind small amounts at a time, to maintain slack.
The design
The basic principle is to repurpose two rubber rollers (grey) from a printer. The bottom one is attached to a motor, which is housed in the case (red), and supported at the other wide by a support (yellow).
The top roller is attached to two mounts (blue) and is free-rolling.
The two mounts will be attached to their respective parts of the case by screws, where the tightness can be adjusted to allow more or less gap between the rollers, to vary the grip depending on the thickness/density of the yarn.
The yarn will be sandwiched between the two rollers, so that when the motor is activated by a foot pedal, it is pulled between the rollers.
To keep the two sides of the frame separate, they were mounted to a small piece of scrap acrylic I found. It's not a perfect size, but it's functional enough for this prototype.
The 3D printed models are pretty basic, but should anyone want to use them, they're up on GitHub.
The electronics
The motor is some generic DC motor that, like most things in the junk bin, was probably pulled from an old printer.
Most of the circuit for this was was salvaged from the old Smoke Machine project.
The SN754410 was de-soldered so that it would function in a more conventional way, powered from a 9v wall wart, and a TS7805 regular to provide 5v.
The electronics were built into an old business card box, similar to the USB KVM Switch.
With the circuit hot glued in place, a piece of a disposable pen was glued to the button to extend it's reach, so that it would sit slightly higher than the top of the box lid. This means the the circuit enclosure also doubles up as the foot pedal - pushing down on the lid pushes on the pen, and in turn presses the switch.
Finished product
In initial testing, it was discovered that the yarn would veer off to the side of the rollers and become tangled. As a quick-fix solution, I used a scrap of leather, punched a guide hole in the middle and tacked it to the input side of the rollers.
Background
I don't crochet or knit, but my partner does, and I often end up watching TV whilst having been delegated to idly unwinding a ball of wool.
So, apparently, when crocheting or knitting, it's important to make sure that there's some slack between the workpiece and the ball of yarn. This usually means stopping every so often to pull more yarn from the ball. It can lead to inconsistent tension in the workpiece, making the work uneven.
This gave me an idea to create a yarn dispenser that could be hands-free, and unwind small amounts at a time, to maintain slack.
 |
| The OpenSCAD model |
The basic principle is to repurpose two rubber rollers (grey) from a printer. The bottom one is attached to a motor, which is housed in the case (red), and supported at the other wide by a support (yellow).
The top roller is attached to two mounts (blue) and is free-rolling.
The two mounts will be attached to their respective parts of the case by screws, where the tightness can be adjusted to allow more or less gap between the rollers, to vary the grip depending on the thickness/density of the yarn.
The yarn will be sandwiched between the two rollers, so that when the motor is activated by a foot pedal, it is pulled between the rollers.
To keep the two sides of the frame separate, they were mounted to a small piece of scrap acrylic I found. It's not a perfect size, but it's functional enough for this prototype.
The 3D printed models are pretty basic, but should anyone want to use them, they're up on GitHub.
The electronics
The motor is some generic DC motor that, like most things in the junk bin, was probably pulled from an old printer.
Most of the circuit for this was was salvaged from the old Smoke Machine project.
The SN754410 was de-soldered so that it would function in a more conventional way, powered from a 9v wall wart, and a TS7805 regular to provide 5v.
 |
| The circuit. The SW1 switch allows the direction of the motor to be easily switched. SW2 is the foot pedal that will be pressed to feed the yarn. |
The electronics were built into an old business card box, similar to the USB KVM Switch.
With the circuit hot glued in place, a piece of a disposable pen was glued to the button to extend it's reach, so that it would sit slightly higher than the top of the box lid. This means the the circuit enclosure also doubles up as the foot pedal - pushing down on the lid pushes on the pen, and in turn presses the switch.
Finished product
In initial testing, it was discovered that the yarn would veer off to the side of the rollers and become tangled. As a quick-fix solution, I used a scrap of leather, punched a guide hole in the middle and tacked it to the input side of the rollers.
Sunday, 1 September 2019
Empty roll warning buzzer
This was a commissioned project that went nowhere, but could easily be re-purposed for many different use cases, so I thought I'd share it.
The aim is to create a range finder device that can be mounted and aimed at a roll of material on an assembly line, so that the range finder can be used to determine the amount of material left on the roll, and sound a buzzer when the supply falls below a set amount, informing the machines operator so that they can replace the roll and minimize downtime.
The sensor is a Sharp GP2Y0A21YK0F. The datasheet shows that the voltage drops as the distance increases. In our particular use case, this means that as the material runs out, the voltage will drop, so we want to flag a warning below a set voltage.
Initially I thought about using a low battery circuit similar to the one I modified to use in the Keyboard Pedal project. However, I later realised that would be over-complicating it, and that the same result can be achieved using a simple comparator circuit.
The chip used is the LM358 op-amp, and the circuit is similar to the one found on page 6 of this PDF.
The key differences being:
The whole enclosure is 3D printed, based off a simple lidded box design with cut outs for controls and the IR sensor itself.
I also took the opportunity to turn the box into a simple parametric template so I can recycle it for other projects. the SCAD source code can be found on GitHub.
All that's needed is to supply the internal dimensions that are required and it'll create a thin-walled box meeting those criteria, using only stock OpenSCAD commands - no other modules required.
The lid fits snug - on my (admittedly by this point quite old) 3D printer, a nice unintended side effect of the rough resolution is that the ridges create a nice friction fit, allowing the box to be closed tight, but also popped back open with relative ease should maintenance be required.
The short buzzing before the alarm fully triggers is driven by the 'wobble' of the roll on the holder. In production use the material rolls are much more securely held, and so this effect would be minimised.
The aim is to create a range finder device that can be mounted and aimed at a roll of material on an assembly line, so that the range finder can be used to determine the amount of material left on the roll, and sound a buzzer when the supply falls below a set amount, informing the machines operator so that they can replace the roll and minimize downtime.
The sensor is a Sharp GP2Y0A21YK0F. The datasheet shows that the voltage drops as the distance increases. In our particular use case, this means that as the material runs out, the voltage will drop, so we want to flag a warning below a set voltage.
Initially I thought about using a low battery circuit similar to the one I modified to use in the Keyboard Pedal project. However, I later realised that would be over-complicating it, and that the same result can be achieved using a simple comparator circuit.
The chip used is the LM358 op-amp, and the circuit is similar to the one found on page 6 of this PDF.
The key differences being:
- The voltage provided by the resistor and zener diode in their diagram is replaced by a potentiometer in mine, so that the 'trigger' value can be adjusted.
- The potentiometer in their diagram is replaced by the IR sensor in mine.
- The resistor and LED output in theirs, replaced by a buzzer.
- The voltage of my circuit is 5V so it can run off a USB charger.
 |
| Note that RV2 is the IR distance sensor - I didn't have the symbol for it in KiCad so used a potentiometer symbol as that's essentially the behaviour it exhibits. |
 |
| The finished circuit, fit neatly into it's enclosure. |
The case
The circuit needed to be neatly enclosed for it's purpose. Often for electronics projects I'll end up re-purposing existing containers and boxes as enclosures, but as it was a commissioned project something more professional was in order.The whole enclosure is 3D printed, based off a simple lidded box design with cut outs for controls and the IR sensor itself.
I also took the opportunity to turn the box into a simple parametric template so I can recycle it for other projects. the SCAD source code can be found on GitHub.
All that's needed is to supply the internal dimensions that are required and it'll create a thin-walled box meeting those criteria, using only stock OpenSCAD commands - no other modules required.
The lid fits snug - on my (admittedly by this point quite old) 3D printer, a nice unintended side effect of the rough resolution is that the ridges create a nice friction fit, allowing the box to be closed tight, but also popped back open with relative ease should maintenance be required.
|
|
The test
As I didn't have access to the factory where this was intended to be used, I whipped up a quick test rig using kitchen roll as the stunt double for the actual material.The short buzzing before the alarm fully triggers is driven by the 'wobble' of the roll on the holder. In production use the material rolls are much more securely held, and so this effect would be minimised.
Friday, 10 May 2019
Pen Plotter Part 2 - Electronics and Software
This is the second part of my pen plotter build - part 1, covering the physical structure of the build, is here.
Printing Hello World!
Electronics and Software
The stepper motors are driven by EasyDriver controllers which were recycled from an old, abandoned project.
Everything else is pulled together and controlled using an Arduino Duemilamove which provide the G-Code interpretation using the GRBL library.
Because GRBL is designed with 3-axis CNC machines in mind, it requires some alterations to work with the servo pen-plotter mechanism.
Thankfully I'm not the first person in the world to have attempted this, and this instructable provided a good head start on how to do this.
The main takeaways are to download the regular GRBL library, but swap out the spindle_control.c file with the one from the instructable. In that file there are two lines:
#define PEN_SERVO_DOWN #define PEN_SERVO_UP
Change the servo values if necessary - after experimenting with changing them, I found that I got the best results setting the down value to 255 and the up value to zero.
Inkscape GCode Conversion
The GCode plugins for Inkscape seem to be included with a standard installation - I didn't have to do anything special for them to appear.
Whatever your source image is (in the video below it was a text object), it needs to be converted to paths.
If you're using objects within Inkscape, such as text, use Path, Object to Path.
If you're starting with a bitmap image then use Path, Trace Bitmap, and use the Edge Detection method.
Post-processing
The next step is to run the generated GCode through a post-processor to add the instructions to raise/lower the servo. The post-processor linked in the Instructable didn't work for me, so I ended up making my own - the code is on GitHub.
To run the machine, I use the Universal G-Code Sender.
Troubleshooting
There were a few issues homing the plotter as near the extremities of the carriages travel it would struggle to move smoothly, and would not reach close enough for the limit switches to be triggered, resulting in it stalling. To overcome this I added screws to the structure in such a way that the limit switches would be triggered when stalling began to occur.
The pen holder that I designed in the previous post did work, but there were a few issues with the overly simplistic design:
- The fact it rotated the marker off the page created 'flick' marks where the pen was raised/lowered.
- As it was secured entirely on the servo, it had too much flexibility which resulted in it being dragged incorrectly on the page.
To fix this I redesigned the pen mount, factoring in what had already been created so as to make use of what was already created as much as possible.The new design relies on supporting rails mounted to the existing carriage, which would allow the servo to push the pen mount directly down onto the paper. When lifting the servo returns to its initial position, letting springs added to the rails lift the pen back up.
This new nozzle is on github here.
Wednesday, 3 April 2019
Pen Plotter Part 1 - The Structure
I had two new years resolutions this year - start posting here on a more regular schedule, and to start whittling down the pile of electronic junk that I'd accumulated over the years.
I've obviously failed the first one already, but to aid the second one I've set myself the challenge of using as much of the junk pile into projects as possible.
A pen plotter works kind of like a printer, but allows for any flat material to be printed on, and uses vectors to draw images - like a person drawing by hand, instead of rasters like a traditional printer.
The principle is simple, a basic 2-axis structure with a tool-end that allows for a marker/pen/pencil to be simply placed on or lifted off the paper.
The stepper motors, gears and drive belts, along with the steel structural rods and bushing were taken from a variety of old ink-jet printers and scanners. The limit switches and servo were either just in my components library or salvaged from old projects.
The supporting structure was 3D printed, having been designed in OpenSCAD - the SCAD source code can be found on GitHub. I'm not putting the files on Thingiverse as they're created to fit the random motors that I scavenged, so anyone else using the design would most likely need to alter the dimensions for their own motors.
The chipboard base has been up-cycled from an old flat-pack desk.
The structure
The first axis consists of two end mounts - one being a simple shape to support the ends of the steel bars (a wheel for the pulley was added manually after printing.)
The other end is a larger mount which contains a mounting point to secure the first stepper motor - obviously this was created bespoke to the stepper that I salvaged, but could easily be adapted in the SCAD file.
In the middle are two pieces which will form the carriage for the second axis. - they're similar to the first end piece, but also contain mounting points to secure the pulley.
The second axis builds off of the first, fitting between the two runners created as part of the first axis:
The two holes are the front are for the steel guide rods. The gap in the middle is a space for the limit switches to be attached to the carriage and the cutaway at the top is for the second axis' motor.
The two runners and this carriage are fixed together by plastic friction welding.
The motor/gear assembly that I'll be using for the second axis lifts the belt over the top of the first axis' rods, so the height of the end piece is made to match. The notch at the top accommodates the spring-loaded tensioner for the belt.
The carriage for the second axis is a simple block which contains the two limit switches for the axis, a servo and a bracket to mount the pulley to.
The final structural piece is a simple pen holder which connects to the arm of the servo.
The next part will cover the electronics and software.
I've obviously failed the first one already, but to aid the second one I've set myself the challenge of using as much of the junk pile into projects as possible.
A pen plotter works kind of like a printer, but allows for any flat material to be printed on, and uses vectors to draw images - like a person drawing by hand, instead of rasters like a traditional printer.
The principle is simple, a basic 2-axis structure with a tool-end that allows for a marker/pen/pencil to be simply placed on or lifted off the paper.
The stepper motors, gears and drive belts, along with the steel structural rods and bushing were taken from a variety of old ink-jet printers and scanners. The limit switches and servo were either just in my components library or salvaged from old projects.
The supporting structure was 3D printed, having been designed in OpenSCAD - the SCAD source code can be found on GitHub. I'm not putting the files on Thingiverse as they're created to fit the random motors that I scavenged, so anyone else using the design would most likely need to alter the dimensions for their own motors.
The chipboard base has been up-cycled from an old flat-pack desk.
The structure
 | |
| The 4 main components of the first axis (Rods not 3D printed) |
The first axis consists of two end mounts - one being a simple shape to support the ends of the steel bars (a wheel for the pulley was added manually after printing.)
The other end is a larger mount which contains a mounting point to secure the first stepper motor - obviously this was created bespoke to the stepper that I salvaged, but could easily be adapted in the SCAD file.
In the middle are two pieces which will form the carriage for the second axis. - they're similar to the first end piece, but also contain mounting points to secure the pulley.
The second axis builds off of the first, fitting between the two runners created as part of the first axis:
|
|
The two runners and this carriage are fixed together by plastic friction welding.
The motor/gear assembly that I'll be using for the second axis lifts the belt over the top of the first axis' rods, so the height of the end piece is made to match. The notch at the top accommodates the spring-loaded tensioner for the belt.
The carriage for the second axis is a simple block which contains the two limit switches for the axis, a servo and a bracket to mount the pulley to.
|
|
The next part will cover the electronics and software.
Sunday, 22 July 2018
Lighter screwdriver bit holder
A sign of a brilliant project is one that is "obvious with hindsight" - when you see it, it suddenly seems so simple that you end up annoyed at yourself for not having thought of it yourself.
For me, Laura Kampf's Zippo Lighter driver bit case was one of those projects.
I've had a similar lighter kicking about in the junk drawer for years, always holding onto it because I liked the aesthetic of it and wanted to use it in a project, but never knowing what that project was.
So I'll admit, this was a shameless copy of Laura's project, but as I don't have access to a milling machine, I had to take a different approach. The insert that I have created is 3D printed, and relies on a friction fit to hold the parts rather than magnets.
Rather than use the free plan, I decided to create my own, adding an additional hollow in the middle of the insert. The idea was that this less-accessible compartment could contain less frequently used driver bits, but still keep them together with the others.
In reality, the fit of the insert is a bit too tight to allow the compartment to be easily accessed, but it does still serve a purpose in reducing the amount of filament required to print the model (compared to leaving that part solid).
I also found that my lighter has a small metal tab in the lid that got in the way once the driver bits were in place, but this was easily removed with pliers. (I'm not sure is this is a typical thing of these lighters, or just because the one I'm using is an off-brand knockoff.)
I have to concede that the insert would've looked better in metal, but from a functionality perspective it works just as well, and sometimes you just have to work with what you've got.
The STLs for the model can be found on Thingiverse, and the OpenSCAD code is on GitHub.
For me, Laura Kampf's Zippo Lighter driver bit case was one of those projects.
I've had a similar lighter kicking about in the junk drawer for years, always holding onto it because I liked the aesthetic of it and wanted to use it in a project, but never knowing what that project was.
So I'll admit, this was a shameless copy of Laura's project, but as I don't have access to a milling machine, I had to take a different approach. The insert that I have created is 3D printed, and relies on a friction fit to hold the parts rather than magnets.
In reality, the fit of the insert is a bit too tight to allow the compartment to be easily accessed, but it does still serve a purpose in reducing the amount of filament required to print the model (compared to leaving that part solid).
I also found that my lighter has a small metal tab in the lid that got in the way once the driver bits were in place, but this was easily removed with pliers. (I'm not sure is this is a typical thing of these lighters, or just because the one I'm using is an off-brand knockoff.)
I have to concede that the insert would've looked better in metal, but from a functionality perspective it works just as well, and sometimes you just have to work with what you've got.
The STLs for the model can be found on Thingiverse, and the OpenSCAD code is on GitHub.
Sunday, 25 February 2018
PC case notification screen, part 3 - software & installation
In the first two parts of this project, I setup a Raspberry Pi to display notifications from my desktop PCs to a small LCD which I then 3D printed mounts for to install it into the PC itself.
Software
I originally hoped to use existing software, such as Grafana and Graphite, but although they do run on the Raspberry Pi, it was difficult to get them to behave reliably, so I ended up going for a homebrew solution.
As I alluded to in an earlier post, the data comes out of the desktop by piping output from the linux command
The application running on the Pi reads data from the serial port, and using a simple parser, extracts the system temperature.
This is then passed to a Processing.org sketch, which draws an (admittedly rather basic) gauge, displaying the temperature.
The code is available on Github. It also contains an interface class and an example implementation of that class, this is a wrapper I made around the Processing.org library to make it easier to compartmentalise the processing functionality into separate classes, with the intent of making it easier to create a modular display (so further notification modules could be added in future - system speed, email/social media notifications etc).
Installation
The two mounts are either side of the metal front panel of the case, back-to-back.
The Pi sits on the inside, and the display sits on the outside (of the metal chassis - it is covered by the actual front panel of the case).
This allows the outside of the case to remain unchanged, but the display of the LCD is bright enough to shine through the translucent panel.
When the PC is powered down, the USB port still provides power, so the Pi stays on, but the power to the display is cut. This avoids having to go through the Pi boot sequence each time, but allows the display to be shut off.
Software
I originally hoped to use existing software, such as Grafana and Graphite, but although they do run on the Raspberry Pi, it was difficult to get them to behave reliably, so I ended up going for a homebrew solution.
As I alluded to in an earlier post, the data comes out of the desktop by piping output from the linux command
sensors via the a USB serial port like so:sensors > /dev/ttyUSB0 2>/dev/null
The application running on the Pi reads data from the serial port, and using a simple parser, extracts the system temperature.
This is then passed to a Processing.org sketch, which draws an (admittedly rather basic) gauge, displaying the temperature.
The code is available on Github. It also contains an interface class and an example implementation of that class, this is a wrapper I made around the Processing.org library to make it easier to compartmentalise the processing functionality into separate classes, with the intent of making it easier to create a modular display (so further notification modules could be added in future - system speed, email/social media notifications etc).
Installation
The two mounts are either side of the metal front panel of the case, back-to-back.
The Pi sits on the inside, and the display sits on the outside (of the metal chassis - it is covered by the actual front panel of the case).
This allows the outside of the case to remain unchanged, but the display of the LCD is bright enough to shine through the translucent panel.
When the PC is powered down, the USB port still provides power, so the Pi stays on, but the power to the display is cut. This avoids having to go through the Pi boot sequence each time, but allows the display to be shut off.
Thursday, 22 February 2018
PC-case notification screen: Part 2, mounts and wiring
In the last post, I configured a Raspberry Pi to receive stats from my desktop PC and display them on a small LCD from a car reversing camera kit.
The next stage is to turn this into a much neater setup to integrate it into my desktop PCs case.
Mounting
The Raspberry Pi quite a popular format, so there's plenty of cases on Thingiverse to choose from - no need to reinvent the wheel. I went with this tray design, as it was the easiest to adapt.
The front of my PC case has several mounting points for an array of fans, so all that was necessary was to create a way of joining the Pi Tray to them.
A simple 'X' shaped bracket in OpenSCAD is all that was needed. It would be easy enough to join this to the model for the Pi Tray, but I ended up printing them separately and gluing them together.
I used the same design as the basis of the mount for the display.
Out of the box it has it's own small stand to attach to a dashboard, with a screw pivot for tilting the display. My idea was to simply remove the stand part and use the same mounting point.
Wiring
The LCD runs of 12 volts. This is nice and easy to deal with - Molex connector straight to the power supply. This was just a case of joining the connector for the display to the Molex.
The Pi requires 5 volts, and there's 2 options on how to provide this - Also on the Molex, or via USB. There's pros and cons to both methods.
Starting with a short USB extension cable, I removed the socket and split out the wires.
Then using a header lead pulled from an old PCs front panel, remove the header connector. Then it's just a case of matching up the pins and joining them together.
The Pi is connected to this using a console cable. This is a USB cable with 4 output pins - 5V, ground, TX and RX, and connects directly to the GPIO of the Pi.
It's not recommended to use the 5V GPIO pin for power as it lacks some of the control circuitry that the usual power socket has, but has the power is coming from a regulated USB socket, it should be fine in this case.
The console cable also takes care of the level conversion of the 5v levels to Pi-safe 3.3v, and appears to the PC as a USB-serial adapter.
Finally, all that's left is to connect the display to the Raspberry Pi. Both the display and the Pi have Composite sockets, so I removed the socket from the display and replaced it with a plug.
SCAD code for the mount
As this is really quite a niche thing I'm not going to put the files on Thingiverse, but here's the OpenSCAD code in case it's useful to anyone.
The basic wrapper around the USB connector
The next stage is to turn this into a much neater setup to integrate it into my desktop PCs case.
Mounting
The Raspberry Pi quite a popular format, so there's plenty of cases on Thingiverse to choose from - no need to reinvent the wheel. I went with this tray design, as it was the easiest to adapt.
The front of my PC case has several mounting points for an array of fans, so all that was necessary was to create a way of joining the Pi Tray to them.
A simple 'X' shaped bracket in OpenSCAD is all that was needed. It would be easy enough to join this to the model for the Pi Tray, but I ended up printing them separately and gluing them together.
 |  |
I used the same design as the basis of the mount for the display.
Out of the box it has it's own small stand to attach to a dashboard, with a screw pivot for tilting the display. My idea was to simply remove the stand part and use the same mounting point.
 |  |
|
|
Wiring
 | |
| Note: The 12V line is typically the yellow line, it just so happens on the connector I found was non-standard. |
The Pi requires 5 volts, and there's 2 options on how to provide this - Also on the Molex, or via USB. There's pros and cons to both methods.
- Going the Molex route is more straightforward - it can use the same connector as the LCD, so wiring will be neater, but on the downside, when the desktop is powered off, the power to the Pi will be cut. This runs the risk of corruption of the SD card.
- Going the USB route means more wiring and a separate power lead, but has the advantage that my desktops motherboard still powers USB devices when powered down, therefore the Pi can remain on.
Starting with a short USB extension cable, I removed the socket and split out the wires.
Then using a header lead pulled from an old PCs front panel, remove the header connector. Then it's just a case of matching up the pins and joining them together.
 |
 |
 |
| The adapter without the 3D printed cover (top), and the finished adapter (bottom). Each motherboard adapter can support 2 ports, so I left the remaining wires outside (just heat-shrinked for safety), so they're available if I decide to add another internal port later. |
The Pi is connected to this using a console cable. This is a USB cable with 4 output pins - 5V, ground, TX and RX, and connects directly to the GPIO of the Pi.
It's not recommended to use the 5V GPIO pin for power as it lacks some of the control circuitry that the usual power socket has, but has the power is coming from a regulated USB socket, it should be fine in this case.
The console cable also takes care of the level conversion of the 5v levels to Pi-safe 3.3v, and appears to the PC as a USB-serial adapter.
Finally, all that's left is to connect the display to the Raspberry Pi. Both the display and the Pi have Composite sockets, so I removed the socket from the display and replaced it with a plug.
SCAD code for the mount
As this is really quite a niche thing I'm not going to put the files on Thingiverse, but here's the OpenSCAD code in case it's useful to anyone.
// Just comment out the one you don't want
piMount();
screenMount();
// Couldn't be bothered to do the conversion...
function inches(x=1) = x*25.4;
module piMount() {
difference() {
cube([inches(4.5),inches(2.75),inches(0.125)], center=true);
translate([inches(-2.0625),inches(-1.125),0]) { screwholes();}
translate([55,0,0]) {cylinder(inches(0.75),inches(0.8),inches(0.8), center=true);}
translate([-55,0,0]) {cylinder(inches(0.75),inches(0.8),inches(0.8), center=true);}
translate([0,40,0]) {cylinder(inches(0.75),inches(1),inches(1), center=true);}
translate([0,-40,0]) {cylinder(inches(0.75),inches(1),inches(1), center=true);}
}
}
module screenMount() {
difference() {
cube([inches(4.5),inches(2.75),inches(0.5)], center=true);
translate([inches(-2.0625),inches(-1.125),0]) { screwholes();}
cube([1.125*25.4,12.7,50], center=true);
rotate([0,90,0]) {cylinder(5*25.4,0.125*25.4,0.125*25.4,true);}
translate([55,0,0]) {cylinder(inches(0.75),inches(0.8),inches(0.8), center=true);}
translate([-55,0,0]) {cylinder(inches(0.75),inches(0.8),inches(0.8), center=true);}
translate([0,40,0]) {cylinder(inches(0.75),inches(1),inches(1), center=true);}
translate([0,-40,0]) {cylinder(inches(0.75),inches(1),inches(1), center=true);}
}
}
module screwholes() {
cylinder(inches(5),inches(0.125),inches(0.125),true);
translate([inches(4.125),0,0]) {cylinder(inches(5),inches(0.125),inches(0.125),true);}
translate([0,inches(2.25),0]) {cylinder(inches(5),inches(0.125),inches(0.125),true);}
translate([inches(4.125),inches(2.25),0]) {cylinder(inches(5),inches(0.125),inches(0.125),true);}
}
The basic wrapper around the USB connector
difference() {
cube([15,40,9], true);
translate([0,7,0]) {cube([13,27,7], true);}
cube([9,45,7], true);
translate([0,0,5]) {cube([20,50,10], true);}
}
Tuesday, 29 November 2016
Tool / Drill Bit Demagnetiser
The Build
The downside to the magnetic drill bit organiser that I created in the last post is that the drills themselves end up becoming magnetised.
This isn't really a problem for woodwork, but can get a bit annoying for drilling metal, so I started looking at building a demagnetiser.
Research online showed lots of examples (such as this) of powered demagnetisers, often using dismantled power transformers, mains power and over-heating risks, which was a bit off-putting.
However, there are passive (unpowered) demagnetisers available to purchase, so there must be another way.
It's well known that metal can be magnetised by rubbing it against a magnet. There is, of course, a lot of dry and boring scientific explanation about why it happens, but in layman's terms, the punchline is that metal stuff gets magnetised when the electrons in it get aligned. So to demagnetise it, just screw up their alignment. Simple, right?
Yeah, really, it is. If putting a bit of metal near one magnet pulls the electrons into line and magnetises it, sit the metal between two strong magnets, and the electrons can't agree which way to point, so they end up pointing in conflicting directions, and become demagnetised.
The magnets were provided courtesy of an old, broken hard drive. Unfortunately the shape of the drive magnets is a bit awkward to work with. To overcome this I took photos of the magnets, imported the photo into Inkscape and drew around them, exporting the resulting SVG into blender to turn into a 3D model for printing (a similar process that I used in this post)
 |  |
The HDD magnet, and the shape drawn around it in Inkscape, ready for extrusion into Blender.
A bit of hot glue was used to fix the magnets in place, and they were covered with Sugru to avoid tools just sticking straight to them.
To join the halves together, I would typically just glue them together, but this time I wanted to test a technique I've not tried before - plastic friction welding. It sounds fancy, but can be done with a Dremel and a bit of 3D printer filament - see the clip below for an example. I used orange filament against the black used for the printed body of the demagnetiser - it's not the most aesthetic choice, but it does help highlight the plastic weld technique a bit more easily.
The resulting join is plenty strong enough - as evidenced by several spontaneous shock tests, and totally not by accidental dropping.
The demagnetiser works simply by waving a magnetised tool through the gap in the gadget, as seen in the video at the top. It won't necessarily remove magnetism entirely, but as you can see, it significantly reduces it.
Thursday, 28 January 2016
Copying objects for 3D printing without a 3D scanner
Over the holidays I broke the smoke alarm in my flat. Not the smoke alarm itself as such, but the mount that held it to the ceiling. Judging by the amount of various adhesives that were on the mount, it looks as though a previous occupant had actually broken the mount, but bodged together enough adhesive to hold it tenuously in place until they left.First of all, take photos of the object against a plain background. Ideally pick a background which contrasts well against the object that you're trying to copy.
Open the image in a photo editor, and crop any unnecessary bits out the picture.
Create a translucent layer above the current layer, so that you're working on the new layer, but can see through to the photo.
Use the paths tool to trace around the object as best you can, invert the selection and delete the contents. This should remove all the surrounding background bits.
Use the paths tool a few more times to create the cut-outs you require - for example in my case it's removing the centre piece and the screw holes.
Then make the working layer opaque, and fill the outline shape with a colour.
Save and export this image as a PNG.
OpenSCAD is meant to be able to import and extrude PNG files directly, but I've found it to be unreliable, so the below is a workaround that I've been using.
Converting to SVG using Inkscape
Open the edited image into a vector graphics editor, such as Inkscape.
Click on the image, right click and select "Trace Bitmap". Select "Edge Detection". If the image being used is simple enough, you can leave the default values, click OK, and then close the menu.
Drag the bitmap out the way (you can delete it now), and you should be left with an outline of the object. Fill the outline with a colour to make the object solid.
Save this SVG file.
Extruding the file in Blender
Open Blender.
Go to File, Import, Scalable Vector Graphics (SVG). Find the file and select it.
You may have to zoom quite far in to see the imported object.
Select the object and move it slightly, you'll see a second outline object that gets left behind. Click on the outline object and delete it, you don't need it here, then replace the rest of the object.
Next we need to set the units of the object, so that we can scale it properly. Click the Scene properties tab on the right, and select Metric or Imperial from the units section.
Next, we scale the object.
Press N to bring up the information about the object, and get the dimensions.Set the X and Y scale here, but for the Z axis we need to extrude the flat image into a 3D object.
To do this, go to the right hand side and select object data, geometry, extrude.
In the case of my project, I added a couple of extra objects to recreate the latches which were broken off the original mount.
Once this is done export to STL and you have a file ready to send to the 3D printer.
 |
| Left, the original broken mount, and right, the 3D printed replacement. |
Saturday, 18 July 2015
In-car Bluetooth Stereo Mod
As the past few projects have been quite frivolous gadgets, this time I'm going to do something practical. It turns out this was actually one of the quicker projects I've done and makes a decent weekend project for anyone looking to make a quick upgrade to their cars audio system.
My car as an auxiliary audio input for connecting MP3 players etc. For this I purchased a bluetooth speaker adapter on Ebay for about a tenner.
It's a great device to connecting my phone for sat-nav, music etc, but there's a small annoyance in the fact that after getting in the car, it requires me to press and hold the power button for about 5 seconds before it'll turn on and connect to my phone. It's a bit of a first-world problem, granted, but it's kinda irritating, so I've been thinking about how to solve it.
Ideally, it should function like a built-in bluetooth adapter does in many new cars - as soon as the car is powered on, the bluetooth is powered on and connects to the phone.
After some experimenting with various approaches - microcontroller delays, 555 timers, I found the most functional circuit was a simple capacitor delay circuit, combined with a transistor NOT gate & optocoupler, so that the optocoupler is active, effectively holding down the adapter's power button, for 5 seconds, then switched off until the circuit loses power.
Powering the circuit was simple enough - I already have a car 'cigarette lighter' to USB adapter with 2 USB ports - one powers the bluetooth adapter, and it powers on with the car ignition, so I added a USB plug to the timer circuit and used that.
Finally, I didn't want to leave exposed wires or circuit boards visible in the car - knowing my luck some paranoid idiot would freak and call the bomb squad or something, so I 3D printed a simple box enclosure which houses the adapter and the circuit nicely, the box itself nestling neatly in the centre console of my car.
My car as an auxiliary audio input for connecting MP3 players etc. For this I purchased a bluetooth speaker adapter on Ebay for about a tenner.
It's a great device to connecting my phone for sat-nav, music etc, but there's a small annoyance in the fact that after getting in the car, it requires me to press and hold the power button for about 5 seconds before it'll turn on and connect to my phone. It's a bit of a first-world problem, granted, but it's kinda irritating, so I've been thinking about how to solve it.
Ideally, it should function like a built-in bluetooth adapter does in many new cars - as soon as the car is powered on, the bluetooth is powered on and connects to the phone.
After some experimenting with various approaches - microcontroller delays, 555 timers, I found the most functional circuit was a simple capacitor delay circuit, combined with a transistor NOT gate & optocoupler, so that the optocoupler is active, effectively holding down the adapter's power button, for 5 seconds, then switched off until the circuit loses power.
 |
| A rough schematic of the circuit I used |
|
|
Powering the circuit was simple enough - I already have a car 'cigarette lighter' to USB adapter with 2 USB ports - one powers the bluetooth adapter, and it powers on with the car ignition, so I added a USB plug to the timer circuit and used that.
Finally, I didn't want to leave exposed wires or circuit boards visible in the car - knowing my luck some paranoid idiot would freak and call the bomb squad or something, so I 3D printed a simple box enclosure which houses the adapter and the circuit nicely, the box itself nestling neatly in the centre console of my car.
 |
| The finished adapter in it's 3D printed box, ready to put in the car |
Subscribe to:
Posts (Atom)