Conheça seu DoguIA.
Domine cada recurso.

Por que pelo aplicativo?

O aplicativo encontra o robô sozinho: procura primeiro por Bluetooth e, se não achar, pela rede Wi-Fi que o próprio robô cria (DoguIA-XXXXX). Você não precisa descobrir endereço, nem trocar o celular de rede à mão.

Pelo aplicativo você:

• Escolhe a rede Wi-Fi da sua casa
• Digita a senha — ela vai direto do celular para o robô, sem passar pelos nossos servidores
• Acompanha o robô reiniciar e voltar conectado
• Vincula o robô à sua conta com o código de 6 dígitos

Ainda não tem o aplicativo? Ele é gratuito, para Android e iPhone: veja Aplicativo DoguIA.

Passo a passo para conectar

Calibracao do Dispositivo

O DoguIA realiza calibracoes automaticas para garantir o melhor desempenho:

Este passo exibe um video tutorial (YouTube) mostrando como conectar o DoguIA ao Wi-Fi. Assista ao video para entender o processo visual e, quando estiver pronto, avance para o proximo passo.

Aqui voce vincula o dispositivo fisico ao sistema. O DoguIA exibe um codigo de 6 digitos no display apos conectar ao Wi-Fi.

Neste passo voce da um nome ao seu agente e escolhe qual modelo de inteligencia artificial ele vai usar.

Escolha como seu DoguIA vai soar! Selecione o idioma e a voz de sintese (TTS).

Defina o comportamento e a personalidade do seu DoguIA. Este e o campo mais criativo!

Baixar o Aplicativo

O DoguIA tem um app oficial para Android e iPhone:

Tela Inicial

Apos abrir o app, você ve:

• Card do robo — mostra o nome, bateria e status
• Botoes de controle — ligar/desligar, conectar, versão do firmware
• Status da bateria — quanto tempo falta de carga
• Menu — acesso ao painel, Wi-Fi e mais

Tela do Robo (Controlar)

Clique no card do robo para entrar no modo de controle:

• Conversar — segure o botao para falar com ele
• Botoes de movimento — andar, pular, dançar
• Cores e luzes — mude a cor dos olhos
• Sons — faça ele latir, roncar, cantar

Conectar no Robo Local (WiFi)

Com o celular e o robô no mesmo Wi-Fi, o app comanda o robô diretamente (a conversa por voz continua precisando de internet):

Modo Demonstração (Demo)

Pode experimentar sem ter um robo fisico! O app tem um robo virtual:

• Basta entrar em modo demo na tela inicial
• Um robo tridimensional aparece na tela
• Voce pode falar com ele e ve-lo se mover
• Perfeito para testar antes de comprar

A aba principal onde voce ajusta todas as configuracoes do agente.

Gerencie os dispositivos fisicos vinculados ao agente.

Historico completo de todas as conversas que o DoguIA teve.

• Expandir — Clique em uma conversa para ver todas as mensagens trocadas.
• Audio — Mensagens com audio incluem um player para ouvir a gravacao.
• Duracao — Mostra quanto tempo durou cada conversa.
• Excluir — Apague conversas individuais quando desejar.

Configure perfis de locutores para que o DoguIA reconheca quem esta falando.

• Adicionar Locutor — Selecione uma amostra de voz (gravada automaticamente pelo dispositivo), de um nome (ex: "Papai", "Mamae") e uma descricao opcional.
• Preview — Ouca a amostra de voz antes de confirmar para garantir que e a pessoa certa.
• Remover — Delete perfis que nao sao mais necessarios.

Gerencie as habilidades do DoguIA baseadas no protocolo MCP (Model Context Protocol).

Crie bases de conhecimento para que o DoguIA tenha acesso a informacoes especificas.

• Criar Base — De um nome (ex: "FAQ do Produto", "Manual Tecnico") e descricao.
• Organizacao — Cada base e identificada por nome e descricao para facil referencia.
• Excluir — Remova bases que nao sao mais necessarias.

