Networking technologies is a principal focus and a strong point for our company. We are proficient in designing, developing, and deploying network-based systems incorporating LAN, WAN, and wireless technologies using commercial and Linux-based equipment. We have an in-depth knowledge of networking protocols, networking security, network modeling and simulation, custom network protocols, and network system design and deployment.

We are well-versed in networking protocols and secure communications, such as TCP/IP, HTTPS/S, FTPS/FTP, PPPoE, PTP, TLS/SSL, Telnet, ICMP, Tunnels, PPP, ARP, DHCP, NTP, and RIP. We have created entire OSI protocol communications stacks for embedded communications devices. We design custom application which communicate over TCP/IP and UDP protocols. We use raw socket programming for Ethernet Layer 2 network device software which implements transparent smart bridging, and for implementing store and forward packet handling with tunneling/IP in IP encapsulation.

When developing communications equipment and networking protocols we leverage modeling and simulation tools to allow for evaluating network based solutions under test conditions that would be difficult or impossible to created in test labs. We predominately use the OPNET simulation tool for network modeling. OPNET is a tool to simulate the behavior and performance of wireless and wired networks.

We utilize a “common coded” principle between simulation and platform deployment code, such that essential algorithms and messaging are initially developed and tested in the OPNET framework, and then the same algorithm code written in C++ is deployed to a hardware platform. We developed this technique before it was in use in the communications industry. The technique developed ensures a high fidelity between the simulation and real time platforms resulting in a significant reduction in problems after deployment of user equipment.

For more information on common coded architecture, refer to the whitepaper Common Code Simulation Architecture for Embedded Wireless Routing Protocols. For more information on our OPNET capabilities, refer to our OPNET Wireless Networking Suite.

Development and analysis in Riverbed OPNET Modeler has a steep learning curve, and it takes many years of practical experience in this environment to become an expert.  If you need to perform network modeling using OPNET Modeler, we can help out on that effort substantially as we have significant experience and expertise in this area.

To complement our expertise in OPNET discrete event based network modeling and simulation, we have experience with developing network emulation environments using the open source Extendable Mobile Ad-hoc Network Emulator (EMANE) network emulation framework. EMANE is a next-generation framework for real-time modeling of mobile network systems. The EMANE components focus on real-time modeling of link and physical layer connectivity so that network protocol and application software can be experimentally subjected to the same conditions that are expected to occur in real-world mobile, wireless network systems. The EMANE architecture provides for Network Emulation Modules (NEMs) that can be associated with computer system (real or virtualized) network stacks as interfaces. The EMANE framework further provides an event-driven control bus and logging facilities.

EMANE is an open source distributed emulation framework which provides wireless network experimenters with a highly flexible modular environment for use during the design, development and testing of simple and complex network architectures. EMANE uses a physical layer model to account for signal propagation, antenna profile effects and interference sources in order to provide a realistic environment for wireless experimentation. Individual radio model plugins are used to emulate the lowest layers of a waveform and can be combined with existing Software Defined Radio (SDR) implementations to enable shared code emulation.

Refer to the news post EMANE Real-Time Spectrum and Waterfall Viewer  for information on a real-time spectrum and waterfall display application we created to support design, development, testing, and demonstrations using the EMANE real-time network emulation framework.

Refer to the news post Network Emulation vs. Simulation for information contrasting OPNET and EMANE network development and analysis tools.

While EMANE is a generalized and highly configurable real-time network emulation framework, there are occasions where a generalized solution does not provide the required functionality, timing, and network messaging protocols necessary for network emulation. For these conditions, we have developed specialized real-time network emulators as described in Radio Emulators.

Our engineers are experts in the C, C++, C#, Python, Java, JavaScript, Visual Basic, VBA, Delphi, Pascal, and assembly (Intel, ARM, MIPS, and others) programming languages using object oriented design principles. We have experience in Linux bash scripting and National Instrument's LabView in the creation of HMIs for the manufacturing industry. We have created a large amount of solutions using the Qt cross platform framework in C++ including both headless applications providing a web interface for status and control, to fat client desktop and embedded applications with interactive GUIs.

