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