Working with Fixed-Point Numbers in Rust Using the fixed Crate

2025-12-20T00:00:00+00:00
While revising the Pico Pico book (an embedded Rust book for the Raspberry Pi Pico 2), I was working on the PWM chapter for controlling servo motors. In that chapter, embassy-rp uses a fixed-point number to store the PWM clock divider. Both the integer and fractional parts are stored together in a single field called divider, using a type from the “fixed” crate.</p>
Instead of explaining fixed-point numbers briefly there, I decided it made more sense to write a separate blog post. That is how this post came to be. Here, I will give a short introduction to fixed-point numbers and explain how to use them in Rust.</p>
</span></a> What is Fixed Point?</h2>
A fixed-point number is a way to represent fractional (non-integer) values using only integer arithmetic. Unlike floating-point numbers (like f32</code> or f64</code>), fixed-point numbers reserve a predetermined number of bits for the fractional part. This makes them predictable, fast, and ideal for embedded systems where floating-point hardware might be unavailable or too slow.</p>
</span></a>
Understanding Fixed-Point Notation</h2>
This idea is explained well in the fixed crate</a> documentation, but let me give a quick overview.</p>
The key idea is this. If you have n total bits and you choose f bits for the fractional part, then you automatically have n - f</code> bits left for the integer part. Once this split is chosen, the position of the decimal point is fixed.</p>
Fixed-point numbers maintain uniform spacing between consecutive values throughout their range. The step size formula is 1/2^f</code>.</p>
For example, consider a 16-bit fixed-point number where 4 bits are used for the fraction. Here, f = 4, so the remaining 16 - 4 = 12 bits are used for the integer part. With 4 fractional bits, the smallest step size is 1 / 2⁴ = 0.0625. This means fractional values are represented as multiples of 0.0625. After 0.0625, the next value is 0.125, and the numbers continue to increase in fixed, evenly spaced steps.</p>
</span></a>
Binary Representation</h2>
Let’s use a 16-bit unsigned number as an example. Normally, to store an integer like 5, the binary representation would be 0000_0000_0000_0101</code>. With fixed-point representation, we dedicate a predetermined number of bits for the fractional part, depending on our precision needs. The remaining upper bits store the integer part.</p>
For instance, if we allocate the last 4 bits for the fraction, we have 12 bits left for the integer.</p>
</span></a>
Example: 4 Fractional bits</h3>
Here’s how the bits map to their values:</p>
Bit Position</th> 15</th> 14</th> 13</th> 12</th> 11</th> 10</th> 9</th> 8</th> 7</th> 6</th> 5</th> 4</th> .</th> 3</th> 2</th> 1</th> 0</th></tr></thead>

Weight</td> 2¹¹</td> 2¹⁰</td> 2⁹</td> 2⁸</td> 2⁷</td> 2⁶</td> 2⁵</td> 2⁴</td> 2³</td> 2²</td> 2¹</td> 2⁰</td> </td> 2⁻¹</td> 2⁻²</td> 2⁻³</td> 2⁻⁴</td></tr>
</tbody></table>
The decimal point (shown as .</code> in the table) is just for our understanding, it doesn’t actually exist in memory. With 4 fractional bits, the smallest value we can represent is 2⁻⁴ = 0.0625, giving us a precision of 1/16.</p>
</span></a>
Example: 8 Fractional bits</h3>
If we need more precision, we can allocate more bits to the fractional part. With 8 fractional bits, we get:</p>
Bit Position</th> 15</th> 14</th> 13</th> 12</th> 11</th> 10</th> 9</th> 8</th> .</th> 7</th> 6</th> 5</th> 4</th> 3</th> 2</th> 1</th> 0</th></tr></thead>

