Propeller on 30m QRSS - Cont'd

My 30m Propeller Beacon is now on the air, a low pass filter was built and attached at the output pin and ground. The output of the filter goes to a 30m vertical via the SMA connector.

The filter was designed with the help of AADE Filter Design Software V4.5.

AADE - 30m Low Pass Filter Design

The Homebrew PCB was designed with Inkscape Graphics Program and produced using the Fab-in-a-Box Toner Transfer Method.

Filter PCB's Ready to Load Parts

Note to self: My Tinnit solution must be getting a little weak.

Low Pass Filter Ready to be Connected
to the Propeller Micro Processor and the Antenna

I have not tested the frequency response of the filter, or attempted to measure actual harmonic attenuation yet, but I plan do so in the next few days.

Now to see if this beacon can be heard at any of the QRSS Grabber Stations, maybe at KK7CC.

SlashCode

I plan to do more Propeller QRSS programming, I want to implement QRSS Slash Code for my station ID. Dots are send as a "/" and Dashes are "\". Note: a Morse slash character is not actually sent, it is the slant of the visual line on a QRSS Grabber that is decoded. Each slash (dot or dash) is sent for 3 seconds, as QRSS3 SlashCode mode (the default speed). For QRSS6, a dot is sent for six seconds.

My call WA0UWH in Slash Code would appear as: "/\\ /\ \\\\\ //\ /\\ ////", which is sent faster than normal visual code sent on QRSS. My call with 25 slashes (20) and spaces (5) would only take 75 seconds to be sent (one slash and space are 3 seconds).  There are no spaces within a sent character, only one slash time between characters, three between words.

In normal QRSS3 CW my call would take 165 seconds to send. That is; (2+1+5+1+1) = 10 dashes, (1+1+2+1+4) = 9 dots, and 5 spaces. That is  ( (10 × 3) + (9×1) + (5×3) ) × 3 = 162 seconds. Slash Code represents a 53.6% savings over normal QRSS CW code (for my call). At this very slow speed every second counts.


--

Propeller on 30m QRSS

As I expected, the Propeller PLL Synthesizer Phase Jitter Shows up on QRSS (see previous post). The received signal appears "fuzzy".

In the next few weeks I will continue the experiments to see if there are modes or functions that will help reduce the annoyance to an acceptable level or irrelevancy.

30m QRSS

The top signal is my QRSS "WA"  (for Washington State) and an unseen CW ID. The lower received signal is from "NM7J" (200mw) in Las Vegas, at 905.1 miles.

Note: my "A" is not a true "A", it is an open "A" without a cross bar (it was quick and easier to program).

To receive the above, I am using; a Homebrew 30m Vertical at 0 AGL, Ensemble RX, WinRAD, and Spectran, connected via Virtual Audio Cable (VAC).

I am still using only short wires for the antenna, as I have not built the necessary low pass filter for connection to a real antenna.

--

30m Beacon In The Window

Here is my 30m Propeller Beacon running in (near) the window (see previous post).

Beacon in the Window

Now it is time to do some electronic design and build a output filter so that it can be connected to a real antenna.

---

UPDATE
I thought by this time I would have some examples of received signals from my Beacon, but my HF rig, audio link, sound card and software is not working. I need to spend more time with the problem.

I will be very interested in how much Propeller Processor PLL phase noise will be present. Will it be objectionable on QRSS?

For now, the received signals would have to be received by my own receiver, as the power level is too low and the Beacon is without an outside antenna.

--

30m Beacon - a 20 min Effort

So how easy was it to Program a CW and QRSS FSK Beacon with the Propeller? See previous post.

Well here is the code of the Main program, followed by the supplied Synthesizer Library. Note: in the Propeller "Spin"Programming Language, line indents (i.e., TABs or spaces) are important. They define the programming constructs for loops and other structures.

The Main Program

CON

  _CLKMODE = XTAL1 + PLL16X
  _XINFREQ = 5_000_000

  RFPin  = 27

  ReceiverDial = 10_138_700
  TuneOffset   =      1_300

  Frequency = ReceiverDial + TuneOffset          'DC to 128MHz


VAR

OBJ
  Freq : "Synth"
  
PUB Main | i
  repeat
    ' Send my Call via CW
    sendCWstr(string("de WA0UWH"))
    delay(2000)

    ' For fun, Generate 5 QRSS tones
    repeat i from 0 to 4
       sendTone(50+2*i)
       delay(3000)
       noTone
       delay(3000)

    delay(12000)

PUB delay(ms)
  waitcnt(cnt + clkfreq/1000 * ms)

PUB sendCWstr(stringptr)
  repeat strsize(stringptr)
      sendCWchr(byte[stringptr++])

PUB sendCWchr(char)    'A lookup Table of CW character

  case char
   " ":
    noTone
    delay(700)
    return

   "A", "a":
    dot
    dash
   "B", "b":
    dash
    dot
    dot
    dot
   "C", "c":
    dash
    dot
    dash
    dot

    . . . .

   "9":
    dash
    dash
    dash
    dash
    dot
   "0":
    dash
    dash
    dash
    dash
    dash

   "@":
    dot
    dash
    dash
    dot
    dash
    dot

  noTone
  delay(300)   ' Delay between each character

PUB sendTone(tone)
  Freq.Synth("A",RFPin, Frequency + tone)

