Mech - User contributions [en]

Ferrofluid Art Display

2010-03-17T04:47:28Z

MaxWiller: /* Results */

== Overview ==
The goal of this project was to create an interesting display using [http://en.wikipedia.org/wiki/Ferrofluid Ferrofluid], which is composed of ferrimagnetic particles suspended in a carrier fluid. The project was inspired by the work of artists such as Sachiko Kodama and Yasushi Miyajima, shown in this [http://www.youtube.com/watch?v=me5Zzm2TXh4&feature=related video] of their installation "Morpho Towers". Our display consisted of a hexagonal array of solenoids used to actuate magnets towards or away from the fluid, allowing us to control which regions were smooth and which displayed corrugations. The display could then be controlled via a user interface with the PC.

=== Team Members ===
* Todd H. Poole (Mechanical Engineering & Electrical Engineering, Class of 2010)
* Katy Powers (Mechanical Engineering, Class of 2010)
* Max Willer (Mechanical Engineering, Class of 2011)

== Mechanical Design ==
Todd
An evolution of concepts.
-Early sketches
--Pros & Cons
Decision of

== Electrical Design ==

[[Image:ELECTRONICS.JPG|thumb|150px|Final Electronics Setup.|right]]

Our electronics system consisted of:
*One NU32 board: [[Introduction to the PIC32]]
*19 solenoids: [https://www.jameco.com/webapp/wcs/stores/servlet/OrderItemDisplay?langId=-1&storeId=10001&catalogId=10001&krypto=WUgCYelA18EFMkT03NuyYowmviur5pLw5O7ybblUbPU1s%2BE5iJH6qHHMpTSj4RJNARBe7J9MvmE%3D&ddkey=https:OrderItemUpdate Jameco Part #262271]
*10 L293NDE Quad-half-bridges: [http://www.datasheetcatalog.com/datasheets_pdf/L/2/9/3/L293DNE.shtml Datasheet]
*5 SN74HC00N NAND Integrated Circuits: [http://www.chipsinfo.com/TI/SN74HC00N.htm Datasheet]

[[Image:circuit_diagram.png]]
*Inputs came from twenty of the PIC's digital output pins. 19 of those went to the NAND logic chips while the last one went to a hub controlling the enable pins of the H-Bridges.

*The NAND's were set up so that the input from the PIC went to both pins of the input so that the opposite signal would come out of the output. Both the input and the output of the NAND chip would then go to 2 inputs of the quad-half-bridge.

*The H-bridge would then output either a +12V or a -12V (forward or reverse) across the solenoid dependent on a high or low output from the PIC.

*The H-bridge is also connected to the enable voltage. Controlled by the PIC, the enable voltage, when high, would allow current to flow through the half-bridges. When low, no current would flow. This made it so that current would not flow at all times, just when the solenoids were switching position.

Picture of circuit for 4 solenoids goes.

==Code==
The code for the display setup consists of a GUI on the PC allowing the user to select which solenoids to turn on and off and code on the PIC to control the solenoids.

===Processing===
[[Image:Kpmw_userinterface.png|thumb|180px|Screenshot of User Interface. Green circles represent solenoids that are up while blue circles represent solenoids that are down.|right]]
The PC side of the user interface was created with [http://processing.org/ Processing], an open source programming environment with many options for interesting visual display. This code creates a display of circles arranged in the same way as the solenoids in our hardware, which will change from blue to green when clicked and output a character via RS232 to the PIC.
 

//Katy Powers
//3/11/2010
//ME 333 Ferrofluid Art GUI
//Lots of code taken from processing website and previous ME 333 labs..thanks!

// add the serial library
import processing.serial.*;
Serial[] myPorts = new Serial[1];

//setup parameters for hexagonal array
//cx,cy define center position, rc is circle radius, sp is how far apart they are
int cx = 250;
int cy = 250;
int rc = 50;
int sp = 10;

//circleX and circleY store center locations of every circle in array
//solenoidON stores state of solenoid
//chararr stores characters corresponding to each solenoid
int[] circleX = {cx, cx + rc + sp,cx + 2*(rc + sp),cx - (rc + sp),cx - 2*(rc + sp),cx + rc/2 + sp/2,
cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,cx+rc+sp, cx - (rc+sp),
cx + rc/2 + sp/2, cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,
cx + rc + sp,cx-(rc + sp)};

int[] circleY = {cy,cy,cy,cy,cy,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + 2*(rc+sp),
cy + 2*(rc+sp), cy + 2*(rc+sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),
cy - 2*(rc+sp),cy - 2*(rc+sp),cy - 2*(rc+sp)};

int[] solenoidON = new int[19];
char[] chararr = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'};
PFont font;
PFont smallfont;

void setup()
{
InitSerial();
background(0);
font = loadFont("FangSong-48.vlw");
smallfont = loadFont("FangSong-16.vlw");
size(500,500);
textAlign(CENTER);
for (int i = 0; i < 19; i = i+1){ //zero array of solenoid values, mouse state data
solenoidON[i] = 0;
}
rectMode(CENTER);
}

void draw()
{
fill(0,0,255);
textFont(font, 48);
text("Ferrofluid Art", cx, cy-200);
textFont(smallfont, 16);
text("Click a circle to make patterns in the Ferrofluid", cx, cy + 200);
hexagon(cx,cy,rc,sp, solenoidON);

}

void hexagon(int cx, int cy, int rc, int sp, int[] sols) //draws hexagon of cirlces
{
for (int i = 0; i < 19; i = i+1){
if(sols[i] == 0) {fill(0,0,255);}
else {fill(0,255,0);}
ellipse(circleX[i], circleY[i], rc, rc);
}

}

void mousePressed() //executes when mouse is pressed, much like an interrupt routine
{
float disX, disY;
for (int i = 0; i < 19; i = i+1){ //see where mouse is
disX = circleX[i] - mouseX;
disY = circleY[i] - mouseY;
if(sqrt(sq(disX) + sq(disY)) < rc/2 ) { //if mouse is in circle, toggle state and send character
solenoidON[i] = 1 - solenoidON[i];
myPorts[0].write(chararr[i]);
println(chararr[i]); //to debug
}
}
}

===PIC===
The PIC side of the code runs an infinite while loop, executing an interrupt routine every time a character is received from the RS232. The
PIC then updates the state of all the solenoids.

/**Ferrofluid Art Project Code**********************************/
/* Katy Powers Winter 2010 */

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include "LCD.h" //needed for Delayms

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define ENABLE1 LATDbits.LATD1 //Enable pins for H bridge circuit
#define ENABLE2 LATDbits.LATD2
#define OUT1 LATBbits.LATB11 //Output pins for solenoid control
#define OUT2 LATBbits.LATB10
#define OUT3 LATBbits.LATB9
#define OUT4 LATBbits.LATB8
#define OUT5 LATAbits.LATA10
#define OUT6 LATAbits.LATA9
#define OUT7 LATBbits.LATB7
#define OUT8 LATBbits.LATB6
#define OUT9 LATBbits.LATB0
#define OUT10 LATBbits.LATB1
#define OUT11 LATBbits.LATB2
#define OUT12 LATBbits.LATB3
#define OUT13 LATBbits.LATB5
#define OUT14 LATEbits.LATE9
#define OUT15 LATEbits.LATE8
#define OUT16 LATGbits.LATG9
#define OUT17 LATGbits.LATG8
#define OUT18 LATGbits.LATG7
#define OUT19 LATGbits.LATG6

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void setSols(void); //sets solenoids on and off depending on global variable sols

/** Global Variables *******************************************/

int sols[19]; //vector to store if solenoids are on or off

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;
// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);
AD1PCFG = 0xFFFF; //this line sets up the B bits as digital outputs

TRISAbits.TRISA10 = 0; //set all solenoid and enable output pins to output
TRISAbits.TRISA9 = 0;
TRISBbits.TRISB11 = 0;
TRISBbits.TRISB10 = 0;
TRISBbits.TRISB9 = 0;
TRISBbits.TRISB8 = 0;
TRISBbits.TRISB7 = 0;
TRISBbits.TRISB6 = 0;
TRISBbits.TRISB5 = 0;
TRISBbits.TRISB3 = 0;
TRISBbits.TRISB2 = 0;
TRISBbits.TRISB1 = 0;
TRISEbits.TRISE9 = 0;
TRISEbits.TRISE8 = 0;
TRISGbits.TRISG8 = 0;
TRISGbits.TRISG7 = 0;
TRISGbits.TRISG6 = 0;
TRISBbits.TRISB0 = 0;
TRISGbits.TRISG9 = 0;
TRISDbits.TRISD1 = 0;
TRISDbits.TRISD2 = 0;

OUT1 = 0; //initialize outputs to low
OUT2 = 0;
OUT3 = 0;
OUT4 = 0;
OUT5 = 0;
OUT6 = 0;
OUT7 = 0;
OUT8 = 0;
OUT9 = 0;
OUT10 = 0;
OUT11 = 0;
OUT12 = 0;
OUT13 = 0;
OUT14 = 0;
OUT15 = 0;
OUT16 = 0;
OUT17 = 0;
OUT18 = 0;
OUT19 = 0;

//also initialize sols array to 0
for(i = 0; i < 19; i++){
sols[i] = 0;
}
setSols(); //this is probably redundant

mInitAllLEDs();

initUART2(pbClk);
INTEnableSystemMultiVectoredInt();

while(1)
{
1;//just keep going and wait for interrupts from RS232
} //end main

}
/** Interrupt Handlers *****************************************/

void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
int i;
unsigned char data2; //store character received from PC
char chararr[19] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'}; //array of characters for comparison
// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data2 = ReadUART2(); //get character

// Toggle LED to indicate UART activity
mLED_1_Toggle();

for(i = 0; i<19; i++){
if (data2 ==(int) chararr[i]){ sols[i] = 1 - sols[i];} //toggle solenoid corresponding to character received
}
setSols(); //update all solenoids

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void setSols(){
OUT1 = sols[0]; //set all outputs to correct value
OUT2 = sols[1];
OUT3 = sols[2];
OUT4 = sols[3];
OUT5 = sols[4];
OUT6 = sols[5];
OUT7 = sols[6];
OUT8 = sols[7];
OUT9 = sols[8];
OUT10 = sols[9];
OUT11 = sols[10];
OUT12 = sols[11];
OUT13 = sols[12];
OUT14 = sols[13];
OUT15 = sols[14];
OUT16 = sols[15];
OUT17 = sols[16];
OUT18 = sols[17];
OUT19 = sols[18];
ENABLE1 = 1; //turn on enable pins
ENABLE2 = 1;
Delayms(500); //wait for half a second for solenoids to change position
ENABLE1 = 0; //turn off enable pins
ENABLE2 = 0;
}

== Results ==

===Summary of Parts===

*Electrical

The electric circuit was fully functional at the end of construction, with each solenoid responding to a high or low signal coming from where the PIC output would enter the NAND chip. If a 3.3 V signal came from the PIC output, 12 V would go across the solenoid. If a 0 V signal came from the PIC, a -12 V signal would go across the solenoid.

*Mechanical

The mechanical setup was also fully functional at the end of construction. Each solenoid fit snugly into their insert with the leads coming out in a shrink-wrapped conduit. The polycarbonate container was bent and sealed with epoxy and there was a wooden base so that the electronics would be housed conveniently under everything.

*Coding

The attempted Fast Fourier Transform coding was working by the end of construction, lighting up LED lights when certain frequencies were active. Our idea for the music response mode was to have the FFT recognize the melody and output the musical note to the corresponding solenoid on the outside diameter of the hexagon. The middle solenoids would be activating at random.

The user interface was also working. The Processing application's solenoid control buttons were functional and sent data over the RS232 cable to the PIC. The final idea was to have it as a user option whether to go into music response mode or manually control the solenoids.

===Combining the Parts===

*Combining Electrical with Mechanical

While all of the solenoids fit snugly into their inserts, we found that the magnets were interfering with each other from their positions. We had all of the cylindrical magnets facing the same polarity (all of the north ends of the magnets faced up). Because of this arrangement, the magnets felt a repulsive force from the other magnets. We found we were able to push the solenoids up (boosted by the magnetic force from the other magnets) but we were unable to bring them down due to the extra force overcoming the force from the solenoid's pull. Since we had tested the forces on the solenoids separately, we did not think to check the forces on them when in the arrangement, but it made for a project that was only half functional.

In addition, we attempted to help overcome the extra force in two ways. First, by increasing the padding space between the bottom of the ferrofluid container and the magnets. This way the solenoid would be more in its most efficient spot, and the magnetic force from the ferrofluid would be less. Second, we removed one of the magnets from each solenoid arrangement (only one magnet instead of two) to try and lessen the magnetic forces between the magnets. Not only did this not work, but it made it so that the magnets then had little effect on the ferrofluid (slight bumps instead of spiky designs).

*Combining Electrical with Coding

Had we been able to take more time with this interface, the problems would have been easy fixes. As it was though, the wires of the solenoids coming down from the hardware enclosure got mixed up when getting connected to the H-bridge outputs. This made it so the NAND inputs did not match up with the PIC outputs they should have.

Another small problem we had was that the solenoids enabled time was too low. Since each solenoid takes around .2 A at 12 V, it would take a lot of power to power all 19 solenoids at once. So we used an enable pin to enable and disable all the H-Bridges at once. This way, we could use only one pin for each solenoid, and the power wouldn't be on at all times, only when solenoids needed to change positions. Since the time we had the enable pin set to high was too short, the solenoids didn't have enough time to push up the magnets. This was a programmed constant and could have been optimized with more testing.

*Combining the Coding with the User Interface

While the FFT code worked in concept, in reality it took too long to compute the main frequencies of a song that was playing. Without some sort of buffer or faster code, the melody might be recognized, just too late.

The User Interface worked on the PC through a Processing program and indicated what mode the user was in as well as which solenoids were up or down. The problem came in when sending user orders across the RS232 cable to the PIC. The RS232 cable was fine, as well as the Processing program, since if we looped the circuit back to the PC, each command was read. The problem was somewhere in the PIC, possibly with a hardware error or interrupt interference.

== Reflections ==
Todd

Ferrofluid Art Display

2010-03-17T04:42:43Z

MaxWiller: /* Combining the Parts */

Ferrofluid Art Display

2010-03-17T04:40:43Z

MaxWiller: /* Results */

Ferrofluid Art Display

2010-03-17T04:39:42Z

MaxWiller: /* Results */

== Overview ==
The goal of this project was to create an interesting display using [http://en.wikipedia.org/wiki/Ferrofluid Ferrofluid], which is composed of ferrimagnetic particles suspended in a carrier fluid. The project was inspired by the work of artists such as Sachiko Kodama and Yasushi Miyajima, shown in this [http://www.youtube.com/watch?v=me5Zzm2TXh4&feature=related video] of their installation "Morpho Towers". Our display consisted of a hexagonal array of solenoids used to actuate magnets towards or away from the fluid, allowing us to control which regions were smooth and which displayed corrugations. The display could then be controlled via a user interface with the PC.

=== Team Members ===
* Todd H. Poole (Mechanical Engineering & Electrical Engineering, Class of 2010)
* Katy Powers (Mechanical Engineering, Class of 2010)
* Max Willer (Mechanical Engineering, Class of 2011)

== Mechanical Design ==
Todd
An evolution of concepts.
-Early sketches
--Pros & Cons
Decision of

== Electrical Design ==

[[Image:ELECTRONICS.JPG|thumb|150px|Final Electronics Setup.|right]]

Our electronics system consisted of:
*One NU32 board: [[Introduction to the PIC32]]
*19 solenoids: [https://www.jameco.com/webapp/wcs/stores/servlet/OrderItemDisplay?langId=-1&storeId=10001&catalogId=10001&krypto=WUgCYelA18EFMkT03NuyYowmviur5pLw5O7ybblUbPU1s%2BE5iJH6qHHMpTSj4RJNARBe7J9MvmE%3D&ddkey=https:OrderItemUpdate Jameco Part #262271]
*10 L293NDE Quad-half-bridges: [http://www.datasheetcatalog.com/datasheets_pdf/L/2/9/3/L293DNE.shtml Datasheet]
*5 SN74HC00N NAND Integrated Circuits: [http://www.chipsinfo.com/TI/SN74HC00N.htm Datasheet]

[[Image:circuit_diagram.png]]
*Inputs came from twenty of the PIC's digital output pins. 19 of those went to the NAND logic chips while the last one went to a hub controlling the enable pins of the H-Bridges.

*The NAND's were set up so that the input from the PIC went to both pins of the input so that the opposite signal would come out of the output. Both the input and the output of the NAND chip would then go to 2 inputs of the quad-half-bridge.

*The H-bridge would then output either a +12V or a -12V (forward or reverse) across the solenoid dependent on a high or low output from the PIC.

*The H-bridge is also connected to the enable voltage. Controlled by the PIC, the enable voltage, when high, would allow current to flow through the half-bridges. When low, no current would flow. This made it so that current would not flow at all times, just when the solenoids were switching position.

Picture of circuit for 4 solenoids goes.

==Code==
The code for the display setup consists of a GUI on the PC allowing the user to select which solenoids to turn on and off and code on the PIC to control the solenoids.

===Processing===
[[Image:Kpmw_userinterface.png|thumb|180px|Screenshot of User Interface. Green circles represent solenoids that are up while blue circles represent solenoids that are down.|right]]
The PC side of the user interface was created with [http://processing.org/ Processing], an open source programming environment with many options for interesting visual display. This code creates a display of circles arranged in the same way as the solenoids in our hardware, which will change from blue to green when clicked and output a character via RS232 to the PIC.
 

//Katy Powers
//3/11/2010
//ME 333 Ferrofluid Art GUI
//Lots of code taken from processing website and previous ME 333 labs..thanks!

// add the serial library
import processing.serial.*;
Serial[] myPorts = new Serial[1];

//setup parameters for hexagonal array
//cx,cy define center position, rc is circle radius, sp is how far apart they are
int cx = 250;
int cy = 250;
int rc = 50;
int sp = 10;

//circleX and circleY store center locations of every circle in array
//solenoidON stores state of solenoid
//chararr stores characters corresponding to each solenoid
int[] circleX = {cx, cx + rc + sp,cx + 2*(rc + sp),cx - (rc + sp),cx - 2*(rc + sp),cx + rc/2 + sp/2,
cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,cx+rc+sp, cx - (rc+sp),
cx + rc/2 + sp/2, cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,
cx + rc + sp,cx-(rc + sp)};

int[] circleY = {cy,cy,cy,cy,cy,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + 2*(rc+sp),
cy + 2*(rc+sp), cy + 2*(rc+sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),
cy - 2*(rc+sp),cy - 2*(rc+sp),cy - 2*(rc+sp)};

int[] solenoidON = new int[19];
char[] chararr = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'};
PFont font;
PFont smallfont;

void setup()
{
InitSerial();
background(0);
font = loadFont("FangSong-48.vlw");
smallfont = loadFont("FangSong-16.vlw");
size(500,500);
textAlign(CENTER);
for (int i = 0; i < 19; i = i+1){ //zero array of solenoid values, mouse state data
solenoidON[i] = 0;
}
rectMode(CENTER);
}

void draw()
{
fill(0,0,255);
textFont(font, 48);
text("Ferrofluid Art", cx, cy-200);
textFont(smallfont, 16);
text("Click a circle to make patterns in the Ferrofluid", cx, cy + 200);
hexagon(cx,cy,rc,sp, solenoidON);

}

void hexagon(int cx, int cy, int rc, int sp, int[] sols) //draws hexagon of cirlces
{
for (int i = 0; i < 19; i = i+1){
if(sols[i] == 0) {fill(0,0,255);}
else {fill(0,255,0);}
ellipse(circleX[i], circleY[i], rc, rc);
}

}

void mousePressed() //executes when mouse is pressed, much like an interrupt routine
{
float disX, disY;
for (int i = 0; i < 19; i = i+1){ //see where mouse is
disX = circleX[i] - mouseX;
disY = circleY[i] - mouseY;
if(sqrt(sq(disX) + sq(disY)) < rc/2 ) { //if mouse is in circle, toggle state and send character
solenoidON[i] = 1 - solenoidON[i];
myPorts[0].write(chararr[i]);
println(chararr[i]); //to debug
}
}
}

===PIC===
The PIC side of the code runs an infinite while loop, executing an interrupt routine every time a character is received from the RS232. The
PIC then updates the state of all the solenoids.

/**Ferrofluid Art Project Code**********************************/
/* Katy Powers Winter 2010 */

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include "LCD.h" //needed for Delayms

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define ENABLE1 LATDbits.LATD1 //Enable pins for H bridge circuit
#define ENABLE2 LATDbits.LATD2
#define OUT1 LATBbits.LATB11 //Output pins for solenoid control
#define OUT2 LATBbits.LATB10
#define OUT3 LATBbits.LATB9
#define OUT4 LATBbits.LATB8
#define OUT5 LATAbits.LATA10
#define OUT6 LATAbits.LATA9
#define OUT7 LATBbits.LATB7
#define OUT8 LATBbits.LATB6
#define OUT9 LATBbits.LATB0
#define OUT10 LATBbits.LATB1
#define OUT11 LATBbits.LATB2
#define OUT12 LATBbits.LATB3
#define OUT13 LATBbits.LATB5
#define OUT14 LATEbits.LATE9
#define OUT15 LATEbits.LATE8
#define OUT16 LATGbits.LATG9
#define OUT17 LATGbits.LATG8
#define OUT18 LATGbits.LATG7
#define OUT19 LATGbits.LATG6

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void setSols(void); //sets solenoids on and off depending on global variable sols

/** Global Variables *******************************************/

int sols[19]; //vector to store if solenoids are on or off

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;
// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);
AD1PCFG = 0xFFFF; //this line sets up the B bits as digital outputs

TRISAbits.TRISA10 = 0; //set all solenoid and enable output pins to output
TRISAbits.TRISA9 = 0;
TRISBbits.TRISB11 = 0;
TRISBbits.TRISB10 = 0;
TRISBbits.TRISB9 = 0;
TRISBbits.TRISB8 = 0;
TRISBbits.TRISB7 = 0;
TRISBbits.TRISB6 = 0;
TRISBbits.TRISB5 = 0;
TRISBbits.TRISB3 = 0;
TRISBbits.TRISB2 = 0;
TRISBbits.TRISB1 = 0;
TRISEbits.TRISE9 = 0;
TRISEbits.TRISE8 = 0;
TRISGbits.TRISG8 = 0;
TRISGbits.TRISG7 = 0;
TRISGbits.TRISG6 = 0;
TRISBbits.TRISB0 = 0;
TRISGbits.TRISG9 = 0;
TRISDbits.TRISD1 = 0;
TRISDbits.TRISD2 = 0;

OUT1 = 0; //initialize outputs to low
OUT2 = 0;
OUT3 = 0;
OUT4 = 0;
OUT5 = 0;
OUT6 = 0;
OUT7 = 0;
OUT8 = 0;
OUT9 = 0;
OUT10 = 0;
OUT11 = 0;
OUT12 = 0;
OUT13 = 0;
OUT14 = 0;
OUT15 = 0;
OUT16 = 0;
OUT17 = 0;
OUT18 = 0;
OUT19 = 0;

//also initialize sols array to 0
for(i = 0; i < 19; i++){
sols[i] = 0;
}
setSols(); //this is probably redundant

mInitAllLEDs();

initUART2(pbClk);
INTEnableSystemMultiVectoredInt();

while(1)
{
1;//just keep going and wait for interrupts from RS232
} //end main

}
/** Interrupt Handlers *****************************************/

void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
int i;
unsigned char data2; //store character received from PC
char chararr[19] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'}; //array of characters for comparison
// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data2 = ReadUART2(); //get character

// Toggle LED to indicate UART activity
mLED_1_Toggle();

for(i = 0; i<19; i++){
if (data2 ==(int) chararr[i]){ sols[i] = 1 - sols[i];} //toggle solenoid corresponding to character received
}
setSols(); //update all solenoids

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void setSols(){
OUT1 = sols[0]; //set all outputs to correct value
OUT2 = sols[1];
OUT3 = sols[2];
OUT4 = sols[3];
OUT5 = sols[4];
OUT6 = sols[5];
OUT7 = sols[6];
OUT8 = sols[7];
OUT9 = sols[8];
OUT10 = sols[9];
OUT11 = sols[10];
OUT12 = sols[11];
OUT13 = sols[12];
OUT14 = sols[13];
OUT15 = sols[14];
OUT16 = sols[15];
OUT17 = sols[16];
OUT18 = sols[17];
OUT19 = sols[18];
ENABLE1 = 1; //turn on enable pins
ENABLE2 = 1;
Delayms(500); //wait for half a second for solenoids to change position
ENABLE1 = 0; //turn off enable pins
ENABLE2 = 0;
}

== Results ==

Before we combined the parts of the project, this is a summary of what we had.

*Electrical

The electric circuit was fully functional at the end of construction, with each solenoid responding to a high or low signal coming from where the PIC output would enter the NAND chip. If a 3.3 V signal came from the PIC output, 12 V would go across the solenoid. If a 0 V signal came from the PIC, a -12 V signal would go across the solenoid.

*Mechanical

The mechanical setup was also fully functional at the end of construction. Each solenoid fit snugly into their insert with the leads coming out in a shrink-wrapped conduit. The polycarbonate container was bent and sealed with epoxy and there was a wooden base so that the electronics would be housed conveniently under everything.

*Coding

The attempted Fast Fourier Transform coding was working by the end of construction, lighting up LED lights when certain frequencies were active. Our idea for the music response mode was to have the FFT recognize the melody and output the musical note to the corresponding solenoid on the outside diameter of the hexagon. The middle solenoids would be activating at random.

The user interface was also working. The Processing application's solenoid control buttons were functional and sent data over the RS232 cable to the PIC. The final idea was to have it as a user option whether to go into music response mode or manually control the solenoids.

When we combined the parts, however, they did not work as expected.

*Combining Electrical with Mechanical

While all of the solenoids fit snugly into their inserts, we found that the magnets were interfering with each other from their positions. We had all of the cylindrical magnets facing the same polarity (all of the north ends of the magnets faced up). Because of this arrangement, the magnets felt a repulsive force from the other magnets. We found we were able to push the solenoids up (boosted by the magnetic force from the other magnets) but we were unable to bring them down due to the extra force overcoming the force from the solenoid's pull. Since we had tested the forces on the solenoids separately, we did not think to check the forces on them when in the arrangement, but it made for a project that was only half functional.

In addition, we attempted to help overcome the extra force in two ways. First, by increasing the padding space between the bottom of the ferrofluid container and the magnets. This way the solenoid would be more in its most efficient spot, and the magnetic force from the ferrofluid would be less. Second, we removed one of the magnets from each solenoid arrangement (only one magnet instead of two) to try and lessen the magnetic forces between the magnets. Not only did this not work, but it made it so that the magnets then had little effect on the ferrofluid (slight bumps instead of spiky designs).

*Combining Electrical with Coding

Had we been able to take more time with this interface, the problems would have been easy fixes. As it was though, the wires of the solenoids coming down from the hardware enclosure got mixed up when getting connected to the H-bridge outputs. This made it so the NAND inputs did not match up with the PIC outputs they should have.

Another small problem we had was that the solenoids enabled time was too low. Since each solenoid takes around .2 A at 12 V, it would take a lot of power to power all 19 solenoids at once. So we used an enable pin to enable and disable all the H-Bridges at once. This way, we could use only one pin for each solenoid, and the power wouldn't be on at all times, only when solenoids needed to change positions. Since the time we had the enable pin set to high was too short, the solenoids didn't have enough time to push up the magnets. This was a programmed constant and could have been optimized with more testing.

*Combining the Coding with the User Interface

== Reflections ==
Todd

Ferrofluid Art Display

2010-03-17T04:14:59Z

MaxWiller: /* Results */

== Overview ==
The goal of this project was to create an interesting display using [http://en.wikipedia.org/wiki/Ferrofluid Ferrofluid], which is composed of ferrimagnetic particles suspended in a carrier fluid. The project was inspired by the work of artists such as Sachiko Kodama and Yasushi Miyajima, shown in this [http://www.youtube.com/watch?v=me5Zzm2TXh4&feature=related video] of their installation "Morpho Towers". Our display consisted of a hexagonal array of solenoids used to actuate magnets towards or away from the fluid, allowing us to control which regions were smooth and which displayed corrugations. The display could then be controlled via a user interface with the PC.

=== Team Members ===
* Todd H. Poole (Mechanical Engineering & Electrical Engineering, Class of 2010)
* Katy Powers (Mechanical Engineering, Class of 2010)
* Max Willer (Mechanical Engineering, Class of 2011)

== Mechanical Design ==
Todd
An evolution of concepts.
-Early sketches
--Pros & Cons
Decision of

== Electrical Design ==

[[Image:ELECTRONICS.JPG|thumb|150px|Final Electronics Setup.|right]]

Our electronics system consisted of:
*One NU32 board: [[Introduction to the PIC32]]
*19 solenoids: [https://www.jameco.com/webapp/wcs/stores/servlet/OrderItemDisplay?langId=-1&storeId=10001&catalogId=10001&krypto=WUgCYelA18EFMkT03NuyYowmviur5pLw5O7ybblUbPU1s%2BE5iJH6qHHMpTSj4RJNARBe7J9MvmE%3D&ddkey=https:OrderItemUpdate Jameco Part #262271]
*10 L293NDE Quad-half-bridges: [http://www.datasheetcatalog.com/datasheets_pdf/L/2/9/3/L293DNE.shtml Datasheet]
*5 SN74HC00N NAND Integrated Circuits: [http://www.chipsinfo.com/TI/SN74HC00N.htm Datasheet]

[[Image:circuit_diagram.png]]
*Inputs came from twenty of the PIC's digital output pins. 19 of those went to the NAND logic chips while the last one went to a hub controlling the enable pins of the H-Bridges.

*The NAND's were set up so that the input from the PIC went to both pins of the input so that the opposite signal would come out of the output. Both the input and the output of the NAND chip would then go to 2 inputs of the quad-half-bridge.

*The H-bridge would then output either a +12V or a -12V (forward or reverse) across the solenoid dependent on a high or low output from the PIC.

*The H-bridge is also connected to the enable voltage. Controlled by the PIC, the enable voltage, when high, would allow current to flow through the half-bridges. When low, no current would flow. This made it so that current would not flow at all times, just when the solenoids were switching position.

Picture of circuit for 4 solenoids goes.

==Code==
The code for the display setup consists of a GUI on the PC allowing the user to select which solenoids to turn on and off and code on the PIC to control the solenoids.

===Processing===
[[Image:Kpmw_userinterface.png|thumb|180px|Screenshot of User Interface. Green circles represent solenoids that are up while blue circles represent solenoids that are down.|right]]
The PC side of the user interface was created with [http://processing.org/ Processing], an open source programming environment with many options for interesting visual display. This code creates a display of circles arranged in the same way as the solenoids in our hardware, which will change from blue to green when clicked and output a character via RS232 to the PIC.
 

//Katy Powers
//3/11/2010
//ME 333 Ferrofluid Art GUI
//Lots of code taken from processing website and previous ME 333 labs..thanks!

// add the serial library
import processing.serial.*;
Serial[] myPorts = new Serial[1];

//setup parameters for hexagonal array
//cx,cy define center position, rc is circle radius, sp is how far apart they are
int cx = 250;
int cy = 250;
int rc = 50;
int sp = 10;

//circleX and circleY store center locations of every circle in array
//solenoidON stores state of solenoid
//chararr stores characters corresponding to each solenoid
int[] circleX = {cx, cx + rc + sp,cx + 2*(rc + sp),cx - (rc + sp),cx - 2*(rc + sp),cx + rc/2 + sp/2,
cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,cx+rc+sp, cx - (rc+sp),
cx + rc/2 + sp/2, cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,
cx + rc + sp,cx-(rc + sp)};

int[] circleY = {cy,cy,cy,cy,cy,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + 2*(rc+sp),
cy + 2*(rc+sp), cy + 2*(rc+sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),
cy - 2*(rc+sp),cy - 2*(rc+sp),cy - 2*(rc+sp)};

int[] solenoidON = new int[19];
char[] chararr = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'};
PFont font;
PFont smallfont;

void setup()
{
InitSerial();
background(0);
font = loadFont("FangSong-48.vlw");
smallfont = loadFont("FangSong-16.vlw");
size(500,500);
textAlign(CENTER);
for (int i = 0; i < 19; i = i+1){ //zero array of solenoid values, mouse state data
solenoidON[i] = 0;
}
rectMode(CENTER);
}

void draw()
{
fill(0,0,255);
textFont(font, 48);
text("Ferrofluid Art", cx, cy-200);
textFont(smallfont, 16);
text("Click a circle to make patterns in the Ferrofluid", cx, cy + 200);
hexagon(cx,cy,rc,sp, solenoidON);

}

void hexagon(int cx, int cy, int rc, int sp, int[] sols) //draws hexagon of cirlces
{
for (int i = 0; i < 19; i = i+1){
if(sols[i] == 0) {fill(0,0,255);}
else {fill(0,255,0);}
ellipse(circleX[i], circleY[i], rc, rc);
}

}

void mousePressed() //executes when mouse is pressed, much like an interrupt routine
{
float disX, disY;
for (int i = 0; i < 19; i = i+1){ //see where mouse is
disX = circleX[i] - mouseX;
disY = circleY[i] - mouseY;
if(sqrt(sq(disX) + sq(disY)) < rc/2 ) { //if mouse is in circle, toggle state and send character
solenoidON[i] = 1 - solenoidON[i];
myPorts[0].write(chararr[i]);
println(chararr[i]); //to debug
}
}
}

===PIC===
The PIC side of the code runs an infinite while loop, executing an interrupt routine every time a character is received from the RS232. The
PIC then updates the state of all the solenoids.

/**Ferrofluid Art Project Code**********************************/
/* Katy Powers Winter 2010 */

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include "LCD.h" //needed for Delayms

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define ENABLE1 LATDbits.LATD1 //Enable pins for H bridge circuit
#define ENABLE2 LATDbits.LATD2
#define OUT1 LATBbits.LATB11 //Output pins for solenoid control
#define OUT2 LATBbits.LATB10
#define OUT3 LATBbits.LATB9
#define OUT4 LATBbits.LATB8
#define OUT5 LATAbits.LATA10
#define OUT6 LATAbits.LATA9
#define OUT7 LATBbits.LATB7
#define OUT8 LATBbits.LATB6
#define OUT9 LATBbits.LATB0
#define OUT10 LATBbits.LATB1
#define OUT11 LATBbits.LATB2
#define OUT12 LATBbits.LATB3
#define OUT13 LATBbits.LATB5
#define OUT14 LATEbits.LATE9
#define OUT15 LATEbits.LATE8
#define OUT16 LATGbits.LATG9
#define OUT17 LATGbits.LATG8
#define OUT18 LATGbits.LATG7
#define OUT19 LATGbits.LATG6

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void setSols(void); //sets solenoids on and off depending on global variable sols

/** Global Variables *******************************************/

int sols[19]; //vector to store if solenoids are on or off

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;
// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);
AD1PCFG = 0xFFFF; //this line sets up the B bits as digital outputs

TRISAbits.TRISA10 = 0; //set all solenoid and enable output pins to output
TRISAbits.TRISA9 = 0;
TRISBbits.TRISB11 = 0;
TRISBbits.TRISB10 = 0;
TRISBbits.TRISB9 = 0;
TRISBbits.TRISB8 = 0;
TRISBbits.TRISB7 = 0;
TRISBbits.TRISB6 = 0;
TRISBbits.TRISB5 = 0;
TRISBbits.TRISB3 = 0;
TRISBbits.TRISB2 = 0;
TRISBbits.TRISB1 = 0;
TRISEbits.TRISE9 = 0;
TRISEbits.TRISE8 = 0;
TRISGbits.TRISG8 = 0;
TRISGbits.TRISG7 = 0;
TRISGbits.TRISG6 = 0;
TRISBbits.TRISB0 = 0;
TRISGbits.TRISG9 = 0;
TRISDbits.TRISD1 = 0;
TRISDbits.TRISD2 = 0;

OUT1 = 0; //initialize outputs to low
OUT2 = 0;
OUT3 = 0;
OUT4 = 0;
OUT5 = 0;
OUT6 = 0;
OUT7 = 0;
OUT8 = 0;
OUT9 = 0;
OUT10 = 0;
OUT11 = 0;
OUT12 = 0;
OUT13 = 0;
OUT14 = 0;
OUT15 = 0;
OUT16 = 0;
OUT17 = 0;
OUT18 = 0;
OUT19 = 0;

//also initialize sols array to 0
for(i = 0; i < 19; i++){
sols[i] = 0;
}
setSols(); //this is probably redundant

mInitAllLEDs();

initUART2(pbClk);
INTEnableSystemMultiVectoredInt();

while(1)
{
1;//just keep going and wait for interrupts from RS232
} //end main

}
/** Interrupt Handlers *****************************************/

void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
int i;
unsigned char data2; //store character received from PC
char chararr[19] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'}; //array of characters for comparison
// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data2 = ReadUART2(); //get character

// Toggle LED to indicate UART activity
mLED_1_Toggle();

for(i = 0; i<19; i++){
if (data2 ==(int) chararr[i]){ sols[i] = 1 - sols[i];} //toggle solenoid corresponding to character received
}
setSols(); //update all solenoids

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void setSols(){
OUT1 = sols[0]; //set all outputs to correct value
OUT2 = sols[1];
OUT3 = sols[2];
OUT4 = sols[3];
OUT5 = sols[4];
OUT6 = sols[5];
OUT7 = sols[6];
OUT8 = sols[7];
OUT9 = sols[8];
OUT10 = sols[9];
OUT11 = sols[10];
OUT12 = sols[11];
OUT13 = sols[12];
OUT14 = sols[13];
OUT15 = sols[14];
OUT16 = sols[15];
OUT17 = sols[16];
OUT18 = sols[17];
OUT19 = sols[18];
ENABLE1 = 1; //turn on enable pins
ENABLE2 = 1;
Delayms(500); //wait for half a second for solenoids to change position
ENABLE1 = 0; //turn off enable pins
ENABLE2 = 0;
}

== Results ==

As seen from our videos, we were able to get all of the parts of our project working, but when put together, they did not work as expected.

*Electrical

The electric circuit was fully functional at the end of construction, with each solenoid responding to a high or low signal coming from where the PIC output would enter the NAND chip. If a 3.3 V signal came from the PIC output, 12 V would go across the solenoid. If a 0 V signal came from the PIC, a -12 V signal would go across the solenoid.

*Mechanical

The mechanical setup was also fully functional at the end of construction. Each solenoid fit snugly into their insert with the leads coming out in a shrink-wrapped conduit. The polycarbonate container was bent and sealed with epoxy and there was a wooden base so that the electronics would be housed conveniently under everything.

*Coding

The FFT coding was working by the end of construction, lighting up LED lights when certain frequencies were active. The user interface was also working. The Processing application's solenoid control buttons were functional and sent data over the RS232 cable to the PIC. The final idea was to have it as a user option whether to go into music response mode or manually control the solenoids.

== Reflections ==
Todd

Ferrofluid Art Display

2010-03-17T00:59:36Z

MaxWiller: /* Electrical Design */

File:Circuit diagram.png

2010-03-17T00:59:13Z

MaxWiller: uploaded a new version of "Image:Circuit diagram.png"

Circuit Diagram

Ferrofluid Art Display

2010-03-17T00:56:41Z

MaxWiller: /* Electrical Design */

== Overview ==
The goal of this project was to create an interesting display using [http://en.wikipedia.org/wiki/Ferrofluid Ferrofluid], which is composed of ferrimagnetic particles suspended in a carrier fluid. The project was inspired by the work of artists such as Sachiko Kodama and Yasushi Miyajima, shown in this [http://www.youtube.com/watch?v=me5Zzm2TXh4&feature=related video] of their installation "Morpho Towers". Our display consisted of a hexagonal array of solenoids used to actuate magnets towards or away from the fluid, allowing us to control which regions were smooth and which displayed corrugations. The display could then be controlled via a user interface with the PC.

=== Team Members ===
* Todd H. Poole (Mechanical Engineering & Electrical Engineering, Class of 2010)
* Katy Powers (Mechanical Engineering, Class of 2010)
* Max Willer (Mechanical Engineering, Class of 2011)

== Mechanical Design ==
Todd
An evolution of concepts.
-Early sketches
--Pros & Cons
Decision of

== Electrical Design ==

[[Image:ELECTRONICS.JPG|thumb|150px|Final Electronics Setup.|right]]

Our electronics system consisted of:
*One NU32 board: [[Introduction to the PIC32]]
*19 solenoids: [https://www.jameco.com/webapp/wcs/stores/servlet/OrderItemDisplay?langId=-1&storeId=10001&catalogId=10001&krypto=WUgCYelA18EFMkT03NuyYowmviur5pLw5O7ybblUbPU1s%2BE5iJH6qHHMpTSj4RJNARBe7J9MvmE%3D&ddkey=https:OrderItemUpdate Jameco Part #262271]
*10 L293NDE Quad-half-bridges: [http://www.datasheetcatalog.com/datasheets_pdf/L/2/9/3/L293DNE.shtml Datasheet]
*5 SN74HC00N NAND Integrated Circuits: [http://www.chipsinfo.com/TI/SN74HC00N.htm Datasheet]

Circuit Diagram:

[[Image:circuit_diagram.png]]
*Inputs came from twenty of the PIC's digital output pins. 19 of those went to the NAND logic chips while the last one went to a hub controlling the enable pins of the H-Bridges.

*The NAND's were set up so that the input from the PIC went to both pins of the input so that the opposite signal would come out of the output. Both the input and the output of the NAND chip would then go to 2 inputs of the quad-half-bridge.

*The H-bridge would then output either a +12V or a -12V (forward or reverse) across the solenoid dependent on a high or low output from the PIC.

*The H-bridge is also connected to the enable voltage. Controlled by the PIC, the enable voltage, when high, would allow current to flow through the half-bridges. When low, no current would flow. This made it so that current would not flow at all times, just when the solenoids were switching position.

Picture of circuit for 4 solenoids goes.

==Code==
The code for the display setup consists of a GUI on the PC allowing the user to select which solenoids to turn on and off and code on the PIC to control the solenoids.

===Processing===
[[Image:Kpmw_userinterface.png|thumb|180px|Screenshot of User Interface. Green circles represent solenoids that are up while blue circles represent solenoids that are down.|right]]
The PC side of the user interface was created with [http://processing.org/ Processing], an open source programming environment with many options for interesting visual display. This code creates a display of circles arranged in the same way as the solenoids in our hardware, which will change from blue to green when clicked and output a character via RS232 to the PIC.
 

//Katy Powers
//3/11/2010
//ME 333 Ferrofluid Art GUI
//Lots of code taken from processing website and previous ME 333 labs..thanks!

// add the serial library
import processing.serial.*;
Serial[] myPorts = new Serial[1];

//setup parameters for hexagonal array
//cx,cy define center position, rc is circle radius, sp is how far apart they are
int cx = 250;
int cy = 250;
int rc = 50;
int sp = 10;

//circleX and circleY store center locations of every circle in array
//solenoidON stores state of solenoid
//chararr stores characters corresponding to each solenoid
int[] circleX = {cx, cx + rc + sp,cx + 2*(rc + sp),cx - (rc + sp),cx - 2*(rc + sp),cx + rc/2 + sp/2,
cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,cx+rc+sp, cx - (rc+sp),
cx + rc/2 + sp/2, cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,
cx + rc + sp,cx-(rc + sp)};

int[] circleY = {cy,cy,cy,cy,cy,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + 2*(rc+sp),
cy + 2*(rc+sp), cy + 2*(rc+sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),
cy - 2*(rc+sp),cy - 2*(rc+sp),cy - 2*(rc+sp)};

int[] solenoidON = new int[19];
char[] chararr = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'};
PFont font;
PFont smallfont;

void setup()
{
InitSerial();
background(0);
font = loadFont("FangSong-48.vlw");
smallfont = loadFont("FangSong-16.vlw");
size(500,500);
textAlign(CENTER);
for (int i = 0; i < 19; i = i+1){ //zero array of solenoid values, mouse state data
solenoidON[i] = 0;
}
rectMode(CENTER);
}

void draw()
{
fill(0,0,255);
textFont(font, 48);
text("Ferrofluid Art", cx, cy-200);
textFont(smallfont, 16);
text("Click a circle to make patterns in the Ferrofluid", cx, cy + 200);
hexagon(cx,cy,rc,sp, solenoidON);

}

void hexagon(int cx, int cy, int rc, int sp, int[] sols) //draws hexagon of cirlces
{
for (int i = 0; i < 19; i = i+1){
if(sols[i] == 0) {fill(0,0,255);}
else {fill(0,255,0);}
ellipse(circleX[i], circleY[i], rc, rc);
}

}

void mousePressed() //executes when mouse is pressed, much like an interrupt routine
{
float disX, disY;
for (int i = 0; i < 19; i = i+1){ //see where mouse is
disX = circleX[i] - mouseX;
disY = circleY[i] - mouseY;
if(sqrt(sq(disX) + sq(disY)) < rc/2 ) { //if mouse is in circle, toggle state and send character
solenoidON[i] = 1 - solenoidON[i];
myPorts[0].write(chararr[i]);
println(chararr[i]); //to debug
}
}
}

===PIC===
The PIC side of the code runs an infinite while loop, executing an interrupt routine every time a character is received from the RS232. The
PIC then updates the state of all the solenoids.

/**Ferrofluid Art Project Code**********************************/
/* Katy Powers Winter 2010 */

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include "LCD.h" //needed for Delayms

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define ENABLE1 LATDbits.LATD1 //Enable pins for H bridge circuit
#define ENABLE2 LATDbits.LATD2
#define OUT1 LATBbits.LATB11 //Output pins for solenoid control
#define OUT2 LATBbits.LATB10
#define OUT3 LATBbits.LATB9
#define OUT4 LATBbits.LATB8
#define OUT5 LATAbits.LATA10
#define OUT6 LATAbits.LATA9
#define OUT7 LATBbits.LATB7
#define OUT8 LATBbits.LATB6
#define OUT9 LATBbits.LATB0
#define OUT10 LATBbits.LATB1
#define OUT11 LATBbits.LATB2
#define OUT12 LATBbits.LATB3
#define OUT13 LATBbits.LATB5
#define OUT14 LATEbits.LATE9
#define OUT15 LATEbits.LATE8
#define OUT16 LATGbits.LATG9
#define OUT17 LATGbits.LATG8
#define OUT18 LATGbits.LATG7
#define OUT19 LATGbits.LATG6

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void setSols(void); //sets solenoids on and off depending on global variable sols

/** Global Variables *******************************************/

int sols[19]; //vector to store if solenoids are on or off

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;
// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);
AD1PCFG = 0xFFFF; //this line sets up the B bits as digital outputs

TRISAbits.TRISA10 = 0; //set all solenoid and enable output pins to output
TRISAbits.TRISA9 = 0;
TRISBbits.TRISB11 = 0;
TRISBbits.TRISB10 = 0;
TRISBbits.TRISB9 = 0;
TRISBbits.TRISB8 = 0;
TRISBbits.TRISB7 = 0;
TRISBbits.TRISB6 = 0;
TRISBbits.TRISB5 = 0;
TRISBbits.TRISB3 = 0;
TRISBbits.TRISB2 = 0;
TRISBbits.TRISB1 = 0;
TRISEbits.TRISE9 = 0;
TRISEbits.TRISE8 = 0;
TRISGbits.TRISG8 = 0;
TRISGbits.TRISG7 = 0;
TRISGbits.TRISG6 = 0;
TRISBbits.TRISB0 = 0;
TRISGbits.TRISG9 = 0;
TRISDbits.TRISD1 = 0;
TRISDbits.TRISD2 = 0;

OUT1 = 0; //initialize outputs to low
OUT2 = 0;
OUT3 = 0;
OUT4 = 0;
OUT5 = 0;
OUT6 = 0;
OUT7 = 0;
OUT8 = 0;
OUT9 = 0;
OUT10 = 0;
OUT11 = 0;
OUT12 = 0;
OUT13 = 0;
OUT14 = 0;
OUT15 = 0;
OUT16 = 0;
OUT17 = 0;
OUT18 = 0;
OUT19 = 0;

//also initialize sols array to 0
for(i = 0; i < 19; i++){
sols[i] = 0;
}
setSols(); //this is probably redundant

mInitAllLEDs();

initUART2(pbClk);
INTEnableSystemMultiVectoredInt();

while(1)
{
1;//just keep going and wait for interrupts from RS232
} //end main

}
/** Interrupt Handlers *****************************************/

void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
int i;
unsigned char data2; //store character received from PC
char chararr[19] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'}; //array of characters for comparison
// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data2 = ReadUART2(); //get character

// Toggle LED to indicate UART activity
mLED_1_Toggle();

for(i = 0; i<19; i++){
if (data2 ==(int) chararr[i]){ sols[i] = 1 - sols[i];} //toggle solenoid corresponding to character received
}
setSols(); //update all solenoids

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void setSols(){
OUT1 = sols[0]; //set all outputs to correct value
OUT2 = sols[1];
OUT3 = sols[2];
OUT4 = sols[3];
OUT5 = sols[4];
OUT6 = sols[5];
OUT7 = sols[6];
OUT8 = sols[7];
OUT9 = sols[8];
OUT10 = sols[9];
OUT11 = sols[10];
OUT12 = sols[11];
OUT13 = sols[12];
OUT14 = sols[13];
OUT15 = sols[14];
OUT16 = sols[15];
OUT17 = sols[16];
OUT18 = sols[17];
OUT19 = sols[18];
ENABLE1 = 1; //turn on enable pins
ENABLE2 = 1;
Delayms(500); //wait for half a second for solenoids to change position
ENABLE1 = 0; //turn off enable pins
ENABLE2 = 0;
}

== Results ==
Max

== Reflections ==
Todd

Ferrofluid Art Display

2010-03-17T00:56:09Z

MaxWiller: /* Electrical Design */

File:Circuit diagram.png

2010-03-17T00:55:19Z

MaxWiller: Circuit Diagram

Circuit Diagram

Ferrofluid Art Display

2010-03-17T00:20:34Z

MaxWiller: /* Electrical Design */

== Overview ==
The goal of this project was to create an interesting display using [http://en.wikipedia.org/wiki/Ferrofluid Ferrofluid], which is composed of ferrimagnetic particles suspended in a carrier fluid. The project was inspired by the work of artists such as Sachiko Kodama and Yasushi Miyajima, shown in this [http://www.youtube.com/watch?v=me5Zzm2TXh4&feature=related video] of their installation "Morpho Towers". Our display consisted of a hexagonal array of solenoids used to actuate magnets towards or away from the fluid, allowing us to control which regions were smooth and which displayed corrugations. The display could then be controlled via a user interface with the PC.

=== Team Members ===
* Todd H. Poole (Mechanical Engineering & Electrical Engineering, Class of 2010)
* Katy Powers (Mechanical Engineering, Class of 2010)
* Max Willer (Mechanical Engineering, Class of 2011)

== Mechanical Design ==
Todd
An evolution of concepts.
-Early sketches
--Pros & Cons
Decision of

== Electrical Design ==

[[Image:ELECTRONICS.JPG|thumb|150px|Final Electronics Setup.|right]]

Our electronics system consisted of:
*One NU32 board: [[Introduction to the PIC32]]
*19 solenoids: [https://www.jameco.com/webapp/wcs/stores/servlet/OrderItemDisplay?langId=-1&storeId=10001&catalogId=10001&krypto=WUgCYelA18EFMkT03NuyYowmviur5pLw5O7ybblUbPU1s%2BE5iJH6qHHMpTSj4RJNARBe7J9MvmE%3D&ddkey=https:OrderItemUpdate Jameco Part #262271]
*10 L293NDE Quad-half-bridges: [http://www.datasheetcatalog.com/datasheets_pdf/L/2/9/3/L293DNE.shtml Datasheet]
*5 SN74HC00N NAND Integrated Circuits: [http://www.chipsinfo.com/TI/SN74HC00N.htm Datasheet]

*Inputs came from twenty of the PIC's digital output pins. 19 of those went to the NAND logic chips while the last one went to a hub controlling the enable pins of the H-Bridges.

*The NAND's were set up so that the input from the PIC went to both pins of the input so that the opposite signal would come out of the output. Both the input and the output of the NAND chip would then go to 2 inputs of the quad-half-bridge.

*The H-bridge would then output either a +12V or a -12V (forward or reverse) across the solenoid dependent on a high or low output from the PIC.

*The H-bridge is also connected to the enable voltage. Controlled by the PIC, the enable voltage, when high, would allow current to flow through the half-bridges. When low, no current would flow. This made it so that current would not flow at all times, just when the solenoids were switching position.

Picture of circuit for 4 solenoids goes.

==Code==
The code for the display setup consists of a GUI on the PC allowing the user to select which solenoids to turn on and off and code on the PIC to control the solenoids.

===Processing===
[[Image:Kpmw_userinterface.png|thumb|180px|Screenshot of User Interface. Green circles represent solenoids that are up while blue circles represent solenoids that are down.|right]]
The PC side of the user interface was created with [http://processing.org/ Processing], an open source programming environment with many options for interesting visual display. This code creates a display of circles arranged in the same way as the solenoids in our hardware, which will change from blue to green when clicked and output a character via RS232 to the PIC.
 

//Katy Powers
//3/11/2010
//ME 333 Ferrofluid Art GUI
//Lots of code taken from processing website and previous ME 333 labs..thanks!

// add the serial library
import processing.serial.*;
Serial[] myPorts = new Serial[1];

//setup parameters for hexagonal array
//cx,cy define center position, rc is circle radius, sp is how far apart they are
int cx = 250;
int cy = 250;
int rc = 50;
int sp = 10;

//circleX and circleY store center locations of every circle in array
//solenoidON stores state of solenoid
//chararr stores characters corresponding to each solenoid
int[] circleX = {cx, cx + rc + sp,cx + 2*(rc + sp),cx - (rc + sp),cx - 2*(rc + sp),cx + rc/2 + sp/2,
cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,cx+rc+sp, cx - (rc+sp),
cx + rc/2 + sp/2, cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,
cx + rc + sp,cx-(rc + sp)};

int[] circleY = {cy,cy,cy,cy,cy,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + 2*(rc+sp),
cy + 2*(rc+sp), cy + 2*(rc+sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),
cy - 2*(rc+sp),cy - 2*(rc+sp),cy - 2*(rc+sp)};

int[] solenoidON = new int[19];
char[] chararr = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'};
PFont font;
PFont smallfont;

void setup()
{
InitSerial();
background(0);
font = loadFont("FangSong-48.vlw");
smallfont = loadFont("FangSong-16.vlw");
size(500,500);
textAlign(CENTER);
for (int i = 0; i < 19; i = i+1){ //zero array of solenoid values, mouse state data
solenoidON[i] = 0;
}
rectMode(CENTER);
}

void draw()
{
fill(0,0,255);
textFont(font, 48);
text("Ferrofluid Art", cx, cy-200);
textFont(smallfont, 16);
text("Click a circle to make patterns in the Ferrofluid", cx, cy + 200);
hexagon(cx,cy,rc,sp, solenoidON);

}

void hexagon(int cx, int cy, int rc, int sp, int[] sols) //draws hexagon of cirlces
{
for (int i = 0; i < 19; i = i+1){
if(sols[i] == 0) {fill(0,0,255);}
else {fill(0,255,0);}
ellipse(circleX[i], circleY[i], rc, rc);
}

}

void mousePressed() //executes when mouse is pressed, much like an interrupt routine
{
float disX, disY;
for (int i = 0; i < 19; i = i+1){ //see where mouse is
disX = circleX[i] - mouseX;
disY = circleY[i] - mouseY;
if(sqrt(sq(disX) + sq(disY)) < rc/2 ) { //if mouse is in circle, toggle state and send character
solenoidON[i] = 1 - solenoidON[i];
myPorts[0].write(chararr[i]);
println(chararr[i]); //to debug
}
}
}

===PIC===
The PIC side of the code runs an infinite while loop, executing an interrupt routine every time a character is received from the RS232. The
PIC then updates the state of all the solenoids.

/**Ferrofluid Art Project Code**********************************/
/* Katy Powers Winter 2010 */

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include "LCD.h" //needed for Delayms

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define ENABLE1 LATDbits.LATD1 //Enable pins for H bridge circuit
#define ENABLE2 LATDbits.LATD2
#define OUT1 LATBbits.LATB11 //Output pins for solenoid control
#define OUT2 LATBbits.LATB10
#define OUT3 LATBbits.LATB9
#define OUT4 LATBbits.LATB8
#define OUT5 LATAbits.LATA10
#define OUT6 LATAbits.LATA9
#define OUT7 LATBbits.LATB7
#define OUT8 LATBbits.LATB6
#define OUT9 LATBbits.LATB0
#define OUT10 LATBbits.LATB1
#define OUT11 LATBbits.LATB2
#define OUT12 LATBbits.LATB3
#define OUT13 LATBbits.LATB5
#define OUT14 LATEbits.LATE9
#define OUT15 LATEbits.LATE8
#define OUT16 LATGbits.LATG9
#define OUT17 LATGbits.LATG8
#define OUT18 LATGbits.LATG7
#define OUT19 LATGbits.LATG6

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void setSols(void); //sets solenoids on and off depending on global variable sols

/** Global Variables *******************************************/

int sols[19]; //vector to store if solenoids are on or off

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;
// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);
AD1PCFG = 0xFFFF; //this line sets up the B bits as digital outputs

TRISAbits.TRISA10 = 0; //set all solenoid and enable output pins to output
TRISAbits.TRISA9 = 0;
TRISBbits.TRISB11 = 0;
TRISBbits.TRISB10 = 0;
TRISBbits.TRISB9 = 0;
TRISBbits.TRISB8 = 0;
TRISBbits.TRISB7 = 0;
TRISBbits.TRISB6 = 0;
TRISBbits.TRISB5 = 0;
TRISBbits.TRISB3 = 0;
TRISBbits.TRISB2 = 0;
TRISBbits.TRISB1 = 0;
TRISEbits.TRISE9 = 0;
TRISEbits.TRISE8 = 0;
TRISGbits.TRISG8 = 0;
TRISGbits.TRISG7 = 0;
TRISGbits.TRISG6 = 0;
TRISBbits.TRISB0 = 0;
TRISGbits.TRISG9 = 0;
TRISDbits.TRISD1 = 0;
TRISDbits.TRISD2 = 0;

OUT1 = 0; //initialize outputs to low
OUT2 = 0;
OUT3 = 0;
OUT4 = 0;
OUT5 = 0;
OUT6 = 0;
OUT7 = 0;
OUT8 = 0;
OUT9 = 0;
OUT10 = 0;
OUT11 = 0;
OUT12 = 0;
OUT13 = 0;
OUT14 = 0;
OUT15 = 0;
OUT16 = 0;
OUT17 = 0;
OUT18 = 0;
OUT19 = 0;

//also initialize sols array to 0
for(i = 0; i < 19; i++){
sols[i] = 0;
}
setSols(); //this is probably redundant

mInitAllLEDs();

initUART2(pbClk);
INTEnableSystemMultiVectoredInt();

while(1)
{
1;//just keep going and wait for interrupts from RS232
} //end main

}
/** Interrupt Handlers *****************************************/

void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
int i;
unsigned char data2; //store character received from PC
char chararr[19] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'}; //array of characters for comparison
// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data2 = ReadUART2(); //get character

// Toggle LED to indicate UART activity
mLED_1_Toggle();

for(i = 0; i<19; i++){
if (data2 ==(int) chararr[i]){ sols[i] = 1 - sols[i];} //toggle solenoid corresponding to character received
}
setSols(); //update all solenoids

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void setSols(){
OUT1 = sols[0]; //set all outputs to correct value
OUT2 = sols[1];
OUT3 = sols[2];
OUT4 = sols[3];
OUT5 = sols[4];
OUT6 = sols[5];
OUT7 = sols[6];
OUT8 = sols[7];
OUT9 = sols[8];
OUT10 = sols[9];
OUT11 = sols[10];
OUT12 = sols[11];
OUT13 = sols[12];
OUT14 = sols[13];
OUT15 = sols[14];
OUT16 = sols[15];
OUT17 = sols[16];
OUT18 = sols[17];
OUT19 = sols[18];
ENABLE1 = 1; //turn on enable pins
ENABLE2 = 1;
Delayms(500); //wait for half a second for solenoids to change position
ENABLE1 = 0; //turn off enable pins
ENABLE2 = 0;
}

== Results ==
Max

== Reflections ==
Todd

Ferrofluid Art Display

2010-03-17T00:19:36Z

MaxWiller: /* Electrical Design */

== Overview ==
The goal of this project was to create an interesting display using [http://en.wikipedia.org/wiki/Ferrofluid Ferrofluid], which is composed of ferrimagnetic particles suspended in a carrier fluid. The project was inspired by the work of artists such as Sachiko Kodama and Yasushi Miyajima, shown in this [http://www.youtube.com/watch?v=me5Zzm2TXh4&feature=related video] of their installation "Morpho Towers". Our display consisted of a hexagonal array of solenoids used to actuate magnets towards or away from the fluid, allowing us to control which regions were smooth and which displayed corrugations. The display could then be controlled via a user interface with the PC.

=== Team Members ===
* Todd H. Poole (Mechanical Engineering & Electrical Engineering, Class of 2010)
* Katy Powers (Mechanical Engineering, Class of 2010)
* Max Willer (Mechanical Engineering, Class of 2011)

== Mechanical Design ==
Todd
An evolution of concepts.
-Early sketches
--Pros & Cons
Decision of

== Electrical Design ==

[[Image:ELECTRONICS.JPG|thumb|150px|Final Electronics Setup.|right]]

Our electronics system consisted of:
*One [[Introduction to the PIC32]] NU32 board
*19 solenoids: [https://www.jameco.com/webapp/wcs/stores/servlet/OrderItemDisplay?langId=-1&storeId=10001&catalogId=10001&krypto=WUgCYelA18EFMkT03NuyYowmviur5pLw5O7ybblUbPU1s%2BE5iJH6qHHMpTSj4RJNARBe7J9MvmE%3D&ddkey=https:OrderItemUpdate Jameco Part #262271]
*10 L293NDE Quad-half-bridges: [http://www.datasheetcatalog.com/datasheets_pdf/L/2/9/3/L293DNE.shtml Datasheet]
*5 SN74HC00N NAND Integrated Circuits: [http://www.chipsinfo.com/TI/SN74HC00N.htm Datasheet]

*Inputs came from twenty of the PIC's digital output pins. 19 of those went to the NAND logic chips while the last one went to a hub controlling the enable pins of the H-Bridges.

*The NAND's were set up so that the input from the PIC went to both pins of the input so that the opposite signal would come out of the output. Both the input and the output of the NAND chip would then go to 2 inputs of the quad-half-bridge.

*The H-bridge would then output either a +12V or a -12V (forward or reverse) across the solenoid dependent on a high or low output from the PIC.

*The H-bridge is also connected to the enable voltage. Controlled by the PIC, the enable voltage, when high, would allow current to flow through the half-bridges. When low, no current would flow. This made it so that current would not flow at all times, just when the solenoids were switching position.

Picture of circuit for 4 solenoids goes.

==Code==
The code for the display setup consists of a GUI on the PC allowing the user to select which solenoids to turn on and off and code on the PIC to control the solenoids.

===Processing===
[[Image:Kpmw_userinterface.png|thumb|180px|Screenshot of User Interface. Green circles represent solenoids that are up while blue circles represent solenoids that are down.|right]]
The PC side of the user interface was created with [http://processing.org/ Processing], an open source programming environment with many options for interesting visual display. This code creates a display of circles arranged in the same way as the solenoids in our hardware, which will change from blue to green when clicked and output a character via RS232 to the PIC.
 

//Katy Powers
//3/11/2010
//ME 333 Ferrofluid Art GUI
//Lots of code taken from processing website and previous ME 333 labs..thanks!

// add the serial library
import processing.serial.*;
Serial[] myPorts = new Serial[1];

//setup parameters for hexagonal array
//cx,cy define center position, rc is circle radius, sp is how far apart they are
int cx = 250;
int cy = 250;
int rc = 50;
int sp = 10;

//circleX and circleY store center locations of every circle in array
//solenoidON stores state of solenoid
//chararr stores characters corresponding to each solenoid
int[] circleX = {cx, cx + rc + sp,cx + 2*(rc + sp),cx - (rc + sp),cx - 2*(rc + sp),cx + rc/2 + sp/2,
cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,cx+rc+sp, cx - (rc+sp),
cx + rc/2 + sp/2, cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,
cx + rc + sp,cx-(rc + sp)};

int[] circleY = {cy,cy,cy,cy,cy,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + 2*(rc+sp),
cy + 2*(rc+sp), cy + 2*(rc+sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),
cy - 2*(rc+sp),cy - 2*(rc+sp),cy - 2*(rc+sp)};

int[] solenoidON = new int[19];
char[] chararr = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'};
PFont font;
PFont smallfont;

void setup()
{
InitSerial();
background(0);
font = loadFont("FangSong-48.vlw");
smallfont = loadFont("FangSong-16.vlw");
size(500,500);
textAlign(CENTER);
for (int i = 0; i < 19; i = i+1){ //zero array of solenoid values, mouse state data
solenoidON[i] = 0;
}
rectMode(CENTER);
}

void draw()
{
fill(0,0,255);
textFont(font, 48);
text("Ferrofluid Art", cx, cy-200);
textFont(smallfont, 16);
text("Click a circle to make patterns in the Ferrofluid", cx, cy + 200);
hexagon(cx,cy,rc,sp, solenoidON);

}

void hexagon(int cx, int cy, int rc, int sp, int[] sols) //draws hexagon of cirlces
{
for (int i = 0; i < 19; i = i+1){
if(sols[i] == 0) {fill(0,0,255);}
else {fill(0,255,0);}
ellipse(circleX[i], circleY[i], rc, rc);
}

}

void mousePressed() //executes when mouse is pressed, much like an interrupt routine
{
float disX, disY;
for (int i = 0; i < 19; i = i+1){ //see where mouse is
disX = circleX[i] - mouseX;
disY = circleY[i] - mouseY;
if(sqrt(sq(disX) + sq(disY)) < rc/2 ) { //if mouse is in circle, toggle state and send character
solenoidON[i] = 1 - solenoidON[i];
myPorts[0].write(chararr[i]);
println(chararr[i]); //to debug
}
}
}

===PIC===
The PIC side of the code runs an infinite while loop, executing an interrupt routine every time a character is received from the RS232. The
PIC then updates the state of all the solenoids.

/**Ferrofluid Art Project Code**********************************/
/* Katy Powers Winter 2010 */

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include "LCD.h" //needed for Delayms

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define ENABLE1 LATDbits.LATD1 //Enable pins for H bridge circuit
#define ENABLE2 LATDbits.LATD2
#define OUT1 LATBbits.LATB11 //Output pins for solenoid control
#define OUT2 LATBbits.LATB10
#define OUT3 LATBbits.LATB9
#define OUT4 LATBbits.LATB8
#define OUT5 LATAbits.LATA10
#define OUT6 LATAbits.LATA9
#define OUT7 LATBbits.LATB7
#define OUT8 LATBbits.LATB6
#define OUT9 LATBbits.LATB0
#define OUT10 LATBbits.LATB1
#define OUT11 LATBbits.LATB2
#define OUT12 LATBbits.LATB3
#define OUT13 LATBbits.LATB5
#define OUT14 LATEbits.LATE9
#define OUT15 LATEbits.LATE8
#define OUT16 LATGbits.LATG9
#define OUT17 LATGbits.LATG8
#define OUT18 LATGbits.LATG7
#define OUT19 LATGbits.LATG6

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void setSols(void); //sets solenoids on and off depending on global variable sols

/** Global Variables *******************************************/

int sols[19]; //vector to store if solenoids are on or off

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;
// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);
AD1PCFG = 0xFFFF; //this line sets up the B bits as digital outputs

TRISAbits.TRISA10 = 0; //set all solenoid and enable output pins to output
TRISAbits.TRISA9 = 0;
TRISBbits.TRISB11 = 0;
TRISBbits.TRISB10 = 0;
TRISBbits.TRISB9 = 0;
TRISBbits.TRISB8 = 0;
TRISBbits.TRISB7 = 0;
TRISBbits.TRISB6 = 0;
TRISBbits.TRISB5 = 0;
TRISBbits.TRISB3 = 0;
TRISBbits.TRISB2 = 0;
TRISBbits.TRISB1 = 0;
TRISEbits.TRISE9 = 0;
TRISEbits.TRISE8 = 0;
TRISGbits.TRISG8 = 0;
TRISGbits.TRISG7 = 0;
TRISGbits.TRISG6 = 0;
TRISBbits.TRISB0 = 0;
TRISGbits.TRISG9 = 0;
TRISDbits.TRISD1 = 0;
TRISDbits.TRISD2 = 0;

OUT1 = 0; //initialize outputs to low
OUT2 = 0;
OUT3 = 0;
OUT4 = 0;
OUT5 = 0;
OUT6 = 0;
OUT7 = 0;
OUT8 = 0;
OUT9 = 0;
OUT10 = 0;
OUT11 = 0;
OUT12 = 0;
OUT13 = 0;
OUT14 = 0;
OUT15 = 0;
OUT16 = 0;
OUT17 = 0;
OUT18 = 0;
OUT19 = 0;

//also initialize sols array to 0
for(i = 0; i < 19; i++){
sols[i] = 0;
}
setSols(); //this is probably redundant

mInitAllLEDs();

initUART2(pbClk);
INTEnableSystemMultiVectoredInt();

while(1)
{
1;//just keep going and wait for interrupts from RS232
} //end main

}
/** Interrupt Handlers *****************************************/

void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
int i;
unsigned char data2; //store character received from PC
char chararr[19] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'}; //array of characters for comparison
// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data2 = ReadUART2(); //get character

// Toggle LED to indicate UART activity
mLED_1_Toggle();

for(i = 0; i<19; i++){
if (data2 ==(int) chararr[i]){ sols[i] = 1 - sols[i];} //toggle solenoid corresponding to character received
}
setSols(); //update all solenoids

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void setSols(){
OUT1 = sols[0]; //set all outputs to correct value
OUT2 = sols[1];
OUT3 = sols[2];
OUT4 = sols[3];
OUT5 = sols[4];
OUT6 = sols[5];
OUT7 = sols[6];
OUT8 = sols[7];
OUT9 = sols[8];
OUT10 = sols[9];
OUT11 = sols[10];
OUT12 = sols[11];
OUT13 = sols[12];
OUT14 = sols[13];
OUT15 = sols[14];
OUT16 = sols[15];
OUT17 = sols[16];
OUT18 = sols[17];
OUT19 = sols[18];
ENABLE1 = 1; //turn on enable pins
ENABLE2 = 1;
Delayms(500); //wait for half a second for solenoids to change position
ENABLE1 = 0; //turn off enable pins
ENABLE2 = 0;
}

== Results ==
Max

== Reflections ==
Todd

Ferrofluid Art Display

2010-03-17T00:17:28Z

MaxWiller: /* Electrical Design */

== Overview ==
The goal of this project was to create an interesting display using [http://en.wikipedia.org/wiki/Ferrofluid Ferrofluid], which is composed of ferrimagnetic particles suspended in a carrier fluid. The project was inspired by the work of artists such as Sachiko Kodama and Yasushi Miyajima, shown in this [http://www.youtube.com/watch?v=me5Zzm2TXh4&feature=related video] of their installation "Morpho Towers". Our display consisted of a hexagonal array of solenoids used to actuate magnets towards or away from the fluid, allowing us to control which regions were smooth and which displayed corrugations. The display could then be controlled via a user interface with the PC.

=== Team Members ===
* Todd H. Poole (Mechanical Engineering & Electrical Engineering, Class of 2010)
* Katy Powers (Mechanical Engineering, Class of 2010)
* Max Willer (Mechanical Engineering, Class of 2011)

== Mechanical Design ==
Todd
An evolution of concepts.
-Early sketches
--Pros & Cons
Decision of

== Electrical Design ==

[[Image:ELECTRONICS.JPG|thumb|150px|Final Electronics Setup.|right]]

Our electronics system consisted of:
*One NU32 board
*19 solenoids: [https://www.jameco.com/webapp/wcs/stores/servlet/OrderItemDisplay?langId=-1&storeId=10001&catalogId=10001&krypto=WUgCYelA18EFMkT03NuyYowmviur5pLw5O7ybblUbPU1s%2BE5iJH6qHHMpTSj4RJNARBe7J9MvmE%3D&ddkey=https:OrderItemUpdate Jameco Part #262271]
*10 L293NDE Quad-half-bridges: [http://www.datasheetcatalog.com/datasheets_pdf/L/2/9/3/L293DNE.shtml Datasheet]
*5 SN74HC00N NAND Integrated Circuits: [http://www.chipsinfo.com/TI/SN74HC00N.htm Datasheet]

*Inputs came from twenty of the PIC's digital output pins. 19 of those went to the NAND logic chips while the last one went to a hub controlling the enable pins of the H-Bridges.

*The NAND's were set up so that the input from the PIC went to both pins of the input so that the opposite signal would come out of the output. Both the input and the output of the NAND chip would then go to 2 inputs of the quad-half-bridge.

*The H-bridge would then output either a +12V or a -12V (forward or reverse) across the solenoid dependent on a high or low output from the PIC.

*The H-bridge is also connected to the enable voltage. Controlled by the PIC, the enable voltage, when high, would allow current to flow through the half-bridges. When low, no current would flow. This made it so that current would not flow at all times, just when the solenoids were switching position.

Picture of circuit for 4 solenoids goes.

==Code==
The code for the display setup consists of a GUI on the PC allowing the user to select which solenoids to turn on and off and code on the PIC to control the solenoids.

===Processing===
[[Image:Kpmw_userinterface.png|thumb|180px|Screenshot of User Interface. Green circles represent solenoids that are up while blue circles represent solenoids that are down.|right]]
The PC side of the user interface was created with [http://processing.org/ Processing], an open source programming environment with many options for interesting visual display. This code creates a display of circles arranged in the same way as the solenoids in our hardware, which will change from blue to green when clicked and output a character via RS232 to the PIC.
 

//Katy Powers
//3/11/2010
//ME 333 Ferrofluid Art GUI
//Lots of code taken from processing website and previous ME 333 labs..thanks!

// add the serial library
import processing.serial.*;
Serial[] myPorts = new Serial[1];

//setup parameters for hexagonal array
//cx,cy define center position, rc is circle radius, sp is how far apart they are
int cx = 250;
int cy = 250;
int rc = 50;
int sp = 10;

//circleX and circleY store center locations of every circle in array
//solenoidON stores state of solenoid
//chararr stores characters corresponding to each solenoid
int[] circleX = {cx, cx + rc + sp,cx + 2*(rc + sp),cx - (rc + sp),cx - 2*(rc + sp),cx + rc/2 + sp/2,
cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,cx+rc+sp, cx - (rc+sp),
cx + rc/2 + sp/2, cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,
cx + rc + sp,cx-(rc + sp)};

int[] circleY = {cy,cy,cy,cy,cy,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + 2*(rc+sp),
cy + 2*(rc+sp), cy + 2*(rc+sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),
cy - 2*(rc+sp),cy - 2*(rc+sp),cy - 2*(rc+sp)};

int[] solenoidON = new int[19];
char[] chararr = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'};
PFont font;
PFont smallfont;

void setup()
{
InitSerial();
background(0);
font = loadFont("FangSong-48.vlw");
smallfont = loadFont("FangSong-16.vlw");
size(500,500);
textAlign(CENTER);
for (int i = 0; i < 19; i = i+1){ //zero array of solenoid values, mouse state data
solenoidON[i] = 0;
}
rectMode(CENTER);
}

void draw()
{
fill(0,0,255);
textFont(font, 48);
text("Ferrofluid Art", cx, cy-200);
textFont(smallfont, 16);
text("Click a circle to make patterns in the Ferrofluid", cx, cy + 200);
hexagon(cx,cy,rc,sp, solenoidON);

}

void hexagon(int cx, int cy, int rc, int sp, int[] sols) //draws hexagon of cirlces
{
for (int i = 0; i < 19; i = i+1){
if(sols[i] == 0) {fill(0,0,255);}
else {fill(0,255,0);}
ellipse(circleX[i], circleY[i], rc, rc);
}

}

void mousePressed() //executes when mouse is pressed, much like an interrupt routine
{
float disX, disY;
for (int i = 0; i < 19; i = i+1){ //see where mouse is
disX = circleX[i] - mouseX;
disY = circleY[i] - mouseY;
if(sqrt(sq(disX) + sq(disY)) < rc/2 ) { //if mouse is in circle, toggle state and send character
solenoidON[i] = 1 - solenoidON[i];
myPorts[0].write(chararr[i]);
println(chararr[i]); //to debug
}
}
}

===PIC===
The PIC side of the code runs an infinite while loop, executing an interrupt routine every time a character is received from the RS232. The
PIC then updates the state of all the solenoids.

/**Ferrofluid Art Project Code**********************************/
/* Katy Powers Winter 2010 */

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include "LCD.h" //needed for Delayms

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define ENABLE1 LATDbits.LATD1 //Enable pins for H bridge circuit
#define ENABLE2 LATDbits.LATD2
#define OUT1 LATBbits.LATB11 //Output pins for solenoid control
#define OUT2 LATBbits.LATB10
#define OUT3 LATBbits.LATB9
#define OUT4 LATBbits.LATB8
#define OUT5 LATAbits.LATA10
#define OUT6 LATAbits.LATA9
#define OUT7 LATBbits.LATB7
#define OUT8 LATBbits.LATB6
#define OUT9 LATBbits.LATB0
#define OUT10 LATBbits.LATB1
#define OUT11 LATBbits.LATB2
#define OUT12 LATBbits.LATB3
#define OUT13 LATBbits.LATB5
#define OUT14 LATEbits.LATE9
#define OUT15 LATEbits.LATE8
#define OUT16 LATGbits.LATG9
#define OUT17 LATGbits.LATG8
#define OUT18 LATGbits.LATG7
#define OUT19 LATGbits.LATG6

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void setSols(void); //sets solenoids on and off depending on global variable sols

/** Global Variables *******************************************/

int sols[19]; //vector to store if solenoids are on or off

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;
// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);
AD1PCFG = 0xFFFF; //this line sets up the B bits as digital outputs

TRISAbits.TRISA10 = 0; //set all solenoid and enable output pins to output
TRISAbits.TRISA9 = 0;
TRISBbits.TRISB11 = 0;
TRISBbits.TRISB10 = 0;
TRISBbits.TRISB9 = 0;
TRISBbits.TRISB8 = 0;
TRISBbits.TRISB7 = 0;
TRISBbits.TRISB6 = 0;
TRISBbits.TRISB5 = 0;
TRISBbits.TRISB3 = 0;
TRISBbits.TRISB2 = 0;
TRISBbits.TRISB1 = 0;
TRISEbits.TRISE9 = 0;
TRISEbits.TRISE8 = 0;
TRISGbits.TRISG8 = 0;
TRISGbits.TRISG7 = 0;
TRISGbits.TRISG6 = 0;
TRISBbits.TRISB0 = 0;
TRISGbits.TRISG9 = 0;
TRISDbits.TRISD1 = 0;
TRISDbits.TRISD2 = 0;

OUT1 = 0; //initialize outputs to low
OUT2 = 0;
OUT3 = 0;
OUT4 = 0;
OUT5 = 0;
OUT6 = 0;
OUT7 = 0;
OUT8 = 0;
OUT9 = 0;
OUT10 = 0;
OUT11 = 0;
OUT12 = 0;
OUT13 = 0;
OUT14 = 0;
OUT15 = 0;
OUT16 = 0;
OUT17 = 0;
OUT18 = 0;
OUT19 = 0;

//also initialize sols array to 0
for(i = 0; i < 19; i++){
sols[i] = 0;
}
setSols(); //this is probably redundant

mInitAllLEDs();

initUART2(pbClk);
INTEnableSystemMultiVectoredInt();

while(1)
{
1;//just keep going and wait for interrupts from RS232
} //end main

}
/** Interrupt Handlers *****************************************/

void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
int i;
unsigned char data2; //store character received from PC
char chararr[19] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'}; //array of characters for comparison
// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data2 = ReadUART2(); //get character

// Toggle LED to indicate UART activity
mLED_1_Toggle();

for(i = 0; i<19; i++){
if (data2 ==(int) chararr[i]){ sols[i] = 1 - sols[i];} //toggle solenoid corresponding to character received
}
setSols(); //update all solenoids

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void setSols(){
OUT1 = sols[0]; //set all outputs to correct value
OUT2 = sols[1];
OUT3 = sols[2];
OUT4 = sols[3];
OUT5 = sols[4];
OUT6 = sols[5];
OUT7 = sols[6];
OUT8 = sols[7];
OUT9 = sols[8];
OUT10 = sols[9];
OUT11 = sols[10];
OUT12 = sols[11];
OUT13 = sols[12];
OUT14 = sols[13];
OUT15 = sols[14];
OUT16 = sols[15];
OUT17 = sols[16];
OUT18 = sols[17];
OUT19 = sols[18];
ENABLE1 = 1; //turn on enable pins
ENABLE2 = 1;
Delayms(500); //wait for half a second for solenoids to change position
ENABLE1 = 0; //turn off enable pins
ENABLE2 = 0;
}

== Results ==
Max

== Reflections ==
Todd

Ferrofluid Art Display

2010-03-17T00:16:53Z

MaxWiller: /* Electrical Design */

== Overview ==
The goal of this project was to create an interesting display using [http://en.wikipedia.org/wiki/Ferrofluid Ferrofluid], which is composed of ferrimagnetic particles suspended in a carrier fluid. The project was inspired by the work of artists such as Sachiko Kodama and Yasushi Miyajima, shown in this [http://www.youtube.com/watch?v=me5Zzm2TXh4&feature=related video] of their installation "Morpho Towers". Our display consisted of a hexagonal array of solenoids used to actuate magnets towards or away from the fluid, allowing us to control which regions were smooth and which displayed corrugations. The display could then be controlled via a user interface with the PC.

=== Team Members ===
* Todd H. Poole (Mechanical Engineering & Electrical Engineering, Class of 2010)
* Katy Powers (Mechanical Engineering, Class of 2010)
* Max Willer (Mechanical Engineering, Class of 2011)

== Mechanical Design ==
Todd
An evolution of concepts.
-Early sketches
--Pros & Cons
Decision of

== Electrical Design ==

[[Image:ELECTRONICS.JPG|thumb|150px|Final Electronics Setup.|right]]

Our electronics system consisted of:
*One NU32 board
*19 solenoids [https://www.jameco.com/webapp/wcs/stores/servlet/OrderItemDisplay?langId=-1&storeId=10001&catalogId=10001&krypto=WUgCYelA18EFMkT03NuyYowmviur5pLw5O7ybblUbPU1s%2BE5iJH6qHHMpTSj4RJNARBe7J9MvmE%3D&ddkey=https:OrderItemUpdate Jameco Part #262271]
*10 L293NDE Quad-half-bridges [http://www.datasheetcatalog.com/datasheets_pdf/L/2/9/3/L293DNE.shtml Datasheet]
*5 SN74HC00N NAND Integrated Circuits [http://www.chipsinfo.com/TI/SN74HC00N.htm Datasheet]

*Inputs came from twenty of the PIC's digital output pins. 19 of those went to the NAND logic chips while the last one went to a hub controlling the enable pins of the H-Bridges.

*The NAND's were set up so that the input from the PIC went to both pins of the input so that the opposite signal would come out of the output. Both the input and the output of the NAND chip would then go to 2 inputs of the quad-half-bridge.

*The H-bridge would then output either a +12V or a -12V (forward or reverse) across the solenoid dependent on a high or low output from the PIC.

*The H-bridge is also connected to the enable voltage. Controlled by the PIC, the enable voltage, when high, would allow current to flow through the half-bridges. When low, no current would flow. This made it so that current would not flow at all times, just when the solenoids were switching position.

Picture of circuit for 4 solenoids goes.

==Code==
The code for the display setup consists of a GUI on the PC allowing the user to select which solenoids to turn on and off and code on the PIC to control the solenoids.

===Processing===
[[Image:Kpmw_userinterface.png|thumb|180px|Screenshot of User Interface. Green circles represent solenoids that are up while blue circles represent solenoids that are down.|right]]
The PC side of the user interface was created with [http://processing.org/ Processing], an open source programming environment with many options for interesting visual display. This code creates a display of circles arranged in the same way as the solenoids in our hardware, which will change from blue to green when clicked and output a character via RS232 to the PIC.
 

//Katy Powers
//3/11/2010
//ME 333 Ferrofluid Art GUI
//Lots of code taken from processing website and previous ME 333 labs..thanks!

// add the serial library
import processing.serial.*;
Serial[] myPorts = new Serial[1];

//setup parameters for hexagonal array
//cx,cy define center position, rc is circle radius, sp is how far apart they are
int cx = 250;
int cy = 250;
int rc = 50;
int sp = 10;

//circleX and circleY store center locations of every circle in array
//solenoidON stores state of solenoid
//chararr stores characters corresponding to each solenoid
int[] circleX = {cx, cx + rc + sp,cx + 2*(rc + sp),cx - (rc + sp),cx - 2*(rc + sp),cx + rc/2 + sp/2,
cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,cx+rc+sp, cx - (rc+sp),
cx + rc/2 + sp/2, cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,
cx + rc + sp,cx-(rc + sp)};

int[] circleY = {cy,cy,cy,cy,cy,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + 2*(rc+sp),
cy + 2*(rc+sp), cy + 2*(rc+sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),
cy - 2*(rc+sp),cy - 2*(rc+sp),cy - 2*(rc+sp)};

int[] solenoidON = new int[19];
char[] chararr = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'};
PFont font;
PFont smallfont;

void setup()
{
InitSerial();
background(0);
font = loadFont("FangSong-48.vlw");
smallfont = loadFont("FangSong-16.vlw");
size(500,500);
textAlign(CENTER);
for (int i = 0; i < 19; i = i+1){ //zero array of solenoid values, mouse state data
solenoidON[i] = 0;
}
rectMode(CENTER);
}

void draw()
{
fill(0,0,255);
textFont(font, 48);
text("Ferrofluid Art", cx, cy-200);
textFont(smallfont, 16);
text("Click a circle to make patterns in the Ferrofluid", cx, cy + 200);
hexagon(cx,cy,rc,sp, solenoidON);

}

void hexagon(int cx, int cy, int rc, int sp, int[] sols) //draws hexagon of cirlces
{
for (int i = 0; i < 19; i = i+1){
if(sols[i] == 0) {fill(0,0,255);}
else {fill(0,255,0);}
ellipse(circleX[i], circleY[i], rc, rc);
}

}

void mousePressed() //executes when mouse is pressed, much like an interrupt routine
{
float disX, disY;
for (int i = 0; i < 19; i = i+1){ //see where mouse is
disX = circleX[i] - mouseX;
disY = circleY[i] - mouseY;
if(sqrt(sq(disX) + sq(disY)) < rc/2 ) { //if mouse is in circle, toggle state and send character
solenoidON[i] = 1 - solenoidON[i];
myPorts[0].write(chararr[i]);
println(chararr[i]); //to debug
}
}
}

===PIC===
The PIC side of the code runs an infinite while loop, executing an interrupt routine every time a character is received from the RS232. The
PIC then updates the state of all the solenoids.

/**Ferrofluid Art Project Code**********************************/
/* Katy Powers Winter 2010 */

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include "LCD.h" //needed for Delayms

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define ENABLE1 LATDbits.LATD1 //Enable pins for H bridge circuit
#define ENABLE2 LATDbits.LATD2
#define OUT1 LATBbits.LATB11 //Output pins for solenoid control
#define OUT2 LATBbits.LATB10
#define OUT3 LATBbits.LATB9
#define OUT4 LATBbits.LATB8
#define OUT5 LATAbits.LATA10
#define OUT6 LATAbits.LATA9
#define OUT7 LATBbits.LATB7
#define OUT8 LATBbits.LATB6
#define OUT9 LATBbits.LATB0
#define OUT10 LATBbits.LATB1
#define OUT11 LATBbits.LATB2
#define OUT12 LATBbits.LATB3
#define OUT13 LATBbits.LATB5
#define OUT14 LATEbits.LATE9
#define OUT15 LATEbits.LATE8
#define OUT16 LATGbits.LATG9
#define OUT17 LATGbits.LATG8
#define OUT18 LATGbits.LATG7
#define OUT19 LATGbits.LATG6

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void setSols(void); //sets solenoids on and off depending on global variable sols

/** Global Variables *******************************************/

int sols[19]; //vector to store if solenoids are on or off

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;
// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);
AD1PCFG = 0xFFFF; //this line sets up the B bits as digital outputs

TRISAbits.TRISA10 = 0; //set all solenoid and enable output pins to output
TRISAbits.TRISA9 = 0;
TRISBbits.TRISB11 = 0;
TRISBbits.TRISB10 = 0;
TRISBbits.TRISB9 = 0;
TRISBbits.TRISB8 = 0;
TRISBbits.TRISB7 = 0;
TRISBbits.TRISB6 = 0;
TRISBbits.TRISB5 = 0;
TRISBbits.TRISB3 = 0;
TRISBbits.TRISB2 = 0;
TRISBbits.TRISB1 = 0;
TRISEbits.TRISE9 = 0;
TRISEbits.TRISE8 = 0;
TRISGbits.TRISG8 = 0;
TRISGbits.TRISG7 = 0;
TRISGbits.TRISG6 = 0;
TRISBbits.TRISB0 = 0;
TRISGbits.TRISG9 = 0;
TRISDbits.TRISD1 = 0;
TRISDbits.TRISD2 = 0;

OUT1 = 0; //initialize outputs to low
OUT2 = 0;
OUT3 = 0;
OUT4 = 0;
OUT5 = 0;
OUT6 = 0;
OUT7 = 0;
OUT8 = 0;
OUT9 = 0;
OUT10 = 0;
OUT11 = 0;
OUT12 = 0;
OUT13 = 0;
OUT14 = 0;
OUT15 = 0;
OUT16 = 0;
OUT17 = 0;
OUT18 = 0;
OUT19 = 0;

//also initialize sols array to 0
for(i = 0; i < 19; i++){
sols[i] = 0;
}
setSols(); //this is probably redundant

mInitAllLEDs();

initUART2(pbClk);
INTEnableSystemMultiVectoredInt();

while(1)
{
1;//just keep going and wait for interrupts from RS232
} //end main

}
/** Interrupt Handlers *****************************************/

void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
int i;
unsigned char data2; //store character received from PC
char chararr[19] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'}; //array of characters for comparison
// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data2 = ReadUART2(); //get character

// Toggle LED to indicate UART activity
mLED_1_Toggle();

for(i = 0; i<19; i++){
if (data2 ==(int) chararr[i]){ sols[i] = 1 - sols[i];} //toggle solenoid corresponding to character received
}
setSols(); //update all solenoids

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void setSols(){
OUT1 = sols[0]; //set all outputs to correct value
OUT2 = sols[1];
OUT3 = sols[2];
OUT4 = sols[3];
OUT5 = sols[4];
OUT6 = sols[5];
OUT7 = sols[6];
OUT8 = sols[7];
OUT9 = sols[8];
OUT10 = sols[9];
OUT11 = sols[10];
OUT12 = sols[11];
OUT13 = sols[12];
OUT14 = sols[13];
OUT15 = sols[14];
OUT16 = sols[15];
OUT17 = sols[16];
OUT18 = sols[17];
OUT19 = sols[18];
ENABLE1 = 1; //turn on enable pins
ENABLE2 = 1;
Delayms(500); //wait for half a second for solenoids to change position
ENABLE1 = 0; //turn off enable pins
ENABLE2 = 0;
}

== Results ==
Max

== Reflections ==
Todd

Ferrofluid Art Display

2010-03-17T00:14:34Z

MaxWiller: /* Electrical Design */

== Overview ==
The goal of this project was to create an interesting display using [http://en.wikipedia.org/wiki/Ferrofluid Ferrofluid], which is composed of ferrimagnetic particles suspended in a carrier fluid. The project was inspired by the work of artists such as Sachiko Kodama and Yasushi Miyajima, shown in this [http://www.youtube.com/watch?v=me5Zzm2TXh4&feature=related video] of their installation "Morpho Towers". Our display consisted of a hexagonal array of solenoids used to actuate magnets towards or away from the fluid, allowing us to control which regions were smooth and which displayed corrugations. The display could then be controlled via a user interface with the PC.

=== Team Members ===
* Todd H. Poole (Mechanical Engineering & Electrical Engineering, Class of 2010)
* Katy Powers (Mechanical Engineering, Class of 2010)
* Max Willer (Mechanical Engineering, Class of 2011)

== Mechanical Design ==
Todd
An evolution of concepts.
-Early sketches
--Pros & Cons
Decision of

== Electrical Design ==

[[Image:ELECTRONICS.JPG|thumb|150px|Final Electronics Setup.|right]]

Our electronics system consisted of:
*One NU32 board
*19 solenoids [https://www.jameco.com/webapp/wcs/stores/servlet/OrderItemDisplay?langId=-1&storeId=10001&catalogId=10001&krypto=WUgCYelA18EFMkT03NuyYowmviur5pLw5O7ybblUbPU1s%2BE5iJH6qHHMpTSj4RJNARBe7J9MvmE%3D&ddkey=https:OrderItemUpdate Jameco Part #262271]
*10 L293N Quad-half-bridges (insert part # + datasheet here)
*5 SN7... NAND Integrated Circuits (insert part # + datasheet here)

*Inputs came from twenty of the PIC's digital output pins. 19 of those went to the NAND logic chips while the last one went to a hub controlling the enable pins of the H-Bridges.

*The NAND's were set up so that the input from the PIC went to both pins of the input so that the opposite signal would come out of the output. Both the input and the output of the NAND chip would then go to 2 inputs of the quad-half-bridge.

*The H-bridge would then output either a +12V or a -12V (forward or reverse) across the solenoid dependent on a high or low output from the PIC.

*The H-bridge is also connected to the enable voltage. Controlled by the PIC, the enable voltage, when high, would allow current to flow through the half-bridges. When low, no current would flow. This made it so that current would not flow at all times, just when the solenoids were switching position.

Picture of circuit for 4 solenoids goes.

==Code==
The code for the display setup consists of a GUI on the PC allowing the user to select which solenoids to turn on and off and code on the PIC to control the solenoids.

===Processing===
[[Image:Kpmw_userinterface.png|thumb|180px|Screenshot of User Interface. Green circles represent solenoids that are up while blue circles represent solenoids that are down.|right]]
The PC side of the user interface was created with [http://processing.org/ Processing], an open source programming environment with many options for interesting visual display. This code creates a display of circles arranged in the same way as the solenoids in our hardware, which will change from blue to green when clicked and output a character via RS232 to the PIC.
 

//Katy Powers
//3/11/2010
//ME 333 Ferrofluid Art GUI
//Lots of code taken from processing website and previous ME 333 labs..thanks!

// add the serial library
import processing.serial.*;
Serial[] myPorts = new Serial[1];

//setup parameters for hexagonal array
//cx,cy define center position, rc is circle radius, sp is how far apart they are
int cx = 250;
int cy = 250;
int rc = 50;
int sp = 10;

//circleX and circleY store center locations of every circle in array
//solenoidON stores state of solenoid
//chararr stores characters corresponding to each solenoid
int[] circleX = {cx, cx + rc + sp,cx + 2*(rc + sp),cx - (rc + sp),cx - 2*(rc + sp),cx + rc/2 + sp/2,
cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,cx+rc+sp, cx - (rc+sp),
cx + rc/2 + sp/2, cx + 3*rc/2 + 3*sp/2,cx - (rc/2 + sp/2),cx - (3*rc/2 + 3*sp/2),cx,
cx + rc + sp,cx-(rc + sp)};

int[] circleY = {cy,cy,cy,cy,cy,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + rc +sp,cy + 2*(rc+sp),
cy + 2*(rc+sp), cy + 2*(rc+sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),cy - (rc +sp),
cy - 2*(rc+sp),cy - 2*(rc+sp),cy - 2*(rc+sp)};

int[] solenoidON = new int[19];
char[] chararr = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'};
PFont font;
PFont smallfont;

void setup()
{
InitSerial();
background(0);
font = loadFont("FangSong-48.vlw");
smallfont = loadFont("FangSong-16.vlw");
size(500,500);
textAlign(CENTER);
for (int i = 0; i < 19; i = i+1){ //zero array of solenoid values, mouse state data
solenoidON[i] = 0;
}
rectMode(CENTER);
}

void draw()
{
fill(0,0,255);
textFont(font, 48);
text("Ferrofluid Art", cx, cy-200);
textFont(smallfont, 16);
text("Click a circle to make patterns in the Ferrofluid", cx, cy + 200);
hexagon(cx,cy,rc,sp, solenoidON);

}

void hexagon(int cx, int cy, int rc, int sp, int[] sols) //draws hexagon of cirlces
{
for (int i = 0; i < 19; i = i+1){
if(sols[i] == 0) {fill(0,0,255);}
else {fill(0,255,0);}
ellipse(circleX[i], circleY[i], rc, rc);
}

}

void mousePressed() //executes when mouse is pressed, much like an interrupt routine
{
float disX, disY;
for (int i = 0; i < 19; i = i+1){ //see where mouse is
disX = circleX[i] - mouseX;
disY = circleY[i] - mouseY;
if(sqrt(sq(disX) + sq(disY)) < rc/2 ) { //if mouse is in circle, toggle state and send character
solenoidON[i] = 1 - solenoidON[i];
myPorts[0].write(chararr[i]);
println(chararr[i]); //to debug
}
}
}

===PIC===
The PIC side of the code runs an infinite while loop, executing an interrupt routine every time a character is received from the RS232. The
PIC then updates the state of all the solenoids.

/**Ferrofluid Art Project Code**********************************/
/* Katy Powers Winter 2010 */

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include "LCD.h" //needed for Delayms

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define ENABLE1 LATDbits.LATD1 //Enable pins for H bridge circuit
#define ENABLE2 LATDbits.LATD2
#define OUT1 LATBbits.LATB11 //Output pins for solenoid control
#define OUT2 LATBbits.LATB10
#define OUT3 LATBbits.LATB9
#define OUT4 LATBbits.LATB8
#define OUT5 LATAbits.LATA10
#define OUT6 LATAbits.LATA9
#define OUT7 LATBbits.LATB7
#define OUT8 LATBbits.LATB6
#define OUT9 LATBbits.LATB0
#define OUT10 LATBbits.LATB1
#define OUT11 LATBbits.LATB2
#define OUT12 LATBbits.LATB3
#define OUT13 LATBbits.LATB5
#define OUT14 LATEbits.LATE9
#define OUT15 LATEbits.LATE8
#define OUT16 LATGbits.LATG9
#define OUT17 LATGbits.LATG8
#define OUT18 LATGbits.LATG7
#define OUT19 LATGbits.LATG6

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void setSols(void); //sets solenoids on and off depending on global variable sols

/** Global Variables *******************************************/

int sols[19]; //vector to store if solenoids are on or off

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;
// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);
AD1PCFG = 0xFFFF; //this line sets up the B bits as digital outputs

TRISAbits.TRISA10 = 0; //set all solenoid and enable output pins to output
TRISAbits.TRISA9 = 0;
TRISBbits.TRISB11 = 0;
TRISBbits.TRISB10 = 0;
TRISBbits.TRISB9 = 0;
TRISBbits.TRISB8 = 0;
TRISBbits.TRISB7 = 0;
TRISBbits.TRISB6 = 0;
TRISBbits.TRISB5 = 0;
TRISBbits.TRISB3 = 0;
TRISBbits.TRISB2 = 0;
TRISBbits.TRISB1 = 0;
TRISEbits.TRISE9 = 0;
TRISEbits.TRISE8 = 0;
TRISGbits.TRISG8 = 0;
TRISGbits.TRISG7 = 0;
TRISGbits.TRISG6 = 0;
TRISBbits.TRISB0 = 0;
TRISGbits.TRISG9 = 0;
TRISDbits.TRISD1 = 0;
TRISDbits.TRISD2 = 0;

OUT1 = 0; //initialize outputs to low
OUT2 = 0;
OUT3 = 0;
OUT4 = 0;
OUT5 = 0;
OUT6 = 0;
OUT7 = 0;
OUT8 = 0;
OUT9 = 0;
OUT10 = 0;
OUT11 = 0;
OUT12 = 0;
OUT13 = 0;
OUT14 = 0;
OUT15 = 0;
OUT16 = 0;
OUT17 = 0;
OUT18 = 0;
OUT19 = 0;

//also initialize sols array to 0
for(i = 0; i < 19; i++){
sols[i] = 0;
}
setSols(); //this is probably redundant

mInitAllLEDs();

initUART2(pbClk);
INTEnableSystemMultiVectoredInt();

while(1)
{
1;//just keep going and wait for interrupts from RS232
} //end main

}
/** Interrupt Handlers *****************************************/

void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
int i;
unsigned char data2; //store character received from PC
char chararr[19] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s'}; //array of characters for comparison
// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data2 = ReadUART2(); //get character

// Toggle LED to indicate UART activity
mLED_1_Toggle();

for(i = 0; i<19; i++){
if (data2 ==(int) chararr[i]){ sols[i] = 1 - sols[i];} //toggle solenoid corresponding to character received
}
setSols(); //update all solenoids

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void setSols(){
OUT1 = sols[0]; //set all outputs to correct value
OUT2 = sols[1];
OUT3 = sols[2];
OUT4 = sols[3];
OUT5 = sols[4];
OUT6 = sols[5];
OUT7 = sols[6];
OUT8 = sols[7];
OUT9 = sols[8];
OUT10 = sols[9];
OUT11 = sols[10];
OUT12 = sols[11];
OUT13 = sols[12];
OUT14 = sols[13];
OUT15 = sols[14];
OUT16 = sols[15];
OUT17 = sols[16];
OUT18 = sols[17];
OUT19 = sols[18];
ENABLE1 = 1; //turn on enable pins
ENABLE2 = 1;
Delayms(500); //wait for half a second for solenoids to change position
ENABLE1 = 0; //turn off enable pins
ENABLE2 = 0;
}

== Results ==
Max

== Reflections ==
Todd

Ferrofluid Art Display

2010-03-15T05:24:05Z

MaxWiller: /* Electrical Design */

Ferrofluid Art Display

2010-03-15T05:23:49Z

MaxWiller: /* Electrical Design */

Ferrofluid Art Display

2010-03-15T05:12:41Z

MaxWiller: /* Electrical Design */

File:ELECTRONICS.jpg

2010-03-15T05:05:14Z

MaxWiller: Picture of our final electronics setup.

Picture of our final electronics setup.

Ferrofluid Art Display

2010-03-15T05:04:18Z

MaxWiller: /* Electrical Design */

File:ELECTRONICS.JPG

2010-03-15T05:03:14Z

MaxWiller: Picture of final electronics setup.

Picture of final electronics setup.

Ferrofluid Art Display

2010-03-15T04:54:59Z

MaxWiller: /* Team Members */

PIC32MX: Benchmarking Mathematical Operations

2010-02-16T18:40:31Z

MaxWiller:

== Original Assignment ==

'''Do not erase this section!'''

Your assignment is to empirically test how long it takes to perform add, subtract, multiply, divide, sqrt, sin, and cos operations with the 80 MHz PIC32460F512L and our standard code optimization setting. You will do these tests with chars (8-bit integers), shorts (16-bit), integers (32-bit), long long integers (64-bit), floats (32-bit single precision floating point), and double (64-bit double-precision floating point). The integers can be unsigned or signed. Your end result will be a table with the operation on one axis (likely the horizontal axis) and the kind of variable on the other axis, and each cell of the table will have a normalized duration for the operation. The time will be normalized by the fastest operation, so the smallest number in the table will be 1.00. All other numbers will indicate how many times longer that operation takes. All numbers will have two decimal places, e.g., 2.57 or 24.72. You will also give the time that 1.00 corresponds to in nanoseconds.

Since bit-shifting left and right correspond to a version of multiplying and dividing, you should also include the operations >>1 and >>4 and <<1 and <<4. (If the results are identical, you can eliminate shift left from your table.)

To generate this table, you can set an output bit low before the operation, then high immediately after the operation, and measure the time on an oscilloscope. Two things to consider: (1) Time a single operation, over and over, with a short delay between the operation. This should create a pulse train on your oscilloscope. Can you get an accurate estimate of the time this way? You could also try doing five or ten operations between changing the digital output. See if this gives the same estimate. (This estimate might be more accurate as you are essentially averaging over a number of operations.) Avoid using arrays and for loops in your test, as indexing arrays and running the loop each take time. (2) Make sure the compiler doesn't compute the results in advance. You could try testing operations with numbers generated randomly (don't time this operation!) vs. numbers that you just type in manually to make sure that both are giving you the same result.

== Overview ==

We were tasked with determining the real-time cost (measured in nanoseconds) of performing seven basic mathematical operations with each one of the six commonly used ANSI C data types.

The mathematical operations we tested were:
* subtraction
* addition
* multiplication
* division
* square root
* sine
* cosine

The six data types we tested each operation on were:
* char
* short
* integer
* long long
* float
* double

Our testing procedure was simple: throw an output pin high on the NU32 development board, perform a mathematical operation with a given data type, and then pull the same pin low.

Placing the above three steps in an infinite while loop afforded us the opportunity to use an oscilloscope to measure the duration between each high-low pair in the output waveform. After subtracting the time it took for the PIC to raise and lower the voltage on the output pin (something we previously measured), we were able to determine the amount of time required for the PIC32 chip to execute an operation with a high level of accuracy.

With seven operations to perform on six different data types, we created the following table to help us assign and keep track of the various tests we planned to run:

{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! char (8-bit) !! short (16-bit) !! int (32-bit) !! long long (64-bit) !! float (32-bit) !! double (64-bit)
|-
! subtraction
| Test 2 || Test 9 || Test 16 || Test 23 || Test 30 || Test 37
|-
! addition
| Test 3 || Test 10 || Test 17 || Test 24 || Test 31 || Test 38
|-
! multiplication
| Test 4 || Test 11 || Test 18 || Test 25 || Test 32 || Test 39
|-
! division
| Test 5 || Test 12 || Test 19 || Test 26 || Test 33 || Test 40
|-
! square root
| Test 6 || Test 13 || Test 20 || Test 27 || Test 34 || Test 41
|-
! sine
| Test 7 || Test 14 || Test 21 || Test 28 || Test 35 || Test 42
|-
! cosine
| Test 8 || Test 15 || Test 22 || Test 29 || Test 36 || Test 43
|}

Several tests contained multiple procedures that explored various ways to carry out a given mathematical operation on a given data type. For example, in the multiplication tests, not only did we test the traditional multiplication operator (*), but also the bitwise left shift operator (<<). Our goal was to find out if one particular operator was faster than the other. Similarly, we also included procedures that performed the above operations on hard-coded numbers (such as 347) as well as randomly chosen numbers stored in variables (such as 'random_int1'). We wanted to ensure that the compiler didn't compute the results of each operation in advance. While pre-compiling can indeed afford welcome increases in execution time, situations in which the compiler can't optimize the operations ahead of time (for example, situations where the data to be operated on is not known in advance) are still common occurrences and are worth benchmarking.

Accordingly, several tests contain multiple procedures that not only account for multiple methods of performing a particular operation, but multiple sets of numbers to perform those operations on.

Test 1 was used to determine the duration required for the PIC32 to throw a pin high and pull a pin low, while Tests 2 through 43 were used to measure the actual performance of each operation and data-type pair.

==Circuit==

The circuit used for testing consisted of connecting the oscilloscope to the output pin (in this case, pin A2) in order to view the waveform.

[[Image:Kp_mw_tp_benchmarkingcircuit2010.jpg]]

== Results ==
Below is the quick summary of the testing results comparing each data type and each operation. All results are normalized to 60ns (1.00 = 60ns).
{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! Subtraction !! Addition !! Multiplication !! Division !! Square Root !! Sine !! Cosine !!
|-
! Char
| 1.87 || 1.65 || 2.28 || N/A || 34.78 || 116.03 || 98.93
|-
! Short
| 1.03 || 1.67 || 1.47 || 5.00 || 144.57 || 230.40 || 215.40
|-
! Int
| 1.07 || 1.00 || 1.43 || 8.10 || 145.62 || 316.43 || 330.62
|-
! Long Long
| 2.50 || 3.33 || 6.63 || 28.73 || 271.85 || 498.30 || 510.38
|-
! Float
| 15.00 || 17.07 || 12.27 || 27.90 || 143.93 || 326.03 || 338.28
|-
! Double
| 26.00 || 20.60 || 23.97 || 53.07 || 133.30 || 343.73 || 333.52

|}

Here is the Excel file with the full results, in nanoseconds and normalized. [[Media:Lab5.xls]]

Below are the results of each particular test we performed, coupled with a short explanation for each result.

=== Basic Timing Constants (Test 1) ===
{{multiple image
| width = 100
| footer = Actual waveforms as seen on the output pin.

| image1 = Test01-high-duration.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Test (a): Time required to throw an output pin high

| image2 = Test01-low-duration.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Test (b): Time required to pull an output pin low

| image3 = Test01-full-while-loop.png
| alt3 = Test (c): Time required to execute 1 empty while loop cycle
| caption3 = Test (c): Time required to execute 1 empty while loop cycle
}}

This test determines the length of time required by the PIC32 chip to push a given output pin high and pull the same pin low.
* Test (a): Time required to throw an output pin high
** Instruction: <code>PIN_A2 = 1;</code>
** Time: 63 ns
* Test (b): Time required to pull an output pin low
** Instruction: <code>PIN_A2 = 0;</code>
** Time: 63 ns
* Test (c): Time required to execute 1 empty while loop cycle
** Instruction: <code>while(1){}</code>
** Time: 23 ns

=== char Performance ===
----
A <code>char</code> data type, in ANSI C, is a value holding one byte, or one character code. The actual number of bits in a char in a particular implementation is documented as CHAR_BIT in that implementation's <code>limits.h</code> file. In practice, it is almost always 8 bits, corresponding to a decimal range of 0 to 255 inclusive. Unless otherwise noted, all (a) benchmarks are operations on two predefined (and mot likely pre-computed) ASCII letters, all (b) benchmarks are operations on two predefined (and most likely pre-computed) numbers in the range of 0 to 255, and all (c) benchmarks are operations on two random (and most likely '''not''' pre-computed) numbers. These multiple benchmarks per test exist to illustrate the differences in execution time between pre-compiled operations and operations the PIC must perform in real time.

==== Subtraction (Test 2) ====
{{multiple image
| width = 100
| footer = Actual waveforms as seen on the output pin.

| image1 = Test02-parta.png
| alt1 = Test (a): Time required to subtract two constant chars
| caption1 = Test (a): Time required to subtract two constant chars

| image2 = Test02-partb.png
| alt2 = Test (b): Time required to subtract two ints cast into a char
| caption2 = Test (b): Time required to subtract two ints cast into a char

| image3 = Test02-partc.png
| alt3 = Test (c): Time required to subtract two random chars
| caption3 = Test (c): Time required to subtract two random chars
}}
This test determines the length of time required by the PIC32 chip to subtract one 8-bit number (a char) from another 8-bit number (a char).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 50 ns
* Test (b): Time required to subtract two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 100-2;</code>
** Time: 50 ns
* Test (c): Time required to subtract two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 3) ====
{{multiple image
| width = 100
| footer = Actual waveforms as seen on the output pin.

| image1 = Test03-parta.png
| alt1 = Test (a): Time required to add two constant chars
| caption1 = Test (a): Time required to add two constant chars

| image2 = Test03-partb.png
| alt2 = Test (b): Time required to add two ints cast into a char
| caption2 = Test (b): Time required to add two ints cast into a char

| image3 = Test03-partc.png
| alt3 = Test (c): Time required to add two random chars
| caption3 = Test (c): Time required to add two random chars
}}
This test determines the length of time required by the PIC32 chip to add one 8-bit number (a char) to another 8-bit number (a char).
* Test (a): Time required to add two constant chars (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 50 ns
* Test (b): Time required to add two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 97+1;</code>
** Time: 50 ns
* Test (c): Time required to add two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 99 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 4) ====
{{multiple image
| width = 100
| footer = Actual waveforms as seen on the output pin.

| image1 = Test04-parta.jpg
| alt1 = Test (a): Time required to multiply two constant chars
| caption1 = Test (a): Time required to multiply two constant chars

| image2 = Test04-partb.jpg
| alt2 = Test (b): Time required to multiply two ints cast into a char
| caption2 = Test (b): Time required to multiply two ints cast into a char

| image3 = Test04-partc.jpg
| alt3 = Test (c): Time required to multiply of two random chars
| caption3 = Test (c): Time required to multiply of two random chars
}}
This test determines the length of time required by the PIC32 chip to multiply one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to multiply two constant chars (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 49 ns
* Test (b): Time required to multiply two ints cast into a char (may be pre-computed)
** Instruction: <code>ascii_200 = 100*2;</code>
** Time: 48 ns
* Test (c): Time required to multiply of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 137 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 5) ====
{{multiple image
| width = 100
| footer = Actual waveforms as seen on the output pin.

| image1 = Test05-parta.jpg
| alt1 = Test (a): Time required to divide two constant chars
| caption1 = Test (a): Time required to divide two constant chars

| image2 = Test05-parta.jpg
| alt2 = Test (b): Time required to divide two ints cast into a char
| caption2 = Test (b): Time required to divide two ints cast into a char
}}
This test determines the length of time required by the PIC32 chip to divide one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to divide two constant chars (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 48 ns
* Test (b): Time required to divide two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = 100/2;</code>
** Time: 50 ns
* Test (c): Time required to divide two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: N/A

<nowiki>*</nowiki> We had great difficulty in trying to test this particular operation. After some research with an oscilloscope and voltmeter, it seems that the PIC32 is not capable of dividing chars in this way. More specifically, every time the PIC32 attempts to divide one char by another, all output pins are immediately grounded. We've tested this code in other C environments, and it works as expected, so the error must either lie somewhere within our specific PICs (which would be very unlikely - we tested 3) or the silicon architecture of the PIC32 itself (sill unlikely, but given the number of PICs we tested, more probable). If you absolutely need to divide chars, cast them to ints first, perform your division, then cast them back to chars.

==== Square Root (Test 6) ====
{{multiple image
| width = 100
| footer = Actual waveforms as seen on the output pin.

| image1 = Test06-parta.jpg
| alt1 = Test (a): Time required to sqrt() a constant char
| caption1 = Test (a): Time required to sqrt() a constant char

| image2 = Test06-partb.jpg
| alt2 = Test (b): Time required to sqrt() an int cast into a char
| caption2 = Test (b): Time required to sqrt() an int cast into a char

| image3 = Test06-partc.jpg
| alt3 = Test (c): Time required to sqrt() a random char
| caption3 = Test (c): Time required to sqrt() a random char
}}
{{multiple image
| width = 100
| footer = Actual waveforms as seen on the output pin.

| image1 = Test06-partd.jpg
| alt1 = Test (d): Time required to ^(1/2) a constant char
| caption1 = Test (d): Time required to ^(1/2) a constant char

| image2 = Test06-parte.jpg
| alt2 = Test (e): Time required to ^(1/2) an int cast into a char
| caption2 = Test (e): Time required to ^(1/2) an int cast into a char

| image3 = Test06-partf.jpg
| alt3 = Test (f): Time required to ^(1/2) a random char
| caption3 = Test (f): Time required to ^(1/2) a random char
}}

This test determines the length of time required by the PIC32 chip to square root one 8-bit number (a char). Benchmarks (a) through (c) use the <code>sqrt()</code> function while benchmarks (d) through (f) raise the operands to the 1/2 power.
* Test (a): Time required to sqrt() a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sqrt('u');</code>
** Time: 48 ns
* Test (b): Time required to sqrt() an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = sqrt(100);</code>
** Time: 48 ns
* Test (c): Time required to sqrt() a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sqrt(random_char1);</code>
** Time: 2087 ns
* Test (d): Time required to ^(1/2) a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = ('u')^(1/2);</code>
** Time: 48 ns
* Test (e): Time required to ^(1/2) an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = (100)^(1/2);</code>
** Time: 48 ns
* Test (f): Time required to ^(1/2) a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = (random_char2)^(1/2);</code>*
** Time: 75 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Sine (Test 7) ====
{{multiple image
| width = 100
| footer = Actual waveforms as seen on the output pin.

| image1 = Test07-parta.jpg
| alt1 = Test (a): Time required to take the sine of a constant char
| caption1 = Test (a): Time required to take the sine of a constant char

| image2 = Test07-partb.jpg
| alt2 = Test (b): Time required to take the sine of a constant int cast into a char
| caption2 = Test (b): Time required to take the sine of a constant int cast into a char

| image3 = Test07-partc.jpg
| alt3 = Test (c): Time required to take the sine of a random char
| caption3 = Test (c): Time required to take the sine of a random char
}}
This test determines the length of time required by the PIC32 chip to take the sine of an 8-bit number (a char).
* Test (a): Time required to take the sine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sin('K');</code>
** Time: 9963 ns
* Test (b): Time required to take the sine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = sin(50);</code>
** Time: 9550 ns
* Test (c): Time required to take the sine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sin(larger);</code>*
** Time: 6962 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Cosine (Test 8) ====
{{multiple image
| width = 100
| footer = Actual waveforms as seen on the output pin.

| image1 = Test08-parta.jpg
| alt1 = Test (a): Time required to take the cosine of a constant char
| caption1 = Test (a): Time required to take the cosine of a constant char

| image2 = Test08-partb.jpg
| alt2 = Test (b): Time required to take the cosine of a constant int cast into a char
| caption2 = Test (b): Time required to take the cosine of a constant int cast into a char

| image3 = Test08-partc.jpg
| alt3 = Test (c): Time required to take the cosine of a random char
| caption3 = Test (c): Time required to take the cosine of a random char
}}
This test determines the length of time required by the PIC32 chip to take the cosine of an 8-bit number (a char).
* Test (a): Time required to take the cosine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = cos('K');</code>
** Time: 9111 ns
* Test (b): Time required to take the cosine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = cos(50);</code>
** Time: 8724 ns
* Test (c): Time required to take the cosine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = cos(larger);</code>*
** Time: 5936 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

=== short Performance ===
----
A short data type, in ANSI C, is a value that holds 2 bytes, or 16 bits. This corresponds to a range of 0 to 65535 (2^16 - 1). If the variable is signed (negative), then the range is from -32767 to 32767 (-2^15 + 1 to 2^15 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 9) ====
{{multiple image
| width = 100
| footer = Actual waveforms as seen on the output pin.

| image1 = test09-parta.png
| alt1 = Test (a): Time required to subtract two constant shorts
| caption1 = Test (a): Time required to subtract two constant shorts

| image2 = test09-partb.png
| alt2 = Test (b): Time required to subtract two random shorts
| caption2 = Test (b): Time required to subtract two random shorts
}}
This test determines the length of time required by the PIC32 chip to subtract one 16-bit number (a short) from another 16-bit number (a short).
*Test (a): Time required to subtract two constant shorts (may be pre-computed)
** Instruction:
** Time: 25 ns
*Test (b): Time required to subtract two random shorts (guaranteed not to be pre-comp)
** Instruction:
** Time: 62 ns

==== Addition (Test 10) ====
{{multiple image
| width = 100
| footer = Actual waveforms as seen on the output pin.

| image1 = Test10-parta.png
| alt1 = Test (a): Time required to add two constant shorts
| caption1 = Test (a): Time required to add two constant shorts

| image2 = Test10-partb.png
| alt2 = Test (b): Time required to add two random shorts
| caption2 = Test (b): Time required to add two random shorts
}}
This test determines the length of time required by the PIC32 chip to add one 16-bit number (a short) to another 16-bit number (a short).
*Test (a): Time required to add two constant shorts (may be pre-computed)
**Instruction:
**Time: 50ns
*Test (b): Time required to add two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 100ns

==== Multiplication (Test 11) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to multiply two constant shorts (may be pre-computed)
**Instruction:
**Time: 24ns
*Test b: Time required to multiply two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 88ns

==== Division (Test 12) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to divide two constant shorts (may be pre-computed)
**Instruction:
**Time: 28ns
*Test b: Time required to divide two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 300ns

==== Square Root (Test 13) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 16-bit number (a short). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant short (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to sqrt() a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 8674ns
*Test c: Time required to ^(1/2) a constant short (may be pre-computed)
**Instruction:
**Time: 50ns
*Test d: Time required to ^(1/2) a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 76ns

==== Sine (Test 14) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 16-bit number (a short).
*Test a: Time required to take the sine of a constant short (may be pre-computed)
**Instruction:
**Time: 13014ns
*Test b: Time required to take the sine of a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 13824ns

==== Cosine (Test 15) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 16-bit number (a short).
*Test a: Time required to take the cosine of a constant short (may be pre-computed)
**Instruction:
**Time: 12174ns
*Test b: Time required to take the cosine of a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 12924ns

===int Performance===
----
An int data type, in ANSI C, is a value that holds 4 bytes, or 32 bits. This corresponds to a range of 0 to 4294967295 (2^32 - 1). If the variable is signed (negative), then the range is from -2147483647 to 2147483647 (-2^31 + 1 to 2^31 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 16) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (an int) from another 32-bit number (an int).
*Test a: Time required to subtract two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to subtract two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 64ns

==== Addition (Test 17) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (an int) to another 32-bit number (an int).
*Test a: Time required to add two constant ints (may be pre-computed)
**Instruction:
**Time: 26ns
*Test b: Time required to add two random ints (guaranteed not to be pre-comp)
**Instructions:
**Time: 60ns

==== Multiplication (Test 18) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (an int) by another 32-bit number (an int).
*Test a: Time required to multiply two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to multiply two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 86ns

==== Division (Test 19) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (an int) by another 32-bit number (an int).
*Test a: Time required to divide two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to divide two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 486s

==== Square Root (Test 20) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (an int). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant int (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to sqrt() a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 8737ns
*Test c: Time required to ^(1/2) a constant int (may be pre-computed)
**Instruction:
**Time: 88ns
*Test d: Time required to ^(1/2) a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 74ns

==== Sine (Test 21) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (an int).
*Test a: Time required to take the sine of a constant int (may be pre-computed)
**Instruction:
**Time: 19488ns
*Test b: Time required to take the sine of a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 18988ns

==== Cosine (Test 22) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (an int).
*Test a: Time required to take the cosine of a constant int (may be pre-computed)
**Instruction:
**Time: 20324ns
*Test b: Time required to take the cosine of a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 19837ns

===long long Performance===
----
A long long data type, in ANSI C, is a value that holds 8 bytes, or 64 bits. This corresponds to a range of 0 to 1.84467441 × 10^19 (2^64 - 1). If the variable is signed (negative), then the range is from -9.22337204 × 10^18 to 9.22337204 × 10^18 (-2^63 + 1 to 2^63 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 23) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a long long) from another 64-bit number (a long long).
*Test a: Time required to subtract two constant long longs (may be pre-computed)
**Instruction:
**Time: 186ns
*Test b: Time required to subtract two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 150ns

==== Addition (Test 24) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 64-bit number (a long long) to another 64-bit number (a long long).
*Test a: Time required to add two constant long longs (may be pre-computed)
**Instruction:
**Time: 88ns
*Test b: Time required to add two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 200ns

==== Multiplication (Test 25) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: Time required to multiply two constant long longs (may be pre-computed)
**Instruction:
**Time: 74ns
*Test b: Time required to multiply two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 398ns

==== Division (Test 26) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: Time required to divide two constant long longs (may be pre-computed)
**Instruction:
**Time: 74ns
*Test b: Time required to divide two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 1724ns

==== Square Root (Test 27) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a long long). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant long long (may be pre-computed)
**Instruction:
**Time: 87ns
*Test b: Time required to sqrt() a random long long (guaranteed not to be pre-comp)
**Instruction:
**Time: 16311ns
*Test c: Time required to ^(1/2) a constant long long (may be pre-computed)
**Instruction:
**Time: 188ns
*Test d: Time required to ^(1/2) a random long long (guaranteed not to be pre-comp)
**Instruction:
**Time: 74ns

==== Sine (Test 28) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a long long).
*Test a: Time required to sqrt() a constant long long (may be pre-computed)
**Instruction:
**Time: 23837 ns
*Test b: Time required to sqrt() a random long long (guaranteed not to be pre-comp)
**Instruction:
**Time: 29898 ns

==== Cosine (Test 29) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a long long).
*Test a: Time required to take the sine of a constant long long (may be pre-computed)
**Instruction:
**Time: 24611ns
*Test b: Time required to take the sine of a random long long (guaranteed not to be pre-comp)
**Instruction:
**Time: 30623ns

===float Performance===
----
A float data type, in ANSI C, is a single-precision value represented by 4 bytes, consisting of a sign bit, an 8-bit excess-127 binary exponent, and a 23-bit mantissa. This roughly corresponds to a range of approximately 3.4E–38 to 3.4E+38 for unsigned floats. Signed floats are more complex to understand, but are covered in depth here: http://msdn.microsoft.com/en-us/library/hd7199ke%28VS.80%29.aspx. In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.
==== Subtraction (Test 30) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (a float) from another 32-bit number (a float).
*Test a: Time required to subtract two constant floats (may be pre-computed)
**Instruction:
**Time: 100ns
*Test b: Time required to subtract two random floats (guaranteed not to be pre-comp)
**Instruction:
**Time: 900ns

==== Addition (Test 31) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (a float) to another 32-bit number (a float).
*Test a: Time required to add two constant floats (may be pre-computed)
**Instruction:
**Time: 124ns
*Test b: Time required to add two random floats (guaranteed not to be pre-comp)
**Instruction:
**Time: 1024ns

==== Multiplication (Test 32) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (a float) by another 32-bit number (a float).
*Test a: Time required to multiply two constant floats (may be pre-computed)
**Instruction:
**Time: 124ns
*Test b: Time required to multiply two random floats (guaranteed not to be pre-comp)
**Instruction:
**Time: 736ns

==== Division (Test 33) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (a float) by another 32-bit number (a float).
*Test a: Time required to divide two constant floats (may be pre-computed)
**Instruction:
**Time: 99ns
*Test b: Time required to divide two random floats (guaranteed not to be pre-comp)
**Instruction:
**Time: 1674ns

==== Square Root (Test 34) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (a float). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant float (may be pre-computed)
**Instruction:
**Time: 99ns
*Test b: Time required to sqrt() a random float (guaranteed not to be pre-comp)
**Instruction:
**Time: 8636ns
*Test c: Time required to ^(1/2) a constant float (may be pre-computed)
**Instruction:
**Time: N/A
*Test d: Time required to ^(1/2) a random float (guaranteed not to be pre-comp)
**Instruction:
**Time: N/A

==== Sine (Test 35) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (a float).
*Test a: Time required to take the sine of a constant float (may be pre-computed)
**Instruction:
**Time: 19574ns
*Test b: Time required to take the sine of a random float (guaranteed not to be pre-comp)
**Instruction:
**Time: 19562ns

==== Cosine (Test 36) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (a float).
*Test a: Time required to take the cosine of a constant float (may be pre-computed)
**Instruction:
**Time: 20311ns
*Test b: Time required to take the cosine of a random float (guaranteed not to be pre-comp)
**Instruction:
**Time: 20297ns

===double Performance===
A double data type, in ANSI C, is a double-precision value represented by 8 bytes, consisting of a sign bit, an 8-bit excess-1023 binary exponent, and a 52-bit mantissa. This roughly corresponds to a range of approximately 2.22E–308 1.79E+308 for unsigned doubles. Signed doubles are more complex to understand, but are covered in depth here: http://msdn.microsoft.com/en-us/library/hd7199ke%28VS.80%29.aspx. In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.
----
==== Subtraction (Test 37) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a double) from another 8-bit number (a double).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 199 ns
* Test (b): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 38) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to add one 64-bit number (a double) to another 64-bit number (a double).
* Test (a): Time required to add two constant doubles (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 199 ns
* Test (c): Time required to add of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 1236 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 39) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a double) by another 64-bit number (a double).
* Test (a): Time required to multiply two constant doubles (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 188 ns
* Test (b): Time required to multiply of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 1438 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 40) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a double) by another 64-bit number (a double).
* Test (a): Time required to divide two constant doubles (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 187 ns
* Test (b): Time required to divide of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: 3184 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Square Root (Test 41) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (c): Time required to pull an output pin low
| caption3 = Caption3

| image4 = test1-whileloop-onoff-timetogohigh.png
| alt4 = Test (d): Time required to throw an output pin high
| caption4 = Caption4

| image5 = test1-whileloop-onoff-timetogolow.png
| alt5 = Test (e): Time required to pull an output pin low
| caption5 = Caption5

| image6 = test1-whileloop-onoff-pair.png
| alt6 = Test (f): Time required to pull an output pin low
| caption6 = Caption6
}}
This test determines the length of time required by the PIC32 chip to square root a 64-bit number (a double). Benchmarks (a) through (c) use the <code>sqrt()</code> function while benchmarks (d) through (f) raise the operands to the 1/2 power.
* Test (a): Time required to sqrt() a constant double (may be pre-computed)
** Instruction: <code>ascii_25 = sqrt('u');</code>
** Time: 188 ns
* Test (b): Time required to sqrt() an int cast into a double (may be pre-computed)
** Instruction: <code>number_10 = sqrt(100);</code>
** Time: 7998 ns
* Test (c): Time required to sqrt() a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sqrt(random_char1);</code>
** Time: N/A ns *
* Test (d): Time required to ^(1/2) a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = ('u')^(1/2);</code>
** Time: N/A ns *

<nowiki>*</nowiki> We had some difficulty in trying to test these particular operations. It seems that the PIC32 is not capable of raising doubles to the 1/2 power.

==== Sine (Test 42) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the sine of an 64-bit number (a double).
* Test (a): Time required to take the sine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sin('K');</code>
** Time: 20299 ns
* Test (b): Time required to take the sine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sin(larger);</code>*
** Time: 20624 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Cosine (Test 43) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a double).
* Test (a): Time required to take the cosine of a constant double (may be pre-computed)
** Instruction: <code>ascii_25 = cos('K');</code>
** Time: 19762 ns
* Test (c): Time required to take the cosine of a random double (guaranteed not to be pre-comp)
** Instruction: <code>random_char = cos(larger);</code>*
** Time: 20011 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

== Code ==

There is a c file for each test that was performed. They are included in a .zip at the bottom of this section. and can be downloaded for further review. Below is an example of the code, in this case, for testing multiplication of two chars.
/*******************************************************************************
* PIC32 Benchmarking Test Suite
*
* Test 4 - char Multiplication Duration
* Version 1.0
* Copyright (C) 2010 Todd H. Poole, Katy Powers, Max Willer
*
* This test determines the length of time required by the PIC32 chip to multiply
* one 8-bit number (a char) by another 8-bit number (a char).
*
* A char data type, in ANSI C, is a value holding one byte, or one character
* code. The actual number of bits in a char in a particular implementation is
* documented as CHAR_BIT in that implementation's limits.h file. In practice,
* it is almost always 8 bits, corresponding to a decimal range of 0 to 255,
* inclusive.
*
* Given that there are many different ways to multiply one char by another,
* we've done our best to include several different multiplication methods that
* we feel are representative of normal coding practices. Depending on how the
* source code is compiled, these different methods may or may not produce
* different results.
*******************************************************************************/

#include "HardwareProfile.h"
#define PIN_A2 LATAbits.LATA2 //Define the specific pin we'll use for our tests

char ascii_225;
char ascii_200;
char random_char;

float zero_to_1;
float zero_to_15;
int int_zero_to_15;
int random_int1;
int random_int2;
char random_char1;
char random_char2;
char larger;
char smaller;

int main(void)
{
SYSTEMConfigPerformance(SYS_FREQ);
TRISAbits.TRISA2 = 0; //Setting our testing pin to be an output

/*Seed the random number generator so we don't get the same 'random'
* numbers over and over again. This is just to ensure that our
* C-compiler doesn't try to pull any optimization tricks on us.
*/
srand(time(NULL));

//Finding our first random char

/*Take the output of rand() - which is a number [0,RAND_MAX] - and
* divide that output by RAND_MAX+1. We now have a number that ranges
* from [0,1). Multiply this result by 16. This will give us a random
* number in the range of [0,16). (I chose 16 because the maximum value
* a char can be is 255. Having our range run from 0 to 16 exclusive will
* ensure that our ints - and, later, our chars - will range from [0,15].
* Thus, regardless of what values our two ints/chars take, the final
* multiplication will fit in a char, which range from 0 to 255 in decimal).
* Cast this result into an int, which will truncate (cut off) the digits
* after the decimal. Thus:
* 0.00001 through 0.99999 will cast to 0.
* 255.00001 through 255.99999 will cast to 255.
* Then, cast our int from an int into a char.
* PS: Yes, I know this doesn't give us a uniform probability distribution, but
* we're not too concerned with true randomness... just enough to ensure nothing
* is computed ahead of time by the C-compiler.
*/

zero_to_1 = rand() / RAND_MAX+1; //float that ranges from [0,1)
zero_to_15 = zero_to_1 * 16; //float that ranges from [0,16)
int_zero_to_15 = zero_to_15; //int that ranges from [0,15]
random_int1 = int_zero_to_15; //our first random int
random_char1 = int_zero_to_15; //our first random char

//Finding our second random char

zero_to_1 = rand() / RAND_MAX+1; //float that ranges from [0,1)
zero_to_15 = zero_to_1 * 16; //float that ranges from [0,256)
int_zero_to_15 = zero_to_15; //int that ranges from [0,255]
random_int2 = int_zero_to_15; //our second random int
random_char2 = int_zero_to_15; //out second random char

/*By forcing all of our operations to depend on the results of randomly
* generated numbers, we've guaranteed that our C-compiler won't be able to
* interfere with our benchmarks by trying to compute our results in advance.
* This ensures that all operations are performed on the fly by the PIC, and
* that it's performance will be similar to what one might encounter in other
* projects where all variables and data are not completely known in advance.
*/

//Time to start the actual benchmarking

while(1)
{
/*We start our while loop off like this so that we can create an easily
* recognizable pattern on the oscilloscope. We need to be able to
* differentiate between the various tests, and so, after seeing this unique
* pattern, we'll know that next test to follow will be the first test, the
* test after that will be the second, etc.
*/

PIN_A2 = 1;
PIN_A2 = 0;
PIN_A2 = 0;
PIN_A2 = 0;
PIN_A2 = 1;
PIN_A2 = 0;

//Test 4(a) - Multiplication of Two Constant chars (may be pre-computed)
PIN_A2 = 1;
ascii_225 = 'K'*'?';
PIN_A2 = 0;

//Test 4(b) - Multiplication of Two ints Cast into a char (may be pre-computed)
PIN_A2 = 1;
ascii_200 = 100*2;
PIN_A2 = 0;

//Test 4(c) - Mulitplication of Two Random chars (guaranteed not to be pre-comp)
PIN_A2 = 1;
random_char = larger*smaller;
PIN_A2 = 0;
PIN_A2 = 1;
}
}

[[Media:Kp_mw_tp_ME333PIC32Benchmarking.zip‎]]
[[Media:Example.ogg]]

File:Lab5.xls

2010-02-16T18:35:27Z

MaxWiller: A summary of all test results, in nanoseconds and normalized.

A summary of all test results, in nanoseconds and normalized.

PIC32MX: Benchmarking Mathematical Operations

2010-02-16T08:12:29Z

MaxWiller:

== Original Assignment ==

'''Do not erase this section!'''

Your assignment is to empirically test how long it takes to perform add, subtract, multiply, divide, sqrt, sin, and cos operations with the 80 MHz PIC32460F512L and our standard code optimization setting. You will do these tests with chars (8-bit integers), shorts (16-bit), integers (32-bit), long long integers (64-bit), floats (32-bit single precision floating point), and double (64-bit double-precision floating point). The integers can be unsigned or signed. Your end result will be a table with the operation on one axis (likely the horizontal axis) and the kind of variable on the other axis, and each cell of the table will have a normalized duration for the operation. The time will be normalized by the fastest operation, so the smallest number in the table will be 1.00. All other numbers will indicate how many times longer that operation takes. All numbers will have two decimal places, e.g., 2.57 or 24.72. You will also give the time that 1.00 corresponds to in nanoseconds.

Since bit-shifting left and right correspond to a version of multiplying and dividing, you should also include the operations >>1 and >>4 and <<1 and <<4. (If the results are identical, you can eliminate shift left from your table.)

To generate this table, you can set an output bit low before the operation, then high immediately after the operation, and measure the time on an oscilloscope. Two things to consider: (1) Time a single operation, over and over, with a short delay between the operation. This should create a pulse train on your oscilloscope. Can you get an accurate estimate of the time this way? You could also try doing five or ten operations between changing the digital output. See if this gives the same estimate. (This estimate might be more accurate as you are essentially averaging over a number of operations.) Avoid using arrays and for loops in your test, as indexing arrays and running the loop each take time. (2) Make sure the compiler doesn't compute the results in advance. You could try testing operations with numbers generated randomly (don't time this operation!) vs. numbers that you just type in manually to make sure that both are giving you the same result.

== Overview ==

We were tasked with determining the real-time cost (measured in nanoseconds) of performing seven basic mathematical operations with each one of the six commonly used ANSI C data types.

The mathematical operations we tested were:
* subtraction
* addition
* multiplication
* division
* square root
* sine
* cosine

The six data types we tested each operation on were:
* char
* short
* integer
* long long
* float
* double

Our testing procedure was simple: throw an output pin high on the NU32 development board, perform a mathematical operation with a given data type, and then pull the same pin low.

Placing the above three steps in an infinite while loop afforded us the opportunity to use an oscilloscope to measure the duration between each high-low pair in the output waveform. After subtracting the time it took for the PIC to raise and lower the voltage on the output pin (something we previously measured), we were able to determine the amount of time required for the PIC32 chip to execute an operation with a high level of accuracy.

With seven operations to perform on six different data types, we created the following table to help us assign and keep track of the various tests we planned to run:

{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! char (8-bit) !! short (16-bit) !! int (32-bit) !! long long (64-bit) !! float (32-bit) !! double (64-bit)
|-
! subtraction
| Test 2 || Test 9 || Test 16 || Test 23 || Test 30 || Test 37
|-
! addition
| Test 3 || Test 10 || Test 17 || Test 24 || Test 31 || Test 38
|-
! multiplication
| Test 4 || Test 11 || Test 18 || Test 25 || Test 32 || Test 39
|-
! division
| Test 5 || Test 12 || Test 19 || Test 26 || Test 33 || Test 40
|-
! square root
| Test 6 || Test 13 || Test 20 || Test 27 || Test 34 || Test 41
|-
! sine
| Test 7 || Test 14 || Test 21 || Test 28 || Test 35 || Test 42
|-
! cosine
| Test 8 || Test 15 || Test 22 || Test 29 || Test 36 || Test 43
|}

Several tests contained multiple procedures that explored various ways to carry out a given mathematical operation on a given data type. For example, in the multiplication tests, not only did we test the traditional multiplication operator (*), but also the bitwise left shift operator (<<). Our goal was to find out if one particular operator was faster than the other. Similarly, we also included procedures that performed the above operations on hard-coded numbers (such as 347) as well as randomly chosen numbers stored in variables (such as 'random_int1'). We wanted to ensure that the compiler didn't compute the results of each operation in advance. While pre-compiling can indeed afford welcome increases in execution time, situations in which the compiler can't optimize the operations ahead of time (for example, situations where the data to be operated on is not known in advance) are still common occurrences and are worth benchmarking.

Accordingly, several tests contain multiple procedures that not only account for multiple methods of performing a particular operation, but multiple sets of numbers to perform those operations on.

Test 1 was used to determine the duration required for the PIC32 to throw a pin high and pull a pin low, while Tests 2 through 43 were used to measure the actual performance of each operation and data-type pair.

== Results ==
Below is the quick summary of the testing results comparing each data type and each operation. All results are normalized to 60ns (1.00 = 60ns).
{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! Subtraction !! Addition !! Multiplication !! Division !! Square Root !! Sine !! Cosine !!
|-
! Char
| 1.87 || 1.65 || 2.28 || N/A || 34.78 || 116.03 || 98.93
|-
! Short
| 1.03 || 1.67 || 1.47 || 5.00 || 144.57 || 230.40 || 215.40
|-
! Int
| 1.07 || 1.00 || 1.43 || 8.10 || 145.62 || 316.43 || 330.62
|-
! Long Long
| 2.50 || 3.33 || 6.63 || 28.73 || 271.85 || 498.30 || 510.38
|-
! Float
| 15.00 || 17.07 || 12.27 || 27.90 || 143.93 || 326.03 || 338.28
|-
! Double
| 26.00 || 20.60 || 23.97 || 53.07 || 133.30 || 343.73 || 333.52

|}
Below are the results of each particular test we performed, coupled with a short explanation for each result.

=== Basic Timing Constants (Test 1) ===
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to push a given output pin high and pull the same pin low.
* Test (a): Time required to throw an output pin high
** Instruction: <code>PIN_A2 = 1;</code>
** Time: 63 ns
* Test (b): Time required to pull an output pin low
** Instruction: <code>PIN_A2 = 0;</code>
** Time: 63 ns
* Test (c): Time required to execute 1 empty while loop cycle
** Instruction: <code>while(1){}</code>
** Time: 23 ns

=== char Performance ===
----
A <code>char</code> data type, in ANSI C, is a value holding one byte, or one character code. The actual number of bits in a char in a particular implementation is documented as CHAR_BIT in that implementation's <code>limits.h</code> file. In practice, it is almost always 8 bits, corresponding to a decimal range of 0 to 255 inclusive. Unless otherwise noted, all (a) benchmarks are operations on two predefined (and mot likely pre-computed) ASCII letters, all (b) benchmarks are operations on two predefined (and most likely pre-computed) numbers in the range of 0 to 255, and all (c) benchmarks are operations on two random (and most likely '''not''' pre-computed) numbers. These multiple benchmarks per test exist to illustrate the differences in execution time between pre-compiled operations and operations the PIC must perform in real time.

==== Subtraction (Test 2) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 8-bit number (a char) from another 8-bit number (a char).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 50 ns
* Test (b): Time required to subtract two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 100-2;</code>
** Time: 50 ns
* Test (c): Time required to subtract two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 3) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 8-bit number (a char) to another 8-bit number (a char).
* Test (a): Time required to add two constant chars (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 50 ns
* Test (b): Time required to add two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 97+1;</code>
** Time: 50 ns
* Test (c): Time required to add two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 99 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 4) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to multiply two constant chars (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 49 ns
* Test (b): Time required to multiply two ints cast into a char (may be pre-computed)
** Instruction: <code>ascii_200 = 100*2;</code>
** Time: 48 ns
* Test (c): Time required to multiply of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 137 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 5) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to divide two constant chars (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 48 ns
* Test (b): Time required to divide two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = 100/2;</code>
** Time: 50 ns
* Test (c): Time required to divide two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: N/A

<nowiki>*</nowiki> We had great difficulty in trying to test this particular operation. After some research with an oscilloscope and voltmeter, it seems that the PIC32 is not capable of dividing chars in this way. More specifically, every time the PIC32 attempts to divide one char by another, all output pins are immediately grounded. We've tested this code in other C environments, and it works as expected, so the error must either lie somewhere within our specific PICs (which would be very unlikely - we tested 3) or the silicon architecture of the PIC32 itself (sill unlikely, but given the number of PICs we tested, more probable). If you absolutely need to divide chars, cast them to ints first, perform your division, then cast them back to chars.

==== Square Root (Test 6) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (c): Time required to pull an output pin low
| caption3 = Caption3

| image4 = test1-whileloop-onoff-timetogohigh.png
| alt4 = Test (d): Time required to throw an output pin high
| caption4 = Caption4

| image5 = test1-whileloop-onoff-timetogolow.png
| alt5 = Test (e): Time required to pull an output pin low
| caption5 = Caption5

| image6 = test1-whileloop-onoff-pair.png
| alt6 = Test (f): Time required to pull an output pin low
| caption6 = Caption6
}}
This test determines the length of time required by the PIC32 chip to square root one 8-bit number (a char). Benchmarks (a) through (c) use the <code>sqrt()</code> function while benchmarks (d) through (f) raise the operands to the 1/2 power.
* Test (a): Time required to sqrt() a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sqrt('u');</code>
** Time: 48 ns
* Test (b): Time required to sqrt() an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = sqrt(100);</code>
** Time: 48 ns
* Test (c): Time required to sqrt() a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sqrt(random_char1);</code>
** Time: 2087 ns
* Test (d): Time required to ^(1/2) a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = ('u')^(1/2);</code>
** Time: 48 ns
* Test (e): Time required to ^(1/2) an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = (100)^(1/2);</code>
** Time: 48 ns
* Test (f): Time required to ^(1/2) a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = (random_char2)^(1/2);</code>*
** Time: 75 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Sine (Test 7) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the sine of an 8-bit number (a char).
* Test (a): Time required to take the sine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sin('K');</code>
** Time: 9963 ns
* Test (b): Time required to take the sine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = sin(50);</code>
** Time: 9550 ns
* Test (c): Time required to take the sine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sin(larger);</code>*
** Time: 6962 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Cosine (Test 8) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the cosine of an 8-bit number (a char).
* Test (a): Time required to take the cosine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = cos('K');</code>
** Time: 9111 ns
* Test (b): Time required to take the cosine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = cos(50);</code>
** Time: 8724 ns
* Test (c): Time required to take the cosine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = cos(larger);</code>*
** Time: 5936 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

=== short Performance ===
----
A short data type, in ANSI C, is a value that holds 2 bytes, or 16 bits. This corresponds to a range of 0 to 65535 (2^16 - 1). If the variable is signed (negative), then the range is from -32767 to 32767 (-2^15 + 1 to 2^15 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 9) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 16-bit number (a short) from another 16-bit number (a short).
*Test a: Time required to subtract two constant shorts (may be pre-computed)
** Instruction:
** Time: 25ns
*Test b: Time required to subtract two random chars (guaranteed not to be pre-comp)
** Instruction:
** Time: 62ns

==== Addition (Test 10) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 16-bit number (a short) to another 16-bit number (a short).
*Test a: Time required to add two constant shorts (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to add two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 100ns

==== Multiplication (Test 11) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to multiply two constant shorts (may be pre-computed)
**Instruction:
**Time: 24ns
*Test b: Time required to multiply two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 88ns

==== Division (Test 12) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to divide two constant shorts (may be pre-computed)
**Instruction:
**Time: 28ns
*Test b: Time required to divide two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 300ns

==== Square Root (Test 13) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 16-bit number (a short). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant short (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to sqrt() a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 8674ns
*Test c: Time required to ^(1/2) a constant short (may be pre-computed)
**Instruction:
**Time: 50ns
*Test d: Time required to ^(1/2) a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 76ns

==== Sine (Test 14) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 16-bit number (a short).
*Test a: Time required to take the sine of a constant short (may be pre-computed)
**Instruction:
**Time: 13014ns
*Test b: Time required to take the sine of a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 13824ns

==== Cosine (Test 15) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 16-bit number (a short).
*Test a: Time required to take the cosine of a constant short (may be pre-computed)
**Instruction:
**Time: 12174ns
*Test b: Time required to take the cosine of a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 12924ns

===int Performance===
----
An int data type, in ANSI C, is a value that holds 4 bytes, or 32 bits. This corresponds to a range of 0 to 4294967295 (2^32 - 1). If the variable is signed (negative), then the range is from -2147483647 to 2147483647 (-2^31 + 1 to 2^31 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 16) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (an int) from another 32-bit number (an int).
*Test a: Time required to subtract two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to subtract two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 64ns

==== Addition (Test 17) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (an int) to another 32-bit number (an int).
*Test a: Time required to add two constant ints (may be pre-computed)
**Instruction:
**Time: 26ns
*Test b: Time required to add two random ints (guaranteed not to be pre-comp)
**Instructions:
**Time: 60ns

==== Multiplication (Test 18) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (an int) by another 32-bit number (an int).
*Test a: Time required to multiply two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to multiply two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 86ns

==== Division (Test 19) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (an int) by another 32-bit number (an int).
*Test a: Time required to divide two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to divide two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 486s

==== Square Root (Test 20) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (an int). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant int (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to sqrt() a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 8737ns
*Test c: Time required to ^(1/2) a constant int (may be pre-computed)
**Instruction:
**Time: 88ns
*Test d: Time required to ^(1/2) a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 74ns

==== Sine (Test 21) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (an int).
*Test a: Time required to take the sine of a constant int (may be pre-computed)
**Instruction:
**Time: 19488ns
*Test b: Time required to take the sine of a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 18988ns

==== Cosine (Test 22) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (an int).
*Test a: Time required to take the cosine of a constant int (may be pre-computed)
**Instruction:
**Time: 20324ns
*Test b: Time required to take the cosine of a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 19837ns

===long long Performance===
----
An long long data type, in ANSI C, is a value that holds 8 bytes, or 64 bits. This corresponds to a range of 0 to 1.84467441 × 10^19 (2^64 - 1). If the variable is signed (negative), then the range is from -9.22337204 × 10^18 to 9.22337204 × 10^18 (-2^63 + 1 to 2^63 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 23) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a long long) from another 64-bit number (a long long).
*Test a: Time required to subtract two constant long longs (may be pre-computed)
**Instruction:
**Time: 186ns
*Test b: Time required to subtract two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 150ns

==== Addition (Test 24) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 64-bit number (a long long) to another 64-bit number (a long long).
*Test a: Time required to add two constant long longs (may be pre-computed)
**Instruction:
**Time: 88ns
*Test b: Time required to add two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 200ns

==== Multiplication (Test 25) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: Time required to multiply two constant long longs (may be pre-computed)
**Instruction:
**Time: 74ns
*Test b: Time required to multiply two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 398ns

==== Division (Test 26) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: Time required to divide two constant long longs (may be pre-computed)
**Instruction:
**Time: 74ns
*Test b: Time required to divide two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 1724ns

==== Square Root (Test 27) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a long long). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant long long (may be pre-computed)
**Instruction:
**Time: 87ns
*Test b: Time required to sqrt() a random long long (guaranteed not to be pre-comp)
**Instruction:
**Time: 16311ns
*Test c: Time required to ^(1/2) a constant long long (may be pre-computed)
**Instruction:
**Time: 188ns
*Test d: Time required to ^(1/2) a random long long (guaranteed not to be pre-comp)
**Instruction:
**Time: 74ns

==== Sine (Test 28) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a long long).
*Test a: 23837ns
*Test b: 29898ns

==== Cosine (Test 29) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a long long).
*Test a: Time required to take the sine of a constant long long (may be pre-computed)
**Instruction:
**Time: 24611ns
*Test b: Time required to take the sine of a random long long (guaranteed not to be pre-comp)
**Instruction:
**Time: 30623ns

===float Performance===
----
==== Subtraction (Test 30) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (a float) from another 32-bit number (a float).
*Test a: Time required to subtract two constant floats (may be pre-computed)
**Instruction:
**Time: 100ns
*Test b: Time required to subtract two random floats (guaranteed not to be pre-comp)
**Instruction:
**Time: 900ns

==== Addition (Test 31) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (a float) to another 32-bit number (a float).
*Test a: Time required to add two constant floats (may be pre-computed)
**Instruction:
**Time: 124ns
*Test b: Time required to add two random floats (guaranteed not to be pre-comp)
**Instruction:
**Time: 1024ns

==== Multiplication (Test 32) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (a float) by another 32-bit number (a float).
*Test a: Time required to multiply two constant floats (may be pre-computed)
**Instruction:
**Time: 124ns
*Test b: Time required to multiply two random floats (guaranteed not to be pre-comp)
**Instruction:
**Time: 736ns

==== Division (Test 33) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (a float) by another 32-bit number (a float).
*Test a: Time required to divide two constant floats (may be pre-computed)
**Instruction:
**Time: 99ns
*Test b: Time required to divide two random floats (guaranteed not to be pre-comp)
**Instruction:
**Time: 1674ns

==== Square Root (Test 34) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (a float). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant float (may be pre-computed)
**Instruction:
**Time: 99ns
*Test b: Time required to sqrt() a random float (guaranteed not to be pre-comp)
**Instruction:
**Time: 8636ns
*Test c: Time required to ^(1/2) a constant float (may be pre-computed)
**Instruction:
**Time: N/A
*Test d: Time required to ^(1/2) a random float (guaranteed not to be pre-comp)
**Instruction:
**Time: N/A

==== Sine (Test 35) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (a float).
*Test a: Time required to take the sine of a constant float (may be pre-computed)
**Instruction:
**Time: 19574ns
*Test b: Time required to take the sine of a random float (guaranteed not to be pre-comp)
**Instruction:
**Time: 19562ns

==== Cosine (Test 36) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (a float).
*Test a: Time required to take the cosine of a constant float (may be pre-computed)
**Instruction:
**Time: 20311ns
*Test b: Time required to take the cosine of a random float (guaranteed not to be pre-comp)
**Instruction:
**Time: 20297ns

===double Performance===
----
==== Subtraction (Test 37) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a double) from another 8-bit number (a double).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 199 ns
* Test (b): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 38) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to add one 64-bit number (a double) to another 64-bit number (a double).
* Test (a): Time required to add two constant doubles (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 199 ns
* Test (c): Time required to add of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 1236 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 39) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a double) by another 64-bit number (a double).
* Test (a): Time required to multiply two constant doubles (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 188 ns
* Test (b): Time required to multiply of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 1438 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 40) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a double) by another 64-bit number (a double).
* Test (a): Time required to divide two constant doubles (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 187 ns
* Test (b): Time required to divide of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: 3184 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Square Root (Test 41) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (c): Time required to pull an output pin low
| caption3 = Caption3

| image4 = test1-whileloop-onoff-timetogohigh.png
| alt4 = Test (d): Time required to throw an output pin high
| caption4 = Caption4

| image5 = test1-whileloop-onoff-timetogolow.png
| alt5 = Test (e): Time required to pull an output pin low
| caption5 = Caption5

| image6 = test1-whileloop-onoff-pair.png
| alt6 = Test (f): Time required to pull an output pin low
| caption6 = Caption6
}}
This test determines the length of time required by the PIC32 chip to square root a 64-bit number (a double). Benchmarks (a) through (c) use the <code>sqrt()</code> function while benchmarks (d) through (f) raise the operands to the 1/2 power.
* Test (a): Time required to sqrt() a constant double (may be pre-computed)
** Instruction: <code>ascii_25 = sqrt('u');</code>
** Time: 188 ns
* Test (b): Time required to sqrt() an int cast into a double (may be pre-computed)
** Instruction: <code>number_10 = sqrt(100);</code>
** Time: 7998 ns
* Test (c): Time required to sqrt() a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sqrt(random_char1);</code>
** Time: N/A ns *
* Test (d): Time required to ^(1/2) a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = ('u')^(1/2);</code>
** Time: N/A ns *

<nowiki>*</nowiki> We had some difficulty in trying to test these particular operations. It seems that the PIC32 is not capable of raising doubles to the 1/2 power.

==== Sine (Test 42) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the sine of an 64-bit number (a double).
* Test (a): Time required to take the sine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sin('K');</code>
** Time: 20299 ns
* Test (b): Time required to take the sine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sin(larger);</code>*
** Time: 20624 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Cosine (Test 43) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a double).
* Test (a): Time required to take the cosine of a constant double (may be pre-computed)
** Instruction: <code>ascii_25 = cos('K');</code>
** Time: 19762 ns
* Test (c): Time required to take the cosine of a random double (guaranteed not to be pre-comp)
** Instruction: <code>random_char = cos(larger);</code>*
** Time: 20011 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

== Code ==

===Test 1===
This is the first test.

===Test 2===
This is the second test.

Blah blah blah, I would really like to be watching the super bowl right about now. /sigh.

PIC32MX: Benchmarking Mathematical Operations

2010-02-16T08:05:12Z

MaxWiller:

== Original Assignment ==

'''Do not erase this section!'''

Your assignment is to empirically test how long it takes to perform add, subtract, multiply, divide, sqrt, sin, and cos operations with the 80 MHz PIC32460F512L and our standard code optimization setting. You will do these tests with chars (8-bit integers), shorts (16-bit), integers (32-bit), long long integers (64-bit), floats (32-bit single precision floating point), and double (64-bit double-precision floating point). The integers can be unsigned or signed. Your end result will be a table with the operation on one axis (likely the horizontal axis) and the kind of variable on the other axis, and each cell of the table will have a normalized duration for the operation. The time will be normalized by the fastest operation, so the smallest number in the table will be 1.00. All other numbers will indicate how many times longer that operation takes. All numbers will have two decimal places, e.g., 2.57 or 24.72. You will also give the time that 1.00 corresponds to in nanoseconds.

Since bit-shifting left and right correspond to a version of multiplying and dividing, you should also include the operations >>1 and >>4 and <<1 and <<4. (If the results are identical, you can eliminate shift left from your table.)

To generate this table, you can set an output bit low before the operation, then high immediately after the operation, and measure the time on an oscilloscope. Two things to consider: (1) Time a single operation, over and over, with a short delay between the operation. This should create a pulse train on your oscilloscope. Can you get an accurate estimate of the time this way? You could also try doing five or ten operations between changing the digital output. See if this gives the same estimate. (This estimate might be more accurate as you are essentially averaging over a number of operations.) Avoid using arrays and for loops in your test, as indexing arrays and running the loop each take time. (2) Make sure the compiler doesn't compute the results in advance. You could try testing operations with numbers generated randomly (don't time this operation!) vs. numbers that you just type in manually to make sure that both are giving you the same result.

== Overview ==

We were tasked with determining the real-time cost (measured in nanoseconds) of performing seven basic mathematical operations with each one of the six commonly used ANSI C data types.

The mathematical operations we tested were:
* subtraction
* addition
* multiplication
* division
* square root
* sine
* cosine

The six data types we tested each operation on were:
* char
* short
* integer
* long long
* float
* double

Our testing procedure was simple: throw an output pin high on the NU32 development board, perform a mathematical operation with a given data type, and then pull the same pin low.

Placing the above three steps in an infinite while loop afforded us the opportunity to use an oscilloscope to measure the duration between each high-low pair in the output waveform. After subtracting the time it took for the PIC to raise and lower the voltage on the output pin (something we previously measured), we were able to determine the amount of time required for the PIC32 chip to execute an operation with a high level of accuracy.

With seven operations to perform on six different data types, we created the following table to help us assign and keep track of the various tests we planned to run:

{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! char (8-bit) !! short (16-bit) !! int (32-bit) !! long long (64-bit) !! float (32-bit) !! double (64-bit)
|-
! subtraction
| Test 2 || Test 9 || Test 16 || Test 23 || Test 30 || Test 37
|-
! addition
| Test 3 || Test 10 || Test 17 || Test 24 || Test 31 || Test 38
|-
! multiplication
| Test 4 || Test 11 || Test 18 || Test 25 || Test 32 || Test 39
|-
! division
| Test 5 || Test 12 || Test 19 || Test 26 || Test 33 || Test 40
|-
! square root
| Test 6 || Test 13 || Test 20 || Test 27 || Test 34 || Test 41
|-
! sine
| Test 7 || Test 14 || Test 21 || Test 28 || Test 35 || Test 42
|-
! cosine
| Test 8 || Test 15 || Test 22 || Test 29 || Test 36 || Test 43
|}

Several tests contained multiple procedures that explored various ways to carry out a given mathematical operation on a given data type. For example, in the multiplication tests, not only did we test the traditional multiplication operator (*), but also the bitwise left shift operator (<<). Our goal was to find out if one particular operator was faster than the other. Similarly, we also included procedures that performed the above operations on hard-coded numbers (such as 347) as well as randomly chosen numbers stored in variables (such as 'random_int1'). We wanted to ensure that the compiler didn't compute the results of each operation in advance. While pre-compiling can indeed afford welcome increases in execution time, situations in which the compiler can't optimize the operations ahead of time (for example, situations where the data to be operated on is not known in advance) are still common occurrences and are worth benchmarking.

Accordingly, several tests contain multiple procedures that not only account for multiple methods of performing a particular operation, but multiple sets of numbers to perform those operations on.

Test 1 was used to determine the duration required for the PIC32 to throw a pin high and pull a pin low, while Tests 2 through 43 were used to measure the actual performance of each operation and data-type pair.

== Results ==
Below is the quick summary of the testing results comparing each data type and each operation. All results are normalized to 60ns (1.00 = 60ns).
{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! Subtraction !! Addition !! Multiplication !! Division !! Square Root !! Sine !! Cosine !!
|-
! Char
| 1.87 || 1.65 || 2.28 || N/A || 34.78 || 116.03 || 98.93
|-
! Short
| 1.03 || 1.67 || 1.47 || 5.00 || 144.57 || 230.40 || 215.40
|-
! Int
| 1.07 || 1.00 || 1.43 || 8.10 || 145.62 || 316.43 || 330.62
|-
! Long Long
| 2.50 || 3.33 || 6.63 || 28.73 || 271.85 || 498.30 || 510.38
|-
! Float
| 15.00 || 17.07 || 12.27 || 27.90 || 143.93 || 326.03 || 338.28
|-
! Double
| 26.00 || 20.60 || 23.97 || 53.07 || 133.30 || 343.73 || 333.52

|}
Below are the results of each particular test we performed, coupled with a short explanation for each result.

=== Basic Timing Constants (Test 1) ===
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to push a given output pin high and pull the same pin low.
* Test (a): Time required to throw an output pin high
** Instruction: <code>PIN_A2 = 1;</code>
** Time: 63 ns
* Test (b): Time required to pull an output pin low
** Instruction: <code>PIN_A2 = 0;</code>
** Time: 63 ns
* Test (c): Time required to execute 1 empty while loop cycle
** Instruction: <code>while(1){}</code>
** Time: 23 ns

=== char Performance ===
----
A <code>char</code> data type, in ANSI C, is a value holding one byte, or one character code. The actual number of bits in a char in a particular implementation is documented as CHAR_BIT in that implementation's <code>limits.h</code> file. In practice, it is almost always 8 bits, corresponding to a decimal range of 0 to 255 inclusive. Unless otherwise noted, all (a) benchmarks are operations on two predefined (and mot likely pre-computed) ASCII letters, all (b) benchmarks are operations on two predefined (and most likely pre-computed) numbers in the range of 0 to 255, and all (c) benchmarks are operations on two random (and most likely '''not''' pre-computed) numbers. These multiple benchmarks per test exist to illustrate the differences in execution time between pre-compiled operations and operations the PIC must perform in real time.

==== Subtraction (Test 2) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 8-bit number (a char) from another 8-bit number (a char).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 50 ns
* Test (b): Time required to subtract two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 100-2;</code>
** Time: 50 ns
* Test (c): Time required to subtract two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 3) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 8-bit number (a char) to another 8-bit number (a char).
* Test (a): Time required to add two constant chars (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 50 ns
* Test (b): Time required to add two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 97+1;</code>
** Time: 50 ns
* Test (c): Time required to add two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 99 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 4) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to multiply two constant chars (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 49 ns
* Test (b): Time required to multiply two ints cast into a char (may be pre-computed)
** Instruction: <code>ascii_200 = 100*2;</code>
** Time: 48 ns
* Test (c): Time required to multiply of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 137 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 5) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to divide two constant chars (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 48 ns
* Test (b): Time required to divide two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = 100/2;</code>
** Time: 50 ns
* Test (c): Time required to divide two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: N/A

<nowiki>*</nowiki> We had great difficulty in trying to test this particular operation. After some research with an oscilloscope and voltmeter, it seems that the PIC32 is not capable of dividing chars in this way. More specifically, every time the PIC32 attempts to divide one char by another, all output pins are immediately grounded. We've tested this code in other C environments, and it works as expected, so the error must either lie somewhere within our specific PICs (which would be very unlikely - we tested 3) or the silicon architecture of the PIC32 itself (sill unlikely, but given the number of PICs we tested, more probable). If you absolutely need to divide chars, cast them to ints first, perform your division, then cast them back to chars.

==== Square Root (Test 6) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (c): Time required to pull an output pin low
| caption3 = Caption3

| image4 = test1-whileloop-onoff-timetogohigh.png
| alt4 = Test (d): Time required to throw an output pin high
| caption4 = Caption4

| image5 = test1-whileloop-onoff-timetogolow.png
| alt5 = Test (e): Time required to pull an output pin low
| caption5 = Caption5

| image6 = test1-whileloop-onoff-pair.png
| alt6 = Test (f): Time required to pull an output pin low
| caption6 = Caption6
}}
This test determines the length of time required by the PIC32 chip to square root one 8-bit number (a char). Benchmarks (a) through (c) use the <code>sqrt()</code> function while benchmarks (d) through (f) raise the operands to the 1/2 power.
* Test (a): Time required to sqrt() a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sqrt('u');</code>
** Time: 48 ns
* Test (b): Time required to sqrt() an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = sqrt(100);</code>
** Time: 48 ns
* Test (c): Time required to sqrt() a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sqrt(random_char1);</code>
** Time: 2087 ns
* Test (d): Time required to ^(1/2) a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = ('u')^(1/2);</code>
** Time: 48 ns
* Test (e): Time required to ^(1/2) an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = (100)^(1/2);</code>
** Time: 48 ns
* Test (f): Time required to ^(1/2) a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = (random_char2)^(1/2);</code>*
** Time: 75 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Sine (Test 7) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the sine of an 8-bit number (a char).
* Test (a): Time required to take the sine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sin('K');</code>
** Time: 9963 ns
* Test (b): Time required to take the sine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = sin(50);</code>
** Time: 9550 ns
* Test (c): Time required to take the sine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sin(larger);</code>*
** Time: 6962 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Cosine (Test 8) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the cosine of an 8-bit number (a char).
* Test (a): Time required to take the cosine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = cos('K');</code>
** Time: 9111 ns
* Test (b): Time required to take the cosine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = cos(50);</code>
** Time: 8724 ns
* Test (c): Time required to take the cosine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = cos(larger);</code>*
** Time: 5936 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

=== short Performance ===
----
A short data type, in ANSI C, is a value that holds 2 bytes, or 16 bits. This corresponds to a range of 0 to 65535 (2^16 - 1). If the variable is signed (negative), then the range is from -32767 to 32767 (-2^15 + 1 to 2^15 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 9) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 16-bit number (a short) from another 16-bit number (a short).
*Test a: Time required to subtract two constant shorts (may be pre-computed)
** Instruction:
** Time: 25ns
*Test b: Time required to subtract two random chars (guaranteed not to be pre-comp)
** Instruction:
** Time: 62ns

==== Addition (Test 10) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 16-bit number (a short) to another 16-bit number (a short).
*Test a: Time required to add two constant shorts (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to add two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 100ns

==== Multiplication (Test 11) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to multiply two constant shorts (may be pre-computed)
**Instruction:
**Time: 24ns
*Test b: Time required to multiply two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 88ns

==== Division (Test 12) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to divide two constant shorts (may be pre-computed)
**Instruction:
**Time: 28ns
*Test b: Time required to divide two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 300ns

==== Square Root (Test 13) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 16-bit number (a short). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant short (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to sqrt() a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 8674ns
*Test c: Time required to ^(1/2) a constant short (may be pre-computed)
**Instruction:
**Time: 50ns
*Test d: Time required to ^(1/2) a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 76ns

==== Sine (Test 14) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 16-bit number (a short).
*Test a: Time required to take the sine of a constant short (may be pre-computed)
**Instruction:
**Time: 13014ns
*Test b: Time required to take the sine of a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 13824ns

==== Cosine (Test 15) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 16-bit number (a short).
*Test a: Time required to take the cosine of a constant short (may be pre-computed)
**Instruction:
**Time: 12174ns
*Test b: Time required to take the cosine of a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 12924ns

===int Performance===
----
An int data type, in ANSI C, is a value that holds 4 bytes, or 32 bits. This corresponds to a range of 0 to 4294967295 (2^32 - 1). If the variable is signed (negative), then the range is from -2147483647 to 2147483647 (-2^31 + 1 to 2^31 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 16) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (an int) from another 32-bit number (an int).
*Test a: Time required to subtract two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to subtract two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 64ns

==== Addition (Test 17) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (an int) to another 32-bit number (an int).
*Test a: Time required to add two constant ints (may be pre-computed)
**Instruction:
**Time: 26ns
*Test b: Time required to add two random ints (guaranteed not to be pre-comp)
**Instructions:
**Time: 60ns

==== Multiplication (Test 18) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (an int) by another 32-bit number (an int).
*Test a: Time required to multiply two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to multiply two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 86ns

==== Division (Test 19) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (an int) by another 32-bit number (an int).
*Test a: Time required to divide two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to divide two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 486s

==== Square Root (Test 20) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (an int). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant int (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to sqrt() a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 8737ns
*Test c: Time required to ^(1/2) a constant int (may be pre-computed)
**Instruction:
**Time: 88ns
*Test d: Time required to ^(1/2) a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 74ns

==== Sine (Test 21) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (an int).
*Test a: Time required to take the sine of a constant int (may be pre-computed)
**Instruction:
**Time: 19488ns
*Test b: Time required to take the sine of a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 18988ns

==== Cosine (Test 22) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (an int).
*Test a: Time required to take the cosine of a constant int (may be pre-computed)
**Instruction:
**Time: 20324ns
*Test b: Time required to take the cosine of a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 19837ns

===long long Performance===
----
An long long data type, in ANSI C, is a value that holds 8 bytes, or 64 bits. This corresponds to a range of 0 to 1.84467441 × 10^19 (2^64 - 1). If the variable is signed (negative), then the range is from -9.22337204 × 10^18 to 9.22337204 × 10^18 (-2^63 + 1 to 2^63 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 23) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a long long) from another 64-bit number (a long long).
*Test a: Time required to subtract two constant long longs (may be pre-computed)
**Instruction:
**Time: 186ns
*Test b: Time required to subtract two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 150ns

==== Addition (Test 24) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 64-bit number (a long long) to another 64-bit number (a long long).
*Test a: Time required to add two constant long longs (may be pre-computed)
**Instruction:
**Time: 88ns
*Test b: Time required to add two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 200ns

==== Multiplication (Test 25) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: Time required to multiply two constant long longs (may be pre-computed)
**Instruction:
**Time: 74ns
*Test b: Time required to multiply two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 398ns

==== Division (Test 26) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: Time required to divide two constant long longs (may be pre-computed)
**Instruction:
**Time: 74ns
*Test b: Time required to divide two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 1724ns

==== Square Root (Test 27) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a long long). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant long long (may be pre-computed)
**Instruction:
**Time: 87ns
*Test b: Time required to sqrt() a random long long (guaranteed not to be pre-comp)
**Instruction:
**Time: 16311ns
*Test c: Time required to ^(1/2) a constant long long (may be pre-computed)
**Instruction:
**Time: 188ns
*Test d: Time required to ^(1/2) a random long long (guaranteed not to be pre-comp)
**Instruction:
**Time: 74ns

==== Sine (Test 28) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a long long).
*Test a: 23837ns
*Test b: 29898ns

==== Cosine (Test 29) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a long long).
*Test a: Time required to take the sine of a constant long long (may be pre-computed)
**Instruction:
**Time: 24611ns
*Test b: Time required to take the sine of a random long long (guaranteed not to be pre-comp)
**Instruction:
**Time: 30623ns

===float Performance===
----
==== Subtraction (Test 30) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (a float) from another 32-bit number (a float).
*Test a: 100ns
*Test b: 900ns

==== Addition (Test 31) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (a float) to another 32-bit number (a float).
*Test a: 124ns
*Test b: 1024ns

==== Multiplication (Test 32) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (a float) by another 32-bit number (a float).
*Test a: 124ns
*Test b: 736ns

==== Division (Test 33) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (a float) by another 32-bit number (a float).
*Test a: 99ns
*Test b: 1674ns

==== Square Root (Test 34) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (a float). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 99ns
*Test b: 8636ns
*Test c: N/A
*Test d: N/A

==== Sine (Test 35) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (a float).
*Test a: 19574ns
*Test b: 19562ns

==== Cosine (Test 36) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (a float).
*Test a: 20311ns
*Test b: 20297

===double Performance===
----
==== Subtraction (Test 37) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a double) from another 8-bit number (a double).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 199 ns
* Test (b): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 38) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to add one 64-bit number (a double) to another 64-bit number (a double).
* Test (a): Time required to add two constant doubles (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 199 ns
* Test (c): Time required to add of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 1236 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 39) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a double) by another 64-bit number (a double).
* Test (a): Time required to multiply two constant doubles (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 188 ns
* Test (b): Time required to multiply of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 1438 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 40) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a double) by another 64-bit number (a double).
* Test (a): Time required to divide two constant doubles (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 187 ns
* Test (b): Time required to divide of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: 3184 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Square Root (Test 41) ====
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a double). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 188ns
*Test b: 7998ns
*Test c: N/A
*Test d: N/A

==== Sine (Test 42) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a double).
*Test a: 20299ns
*Test b: 20624ns

==== Cosine (Test 43) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a double).
*Test a: 19762ns
*Test b: 20011ns

== Code ==

===Test 1===
This is the first test.

===Test 2===
This is the second test.

Blah blah blah, I would really like to be watching the super bowl right about now. /sigh.

PIC32MX: Benchmarking Mathematical Operations

2010-02-16T08:00:39Z

MaxWiller:

== Original Assignment ==

'''Do not erase this section!'''

Your assignment is to empirically test how long it takes to perform add, subtract, multiply, divide, sqrt, sin, and cos operations with the 80 MHz PIC32460F512L and our standard code optimization setting. You will do these tests with chars (8-bit integers), shorts (16-bit), integers (32-bit), long long integers (64-bit), floats (32-bit single precision floating point), and double (64-bit double-precision floating point). The integers can be unsigned or signed. Your end result will be a table with the operation on one axis (likely the horizontal axis) and the kind of variable on the other axis, and each cell of the table will have a normalized duration for the operation. The time will be normalized by the fastest operation, so the smallest number in the table will be 1.00. All other numbers will indicate how many times longer that operation takes. All numbers will have two decimal places, e.g., 2.57 or 24.72. You will also give the time that 1.00 corresponds to in nanoseconds.

Since bit-shifting left and right correspond to a version of multiplying and dividing, you should also include the operations >>1 and >>4 and <<1 and <<4. (If the results are identical, you can eliminate shift left from your table.)

To generate this table, you can set an output bit low before the operation, then high immediately after the operation, and measure the time on an oscilloscope. Two things to consider: (1) Time a single operation, over and over, with a short delay between the operation. This should create a pulse train on your oscilloscope. Can you get an accurate estimate of the time this way? You could also try doing five or ten operations between changing the digital output. See if this gives the same estimate. (This estimate might be more accurate as you are essentially averaging over a number of operations.) Avoid using arrays and for loops in your test, as indexing arrays and running the loop each take time. (2) Make sure the compiler doesn't compute the results in advance. You could try testing operations with numbers generated randomly (don't time this operation!) vs. numbers that you just type in manually to make sure that both are giving you the same result.

== Overview ==

We were tasked with determining the real-time cost (measured in nanoseconds) of performing seven basic mathematical operations with each one of the six commonly used ANSI C data types.

The mathematical operations we tested were:
* subtraction
* addition
* multiplication
* division
* square root
* sine
* cosine

The six data types we tested each operation on were:
* char
* short
* integer
* long long
* float
* double

Our testing procedure was simple: throw an output pin high on the NU32 development board, perform a mathematical operation with a given data type, and then pull the same pin low.

Placing the above three steps in an infinite while loop afforded us the opportunity to use an oscilloscope to measure the duration between each high-low pair in the output waveform. After subtracting the time it took for the PIC to raise and lower the voltage on the output pin (something we previously measured), we were able to determine the amount of time required for the PIC32 chip to execute an operation with a high level of accuracy.

With seven operations to perform on six different data types, we created the following table to help us assign and keep track of the various tests we planned to run:

{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! char (8-bit) !! short (16-bit) !! int (32-bit) !! long long (64-bit) !! float (32-bit) !! double (64-bit)
|-
! subtraction
| Test 2 || Test 9 || Test 16 || Test 23 || Test 30 || Test 37
|-
! addition
| Test 3 || Test 10 || Test 17 || Test 24 || Test 31 || Test 38
|-
! multiplication
| Test 4 || Test 11 || Test 18 || Test 25 || Test 32 || Test 39
|-
! division
| Test 5 || Test 12 || Test 19 || Test 26 || Test 33 || Test 40
|-
! square root
| Test 6 || Test 13 || Test 20 || Test 27 || Test 34 || Test 41
|-
! sine
| Test 7 || Test 14 || Test 21 || Test 28 || Test 35 || Test 42
|-
! cosine
| Test 8 || Test 15 || Test 22 || Test 29 || Test 36 || Test 43
|}

Several tests contained multiple procedures that explored various ways to carry out a given mathematical operation on a given data type. For example, in the multiplication tests, not only did we test the traditional multiplication operator (*), but also the bitwise left shift operator (<<). Our goal was to find out if one particular operator was faster than the other. Similarly, we also included procedures that performed the above operations on hard-coded numbers (such as 347) as well as randomly chosen numbers stored in variables (such as 'random_int1'). We wanted to ensure that the compiler didn't compute the results of each operation in advance. While pre-compiling can indeed afford welcome increases in execution time, situations in which the compiler can't optimize the operations ahead of time (for example, situations where the data to be operated on is not known in advance) are still common occurrences and are worth benchmarking.

Accordingly, several tests contain multiple procedures that not only account for multiple methods of performing a particular operation, but multiple sets of numbers to perform those operations on.

Test 1 was used to determine the duration required for the PIC32 to throw a pin high and pull a pin low, while Tests 2 through 43 were used to measure the actual performance of each operation and data-type pair.

== Results ==
Below is the quick summary of the testing results comparing each data type and each operation. All results are normalized to 60ns (1.00 = 60ns).
{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! Subtraction !! Addition !! Multiplication !! Division !! Square Root !! Sine !! Cosine !!
|-
! Char
| 1.87 || 1.65 || 2.28 || N/A || 34.78 || 116.03 || 98.93
|-
! Short
| 1.03 || 1.67 || 1.47 || 5.00 || 144.57 || 230.40 || 215.40
|-
! Int
| 1.07 || 1.00 || 1.43 || 8.10 || 145.62 || 316.43 || 330.62
|-
! Long Long
| 2.50 || 3.33 || 6.63 || 28.73 || 271.85 || 498.30 || 510.38
|-
! Float
| 15.00 || 17.07 || 12.27 || 27.90 || 143.93 || 326.03 || 338.28
|-
! Double
| 26.00 || 20.60 || 23.97 || 53.07 || 133.30 || 343.73 || 333.52

|}
Below are the results of each particular test we performed, coupled with a short explanation for each result.

=== Basic Timing Constants (Test 1) ===
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to push a given output pin high and pull the same pin low.
* Test (a): Time required to throw an output pin high
** Instruction: <code>PIN_A2 = 1;</code>
** Time: 63 ns
* Test (b): Time required to pull an output pin low
** Instruction: <code>PIN_A2 = 0;</code>
** Time: 63 ns
* Test (c): Time required to execute 1 empty while loop cycle
** Instruction: <code>while(1){}</code>
** Time: 23 ns

=== char Performance ===
----
A <code>char</code> data type, in ANSI C, is a value holding one byte, or one character code. The actual number of bits in a char in a particular implementation is documented as CHAR_BIT in that implementation's <code>limits.h</code> file. In practice, it is almost always 8 bits, corresponding to a decimal range of 0 to 255 inclusive. Unless otherwise noted, all (a) benchmarks are operations on two predefined (and mot likely pre-computed) ASCII letters, all (b) benchmarks are operations on two predefined (and most likely pre-computed) numbers in the range of 0 to 255, and all (c) benchmarks are operations on two random (and most likely '''not''' pre-computed) numbers. These multiple benchmarks per test exist to illustrate the differences in execution time between pre-compiled operations and operations the PIC must perform in real time.

==== Subtraction (Test 2) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 8-bit number (a char) from another 8-bit number (a char).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 50 ns
* Test (b): Time required to subtract two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 100-2;</code>
** Time: 50 ns
* Test (c): Time required to subtract two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 3) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 8-bit number (a char) to another 8-bit number (a char).
* Test (a): Time required to add two constant chars (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 50 ns
* Test (b): Time required to add two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 97+1;</code>
** Time: 50 ns
* Test (c): Time required to add two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 99 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 4) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to multiply two constant chars (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 49 ns
* Test (b): Time required to multiply two ints cast into a char (may be pre-computed)
** Instruction: <code>ascii_200 = 100*2;</code>
** Time: 48 ns
* Test (c): Time required to multiply of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 137 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 5) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to divide two constant chars (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 48 ns
* Test (b): Time required to divide two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = 100/2;</code>
** Time: 50 ns
* Test (c): Time required to divide two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: N/A

<nowiki>*</nowiki> We had great difficulty in trying to test this particular operation. After some research with an oscilloscope and voltmeter, it seems that the PIC32 is not capable of dividing chars in this way. More specifically, every time the PIC32 attempts to divide one char by another, all output pins are immediately grounded. We've tested this code in other C environments, and it works as expected, so the error must either lie somewhere within our specific PICs (which would be very unlikely - we tested 3) or the silicon architecture of the PIC32 itself (sill unlikely, but given the number of PICs we tested, more probable). If you absolutely need to divide chars, cast them to ints first, perform your division, then cast them back to chars.

==== Square Root (Test 6) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (c): Time required to pull an output pin low
| caption3 = Caption3

| image4 = test1-whileloop-onoff-timetogohigh.png
| alt4 = Test (d): Time required to throw an output pin high
| caption4 = Caption4

| image5 = test1-whileloop-onoff-timetogolow.png
| alt5 = Test (e): Time required to pull an output pin low
| caption5 = Caption5

| image6 = test1-whileloop-onoff-pair.png
| alt6 = Test (f): Time required to pull an output pin low
| caption6 = Caption6
}}
This test determines the length of time required by the PIC32 chip to square root one 8-bit number (a char). Benchmarks (a) through (c) use the <code>sqrt()</code> function while benchmarks (d) through (f) raise the operands to the 1/2 power.
* Test (a): Time required to sqrt() a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sqrt('u');</code>
** Time: 48 ns
* Test (b): Time required to sqrt() an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = sqrt(100);</code>
** Time: 48 ns
* Test (c): Time required to sqrt() a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sqrt(random_char1);</code>
** Time: 2087 ns
* Test (d): Time required to ^(1/2) a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = ('u')^(1/2);</code>
** Time: 48 ns
* Test (e): Time required to ^(1/2) an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = (100)^(1/2);</code>
** Time: 48 ns
* Test (f): Time required to ^(1/2) a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = (random_char2)^(1/2);</code>*
** Time: 75 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Sine (Test 7) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the sine of an 8-bit number (a char).
* Test (a): Time required to take the sine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sin('K');</code>
** Time: 9963 ns
* Test (b): Time required to take the sine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = sin(50);</code>
** Time: 9550 ns
* Test (c): Time required to take the sine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sin(larger);</code>*
** Time: 6962 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Cosine (Test 8) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the cosine of an 8-bit number (a char).
* Test (a): Time required to take the cosine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = cos('K');</code>
** Time: 9111 ns
* Test (b): Time required to take the cosine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = cos(50);</code>
** Time: 8724 ns
* Test (c): Time required to take the cosine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = cos(larger);</code>*
** Time: 5936 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

=== short Performance ===
----
A short data type, in ANSI C, is a value that holds 2 bytes, or 16 bits. This corresponds to a range of 0 to 65535 (2^16 - 1). If the variable is signed (negative), then the range is from -32767 to 32767 (-2^15 + 1 to 2^15 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 9) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 16-bit number (a short) from another 16-bit number (a short).
*Test a: Time required to subtract two constant shorts (may be pre-computed)
** Instruction:
** Time: 25ns
*Test b: Time required to subtract two random chars (guaranteed not to be pre-comp)
** Instruction:
** Time: 62ns

==== Addition (Test 10) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 16-bit number (a short) to another 16-bit number (a short).
*Test a: Time required to add two constant shorts (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to add two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 100ns

==== Multiplication (Test 11) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to multiply two constant shorts (may be pre-computed)
**Instruction:
**Time: 24ns
*Test b: Time required to multiply two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 88ns

==== Division (Test 12) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to divide two constant shorts (may be pre-computed)
**Instruction:
**Time: 28ns
*Test b: Time required to divide two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 300ns

==== Square Root (Test 13) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 16-bit number (a short). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant short (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to sqrt() a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 8674ns
*Test c: Time required to ^(1/2) a constant short (may be pre-computed)
**Instruction:
**Time: 50ns
*Test d: Time required to ^(1/2) a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 76ns

==== Sine (Test 14) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 16-bit number (a short).
*Test a: Time required to take the sine of a constant short (may be pre-computed)
**Instruction:
**Time: 13014ns
*Test b: Time required to take the sine of a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 13824ns

==== Cosine (Test 15) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 16-bit number (a short).
*Test a: Time required to take the cosine of a constant short (may be pre-computed)
**Instruction:
**Time: 12174ns
*Test b: Time required to take the cosine of a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 12924ns

===int Performance===
----
An int data type, in ANSI C, is a value that holds 4 bytes, or 32 bits. This corresponds to a range of 0 to 4294967295 (2^32 - 1). If the variable is signed (negative), then the range is from -2147483647 to 2147483647 (-2^31 + 1 to 2^31 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 16) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (an int) from another 32-bit number (an int).
*Test a: Time required to subtract two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to subtract two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 64ns

==== Addition (Test 17) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (an int) to another 32-bit number (an int).
*Test a: Time required to add two constant ints (may be pre-computed)
**Instruction:
**Time: 26ns
*Test b: Time required to add two random ints (guaranteed not to be pre-comp)
**Instructions:
**Time: 60ns

==== Multiplication (Test 18) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (an int) by another 32-bit number (an int).
*Test a: Time required to multiply two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to multiply two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 86ns

==== Division (Test 19) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (an int) by another 32-bit number (an int).
*Test a: Time required to divide two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to divide two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 486s

==== Square Root (Test 20) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (an int). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant int (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to sqrt() a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 8737ns
*Test c: Time required to ^(1/2) a constant int (may be pre-computed)
**Instruction:
**Time: 88ns
*Test d: Time required to ^(1/2) a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 74ns

==== Sine (Test 21) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (an int).
*Test a: Time required to take the sine of a constant int (may be pre-computed)
**Instruction:
**Time: 19488ns
*Test b: Time required to take the sine of a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 18988ns

==== Cosine (Test 22) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (an int).
*Test a: Time required to take the cosine of a constant int (may be pre-computed)
**Instruction:
**Time: 20324ns
*Test b: Time required to take the cosine of a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 19837ns

===long long Performance===
----
An long long data type, in ANSI C, is a value that holds 8 bytes, or 64 bits. This corresponds to a range of 0 to 1.84467441 × 10^19 (2^64 - 1). If the variable is signed (negative), then the range is from -9.22337204 × 10^18 to 9.22337204 × 10^18 (-2^63 + 1 to 2^63 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 23) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a long long) from another 64-bit number (a long long).
*Test a: Time required to subtract two constant long longs (may be pre-computed)
**Instruction:
**Time: 186ns
*Test b: Time required to subtract two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 150ns

==== Addition (Test 24) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 64-bit number (a long long) to another 64-bit number (a long long).
*Test a: Time required to add two constant long longs (may be pre-computed)
**Instruction:
**Time: 88ns
*Test b: Time required to add two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 200ns

==== Multiplication (Test 25) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: Time required to multiply two constant long longs (may be pre-computed)
**Instruction:
**Time: 74ns
*Test b: Time required to multiply two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 398ns

==== Division (Test 26) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: Time required to divide two constant long longs (may be pre-computed)
**Instruction:
**Time: 74ns
*Test b: Time required to divide two random long longs (guaranteed not to be pre-comp)
**Instruction:
**Time: 1724ns

==== Square Root (Test 27) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a long long). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant long long (may be pre-computed)
**Instruction:
**Time: 87ns
*Test b: Time required to sqrt() a random long long (guaranteed not to be pre-comp)
**Instruction:
**Time: 16311ns
*Test c: Time required to ^(1/2) a constant long long (may be pre-computed)
**Instruction:
**Time: 188ns
*Test d: 74ns

==== Sine (Test 28) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a long long).
*Test a: 23837ns
*Test b: 29898ns

==== Cosine (Test 29) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a long long).
*Test a: 24611ns
*Test b: 30623ns

===float Performance===
----
==== Subtraction (Test 30) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (a float) from another 32-bit number (a float).
*Test a: 100ns
*Test b: 900ns

==== Addition (Test 31) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (a float) to another 32-bit number (a float).
*Test a: 124ns
*Test b: 1024ns

==== Multiplication (Test 32) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (a float) by another 32-bit number (a float).
*Test a: 124ns
*Test b: 736ns

==== Division (Test 33) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (a float) by another 32-bit number (a float).
*Test a: 99ns
*Test b: 1674ns

==== Square Root (Test 34) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (a float). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 99ns
*Test b: 8636ns
*Test c: N/A
*Test d: N/A

==== Sine (Test 35) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (a float).
*Test a: 19574ns
*Test b: 19562ns

==== Cosine (Test 36) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (a float).
*Test a: 20311ns
*Test b: 20297

===double Performance===
----
==== Subtraction (Test 37) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a double) from another 8-bit number (a double).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 199 ns
* Test (b): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 38) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to add one 64-bit number (a double) to another 64-bit number (a double).
* Test (a): Time required to add two constant doubles (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 199 ns
* Test (c): Time required to add of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 1236 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 39) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a double) by another 64-bit number (a double).
* Test (a): Time required to multiply two constant doubles (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 188 ns
* Test (b): Time required to multiply of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 1438 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 40) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a double) by another 64-bit number (a double).
* Test (a): Time required to divide two constant doubles (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 187 ns
* Test (b): Time required to divide of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: 3184 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Square Root (Test 41) ====
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a double). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 188ns
*Test b: 7998ns
*Test c: N/A
*Test d: N/A

==== Sine (Test 42) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a double).
*Test a: 20299ns
*Test b: 20624ns

==== Cosine (Test 43) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a double).
*Test a: 19762ns
*Test b: 20011ns

== Code ==

===Test 1===
This is the first test.

===Test 2===
This is the second test.

Blah blah blah, I would really like to be watching the super bowl right about now. /sigh.

PIC32MX: Benchmarking Mathematical Operations

2010-02-16T07:55:45Z

MaxWiller:

== Original Assignment ==

'''Do not erase this section!'''

Your assignment is to empirically test how long it takes to perform add, subtract, multiply, divide, sqrt, sin, and cos operations with the 80 MHz PIC32460F512L and our standard code optimization setting. You will do these tests with chars (8-bit integers), shorts (16-bit), integers (32-bit), long long integers (64-bit), floats (32-bit single precision floating point), and double (64-bit double-precision floating point). The integers can be unsigned or signed. Your end result will be a table with the operation on one axis (likely the horizontal axis) and the kind of variable on the other axis, and each cell of the table will have a normalized duration for the operation. The time will be normalized by the fastest operation, so the smallest number in the table will be 1.00. All other numbers will indicate how many times longer that operation takes. All numbers will have two decimal places, e.g., 2.57 or 24.72. You will also give the time that 1.00 corresponds to in nanoseconds.

Since bit-shifting left and right correspond to a version of multiplying and dividing, you should also include the operations >>1 and >>4 and <<1 and <<4. (If the results are identical, you can eliminate shift left from your table.)

To generate this table, you can set an output bit low before the operation, then high immediately after the operation, and measure the time on an oscilloscope. Two things to consider: (1) Time a single operation, over and over, with a short delay between the operation. This should create a pulse train on your oscilloscope. Can you get an accurate estimate of the time this way? You could also try doing five or ten operations between changing the digital output. See if this gives the same estimate. (This estimate might be more accurate as you are essentially averaging over a number of operations.) Avoid using arrays and for loops in your test, as indexing arrays and running the loop each take time. (2) Make sure the compiler doesn't compute the results in advance. You could try testing operations with numbers generated randomly (don't time this operation!) vs. numbers that you just type in manually to make sure that both are giving you the same result.

== Overview ==

We were tasked with determining the real-time cost (measured in nanoseconds) of performing seven basic mathematical operations with each one of the six commonly used ANSI C data types.

The mathematical operations we tested were:
* subtraction
* addition
* multiplication
* division
* square root
* sine
* cosine

The six data types we tested each operation on were:
* char
* short
* integer
* long long
* float
* double

Our testing procedure was simple: throw an output pin high on the NU32 development board, perform a mathematical operation with a given data type, and then pull the same pin low.

Placing the above three steps in an infinite while loop afforded us the opportunity to use an oscilloscope to measure the duration between each high-low pair in the output waveform. After subtracting the time it took for the PIC to raise and lower the voltage on the output pin (something we previously measured), we were able to determine the amount of time required for the PIC32 chip to execute an operation with a high level of accuracy.

With seven operations to perform on six different data types, we created the following table to help us assign and keep track of the various tests we planned to run:

{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! char (8-bit) !! short (16-bit) !! int (32-bit) !! long long (64-bit) !! float (32-bit) !! double (64-bit)
|-
! subtraction
| Test 2 || Test 9 || Test 16 || Test 23 || Test 30 || Test 37
|-
! addition
| Test 3 || Test 10 || Test 17 || Test 24 || Test 31 || Test 38
|-
! multiplication
| Test 4 || Test 11 || Test 18 || Test 25 || Test 32 || Test 39
|-
! division
| Test 5 || Test 12 || Test 19 || Test 26 || Test 33 || Test 40
|-
! square root
| Test 6 || Test 13 || Test 20 || Test 27 || Test 34 || Test 41
|-
! sine
| Test 7 || Test 14 || Test 21 || Test 28 || Test 35 || Test 42
|-
! cosine
| Test 8 || Test 15 || Test 22 || Test 29 || Test 36 || Test 43
|}

Several tests contained multiple procedures that explored various ways to carry out a given mathematical operation on a given data type. For example, in the multiplication tests, not only did we test the traditional multiplication operator (*), but also the bitwise left shift operator (<<). Our goal was to find out if one particular operator was faster than the other. Similarly, we also included procedures that performed the above operations on hard-coded numbers (such as 347) as well as randomly chosen numbers stored in variables (such as 'random_int1'). We wanted to ensure that the compiler didn't compute the results of each operation in advance. While pre-compiling can indeed afford welcome increases in execution time, situations in which the compiler can't optimize the operations ahead of time (for example, situations where the data to be operated on is not known in advance) are still common occurrences and are worth benchmarking.

Accordingly, several tests contain multiple procedures that not only account for multiple methods of performing a particular operation, but multiple sets of numbers to perform those operations on.

Test 1 was used to determine the duration required for the PIC32 to throw a pin high and pull a pin low, while Tests 2 through 43 were used to measure the actual performance of each operation and data-type pair.

== Results ==
Below is the quick summary of the testing results comparing each data type and each operation. All results are normalized to 60ns (1.00 = 60ns).
{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! Subtraction !! Addition !! Multiplication !! Division !! Square Root !! Sine !! Cosine !!
|-
! Char
| 1.87 || 1.65 || 2.28 || N/A || 34.78 || 116.03 || 98.93
|-
! Short
| 1.03 || 1.67 || 1.47 || 5.00 || 144.57 || 230.40 || 215.40
|-
! Int
| 1.07 || 1.00 || 1.43 || 8.10 || 145.62 || 316.43 || 330.62
|-
! Long Long
| 2.50 || 3.33 || 6.63 || 28.73 || 271.85 || 498.30 || 510.38
|-
! Float
| 15.00 || 17.07 || 12.27 || 27.90 || 143.93 || 326.03 || 338.28
|-
! Double
| 26.00 || 20.60 || 23.97 || 53.07 || 133.30 || 343.73 || 333.52

|}
Below are the results of each particular test we performed, coupled with a short explanation for each result.

=== Basic Timing Constants (Test 1) ===
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to push a given output pin high and pull the same pin low.
* Test (a): Time required to throw an output pin high
** Instruction: <code>PIN_A2 = 1;</code>
** Time: 63 ns
* Test (b): Time required to pull an output pin low
** Instruction: <code>PIN_A2 = 0;</code>
** Time: 63 ns
* Test (c): Time required to execute 1 empty while loop cycle
** Instruction: <code>while(1){}</code>
** Time: 23 ns

=== char Performance ===
----
A <code>char</code> data type, in ANSI C, is a value holding one byte, or one character code. The actual number of bits in a char in a particular implementation is documented as CHAR_BIT in that implementation's <code>limits.h</code> file. In practice, it is almost always 8 bits, corresponding to a decimal range of 0 to 255 inclusive. Unless otherwise noted, all (a) benchmarks are operations on two predefined (and mot likely pre-computed) ASCII letters, all (b) benchmarks are operations on two predefined (and most likely pre-computed) numbers in the range of 0 to 255, and all (c) benchmarks are operations on two random (and most likely '''not''' pre-computed) numbers. These multiple benchmarks per test exist to illustrate the differences in execution time between pre-compiled operations and operations the PIC must perform in real time.

==== Subtraction (Test 2) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 8-bit number (a char) from another 8-bit number (a char).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 50 ns
* Test (b): Time required to subtract two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 100-2;</code>
** Time: 50 ns
* Test (c): Time required to subtract two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 3) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 8-bit number (a char) to another 8-bit number (a char).
* Test (a): Time required to add two constant chars (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 50 ns
* Test (b): Time required to add two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 97+1;</code>
** Time: 50 ns
* Test (c): Time required to add two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 99 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 4) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to multiply two constant chars (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 49 ns
* Test (b): Time required to multiply two ints cast into a char (may be pre-computed)
** Instruction: <code>ascii_200 = 100*2;</code>
** Time: 48 ns
* Test (c): Time required to multiply of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 137 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 5) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to divide two constant chars (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 48 ns
* Test (b): Time required to divide two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = 100/2;</code>
** Time: 50 ns
* Test (c): Time required to divide two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: N/A

<nowiki>*</nowiki> We had great difficulty in trying to test this particular operation. After some research with an oscilloscope and voltmeter, it seems that the PIC32 is not capable of dividing chars in this way. More specifically, every time the PIC32 attempts to divide one char by another, all output pins are immediately grounded. We've tested this code in other C environments, and it works as expected, so the error must either lie somewhere within our specific PICs (which would be very unlikely - we tested 3) or the silicon architecture of the PIC32 itself (sill unlikely, but given the number of PICs we tested, more probable). If you absolutely need to divide chars, cast them to ints first, perform your division, then cast them back to chars.

==== Square Root (Test 6) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (c): Time required to pull an output pin low
| caption3 = Caption3

| image4 = test1-whileloop-onoff-timetogohigh.png
| alt4 = Test (d): Time required to throw an output pin high
| caption4 = Caption4

| image5 = test1-whileloop-onoff-timetogolow.png
| alt5 = Test (e): Time required to pull an output pin low
| caption5 = Caption5

| image6 = test1-whileloop-onoff-pair.png
| alt6 = Test (f): Time required to pull an output pin low
| caption6 = Caption6
}}
This test determines the length of time required by the PIC32 chip to square root one 8-bit number (a char). Benchmarks (a) through (c) use the <code>sqrt()</code> function while benchmarks (d) through (f) raise the operands to the 1/2 power.
* Test (a): Time required to sqrt() a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sqrt('u');</code>
** Time: 48 ns
* Test (b): Time required to sqrt() an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = sqrt(100);</code>
** Time: 48 ns
* Test (c): Time required to sqrt() a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sqrt(random_char1);</code>
** Time: 2087 ns
* Test (d): Time required to ^(1/2) a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = ('u')^(1/2);</code>
** Time: 48 ns
* Test (e): Time required to ^(1/2) an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = (100)^(1/2);</code>
** Time: 48 ns
* Test (f): Time required to ^(1/2) a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = (random_char2)^(1/2);</code>*
** Time: 75 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Sine (Test 7) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the sine of an 8-bit number (a char).
* Test (a): Time required to take the sine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sin('K');</code>
** Time: 9963 ns
* Test (b): Time required to take the sine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = sin(50);</code>
** Time: 9550 ns
* Test (c): Time required to take the sine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sin(larger);</code>*
** Time: 6962 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Cosine (Test 8) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the cosine of an 8-bit number (a char).
* Test (a): Time required to take the cosine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = cos('K');</code>
** Time: 9111 ns
* Test (b): Time required to take the cosine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = cos(50);</code>
** Time: 8724 ns
* Test (c): Time required to take the cosine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = cos(larger);</code>*
** Time: 5936 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

=== short Performance ===
----
A short data type, in ANSI C, is a value that holds 2 bytes, or 16 bits. This corresponds to a range of 0 to 65535 (2^16 - 1). If the variable is signed (negative), then the range is from -32767 to 32767 (-2^15 + 1 to 2^15 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 9) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 16-bit number (a short) from another 16-bit number (a short).
*Test a: Time required to subtract two constant shorts (may be pre-computed)
** Instruction:
** Time: 25ns
*Test b: Time required to subtract two random chars (guaranteed not to be pre-comp)
** Instruction:
** Time: 62ns

==== Addition (Test 10) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 16-bit number (a short) to another 16-bit number (a short).
*Test a: Time required to add two constant shorts (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to add two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 100ns

==== Multiplication (Test 11) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to multiply two constant shorts (may be pre-computed)
**Instruction:
**Time: 24ns
*Test b: Time required to multiply two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 88ns

==== Division (Test 12) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to divide two constant shorts (may be pre-computed)
**Instruction:
**Time: 28ns
*Test b: Time required to divide two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 300ns

==== Square Root (Test 13) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 16-bit number (a short). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant short (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to sqrt() a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 8674ns
*Test c: Time required to ^(1/2) a constant short (may be pre-computed)
**Instruction:
**Time: 50ns
*Test d: Time required to ^(1/2) a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 76ns

==== Sine (Test 14) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 16-bit number (a short).
*Test a: Time required to take the sine of a constant short (may be pre-computed)
**Instruction:
**Time: 13014ns
*Test b: Time required to take the sine of a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 13824ns

==== Cosine (Test 15) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 16-bit number (a short).
*Test a: Time required to take the cosine of a constant short (may be pre-computed)
**Instruction:
**Time: 12174ns
*Test b: Time required to take the cosine of a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 12924ns

===int Performance===
----
An int data type, in ANSI C, is a value that holds 4 bytes, or 32 bits. This corresponds to a range of 0 to 4294967295 (2^32 - 1). If the variable is signed (negative), then the range is from -2147483647 to 2147483647 (-2^31 + 1 to 2^31 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 16) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (an int) from another 32-bit number (an int).
*Test a: Time required to subtract two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to subtract two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 64ns

==== Addition (Test 17) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (an int) to another 32-bit number (an int).
*Test a: Time required to add two constant ints (may be pre-computed)
**Instruction:
**Time: 26ns
*Test b: Time required to add two random ints (guaranteed not to be pre-comp)
**Instructions:
**Time: 60ns

==== Multiplication (Test 18) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (an int) by another 32-bit number (an int).
*Test a: Time required to multiply two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to multiply two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 86ns

==== Division (Test 19) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (an int) by another 32-bit number (an int).
*Test a: Time required to divide two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to divide two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 486s

==== Square Root (Test 20) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (an int). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant int (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to sqrt() a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 8737ns
*Test c: Time required to ^(1/2) a constant int (may be pre-computed)
**Instruction:
**Time: 88ns
*Test d: Time required to ^(1/2) a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 74ns

==== Sine (Test 21) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (an int).
*Test a: Time required to take the sine of a constant int (may be pre-computed)
**Instruction:
**Time: 19488ns
*Test b: Time required to take the sine of a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 18988ns

==== Cosine (Test 22) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (an int).
*Test a: Time required to take the cosine of a constant int (may be pre-computed)
**Instruction:
**Time: 20324ns
*Test b: Time required to take the cosine of a random int (guaranteed not to be pre-comp)
**Instruction:
**Time: 19837ns

===long long Performance===
----
An long long data type, in ANSI C, is a value that holds 8 bytes, or 64 bits. This corresponds to a range of 0 to 1.84467441 × 10^19 (2^64 - 1). If the variable is signed (negative), then the range is from -9.22337204 × 10^18 to 9.22337204 × 10^18 (-2^63 + 1 to 2^63 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 23) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a long long) from another 64-bit number (a long long).
*Test a: 186ns
*Test b: 150ns

==== Addition (Test 24) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 64-bit number (a long long) to another 64-bit number (a long long).
*Test a: 88ns
*Test b: 200ns

==== Multiplication (Test 25) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: 74ns
*Test b: 398ns

==== Division (Test 26) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: 74ns
*Test b: 1724ns

==== Square Root (Test 27) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a long long). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 87ns
*Test b: 16311ns
*Test c: 188ns
*Test d: 74ns

==== Sine (Test 28) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a long long).
*Test a: 23837ns
*Test b: 29898ns

==== Cosine (Test 29) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a long long).
*Test a: 24611ns
*Test b: 30623ns

===float Performance===
----
==== Subtraction (Test 30) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (a float) from another 32-bit number (a float).
*Test a: 100ns
*Test b: 900ns

==== Addition (Test 31) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (a float) to another 32-bit number (a float).
*Test a: 124ns
*Test b: 1024ns

==== Multiplication (Test 32) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (a float) by another 32-bit number (a float).
*Test a: 124ns
*Test b: 736ns

==== Division (Test 33) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (a float) by another 32-bit number (a float).
*Test a: 99ns
*Test b: 1674ns

==== Square Root (Test 34) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (a float). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 99ns
*Test b: 8636ns
*Test c: N/A
*Test d: N/A

==== Sine (Test 35) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (a float).
*Test a: 19574ns
*Test b: 19562ns

==== Cosine (Test 36) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (a float).
*Test a: 20311ns
*Test b: 20297

===double Performance===
----
==== Subtraction (Test 37) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a double) from another 8-bit number (a double).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 199 ns
* Test (b): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 38) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to add one 64-bit number (a double) to another 64-bit number (a double).
* Test (a): Time required to add two constant doubles (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 199 ns
* Test (c): Time required to add of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 1236 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 39) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a double) by another 64-bit number (a double).
* Test (a): Time required to multiply two constant doubles (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 188 ns
* Test (b): Time required to multiply of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 1438 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 40) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a double) by another 64-bit number (a double).
* Test (a): Time required to divide two constant doubles (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 187 ns
* Test (b): Time required to divide of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: 3184 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Square Root (Test 41) ====
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a double). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 188ns
*Test b: 7998ns
*Test c: N/A
*Test d: N/A

==== Sine (Test 42) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a double).
*Test a: 20299ns
*Test b: 20624ns

==== Cosine (Test 43) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a double).
*Test a: 19762ns
*Test b: 20011ns

== Code ==

===Test 1===
This is the first test.

===Test 2===
This is the second test.

Blah blah blah, I would really like to be watching the super bowl right about now. /sigh.

PIC32MX: Benchmarking Mathematical Operations

2010-02-16T07:50:52Z

MaxWiller:

== Original Assignment ==

'''Do not erase this section!'''

Your assignment is to empirically test how long it takes to perform add, subtract, multiply, divide, sqrt, sin, and cos operations with the 80 MHz PIC32460F512L and our standard code optimization setting. You will do these tests with chars (8-bit integers), shorts (16-bit), integers (32-bit), long long integers (64-bit), floats (32-bit single precision floating point), and double (64-bit double-precision floating point). The integers can be unsigned or signed. Your end result will be a table with the operation on one axis (likely the horizontal axis) and the kind of variable on the other axis, and each cell of the table will have a normalized duration for the operation. The time will be normalized by the fastest operation, so the smallest number in the table will be 1.00. All other numbers will indicate how many times longer that operation takes. All numbers will have two decimal places, e.g., 2.57 or 24.72. You will also give the time that 1.00 corresponds to in nanoseconds.

Since bit-shifting left and right correspond to a version of multiplying and dividing, you should also include the operations >>1 and >>4 and <<1 and <<4. (If the results are identical, you can eliminate shift left from your table.)

To generate this table, you can set an output bit low before the operation, then high immediately after the operation, and measure the time on an oscilloscope. Two things to consider: (1) Time a single operation, over and over, with a short delay between the operation. This should create a pulse train on your oscilloscope. Can you get an accurate estimate of the time this way? You could also try doing five or ten operations between changing the digital output. See if this gives the same estimate. (This estimate might be more accurate as you are essentially averaging over a number of operations.) Avoid using arrays and for loops in your test, as indexing arrays and running the loop each take time. (2) Make sure the compiler doesn't compute the results in advance. You could try testing operations with numbers generated randomly (don't time this operation!) vs. numbers that you just type in manually to make sure that both are giving you the same result.

== Overview ==

We were tasked with determining the real-time cost (measured in nanoseconds) of performing seven basic mathematical operations with each one of the six commonly used ANSI C data types.

The mathematical operations we tested were:
* subtraction
* addition
* multiplication
* division
* square root
* sine
* cosine

The six data types we tested each operation on were:
* char
* short
* integer
* long long
* float
* double

Our testing procedure was simple: throw an output pin high on the NU32 development board, perform a mathematical operation with a given data type, and then pull the same pin low.

Placing the above three steps in an infinite while loop afforded us the opportunity to use an oscilloscope to measure the duration between each high-low pair in the output waveform. After subtracting the time it took for the PIC to raise and lower the voltage on the output pin (something we previously measured), we were able to determine the amount of time required for the PIC32 chip to execute an operation with a high level of accuracy.

With seven operations to perform on six different data types, we created the following table to help us assign and keep track of the various tests we planned to run:

{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! char (8-bit) !! short (16-bit) !! int (32-bit) !! long long (64-bit) !! float (32-bit) !! double (64-bit)
|-
! subtraction
| Test 2 || Test 9 || Test 16 || Test 23 || Test 30 || Test 37
|-
! addition
| Test 3 || Test 10 || Test 17 || Test 24 || Test 31 || Test 38
|-
! multiplication
| Test 4 || Test 11 || Test 18 || Test 25 || Test 32 || Test 39
|-
! division
| Test 5 || Test 12 || Test 19 || Test 26 || Test 33 || Test 40
|-
! square root
| Test 6 || Test 13 || Test 20 || Test 27 || Test 34 || Test 41
|-
! sine
| Test 7 || Test 14 || Test 21 || Test 28 || Test 35 || Test 42
|-
! cosine
| Test 8 || Test 15 || Test 22 || Test 29 || Test 36 || Test 43
|}

Several tests contained multiple procedures that explored various ways to carry out a given mathematical operation on a given data type. For example, in the multiplication tests, not only did we test the traditional multiplication operator (*), but also the bitwise left shift operator (<<). Our goal was to find out if one particular operator was faster than the other. Similarly, we also included procedures that performed the above operations on hard-coded numbers (such as 347) as well as randomly chosen numbers stored in variables (such as 'random_int1'). We wanted to ensure that the compiler didn't compute the results of each operation in advance. While pre-compiling can indeed afford welcome increases in execution time, situations in which the compiler can't optimize the operations ahead of time (for example, situations where the data to be operated on is not known in advance) are still common occurrences and are worth benchmarking.

Accordingly, several tests contain multiple procedures that not only account for multiple methods of performing a particular operation, but multiple sets of numbers to perform those operations on.

Test 1 was used to determine the duration required for the PIC32 to throw a pin high and pull a pin low, while Tests 2 through 43 were used to measure the actual performance of each operation and data-type pair.

== Results ==
Below is the quick summary of the testing results comparing each data type and each operation. All results are normalized to 60ns (1.00 = 60ns).
{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! Subtraction !! Addition !! Multiplication !! Division !! Square Root !! Sine !! Cosine !!
|-
! Char
| 1.87 || 1.65 || 2.28 || N/A || 34.78 || 116.03 || 98.93
|-
! Short
| 1.03 || 1.67 || 1.47 || 5.00 || 144.57 || 230.40 || 215.40
|-
! Int
| 1.07 || 1.00 || 1.43 || 8.10 || 145.62 || 316.43 || 330.62
|-
! Long Long
| 2.50 || 3.33 || 6.63 || 28.73 || 271.85 || 498.30 || 510.38
|-
! Float
| 15.00 || 17.07 || 12.27 || 27.90 || 143.93 || 326.03 || 338.28
|-
! Double
| 26.00 || 20.60 || 23.97 || 53.07 || 133.30 || 343.73 || 333.52

|}
Below are the results of each particular test we performed, coupled with a short explanation for each result.

=== Basic Timing Constants (Test 1) ===
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to push a given output pin high and pull the same pin low.
* Test (a): Time required to throw an output pin high
** Instruction: <code>PIN_A2 = 1;</code>
** Time: 63 ns
* Test (b): Time required to pull an output pin low
** Instruction: <code>PIN_A2 = 0;</code>
** Time: 63 ns
* Test (c): Time required to execute 1 empty while loop cycle
** Instruction: <code>while(1){}</code>
** Time: 23 ns

=== char Performance ===
----
A <code>char</code> data type, in ANSI C, is a value holding one byte, or one character code. The actual number of bits in a char in a particular implementation is documented as CHAR_BIT in that implementation's <code>limits.h</code> file. In practice, it is almost always 8 bits, corresponding to a decimal range of 0 to 255 inclusive. Unless otherwise noted, all (a) benchmarks are operations on two predefined (and mot likely pre-computed) ASCII letters, all (b) benchmarks are operations on two predefined (and most likely pre-computed) numbers in the range of 0 to 255, and all (c) benchmarks are operations on two random (and most likely '''not''' pre-computed) numbers. These multiple benchmarks per test exist to illustrate the differences in execution time between pre-compiled operations and operations the PIC must perform in real time.

==== Subtraction (Test 2) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 8-bit number (a char) from another 8-bit number (a char).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 50 ns
* Test (b): Time required to subtract two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 100-2;</code>
** Time: 50 ns
* Test (c): Time required to subtract two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 3) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 8-bit number (a char) to another 8-bit number (a char).
* Test (a): Time required to add two constant chars (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 50 ns
* Test (b): Time required to add two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 97+1;</code>
** Time: 50 ns
* Test (c): Time required to add two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 99 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 4) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to multiply two constant chars (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 49 ns
* Test (b): Time required to multiply two ints cast into a char (may be pre-computed)
** Instruction: <code>ascii_200 = 100*2;</code>
** Time: 48 ns
* Test (c): Time required to multiply of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 137 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 5) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to divide two constant chars (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 48 ns
* Test (b): Time required to divide two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = 100/2;</code>
** Time: 50 ns
* Test (c): Time required to divide two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: N/A

<nowiki>*</nowiki> We had great difficulty in trying to test this particular operation. After some research with an oscilloscope and voltmeter, it seems that the PIC32 is not capable of dividing chars in this way. More specifically, every time the PIC32 attempts to divide one char by another, all output pins are immediately grounded. We've tested this code in other C environments, and it works as expected, so the error must either lie somewhere within our specific PICs (which would be very unlikely - we tested 3) or the silicon architecture of the PIC32 itself (sill unlikely, but given the number of PICs we tested, more probable). If you absolutely need to divide chars, cast them to ints first, perform your division, then cast them back to chars.

==== Square Root (Test 6) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (c): Time required to pull an output pin low
| caption3 = Caption3

| image4 = test1-whileloop-onoff-timetogohigh.png
| alt4 = Test (d): Time required to throw an output pin high
| caption4 = Caption4

| image5 = test1-whileloop-onoff-timetogolow.png
| alt5 = Test (e): Time required to pull an output pin low
| caption5 = Caption5

| image6 = test1-whileloop-onoff-pair.png
| alt6 = Test (f): Time required to pull an output pin low
| caption6 = Caption6
}}
This test determines the length of time required by the PIC32 chip to square root one 8-bit number (a char). Benchmarks (a) through (c) use the <code>sqrt()</code> function while benchmarks (d) through (f) raise the operands to the 1/2 power.
* Test (a): Time required to sqrt() a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sqrt('u');</code>
** Time: 48 ns
* Test (b): Time required to sqrt() an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = sqrt(100);</code>
** Time: 48 ns
* Test (c): Time required to sqrt() a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sqrt(random_char1);</code>
** Time: 2087 ns
* Test (d): Time required to ^(1/2) a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = ('u')^(1/2);</code>
** Time: 48 ns
* Test (e): Time required to ^(1/2) an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = (100)^(1/2);</code>
** Time: 48 ns
* Test (f): Time required to ^(1/2) a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = (random_char2)^(1/2);</code>*
** Time: 75 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Sine (Test 7) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the sine of an 8-bit number (a char).
* Test (a): Time required to take the sine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sin('K');</code>
** Time: 9963 ns
* Test (b): Time required to take the sine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = sin(50);</code>
** Time: 9550 ns
* Test (c): Time required to take the sine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sin(larger);</code>*
** Time: 6962 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Cosine (Test 8) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the cosine of an 8-bit number (a char).
* Test (a): Time required to take the cosine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = cos('K');</code>
** Time: 9111 ns
* Test (b): Time required to take the cosine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = cos(50);</code>
** Time: 8724 ns
* Test (c): Time required to take the cosine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = cos(larger);</code>*
** Time: 5936 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

=== short Performance ===
----
A short data type, in ANSI C, is a value that holds 2 bytes, or 16 bits. This corresponds to a range of 0 to 65535 (2^16 - 1). If the variable is signed (negative), then the range is from -32767 to 32767 (-2^15 + 1 to 2^15 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 9) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 16-bit number (a short) from another 16-bit number (a short).
*Test a: Time required to subtract two constant shorts (may be pre-computed)
** Instruction:
** Time: 25ns
*Test b: Time required to subtract two random chars (guaranteed not to be pre-comp)
** Instruction:
** Time: 62ns

==== Addition (Test 10) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 16-bit number (a short) to another 16-bit number (a short).
*Test a: Time required to add two constant shorts (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to add two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 100ns

==== Multiplication (Test 11) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to multiply two constant shorts (may be pre-computed)
**Instruction:
**Time: 24ns
*Test b: Time required to multiply two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 88ns

==== Division (Test 12) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to divide two constant shorts (may be pre-computed)
**Instruction:
**Time: 28ns
*Test b: Time required to divide two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 300ns

==== Square Root (Test 13) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 16-bit number (a short). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant short (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to sqrt() a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 8674ns
*Test c: Time required to ^(1/2) a constant short (may be pre-computed)
**Instruction:
**Time: 50ns
*Test d: Time required to ^(1/2) a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 76ns

==== Sine (Test 14) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 16-bit number (a short).
*Test a: Time required to take the sine of a constant short (may be pre-computed)
**Instruction:
**Time: 13014ns
*Test b: Time required to take the sine of a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 13824ns

==== Cosine (Test 15) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 16-bit number (a short).
*Test a: Time required to take the cosine of a constant short (may be pre-computed)
**Instruction:
**Time: 12174ns
*Test b: Time required to take the cosine of a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 12924ns

===int Performance===
----
An int data type, in ANSI C, is a value that holds 4 bytes, or 32 bits. This corresponds to a range of 0 to 4294967295 (2^32 - 1). If the variable is signed (negative), then the range is from -2147483647 to 2147483647 (-2^31 + 1 to 2^31 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 16) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (an int) from another 32-bit number (an int).
*Test a: Time required to subtract two constant ints (may be pre-computed)
**Instruction:
**Time: 38ns
*Test b: Time required to subtract two random ints (guaranteed not to be pre-comp)
**Instruction:
**Time: 64ns

==== Addition (Test 17) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (an int) to another 32-bit number (an int).
*Test a: Time required to add two constant ints (may be pre-computed)
**Instruction:
**Time: 26ns
*Test b: Time required to add two random ints (guaranteed not to be pre-comp)
**Instructions:
**Time: 60ns

==== Multiplication (Test 18) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (an int) by another 32-bit number (an int).
*Test a: 38ns
*Test b: 86ns

==== Division (Test 19) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (an int) by another 32-bit number (an int).
*Test a: 38ns
*Test b: 486s

==== Square Root (Test 20) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (an int). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 50ns
*Test b: 8737ns
*Test c: 88ns
*Test d: 74ns

==== Sine (Test 21) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (an int).
*Test a: 19488ns
*Test b: 18988ns

==== Cosine (Test 22) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (an int).
*Test a: 20324ns
*Test b: 19837ns

===long long Performance===
----
An long long data type, in ANSI C, is a value that holds 8 bytes, or 64 bits. This corresponds to a range of 0 to 1.84467441 × 10^19 (2^64 - 1). If the variable is signed (negative), then the range is from -9.22337204 × 10^18 to 9.22337204 × 10^18 (-2^63 + 1 to 2^63 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 23) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a long long) from another 64-bit number (a long long).
*Test a: 186ns
*Test b: 150ns

==== Addition (Test 24) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 64-bit number (a long long) to another 64-bit number (a long long).
*Test a: 88ns
*Test b: 200ns

==== Multiplication (Test 25) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: 74ns
*Test b: 398ns

==== Division (Test 26) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: 74ns
*Test b: 1724ns

==== Square Root (Test 27) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a long long). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 87ns
*Test b: 16311ns
*Test c: 188ns
*Test d: 74ns

==== Sine (Test 28) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a long long).
*Test a: 23837ns
*Test b: 29898ns

==== Cosine (Test 29) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a long long).
*Test a: 24611ns
*Test b: 30623ns

===float Performance===
----
==== Subtraction (Test 30) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (a float) from another 32-bit number (a float).
*Test a: 100ns
*Test b: 900ns

==== Addition (Test 31) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (a float) to another 32-bit number (a float).
*Test a: 124ns
*Test b: 1024ns

==== Multiplication (Test 32) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (a float) by another 32-bit number (a float).
*Test a: 124ns
*Test b: 736ns

==== Division (Test 33) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (a float) by another 32-bit number (a float).
*Test a: 99ns
*Test b: 1674ns

==== Square Root (Test 34) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (a float). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 99ns
*Test b: 8636ns
*Test c: N/A
*Test d: N/A

==== Sine (Test 35) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (a float).
*Test a: 19574ns
*Test b: 19562ns

==== Cosine (Test 36) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (a float).
*Test a: 20311ns
*Test b: 20297

===double Performance===
----
==== Subtraction (Test 37) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a double) from another 8-bit number (a double).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 199 ns
* Test (b): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 38) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to add one 64-bit number (a double) to another 64-bit number (a double).
* Test (a): Time required to add two constant doubles (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 199 ns
* Test (c): Time required to add of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 1236 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 39) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a double) by another 64-bit number (a double).
* Test (a): Time required to multiply two constant doubles (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 188 ns
* Test (b): Time required to multiply of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 1438 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 40) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a double) by another 64-bit number (a double).
* Test (a): Time required to divide two constant doubles (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 187 ns
* Test (b): Time required to divide of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: 3184 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Square Root (Test 41) ====
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a double). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 188ns
*Test b: 7998ns
*Test c: N/A
*Test d: N/A

==== Sine (Test 42) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a double).
*Test a: 20299ns
*Test b: 20624ns

==== Cosine (Test 43) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a double).
*Test a: 19762ns
*Test b: 20011ns

== Code ==

===Test 1===
This is the first test.

===Test 2===
This is the second test.

Blah blah blah, I would really like to be watching the super bowl right about now. /sigh.

PIC32MX: Benchmarking Mathematical Operations

2010-02-16T07:46:40Z

MaxWiller:

== Original Assignment ==

'''Do not erase this section!'''

Your assignment is to empirically test how long it takes to perform add, subtract, multiply, divide, sqrt, sin, and cos operations with the 80 MHz PIC32460F512L and our standard code optimization setting. You will do these tests with chars (8-bit integers), shorts (16-bit), integers (32-bit), long long integers (64-bit), floats (32-bit single precision floating point), and double (64-bit double-precision floating point). The integers can be unsigned or signed. Your end result will be a table with the operation on one axis (likely the horizontal axis) and the kind of variable on the other axis, and each cell of the table will have a normalized duration for the operation. The time will be normalized by the fastest operation, so the smallest number in the table will be 1.00. All other numbers will indicate how many times longer that operation takes. All numbers will have two decimal places, e.g., 2.57 or 24.72. You will also give the time that 1.00 corresponds to in nanoseconds.

Since bit-shifting left and right correspond to a version of multiplying and dividing, you should also include the operations >>1 and >>4 and <<1 and <<4. (If the results are identical, you can eliminate shift left from your table.)

To generate this table, you can set an output bit low before the operation, then high immediately after the operation, and measure the time on an oscilloscope. Two things to consider: (1) Time a single operation, over and over, with a short delay between the operation. This should create a pulse train on your oscilloscope. Can you get an accurate estimate of the time this way? You could also try doing five or ten operations between changing the digital output. See if this gives the same estimate. (This estimate might be more accurate as you are essentially averaging over a number of operations.) Avoid using arrays and for loops in your test, as indexing arrays and running the loop each take time. (2) Make sure the compiler doesn't compute the results in advance. You could try testing operations with numbers generated randomly (don't time this operation!) vs. numbers that you just type in manually to make sure that both are giving you the same result.

== Overview ==

We were tasked with determining the real-time cost (measured in nanoseconds) of performing seven basic mathematical operations with each one of the six commonly used ANSI C data types.

The mathematical operations we tested were:
* subtraction
* addition
* multiplication
* division
* square root
* sine
* cosine

The six data types we tested each operation on were:
* char
* short
* integer
* long long
* float
* double

Our testing procedure was simple: throw an output pin high on the NU32 development board, perform a mathematical operation with a given data type, and then pull the same pin low.

Placing the above three steps in an infinite while loop afforded us the opportunity to use an oscilloscope to measure the duration between each high-low pair in the output waveform. After subtracting the time it took for the PIC to raise and lower the voltage on the output pin (something we previously measured), we were able to determine the amount of time required for the PIC32 chip to execute an operation with a high level of accuracy.

With seven operations to perform on six different data types, we created the following table to help us assign and keep track of the various tests we planned to run:

{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! char (8-bit) !! short (16-bit) !! int (32-bit) !! long long (64-bit) !! float (32-bit) !! double (64-bit)
|-
! subtraction
| Test 2 || Test 9 || Test 16 || Test 23 || Test 30 || Test 37
|-
! addition
| Test 3 || Test 10 || Test 17 || Test 24 || Test 31 || Test 38
|-
! multiplication
| Test 4 || Test 11 || Test 18 || Test 25 || Test 32 || Test 39
|-
! division
| Test 5 || Test 12 || Test 19 || Test 26 || Test 33 || Test 40
|-
! square root
| Test 6 || Test 13 || Test 20 || Test 27 || Test 34 || Test 41
|-
! sine
| Test 7 || Test 14 || Test 21 || Test 28 || Test 35 || Test 42
|-
! cosine
| Test 8 || Test 15 || Test 22 || Test 29 || Test 36 || Test 43
|}

Several tests contained multiple procedures that explored various ways to carry out a given mathematical operation on a given data type. For example, in the multiplication tests, not only did we test the traditional multiplication operator (*), but also the bitwise left shift operator (<<). Our goal was to find out if one particular operator was faster than the other. Similarly, we also included procedures that performed the above operations on hard-coded numbers (such as 347) as well as randomly chosen numbers stored in variables (such as 'random_int1'). We wanted to ensure that the compiler didn't compute the results of each operation in advance. While pre-compiling can indeed afford welcome increases in execution time, situations in which the compiler can't optimize the operations ahead of time (for example, situations where the data to be operated on is not known in advance) are still common occurrences and are worth benchmarking.

Accordingly, several tests contain multiple procedures that not only account for multiple methods of performing a particular operation, but multiple sets of numbers to perform those operations on.

Test 1 was used to determine the duration required for the PIC32 to throw a pin high and pull a pin low, while Tests 2 through 43 were used to measure the actual performance of each operation and data-type pair.

== Results ==
Below is the quick summary of the testing results comparing each data type and each operation. All results are normalized to 60ns (1.00 = 60ns).
{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! Subtraction !! Addition !! Multiplication !! Division !! Square Root !! Sine !! Cosine !!
|-
! Char
| 1.87 || 1.65 || 2.28 || N/A || 34.78 || 116.03 || 98.93
|-
! Short
| 1.03 || 1.67 || 1.47 || 5.00 || 144.57 || 230.40 || 215.40
|-
! Int
| 1.07 || 1.00 || 1.43 || 8.10 || 145.62 || 316.43 || 330.62
|-
! Long Long
| 2.50 || 3.33 || 6.63 || 28.73 || 271.85 || 498.30 || 510.38
|-
! Float
| 15.00 || 17.07 || 12.27 || 27.90 || 143.93 || 326.03 || 338.28
|-
! Double
| 26.00 || 20.60 || 23.97 || 53.07 || 133.30 || 343.73 || 333.52

|}
Below are the results of each particular test we performed, coupled with a short explanation for each result.

=== Basic Timing Constants (Test 1) ===
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to push a given output pin high and pull the same pin low.
* Test (a): Time required to throw an output pin high
** Instruction: <code>PIN_A2 = 1;</code>
** Time: 63 ns
* Test (b): Time required to pull an output pin low
** Instruction: <code>PIN_A2 = 0;</code>
** Time: 63 ns
* Test (c): Time required to execute 1 empty while loop cycle
** Instruction: <code>while(1){}</code>
** Time: 23 ns

=== char Performance ===
----
A <code>char</code> data type, in ANSI C, is a value holding one byte, or one character code. The actual number of bits in a char in a particular implementation is documented as CHAR_BIT in that implementation's <code>limits.h</code> file. In practice, it is almost always 8 bits, corresponding to a decimal range of 0 to 255 inclusive. Unless otherwise noted, all (a) benchmarks are operations on two predefined (and mot likely pre-computed) ASCII letters, all (b) benchmarks are operations on two predefined (and most likely pre-computed) numbers in the range of 0 to 255, and all (c) benchmarks are operations on two random (and most likely '''not''' pre-computed) numbers. These multiple benchmarks per test exist to illustrate the differences in execution time between pre-compiled operations and operations the PIC must perform in real time.

==== Subtraction (Test 2) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 8-bit number (a char) from another 8-bit number (a char).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 50 ns
* Test (b): Time required to subtract two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 100-2;</code>
** Time: 50 ns
* Test (c): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 3) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 8-bit number (a char) to another 8-bit number (a char).
* Test (a): Time required to add two constant chars (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 50 ns
* Test (b): Time required to add two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 97+1;</code>
** Time: 50 ns
* Test (c): Time required to add of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 99 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 4) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to multiply two constant chars (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 49 ns
* Test (b): Time required to multiply two ints cast into a char (may be pre-computed)
** Instruction: <code>ascii_200 = 100*2;</code>
** Time: 48 ns
* Test (c): Time required to multiply of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 137 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 5) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to divide two constant chars (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 48 ns
* Test (b): Time required to divide two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = 100/2;</code>
** Time: 50 ns
* Test (c): Time required to divide of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: N/A

<nowiki>*</nowiki> We had great difficulty in trying to test this particular operation. After some research with an oscilloscope and voltmeter, it seems that the PIC32 is not capable of dividing chars in this way. More specifically, every time the PIC32 attempts to divide one char by another, all output pins are immediately grounded. We've tested this code in other C environments, and it works as expected, so the error must either lie somewhere within our specific PICs (which would be very unlikely - we tested 3) or the silicon architecture of the PIC32 itself (sill unlikely, but given the number of PICs we tested, more probable). If you absolutely need to divide chars, cast them to ints first, perform your division, then cast them back to chars.

==== Square Root (Test 6) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (c): Time required to pull an output pin low
| caption3 = Caption3

| image4 = test1-whileloop-onoff-timetogohigh.png
| alt4 = Test (d): Time required to throw an output pin high
| caption4 = Caption4

| image5 = test1-whileloop-onoff-timetogolow.png
| alt5 = Test (e): Time required to pull an output pin low
| caption5 = Caption5

| image6 = test1-whileloop-onoff-pair.png
| alt6 = Test (f): Time required to pull an output pin low
| caption6 = Caption6
}}
This test determines the length of time required by the PIC32 chip to square root one 8-bit number (a char). Benchmarks (a) through (c) use the <code>sqrt()</code> function while benchmarks (d) through (f) raise the operands to the 1/2 power.
* Test (a): Time required to sqrt() a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sqrt('u');</code>
** Time: 48 ns
* Test (b): Time required to sqrt() an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = sqrt(100);</code>
** Time: 48 ns
* Test (c): Time required to sqrt() a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sqrt(random_char1);</code>
** Time: 2087 ns
* Test (d): Time required to ^(1/2) a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = ('u')^(1/2);</code>
** Time: 48 ns
* Test (e): Time required to ^(1/2) an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = (100)^(1/2);</code>
** Time: 48 ns
* Test (f): Time required to ^(1/2) a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = (random_char2)^(1/2);</code>*
** Time: 75 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Sine (Test 7) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the sine of an 8-bit number (a char).
* Test (a): Time required to take the sine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sin('K');</code>
** Time: 9963 ns
* Test (b): Time required to take the sine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = sin(50);</code>
** Time: 9550 ns
* Test (c): Time required to take the sine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sin(larger);</code>*
** Time: 6962 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Cosine (Test 8) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the cosine of an 8-bit number (a char).
* Test (a): Time required to take the cosine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = cos('K');</code>
** Time: 9111 ns
* Test (b): Time required to take the cosine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = cos(50);</code>
** Time: 8724 ns
* Test (c): Time required to take the cosine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = cos(larger);</code>*
** Time: 5936 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

=== short Performance ===
----
A short data type, in ANSI C, is a value that holds 2 bytes, or 16 bits. This corresponds to a range of 0 to 65535 (2^16 - 1). If the variable is signed (negative), then the range is from -32767 to 32767 (-2^15 + 1 to 2^15 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 9) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 16-bit number (a short) from another 16-bit number (a short).
*Test a: Time required to subtract two constant shorts (may be pre-computed)
** Instruction:
** Time: 25ns
*Test b: Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction:
** Time: 62ns

==== Addition (Test 10) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 16-bit number (a short) to another 16-bit number (a short).
*Test a: Time required to add two constant shorts (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to add of two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 100ns

==== Multiplication (Test 11) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to multiply two constant shorts (may be pre-computed)
**Instruction:
**Time: 24ns
*Test b: Time required to multiply of two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 88ns

==== Division (Test 12) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to divide two constant shorts (may be pre-computed)
**Instruction:
**Time: 28ns
*Test b: Time required to divide of two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 300ns

==== Square Root (Test 13) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 16-bit number (a short). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: Time required to sqrt() a constant short (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to sqrt() a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 8674ns
*Test c: Time required to ^(1/2) a constant short (may be pre-computed)
**Instruction:
**Time: 50ns
*Test d: Time required to ^(1/2) a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 76ns

==== Sine (Test 14) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 16-bit number (a short).
*Test a: Time required to take the sine of a constant short (may be pre-computed)
**Instruction:
**Time: 13014ns
*Test b: Time required to take the sine of a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 13824ns

==== Cosine (Test 15) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 16-bit number (a short).
*Test a: Time required to take the cosine of a constant short (may be pre-computed)
**Instruction:
**Time: 12174ns
*Test b: Time required to take the cosine of a random short (guaranteed not to be pre-comp)
**Instruction:
**Time: 12924ns

===int Performance===
----
An int data type, in ANSI C, is a value that holds 4 bytes, or 32 bits. This corresponds to a range of 0 to 4294967295 (2^32 - 1). If the variable is signed (negative), then the range is from -2147483647 to 2147483647 (-2^31 + 1 to 2^31 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 16) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (an int) from another 32-bit number (an int).
*Test a: 38ns
*Test b: 64ns

==== Addition (Test 17) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (an int) to another 32-bit number (an int).
*Test a: 26ns
*Test b: 60ns

==== Multiplication (Test 18) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (an int) by another 32-bit number (an int).
*Test a: 38ns
*Test b: 86ns

==== Division (Test 19) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (an int) by another 32-bit number (an int).
*Test a: 38ns
*Test b: 486s

==== Square Root (Test 20) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (an int). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 50ns
*Test b: 8737ns
*Test c: 88ns
*Test d: 74ns

==== Sine (Test 21) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (an int).
*Test a: 19488ns
*Test b: 18988ns

==== Cosine (Test 22) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (an int).
*Test a: 20324ns
*Test b: 19837ns

===long long Performance===
----
An long long data type, in ANSI C, is a value that holds 8 bytes, or 64 bits. This corresponds to a range of 0 to 1.84467441 × 10^19 (2^64 - 1). If the variable is signed (negative), then the range is from -9.22337204 × 10^18 to 9.22337204 × 10^18 (-2^63 + 1 to 2^63 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 23) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a long long) from another 64-bit number (a long long).
*Test a: 186ns
*Test b: 150ns

==== Addition (Test 24) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 64-bit number (a long long) to another 64-bit number (a long long).
*Test a: 88ns
*Test b: 200ns

==== Multiplication (Test 25) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: 74ns
*Test b: 398ns

==== Division (Test 26) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: 74ns
*Test b: 1724ns

==== Square Root (Test 27) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a long long). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 87ns
*Test b: 16311ns
*Test c: 188ns
*Test d: 74ns

==== Sine (Test 28) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a long long).
*Test a: 23837ns
*Test b: 29898ns

==== Cosine (Test 29) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a long long).
*Test a: 24611ns
*Test b: 30623ns

===float Performance===
----
==== Subtraction (Test 30) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (a float) from another 32-bit number (a float).
*Test a: 100ns
*Test b: 900ns

==== Addition (Test 31) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (a float) to another 32-bit number (a float).
*Test a: 124ns
*Test b: 1024ns

==== Multiplication (Test 32) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (a float) by another 32-bit number (a float).
*Test a: 124ns
*Test b: 736ns

==== Division (Test 33) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (a float) by another 32-bit number (a float).
*Test a: 99ns
*Test b: 1674ns

==== Square Root (Test 34) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (a float). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 99ns
*Test b: 8636ns
*Test c: N/A
*Test d: N/A

==== Sine (Test 35) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (a float).
*Test a: 19574ns
*Test b: 19562ns

==== Cosine (Test 36) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (a float).
*Test a: 20311ns
*Test b: 20297

===double Performance===
----
==== Subtraction (Test 37) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a double) from another 8-bit number (a double).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 199 ns
* Test (b): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 38) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to add one 64-bit number (a double) to another 64-bit number (a double).
* Test (a): Time required to add two constant doubles (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 199 ns
* Test (c): Time required to add of two random doubles (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 1236 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 39) ====
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a double) by another 64-bit number (a double).
*Test a: 188ns
*Test b: 1438ns

==== Division (Test 40) ====
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a double) by another 64-bit number (a double).
*Test a: 187ns
*Test b: 3184ns

==== Square Root (Test 41) ====
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a double). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 188ns
*Test b: 7998ns
*Test c: N/A
*Test d: N/A

==== Sine (Test 42) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a double).
*Test a: 20299ns
*Test b: 20624ns

==== Cosine (Test 43) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a double).
*Test a: 19762ns
*Test b: 20011ns

== Code ==

===Test 1===
This is the first test.

===Test 2===
This is the second test.

Blah blah blah, I would really like to be watching the super bowl right about now. /sigh.

PIC32MX: Benchmarking Mathematical Operations

2010-02-16T07:40:09Z

MaxWiller:

== Original Assignment ==

'''Do not erase this section!'''

Your assignment is to empirically test how long it takes to perform add, subtract, multiply, divide, sqrt, sin, and cos operations with the 80 MHz PIC32460F512L and our standard code optimization setting. You will do these tests with chars (8-bit integers), shorts (16-bit), integers (32-bit), long long integers (64-bit), floats (32-bit single precision floating point), and double (64-bit double-precision floating point). The integers can be unsigned or signed. Your end result will be a table with the operation on one axis (likely the horizontal axis) and the kind of variable on the other axis, and each cell of the table will have a normalized duration for the operation. The time will be normalized by the fastest operation, so the smallest number in the table will be 1.00. All other numbers will indicate how many times longer that operation takes. All numbers will have two decimal places, e.g., 2.57 or 24.72. You will also give the time that 1.00 corresponds to in nanoseconds.

Since bit-shifting left and right correspond to a version of multiplying and dividing, you should also include the operations >>1 and >>4 and <<1 and <<4. (If the results are identical, you can eliminate shift left from your table.)

To generate this table, you can set an output bit low before the operation, then high immediately after the operation, and measure the time on an oscilloscope. Two things to consider: (1) Time a single operation, over and over, with a short delay between the operation. This should create a pulse train on your oscilloscope. Can you get an accurate estimate of the time this way? You could also try doing five or ten operations between changing the digital output. See if this gives the same estimate. (This estimate might be more accurate as you are essentially averaging over a number of operations.) Avoid using arrays and for loops in your test, as indexing arrays and running the loop each take time. (2) Make sure the compiler doesn't compute the results in advance. You could try testing operations with numbers generated randomly (don't time this operation!) vs. numbers that you just type in manually to make sure that both are giving you the same result.

== Overview ==

We were tasked with determining the real-time cost (measured in nanoseconds) of performing seven basic mathematical operations with each one of the six commonly used ANSI C data types.

The mathematical operations we tested were:
* subtraction
* addition
* multiplication
* division
* square root
* sine
* cosine

The six data types we tested each operation on were:
* char
* short
* integer
* long long
* float
* double

Our testing procedure was simple: throw an output pin high on the NU32 development board, perform a mathematical operation with a given data type, and then pull the same pin low.

Placing the above three steps in an infinite while loop afforded us the opportunity to use an oscilloscope to measure the duration between each high-low pair in the output waveform. After subtracting the time it took for the PIC to raise and lower the voltage on the output pin (something we previously measured), we were able to determine the amount of time required for the PIC32 chip to execute an operation with a high level of accuracy.

With seven operations to perform on six different data types, we created the following table to help us assign and keep track of the various tests we planned to run:

{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! char (8-bit) !! short (16-bit) !! int (32-bit) !! long long (64-bit) !! float (32-bit) !! double (64-bit)
|-
! subtraction
| Test 2 || Test 9 || Test 16 || Test 23 || Test 30 || Test 37
|-
! addition
| Test 3 || Test 10 || Test 17 || Test 24 || Test 31 || Test 38
|-
! multiplication
| Test 4 || Test 11 || Test 18 || Test 25 || Test 32 || Test 39
|-
! division
| Test 5 || Test 12 || Test 19 || Test 26 || Test 33 || Test 40
|-
! square root
| Test 6 || Test 13 || Test 20 || Test 27 || Test 34 || Test 41
|-
! sine
| Test 7 || Test 14 || Test 21 || Test 28 || Test 35 || Test 42
|-
! cosine
| Test 8 || Test 15 || Test 22 || Test 29 || Test 36 || Test 43
|}

Several tests contained multiple procedures that explored various ways to carry out a given mathematical operation on a given data type. For example, in the multiplication tests, not only did we test the traditional multiplication operator (*), but also the bitwise left shift operator (<<). Our goal was to find out if one particular operator was faster than the other. Similarly, we also included procedures that performed the above operations on hard-coded numbers (such as 347) as well as randomly chosen numbers stored in variables (such as 'random_int1'). We wanted to ensure that the compiler didn't compute the results of each operation in advance. While pre-compiling can indeed afford welcome increases in execution time, situations in which the compiler can't optimize the operations ahead of time (for example, situations where the data to be operated on is not known in advance) are still common occurrences and are worth benchmarking.

Accordingly, several tests contain multiple procedures that not only account for multiple methods of performing a particular operation, but multiple sets of numbers to perform those operations on.

Test 1 was used to determine the duration required for the PIC32 to throw a pin high and pull a pin low, while Tests 2 through 43 were used to measure the actual performance of each operation and data-type pair.

== Results ==
Below is the quick summary of the testing results comparing each data type and each operation. All results are normalized to 60ns (1.00 = 60ns).
{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! Subtraction !! Addition !! Multiplication !! Division !! Square Root !! Sine !! Cosine !!
|-
! Char
| 1.87 || 1.65 || 2.28 || N/A || 34.78 || 116.03 || 98.93
|-
! Short
| 1.03 || 1.67 || 1.47 || 5.00 || 144.57 || 230.40 || 215.40
|-
! Int
| 1.07 || 1.00 || 1.43 || 8.10 || 145.62 || 316.43 || 330.62
|-
! Long Long
| 2.50 || 3.33 || 6.63 || 28.73 || 271.85 || 498.30 || 510.38
|-
! Float
| 15.00 || 17.07 || 12.27 || 27.90 || 143.93 || 326.03 || 338.28
|-
! Double
| 26.00 || 20.60 || 23.97 || 53.07 || 133.30 || 343.73 || 333.52

|}
Below are the results of each particular test we performed, coupled with a short explanation for each result.

=== Basic Timing Constants (Test 1) ===
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to push a given output pin high and pull the same pin low.
* Test (a): Time required to throw an output pin high
** Instruction: <code>PIN_A2 = 1;</code>
** Time: 63 ns
* Test (b): Time required to pull an output pin low
** Instruction: <code>PIN_A2 = 0;</code>
** Time: 63 ns
* Test (c): Time required to execute 1 empty while loop cycle
** Instruction: <code>while(1){}</code>
** Time: 23 ns

=== char Performance ===
----
A <code>char</code> data type, in ANSI C, is a value holding one byte, or one character code. The actual number of bits in a char in a particular implementation is documented as CHAR_BIT in that implementation's <code>limits.h</code> file. In practice, it is almost always 8 bits, corresponding to a decimal range of 0 to 255 inclusive. Unless otherwise noted, all (a) benchmarks are operations on two predefined (and mot likely pre-computed) ASCII letters, all (b) benchmarks are operations on two predefined (and most likely pre-computed) numbers in the range of 0 to 255, and all (c) benchmarks are operations on two random (and most likely '''not''' pre-computed) numbers. These multiple benchmarks per test exist to illustrate the differences in execution time between pre-compiled operations and operations the PIC must perform in real time.

==== Subtraction (Test 2) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 8-bit number (a char) from another 8-bit number (a char).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 50 ns
* Test (b): Time required to subtract two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 100-2;</code>
** Time: 50 ns
* Test (c): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 3) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 8-bit number (a char) to another 8-bit number (a char).
* Test (a): Time required to add two constant chars (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 50 ns
* Test (b): Time required to add two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 97+1;</code>
** Time: 50 ns
* Test (c): Time required to add of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 99 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 4) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to multiply two constant chars (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 49 ns
* Test (b): Time required to multiply two ints cast into a char (may be pre-computed)
** Instruction: <code>ascii_200 = 100*2;</code>
** Time: 48 ns
* Test (c): Time required to multiply of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 137 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 5) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to divide two constant chars (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 48 ns
* Test (b): Time required to divide two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = 100/2;</code>
** Time: 50 ns
* Test (c): Time required to divide of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: N/A

<nowiki>*</nowiki> We had great difficulty in trying to test this particular operation. After some research with an oscilloscope and voltmeter, it seems that the PIC32 is not capable of dividing chars in this way. More specifically, every time the PIC32 attempts to divide one char by another, all output pins are immediately grounded. We've tested this code in other C environments, and it works as expected, so the error must either lie somewhere within our specific PICs (which would be very unlikely - we tested 3) or the silicon architecture of the PIC32 itself (sill unlikely, but given the number of PICs we tested, more probable). If you absolutely need to divide chars, cast them to ints first, perform your division, then cast them back to chars.

==== Square Root (Test 6) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (c): Time required to pull an output pin low
| caption3 = Caption3

| image4 = test1-whileloop-onoff-timetogohigh.png
| alt4 = Test (d): Time required to throw an output pin high
| caption4 = Caption4

| image5 = test1-whileloop-onoff-timetogolow.png
| alt5 = Test (e): Time required to pull an output pin low
| caption5 = Caption5

| image6 = test1-whileloop-onoff-pair.png
| alt6 = Test (f): Time required to pull an output pin low
| caption6 = Caption6
}}
This test determines the length of time required by the PIC32 chip to square root one 8-bit number (a char). Benchmarks (a) through (c) use the <code>sqrt()</code> function while benchmarks (d) through (f) raise the operands to the 1/2 power.
* Test (a): Time required to sqrt() a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sqrt('u');</code>
** Time: 48 ns
* Test (b): Time required to sqrt() an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = sqrt(100);</code>
** Time: 48 ns
* Test (c): Time required to sqrt() a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sqrt(random_char1);</code>
** Time: 2087 ns
* Test (d): Time required to ^(1/2) a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = ('u')^(1/2);</code>
** Time: 48 ns
* Test (e): Time required to ^(1/2) an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = (100)^(1/2);</code>
** Time: 48 ns
* Test (f): Time required to ^(1/2) a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = (random_char2)^(1/2);</code>*
** Time: 75 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Sine (Test 7) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the sine of an 8-bit number (a char).
* Test (a): Time required to take the sine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sin('K');</code>
** Time: 9963 ns
* Test (b): Time required to take the sine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = sin(50);</code>
** Time: 9550 ns
* Test (c): Time required to take the sine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sin(larger);</code>*
** Time: 6962 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Cosine (Test 8) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the cosine of an 8-bit number (a char).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>ascii_25 = cos('K');</code>
** Time: 9111 ns
* Test (b): Time required to subtract two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = cos(50);</code>
** Time: 8724 ns
* Test (c): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = cos(larger);</code>*
** Time: 5936 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

=== short Performance ===
----
A short data type, in ANSI C, is a value that holds 2 bytes, or 16 bits. This corresponds to a range of 0 to 65535 (2^16 - 1). If the variable is signed (negative), then the range is from -32767 to 32767 (-2^15 + 1 to 2^15 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 9) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 16-bit number (a short) from another 16-bit number (a short).
*Test a: Time required to subtract two constant shorts (may be pre-computed)
** Instruction:
** Time: 25ns
*Test b: Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction:
** Time: 62ns

==== Addition (Test 10) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 16-bit number (a short) to another 16-bit number (a short).
*Test a: Time required to add two constant shorts (may be pre-computed)
**Instruction:
**Time: 50ns
*Test b: Time required to add of two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 100ns

==== Multiplication (Test 11) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 16-bit number (a short) by another 16-bit number (a short).
*Test a: Time required to multiply two constant shorts (may be pre-computed)
**Instruction:
**Time: 24ns
*Test b: Time required to multiply of two random shorts (guaranteed not to be pre-comp)
**Instruction:
**Time: 88ns

==== Division (Test 12) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 16-bit number (a short) by another 16-bit number (a short).
*Test a: 28ns
*Test b: 300ns

==== Square Root (Test 13) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 16-bit number (a short). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 50ns
*Test b: 8674ns
*Test c: 50ns
*Test d: 76ns

==== Sine (Test 14) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 16-bit number (a short).
*Test a: 13014ns
*Test b: 13824ns

==== Cosine (Test 15) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 16-bit number (a short).
*Test a: 12174ns
*Test b: 12924ns

===int Performance===
----
An int data type, in ANSI C, is a value that holds 4 bytes, or 32 bits. This corresponds to a range of 0 to 4294967295 (2^32 - 1). If the variable is signed (negative), then the range is from -2147483647 to 2147483647 (-2^31 + 1 to 2^31 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 16) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (an int) from another 32-bit number (an int).
*Test a: 38ns
*Test b: 64ns

==== Addition (Test 17) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (an int) to another 32-bit number (an int).
*Test a: 26ns
*Test b: 60ns

==== Multiplication (Test 18) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (an int) by another 32-bit number (an int).
*Test a: 38ns
*Test b: 86ns

==== Division (Test 19) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (an int) by another 32-bit number (an int).
*Test a: 38ns
*Test b: 486s

==== Square Root (Test 20) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (an int). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 50ns
*Test b: 8737ns
*Test c: 88ns
*Test d: 74ns

==== Sine (Test 21) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (an int).
*Test a: 19488ns
*Test b: 18988ns

==== Cosine (Test 22) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (an int).
*Test a: 20324ns
*Test b: 19837ns

===long long Performance===
----
An long long data type, in ANSI C, is a value that holds 8 bytes, or 64 bits. This corresponds to a range of 0 to 1.84467441 × 10^19 (2^64 - 1). If the variable is signed (negative), then the range is from -9.22337204 × 10^18 to 9.22337204 × 10^18 (-2^63 + 1 to 2^63 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 23) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a long long) from another 64-bit number (a long long).
*Test a: 186ns
*Test b: 150ns

==== Addition (Test 24) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 64-bit number (a long long) to another 64-bit number (a long long).
*Test a: 88ns
*Test b: 200ns

==== Multiplication (Test 25) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: 74ns
*Test b: 398ns

==== Division (Test 26) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: 74ns
*Test b: 1724ns

==== Square Root (Test 27) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a long long). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 87ns
*Test b: 16311ns
*Test c: 188ns
*Test d: 74ns

==== Sine (Test 28) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a long long).
*Test a: 23837ns
*Test b: 29898ns

==== Cosine (Test 29) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a long long).
*Test a: 24611ns
*Test b: 30623ns

===float Performance===
----
==== Subtraction (Test 30) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (a float) from another 32-bit number (a float).
*Test a: 100ns
*Test b: 900ns

==== Addition (Test 31) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (a float) to another 32-bit number (a float).
*Test a: 124ns
*Test b: 1024ns

==== Multiplication (Test 32) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (a float) by another 32-bit number (a float).
*Test a: 124ns
*Test b: 736ns

==== Division (Test 33) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (a float) by another 32-bit number (a float).
*Test a: 99ns
*Test b: 1674ns

==== Square Root (Test 34) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (a float). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 99ns
*Test b: 8636ns
*Test c: N/A
*Test d: N/A

==== Sine (Test 35) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (a float).
*Test a: 19574ns
*Test b: 19562ns

==== Cosine (Test 36) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (a float).
*Test a: 20311ns
*Test b: 20297

===double Performance===
----
==== Subtraction (Test 37) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a double) from another 8-bit number (a double).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 199 ns
* Test (b): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 38) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 64-bit number (a double) to another 64-bit number (a double).
*Test a: 199ns
*Test b: 1236ns

==== Multiplication (Test 39) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a double) by another 64-bit number (a double).
*Test a: 188ns
*Test b: 1438ns

==== Division (Test 40) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a double) by another 64-bit number (a double).
*Test a: 187ns
*Test b: 3184ns

==== Square Root (Test 41) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a double). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 188ns
*Test b: 7998ns
*Test c: N/A
*Test d: N/A

==== Sine (Test 42) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a double).
*Test a: 20299ns
*Test b: 20624ns

==== Cosine (Test 43) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a double).
*Test a: 19762ns
*Test b: 20011ns

== Code ==

===Test 1===
This is the first test.

===Test 2===
This is the second test.

Blah blah blah, I would really like to be watching the super bowl right about now. /sigh.

PIC32MX: Benchmarking Mathematical Operations

2010-02-16T07:33:11Z

MaxWiller:

== Original Assignment ==

'''Do not erase this section!'''

Your assignment is to empirically test how long it takes to perform add, subtract, multiply, divide, sqrt, sin, and cos operations with the 80 MHz PIC32460F512L and our standard code optimization setting. You will do these tests with chars (8-bit integers), shorts (16-bit), integers (32-bit), long long integers (64-bit), floats (32-bit single precision floating point), and double (64-bit double-precision floating point). The integers can be unsigned or signed. Your end result will be a table with the operation on one axis (likely the horizontal axis) and the kind of variable on the other axis, and each cell of the table will have a normalized duration for the operation. The time will be normalized by the fastest operation, so the smallest number in the table will be 1.00. All other numbers will indicate how many times longer that operation takes. All numbers will have two decimal places, e.g., 2.57 or 24.72. You will also give the time that 1.00 corresponds to in nanoseconds.

Since bit-shifting left and right correspond to a version of multiplying and dividing, you should also include the operations >>1 and >>4 and <<1 and <<4. (If the results are identical, you can eliminate shift left from your table.)

To generate this table, you can set an output bit low before the operation, then high immediately after the operation, and measure the time on an oscilloscope. Two things to consider: (1) Time a single operation, over and over, with a short delay between the operation. This should create a pulse train on your oscilloscope. Can you get an accurate estimate of the time this way? You could also try doing five or ten operations between changing the digital output. See if this gives the same estimate. (This estimate might be more accurate as you are essentially averaging over a number of operations.) Avoid using arrays and for loops in your test, as indexing arrays and running the loop each take time. (2) Make sure the compiler doesn't compute the results in advance. You could try testing operations with numbers generated randomly (don't time this operation!) vs. numbers that you just type in manually to make sure that both are giving you the same result.

== Overview ==

We were tasked with determining the real-time cost (measured in nanoseconds) of performing seven basic mathematical operations with each one of the six commonly used ANSI C data types.

The mathematical operations we tested were:
* subtraction
* addition
* multiplication
* division
* square root
* sine
* cosine

The six data types we tested each operation on were:
* char
* short
* integer
* long long
* float
* double

Our testing procedure was simple: throw an output pin high on the NU32 development board, perform a mathematical operation with a given data type, and then pull the same pin low.

Placing the above three steps in an infinite while loop afforded us the opportunity to use an oscilloscope to measure the duration between each high-low pair in the output waveform. After subtracting the time it took for the PIC to raise and lower the voltage on the output pin (something we previously measured), we were able to determine the amount of time required for the PIC32 chip to execute an operation with a high level of accuracy.

With seven operations to perform on six different data types, we created the following table to help us assign and keep track of the various tests we planned to run:

{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! char (8-bit) !! short (16-bit) !! int (32-bit) !! long long (64-bit) !! float (32-bit) !! double (64-bit)
|-
! subtraction
| Test 2 || Test 9 || Test 16 || Test 23 || Test 30 || Test 37
|-
! addition
| Test 3 || Test 10 || Test 17 || Test 24 || Test 31 || Test 38
|-
! multiplication
| Test 4 || Test 11 || Test 18 || Test 25 || Test 32 || Test 39
|-
! division
| Test 5 || Test 12 || Test 19 || Test 26 || Test 33 || Test 40
|-
! square root
| Test 6 || Test 13 || Test 20 || Test 27 || Test 34 || Test 41
|-
! sine
| Test 7 || Test 14 || Test 21 || Test 28 || Test 35 || Test 42
|-
! cosine
| Test 8 || Test 15 || Test 22 || Test 29 || Test 36 || Test 43
|}

Several tests contained multiple procedures that explored various ways to carry out a given mathematical operation on a given data type. For example, in the multiplication tests, not only did we test the traditional multiplication operator (*), but also the bitwise left shift operator (<<). Our goal was to find out if one particular operator was faster than the other. Similarly, we also included procedures that performed the above operations on hard-coded numbers (such as 347) as well as randomly chosen numbers stored in variables (such as 'random_int1'). We wanted to ensure that the compiler didn't compute the results of each operation in advance. While pre-compiling can indeed afford welcome increases in execution time, situations in which the compiler can't optimize the operations ahead of time (for example, situations where the data to be operated on is not known in advance) are still common occurrences and are worth benchmarking.

Accordingly, several tests contain multiple procedures that not only account for multiple methods of performing a particular operation, but multiple sets of numbers to perform those operations on.

Test 1 was used to determine the duration required for the PIC32 to throw a pin high and pull a pin low, while Tests 2 through 43 were used to measure the actual performance of each operation and data-type pair.

== Results ==
Below is the quick summary of the testing results comparing each data type and each operation. All results are normalized to 60ns (1.00 = 60ns).
{| class="wikitable" style="text-align:right;" border="0" CELLSPACING = "10" FRAME = "LEFT"
|+Operation vs. Data type
|-
! !! Subtraction !! Addition !! Multiplication !! Division !! Square Root !! Sine !! Cosine !!
|-
! Char
| 1.87 || 1.65 || 2.28 || N/A || 34.78 || 116.03 || 98.93
|-
! Short
| 1.03 || 1.67 || 1.47 || 5.00 || 144.57 || 230.40 || 215.40
|-
! Int
| 1.07 || 1.00 || 1.43 || 8.10 || 145.62 || 316.43 || 330.62
|-
! Long Long
| 2.50 || 3.33 || 6.63 || 28.73 || 271.85 || 498.30 || 510.38
|-
! Float
| 15.00 || 17.07 || 12.27 || 27.90 || 143.93 || 326.03 || 338.28
|-
! Double
| 26.00 || 20.60 || 23.97 || 53.07 || 133.30 || 343.73 || 333.52

|}
Below are the results of each particular test we performed, coupled with a short explanation for each result.

=== Basic Timing Constants (Test 1) ===
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}

This test determines the length of time required by the PIC32 chip to push a given output pin high and pull the same pin low.
* Test (a): Time required to throw an output pin high
** Instruction: <code>PIN_A2 = 1;</code>
** Time: 63 ns
* Test (b): Time required to pull an output pin low
** Instruction: <code>PIN_A2 = 0;</code>
** Time: 63 ns
* Test (c): Time required to execute 1 empty while loop cycle
** Instruction: <code>while(1){}</code>
** Time: 23 ns

=== char Performance ===
----
A <code>char</code> data type, in ANSI C, is a value holding one byte, or one character code. The actual number of bits in a char in a particular implementation is documented as CHAR_BIT in that implementation's <code>limits.h</code> file. In practice, it is almost always 8 bits, corresponding to a decimal range of 0 to 255 inclusive. Unless otherwise noted, all (a) benchmarks are operations on two predefined (and mot likely pre-computed) ASCII letters, all (b) benchmarks are operations on two predefined (and most likely pre-computed) numbers in the range of 0 to 255, and all (c) benchmarks are operations on two random (and most likely '''not''' pre-computed) numbers. These multiple benchmarks per test exist to illustrate the differences in execution time between pre-compiled operations and operations the PIC must perform in real time.

==== Subtraction (Test 2) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 8-bit number (a char) from another 8-bit number (a char).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 50 ns
* Test (b): Time required to subtract two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 100-2;</code>
** Time: 50 ns
* Test (c): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 3) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 8-bit number (a char) to another 8-bit number (a char).
* Test (a): Time required to add two constant chars (may be pre-computed)
** Instruction: <code>letter_a = ')'+'8';</code>
** Time: 50 ns
* Test (b): Time required to add two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_b = 97+1;</code>
** Time: 50 ns
* Test (c): Time required to add of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = random_char1+random_char2;</code>*
** Time: 99 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Multiplication (Test 4) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to multiply two constant chars (may be pre-computed)
** Instruction: <code>ascii_225 = 'K'*'♥';</code>
** Time: 49 ns
* Test (b): Time required to multiply two ints cast into a char (may be pre-computed)
** Instruction: <code>ascii_200 = 100*2;</code>
** Time: 48 ns
* Test (c): Time required to multiply of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger*smaller;</code>*
** Time: 137 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Division (Test 5) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 8-bit number (a char) by another 8-bit number (a char).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>ascii_25 = 'K'/'♥'; //thp</code>
** Time: 48 ns
* Test (b): Time required to subtract two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = 100/2;</code>
** Time: 50 ns
* Test (c): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger/smaller;</code>*
** Time: N/A

<nowiki>*</nowiki> We had great difficulty in trying to test this particular operation. After some research with an oscilloscope and voltmeter, it seems that the PIC32 is not capable of dividing chars in this way. More specifically, every time the PIC32 attempts to divide one char by another, all output pins are immediately grounded. We've tested this code in other C environments, and it works as expected, so the error must either lie somewhere within our specific PICs (which would be very unlikely - we tested 3) or the silicon architecture of the PIC32 itself (sill unlikely, but given the number of PICs we tested, more probable). If you absolutely need to divide chars, cast them to ints first, perform your division, then cast them back to chars.

==== Square Root (Test 6) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (c): Time required to pull an output pin low
| caption3 = Caption3

| image4 = test1-whileloop-onoff-timetogohigh.png
| alt4 = Test (d): Time required to throw an output pin high
| caption4 = Caption4

| image5 = test1-whileloop-onoff-timetogolow.png
| alt5 = Test (e): Time required to pull an output pin low
| caption5 = Caption5

| image6 = test1-whileloop-onoff-pair.png
| alt6 = Test (f): Time required to pull an output pin low
| caption6 = Caption6
}}
This test determines the length of time required by the PIC32 chip to square root one 8-bit number (a char). Benchmarks (a) through (c) use the <code>sqrt()</code> function while benchmarks (d) through (f) raise the operands to the 1/2 power.
* Test (a): Time required to sqrt() a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sqrt('u');</code>
** Time: 48 ns
* Test (b): Time required to sqrt() an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = sqrt(100);</code>
** Time: 48 ns
* Test (c): Time required to sqrt() a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sqrt(random_char1);</code>
** Time: 2087 ns
* Test (d): Time required to ^(1/2) a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = ('u')^(1/2);</code>
** Time: 48 ns
* Test (e): Time required to ^(1/2) an int cast into a char (may be pre-computed)
** Instruction: <code>number_10 = (100)^(1/2);</code>
** Time: 48 ns
* Test (f): Time required to ^(1/2) a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = (random_char2)^(1/2);</code>*
** Time: 75 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Sine (Test 7) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the sine of an 8-bit number (a char).
* Test (a): Time required to take the sine of a constant char (may be pre-computed)
** Instruction: <code>ascii_25 = sin('K');</code>
** Time: 9963 ns
* Test (b): Time required to take the sine of a constant int cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = sin(50);</code>
** Time: 9550 ns
* Test (c): Time required to take the sine of a random char (guaranteed not to be pre-comp)
** Instruction: <code>random_char = sin(larger);</code>*
** Time: 6962 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Cosine (Test 8) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to take the cosine of an 8-bit number (a char).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>ascii_25 = cos('K');</code>
** Time: 9111 ns
* Test (b): Time required to subtract two ints cast into a char (may be pre-computed)
** Instruction: <code>letter_2 = cos(50);</code>
** Time: 8724 ns
* Test (c): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = cos(larger);</code>*
** Time: 5936 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

=== short Performance ===
----
A short data type, in ANSI C, is a value that holds 2 bytes, or 16 bits. This corresponds to a range of 0 to 65535 (2^16 - 1). If the variable is signed (negative), then the range is from -32767 to 32767 (-2^15 + 1 to 2^15 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 9) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 16-bit number (a short) from another 16-bit number (a short).
*Test a: 25ns
*Test b: 62ns

==== Addition (Test 10) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 16-bit number (a short) to another 16-bit number (a short).
*Test a: 50ns
*Test b: 100ns

==== Multiplication (Test 11) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 16-bit number (a short) by another 16-bit number (a short).
*Test a: 24ns
*Test b: 88ns

==== Division (Test 12) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 16-bit number (a short) by another 16-bit number (a short).
*Test a: 28ns
*Test b: 300ns

==== Square Root (Test 13) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 16-bit number (a short). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 50ns
*Test b: 8674ns
*Test c: 50ns
*Test d: 76ns

==== Sine (Test 14) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 16-bit number (a short).
*Test a: 13014ns
*Test b: 13824ns

==== Cosine (Test 15) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 16-bit number (a short).
*Test a: 12174ns
*Test b: 12924ns

===int Performance===
----
An int data type, in ANSI C, is a value that holds 4 bytes, or 32 bits. This corresponds to a range of 0 to 4294967295 (2^32 - 1). If the variable is signed (negative), then the range is from -2147483647 to 2147483647 (-2^31 + 1 to 2^31 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 16) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (an int) from another 32-bit number (an int).
*Test a: 38ns
*Test b: 64ns

==== Addition (Test 17) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (an int) to another 32-bit number (an int).
*Test a: 26ns
*Test b: 60ns

==== Multiplication (Test 18) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (an int) by another 32-bit number (an int).
*Test a: 38ns
*Test b: 86ns

==== Division (Test 19) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (an int) by another 32-bit number (an int).
*Test a: 38ns
*Test b: 486s

==== Square Root (Test 20) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (an int). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 50ns
*Test b: 8737ns
*Test c: 88ns
*Test d: 74ns

==== Sine (Test 21) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (an int).
*Test a: 19488ns
*Test b: 18988ns

==== Cosine (Test 22) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (an int).
*Test a: 20324ns
*Test b: 19837ns

===long long Performance===
----
An long long data type, in ANSI C, is a value that holds 8 bytes, or 64 bits. This corresponds to a range of 0 to 1.84467441 × 10^19 (2^64 - 1). If the variable is signed (negative), then the range is from -9.22337204 × 10^18 to 9.22337204 × 10^18 (-2^63 + 1 to 2^63 -1). In this series of tests, tests (a) are with a predefined number, and tests (b) are with a random number. This is in order to test times for pre-compiled operations and operations on the PIC.

==== Subtraction (Test 23) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a long long) from another 64-bit number (a long long).
*Test a: 186ns
*Test b: 150ns

==== Addition (Test 24) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 64-bit number (a long long) to another 64-bit number (a long long).
*Test a: 88ns
*Test b: 200ns

==== Multiplication (Test 25) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: 74ns
*Test b: 398ns

==== Division (Test 26) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a long long) by another 64-bit number (a long long).
*Test a: 74ns
*Test b: 1724ns

==== Square Root (Test 27) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a long long). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 87ns
*Test b: 16311ns
*Test c: 188ns
*Test d: 74ns

==== Sine (Test 28) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a long long).
*Test a: 23837ns
*Test b: 29898ns

==== Cosine (Test 29) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a long long).
*Test a: 24611ns
*Test b: 30623ns

===float Performance===
----
==== Subtraction (Test 30) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 32-bit number (a float) from another 32-bit number (a float).
*Test a: 100ns
*Test b: 900ns

==== Addition (Test 31) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 32-bit number (a float) to another 32-bit number (a float).
*Test a: 124ns
*Test b: 1024ns

==== Multiplication (Test 32) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 32-bit number (a float) by another 32-bit number (a float).
*Test a: 124ns
*Test b: 736ns

==== Division (Test 33) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 32-bit number (a float) by another 32-bit number (a float).
*Test a: 99ns
*Test b: 1674ns

==== Square Root (Test 34) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 32-bit number (a float). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 99ns
*Test b: 8636ns
*Test c: N/A
*Test d: N/A

==== Sine (Test 35) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 32-bit number (a float).
*Test a: 19574ns
*Test b: 19562ns

==== Cosine (Test 36) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 32-bit number (a float).
*Test a: 20311ns
*Test b: 20297

===double Performance===
----
==== Subtraction (Test 37) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to subtract one 64-bit number (a double) from another 8-bit number (a double).
* Test (a): Time required to subtract two constant chars (may be pre-computed)
** Instruction: <code>letter_capital_a = 'z'-'7';</code>
** Time: 199 ns
* Test (b): Time required to subtract of two random chars (guaranteed not to be pre-comp)
** Instruction: <code>random_char = larger-smaller;</code>*
** Time: 112 ns

<nowiki>*</nowiki>See Code section for a more details on how randomness was guaranteed.

==== Addition (Test 38) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to add one 64-bit number (a double) to another 64-bit number (a double).
*Test a: 199ns
*Test b: 1236ns

==== Multiplication (Test 39) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to multiply one 64-bit number (a double) by another 64-bit number (a double).
*Test a: 188ns
*Test b: 1438ns

==== Division (Test 40) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to divide one 64-bit number (a double) by another 64-bit number (a double).
*Test a: 187ns
*Test b: 3184ns

==== Square Root (Test 41) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the square root of one 64-bit number (a double). Tests (a) and (b) use the 'sqrt()' method, while tests (c) and (d) use a number to the 1/2 power.
*Test a: 188ns
*Test b: 7998ns
*Test c: N/A
*Test d: N/A

==== Sine (Test 42) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the sine of one 64-bit number (a double).
*Test a: 20299ns
*Test b: 20624ns

==== Cosine (Test 43) ====
{{multiple image
| width = 100
| footer = Execution waveforms as seen on the output pin

| image1 = test1-whileloop-onoff-timetogohigh.png
| alt1 = Test (a): Time required to throw an output pin high
| caption1 = Caption1

| image2 = test1-whileloop-onoff-timetogolow.png
| alt2 = Test (b): Time required to pull an output pin low
| caption2 = Caption2

| image3 = test1-whileloop-onoff-pair.png
| alt3 = Test (b): Time required to pull an output pin low
| caption3 = Caption3
}}
This test determines the length of time required by the PIC32 chip to get the cosine of one 64-bit number (a double).
*Test a: 19762ns
*Test b: 20011ns

== Code ==

===Test 1===
This is the first test.

===Test 2===
This is the second test.

Blah blah blah, I would really like to be watching the super bowl right about now. /sigh.

PIC32MX: Benchmarking Mathematical Operations

2010-02-16T05:10:59Z

MaxWiller:

PIC32MX: Benchmarking Mathematical Operations

2010-02-16T04:52:39Z

MaxWiller:

PIC32MX: Benchmarking Mathematical Operations

2010-02-16T00:18:26Z

MaxWiller:

PIC32MX: Benchmarking Mathematical Operations

2010-02-15T22:01:09Z

MaxWiller:

PIC32MX: Benchmarking Mathematical Operations

2010-02-10T06:06:09Z

MaxWiller:

PIC32MX: Benchmarking Mathematical Operations

2010-02-10T06:03:15Z

MaxWiller:

PIC32MX: Benchmarking Mathematical Operations

2010-02-10T04:42:23Z

MaxWiller: