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

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

הטקסט שוב ​​התברר כעצום, אז מטעמי נוחות אני מכין את התוכן:

STM32 Blue Pill: 16 נוריות LED עם דרייבר DM634
STM8: הגדרת שישה פינים PWM
STM8: 8 נוריות RGB על שלושה פינים, מפריעים

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

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

אני מקווה שהמאמר שלי יעזור למישהו בשלב דומה של התעמקות בתחביב.

STM32

16 נוריות LED עם DM634 ו-SPI

פרויקט קטן באמצעות כדור כחול (STM32F103C8T6) ומנהל התקן LED DM634. באמצעות גליונות נתונים, נבין את מנהל ההתקן, יציאות STM IO ונקבע את ההגדרה של SPI.

DM634

שבב טייוואני עם 16 יציאות PWM 16 סיביות, ניתן לחבר בשרשראות. דגם ה-12 סיביות הנמוך מוכר מפרויקט מקומי Lightpack. בשלב מסוים, בבחירה בין ה-DM63x לבין ה-TLC5940 הידוע, בחרתי ב-DM מכמה סיבות: 1) TLC ב-Aliexpress הוא בהחלט מזויף, אבל זה לא; 2) ל-DM יש PWM אוטונומי עם מחולל תדרים משלו; 3) אפשר לקנות אותו בזול במוסקבה, במקום לחכות לחבילה מאלי. וכמובן, היה מעניין ללמוד כיצד לשלוט בשבב בעצמך, במקום להשתמש בספרייה מוכנה. השבבים מוצגים כעת בעיקר בחבילת SSOP24; קל להלחים אותם למתאם.

מכיוון שהיצרן הוא טייוואני, טופס מידע השבב כתוב באנגלית סינית, מה שאומר שיהיה כיף. ראשית אנו מסתכלים על פינאאוט (חיבור פינים) כדי להבין לאיזו רגל לחבר למה, ותיאור של הפינים (תיאור סיכה). 16 סיכות:

מקורות כיור DC (פתח ניקוז)

כִּיוֹר / פלט ניקוז פתוח - לנקז; מקור הזרם הנכנס; הפלט מחובר לאדמה במצב פעיל - הנוריות מחוברות לדרייבר באמצעות קתודות. מבחינה חשמלית, זה, כמובן, לא "ניקוז פתוח" (ניקוז פתוח), אך בגיליונות נתונים ייעוד זה עבור פינים במצב ניקוז נמצא לעתים קרובות.

נגדים חיצוניים בין REXT ל-GND כדי לקבוע את ערך זרם הפלט

בין פין REXT לאדמה מותקן נגד ייחוס, השולט בהתנגדות הפנימית של היציאות, ראה הגרף בעמוד 9 של גיליון הנתונים. ב-DM634, ניתן לשלוט בהתנגדות זו גם באמצעות תוכנה, להגדיר את הבהירות הכוללת (בהירות עולמית); אני לא אכנס לפרטים במאמר זה, אני רק אשים כאן נגד של 2.2 - 3 קילו אוהם.

כדי להבין כיצד לשלוט בשבב, הבה נסתכל על התיאור של ממשק המכשיר:

כן, הנה, אנגלית סינית במלוא תפארתה. תרגום זה בעייתי, אתה יכול להבין את זה אם תרצה, אבל יש דרך אחרת - תראה איך מתואר החיבור ל-TLC5940 הדומה מבחינה פונקציונלית בגיליון הנתונים:

... נדרשים רק שלושה פינים כדי להזין נתונים למכשיר. הקצה העולה של אות SCLK מעביר את הנתונים מפין ה-SIN לאגר הפנימי. לאחר טעינת כל הנתונים, אות XLAT קצר גבוה תופס את הנתונים המועברים ברצף לתוך האוגרים הפנימיים. אוגרים פנימיים הם שערים המופעלים על ידי רמת האות XLAT. כל הנתונים מועברים תחילה הסיבית המשמעותית ביותר.

בְּרִיחַ – תפס/בריח/נעילה.
קצה עולה - קצה מוביל של הדופק
MSB ראשון – הכי משמעותי (הכי שמאלי) קצת קדימה.
לשעון נתונים - העברת נתונים ברצף (ביט אחר ביט).

מלה בְּרִיחַ נמצא לעתים קרובות בתיעוד לצ'יפים ומתורגם בדרכים שונות, אז למען ההבנה ארשה לעצמי

תוכנית חינוכית קטנהמנהל ה-LED הוא בעצם אוגר משמרות. "Shift" (משמרת) בשם - תנועה סיבית של נתונים בתוך המכשיר: כל ביט חדש שנדחף פנימה דוחף את כל השרשרת קדימה לפניו. מכיוון שאף אחד לא רוצה לראות הבהוב כאוטי של נוריות הלד במהלך המשמרת, התהליך מתרחש באוגרי חיץ המופרדים מהאוגרים הפועלים על ידי מנחת (בְּרִיחַ) הוא מעין חדר המתנה שבו הביטים מסודרים ברצף הרצוי. כשהכל מוכן, התריס נפתח והביטים יוצאים לעבודה, מחליפים את האצווה הקודמת. מִלָה בְּרִיחַ בתיעוד עבור microcircuits כמעט תמיד מרמז על מנחת כזה, לא משנה באילו שילובים הוא משמש.

אז, העברת נתונים ל-DM634 מתבצעת כך: הגדר את קלט DAI לערך של הסיבית המשמעותית ביותר של ה-LED הרחוק, משוך DCK למעלה ולמטה; הגדר את קלט DAI לערך של הביט הבא, משוך DCK; וכן הלאה עד שכל הביטים שודרו (שעון פנימה), ולאחר מכן אנו מושכים LAT. ניתן לעשות זאת באופן ידני (ביט-באנג), אך עדיף להשתמש בממשק SPI המותאם במיוחד לכך, מכיוון שהוא מוצג ב- STM32 שלנו בשני עותקים.

גלולה כחולה STM32F103

מבוא: בקרי STM32 הם הרבה יותר מורכבים מ-Atmega328 ממה שהם עשויים להיראות מפחידים. יתרה מכך, מטעמי חיסכון באנרגיה, כמעט כל הציוד ההיקפי כב בהתחלה, ותדר השעון הוא 8 מגה-הרץ מהמקור הפנימי. למרבה המזל, מתכנתי STM כתבו קוד שמביא את השבב ל-72 מגה-הרץ ה"מחושבים", והמחברים של כל ה-IDEs שאני מכיר כללו אותו בהליך האתחול, אז אנחנו לא צריכים לבצע שעון (אבל אתה יכול אם אתה באמת רוצה). אבל תצטרך להפעיל את הציוד ההיקפי.

