RaspberryPI Fotokamera - MagicBox - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-31 10:15

Vor einiger Zeit hatte ich die verrückte Idee, aus einem Raspberry PI eine Fotomaschine zu bauen. In meiner Stadt gab es eine kleine Show, bei der die Leute hingingen und zeigten, was sie mit Elektronik, Computern usw. machten oder herstellen ließen. Ich war wie ein Maker Faire für arme Leute, aber auf lokaler Ebene.

Einer stand kurz bevor, und zusammen mit meiner Frau bauen wir dieses Ding.

Wie funktioniert es ?

Sie drücken die blaue Taste - sie beginnt zu blinken - und nach 3 Sekunden wird ein Bild aufgenommen. Auf der anderen Seite der Kamera befindet sich ein Monitor, der einen Countdown anzeigt und nach der Aufnahme die Vorschau des Fotos.

Sie können es jetzt an Twitter und Facebook senden oder abbrechen und es erneut versuchen. So einfach ist das.

Alles ist in Python programmiert und verwendet den PI-Framebuffer - Es wird kein Xorg, keine GUI verwendet.

Hier ist ein Video von der Projektarbeit

Lieferungen

• Raspberry PI (ich verwende Version 2)
• Raspberry PI-Kamera (mit Version 1)
• 3x Big Dome Druckknöpfe
• TFT/LCD-Monitor mit VGA/HDMI
• MDF
• Metallscharniere, Schrauben, etc..
• Elektrowerkzeuge
• Freizeit und viel Spaß

Schritt 1: Erstellen

Der Aufbau hat Spaß gemacht. Viel Schneiden, Lackieren und Bohren.

Für den Aufbau der Grundstruktur der Kamera habe ich MDF-Platten verwendet. Sie sind leicht und einfach zu verarbeiten. Außerdem war es eine Holzart, die die Lasermaschine im örtlichen Fablab schneiden konnte.

Der Zugang zu den Kabeln im Inneren wurde von der Monitorseite aus hergestellt, wobei hydraulische Scharniere verwendet wurden, damit sie beim Anheben des Monitors helfen konnten.

Schritt 2: Kamera

Kamera

Die Kamera ist eine Box mit folgenden Abmessungen: 60cm x 40cm x 30cm Deine kann kleiner oder größer sein, es liegt an Dir. Sie müssen nur den Monitor aufnehmen, den Sie verwenden werden. Die MDF-Platten wurden im lokalen Fablab lasergeschnitten. Es werden 3 Löcher auf der Rückseite benötigt - zwei große Dome-Druckknöpfe und einer für den Monitor. Vorne 2 Löcher - eines für einen großen Dome-Taster und ein weiteres - kleineres - für die Raspberry PI Kamera. Ich habe keine spezifischen Messungen - stellen Sie sich einfach eine Kamera vor und verwenden Sie diese.

Schritt 3: Überwachen

Monitor

Der Monitorträger wurde mit kleinen Holzstücken hergestellt, um ihn innerhalb seiner Abmessungen zu unterstützen.

Es wurde vom Kunststoffgehäuse abgezogen und mit Schrauben befestigt. Um das Anheben zu erleichtern, wurden zwei hydraulische Scharniere (gebraucht) verwendet.

Schritt 4: Dekorieren

Da mir der Stil meiner Fuji X-T30 sehr gut gefällt, haben wir etwas Ähnliches gemacht.

Zuerst haben wir es mit Schaum bedeckt und als nächstes haben wir es schwarz lackiert. Nach dem Lackieren haben wir die silbernen Teile mit Alufolie versehen und eingepackt

Um das Objektiv zu simulieren, haben wir nur eine runde Tupperware verwendet, in der wir ein kleines Loch für das Raspberry PI-Kameramodul gemacht haben.

Schritt 5: Programmierung

Die Programmierung der Kamera war eine Herausforderung, aber es hat super viel Spaß gemacht.

Es gibt keine GUI - dies läuft auf der CLI und es läuft auf Python Version 3.

