Início / Projetos Arduino / Projetos Squids / Avançado / A01 - Conectando o Arduino ao PC com Python: Sem Usar o Monitor Serial

---

A01 - Conectando o Arduino ao PC com Python: Sem Usar o Monitor Serial

Angelo Luis Ferreira | 16/02/2026 Acessos: 79

Objetivo

Neste primeiro artigo da série Arduino Avançado, nosso objetivo é demonstrar, na prática, como conectar o Arduino Uno ou o Arduino Mega 2560 ao computador e estabelecer uma comunicação serial bidirecional real entre a placa e o PC, sem utilizar o Monitor Serial da IDE Arduino como interface de teste.

Para isso, desenvolveremos um sistema simples e funcional no qual:

• O computador enviará comandos digitados pelo usuário (como LED_ON e LED_OFF)

• O Arduino receberá esses comandos via USB, processando-os;

• O LED interno da placa (LED_BUILTIN) será ligado ou desligado, conforme a instrução recebida;

• O Arduino retornará uma resposta de confirmação de volta ao computador, via mensagens de status.

Desta forma, o PC passará a controlar fisicamente um recurso do Arduino, e o Arduino retornará informações de status ao PC.

A comunicação ocorrerá por meio da porta serial virtual (porta COM), criada automaticamente pelo sistema operacional quando o dispositivo é conectado via USB, utilizando:

• A IDE Arduino para programar o firmware embarcado (Sketch);

• Python no computador, com a biblioteca pyserial, para criar uma aplicação externa responsável por enviar e receber dados.

Ao final do artigo, você terá construído um sistema funcional onde hardware e software trabalham juntos de forma estruturada - base essencial para projetos profissionais envolvendo Arduino e integração com computador.

Definições

1. Comunicação Serial Bidirecional: É o modelo de transmissão de dados no qual dois dispositivos — neste projeto, o Arduino e o Computador — podem enviar e receber informações mutuamente por meio de um canal serial. Em outras palavras, é um método de troca de dados onde informações são enviadas e recebidas sequencialmente, bit a bit, através de um único canal ou conjunto de fios, permitindo que ambos dispositivos envolvidos atuem como emissor e receptor.

1.1. Modelo Lógico da Comunicação: Embora o meio físico seja USB, o modelo lógico utilizado é o de comunicação serial assíncrona, onde ambos os dispositivos devem estar configurados na mesma velocidade, conhecida como Baud Rate (ex: 9600 bps).

1.2. Porta COM Virtual: No Windows (e equivalente em Linux/Mac), quando conectamos o Arduino via USB o sistema operacional cria uma porta virtual, como: COM3, COM4 ou COM5. Ela simula uma porta serial tradicional (como as antigas portas RS-232), mesmo sendo USB. Isso permite que qualquer programa no PC leia dados enviados pelo Arduino e envie dados para o Arduino.

2. Biblioteca pyserial:  É uma biblioteca Python que: Abre a porta serial, envia dados, recebe dados e controla o tempo de leitura. Sem ela, o Python não conseguiria conversar diretamente com a porta COM.

2.1. Python: Python é uma linguagem dinâmica e robusta que foi criada por Guido Van Rossum (1991) e escrita em C (CPython). Fácil de aprender, multiplataforma e é muito utilizada em automação e integração de sistemas. No projeto, Python atua como ponte entre o Arduino e a interface do usuário.

Aplicações

Este projeto pode ser aplicado em sistemas de monitoramento e controle via PC, interfaces homem-máquina (HMI), automação residencial e industrial, controle remoto de dispositivos como relés e motores, dashboards de monitoramento em tempo real, integração com APIs e serviços web, sistemas de aquisição de dados (data logging), desenvolvimento de protocolos personalizados, consoles físicos com teclado matricial, integração com aplicações desktop ou Raspberry Pi, além de possuir forte aplicação didática no ensino de comunicação serial, arquitetura de sistemas embarcados e integração hardware–software.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Arduino UNO	Arduino UNO R3 com cabo USB	1		Você poderá utilizar uma placa Arduino MEGA 2560

Montagem do Circuito

Apenas conecte o Arduino no PC utilizando o cabo USB que geralmente vem acompanhado com a placa.

Atenção

1. Conecte o Arduino ao PC: Conecte o Arduino no computador corretamente, usando um cabo USB de dados (não apenas de carregamento).

1.1.1. O cabo USB que acompanha um kit Arduino geralmente é um cabo de dados. Ele é projetado especificamente para permitir a comunicação completa entre a placa e o computador. A função principal desse cabo é a transferência de dados (fazer o upload dos seus códigos, ou "sketches", para a placa) e a alimentação de energia. Sem a capacidade de dados, você não conseguiria programar o Arduino ou usar o monitor serial para depuração. 

2.  Identifique a Porta Serial: Abra o IDE do Arduino e acesse Ferramentas → Porta e você verá a porta identificada.

Observe que na minha conexão a Porta identificada foi COM 4. Veja qual a porta identificada no seu Arduino, anote esse número, pois ele será utilizado no Python.

