מצלמת צילום RaspberryPI - MagicBox: 13 שלבים (עם תמונות)

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

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

אחד בא, ויחד עם אשתי, אנו בונים את הדבר הזה.

איך זה עובד ?

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

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

הכל מתוכנת ב- Python, תוך שימוש במאגר המסגרות של PI - אין שימוש ב- Xorg, ללא GUI.

הנה סרטון של הפרויקט שעובד

אספקה

• פטל PI (אני משתמש בגרסה 2)
• מצלמת פטל PI (שימוש בגרסה 1)
• 3x לחצני לחיצה של כיפה גדולה
• צג TFT/LCD עם VGA/HDMI
• MDF
• צירי מתכת, ברגים וכו '.
• כלי עבודה חשמליים
• פנוי זמן והרבה כיף

שלב 1: בנה

לבנות את זה היה כיף. הרבה חיתוך, צביעה וקידוח.

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

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

שלב 2: מצלמה

מַצלֵמָה

המצלמה היא קופסה בעלת המידות הבאות: 60cm x 40cm x 30cm שלך יכול להיות קטן יותר, גדול יותר, זה תלוי בך. רק צריך להכיל את המסך שאתה הולך להשתמש בו. לוחות MDF נחתכו בלייזר במפעל Fablab המקומי. יש צורך ב -3 חורים מאחור - שני לחצני כיפה גדולים ואחד למסך. מלפנים 2 חורים - אחד ללחצן כיפה גדול וכיפה ועוד אחד - קטן יותר - למצלמת Raspberry PI. אין לי מדידות ספציפיות - רק דמיינו מצלמה והשתמשו בה.

שלב 3: צג

צג

תמיכת הצג נעשתה הוספת חתיכות עץ קטנות כדי לתמוך בה בתוך ממדיה.

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

שלב 4: קישוט

מכיוון שאני מאוד אוהב את הסגנון של ה- Fuji X-T30 שלי, הלכנו ועשינו משהו דומה.

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

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

שלב 5: תכנות

תכנות המצלמה היה אתגר, אבל זה היה סופר כיף.

אין GUI - זה פועל על CLI והוא פועל על גירסת Python 3.

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

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

ראשית, נתחיל בהגדרת ה- PI של פטל

שלב 6: הכנת ה- PI פטל

אני לא מתכוון להסביר כיצד להתקין Raspbian ב- Raspberry PI - יש הרבה הדרכות בחוץ, אפילו באתר הרשמי של Raspberry PI.

אתה רק צריך לקבל גישה ל- SSH אליו, או לחבר אותו למסך ולחבר מקלדת ועכבר.

הערה: כאשר אתה מתחיל במצלמת Raspberry PI, עליך לחבר אותו למסך. עד לשם, ניתן לבצע את כל השלבים באמצעות SSH.

לאחר אתחול ב- Raspberry PI שלך, עלינו לאפשר את מצלמת Raspberry PI. בואו נשתמש בכלי raspi-config לשם כך.

sudo raspi-config

1. בחר באפשרות 5 - אפשרויות ממשק
2. בחר P1 - הפעל/השבת חיבור למצלמת Raspberry PI
3. תגיד כן
4. עבור בסדר
5. בחר סיום
6. בחר כן כדי לאתחל כעת

לאחר האתחול, נוכל להמשיך

שלב 7: תוכנה

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

ראשית, אפשר להגדיר את Python 3 כברירת המחדל. עקוב אחר הקישור הזה כדי לדעת כיצד להגדיר אותו SYSTEM WIDE

ספריות:

• python-pil.imagetk לתפעל תמונות
• python-rpi.gpio כדי לגשת ל- PINIOs של GPIO
• python-picamera לגישה למצלמת Raspberry PI
• טוויפי כדי לשתף את התמונה בטוויטר
• facebook-sdk לשתף לדף פייסבוק

sudo apt-get install python3-pil.imagetk python3-rpi.gpio python3-picamera python3-tweepy python3-pip

השתמש בפיפט Python להתקנת facebook-sdk

sudo pip3 התקן facebook-sdk

שלב 8: תכנות - תצוגה מקדימה של מצלמה

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

התוכנית הקטנה שלנו (אנחנו הולכים לפתח תוכניות קטנות עד אחת גדולה בסוף) תציג את התצוגה המקדימה של המצלמה.

#!/usr/bin/env python