PUB noTone
 Freq.Synth("A",RFPin, 0)


PRI dot
    sendTone(50)
    delay(100)
    noTone
    delay(100)


PRI dash
    sendTone(50)
    delay(300)
    noTone
    delay(100)

Here is the supplied Libaray

PUB Synth(CTR_AB, Pin, Freq) | s, d, ctr, frq

  Freq := Freq #> 0 <# 128_000_000     'limit frequency range
  
  if Freq < 500_000                    'if 0 to 499_999 Hz,
    ctr := constant(100 << 26)      '..set NCO mode
    s := 1                             '..shift = 1
  else                                 'if 500_000 to 128_000_000 Hz,
    ctr := constant(010 << 26)      '..set PLL mode
    d := >|((Freq - 1) / 1_000_000)    'determine PLLDIV
    s := 4 - d                         'determine shift
    ctr |= d << 23                     'set PLLDIV
    
  frq := fraction(Freq, CLKFREQ, s)    'Compute FRQA/FRQB value
  ctr |= Pin                           'set PINA to complete CTRA/CTRB value

  if CTR_AB == "A"
     CTRA := ctr                        'set CTRA
     FRQA := frq                        'set FRQA                   
     DIRA[Pin]~~                        'make pin output
     
  if CTR_AB == "B"
     CTRB := ctr                        'set CTRB
     FRQB := frq                        'set FRQB                   
     DIRA[Pin]~~                        'make pin output

PRI fraction(a, b, shift) : f

  if shift > 0                         'if shift, pre-shift a or b left
    a <<= shift                        'to maintain significant bits while 
  if shift < 0                         'insuring proper result
    b <<= -shift
 
  repeat 32                            'perform long division of a/b
    f <<= 1
    if a => b
      a -= b
      f++           
    a <<= 1

This 30m Beacon is running on; a Parallax Propeller, a 9Volt Battery, and two short 3 inch wires for the antenna.

--

A Propeller for Christmas

I got a VERY unexpected surprise for Christmas, . . . even though I ordered it for myself.

I have been playing with micro processors for the last few months, with the idea that at some point they will control my beacons or other Amateur Radio Projects and Devices. So far, I have been using the Arduino and Teensy micros for most of my exploration and learning.

One of the Blogs that I follow is Wardy's Projects, he posted about a new device for him. It is the Propeller from Parallax. My initial reaction was; yeah, right, . . another "me-too micro". And, it was made by same people that made the Stamp? The Stamp is one micro that I just never got around to exploring. But, as per Wardy, the Propeller promises to have some interesting capabilities that I would find useful.

Note: while writing the post, the Parallax site appears to be down, what's with that!

After doing a little more reading/research, I decided to order a Propeller "Gadget Gangster" it was about $50.00 and it appeared similar to the Arduino Shield that I had been using. I picked up the order at the post box on Christmas eve.

Some of the attributed of the Propeller Micro Processor that I though would be interesting, are:

• The processor has 8 cores, known as COG's, each is an independent processor which can run it's own code.
• The master clock can run up to 80mHz (or much slower, to save power), and some people over clock it even faster.
• Each COG can control two Frequency Synthesizers, from DC, to an amazing 120mHz.

Some of my concerns were; it does not use "C", it has it own languages called "Spin" and "pasm", although Spin looks a little like "C", . . . it's just another new language to learn.

The Propeller Processor looks like it maybe an ideal Amateur Radio RF Frequency Synthesizer, just ideal for my planned Transmitters, Receivers and Beacons. The raw Propeller Chip is available in DIP and SMT format, for about $8.00.

It took a bit to get the Propeller running (i.e., I am familiar with the Arduino, which obtains its power from the USB cable). By adding a 9Volt Battery and Clip, the hardware installation was complete. Installation of the Propeller IDE software was easy, a download and a few mouse clicks. It did not run, under WINE on my Ubuntu system, it ERRORd with something about the USB could not find the ports. But, there is a download for Linux and it installed quickly. The example and library directories are easily found in the MS directory structure of the first install that I did under WINE.

I clicked on the Frequency Synthesizer example, and its required library, which were loaded into two source TABs on the IDE GUI.

The source files were short and simple, I could see in the source file where "they" set the desired frequency, so therefore, with a quick edit, I picked my favorite frequency: 10.14mHz (typed as "10_140_000", the compiler ignores the under-bars).

I pressed F11, an ERROR! The compiler could not find the USB, pressing F7 fixed the problem. Pressing F11 once again --- out of the speaker across the room came a TONE!!! I had my HF receiver set for upper sideband on 10.1387mHz (the normal QRSS and WISPR receive frequency). - IT WORKED !!

My very unexpected Christmas surprise? - It was so simple.

After modifying the programs a little, I now have a Beacon sending my Call sign with CW, and sending multi-level FSK QRSS signals. Before going live with an antenna, I will need to build a low pass (or band pass) filter for the output. Currently it is just; a Battery, the Propeller, and two short 3 inch wires for an antenna.

And just think, I am only using one of 8 COGs and one of the 16 frequency synthesizers on the processor! I can do a lot more with this thing. Spin is going to take some time to learn, but I think I can like it.

The only downside that I currently see is the Propeller is not 5v TTL, it is a 3.3v CMOS processor. If real TTL levels are necessary; an input 5v TTL can be connected via a 4.7K resistor, for output a TTL driver circuit maybe necessary, and yet some TTL device will work with the CMOS 3.3v output.

