The physical world is continuous, but a digital system can only store a finite list of numbers. Every time an analog signal crosses into the digital domain, it must be snapped to the nearest available code, and the tiny gap between the true value and that code is quantization error. It is not a fault, a defect, or something a better calibration can remove. It is a permanent tax that digitization levies on every analog input, and its size is fixed by how many bits the converter has.
Quantization Error in one line: Quantization error is the small, unavoidable error introduced when a continuous analog signal is rounded to the nearest discrete digital code during analog-to-digital conversion. Because any real value between two codes must be assigned to one of them, the error is at most half of one least significant bit, or half a code width. The number of bits in the converter sets the code width, and therefore the size of this error, for every reading.
An analog-to-digital converter divides its input span into a fixed number of equal steps, one for each code it can output, and the width of one of those steps is called the least significant bit, or LSB. When a continuous input value arrives, the converter assigns it to the nearest code, which means the stored number can differ from the true value by anywhere up to half a code width in either direction. That worst-case difference of plus or minus half an LSB is the quantization error, and it is present on every single conversion.
The error is deterministic in one sense and random in another. For any fixed input, the rounding is the same each time, but across the many different values a live signal takes, the error scatters roughly uniformly across the plus-or-minus half-LSB band. This is why quantization is often modeled as a small uniform noise added to the signal, setting a noise floor below which the converter simply cannot resolve anything. No amount of averaging removes the floor entirely, though averaging combined with real signal noise can help recover information below one LSB.
Crucially, quantization error is unrelated to calibration accuracy. A perfectly calibrated, drift-free converter still rounds, and still carries its half-LSB error. It is a property of the digitization itself, baked in by the bit depth, and the only way to shrink it is to use more bits or a narrower input range so that each code covers a smaller slice of the physical span. Understanding this keeps engineers from chasing a rounding limit with calibration effort that cannot touch it.
The size of the quantization step in engineering units depends on both the bit depth and the range being measured. Take a pressure input scaled zero to one hundred psi. A twelve-bit converter divides its span into four thousand ninety-six codes, so each code covers roughly one hundred divided by four thousand ninety-six, a bit under twenty-five thousandths of a psi per step, with a quantization error of half that per reading. That is fine for many purposes and invisible against most process behavior.
Move to a sixteen-bit converter and the same zero-to-one-hundred span is divided into sixty-five thousand five hundred thirty-six codes. Each step now covers roughly one hundred divided by sixty-five thousand, about one and a half thousandths of a psi, sixteen times finer than the twelve-bit case. The quantization error shrinks proportionally. The jump from twelve to sixteen bits does not make the sensor more accurate, but it stops the converter itself from being the coarse link that throws away fine detail the sensor could otherwise deliver.
The lesson is that bit depth interacts with range. Digitizing a narrow band of interest with a wide-ranged input wastes codes: if the process only ever moves across a small part of the configured span, most of the converter's codes sit unused above and below, and the effective resolution over the region that matters is far coarser than the headline bit count suggests. Scaling the input range to the band you actually care about is often more valuable than adding bits.
On a cheaply carded SCADA point, quantization error can quietly become the largest term in the whole measurement budget. If a precise, well-calibrated sensor feeds a low-resolution input card, the card's coarse code width throws away much of the accuracy the sensor worked to provide, and the reported value can only ever be as fine as the quantization step. Pairing an expensive transmitter with a bargain input card is a common and self-defeating mismatch, because the weakest link caps the result.
This is why the input card belongs in the uncertainty budget alongside the sensor and transmitter. When you build the budget for a point, the quantization step in engineering units is one of the rows, and if it turns out to rival or exceed the sensor and transmitter terms, the fix is a higher-resolution card or a narrower scaled range, not a better sensor. Seeing the quantization term explicitly stops teams from over-investing in field instruments while the digitizing stage silently limits everything downstream.
Because Merobix historizes the digitized value that arrives from the card, the quantization step sets the finest change the historian can ever record for that point. If a small but important process move is smaller than one code width, it will not appear as a change at all, it will be swallowed by the rounding. Knowing each point's quantization step lets you set trend scales, deadbands, and change-detection thresholds sensibly, and tells you honestly which points can resolve fine movement and which are limited by the card long before the sensor is the bottleneck.
No. Quantization error comes from rounding a continuous value to the nearest discrete code, and it exists even in a perfectly calibrated, drift-free converter. Calibration corrects gain and offset errors, but it cannot remove the fundamental rounding step. The only ways to reduce quantization error are to use a converter with more bits or to scale the input range so each code covers a smaller slice of the physical span.
For the same input range, a sixteen-bit converter has sixteen times as many codes as a twelve-bit converter, so each code, and therefore the quantization step, is sixteen times smaller. On a zero to one hundred psi range, a twelve-bit step is a bit under twenty-five thousandths of a psi, while a sixteen-bit step is around one and a half thousandths. The error scales down proportionally with the finer code width.
Only up to the point where quantization stops being the limiting error. Adding bits shrinks the quantization step, but if the sensor, transmitter, or environmental effects already dominate the uncertainty budget, extra bits digitize their error more finely without improving the true accuracy. Bits help most when the converter is the coarsest link, and scaling the range to the band of interest is often more effective than simply adding resolution.
Merobix reads your field devices into a cloud SCADA - the real thing behind these terms, live in days from any browser.