Indicador de Proximidade com Sensor Ultrassônico HC-SR04

Neste artigo será apresentado uma simples aplicação do Sensor Ultrassônico HC-SR04 onde esse tem boa precisão e é de fácil obtenção no mercado.

Funcionamento

Seu funcionamento consiste basicamente em enviar um sinal que, ao atingir o obstáculo, retorna para o sensor e com esse tempo de emissão e recepção, é feito o cálculo entre o sensor e o objeto.

Processo de medição:

É enviado um sinal com duração de 10 us (microssegundos) ao pino trigger, indicando que a medição terá início
Automaticamente, o módulo envia 8 pulsos de 40 KHz e aguarda o retorno do sinal pelo receptor
Caso haja um retorno de sinal (em nível HIGH), determinamos a distância entre o sensor e o obstáculo utilizando a seguinte equação: Distância = [Tempo ECHO em nível alto * Velocidade do Som] / 2.

A velocidade do som considerada é de 340 m/s, com isso o resultado é obtido em metros e o tempo em segundos. Como o tempo calculado é de ida e volta, é preciso dividir a distância por 2.
Especificações:

Alimentação: 5V DC
Corrente de Operação: 2mA
Ângulo de efeito: 15°
Alcance: 2cm ~ 4m
Precisão: 3mm

Visto isso, será apresentado o projeto Indicador de Proximidade o qual permite calcular a distância de um objeto, escalonar essa distância para cada necessidade e indicar a proximidade do obstáculo através de sinal sonoro e luminoso.

Indicador de Proximidade com Sensor Ultrassônico HC-SR04

Componentes:

01 Arduino
01 CI registrador de deslocamento 74HC595
08 LEDs
08 Resistores de 220Ω
01 Resistor de 150Ω (para diminuir a intensidade sonora caso necessário))
01 Sonorizador
01 Sensor Ultrassônico HC-SR04

Após plena certeza da conexão dos fios, inclua a biblioteca Ultrasonic e carregue o código:

1 // Projeto Sensor de Distância

3 #include <Ultrasonic.h>

5 # define latchPin 8 // Pino conectado ao pino 12 do 74HC595 (Latch)

6 # define clockPin 12 // Pino conectado ao pino 11 do 74HC595 (Clock)

7 # define dataPin 11 // Pino conectado ao pino 14 do 74HC595 (Data)

8 # define pinBip 13 // Pino do som conectado ao pino 13 do Arduino

9 # define trig 7 // Pino 7 do Arduino será a saída de trigger

10 # define echo 6 // Pino 6 do Arduino será a entrada de echo

12 void barraLED(float entValor, int c); // Função do sinal luminoso

13 void funBip(float entValor, int c); // Função que gera um bip

14 void trigPulse(); // Função que gera o pulso de trigger

16 float pulse; //Variável que armazena o tempo de duração do echo

17 float dist_cm; //Variável que armazena o valor da distância em centímetros

20 void setup()

21 {

22 // Define os pinos como saída

23 pinMode(latchPin, OUTPUT);

24 pinMode(clockPin, OUTPUT);

25 pinMode(dataPin, OUTPUT);

26 pinMode(trig, OUTPUT); //Pino de trigger será saída digital

28 //

30 pinMode(echo, INPUT); //Pino de echo seá entrada digital

32 digitalWrite(trig, LOW); //Saída trigger inicia em nível baixo

34 Serial.begin(9600); //Inicia comunicação serial

37 }

40 void loop()

41 {

43 int c = 10; // Constante que determina a escala de distância

46 trigPulse(); //Aciona o trigger do módulo ultrassônico

48 pulse = pulseIn(echo, HIGH); //Mede o tempo em que o pino de echo fica em nível alto

50 dist_cm = pulse/58.82; // Valor da distância real em centímetros

52 // 340m/s

53 // 34000cm/s

55 /*

56 100000 us - 34000/2 cm/s

57 x us - 1cm

58 1E6

59 x = ----- = 58.82

60 17E3

61 */

64 Serial.println(dist_cm/c); // Imprime o valor na serial. (dist_cm/c) --> Escala de distância desejada

66 digitalWrite(latchPin, LOW); // Define latchPin como LOW, para permitir o fluxo de dados

68 barraLED(dist_cm, c);

70 digitalWrite(latchPin, HIGH); // Define latchPin como HIGH, para fechar e enviar os dados

73 }

76 void barraLED(float entValor, int c)

