Spiff's Electronics Notebook

Introducing the DuinoStamp

After working in collaboration with Justin Wyatt on his idea for a stamp-sized Freeduino, I'm pleased to introduce the DuinoStamp. It's a convenient breakout board allowing you to easily embed an Arduino compatible environment into your project. The same size as a 34-pin 0.600" DIP, it's easy to incorporate into bread-boards, perf-board, or PCBs. It contains all the components and connections you need, without including costly and large extras.

Head over to it's instructions or buy one below.

Full Kit	Board Only

New URL - store.fundamentallogic.com

Finishing our storefront move, we've changed our URL to http://store.fundamentallogic.com. All the old links will continue working, but you'll be magically transported to the correct page on the new URL.

Summer Time

Just a reminder, Fundamental Logic is closed from June 14th until June 22nd. Any orders received during this period will be shipped starting June 23rd.

We do, however, have several cool kits ready to launch when we return and lots more in the pipe!

New PCBs and Yellow Soldermask

A panel with 5 fresh new products just arrived from Gold Phoenix.

Firstly a comment on the yellow solder mask: Black, Blue, and Green are my staple solder mask colours, but it's nice to branch out sometimes and I went with a yellow mask for this order. My initial impression is that it looks OK on the copper portions of the board, but the masked bare laminate is unimpressive. While it adds variety to the lineup, it definitely looks cheap compared to even the green mask (which is cheaper) and very cheap compared to a blue or black mask. I'm left with a single-sided paper-laminate feeling.

The new projects are, clockwise from the top left:

A thermistor based high/low temperate tracker for the -5°c to 30°c range.
A 555 based high-voltage (48V to 250V) switch-mode boost supply.
An NCP1400 based 5V step-up controller. I'm not sure if I'll push this design for kitting.
The 3.3V version of the popular FT232 USB to TTL converter.
A constant current controller. When hooked between a load and ground, this allows you to set a particular maximum current level regardless of supply voltage or load variances. This is ideal for loading SMPS, LEDs, Laser diodes, etc.

Arduino and Freescale MPX Pressure sensors

Freescale makes a range of integrated pressure sensors with 0-5V analog outputs, in a vast array of configurations. Today, I've picked the MPXV5010DP, but you should be able to adapt this to a range of sensors.

]]> Physical wizardry

This sensor uses a SNSR 8pin Dual Port format, which is like a gull-wing DIP package with two ports poking out. While the gull-wing SMD package is excellent for volume assembly, it's hard to prototype; conveniently, the leads are spaced 0.100" apart, or exactly the same as standard through-hole parts.

By straightening the leads with some pliers, I was able to fit them into a pair of 4 pin female machined-headers (you may find the cheaper folded-leaf/spring variant harder to work with). Using a solder-paste with a lower melting point then the plastic headers, I assembled some legs for my sensor.

Connecting

From the datasheet we're blessed with the pin-out on page #1. If you're having trouble orienting yourself, pin #1had a little notch in it, or just follow the picture below.

Here I'm connecting the sensor to my iDuino. Pin 1 is unconnected. Pin 2 connects to +5. Pin 3 connects to Analog #0, Pin 4 connects to Ground. Pins 5,6,7, and 8 are unconnected. Obviously you could do this on a proto-sheild atop a regular Arduino or Freeduino.

Calculating the resolution.

To calculate the real-world value returned by the AtoD converter, we need to know three things: the AtoD reference voltage (a), the AtoD resolution (b), the sensor's output sensitivity (c). Once we know these three things, we can plug them into the formula (below) to calculate the number of pascals/bit.

The AtoD Reference Voltage (a)

In the below code, I'm using the 1.1V reference, but you're free to use either the 5V reference or your own external reference. (If you follow along, a=1.1)

The AtoD Resolution (b)

The Atmega168 has a 10bit AtoD converter, giving us 2^10=1024 possible values. (b=1024)

The Sensor's Output Sensitivity

Again from the datasheet we find the sensor's sensitivity to be 450mV/kPa or 0.450V/kPa. (c=0.45)

Calculating the resolution

Given our 1.1V reference, 1024 unique AtoD values, and 0.450V/kPa resolution, we come up with a formula like this (1.1 volts / 1024) / (450 millivolts/kilopascal) in kilopascal. Working out to about 0.00238715278 kilopascal/value or 2.38715278 pascals/value.

