A Burr-ee effective simple coffee bean grinder!

Firstly Hello!


It has been a really long time since I last posted stuff.  But I’m back and hopefully I’ll actually update more frequently.


Today’s post is a 3d printed device! A coffee bean grinder. It is a burr type grinder which is designed to spit out grinds that are about 1.5mm radius so it is good for a coarse grind. I’ve put the design up online and you too can download and print it here!


And you can watch a video of it here

Just a notes though the one on thingiverse is the Version II It’s different because it’s actually simplified to just 3 3d printed parts and hot glue. The version in these photos and video is the version I which has a less elegant base which was made out of failed 3d prints and had more 3d printed parts which are prone to breakage.



Experiment: potato starch

The (soldering) Iron Chef


It’s been suggested to me that all purpose flour is not the ideal candidate for a deep fry coating.  This experiment is with potato starch.


The potato starch leaves a crispier coating, and also imparts a slightly sweet taste to the chicken.  There’s no gluten being generated, so the coating doesn’t cake on the wing like a white flour would.  The downside is that this is much more expensive than white flour.  

View original post

TinyEMF Detector

The next device for my attiny85 to tackle is a tiny EMF detector. So I saw a video from Make magazine on youtube, which then linked me to another random youtuber who had originally done this for their arduino. Essentially the original user had just a single LED which was showing the EMF strength vida LED intensity, the Make guy kind of just improved on that buy using a bar graph and now in the ultimate show of one up-man-ship I decided to move this project over to the ATtiny85 because why waste all those arduino pins.

To find the original video go here http://www.aaronalai.com/emf-detector

The Make magazine article is here http://makezine.com/2009/05/15/making-the-arduino-emf-detector/

The code is here and for the most part it’s a copy of the original code

