Capítulo 2: Gerando e Lendo de Sinais#

A geração de sinais é o processo de criar formas de onda ou sinais elétricos artificiais que podem ser utilizados em diversas aplicações, como testes de sistemas eletrônicos, análise de circuitos, comunicações, entre outras. Esses sinais podem ter diferentes formas de onda, como sinusoidal, quadrada, triangular, dente de serra, etc.

Uma das formas de onda mais simples e comuns é a onda quadrada. A onda quadrada é um sinal periódico que alterna entre dois níveis de tensão, geralmente +1 e -1, com uma frequência específica. Ela é caracterizada por transições abruptas entre os níveis alto e baixo, formando um “quadrado” na forma de onda.

Outras formas de onda comuns incluem:

  • Onda senoidal: Sinal periódico que varia de forma suave entre os valores máximo e mínimo, seguindo uma função seno.

  • Onda triangular: Sinal periódico que varia linearmente entre os valores máximo e mínimo, formando um triângulo.

  • Onda dente de serra: Sinal periódico que aumenta linearmente e depois cai abruptamente, formando um dente de serra.

A geração desses sinais é feita normalmente por meio de circuitos eletrônicos dedicados, como osciladores, geradores de função, ou até mesmo por métodos digitais, como a geração por computador utilizando linguagens de programação e bibliotecas matemáticas, como mostrado no seu código em Python.

Vamos explorar essas possibildiades, que além de serem didáticas podem ser impementadas no mundo real.

Onda Quadrada#

Uma onda quadrada de 1 Hz é uma forma de onda periódica que oscila entre valores altos e baixos com uma frequência de um ciclo por segundo. Essa onda possui um período de 1 segundo e, idealmente, mantém uma proporção de 50% do tempo em valor alto (+1) e 50% em valor baixo (-1).

Passo 1: Importar as Bibliotecas Necessárias

import numpy as np
import matplotlib.pyplot as plt

Passo 2: Definir os Parâmetros da Onda Quadrada

Configuraremos o período de amostragem e a frequência da onda quadrada. Para uma onda de 1 Hz, são necessários no mínimo 2 pontos por período, conforme a teoria de Nyquist. No entanto, para uma visualização mais clara, utilizaremos uma quantidade maior de pontos.

# Parâmetros
f = 1  # frequência da onda quadrada em Hz
duration = 2  # duração total do sinal em segundos
sample_rate = 100  # taxa de amostragem em Hz

Passo 3: Gerar o Sinal da Onda Quadrada

Utilizaremos a função sign do NumPy junto com a função seno para criar a onda.

# Gerar um array com os instantes de tempo
t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)

# Gerar a onda quadrada
signal = np.sign(np.sin(2 * np.pi * f * t))

Passo 4: Plotar a Onda Quadrada

Utilizaremos o matplotlib para visualizar a onda quadrada.

# Criar o plot
plt.figure(figsize=(10, 4))
plt.plot(t, signal, label="Onda Quadrada 1 Hz")
plt.xlabel('Tempo (s)')
plt.ylabel('Amplitude')
plt.title('Onda Quadrada de 1 Hz')
plt.grid(True)
plt.ylim(-1.5, 1.5)
plt.legend()
plt.show()

Adicionando uma Onda Senoidal#

Além da onda quadrada, vamos gerar uma onda senoidal de 1 Hz para comparação.

# Gerar a onda senoidal
sine_wave = np.sin(2 * np.pi * f * t)

# Plotar a onda senoidal
plt.figure(figsize=(10, 4))
plt.plot(t, sine_wave, label="Onda Senoidal 1 Hz", color='red')
plt.xlabel('Tempo (s)')
plt.ylabel('Amplitude')
plt.title('Onda Senoidal de 1 Hz')
plt.grid(True)
plt.ylim(-1.5, 1.5)
plt.legend()
plt.show()

Código Completo:

Esse script Python permite visualizar tanto uma onda quadrada quanto uma onda senoidal, ambas com frequência de 1 Hz, facilitando a comparação das suas formas de onda.

import numpy as np
import matplotlib.pyplot as plt

# Parâmetros
f = 1  # frequência das ondas em Hz
duration = 2  # duração total do sinal em segundos
sample_rate = 100  # taxa de amostragem em Hz

# Gerar um array com os instantes de tempo
t = np.linspace(0, duration, int(sample_rate * duration))

# Gerar a onda quadrada
signal = np.sign(np.sin(2 * np.pi * f * t))