Ich habe zunächst mit dem Testen und Programmieren der Schaltflächen begonnen, als nächstes habe ich Bilder mit den bereits bereitgestellten Tools und der Python-API gemacht. Ich ging dann dazu über, Bilder in der Kameraausgabe (für den Countdown) zu überlagern und als nächstes mit Twitter und Facebook zu interagieren.

Nachdem ich mich mit all dem wohl gefühlt hatte, wie ein Puzzle, habe ich alle Teile zusammengebaut. Hier drin gehen wir mit dem gleichen Prozess vor. Fangen Sie langsam und klein an und gehen Sie zu schnell und groß.

Beginnen wir zunächst mit der Konfiguration des Raspberry PI

Schritt 6: Vorbereitung des Raspberry PI

Ich werde nicht erklären, wie man Raspbian auf dem Raspberry PI installiert - es gibt viele Tutorials, sogar auf der offiziellen Raspberry PI-Website.

Sie müssen nur über SSH-Zugriff darauf zugreifen oder es an einen Monitor anschließen und eine Tastatur und eine Maus anschließen.

HINWEIS: Wenn Sie mit der Raspberry PI-Kamera beginnen, müssen Sie sie an einen Monitor anschließen. Bis dahin können alle Schritte mit SSH durchgeführt werden.

Nach dem Booten in Ihrem Raspberry PI müssen wir die Raspberry PI-Kamera aktivieren. Lassen Sie uns dafür das raspi-config-Tool verwenden.

sudo raspi-config

1. Wählen Sie Option 5 - Schnittstellenoptionen
2. Wählen Sie P1 - Verbindung zur Raspberry PI-Kamera aktivieren/deaktivieren
3. Sag ja
4. für OK
5. Wählen Sie Finish
6. Wählen Sie Ja, um jetzt neu zu starten

Nach dem Neustart können wir fortfahren

Schritt 7: Software

Wir müssen einige Python-Bibliotheken installieren. Dies wurde für die neueste Raspbian-Version aktualisiert - Buster

Legen wir zunächst Python 3 als Standard fest. Folgen Sie diesem Link, um zu erfahren, wie Sie es SYSTEM WIDE einrichten

Bibliotheken:

• python-pil.imagetk um Bilder zu manipulieren
• python-rpi.gpio, um auf die GPIO-PINS zuzugreifen
• python-picamera für den Zugriff auf die Raspberry PI-Kamera
• Tweepy, um das Foto auf Twitter zu teilen
• facebook-sdk zum Teilen auf einer Facebook-Seite

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

Verwenden Sie Python pip, um facebook-sdk zu installieren

sudo pip3 installiere facebook-sdk

Schritt 8: Programmierung - Kameravorschau

Eine der Anforderungen, die ich an dieses Projekt stellte, war, dass dieses Programm im CLI-Modus ausgeführt werden sollte. Wir müssen also das Kamerabild auf der Konsole anzeigen. Verwenden wir dazu Python Picamera. Danach verwenden wir pil.imagetk, um ein Overlay über der Kameravorschau anzuzeigen

Unser kleines Programm (wir werden kleine Programme entwickeln, bis am Ende ein großes) wird die Kameravorschau anzeigen.

#!/usr/bin/env python

Zeit importieren Picamera aus Zeit importieren Schlaf importieren camera = picamera. PiCamera() # Gewünschte Auflösung einstellen camera.resolution = (1280, 1024) camera.framerate = 24 camera.start_preview() try: while (True): sleep(1) außer (KeyboardInterrupt, SystemExit): print ("Exiting…") camera.stop_preview()

Um es auszuprobieren, führe es einfach aus

Python-KameraPreview.py

Vorschau der Kamera mit Bildern oben

Da ich vor der Aufnahme einen Countdown anzeigen wollte, brauchte ich Bilder, die die Kameravorschau überlappen.

Erstellen Sie ein PNG-Bild (oder verwenden Sie die hier enthaltenen - speichern Sie sie im Speicherverzeichnis der Skripte) - und stellen Sie den Hintergrund transparent ein. Ich habe ein PNG-Bild mit der Nummer 1 mit einer Auflösung von 256x512 Pixel erstellt. Ich habe es 1-p.webp" />

Der folgende Code überlappt 1-p.webp

