Brief overview of how two different databases are queried to create various AutoCAD Electrical BOM reports.

This question comes up from time to time, most recently today. Here is a brief summary in the form of screenshots illustrating how a component on an AutoCAD Electrical drawing (a mechanical footprint symbol on a panel layout drawing) finds its way on to a BOM report. This illustrates just a simple, straightforward catalog assignment – without “ASSYCODE” and without “Multi-BOM” catalog assignments (future posting!).

A small portion of one drawing, DEMO08.dwg, which is part of a sample AutoCAD Electrical project drawing set “WDDEMO”, is shown below.

AutoCAD Electrical maintains a “scratch” database file, in Microsoft Access format, that follows what is going on in the project drawing set (it does not drive it, it follows it). The above mechanical footprint component, SS433 on drawing DEMO08.dwg of the project, shows up in the “PNLCOMP” table of the scratch database file for this project.

 The scratch database file name is the same name as the active AutoCAD Electrical project name but with an “.mdb” extension. It is saved in the local AutoCAD Electrical “user” folder. The full name can be displayed by typing this at the AutoCAD “Command:” prompt.

 Command:  (c:wd_mdb_get_proj_scratch_dbnam nil) [Enter]

 Here is a screenshot of the above panel component in the PNLCOMP table of the project scratch database:

And here’s another screenshot of the above record with a few other fields exposed. These fields are used to guide AutoCAD Electrical’s BOM reporting command to the appropriate “table” in the catalog lookup database file DEFAULT_CAT.mdb (shown shortly).

The actual table name that the BOM report queries for this “SS433″ symbol’s catalog description information is influenced by the WDBLKNAM value shown above. See this posting for a description of how auto-table selection works.

Ultimately, the BOM reporting goes to table “SS” in the DEFAULT_CAT.mdb file. It uses the MFG/CAT attribute values carried on the panel footprint symbol (and extracted into the PNLCOMP table shown above) to find the appropriate record in the “SS” table shown here:

And now the BOM reporting command merges the data in the record above with the data from the scratch database file. It is formatted into the report and shows up as an entry here in the BOM Report Generator dialog ( ! ):

Now, at this point, you can write the report out to a file (in various formats) or insert the report as a “smart” table on to your AutoCAD drawing.

The Autodesk development team responsible for AutoCAD Electrical wants your feedback. Here’s a note from Autodesk’s Jose Santos:

Are you interested in shaping the future of AutoCAD Electrical?

 The AutoCAD Electrical team is offering two great opportunities if you work with schematics for controls, switchgear, power, process, and instrumentation, and are attending Autodesk University 2009 in Las Vegas:

 Product Usability Evaluation

Various sessions. Nov 30 – Dec 3, 2009

Register here.

 Power, Controls, and Instrumentation Unplugged

November 30, 2009.  2-4pm

Register here.

 If you can’t attend but are interested in keeping in touch with the AutoCAD Electrical team for future events, register here.

Wire number tags based upon connected component tag-ID at each end.

Some time ago we had this posting that dealt with a wire numbering tool utility. It would generate a wire number tag based upon combining the tag-ID and termination pin number of the component connection at each end of the wire. This generated explicit but really “long” wire numbers.

Here’s an example:

Yes, really long wire numbers ( ! )

Request for a Simplified Version

A user in Australia wanted to do this but make the tags shorter. He just wanted to concatenate the two tag-IDs and then add an alpha suffix to keep each wire number unique. No connection pin numbers embedded in the wire number.

For example, in the above drawing, the upper right-hand wire number would be the two device tags jammed together, “SS406TD406″, and an alpha sufffix, let’s say “A”.

Now there are two more wires that tie the same two devices together: the right-hand wire leaving the two child contacts on the selector switch. Both will be “SS406TD406″. So the utility would need to add a “B” and a “C” to each respectively to keep the wire numbers unique.

Modifying the existing milnum_alldwg.lsp utility

So, let’s start with the previous post’s lsp utility, copy it to a new file name, “milnumx_alldwg.lsp”. Open it up in AutoCAD’s Visual Lisp editor (type vlide [enter] at the “Command:” prompt) or open in any ASCII text editor (like WordPad.exe) and let’s have some fun.

Step 1 – this is the easiest part. We want to bypass the original utility’s task of adding in the connection pin numbers. Here is the before and after code:

BEFORE:

                    (if (= flipit 1)
                      (progn ; reverse the order
                        (setq new_wireno comp2_tag)
                        (if (AND pin2 (/= pin2 ""))(setq new_wireno (strcat new_wireno "-" pin2)))
                        (setq new_wireno (strcat new_wireno "/" comp1_tag))
                        (if (AND pin1 (/= pin1 ""))(setq new_wireno (strcat new_wireno "-" pin1)))
                      )
                    ; ELSE
                      (progn ; normal order of wire number format                  
                        (setq new_wireno comp1_tag)
                        (if (AND pin1 (/= pin1 ""))(setq new_wireno (strcat new_wireno "-" pin1)))
                        (setq new_wireno (strcat new_wireno "/" comp2_tag))
                        (if (AND pin2 (/= pin2 ""))(setq new_wireno (strcat new_wireno "-" pin2)))
                    ) )   
                    (c:wd_putwnf en new_wireno) ; put the wire number on wire
AFTER:
                    (if (= flipit 1)
                      (progn ; reverse the order
                        (setq new_wireno (strcat comp2_tag comp1_tag)) ; just jam two tags together, no delimiter
                      )
                    ; ELSE
                      (progn ; normal order of wire number format                   
                        (setq new_wireno (strcat comp2_tag comp1_tag)) ; just jam two tags together, no delimiter
                    )  )  
                    (c:wd_putwnf en new_wireno) ; put the wire number on wire

Step 2 – the harder part. Okay, we have the base wire number figured out above and pushed into lisp variable “new_wireno”. But we need to check each wire number and make sure it is unique. We add an incrementing alpha suffix to the wire number until it is unique.

This means that we need to first extract a list of all existing wire numbers on the active drawing (could do for all dwgs in project but that will be an upcoming blog posting). Then, when we generate a new wire number, we compare against the existing wire number list and, if a repeat found, keep incrementing the suffix for our new wire number until we find one that isn’t already in the list.

So, here’s a little subroutine we’ll add to our milnumx_alldwg.lsp utility. It runs at the front end of our utility to establish a list of all existing wire number assignments.

Here’s how it works… it creates a “selection set” of all wire number block inserts found on the active drawing. AutoCAD Electrical wire numbers have block names that begin with either “WD_WNH” or WD_WNV”. So the “ssget” line below gets all instances of wire number block inserts on the active drawing.

Then we cycle through this list, one at a time, and get each wire number block insert instance, the “(setq en (ssname sswn ixwn))” line below. Then we get the wire number attribute value, WIRENO or WIRENOF. Add to the running list of wire numbers, loop back to the top of the loop, and process the next wire number block insert instance. When done, all of the drawing’s wire numbers are sitting in AutoLISP variable “lst”. This data is returned from this function.

