Kit Educacional Radar Ultrassônico Compatível com Arduino AE320 RB1848 - Curso Completo

Introdução

Este curso apresenta de forma objetiva e técnica o Kit Educacional Radar Ultrassônico Compatível com Arduino AE320 RB1848, o Simulation Radar Ultrasonic Learning Kit da KUONGSHUN (documentação V1.0.23.12.22), um conjunto didático indicado pelo fabricante para idades a partir de 8 anos que implementa um radar de varredura real. A KUONGSHUN Electronic Company (kuongshun.com) fornece o pacote completo usado neste curso — guia de montagem, preparação de programação, bibliotecas e o sketch — com suporte direto em info@kuongshun.cn e resposta dos engenheiros em até 12 horas: um kit com fabricante que responde pelo que vende, e é por isso que este curso espelha a documentação oficial em vez de reinventá-la. um servo motor SG90 gira o sensor ultrassônico HC-SR04 em 180 graus enquanto a placa controladora compatível com Arduino Uno (LAFVIN R3 com USB-serial CH340) mede distâncias e desenha o gráfico do radar em tempo real no display TFT ST7735 de 1.8 polegada (160x128 na horizontal) com a biblioteca Ucglib. O único firmware do kit, o sketch Simulation_Radar.ino com 300 linhas, faz autoteste de abertura na tela (“Mini Radar” / “Testing…” / “OK!”), calibra o zero mecânico com o servo a 90 graus, e depois varre sem parar: alvos a menos de 100 cm aparecem como pontos vermelhos na posição medida, alvos a 1 metro ou mais aparecem como pontos amarelos na borda, e a telemetria sai no Monitor Serial a 115200 baud no formato Degree e Distance.

O conteúdo segue exatamente a ordem da documentação do fabricante — guia de montagem em 8 passos, preparação do ambiente (Arduino IDE, driver CH340 e bibliotecas Servo e Ucglib) e código do radar (gravação, calibração a 90 graus, operação e perguntas frequentes) — com a teoria de cada componente explicada no ponto em que ele aparece: ultrassom junto da medição, servo junto da varredura, SPI junto da tela. Nada aqui foi inventado fora da referência: cada número, cada cor de ponto e cada passo tem origem numa página do pacote do kit ou no sketch real que veio nele. Releia esta Introdução ao final do curso: cada termo técnico dela (varredura, tempo de voo, anéis, telemetria, calibração) terá virado procedimento de bancada — e é assim que se mede que o curso funcionou. Se algum termo ainda soar abstrato, volte à seção dele e refaça o procedimento correspondente com a peça na mão: conceito sem bancada evapora em uma semana. E traga as dúvidas para o assistente no fim da página: ele responde com base neste curso — informe o sintoma, o que a abertura mostra e o valor do 5 V, e a resposta já vem no contexto certo. Quanto melhor a pergunta (com números, fotos e mensagens exatas), melhor a resposta: “não funciona” rende conselho genérico, “tela branca com HelloWorld branco e 5 V em 4,9” rende o número da falha. Esse hábito — observar, medir, registrar, perguntar com dados — é a habilidade real que o kit ensina; o radar montado é só o troféu. Leve o hábito para o próximo kit, para o próximo sensor, para o próximo projeto: bancada boa não é a que nunca falha, é a que diagnostica rápido. Ao final o leitor terá o radar montado, calibrado e operante, saberá explicar cada bloco do sketch real, ler a tela e o Serial, e resolver as 5 falhas catalogadas pelo fabricante.

O que você vai aprender:

• Montar a torre em 8 passos com a lista de peças exata de cada passo do guia do fabricante
• Instalar a Arduino IDE, o driver CH340 e as bibliotecas Servo e Ucglib pelo método do kit
• Gravar o Simulation_Radar.ino e calibrar o zero do servo a 90 graus pelo ritual do fabricante
• Medir distância com o HC-SR04 e entender a fórmula do tempo de voo usada no código
• Ler a tela do radar: anéis de 25/50/75/100 cm, pontos vermelhos e amarelos, rodapé DEG e cm
• Ler a telemetria no Monitor Serial a 115200 baud
• Diagnosticar as 5 falhas oficiais: tela branca, tela preta, imprecisão, varredura lenta e Serial

Material utilizado: Kit Educacional Radar Ultrassônico Compatível com Arduino AE320 RB1848

Visão geral do kit

O kit é um radar de simulação de bancada: o servo varre o sensor de uma extremidade à outra, o HC-SR04 mede a distância em cada ângulo, e a Uno desenha o resultado como um gráfico de radar na TFT. O tutorial do fabricante resume o aparelho em 3 funções: medição de distância (o ultrassom mede e detecta obstáculos), percepção de direção (o servo dá a posição angular aproximada do objeto no espaço) e monitoramento em tempo real (a rotação contínua atualiza posição e distância sem parar). No prefácio, o fabricante declara a intenção pedagógica: montar e operar o kit dá compreensão de sensores, dinâmica mecânica, processamento de dados e visualização — o pacote STEM completo num projeto divertido. É por isso que cada seção deste curso casa uma peça com um conceito: coluna com esquadro, servo com PWM, ultrassom com tempo de voo, TFT com SPI, programa com calibração. E é por isso que o curso termina onde o tutorial termina, nas perguntas frequentes: dominar o kit é montar certo, calibrar certo e diagnosticar certo — o resto é repetir com capricho. A tela de abertura do firmware ainda executa um autoteste: escreve “Mini Radar” e “Testing…”, gira o servo de 0 a 180 graus para provar que a base não trava nem enrosca fios, e só então mostra “OK!” e começa a varredura.

Por dentro, dois fluxos correm juntos. Fluxo de dados, repetido a cada passo: o servo posiciona o sensor no ângulo X, a Uno dispara o Trig por 10 µs, o HC-SR04 emite o trem a 40 kHz, o Echo volta em T microssegundos, o código converte para centímetros, transforma polar em cartesiano com 1,15 px/cm e acende o ponto via SPI — enquanto o rodapé e o Serial registram ângulo e distância. Fluxo de energia: o USB de 5 V entra pela placa, segue aos trilhos do shield e se distribui em estrela para servo, TFT e sensor, com retorno GND comum. O limite aqui é físico: USB 2.0 entrega 500 mA e o pico do servo no arranque passa disso com a tela acesa — por isso a recomendação oficial de fonte externa quando a tela piscar. Sinal e potência andam separados: o fio laranja do servo carrega só comando (miliamperes), o vermelho carrega potência; inverter essa lógica e puxar 5 V de fileira de sinal é o curto clássico de bancada.

Parâmetro	Especificação	Observação
Kit	KUONGSHUN AE320, doc V1.0.23.12.22	A partir de 8 anos
Placa	Compatível com Arduino Uno (LAFVIN R3)	USB-serial CH340, cabo de dados TYPE-C
Shield	Placa de expansão V5	Barras de 5 V, GND e sinal
Sensor	HC-SR04	Trig D6, Echo D5
Atuador	Servo SG90 180 graus	Sinal D3 (fio laranja), 5 V (vermelho), GND (marrom)
Display	TFT ST7735 1.8 pol, 160x128 na horizontal	CD D9, CS D10, RST D8, SPI por hardware
Firmware	Simulation_Radar.ino, 300 linhas	Bibliotecas Servo, SPI e Ucglib
Cores do radar	Vermelho abaixo de 100 cm, amarelo a 1 m ou mais	Anéis de 25/50/75/100 cm
Telemetria	Monitor Serial a 115200 baud	Formato Degree e Distance
Alimentação	USB 5 V, cabo de dados (nunca só-carga)	Carga pesada: fonte externa 5 V 1 A no shield

Inventário do kit

Confira todas as peças sobre mesa clara antes de montar, seguindo a foto da lista de embalagem do fabricante:

• 1x Placa controladora compatível com Arduino Uno (LAFVIN R3, ATmega328P, USB CH340): o cérebro — roda o sketch, gera o PWM do servo, conversa com a TFT por SPI e imprime a telemetria no Serial.
• 1x Placa de expansão V5 para Uno com barras de 5 V, GND e sinal: elimina protoboard — cada trio de pinos entrega sinal, 5 V e GND lado a lado para servo, sensor e display.
• 1x Módulo ultrassônico HC-SR04 com 4 pinos: os “olhos” — VCC, Trig, Echo e GND; mede de ~2 cm a ~400 cm por tempo de voo do eco a 40 kHz.
• 1x Micro servo SG90 180 graus com bracket, rocker arm e parafusos: o “pescoço” — gira o sensor pelo semicírculo; o rocker é a haste que liga o eixo ao suporte do sensor.
• 1x Display TFT ST7735 1.8 pol com flat de 7 vias: a “tela do radar” — 160x128 na horizontal, cores 16 bits, ligada por SPI por hardware.
• 1x Base e suportes em acrílico cortado a laser (base, 2 suportes, bracket do atuador, bracket do ultrassom, moldura do display): o “esqueleto” — encaixe por pressão, sem cola.
• 4x Colunas de cobre de dupla passagem M3x40 e 4x M3x10, com parafusos escareados M3x10, M3x6, cabeça redonda M3x10 e M2x10, porcas M3, M2 e M1.6, parafusos M1.6x10, autoatarraxantes M1.4x5 e parafuso pequeno do servo: a “fixação” — cada tamanho tem exatamente um lugar, e a lista de cada passo diz qual.
• 1x Fio Dupont de 7 pinos (display) e 1x de 4 pinos (servo e ultrassom): os “nervos” — já no tamanho do kit, sem cortar nem soldar.
• 1x Cabo USB de dados TYPE-C: energia e programa — tem de ser de dados, com os fios D+/D−; cabo só-carga acende a placa mas nunca cria a COM.
• Total: 10 grupos de itens (eletrônica, mecânica, parafusos, cabos e documentação).

💡 Dica: separe os parafusos por tamanho em potes com etiqueta (M3, M2, M1.6, M1.4). O passo 1 avisa: coluna curta combina com parafuso curto — misturar aqui trava a base inteira.

Montagem mecânica em 8 passos

Cada passo abaixo reproduz a página correspondente do guia do fabricante: lista de peças, diagrama de encaixe e notas. Regra geral do acrílico a laser: apresente a peça sem forçar, alinhe todos os pinos ao mesmo tempo e pressione com as polpas dos dedos — se um lado entrar e o outro não, recue e reapresente, nunca use um lado como alavanca.

Ferramentas de bancada: chave Philips PH0 (parafusos M2 e M3 do kit), pinça de ponta fina para alojar porcas, régua ou paquímetro para conferir altura dos pilares, e um pote para separar os parafusos por tamanho. Aprenda a ler os parafusos da lista: M3x10 significa rosca de 3 mm de diâmetro por 10 mm de comprimento; escareado (cabeça chata) afunda no acrílico sem relevo; cabeça redonda prende suportes por cima; coluna de dupla passagem é o pilar de cobre com rosca interna dos dois lados; autoatarraxante abre a própria rosca no plástico. Sem solda em nenhuma etapa — todo o curso usa parafusos, Dupont e flat.

Passo 1 - Pilares de cobre M3

Lista do fabricante: base acrílica x1, parafuso escareado Philips M3x10 x4, parafuso escareado Philips M3x6 x4, coluna de cobre de dupla passagem M3x40 x4, coluna de cobre de dupla passagem M3x10 x4. Nota do fabricante: a coluna curta combina com o parafuso curto.

Encaixe as 4 colunas nos furos da base com os parafusos por baixo, conferindo que as colunas longas e curtas estão nas posições do diagrama. As M3x40 sustentam o nível do servo e as M3x10 os pontos baixos: trocar as duas medidas inclina a torre inteira e o erro só aparece lá no Passo 8, com tudo montado. A base chega com película protetora: remova só a face externa para a montagem — a interna sai no fim, protegendo contra poeira e respingos. Verificação: base sem empeno sobre superfície plana e pilares a 90 graus, todos na mesma altura. Com paquímetro ou régua, confira a altura dos 4 pilares: diferença visível entre eles vira torre torta e feixe torto, e o ajuste fino depois é bem mais caro que 1 minuto de régua agora. Erro clássico: apertar o primeiro pilar até o fim antes dos demais — isso desloca os furos e tensiona o acrílico. O certo é o aperto em cruz em duas passadas: encosto manual em todos até assentar, depois um quarto de volta em cada um. Fotografe a base pronta: a imagem serve de referência contra torção posterior da torre.

⚠️ Atenção: nunca force o acrílico; trinca não tem conserto. Aperte até assentar, sem alicate.

Passo 2 - Estrutura de suporte

Lista do fabricante: suporte acrílico x2, parafuso Philips de cabeça redonda M3x10 x2, porca M3 x2. Notas do fabricante: primeiro prenda a porca na posição do furo correspondente; depois insira o suporte acrílico na placa inferior e trave o parafuso; atenção à orientação do bracket.

Aloje cada porca na cavidade antes de apresentar o suporte — porca fora da cavidade espana o acrílico ao apertar. Na prática: encaixe a porca com a pinça, confira que ela assentou plana (sem balançar) e só então apresente o suporte por cima, segurando a porca com o dedo por baixo na primeira volta do parafuso. Quanto à orientação: os dois suportes têm lado certo — o furo redondo e o rasgo se alinham à base e ao nível do servo conforme o diagrama; suporte espelhado fecha os furos e finge que “não coube”. Na dúvida, apresente sem apertar e compare com a imagem antes de travar. Esse hábito — apresentar seco antes de fixar — vale para todos os passos de acrílico e economiza a peça mais cara do kit: o próprio acrílico, que não tem reposição avulsa garantida. Verificação: estrutura rígida, sem estalos e sem bordas esbranquiçadas (sinal de microfissura). Erro clássico: usar um lado já encaixado como alavanca para forçar o outro — o acrílico a laser tem tolerância de décimos e entra por pressão leve; alavanca cria o ponto de tensão que vira trinca dias depois, com a torre já montada.

⚠️ Atenção: nunca force o acrílico; trinca não tem conserto. Confira a orientação dos suportes no diagrama antes de travar.

Passo 3 - Placa controladora e placa de expansão

Lista do fabricante: placa controladora x1, placa de expansão x1, parafuso escareado M3x6 x4. Notas do fabricante: atenção à direção da placa-mãe e da expansão, não force a expansão às cegas e não a encaixe invertida; se um parafuso da placa estiver difícil demais, pode deixar sem ele — 3 bastam.

Fixe a Uno sobre a base com os conectores USB voltados à abertura traseira do acrílico. USB e jack de energia precisam ficar acessíveis por trás: cabo por cima da torre pega no rocker e vira falha intermitente que some quando você olha. A direção correta é a que deixa as fileiras D0–D13 do shield sobre as fileiras D0–D13 da Uno, com a USB dos dois para o mesmo lado — shield girado 180° encaixa “quase” e entorta tudo. O shield encaixa sobre os headers pino a pino: apresente alinhado, confira fileira por fileira e pressione do centro para as bordas. Pressionar do centro distribui a força por igual entre as fileiras; pressionar pela ponta concentra tudo em 4 pinos e entorta. Você sente o clique metálico de cada fileira assentando — conte os cliques: fileira sem clique é vão futuro e mau contato intermitente. A direção correta é a que deixa as fileiras D0–D13 do shield sobre as fileiras D0–D13 da Uno, com a USB dos dois para o mesmo lado — shield girado 180° encaixa “quase” e entorta tudo. Verificação: shield paralelo à Uno, sem vão e sem pino dobrado. Erro clássico: encaixar torto e entortar uma fileira — endireite com pinça antes de insistir, pois insistir rompe a trilha interna. E não se preocupe se um dos 4 parafusos da placa emperrar: o próprio fabricante autoriza deixar com 3 — placa bem assentada em 3 pontos prende melhor que placa forçada em 4.

⚠️ Atenção: desligue o USB antes de refazer qualquer encaixe. Header torto rompe a trilha interna do shield.

Passo 4 - Servo motor

Lista do fabricante: bracket acrílico do atuador x1, servo motor x1, parafuso Philips de cabeça redonda M2x10 x2, porcas M2 x2, parafuso escareado M3x10 x4. Notas do fabricante: primeiro fixe o servo no bracket; depois instale o conjunto na posição das colunas de cobre; atenção à direção do servo.

Fixe o SG90 ao bracket com os 2 parafusos M2 e as porcas nas abas laterais, com o cabo saindo pelo lado oposto ao eixo para não enrolar no horn. Porca M2 é minúscula e foge da pinça: monte sobre o pote, prenda a porca com um dedo e entre com o parafuso por cima, sem pressa — porca caída dentro da torre some e só reaparece chacoalhando na hora da demonstração. Passe o cabo com uma alça de serviço: folga suficiente para o giro completo sem tracionar, mas sem sobra pendurada que entre no disco de varredura. Depois fixe o conjunto às colunas com os 4 parafusos M3x10, eixo perfeitamente vertical — em cruz, como na base: um quarto de volta em cada, rodando, até os quatro assentarem juntos. Apertar um até o fim puxa o bracket de lado e o eixo sai de prumo sem você perceber. Incline a torre e confira o eixo contra o fio de prumo ou a borda de um esquadro: qualquer inclinação aqui vira feixe inclinado e erro de altura na leitura. Não monte o horn ainda: o zero mecânico só é ajustado com o servo energizado a 90 graus, na calibração. Verificação: servo firme, sem folga lateral, e giro manual do eixo suave nos 180 graus. Erro clássico: montar o conjunto com o eixo inclinado ou o cabo do lado do eixo — o cabo enrola no horn na primeira varredura e o eixo torto vira erro sistemático de ângulo que nenhuma calibração de software corrige direito.

⚠️ Atenção: nunca force o acrílico; trinca não tem conserto. Eixo torto aqui vira erro de ângulo no radar inteiro.

Passo 5.1 e 5.2 - Módulo ultrassônico e rocker arm

Lista do fabricante (5.1): bracket do ultrassom x1, módulo ultrassom x1, parafuso de cabeça redonda M1.6x10 x4, porcas M1.6 x4 — nota: atenção à orientação do módulo. Lista (5.2): bracket montado x1, rocker arm do servo x1, parafuso autoatarraxante M1.4x5 x2, parafuso pequeno do servo x1 — notas: primeiro fixe o rocker no suporte com os dois autoatarraxantes; encaixe o suporte no servo; trave com o parafuso do servo.

Fixe o HC-SR04 ao bracket com os 4 parafusos M1.6, transdutores cilíndricos voltados para frente — módulo invertido mede a própria torre. Confira a orientação pelo cristal oscilador prateado: ele fica para trás, os dois “olhos” para frente. Com o módulo certo na mão, repare nos 4 pinos labeled VCC, Trig, Echo e GND — essa é a ordem que o Passo 7 vai buscar, então memorize a sequência agora. Aperto mínimo: a PCI trinca com torque de M3. Use a chave pequena só com a força de dois dedos; se a porca M1.6 girar junto, segure-a com a pinça pela lateral. Erro clássico: apertar como se fosse M3 e romper a trilha do Trig ou do Echo — o sintoma (sem medição) é idêntico a código errado e faz perder horas no lugar errado.

Prenda o rocker ao suporte com os 2 parafusos M1.4x5, encaixe no eixo estriado do servo e trave com o parafuso central. No guia original, o rocker aparece chamado de “steering wheel” (volante da direção): é a mesma peça, a haste com furos que transmite o giro do eixo ao suporte do sensor. Autoatarraxante pede técnica própria: entre reto, gire devagar e pare ao sentir assentar — forçar depois de assentado espana o furo no plástico e o rocker nunca mais trava. Verificação: feixe paralelo ao horizonte (régua sobre os dois transdutores) e curso manual de 0 a 180 sem o suporte tocar pilares ou flat. Erro clássico: apertar o parafuso central com o rocker fora do eixo — o suporte fica bambo, o feixe balança a cada passo e o radar desenha pontos duplos. O parafuso central deve entrar reto, sem folga axial, mas sem esmagar o plástico.

⚠️ Atenção: nunca force o acrílico; trinca não tem conserto. Trilha rompida no Trig ou Echo gera sintoma idêntico a código errado.

Passo 6 - Display TFT

Lista do fabricante: display LCD/TFT x1, parafuso escareado M3x10 x4, porcas M3 x4. (O guia chama de “LCD Display” por hábito, mas a peça é a TFT colorida ST7735 de 1.8” — o firmware e a fiação deste curso tratam dela como TFT.) Notas do fabricante: o display não pode ser instalado de cabeça para baixo; alinhe o lado com os furos.

Fixe a TFT à moldura com a tela voltada para frente e o flat saindo por baixo em curva suave — dobra viva rompe trilhas e gera listras permanentes. Para conectar o flat: abra a trava do conector puxando com a unha, insira o cabo reto até o fundo (contatos para o lado certo, sem torcer) e feche a trava até o clique. Flat mal encaixado dá listras ou tela branca com todo o resto funcionando — antes de culpar solda, reassente. Deixe cerca de 0,5 mm de folga com as porcas como espaçadores para não trincar a solda do conector. Na prática: aperte até a porca encostar, depois volte um oitavo de volta — esse respiro absorve a dilatação e a vibração do servo sem afrouxar. Verificação: tela centrada no vão e conector do flat totalmente inserido com a trava fechada. Erro clássico: montar a tela de cabeça para baixo e só descobrir no upload, com a imagem invertida — confira o lado dos furos contra o diagrama antes de apertar. E flat com dobra viva não tem conserto: rompe trilhas de cobre e gera listras permanentes; o raio de dobra deve passar folgado, maior que 10 mm até o shield.

⚠️ Atenção: nunca force o acrílico; trinca não tem conserto. Display invertido troca a ordem dos sinais e a tela acende branca.

Passo 7 - Fiação

Lista do fabricante: fio Dupont de 7 pinos e fio Dupont de 4 pinos. Nota do fabricante: concentre-se em identificar a posição de cada fio.

Faça toda a fiação com a placa desligada, seguindo o diagrama do fabricante (placa LAFVIN R3 com CH340 e shield de expansão V5). O ramal do servo usa o código de cores do diagrama: laranja no sinal (D3), vermelho no 5 V e marrom no GND. Fio a fio, sem pressa: os 7 do display (CS, CD, RST, MOSI/SDA, SCK, VCC, GND) do flat até o trio de pinos do shield, conferindo cada cor contra o diagrama; depois os 4 do ultrassom e do servo (VCC, Trig D6, Echo D5, GND no sensor; laranja D3, vermelho 5V, marrom GND no servo), com Trig/Echo lado a lado para não cruzar com o flat do SPI. O pulso de 10 µs do Trig é rápido e agressivo: trançar o par Trig/Echo reduz a diafonia que esse pulso injeta no vizinho — detalhe pequeno que evita leituras fantasmas. Anote as suas cores num papel (sugestão: amarelo CS, verde CD, azul RST, roxo MOSI, cinza SCK, vermelho VCC, preto GND): daqui a um mês, esse papel vale mais que a memória. Prenda os cabos com abraçadeiras fora do disco de varredura de 180 graus, com uns 4 cm de folga no servo para o giro não tracionar. Nunca use D0/D1 para o radar: são a USB-Serial do upload e do debug — qualquer fio ali compete com a gravação e o Monitor.

Sinal	Pino da Uno	Destino	Fio / obs.
Trig	D6	HC-SR04	Pulso de disparo de 10 µs
Echo	D5	HC-SR04	Retorno medido com pulseIn
Servo	D3	SG90	Laranja = sinal; vermelho = 5 V; marrom = GND
CD	D9	TFT	Ordem do construtor: CD, CS, RST
CS	D10	TFT	Chip select do SPI
RST	D8	TFT	Reset do controlador
MOSI	D11	TFT	SPI por hardware (fixo no silício)
SCK	D13	TFT	Clock do SPI (fixo no silício)
VCC/GND	5V/GND	Todos	GND único comum, sem exceção

Verificação tripla antes de energizar: cada fio na posição do diagrama, nenhum condutor encostando no eixo do servo, e continuidade GND entre shield, sensor e display. Puxe cada Dupont de leve (uns 5 N, força de ponta de dedo): fio que sai fácil estava só encostado e falharia na primeira vibração do servo — melhor descobrir agora, com a placa desligada, que no meio da demonstração. O GND único comum é o que amarra as referências: sem ele, o nível HIGH do Echo flutua e o pulseIn mede lixo; com GND duplo por caminhos diferentes (fonte externa sem comum), a corrente de retorno injeta offset e falseia a medição do mesmo jeito. D11/D13 são o MOSI/SCK do hardware SPI da Uno e não podem ser trocados por software. Erro clássico nº 1: trocar CD (D9) com RST (D8) por ler o flat de ponta-cabeça — a tela acende branca e todo o resto funciona, o que engana. Erro nº 2: Trig no pino errado — o pulseIn mede silêncio e o radar zera tudo. Com multímetro, confira cada fio de ponta a ponta (menos de 1 ohm) e 5V contra GND sem bipe antes de ligar.

⛔ Perigo: nunca alimente o servo pelo pino de sinal e nunca inverta VCC/GND da TFT — o ST7735 queima em segundos. Confira 5V contra GND sem bipe de continuidade antes de ligar.

Passo 8 - Fixação do display

Lista do fabricante: suporte do display montado x1. Sem notas — é o encaixe final. “Suporte montado” significa o conjunto do Passo 6 (moldura + TFT + parafusos) descendo sobre os dois suportes verticais da base: se a moldura não desce, não force — volte ao Passo 2 e confira a orientação dos suportes, pois é ali que mora o erro.

Encaixe a moldura com a TFT nos suportes frontais, reaperte cada M3 com um oitavo de volta em cruz e gire o rocker de batente a batente conferindo uns 5 mm de folga contra flat e pilares. Para transporte, trave o rocker com espuma e proteja a tela com o plástico da embalagem; na chegada, confira os pilares (vibração afrouxa latão) e o curso manual antes de energizar. Critério de aceite mecânico: sem vibração nem chocalho, varredura manual suave nos 180 graus e fiação identificada. Parafuso frouxo no bracket vibra com o passo do servo e gera pontos falsos na tela que parecem defeito de software. Fotografe a fiação vista de cima com as cores legíveis: essa foto é o mapa de manutenção futura — na próxima falha, comparar com ela diz em segundos se algum fio saiu do lugar. Fotografe também a etiqueta da placa (LAFVIN R3) e a do shield (V5): se um dia precisar repor peça, esses dois nomes são o que o suporte vai pedir primeiro. Só passe à gravação após o aceite.

⚠️ Atenção: desligue o USB antes de refazer qualquer fiação. Manipule a torre desenergizada: susto com o servo ligado derruba a torre sobre a TFT.

Preparação do ambiente

Com a montagem pronta, o tutorial manda concluir o download do software Arduino, a instalação do driver CH340 e a adição das bibliotecas — tudo antes de abrir o código do radar. A lógica da ordem: a IDE sem driver não enxerga a placa, e o sketch sem bibliotecas não compila — cada camada pressupõe a anterior, e pular etapas só muda o lugar onde o erro aparece, nunca o elimina.

Arduino IDE 2.2.1 no Windows

Baixe a IDE pelo site oficial arduino.cc, na opção Windows Win 10 ou superior 64 bits, clicando em JUST DOWNLOAD. As telas deste curso mostram a IDE 2.2.1, mesma das capturas do fabricante — qualquer 2.x atual serve, com os menus nos mesmos lugares. O pacote do kit traz também o tutorial de instalação para Mac — o fluxo é o mesmo (baixar, instalar, driver, bibliotecas), mudando só as telas; este curso detalha o Windows, que é o caso da bancada com Gerenciador de Dispositivos e COM. Na página de download, ignore os botões de doação (CONTRIBUTE) e o newsletter: o caminho gratuito é sempre o JUST DOWNLOAD — a doação é opcional e não libera nada a mais. O tutorial do kit mostra as três telas da web (opções, doação, newsletter) justamente para você reconhecer cada uma e clicar no lugar certo: Windows 64 bits, JUST DOWNLOAD, e pronto. Se o navegador acusar o instalador, é o SmartScreen reclamando de executável baixado; confirme que veio do arduino.cc e prossiga. As telas do fabricante usam a IDE 2.2.1: qualquer 2.x atual serve, pois os menus usados no curso (Placa, Porta, Monitor Serial, Gerenciador de Bibliotecas) continuam nos mesmos lugares. O que não pode mudar é a placa selecionada — sempre Arduino Uno — e a porta, sempre a do CH340.

Na instalação, aceite a licença (I Agree), escolha instalar para todos os usuários (Anyone) e confirme a pasta de destino antes do Install: são as telas do próprio tutorial do kit, sem segredo — o ponto é não pular nenhuma, pois é no meio delas que o Windows instala o driver USB do Arduino. Ao fim, o instalador oferece criar o atalho na área de trabalho e abrir a IDE: aceite os dois, pois o atalho evita caçar o executável depois e a IDE aberta já serve para o teste Blink da próxima seção. Fixe a IDE na barra de tarefas se a bancada é compartilhada: em turma, cada minuto caçando programa é um minuto a menos de radar.

Durante a instalação o Windows pede para instalar o driver USB do Arduino (ArcBotics) — confirme. Ao fim, clique em Finish e a IDE abre com um sketch em branco: é a mesa de trabalho onde o Simulation_Radar.ino vai ser aberto na Parte 1. Conheça a barra de ferramentas antes de precisar: o ✓ verifica (compila sem gravar — use sempre antes do upload para pegar erro de biblioteca cedo, com a mensagem exata no console inferior), a ➔ grava na placa (com TX/RX piscando), a lupa abre o Monitor Serial e o gráfico abre o Plotter. Salve seus testes com Arquivo → Salvar em pasta própria: sketch sem pasta pede para criar uma a cada gravação, e pasta bagunçada perde arquivo na véspera da feira. Nomeie pastas pelo conteúdo e data (radar_90graus_hoje, blink_teste_usb): daqui a um mês, o nome diz o que cada teste prova sem precisar abrir. Deixe a janela do console visível: é ali que aparecem os percentuais de flash/RAM e a primeira linha vermelha de qualquer erro.

💡 Dica: use sempre a mesma porta USB do PC para a placa. Trocar de porta cria outra COM e o upload falha até você reselecionar.

Teste Blink: a prova da cadeia USB

Antes do radar, valide a cadeia inteira (cabo, driver, placa, porta e upload) com o exemplo Blink: conecte a placa, selecione Ferramentas → Placa → Arduino Uno e a COM do CH340, abra Arquivo → Exemplos → 01.Basics → Blink, clique em Verificar e depois em Upload. Resultado esperado: TX/RX piscando durante a gravação, “Upload concluído” e o LED L piscando a 1 Hz — 1 segundo aceso, 1 apagado, o ritmo do delay(1000) do exemplo. Ritmo diferente (rápido demais, irregular) com o Blink recém-gravado indica que gravou outro sketch por engano: regrave o Blink e observe de novo antes de seguir. Detalhe que volta a aparecer no radar: o LED L divide o pino com o SCK (D13) — por isso, com o firmware do radar gravado, é normal ver o LED tremeluzindo durante o desenho da tela. Não é defeito nem código morse: é o clock do SPI piscando o LED a cada rajada de pixels. Se o Blink não grava, o problema é USB, driver, placa ou porta — nunca o sketch do radar. Só prossiga com o Blink funcionando; ele é o divisor de águas entre “defeito de ambiente” e “defeito de montagem”. Dicionário mínimo do console: “Compilação concluída” (toolchain íntegro, pronto para gravar); “Upload concluído” (bootloader recebeu e verificou); primeira linha vermelha (a causa — o resto é cascata); “Port busy” (feche o Monitor); “No such file or directory” (biblioteca ausente ou IDE sem reiniciar após copiar).

Driver CH340 e porta COM

Na maioria dos PCs o driver instala sozinho ao ligar a placa com o cabo TYPE-C de dados — o próprio tutorial do kit registra que MacOS e Windows fazem isso automaticamente na primeira conexão. Confira no Gerenciador de Dispositivos, em Portas: aparecendo USB-SERIAL CH340 (COMn), está pronto e esta seção inteira vira só conferência. Entenda a COM: é o nome que o Windows dá à porta serial virtual criada pelo CH340 — o número entre parênteses identifica qual USB é, e muda se você trocar de porta ou de PC. Por isso o tutorial avisa que o número varia: não decore “COM11”, decore “a COM que tem CH340 no nome”. Se a placa cair em “Outros dispositivos” como USB Serial sem driver, instale manualmente. Em Linux, o usuário precisa estar no grupo dialout e a placa aparece como /dev/ttyUSB0; em macOS, autorize a extensão do fabricante nas configurações de privacidade.