import picamerafrom PIL import Image from time import sleep mit picamera. PiCamera() als Kamera: camera.resolution = (1920, 1080) camera.framerate = 24 camera.start_preview() # Bild laden img = Image.open('1-p.webp

Versuch es:

python imageOverlay.py

Lassen Sie uns nun einen Countdown mit Overlay-Bildern erstellen. Erstellen Sie, wie Sie das 1.png-Bild erstellt haben, zwei weitere Bilder mit 2 und 3 darin.

Verwenden Sie danach einfach den folgenden Code:

Pikamera importieren

from PIL import Image from time import sleep mit picamera. PiCamera() als Kamera: camera.resolution = (1280, 1024) camera.framerate = 24 camera.start_preview() # Bild laden 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(), size=img1.size) o.alpha = 128 o.layer = 3 sleep(2) #Entferne das vorherige Overlay camera.remove_overlay(o) pad.paste(img2, (0, 0)) o = camera.add_overlay(pad. tobytes(), size=img2.size) o.alpha = 128 o.layer = 3 sleep(2) # vorheriges Overlay entfernen camera.remove_overlay(o) pad.paste(img3, (0, 0)) o = Kamera. add_overlay(pad.tobytes(), size=img3.size) o.alpha = 128 o.layer = 3 sleep(2)

Führen Sie es nun aus:

python imageOverlayCounter.py

Und den Countdown sehen

Wow - Etwas viel Code und kein Bild gemacht… Lassen Sie uns das lösen, indem wir alles miteinander kombinieren - Vorschau der Kamera, Countdown und Foto machen

import picamerafrom PIL import Image from time import sleep def overlayCounter(): # load image 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,)) # Überlagerung einfügen - 3 pad.paste(img1, (0, 0)) o = camera.add_overlay(pad.tobytes(), size=img1.size) o.alpha = 128 o.layer = 3 sleep(1) # Vorheriges Overlay entfernen camera.remove_overlay(o) # Overlay einfügen - 2 pad.paste(img2, (0, 0)) o = camera.add_overlay(pad.tobytes(), size=img2.size) o.alpha = 128 o.layer = 3 sleep(1) #remove previous overlay camera.remove_overlay(o) # füge das Overlay ein - 3 pad.paste(img3, (0, 0)) o = camera.add_overlay(pad. tobytes(), size=img3.size) o.alpha = 128 o.layer = 3 sleep(1) camera.remove_overlay(o) camera = picamera. PiCamera() camera.resolution = (1280, 1024) camera.framerate = 24 camera.start_preview() overlayCounter() camera.capture('testingCounter.jpg') camera.stop_preview()

Versuch es:

python pictureWithTimer.py

Und hier haben wir Yoda

Schritt 9: Programmierung - Big Dome-Drucktaste

Der große Dome-Taster ist ein großer runder Taster - mit ca. 100mm Außendurchmesser mit einer kleinen LED. Es heißt, es funktioniert mit 12 V, aber die 3,3 V des Raspberry PI reichen aus, um es zu leuchten

Verwenden Sie den Schaltplan zum Testen

Der Code:

aus RPi importieren GPIO

takeButton = 17 ledButton = 27 GPIO.setmode(GPIO. BCM) GPIO.setup(takeButton, GPIO. IN, GPIO. PUD_UP) GPIO.setup(ledButton, GPIO. OUT) #Licht LED GPIO.output(ledButton, True) # Blockierfunktion GPIO.wait_for_edge(takeButton, GPIO. FALLING) print ("Button Pressed") GPIO.output(ledButton, False) GPIO.cleanup()

Einige Erklärungen des Codes Eine der Formen des Abrufens von Werten von GPIOS ist durch Interrupts (andere ist Polling) - Flankenerkennung.

Die Flanke bezeichnet den Übergang von HIGH nach LOW (fallende Flanke) bzw. LOW nach HIGH (steigende Flanke). Wenn die PIN mit nichts verbunden ist, sind alle Lesevorgänge undefiniert. Eine Problemumgehung besteht darin, einen Pull-Up/Down-Widerstand in der PIN zu haben. Der Raspberry PI ermöglicht es, Pull-Up/Down-Widerstände per Software zu konfigurieren.

Die Linie

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

konfiguriert diese PIN, um genau das zu tun - hochziehen

Warum hochziehen? Nun, der große Dome-Druckknopf hat 2 PINs - Push to Break oder Push to Make (genau wie die kleinen Druckknöpfe, die oft mit Arduino / Himbeer-PI-Kits geliefert werden). Ich habe es mit der "Push-to-Make"-PIN der Taste verdrahtet. Beim Drücken schließt sich der Stromkreis und der Strom fließt (normalerweise geöffnet).

Die Linie

GPIO.wait_for_edge(takeButton, GPIO. FALLING)

wartet (und unterbricht effektiv die Ausführung des Skripts), bis es das Fallen der PIN erkennt - das Loslassen der Taste unterbricht den Stromfluss und die PIN wird von 3,3 V auf 0 V geändert

Die LED-PIN dient nur zum Aufleuchten der LED auf der Taste

Weitere Informationen zu Druckschaltern in Arduino-Tutorials, Wikipedia zu Push-to-Make oder Push-to-Break und GPIO-Interrupts

Kombinieren wir nun einen Taster mit der Kamera - Machen Sie ein Bild nur, wenn der Taster gedrückt wird

Picamerafrom time importieren Sleep von RPi importieren GPIO von PIL importieren Image # HINWEIS: Dies ist die Schaltfläche zum Abbrechen im Hauptprogramm # Ich verwende sie hier nur aus Gründen der Übersichtlichkeit im Video 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) sleep(1) def offLeds (): GPIO.output(ledCancel, False) # Funktion zum Überlagern von Bildern def overlayCounter(): #Bilder laden img1 = Image.open('3.png') img2 = Image.open('2.png') img3 = Image.open('1.png') # Überlagerung erstellen # Wird mit img1 verwendet, da alle die gleiche Größe haben pad = Image.new('RGB', (((img1.size[0] + 31) // 32) * 32, ((img1.size[1] + 15) // 16) * 16,)) # Überlagerung einfügen - 3 pad.paste(img1, (0, 0)) ov = camera.add_overlay(pad.tobytes (), size=img1.size) ov.alpha = 200 # Layer ist 3, weil die Kameravorschau auf Layer 2 liegt ov.layer = 3 sleep(1) camera.remove_overlay(ov) # Overlay einfügen - 2 pad.paste(img2, (0, 0)) ov = camera.add_overlay(pad.tobytes(), size=img2.size) ov.alpha = 200 # Layer ist 3, weil die Kameravorschau auf Layer 2 liegt ov.layer = 3 sleep(1) camera.remove_overlay(ov) # Überlagerung einfügen - 1 pad.paste(img3, (0, 0)) ov = camera.add_overlay(pad.tobytes(), size=img3.size) ov.alpha = 200 # Ebene ist 3, weil die Kameravorschau auf Schicht 2 ov.layer = 3 sleep(1) camera.remove_overlay(ov) camera = 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()

Ein bisschen Code-Erklärung

Es startet die Kameravorschau und wartet dort, bis eine Taste gedrückt wird. Nach dem Drücken der Taste leuchtet die LED und der Countdown beginnt. Am Ende wird das Bild aufgenommen und die LED ausgeschaltet

Schritt 10: Auf Twitter posten

Jetzt werden wir Python verwenden und einen Tweet twittern!:) Du benötigst ein Bild zum Posten – wähle mit Bedacht aus.

Zuerst müssen wir auf die Twitter-API zugreifen und dafür eine APP erstellen. Gehen Sie zu https://apps.twitter.com und erstellen Sie eine neue Anwendung.

Sie müssen ein Entwicklerkonto beantragen. Füllen Sie einige Fragen aus und bestätigen Sie Ihre E-Mail-Adresse. Danach können Sie eine neue APP erstellen.

Navigieren Sie nach dem Erstellen der APP zu Keys and Tokens und generieren Sie ein Access Token und Access Token Secret. Ein Fenster mit den Schlüsseln wird NUR EINMAL angezeigt - DIESE KOPIEREN UND FÜR SPÄTER SPEICHERN.

Verwenden Sie den folgenden Code, um ein Bild an Ihr Twitter-Konto zu senden. Vergessen Sie nicht auszufüllen:

• Consumer_key
• Consumer_Secret
• Zugangstoken
• access_token_secret

Twitter-Nachricht ist der Text, der im Tweet gesendet werden soll.

jpg_foto_to_send ist ein Bild, das an den Tweet angehängt wird. Bitte haben Sie ein Bild im selben Verzeichnis wie das Python-Skript und ändern Sie den Namen im Code.

import tweepy # Twitter-Einstellungen 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) # An Twitter senden def sendToTwitter(): cfg = { "consumer_key": "", "consumer_secret": "", "access_token": "", "access_token_secret": "" } api = get_api(cfg) # Statusnachricht tweet = "Twitter-Nachricht" status = api.update_with_media("jpg_foto_to_Send", tweet) sendToTwitter()

Überprüfen Sie Ihren Twitter-Feed auf Ihren Tweet.

Hier ist der Tweet

Oder unten:

#RaspberryPI MagicBox. Nehmen Sie Bilder auf, überprüfen Sie sie und senden Sie sie an Twitter und Facebook. Angetrieben von Raspberry PI. @@Raspberry_Pi#RaspberryPI#RaspberryPIProject

- Bruno Ricardo Santos (@feiticeir0) 29. Februar 2020

Schritt 11: Einige Elemente kombinieren

Lassen Sie uns nun den Big Dome Push-Button kombinieren, ihn drücken, herunterzählen, ein Bild machen, entscheiden, ob wir es an Twitter senden oder nicht.

Wir fügen ein weiteres Overlay-Bild hinzu und verwenden alle drei Schaltflächen. Wenn das Bild aufgenommen wird, leuchten alle LEDs der 3 Tasten auf.

Wir fügen ein weiteres Bild hinzu, das die Symbole zum Posten in sozialen Netzwerken zeigt

SelectOption-p.webp

Aenviar-p.webp

Im Video ist der blaue Taster (vorne der Kamera) nicht zu sehen, aber die LED leuchtet und sie beginnt zu blinken, sobald sie gedrückt wird.

Der Code ist beigefügt, wenn Sie es vorziehen

Dies ist der letzte Testcode vor dem Hauptprogramm.