I am just getting started with this thing. I am going to have fun with my Propeller in the coming mouths, . . .

Thanks to Wardy, and Santa!

--

My Small Projects

The past few years, I have been working on my own Homebrew Amateur Radio projects, some are of my own design, and others are from; published schematic, from books, blogs or other sources. Most of my projects are small 9Volt QRSS Transmitters, Receivers, Beacons, or Audio Devices.

Lately my devices are becoming smarter as I include micro processors as part of the project. Most projects work very well, and yet, a few have been real flops. For example, when I crossed the input to the output lines on a PCB layout of an Audio Amplifier, it became an unintended-single-frequency-screaming oscillator.

Building Homebrew projects is one of the major aspect of Amateur Radio that I enjoy. In my much younger days, I built everything with the Idea doing QRO (high power) and getting the biggest 1000 watts on the air that I could afford. But, now my goal is to use as little electricity as possible.

My major contribution in my projects, is that; I enjoy making them as small as possible. When asked: "why try to make them so small?" Well, it is something like; "there are clock-makers, and there are watch-makers, I do it for the challenge".

After seeing some of my small projects, several people have asked; "would you sell one?". So far, I have not wanted to part with any of my Homebrew toys.

Well, maybe . . .

I have considering making a few of my Projects available, to anyone that would enjoy the novelty of them. To start, I could produce a few (to test the level of interest). The first few will probably be; completely Built and Tested. Later I may make Kits available if there is a demand. The Kits would only be for people that are looking for a microscopic building challenge and have the right tools.

Remember, the circuits that I plan to sell are "not anything new" and are things that "you can make yourself", using a PCB, "Manhattan", "dead bug" or "ugly style" of construction. But, you may find it a challenge to get it as small as my projects. That is what I plan to sell - the unique smallness.

The First Available Project

Initial Project

The first project that I have available, is the Micro-FM Transmitter (MFMT), as described in my previous posts, and which is a project inspired by Mark VandeWettering - K6HX of the braninwagon.com blog.

The original author of the circuit probably did not expect to see the circuit in this small form factor. The original circuit was Tetsuo Kogawa’s Micro FM transmitter.

I have additional ideas for this circuit, and soon they may show up here.

The MFMT PCB has been shrinking, in this latest revision, it only measures 0.5 x 0.5 inches. My initial blogged version was on a larger board (see the above photo). Moving the phone jack to the back side of the PCB allowed the board to shrink by about 1/3rd. Future revisions maybe even smaller :-) Most parts are now 0603 or 0805 SMDs. The double sided boards are designed with DipTrace and are being produced by DorkBotPDX.

Now For Sale - Revision Three
Ready to be mounted on a Battery
with Double Sided Tape

The MFMT uses a single SMT 2N3904. The output can be heard on a standard FM receiver on 107.5mHz (or near there). The jack and input accept stereo, but the resulting transmitted signal is mono. The usable range is about 30 feet. Which is more than enough to play my Cell Phone tunes on my car radio while driving. But yet, it is at such low power and the antenna length is so short, that I think it is well below any FCC requirements for licensing.

MFMT - Microscope View

This is my view through the microscope of the MFMT PCB, hand soldering at this scale is a little difficult. The 2N3904 is the center black rectangle and the resonate coil and variable capacitor is shown in the upper left. Audio come from the backside connector via the two summing resistors at the lower center. Battery connection is lower left, the Antenna is upper right. The Dime is for scale :-)

Resonate Coil and
a Needle Point for Scale

As can be seen, there is still open space for potential over all size reduction. But that will take many more hours of PCB layup time, and maybe even smaller parts.

See my "For Sale Page", at:
http://wa0uwh.blogspot.com/p/forsale.html

My goal was to make the MFMT available as cheap as possible, but without a facility for mass production it is still expensive. The first few are only for die-hard collectors that can help fund a start up.

I am not selling just the circuit's function, I am selling that function in a small size. Larger devices that will do the same function, will undoubtedly be much cheaper.

More to Build and Test

For now, I am only making Complete and Tested units available.

If you are interested, check the availability on the FOR SALE page, and reserve yours via e-mail, first come, first served.

If this all goes well with this initial offer, you may see more of my little projects listed.

---

Update: Nov 21, 2013
Walt sent me the following link that described a VERY Small FM Transmitter:
http://engineering.columbia.edu/smallest-fm-radio-transmitter-0

--

Island of Shells - Cont'd

Ignore this post if you are only interested in Electronic or Ham Radio.

This post is Way-Off-Topic for my blog, but I want to record my observations for others to review.

See/Read the previous post for details.

Photos were taken, Oct 1999, Click on photos for larger view.

I found my photos of the cliff on the island, and have stitched them together. This and the original photos does not do the area justice.

Stitched Photos of Island Cliff

When standing next to the cliff, the layers are more much visible. 

The upper levels show the different shorelines and their collection of shell.

The Top of the Cliff

Layer and Shoreline at Different Levels

This shell was found in the
lowest level, it is not broken

Other Interesting Shells are
Found at The Base of the Cliff

On the Right,
The End of the Oldest Layer Exposed

Anchored Just Off Shore

Now - Back to Ham Radio.

--

Island of Shells

Ignore this post if you are only interested in Electronic or Ham Radio.

This post is Way-Off-Topic for my blog, but I want to record my observations for others to review.

About ten years ago, while cursing Puget Sound looking for interesting islands and shores to anchor, explore, and spend the weekend. I found an very interesting exposed cliff on the end of a small Island.

I took photos and have always wanted to stitch them together to create a large composite, I may yet if I find the photos.


The following is my recollection of what I saw.

The exposed cliff appeared to have been shaved, cut, or eroded off of the narrow end of the island, exposing a cross section of the layers that make up the island. The cliff rises about 60 feet from base, near the current shoreline. The width of the base is maybe 200 feet.

What I found most fascinating was the obvious eons of the exposed time. There are evidents of about fifteen different shorelines, each with its own population of different types of shells, or the lack there of.

All of the layers get thinner as the layer gets closer to the center of the island.

The oldest (lowest) shoreline contain the most shells, with corral, cockles, and scallops among the items found. The shells appeared thicker than any on the upper layers. Near the current edge of the island this shell layer is about 20 inches thick and containing mostly just shells. The low end of this layer is exposed near the shore by current wave action.

Above the first layer, is a band (maybe 10 inches) of sand, it appears to be volcanic ash, without shells, or any signs of life.

Then another layer (maybe 6 inches) of different type of sand, with only short spiral shells, maybe from a tube worm?

The previous two layer types repeat a few times, with different thickness.

Above that, layers contain an obvious shoreline and associated seashells, but if I remember correctly they were different than any found in lower layers. Their shells appeared to be much thinner.

Each layer of the cliff is text-book cross section of what I would expect of a seashore.

New shorelines appeared to raise in major steps, as the successive layers move up and inland toward the center of the island.

This type of shoreline repeats, several times, up the outer edge of the narrowing cliff, with each successive shoreline further up and inland.

The top of the cliff is the current soil and vegetation layer which is about 60 feet above sea level, it appeared to be about 2 feet thick on top. This top layer is thinnest low on the sides near the water (sea level).

What I find interesting it appeared the island grew from top down (i.e., it was NOT pushed up) and therefore the shells that are most readily picked up, at the foot of  the cliff, are the oldest, and yet they appear to be in perfect shape. If the island grew from the top (as new soil is deposited) then that implies (to my untrained eye) the Ocean and Puget Sound was once as much as 60 feet higher. Again implying, the oldest shells are maybe very-very old.

Yet,  maybe the island sank in jumps, laying new sediment over old and changing the shoreline, and then was pushed up to the current height over a very short period of time. But I do not think so, as the shelled cross sections of the shorelines would not have the same distinctive shapes.

This island is a Sheller's Paradise, with perfectly shaped very-old shells to be easily found.

I think this is one of the most interesting island of Puget Sound.

The island is a semi-popular boaters-only destination, but I do not think many people understand what they are seeing.

I plan to release the location of this island, if I find someone with credentials and interest enough to explore and date the layers. But, so far I have not found that person, and I have avoided any disclosure of the islands name to avoid plundering.

If I find the photos and able to stitch them together, I will post them with a link back to here.


So,  now back to - Electronics, Ham Radio and On-Topic.

--

A Small Part Quest

It is the journey or the quest, and not the destination, that keeps life interesting.

Server years ago I started a goal or strategy for my self, by attempting to build my projects as small as possible, using the smallest parts that I could find. But, one particular part has been problematic, that is, I have a problem with the size of the available "1/8 inch stereo jacks".

My early projects contained stereo jacks from Radio Shack or other sources, they were big, clunky and were mostly the panel mount style, they have a large foot print when mounted on a PCB. Some jacks have built-in switches, which is nice but I seldom use.

My quest has been to find a much smaller - 1/8 inch (3.5 mm) stereo jack.

EBay - USB Sound Card

I noticed there are two very nice small stereo jacks used in the very small USB sound cards, which are available from eBay. These small USB sound cards can be purchased for as little as $0.75 each. I have been using these sound card with headphones on my desktop computers.

Because I had purchased several extra USB sound cards, I decided to try to salvage the stereo jacks for one of my small projects. With a lot of time and work, I finished with two slightly mangled jacks.

The Desired Stereo  Jack
found in USB Sound Cards

The difficulty was the small spacing between jacks on the sound card made it extremely difficult to; cut-out, de-solder, or remove the six through hole leads from their small circuit board. The non-lead solder makes the task just that much more difficult.

The image suggests it is a SMD, but the installed jacks in the USB Sound Card are through hole, with small vertical pins. Once removed, I generally cut the pins very short to set-on and solder to SMD pads.

Project Using
Salvaged Stereo Jack

Here is one of my previous projects, using a salvaged part. It is a very small 30m FSK and CW Transmitter, all mounted on the side of a 9 Volt battery.

I liked the obtained salvaged part, because of its very small foot print. I decided to try to obtain new similar parts from the normal suppliers.

But, all I had was my contrived description of what I wanted. Searches through Mouser and other suppliers did not provide help. They had larger parts, and I settled for the smallest part they had, I purchased several.

Mouser Stereo Jack
PN 161-4034-E at
$0.75 in lots of 100

In the drawing, the Mouser parts looks small, but it is actually about 50%  larger than desired. The part used by the USB Sound card must be available from some vendor. But I did not have a part number to help with the research. I searched my standard/normal Local and Chinese suppliers. Again, lack of a part number, made it difficult.