# Gerar a onda senoidal
sine_wave = np.sin(2 * np.pi * f * t)

# Criar o plot para a onda quadrada
plt.figure(figsize=(10, 4))
plt.plot(t, signal, label="Onda Quadrada 1 Hz")
plt.plot(t, sine_wave, label="Onda Senoidal 1 Hz", color='red')
plt.xlabel('Tempo (s)')
plt.ylabel('Amplitude')
plt.title('Ondas Quadrada e Senoidal de 1 Hz')
plt.grid(True)
plt.ylim(-1.5, 1.5)
plt.legend()
plt.show()

/home/hm/.local/lib/python3.10/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.
  warnings.warn("Unable to import Axes3D. This may be due to multiple versions of "
../../_images/dc058426275fbedea1419e0e3ed596a9d16c183f95e101582ac866a1b232c992.png

Gerando Sinais com Raspberry Pi Pico#

Para gerar uma onda quadrada em uma Raspberry Pi Pico, você pode usar o MicroPython, uma implementação de Python 3 otimizada para microcontroladores. A Raspberry Pi Pico possui pinos GPIO (General Purpose Input/Output) que podem ser configurados para gerar sinais digitais. Aqui está um guia passo a passo para gerar uma onda quadrada e testá-la com um LED e resistor:

Passo 1: Configurar o Ambiente de Desenvolvimento

  • Instalar o MicroPython na Raspberry Pi Pico: Baixe o firmware do MicroPython para a Raspberry Pi Pico a partir do site oficial. Siga as instruções para flashar o firmware na Pico usando o software Thonny IDE ou outro método.

  • Instalar uma IDE de Programação: O Thonny IDE é uma ferramenta amigável para programar em Python, incluindo o MicroPython para a Raspberry Pi Pico.

Passo 2: Escrever o Código em MicroPython

  • Importar as Bibliotecas Necessárias:

    • machine para acessar os pinos GPIO.

    • utime para controlar o tempo e criar delays.

  • Configurar o Pino GPIO:

    • Escolha um pino GPIO da Raspberry Pi Pico para gerar a onda quadrada (por exemplo, o pino 13).

    • Configure o pino como saída.

  • Gerar a Onda Quadrada:

    • Utilize um loop para alternar o estado do pino GPIO entre alto (HIGH) e baixo (LOW) com um intervalo de tempo adequado para criar a frequência desejada.

Aqui está um exemplo de código para gerar uma onda quadrada de 1 Hz (1 ciclo por segundo):

import machine
import utime

# Configurar o pino GPIO (escolha um pino, por exemplo, 13)
pino = machine.Pin(13, machine.Pin.OUT)

# Definir a frequência da onda quadrada (em Hz)
frequencia = 1  # 1 Hz
periodo = 1.0 / frequencia  # período da onda quadrada em segundos

while True:
    pino.value(1)  # Definir o pino como alto (HIGH)
    utime.sleep(periodo / 2)  # Aguardar metade do período
    pino.value(0)  # Definir o pino como baixo (LOW)
    utime.sleep(periodo / 2)  # Aguardar metade do período

Passo 3: Executar o Código

  • Conectar a Raspberry Pi Pico ao Computador:**

    • Conecte a Pico ao seu computador via cabo USB.

  • Abrir o Thonny IDE:

    • No Thonny, selecione a placa Raspberry Pi Pico.

    • Copie e cole o código acima no editor do Thonny.

  • Executar o Código:

    • Clique no botão de execução (Run) no Thonny para enviar o código para a Pico e iniciar a geração da onda quadrada.

Passo 4: Testar a Onda Quadrada com um LED

  • Conectar um LED e um Resistor:

    • Conecte um resistor (220Ω é uma boa escolha) em série com o anodo (perna longa) do LED.

    • Conecte o catodo (perna curta) do LED ao GND (terra) da Raspberry Pi Pico.

    • Conecte o outro terminal do resistor ao pino 13 da Raspberry Pi Pico.

Passo 5: Verificar a Onda Quadrada

Observar o LED Piscar: Quando o código estiver em execução, o LED deve piscar com uma frequência de 1 Hz (um segundo aceso, um segundo apagado).

  • Conectar um Osciloscópio (Opcional):

    • Se você tiver um osciloscópio, conecte a sonda ao pino configurado (pino 13) e ao GND (terra) para visualizar a onda quadrada.

    • Ajuste o osciloscópio para observar a forma de onda e verificar a frequência.

A Seguir, uma figura mostrando o esquema desejado:

setup

Explicação Adicional

  • Pino GPIO: Pinos de Entrada/Saída Gerais (GPIO) são usados para controlar dispositivos eletrônicos. Configurando um pino como saída, podemos controlar seu estado (alto ou baixo).

  • Frequência e Período: A frequência é o número de ciclos por segundo. O período é o tempo que leva para completar um ciclo. Para uma onda quadrada de 1 Hz, o período é 1 segundo.

  • Delays: utime.sleep() é usado para criar atrasos no código. Ao alternar o estado do pino com atrasos de metade do período, geramos a onda quadrada.

Com esses passos, você pode gerar uma onda quadrada em uma Raspberry Pi Pico usando MicroPython e verificar o funcionamento com um LED e resistor. Este exemplo pode ser adaptado para diferentes frequências e aplicações conforme necessário.

Lendo Sinais com Raspberry Pi Pico#

Os pinos GPIO (General Purpose Input/Output) são usados para controlar dispositivos eletrônicos. Configurando um pino como entrada, podemos ler seu estado (alto ou baixo), permitindo a captura de sinais digitais. A seguir, mostramos como aprimorar o código para incluir a leitura de sinais em uma Raspberry Pi Pico.

Código para Geração e Leitura de Sinais

import machine
import utime

# Configurar o pino GPIO para gerar a onda quadrada (Pino 13)
pino_saida = machine.Pin(13, machine.Pin.OUT)

# Configurar o pino GPIO para ler a onda quadrada (Pino 14)
pino_entrada = machine.Pin(14, machine.Pin.IN)

# Definir a frequência da onda quadrada (em Hz)
frequencia = 1  # 1 Hz
periodo = 1.0 / frequencia  # Período da onda quadrada em segundos

# Tempo de execução (em segundos)
tempo_execucao = 5

# Tempo inicial
tempo_inicial = utime.ticks_ms()

# Função para imprimir tempo e amostra com 3 casas decimais
def imprimir_dados(tempo_decorrido, amostra):
    print(f"{tempo_decorrido:.2f} {amostra}")

# Função para calcular o tempo decorrido em segundos
def tempo_decorrido_segundos(tempo_inicial):
    return utime.ticks_diff(utime.ticks_ms(), tempo_inicial) / 1000

# Geração e leitura da onda quadrada
while True:
    # Gerar a onda quadrada (independente do estado de entrada)
    pino_saida.value(1)  # Definir o pino de saída como alto (HIGH)
    estado_entrada = pino_entrada.value()  # Ler o estado do pino de entrada
    imprimir_dados(tempo_decorrido_segundos(tempo_inicial), estado_entrada)
    utime.sleep(periodo / 2)  # Aguardar metade do período

    pino_saida.value(0)  # Definir o pino de saída como baixo (LOW)
    estado_entrada = pino_entrada.value()  # Ler o estado do pino de entrada
    imprimir_dados(tempo_decorrido_segundos(tempo_inicial), estado_entrada)
    utime.sleep(periodo / 2)  # Aguardar metade do período
    
    # Verificar se o tempo de execução foi atingido
    tempo_decorrido = tempo_decorrido_segundos(tempo_inicial)
    if tempo_decorrido >= tempo_execucao:
        break

# Exibir o tempo de execução total
print(f"Tempo de execução total: {tempo_decorrido:.2f}s")

Saída Esperada

0.00 1
0.50 0
1.00 1
1.50 0
2.00 1
2.50 0
3.01 1
3.51 0
4.01 1
4.51 0
Tempo de execução total: 5.01s

Explicação Adicional

  • Pino GPIO: Os pinos GPIO são usados para controlar dispositivos eletrônicos. Configurando um pino como entrada, podemos monitorar o estado do sinal digital (alto ou baixo).

  • Geração e Leitura de Sinais: No exemplo acima, um pino GPIO é configurado como saída para gerar uma onda quadrada, enquanto outro pino é configurado como entrada para ler essa onda. O código alterna o estado do pino de saída e lê o estado do pino de entrada, registrando os dados e o tempo decorrido.

  • Frequência e Período: A frequência é o número de ciclos por segundo. O período é o tempo que leva para completar um ciclo. Para uma onda quadrada de 1 Hz, o período é 1 segundo.

  • Delays: utime.sleep() é usado para criar atrasos no código. Alternando o estado do pino com atrasos de metade do período, geramos a onda quadrada.

Com esses passos, você pode gerar e ler uma onda quadrada em uma Raspberry Pi Pico usando MicroPython, verificando o funcionamento com um LED e um resistor.