Diff: main.cpp

Revision:

7:e4f89c858e61

Parent:

6:fa74a43cae81

Child:

8:e7cafda76315

--- a/main.cpp	Thu Jan 21 15:37:48 2016 +0000
+++ b/main.cpp	Fri Feb 19 17:02:25 2016 +0000
@@ -45,18 +45,7 @@
  */
 int main(){
     
-  /*  
-    0x3FFF  -0.001g
-    0x2001  -7.998g
-    0x2000  -8.000g
-    
-    0x1FFF   8.000g
-    0x1FFE   7.998g
-    0x0000   0.000g
-    
-    */
-    
-    const char ACCEL_ADDRESS = 0xAA;
+    const char ACCEL_ADDRESS = 0x55;
     
     char data_write[1];
     char data_read[7];
@@ -104,47 +93,124 @@
         i2c.start();
         
          // Como con write ya mandamos la direccion, hacemos los dos primeros pasos a la vez.
-        i2c.write(ACCEL_ADDRESS, data_write, 1, true);
+        i2c.write(ACCEL_ADDRESS << 1, data_write, 1, true);
     
-        i2c.read(ACCEL_ADDRESS, data_read, 7, true);
-        
-        pc.printf("Status: %i\n", data_read[0]);
+        i2c.read(ACCEL_ADDRESS << 1, data_read, 7, true);
         
         if(data_read[0] == 0)
             led1 = 0;
         else
             led1 = 1;
         
-        // X 
-        int ch0 = (data_read[1] << 6) | data_read[2] >> 2;
+        //########### X #############            
+        unsigned int ch0 = data_read[1];
+        ch0 = (ch0 << 6) | (data_read[2] >> 2);
         
-        pc.printf("X: %x\n", ch0);
+        int x_l = ch0; // Necesitamos 32 bits
+        if (x_l >= 0x2000)
+            x_l -= 0x4000;
+
+        long x = (1000 * x_l + 512) >> 10;
+        
+        pc.printf("X: ");
         
-        if (ch0 < 0x00FF)
-            led2 = 0;
+        /*if (x > 0x80000000){
+            pc.printf("-");
+            x = ~x + 1;    
+        }
         else
-            led2 = 1;
-            
-        // Y 
-        int ch1 = (data_read[3] << 6) | data_read[4] >> 2;
+            pc.printf("+");*/
         
-        pc.printf("Y: %x\n", ch1);
+        // Hola mantissa    
+        int r = x % 1000;
+        char a = (char)(x / 1000);
+        char b = (char)(r / 100);
+        r %= 100;
+        char c = (char)(r / 10);
+        char d = (char)(r%10);
+        
+        pc.printf("dataread[1]: %x, dataread[2]: %x, x: %d\n", data_read[1], data_read[2], x);
             
-        if(ch1 < 0x00FF) 
-            led3 = 0;
+        //########### Y ############# 
+        unsigned int ch1 = data_read[3];
+        ch1 = (ch1 << 6) | (data_read[4] >> 2);
+        
+        int y_l = ch1;
+        if (y_l >= 0x2000)
+            y_l -= 0x4000;
+        
+        long y = (1000 * y_l + 512) >> 10;
+        
+        pc.printf("Y: long: %d int %d ",sizeof(long),sizeof(int));
+        
+        /*
+        if (y > 0x80000000){
+            pc.printf("-");
+            y = ~y + 1;    
+        }
         else
-            led3 = 1;
+            pc.printf("+");
+        */
         
-        // Z 
-        int ch2 = (data_read[5] << 6) | data_read[6] >> 2;
+        // Hola mantissa    
+         r = y % 1000;
+         a = (char)(y / 1000);
+         b = (char)(r / 100);
+         r %= 100;
+         c = (char)(r / 10);
+         d = (char)(r%10);
+        
+         pc.printf("yl %d y: %d\n", y_l, y);
+        
+        //########### Z ############# 
+        unsigned int ch2 = data_read[5];
+        ch2 = (ch2 << 6) | (data_read[6] >> 2);
+        
+        long z_l = ch2;
+        if (z_l >= 0x2000)
+            z_l -= 0x4000;
         
-        pc.printf("Z: %x\n", ch2);
+        long z = (1000 * z_l + 512) >> 10;
+        
+        pc.printf("Z: ");
+        
+       /* if (z > 0x80000000){
+            pc.printf("-");
+            z = ~z + 1;    
+        }
+        else
+            pc.printf("+");*/
+        
+        // Hola mantissa    
+         r = z % 1000;
+         a = (char)(z / 1000);
+         b = (char)(r / 100);
+         r %= 100;
+         c = (char)(r / 10);
+         d = (char)(r%10);
+        
+         pc.printf("dataread[5]: %x, dataread[6]: %x, z: %d\n", data_read[5], data_read[6], z);
         
-        if(ch2 < 0x00FF) 
-            led4 = 0;
-        else
-            led4 = 1;
-            
+        /*  
+        
+        UNSIGNED CHAR
+        
+        HACER TODO SIN SIGNO Y LUEGO COMPROBAR EL BIT 14 PARA VER SI ES NEGATIVO
+        SI ES NEGATIVO, HACER UNA OR CON FFFFFF
+        
+        EXTENDER SIGNO!
+        
+        Result = (1000 x data.DWord + 512) >> 10
+        0x3FFF  -0.001g
+        0x2001  -7.998g
+        0x2000  -8.000g
+        
+        0x1FFF   8.000g
+        0x1FFE   7.998g
+        0x0000   0.000g
+        
+        */
+        
         i2c.read(0); // Enviamos un NACK (Espero)
         i2c.stop();