# Chapter 4 NUMB3RS.

## Presentation on theme: "Chapter 4 NUMB3RS."— Presentation transcript:

Chapter 4 NUMB3RS

Checklist The following tools will be used in this lesson:
MPLAB X, Integrated Development Environment (v1.8 or later, free) MPLAB XC16, C compiler (v1.11 or later, free) The following pieces of documentation will be used during this lesson: PIC24FJ128GA010 Datasheet –DS39747 (latest rev.) PIC24 Family Reference Manual - Section 14. Timers Make sure they are available and/or installed and ready to use on your computer. You can download them from Microchip web site at: And

Integer Data Types

Under the Hood Type the following few lines of code in a new main.c file: unsigned int i,j,k; main () { i = 0x1234; // assign an initial value to i j = 0x5678; // assign an initial value to j k = i * j; // perform product and store the result in k } Build the project and open the Window>Embedded Memory>Program window to inspect the code produced: i = 0x1234; MOV #0x1234, W // move literal to W0 MOV W0, 0x // move from W0 to i j = 0x5678; MOV #0x5678, W // move literal to W0 MOV W0, 0x // move from W0 to j k = i * j; MOV 0x400, W // move from i to W1 MOV 0x401, W // move from j to W0 B MUL.SS W1, W0, W0 8842A0 MOV W0, 0x // move result to k

Going “long” Try now with long (32-bit) integer values
unsigned long i,j,k; main () { i = 0x L; // assign an initial value to i j = 0x89ABCDEFL; // assign an initial value to j k = i * j; // perform product and store the result in k } And inspect the new code produced for the multiplication: k = i * j; MOV 0x403, W8 MOV 0x404, W9 MOV 0x405, W6 MOV 0x406, W7 MOV W8, W1 MOV W6, W0 B80A MUL.UU W1, W0, W4 B9C MUL.SS W8, W7, W0 MOV W5, W2 ADD W2, W0, W2 B9B MUL.SS W6, W9, W0 MOV W2, W5 MOV W4, 0x407 MOV W5, 0x408

“long long” Multiplications
Finally let’s try long long (64-bit) integer values unsigned long long i,j,k; main () { i = 0x ABCDEFLL; // assign an initial value to i j = 0xFEDCBA LL; // assign an initial value to j k = i * j; // perform product and store the result in k } And inspect the new code produced for the multiplication: k = i * j; 07FDFC RCALL 0x290

Floating Point Types Notice how the MPLAB XC16 compiler, by default, allocates for both the float and the double types the same number of bits (32), using the single precision floating-point format defined in the IEEE754 standard. Only the long double data type is treated as a true double precision IEEE754 floating-point type (64-bit).

Notes for C Experts If porting existing C code from a PC or workstation project, you might want to force the XC16 compiler to use the more standard (true) definition of a double as a 64-bit integer. You can do so by accessing the Project Configuration Dialog and selecting the “Use 64-bit double” option!

Measuring Integer Performance
/* * Numb3rs.c */ #include <config.h> int i1, i2, i3; long x1, x2, x3; long long xx1, xx2, xx3; main() { T1CON = 0x8000; // enable Timer1 1:1 with main clock i1 = 0x1234; // testing integers (16-bit) i2 = 0x5678; TMR1 = 0; // clear the timer i3 = i1 * i2; x1 = 0x L; // testing long integers (32-bit) x2 = 0x89ABCDEFL; x3 = x1 * x2; xx1 = 0x ABCDEFLL; // testing 64-bit integers xx2 = 0xFEDCBA LL; xx3 = xx1 * xx2; } // main Single Step, then read TMR1 Single Step, then read TMR1 Single Step, then read TMR1

Measuring FP Performance
/* * Numb3rs.c */ #include <config.h> float f1,f2, f3; long double d1, d2, d3; main() { T1CON = 0x8000; // enable Timer1 1:1 with main clock f1 = 12.34; // testing single precision floating point f2 = 56.78; TMR1 = 0; // clear the timer f3 = f1 * f2; d1 = 12.34L; // testing double precision floating point d2 = 56.78L; d3 = d1 * d2; } // main Single Step, then read TMR1 Single Step, then read TMR1

Measuring Performance Summary

Lessons Learned Use integers every time you can (i.e. when fractions are not required, or the algorithm can be re-written for integer arithmetic). Use the smallest integer type that will not produce an overflow or underflow. If you have to use a floating-point type (fractions are required), expect an order-of-magnitude reduction in the performance of the compiled program. Double precision floating point (long double) seems to only reduce the performance by a further factor of two.

Notes for the Assembly Experts
Converting an integer type into a smaller/larger one: int x; // 16-bit long y; // 32-bit y = x; // implicit conversion Explicity Conversion using a “type cast”: int x; // 16-bit long y; // 32-bit x = (int) y; // type cast Extracting or manipulating one bit out of an integer variable, use “bitfields” Example from the PIC24 peripheral libraries:  extern unsigned int T1CON; extern union { struct { unsigned :1; unsigned TCS:1; ... unsigned TSIDL:1; unsigned TON:1; }; unsigned :4; unsigned TCKPS:2; } T1CONbits;

Notes for the PIC MCU Experts
8-bit users will notice a considerable improvement in the performance both with integer arithmetic and floating point arithmetic. The 16-bit ALU available in the PIC24 architecture manipulates twice the number of bits per cycle Further improvement is due to the use of 8 working registers which make the coding of critical arithmetic routines and makes numerical algorithms more efficient

Tips and Tricks The MPLAB C compiler supports several standard ANSI C libraries including: limits.h - contains many useful macros defining implementation dependent limits, such as, for example, the number of bits composing a char type (CHAR_BIT) or the largest integer value (INT_MAX). float.h - contains similar implementation dependent limits for floating point data types, such as, for example the largest exponent for a single precision floating point variable (FLT_MAX_EXP). math.h - contains trigonometric functions, rounding functions, logarithms and exponentials.

Tips and Tricks Complex Data Types
The XC16 compiler supports complex data types as an extension of both integer and floating point types. Here is an example declaration for a single precision floating point type: __complex__ float z; Notice the use of a double underscore before and after the keyword complex. The variable z defined so has now a real and an imaginary part that can be individually addressed using the syntax: __real__ z and __imag__ z respectively. Similarly, the next declaration produces a complex variable of 16-bit integer type: __complex__ int x; Complex constants are easily created adding the suffix i or j as in the following examples: x = 2 + 3j; z = 2.0f + 3.0fj; All standard arithmetic operations (+,-,*,/) are performed correctly on complex data types. Additionally the “~” operator produces the complex conjugate.

Suggested Excercises Write a program that uses Timer2 and Timer3 joined in the new 32-bit timer mode. Test the relative performance of the division for the various data types. Test the performance of the trigonometric functions relative to standard arithmetic operations. Test the relative performance of the multiplication for complex data types.

Recommended Readings Gahlinger, P. M. (2000), The cockpit, a flight of escape and discovery, Sagebrush Press, Salt Lake City, UT It’s an interesting journey around the world. Follow the author in search of ... his soul. Every instrument in the cockpit triggers a memory and starts a new chapter.

Online Resources http://en.wikipedia.org/wiki/Taylor_series
If you are curious as to how the C compiler can approximate some of the functions in the math library.

Similar presentations