For about a year, several projects were created and laid up with the much larger Mouser parts.

Only recently, did I inadvertently come across a part number of the desired small part on a published product schematic/drawing, it is - PN MJ4435-R.

Now I had something to find. My favorite part search engine is FindChip, which indicated the part was available from Newark at $2.76 each. Dang, I am not willing to pay that much for the jack, when I could salvage two from a $0.75 USB Sound card.

So, back to the drawing board and lay up of PCBs with the larger Mouser part, or I would have to continue to spend time salvaging parts from USB sound cards.

Recently I created a small project that I am thinking of selling. For it, I want the best parts available. The size of the board is smaller than the available stereo jack from Mouser. I will have to bite-the-bullet and purchase the part from Newark at $2.76 each. That, of course, makes my product just that much more expensive. I attempted to placed an order for 10 parts, but then . . .

The BAD News is; there is a $20 surcharge on the order as this part is supplied and shipped direct from a non-US factory. And, there is an additional sales tax on top of that (all of this could make these little parts very expensive).

But, the GOOD News is; during checkout, I noticed that the price is $2.76 for a package of 5 parts !! ( a detail that I missed before). That will make the individual parts much cheaper than expected.

It is more than I wanted to spend (for my initial product parts order), but instead of 10, I ordered 100 stereo jacks from Newark, just to keep the individual price as low as possible. My cost for the stereo jack will be about $0.85 each.

It could be argued that the Mouser part (number 161-4034-E) at the same price is of better quality, but there is a lot to be said for simpler (which I think is a more elegant design) of the MJ4435-J part, which exposes its complexity on the outside and hides nothing on the inside.  I would think the simplicity and unique design of MJ4435-J parts should sell in the US for around $0.40 ea. Especially as two are sold with each USB Sound card that sells for very little money.

So with all of that, and if all goes well, you my soon find an interesting little product, available here, with a very small stereo jack.


So, the quest goes on, for yet, ever smaller parts and small projects.

--

Strategy for My Homebrew Projects

I have used protoboards (white plug boards) for as long as I remember, in fact most of my Homebrew projects start-out on a protoboard, and from there usually end up on a custom Homebrew PCB.

In the past, I only had a few expensive (typical $30) protoboards to share with new and old projects, and therefore dismantling older circuits was always necessary. My typical protoboards were the fancy ones with a metal backing plate and banana plug terminals, and of course all of which is un-necessary. Actually, only the raw protoboard is necessary, see a previous project.

My previous final Homebrew projects rarely resemble the original; rats nest of wire on the protoboard, nor the required 1/10 inch spacing for headers. Therefore, once prototyping was complete all further circuit development or testing was done directly on the target Homebrew PCB.

That is going to change:

All  of my new Homebrew PCB projects will be laid out with the protoboard in mind as the potential target usage. All headers will be laid out on 1/10 inch non-overlapping grid (i.e., along each side) as required for use with the protoboard. In the final project, the headers holes can be filled with Male pins on the top or bottom side, or with Male-Female stacking adapters as seen in some Arduino Shield products. This strategy will allow interesting combination of assorted projects on a single protoboard or as stacked sets (again, similar to that of the Arduino Shields).

I foresee a future Homebrew Transmitter, Receiver and maybe a Beacon Controller all stacked together to make a fun combined project.

Note: I will still continue my overall strategy of creating the smallest Homebrew projects that I can for as long as I can, but the projects may now be a little bigger to allow for the new header placement strategy. I still enjoy building very-very small and dense projects, the smaller the better!

In support of this Strategy:

Recently I discovered a relatively inexpensive (~$8) source for full size (clear) protoboards from Adafruit (their nomenclature is: breadboards), see:

https://www.adafruit.com/products/239

They also have half size (white) boards, for $5:

https://www.adafruit.com/products/64

UPDATE: I found the half size (clear) protoboards at SparkFun for $5.95:

http://www.sparkfun.com/products/9567

Bulk Male-Female (stacking) headers or more difficult to obtain, I have only found them available from the Chinese manufacture in lots of a million. But they are available in a package of; 2 each 8 pin and 2 each 6 pin headers for $1.50, also from Adafruit and SparkFun. They can be carefully cut apart, or joined to create other size headers as necessary.

https://www.adafruit.com/products/85
http://www.sparkfun.com/products/10007

Male pins are also available as:

https://www.adafruit.com/products/392

https://www.adafruit.com/products/400
or
http://www.sparkfun.com/products/10158

I found jumper wires with Female ends attached, I cut them in the middle, using each end for battery and other device connections:

http://www.sparkfun.com/search/results?term=jumper+wire+-+0.1&what=products

Coin cell holders are useful on small projects:

http://www.sparkfun.com/products/10592

I have looked for other similar sources for all of the above, these are easy, and the links are provided here for my future reference.

Note: I am not a agent or associated with Adafruit nor SparkFun, I just need/use their products.

UPDATE: My Friend Larry - KB7KMO thinks he has a link (somewhere) to bulk Male-Female (stacking) headers, I am waiting his search.

--

Rising Sun

Thanks to Scott Harden for sharing this link via Google+, it is a link to a MUST see Video for young Engineers. Our thanks to the author for creating it.

(Not My Shop)
Click on photo to see the attached YouTube Video
or at: http://www.youtube.com/watch?v=w68qZ8JvBds

