יישום חיישן מחווה ללא חסימה APDS9960: 5 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:16

הַקדָמָה

מדריך זה מפרט כיצד ליצור יישום שאינו חוסם את חיישן המחוות APDS9960 באמצעות ספארק FunK_APDS-9960_Sensor_Arduino_Library.

מבוא

אז אתה בטח שואל את עצמך מהו אי חסימה? או אפילו חסימה לצורך העניין?

חשוב יותר מדוע חשוב שיהיה משהו לא חוסם נכון?

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

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

אז למה זה חשוב?

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

מצידי אני רוצה ליצור מכשיר שולחני מסוג IoT מסוג MQTT באמצעות WiFi הקורא ערכי טמפ '/לחות מקומיים ומרוחקים, רמות אור סביבה, לחץ ברומטרי, עוקב אחר הזמן, מציג את כל הפרמטרים הללו על מסך LCD, היכנס ל- uSD כרטיס בזמן אמת, קריאת כניסות כפתורים, כתיבה לנורות נוריות ופלט ומעקב אחר מחוות כדי לשלוט בדברים בתשתית IoT שלי ועל כל אלה יש לשלוט על ידי ESP8266-12.

לרוע המזל, שני המקורות היחידים של ספריית APDS9960 שיכולתי למצוא היו ספריות SparkFun ו- AdaFruit, ששניהם נתלשו מקוד היישום של Avago (יצרן ADPS9960) ויש להם קריאה בשם 'readGesture' המכילה זמן מה (1) {}; לולאה אשר בעת שימוש בפרויקט לעיל גורמת ל- ESP8266-12E להתאפס בכל פעם שחיישן ADPS9960 נהיה רווי (כלומר כאשר אובייקט נשאר בקרבת מקום, או שהיה מקור IR נוסף המאיר את החיישן).

כתוצאה מכך כדי לפתור התנהגות זו בחרתי להעביר את עיבוד המחוות למעבד שני לפיו ה- ESP8266-12E הפך למיקרו-בקר הראשי ומערכת זו לעבד, כפי שמתואר בתמונות 1 ו -2 לעיל, סקירת המערכת ותרשימי מערכת המערכת בהתאמה.. תמונה 3 מציגה את מעגל האב טיפוס.

על מנת להגביל את השינויים שהייתי צריך לבצע בקוד הקיים שלי כתבתי גם שיעור עטיפה/ספרייה בשם דמיוני 'APDS9960_NonBlocking'.

להלן הסבר מפורט על הפתרון הבלתי חוסם.

אילו חלקים אני צריך?

אם אתה רוצה לבנות את פתרון I2C שעובד עם ספריית APDS9960_NonBlocking תדרש את החלקים הבאים.

1. 1 הנחה על ATMega328P כאן
2. 1 הנחה על PCF8574P כאן
3. 6 נגדי 10K נגדים כאן
4. 4 נגדים נגד 1K כאן
5. 1 דיודה 1N914 דיודה כאן
6. 1 הנחה טרנזיסטור NPN PN2222 כאן
7. קריסטל חד פעמי של 16 מגה -הרץ כאן
8. 2 קבלים של 0.1uF כאן
9. קבל אלקטרוליטי אחד ב- 1000uF כאן
10. 1 off 10uF קבלים אלקטרוליטיים כאן
11. 2 קבלים של 22pF כאן

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

איזו תוכנה אני צריך?

Arduino IDE 1.6.9

אילו כישורים אני צריך?

כדי להגדיר את המערכת, השתמש בקוד המקור (מסופק) וצור את המעגלים הדרושים. תזדקק לדברים הבאים;

• הבנה מינימלית של האלקטרוניקה,
• הכרת Arduino וזה IDE,
• הבנה כיצד לתכנת Arduino מוטבע (ראה הוראת 'תכנות ה- ATTiny85, ATTiny84 ו- ATMega328P: Arduino כספקית האינטרנט')
• קצת סבלנות.

נושאים מכוסים

• סקירה קצרה של המעגל
• סקירה קצרה של התוכנה
• בדיקת התקן חישת מחוות APDS9960
• סיכום
• הפניות

שלב 1: סקירת מעגלים

המעגל מחולק לשני חלקים;

• הראשון הוא ההמרה הסדרתית I2C למקבילה המתבצעת באמצעות הנגדים R8 … 10 ו- IC1. כאן R8… R10 הגדירו את כתובת I2C עבור שבב הרחבת הקלט/פלט 8 סיביות IC1 ו- NXP PCF8574A. טווחי כתובות תקפים למכשיר זה הם 0x38… 0x3F בהתאמה. בדוגמא של תוכנת I2C שסיפק 'I2C_APDS9960_TEST.ino' יהיה צורך לשנות את #define GESTURE_SENSOR_I2C_ADDRESS כך שיתאים לטווח כתובות זה.

