Gerar Senóide

Problema

A idéia é criar uma pequena rotina que:

• Gera senóide na frequência de: 440 Hz

• Usa frequência/faxa de amostragem: $f_s=$$f_s=$10 kHz (ou $T=1/10000=100\mu$$T=1/10000=100\;\mu$s) Isto permite sintetizar 25 pontos por ciclo: $pts={\displaystyle \frac{10000}{440}}=22,7272727273$$pts=\dfrac{10000}{440} = 22,7272727273$ Pontos/ciclo Isto deve render uma senoide semelhante à mostrada abaixo:

  

• Usar DAC1: GPIO25 - 8 bits.
• O botão in-board BOOT será usado para ligar/desligar geração da senóide
• Acrescentar pino I/O de DEBUG, onde deve aparecer uma onda quadrada oscilando na taxa de amostragem (10 KHz), mas cujo duty-cycle deve corresponder ao tempo de processamento usado para processar o seno.

Solução usando Phase Accumulator

Existem diferentes formas de solucionar este problema. Aqui vamos usar a abordagem chamada “phase accumulator”. Ao final é comentada a técnica DDS fixed-point + LUT.

A idéia é implementar uma interrupção por software gerada por oversflow de times, ou simplesmente “ISR”.

A cada instante de amostragem (execução da ISR), vamos:

1. Determinar o novo ângulo da senóide: $\varphi [n+1]=\varphi [n]+\mathrm{\Delta }\varphi$$\phi [n+1] = \phi [n] + \Delta \phi$

2. Calculamos antes de iniciar a ISR, o valor de $\mathrm{\Delta }\varphi$$\Delta \phi$. Como a freq. de amostragem é: $f_s=10000$$f_s=10000$ Hz, Freq. a ser sintetizada é: $f=440$$f=440$ Hz, temos então:

   $\mathrm{\Delta }\varphi =2\pi {\displaystyle \frac{440}{10000}}=0,27646$$\Delta \phi = 2 \pi \dfrac{440}{10000} = 0,27646$ (rad) ou $\approx 15,{84}^o$$\approx 15,84^o$.

3. Isto significa que calculamos $\varphi [n]$$\phi[n]$ sendo algo como:

   0
   0.27646
   0.55292
   0.82938
   1.10584
   

4. E depois calculamos:

   sin(angle)
   

   a cada 100 $\mu$$\mu$s.

Detalhes extras:

1. Calculamos a senoide usando: $x[n]=\sin (\varphi [n])$$x[n]=\sin(\phi[n])$ que gera uma saída no intervalo: $[-1,1]$$[-1, 1]$
2. Temos que escalonar a saída para a faixa: $[-1,+1]\to [0,255]$$[-1,+1]\rightarrow[0,255]$ para alimentar o DAC de 8-bits.

Pinagem

Observações:

1. A placa ESP32 DevKitC v4 variação 32UE do chip não apresenta o “apêndice” superior associado com a antena Bluettoh/WiFi. Na realidade, ela apresenta um conector na parte superior direito para conexão de antena externa.
2. Falta acrescentar filtro passa-baixas na saída do DAC.

Filtro RC na saída do DAC

É interessante colocar um filtro passa-baixa analógico na saída do DAC para cortar os harmônicas de ordem elevada associados com o processo de amostragem.

Como estamos trabalhando com $f_s=10$$f_s=10$ KHz, devemos localizar a frequência de corte abaixo da frequência de Nyquist, oiu seja, em $f_c=10K/2=5$$f_c=10K/2=5$ KHz.

Vamos usar um simples circuito RC, um filtro passa-baixa de 1a-ordem cuja função transferência é dada por:

$H(s)={\displaystyle \frac{K\cdot {\omega }_c}{(s+{\omega }_c)}}$$H(s)=\dfrac{K \cdot \omega_c}{(s+\omega_c)}$

onde:

• ${\omega }_c$$\omega_c$ se refere a frequência de corte do filtro (em rad/s). Frequência na qual, teremos uma queda na amplitude de entrada no valor de $-3$$-3$ dB ou atenuação para 0,7079 do valor de entrada (${10}^{-3/20}$$10^{-3/20}$).
• $K$$K$ se refere ao ganho do filtro (caso de um circuito ativo, com Amp.Op.);

Note que para frequências de entrada abaixo de ${\omega }_c$$\omega_c$, o ganho do filtro é dado por:

$G={\displaystyle \frac{K\cdot {\omega }_c}{{\omega }_c}}=K$$G=\dfrac{K \cdot \omega_c}{\omega_c}=K$.

O valor de ${\omega }_c$$\omega_c$ em Hz por ser calculado via:

${\omega }_c=2\pi \cdot f_c$$\omega_c=2\pi\cdot f_c$

E finalmente podemos relacionar $f_c$$f_c$ com o valores de um circuito RC usados para sintetizar este filtro, através da equação:

$f_c={\displaystyle \frac{1}{2\pi RC}}$$f_c=\dfrac{1}{2\pi RC}$

onde: $R$$R$ se refere ao valor do resitor e $C$$C$ se refere ao valor do capacitor.

Supondo que $R=$$R=$ 10 K$\mathrm{\Omega }$$\Omega$, que representaria uma carga muito leve para o DAC da placa ESP32, decobrimos que o valor do capacitor deve ser de:

$C={\displaystyle \frac{1}{2\pi R{f}_c}}={\displaystyle \frac{1}{2\pi \cdot 10K\cdot 5K}}=3,1831$$C=\dfrac{1}{2\pi R f_c}=\dfrac{1}{2\pi \cdot 10K \cdot 5K}=3,1831$ nF

O valor comercial mais próximo é 3,9 ou 2,7 nF.

Assim, recomenda-se usar um resistor de:

• R = 10 K$\mathrm{\Omega }$$\Omega$;
• C = 2,7 nF (poliester)

Setup físico final

Codificação

Duas abordagem de codificação são apresentadas:

• Versão usado ESP-IDF Puro , ou;
• Versão usando Arduíno-IDE.

Observações

Quanto tempo de processamento é dedicado dentro da ISR (uma tarefa crítica) para calcular o sinf() !?

A idéia é justamente medir o duty-cycle do pino de DEBUG para medir o valor real de tempo (custo) de processamento gasto nesta forma de abordagem.

Resultados

São esperadas formas de onde como as mostradas na figura abaixo:

A figura anterior mostra uma captura da tela do osciloscópio. Na parte superior aparece uma senóide de 438 Hz sendo gerada, com amplitude variando entre [0, 3.14] Volts (a placa ESP32 funciona internamente a 3,3 Volts) e na parte inferior aparece o resultado obtudo no pino DEBUG, confirmando que a ISR está sendo executada na taxa de 10 KHz, e ocupando apenas 5,8% do ciclo de 10 KHz ($\approx$$\approx$ 6 $\mu$$\mu$s para ser executada). O que indica que poderíamos trabalhar com taxas de amostragem maiores e ainda assim conseguir sintetizar esta mesma senóide usando esta abordagem que calcula o $\sin \left(angle\right)$$\sin(angle)$ (ponto flutuante por software à cada 100 $\mu$$\mu$s).

Espera-se um Relatório, contendo:

1. Cópia do código implementado com comentários relevantes (apenas os mais importantes);

2. Cópia da tela do Osciloscópio mostrando a onda senoida sendo gerada, preferencialmente acompanhada do valor da frequência medida pelo equipamento.

3. Cópia da tela do Osciloscópio mostrando::

   1. Canal 1: onda quadrada de 10 KHz correspondendo à exceução da ISR;
   2. Informações sobre frequência e duty-cycle desta onda.

4. Determinação do período de tempo ocupado exclusivamente com o processamento da ISR.

Detalhes

sin() ou sinf() é uma operação relativamente “cara” para um minicontrolador.

Não estamos falando apenas de uma multiplicação:

x = a * b;

O cálculo do seno envolve uma série de operações matemáticas para obter uma aproximação da função.

E estamos pedindo isso $10.000\times$$10.000 \times$ por segundo.

Uma solução seria aprimorar um pouco mais esta abordagem e usar acumular inteiro ou por fixed-point.

Técnica DDS inteiro + LUT

Esta outra abordagem chamada de DDS (Direct Digital Synthesis) fixed Point + LUT table, usa variáveis inteiras de ponto fixo + tabelas (Lookup Table) armazenando valores pré-calculados externamente do seno (dentro de uma faixa equivalente à 0 à $2\pi$$2\pi$). Esta abordagem tentar buscar uma solução mais eficiente computacionalmente (ou menos custosa).

Representamos a fase como um número inteiro de 32-bits:

uint32_t angle;

Um período inteiro da senóide seria representado pela faixa:

$0\le angle<2^{32}$$0 \leq angle < 2^{32}$

E continuamos fazendo algo como:

angle += angle_increment;

Antes desta abordagem, tínhamos que controlar a faixa do ângulo (em radianos):

if (angle >= 2*pi)
    angle -= 2*pi;

Agoram usando aritmética de ponto inteiro de 32-bits, caso o angulo ultrapasse o maior valor (overflow), ocorre naturalmente a “volta ao zero”. Então, nesta nova abordagem simplesmente se faz:

angle += angle_increment;

deixando ocorrer o overflow sem problemas, sem necessidade de um bloco if.

Mas como determinamos o incremento?

A frequência desejada continua sendo $f_0$$f_0$ e a taxa de amostragem: $f_s$$f_s$.

Então o incremento de fase no formato de 32 bits fica:

$angleIncrement={\displaystyle \frac{f_0}{f_s}}\cdot 2^{32}$$angleIncrement = \dfrac{f_0}{f_s} \cdot 2^{32}$

Para: $f_0=440$$f_0=440$ e $f_s=10000$$f_s=10000$, temos:

$angleIncrement=\left({\displaystyle \frac{440}{10000}}\right)\cdot 2^{32}$$angleIncrement = \left( \dfrac{440}{10000} \right) \cdot 2^{32}$

aproximadamente:

$angleIncrement\approx 188.978.562$$angleIncrement \approx 188.978.562$

Então o ISR fica essencialmente:

angle += angleIncrement;

uma soma inteira.

Essa é a grande vantagem do ponto de vista computacional.

Mas ainda precisamos calcular o seno

O acumulador inteiro não elimina automaticamente o cálculo de seno.

Precisamos transformar:

xxxxxxxxxx
angle

em:

xxxxxxxxxx
sin(angle)

Há várias possibilidades.

A mais clássica é usar uma LUT (Lock Up Table):

xxxxxxxxxx
angle (32 bits)
       │
       │ separa-se os bits mais significativos
       │
       ▼
     índice
       │
       ▼
   LUT seno
       │
       ▼
      DAC

Por exemplo, uma LUT com 256 pontos (8-bits):

xxxxxxxxxx
uint8_t sineTable[256];

e usamos os 8 bits mais significativos fazendo um shit right:

xxxxxxxxxx
index = angle >> 24;

Agora o ISR pode ser aproximadamente:

​x
angle += angleIncrement;

index = angle >> 24;

dac_oneshot_output_voltage(
    dac_handle,
    sineTable[index]
);

Veja:

• Antes, versão angle accumulator (float):

  xxxxxxxxxx
  10 kHz
    │
    ├── soma float
    │
    └── sinf()
         ↓
        DAC
  

• Agora, DDS inteiro + LUT:

  xxxxxxxxxx
  10 kHz
    │
    ├── soma inteira
    │
    ├── shift
    │
    └── acesso à LUT
         ↓
        DAC
  

A segunda abordagem é bem menos custosa computacionalmente.

Se ao invés de montar (externamente) uma LUT de 8-bits, usarmos 10-bits (1024 valores) o erro de quantizaçao angular diminui.

$2\pi \to 1024$$2\pi \rightarrow 1024$

Cada ponto corresponderia à passos de:

${\displaystyle \frac{{360}^o}{1024}}=0,{3515625}^o$$\dfrac{360^o}{1024}=0,3515625^o$

O erro máximo de quantização de fase, assumindo o ponto mais próximo, seria aproximadamente metade disso, então:

$\pm 0,{17578125}^o$$\pm 0,17578125^o$

A LUT de 1024 seria endereçada na forma:

xxxxxxxxxx
index = angle >> 22;

porque:

$32-10=22$$32−10=22$

Portanto:

xxxxxxxxxx
32-bit phase
       │
       │ >> 22
       ▼
10-bit index
       │
       ▼
LUT[0 ... 1023]

Mas…. a LUT de 1024 valores de 8-bits vai ocupar 1024 bytes, enquanto a LUT de 256 valores iria ocupar apenas 256 bytes, $4\times$$4 \times$ menos memória, Já as variáveies uint32_t angle e uint32_t angleIncrement, continuariam ocupando 8 bytes.

Resumo Final

A parte do código para sintetizar a senóide ficaria:

xxxxxxxxxx
uint32_t angle;
uint32_t angleIncrement;

mas algo como:

xxxxxxxxxx
uint8_t sineTable[1024];

Assim temos:

xxxxxxxxxx
                 ┌─────────────────────────────┐
                 │       32-bit angle          │
                 │                             │
                 │  10 bits       22 bits      │
                 │   índice      "fração"      │
                 └──────┬──────────────────────┘
                        │
                     >> 22
                        │
                        ▼
                ┌──────────────┐
                │ LUT 1024 × 8 │
                └──────┬───────┘
                       │
                       ▼
                      DAC

E a ISR ficaria praticamente reduzido a:

xxxxxxxxxx
angle += angleIncrement;

uint16_t index = angle >> 22;

dac_oneshot_output_voltage(
    dac_handle,
    sineTable[index]
);

Isso é muito mais eficiente que:

xxxxxxxxxx
angle += angle_increment;

float value = sinf(angle);

...

Vantagens Extras

Nesta nova técnica, se quisermos variar a frequência da senóide, simplesmente re-calculamos o valor do incremento.

Não temos que recalcular a tabela do seno.

E podemos inclusive alterar a frequência em tempo de execução:

xxxxxxxxxx
phaseIncrement
       ↑
       │
       └── variável de controle

Isso é a essência de um NCO — Numerically Controlled Oscillator.

Fernando Passold, em 14/09/2026.