--

My Goto E-Tools

The following are the e-Tools that I most often use.

There are many reasons why each e-Tool was selected, too many to list here. I know a few of the tools have their (own) problems, but in my opinion, they are the best e-Tool for their function that I have found.

• Gmail - My e-mail client.

• Google Voice - Manages my contacts and forwards calls and voice-mail to my current cell phone (I do not have a normal land line phone).

• Blogspot - Used for all of My Blogs.

• Google+ - Still learning and playing with this.

• Dropbox - This is the most recent and BEST addition to my e-Tool belt. It is a place in the cloud for storing ALL of my projects, files are shared and sync'd to all of my other computers and cell phone. It is as easy to use as any normal file system directory. Most of my other e-Tools use this space in one way or another.

• Google Chromium - Web Browser of choice.

• DipTrace - Circuit Capture and PCB Layout.

• Simsmith - Electronic Filter Design with Smith Chart Graphics.

• Inkscape - General Drawing Program.

• Gimp - Photoshop style photo manipulation.

• Picasa - Photo storage, mostly used for online photo storage, for photos used within my blogs. I am still waiting for Picasa to provide a real directory structure before committing many other photos. For now, Dropbox provides the desired (normal directory) function.

• Google Sketchup - For 3D Models.

• Google Docs - A place to save my text documents and for collaboration.

• Google Reader - News Reader.

• Arduino IDE - Software Development for micros.

• WINE - Under Ubuntu (my OS of choice) WINE provides an environment to execute the few MS programs that I use. Unfortunately, WINE does support MS dotnet 4.0 yet.

OK, I admit it, . . . I use a lot of Google products.

--

Arduino IDE 1.0 Released

Arduino IDE 1.0 has been released (previous rev was known as 0023). The release notes provide insight into the new functionality. It will be interesting to see if I can use this new capabilities in my Ham Radio Projects.

To be compatible and consistent, Teensyduino, Version 1.06 was also released.

I have not downloaded either yet, as I am in the middle of a Multi-day Timing Test on my Teensy GUI Protoboard, but will download soon.

--

DipTrace Survival Guide

Compilied From My Use and Observations

By: Eldon R. Brown

Dec 2, 2011
Update: Aug 2, 2012 - DipTrace 2.2.9 Beta
Updated: Aug 12, 2015 - DipTrace 2.9 Beta

Update - Aug 2, 2012: Note I have not explored all of the Changes provided with DipTrace 2.2.9 Beta, I will make further correction/additions as I experiment. So far I am pleased with the progress - Hats off to the DipTrace Devs.


I have been using DipTrace for several years and have recommended it to many new users. Most of the projects, Schematics and PCB's documented within my blog have be created with DipTrace. This Survival Guide it a collections of my Opinions, Use Tips and Techniques.


I will try to Expand and Update this Guide, as new software revisions are released, and when I have time. Occasionally I will repost this, when signification changes are made.


The main reasons that I use DipTrace are:

• Ralative Easy to Learn
• High Resolution Cross Hatch Copper Pour
• Consistent High Quality Exported Gerbers
• DipTrace Runs on MS, and Linux via Wine (Linux is a must for me)
• Low Entry-Level Price
• Easy to Edit Traces - Added via DipTrace 2.2.9 Beta

The few things that I DO NOT LIKE about DipTrace:

• Library Management and It’s Use is Miserable!
• Automatic Edit Modes Always Picks the Wrong Defaults - Fixed DipTrace 2.2.9 Beta
• Lack of User Defined Softkeys and Macros - Partly fixed in DipTrace 2.9 Beta
• Lack of Project Management Tools, and the Hard Coded Internal PATH to Related Schematics contained within the PCB file makes it difficult to; move or archive related design files.
• Auto Route does not use the same grid that Manual Route user has access.

The following are my Survival Suggestions and Observations learned while using DipTrace.

• There are only four magic spots to select and move a VIA, they are at the 3,6,9, and 12 O’clock positions. The magic points are slightly off of the pad, experimentation is necessary to find them. - Fixed DipTrace 2.2.9 Beta

• To select the Ground Pour, you must select it only at the edge, even though it appears on large areas of your PCB.

• To update a part Pattern on the PCB layout,
• Clone (or obtain) a new pattern into you private Active Library
• Edit and save the Pattern as necessary
• Edit and save the offending part within your Private Active Parts Library
• Attache the modified Pattern to the part
• Delete Connections from offending Part within you Schematic
• Insert a the new part into the Schematic
• Connect wires as necessary
• Save the modified Schematic
• Edit the PCB
• File -> Update From Schematic ->
• Reposition (new) modified part as necessary
• Reroute Part Connected Traces as necessary

• With very small traces and parts it is sometime necessary to move the part to access underlying traces. - Fixed DipTrace 2.2.9 Beta, The Trace Edit mode does not change when clicking on a trace under a part.

• It is best to do hand routing, as the auto router does not use the same grid as you have access, therefore it will be difficult to make small change and make your circuit consistent.

• When doing route modification, Rat Line additions has highest priority. There constantly watch and reset “trace modify” mode as necessary. The mode does not stick. - Fixed DipTrace 2.2.9 Beta

• You may find it difficult to consistently move a board point, the priority mode is “point addition”, press “CTL-Z” as necessary to remove the unwanted point.