Writing some code

Theory

The basic premise is simple, we sample Analog #0, we multiply by the resolution, and we get a number in pascals. Sadly, there's one final detail, the sensor has some offset voltage, so 0 pascals actually occurs at around 0.6V. To compensate for this, the software stores the offset value and subtracts it from all readings. For longevity, this value is stored and read from EEPROM. (To set the offset, open both sensor ports to free air, wait for the sensor to stabalize, and send a 'c' over the serial port.)

The sketch outputs the number of applied pascals and the sample number.

Code

#include <EEPROM.h>

// Reading from a MPX5010 sensor
// by Kevin Bralten <http://spiffie.org>

int offset=0;

void setup()
{
Serial.begin(9600);

//setup the offset value and print it for reference
offset=EEPROM.read(0);
offset<<=8;
offset|=EEPROM.read(1);
Serial.print("Offset: ");
Serial.println(offset);

//set the aref to internal, you could use the 3.3V regulator too
analogReference(INTERNAL);

// wait while everything stabalizes.
delay(1000);
}

int number = 0; //number of iterations
int x; //fresh value from sensor
float pascals; //after multiplication

/
* based on 10bit AtoD, 1.1V reference, and 450mV/kPa
* we get 1bit = ~2.38715278pascals
*/

void loop()
{
//read the sensor
x=analogRead(0);

//convert to pascals
pascals = (x-offset)2.38715278;

//output the number of pascals and the iteration number
Serial.print(pascals, DEC);
Serial.print(" pascals @");
Serial.println(number,DEC);

//if someone sends a 'c' update the offset value
if(Serial.available() > 0){
if(Serial.read()=='c'){
offset=x;
EEPROM.write(1,offset & 0xFF);
x>>=8;
EEPROM.write(0,x);
}
}

//update the iteration and pause a bit.
number++; // to the next character
delay(100);
}

In use

I happened to have a syringe with just the right size opening for the sensor ports. Here I've connected the syringe to the vacuum port; pulling back the plunger generates a measurable quantity of vacuum. You could also extend the plunger, then connect the syringe to the pressure port; pushing on the plunger would generate a measurable quantity of pressure.

We've Moved

Welcome to our new e-commerce storefront. If you had an account previously, you'll need to re-register. Feel free to contact us regarding any orders from the old site.

New Freeduino Kits

We're pleased to introduce our range of Arduino compatible products starting with the iDuino and MaxSerial. We hope to expand this line with shields and accessories.

Build a MaxSerial Freeduino

About

The MaxSerial is a MAX232 based serial board compatible with the Arduino environment.

Buy

I'm pleased to offer these as a kit, bare PCB, and fully assembled. Use the below options to purchase with-out the optional 3.3 volt supply or explore your other options.

Full Kit	Board Only	Fully Assembled

]]> Use

Connect an adaptor with a centre-positive supply between 7 and 20 volts and connect the serial port. Your board now works like an Arduino Diecimila including auto-reset. You will find the serial connection (especially during upload) to be more predictable and stable than the transistorized serial boards.

Build a USB7

Follow along to build your own MaxSerial Freeduino.

Tools

First, you'll need the following tools:

	A soldering iron. Let's be honest, you know what the right iron for you is.
	Some solder. I suggest .040 or lower diameter. The boards have a Pb-free finish and will work well with lead-free solder (although leaded solder works just as well).
	Side clippers.
	A multimeter. It doesn't need to be awesome, it should at-least measure voltage and continuity (with beep). Resistance will help as well.
	A male to female DB9 serial cable.You'll need this to connect the MaxSerial board to your computer.
	A power adaptor. You'll need one to power your MaxSerial. Positive-tip/center-positive, between 7 and 20 volts, about 2mm ID.

Parts

Lets make sure you have all the parts.

