ARDUINO PWM SOLAR CHARGE CONTROLLER (V 2.02): 25 ขั้นตอน (พร้อมรูปภาพ)

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:03

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

คุณสามารถผ่านโครงการ Solar ของฉันได้บนเว็บไซต์ของฉัน: www.opengreenenergy.com และช่อง YouTube: Open Green Energy

ประเภทของตัวควบคุมการชาร์จพลังงานแสงอาทิตย์

ปัจจุบันมีตัวควบคุมการประจุสองประเภทที่ใช้กันทั่วไปในระบบไฟฟ้าพลังงานแสงอาทิตย์:

1. ตัวควบคุมการปรับความกว้างพัลส์ (PWM)

2. คอนโทรลเลอร์ Power Point Tracking (MPPT) สูงสุด

ในคำแนะนำนี้ ฉันจะอธิบายให้คุณทราบเกี่ยวกับ PWM Solar Charge Controller ฉันได้โพสต์บทความเกี่ยวกับตัวควบคุมการชาร์จ PWM ก่อนหน้านี้ด้วย ตัวควบคุมการชาร์จพลังงานแสงอาทิตย์รุ่นก่อนหน้าของฉันค่อนข้างเป็นที่นิยมบนอินเทอร์เน็ตและมีประโยชน์สำหรับผู้คนทั่วโลก

เมื่อพิจารณาจากความคิดเห็นและคำถามจากเวอร์ชันก่อนหน้า ฉันได้แก้ไข V2.0 PWM Charge Controller ที่มีอยู่เพื่อให้เป็นเวอร์ชันใหม่ 2.02

ต่อไปนี้คือการเปลี่ยนแปลงใน V2.02 w.r.t V2.0:

1. ตัวควบคุมแรงดันไฟฟ้าเชิงเส้นที่มีประสิทธิภาพต่ำถูกแทนที่ด้วยตัวแปลงบั๊ก MP2307 สำหรับแหล่งจ่ายไฟ 5V

2. เซ็นเซอร์ปัจจุบันเพิ่มเติมหนึ่งตัวเพื่อตรวจสอบกระแสที่มาจากแผงโซลาร์เซลล์

3. MOSFET-IRF9540 ถูกแทนที่ด้วย IRF4905 เพื่อประสิทธิภาพที่ดีขึ้น

4. เซ็นเซอร์อุณหภูมิออนบอร์ด LM35 ถูกแทนที่ด้วยโพรบ DS18B20 เพื่อการตรวจสอบอุณหภูมิแบตเตอรี่ที่แม่นยำ

5. พอร์ต USB สำหรับชาร์จอุปกรณ์อัจฉริยะ

6. ใช้ฟิวส์ตัวเดียวแทนสองตัว

7. LED เพิ่มเติมหนึ่งดวงเพื่อระบุสถานะพลังงานแสงอาทิตย์

8. การใช้อัลกอริธึมการชาร์จ 3 ขั้นตอน

9.การนำตัวควบคุม PID ไปใช้ในอัลกอริธึมการชาร์จ

10. ทำ PCB แบบกำหนดเองสำหรับโครงการ

ข้อมูลจำเพาะ

1. ตัวควบคุมการชาร์จและเครื่องวัดพลังงาน

2. การเลือกแรงดันแบตเตอรี่อัตโนมัติ (6V/12V)

อัลกอริธึมการชาร์จ 3. PWM พร้อมการตั้งค่าการชาร์จอัตโนมัติตามแรงดันแบตเตอรี่

4.ไฟ LED แสดงสถานะการชาร์จและสถานะการโหลด

5. จอแสดงผล LCD ขนาด 20x4 ตัวสำหรับแสดงแรงดันไฟฟ้า กระแสไฟ กำลัง พลังงาน และอุณหภูมิ

6.ป้องกันฟ้าผ่า

7. การป้องกันกระแสย้อนกลับ

8.ป้องกันไฟฟ้าลัดวงจรและโอเวอร์โหลด

9. การชดเชยอุณหภูมิสำหรับการชาร์จ

10. พอร์ต USB สำหรับชาร์จ Gadgets

เสบียง

คุณสามารถสั่งซื้อ PCB V2.02 ได้จาก PCBWay

1. Arduino Nano (อเมซอน / Banggood)

2. P-MOSFET - IRF4905 (Amazon / Banggood)

3.เพาเวอร์ไดโอด-MBR2045(Amazon/Aliexpress)

4. Buck Converter-MP2307 (Amazon / Banggood)

5.อุณหภูมิ เซนเซอร์ - DS18B20 (Amazon / Banggood)

6. Current เซนเซอร์ - ACS712 (Amazon / Banggood)

7. TVS ไดโอด - P6KE36CA (Amazon / Aliexpress)

8.ทรานซิสเตอร์ - 2N3904 (Amazon / Banggood)

9.ตัวต้านทาน (100k x 2, 20k x 2, 10k x 2, 1k x 2, 330ohm x 7) (Amazon / Banggood)

10.ตัวเก็บประจุเซรามิก (0.1uF x 2) (Amazon / Banggood)

11. 20x4 I2C LCD (อเมซอน / Banggood)

12. RGB LED (อเมซอน / Banggood)

13.ไฟ LED สองสี (Amazon)

15.สายจัมเปอร์/สายไฟ (Amazon / Banggood)

16.หมุดส่วนหัว (Amazon / Banggood)

17.ครีบระบายความร้อน (Amazon / Aliexpress)