# encoding=utf-8 import picamera import _thread import subprocess as sp from time import sleep from RPi import GPIO from PIL import image import threading # Twitter import tweepy # Facebook import facebook # Button zum fotografieren takeButton = 17 # SocialNetwork Button socialNetworkButton = 23 # Abbrechen Bild abbrechenButton = 24 # Bild aufnehmen Taste LED takePicButtonLed = 27 # In Sozialem Netzwerk posten LED postSNLed = 22 # Abbrechen Taste LED AbbrechenButtonLed = 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) GPIO.setup(cancelButtonLed, GPIO. OUT) # Twitter-Einstellungen def get_api(cfg): auth = tweepy. OAuthHandler(cfg['consumer_key'], cfg['consumer_secret']) auth.set_access_token(cfg['access_token'], cfg['access_token_secret']) return tweepy. API(auth) # An Twitter senden def sendToTwitter(): cfg = { "con sumer_key": "", "consumer_secret": "", "access_token": "", "access_token_secret": "" } api = get_api(cfg) # Statusmeldung tweet = "MagicBox instructable testing. #MagicBox #RaspberryPI #Raspberry #Instructables" status = api.update_with_media("pushTesting.jpg", tweet) # Facebook AOth def get_api_facebook(cfg): graph = facebook. GraphAPI(cfg['access_token']) # Seiten-Token abrufen an als Seite posten. Sie können Folgendes # überspringen, wenn Sie als Sie selbst posten möchten. resp = graph.get_object('me/accounts') page_access_token = Keine für Seite in resp['data']: if page['id'] == cfg['page_id']: page_access_token = page['access_token'] graph = facebook. GraphAPI(page_access_token) return graph # An Facebook senden def sendToFacebook(): #Werte für den Zugriff cfg = { "page_id": "", "access_token": "" } api = get_api_facebook(cfg) caption = "Bild mit Untertiteln versehen" albumid = "" api.put_photo(image=open("pushTesting.jpg", "rb"), caption="Bild mit Untertiteln ") # Nur Licht TakePicButtonLed def onlyTakePicLed(): GPIO.output(takePicButtonLed, True) GPIO.output(postSNLed, False) GPIO.output(cancelButtonLed, False) # Nur Licht Abbrechen und SocialNetwork-Taste def CancelPostLEDS(): GPI O.output(takePicButtonLed, False) GPIO.output(postSNLed, True) GPIO.output(cancelButtonLed, True) # Blinkt die Aufnahme-LED während des Countdowns def countingTimerPicture(): GPIO.output(takePicButtonLed, True) sleep(0.5) GPIO.output(takePicButtonLed, False) sleep(0.5) GPIO.output(takePicButtonLed, True) sleep(0.5) GPIO.output(takePicButtonLed,False) sleep(0.5) GPIO.output(takePicButtonLed, True) sleep(0.5) GPIO.output(takePicButtonLed, False) # PostSNLed beim Posten in sozialen Netzwerken blinken def blinkPosting(stop_event): # Start while (not stop_event.is_set())): print ("off") GPIO.output(postSNLed, False) sleep(0.5) print ("on") GPIO.output(postSNLed, True) sleep(0.5) def timer(): 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) # Eine Vorschau auf Layer 1 anzeigen def displayPreview(imgName): # Da die PIL-Bildershow ein Mist ist, verwenden wir das Overlay der Kamera, um # die Vorschau anzuzeigen 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.layer = 1 # Vorschau auf Ebene anzeigen 3 def displayPreview3(imgName): # Da die PIL-Bildershow ein Mist ist # verwenden wir das Overlay der Kamera, um # die Vorschau anzuzeigen 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 return ov # Funktion overlaySocialNetwork def overlaysn(): imgsn = Image.open('SelectOption.png') # Create Overlay-Pad = Image.new('RGB', (((imgsn.size[0] + 31) // 32) * 32, ((imgsn.size[1] + 15) // 16) * 16,)) # Einfügen des Overlays pad.paste(imgsn, (0, 0)) ov = camera.add_overlay(pad.tobytes(), size=imgsn.size) ov.alpha = 100 ov.layer = 3 return ov # Funktion zum Overlay image def overlayCounter(): #load images img1 = Image.open('3.png') img2 = Image.open('2.png') img3 = Image.open('1.png') # Überlagerung erstellen # Wird mit img1 verwendet, da alle die gleiche Größe haben pad = Image.new('RGB', (((img1.size[0] + 31) // 32) * 32, ((img1.size[1] + 15) // 16) * 16,)) # Überlagerung einfügen - 3 pad.paste(img1, (0, 0)) ov = camera.add_overlay(pad.tobytes(), size=img1.size) ov.alpha = 200 # Layer ist 3, weil sich die Kameravorschau auf Layer 2 befindet ov.layer = 3 sleep(1) camera.remove_overlay(ov) # das Overlay einfügen - 2 pad.paste(img2, (0, 0)) ov = camera.add_overlay(pad.tobytes(), size=img2.size) ov.alpha = 200 # Layer ist 3, weil die Kameravorschau auf Layer 2 liegt ov.layer = 3 sleep(1) camera.remove_overlay(ov) # einfügen das Overlay - 1 pad.paste(img3, (0, 0)) ov = camera.add_overlay(pad.tobytes(), size=img3.size) ov.alpha = 200 # Ebene ist 3, weil sich die Kameravorschau auf Ebene 2 befindet ov.layer = 3 sleep(1) camera.remove_overlay(ov) # Hauptfunktion # Bildschirm leeren, damit die Boot-Meldungen nicht vorhanden sind # wahrscheinlich könnte es besser sein, dies in bash zu tun tmp = sp.call('clear', shell=True) camera = 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' # Testen Sie hier try: while (True): camera.start_preview() #Show LED Only for Take Picture onlyTakePicLed() # Warten Sie auf die Schaltfläche zum Aufnehmen Bild GPIO.wait_for_edge(takeButton, GPIO. FALLING) # Starte einen Thread, um mit den LEDs zu zählen, während die Bilder angezeigt werden # Könnte wahrscheinlich in der OverlayCounter-Funktion verwendet werden, # weil es auch Timer zum Anzeigen der Bilder hat, aber die LED-Effekte wäre nicht # gleich _thread.start_new_thread (countingTimerPicture, ()) # Zeigen Sie die Bilderüberlagerung in der Kamera an. stop_preview() #display image displayPreview('pushTesting.jpg') # Overlay anzeigen oo = overlaysn() # LEDs zum Abbrechen oder Posten in sozialen Netzwerken anzeigen cancelPostLEDS() GPIO.add_event_detect(socialNetworkButton, GPIO. FALLING) GPIO.add_event_detect(cancelButton, GPIO. FALLING) while (Wahr): wenn GPIO.event_detecte d(socialNetworkButton): camera.remove_overlay(oo) GPIO.output(cancelButtonLed, False) o = displayPreview3('Aenviar.png') #print "Social Networks Button" sendToTwitter() sendToFacebook() camera.remove_overlay(o) break if GPIO.event_detected(cancelButton): #print "Abgebrochen" camera.remove_overlay(oo) break # reset GPIOS GPIO.remove_event_detect(socialNetworkButton) GPIO.remove_event_detect(cancelButton) GPIO.remove_event_detect(pretakeview() (Tastatur) "Beendet…") #offLeds() GPIO.cleanup()

