class Timer – שליטה בטיימרים פנימיים

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

כל טיימר מורכב ממונה הסופר כלפי מעלה בקצב מסוים. הקצב שבו הוא סופר הוא תדר שעון ההתקן ההיקפי (ב-Hz) חלקי ה-prescaler של הטיימר. כאשר המונה מגיע למחזור הטיימר הוא מפעיל אירוע, והמונה מתאפס בחזרה לאפס. באמצעות המתודה callback, אירוע הטיימר יכול לקרוא לפונקציית Python.

דוגמת שימוש להחלפת מצב של LED בתדר קבוע:

tim = pyb.Timer(4)              # create a timer object using timer 4
tim.init(freq=2)                # trigger at 2Hz
tim.callback(lambda t:pyb.LED(1).toggle())

דוגמה לשימוש בפונקציה בעלת שם עבור ה-callback:

def tick(timer):                # we will receive the timer object when being called
    print(timer.counter())      # show current timer's counter value
tim = pyb.Timer(4, freq=1)      # create a timer object using timer 4 - trigger at 1Hz
tim.callback(tick)              # set the callback to our tick function

דוגמאות נוספות:

tim = pyb.Timer(4, freq=100)    # freq in Hz
tim = pyb.Timer(4, prescaler=0, period=99)
tim.counter()                   # get counter (can also set)
tim.prescaler(2)                # set prescaler (can also get)
tim.period(199)                 # set period (can also get)
tim.callback(lambda t: ...)     # set callback for update interrupt (t=tim instance)
tim.callback(None)              # clear callback

הערה: Timer(1) משמש עבור המצלמה. באופן דומה, Timer(5) שולט במנוע השרבו, ו-Timer(6) משמש לקריאה/כתיבה מתוזמנת של ADC/DAC. מומלץ להשתמש בטיימרים האחרים בתוכניות שלכם.

הערה: לא ניתן להקצות זיכרון במהלך callback (פסיקה), ולכן חריגות שמועלות בתוך callback אינן מספקות מידע רב. ראו micropython.alloc_emergency_exception_buf() כיצד לעקוף מגבלה זו.

Constructors

class pyb.Timer(id: int, *args, **kwargs)

בונה אובייקט טיימר חדש עם המזהה הנתון. אם מסופקים ארגומנטים נוספים, הטיימר מאותחל באמצעות init(...). קבוצת ערכי ה-id התקפים תלויה ב-MCU מסוג STM32 שב-OpenMV Cam הנמצא בשימוש; עיינו במדריך העזר של STM32 עבור הטיימרים הזמינים לשימוש כללי ולבקרה מתקדמת.

Methods

init(*, freq: int | float | None = None, prescaler: int | None = None, period: int | None = None, mode: int = Timer.UP, div: int = 1, callback: Callable[[Timer], None] | None = None, deadtime: int = 0, brk: int = Timer.BRK_OFF, hard: bool = True) → None

מאתחל את הטיימר. האתחול חייב להתבצע או באמצעות תדר (ב-Hz) או באמצעות prescaler ומחזור:

tim.init(freq=100)                  # set the timer to trigger at 100Hz
tim.init(prescaler=83, period=999)  # set the prescaler and period directly

ארגומנטים של מילות מפתח:

• freq — מציין את התדר המחזורי של הטיימר. ניתן גם להתייחס לכך כאל התדר שבו הטיימר עובר מחזור שלם אחד.

• prescaler [0-0xffff] - מציין את הערך שייטען לאוגר ה-Prescaler של הטיימר (PSC). מקור שעון הטיימר מחולק ב-(prescaler + 1) כדי לגזור את שעון הטיימר. מקור השעון מגיע מאפיק ה-APB של הטיימר ותלוי ב-MCU. ב-STM32, טיימרים על APB1 משתעים בדרך כלל ב-2 * pclk1 וטיימרים על APB2 ב-2 * pclk2; קראו את תדרי האפיק הנוכחיים באמצעות pyb.freq() ועיינו במדריך העזר של STM32 עבור ה-MCU של ה-OpenMV Cam שלכם.

• period [0-0xffff] עבור טיימרים 1, 3, 4 ו-6-15. [0-0x3fffffff] עבור טיימרים 2 ו-5. מציין את הערך שייטען לאוגר ה-AutoReload של הטיימר (ARR). זה קובע את מחזור הטיימר (כלומר מתי המונה משלים מחזור). מונה הטיימר יתגלגל לאחר period + 1 מחזורי שעון טיימר.

• mode יכול להיות אחד מהבאים:

  • Timer.UP - מגדיר את הטיימר לספור מ-0 עד ARR (ברירת מחדל)

  • Timer.DOWN - מגדיר את הטיימר לספור מ-ARR כלפי מטה עד 0.

  • Timer.CENTER - מגדיר את הטיימר לספור מ-0 עד ARR ואז בחזרה כלפי מטה עד 0.

