การตรวจสอบพลังงานแผงโซลาร์เซลล์แบบ Iot โดยใช้ esp32 และ thingspeak

ในด้านพลังงานหมุนเวียนพลังงานแสงอาทิตย์อยู่ในระดับแนวหน้าเนื่องจากการผลิตพลังงานโดยใช้พลังจากดวงอาทิตย์เป็นวิธีที่ง่ายที่สุดและเป็นไปได้ในเชิงพาณิชย์ของพลังงานหมุนเวียน เมื่อพูดถึงแผงโซลาร์เซลล์จำเป็นต้องมีการตรวจสอบกำลังขับของเอาต์พุตแผงโซลาร์เซลล์เพื่อให้ได้รับพลังงานที่เหมาะสมจากแผงเซลล์แสงอาทิตย์ นี่คือเหตุผลว่าทำไมระบบการตรวจสอบแบบเรียลไทม์จึงมีความจำเป็น ในโรงไฟฟ้าพลังงานแสงอาทิตย์ขนาดใหญ่ยังสามารถใช้เพื่อตรวจสอบกำลังไฟฟ้าที่ออกจากแต่ละแผงซึ่งจะช่วยระบุการสะสมของฝุ่น นอกจากนี้ยังป้องกันความผิดปกติใด ๆ ในช่วงเวลาของการทำงาน ในบทความก่อนหน้านี้เราได้สร้างโครงการเกี่ยวกับพลังงานแสงอาทิตย์บางโครงการเช่นเครื่องชาร์จโทรศัพท์มือถือพลังงานแสงอาทิตย์และวงจรอินเวอร์เตอร์พลังงานแสงอาทิตย์เป็นต้นคุณสามารถตรวจสอบสิ่งเหล่านี้ได้หากคุณกำลังมองหาโครงการเพิ่มเติมเกี่ยวกับพลังงานแสงอาทิตย์

ในโครงการนี้เราจะสร้างระบบตรวจสอบพลังงานแสงอาทิตย์ที่ใช้ IoTโดยผสมผสานเทคนิคการชาร์จแบตเตอรี่แบบMPPT (Maximum Power Point Tracker)ซึ่งจะช่วยลดเวลาในการชาร์จและปรับปรุงประสิทธิภาพ นอกจากนี้เราจะวัดอุณหภูมิแผงแรงดันขาออกและกระแสไฟฟ้าเพื่อปรับปรุงด้านความปลอดภัยของวงจร ในที่สุดเราจะใช้บริการคลาวด์ของ ThingSpeak เพื่อตรวจสอบข้อมูลเอาต์พุตจากทุกที่ทั่วโลก โปรดทราบว่าโครงการนี้เป็นโครงการต่อเนื่องจากโครงการ MPPT Solar Charge Controller ที่เราสร้างไว้ก่อนหน้านี้ ที่นี่เราจะตรวจสอบแรงดันขาออกกระแสและกำลังของแผงโดยใช้บอร์ดพัฒนา ESP32 IoT

การเลือกส่วนประกอบที่เหมาะสมสำหรับการตรวจสอบพลังงานแสงอาทิตย์ที่เปิดใช้งาน IoT

ด้วยจอภาพพลังงานแสงอาทิตย์ทำให้ง่ายต่อการตรวจสอบและตรวจจับความผิดพลาดในระบบสุริยะใด ๆ นี่คือเหตุผลที่การเลือกส่วนประกอบกลายเป็นส่วนที่สำคัญมากเมื่อออกแบบระบบดังกล่าว ด้านล่างเป็นรายการชิ้นส่วนที่เราใช้

บอร์ด dev ESP32
วงจร MPPT (สามารถเป็นวงจรพลังงานแสงอาทิตย์ใดก็ได้)
ตัวต้านทานแบบแบ่ง (เช่น 1 โอห์ม 1 วัตต์ - เหมาะสำหรับกระแสสูงสุด 1A)
แบตเตอรี่ลิเธียม (7.4v ที่ต้องการ)
การเชื่อมต่อ Wi-Fi ที่ใช้งานอยู่
เซ็นเซอร์อุณหภูมิสำหรับแผงโซลาร์เซลล์
วงจรแบ่งแรงดัน (ดูคำอธิบาย)

