How To Effectively Check A PCB Schematic

[stextbox id=’info’]The following is a sponsored post, brought to you by Altium and Mil-Max.[/stextbox]

When you design a printed circuit board, you often begin with creating a schematic that will be used as a reference later in the process. Of course, schematics for PCBs can be very long and complicated which can make checking them for errors quite difficult.

Here, we are going to tell you how you can effectively check your PCB schematic. Keep reading to find out more about this.

Continue reading “How To Effectively Check A PCB Schematic”

Day 30: final day

This post is part of the GaSiProMo challenge.   You can read more about this here.

I’ve got most of the bugs ironed out in my display interface, but not all have been squashed in the driver portion.  In other words, the method in which I can input text into the OsRAM is working nicely (I’m using a serial port console), but the nuts and bolts of how strings are sent to the display — arguably the most important part of this project — remains broken slightly.

OsRAM write timing
OsRAM write timing

The problem is that I was lazy.  I should have paid more attention to the WR and CE lines for proper data latching into the display at the right times.

Oh well, what can I say?   I got distracted by another project.  So I can show you what I have so far:

But this challenge has been fun.  It’s always fun to work under a deadline to see what you can do.  This forced me to learn more about Arduino.  And despite my first impression, I’ve come to see that it’s pretty great.  I especially love the C++ class support.  For instance, its string and bitwise libraries are awesome.  There are things that aren’t so great, like the editor.  I had consistent undo (CTRL+Z) wonkiness that scared me (I was afraid of code-eating), so I switched quickly to Notepad++ with a good syntax language profile.

Until next year.



I’m a notorious task-starter, and not a great task-finisher.  My garage is littered with old projects that are collecting more dust than accolades.  I can lean on the old, dependable excuses 1 but really that’s lame.  If every moment is the new normal, then there aren’t any excuses.  Our hobbies define us, and I love my hobbies.  So it’s time to get serious about some side projects.

One thing that I’ve always responded to positively when it comes to my side projects is a good deadline.  Nothing motivates like external pressure.

The deadline this time?  Something called the Galactic Side Project Month  (GaSiProMo) challenge.  You’ve heard of Hackathons or Codefests?  This is similar, but with a more sane schedule of an entire month for completion.

It was tempting to submit one of my more languishing, challenging old projects.  But in the end I decided on something new and fresh, one that is slightly more achievable.

Osram 5x7 display module
Osram 5×7 display module

For GaSiProMo, I’m going to get this display up and running.  It’s an intelligent LED matrix.  I might even throw in a keypad to change the patterns and such.

I’ve had this display module lying in my Big Bin of Parts for… more than 10 years.  At this point:

  1. I’m not convinced it even works.
  2. I don’t know what color the LEDs are (the module comes in yellow, red, and green).
  3. And I’m certainly not convince it will be that cool, but at least it’s a project that I’ve always wanted to do.

So there we go.  I’ll post regular updates here and over at the GaSiProMo website.  It’s time to blow the dust off some of these old projects.

The state of the Arduino ecosystem

*** The following is a “bitter old engineer” rant.  You’ve been warned.

At this ripe old age, I have come to value most the quality of a toolchain. I’ll go a step further and say that the coherency and consistency of the umbrella that toolchain inhabits is a most prized quality.  And what spurred this revelation?  Why the obtuse declaration?

I have seen the other side, brothers and sisters. I have felt the greener grass on the knoll of Arduino, and I’m here to tell you something: it ain’t that green.

My (albeit, limited) experience to date in hacker-friendly Arduino land has been lackluster. It reminds me of another favorite rant of mine: Linux. There are some striking similarities between the two communities of DIY hobbyists and computer enthusiasts.

The Arduino Uno, marvel of electronics enthusiasts.
The Arduino Uno, marvel of electronics enthusiasts.

  1. As soon as something “official” releases, there are half a dozen “forks” that have splintered off. This serves to dilute the overall user experience, causing bewilderment and disorganization.
  2. As a result, newer users aren’t sure where to start to get things up and running.
  3. Knowing where to turn for help is equally difficult. Because the dragon has a dozen heads, you might have to slay them all before you master the thing.

I have on my work bench a handful of Arduino-esque stuff, virtually all of it non-operational hardware (so far):
a) A Pololu AVR programmer
b) A Sparkfun Pocket AVR Programmer
c) A homemade ISP programmer
d) An Arduino UNO
e) A relay development board with ATtiny2313 MCU


This was a replacement for (b), promising to be more better faster. At least this manufacturer’s drivers are self-hosted, i.e., they make their own suite of drivers. It’s not some arcane foreign package, managed by yet another third party, long defunct. And yet… damned if the thing won’t work. I get the dreaded Exclamation Point of Death.


This is a hopeless mess. Sparkfun’s driver link just goes nowhere. After a half an hour of reading and clicking, I stumble over to another vendor’s site and find some hearsay about yet another suite of drivers that allegedly work. Finally this installs, but there’s no COMM port listed in Device Manager. So, none of the software tools can recognized the thing.


I was foolhardy to think I could make my own programmer from scant directions on the interwebz.  That was just a big fail.


My first Arduino dev board, the Uno, does not work. I plug it in, and most of the time no machine will recognize it. No “bonk”, no “ding”, nothing. I took this to my office and gave it to my technicians who are well accustomed to working with QC and microscopes and fancy solder reflow equipment. They found nothing distinctly wrong with it. And yet it clearly doesn’t work.

