Nlview™ Widgets -
Automatic Schematic Generation
Concept Engineering's Nlview™ engine
provides automatic generation of
schematic diagrams for different levels of electronic circuits,
including gate-level, RTL and block-level. Optional engines are
available for the system-level (S-engine) and for the transistor-level
The schematic layout can be modified and controlled by human intervention
and always optimized by algorithms.
A fine granularity of user preferences can be mixed with machine computed
"beauty" to get the best human readable diagrams.
Interactive circuit exploration is supported by incremental schematic
Nlview provides a set of APIs and interfaces with a certain
Please see also the Nlview Widgets
datasheet (PDF file).
The examples below show Nlview-generated schematic diagrams with
The left side shows a cropped pictures, clicking on them will display the
This simple schematic diagram shows
a circuit on operator level with bused connectivity.
The connectivity may come e.g. from elaborated Verilog.
One way for doing that is using the third-party
Verific parser and the
that gives Nlview access to the Verific netlist database.
The VVDI-link is part of Concept Engineering's Nlview software package.
This schematic diagram
shows two highlighted paths and some timing values - as text labels -
and some markers
(that may have been computed by a third-party tool, e.g. a static
Text labels, markers and highlighting can quickly change without
the schematic layout. However, Nlview can optionally adjust the
schematic layout to avoid text overlapping or reuse free space
whenever the text labels change in length.
For this simple example the loading of the netlist and the
generation of the schematic diagram takes about 8ms
of CPU time on an old Intel Xeon and the Nlview data-base
consumes about 100kB.
This schematic diagram
shows two bused muxes with some non-trivial bus
connectivity. The rippers are automatically created.
The circuit (netlist) given for this example is defined
on single-bit level
with Nlview performing automatic net bundling from the
connectivity (however, the
IO port buses and the bus pins of the muxes are given to Nlview).
generated schematic diagram shows only a part
of the whole circuit: the dashed wires indicate nets or buses
that connect more than what is currently displayed.
In addition, this example uses a Nlview feature that displays constant
values as labels at the pins (here with yellow background)
rather than routing power/ground nets to those pins.
This example comes from elaborated Verilog, actually
from the OpenCores project
This schematic diagram shows two signal paths thru
a hierarchical circuit.
The different hierarchy blocks are colored differently illustrating
some rendering features that Nlview provides, including
drop shadow and a sandwich-style stacked appearance.
The plus and minus buttons can be used to unfold and fold
Nlview can also provide incremental schematic navigation starting
with the given diagram.
For this example, the loading of the netlist and the
generation of the schematic diagram takes about 15ms
of CPU time and the Nlview data-base consumes about 80kB.
This schematic diagram is the data-path of the
CPU. This example needs about 55ms for loading the netlist thru
and about 220ms for the generation of the schematic diagram
(on an old Intel Xeon).
The Nlview data-base consumes about 2000kB.
A Family of Nlview Widgets
Nlview interfaces with a certain GUI environment.
Each GUI environment requires a different member of the Nlview
Widget Family like e.g. NlviewQT for the Qt development environment.
Each "family member" is available as a separate product
in a separate distribution package.
However, they all share exactly the same algorithms
and identical APIs and only differ in the way they are tailored for
a certain GUI system.
Each Nlview product is a software component
(available as linkable binary and header files)
that is intended to be used as a GUI building block
for the customer's application. The Nlview Family consists of:
- NlviewQT is a component for the Qt
cross-platform application and user interface framework
(today owned by Digia Plc, former by Nokia and Trolltech).
It is implemented as a class derived from QWidget and provides a
qmake-based build flow.
It is available on most UNIX and
Microsoft Windows platforms
- NlviewTK is a Tcl/Tk
component available as a loadable
object on most UNIX and Microsoft Windows platforms.
It is implemented as a standard Tcl extension for Tcl/Tk 8.1
- NlviewJA is a component for the Java
platform and is available as a
Swing-based component or alternativly as an AWT-based component.
It is implemented as a class derived from JComponent and Component,
NlviewJA is bundled as a Java Bean and supports JDK 1.4 or later.
It can be added to HTML pages for server/client based web applications
(e.g. using AJAX). NlviewJS uses HTML5 canvas objects for rendering.
It is bundled as a .js file and comes with some usage examples.
- NlviewMFC is a Microsoft Windows "control" based on the
Microsoft Foundation Class Library
NlviewMFC is a MFC extension DLL and is implemented as a class derived from
CWnd. It supports MFC version 4.2 or later.
- NlviewWIN is a Microsoft "window" using the Microsoft
native Win32 interface
(internally based on the Microsoft Foundation Class Library).
NlviewWIN is available as a DLL.
- NlviewWX is a component for the
wxWidgets cross-platform GUI Library.
It supports wxWidgets on GTK version 2.4.2 or later.
- NlviewPTK is a Perl package using the Tk module;
Perl is available on most UNIX platforms and on Microsoft Windows.
- NlviewCORE is a GUI-less component for building headless programs
that may e.g. output graphic files like SVG, PostScript or PDF in batch mode.
||Tcl/Tk ≥ 8.1
||MFC ≥ 4.2
||Qt 3, 4 or 5
||wx > 2.4.2
||coreLib & sources
||commands with string arguments
||PDF, PS, EPS, SVG
||PDF, PS, EPS, SVG
The Nlview schematic engines give software teams unparalleled reliability,
flexibility and performance,
so that they can realize GUIs for EDA applications with shorter design cycles,
lower development and maintenance cost and with higher quality.
Build or Buy ?
Automatic schematic generation and display capabilities are
typically integrated into EDA applications such as
logic synthesis, simulation, verification, emulation, test automation
and physical design. Developing high quality and high performance schematic
diagram generation and viewing technology for one of these applications
is tedious and time-consuming.
The EDA tool developers' leverage comes from focusing on
their core competency, not from spending their
precious resources developing schematic technology.
Concept Engineering is totally focused on schematic
generation and viewing technology. The resources required
by commercial and in-house CAD tool developers
schematic technology of equal speed, quality, and
capability are sufficiently high so that these
companies welcome the opportunity to purchase ready-made
With the Nlview Widgets software components,
software teams can begin focusing on the important
issue of their project - the application.
An Industry Standard
Today the Nlview Widgets family is the most
robust and flexible schematic
generation and viewing technology on the market.
component-based solutions ensure that applications work reliably and that
integrators get the highest level of control and customizability.
With tens of thousands of installed EDA applications making use of
Nlview Widgets, Concept Engineering clearly sets the
industry standard for schematic generation and viewing.
Integrate Nlview into Customer Application
The production-proven API (Application Programming Interface) provides
a simple set of commands,
callbacks and configuration properties and makes it easy to
exchange data and information with the application.
Nlview Widget components are available for the most common GUI development
environments and easily fit into most software development flows.
Simple and robust API
Ensures easy integration and reliable applications
Production-proven software components
Performance and quality of application is very high
Highly customizable component
Widget and application fit together
Tcl/Tk, Java, Windows, Qt, Perl/Tk and wxWidgets
Easily fits into your existing software development flow
Result in easy-to-read schematics and short response times
On-the-fly schematic creation
Results in very high speed and capacity
Bi-directional communication between
widget and application
Allows interaction with the application
(e.g. cross-probing, highlighting, attribute display, ballooning)
Incremental schematic viewing
Allows interactive modification of schematic fragments
Windows and UNIX platform support
Application will work on almost any hardware platform
Built-in RTL and gate-level symbols
Application works without symbol libraries
Symbol translation tools
Provide access to existing symbol libraries