Bench Talk

What Agentic AI Means for Work and SaaS

Tue, 12 May 2026 01:20:00 GMT

(Source: GamePixel/stock.adobe.com;)

When the latest generation of agentic artificial intelligence (AI) desktop tools launched, it put much of the Software-as-a-Service (SaaS) and enterprise world into a tailspin. The tech markets took a hit too, with the software sector of the S&P 500 down roughly 20 percent year-to-date.^[1] On the surface, it looked like this was the AI upgrade that would finally spell disaster for the job market. These new tools could interact with a wide range of other software and plugins, emulating the complex workflows that define white-collar work in sales, legal, accounting, and marketing. But the reality is more nuanced than the headlines suggest. The underlying model intelligence existed before these most recent releases, primarily used by those in more technical roles, so what actually changed is who had access to it. That accessibility shift has real implications for SaaS companies and workers alike, but both have more agency in the situation than the initial reaction implied.

What Actually Changed?

The first models capable of reasoning started shipping in 2024 and 2025, which is the same timeframe that the term “agentic” emerged, along with workflows built around it. Those developments marked the shift from chatbots alone to systems that could answer more rigorously and slot into real workflows with meaningful utility. Software programmers, for example, started using coding assistants with the same level of agentic workflow automation and tool use long before these desktop apps showed up, and without anywhere near the same level of panic. These models could create and modify files, plan and execute multi-step updates, and interact with other coding tools and libraries to format and make requests to merge new code. In other words, these agentic AI models were smart enough to do meaningful work within the software developers’ day-to-day, but their arrival did not bring the same level of unrest.

So, what is markedly different this time round? Digging deeper, the inflection point appears to be accessibility. According to Microsoft, 75 percent of knowledge workers are already using AI tools, often without formal company deployment.^[2] What's new, though, is that non-developers now have access to the same kind of agentic capability that was previously confined to developers and technical users. Low-code and no-code agent platforms mean that business users, not just engineers, can build and deploy agents. This is a genuine democratization moment, and it's the accessibility rather than the raw capability that made the market react the way it did.

What Does This Mean for SaaS?

The demo videos and functionality assessments of these tools do make it look like certain software categories are at risk, because now the AI appears to be able to do what some common software does. That concern was directed at SaaS companies in particular, with those providing tools in domains like legal, sales, and project management seeing their valuations fall. Investors were chiefly concerned that agentic AI could build the same convenience-type software in-house or reduce the need for paid seats, as individual employee productivity could be dramatically enhanced by AI. But the overlooked piece is that part of the power of these agentic tools comes from their plugins to the very apps the market dropped. Customer relationship management (CRM) platforms, project management tools, and analytics suites are all the connective tissue that agents plug into. The fact that they're considered staples across various domains—enough to warrant out-of-the-box support from many agentic AI providers—means it's unlikely they'll disappear.

The companies that successfully navigate this shift will be the ones that become essential nodes in the agentic stack, not the ones that target small friction and inconveniences that are easier to automate away now.

Where Do Workers Fit In?

Workers worried about losing their jobs to AI would do well to think about this from a similar angle. According to PwC and Capgemini, while 79 percent of executives say AI agents are being adopted at their companies, only 27 percent of organizations trust fully autonomous AI agents, and 71 percent of users still prefer a human-in-the-loop setup for high-stakes decisions.^[3] This shows that despite the advances, people still trust other people more than algorithms when the stakes are high, and that's an opportunity to establish real value.

The practical move then is to use these tools to automate the generic, easily replaceable parts of day-to-day work, and then double down on areas where judgment and context are critical and where useful outcomes are genuinely harder to automate. The productivity upside of doing this well is significant. A study from the Harvard Business School and Boston Consulting Group found that consultants using AI completed tasks 25 percent faster and produced 40 percent higher quality results compared to those working without such tools.^[4] Those kinds of gains are available to anyone willing to learn the tools, and the advantage they bring makes the case for keeping a skilled human in the loop even stronger. Workers who position themselves as the people who know how to leverage AI effectively while still applying the expertise and critical thinking that these tools lack will be considerably harder to replace than those who ignore the shift entirely.

Conclusion

There is a meaningful shift in how AI tools are built and who they're built for, and that accessibility is what makes this moment different from previous waves of AI capability. The underlying intelligence is not new, but putting it in the hands of every knowledge worker with point-and-click simplicity is. The companies and workers who will come out ahead are those treating these tools as a new layer of infrastructure to build on, while leaning into the judgment, context, and trust that remain genuinely difficult to automate. The market reaction was understandable, but this is ultimately a story about a redistribution of capability. The next, and possibly most important, step is determining where humans matter most in that equation.

[1] https://finance.yahoo.com/news/why-software-stocks-are-getting-crushed-as-ai-casts-shadow-of-uncertainty-over-sector-160011783.html
[2] https://www.microsoft.com/en-us/worklab/work-trend-index/ai-at-work-is-here-now-comes-the-hard-part
[3] https://www.capgemini.com/insights/research-library/generative-ai-in-organizations-2025/; https://www.pwc.com/us/en/tech-effect/ai-analytics/ai-agent-survey.html
[4] https://doi.org/10.2139/ssrn.4573321

From Concept to Gadget: Building Embedded Systems That Ship

Fri, 24 Apr 2026 22:53:51 GMT

(Source: ROMBIX STUDIO/stock.adobe.com)

Starting a new embedded electronics project can be both exhilarating and overwhelming. It’s an opportunity to learn new techniques, explore new components, and build something tangible. But before the first line of code is written or the first printed circuit board (PCB) trace is routed, a significant amount of groundwork must be done. Requirements need to be defined, architectures planned, budgets and schedules agreed upon.

There are entire textbooks on product development, so the goal of this blog is not to be exhaustive. Instead, it provides a practical framework for low-volume embedded devices, such as a gadget retailing for around $100USD. By keeping scope and complexity constrained, we can focus on the essential steps required to move from concept to prototype to small-batch production.

Step 1: Requirements define the what and why

Though it is tempting to jump straight into wiring sensors to a development board, successful projects begin with clear requirements. These requirements become the foundation for every decision that follows.

Identify the problem and use case

Start by identifying the problem and use case. Ask, “What is the device meant to do, and who will use it? A consumer device demands simplicity, safety, and polish. A tool for trained technicians can assume more technical knowledge and tolerate complexity. The intended user strongly influences interface design, durability, documentation, and support expectations.

Define functional requirements

Once the problem and use case are clearly understood, the next step is to translate that understanding into concrete capabilities the device must deliver. List the core capabilities the device must provide, such as sensor ranges and accuracy, update rates, battery life, physical size, operating environment, cost targets, and any communications needs. Environmental factors matter—outdoor use implies temperature and moisture concerns, while industrial settings may require electrical noise tolerance.

Consider non-functional requirements

Beyond what the device does, it’s equally important to define how well it must do it. This is where non‑functional requirements come into play. These include safety expectations, reliability goals, aesthetics, regulatory constraints, maintainability, and upgrade paths. Examples include “operate continuously for one year without reboot” or “support field firmware updates.”

Plan for verification early

Because each requirement should be testable, verification planning should happen in parallel with requirements development. If you specify eight hours of battery life, plan a discharge test. If operating down to 0 °C is required, plan a cold test. Thinking about validation early often reveals hidden needs, such as calibration procedures or diagnostic indicators.

For critical projects, a lightweight failure mode analysis can be invaluable. Asking “what happens if this fails?” often leads to additional requirements such as fail-safe behavior or user alerts.

Document your requirements—whether in a formal document or a notebook—and ensure each one ties back to a purpose and a verification method. Clear requirements prevent scope creep and keep development focused.

Step 2: Architecture and design (plan the how)

With requirements clearly defined and tied to verification, attention can shift from what the device must do to how it will do it. This is the role of system architecture and design.

System architecture

Divide the system into functional blocks: sensing, processing, power, user interface, and communications. A simple block diagram helps visualize data and power flow and highlights integration challenges early.

Decide on core components. A microcontroller offers efficiency and low power consumption, while a Linux-based single-board computer may accelerate development but increase cost and power draw. Wireless modules can simplify certification and reduce development time. Every choice involves tradeoffs.

Hardware design considerations

Select hardware components carefully, verifying voltage compatibility, interfaces, addresses, packages, and availability. Read datasheets thoroughly and collect application notes and reference designs—they save time later. Some key Design for Excellence/X (DfX) principles to keep in mind:

Design for Manufacturability (DFM): Avoid exotic parts and follow good PCB practices.
Design for Assembly (DFA): Minimize part variety and assembly complexity.
Design for Test (DFT): Include test points and accessible programming interfaces.

Mechanical integration matters even at this stage. Ensure the PCB fits the enclosure, the mounting holes align, the connectors are accessible, and the cables are strain-relieved. Simple 3D models or even printed templates can prevent costly surprises.

Power design deserves special attention. Calculate power budgets, especially for battery-powered devices, and decide early on charging, regulation, and power-management features.

Software architecture

When planning the software architecture, choose a platform you can deliver with. C/C++ offers efficiency and control. CircuitPython or MicroPython accelerates iteration but requires more resources. Rust offers memory safety at the cost of a steeper learning curve. The “best” option is the one that fits the project and team.

Determine whether a real-time operating system (RTOS) is needed. Simple devices may run happily on bare metal, while systems with multiple time-critical tasks may benefit from FreeRTOS or Zephyr.

Though Internet of Things (IoT) devices are all the rage, think about if a connection to the internet is really needed. Connectivity adds value but significantly increases complexity. If the device doesn’t truly need internet access, leaving it offline avoids security, privacy, and maintenance challenges. If IoT is justified, plan for encryption, authentication, and long-term update strategies from day one.

(Remember,) Project organization is crucial. Use version control for firmware, schematics, PCB files, and documentation. Decide early whether the project will be open source or proprietary and ensure licenses align with that choice.

By the end of this step, you should have a clear technical roadmap, component selections, and a coherent plan for hardware and software integration.

Step 3: Prototyping and development (build, break, improve)

Prototyping turns plans into reality and exposes assumptions. During the prototyping and development stage(s), follow the principles outlined below.

Start simple

Start simple when prototyping. Use development boards and breadboards to validate sensors, displays, communications, and power consumption before committing to custom hardware. Early integration testing often reveals issues such as resource conflicts or library limitations.

Develop incrementally

Bring up the system in stages: verify the toolchain, test individual peripherals, then integrate subsystems. Small, testable milestones make debugging manageable.

Prototype PCB design

Once subsystems work, design a prototype PCB. Be sure to double-check pinouts, footprints, and power routing. Run design rule checks and review the layout carefully. Printing the board at 1:1 scale can catch mechanical issues. For low-volume boards, services like OSH Park, PCBWay, JLCPCB, and Seeed Studio offer affordable, high-quality fabrication. Choose based on board size, quantity, and turnaround time. Consider the assembly strategy. Through-hole parts are forgiving, while surface-mount parts save space. Use package sizes you can reliably assemble or leverage low-cost assembly services if needed.

Bring up methodically

Test the power supply first, then program the microcontroller. Add peripherals one at a time, verifying functionality at each stage. Expect bridge wires and fixes on early revisions. Be sure to document them for the next spin. Firmware development proceeds alongside hardware testing. Early code may be diagnostic-heavy, evolving toward production behavior over time. Source control is invaluable during this phase. Iteration is normal. Each prototype teaches you something and reduces risk.

Step 4: Testing and validation (prove it works)

Testing confirms that the design meets requirements and behaves reliably under real-world conditions.

Verify against requirements

Test each requirement explicitly: accuracy, battery life, environmental limits, durability, and performance. Document results, even for small projects.

Test edge cases and failures

Power cycling, brown-outs, sensor disconnections, communication dropouts, and environmental stress can reveal weaknesses. It’s better to discover them in the lab than in the field. Adopt a failure mode and effects analysis (FMEA) mindset during testing. Ask what happens when components fail or users make mistakes. Ensure failures are safe and detectable.

User feedback

Let representative users try the device. Observing real interactions often uncovers usability improvements that engineers overlook. Refine the design based on findings. Some fixes may require another prototype iteration; others can be addressed in firmware or documentation.

Step 5: Production, launch, and support

With a validated design, focus shifts to delivering a real product.

Finalize the design

Incorporate fixes, clean up firmware, and freeze files for production.

Plan low-volume manufacturing

For very small runs, in-house assembly may be practical. For larger quantities, turnkey assembly services can save time and improve consistency. Order extra components to account for losses.

Manage the supply chain

Check component availability and life cycles early. A single unavailable part can stall production.

Enclosures and labeling

Finalize mechanical designs, ensuring proper fit and alignment. Plan labeling, serial numbers, and branding.

Regulatory considerations

In the U.S., most electronic products require FCC compliance; devices with radios face stricter requirements. In the EU, CE marking is mandatory for most electronics. Using pre-certified wireless modules can significantly reduce cost and complexity. Even for low volumes, understand the legal implications of skipping certification.

Documentation and logistics

Prepare user guides, assembly instructions, and test procedures. Plan packaging and shipping to protect the product and satisfy customs requirements if shipping internationally.

Support and lifecycle

Expect post-launch support. Plan for firmware updates, repairs, and long-term component availability. Responsible design also considers end-of-life and recycling.

Conclusion

Embedded product development is inherently iterative. Requirements, design, prototyping, testing, and production often overlap and inform one another. A structured approach doesn’t limit creativity. Rather, it channels it into steady progress, reducing costly surprises.

Whether you’re building a commercial IoT device or a personal project, taking time to define requirements, design thoughtfully, prototype intelligently, test thoroughly, and plan for real-world deployment dramatically increases your chances of success. Few experiences match the satisfaction of turning an idea into a tangible, working product. With a solid roadmap, that journey becomes both manageable and rewarding.

Using GitHub for Hardware Development

Thu, 09 Oct 2025 22:31:54 GMT

