class ADC – המרה מאנלוגי לדיגיטלי

שימוש:

import pyb

adc = pyb.ADC("P6")
val = adc.read()

ראו pyb.ADCAll לגישה בו-זמנית לכל ערוצי ה-ADC וכן לחיישני טמפרטורת השבב הפנימיים של ה-MCU, VBAT ו-VREFINT.

בנאים

class pyb.ADC(pin: int | str | Pin)

יצירת אובייקט ADC המשויך לפין הנתון. הדבר מאפשר לכם לאחר מכן לקרוא ערכים אנלוגיים על אותו פין.

מתודות

read() → int

קריאת הערך על הפין האנלוגי והחזרתו. הערך המוחזר יהיה בין 0 ל-4095.

read_timed(buf: bytearray | 'array.array', timer: Timer | int) → int

קריאת ערכים אנלוגיים אל תוך buf בקצב שנקבע על ידי אובייקט ה-timer.

buf יכול להיות bytearray או array.array, לדוגמה. לערכי ה-ADC יש רזולוציה של 12 ביט והם נשמרים ישירות אל תוך buf אם גודל האיבר שלו הוא 16 ביט או יותר. אם ל-buf יש איברים בני 8 ביט בלבד (למשל bytearray), אזי רזולוציית הדגימה תוקטן ל-8 ביט.

timer צריך להיות אובייקט Timer, ודגימה נקראת בכל פעם שהטיימר מופעל. הטיימר חייב להיות כבר מאותחל ופועל בתדר הדגימה הרצוי.

כדי לתמוך בהתנהגות הקודמת של פונקציה זו, timer יכול להיות גם מספר שלם המציין את התדר (ב-Hz) שבו לדגום. במקרה זה Timer(6) יוגדר אוטומטית לפעול בתדר הנתון.

דוגמה באמצעות אובייקט Timer (הדרך המועדפת):

adc = pyb.ADC(pyb.Pin.board.P6)    # create an ADC on pin P6
tim = pyb.Timer(6, freq=10)        # create a timer running at 10Hz
buf = bytearray(100)               # buffer to hold the samples
adc.read_timed(buf, tim)           # sample 100 values, taking 10s

דוגמה באמצעות מספר שלם עבור התדר:

adc = pyb.ADC(pyb.Pin.board.P6)    # create an ADC on pin P6
buf = bytearray(100)               # buffer of 100 bytes
adc.read_timed(buf, 10)            # read 100 samples at 10Hz (10s total)

for val in buf:
    print(val)

פונקציה זו אינה מקצה זיכרון heap כלשהו. יש לה התנהגות חוסמת: היא אינה חוזרת לתוכנית הקוראת עד שהחוצץ (buffer) מתמלא.

static read_timed_multi(adcs: Tuple[ADC, ...], bufs: Tuple[bytearray | 'array.array', ...], timer: Timer) → bool

חילוץ נתוני תזמון יחסי או נתוני פאזה ממספר ADC-ים.

קריאת ערכים אנלוגיים ממספר ADC-ים אל תוך חוצצים (buffers) בקצב שנקבע על ידי אובייקט ה-timer. בכל פעם שהטיימר מופעל, נקראת במהירות דגימה מכל ADC בתורו.

מופעי ADC ומופעי חוצץ (buffer) מועברים בטאפלים כאשר לכל ADC משויך חוצץ. כל החוצצים חייבים להיות מאותו טיפוס ואורך, ומספר החוצצים חייב להיות שווה למספר ה-ADC-ים.

חוצצים (buffers) יכולים להיות bytearray או array.array, לדוגמה. לערכי ה-ADC יש רזולוציה של 12 ביט והם נשמרים ישירות אל תוך החוצץ אם גודל האיבר שלו הוא 16 ביט או יותר. אם לחוצצים יש איברים בני 8 ביט בלבד (למשל bytearray), אזי רזולוציית הדגימה תוקטן ל-8 ביט.

timer חייב להיות אובייקט Timer. הטיימר חייב להיות כבר מאותחל ופועל בתדר הדגימה הרצוי.

מצלמות OpenMV Cam מבוססות STM32 חושפות רק פין כותרת אחד בעל יכולת ADC (P6), ולכן בחומרה הסטנדרטית read_timed_multi שימושית רק עם ADC יחיד. חברו כניסות אנלוגיות נוספות באמצעות הפניות cpu של pyb.Pin כדי להשתמש בה עם יותר מ-ADC אחד.

דוגמה לקריאת ADC יחיד:

import array

adc = pyb.ADC(pyb.Pin.board.P6)
tim = pyb.Timer(8, freq=100)
rx = array.array("H", (0 for i in range(100)))

# Sample 100 values at 100Hz (takes one second).
pyb.ADC.read_timed_multi((adc,), (rx,), tim)

for val in rx:
    print(val)

פונקציה זו אינה מקצה זיכרון heap כלשהו. יש לה התנהגות חוסמת: היא אינה חוזרת לתוכנית הקוראת עד שהחוצצים (buffers) מתמלאים.

הפונקציה מחזירה True אם כל הדגימות נרכשו בתזמון נכון. בקצבי דגימה גבוהים, הזמן הנדרש לרכישת קבוצת דגימות עלול לחרוג מתקופת הטיימר. במקרה זה הפונקציה מחזירה False, מה שמצביע על אובדן דיוק במרווח הדגימה. במקרים קיצוניים דגימות עלולות להיות מוחמצות.

הקצב המרבי תלוי בגורמים הכוללים את רוחב הנתונים ומספר ה-ADC-ים הנקראים. בבדיקות, שני ADC-ים נדגמו בקצב טיימר של 210kHz ללא חריגה. דגימות הוחמצו ב-215kHz. עבור שלושה ADC-ים הגבול הוא סביב 140kHz, ועבור ארבעה הוא סביב 110kHz. בקצבי דגימה גבוהים, השבתת פסיקות למשך התהליך יכולה להפחית את הסיכון לאובדן נתונים ספורדי.