Description	Qty	Supplier
The MaxSerial PCB. This is the backbone of your MaxSerial	1	Fundamental Logic
10KΩ Resistor.	1	Various
10KΩ Resistor.	4	Various
0.1µF ceramic capacitor. If you ordered the optional 3.3volt supply, you'll receive 11 capacitors instead of 10.	10	Futurlec C100UMC
DB9 Right Angle Female Connector.	1	Futurlec DSUBPCF9
Diode. This is a generic diode used to protect against reverse polarity. The kit includes a 1N4004, but most diodes will work.	1	Various
Electrolytic Capacitor. If you're going to use a shield, these have to be short and compact.	2	Fundamental Logic
6pin Female Header	2	Futurlec FHEADS8
8pin Female Header	2	Futurlec FHEADS8
Atmega168	1	Mouser 556-ATMEGA168-20PU
28pin 0.300 DIP Socket	1	Futurlec ICS28N
MAX232 or equivalent. Here we're using a DS14C232.	1	Mouser 595-MAX232NE4
16pin DIP Socket	1	Futurlec ICS16
2x3 Header	1	Futurlec HEADD6
LEDs in various colors	2	Fundamental Logic
Power Connector ID:2mm OD:6.3mm.	1	Mouser 806-KLDX-0202-A
5 Volt regulator. The ubiquitous 7805 is used here, but there are other regulators with the same pinout and footprint.	1	Futurlec 7805T
3.3 Volt Regulator (Optional). The 78L33 is a low drop out 3.3 volt regulator from the 78Lxx family.	1	Mouser 511-L78L33ACZ
16MHz Ceramic Resonator. This is a 3-pin resonator with integrated capacitors.	1	Mouser 815-AWCR-16.00MD
6mm Tactile Switch.	1	Futurlec TACT001

Assemble

Now that you have everything, lets assemble a MaxSerial board!

Install the 10KΩ resistor.

Bend the 10KΩ resistor's (Brown-Black-Orange-Gold) leads to almost right-angles.

Insert the resistor into the location marked R1.

Install the 1K&Omega resistors.

Bend the 1KΩ resistors' leads and insert them into the four (4) remaining locations.

Solder the resistors.

Solder all 5 resistors (10 leads).

Clip their leads flush with the PCB.

Install the diode.

Bend the diode's leads and insert it into it's holes. Make sure you align the line on the diode with the markings on the board.

Solder the diode and clip it's leads.

Install two sockets.

Install both the 28 and 16 pin sockets. Make sure you align the sockets' notches with the markings on the board.

Solder all the leads. You don't need to clip these.

Install the ceramic caps.

Install the ceramic caps into the marked locations. If you didn't order the 3.3volt supply, leave C8 empty.

Solder and trim all the leads.

Install the 5 volt regulator.

Bend the regulators leads back.

Install the regulator. Make sure you get it face up and the right way round!

Solder and clip the regulator's leads.

Install the electrolytic capacitors.

Install the two electrolytic caps. Make sure the 'stripe' is down, or the long lead is up, or align the long lead with the '+' mark on the board.

Solder the electrolytic caps and trim their leads.

Install the reset switch.

Place the reset switch in it's location. It's wider one way then the other, if it doesn't fit, try rotating it 90°.

Solder the switch.

Install the 16MHz resonator.

Install the resonator. It will work in either direction, but the outside pins must be in the outside holes, and the inside pin must be in the center hole. If you have a crystal instead, go ahead and install it, but install the loading caps too!

Solder the resonator and clip it's leads short.

Install the LEDs

Install the two LEDs, you may put either LED in either location, but make sure the long lead is on the bottom.

Solder and trim your LEDs' leads.

Install the headers.

Install the headers. If you're kit came with a single block of headers, you'll need to cut them apart now, remember, you need to cut through a hole.

Solder the headers. You may need to do some pre-solder wiggling to make them straight.

Install the ICSP header.

Place the ICSP header.

Solder the ICSP header.

Install the power connector.

Place the power connector.

Solder the power connector. You'll want to use lots of solder to keep the connector connection physically strong.

Install the serial connector.

Place the serial connector. The lugs should snap into place and hold the connector momentarily.

Solder the serial connector. Make sure you solder the lugs in place, these are the mechanical connection between the MaxSerial and the serial port.

Install the ICs.

Install both ICs into their sockets. Make sure you align the notches on the ICs with the notches on the sockets and the board silkscreen.

Install the 3.3 volt regulator. (Optional)

