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#

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