Here are three practical ways DMC has used AI and Python to optimize a real-time inspection system and deliver real results to our clients.

1. Profile Your Pipeline to Find the Bottlenecks

As you move from implementation to production, the slower parts of your code can become painful while remaining hidden. In fact, slow lines of code can show up in surprising places and, depending on how your pipeline is structured, have an outsized effect on your speed. The solution is to bring a magnifying glass to your code by profiling it.

I’ve been a heavy user of Jupyter notebooks inside VS Code, which allows me to use the AI coding agent of my choice to easily set up and run experiments against my inspection pipeline to understand how it runs in practice against specific examples and, more relevantly, how long each section of the pipeline takes to run.

For example, one recent system DMC worked on involved belt masking. A client needed to inspect yellow tortillas moving down a blue conveyor belt, so we had to isolate each tortilla on each frame, separating it from the background for later steps in our analysis. The naive-but-useful approach we started with computed a full-resolution color distance, each pixel relative to the average color of the belt. This gave us a reference for what a functionally correct approach looks like, but profiling the code in conversation with AI showed us that it took up the majority of its time analyzing each frame.

2. Redesign Expensive Metrics to be Computationally Cheaper

Once you know which stage is slow, the next lever is the algorithms inside it. Many vision metrics have a naive implementation that’s accurate but expensive, and a smarter implementation that’s nearly as accurate and far faster.

After profiling the inspection system, we looked for ways to optimize it. A faster approach involved shrinking the frame by 50% on each side to reduce the number of computations by 75%. Comparing against the full-frame approach, we saw minimal reduction in accuracy. Additionally, by computing distances, we were performing a square root operation before comparing the distance to a threshold parameter; we could ditch that operation by squaring the threshold parameter and then comparing the squared distance, which sped up the process even further with no reduction in accuracy.

Eventually, we switched from checking RGB color distance to an axis-aligned range, which had similar accuracy while drastically reducing the computational load per frame. AI was vital here for quickly brainstorming and drafting these alternative formulations so we could compare their performance and accuracy.

3. Use Synthetic Data to Stress-Test Thresholds and Edge Cases

Optimization isn’t only about speed; it’s also about ensuring the system remains correct under pressure and across the full range of inputs. It’s hard to verify with only a handful of real images, which is often the case at the pre-deployment stage of a project.

Synthetic data can fill this gap. By generating test subjects across the entire pass/fail spectrum, including rare failure modes, you can stress-test thresholds and confirm the optimized pipeline still behaves correctly on edge cases.

In our example of the tortilla inspection project, we used a Python script to programmatically generate AI images of tortillas with different levels and types of defects by varying the prompts. For example, each tortilla prompt was given a probability of having a prompt addition specifying a torn edge or a burn mark. After generating 100 tortillas, we used another script to create simulated footage of these tortillas moving down a looping belt texture, with added random noise and motion blur, which we then used to verify our pipeline’s capabilities before we had any real footage to work with. These efforts allowed us to deploy our code into production quickly for our client.

Conclusion

These threThese three practices work together to create a more efficient and reliable system:

• Profiling identifies where to focus your optimization efforts.
• Metric redesign speeds up slow stages exposed by your profiling.
• Synthetic data ensures your system remains accurate across edge cases.

Each of these stages has always been essential to vision inspection, but AI and modern coding tools have made them faster and easier to implement. Additionally, unlike certain uses of AI that have greater exposure to risk, like code implementation, using AI here is less likely to cause major faults in your system. That said, AI should be an accelerator, not a replacement for engineering judgment. It is essential to verify that AI-generated code is correct and aligned with system requirements.

Ultimately, the impact of these practices is clear. By combining these approaches, you can confidently improve the speed and reliability of your real-time vision inspection pipeline.

The post 3 Ways AI Improves Real-Time Vision Inspection with Python appeared first on DMC, Inc..

At DMC, we pride ourselves on our technical skillset. AI solutions are just a part of our application development services. From IoT solutions to custom software from scratch, we are ready to tackle any project that comes our way. In this post, we will introduce the fundamentals of Azure AI Vision, facial recognition, and optical character recognition. We will also talk about what an AI Vision solution might look like from DMC. 

What is Azure AI Vision? 

Creating solutions that can “see” the world and interpret it is a core area of artificial intelligence. Computers don’t exactly have eyes, but they are capable of processing info from videos, images, or live camera feeds. 

The architecture for computer vision models is complex and requires significant amounts of training and resources to perform at a high level, i.e. identify objects correctly with confidence. With Azure AI Vision, we can create complex models much quicker and easier than producing one from scratch. While these existing models can be functional out of the box, we can build on top of them to create custom models that fit your exact needs! 

Using these models can be done with ease by provisioning an Azure AI Vision resource in an Azure Subscription, which allows us to use the Azure Portal to easily manage and modify your AI solution. 

What Can Azure AI Vision Do? 

Azure AI Vision offers several image analysis capabilities which include: 

• Extracting text from images using Optical Character Recognition (OCR) 
• Generating captions and descriptions of images 
• Common object detection 
• Tagging visual features 
• Detecting and recognizing faces 

Let’s dive deeper into these capabilities, starting with the ones that fall under facial recognition. 

Facial Recognition 

Facial recognition is one of the most powerful capabilities of Azure AI Vision, enabling systems to detect, analyze, and identify human faces in images or video feeds. This technology has a wide range of applications, from enhancing security systems to personalizing user experiences. Azure AI Vision provides robust facial recognition tools that are both accurate and easy to integrate into custom solutions. 

How Facial Recognition Works 