int aOut2 = 0;
long EMFval = 0;
int averaging = 0 ;
int EMFread = 1;
int sample = 25; // number of samples per read
int sensingRange = 100; // the max expected analog response
void setup() {
// put your setup code here, to run once:

void loop() {
for (int x =0; x < sample ; x ++) {
averaging = analogRead(EMFread)+ averaging;
EMFval = averaging / sample ;
//Serial.println (EMFval);
EMFval = constrain (EMFval, 0, sensingRange);
EMFval = map (EMFval,0,sensingRange,0,255);

analogWrite (aOut2, EMFval);
averaging = 0;



The difficult part clearly wasn’t going to be the code since well I copied the crap out of that. The tricky parts were the pin constraints. Now the hardware required for this project is as follows : 

LM3915 bar graph driver

10LEDS or a bar graph (I used 10 leds because I had them lying around.

0.1 uf Cap

10K resister

1K resister

2x100k resister

500K resister

1 push button


5V 1A regulator (if you want to have it fun off batteries or an unregulated supply)

9V (and battery) battery adapter (if you want to have it run on batteries)

and some wire

One you have that you can follow this schematic load up the ATTiny and go on finding some interesting fields


I just realized that I didn’t put a button in the schematic, but anyway it’s trivial pick a spot between the power or ground and connect it, that way when you press the button it’ll power up and you can see the fields.  Also I used 400k of resisters because I didn’t have any bigger lying around you can choose bigger or smaller ones based on your needs and just tune the code a bit specifically this variable “sensingRange”.

Here’s a photo of my finished product, I made it a case with my new 3d printer which I will talk about later. Image

As of yet I don’t have a video of it in action because well I didn’t know how to record it nicely, I would like to walk around home and detect things but then you’d have to view it in shakey cam, so if you want to see it in action click the links above to the original folks who did this and watch their demo, it’s essentially the same, mine is just smaller 🙂

A Tiny Light

Do you have an ATTiny85 and a shiftbright V2 sitting around doing nothing?!  Well you might not but I do.

Well I’ve got a solution to fix that! We can combine the 2 to give you a compact and relatively powerful flashlight! Now why would I want to do this other than because I need to burn parts? Well the shiftbright V2 is an interesting little thing. it’s essentially a 3 colour LED with a controller on it to set power levels and color. So you can’t just connect it to a battery and expect it to power up. It requires instruction! That is where the ATTiny85 comes in, we can use it to blast in some bits to set the LED.

You can find most of the code I used here http://docs.macetech.com/doku.php/shiftbrite to make it . (I’ll post my modified code below) . Also FYI I am coding the ATTiny using the arduino IDE.

The ATTiny85 as I mentioned before has 5 I/O pins (6 if you disable the reset pin) so in this project we’re going to use 4 of them for the shift bright and 1 for a button to toggle between pre-programmed light modes. (RED/WHITE/GREEN/BLUE/STROBE in this case).

The ATTiny85 will be determining how to change the status of the LEDS the way I did it was to time a button hold, to make sure the mode change was deliberate. what I wanted was that if you held the button down for a second but less than 2 seconds it will toggle between red/ white / green / blue, starting at red because that won’t kill your night vision too bad at night. Then if the button is held for more than 2 seconds it goes into a crazy strobe mode, good for when you want to party? I don’t know. To get out of the strobe mode Hold the button for 1-2 seconds and it defaults back to red.

Here’s a small video of it in action!

You can see the schematic below, it’s a pretty simple set up by the way the little 3 pin thing at the bottom is a 5V 1A regulator that I just realized the label is too small on.


And here is the code, again most of it is just a modified version of the shiftbright code in the above link.

int datapin = 3; // DI
int latchpin = 2; // LI
int enablepin = 1; // EI
int clockpin = 0; // CI
unsigned long SB_CommandPacket;
int SB_CommandMode;
int SB_BlueCommand;
int SB_RedCommand;
int SB_GreenCommand;
long previousMillis = 0;
long previousMillisStrobe = 0;
int buttonMode =0;
int interval = 25;
int Button1 =0;
int Button2 =0;
int buttonHold =0;
int flashmode=0;
int countup=0;

// SHIFTBRIGHT code BY http://macetech.com/blog/node/54
void setup() {
pinMode(datapin, OUTPUT);
pinMode(latchpin, OUTPUT);
pinMode(enablepin, OUTPUT);
pinMode(clockpin, OUTPUT);
pinMode(4, INPUT);

digitalWrite(latchpin, LOW);
digitalWrite(enablepin, LOW);

void SB_SendPacket() {
SB_CommandPacket = SB_CommandMode & B11;
SB_CommandPacket = (SB_CommandPacket << 10) | (SB_BlueCommand & 1023);
SB_CommandPacket = (SB_CommandPacket << 10) | (SB_RedCommand & 1023);
SB_CommandPacket = (SB_CommandPacket << 10) | (SB_GreenCommand & 1023);

shiftOut(datapin, clockpin, MSBFIRST, SB_CommandPacket >> 24);
shiftOut(datapin, clockpin, MSBFIRST, SB_CommandPacket >> 16);
shiftOut(datapin, clockpin, MSBFIRST, SB_CommandPacket >> 8);
shiftOut(datapin, clockpin, MSBFIRST, SB_CommandPacket);

delay(1); // adjustment may be necessary depending on chain length
digitalWrite(latchpin,HIGH); // latch data into registers
delay(1); // adjustment may be necessary depending on chain length
void strobe () { // This is the strobe mode, used to just switch colors of the LEDS at 25ms intervals
unsigned long currentMillis = millis();

if (currentMillis – previousMillisStrobe > 25)
{previousMillisStrobe = currentMillis; countup ++ ; // Count up tells it to switch when it’s incremented

if ( countup ==1 ){
SB_CommandMode = B00; // Write to PWM control registers
SB_RedCommand = 0; // Minimum red
SB_GreenCommand = 0; // Minimum green
SB_BlueCommand = 1023; // Maximum blue
if (countup ==2)
{previousMillisStrobe = currentMillis;
SB_CommandMode = B00; // Write to PWM control registers
SB_RedCommand = 0; // red
SB_GreenCommand = 1023; // green
SB_BlueCommand =0; // blue
if (countup==3)
{previousMillisStrobe = currentMillis;
SB_CommandMode = B00; // Write to PWM control registers
SB_RedCommand = 1023; // red
SB_GreenCommand = 0; // green
SB_BlueCommand =0; // blue

if (countup== 4)
{previousMillisStrobe = currentMillis;
SB_CommandMode = B00; // Write to PWM control registers
SB_RedCommand = 1023; // red
SB_GreenCommand = 1023; // green
SB_BlueCommand =1023; // blue
if (countup> 4){if (countup= 0);}} // the strobe mode quickly switch between all the colors then white

void loop() {
unsigned long currentMillis = millis();
Button1 = digitalRead(4);
SB_CommandMode = B01; // Write to current control registers
SB_RedCommand = 127; // Full current
SB_GreenCommand = 127; // Full current
SB_BlueCommand = 127; // Full current
if(currentMillis-previousMillis > interval) // Poles the button press at the interval
previousMillis = currentMillis;
if (Button1 == 1) {buttonHold++;}// if it was pressed increment the Button hold status
if(buttonHold <40 && Button1 == 0) {buttonHold =0;} // if the button was let fo at some point before the 1 second mark reset the button hold status
if (buttonHold > 40 && buttonHold <80 && Button1 ==0){flashmode ++;buttonHold =0; }// If it is held between 1-2s then toggle the LED colors
if (buttonHold > 80) {flashmode = -1;buttonHold =0;} // If it’s more than 2 seconds switch to strobe mode.
if (flashmode ==0)
SB_CommandMode = B00; // Write to PWM control registers
SB_RedCommand = 1023; // Maximum red
SB_GreenCommand = 0; // Minimum green
SB_BlueCommand = 0; // Minimum blue

if (flashmode ==1) {
SB_CommandMode = B00; // Write to PWM control registers
SB_RedCommand = 1023; // Minimum red
SB_GreenCommand = 1023; // Maximum green
SB_BlueCommand = 1023; // Minimum blue


if (flashmode == 2) {
SB_CommandMode = B00; // Write to PWM control registers
SB_RedCommand = 0; // Minimum red
SB_GreenCommand = 1023; // Maximum green
SB_BlueCommand = 0; // Minimum blue


if (flashmode == 3) {
SB_CommandMode = B00; // Write to PWM control registers
SB_RedCommand = 0; // Minimum red
SB_GreenCommand = 0; // Minimum green
SB_BlueCommand = 1023; // Maximum blue

if (flashmode > 3)
{ flashmode=0; }

if (flashmode == -1 ) {strobe ();}


Thanks for reading!  Heres a couple photos of it.

Attinylite Attinylite_1 Attinylite_2 Attinylite_3 Attinylite_4 Attinylite_5

Oh random fun fact, so from a typical 9V alkaline cell with about 560mAh on it, with this if you run it on white, (using all 3 colors) you should get a good 8 hours of light from it.  (60mAh for te LED and 7mAh for the ATTiny)

The Tiny Tiny Series

Before I left to do some training I had bought 25 ATTiny85’s . I still have them and I’m trying to figure out projects for them. So one at a time I will be making projects with them.

For those who don’t know about the ATTiny85 its a 8 pin micro controller. It’s a convenient, solution for very small projects, has a built in 8Mhz clock (with the clock prescaler set to 8, so effectively operating at 1Mhz), can operate with 5V supplies and upto 6 IOs (If the reset pin is disabled, otherwise has 5).

Another thing about these cores is that they can be programmed with the arduino IDE and you can find out more about it here. http://hlt.media.mit.edu/?p=1695

You can read about them here. http://www.atmel.ca/devices/ATTINY85.aspx.


OK so I’ve been away a REAL long time. Sorry I ended up getting a full time job in the Canadian Navy so I had to go off to do a bunch of training. Now that I’m back I’ll be making a bunch of things again 😀 This time hopefully I’ll be posting diagrams from Fritzing or Eagle so that it can actually be followed.

Unfortunately everyone who wanted to see Alto-Scope instructions will have to hold out until much later, probably until it gets a revisit because at this point I have no circuit diagram and the code is a mess.

DIY – How to add a 3.5mm Jack to your SB-800

Ok so recently my brother asked me to modify his nikon SB-800 flash so he could connect his wireless trigger with a 3.5mm cord rather than a PC sync (because on this sb-800 it was a flaky connection). So I decided  I’d do it and turn it into a tutorial at the same time! If you can guess by the Youtube video it was a success! So coming up is a disclaimer!

**************WARNING if you proceed with this you will void any remaining warranty******************

**************DOUBLE WARNING if you proceed with this you will be exposing yourself to potentially high voltages!************

So now that the disclaimer is done here’s what you’ll need.

A Soldering iron

A 3.5mm jack (you can get it here http://www.digikey.com/product-detail/en/SJ1-3533/CP1-3533-ND/738695 )

Some wires (find some thin ones you can pick those up at a Radio shack or something or order it also from here http://www.digikey.com/product-detail/en/3050%2F1%20BK005/A3050B-100-ND/281566)

Some solder (again you can find it here http://www.digikey.com/product-search/en/soldering-desoldering-rework-products/solder/1310838?k=solder )

A Drill/Dremel tool and a good bit to drill into plastic

A small Philips screwdriver

So in order to get into the SB-800 you’ll need to take apart the following screws there are 6 on the bottom shown in the photo in red. 

For the next set you’ll need to turn the flash 90 degrees to expose the next 4 as shown below also in red.

Now that the screws are out. STOP for a second and DO not pull everything apart things will fall and I may or may not have documented that. The first time I did it I pulled it apart and 2 metal plates fell down. As it turns out they were very important and were what held the top part of the flash together. Below is a photo of it (again look for the red) and where they are, look there and make a note of it’s orientation and take them off and put them in a nice place so they don’t fall out and you lose em. Also make note of the flash head direction and when you do pull the plastics apart make sure to not pull hard as there are tons of connectors and the flash head may fall so do it close to the ground.

Ok so now that you are carefully taking the flash apart this is where it gets dicey. HERE IS WHERE YOU WILL BE EXPOSED TO HIGH VOLTAGES THERE ARE CAPACITORS AND THEIR TERMINALS EXPOSED WATCH OUT FOR THESE. You’ll notice that as of now it’s a bit difficult to get a good look inside, that is because there are 2 connectors you need to disconnect so that the flash comes apart easier, in the photo below they are already disconnected but highlighted in blue and red are the connectors you need to disconnect.

Ok so now we have the flash apart enough to see things. The first order of business is to drill the hole (we want to get that out of the way first because we’ll need room and if you decide to solder the new connector in there you’ll have less) Here’s where I drilled mine (look for the red), Drill lower than that unless you really don’t mind squishing everything in. IF you want drill it on the front plastic and just make sure to insulate the connectors so they don’t come in contact with any of the capacitors (glue gun the terminals or something) this will make closing it up easier but it won’t look as nice.

So the next step is to solder your 3.5mm jack to the wire. I’m not sure which jack you got but here’s a diagram I borrowed from the internet http://www.talkandroid.com/wp-content/uploads/2010/06/pinout-audio1.png?3995d3 I broke the connector out for the “right speaker” connector and just connected the ground and “left speaker” because in our project the “right speaker” connection is not used in cameras.  When you have the jack wired up connect the ground to the bottom red dot and connect the “left”  connection to the  middle spot highlighted in red in the photo below .

Once you have that connected you can put the 3.5mm jack through the hole and screw/glue (depending on the connector you got) and then reverse the process. Just as a frame of reference mine looked like this.

So if yours looks something like that then go backwards and reassemble your flash and give it a shot! When you do that though just keep in mind you may need to hold down the flash while you screw the screws back since the jack maybe applying pressure to the cords heading into the flash head.

Enjoy! I hope that was informative!