บอร์ด Esp32 Dev:

สำหรับแอปพลิเคชันที่เปิดใช้งาน IoT จำเป็นอย่างยิ่งที่จะต้องเลือกประเภทของบอร์ดพัฒนาที่เหมาะสมซึ่งจะสามารถประมวลผลข้อมูลจากพินอนาล็อกและส่งข้อมูลผ่านโปรโตคอลการเชื่อมต่อประเภทใดก็ได้เช่น Wi-Fi หรือไปยังคลาวด์ เซิร์ฟเวอร์ เราเลือก ESP32 โดยเฉพาะเนื่องจากเป็นไมโครคอนโทรลเลอร์ราคาประหยัดพร้อมคุณสมบัติมากมาย นอกจากนี้ยังมีวิทยุ Wi-Fi ในตัวซึ่งเราสามารถเชื่อมต่อกับอินเทอร์เน็ตได้อย่างง่ายดาย

วงจรพลังงานแสงอาทิตย์:

วงจรชาร์จพลังงานแสงอาทิตย์เป็นวงจรที่ได้รับแรงดันไฟฟ้าสูงขึ้นจากแผงโซลาร์เซลล์และแปลงเป็นแรงดันไฟฟ้าในการชาร์จเพื่อให้สามารถชาร์จแบตเตอรี่ได้อย่างมีประสิทธิภาพ สำหรับโครงการนี้เราจะใช้แผงวงจรควบคุมการชาร์จ MPPT ที่ใช้ LT3562 ซึ่งเราได้ทำไว้ในโครงการก่อนหน้านี้ แต่ถ้าคุณต้องการฝัง IoT นี้เพื่อเปิดใช้งานการตรวจสอบคุณสามารถใช้วงจรพลังงานแสงอาทิตย์ชนิดใดก็ได้ เราเลือกบอร์ดนี้เนื่องจากวงจรมี Maximum Power Point Tracking (MPPT) ซึ่งเป็นประโยชน์สำหรับโครงการแผงโซลาร์เซลล์พลังงานต่ำ เป็นวิธีที่มีประสิทธิภาพในการชาร์จแบตเตอรี่ลิเธียมขนาดเล็กจากแผงโซลาร์เซลล์

ตัวต้านทาน Shunt:

ตัวต้านทานใด ๆ เป็นไปตามกฎของโอห์มซึ่งหมายความว่าหากกระแสจำนวนหนึ่งไหลผ่านตัวต้านทานแรงดันไฟฟ้าตกจำนวนหนึ่งจะปรากฏขึ้น ตัวต้านทานแบบแบ่งไม่ได้เป็นข้อยกเว้นและใช้เพื่อวัดการไหลของกระแสโดยเฉพาะ อย่างไรก็ตามขึ้นอยู่กับการไหลของกระแสเล็กน้อยผ่านแผงโซลาร์เซลล์ให้เลือกตัวต้านทานแบบแบ่งที่จะสร้างแรงดันไฟฟ้าที่เพียงพอซึ่งสามารถวัดได้โดยหน่วยไมโครคอนโทรลเลอร์ แต่ในขณะเดียวกันกำลังวัตต์ของตัวต้านทานก็เป็นสิ่งสำคัญเช่นกัน การเลือกวัตต์ของตัวต้านทานแบบแบ่งก็มีความสำคัญเช่นกัน

สามารถคำนวณแรงดันตกโดยใช้สูตรที่ระบุด้านล่าง สิ่งนี้เรียกว่ากฎของโอห์ม

V = ฉัน x R

V คือแรงดันไฟฟ้าที่จะเกิดขึ้นในช่วง 'I' นั่นคือปริมาณกระแสไฟฟ้าที่ไหลผ่านจำนวนตัวต้านทาน 'R' ตัวอย่างเช่นตัวต้านทาน 1 โอห์มจะสร้างแรงดันตก 1V เมื่อกระแส 1A ไหลผ่าน