• כל שאר המרכיבים יוצרים עבד Arduino Uno ויש להם את הפונקציות הבאות;

  • R1, T1, R2 ו- D1 מספקים כניסת איפוס למכשיר עבדים. כאן דופק גבוה פעיל ב- IC1 - P7 יאלץ את U1 לאפס.
  • R3, R4, הם נגדי הגבלת זרם עבור המכשיר המשובץ המתכנת קווי TX/RX.
  • C5 ו- R7 מאפשרים ל- Arduino IDE לתכנת U1 באופן אוטומטי באמצעות דופק בקו DTR של מכשיר FTDI מחובר.
  • R5 ו- R6 הם נגדי משיכה I2C ל- APDS9960 עם C6 המספק ניתוק מקומי של מסילת אספקה מקומית.
  • U1, C1, C2 ו- Q1 יוצרים את ה- Arduino Uno המשובץ והשעון שלו בהתאמה.
  • לבסוף C3 ו- C4 מספקים ניתוק מקומי של מסילת אספקה מקומית עבור U1.

שלב 2: סקירת תוכנה

הַקדָמָה

כדי לאסוף בהצלחה את קוד המקור הזה תזדקק לספריות הנוספות הבאות כדי לתכנת את Arduino Uno U1 המוטבע;

SparkFun_APDS9960.h

• מאת: סטיב קווין
• מטרה: זוהי גרסה מסולסלת של חיישן SparkFun APDS9960 המזלג מ- jonn26/SparkFun_APDS-9960_Sensor_Arduino_Library. יש לו כמה שינויים שיסייעו באיתור באגים ויש לו גלאי דה-רגיש להפחתת טריגרים מזויפים.
• מאת:

APDS9960_NonBlocking.h

• מאת: סטיב קווין
• מטרה: מספק ממשק נקי להטמעת יישום זה הבלתי חוסם של חיישן המחווה APDS9960 בקוד ה- Arduino שלך.
• מאת:

עיין בהוראות הבאות כיצד לתכנת מיקרו -בקר Arduino Uno (ATMega328P) מוטמע אם אינך מכיר כיצד להשיג זאת;

תכנות ATTINY85, ATTINY84 ו- ATMEGA328P: ARDUINO כספקית אינטרנט

סקירה פונקציונלית

מיקרו -בקר העבד המשובץ ATMega328P סוקר את קו INT מה- ADPS9960. כאשר שורה זו יורדת, מיקרו -הבקר קורא את רישומי ADPS9960 וקובע אם חוותה תוקף. אם זוהתה מחווה תקפה, הקוד למחווה זו 0x0 … 0x6, 0xF מוצב ביציאה B וה- 'nGestureAvailable' נקבע נמוך.

כאשר המכשיר הראשי רואה 'nGestureAvailable' פעיל, הוא קורא את הערך ביציאה B ואז מוריד את 'nGestureClear' נמוך באופן זמני כדי לאשר את קבלת הנתונים.

לאחר מכן מכשיר העבד מבטל את הטענה 'nGestureAvailable' גבוה ומנקה את הנתונים ביציאה B. תמונה 5 למעלה מציגה תפיסת מסך שנלקחה ממנתח לוגי במהלך מחזור זיהוי/קריאה מלא.

סקירת קוד

Pic 1 לעיל מפרט כיצד התוכנה ב- U1 העבד המשובץ Arduino Uno מתפקד, יחד עם Pic 2 כיצד שתי משימות הרקע/קדמה פועלות ביניהן. Pic 3 הוא קטע קוד המתאר כיצד להשתמש בספריית APDS9960_NonBlocking. Pic 4 נותן מיפוי בין סיכות דיגיטליות של Arduino Uno לבין סיכות חומרה בפועל ב- ATMega328P.

לאחר איפוס המיקרו -בקר העבד המשובץ מאתחל את ה- APDS9960 המאפשר לגילוי מחוות להפעיל את פלט ה- INT שלו ומגדיר את ה- I/O שלו, מצרף שגרת שירות מפסיקה (ISR) 'GESTURE_CLEAR ()' כדי להפריע את הווקטור INT0 (סיכה דיגיטלית 2, סיכה IC של חומרה 4), להגדיר אותו עבור טריגר קצה נופל. זה יוצר את הקלט nGestureClear מהמכשיר הראשי.

סיכת הפלט Interrupt 'INT' מ- APDS9960 מחוברת לפין דיגיטלי 4, חומרה IC פין 6 שמוגדרת ככניסה ל- U1.

