Manual routing in Cadance

Hi,

I am doing a cutsom layout.
I am using leHiCreatePath() command to route in metals. Whenever I
want to go to next metal with a contact, I use F3 and change in the
form. This will place a contact and LSW will switch to new layer.

Is there a skill routine which will allow you to assign bind keys to
switch between layers, so that tedious process of F3 and form can be
avoided.

Basically I am looking for a manual router.

Regards,
Lakshman

 

I'm looking for that, too. I'd prefer to assign mouse wheel events (roll
up/down) to it.

 

try a <Ctrl> <right mouse click> when drawing the path,
also the create wire command in virtuoso XL can be helpful

 

Hi,

I am working in a Analog group as well and have been struggling with
the same, I wished to create some productivity improvements to manual
routing. I have had some success, although I wish my solution was
more elegant but I thought I would share anyways. I hope it is of
some help and of course if you have a better way I would very much
like to know.

So, here goes. The technology file I am working on has three metal
layers. M1, M2 and M3. First I made the "rec" or recover files,
but in hindsight it would make more sense to call them .replay files
(Intel tools call them recover files, cadence replay. I am new to
Cadence tools). Anyways here they are....

m1trans.rec file contains:
\a le0PathForm->changePathLayer->value = '(79693202 102 26 "metal1
(drawing)")

m2trans.rec file:
\a le0PathForm->changePathLayer->value = '(79693204 102 26 "metal2
(drawing)")

m3trans.rec file:
\a le0PathForm->changePathLayer->value = '(79693206 102 26 "metal3
(drawing)")


Next step I made skill code that when I hit key "2" I would transition
from m1 to m2(via1), etc...

procedure(m3trans()
hiReplayFile("/home/fitzsied/c05hma_atran/m3trans.rec")
)
procedure(m2trans()
hiReplayFile("/home/fitzsied/c05hma_atran/m2trans.rec")
)
procedure(m1trans()
hiReplayFile("/home/fitzsied/c05hma_atran/m1trans.rec")
)




hiSetBindKeys( "Layout" list(
list("1" "m1trans()");
list("2" "m2trans()");
list("3" "m3trans()");
))