Instalação manual: botão direito sobre o dispositivo, Atualizar driver, “Procurar driver no meu computador” apontando para a pasta USB_Drive_CH341_3_1 do pacote do kit, e conclua. Repare que os textos do tutorial do fabricante às vezes citam “placa de controle ESP32” nas telas de driver: é reaproveitamento de texto entre kits no documento original — a sua placa é a Uno/LAFVIN com CH340 e a pasta certa é a USB_Drive_CH341_3_1; ignore as menções a ESP32. Saiba ler o Gerenciador: “Outros dispositivos” com USB Serial e ponto de exclamação = sem driver; “Portas (COM e LPT)” com USB-SERIAL CH340 (COMn) = pronto. No Windows 10 o caminho é botão direito no Iniciar → Gerenciador de Dispositivos; no 11, o mesmo pelo menu do botão Iniciar ou pela busca. Dispositivo que aparece e some em loop indica mal contato no cabo ou hub sem fonte — troque cabo e porta antes de reinstalar qualquer coisa. E se o Windows pedir reinicialização após instalar o driver, reinicie de verdade: COM instalada pela metade aparece no Gerenciador mas some na IDE, um estado que confunde até quem já instalou dezenas de vezes.

A prova final, direto do tutorial do fabricante:

Com a porta estável, meça o 5 V sob carga antes de culpar qualquer código: multímetro em DC 20 V, ponta preta no GND do shield e vermelha no 5V — esperado 4,75 a 5,25 V. Abaixo de 4,6 V, o USB está fraco: troque para porta traseira com cabo curto. USB frontal de gabinete e hub sem fonte costumam entregar menos tensão, e o pico do servo derruba o barramento e reinicia a Uno em loop — sintoma que imita defeito de firmware. Repita a mesma medida no par VCC/GND do HC-SR04: tem de repetir o valor do shield; diferença maior que 0,2 V denuncia Dupont rompido por dentro, o defeito invisível mais comum de bancada.

⚠️ Atenção: cabo só-carga não tem os fios de dados D+/D−: a placa acende, mas nenhuma COM aparece. Na dúvida, troque o cabo antes de culpar a placa. Na IDE, selecione sempre a COM do CH340 — porta errada gera erro de upload com hardware íntegro.

Bibliotecas Servo e Ucglib

O pacote do kit traz a pasta libraries com Servo e Ucglib (inclusive os .zip originais das duas, caso precise reinstalar pela via ZIP). O método do fabricante é copiar essa pasta para o local do Sketchbook: copie a pasta libraries, na IDE abra Arquivo → Preferências, clique em BROWSE ao lado de Sketchbook location, cole a pasta no local e confirme com OK. Entenda o Sketchbook: é a pasta onde a IDE guarda seus sketches e suas bibliotecas (em geral Documentos/Arduino); tudo que está em Sketchbook/libraries a IDE enxerga automaticamente — por isso o método do kit funciona sem instalador: é só arquivo no lugar certo. Depois de colar, feche e reabra a IDE: ela indexa as bibliotecas na abertura, então pasta colada com IDE aberta só aparece depois do reinício — detalhe que gera metade dos “instalei e não achou”.

Com as bibliotecas no lugar, o sketch compila e grava sem erro. Feche e reabra a IDE após copiar.

Via alternativa (Gerenciador): Sketch > Incluir Biblioteca > Gerenciar Bibliotecas, busque Ucglib, instale a versão do pacote do kit e reinicie a IDE. Na dúvida entre as vias, prefira a do kit: a pasta libraries do pacote é a combinação testada pelo fabricante com este sketch — Gerenciador com versão diferente pode trazer API mudada e erro estranho em SPI.h ou nos exemplos. Validação extra da Servo: Arquivo > Exemplos > Servo > Sweep deve abrir e compilar — se nem o exemplo da casa compila, o problema é núcleo da IDE, nunca o radar. E o Sweep ainda serve de teste mecânico avulso: gravado com a placa nua (antes da montagem final), ele prova o servo sozinho, isolando “servo com defeito” de “montagem travando o eixo”. Conferência obrigatória nas duas vias: Arquivo > Exemplos > Ucglib > HelloWorld deve abrir; adapte o construtor para Ucglib_ST7735_18x128x160_HWSPI ucg(10, 9, 8), compile e grave — TFT acesa com o texto de teste prova a fiação CS/CD/RST/MOSI/SCK antes do radar. Se o HelloWorld também sair branco, o problema é fiação ou biblioteca, nunca o sketch do radar.

Tabela-mestre de bibliotecas do curso

Biblioteca	Como instalar	Versão usada	Lições
Servo (Servo.h, embutida na IDE)	Nada a instalar; vem com a IDE 2.2.1	Embutida	Código do radar
SPI (SPI.h, embutida na IDE)	Nada a instalar; hardware MOSI D11/SCK D13	Embutida	Código do radar
Ucglib (Ucglib.h, externa, por Olikraus)	Método do kit: copiar a pasta libraries; alternativa: Gerenciador (Sketch > Incluir Biblioteca > Gerenciar Bibliotecas, buscar Ucglib) ou ZIP oficial em https://github.com/olikraus/ucglib	A do pacote do kit	Código do radar

📦 Bibliotecas desta lição: Servo e SPI — embutidas na IDE, nada a baixar. Ucglib — use a pasta libraries do pacote do kit (método acima); pela via Gerenciador, confira em Arquivo > Exemplos > Ucglib > HelloWorld que o exemplo abre e compila sem No such file or directory.

⚠️ Atenção: nunca misture duas cópias da Ucglib (pasta copiada + Gerenciador com versão diferente). Duas cópias geram Multiple libraries found for Ucglib.h e compilação ambígua — apague a antiga com a IDE fechada e reinstale por uma via só.

Parte 1 — Código do radar de simulação

Siga os 5 numerados do tutorial do fabricante, na ordem. O objetivo desta parte é gravar o programa e calibrar o zero do servo a 90 graus.

Antes de começar, o checklist da Parte 0 do tutorial: montagem do guia concluída com aceite mecânico, software Arduino baixado e instalado, driver CH340 com COM estável e bibliotecas Servo e Ucglib no lugar. Se qualquer item estiver pendente, volte à seção correspondente — o código não compensa hardware incompleto, e cada falha aqui embaixo pressupõe a base pronta.

Abrir o programa, ligar a placa e selecionar Uno e porta

① Abra o programa no caminho do pacote do kit (Simulation_Radar.ino). Navegue até a pasta 3. Code and Tutorial/Simulation_Radar e dê duplo clique: com a IDE instalada, o .ino abre direto nela. Se abrir no Bloco de Notas, botão direito → abrir com → Arduino IDE, e marque sempre usar a IDE para .ino — sketch editado em editor sem realce esconde erro bobo de digitação.

② Ligue a placa ao computador com o cabo TYPE-C de dados. Confira que é cabo de dados de verdade: com a placa ligada, a COM do CH340 tem de aparecer no Gerenciador de Dispositivos. Só acender LED não prova nada — cabo só-carga também acende.

③ Em Ferramentas → Placa, selecione Arduino Uno. Parece óbvio, mas é o erro nº 1 de quem alterna entre kits: placa errada gera binário errado e o upload falha ou — pior — grava e o aparelho se comporta de forma esquisita. Confira também que nenhum outro programa está com a COM aberta.

④ Selecione a porta — o número da COM varia por computador; é a COM do CH340 que apareceu no Gerenciador. Se na IDE só aparecer COM1, volte à seção do driver CH340 e instale-o. Anote o número (por exemplo COM11): em turmas, cada bancada tem o seu, e trocar de porta USB muda o número e quebra o upload até reselecionar.

⑤ Grave o programa na placa. A imagem acima mostra o upload com sucesso — repare nos números ao fim (no exemplo do fabricante: sketch com 25438 bytes, 78% da flash; variáveis globais com 698 bytes, 34% da RAM; os valores variam um pouco por versão da IDE). Guarde esses dois percentuais: flash perto de 100% ou RAM perto de 100% explicaria travamentos, mas aqui há folga confortável — se o radar travar, não é memória, é energia ou fiação. A RAM usada (698 bytes) abriga as variáveis globais e a pilha de poucas chamadas aninhadas; sem Strings nem alocação dinâmica no sketch, não há fragmentação nem estouro: o aparelho pode varrer por horas que a memória não é o limite. Leia o painel Output (abaixo do código) como instrumento: os percentuais de flash e RAM dizem a folga do sketch, os avisos em laranja pedem atenção futura e só o vermelho trava. Acostume-se a compilar com o Output aberto desde o Blink: quando o erro real aparecer no radar, você já saberá onde olhar em vez de descobrir a janela na hora do nervoso.

💡 Dica: feche o Monitor Serial e qualquer programa que use a COM antes de gravar. Porta ocupada derruba o upload mesmo com tudo certo.

Erros de upload e o que fazer: Port busy (feche o Monitor e regrave); avrdude: stk500_recv() (placa ou porta errada, cabo só-carga, ou reset fora da janela — aperte RESET na Uno no instante em que a IDE mostra o upload para forçar a janela do bootloader); placa diferente de Uno selecionada (corrija em Ferramentas → Placa). Entenda o mecanismo: a IDE reseta a placa pelo sinal DTR e o bootloader escuta por ~1 segundo; se o antivírus bloqueia o programa de gravação ou outro Monitor ocupa a COM, a janela passa e o upload falha com hardware íntegro. Monitores simultâneos são o caso clássico em dupla: um PC com o Serial aberto e outro tentando gravar pela mesma placa nunca vai funcionar — a COM é exclusiva, um dono por vez. Regra geral: leia a primeira linha vermelha do console, não a última — a cascata seguinte é consequência.

Calibração do zero: servo a 90 graus

O tutorial define: com o servo a 90 graus, o objeto está centralizado. Mas o ângulo do programa e o ângulo real da montagem quase nunca coincidem — por isso existe este ritual, e ele é obrigatório antes da primeira varredura. Entenda o porquê: 90° é o centro geométrico do semicírculo de 0 a 180, então só com o zero certo os dois lados da varredura espelham. Pular a calibração não impede o radar de “funcionar” — ele varre, mede e desenha — mas tudo sai deslocado: alvos à frente aparecem para o lado, e a simetria que valida o aparelho some.

Após o upload, o servo vai para o ângulo inicial de 90 graus por 1 segundo e depois começa a ir e vir. Desconecte o cabo de dados dentro desse 1 segundo — nessa posição congelada dá para ver o estado abaixo. Técnica: segure o conector (nunca puxe pelo cabo) e retire com um movimento firme assim que o servo centrar; sacolejar o conector com a placa ligada provoca microcortes que reiniciam a placa e roubam a janela. Se não der tempo, aperte RESET na placa e desconecte em seguida. O RESET reinicia o sketch do zero: a abertura roda de novo e os mesmos 90 graus por 1 segundo voltam, dando quantas chances forem preciso — é o botão de “replay” da calibração, use sem moderação. E guarde o gatilho de recalibração: qualquer desmontagem, troca de cabo que force o suporte ou queda da torre invalida o zero — refaça o ritual antes da próxima demonstração em vez de descobrir no palco.

Com o suporte parado a 90 graus, confira se o feixe do HC-SR04 aponta para o centro da escala, como na figura. Leia o transferidor da imagem como referência: 0° à esquerda, 180° à direita e 90° no centro, com o feixe centralizado. Dica de bancada: imprima a imagem do transferidor em tamanho real e cole atrás da torre durante a calibração — comparar o feixe real com o impresso é mais preciso que “olhômetro”, e o papel serve de gabarito permanente do kit. Marque no papel as posições 0/90/180 conferidas com o sketch de apoio: na próxima manutenção, é só alinhar e pronto, sem recalibrar do zero. Se o ângulo do servo não bater com a imagem, solte o parafuso central do rocker, separe o rocker do servo, gire até coincidir com a imagem, encaixe de novo e reaperte:

