Projetos II: julho 2025

sexta-feira, 25 de julho de 2025

Contrato Projetos - Curso Técnico em Eletroeletrônica 2ELA e 2ELB - 2S - 2025

CONTRATO PARA DESENVOLVIMENTO DE: CONHECIMENTOS, HABILIDADES E ATITUDES

DAS PARTES: Nós alunos e professores abaixo assinado regularmente matriculados no quarto termo do curso Técnico em Eletroeletrônica da Escola SENAI “Henrique Lupo” – Araraquara – SP, neste ano de 2025, ciente da importância da união da sala como um só grupo, forte e unido para o bom desenvolvimento da disciplina de projetos:

CLÁUSULAS:

1. Identificamos as seguintes necessidades das quais nos comprometemos a desenvolver e praticar: a humildade; o saber ouvir; a paciência, o comprometimento, a empatia, a perspicácia, o espírito de trabalho em equipe, a organização, o respeito, a determinação, a postura profissional, a união, a doação, a pró atividade, a iniciativa, a boa comunicação, o entusiasmo e a criatividade.

2. Para tanto, iremos deixar de lado: o stress, a arrogância, a picuinha, o egoísmo, a ofensa, o mau humor, a preguiça, a infantilidade, faltas, individualidade e desinteresse.

Contratantes e contratados: Turma A

ALESSANDRO DOS SANTOS DE OLIVEIRA

ANA JULIA DOS SANTOS

ANA LAURA MOISES

ISABELLI VALERIAN DA SILVA

AMANDA DA SILVA NUNES FERREIRA DE OLIVEIRA

ANA BEATRIZ SOARES DE OLIVEIRA

CAROLINE CORRÊA DE SOUZA

EVELIN TAGLIATI FERNANDES

EDSON BENEDITO RODRIGUES DA CRUZ

JOÃO VITOR MARTINS DE FRANÇA

NÍCOLAS ENAY BELO COSTA

PAULO EDUARDO ZAVAN FILHO

BEATRIZ RODRIGUES SANCHES

CAUÃ HENRIQUE ALVES MECENE

JULIA SILVEIRA DA SILVA

RENAN EDUARDO PENEDO LEMONIE

BIANCA SAES MAIA

LARISSA LIMA SANTANA

NATÁLIA ALVES SIQUEIRA

YASMIM DAS DORES SILVA

KHETYLLIN LUIZA DE CARLOS GOMES

NICOLE BITENCOURT DA ROCHA

SOPHIA CARUSO XAVIER

VINICIUS BORGES GOUVÊA

Contratantes e contratados: Turma B

GIOVANA STAHLHAUER FAJARDO CORDEIRO

JHENIFER FERNANDA SANTOS DE SOUZA

LEANDRA CARDAMONI DE SOUZA

LÍDIA BEATRIZ BRITO

GIOVANNA SILVA DE ALMEIDA

LUANA DA SILVA BRITO

MATHEUS RIBEIRO ALVES FERREIRA

ROBERTA CRISTINA GUIMARÃES

GUILHERME VENTURA

TALLYS CARLYSON DA SILVA

THIAGO MAYCON VILELA DA SILVA

VICTOR RODRIGUES ADABBO

HILLARI GABRIELI RAMOS DA SILVA

ISABELLY CONCEIÇÃO MARTINS

JOÃO PEDRO GOMES SILVA

RYAN PITANGA DE SOUZA

ISABELLA FERNANDA STEFANUTO

RAFAELA LIMA MORAES

YASMIN DE SOUZA

THAINARA NASCIMENTO DOS SANTOS

LEONARDO HENRIQUE ARAUJO

MARIA FERNANDA VARUSSA DOS SANTOS

VICTOR GABRIEL MARTINS SILVA SOUZA

WESLEY DE OLIVEIRA PIRES

PALOMA ARAÚJO OLIVEIRA

Araraquara, 22 de julho de 2025.

Prof. Sinésio Raimundo Gomes

terça-feira, 22 de julho de 2025

2EL - B - Projeto 12 - Cancela Controlada por RFID

P12 - Cancela Controlada por RFID e ARDUINO: HILLARI GABRIELI RAMOS DA SILVA, ISABELLY CONCEIÇÃO MARTINS, JOÃO PEDRO GOMES SILVA e RYAN PITANGA DE SOUZA
Cancela Controlada por RFID

