🗣️Jarvis 2/4: “Oi, Jarvis!” - Dando Comandos Reais ao Nosso Assistente

⚙️🌌 Projeto CodeVerse Python – #45/2025

👋 Fala, galera dev! 🚀

Se no artigo anterior (#44) o nosso Jarvis ganhou voz, presença e uma identidade digital, hoje chegou a hora dele realmente obedecer aos nossos comandos. Nesse artigo do CodeVersePython2025 vamos adicionar nosso código anteior com comandos reais ao nosso assistente, juntando assim as peças do quebra cabeça.

Entramos na segunda etapa da construção do assistente completo, e neste artigo vamos implementar uma das partes mais icônicas do Jarvis: a wake word (“Oi, Jarvis”) e a capacidade de abrir programas reais no computador, tudo controlado por voz.

Assim, o nosso assistente começa a se comportar como um verdadeiro sistema de automação pessoal, unindo tecnologia, conveniência e um toque cinematográfico. Vamos lá?

🦸 Entendendo como vai funcionar...

Imagine Tony Stark entrando no laboratório, tomando um café e dizendo casualmente:

“Jarvis, abra os relatórios de energia.”

E, em segundos, o sistema projeta hologramas no ar, executa cálculos e abre arquivos. É exatamente esse o estágio em que estamos chegando agora.

No nosso projeto, o Jarvis vai reconhecer a frase de ativação, aguardar o comando seguinte e executar ações reais, como abrir o navegador, o Excel, o Word, a Calculadora ou até o VS Code. Tudo isso rodando a partir da estrutura criada no artigo anterior (#44), agora com uma lógica de decisão real e respostas dinâmicas.

🧠 Explicando melhor como tudo irá funcionar...

Nesta etapa, o Jarvis deixará de ser apenas reativo (responder quando chamado) e passará a ser funcional, ou seja, capaz de executar tarefas concretas. E vamos implementar:

✅ Uma wake word real (“Oi, Jarvis”) que ativa o modo de escuta;
✅ Um sistema de decisão com if/elif, para processar comandos de voz;
✅ A abertura de aplicativos nativos (Word, Excel, Calculadora, VS Code, Navegador etc.);
✅ E pequenas respostas personalizadas, tornando o diálogo mais natural.

O objetivo é que, ao dizer “Oi, Jarvis”, o assistente responda e entre em modo de espera para o próximo comando — exatamente como o original.

🐍 Falar é Fácil, Mostre-me o Código...

Abaixo está o código atualizado do nosso Jarvis, agora com wake word, estrutura condicional e comandos reais de automação. Nele eu implemento de forma bem simples tudo o que já foi ensinado nos artigos anteriores, juntando-os em um código só. A partir desse código, nosso assistente já é capaz de ser acionar os comandos apenas quando a palavra chave ou wake word é falada, aguardando e ouvindo nossos comandos, paar entrar na estrutura de if/else para verificar qual função queremos que ele execute. Mas calma, vamos ver anlisar o código abaixo e depois vou expliar com mais detalhes o que faz cada parte.

import os
import random
import time
import tkinter as tk
from threading import Thread
from datetime import datetime
import speech_recognition as sr
import pyttsx3


class JarvisApp:
  def __init__(self, root):
      self.root = root
      self.root.title("Jarvis - CodeVerse 2025")
      self.root.geometry("220x200")
      bg_color = "#0B3D2E"
      fg_color = "#E6F2EF"
      self.root.configure(bg=bg_color)

      self.label = tk.Label(root, text="Assistente de Voz - J.A.R.V.I.S.",
                            bg=bg_color, fg=fg_color, font=("Helvetica", 9))
      self.label.pack(pady=10)

      self.canvas = tk.Canvas(root, width=100, height=100, bg=bg_color, highlightthickness=0)
      self.circle = self.canvas.create_oval(30, 30, 70, 70, outline="#00FFFF", width=5)
      self.canvas.pack()

      self.btn_iniciar = tk.Button(root, text="Iniciar Assistente",
                                   command=self.iniciar_assistente,
                                   bg=fg_color, fg=bg_color, font=("Helvetica", 9))
      self.btn_iniciar.pack(pady=5)

      self.running = False
      self.speaking = False

  def iniciar_assistente(self):
      if not self.running:
          self.running = True
          thread = Thread(target=self.executar_assistente)
          thread.start()
          self.label.config(text="Assistente iniciado...")

  def executar_assistente(self):
      engine = pyttsx3.init()
      r = sr.Recognizer()

      def falar(texto):
          self.canvas.itemconfig(self.circle, outline="#00FF00")
          self.speaking = True
          engine.say(texto)
          engine.runAndWait()
          self.speaking = False
          self.canvas.itemconfig(self.circle, outline="#00FFFF")

      def saudacao_inicial():
          hora = datetime.now().hour
          if hora < 12:
              saudacao = "Bom dia"
          elif hora < 18:
              saudacao = "Boa tarde"
          else:
              saudacao = "Boa noite"
          falar(f"{saudacao}, senhor Carlos. Hoje é {datetime.now().strftime('%d/%m/%Y')}, são {datetime.now().strftime('%H:%M')}. Estou pronto para ajudar.")
          self.label.config(text="Diga: 'Oi Jarvis' para iniciar...")

      saudacao_inicial()

      while self.running:
          with sr.Microphone() as source:
              r.adjust_for_ambient_noise(source)
              self.label.config(text="Ouvindo...")
              audio = r.listen(source)

              try:
                  frase = r.recognize_google(audio, language="pt-BR").lower()
                  print("Você disse:", frase)

                  # Ativação
                  if "oi jarvis" in frase:
                      respostas = [
                          "Sim, senhor?",
                          "Às ordens, senhor.",
                          "Estou ouvindo.",
                          "Pronto para receber o comando."
                      ]
                      resposta = random.choice(respostas)
                      falar(resposta)
                      self.label.config(text=resposta)

                      # Espera o próximo comando
                      with sr.Microphone() as source2:
                          r.adjust_for_ambient_noise(source2)
                          audio2 = r.listen(source2)
                          comando = r.recognize_google(audio2, language="pt-BR").lower()
                          print("Comando recebido:", comando)

                          if "abrir navegador" in comando:
                              os.system("start chrome.exe")
                              falar("Abrindo o navegador.")
                          elif "abrir word" in comando:
                              os.system("start winword.exe")
                              falar("Abrindo o Word.")
                          elif "abrir excel" in comando:
                              os.system("start excel.exe")
                              falar("Abrindo o Excel.")
                          elif "abrir bloco de notas" in comando:
                              os.system("start notepad.exe")
                              falar("Abrindo o bloco de notas.")
                          elif "abrir calculadora" in comando:
                              os.system("start calc.exe")
                              falar("Abrindo a calculadora.")
                          elif "abrir vs code" in comando:
                              os.system("start code")
                              falar("Abrindo o Visual Studio Code.")
                          elif "que horas são" in comando:
                              hora = datetime.now().strftime("%H:%M")
                              falar(f"Agora são {hora}.")
                          elif "que dia é hoje" in comando:
                              data = datetime.now().strftime("%d/%m/%Y")
                              falar(f"Hoje é {data}.")
                          elif "desligar sistema" in comando:
                              falar("Encerrando o sistema. Até logo, senhor.")
                              self.running = False
                              self.label.config(text="Assistente desligado.")
                          else:
                              falar("Desculpe, não entendi o comando.")
                  else:
                      pass

              except sr.UnknownValueError:
                  self.label.config(text="Não entendi, senhor.")
                  falar("Não entendi, senhor.")


root = tk.Tk()
app = JarvisApp(root)
root.mainloop()

⚙️ Explicando o código...

Com as novas atualizações, o nosso Jarvis acaba de dar um salto importante em direção ao comportamento de um assistente real. Nesta etapa, implementamos três grandes melhorias que transformam o código em algo muito mais interativo e funcional.

Uma delas é o sistema de comandos, que utiliza uma estrutura de if/elif para interpretar e executar diferentes instruções — como abrir a Calculadora, o Word, o Excel ou até o VS Code. Além disso, adicionamos um conjunto de respostas aleatórias, tornando as interações mais naturais e menos robóticas, já que o Jarvis nunca responde exatamente da mesma forma.

Enfim, vamos detalhar a seguir as três principais evoluções implementadas nesta nova versão do projeto.

1️⃣ A “Wake Word”: “Oi, Jarvis”

O assistente fica em modo de escuta passiva, aguardando a frase de ativação. Quando você diz “Oi, Jarvis”, o sistema reconhece a palavra-chave e muda o comportamento: passa a escutar o comando seguinte.

Esse mecanismo é o mesmo usado em assistentes como Alexa, Google Assistant e Siri, e é o primeiro passo para criar um sistema contínuo de diálogo.

2️⃣ O Sistema de Comandos (if/elif)

Após a ativação, o código usa estruturas condicionais (if / elif) para verificar qual ação o usuário pediu. Exemplo:

if "abrir word" in comando:
  os.system("start winword.exe")
  falar("Abrindo o Word.")

Isso faz com que o Jarvis reaja a cada comando específico, abrindo programas, informando hora, data, ou encerrando o sistema. Cada “elif” é uma habilidade e nos próximos artigos, vamos adicionar ainda mais poderes a ele.

3️⃣ A interação natural

As respostas aleatórias (“Sim, senhor?”, “Às ordens, senhor”, “Estou ouvindo...”) tornam o diálogo mais natural e humano. Esse toque de variação faz toda a diferença, quebrando o padrão robótico e dando ao Jarvis uma “personalidade”.

🧩 Onde estamos na construção do Jarvis

Nesta segunda etapa, o Jarvis deixa de ser passivo e passa a ser funcional. Agora ele entende quando é chamado e executa ações reais, estabelecendo o comportamento base de um assistente pessoal.

Nos próximos artigos, vamos expandir ainda mais as capacidades dele:

✅ #46 – Conectando à Internet: o Jarvis vai acessar APIs de clima, previsão do tempo e até se integrar ao Google Gemini, tornando-se realmente inteligente.

✅ #47 – Jarvis Avançado: vamos adicionar memória, transcrição de voz, playlists e um modo privado, consolidando tudo em um assistente completo.

🔮 Concluindo...

Com o artigo #45, o Jarvis deixou de ser apenas uma voz e se tornou um verdadeiro sistema de automação pessoal. Agora ele entende comandos, executa tarefas e responde de forma natural, o que antes era apenas um experimento visual, começa a se tornar uma ferramenta funcional e prática em nosso dia a dia.

Estamos muito próximos do Jarvis que sempre imaginamos. Nos vemos no próximo artigo, quando o conectaremos à Internet e daremos a ele o poder da informação em tempo real. 🌐

“O futuro pertence àqueles que constroem as ferramentas que os outros ainda sonham em usar.” — CodeVerse Python 2025