Table of Contents
1. Summary 2. Key Features 3. Customers and Market 4. Compiler Support 5. Platforms Supported 6. Chip Architectures Supported 7. How it Works 8. Tilcon Architecture 9. Portability 10. Tilcon Graphics Engine – Detail 11. APPLICATION PROGRAMMING INTERFACE 12. Tilcon Graphics Editor 13. GUI/HMI Object Descriptions 14. Integration with Graphics 15. Dynamic Language Update and Internationalization 16. Scalability 17. TILCON Networking Support 18. Redraw options(offscreen draw or double buffering) 19. ODBC 20. OPC 21. Map Module 22. Other Utilities 23. Resources Available The Main Tilcon Demo The Tilcon Map Demo Tilcon Evaluation Systems Tilcon Tutorials Tilcon Examples Tilcon Documentation Tilcon Technical Support Graphics Editor Development Consulting and Training Graphics Services 24. Sample application 25. Scalability 26. Memory Requirements 27. System Requirements
The Tilcon Real-Time Developer (TRTD) is a multi-platform user interface development solution (Gui Builder) that delivers robust, highly interactive user interfaces for real-time, embedded and mission critical applications.
This white paper is intended to provide a high level technical overview of the Tilcon Real-Time Developer. The first part of the paper will provide a basic overview of the software. A listing of key features, customers and markets will help you quickly understand where this tool is positioned in the market. We will also detail the compiler, processor and operating systems supported. We will then provide a quick overview of how our technology works from the user’s perspective followed by a more in-depth examination of the architecture of the Tilcon system and its relationship to a user application.
We will also review some of the strong points of the architecture as well as portability and reconfigurability of a Tilcon application.
In the second part of the paper, The Tilcon Graphics Engine and the API will be looked at in more detail, followed by an examination of the capabilities of the Tilcon Graphics Editor, our main screen design tool. A detailed listing of the GUI objects and HMI objects will also be included. Important features such as redraw options (built-in double buffering) and anti-aliasing will be reviewed and we will talk about how Tilcon facilitates the integration of design and functionality.
Details on our ODBC and OPC client modules and Tilcon Map Module will be provided as well as more mundane information such as system requirements, build utility and module sizes for scalable applications.
We will also step through a sample Tilcon application and point you to the many resources available from Tilcon to get you off to a fast start.
TRTD is the ideal solution for custom GUI/HMI building, SCADA development, virtual instruments and embedded device interfaces for a variety of industries.
Creating custom graphical interfaces that include high quality virtual instruments is difficult, code intensive and requires very specialized skill sets not readily available in the market. Tilcon frees you from the tedious burden of coding complex user interfaces and helps deliver graphically impressive applications and instrument clusters. You can quickly prototype and immediately test your custom user interfaces moving your project from concept, to prototype, to product in record time.
Tilcon has gained considerable recognition for its development tools and has built up an impressive list of Fortune 500 clients using Tilcon tools to develop their products. This includes a wide range of industrial machinery and devices, such as plastic injection molding machinery, semiconductor manufacturing equipment, mail sorting equipment, steel & paper mill machinery, sophisticated test benches for engine testing and many more.
Tilcon is used in a wide range of on-board vehicle systems in equipment such as aircraft, armored vehicles, locomotives, submarines and other similar applications.
Tilcon has several major design wins with medical device manufacturers helping them produce very sophisticated user interfaces for devices such as anesthesia monitoring equipment, radiation therapy equipment, dialysis machines, patient monitors etc.
With the rise of portable computing, Tilcon is increasingly in use in a variety of handheld and other portable devices. Tilcon’s small size, scalability, speed of development and the exceptional graphics display are all important factors.
Tilcon’s powerful mapping module and the excellence of its virtual instruments is of considerable interest to automobile manufacturers who are moving in the direction of fully integrated electronic vehicle systems.
From the user’s perspective, the process of user interface development with Tilcon looks like this: You use our design tools (Tilcon Graphics Editor) to build screens (twd files). Drag & drop user interface objects from toolbar. Right click to open property sheet and customize to your heart’s content.
All changes are immediately reflected in your work window. At the same time you have the opportunity of visually setting much of the functionality and event management for the object. Click on test button to see what your windows will look like at runtime. Tilcon’s “Test” feature includes object animation with simulated data.
Your C/C++ application will include a main event loop to control the user interface. Your application will start the Tilcon Graphics Engine (a process completely separate from your application) and opens a line of communication with it using TRT_Start. After performing some initialization commands, your application will then instruct the Graphics Engine using API commands to load and possibly display the introductory windows of your interface or create them dynamically.
Typically, the application will then go into a main loop and essentially waits for events to occur. When a Gui event occurs (i.e. button is clicked), the event is either processed directly by Tilcon (i.e. triggers) or Tilcon passes a structure to your control application describing the event for handling by the application code or by calling a callback function.
Your control process (your application) will pass instructions (API commands) that are queued into the Tilcon Graphics Engine. The commands are asynchronous and the control process does not have to wait for the display to be updated before returning to its task of monitoring/controlling the real-world system.
The Graphics Engine isolates the GUI calls from the control application. It is a separate process to allow the control application to be real-time and enhance system reliability.
Once your screens are done and control application written, you compile your application and link to the Tilcon API and are ready to run.
Suggested templates for a Tilcon based control application are provided. A basic template and schematics for a simple Tilcon application is appended to this paper.
The Tilcon development system consists of three principal components: the Tilcon Graphics Engine, a platform independent API and a visual design tool, the Tilcon Graphics Editor.
The Tilcon Graphics Engine is a small, event-driven kernel that has the task of rendering the user's screens. It is a separate process from your application and manages all screen display and user events.
Your application needs only to focus on its core real-time functionality. The separation of the user interface makes your user interface very portable, easy to modify and maintain.
The second component is a comprehensive set of platform independent API calls. These provide the communication between your application and the Graphics Engine. They support the dynamic creation of objects and offer total control over object attributes, while remaining simple and easy to use.
The Tilcon Graphics Editor allows you to build complex screens using simple drag and drop from a broad selection of powerful objects. The appearance and functionality of these objects can be fully customized using the editor's straightforward property sheets.
Prior to providing additional details on each of these components, the unique advantages that arise out of Tilcon’s unique architecture will be described.
The Tilcon process is separate from your application and handles all interfaces to the windowing system.
Tilcon’s Api library is the same on all platforms (windowing systems). A clean separation between application code and the windowing system is maintained.
It is important to understand that TRTD does not generate any code. When you use our Graphics Editor to build a screen and save to our file format, what is being saved in more in the nature of a resource file... a collection of labels, coordinates and instructions that the Graphics Engine knows how to interpret and render. Inside the Graphics Engine are generic "button" routine, a "listbox" routine, a "chart" routine. From the data in the .twd file, the Graphics Engine knows where to put the window, how big to make it, how many buttons there are, where they are, what their labels are, etc. Because these .twd files are data files rather than C code, you can change these files with the Graphics Editor without having to recompile a thing. This approach shields the developer from volumes of generated code, minimizes time-consuming recompilations and makes the application very portable. The files are independent of operating or windowing system and usable on all supported platforms.
The Tilcon Graphics Engine has its own drawing capabilities. All of the “objects” are Tilcon objects and not borrowed from the various windowing systems. Only the most primitive graphics services are called from the windowing system API. As a result the screens are identical from platform to platform.
Minor exceptions arise out of limitations of individual operating systems.
Objects can be created using the editor and saved as part of a twd file or they can be saved as Tilcon object files in the Tilcon library. Objects can also be created dynamically and in fact entire screens can be created, edited and saved dynamically. Regardless of how they are created, the look and feel will be the same on all the supported platforms. The only part of the system that is platform specific is the actual Tilcon Graphics Engine supplied for individual platforms by Tilcon.
The portability of the user interface has many implications and how important these are varies from application to application.
As you can make changes to the user interface without recompiling, maintenance and upgrading is simplified and for some applications remote maintenance becomes a possibility.
All screens are entirely reusable. Your prototype becomes your application.
You only need to write your application once and it is immediately available under all platforms that Tilcon supports. If you are developing a product and want to maximize your market by releasing on multiple platforms, Tilcon’s capabilities are ideal. Many device manufacturers like the fact that although their actual machine or device may be using an RTOS, their sales force are able to walk around with the same application in their Windows laptop. Same considerations apply to training systems.
Another major advantage is cross-platform development. The choice of tools in some platforms may be more limited. It may be difficult to get specialized developers. The need to constantly download to a target may be inconvenient. The ability to do the bulk of the development on a standard operating system with your favorite development environment and better tools with only final tuning on the target is a real advantage.
The Tilcon design tools (Graphics Editor) is very user friendly and designers, artists and developers can easily work in concert even in a mixed environment. More will be said later about the integration of graphics and functional user interface objects.
With built-in TCP/IP networking, you can display and control in a heterogeneous environment. Your data acquisition or device can be on an RTOS and it can easily integrate into your desktop environment.
For some business issues are important. Having the ability to easily move to another operating system may provide leverage and freedom of choice in the future.
Tilcon’s Graphics Engine is in effect a very sophisticated graphics driver. In addition to executing all API commands and rendering the screens, it is responsible for maintaining the main data structure that describes all of the object spaces and objects, and processes window messages, triggers, notifications and callback functions.
It is the go-between your application and the windowing system. It knows how to read a .twd file (the screens you create with our design tool, the Tilcon Graphics Editor); how to create a window from it; and how to create all the buttons, text, charts, meters and other objects within the window. It knows what windowing system commands to use to update an object; how to get the value stored in an object; and how to detect when the user changes an object. It runs side-by-side with your application and in response to its API commands loads and displays the required windows, puts values into the meters, charts and other objects. The Graphics Engine tells the application about text modifications, button clicks and other user interactions with objects in your interface window.
Triggers are in effect API commands that were built into the objects themselves when they were created.
In response to specific events – for example, a checkbox becoming un-checked – the Graphics Engine executes the trigger that was built into the selected object. In this way, a button could be used to dim several fields and display a window, without the need to communicate with your application.
The Server is the part of the Tilcon Graphics Engine (runtime) that handles the graphics services for the user application. It replays and translates API calls to instructions understood by the Engine. It also receives, translates and replays UI events and data to the application.
The API (Application Program Interface) is the protocol between the application and the Tilcon Graphics Engine. The heart of the TILCON API is a handful of fundamental functions. These are the functions that initiate and terminate communication with the graphics engine, that query for notifications, that create and delete objects, and that set or query object attributes. They are as follows.
TRT_Create TRT_Delete TRT_Exit TRT_GetInput TRT_GetValues TRT_SetValues TRT_SimpleCreate TRT_StartEx TRT_WindowLoad
These core API commands in combination with a name/value paired list of attributes affecting all of the objects characteristics enable the creation or editing of all objects. The result is an unparalleled level of dynamic configuration abilities and fine tune control to the developer over the appearance and behavior of objects at runtime.
The key functions needed to interact with an object's properties are:
TRT_SetValues to set the format etc. of the the attribute of the object TRT_GetValues to obtain actual values for the attribute
These functions take a variable number of arguments; the last argument must always be a NULL pointer to show that the list is complete. The arguments in these functions are paired. One parameter specifies which attribute is to be changed or queried; it is immediately followed by the value to be assigned or, for TRT_GetValues, by a pointer to a variable that will hold the value of the queried attribute.
The TILCON Graphics Editor is a set of powerful integrated tools designed to facilitate the creation of the user interface screens. Shortly stated, it allows you to drag and drop user interface objects unto a work window and customize all of the objects to your exact requirements and then save the screen to be called and displayed as part of your application. In addition to all standard user interface objects (buttons, text, combo boxes, listboxes, tree etc), Tilcon provides an array of advanced components such as table, meters, charting, spectrograph etc. A full listing of the user interface objects follows below.
All objects are easily edited by filling in the object’s resource sheets. This allows you to fully customize the appearance (i.e. color, label, borders, images, fonts etc) of the object. Equally important is that much of the behavior of the object can also be specified. Initial state, blinking, text wrap modes, display focus, help bubbles, pop up menus, cursors, shortcut keys etc. A powerful object management paradigm is employed that allows you to effortlessly specify object relationships and implement important functionality such as notification, callbacks, object linking and triggers.
Triggers are embedded api commands that allow you to act upon (delete, display, hide, dim etc) other objects. In effect much of the user interface programming is handled for you.
Tools / features of the graphics editor, include the following:
Add objects to library Save as bmp Grouping Precise placement and sizing tools (nudge tools) Control over redraw (double buffering) and anti-aliasing Dynamic language change facilities Built-in object browser Grid control Zooming Cut/copy/paste/duplicate Front/back Patterns, line styles, line caps Control over curve smoothness Fountain fills and non-linear fills Full graphics and images integration Test Feature
The Tilcon Graphics Editor includes its own vector drawing capabilities and the capability to import and manipulate various image formats.
The TILCON Graphics Editor is itself an application of the Tilcon Graphics Engine. Whatever capabilities your see in the editor…you can also do in your application. Some developers need to create their own customized development tool or editor. To facilitate this task, TILCON does make its editor source code available to qualified developers (agreement required). For more on this see Resources section of the white paper or contact your Tilcon account representative.
Objects
In simplest terms an object is any window, shape or text that has an ID. Each object has specific attributes such as its size and common attributes like colour that control its appearance and behaviour.
The following are the Tilcon objects: (more fully described below):
Animation Area Editable Text Multi-line Text Spectrograph Animation Obj Groups Needle State Objects Button Html Numberbox Tab Notebook Charts Label Text Panel Table Checkbox LCD Text Radio Button Tree Clock Listbox Real Image Window Combobox Menu Items Scale Directory Box Message Text Scroll Area Draw Tools Meter Slider
Components
Objects can contain components. For example, the button object can have alarms which are components.
Alarms Common Indicators Scrollbars Anchor Container Items Tab Notebook Item Angle Cursor Types Link Group Tabbing Blinking Draw Components Notification Text Component Borders(Frames) Fields Popup Menu Triggers Bubbles Fountain Fills Position Calculations Highlight Pulldown Menu Callbacks Images Scales
Buttons
Buttons can respond in a variety of ways to 'clicks' depending on the button type - spring, toggle, repeating, on/off and instant button types are available. Use vector and raster images to complement or replace textual labels. Customize shape, shading, dimming, blinking and help bubbles. Notify your application of events, invoke callback functions, and/or build a list of commands to be triggered in response to the 'clicks'.
Radio Buttons
Radio buttons manage a group of buttons; selecting one item automatically deselects the others in the group. Apply vector/raster images and help bubbles to each label. Customize layout, bullets and shading. Triggers and callbacks are available for individual items, as well as notification of the selected item by the group.
Checkboxes
Tilcon’s checkmark object offers an array of checkmarks, layouts and shadings. Add vector/raster images and help bubbles to the label. Respond to user actions by notifying the application, invoking a callback, or triggering a predefined list of commands.
Scroll Areas
These containers with scroll bars allow you to group many or large objects into a small area of your window. Any object can be placed into a scroll area, including background images (e.g. maps) over which other objects can be layered. Choose the viewed size, total size, shadings, and scrollable options.
Directory Boxes
Directory boxes allow the user to choose from a list of files. Drive, directory, filename and file type are shown; file types can be limited so only certain types are visible to the user. An invaluable tool for 'Open' and 'Save As' forms!
Toolbars
Toolbars attach themselves to any edge of a window - top, bottom, left or right. They provide space for vital information that should be displayed even when the main contents of a window change. Clocks, warning messages and status indicators are a few objects commonly placed in toolbars, which can be customized in layout, shading, as well as in content.
Trees:
Tilcon’s tree widget provide a visualization of a hierarchical list of items. Trees are built quickly and easily: each item is added as a child or sibling of a previous item. Branches expand and collapse in response to user 'clicks'; selected items can trigger commands or send notifications to the application. Customize each item by adding an image, changing its shading or providing a help bubble.
Color Listboxes/Comboboxes:
Color Listboxes or comboboxes are simple tools for providing a choice of colors to the user. A palette of 256 colors is available through these listbox and combobox objects.
Listboxes
Listboxes allow the selection of one or more items from a list. Tailor the listbox behavior to your needs by choosing multiple/single selection, specifying the orientation and sorting of the items, and setting the conditions under which notifications are sent, callbacks invoked, or commands triggered. Specify multiple columns with individual widths. Provide images, help bubbles, hiding, dimming and colors for each item.
Comboboxes:
Comboboxes combine a text field and a listbox. Choose a popup or static listbox, editable or non-editable text, and an array of options for both listbox and text components: layout, colors, images, shading, help bubbles, to name a few.
Numberboxes:
Numberboxes are the perfect tool for numeric input. Control the layout of the editable text, repeating arrows and label. Specify minimum, maximum values, decimal accuracy, number of digits displayed, justification, arrow increments and help bubbles. Set the conditions when notifications are sent, callbacks invoked, or commands triggered. Customize the appearance by setting colors, shading and other options. Link to other objects to share a common value.
Tabbed Notebooks:
Tabbed notebooks allow you to group objects into related categories, each contained in its own folder. Selecting a tab changes the active folder, allowing many choices in a form while using little screen real estate. Tabbed Notebooks options include setting the location, shape, font, default colors, highlight colors, and labels of each tab, as well as the colors for each folder in the notebook.
Panels:
Panels are tools commonly used for grouping objects. These containers are surrounded by a 3-D border with an optional label at the top. All objects in the panel can be moved as one, hidden, cut, copied, pasted - by performing these actions on the panel itself. The type of 3-D border, the label and all colors can be customized.
HTML File Displays:
HTML File Display will, as the name implies, display an html page given its URL. Use this to create on-line help applications, or maybe even your own web browser! Font, scrollbar and notification controls are built in (where applicable).
LCD Text:
Tilcon’s LCD Text Object simulates the segmented text of an LCD or LED screen. Ideal for realistic-looking displays, e.g. for calculator applications and consumer appliance displays. Customize the segment sizes, margins and colors.
Raw Images
Raw Images are used to import vector and raster images into a window. Like all objects, they have their own frame, can be moved about the window, and can send notification of mouse clicks... they can even display a help bubble.
Text:
Editable, message, label and multi-line forms of text are available to meet the need for textual objects. Editable and multi-line text can respond to user interaction and events - gaining focus, losing focus, individual keystrokes - by sending a notification, invoking a callback or triggering a command. International text is supported, as are input masking, formatted output, and a wide assortment of fonts and sizes. Other attributes include justification, colors, dimming, hiding, linking to other objects, blinking, and help bubbles.
Tables:
Tables provide spreadsheet-like control of your data I/O. Each column can contain its own type of object, including editable text, message text, raw images, numberboxes and comboboxes. Every cell has all the options and attributes available to the type of object it contains, so tables provide vast amounts of built-in functionality and configurability. In addition to which the table has many attributes of its own, including row/column dimensions, scrollbar options, grid line options and colors, and sorting. And, as with all objects, every attribute can be modified dynamically!
Fill Meters:
Fillmeters are invaluable tools for process-oriented applications where a value is represented by the fill level within an outer body. Updates are smooth, fast and flicker-free. In addition to the predefined shapes (square, rounded, triangular, thermometer), vector images can be imported. Fully configurable scales are automatically attached; calculations can be built in; and the value can be linked to other objects. The meter can fill from its minimum or from 0; it can also change its fill color automatically as its value crosses 0. Other features include control of the colors and borders of each component.
Needle Meters:
Needle meters are formed after adding one or more Needles into a Needle Meter Body. An array of body shapes is available, defining the behavior of the needles. Meter bodies can also be hidden so the needles are shown over imported images, increasing their realism. As with fill meters, scales are automatically attached, and needle updates are smooth and flicker free.
Needles offer an array of predefined shapes and widths; vector images can also be imported to increase realism. Links can be made to other objects; calculations can be applied to values before they are displayed. Other options affect colors, tip/tail lengths, and pin shape and size. Anti-aliasing options are currently available for all predefined needles. This feature is being extended to meter bodies and will soon also be extended to user defined needles.
Color and Multi State Objects:
Color and Multi-State Objects have numerous applications, the most obvious as alarms in process control applications. They are configured to have one or more 'states' corresponding to a range of values. When the value in the object crosses the boundary from one state to another, either the color or symbol of the object changes, and the object can trigger a command or notify the application of this event. Vector images are imported and used as the symbols. Blinking can be set for each state individually; links can be made to other objects; and calculations can be applied to values before state changes are assessed.
Scales
Numeric, alphanumeric, date and time stand-alone scales provide the perfect complement to drawings, animation and other objects. With the choice between linear or circular shapes, linear or logarithmic increments, a tri-colored alarm indicator, and a battery of configurable options for the text and tickmarks, the scale offers complete versatility.
Menubars & Pop-up Menus:
Placed at the top of the window, the menubar provides multiple levels of drop-down menu items. The cascaded sub-menus provide command, toggle and radio button behaviour for each of their items. Each item can send a notification, invoke a callback or trigger a command upon its selection. Additionally, Pop-up Menus can be created in most objects; these appear when a 'right-click' occurs on an object that has defined a pop-up menu.
Sliders:
Sliders provide a visual method for numeric input. The slider offers predefined and custom handle images, optional endbuttons, attached scales, and a choice of directions. Customize the layout and appearance of each of its components. Set the conditions under which the slider responds to user input - by notification, callback or trigger.
Clocks:
The clock object allows for the display of current date or time in a variety of formats. Fonts and colors are also configurable.
Charts:
Tilcon charts represent data as a function of an independent (x) variable, where each y-series provides a data point for each xvalue.
The x-data may be numeric, alphanumeric, date or time; attached scales can represent each of these cases. Charts offer multiple ways of plotting their data: as scattered points, as connected lines, as solid areas, as pie slices, as vertical or horizontal bars, as stacked bars or areas when more than one series is supplied. Series can also be used to create x/y error bars or high-low plots. Other features include auto-scaling, dual y-scales, markers for each point, individual colors for each line/area/marker, limits above/below which plotted colors change, linear/log increments for each scale, and many other options affecting the chart's appearance. Functions are provided to update the chart one point at a time or in groups of points (like an oscilloscope) or to scroll data onto the chart (like a strip-chart recorder). Like in other objects, every attribute of the chart is fully dynamic and can be changed either during development or programmatically.
Spectrographs:
Tilcon’s spectrograph object displays a raster image in an array of cells. However, this data is supplied by directly setting the colors for each cell rather than through the use of an image file. With a configurable cell size, variable number of rows and columns, and the ability to scroll the spectrograph's data towards any edge, this object provides a simple yet powerful alternative to raw images for applications that have immediate access to the data that will form the image.
Animation Areas and Objects:
Animation areas and objects provide smooth motion for vector images and raster images, and smooth sizing and rotation for vector images. The area defines the space in which the objects may move and sets up a coordinate system scaled to that area.
Object position, and the size and rotation of vector objects, are calculated with respect to the animation area coordinates.
Draw Tools:
The TILCON Graphics Editor offers powerful drawing tools with 24 unique drawing shapes, full bezier and polygon editing, rotate, skew, mirror, attach arrows, line widths and types are provided allowing you to create the symbol shapes, logos and designs you need in your application. Combine this with the ability to import vector images and modify them dynamically gives you powerful animation capabilities.
The twelve universal drawing tools are Bezier curve, polygon, trapezoid, diamond, ellipse, parallelogram, rectangle, roundcornered box, straight line, triangle, arrow and arc. In addition to these, there is a selection of twelve standard flow chart tools to help you create multi-component charts quickly and easily. The flow chart tools are: manual input, gate, manual operation, display, preparation, on-line string, punch tape, keying, document, off page and transfer tape. Each drawn shape can be moved, resized, extended, reduced and manipulated alone or as a group to produce your drawing. Each shape created with the draw tools can be reshaped with the available option features.
Tilcon prides itself in making it very easy for its customers to build graphically impressive and fully custom user interfaces. Part of those capabilities comes from the range of attributes and the handling of colors, transparencies, fills, anti-aliasing, double buffering and other features of the user interface objects by the Tilcon Graphics Engine. Also important is the full integration of images and user interface objects making it very easy to incorporate images that have been given the perfect look and feel using artist or designer tools (i.e. Photoshop) into user interface objects. With Tilcon it is very easy for both designers and developers to work in parallel in their development. The Graphics Editor is simple and intuitive and no programming ability is required to create screens.
Tilcon provides a range of clipart in its clipart directories. Support is provided for various image formats allowing companies to use existing assets. Extensive demos are provided, any part of which (including buttons etc) is fully reusable by licensed customers.
A developer who has the help of a competent graphics artist will have no difficulty in recreating any of the effects seen in the Tilcon demos.
Tilcon has in-house graphics artists who are skilled with Tilcon tools and they are available for consulting work on projects if your project has no graphics artist resources.
Tilcon supports international character sets in all text tools.
In addition to TRT_SetValues function that allows the change of attributes one-by-one, Tilcon provides a mechanism that makes it easy for your application to globally change the language of the labels in your user interface. The function that implements this mechanism is called TRT_ChangeLanguage.
This function uses the contents of a file to replace text labels, whether of GUI objects, text fields, help bubbles, menus or window titles.
At development time, you would start with the “Save Language File” option found in the Tilcon Graphics Editor. Selecting this option generates a Tilcon language file (.twl) for that window. A .twl file is encoded in UTF8 and each line contains the ID of the Tilcon object followed by all the text to use within that object. The language files can be merged with other .twl files, or individual entries can be added or deleted until you have a satisfactory template. As you need a language file for each language you want to support, you would then make a copy of this file for each language and then have the files translated (make the language specific changes to the labels in each copy.).
TRT_ChangeLanguage will read and display the labels from a language file (.twl) and changing language is simply a matter of pointing to the right language file.
Tilcon also provides a language conversion utility to facilitate conversion from multibyte to UTF8 and vice versa. Version 4.7 will also provide support for Unicode and code page.
Version 4.7 of the Tilcon Real-Time Developer will also include a major redesign of the font engine. In addition to the basic font set that Tilcon will provide, users will be able to install their own font sets.
The TILCON Real-Time Developer enables you to create a custom-configured kernel (graphics engine), which is composed only of the components required by your application. With this scalable kernel option, you can compile a much smaller kernel using less RAM. The scalable option allows you to discard any unnecessary software overhead. This of course, is especially significant in embedded systems where memory is at a premium. An application, for example, that never uses animation does not require a graphics engine kernel with animation capabilities.
Using a utility in the TRTD and a simple point and click interface, you can select the desired capabilities from the available set of TILCON libraries. The utility then produces a makefile that can be used to link the appropriate libraries to create a scaled down graphics engine kernel. Additional details and memory requirements of individual objects are appended.
Tilcon has implemented a powerful channel object, which gives the user built-in support for many alternatives in application and network architecture. The channel object is in effect a communication nexus encapsulating the transport mechanism ...a mailbox if you will through which messages enter and leave the program. The transport mechanisms currently implemented include TCP/IP and IPC (interprocess communications). IPC is used for Tilcon threads or tasks within the same host. Additional protocols (HTTP and PPP) will be added in 2003.
The IPC mechanisms supported are as follows:
Message passing (Neutrino, QNX) Pipes (VxWorks) Shared Memory (Windows NT, CE)
P1, P2, P3, P4 and Tilcon Graphics Engine are on same host. This architecture is the most common work form.
P1, P2, P3, P4 are Tilcon applications. They call Tilcon APIs to
connect to the Tilcon Graphics Engine.
C3, C4 and Tilcon Runtime are not on same host. They must be
connected by a communication line. At present, built-in support for TCP/IP
connection is provided. Requests for
support for additional networking protocols will be considered.
Notes Application – to - Application communication is currently available using IPC only. Application - to - application communication using TCP/IP is under development. Threads cannot share channels. Channels are implemented using SRR (Send->Receive->Reply) providing advantages for real time applications. Tilcon channels are modular and designed to accommodate additional protocols. New protocols (PPP and HTTP) are planned for 2003. Runtime - to - runtime ditto feature…where application sends to one graphics engine and a command executes on multiple graphics engines (displays)… is also under development.
In order to update an object, it must be redrawn. All or part of the object must be cleared and then drawn again to reflect new values or settings. This re-draw of the object may be done directly on the screen, or it may first be produced as an offscreen image, which is copied to the screen. There are differences between Onscreen and Offscreen Redraw.
Redrawing objects Onscreen is the quickest way to update them. However, because the old setting must be cleared from the screen to draw and display the updated settings, the user often sees a flicker in the application where the clearing occurs. The Onscreen option is best used when the application must make a quick update of an object that does not change very frequently.
By drawing first into the offscreen image and then copying that image to the screen, the user never sees the screen cleared, and therefore sees no flicker. This is a recommended method for updating objects, which are constantly changing such as a needle meters and fillmeters.
If the object to be updated has other superimposed objects, you must decider whether you want to draw just the object or the area that encompasses it.
Redraw Object - is the choice when an object stands alone, or when no other objects are layered above or beneath it. Drawing only one object is much faster than redrawing its area, but that object will be drawn over any other object at that location.
Area redraw - This option redraws the object that you are updating and all other objects, which are layered on top and below it. In effect, it draws the "area" which is affected by the update. In this way, an object is redrawn in its correct position amidst the layers. If the area is drawn Onscreen, flickering will appear for the updating of the area. If it is done Offscreen, the layers are drawn from the back to the front, and appear much smoother when displayed.
Never Redraw - This option is useful for objects you do not wish to have redrawn when you know another update is forthcoming. ‘Never’ objects do not redraw themselves when they are updated, only when the area they are in must be redrawn.
The Tilcon redraw options can be fixed as the screens are being designed in the Graphics Editor or programmatically using api commands.
The ODBC module supplies the reading and writing functions between an object and an ODBC compliant database server. Each of the many existing databases has its own format. The ODBC standard defines a set of functions - an interface - that enables an application to communicate with any (ODBC compliant) database. By using the standard ODBC functions with your application, it becomes an ODBC client ready to communicate directly with a database.
The TILCON difference - The TILCON ODBC functions serve a somewhat different purpose. They assume your application is not an ODBC client - but that the TILCON kernel is. The TILCON ODBC functions tell the TILCON kernel: - how to interact with the ODBC database - which ODBC fields and tables to use - how the ODBC fields and tables should be bound - which TILCON objects should be bound to these fields The TILCON functions are not wrappers for standard ODBC functions, nor do they directly retrieve values. However, your application can exchange data with TILCON objects and these objects can exchange their data with ODBC fields; your application therefore has an indirect path into the ODBC Database.
TILCON ODBC group - The TILCON ODBC group collects one or more fields belonging to a Database table. The group then coordinates the exchange of data between these fields and the TILCON objects that are bound to them. The ODBC group functions let you select a number of records, fetch their values into TILCON objects, update selected records using TILCON objects, and insert object values into ODBC fields.
For additional information please download the ODBC manual (.pdf) available from our website.
The OPC module supplies the OPC functions between the graphics engine and an OPC compliant server. OPC is a mechanism by which a server makes memory addresses available to multiple clients. An application must connect to an OPC server using TRT_OPCAddServer. The server is identified by its ServerID (ProgID) and by its HostID (computer name where the server will run). The ServerID must exist in the local Registry; please refer to your OPC server's documentation for how to register this name.
The application must then create 'groups' within the server object, using TRT_OPCAddGroup. Groups store the input/output attributes for the items they will contain, e.g. the update rate, whether to read from OPC or write to it, etc. Into each group, the application will add items using TRT_OPCAddItems. The item properties specify, for example, how to bind the OPC item to a TILCON object. Some objects (e.g. charts) have multiple components (e.g. series) that may be bound to OPC items. Other objects (e.g. comboboxes) may have several interpretations of the data they receive (e.g. an OPC string could be interpreted as a label or as an index).
Each item in a group shares the group attributes - e.g. read/write mode. All items in a group (or a subset of them) are updated simultaneously, with a single call. An item can be added to multiple groups. Since updates occur on a group-by-group basis, not an item-by-item basis, one group can be reading OPC values into an item at one rate while another group writes the item's values back into OPC at a different rate. Items within a group need not be bound to TILCON objects. They may simply provide a connection to the items in the OPC server, relaying data between the application and the OPC server.
Updates between OPC and connected items can happen by any/all of the following mechanisms:
a) forced update by API command;
b) response to the group's timer;
c) notification from the OPC server of a change in an OPC value.
For additional information, the full OPC manual is available for download (.pdf format).
The Map module enables users to manipulate and display geographic information;
Support is provided for the import of standard ADRG, CADRG and DTED (Digital Terrain Data), (DTED implementation not finished as of the date of this paper);
Tilcon's Map API comprises over 80 API function calls to manipulate geographic data. This API currently addresses the manipulation of map data originating from paper documents, that is, paper maps that have been scanned. The API functions allow the registration of such data to selected geographic projections (below), and the creation of databases of registered map files. The databases use a tiled file structure.
Tilcon’s map library also includes functions for displaying grids and digitizing and playing back routes, Zoom, Pan and Animate objects.; (These calls are implemented in the demo and illustrate how to use the API to achieve the related functions);Utility functions for handling commonly-used geographic coordinate systems;
Rasterized map data are stored as Microsoft Device Independent Bitmaps (BMP files) for which the Tilcon Graphics Engine provides support. Geo-referencing of these files is handled by structures embedded in the map library. Coverage databases comprise matrices of geo-referenced BMP files.
Utility functions to change reference datums to and from WGS84-based datums as well as converting between geographic coordinates and projection coordinates are provided. At the moment the widely used UTM projection is fully supported together with MGRS-encoding of the UTM values, as are the UPS projection for polar regions, the Albers equal-area conic and the Lambert conformal conic projections with two standard parallels, Generic TM projections such as Gauss-Kruger and the MTM projections is forthcoming.
Functionally for removing systematic distortions from scanned paper map products is an important aspect of the map library which enables users to register scanned products to the projection coordinate system, and is a first step to the creation of the coverage databases. Additional functionality to create a matrixed database of map tiles from scanned maps is also provided. Functionality for merging adjoining databases is also provided.
A table of datums and associated ellipsoids and geographic areas is supplied to assist users in selecting appropriate values for their areas of interest. A table of coefficients for datum shifts to WGS84 using the MRE method is also supplied together with a table containing parameters of thirty-four commonly used ellipsoids.
A database of Map data is created by a utility. This database comprises many .bmp files (Tiles) as well as a .toc file, which describes the contents of the database.
An image object is created in the display window. This object is referenced to the real-word. API calls seek out the area of interest in the dbase and create an image in memory, which is displayed.
The application may then instruct the viewer to manipulate the map to achieve the desired results using the API calls provided in the library.
The API also contains functions for forward and reverse conversions between geographic coordinates and projection coordinates (for the supported projections) as well as functionality for converting to and from WGS84-based datums.
The full Map Module Reference Manuals is available for download in .pdf format for additional details.
TTR
The TTR utility is used to produce reports about the contents of a .twd file (the window or screen contents). A report can list all the objects in the .twd file in a hierarchical format, showing all the objects and their parents, siblings and children. Another report provides detail on attributes (object properties) within the .twd file. The user is able to define which of the properties to report on. TTR Utility’s main purpose is to facilitate generation of documentation about the contents of the user interface.
The Tilcon demo is a suite of sample Tilcon applications intended to demonstrate the range and capabilities of the Tilcon Graphics Engine. It includes applications such as a car dashboard demo, reconfigurable meters, oscilloscope, reconfigurable charts, strip charts, medical device demos, process control (beer factory), calculators, cellphones and others.
All of the source code for the demo comes with the download allowing you to further examine the structure of Tilcon applications.
If you also downloaded a Tilcon evaluation system, all of the demo screens (twd files) can be opened in the Tilcon Graphics Editor and essentially reverse engineered to see exactly how the screens were built. All you do open the file (using file open in menu of editor), select any object or component and right click to open up the property sheets for that object. The object browser (button on the toolbar if not already open) allows to easily pick out objects that are small, layered or obscured by other objects.
The Tilcon Map Demo a fully integrated map viewer demonstrating the display and manipulation of a matrixed databases of maps which includes features such as ROAMER (to quickly navigate the entire map database), 8 button scrolling, Zoom, Map Centering, Soft Zoom, Route Digitization and Playback, Sites of Interest database and other features. As the map database is quite large, this is a substantial download and separate from Tilcon’s main demo. The map demo source code is also available.
Tilcon makes available a 30-day evaluation system in its standard configuration on multiple platforms. Generally this does not include specialized modules such as OPC, ODBC or the Map Library. If you wish to evaluate these capabilities specifically, you need to contact Tilcon to ensure that the proper licensing and software is provided.
The evaluation systems are time limited but are otherwise fully functional versions of the software. Full online help is provided, the Tilcon Tutorials are provided as well as the sample and clipart libraries.
The tutorials are designed to be systematically stepped through and will teach you step by step how to create screens with the Tilcon Graphics Editor and how to bring them to life with your C/C++ application. In so doing it explains much of the basic functionality and features of the software and are highly recommended to new users.
The TE4 directory that comes with the Tilcon evaluation system includes basic application templates as well as more complex items such as TCP/IP examples, ODBC and OPC examples. The source code from the demo is also very useful and contains a multitude of code examples.
You can also contact Tilcon Technical Support to obtain additional examples for specific issues.
Tilcon’s full manuals are contained within the online help. This includes the full manual for the Graphics Editor and the full API manual. The full manuals for the Map Library , ODBC, OPC and various other utilities are also available.
In addition to your Tilcon account manager, you also have free access to the engineers in our Technical Support Department for the duration of your evaluation period. After your purchase, Technical Support is also available. As you will note from the customers comments on our website, the Tilcon Technical Support team has received very high praise from our customers and they are invaluable in helping you get up to speed and productive quickly.
Occasionally, developers enquire about using the Tilcon as a graphics engine to construct their own specialized editor or toolkit for dedicated applications. They want to be able to construct their own form or graphics editor, to be able to give their end users extensive abilities to modify screens and on their own label. This can be achieved using the Tilcon Graphics Engine. In fact, that is precisely what we did! The Tilcon Graphics Editor is nothing else but an application of the Tilcon Graphics Engine. It is a reasonably complex application and depending on the extent of functionality that a customer requires, could be an extensive project to undertake.
To make it easier for customers to build their own fully custom graphics or forms editor, Tilcon has available for sale the source code for the Tilcon Graphics Editor.
Tilcon has highly trained and experienced engineers and trainers who can be of invaluable assistance in getting your project off to a fast start. They are highly knowledgeable in Tilcon internals and can also be of great help in the fine-tuning and optimization of your application prior to commercial release.
Tilcon has in-house graphics artists who are experienced with Tilcon software tools and available to assist customers in creating a custom look and feel for their application.
Here is the skeleton of an application for use with TILCON. Communication is opened with TRT_Start, and an initial window is created and displayed. Within the main loop, TRT_GetInput waits for the Runtime (graphics engine) to report an event. Your application provides some form of ProcessTilconNotification function to be called when notifications are received from the Runtime; TRT_GetInput takes care of processing callbacks. TRT_GetInput can also be set up so that messages from other processes can be received, or it can wait for semaphores to signal events, allowing for this program to communicate with other processes. At some point, in response to some event, the program will break out of the infinite loop and call TRT_Exit, which will tell the Runtime to terminate.
This is a very simple application that uses TRTD V4.6.
It creates a window and two buttons. When the user clicks on one of the buttons the window will change color.
To compile you must link this to "trtapi.lib".
#define CC_TRT_DOS // Do this so the kernel knows we are in Windows
#include <windows.h>
#include <stdlib.h>
#include <tilcon/TRTConst.h>
#include <tilcon/TRTAPI.h>
// Function Prototypes //
void CreateGUI(pid_t TRT_pid);
// Global variables //
TRT_StartData StartData; // This structure will store info about the kernel
// Function Definitions WinMain or Main//
int WINAPI WinMain ( HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpszCmdLine,
int nCmdShow )
{
TRT_ReceiveData rec_data;
long running;
long looping = 0;
long c;
// Start the runtime //
StartData.Display = NULL; // This flag is used for TCP/IP. Normally it is set to NULL
StartData.Userprog = "tutor";
StartData.AppName = "tutor";
StartData.Flags = NULL; // For now set to NULL
StartData.Os_Env = TRT_MS_WINDOWS; // The operating system this app is running under.
running = TRT_Start ( &StartData);
// If the runtime started up okay //
if (0 == running) // - 1 an error//
{ // Create the GUI //
CreateGUI(StartData.TRT_CID);
looping = 1;
}
while (looping)
{
// _Wait for input from the runtime. Notice TRT_BLOCK //
c = TRT_GetInput (0, 0, NULL, 0, &rec_data, TRT_BLOCK );
if (c == 0)
{
// You can find definitions for the codes in TRTCONST.H //
// The receive data structure essentially works the same as //
// in version 3 //
switch (rec_data.code)
{
// The user clicked on a button //
case TRT_button:
if (0 == strcmp("button1", rec_data.ID))
{
// Color the window dark blue //
TRT_SetValues(StartData.TRT_CID, "main",
TRT_ATT_FILL_COLOR, 1, NULL );
}
else if (0 == strcmp("button2", rec_data.ID))
{
// Color the window green //
TRT_SetValues(StartData.TRT_CID, "main",
TRT_ATT_FILL_COLOR, 2,
NULL );
}
break;
// The user clicked on something else, most probably the X close button on the window //
default:
looping = 0;;
break;
}
}
}
TRT_Delete(StartData.TRT_CID, "main");
TRT_Exit(StartData.TRT_CID);
return 0;
}
void CreateGUI ( pid_t TRT_pid )
Parameters: TRT_pid : Channel ID of an object space within a tilcon runtime
Returns int : Exit code
Comments : Create a window and two (2) buttons.
void CreateGUI(pid_t TRT_pid)
{
SimpleObject widget; // This structure is used to create Widgets
// Create the main window //
strcpy ( widget.Id, "main" ) ; // This is the ID of the window
strcpy ( widget.Label, "Tutor" ) ; // This is the label that appear on the window
widget.parent_id[0] = NULL; // The window will not have a parent
widget.Style = 0;
widget.X = 0; // It will appear at 0,0
widget.Y = 0;
widget.Width = 320; // and be 320x240
widget.Height = 240;
widget.Flag = 0;
TRT_SimpleCreate (TRT_pid, (long)TRT_window, &widget);
// Create a button //
strcpy ( widget.Id, "button1");
strcpy ( widget.Label, "Blue");
strcpy ( widget.parent_id, "main");
widget.Style = 0;
widget.X = 5;
widget.Y = 5;
widget.Width = 60;
widget.Height = 40;
widget.Flag = 0;
TRT_SimpleCreate (TRT_pid, (long)TRT_button, &widget ) ;
// Make the button look a little more intresting //
TRT_SetValues(TRT_pid, "button1",
TRT_ATT_HIDE, 0,
TRT_ATT_BORDER_LOOK3D, 0,
TRT_ATT_BORDER_DEPTH3D, 2,
TRT_ATT_NOTIFY, 1,
NULL);
// Create another button with the same attributes //
strcpy ( widget.Id, "button2"); //All widgets require a unique ID
strcpy ( widget.Label, "Green");
strcpy ( widget.parent_id, "main");
widget.Style = 0;
widget.X = 65;
widget.Y = 5;
widget.Width = 60;
widget.Height = 40;
widget.Flag = 0;
TRT_SimpleCreate (TRT_pid, (long)TRT_button, &widget );
TRT_SetValues(TRT_pid, "button2",
TRT_ATT_HIDE, 0,
TRT_ATT_BORDER_LOOK3D, 0,
TRT_ATT_BORDER_DEPTH3D, 2,
TRT_ATT_NOTIFY, 1,
NULL);
// Display our Widgets //
TRT_Display(TRT_pid, "button2");
TRT_Display(TRT_pid, "button1");
TRT_Display(TRT_pid, "main");
}
Overview
The Scalable user interface is a set of integrated components needed to create a custom-configured kernel. This kernel will contain only the functionality required for the application. The utility produces a makefile, which is used to link the appropriate libraries to create the scaled-down runtime kernel.
The scalability utility uses a script file (*.tsc) to control the generation of the makefile. If a particular object is not required, a stub file is inserted into the build.
Scalability Screen showing the defaults selected.
File
This menu contains sub-menus to open, close or save a *.tsc file.
New
The New... sub-menu creates a new Scalable screen with runtime components.
Open
The Open... sub-menu opens a dialog in which a (*.tsc) file can be selected. The file will be loaded and can be edited before saving.
Save
The Save sub-menu saves the current configuration to the *.tsc file that was opened.
Save As
The Save As sub-menu saves the current configuration to a new *.tsc file..
Close
The Close sub-menu closes the current configuration and exits the program.
The Scalability Utility offers a standard layout of runtime components as a default.
Create
Selecting the Create button causes the Scalable utility to create a runtime kernel based on the selections made in the utility screen.
The following table indicates approximate memory requirements for each component.
The memory size for a given component, includes the memory requirements for the other included or required components.
Component Other Required Components MS(KB) QNX(KB) Slider Scale 28 20.11 Spectrograph 4 4.91 State Object 24 17.11 Tab Notebook 16 18.36 Table Button, Text Editable, Text Message, Scroll area, 52 34.7 List Box, Combo Box, Number Box Text Editable 32 28.88 Text Label 12 18.54 Text Message 24 28.88 Toolbar <4 4.19 Treeview List Box 8 8.92 ODBC 40 326.07 OPC 24 N/A Empty Kernel 496 493.13 3D Panel <4 3.17 Animation 20 13.81 Button 16 17.5 Chart Scale 152 120.54 Clock 12 19 Combo Box Text Editable, List Box, Scroll Area 24 17.02 Directory Box Text Editable, Text Label, Treeview, Scroll Area, List Box, Combo Box 28 15.56 HTML <4 74.25 LCD 24 24.27 List Box 36 34.28 JPEG Image Support 56 56.94 Menu 12 11.76 Meter Scale 64 44.7 Number Box Text Editable 12 11.67 Radio Button 20 19.96 Scale 56 63.38 Scroll Area 4 4.91
* Information is provided for illustration purposes only and not warranted. Data is based on specific version under test at the time. Actual memory requirements will vary from version to version as code changes are made and new features added. *
The following system requirements are for the Tilcon Real-Time Developer and vary according to platform. Runtime information is full runtime with no components deleted.
Photon microGUI QNX 4.25 1.5 MB Ram for the Runtime 32-bit Kernel nameloc – running Pipe – running (if running over network) QNX – running Photon – running WATCOM Compile Photon microGUI QNX 6.1 1.5 MB RAM for Runtime 32-bit Kernel nameloc running Pipe running – (If running over network) QNX – running Photon – running GNU Compiler Windows 95/98/Me/NT/2000/ NT Embedded 3 MB RAM for the Runtime 32-bit Kernel Windows running VC++ Compiler Wind River® VxWorks 1.5 MB RAM for the Runtime 32-bit Kernel Tornado™ WindML™ Windows CE 1.5 MB RAM for runtime 32-bit Kernel Windows running Embedded VC++ Compiler Or CE Platform Builder Or Board Manufacturer development system
* Information is approximate, version specific and not warranted. *