18.ฟิวส์และฟิวส์ (Amazon)

19. ปุ่มกด (Amazon / Banggood)

22.ขั้วต่อสกรู 1x6 พิน (Aliexpress)

23. PCB Standoffs (บางกู๊ด)

24. ซ็อกเก็ต USB (Amazon / Banggood)

เครื่องมือ:

1.หัวแร้ง (อเมซอน)

2. ปั๊ม Desoldering (อเมซอน)

2.เครื่องตัดและปอกสายไฟ (Amazon)

3.ไขควง (อเมซอน)

ขั้นตอนที่ 1: หลักการทำงานของตัวควบคุมการชาร์จ PWM

PWM ย่อมาจาก Pulse Width Modulation ซึ่งหมายถึงวิธีการที่ใช้ในการควบคุมการชาร์จ หน้าที่ของมันคือดึงแรงดันไฟของแผงโซลาร์เซลล์ให้ใกล้แบตเตอรี่เพื่อให้แน่ใจว่าชาร์จแบตเตอรี่อย่างเหมาะสม กล่าวอีกนัยหนึ่งพวกเขาล็อคแรงดันแผงโซลาร์เซลล์กับแรงดันแบตเตอรี่โดยลากแผงโซลาร์เซลล์ Vmp ลงไปที่แรงดันของระบบแบตเตอรี่โดยไม่มีการเปลี่ยนแปลงในปัจจุบัน

ใช้สวิตช์อิเล็กทรอนิกส์ (MOSFET) เพื่อเชื่อมต่อและถอดแผงโซลาร์เซลล์ด้วยแบตเตอรี่ ด้วยการเปลี่ยน MOSFET ที่ความถี่สูงด้วยความกว้างพัลส์ต่างๆ จึงสามารถรักษาแรงดันไฟคงที่ได้ ตัวควบคุม PWM ปรับตัวเองโดยเปลี่ยนความกว้าง (ความยาว) และความถี่ของพัลส์ที่ส่งไปยังแบตเตอรี่

เมื่อความกว้างอยู่ที่ 100% MOSFET จะเปิดเต็ม ทำให้แผงโซลาร์เซลล์สามารถชาร์จแบตเตอรี่จำนวนมากได้ เมื่อความกว้างอยู่ที่ 0% ทรานซิสเตอร์จะปิดวงจรเปิด แผงโซลาร์เซลล์จะป้องกันไม่ให้กระแสไหลไปยังแบตเตอรี่เมื่อชาร์จแบตเตอรี่จนเต็ม

ขั้นตอนที่ 2: วงจรทำงานอย่างไร

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

หมายเหตุ: ในภาพด้านบน มีข้อผิดพลาดในการพิมพ์พลังงานและสัญญาณควบคุม เส้นสีแดงสำหรับกำลังและเส้นสีเหลืองสำหรับสัญญาณควบคุม

แผนผังทั้งหมดแบ่งออกเป็นวงจรต่อไปนี้:

1. วงจรจ่ายไฟ:

พลังงานจากแบตเตอรี่ (B+ & B-) ลดลงเหลือ 5V โดยตัวแปลงบั๊ก X1 (MP2307) เอาต์พุตจากตัวแปลงบั๊กกระจายไปที่

1. บอร์ด Arduino

2. LEDs สำหรับบ่งชี้

3. จอ LCD

4. พอร์ต USB เพื่อชาร์จอุปกรณ์ต่างๆ

2. เซ็นเซอร์อินพุต:

แผงโซลาร์เซลล์และแรงดันไฟฟ้าของแบตเตอรี่รับรู้โดยใช้วงจรแบ่งแรงดันสองวงจรซึ่งประกอบด้วยตัวต้านทาน R1-R2 และ R3- R4 C1 และ C2 เป็นตัวเก็บประจุกรองเพื่อกรองสัญญาณรบกวนที่ไม่ต้องการ เอาต์พุตจากตัวแบ่งแรงดันไฟฟ้าเชื่อมต่อกับพินอะนาล็อก Arduino A0 และ A1 ตามลำดับ

แผงโซลาร์เซลล์และกระแสโหลดถูกตรวจจับโดยใช้โมดูล ACS712 สองโมดูล เอาต์พุตจากเซ็นเซอร์ปัจจุบันเชื่อมต่อกับ Arduino analog pin A3 และ A2 ตามลำดับ

อุณหภูมิของแบตเตอรี่วัดโดยใช้เซ็นเซอร์อุณหภูมิ DS18B20 R16 (4.7K) เป็นตัวต้านทานแบบดึงขึ้น เอาต์พุตของเซ็นเซอร์อุณหภูมิเชื่อมต่อกับ Arduino Digital pin D12

3. วงจรควบคุม:

วงจรควบคุมนั้นสร้างโดย p-MOSFET สองตัว Q1 และ Q2 MOSFET Q1 ใช้เพื่อส่งพัลส์การชาร์จไปยังแบตเตอรี่ และใช้ MOSFET Q2 เพื่อขับเคลื่อนโหลด วงจรขับ MOSFET สองวงจรประกอบด้วยทรานซิสเตอร์สองตัว T1 และ T2 พร้อมตัวต้านทานแบบดึงขึ้น R6 และ R8 กระแสฐานของทรานซิสเตอร์ถูกควบคุมโดยตัวต้านทาน R5 และ R7

4. วงจรป้องกัน:

แรงดันไฟเกินอินพุตจากด้านแผงโซลาร์เซลล์ได้รับการป้องกันโดยใช้ไดโอด TVS D1 กระแสย้อนกลับจากแบตเตอรี่ไปยังแผงโซลาร์เซลล์ได้รับการป้องกันโดย Schottky diode D2 กระแสไฟเกินได้รับการป้องกันโดยฟิวส์ F1

5. LED บ่งชี้:

LED1, LED2 และ LED3 ใช้เพื่อระบุสถานะพลังงานแสงอาทิตย์ แบตเตอรี่ และโหลดตามลำดับ ตัวต้านทาน R9 ถึง R15 เป็นตัวต้านทานจำกัดกระแส

7. จอ LCD:

จอ LCD I2C ใช้เพื่อแสดงพารามิเตอร์ต่างๆ

8. การชาร์จ USB:

ช่องเสียบ USB ต่อเอาท์พุตสูงสุด 5V จาก Buck Converter

9. การรีเซ็ตระบบ:

SW1 เป็นปุ่มกดเพื่อรีเซ็ต Arduino

คุณสามารถดาวน์โหลดแผนผังในรูปแบบ PDF ที่แนบมาด้านล่าง

ขั้นตอนที่ 3: หน้าที่หลักของ Solar Charge Controller

ตัวควบคุมการชาร์จได้รับการออกแบบโดยดูแลประเด็นต่อไปนี้

1. ป้องกันการชาร์จแบตเตอรี่เกิน: เพื่อจำกัดพลังงานที่แผงโซลาร์เซลล์จ่ายให้กับแบตเตอรี่เมื่อแบตเตอรี่ชาร์จเต็ม สิ่งนี้ถูกนำไปใช้ใน charge_cycle() ของรหัสของฉัน

2. ป้องกันการคายประจุของแบตเตอรี่เกิน: เพื่อตัดการเชื่อมต่อแบตเตอรี่จากโหลดไฟฟ้าเมื่อแบตเตอรี่มีประจุเหลือน้อย สิ่งนี้ถูกนำไปใช้ใน load_control() ของรหัสของฉัน

3. จัดเตรียมฟังก์ชันการควบคุมโหลด: เพื่อเชื่อมต่อและตัดการเชื่อมต่อโหลดไฟฟ้าโดยอัตโนมัติตามเวลาที่กำหนด โหลดจะเปิดเมื่อพระอาทิตย์ตกและปิดเมื่อพระอาทิตย์ขึ้น สิ่งนี้ถูกนำไปใช้ใน load_control() ของรหัสของฉัน 4. การตรวจสอบพลังงานและพลังงาน: เพื่อตรวจสอบกำลังโหลดและพลังงานและแสดงผล

5. ป้องกันจากสภาวะผิดปกติ: เพื่อป้องกันวงจรจากสภาวะผิดปกติต่างๆ เช่น ฟ้าผ่า แรงดันไฟเกิน กระแสเกิน และไฟฟ้าลัดวงจร เป็นต้น

6. Indicating and Displaying: เพื่อระบุและแสดงพารามิเตอร์ต่างๆ

7. Serial Communication: เพื่อพิมพ์พารามิเตอร์ต่างๆในมอนิเตอร์แบบอนุกรม

8. การชาร์จ USB: เพื่อชาร์จอุปกรณ์อัจฉริยะ

ขั้นตอนที่ 4: การวัดแรงดัน

เซ็นเซอร์แรงดันไฟฟ้าใช้เพื่อตรวจจับแรงดันไฟฟ้าของแผงโซลาร์เซลล์และแบตเตอรี่ มันถูกใช้งานโดยใช้วงจรแบ่งแรงดันสองวงจร ประกอบด้วยตัวต้านทานสองตัว R1=100k และ R2=20k สำหรับตรวจจับแรงดันไฟของแผงโซลาร์เซลล์ และในทำนองเดียวกัน R3=100k และ R4=20k สำหรับแรงดันแบตเตอรี่ เอาต์พุตจาก R1 และ R2 เชื่อมต่อกับ Arduino analog pin A0 และเอาต์พุตจาก R3 และ R4 เชื่อมต่อกับ Arduino analog pin A1

การวัดแรงดันไฟฟ้า:อินพุตอนาล็อกของ Arduino สามารถใช้วัดแรงดัน DC ระหว่าง 0 ถึง 5V (เมื่อใช้แรงดันอ้างอิงอนาล็อกมาตรฐาน 5V) และช่วงนี้สามารถเพิ่มได้โดยใช้เครือข่ายตัวแบ่งแรงดันไฟฟ้า ตัวแบ่งแรงดันไฟฟ้าจะลดแรงดันไฟฟ้าที่วัดได้ภายในช่วงของอินพุตอนาล็อกของ Arduino

สำหรับวงจรแบ่งแรงดัน Vout = R2/(R1+R2) x Vin

วิน = (R1+R2)/R2 x Vout

ฟังก์ชัน analogRead() อ่านแรงดันไฟฟ้าและแปลงเป็นตัวเลขระหว่าง 0 ถึง 1023

การปรับเทียบ: เราจะอ่านค่าเอาต์พุตด้วยหนึ่งในอินพุตแบบอะนาล็อกของ Arduino และฟังก์ชัน analogRead () ฟังก์ชันนั้นส่งค่าระหว่าง 0 ถึง 1023 ที่ 0.00488V สำหรับการเพิ่มขึ้นแต่ละครั้ง (เป็น 5/1024 = 0.00488V)

