Vtrek is a reusable and portable embedded application support package (an embedded framework) with code, utilities and tools…
Vtrek includes components that manage all aspects of a typical embedded system such as…
Vtrek includes the long list of utilities shown…
The tools in Vtrek reduce embedded development effort and increase developers strengths thus optimizing development…
Vtrek will save you money, help you get projects done faster, and improve software quality…
Vtrek has been in existence for more than 30 years in various incarnations and has been used in many embedded products…
In a typical embedded software development project, embedded software engineers need to…
Vtrek is a reusable and portable embedded application support package (an embedded framework) with code, utilities and tools that make embedded software developers stronger and faster which saves time and money and increases quality of embedded software development projects.
Vtrek sits on top of your BSP (Board Support Package enablement software supplied by the CPU vendor).
Vtrek exposes an embedded API that your developers use to implement the user-facing features of your product.
This makes Vtrek an embedded Application Support Package (ASP) that interconnects your user-facing features to the infrastructure thus making those features portable to all of your products that use Vtrek!
Allows your embedded developers to focus ONLY on your product’s features (instead of the infrastructure).
You get more done in less time with less staff yet your software quality goes up!
We’ll say it again but differently. WHAT IS Vtrek?
- Automatically implements core embedded software functionality such as:
- A/D & D/A sampling.
- GPIO input/output.
- Communications (I2C, SPI, USB CDC, ethernet, etc).
- Mode management.
- File management.
- RTOS abstraction.
- Data management.
- Is an embedded Application Support Package that separates the implementation of user-facing features from the core embedded software functionality, thus:
- User-facing features become portable to all embedded projects using Vtrek.
- Device drivers/adapters become portable to all embedded projects using Vtrek.
- Enables/encourages reuse so much that the team members vigorously implement, defend and enforce full reusability across all products.
- Includes 3 revolutionary Windows tools:
- ProDev – Automates creation, management, extension and maintenance of embedded software projects and code.
- DDC – Unmasks embedded system data with real-time drag-and-drop charting and graphing making debugging and tuning absurdly easy.
- VTDD – A full-featured, simple, test-driven development environment that triples as a unit testing facility AND a code development environment.
We’ll say it again but differently. WHAT IS Vtrek?
Vtrek is a C/C++ event driven software framework for embedded systems:
Vtrek is reusable without copy/modify (true reuse across all your embedded products).
Vtrek is portable across all ARM CPUs from any vendor (one software design for all your embedded software systems).
Vtrek is comprised of thin, efficient service components that encapsulate and automate the entire infrastructure.
Vtrek is completely unit tested (shown to work as advertised yielding high product quality).
Vtrek is targeted at small to medium embedded systems (less than 2 MB RAM/flash).
Vtrek is a collection of commonly required Software components (RTI, DC, Communications, Analog, GPIO, Mode Service, Fault Tracking, File).
Vtrek is a collection of commonly needed Utilities (Code automation, Containers, Controls, Switches/buttons, etc).
Vtrek is an integrated collection of innovative Tools (ProDev, DDC, VTDD).
Vtrek is configurable. The software components never change. You configure (tailor) each component by modifying the configuration file. This means that these software components do not need to be tested on any project they’re used on (we’ve already done the testing). This means Vtrek does the heavy lifting of embedded software projects.
Vtrek is a REVOLUTIONARY DESIGN PHILOSOPHY. All your tasks run to completion every time and return to the caller (RTI). Once your staff start developing products using Vtrek, they will automatically start using the same philosophy which eliminates complexity and simplifies design and code.
Vtrek is NOT AN RTOS!
Vtrek is NOT an IDE. You use whatever IDE you currently use. Vtrek integrates into your existing environment.
Vtrek is NOT a library manager.
Vtrek includes components that manage all aspects of a typical embedded system such as…
- Real Time Interface (RTI) – sits on top of any RTOS (FreeRTOS is included in VTrek). Implementing an RMA mechanism to schedule tasks, RTI eliminates deadlocks and race conditions and the need for developers to use semaphores, mutexes, task delays, message queues, mailboxes and all other RTOS-specific features that often cause system unpredictability, non-determinism and bugs. This significantly simplifies software! And RTI allows both event driven and time driven processing.
- Incredibly simple API
- All tasks in your project are standardized.
- No more juggling task priorities, semaphores or task delays to solve real time bugs.
- Event processing is separate from periodic processing in every task.
- Automatic task creation.
- Abstracts any RTOS
- Data Center (DC) – a design pattern that stores/shares data.
- Central shared repository for data.
- Automatic write protection – restricts writing of data to the owner.
- Automatic write/change notification – notifies listeners upon data write or change, eliminates polling of data.
- Override capable – allows write override for testing and troubleshooting via the tools.
- Standard data types (uint/sint8/16/32/bool/float) and user-defined data types (structures, arrays, buffers, messages, queues, etc.).
- Supports automatic redundant independent copies for safety-critical data (ISO 26262).
- Analog I/O Service – a design pattern that automates analog/digital conversions for all analog inputs/outputs on the CPU.
- Independent sampling rate for each input pin
- IIR Filter for each pin
- Digital I/O Service – a design pattern that standardizes the GPIO pin input/output interface.
- Independent sampling rate for each pin
- Debounce / filtering
- Mode Service (MS) – Centralized/extensible operating mode manager.
- Manages operating mode and distributes changes to all components listening.
- Supports (extensible) modes: power down, bootloader, reboot, enter/exit (sleep, manufacturing, development test, diagnostics, POST).
- Communications service (COMM_SVC) – a design pattern that provides a standardized interface/implementation for communicating data via I2C, SPI, Serial, USB Device, Ethernet, CAN, LIN, NFC (and any other medium).
- Multiple devices per port for protocols that support it.
- Add/remove/configure devices via a simple text file.
- Automatic startup.
- Very thin standardized communications API.
- File Storage Service
- Mass storage facility, works with on-chip memory or off-chip memory.
- Fault Tracking Service (FTS)
- Store faults/diagnostic codes & statistics in NVM
- Interfaces with Vtrek tools for off board viewing & analysis.
- All components are tailored by modifying a text-based configuration file. The code does not change.
- Built in error trapping
Vtrek also includes: Standard doxygen documentation and user manuals.
Vtrek includes training (web and/or on site),
Vtrek also includes support with every seat.
Vtrek includes the long list of utilities shown below. Got a GPIO button input that needs to be de-bounced and toggled? Invoke the macro and it’s done. What about an incoming or outgoing data stream and need a queue? Use FIFO buffer and the tedious, repetitive work is done. What if you need a linked list for storing data? The linked list module implements all the standard linked list features (and it is statically allocated to so no dynamic memory allocate/deallocate/reallocate problems arise causing memory leaks or a fragmented heap). Take a serious look at these utilities and consider how having this swiss army knife at your fingertips could make it a whole new ballgame.
|Code Automation||Controls||Signal processing|
|Callbacks||Flasher||Data threshold monitor|
|Listener list||PID control||Debounce filter|
|Subscriptions||Sequence state machine||Diagnostics monitor|
|Communication||State machine||Edge counter|
|Bit stream||Trim control||Event density|
|CAN||Data center||IIR low pass filter|
|SLIP||Gate constructor||Linear interpolation|
|Containers||Data Processing||Linear signal scaling|
|Bit array||Clamp||Nonlinear scaling|
|Bit field||CRC16||Simple integrator|
|Byte array||Packetizer||Window integrator|
|FIFO buffer||Serializer||Latched button|
|Fixed block||Slew generator||Multi position switch|
|Holding buffer||Rotation||Push button|
|Linked list||Measured RPM||Push to toggle button|
|Revolving buffer||Motor Control||Timers (Timer/Counter)|
|Shared buffer||Quadrature decoder||Simple Counters|
The tools in Vtrek reduce embedded development effort and increase developers strengths thus optimizing development and getting your projects done faster while saving money and improving quality.
Like all software developers, we’ve been there. We’ve done that. We got tired of repetitive creating and typing.
We took matters into our own hands and automated.
Vtrek ProDev automates creation, management, extension and maintenance of embedded software projects and code.
With Vtrek ProDev, developers utilize this powerful automation to their advantage! Saves time. Saves money. Increases quality.
ProDev automates creation, management, extension and maintenance of embedded software projects and code.
Like all embedded developers, we found that development tools available just didn’t work well when debugging elusive, complex, hard-to-see embedded issues.
We all know that the data is where the magic (or pain) lives. We imagined being able to visualize what the embedded system is doing in real time.
Vtrek DDC provides visibility into your embedded software product for debugging, tuning (think mechatronics/control systems) and optimization.
Log your debug output to a file easily and automatically. See real time tasking metrics. Grab automatic Data Center variables and graph them with drag-and-drop simplicity.
Record embedded Data Center variables. Playback those recorded log files to inject the recorded anomalies and catch them in the act!
DDC unmasks embedded system data with real-time drag-and-drop charting and graphing making debugging and tuning absurdly easy.
Again, like all embedded developers, we found unit testing to be far too painful and tedious. The pain translates into significant time and money costs. Thus unit testing gets the bad rap and often it is not given the effort it deserves so the payoff never arrives.
Vtrek VTDD (Vtrek Test Driven Development) provides a full-featured, simple, test-driven development environment that triples as a unit testing facility AND a code development environment.
So, we ported Vtrek into VTDD. This allows developers to build embedded features outside the embedded environment (far more powerful debugging, far faster development process, far stronger tools).
With VTDD, your developers can develop embedded features without ever touching hardware. That’s because VTDD allows developers to reach around the back of Vtrek and stimulate the hardware in whatever way they want by feeding static data into Vtrek. This is especially useful when you have remote developers who don’t have hardware.
Vtrek will save you money, help you get projects done faster, and improve software quality because of these things:
Vtrek permits the same runtime environment on all your products (making your embedded software staff more efficient and knowledgeable across your entire product line).
Your business logic (product features) become portable and reusable across your product line (implement once, use many).
Device drivers/adapters are portable across your product line (reducing embedded software development effort and reusing code without modification).
Embodies a component architecture (embedded software is simpler and higher quality).
Strong tools help embedded software developers build systems and solve problems quickly (making your embedded software staff more efficient and productive).
Mature collection of utilities (reducing custom code and making developers more efficient).
Creates a very strong and easy to use test-driven development environment (code development starts with testing and is much quicker to develop and test than an embedded environment).
Runtime environment is unit tested (high quality, works as advertised).
All of this means:
1 Your embedded software schedule and budget shrink
2 Your software quality improves.
3. Your software developers can complete more projects in less time.
We have found that using Vtrek causes your developers to think about reuse and vigorously protect known reusable software from modifications that will affect it’s reusability.
We have found that using Vtrek “takes the variables out” of embedded software development and makes it into a simple process of production. There is an inherent “efficiency gain” that is realized by the team.
Vtrek has been in existence for more than 30 years in various incarnations and has been used in many embedded products over those years.
By Mark Bryant, Omni Embedded Managing Partner, July 24, 2020
In 1981 I started my career working in a VT&T department for a large automotive electronics supplier. At that time OOP (Object-Oriented Programming) concepts were in their infancy and not widely discussed. We used HP Basic and HP test systems and every test system was uniquely designed for each product model. I soon realized that test software development in that environment felt much like production line work and started thinking about ways to capture design patterns and eliminate the drudgery. The first step was to commonize the test systems to the extent possible. Once that was completed, many of the test modules could be set up to read data from a data table and conduct the testing in a loop. To test a discrete input pin, for example, the same steps are repeated through a different set of channels or paths. It was easy to separate the variables from the constants and commit the variables to a table.
After that work I switched to embedded product development. That work was still in assembly in those days and the concept of configurable code could not really be supported in that environment. As CPU power grew along came the use of C code in embedded, and my quest for configurable re-use of code modules came back to the fore. I created a method that I called CCLASS that made C work somewhat like an OOP language (many others created the same methodology) and began to build a source library over the course of many product development cycles. There was not enough commonality among CPU vendors, so I had to select a particular vendor and model silo and then port the library to that silo. I became a shareholder in a coin-operated product development business and we used this library extensively. It allowed us to out-bid competitors and land a number of contracts due to the time savings that a re-usable code library provides.
C++ started being used for embedded, and in order to make full use of this concept you need an OOD (Object-Oriented Design) language. Then ARM core processors started being used widely by numerous CPU vendors. With ARM, the build and debug tools are free, Eclipse is free as an IDE and CPU suppliers started providing a BSP solution for their CPUs. All of that combined created enough commonality at the hardware and tools levels to make it cost effective to port this product to numerous vendors and models.
Along with that, we started doing business with a large medical equipment manufacturer who purchased a license for Vtrek. They have had great success with it. It has trimmed their development costs and time to market, their embedded software development team members really appreciate it and now other divisions in this company are starting to adapt it to their product lines. That was enough to convince myself and other trusted colleagues to bring this product to market.
In a typical embedded software development project, embedded software engineers need to interface with multiple peripherals and communicate with multiple integrated circuits to form an infrastructure and mixed in is the many features of the electronic product (the product logic). This often leads to a spread-out, puzzling array of disjointed pieces of software thrown into a bag in the hopes that it ends up making your product work the right way. When you near shipment and the system is being tested, problems often arise that causes the embedded software team to scratch their heads and try to figure out what is wrong and then how to fix it. Often, they juggle task priorities, semaphores, and other complex concepts to try to figure out what is wrong. Often, this trial and error method leaves everyone feeling less than comfortable but the product ships anyway. Everyone hopes no problems occur in the field.