• div יכול להיות 1, 2 או 4. מחלק את שעון הטיימר כדי לקבוע את שעון הדגימה המשמש את המסננים הדיגיטליים.

• callback - כמו ב-Timer.callback()

• deadtime - מציין את משך הזמן ה“מת“ או הלא-פעיל בין מעברים בערוצים משלימים (שני הערוצים יהיו לא-פעילים במשך זמן זה). deadtime יכול להיות מספר שלם בין 0 ל-1008, עם ההגבלות הבאות: 0-128 בצעדים של 1. 128-256 בצעדים של 2, 256-512 בצעדים של 8, ו-512-1008 בצעדים של 16. deadtime מודד טיקים של source_freq חלקי div טיקי שעון. deadtime זמין רק בטיימרים 1 ו-8.

• brk - מציין אם מצב ה-break משמש להשבתת הפלט של ה-PWM כאשר קלט ה-BRK_IN מופעל. ערך ארגומנט זה קובע אם break מופעל ומהי הקוטביות, ויכול להיות אחד מ-Timer.BRK_OFF, Timer.BRK_LOW או Timer.BRK_HIGH. כדי לבחור את הפין BRK_IN בנו אובייקט Pin עם mode=Pin.ALT, alt=Pin.AFn_TIMx. תכונות הקלט של ה-GPIO של הפין זמינות במצב alt - pull= , value() ו-irq().

• hard יכול להיות אחד מהבאים:

  • True - ה-callback יבוצע בהקשר של פסיקה קשיחה, מה שממזער את ההשהיה והרעד אך כפוף למגבלות המתוארות ב-כתיבת מטפלי פסיקה כולל חוסר היכולת להקצות בערימה.

  • False - ה-callback יתוזמן כפסיקה רכה, מה שמאפשר לו להקצות אך גם עשוי להכניס השהיות ורעד של איסוף אשפה.

  ערך ברירת המחדל של אפשרות זו הוא True.

עליכם לציין או freq או גם period וגם prescaler.

deinit() → None

מבטל את אתחול הטיימר.

משבית את ה-callback (ואת ה-irq המשויך).

משבית את כל ה-callbacks של הערוצים (ואת ה-irq המשויך). עוצר את הטיימר ומשבית את ההתקן ההיקפי של הטיימר.

callback(fun: Callable[[Timer], None] | None) → None

מגדיר את הפונקציה שתיקרא כאשר הטיימר מופעל. ל-fun מועבר ארגומנט אחד, אובייקט הטיימר. אם fun הוא None אז ה-callback יושבת.

channel(channel: int, mode: int | None = None, *args, **kwargs) → TimerChannel | None

אם מועבר רק מספר ערוץ, אז מוחזר אובייקט ערוץ שאותחל קודם לכן (או None אם אין ערוץ קודם).

אחרת, אובייקט TimerChannel מאותחל ומוחזר.

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

ארגומנטים של מילות מפתח:

• mode יכול להיות אחד מהבאים:

  • Timer.PWM — מגדיר את הטיימר במצב PWM (פעיל גבוה).

  • Timer.PWM_INVERTED — מגדיר את הטיימר במצב PWM (פעיל נמוך).

  • Timer.OC_TIMING — מציין שאף פין אינו מונע.

  • Timer.OC_ACTIVE — הפין יהפוך לפעיל כאשר מתרחשת התאמת השוואה (פעיל נקבע לפי הקוטביות)

  • Timer.OC_INACTIVE — הפין יהפוך ללא-פעיל כאשר מתרחשת התאמת השוואה.

  • Timer.OC_TOGGLE — מצב הפין יוחלף כאשר מתרחשת התאמת השוואה.

  • Timer.OC_FORCED_ACTIVE — הפין נכפה לפעיל (התאמת ההשוואה מתעלמת).

  • Timer.OC_FORCED_INACTIVE — הפין נכפה ללא-פעיל (התאמת ההשוואה מתעלמת).

  • Timer.IC — מגדיר את הטיימר במצב לכידת קלט (Input Capture).

  • Timer.ENC_A — מגדיר את הטיימר במצב Encoder. המונה משתנה רק כאשר CH1 משתנה.

  • Timer.ENC_B — מגדיר את הטיימר במצב Encoder. המונה משתנה רק כאשר CH2 משתנה.

  • Timer.ENC_AB — מגדיר את הטיימר במצב Encoder. המונה משתנה כאשר CH1 או CH2 משתנים.

• callback - כמו ב-TimerChannel.callback()

• pin None (ברירת המחדל) או אובייקט Pin. אם צוין (ואינו None) זה יגרום לתצורת הפונקציה החלופית של הפין המצוין עבור ערוץ טיימר זה. תועלה שגיאה אם הפין אינו תומך בפונקציות חלופיות כלשהן עבור ערוץ טיימר זה.

ארגומנטים של מילות מפתח עבור מצבי Timer.PWM:

• pulse_width - קובע את ערך רוחב הפולס ההתחלתי לשימוש.