(Source: GitHub)

In the world of embedded systems and hardware development, collaboration, version control, and traceability are critical—yet often overlooked—components of the engineering process. Software developers have long embraced Git and platforms like GitHub^® to manage codebases efficiently. However, the power of GitHub extends well beyond code repositories. Today, hardware engineers, printed circuit board (PCB) designers, and embedded systems developers are leveraging GitHub to manage schematics, PCB layouts, firmware, documentation, and even manufacturing files.

In this blog, we explore how GitHub can become a central hub for hardware design workflows, enabling better collaboration, reproducibility, and project transparency.

Why GitHub for Hardware Development?

Traditionally, hardware development has suffered from fragmented file management practices, with schematics in one location, PCB layouts on a local drive, firmware in another repository—if versioned at all—and documentation residing on various cloud services or internal networks.

By unifying these under a Git-based system like GitHub, teams can version control everything—not just code, but also schematics, bills of materials (BOMs), Gerber files, and design reviews. Developers can collaborate across teams, sharing designs with firmware, mechanical, and test engineers in one place. This approach improves traceability by tracking who changed what and when, with detailed commit histories that provide a clear record of changes. It also enables continuous integration and automation, as it can automatically build firmware or generate documentation whenever changes are pushed to the repository.

What to Store in a Hardware GitHub Repository?

Let’s break down what a well-structured embedded systems GitHub repository might include:

Schematics

Most modern electronic design automation (EDA) tools, including KiCad, Altium Designer, and EasyEDA, save schematics as text-based files or structured XML. This makes them compatible with Git’s diffing and merging capabilities. It’s best to organize schematics by subsystem or board revision in dedicated folders:

/hardware/schematics/v1.0/

/hardware/schematics/v2.0/

PCB Layouts

PCB layout files, such as KiCad .kicad_pcb or Altium .PcbDoc, can be stored alongside schematics. GitHub makes it easy to trace design changes over time, tracking changes like layer modifications, routing updates, or footprint swaps, with each commit linked to a description of why the change was made. Developers should include manufacturing outputs like Gerber files and drill files in separate outputs or manufacturing directories for clarity:

/hardware/manufacturing/v1.0/

/hardware/manufacturing/v2.0/

Firmware

GitHub shines in managing firmware source code, whether written in C, C++, or Assembly. Linking the firmware repository directly to specific hardware revisions ensures the right code is paired with the correct hardware version. Using tags or branches named after hardware revisions (e.g., rev1.0, rev2.0) enables a tight linkage between hardware and firmware. Additionally, utilizing feature branches for significant design changes (e.g., feature/add-usb-interface) and revision branches for hardware versions (e.g., hardware/rev1.1) can improve firmware management.

Mechanical Drawings

If your hardware involves enclosures, brackets, or custom parts, GitHub can store source files (e.g., STEP, STL, DXF) or exported drawings (PDFs) for mechanical designs. These files can live in /mechanical/ or /enclosure/ folders within the repository. Providing mechanical design files can be particularly attractive to potential clients who already own 3D printers, and this means you have less stock to warehouse.

Documentation

Often overlooked, documentation is crucial for long-term sustainability of a project. GitHub offers excellent tools for keeping hardware development organized and up to date. A clear, well-written README.md serves as a human-friendly entry point for the project, while a dedicated /docs/ directory can hold detailed design notes, setup instructions, BOMs, and test procedures. Using a Wiki or GitHub pages makes it easy to host formatted documentation directly from the repository. Meanwhile, markdown files are ideal for writing design notes, guides, and overviews, and they can include images, screenshots, diagrams, and links to datasheets or supplier pages to keep all vital details in one accessible place.

Test and Validation Data

GitHub allows you to store test scripts, validation data, and even results in your repository. Automated test scripts can be versioned like any other code, and result logs can help future teams reproduce or debug issues.

Organizing Your Repository

A well-thought-out organizational structure for your repository is crucial in making it useful throughout the design process. This structure should separate schematic and PCB sources from generated manufacturing files, keeping firmware build artifacts out of src. Additionally, effective organization gives mechanical computer aided drafting (CAD) its own home and reserves docs for the BOMs, guides, and design notes people actually read. When using GitHub for organization, tests and continuous integration (CI) scripts live beside the code they validate, while the top-level README.md explains how to build, program, and order the board, and LICENSE clarifies reuse. Pair this structure with Git’s large file storage (LFS) for big binaries (e.g., STEP, STL, PDFs) and text-friendly formats like KiCad for schematics and PCBs to keep diffs clean, reviews focused, and releases reproducible. A typical embedded systems hardware project might look like this:

/hardware/

/schematics/

/pcb_layouts/

/manufacturing_outputs/ (Gerbers, drill files, assembly drawings)

/firmware/

/src/

/bin/

/mechanical/

/models/ (STEP, STL)

/drawings/

/docs/

/BOMs/

/assembly_guides/

/design_notes/

/test/

/scripts/

/results/

/ci_scripts/ (for automation tasks)

README.md

LICENSE

Collaboration and Workflow Best Practices

Hardware moves fast—and breaks expensively—so your repo needs to be more than a code dump; it should be the single source of truth for schematics, layouts, firmware, manufacturing files, and decisions. Treat GitHub like a lightweight product lifecycle management (PLM): use branches to isolate risky changes, pull requests to stage cross-disciplinary reviews, and employ issues and boards to keep electrical, mechanical, and firmware workstreams aligned. Tie every artifact to a discussion, a decision, and a release for traceability from napkin sketch to shipped product. The practices below show how to turn that principle into a day-to-day workflow that scales from a solo builder to an enterprise hardware team.

Pull Requests and Code Reviews

Pull requests and code reviews can be used for schematic or layout changes just as they are for firmware. Teams can review differences in schematic files—especially when using text-friendly formats like KiCad’s .sch—and discuss design choices in context. Even for schematics and PCB files, pull requests offer a formal way to propose, review, and refine design changes before merging them into the main branch. This process encourages cross-disciplinary reviews, such as having firmware developers check pin assignments or connector choices, while GitHub’s discussion threads help document design decisions along the way.

Issues and Project Boards

Track bugs, hardware errata, and TODOs using GitHub Issues. Organize them into milestones or Kanban-style boards to manage hardware and firmware development side-by-side.

Git LFS

PCB design files, 3D models, and high-resolution documentation can exceed GitHub’s file size limits. Use Git LFS to manage these efficiently, with its ability to handle large binaries without bloating the repository.

Release Tagging and Linking

Tag releases that align hardware revisions with firmware versions (e.g., rev1.0-fw1.0) so it is easy to pull up the exact design files, firmware, and documentation used in any given release. Link issues directly to commits or pull requests to document bug fixes or design changes.

CI/CD for Hardware Projects

Continuous integration/continuous delivery (CI/CD), though standard in software, is becoming increasingly valuable for hardware projects as well. For example, teams can use GitHub Actions or other CI tools to automatically compile firmware whenever new code is pushed. Documentation can be automatically generated, converting Markdown files to PDFs or exporting BOMs directly from source files. Scripts can run design rule checks to verify layout constraints or ensure schematic consistency. For instance, a commit to the firmware directory can trigger an automated build, while an update to the documentation folder can regenerate and publish the latest docs to GitHub Pages.

Integrating GitHub with Third-Party Add-ons

Integrating third-party tools like Kitspace with GitHub provides an elegant solution for sharing PCB design files in a way that’s accessible, transparent, and fabrication-ready. Kitspace connects directly to your public GitHub repository and automatically generates a rich, browsable project page that includes rendered board previews, BOMs, and links to PCB manufacturers and distributors. By simply adding a .kitspace.yaml configuration file to the repository and following Kitspace’s conventions, especially for KiCad projects, hardware designers can offer collaborators, manufacturers, and the broader community an interactive view of their design without requiring specialized software to open the files. This integration streamlines collaboration, making it easy to keep documentation, schematics, layouts, and manufacturing outputs synchronized and accessible.

GitHub Limitations for Hardware Projects

While GitHub provides a strong backbone for hardware projects, there are a few important considerations to keep in mind. PCB layout files stored as binaries cannot be diffed in a meaningful way, so it’s best to use text-based EDA tools whenever possible. Merging schematic or layout changes can also be challenging without good coordination, so teams should use branches thoughtfully and communicate frequently to avoid conflicts. Additionally, GitHub has a file size limitation of 100MB per file, so very large designs or mechanical assemblies might require Git LFS or an alternative hosting solution.

Conclusion

GitHub isn’t just for software-only projects anymore. As hardware development grows more complex and collaborative, version control systems like Git have become invaluable tools for managing everything from schematics and PCB layouts to firmware, mechanical files, and documentation. By bringing hardware into the same structured, trackable workflows that software teams rely on, engineers can achieve new levels of efficiency, reproducibility, and teamwork.

From Bare Metal to Zephyr: How RTOSes Power Embedded Systems

Mon, 08 Sep 2025 17:05:57 GMT

(Source: Cheewynn/stock.adobe.com; generated with AI)

Many developers started their embedded development journeys writing firmware that ran directly on the bare metal of a microcontroller. It was straightforward and efficient, at least memory-wise. For single-purpose built applications, say flashing an LED, this was fine. In fact, writing firmware was a considerable shift from building systems with just hardware (for example, incorporating a 555 timer). Developers could now change code and modify behaviors with relative ease, as opposed to rewiring a circuit.

Today, embedded systems are everywhere, from smartwatches and vehicles' electronic control units (ECUs) to smart fridges and medical devices. The increasing complexity of modern embedded applications has led to the widespread adoption of real-time operating systems (RTOSes). In this article, we will define RTOSes and explore some of the features of the popular RTOS Zephyr.

RTOS in a Nutshell

An RTOS is specialized software that manages hardware resources and allows multiple tasks to run concurrently in a predictable and timely manner. Unlike general-purpose operating systems like Windows or Linux, an RTOS prioritizes deterministic behavior, which means it guarantees that certain operations will be completed within a defined time frame. However, "time frame" in this sense does not mean "poll this sensor every Thursday at 3 p.m." Instead, it means something more akin to "poll this sensor every 500ms."

RTOSes are built to meet the specific needs of systems that require deterministic and predictable timing behavior. In most embedded real-time systems (e.g., medical devices, avionics, automotive ECUs), applications often need tasks to be executed within precise time windows. Thus, RTOSes are designed to ensure real-time guarantees (i.e., tasks that meet strict timing deadlines) and low latency (i.e., fast response to interrupts and events).

While it's possible to write firmware that can do this without using an RTOS, developers would be reinventing the wheel and building a subset of what a modern RTOS offers. The overhead of an RTOS will typically be outweighed by the utility it provides, except for the most resource-constrained of projects, such as those using 8-bit AVR or PIC microcontrollers.

Essentially, an RTOS is ideal in systems that require precise timing (e.g., motor control, audio processing) or that handle multiple tasks at once (e.g., a device that simultaneously uses Bluetooth^® connectivity, a user interface, and sensor data). An RTOS makes sense for developers that want modular, reusable code that is easy to maintain as the project grows, and when efficient power management is critical to maximize battery life.

Bare-metal firmware is best for simple applications, such as blinking an LED or reading a sensor. It's also ideal for working with extremely limited memory or for complete control over low-level hardware timing.

Anatomy of an RTOS

RTOSes are designed to handle tasks with predictable timing and deterministic behavior, critical for embedded systems, robotics, automotive software, and industrial controls. While implementations can vary in complexity, most modern RTOSes are built around a standard set of foundational elements, including kernels, tasks and threads, schedulers, inter-process communication (IPC), memory management, and timers. Each plays a vital role in enabling concurrent execution, time-sensitive responsiveness, and system reliability.

Kernel

At the heart of any RTOS is the kernel, a lightweight and deterministic core designed to ensure that critical tasks execute with minimal and predictable delay. The kernel manages the system's essential low-level operations, including the following:

Scheduling and dispatching tasks to determine when to run which task.
Handling interrupts to respond immediately to external events.
Performing context switching to swap between tasks efficiently.
Providing synchronization and communication services so tasks can coordinate and share data safely.

Tasks/Threads

Tasks (also known as threads) are the basic units of execution in an RTOS. Each task represents an independent control flow with its own stack for managing local data, a defined priority level that determines when it runs, and a clear state—such as ready, running, blocked, or suspended—that changes as the RTOS manages execution. Tasks can be preemptive, allowing higher-priority tasks to interrupt lower ones, or cooperative, where tasks voluntarily yield control. In either case, the RTOS ensures that the highest-priority task that is ready always receives CPU time.

Scheduler

The scheduler acts as the brain of the RTOS, determining which task runs at any given moment. Schedulers are usually priority-based and can be preemptive, cooperative, or a hybrid of both approaches. Many RTOSes allow configuration for specific algorithms such as rate monotonic scheduling for periodic tasks, round-robin scheduling for time-sharing, or earliest-deadline-first for deadline-driven workloads. Regardless of the method, the scheduler's main goal is determinism—making sure that task execution occurs within known, guaranteed time bounds, which is vital for real-time performance.

Inter-Process Communication

To keep multiple tasks running smoothly and in sync, an RTOS provides IPC mechanisms that enable safe data sharing and coordination. These tools help prevent race conditions and deadlocks, ensuring tasks interact reliably. Common IPC features include semaphores for signaling and mutual exclusion (either binary or counting), mutexes that offer mutual exclusion and priority inheritance to prevent priority inversion, message queues that act as first-in–first-out (FIFO) buffers for sending structured data between tasks, and event flags that use lightweight bit masks for efficient synchronization.

Memory Management

An RTOS must handle memory in a way that balances flexibility with predictability. Some systems rely on static memory allocation fixed at compile time to maintain consistent behavior, while others also support dynamic allocation that uses a heap or memory pools when runtime flexibility is needed. Many RTOSes include safety features such as stack overflow detection to catch errors early, memory partitioning to keep different regions separate, thread-safe allocators to avoid conflicts, and hardware-backed memory protection if supported by a memory management unit (MMU). Some real-time systems avoid dynamic memory altogether to ensure timing remains predictable and fragmentation does not occur.