O projeto utiliza Arduino Uno R3, Micro Servo Motor SG90 ou Servo Motor Digital Mg996R, LED, Display Oled 0,96 128x64 e Modulo de comunicação RFID para controlar a abertura e fechamento de uma cancela.
Para este projeto utiliza bibliotecas: Adafruit GFX, Adafruit SSD1306, MFRC522, Servo e SPI

A função de uma cancela está relacionada a um obstáculo móvel, seja ela de pedestres, atletas, hipismo, pedágios, veículos ou animais. Normalmente são feitas de madeira, canos metálicos ou plásticos, mas, podem ser feitas com materiais alternativos como por exemplo o bambu. O acionamento, seja manual ou mecânico, ergue a cancela até a posição vertical para permitir a passagem e baixada paralelamente ao nível do chão, a uma distância média de 80cm de altura para impedir a passagem.

O controle da cancela é feioto pelo Arduíno Uno. O datasheet da placa Arduino UNO R3 está disponível em: Manual Arduino® UNO R3.

Já a cancela é acionada pelo Micro Servo Motor SG90

O Micro Servo Motor SG90 9g é um item essencial para este e outros projetos de robótica, mecatrônica e diversos outros projetos. Na robótica, o servo motor é responsável por movimentar braços, pernas e mãos dos robôs. No automodelismo o servo motor é utilizado para virar as rodas dianteiras dos carrinhos e no aeromodelismo é utilizado para controlar os flaps das asas dos aviões.

O manual do Micro Servo Motor 9g SG90 está disponível em: Micro Servo Motor 9g SG90 .

Tag e leitor RFID (Radio Frequency Identification, ou Identificação por Radiofrequência) costumam ser utilizados para controle de acesso e identificação de pessoas e equipamentos, seja por meio de crachás ou etiquetas aplicadas à produtos.

Circuito Módulo RFID com Arduino: As etiquetas (ou tags) RFID, podem conter vários dados sobre o proprietário do cartão, como nome e endereço e, no caso de produtos, informações sobre procedência e data de validade, apenas para citar alguns exemplos.

Como são compostas apenas por um pequeno circuito, as tags RFID podem ser embutidas facilmente em vários objetos, nos mais variados tamanhos e formatos.

Modulo RFID Mfrc522: Cada etiqueta/tag do leitor RFID tem a sua própria identificação (UID), e é com essa identificação que vamos montar um controle de acesso que irá ler o UID do cartão e exibir as informações de acesso num display LCD 16×2. Com pequenas alterações no programa é possível acionar as outras portas do Arduino e ligar motores, sensores, luzes e outros dispositivos.

O manual do Módulo e tags RFID está disponível em: Modulo RFID Mfrc52.

O código fonte de referência: Cancela Controlada por RFID

// Projeto: Cancela Controlada por RFID 
// Autor: André Silveira
// Data: 03/09/2019

#include "Wire.h" 							// Biblioteca para Comunicação I2C
#include "Adafruit_GFX.h"                   			// Biblioteca para processamento gráfica
#include "Adafruit_SSD1306.h"              			// Biblioteca do controlador SSD1306 (128x64 e 128x32)
#include "SPI.h" 							// Biblioteca comunicação SPI
#include "MFRC522.h" 						// Biblioteca RFID RC522
#include "Servo.h" 							// Biblioteca Servo Motor
 
Adafruit_SSD1306 display = Adafruit_SSD1306(); 
 
#define SDA_PIN 10 							// Pino SDA
#define RST_PIN 9 							// Pino RESET
 
MFRC522 rfid(SDA_PIN, RST_PIN); 				// Define pinos para Módulo RFID
 
Servo servo1;								// Cria objeto Servo
int pos; 									// Variável posição Servo
 
const int PinoLedVerde = 2; 					// Pino digital do LED Verde
const int PinoLedVermelho = 3; 					// Pino digital do LED Vermelho
const int PinoServo = 6; 						// Pino digital do Servo Motor
 
byte CancelaFechada = 74; 					// Ângulo para cancela fechada
byte CancelaAberta = 174; 					// Ângulo para cancela aberta
 
