klass DAC – digital-till-analog-omvandling¶

DAC:n matar ut analoga spänningar mellan 0 V och 3,3 V på en av två STM32 DAC-kanaler.

På varje STM32-baserad OpenMV Cam som exponerar pyb.DAC (M4 / M7 / H7 / H7 Plus / Pure Thermal) är kanalerna kopplade enligt följande:

DAC-kanal	Stift på kontakt	STM32-stift
`DAC(1)`	(ej på kontakten)	`PA4`
`DAC(2)`	`P6`	`PA5`

OpenMV Cam N6 har ingen DAC-kringutrustning; pyb.DAC är inte tillgänglig på det kortet.

Exempel på användning:

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

För att mata ut en kontinuerlig sinusvåg:

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)

För att mata ut en kontinuerlig sinusvåg med 12-bitars upplösning:

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)

Konstruktorer¶

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

Skapa ett nytt DAC-objekt.

port kan vara ett Pin-objekt, eller ett heltal (1 eller 2) som väljer DAC-kanal 1 eller 2. Vilket fysiskt stift varje kanal dras till beror på OpenMV Cam.

bits är ett heltal som anger upplösningen, och kan vara 8 eller 12. Det maximala värdet som accepteras av write() och write_timed() är (2**bits) - 1 (255 för 8-bitars, 4095 för 12-bitars).

Parametern buffering väljer beteendet för DAC:ns op-amp-utgångsbuffert, vars syfte är att minska utgångsimpedansen. Den kan vara None för att välja standardvärdet (buffring aktiverad för DAC.noise(), DAC.triangle() och DAC.write_timed(), och inaktiverad för DAC.write()), False för att inaktivera buffring helt, eller True för att aktivera utgångsbuffring.

När buffring är aktiverad kan DAC-stiftet driva laster ända ner till 5 KΩ. Annars har det en maximal utgångsimpedans på 15 KΩ: följaktligen krävs för att uppnå 1 % noggrannhet utan buffring att den anslutna lasten är mindre än 1,5 MΩ. Att använda bufferten medför en noggrannhetsförlust, särskilt nära ändarna av området.

Metoder¶

init(bits: int = 8, *, buffering: bool | None = None) → None¶: Återinitiera DAC:n. bits kan vara 8 eller 12. buffering kan vara None, False eller True; se konstruktorn ovan för innebörden av denna parameter.

deinit() → None¶: Avinitiera DAC:n så att dess stift blir tillgängligt för annan användning.

noise(freq: int) → None¶: Generera en pseudoslumpmässig brussignal. Ett nytt slumpmässigt sampel skrivs till DAC-utgången med den angivna frekvensen.

triangle(freq: int) → None¶: Generera en triangelvåg. Värdet på DAC-utgången ändras med den angivna frekvensen och rampar genom hela det 12-bitars området (upp och ner). Därför är frekvensen för själva den upprepande triangelvågen 8192 gånger lägre.

write(value: int) → None¶: Direktåtkomst till DAC-utgången. Minimivärdet är 0; maximum är (2**bits) - 1, där bits ställs in när DAC-objektet skapas eller via init().

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

Initierar en skur av RAM-till-DAC med en DMA-överföring. Indatan behandlas som en array av bytes i 8-bitarsläge, och en array av osignerade halvord (array-typkod ’H’) i 12-bitarsläge.

freq kan vara ett heltal som anger frekvensen att skriva DAC-samplen med, med Timer(6). Eller det kan vara ett redan initierat Timer-objekt som används för att utlösa DAC-samplet. Giltiga timrar är 2, 4, 5, 6, 7 och 8.

mode kan vara DAC.NORMAL eller DAC.CIRCULAR.

Exempel där båda DAC:erna används samtidigt:

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)

Konstanter¶

NORMAL: int¶: NORMAL-läget gör en enstaka sändning av vågformen i databufferten.

CIRCULAR: int¶: CIRCULAR-läget sänder vågformen i databufferten och börjar om från bufferten varje gång det når slutet, vilket ger en kontinuerlig loop tills deinit() anropas.