Timers

Precise timing is critical in real-time applications, and an RTOS typically provides both software timers and integration with hardware timers to make this possible. Timers allow tasks to execute at exact intervals or after specified durations. They are essential for delaying tasks, implementing timeouts to handle unexpected delays, and triggering periodic operations that must run on a strict schedule to maintain real-time performance.

Zerphyr Overview

One RTOS that has experienced rapid growth in recent years is Zephyr. In fact, Arduino has chosen the open-source, feature-rich, modular Zephyr for its next-generation hardware cores, following the sunset of Mbed.

Zephyr began in 2016 as a spin-off of the Virtuoso Nano microkernel. It was initially developed by Wind River Systems, the same company behind VxWorks, one of the most established commercial RTOSes. Zephyr's stated goal is to provide a vendor-neutral, open source, and security-first RTOS for Internet of Things (IoT) and embedded devices.

Zephyr's architecture is built around a preemptive, priority-based microkernel design. The modular kernel is configurable at compile time, which keeps the footprint minimal. This allows developers to use Zephyr for everything from tiny 8-bit MCUs to 64-bit embedded processors.

Zephyr uses the Kconfig system (from the Linux kernel) and the CMake build system, allowing developers to configure the entire OS for a specific use case or board. The kernel, drivers, stacks, and middleware are divided into components developers can enable and disable selecting only the necessary modules such as networking and power management.

As of this writing, Zephyr supports 800+ boards from manufacturers such as Nordic Semiconductor, NXP, STMicroelectronics, Texas Instruments, Intel^®, Microchip Technology, and SiFive (RISC-V).^[1]

Zephyr includes built-in support for essential connectivity options such as Bluetooth Low Energy, Ethernet, Thread, CAN, and Wi-Fi^®, so embedded developers can spend less time writing drivers and more time building their applications. The RTOS provides security through lightweight, integrated cryptography libraries like TinyCrypt and mbedTLS. For safety-critical automotive and industrial systems, Zephyr's certifications such as ISO 26262 and IEC 61508 can help designers meet strict regulatory standards. Zephyr also provides drivers for LCDs, OLEDs, touch panels, and e-ink screens, and works seamlessly with Light and Versatile Graphics Library (LVGL) for designing graphical user interfaces (GUIs).

The Zephyr development ecosystem is also solid and well-rounded. At its core is West, a versatile command-line tool that collects CMake, Git, and flashing or debugging commands in a single interface. The Zephyr SDK comes bundled with prebuilt toolchains, QEMU for virtualized testing, and other development tools that help developers get up and running quickly. Zephyr integrates well with popular environments like Visual Studio Code, SEGGER Embedded Studio, and traditional command-line workflows, giving developers flexibility in how they work. For debugging, developers have a range of options at their disposal, including GDB, OpenOCD, J-Link, and pyOCD.

Conclusion

RTOSes are powerful tools that help embedded developers meet the demanding requirements of modern applications, where precision, reliability, and scalability are non-negotiable. Zephyr, with its modular architecture, rich ecosystem, and strong industry support, represents a compelling choice for projects ranging from home automation IoT devices to safety-critical automotive systems. As embedded systems continue to evolve in complexity, leveraging an RTOS like Zephyr allows developers to focus on innovation rather than reinventing the wheel. Whether building the next generation of wearable devices or industrial controllers, Zephyr provides the flexibility and confidence to bring designs to life.

Sources

[1] https://zephyrproject.org/

Planning for Machine Learning Success

Sat, 26 Apr 2025 03:31:39 GMT

How to Navigate the Journey from Proof of Concept to Production

(Source: Kolapatha/stock.adobe.com; generated with AI)

Machine learning (ML) has the potential to redefine industries by transforming innovative ideas into practical, impactful solutions. The journey from proof of concept (PoC) to production is critical in ensuring that ML projects not only start strong but also deliver lasting value. This process involves meticulous planning, robust experimentation, and continuous monitoring to ensure that ML models perform effectively in real-world scenarios. In this blog, we briefly review the main steps in the computing journey from PoC to production.

Establishing a Foundation: Business Goals and ML Metrics

Developing a PoC begins with defining clear business goals and relevant metrics. This foundational step ensures that the ML project aligns with overarching business objectives, such as improving productivity or reducing costs.

By translating these goals into specific ML metrics, teams can measure progress and success accurately. This first stage involves creating a roadmap that outlines the PoC implementation and experimentation approaches, ensuring that each step is validated and aligned with the desired outcomes once it’s time for production.

Data: The Lifeblood of ML Projects

No ML project can succeed without high-quality data. Selecting the right data inputs and labels, evaluating data quality, and determining the necessary quantity are critical steps.

High-quality data ensures that the ML model can learn effectively and make precise predictions. This stage involves constructing data acquisition pipelines and ensuring that the data is relevant and sufficient for the PoC.

Experimentation: Building a Robust Environment

Creating a robust experimentation environment is essential for developing and testing ML models. This involves setting up the necessary tools and infrastructure to support iterative testing and validation.

A well-structured experimentation environment allows teams to refine their models, test different approaches, and ensure that the models perform well under various conditions.

Leveraging Existing Resources: Open Source for ML Modeling

One of the key strategies for accelerating ML development is leveraging existing resources, such as open source models and software packages.

These open source resources can significantly reduce the time and effort required to build a PoC. By using pre-trained models and third-party tools, teams can focus on fine-tuning and customizing the models to meet specific project requirements.

Transitioning to Production: Extending the ML PoC

Once the PoC has demonstrated its feasibility through experimentation and modeling, the next step is to transition it into production. This involves robust software development practices, including testing, integration, and deployment.

Establishing production requirements, such as expected latency and framework compatibility, helps guide the choice of tooling and architecture solutions. Confirming that the model is robust and reliable in a production environment is crucial for its long-term success.

Post-Production: Tracking for ML Observability

This computing journey doesn't end with deployment. Post-production monitoring and observability are necessary to ensure the ML model continues to perform well.

This post-production stage involves tracking various metrics, such as input and output data, performance, and any relevant business key performance indicators (KPIs). Monitoring for data drift and model performance issues allows teams to retrain and redeploy models as needed, ensuring that they remain accurate and effective over time.

Conclusion

Transitioning an ML project from proof of concept to production is a complex but rewarding journey. By establishing clear business goals, selecting high-quality data, creating a robust experimentation environment, leveraging existing resources, and maintaining rigorous post-production monitoring, teams can ensure that their ML projects deliver lasting value.

For a deeper dive into this topic, read the full article, “Applying Business Goals to Machine Learning Metrics.”

This blog was generated with assistance from Copilot for Microsoft 365.

Getting Started with Coding a DIY Project

Mon, 17 Mar 2025 15:58:59 GMT

(Source: Victoria Kluy/stock.adobe.com)

It is increasingly rare to build electronic systems that consist only of hardware. In both professional and hobbyist markets, embedded systems are a marriage of passive and active electronic components and software or firmware. A quick aside: The term firmware originates from the late 1960s and is a combination of "firm" (suggesting something solid but not as rigid as hardware) and "ware" (from software). Firmware is "firm" in the sense that it is stored in non-volatile memory (like ROM, EPROM, or flash memory) and is essential for a device’s operation. However, it can still be updated or modified.

So, what does it take to develop code for DIY electronics, specifically microcontroller-based projects? First, let’s examine the embedded programming languages geared toward hobbyists. The most common options are Arduino (C/C++), MicroPython, CircuitPython, and their associated runtime environments.

Arduino (C/C++): The Arduino platform provides a simplified version of C/C++ that abstracts low-level complexities while offering supporting libraries for embedded development. Its advantages include better performance for critical applications, lower memory usage, greater hardware compatibility, broader peripheral support, and more control over low-level hardware.
MicroPython and CircuitPython: These implementations of the Python language were created to address some of the challenges of C/C++ programming. Advantages include simplified library management, interactive debugging, automatic storage mounting, and better error handling.

If you have experience in desktop programming in C/C++ or Python, you should pick the embedded counterpart to reduce the learning curve. For those without programming experience, reviewing sample projects in each language can help determine which feels most natural. In general, C/C++ offers better performance, while Python-based options prioritize ease of use and readability.

Steps for Writing Firmware

Regardless of the hardware platform and programming language selected, the high-level process of writing code is essentially the same. First, we must get our logic out of our brains and into the computer. This can be achieved in a simple text editor like Notepad or a more advanced editor like Visual Studio Code. Simply write down the steps your code needs to walk through in a numbered list. We aren’t worried about coding yet; we are just documenting how we envision our code will flow. What inputs are taken in, how are we processing the data, and what outputs do we generate and when? This is called pseudocode and is written in your native language.

After we have documented the high-level requirements for our code, it’s time to write the firmware. The code we produce in human-readable format is called source code. The file extension of a source code file typically indicates the programming language used. For example, .ino and .c are indicative of Arduino and C programs, whereas .py and .mpy are the file extensions of Python-based programs. You can write source code in a simple text editor. However, novices might consider an integrated development environment (IDE).

An IDE is a software application that provides a comprehensive set of tools for software development in one package. In addition to a code editor, it also includes useful tools such as a compiler/interpreter, debugger, and version control. While it is possible to manually set up the toolchain that allows one to compile source code into a file understood by a microcontroller (i.e., machine code) and then upload it to the device using specialized hardware, an IDE handles all this complexity in a single application from the user’s perspective.

Conversely, MicroPython and CircuitPython are interpreted languages. This means the source code remains in a human-readable format and is executed directly by the Python interpreter on the microcontroller. This removes the need for a compilation step but requires the microcontroller to have sufficient resources to run the interpreter in addition to the source. The CircuitPython firmware must first be flashed to the hardware. After a reboot, the development board will appear as a USB mass storage device and the user’s source code can be copied to the apparent flash drive. After another reboot, the microcontroller will begin executing the code.

Additional Tips for Success

Whether you use compiled code, such as Arduino, or interpreted code, like CircuitPython, it is important to remember to wire your external hardware before uploading firmware. Ensure the USB cable you use to connect your microcontroller development kit to your development board carries data. If you connect your board and onboard LEDs light up, but your IDE doesn’t see the board, you may have incorrect drivers or are using a power-only USB cable that lacks data lines. Also, consider the following when getting started with coding for your DIY projects:

Start with Simple Projects

Blinking an LED, reading a sensor, or controlling a motor are great beginner exercises. They help you learn how software influences hardware and vice versa. It is not always intuitive, so start small and build confidence.

Remember to Debug

Code will rarely, if ever, work as intended on the first try. Developing debugging skills is crucial. Professional engineers may rely more on hardware debugging tools, such as hardware debuggers, oscilloscopes, and logic analyzers, to inspect signals, particularly when building custom circuit boards or interfacing with many external components. However, a simple way to debug for beginners is to use the serial terminal to pass messages from the microcontroller to the host machine. The Arduino ecosystem uses the serial.print() function for this purpose. Similarly, in MicroPython, the print() function outputs messages via the read-eval-print loop (REPL) interface. That said, even low-cost development kits incorporate built-in debugging hardware so that users can insert breakpoints and peek into registers via the IDE.

Explore Third-Party Libraries but Also Write Your Own

If you are considering adding functionality or external components (e.g., sensors, actuators) to your project, chances are that code already exists to provide the interfaces. Arduino libraries and MicroPython modules are great ways to get a project working fast and reliably. However, overreliance on libraries and modules may deprive you of a great learning opportunity to understand the intersection of hardware and software. Once you get a project up and running, consider forking a library that interfaces a sensor and the microcontroller and see if you can add functionality that is not native to the library. Reading the library or module code is beneficial as you will have to interact more directly with the hardware (e.g., ports and registers).

Experiment and Learn

Hands-on learning and iterative improvements will enhance your understanding of microcontroller programming. Beyond the basic general-purpose input/output (GPIO), learn how to interact with communication protocols (e.g., I²C, SPI, UART), power management, task scheduling, and other advanced features your hardware supports. Pick a new feature of your microcontroller and learn how to write the code that controls that functionality.

Conclusion

Getting started with embedded programming has never been more accessible. Platforms like Arduino, MicroPython, and CircuitPython provide powerful options regardless of your technical background. Arduino, built on C/C++, delivers high performance and precise hardware control, while Python-based environments prioritize ease of use and rapid development. Writing firmware is a structured process: Start with pseudocode, move to an IDE to program the source code, and then test with real hardware interactions and serial output. Beginners should start with fundamental projects like blinking an LED before diving into debugging techniques, serial communication, and built-in diagnostic tools. While third-party libraries accelerate development, writing custom code deepens understanding and enhances flexibility. Exploring core microcontroller functions like I²C, SPI, and UART opens the door to more advanced designs, helping engineers push the limits of what’s possible.

Embedded Development Using No-Code/Low-Code Platforms

Thu, 13 Mar 2025 23:13:51 GMT

(Source: Hikmet/stock.adobe.com; generated with AI)

No-code/low-code (NCLC) platforms have become popular for developing software without deep programming knowledge or expertise. While these platforms are widely used in desktop, web, and mobile app development, they are beginning to make strides in the embedded systems domain. NCLC platforms typically feature intuitive drag-and-drop interfaces, making these tools accessible to users lacking an extensive programming foundation.

By lessening the learning curve, NCLC enables faster application development and reduces the time from concept to deployment, making it ideal for quick prototyping to test ideas and functionalities before full-scale development. Additionally, many NCLC platforms provide real-time feedback and interactive debugging tools, allowing users to test and refine their applications rapidly. These characteristics make NCLC platforms popular in scientific, system integration, and academic applications, where real-world outcomes are prioritized higher than detailed software development.