Weight</td> 2⁷</td> 2⁶</td> 2⁵</td> 2⁴</td> 2³</td> 2²</td> 2¹</td> 2⁰</td> </td> 2⁻¹</td> 2⁻²</td> 2⁻³</td> 2⁻⁴</td> 2⁻⁵</td> 2⁻⁶</td> 2⁻⁷</td> 2⁻⁸</td></tr>
</tbody></table>
With 8 fractional bits, our smallest representable value is 2⁻⁸ = 0.00390625 (1/256), giving us finer precision but reducing the maximum integer we can represent.</p>
</span></a>
Fixed Crate Types</h2>
The fixed crate provides fixed-point number types in different sizes. The number in the type name tells you how many bits are used in total.</p>
For example, FixedI8 and FixedU8 are 8-bit fixed-point numbers. FixedI16 and FixedU16 are 16-bit types. In the same way, there are 32-bit, 64-bit, and even 128-bit fixed-point types, both signed (FixedI*) and unsigned (FixedU*).</p>
What makes these types flexible is the extra generic parameter that controls how many bits are used for the fractional part. For example, FixedU16<extra::U4></code> is a 16-bit unsigned fixed-point number where 4 bits are used for the fraction. That leaves 16 - 4 = 12 bits for the integer part. If you use FixedU16<U0></code>, there are no fractional bits, so it behaves just like a normal u16.</p>
The crate also provides convenient type aliases so you do not always have to write the generic form. For example, U12F4 represents a unsigned fixed-point number with 12 integer bits and 4 fractional bits. You can use it directly like this:</p>
use</span> fixed::</span></span>types::</span></span>U12F4</span>;</span>
</span></code></pre>
</span></a>
Example 1</h2>
Create a new Rust project, add the fixed</code> crate as a dependency, and replace main.rs with the following code.</p>
To make things easier to understand, the example prints the same value in several different forms.</p>
First, it prints the fixed-point value itself. The :.4 formatting is only for display and shows four digits after the decimal point.</p>
Next, it uses helper methods from the fixed crate to print the fractional part and the integer part separately.</p>
Then it prints the binary representation in two different ways.</p>
The first binary print ({:b}) is a human-friendly representation provided by the fixed crate. It inserts a binary point to show where the fractional bits are. This can feel a little confusing at first glance, at least it did for me. But once you get used to reading it, it actually becomes easier to reason about fixed-point values.</p>
The second binary print uses to_bits(), which returns the raw 16-bit value stored internally. For clarity, the integer bits and the fractional bits are manually separated with an underscore when printing.</p>
use</span> fixed::</span></span>{</span>FixedU16,</span> types::</span></span>extra</span>}</span></span>;</span>
</span>use</span> fixed::</span></span>types;</span>
</span>
</span>fn</span> </span>main</span></span>(</span></span>)</span></span></span></span> </span>{</span>
</span></span></span>    //</span> let f_u16: FixedU16<extra::U4> = FixedU16::from_num(5.75); // you can use this approach
</span></span></span></span>    let</span> f_u16:</span> FixedU16<</span>extra::</span></span>U4></span></span> =</span> types::</span></span>U12F4</span>::</span></span>from_num(</span>5.</span>75</span></span>)</span></span>;</span> //</span> or this approach
</span></span></span></span>    assert_eq!</span>(</span>f_u16,</span> 5.</span>75</span></span>)</span></span>;</span>
</span></span></span>
</span></span></span>    println!</span>(</span></span>"</span>Fixed Point: {:.4}</span>"</span></span></span>,</span> f_u16)</span></span>;</span>
</span></span></span>    println!</span>(</span></span>"</span>Fraction: {}</span>"</span></span></span>,</span> f_u16.</span>frac</span>(</span></span>)</span></span>)</span></span>;</span>
</span></span></span>    println!</span>(</span></span>"</span>Integer: {}</span>"</span></span></span>,</span> f_u16.</span>int</span>(</span></span>)</span></span>)</span></span>;</span>
</span></span></span>    println!</span>(</span></span>"</span>Binary with Fraction repr: {:b}</span>"</span></span></span>,</span> f_u16)</span></span>;</span>
</span></span></span>
</span></span></span>    //</span> println!("Actual binary: {:016b}", f_u16.to_bits());
</span></span></span></span>    let</span> bits =</span> format!</span>(</span></span>"</span>{:016b}"</span></span></span>,</span> f_u16.</span>to_bits</span>(</span></span>)</span></span>)</span></span>;</span>
</span></span></span>    let</span> formatted =</span> format!</span>(</span></span>
</span></span></span></span>        "</span>{}</span>_{}</span>"</span></span></span>,</span>
</span></span></span></span>        &</span>bits[</span>..</span>12</span>]</span></span>,</span>
</span></span></span></span>        &</span>bits[</span>12</span>..</span>]</span></span>,</span>
</span></span></span></span>    )</span></span>;</span>
</span></span></span>    println!</span>(</span></span>"</span>Actual binary: {}</span>"</span></span></span>,</span> formatted)</span></span>;</span>
</span></span></span>
</span></span></span>    println!</span>(</span></span>"</span>F32: {}</span>"</span></span></span>,</span> f_u16.</span>to_num::</span></span><</span>f32</span>></span></span>(</span></span>)</span></span>)</span></span>;</span>
</span></span></span></span>}</span></span></span>
</span></code></pre>
If you run this code, you will see output like this:</p>
Fixed</span></span> Point: 5.7500</span>
</span>Frac:</span></span> 0.75</span>
</span>Int:</span></span> 5</span>
</span>Binary</span></span> with Fraction repr: 101.11</span>
</span>Actual</span></span> binary: 000000000101_1100</span>
</span>F32:</span></span> 5.75</span>
</span></code></pre>
When I first saw Binary with Fraction repr: 101.11, it was confusing. My brain read the 11 in the fractional part as the number three. That is not how fixed-point fractions work.</p>
To understand what this value really represents, let’s look at the binary representation.</p>
Bit Position</th> 15</th> 14</th> 13</th> 12</th> 11</th> 10</th> 9</th> 8</th> 7</th> 6</th> 5</th> 4</th> .</th> 3</th> 2</th> 1</th> 0</th></tr></thead>