วิน = Vout*(R1+R2)/R2; R1=100k และ R2=20k

Vin= จำนวน ADC*0.00488*(120/20) โวลต์ // ส่วนที่ไฮไลต์คือ Scale factor

หมายเหตุ: สิ่งนี้ทำให้เราเชื่อว่าการอ่าน 1,023 สอดคล้องกับแรงดันไฟฟ้าขาเข้าที่ 5.0 โวลต์พอดี ในทางปฏิบัติคุณอาจไม่ได้รับ 5V จาก Arduino pin 5V เสมอไป ดังนั้นระหว่างการสอบเทียบ ขั้นแรกให้วัดแรงดันไฟฟ้าระหว่างพิน 5v และ GND ของ Arduino โดยใช้มัลติมิเตอร์ และใช้สเกลแฟกเตอร์โดยใช้สูตรด้านล่าง:

ตัวประกอบมาตราส่วน = แรงดันที่วัดได้/1024

ขั้นตอนที่ 5: การวัดกระแส

สำหรับการวัดกระแส ฉันใช้เซ็นเซอร์กระแส Hall Effect รุ่น ACS 712 -5A เซ็นเซอร์ ACS712 มีสามรุ่นตามช่วงการตรวจจับปัจจุบัน เซ็นเซอร์ ACS712 อ่านค่าปัจจุบันและแปลงเป็นค่าแรงดันไฟฟ้าที่เกี่ยวข้อง ค่าที่เชื่อมโยงการวัดทั้งสองคือความไว ความไวของเอาต์พุตสำหรับตัวแปรทั้งหมดมีดังนี้:

รุ่น ACS712 -> ช่วงกระแสไฟ -> ความไว

ACS712 ELC-05 - > +/- 5A - > 185 mV/A

ACS712 ELC-20 - > +/- 20A - > 100 mV/A

ACS712 ELC-30 - > +/- 30A - > 66 mV/A

ในโครงการนี้ ฉันใช้ตัวแปร 5A ซึ่งมีความไว 185mV/A และแรงดันเซ็นเซอร์กลางคือ 2.5V เมื่อไม่มีกระแสไฟฟ้า

การสอบเทียบ:

ค่าการอ่านแบบอะนาล็อก = analogRead (พิน);

ค่า = (5/1024)*ค่าการอ่านแบบอะนาล็อก // หากคุณไม่ได้รับ 5V จากพิน Arduino 5V

กระแสในแอมป์ = (ค่า – offsetVoltage) / ความไว

แต่ตามข้อมูลแรงดันออฟเซ็ตของแผ่นข้อมูลคือ 2.5V และความไวคือ 185mV/A

กระแสไฟในแอมป์ = (Value-2.5)/0.185

ขั้นตอนที่ 6: การวัดอุณหภูมิ

เหตุใดจึงต้องมีการตรวจวัดอุณหภูมิ

ปฏิกิริยาเคมีของแบตเตอรี่จะเปลี่ยนไปตามอุณหภูมิ เมื่อแบตเตอรี่ร้อนขึ้น แก๊สก็จะเพิ่มขึ้น เมื่อแบตเตอรี่เย็นลง จะทนทานต่อการชาร์จมากขึ้น สิ่งสำคัญคือต้องปรับการชาร์จตามการเปลี่ยนแปลงของอุณหภูมิ ทั้งนี้ขึ้นอยู่กับอุณหภูมิของแบตเตอรี่ที่แตกต่างกัน ดังนั้นจึงเป็นเรื่องสำคัญที่จะต้องปรับการชาร์จให้เหมาะสมกับผลกระทบของอุณหภูมิ เซ็นเซอร์อุณหภูมิจะวัดอุณหภูมิของแบตเตอรี่ และ Solar Charge Controller จะใช้อินพุตนี้เพื่อปรับจุดตั้งค่าการชาร์จตามต้องการ ค่าชดเชยคือ - 5mv /degC/cell สำหรับแบตเตอรี่ประเภทตะกั่ว-กรด (–30mV/ºC สำหรับ 12V และ 15mV/ºC สำหรับแบตเตอรี่ 6V) เครื่องหมายลบของการชดเชยอุณหภูมิบ่งชี้ว่าอุณหภูมิที่เพิ่มขึ้นต้องลดค่าที่ตั้งไว้ สำหรับรายละเอียดเพิ่มเติม คุณสามารถติดตามบทความนี้

การวัดอุณหภูมิโดย DS18B20

ฉันใช้โพรบ DS18B20 ภายนอกเพื่อวัดอุณหภูมิของแบตเตอรี่ ใช้โปรโตคอลแบบสายเดียวเพื่อสื่อสารกับไมโครคอนโทรลเลอร์ สามารถต่อเข้ากับพอร์ต-J4 บนบอร์ดได้

หากต้องการเชื่อมต่อกับเซ็นเซอร์อุณหภูมิ DS18B20 คุณต้องติดตั้งไลบรารี One Wire และไลบรารี Dallas Temperature

คุณสามารถอ่านบทความนี้สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับเซ็นเซอร์ DS18B20

ขั้นตอนที่ 7: วงจรการชาร์จ USB

ตัวแปลงบั๊ก MP2307 ที่ใช้สำหรับจ่ายไฟสามารถจ่ายกระแสไฟได้ถึง 3A ดังนั้นจึงมีระยะขอบเพียงพอสำหรับการชาร์จอุปกรณ์ USB ช่องเสียบ USB VCC เชื่อมต่อกับ 5V และ GND เชื่อมต่อกับ GND คุณสามารถอ้างถึงแผนผังด้านบน

