Version 1.4.2 of the SPC Histogram panel for Grafana is out. This release adds a handful of features that have been requested for a while, along with the usual round of bug fixes. Here's a rundown of what changed.
Statistics Table

The biggest addition in this release is the statistics table — a summary panel that appears below the histogram and shows the key numbers for each data series in one place.

The table includes:

• Descriptive statistics: n, Mean, Std Dev, Min, and Max
• Control limits: LCL and UCL (when a chart type is selected)
• Process capability indices: Cp, Cpk, Pp, and Ppk (when LSL and USL are defined)

You don't have to show every column. The panel editor lets you pick exactly which ones you want to display, so you can keep it focused on what matters for your use case.

Export to CSV

You can now export your SPC data to a CSV file directly from the panel. There are two ways to do it: click the download icon in the statistics table header, or right-click anywhere on the panel and choose "Download CSV".

The exported file has three sections: statistics (the same numbers shown in the table), control lines (name, type, and position for each configured line), and histogram data (bucket boundaries and counts per series).

One thing worth noting: this exports the calculated SPC values, not the raw data from your data source. If you need the raw values, Grafana's built-in Inspect panel export still works the same way.

Histogram Tooltip

Hovering over histogram bins now shows a tooltip with the bucket range and the count for each series — similar to how Grafana's built-in histogram panel behaves. If you have a Gaussian curve configured, the tooltip also shows the fitted curve's value at that bin, which makes it easy to compare your actual data against the expected normal distribution.

Gaussian Peak (µ) Control Line

There's a new control line type called Gaussian Peak (µ). It marks the peak of the fitted Gaussian curve, using the mean calculated by the Levenberg-Marquardt algorithm.

This is different from the arithmetic Mean control line. For data that follows a normal distribution closely, the two will land in nearly the same spot. For skewed or non-normal data, they can diverge — and seeing both on the same chart can tell you something useful about your process.

This control line requires a Gaussian curve to be configured on the same series.

Bug Fixes

A number of smaller bugs were fixed in this release. Nothing dramatic, but things should generally feel more stable and reliable.

Getting Started

SPC Histogram is available in the Grafana Plugin Catalog. If you're already using it, the update should be available from your Grafana plugin management page.

The full documentation is at docs.kensobi.com/panels/spc-histogram. If you run into issues or have questions, you can open a ticket on GitHub or join the conversation on Discord.

Last week we released the SPC CAD Panel, a free, open-source Grafana plugin that lets you visualize measurement data directly on 3D CAD models. You can find the documentation here and the GitHub repository here.

Part of a Growing SPC Toolkit for Grafana

The SPC CAD Panel is the third open-source plugin we've released for statistical process control in Grafana. Together, they give you a complete set of tools for quality analysis:

SPC Chart Panel — Control charts for monitoring process stability over time. Supports Xbar-R, Xbar-S, and XmR charts with automatic calculation of control limits. If you're tracking whether a process is staying in control, this is your starting point.

SPC Histogram Panel — Distribution analysis with histograms, bell curves, and a built-in statistics table showing Cp, Cpk, Pp, and Ppk. Use it to understand process capability: is your process producing results within specification limits?

SPC CAD Panel — The new one. Brings 3D geometry into the picture, letting you bind the data from control charts and histograms to physical features on your parts.

The three panels work together. You might have a dashboard where the CAD panel shows your part with color-coded features, and clicking a feature opens an annotation with an SPC chart showing its measurement history. The geometry gives you context; the charts give you the statistical analysis.

The Problem: Manufacturing Data is Spatial, Dashboards Are Not

Every measurement in manufacturing comes from somewhere physical. A diameter measurement comes from a specific hole. A surface roughness reading comes from a specific face. A temperature sensor sits at a specific location on a machine.

Yet when we visualize this data, we strip away all that spatial context. We end up with charts, tables, KPIs, and time series — all useful, but all flat. The geometry disappears.

This creates real friction in daily work. When you're investigating a tolerance issue, you have the measurement data in one system and the CAD model in another, mentally mapping between them. When you're explaining a quality problem to someone from another department, you're pointing at a chart and saying "this is the feature near the top left, the smaller hole, no the other one."

The system knows the geometry. The engineers know the geometry. The dashboards don't.

The Solution: Put the Data Where It Came From

The SPC CAD Panel brings 3D CAD models directly into Grafana dashboards and lets you bind live data to physical features. Instead of navigating between charts and mentally reconstructing which measurement belongs to which feature, you navigate the part itself. Click on a feature, see its data. The geometry becomes the interface.

The plugin supports STL, 3MF, and PLY files, plus ASC point cloud data for scan comparisons. You can upload models up to 5MB directly into the panel, or reference a URL to load larger models up to 200MB. All formats support gzip compression for faster loading.

Starting April 1, our commercial SPC CAD Data Source plugin will also support direct uploads up to 200MB.

What You Can Actually Do With It

Once your CAD model is loaded and connected to your data, you can:

• Click any feature to see its annotation — a panel showing measurements, tolerances, charts, or whatever data you've configured
• Color-code features based on live data — set up rules so features turn green, yellow, or red based on pass/fail status, deviation from nominal, or any column in your data
• View SPC charts in spatial context — click a hole, see its diameter trending over the last 500 parts, with control limits and forecasting if you have that configured

• Animate through scan history — load point cloud scans from different times and scrub through them on a timeline to see how a part or tool changed
• See deviation data as color gradients on point clouds — blue for negative deviation, green for nominal, red for positive, all mapped automatically