תיעוד: Blue Pill מצויד בשבב הפופולרי STM32F103C8T6, יש שני מסמכים שימושיים עבורו:

• גיליון נתונים עבור מיקרו-בקרים STM32F103x8 ו- STM32F103xB;
• מדריך עזר עבור כל קו STM32F103 ועוד.

בגיליון הנתונים אולי נתעניין ב:

• Pinouts – chip pinouts – למקרה שנחליט להכין את הלוחות בעצמנו;
• מפת זיכרון – מפת זיכרון לשבב ספציפי. במדריך העזר יש מפה לכל הקו, והוא מזכיר אוגרים שאין לנו.
• טבלת הגדרות פינים - פירוט הפונקציות העיקריות והחלופיות של פינים; עבור "הגלולה הכחולה" אתה יכול למצוא תמונות נוחות יותר באינטרנט עם רשימה של סיכות ופונקציות שלהן. לכן, אנו מיד מחפשים את ה-Pinout של Blue Pill ושומרים את התמונה הזו בהישג יד:

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

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

פלט קלט

ב-Atmega328, I/O מיושם בצורה פשוטה ביותר, וזו הסיבה ששפע האפשרויות של STM32 יכול להיות מבלבל. עכשיו אנחנו צריכים רק מסקנות, אבל אפילו לאלה יש ארבע אפשרויות:

ניקוז פתוח, דחיפה-משיכה, דחיפה-משיכה אלטרנטיבית, ניקוז פתוח חלופי

"משוך דחוף" (למשוך לדחוף) הוא הפלט הרגיל מהארדואינו, הסיכה יכולה לקבל את הערך HIGH או LOW. אבל עם "ניקוז פתוח" יש המורכבות, למרות שלמעשה הכל פשוט כאן:

תצורת פלט / כאשר היציאה מוקצית לפלט: / מאגר פלט מופעל: / – מצב ניקוז פתוח: "0" באוגר הפלט מאפשר N-MOS, "1" באוגר הפלט עוזב את היציאה במצב Hi-Z ( P-MOS אינו מופעל ) / – מצב דחיפה-משיכה: "0" באוגר הפלט מפעיל את N-MOS, "1" באוגר הפלט מפעיל את P-MOS.

כל ההבדל בין ניקוז פתוח (ניקוז פתוח) מ-"push-pull" (למשוך לדחוף) הוא שבפין הראשון לא יכול לקבל את המצב HIGH: כאשר כותבים אחד לאוגר הפלט, הוא עובר למצב התנגדות גבוהה (עכבה גבוהה, היי-ז). כשכותבים אפס, הסיכה מתנהגת זהה בשני המצבים, גם מבחינה לוגית וגם מבחינה חשמלית.

במצב פלט רגיל, הפין פשוט משדר את התוכן של אוגר הפלט. ב"חלופה" הוא נשלט על ידי הציוד ההיקפי המקביל (ראה 9.1.4):

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

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

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

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

אז: אנחנו משתמשים ב-SPI, מה שאומר ששני פינים (עם נתונים ועם אות שעון) צריכים להיות "פונקציית דחיפה-משיכה חלופית", ואחד אחר (LAT) צריך להיות "דחיפה-משיכה רגילה". אבל לפני שנקצה אותם, בואו נתמודד עם SPI.

SPI

עוד תוכנית חינוכית קטנה

SPI או Serial Peripheral Interface (ממשק היקפי טורי) הוא ממשק פשוט ויעיל מאוד לחיבור חבר כנסת עם חברי כנסת אחרים והעולם החיצון בכלל. עקרון פעולתו כבר תואר לעיל, היכן לגבי מנהל התקן LED הסיני (במדריך העזר, ראה סעיף 25). SPI יכול לפעול במצב מאסטר ("מאסטר") ועבד ("עבד"). ל-SPI יש ארבעה ערוצים בסיסיים, שלא בכולם ניתן להשתמש:

• MOSI, פלט מאסטר / כניסת עבדים: סיכה זו משדרת נתונים במצב מאסטר, ומקבלת נתונים במצב עבד;
• MISO, Master Input / Slave Output: להיפך, הוא מקבל במאסטר, ומשדר בעבד;
• SCK, Serial Clock: מגדיר את תדירות העברת הנתונים במאסטר או מקבל אות שעון בעבד. בעצם להכות מכות;
• SS, Slave Select: בעזרת הערוץ הזה העבד יודע שרוצים ממנו משהו. ב-STM32 זה נקרא NSS, כאשר N = שלילי, כלומר. הבקר הופך לעבד אם יש הארקה בערוץ הזה. זה משתלב היטב עם מצב ה-Open Drain Output, אבל זה כבר סיפור אחר.

כמו כל דבר אחר, SPI ב- STM32 עשיר בפונקציונליות, מה שמקשה במקצת על הבנתו. לדוגמה, זה יכול לעבוד לא רק עם SPI, אלא גם עם ממשק I2S, ובתיעוד התיאורים שלהם מעורבים, יש צורך לנתק את העודף בזמן. המשימה שלנו פשוטה ביותר: אנחנו רק צריכים לשלוח נתונים באמצעות MOSI ו- SCK בלבד. נעבור לסעיף 25.3.4 (תקשורת חצי דופלקס, תקשורת חצי דופלקס), שם אנו מוצאים שעון אחד וחוט נתונים חד-כיווני (אות שעון אחד וזרם נתונים חד-כיווני אחד):

במצב זה, האפליקציה משתמשת ב-SPI במצב שידור בלבד או קבלה בלבד. / מצב שידור בלבד דומה למצב דופלקס: נתונים מועברים על פין השידור (MOSI במצב מאסטר או MISO במצב עבד), ופין הקבלה (MISO או MOSI בהתאמה) יכול לשמש כסיכת I/O רגילה . במקרה זה, האפליקציה צריכה רק להתעלם ממאגר Rx (אם הוא נקרא, לא יהיו נתונים מועברים לשם).

מעולה, פין MISO פנוי, בואו נחבר אליו את אות ה-LAT. בואו נסתכל על Slave Select, שעל ה-STM32 ניתן לשלוט באופן תכנותי, וזה מאוד נוח. קראנו את הפסקה באותו שם בסעיף 25.3.1 SPI תיאור כללי:

בקרת תוכנה NSS (SSM = 1) / מידע בחירת עבדים כלול בסיבית SSI של האוגר SPI_CR1. סיכת ה-NSS החיצונית נשארת פנויה לצרכי יישומים אחרים.

זה הזמן לכתוב לפנקסים. החלטתי להשתמש ב-SPI2, חפש את כתובת הבסיס שלו בגיליון הנתונים - בסעיף 3.3 מפת זיכרון:

ובכן, בואו נתחיל:

#define _SPI2_(mem_offset) (*(volatile uint32_t *)(0x40003800 + (mem_offset)))

פתח את סעיף 25.3.3 עם הכותרת המסבירה את עצמה "הגדרת SPI במצב מאסטר":

1. הגדר את תדר השעון הטורי עם סיביות BR[2:0] באוגר SPI_CR1.

הרישומים נאספים בחלק המדריך לעיון באותו שם. שינוי כתובת (היסט כתובת) עבור CR1 – 0x00, כברירת מחדל כל הסיביות מנוקים (אפס ערך 0x0000):

סיביות BR מגדירים את מחלק השעון של הבקר, ובכך קובעים את התדר שבו ה-SPI יפעל. תדר STM32 שלנו יהיה 72 מגה-הרץ, דרייבר ה-LED, על פי גליון הנתונים שלו, פועל בתדר של עד 25 מגה-הרץ, ולכן עלינו לחלק בארבע (BR[2:0] = 001).

#define _SPI_CR1 0x00

#define BR_0        0x0008
#define BR_1        0x0010
#define BR_2        0x0020

_SPI2_ (_SPI_CR1) |= BR_0;// pclk/4

2. הגדר את סיביות ה-CPOL וה-CPHA כדי להגדיר את הקשר בין העברת נתונים ותזמון שעון טורי (ראה תרשים בעמוד 240)

מכיוון שאנו קוראים גיליון נתונים כאן ולא מסתכלים על סכמות, בואו נסתכל מקרוב על תיאור הטקסט של סיביות ה-CPOL וה-CPHA בעמוד 704 (תיאור כללי של SPI):

שלב השעון והקוטביות
באמצעות סיביות CPOL ו-CPHA של האוגר SPI_CR1, אתה יכול לבחור באופן תכנותי ארבעה קשרי תזמון. סיבית ה-CPOL (קוטביות שעון) שולטת במצב אות השעון כאשר לא מועברים נתונים. סיביות זו שולטת במצבי המאסטר והעבד. אם CPOL מאופס, סיכת SCK נמוכה במצב מנוחה. אם ביט ה-CPOL מוגדר, פין ה-SCK גבוה במצב מנוחה.
כאשר סיבית ה-CPHA (פאזת השעון) מוגדרת, מלכודת הסיביות הגבוהה היא הקצה השני של אות SCK (נופל אם CPOL ברור, עולה אם CPOL מוגדר). הנתונים נלכדים על ידי השינוי השני באות השעון. אם סיביות ה-CPHA ברורות, ה-High-Trap strobe הוא הקצה העולה של אות SCK (קצה נופל אם CPOL מוגדר, קצה עולה אם CPOL מסולק). הנתונים נקלטים בשינוי הראשון באות השעון.

לאחר שקלטנו את הידע הזה, אנחנו מגיעים למסקנה ששני הביטים חייבים להישאר אפסים, מכיוון אנו רוצים שאות SCK יישאר נמוך כאשר אינו בשימוש, ושהנתונים ישודרו בקצה העולה של הדופק (ראה איור. קצה עולה בגיליון הנתונים של DM634).

אגב, כאן נתקלנו לראשונה בתכונה של אוצר המילים בגיליונות הנתונים של ST: בהם נכתב הביטוי "אפס את הביט לאפס" להתאפס קצתולא לנקות קצת, כמו, למשל, Atmega.

3. הגדר את סיביות DFF כדי לקבוע אם בלוק הנתונים הוא בפורמט של 8 סיביות או 16 סיביות

לקחתי במיוחד DM16 של 634 סיביות כדי לא לטרוח בהעברת נתוני PWM של 12 סיביות, כמו ה-DM633. הגיוני להגדיר את DFF לאחד:

#define DFF         0x0800

_SPI2_ (_SPI_CR1) |= DFF; // 16-bit mode

4. הגדר את סיביות LSBFIRST באוגר SPI_CR1 כדי לקבוע את פורמט הבלוק

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

5. במצב חומרה, אם נדרשת קלט מפין ה-NSS, החל אות גבוה על פין ה-NSS במהלך כל רצף העברת הבתים. במצב תוכנת NSS, הגדר את סיביות SSM ו-SSI באוגר SPI_CR1. אם יש להשתמש בפין ה-NSS כפלט, יש להגדיר רק את סיביות ה-SSOE.

התקן SSM ו-SSI כדי לשכוח ממצב החומרה של NSS:

#define SSI         0x0100
#define SSM         0x0200

_SPI2_ (_SPI_CR1) |= SSM | SSI; //enable software control of SS, SS high

6. יש להגדיר את סיביות ה-MSTR וה-SPE (הן נשארות מוגדרות רק אם אות ה-NSS גבוה)

למעשה, עם הקטעים האלה אנו מייעדים את ה-SPI שלנו כמאסטר ומפעילים אותו:

#define MSTR        0x0004
#define SPE         0x0040

_SPI2_ (_SPI_CR1) |= MSTR; //SPI master
//когда все готово, включаем SPI
_SPI2_ (_SPI_CR1) |= SPE;

SPI מוגדר, בוא נכתוב מיד פונקציות ששולחות בתים למנהל ההתקן. המשך לקרוא את 25.3.3 "הגדרת SPI במצב מאסטר":

סדר העברת נתונים
השידור מתחיל כאשר בייט נכתב למאגר Tx.
בית הנתונים נטען לאוגר המשמרות בשעה מַקְבִּיל מצב (מהאוטובוס הפנימי) במהלך השידור של הביט הראשון, שלאחריו הוא מועבר אל סִדרָתִי מצב PIN MOSI, סיביות ראשונה או אחרונה קדימה בהתאם להגדרת סיבית LSBFIRST באוגר CPI_CR1. דגל TXE מוגדר לאחר העברת נתונים ממאגר Tx לאוגר משמרות, וגם יוצר פסיקה אם ביט TXEIE באוגר CPI_CR1 מוגדר.

הדגשתי כמה מילים בתרגום כדי למשוך תשומת לב לתכונה אחת של יישום SPI בבקרי STM. ב-Atmega דגל TXE (Tx ריק, Tx ריק ומוכן לקבל נתונים) מוגדר רק לאחר שליחת כל הבתים החוצה. והנה הדגל הזה נקבע לאחר שהבית הוכנס לאוגר המשמרות הפנימי. מכיוון שהוא נדחף לשם עם כל הביטים בו-זמנית (במקביל), ואז הנתונים מועברים ברצף, TXE מוגדר לפני שהבייט נשלח לחלוטין. זה חשוב כי במקרה של דרייבר LED שלנו, עלינו למשוך את סיכת ה-LAT לאחר השליחה כל נתונים, כלומר. דגל TXE לבדו לא יספיק לנו.

