Frequently
Asked Questions
Allegro Toolkit Product FAQ
This FAQ attempts to answer the most common
set of questions about the Allegro device management and UPnP
toolkits. We will update it as often as we can to cover the widest
range of topics. There is also a selection of backgrounder and
more detailed presentations and white papers elsewhere
on this site. For any additional information please contact
us.
Why
Use Browser based Device Management?
Why RomPager?
Who uses Web management?
How does it work?
Are there Operating System
Environment requirements?
What are the Compiler Requirements?
What are the Memory Requirements?
What are the TCP/IP Interface Requirements
Are there
HTML Formatting Requirements?
Forms Processing
Requirements
When can I have it?
Is a Demo Available?
Need more info?
Why
Use Browser based Device Management?
Since Web browsers run on any Windows PC,
DOS, OS/2, Unix, and Macintosh systems, embedding a Web server
means universal client support so you can avoid building custom
management applications or requiring expensive SNMP management
consoles.
Web pages located on the network device can point back to your
Web site to improve customer support, provide current marketing
information and improve your relationship with your customers.
Web-based Management with RomPager makes
accessing and setting up your routers, gateways, switches, hubs,
print servers, RAID disk servers, controllers, Universal Power
Supplies and other network devices as easy as browsing the Net.
For further information read Allegro’s background
paper.
^TOP OF PAGE
Why RomPager?
Using the RomPager embedded Web server toolkit
provides you with a number of advantages:
You will be in the marketplace sooner with less engineering expense
than developing these capabilities on your own. We've already
done the compatability testing for all versions of the major browsers
to insure a solid, protocol-compliant, implementation of the Web
server specifications.
RomPager was designed from the ground up
to support devices with ROM-based real-time environments, while
the available public domain code was designed for disk-based Unix
environments.
Ongoing support for new browser revisions
and the new versions of the evolving HTTP/HTML specifications
is provided by Allegro to save you engineering time.
^TOP OF PAGE
Who
uses Web management?
Check out this list
of companies using this product.
^TOP OF PAGE
How does it
work?
Please see our detailed presentation of product
architecture here.
^TOP OF PAGE
Are
there Operating System Environment requirements?
The Allegro toolkits are designed to be portable
between embedded RTOS and TCP run-time package and include interface
files for popular RTOS environments on the distribution diskettes.
Some of the run-time environments that we know have supported
our products include uCOS, ARC/Precise MQX, Elmic ELX, Enea OSE,
Express Logic ThreadX, Green Hills INTEGRITY, JMI C-EXEC, Kadak
AMX, Accelerated Technology Nucleus, Microsoft Windows CE, Fusion,
Perihelion Helios, Radisys OS-9, QNX, SNMP Research, Treck TCP
and WindRiver pSOS/VxWorks stacks. RomPager has also been ported
to Windows 95/98/NT/2000/Me/XP, Macintosh, Linux and Unix environments.
Since RomPager comes with its own internal
scheduler, any OS can be used to support the engine. In fact,
some of our customers do not use an OS, and just run RomPager
off the main device idle loop. For these environments, RomPager
may be invoked with code similar to the sample below:
AllegroTaskIsUp = false;
theAllegroData = AllegroInit();
if (theAllegroData != (void *) 0) {
AllegroTaskIsUp = true;
}
while (AllegroTaskIsUp) {
/*
Wait here for time or
event message and
give up time to other
threads.
*/
if (!AllegroMainTask(theAllegroData, &theHttpTasks,
&theTcpTasks)) {
AllegroDeInit(theAllegroData);
AllegroTaskIsUp = false;
}
}
RomPager uses a single processing thread with multiple TCP connections
maintained in the TCP layer and multiple overlapping HTTP requests
supported by the RomPager engine using internal request control
blocks and a lightweight scheduler. The engine uses either a polling
or message passing model to interface with the TCP/IP interface
and timer services. If a message passing model is used, the thread
is passed messages from the TCP interface for packet activity,
and timer messages once per second. The HTTP protocol is not very
time-sensitive, so the RomPager thread may be run at a low priority.
^TOP OF PAGE
What
are the Compiler Requirements?
The Allegro toolkits are delivered as an
integrated set of ANSI-C compliant source code that provides HTTP,
HTML, and forms processing engines. The code has been smoothly
compiled across many versions of Intel, Motorola, AMD, ARM, SPARC
and MIPS processors in CISC and RISC environments.
^TOP OF PAGE
What are the Memory
Requirements?
As a benchmark on memory requirements, the
RomPager engine and toolkit runtime routines take between 9Kb
to 25Kb of ROM code, with 4Kb of ROM data, 1Kb basic engine RAM
and 3Kb to 5Kb of RAM per simultaneous HTTP request. Actual requirements
depend on which compilation options and engine features are chosen.
The RomPager application toolkit uses a number
of techniques to save page memory including dynamic HTML generation
and text pointer sharing. As a result, the internal stored format
of pages is about 60% of the external HTML page size. A typical
application?s pages and set/get routines will take between 25Kb
and 35Kb of memory, depending on complexity and image use. Thus,
a complete Web-based management application can be implemented
in 50Kb of ROM and 10Kb of RAM.
^TOP OF PAGE
What are the TCP/IP
Interface Requirements
Allegro toolkits will work with any TCP/IP
package and have been ported to all the popular embedded TCP environments.
Interface files for many common run-time environments are included
on the distribution disks. In general, RomPager includes a simple
interface shell to the TCP services which allows the porter to
keep all the specific interface routines in a separately compiled
module. The engine passes a connection index to the interface
routines as an abstraction of the per connection data. The prototypes
of the commands the porter needs to implement for non-standard
services are shown below:
extern RpErrorCode
StcpInit(void);
extern RpErrorCode StcpDeInit(void);
extern RpErrorCode StcpOpenPassive(StcpConnection theConnection);
extern RpErrorCode StcpSetServerPortNumbers(int theServerPortCount,
StcpPort
*theServerPortArrayPtr);
extern RpErrorCode StcpConnectionStatus(StcpConnection theConnection,
StcpStatus
*theConnectStatus,
StcpIpAddress
*theRemoteAddressPtr,
StcpIpAddress
*theLocalAddressPtr,
StcpPort
*theLocalPortPtr);
extern RpErrorCode StcpOpenActive(StcpConnection theConnection,
StcpIpAddress
theRemoteAddress,
StcpPort
theRemotePort);
extern RpErrorCode StcpActiveConnectionStatus(StcpConnection theConnection,
StcpStatus
*theConnectStatus,
StcpIpAddress
*theLocalAddressPtr);
extern RpErrorCode StcpReceive(StcpConnection theConnection);
extern RpErrorCode StcpReceiveStatus(StcpConnection theConnection,
StcpStatus
*theReceiveStatus,
char
**theReceivePtrPtr,
StcpLength
*theReceiveLengthPtr);
extern RpErrorCode StcpSend(StcpConnection theConnection,
char
*theSendPtr,
StcpLength
theSendLength);
extern RpErrorCode StcpSendStatus(StcpConnection theConnection,
StcpStatus
*theSendStatus);
extern RpErrorCode StcpCloseConnection(StcpConnection theConnection);
extern RpErrorCode StcpCloseStatus(StcpConnection theConnection,
StcpStatus
*theCloseStatus);
extern RpErrorCode StcpAbortConnection(StcpConnection theConnection);
^TOP OF PAGE
Are
there HTML Formatting Requirements?
Any HTML page or
other Web object (graphics, applets, sound) that can be served
by a disk-based server can be served by the RomPager engine. The
objects to be served are converted to a RomPager internal format.
The HTML internal format consists of a mixture of static text
strings and dynamic form element structures. The RomPager toolkit
includes the PageBuilder conversion application to prepare the
internal page formats.
^TOP OF PAGE
Forms Processing Requirements
The same dynamic
form element structures used to prepare the HTML pages are used
by the internal forms processing. These structures contain pointers
to the set and get routines for processing the variables. Typically,
devices with SNMP management routines can link to the SNMP set/get
routines from the HTML form element structures.
^TOP
OF PAGE
When can I have it?
RomPager and many other Allegro toolkit technologies
are shipping now inside the products of a number of vendors. They
are available for your devices today. You can port and integrate
the toolkits yourself, or we can help you.
^TOP OF PAGE
Is
a Demo Available?
A self-contained demonstration of the RomPager
embedded Web server is available for Windows or Macintosh platforms
here.
^TOP OF PAGE
Need More Info?
Use our inquiries form
to ask further questions or to subscribe to our newsletter.
^TOP OF PAGE |
