DEVELOPMENT BOARDS / MODELS / SOFTWARE
Build, test and refine your idea.
Get a working demonstrator, repeatable build instructions and test findings that guide the next decision. We combine development boards, MATLAB / Simulink models, firmware and custom software to demonstrate and evaluate the agreed product functions.
WHAT WE DEVELOP
Engage us for a complete demonstrator or a specific task, from getting a board running to developing its control software and operator interface.
Start with an evaluation board or ready-made module selected for your requirements. Connect sensors, actuators and communication interfaces to build a functional prototype.
Develop control algorithms, signal processing and operating sequences in MATLAB, Simulink and Stateflow. Simulate expected behaviour before testing it on hardware.
Build firmware, integrate device drivers and configure the target toolchain. Program the board, debug the application and check its behaviour on the bench.
Create the software needed to operate, configure and evaluate your prototype. Keep the interface clear so the team can understand the system and investigate issues.
MATLAB / SIMULINK HARDWARE OPTIONS
These families offer integration through MathWorks support packages, dedicated blocksets or manufacturer tools. We select the platform around the interfaces, performance and software needs of your prototype.
| Manufacturer | Example families | Integration route |
|---|---|---|
| STMicroelectronics | STM32F4, STM32G4 and STM32H7 | Embedded Coder support package or STM32 Microcontroller Blockset, depending on the MATLAB release. |
| Texas Instruments | C2000, including F280049C and F28379D | C2000 Microcontroller Blockset for supported devices and peripherals. |
| NXP | S32K1 and S32K3 | NXP Model-Based Design Toolbox for the selected device family. |
| Infineon | AURIX TC3x and TC4x | Family-specific Embedded Coder support packages and the required compiler toolchain. |
| Microchip | dsPIC33, PIC32 and selected SAM devices | MPLAB Device Blocks for Simulink, with MPLAB X and the appropriate XC compiler. |
Exact device, peripheral and software-version compatibility is checked for each project. Code generation, flashing and debugging are configured for the selected board, support packages and toolchain. Custom driver integration is included where required by the agreed scope.
AI INTEGRATION
Add machine learning where it helps the prototype solve a defined problem. Applications include detecting unusual sensor behaviour, estimating values that are difficult to measure, and recognising patterns in images, sound or time-series data.
We connect the AI model to the prototype’s sensors, firmware and application software. The processing location is chosen to suit the workload and the project’s timing, power and connectivity requirements.
Agree on accuracy, response time and fallback behaviour before deployment. Validate the model with representative data and document its operating limits.
Review the available measurements, define labels and features, and keep independent data for evaluating the model.
Use MATLAB machine learning and deep learning tools to compare approaches, measure prediction quality and investigate errors.
Deploy inference on suitable embedded hardware, an edge computer or a PC application. Measure accuracy, memory use and response time in the intended operating conditions.
THE V-MODEL
We agree on what the prototype needs to do, turn those requirements into a design, and define the checks that will demonstrate the result. The level of detail is matched to the scope and risks of the project.
Each design stage has a corresponding check.
Purpose, users and operating context. Define what the prototype must show.
Demonstrate the agreed use cases. Confirm suitability for the intended use.
Functions, performance and constraints. Set measurable limits and test conditions.
Evaluate the complete prototype. Check the agreed system requirements.
Allocate hardware and software functions. Define connections and data exchange.
Connect boards, firmware and PC software. Check interfaces and combined behaviour.
Design algorithms, circuits and drivers. Define component behaviour and limits.
Check individual functions and modules. Record results against their specifications.
Implement the models, code and hardware, then program the board. Begin with unit checks and progress through integration, system verification and acceptance.
VerificationCheck the prototype against the agreed technical requirements.
ValidationConfirm that it serves the intended users and use cases.
Plan the checks when defining the requirements. Review, simulate and test throughout development, then update the design and repeat the affected checks as the prototype evolves.
Capture the purpose, functions, interfaces and constraints. Resolve open questions, give each requirement a reference and agree on measurable acceptance criteria.
Link requirements to the relevant models, hardware, software and test cases. Requirements Toolbox and Simulink Test can support this traceability within the agreed workflow.
Record the tested configuration, results and open issues. When a requirement changes, review the affected design and tests, repeat the relevant checks and update the handover.
MIL / SIL / PIL / HIL
Choose the testing stages around your prototype, its risks and the available hardware. Each stage answers a different question as the design moves from simulation to an embedded implementation.
MIL
Simulate the controller and the physical system together in MATLAB / Simulink. Check algorithms, operating modes and expected responses before deploying code to hardware.
What this checksCheck the control logic against the requirements.
SIL
Run generated C or C++ code on the development computer. Compare its results with the model using the same test inputs and agreed tolerances.
What this checksCheck that the generated code matches the model.
PIL
Compile code for the selected microcontroller and run it on that processor. Compare outputs with the model and assess execution time where supported.
What this checksCheck the implementation on the intended processor.
HIL
Connect the real controller to a real-time simulation of the physical system. Check I/O, communications, timing and responses to simulated faults.
What this checksCheck hardware and software working together.
Reuse test scenarios where practical and record the model version, code build, target configuration and results. Simulink Test and Requirements Toolbox can connect the tests to the agreed requirements; Embedded Coder supports suitable SIL and PIL workflows.
SIL and PIL exchange simulation data without requiring real-time execution. HIL needs a suitable real-time plant model, simulator hardware and I/O. A Simulink Real-Time setup and its hardware requirements are agreed for each project.
AI-generated illustrations of typical test setups. Equipment and software are selected for each project.
BUILD / MEASURE / REFINE
A useful prototype connects the model, the code and the physical hardware. We make the build repeatable and the results easy to review.
FIRMWARE & CUSTOM SOFTWARE
Compile the firmware, program the target and debug its start-up, drivers and communications. Build custom PC tools to configure the prototype, display live values, log data and support firmware updates.
What you receiveAgreed source files, a repeatable build and flashing procedure, and clear operating instructions.
BENCH TESTING & MEASUREMENT
Check sensor readings, control response, timing and fault handling. Compare measurements with the model and acceptance criteria, investigate differences, refine the design and repeat the relevant tests.
What you receiveRecorded test results, the tested configuration, known limitations and recommendations for further development.
AI-generated illustrations of typical engineering activities. Hardware, tools and test arrangements are selected for each project.
THE TECHNICAL HANDOVER
The quotation defines the hardware, software and documentation included in the delivery.
When the prototype has answered the initial questions, continue with hardware design or mechanical design for the next development stage.
START YOUR PROTOTYPE
Tell us the intended functions, interfaces, preferred board or existing hardware, and target date. Mention any models, code or measurements already available.
Discuss your prototypeScope, deliverables and pricing are confirmed in a quotation.