สำหรับกำลังวัตต์ของตัวต้านทานสามารถใช้สูตรที่ระบุด้านล่างได้ -

P = ฉัน² R

โดยที่ฉันคือกระแสไฟฟ้าสูงสุดและ R คือค่าตัวต้านทาน สำหรับกระแส 1A ที่มีตัวต้านทาน 1 โอห์ม 1 วัตต์เพียงพอสำหรับการกระจายพลังงาน อย่างไรก็ตามสิ่งนี้มีประโยชน์สำหรับโครงการแผงโซลาร์เซลล์ขนาดเล็ก แต่ไม่เหมาะสำหรับการใช้งานที่เกี่ยวข้องกับกริดพลังงานแสงอาทิตย์เลย ในกรณีเช่นนี้เทคนิคการวัดกระแสแบบไม่รุกรานเป็นสิ่งที่จำเป็นต้องใช้ ในกรณีเช่นนี้สามารถวัดการไหลของกระแสได้อย่างแม่นยำซึ่งสามารถวัดปริมาณกระแสไฟฟ้าที่ต่ำมากรวมทั้งกระแสไฟฟ้าที่สูงมากได้

แบตเตอรี่ลิเธียม:

การเลือกแบตเตอรี่ลิเธียมเป็นส่วนสำคัญของโครงการใด ๆ ที่เกี่ยวข้องกับแผงโซลาร์เซลล์ เนื่องจากหน่วยไมโครคอนโทรลเลอร์ที่ยังคงเปิดอยู่และตรวจสอบและส่งข้อมูลอยู่ตลอดเวลาต้องการกระแสไฟฟ้าอย่างน้อยหนึ่งร้อยมิลลิแอมป์เพื่อการทำงานที่เสถียร

ความจุของแบตเตอรี่ควรเป็นสิ่งที่สามารถจ่ายไฟให้กับไมโครคอนโทรลเลอร์ได้อย่างน้อย 4-5 วันเมื่อแดดไม่ส่องถึงเพราะมรสุม สิ่งสำคัญคือกระแสประจุจะต้องมากกว่ากระแสโหลดจากมุมมองของแบตเตอรี่ มันค่อนข้างผิดปกติถ้ามีคนเชื่อมต่อโหลด 100mA กับแบตเตอรี่และให้กระแสประจุซึ่งน้อยกว่านั้น เพื่อความปลอดภัยเราควรมีกระแสชาร์จมากกว่ากระแสโหลดอย่างน้อย 5 เท่า

ในทางกลับกันแรงดันไฟฟ้าของแบตเตอรี่จะต้องสูงกว่าแรงดันไฟฟ้าขาเข้าของตัวควบคุมแรงดันไฟฟ้าทั่วไปที่ต้องใช้สำหรับไมโครคอนโทรลเลอร์ ตัวอย่างเช่นแบตเตอรี่ลิเธียม 7.4V สามารถเชื่อมต่อกับตัวควบคุมแรงดันไฟฟ้าเชิงเส้นทั้ง 3.3V และ 5.0V (เนื่องจากตัวควบคุมเชิงเส้นต้องการแรงดันตกกลางที่สูงกว่า LDO และการสลับ)

ในโครงการของเราเราใช้แบตเตอรี่ 4000mAH ที่มีพิกัด 7.4V เราใช้ตัวควบคุม 5.0V ที่ให้กระแสและแรงดันเอาต์พุตเพียงพอสำหรับ ESP32

ตัวแบ่งแรงดันไฟฟ้า:

ตัวแบ่งแรงดันไฟฟ้าเป็นส่วนสำคัญของการวัดแรงดันไฟฟ้าของแผงโซลาร์เซลล์ ควรเลือกตัวแบ่งแรงดันไฟฟ้าที่จะแบ่งแรงดันไฟฟ้าตามอินพุตแรงดันไฟฟ้า I / O ของไมโครคอนโทรลเลอร์