I called this file transitions.il, so after this is created.....load("/
yourpath/transitions.il") in te CIW.

================================================================

One other thing I did, but isn't really necessary is I made some
"bias" code. Instead of starting create path command, I set up code
in which if I press ctrl 1 the path command starts biased to metal 1.

m1bias.rec
::::::::::::::
\a leiMouseSetEntryLayer(7)
\a leHiCreatePath()
;\a le0PathForm->pathWidth->value = 6.0 This will auto fill in
your width(6u) in the Create Path form if you wish
;\a le0PathForm->fixedWidthPaths->value = t This will make it
"sticky" across all the metals for the width
::::::::::::::
m2bias.rec
::::::::::::::
\a leiMouseSetEntryLayer(9)
\a leHiCreatePath()
;\a le0PathForm->pathWidth->value = 6.0
;\a le0PathForm->fixedWidthPaths->value = t
::::::::::::::
m3bias.rec
::::::::::::::
\a leiMouseSetEntryLayer(11)
\a leHiCreatePath()
;\a le0PathForm->pathWidth->value = 6.0
;\a le0PathForm->fixedWidthPaths->value = t

procedure(m3bias()
hiReplayFile("/pathwherem3biaslives/m3bias.rec")
)
procedure(m2bias()
hiReplayFile("/path/m2bias.rec")
)
procedure(m1bias()
hiReplayFile("/path/m1bias.rec")
)



hiSetBindKeys( "Layout" list(
list("Ctrl<Key>1" "m1bias()");
list("Ctrl<Key>2" "m2bias()");
list("Ctrl<Key>3" "m3bias()");
))
------------------
load("/path/transition.il")

So, to "bias" hit Ctrl 1(2 or 3) to "transition" hit 2 to transition
to metal2 from m3. M2 to M1 press 1.

Hope that helps and please let me know if there is an easier way. I
also would like to get rid of the "replay" files, so if somebody knows
a better way to manipulate gui forms please share!

Happy Holidays!
Eric Fitzsimmons
IC Layout Designer

 

The following code was supplied by Cadence Customer Support and worked
quite well for me.


/* CCSchangePathLayer.il

Group Custom IC, Cadence Design Systems
Language SKILL
Revision No. 1.1
Date Created Apr 04, 2006
Last Modified
Tested in IC5141
Lint score 100 (best is 100)
Description:

The following code defines three functions that are designed to be
called during the "Create Path" command in the layout editor. The
entry functions are CCSlayerUp() and CCSlayerDown() which in turn
call the CCSchangePathLayer() function.

The default bindkey for the Ctrl-RMB (Control and the Right Mouse
Button combination) key sequence is the function cmdCtrlOption(),
which is intended to change the entry layer during the "create path"
command - it does so but typically only in one direction, down.

The CCSlayerUp() and CCSlayerDown() functions are assigned to the
Ctrl-MMB (Middle Mouse Button) and Ctrl-RMB respectively and are
intended to replace the above default functionality.

The function that actually does the work is CCSchangePathLayer(),
this accepts three arguments to control the direction ("up" or
"down"), the limit in each direction (e.g. "poly" or "metal5"),
and the verbosity of the command ('t' is silent, the default is
'nil' which gives information messages).

Usage:

;; the CCSlayerUp() and CCSlayerDown() commands are intended
;; to be assigned to bindkeys and should supply the arguments
;; "topLayer"/"bottomLayer" and "silent" to be passed to the
;; CCSchangePathLayer() command
;; The example below assumes a 3-layer metal process with
;; the "poly1" layer being the bottom-most interconnect and
;; the "M3" layer being the top-most metal layer.
hiSetBindKeys("Layout"
list(
list("Ctrl<Btn2Down>" nil "CCSlayerUp(\"M3\")")
list("Ctrl<Btn3Down>" nil "CCSlayerDown(\"poly1\")")
)
)


NOTE: Depending upon how the layers have been set up in the
techfile, the code may not behave as described; special conditions
may need to be catered for if they are particular to your process.

***************************************************

SCCS Info: @(#) CCSchangePathLayer.il 04/05/06.17:19:06 1.1

********************************************************************
* DISCLAIMER: The following code is provided for Cadence customers *
* to use at their own risk. The code may require modification to *
* satisfy the requirements of any user. The code and any *
* modifications to the code may not be compatible with current or *
* future versions of Cadence products. *
* THE CODE IS PROVIDED "AS IS" AND WITH NO WARRANTIES, INCLUDING *
* WITHOUT LIMITATION ANY EXPRESS WARRANTIES OR IMPLIED WARRANTIES *
* OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE. *
********************************************************************

*/

/***************************************************************
* *
* CCSlayerUp([t_topLayer | nil] [g_silent]) *
* This procedure calls the CCSchangePathLayer function if the *
* current command is the Path command. The "topLayer" and *
* "silent" arguments are passed through without being checked *
* *
***************************************************************/
procedure(CCSlayerUp(@optional topLayer silent)
let( ((wid hiGetCurrentWindow()))
when(wid && hiGetCurrentCmd(wid)=="Path"
CCSchangePathLayer("up" topLayer silent)
); when
); let
); procedure CCSlayerUp

/***************************************************************
* *
* CCSlayerDown([t_bottomLayer | nil] [g_silent]) *
* This procedure calls the CCSchangePathLayer function if the *
* current command is the Path command. The "bottomLayer" and *
* "silent" arguments are passed through without being checked *
* *
***************************************************************/
procedure(CCSlayerDown(@optional bottomLayer silent)
let( ((wid hiGetCurrentWindow()))
when(wid && hiGetCurrentCmd(wid)=="Path"
CCSchangePathLayer("down" bottomLayer silent)
); when
); let
); procedure CCSlayerDown


/***************************************************************
* *
* CCSchangePathLayer( *
* [t_direction] *
* [t_limit | nil] *
* [g_silent] *
* ) *
* This procedure is designed to be called during the Create *
* Path enterfunction. The direction argument controls whether *
* the layer is changed up or down, "up" or "down" are valid *
* values. The limit argument specifies the top layer name as *
* a limit in the up direction or the bottom layer name as the *
* limit in the down direction, this information is needed to *
* cope with the top or bottom layer conditions when the Change *
* To Layer field typically contains only 2 entries. The silent *
* argument controls whether information messages are output to *
* the CIW while changing the path layer, 't' turns them off. *
* *
***************************************************************/
procedure(CCSchangePathLayer(@optional (direction "down")
limit silent "tgg")
let( (form pathLayers)
when(and( form = hiGetCurrentForm()
form->changePathLayer)
pathLayers = form->changePathLayer->choices
cond(
;; if the change layer direction is 'down' and as long as
;; there are at least three choices, choose the second
;; layer which should be one layer down from current
(and(direction=="down" length(pathLayers)>=3)
form->changePathLayer->value = cadr(pathLayers)
;; unless the silent flag is 't' print a message
unless(silent
printf("changed layer %s to %s\n"
direction cadddr(cadr(pathLayers)))
); unless
)
;; if the change layer direction is 'up' and as long as
;; there are at least three choices, then select the third
;; choice which should be one layer up from current
(and(direction=="up" length(pathLayers)>=3)
form->changePathLayer->value = caddr(pathLayers)
;; unless the silent flag is 't' print a message
unless(silent
printf("changed layer %s to %s\n"
direction cadddr(caddr(pathLayers)))
); unless
)
;; if there are two choices and we are changing up choose
;; the second layer which should be one layer up from current
(and(direction=="up" length(pathLayers)==2)
if(!equal(limit
car(parseString(cadddr(form->changePathLayer->value)))) then
form->changePathLayer->value = cadr(pathLayers)
;; unless the silent flag is 't' print a message
unless(silent
printf("changed layer %s to %s\n"
direction cadddr(cadr(pathLayers)))
); unless
else
;; unless the silent flag is 't' print a message
unless(silent
printf("could not change layer %s from %s\n"
direction cadddr(form->changePathLayer->value))
); unless
); if
)
;; if there are two choices and we are changing down choose
;; the second layer which should be one layer down from current
(and(direction=="down" length(pathLayers)==2)
if(!equal(limit
car(parseString(cadddr(form->changePathLayer->value)))) then
form->changePathLayer->value = cadr(pathLayers)
;; unless the silent flag is 't' print a message
unless(silent
printf("changed layer %s to %s\n"
direction cadddr(cadr(pathLayers)))
); unless
else
;; unless the silent flag is 't' print a message
unless(silent
printf("could not change layer %s from %s\n"
direction cadddr(form->changePathLayer->value))
); unless
); if
)
;; for any other condition don't do anything
(t
;; unless the silent flag is 't' print a message
unless(silent
printf("could not change layer %s from %s\n" direction
cadddr(form->changePathLayer->value))
); unless
nil
)
); cond
); when
); let
); procedure CCSchangePathLayer


;; create bindkeys for the middle and right mouse buttons in
;; combination with the Control key, Ctrl-Middle changes up a
;; layer, Ctrl-Right changes down a layer. For silent operation
;; add a 't' after the top/bottom layer name in the function call
;; to CCSlayerUp() or CCSlayerDown()
hiSetBindKeys("Layout"
list(
list("Ctrl<Btn2Down>" nil "CCSlayerUp(\"M11\")")
;; Button 3 is currently down, keeping for compatibility
list("Ctrl<Btn3Down>" nil "CCSlayerDown(\"PC\")")
)
)

 

Hi Colin,

You had explained about ChangePathLayer while creating "createPath". I
have a doubt regarding an option called change To Layer in
"createPath" funtion. If you use CreatePath and change layer in LSW,
Change To Layer field will be getting updated to the layer you have
selected. How LSW is synchronised with Change To Field.

Thanks in advance

 

This is using the standard create path command. It changes the routing layer on
the options form for that command, and in turn that sets the entry layer in the LSW.

It is not done the other way around - although there are some triggers in this
internal code which do update the information about the routing based on the
entry layer.

Regards,

Andrew.