3 - Conexão correta do Arduino com o computador:

Instalação do Python

1. Antes de instalar o Python, você poderá verificar se o eu PC já possui o programa instalado. Para isso, abra o terminal (prompt de comando do Windows, por exemplo).

1.1. Digite no terminal: python --version

1.2. Se você não tiver uma resposta e aparecer Python não encontrado, precisará instalar o Pyton no seu PC.

2. Instalação do Python no PC

2.1. Acesso o site oficial do Python: https://www.python.org/ e clique no botão Downloads

2.2. Clique no link da última versão: Neste exemplo é a versão Python 3.14.3

2.3. Aguarde finalizar o download e clique no arquivo de instalação que foi baixado: 

2.4.Clique no botão Install Now depois de ter marcado a opção Add python.exe to PATH.

2.4.1. ⚠ IMPORTANTE: Marque a opção Add python.exe to PATH

2.4.2. Aguarde a finalização da instalação. Se pedir alguma confirmação no Terminal, digite sempre Y (yes).

2.5. No terminal (prompt de comando) verifique novamente se foi instalado digitando: python --version

Instalação da biblioteca pyserial do Python

1. Abra o terminal (prompt de comando do Windows, por exemplo), e digite: pip install pyserial

Obs: O pip (Python Package Index) é o gerenciador de pacotes padrão do Python, utilizado para instalar, atualizar e remover bibliotecas e dependências de terceiros que não fazem parte da biblioteca padrão. 

2. Digite Enter e aguarde a instalação. Esse processo pode demorar um pouco.

Código do Projeto (Sketch)

Agora vamos preparar o Arduino para: Receber comandos, Interpretar texto, Executar ação e Responder.

1. Faça o download e abra o arquivo projetoI23.ino no IDE do Arduino:

1.1. Se preferir, copie e cole o código abaixo no IDE do Arduino:

/*******************************************************************************
*
*    Projeto A01: Comunicação Serial Bidirecional Arduino ↔ PC
     Objetivo: Receber comandos via Serial USB, controlar o LED interno
          e retornar mensagens de status ao computador.
*    Autor: Angelo Luis Ferreira
*    Data: 16/02/2026
*    
*             http://squids.com.br/arduino             
*
*******************************************************************************/

void setup() {

  // Configura o pino do LED interno como saída digital.
  // LED_BUILTIN é uma constante definida pela placa.
  pinMode(LED_BUILTIN, OUTPUT);

  // Inicializa a comunicação serial com taxa de 9600 bits por segundo.
  // Este valor deve ser igual ao configurado no programa Python.
  Serial.begin(9600);
}

void loop() {

  // Verifica se existem dados disponíveis no buffer de recepção serial.
  // Serial.available() retorna a quantidade de bytes recebidos.
  if (Serial.available() > 0) {

    // Lê os dados recebidos até encontrar o caractere de nova linha '\n'.
    // Esse caractere será enviado pelo Python ao final de cada comando.
    String comando = Serial.readStringUntil('\n');

    // Remove possíveis espaços em branco ou caracteres extras
    // que possam ter vindo junto com a string.
    comando.trim();

    // Compara o texto recebido com o comando esperado.
    if (comando == "LED_ON") {

      // Liga o LED interno (nível lógico HIGH).
      digitalWrite(LED_BUILTIN, HIGH);

      // Envia uma mensagem de confirmação ao computador.
      Serial.println("STATUS:LED_LIGADO");
    }

    // Verifica se o comando recebido é para desligar o LED.
    else if (comando == "LED_OFF") {

      // Desliga o LED interno (nível lógico LOW).
      digitalWrite(LED_BUILTIN, LOW);

      // Envia mensagem de confirmação ao computador.
      Serial.println("STATUS:LED_DESLIGADO");
    }

    // Caso o comando recebido não seja reconhecido,
    // envia mensagem de erro.
    else {

      Serial.println("ERRO:COMANDO_INVALIDO");
    }
  }

  // O loop continua executando indefinidamente,
  // verificando constantemente se novos dados chegaram.
}

2. Verifique se o código está funcionando corretamente usando o Monitor Serial (opcional).

2.1. Faça o upload do código para a placa do Arduino (não esqueça). 

2.2. Abra o Monitor Serial. Verifique se a porta de comunicação está correta com o que você verificou antes.

2.3. Digite os comandos LED_ON para acender o led da placa e LED_OFF para apagar. Você deverá receber as menssagens de status também.

2.3. ⚠ IMPORTANTE: Feche completamente o Monitor Serial, depois do teste. Ele não pode ficar aberto quando o Python usar a porta.

Código Python (no computador)

1. Crie uma pasta com o nome C:\Arduino\Python\

2. Utilize um editor de código como VS Code, NetBeans, entre outros, ou mesmo o bloco de notas do Windows. Copie o código Python abaixo e salve como controle_arduino.py dentro da pasta que você criou.

2.1. Se você utilizar um editor de texto, tipo bloco de notas, renomeie o arquivo de .txt para .py