יבוא זמן ייבא פיקמרה מהזמן ייבא מצלמת שינה = picamera. PiCamera () # הגדר את הרזולוציה שאתה רוצה camera.resolution = (1280, 1024) camera.framerate = 24 camera.start_preview () נסה: while (True): sleep (1) למעט (KeyboardInterrupt, SystemExit): הדפס ("יוצא …") camera.stop_preview ()

כדי לנסות את זה פשוט בצע את זה

מצלמת פייתון Preview.py

תצוגה מקדימה של המצלמה עם תמונות למעלה

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

צור תמונת-p.webp" />

הקוד הבא יחפוף את 1-p.webp

ייבוא picameraf ייבוא PIL תמונה מעת עת ייבוא שינה עם picamera. PiCamera () כמצלמה: camera.resolution = (1920, 1080) camera.framerate = 24 camera.start_preview () # טען תמונה img = Image.open ('1-p.webp

נסה זאת:

python imageOverlay.py

בואו עכשיו ליצור ספירה לאחור עם תמונות כיסוי. כמו שיצרת את התמונה 1.png, צור עוד שתי תמונות עם 2 ו -3 בתוכן.

לאחר מכן, פשוט השתמש בקוד הבא:

לייבא פיקמרה

מיבוא PIL תמונה מעת עת ייבוא שינה עם picamera. PiCamera () כמצלמה: camera.resolution = (1280, 1024) camera.framerate = 24 camera.start_preview () # טען תמונה img1 = Image.open ('3.png') img2 = Image.open ('2.png') img3 = Image.open ('1.png') # create pad = Image.new ('RGB', (((img1.size [0] + 31) / / 32) * 32, ((img1.size [1] + 15) // 16) * 16,)) pad.paste (img1, (0, 0)) o = camera.add_overlay (pad.tobytes (), גודל = img1.size) o.alpha = 128 o.layer = 3 שינה (2) #להסיר שכבת כיסוי קודמת.הרחקת_החלפה (o) pad.paste (img2, (0, 0)) o = camera.add_overlay (pad. tobytes (), size = img2.size) o.alpha = 128 o.layer = 3 שינה (2) # הסר שכבת שכבה קודמת מצלמה. remove_overlay (o) pad.paste (img3, (0, 0)) o = מצלמה. add_overlay (pad.tobytes (), גודל = img3.size) o.alpha = 128 o.layer = 3 שינה (2)

כעת בצע זאת:

python imageOverlayCounter.py

וראה את הספירה לאחור

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

ייבוא picamerafrom ייבוא PIL תמונה מעת עת ייבוא שינה שינה מוגדרת Counter (): # load image img1 = Image.open ('3.png') img2 = Image.open ('2.png') img3 = Image.open ('1.-p.webp

נסה זאת:

picture pythonWithTimer.py

והנה יש לנו את יודה

שלב 9: תכנות - לחצן לחיצה על כיפה גדולה

כפתור לחיצת הכיפה הגדול הוא כפתור עגול גדול - עם קוטר של כ -100 מ מ בחוץ עם LED קטן. הוא אומר שהוא עובד ב -12 וולט, אבל 3.3 וולט של ה- RI פטל מספיק כדי להאיר אותו

השתמש בסכימה לבדיקה

הקוד:

מ- RIO יבוא GPIO

takeButton = 17 ledButton = 27 GPIO.setmode (GPIO. BCM) GPIO.setup (takeButton, GPIO. IN, GPIO. PUD_UP) GPIO.setup (ledButton, GPIO. OUT) #Light led GPIO.output (ledButton, True) # פונקציית חסימה GPIO.wait_for_edge (takeButton, GPIO. FALLING) הדפסה ("לחצן נלחץ") GPIO.output (ledButton, False) GPIO.cleanup ()

כמה הסברים על הקוד אחת הצורות של קבלת ערכים מ- GPIOS היא באמצעות הפרעות (אחר הוא סקר) - זיהוי קצה.

הקצה הוא שם המעבר מ- HIGH ל- LOW (קצה נופל) או LOW ל- HIGH (קצה עולה). כאשר ה- PIN אינו מחובר לשום דבר, כל קריאה לא תהיה מוגדרת. דרך לעקיפת הבעיה היא לקבל נגד למעלה/למטה ב- PIN האמור. ה- Raspberry PI מאפשר להגדיר נגדי משיכה למעלה/למטה באמצעות תוכנה.

השורה

