Training Wheels before I mess with the KILN

You see,   I have a SKUTT 8 kiln for working with PMC (precious metal clay).  It’s a nice kiln and all bit it doesn’t have what I would call good temperature control.  This got me thinking… rather than spend $300-$800 dollars for a professional kiln controller… I could use the Arduino to make my own.  Seems simple enough…  I thought.  Well, the KILN draws over 15 amps and after a little research,  I realized that there was this thing called Proportional-Integral-Derivative feedback control systems… and if I were smart… (I try)  that’s what I would be using to control temperature over and undershoot.  PMC clay is rather particular about temperatures… and quite expensive… so there is little room for mistakes.

So… initially I need  to build a similar controller for my Toner Transfer laminator as a dry run.    Lower temperatures and current… so I can test my theory on something that won’t burn down the house.

The first step in that process is to build a breakoutboard… since the MAX6674 is a small surface mount package.  Here is the result:

Arduino’s know how to multiply

So,  I just counted…   I now have 5 Arduino boards.    These little toys are just so useful.

By far the coolest add-on I picked up so far is the Arduino Ethernet shield.  This device is based on the Wiznet W5100 and it makes connecting to the wire a breeze with low Arduino overhead.  You see, I made the mistake of trying to use the ENC28J60 Ethernet chip.  A nice chip and Guido Socher did a great write up about it at TUX GRAPHICS… (http://tuxgraphics.org/electronics/200606/article06061.shtml)  but you need to create the TCP/IP stack in software… that’s surely flexible… but not a very nice way to leave you some ram in your Arduino for what you ant it to do.  I got frustrated with the ENC28J60 (I’d built a break out board)  and just ordered the ETHERNET shield from NKC electronics.  (Nice purchasing experience from NKC,  and a real fine supporter of the Arduino community by the way)

Wow.  This board is well made, well designed and simple to use.  This opens up all sorts of neat possibilities.  I just need to figure out which one gets priority.

Time on my hands…

Someone in the Arduino forums mentioned they were having troubles with their Single Sided Arduino board that they built on their own.   It reminded me that I wanted to make one for myself.  I needed an extra Arduino I could use for RS485 testing and a NON-USB one was preferred.

What a great afternoon project this is.  I took the toner transfer PNG file and printed it out so I could use the laminator to do a toner transfer. Once it was etched I could really see the benefit of having a silkscreen on the topside… the trouble is, I’ve never done a board with imagerey on top.   I first tried using a heat transfer…  just like I did with the copper side but I had no luck.  After 10 times through the laminator I still had no luck bonding the toner with the fiberglass side.  (I sort of figured that would happen…)

I remembered that I had some 8 1/2 by 11 blank decal sheet on hand and thought maybe I could float the silk screen  side decal onto the surface.   OK… having never done this  before I’m going to now admit I was a bit overconfident,  this is really not easy.

Eventually I got it applied.  I lost a few bits here and there, but the important parts didn’t tear off.  I wanted to coat the decal with FUTURE floor wax but I could not locate the bottle I had for this purpose.  It would be a good idea though.

Anyway… here are the results.  Powered it up and loaded a sketch…  Yippie.

Feeling kind of damp – The SHT-11 and Arduino

As a part of my ongoing project and seemingly never ending interest in what’s going on outside my window, I purchased a a PARALLAX humidity and temperature sensor.  Basically, the Parallax part is a surface mount  Sensirion Temperature/Humidity Sensor nicely mounted on a PC board that has 8-PIN DIL pin out for insertion into a solder-less breadboard.

It’s available from MOUSER and from PARALLAX directly.

To get it working, the circuit itself is dead easy.  The Parallax part has additional SMD pullups and capacitors right in the 8-pin DIL package so we are only dealing with a few wires.  I don’t even need to really show a schematic… the details are in the code.

The code is not really my own creation at all.  It is a collection of good ideas from others who have already dealt with this device.

RS485 with Automatic Transmit Enable

Here is a simple RS232-485 converter for the PC serial port I developed with the help of a Circuit Cellar article by  Jan Axelson about RS485 interfacing.

It uses a 555 as a monostable to enable the transmit mode only when “sending”.

It’s a pretty basic circuit and nothing special is really happening here other than the portion involving the LM555 timer.  The termination jumpers allow the 120 OHM termination on the master node as well as the balancing termination resistors connected to +5V and GND.

There were only minor changes throughout development.  For example, originally the indicator LED’s were ON unless sending since they were tied to GND.  Now then go LIT when sending, which is more intuitive, I suppose.

Here is the circuit:

Here is the board Layout:

PCB Design:

Completed board:

Overall this was an Easy Project.

And yes, this is a HOMEBREW toner transfer method PC board.  The DRAWING package is NOT EAGLE but rather ABACOM SPRINT LAYOUT and ABACOM SPLAN.

More on Serial Ports

(Please note: None this applies to LINUX.  Linux is much smarter about “devices” IMHO)

When testing out an idea, it sometimes a lot easier to write a little tidbit of code in PERL to do some concept verification.

Case in point:  I’m developing a a protocol to run over a RS485 bus and need to “act” like a master host from my PC.  Now I haven’t got the MASTER host code written yet and getting a protocol tested from a Serial Terminal program is tedious so I needed a quick way to send oddball strings.  PERL to the rescue…  and then I hit the brick wall.

I tested the code with stationary PC that has a “real” serial port on the motherboard.  It worked as planned so I went to the LAB table where I have a laptop (with no built in serial) and I tried the code.  I have an IOGEAR 2-port USB to SERIAL adapter on that laptop but I had not until then tried to access the device with PERL.

I am using the PERL module WIN32::SerialPort(0.19) and I kept getting “can’t open port” error messages.  I was not getting these on the other PC.  The only difference was that the IOGEAR USB-RS232 adapter was now using COM ports 13 & 14.   When I changed the PERL code to read COM13, it broke.

Here is the fix:

my $myPort = 11;

# COM PORT

# Deal with ports higher than 9
if($myPort < 10){
 $myPort_Str = "COM".$myPort;
  print "low port: $myPort_Str\n";
  } else {
 $myPort_Str = "\\\\.\\COM".$myPort;
 print "high port: $myPort_Str\n";
}

I guess Microsoft never imagined you would have more than 9 serial ports.

Ports 10 and Higher will not respond to being called “COMx”.  You need to use the following naming method: “\\.\COMxx”.

So when I open the port, I use:

my $port = Win32::SerialPort->new($myPort_Str);

This way, you can use higher number ports that would by default have the system saying, “sorry, port doesn’t exist” .   USB-RS232 drivers have a tendency to assign ports higher than COM9.

Serial Ports & User Interfaces

Serial Ports

The Arduino, the Basic Stamp2 and other similar development tools often use the Serial Interface for communicating with attached computers. This is clearly the most efficient and cost effective method since it requires very little overhead, unlike using ETHERNET or Radio Communications, etc.

Creating a user interface for these devices with either a Linux or Windows PC is as simple as writing a terminal program that drives a custom GUI. I could use Visual Basic or C if I wanted stick with windows. To be really flexible, I could use a language like Perl, Python or TCL/TK.

So I did some research. I really like the way TCL/TK works. It understands that you might want to interact directly with the operating system. It has not forgotten that we love our serial ports. In essence, I think TCL/TK is ideal for working with PC’s and micro-controllers via the serial port.

On the other hand, the serial port seems to be destined to become a legacy item. While the Arduino now uses a built in USB-Serial bridge on board, getting connected to the communications port that the USB creates is sometimes a little tricky. You see, serial ports were historically considered to be physically part of a machine. Why would you even need more than 4 or so, right? Now, with the USB, you could easily have many more than 4 since the USB port needs to avoid the potential of stepping on physical ports.

Many Microsoft programming languages and API’s had built in support for up to 9 serial ports. If your USB-Serial bridge created COM11… you might run into trouble writing code to access it. Another problem, many of the freely available terminal programs have limited support for high com ports. Some actually stop at COM4.

Back to TCL/TK

This scripting language is mature and just plain cool.  Few scripting language solutions let you take Graphical User Interface  code written for a UNIX platform and plop it unchanged on a Windows platform (with TCL/TK installed) and have it run… with no modifications.  There is also a solution that wraps the “interpreter”  and script into and executable so a system doesn’t really have to have TCL/TK installed.

TCL/TK is available on the PC for Windows as well a Linux.  This amount of flexibility is really interesting to me.  Being able to use either with practically the same code means that I don’t  have to decide immediately which platform I’m coding for.

Barometric Pressure

While looking at low cost pressure sensors in the Mouser Electronics catalog,  I located the FREESCALE MPXAZ6115A as a possible sensor for my project.  The sensor has the following statistics;  Device: MPX6115,   MAX PSI   16.7,    MAX kPa 115.

Since barometric pressure here hovers at around 100kPa or so,  this sensor would do just fine.  The analog output of the sensor is relative to the min/max pressure range of the sensor.

According to my initial tests, the sensor would output about 4.06 volts at 100kPa.

The built-in analog input on the Arduino would also keep the circuit simple and after a few tests I was able to determine the offset value I needed to get correct readings for the localized barometric pressure.

Here is the Arduino Code:

// Nominal Transfer Value:

// Vout = VS x (0.009 x P – 0.095)

// ± (Pressure Error x Temp. Factor x 0.009 x VS)

// VS = 5.1 ± 0.25 Vdc



float Vin;

float P;



void setup()

{

Serial.begin(9600);

}



void loop()

{



Vin = (5.0/1024.0) * analogRead(0);

Vin = Vin + 0.11;                  // Offset Adjustment

Serial.print(Vin);

Serial.println(" Volts");



P=((Vin/5.0)+0.095)/0.009;

Serial.print(P);

Serial.println(" kPa");



Vin = (P * 0.2952999);

Serial.print(Vin);

Serial.println(" Inches of Mercury");



delay(2000);

}

I’m using a LADYADA Boarduino on a solder-less breadboard for testing.  The sensor hookup is dead simple with only one exception that makes it tricky.  The part I selected is designed to be surface mounted.       I decided to create  a carrier board using the board layout software I prefer called SprintLayout  from ABACOM in Germany.   Other than 5V power and ground connections, the Vout from the carrier board goes directly to the Arduino Analog(0) pin.

To create the PCB board, I use the GOOTIE toner transfer method to apply the layout on the PCB for etching.  (google search “gootie  PCB” for more info)

Having developed a dislike for the chemical etchant that Radio Shack sells; Ferric Chloride, I have also adopted the etchant that Gootie describes.   It is based on the swimming pool chemical Muratic Acid and Hydrogen Peroxide in a 1 to 2 ratio.   It’s fast, non-opaque and does not require heating or excessive agitation.

Note: I also recently picked up a used GBC Creative Laminator at the local Goodwill for $14.00.  It does an excellent job of applying the toner to the copper on the PCB to be etched.  Using an hand iron was OK, but the results were not always predictable.

Here is the Layout:

This is the Component side view  or “TOP VIEW” through the board and “yes”, the sensor is actually underneath on the copper side… so the pin out is upside down in this view for that part.

The layout file is here: Pressure.zip

I used  0.100 spaced right angle pins so the board actually sits vertical in the breadboard.

The parts and schematic used are directly from the manufacturers data sheet.

The test program output looks like this:

4.10 Volts
101.65 kPa
30.02 Inches of Mercury

Results:   Complete success.

Weather project

I have this idea that it would be really nice to keep track of the weather where I live.  I know that I can just turn on my TV and watch the Weather Channel but I’m really more inclined to come up with my own technology solution.

I simply want my own personal weather station.  I already knew that  I didn’t want to dedicate a PC  for a weather data collector.    If I keep a PC on all the time just to collect data means I’m NOT collecting data if I lose power.  If I use a battery powered micro controller, keeping the battery trickle charged from a wall outlet,  I would still be collecting data during storms where the potential for power loss is high and when the data being collected is useful.

Being a big fan of micro-controllers, I’m looking  into the Parallax BASIC STAMP or the AVR-Based Arduino as a quick way to test out some ideas for weather data sensors.

I learned during my research on the subject that nearly ten years ago Dallas Semiconductor had created a showcase for their 1-wire sensor products in the form of a simple weather station.  The Dallas weather station has a Wind Direction Vane, a Wind Speed Anemometer and a temperature sensor.

After a quick trip to EBAY.com,  I soon won an auction for a unit of my very own.  It turns out that I bid on one of the Original Dallas Semiconductor units.  This is somewhat of a complication as this version did not see as many units built as the “version 2″ model built by AAG of Mexico.

All this really means… is that I’m going to have to write a lot of my own code from scratch instead using of what I could find “as-is” published in “NUTS & VOLTS” magazine by the Basic STAMP guru, Jon Williams.

The primary differences between the first model from Dallas and the following AAG model is the fact that the Wind Vane section uses an Analog to Digital converter with a potentiometer instead of magnetic reed switches and silicon serial number chips.

On my unit, when the wind vane moves a magnet inside the unit.  This moving magnet closes magnetic reed switch(es) that supply power to 1 or 2 of  the 8 Silicon Serial Number devices.  The 1-wire master device will search the 1-wire bus and depending on the serial number sent by the device(s) that respond… the position of the wind vane can be determined.

Any solution I come up with needs to constantly search the 1-wire bus and then check the responses against a pre-built table to determine wind direction.  It also means that I need to know, in advance, which serial number corresponds to each of the 8 compass directions.

This method does make the version 1 weather station more complicated to setup and monitor.  My first tests are going to be done with the Parallax Basic Stamp2P version.  The “P” version has more capabilities, including direct support for 1-wire bus devices.

Example Wind Vane response list:

1E00000273822601
3700000273B16F01
540000020057CC01
AE0000020057D401
720000020057D001
FB00000273790101
2000000273AB3401
BD00000273823D01

Notice that each serial number ends in 01.  This is the ID section of the number that identifies the device as a  Silicon Serial Number device.

Temperature sensors would look like:

5B000000261EB010

So, once we have a temperature sensor ID, we can then send a query to that device ID and ask for a temperature reading.

The real beauty of 1-wire technology is that it really only needs  two wires (signal and ground) to create a small “network” of devices that can each be queried uniquely.

Dallas Semiconductor was eventually aquired by Maxim Semiconductor.  In 2001, Dallas Semiconductor became a wholly owned subsidiary of Maxim Integrated Products.  This also seems to be beginnings of a period where things start to get very quiet on the 1-wire front.  Sure, there were still 1-wire products being developed but from the software development standpoint things started to get stale.

Dallas focused alot of attention on JAVA, for example, but the developer tools are now very out of date.  They did some C# too but you’d have to locate a really old C# compiler to make use of it.   This means that as a PC based 1-wire developer your will  need a huge amount of overhead and code bloat just to query a simple 1-wire device for the temperature.  When you consider that you can get a micro-controller to do this with a few lines of code… you might come to the same conclusion I did.  Let’s chuck the PC and JAVA and do it the simple way.

With the Basic Stamp 2P, the 1-Wire™ devices are supported with two easy-to-use commands:

OWOUT pin, reset, [output data]

OWIN pin, reset, [input data]

The choice for me was simple.    I’ll follow up with some examples.

Starting over from scratch…

“Floobydust” is a contemporary term derived from archaic Latin miscellaneous, whose disputed history probably springs from Greek origins (influenced, of course, by Egyptian linguists) — meaning here “a mixed bag.”

So,  here is yet another web log.  Of couse, I start “blogging” when blogging becomes considered to be something we did “yesterday”, but here I am.  Actually, I’m just looking for a convenient method to share my ideas and plilosophies.  Arriving late is better than not even trying, I suppose.