• Due to the lack of custom softkey, many tasks such as “un-Route Trace” and “Auto Route Trace” can be found in the right click menu, but the two menu items are not next to each other, and therefore you will need to learn the menus.

• To avoid trying to fix a difficult routed “Trace” it is sometime easier to create a second (and simpler ) manageable trace before deleting the original. - Fixed DipTrace 2.2.9 Beta - Edit mode stays set

• When moving parts on the PCB, remember that the mode often switch to “Rat Line Add” mode, “Escape” will return you to part select mode. This happens often, therefore for speed you should place your left hand (hover) near the Escape key. - Fixed DipTrace 2.2.9 Beta

• Lock Net mode does not avoid the “Net Add” process, it only increases the clicks and dialog to escape from - i.e, a net productivity loss. - Fixed DipTrace 2.2.9 Beta - No longer a problem

• The supplied Pattern and Part Libraries as difficult to “Brows” and therefore if you do not know the nomenclature use in the library of a spacial part, it is sometime much easier to create your own part. Simple standard parts are sometimes very difficult to find, for example try to find a 3-pin FAN header. - Many more parts in DipTrace 2.2.9 Beta, more investigation need.

• The default mode for both PCB and Schematic is to add parts from the active Library, be careful not to to add unexpected hidden parts. Here again, pressing the Escape key often generally avoid the problem.

• Because DipTrace does not maintain a Schematics and PCB’s as a project, and because it has Hard-coded Links from the PCB back to the Schematic, It is best to plan you project directory structure before starting.