We have developed an Android like touch screen interface in Qt for an embedded instrument with a modern cell phone fluid interfaces including touch screen control, swipe navigation, rich multi-line list controls, embedded keyboards, pop up context menus, icon based selection screens, animated scene transitions, over scroll animations, international language support, kinetic scrolling, and real time 2D line graphing with autoranging, autoscaling, and data decimation.

For thin client web based developments on desktop and embedded web servers, we have experience with HTML5, CSS3, JavaScript, jQuery, Ajax, Bootstrap, RESTful Web Services, ASP.NET, C#.NET, VB.NET, JSON, and the Django/Python web framework. We are familiar with setup, configuration, and operation of the most common web servers including IIS, Apache, lighttpd, and NGINX. We are familiar with modern day content management systems (CMS) and various web database backing technologies.

For some of our embedded web developments on low resource platforms, we utilize a custom Qt/C++ based HTTPS/HTTP web server that is integrated and combined with the application server itself in a one tier architecture. One-tier, or single tier web application architectures involves putting all of the required components for a software application or technology within a single application or process. The single tier embedded web server allows us to not use a database or inter-process communication (IPC) as an intermediary between web server and application server, integrating logging and setting of web related thread priorities, simplifying deployment and interface complexity, decreasing latency and enhancing response timing. The web framework architecture is inspired by Java scriplets, with the application code handlers written in C++ separate from the web HTML content, separating web HTML design from web application programming. This framework is modular and easy to extend for additional functionality. Our single tier integrated web server also provides a full featured REST API interface for upstream control and status, which can be used as a replacement for or in addition to SNMP upstream control and status  For more information on embedded systems or resource constrained single tier web server architectures and content implementations, refer to our low latency scheduler product.

We have also created a multi-tier based web solutions separating the web server tier from the platform application tier. This type of solution architecture uses a database and the intermediary between the web server and the application. The web server tier typically consists of a COTS web server combined with custom web content. We have created a reliable multi-tier web solution for an embedded platform using the lighttpd web server along with the popular Django framework for web content. The Django framework follows the Model-View-Controller (MVC) design pattern. The web server interfaces with the custom Django based content using the FastCGI interface protocol. A SQLite database is used as the backend data store, and for communications between the platform application tier and the web interface tier. For more information on our web based embedded real time control and status interface developments, refer to our Web Monitor & Control Product.

We have developed software for various generalized embedded Linux distributions (e.g. Arch Linux, Embedded Debian, UbuntuMATE, Raspian, OpenWRT, OpenEmbedded, Linaro, Analog Devices custom Linux, MontaVista Linux). We have built and customized deployed Linux kernels from kernel source code for performance, removing unused capabilities and adding necessary features and drivers.

For the embedded Linux environment, we have experience with platform tuning to achieve reliable near real time behavior from either a generalized Linux distribution, or a stripped down embedded Linux distribution. This is cost effective alternative to the use of a real time operating system (RTOS) based development. Platform tuning includes support for CPU shielding to take advantage of a multi-core processors and using real time priorities for application threads. CPU shielding (CPU thread pinning and CPU core isolation) is a practice where on a multiprocessor system or on a CPU with multiple cores, real-time tasks can run on one CPU or core while non-real-time tasks run on another.

Our experience using embedded Linux most often takes advantage of parallel processing on multiple core processors using both single and multiple processors. For more information on achieving near real time behavior on an embedded or desktop Linux operating system platform, refer to our low latency scheduler product.

If you are converting an RTOS based implementation to embedded Linux, we can help in that effort.

Our engineers have developed commercial grade custom client/server database centric applications in C#, C++, and C that utilize both enterprise class databases such as Oracle, SQL Server, and MySQL, desktop databases such as Microsoft Access and VBA, to embedded system resource constrained databases such as SQLite. We have designed and developed SQL relational database management systems (RDBMS) and database schema to proper normalized form, and have experience with database views, stored procedures, and triggers. We have created database-based solutions by converting legacy Excel formatted data repositories into one and two tier database designs. For more information on automated database driven source code generation, refer to our application source code generation product.

If you need to create a client server database based application or need to create and/or normalize a database schema -- we can help.