หมายเหตุ: แรงดันเอาต์พุต USB จะไม่อยู่ที่ 5V เมื่อกระแสโหลดเกิน 1A ดังนั้นฉันขอแนะนำให้จำกัดโหลด USB ที่ต่ำกว่า 1A

ขั้นตอนที่ 8: อัลกอริธึมการชาร์จ

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

ขั้นตอนที่ 1 การเรียกเก็บเงินจำนวนมาก:

Arduino จะเชื่อมต่อแผงโซลาร์เซลล์กับแบตเตอรี่โดยตรง (รอบการทำงาน 99%) แรงดันแบตเตอรี่จะค่อยๆเพิ่มขึ้น เมื่อแรงดันแบตเตอรี่ถึง 14.4V ระยะที่ 2 จะเริ่มต้นขึ้น

ในขั้นตอนนี้กระแสจะคงที่เกือบตลอดเวลา

ระยะที่ 2 ค่าการดูดซึม:

ในขั้นตอนนี้ Arduino จะควบคุมกระแสไฟชาร์จโดยรักษาระดับแรงดันไฟไว้ที่ 14.4 เป็นเวลาหนึ่งชั่วโมง แรงดันไฟฟ้าจะคงที่โดยการปรับรอบการทำงาน

ระยะที่ 3 ค่าธรรมเนียมลอยตัว:

คอนโทรลเลอร์สร้างประจุหยดเพื่อรักษาระดับแรงดันไฟไว้ที่ 13.5V ขั้นตอนนี้จะทำให้แบตเตอรี่ชาร์จจนเต็ม หากแรงดันแบตเตอรี่น้อยกว่า 13.2V เป็นเวลา 10 นาที

รอบการชาร์จจะถูกทำซ้ำ

ขั้นตอนที่ 9: การควบคุมการโหลด

ในการเชื่อมต่อและตัดการเชื่อมต่อโหลดโดยอัตโนมัติโดยการตรวจสอบเวลาพลบค่ำ/รุ่งเช้าและแรงดันแบตเตอรี่ การควบคุมโหลดจะถูกใช้

จุดประสงค์หลักของการควบคุมโหลดคือการปลดโหลดออกจากแบตเตอรี่เพื่อป้องกันการคายประจุที่ลึก การคายประจุอย่างลึกอาจทำให้แบตเตอรี่เสียหายได้

ขั้วโหลด DC ออกแบบมาสำหรับโหลด DC พลังงานต่ำ เช่น ไฟถนน

แผงเซลล์แสงอาทิตย์ใช้เป็นเซ็นเซอร์วัดแสง

สมมติว่าแรงดันแผงโซลาร์เซลล์> 5V หมายถึงรุ่งอรุณและเมื่อ <5V พลบค่ำ

เงื่อนไขการเปิด: ในตอนเย็น เมื่อระดับแรงดัน PV ต่ำกว่า 5V และแรงดันแบตเตอรี่สูงกว่าการตั้งค่า LVD ตัวควบคุมจะเปิดโหลดและไฟ LED สีเขียวของโหลดจะสว่างขึ้น

เงื่อนไข OFF: โหลดจะถูกตัดออกในสองเงื่อนไขต่อไปนี้

1. ในตอนเช้าเมื่อแรงดัน PV มากกว่า 5v

2. เมื่อแรงดันไฟฟ้าของแบตเตอรี่ต่ำกว่าการตั้งค่า LVD ไฟ LED สีแดงบนโหลดแสดงว่าโหลดถูกตัดออก

LVD เรียกว่า Low Voltage Disconnect

ขั้นตอนที่ 10: พลังงานและพลังงาน

พลังงาน: พลังงานเป็นผลคูณของแรงดัน (โวลต์) และกระแส (แอมป์)

P=VxI หน่วยของกำลังคือ วัตต์ หรือ KW

พลังงาน: พลังงานเป็นผลคูณของกำลัง (วัตต์) และเวลา (ชั่วโมง)

E= Pxt หน่วยของพลังงานคือวัตต์ชั่วโมงหรือกิโลวัตต์ชั่วโมง (kWh)

ในการตรวจสอบพลังงานและพลังงานเหนือตรรกะนั้นถูกนำไปใช้ในซอฟต์แวร์และพารามิเตอร์จะแสดงใน LCD ขนาด 20x4 ถ่าน

เครดิตภาพ: imgoat

ขั้นตอนที่ 11: การป้องกัน

1. ขั้วย้อนกลับและการป้องกันกระแสไฟย้อนกลับสำหรับแผงโซลาร์เซลล์

สำหรับขั้วย้อนกลับและการป้องกันกระแสย้อนกลับจะใช้ไดโอด Schottky (MBR2045)

2. การป้องกันการคายประจุเกินและลึก

ซอฟต์แวร์ใช้การป้องกันการชาร์จเกินและการปล่อยลึก

3. ไฟฟ้าลัดวงจรและป้องกันการโอเวอร์โหลด

การป้องกันการลัดวงจรและการโอเวอร์โหลดทำได้โดยฟิวส์ F1

4.การป้องกันแรงดันไฟเกินที่อินพุตแผงโซลาร์เซลล์