GPIO.setup (takeButton, GPIO. IN, GPIO. PUD_UP)

מגדיר את ה- PIN הזה בדיוק בשביל זה - משוך למעלה

למה למשוך? ובכן, ללחצן לחיצת הכיפה הגדול יש 2 קודים - לחיצה לשבירה או לחיצה לביצוע (ממש כמו כפתורי הלחיצה הקטנים שמגיעים לעתים קרובות עם ערכות PI Arduino/Raspberry). חיברתי אותו ל- PIN של "לחץ כדי לעשות" של הכפתור. כאשר לוחצים עליו, המעגל נסגר והחשמל עובר (פתוח בדרך כלל).

השורה

GPIO.wait_for_edge (takeButton, GPIO. FALLING)

יחכה (בהשעיה למעשה את ביצוע התסריט) עד שיזהה את נפילת ה- PIN - שחרור הכפתור יוריד את זרימת החשמל וה- PIN יעלה מ -3.3 וולט ל 0 וולט

מספר ה- LED הוא רק כדי להדליק את הנורית בכפתור

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

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

ייבא פיקמרה מרגע ייבוא שינה מ- RPi ייבוא GPIO מיבוא PIL תמונה # הערה: זה מה שיהיה כפתור הביטול בתוכנית הראשית # אני פשוט משתמש בו כאן למען הבהירות בסרטון takeButton = 24 ledCancel = 5 GPIO.setmode (GPIO. BCM) GPIO.setup (takeButton, GPIO. IN, GPIO. PUD_UP) GPIO.setup (ledCancel, GPIO. OUT) def onLeds (): GPIO.output (ledCancel, True) שינה (1) def offLeds (): GPIO.output (ledCancel, False) # פונקציה לשכבת שכבה של התמונה def overCounter (): # load images img1 = Image.open ('3.png') img2 = Image.open ('2.png') img3 = Image.open ('1.png') # צור כיסוי # משמש עם img1 מכיוון שכולם באותו גודל כרית = Image.new ('RGB', (((img1.size [0] + 31) // 32) * 32, ((img1.size [1] + 15) // 16) * 16,)) # הדבק את שכבת העל - 3 pad.paste (img1, (0, 0)) ov = camera.add_overlay (pad.tobytes (), גודל = img1.size) ov.alpha = 200 # שכבה היא 3 מכיוון שתצוגה מקדימה של המצלמה נמצאת בשכבה 2 ov.layer = 3 שינה (1) camera.remove_overlay (ov) # הדבק את השכבה - 2 pad.paste (img2, (0, 0)) ov = camera.add_overlay (pad.tobytes (), size = img2.size) ov.alpha = 200 # שכבה היא 3 מכיוון שהתצוגה המקדימה של המצלמה נמצאת בשכבה 2 ov.layer = 3 שינה (1) camera.remove_overlay (ov) # הדבק את שכבת העל - כרית אחת. הדבק (img3, (0, 0)) ov = camera.add_overlay (pad.tobytes (), size = img3.size) ov.alpha = 200 # שכבה היא 3 מכיוון שתצוגה מקדימה של המצלמה היא בשכבה 2 ov.layer = 3 שינה (1) camera.remove_overlay (ov) מצלמה = picamera. PiCamera () camera.resolution = (1280, 1024) camera.framerate = 24 camera.start_preview () GPIO.wait_for_edge (takeButton, GPIO. FALLING) onLeds () overlayCounter () camera.capture ('pushTesting.jpg') camera.stop_preview () offLeds () GPIO.cleanup ()

קצת הסבר על הקוד

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

שלב 10: פרסם בטוויטר

כעת, נשתמש ב- Python וצייץ ציוץ!:) תצטרך תמונה כדי לפרסם - בחר בתבונה.

ראשית, עלינו לגשת ל- twitter API ולשם כך עלינו ליצור אפליקציה. עבור אל https://apps.twitter.com וצור יישום חדש.

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

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

השתמש בקוד הבא כדי לשלוח תמונה לחשבון הטוויטר שלך. אל תשכח למלא:

• מפתח_צרכן
• צרכן_סודי
• אסימון גישה
• access_token_secret

הודעת טוויטר היא הטקסט שיש לשלוח בציוץ.

jpg_foto_to_send היא תמונה שתצורף לציוץ. יש תמונה כלשהי באותה ספרייה כמו סקריפט Python ושנה את השם בקוד.