void setup(){ 

      Serial.begin(9600);
      Serial.println("Aproxime o seu cartao do leitor...");
      Serial.println();

      Wire.begin(); 							// INICIALIZA A BIBLIOTECA WIRE
      display.begin(SSD1306_SWITCHCAPVCC, 0x3C);    // Inicializa a tela com endereço I2C 0x3C
      display.setTextColor(WHITE);                  		// Define cor do texto
      display.setRotation(0);                       			// Configura orientação 0      
      display.setTextSize(1); 					// Tamanho do texto
      display.clearDisplay();                  			// Limpa a tela 
      display.setCursor(14,10); 					// Posição cursor
      display.print("Supermercado"); 				// Escreve
      display.display(); 						// Efetiva escrita
     
      SPI.begin(); 							// Inicializa barramento de comunicação SPI
      rfid.PCD_Init(); 							// Inicializa RFID MFRC522
     
      servo1.attach(PinoServo); 					// Associa pino digital ao Servo
      servo1.write(74); 						// Inicializa Servo na posição Cancela Fechada
      
      pinMode(PinoLedVerde, OUTPUT); 			// Pino LED Verde como saída 
      pinMode(PinoLedVermelho, OUTPUT); 			// Pino LED Vermelho como saída
      
      digitalWrite(PinoLedVerde, LOW); 				// LED deslidado
      digitalWrite(PinoLedVermelho, LOW); 			// LED deslidado
}
 
void loop() {
  	leituraRfid(); 							// Chama função para validar TAG RFID
}
 
/* --- Função para validar TAG RFID --- */

void leituraRfid(){
  
/* --- Verifica se cartão é diferente do último lido --- */ 
  
      if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) {
      	  return;
      }
      
      Serial.println("");
      Serial.println("Aguarde um momento");        
      
      display.clearDisplay(); 						// Limpa display
      display.setCursor(40,0); 					// Posiciona cursor
      display.print("Aguarde"); 					// Escreve texto
      display.setCursor(50,10); 					// Posiciona cursor
      display.print("por"); 						// Escreve texto
      display.setCursor(30,20); 					// Posiciona cursor
      display.print("favor..."); 					// Escreve texto
      display.display(); 						// Efetiva escrita
      delay(40); 							
     
/* --- Monta TAG RFID lida --- */ 
      
      String strID = ""; 
      for (byte i = 0; i < 4; i++) {
           strID += (rfid.uid.uidByte[i] < 0x10 ? "0" : "") + String(rfid.uid.uidByte[i], HEX) + (i!=3 ? ":" : "");
      }
      strID.toUpperCase();
  
/* --- Valida endereço da TAG lida comparando com o valor "D0:64:BB:4F" --- */ 
/* --- O endereço "D0:64:BB:4F" deve ser substituído pelo endereço da sua TAG RFID --- */ 

      Serial.println("");
      Serial.print("Identificador (UID) da tag: "); 		
      Serial.println(strID); 						// Imprime na serial o ID da TAG RFID
  
      if (strID.indexOf("CB:F0:03:C5") >= 0 || strID.indexOf("A6:50:22:7E") >= 0) { 
           Serial.println("");
           Serial.println("Acesso autorizado, cancela abrindo");           
           
           digitalWrite(PinoLedVerde, HIGH); 			// Liga LED Verde
           display.clearDisplay(); 					// Limpa display
           display.setCursor(45,5); 					// Posiciona cursor
           display.print("Acesso"); 					// Escreve texto
           display.setCursor(35,15); 				// Posiciona cursor
           display.print("Autorizado"); 				// Escreve texto
           display.display(); 						// Efetiva escrita
           delay(4000); 							// Aguarda 4 segundos
           
           abrirCancela(); 						// Abre cancela
           delay(10000); 						// Aguarda 10 segundos
           fecharCancela(); 						// Fecha cancela
           digitalWrite(PinoLedVerde, LOW); 			// Desliga LED Verde
      }else{ 
           Serial.println("Acesso negado"); 
           
           digitalWrite(PinoLedVermelho, HIGH); 		// Liga LED Vermelho
           display.clearDisplay(); 					// Limpa display
           display.setCursor(45,5);					// Posiciona cursor
           display.print("Acesso");					// Escreve texto
           display.setCursor(45,15);				// Posiciona cursor
           display.print("Negado");					// Escreve texto
           display.display();						// Efetiva escrita
           delay(10000);						// Aguarda 10 segundos
           digitalWrite(PinoLedVermelho, LOW);		// Desliga LED Verde
           display.clearDisplay();					// Limpa display
           display.setCursor(14,10);				// Posiciona cursor
           display.print("MasterWalker Shop");			// Escreve texto
           display.display();						// Efetiva escrita
          }
     
      rfid.PICC_HaltA(); 						// Para leitura do cartão
      rfid.PCD_StopCrypto1(); 					// Para criptografia 

}
 