If you've ordered a 3.3 volt regulator, install the regulator and it's associated cap. Make sure you align the flat side of the regulator with the flat side of the board silkscreen.

Download

The schematic and board files.
The Arduino IDE

A High-Volume Atmega Arduino Programmer and Tester

I need to program several dozen Atmega168s and I only own ICSP Atmel programmers; what to do? Bodge one up of course. Best of all, the bodged programmer functions as an Arduino test bed.

]]> Starting with an Arduino platform, pull out the Atmega168 and set it aside.

Now, connect the following pins from the Arduino to a 28-pin ZIF socket:

Reset to pin 1
RX to pin 2
TX to pin 3
+5 to pin 7
Ground to pin 8
Digital 13 to pin 17
Digital 12 to pin 18
Digital 11 to pin 19

Connect pins 9 and 10 from the Arduino's (now empty) socket to pins 9 and 10 of the ZIF socket. These provide the clock signal.

Attach your programmer's ICSP connector to the Arduino's ICSP header (using a 10 to 6 adaptor if necessary). Connect the USB cable to your Arduino (with it set to USB power), or the power and serial connector to a serial based Arduino.

Insert a blank Atmega168 in the socket and use your programmer to burn the bootloader; now you may use the Arduino IDE to upload a test sketch. If all goes well, remove the Atmega, rinse, repeat.

I use the following command to burn ADABoot with avrdude (beep is a batch file that beeps the PC speaker).

avrdude -c siprog -p m168 -P \\.\com1 -u -U lock:w:0x3f:m -U efuse:w:0x00:m -U hfuse:w:0xdd:m -U lfuse:w:0xff:m
avrdude -c siprog -p m168 -P \\.\com1 -u -U flash:w:ATmegaBOOT_168_ng.hex:i -U lock:w:0x0f:m
beep

Obviously, with a ZIFDuino, you could avoid all the wiring. Even a nice breakout board would be a start.

Introducing the USB7

I'd like to introduce you to my latest idea, the USB7. 6 digits of 7 segment awesomeness all controllable from a USB virtual com port (via AVR-CDC). You send it numbers, it displays them, what could be easier?

The protocol is very simple; the device accepts a string of numbers, '+', '-', '.', space, and upper/lower hex digits (A-E). The device will buffer up to 6 characters to display. When you send a newline or carriage return (0x0A or 0x0D) the display will update with the buffered data. Any other character is thrown away. It is important to remember that decimals take up no character space because they share a digit with the previous number. This means you can't start a string with a '.', you must first send a character (even space) then the '.'.

After the jump I'll set it up to show my download speed using LCD Smartie.

]]>

So go download LCD Smartie.

In the LCD Smartie directory, we need to create a TestDriver.ini file that describes how the display behaves. Fill the file with the following snippit:

    [Test Driver]
    Init=32,10
    Fini=32,10
    CharMap=32,10

Good, now start LCD Smartie (and open the setup dialogue if you have to).

Set the Display Plugin to Test Driver. Set the Startup Parameters to use whatever virtual com port your USB7 is assigned (mine uses 22). Set the screen size to something small like 1x10. Finally set the first screen to $NetSpDownK(4) (insert an appropriate adapter number instead of 4) and make it sticky.

Here's my display showing network speed as I stream a movie.

Some other tasks it might be well suited for:

High scores on a video game server
Users logged into a terminal server
Realtime webpage hit counter
Seconds from/till an event
POS price display.
Current score on a mame cabinet
Anything else you can send to a serial port.

Finally, some source code and the schematic/board. I promise to have detailed instructions along with kits later.

Buy

I'm pleased to offer these as a kit, bare PCB, and fully assembled. Use the below options to purchase with the default colored displays or explore your other options.

Regular version

Full Kit	Board Only	Fully Assembled

With Mounting Holes

Full Kit	Board Only	Fully Assembled

Reflowing without Solder Paste

I've discovered a neat trick! Using (at least one manufacturer's) Lead-Free PCB finish, it's possible to reflow solder without the solder paste!

]]> The PCBs were ordered from Advanced Circuits with their SMOBC finish plating and I can reflow components onto them in a regular toaster oven set to ~475/500°F. I've attempted the same task with some Gold Phoenix PCB with plain old Pb finish and had no success.