The annotation system is flexible. Each feature can have multiple views with tables, time series charts, and custom grid layouts. There are 13 built-in templates for common feature types (holes, cylinders, planes, etc.), or you can build your own.

Use Cases

Quality Engineering

• Click on a hole feature, see its diameter measurements trending over the last 500 parts
• Spot which features are drifting out of tolerance — they turn red right on the model
• When something fails inspection, see exactly where on the part it happened without cross-referencing spreadsheets

Manufacturing Operations

• Bind temperature or vibration sensors to the actual machine geometry — see hot spots, not just numbers
• When a fault occurs, see which physical area of the machine triggered it
• Compare scan data from this morning to last week, animated on the same model

Digital Twins

• Your CAD model becomes the interface — click anywhere to access live or historical data
• No more separate systems for "the model" and "the data"
• Start with geometry you already have (STL, 3MF), connect it to measurements you're already collecting

Why Grafana?

If you're not familiar with Grafana, it's an open-source analytics and visualization platform. It connects to almost any data source — SQL databases, time series databases, REST APIs, CSV files, and more — and lets you build dashboards combining data from multiple sources.

For manufacturing, this matters because your measurement data probably lives in multiple places: a quality database here, a historian there, maybe some CSV exports from coordinate measuring machines. Grafana can pull from all of them without requiring you to consolidate everything into one system first.

The SPC CAD Panel extends Grafana into 3D space. Your existing queries, your existing data sources, your existing dashboards — now you can add a panel where the visualization is the actual part geometry.

Why Open Source?

We believe industrial analytics infrastructure should be composable and extensible, not locked into proprietary ecosystems. The plugin is released under the GNU Affero General Public License v3.0.

If you find bugs, want features, or want to contribute, the GitHub repo is here. We also have a Discord community if you want to ask questions or share what you're building.

Getting Started

1. Install the plugin in your Grafana instance
2. Add a CAD model (upload a file or provide a URL)
3. Configure a query that returns feature data with at least: feature name, characteristic ID, and nominal value
4. Click on features in the 3D view to create annotations

The documentation has detailed setup instructions, data model requirements, and examples.

We'd love to see what you build with it.

Rzeszów, Poland – Kenso Software, a dynamic and fast-growing startup specializing in analytics software for real-time production quality monitoring, and Metrica-Metrologia, a distinguished metrology services company specializing in instrument calibration, metrological training, and design of modern measurement systems, are pleased to announce their partnership to develop a comprehensive quality control automation solution.

The partnership will leverage KensoBI analytics software and Metrica’s metrology services and expertise to provide a comprehensive quality control automation solution that will help manufacturers identify opportunities or anomalies in production quality in real-time and verify the accuracy of the production process to ensure that it meets the required specifications.

In addition, Metrica will be the exclusive distributor of KensoBI in Poland, providing customers with access to KensoBI cutting-edge analytics software.

"We are excited to partner with Artur and his team at Metrica to develop a comprehensive quality control automation solution that will help manufacturers improve their production quality and efficiency," said Tomasz Czerkas, founder and CEO of Kenso Software.

"We believe that our analytics software, combined with Metrica’s metrology expertise, will provide manufacturers with a powerful tool to optimize their production processes."

"We are thrilled to be exclusive distributor of KensoBI in Poland," said Artur Kopa, founder and CEO of Metrica-Metrologia.

"We believe that KensoBI is a game-changer in the manufacturing industry, and we are excited to bring this cutting-edge technology to our customers in Poland."

About Kenso Software

Kenso Software is a leading provider of analytics software for real-time production quality monitoring. The company's software monitors production quality in real-time and displays measurements linked to CAD models on an interactive dashboard while streamlining data collection processes.

About Metrica-Metrologia

Metrica-Metrologia is a renowned metrology services company specializing in instrument calibration, metrological training, and the design of modern measurement systems. The company provides metrology services to a wide range of industries, including aerospace, automotive, and medical devices.

At KensoBI, we provide a complete solution for easily generating SPC reports. With a simple user interface, you can create reports without requiring in-depth mathematical knowledge. You have the flexibility to adjust report settings, nominal values, tolerances, and more. Let's discuss how to quickly integrate SPC calculations into your CAD panel using KensoBI.

Feature Data Source

Upon accessing the KensoBI dashboard, you will find a menu that allows you to fine-tune SPC calculations. Here's a brief overview of the key functions available:

1. Features

The "Features" section presents a list of current features. Users can pick the model and part, and then select the necessary features. We've established a dedicated database schema based on PostgreSQL for this purpose.

2. Characteristics

Once the characteristics are identified, users can choose which ones to include in the report and use as the foundation for SPC calculations.

3. SPC

In this section, users can select commonly used statistical calculations. The chosen calculations are automatically compiled and made available in annotations for all selected characteristics.

4. ML (Machine Learning)

KensoBI incorporates machine learning capabilities to predict and detect anomalies in your production line. This proactive approach helps you maintain quality standards by promptly addressing issues.

Annotations

Within the main dashboard, users have the capability to display multiple features simultaneously, such as spatial positioning, dimensions (length and width), temperature, and more.

To streamline calculations and optimize data processing, users can selectively choose the characteristics required for their reports.

By simply double-clicking on the window associated with a chosen characteristic, a panel will appear, offering the option to specify the SPC calculation type.

This list will contain all SPC calculation types selected previously in Feature Data Source.

At its core, Prediction Control Charts (PCC) leverage the power of machine learning and predictive analytics to monitor and control manufacturing processes. Unlike traditional SPC charts that rely solely on historical data to detect deviations, PCC combines historical data with real-time predictive models. This fusion enables manufacturers to not only identify issues as they arise but also forecast potential anomalies before they occur.