However, as with all engineering decisions, there are tradeoffs that must be considered when electing to use an NCLC platform for developing an embedded system. These include the following:

Limited Customization: Typically, NCLC platforms rely on predefined components and templates, which may not meet all unique or complex requirements. Some, however, allow for creating custom modules using more traditional languages, such as C.
Performance and Efficiency Concerns: Applications built with NCLC platforms can be less efficient, more resource-intensive, and less scalable than those developed with traditional coding practices.
Vendor Lock-In: Some platforms use proprietary technologies that may not be easily transferable to other architectures or development environments.
Security and Compliance Risks: Ensuring compliance with industry standards and regulations can be more challenging when using NCLC platforms, given their inherent “black box” nature. This can be particularly problematic in highly regulated industries.
Debugging Difficulty: The abstraction layers that make NCLC platforms easy to use can also obscure the underlying operations, making diagnosing and fixing issues more difficult.

With the pros and cons of NCLC platforms understood, let’s take a take deep dive into some of the more notable NCLC options for programming embedded systems.

Education and Maker Platforms

“Drag-and-drop” NCLC platforms are excellent for rapid prototyping and educational purposes. There are several options that enable quick iteration and experimentation without the need for even basic programming knowledge.

BlocklyDuino is an Arduino-oriented, web-based visual programming editor that uses Google's Blockly library. Key features include:
- Drag-and-drop programming blocks
- Real-time code generation in Arduino's programming language
- Suitable for educational purposes and beginners
- Open source and customizable

MicroBlocks is a live, blocks-based programming environment for microcontrollers inspired by Scratch. Key features include:
- Interactive programming with real-time updates
- Support for multiple microcontroller platforms (e.g., micro, ESP32)
- Simple and engaging for education and quick prototyping
- Open source and community driven

Automation and IoT Platforms

Beyond their educational benefits, NCLC platforms can assist with automation and Internet of Things (IoT) needs. Platforms like Node-RED, XOD, and more are particularly suited for IoT projects, allowing users to integrate various sensors and devices easily.

Node-RED is a flow-based development tool initially developed by IBM Emerging Technology Services’ browser-based editor. It enables users to wire together devices, APIs, and online services with a wide range of nodes. Key features include:
- Drag-and-drop interface for building workflows
- Extensive pre-built node library for common tasks
- Ability to run on devices like Raspberry Pi, making it suitable for IoT projects
- Supports integration with various protocols (e.g., MQTT, HTTP, WebSockets)

XOD is a visual programming language for microcontrollers and Arduino boards. It uses a graphical interface where users connect nodes to create functional programs. Key features include:
- Intuitive drag-and-drop interface
- Open source with a growing library of nodes
- Suitable for beginners and hobbyists
- Supports Arduino, Raspberry Pi, and other microcontroller platforms
Visuino is a graphical development environment for Arduino. It enables users to create programs by connecting visual blocks. Key features include:
- Visual programming for Arduino boards
- Extensive component library with pre-built blocks
- Real-time simulation and debugging
- Export to Arduino IDE for further customization
Mendix is a low-code platform for rapid application development, including those for IoT and embedded systems. Key features include:
- Model-driven development with a visual interface
- Integration with IoT platforms and devices
- Robust support for workflows, business logic, and data management
- Cloud and on-premises deployment options

Industrial and Scientific Platforms

NCLC solutions are even making their way into industrial and scientific development projects. The following tools are suited for industrial applications where reliability, security, and precise control are critical.

Laboratory Virtual Instrument Engineering Workbench (LabVIEW) is a system-design platform and development environment from National Instruments. It is particularly popular in engineering and scientific applications. Key features include:
- Graphical programming environment
- Extensive libraries for data acquisition, instrument control, and industrial automation
- Integration with hardware devices for real-time processing
- Suitable for complex systems requiring precise control and monitoring
Torizon™ by Toradex is a Linux-based software platform designed to simplify the development and maintenance of embedded systems. It integrates with Visual Studio and Visual Studio Code, providing a low-code approach for developing embedded applications. Key features include:
- Easy setup and deployment for embedded Linux
- Integration with Docker for containerized applications
- Remote monitoring and update capabilities
- Security and reliability for industrial applications

Conclusion

No-code/low-code platforms are expanding program development opportunities and making significant impacts on the pace of building and deployment. The NCLC options discussed throughout this blog offer diverse capabilities, making them suitable for different use cases in embedded systems development. They democratize the development process, enabling a wider range of users to create sophisticated embedded applications.

Still, while NCLC platforms offer a compelling approach to rapid application development, they are not a one-size-fits-all solution. In response, these platforms have diversified their offerings to better meet various embedded development needs. For example, education and maker NCLC platforms feature rapid prototyping for educational purposes and strong support for source resources, while automation and IoT NCLC platforms allow sensors and devices to easily integrate into embedded systems, and industrial and scientific NCLC platforms provide reliability, security, and precise control to critical applications. By understanding the strengths and limitations of NCLC tools, developers and businesses can make informed decisions about their suitability for specific projects.

A New Era of Industrial Automation

Fri, 14 Feb 2025 00:26:05 GMT

Embracing Open-Source Flexibility and Innovation

(Source: Heng Heng - AI Stock/stock.adobe.com; generated with AI)

Thanks to the growing integration of open-source technologies, the industrial automation sector is experiencing a remarkable transformation. This shift is the result of increasing demand for more flexible, scalable, and cost-effective solutions that can adapt to the evolving needs of modern manufacturing and production processes. By moving away from proprietary, rigid systems, industries are discovering the many benefits of open-source platforms. In this blog, we’ll explore how open-source solutions are reshaping automation and why they are becoming a cornerstone of industrial progress.

New Tools, New Advantages in Industry

Unlike traditional solutions, open-source tools allow for greater flexibility, enabling engineers and manufacturers to build systems that cater to their unique requirements. Open-source technology is particularly advantageous in industries where off-the-shelf products often fail to meet the complexity and specificity of certain applications.

Perhaps the most notable advantage of open-source is the significant reduction in costs. By eliminating the need for expensive licensing fees and support contracts, companies can not only lower their upfront investment but also decrease long-term maintenance expenses. As a result, even smaller businesses with limited budgets can now access advanced automation technologies, leveling the playing field in industries that were once reliant on high-cost proprietary systems.

Open-source automation solutions offer seamless integration across diverse systems by supporting various industry-standard protocols, enhancing interoperability, ensuring smoother operations, and preventing costly silos. Contrary to common belief, open-source platforms often enhance security through transparency, enabling faster identification and resolution of vulnerabilities. Additionally, they eliminate vendor lock-in, providing businesses with the flexibility to choose service providers and adapt solutions without being tied to a single vendor.

Modern Hardware for Modern Automation

Alongside software, open-source hardware platforms are gaining traction in the industrial automation space. These devices offer flexibility and scalability, enabling companies to tailor their automation systems without being constrained by exclusive designs.

KUNBUS Revolution Pi

The Revolution Pi (RevPi) is an innovative industrial PC built on the Raspberry Pi Compute Module. This open-source hardware platform offers outstanding adaptability with support for a wide variety of industrial communication protocols, including MQTT, Modbus, OPC UA, and EtherNet/IP. The modular nature of the RevPi allows it to be easily customized and expanded to suit the specific needs of different production environments. For example, a manufacturer could use it as the central controller for managing multiple production lines or gathering data from various sensors.

Arduino Opta

The Arduino Opta is a compact programmable logic controller (PLC) designed for automation applications. With Arduino already renowned for its user-friendly development boards, this open-source solution comes as natural solution for various industrial automation needs. The Opta combines the simplicity of the Arduino ecosystem with the ruggedness required for industrial environments. It’s particularly useful for small-scale automation projects and is perfect for quickly prototyping solutions, such as automating a conveyor belt or controlling a packaging line in a small factory.

Open-Source Software in Automation Control

Software has long-played a key role in managing industrial automation systems, and open-source options are making it easier than ever to implement highly customizable control systems. Here are several key open-source software solutions for automation control in industrial settings:

Zephyr RTOS: A lightweight, real-time operating system (RTOS) designed for embedded devices with limited resources. Zephyr's small footprint and highly configurable nature make it ideal for industrial applications where millisecond-level accuracy is essential, such as in high-speed sorting systems or precision-controlled machinery.
FreeRTOS: Widely used in microcontroller-based automation, FreeRTOS is an open-source RTOS known for its ease of use and extensive ecosystem. It is particularly suitable for distributed control systems, where multiple microcontrollers work together to manage complex processes across a factory or production facility.
Real-Time Linux: For more demanding industrial tasks, real-time Linux provides the power of a full operating system combined with the deterministic performance required for real-time applications. By modifying the Linux kernel, this version of Linux ensures low-latency performance while maintaining the flexibility and robustness of the standard Linux environment. It is especially valuable in applications like vision-based quality control or robotics, where real-time data processing is critical.

Open-source software also extends to control systems themselves. Compared to traditional supervisory control and data acquisition (SCADA) systems, platforms like Rapid SCADA are providing a flexible, versatile alternative. Rapid SCADA’s open architecture is particularly valuable in industries where customization is key, such as water treatment plants, energy management systems, and environmental monitoring.

Another significant advancement in industrial automation software is the rise of ROS-Industrial, an open-source framework derived from the Robot Operating System (ROS). ROS-Industrial brings ROS into industrial settings by offering a powerful platform for controlling and programming robotic arms, automated conveyors, and other robotic systems on the factory floor.

Communication Protocols to Ensure Smooth Data Flow

In any automated system, seamless communication between devices is essential. Open-source communication protocols, such as OPC UA and MQTT, are helping make this possible by providing robust, standardized methods for devices to exchange data in real time. OPC UA is a popular protocol for industrial automation because of its security and compatibility with a wide range of devices. MQTT, a lightweight protocol, is especially useful in Internet of Things (IoT) applications, where devices are distributed over large areas or where network reliability may be a concern.

Conclusion

As the industrial sector continues to evolve, the role of open-source technologies is only set to grow. With the continued development of IoT, AI, and machine learning, open-source platforms will become even more capable, providing the flexibility and intelligence needed for next-generation industrial automation systems. The open-source movement is not just a trend—it’s reshaping the way industries think about control, optimization, and innovation.

For a deeper dive into this topic, read the full article.

This blog was generated with assistance from Copilot for Microsoft 365.

POC Post-Production: Tracking for ML Observability

Mon, 30 Dec 2024 14:42:10 GMT

Moving Your ML Proof of Concept to Production Part 6: Ensuring Smooth Sailing Post-Production

(Source: TensorSpark/stock.adobe.com); generated with AI

After fortifying the machine learning (ML) proof of concept (POC) and launching it into production, the next important steps are planning for its future and ensuring its continued success. Although the bulk of the effort and resources for a project like this will go into the first steps that we covered previously in the series—including determining metrics and objectives, building the dataset, establishing an experiment environment, and developing and deploying the POC model and code—more tasks remain after production.

This final blog will cover what comes right at the “end,” once the project seemingly should be finished. In particular, as the model begins to be used, various elements should be tracked such as input and output data, performance, and any relevant metrics like latency or compute usage. These should then help identify performance issues or data drift, which can be corrected when necessary, by retraining and redeploying the model after establishing that it performs as well as or better than previous versions. This blog highlights important elements to track post-production, some useful tools for this type of monitoring, and strategies for deciding when and how to upgrade model versions as well as for launching them successfully.

Tracking Models

Once a model is in production, as with any piece of software, the typical discussion occurs around what to monitor, particularly in terms of performance and failures. However, with ML, monitoring goes further than just collecting information about things like resource usage or latency. Monitoring for post-production ML that goes beyond these low-level metrics is termed “observability” and is vital for determining not only when and how a model has gone astray but also how to fix it. Tracking for ML observability gives developers the ability to probe the underlying reasons why a model isn’t performing as expected in production. In addition to identifying model drift (when the model’s performance drops or gradually becomes worse over time), tracking under observability can help uncover causes—in particular, data drift. This occurs when the input data in production no longer match the expected data on which the model was trained. For example, a vision model trained to select certain information from scanned documents with the same format suddenly fails because newer documents have a different format.

Beyond data collected for observability and model troubleshooting, lower-level software-type metrics as well as higher-level business key performance indicator (KPI)–based metrics exist. Examples of each type include the following:

Software health—disk usage, error rates, memory, latency, and compute usage
Business value—linked to initial metrics chosen at the start of the POC development (e.g., number of purchases, loan approval rates, and cost savings)
ML observability—typically data-related metrics (e.g., percentage of missing values, type mismatches, or changes in value distributions) or model-related metrics (e.g., precision and recall for classification, mean absolute error or root mean squared error for regression, or top-k accuracy for ranking)

Note that to track model performance or accuracy, the true label or "correct answer" for what the model was trying to predict is also needed. Hence, incorporating a method for users to rate or correct the model's output is vital for capturing that information and ensuring that decisions about model retraining and redeployment can be made.

This may seem like a lot to keep track of post-production, but, fortunately, these monitoring or observability features no longer need to be built from scratch. Many solutions exist across the spectrum of levels of monitoring. For the software-type metrics, tools like Grafana or Datadog integrate well and collect necessary data seamlessly, typically with a helpful user interface on top. Other platforms, like Neptune, Evidently AI, and Arize, cover the more complex ML observability metrics from tracking model performance to providing features that help uncover issues like data drift.

Updating Models and Launching Changes

Updating ML models and launching changes in production requires a strategic approach to ensure optimal performance. Triggers for model updates include significant shifts in input data patterns, declining model accuracy, or the introduction of new features that could enhance predictions. When working with pre-trained or foundation models, like large language models, retraining strategies might involve fine-tuning the model with a smaller, domain-specific dataset or using transfer learning to adapt to new tasks. To safeguard against performance regressions, A/B testing and canary rollouts are effective methods for evaluating the new model. By gradually exposing a small subset of users to the updated model, teams can monitor its performance closely against the existing version, ensuring that the new model meets or exceeds benchmarks before a full deployment. This systematic approach not only mitigates risk but also fosters confidence in the reliability of the ML system. Additionally, monitoring KPIs throughout the process and having a rollback plan in place to revert quickly to the previous model if needed is crucial.