I found that if I bend the Uno board a bit (yes, bend), I can get Windows Device Manager to wiggle a bit. So there appears to be an inner layer fault, most likely a trace intermittence. Lovely. Another brick for my pile.


To program the AVR chip, I turned to these sprinkling of software tools that purport to do so:

  • WinAVR
  • AVRDude
  • AVRDude-GUI
  • AVR Studio

The top three have been dudes for me so far.  I’m yet to try the gold standard, AVR Studio.  After all, this is published by the manufacturer of the MCU…

The only piece of hardware above that I got to work was the relay I/O board. And you know how I did it? With a Freescale HCS08 dev board. Not an AVR chip or an Arduino board. The S family of chips is simply lovely. It’s soothing. It’s a fresher breath of air, having inhaled the stale aroma from the Arduino “hackerspace”.

But to be fair, Freescale is my comfort zone.  I cut my teeth on the Motorola HC11.  So it stands to reason that I’d favor that flavor.

The uniformity of experience in going from a line of C code to a hex file burned onto silicon is now even more valuable to me. The Freescale “way of doing things” is a much more pleasant thing. One application (CodeWarrior) weighing in at a hefty half gig, published by a single vendor that also happens to design and fab the chip you’re using, is all you need. Start to finish. That’s power.

I should note right here and now that I’m actually the biggest supporter of the Open Hardware Movement and the philosophies that Arduino espouses.  There have been countless amazing creations achieved with this platform.

It’s in the implementation that I’m disappointed.  Frankly, I’m surprised that the masses aren’t as frustrated as I am.  I suspect that this is indicative of a greater public movement: that of DIY culture invading every corner of the marketplace.  The software (or tool, or apparatus) doesn’t work as advertised?  No sweat, just hack it!

And that ethos truly is something to celebrate.  Kudos to the Everyman who fixes something rather than disposes of it, complains, and buys a new one.

But coming from the engineering and product development side of the aisle, I’m forced to side with the philosophies of coherent and esthetically pleasing user experience.  This has value too, just as much (I would argue) as the value of DIY, crowd-sourced electronic hobbyism.

Surround Sound Debug

For some reason, this keeps happening to me. I must be doing it wrong. But I’ve either been too stubborn or too distracted to find the better way to do it.

I’ve installed surround sound wiring into my abodes at least five times (twice in my bachelor days at two different apartments 1, and thrice in my married days in all three of Sarah’s and my mutual houses. So I have a fair amount of experience with fishing wires down walls and into ceiling joists, cutting in low-voltage single-gang electrical boxes, and wiring up multi-channel audio speakers.

But the one step in this many-tiered project that I haven’t mastered is this: the differentiation of the channels during the final wiring.

home-theatre-speakers-diagramHere’s what I mean. You get all the four main channels mounted and wiring run from the four corners of your media room 2. Add the center channel and you have five sets of wires coming into a single hook-up junction box near your media center cabinet. Next step: terminate those 10 conductors 3 into speaker lugs, or banana jacks, or binding posts.

But which channel pair goes to which speaker location? Doh!

And it’s not just an accident. I have tried various cable labeling in the past, as I did this most recent installation. But inevitably, my installs have included fish-taping cable down finished walls 4. Therefore, the labels that I’ve used — such as tape or zip ties, etc. — have always come off the cable in the process. Without that identification, it’s hard to know how to hook the cables up.

So what to do? I haven’t found much on the DIY home audio forums on this topic, strangely, which makes me wonder if I’m going about this installation all goofy. Do the pros do it better? Probably.

My first generation surround sound amplifier had a channel test tone utility that was helpful. It would emit a 1KHz tone into each channel for about 2 seconds and automatically increment to the next channel. But this wasn’t ideal for a few reasons: 1) It wasn’t controllable. Once that 2 seconds had expired, you’d have to race to the other speaker to hear the tone. Not very efficient. 2) The tone obviously required that the speaker cable be terminated between the speaker and the amp to be of any use. It’s an audible tone, therefore you need a speaker to hear it. So that’s not too helpful either since I’d rather hook up all the wire after I determine which set of wires goes to which speaker channel.

So here’s how I solved the problem.


  • An LED
  • A 1KOhm resistor
  • A 12 battery
  • Some alligator clip leads


  1. Wire up the LED indicator with the current limiting resistor attached either to the anode or cathode. A more preferred method would be to use a ready-made indicator LED panel lamp that has a built-in resistor. These assemblies come with red (positive) and black (negative) wires. Here’s one from Digi-Key.
  2. Connect the anode side (red wire) to your unknown speaker wire positive lead.
  3. Connect the cathode side (black wire) to your unknown speaker wire negative lead.
  4. Back at the junction box end with all 5 channels, connect the 12V battery to the positive and negative wires.
  5. If you don’t see the LED light up, first try switching the battery leads on that same channel.
  6. If the LED still doesn’t light, move the battery to the next set of channel wires.
  7. If the LED still doesn’t light, repeat steps 5-6 until you find it.

Theory of operation

The nice thing about this method is that the LED is unidirectional. In other words, it doesn’t light unless (conventional) current is flowing from positive to negative. This is key, because you don’t want to get the positive and negative terminals mixed up to your speakers. Therefore, using a DC incandescent light bulb would be a mistake, since it will light bi-directionally.


I’m aware that some speaker wire have knurled, striped, or discolored conductor insulators to help you differentiate between the two. This is helpful in most cases. But in two of my installs, I used some Monster brand cable that had little to no helpful indicators. So the above bailed me out.

Project Gallery

Social Media Auto Publish Powered By :