แรงดันไฟเกินชั่วคราวเกิดขึ้นในระบบไฟฟ้าด้วยเหตุผลหลายประการ แต่ฟ้าผ่าทำให้เกิดแรงดันไฟเกินที่รุนแรงที่สุด โดยเฉพาะอย่างยิ่งกับระบบ PV เนื่องจากตำแหน่งที่เปิดโล่งและสายเคเบิลเชื่อมต่อระบบ ในการออกแบบใหม่นี้ ฉันใช้ไดโอด TVS แบบสองทิศทาง 600 วัตต์ (P6KE36CA) เพื่อระงับฟ้าผ่าและแรงดันไฟฟ้าเกินที่ขั้ว PV

เครดิตภาพ: freeimages

ขั้นตอนที่ 12: ไฟ LED แสดงสถานะ

1. ไฟ LED พลังงานแสงอาทิตย์: LED1 ไฟ LED สองสี (สีแดง/เขียว) ใช้สำหรับระบุสถานะพลังงานแสงอาทิตย์ เช่น พลบค่ำหรือรุ่งอรุณ

ไฟ LED พลังงานแสงอาทิตย์ ------------------- สถานะพลังงานแสงอาทิตย์

กรีน ----------------------- เดย์

RED ------------------------- กลางคืน

2. ไฟ LED แสดงสถานะการชาร์จ (SOC) ของแบตเตอรี่: LED2

พารามิเตอร์สำคัญอย่างหนึ่งที่กำหนดปริมาณพลังงานของแบตเตอรี่คือสถานะการชาร์จ (SOC) พารามิเตอร์นี้ระบุว่ามีประจุเท่าใดในแบตเตอรี่ RGB LED ใช้เพื่อระบุสถานะการชาร์จของแบตเตอรี่ สำหรับการเชื่อมต่อ อ้างถึงแผนผังด้านบน

LED แบตเตอรี่ ---------- สถานะแบตเตอรี่

สีแดง ------------------ แรงดันไฟต่ำ

สีเขียว ------------------ แรงดันไฟแข็งแรง

BLUE ------------------ ชาร์จเต็มแล้ว

2. โหลด LED: LED3

ไฟ LED สองสี (แดง/เขียว) ใช้สำหรับแสดงสถานะการโหลด อ้างถึงแผนผังด้านบนสำหรับการเชื่อมต่อ

โหลด LED ------------------- สถานะโหลด

สีเขียว ----------------------- เชื่อมต่อแล้ว (เปิด)

สีแดง ------------------------- ตัดการเชื่อมต่อ (ปิด)

ขั้นตอนที่ 13: จอแสดงผล LCD

จอแอลซีดีถ่านขนาด 20X4 ใช้สำหรับตรวจสอบพารามิเตอร์แผงโซลาร์เซลล์ แบตเตอรี่ และโหลด

เพื่อความเรียบง่าย จอ LCD I2C ถูกเลือกสำหรับโปรเจ็กต์นี้ ต้องการเพียง 4 สายเพื่อเชื่อมต่อกับ Arduino

การเชื่อมต่ออยู่ด้านล่าง:

จอแอลซีดี Arduino

วีซีซี 5V, GNDGND, SDAA4, SCLA5

แถวที่ 1: แรงดันไฟแผงโซลาร์เซลล์ กระแสไฟ และกำลังไฟฟ้า

แถวที่ 2: แรงดันแบตเตอรี่ อุณหภูมิ และสถานะเครื่องชาร์จ (กำลังชาร์จ / ไม่ชาร์จ)

แถวที่ 3: โหลดกระแสไฟ กำลัง และสถานะโหลด

แถวที่ 4: พลังงานอินพุตจากแผงโซลาร์เซลล์และพลังงานที่ใช้โดยโหลด

คุณต้องดาวน์โหลดไลบรารีจาก LiquidCrystal_I2C

ขั้นตอนที่ 14: การสร้างต้นแบบและการทดสอบ

1. เขียงหั่นขนม:

ก่อนอื่นฉันสร้างวงจรบนเขียงหั่นขนม ข้อได้เปรียบหลักของเขียงหั่นขนมแบบบัดกรีคือไม่มีบัดกรี ดังนั้น คุณสามารถเปลี่ยนการออกแบบได้อย่างง่ายดายเพียงแค่ถอดปลั๊กส่วนประกอบและสายนำออกตามที่คุณต้องการ

2. กระดานปรุ:

หลังจากทำการทดสอบเขียงหั่นขนม ฉันสร้างวงจรบนบอร์ดที่มีรูพรุน เพื่อให้เป็นไปตามคำแนะนำด้านล่าง

i) ขั้นแรกให้ใส่ชิ้นส่วนทั้งหมดลงในรูของ Perforated-Board

ii) ประสานแผ่นส่วนประกอบทั้งหมดและตัดขาพิเศษด้วยก้าม

iii) เชื่อมต่อแผ่นบัดกรีโดยใช้สายไฟตามแผนผัง

iv) ใช้ข้อขัดแย้งเพื่อแยกวงจรออกจากพื้น

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

ขั้นตอนที่ 15: การออกแบบ PCB

ฉันวาดแผนผังโดยใช้ซอฟต์แวร์ออนไลน์ EasyEDA หลังจากนั้นเปลี่ยนเป็นเค้าโครง PCB

ส่วนประกอบทั้งหมดที่คุณเพิ่มในแผนผังควรอยู่ที่นั่น ซ้อนกัน พร้อมที่จะวางและกำหนดเส้นทาง ลากส่วนประกอบโดยจับที่แผ่นรอง แล้ววางลงในแนวขอบสี่เหลี่ยม

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

ตอนนี้คุณต้องกำหนดเส้นทาง การกำหนดเส้นทางเป็นส่วนที่สนุกที่สุดของกระบวนการทั้งหมดนี้ มันเหมือนกับการไขปริศนา! การใช้เครื่องมือติดตามเราจำเป็นต้องเชื่อมต่อส่วนประกอบทั้งหมด คุณสามารถใช้ทั้งชั้นบนและชั้นล่างเพื่อหลีกเลี่ยงการทับซ้อนกันระหว่างสองแทร็กที่แตกต่างกันและทำให้แทร็กสั้นลง

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

ตอนนี้ PCB พร้อมสำหรับการผลิตแล้ว

ขั้นตอนที่ 16: ดาวน์โหลดไฟล์ Gerber

หลังจากสร้าง PCB แล้ว เราต้องสร้างไฟล์ที่สามารถส่งไปยังบริษัทผลิต PCB ได้ ซึ่งจะส่ง PCB จริงบางส่วนกลับมาให้เรา

ใน EasyEDA คุณสามารถส่งออกไฟล์ Fabrication (ไฟล์ Gerber) ผ่าน Document > Generate Gerber หรือโดยการคลิกปุ่ม Generate Gerber จากแถบเครื่องมือ ไฟล์ Gerber ที่สร้างขึ้นนั้นเป็นแพ็คเกจที่บีบอัด หลังจากคลายการบีบอัด คุณจะเห็นไฟล์ 8 ไฟล์ต่อไปนี้:

1. ทองแดงด้านล่าง:.gbl

2. ทองแดงด้านบน:.gtl

3. มาสก์บัดกรีด้านล่าง:.gbs

4.หน้ากากบัดกรียอดนิยม:.gts

5. หน้าจอไหมด้านล่าง:.gbo

6. หน้าจอไหมยอดนิยม:.gto

7. สว่าน:.drl

8.เค้าร่าง:.เค้าร่าง

คุณสามารถดาวน์โหลดไฟล์ Gerber ได้จาก PCBWay

เมื่อคุณสั่งซื้อจาก PCBWay ฉันจะได้รับเงินบริจาค 10% จาก PCBWay สำหรับผลงานของฉัน ความช่วยเหลือเล็กๆ น้อยๆ ของคุณอาจกระตุ้นให้ฉันทำงานที่ยอดเยี่ยมกว่านี้ในอนาคต ขอบคุณสำหรับความร่วมมือ.

ขั้นตอนที่ 17: การผลิต PCB

ถึงเวลาค้นหาผู้ผลิต PCB ที่สามารถเปลี่ยนไฟล์ Gerber ของเราให้เป็น PCB จริงได้ ฉันได้ส่งไฟล์ Gerber ไปที่ JLCPCB เพื่อผลิต PCB ของฉันแล้ว บริการของพวกเขาดีมาก ฉันได้รับ PCB ของฉันในอินเดียภายใน 10 วัน

BOM สำหรับโครงการแนบมาด้านล่าง

ขั้นตอนที่ 18: การบัดกรีส่วนประกอบ

หลังจากได้รับบอร์ดจาก PCB fab house คุณต้องประสานส่วนประกอบต่างๆ

สำหรับการบัดกรี คุณจะต้องใช้หัวแร้ง บัดกรี ก้าม ไส้ตะเกียงหรือปั๊ม และมัลติมิเตอร์ที่เหมาะสม

เป็นการดีที่จะประสานส่วนประกอบตามความสูง ประสานส่วนประกอบที่มีความสูงน้อยกว่าก่อน

คุณสามารถทำตามขั้นตอนต่อไปนี้เพื่อประสานส่วนประกอบ:

1. ดันขาส่วนประกอบผ่านรู แล้วหมุน PCB ที่ด้านหลัง

2. จับปลายหัวแร้งกับทางแยกของแผ่นอิเล็กโทรดและขาของส่วนประกอบ

3. ป้อนบัดกรีเข้าไปในข้อต่อเพื่อให้ไหลไปทั่วตะกั่วและปิดแผ่น เมื่อมันไหลไปทั่วแล้วให้ขยับปลายออกไป

4. ตัดขาส่วนเกินโดยใช้ก้าม

ปฏิบัติตามกฎข้างต้นสำหรับการบัดกรีส่วนประกอบทั้งหมด

ขั้นตอนที่ 19: การติดตั้งเซ็นเซอร์กระแส ACS712

เซ็นเซอร์กระแส ACS712 ที่ฉันได้รับมีขั้วต่อสกรูที่บัดกรีไว้ล่วงหน้าสำหรับการเชื่อมต่อ ในการบัดกรีโมดูลโดยตรงบนบอร์ด PCB คุณต้องถอดขั้วต่อสกรูออกก่อน

ฉันถอดขั้วสกรูด้วยความช่วยเหลือของปั๊มแยกบัดกรีดังที่แสดงด้านบน

จากนั้นฉันก็ประสานโมดูล ACS712 กลับด้าน

ในการเชื่อมต่อขั้ว Ip+ และ Ip- กับ PCB ฉันใช้ขาเทอร์มินัลไดโอด

ขั้นตอนที่ 20: การเพิ่ม Buck Converter

ในการประสานโมดูล Buck Converter คุณต้องเตรียมหมุดส่วนหัวแบบตรง 4 อันดังที่แสดงด้านบน

ประสานหมุดส่วนหัว 4 ตัวที่ X1, 2 อันสำหรับเอาต์พุตและอีกสองตัวที่เหลือสำหรับอินพุต

ขั้นตอนที่ 21: การเพิ่ม Arduino Nano

เมื่อคุณซื้อหัวต่อแบบตรง มันจะยาวเกินไปสำหรับ Arduino Nano คุณจะต้องตัดมันให้มีความยาวที่เหมาะสม ซึ่งหมายถึง 15 พินแต่ละอัน

วิธีที่ดีที่สุดในการตัดส่วนหัวของตัวเมียคือการนับ 15 พิน ดึงพินที่ 16 จากนั้นใช้คีมตัดช่องว่างระหว่างพินที่ 15 และ 17

ตอนนี้เราต้องติดตั้งส่วนหัวของตัวเมียบน PCB นำส่วนหัวของผู้หญิงแล้ววางไว้บนส่วนหัวของผู้ชายบนบอร์ด Arduino Nano

จากนั้นประสานหมุดส่วนหัวของตัวเมียเข้ากับ Charge Controller PCB

ขั้นตอนที่ 22: การเตรียม MOSFETs

ก่อนทำการบัดกรี MOSFETs Q1 Q2 และ diode D1 บน PCB ควรติดฮีทซิงค์เข้ากับตัวระบายความร้อนก่อน ฮีตซิงก์ใช้เพื่อย้ายความร้อนออกจากอุปกรณ์เพื่อรักษาอุณหภูมิของอุปกรณ์ให้ต่ำลง

ใช้ชั้นของสารประกอบฮีทซิงค์เหนือแผ่นฐานโลหะ MOSFET จากนั้นวางแผ่นนำความร้อนไว้ระหว่าง MOSFET กับแผ่นระบายความร้อน แล้วขันสกรูให้แน่น คุณสามารถอ่านบทความนี้เกี่ยวกับสาเหตุที่แผงระบายความร้อนมีความสำคัญ

สุดท้ายประสานเข้ากับ PCB ตัวควบคุมการประจุ

ขั้นตอนที่ 23: การติดตั้ง Standoffs

หลังจากบัดกรีชิ้นส่วนทั้งหมดแล้ว ให้ติดตั้งแท่นรองที่มุมทั้ง 4 ฉันใช้ M3 Brass Hex Standoffs

การใช้ standoffs จะช่วยให้มีช่องว่างเพียงพอสำหรับข้อต่อบัดกรีและสายไฟจากพื้นดิน

ขั้นตอนที่ 24: ซอฟต์แวร์และไลบรารี

ขั้นแรก ดาวน์โหลดรหัส Arduino ที่แนบมา จากนั้นดาวน์โหลดไลบรารีต่อไปนี้และติดตั้ง

1. หนึ่งสาย

2. อุณหภูมิดัลลัส

3. LiquidCrystal_I2C

4. ห้องสมุด PID

รหัสทั้งหมดถูกแบ่งออกเป็นบล็อกการทำงานขนาดเล็กเพื่อความยืดหยุ่น สมมติว่าผู้ใช้ไม่สนใจที่จะใช้จอ LCD และพอใจกับสัญญาณไฟ LED จากนั้นเพียงแค่ปิดการใช้งาน lcd_display() จาก void loop() นั่นคือทั้งหมดที่ ในทำนองเดียวกัน ตามความต้องการของผู้ใช้ เขาสามารถเปิดและปิดฟังก์ชันการทำงานต่างๆ ได้

หลังจากติดตั้งไลบรารี่ด้านบนทั้งหมดแล้ว ให้อัปโหลดโค้ด Arduino

หมายเหตุ: ตอนนี้ฉันกำลังทำงานกับซอฟต์แวร์เพื่อใช้อัลกอริธึมการชาร์จที่ดีขึ้น โปรดติดต่อเพื่อรับเวอร์ชันล่าสุด

อัพเดทเมื่อ 02.04.2020

อัปโหลดซอฟต์แวร์ใหม่พร้อมอัลกอริธึมการชาร์จที่ปรับปรุงแล้วและการนำตัวควบคุม PID ไปใช้

ขั้นตอนที่ 25: การทดสอบขั้นสุดท้าย

เชื่อมต่อขั้วแบตเตอรี่ตัวควบคุมการชาร์จ (BAT) กับแบตเตอรี่ 12V ตรวจสอบให้แน่ใจว่าขั้วถูกต้อง หลังจากเชื่อมต่อแล้ว LED และ LCD จะเริ่มทำงานทันที คุณจะสังเกตเห็นแรงดันไฟและอุณหภูมิของแบตเตอรี่ที่แถวที่ 2 ของจอ LCD

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

ขั้นตอนการทดสอบแสดงในวิดีโอสาธิตนี้

ในอนาคต ฉันจะออกแบบกล่องที่พิมพ์ 3 มิติสำหรับโครงการนี้ ติดต่อกัน.

โครงการนี้เป็นผลงานในการประกวด PCB โปรดลงคะแนนให้ฉัน โหวตของคุณเป็นแรงบันดาลใจให้ฉันทำงานหนักขึ้นเพื่อเขียนโครงการที่เป็นประโยชน์มากขึ้นเช่นนี้

ขอบคุณที่อ่านคำแนะนำของฉัน หากคุณชอบโครงการของฉันอย่าลืมแชร์

ความคิดเห็นและข้อเสนอแนะยินดีต้อนรับเสมอ

รองชนะเลิศในการแข่งขันการออกแบบ PCB