SPIcommFunctions.h

00001 //=========================================================================
00002 //Communication pinouts for serial COM port, SPI, and interrupts
00003 //=========================================================================
00004 static Serial pc(USBTX, USBRX);                     //PC comm
00005 static SPI spi(p23, p24, p25);                      //mosi, miso, sclk
00006 static DigitalOut cs(p22);                          //chip select
00007 
00008 
00009 //=========================================================================
00010 //Variables and arrays used for communications and data storage
00011 //=========================================================================
00012 int8_t deltaX_low, deltaY_low;                      //Stores the low-bits of movement data.
00013 int16_t deltaX_high, deltaY_high;                   //Stores the high-bits of movement data.
00014 int16_t deltaX, deltaY;                             //Stores the combined value of low and high bits.
00015 int16_t totalX, totalY = 0;                         //Stores the total deltaX and deltaY moved during runtime.
00016 
00017 
00018 //=========================================================================
00019 //Functions used to communicate with the sensor and grab/print data
00020 //=========================================================================
00021 uint8_t readRegister(uint8_t addr);
00022 //This function takes an 8-bit address in the form 0x00 and returns an 8-bit value in the form 0x00.
00023 
00024 void writeRegister(uint8_t addr, uint8_t data);
00025 //This function takes an 8-bit address and 8-bit data. Writes the given data to the given address.
00026 
00027 void initializeSensor(void);
00028 //Sets all of the registers needed for initialization and performance optimization.
00029 
00030 void grabData(void);
00031 //Grabs the deltaX and deltaY information from the proper registers and formats it into the proper format.
00032 
00033 void printData(void);
00034 //Prints the data out to a serial terminal.
00035 
00036 
00037 
00038 
00039 
00040 //=========================================================================
00041 //Functions definitions
00042 //=========================================================================
00043 uint8_t readRegister(uint8_t addr)
00044 {
00045     cs = 0;                                 //Set chip select low/active
00046     addr = addr & 0x7F;                     //Set MSB to 0 to indicate read operation
00047     spi.write(addr);                        //Write the given address
00048     wait_us(35);                             //Add a tiny delay after sending address for some internal cycle timing.
00049     uint8_t data_read = spi.write(0x00);    //Throw dummy byte after sending address to receieve data
00050     cs = 1;                                 //Set chip select back to high/inactive
00051     return data_read;                       //Returns 8-bit data from register
00052 }
00053 
00054 
00055 //=========================================================================
00056 void writeRegister(uint8_t addr, uint8_t data)
00057 {
00058     cs = 0;                         //Set chip select low/active
00059     addr = addr | 0x80;             //Set MSB to 1 to indicate write operation
00060     spi.write(addr);                //Write the given address
00061     spi.write(data);                //Write the given data
00062     cs = 1;                         //Set chip select back to high/inactive
00063     
00064     //pc.printf("R:%2X, D:%2X\n\r", addr, readRegister(addr));
00065             //Uncomment this line for debugging. Prints every register write operation.
00066 }
00067 
00068 
00069 //=========================================================================
00070 void initializeSensor(void)
00071 {
00072     writeRegister(0x7F, 0x00);
00073     writeRegister(0x55, 0x01);
00074     writeRegister(0x50, 0x07);
00075     writeRegister(0x7F, 0x0E);
00076     writeRegister(0x43, 0x10);
00077     
00078     if(readRegister(0x67) & 0x40)
00079         writeRegister(0x48, 0x04);
00080         
00081     else
00082         writeRegister(0x48, 0x02);
00083     
00084     writeRegister(0x7F, 0x00);
00085     writeRegister(0x51, 0x7B);
00086     writeRegister(0x50, 0x00);
00087     writeRegister(0x55, 0x00);
00088     writeRegister(0x7F, 0x0E);
00089     
00090     if(readRegister(0x73) == 0x00)
00091     {
00092         writeRegister(0x7F, 0x00);
00093         writeRegister(0x61, 0xAD);
00094         writeRegister(0x51, 0x70);
00095         writeRegister(0x7F, 0x0E);
00096         
00097         if(readRegister(0x70) <= 28)
00098             writeRegister(0x70, readRegister(0x70) + 14);
00099             
00100         else
00101             writeRegister(0x70, readRegister(0x70) + 11);
00102             
00103         writeRegister(0x71, readRegister(0x71) * 45/100);
00104     }
00105     
00106     writeRegister(0x7F, 0x00);
00107     writeRegister(0x61, 0xAD);
00108     writeRegister(0x7F, 0x03);
00109     writeRegister(0x40, 0x00);
00110     writeRegister(0x7F, 0x05);
00111     writeRegister(0x41, 0xB3);
00112     writeRegister(0x43, 0xF1);
00113     writeRegister(0x45, 0x14);
00114     writeRegister(0x5B, 0x32);
00115     writeRegister(0x5F, 0x34);
00116     writeRegister(0x7B, 0x08);
00117     writeRegister(0x7F, 0x06);
00118     writeRegister(0x44, 0x1B);
00119     writeRegister(0x40, 0xBF);
00120     writeRegister(0x4E, 0x3F);
00121     writeRegister(0x7F, 0x06);
00122     writeRegister(0x44, 0x1B);
00123     writeRegister(0x40, 0xBF);
00124     writeRegister(0x4E, 0x3F);
00125     writeRegister(0x7F, 0x08);
00126     writeRegister(0x65, 0x20);
00127     writeRegister(0x6A, 0x18);
00128     writeRegister(0x7F, 0x09);
00129     writeRegister(0x4F, 0xAF);
00130     writeRegister(0x5F, 0x40);
00131     writeRegister(0x48, 0x80);
00132     writeRegister(0x49, 0x80);
00133     writeRegister(0x57, 0x77);
00134     writeRegister(0x60, 0x78);
00135     writeRegister(0x61, 0x78);
00136     writeRegister(0x62, 0x08);
00137     writeRegister(0x63, 0x50);
00138     writeRegister(0x7F, 0x0A);
00139     writeRegister(0x45, 0x60);
00140     writeRegister(0x7F, 0x00);
00141     writeRegister(0x4D, 0x11);
00142     writeRegister(0x55, 0x80);
00143     writeRegister(0x74, 0x21);
00144     writeRegister(0x75, 0x1F);
00145     writeRegister(0x4A, 0x78);
00146     writeRegister(0x4B, 0x78);
00147     writeRegister(0x44, 0x08);
00148     writeRegister(0x45, 0x50);
00149     writeRegister(0x64, 0xFF);
00150     writeRegister(0x65, 0x1F);
00151     writeRegister(0x7F, 0x14);
00152     writeRegister(0x65, 0x67);
00153     writeRegister(0x66, 0x08);
00154     writeRegister(0x63, 0x70);
00155     writeRegister(0x7F, 0x15);
00156     writeRegister(0x48, 0x48);
00157     writeRegister(0x7F, 0x07);
00158     writeRegister(0x41, 0x0D);
00159     writeRegister(0x43, 0x14);
00160     writeRegister(0x4B, 0x0E);
00161     writeRegister(0x45, 0x0F);
00162     writeRegister(0x44, 0x42);
00163     writeRegister(0x4C, 0x80);
00164     writeRegister(0x7F, 0x10);
00165     writeRegister(0x5B, 0x02);
00166     writeRegister(0x7F, 0x07);
00167     writeRegister(0x40, 0x41);
00168     writeRegister(0x70, 0x00);
00169     
00170     wait_ms(10);
00171     
00172     writeRegister(0x32, 0x44);
00173     writeRegister(0x7F, 0x07);
00174     writeRegister(0x40, 0x40);
00175     writeRegister(0x7F, 0x06);
00176     writeRegister(0x62, 0xF0);
00177     writeRegister(0x63, 0x00);
00178     writeRegister(0x7F, 0x0D);
00179     writeRegister(0x48, 0xC0);
00180     writeRegister(0x6F, 0xD5);
00181     writeRegister(0x7F, 0x00);
00182     writeRegister(0x5B, 0xA0);
00183     writeRegister(0x4E, 0xA8);
00184     writeRegister(0x5A, 0x50);
00185     writeRegister(0x40, 0x80);
00186 }
00187 
00188 
00189 //=========================================================================
00190 void grabData(void)
00191 {
00192     deltaX_low = readRegister(0x03);        //Grabs data from the proper registers.
00193     deltaX_high = (readRegister(0x04)<<8) & 0xFF00;      //Grabs data and shifts it to make space to be combined with lower bits.
00194     deltaY_low = readRegister(0x05);
00195     deltaY_high = (readRegister(0x06)<<8) & 0xFF00;
00196         
00197     deltaX = deltaX_high | deltaX_low;      //Combines the low and high bits.
00198     deltaY = deltaY_high | deltaY_low;
00199 }
00200 
00201 
00202 //=========================================================================
00203 void printData(void)
00204 {
00205     if((deltaX != 0) || (deltaY != 0))      //If there is deltaX or deltaY movement, print the data.
00206     {
00207         totalX += deltaX;
00208         totalY += deltaY;
00209         
00210         pc.printf("deltaX: %d\t\t\tdeltaY: %d\n\r", deltaX, deltaY);    //Prints each individual count of deltaX and deltaY.
00211         pc.printf("X-axis Counts: %d\t\tY-axis Counts: %d\n\r", totalX, totalY);  //Prints the total movement made during runtime.
00212     }
00213     
00214     deltaX = 0;                             //Resets deltaX and Y values to zero, otherwise previous data is stored until overwritten.
00215     deltaY = 0;
00216 }