Veja e edite as memorias que o DoguIA acumulou durante as conversas.

• Editar — Cada memoria e editavel. Altere o texto e clique no para salvar.
• Excluir Individual — Remova memorias especificas que voce nao quer que o DoguIA lembre.
• Limpar Tudo — Apague todas as memorias de uma vez (acao irreversivel).

Comprou o robô de outro vendedor?

Robô comprado em outra loja, de segunda mão ou direto da China chega com o firmware do fabricante. Antes de instalar, assista ao guia de migração em vídeo (9 min): ele mostra como conferir a placa, guardar o backup do sistema original, instalar pelo computador, desvincular no xiaozhi.me e vincular no aplicativo.

Assistir ao guia de migração

Como funciona?

Sao 3 passos, e leva cerca de 2 minutos:

Deu erro no meio. Estraguei o DoguIA?

Quase certamente nao. O modo de gravacao do chip fica numa memoria que nao pode ser apagada, entao o DoguIA sempre aceita uma nova tentativa — mesmo que a gravacao anterior tenha parado no meio e ele nao esteja mais ligando.

Repita a instalacao entrando no modo de gravacao na mao: desconecte o cabo, segure o botao da placa, conecte o cabo com o botao apertado, solte o botao e clique em "Instalar firmware" de novo. Se o erro se repetir, troque o cabo por um de dados e ligue direto no computador, sem hub USB.

Preservacao de Dados (NVS)

Quando a atualizacao e feita pelo Painel, o firmware e dividido em partes que pulam a regiao NVS (Non-Volatile Storage). Isso garante que:

Requisitos e Compatibilidade

A conversa com o cabo USB depende da Web Serial API, que existe so em navegador de computador e so em paginas https://. Em celular e tablet nao ha como gravar. Se o seu navegador nao servir, a propria tela avisa antes de voce comecar.

50+ Movimentos

Seu DoguIA possui 68 movimentos pre-programados divididos em categorias. Basta pedir por voz!

20 Reacoes Emocionais

O DoguIA combina automaticamente movimento + LED para reagir a emocoes. Basta conversar naturalmente que a IA decide qual reacao usar.

Efeitos de LED

O DoguIA possui 4 LEDs RGB WS2812 com 16,7 milhoes de cores. Alem de cores solidas, tem efeitos animados:

15 Coreografias

Sequencias pre-programadas que combinam varios movimentos em ordem:

Jogos Interativos

O DoguIA tem jogos interativos que voce pode jogar por voz:

200+ Melodias

O DoguIA pode tocar melodias no buzzer! Sao mais de 200 musicas organizadas por categoria:

5 Modos de Personalidade

Alem da personalidade configurada no Painel, voce pode ativar modos temporarios por voz:

O que é um MCP e o que dá para fazer

MCP (Model Context Protocol) é o padrão que a IA do DoguIA usa para chamar ferramentas. Cada ferramenta é uma função sua — com um nome, uma descrição e parâmetros. Quando você fala com o robô, a IA lê essas descrições, decide se alguma serve para o seu pedido, chama a função e responde em voz com o resultado.

Com um MCP próprio você pode, por exemplo:

• fazer contas exatas, conversões e cálculos do seu trabalho;
• manter uma lista de compras, de tarefas ou de estoque que fica salva no seu computador;
• consultar serviços da internet (clima, cotações, o sistema da sua empresa);
• acionar coisas na sua casa ou no seu escritório que tenham uma API (automação residencial, planilhas, webhooks).

A ligação é de dentro para fora: é o seu computador que se conecta ao DoguIA. Você não precisa abrir porta no roteador, ter IP fixo nem domínio — basta internet.

Só o agente do link é afetado

O link MCP pertence a um agente, não à sua conta. Ele carrega a identificação daquele agente, e as ferramentas que você conectar por ele aparecem somente nele:

• Seus outros agentes continuam exatamente como estavam — não veem nem chamam as suas ferramentas.
• Os robôs vinculados a esse agente passam a usar as ferramentas; robôs de outros agentes, não.
• As habilidades que já vêm no DoguIA (movimentos, luzes, melodias, agenda) continuam funcionando junto com as suas.
• As ferramentas só existem enquanto a ponte está ligada. Desligou o programa, o agente volta a ser o que era.

Passo 1 — Gere o link MCP no painel

O link é gerado no painel web (no computador ou no navegador do celular), entrando com o mesmo e-mail e senha do aplicativo.

Passo 2 — Prepare o computador

Você precisa do Python 3.10 ou mais novo (Windows, macOS ou Linux; um Raspberry Pi também serve). No Windows, baixe em python.org e marque “Add Python to PATH” na instalação.

Crie uma pasta (por exemplo meu-mcp), abra o terminal nela e instale as duas bibliotecas:

python3 -m venv .venv
source .venv/bin/activate
pip install "mcp>=1.2" "websockets>=12"

No Windows, troque python3 por python e o source por .venv\Scripts\activate.

Passo 3 — Escreva as ferramentas (servidor.py)

Este é o arquivo onde ficam as suas funções. Cada função com @mcp.tool() em cima vira uma ferramenta do agente. O exemplo traz três prontas: uma calculadora, a hora certa em qualquer fuso e uma lista de compras que fica salva num arquivo ao lado.

"""
servidor.py — as ferramentas que o seu DoguIA vai poder usar.

Cada função marcada com @mcp.tool() vira uma ferramenta. O NOME da função,
a DESCRIÇÃO (o texto entre três aspas) e os PARÂMETROS são o que a IA lê
para decidir quando e como chamar. Escreva a descrição pensando nela.
"""
import ast
import json
import operator
import sys
from datetime import datetime
from pathlib import Path
from zoneinfo import ZoneInfo

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("minhas-ferramentas")


# ── Exemplo 1: calculadora (sem eval, à prova de código malicioso) ──────────
_OPERACOES = {
    ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul,
    ast.Div: operator.truediv, ast.Pow: operator.pow, ast.Mod: operator.mod,
    ast.USub: operator.neg, ast.UAdd: operator.pos,
}


def _avaliar(no):
    if isinstance(no, ast.Constant) and isinstance(no.value, (int, float)):
        return no.value
    if isinstance(no, ast.BinOp) and type(no.op) in _OPERACOES:
        return _OPERACOES[type(no.op)](_avaliar(no.left), _avaliar(no.right))
    if isinstance(no, ast.UnaryOp) and type(no.op) in _OPERACOES:
        return _OPERACOES[type(no.op)](_avaliar(no.operand))
    raise ValueError("expressão não permitida")


@mcp.tool()
def calcular(expressao: str) -> dict:
    """Calcula uma conta de matemática. Use sempre que a pessoa pedir uma conta,
    em vez de calcular de cabeça. Escreva a expressão com números e os
    operadores + - * / ** e %. Exemplo: "(12.5 * 3) + 7"."""
    try:
        resultado = _avaliar(ast.parse(expressao, mode="eval").body)
        return {"ok": True, "expressao": expressao, "resultado": resultado}
    except Exception as erro:
        return {"ok": False, "erro": str(erro)}


# ── Exemplo 2: data e hora em qualquer fuso ─────────────────────────────────
@mcp.tool()
def hora_agora(fuso: str = "America/Sao_Paulo") -> dict:
    """Diz a data e a hora atuais. O fuso é opcional, no formato
    "Continente/Cidade" (ex.: "Europe/Lisbon", "America/Manaus")."""
    try:
        agora = datetime.now(ZoneInfo(fuso))
    except Exception:
        return {"ok": False, "erro": f"fuso desconhecido: {fuso}"}
    return {"ok": True, "fuso": fuso, "data": agora.strftime("%d/%m/%Y"),
            "hora": agora.strftime("%H:%M")}


# ── Exemplo 3: lista de compras que fica salva num arquivo ──────────────────
ARQUIVO_LISTA = Path(__file__).with_name("lista_de_compras.json")


