There is no radio between them: the phone is a pane in Mokxi, not a real radio (Bluetooth, simulado). O que é modelado é a metade do módulo que um circuito consegue ver, o UART, e isso acaba sendo quase tudo o que um sketch faz com um.
A plaquinha azul com o botão na ponta é vendida como "Bluetooth para Arduino", e o que ela é de verdade não poderia ser mais simples: um cabo de extensão sem fio para uma porta serial. Os bytes que entram em RXD saem no celular do outro lado; os bytes que o celular envia saem em TXD. Isso é tudo o que o dispositivo é do lado da placa, e um sketch não consegue distinguir entre um HC-05 pareado e um fio até um terminal.
Pinos e propriedades
| Pin | O que faz |
|---|---|
VCC, GND |
Alimentação, 3,6 a 6 V, e terra. A lógica é de 3,3 V. |
TXD |
A saída do módulo: ligue no pino RX da placa. |
RXD |
A entrada do módulo: ligue no pino TX da placa. |
EN |
HC-05 only. High puts it in AT mode. |
STATE |
Só no HC-05. Nível alto quando algo está conectado. |
O HC-06 tem apenas os quatro primeiros. Ambos têm baud (9600 por padrão), name (o que o celular vê) e connected, se um celular está conectado quando a simulação começa: ligado no HC-05, desligado no HC-06.
Onde está a outra ponta
O celular no painel Bluetooth. Abra a aba Bluetooth com o circuito rodando: o módulo aparece listado com o nome dele. Pareie com o PIN dele (1234 até que AT+PSWD ou AT+PIN mude; um PIN errado falha), conecte, e o painel vira um terminal como o app "Serial Bluetooth Terminal". O que você digita sai por TXD; o que o sketch envia entra por RXD e aparece abaixo.
O painel serial tem a mesma outra ponta, sob o id do componente do módulo, com sua própria caixa de entrada ao lado das placas, então digitar ali também é o celular enviando.
Clique no módulo no canvas para desligar e religar, o mesmo que Conectar e Desconectar do painel. No HC-05 o STATE acompanha: alto enquanto tem alguém do outro lado, baixo quando não tem, e é assim que um sketch sabe se está falando sozinho.
O que você não pode aprender aqui é tudo do outro lado da antena: alcance do rádio, interferência e os papéis de mestre e escravo. Esses existem de verdade, e não estão neste modelo.
O que é real, e é a metade que dá problema
Os bytes não são teletransportados. TXD e RXD carregam 8N1 no baud do módulo, bit por bit: um bit de início em nível baixo, oito bits de dados do menos significativo primeiro, um bit de parada em nível alto.
Então a falha que todo mundo já teve é reproduzível aqui de propósito. Abra as propriedades do módulo, defina baud como 4800 enquanto o sketch ainda amostra a 9600, e o bit de parada cai no meio de um byte: o quadro é descartado e o log enche de erros de enquadramento. É o problema de HC-05 mais comum do mundo e vale a pena causar uma vez, de propósito, com os fios na sua frente.
O módulo vem de fábrica a 9600 baud em modo de dados, e é por isso que todo tutorial começa com Serial.begin(9600).
Três volts, não cinco
A placa aceita 3,6 a 6 V em VCC através do próprio regulador, e a lógica dela é de 3,3 V. O TXD varia até 3,3 V, o que um AVR lê como alto com folga.
RXD é o pino que importa numa bancada de verdade: ele não tolera 5 V, e é por isso que todo tutorial coloca um divisor de tensão na linha de transmissão da placa. Nada no Mokxi pode ser danificado, então o circuito da galeria não tem um, mas o TXD aqui realmente só chega a 3,3 V, então um circuito que o compara com o trilho de 5 V se comporta como o real. No hardware, adicione o divisor.
Dois pinos, e uma UART de hardware
Um Uno tem uma UART de hardware e ela é do monitor serial, então o módulo recebe uma de software, que é o que a SoftwareSerial é, e por que ela existe. O sketch dos tutoriais compila e roda como está escrito:
#include <SoftwareSerial.h>
SoftwareSerial BTSerial(2, 3); // RX, TX: the module's TXD into 2
void setup() { Serial.begin(9600); BTSerial.begin(9600); }
void loop() {
if (BTSerial.available()) Serial.write(BTSerial.read());
if (Serial.available()) BTSerial.write(Serial.read());
}
O SoftwareSerial.h é do próprio runtime, escrito para o Mokxi, com as chamadas da biblioteca do Arduino e o mecanismo dela: uma interrupção de mudança de pino captura o bit de início, e loops contados cronometram os outros bits, com interrupções desligadas durante o byte. O modelo do ATmega328P executa cada instrução na contagem de ciclos do data sheet, então o tempo é o do chip. Foi testado com este módulo a 9600, 38400 e 57600 baud numa placa de 16 MHz, a 9600 e 38400 no Pro Mini de 8 MHz, e com o módulo 4% rápido ou lento. Três comportamentos da biblioteca real passam para cá, e todos importam com este módulo:
- Half duplex. Enquanto o sketch envia um byte, as interrupções ficam desligadas, então um byte que chega nesse momento é perdido. Atenda o telefone depois que a linha dele terminar, não no meio dela.
- Uma porta escuta por vez. Com duas portas
SoftwareSerial, só a que chamoulisten()por último recebe. O buffer de recepção tem 64 bytes e guarda 63, eoverflow()avisa quando encheu. - 38400 baud é apertado a 8 MHz. No Pro Mini de 8 MHz, cada byte a 38400 mantém as interrupções desligadas por cerca de 95% do tempo, então quando a interrupção do timer do
millis()cai num bit de início, esse byte pode chegar errado. Num teste de 24 linhas de 31 bytes, 23 chegaram inteiras. Use 9600 ou 19200 numa placa de 8 MHz quando cada byte importa.
O mesmo cabeçalho funciona no Nano, no Pro Mini, no Mega (recepção em 10 a 15, 50 a 53 e A8 a A15), no Leonardo e no Pro Micro (recepção em 8 a 11 e 14 a 16), no ESP8266, no ESP32 e no ESP32-S3. Nas placas ESP é o jeito do EspSoftwareSerial: cada borda é cronometrada numa interrupção, então várias portas recebem ao mesmo tempo.
O sketch btlamp conta um byte na mão a 1200 baud, então ele inteiro é visível em trinta linhas.
Modo AT
EN (marcado KEY em algumas placas) em nível alto coloca o módulo em modo de comando: os bytes em RXD são comandos para o próprio módulo em vez de tráfego para a outra ponta, e as respostas voltam por TXD. O subconjunto respondido aqui é o que uma aula usa:
| comando | resposta |
|---|---|
AT |
OK |
AT+VERSION? |
+VERSION:3.0-20170601 depois OK |
AT+NAME? |
+NAME:<name> depois OK |
AT+NAME=<text> |
OK, e o nome muda |
AT+UART? |
+UART:<baud>,0,0 depois OK |
AT+UART=<baud>,0,0 |
OK, e a taxa muda |
AT+ADDR? |
+ADDR:98d3:31:fb1234 depois OK |
AT+ROLE?, AT+ROLE=<0..2> |
+ROLE:<n> depois OK; OK |
AT+CMODE?, AT+CMODE=<0..1> |
+CMODE:<n> depois OK; OK |
AT+PSWD?, AT+PSWD=<pin> |
+PSWD:<pin> depois OK; OK |
| qualquer outro valor | ERROR:(0) |
O modo AT conversa a 38400 baud, seja qual for a taxa de dados configurada, como o módulo real faz em modo de comando. Então o sketch AT dos tutoriais, com BTSerial.begin(38400) e EN em nível alto por um pino, funciona como está escrito. Um sketch que fica a 9600 não recebe nada sensato de volta, e esse é o erro mais comum no modo AT. AT+UART= muda a taxa de dados, que passa a valer quando EN volta ao nível baixo. O papel e o modo de conexão são guardados e lidos de volta, e não mudam mais nada, porque não há rádio para mudar. O PIN é o que o celular do painel Bluetooth precisa digitar para parear.
O módulo real exige que cada comando termine com CR LF ("Both NL & CR" no monitor serial da IDE do Arduino). Este também aceita um LF sozinho, que é o que o monitor serial do Mokxi envia.
O HC-06
O irmão só-escravo do HC-05, na placa de quatro pinos: VCC, GND, TXD e
RXD, sem EN e sem STATE. Ele sai do saquinho com nada conectado, e enquanto nada estiver conectado, tudo que chegar em RXD é um comando AT, na taxa de dados, no antigo dialeto "linvor": sem final de linha, e o módulo responde depois que a linha fica quieta por um décimo de segundo, também sem final de linha. Escolha "No line ending" para ele.
| comando | resposta |
|---|---|
AT |
OK |
AT+VERSION |
OKlinvorV1.8 |
AT+NAME<name> |
OKsetname, e o painel mostra o novo nome |
AT+PIN<four digits> |
OKsetPIN, e o pareamento pede o novo PIN |
AT+BAUD<1 to C> |
OK<rate> na taxa antiga, depois na nova: 4 é 9600, 8 é 115200 |
| qualquer outro valor | nada |
Assim que o celular conecta, os mesmos bytes viram tráfego, como no módulo real.
O que não é modelado
O rádio e tudo o que depende dele: o que o papel (mestre/escravo) faria, AT+BIND, AT+INQ e a descoberta a que pertencem. A diferença entre entrar no modo AT na inicialização e depois dela: aqui EN em nível alto é modo AT a 38400 em ambos os casos. O botão na ponta da placa, que num módulo real é o outro caminho para o modo AT. O controle de fluxo, que o cabeçalho não expõe. Qualquer enquadramento que não seja 8N1. E o atraso entre um byte chegar ao módulo e sair na outra ponta. Aqui é instantâneo, enquanto um link real leva dezenas de milissegundos e sofre jitter.
Os circuitos para abrir
Chat por Bluetooth: o sketch do tutorial como escrito, SoftwareSerial nos pinos 2 e 3 a 9600. Digite como o celular na caixa do módulo; envie 1 ou 0 para o LED.
Lâmpada por Bluetooth: digite on, off, blink ou status no módulo, no painel serial, e a lâmpada responde, com STATE ligado para o sketch poder avisar quando ninguém está escutando.
Veja em ação
O tutorial Arduino HC-05 Bluetooth percorre a ligação, o sketch de chat e os comandos AT.
Two projects take commands from the module's box the way a phone app sends them: the Bluetooth RC car drives a 2WD car on an L298N from F, B, L, R and S, and Bluetooth home automation toggles four relays from 1 to 4.