https://t.co/chbfdM8zjU pic.twitter.com/QInx635sf2

— Elisabete (@Elisabete212046) August 1, 2026

Aprenda a Usar o Nano no Linux Mint e Teste Seus Projetos de Arduino Online!

No desenvolvimento de sistemas embarcados e projetos de automação, utilizar o ambiente de linha de comando para editar códigos é uma prática eficiente e muito comum em ambientes Linux. Neste artigo, vamos explorar como utilizar o editor de texto GNU Nano no sistema operacional Linux Mint, apresentar um código em C++ para controle de LED via botão com lógica de alternância (toggle), explicar linha por linha a sua estrutura e demonstrar como simulá-lo na plataforma Tinkercad.

---

1. Usando o Editor Nano no Linux Mint

O GNU Nano é um editor de texto simples, intuitivo e direto via terminal, muito utilizado no Linux Mint para criar scripts, ajustar configurações de sistema e escrever códigos para microcontroladores.

Passo 1: Abrindo o Terminal no Linux Mint

Abra o terminal utilizando o atalho do teclado: Ctrl + Alt + T.

Passo 2: Criando ou Abrindo um Arquivo no Nano

Digite o comando a seguir no terminal para criar e abrir um arquivo fonte chamado codigo.cpp (ou sketch.ino):

nano codigo.cpp

Passo 3: Editando o Código dentro do Nano

Após executar o comando, o editor Nano abrirá na própria janela do terminal. Você pode digitar ou colar seu código C/C++ diretamente na tela.

Passo 4: Atalhos para Salvar e Sair

• Salvar as alterações: Pressione Ctrl + O, confirme o nome do arquivo pressionando Enter.
• Sair do Nano: Pressione Ctrl + X. Se você alterou o arquivo e não salvou, ele perguntará se deseja salvar antes de fechar.

---

2. Compilando C++ no Linux via Linha de Comando

Se você estiver escrevendo um código em C++ padrão (sem as bibliotecas nativas do framework Arduino), pode compilá-lo no Linux Mint utilizando o compilador g++:

# Instalar o compilador g++ (caso ainda não possua)
sudo apt update && sudo apt install g++ -y

# Compilar o arquivo fonte C++
g++ codigo.cpp -o programa

# Executar o binário compilado
./programa

Nota: Códigos específicos para placas Arduino (como o utilizado a seguir) utilizam a biblioteca nativa do framework C/C++ da plataforma e dependem da ferramenta arduino-cli para compilação via terminal Linux ou da IDE Arduino/Simuladores para execução.

---

3. Código-Fonte: Controle de LED por Botão (Detecção de Borda de Queda)

Abaixo está o código em C++ para controle de estado de um LED utilizando um botão configurado com resistor de pull-up interno:

// Declaração das variáveis e pinos
const int pinoBotao = 2;
const int pinoLed = 13;

int estadoLed = LOW;
int leituraAnterior = HIGH;

void setup() {
  pinMode(pinoBotao, INPUT_PULLUP);  // ativa o resistor interno de pull-up
  pinMode(pinoLed, OUTPUT);          // configura o pino do LED como saída
}

void loop() {
  int leituraAtual = digitalRead(pinoBotao);

  // Detecção da transição de HIGH para LOW (botão pressionado)
  if (leituraAtual == LOW && leituraAnterior == HIGH) {
    estadoLed = !estadoLed;            // inverte o estado do LED
    digitalWrite(pinoLed, estadoLed);   // atualiza a saída física
    delay(50);                         // debouncing por software
  }

  leituraAnterior = leituraAtual;       // atualiza a leitura prévia para o próximo ciclo
}

---

4. Explicação Detalhada do Código Passo a Passo

Configurações Iniciais (Bloco setup())

1. pinMode(pinoBotao, INPUT_PULLUP);
   Configura o pino digital conectado ao botão como entrada com o resistor de pull-up interno ativado. Com isso, o pino lerá continuamente nível alto (HIGH / 5V) quando o botão estiver solto. Ao ser pressionado, o pino é conectado ao pino GND, alterando seu estado para nível baixo (LOW / 0V). Isso elimina a necessidade de colocar resistores externos no circuito do botão.
2. pinMode(pinoLed, OUTPUT);
   Configura o pino do LED como saída digital, permitindo ao microcontrolador enviar sinais elétricos em nível HIGH (para acender) ou LOW (para apagar).

Laço Principal (Bloco loop())

1. int leituraAtual = digitalRead(pinoBotao);
   Lê o estado lógico atual da porta digital associada ao botão e armazena o valor na variável leituraAtual.
2. if (leituraAtual == LOW && leituraAnterior == HIGH)
   Detecta a borda de descida (falling edge). A condição só é satisfeita no exato instante em que o botão passa do estado solto (HIGH) para o estado pressionado (LOW). Isso evita que o LED fique alternando descontroladamente enquanto o botão permanece pressionado.
3. estadoLed = !estadoLed;
   Aplica o operador lógico de negação (!) para inverter o estado da variável booleana. Se estiver desligado (LOW), passa para ligado (HIGH), e vice-versa.
4. digitalWrite(pinoLed, estadoLed);
   Aplica no pino físico do LED o novo estado lógico atualizado.
5. delay(50);
   Cria uma pausa de 50 milissegundos para realizar o tratamento de debouncing via software, atenuando os ruídos mecânicos e trepidações de contato do botão.
6. leituraAnterior = leituraAtual;
   Atualiza a variável de memória leituraAnterior com a leitura atual, preparando o programa para comparar novamente o estado do pino na próxima iteração do ciclo loop().

---

5. Como Montar e Simular no Tinkercad Passo a Passo

Para testar o funcionamento da lógica sem a necessidade de componentes físicos, você pode utilizar a plataforma de simulação online Tinkercad Circuits.

Passo 1: Criar um Projeto

1. Acesse tinkercad.com e faça login na sua conta.
2. No menu lateral, clique em Criar > Circuito.

Passo 2: Adicionar os Componentes no Espaço de Trabalho

• 1x Placa Arduino Uno R3
• 1x Protoboard (Matriz de contatos)
• 1x Pushbutton (Botão)
• 1x LED (Qualquer cor)
• 1x Resistor de 220 Ω (Para limitação de corrente do LED)

Passo 3: Esquema de Ligação (Conexões)

1. Conexão do Botão:
   • Ligue um dos terminais do botão ao Pino Digital 2 do Arduino.
   • Ligue o terminal oposto na mesma linha de contato ao pino GND do Arduino.
2. Conexão do LED:
   • Ligue o Anodo (perna mais longa/curvada do LED) ao Pino Digital 13 do Arduino.
   • Ligue o Catodo (perna mais curta do LED) a um terminal do resistor de 220 Ω.
   • Ligue o outro terminal do resistor ao pino GND do Arduino.

Passo 4: Inserir o Código

1. No canto superior direito, clique no botão Código.
2. Altere o modo de visualização de Blocos para Texto. Confirmando o aviso da plataforma.
3. Apague o código padrão pré-carregado e cole o código-fonte C++ apresentado acima neste artigo.

Passo 5: Iniciar a Simulação

1. Clique no botão verde Iniciar Simulação.
2. Clique no botão interativo na protoboard: a cada clique completo (pressionar e soltar), o LED alternará entre os estados aceso e apagado de forma estável.