Real-time Predictive Models

Prediction Control Charts are designed to accommodate dynamic, non-linear processes, making them highly adaptable to modern manufacturing environments. Here's how they work:

• Data Collection and Integration: PCC starts by collecting vast amounts of data from sensors, IoT devices, and other sources across the production line. This data is integrated and cleansed to create a comprehensive dataset.
• Machine Learning Algorithms: Advanced machine learning algorithms are then applied to this dataset to build predictive models. These models can anticipate how the process should behave under normal conditions.
• Real-time Monitoring: As the manufacturing process unfolds, PCC continuously compares the real-time data with the predictions generated by the models. Any deviations from the expected behavior trigger alerts.
• Early Anomaly Detection: PCC excels at early anomaly detection. By identifying subtle deviations from predicted patterns, it allows manufacturers to take corrective action before defects or quality issues escalate.

Beyond Traditional SPC

One of the standout features of Prediction Control Charts is their flexibility:

• Adaptive Learning: PCC models can adapt to changes in the manufacturing environment. This means they remain effective even as processes evolve or new variables are introduced.
• Multivariate Analysis: PCC can handle multivariate data with ease. This is crucial in industries where various factors influence product quality simultaneously.
• Reduced False Alarms: Traditional SPC charts often produce false alarms, leading to unnecessary downtime and resource allocation. PCC's predictive capabilities significantly reduce these false positives.

The good

The adoption of Prediction Control Charts yields numerous advantages for manufacturers:

• Improved Quality: By identifying issues early and proactively, PCC helps improve product quality and reduce defects.
• Increased Efficiency: Minimizing downtime due to unexpected issues translates to increased efficiency and productivity.
• Cost Savings: Reduced waste, fewer rework requirements, and improved resource allocation lead to significant cost savings.
• Enhanced Decision-Making: PCC provides actionable insights, allowing manufacturers to make data-driven decisions and continuously optimize processes.

The bad

While Prediction Control Charts offer immense promise, they are not without challenges. These include the need for robust data infrastructure, ongoing model maintenance, and skilled personnel for implementation and interpretation. However, the benefits far outweigh the challenges, making PCC a worthy investment for forward-thinking manufacturers.

Conclusion

Prediction Control Charts offer a flexible, AI-driven approach to Statistical Process Control that empowers manufacturers to achieve higher quality, efficiency, and cost savings. As the manufacturing industry evolves, embracing this new but complicated tool will be key to staying competitive and ensuring the highest standards of product quality.

In the realm of artificial intelligence (AI), machine learning stands out as a dynamic subset that empowers computers to process intricate data, make informed decisions, and adapt autonomously to new information. Unlike conventional AI, machine learning doesn't just rely on preset rules; it learns from new data without manual intervention. This remarkable capability holds significant promise in managing large volumes of complex data generated by modern manufacturing processes.

A pivotal distinction between machine learning and statistical process control (SPC) lies in their data analysis capabilities. Machine learning excels at swiftly identifying anomalies and deriving insights from data, tasks that often take human analysts hours or days using SPC methodologies.

It's important to highlight that machine learning and SPC are not competing strategies but rather complementary tools that can coexist to optimize manufacturing processes. While SPC charts are effective at showcasing statistical control and in-process data, they can't replace the need for end-of-line (EOL) tests. EOL testing remains essential to ensure the quality of individual components. This underscores that SPC alone is insufficient in minimizing production waste and rework.

However, machine learning doesn't aim to supplant SPC; rather, it brings a fresh perspective to addressing manufacturing challenges. For instance, it can help answer confusing questions like, "Why do components fail EOL tests despite falling within specified limits?" While SPC involves statistical analysis of data trends, machine learning, delves into the intricate relationships between signals. This distinction allows machine learning to identify common abnormalities through a more holistic lens.

Consider an EOL test generating a staggering 1 000 000 time series data points. Here, machine learning truly shines by uncovering relationships within this vast dataset and comparing them across various transmissions to detect anomalies comprehensively. This level of complexity far surpasses manual analysis and even the capabilities of traditional SPC techniques.

Furthermore, machine learning's strength lies in its ability to collect actionable insights from interconnected signal relationships. This sets it apart from SPC, which predominantly focuses on the direction of single signal trends over time, lacking the capability to suggest solutions. Machine learning's ability in providing actionable insights transforms it into a valuable tool for effective problem-solving.

In the context of the automotive industry, SPC finds its niche in specific scenarios, such as monitoring features that intermittently impact downstream assembly. In such cases, SPC, combined with a well-defined sampling frequency, ensures the feature remains within statistical control. Conversely, machine learning offers a more comprehensive view of the entire manufacturing process, aiding in root cause analysis and providing holistic protection for the product's quality.

Machine learning steps into the manufacturing arena as a response to the surging volumes of data that modern plants generate. Just as the internet expanded the capabilities of computers, machine learning brings exponential possibilities to decipher patterns, connect seemingly disparate data, and present a comprehensive overview of production dynamics. Innovative solutions like KensoBI integrate SPC data with machine learning, heralding a new era of manufacturing analysis and quality management.

When conventional SPC proves inadequate in explaining downstream assembly issues despite favorable process checks, machine learning emerges as a tough ally. While SPC suffices for univariate data following a normal distribution, machine learning becomes indispensable when dealing with non-normally distributed multivariate data.

Machine learning's effectiveness hinges on the availability of extensive datasets, a common occurrence in modern manufacturing. Attempting to apply traditional statistical methods in such contexts overlooks inherent data imbalances. Moreover, the granularity of big data might amplify minor differences, making machine learning a more adept choice.