Verificação: escreva um teste com myservo.write(90) — o feixe deve ficar perpendicular à frente da torre; confira 0° e 180° contra um esquadro. Erro aqui entorta o radar inteiro: alvos à frente apareceriam deslocados para o lado na tela. Um sketch mínimo de apoio, só para conferir sem regravar o radar toda hora:

#include <Servo.h>
Servo baseServo;
void setup() { baseServo.attach(3); baseServo.write(90); } // trava a 90 graus
void loop() { } // parado: ajuste o horn com calma

Com esse sketch gravado, o servo fica parado a 90 graus o tempo que for preciso: solte o horn, alinhe o feixe ao gabarito de 90°, recoloque e reaperte. O eixo estriado tem ~21 dentes (passo de ~17°): cada dente que você pula move o zero quase 17°, e inverter o horn dá meio-passo de ~8,5° — é esse o ajuste fino quando nenhum dente crava o centro. Depois confira as extremidades trocando o 90 por 0 e por 180 e regravando — os três pontos (0/90/180) têm de bater no esquadro. O horn tem dentes grossos: se 90 ficar perfeito mas as bordas desviarem para o mesmo lado, inverta o horn (meio-passo de ajuste) e escolha o dente de menor erro médio. Sintomas de zero errado já com o radar rodando: pontos espelhados (alvo à esquerda aparece à direita), varredura assimétrica e anteparo de frente marcando DEG longe de 090 — todos se corrigem no horn, nunca no código.

⚠️ Atenção: corrija o zero reposicionando o horn no dente da estria, nunca com desvio fixo no código — gambiarra no código mascara o zero mecânico e quebra a simetria da varredura.

Tela de abertura e autoteste

Toda vez que energiza, o firmware mostra “Mini Radar” e “Testing…” e gira o servo de 0 a 180 graus em passos de 5 — é o autoteste da base: preste atenção na posição, na postura de giro e em travamentos ou fios enrolando. Só então aparece “OK!” e começa a varredura. Se a base enroscar no flat ou nos pilares nesta hora, desligue e refaça o curso mecânico do Passo 8 antes de culpar o código. Leia a abertura como um checklist: sem “Mini Radar”, a TFT não inicializou (fiação ou biblioteca); com “Testing…” parado e servo imóvel, o sinal do D3 não chega; com “Testing…” mas varredura assimétrica, o horn escorregou e o zero mecânico saiu do lugar. E repare que o “Testing…” fica na tela durante todo o giro de teste: 36 posições a 50 ms somam ~1,8 s — tempo de sobra para observar com calma se a base range, pula ou enrosca em algum ponto específico do curso. Rangido sempre no mesmo ângulo indica pilar ou flat no caminho; rangido aleatório indica folga — dois diagnósticos diferentes, mesmo som. E se o autoteste passar liso mas a varredura real enroscar depois, o culpado é o cabo do servo sem alça de serviço: no teste ele vai e volta uma vez, na operação ele trabalha sem parar e a folga curta aparece.

Operação: o que significam as cores

Realimentada a placa após a calibração, a varredura começa e os resultados aparecem na tela. Com os 180 graus do servo e a medição do ultrassom, a Uno detecta alvos e os representa com pontos de cores diferentes: alvos a menos de 1 metro viram pontos vermelhos na posição medida; alvos a 1 metro ou mais viram pontos amarelos na borda da tela. Repare na elegância do corte: a 1,15 px/cm, 100 cm dariam raio de 115 px — e o código desenha o amarelo no raio fixo de 116 px, exatamente a borda dos anéis. Ou seja, o vermelho é posição medida de verdade e o amarelo é “longe, direção conhecida, distância fora de escala”. Na prática o amarelo pisca menos que o vermelho: como ele mora na borda, qualquer microvariação do ângulo o apaga e reacende — ponto amarelo tremeluzindo com alvo parado é normal, não é falha de contato. E alvo que alterna vermelho e amarelo está exatamente sobre o corte de 100 cm: meio passo para perto ou para longe estabiliza a cor e confirma o limiar na prática. Os anéis da escala marcam 25, 50, 75 e 100 cm, e o rodapé mostra DEG (ângulo) e a distância em cm.

Na prática: objeto parado gera ponto fixo ciclo após ciclo; ponto que pisca uma vez e some é ruído ou eco múltiplo entre paredes — afaste a bancada 1 m das paredes. Anatomia da tela, de baixo para cima: rodapé com DEG (ângulo atual) e distância em cm; linha de base horizontal; 4 arcos (25/50/75/100 cm) com rótulos; escala graduada de 40 a 140 graus; scanline tripla andando (brilhante na frente, rastro e apagador atrás); pontos vermelhos dentro dos anéis e amarelos na borda. Para ler a distância, localize o anel: entre o 1º e o 2º arco, 25 a 50 cm — e confirme no rodapé no instante da passagem. Para o ângulo, leia o DEG no mesmo instante: objeto à frente marca por volta de 085 a 095. Dois objetos separados viram dois pontos em azimutes distintos no mesmo ciclo; objetos separados por menos de ~10° se fundem num ponto alongado, porque o feixe de 15° ilumina os dois de uma vez — é física do sensor, não defeito. E o amarelo também tem leitura: ele diz “há algo nessa direção, a 1 m ou mais” — para mapear a sala, anote os azimutes amarelos girando a base em 4 orientações de 90° e componha os 360° no papel. Sem ponto e Serial disparado: área livre ou objeto absorvente/inclinado — aproxime o padrão de papelão para discriminar os casos. Demonstração clássica de 3 minutos: 30 s mostrando as peças, 60 s de varredura com a mão gerando pontos vermelhos que perseguem o movimento, 60 s com anteparo fixo de papelão a 40 cm em 90° mostrando o ponto estável, 30 s de Serial visível explicando Degree e Distance.

Exercício de cronômetro (entenda o ritmo): marque o tempo de uma varredura completa de ida com o anteparo próximo e depois com a bancada livre. Com eco perto, cada passo dura o movimento do servo mais ~1 ms de ultrassom mais milissegundos de SPI; livre, cada passo pode estourar o timeout de ~1 s do pulseIn — a varredura livre é dramaticamente mais lenta, e essa variação com o ambiente é a assinatura do timeout funcionando, não defeito. Anote os dois tempos no registro de aceite: na próxima falha, tempo muito acima do normal com zeros aponta direto para a falha nº 4.

Exercício de linearidade (validação de bancada): posicione o anteparo de papelão 20x20 cm a 10, 20, 40 e 80 cm, sempre de frente para o feixe, anote 5 leituras do Serial em cada distância e calcule a média. Esperado: médias próximas do valor real com erro de até ~1 cm perto e crescendo com a distância, pois o feixe de 15° espalha e o eco volta mais fraco. Depois incline o anteparo uns 30° e observe a leitura degradar; volte a 90° e confirme o retorno. Esse par de testes separa “sensor com defeito” de “física do ultrassom” — e o segundo caso é o mais comum.

Monitor Serial a 115200 baud

Com o código gravado, clique no ícone do Monitor Serial no canto superior direito da IDE e ajuste para 115200 baud: o ângulo e a distância são impressos no monitor. A lista de baud vai de 300 a 115200 — qualquer valor diferente do Serial.begin(115200) gera hieróglifos: se a tela do radar está certa mas o Serial sai corrompido, o culpado é sempre o baud, nunca o sensor. O Monitor mostra o que chega; não mostra o que a IDE mandou gravar — são canais diferentes na mesma COM, e é por isso que ele precisa estar fechado durante o upload. Ajuste também a terminação de linha para Nova-linha: sem ela, o campo de envio comporta-se de forma estranha e a leitura em alguns PCs mistura linhas.

Cada linha traz Degree (0 a 180) e Distance em cm, em sincronia com o rodapé da TFT. A 115200 baud (8N1, ~11,5 KB/s), cada linha de ~30 bytes leva uns 3 ms — fração do passo, que é dominado pelo servo e pelo pulseIn. Por isso o buffer de 64 bytes nunca transborda: o programa imprime devagar perto do que o USB escoa. Anteparo a 20 cm gera leituras de ~20 no azimute correspondente em todas as passagens; sem eco à vista, a distância dispara — leitura correta de área livre, não falha. Congele a rolagem para ler um ciclo completo e copiar para o relatório. Exemplos de leitura sã: Degree: 90 ,Distance: 20 com o padrão a 20 cm de frente; sequência de Distance subindo e descendo de forma monótona ao aproximar e afastar a mão; valores altos e estáveis (acima de 100) com a bancada livre. Texto corrompido ou símbolos estranhos indicam baud diferente de 115200 — alinhe o Serial.begin e o Monitor. Números congelados com a scanline andando indicam plot travado por distância fora da faixa: restaure a escala e confira a fiação MOSI/SCK. Para o relatório, congele a rolagem num ciclo completo de ida e volta, copie as linhas e cole numa planilha: separando Degree e Distance em colunas dá para contar quantos passos viram eco válido, qual a distância média por quadrante e se há assimetria esquerda-direita (que denunciaria o horn deslocado). Guarde esse arquivo com a foto da TFT: é a evidência numérica do aceite. Formato byte a byte: a palavra Degree:, dois espaços, o ângulo sem zeros à esquerda, quatro espaços, ,Distance:, três espaços e a distância com quebra de linha — qualquer script lê esse protocolo sem alterar o firmware, o que rende um exercício avançado de instrumentação (ler a COM, converter polar-cartesiano e redesenhar o radar no PC).

O sketch por dentro

Esta seção explica o Simulation_Radar.ino real do pacote do kit, bloco a bloco, com o código comentado em português. Os comentários do código estão sem acentos de propósito: sketch colado com acentos pode falhar com stray '\303' in program — escreva identificadores e comentários sempre em ASCII.

Teoria: como o HC-SR04 mede

O pino Trig recebe um pulso de 10 µs que dispara um trem de 8 ciclos a 40 kHz — frequência acima da audição humana (por isso o sensor “clica” em silêncio) e com comprimento de onda de ~8,6 mm, o que dá a ordem de grandeza da resolução: objetos muito menores que isso refletem pouco. A onda viaja, reflete no obstáculo e volta; o pino Echo fica em HIGH durante o voo de ida e volta. A função calculateDistance mede essa largura com pulseIn e converte para centímetros:

$d = \frac{t \times 0{,}034}{2}$

onde $t$ é o tempo em microssegundos e $0{,}034$ cm/µs é a velocidade do som adotada no código (cerca de 340 m/s a temperatura ambiente; a 20 °C o valor real é 343 m/s, diferença de menos de 1%, invisível na escala do radar). Exemplos de conta: eco de 1160 µs → 19,7 cm (≈20 no int); eco de 5800 µs → 98,6 cm (≈98, ainda vermelho); eco zerado → sem eco. Repare que o pulseIn do sketch não usa timeout: sem eco, ele espera pelo limite padrão de 1 segundo — por isso varredura muito lenta com distâncias zeradas sempre indica fio do ultrassom solto (é a 4ª pergunta oficial do fabricante). Limites físicos: zona morta abaixo de ~2 cm (o receptor ainda vibra com o pulso emitido) e feixe de uns 15 graus que exige anteparo plano e de frente — tecido e espuma absorvem e encurtam o alcance, vidro inclinado desvia o feixe por reflexão e some da tela.

Teoria: servo e varredura

A Servo.h gera o PWM de 50 Hz no D3 sem bloquear o programa: attach(3) vincula, write(ângulo) posiciona — 1000 µs para 0 grau, 1500 µs para o centro de 90 graus e 2000 µs para 180 graus, relação linear no período de 20 ms:

$\tau = 1000\,\mu s + \frac{\theta}{180}\cdot 1000\,\mu s \quad T = 20\,ms$

Para 45°: 1250 µs; para 135°: 1750 µs. A biblioteca usa o Timer de 16 bits da Uno e gera o pulso por interrupção — por isso o loop anda livre enquanto o servo segura a posição, e o potenciômetro interno desliga o motor ao atingir o alvo. A varredura do radar é ida e volta contínuas entre ~0 e ~180 graus em passos de 2, sem salto brusco de 180 para 0 que forçaria a engrenagem. Corrente: o servo puxa picos no arranque — por isso vai ao 5 V direto do shield com GND comum; alimentar pelo pino de sinal derruba a tensão e reinicia a Uno. O sintoma clássico de energia no limite é a TFT apagando no arranque do servo: hub alimentado ou porta traseira resolve. E nunca write fora de 0–180: força o potenciômetro interno contra o batente e desgasta a engrenagem plástica.

Teoria: TFT e SPI

O display usa o barramento SPI por hardware (MOSI D11, SCK D13, fixos no silício) mais 3 GPIOs: CD D9, CS D10 e RST D8 — exatamente a ordem do construtor ucg(9, 10, 8). No SPI, a Uno é mestre e gera o clock: a cada pulso de SCK um bit sai pelo MOSI e a TFT selecionada pelo CS em nível baixo o amostra; CD em nível comando interpreta o byte como instrução do ST7735, em nível dado como pixel; RST com pulso baixo reinicia o controlador. A ~8 MHz, um ponto com endereçamento leva dezenas de microssegundos — por isso a scanline de ~88 pontos por varredura custa milissegundos (fração do tempo do servo), e redesenhar a tela cheia a cada passo seria um desastre de taxa. O firmware trabalha com a tela na horizontal de 160x128 (setRotate90(); se a imagem sair invertida na sua variante de ST7735, troque para setRotate270), abre em modo sólido e desenha ponto a ponto porque os 2 KB de RAM da Uno não comportam um framebuffer — a tela cheia de 40 KB levaria dezenas de milissegundos no SPI a cada redesenho, por isso o fundo se pinta uma vez por varredura. A escala do radar é 1,15 pixel por cm, e o rodapé DEG/cm é redesenhado a cada passo com limpeza prévia da faixa para não deixar fantasmas de dígitos (o “120” sobre o “20” viraria “200”). Tela branca após upload com resto funcionando = CS/CD/RST trocados ou Ucglib ausente; confira primeiro o HelloWorld adaptado.

Item	Descrição
Placa	Uno (LAFVIN R3) com shield V5
Pinos	Trig D6, Echo D5, Servo D3, TFT CD D9 CS D10 RST D8 MOSI D11 SCK D13, VCC GND
Energia	USB 5 V de dados (cabo TYPE-C); servo no 5 V do shield, nunca pelo pino de sinal

📦 Bibliotecas deste sketch: Servo e SPI — embutidas na IDE, nada a baixar. Ucglib — a pasta libraries do pacote do kit (seção de bibliotecas acima). Repare que o sketch inclui com aspas (#include "Ucglib.h"): com a pasta copiada no Sketchbook, compila direto. O que cada uma faz aqui: Servo abstrai o Timer e o PWM do D3; SPI opera o barramento de hardware da TFT; Ucglib oferece primitivas (drawPixel, drawLine, drawCircle, drawDisc, print) e fontes em flash (logisoso18 no splash, helvB08 no “Testing…”, orgv01 nos rótulos) sem custar RAM.

/* Mini radar kit - Simulation_Radar.ino (pacote do fabricante) */
#include <Servo.h>    // embutida: gera o PWM do servo sem bloquear
#include <SPI.h>      // embutida: barramento da TFT (MOSI D11, SCK D13)
#include "Ucglib.h"   // do kit: graficos sem framebuffer (entre aspas pois vem na pasta libraries)
#define  trigPin   6  // Trig do HC-SR04 no D6
#define  echoPin   5  // Echo do HC-SR04 no D5
#define  ServoPin  3  // Sinal do servo no D3
int Ymax = 128;       // pixels verticais da tela
int Xmax = 160;       // pixels horizontais da tela
int Xcent = Xmax / 2; // centro horizontal do radar (80)
int base = 118;       // linha de base do desenho
int scanline = 105;   // comprimento da linha de varredura
Servo baseServo;      // objeto do servo da varredura
Ucglib_ST7735_18x128x160_HWSPI ucg(/*cd=*/ 9, /*cs=*/ 10, /*reset=*/ 8); // TFT: CD D9, CS D10, RST D8

Xcent, base e scanline são a geometria do radar: origem no centro-inferior (80, 118) e scanline de 105 px. Mudar a escala sem recalibrar os anéis de 25/50/75/100 cm quebra a leitura — por isso a calibração oficial mexe só no zero mecânico, nunca nestes números.

Mapa do sketch

Bloco	Linhas	Papel em uma frase
Cabeçalho e pinagem	1–14	Includes, D6/D5/D3, geometria 160x128 e construtor da TFT
setup + abertura	17–68	Inicializa tudo, mostra “Mini Radar”, autotesta a base e limpa a tela
cls	71–84	Limpa a tela com caixas pretas
calculateDistance	87–101	Dispara, mede o eco e converte para cm
fix_font	103–114	Rótulos dos anéis de 25/50/75/100 cm
fix	116–179	Fundo estático: arcos, escala, moldura e legenda
loop ida e volta	183–300	Varre 180→4 e 1→176 plotando pontos, Serial e rodapé

void setup(void)
{
  ucg.begin(UCG_FONT_MODE_SOLID); // inicializa a tela em modo solido
  ucg.setRotate90();              // tela na horizontal 160x128 (se inverter, use setRotate270)
  pinMode(trigPin, OUTPUT);       // Trig como saida
  pinMode(echoPin, INPUT);        // Echo como entrada
  Serial.begin(115200);           // telemetria Degree/Distance
  baseServo.attach(ServoPin);     // vincula o servo ao D3

  // tela de abertura
  ucg.setFontMode(UCG_FONT_MODE_TRANSPARENT);
  ucg.setColor(0, 0, 100, 0);
  ucg.setColor(1, 0, 100, 0);
  ucg.setColor(2, 20, 20, 20);
  ucg.setColor(3, 20, 20, 20);
  ucg.drawGradientBox(0, 0, 160, 128);
  ucg.setPrintDir(0);
  ucg.setColor(0, 5, 0);
  ucg.setPrintPos(27, 42);
  ucg.setFont(ucg_font_logisoso18_tf);
  ucg.print("Mini Radar");
  ucg.setColor(0, 255, 0);
  ucg.setPrintPos(25, 40);
  ucg.print("Mini Radar");
  ucg.setFont(ucg_font_helvB08_tf);
  ucg.setColor(0, 255, 0);
  ucg.setPrintPos(40, 100);
  ucg.print("Testing...");
  baseServo.write(90);
  delay(1000);

  // testa a base de 0 a 180 em passos de 5: observe travamentos e fios enrolando
  // 36 posicoes x 50 ms = ~1,8 s de autoteste mecanico
  for (int x = 0; x < 180; x += 5)
  {
    baseServo.write(x);
    delay(50);
  }
  ucg.print("OK!");
  delay(500);
  ucg.setColor(0, 0, 0, 0);
  ucg.setColor(1, 0, 0, 0);
  ucg.setColor(2, 0, 0, 0);
  ucg.setColor(3, 0, 0, 0);

  // limpa a tela e fixa a fonte dos rotulos
  cls();
  ucg.setFont(ucg_font_orgv01_hr);
  ucg.setFontMode(UCG_FONT_MODE_SOLID);
}

O setup executa uma vez: abre Serial e servo, pinta a abertura em degradê, centraliza a 90 por 1 segundo (é aqui que acontece o ritual de calibração: desconecte o cabo ou dê RESET nessa janela), roda o autoteste mecânico e limpa a tela para a varredura. O write(90) + delay(1000) não é enfeite — é o instante oficial de conferir e corrigir o zero. As três fontes contam a hierarquia visual: logisoso18 grande no título “Mini Radar”, helvB08 pequena no “Testing…”, orgv01 mínima nos rótulos dos anéis — todas moram na flash, nenhuma consome a RAM de 2 KB.

void cls()
{
  // limpa a tela desenhando caixas pretas (sem clearScreen)
  ucg.setColor(0, 0, 0, 0);
  for (int s = 0; s < 128; s += 8)
    for (int t = 0; t < 160; t += 16)
    {
      ucg.drawBox(t, s, 16, 8);
    }
}

Repare na linha comentada do setup (//ucg.clearScreen();): o autor testou o apagamento pronto da biblioteca e optou pelo cls() manual em blocos de 16x8 — mesma função, mas explícita e sem depender de comando que varia entre lotes do controlador. É um detalhe que conta a filosofia do sketch inteiro: nada de mágica escondida, cada efeito desenhado à mão.

int calculateDistance()
{
  long duration;
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);   // garante nivel anterior limpo
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);  // dispara o trem de 8 ciclos a 40 kHz
  digitalWrite(trigPin, LOW);
  // largura do eco em microssegundos (SEM timeout: padrao de 1 s)
  duration = pulseIn(echoPin, HIGH);
  // converte tempo de voo em distancia
  return duration * 0.034 / 2;
}

Os 2 µs de LOW inicial não são frescura: garantem que o pino estava baixo antes do pulso, pois um HIGH residual encurtaria o disparo e o sensor nem acordaria. E os 10 µs de HIGH são o mínimo que o HC-SR04 reconhece como ordem de disparo — menos que isso, silêncio; mais que isso, sem ganho.

Retorno em ponto flutuante truncado para int no loop: erro máximo de 1 cm, invisível na escala de 1,15 px/cm. E atenção ao detalhe que explica a falha oficial nº 4: sem argumento de timeout, cada passo sem eco bloqueia ~1 segundo — varredura arrastada com zeros é fiação, nunca “servo lento”.

void fix_font()
{
  // rotulos dos aneis de 25/50/75/100 cm (posicoes calculadas a partir da base 118)
  ucg.setColor(0, 180, 0);
  ucg.setPrintPos(70, 128 - 120 + 7);
  ucg.print("100cm");
  ucg.setPrintPos(70, 128 - 85 - 11);
  ucg.print("75cm");
  ucg.setPrintPos(70, 128 - 60 - 8);
  ucg.print("50cm");
  ucg.setPrintPos(70, 128 - 35 - 4);
  ucg.print("25cm");
}

