class DAC – digitaal-naar-analoog-conversie¶

De DAC geeft analoge spanningen tussen 0 V en 3,3 V uit op een van de twee STM32 DAC-kanalen.

Op elke STM32 OpenMV Cam die pyb.DAC beschikbaar stelt (M4 / M7 / H7 / H7 Plus / Pure Thermal) zijn de kanalen als volgt bedraad:

DAC-kanaal	Header-pin	STM32-pin
`DAC(1)`	(niet op header)	`PA4`
`DAC(2)`	`P6`	`PA5`

De OpenMV Cam N6 heeft geen DAC-randapparaat; pyb.DAC is niet beschikbaar op dat board.

Voorbeeldgebruik:

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

Om een continue sinusgolf uit te voeren:

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)

Om een continue sinusgolf met 12-bits resolutie uit te voeren:

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)

Constructors¶

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

Construeer een nieuw DAC-object.

port kan een Pin-object zijn, of een geheel getal (1 of 2) dat DAC-kanaal 1 of 2 selecteert. Naar welke fysieke pin elk kanaal wordt gerouteerd hangt af van de OpenMV Cam.

bits is een geheel getal dat de resolutie aangeeft en kan 8 of 12 zijn. De maximale waarde die door write() en write_timed() wordt geaccepteerd is (2**bits) - 1 (255 voor 8-bits, 4095 voor 12-bits).

De parameter buffering selecteert het gedrag van de uitgangsbuffer van de DAC-opamp, die als doel heeft de uitgangsimpedantie te verlagen. Het kan None zijn om de standaard te selecteren (buffering ingeschakeld voor DAC.noise(), DAC.triangle() en DAC.write_timed(), en uitgeschakeld voor DAC.write()), False om buffering volledig uit te schakelen, of True om uitgangsbuffering in te schakelen.

Wanneer buffering is ingeschakeld kan de DAC-pin lasten tot 5KΩ aansturen. Anders heeft hij een uitgangsimpedantie van maximaal 15KΩ: om zonder buffering een nauwkeurigheid van 1% te bereiken, moet de aangelegde last bijgevolg kleiner zijn dan 1,5MΩ. Het gebruik van de buffer gaat ten koste van nauwkeurigheid, vooral nabij de uiteinden van het bereik.

Methods¶

init(bits: int = 8, *, buffering: bool | None = None) → None¶: Herinitialiseer de DAC. bits kan 8 of 12 zijn. buffering kan None, False of True zijn; zie de bovenstaande constructor voor de betekenis van deze parameter.

deinit() → None¶: Deïnitialiseer de DAC zodat de pin beschikbaar komt voor ander gebruik.

noise(freq: int) → None¶: Genereer een pseudowillekeurig ruissignaal. Op de gegeven frequentie wordt een nieuw willekeurig sample naar de DAC-uitgang geschreven.

triangle(freq: int) → None¶: Genereer een driehoeksgolf. De waarde op de DAC-uitgang verandert op de gegeven frequentie en doorloopt het volledige 12-bits bereik (omhoog en omlaag). De frequentie van de herhalende driehoeksgolf zelf is daarom 8192 keer kleiner.

write(value: int) → None¶: Directe toegang tot de DAC-uitgang. De minimumwaarde is 0; het maximum is (2**bits) - 1, waarbij bits wordt ingesteld bij het aanmaken van het DAC-object of via init().

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

Start een burst van RAM naar DAC met behulp van een DMA-overdracht. De invoerdata wordt in 8-bits modus behandeld als een array van bytes en in 12-bits modus als een array van unsigned halfwords (array-typecode ‘H’).

freq kan een geheel getal zijn dat de frequentie aangeeft waarmee de DAC-samples worden geschreven, met behulp van Timer(6). Of het kan een al geïnitialiseerd Timer-object zijn dat wordt gebruikt om het DAC-sample te triggeren. Geldige timers zijn 2, 4, 5, 6, 7 en 8.

mode kan DAC.NORMAL of DAC.CIRCULAR zijn.

Voorbeeld waarbij beide DAC’s tegelijkertijd worden gebruikt:

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)

Constants¶

NORMAL: int¶: In de modus NORMAL wordt de golfvorm in de databuffer eenmaal verzonden.

CIRCULAR: int¶: In de modus CIRCULAR wordt de golfvorm in de databuffer verzonden en wordt telkens bij het bereiken van het einde naar het begin van de buffer teruggesprongen, waardoor een continue lus ontstaat totdat deinit() wordt aangeroepen.