Beyond theoretical considerations, practical execution of SPC introduces variability due to human involvement. Operator-driven SPC, reliant on manual calculations and observations, can yield inconsistent results. In contrast, machine learning thrives on processed and visualized production line data, minimizing human errors.

In conclusion, the synergetic relationship between machine learning and SPC holds immense potential for enriching manufacturing insights. Machine learning's ability in unraveling complex relationships and patterns, coupled with its ability to provide actionable insights, fills the gaps left by SPC's limitations. As manufacturing experiences, a paradigm shift toward data-driven decision-making, integrating machine learning alongside SPC emerges as a pivotal strategy for optimizing processes, minimizing waste, and upholding product quality. Are you ready for the next generation of manufacturing analysis?

In this guide, you will learn how to quickly create a Pareto chart using measurement data stored in an SQL database and visualize it in Grafana. We will use concepts from dimensional metrology, meaning we will utilize measurement and characteristic data to identify which characteristics are primarily responsible for the most problems, based on the Pareto principle: 20% of the sources cause 80% of the problems.

Prerequisites

• Postgres SQL database
• Grafana or KensoBI

Initial setup

To keep things very simple, let's use the following Docker Compose file to set up everything we need.

To run it, you can use Windows PowerShell:

docker-compose up -d

Next, open your web browser and enter: localhost:3000. On the login screen, type admin/admin.

Add data source

Navigate to Administration -> Data Sources and click on Add New Data Source. Choose PostgreSQL and enter the following information and press Save and test button.

Host: host.docker.internal:5432
Database: kensobi
User: kensobi
Password: kensobiuser
TLS/SSL Mode: disable
Version: 15

Add Pareto Panel

Go to Administration -> Plugins and search for Pareto and click install.

Generate sample data

To create measurements, execute our measurement generator. You can locate it at https://github.com/KensoBI/measurement-generator. You have the option to download the pre-built binaries or compile it on your own.

Run the generator with the provided parameters:

.\MeasurementGenerator.exe --schema 1

Creating a New Dashboard

Begin by creating a new dashboard.

Select the Pareto panel and choose the PostgreSQL data source. In the data source settings, switch to Code view and input the following query:

SELECT CONCAT(c.id, '-', c.name) as characteristic,
       COUNT(*) AS out_of_tolerance_count
FROM public.characteristic c
JOIN public.measurement m ON c.id = m.characteristic_id
WHERE m.value > c.nominal + c.usl
   OR m.value < c.nominal + c.lsl
GROUP BY c.id, c.name
ORDER BY out_of_tolerance_count DESC
LIMIT 10;

To add dynamism to the chart, include time filter variable to factor in the selected date.

SELECT CONCAT(c.id, '-', c.name) as characteristic,
       COUNT(*) AS out_of_tolerance_count
FROM public.characteristic c
JOIN public.measurement m ON c.id = m.characteristic_id
WHERE (m.value > c.nominal + c.usl
   OR m.value < c.nominal + c.lsl)
AND $__timeFilter(m.time)
GROUP BY c.id, c.name
ORDER BY out_of_tolerance_count DESC
LIMIT 10

This is it. Our Pareto chart is complete!

As a manufacturing company, you face numerous challenges when it comes to maintaining quality standards and optimizing your production processes. With increasing consumer demands for high-quality products, it's crucial to find innovative ways to ensure that your products meet the strictest quality and precision standards. That's where KensoBI comes in - a tailored "quality intelligence platform" that provides manufacturing companies with a smart, real-time monitoring and analysis solution.

At the core of the KensoBI system is an app based on Grafana, an open-source log analytics tool that has been customized for the manufacturing industry with built-in CAD support, SPC calculations, and now, with our new feature of KensoBI - Machine Learning. This feature enables us to forecast measure results and raise an alarm if something goes wrong, helping to save 30-40% losses in the production process.

With KensoBI, you can create digital twin dashboards with fully interactive CAD objects, allowing you to move and resize 3D objects from a web browser. The 3D parts can also be enriched with features and show visualization of measured characteristics, making it easier to monitor the production process. KensoBI seamlessly integrates with major SQL databases, making it easy to create stunning visualizations without the need for SQL programming language knowledge. Additionally, KensoBI fully embraces industry 4.0 and helps clients move to an event-driven architecture for their measurement collection needs. This approach offers a scalable, flexible, and real-time data processing solution, empowering businesses to handle growth as the volume of measurements increases over time.

In summary, KensoBI is a powerful quality intelligence platform that helps manufacturing companies like yours maintain quality standards and optimize production processes. With its digital twin dashboards, machine learning capabilities, and event-driven architecture, KensoBI offers a comprehensive solution for companies looking to stay ahead of the curve in today's competitive market. Trust KensoBI to provide you with the smart, real-time monitoring and analysis solution your manufacturing business needs.

Charlotte, NC - Kenso Software, a fast-growing startup that specializes in manufacturing intelligence software, announced today the release of KensoBI version 2 to production. With this latest release, Kenso Software has made significant improvements to its flagship product, making it easier and more intuitive for manufacturers to gain insights into their production processes.

The brand-new user interface (UI) of KensoBI version 2 offers a sleek and modern design, making it easy for users to build 3D dashboards. The new CAD editor simplifies the process of adding label visualizations and providing an intuitive interface for designing custom reports.

One of the most significant new features of KensoBI version 2 is the data source that enables the creation of statistical process control (SPC) dashboards without requiring knowledge of SQL programming language. With this feature, users can create custom dashboards that display the specific data they need, in the format they want, with just a few clicks.

