Advertisement
Agno

Untitled

Nov 11th, 2019
203
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 4.11 KB | None | 0 0
  1.  
  2. double acc[3];
  3.  
  4. /****************/
  5.  
  6. int i2cspeed = 100;
  7.  
  8. void setup() {
  9. Serial.begin(57600);
  10. delay(1000);
  11. endTransmission(A4, A5);
  12. delay(100);
  13. initializeAccel(0x68, A4,A5);
  14. delay(100);
  15. Serial.println("init accel");
  16.  
  17. }
  18.  
  19.  
  20.  
  21. void loop() {
  22. readAccelRaw(0x68, A4, A5);
  23. double accAngleX = atan(acc[0] / sqrt(pow(acc[0], 2) + pow(acc[2], 2 ))) / (PI / 180);
  24. double accAngleY = atan(acc[1] / sqrt(pow(acc[0], 2) + pow(acc[2], 2 ))) / (PI / 180);
  25.  
  26. Serial.println(accAngleY);
  27. // Serial.print("{ \"a0x\" :\"");
  28. // Serial.print(accel[0]);
  29. // Serial.print("\", \"a0y\" :\"");
  30. // Serial.print(accel[1]);
  31. // Serial.print("\", \"a0z\" :\"");
  32. // Serial.println(accel[2]);
  33.  
  34. delay(10);
  35. }
  36.  
  37. /********** ACCEL *****************/
  38.  
  39. int initializeAccel(byte devaddress, int sda, int scl) {
  40.  
  41. beginTransmission(devaddress, sda, scl);
  42. i2c_write(0x6B, sda, scl);
  43. i2c_write(0x00, sda, scl);
  44. endTransmission(sda, scl);
  45. };
  46.  
  47.  
  48.  
  49.  
  50. void readAccelRaw(byte devaddress, int sda, int scl) {
  51. uint8_t xlg, xhg, ylg, yhg, zlg, zhg;
  52. xhg = getReading(devaddress, 0x3B, sda, scl);
  53. xlg = getReading(devaddress, 0x3C, sda, scl);
  54. yhg = getReading(devaddress, 0x3D, sda, scl);
  55. ylg = getReading(devaddress, 0x3E, sda, scl);
  56. zhg = getReading(devaddress, 0x3F, sda, scl);
  57. zlg = getReading(devaddress, 0x40, sda, scl);
  58.  
  59. // Serial.println((int)yhg);
  60. int accelraw[3];
  61. accelraw[0] = (xhg << 8 | xlg);
  62. accelraw[1] = (yhg << 8 | ylg);
  63. accelraw[2] = (zhg << 8 | zlg);
  64. acc[0] = accelraw[0] / 16384.0;
  65. acc[1] = accelraw[1] / 16384.0;
  66. acc[2] = accelraw[2] / 16384.0;
  67. }
  68.  
  69.  
  70. uint8_t getReading(uint8_t devaddress, uint8_t regaddress, int sda, int scl) {
  71. beginTransmission(devaddress, sda, scl);
  72. i2c_write(regaddress, sda, scl);
  73. endTransmission(sda, scl);
  74. requestFrom(devaddress, sda, scl);
  75. endTransmission(sda, scl);
  76. uint8_t reply = i2c_read(sda, scl);
  77. ack(sda, scl);
  78. endTransmission(sda, scl);
  79. return reply;
  80. }
  81.  
  82. void ack(int sda, int scl) {
  83. pinMode(sda, OUTPUT);
  84. digitalWrite(sda, LOW);
  85. delayMicroseconds(i2cspeed);
  86. digitalWrite(scl, HIGH);
  87. delayMicroseconds(i2cspeed);
  88. digitalWrite(scl, LOW);
  89. digitalWrite(sda, HIGH);
  90. }
  91.  
  92. void i2c_start(int sda, int scl) {
  93. pinMode(sda, OUTPUT);
  94. digitalWrite(sda, LOW);
  95. delayMicroseconds(i2cspeed);
  96. pinMode(scl, OUTPUT);
  97. digitalWrite(scl, LOW);
  98. }
  99.  
  100. void i2c_stop(int sda, int scl) {
  101. pinMode(scl, OUTPUT);
  102. digitalWrite(scl, HIGH);
  103. delayMicroseconds(i2cspeed);
  104. pinMode(sda, OUTPUT);
  105. digitalWrite(sda, HIGH);
  106. }
  107.  
  108.  
  109. uint8_t beginTransmission(uint8_t address, int sda, int scl) {
  110. i2c_start(sda, scl);
  111. uint8_t rc = i2c_write((address << 1) | 0, sda, scl);
  112. return rc;
  113. }
  114.  
  115. uint8_t requestFrom(uint8_t address, int sda, int scl)
  116. {
  117. i2c_start(sda, scl);
  118. uint8_t rc = i2c_write((address << 1) | 1, sda, scl); // set read bit
  119. return rc;
  120. }
  121.  
  122. uint8_t endTransmission(int sda, int scl)
  123. {
  124. i2c_stop(sda, scl);
  125. return 0;
  126. }
  127.  
  128. uint8_t i2c_write( uint8_t c , int sda, int scl)
  129. {
  130. for ( uint8_t i = 0; i < 8; i++) {
  131. i2c_writebit( c & 128 , sda, scl);
  132. c <<= 1;
  133. }
  134.  
  135. return i2c_readbit(sda, scl); //ACK
  136. }
  137.  
  138. uint8_t i2c_read(int sda, int scl)
  139. {
  140. uint8_t res = 0;
  141.  
  142. for ( uint8_t i = 0; i < 8; i++) {
  143. res <<= 1;
  144. res |= i2c_readbit(sda, scl);
  145. //Serial.println(res);
  146. }
  147. return res;
  148. }
  149.  
  150. void i2c_writebit( uint8_t c, int sda, int scl )
  151. {
  152. delayMicroseconds(i2cspeed);
  153.  
  154. if ( c > 0 ) {
  155. pinMode(sda, OUTPUT);
  156. digitalWrite(sda, HIGH);
  157. } else {
  158. pinMode(sda, OUTPUT);
  159. digitalWrite(sda, LOW);
  160. }
  161. delayMicroseconds(i2cspeed);
  162.  
  163. pinMode(scl, OUTPUT);
  164. digitalWrite(scl, HIGH);
  165. delayMicroseconds(i2cspeed);
  166.  
  167. pinMode(scl, OUTPUT);
  168. digitalWrite(scl, LOW);
  169. delayMicroseconds(i2cspeed);
  170.  
  171. }
  172.  
  173. //
  174. uint8_t i2c_readbit(int sda, int scl)
  175. {
  176.  
  177. pinMode(sda, INPUT);
  178. digitalWrite(scl, LOW);
  179. delayMicroseconds(i2cspeed);
  180. digitalWrite(scl, HIGH);
  181. delayMicroseconds(i2cspeed);
  182. uint8_t i2creadbit = digitalRead(sda);
  183. digitalWrite(scl, LOW);
  184.  
  185. delayMicroseconds(i2cspeed);
  186.  
  187. return i2creadbit;
  188. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement