7.7 KiB

Raw Permalink Blame History

Ta et bilde - Raspberry Pi

I denne delen av leksjonen skal du legge til en kamerasensor på din Raspberry Pi og lese bilder fra den.

Maskinvare

Raspberry Pi trenger et kamera.

Kameraet du skal bruke er et Raspberry Pi Camera Module. Dette kameraet er designet for å fungere med Raspberry Pi og kobles til via en dedikert kontakt på Pi.

💁 Dette kameraet bruker Camera Serial Interface, en protokoll fra Mobile Industry Processor Interface Alliance, kjent som MIPI-CSI. Dette er en dedikert protokoll for å sende bilder.

Koble til kameraet

Kameraet kan kobles til Raspberry Pi ved hjelp av en flatkabel.

Oppgave - koble til kameraet

Slå av Pi.
Koble flatkabelen som følger med kameraet til kameraet. For å gjøre dette, trekk forsiktig i den svarte plastklipsen i holderen slik at den kommer litt ut, og skyv deretter kabelen inn i kontakten med den blå siden vendt bort fra linsen og metallstripene vendt mot linsen. Når kabelen er helt inne, skyv den svarte plastklipsen tilbake på plass.

Du kan finne en animasjon som viser hvordan du åpner klipsen og setter inn kabelen i Raspberry Pi Getting Started with the Camera module documentation.
Fjern Grove Base Hat fra Pi.
Før flatkabelen gjennom kamerasporet i Grove Base Hat. Sørg for at den blå siden av kabelen vender mot de analoge portene merket A0, A1 osv.
Sett flatkabelen inn i kamerakontakten på Pi. Igjen, trekk den svarte plastklipsen opp, sett inn kabelen, og skyv klipsen tilbake. Den blå siden av kabelen skal vende mot USB- og Ethernet-portene.
Sett Grove Base Hat tilbake på plass.

Programmer kameraet

Raspberry Pi kan nå programmeres til å bruke kameraet ved hjelp av Python-biblioteket PiCamera.

Oppgave - aktiver legacy kameramodus

Dessverre, med utgivelsen av Raspberry Pi OS Bullseye, endret kameraprogramvaren som fulgte med operativsystemet, noe som betyr at PiCamera ikke fungerer som standard. Det er en erstatning under utvikling, kalt PiCamera2, men denne er ikke klar til bruk ennå.

Foreløpig kan du sette Pi i legacy kameramodus for å tillate PiCamera å fungere. Kamerakontakten er også deaktivert som standard, men aktivering av legacy kameramodus aktiverer automatisk kontakten.

Slå på Pi og vent til den starter opp.
Start VS Code, enten direkte på Pi eller koble til via Remote SSH-utvidelsen.
Kjør følgende kommandoer fra terminalen:
```
sudo raspi-config nonint do_legacy 0
sudo reboot
```
Dette vil endre en innstilling for å aktivere legacy kameramodus, og deretter starte Pi på nytt for at innstillingen skal tre i kraft.
Vent til Pi har startet på nytt, og start deretter VS Code på nytt.

Oppgave - programmer kameraet

Programmer enheten.

Fra terminalen, opprett en ny mappe i hjemmekatalogen til brukeren pi kalt fruit-quality-detector. Opprett en fil i denne mappen kalt app.py.
Åpne denne mappen i VS Code.
For å samhandle med kameraet kan du bruke Python-biblioteket PiCamera. Installer Pip-pakken for dette med følgende kommando:
```
pip3 install picamera
```
Legg til følgende kode i filen app.py:
```
import io
import time
from picamera import PiCamera
```
Denne koden importerer noen nødvendige biblioteker, inkludert PiCamera-biblioteket.
Legg til følgende kode under dette for å initialisere kameraet:
```
camera = PiCamera()
camera.resolution = (640, 480)
camera.rotation = 0

time.sleep(2)
```
Denne koden oppretter et PiCamera-objekt og setter oppløsningen til 640x480. Selv om høyere oppløsninger støttes (opptil 3280x2464), fungerer bildekvalitetsklassifiseringen på mye mindre bilder (227x227), så det er ikke nødvendig å ta opp og sende større bilder.

Linjen camera.rotation = 0 setter rotasjonen til bildet. Flatkabelen kommer inn i bunnen av kameraet, men hvis kameraet ditt er rotert for å gjøre det lettere å peke på objektet du vil klassifisere, kan du endre denne linjen til antall grader rotasjon.

For eksempel, hvis du henger flatkabelen over noe slik at den er på toppen av kameraet, sett rotasjonen til 180:
```
camera.rotation = 180
```
Kameraet tar noen sekunder å starte opp, derfor linjen time.sleep(2).
Legg til følgende kode under dette for å ta opp bildet som binære data:
```
image = io.BytesIO()
camera.capture(image, 'jpeg')
image.seek(0)
```
Denne koden oppretter et BytesIO-objekt for å lagre binære data. Bildet leses fra kameraet som en JPEG-fil og lagres i dette objektet. Dette objektet har en posisjonsindikator for å vite hvor det er i dataene slik at mer data kan skrives til slutten hvis nødvendig, så linjen image.seek(0) flytter denne posisjonen tilbake til starten slik at alle dataene kan leses senere.
Under dette, legg til følgende for å lagre bildet til en fil:
```
with open('image.jpg', 'wb') as image_file:
    image_file.write(image.read())
```
Denne koden åpner en fil kalt image.jpg for skriving, leser deretter alle dataene fra BytesIO-objektet og skriver det til filen.

💁 Du kan ta opp bildet direkte til en fil i stedet for et BytesIO-objekt ved å sende filnavnet til camera.capture-kallet. Grunnen til å bruke BytesIO-objektet er at du senere i denne leksjonen kan sende bildet til bildekvalitetsklassifiseringen.
Pek kameraet mot noe og kjør denne koden.
Et bilde vil bli tatt opp og lagret som image.jpg i den gjeldende mappen. Du vil se denne filen i VS Code explorer. Velg filen for å se bildet. Hvis det trenger rotasjon, oppdater linjen camera.rotation = 0 etter behov og ta et nytt bilde.

💁 Du finner denne koden i mappen code-camera/pi.

😀 Kameraet ditt fungerer!

Ansvarsfraskrivelse:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten Co-op Translator. Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

7.7 KiB Raw Permalink Blame History