Conclusion

As you transition your successful ML POC to a fully operational production model, establishing a comprehensive strategy for ongoing monitoring and updates is essential. In particular, the key elements to monitor post-production include various metrics across several levels, from software performance to ML observability to business value, with particular attention toward ML-critical aspects such as data drift and model performance. Leveraging existing observability tools will accelerate the post-production work as well. Strategies for determining when to retrain models and best practices for testing new versions will ensure that your ML system remains effective and resilient over time.

Throughout this series, we’ve explored the critical steps necessary for a successful ML project, from setting goals and metrics to preparing datasets and developing the initial POC model. With this final blog, you should have all the knowledge and guidance you need to bring your ML ideas to fruition.

New Tech Tuesdays: Separating Signals from Noise

Tue, 12 Nov 2024 06:01:00 GMT

The 14-Bit Difference

New Tech Tuesdays

Join Rudy Ramos for a weekly look at all things interesting, new, and noteworthy for design engineers.

I am a big proponent of using the right tool for the job. My father instilled this in me, and I have instilled it in my son. Failing to do so will lead to valuable, albeit hard-earned, experience. Trust me, I’ve learned this lesson the hard way. Your future self will thank you.

As Abraham Maslow wrote, “If all you have is a hammer, everything looks like a nail."^[1] Working without the proper tools often leads to frustration, delays, increased costs, quality issues, and accidents. For example, a house inspector using a smartphone light instead of a proper flashlight could result in costly repairs for the new homeowner. Likewise, a mechanic who exclusively uses a 12V tester to diagnose an electric vehicle's (EV) problems is likely to experience prolonged troubleshooting, only to arrive at an incomplete diagnosis.

It is no different for engineers needing to test, characterize, and debug their latest circuit designs, especially because devices have become exponentially smaller and operate at ultra-low voltages. Using the proper test equipment is crucial early in the product design and development stages. Otherwise, engineers risk affecting signal integrity and causing delays, cost overruns, quality issues, or even product recalls.

In this week’s New Tech Tuesday, we look at high-performance test equipment from Keysight that enables engineers to design, test, and debug their newest designs with confidence and precision.

The Newest Products for Your Newest Designs^®

The Keysight InfiniiVision HD3 Series (Figure 1) marks a significant technological leap with its advanced 14-bit analog-to-digital converters (ADCs).^[2] These ADCs are capable of encoding analog inputs into 16,384 distinct levels, providing four times the resolution compared to the traditional 12-bit ADCs, which manage only 4,096 levels. This enhanced resolution is crucial in capturing finer details in waveform signals, particularly in complex electronic circuit designs.

Figure 1: The newest generation of Keysight’s InfiniiVision oscilloscopes, the HD3 Series, offers precision measurements from 200MHz to 1GHz in a portable form factor. (Source: Mouser Electronics)

One of the standout features of the Keysight InfiniiVision HD3 oscilloscope is its exceptionally low noise floor of 50µV_RMS at a bandwidth of 1GHz. This low noise floor minimizes the oscilloscope's impact on measurements, allowing for more accurate and reliable data. Engineers can also utilize bandwidth limiting and waveform averaging to reduce noise further, thereby enhancing the quality of the signal analysis.

Tuesday’s Takeaway

As miniaturization of electronic components advances, the importance of using the right test equipment becomes crucial. High-performance testing tools like the Keysight InfiniiVision HD3 series oscilloscopes enable engineers to tackle modern circuit design challenges with precision. The HD3 equips them to capture, analyze, and debug minute signal anomalies, ensuring optimal functionality and reliability in complex devices.

Sources

[1] https://www.memic.com/workplace-safety/safety-net-blog/the-right-tool-for-the-job
[2] https://www.keysight.com/us/en/products/oscilloscopes/infiniivision-2-4-channel-digital-oscilloscopes/infiniivision-hd3-series-oscilloscopes.html

New Tech Tuesdays: The Slow Decline of Voice Assistants

Tue, 05 Nov 2024 13:13:48 GMT

From Smart to Stagnant: Is the AI Revolution Leaving Them Behind?

New Tech Tuesdays

Join Rudy Ramos for a weekly look at all things interesting, new, and noteworthy for design engineers.

In recent years, there has been growing frustration among users of voice assistant devices like Google Home, Amazon Alexa, and Apple Siri. What once seemed like intuitive, reliable voice assistants are now sources of aggravation. Users (including myself) report increasingly frequent problems, such as misunderstood commands, inconsistent performance, and confusing responses to even basic requests.^[1] This degeneration in functionality has raised a critical question: Why are voice assistants lagging behind when artificial intelligence (AI) is making big strides in many areas?

In this week's New Tech Tuesday, we explore the declining performance of ubiquitous voice assistants and consider some of the key issues at the root of this decline.

Technical Debt and Software Fragmentation

One of the biggest culprits behind voice assistants' declining performance is the accumulation of technical debt. Technical debt occurs when developers prioritize rapid feature releases over proper system maintenance and optimization. This leads to complex, bloated software that is difficult to update or debug without breaking functionality. Related, software fragmentation is a result of multiple poorly integrated changes over time, further contributing to this decline and the accumulation of more technical debt.^[2]

AI Expansion

Over the last few years, AI chatbots such as ChatGPT, Gemini, and CoPilot have significantly advanced natural language processing (NLP), image recognition, and predictive analytics. The accelerated proliferation of these chatbots has led to quick acceptance across horizontal market sectors, including the smart home. Most of these chatbots offer edge-based options that run on current hardware, enabling them to quickly respond to commands.

In contrast, voice assistants typically run on legacy hardware and rely on cloud-based processing for many of their features. Latency, stable internet connectivity, and cloud integration are all factors that limit their capacity for real-time responses.

Hardware Limitations, Lack of Updates, and Obsolescence

Outdated hardware is another source of users' frustration. Many voice assistant devices have remained on the market with minimal hardware updates. While the software has evolved, the hardware has not kept pace, leading to a mismatch between the capabilities of the AI and the processing power of the device. In many cases, users must reset their devices frequently, as older hardware struggles to keep up with the demands of newer software updates.

Privacy Concerns and Reduced Functionality

Data privacy scrutiny in regions like the EU and the US has also contributed to the reduced functionality of smart home assistants. Companies are balancing convenience with stricter privacy laws, which, in turn, affects features like voice recognition and personalized responses. This trade-off makes devices less responsive and less capable of learning user habits, resulting in a more generic user experience.

The Newest Products for Your Newest Designs^®

This week’s New Tech Tuesday features product development tools from DFRobot and Arduino that can help design engineers build next-gen home assistants.

DFRobot’s LattePanda Mu Micro x86 compute module packs an Intel^® N100 quad-core processor, 8GB of LPDDR5 RAM, and 64GB of storage. Connectivity options include three HDMI/DisplayPort outputs, up to eight USB 2.0 pins, up to four USB 3.2 pins, and nine PCIe 3.0 lanes. This module is ideal for designing handheld devices, AI robots, IoT projects, edge computing, voice recognition, and cloud machine learning.

The Arduino Portenta Environmental Monitoring Bundle is a versatile toolkit designed for developers, researchers, and hobbyists interested in building sophisticated environmental monitoring applications. The kit includes the powerful Arduino Portenta C33 system-on-module (SoM) and an Arduino Nicla Sense Env board with a temperature and humidity sensor, indoor air quality sensor, and outdoor air monitoring (NO₂, O₃) sensor. The Portenta Environmental Monitoring Bundle offers a combination of sensor integration, edge computing capabilities, wireless connectivity, and IoT compatibility that make it a powerful tool for real-time, location-based environmental data collection and analysis in applications such as smart cities, agriculture, indoor air quality monitoring, healthcare, and environmental research.

Tuesday’s Takeaway

While AI is advancing in industries like healthcare, finance, and automation, the voice assistant market is facing challenges like technical debt, software fragmentation, cloud reliance, evolving natural language models, outdated hardware, and privacy concerns, all contributing to the user’s satisfaction decline, and questioning if voice assistants have reached their peak.

Sources:

[1] https://www.googlenestcommunity.com/t5/Speakers-and-Displays/Google-Home-assistant-is-getting-worse-and-worse/m-p/457868#M87618
[2] https://asana.com/resources/technical-debt

AI, IoT, and Sustainability at embedded world North America 2024

Fri, 18 Oct 2024 14:03:05 GMT

The first North American embedded world conference has come to a close. As always, the multi-day exhibition brought together some of the world's leading embedded systems design and development experts.

Attendees who visited were able to explore the latest embedded tools and products while learning more about application and prototype development through Mouser’s Empowering Innovation Together series. They were also given a firsthand look at the new Circuit Showdown competition—a design contest where three engineering students battle it out, designing innovative projects under tight deadlines.

Of course, Mouser also showcased a wide range of products via a “Spin-to-Win” game and retro arcade with “Pick, Pack, Stack.”

As for the show itself, we previously set the stage for this first-of-its-kind embedded world. Here, we look closer at some of the key takeaways from last week’s exhibition and conference in Austin, Texas.

Highlights From The Conference

As expected, open-source technology and artificial intelligence (AI) played major roles in the conference, with topics ranging from sustainability and edge processing to cyber resilience.

Building a Foundation for Sustainable Development

One of the conference’s keynotes, hosted by Kate Stewart, VP of Dependable Embedded Systems at The Linux Foundation, discussed how open-source projects will be central to achieving the UN’s climate goals. The UN’s Department of Economic and Social Affairs set ambitious targets with its 2030 Agenda for Sustainable Development, including objectives that provide clean and affordable energy and create more sustainable communities.

Stewart examined how open-source technologies can support sustainable research and development with products that conserve natural resources. The keynote also covered implementation strategies, requirements, and potential challenges. Particular focus was given to The Linux Foundation’s Zephyr Project, an open-source real-time operating system (RTOS) designed for resource-constrained devices like microcontrollers.

Revolutionizing Low-Level IoT Development

One use case for the Zephyr RTOS revealed around the conference came courtesy of the BeagleBoard.org Foundation. Based on the Texas Instruments SimpleLink^™ CC1352P7 microcontroller, BeagleConnect™ Freedom eliminates low-level software development for Internet of Things (IoT) and Industrial Internet of Things (IIoT) applications. Developers working with use cases such as building automation have traditionally relied on multiple microcontroller software libraries to support devices like sensors and actuators and enable network communication.

BeagleConnect Freedom offloads this burden onto Zephyr. Compatible with all BeagleConnect-enabled sub-GHz wireless gateways, the board can be used with over a thousand MikroBUS™-based click boards. It also provides Bluetooth^® Low Energy-enabled Linux computers at 2.4GHz and long-range, low-power sub-GHz IEEE 802.15.4 wireless connections at up to 1km with data rates of 1kbps.

Enabling Low-Power Artificial Intelligence at the Edge

When it comes to AI, one point discussed at the show was its intense hunger for resources. For example, AI adoption in the United States is expected to more than triple the power usage of data centers by 2030.^[1] Developers looking to incorporate AI technology into resource-constrained edge systems have their work cut out for them.

The tinyML foundation seeks to change that. By enabling global collaboration between industry leaders, academics, and policymakers, the non-profit organization has spurred the development of new model architectures, software orchestration functionality, and semiconductor capabilities. A fireside chat between tinyML’s Pete Bernard and Qualcomm’s Nakul Duggal explored some of these innovations, which included an ultra-low-power neuromorphic microcontroller, automated model discovery for edge devices, and new systems-on-chip (SoCs), systems, and solutions developed specifically for edge AI.

ST Microelectronics, for example, unveiled a new family of 32-bit high-performance microcontrollers that combine real-time capabilities, digital signal processing, low power usage, and low voltage operation.

Supporting Smarter Edge Security

Another topic featured at embedded world North America was how designers and engineers must build from a secure foundation to protect embedded systems from malicious actors. But what happens once those systems are deployed? How do we prevent these actors from finding and exploiting a previously undetected vulnerability?

To answer this question, Tanmaya Mishra of Analog Devices (ADI) talked about how machine learning can enable cyber resilience in microcontrollers, explaining how AI can help automatically identify and remediate intrusion attempts for edge devices. Mishra outlined how ADI’s solution acts as a digital immune system, dealing with most intrusion attempts without human intervention. This spares security teams from the workload associated with monitoring a massive network of connected endpoints.

Charting a Course for 2025

The 2024 embedded world North America conference provided an optimistic vision of what the technology industry can expect in the coming year. Supported by open-source hardware and software and new processor architectures, we will likely see a greater focus on sustainable development and design. Along the way, we will get a firsthand look at AI, further advances in the realm of sustainability, and improvements in everything from open source to security as we develop new ways to support technology at the edge.

Sources

[1] https://www.mckinsey.com/industries/private-capital/our-insights/how-data-centers-and-the-energy-sector-can-sate-ais-hunger-for-power.

Key Trends Shaping the Future of Embedded Systems

Wed, 25 Sep 2024 05:01:00 GMT

Embedded Systems Trends

embedded world is coming to North America for the first time—and Mouser Electronics is excited to announce that we will be there as an exhibitor.

Founded in 2003, embedded world is the industry’s foremost trade show. The conference brings together the world's top embedded system experts, designers, and developers to discuss everything from components to software design. embedded world North America debuts in Austin, Texas, from Tuesday, October 8 to Thursday, October 10.