KensoBI version 2 also includes data collection with Apache Kafka microservices, which streamlines the process of data collection and makes it easier to integrate data from multiple sources. This functionality provides real-time visibility into the production process, enabling users to make better decisions and improve overall productivity.

Finally, Kenso Software has added predictive measurement analytics with machine learning (ML) algorithms. These algorithms enable users to predict future production trends, identify patterns, and make data-driven decisions that can help optimize their operations.

"With the release of KensoBI version 2, we've made significant improvements to our manufacturing intelligence software," said Tomasz Czerkas, Founder and CEO of Kenso Software. "Our team has worked hard to incorporate customer feedback and improve the user experience. The new UI, Feature Data Source, microservices for data collection, and predictive ML algorithms will provide our customers with the insights they need to improve their production processes and stay ahead of the competition."

KensoBI version 2 is available now for new and existing customers. For more information, please visit https://kensobi.com.

We're excited to announce the start of the KensoBI 2.0 closed beta program! We are very close to a production version and would like to hear your thoughts and suggestions.

KensoBI is a cutting-edge business intelligence software designed for use in metrology, quality assurance, and production monitoring departments within manufacturing industries.

To join our closed beta program, you need to follow our company page on LinkedIn and join our Discord channel. This will give you exclusive access to the KensoBI 2.0 software and the opportunity to provide feedback to help shape the future of manufacturing business intelligence.

What Are You Getting

As a thank you for joining our closed beta program, we're offering the following perks:

• Early Access: Be among the first to use the KensoBI 2.0 before it's publicly released.
• Feature Request Priority: Decide which features we need to focus on first.
• Personalized Support and direct access to the dev team
• KensoBI Swag!
• Discounts: Receive a discount on KensoBI 2.0 once it's publicly released.

We're excited to have you join us in this journey to revolutionize manufacturing business intelligence. Your feedback and support will help us shape the future of KensoBI, and we can't wait to see what insights you discover.

What Do You Need To Do

To join the KensoBI 2.0 closed beta program, please follow these steps:

1. Follow Kenso Software company page on LinkedIn by clicking the "Follow" button.
2. Join our Discord channel by clicking this link: https://discord.gg/QFsJJvvT

Thank you for your interest, and we look forward to hearing your feedback and seeing you in the KensoBI 2.0 closed beta program!

Event-driven software architecture has been used in software development for a long time. Particularly in finance, where processing real-time information from multiple sources is critical for gaining a competitive advantage or preventing fraud. The manufacturing industry is still primarily relying on monolithic software architecture; however, it is rapidly catching up.

This article will discuss how event-driven architecture (EDA) can be used to address issues manufacturers face today with measurement data collection and ways to prepare for a ten-fold increase of data in the coming years.

What is Event-Driven Architecture and How Does It Differ from Monolithic Architecture?

Event-driven architecture is a way of designing software systems that uses events as way of communication between different components, rather than making direct function calls or requests.

I other words, system components either announce some event happened (like a button click) or listen to those events and perform action upon receiving an event.

In contrast, monolithic software architecture typically follows a request-response pattern, where one component makes a request to another component to perform a specific action, resulting in a tightly coupled relationship that makes it difficult to scale and modify the system.

How Does Event-Driven Architecture Improve Scalability?

In monolithic architecture, all components are tightly integrated, making it difficult to scale specific parts of the system as data volume increases. With event-driven architecture, adding more “horsepower” is as simple as adding more worker services that can listen to events and scale independently.

What Tools Can Help Make a System More Event-Driven?

Opinionated choice - Apache Kafka. It is a free, open-source messaging system that acts as a messaging hub for transmitting and receiving messages between microservices. It has become very popular in recent years and most Fortune 500 companies rely on it.

Check out the video of one of the Apache Kafka cofounders:

A Real-World Example of Event-Driven Architecture in Manufacturing Quality Control

Consider a manufacturing company that uses metrology software to perform quality control measurements. The measurements are regularly exported to an XML file format. There will be a microservice to monitor a location where these XML files are stored. When new file arrives, microservice will process it and send the measurement data to Apache Kafka. This microservice acts as a producer of events. Another microservice, acting as a consumer of events, listens to the events produced by the first microservice, processes the measurement data, and saves it in a database for further analysis.

As the number of measurement devices increases, the system can easily scale to handle the increased data volume by adding more instances of the microservice that processes the XML files. If the database experiences a high volume of writes, another microservice can be added to perform calculations and caching.

Each microservice operates independently, so adding more instances does not affect the performance or scalability of the other microservices in the system.

Are There Any Microservices I Can Use to Get Started?

Lucky you! We have developed an open-source microservices to extract features, characteristics, and measurements from XML files generated by GOM Inspect. These include a Kafka producer that parses the XML and sends it to Kafka and a consumer service that saves the data to the database. You can find these microservices on GitHub at https://github.com/KensoBI/gomxml-kafka.

In summary, event-driven architecture with Apache Kafka and microservices is an effective solution for collecting and managing quality control measurements. This approach offers a scalable, flexible, and real-time data processing solution, empowering businesses to effectively handle growth as the volume of measurements increases over time.

You are either familiar with Industry 3.0 & Industry 4.0, or maybe you’re hearing the terms for the first time. This article will go over the basic components and differences between the two. We are in a new era of manufacturing, and companies either large or small are converting from Industry 3.0 to Industry 4.0. Why is this topic becoming so relevant today? Well, for starters, the global industry 4.0 market accounted for $68.2 billion in 2021 and is predicted to achieve a market size of $261.9 Billion by 2030.

