ODB to Gerber Web page header

ODB2GBR64 Command Line

Users can run the ODB2GBR64 software from a command line instead of the GUI by including the expected arguments when invoking the program. When the program detects the additional arguments, it runs from the command line instead of launching the user interface.


Here is a command line you can use to convert the sample ODB++ file we include in our examples directory. There are no returns in the command line but I've added them so I can annotate the arguments and fit nicely on the page:)

c:\wcad\odb2gbr64\odb2gbr64.exe               the path to the executable         
"-job:C:/wcad/odb2gbr/examples/sample.tgz"    the name and path to the input ODB++ file (.tgz)
"-workdir:C:/wcad/odb2gbr/examples"           the name of the directory to hold working files
"-outdir:C:/wcad/odb2gbr/examples"            the name of the output directory for the Gerber files.

-step:pcbdata                                 the name of the ODB++ step to process

-step_repeat                                  if ODB++ is stepped, use the RS274X SR command to
                                              minimize the file size.

-odb_symbols                                  Use RS274X macros for user defined symbols

-thrnum:1                                     number of concurrent threads. Many of the processes
                                              are single threaded - multiple threads will increase
                                              performance when there is a lot of Boolean operations
                                              to perform.

-non_std                                      Evaluate ODB++ attributes

-unit:mm                                      any command line dimension data is in these units. Note
                                              that ODB++ files may be in inches or mm and this does
                                              not have any effect on the output data.


Complete Set - Command Line Arguments

odb2gbr64.exe -job:[odb_path] -outdir:[dir] -workdir:[dir] -step:[step[,l1,l2,..]] [OPTARGS]







-h                                  Get the usage information.

-dbg[:[log_fname]]                  Enable debugging.

-log[:[log_fullpath]]               Enable logging (default).

-nolog                              Disable logging.

-silent                             Run in silent mode (no GUI or pop-ups)

-keep_tmpfiles                      Keep temporary files; otherwise erased at end of run.

-non_std                            Evaluate system defined attributes.

-nosropt                            Disable Step-Repeat optimization.

-copyin                             Make a copy of the input into the working folder - the original source folder tree is preserved and not modified
                                    Applicable when the ODB++ database is a folder.
-nocopyin                           Don't make a copy of the input folder. Use the input folder as a scratch pad. It assumes the folder tree and the files in it are writable. Applicable when the ODB++ database is a folder.

-netex                              Read ODB++ nets

-userattr                           Read ODB++ user attributes

-thrnum:[+thrnum_int_val]           Set the max thread. Multi threads are used to convert 
                                    multiple symbols or multiple layers into intermediate 
                                    files, and in split274x post processing engine which 
                                    writes the Gerber data.

-stepinfo:[step[,lyr1...]]          Info a specific step(/layers)

-dont_traverse                      Don't traverse step, used with -stepinfo

-steplist                           Get the list of steps

-layerlist                          Get the list of layers

-outinfo:[full_path]                Set output fname used with -steplist|-layerlist|-stepinfo

-netlayers[:[full_path]]            Get the list of steps and net specific layers

-gbr[:[gbr basename]]               GBR output (default) (separate file per ODB layer)

-gds[:[gds basename]]               GDS output (separate GDSII per layer)

+gds[:[gds filename]]               GDS output (combine layers into one GDSII)

-oas[:[oas basename]]               OAS output (separate OAS per layer)

-mic[:[mic filename]]               Mycronic MIC output

-lyrastackup                        Set GDSII layer as the stackup, used with +gds

-usegbrflow                         Convert to GBR then MIC, used with -mic

-exclude:[stepnames]                Set steps to be excluded

-excludel:[layernames]              Set layers to be excluded

-window:[minx,miny,maxx,maxy]       Set window clip (GDSII, OASIS, outputs only)

-gds_layer:[layer_int_val]          Set GDSII layer output

-gds_struct:[struct_name]           :Set GDSII top structure output

-oas_modal                          :Set OASIS modal option on

-oas_sort                           :Set OASIS sort option on

-oas_grid:[grid_dbl_val]            :Set OASIS new grid

-oas_tile:[x,y]                     :Set OASIS tile (double val)

-oas_top2bot                        :Set OASIS top2bottom option ON

-oas_scale:[scale_dbl_val]          :Set OASIS scale

-oas_angle:[0 | 90 | 180 | 270]     :Set OASIS angle

-oas_mirror:[none | x | y]          :Set OASIS mirror

-oas_trans:[none | auto]            :Set OASIS translate none or auto

-oas_trans:[explicit],[x,y]         :Set OASIS explicit translate (double val)

-oas_arg [args]                     :Set OASIS other arguments (end with -endarg)