2.2. O código Python foi cuidadosamente documentado com comentários técnicos que descrevem sua arquitetura, fluxo de execução e a função de cada instrução, facilitando a compreensão e a manutenção do projeto.

"""
Projeto: Comunicação Serial Bidirecional Arduino ↔ PC
Objetivo: Enviar comandos ao Arduino e receber respostas via porta serial USB.
Requisito: Biblioteca pyserial instalada.
"""

# Importa a biblioteca responsável por comunicação serial
import serial

# Importa biblioteca para controle de tempo (usada para aguardar inicialização)
import time


# ==============================
# CONFIGURAÇÕES DA COMUNICAÇÃO
# ==============================

# Define a porta serial onde o Arduino está conectado.
# No Windows normalmente será COM3, COM4, etc.
# No Linux algo como '/dev/ttyACM0'
# No macOS algo como '/dev/cu.usbmodemXXXX'
porta = 'COM4'  # <-- Altere para a porta correta do seu sistema

# Define a taxa de transmissão (baud rate).
# Deve ser IGUAL ao valor configurado no Arduino (Serial.begin(9600))
baudrate = 9600


# ==============================
# ABERTURA DA CONEXÃO SERIAL
# ==============================

# Cria um objeto Serial que representa a conexão com o Arduino.
# timeout=1 significa que o programa esperará até 1 segundo
# por dados antes de continuar a execução.
arduino = serial.Serial(porta, baudrate, timeout=1)

# Aguarda 2 segundos para permitir que o Arduino reinicie.
# Quando a porta serial é aberta, o Arduino geralmente executa reset automático.
time.sleep(2)

print("Conectado ao Arduino!")


# ==============================
# LOOP PRINCIPAL DO PROGRAMA
# ==============================

# Loop infinito para permitir envio contínuo de comandos
while True:

    # Solicita ao usuário que digite um comando
    comando = input("Digite LED_ON ou LED_OFF: ")

    # Envia o comando para o Arduino.
    # É acrescentado "\n" (nova linha), pois o Arduino usa
    # readStringUntil('\n') para identificar o fim da mensagem.
    #
    # .encode() converte a string Python (Unicode)
    # em bytes, que é o formato necessário para transmissão serial.
    arduino.write((comando + "\n").encode())

    # Lê uma linha enviada pelo Arduino.
    # readline() lê até encontrar '\n' ou até o timeout expirar.
    resposta = arduino.readline().decode().strip()

    # .decode() converte os bytes recebidos para string.
    # .strip() remove espaços e quebras de linha extras.

    # Verifica se alguma resposta foi recebida
    if resposta:
        print("Arduino respondeu:", resposta)

⚠  ATENÇÃO: Altere 'COM4' para a porta que você identificou no início do projeto.

Executando o projeto de comunicação bidirecional

1. Antes de executar o projeto, verifique se:

• O Arduino está conectado
• O Código (scketch) do IDE do Arduino foi carregado usando o Upload.
• O Monitor Serial está fechado
• Se a Porta identificada está correta no script do Python
• Se Baud rate está com 9600 (no monitor serial)

2. Abra o terminal (prompt do Windows).

3. Vá até a pasta que você criou o arquivo, digite: cd C:\Arduino\Python

4. Digite python controle_arduino.py e dê um enter para executar o script Python.

4.1. Se tudo estiver correto, aparecerá: Conectado ao Arduino! como mostra na tela abaixo.

5. Agora é digitar os comandos LED_ON e LED_OFF para acender ou apagar o Led interno do Arduino.

Conclusão

À primeira vista, este projeto pode parecer simples: enviar um comando pelo computador e acender o LED interno do Arduino Uno ou do Arduino Mega 2560. No entanto, por trás dessa ação elementar está a implementação de uma arquitetura fundamental em sistemas embarcados modernos.

Com poucas linhas de código, construímos:

• Comunicação serial bidirecional real

• Um protocolo de aplicação baseado em texto

• Integração entre firmware embarcado (sketch) e software desktop (Python)

• Sincronização de transmissão de dados

• Estrutura básica de cliente–servidor

O LED não é o foco — ele é apenas a prova física de que o fluxo de dados está funcionando corretamente entre hardware e software.

A partir dessa base, é possível evoluir para:

• Interfaces gráficas completas (HMI)

• Sistemas supervisórios (controles de componentes e sensores)

• Dashboards de monitoramento

• Controle remoto de dispositivos

• Integração com APIs e serviços web

• Projetos com Raspberry Pi ou sistemas híbridos

• Automação residencial e industrial

O verdadeiro valor didático deste projeto está em mostrar que o Arduino não precisa ser um sistema isolado. Ele pode fazer parte de uma arquitetura maior, integrada a aplicações externas, serviços digitais e interfaces profissionais.

Em outras palavras, este experimento marca a transição entre “projetos de bancada” e “sistemas integrados”.

Você agora domina o princípio essencial que sustenta praticamente toda comunicação entre sistemas embarcados e computadores: troca estruturada de dados. E isso abre um universo de possibilidades.

Comentários