Quick History 101 Lesson:

18^th Century, England; James Watt invented the steam engine, revolutionizing the manufacturing industry and coining the term “Industry 1.0”. The second Industrial Revolution started in the late 1800s after the expansion of electrical technology thanks to a man by the name of, Thomas Edison. These monumental inventions that are sometimes taken for granted but are the origin of the mind-blowing technology we all use today. And so, the story begins:

What is industry 3.0?

The path to Industry 3.0 was made possible by the introduction of computers in the mid-1900s, known as the “Digital Revolution”. Computer technology, electronic systems, and automation became the dominant force in the industrial market, which was the catalyst for Industry 3.0. Old factories became automated and shifted from analogue and mechanical systems to electrical and digital systems. The process began through partial automation, which was achieved through simple computers and PLCs (programmable logic controllers). Machines could now be controlled much more efficiently, reducing human intervention to a minimum. This was an enormous step forward compared to series production, as engines were far more efficient, and we were able to rely more on automated processes on the assembly line to perform human tasks. Ultimately, Industry 3.0 automated processes on the production line, replacing blue-collar jobs with white-collar jobs.

What is Industry 4.0

Here is where a simple “google search” may not do you any good, as there are several different meanings and definitions of “Industry 4.0” out there. Industry 4.0 is the revolution happening today, constantly adapting and changing to mold the future of global manufacturing. This is a relatively new concept, to give you an idea, companies such as Amazon and Tesla are using Industry 4.0 technology and have still not fully integrated it into their business model.  The common explanation of Industry 4.0 is “the intelligent networking of machines and processes in the industry with the aid of information and communication technology”. For those still scratching their head, this means the production process is now fully automated, 100% eliminating human error from the equation compared to Industry 3.0. “Digital transformation” is the integration of digital technology into all fields of business, essentially changing how companies operate and deliver value to the end user. The so-called “Holy Grail” of Industry 4.0 is implementing digital transformation wherein products are autonomously manufactured, monitored, and delivered using software processes without the intervention of humans.

Key Differences of 3.0 & 4.0

Fortune 500 companies are working diligently to automize their processes and reach the “Holy Grail” of Industry 4.0 technologies. Achieving the Holy Grail means companies can automatically take a sales order and schedule, operate, and deliver the order with zero human intervention. Examples of where Industry 4.0 could be implemented are endless, anywhere from vehicles, medical equipment, home building, retail designs, and the list goes on. Let’s be honest, robots and computers are far more efficient and reliable than humans regarding certain tasks. The functionality of Industry 4.0 brings us to a new paradigm of how we operate day-to-day business operations. There is still a lot more to come while Industry 4.0 evolves, sit back and enjoy the ride!

Mean monitoring or control charting in Statistical Process Control (SPC) is used to monitor trends or shifts in the manufacturing process. It helps to understand anomalies and define the typical production process variation (natural process variation or common cause).

In this guide, you will learn how to create an SPC dashboard to monitor the continuous manufacturing process. You will see how to calculate common SPC indicators using SQL and how to customize balloon’s views to create a unique experience for your users.

Tools needed:

• Any SQL database. We will use free and open-source PostgreSQL.
• Database schema from Q-DAS - popular statistical software. You can download SQL scripts for the schema from Q-DAS’ website.
• KensoBI. Sign up for your free cloud account at https://cloud.kensobi.com/signup.
• Download and import dashboard from the previous article.

We will be extending the dashboard we build in our previous blog post. If you already have it, open it, go to dashboard settings and click Save As to save it under a different name.

Note: when you re-import the same dashboard, you will be required to change UUID - just add or remove a letter to make it unique.

SPC calculations in SQL

We need to expand our existing database query to calculate some common SPC indicators. Navigate to the Queries tab and replace query A with the following:

--calculate SPC indicators
SELECT 
	substring(memerknr from '(.*)\[') as feature,
	substring(memerknr from '\[(.*)\]') as control,
	'point' as featuretype,
	Menennmas as value,
	Meugw as lsl, 
  	Meogw as usl,
	avg(sampleMean) as grandMean, 
	max(sampleMean)-min(sampleMean) as range,  
	min(sampleMean) as min,
	max(sampleMean) as max,	
	stddev_pop(sampleMean) as stdDev,
	avg(sampleMean) + (0.577 * (max(sampleMean)-min(sampleMean))) as ucl,
	avg(sampleMean) - (0.577 * (max(sampleMean)-min(sampleMean))) as lcl,
	(Meogw - Meugw)/(6*stddev_pop(sampleMean)) as cp,
	LEAST (((Menennmas + Meogw) - avg(sampleMean))/(3*stddev_pop(sampleMean)),
		   (avg(sampleMean) - (Menennmas + Meugw))/(3*stddev_pop(sampleMean))) as cpk
FROM(
	--3) calculate sample mean for each characteristic 
	SELECT 
		characteristicId,
		avg(measurementValue) as sampleMean, 
		sampleNumber
	FROM(			
		-- 2) group measurements for each characteristic in samples size of 5
		SELECT
			w.wvmerkmal as characteristicId, 
			w.wvwert measurementValue, 			
			wvdatzeit as measurementDate, 
			(row_number() OVER (PARTITION BY wvmerkmal 
            					ORDER BY wvmerkmal, 
                                wvdatzeit DESC) - 1) / 5 AS sampleNumber 
		FROM 
			wertevar w
		WHERE
			w.wvteil = 1 
			-- 1) filter only X,Y and Z characteristics for part 1
			AND w.wvmerkmal in (SELECT memerkmal FROM merkmal WHERE 
            					meteil = 1 
								AND memerknr like '%[x]' 
                                OR memerknr like '%[y]' 
                                OR memerknr like '%[z]')
			AND $__timeFilter(wvdatzeit)					
	) means
	GROUP BY 
		sampleNumber,
		characteristicId
) sampleMeans, merkmal characteristic
WHERE
	sampleMeans.characteristicId = characteristic.memerkmal