def _ler_lista() -> list:
    if ARQUIVO_LISTA.exists():
        return json.loads(ARQUIVO_LISTA.read_text(encoding="utf-8"))
    return []


@mcp.tool()
def lista_de_compras(acao: str, item: str = "") -> dict:
    """Gerencia a lista de compras da casa.
    acao: "adicionar" (precisa de item), "remover" (precisa de item),
    "ver" (mostra a lista) ou "limpar" (apaga tudo)."""
    lista = _ler_lista()
    item = item.strip().lower()
    if acao == "adicionar" and item:
        if item not in lista:
            lista.append(item)
    elif acao == "remover" and item:
        lista = [i for i in lista if i != item]
    elif acao == "limpar":
        lista = []
    elif acao != "ver":
        return {"ok": False, "erro": "ação inválida ou item faltando"}
    ARQUIVO_LISTA.write_text(json.dumps(lista, ensure_ascii=False), encoding="utf-8")
    return {"ok": True, "itens": lista, "total": len(lista)}


if __name__ == "__main__":
    # Aviso vai para stderr: o stdout é o canal do protocolo e não pode ter
    # nada além das mensagens MCP. Um print() solto ali quebra a conexão.
    print("[servidor] ferramentas prontas", file=sys.stderr)
    mcp.run(transport="stdio")

O que a IA enxerga de cada ferramenta:

• O nome da função (lista_de_compras) — curto, sem espaço nem acento.
• A descrição (o texto entre """) — é por ela que a IA decide quando usar. Diga quando usar e explique cada parâmetro.
• Os parâmetros com tipo (cidade: str, quantidade: int = 1) — viram o formulário que a IA preenche. Parâmetro com valor padrão é opcional.
• O retorno — devolva um dicionário pequeno com o que importa. A IA transforma isso em fala.

Passo 4 — Ligue ao seu agente (ponte.py)

O servidor.py fala pela entrada e saída do terminal; o DoguIA fala por WebSocket. A ponte.py liga os dois lados, repassa as mensagens e reconecta sozinha se a internet cair. Você não precisa mexer nela — só colar o link.

"""
ponte.py — liga o seu servidor MCP (servidor.py) ao link MCP do seu agente DoguIA.

O DoguIA conversa por WebSocket; o servidor.py conversa pela entrada e saída
padrão (stdio). Esta ponte abre os dois lados e repassa as mensagens, e se a
internet cair ela reconecta sozinha.

Uso:
    python ponte.py                      # roda o servidor.py desta pasta
    python ponte.py python outro.py      # roda outro servidor MCP qualquer
"""
import asyncio
import json
import os
import sys
import time

import websockets

# Cole o link aqui OU defina a variável de ambiente DOGUIA_MCP_URL.
LINK_MCP = os.environ.get("DOGUIA_MCP_URL") or "COLE_AQUI_O_SEU_LINK"

# Comando que inicia o seu servidor MCP.
SERVIDOR = sys.argv[1:] or [sys.executable, "servidor.py"]


def log(texto):
    print(f"[ponte {time.strftime('%H:%M:%S')}] {texto}", file=sys.stderr, flush=True)


async def uma_sessao():
    async with websockets.connect(LINK_MCP, ping_interval=30, ping_timeout=30, max_size=None) as ws:
        log("conectado ao DoguIA")
        processo = await asyncio.create_subprocess_exec(
            *SERVIDOR,
            stdin=asyncio.subprocess.PIPE,
            stdout=asyncio.subprocess.PIPE,
            limit=16 * 1024 * 1024,  # respostas grandes cabem numa linha só
        )

        async def do_doguia_para_servidor():
            async for mensagem in ws:
                if isinstance(mensagem, bytes):
                    mensagem = mensagem.decode("utf-8")
                # O stdio do MCP é "uma mensagem JSON por linha": recompacta
                # para garantir que nenhuma quebra de linha parta a mensagem.
                linha = json.dumps(json.loads(mensagem), ensure_ascii=False)
                processo.stdin.write((linha + "\n").encode("utf-8"))
                await processo.stdin.drain()
            raise ConnectionError("o DoguIA fechou a conexão")

        async def do_servidor_para_doguia():
            while True:
                linha = await processo.stdout.readline()
                if not linha:
                    raise RuntimeError("o servidor MCP parou (veja o erro acima)")
                linha = linha.decode("utf-8").strip()
                if linha:
                    await ws.send(linha)

        tarefas = [asyncio.create_task(do_doguia_para_servidor()),
                   asyncio.create_task(do_servidor_para_doguia())]
        try:
            prontas, _ = await asyncio.wait(tarefas, return_when=asyncio.FIRST_EXCEPTION)
            for tarefa in prontas:
                tarefa.result()
        finally:
            for tarefa in tarefas:
                tarefa.cancel()
            if processo.returncode is None:
                processo.terminate()
                try:
                    await asyncio.wait_for(processo.wait(), 5)
                except asyncio.TimeoutError:
                    processo.kill()


async def principal():
    if not LINK_MCP.startswith(("wss://", "ws://")):
        log("falta o link MCP: cole em LINK_MCP ou defina DOGUIA_MCP_URL")
        sys.exit(1)
    espera = 1
    while True:
        inicio = time.monotonic()
        try:
            await uma_sessao()
        except Exception as erro:
            log(f"conexão caiu: {erro}")
        if time.monotonic() - inicio > 60:
            espera = 1  # ficou de pé um bom tempo: recomeça a espera do zero
        log(f"tentando de novo em {espera}s...")
        await asyncio.sleep(espera)
        espera = min(espera * 2, 60)


if __name__ == "__main__":
    try:
        asyncio.run(principal())
    except KeyboardInterrupt:
        log("encerrado")

Passo 5 — Rode e converse

Com os dois arquivos na mesma pasta, informe o link e inicie a ponte (ela mesma inicia o servidor.py):

source .venv/bin/activate
export DOGUIA_MCP_URL="wss://www.doguia.com.br/mcp/?token=COLE_O_SEU_TOKEN_AQUI"
python ponte.py

.venv\Scripts\activate
$env:DOGUIA_MCP_URL = "wss://www.doguia.com.br/mcp/?token=COLE_O_SEU_TOKEN_AQUI"
python ponte.py

Se der certo, o terminal mostra:

[ponte 23:34:24] conectado ao DoguIA
[servidor] ferramentas prontas
INFO     Processing request of type ListToolsRequest

Pronto: o agente já tem as ferramentas. Fale com o DoguIA (vinculado a esse agente):

• “Quanto é doze e meio vezes três, mais sete?” → usa calcular
• “Coloca pão e leite na lista de compras.” → usa lista_de_compras
• “Que horas são em Lisboa?” → usa hora_agora

A cada uso, o terminal registra Processing request of type CallToolRequest — é a prova de que a IA chamou a sua função.

Exemplo: ferramenta que consulta a internet

Cole no servidor.py, antes do bloco if __name__ == "__main__":. Ela usa o serviço gratuito Open-Meteo (sem cadastro nem chave) e só a biblioteca padrão do Python.

import json
import urllib.parse
import urllib.request


def _buscar_json(url: str) -> dict:
    with urllib.request.urlopen(url, timeout=8) as resposta:
        return json.load(resposta)


@mcp.tool()
def clima_agora(cidade: str) -> dict:
    """Diz a temperatura e o vento agora numa cidade. Use quando a pessoa
    perguntar como está o tempo, se está calor ou frio. cidade: nome da
    cidade, ex.: "Campinas" ou "Belo Horizonte"."""
    try:
        busca = _buscar_json("https://geocoding-api.open-meteo.com/v1/search?count=1&language=pt&name="
                             + urllib.parse.quote(cidade))
        if not busca.get("results"):
            return {"ok": False, "erro": f"não achei a cidade {cidade}"}
        lugar = busca["results"][0]
        tempo = _buscar_json("https://api.open-meteo.com/v1/forecast?current=temperature_2m,wind_speed_10m"
                             f"&latitude={lugar['latitude']}&longitude={lugar['longitude']}")["current"]
    except Exception:
        return {"ok": False, "erro": "o serviço de clima não respondeu agora"}
    return {"ok": True, "cidade": lugar["name"], "estado": lugar.get("admin1"),
            "temperatura_c": tempo["temperature_2m"], "vento_kmh": tempo["wind_speed_10m"]}

Teste dizendo: “Como está o tempo em Campinas agora?”. Repare no padrão que vale para qualquer API: tempo limite curto (timeout=8) e, quando falhar, devolver um erro em texto em vez de deixar a exceção estourar — assim o robô explica o que houve em vez de ficar mudo.

O que acontece por baixo (para quem quer entender)

As mensagens são JSON-RPC 2.0. Quem pergunta é a plataforma; quem responde é o seu servidor. Ao conectar, a plataforma se apresenta (initialize) e pede a lista de ferramentas:

→ {"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}}

← {"jsonrpc": "2.0", "id": 2, "result": {"tools": [
     {"name": "lista_de_compras",
      "description": "Gerencia a lista de compras da casa. ...",
      "inputSchema": {"type": "object",
                      "properties": {"acao": {"type": "string"},
                                     "item": {"type": "string", "default": ""}},
                      "required": ["acao"]}}
   ]}}

Quando a IA decide usar uma ferramenta, chega um tools/call com os argumentos que ela preencheu, e o seu servidor devolve o resultado:

→ {"jsonrpc": "2.0", "id": 4, "method": "tools/call",
   "params": {"name": "lista_de_compras",
              "arguments": {"acao": "adicionar", "item": "pão"}}}

← {"jsonrpc": "2.0", "id": 4, "result": {
     "content": [{"type": "text",
                  "text": "{\"ok\": true, \"itens\": [\"pão\"], \"total\": 1}"}],
     "isError": false}}

A biblioteca mcp monta tudo isso a partir da sua função — o inputSchema sai dos tipos dos parâmetros, e a description, do texto entre """. Se preferir outra linguagem (Node.js, Go, Java…), qualquer servidor MCP que fale pela entrada e saída padrão funciona com a mesma ponte: python ponte.py node meu-servidor.js.

Boas práticas

• Responda rápido. A pessoa está esperando o robô falar. Para tarefas longas, comece o trabalho e devolva “comecei, aviso quando terminar” — não segure a resposta por minutos.
• Devolva pouco. Um dicionário com o essencial. Páginas inteiras de texto deixam a resposta lenta e a fala confusa.
• Nomes únicos e claros. Evite nomes genéricos como tocar ou mover, que podem confundir com as habilidades de fábrica; prefira casa_ligar_luz, loja_consultar_estoque.
• Valide tudo que chega. Os argumentos são escritos pela IA a partir do que alguém falou. Nunca use eval(), nunca monte comando de terminal com eles, e confirme por voz antes de ações que não têm volta (apagar, comprar, abrir portão).
• Ajude a IA a lembrar. Se ela não usa a ferramenta quando deveria, melhore a descrição (“Use sempre que…”) ou cite a ferramenta na personalidade do agente, na aba Configuração.

Deixar ligado o tempo todo

As ferramentas só existem enquanto a ponte roda. Para não depender de um terminal aberto, rode-a num computador que fica ligado (um Raspberry Pi é ótimo para isso). No Linux, um serviço do systemd inicia sozinho no boot e reinicia se cair — ajuste os caminhos e o usuário:

[Unit]
Description=Meu MCP do DoguIA
After=network-online.target
Wants=network-online.target

[Service]
User=pi
WorkingDirectory=/home/pi/meu-mcp
Environment="DOGUIA_MCP_URL=wss://www.doguia.com.br/mcp/?token=COLE_O_SEU_TOKEN_AQUI"
ExecStart=/home/pi/meu-mcp/.venv/bin/python ponte.py
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now meu-mcp
journalctl -u meu-mcp -f      # acompanhar o que está acontecendo

No Windows, a forma mais simples é o Agendador de Tarefas: crie uma tarefa “Ao fazer logon” que execute C:\caminho\meu-mcp\.venv\Scripts\python.exe com o argumento ponte.py e “Iniciar em” apontando para a pasta meu-mcp (defina DOGUIA_MCP_URL nas variáveis de ambiente do usuário, ou cole o link dentro da ponte.py).

Problemas comuns

Por que o app nao mostra a porcentagem

O DoguIA padrao nao tem sensor de bateria: a bateria fica na base, e a cabeca recebe sempre a mesma tensao, cheia ou quase vazia. Qualquer numero na tela seria um chute — e um numero ao lado de um icone de bateria e lido como verdade, como no celular. Por isso o app nao mostra porcentagem nem tempo restante para o DoguIA padrao.

O DoguIA Pro mede a carga de verdade, e nele a porcentagem aparece normalmente.

Como Carregar

O robo nao carrega ligado. Siga a ordem do guia:

1

Desligue o robo na chave

Com a luz verde acesa ele esta ligado e nao vai carregar. Desligue e espere a luz verde apagar.

2

Conecte o cabo de carga

A entrada USB-C fica na base do robo. Use o cabo que veio na caixa ou um cabo USB-C comum ligado a um carregador de celular.

3

Confira a luz vermelha

Carregando certo e verde apagado + vermelho aceso. A vermelha e discreta, ao lado da entrada do cabo — olhe de perto. Mantenha o cabo conectado.

Quando a Bateria Acaba (Brownout)

Se a bateria realmente esvaziar, o robo desliga sozinho. Isso se chama "brownout".

Quando isso acontece, o app mostra um aviso especial: "a bateria esta muito fraca". Isso e a unica certeza de que a bateria esta realmente acabando.

Se ver esse aviso, carregue o robo imediatamente.

Como Funciona o Volume

O DoguIA pode ficar bem alto — ate 200%! Mas existe um limite seguro para nao prejudicar a audicao:

• Nivel Seguro = ate 100% (totalmente seguro)
• Acima de 100% = cuidado, pode machucar os ouvidos
• Maximo = 200% (so use por pouco tempo)

Aviso de Seguranca

Quando voce tenta aumentar o volume acima de 100%, o app mostra um aviso:

"Cuidado! Volume alto pode prejudicar seus ouvidos. Tem certeza?"

Voce pode clicar "Sim, aumentar" ou "Nao, manter seguro".

Se clicar sim, o volume sobe. Mas voce so ve esse aviso uma vez por sessao do app — depois pode aumentar sem avisos.

Dicas de Uso

• Para criancas pequenas, mantenha sempre em 100% ou menos
• Se vai usar acima de 100%, use so por alguns minutos
• O firmware do robo tambem respeita o limite — nunca vai ficar mais alto que o permitido

Quando calibrar?

Voce deve calibrar os servos se perceber qualquer um destes sintomas:

• Patas desalinhadas — O DoguIA nao fica reto em pe, uma pata fica mais alta ou baixa que as outras.
• Movimentos tortos — Ao andar, ele puxa para um lado ou as patas se cruzam.
• Posicao neutra errada — Em repouso, as patas nao ficam paralelas ou simetricas.
• Ruidos mecanicos — Servos forcando porque estao calibrados fora do centro.
• Apos trocar um servo — Se voce substituiu um servo motor, ele precisa ser recalibrado.

Hardware dos Servos

O DoguIA possui 4 servo-motores independentes (180 graus de amplitude) controlados por PWM a 50Hz:

Como ajustar a calibracao

A calibração é feita pelo aplicativo DoguIA, com o robô ligado e na mesma rede Wi-Fi do celular. O app encontra o robô sozinho — não há endereço para digitar.

Valores Padrao de Fabrica

Se voce precisa restaurar os valores originais, estes sao os valores padrao de cada servo:

Dicas de Calibracao