Azure’s facial recognition capabilities rely on sophisticated machine learning models that analyze facial features in images or video frames. These models detect faces by identifying key landmarks, such as the eyes, nose, and mouth, and then generate a unique facial signature based on these features. The process involves several key steps that ascend in complexity: 

• Face Detection: Identifies the presence of faces in an image or video and determines their locations within the input
• Facial Attribute Analysis: Extracts attributes like age, gender, facial hair, or even emotional expressions (e.g., happy, sad, neutral)
• Face Identification: Matches detected faces against a database of known faces to identify individuals to a known group
• Face Verification: Confirms whether two faces belong to the same person by comparing their facial signatures

Azure AI Vision’s facial recognition APIs make it simple to integrate these capabilities into applications. The service also supports real-time analysis, making it ideal for applications like live surveillance or interactive kiosks. 

Use Cases for Facial Recognition

Facial recognition opens a variety of possibilities for businesses and organizations. Some potential use cases include: 

• Security and Access Control: Implementing facial recognition for secure building access or device unlocking, replacing traditional keycards or passwords
• Retail and Marketing: Analyzing customer demographics and emotions in stores to tailor marketing campaigns or improve customer experience
• Event Management: Streamlining check-in processes at events by identifying attendees through facial recognition

At DMC, we are confident in our ability to leverage Azure’s facial recognition capabilities to build tailored solutions for clients across industries. Whether it’s enhancing security protocols or creating personalized customer interactions, our team is equipped to fine-tune these models to meet specific requirements while ensuring high accuracy and reliability. 

Optical Character Recognition (OCR) 

Optical Character Recognition (OCR) is another cornerstone of Azure AI Vision, enabling systems to extract text from images, scanned documents, or video feeds. This capability is designed for digitizing physical documents, automating data entry, and making content searchable. Azure’s OCR technology is highly accurate and supports a wide range of languages and formats, making it a versatile tool for our clients. 

How OCR Works 

Azure’s OCR functionality, powered by the Read API, processes images or PDFs and converts text within them into machine-readable data. The process involves: 

• Text Detection: Identifying regions in an image that contain text, regardless of orientation or font style
• Text Recognition: Converting detected text into digital characters, preserving formatting where possible
• Language Support: Recognizing text in multiple languages, including handwritten and printed text
• Layout Analysis: Understanding the structure of the document, such as paragraphs, tables, or lists, to maintain context 

The Read API is designed to handle complex scenarios, such as noisy images, low-resolution scans, or text in mixed languages. Developers can easily integrate OCR into applications by calling the API and receiving structured JSON output containing the extracted text and its coordinates. 

Advanced OCR Features 

Azure AI Vision’s OCR goes beyond basic text extraction. Some advanced features include: 

• Handwritten Text Recognition: Extracting text from handwritten notes or forms, which is particularly useful for industries like healthcare or education
• Form Recognition: Automatically extracting key-value pairs from structured documents like invoices, receipts, or IDs 
• Multi-Page Document Processing: Handling large documents, such as contracts or reports, with consistent accuracy across pages
• Real-Time OCR: Processing live camera feeds to extract text instantly, ideal for applications like license plate recognition

Use Cases for OCR 

OCR is a game-changer for organizations looking to streamline operations and reduce manual work. Some practical applications include: 

• Document Digitization: Converting paper-based records, such as medical charts or legal contracts, into searchable digital formats
• Automated Data Entry: Extracting information from invoices, receipts, or forms to populate databases without human intervention
• Accessibility: Enabling text-to-speech systems to read printed text aloud for visually impaired users
• Logistics and Transportation: Reading shipping labels or license plates in real time to improve supply chain efficiency

Real-World Solution: Enhancing Security with Azure AI Vision

To illustrate the power of Azure AI Vision, let’s explore a high-level example of how DMC could leverage this technology to solve a security problem for a client. 

The Challenge

A large corporate campus with multiple buildings wants to enhance its security measures and streamline access control. The client faces two key issues: 

1. Unauthorized Access: The current keycard-based system is vulnerable to lost or stolen cards, allowing potential unauthorized entry to sensitive areas. 
2. Incident Reporting: Manual logging of security incidents, such as identifying individuals in surveillance footage, is time-consuming and prone to errors. 

The Solution

DMC proposes a comprehensive Azure AI Vision solution that combines facial recognition, OCR, and object detection to address these security challenges. The solution includes: 

Secure Access Control: Using Azure’s Face API, the system verifies employee identities at entry points by matching their faces against a secure database of authorized personnel. The system operates in real time, granting or denying access within seconds. 

Automated Incident Logging: Azure’s OCR capabilities are integrated into a security management platform that processes surveillance footage and incident reports. The system extracts text from identification documents or name badges captured in footage, cross-referencing with employee records to log incidents accurately. Object detection identifies potential security threats, such as unrecognized items in restricted areas. 

Security Analytics Dashboard: A centralized dashboard provides real-time insights into access logs and incident reports, powered by Azure’s facial recognition and OCR data. Security teams can monitor entry patterns, flag suspicious activities, and generate reports for compliance audits. 

Implementation

To build this solution, DMC provisions an Azure AI Vision resource within the client’s Azure Subscription. The development process includes: 

• Custom Model Training: Fine-tuning Azure’s facial recognition models with a dataset of employee images (with consent) to ensure high accuracy in identification under various lighting and angle conditions
• OCR Integration: Configuring the Read API to extract text from identification documents, badges, or signage in surveillance footage, supporting multiple formats and orientations
• Object Detection: Training a custom object detection model to recognize specific items (e.g., bags, devices) that may pose security risks
• Security Platform Development: Building a web or desktop platform that integrates the Face API, Read API, and object detection models, with a user-friendly interface for security personnel
• Security and Compliance: Implementing end-to-end encryption for all data, including facial signatures and extracted text, and ensuring compliance with privacy regulations according to state and federal guidelines. Human-in-the-loop oversight is incorporated, allowing security staff to review and intervene in real-time decisions.