GROUP BY 
	 memerknr, Menennmas, Meugw, Meogw

Ok, this might look wild at first glance. No worries. Let’s go over what is happening here.

1. This is a simple performance trick to filter this massive measurement table quickly. In this example, we will focus only on in X, Y, and Z characteristics of part with ID=1.
2. This statement filters measurements and groups them into samples of size 5.
3. Calculate the sample mean for each characteristic
4. Calculate SPC indicators:
   • Grand mean
   • Range
   • Minimum
   • Maximum
   • Standard Deviation
   • Lower Control Limit (LCL)
   • Upper Control Limit (UCL)
   • Process Capability (Cp)
   • Process Capability Index (Cpk)

Balloon chart data

Our balloon charts should display sample means instead of raw measurement values. Let’s reuse query A. We only need a sample mean for each characteristic so remove all other calculations. Paste in following SQL in query B and change Format As dropdown to table.

SELECT 	
	substring(memerknr from '(.*)\[') as feature,
	substring(memerknr from '\[(.*)\]') as control,
	sampleMean,
	sampleNumber +1 as sampleNumber
FROM(
	--calculate mean of each sample
	SELECT 
		characteristicId,
		avg(measurementValue) as sampleMean, 
		sampleNumber
	FROM(			
		-- group measurements for each characteristic in samples size of 5
		SELECT
			w.wvmerkmal as characteristicId, 
			w.wvwert measurementValue, 			
			wvdatzeit as measurementDate, 
			(row_number() OVER (PARTITION BY wvmerkmal 
            					ORDER BY wvmerkmal, 
                                wvdatzeit DESC) - 1) / 5 AS sampleNumber 
		FROM 
			wertevar w
		WHERE
			w.wvteil = 1 
			-- 1) filter only X,Y and Z characteristics for part 1
			AND w.wvmerkmal in (SELECT memerkmal FROM merkmal WHERE 
            					meteil = 1 
								AND memerknr like '%[x]' 
                                OR memerknr like '%[y]' 
                                OR memerknr like '%[z]')
			AND $__timeFilter(wvdatzeit)
	) means
	GROUP BY 
		sampleNumber,
		characteristicId
) sampleMeans, merkmal characteristic
WHERE
	sampleMeans.characteristicId = characteristic.MEMERKMAL

View groups

Switch to the Visualization tab, select Point template in Balloon Settings, scroll down to Balloon Views, and click on Add button to add a new view.  Enter the following settings:

First column with value X should be set to static value. Set other cells to type Number and decimals 2.

Create another table view called X bottom:

And another one:

Switch to X view. Scroll down to Graph Axes section and change decimals to 2 in Left Y settings. Next, in X-Axis change:

Mode: Data series
X column: sampleNumber
Y column: sampleMean

In Graph Thresholds, add lines for grand mean, UCL and LCL.

Exit edit mode and resize balloon with X characteristic, so both tables and chart are visible. We made a lot of changes, so let’s save the current dashboard.

Conditional styling

A proper monitoring dashboard has to include color highlighting to spot indicators requiring attention quickly. KensoBI can dynamically change balloon colors, and individual table cells based on values returned from the database.

We want to turn balloon, label, and 3D feature red when Cp and Cpk for X, Y, or Z go below our limit. To do this, go back to editor, select Point template, and press the +Add Color Mapping button.

Add mapping for each control and characteristic.

The last step is to add conditional formatting to individual values in the balloon table. Scroll down to the Balloon Views section and then select X bottom view. Click on the Cp column, then Add Style button.  Change = to < and set value to the desired limit. Repeat for Cpk and standard deviation.

Now, let’s duplicate it for Y and Z characteristics. Select each view, press the  green clone button  and change the control value.

Congratulations! Your SPC dashboard is ready!

You can download the latest version of this dashboard from our demo instance. Send us a message if you need an account.

Have you ever found it inconvenient to import features to the free edition of GOM Inspect? As you may know, the free edition does not allow you to edit Import Templates. You are forced to format the input file in a certain way. You will also need to create and load files separately for elements and inspections.

Don’t let this limitation slow you down. I wrote Node-RED flow to automatically convert all your CSV files (in your column format) to the GOM XML file.

GOM’s Inspection Exchange Format is a first-class citizen for data transfer in GOM software. It supports the import of geometry primitives, dimensions, GD&T elements, and even meshes.

Node-RED flow

Go to node-red library and to import the flow.

If you not yet familiar with Node-RED, jump into my previous blog post where I go over what Node-RED is and a sample setup.

Both Node-RED and this flow are free and open-source. You can use and modify it to fit your specific use case. In the current version, it only supports the import of geometry primitives. I did not need to load other types of elements. However, reach out to me if you are interested in working together on adding more functionality to this flow.

Notes

There are only two nodes you need to modify:

Start node - enter the path to directory with CSV files.

Mapping template - You need to specify how columns in your CSV map to GOM elements, i.e., x field will map to CSV column called “coord-x.”

Testing

Use the following test file to test and learn how this flow works. Generated XML was tested on GOM Inspect 2019 and 2020.

Possible use cases