Attendees can expect expert lectures and panels, plus ample opportunities for insightful discussions with embedded technology leaders. At Mouser Booth #2215, attendees will find inspiration for their next embedded project. Mouser representatives will be on hand to help visitors discover the newest and widest selection of embedded products available today, as well as the online tools and technical information needed to accelerate design. In addition, the booth will feature a gaming kiosk and a video from the first episode of the new design competition, “Circuit Showdown.”

In preparation for embedded world North America 2024, this blog presents a snapshot of some key trends in embedded technology that will be showcased at this year’s event.

Surveying the Embedded Landscape

The technologies showcased at the Mouser booth reflect significant trends in today’s embedded industry. Here are some of the key themes to watch for at the show.

Artificial Intelligence (AI)

AI has become a cornerstone of the embedded industry, with its potential applications expanding rapidly as embedded processors evolve to better support the technology.

Computer vision exemplifies this trend, finding applications in diverse areas, such as authentication in secure facilities and defect detection in manufacturing processes. Another significant application is sensor fusion, where AI algorithms combine data from multiple embedded sensors to enhance accuracy, precision, and reliability. In the realm of maintenance, AI enables predictive strategies, allowing manufacturers to proactively identify system components approaching failure.

Generative AI (GenAI), a subset of AI focused on creating new content, presents even more transformative possibilities. Example applications include natural language processing (NLP), AI-enhanced code generation, and synthetic data creation to train traditional machine learning algorithms.

Open-Source and Interoperability

Open-source technologies are a hotbed of innovation within the embedded industry. The Zephyr Project, for instance, is a scalable real-time operating system designed specifically for resource-constrained environments. With support for over 170 hardware devices and a wide range of use cases, the project is also supported by a robust and active community that regularly incorporates a wide range of improvements.

Specialized open-source hardware licenses such as CERN and TAPR also exist, which aligns with original equipment manufacturers (OEMs) increasingly embracing greater interoperability in their hardware designs.

Cybersecurity Concerns

Protecting embedded systems against malicious actors requires more than security software. Designers and engineers must bake security directly into embedded hardware with technologies such as secure boot, cryptographic processing, attestation, random number generation, and physical tamper monitoring. Security must also be part of software development and lifecycle management.

Quantum computing represents one of the most significant emerging challenges for embedded system security. Quantum computers will potentially render traditional cryptography obsolete, easily breaking even complex encryption. Developers will need to find a way to incorporate post-quantum encryption into their systems to protect against both quantum systems and traditional intrusion tactics.

Complex Communication

Embedded system communication is deceptively complex. On the one hand, a standard array of connectivity technologies exists, such as 5G, Wi-Fi^®, Bluetooth^®, Ethernet, Zigbee, and low-power wide-area network (LPWAN). On the other hand, there is a massive list of embedded communication protocols,^[1] each with its own set of rules.

This complexity makes interoperability something of a logistical nightmare. Fortunately, communication standards that address this complexity have begun to emerge. Keeping track of these evolving and emerging standards will be essential for embedded system designers and developers.

Human-Machine Interface (HMI)

Even an embedded system designed to operate largely autonomously will, at some point, need to be configured or accessed by a human. A well-designed user interface is a must for these scenarios. Numerous frameworks already exist to facilitate the development of human-machine interaction, including Crank, Qt, LVGL, TouchGFX, SLint, Crank, and Flutter.

Designers will need to learn about these HMI frameworks to decide which is best suited for their use case. AI also has the potential to play a part by enabling dynamic personalization for embedded GUIs.

embedded world North America 2024

The 2024 North American embedded world conference will help define the course for the embedded industry in 2025. This year's event will feature keynotes hosted by Silicon Labs and The Linux Foundation, as well as multiple expert panels, technical presentations, and product showcases.

Attendees are invited to visit the Mouser Booth #2215 at the Austin Convention Center in Austin, Texas, from Tuesday, October 8 to Thursday, October 10. Stop by to discover the latest products, online tools, and technical information to help accelerate embedded design. Also, catch a sneak peek from the first episode of Mouser’s new Circuit Showdown contest. Circuit Showdown pits three university electrical and mechanical engineering students against each other in a design standoff. Additionally, the Mouser booth will include a gaming kiosk where attendees can go head-to-head in the retro arcade stacking game, “Pick, Pack, Stack.” Visitors will also have the chance to win prizes in Mouser's “Spin-to-Win” game and sign up to win a Bose SoundLink Max Portable Speaker.

To learn more about embedded world North America 2024, view the schedule, or register, visit Mouser’s embedded world 2024 page.

Sources:

[1] https://www.theiotacademy.co/blog/communication-protocols-in-embedded-systems/

Open Source for ML Modeling

Fri, 30 Aug 2024 18:37:53 GMT

Moving Your ML Proof of Concept to Production Part 4: Leveraging Existing Resources

(Source: ArtemisDiana/stock.adobe.com)

While machine learning (ML) may seem complicated and time-consuming for novel research in the field, often the opposite is true for building a proof of concept (POC). The purpose of a POC is to demonstrate rapidly that an application or idea is feasible with ML, which does not need to be done from scratch. Instead of training the model or producing anything completely new, one can leverage existing third-party or open source resources.

This series on implementing an ML POC has discussed translating business objectives to ML metrics, building a project-specific dataset, and structuring the experimentation environment. Now, we will discuss how to put those stages to use in developing the POC model. Revisiting the initial project roadmap will offer a guide on how to approach development, particularly in terms of when to leverage the many available resources in the ML ecosystem that are constantly being updated. This article describes some of the key tools, software packages, and pre-trained model hubs that help build an ML POC successfully.

Revisiting the Roadmap

To develop a model that performs well enough to be considered a successful POC, one should look at the initial roadmap that was made while translating objectives into metrics. This typically begins with off-the-shelf models or those available via a third-party application programming interface (API), if allowable in the business context. Next, the roadmap moves to architectures or pre-trained models that can be adjusted via fine-tuning or retraining for the particular task, before finishing with those that need to be implemented from scratch with perhaps more complicated training regimes. Fortunately, with the growth of the ML ecosystem, many tools, resources, software libraries, and even open-source research papers with code repositories can be modified as needed for each stage.

Leveraging Existing Resources

Sufficiently demonstrating the use of ML for a particular application doesn’t need to start from scratch or even involve training an ML model if performance can be shown through other means. Therefore, one should certainly use existing tools and pre-trained models if possible. Across all ML domains—such as computer vision (CV), time series prediction, regression, and natural language processing (NLP)—a variety of third-party and open source software packages and models or paid service options are available to bootstrap an ML POC. They vary in their ease of use, expertise needed to operate or integrate them, amount of data required, and their flexibility or customizability for new tasks. Most will be compatible with the experimentation environment created in the previous POC stages.

Pre-Built Options

Roughly speaking, the more pre-packaged a tool or model is, the less flexible it is in terms of retraining for new tasks—but this is less of an issue when the task is not highly bespoke, data sparse, or complex. For example, CV models used for object detection are generally available with cloud providers like Cloud Vision by Google or Rekognition by Amazon Web Services. They are likely to perform well at identifying common objects like produce items on a conveyor belt or in a warehouse but would struggle with highly specific tasks like defect detection without more data and fine-tuning where the services allow.

Typically trained on millions of data points, these foundation models are served with APIs or interactive user interfaces, which means that they are easier to use and still perform well on a variety of tasks. They are accessed most commonly through cloud providers (for the different ML domains like NLP or CV), but other companies have them too. For example, OpenAI has large language models (LLMs) for NLP, such as GPT-4, as well as Whisper for speech recognition. With these tools, the user does not have the burden of developing infrastructure for training and then hosting the model for further use. Additionally, these tools remove the risk of the POC dataset not containing enough data for the task.

DIY Options

In the cases where these types of pre-built, pre-packaged tools do not work well enough to complete the POC, are too expensive, or are prohibited due to privacy or network considerations, other options are available. However, they may require the user to have more expertise, develop infrastructure, or have more data for training. Several large software players in the ML ecosystem have open-source hubs for pre-trained models that can be downloaded, with further code written to repurpose and retrain them for different tasks.

In particular, Hugging Face is one of the most popular open-source platforms, with models across all domains available for free reuse, architecture documentation on how they work, and code snippets showing how to use and modify them. Another popular option is Google’s TensorFlow Hub. Even Meta and Microsoft have thrown their hats into the ring by releasing different open-source models. Depending on the size of the model chosen and the degree of modification needed, complete retraining, training from scratch, or additional infrastructure might be required (as might ML engineering expertise). For the ambitious user, solutions might also be found on arXiv, an open library of frequently updated academic papers that describe novel ML approaches, often with code repositories used to demonstrate the reproducibility of the research.

Conclusion

When launching the ML development portion of POC-building, one should revisit the initial roadmap created during the stages of generating metrics and project specifications. Resources exist for each stage in that roadmap—from easy-to-use but potentially less flexible or performant third-party models to more complex but customizable software packages that can be fit for purpose as needed. Fortunately, with the maturity of the ML ecosystem, several high-quality software tools can be deployed and connected easily to cover all aspects of the ML development life cycle. This is even the case for newer models like LLMs.

So far, this series has covered four important first steps to success with an ML project: establishing goals and translating them to metrics, getting the dataset ready, creating a development environment to ensure reliability, and in this blog, developing the POC model. Keep following to learn the remaining stages of developing an ML POC and putting the results into production. The remaining blogs will cover important guidelines for extending the POC developed in this stage to a production-ready version and advice about what to anticipate and monitor post-deployment, especially regarding updating the model.

New Tech Tuesdays: Genesis of ChatGPT: A Revolutionary AI Chatbot

Tue, 09 Apr 2024 05:01:00 GMT

New Tech Tuesdays

Join Rudy Ramos for a weekly look at all things interesting, new, and noteworthy for design engineers.

The advent of ChatGPT has marked a pivotal moment in the development of artificial intelligence (AI). This language model has taken the world by storm, showcasing AI’s incredible potential to revolutionize various aspects of our lives. Chances are that by now, you have encountered the emergence of AI chatbots and are probably wondering how these have grown so quickly, and where they will go.

In this week’s New Tech Tuesday, we examine the rise of ChatGPT and explore its impact on the evolution of AI and diverse applications across various industries.

ChatGPT: A Journey of Progress and Potential

ChatGPT, developed by OpenAI, has captivated the tech world with its remarkable ability to understand and respond to human language in a conversational manner. Since its release in November 2022, ChatGPT has garnered immense popularity, attracting over one million users within just five days.^[1] This AI generative pre-trained transformer (GPT) chatbot, particularly GPT-4, is built upon the foundation of large language models (LLMs).

ChatGPT utilizes transformer-based models, a type of neural network architecture, to process and generate human language. Deep learning is a subset of machine learning (ML) that employs artificial neural networks (ANNs) with representation learning techniques (Figure 1). These advanced techniques allow the algorithms to progressively extract higher-level features and meaningful patterns from the raw data to create representations that reveal detailed hidden features that are easier to understand and process.

Figure 1: Deep learning is a subset of machine learning that extends the feature extraction process for more advanced classification. (Source: VectorMine/stock.adobe.com)

However, the use of these AI tools is not without drawbacks. Numerous ethical considerations exist, ranging from corporate security and data leakage to individual confidentiality and privacy, intellectual property issues, social justice, safety, bias, responsibility, autonomy and compliance, and constraints on future AI growth.^[2]

AI Chatbot Applications Transforming Industries

Already, AI chatbots have demonstrated their versatility by finding applications in a wide range of industries. For example, ChatGPT's ability to understand and respond to customer inquiries has made it a valuable tool for automating customer service tasks, improving response times, and enhancing customer satisfaction.

AI chatbots have the potential to revolutionize education by providing personalized tutoring assistance, generating educational content, and facilitating interactive learning experiences. In the business world, for instance, ChatGPT can automate various tasks, such as drafting emails, analyzing data, and generating reports that help improve productivity and efficiency in the workplace. The healthcare industry is already starting to reap the benefits of AIs. ChatGPT has applications in clinical decision support, medical recordkeeping, and analyzing medical literature, aiding healthcare professionals in providing better care to patients.

The Future of ChatGPT and AI Development

ChatGPT will likely continue to improve its capabilities, becoming even more accurate, comprehensive, and diverse in its responses. Some of the key driving factors behind this rise in AI-powered chatbots include the proliferation of development tools, the closer relationship between software and electronics, and the complexities of modern applications lending themselves to the sharing of information and the need for solutions to difficult problems.

In the coming years, it is highly probable that the electronics industry will be greatly influenced by open-source AI software solutions and related hardware.

The Newest Products for Your Newest Designs^®

This week's New Tech Tuesday features a product from Seeed Studio that offers the ability to bring imaginative AI concepts to life.

The Seeed Studio NVIDIA Jetson Orin Nano 8GB Developer Kit offers engineers and developers a robust platform for AI projects. With its compact size and powerful Jetson Orin Nano 8GB module, delivering up to 40 TOPS AI performance, this kit is an excellent choice for edge AI applications. Its ease of use simplifies the development process, allowing quick prototyping and testing of AI algorithms. Additionally, the kit supports running modern AI models efficiently, making it suitable for a wide range of applications.

Tuesday’s Takeaway

ChatGPT's journey has just begun, and its potential for further development is vast. We can anticipate ongoing evolution and progress in the field of AI, with ChatGPT and similar AI chatbots playing a pivotal role in reshaping our world in profound ways. From transforming the way we interact with technology and communicate with each other to helping humanity solve many of its complex problems.

Sources:

[1] “ChatGPT Crosses 1 Million Users Five Days after Launch - Tech Startups,” December 5, 2022, https://techstartups.com/2022/12/05/chatgpt-crosses-1-million-users-five-days-launch/.
[2] Jerry Cuomo, “Exploring the Risks and Alternatives of ChatGPT: Paving a Path to Trustworthy AI,” IBM Blog, August 16, 2023, https://www.ibm.com/blog/exploring-the-risks-and-alternatives-of-chatgpt-paving-a-path-to-trustworthy-ai/.

