Path: utzoo!mnetor!uunet!husc6!mit-eddie!uw-beaver!cornell!batcomputer!sun.soe.clarkson.edu!bkc
From: bkc@sun.soe.clarkson.edu (Brad Clements)
Newsgroups: sci.electronics
Subject: Re: Posting Schematics
Message-ID: <535@sun.soe.clarkson.edu>
Date: 11 Mar 88 00:13:49 GMT
Sender: bkc@sun.soe.clarkson.edu
Reply-To: bkc@sun.soe.clarkson.edu (Brad Clements)
Organization: Clarkson University, Potsdam, NY
Lines: 101

From article <329@nancy.UUCP>, by magnani@msudoc.ee.mich-state.edu (Steven Magnani EE):
> (I have added comp.lang.postscript to the discussion to get sone
> feedback on this idea. Note that followups go to sci.electronics --SJM)
> 
> A proposed soultion:
> 
> If one is talking about exchanging graphics only (ie, not an actual
> circuit description, such as SPICE or MAGIC could deal with), a graphics
> description language such as PostScript ((tm) Adobe Systems) or
> Interpress ((tm) Xerox) might be useful. These files may be stored in
> ASCII format (perfect for E-mail interchange!), and may be interpreted
> by programs on widely differing systems. Translation programs exist
> to go between PostScript/Interpress and other graphics description
> languages (such as HPGL). Also, PostScript-type printers
> such as the LaserWriter are becoming more common, so even if a
> particular site has no tools for displaying the schematic on the screen,
> a hard copy may be generated. Since the Mac tools are capable of
> generating PostScript output (correct me on this...) this might be a
> better idea than posting binary files.
> 
> One disadvantage of this scheme that *I* can think of is that the
> PostScript files may not be easily edited. It sounds like MacPaint
> stores its files in binary format, in which case it is probably unable
> to accept PostScript files as input. FrameMaker ((tm) Frame Technology) is
One thing to consider is using more of the power of PostScript.

These schematics could be encoded in PostScript Arrays in the form
of standard Netlists and a 'PostScript Program' could read the array/
netlist and generate the drawing. The 'program' could be just some 
standard PostScript which wouldn't need to be copied around
the net, but rather one copy kept at each site. Concatenation of the
PostScript/netlist file with the 'program' and send it to a Laser Printer
or PostScript screen previewer would give a drawn picture. The
netlist/arrays could easily be edited.

In other words, don't encode the schematic as individual graphical
commands, but rather use the power of PostScript to read data arrays
of netlist info and draw the diagram from the arrays. I have already
done something like this for drawing the Network Topology of our
Campus Ethernet using a hosts.txt file converted to postscript
arrays and concatenated with the 'PostScript Program'. It works
great! No more painstaking hand drawing of our network and
any updates to our hosts.txt file is 'automatically' incorporated in
the drawing.

An example netlist could be layed out as (for those into PostScript)
/component_name [
  component_type (component name) (component data)
  [ (pin textural name) (signal name) (otherinfo) (destination pin name)
    destination_component]
] def

The component_type is a composite array describing how to draw the
component, how many pins and what their names/placements are.
The sub-array of pin connections can go on for ever. The destination
component is the name (literal) of an array (not the array itself) which is the same kind of
array as the source component.

Editing this kind of structure is easy. And writing PostScript code
to parse the arrays and automatically draw the schematic isn't
too difficult.

Example:

/Part_resistor [ {procedure for drawing one} {procedure for labeling}
	[ (pin1) (pin2) ]
] def

/Part_transistor [ {procedure for drawing one} {procedure for labeling}
	[ (cathode) (anode) (gate) ]
] def

% begin dummy schematic
/part_one [ Part_resistor (R1) (220ohm)
	[ (pin1) (Oscillator Output) (otherinfo) (anode) /part_two ]
	[ (pin2) (some other signal) (otherinfo) (cathode) /part_three ]
] def
/part_two [ Part_transistor (T1) (22227)
	[ (cathode) (+5V) (otherinfo) (pin1) /part_four ]
	[ (gate) () () (pin2) (anode) /part_three ]
] def

/part_three [ Part_transistor (T2) (25634)
	[ (gate) (ground) () (pin2) /part_four ]
] def
/part_four  [ Part_resistor (R2) (345ohm +-1%)
] def

Anyway, you get the idea. Notice that each part only lists what it
connects to, not what connects to it. There would have to be more stuff
in the structures etc, but I think this is a basic netlist with []
added. How easy is it to change the wiring of this? Easy.
Then just feed it to your laser printer...

The style of the drawn schematic could be hand tailored to each site if
desired. 

It's time to start thinking of PostScript as a programming language, not
just a graphical one.

Brad Clements