Benefits 

The solution delivers measurable results for the corporate client: 

• Enhanced Security: Facial recognition ensures only authorized personnel access restricted areas, minimizing risks from lost or stolen keycards. 
• Operational Efficiency: Automated incident logging reduces manual work and improves the accuracy of security reports. 
• Proactive Monitoring: Real-time analytics enable security teams to detect and respond to potential threats quickly. 
• Scalability: The Azure-based solution can be expanded to additional campus locations or integrated with other security systems. 

Ethical Considerations 

While facial recognition and image analysis is a powerful tool, it’s important to address ethical considerations. Privacy, consent, and data security are critical when deploying these solutions. Azure AI Vision adheres to strict compliance standards, and at DMC, we prioritize responsible AI practices, ensuring that facial recognition systems are implemented transparently and with user consent. As a registered partner with Microsoft, we are committed to responsible AI practices in deploying both facial recognition and OCR solutions in accordance with their general guidelines.  

We ensure responsible use and integration of visual AI solutions by: 

• Thoroughly assessing Azure AI Vision’s capabilities to ensure they align with client needs, while performing sufficient testing to understand its capabilities and limitations
• Respecting individuals’ privacy by collecting data only with explicit consent and using it solely for authorized purposes
• Incorporating human-in-the-loop oversight to enable real-time intervention, maintaining human decision-making to prevent harm
• Prioritizing security through robust controls to protect data integrity and prevent unauthorized access

More information on Microsoft’s guidelines on responsible used of AI Image Analysis can be found in their documentation provided. 

Why DMC?

At DMC, we combine technical expertise with a deep understanding of our clients’ business needs. Our experience with Azure AI Vision allows us to deliver tailored solutions that drive real value. Whether it’s enhancing customer experiences, automating processes, or unlocking new insights, we’re ready to help our clients succeed. 

Let’s Recap

Azure AI Vision is a transformative technology that empowers businesses to “see” and understand the world in new ways. With capabilities like facial recognition and OCR, it opens endless possibilities for innovation. At DMC, we’re passionate about harnessing these tools to solve complex challenges and deliver measurable results. From automation to agriculture, our team is equipped to build custom AI solutions across industries that meet your unique needs.

The post Azure AI: Computer Vision Solutions appeared first on DMC, Inc..

At DMC, we pride ourselves on our vast technology skillset. AI solutions are just a part of our application development services. From IoT solutions to custom software from scratch, we are ready to tackle any project that comes our way. In this post, we will introduce the fundamentals of Azure AI Search, AI Enrichment, and Multimodal Search. We will also talk about what an AI Search solution might look like from DMC. 

What is Azure AI Search? 

Azure AI Search is a Microsoft-owned and managed, cloud-based service that enables applications to have enterprise-grade information retrieval. The service has the traditional characteristics of a search service, such as indexing, keyword search, and knowledge stores. However, Azure AI search can enhance your search capabilities using AI Enrichment, Multimodal Search, and more! All these features live in the Azure ecosystem, making it easy to scale and apply a secure solution that fits your needs. 

What Can Azure AI Search Do? 

Azure AI offers several standard features of a search service, with the addition of AI capabilities. In this article, we will take a deeper look at AI Enrichment and Multimodal Search. Other features exist such as: 

• Indexing 
• Vector and hybrid search 
• Full-text search 
• Full Lucene query syntax search 
• Relevance scoring 
• Semantic ranking 
• Knowledge stores 

AI Enrichment

AI Enrichment in the Azure AI Search service takes raw, unstructured data and transforms it into structured, searchable content using other Azure AI Services such as Computer Vision and Language Processing. What this means is that we can take inputs, such as PDFs and text files, and extract meaningful information from them so they can be accurately retrieved in response to a search query. 

How AI Enrichment Works

The process for AI Enrichment can be broken down into three phases: 

1. Date Importing 
2. Enrichment and Indexing 
3. Output Exploration

Data Importing is the step where an indexer connects a data source with unstructured documents and pulls them into the search service. 

Enrichment and Indexing is the largest and most complex step of the process. Enrichment starts with the indexer opening files and extracting key data from them, such as dates, keywords, or any other customizable entities. During this process, an “enriched” version of the document is created. This enriched document can either be temporary or stored for future reuse. The indexer then applies field mappings, which are paths between the source data and search index. We also create a path between the enriched data and search index. 

In the final step, Output Exploration, we start to see the end goal of setting up this service, which is to be able to navigate a previously unsearchable data source. This can appear in the form of a simple search bar or passed onto a chatbot that can dynamically retrieve the enriched data and present it in a user-friendly, conversational format.  

Use Cases for AI Enrichment

• Knowledge Management: Extract entities and key phrases from internal documents to support advanced search
• Customer Support: Enrich support tickets with metadata to improve query routing
• Research Analysis: Process academic papers or reports to extract insights for searchable archives

Multimodal Search

Multimodal search is the ability to ingest, understand, and retrieve information across multiple content types, including text, images, video, and audio. This enables us to search using more diverse methods such as similarity search and hybrid queries, which we will talk about more in this section.  

How Multimodal Search Works

Multimodal Search uses AI to vectorize and index non-text content, enabling similarity search and hybrid queries. The process involves the following steps: 

1. Content Ingestion 
2. Vectorization 
3. Index Storage 
4. Query Processing 

Content Ingestion is where we extract data from text, images, PDFs, and more via indexers.  

Vectorization uses AI models to convert unstructured content into vectors. Vectors are used to capture semantic or visual features of data. They are essential in getting accurate return results when querying for non-text elements, such as visual features. 

The process of storing the vectors and their associated metadata for fast retrieval is the Index Storage step. 

Finally, Query Processing is where a user’s search input is matched against relevant vectors so that semantically similar results can be returned.  

So, what is the end goal of multimodal search? While the overall goal is to expand your organization’s knowledge sharing and storage capabilities, the two primary added features are similarity searches and hybrid queries.

Similarity Search

This technique leverages vector embeddings to find content that is conceptually or visually like a query, rather than relying solely on exact keyword matches. For example, a user uploading an image of a red dress can retrieve similar dresses based on visual features like color and style, even if the textual descriptions differ. Similarity search enables semantic and visual matching across diverse data types. 

Hybrid Queries

Multimodal Search supports hybrid queries that combine similarity search with traditional keyword search for more comprehensive results. By merging results using Reciprocal Rank Fusion, Azure AI Search ensures that both semantic relevance and exact matches are considered. For instance, a query like “blue sneakers” can retrieve results based on both the text description and vectorized images of sneakers, providing a balanced and highly relevant output. 

With these two query processing features, an application can answer questions like “What is the process to approve a purchase order?” even when the only description of the process lives inside an embedded diagram in a PDF file. 

Use Cases for Multimodal Search 

• Conversational AI: Enable chatbots to answer queries using text, images, or PDFs from a knowledge base 
• E-Commerce: Allow users to upload product images to retrieve descriptions or reviews
• Healthcare: Query medical images and patient records for diagnostics
• Media Analysis: Search video or audio archives alongside text for comprehensive insights

Real-World Solution: Enhancing a Knowledge Base using Azure AI Search

To demonstrate the power of Azure AI Search, let’s explore a high-level example of how DMC could leverage this technology to solve a knowledge organization problem for a client. 

The Challenge

A multinational consulting firm needs a search solution to help consultants quickly access industry trends, regulations, and internal best practices. Their knowledge base includes thousands of PDFs, images, and internal reports across multiple languages, but traditional search tools deliver irrelevant results and struggle with non-text data. This leads to countless hours spent manually searching documents, impacting productivity and client response times. 

The Solution

DMC proposes that the firm implement Azure AI Search with AI Enrichment and Multimodal Search to create an intelligent search platform. By enriching and vectorizing their knowledge base, this enables consultants to retrieve accurate, contextually relevant content using text or image queries, streamlining research and improving client outcomes. This solution would include: 

Complete Knowledge Base Ingestion: Using Azure’s pre-built indexers vectorize and index a pre-existing knowledge base to make it easier to navigate. 

Enhanced Data Retrieval: With AI Enrichment and Multimodal Search, the search service can quickly and accurately retrieve information based off a query. 

Implementation

To build this solution, DMC provisions an Azure AI Search resource within the client’s Azure subscription. The development process includes: 

• Data Ingestion 
  • Store PDFs, images, and reports in Azure Blob Storage, ingested via Azure AI Search indexers
• AI Enrichment Pipeline 
  • Apply Optical Character Recognition (OCR) to extract text from scanned PDFs and images (e.g., charts, infographics) 
  • Use entity recognition to tag regulations, companies, and dates in documents
  • Employee translation skills to index multilingual content for global teams
• Multimodal Search Setup 
  • Vectorized images and text using Azure OpenAI and Computer Vision models
  • Configured hybrid search to combine keyword and vector queries for comprehensive retrieval
• Deployment 
  • Integrate the search solution into the firm’s internal portal using Azure SDKs, supporting text and image-based queries

Benefits

• Improved Relevance: Semantic ranking and vector search increases result accuracy
• Time Savings: Reduced research time by accessing insights via intuitive searches 
• Multimodal Flexibility: Image-based queries (e.g., uploading a chart) can now retrieve related documents, enhancing usability
• Global Accessibility: Multilingual indexing supports seamless search for international teams
• Scalability: Using Azure as the foundation, the service can scale easily with the firm’s needs and goals

Responsible AI

AI Enrichment and Multimodal Search rely on Azure AI models (e.g., Computer Vision, Language Service, Azure OpenAI) that may process personal or sensitive information.  

To uphold privacy and fairness, it is essential to consider the following: 

• Ensure input data complies with applicable privacy laws and regulations. Avoid processing sensitive personal data without explicit consent or legal basis. 
• AI models may inadvertently reflect biases in training data, potentially affecting entity recognition or image analysis. Regularly evaluate outputs for fairness and adjust configurations (e.g., custom skills or filters) to minimize biased results. 
• Clearly communicate to users when AI-generated outputs, such as extracted entities or vectorized content, are used in search results, ensuring they understand the role of AI. 

See the information on Microsoft’s guidelines on responsible use of AI Search. 

Why DMC? 

At DMC, we blend our years of expertise with the Azure ecosystem with a client-centric approach to deliver transformative cloud-based solutions. Our deep knowledge base enables us to craft tailored platforms that unlock actionable insights and streamline operations. As a Microsoft Solutions Partner, we are committed to responsible AI practices. We ensure ethical, secure, and scalable solutions that align with your business goals, empowering you to stay ahead and succeed. 

Let’s Recap

Azure AI Search is a powerful platform for intelligent search that uses AI Enrichment and Multimodal Search. AI Enrichment processes unstructured data into searchable, structured content, enabling applications like knowledge management and multilingual search. Multimodal Search extends this to images and audio, supporting cross-modal retrieval with similarity search and hybrid queries. Responsible AI practices ensure ethical use by addressing privacy, bias, and accuracy concerns. In our real-world example, a consulting firm could leverage these features to build an efficient search solution, boosting productivity and client satisfaction. For organizations seeking to unify diverse data and enhance discovery, Azure AI Search delivers expert results. 

