;;--------------------------------------------------------------------------------------------------
;; gnet-spice-msw.scm
;; --------------------
;; Description : gEDA - GPL Electronic Design Automation
;; gnetlist - gEDA Netlist
;; gnet-spice-msw.scm - gnetlist SPICE backend
;; Last Update : Refer to version string declaration
;; Authors : Copyright (C) 1998-2010 Ales Hvezda
;; Copyright (C) 1998-2010 gEDA Contributors (see ChangeLog for details)
;; SPICE netlist backend written by S. Gieltjes.
;; Modified by W. Kazubski to use scaling parameters for devices other than MOSFETS.
;; Hacked by SDB (Stuart Brorson) to support advanced SPICE netlist generation.
;; Refactoring and debugging by Mike Waters (2016).
;;--------------------------------------------------------------------------------------------------
;; This program is free software; you can redistribute it and/or modify it under the terms of the
;; GNU General Public License as published by the Free Software Foundation; either version 2 of the
;; License, or (at your option) any later version.
;;
;; This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
;; even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
;; General Public License for more details.
;;--------------------------------------------------------------------------------------------------
;; New Features :
;;
;; 1. Program is now case insensitive.
;; 2. Refactored code to make it more readable eg. matched indenting of matching parenthesis.
;; 3. In verbose mode the debug spew has been tidied up.
;; 4. Documentation of procedure argument list and return values where appropriate.
;; 5. Documentation of program call options.
;; 6. Fixed a bug where JFETs could be identified as unknown components.
;; 7. Removed unnecessary procedures eg. "write-footer" and "empty-string?".
;; 8. Inserted the contents of spice-common.scm in this file. Easier to debug and maintain.
;; 9. Extend nomunge_mode to include all components eg. resistor, capacitors, etc.
;; 10. Add support for current controlled switches.
;; 11. Procedure "get-file-type" now only stops before EOF if it encounters a .SUBCKT or .MODEL line.
;;--------------------------------------------------------------------------------------------------
;; Usage :
;;
;; 1. Invoke this guile backend from gnetlist :
;; gnetlist -g spice-msw -o circuit.ckt circuit.sch
;; 2. Send command line arguments to the guile backend :
;; gnetlist -O <OPTION1> -O <OPTION2> -g spice-msw circuit.sch
;; 2. Send the gnetlist output to standard out :
;; gnetlist -g spice-msw -o - circuit.sch
;;
;; Options :
;;
;; include_mode - Enable .INCLUDE directives instead of inserting file contents eg. for model files
;; nomunge_mode - Enable testing of package prefix and prepending the correct prefix if required
;; sort_mode - Enable sorting of packages alphabetically according to refdes's
;; embedd_mode - Enable inserting of file contents when a .INCLUDE directive is encountered
;; no_end_mode - Disable appending of .END or .ENDS directives at the end of the netlist file
;;--------------------------------------------------------------------------------------------------
;; Organization :
;;
;; - The program entry point is at the top of the file.
;; - High-level functions which control program flow.
;; - Functions for program housekeeping, handling of calling flags, file manipulation.
;; - Functions for handling nets & devices and creating SPICE cards.
;;--------------------------------------------------------------------------------------------------
;; Things To Do :
;;
;; 2016-10-24 The Josephson Junction procedure "write-joseph-jn" uses the prefix B for the refdes
;; but in SPICE this is the prefix for a non-linear dependent source.
;; 2016-09-08 Search for "???" to find locations needing attention
;;--------------------------------------------------------------------------------------------------
;; Change Log :
;;
;; 2016-11-05 Removed unecessary space characters from component definition lines in netlist
;; 2016-09-08 Procedure "get-file-type" now overlooks SPICE .DIRECTIVE commands (eg. .PARAM) and
;; only stop before EOF if it encounters a .SUBCKT or .MODEL line.
;; 2016-10-24 Extend procedure "write-def-cmpnt" to include as many components as possible.
;; 2016-10-24 Removed procedure "get-cmpnt-value", it didn't do enough to justify it's existence.
;; 2016-10-23 Drop support for Guile 1.8.x (gnetlist has dropped support for it).
;; 2016-10-22 Removed procedure "write-footer", unnecessary obfuscation.
;; 2016-10-21 Dropped case sensitivity by using string-ci? instead of string? when testing strings.
;; 2016-10-20 Document procedure argument lists and return values
;; 2016-10-20 Moved to a case insensitive model. This backend should now be less finicky.
;; 2016-10-16 Move the script entry point to the top of the file (seems more logical to me).
;; 2016-09-17 Refactor code : choose more readable procedure names where necessary.
;; 2016-09-17 Removed procedure "component-model" as it wasn't used.
;; 2016-09-17 Removed procedure "component-optional-value" as it wasn't used.
;; 2016-09-16 Insert contents of spice-common.scm in this file. Easier to debug.
;; 2016-09-12 Removed procedure "empty-string?" and replaced it with call to builtin "string-null?"
;; 2016-09-10 Refactor code : use short hand procedure definitions (remove lambda lines),
;; 2016-09-10 Refactor code : match indenting of matched parenthesis.
;; 2016-09-10 Refactor code : general tidy up of file formatting.
;;--------------------------------------------------------------------------------------------------
;; Define modules needed by this program
(use-modules (ice-9 rdelim))
;;(use-modules (srfi srfi-1)) ;; This is needed to make guile 1.8.x happy
;;--------------------------------------------------------------------------------------------------
;; Get the current version of this Guile script.
;;
;; Note : This procedure definition is to get the version string at the top of the file
;;
;; Return Values :
;; The current version string.
(define version "2016-11-06")
;;**************************************************************************************************
;;* *
;;* Program Entry Point *
;;* *
;;**************************************************************************************************
;;--------------------------------------------------------------------------------------------------
;; Spice netlist generation entry point.
;;
;; The algorithm is as follows :
;;
;; 1. Determine if there's a .SUBCKT block in the schematic or if it is just a normal schematic.
;; If there's a .SUBCKT block :
;; - Write out subcircuit header (a comment identifying the netlister).
;; - Find all spice-IO pins. Get a list of the packages.
;; - Put them in order (ordered by package refdes)
;; - Get the list of nets attached to the spice-IO pins.
;; - Write out .SUBCKT line
;; If a normal schematic :
;; - Write out top header (a comment identifying the netlister).
;; 2. Loop through all components looking for components with a "file" attribute. Every time a
;; "file" attribute is found :
;; - Open the file and find out what kind of file it is (.SUBCKT or .MODEL).
;; - Determine if the file has previously been processed. If not stick the following info.
;; into the file-info list : (model-name file-name file-type), otherwise just continue.
;; 3. Loop through all components again, and write out a SPICE card for each.
;; 4. Afterwards, for each item in the file-info list, open the file and write it's contents into
;; the netlist.
;; 5. If the schematic type is .SUBCKT : write out .ENDS otherwise write out .END
;; 6. Close the SPICE netlist file and return.
;;
;; Argument List :
;; netlist-filename - The name of the SPICE netlist file
(define (spice-msw netlist-filename)
;; Send the script output to the SPICE netlist file
(set-current-output-port (gnetlist:output-port netlist-filename))
(let*
( (schem-type (spice-msw:get-schem-type packages))
(model-name (substring schem-type 8 (string-length schem-type)))
(file-list (list)) )
(message "Running the SPICE backend to gnetlist :\n\n")
;; First decide if this is a .SUBCKT lower level, or if it is a regular schematic
(if (string=? schem-type "normal schematic")
;; This is a regular schematic
(begin
(debug-spew "Found a normal type schematic\n\n")
(display (string-append "* " (gnetlist:get-command-line) "\n"))
(spice-msw:write-netlist-header)
)
;; This is a .SUBCKT type schematic
(let*
( (io-pin-packages (spice-msw:get-spice-io-pins packages (list)))
(io-pin-packages-ordered (spice-msw:sort-spice-io-pins io-pin-packages))
(io-nets-list (spice-msw:get-io-nets io-pin-packages-ordered (list))) )
;; The procedure "debug-spew" is defined in : gnetlist.scm
(debug-spew "Found a .SUBCKT type schematic\n\n")
;; Write out a .SUBCKT header and .SUBCKT line
(spice-msw:write-subcircuit-header)
(let
( (io-nets-string (list-2-string io-nets-list)) )
(display (string-append schem-type " " io-nets-string "\n"))
)
)
)
;; Search all the devices and compile a file list from all the "file" attributes
(debug-spew "Make first pass through design and create list of all model files referenced :\n")
(set! file-list (spice-msw:create-file-list packages file-list))
(debug-spew "\nDone creating file-list\n\n")
;; Loop through the file list and write the file contents or a reference to it to the netlist
(debug-spew "Now process the items in the model file list :\n")
(spice-msw:process-files file-list)
(debug-spew "Done processing items in the model file list\n\n")
;; Write components to the netlist file (sorting components if required)
(debug-spew "Make second pass through design and write out a SPICE card for each component found :\n")
(if (calling-flag? "sort_mode" (gnetlist:get-calling-flags))
(spice-msw:write-netlist file-list (sort packages spice-msw:package-sort)) ;; Sort on refdes
(spice-msw:write-netlist file-list packages) ;; Don't sort
)
(debug-spew "\n")
;; Write .END(S) of netlist, depending upon whether schematic is a "normal schematic" or .SUBCKT
(if (not (string=? schem-type "normal schematic"))
(display (string-append ".ENDS " model-name "\n"))
(if (not (calling-flag? "no_end_mode" (gnetlist:get-calling-flags)))
(display ".END\n")
)
)
)
(debug-spew "\nDone writing SPICE cards\n\n")
;; Finally, close the netlist file
(close-output-port (current-output-port))
)
;;**************************************************************************************************
;;* *
;;* High-level functions for program control *
;;* *
;;**************************************************************************************************
;;--------------------------------------------------------------------------------------------------
;; Determine the schematic type ie. a normal schematic or a .SUBCKT lower level.
;;
;; Search for a "spice-subcircuit-LL" device instantiated somewhere in the schematic. If it is a
;; .SUBCKT return ".SUBCKT model-name" else return "normal schematic".
;;
;; Argument List :
;; package-list - A list of package (component) labels (refdes's)
(define (spice-msw:get-schem-type package-list)
(if (not (null? package-list))
(let*
( (package (car package-list))
(device (gnetlist:get-package-attribute package "device")) )
(if (string-ci=? device "SPICE-SUBCIRCUIT-LL") ;; Look for a subcircuit label
(string-append ".SUBCKT " (gnetlist:get-package-attribute package "model-name"))
(spice-msw:get-schem-type (cdr package-list)) ;; Iterate to the next package
)
)
"normal schematic"
)
)
;;--------------------------------------------------------------------------------------------------
;; This function takes as argument the list of packages (refdes's). It runs through the package
;; list, and for each gets the attributes. If there is a "FILE" attribute, it gets the file info &
;; uses it to build the file-list. When done, it returns the file-list.
;;
;; Argument List :
;; package-list - A list of package (component) labels (refdes's)
;; file-list - A list of files referred to in the schematic file
(define (spice-msw:create-file-list package-list file-list)
(if (null? package-list)
file-list ;; Return the file-list
(let*
( (package (car package-list)) ;; Get the next package (ie. refdes)
(device (string))
(model (string))
(value (string))
(model-file (string)) )
(set! device (gnetlist:get-package-attribute package "device") )
(set! model (gnetlist:get-package-attribute package "model-name") )
(set! value (gnetlist:get-package-attribute package "value") )
(set! model-file (gnetlist:get-package-attribute package "file") )
;; Now run a series of checks to see if we should stick this file into the file-list
;; Check to see if "file" attribute is non-empty
(if (not (string-ci=? model-file "unknown"))
(begin
(debug-spew "\n spice-msw:create-file-list : ")
(debug-spew (string-append "Found file attribute for package " package " = " model-file "\n"))
;; Now check if the file is already in the file-list
(if (not (spice-msw:in-file-list? model-file file-list))
;; File is new, open it and find out what type it is
(let
( (file-type (spice-msw:get-file-type model-file)) )
(debug-spew " spice-msw:create-file-list : ")
(debug-spew (string-append "File is not in the list and has type " file-type "\n"))
;; Check to see if file-type is known.
(if (not (string-ci=? file-type "OTHER"))
(begin
(debug-spew " spice-msw:create-file-list : Adding it to the list of model files\n")
(set! file-list (append (list (list model model-file file-type)) file-list) )
)
(debug-spew " spice-msw:create-file-list : File type is OTHER so ignore it\n")
)
)
;; File is already in list. Print debug spew if desired.
(debug-spew " spice-msw:create-file-list : File is already in the model file list.\n")
)
)
)
;; having done checking and processing of this package, iterate to the next one.
(spice-msw:create-file-list (cdr package-list) file-list)
)
)
)
;;--------------------------------------------------------------------------------------------------
;; This is a helper function which returns #t if a file is already in file-list, otherwise #f.
;;
;; Note : It is assumed that file-list is of the form :
;; ( (model1 file-name1 file-type1) (model2 file-name2 file-type2) . . . . )
;;
;; Argument List :
;; file-name - The file name to search for
;; file-list - The list of file info. to search
;;
;; Return Values :
;; Success - #t (the file was found in the list)
;; Failure - #f (the file wasn't found in the list)
(define (spice-msw:in-file-list? file-name file-list)
(if (null? file-list)
#f ;; file-list is empty
(let
( (list-element (car file-list)) ) ;; Get a list element and process it
(if (null? list-element)
#f ;; list-element is empty (should never get here)
(let
( (list-file-name (cadr list-element)) )
(if (string=? list-file-name file-name)
#t ;; file-name was found in file-list
(spice-msw:in-file-list? file-name (cdr file-list)) ;; Iterate . . .
)
)
)
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Search a file and determine it's type based on it's contents.
;;
;; Note : The function opens input-file and closes it when it is done.
;;
;; Argument List :
;; file-name - The file to test
;;
;; Return Values :
;; ".MODEL" - The file contains a model
;; ".SUBCKT" - The file contains a sub-circuit
;; "OTHER" - The file is neither of the above
(define (spice-msw:get-file-type file-name)
(if (file-exists? file-name)
(let
( (in-file (open-input-file file-name)) )
(let while ( (file-line (read-line in-file)) )
(cond
((eof-object? file-line) ;; Arrived at end of line without finding .MODEL or .SUBCKT
"OTHER"
)
((string-null? file-line) ;; Found empty line, iterate before doing anything else
(while (read-line in-file))
)
((string=? (string (string-ref file-line 0)) "*") ;; Found comment, iterate
(while (read-line in-file))
)
((string=? (string (string-ref file-line 0)) ".") ;; The first char is a '.'
(begin
(cond
((string-ci=? (safe-string-head file-line 7) ".SUBCKT") ;; Found .SUBCKT line
".SUBCKT"
)
((string-ci=? (safe-string-head file-line 6) ".MODEL") ;; Found .MODEL line
".MODEL"
)
(else
(while (read-line in-file))
)
)
)
)
(else
(while (read-line in-file))
)
)
)
)
(begin
(message (string-append "ERROR: File '" file-name "' not found.\n"))
(primitive-exit 1)
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Take a list and turns it into a string.
;;
;; The difference between this and list->string is that this function can handle lists made up of
;; multi-char strings.
;;
;; Argument List :
;; str-list - A list of strings
(define (list-2-string str-list)
(let while ( (st (string)) (local-list str-list) )
(if (null? local-list)
st ;; end iteration & return string if list is empty.
(begin ;; otherwise turn next element of list into string. . .
(set! st (string-append (car local-list) " " st)) ;; stuff next element onto st
(while st (cdr local-list)) ;; iterate with remainder of ls
)
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write out spice netlist header.
(define (spice-msw:write-netlist-header)
(display "**************************************************\n")
(display "* SPICE file generated by gnetlist *\n")
(display (string-append "* using spice-msw (" version ") backend *\n"))
(display "**************************************************\n\n")
)
;;--------------------------------------------------------------------------------------------------
;; Write out .SUBCKT netlist header.
(define (spice-msw:write-subckt-header)
(display "*************************************\n")
(display "* Begin .SUBCKT model *\n")
(display "*************************************\n")
)
;;**************************************************************************************************
;;* *
;;* Program housekeeping, handling calling flags, file manipulation *
;;* *
;;**************************************************************************************************
;;--------------------------------------------------------------------------------------------------
;; Loop through the model-file list looking for a triplet corresponding to a particular model-name.
;;
;; Argument List :
;; model-name - The model name being sort
;; file-list - A list of files referred to in the schematic file
;;
;; Return Values :
;; Success - The file list item associated with the model name
;; Failure - #f
(define (spice-msw:get-file-list-item model-name file-list)
(if (null? file-list)
(quote #f)
(let*
( (list-item (car file-list))
(item-model-name (car list-item))
(item-file-name (cadr list-item))
(item-file-type (caddr list-item)) )
(if (string-ci=? item-model-name model-name)
list-item ;; Found model-name
(spice-msw:get-file-list-item model-name (cdr file-list)) ;; Keep looking
)
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Loop through the model file list and for each file invoke handle-spice-file.
;;
;; Argument List :
;; file-list - A list of files referred to in the schematic file
(define (spice-msw:process-files file-list)
(if (not (null? file-list))
(let*
( (list-element (car file-list)) (model-name (car list-element))
(file-name (cadr list-element)) (file-type (caddr list-element)) )
(spice-msw:process-spice-file file-name)
(spice-msw:process-files (cdr file-list))
)
(display "\n")
)
)
;;--------------------------------------------------------------------------------------------------
;; This wraps insert-text-file.
;;
;; If "include_mode" has been enabled just write an .INCLUDE card with the file name. If not it
;; call insert-text-file to insert the file's contents into the SPICE netlist.
;;
;; Argument List :
;; file-name - The file name to be processed
(define (spice-msw:process-spice-file file-name)
(debug-spew (string-append "\n spice-msw:process-spice-file : " file-name "\n"))
(if (calling-flag? "include_mode" (gnetlist:get-calling-flags))
(display (string-append ".INCLUDE " file-name "\n")) ;; Use .INCLUDE card
(spice-msw:insert-text-file file-name) ;; Insert file contents
)
)
;;--------------------------------------------------------------------------------------------------
;; Open a file, get the contents and insert it into the SPICE file.
;;
;; This function is usually used to include SPICE models contained in files into the netlist.
;;
;; Argument List :
;; file-name - The name of the file
(define (spice-msw:insert-text-file file-name)
(if (file-exists? file-name)
(let
( (in-file (open-input-file file-name)) )
(display (string-append "* Include SPICE model file : " file-name "\n") )
(let while ((line (read-line in-file)))
(if (not (eof-object? line))
(begin
(display (string-append line "\n"))
(while (read-line in-file))
)
)
)
(close-port in-file)
(newline)
)
(begin
(message (string-append "ERROR: File '" file-name "' not found.\n"))
(primitive-exit 1)
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Iterate through the schematic and compile a list of all SPICE-IO pins found. This is used when
;; writing out a .SUBCKT lower level netlist.
;;
;; Argument List :
;; package-list - A list of package (component) labels (refdes's)
;;
;; Return Values :
;; spice-io-pin-list - A list of the SPICE-IO pins
(define (spice-msw:get-spice-io-pins package-list spice-io-pin-list)
(if (null? package-list)
spice-io-pin-list
(let*
( (package (car package-list))
(device (gnetlist:get-package-attribute package "device")) )
(if (string-ci=? device "SPICE-IO") ;; Look for subcircuit label
;; Found a spice-IO pin.
(spice-msw:get-spice-io-pins (cdr ls) (cons package spice-io-pin-list))
;; No spice-IO pin found. Iterate . . . .
(spice-msw:get-spice-io-pins (cdr ls) spice-io-pin-list)
)
)
)
)
;;--------------------------------------------------------------------------------------------------
;; This takes the list of io-pin-packages and sorts it in order of refdes.
;;
;; Argument List :
;; package-list - A list of package (component) labels (refdes's)
(define (spice-msw:sort-spice-io-pins package-list)
;; Yes, this isn't good Scheme form. Tough! Writing this out in a functional programming form
;; would be totally confusing! Note that this function requires that each spice-IO pin have the
;; same, single character prefix (i.e. 'P')
(let*
( (char-prefixes (map car (map string->list package-list))) ;; Pull off first char (prefix)
(prefixes (map string char-prefixes)) ;; Make list of strings from prefixes
(split-numbers-list (map cdr (map string->list package-list))) ;; Pull off refdes numbers as list elements
(string-numbers-list (map list->string split-numbers-list)) ;; Recombine split up (multidigit) number strings
(numbers-list (map string->number string-numbers-list)) ;; Convert strings to numbers for sorting
(sorted-numbers-list (sort numbers-list <)) ;; Sort refdes numbers as numbers
(sorted-string-numbers-list (map number->string sorted-numbers-list)) ) ;; Create sorted list of refdes strings.
(map-in-order string-append prefixes sorted-string-numbers-list) ;; Laminate prefixes back onto refdes numbers & return.
)
)
;;--------------------------------------------------------------------------------------------------
;; Given a list of spice-IO packages (refdes's), return the list of nets attached to the IOs.
;;
;; Argument List :
;; package-list - A list of package (component) labels (refdes's)
;;
;; Return Values :
;; net-list - A list of nets
(define (spice-msw:get-io-nets package-list net-list)
(if (null? package-list)
net-list ;; End iteration & return net-list if ls is empty.
(let*
( (package (car package-list)) ;; otherwise process package. . .
(net (car (gnetlist:get-nets package "1"))) ) ;; get the net attached to pin 1
;; Now iterate
(spice-msw:get-io-nets (cdr package-list) (cons net net-list))
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write netnames connected to pin-a and pin-b.
;;
;; Currently used by the controlled sources eg. f and h.
;;
;; Argument List :
;; package - The refdes of a component eg. R1
;; pin-a - The name of pin-a
;; pin-b - The name of pin-b
(define (spice-msw:write-two-pin-names package pin-a pin-b)
(display (string-append
(car (spice-msw:get-net package (gnetlist:get-attribute-by-pinseq package pin-a "pinnumber"))) " "))
(display (string-append
(car (spice-msw:get-net package (gnetlist:get-attribute-by-pinseq package pin-b "pinnumber"))) " "))
)
;;--------------------------------------------------------------------------------------------------
;; Write all listed and available attributes in the form of <variable>=<value>.
;;
;; Argument List :
;; package - The refdes of a component eg. R1
;; attrib-list - A list of attributes
(define (spice-msw:write-attrib-list package attrib-list)
(if (not (null? attrib-list))
(let
( (attrib (gnetlist:get-package-attribute package (car attrib-list))) )
(if (not (string-ci=? attrib "unknown"))
(display (string-append " " (car attrib-list) "=" attrib))
)
(spice-msw:write-attrib-list package (cdr attrib-list))
)
)
)
;;--------------------------------------------------------------------------------------------------
;; A replacement of the procedure gnetlist:get-nets. A net labeled "GND" becomes 0.
;;
;; Argument List :
;; package - The refdes of a component eg. R1
;; pin-name - The component pin name connected to the net
(define (spice-msw:get-net package pin-name)
(let
( (net-name (gnetlist:get-nets package pin-name)) )
(cond ((string-ci=? (car net-name) "GND") (cons "0" #t))
(else (cons (car net-name) #t))
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Sort procedure to order refdes's alphabetically but keep A? packages at the end of the list so
;; SPICE simulation directives operate correctly.
;;
;; This function was written by Ken Healy to facilitate SPICE netlisting for GNU-CAP, which wants A?
;; refdes cards (ie. SPICE directives) to appear last in the SPICE netlist.
;;
;; Argument List :
;; x - First item to compare
;; y - Second item to compare
(define (spice-msw:package-sort x y)
(define (string-tail string start) (substring string start (string-length string)))
(let
( (xdes (string-ref x 0))
(ydes (string-ref y 0))
(xnum (string-tail x 1))
(ynum (string-tail y 1)) )
(if (char-ci=? xdes ydes)
(if (string-ci<? xnum ynum) #t #f)
(if (char-ci=? xdes #\A) #f
(if (char-ci=? ydes #\A) #t
(if (char-ci<? xdes ydes) #t #f)
)
)
)
)
)
;;**************************************************************************************************
;;* *
;;* Dealing with nets, devices, & SPICE cards *
;;* *
;;**************************************************************************************************
;;--------------------------------------------------------------------------------------------------
;; This function is passed a list of refdes's (ls). It uses each refdes to get the corresponding
;; "device" attribute. Depending upon the device, it then invokes one or another of the spice line
;; output fcns to output a line of the spice netlist.
;;
;; Write the refdes, to the pin# connected net and component value and optional extra attributes
;; check if the component is a special spice component.
;;
;; Argument List :
;; file-list - A list of files referred to in the schematic file
;; package-list - A list of package (component) labels (refdes's)
(define (spice-msw:write-netlist file-list package-list)
(if (not (null? package-list))
(let*
( (package (car package-list)) ;; assign package
(device (gnetlist:get-package-attribute package "device")) ) ;; assign device.
;; Super debug stuff -- outputs line describing device being processed.
(debug-spew "\n spice-msw:write-netlist : ")
(debug-spew (string-append "Check package refdes = " package ", device = " device "\n"))
(cond
((string-ci=? device "NONE")) ;; Do nothing for graphical symbols
((string-ci=? device "SPICE-SUBCIRCUIT-LL")) ;; Do nothing for subcircuit declaration
((string-ci=? device "SPICE-IO")) ;; Do nothing for SPICE IO pins
((string-ci=? device "SPICE-CCVS" ) (spice-msw:write-ccvs package))
((string-ci=? device "SPICE-CCCS" ) (spice-msw:write-cccs package))
((string-ci=? device "SPICE-VCVS" ) (spice-msw:write-vcvs package))
((string-ci=? device "SPICE-VCCS" ) (spice-msw:write-vccs package))
((string-ci=? device "VOLTAGE_SOURCE" ) (spice-msw:write-ivs package)) ;; change someday ???
((string-ci=? device "CURRENT_SOURCE" ) (spice-msw:write-ics package)) ;; change someday ???
((string-ci=? device "SPICE-NULLOR" ) (spice-msw:write-nullor package))
((string-ci=? device "DIODE" ) (spice-msw:write-diode package))
((string-ci=? device "PMOS_TRANSISTOR" ) (spice-msw:write-pmos package))
((string-ci=? device "NMOS_TRANSISTOR" ) (spice-msw:write-nmos package))
((string-ci=? device "SUBCKT_PMOS" ) (spice-msw:write-pmos-subckt package))
((string-ci=? device "SUBCKT_NMOS" ) (spice-msw:write-nmos-subckt package))
((string-ci=? device "PNP_TRANSISTOR" ) (spice-msw:write-pnp package))
((string-ci=? device "SPICE-PNP" ) (spice-msw:write-pnp package))
((string-ci=? device "NPN_TRANSISTOR" ) (spice-msw:write-npn package))
((string-ci=? device "SPICE-NPN" ) (spice-msw:write-npn package))
((string-ci=? device "PFET_TRANSISTOR" ) (spice-msw:write-pfet package))
((string-ci=? device "NFET_TRANSISTOR" ) (spice-msw:write-nfet package))
((string-ci=? device "MESFET_TRANSISTOR" ) (spice-msw:write-mesfet package))
((string-ci=? device "SPICE-VC-SWITCH" ) (spice-msw:write-vc-switch package))
((string-ci=? device "SPICE-CC-SWITCH" ) (spice-msw:write-cc-switch package))
((string-ci=? device "AOP-STANDARD" ) (spice-msw:write-def-cmpnt package device file-list))
((string-ci=? device "RESISTOR" ) (spice-msw:write-resistor package))
((string-ci=? device "CAPACITOR" ) (spice-msw:write-capacitor package))
((string-ci=? device "POLARIZED_CAPACITOR") (spice-msw:write-capacitor package)) ;; change someday ???
((string-ci=? device "INDUCTOR" ) (spice-msw:write-inductor package))
((string-ci=? device "COIL" ) (spice-msw:write-inductor package)) ;; Added to enable netlisting of coil-*.sym
((string-ci=? device "JOSEPHSON_JUNCTION" ) (spice-msw:write-joseph-jn package))
((string-ci=? device "K" ) (spice-msw:write-coupled-ind package))
((string-ci=? device "MODEL" ) (spice-msw:write-model package))
((string-ci=? device "OPTIONS" ) (spice-msw:write-options package))
((string-ci=? device "DIRECTIVE" ) (spice-msw:write-directive package))
((string-ci=? device "INCLUDE" ) (spice-msw:write-include package))
((string-ci=? device "TESTPOINT" ) (spice-msw:write-probe package))
(else
;; The package couldn't be identified using it's device attribute so attempt to write the
;; package using it's refdes prefix to identify it
(spice-msw:write-def-cmpnt package device file-list)
)
)
(spice-msw:write-netlist file-list (cdr package-list))
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write out the default component based on the first character of it's refdes (eg. a prefix 'Q' is
;; assumed to be a bipolar transistor).
;;
;; This function does the following :
;;
;; 1. Gets the refdes (package).
;; 2. Checks the refdes against a short list of possible values.
;; Depending upon the refdes, it does the following thing :
;; A? -- Invoke write-ic. This provides the opportunity for a code model which may include a
;; .MODEL line.
;; D? -- Invoke write-diode.
;; Q? -- Invoke write-component. (The "type" attribute is <unknown> in this case so that the
;; SPICE simulator will barf if the user has been careless).
;; M? -- Same as Q.
;; U? -- Invoke write-ic. This provides the opportunity for a component model to be
;; instantiated.
;; X? -- Invoke write-ic. This provides the opportunity for a component subcircuit to be
;; instantiated.
;; V? -- Invoke write-ivs.
;; I? -- Invoke write-ics.
;; 3. Otherwise, just output the refdes, the attached nets and the "value" attribute.
;;
;; Argument List :
;; package - The refdes of a component eg. R1
;; device - The device attribute value for the package
;; file-list - A list of files referred to in the schematic file
(define (spice-msw:write-def-cmpnt package device file-list)
(let
( (first-char (string (string-ref package 0))) ) ;; Extract first char of refdes
(cond
((string-ci=? first-char "A") (spice-msw:write-ic package file-list))
((string-ci=? first-char "C") (spice-msw:write-capacitor package))
((string-ci=? first-char "D") (spice-msw:write-diode package))
((string-ci=? first-char "E") (spice-msw:write-vcvs package))
((string-ci=? first-char "F") (spice-msw:write-cccs package))
((string-ci=? first-char "G") (spice-msw:write-vccs package))
((string-ci=? first-char "H") (spice-msw:write-ccvs package))
((string-ci=? first-char "I") (spice-msw:write-ics package))
((string-ci=? first-char "J") (spice-msw:write-component package #f "<unknown>" (list)))
((string-ci=? first-char "K") (spice-msw:write-coupled-ind package))
((string-ci=? first-char "L") (spice-msw:write-inductor package))
((string-ci=? first-char "M") (spice-msw:write-component package #f "<unknown>" (list)))
((string-ci=? first-char "Q") (spice-msw:write-component package #f "<unknown>" (list)))
((string-ci=? first-char "R") (spice-msw:write-resistor package))
((string-ci=? first-char "S") (spice-msw:write-vc-switch package))
((string-ci=? first-char "M") (spice-msw:write-component package #f "<unknown>" (list)))
((string-ci=? first-char "U") (spice-msw:write-ic package file-list))
((string-ci=? first-char "V") (spice-msw:write-ivs package))
((string-ci=? first-char "W") (spice-msw:write-cc-switch package))
((string-ci=? first-char "X") (spice-msw:write-ic package file-list))
((string-ci=? first-char "Z") (spice-msw:write-mesfet package))
(else
(debug-spew " spice-msw:write-def-cmpnt : ")
(debug-spew (string-append "Found unknown device " device "\n"))
(spice-msw:write-refdes-nets package)
(display (gnetlist:get-package-attribute package "value"))
(newline)
)
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write out component followed by model or model file associated with the component.
;;
;; This function does the following :
;; 1. Writes out the correct refdes prefix (if specified and necessary).
;; 2. Writes out the refdes and nets
;; 3. Looks for "model-name" attribute. Writes it out if it exists.
;; 4. If there is no "model-name" attribute, it writes out the "value" attribute. If there is no
;; "value" attribute, it writes out "unknown" and returns, causing the spice simulator to puke
;; when the netlist is run. This is important because the spice simulator needs to have some
;; indication of what model to look for.
;; 5. Outputs optional attributes attached to device, if any.
;; 6. Outputs a new line
;; 7. Looks for a "model" attribute. If it exists, it writes a .MODEL line like :
;; .MODEL model-name type ( model )
;;
;; Argument List :
;; package - The refdes of a component eg. Q1
;; prefix - The correct refdes prefix for this package type
;; type - The SPICE model type eg. NPN or JFT
;; attrib-list - A list of attributes for the package
(define (spice-msw:write-component package prefix type attrib-list)
(let
( (model-name (gnetlist:get-package-attribute package "model-name"))
(model (gnetlist:get-package-attribute package "model" ))
(value (gnetlist:get-package-attribute package "value" ))
(area (gnetlist:get-package-attribute package "area" ))
(off (gnetlist:get-package-attribute package "off" ))
(model-file (gnetlist:get-package-attribute package "file" )) )
;; Write out the refdes prefix, if required
(if prefix (spice-msw:write-prefix package prefix) )
;; Next we write out the refdes and nets.
(spice-msw:write-refdes-nets package)
;; Look for "model-name" attribute. Write it out if it exists otherwise look for "value" attribute
(if (not (string-ci=? model-name "unknown"))
(display model-name) ;; Display the model-name
(display value) ;; Otherwise display the value
)
;; Next write out attributes if they exist
;; First attribute is area. It is written as a simple string
(if (not (string-ci=? area "unknown"))
(display (string-append " " area))
)
;; Next attribute is off. It is written as a simple string
(if (not (string-ci=? off "unknown"))
(display (string-append " " off))
)
;; Write out remaining attributes
(spice-msw:write-attrib-list package attrib-list)
;; Now write out newline in preparation for writing out model.
(newline)
;; Now write out any model which is pointed to by the part.
(cond
;; One line model and model name exist
( (not (or (string-ci=? model "unknown") (string-ci=? model-name "unknown")))
(begin
(debug-spew " spice-msw:write-component : ")
(debug-spew (string-append "Found model and model-name for " package "\n"))
)
(display (string-append ".MODEL " model-name " " type " (" model ")\n"))
)
;; One line model and component value exist
( (not (or (string-ci=? model "unknown") (string-ci=? value "unknown")))
(begin
(debug-spew " spice-msw:write-component : ")
(debug-spew (string-append "Found model and value for " package "\n"))
)
(display (string-append ".MODEL " model-name " " type " (" value ")\n"))
)
;; Model file and model name exist
( (not (or (string-ci=? model-file "unknown") (string-ci=? model-name "unknown")))
(begin
(debug-spew " spice-msw:write-component : ")
(debug-spew (string-append "Found file and model-name for " package "\n"))
)
)
;; Model file and component value exist
( (not (or (string-ci=? model-file "unknown") (string-ci=? value "unknown")))
(begin
(debug-spew " spice-msw:write-component : ")
(debug-spew (string-append "Found file and value for " package "\n"))
)
)
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write a diode.
;;
;; Write out a valid diode refdes & then call the function which writes the rest of the line.
;;
;; Argument List :
;; package - The refdes of a component eg. D1
(define (spice-msw:write-diode package)
(debug-spew " spice-msw:write-diode : Found a diode\n")
(let
( (attrib-list (list "IC" "TEMP")) )
(spice-msw:write-component package "D" "D" attrib-list)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write out a valid IC or sub-circuit line.
;;
;; The algorithm is as follows :
;; 1. Figure out what type of model goes with this part from file-list. If it isn't listed
;; look for a MODEL attribute. If a MODEL attribute is attached write out SPICE card and then
;; write out .MODEL on next line. If no MODEL attribute is attached just write out what little
;; we know then return.
;; 2. If the model-name is in the file-list, get the associated file-type. Compare it against
;; the component's refdes. If model-type is .MODEL or .SUBCKT and refdes doesn't begin with a U
;; or X respectively, prepend the correct prefix to the refdes.
;; 3. Print out the rest of the line.
;;
;; Argument List :
;; package - The refdes of a component eg. U1
;; file-list - A list of files referred to in the schematic file
(define (spice-msw:write-ic package file-list)
;; First do local assignments
(let
( (first-char (string (string-ref package 0))) ;; extract first char of refdes
(model-name (gnetlist:get-package-attribute package "model-name"))
(model (gnetlist:get-package-attribute package "model"))
(value (gnetlist:get-package-attribute package "value"))
(type (gnetlist:get-package-attribute package "type"))
(model-file (gnetlist:get-package-attribute package "file"))
(list-item (list)) )
(cond
( (string-ci=? first-char "U")
(debug-spew " spice-msw:write-ic : Found a Integrated Circuit\n")
)
( (string-ci=? first-char "X")
(debug-spew " spice-msw:write-ic : Found a Sub-Circuit\n")
)
)
;; First, if model-name is empty, we use value attribute instead.
;; We do this by sticking the contents of "value" into "model-name".
(if (string-ci=? model-name "unknown") (set! model-name value) )
;; Now get item from file-list using model-name as key
(set! list-item (spice-msw:get-file-list-item model-name file-list) )
;; Check if list-item is null
(if (or (null? list-item) (eq? list-item #f))
;; list-item is null. Evidently, we didn't discover any files holding this model.
;; Instead we look for model attribute
(if (not (string-ci=? model "unknown"))
(begin ;; Model attribute exists, write card and model
(debug-spew " spice-msw:write-ic : ")
(debug-spew "Model info not found in model file list, but model attribute exists, write out spice card and .MODEL line\n")
(spice-msw:write-refdes-nets package)
(display (string-append model-name "\n" ))
(display (string-append ".MODEL " model-name " "))
(if (not (string-ci=? type "unknown")) (display (string-append type " ")) ) ;; If no type then just skip it.
(display (string-append "(" model ")\n"))
)
(begin ;; No model attribute either, just write out card
(debug-spew " spice-msw:write-ic : ")
(debug-spew "Model info not found in model file list, no model attribute either\n")
(spice-msw:write-refdes-nets package)
(display (string-append model-name "\n" ))
)
)
;; list-item is not null. Therefore we process line depending upon contents of list-item
(let
( (file-type (caddr list-item)) )
(cond
;; File contains a model
((string-ci=? file-type ".MODEL")
(begin
(debug-spew " spice-msw:write-ic : ")
(debug-spew (string-append "Found .MODEL with model-file and model-name for " package "\n"))
(spice-msw:write-prefix package "U") ;; Write out the refdes prefix, if required
(spice-msw:write-refdes-nets package)
(display (string-append model-name "\n" ))
)
)
;; File contains a subcircuit
((string-ci=? file-type ".SUBCKT")
(begin
(debug-spew " spice-msw:write-ic : ")
(debug-spew (string-append "Found .SUBCKT with model-file and model-name for " package "\n"))
(spice-msw:write-prefix package "X") ;; Write out the refdes prefix, if required
(spice-msw:write-refdes-nets package)
(display (string-append model-name "\n" ))
)
)
)
)
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write an NPN bipolar transistor.
;;
;; Write a valid transistor refdes & then call the function which writes the rest of the line.
;;
;; Argument List :
;; package - The refdes of a component eg. Q1
(define (spice-msw:write-npn package)
(debug-spew " spice-msw:write-npn : Found a NPN Bipolar Transistor\n")
(let
( (attrib-list (list "IC" "TEMP")) )
(spice-msw:write-component package "Q" "NPN" attrib-list)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write a PNP bipolar transistor.
;;
;; Argument List :
;; package - The refdes of a component eg. Q1
(define (spice-msw:write-pnp package)
(debug-spew " spice-msw:write-pnp : Found a PNP Bipolar Transistor\n")
(let
( (attrib-list (list "IC" "TEMP")) )
(spice-msw:write-component package "Q" "PNP" attrib-list)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write an N-channel JFET transistor.
;;
;; Argument List :
;; package - The refdes of a component eg. J1
(define (spice-msw:write-nfet package)
(debug-spew " spice-msw:write-nfet : Found a N-channel JFET\n")
(let
( (attrib-list (list "IC" "TEMP") ))
(spice-msw:write-component package "J" "NJF" attrib-list)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write a P-channel JFET transistor.
;;
;; Argument List :
;; package - The refdes of a component eg. J1
(define (spice-msw:write-pfet package)
(debug-spew " spice-msw:write-pfet : Found a P-channel JFET\n")
(let
( (attrib-list (list "IC" "TEMP")) )
(spice-msw:write-component package "J" "PJF" attrib-list)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write a PMOS transistor.
;;
;; Argument List :
;; package - The refdes of a component eg. M1
(define (spice-msw:write-pmos package)
(debug-spew " spice-msw:write-pmos : Found a PMOS Transistor\n")
(let
( (attrib-list (list "L" "W" "AS" "AD" "PD" "PS" "NRD" "NRS" "TEMP" "IC" "M")) )
(spice-msw:write-component package "M" "PMOS" attrib-list)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write a NMOS transistor.
;;
;; Argument List :
;; package - The refdes of a component eg. M1
(define (spice-msw:write-nmos package)
(debug-spew " spice-msw:write-nmos : Found a NMOS Transistor\n")
(let
( (attrib-list (list "L" "W" "AS" "AD" "PD" "PS" "NRD" "NRS" "TEMP" "IC" "M")) )
(spice-msw:write-component package "M" "NMOS" attrib-list)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write a subckt PMOS transistor.
;;
;; Argument List :
;; package - The refdes of a component eg. X1
(define (spice-msw:write-pmos-subckt package)
(debug-spew " spice-msw:write-pmos-subckt : Found a PMOS Transistor sub-circuit\n")
(let
( (attrib-list (list "L" "W" "AS" "AD" "PD" "PS" "NRD" "NRS" "TEMP" "IC" "M")) )
(spice-msw:write-component package "X" "PMOS" attrib-list)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write a subckt NMOS transistor.
;;
;; Argument List :
;; package - The refdes of a component eg. X1
(define (spice-msw:write-nmos-subckt package)
(debug-spew " spice-msw:write-nmos-subckt : Found a NMOS Transistor sub-circuit\n")
(let
( (attrib-list (list "L" "W" "AS" "AD" "PD" "PS" "NRD" "NRS" "TEMP" "IC" "M")) )
(spice-msw:write-component package "X" "NMOS" attrib-list)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write a MESFET transistor.
;;
;; Argument List :
;; package - The refdes of a component eg. Z1
(define (spice-msw:write-mesfet package)
(debug-spew " spice-msw:write-mesfet : Found a MESFET Transistor\n")
(let
( (attrib-list (list "IC")) )
(spice-msw:write-component package "Z" "MESFET" attrib-list)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write a voltage controled switch.
;;
;; Argument List :
;; package - The refdes of a component eg. S1
(define (spice-msw:write-vc-switch package)
(debug-spew " spice-msw:write-vc-switch : Found a Voltage Controlled Switch\n")
(let
( (attrib-list (list " ")) )
(spice-msw:write-component package "S" "SW" attrib-list)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write a current controled switch.
;;
;; Argument List :
;; package - The refdes of a component eg. W1
(define (spice-msw:write-cc-switch package)
(debug-spew " spice-msw:write-cc-switch : Found a Voltage Controlled Switch\n")
(let
( (attrib-list (list " ")) )
(spice-msw:write-component package "W" "CSW" attrib-list)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write a resistor.
;;
;; Argument List :
;; package - The refdes of a component eg. R1
(define (spice-msw:write-resistor package)
(debug-spew " spice-msw:write-resistor : Found a Resistor\n")
;; Write out the refdes prefix, if required
(spice-msw:write-prefix package "R")
;; First write out refdes and attached nets
(spice-msw:write-refdes-nets package)
;; Next write mandatory resistor value if it exists.
(let
( (value (gnetlist:get-package-attribute package "value")) )
(if (not (string-ci=? value "unknown"))
(display value)
)
)
;; Next write our model name if it exists
(let
( (model-name (gnetlist:get-package-attribute package "model-name")))
(if (not (string-ci=? model-name "unknown"))
(display (string-append " " model-name))
)
)
;; next create list of attributes which can be attached to a resistor.
;; I include non-standard "area" attrib here per popular demand.
(let
((attrib-list (list "AREA" "L" "W" "TEMP")))
(spice-msw:write-attrib-list package attrib-list) ;; write the attributes (if any) separately
)
;; finally output a new line
(newline)
)
;;--------------------------------------------------------------------------------------------------
;; Write a capacitor.
;;
;; Argument List :
;; package - The refdes of a component eg. C1
(define (spice-msw:write-capacitor package)
(debug-spew " spice-msw:write-capacitor : Found a Capacitor\n")
;; Write out the refdes prefix, if required
(spice-msw:write-prefix package "C")
;; first write out refdes and attached nets
(spice-msw:write-refdes-nets package)
;; next write capacitor value, if any. Note that if the
;; component value is not assigned nothing will be written out.
(let
( (value (gnetlist:get-package-attribute package "value")) )
(if (not (string-ci=? value "unknown"))
(display value)
)
)
;; next write capacitor model name, if any. This is applicable to
;; semiconductor caps used in chip design.
(let
( (model-name (gnetlist:get-package-attribute package "model-name")) )
(if (not (string-ci=? model-name "unknown"))
(display (string-append " " model-name))
)
)
;; Next write out attributes if they exist. Use
;; a list of attributes which can be attached to a capacitor.
;; I include non-standard "area" attrib here per request of Peter Kaiser.
(let
( (attrib-list (list "AREA" "L" "W" "IC")) )
(spice-msw:write-attrib-list package attrib-list)
)
(newline)
)
;;--------------------------------------------------------------------------------------------------
;; Write an inductor.
;;
;; Argument List :
;; package - The refdes of a component eg. L1
(define (spice-msw:write-inductor package)
(debug-spew " spice-msw:write-inductor : Found a Inductor\n")
;; Write out the refdes prefix, if required
(spice-msw:write-prefix package "L")
;; first write out refdes and attached nets
(spice-msw:write-refdes-nets package)
;; next write inductor value, if any. Note that if the
;; component value is not assigned, then it will write "unknown"
(let
( (value (gnetlist:get-package-attribute package "value")) )
(display value)
)
;; create list of attributes which can be attached to a inductor
(let
( (attrib-list (list "L" "W" "IC")) )
(spice-msw:write-attrib-list package attrib-list)
)
(newline)
)
;;--------------------------------------------------------------------------------------------------
;; Write an independent voltage source.
;;
;; The behavior of the voltage source is held in the "value" attribute.
;;
;; Argument List :
;; package - The refdes of a component eg. V1
(define (spice-msw:write-ivs package)
(debug-spew " spice-msw:write-ivs : Found a Independent Voltage Source\n")
;; Write out the refdes prefix, if required
(spice-msw:write-prefix package "V")
;; First write out refdes and attached nets
(spice-msw:write-refdes-nets package)
;; Next write voltage value, if any. Note that if the voltage value is not assigned, then it will
;; write "unknown".
(let
( (value (gnetlist:get-package-attribute package "value")) )
(display value)
)
(newline)
)
;;--------------------------------------------------------------------------------------------------
;; Write an independent current source.
;;
;; The behavior of the current source is held in the "value" attribute
;;
;; Argument List :
;; package - The refdes of a component eg. I1
(define (spice-msw:write-ics package)
(debug-spew " write-ics : Found a Independent Current Source\n")
;; Write out the refdes prefix, if required
(spice-msw:write-prefix package "I")
;; First write out refdes and attached nets
(spice-msw:write-refdes-nets package)
;; Next write current value, if any. Note that if the current value is not assigned, then it will
;; write "unknown".
(let
( (value (gnetlist:get-package-attribute package "value")) )
(display value)
)
(newline)
)
;;--------------------------------------------------------------------------------------------------
;; Write a current controlled voltage source and implement the necessary current measuring voltage
;; source.
;;
;; Argument List :
;; package - The refdes of a component eg. H1
(define (spice-msw:write-ccvs package)
(debug-spew " spice-msw:write-ccvs : Found a Current Controlled Voltage Source\n")
;; Write out the refdes prefix, if required
(spice-msw:write-prefix package "H")
;; Implement the controlled current source
(display (string-append package " "))
(spice-msw:write-two-pin-names package "1" "2")
(display (string-append "Vsense_" package " " (spice-msw:component-value package) "\n" ))
;; Implement the current measuring voltage source
(display (string-append "Vsense_" package " "))
(spice-msw:write-two-pin-names package "3" "4")
(display "DC 0\n")
;; It's possible to leave the output voltage source unconnected, SPICE won't complain about
;; unconnected nodes
(display (string-append "IOut_" package " "))
(spice-msw:write-two-pin-names package "1" "2")
(display "DC 0\n")
)
;;--------------------------------------------------------------------------------------------------
;; Write a current controlled current source and implement the necessary current measuring voltage
;; source.
;;
;; Argument List :
;; package - The refdes of a component eg. F1
(define (spice-msw:write-cccs package)
(debug-spew " spice-msw:write-cccs : Found a Current Controlled Current Source\n")
;; Write out the refdes prefix, if required
(spice-msw:write-prefix package "F")
;; Implement the controlled current source
(display (string-append package " "))
(spice-msw:write-two-pin-names package "1" "2")
(display (string-append "Vsense_" package " " (gnetlist:get-package-attribute package "value") "\n"))
;; Implement the current measuring voltage source
(display (string-append "Vsense_" package " "))
(spice-msw:write-two-pin-names package "3" "4")
(display "DC 0\n")
)
;;--------------------------------------------------------------------------------------------------
;; Write a voltage controlled current source and implement the necessary voltage measuring current
;; source.
;;
;; Argument List :
;; package - The refdes of a component eg. G1
(define (spice-msw:write-vccs package)
(debug-spew " spice-msw:write-vccs : Found a Voltage Controlled Current Source\n")
;; Write out the refdes prefix, if required
(spice-msw:write-prefix package "G")
;; Implement the controlled current source
(display (string-append package " "))
(spice-msw:write-net-names package)
(display (string-append (spice-msw:component-value package) "\n"))
;; Implement the voltage measuring current source
;; Imagine copying the voltage of a voltage source with an internal impedance, SPICE complains
;; about unconnected nets if this current source is not here.
(display (string-append "IMeasure_" package " "))
(spice-msw:write-two-pin-names package "3" "4")
(display "DC 0\n")
)
;;--------------------------------------------------------------------------------------------------
;; Write a voltage controlled voltage source and implement the necessary voltage measuring current
;; source.
;;
;; Argument List :
;; package - The refdes of a component eg. E1
(define (spice-msw:write-vcvs package)
(debug-spew " spice-msw:write-vcvs : Found a Voltage Controlled Voltage Source\n")
;; Write out the refdes prefix, if required
(spice-msw:write-prefix package "E")
;; Implement the controlled voltage source
(display (string-append package " "))
(spice-msw:write-net-names package)
(display (string-append (gnetlist:get-package-attribute package "value") "\n" ))
;; Implement the voltage measuring current source
;; Imagine copying the voltage of a voltage source with an internal impedance, SPICE complains
;; about unconnected nets if this current source is not here.
(display (string-append "Isense_" package " "))
(spice-msw:write-two-pin-names package "3" "4")
(display "DC 0\n")
;; With an output current source it is possible to leave the output voltage source unconnected,
;; SPICE won't complain about unconnected nodes
(display (string-append "IOut_" package " "))
(spice-msw:write-two-pin-names package "1" "2")
(display "DC 0\n")
)
;;--------------------------------------------------------------------------------------------------
;; Create a nullor, make sure it consists of a voltage controlled source.
;;
;; Argument List :
;; package - The refdes of a component eg. E1
(define (spice-msw:write-nullor package)
(debug-spew " spice-msw:write-nullor : Found a Nullor\n")
(let
( (value (gnetlist:get-package-attribute package "value")) )
;; Write out the refdes prefix, if required
(spice-msw:write-prefix package "E")
;; Implement the controlled voltage source
(display (string-append package " "))
(spice-msw:write-net-names package)
(display (string-append (if (string-ci=? value "unknown") "1000Meg" value) "\n"))
;; Implement the voltage measuring current source.
;; Imagine yourself copying the voltage of a voltage source with an internal impedance, SPICE
;; complains about unconnected nets if this current source is not here.
(display (string-append "IMeasure_" package " "))
(spice-msw:write-two-pin-names package "3" "4")
(display "DC 0\n")
;; With an output current source it is possible to leave the output voltage source unconnected,
;; SPICE won't complain about unconnected nodes
(display (string-append "IOut_" package " "))
(spice-msw:write-two-pin-names package "1" "2")
(display "DC 0\n")
)
)
;;--------------------------------------------------------------------------------------------------
;; Write a Josephson junction.
;;
;; Argument List :
;; package - The refdes of a component eg. B1
(define (spice-msw:write-joseph-jn package)
(debug-spew " spice-msw:write-joseph-jn : Found a Josephson junction\n")
;; Write out the refdes prefix, if required
(spice-msw:write-prefix package "B")
;; First write out refdes and attached nets
(spice-msw:write-refdes-nets package)
;; Next, add a dummy node for JJ phase. Unlike in Xic netlister, give it
;; a reasonable name, not a number, eg. refdes
(display (string-append package " "))
;; Next write JJ model name, if any.
(let
((model-name (gnetlist:get-package-attribute package "model-name")))
(if (not (string-ci=? model-name "unknown")) (display (string-append model-name " " )))
)
;; Next write out attributes if they exist. Use a list of attributes which can be attached to a
;; junction.
(spice-msw:write-attrib-list package (list "AREA"))
(newline)
)
;;--------------------------------------------------------------------------------------------------
;; Write a coupled (mutual) inductor.
;;
;; Argument List :
;; package - The refdes of a component eg. K1
(define (spice-msw:write-coupled-ind package)
(debug-spew " spice-msw:write-coupled-ind : Found a coupled (mutual) inductor\n")
;; Write out the refdes prefix, if required
(spice-msw:write-prefix package "K")
;; First write out refdes and attached nets (none)
(spice-msw:write-refdes-nets package)
;; Next two inductor names and value
(let
( (inductors (gnetlist:get-package-attribute package "inductors"))
(value (gnetlist:get-package-attribute package "value")) )
(if (not (string-ci=? inductors "unknown")) (display (string-append inductors " " )))
(if (not (string-ci=? value "unknown")) (display (string-append value " " )))
)
(newline)
)
;;--------------------------------------------------------------------------------------------------
;; Write a voltage probe.
;;
;; Argument List :
;; package - The refdes of a component eg. R1
(define (spice-msw:write-probe package)
(debug-spew " spice-msw:write-probe : Found a probe\n")
(let
((value (gnetlist:get-package-attribute package "value")) )
(if (string-ci=? value "unknown") (set! value "TRAN") )
(display (string-append "* Probe device " package " on nets "))
(spice-msw:write-net-names package)
(newline)
(display (string-append ".print " value " +"))
(spice-msw:write-net-names package
(string-join (map (lambda (x) "V(~a)") (gnetlist:get-pins package)) " " 'infix) ) ;; make format string
(newline)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write a prefix if first char of refdes is improper.
;;
;; Eg. if MOSFET is named T1 then it becomes MT1 in the SPICE file.
;;
;; Argument List :
;; package - The refdes of a component eg. R1
;; prefix - The desired prefix character
(define (spice-msw:write-prefix package prefix)
(let
( (different-prefix (not (string-ci=? (substring package 0 1) prefix)))
(nomunge-mode (calling-flag? "nomunge_mode" (gnetlist:get-calling-flags))) )
(debug-spew " spice-msw:write-prefix : Check refdes ")
(debug-spew (string-append "prefix = " (substring package 0 1)))
(debug-spew (string-append " (correct prefix = " prefix ")\n"))
(if (and different-prefix (not nomunge-mode)) (display prefix))
)
)
;;--------------------------------------------------------------------------------------------------
;; Given a refdes, and optionally a format string, write out the nets attached to the component's
;; pins.
;;
;; If it's not called with a format string it looks for one in the net-format attribute, otherwise
;; it writes out the pins unformatted. This is used to write out non-slotted parts.
;;
;; Argument List :
;; ???
(define (spice-msw:write-net-names refdes . format)
;; get-net-name - helper function. Called with pinseq, returns net name, unless net name is
;; "ERROR_INVALID_PIN" then it returns false.
(define (get-net-name pin)
(set! pin (number->string pin))
;; ------- Super debug stuff --------
(if #f
(begin
(debug-spew " spice-msw:write-net-names :\n")
(debug-spew (string-append " pin-name = " pin "\n"))
(debug-spew (string-append " pinnumber = "
(gnetlist:get-attribute-by-pinseq refdes pin "pinnumber") "\n"))
(debug-spew (string-append " pinseq = "
(gnetlist:get-attribute-by-pinseq refdes pin "pinseq")))
(if (not (string-ci=? pin (gnetlist:get-attribute-by-pinseq refdes pin "pinseq")))
(debug-spew " <== INCONSISTENT!\n")
(debug-spew "\n")
)
(debug-spew (string-append " netname = "
(car (spice-msw:get-net refdes (gnetlist:get-attribute-by-pinseq refdes pin "pinnumber"))) "\n"))
)
)
;; -------------------------------------
(set! pin (car (spice-msw:get-net refdes (gnetlist:get-attribute-by-pinseq refdes pin "pinnumber"))))
(if (string-ci=? pin "ERROR_INVALID_PIN")
(begin
(debug-spew (string-append "For " refdes ", found pin with no pinseq attribute. Ignoring. . . .\n"))
#f
)
pin
)
)
;; First do local assignments
(let
( (netnames (filter-map get-net-name (range 1 (length (gnetlist:get-pins refdes))))) )
(if (null? format) ;; Format agument take priority, otherwise use attribute
(set! format (gnetlist:get-package-attribute refdes "net-format"))
(set! format (car format))
)
(if (string-ci=? format "unknown")
(display (string-join netnames " " 'suffix)) ;; Write out nets.
(apply simple-format (cons #t (cons format netnames))) ;; Write out nets with format string
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Return a list of all the integers from start to stop, with the optional step size.
;;
;; It is similar to perl's range operator '..'
;;
;; Argument List :
;; ???
(define (range start stop . step)
(if (null? step)
(iota (+ (- stop start) 1) start)
(begin
(set! step (car step))
(iota (+ (ceiling (/ (- stop start) step)) 1) start step)
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Write the refdes and the net names connected to pins on this component.
;;
;; No component value is written or extra attributes. Those are handled later.
;;
;; Argument List :
;; package - The refdes of a component eg. R1
(define (spice-msw:write-refdes-nets package)
(display (string-append package " ")) ;; Write component refdes
(spice-msw:write-net-names package) ;; Write the net names
)
;;--------------------------------------------------------------------------------------------------
;; Include SPICE statements from a directive block.
;;
;; Argument List :
;; package - The refdes of a component eg. ???
(define (spice-msw:write-directive package)
(debug-spew " spice-msw:write-directive : Found a SPICE directive\n")
;; Collect variables used in creating spice code
(let
( (value (gnetlist:get-package-attribute package "value"))
(file (gnetlist:get-package-attribute package "file")) )
(cond
;; First look to see if there is a value.
((not (string-ci=? value "unknown"))
(begin
(display (string-append value "\n"))
(debug-spew (string-append "Appending value = \"" value "\" to output file.\n"))
)
)
;; Since there is no value, look for file.
((not (string-ci=? file "unknown"))
(begin
(spice-msw:insert-text-file file) ;; Note that we don't wait until the end here. Is that OK?
(debug-spew (string-append "Inserting contents of file = " file " into output file.\n"))
)
)
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Include a file using an .INCLUDE directive.
;;
;; Argument List :
;; package - The refdes of a component eg. .INCLUDE
(define (spice-msw:write-include package)
(debug-spew " spice-msw:write-include : Found a .INCLUDE directive\n")
(let
( (file (gnetlist:get-package-attribute package "file")) )
(if (not (string-ci=? file "unknown"))
(if (calling-flag? "embedd_mode" (gnetlist:get-calling-flags))
(begin
(spice-msw:insert-text-file file)
(debug-spew (string-append "embedding contents of file " file " into netlist.\n"))
)
(begin
(display (string-append ".INCLUDE " file "\n"))
(debug-spew "placing .include directive string into netlist.\n")
)
)
(debug-spew "silently skip \"unknown\" file.\n")
)
)
)
;;--------------------------------------------------------------------------------------------------
;; Include an option using an .OPTIONS directive.
;;
;; Argument List :
;; package - The refdes of a component eg. .OPTIONS
(define (spice-msw:write-options package)
(debug-spew " spice-msw:write-options : Found a .OPTIONS directive\n")
(display (string-append ".OPTIONS " (gnetlist:get-package-attribute package "value") "\n"))
)
;;--------------------------------------------------------------------------------------------------
;; Include a spice model (instantiated as a model box on the schematic).
;;
;; Two types of model can be included:
;; 1. An embedded model, which is a one- or multi-line string held in the attribute "model".
;; In this case, the following attributes are mandatory :
;; - model (i.e. list of parameter=value strings)
;; - model-name
;; - type
;; In this case, the function creates and formats the correct spice model line(s).
;; 2. A model held in a file whose name is held in the attribute "file"
;; In this case, the following attribute are mandatory :
;; - file (i.e. list of parameter=value strings)
;; In this case, the function just opens the file and dumps the contents into the netlist.
;;
;; Argument List :
;; package - The refdes of a component eg. .MODEL
(define (spice-msw:write-model package)
(debug-spew " spice-msw:write-model : Found a .MODEL directive")
;; Collect variables used in creating spice code
(let
( (model-name (gnetlist:get-package-attribute package "model-name"))
(model-file (gnetlist:get-package-attribute package "file"))
(model (gnetlist:get-package-attribute package "model"))
(type (gnetlist:get-package-attribute package "type")) )
;; Now, depending upon what combination of model, model-file, and model-name
;; exist (as described above) write out lines into spice netlist.
(cond
;; one model and model name exist
((not (or (string-ci=? model "unknown") (string-ci=? model-name "unknown")))
(debug-spew (string-append " and model and model-name for " package "\n"))
(display (string-append ".MODEL " model-name " " type " (" model ")\n"))
)
;; model file exists
((not (or (string-ci=? model-file "unknown") ))
(debug-spew (string-append " and model-file for " package "\n"))
)
(else
(debug-spew " but no model, model-name or model-file\n")
)
)
)
)
;;**************************************************************************************************