קו האות 'nGestureAvailable' על פין דיגיטלי 7, PIN IC של חומרה מוגדר כפלט ומוגדר גבוה, לא פעיל (דה-טען).

לבסוף סיביות יציאה B 0 … 3 בהתאמה מוגדרות כפלט ומוגדרות נמוכות. אלה יוצרים את נגיסת הנתונים המייצגת את סוגי המחוות השונות שזוהו; None = 0x0, שגיאה = 0xF, למעלה = 0x1, למטה = 0x2, שמאל = 0x3, ימין = 0x4, קרוב = 0x5 ורחוק = 0x6.

משימת הרקע 'לולאה' מתוכננת, אשר בוחנת ללא הרף את פלט ה- APDS9960 Interrupt INT באמצעות קריאת סיכה דיגיטלית 4. כאשר יציאת INT מ- APDS9960 הופכת לפעילה נמוכה ומצביעה על כך שהחיישן הופעל, המיקרו -בקר מנסה לפרש כל מחווה על ידי קריאת 'readGesture () 'עם זה בעוד (1) {}; לולאה אין סופית.

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

ברגע שהמאסטר מזהה את הפלט 'nGestureAvailable' הפעיל, הוא קורא את הערך החדש הזה ומקפיץ את השפל הפעיל 'nGestureClear'. קצה נופל זה מפעיל את משימת החזית 'ISR GESTURE_CLEAR ()' שתוזמן לביצוע משימת הרקע 'לולאה', ניקוי יציאה B, 'bGestureAvailable' סמפור ופלט 'nGestureAvailable'.

משימת החזית 'GESTURE_CLEAR ()' מושעה כעת ומשימת הרקע 'לולאה' מתוזמנת מחדש. כעת ניתן לחוש מחוות נוספות מה- APDS9960.

על ידי שימוש במשימות חזית/רקע המופעלות באופן זה, הלולאה האינסופית הפוטנציאלית ב- 'readGesture ()' של התקן העבד לא תשפיע על פעולת המכשיר הראשי וגם לא תפריע לביצוע מכשיר העבדים. זה מהווה את הבסיס למערכת הפעלה פשוטה מאוד בזמן אמת (RTOS).

הערה: הקידומת 'n' פירושה נמוך נמוך או נטען כמו ב- 'nGestureAvailable'

שלב 3: בדיקת התקן חישה מחוות APDS9960 NonBlocking

הַקדָמָה

למרות שמודול APDS9960 מסופק עם +5v הוא משתמש בווסת +3v3 המשולב, כלומר קווי I2C תואמים +3v3 ולא +5v. זו הסיבה שבחרתי להשתמש ב- Arduino Due תואם +3v3 כבקר המיקרו לבדיקה, כדי למנוע את הצורך בשיפולי רמות.

אם ברצונך להשתמש ב- Arduino Uno בפועל, יהיה עליך להזיז את קווי I2C ברמה ל- U1. עיין במדריך הבא שבו צירפתי ערכת שקופיות שימושית (I2C_LCD_With_Arduino) אשר נותנת הרבה עצות מעשיות על השימוש ב- I2C.

בדיקת ממשק I2C

תמונות 1 ו -2 לעיל מראות כיצד להגדיר ולתכנת את המערכת עבור ממשק I2C. תחילה יהיה עליך להוריד ולהתקין את ספריית APDS9960_NonBlocking. פה

בדיקת ממשק מקביל

התמונות 3 ו -4 מפרטות את אותו הדבר עבור הממשק המקביל

שלב 4: מסקנה

כללי

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

שיפורים אפשריים

• הברור. כתוב מחדש את ספריית חיישן המחוות של APDS9960 כך שהיא לא תחסום.

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

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

שלב 5: הפניות

נדרש לתכנת הארדואינו המשובץ (ATMega328P - U1)

SparkFun_APDS9960.h

• מאת: סטיב קווין
• מטרה: זוהי גרסה מפונקת של חיישן SparkFun APDS9960 המזלג מ- jonn26/SparkFun_APDS-9960_Sensor_Arduino_Library. יש לו כמה שינויים שיסייעו באיתור באגים ויש לו גלאי דה-רגיש להפחתת טריגרים מזויפים.
• מאת:

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

APDS9960_NonBlocking.h

• מאת: סטיב קווין
• מטרה: מספק ממשק נקי להטמעת יישום זה הבלתי חוסם של חיישן המחווה APDS9960 בקוד ה- Arduino שלך.
• מאת:

מערכת הפעלה בזמן אמת

https://en.wikipedia.org/wiki/Real-time_operating_system

גיליון נתונים של APDS9960

https://cdn.sparkfun.com/assets/learn_tutorials/3/2/1/Avago-APDS-9960-datasheet.pdf