เลือกตัวต้านทานด้านบนในลักษณะที่แรงดันเอาต์พุตของตัวแบ่งแรงดันไฟฟ้าไม่ควรเกินแรงดัน I / O สูงสุดของไมโครคอนโทรลเลอร์ (3.3V สำหรับ ESP32) อย่างไรก็ตามขอแนะนำให้ใช้โพเทนชิออมิเตอร์เนื่องจากจะให้ความยืดหยุ่นในการเลือกแผงโซลาร์เซลล์ใด ๆ ที่มีพิกัดแรงดันไฟฟ้าสูงหรือต่ำกว่าและสามารถตั้งค่าแรงดันไฟฟ้าโดยใช้มัลติมิเตอร์ได้อย่างง่ายดาย

ในกรณีของเราเรามีโพเทนชิออมิเตอร์ในวงจรบอร์ด MPPT ซึ่งทำหน้าที่เป็นตัวแบ่งแรงดันไฟฟ้า เราตั้งค่าตัวแบ่งแรงดันไฟฟ้าด้วยปัจจัยการหาร 6V เราเชื่อมต่อสองหลายเมตรหนึ่งในอินพุตและอีกอันหนึ่งในเอาต์พุตของหม้อและตั้งค่าว่าเมื่อแรงดันไฟฟ้าอินพุตเป็น 18V เอาต์พุตจะเป็น 3V เนื่องจากแรงดันขาออกเล็กน้อยของแผงโซลาร์เซลล์คือ 18V

เซ็นเซอร์อุณหภูมิสำหรับแผงโซลาร์เซลล์:

เอาท์พุทพลังงานของแผงโซลาร์เซลล์มีการเชื่อมต่อโดยตรงกับอุณหภูมิของแผงโซลาร์เซลล์ ทำไม? เนื่องจากเมื่ออุณหภูมิของแผงโซลาร์เซลล์เริ่มเพิ่มขึ้นกระแสไฟฟ้าขาออกจากแผงโซลาร์เซลล์จะเพิ่มขึ้นเป็นทวีคูณในขณะที่แรงดันไฟฟ้าขาออกเริ่มลดลงในเชิงเส้น

ตามสูตรกำลังวัตต์จะเท่ากับแรงดันไฟฟ้าคูณกระแส (W = V x A) การลดแรงดันขาออกยังลดกำลังขับของแผงโซลาร์เซลล์แม้หลังจากการไหลของกระแสเพิ่มขึ้น คำถามต่อไปที่อยู่ในใจของเราคือจะวัดอุณหภูมิแสงอาทิตย์ได้อย่างไร? ค่อนข้างน่าสนใจเนื่องจากโดยทั่วไปแผงโซลาร์เซลล์จะสัมผัสกับสภาพแวดล้อมที่ร้อนเนื่องจากสัมผัสกับแสงแดดโดยตรงและด้วยเหตุผลที่ชัดเจน วิธีที่ดีที่สุดในการวัดอุณหภูมิแผงโซลาร์เซลล์คือการใช้เซ็นเซอร์อุณหภูมิพื้นผิวเรียบ นอกจากนี้ยังแนะนำให้ใช้เทอร์โมคัปเปิลชนิด K ที่วางไว้ในแผงโซลาร์เซลล์โดยตรง

สำหรับแอปพลิเคชันของเราเราได้ใช้โมดูลเซ็นเซอร์อุณหภูมิที่ใช้เทอร์มิสเตอร์ซึ่งแสดงไว้ด้านล่าง

แผนภาพวงจรสำหรับการตรวจสอบพลังงานแสงอาทิตย์ตาม IoT

แผนภาพวงจรที่สมบูรณ์สำหรับการตรวจสอบพลังงานแสงอาทิตย์ที่เปิดใช้งาน IoTแสดงอยู่ด้านล่าง แผนผังนั้นเรียบง่าย กระดานจุดประสีแดงคือบอร์ด MPPT ที่เราใช้สำหรับโครงการนี้