זה אומר שאנחנו צריכים דגל נוסף. בואו נסתכל על 25.3.7 - "דגלי סטטוס":

<...>

דגל עסוק
דגל BSY מוגדר ומנוקה על ידי חומרה (לכתיבה אליו אין השפעה). דגל BSY מציין את מצב שכבת התקשורת SPI.
זה מתאפס:
כאשר ההעברה הושלמה (למעט במצב מאסטר אם ההעברה רציפה)
כאשר SPI מושבת
כאשר מתרחשת שגיאת מצב מאסטר (MODF=1)
אם ההעברה אינה רציפה, דגל ה-BSY נמחק בין כל העברת נתונים

אוקיי, זה יהיה שימושי. בואו לגלות היכן ממוקם מאגר ה-Tx. כדי לעשות זאת, קרא את "מרשם הנתונים של SPI":

Bits 15:0 DR[15:0] Data Register
נתונים שהתקבלו או נתונים שישודרו.
מאגר הנתונים מחולק לשני מאגרים - אחד לכתיבה (מאגר שידור) ואחד לקריאה (מאגר קליטה). כתיבה למאגר הנתונים כותבת למאגר Tx, וקריאה ממאגר הנתונים תחזיר את הערך הכלול במאגר Rx.

ובכן, ומרשם הסטטוס, שבו נמצאים דגלי TXE ו-BSY:

אנחנו כותבים:

#define _SPI_DR  0x0C
#define _SPI_SR  0x08

#define BSY         0x0080
#define TXE         0x0002

void dm_shift16(uint16_t value)
{
    _SPI2_(_SPI_DR) = value; //send 2 bytes
    while (!(_SPI2_(_SPI_SR) & TXE)); //wait until they're sent
}

ובכן, מכיוון שאנחנו צריכים לשדר 16 כפול שני בתים, לפי מספר יציאות מנהלי התקן LED, משהו כזה:

void sendLEDdata()
{
    LAT_low();
    uint8_t k = 16;
    do
    {   k--;
        dm_shift16(leds[k]);
    } while (k);

    while (_SPI2_(_SPI_SR) & BSY); // finish transmission

    LAT_pulse();
}

אבל אנחנו עדיין לא יודעים איך למשוך את סיכת ה-LAT, אז נחזור ל-I/O.

הקצאת סיכות

ב-STM32F1, הרגיסטרים האחראים על מצב הפינים הם די יוצאי דופן. ברור שיש יותר מהם מאשר Atmega, אבל הם גם שונים משבבי STM אחרים. סעיף 9.1 תיאור כללי של GPIO:

כל אחת מיציאות I/O לשימוש כללי (GPIO) יש שני אוגרי תצורה של 32 סיביות (GPIOx_CRL ו-GPIOx_CRH), שני אוגרי נתונים של 32 סיביות (GPIOx_IDR ו-GPIOx_ODR), אוגר 32 סיביות להגדיר/איפוס (GPIOx_BSRR), אוגר איפוס של 16 סיביות (GPIOx_BRR) ו-32- אוגר חסימת סיביות (GPIOx_LCKR).

שני הרגיסטרים הראשונים הם יוצאי דופן, וגם די לא נוחים, מכיוון ש-16 פיני היציאות מפוזרים עליהם בפורמט "ארבעה ביטים לאח". הָהֵן. פינים אפס עד שבע נמצאים ב-CRL, והשאר ב-CRH. יחד עם זאת, הרגיסטרים הנותרים מכילים בהצלחה את הסיביות של כל הפינים של היציאה - לרוב נשארים חצי "שמורים".

לשם הפשטות, נתחיל מסוף הרשימה.

אנחנו לא צריכים פנקס חוסם.

אוגרי הסט והאיפוס די מצחיקים בכך שהם משכפלים זה את זה חלקית: אתה יכול לכתוב הכל רק ב-BSRR, כאשר 16 הסיביות הגבוהות יותר יאפסו את הפין לאפס, והתחתונים יוגדרו ל-1, או שאתה יכול גם השתמש ב-BRR, ש-16 הסיביות התחתונות שבהן רק מאפסות את הפין. אני אוהב את האפשרות השנייה. רגיסטרים אלה חשובים מכיוון שהם מספקים גישה אטומית לסיכות:

סט או איפוס אטומי
אין צורך לנטרל פסיקות בעת תכנות GPIOx_ODR ברמת הסיביות: ניתן לשנות סיביות אחת או יותר בפעולת כתיבה אטומית אחת APB2. זה מושג על ידי כתיבת "1" לאגר הסט/איפוס (GPIOx_BSRR או, לאיפוס בלבד, GPIOx_BRR) של הביט שצריך לשנות. ביטים אחרים יישארו ללא שינוי.

למאגרי הנתונים יש שמות די ברורים - IDR = קֶלֶט מרשם כיוון, אוגר קלט; ODR = תְפוּקָה אוגר כיוון, אוגר פלט. לא נצטרך אותם בפרויקט הנוכחי.

ולבסוף, רושמת בקרה. מכיוון שאנו מעוניינים בפינים השניים של SPI, כלומר PB13, PB14 ו-PB15, אנו מיד מסתכלים על CRH:

ואנחנו רואים שנצטרך לכתוב משהו בסיביות מ-20 עד 31.

כבר הבנו למעלה מה אנחנו רוצים מסיכות, אז כאן אני אעשה בלי צילום מסך, אני רק אגיד ש-MODUS מציין את הכיוון (הקלט אם שני הביטים מוגדרים ל-0) ואת מהירות הפין (אנחנו צריכים 50MHz, כלומר. שניהם פינים ל-"1"), ו-CNF מגדיר את המצב: "דחיפה-משיכה" רגילה - 00, "אלטרנטיבה" - 10. כברירת מחדל, כפי שאנו רואים לעיל, לכל הפינים יש את הסיביות השלישית מלמטה (CNF0), זה מכוון אותם למצב קלט צף.

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

איכשהו ככה

#define CNF0_0 0x00000004
#define CNF0_1 0x00000008
#define CNF1_0 0x00000040
#define CNF1_1 0x00000080
#define CNF2_0 0x00000400
#define CNF2_1 0x00000800
#define CNF3_0 0x00004000
#define CNF3_1 0x00008000
#define CNF4_0 0x00040000
#define CNF4_1 0x00080000
#define CNF5_0 0x00400000
#define CNF5_1 0x00800000
#define CNF6_0 0x04000000
#define CNF6_1 0x08000000
#define CNF7_0 0x40000000
#define CNF7_1 0x80000000
#define CNF8_0 0x00000004
#define CNF8_1 0x00000008
#define CNF9_0 0x00000040
#define CNF9_1 0x00000080
#define CNF10_0 0x00000400
#define CNF10_1 0x00000800
#define CNF11_0 0x00004000
#define CNF11_1 0x00008000
#define CNF12_0 0x00040000
#define CNF12_1 0x00080000
#define CNF13_0 0x00400000
#define CNF13_1 0x00800000
#define CNF14_0 0x04000000
#define CNF14_1 0x08000000
#define CNF15_0 0x40000000
#define CNF15_1 0x80000000