• If you move a Project (Schematic and PCB files) remember the Hard-coded links will still point to the original directory space. Modification of the links in the PCB files can be corrected by “re-associating” (updating from Schematic by Reference”. Or if you are clever, and do not mind “text” editing the PCB source file, the Hard-coded link to the Schematic can be change.

• For easy access to your private Library of Parts and Patterns, move your library to the top (and which is left) of the LIB list. Note there is not an easy way to move the appended (bottom of the list) Library except one click at a time for each library in the list (actually it takes two clicks, one to select and one to exchange adjacent Libraries). It may take several minutes to move a library from the bottom to the top. Avoid the problem, put your Library at the END of the list, as default for an added library, just remember where to look.

• Component placement rules do not appear to observe a shortest trace placement strategy. Many times two schematic parallel parts will be place with crossed nets. Also, Power and ground nets can not be ignored for auto placement.

• A useful strategy for manual placement, is to hide the Power and Ground nets, place adjacent schematic parts together, move them into position as a group. 

• Do not modify PADs on the PCB, an update from the Schematic will remove your changes. Modify the Schematic Parts with the Correct PAD information for the Project.

• There are about 2500 3D parts within one single (file system) directory, take a hour (or two) to sort like parts into sub-directories for easy and quicker access (accessing or just listing the directory repeatedly takes a lot of CPU time).

• The Schematic and PCB Title Options only includes two automatic fields; “file name”, “sheet name”. Other useful information must be manually included, for example: “Date last updated”, “Project Directory Name”, “Revision Number”, “Creator or Editor Name”, default “Company Name”, “Related Schematic file Name”, Pins Used, Layers Used, etc, etc.

• For Documentation, each time Print Review is used the options must be re-setup, options are not saved from previous use.

• Before having a PCB created, it is best to verify each of the Schematic part’s Attached Pattern. Because the Pattern is not one of the “optional” labels that can be printed on the Schematic, it is necessary to inspect each part’s Properties, or right click on each and then click on “Attached Pattern” and change it as necessary.

• DipTrace does not support "Targets" for assistance in Top and Bottom layer alignment. A useful Technique is to use circuit "Edit -> Panelizing" to print extra copies of the same circuit for alignment images, a 3 by 3 panel provide corner images for the single center image alignment.

• As Time Permits, I will update this with more DipTrace Survival Tips.

UPDATE:
A very nice tutorial has been created by a user on the EEVBlog Forum, See: http://goo.gl/bMp6m

DipTrace 2.2.9 Beta is available at http://www.diptrace.com/downloads/dipfree_beta.exe


--

Teensy Clock Fixed

Paul - the creator of the Teensy has provided a software update (Rev 1.04), that fixes the clock problem that I observed (see previous post) After a 24 hour test, my Teensy has only gained about 1 second (as compared to a wall clock) that is only about 11 ppm error, which is good considering ambient temp and generic 16mHz cpu crystal.

Another test with a known good reference clock is necessary for more resolution.

Thanks Paul, for your efforts to provide a fix.

--

Teensy Programming Shield

I had some time this morning to install the headers on the Teensy Programming Shield which I just received from the FAB Shop (see previous post). With plated through holes, soldering of parts (headers) is much easier than experienced with Homebrew double sided boards.

Headers Installed

Bottom

Top

--

DorkBotPDX in Portland

Monday night Jeff - KO7M and I attended the 7-11pm  DorkBotPDX meeting in Portland, there were many projects available to review and interesting people to meet.

An unexpected pleasurable encounter was with Paul - the creator of the "Teensy", which is the cpu board that I have mentioned in previous posts (see search label: Teensy). Paul also, video taped some of the high lights of the meeting. My GUI Development Board and 9 Volt Micro Transmitters can be seen.

http://youtu.be/seyTMkTGZ3E

It was a great meeting, even thought I did not get back to Seattle and home until 3:30am, I plan to attend often.

--

Teenys Clock Trouble

The only time I have had to work on other projects was late a night. My Teensy (an Arduino work-a-like, see previous posts) has been giving me fits. The clock is FAST by about 24 seconds per 6 hours. All previous efforts to correct the problem resulted in No Change.  Jeff - KO7M and I had some time to review my progress (or lack there of) and found that the Teensy does not use the same Clock file (wiring.c) as used by the Arduino (I was modifying the wrong file), in fact it not even named the same under the Teensy directory structure (pins_teensy.c).

void TIMER0_OVF_vect()
{
        asm volatile(
                "push   r24"                            "\n\t"
                "in     r24, __SREG__"                  "\n\t"
                "push   r24"                            "\n\t"

                "lds    r24, timer0_fract_count"        "\n\t"
                "subi   r24, 256 - %0"                  "\n\t"
                "cpi    r24, 125"                       "\n\t"
                "brsh   L_%=_fract_roll"                "\n\t"

        "L_%=_fract_noroll:"                            "\n\t"
                "sts    timer0_fract_count, r24"        "\n\t"
                "lds    r24, timer0_millis_count"       "\n\t"
                "subi   r24, 256 - %1"                  "\n\t"
                "sts    timer0_millis_count, r24"       "\n\t"
                "brcs   L_%=_ovcount"                   "\n\t"

        "L_%=_millis_inc_sext:"
                "lds    r24, timer0_millis_count+1"     "\n\t"
                "sbci   r24, 255"                       "\n\t"
                "sts    timer0_millis_count+1, r24"     "\n\t"
                "brcs   L_%=_ovcount"                   "\n\t"
                "lds    r24, timer0_millis_count+2"     "\n\t"
                "sbci   r24, 255"                       "\n\t"
                "sts    timer0_millis_count+2, r24"     "\n\t"
                "brcs   L_%=_ovcount"                   "\n\t"
                "lds    r24, timer0_millis_count+3"     "\n\t"
                "sbci   r24, 255"                       "\n\t"
                "sts    timer0_millis_count+3, r24"     "\n\t"
                "rjmp   L_%=_ovcount"                   "\n\t"

        "L_%=_fract_roll:"                              "\n\t"
                "subi   r24, 125 - %0"                  "\n\t"
                "sts    timer0_fract_count, r24"        "\n\t"
                "lds    r24, timer0_millis_count"       "\n\t"
                "subi   r24, 256 - %1 - 1"              "\n\t"
                "sts    timer0_millis_count, r24"       "\n\t"
                "brcc   L_%=_millis_inc_sext"           "\n\t"

        "L_%=_ovcount:"
                "lds    r24, timer0_micros_count"       "\n\t"
                "subi   r24, 256 - %2"                  "\n\t"
                "sts    timer0_micros_count, r24"       "\n\t"
                "brcs   L_%=_end"                       "\n\t"
                "lds    r24, timer0_micros_count+1"     "\n\t"
                "sbci   r24, 255"                       "\n\t"
                "sts    timer0_micros_count+1, r24"     "\n\t"
                "brcs   L_%=_end"                       "\n\t"
                "lds    r24, timer0_micros_count+2"     "\n\t"
                "sbci   r24, 255"                       "\n\t"
                "sts    timer0_micros_count+2, r24"     "\n\t"

        "L_%=_end:"
                "pop    r24"                            "\n\t"
                "out    __SREG__, r24"                  "\n\t"
                "pop    r24"                            "\n\t"
                "reti"
                : 
                : "M" (TIMER0_FRACT_INC), "M" (TIMER0_MILLIS_INC),
                  "M" (TIMER0_MICROS_INC)
        );
}

Teensy Clock Code from Original File

The Teensy Clock file is "pin_teensy.c", which is mostly written in Assembly Language. I unfortunately do not know Assembly Language well enough to make modification to attempt to correct the Clock. Jeff suggested we replace a section (the clock) with known working "C" code from Arduino.

The first attempt included a section to try to slow the Clock by an amount equal to the previously observed error. After 6 more hours, the clock was NOW slow by about the same amount as it was FAST before. Jeff suggested we remove the correction and obtain a new base line with just the "C" code installed.

SIGNAL(TIMER0_OVF_vect)
{
 // copy these to local variables so they can be stored in registers
 // (volatile variables must be read from memory on every access)
 unsigned long m = timer0_millis_count;
 unsigned char f = timer0_fract_count;

 m += MILLIS_INC;
 f += FRACT_INC;
 if (f >= FRACT_MAX) {
  f -= FRACT_MAX;
  m += 1;
 }
 
 timer0_fract_count = f;
 timer0_millis_count = m;
 timer0_overflow_count++;
}

Copied Arduino Clock Code

Due to the work in the Shop (listed above) I did not get back to the Clock project for 29 hours. After 29 hours, the base line results indicated that the Clock was spot-on, only less than a second difference could be observed when compared to a wall clock. Wow!

But, the "C" code replacement did something to the "Interrupts" for the Teensy, my push buttons no longer work as expected. We damaged something by removing the Assembly Language code. More investigation will be needed.

For now, I have reverted to the Assembly Language Clock routing, so that all of my GUI development environment works correctly, but with a Clock that runs a little fast.


UPDATE: The new release of Teensyduino 1.04 fixed the problem.

--