-g2k_ver:[0|1|2|3]                  :Set genesis emulation version

-g2k_order:[0|1|2]                  :Set translation order (2 is no mirror)

-g2k_break_sr:[0|1|2]               :Set break SR on or off

-g2k_scale_mode:[1|2|3]             :Set scaling mode

-g2k_scalexy:[x,y]                  :Override .out_x_scale and .out_y_scale

-g2k_anchor:[0|1|2|3]               :Set anchor mode

-g2k_inch_anchor:[x,y]              :Set anchor inch value

-g2k_mm_anchor:[x,y]                :Set anchor mm value

-g2k_offset:[0|1|2|3|4|5]           :Set offset mode

-g2k_inch_offset:[x,y]              :Set offset inch value

-g2k_mm_offset:[x,y]                :Set offset mm value

-show_progress                      :Enable progress dialog

-unit:[mils|inch|um|mm|cm]          :Set the unit of conversion
                                     (GBR: inch/mm only, OAS: um only, MIC: not used)

-format:[dbl_val]                   :Set the format of RS274X output

-scale:[scale_dbl_val]              :Set the scale of conversion

-cir_map_min_cnt:[int_val]          :Minimum circ surface to convert into flash

-arcres:[dbl_val]                   :Set the arcres of conversion

-arcsag: [dbl_val]                   :Set the arcsag of conversion

-circularize:[dbl_val]              :Circularize arcs (gbr output)

-rotate:[0|90|180|270]              :Rotate (counterclockwise) the gbr output

-mirror:[x|y|xy]                    :Mirror (after rotating) the gbr output

-ply_arg [args]                     :Pass additional args for polygons (end with -endarg)

-circular                           :Set circular mode (mic output)

-keepzerow                          :Set zero width mode (mic output) symbols

-dropzerow                          :Drop zero width draws and flashes.

-odb_symbols                        :Use macro for user defined symbols

-explode_all                        :Explode all symbols (no macro)

-butting                            :Enable butting edge instead of cutline

-polyedge                           :Enable butting/cutline edge patch

-step_repeat                        :Enable step repeat on the files

-filter_text                        :Enable filtering out of text

-filter_barc                        :Enable filtering out of barcodes

-attrout:[attrname],[0|1]           :Output information of specified attrname

                                     convert nonzero pad (default:1)

-plotout                            :Output .orbotech_plot_stamp information

-attributeson                       :Enable attribute output

                                     (set by -attrout/-plotout by default)

-log_dyntxt_info                    :Output information regarding dynamic text

-cc_ir                              :Use counter clockwise rotation on IR

-out_scale:[default|sf|scale|local] :Set the out_scale mode of conversion

-njb[:[njb_fname]]                  :Create job file and Gerber files for Netex-G

-ply_arg [args]                     :Pass args to split274x (end with -end_arg)

-engargs [args]                     :Pass additional args to odb2gdx (end with -endarg)

-iso_week                           :disable ISO standard for week number and year. Must come within -engargs and -end_arg
                                    :The new behavior and default uses ISO standard. -iso_week:1 turns this option on.

-week_incr:N                        :Adds N value to week number ($$WW dynamic text). Must come within -engargs and -end_arg. 
                                    (1 added if N is absent)

-end_arg                            :End of additional arguments

-nobreaksr                          :Use SR optimization even if extents of SR steps were defined by scratch data and the step extents overlap

-gbr_prf[:]           Convert ODB step profile to Gerber file (No full path, default is profile.gbr. 
                                     By default 0.01mm or 0.0004in traces are output)
-gbr_prf_mod_njb                     Insert Gerber profile into njb filename if generated

-gbr_prf_use_g36_g37                 Fill Gerber profile regions with G36/G37. Gerber G-Codes (off by default)

-gbr_prf_dia_trc:dia_val             Trace Gerber profile outlines with aperture D-Code size dia_val

Example for Netex-G

ODB2GBR can be used as a "front" end for the NETEX-G engine (which uses Gerber as its native input.) If you are going to use ODB2GBR to produce Gerber files for NETEX-G, you should also have it produce a NETEX-G job file. There are two command line arguments for that.

Here is a sample command line you can use to convert the sample ODB++ file to Gerber along with the Netex-G job file.

"c:\WCAD\NETEX-G\odb2gbr64.exe"                  path to the executable 

"-job:c:\WCAD\NETEX-G\examples\video_mux.tgz"    name of the ODB++ file to process
"-workdir:c:\WCAD\NETEX-G\examples"              working directory for temp files
"-outdir:c:\WCAD\NETEX-G\examples"               output directory

-netex                                           create output for NETEX-G

-njb:job.njb                                     create the .njb and Gerber files for Netex-G

-step:pcb                                        process the step called "PCB"