gEDA-user: Notes from this evening's Free Dog meeting

[sdb@xxxxxxxxxx (Stuart Brorson)]

Several people have asked what we do at Free Dog meetings . . . .
besides hang out and drink coffee, that is.  Since the 
topic this evening may be of interest to everybody on this list, I've
put together a short description of the meeting we just had (8.4.2005).
 
Four people showed up, Ales, John Luciani, my buddy John (who doesn't
participate on this list), and me (Stuart).  We initially just talked
about using Scilab & Octave instead of Matlab at John's place of
business, and chit-chat about other things.
 
We soon turned to the main topic on the agenda:  Look at various
alternative EDA pacakges.  (Alternative to gEDA/gaf & PCB, that is).
 
I started up XCircuit, but we didn't play with it much.  It still used
the old X11 widget set, and I couldn't figure out how place a
component with it.  We all agreed that it is more of a drawing program
than a schematic capture program.  John Luciani remarked that XCircuit
outputs nice Postscript, and then we moved on.
 
Next we started up Kicad, which several people have mentioned on this
list.  Ales had installed it on his laptop, and he took us on a test
drive.
 
Kicad is a marvelous program for board design, and will give
gEDA/gaf/PCB a real run for its money.  It has a (working) project
manager (unlike geda, which is currently broken), and has a schematic
capture program tightly bundled with an amazing layout editor.
Overall the UI is very polished, and (arguable) looks more
professional than gEDA.  Here are some notes I took while we played:
 
Eeschema
*  Selection is strange.  Clicking on an object doesn't select it.
   Rather, you need to do a mouse drag through the object.  This is
   not natural.
*  Net connections require separate component (connection) placed.
   This can be a PITA.
*  Attributes aren't easily movable.  However, all attributes of an
   object are accessible for editing, unlike gEDA/gaf.  (For example,
   you can't change the color of a net by clicking on it in gEDA/gaf,
   but you can in kicad.
*  Netnames -- how are they placed?
*  We tried SPICE netlisting.  Seems to work correctly once you figure
   out how to use program (not hard).  How to embedd vendor netlists?
*  No keyboard shortcuts.
*  Pans during drawing.  This is nice.
*  Can create netlist from within program.
*  Limited quantity of netlist formats available.  No separate
   netlister, and no ability to write new netlist backends.
*  Program crashed when trying to write to a non-writable file.
*  It took us a while to figure out how to create a multi-page
   schematic.  Will a multi-page schematic netlist correctly?
*  Pins are rigidly defined.  Can't define new pin attributes.
 
Pcbnew
*  Beautiful UI.  Much better thought-out & logical than PCB.
*  Newpcb max layers = 16.
*  Separate footprint editor very nice.  (PCB requires you to edit
   footprint directly on the layout page.)
*  Footprint libs -- like symbol libs -- are single file, not one
   footprint per file.  This makes footprint creation via scripts more
   involved.   Not sure this is a good thing.
*  3D view of board is very cool, but is probably is pure fluff --
   3D viewer can't do anything useful like report board dimensions or
   component heights.
*  Gencam supported.  This is precursor to ODB++  (I think -- SDB.)
   This is very cool since ODB++ is supposed to be the next-gen file
   format superseding Gerber.
*  DRC checker seems to work, both in real time as well as when
   invoked at end of layout.
*  Does it support backannotation?
 
My general conclusion (my opinion only) is that Kicad is an
outstanding program.  Its UI is almost as good as gschem's (I like
gschem's better) and is better than PCB's because it is more
logical and consistent.  For example, in PCB to export Gerbers you
need to do "file -> print" and then change target to Gerbers/RS-273X
(or whatever).  In newpcb you do something like "file -> export
Gerber", which is what you'd expect to do.
 
Philosophically, Kicad is different from the gEDA
Suite in that Kicad provides a much more integrated board design
environment than gEDA.  You never need to drop to the command line to
do anything.  GEDA, on the other hand, is really more of a suite of
individual components which share some file formats and work
together.  If you like the approach of an integrated design
environment, then Kicad is a reasonable choice for doing designs.
OTOH, if you like the "unix philosophy" of having separate programs
which implement specific features, then gEDA wins.
 
One issue with Kicad is that symbol and footprint creation doesn't
seem to be as nicely scriptable as with gEDA/gaf & PCB.  The problem
is that Kicad has symbol and footprint libs which hold multiple
symbols, instead of holding each symbol/footprint in an individual
file.  We talked about why you would have multiple symbols per lib
file, but couldn't figure out why that was preferable, except that it
gave you fewer individual files.
 
Finally, Kicad doesn't build nicely, i.e. it doesn't use the
GNU build system (i.e. configure etc.), and certain paths &
directories are hard-coded into the Makefiles, so newbies will have a
problem with that.
 
Personally, I won't move to Kicad since I already know gEDA.  I also
like the "unix style" of having one program do only one thing.  This
promotes "best of breed" solutions for each task.  OTOH, if somebody
whines about gEDA not being integrated enough, then I will point to
Kicad as an alternative.
 
After spending over an hour playing with Kicad, we tried out Electric,
which Ales had also installed on his laptop.  Electric is now a Java
program.  I had tried installing it on my laptop and running it with
gcj, but had failed miserably.  Ales had installed the whole Sun JDK
on his laptop and was able to run Electric successfully.  Electric ran
& looked OK, but it seems optimized for chip design, and not board
design.  We played with it for a little while, and then gave up
because nobody amongst us really knew anything about chip design.
Maybe I'll try running Magic at some Free Dog meeting in the future.
 
After that, John Luciani passed out some info about his latest Perl
creations:  A set of scripts which handle BOM management.  John's
scripts are waaaaaay more advanced than the simple BOM generation
provided by "gnetlist -g bom" We talked about the problems involved
with parts procurement & how that can be integrated into the design
cycle upfront, instead of at the end of the design phase.  This led
into a discussion about PRM and ERP software, which I think is a
possible next step for gEDA.
 
Then we broke up for the evening.  The next Free Dog will likely be a
special event co-incident with the Embedded Systems Conference in
Boston around the middle of September.  Stay tuned for an
announcement!
 
Stuart