78 {

80 boolean pinState[8]; /*Inicializamos uma variável booleana, pinState, que armazenará o estado no

81 qual você deseja que o pino relevante esteja, quando os dados forem enviados (1 ou 0): */

83 /* Os pinos de dados e do clock são definidos como LOW para limpar as linhas de dados

84 e do clock, deixando-as prontas para o envio de novos dados. */

86 digitalWrite(dataPin, LOW);

87 digitalWrite(clockPin, LOW);

89 if(entValor > 0 && entValor <= 32/c)

90 {

92 funBip(entValor, c);

93 pinState[0] = HIGH;

94 pinState[1] = LOW;

95 pinState[2] = LOW;

96 pinState[3] = LOW;

97 pinState[4] = LOW;

98 pinState[5] = LOW;

99 pinState[6] = LOW;

100 pinState[7] = LOW;

101

102 for(int i = 0; i < 8; i++)

103 {

104 digitalWrite(dataPin, pinState[i]); // Envia o bit no extremo ascendente do clock

105 digitalWrite(clockPin, HIGH); // Para escrever esse valor no registro de armazenamento

106 digitalWrite(clockPin, LOW); // Interrompa o deslocamento de dados

107

108 }

109

110 delay(10);

111

112 }

113

114

115 if(entValor > 32/c && entValor <= 64/c)

116 {

117

118 funBip(entValor, c);

119 pinState[0] = HIGH;

120 pinState[1] = HIGH;

121 pinState[2] = LOW;

122 pinState[3] = LOW;

123 pinState[4] = LOW;

124 pinState[5] = LOW;

125 pinState[6] = LOW;

126 pinState[7] = LOW;

127

128 for(int i = 0; i < 8; i++)

129 {

130 digitalWrite(dataPin, pinState[i]);

131 digitalWrite(clockPin, HIGH);

132 digitalWrite(clockPin, LOW);

133

134 }

135

136 delay(10);

137

138 }

139

140

141 if(entValor > 64/c && entValor <= 96/c)

142 {

143 funBip(entValor, c);

144 pinState[0] = HIGH;

145 pinState[1] = HIGH;

146 pinState[2] = HIGH;

147 pinState[3] = LOW;

148 pinState[4] = LOW;

149 pinState[5] = LOW;

150 pinState[6] = LOW;

151 pinState[7] = LOW;

152

153 for(int i = 0; i < 8; i++)

154 {

155 digitalWrite(dataPin, pinState[i]);

156 digitalWrite(clockPin, HIGH);

157 digitalWrite(clockPin, LOW);

158

159 }

160

161 delay(10);

162

163 }

164

165

166 if(entValor > 96/c && entValor <= 128/c)

167 {

168

169 funBip(entValor, c);

170 pinState[0] = HIGH;

171 pinState[1] = HIGH;

172 pinState[2] = HIGH;

173 pinState[3] = HIGH;

174 pinState[4] = LOW;

175 pinState[5] = LOW;

176 pinState[6] = LOW;

177 pinState[7] = LOW;

178

179 for(int i = 0; i < 8; i++)

180 {

181 digitalWrite(dataPin, pinState[i]);

182 digitalWrite(clockPin, HIGH);

183 digitalWrite(clockPin, LOW);

184

185 }

186

187 delay(10);

188

189 }

190

191

192 if(entValor > 128/c && entValor <= 160/c)

193 {

194 funBip(entValor, c);

195 pinState[0] = HIGH;

196 pinState[1] = HIGH;

197 pinState[2] = HIGH;

198 pinState[3] = HIGH;

199 pinState[4] = HIGH;

200 pinState[5] = LOW;

201 pinState[6] = LOW;

202 pinState[7] = LOW;

203

204 for(int i = 0; i < 8; i++)

205 {

206 digitalWrite(dataPin, pinState[i]);

207 digitalWrite(clockPin, HIGH);

208 digitalWrite(clockPin, LOW);

209

210 }

211

212 delay(10);

213 }

214

215

216 if(entValor > 160/c && entValor <= 192/c)

217 {

218

219 funBip(entValor, c);

220 pinState[0] = HIGH;

221 pinState[1] = HIGH;

222 pinState[2] = HIGH;

223 pinState[3] = HIGH;

224 pinState[4] = HIGH;

225 pinState[5] = HIGH;

226 pinState[6] = LOW;

227 pinState[7] = LOW;

228

229 for(int i = 0; i < 8; i++)

230 {

231 digitalWrite(dataPin, pinState[i]);

232 digitalWrite(clockPin, HIGH);

233 digitalWrite(clockPin, LOW);

234

235 }

236

237 delay(10);

238 }

239

240

241

242 if(entValor > 192/c && entValor <= 224/c)

243 {

244 funBip(entValor, c);

245 pinState[0] = HIGH;

246 pinState[1] = HIGH;

247 pinState[2] = HIGH;

248 pinState[3] = HIGH;

249 pinState[4] = HIGH;

250 pinState[5] = HIGH;

251 pinState[6] = HIGH;

252 pinState[7] = LOW;

253 for(int i = 0; i < 8; i++)

254 {

255 digitalWrite(dataPin, pinState[i]);

256 digitalWrite(clockPin, HIGH);

257 digitalWrite(clockPin, LOW);

258

259 }

260

261 delay(10);

262

263 }

264

265

266

267 if(entValor > 224/c && entValor <= 255/c)

268 {

269 funBip(entValor, c);

270 pinState[0] = HIGH;

271 pinState[1] = HIGH;

272 pinState[2] = HIGH;

273 pinState[3] = HIGH;

274 pinState[4] = HIGH;

275 pinState[5] = HIGH;

276 pinState[6] = HIGH;

277 pinState[7] = HIGH;

278

279 for(int i = 0; i < 8; i++)

280 {

281 digitalWrite(dataPin, pinState[i]); // Envia o bit no extremo ascendente do clock

282 digitalWrite(clockPin, HIGH); // para escrever esse valor no registro de armazenamento

283 digitalWrite(clockPin, LOW); // interrompa o deslocamento de dados

284

285 }

286

287 delay(10);

288

289 }

290

291 if(entValor > 255/c)

292 {

293 funBip(entValor, c);

294 pinState[0] = LOW;

295 pinState[1] = LOW;

296 pinState[2] = LOW;

297 pinState[3] = LOW;

298 pinState[4] = LOW;

299 pinState[5] = LOW;

300 pinState[6] = LOW;

301 pinState[7] = LOW;

302

303 for(int i = 0; i < 8; i++)

304 {

305 digitalWrite(dataPin, pinState[i]); // Envia o bit no extremo ascendente do clock

306 digitalWrite(clockPin, HIGH); // Para escrever esse valor no registro de armazenamento

307 digitalWrite(clockPin, LOW); // Interrompa o deslocamento de dados

308

309 }

310

311 delay(10);

312

313 }

314

315

316

317 }