การตั้งค่า ThingSpeak

สร้างบัญชีกับ ThingSpeak และไปที่“ช่องของฉัน”ตัวเลือกแล้วคลิกที่ช่องทางใหม่

สร้างช่องใหม่ด้วยชื่อเขตข้อมูล

หลังจากตั้งค่าฟิลด์แล้วให้ไปที่ฟิลด์API Keysที่มี Write API Key ต้องระบุคีย์นี้ในรหัสและรหัสช่อง

ที่อยู่ ThingSpeak สามารถพบได้ในหน้าเดียวกัน

ด้วยขั้นตอนข้างต้นคุณสามารถตั้งค่า ThingSpeak ได้อย่างง่ายดาย หากคุณต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ ThingSpeak และขั้นตอนการตั้งค่าคุณสามารถอ่านบทความก่อนหน้าของเราในหัวข้อ

รหัส Arduino สำหรับการตรวจสอบพลังงานแสงอาทิตย์โดยใช้ ESP32

รหัสตรวจสอบพลังงานแสงอาทิตย์ ESP32 ที่สมบูรณ์มีอยู่ที่ด้านล่างของหน้านี้ รหัสเริ่มต้นด้วยการกำหนด SSID รหัสผ่านและพารามิเตอร์คงที่อื่น ๆ ตามที่แสดงด้านล่าง

// กำหนด WiFi SSID & PWD สำหรับอัปลิงค์ #define WLAN_SSID "xxxx" # กำหนด WLAN_PASS "xxxxxxxxxx"

// ความต้านทานที่ 25 องศา C # กำหนด THERMISTORNOMINAL 10000 // temp. สำหรับความต้านทานเล็กน้อย (เกือบตลอดเวลา 25 C) #define TEMPERATURENOMINAL 25 // ค่าสัมประสิทธิ์เบต้าของเทอร์มิสเตอร์ (โดยปกติคือ 3000-4000) # กำหนดค่า BCOEFFICIENT 3950 // ค่าของตัวต้านทาน 'อื่น ๆ ' #define SERIESRESISTOR 10000

เทอร์มิสเตอร์โอห์มระบุมีให้ที่อุณหภูมิเล็กน้อย ตั้งค่านี้ขึ้นอยู่กับแผ่นข้อมูลของเทอร์มิสเตอร์ ใส่ค่าสัมประสิทธิ์เบต้าและค่าตัวต้านทานอนุกรมของเทอร์มิสเตอร์

// กำหนด Analog สำหรับกระแสและแรงดัน const int curr_an_pin = 35; const int volt_an_pin = 34; const int ntc_temp_an_pin = 33;

PIN ถูกกำหนดไว้ที่นี่

#define thingSpeakAddress "xxxxxxxxx" #define channelID xxxxx #define writeFeedAPIKey "xxxxxxx" #define readFeedAPIKey "xxxxxxx" #define readFieldAPIKey "xxxxxxxx" #define readStatusAPIKey "xxxxxxx"

ใส่ thingSpeakAddress, channelID, Write Feed API Key ส่วนที่เหลือไม่จำเป็นต้องใช้ แต่ยังมีประโยชน์หากต้องรับข้อมูลจากเว็บ