#define MODE0_0 0x00000001
#define MODE0_1 0x00000002
#define MODE1_0 0x00000010
#define MODE1_1 0x00000020
#define MODE2_0 0x00000100
#define MODE2_1 0x00000200
#define MODE3_0 0x00001000
#define MODE3_1 0x00002000
#define MODE4_0 0x00010000
#define MODE4_1 0x00020000
#define MODE5_0 0x00100000
#define MODE5_1 0x00200000
#define MODE6_0 0x01000000
#define MODE6_1 0x02000000
#define MODE7_0 0x10000000
#define MODE7_1 0x20000000
#define MODE8_0 0x00000001
#define MODE8_1 0x00000002
#define MODE9_0 0x00000010
#define MODE9_1 0x00000020
#define MODE10_0 0x00000100
#define MODE10_1 0x00000200
#define MODE11_0 0x00001000
#define MODE11_1 0x00002000
#define MODE12_0 0x00010000
#define MODE12_1 0x00020000
#define MODE13_0 0x00100000
#define MODE13_1 0x00200000
#define MODE14_0 0x01000000
#define MODE14_1 0x02000000
#define MODE15_0 0x10000000
#define MODE15_1 0x20000000

הפינים שלנו ממוקמים ביציאה B (כתובת בסיס – 0x40010C00), קוד:

#define _PORTB_(mem_offset) (*(volatile uint32_t *)(0x40010C00 + (mem_offset)))

#define _BRR  0x14
#define _BSRR 0x10
#define _CRL  0x00
#define _CRH  0x04

//используем стандартный SPI2: MOSI на B15, CLK на B13
//LAT пусть будет на неиспользуемом MISO – B14

//очищаем дефолтный бит, он нам точно не нужен
_PORTB_ (_CRH) &= ~(CNF15_0 | CNF14_0 | CNF13_0 | CNF12_0);

//альтернативные функции для MOSI и SCK
_PORTB_ (_CRH) |= CNF15_1 | CNF13_1;

//50 МГц, MODE = 11
_PORTB_ (_CRH) |= MODE15_1 | MODE15_0 | MODE14_1 | MODE14_0 | MODE13_1 | MODE13_0;

ובהתאם לכך, אתה יכול לכתוב הגדרות עבור LAT, אשר יעוותו על ידי אוגרי BRR ו-BSRR:

/*** LAT pulse – high, then low */
#define LAT_pulse() _PORTB_(_BSRR) = (1<<14); _PORTB_(_BRR) = (1<<14)

#define LAT_low() _PORTB_(_BRR) = (1<<14)

(LAT_low רק בגלל אינרציה, זה תמיד היה ככה, תן לזה להישאר)

עכשיו הכל נהדר, אבל זה לא עובד. מכיוון שזה STM32, הם חוסכים בחשמל, מה שאומר שאתה צריך לאפשר שעון של הציוד ההיקפי הנדרש.

הפעל את השעון

השעון, הידוע גם בשם Clock, אחראי על השעון. וכבר יכולנו לשים לב לקיצור RCC. אנחנו מחפשים את זה בתיעוד: זה איפוס ובקרת שעון.

כפי שנאמר למעלה, למרבה המזל, החלק הקשה ביותר בנושא השעון נעשה עבורנו על ידי אנשי STM, ועל כך אנו מודים להם מאוד (שוב אתן קישור ל האתר של די האלט, כדי להבהיר כמה זה מבלבל). אנחנו צריכים רק אוגרים האחראים להפעלת שעון היקפי (Peripheral Clock Enable Registers). ראשית, בואו נמצא את כתובת הבסיס של ה-RCC, היא נמצאת ממש בתחילת "מפת הזיכרון":

#define _RCC_(mem_offset) (*(volatile uint32_t *)(0x40021000 + (mem_offset)))

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

והם, בהתאם, מכילים ביטים הכוללים את השעון של SPI2, IOPB (יציאת I/O B) ופונקציות חלופיות (AFIO).

#define _APB2ENR 0x18
#define _APB1ENR 0x1C

#define IOPBEN 0x0008
#define SPI2EN 0x4000
#define AFIOEN 0x0001

//включаем тактирование порта B и альт. функций
_RCC_(_APB2ENR) |= IOPBEN | AFIOEN;

//включаем  тактирование SPI2
_RCC_(_APB1ENR) |= SPI2EN;

ניתן למצוא את הקוד הסופי כאן.

אם יש לך הזדמנות ורצון לבדוק, אז חבר את ה-DM634 כך: DAI ל-PB15, DCK ל-PB13, LAT ל-PB14. אנו מפעילים את הנהג מ-5 וולט, אל תשכח לחבר את הקרקע.

STM8 PWM

PWM על STM8

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

גם לשבב יש טופס מידע и מדריך עזר RM0016, בראשון יש pinout וכתובות רישום, בשני - כל השאר. STM8 מתוכנת ב-C ב-IDE נורא ST Visual Develop.

שעון וקלט/פלט

כברירת מחדל, STM8 פועל בתדר של 2 מגה-הרץ, יש לתקן זאת מיד.

שעון HSI (High Speed ​​​​Internal).
אות השעון HSI נגזר מתנד RC פנימי של 16 מגה-הרץ עם מחלק הניתן לתכנות (1 עד 8). הוא מוגדר בפנקס מחלק השעון (CLK_CKDIVR).
הערה: בהתחלה, מתנד HSI RC עם מחלק של 8 נבחר כמקור המוביל של אות השעון.

אנו מוצאים את כתובת הרישום בגיליון הנתונים, את התיאור ב-refman ורואים שיש לנקות את המרשם:

#define CLK_CKDIVR *(volatile uint8_t *)0x0050C6

CLK_CKDIVR &= ~(0x18);

מכיוון שאנו הולכים להפעיל PWM ולחבר את נוריות ה-LED, בואו נסתכל על ה-pinout:

השבב קטן, פונקציות רבות תלויות על אותן פינים. מה שמופיע בסוגריים מרובעים הוא "פונקציונליות חלופית", היא משתנה על ידי "בתים של אפשרויות" (בתים של אפשרות) - משהו כמו נתיכים של Atmega. אתה יכול לשנות את הערכים שלהם באופן תכנותי, אבל זה לא הכרחי, כי הפונקציונליות החדשה מופעלת רק לאחר אתחול מחדש. קל יותר להשתמש ב-ST Visual Programmer (הורד עם Visual Develop), שיכול לשנות בתים אלה. ה-Pinout מראה שהפינים CH1 ו-CH2 של הטיימר הראשון מוסתרים בסוגריים מרובעים; יש צורך להגדיר את סיביות AFR1 ו-AFR0 ב-STVP, והשני יעביר גם את פלט CH1 של הטיימר השני מ-PD4 ל-PC5.

לפיכך, 6 פינים ישלטו על הנוריות: PC6, PC7 ו-PC3 עבור הטיימר הראשון, PC5, PD3 ו-PA3 עבור השני.

הגדרת פיני הקלט/פלט עצמם ב- STM8 היא פשוטה והגיונית יותר מאשר ב- STM32:

• מוכר מאוגר כיוון הנתונים של Atmega DDR (רישום כיוון נתונים): 1 = פלט;
• אוגר הבקרה הראשון CR1, כאשר יוצא, מגדיר את מצב דחיפה-משיכה (1) או ניקוז פתוח (0); מכיוון שאני מחבר את הנוריות לשבב עם קתודות, אני משאיר כאן אפסים;
• אוגר הבקרה השני CR2, כאשר יוצא, מגדיר את מהירות השעון: 1 = 10 מגה-הרץ

#define PA_DDR     *(volatile uint8_t *)0x005002
#define PA_CR2     *(volatile uint8_t *)0x005004
#define PD_DDR     *(volatile uint8_t *)0x005011
#define PD_CR2     *(volatile uint8_t *)0x005013
#define PC_DDR     *(volatile uint8_t *)0x00500C
#define PC_CR2     *(volatile uint8_t *)0x00500E

PA_DDR = (1<<3); //output
PA_CR2 |= (1<<3); //fast
PD_DDR = (1<<3); //output
PD_CR2 |= (1<<3); //fast
PC_DDR = ((1<<3) | (1<<5) | (1<<6) | (1<<7)); //output
PC_CR2 |= ((1<<3) | (1<<5) | (1<<6) | (1<<7)); //fast

הגדרת PWM

ראשית, בוא נגדיר את המונחים:

• תדר PWM - תדירות שבה הטיימר מתקתק;
• טען מחדש אוטומטית, AR - ערך הניתן לטעינה אוטומטית שעד אליו הטיימר ייספר (תקופת הדופק);
• עדכון אירוע, UEV - אירוע המתרחש כאשר הטיימר סופר ל-AR;
• מחזור עבודה של PWM - מחזור עבודה PWM, המכונה לעתים קרובות "גורם חובה";
• לכידת/השוואת ערך – ערך ללכידה/השוואה, שאליו סופר הטיימר יעשה משהו (במקרה של PWM, הוא הופך את אות הפלט);
• ערך טעינה מראש - ערך נטען מראש. השווה ערך לא יכול להשתנות בזמן שהטיימר מתקתק, אחרת מחזור ה-PWM יישבר. לכן, ערכים משודרים חדשים ממוקמים במאגר ונשלפים כאשר הטיימר מגיע לסוף הספירה לאחור ומתאפס;
• מיושר לקצה и מצבים מיושרים למרכז - יישור לאורך הגבול ובמרכז, זהה לזה של Atmel PWM מהיר и PWM תואם שלב.
• OCiREF, Output Compare Reference Signal - הפניה לאות פלט, למעשה, מה שמופיע בפין המתאים במצב PWM.

כפי שכבר ברור מה-pinout, לשני טיימרים יש יכולות PWM - הראשון והשני. שניהם הם 16 סיביות, לראשון יש הרבה תכונות נוספות (בפרט, הוא יכול לספור גם למעלה וגם למטה). שנינו צריכים לעבוד בצורה שווה, אז החלטתי להתחיל עם השני המסכן יותר, כדי לא להשתמש בטעות במשהו שלא קיים. בעיה כלשהי היא שהתיאור של פונקציונליות ה-PWM של כל הטיימרים במדריך העזר נמצא בפרק על הטיימר הראשון (17.5.7 PWM Mode), כך שצריך לקפוץ קדימה ואחורה לאורך המסמך כל הזמן.

ל-PWM ב-STM8 יש יתרון חשוב על פני PWM ב-Atmega:

Boundary Aligned PWM
תצורת חשבון מלמטה למעלה
ספירה מלמטה למעלה פעילה אם סיבית ה-DIR באוגר TIM_CR1 מנוקה
דוגמה
הדוגמה משתמשת במצב PWM הראשון. אות ההתייחסות PWM OCiREF נשמר גבוה כל עוד TIM1_CNT < TIM1_CCRi. אחרת זה דורש רמה נמוכה. אם ערך ההשוואה באוגר TIM1_CCRi גדול מערך הטעינה האוטומטית (אוגר TIM1_ARR), האות OCiREF מוחזק על 1. אם ערך ההשוואה הוא 0, OCiREF נשמר באפס....

טיימר STM8 במהלך עדכון אירוע בודקים קודם להשוות ערך, ורק אז מייצר אות התייחסות. הטיימר של Atmega מתברג תחילה ואז משווה, וכתוצאה מכך compare value == 0 הפלט הוא מחט, שחייבים להתמודד איתה איכשהו (לדוגמה, על ידי היפוך תוכניתי של ההיגיון).

אז מה אנחנו רוצים לעשות: 8 סיביות PWM (AR == 255), ספירה מלמטה למעלה, יישור לאורך הגבול. מכיוון שהנורות מחוברות לשבב באמצעות קתודות, ה-PWM אמור להוציא 0 (LED דולק) עד להשוות ערך ו-1 אחרי.

כבר קראנו על כמה מצב PWM, אז אנו מוצאים את האוגר הנדרש של הטיימר השני על ידי חיפוש במדריך העזר של הביטוי הזה (18.6.8 - TIMx_CCMR1):

110: מצב PWM ראשון - כאשר סופרים מלמטה למעלה, הערוץ הראשון פעיל בעוד TIMx_CNT < TIMx_CCR1. אחרת, הערוץ הראשון אינו פעיל. [בהמשך במסמך יש העתק-הדבק שגוי מטיימר 1] 111: מצב PWM שני – כשסופרים מלמטה למעלה, הערוץ הראשון אינו פעיל בעוד TIMx_CNT < TIMx_CCR1. אחרת, הערוץ הראשון פעיל.

מכיוון שהנוריות מחוברות ל-MK באמצעות קתודות, המצב השני מתאים לנו (גם הראשון, אבל אנחנו לא יודעים את זה עדיין).