At DMC, we’re passionate about harnessing these tools to solve complex challenges and deliver measurable results.

The post Azure AI: Knowledge Mining Solutions appeared first on DMC, Inc..

Why ChatGPT is a Valuable Tool for Embedded Systems Engineers

Time-Savings Benefits

Embedded systems engineers often find themselves running command-line applications repeatedly, frequently changing parameters or values. ChatGPT can help automate these workflows with Python or other scripting languages. It saves a significant amount of time by quickly generating the code. It’s particularly useful for creating easy-to-use GUIs that both you and your collaborators can interact with seamlessly. This is especially true with IOT applications that are likely to have Wi-Fi or BLE to easily interact with your computer.

Answer Obscure Questions

In embedded systems, I often encounter obscure questions that a simple Google search may not easily resolve. While the information is likely out there, it can be time-consuming to sift through multiple pages of search results. Instead, I turn to ChatGPT. It often provides a clear and concise answer in seconds to even the most obscure questions about embedded systems libraries, functionalities, or tools.

Increased Efficiency

When faced with an algorithm or calculation that would take several minutes to write manually, ChatGPT can help you save time. Describe the function in a sentence or two, and ChatGPT will generate the code including the outputs within the same function.

Important Considerations When Using ChatGPT

While ChatGPT is a great resource, it’s important to be mindful of a few key points.

1. Lack of Awareness of Your Ongoing Efforts

ChatGPT doesn’t inherently understand your project’s context unless explicitly told. For example, while working on a Python GUI using ChatGPT for a video frame analyzer, I assumed that holding down the “next frame” button would fast-forward through the video.This is something I’m accustomed to in modern interfaces. However, holding down the button simply brought me to the next frame. After I specifically asked for this feature, ChatGPT provided me with updated functional code.

2. Works Best as an Input-to-Output Solution

Think of ChatGPT as an elevator— provide a clear, specific request, and it will take you directly to your desired floor. But if you overload it with too many requests at once, you risk stopping at every floor along the way. To get the most efficient results, break your tasks into smaller, manageable chunks, test the output at each step, and refine as needed. This step-by-step approach ensures you reach your goal smoothly and effectively.

3. Requires Some Technical Knowledge for Troubleshooting

ChatGPT’s solutions are often accurate, but they may need refinement. If you encounter errors, your technical expertise becomes crucial. By providing error messages, clarifying unexpected behavior, or hypothesizing potential causes, you can guide ChatGPT to improve its suggestions effectively.

4. Falling Into Rabbit Holes

While ChatGPT is a great troubleshooting tool, its suggestions may not always work as expected. You might spend time trying multiple plausible fixes that don’t resolve the issue, leading to frustration. It’s crucial to recognize when this happens, step back, and explore alternative solutions. ChatGPT can generate helpful ideas, but it is fallible and may require you to pivot or revisit the problem from a new angle.

5. Outdated Solutions

One important thing to keep in mind when using ChatGPT for embedded systems work is that its knowledge is based on information up until its last update. This means it may sometimes suggest solutions that are outdated or no longer relevant, especially in fields like embedded systems where tools, libraries, and platforms evolve rapidly.

For example, when working with newer kernel versions on platforms like Raspberry Pi, I have seen important configuration files relocated, but ChatGPT still suggests solutions based on older configurations. This can lead to frustration if you’re trying to apply outdated practices to a more recent environment. As a result, it’s essential to stay on top of the latest updates for your development tools and platforms, verifying ChatGPT’s suggestions against current documentation to avoid wasting time on solutions that no longer apply.

6. Maintain Confidentiality with Proprietary Information

It’s important to understand that ChatGPT, by default, may use your data to improve its AI model. When working with code or documents under an NDA or requiring confidentiality, take steps to protect sensitive information. Replace identifiable details (e.g., project names, client specifics, or unique identifiers) with placeholders, and frame questions using generalized examples to safeguard proprietary content.

Practical Uses: How ChatGPT Accelerates Embedded Systems Development

Here are practical examples of how I leverage ChatGPT to enhance my embedded systems projects.

1. Creating Python GUIs to Save Time

Working with IoT devices often means dealing with clunky command-line interfaces requiring dozens of parameters or outdated tools that slow down development. These challenges become even more apparent when collaborating with clients or non-technical teams, where usability and clarity are key. A simple, intuitive GUI can make a world of difference.

Example:

While implementing MQTT for IoT communication, I needed an easy way to start the broker, send predefined messages, and display incoming responses in real time. Using ChatGPT, I quickly generated a Python-based GUI that achieved these goals. The interface featured buttons to trigger common commands like starting and stopping recording, fields to customize message payloads, and a real-time log for incoming messages.

This solution saved significant development time and improved usability for both me and my client. It streamlined testing and debugging by replacing a cumbersome command-line process with a user-friendly, visually intuitive interface. With this approach, I could focus on delivering results while fostering better collaboration.

2. Automating Tedious Tasks

On a recent project requiring precise camera synchronization, I needed to fetch and review numerous video files stored on separate embedded Linux devices. Doing this manually via SSH and buggy third-party tools was inefficient.

Solution:

I used ChatGPT to create a GUI that:

• Connected to remote devices via SSH
• Downloaded the latest video files
• Displayed all videos synchronously

Originally this GUI provided a start and stop button and up to four screens to view the videos. By iteratively refining the GUI with ChatGPT, I also added frame-by-frame navigation for debugging as well as up to eight screens. This greatly improved my workflow and let me iterate on my actual project much faster.