/* --- Função para abrir Cancela --- */

void abrirCancela(){

      for (pos = CancelaFechada; pos < CancelaAberta; pos++){ 
            servo1.write(pos); 					// Posição que o servo deve girar
            delay(15); 							// Intervalo de 15 Milisegundos
      }
}
 

/* --- Função para fechar Cancela --- */

void fecharCancela(){  

      Serial.println(""); 
      Serial.println("Fechando cancela");        // Escreve

      for (pos = CancelaAberta; pos >= CancelaFechada; pos--) { 
           servo1.write(pos); 						// Posição que o servo deve girar
           delay(15); 
      }
      
      display.clearDisplay(); 						// Limpa informações do display
      display.setCursor(14,10); 					// Posiciona cursor para escrever
      display.print("Supermercado"); 				// Escreve
      display.display(); 						// Efetiva escrita
      
}

Referência: Arduino, Internet das Coisas e Computação vestível - André Luis Marques da Silveira

domingo, 20 de julho de 2025

2EL - B - Projeto 11 - Radar Ultrassônico controlado através Arduino e o software Processing

P11 - Radar Ultrassônico ARDUINO: ISABELLA FERNANDA STEFANUTO, RAFAELA LIMA MORAES, YASMIN DE SOUZA, PALOMA ARAÚJO OLIVEIRA e THAINARA NASCIMENTO DOS SANTOS

Neste projeto você vai aprender a construir um radar ultrassônico utilizando a placa de desenvolvimento Arduino e o software Processing. Iremos usar o nosso conhecimento de programação com o sensor ultrassônico no Arduino (para mais informações, acesse o post “Como conectar o Sensor Ultrassônico ao Arduino“) e substituir a sua leitura da tela no monitor serial pela leitura gráfica, parecida com as usadas na aviação.

Dessa forma, iremos identificar o ângulo e distância que o objeto está de nossa máquina (robô, drone, carro, braço robótico).

Para o projeto, iremos utilizar um sensor ultrassônico fixo em um servo motor. Eles serão responsáveis por realizar uma varredura do ambiente em busca de obstáculos. Os dois componentes serão conectados ao Arduino, o qual coordena o movimento do servo, realiza a leitura do sensor e envia o resultado para o Processing. No Processing será gerado um gráfico como a figura ao lado.

O datasheet da placa Arduino UNO R3 está disponível em: Manual Arduino® UNO R3.

Micro Servo Motor SG90

O manual do Micro Servo Motor 9g SG90 está disponível em: Micro Servo Motor 9g SG90 .

Software Processing

O Processing, além de software, é uma linguagem de programação de código aberto, assim como o Arduino, ele é utilzado para mostrar informações do Arduino na tela do computador. Faça o download do Processing diretamente do site oficial do programa, no endereço: Processing .

Se essa é sua primeira vez utilizando o Processing recomendo a leitura do post “Integrando Processing e Arduino – Criando Interface no Processing“, de Mauricio Gavina do blog da MakerHero.

Materiais Necessários

Abaixo está a lista com os materiais necessários para o projeto:

1 x Arduino Nano (ou outro similar);

1 x Cabo USB;

1 x Micro Servo Motor 9G;

1 x Sensor Ultrassônico HC-SR04;

1 x Base Mini Radar Staction;

1 x Tela TFT 7'';

1x Fonte 5V;

20 x Parafusos e porcas M3;

1 x Protoboard 400 Pontos;

4 x Cabos Jumper Macho-Fêmea;

4 x Cabos Jumper Macho-Macho;

Esquemático Eletrônico

Na figura acima está o esquema de ligação dos componentes: Esquema de ligação do Arduino Nano com o Sensor Ultrassônico fixo no Servo Motor 9G montado por Sandro Mesquita.