void fix()
{
  ucg.setColor(0, 40, 0);
  // fundo: base, arcos de 29/58/86/115 px e linha da base
  // cada arco sai em 2 metades (UPPER_LEFT + UPPER_RIGHT) que se juntam no topo
  // metades separadas porque a biblioteca desenha meio circulo por chamada
  ucg.drawDisc(Xcent, base + 1, 3, UCG_DRAW_ALL);  ucg.drawCircle(Xcent, base + 1, 115, UCG_DRAW_UPPER_LEFT);
  ucg.drawCircle(Xcent, base + 1, 115, UCG_DRAW_UPPER_RIGHT);
  ucg.drawCircle(Xcent, base + 1, 86, UCG_DRAW_UPPER_LEFT);
  ucg.drawCircle(Xcent, base + 1, 86, UCG_DRAW_UPPER_RIGHT);
  ucg.drawCircle(Xcent, base + 1, 58, UCG_DRAW_UPPER_LEFT);
  ucg.drawCircle(Xcent, base + 1, 58, UCG_DRAW_UPPER_RIGHT);
  ucg.drawCircle(Xcent, base + 1, 29, UCG_DRAW_UPPER_LEFT);
  ucg.drawCircle(Xcent, base + 1, 29, UCG_DRAW_UPPER_RIGHT);
  ucg.drawLine(0, base + 1, Xmax, base + 1);

  ucg.setColor(0, 120, 0);
  // escala graduada de 40 a 140 graus
  for (int i = 40; i < 140; i += 2)
  {
    if (i % 10 == 0)
      ucg.drawLine(105 * cos(radians(i)) + Xcent, base - 105 * sin(radians(i)), 113 * cos(radians(i)) + Xcent, base - 113 * sin(radians(i)));
    else
      ucg.drawLine(110 * cos(radians(i)) + Xcent, base - 110 * sin(radians(i)), 113 * cos(radians(i)) + Xcent, base - 113 * sin(radians(i)));
  }

  // enfeites do painel: barras laterais e legenda colorida
  ucg.setColor(0, 200, 0);
  ucg.drawLine(0, 0, 0, 18);
  for (int i = 0; i < 5; i++)
  {
    ucg.setColor(random(255), random(255), random(255));
    ucg.drawBox(2, i * 4, random(14) + 2, 3);
  }

  ucg.setColor(0, 0, 180);
  ucg.drawFrame(146, 0, 14, 14);
  ucg.setColor(0, 0, 60);
  ucg.drawHLine(148, 0, 10);
  ucg.drawVLine(146, 2, 10);
  ucg.drawHLine(148, 13, 10);
  ucg.drawVLine(159, 2, 10);

  ucg.setColor(random(255), random(255), random(255));
  ucg.drawBox(148, 2, 4, 4);
  ucg.setColor(0, 220, 0);
  ucg.drawBox(148, 8, 4, 4);
  ucg.setColor(random(255), random(255), random(255));
  ucg.drawBox(154, 8, 4, 4);
  ucg.setColor(random(255), random(255), random(255));
  ucg.drawBox(154, 2, 4, 4);

  ucg.setColor(0, 0, 90);
  ucg.drawTetragon(62, 123, 58, 127, 98, 127, 102, 123);
  ucg.setColor(0, 0, 160);
  ucg.drawTetragon(67, 123, 63, 127, 93, 127, 97, 123);
  ucg.setColor(0, 255, 0);
  ucg.drawTetragon(72, 123, 68, 127, 88, 127, 92, 123);
}

fix() desenha o fundo estático (arcos, escala, moldura, legenda) e fix_font() os rótulos — uma vez por varredura, nunca por passo, para não travar a taxa nem causar flicker. Os enfeites do canto (barrinhas coloridas, moldura azul e legenda) são decorativos: provam que a escrita RGB funciona em todas as cores — se uma cor sumir dos enfeites, o defeito é bit travado no SPI, não lógica do radar. Os três tetragonos sobrepostos na base formam o pedestal do centro do radar, de onde partem scanline e arcos. E os raios 29/58/86/115 não são arbitrários: a 1,15 px/cm, 25 cm dariam raio de 115 px — e o código desenha o amarelo no raio fixo de 116 px, exatamente a borda dos anéis. Ou seja, o vermelho é posição medida de verdade e o amarelo é “longe, direção conhecida, distância fora de escala”. A escala graduada vai só de 40 a 140 graus porque as bordas do semicírculo (perto de 0 e 180) ficam espremidas na projeção e os tracinhos se amontoariam; o centro, onde a leitura importa, ganha marca a cada 2 graus e traço longo a cada 10. É a mesma lógica dos limites 4 e 176 do loop: as extremidades mecânicas existem para chegar, não para morar — medição séria acontece no miolo da varredura. A conversão polar-cartesiana dos pontos segue:

$x = 80 + 1{,}15 \cdot d \cdot \cos(\theta) \quad y = 118 - 1{,}15 \cdot d \cdot \sin(\theta)$

void loop(void)
{
  int distance;

  fix();
  fix_font();  // repinta o fundo uma vez por varredura

  for (int x = 180; x > 4; x -= 2) {   // ida: do servo de 180 a 0 graus
    // limites 4 e 176 (em vez de 0 e 180 cravados) poupam os batentes do servo
    baseServo.write(x);                // posiciona o servo

    // scanline tripla: brilhante, rastro e apagador
    int f = x - 4;
    ucg.setColor(0, 255, 0);
    ucg.drawLine(Xcent, base, scanline * cos(radians(f)) + Xcent, base - scanline * sin(radians(f)));
    f += 2;
    ucg.setColor(0, 128, 0);
    ucg.drawLine(Xcent, base, scanline * cos(radians(f)) + Xcent, base - scanline * sin(radians(f)));
    f += 2;
    ucg.setColor(0, 0, 0);
    ucg.drawLine(Xcent, base, scanline * cos(radians(f)) + Xcent, base - scanline * sin(radians(f)));
    ucg.setColor(0, 200, 0);

    distance = calculateDistance();    // mede em cm

    // ponto vermelho perto, ponto amarelo na borda quando longe
    if (distance < 100)
    {
      ucg.setColor(255, 0, 0);
      ucg.drawDisc(1.15 * distance * cos(radians(x)) + Xcent, -(1.15 * distance * sin(radians(x))) + base, 1, UCG_DRAW_ALL);
    }
    else
    { // 1 metro ou mais: amarelo na borda, raio fixo de 116 px
      ucg.setColor(255, 255, 0);
      ucg.drawDisc(116 * cos(radians(x)) + Xcent, -116 * sin(radians(x)) + base, 1, UCG_DRAW_ALL);
    }

    // telemetria: angulo e distancia no Serial
    Serial.print("Degree:  ");
    Serial.print(x);
    Serial.print("    ,Distance:   ");
    Serial.println(distance);

    if (x > 70 and x < 110)  fix_font();  // scanline passou sobre os numeros: redesenha
    // rodape na faixa y=126: rotulo, angulo e distancia com espacos de limpeza
    // x=0 rotulo, x=24 angulo, x=125 distancia — posicoes fixas na faixa inferior
    ucg.setColor(0, 0, 155, 0);
    ucg.setPrintPos(0, 126);
    ucg.print("DEG: ");
    ucg.setPrintPos(24, 126);
    ucg.print(x);
    ucg.print("  ");   // espacos apagam o digito anterior (120 sobre 20 nao vira 200)
    ucg.setPrintPos(125, 126);
    ucg.print("  ");
    ucg.print(distance);
    ucg.print("cm  ");
  }
  delay(50);   // respiro entre varreduras antes de limpar e recomecar
  cls();
  fix();
  fix_font();

  for (int x = 1; x < 176; x += 2) {   // volta: de 1 a 176 graus (espelho, sem salto)
    baseServo.write(x);
    int f = x + 4;
    ucg.setColor(0, 255, 0);
    ucg.drawLine(Xcent, base, scanline * cos(radians(f)) + Xcent, base - scanline * sin(radians(f)));
    f -= 2;
    ucg.setColor(0, 128, 0);
    ucg.drawLine(Xcent, base, scanline * cos(radians(f)) + Xcent, base - scanline * sin(radians(f)));
    f -= 2;
    ucg.setColor(0, 0, 0);
    ucg.drawLine(Xcent, base, scanline * cos(radians(f)) + Xcent, base - scanline * sin(radians(f)));
    ucg.setColor(0, 200, 0);
    distance = calculateDistance();
    if (distance < 100)
    {
      ucg.setColor(255, 0, 0);
      ucg.drawDisc(1.15 * distance * cos(radians(x)) + Xcent, -(1.15 * distance * sin(radians(x))) + base, 1, UCG_DRAW_ALL);
    }
    else
    {
      ucg.setColor(255, 255, 0);
      ucg.drawDisc(116 * cos(radians(x)) + Xcent, -116 * sin(radians(x)) + base, 1, UCG_DRAW_ALL);
    }
    Serial.print("Degree:  ");
    Serial.print(x);
    Serial.print("    ,Distance:   ");
    Serial.println(distance);
    if (x > 70 and x < 110)  fix_font();
    ucg.setColor(0, 0, 155, 0);
    ucg.setPrintPos(0, 126);
    ucg.print("DEG: ");
    ucg.setPrintPos(24, 126);
    ucg.print(x);
    ucg.print("   ");
    ucg.setPrintPos(125, 126);
    ucg.print("   ");
    ucg.print(distance);
    ucg.print("cm   ");
  }
  delay(50);
  cls();
}

Cada passo da varredura faz: posiciona o servo, desenha a scanline tripla (linha brilhante na frente, rastro médio e apagador preto atrás — é assim que a “cauda” do radar anda sem redesenhar a tela), mede, plota o ponto na cor certa, imprime no Serial e atualiza o rodapé. O rodapé merece atenção: os espaços impressos depois dos números não são capricho — sem eles, um “120” escrito sobre um “20” anterior deixaria um “0” fantasma (“200”); os espaços apagam o dígito velho a cada passo. A volta espelha a ida para não dar o salto de 180 a 0 que estressaria a engrenagem. Entre varreduras, delay(50) + cls() + fundo novo. Entenda a scanline como três pincéis: o primeiro (f = x - 4, verde cheio) é a frente que avança; o segundo (f += 2, verde médio) é o rastro de um passo atrás; o terceiro (preto) apaga dois passos atrás. Esse é o truque que cria persistência sem framebuffer e sem redesenhar os arcos — redesenhar o fundo a cada passo travaria a taxa e causaria flicker, por isso fix() roda uma vez por varredura. E o if (x > 70 and x < 110) fix_font() existe porque a scanline passa por cima dos rótulos 50/75 cm no centro da tela: sem redesenhar os números, eles ficariam comidos pela linha verde.

Gravação e resultado esperado: selecione Uno e a COM do CH340, compile (erro em Ucglib.h = biblioteca), grave, observe a abertura “Mini Radar” → autoteste do servo → “OK!” → scanline varrendo com pontos vermelhos sobre o anteparo a 20 cm, rodapé DEG/cm sincronizado e Serial imprimindo Degree/Distance coerentes.