```

Como Funcionam os Testes de Segurança nas Urnas Eletrônicas?

Entenda o acesso dos peritos, os tipos de ataque testados e o ciclo de correção de falhas.

Os testes de segurança nas urnas são concentrados principalmente no Teste Público de Segurança (TPS), um evento oficial e aberto que o TSE realiza meses antes de cada eleição. Nesse evento, peritos independentes, acadêmicos, hackers éticos e instituições parceiras recebem sinal verde para tentar invadir e burlar o sistema de todas as formas possíveis.

A lógica do TPS é a de um red teaming (teste de invasão e hackeamento ético): o TSE entrega o sistema nas mãos de especialistas para que eles tentem achar as falhas antes que criminosos possam tentar explorá-las no dia do pleito.

1. A que os investigadores têm acesso?

Durante os testes, os investigadores e peritos não trabalham "às cegas". O TSE adota o modelo de teste de caixa-branca (white-box test), fornecendo acesso amplo aos componentes do sistema:

• Código-fonte completo: Os peritos têm acesso a todas as linhas de código do sistema operacional da urna (um Linux simplificado), dos programas de votação, dos algoritmos de criptografia e do sistema de transmissão.
• Hardware da urna: Os participantes recebem equipamentos reais da urna eletrônica (incluindo placas, mídias de memória e leitores biométricos) para manipular fisicamente no laboratório do TSE.
• Bibliotecas e softwares auxiliares: Acesso às ferramentas usadas para gerar os arquivos e assinar as mídias.
• Documentação técnica: Manuais do sistema, especificações de arquitetura e esquemas de circuitos do hardware.

2. Quais testes são feitos e quais vulnerabilidades eles buscam?

Os investigadores criam planos de teste específicos e tentam explorar diferentes caminhos de ataque:

A. Injeção e alteração de código (Tentativa de adulteração de software)

• O teste: Os peritos tentam modificar o código interno da urna para fazer com que ela registre votos em um candidato diferente do digitado.
• O que avaliam: Se a urna percebe a alteração e trava. O sistema usa assinaturas digitais — se o código for modificado sem a chave oficial, a urna deve recusar a inicialização.

B. Extração do Registro Digital do Voto (Ataque ao sigilo do voto)

• O teste: Tentativas de extrair o histórico de votação para descobrir a ordem em que os votos foram digitados e cruzar com o horário de entrada dos eleitores.
• O que avaliam: Se o algoritmo de embaralhamento dos votos no arquivo RDV (Registro Digital do Voto) é seguro e matematicamente imprevisível.

C. Ataques físicos ao hardware (Engenharia reversa)

• O teste: Os investigadores conectam equipamentos externos diretamente às placas de circuito da urna, portas USB e leitoras de cartão de memória para tentar injetar dados ou extrair chaves de criptografia diretamente da memória RAM/Flash.
• O que avaliam: Se o hardware possui blindagem física suficiente contra leitura direta de dados.

D. Ataques ao leitor biométrico e tela

• O teste: Tentativas de "enganar" o leitor biométrico (usando moldes ou dedos falsos) ou de interceptar o sinal que vai da placa principal para o visor da urna.

3. O Passo a Passo: O que acontece quando uma vulnerabilidade é encontrada?

Encontrar uma falha no TPS é considerado um sucesso do teste, e não uma derrocada do sistema. O processo funciona no seguinte ciclo rigoroso de 3 passos:

Passo 1: Relatório de Vulnerabilidade

Se uma equipe de peritos encontra uma brecha (por exemplo, uma falha na forma como um arquivo de log é gravado), ela documenta detalhadamente o passo a passo da invasão e entrega ao TSE.

Passo 2: Correção do Sistema (Patch de Segurança)

A equipe de engenheiros de software do TSE analisa o relatório e desenvolve uma solução técnica para fechar e selar a brecha identificada no código ou hardware.

Passo 3: Teste de Confirmação (Re-teste Público)

Meses depois, as mesmas equipes que acharam as falhas voltam ao laboratório do TSE para testar o sistema novamente e confirmar se o "buraco" foi devidamente selado antes das eleições.

---

🛠️ Simulador de Red Team: Teste Público de Segurança (TPS)

Selecione um vetor de ataque e execute a simulação para observar como o sistema reage e aplica a correção.

Escolha o vetor de ataque do perito/investigador: Ataque A: Injeção de Código na Memória Flash Ataque B: Análise Estatística do Embaralhamento do RDV (Sigilo) Ataque C: Conexão Física via Porta USB / Barramento da Placa

Terminal de Diagnóstico do TPS:

> Selecione o ataque acima e clique em "Executar Plano de Teste".

🖥️ Simulador de Boot e Integridade Criptográfica (Urna Eletrônica)

Teste como o hardware verifica a assinatura digital do código do TSE antes de iniciar a votação.

Selecione o estado do software inserido na mídia: ✅ Código Oficial do TSE (Assinado com Chave Privada Autêntica) 🚨 Código Modificado / Injeção Externa (Sem Assinatura Válida)

Log de Diagnóstico do Hardware:

> Sistema em espera. Selecione o código e clique em "Ligar Urna".