Bit 3 OC1PE: אפשר טעינה מוקדמת של פין 1
0: אוגר טעינה מראש ב-TIMx_CCR1 מושבת. אתה יכול לכתוב אל TIMx_CCR1 בכל עת. הערך החדש עובד מיד.
1: אוגר טעינה מראש ב-TIMx_CCR1 מופעל. פעולות קריאה/כתיבה ניגשות לאוגר טעינה מראש. הערך הנטען מראש TIMx_CCR1 נטען לתוך אוגר הצללים במהלך כל אירוע עדכון.
*הערה: כדי שמצב PWM יפעל כראוי, יש להפעיל את אוגרי הטעינה המוקדמת. זה לא הכרחי במצב אות בודד (סיבית OPM מוגדרת באוגר TIMx_CR1).

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

#define TIM2_CCMR1 *(volatile uint8_t *)0x005307
#define TIM2_CCMR2 *(volatile uint8_t *)0x005308
#define TIM2_CCMR3 *(volatile uint8_t *)0x005309

#define PWM_MODE2   0x70 //PWM mode 2, 0b01110000
#define OCxPE       0x08 //preload enable

TIM2_CCMR1 = (PWM_MODE2 | OCxPE);
TIM2_CCMR2 = (PWM_MODE2 | OCxPE);
TIM2_CCMR3 = (PWM_MODE2 | OCxPE);

AR מורכב משני אוגרים של שמונה סיביות, הכל פשוט:

#define TIM2_ARRH  *(volatile uint8_t *)0x00530F
#define TIM2_ARRL  *(volatile uint8_t *)0x005310

TIM2_ARRH = 0;
TIM2_ARRL = 255;

הטיימר השני יכול לספור רק מלמטה למעלה, יישור לאורך הגבול, אין צורך לשנות דבר. בוא נגדיר את מחלק התדרים, למשל, ל-256. עבור הטיימר השני, המחלק מוגדר באוגר TIM2_PSCR והוא חזק של שתיים:

#define TIM2_PSCR  *(volatile uint8_t *)0x00530E

TIM2_PSCR = 8;

כל מה שנותר הוא להפעיל את המסקנות ואת הטיימר השני עצמו. הבעיה הראשונה נפתרת על ידי אוגרים לכיד / השוואה אפשר: ישנם שניים, שלושה ערוצים מפוזרים עליהם בצורה אסימטרית. כאן נוכל גם ללמוד שאפשר לשנות את הקוטביות של האות, כלומר. באופן עקרוני, ניתן היה להשתמש במצב PWM 1. אנו כותבים:

#define TIM2_CCER1 *(volatile uint8_t *)0x00530A
#define TIM2_CCER2 *(volatile uint8_t *)0x00530B

#define CC1E  (1<<0) // CCER1
#define CC2E  (1<<4) // CCER1
#define CC3E  (1<<0) // CCER2

TIM2_CCER1 = (CC1E | CC2E);
TIM2_CCER2 = CC3E;

ולבסוף, אנו מפעילים את הטיימר באוגר TIMx_CR1:

#define TIM2_CR1   *(volatile uint8_t *)0x005300

TIM2_CR1 |= 1;

בואו נכתוב אנלוגי פשוט של AnalogWrite(), שיעביר את הערכים האמיתיים לטיימר לצורך השוואה. הרשמים נקראים באופן צפוי לכידת/השוואה של אוגרים, ישנם שניים מהם עבור כל ערוץ: 8 סיביות מסדר נמוך ב- TIM2_CCRxL וה- מסדר גבוה ב- TIM2_CCRxH. מכיוון שיצרנו PWM של 8 סיביות, מספיק לכתוב רק את הביטים הפחות משמעותיים:

#define TIM2_CCR1L *(volatile uint8_t *)0x005312
#define TIM2_CCR2L *(volatile uint8_t *)0x005314
#define TIM2_CCR3L *(volatile uint8_t *)0x005316

void setRGBled(uint8_t r, uint8_t g, uint8_t b)
{
    TIM2_CCR1L = r;
    TIM2_CCR2L = g;
    TIM2_CCR3L = b;
}

הקורא הקשוב ישים לב שיש לנו PWM מעט פגום, שאינו מסוגל לייצר 100% מילוי (בערך מרבי של 255, האות מתהפך למחזור טיימר אחד). עבור נוריות זה לא משנה, והקורא הקשוב כבר יכול לנחש איך לתקן את זה.

PWM בטיימר השני עובד, בואו נעבור לראשון.

לטיימר הראשון יש בדיוק אותם סיביות באותם רגיסטרים (רק שהביטים האלה שנשארו "שמורים" בטיימר השני משמשים באופן פעיל ב-16 לכל מיני דברים מתקדמים). לכן, מספיק למצוא את הכתובות של אותם אוגרים בגיליון הנתונים ולהעתיק את הקוד. ובכן, שנה את הערך של מחלק התדרים, כי... הטיימר הראשון רוצה לקבל לא כוח של שתיים, אלא ערך מדויק של XNUMX סיביות בשני אוגרים Prescaler High и נמוך. אנחנו עושים הכל ו... הטיימר הראשון לא עובד. מה הבעיה?

ניתן לפתור את הבעיה רק ​​על ידי עיון בכל הסעיף על אוגרי הבקרה של טיימר 1, שם אנו מחפשים את זה שאין לטיימר השני. יהיה 17.7.30 רישום הפסקה (TIM1_BKR), איפה יש את הקטע הזה:

אפשר פלט ראשי

#define TIM1_BKR   *(volatile uint8_t *)0x00526D

TIM1_BKR = (1<<7);

זה הכל בטוח עכשיו, הקוד שם.

STM8 Multiplex

ריבוי ב-STM8

המיני-פרויקט השלישי הוא לחבר שמונה נוריות RGB לטיימר השני במצב PWM ולגרום להם להראות צבעים שונים. הוא מבוסס על הרעיון של ריבוי LED, כלומר שאם מדליקים ומכבים נורות לד מאוד מאוד מהר, ייראה לנו שהם כל הזמן דולקים (התמדה בראייה, אינרציה של תפיסה חזותית). פעם עשיתי משהו כזה ב- Arduino.

אלגוריתם העבודה נראה כך:

• חיבר את האנודה של LED RGB הראשון;
• הדליק אותו, שולח את האותות הדרושים לקתודות;
• המתין עד סוף מחזור ה-PWM;
• חיבר את האנודה של LED RGB השני;
• תדליק את זה...

ובכן וכו'. כמובן, לתפעול יפה נדרש שהאנודה מחוברת וה-LED "נדלקת" בו-זמנית. טוב, או כמעט. בכל מקרה, עלינו לכתוב קוד שיוציא ערכים בשלושה ערוצים של הטיימר השני, ישנה אותם כשמגיעים ל-UEV, ובמקביל לשנות את ה-RGB LED הפעילה כעת.