ALL NEW:

  (defun milnumx_get_all_existing_wirenums ( / sswn ixwn slenwn lst )
    ; Extract a list of all wire numbers found on the active drawing. Create a selection
    ; set of all block insert instances that have block name "WD_WNH*" or "WD_WNV*". There
    ; are AutoCAD Electrical wire number block names.
    (setq lst nil)
    (setq sswn (ssget "_X" '((-4 . "<AND")(0 . "INSERT")(2 . "WD_WNH*,WD_WNV*")(-4 . "AND>"))))
    (if (/= sswn nil)
      (progn ; some wire number block instances found. Process them.
        (setq slenwn (sslength sswn)) ; number of block instances found
        (setq ixwn 0) ; this will be used to index through the blocks
        (while (< ixwn slenwn)
          (setq en (ssname sswn ixwn)) ; get next block instance entity name
          ; Get WIRENO* attribute value off of this wire number block insert
          (setq wn (c:wd_getattrval en "WIRENO*"))
          (if (AND wn (/= wn "") (not (member wn lst)))
            (progn ; add to the running list
              (setq lst (cons wn lst))
          ) )
          (setq ixwn (1+ ixwn))
    ) ) )
    (setq sswn nil) ; release the selection set
    lst ; return the list of existing wire numbers found on active drawing
  )

Step 3 – Putting it all together. Now we add a call to our wire number collection function to capture a list of all wire numbers and dump into AutoLISP variable name “existing_wnum_list”. We do this toward the beginning of the utility as shown here:

  ; -- main routine starts here --                  

  ; Two options here. Uncomment first two lines and uncomment third line to prompt
  ; user to "window" what wires to process. Or, comment out the first two lines and
  ; uncomment the third line to process all wires on active drawing without any
  ; user prompts.

;;;  (princ "\nSelect wire or wires to process for special source/dest wire number format")
;;;  (setq ss (ssget '((0 . "LINE")))) ; user windows what to process
  (setq ss (ssget "_X" '((0 . "LINE")))) ; automatically process all wires on active dwg

  (if (/= ss nil)
    (progn

      ; Get list of all existing wire numbers
      (setq existing_wnum_list (milnumx_get_all_existing_wirenums)) ; ** 12-Nov-09 NEHolt
         
      (setq slen (sslength ss)) ; number of LINE entities selected
      (setq lines_processed_entlist nil) ; used to track what has been processed
      (setq ix 0) ; used to index through the selection set
      (while (< ix slen)

… and we go back to what we did in Step 1. We add a “foreach” loop just below the point where we have generated the raw “component1-component2″ tag. We want to find the next suffix character that keeps this proposed wire number unique.

                    (if (= flipit 1)
                      (progn ; reverse the order
                        (setq new_wireno (strcat comp2_tag comp1_tag)) ; just jam two tags together, no delimiter
                      )
                    ; ELSE
                      (progn ; normal order of wire number format                  
                        (setq new_wireno (strcat comp1_tag comp2_tag)) ; just jam two tags together, no delimiter                       
                    ) )   
                    ; Now add an incrementing alpha suffix to the wire number until
                    ; a unique wire number is found (one that does not appear to have
                    ; already been used elsewhere on this drawing).
                    ; "existing_wnum_list" is the list of existing wire numbers
                    ; collected for the active drawing.

                    (setq alphalst (list "A" "B" "C" "D" "E" "F" "G" "H" "J" "K" "L" "M" "N"
                                         "P" "R" "S" "T" "U" "V" "W" "X" "Y" "Z" "A1" "A2"))
                    (setq hit nil)
                    (foreach suffix alphalst
                      (if (not hit)
                        (progn ; don't have a unique number yet. Try this one.
                          (setq x (strcat new_wireno suffix))
                          (if (not (member x existing_wnum_list))
                            (progn ; Yes, found next available suffix that yields a
                                   ; unique wire number!
                              ; Add this new wire number to the running list
                              (setq existing_wnum_list (cons x existing_wnum_list))
                              (setq hit T) ; to bypass the rest of this "foreach" loop
                              (setq new_wireno x)
                          ) )
                    ) ) )                                        
                    (if (not hit)
                      (progn ; didn't find a unique wire number suffix. Add "???"
                        (setq new_wireno (strcat new_wireno "???"))
                    ) )
                    (c:wd_putwnf en new_wireno) ; put the wire number on wire

There it is. Let’s test. Save the above file. APPLOAD it. Then type MILNUM_ALLDWG [Enter] at the Command: prompt.

Download full file here

UPDATE: found typo in the uploaded file (13-Nov-2009). Fixed and reposted.

Adding a new option to the “Spreadsheet to PLC I/O” drawing generator tool – pre-defining wire numbers right in the spreadsheet.

This AutoCAD Electrical tool is pretty flexible. Using Excel, you lay out your control system’s I/O module requirements and out pops a set of 75-80% complete PLC I/O drawings.

For example, the first three lines of this example spreadsheet drives the AutoCAD Electrical Spreadsheet to PLC I/O utility to generate the circuitry shown below. But wouldn’t it be nice if we could pre-define the existing wire number assignments that tie into the two customer-supplied interlocks?

How to add this new feature

This is not too difficult. One thing that makes it possible is that this Spreadsheet to PLC I/O generator tool runs is an AutoLISP function that runs totally bare. It is supplied and runs in full-source mode, file name “wdio.lsp”. This means you are free to modify your copy of this tool.

The second thing that makes adding this new option easy-to-do is that the tool is already set up to support “piggy-backed” attribute assignments.  For example, in the row of your spreadsheet for I/O point “I:003/10″ you’ve entered the block name for a N.O. temperature switch, block name “HTS11″. In the D3DESC column you’ve entered a description for this switch, “SLURRY HEAT READY”. But you’d also like to define the “RATING1″ value for this switch. But your spreadsheet has no column for RATING1 for the 3rd connected component. No problem. Just piggy-back the RATING1 assignment to the D3DESC value:

D3DESC value before:  SLURRY HEAT READY

D3DESC value after: SLURRY HEAT READY;RATING1=95C

We’ll use this same idea to flag pre-defined wire number insertion on each side of a component. Instead of a name of an attribute, we’ll use these names:  $WNL and $WNR for “wire number left side” and “wire number right side”.

So, let’s say that we want to pre-define wire number assignments “TS-100″ and “TS-101″ for this temperature switch in our spreadsheet. We’d enter this:

D3DESC value: SLURRY HEAT READY;RATING1=95C;$WNL=TS-100;$WNR=TS-101

So, that’s how we’ll set up our Excel spreadsheet to define wire number assignments. Now, the key piece is to modify the “wdio.lsp” file to be ready to recognize that a piggy-backed attribute name that is $WNL or $WNR is really a flag for a wire number insert.

Step 1 – find the wdio.lsp utility. A good way to do this is to type this at your AutoCAD Electrical ”Command:” prompt

(c:ace_find_file “wdio.lsp” 3) [Enter]

If it can be found, the full path will display. Ignore the doubled-up back-slashes. It’s a Lisp thing.

Step 2 – MAKE BACK-UP COPY OF wdio.lsp. Important! Safety first.

Step 3 – Open wdio.lsp with any ASCII text editor or use AutoCAD’s Visual Lisp editor (type vlide [enter] at Command: prompt)

Step 4 – find this function within wdio.lsp file

Step 5 – Carefully cut and paste the code below to replace everything shown in the screenshot above.

  ; --
  (defun wdio_write_out_accum_extra_attr_data ( en lst2 / atnam atval x xx hit_wen lstx)
    ; "lst2" = (list (list attrnam attrval) (list attrnam attrval) ...)
    (foreach x lst2
; ** 06-Nov-09 NEHolt.begin, N8 Consultants LLC     
      (cond
        ((wcmatch (strcase (car x)) "$WNL,$WNT,$WNR,$WNB") ; Look for special wire number flag
          ; masquerading as an attribute tag name. When found, the "attribute value" associated
          ; with it will be the desired fixed wire number value.
          ; The name of the flag indicates which "side" of the inserted component "en" that
          ; the wire number goes with.
          ; Get component's wire connection data
          (setq lstx (c:wd_get_sym_pntlst en 1 nil))
          (setq hit_wen nil)
          (foreach xx lstx
            ; Going through each wire connection returned from the component that was
            ; just inserted (entity name "en"). Each sublist has the X?TERMxx wire connection
            ; direction (the "?" part) held in (nth 4...) element. If any wires tied to
            ; this connection, they are held in a list of entity names in (nth 3...) element.
            (cond
              ((/= hit_wen nil)) ; already processed this wire number, skip
              ((= (nth 3 xx) nil)) ; no wire connected to this component connection, keep looking
              ((AND (= (strcase (car x)) "$WNL")
                    (= (nth 4 xx) 4)) ; connection direction is from the left
                ; Found wire connection on left side (wire connection direction "4")
                ; Push fixed wire number out to this wire connection's attached wire                
                (setq hit_wen (car (nth 3 xx))) ; save wire entity name & exit loop
              ) 
              ((AND (= (strcase (car x)) "$WNR")
                    (= (nth 4 xx) 1)) ; connection direction is from the right
                ; Found wire connection on right side (wire connection direction "1")
                ; Push fixed wire number out to this wire connection's attached wire                 
                (setq hit_wen (car (nth 3 xx))) ; save wire entity name & exit loop
              ) 
              ((AND (= (strcase (car x)) "$WNT")
                    (= (nth 4 xx) 2)) ; connection direction is from above
                ; Found wire connection on top side (wire connection direction "2")
                ; Push fixed wire number out to this wire connection's attached wire                 
                (setq hit_wen (car (nth 3 xx))) ; save wire entity name & exit loop
              ) 
              ((AND (= (strcase (car x)) "$WNB")
                    (= (nth 4 xx) 8)) ; connection direction is from below
                ; Found wire connection on bottom (wire connection direction "8")
                ; Push fixed wire number out to this wire connection's attached wire                 
                (setq hit_wen (car (nth 3 xx))) ; save wire entity name & exit loop               
          ) ) )    
          (if hit_wen
            (progn ; push the defined wire number out to wire entity "hit_wen".
                   ; Insert it as a "fixed" wire number value.
              (c:wd_putwnf hit_wen (cadr x))             
        ) ) )    
        (T
; ** 06-Nov-09 NEHolt.end

          (if (AND (not (c:wd_modattrval en (car x) (cadr x) 1)) (/= (car x) ""))
            (progn ; target attribute name not found
              ; If it is the format of CATxx, MFGxx, CNTxx, ASSYCODExx, or WDBLKNAMxx then write out as XData
              (if (wcmatch (car x) "CAT??,MFG??,CNT??,ASSYCODE??,UM??,WDBLKNAM??")
                (progn ; write as XData
                  (c:wd_upd_pnlval en (car x) (cadr x))             
        ) ) ) ) )
      )
  ) )

Step 6 – save your modified version of wdio.lsp.

Now, let’s test.

Here we’ve opened up the demo PLC spreadsheet demoplc.xls and added some references. We changed the terminal block names from HT0001 to HT1001 so that wire numbers change through them. We’ve added a couple customer symbol references. Finally, we added in our wire number flags to insert wire numbers “W1″, “W2″ on the customer limit switch and “W5″ and “W9″ for the N.C. relay contact.

Save spreadsheet. Exit out of Excel. Cross fingers and fire up the AutoCAD Electrical Spreadsheet –> PLC I/O utility. Reference the modified spreadhseet, and watch what happens…

A few things to keep in mind with this modification:

1. Remember that terminals come in two flavors… those that maintain a wire number assignment through the terminal on those that trigger a wire number change through them. You might need to use the latter.

2. If you put the “$WNL=<wire number>” or “$WNR=<wire number>” flag in an empty cell in your spreadsheet, precede it with a semi-colon (ex: empty cell contents becomes ”;$WNL=12345″). This triggers the utility to treat this as a piggy-backed attribute.

3. For wires attaching from above or below, use flags $WNT and $WNB.

4. If these flag names don’t make sense or the “$” character is not one that shows up on your keyboard, adjust to suit your needs by editing the appropriate places in the pasted in Lisp code of step #5 above.

Advertisement – if your company is in need of AutoCAD Electrical customization, please visit http://n8consultants.com

Overriding a propensity for AutoCAD Electrical’s cool “Scoot” command to default to “horizontal” mode

This was another “head-scratcher”. The task seemed so simple. Just create a horizontal and vertical version of an electrical symbol to represent a multi-ratio current transformer. Should be easy, piece of cake…

… but, when finished and testing the results, the horizontal version worked great and SCOOTed great, but the vertical version behaved unexpectedly.

Here’s are a couple instances of the new horizontal symbol inserted into a bus wire. The Scoot command works as expected.

Right click on the symbol, select SCOOT command, and slide it over to the right…

… and click. Everything stretches/trims/reconnects nicely.

But not the Vertical version ( ! )

The vertical version wants to scoot horizontally on the horizontal connected wire. What’s going on??

The problem: the SCOOT command appears to have a built-in bias to default to horizontal scooting. If there are the same number of horizontal wire connection points as there are vertical wire connection points on a symbol, and at least one wire connects to each type, the SCOOT command defaults to horizontal scoot mode.

Here’s the exploded vertical version of the custom CT symbol:

There are two vertical wire connection attributes, X2TERM04 and X8TERM03 (where the 2nd character of 2 or 8 flags vertical). There are two horizontal wire connection attributes, X4TERM02 and X4TERM01 (where the 2nd character of 1 or 4 flags horizontal connection). So, equal number of horizontal and vertical… and the SCOOT command defaults to horizontal scooting.

The Work-around

On a tie vote, horizontal wins. So we need to stuff the ballot box with an extra “vote” for vertical. Here’s the work-around. Add a dummy vertical wire connection attribute to the symbol so that the vote will end up being 3 vertical versus 2 horizontal… and scoot will go with the vertical majority.

Add the unused dummy vertical wire connection attribute at a point on the symbol where it will likely not be accidentally used. Here’s the example for the above symbol:

Not necessary, but used an odd suffix value of “99″ to make it “stand out” from the others.

Testing

Now, it scoots vertically, very nicely!

Quickly create a tool to find and zoom to a given entity using its handle number.

You know an entity/object’s “handle” number, but where in the world is it in your jumbled drawing?

Complex library creation and testing has been on my plate for a couple weeks. The new code spits out the AutoCAD handle of various entities as processing proceeds. Sometimes there’s a need to go back in and find a problem entity on the drawing. Have the handle reference but that’s it. What is it, where is it?

Manual Method – Crude with  no-frills

Here’s the crude, no-frills way. Open the entity and display its guts in the command window.

Let’s say that you’ve run your program in a “debugging” mode and find that there is some issue with object handle “74F” in the active drawing. What and where is this entity?

Type this AutoLISP expression at the “Command:” prompt

Command: (entget (handent “74F”)) [Enter]

It returns this block of data about this entity.

((-1 . <Entity name: 7ef152f8>) (0 . “LINE”) (330 . <Entity name: 7ef11c10>) (5 . “74F”) (100 . “AcDbEntity”) (67 . 0) (410 . “Model”) (8 . “0″) (100 .
“AcDbLine”) (10 6.09375 13.5 0.0) (11 6.12676 13.5 0.0) (210 0.0 0.0 1.0))

The “0″ entry flags the entity type: “LINE” and the “10″ and “11″ parts give the XYZ start and end points of the LINE segment.

Crude, but it does work.

Better Method: auto-ZOOM to the entity

Here’s a little AutoLISP utility thrown together to help in troubleshooting. It zooms in on the target object given the typed-in handle.

The syntax is pretty simple. After the utility is APPLOADed, type ZH at the AutoCAD command prompt and then enter the handle number at the next prompt…

Command: zh [Enter]
Handle  =74F [Enter]

The utility opens up the entity. If it is a simple graphical entity like an arc, text, block insert, line, then it opens it to find “where” it is.

Entity type: LINE XY=(6.11026 13.5 0.0)

… and then it issues a ZOOM “Centered” command to display the object in the middle of the screen. It then tries to highlight it. Now you can zoom in or out with “I” or “O” keystrokes or use your mouse “wheel” to take a better look in context.

Here’s the handle “74F” example… it was an incomplete wire connection on the high side of a control transformer.

Here’s the utility itself. Cut and paste into an ASCII text file, let’s call it “zh.lsp”.

; ** 13-Oct-09 NEHolt - http://n8consultants.com
(defun c:zh ( / hdl xy enttype ed en xy2)
  ; ZOOM to entity "handle". Does not check model vs layout space.
  (while (/= (setq hdl (getstring (strcat
              "\nHandle " (if en "(or I=Zoom IN, O=Zoom out)" "") " ="))) "")
    (cond
      ((= (strcase hdl) "I")(command "_.ZOOM" "1.5x"))
      ((= (strcase hdl) "O")(command "_.ZOOM" "0.75x"))
      (T
        (if (setq en (handent hdl)) ; convert handle string to its "entity name"
          (progn ; appears to be a valid handle number
            (if (setq ed (entget en)) ; open up the entity
              (progn ; success, okay to continue
                (setq xy nil)
                (setq enttype (cdr (assoc 0 ed))) ; extract the entity type
                (princ "\nEntity type: ")(princ enttype)
                (if (= enttype "INSERT")
                  (progn ; this is a block INSERT instance
                    (princ " blk nam=")
                    (princ (cdr (assoc 2 ed))) ; display block name
                ) )
                ; Figure where entity is located
                (if (cdr (assoc 10 ed))
                  (progn
                    (setq xy (cdr (assoc 10 ed))) ; 10 subrec often gives a location value
                    (if (= enttype "LINE")
                      (progn ; LINE entity. Reset to zoom to line's midpoint
                        (setq xy2 (cdr (assoc 11 ed))) ; XY of other end
                        ; Calc midpoint coordinate
                        (setq xy (list (+ (car xy) (* 0.5 (- (car xy2) (car xy))))
                                       (+ (cadr xy) (* 0.5 (- (cadr xy2) (cadr xy))))
                                       (+ (caddr xy) (* 0.5 (- (caddr xy2) (caddr xy))))))
                ) ) ) )
                (if xy
                  (progn ; Non-blank XY extracted from picked entity. Go ahead and
                           ; display the value and ZOOM in to that point on the drawing.
                    (princ " XY=")(princ xy)
                    (command "_.ZOOM" "_C" xy 1.0) ; use ZOOM CENTER command
                    (redraw en 3) ; trigger entity to "highlight"
                ) )
        ) ) ) )
      )
    )
  )
  (command "_.REGEN") ; brute force - unhighlight everything
  (princ) ; quiet return
)

That should be it. APPLOAD this file and that should expose the utility to use on your active drawing.

UPDATE: typo introduced when the above program was cut/paste into this posting. Very sorry. Should be okay now. – Nate.

Using the selection set function “ssget” to track down and remove instances of an invisible block.

This exercise will be short and [hopefully] sweet. The idea for this one came from personal experience… today.

Let’s say that you create a block instance consisting of just one attribute definition. You define its tag name to be “BY_CUSTOMER” and you leave the value blank, planning to fill in with different values later.

You go ahead and block this single attribute definition with a block name of “CUSTOMER_FLAG”…

… and you sprinkle a bunch of instances of this block across your drawing. You keep working away. A couple hours later you’re ready to go back and assign values to the BY_CUSTOMER attribute on each inserted instance of your CUSTOMER_FLAG block.

Hey… where are they? Don’t see them. You know you inserted them at multiple places in your drawing. But there’s nothing to pick on!

The block was just a single attribute and, unfortunately, you created it with a blank default value ( ! ).

Okay, let’s erase them and have a “do over”. But hey, how can I erase something I can’t select… something I can’t even see?!

Well, could try the QTEXT trick. Turn QTEXT “ON” and type REGEN. All blank attribute values now should display a tiny dot. But how can I tell which dot is which without picking one at a time and listing what it is?

Quick solution using the AutoLISP function “SSGET” with a filter

The solution uses AutoLISP and is easy… we can do it all right at the “Command:” prompt.

What we’ll do is make a “selection set” of all instances of this invisible / un-selectable block. We’ll do this by scanning ALL entities in our active drawing and filter out everything except blocks that carry the block name “CUSTOMER_FLAG”. A block instance carries the assigned block name in the “2″ entity sub-record. We’ll make a really simple filter by just looking for entities that have “CUSTOMER_FLAG” as the value of their “2″ subrecord.

Type this at the “Command:” prompt:

(setq ss (ssget “_X”  ’((2 . “CUSTOMER_FLAG”))))  [Enter]

If any matches found, the message “<Selection set xx>” will display below the “Command:” prompt. What we’ve done here is defined a dummy variable we’re calling “ss” and it will carry the selection set returned by the call to “(ssget …)”.

Let’s see how many it found. Type this:

(sslength ss) [Enter]

… and it will display the number of instances of CUSTOMER_FLAG that were found in the drawing.

Okay, now let’s blow them away so we can PURGE our drawing. Type this:

(command “_ERASE” ss “”) [Enter]

… and they’re gone! The above just launches the normal AutoCAD ERASE command. We pass the selection set variable we created above, “ss” to this command along with an extra “” at the end to kick out of the “select objects” loop. Finally, launch the PURGE command. You should now see that block CUSTOMER_FLAG is a candidate for purging. Yes! Blow it away.

Caution

The above solution will probably work as expected 99.9% of the time. But there are some entities that “share” the “2″ sub-record. For example, an ATTDEF entity uses the “2″ subrecord to carry the attribute tag name. So if we had some orphaned ATTDEFs floating around in our drawing and they happened to have a tag name of “CUSTOMER_FLAG”, then these CUSTOMER_FLAG ATTDEFs would be erased along with the CUSTOMER_FLAG block instances.

To be really, really safe, we could redo our selection set filtering like this to make sure that we’re only dealing with block instances AND the block instance is named “CUSTOMER_FLAG”. The entity type is carried in sub-record type zero. Block insert entity type is “INSERT”. So, a fool-proof, command-prompt-entered query to build the selection set might look like this:

(setq ss (ssget “_X”  ‘((-4 . “<AND”)(0 . “INSERT”)(2 . “CUSTOMER_FLAG”)(-4 . “AND>”))))  [Enter]

Experimenting with attribute definition order, entity sorting, and entmake

This lesson’s issue: Scrambled attribute order on a block insert.

(Note: previous postings: Lesson 001, Lesson 002, Lesson 003, Lesson 004, and Lesson 005)

Here is an AutoCAD Electrical transformer symbol popped into a circuit. If I decide to use the generic attribute editor command built into AutoCAD to examine and possibly adjust values for this instance of the transformer block insert, the attribute order listed is pretty scrambled.

It appears that the order that attributes are listed here are in the same order that the ATTDEF entities were inserted into the block’s source “.dwg” file. (Note: you can use AutoCAD’s BATTMAN command and painfully re-order the attribute listing for the block reference in the active drawing… but that is a one-time fix and not a permanent library “.dwg”-based solution. Read on.)

Call up the block’s original “.dwg” file, VXF1D.dwg. Type this at the command prompt:

Command: (entget (car (entsel))) [Enter]  

Select object:[Pick on the TAG1 attribute definition]

((-1 . <Entity name: 7ffffbbedf0>) (0 . "ATTDEF") (330 . <Entity name: 7ffffbbe820>) (5 . "5F")(100 . "AcDbEntity") (67 . 0) (410 . "Model")
(8 . "0") (100 . "AcDbText") (10 0.166667 0.749995 0.0) (40 . 0.125) (1 . "XF") (50 . 0.0) (41 . 1.0) (51 . 0.0) (7 . "WD") (71 . 0) (72 . 1)
(11 0.375 0.749995 0.0) (210 0.0 0.0 1.0) (100 . "AcDbAttributeDefinition") (280 . 0) (3 . "") (2 . "TAG1") (70 . 0) (73 . 0) (74 . 0) (280 . 0))

and then pick on the TAG1 attribute definition. This expression will read the attribute definition entity (the one you select) and return the entity’s data (above). This is pretty cryptic but the part shown in red is the picked entity’s “handle” number, “5F”.

If we repeat for the RATING1 and the DESC1 attributes, the handle numbers are “5E” and “60″ respectively.

These entity handle numbers (in hexidecimal format) indicate the order that these attribute definitions were created and added to the library symbol drawing. It looks like the RATING1 attribute definition (5E) was created just before the TAG1 (5F) attribute definition. Next, the DESC1 (60) was defined and added to the symbol.

ATTDEF creation order and attribute display order

Does the creation order drive the attribute’s display order when the source library symbol is inserted as a block insert into another drawing?

Let’s take another look at the attribute editor dialog display when the symbol above is inserted as a block reference into a drawing.

Note that these three attributes are listed together with RATING1 (original handle ”5E”) leading, TAG1 next (original handle “5F”) and DESC1 (original handle “60″) bring up the rear. It looks like that the creation order DOES influence the display order.

Let’s say that we really want the TAG1 attribute to be first in the list. Then we want the three DESC1, DESC2, and DESC3 attributes listed, then all of the “RATING*” attributes, catalog assignment attributes, and then all the rest in alphabetical order. So, if creation order is a controlling factor, we have a couple options…

OPTION 1: We could carefully re-construct our VXF1D.dwg base library symbol (and the many hundreds of others) so that the attribute defintions are each created in this order.

OPTION 2: Write a little AutoLISP utility that takes an existing scrambled library symbol dwg file, deletes all the attribute definitions, and then pushes them back into the symbol’s dwg file in the desired order.

Let’s go with the second option.

Using (entmake…)

Let’s try a little experiment. Let’s save an ATTDEF’s block of data into an AutoLISP variable. Then delete the ATTDEF using AutoCAD ERASE command. Then see if we can re-create a new, carbon-copy of the original ATTDEF with a call to “entmake”.

1. With our VXF1D.dwg drawing open on the screen, type this at the command prompt:

Command: (setq tag1_data (entget(car (entsel)))) [Enter, pick on TAG1 attdef]

Select object: ((-1 . <Entity name: 7ffffbbedf0>) (0 . “ATTDEF”) (330 . <Entity
name: 7ffffbbe820>) (5 . “5F”) (100 . “AcDbEntity”) (67 . 0) (410 . “Model”) (8
. “0″) (100 . “AcDbText”) (10 0.166667 0.749995 0.0) (40 . 0.125) (1 . “XF”)
(50 . 0.0) (41 . 1.0) (51 . 0.0) (7 . “WD”) (71 . 0) (72 . 1) (11 0.375
0.749995 0.0) (210 0.0 0.0 1.0) (100 . “AcDbAttributeDefinition”) (280 . 0) (3
. “”) (2 . “TAG1″) (70 . 0) (73 . 0) (74 . 0) (280 . 0))

Command: (setq desc1_data (entget (car (entsel)))) [Enter, pick on DESC1 attdef]

Select object: ((-1 . <Entity name: 7ffffbbee00>) (0 . “ATTDEF”) (330 . <Entity
name: 7ffffbbe820>) (5 . “60″) (100 . “AcDbEntity”) (67 . 0) (410 . “Model”) (8
. “0″) (100 . “AcDbText”) (10 0.234887 -0.89792 0.0) (40 . 0.125) (1 . “”) (50
. 0.0) (41 . 0.7) (51 . 0.0) (7 . “WD”) (71 . 0) (72 . 1) (11 0.424471 -0.89792
0.0) (210 0.0 0.0 1.0) (100 . “AcDbAttributeDefinition”) (280 . 0) (3 . “”) (2
. “DESC1″) (70 . 0) (73 . 0) (74 . 0) (280 . 0))

Command: (setq rating1_data (entget (car (entsel)))) [Enter, pick on RATING1 attdef]

Select object: ((-1 . <Entity name: 7ffffbbede0>) (0 . “ATTDEF”) (330 . <Entity
name: 7ffffbbe820>) (5 . “5E”) (100 . “AcDbEntity”) (67 . 0) (410 . “Model”) (8
. “0″) (100 . “AcDbText”) (10 0.136875 0.59375 0.0) (40 . 0.125) (1 . “”) (50 .
0.0) (41 . 0.7) (51 . 0.0) (7 . “WD”) (71 . 0) (72 . 1) (11 0.399375 0.59375
0.0) (210 0.0 0.0 1.0) (100 . “AcDbAttributeDefinition”) (280 . 0) (3 . “”) (2
. “RATING1″) (70 . 0) (73 . 0) (74 . 0) (280 . 0))

2. Now erase these three ATTDEFS ( ! )

3. Now, let’s recreate them, but in a specific order. Type these three commands at the command line:

(entmake tag1_data) [Enter]

(entmake desc1_data) [Enter]

(entmake rating1_data) [Enter]

4. The deleted ATTDEFs are re-created, but they are now in a different order. Confirm that the handles of the three new ATTDEFs now increment in the new order of TAG1, DESC1, and then RATING1.

A Re-order ATTDEF AutoLISP utility

With our little utility, we need to more or less duplicate what we just did above:  1. Capture all the ATTDEFs, 2. Erase them, 3. Re-create them with (entmake…) in the desired order.

Here’s what our little AutoLISP utility’s program flow might look like in order to do this:

1. We first define the order for specific attribute definition tagnames. We decide that we’ll support wild-cards in the tag names. This makes it easy to define all of the various AutoCAD Electrical component “tag-ID” attribute tagnames in the first entry of the priority list.

  ; Set up order list of ATTDEFS. Wild-cards are supported.     
  (setq orderlst (list "TAG1*,TAG2,TAGSTRIP,P_TAG1,P_TAGSTRIP"
                       "DESC1"
                       "DESC2"
                       "DESC3"
                       "RATING*"
                       "MFG"
                       "CAT"
                       "ASSYCODE"
                       "INST"
                       "LOC"
                       "FAMILY"
                       "TERM*"))

2. Now, with the source block “.dwg” open in AutoCAD, our utility constructs a selection set of all ATTDEF entities found in the drawing. The call is to “ssget” and we pass the “_X” parameter which processes ALL entities in the active drawing. Our expression has a ‘((0 . “ATTDEF”)) filter included so that only ATTDEFs will end up in our selection set.

  ; Gather up selection set of all ATTDEFs on the active drawing
  (setq ss (ssget "_X" '((0 . "ATTDEF"))))

3. Our utility then opens each of these ATTDEF entities in a “while” loop, indexing through the ATTDEFs in the selction set “ss”, one at a time. It pushes each ATTDEF block of data into an overall big list of data that we’re calling “attdef_lst”.

   (if (AND (/= ss nil)(> (sslength ss) 1))
    (progn ; at least one ATTDEF found. Okay to continue.
      ; Extract all ATTDEF tag names and overall ATTDEF entity data. Save in parallel lists.     
      (setq attdef_lst nil) ; start with blank data list
      (setq slen (sslength ss)) ; number of ATTDEFs in selection set
      (setq ix 0) ; used to index through the selection list
      (while (< ix slen)        
        (setq en (ssname ss ix)) ; get next ATTDEF entity name from selection set
        (setq ed (entget en)) ; open up this ATTDEF entity
        (setq attdef_lst (cons ed attdef_lst)) ; add its data to the big list
        (princ " ")(princ (cdr (assoc 2 ed))) ; display existing order in command window
        (setq ix (1+ ix)) ; increment index to get next ATTDEF entity from selection set
      )

4. Next we sort this long list of chunks of ATTDEF data alphabetically - by the tagname part of each chunk of ATTDEF data. Setting up this sort function is a bit cryptic. See the normal AutoCAD help for a few more examples. For our time here, just go with it as shown. Basically it doing a sort on the “2″ part of each ATTDEF block of data. This is the part that carries the ATTDEF “tag name”. To get at it in each list, our function uses the “(assoc 2…)” to dig it out and then a “(cdr …” to strip off the leading “2″ identifier. This leaves just the tag name to be used in the sort compare.

      ; Initially sort the list alphabetically by tagname. The tagname is in the "2"
      ; part of the entity's data. Access the value by extracting with the
      ; (assoc 2 ...) function.
      (setq attdef_lst (vl-sort attdef_lst
            '(lambda (X Y) (< (cdr (assoc 2 X)) (cdr (assoc 2 Y))))))

5. Now we’re ready to create a new version of this data list with certain ATTDEF tagnamed chunks pushed to the front part of the list. The utility cycles through the tagname priority list that we’ve set up in “orderlst” (step #1 above). For each tagname or wild-carded tagname, the utility cycles through the alphabetized list, looking for a match on the (cdr (assoc 2 …)) tagname extracted from each ATTDEF block of data. On a match, that block of data is pushed into the new list.

      ; Okay. So far, so good. We now have all ATTDEFs alphabetically sorted and held
      ; in a big data list called "attdef_lst".
           
      ; Now prepare to create a brand new ATTDEF list by pulling entries from the
      ; "attdef_lst" and pushing them into this new list in the desired order.
      (setq new_attdef_lst nil) ; Start with empty new list
      (setq processed_ix_lst nil) ; To be used for tracking what items have been
                                  ; pulled from alphabetized list into the new list.
     
      ; Process the ATTDEF tagnames against the desired order given in the "orderlst"
      (foreach sortorder_name orderlst
        (setq ix 0)
        (foreach rec attdef_lst
          (setq attdef_tag (cdr (assoc 2 rec))) ; extract ATTDEF tagname for this entry
          (if (AND (not (member ix processed_ix_lst)) ; check if already processed
                   (wcmatch attdef_tag sortorder_name)) ; check if tagname wild-card
                                      ; matches with the target sortordername string.
            (progn ; This ATTDEF name matches what we're looking for. Pull its data out
                   ; of the attdef_lst and push the entity's block of data into the
                   ; new "new_attdef_lst" ordered list.
              (setq new_attdef_lst (cons rec new_attdef_lst))
              ; Remember this entry's index number so won't try to add it in again
              (setq processed_ix_lst (cons ix processed_ix_lst))
          ) )
          (setq ix (1+ ix))
        )
      )   

6. When no more of the priority list to process, we need to push any un-referenced attribute definition chunks of data on to the new list (they are still alphabetized).

      ; The new_attdef_lst should contain the ordered attributes that were specifically
      ; defined. Now add in any left-overs. These will go in alphabetically.
      (setq ix 0)
      (foreach rec attdef_lst
        (if (not (member ix processed_ix_lst))
          ; This entry not processed above. Go ahead and push it into the new list.
          (setq new_attdef_lst (cons rec new_attdef_lst))
        )
        (setq ix (1+ ix))
      )

7.  That’s it. Our new ATTDEF blocks of data list is complete. But it’s in reverse order because we used the more efficient “cons…” function to build the new version of the list (instead of using the slower “append…” function). Reverse the list.

      ; Now put the new_attdef_lst into the correct order (it is reversed due to
      ; using "(cons ...) to add elements to the beginning of the list instead of
      ; the end of the list)
      (setq new_attdef_lst (reverse new_attdef_lst))

8. Now we cross our fingers. The utility erases ALL of the existing ATTDEF entities in the drawing…

      ; Erase all existing ATTDEFS (!)
      (command "_.ERASE" ss "")

9. … and we then cycle through our new, re-ordered list of ATTDEF data and re-create each ATTDEF using calls to (entmake …) .

      ; Now rewrite the ATTDEFs but using the new ordered list of ATTDEF blocks of
      ; data. Each ATTDEF should pop back in exactly as before, but the handle assignment
      ; given to each re-written ATTDEF will now be the next sequential for the
      ; drawing (!)
      (foreach rec new_attdef_lst
        (princ "\n")(princ (cdr (assoc 2 rec))) ; display attdef name to command window
        (entmake rec)
      )

Full Utility

Here’s the full utility. Cut and paste it into a file called reorder_attdef.lsp.

; ----------  R E O R D E R _ A T T D E F . L S P  ---------------------
(defun c:reorder_attdef ( / attdef_lst ix slen ss en ed attdef_tag new_attdef_lst
                            processed_ix_lst rec orderlst sortorder_name x y)
                           
  ; Set up order list of ATTDEFS. Wild-cards are supported.     
  (setq orderlst (list "TAG1*,TAG2,TAGSTRIP,P_TAG1,P_TAGSTRIP"
                       "DESC1"
                       "DESC2"
                       "DESC3"
                       "RATING*"
                       "MFG"
                       "CAT"
                       "ASSYCODE"
                       "INST"
                       "LOC"
                       "FAMILY"
                       "TERM*"))
  ; Gather up selection set of all ATTDEFs on the active drawing
  (setq ss (ssget "_X" '((0 . "ATTDEF"))))
 
  (if (AND (/= ss nil)(> (sslength ss) 1))
    (progn ; at least one ATTDEF found. Okay to continue.
      ; Extract all ATTDEF tag names and overall ATTDEF entity data. Save in parallel lists.     
      (setq attdef_lst nil) ; start with blank data list
      (setq slen (sslength ss)) ; number of ATTDEFs in selection set
      (setq ix 0) ; used to index through the selection list
      (while (< ix slen)        
        (setq en (ssname ss ix)) ; get next ATTDEF entity name from selection set
        (setq ed (entget en)) ; open up this ATTDEF entity
        (setq attdef_lst (cons ed attdef_lst)) ; add its data to the big list
        (princ " ")(princ (cdr (assoc 2 ed))) ; display existing order in command window
        (setq ix (1+ ix)) ; increment index to get next ATTDEF entity from selection set
      )
     
      ; Initially sort the list alphabetically by tagname. The tagname is in the "2"
      ; part of the entity's data. Access the value by extracting with the
      ; (assoc 2 ...) function.
      (setq attdef_lst (vl-sort attdef_lst
            '(lambda (X Y) (< (cdr (assoc 2 X)) (cdr (assoc 2 Y))))))
      ; Okay. So far, so good. We now have all ATTDEFs alphabetically sorted and held
      ; in a big data list called "attdef_lst".
           
      ; Now prepare to create a brand new ATTDEF list by pulling entries from the
      ; "attdef_lst" and pushing them into this new list in the desired order.
      (setq new_attdef_lst nil) ; Start with empty new list
      (setq processed_ix_lst nil) ; To be used for tracking what items have been
                                  ; pulled from alphabetized list into the new list.
     
      ; Process the ATTDEF tagnames against the desired order given in the "orderlst"
      (foreach sortorder_name orderlst
        (setq ix 0)
        (foreach rec attdef_lst
          (setq attdef_tag (cdr (assoc 2 rec))) ; extract ATTDEF tagname for this entry
          (if (AND (not (member ix processed_ix_lst)) ; check if already processed
                   (wcmatch attdef_tag sortorder_name)) ; check if tagname wild-card
                                      ; matches with the target sortordername string.
            (progn ; This ATTDEF name matches what we're looking for. Pull its data out
                   ; of the attdef_lst and push the entity's block of data into the
                   ; new "new_attdef_lst" ordered list.
              (setq new_attdef_lst (cons rec new_attdef_lst))
              ; Remember this entry's index number so won't try to add it in again
              (setq processed_ix_lst (cons ix processed_ix_lst))
          ) )
          (setq ix (1+ ix))
        )
      )   
     
      ; The new_attdef_lst should contain the ordered attributes that were specifically
      ; defined. Now add in any left-overs. These will go in alphabetically.
      (setq ix 0)
      (foreach rec attdef_lst
        (if (not (member ix processed_ix_lst))
          ; This entry not processed above. Go ahead and push it into the new list.
          (setq new_attdef_lst (cons rec new_attdef_lst))
        )
        (setq ix (1+ ix))
      )
      ; Now put the new_attdef_lst into the correct order (it is reversed due to
      ; using "(cons ...) to add elements to the beginning of the list instead of
      ; the end of the list)
      (setq new_attdef_lst (reverse new_attdef_lst))
     
      ; Erase all existing ATTDEFS (!)
      (command "_.ERASE" ss "")
     
      ; Now rewrite the ATTDEFs but using the new ordered list of ATTDEF blocks of
      ; data. Each ATTDEF should pop back in exactly as before, but the handle assignment
      ; given to each re-written ATTDEF will now be the next sequential for the
      ; drawing (!)
      (foreach rec new_attdef_lst
        (princ "\n")(princ (cdr (assoc 2 rec))) ; display attdef name to command window
        (entmake rec)
      )
  ) )
  (setq ss nil) ; release the selection set
  (princ)
)        
       

Let’s try it.

With drawing VXF1D.dwg open on screen, APPLOAD the above utility file reorder_attdef.lsp.

Then type REORDER_ATTDEF [Enter] at the command prompt. In the blink of an eye, the utility should delete all ATTDEFs, sort, and re-write them. Save the symbol “.dwg”.

Now, in a fresh or purged drawing, insert this revised symbol. Cross fingers. Launch the attribute edit command, pick on the newly inserted transformer symbol…

Good work! Now batch this tool against a bunch of symbols (make a backup first, just in case!). In short order your library should be modified.

Advertisement

Could some custom applications make your company more productive? Find out. http://n8consultants.com

U P D A T E :  I just noticed that the original program with “RATING*” would put RATING10, 11, and 12 right after RATING1 and before RATING2. Looks like my original attribute definition order list example should explicitly list all 12 “RATING*” tag names like this to avoid this problem:

(setq orderlst (list "TAG1*,TAG2,TAGSTRIP,P_TAG1,P_TAGSTRIP"
                       "DESC1"
                       "DESC2"
                       "DESC3"
                       "RATING1"
                       "RATING2"
                       "RATING3"
                       "RATING4"
                       "RATING5"
                       "RATING6"
                       "RATING7"
                       "RATING8"
                       "RATING9"
                       "RATING10"
                       "RATING11"
                       "RATING12"
                       "MFG"
                       "CAT"
                       "ASSYCODE"
                       "INST"
                       "LOC"
                       "FAMILY"
                       "TERM*"))

Tool to create and manage sub-projects within an overall “super” project set of AutoCAD Electrical drawings

Performance takes a hit when an AutoCAD Electrical project gets very large. Also, on large projects, a user sometimes needs the ability to divide the overall drawing set into separate document numbers.  They require that each different type of document (i.e. schematic, panel layout, wire list, parts list) have a separate document number and title block information.  They want all drawings to be intelligently linked for design and editing but separated for title block update and page numbering.

There is a nifty way to manually split a project into more manageable or logically grouped sub-projects while still allowing ability to do overall project cross-referencing and reporting functions. This is described in detail in a posting made last month, link here.

This idea has resonated with some users including Nick Hall who has indicated that he has put together a VB program that can combine multiple subprojects into one “super” project (see note 2 at the end of the above link).

Super Project Manager tool

Here is another approach, an automated way to split out sub-projects. This is a manager tool that will take one big project and break it down into multiple, related sub-projects where each sub-project is a stand-alone AutoCAD Electrical project. This tool gives a listing of all drawings in the overall “super” project and lets you pick groups of drawings to move into sub-projects. Each new sub-project inherits the settings of the main super project. NOTE: the overall “super” project never changes - drawings in this overall project stay… the sub-projects just reference subsets of the drawings permanently held in the overall super project.

It seems to work pretty well.

Example

We’ll use the small, simple example give in the previous posting. Our overall project, PROJ-07, has just 29 drawings. But we want to create three sub-projects that each contain a sub-set of these 29 drawing references. This will give us the ability to either work on a small subset of the main project drawing set (a sub-project is marked as the “active” project) or instantly flip over to take the whole project drawing set into account (main project is flipped to be the “active” project).

We appload the new tool and then launch it by typing SPM at the “Command:” prompt. It checks for the current active project and pops this active project’s drawing list into the dialog shown below. If it detected any existing sub-projects tied to this main project, these would be listed in the lower display list.

All subprojects are identified by this tool by their file name…. “<main_projectname>[subproj_name].wdp“. None are found for this sample project – there is project file PROJ-07.wdp but there are no PROJ-07[xxx].wdp projects found in the same folder.

Our first sub-project

We want to reference six of these drawings in a small sub-project called “CELL01″. Highlight the drawings that you want to reference in this new sub-project. Hit the “Create a new sub-project” button. Enter ”CELL01″ as shown in the sub-dialog that pops up.

Hit OK to dismiss this “suffix code” sub-dialog.

The new sub-project reference goes into the first position of the sub-project listing. A “1″ marks each drawing that is referenced in this first sub-project.

Adding a 2nd sub-project

Repeat the process. Let’s say we want drawings 001 through 006 to be referenced in a second sub-project. Repeat the above but type “CELL02″ as a name for this new sub-project.

A third sub-project

And we repeat the above for the third sub-project, picking drawings 001, 002 and 010-014, and 019.

Here’s what our main dialog display now looks like (below). Note that each of the three sub-projects that we’ve defined show up in the bottom list box along with an “index” number. The upper dialog records which drawings have been referenced in each of the three sub-projects. Up to 9 sub-projects in one main project are supported by this tool.

Tools are there to add and remove drawing references from selected sub-project(s).

When all looks good, hit the “Save changes” button. The three new sub-projects are created. The main AutoCAD Electrical Project Manager window now displays the original, main “super” project and now three more sub-projects. Each sub-project is the same name as the main project but with a unique suffix shown in square brackets.

This Super Project Manager tool keys off of the square bracketed suffixes at the end of the project files names to automatically group all sub-projects together with a main “super” project. Seems to work well.

Touch base with Doug McAlexander ECADConsultant@aol.com if any interest in this cool tool.

U P D A T E:  short video demo of this tool is here.

AutoCAD’s ”Group” concept for entity selection can be leveraged by Circuit Builder.

This was a cool idea. John Zwerlein, a long-time AutoCAD Electrical guru guy, asked me if Circuit Builder could somehow interact with existing entities on a drawing that carry specific AutoCAD “Group” name assignments. For example, when running Circuit Builder in its “Configure” circuit mode, could certain existing things be removed from the drawing is a given circuit option was selected? Hmm…

Tried it. Worked. Pretty cool.

Here’s a simple example.

Let’s say your drawing has a list of engineering notes in a column along the side of the drawing. Two of them are appropriate if the user selects a “full voltage” option, a different one is appropriate for the “with transformer” option, and none of the three are appropriate if the user selects a “None” option.

What we do is make sure each note carries a unique AutoCAD “GROUP” name. Let’s use names “NOTE1″, “NOTE2″, and “NOTE3″. You assign a group name to one or more entities by launching the AutoCAD “GROUP” command (type GROUP or _GROUP at the “Command:” prompt). Dialog pops up and you make it happen.

Now, your drawing engineering notes are set up with unique “group” names. Next step is to adjust the Circuit Builder spreadsheet “ace_circuit_builder.xls”. Open in Excel. If you have trouble finding this file, type this at the AutoCAD command prompt:  (c:ace_find_file “ace_circuit_builder.xls” 3) [Enter]. Go to the appropriate sheet. Here’s the “horizontal insertion” sheet showing the control transformer entries:

What we want to do is carefully add in the stuff shown in red and yellow. For the red part, be very cautions. You need to enter the number zero but it needs to be interpreted by Excel as text, not as numeric. This means you should type in with a preceeding single quote, ‘0, instead of just the number zero. The value will appear left justfied in the cell. If it does not, fix it! This is important.

Here’s a close up.

In operation… when the “None” option is selected, the string “(Command “_ERASE” “_GROUP” “NOTE*” “”)” is sent by Circuit Builder to AutoCAD’s command processor. All entities with wild-card group name “NOTE*” are selected and erased. If the “Control transformer” option is selected, then entities with group names “NOTE1″ and “NOTE2″ are erased. For full voltage option, only “Note3″ is erased.

Pretty cool.