O jumper de sinal do servo (amarelo) deve ser conectado ao pino 12 do Arduino. O pinos ECHO e TRIG do sensor ultrassônico devem ser conectados nos 10 e 11 do Arduino, respectivamente. Tanto o servo motor quanto o sensor ultrassônico devem ser alimentados com 5 V, como pode ser visto na imagem acima.

Código do Radar Ultrassônico na IDE Arduino

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <Servo.h>. 
 
const int trigPin = 11;
const int echoPin = 10;
 
long tempo;
int distancia;
 
Servo servo; 
 
void setup() {
  
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 
  Serial.begin(9600);
  servo.attach(12);
 
}
 
void loop() {
  
  for(int i=15;i<=165;i++){  
  servo.write(i);
  delay(30);
  distancia = calculoDistancia();
  Serial.print(i); 
  Serial.print(","); 
  Serial.print(distancia); 
  Serial.print("."); 
  }
  
  for(int i=165;i>15;i--){  
  servo.write(i);
  delay(30);
  distancia = calculoDistancia();
  Serial.print(i);
  Serial.print(",");
  Serial.print(distancia);
  Serial.print(".");
  }
 
}
 
int calculoDistancia(){ 
  
  digitalWrite(trigPin, LOW); 
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH); 
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  tempo = pulseIn(echoPin, HIGH); 
  distancia= tempo*0.034/2;
  return distancia;
 
}

Após carregar o código para a placa, abra o Monitor Serial e selecione a velocidade de 9600. Você verá algo assim:

Como você pode ver acima, a visualização no Monitor Serial não é muito intuitiva. É importante lembrar que nosso objetivo não é ler a distância na Arduino IDE mas sim imprimir um gráfico no Processing. Por esse motivo, a saída deve ser como visto acima, para a correta interpretação pelo Processing.

Código do Radar Ultrassônico no Processing

Abaixo está o código completo do Radar Ultrassônico com Arduino e Processing:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
import processing.serial.*;
import java.awt.event.KeyEvent;
import java.io.IOException;
 
Serial myPort; 
 
String angle="";
String distance="";
String data="";
String noObject;
float pixsDistance;
int iAngle, iDistance;
int index1=0;
int index2=0;
PFont orcFont;
 
void setup() {
 
  size (1366, 700);
  smooth();
  myPort = new Serial(this, "COM11", 9600);
  myPort.bufferUntil('.');
}
 
void draw() {
 
  fill(98, 245, 31);
 
  noStroke();
  fill(0, 4);
  rect(0, 0, width, 1010); 
 
  fill(98, 245, 31); // yeþil renk
 
  drawRadar(); 
  drawLine();
  drawObject();
  drawText();
}
 
void serialEvent (Serial myPort) { 
 
  data = myPort.readStringUntil('.');
  data = data.substring(0, data.length()-1);
 
  index1 = data.indexOf(",");
  angle= data.substring(0, index1);
  distance= data.substring(index1+1, data.length()); 
 
  iAngle = int(angle);
  iDistance = int(distance);
}
 
void drawRadar() {
  pushMatrix();
  translate(683, 700);
  noFill();
  strokeWeight(2);
  stroke(98, 245, 31);
  // draws the arc lines
  arc(0, 0, 1300, 1300, PI, TWO_PI);
  arc(0, 0, 1000, 1000, PI, TWO_PI);
  arc(0, 0, 700, 700, PI, TWO_PI);
  arc(0, 0, 400, 400, PI, TWO_PI);
  // draws the angle lines
  line(-700, 0, 700, 0);
  line(0, 0, -700*cos(radians(30)), -700*sin(radians(30)));
  line(0, 0, -700*cos(radians(60)), -700*sin(radians(60)));
  line(0, 0, -700*cos(radians(90)), -700*sin(radians(90)));
  line(0, 0, -700*cos(radians(120)), -700*sin(radians(120)));
  line(0, 0, -700*cos(radians(150)), -700*sin(radians(150)));
  line(-700*cos(radians(30)), 0, 700, 0);
  popMatrix();
}
 