Stored Bit</td> 0</td> 0</td> 0</td> 0</td> 0</td> 0</td> 0</td> 0</td> 0</td> 1</td> 0</td> 1</td> </td> 1</td> 1</td> 0</td> 0</td></tr>
Weight</td> 2¹¹</td> 2¹⁰</td> 2⁹</td> 2⁸</td> 2⁷</td> 2⁶</td> 2⁵</td> 2⁴</td> 2³</td> 2²</td> 2¹</td> 2⁰</td> </td> 2⁻¹</td> 2⁻²</td> 2⁻³</td> 2⁻⁴</td></tr>
</tbody></table>
The integer part is straightforward. The bits 101 represent the value 5 using normal binary rules.</p>
The fractional part is where the confusion usually comes from. Each fractional bit represents a negative power of two.</p>
fraction</span></span> = 1 × 0.5 + 1 × 0.25 + 0 × 0.125 + 0 × 0.0625</span>
</span></code></pre>
That adds up to 0.75.</p>
</span></a>
Example 2</h2>
Let’s look at one more example. This time, I try to represent the value 20.3. I keep the same fixed-point configuration as before, with 4 fractional bits.</p>
use</span> fixed::</span></span>{</span>FixedU16,</span> types::</span></span>extra</span>}</span></span>;</span>
</span>use</span> fixed::</span></span>types;</span>
</span>
</span>fn</span> </span>main</span></span>(</span></span>)</span></span></span></span> </span>{</span>
</span></span></span>    let</span> f_u16:</span> FixedU16<</span>extra::</span></span>U4></span></span> =</span> FixedU16::</span></span>from_num(</span>20.</span>3</span></span>)</span></span>;</span>
</span></span></span>    assert_eq!</span>(</span>f_u16,</span> 20.</span>3125</span></span>)</span></span>;</span>
</span></span></span>
</span></span></span>    println!</span>(</span></span>"</span>Fixed Point: {:.4}</span>"</span></span></span>,</span> f_u16)</span></span>;</span>
</span></span></span>    println!</span>(</span></span>"</span>Fraction: {}</span>"</span></span></span>,</span> f_u16.</span>frac</span>(</span></span>)</span></span>)</span></span>;</span>
</span></span></span>    println!</span>(</span></span>"</span>Integer: {}</span>"</span></span></span>,</span> f_u16.</span>int</span>(</span></span>)</span></span>)</span></span>;</span>
</span></span></span>    println!</span>(</span></span>"</span>Binary with Fraction repr: {:b}</span>"</span></span></span>,</span> f_u16)</span></span>;</span>
</span></span></span>
</span></span></span>    //</span> println!("Actual binary: {:016b}", f_u16.to_bits());
</span></span></span></span>    let</span> bits =</span> format!</span>(</span></span>"</span>{:016b}"</span></span></span>,</span> f_u16.</span>to_bits</span>(</span></span>)</span></span>)</span></span>;</span>
</span></span></span>    let</span> formatted =</span> format!</span>(</span></span>
</span></span></span></span>        "</span>{}</span>_{}</span>"</span></span></span>,</span>
</span></span></span></span>        &</span>bits[</span>..</span>12</span>]</span></span>,</span>
</span></span></span></span>        &</span>bits[</span>12</span>..</span>]</span></span>,</span>
</span></span></span></span>    )</span></span>;</span>
</span></span></span>    println!</span>(</span></span>"</span>Actual binary: {}</span>"</span></span></span>,</span> formatted)</span></span>;</span>
</span></span></span>
</span></span></span>    println!</span>(</span></span>"</span>F32: {}</span>"</span></span></span>,</span> f_u16.</span>to_num::</span></span><</span>f32</span>></span></span>(</span></span>)</span></span>)</span></span>;</span>
</span></span></span></span>}</span></span></span>
</span></code></pre>
If you expect the line assert_eq!(f_u16, 20.3125) to fail, you might be surprised. It does not fail. The code compiles successfully and produces the following output:</p>
Fixed</span></span> Point: 20.3125</span>
</span>Fraction:</span></span> 0.3</span>
</span>Integer:</span></span> 20</span>
</span>Binary</span></span> with Fraction repr: 10100.0101</span>
</span>Actual</span></span> binary: 000000010100_0101</span>
</span>F32:</span></span> 20.3125</span>
</span></code></pre>
This happens because 20.3 cannot be represented exactly using this fixed-point format. As stated earlier, the fractional part can only increase in steps of 1 / 2^f. With 4 fractional bits, the step size is: 1 / 2^4 = 0.0625</code></p>
So the fraction 0.3 must be rounded to the nearest multiple of 0.0625. The value 0.3125 is a valid multiple:  0.0625 × 5 = 0.3125</code></p>
In the binary, it is represented like this:</p>
Bit Position</th> 15</th> 14</th> 13</th> 12</th> 11</th> 10</th> 9</th> 8</th> 7</th> 6</th> 5</th> 4</th> .</th> 3</th> 2</th> 1</th> 0</th></tr></thead>

Stored Bit</td> 0</td> 0</td> 0</td> 0</td> 0</td> 0</td> 0</td> 0</td> 0</td> 1</td> 0</td> 1</td> </td> 0</td> 1</td> 0</td> 1</td></tr>
Weight</td> 2¹¹</td> 2¹⁰</td> 2⁹</td> 2⁸</td> 2⁷</td> 2⁶</td> 2⁵</td> 2⁴</td> 2³</td> 2²</td> 2¹</td> 2⁰</td> </td> 2⁻¹</td> 2⁻²</td> 2⁻³</td> 2⁻⁴</td></tr>
</tbody></table>
If we calculate the fractional part:</p>
fraction</span></span> = 0 × 0.5 + 1 × 0.25 + 0 × 0.125 + 1 × 0.0625 = 0.3125</span>
</span></code></pre>
</span></a>
In Raspberry Pi Pico 2 (RP2350)</h2>
On the Raspberry Pi Pico 2 (RP2350), the PWM clock divider controls how fast the PWM counter runs. The PWM counting rate is calculated by dividing the system clock frequency by this divider value.</p>
The divider register stores the value using a fixed point format. It is split into an integer part and a fractional part. The upper 8 bits represent the integer portion of the divider, and 4 bits represent the fractional portion. Together, these bits form a fixed point number, allowing finer control over the PWM frequency.</p>
The following code snippet is from the rp-pac</a> crate and shows how the divider register is defined.</p>
#</span>[</span>doc</span> =</span> "</span>INT and FRAC form a fixed-point fractional number. Counting rate is system clock frequency divided by this number. Fractional division uses simple 1st-order sigma-delta."</span></span>]</span></span>
</span>#</span>[</span>repr</span>(</span></span></span>transparent</span></span>)</span></span></span>]</span></span>
</span>#</span>[</span>derive</span>(</span></span></span>Copy,</span> Clone,</span> Eq,</span> PartialEq</span></span>)</span></span></span>]</span></span>
</span>pub</span> struct</span> </span>ChDiv</span></span>(</span>pub u32</span></span>)</span></span>;</span>
</span>impl</span> </span>ChDiv</span> </span>{</span>
</span></span></span>    #</span>[</span>inline</span>(</span></span></span>always</span></span>)</span></span></span>]</span></span>
</span></span></span>    pub</span> const</span> fn</span> </span>frac</span></span>(</span>&</span>self</span></span>)</span></span></span></span> -></span> u8</span></span> </span>{</span>
</span></span></span></span></span>        let</span> val =</span> (</span>self</span>.</span>0</span> ></span>></span> 0</span>usize</span></span>)</span></span> &</span> 0x0f</span>;</span>
</span></span></span></span></span>        val as</span> u8</span>
</span></span></span></span></span>    </span>}</span></span></span>
</span></span></span>
</span></span></span>    ...</span>
</span></span></span>
</span></span></span>    #</span>[</span>inline</span>(</span></span></span>always</span></span>)</span></span></span>]</span></span>
</span></span></span>    pub</span> const</span> fn</span> </span>int</span></span>(</span>&</span>self</span></span>)</span></span></span></span> -></span> u8</span></span> </span>{</span>
</span></span></span></span></span>        let</span> val =</span> (</span>self</span>.</span>0</span> ></span>></span> 4</span>usize</span></span>)</span></span> &</span> 0xff</span>;</span>
</span></span></span></span></span>        val as</span> u8</span>
</span></span></span></span></span>    </span>}</span></span></span>
</span></span></span>
</span></span></span>    ...</span>
</span></span></span></span>}</span></span></span>
</span></code></pre>
Although the register is defined as a 32 bit unsigned integer, only 12 bits are actually used. Of these, 8 bits are used for the integer part and 4 bits for the fractional part.</p>
In the embassy-rp crate, the divider is represented using a type from the fixed crate. When configuring the PWM hardware, this fixed point value is converted into a u32 and written directly to the register.</p>
if</span> config.</span>divider ></span> FixedU16::</span></span><</span>fixed::</span></span>types::</span></span>extra::</span></span>U4></span></span>::</span></span>from_bits(</span>0xFFF</span></span>)</span></span> {</span>
</span></span>    panic!</span>(</span>"</span>Requested divider is too large"</span></span></span>)</span></span>;</span>
</span></span></span>}</span></span>
</span>
</span>p.</span>div</span>(</span></span>)</span></span>.</span>write_value</span>(</span>ChDiv(</span>config.</span>divider.</span>to_bits</span>(</span></span>)</span></span> as</span> u32</span></span>)</span></span></span>)</span></span>;</span>
</span></code></pre>
impl Blog for Rust - fixed-point

Working with Fixed-Point Numbers in Rust Using the fixed Crate
