ESP32 ਬੇਸਿਕ ਸਟਾਰਟਰ
ਕਿੱਟ

ਪੈਕਿੰਗ ਸੂਚੀ

ESP32 ਜਾਣ-ਪਛਾਣ

ESP32 ਲਈ ਨਵੇਂ? ਇੱਥੇ ਸ਼ੁਰੂ ਕਰੋ! ESP32 ਏਸਪ੍ਰੈਸੀਫ ਦੁਆਰਾ ਵਿਕਸਤ ਕੀਤੇ ਇੱਕ ਚਿੱਪ (SoC) ਮਾਈਕ੍ਰੋਕੰਟਰੋਲਰ 'ਤੇ ਘੱਟ-ਕੀਮਤ ਅਤੇ ਘੱਟ-ਪਾਵਰ ਸਿਸਟਮ ਦੀ ਇੱਕ ਲੜੀ ਹੈ ਜਿਸ ਵਿੱਚ Wi-Fi ਅਤੇ ਬਲੂਟੁੱਥ ਵਾਇਰਲੈੱਸ ਸਮਰੱਥਾਵਾਂ ਅਤੇ ਦੋਹਰਾ-ਕੋਰ ਪ੍ਰੋਸੈਸਰ ਸ਼ਾਮਲ ਹਨ। ਜੇਕਰ ਤੁਸੀਂ ESP8266 ਤੋਂ ਜਾਣੂ ਹੋ, ਤਾਂ ESP32 ਇਸਦਾ ਉੱਤਰਾਧਿਕਾਰੀ ਹੈ, ਬਹੁਤ ਸਾਰੀਆਂ ਨਵੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਾਲ ਭਰਿਆ ਹੋਇਆ ਹੈ।ESP32 ਨਿਰਧਾਰਨ
ਜੇ ਤੁਸੀਂ ਥੋੜਾ ਹੋਰ ਤਕਨੀਕੀ ਅਤੇ ਖਾਸ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ESP32 (ਸਰੋਤ: http://esp32.net/)-ਵਧੇਰੇ ਵੇਰਵਿਆਂ ਲਈ, ਡੇਟਾਸ਼ੀਟ ਦੀ ਜਾਂਚ ਕਰੋ):

• ਵਾਇਰਲੈੱਸ ਕਨੈਕਟੀਵਿਟੀ ਵਾਈਫਾਈ: HT150.0 ਦੇ ਨਾਲ 40 Mbps ਡਾਟਾ ਰੇਟ
• ਬਲੂਟੁੱਥ: BLE (ਬਲਿਊਟੁੱਥ ਲੋਅ ਐਨਰਜੀ) ਅਤੇ ਬਲੂਟੁੱਥ ਕਲਾਸਿਕ
• ਪ੍ਰੋਸੈਸਰ: ਟੈਨਸਿਲਿਕਾ ਐਕਸਟੈਂਸਾ ਡਿਊਲ-ਕੋਰ 32-ਬਿਟ LX6 ਮਾਈਕ੍ਰੋਪ੍ਰੋਸੈਸਰ, 160 ਜਾਂ 240 ਮੈਗਾਹਰਟਜ਼ 'ਤੇ ਚੱਲਦਾ ਹੈ
• ਮੈਮੋਰੀ:
• ROM: 448 KB (ਬੂਟਿੰਗ ਅਤੇ ਕੋਰ ਫੰਕਸ਼ਨਾਂ ਲਈ)
• SRAM: 520 KB (ਡਾਟਾ ਅਤੇ ਨਿਰਦੇਸ਼ਾਂ ਲਈ)
• RTC fas SRAM: 8 KB (ਡੀਪ-ਸਲੀਪ ਮੋਡ ਤੋਂ RTC ਬੂਟ ਦੌਰਾਨ ਡਾਟਾ ਸਟੋਰੇਜ ਅਤੇ ਮੁੱਖ CPU ਲਈ)
• RTC ਹੌਲੀ SRAM: 8KB (ਡੀਪ-ਸਲੀਪ ਮੋਡ ਦੌਰਾਨ ਸਹਿ-ਪ੍ਰੋਸੈਸਰ ਐਕਸੈਸ ਕਰਨ ਲਈ) eFuse: 1 Kbit (ਜਿਸ ਵਿੱਚੋਂ 256 ਬਿੱਟ ਸਿਸਟਮ (MAC ਐਡਰੈੱਸ ਅਤੇ ਚਿੱਪ ਕੌਂਫਿਗਰੇਸ਼ਨ) ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਬਾਕੀ 768 ਬਿੱਟ ਗਾਹਕ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਰਾਖਵੇਂ ਹਨ, ਸਮੇਤ ਫਲੈਸ਼-ਏਨਕ੍ਰਿਪਸ਼ਨ ਅਤੇ ਚਿੱਪ-ਆਈਡੀ)

ਏਮਬੇਡਡ ਫਲੈਸ਼: ਫਲੈਸ਼ IO16, IO17, SD_CMD, SD_CLK, SD_DATA_0 ਅਤੇ SD_DATA_1 ਦੁਆਰਾ ESP32-D2WD ਅਤੇ ESP32-PICO-D4 'ਤੇ ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ ਜੁੜੀ ਹੋਈ ਹੈ।

• 0 MiB (ESP32-D0WDQ6, ESP32-D0WD, ਅਤੇ ESP32-S0WD ਚਿਪਸ)
• 2 MiB (ESP32-D2WD ਚਿੱਪ)
• 4 MiB (ESP32-PICO-D4 SiP ਮੋਡੀਊਲ)

ਘੱਟ ਪਾਵਰ: ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਅਜੇ ਵੀ ਏਡੀਸੀ ਪਰਿਵਰਤਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਸਾਬਕਾ ਲਈample, ਡੂੰਘੀ ਨੀਂਦ ਦੌਰਾਨ.
ਪੈਰੀਫਿਰਲ ਇਨਪੁਟ/ਆਊਟਪੁੱਟ:

• DMA ਨਾਲ ਪੈਰੀਫਿਰਲ ਇੰਟਰਫੇਸ ਜਿਸ ਵਿੱਚ ਕੈਪੇਸਿਟਿਵ ਟੱਚ ਸ਼ਾਮਲ ਹੈ
• ADCs (ਐਨਾਲਾਗ-ਟੂ-ਡਿਜੀਟਲ ਪਰਿਵਰਤਕ)
• DACs (ਡਿਜੀਟਲ ਤੋਂ ਐਨਾਲਾਗ ਕਨਵਰਟਰ)
• I²C (ਅੰਤਰ-ਏਕੀਕ੍ਰਿਤ ਸਰਕਟ)
• UART (ਯੂਨੀਵਰਸਲ ਅਸਿੰਕ੍ਰੋਨਸ ਰਿਸੀਵਰ/ਟ੍ਰਾਂਸਮੀਟਰ)
• SPI (ਸੀਰੀਅਲ ਪੈਰੀਫਿਰਲ ਇੰਟਰਫੇਸ)
• I²S (ਏਕੀਕ੍ਰਿਤ ਇੰਟਰਚਿੱਪ ਧੁਨੀ)
• RMII (ਘਟਾਇਆ ਮੀਡੀਆ-ਸੁਤੰਤਰ ਇੰਟਰਫੇਸ)
• PWM (ਪਲਸ-ਚੌੜਾਈ ਮੋਡੂਲੇਸ਼ਨ)

ਸੁਰੱਖਿਆ: AES ਅਤੇ SSL/TLS ਲਈ ਹਾਰਡਵੇਅਰ ਐਕਸਲੇਟਰ

ESP32 ਵਿਕਾਸ ਬੋਰਡ

ESP32 ਬੇਅਰ ESP32 ਚਿੱਪ ਦਾ ਹਵਾਲਾ ਦਿੰਦਾ ਹੈ। ਹਾਲਾਂਕਿ, "ESP32" ਸ਼ਬਦ ਨੂੰ ESP32 ਵਿਕਾਸ ਬੋਰਡਾਂ ਦਾ ਹਵਾਲਾ ਦੇਣ ਲਈ ਵੀ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ESP32 ਬੇਅਰ ਚਿਪਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਆਸਾਨ ਜਾਂ ਵਿਹਾਰਕ ਨਹੀਂ ਹੈ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਸਿੱਖਣ, ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰੋਟੋਟਾਈਪਿੰਗ ਕਰਦੇ ਸਮੇਂ। ਜ਼ਿਆਦਾਤਰ ਸਮਾਂ, ਤੁਸੀਂ ਇੱਕ ESP32 ਵਿਕਾਸ ਬੋਰਡ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੋਗੇ।
ਅਸੀਂ ਇੱਕ ਸੰਦਰਭ ਵਜੋਂ ESP32 DEVKIT V1 ਬੋਰਡ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਹੇਠਾਂ ਦਿੱਤੀ ਤਸਵੀਰ ESP32 DEVKIT V1 ਬੋਰਡ, 30 GPIO ਪਿਨਾਂ ਵਾਲਾ ਸੰਸਕਰਣ ਦਿਖਾਉਂਦੀ ਹੈ।ਨਿਰਧਾਰਨ - ESP32 DEVKIT V1
ਹੇਠ ਦਿੱਤੀ ਸਾਰਣੀ ESP32 DEVKIT V1 DOIT ਬੋਰਡ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਸਾਰ ਦਰਸਾਉਂਦੀ ਹੈ:

ਕੋਰ ਦੀ ਸੰਖਿਆ	2 (ਦੋਹਰਾ ਕੋਰ)
ਵਾਈ-ਫਾਈ	2.4 GHz 150 Mbits/s ਤੱਕ
ਬਲੂਟੁੱਥ	BLE (ਬਲਿਊਟੁੱਥ ਲੋਅ ਐਨਰਜੀ) ਅਤੇ ਪੁਰਾਤਨ ਬਲੂਟੁੱਥ
ਆਰਕੀਟੈਕਚਰ	32 ਬਿੱਟ
ਘੜੀ ਦੀ ਬਾਰੰਬਾਰਤਾ	240 MHz ਤੱਕ
ਰੈਮ	512 KB
ਪਿੰਨ	30 (ਮਾਡਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ)

ਪੈਰੀਫਿਰਲ	Capacitive touch, ADC (ਐਨਾਲੌਗ ਤੋਂ ਡਿਜੀਟਲ ਕਨਵਰਟਰ), DAC (ਡਿਜੀਟਲ ਤੋਂ ਐਨਾਲਾਗ ਕਨਵਰਟਰ), 12C (ਇੰਟਰ-ਇੰਟੀਗ੍ਰੇਟਿਡ ਸਰਕਟ), UART (ਯੂਨੀਵਰਸਲ ਅਸਿੰਕ੍ਰੋਨਸ ਰਿਸੀਵਰ/ਟ੍ਰਾਂਸਮੀਟਰ), CAN 2.0 (ਕੰਟਰੋਲਰ ਏਰੀਆ ਨੈੱਟਵੋਕਰ), SPI (ਸੀਰੀਅਲ ਪੈਰੀਫਿਰਲ ਇੰਟਰਫੇਸ) , 12S (ਏਕੀਕ੍ਰਿਤ ਇੰਟਰ-ਆਈ.ਸੀ ਧੁਨੀ), RMII (ਰਿਡਿਊਸਡ ਮੀਡੀਆ-ਸੁਤੰਤਰ ਇੰਟਰਫੇਸ), PWM (ਪਲਸ ਚੌੜਾਈ ਮੋਡੂਲੇਸ਼ਨ), ਅਤੇ ਹੋਰ।
ਬਿਲਟ-ਇਨ ਬਟਨ	ਰੀਸੈੱਟ ਅਤੇ ਬੂਟ ਬਟਨ
ਬਿਲਟ-ਇਨ ਐਲ.ਈ.ਡੀ	ਬਿਲਟ-ਇਨ ਨੀਲਾ LED GPIO2 ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ; ਬਿਲਟ-ਇਨ ਲਾਲ LED ਜੋ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਬੋਰਡ ਨੂੰ ਸੰਚਾਲਿਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ
ਯੂਆਰਟੀ ਤੋਂ ਯੂਆਰਟੀ ਪੁਲ	CP2102

ਇਹ ਇੱਕ microUSB ਇੰਟਰਫੇਸ ਦੇ ਨਾਲ ਆਉਂਦਾ ਹੈ ਜਿਸਦੀ ਵਰਤੋਂ ਤੁਸੀਂ ਕੋਡ ਅੱਪਲੋਡ ਕਰਨ ਜਾਂ ਪਾਵਰ ਲਾਗੂ ਕਰਨ ਲਈ ਬੋਰਡ ਨੂੰ ਆਪਣੇ ਕੰਪਿਊਟਰ ਨਾਲ ਕਨੈਕਟ ਕਰਨ ਲਈ ਕਰ ਸਕਦੇ ਹੋ।
ਇਹ ਸੀਰੀਅਲ ਇੰਟਰਫੇਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ COM ਪੋਰਟ ਰਾਹੀਂ ਤੁਹਾਡੇ ਕੰਪਿਊਟਰ ਨਾਲ ਸੰਚਾਰ ਕਰਨ ਲਈ CP2102 ਚਿੱਪ (USB ਤੋਂ UART) ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਇੱਕ ਹੋਰ ਪ੍ਰਸਿੱਧ ਚਿੱਪ CH340 ਹੈ। ਜਾਂਚ ਕਰੋ ਕਿ ਤੁਹਾਡੇ ਬੋਰਡ 'ਤੇ USB ਤੋਂ UART ਚਿੱਪ ਕਨਵਰਟਰ ਕੀ ਹੈ ਕਿਉਂਕਿ ਤੁਹਾਨੂੰ ਲੋੜੀਂਦੇ ਡ੍ਰਾਈਵਰਾਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਦੀ ਲੋੜ ਪਵੇਗੀ ਤਾਂ ਜੋ ਤੁਹਾਡਾ ਕੰਪਿਊਟਰ ਬੋਰਡ ਨਾਲ ਸੰਚਾਰ ਕਰ ਸਕੇ (ਇਸ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਬਾਅਦ ਵਿੱਚ ਇਸ ਗਾਈਡ ਵਿੱਚ)।
ਇਹ ਬੋਰਡ ਬੋਰਡ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰਨ ਲਈ ਇੱਕ ਰੀਸੈੱਟ ਬਟਨ (EN ਲੇਬਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ) ਅਤੇ ਬੋਰਡ ਨੂੰ ਫਲੈਸ਼ਿੰਗ ਮੋਡ ਵਿੱਚ ਰੱਖਣ ਲਈ ਇੱਕ BOOT ਬਟਨ (ਕੋਡ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਉਪਲਬਧ) ਨਾਲ ਵੀ ਆਉਂਦਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਕੁਝ ਬੋਰਡਾਂ ਵਿੱਚ BOOT ਬਟਨ ਨਾ ਹੋਵੇ।
ਇਹ ਇੱਕ ਬਿਲਟ-ਇਨ ਨੀਲੇ LED ਦੇ ਨਾਲ ਵੀ ਆਉਂਦਾ ਹੈ ਜੋ ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ GPIO 2 ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ। ਇਹ LED ਕਿਸੇ ਕਿਸਮ ਦੀ ਵਿਜ਼ੂਅਲ ਭੌਤਿਕ ਆਉਟਪੁੱਟ ਦੇਣ ਲਈ ਡੀਬੱਗਿੰਗ ਲਈ ਉਪਯੋਗੀ ਹੈ। ਇੱਥੇ ਇੱਕ ਲਾਲ LED ਵੀ ਹੈ ਜੋ ਜਦੋਂ ਤੁਸੀਂ ਬੋਰਡ ਨੂੰ ਪਾਵਰ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹੋ ਤਾਂ ਰੌਸ਼ਨੀ ਹੁੰਦੀ ਹੈ।ESP32 ਪਿਨਆਉਟ
ESP32 ਪੈਰੀਫਿਰਲ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:

• 18 ਐਨਾਲਾਗ-ਟੂ-ਡਿਜੀਟਲ ਕਨਵਰਟਰ (ADC) ਚੈਨਲ
• 3 SPI ਇੰਟਰਫੇਸ
• 3 UART ਇੰਟਰਫੇਸ
• 2 I2C ਇੰਟਰਫੇਸ
• 16 PWM ਆਉਟਪੁੱਟ ਚੈਨਲ
• 2 ਡਿਜੀਟਲ ਤੋਂ ਐਨਾਲਾਗ ਪਰਿਵਰਤਕ (DAC)
• 2 I2S ਇੰਟਰਫੇਸ
• 10 ਕੈਪੇਸਿਟਿਵ ਸੈਂਸਿੰਗ GPIOs

ADC (ਐਨਾਲਾਗ ਤੋਂ ਡਿਜੀਟਲ ਕਨਵਰਟਰ) ਅਤੇ DAC (ਡਿਜੀਟਲ ਤੋਂ ਐਨਾਲਾਗ ਕਨਵਰਟਰ) ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਖਾਸ ਸਥਿਰ ਪਿੰਨਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ। ਹਾਲਾਂਕਿ, ਤੁਸੀਂ ਇਹ ਫੈਸਲਾ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਕਿਹੜੀਆਂ ਪਿੰਨ UART, I2C, SPI, PWM, ਆਦਿ ਹਨ - ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ਕੋਡ ਵਿੱਚ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਹ ESP32 ਚਿੱਪ ਦੀ ਮਲਟੀਪਲੈਕਸਿੰਗ ਵਿਸ਼ੇਸ਼ਤਾ ਦੇ ਕਾਰਨ ਸੰਭਵ ਹੋਇਆ ਹੈ।
ਹਾਲਾਂਕਿ ਤੁਸੀਂ ਸਾਫਟਵੇਅਰ 'ਤੇ ਪਿੰਨ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹੋ, ਹੇਠਾਂ ਦਿੱਤੇ ਚਿੱਤਰ ਵਿੱਚ ਦਰਸਾਏ ਅਨੁਸਾਰ ਡਿਫੌਲਟ ਤੌਰ 'ਤੇ ਪਿੰਨ ਨਿਰਧਾਰਤ ਕੀਤੇ ਗਏ ਹਨਇਸ ਤੋਂ ਇਲਾਵਾ, ਖਾਸ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਾਲੇ ਪਿੰਨ ਹਨ ਜੋ ਉਹਨਾਂ ਨੂੰ ਕਿਸੇ ਖਾਸ ਪ੍ਰੋਜੈਕਟ ਲਈ ਢੁਕਵਾਂ ਬਣਾਉਂਦੇ ਹਨ ਜਾਂ ਨਹੀਂ। ਹੇਠਾਂ ਦਿੱਤੀ ਸਾਰਣੀ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਕਿਹੜੀਆਂ ਪਿੰਨਾਂ ਨੂੰ ਇਨਪੁਟਸ, ਆਉਟਪੁੱਟ ਦੇ ਤੌਰ 'ਤੇ ਵਰਤਣਾ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਕਿਨ੍ਹਾਂ ਤੋਂ ਸਾਵਧਾਨ ਰਹਿਣ ਦੀ ਲੋੜ ਹੈ।
ਹਰੇ ਰੰਗ ਵਿੱਚ ਉਜਾਗਰ ਕੀਤੇ ਪਿੰਨ ਵਰਤਣ ਲਈ ਠੀਕ ਹਨ। ਪੀਲੇ ਰੰਗ ਵਿੱਚ ਉਜਾਗਰ ਕੀਤੇ ਗਏ ਵਰਤਣ ਲਈ ਠੀਕ ਹਨ, ਪਰ ਤੁਹਾਨੂੰ ਧਿਆਨ ਦੇਣ ਦੀ ਲੋੜ ਹੈ ਕਿਉਂਕਿ ਉਹਨਾਂ ਦਾ ਮੁੱਖ ਤੌਰ 'ਤੇ ਬੂਟ ਹੋਣ ਵੇਲੇ ਅਚਾਨਕ ਵਿਵਹਾਰ ਹੋ ਸਕਦਾ ਹੈ। ਲਾਲ ਰੰਗ ਵਿੱਚ ਉਜਾਗਰ ਕੀਤੇ ਪਿੰਨਾਂ ਨੂੰ ਇਨਪੁਟਸ ਜਾਂ ਆਉਟਪੁੱਟ ਵਜੋਂ ਵਰਤਣ ਦੀ ਸਿਫਾਰਸ਼ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ।

ਜੀਪੀ ਆਈ.ਓ	ਇੰਪੁੱਟ	ਆਉਟਪੁੱਟ	ਨੋਟਸ
0	ਖਿੱਚਿਆ	OK	ਬੂਟ ਹੋਣ 'ਤੇ PWM ਸਿਗਨਲ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ, ਫਲੈਸ਼ਿੰਗ ਮੋਡ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਲਈ ਘੱਟ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
1	TX ਪਿੰਨ	OK	ਬੂਟ ਤੇ ਡੀਬੱਗ ਆਉਟਪੁੱਟ
2	OK	OK	ਆਨ-ਬੋਰਡ LED ਨਾਲ ਜੁੜਿਆ, ਫਲੈਸ਼ਿੰਗ ਮੋਡ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਲਈ ਫਲੋਟਿੰਗ ਜਾਂ ਨੀਵਾਂ ਛੱਡਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ
3	OK	RX ਪਿੰਨ	ਬੂਟ 'ਤੇ ਉੱਚ
4	OK	OK
5	OK	OK	ਬੂਟ, ਸਟ੍ਰੈਪਿੰਗ ਪਿੰਨ 'ਤੇ PWM ਸਿਗਨਲ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ
12	OK	OK	ਬੂਟ ਫੇਲ ਹੁੰਦਾ ਹੈ ਜੇਕਰ ਉੱਚਾ, ਸਟ੍ਰੈਪਿੰਗ ਪਿੰਨ ਖਿੱਚਿਆ ਜਾਵੇ
13	OK	OK
14	OK	OK	ਬੂਟ ਹੋਣ 'ਤੇ PWM ਸਿਗਨਲ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ
15	OK	OK	ਬੂਟ, ਸਟ੍ਰੈਪਿੰਗ ਪਿੰਨ 'ਤੇ PWM ਸਿਗਨਲ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ

16	OK	OK
17	OK	OK
18	OK	OK
19	OK	OK
21	OK	OK
22	OK	OK
23	OK	OK
25	OK	OK
26	OK	OK
27	OK	OK
32	OK	OK
33	OK	OK
34	OK		ਸਿਰਫ਼ ਇੰਪੁੱਟ
35	OK		ਸਿਰਫ਼ ਇੰਪੁੱਟ
36	OK		ਸਿਰਫ਼ ਇੰਪੁੱਟ
39	OK		ਸਿਰਫ਼ ਇੰਪੁੱਟ

ESP32 GPIOs ਅਤੇ ਇਸਦੇ ਕਾਰਜਾਂ ਦੇ ਵਧੇਰੇ ਵਿਸਥਾਰ ਅਤੇ ਡੂੰਘਾਈ ਨਾਲ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਪੜ੍ਹਨਾ ਜਾਰੀ ਰੱਖੋ।
ਇਨਪੁਟ ਸਿਰਫ਼ ਪਿੰਨ
GPIOs 34 ਤੋਂ 39 GPIs ਹਨ - ਇਨਪੁਟ ਕੇਵਲ ਪਿੰਨ। ਇਹਨਾਂ ਪਿੰਨਾਂ ਵਿੱਚ ਅੰਦਰੂਨੀ ਪੁੱਲ-ਅੱਪ ਜਾਂ ਪੁੱਲ-ਡਾਊਨ ਰੋਧਕ ਨਹੀਂ ਹੁੰਦੇ ਹਨ। ਉਹਨਾਂ ਨੂੰ ਆਉਟਪੁੱਟ ਦੇ ਤੌਰ ਤੇ ਨਹੀਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਇਸਲਈ ਇਹਨਾਂ ਪਿੰਨਾਂ ਨੂੰ ਸਿਰਫ ਇਨਪੁਟਸ ਦੇ ਤੌਰ ਤੇ ਹੀ ਵਰਤੋ:

• GPIO 34
• GPIO 35
• GPIO 36
• GPIO 39

SPI ਫਲੈਸ਼ ESP-WROOM-32 'ਤੇ ਏਕੀਕ੍ਰਿਤ ਹੈ
GPIO 6 ਤੋਂ GPIO 11 ਕੁਝ ESP32 ਵਿਕਾਸ ਬੋਰਡਾਂ ਵਿੱਚ ਪ੍ਰਗਟ ਕੀਤੇ ਗਏ ਹਨ। ਹਾਲਾਂਕਿ, ਇਹ ਪਿੰਨ ESP-WROOM-32 ਚਿੱਪ 'ਤੇ ਏਕੀਕ੍ਰਿਤ SPI ਫਲੈਸ਼ ਨਾਲ ਜੁੜੇ ਹੋਏ ਹਨ ਅਤੇ ਹੋਰ ਵਰਤੋਂ ਲਈ ਸਿਫ਼ਾਰਸ਼ ਨਹੀਂ ਕੀਤੇ ਗਏ ਹਨ। ਇਸ ਲਈ, ਆਪਣੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਇਹਨਾਂ ਪਿੰਨਾਂ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ:

• GPIO 6 (SCK/CLK)
• GPIO 7 (SDO/SD0)
• GPIO 8 (SDI/SD1)
• GPIO 9 (SHD/SD2)
• GPIO 10 (SWP/SD3)
• GPIO 11 (CSC/CMD)

Capacitive touch GPIOs
ESP32 ਵਿੱਚ 10 ਅੰਦਰੂਨੀ ਕੈਪੇਸਿਟਿਵ ਟੱਚ ਸੈਂਸਰ ਹਨ। ਇਹ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਵਿੱਚ ਭਿੰਨਤਾਵਾਂ ਨੂੰ ਮਹਿਸੂਸ ਕਰ ਸਕਦੇ ਹਨ ਜਿਸ ਵਿੱਚ ਬਿਜਲੀ ਦਾ ਚਾਰਜ ਹੁੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਮਨੁੱਖੀ ਚਮੜੀ। ਇਸ ਲਈ ਉਹ ਉਂਗਲੀ ਨਾਲ GPIOs ਨੂੰ ਛੂਹਣ ਵੇਲੇ ਪ੍ਰੇਰਿਤ ਭਿੰਨਤਾਵਾਂ ਦਾ ਪਤਾ ਲਗਾ ਸਕਦੇ ਹਨ। ਇਹਨਾਂ ਪਿੰਨਾਂ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਕੈਪੇਸਿਟਿਵ ਪੈਡਾਂ ਵਿੱਚ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਮਕੈਨੀਕਲ ਬਟਨਾਂ ਨੂੰ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ। ESP32 ਨੂੰ ਡੂੰਘੀ ਨੀਂਦ ਤੋਂ ਜਗਾਉਣ ਲਈ Capacitive ਟੱਚ ਪਿੰਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਉਹ ਅੰਦਰੂਨੀ ਟੱਚ ਸੈਂਸਰ ਇਹਨਾਂ GPIOs ਨਾਲ ਜੁੜੇ ਹੋਏ ਹਨ:

• T0 (GPIO 4)
• T1 (GPIO 0)
• T2 (GPIO 2)
• T3 (GPIO 15)
• T4 (GPIO 13)
• T5 (GPIO 12)
• T6 (GPIO 14)
• T7 (GPIO 27)
• T8 (GPIO 33)
• T9 (GPIO 32)

ਡਿਜੀਟਲ ਕਨਵਰਟਰ (ਏ ਡੀ ਸੀ) ਦਾ ਐਨਾਲਾਗ
ESP32 ਵਿੱਚ 18 x 12 ਬਿੱਟ ADC ਇਨਪੁਟ ਚੈਨਲ ਹਨ (ਜਦਕਿ ESP8266 ਵਿੱਚ ਸਿਰਫ਼ 1x 10 ਬਿੱਟ ADC ਹੈ)। ਇਹ ਉਹ GPIO ਹਨ ਜੋ ADC ਅਤੇ ਸੰਬੰਧਿਤ ਚੈਨਲਾਂ ਵਜੋਂ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ:

• ADC1_CH0 (GPIO 36)
• ADC1_CH1 (GPIO 37)
• ADC1_CH2 (GPIO 38)
• ADC1_CH3 (GPIO 39)
• ADC1_CH4 (GPIO 32)
• ADC1_CH5 (GPIO 33)
• ADC1_CH6 (GPIO 34)
• ADC1_CH7 (GPIO 35)
• ADC2_CH0 (GPIO 4)
• ADC2_CH1 (GPIO 0)
• ADC2_CH2 (GPIO 2)
• ADC2_CH3 (GPIO 15)
• ADC2_CH4 (GPIO 13)
• ADC2_CH5 (GPIO 12)
• ADC2_CH6 (GPIO 14)
• ADC2_CH7 (GPIO 27)
• ADC2_CH8 (GPIO 25)
• ADC2_CH9 (GPIO 26)

ਨੋਟ: ਜਦੋਂ ਵਾਈ-ਫਾਈ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਤਾਂ ADC2 ਪਿੰਨ ਨਹੀਂ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਇਸ ਲਈ, ਜੇਕਰ ਤੁਸੀਂ Wi-Fi ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ ਅਤੇ ਤੁਹਾਨੂੰ ADC2 GPIO ਤੋਂ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਵਿੱਚ ਮੁਸ਼ਕਲ ਆ ਰਹੀ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇਸਦੀ ਬਜਾਏ ADC1 GPIO ਦੀ ਵਰਤੋਂ ਕਰਨ ਬਾਰੇ ਵਿਚਾਰ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਤੁਹਾਡੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ.
ADC ਇਨਪੁਟ ਚੈਨਲਾਂ ਦਾ 12-ਬਿੱਟ ਰੈਜ਼ੋਲਿਊਸ਼ਨ ਹੁੰਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਤੁਸੀਂ 0 ਤੋਂ 4095 ਤੱਕ ਐਨਾਲਾਗ ਰੀਡਿੰਗ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ, ਜਿਸ ਵਿੱਚ 0 0V ਅਤੇ 4095 ਤੋਂ 3.3V ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਤੁਸੀਂ ਕੋਡ ਅਤੇ ADC ਰੇਂਜ 'ਤੇ ਆਪਣੇ ਚੈਨਲਾਂ ਦਾ ਰੈਜ਼ੋਲਿਊਸ਼ਨ ਵੀ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹੋ।
ESP32 ADC ਪਿੰਨਾਂ ਦਾ ਕੋਈ ਰੇਖਿਕ ਵਿਵਹਾਰ ਨਹੀਂ ਹੁੰਦਾ ਹੈ। ਤੁਸੀਂ ਸ਼ਾਇਦ 0 ਅਤੇ 0.1V, ਜਾਂ 3.2 ਅਤੇ 3.3V ਵਿਚਕਾਰ ਫਰਕ ਕਰਨ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਵੋਗੇ। ADC ਪਿੰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਤੁਹਾਨੂੰ ਇਸ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਚਿੱਤਰ ਵਿੱਚ ਦਿਖਾਏ ਗਏ ਇੱਕ ਵਰਗਾ ਵਿਵਹਾਰ ਮਿਲੇਗਾ।ਡਿਜੀਟਲ ਤੋਂ ਐਨਾਲਾਗ ਕਨਵਰਟਰ (DAC)
ਡਿਜੀਟਲ ਸਿਗਨਲਾਂ ਨੂੰ ਐਨਾਲਾਗ ਵੋਲ ਵਿੱਚ ਬਦਲਣ ਲਈ ESP2 ਉੱਤੇ 8 x 32 ਬਿੱਟ DAC ਚੈਨਲ ਹਨ।tage ਸਿਗਨਲ ਆਉਟਪੁੱਟ। ਇਹ DAC ਚੈਨਲ ਹਨ:

• DAC1 (GPIO25)
• DAC2 (GPIO26)

RTC GPIOs
ESP32 'ਤੇ RTC GPIO ਸਪੋਰਟ ਹੈ। RTC ਘੱਟ-ਪਾਵਰ ਸਬ-ਸਿਸਟਮ ਲਈ ਰੂਟ ਕੀਤੇ GPIOs ਦੀ ਵਰਤੋਂ ਉਦੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜਦੋਂ ESP32 ਡੂੰਘੀ ਨੀਂਦ ਵਿੱਚ ਹੋਵੇ। ਇਹ RTC GPIOs ਦੀ ਵਰਤੋਂ ESP32 ਨੂੰ ਡੂੰਘੀ ਨੀਂਦ ਤੋਂ ਜਗਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜਦੋਂ ਅਲਟਰਾ ਲੋਅ
ਪਾਵਰ (ULP) ਕੋ-ਪ੍ਰੋਸੈਸਰ ਚੱਲ ਰਿਹਾ ਹੈ। ਹੇਠਾਂ ਦਿੱਤੇ GPIOs ਨੂੰ ਬਾਹਰੀ ਵੇਕ ਅੱਪ ਸਰੋਤ ਵਜੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

• RTC_GPIO0 (GPIO36)
• RTC_GPIO3 (GPIO39)
• RTC_GPIO4 (GPIO34)
• RTC_GPIO5 (GPIO35)
• RTC_GPIO6 (GPIO25)
• RTC_GPIO7 (GPIO26)
• RTC_GPIO8 (GPIO33)
• RTC_GPIO9 (GPIO32)
• RTC_GPIO10 (GPIO4)
• RTC_GPIO11 (GPIO0)
• RTC_GPIO12 (GPIO2)
• RTC_GPIO13 (GPIO15)
• RTC_GPIO14 (GPIO13)
• RTC_GPIO15 (GPIO12)
• RTC_GPIO16 (GPIO14)
• RTC_GPIO17 (GPIO27)

PWM
ESP32 LED PWM ਕੰਟਰੋਲਰ ਵਿੱਚ 16 ਸੁਤੰਤਰ ਚੈਨਲ ਹਨ ਜੋ ਵੱਖ-ਵੱਖ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਨਾਲ PWM ਸਿਗਨਲ ਬਣਾਉਣ ਲਈ ਕੌਂਫਿਗਰ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਸਾਰੇ ਪਿੰਨ ਜੋ ਆਉਟਪੁੱਟ ਦੇ ਤੌਰ ਤੇ ਕੰਮ ਕਰ ਸਕਦੇ ਹਨ PWM ਪਿੰਨ ਦੇ ਤੌਰ ਤੇ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ (GPIOs 34 ਤੋਂ 39 PWM ਤਿਆਰ ਨਹੀਂ ਕਰ ਸਕਦੇ ਹਨ)।
ਇੱਕ PWM ਸਿਗਨਲ ਸੈੱਟ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਕੋਡ ਵਿੱਚ ਇਹਨਾਂ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

• ਸਿਗਨਲ ਦੀ ਬਾਰੰਬਾਰਤਾ;
• ਡਿਊਟੀ ਚੱਕਰ;
• PWM ਚੈਨਲ;
• GPIO ਜਿੱਥੇ ਤੁਸੀਂ ਸਿਗਨਲ ਆਉਟਪੁੱਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ।

I2C
ESP32 ਦੇ ਦੋ I2C ਚੈਨਲ ਹਨ ਅਤੇ ਕਿਸੇ ਵੀ ਪਿੰਨ ਨੂੰ SDA ਜਾਂ SCL ਵਜੋਂ ਸੈੱਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। Arduino IDE ਨਾਲ ESP32 ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਡਿਫੌਲਟ I2C ਪਿੰਨ ਹਨ:

• GPIO 21 (SDA)
• GPIO 22 (SCL)

ਜੇਕਰ ਤੁਸੀਂ ਵਾਇਰ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਹੋਰ ਪਿੰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਕਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:
Wire.begin(SDA, SCL);
ਐਸ.ਪੀ.ਆਈ
ਮੂਲ ਰੂਪ ਵਿੱਚ, SPI ਲਈ ਪਿੰਨ ਮੈਪਿੰਗ ਹੈ:

ਐਸ.ਪੀ.ਆਈ	ਮੋਸੀ	ਮੀਸੋ	ਸੀ.ਐਲ.ਕੇ	CS
ਵੀ.ਐਸ.ਪੀ.ਆਈ	GPIO 23	GPIO 19	GPIO 18	GPIO 5
HSPI	GPIO 13	GPIO 12	GPIO 14	GPIO 15

ਰੁਕਾਵਟਾਂ
ਸਾਰੇ GPIO ਨੂੰ ਰੁਕਾਵਟਾਂ ਵਜੋਂ ਸੰਰਚਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
ਸਟ੍ਰੈਪਿੰਗ ਪਿੰਨ
ESP32 ਚਿੱਪ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਸਟ੍ਰੈਪਿੰਗ ਪਿੰਨ ਹਨ:

• GPIO 0 (ਬੂਟ ਮੋਡ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਲਈ ਘੱਟ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ)
• GPIO 2 (ਬੂਟ ਦੌਰਾਨ ਫਲੋਟਿੰਗ ਜਾਂ ਘੱਟ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ)
• GPIO 4
• GPIO 5 (ਬੂਟ ਦੌਰਾਨ ਉੱਚਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ)
• GPIO 12 (ਬੂਟ ਦੌਰਾਨ ਘੱਟ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ)
• GPIO 15 (ਬੂਟ ਦੌਰਾਨ ਉੱਚਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ)

ਇਹਨਾਂ ਦੀ ਵਰਤੋਂ ESP32 ਨੂੰ ਬੂਟਲੋਡਰ ਜਾਂ ਫਲੈਸ਼ਿੰਗ ਮੋਡ ਵਿੱਚ ਪਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਬਿਲਟ-ਇਨ USB/ਸੀਰੀਅਲ ਵਾਲੇ ਜ਼ਿਆਦਾਤਰ ਵਿਕਾਸ ਬੋਰਡਾਂ 'ਤੇ, ਤੁਹਾਨੂੰ ਇਹਨਾਂ ਪਿੰਨਾਂ ਦੀ ਸਥਿਤੀ ਬਾਰੇ ਚਿੰਤਾ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਫਲੈਸ਼ਿੰਗ ਜਾਂ ਬੂਟ ਮੋਡ ਲਈ ਬੋਰਡ ਪਿੰਨਾਂ ਨੂੰ ਸਹੀ ਸਥਿਤੀ ਵਿੱਚ ਰੱਖਦਾ ਹੈ। ESP32 ਬੂਟ ਮੋਡ ਚੋਣ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਇੱਥੇ ਲੱਭੀ ਜਾ ਸਕਦੀ ਹੈ।
ਹਾਲਾਂਕਿ, ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਉਹਨਾਂ ਪਿੰਨਾਂ ਨਾਲ ਜੁੜੇ ਪੈਰੀਫਿਰਲ ਹਨ, ਤਾਂ ਤੁਹਾਨੂੰ ਨਵਾਂ ਕੋਡ ਅੱਪਲੋਡ ਕਰਨ, ਨਵੇਂ ਫਰਮਵੇਅਰ ਨਾਲ ESP32 ਨੂੰ ਫਲੈਸ਼ ਕਰਨ, ਜਾਂ ਬੋਰਡ ਨੂੰ ਰੀਸੈਟ ਕਰਨ ਵਿੱਚ ਮੁਸ਼ਕਲ ਆ ਸਕਦੀ ਹੈ। ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਸਟ੍ਰੈਪਿੰਗ ਪਿੰਨ ਨਾਲ ਜੁੜੇ ਕੁਝ ਪੈਰੀਫਿਰਲ ਹਨ ਅਤੇ ਤੁਹਾਨੂੰ ਕੋਡ ਅੱਪਲੋਡ ਕਰਨ ਜਾਂ ESP32 ਨੂੰ ਫਲੈਸ਼ ਕਰਨ ਵਿੱਚ ਮੁਸ਼ਕਲ ਆ ਰਹੀ ਹੈ, ਤਾਂ ਇਹ ਇਸ ਲਈ ਹੋ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ ਉਹ ਪੈਰੀਫਿਰਲ ESP32 ਨੂੰ ਸਹੀ ਮੋਡ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਤੋਂ ਰੋਕ ਰਹੇ ਹਨ। ਸਹੀ ਦਿਸ਼ਾ ਵਿੱਚ ਤੁਹਾਡੀ ਅਗਵਾਈ ਕਰਨ ਲਈ ਬੂਟ ਮੋਡ ਚੋਣ ਦਸਤਾਵੇਜ਼ ਪੜ੍ਹੋ। ਰੀਸੈਟ ਕਰਨ, ਫਲੈਸ਼ ਕਰਨ, ਜਾਂ ਬੂਟ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਉਹ ਪਿੰਨ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਕਰਦੇ ਹਨ।
ਬੂਟ 'ਤੇ ਉੱਚੀ ਪਿੰਨ
ਕੁਝ GPIOs ਬੂਟ ਜਾਂ ਰੀਸੈਟ 'ਤੇ ਆਪਣੀ ਸਥਿਤੀ ਨੂੰ ਉੱਚ ਜਾਂ ਆਉਟਪੁੱਟ PWM ਸਿਗਨਲਾਂ ਵਿੱਚ ਬਦਲਦੇ ਹਨ।
ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਇਹਨਾਂ GPIOs ਨਾਲ ਕਨੈਕਟ ਕੀਤੇ ਆਉਟਪੁੱਟ ਹਨ ਤਾਂ ਤੁਸੀਂ ESP32 ਰੀਸੈੱਟ ਜਾਂ ਬੂਟ ਹੋਣ 'ਤੇ ਅਚਾਨਕ ਨਤੀਜੇ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ।

• GPIO 1
• GPIO 3
• GPIO 5
• GPIO 6 ਤੋਂ GPIO 11 (ESP32 ਏਕੀਕ੍ਰਿਤ SPI ਫਲੈਸ਼ ਮੈਮੋਰੀ ਨਾਲ ਜੁੜਿਆ – ਵਰਤਣ ਦੀ ਸਿਫਾਰਸ਼ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ)।
• GPIO 14
• GPIO 15

ਸਮਰੱਥ (EN)
ਸਮਰੱਥ (EN) 3.3V ਰੈਗੂਲੇਟਰ ਦਾ ਯੋਗ ਪਿੰਨ ਹੈ। ਇਹ ਖਿੱਚਿਆ ਗਿਆ ਹੈ, ਇਸ ਲਈ 3.3V ਰੈਗੂਲੇਟਰ ਨੂੰ ਅਸਮਰੱਥ ਬਣਾਉਣ ਲਈ ਜ਼ਮੀਨ ਨਾਲ ਜੁੜੋ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਆਪਣੇ ESP32 ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰਨ ਲਈ ਇੱਕ ਪੁਸ਼ਬਟਨ ਨਾਲ ਜੁੜੇ ਇਸ ਪਿੰਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਸਾਬਕਾ ਲਈample.
GPIO ਮੌਜੂਦਾ ਖਿੱਚਿਆ ਗਿਆ
ESP40 ਡੇਟਾਸ਼ੀਟ ਵਿੱਚ "ਸਿਫਾਰਿਸ਼ ਕੀਤੇ ਓਪਰੇਟਿੰਗ ਸ਼ਰਤਾਂ" ਸੈਕਸ਼ਨ ਦੇ ਅਨੁਸਾਰ ਪ੍ਰਤੀ GPIO 32mA ਕੱਢਿਆ ਗਿਆ ਪੂਰਨ ਅਧਿਕਤਮ ਵਰਤਮਾਨ ਹੈ।
ESP32 ਬਿਲਟ-ਇਨ ਹਾਲ ਇਫੈਕਟ ਸੈਂਸਰ
ESP32 ਵਿੱਚ ਇੱਕ ਬਿਲਟ-ਇਨ ਹਾਲ ਇਫੈਕਟ ਸੈਂਸਰ ਵੀ ਹੈ ਜੋ ਇਸਦੇ ਆਲੇ ਦੁਆਲੇ ਦੇ ਚੁੰਬਕੀ ਖੇਤਰ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਦਾ ਪਤਾ ਲਗਾਉਂਦਾ ਹੈ।
ESP32 Arduino IDE
Arduino IDE ਲਈ ਇੱਕ ਐਡ-ਆਨ ਹੈ ਜੋ ਤੁਹਾਨੂੰ Arduino IDE ਅਤੇ ਇਸਦੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ESP32 ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ ਤੁਹਾਨੂੰ ਦਿਖਾਵਾਂਗੇ ਕਿ ESP32 ਬੋਰਡ ਨੂੰ Arduino IDE ਵਿੱਚ ਕਿਵੇਂ ਇੰਸਟਾਲ ਕਰਨਾ ਹੈ ਭਾਵੇਂ ਤੁਸੀਂ ਵਿੰਡੋਜ਼, ਮੈਕ ਓਐਸ ਐਕਸ ਜਾਂ ਲੀਨਕਸ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ।
ਪੂਰਵ-ਸ਼ਰਤਾਂ: Arduino IDE ਸਥਾਪਿਤ
ਇਸ ਇੰਸਟਾਲੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਆਪਣੇ ਕੰਪਿਊਟਰ 'ਤੇ Arduino IDE ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। Arduino IDE ਦੇ ਦੋ ਸੰਸਕਰਣ ਹਨ ਜੋ ਤੁਸੀਂ ਸਥਾਪਿਤ ਕਰ ਸਕਦੇ ਹੋ: ਸੰਸਕਰਣ 1 ਅਤੇ ਸੰਸਕਰਣ 2।
ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਲਿੰਕ 'ਤੇ ਕਲਿੱਕ ਕਰਕੇ Arduino IDE ਨੂੰ ਡਾਊਨਲੋਡ ਅਤੇ ਸਥਾਪਿਤ ਕਰ ਸਕਦੇ ਹੋ: arduino.cc/en/Main/Software
ਅਸੀਂ ਕਿਹੜੇ Arduino IDE ਸੰਸਕਰਣ ਦੀ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦੇ ਹਾਂ? ਇਸ ਸਮੇਂ, ਕੁਝ ਹਨ plugins ESP32 ਲਈ (ਜਿਵੇਂ ਕਿ SPIFFS Fileਸਿਸਟਮ ਅਪਲੋਡਰ ਪਲੱਗਇਨ) ਜੋ ਕਿ ਅਜੇ ਅਰਡਿਊਨੋ 2 'ਤੇ ਸਮਰਥਿਤ ਨਹੀਂ ਹਨ। ਇਸ ਲਈ, ਜੇਕਰ ਤੁਸੀਂ ਭਵਿੱਖ ਵਿੱਚ SPIFFS ਪਲੱਗਇਨ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਅਸੀਂ ਪੁਰਾਤਨ ਸੰਸਕਰਣ 1.8.X ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦੇ ਹਾਂ। ਇਸ ਨੂੰ ਲੱਭਣ ਲਈ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ Arduino ਸੌਫਟਵੇਅਰ ਪੰਨੇ 'ਤੇ ਹੇਠਾਂ ਸਕ੍ਰੋਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
Arduino IDE ਵਿੱਚ ESP32 ਐਡ-ਆਨ ਇੰਸਟਾਲ ਕਰਨਾ
ਆਪਣੇ Arduino IDE ਵਿੱਚ ESP32 ਬੋਰਡ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ, ਇਹਨਾਂ ਅਗਲੀਆਂ ਹਦਾਇਤਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ:

1. ਆਪਣੇ Arduino IDE ਵਿੱਚ, 'ਤੇ ਜਾਓ File> ਤਰਜੀਹਾਂ
2. "ਵਧੀਕ ਬੋਰਡ ਮੈਨੇਜਰ ਵਿੱਚ ਹੇਠਾਂ ਦਰਜ ਕਰੋ URLs" ਖੇਤਰ:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
ਫਿਰ, "ਠੀਕ ਹੈ" ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰੋ:ਨੋਟ: ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ESP8266 ਬੋਰਡ ਹਨ URL, ਤੁਸੀਂ ਵੱਖ ਕਰ ਸਕਦੇ ਹੋ URLਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਕੌਮੇ ਨਾਲ s:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json,
http://arduino.esp8266.com/stable/package_esp8266com_index.json
ਬੋਰਡ ਮੈਨੇਜਰ ਖੋਲ੍ਹੋ। ਟੂਲ > ਬੋਰਡ > ਬੋਰਡ ਮੈਨੇਜਰ ‘ਤੇ ਜਾਓ…ਲਈ ਖੋਜ ESP32 and press install button for the “ESP32 by Espressif Systems“:ਇਹ ਹੀ ਗੱਲ ਹੈ. ਇਸ ਨੂੰ ਕੁਝ ਸਕਿੰਟਾਂ ਬਾਅਦ ਸਥਾਪਿਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ.

ਟੈਸਟ ਕੋਡ ਅੱਪਲੋਡ ਕਰੋ

ESP32 ਬੋਰਡ ਨੂੰ ਆਪਣੇ ਕੰਪਿਊਟਰ ਨਾਲ ਲਗਾਓ। ਤੁਹਾਡੇ Arduino IDE ਖੁੱਲ੍ਹਣ ਦੇ ਨਾਲ, ਇਹਨਾਂ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ:

1. ਟੂਲਸ > ਬੋਰਡ ਮੀਨੂ ਵਿੱਚ ਆਪਣਾ ਬੋਰਡ ਚੁਣੋ (ਮੇਰੇ ਕੇਸ ਵਿੱਚ ਇਹ ESP32 DEV ਮੋਡੀਊਲ ਹੈ)
2. ਪੋਰਟ ਚੁਣੋ (ਜੇਕਰ ਤੁਸੀਂ ਆਪਣੇ Arduino IDE ਵਿੱਚ COM ਪੋਰਟ ਨਹੀਂ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ CP210x USB ਨੂੰ UART ਬ੍ਰਿਜ VCP ਡਰਾਈਵਰਾਂ ਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ):
3. ਹੇਠ ਦਿੱਤੇ ਸਾਬਕਾ ਨੂੰ ਖੋਲ੍ਹੋampਹੇਠ File > ਸਾਬਕਾamples > WiFi
   (ESP32) > WiFiScan
4. ਤੁਹਾਡੇ Arduino IDE ਵਿੱਚ ਇੱਕ ਨਵਾਂ ਸਕੈਚ ਖੁੱਲ੍ਹਦਾ ਹੈ:
5. Arduino IDE ਵਿੱਚ ਅੱਪਲੋਡ ਬਟਨ ਦਬਾਓ। ਕੋਡ ਕੰਪਾਇਲ ਅਤੇ ਤੁਹਾਡੇ ਬੋਰਡ 'ਤੇ ਅੱਪਲੋਡ ਹੋਣ ਤੱਕ ਕੁਝ ਸਕਿੰਟ ਉਡੀਕ ਕਰੋ।
6. ਜੇਕਰ ਸਭ ਕੁਝ ਉਮੀਦ ਅਨੁਸਾਰ ਚੱਲਦਾ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ "ਅੱਪਲੋਡਿੰਗ ਹੋ ਗਿਆ" ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ। ਸੁਨੇਹਾ।
7. Arduino IDE ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਨੂੰ 115200 ਦੀ ਬੌਡ ਦਰ 'ਤੇ ਖੋਲ੍ਹੋ:
8. ESP32 ਆਨ-ਬੋਰਡ ਸਮਰੱਥ ਬਟਨ ਨੂੰ ਦਬਾਓ ਅਤੇ ਤੁਹਾਨੂੰ ਆਪਣੇ ESP32 ਦੇ ਨੇੜੇ ਉਪਲਬਧ ਨੈੱਟਵਰਕ ਦੇਖਣੇ ਚਾਹੀਦੇ ਹਨ:

ਸਮੱਸਿਆ ਨਿਪਟਾਰਾ

ਜੇਕਰ ਤੁਸੀਂ ਆਪਣੇ ESP32 'ਤੇ ਇੱਕ ਨਵਾਂ ਸਕੈਚ ਅੱਪਲੋਡ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ ਅਤੇ ਤੁਹਾਨੂੰ ਇਹ ਗਲਤੀ ਸੁਨੇਹਾ ਮਿਲਦਾ ਹੈ "ਇੱਕ ਘਾਤਕ ਗਲਤੀ ਆਈ ਹੈ: ESP32 ਨਾਲ ਕਨੈਕਟ ਕਰਨ ਵਿੱਚ ਅਸਫਲ: ਸਮਾਂ ਸਮਾਪਤ ਹੋਇਆ... ਕਨੈਕਟ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ..."। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਡਾ ESP32 ਫਲੈਸ਼ਿੰਗ/ਅੱਪਲੋਡਿੰਗ ਮੋਡ ਵਿੱਚ ਨਹੀਂ ਹੈ।
ਸਹੀ ਬੋਰਡ ਨਾਮ ਅਤੇ COM ਚੁਣੇ ਜਾਣ ਤੋਂ ਬਾਅਦ, ਇਹਨਾਂ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ:
ਆਪਣੇ ESP32 ਬੋਰਡ ਵਿੱਚ "BOOT" ਬਟਨ ਨੂੰ ਦਬਾ ਕੇ ਰੱਖੋ

• ਆਪਣਾ ਸਕੈਚ ਅੱਪਲੋਡ ਕਰਨ ਲਈ Arduino IDE ਵਿੱਚ "ਅੱਪਲੋਡ" ਬਟਨ ਦਬਾਓ:
• ਜਦੋਂ ਤੁਸੀਂ "ਕਨੈਕਟ ਕਰ ਰਿਹਾ ਹੈ..." ਦੇਖਣ ਤੋਂ ਬਾਅਦ ਆਪਣੇ Arduino IDE ਵਿੱਚ ਸੁਨੇਹਾ, "BOOT" ਬਟਨ ਤੋਂ ਉਂਗਲ ਛੱਡੋ:
• ਉਸ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ "ਅੱਪਲੋਡਿੰਗ ਹੋ ਗਿਆ" ਸੁਨੇਹਾ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ
  ਇਹ ਹੀ ਗੱਲ ਹੈ. ਤੁਹਾਡੇ ESP32 ਵਿੱਚ ਨਵਾਂ ਸਕੈਚ ਚੱਲਣਾ ਚਾਹੀਦਾ ਹੈ। ESP32 ਨੂੰ ਰੀਸਟਾਰਟ ਕਰਨ ਅਤੇ ਅੱਪਲੋਡ ਕੀਤੇ ਨਵੇਂ ਸਕੈਚ ਨੂੰ ਚਲਾਉਣ ਲਈ "ਯੋਗ ਕਰੋ" ਬਟਨ ਨੂੰ ਦਬਾਓ।
  ਹਰ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਕੋਈ ਨਵਾਂ ਸਕੈਚ ਅੱਪਲੋਡ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਤੁਹਾਨੂੰ ਉਸ ਬਟਨ ਕ੍ਰਮ ਨੂੰ ਦੁਹਰਾਉਣਾ ਪਵੇਗਾ।

ਪ੍ਰੋਜੈਕਟ 1 ESP32 ਇਨਪੁਟਸ ਆਉਟਪੁੱਟ

ਇਸ ਸ਼ੁਰੂਆਤੀ ਗਾਈਡ ਵਿੱਚ ਤੁਸੀਂ ਸਿੱਖੋਗੇ ਕਿ ਡਿਜੀਟਲ ਇਨਪੁਟਸ ਨੂੰ ਕਿਵੇਂ ਪੜ੍ਹਨਾ ਹੈ ਜਿਵੇਂ ਕਿ ਇੱਕ ਬਟਨ ਸਵਿੱਚ ਅਤੇ ਡਿਜੀਟਲ ਆਉਟਪੁੱਟ ਨੂੰ ਕਿਵੇਂ ਕੰਟਰੋਲ ਕਰਨਾ ਹੈ ਜਿਵੇਂ ਕਿ ESP32 ਨਾਲ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ।
ਪੂਰਵ-ਸ਼ਰਤਾਂ
ਅਸੀਂ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਕੇ ESP32 ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਕਰਾਂਗੇ। ਇਸ ਲਈ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਤੁਹਾਡੇ ਕੋਲ ESP32 ਬੋਰਡ ਐਡ-ਆਨ ਸਥਾਪਤ ਹੈ:

• Arduino IDE ਵਿੱਚ ESP32 ਐਡ-ਆਨ ਇੰਸਟਾਲ ਕਰਨਾ

ESP32 ਕੰਟਰੋਲ ਡਿਜੀਟਲ ਆਉਟਪੁੱਟ
ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ GPIO ਸੈੱਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜਿਸਨੂੰ ਤੁਸੀਂ ਇੱਕ OUTPUT ਵਜੋਂ ਕੰਟਰੋਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ। pinMode() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਇਸ ਤਰ੍ਹਾਂ ਕਰੋ:
ਪਿਨਮੋਡ (GPIO, ਆਊਟਪੁੱਟ);
ਇੱਕ ਡਿਜੀਟਲ ਆਉਟਪੁੱਟ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ digitalWrite() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਜੋ ਕਿ ਆਰਗੂਮੈਂਟਾਂ ਵਜੋਂ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ, GPIO (ਇੰਟ ਨੰਬਰ) ਜਿਸਦਾ ਤੁਸੀਂ ਹਵਾਲਾ ਦੇ ਰਹੇ ਹੋ, ਅਤੇ ਸਥਿਤੀ, ਜਾਂ ਤਾਂ ਉੱਚ ਜਾਂ ਘੱਟ।
ਡਿਜੀਟਲ ਰਾਈਟ (GPIO, STATE);
GPIOs 6 ਤੋਂ 11 (ਏਕੀਕ੍ਰਿਤ SPI ਫਲੈਸ਼ ਨਾਲ ਜੁੜੇ) ਅਤੇ GPIOs 34, 35, 36 ਅਤੇ 39 (ਇਨਪੁਟ ਸਿਰਫ਼ GPIOs) ਨੂੰ ਛੱਡ ਕੇ ਸਾਰੇ GPIOs ਨੂੰ ਆਉਟਪੁੱਟ ਵਜੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ;
ESP32 GPIO ਬਾਰੇ ਹੋਰ ਜਾਣੋ: ESP32 GPIO ਹਵਾਲਾ ਗਾਈਡ
ESP32 ਡਿਜੀਟਲ ਇਨਪੁਟਸ ਪੜ੍ਹੋ
ਪਹਿਲਾਂ, GPIO ਨੂੰ ਸੈਟ ਕਰੋ ਜਿਸ ਨੂੰ ਤੁਸੀਂ INPUT ਦੇ ਤੌਰ ਤੇ ਪੜ੍ਹਨਾ ਚਾਹੁੰਦੇ ਹੋ, pinMode() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ:
ਪਿਨਮੋਡ (GPIO, INPUT);
ਇੱਕ ਡਿਜ਼ੀਟਲ ਇੰਪੁੱਟ ਨੂੰ ਪੜ੍ਹਨ ਲਈ, ਜਿਵੇਂ ਕਿ ਇੱਕ ਬਟਨ, ਤੁਸੀਂ digitalRead() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਜੋ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ, GPIO (ਇੰਟ ਨੰਬਰ) ਜਿਸਦਾ ਤੁਸੀਂ ਹਵਾਲਾ ਦੇ ਰਹੇ ਹੋ।
ਡਿਜੀਟਲ ਰੀਡ (GPIO);
ਸਾਰੇ ESP32 GPIOs ਨੂੰ ਇਨਪੁਟਸ ਵਜੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, GPIOs 6 ਤੋਂ 11 (ਏਕੀਕ੍ਰਿਤ SPI ਫਲੈਸ਼ ਨਾਲ ਜੁੜਿਆ) ਨੂੰ ਛੱਡ ਕੇ।
ESP32 GPIO ਬਾਰੇ ਹੋਰ ਜਾਣੋ: ESP32 GPIO ਹਵਾਲਾ ਗਾਈਡ
ਪ੍ਰੋਜੈਕਟ ਸਾਬਕਾample
ਤੁਹਾਨੂੰ ਇਹ ਦਿਖਾਉਣ ਲਈ ਕਿ ਡਿਜੀਟਲ ਇਨਪੁਟਸ ਅਤੇ ਡਿਜੀਟਲ ਆਉਟਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ, ਅਸੀਂ ਇੱਕ ਸਧਾਰਨ ਪ੍ਰੋਜੈਕਟ ਬਣਾਵਾਂਗੇample ਇੱਕ ਪੁਸ਼ਬਟਨ ਅਤੇ ਇੱਕ LED ਨਾਲ. ਅਸੀਂ ਪੁਸ਼ਬਟਨ ਦੀ ਸਥਿਤੀ ਨੂੰ ਪੜ੍ਹਾਂਗੇ ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਚਿੱਤਰ ਵਿੱਚ ਦਰਸਾਏ ਅਨੁਸਾਰ LED ਨੂੰ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਾਂਗੇ।

ਪੁਰਜ਼ਿਆਂ ਦੀ ਲੋੜ ਹੈ
ਸਰਕਟ ਬਣਾਉਣ ਲਈ ਤੁਹਾਨੂੰ ਲੋੜੀਂਦੇ ਹਿੱਸਿਆਂ ਦੀ ਸੂਚੀ ਇੱਥੇ ਦਿੱਤੀ ਗਈ ਹੈ:

• ESP32 DEVKIT V1
• 5 ਮਿਲੀਮੀਟਰ LED
• 220 ਓਹਮ ਰੋਧਕ
• ਪੁਸ਼ ਬਟਨ
• 10k Ohm ਰੋਧਕ
• ਰੋਟੀ ਦਾ ਬੋਰਡ
• ਜੰਪਰ ਤਾਰਾਂ

ਯੋਜਨਾਬੱਧ ਚਿੱਤਰ
ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਇੱਕ LED ਅਤੇ ਇੱਕ ਪੁਸ਼ਬਟਨ ਨਾਲ ਇੱਕ ਸਰਕਟ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
ਅਸੀਂ LED ਨੂੰ GPIO 5 ਅਤੇ ਪੁਸ਼ਬਟਨ ਨੂੰ GPIO ਨਾਲ ਕਨੈਕਟ ਕਰਾਂਗੇ 4.ਕੋਡ
ਕੋਡ Project_1_ESP32_Inputs_Outputs.ino arduino IDE ਵਿੱਚ ਖੋਲ੍ਹੋਕੋਡ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ
ਹੇਠ ਲਿਖੀਆਂ ਦੋ ਲਾਈਨਾਂ ਵਿੱਚ, ਤੁਸੀਂ ਪਿੰਨ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਵੇਰੀਏਬਲ ਬਣਾਉਂਦੇ ਹੋ:

ਬਟਨ GPIO 4 ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ ਅਤੇ LED GPIO 5 ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ। ESP32 ਨਾਲ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, 4 GPIO 4 ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ ਅਤੇ 5 GPIO 5 ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।
ਅੱਗੇ, ਤੁਸੀਂ ਬਟਨ ਸਥਿਤੀ ਨੂੰ ਰੱਖਣ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ ਬਣਾਉਂਦੇ ਹੋ। ਮੂਲ ਰੂਪ ਵਿੱਚ, ਇਹ 0 ਹੈ (ਦਬਾਓ ਨਹੀਂ)।
int buttonState = 0;
ਸੈੱਟਅੱਪ() ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਇਨਪੁਟ ਦੇ ਤੌਰ ਤੇ ਬਟਨ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ, ਅਤੇ LED ਨੂੰ ਇੱਕ ਆਉਟਪੁਟ ਵਜੋਂ।
ਇਸਦੇ ਲਈ, ਤੁਸੀਂ pinMode() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ ਜੋ ਉਸ ਪਿੰਨ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ ਜਿਸਦਾ ਤੁਸੀਂ ਹਵਾਲਾ ਦੇ ਰਹੇ ਹੋ, ਅਤੇ ਮੋਡ: INPUT ਜਾਂ OUTPUT.
ਪਿਨਮੋਡ (ਬਟਨਪਿਨ, ਇਨਪੁਟ);
pinMode(ledPin, OUTPUT);
ਲੂਪ () ਵਿੱਚ ਉਹ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਬਟਨ ਦੀ ਸਥਿਤੀ ਪੜ੍ਹਦੇ ਹੋ ਅਤੇ ਉਸ ਅਨੁਸਾਰ LED ਸੈੱਟ ਕਰਦੇ ਹੋ।
ਅਗਲੀ ਲਾਈਨ ਵਿੱਚ, ਤੁਸੀਂ ਬਟਨ ਸਟੇਟ ਨੂੰ ਪੜ੍ਹਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਬਟਨ ਸਟੇਟ ਵੇਰੀਏਬਲ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰਦੇ ਹੋ।
ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਦੇਖਿਆ ਹੈ, ਤੁਸੀਂ digitalRead() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ।
buttonState = ਡਿਜੀਟਲ ਰੀਡ (ਬਟਨਪਿਨ);
ਹੇਠ ਦਿੱਤੀ if ਸਟੇਟਮੈਂਟ, ਜਾਂਚ ਕਰਦੀ ਹੈ ਕਿ ਕੀ ਬਟਨ ਸਥਿਤੀ ਉੱਚੀ ਹੈ। ਜੇਕਰ ਇਹ ਹੈ, ਤਾਂ ਇਹ ਡਿਜੀਟਲ ਰਾਈਟ() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ LED ਨੂੰ ਚਾਲੂ ਕਰਦਾ ਹੈ ਜੋ ledPin ਅਤੇ ਸਟੇਟ ਹਾਈ ਨੂੰ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ।
ਜੇਕਰ (ਬਟਨ ਸਟੇਟ == ਉੱਚਾ)ਜੇਕਰ ਬਟਨ ਦੀ ਸਥਿਤੀ ਉੱਚੀ ਨਹੀਂ ਹੈ, ਤਾਂ ਤੁਸੀਂ LED ਨੂੰ ਬੰਦ ਕਰ ਦਿੰਦੇ ਹੋ। ਡਿਜੀਟਲ ਰਾਈਟ () ਫੰਕਸ਼ਨ ਵਿੱਚ ਇੱਕ ਦੂਜੇ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ 'ਤੇ LOW ਨੂੰ ਸੈੱਟ ਕਰੋ।ਕੋਡ ਅੱਪਲੋਡ ਕਰ ਰਿਹਾ ਹੈ
ਅੱਪਲੋਡ ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਟੂਲਜ਼ > ਬੋਰਡ 'ਤੇ ਜਾਓ ਅਤੇ ਬੋਰਡ ਨੂੰ ਚੁਣੋ: DOIT ESP32 DEVKIT V1 ਬੋਰਡ।
ਟੂਲਸ > ਪੋਰਟ 'ਤੇ ਜਾਓ ਅਤੇ COM ਪੋਰਟ ਦੀ ਚੋਣ ਕਰੋ ਜਿਸ ਨਾਲ ESP32 ਜੁੜਿਆ ਹੋਇਆ ਹੈ। ਫਿਰ, ਅੱਪਲੋਡ ਬਟਨ ਦਬਾਓ ਅਤੇ "ਅੱਪਲੋਡਿੰਗ ਹੋ ਗਿਆ" ਸੁਨੇਹੇ ਦੀ ਉਡੀਕ ਕਰੋ।ਨੋਟ: ਜੇਕਰ ਤੁਸੀਂ ਡੀਬਗਿੰਗ ਵਿੰਡੋ 'ਤੇ ਬਹੁਤ ਸਾਰੇ ਬਿੰਦੀਆਂ (ਕਨੈਕਟ ਕਰ ਰਹੇ ਹੋ.......... ਬਿੰਦੀਆਂ ਦੇ ਬਾਅਦ ਬਟਨ
ਦਿਸਣਾ ਸ਼ੁਰੂ ਕਰੋ।ਸਮੱਸਿਆ ਨਿਪਟਾਰਾ

ਪ੍ਰਦਰਸ਼ਨ

ਕੋਡ ਅੱਪਲੋਡ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਆਪਣੇ ਸਰਕਟ ਦੀ ਜਾਂਚ ਕਰੋ। ਜਦੋਂ ਤੁਸੀਂ ਪੁਸ਼ਬਟਨ ਦਬਾਉਂਦੇ ਹੋ ਤਾਂ ਤੁਹਾਡੀ LED ਰੋਸ਼ਨੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ:ਅਤੇ ਜਦੋਂ ਤੁਸੀਂ ਇਸਨੂੰ ਜਾਰੀ ਕਰਦੇ ਹੋ ਤਾਂ ਬੰਦ ਕਰੋ:

ਪ੍ਰੋਜੈਕਟ 2 ESP32 ਐਨਾਲਾਗ ਇਨਪੁਟਸ

ਇਹ ਪ੍ਰੋਜੈਕਟ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ESP32 ਨਾਲ ਐਨਾਲਾਗ ਇਨਪੁਟਸ ਨੂੰ ਕਿਵੇਂ ਪੜ੍ਹਨਾ ਹੈ।
ਐਨਾਲਾਗ ਰੀਡਿੰਗ ਵੇਰੀਏਬਲ ਰੋਧਕਾਂ ਜਿਵੇਂ ਕਿ ਪੋਟੈਂਸ਼ੀਓਮੀਟਰਾਂ, ਜਾਂ ਐਨਾਲਾਗ ਸੈਂਸਰਾਂ ਤੋਂ ਮੁੱਲਾਂ ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਉਪਯੋਗੀ ਹੈ।
ਐਨਾਲਾਗ ਇਨਪੁਟਸ (ADC)
ESP32 ਦੇ ਨਾਲ ਐਨਾਲਾਗ ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਨ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਵੱਖੋ-ਵੱਖਰੇ ਵੋਲਯੂਮ ਨੂੰ ਮਾਪ ਸਕਦੇ ਹੋtage ਦਾ ਪੱਧਰ 0 V ਅਤੇ 3.3 V ਦੇ ਵਿਚਕਾਰ ਹੈ।
ਵਾਲੀਅਮtage ਮਾਪਿਆ ਗਿਆ ਫਿਰ 0 ਅਤੇ 4095 ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ 0 V 0 ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ, ਅਤੇ 3.3 V 4095 ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਕੋਈ ਵੀ ਵੋਲਯੂਮtage 0 V ਅਤੇ 3.3 V ਦੇ ਵਿਚਕਾਰ ਵਿੱਚ ਅਨੁਸਾਰੀ ਮੁੱਲ ਦਿੱਤਾ ਜਾਵੇਗਾ।ADC ਗੈਰ-ਲੀਨੀਅਰ ਹੈ
ਆਦਰਸ਼ਕ ਤੌਰ 'ਤੇ, ਤੁਸੀਂ ESP32 ADC ਪਿੰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਇੱਕ ਲੀਨੀਅਰ ਵਿਵਹਾਰ ਦੀ ਉਮੀਦ ਕਰੋਗੇ।
ਹਾਲਾਂਕਿ, ਅਜਿਹਾ ਨਹੀਂ ਹੁੰਦਾ। ਤੁਸੀਂ ਜੋ ਪ੍ਰਾਪਤ ਕਰੋਗੇ ਉਹ ਇੱਕ ਵਿਵਹਾਰ ਹੈ ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦਿੱਤੇ ਚਾਰਟ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ:ਇਸ ਵਿਵਹਾਰ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਡਾ ESP32 3.3 V ਨੂੰ 3.2 V ਤੋਂ ਵੱਖ ਕਰਨ ਦੇ ਯੋਗ ਨਹੀਂ ਹੈ।
ਤੁਹਾਨੂੰ ਦੋਵਾਂ ਵੋਲਯੂਮ ਲਈ ਇੱਕੋ ਜਿਹਾ ਮੁੱਲ ਮਿਲੇਗਾtages: 4095.
ਬਹੁਤ ਘੱਟ ਵਾਲੀਅਮ ਲਈ ਵੀ ਅਜਿਹਾ ਹੀ ਹੁੰਦਾ ਹੈtage ਮੁੱਲ: 0 V ਅਤੇ 0.1 V ਲਈ ਤੁਹਾਨੂੰ ਉਹੀ ਮੁੱਲ ਮਿਲੇਗਾ: 0. ਤੁਹਾਨੂੰ ESP32 ADC ਪਿੰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਇਸ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣ ਦੀ ਲੋੜ ਹੈ।
analogRead() ਫੰਕਸ਼ਨ
Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ESP32 ਦੇ ਨਾਲ ਇੱਕ ਐਨਾਲਾਗ ਇਨਪੁਟ ਪੜ੍ਹਨਾ ਐਨਾਲਾਗ ਰੀਡ() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਜਿੰਨਾ ਸਰਲ ਹੈ। ਇਹ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ, GPIO ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਪੜ੍ਹਨਾ ਚਾਹੁੰਦੇ ਹੋ:
analogRead(GPIO);
DEVKIT V15board (1 GPIO ਦੇ ਨਾਲ ਸੰਸਕਰਣ) ਵਿੱਚ ਸਿਰਫ਼ 30 ਉਪਲਬਧ ਹਨ।
ਆਪਣੇ ESP32 ਬੋਰਡ ਪਿਨਆਉਟ ਨੂੰ ਫੜੋ ਅਤੇ ADC ਪਿੰਨ ਲੱਭੋ। ਇਹਨਾਂ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਚਿੱਤਰ ਵਿੱਚ ਲਾਲ ਕਿਨਾਰੇ ਨਾਲ ਉਜਾਗਰ ਕੀਤਾ ਗਿਆ ਹੈ।ਇਹਨਾਂ ਐਨਾਲਾਗ ਇਨਪੁਟ ਪਿਨਾਂ ਵਿੱਚ 12-ਬਿੱਟ ਰੈਜ਼ੋਲਿਊਸ਼ਨ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਐਨਾਲਾਗ ਇਨਪੁਟ ਪੜ੍ਹਦੇ ਹੋ, ਤਾਂ ਇਸਦੀ ਰੇਂਜ 0 ਤੋਂ 4095 ਤੱਕ ਵੱਖ-ਵੱਖ ਹੋ ਸਕਦੀ ਹੈ।
ਨੋਟ: ਜਦੋਂ ਵਾਈ-ਫਾਈ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਤਾਂ ADC2 ਪਿੰਨ ਨਹੀਂ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਇਸ ਲਈ, ਜੇਕਰ ਤੁਸੀਂ Wi-Fi ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ ਅਤੇ ਤੁਹਾਨੂੰ ADC2 GPIO ਤੋਂ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਵਿੱਚ ਮੁਸ਼ਕਲ ਆ ਰਹੀ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇਸਦੀ ਬਜਾਏ ADC1 GPIO ਦੀ ਵਰਤੋਂ ਕਰਨ ਬਾਰੇ ਵਿਚਾਰ ਕਰ ਸਕਦੇ ਹੋ, ਜਿਸ ਨਾਲ ਤੁਹਾਡੀ ਸਮੱਸਿਆ ਦਾ ਹੱਲ ਹੋ ਜਾਵੇਗਾ।
ਇਹ ਦੇਖਣ ਲਈ ਕਿ ਸਭ ਕੁਝ ਕਿਵੇਂ ਜੁੜਦਾ ਹੈ, ਅਸੀਂ ਇੱਕ ਸਧਾਰਨ ਸਾਬਕਾ ਬਣਾਵਾਂਗੇampਇੱਕ ਪੋਟੈਂਸ਼ੀਓਮੀਟਰ ਤੋਂ ਐਨਾਲਾਗ ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਨ ਲਈ।
ਪੁਰਜ਼ਿਆਂ ਦੀ ਲੋੜ ਹੈ
ਇਸ ਲਈ ਸਾਬਕਾampਲੇ, ਤੁਹਾਨੂੰ ਹੇਠ ਦਿੱਤੇ ਭਾਗਾਂ ਦੀ ਲੋੜ ਹੈ:

• ESP32 DEVKIT V1 ਬੋਰਡ
• ਪੌਟੈਂਟੀਓਮੀਟਰ
• ਰੋਟੀ ਦਾ ਬੋਰਡ
• ਜੰਪਰ ਤਾਰਾਂ

ਯੋਜਨਾਬੱਧ
ਆਪਣੇ ESP32 ਨੂੰ ਇੱਕ ਪੋਟੈਂਸ਼ੀਓਮੀਟਰ ਵਾਇਰ ਕਰੋ। ਪੋਟੈਂਸ਼ੀਓਮੀਟਰ ਮੱਧ ਪਿੰਨ GPIO 4 ਨਾਲ ਜੁੜਿਆ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਤੁਸੀਂ ਇੱਕ ਸੰਦਰਭ ਦੇ ਤੌਰ 'ਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਯੋਜਨਾਬੱਧ ਚਿੱਤਰ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਕੋਡ
ਅਸੀਂ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ESP32 ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਕਰਾਂਗੇ, ਇਸ ਲਈ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ESP32 ਐਡ-ਆਨ ਸਥਾਪਤ ਹੈ: (ਜੇ ਤੁਸੀਂ ਇਹ ਕਦਮ ਪਹਿਲਾਂ ਹੀ ਕਰ ਚੁੱਕੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਅਗਲੇ ਪੜਾਅ 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ।)
Arduino IDE ਵਿੱਚ ESP32 ਐਡ-ਆਨ ਇੰਸਟਾਲ ਕਰਨਾ
ਕੋਡ Project_2_ESP32_Inputs_Outputs.ino arduino IDE ਵਿੱਚ ਖੋਲ੍ਹੋਇਹ ਕੋਡ ਸਿਰਫ਼ ਪੋਟੈਂਸ਼ੀਓਮੀਟਰ ਤੋਂ ਮੁੱਲਾਂ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਮੁੱਲਾਂ ਨੂੰ ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਵਿੱਚ ਛਾਪਦਾ ਹੈ।
ਕੋਡ ਵਿੱਚ, ਤੁਸੀਂ GPIO ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ ਜਿਸ ਨਾਲ ਪੋਟੈਂਸ਼ੀਓਮੀਟਰ ਜੁੜਿਆ ਹੋਇਆ ਹੈ। ਇਸ ਵਿੱਚ ਸਾਬਕਾample, GPIO 4.ਸੈੱਟਅੱਪ () ਵਿੱਚ, 115200 ਦੀ ਬੌਡ ਦਰ 'ਤੇ ਇੱਕ ਸੀਰੀਅਲ ਸੰਚਾਰ ਸ਼ੁਰੂ ਕਰੋ।ਲੂਪ () ਵਿੱਚ, potPin ਤੋਂ ਐਨਾਲਾਗ ਇਨਪੁਟ ਨੂੰ ਪੜ੍ਹਨ ਲਈ analogRead() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।ਅੰਤ ਵਿੱਚ, ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਵਿੱਚ ਪੋਟੈਂਸ਼ੀਓਮੀਟਰ ਤੋਂ ਪੜ੍ਹੇ ਗਏ ਮੁੱਲਾਂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰੋ।ਆਪਣੇ ESP32 'ਤੇ ਮੁਹੱਈਆ ਕੀਤੇ ਕੋਡ ਨੂੰ ਅੱਪਲੋਡ ਕਰੋ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਟੂਲਸ ਮੀਨੂ ਵਿੱਚ ਸਹੀ ਬੋਰਡ ਅਤੇ COM ਪੋਰਟ ਚੁਣਿਆ ਗਿਆ ਹੈ।
ਸਾਬਕਾ ਦੀ ਜਾਂਚample
ਕੋਡ ਨੂੰ ਅੱਪਲੋਡ ਕਰਨ ਅਤੇ ESP32 ਰੀਸੈਟ ਬਟਨ ਨੂੰ ਦਬਾਉਣ ਤੋਂ ਬਾਅਦ, ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਨੂੰ 115200 ਦੀ ਬੌਡ ਦਰ 'ਤੇ ਖੋਲ੍ਹੋ। ਪੋਟੈਂਸ਼ੀਓਮੀਟਰ ਨੂੰ ਘੁੰਮਾਓ ਅਤੇ ਮੁੱਲ ਬਦਲਦੇ ਹੋਏ ਦੇਖੋ।ਵੱਧ ਤੋਂ ਵੱਧ ਮੁੱਲ ਜੋ ਤੁਸੀਂ ਪ੍ਰਾਪਤ ਕਰੋਗੇ 4095 ਹੈ ਅਤੇ ਨਿਊਨਤਮ ਮੁੱਲ 0 ਹੈ।

ਸਮੇਟਣਾ

ਇਸ ਲੇਖ ਵਿੱਚ ਤੁਸੀਂ ਸਿੱਖਿਆ ਹੈ ਕਿ Arduino IDE ਨਾਲ ESP32 ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਐਨਾਲਾਗ ਇਨਪੁਟਸ ਨੂੰ ਕਿਵੇਂ ਪੜ੍ਹਨਾ ਹੈ। ਸਾਰੰਸ਼ ਵਿੱਚ:

• ESP32 DEVKIT V1 DOIT ਬੋਰਡ (30 ਪਿਨਾਂ ਵਾਲਾ ਸੰਸਕਰਣ) ਵਿੱਚ 15 ADC ਪਿੰਨ ਹਨ ਜੋ ਤੁਸੀਂ ਐਨਾਲਾਗ ਇਨਪੁਟਸ ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਵਰਤ ਸਕਦੇ ਹੋ।
• ਇਹਨਾਂ ਪਿੰਨਾਂ ਦਾ ਰੈਜ਼ੋਲਿਊਸ਼ਨ 12 ਬਿੱਟ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ 0 ਤੋਂ 4095 ਤੱਕ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ।
• Arduino IDE ਵਿੱਚ ਇੱਕ ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਨ ਲਈ, ਤੁਸੀਂ ਸਿਰਫ਼ analogRead() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ।
• ESP32 ADC ਪਿੰਨਾਂ ਦਾ ਕੋਈ ਰੇਖਿਕ ਵਿਵਹਾਰ ਨਹੀਂ ਹੁੰਦਾ ਹੈ। ਤੁਸੀਂ ਸ਼ਾਇਦ 0 ਅਤੇ 0.1V, ਜਾਂ 3.2 ਅਤੇ 3.3V ਵਿਚਕਾਰ ਫਰਕ ਕਰਨ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਵੋਗੇ। ADC ਪਿੰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਤੁਹਾਨੂੰ ਇਸ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ।

ਪ੍ਰੋਜੈਕਟ 3 ESP32 PWM (ਐਨਾਲਾਗ ਆਉਟਪੁੱਟ)

ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ ਤੁਹਾਨੂੰ ਦਿਖਾਵਾਂਗੇ ਕਿ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ESP32 ਨਾਲ PWM ਸਿਗਨਲ ਕਿਵੇਂ ਤਿਆਰ ਕਰਨਾ ਹੈ। ਸਾਬਕਾ ਵਜੋਂample ਅਸੀਂ ਇੱਕ ਸਧਾਰਨ ਸਰਕਟ ਬਣਾਵਾਂਗੇ ਜੋ ESP32 ਦੇ LED PWM ਕੰਟਰੋਲਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ LED ਨੂੰ ਮੱਧਮ ਕਰਦਾ ਹੈ।ESP32 LED PWM ਕੰਟਰੋਲਰ
ESP32 ਵਿੱਚ 16 ਸੁਤੰਤਰ ਚੈਨਲਾਂ ਵਾਲਾ ਇੱਕ LED PWM ਕੰਟਰੋਲਰ ਹੈ ਜੋ ਵੱਖ-ਵੱਖ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਨਾਲ PWM ਸਿਗਨਲ ਬਣਾਉਣ ਲਈ ਕੌਂਫਿਗਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ PWM ਦੇ ਨਾਲ ਇੱਕ LED ਨੂੰ ਮੱਧਮ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਇਹਨਾਂ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨੀ ਪਵੇਗੀ:

1. ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਇੱਕ PWM ਚੈਨਲ ਚੁਣਨ ਦੀ ਲੋੜ ਹੈ। 16 ਤੋਂ 0 ਤੱਕ 15 ਚੈਨਲ ਹਨ।
2. ਫਿਰ, ਤੁਹਾਨੂੰ PWM ਸਿਗਨਲ ਬਾਰੰਬਾਰਤਾ ਸੈੱਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇੱਕ LED ਲਈ, 5000 Hz ਦੀ ਬਾਰੰਬਾਰਤਾ ਵਰਤਣ ਲਈ ਠੀਕ ਹੈ।
3. ਤੁਹਾਨੂੰ ਸਿਗਨਲ ਦੇ ਡਿਊਟੀ ਚੱਕਰ ਰੈਜ਼ੋਲੂਸ਼ਨ ਨੂੰ ਵੀ ਸੈੱਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ: ਤੁਹਾਡੇ ਕੋਲ 1 ਤੋਂ 16 ਬਿੱਟ ਤੱਕ ਰੈਜ਼ੋਲੂਸ਼ਨ ਹਨ। ਅਸੀਂ 8-ਬਿੱਟ ਰੈਜ਼ੋਲਿਊਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ 0 ਤੋਂ 255 ਤੱਕ ਮੁੱਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ LED ਚਮਕ ਨੂੰ ਕੰਟਰੋਲ ਕਰ ਸਕਦੇ ਹੋ।
4.  ਅੱਗੇ, ਤੁਹਾਨੂੰ ਇਹ ਦੱਸਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਕਿਹੜੇ GPIO ਜਾਂ GPIOs 'ਤੇ ਸਿਗਨਲ ਦਿਖਾਈ ਦੇਵੇਗਾ। ਇਸਦੇ ਲਈ ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋਗੇ:
   ledcAttachPin (GPIO, ਚੈਨਲ)
   ਇਹ ਫੰਕਸ਼ਨ ਦੋ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ। ਪਹਿਲਾ GPIO ਹੈ ਜੋ ਸਿਗਨਲ ਨੂੰ ਆਉਟਪੁੱਟ ਕਰੇਗਾ, ਅਤੇ ਦੂਜਾ ਉਹ ਚੈਨਲ ਹੈ ਜੋ ਸਿਗਨਲ ਤਿਆਰ ਕਰੇਗਾ।
5. ਅੰਤ ਵਿੱਚ, PWM ਦੀ ਵਰਤੋਂ ਕਰਕੇ LED ਚਮਕ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ:

ledcWrite (ਚੈਨਲ, ਡਿਊਟੀ ਸਾਈਕਲ)
ਇਹ ਫੰਕਸ਼ਨ ਉਸ ਚੈਨਲ ਨੂੰ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ ਜੋ PWM ਸਿਗਨਲ ਤਿਆਰ ਕਰ ਰਿਹਾ ਹੈ, ਅਤੇ ਡਿਊਟੀ ਚੱਕਰ।
ਪੁਰਜ਼ਿਆਂ ਦੀ ਲੋੜ ਹੈ
ਇਸ ਟਿਊਟੋਰਿਅਲ ਦੀ ਪਾਲਣਾ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਇਹਨਾਂ ਭਾਗਾਂ ਦੀ ਲੋੜ ਹੈ:

• ESP32 DEVKIT V1 ਬੋਰਡ
• 5mm LED
• 220 ਓਹਮ ਰੋਧਕ
•  ਰੋਟੀ ਦਾ ਬੋਰਡ
• ਜੰਪਰ ਤਾਰਾਂ

ਯੋਜਨਾਬੱਧ
ਹੇਠਾਂ ਦਿੱਤੇ ਯੋਜਨਾਬੱਧ ਚਿੱਤਰ ਦੇ ਅਨੁਸਾਰ ਆਪਣੇ ESP32 ਲਈ ਇੱਕ LED ਵਾਇਰ ਕਰੋ। LED ਨੂੰ GPIO ਨਾਲ ਕਨੈਕਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ 4.ਨੋਟ: ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਪਿੰਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜਿੰਨਾ ਚਿਰ ਇਹ ਇੱਕ ਆਉਟਪੁੱਟ ਵਜੋਂ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ। ਸਾਰੇ ਪਿੰਨ ਜੋ ਆਉਟਪੁੱਟ ਦੇ ਤੌਰ ਤੇ ਕੰਮ ਕਰ ਸਕਦੇ ਹਨ ਉਹਨਾਂ ਨੂੰ PWM ਪਿੰਨ ਵਜੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ESP32 GPIO ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ, ਪੜ੍ਹੋ: ESP32 Pinout ਹਵਾਲਾ: ਤੁਹਾਨੂੰ ਕਿਹੜੇ GPIO ਪਿੰਨ ਵਰਤਣੇ ਚਾਹੀਦੇ ਹਨ?
ਕੋਡ
ਅਸੀਂ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ESP32 ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਕਰਾਂਗੇ, ਇਸ ਲਈ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ESP32 ਐਡ-ਆਨ ਸਥਾਪਤ ਹੈ: (ਜੇ ਤੁਸੀਂ ਇਹ ਕਦਮ ਪਹਿਲਾਂ ਹੀ ਕਰ ਚੁੱਕੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਅਗਲੇ ਪੜਾਅ 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ।)
Arduino IDE ਵਿੱਚ ESP32 ਐਡ-ਆਨ ਇੰਸਟਾਲ ਕਰਨਾ
arduino IDE ਵਿੱਚ Project_3_ESP32_PWM.ino ਕੋਡ ਖੋਲ੍ਹੋਤੁਸੀਂ ਉਸ ਪਿੰਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ ਜਿਸ ਨਾਲ LED ਜੁੜੀ ਹੈ। ਇਸ ਕੇਸ ਵਿੱਚ LED ਨੂੰ GPIO 4 ਨਾਲ ਜੋੜਿਆ ਗਿਆ ਹੈ।ਫਿਰ, ਤੁਸੀਂ PWM ਸਿਗਨਲ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸੈਟ ਕਰਦੇ ਹੋ. ਤੁਸੀਂ 5000 Hz ਦੀ ਬਾਰੰਬਾਰਤਾ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ, ਸਿਗਨਲ ਬਣਾਉਣ ਲਈ ਚੈਨਲ 0 ਦੀ ਚੋਣ ਕਰੋ, ਅਤੇ 8 ਬਿੱਟ ਦਾ ਰੈਜ਼ੋਲਿਊਸ਼ਨ ਸੈੱਟ ਕਰੋ। ਤੁਸੀਂ ਵੱਖ-ਵੱਖ PWM ਸਿਗਨਲ ਬਣਾਉਣ ਲਈ ਇਹਨਾਂ ਤੋਂ ਵੱਖਰੀਆਂ ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਚੋਣ ਕਰ ਸਕਦੇ ਹੋ।ਸੈੱਟਅੱਪ() ਵਿੱਚ, ਤੁਹਾਨੂੰ ledcSetup() ਫੰਕਸ਼ਨ ਜੋ ਆਰਗੂਮੈਂਟਾਂ, ledChannel, ਬਾਰੰਬਾਰਤਾ ਅਤੇ ਰੈਜ਼ੋਲਿਊਸ਼ਨ ਵਜੋਂ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ, ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਾਲ LED PWM ਨੂੰ ਸੰਰਚਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਜਿਵੇਂ ਕਿ:ਅੱਗੇ, ਤੁਹਾਨੂੰ GPIO ਚੁਣਨ ਦੀ ਲੋੜ ਹੈ ਜਿਸ ਤੋਂ ਤੁਸੀਂ ਸਿਗਨਲ ਪ੍ਰਾਪਤ ਕਰੋਗੇ। ਇਸਦੇ ਲਈ ledcAttachPin() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜੋ ਆਰਗੂਮੈਂਟ ਵਜੋਂ GPIO ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਸਿਗਨਲ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਅਤੇ ਉਹ ਚੈਨਲ ਜੋ ਸਿਗਨਲ ਤਿਆਰ ਕਰ ਰਿਹਾ ਹੈ। ਇਸ ਵਿੱਚ ਸਾਬਕਾample, ਸਾਨੂੰ ledPin GPIO ਵਿੱਚ ਸਿਗਨਲ ਮਿਲੇਗਾ, ਜੋ GPIO 4 ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਚੈਨਲ ਜੋ ਸਿਗਨਲ ਬਣਾਉਂਦਾ ਹੈ ਉਹ ledChannel ਹੈ, ਜੋ ਚੈਨਲ 0 ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।ਲੂਪ ਵਿੱਚ, ਤੁਸੀਂ LED ਚਮਕ ਵਧਾਉਣ ਲਈ ਡਿਊਟੀ ਚੱਕਰ ਨੂੰ 0 ਅਤੇ 255 ਦੇ ਵਿਚਕਾਰ ਬਦਲੋਗੇ।ਅਤੇ ਫਿਰ, ਚਮਕ ਘਟਾਉਣ ਲਈ 255 ਅਤੇ 0 ਦੇ ਵਿਚਕਾਰ.LED ਦੀ ਚਮਕ ਨੂੰ ਸੈੱਟ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ledcWrite() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜੋ ਸਿਗਨਲ ਤਿਆਰ ਕਰਨ ਵਾਲੇ ਚੈਨਲ ਅਤੇ ਡਿਊਟੀ ਚੱਕਰ ਨੂੰ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ।ਜਿਵੇਂ ਕਿ ਅਸੀਂ 8-ਬਿੱਟ ਰੈਜ਼ੋਲਿਊਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ, ਡਿਊਟੀ ਚੱਕਰ ਨੂੰ 0 ਤੋਂ 255 ਤੱਕ ਮੁੱਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨਿਯੰਤਰਿਤ ਕੀਤਾ ਜਾਵੇਗਾ। ਧਿਆਨ ਦਿਓ ਕਿ ledcWrite() ਫੰਕਸ਼ਨ ਵਿੱਚ ਅਸੀਂ ਉਸ ਚੈਨਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਜੋ ਸਿਗਨਲ ਤਿਆਰ ਕਰ ਰਿਹਾ ਹੈ, ਨਾ ਕਿ GPIO।

ਸਾਬਕਾ ਦੀ ਜਾਂਚample

ਕੋਡ ਨੂੰ ਆਪਣੇ ESP32 'ਤੇ ਅੱਪਲੋਡ ਕਰੋ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਸਹੀ ਬੋਰਡ ਅਤੇ COM ਪੋਰਟ ਚੁਣਿਆ ਗਿਆ ਹੈ। ਆਪਣੇ ਸਰਕਟ ਨੂੰ ਵੇਖੋ. ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਮੱਧਮ LED ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ ਜੋ ਚਮਕ ਵਧਾਉਂਦੀ ਹੈ ਅਤੇ ਘਟਾਉਂਦੀ ਹੈ।

ਪ੍ਰੋਜੈਕਟ 4 ESP32 PIR ਮੋਸ਼ਨ ਸੈਂਸਰ

ਇਹ ਪ੍ਰੋਜੈਕਟ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ PIR ਮੋਸ਼ਨ ਸੈਂਸਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ESP32 ਨਾਲ ਮੋਸ਼ਨ ਦਾ ਪਤਾ ਕਿਵੇਂ ਲਗਾਇਆ ਜਾਵੇ। ਜਦੋਂ ਮੋਸ਼ਨ ਦਾ ਪਤਾ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਬਜ਼ਰ ਇੱਕ ਅਲਾਰਮ ਵਜਾਏਗਾ, ਅਤੇ ਅਲਾਰਮ ਨੂੰ ਬੰਦ ਕਰ ਦੇਵੇਗਾ ਜਦੋਂ ਇੱਕ ਪੂਰਵ-ਨਿਰਧਾਰਤ ਸਮੇਂ (ਜਿਵੇਂ ਕਿ 4 ਸਕਿੰਟ) ਲਈ ਕੋਈ ਮੋਸ਼ਨ ਨਹੀਂ ਲੱਭਿਆ ਜਾਂਦਾ ਹੈ।
HC-SR501 ਮੋਸ਼ਨ ਸੈਂਸਰ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ
.HC-SR501 ਸੈਂਸਰ ਦਾ ਕੰਮ ਕਰਨ ਵਾਲਾ ਸਿਧਾਂਤ ਚਲਦੀ ਵਸਤੂ 'ਤੇ ਇਨਫਰਾਰੈੱਡ ਰੇਡੀਏਸ਼ਨ ਦੇ ਬਦਲਾਅ 'ਤੇ ਅਧਾਰਤ ਹੈ। HC-SR501 ਸੈਂਸਰ ਦੁਆਰਾ ਖੋਜੇ ਜਾਣ ਲਈ, ਆਬਜੈਕਟ ਨੂੰ ਦੋ ਲੋੜਾਂ ਪੂਰੀਆਂ ਕਰਨੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ:

• ਵਸਤੂ ਇਨਫਰਾਰੈੱਡ ਤਰੀਕੇ ਨਾਲ ਨਿਕਾਸ ਕਰ ਰਹੀ ਹੈ।
• ਵਸਤੂ ਹਿੱਲ ਰਹੀ ਹੈ ਜਾਂ ਹਿੱਲ ਰਹੀ ਹੈ

ਇਸ ਲਈ:
ਜੇਕਰ ਕੋਈ ਵਸਤੂ ਇਨਫਰਾਰੈੱਡ ਕਿਰਨਾਂ ਦਾ ਨਿਕਾਸ ਕਰ ਰਹੀ ਹੈ ਪਰ ਹਿੱਲ ਨਹੀਂ ਰਹੀ ਹੈ (ਉਦਾਹਰਣ ਵਜੋਂ, ਕੋਈ ਵਿਅਕਤੀ ਬਿਨਾਂ ਹਿੱਲੇ ਖੜ੍ਹਾ ਹੈ), ਤਾਂ ਇਹ ਸੈਂਸਰ ਦੁਆਰਾ ਖੋਜਿਆ ਨਹੀਂ ਜਾਂਦਾ ਹੈ।
ਜੇਕਰ ਕੋਈ ਵਸਤੂ ਹਿੱਲ ਰਹੀ ਹੈ ਪਰ ਇਨਫਰਾਰੈੱਡ ਕਿਰਨਾਂ (ਜਿਵੇਂ ਕਿ ਰੋਬੋਟ ਜਾਂ ਵਾਹਨ) ਨਹੀਂ ਕੱਢ ਰਹੀ ਹੈ, ਤਾਂ ਸੈਂਸਰ ਦੁਆਰਾ ਇਸਦਾ ਪਤਾ ਨਹੀਂ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ।
ਪੇਸ਼ ਹੈ ਟਾਈਮਰ
ਇਸ ਵਿੱਚ ਸਾਬਕਾampਅਸੀਂ ਟਾਈਮਰ ਵੀ ਪੇਸ਼ ਕਰਾਂਗੇ। ਅਸੀਂ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਮੋਸ਼ਨ ਦਾ ਪਤਾ ਲੱਗਣ ਤੋਂ ਬਾਅਦ LED ਪੂਰਵ-ਨਿਰਧਾਰਤ ਸਕਿੰਟਾਂ ਲਈ ਚਾਲੂ ਰਹੇ। ਇੱਕ delay() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਬਜਾਏ ਜੋ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਬਲੌਕ ਕਰਦਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਸਕਿੰਟਾਂ ਦੀ ਇੱਕ ਨਿਰਧਾਰਤ ਸੰਖਿਆ ਲਈ ਹੋਰ ਕੁਝ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਦਿੰਦਾ ਹੈ, ਸਾਨੂੰ ਇੱਕ ਟਾਈਮਰ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।ਦੇਰੀ() ਫੰਕਸ਼ਨ
ਤੁਹਾਨੂੰ delay() ਫੰਕਸ਼ਨ ਤੋਂ ਜਾਣੂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਫੰਕਸ਼ਨ ਵਰਤਣ ਲਈ ਕਾਫ਼ੀ ਸਿੱਧਾ ਹੈ. ਇਹ ਇੱਕ ਇੱਕਲੇ ਇੰਟ ਨੰਬਰ ਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ।
ਇਹ ਨੰਬਰ ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ ਉਸ ਸਮੇਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕੋਡ ਦੀ ਅਗਲੀ ਲਾਈਨ 'ਤੇ ਜਾਣ ਤੱਕ ਉਡੀਕ ਕਰਨੀ ਪੈਂਦੀ ਹੈ।ਜਦੋਂ ਤੁਸੀਂ ਦੇਰੀ (1000) ਕਰਦੇ ਹੋ ਤਾਂ ਤੁਹਾਡਾ ਪ੍ਰੋਗਰਾਮ ਉਸ ਲਾਈਨ 'ਤੇ 1 ਸਕਿੰਟ ਲਈ ਰੁਕ ਜਾਂਦਾ ਹੈ।
delay() ਇੱਕ ਬਲਾਕਿੰਗ ਫੰਕਸ਼ਨ ਹੈ। ਬਲਾਕਿੰਗ ਫੰਕਸ਼ਨ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕੁਝ ਹੋਰ ਕਰਨ ਤੋਂ ਰੋਕਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਉਹ ਖਾਸ ਕੰਮ ਪੂਰਾ ਨਹੀਂ ਹੋ ਜਾਂਦਾ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਇੱਕੋ ਸਮੇਂ ਕਈ ਕਾਰਜ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਤੁਸੀਂ delay() ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰ ਸਕਦੇ।
ਜ਼ਿਆਦਾਤਰ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਤੁਹਾਨੂੰ ਦੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਬਚਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਇਸ ਦੀ ਬਜਾਏ ਟਾਈਮਰ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।
ਮਿਲੀਸ() ਫੰਕਸ਼ਨ
millis() ਨਾਮਕ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੁਸੀਂ ਮਿਲੀਸਕਿੰਡ ਦੀ ਸੰਖਿਆ ਵਾਪਸ ਕਰ ਸਕਦੇ ਹੋ ਜੋ ਪ੍ਰੋਗਰਾਮ ਦੇ ਪਹਿਲੀ ਵਾਰ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਲੰਘ ਗਏ ਹਨ।ਇਹ ਫੰਕਸ਼ਨ ਲਾਭਦਾਇਕ ਕਿਉਂ ਹੈ? ਕਿਉਂਕਿ ਕੁਝ ਗਣਿਤ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਸੀਂ ਆਸਾਨੀ ਨਾਲ ਪੁਸ਼ਟੀ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਬਲਾਕ ਕੀਤੇ ਬਿਨਾਂ ਕਿੰਨਾ ਸਮਾਂ ਲੰਘ ਗਿਆ ਹੈ।
ਪੁਰਜ਼ਿਆਂ ਦੀ ਲੋੜ ਹੈ
ਇਸ ਟਿਊਟੋਰਿਅਲ ਦੀ ਪਾਲਣਾ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਭਾਗਾਂ ਦੀ ਲੋੜ ਹੈ

• ESP32 DEVKIT V1 ਬੋਰਡ
• ਪੀਆਈਆਰ ਮੋਸ਼ਨ ਸੈਂਸਰ (HC-SR501)
• ਐਕਟਿਵ ਬੱਜ਼ਰ
• ਜੰਪਰ ਤਾਰਾਂ
• ਰੋਟੀ ਦਾ ਬੋਰਡ

ਯੋਜਨਾਬੱਧਨੋਟ: ਕਾਰਜਸ਼ੀਲ ਵੋਲਯੂtagHC-SR501 ਦਾ e 5V ਹੈ। ਇਸਨੂੰ ਪਾਵਰ ਦੇਣ ਲਈ Vin ਪਿੰਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਕੋਡ
ਇਸ ਟਿਊਟੋਰਿਅਲ ਨਾਲ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਤੁਹਾਡੇ ਕੋਲ ਆਪਣੇ Arduino IDE ਵਿੱਚ ESP32 ਐਡ-ਆਨ ਇੰਸਟਾਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। Arduino IDE 'ਤੇ ESP32 ਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ ਟਿਊਟੋਰਿਅਲਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦਾ ਪਾਲਣ ਕਰੋ, ਜੇਕਰ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਨਹੀਂ ਕੀਤਾ ਹੈ।
Arduino IDE ਵਿੱਚ ESP32 ਐਡ-ਆਨ ਇੰਸਟਾਲ ਕਰਨਾ
arduino IDE ਵਿੱਚ Project_4_ESP32_PIR_Motion_Sensor.ino ਕੋਡ ਖੋਲ੍ਹੋ।
ਪ੍ਰਦਰਸ਼ਨ
ਕੋਡ ਨੂੰ ਆਪਣੇ ESP32 ਬੋਰਡ 'ਤੇ ਅੱਪਲੋਡ ਕਰੋ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਸਹੀ ਬੋਰਡ ਅਤੇ COM ਪੋਰਟ ਚੁਣਿਆ ਗਿਆ ਹੈ। ਕੋਡ ਸੰਦਰਭ ਪੜਾਅ ਅੱਪਲੋਡ ਕਰੋ।
ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਨੂੰ 115200 ਦੀ ਬੌਡ ਦਰ 'ਤੇ ਖੋਲ੍ਹੋ।PIR ਸੈਂਸਰ ਦੇ ਸਾਹਮਣੇ ਆਪਣਾ ਹੱਥ ਹਿਲਾਓ। ਬਜ਼ਰ ਨੂੰ ਚਾਲੂ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਵਿੱਚ ਸੁਨੇਹਾ ਛਾਪਿਆ ਜਾਂਦਾ ਹੈ "ਮੋਸ਼ਨ ਖੋਜਿਆ ਗਿਆ ਹੈ! ਬਜ਼ਰ ਅਲਾਰਮ"।
4 ਸਕਿੰਟਾਂ ਬਾਅਦ ਬਜ਼ਰ ਬੰਦ ਹੋ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

ਪ੍ਰੋਜੈਕਟ 5 ESP32 ਸਵਿੱਚ Web ਸਰਵਰ

ਇਸ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਤੁਸੀਂ ਇੱਕ ਸਟੈਂਡਅਲੋਨ ਬਣਾਉਗੇ web ਇੱਕ ESP32 ਵਾਲਾ ਸਰਵਰ ਜੋ Arduino IDE ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਾਤਾਵਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਉਟਪੁੱਟ (ਦੋ LEDs) ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ। ਦ web ਸਰਵਰ ਮੋਬਾਈਲ ਜਵਾਬਦੇਹ ਹੈ ਅਤੇ ਕਿਸੇ ਵੀ ਡਿਵਾਈਸ ਨਾਲ ਐਕਸੈਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਸਥਾਨਕ ਨੈਟਵਰਕ ਤੇ ਇੱਕ ਬ੍ਰਾਉਜ਼ਰ ਦੇ ਰੂਪ ਵਿੱਚ ਹੈ। ਅਸੀਂ ਤੁਹਾਨੂੰ ਦਿਖਾਵਾਂਗੇ ਕਿ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ web ਸਰਵਰ ਅਤੇ ਕੋਡ ਕਦਮ-ਦਰ-ਕਦਮ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।
ਪ੍ਰੋਜੈਕਟ ਸਮਾਪਤview
ਸਿੱਧੇ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ, ਇਹ ਦੱਸਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਸਾਡੇ ਕੀ web ਸਰਵਰ ਕਰੇਗਾ, ਤਾਂ ਜੋ ਬਾਅਦ ਵਿੱਚ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨਾ ਆਸਾਨ ਹੋਵੇ।

• ਦ web ਸਰਵਰ ਜੋ ਤੁਸੀਂ ESP32 GPIO 26 ਅਤੇ GPIO 27 ਨਾਲ ਜੁੜੇ ਦੋ LEDs ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰੋਗੇ;
• ਤੁਸੀਂ ESP32 ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹੋ web ਸਥਾਨਕ ਨੈੱਟਵਰਕ ਵਿੱਚ ਇੱਕ ਬਰਾਊਜ਼ਰ ਉੱਤੇ ESP32 IP ਐਡਰੈੱਸ ਟਾਈਪ ਕਰਕੇ ਸਰਵਰ;
• 'ਤੇ ਬਟਨਾਂ ਨੂੰ ਦਬਾ ਕੇ ਤੁਹਾਡੇ web ਸਰਵਰ ਤੁਸੀਂ ਤੁਰੰਤ ਹਰੇਕ LED ਦੀ ਸਥਿਤੀ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹੋ।

ਪੁਰਜ਼ਿਆਂ ਦੀ ਲੋੜ ਹੈ
ਇਸ ਟਿਊਟੋਰਿਅਲ ਲਈ ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਭਾਗਾਂ ਦੀ ਲੋੜ ਪਵੇਗੀ:

• ESP32 DEVKIT V1 ਬੋਰਡ
• 2x 5mm LED
• 2x 200 Ohm ਰੋਧਕ
• ਰੋਟੀ ਦਾ ਬੋਰਡ
• ਜੰਪਰ ਤਾਰਾਂ

ਯੋਜਨਾਬੱਧ
ਸਰਕਟ ਬਣਾ ਕੇ ਸ਼ੁਰੂ ਕਰੋ। ਦੋ LEDs ਨੂੰ ESP32 ਨਾਲ ਕਨੈਕਟ ਕਰੋ ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦਿੱਤੇ ਯੋਜਨਾਬੱਧ ਚਿੱਤਰ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ - ਇੱਕ LED GPIO 26 ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ, ਅਤੇ ਦੂਜਾ GPIO 27 ਨਾਲ।
ਨੋਟ: ਅਸੀਂ 32 ਪਿੰਨਾਂ ਦੇ ਨਾਲ ESP36 DEVKIT DOIT ਬੋਰਡ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ। ਸਰਕਟ ਨੂੰ ਅਸੈਂਬਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਉਸ ਬੋਰਡ ਲਈ ਪਿਨਆਉਟ ਦੀ ਜਾਂਚ ਕਰ ਰਹੇ ਹੋ ਜੋ ਤੁਸੀਂ ਵਰਤ ਰਹੇ ਹੋ।ਕੋਡ
ਇੱਥੇ ਅਸੀਂ ਕੋਡ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਾਂ ਜੋ ESP32 ਬਣਾਉਂਦਾ ਹੈ web ਸਰਵਰ ਕੋਡ ਪ੍ਰੋਜੈਕਟ_5_ESP32_ਸਵਿੱਚ _ ਖੋਲ੍ਹੋWeb_Server.ino arduino IDE ਵਿੱਚ, ਪਰ ਇਸਨੂੰ ਅਜੇ ਅੱਪਲੋਡ ਨਾ ਕਰੋ। ਇਹ ਤੁਹਾਡੇ ਲਈ ਕੰਮ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਕੁਝ ਬਦਲਾਅ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
ਅਸੀਂ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ESP32 ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਕਰਾਂਗੇ, ਇਸ ਲਈ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ESP32 ਐਡ-ਆਨ ਸਥਾਪਤ ਹੈ: (ਜੇ ਤੁਸੀਂ ਇਹ ਕਦਮ ਪਹਿਲਾਂ ਹੀ ਕਰ ਚੁੱਕੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਅਗਲੇ ਪੜਾਅ 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ।)
Arduino IDE ਵਿੱਚ ESP32 ਐਡ-ਆਨ ਇੰਸਟਾਲ ਕਰਨਾ
ਤੁਹਾਡੇ ਨੈੱਟਵਰਕ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਨੂੰ ਸੈੱਟ ਕਰਨਾ
ਤੁਹਾਨੂੰ ਆਪਣੇ ਨੈੱਟਵਰਕ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਨਾਲ ਹੇਠ ਲਿਖੀਆਂ ਲਾਈਨਾਂ ਨੂੰ ਸੋਧਣ ਦੀ ਲੋੜ ਹੈ: SSID ਅਤੇ ਪਾਸਵਰਡ। ਕੋਡ ਵਿੱਚ ਚੰਗੀ ਤਰ੍ਹਾਂ ਟਿੱਪਣੀ ਕੀਤੀ ਗਈ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਤਬਦੀਲੀਆਂ ਕਿੱਥੇ ਕਰਨੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ।ਕੋਡ ਅੱਪਲੋਡ ਕਰ ਰਿਹਾ ਹੈ
ਹੁਣ, ਤੁਸੀਂ ਕੋਡ ਅੱਪਲੋਡ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਅਤੇ web ਸਰਵਰ ਤੁਰੰਤ ਕੰਮ ਕਰੇਗਾ।
ESP32 'ਤੇ ਕੋਡ ਅੱਪਲੋਡ ਕਰਨ ਲਈ ਅਗਲੇ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ:

1. ਆਪਣੇ ਕੰਪਿਊਟਰ ਵਿੱਚ ਆਪਣੇ ESP32 ਬੋਰਡ ਨੂੰ ਪਲੱਗ ਕਰੋ;
2. Arduino IDE ਵਿੱਚ ਟੂਲਸ > ਬੋਰਡ ਵਿੱਚ ਆਪਣਾ ਬੋਰਡ ਚੁਣੋ (ਸਾਡੇ ਕੇਸ ਵਿੱਚ ਅਸੀਂ ESP32 DEVKIT DOIT ਬੋਰਡ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ);
3. ਟੂਲਸ > ਪੋਰਟ ਵਿੱਚ COM ਪੋਰਟ ਚੁਣੋ।
4. Arduino IDE ਵਿੱਚ ਅੱਪਲੋਡ ਬਟਨ ਦਬਾਓ ਅਤੇ ਕੋਡ ਕੰਪਾਇਲ ਅਤੇ ਤੁਹਾਡੇ ਬੋਰਡ 'ਤੇ ਅੱਪਲੋਡ ਹੋਣ ਤੱਕ ਕੁਝ ਸਕਿੰਟ ਉਡੀਕ ਕਰੋ।
5. "ਅੱਪਲੋਡਿੰਗ ਹੋ ਗਿਆ" ਸੁਨੇਹੇ ਦੀ ਉਡੀਕ ਕਰੋ।

ESP IP ਪਤਾ ਲੱਭਣਾ
ਕੋਡ ਅੱਪਲੋਡ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਨੂੰ 115200 ਦੀ ਬੌਡ ਦਰ 'ਤੇ ਖੋਲ੍ਹੋ।ESP32 EN ਬਟਨ ਦਬਾਓ (ਰੀਸੈਟ)। ESP32 Wi-Fi ਨਾਲ ਜੁੜਦਾ ਹੈ, ਅਤੇ ਸੀਰੀਅਲ ਮਾਨੀਟਰ 'ਤੇ ESP IP ਐਡਰੈੱਸ ਨੂੰ ਆਊਟਪੁੱਟ ਕਰਦਾ ਹੈ। ਉਸ IP ਪਤੇ ਨੂੰ ਕਾਪੀ ਕਰੋ, ਕਿਉਂਕਿ ਤੁਹਾਨੂੰ ESP32 ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਇਸਦੀ ਲੋੜ ਹੈ web ਸਰਵਰਤੱਕ ਪਹੁੰਚ ਕਰ ਰਿਹਾ ਹੈ Web ਸਰਵਰ
ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ web ਸਰਵਰ, ਆਪਣਾ ਬ੍ਰਾਊਜ਼ਰ ਖੋਲ੍ਹੋ, ESP32 IP ਐਡਰੈੱਸ ਪੇਸਟ ਕਰੋ, ਅਤੇ ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤਾ ਪੰਨਾ ਦੇਖੋਗੇ।
ਨੋਟ: ਤੁਹਾਡਾ ਬ੍ਰਾਊਜ਼ਰ ਅਤੇ ESP32 ਇੱਕੋ LAN ਨਾਲ ਕਨੈਕਟ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ।ਜੇਕਰ ਤੁਸੀਂ ਸੀਰੀਅਲ ਮਾਨੀਟਰ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਪਿਛੋਕੜ 'ਤੇ ਕੀ ਹੋ ਰਿਹਾ ਹੈ। ESP ਨੂੰ ਇੱਕ ਨਵੇਂ ਕਲਾਇੰਟ (ਇਸ ਕੇਸ ਵਿੱਚ, ਤੁਹਾਡਾ ਬ੍ਰਾਊਜ਼ਰ) ਤੋਂ ਇੱਕ HTTP ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ।ਤੁਸੀਂ HTTP ਬੇਨਤੀ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਵੀ ਦੇਖ ਸਕਦੇ ਹੋ।
ਪ੍ਰਦਰਸ਼ਨ
ਹੁਣ ਤੁਸੀਂ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹੋ ਜੇਕਰ ਤੁਹਾਡਾ web ਸਰਵਰ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ। LEDs ਨੂੰ ਕੰਟਰੋਲ ਕਰਨ ਲਈ ਬਟਨਾਂ 'ਤੇ ਕਲਿੱਕ ਕਰੋ।ਉਸੇ ਸਮੇਂ, ਤੁਸੀਂ ਸੀਰੀਅਲ ਮਾਨੀਟਰ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਲੈ ਸਕਦੇ ਹੋ ਇਹ ਵੇਖਣ ਲਈ ਕਿ ਬੈਕਗ੍ਰਾਉਂਡ ਵਿੱਚ ਕੀ ਹੋ ਰਿਹਾ ਹੈ। ਸਾਬਕਾ ਲਈample, ਜਦੋਂ ਤੁਸੀਂ GPIO 26 ਨੂੰ ਚਾਲੂ ਕਰਨ ਲਈ ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰਦੇ ਹੋ, ESP32 ਨੂੰ /26/on 'ਤੇ ਇੱਕ ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ। URL.ਜਦੋਂ ESP32 ਨੂੰ ਉਹ ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਇਹ GPIO 26 ਨਾਲ ਜੁੜੇ LED ਨੂੰ ਚਾਲੂ ਕਰ ਦਿੰਦਾ ਹੈ ਅਤੇ ਇਸਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ। web ਪੰਨਾGPIO 27 ਲਈ ਬਟਨ ਇਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਜਾਂਚ ਕਰੋ ਕਿ ਇਹ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ।

ਕੋਡ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ

ਇਸ ਭਾਗ ਵਿੱਚ ਇਹ ਦੇਖਣ ਲਈ ਕੋਡ 'ਤੇ ਇੱਕ ਡੂੰਘਾਈ ਨਾਲ ਵਿਚਾਰ ਕਰੇਗਾ ਕਿ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।
ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਤੁਹਾਨੂੰ WiFi ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।ਜਿਵੇਂ ਕਿ ਪਹਿਲਾਂ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਤੁਹਾਨੂੰ ਡਬਲ ਕੋਟਸ ਦੇ ਅੰਦਰ ਹੇਠ ਲਿਖੀਆਂ ਲਾਈਨਾਂ ਵਿੱਚ ਆਪਣਾ ssid ਅਤੇ ਪਾਸਵਰਡ ਪਾਉਣ ਦੀ ਲੋੜ ਹੈ।ਫਿਰ, ਤੁਸੀਂ ਆਪਣਾ ਸੈੱਟ ਕਰੋ web ਸਰਵਰ ਨੂੰ ਪੋਰਟ 80.ਹੇਠ ਦਿੱਤੀ ਲਾਈਨ HTTP ਬੇਨਤੀ ਦੇ ਸਿਰਲੇਖ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ ਬਣਾਉਂਦੀ ਹੈ:ਅੱਗੇ, ਤੁਸੀਂ ਆਪਣੇ ਆਉਟਪੁੱਟ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਸਹਾਇਕ ਵੇਰੀਏਬਲ ਬਣਾਉਂਦੇ ਹੋ। ਜੇ ਤੁਸੀਂ ਹੋਰ ਆਉਟਪੁੱਟ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹੋ ਅਤੇ ਇਸਦੀ ਸਥਿਤੀ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਹੋਰ ਵੇਰੀਏਬਲ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ।ਤੁਹਾਨੂੰ ਆਪਣੇ ਹਰੇਕ ਆਉਟਪੁੱਟ ਲਈ ਇੱਕ GPIO ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਵੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇੱਥੇ ਅਸੀਂ GPIO 26 ਅਤੇ GPIO 27 ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ। ਤੁਸੀਂ ਕਿਸੇ ਹੋਰ ਯੋਗ GPIO ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਸਥਾਪਨਾ ਕਰਨਾ()
ਹੁਣ, ਆਉ ਸੈੱਟਅੱਪ() ਵਿੱਚ ਚੱਲੀਏ। ਪਹਿਲਾਂ, ਅਸੀਂ ਡੀਬੱਗਿੰਗ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ 115200 ਦੀ ਬੌਡ ਦਰ 'ਤੇ ਸੀਰੀਅਲ ਸੰਚਾਰ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ।ਤੁਸੀਂ ਆਪਣੇ GPIOs ਨੂੰ OUTPUTs ਵਜੋਂ ਵੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਘੱਟ ਸੈੱਟ ਕਰਦੇ ਹੋ।ਹੇਠ ਲਿਖੀਆਂ ਲਾਈਨਾਂ WiFi.begin(ssid, ਪਾਸਵਰਡ) ਨਾਲ Wi-Fi ਕਨੈਕਸ਼ਨ ਸ਼ੁਰੂ ਕਰਦੀਆਂ ਹਨ, ਇੱਕ ਸਫਲ ਕਨੈਕਸ਼ਨ ਦੀ ਉਡੀਕ ਕਰੋ ਅਤੇ ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਵਿੱਚ ESP IP ਐਡਰੈੱਸ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰੋ।ਲੂਪ()
ਲੂਪ() ਵਿੱਚ ਅਸੀਂ ਪ੍ਰੋਗਰਾਮ ਕਰਦੇ ਹਾਂ ਕਿ ਕੀ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਨਵਾਂ ਕਲਾਇੰਟ ਨਾਲ ਇੱਕ ਕੁਨੈਕਸ਼ਨ ਸਥਾਪਤ ਕਰਦਾ ਹੈ web ਸਰਵਰ
ESP32 ਹਮੇਸ਼ਾ ਹੇਠਾਂ ਦਿੱਤੀ ਲਾਈਨ ਦੇ ਨਾਲ ਆਉਣ ਵਾਲੇ ਗਾਹਕਾਂ ਲਈ ਸੁਣ ਰਿਹਾ ਹੈ:ਜਦੋਂ ਕਿਸੇ ਕਲਾਇੰਟ ਤੋਂ ਕੋਈ ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਅਸੀਂ ਆਉਣ ਵਾਲੇ ਡੇਟਾ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਾਂਗੇ। ਜਦੋਂ ਤੱਕ ਕਲਾਇੰਟ ਕਨੈਕਟ ਰਹਿੰਦਾ ਹੈ, ਤਦ ਤੱਕ ਚੱਲਣ ਵਾਲਾ ਲੂਪ ਚੱਲਦਾ ਰਹੇਗਾ। ਅਸੀਂ ਕੋਡ ਦੇ ਹੇਠਲੇ ਹਿੱਸੇ ਨੂੰ ਬਦਲਣ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਨਹੀਂ ਕਰਦੇ ਹਾਂ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਇਹ ਨਹੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਕੀ ਕਰ ਰਹੇ ਹੋ।if ਅਤੇ else ਸਟੇਟਮੈਂਟਾਂ ਦਾ ਅਗਲਾ ਭਾਗ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਤੁਹਾਡੇ ਵਿੱਚ ਕਿਹੜਾ ਬਟਨ ਦਬਾਇਆ ਗਿਆ ਸੀ web ਪੇਜ, ਅਤੇ ਉਸ ਅਨੁਸਾਰ ਆਉਟਪੁੱਟ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ। ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਦੇਖਿਆ ਹੈ, ਅਸੀਂ ਵੱਖ-ਵੱਖ 'ਤੇ ਬੇਨਤੀ ਕਰਦੇ ਹਾਂ URLs ਦਬਾਏ ਗਏ ਬਟਨ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।ਸਾਬਕਾ ਲਈample, ਜੇਕਰ ਤੁਸੀਂ GPIO 26 ON ਬਟਨ ਨੂੰ ਦਬਾਇਆ ਹੈ, ਤਾਂ ESP32 ਨੂੰ /26/ON 'ਤੇ ਇੱਕ ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ। URL (ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ ਕਿ ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਉੱਤੇ HTTP ਸਿਰਲੇਖ ਉੱਤੇ ਉਹ ਜਾਣਕਾਰੀ)। ਇਸ ਲਈ, ਅਸੀਂ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਕੀ ਸਿਰਲੇਖ ਵਿੱਚ ਸਮੀਕਰਨ GET /26/on ਹੈ। ਜੇਕਰ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ, ਤਾਂ ਅਸੀਂ ਆਉਟਪੁੱਟ26 ਸਟੇਟ ਵੇਰੀਏਬਲ ਨੂੰ ਚਾਲੂ ਕਰਦੇ ਹਾਂ, ਅਤੇ ESP32 LED ਨੂੰ ਚਾਲੂ ਕਰਦਾ ਹੈ।
ਇਹ ਦੂਜੇ ਬਟਨਾਂ ਲਈ ਵੀ ਇਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਸ ਲਈ, ਜੇਕਰ ਤੁਸੀਂ ਹੋਰ ਆਉਟਪੁੱਟ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਕੋਡ ਦੇ ਇਸ ਹਿੱਸੇ ਨੂੰ ਸੋਧਣਾ ਚਾਹੀਦਾ ਹੈ।
HTML ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ web ਪੰਨਾ
ਅਗਲੀ ਚੀਜ਼ ਜੋ ਤੁਹਾਨੂੰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਉਹ ਬਣਾਉਣਾ ਹੈ web ਪੰਨਾ ESP32 ਨੂੰ ਬਣਾਉਣ ਲਈ ਕੁਝ HTML ਕੋਡ ਦੇ ਨਾਲ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਜਵਾਬ ਭੇਜਿਆ ਜਾਵੇਗਾ web ਪੰਨਾ
ਦ web ਸਫ਼ਾ ਗਾਹਕ ਨੂੰ ਇਸ ਐਕਸਪ੍ਰੈਸਿੰਗ client.println() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਉਹ ਦਰਜ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਕਲਾਇੰਟ ਨੂੰ ਇੱਕ ਦਲੀਲ ਵਜੋਂ ਭੇਜਣਾ ਚਾਹੁੰਦੇ ਹੋ।
ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਜੋ ਸਾਨੂੰ ਭੇਜਣਾ ਚਾਹੀਦਾ ਹੈ ਉਹ ਹਮੇਸ਼ਾ ਹੇਠਾਂ ਦਿੱਤੀ ਲਾਈਨ ਹੁੰਦੀ ਹੈ, ਜੋ ਇਹ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਅਸੀਂ HTML ਭੇਜ ਰਹੇ ਹਾਂ।ਫਿਰ, ਹੇਠ ਦਿੱਤੀ ਲਾਈਨ ਬਣਾ ਦਿੰਦੀ ਹੈ web ਪੰਨਾ ਕਿਸੇ ਵੀ ਵਿੱਚ ਜਵਾਬਦੇਹ web ਬਰਾਊਜ਼ਰ।ਅਤੇ ਫੇਵੀਕੋਨ 'ਤੇ ਬੇਨਤੀਆਂ ਨੂੰ ਰੋਕਣ ਲਈ ਹੇਠ ਲਿਖੇ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। - ਤੁਹਾਨੂੰ ਇਸ ਲਾਈਨ ਬਾਰੇ ਚਿੰਤਾ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।

ਸਟਾਈਲਿੰਗ Web ਪੰਨਾ

ਅੱਗੇ, ਸਾਡੇ ਕੋਲ ਬਟਨਾਂ ਨੂੰ ਸਟਾਈਲ ਕਰਨ ਲਈ ਕੁਝ CSS ਟੈਕਸਟ ਹੈ ਅਤੇ web ਪੰਨੇ ਦੀ ਦਿੱਖ.
ਅਸੀਂ ਹੈਲਵੇਟਿਕਾ ਫੌਂਟ ਚੁਣਦੇ ਹਾਂ, ਬਲਾਕ ਦੇ ਤੌਰ 'ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਸਮਗਰੀ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ ਅਤੇ ਕੇਂਦਰ 'ਤੇ ਇਕਸਾਰ ਹੁੰਦੇ ਹਾਂ।ਅਸੀਂ ਆਪਣੇ ਬਟਨਾਂ ਨੂੰ #4CAF50 ਰੰਗ, ਬਿਨਾਂ ਬਾਰਡਰ, ਸਫੇਦ ਰੰਗ ਵਿੱਚ ਟੈਕਸਟ, ਅਤੇ ਇਸ ਪੈਡਿੰਗ ਨਾਲ ਸਟਾਈਲ ਕਰਦੇ ਹਾਂ: 16px 40px। ਅਸੀਂ ਟੈਕਸਟ-ਸਜਾਵਟ ਨੂੰ ਕੋਈ ਨਹੀਂ 'ਤੇ ਸੈੱਟ ਕਰਦੇ ਹਾਂ, ਫੌਂਟ ਆਕਾਰ, ਹਾਸ਼ੀਏ, ਅਤੇ ਕਰਸਰ ਨੂੰ ਪੁਆਇੰਟਰ ਲਈ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ।ਅਸੀਂ ਦੂਜੇ ਬਟਨ ਲਈ ਸ਼ੈਲੀ ਨੂੰ ਵੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ, ਬਟਨ ਦੀਆਂ ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਨਾਲ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ, ਪਰ ਇੱਕ ਵੱਖਰੇ ਰੰਗ ਨਾਲ। ਇਹ ਬੰਦ ਬਟਨ ਲਈ ਸ਼ੈਲੀ ਹੋਵੇਗੀ।

ਸੈੱਟ ਕਰਨਾ Web ਪੰਨਾ ਪਹਿਲਾ ਸਿਰਲੇਖ
ਅਗਲੀ ਲਾਈਨ ਵਿੱਚ ਤੁਸੀਂ ਆਪਣਾ ਪਹਿਲਾ ਸਿਰਲੇਖ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹੋ web ਪੰਨਾ ਇੱਥੇ ਸਾਡੇ ਕੋਲ “ESP32 ਹੈ Web ਸਰਵਰ”, ਪਰ ਤੁਸੀਂ ਇਸ ਟੈਕਸਟ ਨੂੰ ਆਪਣੀ ਮਰਜ਼ੀ ਨਾਲ ਬਦਲ ਸਕਦੇ ਹੋ।ਬਟਨ ਅਤੇ ਅਨੁਸਾਰੀ ਸਥਿਤੀ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ
ਫਿਰ, ਤੁਸੀਂ GPIO 26 ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਇੱਕ ਪੈਰਾ ਲਿਖਦੇ ਹੋ। ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਅਸੀਂ output26State ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਕਿ ਜਦੋਂ ਇਹ ਵੇਰੀਏਬਲ ਬਦਲਦਾ ਹੈ ਤਾਂ ਸਟੇਟ ਤੁਰੰਤ ਅੱਪਡੇਟ ਹੋ ਜਾਂਦੀ ਹੈ।ਫਿਰ, ਅਸੀਂ GPIO ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ, ਚਾਲੂ ਜਾਂ ਬੰਦ ਬਟਨ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੇ ਹਾਂ। ਜੇਕਰ GPIO ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਬੰਦ ਹੈ, ਤਾਂ ਅਸੀਂ ON ਬਟਨ ਦਿਖਾਉਂਦੇ ਹਾਂ, ਜੇਕਰ ਨਹੀਂ, ਤਾਂ ਅਸੀਂ OFF ਬਟਨ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੇ ਹਾਂ।ਅਸੀਂ GPIO 27 ਲਈ ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਵਰਤਦੇ ਹਾਂ।
ਕਨੈਕਸ਼ਨ ਬੰਦ ਕਰਨਾ
ਅੰਤ ਵਿੱਚ, ਜਦੋਂ ਜਵਾਬ ਖਤਮ ਹੁੰਦਾ ਹੈ, ਅਸੀਂ ਸਿਰਲੇਖ ਵੇਰੀਏਬਲ ਨੂੰ ਸਾਫ਼ ਕਰਦੇ ਹਾਂ, ਅਤੇ client.stop() ਨਾਲ ਕਲਾਇੰਟ ਦੇ ਨਾਲ ਕੁਨੈਕਸ਼ਨ ਨੂੰ ਰੋਕ ਦਿੰਦੇ ਹਾਂ।

ਸਮੇਟਣਾ

ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ ਤੁਹਾਨੂੰ ਇੱਕ ਬਣਾਉਣ ਦਾ ਤਰੀਕਾ ਦਿਖਾਇਆ ਹੈ web ESP32 ਨਾਲ ਸਰਵਰ। ਅਸੀਂ ਤੁਹਾਨੂੰ ਇੱਕ ਸਧਾਰਨ ਸਾਬਕਾ ਦਿਖਾਇਆ ਹੈample ਜੋ ਦੋ LEDs ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ, ਪਰ ਵਿਚਾਰ ਉਹਨਾਂ LEDs ਨੂੰ ਇੱਕ ਰੀਲੇਅ ਨਾਲ ਬਦਲਣਾ ਹੈ, ਜਾਂ ਕੋਈ ਹੋਰ ਆਉਟਪੁੱਟ ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਕੰਟਰੋਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ।

ਪ੍ਰੋਜੈਕਟ 6 RGB LED Web ਸਰਵਰ

ਇਸ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਅਸੀਂ ਤੁਹਾਨੂੰ ਦਿਖਾਵਾਂਗੇ ਕਿ ਇੱਕ ESP32 ਬੋਰਡ ਦੇ ਨਾਲ ਇੱਕ RGB LED ਨੂੰ ਰਿਮੋਟਲੀ ਕਿਵੇਂ ਕੰਟਰੋਲ ਕਰਨਾ ਹੈ web ਇੱਕ ਰੰਗ ਚੋਣਕਾਰ ਨਾਲ ਸਰਵਰ.
ਪ੍ਰੋਜੈਕਟ ਸਮਾਪਤview
ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਦੇਖੀਏ ਕਿ ਇਹ ਪ੍ਰੋਜੈਕਟ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ:

• ESP32 web ਸਰਵਰ ਇੱਕ ਰੰਗ ਚੋਣਕਾਰ ਦਿਖਾਉਂਦਾ ਹੈ।
• ਜਦੋਂ ਤੁਸੀਂ ਕੋਈ ਰੰਗ ਚੁਣਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਡਾ ਬ੍ਰਾਊਜ਼ਰ ਏ 'ਤੇ ਬੇਨਤੀ ਕਰਦਾ ਹੈ URL ਜਿਸ ਵਿੱਚ ਚੁਣੇ ਗਏ ਰੰਗ ਦੇ R, G, ਅਤੇ B ਪੈਰਾਮੀਟਰ ਹੁੰਦੇ ਹਨ।
• ਤੁਹਾਡਾ ESP32 ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਹਰੇਕ ਰੰਗ ਪੈਰਾਮੀਟਰ ਲਈ ਮੁੱਲ ਨੂੰ ਵੰਡਦਾ ਹੈ।
• ਫਿਰ, ਇਹ RGB LED ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਵਾਲੇ GPIOs ਨੂੰ ਸੰਬੰਧਿਤ ਮੁੱਲ ਦੇ ਨਾਲ ਇੱਕ PWM ਸਿਗਨਲ ਭੇਜਦਾ ਹੈ।

RGB LEDs ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?
ਇੱਕ ਆਮ ਕੈਥੋਡ RGB LED ਵਿੱਚ, ਸਾਰੇ ਤਿੰਨ LED ਇੱਕ ਨਕਾਰਾਤਮਕ ਕੁਨੈਕਸ਼ਨ (ਕੈਥੋਡ) ਨੂੰ ਸਾਂਝਾ ਕਰਦੇ ਹਨ। ਕਿੱਟ ਵਿੱਚ ਸ਼ਾਮਲ ਸਾਰੇ ਕਾਮਨ-ਕੈਥੋਡ RGB ਹਨ।ਵੱਖ-ਵੱਖ ਰੰਗਾਂ ਨੂੰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?
ਇੱਕ RGB LED ਨਾਲ ਤੁਸੀਂ, ਬੇਸ਼ਕ, ਲਾਲ, ਹਰਾ, ਅਤੇ ਨੀਲੀ ਰੋਸ਼ਨੀ ਪੈਦਾ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਹਰੇਕ LED ਦੀ ਤੀਬਰਤਾ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਕੇ, ਤੁਸੀਂ ਹੋਰ ਰੰਗ ਵੀ ਪੈਦਾ ਕਰ ਸਕਦੇ ਹੋ।
ਸਾਬਕਾ ਲਈampਲੇ, ਬਿਲਕੁਲ ਨੀਲੀ ਰੋਸ਼ਨੀ ਪੈਦਾ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਨੀਲੇ LED ਨੂੰ ਸਭ ਤੋਂ ਵੱਧ ਤੀਬਰਤਾ ਅਤੇ ਹਰੇ ਅਤੇ ਲਾਲ LED ਨੂੰ ਸਭ ਤੋਂ ਘੱਟ ਤੀਬਰਤਾ 'ਤੇ ਸੈੱਟ ਕਰੋਗੇ। ਇੱਕ ਚਿੱਟੀ ਰੋਸ਼ਨੀ ਲਈ, ਤੁਸੀਂ ਤਿੰਨੋਂ LEDs ਨੂੰ ਸਭ ਤੋਂ ਵੱਧ ਤੀਬਰਤਾ 'ਤੇ ਸੈੱਟ ਕਰੋਗੇ।
ਰੰਗ ਮਿਲਾਉਣਾ
ਹੋਰ ਰੰਗ ਪੈਦਾ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਤਿੰਨ ਰੰਗਾਂ ਨੂੰ ਵੱਖ-ਵੱਖ ਤੀਬਰਤਾ ਵਿੱਚ ਜੋੜ ਸਕਦੇ ਹੋ। ਹਰੇਕ LED ਦੀ ਤੀਬਰਤਾ ਨੂੰ ਅਨੁਕੂਲ ਕਰਨ ਲਈ ਤੁਸੀਂ PWM ਸਿਗਨਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।
ਕਿਉਂਕਿ ਐਲਈਡੀ ਇੱਕ ਦੂਜੇ ਦੇ ਬਹੁਤ ਨੇੜੇ ਹਨ, ਸਾਡੀਆਂ ਅੱਖਾਂ ਰੰਗਾਂ ਦੇ ਸੁਮੇਲ ਦਾ ਨਤੀਜਾ ਦੇਖਦੀਆਂ ਹਨ, ਨਾ ਕਿ ਤਿੰਨਾਂ ਰੰਗਾਂ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ।
ਰੰਗਾਂ ਨੂੰ ਕਿਵੇਂ ਜੋੜਨਾ ਹੈ ਇਸ ਬਾਰੇ ਵਿਚਾਰ ਕਰਨ ਲਈ, ਹੇਠਾਂ ਦਿੱਤੇ ਚਾਰਟ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੋ।
ਇਹ ਸਭ ਤੋਂ ਸਰਲ ਰੰਗ ਮਿਕਸਿੰਗ ਚਾਰਟ ਹੈ, ਪਰ ਇਹ ਤੁਹਾਨੂੰ ਇੱਕ ਵਿਚਾਰ ਦਿੰਦਾ ਹੈ ਕਿ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਵੱਖ-ਵੱਖ ਰੰਗਾਂ ਨੂੰ ਕਿਵੇਂ ਪੈਦਾ ਕਰਨਾ ਹੈ।ਪੁਰਜ਼ਿਆਂ ਦੀ ਲੋੜ ਹੈ
ਇਸ ਪ੍ਰੋਜੈਕਟ ਲਈ ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਭਾਗਾਂ ਦੀ ਲੋੜ ਹੈ:

• ESP32 DEVKIT V1 ਬੋਰਡ
• RGB LED
• 3x 220 ohm ਰੋਧਕ
• ਜੰਪਰ ਤਾਰਾਂ
• ਰੋਟੀ ਦਾ ਬੋਰਡ

ਯੋਜਨਾਬੱਧਕੋਡ
ਅਸੀਂ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ESP32 ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਕਰਾਂਗੇ, ਇਸ ਲਈ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ESP32 ਐਡ-ਆਨ ਸਥਾਪਤ ਹੈ: (ਜੇ ਤੁਸੀਂ ਇਹ ਕਦਮ ਪਹਿਲਾਂ ਹੀ ਕਰ ਚੁੱਕੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਅਗਲੇ ਪੜਾਅ 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ।)

• Arduino IDE ਵਿੱਚ ESP32 ਐਡ-ਆਨ ਇੰਸਟਾਲ ਕਰਨਾ

ਸਰਕਟ ਨੂੰ ਅਸੈਂਬਲ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਕੋਡ ਖੋਲ੍ਹੋ
ਪ੍ਰੋਜੈਕਟ_6_RGB_LED_Webarduino IDE ਵਿੱਚ _Server.ino।
ਕੋਡ ਅੱਪਲੋਡ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਆਪਣੇ ਨੈੱਟਵਰਕ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ ਨਾ ਭੁੱਲੋ ਤਾਂ ਜੋ ESP ਤੁਹਾਡੇ ਸਥਾਨਕ ਨੈੱਟਵਰਕ ਨਾਲ ਜੁੜ ਸਕੇ।ਕੋਡ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ
ESP32 ਸਕੈਚ WiFi.h ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਹੇਠ ਲਿਖੀਆਂ ਲਾਈਨਾਂ ਬੇਨਤੀ ਤੋਂ R, G, ਅਤੇ B ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਰੱਖਣ ਲਈ ਸਟ੍ਰਿੰਗ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀਆਂ ਹਨ।ਅਗਲੇ ਚਾਰ ਵੇਰੀਏਬਲਾਂ ਦੀ ਵਰਤੋਂ ਬਾਅਦ ਵਿੱਚ HTTP ਬੇਨਤੀ ਨੂੰ ਡੀਕੋਡ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।GPIO ਲਈ ਤਿੰਨ ਵੇਰੀਏਬਲ ਬਣਾਓ ਜੋ ਸਟ੍ਰਿਪ R, G, ਅਤੇ B ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨਗੇ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਅਸੀਂ GPIO 13, GPIO 12, ਅਤੇ GPIO 14 ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ।ਇਹਨਾਂ GPIOs ਨੂੰ PWM ਸਿਗਨਲ ਆਊਟਪੁੱਟ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਇਸਲਈ ਸਾਨੂੰ ਪਹਿਲਾਂ PWM ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। PWM ਸਿਗਨਲ ਬਾਰੰਬਾਰਤਾ ਨੂੰ 5000 Hz 'ਤੇ ਸੈੱਟ ਕਰੋ। ਫਿਰ, ਹਰੇਕ ਰੰਗ ਲਈ ਇੱਕ PWM ਚੈਨਲ ਜੋੜੋਅਤੇ ਅੰਤ ਵਿੱਚ, PWM ਚੈਨਲਾਂ ਦੇ ਰੈਜ਼ੋਲਿਊਸ਼ਨ ਨੂੰ 8-ਬਿੱਟ 'ਤੇ ਸੈੱਟ ਕਰੋਸੈੱਟਅੱਪ () ਵਿੱਚ, PWM ਚੈਨਲਾਂ ਨੂੰ PWM ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਿਰਧਾਰਤ ਕਰੋPWM ਚੈਨਲਾਂ ਨੂੰ ਸੰਬੰਧਿਤ GPIO ਨਾਲ ਨੱਥੀ ਕਰੋਹੇਠਲਾ ਕੋਡ ਭਾਗ ਤੁਹਾਡੇ ਵਿੱਚ ਰੰਗ ਚੋਣਕਾਰ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ web ਪੇਜ ਅਤੇ ਤੁਹਾਡੇ ਦੁਆਰਾ ਚੁਣੇ ਗਏ ਰੰਗ ਦੇ ਅਧਾਰ ਤੇ ਇੱਕ ਬੇਨਤੀ ਕਰਦਾ ਹੈ।ਜਦੋਂ ਤੁਸੀਂ ਕੋਈ ਰੰਗ ਚੁਣਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਫਾਰਮੈਟ ਨਾਲ ਇੱਕ ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ।

ਇਸ ਲਈ, ਸਾਨੂੰ R, G, ਅਤੇ B ਪੈਰਾਮੀਟਰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਸਤਰ ਨੂੰ ਵੰਡਣ ਦੀ ਲੋੜ ਹੈ। ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ redString, greenString, ਅਤੇ blueString ਵੇਰੀਏਬਲ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਹਨਾਂ ਦੇ ਮੁੱਲ 0 ਅਤੇ 255 ਦੇ ਵਿਚਕਾਰ ਹੋ ਸਕਦੇ ਹਨ।ESP32 ਨਾਲ ਸਟ੍ਰਿਪ ਨੂੰ ਕੰਟਰੋਲ ਕਰਨ ਲਈ, HTTP ਤੋਂ ਡੀਕੋਡ ਕੀਤੇ ਮੁੱਲਾਂ ਨਾਲ PWM ਸਿਗਨਲ ਬਣਾਉਣ ਲਈ ledcWrite() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਬੇਨਤੀਨੋਟ: ESP32 ਦੇ ਨਾਲ PWM ਬਾਰੇ ਹੋਰ ਜਾਣੋ: ਪ੍ਰੋਜੈਕਟ 3 ESP32 PWM(ਐਨਾਲਾਗ ਆਉਟਪੁੱਟ)
ESP8266 ਨਾਲ ਪੱਟੀ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਸਿਰਫ਼ ਵਰਤਣ ਦੀ ਲੋੜ ਹੈ
HTPP ਬੇਨਤੀ ਤੋਂ ਡੀਕੋਡ ਕੀਤੇ ਮੁੱਲਾਂ ਨਾਲ PWM ਸਿਗਨਲ ਬਣਾਉਣ ਲਈ analogWrite() ਫੰਕਸ਼ਨ।
analogWrite(redPin, redString.toInt());
analogWrite(greenPin, greenString.toInt());
analogWrite(bluePin, blueString.toInt())
ਕਿਉਂਕਿ ਸਾਨੂੰ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵੇਰੀਏਬਲ ਵਿੱਚ ਮੁੱਲ ਪ੍ਰਾਪਤ ਹੁੰਦੇ ਹਨ, ਸਾਨੂੰ toInt() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਹਨਾਂ ਨੂੰ ਪੂਰਨ ਅੰਕਾਂ ਵਿੱਚ ਬਦਲਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
ਪ੍ਰਦਰਸ਼ਨ
ਆਪਣੇ ਨੈੱਟਵਰਕ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਨੂੰ ਸੰਮਿਲਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਸਹੀ ਬੋਰਡ ਅਤੇ COM ਪੋਰਟ ਚੁਣੋ ਅਤੇ ਕੋਡ ਨੂੰ ਆਪਣੇ ESP32 'ਤੇ ਅੱਪਲੋਡ ਕਰੋ। ਕੋਡ ਸੰਦਰਭ ਪੜਾਅ ਅੱਪਲੋਡ ਕਰੋ।
ਅਪਲੋਡ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਨੂੰ 115200 ਦੀ ਬਾਡ ਦਰ 'ਤੇ ਖੋਲ੍ਹੋ ਅਤੇ ESP ਸਮਰੱਥ/ਰੀਸੈੱਟ ਬਟਨ ਨੂੰ ਦਬਾਓ। ਤੁਹਾਨੂੰ ਬੋਰਡ ਦਾ IP ਪਤਾ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।ਆਪਣਾ ਬ੍ਰਾਊਜ਼ਰ ਖੋਲ੍ਹੋ ਅਤੇ ESP IP ਐਡਰੈੱਸ ਪਾਓ। ਹੁਣ, RGB LED ਲਈ ਰੰਗ ਚੁਣਨ ਲਈ ਰੰਗ ਚੋਣਕਾਰ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਫਿਰ, ਰੰਗ ਨੂੰ ਪ੍ਰਭਾਵੀ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ "ਰੰਗ ਬਦਲੋ" ਬਟਨ ਨੂੰ ਦਬਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.RGB LED ਨੂੰ ਬੰਦ ਕਰਨ ਲਈ, ਕਾਲਾ ਰੰਗ ਚੁਣੋ।
ਸਭ ਤੋਂ ਮਜ਼ਬੂਤ ​​ਰੰਗ (ਰੰਗ ਚੋਣਕਾਰ ਦੇ ਸਿਖਰ 'ਤੇ), ਉਹ ਹਨ ਜੋ ਬਿਹਤਰ ਨਤੀਜੇ ਪ੍ਰਦਾਨ ਕਰਨਗੇ।

ਪ੍ਰੋਜੈਕਟ 7 ESP32 ਰੀਲੇਅ Web ਸਰਵਰ

ESP32 ਨਾਲ ਰੀਲੇਅ ਦੀ ਵਰਤੋਂ ਕਰਨਾ AC ਘਰੇਲੂ ਉਪਕਰਨਾਂ ਨੂੰ ਰਿਮੋਟਲੀ ਕੰਟਰੋਲ ਕਰਨ ਦਾ ਵਧੀਆ ਤਰੀਕਾ ਹੈ। ਇਹ ਟਿਊਟੋਰਿਅਲ ਦੱਸਦਾ ਹੈ ਕਿ ESP32 ਨਾਲ ਰੀਲੇਅ ਮੋਡੀਊਲ ਨੂੰ ਕਿਵੇਂ ਕੰਟਰੋਲ ਕਰਨਾ ਹੈ।
ਅਸੀਂ ਇੱਕ ਨਜ਼ਰ ਮਾਰਾਂਗੇ ਕਿ ਇੱਕ ਰੀਲੇਅ ਮੋਡੀਊਲ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਰੀਲੇ ਨੂੰ ESP32 ਨਾਲ ਕਿਵੇਂ ਜੋੜਨਾ ਹੈ ਅਤੇ ਇੱਕ web ਇੱਕ ਰੀਲੇਅ ਨੂੰ ਰਿਮੋਟਲੀ ਕੰਟਰੋਲ ਕਰਨ ਲਈ ਸਰਵਰ।
ਰੀਲੇਅ ਪੇਸ਼ ਕਰ ਰਿਹਾ ਹੈ
ਇੱਕ ਰੀਲੇਅ ਇੱਕ ਇਲੈਕਟ੍ਰਿਕ ਤੌਰ 'ਤੇ ਸੰਚਾਲਿਤ ਸਵਿੱਚ ਹੈ ਅਤੇ ਕਿਸੇ ਹੋਰ ਸਵਿੱਚ ਦੀ ਤਰ੍ਹਾਂ, ਇਸ ਨੂੰ ਚਾਲੂ ਜਾਂ ਬੰਦ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਕਰੰਟ ਨੂੰ ਲੰਘਣ ਦਿੰਦਾ ਹੈ ਜਾਂ ਨਹੀਂ। ਇਸ ਨੂੰ ਘੱਟ ਵੋਲਯੂਮ ਨਾਲ ਕੰਟਰੋਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈtages, ESP3.3 GPIOs ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ 32V ਵਾਂਗ ਅਤੇ ਸਾਨੂੰ ਉੱਚ ਵੋਲਯੂਮ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈtages ਜਿਵੇਂ 12V, 24V ਜਾਂ ਮੇਨ ਵੋਲtage (ਯੂਰਪ ਵਿੱਚ 230V ਅਤੇ ਅਮਰੀਕਾ ਵਿੱਚ 120V)।ਖੱਬੇ ਪਾਸੇ, ਉੱਚ ਵੋਲਯੂਮ ਨੂੰ ਜੋੜਨ ਲਈ ਤਿੰਨ ਸਾਕਟਾਂ ਦੇ ਦੋ ਸੈੱਟ ਹਨtages, ਅਤੇ ਸੱਜੇ ਪਾਸੇ ਦੇ ਪਿੰਨ (low-voltage) ESP32 GPIOs ਨਾਲ ਜੁੜੋ।
ਮੇਨਸ ਵੋਲtagਈ ਕੁਨੈਕਸ਼ਨਪਿਛਲੀ ਫੋਟੋ ਵਿੱਚ ਦਿਖਾਏ ਗਏ ਰੀਲੇਅ ਮੋਡੀਊਲ ਵਿੱਚ ਦੋ ਕਨੈਕਟਰ ਹਨ, ਹਰੇਕ ਵਿੱਚ ਤਿੰਨ ਸਾਕਟ ਹਨ: ਆਮ (COM), ਆਮ ਤੌਰ 'ਤੇ ਬੰਦ (NC), ਅਤੇ ਆਮ ਤੌਰ 'ਤੇ ਖੁੱਲ੍ਹਾ (NO)।

• COM: ਉਸ ਕਰੰਟ ਨੂੰ ਕਨੈਕਟ ਕਰੋ ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਕੰਟਰੋਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ (ਮੁੱਖ ਵੋਲtagਈ).
• NC (ਆਮ ਤੌਰ 'ਤੇ ਬੰਦ): ਆਮ ਤੌਰ 'ਤੇ ਬੰਦ ਸੰਰਚਨਾ ਉਦੋਂ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਰੀਲੇਅ ਨੂੰ ਮੂਲ ਰੂਪ ਵਿੱਚ ਬੰਦ ਕੀਤਾ ਜਾਵੇ। NC ਹਨ COM ਪਿੰਨ ਜੁੜੇ ਹੋਏ ਹਨ, ਭਾਵ ਕਰੰਟ ਵਗ ਰਿਹਾ ਹੈ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਸਰਕਟ ਨੂੰ ਖੋਲ੍ਹਣ ਅਤੇ ਮੌਜੂਦਾ ਪ੍ਰਵਾਹ ਨੂੰ ਰੋਕਣ ਲਈ ESP32 ਤੋਂ ਰੀਲੇਅ ਮੋਡੀਊਲ ਨੂੰ ਸਿਗਨਲ ਨਹੀਂ ਭੇਜਦੇ ਹੋ।
• NO (ਆਮ ਤੌਰ 'ਤੇ ਓਪਨ): ਆਮ ਤੌਰ 'ਤੇ ਖੁੱਲ੍ਹੀ ਸੰਰਚਨਾ ਦੂਜੇ ਤਰੀਕੇ ਨਾਲ ਕੰਮ ਕਰਦੀ ਹੈ: NO ਅਤੇ COM ਪਿੰਨ ਵਿਚਕਾਰ ਕੋਈ ਕਨੈਕਸ਼ਨ ਨਹੀਂ ਹੈ, ਇਸਲਈ ਸਰਕਟ ਟੁੱਟ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ESP32 ਤੋਂ ਸਰਕਟ ਨੂੰ ਬੰਦ ਕਰਨ ਲਈ ਸਿਗਨਲ ਨਹੀਂ ਭੇਜਦੇ ਹੋ।

ਕੰਟਰੋਲ ਪਿੰਨਲੋਅ-ਵੋਲtage ਸਾਈਡ ਵਿੱਚ ਚਾਰ ਪਿੰਨਾਂ ਦਾ ਸੈੱਟ ਅਤੇ ਤਿੰਨ ਪਿੰਨਾਂ ਦਾ ਇੱਕ ਸੈੱਟ ਹੈ। ਪਹਿਲੇ ਸੈੱਟ ਵਿੱਚ ਮੋਡੀਊਲ ਨੂੰ ਪਾਵਰ ਅੱਪ ਕਰਨ ਲਈ VCC ਅਤੇ GND, ਅਤੇ ਕ੍ਰਮਵਾਰ ਹੇਠਲੇ ਅਤੇ ਉੱਪਰਲੇ ਰੀਲੇਅ ਨੂੰ ਕੰਟਰੋਲ ਕਰਨ ਲਈ ਇਨਪੁਟ 1 (IN1) ਅਤੇ ਇਨਪੁਟ 2 (IN2) ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ।
ਜੇਕਰ ਤੁਹਾਡੇ ਰੀਲੇਅ ਮੋਡੀਊਲ ਵਿੱਚ ਸਿਰਫ਼ ਇੱਕ ਚੈਨਲ ਹੈ, ਤਾਂ ਤੁਹਾਡੇ ਕੋਲ ਸਿਰਫ਼ ਇੱਕ IN ਪਿੰਨ ਹੋਵੇਗਾ। ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਚਾਰ ਚੈਨਲ ਹਨ, ਤਾਂ ਤੁਹਾਡੇ ਕੋਲ ਚਾਰ IN ਪਿੰਨ ਹੋਣਗੇ, ਅਤੇ ਹੋਰ ਵੀ।
ਸਿਗਨਲ ਜੋ ਤੁਸੀਂ IN ਪਿੰਨ ਨੂੰ ਭੇਜਦੇ ਹੋ, ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਰੀਲੇਅ ਕਿਰਿਆਸ਼ੀਲ ਹੈ ਜਾਂ ਨਹੀਂ। ਜਦੋਂ ਇਨਪੁਟ ਲਗਭਗ 2V ਤੋਂ ਹੇਠਾਂ ਜਾਂਦਾ ਹੈ ਤਾਂ ਰੀਲੇਅ ਸ਼ੁਰੂ ਹੋ ਜਾਂਦੀ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਹੇਠਾਂ ਦਿੱਤੇ ਦ੍ਰਿਸ਼ ਹੋਣਗੇ:

• ਆਮ ਤੌਰ 'ਤੇ ਬੰਦ ਸੰਰਚਨਾ (NC):
• ਉੱਚ ਸਿਗਨਲ - ਕਰੰਟ ਵਗ ਰਿਹਾ ਹੈ
• ਘੱਟ ਸਿਗਨਲ - ਕਰੰਟ ਵਗ ਨਹੀਂ ਰਿਹਾ ਹੈ
• ਆਮ ਤੌਰ 'ਤੇ ਓਪਨ ਕੌਂਫਿਗਰੇਸ਼ਨ (NO):
• ਉੱਚ ਸਿਗਨਲ - ਕਰੰਟ ਵਗ ਨਹੀਂ ਰਿਹਾ ਹੈ
• ਘੱਟ ਸਿਗਨਲ - ਵਹਾਅ ਵਿੱਚ ਕਰੰਟ

ਤੁਹਾਨੂੰ ਇੱਕ ਆਮ ਤੌਰ 'ਤੇ ਬੰਦ ਸੰਰਚਨਾ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਜਦੋਂ ਕਰੰਟ ਜ਼ਿਆਦਾਤਰ ਵਾਰ ਵਗਦਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਕਦੇ-ਕਦਾਈਂ ਰੋਕਣਾ ਚਾਹੁੰਦੇ ਹੋ।
ਇੱਕ ਆਮ ਤੌਰ 'ਤੇ ਖੁੱਲ੍ਹੀ ਸੰਰਚਨਾ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਦੋਂ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਕਰੰਟ ਕਦੇ-ਕਦਾਈਂ ਵਹਿੰਦਾ ਹੋਵੇ (ਉਦਾਹਰਨ ਲਈample, al ਚਾਲੂ ਕਰੋamp ਕਦੇ ਕਦੇ).
ਪਾਵਰ ਸਪਲਾਈ ਦੀ ਚੋਣਪਿੰਨ ਦੇ ਦੂਜੇ ਸੈੱਟ ਵਿੱਚ GND, VCC, ਅਤੇ JD-VCC ਪਿੰਨ ਹੁੰਦੇ ਹਨ।
JD-VCC ਪਿੰਨ ਰੀਲੇਅ ਦੇ ਇਲੈਕਟ੍ਰੋਮੈਗਨੇਟ ਨੂੰ ਸ਼ਕਤੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਧਿਆਨ ਦਿਓ ਕਿ ਮੋਡੀਊਲ ਵਿੱਚ ਇੱਕ ਜੰਪਰ ਕੈਪ ਹੈ ਜੋ VCC ਅਤੇ JD-VCC ਪਿੰਨਾਂ ਨੂੰ ਜੋੜਦਾ ਹੈ; ਇੱਥੇ ਦਿਖਾਇਆ ਗਿਆ ਇੱਕ ਪੀਲਾ ਹੈ, ਪਰ ਤੁਹਾਡਾ ਇੱਕ ਵੱਖਰਾ ਰੰਗ ਹੋ ਸਕਦਾ ਹੈ।
ਜੰਪਰ ਕੈਪ ਚਾਲੂ ਹੋਣ ਨਾਲ, VCC ਅਤੇ JD-VCC ਪਿੰਨ ਜੁੜੇ ਹੋਏ ਹਨ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਰੀਲੇਅ ਇਲੈਕਟ੍ਰੋਮੈਗਨੇਟ ਸਿੱਧੇ ESP32 ਪਾਵਰ ਪਿੰਨ ਤੋਂ ਸੰਚਾਲਿਤ ਹੁੰਦਾ ਹੈ, ਇਸਲਈ ਰੀਲੇਅ ਮੋਡੀਊਲ ਅਤੇ ESP32 ਸਰਕਟ ਇੱਕ ਦੂਜੇ ਤੋਂ ਭੌਤਿਕ ਤੌਰ 'ਤੇ ਅਲੱਗ ਨਹੀਂ ਹੁੰਦੇ ਹਨ।
ਜੰਪਰ ਕੈਪ ਤੋਂ ਬਿਨਾਂ, ਤੁਹਾਨੂੰ JD-VCC ਪਿੰਨ ਦੁਆਰਾ ਰੀਲੇਅ ਦੇ ਇਲੈਕਟ੍ਰੋਮੈਗਨੇਟ ਨੂੰ ਪਾਵਰ ਕਰਨ ਲਈ ਇੱਕ ਸੁਤੰਤਰ ਪਾਵਰ ਸਰੋਤ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਉਹ ਸੰਰਚਨਾ ਮਾਡਿਊਲ ਦੇ ਬਿਲਟ-ਇਨ ਔਪਟੋਕਪਲਰ ਨਾਲ ESP32 ਤੋਂ ਰੀਲੇਅ ਨੂੰ ਭੌਤਿਕ ਤੌਰ 'ਤੇ ਅਲੱਗ ਕਰਦੀ ਹੈ, ਜੋ ਇਲੈਕਟ੍ਰੀਕਲ ਸਪਾਈਕਸ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ESP32 ਨੂੰ ਨੁਕਸਾਨ ਤੋਂ ਰੋਕਦੀ ਹੈ।
ਯੋਜਨਾਬੱਧਚੇਤਾਵਨੀ: ਉੱਚ ਵੋਲਯੂਮ ਦੀ ਵਰਤੋਂtage ਪਾਵਰ ਸਪਲਾਈ ਗੰਭੀਰ ਸੱਟ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੀ ਹੈ।
ਇਸ ਲਈ, ਉੱਚ ਸਪਲਾਈ ਵਾਲੀ ਵੋਲਯੂਮ ਦੀ ਬਜਾਏ 5mm LEDs ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈtagਪ੍ਰਯੋਗ ਵਿੱਚ ਈ ਬਲਬ. ਜੇਕਰ ਤੁਸੀਂ ਮੁੱਖ ਵੋਲਯੂਮ ਤੋਂ ਜਾਣੂ ਨਹੀਂ ਹੋtage ਕਿਸੇ ਅਜਿਹੇ ਵਿਅਕਤੀ ਨੂੰ ਪੁੱਛੋ ਜੋ ਤੁਹਾਡੀ ਮਦਦ ਕਰਨ ਲਈ ਹੈ। ESP ਪ੍ਰੋਗਰਾਮਿੰਗ ਕਰਦੇ ਸਮੇਂ ਜਾਂ ਆਪਣੇ ਸਰਕਟ ਨੂੰ ਵਾਇਰਿੰਗ ਕਰਦੇ ਸਮੇਂ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਸਭ ਕੁਝ ਮੇਨ ਵੋਲਯੂਮ ਤੋਂ ਡਿਸਕਨੈਕਟ ਕੀਤਾ ਗਿਆ ਹੈtage.ESP32 ਲਈ ਲਾਇਬ੍ਰੇਰੀ ਇੰਸਟਾਲ ਕਰਨਾ
ਇਸ ਨੂੰ ਬਣਾਉਣ ਲਈ web ਸਰਵਰ, ਅਸੀਂ ESPAsync ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ ਅਤੇ AsyncTCP ਲਾਇਬ੍ਰੇਰੀ।
ESPAsync ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ
ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਅਗਲੇ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ ESPAsyncWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ:

1. ESPAsync ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਇੱਥੇ ਕਲਿੱਕ ਕਰੋWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ. ਤੁਹਾਨੂੰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
   ਤੁਹਾਡੇ ਡਾਊਨਲੋਡ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ .zip ਫੋਲਡਰ
2. .zip ਫੋਲਡਰ ਨੂੰ ਅਨਜ਼ਿਪ ਕਰੋ ਅਤੇ ਤੁਹਾਨੂੰ ESPAsync ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈWebਸਰਵਰ-ਮਾਸਟਰ ਫੋਲਡਰ
3. ESPAsync ਤੋਂ ਆਪਣੇ ਫੋਲਡਰ ਦਾ ਨਾਮ ਬਦਲੋWebESPAsync ਲਈ ਸਰਵਰ-ਮਾਸਟਰWebਸਰਵਰ
4. ESPAsync ਨੂੰ ਮੂਵ ਕਰੋWebਤੁਹਾਡੇ Arduino IDE ਇੰਸਟਾਲੇਸ਼ਨ ਲਾਇਬ੍ਰੇਰੀ ਫੋਲਡਰ ਵਿੱਚ ਸਰਵਰ ਫੋਲਡਰ

ਵਿਕਲਪਕ ਤੌਰ 'ਤੇ, ਤੁਹਾਡੇ Arduino IDE ਵਿੱਚ, ਤੁਸੀਂ Sketch > Include 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ
ਲਾਇਬ੍ਰੇਰੀ > .ZIP ਲਾਇਬ੍ਰੇਰੀ ਸ਼ਾਮਲ ਕਰੋ… ਅਤੇ ਉਹ ਲਾਇਬ੍ਰੇਰੀ ਚੁਣੋ ਜੋ ਤੁਸੀਂ ਹੁਣੇ ਡਾਊਨਲੋਡ ਕੀਤੀ ਹੈ।
ESP32 ਲਈ AsyncTCP ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਇੰਸਟਾਲ ਕਰਨਾ
ਦ ESPAsyncWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਲੋੜ ਹੈ AsyncTCP ਕੰਮ ਕਰਨ ਲਈ ਲਾਇਬ੍ਰੇਰੀ. ਦਾ ਪਾਲਣ ਕਰੋ
ਉਸ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਅਗਲੇ ਕਦਮ:

1. AsyncTCP ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਇੱਥੇ ਕਲਿੱਕ ਕਰੋ। ਤੁਹਾਡੇ ਕੋਲ ਤੁਹਾਡੇ ਡਾਊਨਲੋਡ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ .zip ਫੋਲਡਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
2. .zip ਫੋਲਡਰ ਨੂੰ ਅਨਜ਼ਿਪ ਕਰੋ ਅਤੇ ਤੁਹਾਨੂੰ AsyncTCP-master ਫੋਲਡਰ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ
   1. ਆਪਣੇ ਫੋਲਡਰ ਦਾ ਨਾਮ AsyncTCP-master ਤੋਂ AsyncTCP ਵਿੱਚ ਬਦਲੋ
   3. AsyncTCP ਫੋਲਡਰ ਨੂੰ ਆਪਣੇ Arduino IDE ਇੰਸਟਾਲੇਸ਼ਨ ਲਾਇਬ੍ਰੇਰੀ ਫੋਲਡਰ ਵਿੱਚ ਭੇਜੋ
   4. ਅੰਤ ਵਿੱਚ, ਆਪਣਾ Arduino IDE ਮੁੜ-ਖੋਲੋ

ਵਿਕਲਪਕ ਤੌਰ 'ਤੇ, ਤੁਹਾਡੇ Arduino IDE ਵਿੱਚ, ਤੁਸੀਂ Sketch > Include 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ
ਲਾਇਬ੍ਰੇਰੀ > .ZIP ਲਾਇਬ੍ਰੇਰੀ ਸ਼ਾਮਲ ਕਰੋ… ਅਤੇ ਉਹ ਲਾਇਬ੍ਰੇਰੀ ਚੁਣੋ ਜੋ ਤੁਸੀਂ ਹੁਣੇ ਡਾਊਨਲੋਡ ਕੀਤੀ ਹੈ।
ਕੋਡ
ਅਸੀਂ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ESP32 ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਕਰਾਂਗੇ, ਇਸ ਲਈ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ESP32 ਐਡ-ਆਨ ਸਥਾਪਤ ਹੈ: (ਜੇ ਤੁਸੀਂ ਇਹ ਕਦਮ ਪਹਿਲਾਂ ਹੀ ਕਰ ਚੁੱਕੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਅਗਲੇ ਪੜਾਅ 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ।)
Arduino IDE ਵਿੱਚ ESP32 ਐਡ-ਆਨ ਇੰਸਟਾਲ ਕਰਨਾ
ਲੋੜੀਂਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਪ੍ਰੋਜੈਕਟ_7_ESP32_Relay_ ਕੋਡ ਖੋਲ੍ਹੋWebarduino IDE ਵਿੱਚ _Server.ino।
ਕੋਡ ਅੱਪਲੋਡ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਆਪਣੇ ਨੈੱਟਵਰਕ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ ਨਾ ਭੁੱਲੋ ਤਾਂ ਜੋ ESP ਤੁਹਾਡੇ ਸਥਾਨਕ ਨੈੱਟਵਰਕ ਨਾਲ ਜੁੜ ਸਕੇ।ਪ੍ਰਦਰਸ਼ਨ
ਲੋੜੀਂਦੀਆਂ ਤਬਦੀਲੀਆਂ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਕੋਡ ਨੂੰ ਆਪਣੇ ESP32 ਵਿੱਚ ਅੱਪਲੋਡ ਕਰੋ। ਕੋਡ ਸੰਦਰਭ ਪੜਾਅ ਅੱਪਲੋਡ ਕਰੋ।
ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਨੂੰ 115200 ਦੀ ਬੌਡ ਦਰ 'ਤੇ ਖੋਲ੍ਹੋ ਅਤੇ ਇਸਦਾ IP ਪਤਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ESP32 EN ਬਟਨ ਦਬਾਓ। ਫਿਰ, ਆਪਣੇ ਸਥਾਨਕ ਨੈਟਵਰਕ ਵਿੱਚ ਇੱਕ ਬ੍ਰਾਊਜ਼ਰ ਖੋਲ੍ਹੋ ਅਤੇ ਇਸ ਤੱਕ ਪਹੁੰਚ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ESP32 IP ਐਡਰੈੱਸ ਟਾਈਪ ਕਰੋ। web ਸਰਵਰ
ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਨੂੰ 115200 ਦੀ ਬੌਡ ਦਰ 'ਤੇ ਖੋਲ੍ਹੋ ਅਤੇ ਇਸਦਾ IP ਪਤਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ESP32 EN ਬਟਨ ਦਬਾਓ। ਫਿਰ, ਆਪਣੇ ਸਥਾਨਕ ਨੈਟਵਰਕ ਵਿੱਚ ਇੱਕ ਬ੍ਰਾਊਜ਼ਰ ਖੋਲ੍ਹੋ ਅਤੇ ਇਸ ਤੱਕ ਪਹੁੰਚ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ESP32 IP ਐਡਰੈੱਸ ਟਾਈਪ ਕਰੋ। web ਸਰਵਰਨੋਟ: ਤੁਹਾਡਾ ਬ੍ਰਾਊਜ਼ਰ ਅਤੇ ESP32 ਇੱਕੋ LAN ਨਾਲ ਕਨੈਕਟ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ।
ਤੁਹਾਨੂੰ ਆਪਣੇ ਕੋਡ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਰੀਲੇਅ ਦੀ ਸੰਖਿਆ ਦੇ ਰੂਪ ਵਿੱਚ ਦੋ ਬਟਨਾਂ ਦੇ ਨਾਲ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਕੁਝ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।ਹੁਣ, ਤੁਸੀਂ ਆਪਣੇ ਸਮਾਰਟਫੋਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੇ ਰੀਲੇਅ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਬਟਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।

ਪ੍ਰੋਜੈਕਟ_8_ਆਉਟਪੁੱਟ_ਸਟੇਟ_ਸਿੰਕਰੋਨਾਈਜ਼ੇਸ਼ਨ_ Web_ਸਰਵਰ

ਇਹ ਪ੍ਰੋਜੈਕਟ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਕਿਵੇਂ ESP32 ਜਾਂ ESP8266 ਆਉਟਪੁੱਟ ਨੂੰ ਏ web ਸਰਵਰ ਅਤੇ ਇੱਕ ਭੌਤਿਕ ਬਟਨ ਇੱਕੋ ਸਮੇਂ। ਆਉਟਪੁੱਟ ਸਥਿਤੀ 'ਤੇ ਅੱਪਡੇਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ web ਪੰਨਾ ਭਾਵੇਂ ਇਹ ਭੌਤਿਕ ਬਟਨ ਰਾਹੀਂ ਬਦਲਿਆ ਗਿਆ ਹੋਵੇ ਜਾਂ web ਸਰਵਰ
ਪ੍ਰੋਜੈਕਟ ਸਮਾਪਤview
ਆਉ ਇਸ 'ਤੇ ਇੱਕ ਝਾਤ ਮਾਰੀਏ ਕਿ ਪ੍ਰੋਜੈਕਟ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।ESP32 ਜਾਂ ESP8266 ਇੱਕ ਹੋਸਟ ਕਰਦਾ ਹੈ web ਸਰਵਰ ਜੋ ਤੁਹਾਨੂੰ ਆਉਟਪੁੱਟ ਦੀ ਸਥਿਤੀ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ;

• ਮੌਜੂਦਾ ਆਉਟਪੁੱਟ ਸਥਿਤੀ 'ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਹੁੰਦੀ ਹੈ web ਸਰਵਰ;
• ESP ਇੱਕ ਭੌਤਿਕ ਪੁਸ਼ਬਟਨ ਨਾਲ ਵੀ ਜੁੜਿਆ ਹੋਇਆ ਹੈ ਜੋ ਉਸੇ ਆਉਟਪੁੱਟ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ;
• ਜੇਕਰ ਤੁਸੀਂ ਭੌਤਿਕ puhsbutton ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਉਟਪੁੱਟ ਸਥਿਤੀ ਨੂੰ ਬਦਲਦੇ ਹੋ, ਤਾਂ ਇਸਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਵੀ ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ web ਸਰਵਰ

ਸੰਖੇਪ ਵਿੱਚ, ਇਹ ਪ੍ਰੋਜੈਕਟ ਤੁਹਾਨੂੰ ਇੱਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਸੇ ਆਉਟਪੁੱਟ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ web ਸਰਵਰ ਅਤੇ ਇੱਕ ਪੁਸ਼ ਬਟਨ ਇੱਕੋ ਸਮੇਂ। ਜਦੋਂ ਵੀ ਆਉਟਪੁੱਟ ਸਥਿਤੀ ਬਦਲਦੀ ਹੈ, web ਸਰਵਰ ਅੱਪਡੇਟ ਕੀਤਾ ਗਿਆ ਹੈ।
ਪੁਰਜ਼ਿਆਂ ਦੀ ਲੋੜ ਹੈ
ਸਰਕਟ ਬਣਾਉਣ ਲਈ ਤੁਹਾਨੂੰ ਲੋੜੀਂਦੇ ਹਿੱਸਿਆਂ ਦੀ ਸੂਚੀ ਇੱਥੇ ਦਿੱਤੀ ਗਈ ਹੈ:

• ESP32 DEVKIT V1 ਬੋਰਡ
• 5 ਮਿਲੀਮੀਟਰ LED
• 220Ohm ਰੋਧਕ
• ਪੁਸ਼ ਬਟਨ
• 10k Ohm ਰੋਧਕ
• ਰੋਟੀ ਦਾ ਬੋਰਡ
• ਜੰਪਰ ਤਾਰਾਂ

ਯੋਜਨਾਬੱਧESP32 ਲਈ ਲਾਇਬ੍ਰੇਰੀ ਇੰਸਟਾਲ ਕਰਨਾ
ਇਸ ਨੂੰ ਬਣਾਉਣ ਲਈ web ਸਰਵਰ, ਅਸੀਂ ESPAsync ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ ਅਤੇ AsyncTCP ਲਾਇਬ੍ਰੇਰੀ।
ESPAsync ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ
ESPAsync ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਅਗਲੇ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ:

1. ESPAsync ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਇੱਥੇ ਕਲਿੱਕ ਕਰੋWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ. ਤੁਹਾਨੂੰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
   ਤੁਹਾਡੇ ਡਾਊਨਲੋਡ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ .zip ਫੋਲਡਰ
2. .zip ਫੋਲਡਰ ਨੂੰ ਅਨਜ਼ਿਪ ਕਰੋ ਅਤੇ ਤੁਹਾਨੂੰ ESPAsync ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈWebਸਰਵਰ-ਮਾਸਟਰ ਫੋਲਡਰ
3. ESPAsync ਤੋਂ ਆਪਣੇ ਫੋਲਡਰ ਦਾ ਨਾਮ ਬਦਲੋWebESPAsync ਲਈ ਸਰਵਰ-ਮਾਸਟਰWebਸਰਵਰ
4. ESPAsync ਨੂੰ ਮੂਵ ਕਰੋWebਤੁਹਾਡੇ Arduino IDE ਇੰਸਟਾਲੇਸ਼ਨ ਲਾਇਬ੍ਰੇਰੀ ਫੋਲਡਰ ਵਿੱਚ ਸਰਵਰ ਫੋਲਡਰ
   ਵਿਕਲਪਕ ਤੌਰ 'ਤੇ, ਤੁਹਾਡੇ Arduino IDE ਵਿੱਚ, ਤੁਸੀਂ Sketch > Include 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ
   ਲਾਇਬ੍ਰੇਰੀ > .ZIP ਲਾਇਬ੍ਰੇਰੀ ਸ਼ਾਮਲ ਕਰੋ… ਅਤੇ ਉਹ ਲਾਇਬ੍ਰੇਰੀ ਚੁਣੋ ਜੋ ਤੁਸੀਂ ਹੁਣੇ ਡਾਊਨਲੋਡ ਕੀਤੀ ਹੈ।

ESP32 ਲਈ AsyncTCP ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਇੰਸਟਾਲ ਕਰਨਾ
ESPAsyncWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਕੰਮ ਕਰਨ ਲਈ AsyncTCP ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਉਸ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਅਗਲੇ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ:

1. AsyncTCP ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਇੱਥੇ ਕਲਿੱਕ ਕਰੋ। ਤੁਹਾਡੇ ਕੋਲ ਤੁਹਾਡੇ ਡਾਊਨਲੋਡ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ .zip ਫੋਲਡਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
2. .zip ਫੋਲਡਰ ਨੂੰ ਅਨਜ਼ਿਪ ਕਰੋ ਅਤੇ ਤੁਹਾਨੂੰ AsyncTCP-master ਫੋਲਡਰ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ
3. ਆਪਣੇ ਫੋਲਡਰ ਦਾ ਨਾਮ AsyncTCP-master ਤੋਂ AsyncTCP ਵਿੱਚ ਬਦਲੋ
4. AsyncTCP ਫੋਲਡਰ ਨੂੰ ਆਪਣੇ Arduino IDE ਇੰਸਟਾਲੇਸ਼ਨ ਲਾਇਬ੍ਰੇਰੀ ਫੋਲਡਰ ਵਿੱਚ ਭੇਜੋ
5. ਅੰਤ ਵਿੱਚ, ਆਪਣੇ Arduino IDE ਨੂੰ ਮੁੜ-ਖੋਲੋ
   ਵਿਕਲਪਕ ਤੌਰ 'ਤੇ, ਤੁਹਾਡੇ Arduino IDE ਵਿੱਚ, ਤੁਸੀਂ Sketch > Include 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ
   ਲਾਇਬ੍ਰੇਰੀ > .ZIP ਲਾਇਬ੍ਰੇਰੀ ਸ਼ਾਮਲ ਕਰੋ… ਅਤੇ ਉਹ ਲਾਇਬ੍ਰੇਰੀ ਚੁਣੋ ਜੋ ਤੁਸੀਂ ਹੁਣੇ ਡਾਊਨਲੋਡ ਕੀਤੀ ਹੈ।

ਕੋਡ
ਅਸੀਂ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ESP32 ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਕਰਾਂਗੇ, ਇਸ ਲਈ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ESP32 ਐਡ-ਆਨ ਸਥਾਪਤ ਹੈ: (ਜੇ ਤੁਸੀਂ ਇਹ ਕਦਮ ਪਹਿਲਾਂ ਹੀ ਕਰ ਚੁੱਕੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਅਗਲੇ ਪੜਾਅ 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ।)
Arduino IDE ਵਿੱਚ ESP32 ਐਡ-ਆਨ ਇੰਸਟਾਲ ਕਰਨਾ
ਲੋੜੀਂਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਕੋਡ ਖੋਲ੍ਹੋ
ਪ੍ਰੋਜੈਕਟ_8_ਆਉਟਪੁੱਟ_ਸਟੇਟ_ਸਿੰਕਰੋਨਾਈਜ਼ੇਸ਼ਨ_Webarduino IDE ਵਿੱਚ _Server.ino।
ਕੋਡ ਅੱਪਲੋਡ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਆਪਣੇ ਨੈੱਟਵਰਕ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ ਨਾ ਭੁੱਲੋ ਤਾਂ ਜੋ ESP ਤੁਹਾਡੇ ਸਥਾਨਕ ਨੈੱਟਵਰਕ ਨਾਲ ਜੁੜ ਸਕੇ।

ਕੋਡ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ

ਬਟਨ ਸਟੇਟ ਅਤੇ ਆਉਟਪੁੱਟ ਸਟੇਟ
ledState ਵੇਰੀਏਬਲ LED ਆਉਟਪੁੱਟ ਸਥਿਤੀ ਰੱਖਦਾ ਹੈ। ਡਿਫੌਲਟ ਲਈ, ਜਦੋਂ web ਸਰਵਰ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ, ਇਹ ਘੱਟ ਹੈ।

ButtonState ਅਤੇ lastButtonState ਦੀ ਵਰਤੋਂ ਇਹ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਕੀ ਪੁਸ਼ਬਟਨ ਦਬਾਇਆ ਗਿਆ ਸੀ ਜਾਂ ਨਹੀਂ।ਬਟਨ (web ਸਰਵਰ)
ਅਸੀਂ index_html ਵੇਰੀਏਬਲ 'ਤੇ ਬਟਨ ਬਣਾਉਣ ਲਈ HTML ਨੂੰ ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤਾ ਹੈ।
ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ ਅਸੀਂ ਮੌਜੂਦਾ LED ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਤੇ ਇਸਨੂੰ ਬਦਲਣ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੁੰਦੇ ਹਾਂ ਜੋ ਪੁਸ਼ਬਟਨ ਨਾਲ ਵੀ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ।
ਇਸ ਲਈ, ਅਸੀਂ ਬਟਨ %BUTTONPLACEHOLDER% ਲਈ ਇੱਕ ਪਲੇਸਹੋਲਡਰ ਬਣਾਇਆ ਹੈ ਜੋ ਬਾਅਦ ਵਿੱਚ ਕੋਡ 'ਤੇ ਬਟਨ ਬਣਾਉਣ ਲਈ HTML ਟੈਕਸਟ ਨਾਲ ਬਦਲਿਆ ਜਾਵੇਗਾ (ਇਹ ਪ੍ਰੋਸੈਸਰ() ਫੰਕਸ਼ਨ ਵਿੱਚ ਕੀਤਾ ਜਾਂਦਾ ਹੈ)।ਪ੍ਰੋਸੈਸਰ()
ਪ੍ਰੋਸੈਸਰ() ਫੰਕਸ਼ਨ HTML ਟੈਕਸਟ 'ਤੇ ਕਿਸੇ ਵੀ ਪਲੇਸਹੋਲਡਰ ਨੂੰ ਅਸਲ ਮੁੱਲਾਂ ਨਾਲ ਬਦਲਦਾ ਹੈ। ਪਹਿਲਾਂ, ਇਹ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ HTML ਟੈਕਸਟ ਵਿੱਚ ਕੋਈ ਸ਼ਾਮਲ ਹੈ
ਪਲੇਸਹੋਲਡਰ %BUTTONPLACEHOLDER%।ਫਿਰ, theoutputState() ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰੋ ਜੋ ਮੌਜੂਦਾ ਆਉਟਪੁੱਟ ਸਥਿਤੀ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਅਸੀਂ ਇਸਨੂੰ outputStateValue ਵੇਰੀਏਬਲ ਵਿੱਚ ਸੇਵ ਕਰਦੇ ਹਾਂ।ਉਸ ਤੋਂ ਬਾਅਦ, ਸਹੀ ਸਥਿਤੀ ਦੇ ਨਾਲ ਬਟਨ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ HTML ਟੈਕਸਟ ਬਣਾਉਣ ਲਈ ਉਸ ਮੁੱਲ ਦੀ ਵਰਤੋਂ ਕਰੋ:ਆਉਟਪੁੱਟ ਸਥਿਤੀ (ਜਾਵਾ ਸਕ੍ਰਿਪਟ) ਨੂੰ ਬਦਲਣ ਲਈ HTTP GET ਬੇਨਤੀ
ਜਦੋਂ ਤੁਸੀਂ ਬਟਨ ਦਬਾਉਂਦੇ ਹੋ, ਤਾਂ toggleCheckbox() ਫੰਕਸ਼ਨ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਫੰਕਸ਼ਨ ਵੱਖ-ਵੱਖ 'ਤੇ ਇੱਕ ਬੇਨਤੀ ਕਰੇਗਾ URLLED ਨੂੰ ਚਾਲੂ ਜਾਂ ਬੰਦ ਕਰਨ ਲਈ s.LED ਨੂੰ ਚਾਲੂ ਕਰਨ ਲਈ, ਇਹ /update?state=1 'ਤੇ ਬੇਨਤੀ ਕਰਦਾ ਹੈ URL:ਨਹੀਂ ਤਾਂ, ਇਹ /update?state=0 'ਤੇ ਬੇਨਤੀ ਕਰਦਾ ਹੈ URL.
HTTP ਸਟੇਟ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਕਰੋ (ਜਾਵਾ ਸਕ੍ਰਿਪਟ)
'ਤੇ ਆਉਟਪੁੱਟ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਰੱਖਣ ਲਈ web ਸਰਵਰ, ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦੇ ਹਾਂ ਜੋ /ਸਟੇਟ 'ਤੇ ਨਵੀਂ ਬੇਨਤੀ ਕਰਦਾ ਹੈ URL ਹਰ ਸਕਿੰਟਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲੋ
ਫਿਰ, ਸਾਨੂੰ ਇਹ ਸੰਭਾਲਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਜਦੋਂ ESP32 ਜਾਂ ESP8266 ਉਹਨਾਂ 'ਤੇ ਬੇਨਤੀਆਂ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ URLs.
ਜਦੋਂ ਰੂਟ 'ਤੇ ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ /URL, ਅਸੀਂ ਪ੍ਰੋਸੈਸਰ ਦੇ ਨਾਲ-ਨਾਲ HTML ਪੇਜ ਭੇਜਦੇ ਹਾਂ।ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਲਾਈਨਾਂ ਇਹ ਜਾਂਚ ਕਰਦੀਆਂ ਹਨ ਕਿ ਕੀ ਤੁਹਾਨੂੰ /update?state=1 ਜਾਂ /update?state=0 'ਤੇ ਕੋਈ ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਹੋਈ ਹੈ। URL ਅਤੇ ਉਸ ਅਨੁਸਾਰ ledState ਨੂੰ ਬਦਲਦਾ ਹੈ।ਜਦੋਂ /ਸਟੇਟ 'ਤੇ ਕੋਈ ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ URL, ਅਸੀਂ ਮੌਜੂਦਾ ਆਉਟਪੁੱਟ ਸਥਿਤੀ ਭੇਜਦੇ ਹਾਂ:ਲੂਪ()
ਲੂਪ() ਵਿੱਚ, ਅਸੀਂ ਪੁਸ਼ਬਟਨ ਨੂੰ ਡੀਬਾਊਂਸ ਕਰਦੇ ਹਾਂ ਅਤੇ ledState ਦੇ ਮੁੱਲ ਦੇ ਅਧਾਰ ਤੇ LED ਨੂੰ ਚਾਲੂ ਜਾਂ ਬੰਦ ਕਰਦੇ ਹਾਂ। ਵੇਰੀਏਬਲਪ੍ਰਦਰਸ਼ਨ
ਕੋਡ ਨੂੰ ਆਪਣੇ ESP32 ਬੋਰਡ 'ਤੇ ਅੱਪਲੋਡ ਕਰੋ। ਕੋਡ ਸੰਦਰਭ ਪੜਾਅ ਅੱਪਲੋਡ ਕਰੋ।
ਫਿਰ, 115200 ਦੀ ਬੌਡ ਦਰ 'ਤੇ ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਖੋਲ੍ਹੋ। IP ਐਡਰੈੱਸ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਆਨ-ਬੋਰਡ EN/RST ਬਟਨ ਨੂੰ ਦਬਾਓ।ਆਪਣੇ ਸਥਾਨਕ ਨੈੱਟਵਰਕ 'ਤੇ ਇੱਕ ਬ੍ਰਾਊਜ਼ਰ ਖੋਲ੍ਹੋ, ਅਤੇ ESP IP ਐਡਰੈੱਸ ਟਾਈਪ ਕਰੋ। ਤੁਹਾਨੂੰ ਤੱਕ ਪਹੁੰਚ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ web ਸਰਵਰ ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।
ਨੋਟ: ਤੁਹਾਡਾ ਬ੍ਰਾਊਜ਼ਰ ਅਤੇ ESP32 ਇੱਕੋ LAN ਨਾਲ ਕਨੈਕਟ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ।'ਤੇ ਬਟਨ ਨੂੰ ਟੌਗਲ ਕਰ ਸਕਦੇ ਹੋ web LED ਨੂੰ ਚਾਲੂ ਕਰਨ ਲਈ ਸਰਵਰ।ਤੁਸੀਂ ਭੌਤਿਕ ਪੁਸ਼ਬਟਨ ਨਾਲ ਉਸੇ LED ਨੂੰ ਵੀ ਨਿਯੰਤਰਿਤ ਕਰ ਸਕਦੇ ਹੋ। ਇਸਦੀ ਸਥਿਤੀ ਨੂੰ ਹਮੇਸ਼ਾ ਆਪਣੇ ਆਪ ਅਪਡੇਟ ਕੀਤਾ ਜਾਵੇਗਾ web ਸਰਵਰ

ਪ੍ਰੋਜੈਕਟ 9 ESP32 DHT11 Web ਸਰਵਰ

ਇਸ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ, ਤੁਸੀਂ ਸਿੱਖੋਗੇ ਕਿ ਇੱਕ ਅਸਿੰਕਰੋਨਸ ESP32 ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ web DHT11 ਵਾਲਾ ਸਰਵਰ ਜੋ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤਾਪਮਾਨ ਅਤੇ ਨਮੀ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ।
ਪੂਰਵ-ਸ਼ਰਤਾਂ
ਦ web ਸਰਵਰ ਨੂੰ ਰਿਫ੍ਰੈਸ਼ ਕਰਨ ਦੀ ਲੋੜ ਤੋਂ ਬਿਨਾਂ ਅਸੀਂ ਰੀਡਿੰਗਾਂ ਨੂੰ ਆਟੋਮੈਟਿਕਲੀ ਅਪਡੇਟ ਬਣਾਵਾਂਗੇ web ਪੰਨਾ
ਇਸ ਪ੍ਰੋਜੈਕਟ ਨਾਲ ਤੁਸੀਂ ਸਿੱਖੋਗੇ:

• DHT ਸੈਂਸਰਾਂ ਤੋਂ ਤਾਪਮਾਨ ਅਤੇ ਨਮੀ ਨੂੰ ਕਿਵੇਂ ਪੜ੍ਹਨਾ ਹੈ;
• ਇੱਕ ਅਸਿੰਕਰੋਨਸ ਬਣਾਓ web ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਰਵਰ ESPAsyncWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ;
• ਨੂੰ ਤਾਜ਼ਾ ਕਰਨ ਦੀ ਲੋੜ ਤੋਂ ਬਿਨਾਂ ਸੈਂਸਰ ਰੀਡਿੰਗਾਂ ਨੂੰ ਆਪਣੇ ਆਪ ਅੱਪਡੇਟ ਕਰੋ web ਪੰਨਾ

ਅਸਿੰਕ੍ਰੋਨਸ Web ਸਰਵਰ
ਬਣਾਉਣ ਲਈ web ਸਰਵਰ ਅਸੀਂ ਵਰਤਾਂਗੇ ESPAsyncWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ ਜੋ ਕਿ ਇੱਕ ਅਸਿੰਕਰੋਨਸ ਬਣਾਉਣ ਦਾ ਇੱਕ ਆਸਾਨ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ web ਸਰਵਰ ਇੱਕ ਅਸਿੰਕ੍ਰੋਨਸ ਬਣਾਉਣਾ web ਸਰਵਰ ਦੇ ਕਈ ਐਡਵਾਂ ਹਨtages ਜਿਵੇਂ ਕਿ ਲਾਇਬ੍ਰੇਰੀ GitHub ਪੰਨੇ ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਜਿਵੇਂ ਕਿ:

• "ਇੱਕੋ ਸਮੇਂ ਵਿੱਚ ਇੱਕ ਤੋਂ ਵੱਧ ਕੁਨੈਕਸ਼ਨ ਹੈਂਡਲ ਕਰੋ";
• "ਜਦੋਂ ਤੁਸੀਂ ਜਵਾਬ ਭੇਜਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਦੂਜੇ ਕਨੈਕਸ਼ਨਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਤੁਰੰਤ ਤਿਆਰ ਹੋ ਜਾਂਦੇ ਹੋ ਜਦੋਂ ਕਿ ਸਰਵਰ ਬੈਕਗ੍ਰਾਉਂਡ ਵਿੱਚ ਜਵਾਬ ਭੇਜਣ ਦੀ ਦੇਖਭਾਲ ਕਰ ਰਿਹਾ ਹੁੰਦਾ ਹੈ";
• "ਟੈਂਪਲੇਟਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਸਧਾਰਨ ਟੈਂਪਲੇਟ ਪ੍ਰੋਸੈਸਿੰਗ ਇੰਜਣ";

ਪੁਰਜ਼ਿਆਂ ਦੀ ਲੋੜ ਹੈ
ਇਸ ਟਿਊਟੋਰਿਅਲ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਭਾਗਾਂ ਦੀ ਲੋੜ ਹੈ:

• ESP32 ਵਿਕਾਸ ਬੋਰਡ
• DHT11 ਮੋਡੀਊਲ
• ਰੋਟੀ ਦਾ ਬੋਰਡ
• ਜੰਪਰ ਤਾਰਾਂ

ਯੋਜਨਾਬੱਧਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ
ਤੁਹਾਨੂੰ ਇਸ ਪ੍ਰੋਜੈਕਟ ਲਈ ਕੁਝ ਲਾਇਬ੍ਰੇਰੀਆਂ ਸਥਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

• ਦ ਡੀ.ਐਚ.ਟੀ ਅਤੇ ਐਡਫਰੂਟ ਯੂਨੀਫਾਈਡ ਸੈਂਸਰ DHT ਸੈਂਸਰ ਤੋਂ ਪੜ੍ਹਨ ਲਈ ਡਰਾਈਵਰ ਲਾਇਬ੍ਰੇਰੀਆਂ।
• ESPAsyncWebਸਰਵਰ ਅਤੇ Async TCP ਅਸਿੰਕਰੋਨਸ ਬਣਾਉਣ ਲਈ ਲਾਇਬ੍ਰੇਰੀਆਂ web ਸਰਵਰ
  ਉਹਨਾਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਅਗਲੀਆਂ ਹਦਾਇਤਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ:

DHT ਸੈਂਸਰ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ
Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ DHT ਸੈਂਸਰ ਤੋਂ ਪੜ੍ਹਨ ਲਈ, ਤੁਹਾਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ DHT ਸੈਂਸਰ ਲਾਇਬ੍ਰੇਰੀ. ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਅਗਲੇ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ।

1. DHT ਸੈਂਸਰ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਇੱਥੇ ਕਲਿੱਕ ਕਰੋ। ਤੁਹਾਡੇ ਕੋਲ ਤੁਹਾਡੇ ਡਾਊਨਲੋਡ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ .zip ਫੋਲਡਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
2. .zip ਫੋਲਡਰ ਨੂੰ ਅਨਜ਼ਿਪ ਕਰੋ ਅਤੇ ਤੁਹਾਨੂੰ DHT-sensor-library-master ਫੋਲਡਰ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ
3. ਆਪਣੇ ਫੋਲਡਰ ਦਾ ਨਾਮ DHT-sensor-library-master ਤੋਂ DHT_sensor ਵਿੱਚ ਬਦਲੋ
4. DHT_sensor ਫੋਲਡਰ ਨੂੰ ਆਪਣੇ Arduino IDE ਇੰਸਟਾਲੇਸ਼ਨ ਲਾਇਬ੍ਰੇਰੀ ਫੋਲਡਰ ਵਿੱਚ ਭੇਜੋ
5. ਅੰਤ ਵਿੱਚ, ਆਪਣੇ Arduino IDE ਨੂੰ ਮੁੜ-ਖੋਲੋ

ਐਡਫਰੂਟ ਯੂਨੀਫਾਈਡ ਸੈਂਸਰ ਡ੍ਰਾਈਵਰ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ
ਤੁਹਾਨੂੰ ਵੀ ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਐਡਫਰੂਟ ਯੂਨੀਫਾਈਡ ਸੈਂਸਰ ਡਰਾਈਵਰ ਲਾਇਬ੍ਰੇਰੀ DHT ਸੈਂਸਰ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ। ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਅਗਲੇ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ।

1. Adafruit ਯੂਨੀਫਾਈਡ ਸੈਂਸਰ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਇੱਥੇ ਕਲਿੱਕ ਕਰੋ। ਤੁਹਾਡੇ ਕੋਲ ਤੁਹਾਡੇ ਡਾਊਨਲੋਡ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ .zip ਫੋਲਡਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
2. .zip ਫੋਲਡਰ ਨੂੰ ਅਨਜ਼ਿਪ ਕਰੋ ਅਤੇ ਤੁਹਾਨੂੰ Adafruit_sensor-master ਫੋਲਡਰ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ
3. ਆਪਣੇ ਫੋਲਡਰ ਦਾ ਨਾਮ Adafruit_sensor-master ਤੋਂ Adafruit_sensor ਵਿੱਚ ਬਦਲੋ
4. Adafruit_sensor ਫੋਲਡਰ ਨੂੰ ਆਪਣੇ Arduino IDE ਇੰਸਟਾਲੇਸ਼ਨ ਲਾਇਬ੍ਰੇਰੀ ਫੋਲਡਰ ਵਿੱਚ ਲੈ ਜਾਓ
5. ਅੰਤ ਵਿੱਚ, ਆਪਣੇ Arduino IDE ਨੂੰ ਮੁੜ-ਖੋਲੋ

ESPAsync ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ

ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਅਗਲੇ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ ESPAsyncWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ:

1. ESPAsync ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਇੱਥੇ ਕਲਿੱਕ ਕਰੋWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ. ਤੁਹਾਨੂੰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
   ਤੁਹਾਡੇ ਡਾਊਨਲੋਡ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ .zip ਫੋਲਡਰ
2. .zip ਫੋਲਡਰ ਨੂੰ ਅਨਜ਼ਿਪ ਕਰੋ ਅਤੇ ਤੁਹਾਨੂੰ ਚਾਹੀਦਾ ਹੈ
   ESPAsync ਪ੍ਰਾਪਤ ਕਰੋWebਸਰਵਰ-ਮਾਸਟਰ ਫੋਲਡਰ
3. ESPAsync ਤੋਂ ਆਪਣੇ ਫੋਲਡਰ ਦਾ ਨਾਮ ਬਦਲੋWebESPAsync ਲਈ ਸਰਵਰ-ਮਾਸਟਰWebਸਰਵਰ
4. ESPAsync ਨੂੰ ਮੂਵ ਕਰੋWebਤੁਹਾਡੇ Arduino IDE ਇੰਸਟਾਲੇਸ਼ਨ ਲਾਇਬ੍ਰੇਰੀ ਫੋਲਡਰ ਵਿੱਚ ਸਰਵਰ ਫੋਲਡਰ

ESP32 ਲਈ Async TCP ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ
ਦ ESPAsyncWebਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਲੋੜ ਹੈ AsyncTCP ਕੰਮ ਕਰਨ ਲਈ ਲਾਇਬ੍ਰੇਰੀ. ਉਸ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਅਗਲੇ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ:

1. AsyncTCP ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਇੱਥੇ ਕਲਿੱਕ ਕਰੋ। ਤੁਹਾਡੇ ਕੋਲ ਤੁਹਾਡੇ ਡਾਊਨਲੋਡ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ .zip ਫੋਲਡਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
2. .zip ਫੋਲਡਰ ਨੂੰ ਅਨਜ਼ਿਪ ਕਰੋ ਅਤੇ ਤੁਹਾਨੂੰ AsyncTCP-master ਫੋਲਡਰ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ
3. ਆਪਣੇ ਫੋਲਡਰ ਦਾ ਨਾਮ AsyncTCP-master ਤੋਂ AsyncTCP ਵਿੱਚ ਬਦਲੋ
4. AsyncTCP ਫੋਲਡਰ ਨੂੰ ਆਪਣੇ Arduino IDE ਇੰਸਟਾਲੇਸ਼ਨ ਲਾਇਬ੍ਰੇਰੀ ਫੋਲਡਰ ਵਿੱਚ ਭੇਜੋ
5. ਅੰਤ ਵਿੱਚ, ਆਪਣੇ Arduino IDE ਨੂੰ ਮੁੜ-ਖੋਲੋ

ਕੋਡ
ਅਸੀਂ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ESP32 ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਕਰਾਂਗੇ, ਇਸ ਲਈ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ESP32 ਐਡ-ਆਨ ਸਥਾਪਤ ਹੈ: (ਜੇ ਤੁਸੀਂ ਇਹ ਕਦਮ ਪਹਿਲਾਂ ਹੀ ਕਰ ਚੁੱਕੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਅਗਲੇ ਪੜਾਅ 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ।)
Arduino IDE ਵਿੱਚ ESP32 ਐਡ-ਆਨ ਇੰਸਟਾਲ ਕਰਨਾ
ਲੋੜੀਂਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਕੋਡ ਖੋਲ੍ਹੋ
ਪ੍ਰੋਜੈਕਟ_9_ESP32_DHT11_Webarduino IDE ਵਿੱਚ _Server.ino।
ਕੋਡ ਅੱਪਲੋਡ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਆਪਣੇ ਨੈੱਟਵਰਕ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ ਨਾ ਭੁੱਲੋ ਤਾਂ ਜੋ ESP ਤੁਹਾਡੇ ਸਥਾਨਕ ਨੈੱਟਵਰਕ ਨਾਲ ਜੁੜ ਸਕੇ।ਕੋਡ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ
ਹੇਠਾਂ ਦਿੱਤੇ ਪੈਰਿਆਂ ਵਿੱਚ ਅਸੀਂ ਦੱਸਾਂਗੇ ਕਿ ਕੋਡ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਹੋਰ ਸਿੱਖਣਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਪੜ੍ਹਦੇ ਰਹੋ ਜਾਂ ਅੰਤਿਮ ਨਤੀਜਾ ਦੇਖਣ ਲਈ ਡੈਮੋਸਟ੍ਰੇਸ਼ਨ ਸੈਕਸ਼ਨ 'ਤੇ ਜਾਓ।
ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਆਯਾਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ
ਪਹਿਲਾਂ, ਲੋੜੀਂਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਆਯਾਤ ਕਰੋ। WiFi, ESPAsyncWebਨੂੰ ਬਣਾਉਣ ਲਈ ਸਰਵਰ ਅਤੇ ESPAsyncTCP ਦੀ ਲੋੜ ਹੈ web ਸਰਵਰ Adafruit_Sensor ਅਤੇ DHT ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ DHT11 ਜਾਂ DHT22 ਸੈਂਸਰਾਂ ਤੋਂ ਪੜ੍ਹਨ ਲਈ ਲੋੜੀਂਦਾ ਹੈ।ਵੇਰੀਏਬਲ ਪਰਿਭਾਸ਼ਾ
GPIO ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜਿਸ ਨਾਲ DHT ਡੇਟਾ ਪਿੰਨ ਜੁੜਿਆ ਹੋਇਆ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਇਹ GPIO 4 ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ।ਫਿਰ, DHT ਸੈਂਸਰ ਦੀ ਕਿਸਮ ਚੁਣੋ ਜੋ ਤੁਸੀਂ ਵਰਤ ਰਹੇ ਹੋ। ਸਾਡੇ ਸਾਬਕਾ ਵਿੱਚample, ਅਸੀਂ DHT22 ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ। ਜੇਕਰ ਤੁਸੀਂ ਕਿਸੇ ਹੋਰ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਆਪਣੇ ਸੈਂਸਰ 'ਤੇ ਟਿੱਪਣੀ ਕਰਨ ਅਤੇ ਬਾਕੀਆਂ 'ਤੇ ਟਿੱਪਣੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਇੱਕ DHT ਵਸਤੂ ਨੂੰ ਉਸ ਕਿਸਮ ਅਤੇ ਪਿੰਨ ਨਾਲ ਸਥਾਪਿਤ ਕਰੋ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ।ਇੱਕ ਅਸਿੰਕ ਬਣਾਓWebਪੋਰਟ 80 'ਤੇ ਸਰਵਰ ਆਬਜੈਕਟ।ਤਾਪਮਾਨ ਅਤੇ ਨਮੀ ਫੰਕਸ਼ਨ ਪੜ੍ਹੋ
ਅਸੀਂ ਦੋ ਫੰਕਸ਼ਨ ਬਣਾਏ ਹਨ: ਇੱਕ ਤਾਪਮਾਨ ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਅਸੀਂ ਦੋ ਫੰਕਸ਼ਨ ਬਣਾਏ ਹਨ: ਇੱਕ ਤਾਪਮਾਨ ਨੂੰ ਪੜ੍ਹਨਾ (readDHTTtemperature()) ਅਤੇ ਦੂਜਾ ਨਮੀ (readDHTHumidity()) ਨੂੰ ਪੜ੍ਹਨਾ।ਸੈਂਸਰ ਰੀਡਿੰਗ ਪ੍ਰਾਪਤ ਕਰਨਾ ਓਨਾ ਹੀ ਸਰਲ ਹੈ ਜਿੰਨਾ ਕਿ ਸੈਂਸਰ ਰੀਡਿੰਗ ਪ੍ਰਾਪਤ ਕਰਨਾ dht ਆਬਜੈਕਟ 'ਤੇ readTemperature() ਅਤੇ readHumidity() ਵਿਧੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਜਿੰਨਾ ਹੀ ਸਰਲ ਹੈ।ਸਾਡੇ ਕੋਲ ਇੱਕ ਸ਼ਰਤ ਵੀ ਹੈ ਜੋ ਸੈਂਸਰ ਰੀਡਿੰਗ ਪ੍ਰਾਪਤ ਕਰਨ ਵਿੱਚ ਅਸਫਲ ਹੋਣ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਦੋ ਡੈਸ਼ (-) ਵਾਪਸ ਕਰਦਾ ਹੈ।ਰੀਡਿੰਗਾਂ ਨੂੰ ਸਤਰ ਦੀ ਕਿਸਮ ਵਜੋਂ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਫਲੋਟ ਨੂੰ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲਣ ਲਈ, String() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋਮੂਲ ਰੂਪ ਵਿੱਚ, ਅਸੀਂ ਤਾਪਮਾਨ ਨੂੰ ਸੈਲਸੀਅਸ ਡਿਗਰੀ ਵਿੱਚ ਪੜ੍ਹ ਰਹੇ ਹਾਂ। ਫਾਰਨਹੀਟ ਡਿਗਰੀ ਵਿੱਚ ਤਾਪਮਾਨ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਸੈਲਸੀਅਸ ਵਿੱਚ ਤਾਪਮਾਨ ਨੂੰ ਟਿੱਪਣੀ ਕਰੋ ਅਤੇ ਫਾਰਨਹੀਟ ਵਿੱਚ ਤਾਪਮਾਨ ਨੂੰ ਅਣਕਮੇਂਟ ਕਰੋ, ਤਾਂ ਜੋ ਤੁਹਾਡੇ ਕੋਲ ਹੇਠ ਲਿਖੇ ਹਨ:ਕੋਡ ਅੱਪਲੋਡ ਕਰੋ
ਹੁਣ, ਆਪਣੇ ESP32 'ਤੇ ਕੋਡ ਅੱਪਲੋਡ ਕਰੋ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਸਹੀ ਬੋਰਡ ਅਤੇ COM ਪੋਰਟ ਚੁਣਿਆ ਗਿਆ ਹੈ। ਕੋਡ ਸੰਦਰਭ ਪੜਾਅ ਅੱਪਲੋਡ ਕਰੋ।
ਅੱਪਲੋਡ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਨੂੰ 115200 ਦੀ ਬਾਡ ਦਰ 'ਤੇ ਖੋਲ੍ਹੋ। ESP32 ਰੀਸੈਟ ਬਟਨ ਦਬਾਓ। ਸੀਰੀਅਲ ਵਿੱਚ ESP32 IP ਪਤਾ ਪ੍ਰਿੰਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਮਾਨੀਟਰ.ਪ੍ਰਦਰਸ਼ਨ
ਇੱਕ ਬ੍ਰਾਊਜ਼ਰ ਖੋਲ੍ਹੋ ਅਤੇ ESP32 IP ਐਡਰੈੱਸ ਟਾਈਪ ਕਰੋ। ਤੁਹਾਡਾ web ਸਰਵਰ ਨੂੰ ਨਵੀਨਤਮ ਸੈਂਸਰ ਰੀਡਿੰਗਾਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
ਨੋਟ: ਤੁਹਾਡਾ ਬ੍ਰਾਊਜ਼ਰ ਅਤੇ ESP32 ਇੱਕੋ LAN ਨਾਲ ਕਨੈਕਟ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ।
ਧਿਆਨ ਦਿਓ ਕਿ ਤਾਪਮਾਨ ਅਤੇ ਨਮੀ ਦੀਆਂ ਰੀਡਿੰਗਾਂ ਨੂੰ ਤਾਜ਼ਾ ਕਰਨ ਦੀ ਲੋੜ ਤੋਂ ਬਿਨਾਂ ਆਪਣੇ ਆਪ ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ web ਪੰਨਾ

ਪ੍ਰੋਜੈਕਟ_10_ESP32_OLED_ਡਿਸਪਲੇ

ਇਹ ਪ੍ਰੋਜੈਕਟ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ESP0.96 ਦੇ ਨਾਲ 1306 ਇੰਚ SSD32 OLED ਡਿਸਪਲੇ ਨੂੰ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ।
ਪੇਸ਼ ਹੈ 0.96 ਇੰਚ ਦੀ OLED ਡਿਸਪਲੇ
ਦ OLED ਡਿਸਪਲੇਅ ਜੋ ਅਸੀਂ ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਵਰਤਾਂਗੇ ਉਹ SSD1306 ਮਾਡਲ ਹੈ: ਇੱਕ ਮੋਨੋਕਲਰ, 0.96 ਇੰਚ ਡਿਸਪਲੇ 128×64 ਪਿਕਸਲ ਦੇ ਨਾਲ ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦਿੱਤੀ ਤਸਵੀਰ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।OLED ਡਿਸਪਲੇਅ ਨੂੰ ਬੈਕਲਾਈਟ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ ਹੈ, ਜਿਸਦਾ ਨਤੀਜਾ ਹਨੇਰੇ ਵਾਤਾਵਰਨ ਵਿੱਚ ਇੱਕ ਬਹੁਤ ਵਧੀਆ ਵਿਪਰੀਤ ਹੁੰਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਸਦੇ ਪਿਕਸਲ ਉਦੋਂ ਹੀ ਊਰਜਾ ਦੀ ਖਪਤ ਕਰਦੇ ਹਨ ਜਦੋਂ ਉਹ ਚਾਲੂ ਹੁੰਦੇ ਹਨ, ਇਸਲਈ OLED ਡਿਸਪਲੇ ਹੋਰ ਡਿਸਪਲੇ ਦੇ ਮੁਕਾਬਲੇ ਘੱਟ ਪਾਵਰ ਦੀ ਖਪਤ ਕਰਦਾ ਹੈ।
ਕਿਉਂਕਿ OLED ਡਿਸਪਲੇ I2C ਸੰਚਾਰ ਪ੍ਰੋਟੋਕੋਲ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਵਾਇਰਿੰਗ ਬਹੁਤ ਸਧਾਰਨ ਹੈ। ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੀ ਸਾਰਣੀ ਨੂੰ ਹਵਾਲੇ ਵਜੋਂ ਵਰਤ ਸਕਦੇ ਹੋ।

OLED ਪਿੰਨ	ESP32
ਵਿਨ	3.3 ਵੀ
ਜੀ.ਐਨ.ਡੀ	ਜੀ.ਐਨ.ਡੀ
SCL	GPIO 22
ਐਸ.ਡੀ.ਏ	GPIO 21

ਯੋਜਨਾਬੱਧSSD1306 OLED ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ - ESP32
ESP32 ਦੇ ਨਾਲ OLED ਡਿਸਪਲੇ ਨੂੰ ਕੰਟਰੋਲ ਕਰਨ ਲਈ ਕਈ ਲਾਇਬ੍ਰੇਰੀਆਂ ਉਪਲਬਧ ਹਨ।
ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ ਦੋ ਐਡਫਰੂਟ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ: Adafruit_SSD1306 ਲਾਇਬ੍ਰੇਰੀ ਅਤੇ Adafruit_GFX ਲਾਇਬ੍ਰੇਰੀ.
ਉਹਨਾਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਅਗਲੇ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ।

1. ਆਪਣਾ Arduino IDE ਖੋਲ੍ਹੋ ਅਤੇ ਸਕੈਚ> ਲਾਇਬ੍ਰੇਰੀ ਸ਼ਾਮਲ ਕਰੋ> ਲਾਇਬ੍ਰੇਰੀਆਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰੋ 'ਤੇ ਜਾਓ। ਲਾਇਬ੍ਰੇਰੀ ਮੈਨੇਜਰ ਨੂੰ ਖੋਲ੍ਹਣਾ ਚਾਹੀਦਾ ਹੈ।
2. ਖੋਜ ਬਾਕਸ ਵਿੱਚ “SSD1306” ਟਾਈਪ ਕਰੋ ਅਤੇ Adafruit ਤੋਂ SSD1306 ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ।
3. Adafruit ਤੋਂ SSD1306 ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਖੋਜ ਬਾਕਸ ਵਿੱਚ "GFX" ਟਾਈਪ ਕਰੋ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ।
4. ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਆਪਣੇ Arduino IDE ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰੋ।

ਕੋਡ
ਲੋੜੀਂਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, arduino IDE ਵਿੱਚ Project_10_ESP32_OLED_Display.ino ਨੂੰ ਖੋਲ੍ਹੋ। ਕੋਡ
ਅਸੀਂ Arduino IDE ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ESP32 ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਕਰਾਂਗੇ, ਇਸ ਲਈ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ESP32 ਐਡ-ਆਨ ਸਥਾਪਤ ਹੈ: (ਜੇ ਤੁਸੀਂ ਇਹ ਕਦਮ ਪਹਿਲਾਂ ਹੀ ਕਰ ਚੁੱਕੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਅਗਲੇ ਪੜਾਅ 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ।)
Arduino IDE ਵਿੱਚ ESP32 ਐਡ-ਆਨ ਇੰਸਟਾਲ ਕਰਨਾਕੋਡ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ
ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਆਯਾਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ
ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਲੋੜੀਂਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਆਯਾਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ. I2C ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਵਾਇਰ ਲਾਇਬ੍ਰੇਰੀ ਅਤੇ ਡਿਸਪਲੇ 'ਤੇ ਲਿਖਣ ਲਈ ਐਡਫ੍ਰੂਟ ਲਾਇਬ੍ਰੇਰੀਆਂ: Adafruit_GFX ਅਤੇ Adafruit_SSD1306।OLED ਡਿਸਪਲੇ ਸ਼ੁਰੂ ਕਰੋ
ਫਿਰ, ਤੁਸੀਂ ਆਪਣੀ OLED ਚੌੜਾਈ ਅਤੇ ਉਚਾਈ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ। ਇਸ ਵਿੱਚ ਸਾਬਕਾample, ਅਸੀਂ ਇੱਕ 128×64 OLED ਡਿਸਪਲੇ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ। ਜੇਕਰ ਤੁਸੀਂ ਹੋਰ ਆਕਾਰ ਵਰਤ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ SCREEN_WIDTH, ਅਤੇ SCREEN_HEIGHT ਵੇਰੀਏਬਲ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ।ਫਿਰ, I2C ਸੰਚਾਰ ਪ੍ਰੋਟੋਕੋਲ (&ਤਾਰ) ਨਾਲ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਚੌੜਾਈ ਅਤੇ ਉਚਾਈ ਦੇ ਨਾਲ ਇੱਕ ਡਿਸਪਲੇ ਆਬਜੈਕਟ ਨੂੰ ਸ਼ੁਰੂ ਕਰੋ।(-1) ਪੈਰਾਮੀਟਰ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਡੇ OLED ਡਿਸਪਲੇਅ ਵਿੱਚ ਰੀਸੈੱਟ ਪਿੰਨ ਨਹੀਂ ਹੈ। ਜੇਕਰ ਤੁਹਾਡੇ OLED ਡਿਸਪਲੇਅ ਵਿੱਚ ਇੱਕ ਰੀਸੈੱਟ ਪਿੰਨ ਹੈ, ਤਾਂ ਇਹ ਇੱਕ GPIO ਨਾਲ ਜੁੜਿਆ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਸ ਸਥਿਤੀ ਵਿੱਚ, ਤੁਹਾਨੂੰ ਇੱਕ ਪੈਰਾਮੀਟਰ ਵਜੋਂ GPIO ਨੰਬਰ ਪਾਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
ਸੈੱਟਅੱਪ (), ਡੀਬੱਗਿੰਗ ਉਦੇਸ਼ਾਂ ਲਈ 115200 ਦੇ ਬੌਡ ਰਾਊਟ 'ਤੇ ਸੀਰੀਅਲ ਮਾਨੀਟਰ ਨੂੰ ਸ਼ੁਰੂ ਕਰੋ।OLED ਡਿਸਪਲੇ ਨੂੰ ਬਿਗਨ() ਵਿਧੀ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ:ਇਹ ਸਨਿੱਪਟ ਸੀਰੀਅਲ ਮਾਨੀਟਰ 'ਤੇ ਇੱਕ ਸੁਨੇਹਾ ਵੀ ਛਾਪਦਾ ਹੈ, ਜੇਕਰ ਅਸੀਂ ਡਿਸਪਲੇ ਨਾਲ ਕਨੈਕਟ ਕਰਨ ਦੇ ਯੋਗ ਨਹੀਂ ਹਾਂ।

ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਵੱਖਰੇ OLED ਡਿਸਪਲੇ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ OLED ਪਤਾ ਬਦਲਣ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਪਤਾ 0x3C ਹੈ।ਡਿਸਪਲੇਅ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਦੋ ਸਕਿੰਟ ਦੀ ਦੇਰੀ ਜੋੜੋ, ਤਾਂ ਕਿ OLED ਕੋਲ ਟੈਕਸਟ ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਕਾਫ਼ੀ ਸਮਾਂ ਹੋਵੇ:ਡਿਸਪਲੇ ਸਾਫ਼ ਕਰੋ, ਫੌਂਟ ਦਾ ਆਕਾਰ, ਰੰਗ ਸੈੱਟ ਕਰੋ ਅਤੇ ਟੈਕਸਟ ਲਿਖੋ
ਡਿਸਪਲੇਅ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਡਿਸਪਲੇਅ ਬਫਰ ਨੂੰ clearDisplay() ਵਿਧੀ ਨਾਲ ਸਾਫ਼ ਕਰੋ:

ਟੈਕਸਟ ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਟੈਕਸਟ ਦਾ ਆਕਾਰ, ਰੰਗ ਅਤੇ OLED ਵਿੱਚ ਟੈਕਸਟ ਨੂੰ ਕਿੱਥੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ ਸੈੱਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
setTextSize() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਫੌਂਟ ਦਾ ਆਕਾਰ ਸੈਟ ਕਰੋ:setTextColor() ਵਿਧੀ ਨਾਲ ਫੌਂਟ ਦਾ ਰੰਗ ਸੈੱਟ ਕਰੋ:
ਵ੍ਹਾਈਟ ਸਫੈਦ ਫੌਂਟ ਅਤੇ ਕਾਲਾ ਬੈਕਗ੍ਰਾਊਂਡ ਸੈੱਟ ਕਰਦਾ ਹੈ।
ਉਸ ਸਥਿਤੀ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜਿੱਥੇ ਟੈਕਸਟ setCursor(x,y) ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਸੀਂ ਟੈਕਸਟ ਨੂੰ (0,0) ਕੋਆਰਡੀਨੇਟਸ ਤੋਂ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਸੈੱਟ ਕਰ ਰਹੇ ਹਾਂ - ਉੱਪਰ ਖੱਬੇ ਕੋਨੇ 'ਤੇ।ਅੰਤ ਵਿੱਚ, ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ println() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡਿਸਪਲੇਅ ਵਿੱਚ ਟੈਕਸਟ ਭੇਜ ਸਕਦੇ ਹੋਫਿਰ, ਤੁਹਾਨੂੰ ਸਕ੍ਰੀਨ 'ਤੇ ਟੈਕਸਟ ਨੂੰ ਅਸਲ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਡਿਸਪਲੇ() ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.

Adafruit OLED ਲਾਇਬ੍ਰੇਰੀ ਟੈਕਸਟ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਸਕ੍ਰੋਲ ਕਰਨ ਲਈ ਉਪਯੋਗੀ ਤਰੀਕੇ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ।

• startscrollright(0x00, 0x0F): ਟੈਕਸਟ ਨੂੰ ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਸਕ੍ਰੋਲ ਕਰੋ
• startscrollleft(0x00, 0x0F): ਟੈਕਸਟ ਨੂੰ ਸੱਜੇ ਤੋਂ ਖੱਬੇ ਤੱਕ ਸਕ੍ਰੋਲ ਕਰੋ
• startscrolldiagright(0x00, 0x07): ਖੱਬੇ ਹੇਠਲੇ ਕੋਨੇ ਤੋਂ ਸੱਜੇ ਉਪਰਲੇ ਕੋਨੇ ਤੱਕ ਸਕ੍ਰੌਲ ਟੈਕਸਟ startscrolldiagleft(0x00, 0x07): ਸੱਜੇ ਹੇਠਲੇ ਕੋਨੇ ਤੋਂ ਖੱਬੇ ਉੱਪਰਲੇ ਕੋਨੇ ਤੱਕ ਸਕ੍ਰੌਲ ਟੈਕਸਟ

ਕੋਡ ਅੱਪਲੋਡ ਕਰੋ
ਹੁਣ, ਆਪਣੇ ESP32 'ਤੇ ਕੋਡ ਅੱਪਲੋਡ ਕਰੋ। ਕੋਡ ਸੰਦਰਭ ਪੜਾਅ ਅੱਪਲੋਡ ਕਰੋ।
ਕੋਡ ਅੱਪਲੋਡ ਕਰਨ ਤੋਂ ਬਾਅਦ, OLED ਸਕ੍ਰੋਲਿੰਗ ਟੈਕਸਟ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗਾ।

ਦਸਤਾਵੇਜ਼ / ਸਰੋਤ

LAFVIN ESP32 ਬੇਸਿਕ ਸਟਾਰਟਰ ਕਿੱਟ [pdf] ਹਦਾਇਤ ਮੈਨੂਅਲ ESP32 ਬੇਸਿਕ ਸਟਾਰਟਰ ਕਿੱਟ, ESP32, ਬੇਸਿਕ ਸਟਾਰਟਰ ਕਿੱਟ, ਸਟਾਰਟਰ ਕਿੱਟ

ਹਵਾਲੇ

• ਯੂਜ਼ਰ ਮੈਨੂਅਲ