การตั้งค่าเป็นโมฆะ () { // ใส่รหัสการตั้งค่าของคุณที่นี่เพื่อเรียกใช้ครั้งเดียว: // ตั้งค่าพอร์ตอนุกรมที่ 115200 Serial.begin (115200); // เริ่มต้นการ หน่วงเวลา แบบอนุกรม (1,000); WiFi.mode (WIFI_STA); ThingSpeak.begin (ไคลเอนต์); // เริ่มต้น ThingSpeak // สิ่งที่ต้องทำ: สร้างงานเพื่ออ่านพินเพื่อรับกระแสและแรงดันและคำนวณวัตต์และอุณหภูมิของแผงโซลาร์เซลล์ xTaskCreate ( wifi_task, / * ฟังก์ชัน Task. * / "wifi_task", / * สตริงที่มีชื่อของ งาน. * / 1024 * 2, / * ขนาดสแต็คเป็นไบต์ * / NULL, / * พารามิเตอร์ที่ส่งผ่านเป็นอินพุตของงาน * / 5, / * ลำดับความสำคัญของงาน * / NULL); / * ที่จับงาน * / Serial.print ("การอ่านข้อมูล"); }

ในโค้ดด้านบนเซิร์ฟเวอร์ ThingSpeak ได้รับการเตรียมใช้งานและมีการสร้างงานที่จะรับข้อมูลที่เกี่ยวข้องกับแผงโซลาร์เซลล์

ในลูปหลักกระแสแสงอาทิตย์และแรงดันไฟฟ้าจะถูกตรวจจับผ่านพินอนาล็อกและค่าเฉลี่ยจะเสร็จสิ้น

ลอย solar_curr_adc_val = 0; ลอย solar_volt_adc_val = 0; สำหรับ (i = 0; i <NUMSAMPLES; i ++) { curr_samples = analogRead (curr_an_pin); volt_samples = analogRead (volt_an_pin); temp_samples = analogRead (ntc_temp_an_pin); ล่าช้า (10); } // เฉลี่ยตัวอย่างทั้งหมดออก float curr_avg = 0; ลอย volt_avg = 0; ลอย temp_avg = 0; สำหรับ (i = 0; i <NUMSAMPLES; i ++) { curr_avg + = curr_samples; volt_avg + = volt_samples; temp_avg + = temp_samples; } curr_avg / = NUMSAMPLES; volt_avg / = NUMSAMPLES; temp_avg / = NUMSAMPLES; //Serial.print("ADC VALUE = "); //Serial.println(ADC_VALUE); // แปลงค่า adc เป็นแรงดันไฟฟ้าเพื่อรับกระแสและแรงดันจริง ลอย solar_curr = (curr_avg * 3.3) / (4095); ลอย solar_volt = (volt_avg * 3.3) / (4095); // โดยใช้ตัวแบ่งแรงดันไฟฟ้าเราลดแรงดันไฟฟ้าจริง // ด้วยเหตุนี้เราจึงคูณ 6 ด้วยแรงดันไฟฟ้าเฉลี่ยเพื่อให้ได้แรงดันไฟฟ้าจริงของแผงโซลาร์เซลล์ solar_volt * = 6;

แรงดันไฟฟ้าแสงอาทิตย์จะถูกส่งโดยการคูณด้วย 6 ในขณะที่เราสร้างตัวแบ่งแรงดันไฟฟ้าที่จะหารแรงดันไฟฟ้าขาเข้า 6 เท่า

อุณหภูมิถูกสร้างขึ้นจากเทอร์มิสเตอร์โดยใช้การสร้างลอการิทึม

// แปลงค่าเป็นความต้านทาน temp_avg = 4095 / temp_avg - 1; temp_avg = SERIESRESISTOR / temp_avg; //Serial.print("ตัวต้านทานเทอร์มิสเตอร์"); //Serial.println(temp_avg); ลอยสไตน์ฮาร์ท; สไตน์ฮาร์ท = temp_avg / THERMISTORNOMINAL; // (R / Ro) steinhart = บันทึก (สไตน์ฮาร์ท); // ln (R / Ro) ส ไตน์ฮาร์ท / = BCOEFFICIENT; // 1 / B * ln (R / Ro) ส ไตน์ฮาร์ท + = 1.0 / (อุณหภูมิ + 273.15); // + (1 / ถึง) steinhart = 1.0 / steinhart; // กลับส ไตน์ฮาร์ต - = 273.15; // แปลงอุณหภูมิสัมบูรณ์เป็น C

ข้อมูลจะถูกอ่านทุกๆ 15 วินาที

ล่าช้า (1,000); นับ ++; Serial.print ("."); ถ้า (count> = 15) { count = 0; Serial.println ("============================================= ============================ "); Serial.print ("Solar Voltage ="); Serial.println (solar_volt); Serial.print ("กระแสแสงอาทิตย์ ="); Serial.println (solar_curr); ลอย solar_watt = solar_volt * solar_curr; Serial.print ("พลังงานแสงอาทิตย์วัตต์ ="); Serial.println (solar_watt); Serial.print ("อุณหภูมิแสงอาทิตย์ ="); Serial.println (สไตน์ฮาร์ท); Serial.println ("============================================= ============================ ");

ข้อมูลสำหรับฟิลด์ต่างๆจะถูกส่งโดยใช้ฟังก์ชัน Thing.Speak.setField (); เมื่อเชื่อมต่อ WiFi

ถ้า (WiFi.status () == WL_CONNECTED) { ThingSpeak.setField (1, solar_volt); ThingSpeak.setField (2, solar_curr); ThingSpeak.setField (3, solar_watt); ThingSpeak.setField (4, สไตน์ฮาร์ท); // เขียนไปที่ช่อง ThingSpeak int x = ThingSpeak.writeFields (channelID, writeFeedAPIKey); ถ้า (x == 200) { Serial.println ("การอัปเดตช่องสำเร็จ"); } else { Serial.println ("ปัญหาในการอัปเดต channel. HTTP error code" + String (x)); } } else { Serial.println ("\ r \ n ##################################### ######################## "); Serial.println ("ไม่สามารถอัปเดตข้อมูลไปยังเซิร์ฟเวอร์ thingSpeak"); Serial.println ("ไม่ได้เชื่อมต่อ WiFi… "); Serial.println ("############################################ ################ \ r \ n "); } Serial.print ("การอ่านข้อมูล"); } }

งาน Wi-Fi ที่สร้างขึ้นในข้อมูลโค้ดด้านล่าง -

เป็นโมฆะ wifi_task (พารามิเตอร์โมฆะ *) { while (1) { if (WiFi.status ()! = WL_CONNECTED) { Serial.print ("พยายามเชื่อมต่อกับ SSID:"); Serial.println (WLAN_SSID); ในขณะที่ (WiFi.status ()! = WL_CONNECTED) { WiFi.begin (WLAN_SSID, WLAN_PASS); // เชื่อมต่อกับเครือข่าย WPA / WPA2 เปลี่ยนบรรทัดนี้หากใช้เครือข่ายแบบเปิดหรือ WEP Serial.print ("."); ล่าช้า (5000); } Serial.println ("\ nConnected."); Serial.println (); Serial.println ("เชื่อมต่อ WiFi แล้ว"); Serial.println ("ที่อยู่ IP:"); Serial.println (WiFi.localIP ()); } vTaskDelay (1000 / portTICK_PERIOD_MS); } vTaskDelete (NULL); }

การทดสอบและการตรวจสอบข้อมูล

แผงโซลาร์เซลล์เชื่อมต่อกับวงจรและวางไว้ในแสงแดดเพื่อทดสอบดังแสดงด้านล่าง

การทำงานที่สมบูรณ์แสดงให้เห็นในวิดีโอด้านล่าง วงจรของเราสามารถอ่านแรงดันเอาท์พุทกระแสและกำลังไฟฟ้าจากแผงควบคุมและอัปเดตได้แบบสดบนช่อง thingspeak ดังที่แสดงด้านล่าง

อย่างที่เราเห็นข้อมูล 15 นาทีจะแสดงในกราฟด้านบน เนื่องจากเป็นโครงการดำเนินการกลางแจ้งจึงต้องใช้ PCB ที่เหมาะสมพร้อมกับกล่องปิด ต้องทำตู้ในลักษณะที่วงจรยังคงกันน้ำได้เมื่อฝนตก หากต้องการแก้ไขวงจรนี้หรือเพื่อหารือเกี่ยวกับแง่มุมเพิ่มเติมของโครงการนี้โปรดใช้ฟอรัมที่ใช้งานอยู่ของ Circuit Digest หวังว่าคุณจะสนุกกับบทช่วยสอนและเรียนรู้สิ่งที่เป็นประโยชน์