Schritt 12: Verkabelung

Die Verkabelung ist nur die Verkabelung der Big Dome-Drucktasten mit dem Raspberry PI.

Folgen Sie einfach dem Fritzing-Schema.

Die Anschlüsse sind:

VerbindungRPI GPIO PIN GND Grüner TasterGND (#3) GND Gelber TasterGND (#9) GND Blauer TasterGND(#39) Foto aufnehmen (Blauer Taster "Push to make")17 (BCM) In sozialen Netzwerken posten (Grüner Push) Taste „Push to make“)23 (BCM) Cancel (gelber Taster „Push to make“)24 (BCM) blauer Taster LED27 (BCM) grüner Taster LED22 (BCM) gelber Taster LED5 (BCM)

Der Schrumpfschlauch ist auch farbcodiert

• Schwarz ist GND-Anschlüsse
• Gelb sind "Push-to-Make"-Verbindungen
• Blau sind LED-Anschlüsse

GPIO. BCM-Nummern im Vergleich zu GPIO. BOARD-Verbindungen

Da meine Verbindungen BCM sind, denke ich, dass jetzt ein guter Zeitpunkt ist, darüber und den Unterschied zwischen BCM und BOARD zu sprechen.

Der Hauptunterschied besteht darin, wie Sie auf die GPIO-PINs verweisen, die wiederum bestimmen, wie Sie die Verbindungen herstellen. GPIO.board verweist auf die PINs anhand der Nummer, die auf jedem GPIO-Layout im Internet aufgedruckt ist.

GPIO. BCM bezieht sich auf die PIN-Nummern, wie das Broadcom SOC sie sieht. Dies wird sich wahrscheinlich mit neueren Versionen des Raspberry PI ändern.

Auf der Seite pinout.xyz sind die Platinennummern direkt neben den Pins und das BCM wird so bezeichnet - BCM X (wobei X die Nummer ist)

Schritt 13: Die MagicBox

Der angehängte Code zu diesem Schritt ist der letzte.

Sie können es beim Raspberry PI Boot ausführen, ohne sich anmelden zu müssen. Erstellen Sie dazu einfach dieses kleine Skript in dem Verzeichnis, in dem Sie den Code abgelegt haben - ändern Sie die Pfade entsprechend

#!/bin/bash

cd /home/pi/magicbox python MagicBox.py

Mach es ausführbar

chmod +x start_magicbox.sh

Rufen Sie es jetzt in /etc/rc.local auf, kurz vor der Anweisung exit 0

sudo vi /etc/rc.local

/home/pi/magicbox/start_magicbox.sh &

speichern und Beenden.

Jetzt wird das Python-Programm bei jedem Neustart ausgeführt

HINWEIS: Alle Bilddateien müssen sich im selben Verzeichnis wie das Skript befinden. Du brauchst:

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

Sie können alle diese Dateien auf dem Github von MagicBox erhalten.