MPU-6050 com Processing

Os sensores IMU são um dos tipos mais comuns e mais confiáveis de sensores usados ​​hoje em todos os tipos de aparelhos eletrônicos. Os sensores da IMU (Inertia Measurement Unit) nos ajudam a obter a atitude de um objeto ligado ao sensor no espaço tridimensional. Esses sensores fornecem valores que geralmente são transformados em ângulos para nos ajudar a determinar sua atitude. Eles são usados ​​em smartphones para detectar sua orientação ou em aparelhos wearable como o Fit Bit que usam sensores IMU para rastrear o movimento. 

Os sensores IMU normalmente consistem em duas ou mais partes. Listando-os por prioridade são o acelerômetro, o giroscópio, o magnetômetro e o altímetro. O MPU 6050 é um 6 DOF (Degrees of Freedom) ou um sensor de IMU de seis eixos, o que significa que ele fornece seis valores como saída. Três valores do acelerômetro e três do giroscópio. O MPU 6050 é um sensor baseado na tecnologia MEMS (Micro Electro Mechanical Systems).

Um acelerômetro funciona com o princípio do efeito piezoelétrico. Imagine uma caixa com uma bola pequena dentro dela onde as paredes desta caixa são feitas com cristais piezoelétricos e, quando inclinamos essa caixa, a bola é forçada a se mover na direção da inclinação devido à gravidade. Existem três pares de paredes opostas nessa caixa onde cada par corresponde a um eixo no espaço 3D: eixos X, Y e Z. Quando a bola colide em cada uma dessa parede, cria pequenas correntes piezoelétricas as quais são utilizadas para determinar a direção da inclinação e sua magnitude.

Os giroscópios trabalham de acordo com no princípio da aceleração de Coriolis. 
Imagine uma estrutura de cristais piezoelétricos (representada pelos braços sensores na figura ao lado) semelhante a uma forquilha que esteja em constante movimento vibratório. Essas vibrações nos cristais, resultado da inércia do garfo móvel, produzem assim uma corrente em consenso com o efeito piezoelétrico, esta corrente é amplificada e seus valores são então refinados pelo microcontrolador.

O MPU-6050 é um sensor DMP (Digitam Motion Processor) que além do giroscópio e do acelerômetro, tem um termômetro na mesma board. É um dispositivo de alta precisão e baixo custo com comunicação I2C (Inter-Integrated Circuit) com o Arduino.

Partindo para o exemplo, faça a ligação do componente no Arduino conforme o esquema abaixo:

Prosseguindo, baixe as bibliotecas, descompacte o arquivo zip i2cdevlib-master, abra essa pasta, em seguida, abra a pasta Arduino, copie as pastas I2Cdev e MPU6050 e cole em C:\Users\admin\Documents\Arduino\libraries. 

Feito isso, baixe o código de calibração, carregue no Arduino, abra o Monitor Serial, aguarde o final e copie os offsets para serem inseridos no próximo programa.
Vá à pasta Arquivo>Exemplo>MPU6050> MPU6050_DMP6 abra o exemplo MPU6050_DMP6, insira os valores offsets encontrados no sketch de calibragem, faça a seleção para # define OUTPUT_TEAPOT e siga as demais alterações conforme as figuras abaixo:

Seguindo para o Processing,  baixe a biblioteca Toxilib, descompacte-a, copie a pasta e cole em em C:\Users\admin\Documents\Processing\libraries. Feito isso baixe o arquivo MPUTeapot, inicie o programa e configure-o conforme indicado abaixo:

Ao executar o MPUTeapot, ele inicia com a figura conforme calibrado e ao movimentar o Sensor MPU 6050, vemos a imagem em 3D se movimentando conforme o movimento do sensor.

Carro Robótico 4WD + Bluetooth

Neste projeto, desenvolveremos um carro robótico autônomo capaz de desviar dos obstáculos numa simples plataforma de acrílico e, também, com uma outra opção de controle manual via bluetooth.

Componentes:

• 01 Chassi completo com  quatro motores DC (3~6v) com caixa de redução, quatro  rodas de borracha, um  suporte para  pilhas e  um jogo de parafusos
• 01 Arduino Uno/Mega
• 01 Arduino Sensor Shield(opcional)
• 01 Sensor HC-SR04
• 01 Micro Servo 9g
• 01 Ponte H L298N
• 01 Módulo Bluetooth HC-06 

Quanto à escolha do Arduino, fica a critério de cada um com uma sugestão do Arduino Mega, pois se futuramente você quiser adicionar outros sensores, terá uma gama maior de opções.
Monte com calma os componentes no chassi e faça a ligação conforme o esquema abaixo:

Feito isso, carregue o seguinte código:

  
  1  # include <SoftwareSerial.h>

  2  # include <string.h>

  3

  4  # define enA 2 //  ENA

  5  # define MotorDireitoAvante  3  // IN1

  6  # define MotorDireitoAtras   4  // IN2

  7

  8  # define enB 8 // ENB

  9  # define MotorEsquerdoAvante  6 // IN3

 10  # define MotorEsquerdoAtras   7 // IN4

 11

 12  # define pinRx 0 // RX do Arduino

 13  # define pinTx 1 // TX do Arduino

 14

 15  int veloc = 0;

 16  int v1 = 0;

 17  char dir;

 18  String modo;

 19

 20  String StringRecebido;

 21

 22  void  MoverAdiante(int veloc);

 23  void  MoverAtras(int veloc);

 24  void left(int veloc);

 25  void VirarEsquerda(int veloc);

 26  void VirarDireita(int veloc);

 27  void Parar();

 28  int Acelerar() ;

 29  int Desacelerar();

 30

 31  # include <Servo.h>   // Ativa a bibliateca Servo Motor

 32  # include <NewPing.h> // Biblioteca do Sensor Ultrassônico

 33  # define trig_pin A0  // Trig no pino analógico A1

 34  # define echo_pin A1  // Echo no pino analógico A2

 35

 36  # define dist_maxima 300

 37

 38  int dist;

 39

 40  int VarrerDireita();

 41  int VarrerEsquerda();

 42  int LerPing();

 43 

 44  NewPing sonar(trig_pin, echo_pin, dist_maxima);

 45  Servo servo_motor;

 46

 47  void setup()

 48  {

 49      Serial.begin(9600);

 50      pinMode(pinRx, INPUT);

 51      pinMode(pinTx, OUTPUT);

 52      pinMode(MotorDireitoAvante,  OUTPUT); // IN1

 53      pinMode(MotorDireitoAtras,   OUTPUT); // IN2

 54      pinMode(MotorEsquerdoAvante, OUTPUT); // IN3

 55      pinMode(MotorEsquerdoAtras,  OUTPUT); // IN4

 56      servo_motor.attach(12);

 57      servo_motor.write(80);

 58      delay(2000);

 59      dist = LerPing();

 60      delay(100);

 61      dist = LerPing();

 62      delay(100);

 63      dist = LerPing();

 64      delay(100);

 65      dist = LerPing();

 66      delay(100);

 67      dir = 'F';

 68      modo = "auto";

 69  }

 70  void loop()

 71  {

 72      if(Serial.available())

 73      {

 74          delay(100);

 75          StringRecebido = "";

 76          while(Serial.available())

 77          {

 78              char c = Serial.read();

 79              StringRecebido += c;

 80              delay(5);

 81          }

 82          Serial.println(StringRecebido);

 83      }

 84      if(StringRecebido == "downAdiante" && modo == "manual")

 85      {

 86          MoverAdiante(veloc);

 87          dir = 'F';

 88      }

 89      if(StringRecebido == "upAdiante" && modo == "manual")

 90      {

 91

 92      }

 93      if(StringRecebido == "downAtras" && modo == "manual")

 94      {

 95          MoverAtras(veloc);

 96          dir = 'R';

 97      }

 98      if(StringRecebido == "upAtras" && modo == "manual")

 99      {

100

101      }

102      if(StringRecebido == "downEsquerda" && modo == "manual")

103      {

104          VirarEsquerda(veloc);

105      }

106      if(StringRecebido == "upEsquerda" && modo == "manual")

107      {

108          if(dir == 'F')

109          {

110              MoverAdiante(veloc);

111          }

112          if(dir == 'R')

113          {

114              MoverAtras(veloc);

115          }

116      }

117      if(StringRecebido == "downDireita" && modo == "manual")

118      {

119          VirarDireita(veloc);

120      }

121      if(StringRecebido == "upDireita" && modo == "manual")

122      {

123          if(dir == 'F')

124          {

125              MoverAdiante(veloc);

126          }

127          if(dir == 'R')

128          {

129              MoverAtras(veloc);

130          }

131      }

132      if(StringRecebido == "downAcel" && modo == "manual")

133      {

134          veloc = Acelerar(v1);

135          delay(30);

136          v1 = veloc;

137          if(dir == 'F')

138          {

139              MoverAdiante(veloc);

140          }

141

142          if(dir == 'R')

143          {

144              MoverAtras(veloc);

145          }

146      }

147

148      if(StringRecebido == "upAcel" && modo == "manual")

149      {

150

151      }

152      if(StringRecebido == "downDesacel" && modo == "manual")

153      {

154          veloc = Desacelerar(v1);

155          delay(30);

156          v1 = veloc;

157          if(dir == 'F')

158          {

159              MoverAdiante(veloc);

160          }

161

162          if(dir == 'R')

163          {

164              MoverAtras(veloc);

165          }

166      }

167      if(StringRecebido == "upDesacel" && modo == "manual")

168      {

169

170      }

171      if(StringRecebido == "Auto")

172      {

173          Parar();

174          modo = "auto";

175          delay(2000);

176          StringRecebido = "";

177      }

178      if(StringRecebido == "Manual")

179      {

180          modo = "manual";

181          Parar();

182          veloc = 0;

183      }

184      if(StringRecebido == "B1")

185      {

186

187      }

188      if(StringRecebido == "b1")

189      {

190

191      }

192      if(StringRecebido == "B2")

193      {

194

195      }

196      if(StringRecebido == "b2")

197      {

198

199      }

200      if(StringRecebido == "B3")

201      {

202

203      }

204      if(StringRecebido == "b3")

205      {

206

207      }

208      if(modo == "auto")

209      {

210          int dist_Direita  = 0;

211          int dist_Esquerda = 0;

212          int dist_Adiante =  0;

213

214          if (dist <= 50)

215          {

216              Parar();

217              delay(500);

218              MoverAtras(130);

219              delay(400);

220              Parar();

221              dist_Direita  = VarrerDireita();

222              delay(100);

223              dist_Esquerda = VarrerEsquerda();

224              delay(100);

225              dist_Direita  = VarrerDireita();

226              delay(100);

227              dist_Esquerda = VarrerEsquerda();

228              delay(100);

229

230              if (dist_Direita >= dist_Esquerda)

231              {

232                  VirarDireita(130);

233                  delay(800);

234                  Parar();

235                  delay(500);

236                  dist = LerPing();

237              }

238              else

239              {

240                  VirarEsquerda(130);

241                  delay(800);

242                  Parar();

243                  delay(500);

244                  dist = LerPing();

245              }

246          }

247          else

248          {

249              delay(100);

250              MoverAdiante(140);

251          }

252          dist = LerPing();

253      }

254  }