יבוא tweepy # הגדרות טוויטר def get_api (cfg): auth = tweepy. OAuthHandler (cfg ['consumer_key'], cfg ['consumer_secret']) auth.set_access_token (cfg ['access_token'], cfg ['access_token_secret']) החזר tweepy. API (auth) # שלח אל twitter def sendToTwitter (): cfg = {"consumer_key": "", "consumer_secret": "", "access_token": "", "access_token_secret": ""} api = get_api (cfg) # הודעת סטטוס tweet = "הודעת טוויטר" status = api.update_with_media ("jpg_foto_to_Send", ציוץ) sendToTwitter ()

בדוק את ציוץ הטוויטר שלך בעדכון הטוויטר שלך.

הנה הציוץ

או להלן:

#פטל PI MagicBox. צלמו, סקרו אותן ובחרו לשלוח אותן לטוויטר ולפייסבוק. מופעל על ידי פטל PI. @@ Raspberry_Pi#RaspberryPI#RaspberryPIProjectpic.twitter.com/cCL33Zjb8p

- ברונו ריקרדו סנטוס (@feiticeir0) 29 בפברואר 2020

שלב 11: שילוב של כמה אלמנטים

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

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

אנו מוסיפים תמונה נוספת, המציגה את הסמלים לפרסום ברשתות חברתיות

SelectOption-p.webp

Aenviar-p.webp

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

הקוד מצורף אם אתה מעדיף

זהו קוד הבדיקה הסופי לפני התוכנית הראשית.