318

319

320 void funBip(float entValor, int c)

321 {

322 float sinVal;

323 int toneVal;

324

325 if(entValor > 0 && entValor <= 32/c)

326 {

327

328 tone(pinBip, 2000);

329 delay(10);

330

331 }

332

333 if(entValor > 32/c && entValor <= 64/c)

334 {

335 tone(pinBip, 2000, 100); /*

336 O comando tone() requer dois ou três parâmetros, da seguinte maneira:

337 tone(pin, frequência)

338 tone(pin, frequência, duração) */

339

340 delay(200);

341 noTone(pinBip);

342 }

343

344

345 if(entValor > 64/c && entValor <= 96/c)

346 {

347 tone(pinBip, 2000, 100);

348 delay(300);

349 noTone(pinBip);

350 }

351

352 if(entValor > 96/c && entValor <= 128/c)

353 {

354 tone(pinBip, 2000, 100);

355 delay(400);

356 noTone(pinBip);

357 }

358

359 if(entValor > 128/c && entValor <= 160/c)

360 {

361 tone(pinBip, 2000, 100);

362 delay(500);

363 noTone(pinBip);

364 }

365

366 if(entValor > 160/c && entValor <= 192/c)

367 {

368 tone(pinBip, 2000, 100);

369 delay(600);

370 noTone(pinBip);

371 }

372

373 if(entValor > 192/c && entValor <= 224/c)

374 {

375 tone(pinBip, 2000, 100);

376 delay(700);

377 noTone(pinBip);

378 }

379

380 if(entValor > 224/c && entValor <= 255/c)

381 {

382 tone(pinBip, 2000, 100);

383 delay(800);

384 noTone(pinBip); ;

385 }

386

387 if(entValor > 255/c)

388 {

389

390 noTone(pinBip);

391 }

392

393 }

394

395 void trigPulse()

396 {

397 digitalWrite(trig, HIGH); // Pulso de trigger em nível alto

398 delayMicroseconds(10); // Duração de 10 micro segundos

399 digitalWrite(trig, LOW); // Pulso de trigge em nível baixo

400 }

401

Com isso, observar-se que, conforme o objeto se aproxima do sensor, os LEDs vão se apagando escalonadamente com a diminuição da distância e, também, o sinal sonoro vai bipando mais rapidamente com a proximidade do objeto. Efeito inverso é observado quando o objeto se afasta.

Páginas

Indicador de Proximidade com Sensor Ultrassônico HC-SR04

Nenhum comentário:

Postar um comentário