Open Source and the Electronics Industry

Thu, 29 Feb 2024 23:41:39 GMT

Exploring the Relationship between the Electronics Industry and Open Source: Q&A with Adam Taylor

(Source: Steve /stock.adobe.com)

As embedded and miniaturized hardware solutions continue to advance, an increasing number of developers are opting for standardized open-source or license-free software solutions. Mouser Electronics and Adam Taylor, founder and lead consultant of Adiuvo Engineering & Training Ltd., discuss how open-source solutions impact the electronics sector and explore what the future could hold.

Adam Taylor is a professor of embedded systems, engineering leader, and world-recognized expert in FPGA/System on Chip and Electronic Design.

"Open source" can have different interpretations depending on your background. How do you define it within the electronics industry and from an electronics engineer’s point of view? What do you see as the pros and cons of open source?

It is an interesting topic to define, especially when separated from the software side. Open source is undeniably advantageous, as it enables shared knowledge and collaboration in a practical manner. It also enables the ability to explore existing designs and utilize them as a foundation or for inspiration.

However, one of the biggest issues with open source, especially in the world of electronics, is the surrounding confusion. There are varying degrees of permissions at the licensing level, which contributes to the complexity and misunderstandings; some licensed solutions provide complete freedom, whereas licenses like copyleft can be quite restrictive for certain applications. For smaller companies, this can be a major barrier as they may not have the resources to investigate where they stand legally in terms of usage.

Engineers often believe that every project is entirely unique. But in reality, even the most cutting-edge designs will incorporate ideas or components from other existing projects, and it is here where open source can foster collaboration and cooperation. Embracing open source provides engineers with the opportunity to leverage the knowledge of others, enhancing the potential benefits for their own projects.

How can an open-source solution impact product development?

Open-source initiatives allow engineers to build off existing ideas, whether these are development tools or electronic devices. With open source, engineers usually have a greater support network and larger working communities that can support when a problem or application arises. Essentially, open source significantly streamlines and enhances project development.

Open-source applications can also have a significant impact in terms of quality and compliance. In a closed-source environment, new designs have to undergo extensive internal checks. However, in an open-source environment, reputable designs have already passed through the scrutiny of several engineers. While this may not be sufficient for full validation in highly stringent applications, it can help to streamline the process.

From a business perspective, creating a strong product traditionally involves unique selling points and intellectual property. Are open-source solutions truly viable for market-ready products?

This is the major concern that can turn engineers away from open-source solutions. From a business standpoint, there is a concern about seeing no return on investment. Individuals are often unwilling to invest time and resources in open-source projects without seeing any benefits.

Looking at Adiuvo, for example, there is a real benefit in using open source to add value to a product or solution. With one of the new field-programmable gate arrays (FPGA) development boards, the schematic and layout will be open source to enhance the value of the product. The aim of incorporating open source as part of the business model is to appeal to engineers by making their jobs easier.

Open source needs to be a middle ground. As a business, you can make elements open-source and invite engineers in, but you have to be careful. There is not a one-size-fits-all solution for making open source a part of your business model.

What are examples you recognize as successful open-source electronics solutions, and where are these impacting the market? Are we looking at development solutions or final products?

Most developments in the FPGA market are focused on software and development tools, rather than providing a ready-to-use hardware solution or components that engineers can drop straight into their application.

This trend is similar to the impact that open-source solutions like compilers have had on the software industry. It is expected that this shift will also affect the development of hardware such as FPGAs, system-on-chips (SoCs), microcontroller units (MCUs), and more, where engineers add value from the application of the hardware, rather than the hardware itself.

How do broader industry-backed open-source solutions like Zephyr and Matter fit in, and what impact do they have on the electronics industry?

Evaluating embedded Linux as an example, this is an area where open source is thriving. For years, engineers have been doing very similar things in terms of the application and its requirements, using the same source or kernel but approaching it in a completely different way.

These varying approaches create a few issues, but one of the main ones is the portability of software engineers. Different approaches make it challenging for software personnel to switch projects or companies. This results in unnecessary training and redundant work by highly skilled individuals, as well as harming interoperability.

The Linux Foundation Yocto Project is a perfect example of widespread collaboration. It enables individuals to build embedded Linux solutions using a standardized approach, resulting in decreased deployment time and expenses while also fostering best practices. Other industry-supported solutions like Zephyr and Matter have been influenced by the success of Yocto. Its results showed that producing industry-focused contributions can positively impact businesses, end user’s projects, and the entire engineering community.

Has the rise of IoT and IIoT smart devices, with a focus on interoperability, impacted industry-supported open-source solutions?

Yes, but this is a component of a bigger theme, which is the search for standardization. While engineers like to start from scratch, this is not always the best way to go about development for the end user—especially in terms of smart homes or connected services.

Evaluating Matter as an example, the reason it is successful is more tied to its ability to get companies to agree on a standard, rather than it necessarily being open source. A closed-source free standard could easily have the same impact, so it is the standardization with low cost of entry that is the critical factor, rather than if it is open or closed source.

What are your thoughts on hybrid approaches that involve a fusion of open-source and closed-source solutions, and how do these approaches benefit both suppliers and developers?

At the heart of being an engineer is the ability to identify or create the perfect solution for a particular use, delivering it on time, to a high quality, and within budget. This hybrid approach truly embodies this principle and is increasing in popularity across the industry. As long as licensing rules are adhered to, it is a sensible way to conduct business.

When delving into many open-source hardware solutions, they typically involve a hybrid approach. Looking back at the Linux example, many Yocto-based solutions are running on closed-source hardware. Similarly, many larger open-source hardware solutions will usually have a closed-source proprietary connector or component in there.

Finally, how do you predict the future market share of the electronics industry in terms of proprietary versus open source?

There will likely be a rise in open-source solutions as there are a number of driving factors, including the proliferation of development tools, the closer relationship between software and electronics, and the complexities of modern applications lending themselves to the sharing of information.

Twenty years ago, developing an FPGA solution required a significant financial commitment and a steep learning curve, limiting entry to big companies. Free editors, simulators, and synthesis tools are now available for download, effectively eliminating the entry barrier. Many larger hardware manufacturers are now happy to provide free resources to better support their products, causing a significant shift.

In the coming years, it is highly probable that the electronics industry will be greatly influenced by open-source solutions encompassing software, hardware, and AI.

Edge Impulse Fundamentals Part Eight

Mon, 15 Jan 2024 14:29:00 GMT

Edge Impulse #8: Model Versioning and Deployment

(Source: photon_photo- stock.adobe.com)

In the continuously evolving landscape of machine learning (ML) and artificial intelligence (AI), the ability to manage, version, and deploy models efficiently is of paramount importance. Edge Impulse, with its dedication to the realm of edge computing, recognizes these needs and has consequently developed features that make model versioning and deployment not just feasible but also efficient. Let’s delve deep into how Edge Impulse manages these functionalities and why they are crucial for developers and organizations.

Understanding the Importance of Model Versioning

Let’s begin by gaining an understanding of the significance of model versioning (Figure 1). There are many essential aspects of versioning that become increasingly important as we move from prototype to production. Edge Impulse provides:

Iterative Development: Machine learning model development is seldom a one-time process. Models are continually refined and retrained to enhance performance, adapt to new data, or meet changing requirements.
Reproducibility: The ability to trace back to a specific version of a model is crucial for scientific studies and commercial applications.
Accountability: For regulatory or compliance needs, especially in critical sectors like healthcare or finance, it's essential to document the evolution of models and be able to revert or audit a particular version if needed.
Collective Development: In team settings, multiple data scientists might work on different versions of a model, necessitating a system that manages concurrent versions and integrates them seamlessly.

Figure 1: ML model version control is built into Edge Impulse Studio, making configuration management more attainable. (Source: Green Shoe Garage)

Model Versioning with Edge Impulse

For designers, developing ML models requires configuration management that is adaptable and efficiently integrates as requirements change. Recognizing these needs, Edge Impulse has incorporated features that enable effective model versioning:

Snapshot Creation: Edge Impulse allows users to create snapshots of their projects at any point. This means that after training a model or making significant modifications, a snapshot can be taken, preserving that specific state for future reference or deployment.
Descriptive Metadata: Along with snapshots, users can add metadata, such as notes or tags, to provide context or mark significant milestones. This ensures that versions aren't just identifiable by timestamps but also by their characteristics or relevance.
Seamless Switching: With the stored versions, users can effortlessly switch between different model versions, allowing them to compare performances, revert to earlier versions, or branch off from a specific point.
Collaborative Features: Versioning in Edge Impulse is designed with collaboration in mind. Different team members can work on their versions, merge changes, or build upon each other’s work without overwriting or losing information.

Model Deployment with Edge Impulse

Once a model is developed, refined, and versioned, the next step is deployment. Deploying machine learning models, especially on edge devices, comes with its unique set of challenges. Edge Impulse’s deployment strategy addresses the following challenges:

Optimized for Edge: Edge Impulse's deployment mechanism is tailored for edge devices. Recognizing the constraints of these devices, models are optimized to be lightweight while retaining efficacy.
Diverse Platform Support: Whether it's an IoT device, a mobile phone, or a microcontroller, Edge Impulse offers deployment solutions tailored for various platforms, ensuring broad applicability.
Integration with TensorFlow Lite: Edge Impulse supports TensorFlow Lite Micro, making it easy to deploy models on devices with minimal overhead and maximal compatibility.
Over-the-Air Deployment: Edge Impulse supports Over-the-Air (OTA) deployment for devices connected to the internet (Figure 2). This means updated or refined models can be pushed to devices remotely, ensuring they remain updated without manual intervention.

Figure 2: Edge Impulse allows for Over-the-Air updates to edge devices via cloud connectivity. (Source: Green Shoe Garage)

Standalone Libraries: Edge Impulse provides the option to export models as standalone libraries. This ensures that developers can integrate them into their applications or platforms seamlessly.
WebAssembly Deployment: Edge Impulse supports deployment via WebAssembly for web-based applications. This means models can be run directly in browsers, making them accessible to a broad audience without platform-specific constraints.

Versioning and Deployment Together

While versioning and deployment might seem like distinct phases, they are intrinsically linked in a number of ways:

Streamlined Workflow: The workflow becomes streamlined with versioning and deployment features integrated into one platform. Once a model version is finalized, it can be deployed immediately without juggling between different tools or platforms.
Quality Assurance: Before deploying a new version, teams can revert to previous model versions, run tests, and ensure that the new version offers improvements. This iterative testing and deployment process ensures higher quality in real-world applications.
Feedback Loop: Once a model is deployed, it might gather new data or feedback. This can be used to refine the model further. With integrated versioning, this feedback can lead to the creation of a new version, which, after refinement, can again be deployed. This continuous feedback loop ensures models remain relevant and adaptive.

Conclusion

In the rapidly progressing world of machine learning on edge devices, platforms like Edge Impulse play a pivotal role in ensuring that the development and deployment processes are efficient, manageable, and scalable. By integrating model versioning and deployment functionalities into a unified platform, Edge Impulse simplifies the workflow for developers. It ensures that models are always at their best when making real-time decisions on edge devices.

Furthermore, in a world where collaboration, accountability, and adaptability are becoming increasingly crucial, features like versioning become valuable and indispensable. As more devices incorporate AI and machine learning capabilities, platforms like Edge Impulse will undoubtedly be at the forefront, shaping the future of intelligent, responsive, and efficient edge devices.

New Tech Tuesdays: Ambient Power: Energy-Harvesting Robots

Tue, 14 Nov 2023 06:01:00 GMT

New Tech Tuesdays

Join Rudy Ramos for a weekly look at all things interesting, new, and noteworthy for design engineers.

In an era marked by the pursuit of sustainable and efficient technological solutions, energy-harvesting robots emerge as a beacon of hope. By extracting power directly from their surroundings, these robots promise a new frontier in autonomous operations, limiting the dependency on traditional charging methods or battery replacements.

Energy-harvesting robots are robots equipped with technology that allows them to generate and store energy from their environment to power their operations. This innovative approach offers several advantages, including increased autonomy and sustainability. Here are several key features of energy-harvesting robots:

Adaptive Morphology: Some robots use adaptive morphology to harvest energy, altering their physical shape to capture and convert energy sources such as sunlight or wind.

Agricultural Robotics: In the agricultural sector, energy-harvesting robots have gained attention for their role in automated farming. These robots may use various energy sources, potentially reducing costs and environmental impact.

Soft Robot Locomotion: Energy harvesting can enhance the efficiency of soft robots during locomotion, with research currently exploring methods to harvest energy used in robot movement.

Tiny Energy-Harvesting Robots: MilliMobile robots represent a smaller-scale example of energy-harvesting robots. These battery-free robots are powered by surrounding light or radio frequency.

Multifunctional Systems: Energy harvesting can be integrated into multifunctional robotic systems, enabling these robots to perform various tasks while maintaining their energy supply.

Ultimately, energy-harvesting robots represent a promising area of research and development, offering potential solutions to the challenges of energy sustainability and autonomous operation in various domains.

Potential Uses for Energy-Harvesting Robots

Energy-harvesting robots find relevance across various industries and applications. Their capability to utilize ambient energy sources allows for prolonged operations, which is especially important in remote or inaccessible areas. These robots are ideal for environmental monitoring—whether it's tracking oceanic patterns by harnessing wave energy or observing wildlife through solar power. Agriculture is another sector ripe for innovation, with robots that can monitor soil conditions or assist in crop cultivation while drawing power from the sun or wind. Moreover, the vast expanse of outer space beckons, with robots exploring celestial bodies using harvested solar energy.

Microrobotics with energy harvesting capabilities have also found applications in disaster relief scenarios. The Defense Advanced Research Projects Agency (DARPA) initiated its Short-Range Independent Microrobotic Platforms (SHRIMP) program with the purpose of advancing microrobots’ functionality by developing improved energy efficiency techniques (Figure 1). With advanced functionality, energy-harvesting microrobots will better perform disaster relief activities in harsh environments.

