You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
155 lines
15 KiB
155 lines
15 KiB
<!--
|
|
CO_OP_TRANSLATOR_METADATA:
|
|
{
|
|
"original_hash": "c677667095f6133eee418c7e53615d05",
|
|
"translation_date": "2025-08-27T10:21:36+00:00",
|
|
"source_file": "4-manufacturing/lessons/2-check-fruit-from-device/pi-camera.md",
|
|
"language_code": "pa"
|
|
}
|
|
-->
|
|
# ਰਸਪਬੈਰੀ ਪਾਈ ਨਾਲ ਤਸਵੀਰ ਕੈਪਚਰ ਕਰੋ
|
|
|
|
ਇਸ ਪਾਠ ਦੇ ਇਸ ਹਿੱਸੇ ਵਿੱਚ, ਤੁਸੀਂ ਆਪਣੇ ਰਸਪਬੈਰੀ ਪਾਈ ਵਿੱਚ ਕੈਮਰਾ ਸੈਂਸਰ ਜੋੜੋਗੇ ਅਤੇ ਇਸ ਤੋਂ ਤਸਵੀਰਾਂ ਪੜ੍ਹੋਗੇ।
|
|
|
|
## ਹਾਰਡਵੇਅਰ
|
|
|
|
ਰਸਪਬੈਰੀ ਪਾਈ ਨੂੰ ਇੱਕ ਕੈਮਰਾ ਦੀ ਲੋੜ ਹੈ।
|
|
|
|
ਤੁਸੀਂ ਜੋ ਕੈਮਰਾ ਵਰਤੋਗੇ ਉਹ ਹੈ [ਰਸਪਬੈਰੀ ਪਾਈ ਕੈਮਰਾ ਮਾਡਿਊਲ](https://www.raspberrypi.org/products/camera-module-v2/)। ਇਹ ਕੈਮਰਾ ਖਾਸ ਤੌਰ 'ਤੇ ਰਸਪਬੈਰੀ ਪਾਈ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਪਾਈ ਦੇ ਇੱਕ ਖਾਸ ਕਨੈਕਟਰ ਰਾਹੀਂ ਜੁੜਦਾ ਹੈ।
|
|
|
|
> 💁 ਇਹ ਕੈਮਰਾ [ਕੈਮਰਾ ਸੀਰੀਅਲ ਇੰਟਰਫੇਸ, ਜੋ ਕਿ ਮੋਬਾਈਲ ਇੰਡਸਟਰੀ ਪ੍ਰੋਸੈਸਰ ਇੰਟਰਫੇਸ ਅਲਾਇੰਸ ਦਾ ਇੱਕ ਪ੍ਰੋਟੋਕੋਲ ਹੈ](https://wikipedia.org/wiki/Camera_Serial_Interface), ਨੂੰ ਵਰਤਦਾ ਹੈ। ਇਹ ਤਸਵੀਰਾਂ ਭੇਜਣ ਲਈ ਇੱਕ ਖਾਸ ਪ੍ਰੋਟੋਕੋਲ ਹੈ।
|
|
|
|
## ਕੈਮਰਾ ਜੁੜੋ
|
|
|
|
ਕੈਮਰਾ ਨੂੰ ਰਸਪਬੈਰੀ ਪਾਈ ਨਾਲ ਰਿਬਨ ਕੇਬਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ।
|
|
|
|
### ਕੰਮ - ਕੈਮਰਾ ਜੁੜੋ
|
|
|
|
|
|
|
|
1. ਪਾਈ ਨੂੰ ਬੰਦ ਕਰੋ।
|
|
|
|
1. ਕੈਮਰਾ ਨਾਲ ਆਉਣ ਵਾਲੀ ਰਿਬਨ ਕੇਬਲ ਨੂੰ ਕੈਮਰਾ ਨਾਲ ਜੋੜੋ। ਇਸ ਲਈ, ਹੋਲਡਰ ਵਿੱਚ ਕਾਲੇ ਪਲਾਸਟਿਕ ਕਲਿੱਪ ਨੂੰ ਹੌਲੀ ਹੌਲੀ ਖਿੱਚੋ ਤਾਂ ਜੋ ਇਹ ਥੋੜ੍ਹਾ ਬਾਹਰ ਆ ਜਾਵੇ, ਫਿਰ ਕੇਬਲ ਨੂੰ ਸਾਕਟ ਵਿੱਚ ਪਾ ਦਿਓ, ਨੀਲੇ ਪਾਸੇ ਨੂੰ ਲੈਂਸ ਤੋਂ ਦੂਰ ਅਤੇ ਧਾਤ ਦੇ ਪਿੰਨ ਲੈਂਸ ਵੱਲ ਰੱਖੋ। ਜਦੋਂ ਇਹ ਪੂਰੀ ਤਰ੍ਹਾਂ ਅੰਦਰ ਹੋਵੇ, ਕਾਲੇ ਪਲਾਸਟਿਕ ਕਲਿੱਪ ਨੂੰ ਵਾਪਸ ਜਗ੍ਹਾ 'ਤੇ ਧੱਕੋ।
|
|
|
|
ਤੁਸੀਂ ਕਲਿੱਪ ਨੂੰ ਖੋਲ੍ਹਣ ਅਤੇ ਕੇਬਲ ਨੂੰ ਪਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦਿਖਾਉਣ ਵਾਲੀ ਐਨੀਮੇਸ਼ਨ ਨੂੰ [ਰਸਪਬੈਰੀ ਪਾਈ ਕੈਮਰਾ ਮਾਡਿਊਲ ਦਸਤਾਵੇਜ਼](https://projects.raspberrypi.org/en/projects/getting-started-with-picamera/2) ਵਿੱਚ ਦੇਖ ਸਕਦੇ ਹੋ।
|
|
|
|
|
|
|
|
1. ਗਰੋਵ ਬੇਸ ਹੈਟ ਨੂੰ ਪਾਈ ਤੋਂ ਹਟਾਓ।
|
|
|
|
1. ਰਿਬਨ ਕੇਬਲ ਨੂੰ ਗਰੋਵ ਬੇਸ ਹੈਟ ਵਿੱਚ ਕੈਮਰਾ ਸਲਾਟ ਰਾਹੀਂ ਪਾਸ ਕਰੋ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਕੇਬਲ ਦਾ ਨੀਲਾ ਪਾਸਾ ਐਨਾਲੌਗ ਪੋਰਟਾਂ **A0**, **A1** ਆਦਿ ਵੱਲ ਹੈ।
|
|
|
|
|
|
|
|
1. ਰਿਬਨ ਕੇਬਲ ਨੂੰ ਪਾਈ ਦੇ ਕੈਮਰਾ ਪੋਰਟ ਵਿੱਚ ਪਾਓ। ਫਿਰ, ਕਾਲੇ ਪਲਾਸਟਿਕ ਕਲਿੱਪ ਨੂੰ ਉੱਪਰ ਖਿੱਚੋ, ਕੇਬਲ ਪਾਓ, ਅਤੇ ਕਲਿੱਪ ਨੂੰ ਵਾਪਸ ਜਗ੍ਹਾ 'ਤੇ ਧੱਕੋ। ਕੇਬਲ ਦਾ ਨੀਲਾ ਪਾਸਾ USB ਅਤੇ ਈਥਰਨੈਟ ਪੋਰਟਾਂ ਵੱਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
|
|
|
|
|
|
|
|
1. ਗਰੋਵ ਬੇਸ ਹੈਟ ਨੂੰ ਮੁੜ ਲਗਾਓ।
|
|
|
|
## ਕੈਮਰਾ ਪ੍ਰੋਗਰਾਮ ਕਰੋ
|
|
|
|
ਹੁਣ ਰਸਪਬੈਰੀ ਪਾਈ ਨੂੰ [PiCamera](https://pypi.org/project/picamera/) ਪਾਈਥਨ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੈਮਰਾ ਚਲਾਉਣ ਲਈ ਪ੍ਰੋਗਰਾਮ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
|
|
|
|
### ਕੰਮ - ਲੈਗੇਸੀ ਕੈਮਰਾ ਮੋਡ ਚਾਲੂ ਕਰੋ
|
|
|
|
ਬਦਕਿਸਮਤੀ ਨਾਲ, ਰਸਪਬੈਰੀ ਪਾਈ OS ਬੁੱਲਜ਼ਆਈ ਦੇ ਜਾਰੀ ਹੋਣ ਨਾਲ, OS ਨਾਲ ਆਉਣ ਵਾਲਾ ਕੈਮਰਾ ਸੌਫਟਵੇਅਰ ਬਦਲ ਗਿਆ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਡਿਫਾਲਟ ਰੂਪ ਵਿੱਚ PiCamera ਹੁਣ ਕੰਮ ਨਹੀਂ ਕਰਦਾ। ਇਸਦਾ ਇੱਕ ਬਦਲ ਤਿਆਰ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਜਿਸਨੂੰ PiCamera2 ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਪਰ ਇਹ ਅਜੇ ਤਿਆਰ ਨਹੀਂ ਹੈ।
|
|
|
|
ਫਿਲਹਾਲ, ਤੁਸੀਂ ਆਪਣੇ ਪਾਈ ਨੂੰ ਲੈਗੇਸੀ ਕੈਮਰਾ ਮੋਡ ਵਿੱਚ ਸੈਟ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ PiCamera ਕੰਮ ਕਰ ਸਕੇ। ਕੈਮਰਾ ਸਾਕਟ ਵੀ ਡਿਫਾਲਟ ਰੂਪ ਵਿੱਚ ਬੰਦ ਹੁੰਦਾ ਹੈ, ਪਰ ਲੈਗੇਸੀ ਕੈਮਰਾ ਸੌਫਟਵੇਅਰ ਚਾਲੂ ਕਰਨ ਨਾਲ ਇਹ ਸਾਕਟ ਆਟੋਮੈਟਿਕ ਤੌਰ 'ਤੇ ਚਾਲੂ ਹੋ ਜਾਂਦਾ ਹੈ।
|
|
|
|
1. ਪਾਈ ਨੂੰ ਚਾਲੂ ਕਰੋ ਅਤੇ ਇਸਦੇ ਬੂਟ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰੋ।
|
|
|
|
1. VS Code ਲਾਂਚ ਕਰੋ, ਚਾਹੇ ਸਿੱਧੇ ਪਾਈ 'ਤੇ ਜਾਂ ਰਿਮੋਟ SSH ਐਕਸਟੈਂਸ਼ਨ ਰਾਹੀਂ ਜੁੜ ਕੇ।
|
|
|
|
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` ਲਾਈਨ ਤਸਵੀਰ ਦੀ ਰੋਟੇਸ਼ਨ ਸੈਟ ਕਰਦੀ ਹੈ। ਰਿਬਨ ਕੇਬਲ ਕੈਮਰਾ ਦੇ ਹੇਠਾਂ ਆਉਂਦਾ ਹੈ, ਪਰ ਜੇਕਰ ਤੁਹਾਡਾ ਕੈਮਰਾ ਉਸ ਆਈਟਮ ਵੱਲ ਆਸਾਨੀ ਨਾਲ ਇਸ਼ਾਰਾ ਕਰਨ ਲਈ ਘੁੰਮਾਇਆ ਗਿਆ ਹੈ ਜਿਸਨੂੰ ਤੁਸੀਂ ਕਲਾਸੀਫਾਈ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਸ ਲਾਈਨ ਨੂੰ ਘੁੰਮਾਉਣ ਦੇ ਡਿਗਰੀ ਦੇ ਅਨੁਸਾਰ ਬਦਲ ਸਕਦੇ ਹੋ।
|
|
|
|
|
|
|
|
ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਤੁਸੀਂ ਰਿਬਨ ਕੇਬਲ ਨੂੰ ਕਿਸੇ ਚੀਜ਼ ਦੇ ਉੱਪਰ ਲਟਕਾਉਂਦੇ ਹੋ ਤਾਂ ਕਿ ਇਹ ਕੈਮਰਾ ਦੇ ਉੱਪਰ ਹੋਵੇ, ਤਾਂ ਰੋਟੇਸ਼ਨ ਨੂੰ 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` ਆਬਜੈਕਟ ਦੇ। ਇਸ ਪਾਠ ਵਿੱਚ `BytesIO` ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਇਸ ਲਈ ਕੀਤੀ ਗਈ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਬਾਅਦ ਵਿੱਚ ਤਸਵੀਰ ਨੂੰ ਆਪਣੇ ਇਮੇਜ ਕਲਾਸੀਫਾਇਰ ਨੂੰ ਭੇਜ ਸਕੋ।
|
|
|
|
1. ਕੈਮਰਾ ਨੂੰ ਕਿਸੇ ਚੀਜ਼ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰੋ ਅਤੇ ਇਸ ਕੋਡ ਨੂੰ ਚਲਾਓ।
|
|
|
|
1. ਇੱਕ ਤਸਵੀਰ ਕੈਪਚਰ ਕੀਤੀ ਜਾਵੇਗੀ ਅਤੇ ਮੌਜੂਦਾ ਫੋਲਡਰ ਵਿੱਚ `image.jpg` ਵਜੋਂ ਸੇਵ ਕੀਤੀ ਜਾਵੇਗੀ। ਤੁਸੀਂ ਇਸ ਫਾਈਲ ਨੂੰ VS Code ਐਕਸਪਲੋਰਰ ਵਿੱਚ ਦੇਖੋਗੇ। ਫਾਈਲ ਨੂੰ ਚੁਣੋ ਅਤੇ ਤਸਵੀਰ ਵੇਖੋ। ਜੇਕਰ ਇਸਨੂੰ ਰੋਟੇਸ਼ਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ `camera.rotation = 0` ਲਾਈਨ ਨੂੰ ਅਪਡੇਟ ਕਰੋ ਅਤੇ ਦੁਬਾਰਾ ਤਸਵੀਰ ਲਓ।
|
|
|
|
> 💁 ਤੁਸੀਂ ਇਹ ਕੋਡ [code-camera/pi](../../../../../4-manufacturing/lessons/2-check-fruit-from-device/code-camera/pi) ਫੋਲਡਰ ਵਿੱਚ ਲੱਭ ਸਕਦੇ ਹੋ।
|
|
|
|
😀 ਤੁਹਾਡਾ ਕੈਮਰਾ ਪ੍ਰੋਗਰਾਮ ਸਫਲ ਰਿਹਾ!
|
|
|
|
---
|
|
|
|
**ਅਸਵੀਕਤੀ**:
|
|
ਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ [Co-op Translator](https://github.com/Azure/co-op-translator) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀ ਹੋਣ ਦੀ ਪੂਰੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁਚੱਜੇਪਣ ਹੋ ਸਕਦੇ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਇਸਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ। |