Parte 2 — Perguntas frequentes

As 5 perguntas oficiais do tutorial do fabricante, com a causa raiz e a ação corretiva de cada uma. Use esta ordem como árvore de decisão: tela não acende direito → falhas 1 e 2; mede errado → falha 3; anda devagar → falha 4; não sei ler → dúvida 5. Só passe ao próximo galho com o anterior verde. E repare que o tutorial separa “tela que funciona e degrada” (falha 1, energia) de “tela que nunca funcionou” (falha 2, fiação): essa distinção sozinha resolve metade dos diagnósticos errados, onde se reinstala biblioteca para problema de fio e se refaz fiação para problema de fonte.

#	Sintoma (fabricante)	Causa raiz	Ação corretiva
1	Tela pisca e fica branca após um tempo ligado	Fonte da Uno insuficiente para o consumo da tela	Alimentação externa: use os bornes do shield, outra fonte 5 V 1 A ou powerbank
2	Tela branca ao ligar, ou sempre preta	Fiação errada ou Dupont frouxo	Confira o diagrama fio a fio e reconecte; empurre cada Dupont até a trava
3	Precisão da medição baixa	Fonte fraca + material/orientação do alvo (superfície e ângulo mudam o reflexo; cilindro alarga, mesa bagunçada espalha)	Alimentação externa + anteparo plano de papelão de frente para validar
4	Varredura lenta e distâncias sempre 0	Fio do ultrassom solto: sem eco, o pulseIn sem timeout espera ~1 s por passo	Confira Trig D6, Echo D5, VCC e GND do HC-SR04
5	Como ver a distância do ultrassom	Recurso desconhecido	Monitor Serial a 115200 baud: imprime ângulo (Degree) e distância (Distance)

Para a falha nº 1, o fabricante mostra onde entra a energia externa:

Diagnóstico da falha nº 1 em 3 passos: primeiro meça o 5 V sob carga (4,75 a 5,25 V esperado); depois repita a medida no par VCC/GND do HC-SR04 — diferença maior que 0,2 V denuncia Dupont rompido; por fim ligue a fonte externa de 5 V 1 A nos bornes do shield (ou powerbank) e observe uma varredura completa sem piscar. Se estabilizar, era energia — guarde a fonte externa para feiras, onde a torre opera horas seguidas.

Para a falha nº 2, volte ao diagrama oficial e confira fio a fio — CS/CD/RST trocados dão exatamente tela branca com todo o resto funcionando:

Diagnóstico da falha nº 2 em 3 passos: grave o HelloWorld adaptado ao construtor do kit — se também sair branco, o problema é fiação ou biblioteca, nunca o sketch do radar; confira CD→D9, RST→D8 e CS→D10 nessa ordem (a troca mais comum é CD com RST por ler o flat de ponta-cabeça); por fim reassente o flat com a trava aberta e feche até o clique. Tela sempre preta com Serial rolando aponta o mesmo caminho: sem inicialização, sem imagem.

Para a falha nº 3, valide com protocolo antes de declarar defeito: anteparo de papelão 20x20 cm a 20 cm deve retornar 19–21 cm estáveis; mão a 50 cm retorna com mais variância pelo formato irregular — isso é física do feixe, não defeito. O próprio fabricante dá os exemplos: objeto cilíndrico “alarga” na tela (o feixe vê as bordas), e mesa bagunçada faz a distância pular (vários ecos competindo). Três leituras com média eliminam outliers de eco múltiplo. Se o erro for sistemático (sempre X cm a mais), anote a temperatura ambiente: o divisor real varia com o calor, e o código usa 0,034 fixo.

Para a falha nº 4, o teste é binário: desconfie da fiação sempre que a varredura arrastar com zeros. Confira Trig D6 com pulso de 10 µs saindo, Echo D5 devolvendo largura, VCC com 5 V e GND contínuo até o shield. Fio certo e sintoma igual = Dupont rompido por dentro (troque o fio) ou módulo com trilha trincada pelo aperto excessivo do Passo 5.1.

Para a dúvida nº 5, o ritual: código gravado, Monitor aberto pelo ícone do canto superior direito, 115200 baud, Nova-linha. Sem texto e com símbolos corrompidos = baud divergente; sem texto e limpo = Serial.begin diferente ou Monitor na porta errada. E o botão de rolagem do Monitor (congelar) é seu melhor amigo: com a varredura correndo, a tela rola rápido demais para ler — congele, leia o ciclo com calma, copie, descongele. Para comparar dois momentos (antes e depois de um ajuste), congele, copie para um arquivo, ajuste, congele de novo em outro arquivo: diff de pobre, diagnóstico de rico.

Outros erros de ambiente que aparecem na bancada e seguem a mesma lógica: COM que some (driver CH340 — volte à seção de preparação), upload que falha (placa ou porta errada na IDE), e cabo só-carga (troque por cabo de dados TYPE-C). Antes de acionar qualquer garantia, repita a calibração a 90 graus e o autoteste da abertura: 9 em cada 10 casos se resolvem em fiação, driver ou cabo, sem troca de peças. E ao pedir ajuda, leve o kit de informações que resolve na primeira resposta: mensagem exata do console ou do Serial, foto da fiação vista de cima, valor do 5 V sob carga e o que a abertura mostra (“Mini Radar”, “Testing…”, “OK!” ou onde para). Sobre garantia: peças eletrônicas e mecânicas têm cobertura contra defeito de fabricação, mas acrílico trincado por torque excessivo e servo com engrenagem forçada além de 180° caracterizam mau uso — daí a importância dos avisos de aperto e curso deste curso. E se precisar do fabricante: o pacote identifica a KUONGSHUN com site e e-mail de suporte e promete resposta dos engenheiros em até 12 horas (24 em feriado) — ao escrever, mande o kit de informações da seção anterior junto, pois sintoma sem dados volta como pergunta. Informe também a versão da sua documentação (a deste curso é a V1.0.23.12.22) e o que já foi tentado da árvore de decisão: suporte bom resolve no detalhe que você manda, não no que ele adivinha. Antes de escrever, porém, passe a árvore de decisão inteira de novo do zero: metade dos chamados se resolve no segundo olhar sobre o flat, o cabo ou a COM. E documente o que achou, mesmo quando a solução for boba: o caderno de bancada com sintoma, causa e correção vira o manual de manutenção do kit — e a próxima turma agradece. Com o tempo, esse caderno vale mais que este curso: ele registra os defeitos reais da sua bancada, com as suas fotos, os seus valores de 5 V e as suas COMs — um retrato do seu kit que nenhum manual genérico substitui.

Aceite final do radar

Critério de aprovação, nesta ordem: abertura “Mini Radar” → “Testing…” → autoteste suave de 0 a 180 → “OK!”; scanline varrendo ida e volta sem travar; ponto vermelho estável sobre anteparo de papelão a 40 cm em 90°; rodapé DEG/cm sincronizado com o Serial a 115200; 3 ciclos contínuos sem reiniciar. Os 3 ciclos são o teste de estresse mínimo: o primeiro prova que funciona, o segundo prova que repete, o terceiro prova que não esquenta nem afrouxa. Fotografe a TFT de frente, sem flash (o reflexo apaga os pontos vermelhos na foto): luz lateral difusa e exposição travada no celular resolvem. Tire duas fotos — uma da tela cheia com o anteparo visível ao lado (contexto) e um close do rodapé com o DEG legível (evidência numérica): o par dispensa discussão sobre “estava funcionando”. Fotografe a TFT com o anteparo e arquive com a data, a temperatura ambiente e o delay usado — na próxima falha, comparar com esse registro diz em segundos se o problema é mecânico, elétrico ou de ambiente. Guarde a caixa com o sketch e essa foto: na próxima montagem, o tempo cai pela metade.

Rotina de bancada a cada uso: área de 1 m livre à frente do feixe (sem copos nem instrumentos de vidro na linha do rocker), USB de dados na mesma porta de sempre, conferência rápida do curso manual do servo antes de energizar e anteparo padrão a 20 cm para validar o primeiro ciclo. A cada 20 h de operação: reaperto M3 em cruz, Duponts pressionados, transdutores limpos com pincel seco e flat sem dobra nova. Em turmas, vale o ritual de entrada e saída: contar parafusos no início e no fim (peça M3 é risco de ingestão para pequenos), rocker em 90° nas pausas para não tensionar o horn, e TFT coberta contra poeira ao guardar. E o mesmo aceite vira avaliação prática: cada bancada apresenta a abertura, a varredura com a mão e o ponto fixo no anteparo, explicando um bloco do sketch por aluno. Quem explica o pulseIn entendeu o ultrassom; quem explica a scanline tripla entendeu o SPI; quem explica o 90° entendeu calibração. Três explicações certas por bancada valem mais que prova escrita — e a foto de aceite de cada grupo compõe o mural do laboratório. No fim do bimestre, o mural conta a história da turma melhor que nota: torres montadas, telas com scanline, anteparos de papelão e os sorrisos de quem viu o ponto vermelho aparecer pela primeira vez no azimute certo. Guarde também os registros de aceite em pasta: ano após ano, eles viram a linha de base que diz se o kit está envelhecendo bem ou pedindo aposentadoria de alguma peça. Servo que passa a ranger no mesmo ângulo todo ano, flat que amarela, coluna que afrouxa sozinha — o registro conta a vida útil real, melhor que qualquer estimativa de catálogo. E quando chegar a hora de aposentar uma peça, o registro diz qual: manutenção orientada por dados, do primeiro parafuso ao último ciclo. Radar calibrado, bancada organizada, caderno em dia — bom trabalho, operador: o próximo projeto já pode começar. E quando ele começar, volte aqui: o ultrassom, o servo, o SPI e o Serial deste kit são os mesmos de dezenas de outros projetos — fundação que se reaproveita. Bons experimentos, boas medições e até a próxima montagem. Que cada novo projeto encontre uma bancada mais organizada, um caderno mais completo e um operador mais experiente. Para feiras, monte o kit de sobrevivência: hub alimentado, cabo TYPE-C reserva, kit de parafusos M3, anteparo padrão de papelão, ficha de aceite impressa e a IDE com driver já instalados (o Wi-Fi do pavilhão sempre falha na hora de baixar). Chegando, meça o 5 V na tomada do estande antes de ligar: estabilizador ruidoso de pavilhão pede o hub com filtro, e descobrir isso com o público na frente custa a demonstração. Pausa de 10 minutos por hora de operação contínua preserva o motor de escovas do servo. Proibido na rotina: alimentar o servo por pino de sinal, write fora de 0–180, flat dobrado e gabinete fechado sem ventilação (o regulador da Uno aquece com TFT e servo no limite).

Solução de problemas

Olá! Sou o assistente técnico da RoboBuilders. Descreva seu problema com o Kit Educacional Radar Ultrassônico Compatível com Arduino AE320 RB1848 - Curso Completo e eu ajudarei a encontrar a solução.

Enviar

O assistente usa IA e pode errar. Confirme informações críticas no datasheet oficial do fabricante.