Figure 1: DARPA’s SHRIMP program develops microrobotics for disaster recovery and high-risk environments. (Source: DARPA)

Challenges Yet to be Surmounted

While the prospects seem boundless, the journey of energy-harvesting robots is not without its hurdles. The energy density from ambient sources often pales in comparison to conventional batteries, limiting the robot's continuous operational capabilities. The inconsistency of environmental energy—be it the sun on a cloudy day or the absence of wind—poses reliability concerns. Additionally, the technology grapples with issues of conversion efficiency, effective energy storage, and the added weight and size of harvesting modules. A balance between sustainability and efficiency remains to be struck.

The Bright Horizon Ahead

Should these challenges be addressed, the future of energy-harvesting robots shines bright. An evolution in materials science or breakthroughs in storage solutions could propel these robots to the forefront of many industries. As the integration of these technologies becomes more seamless, and as efficiency and reliability improve, we could witness an era where robots operate for extended periods without human intervention, all while leaving a minimal carbon footprint.

Featured Products

Redefining traditional charging and battery paradigms requires new products that evolve how we approach power supply and management in the latest designs. This week’s New Tech Tuesday features two products that work toward that effort.

The Vishay / BC Components 230 EDLC-HV ENYCAP^™ polarized energy storage capacitors are high capacity and high density. The double-layer capacitors have a useful life of 2,000 hours at 85°C and an operating voltage of up to 3V. The series features rapid charging and discharging with maintenance-free operation. Power backup, burst power support, and energy recovery are just a few of the applications for the Vishay / BC Components 230 EDLC-HV ENYCAP capacitors.

Next, the TDK BCS Low Illumination Solar Cells are advanced, slim, lightweight, and flexible amorphous silicon-type film solar cells available in circular or quadrangle shapes. They exhibit remarkable power generation efficiency under fluorescent lamps and LED light sources, maintaining consistent output in low and dim lighting conditions. These solar cells reduce battery replacement and wiring costs while helping extend the lifespan of primary batteries and rechargeable devices' operational time. TDK's clean-energy BCS Low Illumination Solar Cells are ideal for environmental energy-harvesting applications.

Tuesday’s Takeaway

Energy-harvesting robots encapsulate the dream of merging sustainability with technological advancement. The emerging research and wide-ranging applications for these robots reveal new directions in power management. While the path is not without its challenges, the potential rewards—in terms of efficiency, sustainability, and innovation—paint a future that's both exciting and promising.

Sources:

Coxworth, Ben. “Tiny energy-harvesting MilliMobile robot has no need for batteries.” New Atlas, September 28, 2023. https://newatlas.com/robotics/energy-harvesting-millimobile-robot/.

Crowe, Steve. “DARPA SHRIMP challenge developing microrobots for disaster relief.” The Robot Report, July 20, 2018. https://www.therobotreport.com/darpa-shrimp-microbots-disaster/.

Ftobe. “The Ultimate Guide to Agricultural Robotics.” Robotics Business Review, January 1, 2017. https://www.roboticsbusinessreview.com/agriculture/the_ultimate_guide_to_agricultural_robotics/#:~:text=Price%3A%20%24250%2C000%20for%20a%20harvester,works%20on%20several%20investment%20paths.

Fu, Yiqiang, Hongqiang Wang, Yunlong Zi, and Xuanquan Liang. “A multifunctional robotic system toward moveable sensing and energy harvesting.” Nano Energy 89, November 2021. https://doi.org/10.1016/j.nanoen.2021.106368.

Katiyar, Shiv A., Loong Yi Lee, Fumiya Iida, and Surya G. Nurzaman. “Energy Harvesting for Robots with Adaptive Morphology.” Soft Robotics 10.2, April 13, 2023: 365–79. https://doi.org/10.1089/soro.2021.0138.

Edge Impulse Fundamentals Part Seven

Wed, 01 Nov 2023 03:55:11 GMT

Edge Impulse Fundamentals 7: Live Classification Tool for Real-World Testing

(Source: Sikov - stock.adobe.com)

Welcome back to our series on Edge Impulse, one of the major players in the world of embedded machine learning specifically designed to provide developers with the tools they need to integrate machine learning capabilities into edge devices. Among their many functionalities, live classification is an essential feature for real-world testing. The live classification feature allows you to validate your model within the browser with data captured directly from any device or supported development board. Thus, live classification eliminates the need to deploy the model with every iteration of your model. To use live classification, you first need to create an impulse, as we discussed in the previous entries in this series. Recall that an impulse is a collection of data, preprocessing blocks, and learning blocks that can be used to classify new data. Once you have created an impulse, you can connect your device to Edge Impulse and start live classification.

Understanding Live Classification

Live classification in the context of Edge Impulse refers to the near real-time, cloud-based processing and analysis of data directly taken from sensors aboard edge devices. When you are in live classification mode, Edge Impulse will continuously stream data from your device and classify it using your model. You can see the classification results in real-time and adjust the thresholds for the classification to improve the accuracy. It can be used to debug your model and identify any problems. Lastly, validating your model with real-world data makes it more likely to perform well for others once deployed.

To enable live classification, you must use one of the supported development boards, a smartphone, or a desktop computer. If you are using a supported development board, it must be connected to an internet-connected desktop computer via USB. The data will stream from the desktop to Edge Impulse ingestion service using the Edge Impulse Command Line Interface (CLI) or Web Serial (WebUSB). The chief advantage of WebUSB is that it can collect data from any fully supported development board straight from your browser without the need to install additional software onto your computer. The data forwarder of the CLI, on the other hand, can be used on any development board beyond those that are officially supported.

Inside Edge Impulse Studio, the live classification tool offers a few settings the developer can tweak. First, you can specify which device to accept incoming data from. If the board has multiple sensors, you can designate which sensor to perform live classification against. Lastly, you can adjust the sample length (in milliseconds) and sample frequency to improve the model performance (Figure 1). Also, recall that every learning block has a threshold. The threshold can be the minimum confidence that a neural network requires or the maximum anomaly score before a sample is tagged as an anomaly. You can configure these thresholds to tweak the sensitivity of these learning blocks. This affects both live classification and model testing.

Figure 1: Live classification tools in Edge Impulse Studio make real-world ML model testing a snap. (Source: Green Shoe Garage)

With the target device connected to the development computer from within Edge Impulse Studio, click the Live classification button. This button is located in the top right corner of the user interface. Once you have clicked on the "Live classification" button, you will need to start streaming data from your device. Your specific method will depend on your device and your development board. Once data is streaming from your device, you will see the classification results in real time (Figure 2). The classification results will be displayed in a table, and they will also be plotted on a graph. Adjust the thresholds for the classification to improve the accuracy. The thresholds for the classification are the values that determine how confident the model must be to make a classification. You can adjust the thresholds to improve the accuracy of the classification.

Figure 2: Live classification results can be reviewed in many ways inside Edge Impulse Studio. (Source: Green Shoe Garage)

Here are some additional tips for performing live classification with Edge Impulse:

Make sure that your device is connected to a stable internet connection. This will ensure that the data is streamed to Edge Impulse without any problems.
Use a large enough dataset for training your model. The more data you use, the better the model will classify new data.
Use a variety of data for training your model. This will help the model to generalize better with new data.
Tune the hyperparameters of your model. The hyperparameters are the settings that control the behavior of the model. Tuning the hyperparameters can improve the accuracy of the model.

Conclusion

Edge Impulse live classification is a powerful tool that can be used to validate and improve the performance of machine learning models for embedded devices. By streaming data from the device in real-time, Edge Impulse allows developers to see how the model is performing and adjust as needed to ensure that the model is ready for deployment and that it will perform well in the real world. In the next entry, we will look at how Edge Impulse supports modern development operations (DevOps) procedures, including version control and secure deployment of trained models from the cloud to edge devices.

New Tech Tuesdays: The Evolution of the Arduino UNO: A Little Marvel of Electronics

Tue, 03 Oct 2023 05:01:00 GMT

Join Rudy Ramos for a weekly look at all things interesting, new, and noteworthy for design engineers.

The Arduino UNO Board, a tiny microcontroller board that packs a punch, has captured the imaginations of hobbyists, educators, and even professionals since its inception. Over the years, it has undergone various iterations, becoming more refined, versatile, and user-friendly.

Born in the picturesque town of Ivrea, Italy, Arduino originated as an inexpensive tool for students. Massimo Banzi and his colleagues introduced the Arduino platform in 2005. It was developed as a simple, open-source electronics platform with a user-friendly software interface for creating digital devices and interactive objects. Arduino has become increasingly popular among hobbyists and professionals and is now used in a variety of applications, from robotics to home automation. Its open-source nature has enabled it to grow into a global community of makers and developers.

Functionality: The Heart and Soul of Arduino

At its core, the Arduino UNO Board is essentially a microcontroller on a circuit board. It interprets and executes written software codes, allowing communication with devices such as sensors, motors, and even other microcontrollers. Due to their simplicity and versatility, Arduino boards have found applications in countless projects, ranging from basic LED displays and complex robots to drones, weather stations, and game controllers.

One of the standout features of the Arduino movement is its commitment to open-source principles. By making hardware design and software libraries open and freely available, Arduino ignited a revolution. This openness fosters a robust community of enthusiasts, educators, and developers. As a result, countless projects, guides, and libraries are available online, making it easier for newcomers to learn and experiment.

Websites such as Maker Pro, Instructibles, Circuit Basics, Hackaday, ElectronicsHub, and YouTube are just a few of a multitude of websites brimming with resources for makers. These sites enable design collaboration, project showcasing, and knowledge sharing. They also offer a space for receiving valuable feedback from a passionate community of enthusiasts.

Impacting the Maker Community

The affordability and accessibility of the Arduino UNO Board spurred a 'Do-It-Yourself' (DIY) culture, particularly within the maker community. Makerspaces and tech workshops worldwide adopted Arduino for its ease of use, leading to a proliferation of prototypes and projects. From creating interactive art installations to building home automation systems, Arduino has become the backbone of countless innovative ideas.

Featured Product

June 2023 saw the latest Arduino UNO REV 4 Boards release in the form of two new flavors: the UNO R4 Minima and UNO R4 Wi-Fi^® (Figure 1). Both new boards mark a departure from the Microchip Technology ATmega4809 8-bit microcontroller used in the previous generation of the UNO. The two new boards now sport a Renesas RA4M1 32-bit 48MHz Arm^® Cortex^®-M4 microcontroller with a floating-point unit (FPU) and 256kB flash, 32kB SRAM, and 8kB data memory (EEPROM), bringing a considerable performance boost for numerous applications. Additionally, the R4 Wi-Fi^® incorporates an Espressif S3 Wi-Fi^® module for Wi-Fi and Bluetooth^® Low Energy connectivity, as well as a bright 12 x 8 red LED matrix, ideal for plotting sensor data without the need for additional display hardware. These new board versions are form factor, pin, and power compatible with the R1 through R3 versions, so they should largely be able to serve as drop-in replacements, which potentially makes them compatible with hundreds of existing third-party shields and other accessories.

Figure 1: Arduino UNO REV 4 Boards powered by the Renesas RA4M1 32-bit 48MHz Arm^® Cortex^®-M4 microcontroller. (Source: Mouser Electronics)

A Bewitching Time Approaches

Autumn's embrace is truly a bewitching time, with the air turning crisp and the leaves painting the earth in hues of gold and crimson. In my corner of the world, the chilling embrace of winter starts to whisper, but not before the spine-tingling celebrations of Halloween take center stage.

As the shadow of Halloween 2023 looms closer, the Arduino UNO R4 Wi-Fi^® presents an intriguing new spectral delight for those looking to add a fear factor to their decorations. One can't help but imagine the eerie and otherworldly creations that will come to life with this technology in hand. Will we see possessed pumpkins sending ghostly messages through the Wi-Fi waves? Or perhaps haunted houses that sync with the digital realm, giving those brave enough to enter an augmented reality fright? The possibilities are as endless as the night is dark.

With such advancements in our grasp, this Halloween promises to be an electrifying blend of traditional spookiness and cutting-edge innovation. So, to all tech witches and wizards out there, ready your cauldrons! The Arduino UNO R4 Wi-Fi^® awaits your darkest and most ingenious incantations.

One of my favorite ghostly Halloween creations comes from a YouTube maker who brewed a spooky concoction of technology and terror! Using the magic of an Arduino UNO, the piercing gaze of a few budget-friendly IR cameras, and the swift motion of a servo motor, this innovator brought their front yard Grim Reaper to life. Beware, trick-or-treaters! As you dare to walk past, the Reaper's head eerily follows along with your every move, ensuring a hauntingly unforgettable All Hallows' Eve experience.

Tuesday’s Takeaway

The Arduino UNO Board's evolution is a testament to the power of open-source collaboration and the spirit of innovation. What started as a modest teaching tool in Italy has blossomed into a global movement, inspiring countless individuals to create, innovate, and share. As we look to the future, the legacy of the Arduino UNO Board serves as a reminder of how democratizing technology can lead to unbridled creativity and progress.

Lastly, as the witching hour nears and the moon rises high, the ghostly glow of innovation lights our path. The tales of Arduino UNO's legacy, combined with the passionate spirit of the maker community, underscore that the future holds infinitely innovative surprises. From bewitching boards to hair-raising hacks, the technological realm is replete with hauntings and trickery. As October 31^st approaches, we eagerly await the dark dance of digital wonders. May your cauldrons bubble with imagination, your spells sparkle with creativity, and may your Halloween be as enchanting as an Arduino-powered Grim Reaper.

Sources

68percentwater. “Arduino and IR camera animatronic Grim Reaper.” YouTube Video, 25:09. January 16, 2022. https://www.youtube.com/watch?v=syvH8i-V0Zk.