Loading CSV is just one of the use cases. We could easily add database node and pull features from the database and save them to GOM XML.  We could also support other file types or integrate them with automated measurement collection workflow.

I hope this is useful. If you like the content, like, share, and follow us on LinkedIn and Twitter!

A KensoBI 3D dashboard is a single page interactive report that tells the story of data through visualizations. It usually represents critical performance indicators and relevant business data accompanied by a 3D model.

In this guide, you will learn how to create a simple 3D dashboard to monitor the manufacturing inspection process.

Here are the tools we are going to use:

• Any SQL database. We will use free and open-source PostgreSQL.
• Database schema from Q-DAS - popular statistical software. You can download SQL scripts for the schema from Q-DAS’ website.
• KensoBI. Sign up for your free cloud account at https://cloud.kensobi.com/signup.

Create new dashboard with CAD panel

In KensoBI, click on the + sign, then Choose Visualization, and then double-click on CAD panel.

In the CAD section, press the Add button and then paste in the path to your STL or 3MF file. You can link the model stored in your own cloud storage or use a professional version and upload it directly to KensoBI. You can load as many models as you need, but try to keep your models below 10 MBs for the best user experience. Larger files will take longer to load, and on old devices, the browser may appear slow or unresponsive.

Next, exit the editor, resize the panel, and adjust your model. Use the mouse’s left button to rotate, the right button to move it, and the scroll wheel to zoom in or out. If you use a touchscreen device, you can pinch-zoom and move it around with your fingers. This is an excellent time to stop and save your work.

Add features and characteristics

Let’s go back to the panel editor. Click on the panel’s header, then select edit. Click on the Queries tab if you not already there. Query editor allows us to communicate with data sources and get data for visualizations. Depending on your data source, this editor may look a little different.

You can use the query builder to build your request or switch to the raw mode and start typing raw SQL query.  

KensoBI can construct a feature from the dataset in two formats - feature per row and characteristic per row.

Feature per row -  where each characteristic has its own column.

SELECT feature, x, y, z FROM features

Characteristic per row - feature is constructed from characteristics in rows by grouping them by feature name.

SELECT feature, control, value FROM characteristics

Default Q-DAS schema does not come with a feature table to link characteristics. You can either create it yourself or come up with some clever naming structure for your characteristics. This exactly what we are going to do. Our characteristic name will consist of a feature name and control in the following format:

featureName[control] i.e. TX9019[x]

We will use substring functions available in Postgres to derive feature name and characteristic control.

Here is the full query:

SELECT 
	substring(memerknr from '(.*)\[') as feature,
	substring(memerknr from '\[(.*)\]') as control,
	Menennmas as value
FROM
	merkmal 
WHERE
	meteil = 1

We expect our result to be in a table format, not time series, so select TABLE format in the dropdown below the input box. Enter the query in query window and click away. It will trigger a database call and features should show up on our model.

Remember, at the very minimum, we need x,y,z characteristics to construct a feature and draw it in the 3D space.

Feature labels and balloons

Our features are now displayed correctly in 3D space. You can click on any feature to see its label. You can show all labels by going to the panel menu -> Balloons -> Open all.

You can also pin balloons by clicking on them. Move pinned balloons by dragging the balloon’s header and place them around the model.

Templates

KensoBI comes with a predefined balloon template for basic feature types. If we provide feature type (feature type column) in our query, each feature balloon will be formatted according to its template.

Templates can have more than one view. Let’s modify the “Point” template and add LCL and UCL values to our table view. Before we can add a new column, we need to include it in our query.

SELECT 
	substring(memerknr from '(.*)\[') as feature,
	substring(memerknr from '\[(.*)\]') as control,
	Menennmas as value,
	(Menennmas + Meugw) as lsl, 
    (Menennmas + Meogw) as usl,
	'point' as featuretype
FROM
	merkmal 
WHERE
	meteil = 1

Now, go back to balloon editing. Change columns from 2 to 4. Click on the column header and type LSL. Next, click on the cell in X row. Select “lsl” and provide control value – X. Repeat for Y and Z coordinates.

You can see values changing in our balloons. Do the same for USL. Exit the editor and adjust balloons.

Show measurements in feature balloons

Go to Query Editor and click on the Add Query button. In our query, we need to provide time, value, and a metric name. The metric name needs to be in a specific format: feature[space]control .

SELECT 
	concat(substring(memerknr from '(.*)\['),
    	' ',
        substring(memerknr from '\[(.*)\]'))
    as characteristic,
    WVDATZEIT as "time",
    WVWERT as "value"
FROM
	WERTEVAR, merkmal
WHERE 
	WVMERKMAL = merkmal.MEMERKMAL
    AND wvteil = 1 
    AND $__timeFilter(WVDATZEIT)  
ORDER BY
	WVDATZEIT ASC

Notice $__timeFilter function. It is a built-in function to automatically take the current dashboard’s time range and add it to the query.

Again, our query is a bit convoluted because we are embedding feature name and control in our characteristic name. Anyhow, let’s add chart views. Go to the Visualization tab, select Point template, and create a new view by clicking the +Add button in the Balloon Views section. Set name to X, view type to chart, and control to X. Duplicate this view for Y and Z and by clicking the copy button and set the control to Y and Z.

Click on the balloon header and select Y.  You should now see the chart with the latest measurements. We can make our chart look a little better by modifying chart settings. In draw modes, disable points, set fill to 0 and line width to 2.

Congratulations! Your first 3D dashboard is ready!

You can download the latest version of this dashboard from our demo instance. Send us a message, and we will create a demo account for you.