Got a request to build a sensory board and figured I’d share it here. It’s one of my few woodworking projects that needed to have a good fit and finish and I feel that it came out pretty nicely. It’s an assortment of fabric materials and touchable items that are good for children to explore for sensory experience. The board itself is a piece of cabinet grade maple ply, with a red oak banding. I went with rabbeted corners on the banding because I don’t quite trust my current setup for doing miteres, something in my saw is getting sloppy. Anyhow, I think it turned out not too bad.
I like to have some tunes on when I’m out riding and the way I’d been doing it was to squeeze a set of headphones under my helmet, run a cable down to my phone in my pocket, and control volume and track by pressing the side buttons through my jeans. Not the best solution, and often when wearing gloves it was next to impossible to tell where the buttons were.
My answer was to try out one of these ebay bluetooth modules. For around 7$ these things can pair with your phone to provide audio output as well as a way to hook up custom play/pause/back/next buttons. The version I got was called a XS-3868 but they all seem to be based on the OVC-3860 chipset. My idea was to stick one of these in a project box and hide it somewhere on the bike, then run wires up for a place to connect the headphones and come up with some sort of handlebar switches for changing tracks.
The schematic is nothing special, the only notes are that the regulator section was replaced with one of these modules. On ebay they can be had for under 2$ a piece and they just simplify voltage sourcing so much. Last time I ordered some I got a 10 pack 🙂 The other note is that some filtering had to be added to the switch inputs. The GPIOs on this board only draw about 40 microamps at 1.8v, it’s awfully easy to pick up stray voltage that’ll trip those once you have a cable attached of any length. So there are 1uf caps in parallel with 4.7k resistors close to the module to help filter out unwanted inputs.
So the schematic looks all well and good, and the module looks pretty, but they came together to make something much much uglier…
I did attempt an an etched PCB layout for this board but the fine pitch on the module made it very difficult to get it soldered down without shorts, so that was abandoned and instead the module was stood off from a piece of copper clad board and fly wired down to a set of pads that I cut out with a dremel. It started off crude, and got even worse when I realized that the extra filtering was required for the switches. Cramming those in was not easy.
But the project box hides all sins, and even the project box will be hidden under one of the bikes side covers, so that’s good enough for me.
For the control switches, I’ve taken the smallest die cast aluminum project box I could find and put three push button switches in it. I used two black zip ties pulled through holes in the rear of the box to attach it to the handle bars, it actually came out alot cleaner looking than I expected.
I also routed the audio connection under the tank to a spot that I could connect my headset to but I since it turns out that all of the controls work whether the headset is plugged into the phone or into the bluetooth module, so I’ll likely just leave them plugged into my phone. It’s audio quality is better anyhow, and it’ll reduce the chances of me ripping something off when I inevitably forget to disconnect before getting off the bike.
My wife was looking for some wooden animals for her daycare kids to play with. It didn’t sound hard so I found a used scroll saw on kijiji, printed out some templates, taped them to some 3/4″ pine board and started cutting.
They definitely aren’t hard to make, but they do take up a boatload of time. If you want to make these yourself be prepared to put in some earbuds, get a comfy chair, and spend the next few hours zoning out lining up blade with line.
I probably wouldn’t go with the 3/4″ board again though. It made for some nice solid pieces, but it also made it very easy to snap blades.
And of course if you’re going to have animals, you need to have a barn for them. 🙂
This one’s just a quick post to show off my experience with the Farmhouse Table plans from Ana White’s page. It’s a nice, straightforward design which goes together reasonably quick and uses affordable lumber (in our particular locale).
The one tip I’d have for building this table in Ontario is that if you’re buying box store lumber (Home Depot, Lowes, etc) be careful about selecting the right stuff. The cheap framing lumber that works for this table is usually “SPF”, which means it’s a potential mix of spruce, pine or fir. When I bought the stuff for this table it was all quite nice pine, but I know that in previous years they’ve had lots of ugly, cantankerous spruce. Haven’t run across fir yet…. in any case, I’d recommend purchasing some samples before you get started and ensure it’s the good stuff, and that it’ll retain it’s shape well.
Another thing I would consider if I was building again, would be to trade the 2×6 table top for a 1×6 or some other 1xX wood. The 2×6’s are extremely solid but man does it ever make this thing heavy! The table top alone it over 100lbs. It was quite a job getting this thing in from the garage.
Anyhow, here are some pictures.
The stain I picked was Minwax Jacobean, it was a nice dark stain that matched the decor in our dining room reasonably closely. It does a really good job of disguising the cheap lumber in this piece, although the more woodworking I do the more I am learning that what adds the most value in a piece is the amount of time spent on the finish. An unfinished version of this table can be whipped together easily in one day, but to get this looking like something I would want in my dining room took well over a week of sanding, coating, and drying cycles.
I’ve been working with some AD9850 ebay modules that are serving well as function generators, but they’re a bit limited output power wise. I needed something to boost its signals into the 1/4 to 1/2 watt range and the designs at SM0VPO’s page look to be pretty close to what I need.
Building off the design posted at the very bottom of the page, I’ve come up with my own board based on SMT parts because apparently I have a masochistic need to work with 805 components, but also because it would meant that even with the clumsiest layouts I could still fit it into the small die cast aluminum project boxes that I like.
Using the toner transfer method and the HCl+H2O2 DIY etchant process I had the PCB laid out in just a couple hours, it’s not the prettiest board but it should do the job. I’ll post the eagle files at some point for anyone who’s interested… though it can very likely use some optimization… 🙂
Part placement went not too but there was one rather significant hangup. I had two types of transistor on hand, some BC847 and some 2SC4081. I thought I was placing the 847s, which would line up with SM0VPO’s design, but it turns out I was actually placing the 2SC4081s. This might have been a waste of time but I figured it was worth a go.
When the board was fired up and fed a 1Mhz signal it did manage to amplify but it had a pretty distorted output. With the biasing set the way it was it seems like these little chips weren’t able to do what I was asking of them.
I ended up swapping out these little guys for some higher power capable 2n4401 chips that I had to scrounge around for. I also added a pot for the biasing on the input transformer to see if I could tune in a little better. The emitter resistor also needed to be changed out. The value stayed the same but it turned into a 1/4W axial style in order to better deal with the power dissipation, even if only during my messing around with biasing values. Perhaps on revision 2 I might actually get a full SMT version of this amplifier, but this will do for now.
Here’s the whole package put together and in it’s new home.
With a 0.5 Vrms input I get about 3.3 Vrms output (both into 50ohms), so that’s not a bad performance for a rev A boards I’d say 🙂
In the summer of 2012 I went on a great motorcycle trip. On my trusty old 1981 KZ750, myself and a few friends headed north in the general direction of Sudbury. It was a great trip with a lot of really excellent sights and increasingly twisty roads as you head North. Through about 800 km of riding everything went quite smoothly, but an unpleasant thing happened when we were just north of Barrie on the ride back. I was noticing that something was sounding slightly off, and my suspicions were confirmed when I tried to catch up to the bike ahead of me and there was no power to get me there. After doing some roadside diagnosis, it was clear that I had a dead cylinder. Back at the garage the full tear down showed that one of my exhaust valves had stuck open and got a nasty bend in it. Thankfully it didn’t break right off, so apart from a small dent in the piston the engine was otherwise unharmed. This was likely due to overheating as a result of a low oil condition. I guess all the high RPM freeway riding had eaten though a lot more oil than I was expecting.
Anyhow, this was a lousy thing to have happened, and it likely could have been avoided or at least mitigated if the bike had some method of indicating its engine temperature, (this is assuming I’d pay more attention to a gauge than I would to my oil level.. 🙂 ) This seemed like as good a reason as any to build something. I looked through my pile of assorted boards and quickly stuck together a Netduino Plus, a Nokia 6100 LCD Shield, and some TMP102 temperature sensors to do some experimenting.
This was a reasonably good setup, but it would need some changes if it would be useful on the bike.
1. The TMP102 wouldn’t do the job. They’re good sensors, but their temperature limit is much lower than alot of the temps they’d have to deal with in the engine. These will get replaced by a pair of MAX 6675 thermocouple amplifiers and some K-type thermocouples
2. The netduino plus is big. If I wanted something small enough to potentially mount on my handlbars I’d need it shrunk down, so it’ll get replaced by a Netduino Mini stuck on a custom PCB to accommodate some of the additional bits and pieces needed to run this off the bike’s 11-15 volt supply.
Here’s the circuit and PCB layout that I eventually ended up with.
There are two voltage regulators, one to bring the bike’s voltage down to the 8v for the netduino, and another to provide the 3.3v needed for the LCD and the sensor digital parts. There are a couple of discrete parts tied to the unregulated input voltage that divide it down and clamp it to a safe level before passing it in to an analog input, this is for showing the bike’s charging voltage while running, an added bonus.
Here’s the final etched PCB with all the components placed. It ain’t pretty, but hey, it’ll be in a box 🙂
And here’s the whole arrangement with the LCD installed, powered up with the display showing the running info. The silver ring at the top of the picture is one of the k type temperature probes, these ones are meant to fit under a 14mm spark plug.
I did finally end up putting this in a project box and riding around a fair bit with it strapped to my handlebars but eventually it was removed for a few important reasons. One, it’s hard to see in sunlight. That little LCD just can’t compete with a nice sunny day, and as it happens, that’s when I prefer to do my riding 🙂 Two, it’s ugly. The project box I crammed this thin into is quite…boxy, and there weren’t really any good places on the dash of the bike to clamp it. It rode around in my tank bag window for a while, but that wasn’t the most convenient of places either..
It served it’s purposes though, after rebuilding the engine in the bike I was able to install this thing and monitor for at least the first few rides to ensure that it wasn’t going to blow up a second time, and more importantly it gave me a project to fiddle with in my spare time.
Had a few modules kicking around that I ordered on a whim a while back. Figured it’d be worth making something interesting out of them as an excuse to learn a little more about i2c. Slapped together this board with a couple of sensor breakouts on it and stuck it on the back of a Netduino Plus. I like the netduino boards because they’re hardware compatible with the arduino shields, but being able work in C# makes them a little more familiar. The sensors are a Bosch BMP085 barometric pressure sensor and a HTU21D. The HTU21D is on a Sparkfun breakout board, the BMP085 is a 3$ ebay dealie. Forgive the ugly solder job.
The idea is to stick this board in various locations around the house and see how the temperature and humidity vary throughout the day. Want to get an idea of just how dry it gets in this place during the winter and how well the furnace pushes the warm air around. This board will quietly log all of these items in a csv file on the SD card installed in the Netduino.
It took a fair bit of monkeying around but I managed to get two fairly useful classes for reading from both of these sensors. The I2C methods came from the library referenced in this post. The logic for the BMP085 sensor was modified from this Arduino specific tutorial to create the Netduino version.
I’ve posted the source in a github at for anyone that might be able to make use of it. The code might not be pretty but it might help if you’re trying to deal with either of these two sensor modules on the Netduino platform.
The data logs pretty well, the only thing I might need now is a real time clock module though because right now all I can record is the relative time from the board booting and beginning to log.
|Temp Sensor1||23.05||Relative Humidity||29.3546143||Barometric Pressure||97889||Altitude(m)||290.07|
|Temp Sensor1||23.20||Relative Humidity||28.5993042||Barometric Pressure||97891||Altitude(m)||289.90|
|Temp Sensor1||23.14||Relative Humidity||27.9889526||Barometric Pressure||97897||Altitude(m)||289.38|
From time to time me and my closest friends like to have a good bout in IL-2 Sturmovik . Despite being released in 2001 this game still seems to be the go to sim for online fighter battles. The one thing that always irritates me is keeping track of my key mappings while preoccupied with trying to fly a plane. There’s nothing worse than lowering your gear in the middle of a turn or worse, accidentally dropping the only bomb you have in the wrong place because you hit G instead of B…especially if the wrong place is 20ft above your own runway, where you’d normally be raising gear. Anyhow, to solve this problem I built this.
It may not be pretty but it should do the job. It gives me 5 way selector switches for flaps, potentiometer sliders for mixture and pitch control, missile still switches for…missiles I guess :), and a few switches for things like gear and ignition.
The guts are fairly simple, it’s all straightforward IO wiring into a Sparkfun Arudino Pro Micro. I made a poor choice here though, I bought the 3.3v version, which happens to run at 8Mhz instead of the 16Mhz that the 5v version does. This shouldn’t really have been a problem but I was making use of the Leojoy package to get this working and, despite being an excellent package, it came with a couple of snags.
If you’ve got a 3.3v pro micro (or potentially any 3.3v/8Mhz leonardo based board) you’ll need to take a couple of steps to get it working.
1. Install the leojoy package following the instructions included with it. Once its installed you should be able to build, compile, and upload your sketch to the board using the “LeoJoy!” board type, however when it resets after loading you’ll get a “Unrecognized USB Device” error, and the device will show up as a disabled “Unknown Device” in your device manager. To fix this:
2. Add the entry below to your .\arduino\hardware\leojoy\boards.txt
############################################################## promicro8.name=SparkFun Pro Micro 3.3V/8MHz Leojoy! promicro8.upload.protocol=avr109 promicro8.upload.maximum_size=28672 promicro8.upload.speed=57600 promicro8.upload.disable_flushing=true promicro8.bootloader.low_fuses=0xff promicro8.bootloader.high_fuses=0xd8 promicro8.bootloader.extended_fuses=0xfe promicro8.bootloader.path=caterina promicro8.bootloader.file=Caterina-promicro8.hex promicro8.bootloader.unlock_bits=0x3F promicro8.bootloader.lock_bits=0x2F promicro8.build.mcu=atmega32u4 promicro8.build.f_cpu=8000000L promicro8.build.vid=0x20A0 promicro8.build.pid=0x41B2 promicro8.build.core=leojoy promicro8.build.variant=leojoy
This will add a “SparkFun Pro Micro 3.3V/8MHz Leojoy!” entry to your list of boards in the arduino IDE. This entry is a copy of the one that comes with the sparkfun addons for their versions of the pro micro but with the “name”, “vid”, “pid”, “core”, and “variant” fields changed to line up with the LeoJoy board configuration. The VID and PID change is what allows the device to be identified as a HID device on connection. The “core” option is what points the compiler to the LeoJoy set of code files on compilation.
3. Open up .\arduino\hardware\leojoy\cores\leojoy\USBCore.cpp and replace this line:
PLLCSR = 0x12; // Need 16 MHz xtal
#if F_CPU == 16000000UL PLLCSR = 0x12; // Need 16 MHz xtal #elif F_CPU == 8000000UL PLLCSR = 0x02; // Need 8 MHz xtal #endif
It seems that in the version of the core that leojoy was compiled with there still wasn’t the support for the 8Mhz crystal option.
After making these two changes you should be able to upload the sketch to your board and have it show up as a game controller.
Hopefully this helps anyone else out there hung up with the 8Mhz version of these nifty boards.
It was a snowy lousy day here which was a good excuse to stay in and play with the Pi I had kicking around. I used the software and instructions from the package located here . Whipped together a lowpass filter that could be plugged in easily for the 20m band. Powered the package with the battery from my old IC-02AT and a LM2577 based module to get the voltage right for the Pi.
Here’s all that junk together before it went in the bucket.
This was all tossed in an kitty litter bucket to keep the snow out and taken out in the backyard. A quick and dirty 20m dipole was strung up between a couple of trees a few feet off the ground. In the picture you can just make out the bit of red signal wire strung to the the 1:1 balun that the bucket ties into.
I really wasn’t expecting much from this 2 hour cobble, but the result was actually quite decent. From my QTH in Waterloo I reached out to as far as Edmonton, Dallas, and the west shore of Florida.
A pretty neat little project for a Friday afternoon.