255  int Acelerar(int v)

256  {

257      v = v + 5;

258      if(v >255)

259      {

260          v = 255;

261      }

262      return v;

263  }

264  int Desacelerar(int v)

265  {

266      v = v - 5;

267      if(v < 0)

268      {

269          v = 0;

270      }

271      return v;

272  }

273  void MoverAdiante(int veloc)

274  {

275      digitalWrite(MotorDireitoAvante,  HIGH); // IN1

276      digitalWrite(MotorDireitoAtras,   LOW);  // IN2

277      digitalWrite(MotorEsquerdoAvante, HIGH); // IN3

278      digitalWrite(MotorEsquerdoAtras,  LOW);  // IN4

279      analogWrite(enA, veloc);

280      analogWrite(enB, veloc);

281  }

282  void MoverAtras(int veloc)

283  {

284      digitalWrite(MotorDireitoAtras,   HIGH); // IN2

285      digitalWrite(MotorEsquerdoAtras,  HIGH); // IN4

286      digitalWrite(MotorDireitoAvante,  LOW);  // IN1

287      digitalWrite(MotorEsquerdoAvante, LOW);  // IN3

288      analogWrite(enA, veloc);

289      analogWrite(enB, veloc);

290  }

291  void VirarEsquerda(int veloc)

292  {

293      digitalWrite(MotorDireitoAvante,  HIGH);

294      digitalWrite(MotorEsquerdoAtras,  HIGH);

295      digitalWrite(MotorDireitoAtras,   LOW);

296      digitalWrite(MotorEsquerdoAvante, LOW);

297      analogWrite(enA, veloc);

298      analogWrite(enB, veloc);

299  }

300  void VirarDireita(int veloc)

301  {

302      digitalWrite(MotorDireitoAtras,   HIGH);

303      digitalWrite(MotorEsquerdoAvante, HIGH);

304      digitalWrite(MotorDireitoAvante,  LOW);

305      digitalWrite(MotorEsquerdoAtras,  LOW);

306      analogWrite(enA, veloc);

307      analogWrite(enB, veloc);

308  }

309  void Parar()

310  {

311      digitalWrite(MotorDireitoAvante,  LOW);  // IN1

312      digitalWrite(MotorDireitoAtras,   LOW);  // IN2

313      digitalWrite(MotorEsquerdoAvante, LOW);  // IN3

314      digitalWrite(MotorDireitoAtras,   LOW);  // IN4

315      analogWrite(enA, 0);

316      analogWrite(enB, 0);

317  }

318  int VarrerDireita()

319  {

320      servo_motor.write(0);

321      int dist = LerPing();

322      delay(500);

323      dist = LerPing();

324      servo_motor.write(80);

325      return dist;

326  }

327  int VarrerEsquerda()

328  {

329      servo_motor.write(180);

330      int dist = LerPing();

331      delay(500);

332      dist = LerPing();

333      servo_motor.write(80);

334      return dist;

335  }

336  int LerPing()

337  {

338      int dist_cm = sonar.ping_cm();

339      Serial.println(dist_cm);

340      return dist_cm;

341  }

Partindo para a próxima etapa, faça seu aplicativo no App Inventor conforme os blocos mostrados na figura abaixo:

Depois de instalar o aplicativo Android no seu celular, podemos ligar o carro robô, percebemos que ele inicia o movimento no modo autônomo. Quando apertamos o botão "manual" ele para imediatamente, então pressionamos o botão "+" para acelerar e "-" para desacelerar combinando com os outro botões para controlar a direção e mais o botão de parada quando a mesma se torna necessária.
Com isso, concluímos que esse projeto não é tão difícil como aparenta e ao mesmo tempo muito interessante com a possibilidade de fazer várias alterações com a inclusão de outros sensores aproveitado a mesma plataforma.