Chapter 9 Introduction to Floating-Point: Basics, Data Types,
9.11 Conversions to Non-Floating-Point Formats
Often data is input to a system in integer or fixed-point formats and must be con- verted to floating-point to be operated on. For example, the analog-to-digital con- verter in the TM4C1233H6PM microcontroller from Texas Instruments outputs a 12-bit digital conversion in the range 0 to the analog supply voltage, to a maximum of 4 volts. Using the fixed-point to floating-point conversion instructions, the conver- sion from a converter output to floating-point is possible in two instructions—one to move the data from memory to a floating-point register, and the second to perform the conversion. The range of options in the fixed-point conversion instructions makes it easy to configure most conversions without any scaling required. In Chapter 18, we will look at how to construct conversion routines using these instructions, which may be easily called from C or C++.
In the following sections, we will look at the instructions for conversion between 32-bit integers and floating-point single-precision, and between 32-bit and 16-bit fixed-point and floating-point single-precision.
TABLE 9.15
Useful Floating-Point Constants
Constant Value imm4H Imm4L
0.5 0110 0000
0.125 0100 0000
2.0 0000 0000
31 0011 1111
15 0010 1110
4.0 0001 0000
−4.0 1001 0000
1.5 0111 1000
2.5 0001 0100
0.75 0110 1000
9.11.1 ConVeRsionsBeTWeen inTegeRAnd fLoATing-poinT
The Cortex-M4 has two instructions for conversion between integer and floating- point formats. The instructions have the format
VCVT{R}<c>.<T32>.F32 <Sd>, <Sm>
VCVT<c>.F32.<T32> <Sd>, <Sm>
The <T32> may be replaced by either S32, for 32-bit signed integer, or U32, for 32-bit unsigned integer. Conversions to integer format commonly use the round- TowardZero (RZ) format. This is the behavior seen in the C and C++ languages; con- version of a floating-point value to an integer always truncates any fractional part.
For example, each of the following floating-point values, 12.0, 12.1, 12.5, and 12.9, will return 12 when converted to integer. Likewise, −12.0, −12.1, −12.5, and −12.9 will return −12. To change this behavior, the R variant may be used to perform the conversion using the rounding mode in the FPSCR. When the floating-point value is too large to fit in the destination precision, or is an infinity or a NaN, an Invalid Operation exception is signaled, and the largest value for the destination type is returned. Exceptions are covered in greater detail in Chapter 10.
A conversion from integer to floating-point always uses the rounding mode in the FPSCR. If the conversion is not exact, as in the case of a very large integer that has more bits of precision than are available in the single-precision format, the Inexact exception is signaled, and the input integer is rounded. For example, the value 10,000,001 cannot be precisely represented in floating-point format, and when converted to single-precision floating-point will signal the Inexact exception.
9.11.2 ConVeRsionsBeTWeen fixed-poinTAnd fLoATing-poinT
The formats of the fixed-point data type in the Cortex-M4 can be either 16 bits or 32 bits, and each may be signed or unsigned. The position of the binary point is identi- fied by the <fbits> field, which specifies the number of fractional bits in the format.
For example, let us specify an unsigned, 16-bit, fixed-point format in which there are 8 bits of integer data and 8 bits of fractional data. So the range of this data type is [0, 128), with a numeric separation of 1/256, or 0.00390625. That is, the value incre- ments by 1/256 as one is added to the least-significant bit.
The instructions have the format
VCVT{<cond>}.<Td>.F32 <Sd>, <Sd>, #<fbits>
VCVT{<cond>}.F32.<Td> <Sd>, <Sd>, #<fbits>
The <Td> value is the format of the fixed-point value, one of U16, S16, U32, or S32. Rounding of the conversions depends on the direction. Conversions from fixed-point to floating-point are always done with the roundTiesToEven rounding mode, and conversions from floating-point to fixed-point use the roundTowardZero rounding mode. We will consider these rounding modes in Chapter 10. One thing to notice in these instructions is the reuse of the source register for the destination register. This is due to the immediate <fbits> field. Simply put, there is not room
in the instruction word for two registers, so the source register is overwritten. This should not be an issue; typically this instruction takes a fixed-point value and con- verts it, and the fixed-point value is needed only for the conversion. Likewise, when a floating-point value is converted to a fixed-point value, the need for the floating-point value is often gone.
EXAMPLE 9.5
Convert the 16-bit value 0x0180 in U16 format with 8 bits of fraction to a single- precision floating-point value.
soLuTion ADR r1, DataStore
LDRH r2, [r1]
; Convert each of the 16-bit data to single-precision with
; different <fbits> values
VMOV.U16 s7, r2 ; load the 16-bit fixed-pt to s reg VCVT.F32.U16 s7, s7, #8 ; convert the fixed-pt to SP with
; 8 bits of fraction loop B loop
ALIGN DataStore
DCW 0x0180
The value in register s7 after this code is run is 0x3FC00000, which is 1.5. How did the Cortex-M4 get this value? Look at Table 9.16.
Notice that we specified 8 bits of fraction (here 8’b10000000, representing 0.5 in decimal) and 8 bits of integer (here 8’b00000001, representing 1.0), hence the final value of 1.5. In this format, the smallest representable value would be 0x0001 and would have the value 0.00390625, and the largest value would be 0xFFFF, which is 255.99609375 (256 – 0.00390625). Any multiple of 0.00390625 between these two values may be represented in 16 bits. If we wanted to do this in single-precision, each value would require 32 bits. With the U16 format we can represent each in only 16 bits.
There are valid uses for this type of conversion. The cost of memory is often a factor in the cost of the system, and minimizing memory usage, particularly ROM storage, will help. Another use is generating values that may be used by peripherals that expect outputs in a non-integer range. If we want to control a motor and the motor control
TABLE 9.16
Output of Example 9.5
Format U/S,
<fbits > Hex Value Binary Value
Decimal Value
Single-Precision Floating-Point Value
U16, 8 0x0180 00000001.10000000 1.5 0x3FC00000
inputs are between 0 to almost 10, with 4 bits of fraction (so we can increment by 1/16, i.e., 0, 1/16, 1/8, 3/16, … 9.8125, 9.875) the same instruction can be used to convert from floating-point values to U16 values. Conversion instructions are another tool in your toolbox for optimizing your code for speed or size, and in some cases, both.
The 16-bit formats may also be interpreted as signed when the S16 format is used, and both signed and unsigned fixed-point 32-bit values are available. Table 9.17 shows how adjusting the #fbits value can change how a 16-bit hex value is inter- preted. If the #fbits value is 0, the 16 bits are interpreted as an integer, either signed
TABLE 9.17
Ranges of Available 16-Bit Fixed-Point Format Data
fbits
Integer Bits:
Fraction Bits
Numeric Separation
Range Unsigned Range Signed
0 16:0 20, 1 0 … 65,535
−32,768 … 32,767
1 15:1 2−1, 0.5 0 … 32,767.5
−16,384 … 16,383.5
2 14:2 2−2, 0.25 0 … 16,383.75
−8,192 … 8,191.75
3 13:3 2−3, 0.125 0 … 8,191.875
−4,096 … 4,047.875
4 12:4 2−4, 0.0625 0 … 4,095.9375
−2,048 … 2,023.9375
5 11:5 2−5, 0.03125 0 … 2,047.96875
−1,024 … 1,023.96875
6 10:6 2−6, 0.015625 0 … 1,023.984375
−512 … 511.984375
7 9:7 2−7, 0.0078125 0 … 511.9921875
−256 … 255.9921875
8 8:8 2−8, 0.00390625 0 … 255.99609375
−128 … 127.99609375
9 7:9 2−9, 0.001953125 0 … 127.998046875
−64 … 63.998046875
10 6:10 2−10, 0.000976563 0 … 63.999023438
−32 … 31.999023438
11 5:11 2−11, 0.000488281 0 … 31.99951171875
−16 … 15.99951171875
12 4:12 2−12, 0.000244141 0 … 15.999755859375
−8 … 7.999755859375
13 3:13 2−13, 0.00012207 0 … 7.9998779296875
4 … 3.9998779296875
14 2:14 2−14, 6.10352E-05 0 … 3.99993896484375
2 … 1.99993896484375
15 1:15 2−15, 3.05176E-05 0 … 1.999969482421875
−1 … 0.999969482421875
16 0:16 2−16, 1.52588E-05 0 … 0.999984741210937
−0.5 … 0.499984741210937
or unsigned, and the numeric separation is 1, as we expect in the integer world.
However, if we choose #fbits to be 8, the 16 bits are interpreted as having 8 integer bits and 8 fraction bits, and the range is that of an 8-bit integer, but with a numeric separation of 2−8, or 0.00390625, allowing for a much higher precision than is avail- able with integers by trading off range.
When the range and desired precision are known, for example, for a sensor attached to an analog-to-digital converter (ADC) or for a variable speed motor, the fixed-point format can be used to input the data directly from the converter without having to write a conversion routine. For example, if we have an ADC with 16-bit resolution over the range 0 to +VREF, we could choose a VREF value of 4.0 V. The U16 format with 14 fraction bits has a range of 0 up to 4 with a resolution of 2−14. All control computations for the motor control could be made using a single-precision floating-point format and directly converted to a control voltage using
VCVT.U16.F32 s9, s9, #14
The word value in the s9 register could then be written directly to the ADC buffer location in the memory map. If the conversion is not 16 bits, but say 12 bits, conver- sion with the input value specified to be the format U16 with 10 fraction bits would return a value in the range 0 to 4 for all 12-bit inputs. Similarly, if VREF is set to 2 V, the U16 format with 15 fraction bits would suffice for 16-bit inputs and the U16 with 11 fraction bits for 12-bit inputs. The aim of these instructions is to eliminate the need for a multiplier step for each input sampled or control output. Careful selection of the VREF and the format is all that is required. Given the choice of signed and unsigned formats and the range of options available, these conversion instructions can be a powerful tool when working with physical input and output devices.