# coding = utf-8 יבוא picamera יבוא _ תת-תהליך ייבוא thread כמו SP מעת עת ייבוא מ- RPi יבוא GPIO מ- PIL יבוא שרשור ייבוא תמונות # Twitter ייבוא twepy # ייבוא פייסבוק פייסבוק # לחצן לצלם takeButton = 17 # לחצן SocialNetwork socialNetworkButton = 23 # ביטול תמונה CancelButton = 24 # כפתור לצלם תמונה takePicButtonLed = 27 # כפתור פרסום לרשת החברתית LED postSNLed = 22 # לחצן ביטול LED CancelButtonLed = 5 GPIO.setmode (GPIO. BCM) GPIO.setup (takeButton, GPIO. IN, GPIO. PUD_UP) GPIO.setup (socialNetworkButton, GPIO. IN, GPIO. PUD_UP) GPIO.setup (cancelButton, GPIO. IN, GPIO. PUD_UP) GPIO.setup (takePicButtonLed, GPIO. OUT) GPIO.setup (postSNLed, GPIO. OUT) GPIO.setup (cancelButtonLed, GPIO. OUT) # הגדרות טוויטר def get_api (cfg): auth = tweepy. OAuthHandler (cfg ['consumer_key'], cfg ['consumer_secret']) auth.set_access_token (cfg ['access_token'], cfg ['access_token_secret']) החזר tweepy. API (auth) # שלח לטוויטר def sendToTwitter (): cfg = {"con sumer_key ":" "," consumer_secret ":" "," access_token ":" "," access_token_secret ":" "} api = get_api (cfg) # הודעת סטטוס tweet =" בדיקות ניתנות להנחיה של MagicBox. #MagicBox #RaspberryPI #Raspberry #Instructables "status = api.update_with_media (" pushTesting.jpg ", ציוץ) #Facebook AOth def get_api_facebook (cfg): graph = facebook. GraphAPI (cfg ['access_token']) #קבל אסימון דף פרסם כדף. תוכל לדלג על # הבאים אם ברצונך לפרסם את עצמך.] == cfg ['page_id']: page_access_token = page ['access_token'] graph = facebook. GraphAPI (page_access_token) גרף החזרה # שלח לפייסבוק def sendToFacebook (): # ערכים לגישה cfg = {"page_id": "", "access_token": ""} api = get_api_facebook (cfg) caption = "כיתוב התמונה" albumid = "" api.put_photo (image = open ("pushTesting.jpg", "rb"), caption = "כיתוב התמונה ") # Light only TakePicButtonLed def onlyTakePicLed (): GPIO.output (takePicButtonLed, True) GPIO.output (postSNLed, False) GPIO.output (cancelButtonLed, False) # Light only Cancel and כפתור Network Social Def def CancelPostLEDS (): GPI O.output (takePicButtonLed, False) GPIO.output (postSNLed, True) GPIO.output (cancelButtonLed, True) # מהבהב לצלם LED תוך ספירה לאחור של ספירת TimerPicture (): GPIO.output (takePicButtonLed, True) שינה (0.5) GPIO.output (takePicButtonLed, False) שינה (0.5) GPIO.output (takePicButtonLed, True) שינה (0.5) GPIO.output (takePicButtonLed,False) sleep (0.5) GPIO.output (takePicButtonLed, True) sleep (0.5) GPIO.output (takePicButtonLed, False) # Blink postSNLed בעת פרסום לרשתות חברתיות def blinkPosting (stop_event): # התחל בעוד (לא stop_event.is_set ()): הדפסה ("כבוי") GPIO.output (postSNLed, False) שינה (0.5) הדפסה ("on") GPIO.output (postSNLed, True) sleep (0.5) טיימר def (): GPIO.output (takePicButtonLed, True) sleep (1) GPIO.output (postSNLed, True) sleep (1) GPIO.output (cancelButtonLed, True) sleep (1) def showAllLeds (): GPIO.output (takePicButtonLed, True) GPIO.output (postSNLed, True) GPIO.output (cancelButtonLed, True) # הצג תצוגה מקדימה בשכבה 1 def displayPreview (imgName): # מכיוון שתצוגת ה- PIL היא זבל # אנו משתמשים בשכבת -על מהמצלמה כדי להציג # התצוגה המקדימה img = Image.open (imgName) ריפוד = Image.new ('RGB', (((img.size [0] + 31) // 32) * 32, ((img.size [1] + 15) // 16) * 16,)) padding.paste (img, (0, 0)) ov = camera.add_overlay (padding.tobytes (), size = img.size) ov.layer = 1 # הצג תצוגה מקדימה בשכבה 3 def displayPreview3 (imgName): # מכיוון שתצוגת ה- PIL היא חרא # אנו משתמשים בשכבת העל מהמצלמה כדי להציג # תצוגה מקדימה img = Image.open (imgName) padding = Image.new ('RGB', ((((img.size [0] + 31) // 32) * 32, ((img.size [1] + 15) // 16) * 16,)) padding.paste (img, (0, 0)) ov = camera.add_overlay (padding.tobytes (), size = img.size) ov.alpha = 150 ov.layer = 3 חזור ov # שכבת פונקציות Social overwork def overlaysn (): imgsn = Image.open ('SelectOption.png') # צור משטח כיסוי = Image.new ('RGB', (((imgsn.size [0] + 31) // 32) * 32, ((imgsn.size [1] + 15) // 16) * 16,)) # הדבק את משטח ההשכבה. הדבק (imgsn, (0, 0)) ov = camera.add_overlay (pad.tobytes (), גודל = imgsn.size) ov.alpha = 100 ov.layer = 3 החזרה ov # פונקציה לשכבה image def overlayCounter (): #load images img1 = Image.open ('3.png') img2 = Image.open ('2.png') img3 = Image.open ('1.png') # צור שכבת על # משמש עם img1 מכיוון שכולם באותו גודל כרית = Image.new ('RGB', (((img1.size [0] + 31) // 32) * 32, ((img1.size [1] + 15) // 16) * 16,)) # הדבק את שכבת העל - 3 pad.paste (img1, (0, 0)) ov = camera.add_overlay (pad.tobytes (), size = img1.size) ov.alpha = 200 # שכבה היא 3 מכיוון שהתצוגה המקדימה של המצלמה נמצאת בשכבה 2 ov.layer = 3 שינה (1) camera.remove_overlay (ov) # הדבק את השכבה - 2 כרית. הדבק (img2, (0, 0)) ov = camera.add_overlay (pad.tobytes (), size = img2.size) ov.alpha = 200 # שכבה היא 3 מכיוון שהתצוגה המקדימה של המצלמה נמצאת בשכבה 2 ov.layer = 3 שינה (1) camera.remove_overlay (ov) # הדבק שכבת העל - 1 pad.paste (img3, (0, 0)) ov = camera.add_overlay (pad.tobytes (), size = img3.size) ov.alpha = 200 # שכבה היא 3 מכיוון שהתצוגה המקדימה של המצלמה נמצאת בשכבה 2 ov.layer = 3 שינה (1) camera.remove_overlay (ov) # פונקציה ראשית # מסך נקה כך שלא יהיו הודעות האתחול # כנראה שעדיף לעשות זאת ב- bash tmp = sp.call ('ברור', shell = True) מצלמה = picamera. PiCamera () camera.resolution = (1280, 1024) camera.framerate = 24 camera.brightness = 55 camera.sharpness = 0 camera.contrast = 0 #camera.exposure_co mpensation = 0 #camera.exposure_mode = 'auto' #camera.meter_mode = 'average' #בדיקה כאן נסה: בעוד (נכון): camera.start_preview () #הצג נורית בלבד לצלם בלבד TakePicLed () #המתן עד שהכפתור ייקח תמונה GPIO.wait_for_edge (takeButton, GPIO. FALLING) # התחל שרשור לספור עם הלדים בזמן שהתמונות מוצגות. לא # היה אותו _thread.start_new_thread (countingTimerPicture, ()) # הצג את שכבת התמונות במצלמת שכבת התמונה מצלמה () # הצג את כל נוריות LED בעת צילום המצלמה showAllLeds () camera.capture ('pushTesting.jpg'). stop_preview () # display display imagePreview ('pushTesting.jpg') # Show overlay oo = overlaysn () # הצג נוריות לביטול או פרסם ברשתות חברתיות ביטול PostLEDS () GPIO.add_event_detect (socialNetworkButton, GPIO. FALLING) GPIO.add_event_detect (ביטול, GPIO. FALLING) בעוד (נכון): אם GPIO.event_detecte d (socialNetworkButton): camera.remove_overlay (oo) GPIO.output (cancelButtonLed, False) o = displayPreview3 ('Aenviar.png') #print "לחצן רשתות חברתיות" sendToTwitter () sendToFacebook () camera.remove_overlay (o) הפסקה אם GPIO.event_detected (cancelButton): #print "ביטול" camera.remove_overlay (oo) break # reset GPIOS GPIO.remove_event_detect (socialNetworkButton) GPIO.remove_event_detect (cancelButton) GPIO.remove_event_detect (takeButton) camera (stopButton) "יצא …") #offLeds () GPIO.cleanup ()