So, share and enjoy, try it and let me know how it goes. Worst case scenario, you heat some chips and boards.

Update (hours later)

The PCBs survived several hours on the vibration/earthquake table, but I am able to remove the chips with sufficient sideways pressure (I can't remove the pasted chips). While I wouldn't expect failure under normal circumstances, I couldn't recommend this as a production technique, even for small time work. It could however, be used as the Post-It note of reflowing. The adhesion is good, but not too good you can't scrape it away and try again.

With the oven cranked up to 550-600°F (using a variac to surpass the oven's 450°F top end), I was able to reflow a Gold Phoenix PCB.

A max232 Based 'duino

I, and some others it seems, have spotty results talking to the "official" Arduino serial boards and their Freeduino counterparts. To that end, I present a max232 based design, complete with Diecimila layout and DTR reset.

]]> The resulting design is a double-sided board based on the Freeduino PTH and then modified to my liking. Currently, the design is still sitting in the manufacturing queue awaiting a spot on a panel, so treat as untested.

A PNG of the schematic is available; as are Eagle board and schematic files. These are labeled as V1.2

Some items of note:

The 5V regulator is a surface mount 7805DT. If you don't need to use sheilds, or you're willing to mutilate your regulator, feel free to design a PTH version in.
IC1 is an LDO 3.3 volt regulator. If you don't need the 3.3V header, you may omit IC1 and C8. If you do need 3.3v, choosing an appropriate regulator is left as an exercise for the reader.
There is a SMT cap placed on the bottom of the board below the Atmega, feel free not to populate it..
Like most Arduino knock-offs, C6 and C7 must be low-profile caps (like these) if you're going to use a shield.
This board uses the _tSilk layer instead of tPlace. I've already gone to the trouble of trimming the _tSilk layer to the board confines.

Buy

I'm pleased to offer these as a kit, bare PCB, and fully assembled. Use the below options to purchase with-out the optional 3.3 volt supply or explore your other options.

Full Kit	Board Only	Board with FT232 soldered

Restricting via placement in Eagle

Vias are a useful tool when laying out a pcb, but if there's a via in the middle of your text, the effect isn't pretty. This is an especially common occurrence when using and auto-router.

There are a few solutions to this, the easiest is not caring. A harder to execute, but similar solution is to integrate the via into your text.

Finally, in eagle, you can use the vRestrict layer to keep via's out of your text.

]]>

This board has a via stuck right in the middle of the product label. Unless it'll be renamed 'USE7' it'll need to be fixed.

The first step, using the rip-up tool is to rip-up any tracks in the affected area of the board.

Now, using the rectangle tool, select the vRestrict layer from the layer drop-down menu. Draw a box around any text you wish to preserve. Here, I'm preserving the 'USB7' name and the '08KB' production mark.

When you're done, run the auto-router again. You'll find the auto-router has kept is via's out of your protected areas. You can be proud of the refined look it gives your board.

555 based SMPS

One of my tasks involved a 105V supply voltage, and therefore a 105V power supply. This simple 555 based switch mode power supply performs nicely around 100 to 300 volts (depending on load) from a 9 to 12 volt supply.

]]>

The soul of the supply is a plain 555 driving an N channel MOSFET chopping the current through an inductor. Additionally, the 555's operating frequency (and the output voltage) is regulated by a transistor fed by a voltage-divider on the output section while an R,R,C pole sets the 555 base frequency. A fast schottky diode and a cap complete the output section. In total, the circuit uses 13 components.

From start-up, the supply achieves it's target voltage in about 40ms and quickly stabilizes with some ripple (2-4% at 100mA).

The opening picture shows the power-supply pcb being test-fit as a new kit.

Eagle Postscript Cam Job

On occasion, I etch a circuit board using the toner transfer method. This, unfortunately, usually takes several steps to go from eagle to gerber plots to printable file to printer. With this in mind, I present the postscript cam job for eagle.

Simply unzip the cam file to your cam directory. When you're ready, open the ps.cam file from Eagle's CAM tool. The result is three nice postscript files for the component side, solder side, and the silkscreen. The component side and silkscreen files are already mirrored, so just print from your post-script capable program of choice. (Hint: ghostview is a free postscript capable viewer.)