• pulse_width_percent - קובע את אחוז רוחב הפולס ההתחלתי לשימוש.

ארגומנטים של מילות מפתח עבור מצבי Timer.OC:

• compare - קובע את הערך ההתחלתי של אוגר ההשוואה.

• polarity יכול להיות אחד מהבאים:

  • Timer.HIGH - הפלט פעיל גבוה

  • Timer.LOW - הפלט פעיל נמוך

ארגומנטים אופציונליים של מילות מפתח עבור מצבי Timer.IC:

• polarity יכול להיות אחד מהבאים:

  • Timer.RISING - לוכד בקצה עולה.

  • Timer.FALLING - לוכד בקצה יורד.

  • Timer.BOTH - לוכד בשני הקצוות.

שימו לב שלכידה עובדת רק בערוץ הראשי, ולא בערוצים המשלימים.

הערות עבור מצבי Timer.ENC:

• דורש 2 פינים, ולכן אחד מהפינים או שניהם יצטרכו להיות מוגדרים לשימוש ב-AF המתאים של הטיימר באמצעות Pin API.

• קראו את ערך ה-encoder באמצעות המתודה timer.counter().

• עובד רק על CH1 ו-CH2 (ולא על CH1N או CH2N)

• מספר הערוץ מתעלם בעת הגדרת מצב ה-encoder.

דוגמת PWM – בכל OpenMV Cam מסוג STM32 הערוצים 1 ו-2 של TIM4 מנותבים לפיני הכותרת P7 ו-P8 בהתאמה:

timer = pyb.Timer(4, freq=1000)
ch1 = timer.channel(1, pyb.Timer.PWM, pin=pyb.Pin.board.P7,
                    pulse_width=8000)
ch2 = timer.channel(2, pyb.Timer.PWM, pin=pyb.Pin.board.P8,
                    pulse_width=16000)

counter(value: int | None = None) → int | None

קבל או הגדר את מונה הטיימר.

freq(value: int | float | None = None) → int | float | None

קבל או הגדר את התדר עבור הטיימר (משנה את ה-prescaler ואת המחזור אם מוגדר).

period(value: int | None = None) → int | None

קבל או הגדר את מחזור הטיימר.

prescaler(value: int | None = None) → int | None

קבל או הגדר את ה-prescaler עבור הטיימר.

source_freq() → int

קבל את התדר של מקור הטיימר.

Constants

קבועי מצב-מונה (ארגומנט mode של init()):

UP: int

ספור מ-0 כלפי מעלה עד ARR (מצב ברירת המחדל).

DOWN: int

ספור מ-ARR כלפי מטה עד 0.

CENTER: int

ספור מ-0 כלפי מעלה עד ARR ואז בחזרה כלפי מטה עד 0.

קבועי מצב-break (ארגומנט brk של init()):

BRK_OFF: int

קלט ה-break מושבת.

BRK_LOW: int

קלט ה-break פעיל-נמוך.

BRK_HIGH: int

קלט ה-break פעיל-גבוה.

קבועי מצב-ערוץ (ארגומנט mode של channel()):

PWM: int

הגדר את הערוץ לפלט PWM (פעיל גבוה).

PWM_INVERTED: int

הגדר את הערוץ לפלט PWM (פעיל נמוך).

OC_TIMING: int

מצב תזמון השוואת-פלט; אף פין אינו מונע.

OC_ACTIVE: int

מצב פעיל של השוואת-פלט; הפין הופך לפעיל בהתאמת השוואה.

OC_INACTIVE: int

מצב לא-פעיל של השוואת-פלט; הפין הופך ללא-פעיל בהתאמת השוואה.

OC_TOGGLE: int

מצב החלפה של השוואת-פלט; מצב הפין מתחלף בהתאמת השוואה.

OC_FORCED_ACTIVE: int

מצב פעיל-כפוי של השוואת-פלט; הפין נכפה לפעיל והתאמת ההשוואה מתעלמת.

OC_FORCED_INACTIVE: int

מצב לא-פעיל-כפוי של השוואת-פלט; הפין נכפה ללא-פעיל והתאמת ההשוואה מתעלמת.

IC: int

הגדר את הערוץ למצב לכידת-קלט.

ENC_A: int

מצב Encoder: המונה משתנה רק כאשר CH1 משתנה.

ENC_B: int

מצב Encoder: המונה משתנה רק כאשר CH2 משתנה.

ENC_AB: int

מצב Encoder: המונה משתנה בכל פעם ש-CH1 או CH2 משתנים.

קוטביות השוואת-פלט (ארגומנט polarity של channel() במצבי OC):

HIGH: int

הפלט פעיל-גבוה.

LOW: int

הפלט פעיל-נמוך.

קוטביות לכידת-קלט (ארגומנט polarity של channel() במצב IC):

RISING: int

לכוד בקצה העולה.

FALLING: int

לכוד בקצה היורד.

BOTH: int

לכוד בכל אחד מהקצוות.