שלב 12: חיווט

החיווט הוא רק חיווט כפתורי לחיצת הכיפה הגדולה ל- PI של פטל.

פשוט עקוב אחר סכמטי Fritzing.

החיבורים הם:

חיבור RPI GPIO PIN GND כפתור לחיצה ירוק GND (#3) GND כפתור לחיצה צהוב GND (#9) כפתור לחיצה כחול GND GND (#39) צלם תמונה (לחצן לחיצה כחול "Push to make") 17 (BCM) פרסם לרשתות חברתיות (Push Push) כפתור "דחיפה לביצוע") 23 (BCM) ביטול (כפתור לחיצה צהוב "דחיפה לביצוע") 24 (BCM) כפתור לחיצה כחול LED27 (BCM) כפתור לחיצה ירוק LED22 (BCM) כפתור לחיצה צהוב LED5 (BCM)

כיווץ החום גם הוא מקודד בצבע

• שחור הוא חיבורי GND
• צהוב הם חיבורים "לדחוף ליצור"
• כחול הם חיבורי LED

מספרי GPIO. BCM לעומת חיבורי GPIO. BOARD

מכיוון שהקשרים שלי הם BCM, אני חושב שעכשיו זה זמן טוב לדבר על זה ועל ההבדל בין BCM ל- BOARD.

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

GPIO. BCM מתייחס למספרי ה- PIN כפי ש- Broadcom SOC רואה אותם. סביר להניח שזה ישתנה לאורך גירסאות חדשות יותר של ה- Raspberry PI.

באתר pinout.xyz, מספרי הלוח הם אלה שנמצאים ממש ליד הפינים וה- BCM מופנים כך - BCM X (כאשר X הוא המספר)

שלב 13: ה- MagicBox

הקוד המצורף לשלב זה הוא הסופי.

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

#!/bin/bash

cd/home/pi/magicbox python MagicBox.py

הפוך אותו להפעלה

chmod +x start_magicbox.sh

כעת, קראו לזה ב- /etc/rc.local, ממש לפני היציאה 0 ליציאה

sudo vi /etc/rc.local

/home/pi/magicbox/start_magicbox.sh &

שמור וצא.

כעת, עם כל אתחול מחדש, תוכנית Python תבוצע

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

• 1. png
• 2. png
• 3. png
• Aenviar.png
• SelectOption.png

אתה יכול להשיג את כל הקבצים האלה ב github של MagicBox.