# ഒരു ചിത്രംപിടിക്കുക - റാസ്ബെറി പൈ

പാഠത്തിന്റെ ഈ ഭാഗത്ത്, നിങ്ങൾ നിങ്ങളുടെ റാസ്ബെറി പൈയിൽ ഒരു ക്യാമറ സെൻസോർ ചേർക്കുകയും അതിൽ നിന്നുള്ള ചിത്രങ്ങൾ വായിക്കുകയും ചെയ്യും.

## ഹാർഡ്‌വെയർ

റാസ്ബെറി പൈക്കൊരു ക്യാമറ ആവശ്യമാണ്.

നിങ്ങൾ ഉപയോഗിക്കുന്ന ക്യാമറയാണ് [റാസ്ബെറി പൈ ക്യാമറ മോഡ്യൂൾ](https://www.raspberrypi.org/products/camera-module-v2/). ഈ ക്യാമറ റാസ്ബെറി പൈയുമായി പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്തതാണ് കൂടാതെ പൈയിൽ ഉള്ള സമർപ്പിത കണക്റ്ററിലൂടെ കണക്ട് ചെയ്യുന്നു.

> 💁 ഈ ക്യാമറ [ക്യാമറ സീരിയൽ ഇന്റർഫേസ്, മൊബൈൽ ഇൻഡസ്ട്രി പ്രോസസ്സർ ഇന്റർഫേസ് അലൈയൻസിന്റെ പ്രോട്ടോക്കോൾ](https://wikipedia.org/wiki/Camera_Serial_Interface) ഉപയോഗിക്കുന്നു, മിപിഐ-സിഎസ്ഐ എന്നറിയപ്പെടുന്നത്. ഇത് ചിത്രങ്ങൾ അയയ്ക്കാൻ സമർപ്പിത പ്രോട്ടോക്കോളാണ്

## ക്യാമറ ബന്ധിപ്പിക്കുക

ക്യാമറ റാസ്ബെറി പൈയുമായി റിബൺ കേബിൾ ഉപയോഗിച്ച് ബന്ധിപ്പിക്കാം.

### ടാസ്ക് - ക്യാമറ ബന്ധിപ്പിക്കുക

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

1. പൈ പവർ ഓഫ് ചെയ്യുക.

1. ക്യാമറയിൽ കൂടെ വരുന്ന റിബൺ കേബിൾ ക്യാമറയുമായി കണക്ട് ചെയ്യുക. ഇതിനായി, ഹോൾഡറിൽ കറുത്ത പ്ലാസ്റ്റിക് ക്ലിപ്പ് സൂക്ഷ്മമായി പിൻതുടർന്ന് കുറച്ച് പുറത്തെടുക്കുക, തുടർന്ന് കേബിൾ സോക്കറ്റിൽ സ്ലൈഡ് ചെയ്യുക, നീല വശം ലെൻസിൽ നിന്നും മറിച്ച്, മെറ്റൽ പിന് സ്ട്രിപ്പുകൾ ലെൻസിന്റെ ദിശയിലേക്ക് വരുന്നതായി ഉറപ്പാക്കുക. ഇത് മുഴുവനും കയറുമ്പോൾ, കറുത്ത പ്ലാസ്റ്റിക് ക്ലിപ്പ് സ്ഥിതിയിലേക്ക് തിരികെ തുരത്തുക.

    ക്ലിപ്പ് തുറക്കാനും കേബിൾ ഉൾപ്പെടുത്താനും എങ്ങനെ ചെയ്യാമെന്ന് കാണിക്കുന്ന ഒരു അനിമേഷൻ നിങ്ങൾക്ക് [Raspberry Pi Getting Started with the Camera module documentation](https://projects.raspberrypi.org/en/projects/getting-started-with-picamera/2) ൽ കാണാം.

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

1. Grove ബേസ് ഹാറ്റ് പൈയിൽ നിന്നും നീക്കം ചെയ്യുക.

1. റിബൺ കേബിൾ Grove ബേസ് ഹാറ്റിലെ ക്യാമറ സ്ലോട്ടിലൂടെ കടത്തുക. കേബിളിന്റെ നീല വശം **A0**, **A1** തുടങ്ങി ലേബൽ ചെയ്ത അനലോഗ് പോർട്ടുകളുടെ ദിശയിലേക്ക് 바라ക്കുകയാണെന്ന് ഉറപ്പാക്കുക.

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

1. റിബൺ കേബിൾ പൈയിലെ ക്യാമറ പോർട്ടിലേക്ക് ഉൾപ്പെടുത്തുക. വീണ്ടും, കറുത്ത പ്ലാസ്റ്റിക് ക്ലിപ്പ് ഉയർത്തി, കേബിൾ ചേർക്കുക പിന്നെയത് തിരിച്ചടക്കുക. കേബിളിന്റെ നീല വശം USB ഉം ഇഥർനെറ്റ് പോർട്ടുകളും അഭിമുഖ്യമായിരിക്കണം.

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

1. Grove ബേസ് ഹാറ്റ് വീണ്ടും സജ്ജമാക്കുക

## ക്യാമറ പ്രോഗ്രാം ചെയ്യുക

റാസ്ബെറി പൈ ഇനി [PiCamera](https://pypi.org/project/picamera/) പൈത്തൺ ലൈബ്രറി ഉപയോഗിച്ച് ക്യാമറ ഉപയോഗിക്കാൻ പ്രോഗ്രാം ചെയ്യാനാകും.

### ടാസ്ക് - ലെഗസി ക്യാമറ മോഡ് പ്രവർത്തനക്ഷമമാക്കുക

ദുരന്തകരം, റാസ്ബെറി പൈ OS ബുള്ള്സായി പുറത്തിറങ്ങിയതോടകം, OS പാക്കേജിൽ ഉണ്ടായ ക്യാമറ സോഫ്റ്റ്‌വെയർ മാറിവിട്ടതാണ്, അതിനാൽ ശുദ്ധമായ PiCamera നെയുള്ള പിന്തുണ ഇല്ലാതായി. PiCamera2 എന്ന് പേരിട്ട പുതിയൊരു പദവി ഉണ്ടാകുകയാണ്, പക്ഷേ അതുവരെ അത് ഉപയോഗിക്കാൻ തയ്യാറല്ല.

ഇപ്പോൾ, PiCamera പ്രവർത്തിക്കാൻ സാധിക്കുന്നതിന് നിങ്ങളുടെ പൈയെ ലെഗസി ക്യാമറ മോഡിലേക്ക് മാറ്റാം. ക്യാമറ സോക്കറ്റ് യാഥാസ്ഥിതികമായി ഓഫ് ആണ്, എന്നാൽ ലെഗസി ക്യാമറ സോഫ്റ്റ്‌വെയർ ഓണാക്കുമ്പോൾ അത് സ്വയം സജീവമാകും.

1. പൈ പവർ ഓണാക്കുക, ബൂട്ടിംഗ് പൂർത്തിയാകാൻ കാത്തിരിക്കുക

1. പൈയിൽ നേരിട്ട് അല്ലെങ്കിൽ റിമോട്ട് SSH എക്‌സ്‌റ്റൻഷൻ ഉപയോഗിച്ച് VS Code തുറക്കുക.

1. നിങ്ങളുടെ ടെർമിനലിൽ താഴെ പറയുന്ന കമാൻഡുകൾ എക്‌സിക്യൂട്ട് ചെയ്യുക:

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

    ഇത് ഒരു സെറ്റിംഗ് ടോഗിൾ ചെയ്ത് ലെഗസി ക്യാമറ സോഫ്റ്റ്‌വെയർ ഓണാക്കും, പിന്നീട് പൈ റീബൂട്ട് ചെയ്യും.

1. പൈയുടെ പൂർണ്ണമായ പുനരാരംഭത്തിന് ശേഷം VS Code വീണ്ടും ആരംഭിക്കുക.

### ടാസ്ക് - ക്യാമറ പ്രോഗ്രാം ചെയ്യുക

ഡിവൈസ് പ്രോഗ്രാം ചെയ്യുക.

1. ടെർമിനലിൽ നിന്ന് `pi` ഉപയോക്താവിന്റെ ഹോം ഡയറക്ടറിയിൽ പുതിയ ഫോളഡർ `fruit-quality-detector` എന്ന് സൃഷ്ടിക്കുക. ഈ ഫോളഡറിൽ `app.py` എന്ന ഫയൽ സൃഷ്ടിക്കുക.

1. ഈ ഫോൾഡർ VS Code-ൽ തുറക്കുക

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 ഓബ്ജക്ട് സൃഷ്ടിക്കുന്നു, റെസല്യൂഷൻ 640x480 ആയി സജ്ജമാക്കുന്നു. ഉയർന്ന റെസല്യൂഷനുകൾ പിന്തുണയ്ക്കുന്നു (3280x2464 വരെ), എന്നാല്‍ ഇമേജ് ക്ലാസിഫയർ വളരെ ചെറുതായ (227x227) ചിത്രങ്ങളിൽ പ്രവർത്തിക്കുന്നതിനാൽ വലുതായ ചിത്രങ്ങൾ പിടിക്കാൻ ആവശ്യം ഇല്ല.

    `camera.rotation = 0` ലൈനുൽ ചിത്രത്തിന്റെ ത്രൈധാന്യം സജ്ജമാക്കുന്നു. റിബൺ കേബിൾ ക്യാമറയുടെയും താഴെ ഭാഗത്ത് പ്രവേശിക്കുന്നതാണ്, പക്ഷേ ക്ലാസിഫൈ ചെയ്യേണ്ട വസ്തുവിനെ പറ്റാൻ ക്യാമറ തിരിച്ചത് എളുപ്പമാക്കാൻ നിങ്ങൾ തയ്യാറാക്കിയാൽ ഈ ലൈനിലെ ഡിഗ്രികൾ തിരുത്താം.

    ![The camera hanging down over a drink can](../../../../../translated_images/ml/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 ഫയലായി വായിച്ച് ഈ ഒബ്ജക്ട് ലേക്ക് സേവ് ചെയ്യുന്നു. ഈ ഒബ്ജക്ടിന് dataയിലെ സ്ഥാനം അറിയാൻ position ഇൻഡിക്കേറ്റർ ഉണ്ട്, പിന്നെ കൂടുതൽ ഡാറ്റ എഴുതി ചേർക്കാനാകും, അതിനാൽ `image.seek(0)` സ്രോതസ്സിലെ സ്ഥാനത്തെ തിരിച്ചുപിടിക്കുന്നു ഒപ്പം എല്ലാവിധ ഡാറ്റയും പിന്നീട് വായിക്കാനും അതിനെ സഹായിക്കുന്നു.

1. ഇതിന്റെ താഴെ ചേർത്ത് ചിത്രം ഫയലാക്ഷേപിക്കാൻ താഴെ പറയുന്ന കോഡ് ചേർക്കുക:

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

    `image.jpg` എന്ന ഫയൽ എഴുതാനായി തുറക്കുന്നു, പിന്നെ `BytesIO` ഒബ്ജക്ടിൽ ഉള്ള മുഴുവൻ ഡാറ്റ വായിച്ച് ഫയലിൽ എഴുതുന്നു.

    > 💁 직접 `BytesIO` ഉപയോഗിക്കാതെ, `camera.capture` കോൾക്ക് ഫയൽ നാമം നൽകുകയും ചിത്രത്തെ നേരിട്ട് ഫയലായി പിടിക്കുകയും ചെയ്യാം. `BytesIO` ഉപയോഗിക്കുന്നത് ഈ പാഠത്തിൽ പിന്നിലെ ഇമേജ് ക്ലാസിഫയറിലേക്ക് ചിത്രം അയയ്ക്കാൻ സാധിക്കുന്നതിനാൽ ആ കുറിച്ച് ആണ്.

1. ക്യാമറ ഒരുറ്റിലേക്കു വീക്ഷിക്കുക, കോഡ് നടത്തുക.

1. ചിത്രം പിടിച്ച് നിലവിലെ ഫോൾഡറിൽ `image.jpg` എന്ന പേരിൽ സേവ് ചെയ്യും. VS Code എക്‌സ്‌പ്ലോററിൽ ഈ ഫയൽ കാണാം. ഫയൽ തിരഞ്ഞെടുക്കാൻ ചിത്രം കാണാൻ. ചിത്രത്തിന് തിരക്കം വേണ്ടേെങ്കിൽ `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 -->