classe DAC – conversão digital para analógico¶

O DAC gera tensões analógicas entre 0 V e 3,3 V em um de dois canais DAC do STM32.

Em cada OpenMV Cam baseada em STM32 que expõe pyb.DAC (M4 / M7 / H7 / H7 Plus / Pure Thermal) os canais são conectados da seguinte forma:

Canal do DAC	Pino do header	Pino do STM32
`DAC(1)`	(não disponível no header)	`PA4`
`DAC(2)`	`P6`	`PA5`

A OpenMV Cam N6 não possui um periférico DAC; pyb.DAC não está disponível nessa placa.

Exemplo de uso:

from pyb import DAC

dac = DAC(1)            # create DAC channel 1
dac.write(128)          # write a value to the DAC (approximately 1.65 V)

dac = DAC(1, bits=12)   # use 12-bit resolution
dac.write(4095)         # output maximum value, 3.3 V

Para gerar uma onda senoidal contínua:

import math
from pyb import DAC

# create a buffer containing a sine-wave
buf = bytearray(100)
for i in range(len(buf)):
    buf[i] = 128 + int(127 * math.sin(2 * math.pi * i / len(buf)))

# output the sine-wave at 400Hz
dac = DAC(1)
dac.write_timed(buf, 400 * len(buf), mode=DAC.CIRCULAR)

Para gerar uma onda senoidal contínua com resolução de 12 bits:

import math
from array import array
from pyb import DAC

# 128-sample sine wave, half-word samples centred at 2048 (12-bit mid).
N = 128
buf = array("H", (
    2048 + int(2047 * math.sin(2 * math.pi * i / N))
    for i in range(N)
))

# Output the sine wave at 400Hz.
dac = DAC(1, bits=12)
dac.write_timed(buf, 400 * len(buf), mode=DAC.CIRCULAR)

Construtores¶

class pyb.DAC(port: int | Pin, bits: int = 8, *, buffering: bool | None = None)¶

Constrói um novo objeto DAC.

port pode ser um objeto Pin ou um inteiro (1 ou 2) selecionando o canal DAC 1 ou 2. O pino físico para o qual cada canal é roteado depende da OpenMV Cam.

bits é um inteiro que especifica a resolução, e pode ser 8 ou 12. O valor máximo aceito por write() e write_timed() é (2**bits) - 1 (255 para 8 bits, 4095 para 12 bits).

O parâmetro buffering seleciona o comportamento do buffer de saída do amplificador operacional do DAC, cujo propósito é reduzir a impedância de saída. Pode ser None para selecionar o padrão (buffering habilitado para DAC.noise(), DAC.triangle() e DAC.write_timed(), e desabilitado para DAC.write()), False para desabilitar o buffering completamente, ou True para habilitar o buffering de saída.

Quando o buffering está habilitado, o pino do DAC pode acionar cargas de até 5KΩ. Caso contrário, ele tem uma impedância de saída de no máximo 15KΩ: consequentemente, para alcançar uma precisão de 1% sem buffering, a carga aplicada deve ser menor que 1,5MΩ. Usar o buffer acarreta uma penalidade na precisão, especialmente próximo aos extremos da faixa.

Métodos¶

init(bits: int = 8, *, buffering: bool | None = None) → None¶: Reinicializa o DAC. bits pode ser 8 ou 12. buffering pode ser None, False ou True; veja o construtor acima para o significado desse parâmetro.

deinit() → None¶: Desinicializa o DAC, tornando seu pino disponível para outros usos.

noise(freq: int) → None¶: Gera um sinal de ruído pseudoaleatório. Uma nova amostra aleatória é escrita na saída do DAC na frequência fornecida.

triangle(freq: int) → None¶: Gera uma onda triangular. O valor na saída do DAC muda na frequência fornecida e percorre toda a faixa de 12 bits (subindo e descendo). Portanto, a frequência da própria onda triangular repetitiva é 8192 vezes menor.

write(value: int) → None¶: Acesso direto à saída do DAC. O valor mínimo é 0; o máximo é (2**bits) - 1, onde bits é definido na criação do objeto DAC ou via init().

write_timed(data: bytes | bytearray | 'array.array', freq: int | Timer, *, mode: int = DAC.NORMAL) → None¶

Inicia uma rajada de RAM para DAC usando uma transferência DMA. Os dados de entrada são tratados como um array de bytes no modo 8 bits, e como um array de meias-palavras sem sinal (typecode de array ‘H’) no modo 12 bits.

freq pode ser um inteiro especificando a frequência na qual escrever as amostras do DAC, usando Timer(6). Ou pode ser um objeto Timer já inicializado, que é usado para disparar a amostra do DAC. Os timers válidos são 2, 4, 5, 6, 7 e 8.

mode pode ser DAC.NORMAL ou DAC.CIRCULAR.

Exemplo usando ambos os DACs ao mesmo tempo:

dac1 = DAC(1)
dac2 = DAC(2)
dac1.write_timed(buf1, pyb.Timer(6, freq=100), mode=DAC.CIRCULAR)
dac2.write_timed(buf2, pyb.Timer(7, freq=200), mode=DAC.CIRCULAR)

Constantes¶

NORMAL: int¶: O modo NORMAL faz uma única transmissão da forma de onda no buffer de dados.

CIRCULAR: int¶: O modo CIRCULAR transmite a forma de onda no buffer de dados e retorna ao início do buffer toda vez que chega ao fim, produzindo um loop contínuo até que deinit() seja chamado.