Simple Network Management Protocol (SNMP) is an Internet-standard protocol for collecting and organizing information about managed devices on IP networks and for modifying that information to change device behavior. It is used for collecting information from, and configuring, network devices, such as servers, printers, hubs, switches, and routers on an Internet Protocol (IP) network.

Many of the applications that we have developed for embedded systems are networked communications devices, and as such, provide an SNMP agent interface to allow for network management from an upstream SNMP manager. We have implemented SNMP agents on several projects providing support for SNMP scalars, SNMP read-only and read-write tables, and notifications from the agent to the SNMP manager via SNMP traps. Security for the SNMP communications utilizes the security built into the SNMP v3 protocol.

SNMP agents expose management data on the managed systems as variables. The variables accessible via SNMP are organized in hierarchies. SNMP uses an extensible design which allows applications to define their own hierarchies and metadata. These hierarchies, and other metadata (such as type and description of the variable), are described by management information bases (MIBs).

We have developed custom MIBs for the SNMP agent interfaces provided by our embedded systems developments, as well as preserving legacy and augment MIB content for existing products to provide backwards SNMP compatibility.

The complement to an SNMP agent is an SNMP Manager.  An SNMP manager or SNMP management system is a separate entity that is responsible to communicate with the SNMP agent implemented network devices.  We have developed a custom control application acting as an SNMP manager which implements a dynamic TDMA scheduler which utilizes SNMP management to query Cisco routers for unicast and multicast multihop link connections and link metrics.

If you need to add SNMP agent or SNMP management capabilities to your existing or future developed networked device, or require the development of a custom MIB, we have experience and can reduce development and deployment risk.

To provide command and control of a networked device, RESTful web services or RESTful APIs are becoming a popular technology as an alternative to SNMP Management. RESTful APIs are application programming interfaces that adhere to style of the REST architectural pattern.

RESTful APIs define a set of functions which developers can perform to request and receive responses via the HTTP protocol such as GET and POST. Because RESTful API’s use HTTP, they can be used by practically any programming language and are easy to test.

Many of the products we have developed provide custom RESTful APIs for command and control as an alternative or to supplement an SNMP command interface.  For example. for programs based our our RoboComRT framework, the REST API interface implemented uses the HTTP protocol secured using Basic Authentication over TLS/SSL for upstream command, status, and control.  Both REST API GET and PUT operations are supported with read-only and read-write content based on user assigned role.  User roles for REST API access is provided by two broad categories: users that have read-only access to REST API content (GET operation) and those with read-write access (GET and PUT operations).

While SNMP and RESTful APIs provide similar functionality, one advantage that RESTful APIS (or RESTful services) has over SNMP based status and control, is anyone can write a client script that uses HTTP(S) to send form data to a web server and process JSON responses.  Most most real-life implementations run over HTTP(S) and reuse existing web services authentication/authorization mechanisms. SNMP has one advantage over RESTful APIs by way of SNMP notifications (a generic term covering both SNMP Traps and Informs), which allows the SNMP agent to inform the SNMP manager of an asynchronous event without responding to a manager request.  RESTful APIs follow the HTTP request and response model.

For most of the embedded and desktop developments we have created, and application will typically need initial boot up configuration and then perhaps runtime configuration. We favor the use of Extensible Markup Language (XML) documents for configuration as it provides validation ranges and settings for parameters.

For XML configuration, we initially develop an XSD (XML Schema Definition) file that is a World Wide Web Consortium (W3C) recommendation that specifies how to formally describe the elements in an Extensible Markup Language (XML) document. We generate XML W3C validation routines to validate an XML instance document is properly formatted.

We can help if you need to create an XSD  schema document, or create/add XML document support with W3C validation schema validation to your low resource embedded or desktop application.

For application deployment to various operating systems, we have developed formal package management installation applications for Windows platforms (Visual Studio based setup applications and InstallShield), desktop and embedded and desktop 32-bit and 64-bit Linux in the form of RPMs or DEBs. The installation applications provide distribution of program binaries, web content, startup and operating configuration, and automatically starts and stops requisite services or daemons.

If you need to create a formalized deployment package for various operating systems, we have experience is this area and can help.