void drawObject() {
  pushMatrix();
  translate(683, 700);
  strokeWeight(9);
  stroke(255, 10, 10); // kýrmýzý renk
  pixsDistance = iDistance*22.5; 
  // 40 cm ye kadar ölçer
  if (iDistance<40) {
 
    line(pixsDistance*cos(radians(iAngle)), -pixsDistance*sin(radians(iAngle)), 700*cos(radians(iAngle)), -700*sin(radians(iAngle)));
  }
  popMatrix();
}
 
void drawLine() {
  pushMatrix();
  strokeWeight(9);
  stroke(30, 250, 60);
  translate(683, 700);
  line(0, 0, 700*cos(radians(iAngle)), -700*sin(radians(iAngle)));
  popMatrix();
}
 
void drawText() { 
 
  pushMatrix();
  if (iDistance>40) {
    noObject = "Out of Range";
  } else {
    noObject = "In Range";
  }
  fill(0, 0, 0);
  noStroke();
  rect(0, 1010, width, 1080);
  fill(98, 245, 31);
  textSize(25);
  text("10cm", 800, 690);
  text("20cm", 950, 690);
  text("30cm", 1100, 690);
  text("40cm", 1250, 690);
  textSize(40);
  text("Object: " + noObject, 240, 1050);
  text("Angle: " + iAngle +" °", 1050, 1050);
  text("Distance: ", 1380, 1050);
  if (iDistance<40) {
    text("        " + iDistance +" cm", 1400, 1050);
  }
  textSize(25);
  fill(98, 245, 60);
  translate(390+960*cos(radians(30)), 780-960*sin(radians(30)));
  rotate(-radians(-60));
  text("30°", 0, 0);
  resetMatrix();
  translate(490+960*cos(radians(60)), 920-960*sin(radians(60)));
  rotate(-radians(-30));
  text("60°", 0, 0);
  resetMatrix();
  translate(630+960*cos(radians(90)), 990-960*sin(radians(90)));
  rotate(radians(0));
  text("90°", 0, 0);
  resetMatrix();
  translate(760+960*cos(radians(120)), 1000-960*sin(radians(120)));
  rotate(radians(-38));
  text("120°", 0, 0);
  resetMatrix();
  translate(840+900*cos(radians(150)), 920-960*sin(radians(150)));
  rotate(radians(-60));
  text("150°", 0, 0);
  popMatrix();
}

Para testar o funcionamento do circuito, vamos utilizar o código abaixo. Ele é responsável por movimentar o servo motor entre 15º e 165º e calcular a distância entre o sensor ultrassônico e o objeto.
Se preferir, você pode fazer o download do código “Radar com sensor ultrassônico” no GitHub.

Conectando a IDE Processing com a IDE Arduino

Agora precisamos comunicar o Arduino com o programa no Processing que acabamos de desenvolver. Abaixo estão algumas passos desse processo:

1. Na Arduino IDE, verifique qual porta “COM” o Arduino está conectado. Para isso, com o Arduino conectado ao computador, vá em Ferramentas > Porta.

2. Na IDE do Processing, altere a linha abaixo para a porta “COM” que o Arduino está conectado.

myPort = new Serial(this, "COM11", 9600);

3. Certifique que a tela do Monitor Serial está fechada.

4. Na IDE do Processing click no botão “PLAY” conforme figura acima: Código do radar ultrassônico no processing

Funcionamento:

O servo varre 15° a 165°;
Em cada posição, o HC-SR04 mede a distância;
Os dados (ângulo + distância) são enviados via serial;
A linha de varredura é desenhada em verde;
Os objetos são desenhados em linha vermelha, a partir do ponto de detecção;
O Processing visualiza os objetos em tempo real;

Limitações:

Alcance máximo: ~4m (HC-SR04);
Ângulo de detecção: 15° (sensor);
Precisão reduzida em superfícies irregulares;

Resultado Final

Este projeto é ideal para demonstrar princípios de sensoriamento, processamento de dados e visualização. Para aplicações profissionais, considere sensores LIDAR ou radares de alta frequência.

O resultado final do projeto Radar Ultrassônico com Arduino e Processing deve ficar semelhante ao apresentando acima.

O desenho técnico da base do projeto está disponível em: 25_08_01 Base_Radar_IRTY .

Referência: Radar Ultrassônico com Arduino e Processing - Sandro Mesquita - MakerHero® .