IoT-For-Beginners/translations/te/4-manufacturing/lessons/2-check-fruit-from-device/pi-camera.md

# చిత్రం క్యాప్చర్ చేసుకోండి - రాస్బెర్రీ పై

ఈ బోధనలో, మీరు మీ రాస్బెర్రీ పైకి కెమెరా సెన్సార్‌ను జోడించి, దాని నుండి చిత్రాలను చదువుకోగలుగుతారు.

## హార్డు‌వేర్

రాస్బెర్రీ పైకి ఒక కెమెరా అవసరం.

మీరు ఉపయోగించబోయే కెమెరా [రాస్బెర్రీ పై కెమెరా మాడ్యూల్](https://www.raspberrypi.org/products/camera-module-v2/) అయిఉంటుంది. ఈ కెమెరా రాస్బెర్రీ పైతో పనిచేయడానికి రూపొందించబడింది మరియు పైపైని ప్రత్యేక కనెక్టర్ ద్వారా కనెక్ట్ అవుతుంది.

> 💁 ఈ కెమెరా [కెమెరా సీరియల్ ఇంటర్ఫేస్, మొబైల్ ఇండస్ట్రీ ప్రాసెసర్ ఇంటర్ఫేస్ అలయెన్స్ నుండి ఒక ప్రోటోకాల్](https://wikipedia.org/wiki/Camera_Serial_Interface), MIPI-CSI గా పిలవబడే ప్రోటోకాల్‌ను ఉపయోగిస్తుంది. ఇది చిత్రాలను పంపించడానికి ప్రత్యేకమైన ప్రోటోకాల్.

## కెమెరాను కనెక్ట్ చేయండి

రిబ్బన్ కేబుల్ ఉపయోగించి కెమెరాను రాస్బెర్రీ పైకి కనెక్ట్ చేయవచ్చు.

### పని - కెమెరాను కనెక్ట్ చేయండి

![A Raspberry Pi Camera](../../../../../translated_images/te/pi-camera-module.4278753c31bd6e75.webp)

1. పై పవర్ ఆఫ్ చేయండి.

1. కెమెరాతో కలిసి వచ్చే రిబ్బన్ కేబుల్‌ను కెమెరాకు కనెక్ట్ చేయండి. దీనికి, హోల్డర్‌లోని బ్లాక్ ప్లాస్టిక్ క్లిప్‌ను నెమ్మదిగా లాగండి ఇది కొంచెం బయటకు వస్తుంది, ఆపై కేబుల్‌ను స్లయిడ్ చేయండి, నీలం వైపు లెన్స్ నుండి దూరంగా మరియు మెటల్ పిన్ పట్టీలు లెన్స్ వైపు ఉంచాలి. ఇది పూర్తిగా చొప్పునాయిన తర్వాత బ్లాక్ ప్లాస్టిక్ క్లిప్‌ను తిరిగి స్థానం లో పెట్టండి.

    మీరు క్లిప్ ఎలా తెరిచి కేబుల్ ఎలా ఇన్సర్ట్ చేయాలి అనేదాన్ని చూపించే యానిమేషన్‌ను [రాస్బెర్రీ పై Getting Started with the Camera module డాక్యుమెంటేషన్](https://projects.raspberrypi.org/en/projects/getting-started-with-picamera/2) లో చూడవచ్చు.

    ![The ribbon cable inserted into the camera module](../../../../../translated_images/te/pi-camera-ribbon-cable.0bf82acd251611c2.webp)

1. పై నుండి Grove Base Hat తీసివేయండి.

1. రిబ్బన్ కేబుల్‌ను Grove Base Hat లోని కెమెరా స్లాట్ ద్వారా తీసిపోగండి. కేబుల్ యొక్క నీలం వైపు అనలాగ్ పోర్ట్ల వైపు **A0**, **A1** లాంటి లేబుల్స్ వైపు ఉండాలి.

    ![The ribbon cable passing through the grove base hat](../../../../../translated_images/te/grove-base-hat-ribbon-cable.501fed202fcf73b1.webp)

1. రిబ్బన్ కేబుల్‌ను పై పై కెమెరా పోర్టులో చొప్పించండి. మరలా బ్లాక్ ప్లాస్టిక్ క్లిప్‌ను లాగి, కేబుల్‌ను డాల్చి, క్లిప్‌ని తిరిగి గట్టిగా పెట్టండి. కేబుల్ యొక్క నీలం వైపు USB మరియు ఈథర్నెట్ పోర్టుల వైపు ఉండాలి.

    ![The ribbon cable connected to the camera socket on the Pi](../../../../../translated_images/te/pi-camera-socket-ribbon-cable.a18309920b118009.webp)

1. Grove Base Hat మళ్ళీ ఇన్సర్ట్ చేయండి.

## కెమెరాను ప్రోగ్రామ్ చేయండి

రాస్బెర్రీ పై ఇప్పుడు కెమెరాను ఉపయోగించేందుకు [PiCamera](https://pypi.org/project/picamera/) పైథాన్ లైబ్రరీ ఉపయోగించి ప్రోగ్రామ్ చేయవచ్చు.

### పని - లెగసీ కెమెరా మోడ్‌ను ఎనేబుల్ చేయండి

దురదృష్టవశాత్తూ, రాస్బెర్రీ పై OS బుల్సై విడుదలతో కెమెరా సాఫ్ట్‌వేర్ మారింది, అందువలన డిఫాల్ట్‌గా PiCamera పనిచేయదు. PiCamera2 అనే ప్రత్యామ్నాయం అభివృద్ధిలో ఉంది, ఇది ఇంకా ఉపయోగించడానికి సిద్దం కాదు.

ప్రస్తుతం, మీ పైని లెగసీ కెమెరా మోడ్‌లో సెట్ చేయవచ్చు, దీనివల్ల PiCamera పనిచేస్తుంది. కెమెరా సాకెట్ కూడా డిఫాల్ట్‌గా డిసేబుల్ అవుతుంది, కానీ లెగసీ కెమెరా సాఫ్ట్‌వేర్ ఆన్ చేయడంతో సాకెట్ ఆటోమేటిక్ ఎనేబుల్ అవుతుంది.

1. పై పవర్ అప్ చేసి బూట్ కావడంతో పాటు వేచి ఉండండి

1. VS కోడ్‌ను ప్రైవేట్‌గా పైపై నేరుగా లేదా రిమోట్ SSH ఎక్స్‌టెన్షన్ ద్వారా కనెక్ట్ చేసి ప్రారంభించండి.

1. మీ టెర్మినల్ నుండి క్రింది కమాండ్లు రన్ చేయండి:

    ```sh
    sudo raspi-config nonint do_legacy 0
    sudo reboot
    ```

    ఇది లెగసీ కెమెరా సాఫ్ట్‌వేర్ ఎనేబుల్ చేసే సెట్టింగ్‌లను టోగుల్ చేసి, ఆ సెట్టింగ్ అమలవ్వడంతో పాటు పైని రీబూట్ చేస్తుంది.

1. పై రీబూట్ అయ్యి తిరిగి VS కోడ్ ప్రారంభించడానికి వేచి ఉండండి.

### పని - కెమెరాను ప్రోగ్రామ్ చేయండి

పరికరాన్ని ప్రోగ్రామ్ చేయండి.

1. టెర్మినల్ నుండి `pi` యూజర్ హోమ్ డైరెక్టరీలో `fruit-quality-detector` అనే కొత్త ఫోల్డర్ సృష్టించండి. ఈ ఫోల్డర్‌లో `app.py` అనే ఫైల్ సృష్టించండి.

1. ఈ ఫోల్డర్‌ను VS కోడ్‌లో ఓపెన్ చేయండి

1. కెమెరాతో ఇంటరాక్ట్ చేయడానికి PiCamera పైథాన్ లైబ్రరీని ఉపయోగించవచ్చు. క్రింది కమాండ్‌తో పిప్ ప్యాకేజ్‌ని ఇన్స్టాల్ చేయండి:

    ```sh
    pip3 install picamera
    ```

1. మీ `app.py` ఫైల్‌లో క్రింది కోడ్ జోడించండి:

    ```python
    import io
    import time
    from picamera import PiCamera
    ```

    ఈ కోడ్ కొన్ని అవసరమైన లైబ్రరీలను, PiCamera లైబ్రరీని ఇంపోర్ట్ చేస్తుంది.

1. కెమెరాను ప్రారంభించడానికి క్రింది కోడ్ జోడించండి:

    ```python
    camera = PiCamera()
    camera.resolution = (640, 480)
    camera.rotation = 0
    
    time.sleep(2)
    ```

    ఈ కోడ్ PiCamera	objec` తయారు చేస్తుంది, రిజల్యూషన్‌ను 640x480 గా సెట్ చేస్తుంది. ఎక్కువ రిజల్యూషన్‌లు (3280x2464 వరకు) మద్దతు ఇవ్వబడినప్పటికీ, ఇమేజ్ క్లాసిఫైయర్ చాలా చిన్న చిత్రాల (227x227) పై పనిచేస్తుంది కనుక పెద్ద చిత్రాలను క్యాప్చర్ చేసి పంపవలసిన అవసరం లేదు.

    `camera.rotation = 0` లైన్ చిత్రం యొక్క తిరుగుబాటును సెట్ చేస్తుంది. రిబ్బన్ కేబుల్ కెమెరా క్రింద నుంచి వస్తుంది, కానీ మీరు క్లాస్ చేయవలసిన వస్తువు వైపు చెయ్యడానికి కెమెరాను తిప్పితే, ఈ లైన్‌లో తిరుగుబాటు కోణాన్నివారుసేవో మార్చవచ్చు.

    ![The camera hanging down over a drink can](../../../../../translated_images/te/pi-camera-upside-down.5376961ba3145988.webp)

    ఉదాహరణకి, మీరు రిబ్బన్ కేబుల్‌ను ఏదైన వస్తువు మీద ఉంచి కెమెరా టాప్‌లో ఉందని భావించి తిరుగుబాటును 180 గా సెట్ చేయండి:

    ```python
    camera.rotation = 180
    ```

    కెమెరా ప్రారంభం కావడానికి కొన్ని సెకన్లు పడుతుంది, అందుకే `time.sleep(2)` ఉంది

1. చిత్రాన్ని బైనరీ డేటాగా క్యాప్చర్ చేయడానికి క్రింది కోడ్ జోడించండి:

    ```python
    image = io.BytesIO()
    camera.capture(image, 'jpeg')
    image.seek(0)
    ```

    ఇది బైనరీ డేటాను నిల్వ చేయడానికి `BytesIO` ఆబ్జెక్ట్‌ను సృష్టిస్తుంది. చిత్రం కెమెరా నుండి JPEG ఫైల్‌గా చదువుకొని ఈ ఆబ్జెక్టులో నిల్వ అవుతుంది. ఈ ఆబ్జెక్టుకు డేటాలో ఎక్కడ ఉన్నదన్నది సూచించే స్థానం సూచిక ఉంటుంది, కాబట్టి ఎక్కువ డేటా అవసరమైతే చివరకి వ్రాయవచ్చు. `image.seek(0)` లైన్ ఈ స్థానాన్ని మొదటికి మార్చుతుంది తద్వారా అన్ని డేటా తర్వాత చదవబడుతుంది.

1. దీని క్రింద, చిత్రాన్ని ఫైల్‌గా నిల్వ చేసేందుకు క్రింది జోడించండి:

    ```python
    with open('image.jpg', 'wb') as image_file:
        image_file.write(image.read())
    ```

    ఈ కోడ్ `image.jpg` అనే ఫైల్ వ్రాయడానికి ఓపెన్ చేసి, `BytesIO` ఆబ్జెక్టులోని అన్ని డేటాను ఫైల్‌కు రాయుతుంది.

    > 💁 మీరు `BytesIO` ఆబ్జెక్ట్‌పై కాకుండా `camera.capture` పిలుపులో ఫైల్ పేరును ఇచ్చి చిత్రాన్ని నేరుగా ఫైల్‌గా కూడా క్యాప్చర్ చేయవచ్చు. దీనిని ఇప్పుడు ఎందుకు ఉపయోగిస్తామంటే, తర్వాత పాఠం లో చిత్రాన్ని ఇమేజ్ క్లాసిఫైయర్‌కు పంపడానికి అవసరం.

1. కెమెరాను ఏదైనా వస్తువు వైపు పెట్టి ఈ కోడ్‌ను రన్ చేయండి.

1. చిత్రం క్యాప్చర్ అయ్యి ప్రస్తుత ఫోల్డర్‌లో `image.jpg` పేరుతో సేవ్ అవుతుంది. మీరు VS కోడ్ ఎక్స్ప్లోరర్‌లో ఈ ఫైల్‌ను చూడవచ్చు. చిత్రాన్ని చూడడానికి ఫైల్‌ను సెలెక్ట్ చేయండి. తిరుగుబాటు అవసరం అయితే `camera.rotation = 0` లైన్‌ను అవసరమైతే నవీకరించి మరొక చిత్రం తీసుకోండి.

> 💁 మీరు ఈ కోడ్‌ను [code-camera/pi](../../../../../4-manufacturing/lessons/2-check-fruit-from-device/code-camera/pi) ఫోల్డర్‌లో కూడా కనుగొనవచ్చు.

😀 మీ కెమెరా ప్రోగ్రామ్ విజయవంతమైంది!

---

<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ దస్తావేజును AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించాం. మేము ఖచ్చితత్వాన్ని లక్ష్యంగా పెట్టుకున్నప్పటికీ, స్వయంచాలక అనువాదాల్లో దోషాలు లేదా తప్పులున్నాం ఉండవచ్చు. అసలి దస్తావేజ్ స్థానిక భాషలో ఉన్నది అధికారం గల మూలం అని గమనించండి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదాన్ని సిఫారసు చేస్తాము. ఈ అనువాదం వాడకం వల్ల ఏర్పడే ఏ సందేహాలు లేదా తప్పుదోవలో పడే పరిస్థితుల కోసం మేము బాధ్యులు కాదు.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->