We pride ourselves in developing quality software solutions that operate reliably 24x7 on various operating system and hardware platforms. Nearly all of the applications we develop are multi-threaded and vary in complexity from moderate to complex. Most all of our custom solutions decompose a problem space into a multi-threaded application running under either an embedded RTOS distribution or a desktop operating system, with tasks of different relative priorities.

To avoid issues with resource locking in multi-threaded programming (e.g. priority inversions, deadlocks, livelocks, convoying, etc.), we utilize lock free programming where ever possible as supported by the CPU to avoid common multi-threaded programming issues. By avoiding these multi-threaded issues, we can develop a reliable software product free of any unexpected and perhaps difficult to reproduce errant behaviors.

Refer to the lock-free programming post for more details on multi-threaded application locking issues and solutions.

We believe strongly in software configuration management and diligently use tools such as GIT, Subversion, and/or Mercurial.

We track software bugs using open source bug tracking databases such as Bugzilla and Mantas. We collaborate with customers for software defect management using products such as cloud based MantisHub online bug tracker as described in the news post Software Defect Management.

We utilize Google Sheets and Google Docs to collaborate with customers for program/project management, requirements tracking, and communication.

We perform testing at the Unit, Integration, Functional, System, Stress, Performance, Usability, and Acceptance Test levels.

In addition to program management documentation, we have created and maintained the full suite of software development documentation which includes:

• Software Requirements Document.
• Software Development Plan.
• Software Design Document.
• Software Test Plan.
• Version Description Document.
• User’s Manual.
• Software Build Document.
• System Architecture documentation.
• API level documentation (e.g. SNMP or REST API Interfaces).
• Doxygen documentation from annotated source code.

Our engineers have experience planning and leading the development of software and firmware based projects. This discipline involves the full software development life cycle (SDLC) from proposal, to implementation, project monitoring and control, to final testing and deployment. Software methodologies that we support include the traditional Waterfall and Agile methods.

Our project/program manager is responsible for:

• Planning and designing the program and proactively monitoring its progress, resolving issues, and initiating appropriate corrective action.
• Facilitating the appointment of individuals to project teams.
• Infrastructure planning, interfaces, technical, and specialist standards.
• Managing the program's budget.
• Ensuring the delivery of products or services from projects is to the appropriate level of quality, on time and within budget in accordance with the program plan.
• Ensuring there is allocation of common resources and skills within the program's individual projects.
• Managing third party contributions to the program.
• Managing communications with all stakeholders.
• Managing both the dependencies and the interfaces between projects.
• Managing risks to the program's successful outcome.
• Ensuring effective quality assurance.
• Initiating extra activities and other management interventions wherever gaps in the program are identified or issues arise.
• Reporting the progress of the program at regular intervals.

We created this web site using the popular open source WordPress web content management system (CMS). Who doesn't love WordPress? It is a giant leap in technology from our days of developing web content with Adobe Dreamweaver. WordPress is just one of many open source tools that we use in our company and in our products and we are strong supporters of the open source community.

Our open source technology practice revolves around leveraging our open source expertise for the benefit of our customers in their product development initiatives. Our team has extensive experience working on Linux, Apache, C, C++, Qt, MySQL, Django, Python, Bootstrap, jQuery, Javascript, HTML, and Ajax and other development languages and technologies. The strong developer communities and open licensing model, which reduces the Total Cost of Ownership (TCO) of products, are some of the advantages gained by using open-source for development initiatives.

We strive to reap the benefits of open source technologies to our customers by:

• Reusing and customizing various open source frameworks and deriving exceptional cost advantages as a result.
• Realizing stable and high quality products faster.
• Extending open source to add in custom functionality. You can modify and adapt open source software for your own business requirements, something that is not possible with proprietary systems.
• It is generally cost free, reducing TCO for end-users. These days for virtually every paid for proprietary software system you will find an open source version.
• It’s continually evolving in real time as developers add to it and modify it, which means it can be better quality and more secure and less prone to bugs than proprietary systems, because it has so many users poring over it and weeding out problems.

Our experience in developing and customizing products using open source technology help us in providing our customers the right solutions for their engineering requirements.