Advertisement
Agno

Untitled

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