3. Writing C++ Wrappers for Libraries

One of the biggest challenges in embedded systems is dealing with the highly diverse firmware ecosystems, such as FreeRTOS, Mbed, Zephyr, and others. Each platform has its own strengths and weaknesses, and you may find yourself working in a FreeRTOS environment but wishing you had access to some of Mbed’s powerful networking stack. While the underlying architectures differ, both FreeRTOS and Mbed are well-documented, which makes it easier to bridge the gap with a wrapper.

Example:

I needed Mbed’s threading, mutex, and semaphore features in a FreeRTOS project. I used ChatGPT to generate a wrapper class that allowed me to use Mbed-like functionality within FreeRTOS. With just a simple request, I received a base implementation for the Mbed Thread class, Mutex, and Semaphore, all translated into FreeRTOS-compatible code. While some underlying issues may arise during implementation, this wrapper provided a solid foundation to build on and integrate Mbed-specific features into my FreeRTOS-based device.

My prompt:

“Write me a wrapper class that uses FreeRTOS but gives me class’s that perfectly mimics Mbed’s threading functions”

ChatGPT’s response:

#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
 
class Thread {
public:
    // Constructor: Takes a function pointer and optional argument
    Thread(void (*taskFunction)(void*), void* argument = nullptr, const char* name = "Thread", 
           uint16_t stackSize = configMINIMAL_STACK_SIZE, UBaseType_t priority = tskIDLE_PRIORITY)
    {
        xTaskCreate(taskFunction, name, stackSize, argument, priority, &taskHandle);
    }
 
    // Destructor: Deletes the FreeRTOS task
    ~Thread() {
        if (taskHandle != nullptr) {
            vTaskDelete(taskHandle);
        }
    }
 
    // Start the thread (already started in constructor)
    void start() {
        // FreeRTOS tasks start immediately upon creation, so this is typically a no-op
    }
 
    // Join function (Waits for the thread to terminate)
    void join() {
        while (eTaskGetState(taskHandle) != eDeleted) {
            vTaskDelay(1);
        }
    }
 
    // Detach function (make the thread independent)
    void detach() {
        taskHandle = nullptr;
    }
 
    // Static function to yield execution to another thread
    static void yield() {
        taskYIELD();
    }
 
    // Static function to get the thread's id
    static TaskHandle_t get_id() {
        return xTaskGetCurrentTaskHandle();
    }
 
private:
    TaskHandle_t taskHandle;
};
 
// Mbed-style Mutex wrapper using FreeRTOS
class Mutex {
public:
    Mutex() {
        mutexHandle = xSemaphoreCreateMutex();
    }
 
    ~Mutex() {
        vSemaphoreDelete(mutexHandle);
    }
 
    void lock() {
        xSemaphoreTake(mutexHandle, portMAX_DELAY);
    }
 
    void unlock() {
        xSemaphoreGive(mutexHandle);
    }
 
    bool trylock(uint32_t timeout_ms) {
        return xSemaphoreTake(mutexHandle, pdMS_TO_TICKS(timeout_ms)) == pdTRUE;
    }
 
private:
    SemaphoreHandle_t mutexHandle;
};
 
// Mbed-style Semaphore wrapper using FreeRTOS
class Semaphore {
public:
    Semaphore(int max_count, int initial_count) {
        semaphoreHandle = xSemaphoreCreateCounting(max_count, initial_count);
    }
 
    ~Semaphore() {
        vSemaphoreDelete(semaphoreHandle);
    }
 
    void acquire() {
        xSemaphoreTake(semaphoreHandle, portMAX_DELAY);
    }
 
    void release() {
        xSemaphoreGive(semaphoreHandle);
    }
 
    bool try_acquire(uint32_t timeout_ms) {
        return xSemaphoreTake(semaphoreHandle, pdMS_TO_TICKS(timeout_ms)) == pdTRUE;
    }
 
private:
    SemaphoreHandle_t semaphoreHandle;
};

#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
 
class Thread {
public:
    // Constructor: Takes a function pointer and optional argument
    Thread(void (*taskFunction)(void*), void* argument = nullptr, const char* name = "Thread", 
           uint16_t stackSize = configMINIMAL_STACK_SIZE, UBaseType_t priority = tskIDLE_PRIORITY)
    {
        xTaskCreate(taskFunction, name, stackSize, argument, priority, &taskHandle);
    }
 
    // Destructor: Deletes the FreeRTOS task
    ~Thread() {
        if (taskHandle != nullptr) {
            vTaskDelete(taskHandle);
        }
    }
 
    // Start the thread (already started in constructor)
    void start() {
        // FreeRTOS tasks start immediately upon creation, so this is typically a no-op
    }
 
    // Join function (Waits for the thread to terminate)
    void join() {
        while (eTaskGetState(taskHandle) != eDeleted) {
            vTaskDelay(1);
        }
    }
 
    // Detach function (make the thread independent)
    void detach() {
        taskHandle = nullptr;
    }
 
    // Static function to yield execution to another thread
    static void yield() {
        taskYIELD();
    }
 
    // Static function to get the thread's id
    static TaskHandle_t get_id() {
        return xTaskGetCurrentTaskHandle();
    }
 
private:
    TaskHandle_t taskHandle;
};
 
// Mbed-style Mutex wrapper using FreeRTOS
class Mutex {
public:
    Mutex() {
        mutexHandle = xSemaphoreCreateMutex();
    }
 
    ~Mutex() {
        vSemaphoreDelete(mutexHandle);
    }
 
    void lock() {
        xSemaphoreTake(mutexHandle, portMAX_DELAY);
    }
 
    void unlock() {
        xSemaphoreGive(mutexHandle);
    }
 
    bool trylock(uint32_t timeout_ms) {
        return xSemaphoreTake(mutexHandle, pdMS_TO_TICKS(timeout_ms)) == pdTRUE;
    }
 
private:
    SemaphoreHandle_t mutexHandle;
};
 
// Mbed-style Semaphore wrapper using FreeRTOS
class Semaphore {
public:
    Semaphore(int max_count, int initial_count) {
        semaphoreHandle = xSemaphoreCreateCounting(max_count, initial_count);
    }
 
    ~Semaphore() {
        vSemaphoreDelete(semaphoreHandle);
    }
 
    void acquire() {
        xSemaphoreTake(semaphoreHandle, portMAX_DELAY);
    }
 
    void release() {
        xSemaphoreGive(semaphoreHandle);
    }
 
    bool try_acquire(uint32_t timeout_ms) {
        return xSemaphoreTake(semaphoreHandle, pdMS_TO_TICKS(timeout_ms)) == pdTRUE;
    }
 
private:
    SemaphoreHandle_t semaphoreHandle;
};

This wrapper gave me a great starting point, saving hours of manual coding and research.

Key Takeaways

ChatGPT is a game-changer for embedded systems development when used wisely. Here’s how you can maximize its benefits:

• Be Specific: Define your problem clearly to guide ChatGPT effectively
• Iterate: Break complex tasks into smaller, manageable chunks
• Validate: Always test and review ChatGPT’s suggestions
• Leverage Your Expertise: Combine your technical knowledge with ChatGPT’s output for optimal results

By incorporating ChatGPT into your embedded development workflow, you can significantly enhance productivity, streamline development, and tackle tedious tasks more effectively.

The post Streamlining Embedded Systems Development with ChatGPT appeared first on DMC, Inc..

Hardware experts don’t always have hours of time to invest in staying updated on the latest in LabVIEW like we do at DMC. Understandably, this can result in code that doesn’t follow standard architecture or best practices.

We’ve seen every kind of graphical code structure under the sun. It takes time to follow the hundreds of wires and many parallel loops to figure out what makes a program behave the way that it does.

Me analyzing LabVIEW code for the first time

Using OpenAI and LabVIEW

Text-based languages have benefitted from recent advancements in tools used to analyze and write code like Python with tools like GitHub Copilot. NI has been hard at work too, as evidenced by their recent demo of Nigel, but they haven’t yet released it.

In the meantime, I thought I could try something rudimentary to achieve a similar outcome using the GPT API from OpenAI with a few tricks to make it work on VI files (files for LabVIEW written in their G language). I wanted to see if I could use GPT to describe LabVIEW code.

Here are the steps:

1. Convert the LabVIEW graphical code to text-based code.
2. Pass the text-based code to GPT and ask it to analyze the code.

Converting Graphical Code to Text-Based Code

Step 1 basically describes a transpiler which is a compiler that takes code in one language and produces equivalent code in a target language, though as we’ll see that’s easier said than done. For my purposes, I decided to target Python-like code since it isn’t strictly typed and would let me get away with leaving out a lot of information about data types. It’s also likely that GPT is trained on tons of Python code and trying to use a language more equivalent to LabVIEW code would mean implementing more programming constructs in the transpiler or creating a proprietary intermediary language as NI has been doing with Nigel.

The first major hurdle is the fact that LabVIEW code isn’t written as a series of sequential statements. Instead, it is a data-flow language which uses “wires” to transfer information from block to block. This makes it especially great for simple-looking implementations of multi-threaded applications but annoying for our purposes. Luckily, this construct maps well onto the concept of computational graphs and we can try to move from code to a more abstract graph to make our life simpler. We can think of LabVIEW code as a “directed acyclic graph” with a set of start nodes (controls) and end nodes (indicators) connected by edges (wires).

But how do we convert LabVIEW code to a computational graph? Using VI Scripting of course! NI has a library of tools that lets you find all instances of a specified type of LabVIEW programming construct and if we look for all wires and note what pair of objects each one joins, we can build our graph.

We then take the graph and use a custom scheduler algorithm to create a sequence of operations for each of the code blocks and finally use the metadata of each wire’s two terminals to provide some additional data in the transpiled code.

Ask GPT to Analyze the Code

Add in some logic to avoid accidentally using the variable names in multiple places using UIDs and we’re basically done! All we do now is ask GPT to describe the code in terms of what it represents and not the actual variables themselves and we have a crude AI-powered VI analysis tool.

Except that it doesn’t work for:

• For loops
• While loops
• Broken code
• Cases where there are orphaned blocks
• Feedback loops
• Analyzing sub-VIs
• Etc.

You get the idea. Perhaps with a more structured approach to VI scripting and fine-tuning with example code, it might be possible to get more out of this idea, but I think this serves as a useful demo to see what might one day possible!

The post Creating Custom AI Tools to Analyze LabVIEW Code appeared first on DMC, Inc..

NI Connect 2024 was a highlight event this year for the Test and Measurement industry that brought together major thought leaders to share insights, forge connections, and celebrate innovation. Let’s dive into the key takeaways! 

Solving the Challenges of Battery Production and Remanufacturing Test

At NI Connect, DMC had the privilege of showcasing our cutting-edge battery production and remanufacturing test innovations at our exhibit in the Battery Production Test booth. We deeply appreciate the valuable input from our customers, which has allowed us to develop solutions that directly addresses the common pain points we frequently hear about from conference attendees. Scalability and openness to the test platform are core principles of DMC’s Battery Pack Test (BPT) solution, ensuring it meets the dynamic needs of the industry. If you are encountering similar challenges with you battery pack or module testing, explore our Battery Test page to learn how we can assist you-from consulting to full system integration.

The DMC Battery Pack Test (BPT) System is designed by DMC’s Battery Test experts, leveraging almost two decades’ worth of battery test experience. It is a highly capable pack and module testing solution that enhances test coverage and scales with your organization. Some notable features include: 

• Open Platform: Built on NI TestStand, the BPT offers a truly open platform for managing test recipes that allows customers to fully own and adapt the solution to meet emerging technology requirements. 

• User-Centric Station Operation: Intuitive workflows ensure consistent daily production operation with minimal interaction with the software. 

• Role-Based Access Controls: Screen and feature access are controlled based on roles. 

• Flexible Configurations: The BPT can be deployed in one station rack module or decomposed into multiple station modules for optimized cycle times and throughput. 

• Complete Traceability: Continuous data acquisition (DAQ) provides traceability and visualization. 

• Integration with MES/SCADA Systems: Seamlessly integrates with your manufacturing execution system (MES) or supervisory control and data acquisition (SCADA) system. 

• Data Analytics via NI SystemLink or custom database plugin: Enables data analysis and insights. 

• IT-Synced User Permissions Management: Ensures secure access. 

• Soft-Front Panel HMIs: Allows manual device control and diagnostics.

DMC also took part in a joint presentation with NI on Advanced Battery Cell Testing Techniques, highlighting the work we’re currently doing to help our customers scale battery cell testing with NI’s latest technology.

Celebrating Partnerships and Connections

NI Connect 2024 was more than just a conference; it was a celebration of the strong bonds formed between colleagues, partners, and clients. Amidst great dinners, social events, and learning opportunities, the DMC team took a moment to recognize the strong partnership we’ve shared with NI for over 25 years. This partnership has been instrumental in helping our mutual customers solve challenging technical problems in a variety of industries. Some key themes to our partnership as I see them are:

Expertise and Solutions: DMC, recognized as an NI Preferred System Integrator, brings unparalleled NI ecosystem expertise to the table, especially LabVIEW programming. DMC’s role extends beyond writing code; we act as consultants, advising on hardware choices and anticipating future needs. NI’s hardware product offerings combined with DMC’s expertise and software solutions helps our customers get to market faster. 

Investments in Product Offerings: NI continues to invest in both hardware and software, enhancing test workflows and leveraging test data with their latest emphasis on the LabVIEW+ Suite. NI’s renewed commitment to their software platforms provides clarity on areas of NI’s investment and enables DMC to focus on forward-looking solutions for our customers, knowing that we have the investment and backing of NI to take on the next challenge. In particular, NI’s focus on AI is opening new doors for the future of what test engineering can look like, and DMC is excited for the new opportunities ahead. 

Collaborative Spirit: NI Connect 2024 exemplified the collaborative spirit that drives the industry forward. The strong partnership between NI and DMC is a testament to this spirit, resulting in innovative solutions for customers. NI’s Battery Test Solution for Pack Validation and DMC’s Battery Production Test (BPT) solution are recent examples of DMC and NI collaboration.  

Thought Leadership and Educational Lectures: A key feature of NI Connect 2024 was the array of lectures on cutting-edge innovations, providing a platform for thought leadership within the industry. These sessions were not just educational but inspirational at times, offering a glimpse into the technological advancements that are shaping our world.  

NI Focus on Generative AI

Notably, several exciting AI technology integrations were discussed, highlighting how NI is focusing on leveraging AI as a competitive advantage in their product offerings, which will help our customers leverage this cutting edge technology to enhance their business performance. Here are some highlights: 

Analytics Tools (AI and ML): The use of artificial intelligence (AI) and machine learning (ML) in test processes was a hot topic this year. Attendees discovered how these tools can improve yield, enhance product quality, and drive innovation. NI continues to invest in its new AI assistant, NIGEL, expanding capabilities and planning a roadmap that ensures you can leverage the power of AI wherever you need: from the cloud to the edge and anywhere in between. 

Effective Test Data Management: Companies learned strategies for optimizing test data management. By efficiently handling large volumes of data, organizations can make informed decisions and drive better outcomes. Tools like NI SystemLink greatly simplify this task. DMC has lots of experience using SystemLink and can attest to its impact on our customers’ workflows, data analytics, and systems management. AI is certain to play a large role in transforming the utility of this data and rapidly accelerating data analysis capabilities for our customers.

Python/LabVIEW Integration: Attendees explored Python/LabVIEW integration, allowing seamless collaboration between these two powerful programming languages. This integration streamlines test development and data analysis, enhancing overall efficiency and productivity. Both Python and LabVIEW are getting lots of AI integration investment, making it easier for teams to build sophisticated software in record time. DMC’s multiple service areas, including Test & Measurement and Application Development frequently work together on projects, bringing the best solutions from multiple technologies like LabVIEW and Python together into an integrated solution that leverages the advantages of both. You can check out some of our latest thinking on using text-based languages for your test projects here. 

Final Thoughts

NI Connect 2024 was a testament to the power of collaboration and innovation. It was an event where industry leaders could share their vision for the future and where partnerships were strengthened. As we reflect on the success of this year’s conference, we are reminded of the endless possibilities that lie ahead for technology and innovation. The DMC team, along with our partners at NI, are at the forefront of this journey, providing our expertise and enthusiasm to our customers to help them solve their most challenging problems.  

Thanks for reading! We hope to see you next year at NI Connect 2025 in Fort Worth, Texas.  

The post The Future of Test and Measurement and NI Connect 2024 appeared first on DMC, Inc..