מכיוון שהמיתוג LED הוא אוטומטי, עלינו ליצור "זיכרון וידאו" שממנו יקבל מטפל ההפרעות נתונים. זהו מערך פשוט:

uint8_t colors[8][3];

כדי לשנות את הצבע של LED ספציפי, זה יהיה מספיק כדי לכתוב את הערכים הנדרשים למערך זה. והמשתנה יהיה אחראי על מספר הנורית הפעילה

uint8_t cnt;

Demux

לצורך ריבוי תקין, אנו זקוקים, באופן מוזר, ל-CD74HC238 demultiplexer. Demultiplexer - שבב המיישם את המפעיל בחומרה <<. דרך שלושה פיני קלט (סיביות 0, 1 ו-2) אנו מאכילים אותו במספר X של שלוש סיביות, ובתגובה הוא מפעיל את מספר הפלט (1<<X). שאר הכניסות של השבב משמשות להגדלת העיצוב כולו. אנחנו צריכים את השבב הזה לא רק כדי לצמצם את מספר הפינים התפוסים של המיקרו-בקר, אלא גם לבטיחות - כדי לא להדליק בטעות יותר נוריות מהאפשריות ולא לשרוף את ה-MK. השבב עולה אגורה ויש לשמור אותו תמיד בארון התרופות הביתי.

ה-CD74HC238 שלנו יהיה אחראי על אספקת המתח לאנודה של ה-LED הרצוי. בריבוי מלא, הוא יספק מתח לעמוד דרך P-MOSFET, אבל בהדגמה זו זה אפשרי ישירות, כי הוא שואב 20 mA, לפי דירוג מרבי מוחלט בגיליון הנתונים. מ גיליון נתונים CD74HC238 אנחנו צריכים pinouts ואת דף הצ'יט הזה:

H = רמת מתח גבוה, L = רמת מתח נמוכה, X - לא אכפת

אנו מחברים את E2 ו-E1 לאדמה, E3, A0, A1 ו-A3 לפינים PD5, PC3, PC4 ו-PC5 של STM8. מכיוון שהטבלה שלמעלה מכילה רמות נמוכות וגבוהות, אנו מגדירים את הפינים הללו כסיכות משיכה.

PWM

PWM בטיימר השני מוגדר באותו אופן כמו בסיפור הקודם, עם שני הבדלים:

ראשית, עלינו להפעיל את ההפרעה עדכן את האירוע (UEV) שתקרא לפונקציה שתחליף את ה-LED הפעילה. זה נעשה על ידי שינוי הביט Update Interrupt Enable בפנקס עם שם אומר

הרשמה לאפשר הפסקה

#define TIM2_IER   *(volatile uint8_t *)0x005303

//enable interrupt
TIM2_IER = 1;

ההבדל השני קשור לתופעת הריבוי, כגון ghosting - זוהר טפילי של דיודות. במקרה שלנו, זה עשוי להופיע בגלל העובדה שהטיימר, לאחר שגרם להפרעה ב-UEV, ממשיך לתקתק, ולמטפל ההפרעות אין זמן להחליף את הנורית לפני שהטיימר יתחיל לכתוב משהו לפינים. כדי להילחם בזה, תצטרך להפוך את ההיגיון (0 = בהירות מקסימלית, 255 = שום דבר לא מואר) ולהימנע מערכי מחזור עבודה קיצוניים. הָהֵן. ודא שאחרי UEV הנוריות יכבו לחלוטין למשך מחזור PWM אחד.

שינוי קוטביות:

//set polarity 
    TIM2_CCER1 |= (CC1P | CC2P);
    TIM2_CCER2 |= CC3P;

הימנע מהגדרת r, g ו-b ל-255 וזכור להפוך אותם בעת השימוש בהם.

מפריע

המהות של פסיקה היא שבנסיבות מסוימות השבב מפסיק להפעיל את התוכנית הראשית וקורא לפונקציה חיצונית כלשהי. הפרעות מתרחשות עקב השפעות חיצוניות או פנימיות, כולל הטיימר.

כאשר יצרנו פרויקט לראשונה ב-ST Visual Develop, בנוסף ל main.c קיבלנו חלון עם קובץ מסתורי stm8_interrupt_vector.c, נכלל אוטומטית בפרויקט. בקובץ זה, מוקצית פונקציה לכל פסיקה NonHandledInterrupt. אנחנו צריכים לקשור את הפונקציה שלנו לפסיקה הרצויה.

בגליון הנתונים יש טבלה של וקטורי פסיקה, שבה אנו מוצאים את אלה שאנו צריכים:

13 עדכון/הצפה של TIM2
14 לכידת/השוואה של TIM2

אנחנו צריכים לשנות את ה-LED ב-UEV, אז אנחנו צריכים הפרעה מס' 13.

לפיכך, ראשית, בתיק stm8_interrupt_vector.c שנה את שם ברירת המחדל של הפונקציה האחראית לפסיקה מס' 13 (IRQ13) לשם שלך:

{0x82, TIM2_Overflow}, /* irq13 */

שנית, נצטרך ליצור קובץ main.h עם התוכן הבא:

#ifndef __MAIN_H
#define __MAIN_H

@far @interrupt void TIM2_Overflow (void);
#endif

ולבסוף, כתוב את הפונקציה הזו שלך main.c:

@far @interrupt void TIM2_Overflow (void)
{
    PD_ODR &= ~(1<<5); // вырубаем демультиплексор
    PC_ODR = (cnt<<3); // записываем в демультиплексор новое значение
    PD_ODR |= (1<<5); // включаем демультиплексор

    TIM2_SR1 = 0; // сбрасываем флаг Update Interrupt Pending

    cnt++; 
    cnt &= 7; // двигаем счетчик LED

    TIM2_CCR1L = ~colors[cnt][0]; // передаем в буфер инвертированные значения
    TIM2_CCR2L = ~colors[cnt][1]; // для следующего цикла ШИМ
    TIM2_CCR3L = ~colors[cnt][2]; // 

    return;
}

כל מה שנותר הוא לאפשר הפרעות. זה נעשה באמצעות הפקודה assembler rim - תצטרך לחפש אותו מדריך תכנות:

//enable interrupts
_asm("rim");

פקודת אסמבלר נוספת היא sim - מכבה את ההפרעות. יש לכבות אותם בזמן שערכים חדשים נכתבים ל"זיכרון הווידאו", כך שהפרעה שנגרמה ברגע הלא נכון לא תקלקל את המערך.

כל הקוד - ב-GitHub.

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

מקור: www.habr.com