clasa DAC – conversie digital-analogică¶

DAC-ul generează tensiuni analogice între 0 V și 3,3 V pe unul dintre cele două canale DAC ale STM32.

Pe fiecare OpenMV Cam bazat pe STM32 care expune pyb.DAC (M4 / M7 / H7 / H7 Plus / Pure Thermal), canalele sunt conectate astfel:

Canal DAC	Pin header	Pin STM32
`DAC(1)`	(nu este pe header)	`PA4`
`DAC(2)`	`P6`	`PA5`

OpenMV Cam N6 nu are un periferic DAC; pyb.DAC nu este disponibil pe această placă.

Exemplu de utilizare:

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

Pentru a genera o undă sinusoidală continuă:

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)

Pentru a genera o undă sinusoidală continuă la rezoluție de 12 biți:

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)

Constructori¶

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

Construiește un nou obiect DAC.

port poate fi un obiect Pin sau un întreg (1 sau 2) care selectează canalul DAC 1 sau 2. Pinul fizic la care este direcționat fiecare canal depinde de OpenMV Cam.

bits este un întreg care specifică rezoluția și poate fi 8 sau 12. Valoarea maximă acceptată de write() și write_timed() este (2**bits) - 1 (255 pentru 8 biți, 4095 pentru 12 biți).

Parametrul buffering selectează comportamentul tamponului (buffer) de ieșire al amplificatorului operațional al DAC-ului, al cărui scop este reducerea impedanței de ieșire. Poate fi None pentru a selecta valoarea implicită (tamponare activată pentru DAC.noise(), DAC.triangle() și DAC.write_timed(), și dezactivată pentru DAC.write()), False pentru a dezactiva complet tamponarea sau True pentru a activa tamponarea ieșirii.

Când tamponarea este activată, pinul DAC poate alimenta sarcini de până la 5KΩ. În caz contrar, are o impedanță de ieșire de maximum 15KΩ: în consecință, pentru a obține o precizie de 1% fără tamponare, sarcina aplicată trebuie să fie mai mică de 1,5MΩ. Utilizarea tamponului implică o penalizare a preciziei, în special în apropierea extremelor intervalului.

Metode¶

init(bits: int = 8, *, buffering: bool | None = None) → None¶: Reinițializează DAC-ul. bits poate fi 8 sau 12. buffering poate fi None, False sau True; vezi constructorul de mai sus pentru semnificația acestui parametru.

deinit() → None¶: Dezinițializează DAC-ul, făcând pinul său disponibil pentru alte utilizări.

noise(freq: int) → None¶: Generează un semnal de zgomot pseudo-aleatoriu. La frecvența dată se scrie un nou eșantion aleatoriu la ieșirea DAC-ului.

triangle(freq: int) → None¶: Generează o undă triunghiulară. Valoarea de la ieșirea DAC-ului se modifică la frecvența dată și parcurge în rampă întregul interval de 12 biți (în sus și în jos). Prin urmare, frecvența undei triunghiulare repetate în sine este de 8192 de ori mai mică.

write(value: int) → None¶: Acces direct la ieșirea DAC-ului. Valoarea minimă este 0; maximul este (2**bits) - 1, unde bits este setat la crearea obiectului DAC sau prin init().

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

Inițiază un transfer în rafală din RAM către DAC folosind un transfer DMA. Datele de intrare sunt tratate ca un tablou de octeți în modul pe 8 biți și ca un tablou de jumătăți de cuvânt fără semn (codul de tip al tabloului «H») în modul pe 12 biți.

freq poate fi un întreg care specifică frecvența la care se scriu eșantioanele DAC, folosind Timer(6). Sau poate fi un obiect Timer deja inițializat, care este folosit pentru a declanșa eșantionul DAC. Temporizatoarele valide sunt 2, 4, 5, 6, 7 și 8.

mode poate fi DAC.NORMAL sau DAC.CIRCULAR.

Exemplu folosind ambele DAC-uri în același timp:

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)

Constante¶

NORMAL: int¶: Modul NORMAL realizează o singură transmisie a formei de undă din tamponul de date.

CIRCULAR: int¶: Modul CIRCULAR transmite forma de undă din tamponul de date și se reia de la începutul tamponului de fiecare dată când ajunge la sfârșit, producând o buclă continuă până la apelarea metodei deinit().