แอมแปร์และโวลต์มิเตอร์จาก Arduino Uno โวลต์มิเตอร์ลับใน Arduino - วัดแรงดันแบตเตอรี่โดยใช้ไมโครคอนโทรลเลอร์ เขียนและอ่านข้อมูลพอร์ตอนุกรม

สวัสดีฮับ! วันนี้ฉันต้องการที่จะสานต่อหัวข้อ "การข้าม" Arduino และ Android ใน สิ่งพิมพ์ก่อนหน้าฉันพูดถึงเรื่องนี้แล้ว และวันนี้เราจะมาพูดถึง DIY บลูทูธโวลต์มิเตอร์- อุปกรณ์อื่นดังกล่าวสามารถเรียกว่าโวลต์มิเตอร์อัจฉริยะ โวลต์มิเตอร์ "อัจฉริยะ" หรือเพียงแค่โวลต์มิเตอร์อัจฉริยะ โดยไม่มีเครื่องหมายคำพูด นามสกุลไม่ถูกต้องจากมุมมองของไวยากรณ์รัสเซีย แต่มักพบในสื่อ ในตอนท้ายของบทความจะมีการลงคะแนนในหัวข้อนี้ แต่ฉันขอแนะนำให้เริ่มต้นด้วยการสาธิตการทำงานของอุปกรณ์เพื่อทำความเข้าใจว่าบทความจะเกี่ยวกับอะไร

ร่าง

อินพุทอนาล็อกอินพุท = A0;
วาลลอยตัว = 0.0;
แรงดันลอย = 0.0;
ลอย R1 = 100,000.0; //แบตเตอรี่ Vin-> 100K -> A0
ลอย R2 = 10,000.0; // แบตเตอรี่ Gnd -> Arduino Gnd และ Arduino Gnd -> 10K -> A0
ค่า int = 0;

การตั้งค่าเป็นโมฆะ() (
อนุกรมเริ่มต้น(9600);
pinMode (อินพุตอะนาล็อก, อินพุต);
}

โมฆะวน() (
ค่า = analogRead (analogInput);
วาล = (ค่า * 4.7) / 1,024.0;
แรงดันไฟฟ้า = วาล / (R2/(R1+R2));
Serial.println (แรงดันไฟฟ้า);
ล่าช้า (500);
}

อินพุตแบบอะนาล็อกของบอร์ด Arduino

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

พินเหล่านี้มีหมายเลข 14 ถึง 19 โดยเริ่มแรกกำหนดค่าเป็นอินพุตอะนาล็อก และสามารถเข้าถึงได้โดยใช้ชื่อ A0-A5 สามารถกำหนดค่าให้เป็นโหมดเอาท์พุตแยกได้ตลอดเวลา

pinMode(A3, เอาท์พุต); - การตั้งค่าโหมดเอาต์พุตแยกสำหรับ A3
digitalWrite (A3, ต่ำ); - การตั้งค่าเอาต์พุต A3 ต่ำ

หากต้องการกลับสู่โหมดอินพุตแบบอะนาล็อก:

pinMode(A3, อินพุต); - การตั้งค่าโหมดอินพุตแบบอะนาล็อกสำหรับ A3

อินพุตแบบอะนาล็อกและตัวต้านทานแบบดึงขึ้น

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

digitalWrite (A3, สูง); - เปิดตัวต้านทานแบบดึงขึ้นเพื่ออินพุต A3

ต้องใช้คำสั่งกับพินที่กำหนดค่าในโหมดอินพุต

ต้องจำไว้ว่าตัวต้านทานอาจส่งผลต่อระดับสัญญาณอินพุตแบบอะนาล็อก กระแสไฟฟ้าจากแหล่งจ่ายไฟ 5V ผ่านตัวต้านทานแบบดึงขึ้น จะทำให้แรงดันไฟฟ้าตกคร่อมความต้านทานภายในของแหล่งสัญญาณ ดังนั้นจึงควรถอดตัวต้านทานออกจะดีกว่า

ตัวแปลงอนาล็อกเป็นดิจิตอลของบอร์ด Arduino

ทำการวัดแรงดันไฟฟ้าจริงที่อินพุต ตัวแปลงอนาล็อกเป็นดิจิทัล(ADC) พร้อมสวิตช์ 6 ช่อง ADC มีความละเอียด 10 บิต ซึ่งสอดคล้องกับโค้ดที่เอาต์พุตของตัวแปลง 0...1023 ข้อผิดพลาดในการวัดไม่เกิน 2 หน่วยของหลักที่มีนัยสำคัญน้อยที่สุด

เพื่อรักษาความแม่นยำสูงสุด (10 หลัก) จึงมีความจำเป็นที่ ความต้านทานภายในแหล่งสัญญาณไม่เกิน 10 kOhm ข้อกำหนดนี้มีความสำคัญอย่างยิ่งเมื่อใช้ตัวแบ่งตัวต้านทานที่เชื่อมต่อกับอินพุตอะนาล็อกของบอร์ด ความต้านทานของตัวต้านทานตัวแบ่งต้องไม่สูงเกินไป

ฟังก์ชั่นซอฟต์แวร์อินพุตแบบอะนาล็อก

int analogRead (พอร์ต)

อ่านค่าแรงดันไฟฟ้าที่อินพุตอนาล็อกที่ระบุ แรงดันไฟฟ้าอินพุตมีตั้งแต่ 0 ถึงระดับแรงดันอ้างอิง (มักเป็น 5 V) แปลงเป็นรหัสตั้งแต่ 0 ถึง 1,023

ด้วยแรงดันอ้างอิง 5 V ความละเอียดคือ 5 V / 1024 = 4.88 mV

การแปลงใช้เวลาประมาณ 100 μs

int inputCod; - รหัส แรงดันไฟฟ้าขาเข้า
แรงดันไฟฟ้าอินพุตลอย; - แรงดันไฟฟ้าขาเข้าใน V

inputCod= แอนะล็อกอ่าน(A3); - อ่านแรงดันไฟฟ้าที่อินพุต A3
inputVoltage= ((ลอย)inputCod * 5. / 1024.); - การแปลงรหัสเป็นแรงดันไฟฟ้า (V)

เป็นโมฆะการอ้างอิงแบบอะนาล็อก (ชนิด)

ตั้งค่าแรงดันอ้างอิงสำหรับ ADC มันกำหนด ค่าสูงสุดแรงดันไฟฟ้าที่อินพุตแบบอะนาล็อกซึ่ง ADC สามารถแปลงได้อย่างถูกต้อง ค่าของแรงดันอ้างอิงยังกำหนดปัจจัยการแปลงรหัสเป็นแรงดันไฟฟ้าด้วย:

แรงดันไฟฟ้าขาเข้า = รหัส ADC * แรงดันอ้างอิง / 1024

อาร์กิวเมนต์ประเภทสามารถรับค่าต่อไปนี้:

• ค่าเริ่มต้น – แรงดันอ้างอิงเท่ากับแรงดันแหล่งจ่ายไฟของตัวควบคุม (5 V หรือ 3.3 V) สำหรับ Arduino UNO R3 – 5 V.
• ภายใน – แรงดันอ้างอิงภายใน 1.1 V สำหรับบอร์ดที่มีตัวควบคุม ATmega168 และ ATmega328 สำหรับ ATmega8 – 2.56 V.
• INTERNAL1V1 – แรงดันอ้างอิงภายใน 1.1 V สำหรับ คอนโทรลเลอร์ Arduinoเมก้า.
• INTERNAL2V56 – แรงดันอ้างอิงภายใน 2.56 V สำหรับคอนโทรลเลอร์ Arduino Mega
• ภายนอก – แหล่งภายนอกแรงดันอ้างอิงที่เชื่อมต่อกับอินพุต AREF

การอ้างอิงแบบอะนาล็อก (ภายใน); - แรงดันอ้างอิงคือ 1.1 V

โวลต์มิเตอร์สองช่องสัญญาณบน Arduino

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

ลองตัดสินใจว่าโวลต์มิเตอร์ควรวัดแรงดันไฟฟ้าในช่วงอย่างน้อย 0...20 V และพัฒนาวงจรสำหรับเชื่อมต่ออินพุตโวลต์มิเตอร์เข้ากับบอร์ด Arduino UNO

หากเราตั้งค่าแรงดันอ้างอิงเป็น 5 V อินพุตแบบอะนาล็อกของบอร์ดจะวัดแรงดันไฟฟ้าภายใน 0...5 V และเราต้องการอย่างน้อย 0...20 V ซึ่งหมายความว่าเราจำเป็นต้องใช้ตัวแบ่งแรงดันไฟฟ้า

แรงดันไฟฟ้าที่อินพุตและเอาต์พุตของตัวแบ่งมีความสัมพันธ์กันตามความสัมพันธ์:

Uoutput = (Uinput / (R1 + R2)) * R2

อัตราส่วนการส่ง:

K = Uoutput / Uinput = R2 / (R1 + R2)

เราต้องการอัตราส่วนการถ่ายโอน 1/4 (20 V * 1/4 = 5 V)

เพื่อรักษาความแม่นยำสูงสุด (10 บิต) ความต้านทานภายในของแหล่งสัญญาณจำเป็นจะต้องไม่เกิน 10 kOhm ดังนั้นเราจึงเลือกตัวต้านทาน R2 เท่ากับ 4.22 kOhm เราคำนวณความต้านทานของตัวต้านทาน R1

0.25 = 4.22 / (R1 + 4.22)
R1 = 4.22 / 0.25 – 4.22 = 12.66 โอห์ม

ฉันพบตัวต้านทานที่มีความต้านทาน 15 kOhm โดยมีค่าใกล้เคียงที่สุด ด้วยตัวต้านทาน R1 = 15 kOhm และ R2 = 4.22:

5 / (4.22 / (15 + 4.22)) = 22.77 โวลต์

วงจรโวลต์มิเตอร์ที่ใช้ Arduino จะมีลักษณะเช่นนี้

ตัวแบ่งแรงดันไฟฟ้าสองตัวเชื่อมต่อกับอินพุตอะนาล็อก A0 และ A1 ตัวเก็บประจุ C1 และ C2 พร้อมด้วยตัวต้านทานตัวแบ่งจะสร้างตัวกรองความถี่ต่ำผ่านเพื่อขจัดสัญญาณรบกวนความถี่สูงออกจากสัญญาณ

ฉันประกอบวงจรนี้ไว้บนเขียงหั่นขนม

ฉันเชื่อมต่ออินพุตแรกของโวลต์มิเตอร์เข้ากับแหล่งพลังงานที่มีการควบคุมและอินพุตที่สองกับแหล่งจ่ายไฟ 3.3 V ของบอร์ด Arduino เพื่อตรวจสอบแรงดันไฟฟ้า ฉันเชื่อมต่อโวลต์มิเตอร์เข้ากับอินพุตแรก สิ่งที่เหลืออยู่คือการเขียนโปรแกรม

โปรแกรมสำหรับวัดแรงดันไฟฟ้าโดยใช้บอร์ด Arduino

อัลกอริธึมนั้นง่าย จำเป็น:

• อ่านรหัส ADC สองครั้งต่อวินาที
• แปลงเป็นแรงดันไฟฟ้า
• ส่งค่าที่วัดได้ผ่านพอร์ตอนุกรมไปยังคอมพิวเตอร์
• โปรแกรมตรวจสอบพอร์ต อาร์ดูโน่ IDEแสดงค่าแรงดันไฟฟ้าที่ได้รับบนหน้าจอคอมพิวเตอร์

ฉันจะให้ภาพร่างโปรแกรมฉบับสมบูรณ์แก่คุณทันที

// โปรแกรมวัดแรงดันไฟฟ้า
// บนอินพุตอะนาล็อก A0 และ A1

#รวม

ระยะเวลาการวัด
#define R1 15. // ความต้านทานของตัวต้านทาน R1
#define R2 4.22 // ความต้านทานของตัวต้านทาน R2

ลอย u1, u2; - แรงดันไฟฟ้าที่วัดได้

การตั้งค่าเป็นโมฆะ () (
อนุกรมเริ่มต้น(9600); -

MsTimer2::เริ่มต้น(); - ขัดจังหวะเปิดใช้งาน
}

เป็นโมฆะวน() (

// ระยะเวลา 500 มิลลิวินาที
ถ้า (การนับเวลา >= MEASURE_PERIOD) (
นับเวลา= 0;

//

// อ่านโค้ดช่อง 2 แล้วแปลงเป็นแรงดัน
u2= ((ลอย)อ่านอนาล็อก(A1)) * 5. / 1024. / R2 * (R1 + R2);

// ถ่ายโอนข้อมูลผ่านทาง พอร์ตอนุกรม
Serial.print("U1 = "); Serial.พิมพ์(u1, 2);
Serial.print(" U2 = "); อนุกรม.println(u2, 2);
}
}

// ขัดจังหวะการประมวลผล 1 ms
โมฆะจับเวลาขัดจังหวะ () (
นับเวลา++;
}

ให้ฉันอธิบายบรรทัดที่รหัส ADC ถูกแปลงเป็นแรงดันไฟฟ้า:

// อ่านโค้ดช่อง 1 แล้วแปลงเป็นแรงดัน
u1= ((ลอย)อ่านอนาล็อก(A0)) * 5. / 1024. / R2 * (R1 + R2);

• อ่านรหัส ADC: analogRead(A0)
• แปลงเป็นรูปแบบจุดลอยตัวอย่างชัดเจน: (float)
• แปลงเป็นแรงดันไฟฟ้าที่อินพุตแบบอะนาล็อก: * 5. / 1024 จุดที่ท้ายตัวเลขแสดงว่านี่คือตัวเลขทศนิยม
• ค่าสัมประสิทธิ์การส่งผ่านของตัวแบ่งถูกนำมาพิจารณา: / R2 * (R1 + R2)

มาโหลดโปรแกรมลงในบอร์ดแล้วเปิดมอนิเตอร์พอร์ตอนุกรม

แถบวิ่งสองแถบแสดงค่าของแรงดันไฟฟ้าที่วัดได้ ทุกอย่างทำงานได้

การวัดค่าสัญญาณเฉลี่ย

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

ค่าแรงดันไฟฟ้าของช่องแรกบนหน้าจอมอนิเตอร์จะกระตุกและกระโดดอยู่ตลอดเวลา และการอ่านค่าของโวลต์มิเตอร์ควบคุมค่อนข้างเสถียร เนื่องจากโวลต์มิเตอร์อ้างอิงจะวัดค่าเฉลี่ยของสัญญาณ ในขณะที่บอร์ด Arduino อ่านตัวอย่างแต่ละรายการทุกๆ 500 มิลลิวินาที โดยปกติแล้ว ช่วงเวลาของการอ่าน ADC จะตกอยู่ในช่วงนั้น จุดที่แตกต่างกันสัญญาณ. และเมื่อ ระดับสูงแอมพลิจูดของการเต้นที่จุดเหล่านี้แตกต่างกัน

นอกจากนี้ หากอ่านสัญญาณในตัวอย่างกระจัดกระจายแยกกัน สัญญาณรบกวนที่เกิดจากแรงกระตุ้นอาจทำให้เกิดข้อผิดพลาดที่สำคัญในการวัดได้

วิธีแก้ไขคือการเก็บตัวอย่างหลายๆ ตัวอย่างบ่อยๆ และหาค่าเฉลี่ยของค่าที่วัดได้ สำหรับสิ่งนี้:

• ในตัวจัดการการขัดจังหวะเราอ่านโค้ด ADC และรวมเข้ากับตัวอย่างก่อนหน้า
• นับเวลาเฉลี่ย (จำนวนตัวอย่างเฉลี่ย)
• เมื่อไปถึง หมายเลขที่กำหนดตัวอย่าง – เราบันทึกมูลค่ารวมของรหัส ADC
• หากต้องการหาค่าเฉลี่ย ให้หารผลรวมของรหัส ADC ด้วยจำนวนตัวอย่างเฉลี่ย

ปัญหาจากหนังสือเรียนคณิตศาสตร์ชั้นประถมศึกษาปีที่ 8 นี่คือภาพร่างของโปรแกรม ซึ่งเป็นโวลต์มิเตอร์ค่าเฉลี่ยแบบสองช่องสัญญาณ

// โปรแกรมวัดแรงดันไฟฟ้าปานกลาง
// บนอินพุตอะนาล็อก A0 และ A1

#รวม

#define MEASURE_PERIOD 500 // ระยะเวลาการวัด
#define R1 15. // ความต้านทานของตัวต้านทาน R1
#define R2 4.22 // ความต้านทานของตัวต้านทาน R2

int นับเวลา; //เครื่องนับเวลา
sumU1 ยาว, sumU2; - ตัวแปรสำหรับการรวมรหัส ADC
ค่าเฉลี่ย U1 ยาว, ค่าเฉลี่ย U2; - ผลรวมของรหัส ADC (ค่าเฉลี่ย * 500)
ธงบูลีนพร้อม; - ตัวบ่งชี้ความพร้อมของข้อมูลการวัด

การตั้งค่าเป็นโมฆะ () (
อนุกรมเริ่มต้น(9600); - เริ่มต้นพอร์ตความเร็ว 9600
MsTimer2::set(1, ตัวจับเวลาอินเตอร์อัพ); - ตัวจับเวลาขัดจังหวะ ระยะเวลา 1 ms
MsTimer2::เริ่มต้น(); - ขัดจังหวะเปิดใช้งาน
}

เป็นโมฆะวน() (

ถ้า (flagReady == จริง) (
flagReady=เท็จ;
// การแปลงเป็นแรงดันไฟฟ้าและถ่ายโอนไปยังคอมพิวเตอร์
Serial.print("U1 = ");
Serial.print((ลอย)avarageU1 / 500. * 5. / 1024. / R2 * (R1 + R2), 2);
Serial.print(" U2 = ");
Serial.println((ลอย)avarageU2 / 500. * 5. / 1024. / R2 * (R1 + R2), 2);
}
}

// ขัดจังหวะการประมวลผล 1 ms
โมฆะจับเวลาขัดจังหวะ () (

นับเวลา++; - +1 ตัวนับตัวอย่างเฉลี่ย
sumU1+= อะนาล็อกอ่าน(A0); - สรุปรหัส ADC
sumU2+= อะนาล็อกอ่าน(A1); - สรุปรหัส ADC

// การตรวจสอบจำนวนตัวอย่างเฉลี่ย
ถ้า (การนับเวลา >= MEASURE_PERIOD) (
นับเวลา= 0;
ค่าเฉลี่ย U1= ผลรวม U1; - เกินค่าเฉลี่ย
avarageU2= ผลรวม U2; - เกินค่าเฉลี่ย
ผลรวมU1= 0;
ผลรวมU2= 0;
flagReady= จริง; - ผลการวัดสัญญาณพร้อมแล้ว
}
}

ในสูตรการแปลงรหัส ADC เป็นแรงดันไฟฟ้า /500 ถูกเพิ่ม - จำนวนตัวอย่าง โหลด เปิดมอนิเตอร์พอร์ต (Cntr+Shift+M)

ตอนนี้ถึงแม้จะมีการเต้นเป็นจังหวะในระดับที่มีนัยสำคัญ แต่การอ่านก็เปลี่ยนไปเป็นร้อย นี่เป็นเพียงเพราะแรงดันไฟฟ้าไม่เสถียร

ต้องเลือกจำนวนตัวอย่างโดยคำนึงถึง:

• จำนวนตัวอย่างจะกำหนดเวลาในการวัด
• ยังไง จำนวนที่มากขึ้นตัวอย่างอิทธิพลของเสียงก็จะน้อยลงเท่านั้น

แหล่งที่มาหลักของการรบกวนใน สัญญาณอะนาล็อกเป็นเครือข่ายความถี่ 50 Hz ดังนั้นจึงแนะนำให้เลือกเวลาเฉลี่ยที่เป็นผลคูณของ 10 ms ซึ่งเป็นเวลาครึ่งรอบของเครือข่าย 50 Hz

การเพิ่มประสิทธิภาพการคำนวณ

การคำนวณจุดลอยตัวเพียงใช้ทรัพยากรของไมโครคอนโทรลเลอร์ 8 บิต การดำเนินการจุดลอยตัวใด ๆ จำเป็นต้องมีการปรับสภาพแมนทิสซา, การดำเนินการจุดคงที่, การทำให้เป็นมาตรฐานของแมนทิสซา, การแก้ไขคำสั่ง... และการดำเนินการทั้งหมดด้วย 32 ตัวเลขหลัก- ดังนั้นจึงจำเป็นต้องลดการใช้การคำนวณจุดลอยตัวให้เหลือน้อยที่สุด ฉันจะบอกวิธีการทำเช่นนี้ในบทเรียนต่อไปนี้ แต่อย่างน้อยเรามาเพิ่มประสิทธิภาพการคำนวณของเรากันดีกว่า ผลกระทบจะมีนัยสำคัญ

ในโปรแกรมของเรา การแปลงรหัส ADC เป็นแรงดันไฟฟ้าจะถูกเขียนดังนี้:

(ลอย)avarageU1 / 500. * 5. / 1024. / R2 * (R1 + R2)

มีการคำนวณมากมายที่นี่ ทั้งหมดมีจุดลอยตัว แต่การคำนวณส่วนใหญ่เป็นการดำเนินการที่มีค่าคงที่ ส่วนหนึ่งของบรรทัด:

/ 500. * 5. / 1024. / R2 * (R1 + R2)

(ลอย)ขนาดเฉลี่ยU1 * 0.00004447756

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

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

// การตรวจสอบการเพิ่มประสิทธิภาพการคำนวณ

อินท์ x= 876;
ลอย y;
จำนวน int ที่ไม่ได้ลงนาม
ไม่ได้ลงนาม เวลานาน ปัจจุบัน, เวลาก่อนหน้า;

การตั้งค่าเป็นโมฆะ () (
อนุกรมเริ่มต้น(9600);
}

เป็นโมฆะวน() (
นับ++;
// y= (ลอย)x / 500. * 5. / 1024. / 4.22 * (15. + 4.22);
// y= (ลอย)x * 0.00004447756 ;

ถ้า (นับ >= 10,000) (
นับ= 0;
timeCurrent= มิลลิวินาที();
Serial.println(เวลาปัจจุบัน - timePrev);
timePrev= เวลาปัจจุบัน;
}
}

ในตัวเลือกแรก เมื่อการดำเนินการจุดลอยตัวในลูปถูกใส่เครื่องหมายหมายเหตุและไม่ได้ดำเนินการ โปรแกรมจะสร้างผลลัพธ์เป็น 34 ms

เหล่านั้น. ลูปว่าง 10,000 ลูปจะเสร็จสิ้นภายใน 34 มิลลิวินาที

จากนั้นฉันก็เปิดบรรทัด:

y= (ลอย)x / 500. * 5. / 1024. / 4.22 * (15. + 4.22);

ทำซ้ำการคำนวณของเรา ผลลัพธ์ 10,000 รอบใน 922 ms หรือ

(922 – 34) / 10,000 = 88.8 µs

เหล่านั้น. การคำนวณจุดลอยตัวบรรทัดนี้ใช้เวลา 89 µs จึงจะเสร็จสมบูรณ์ ฉันคิดว่าจะมีมากกว่านี้

ตอนนี้ฉันปิดบรรทัดนี้ด้วยความคิดเห็นและเปิดบรรทัดถัดไป คูณด้วยค่าคงที่ที่คำนวณไว้ล่วงหน้า:

y= (ลอย)x * 0.00004447756 ;

ผลลัพธ์ 10,000 รอบใน 166 ms หรือ

(166 – 34) / 10,000 = 13.2 µs

ผลลัพธ์ที่น่าอัศจรรย์ เราประหยัดได้ 75.6 μs ต่อบรรทัด เราทำมันเสร็จเร็วขึ้นเกือบ 7 เท่า เรามี 2 บรรทัดดังกล่าว แต่อาจมีอีกมากในโปรแกรม

สรุป - การคำนวณด้วยค่าคงที่ต้องทำด้วยตัวเองบนเครื่องคิดเลขและใช้ในโปรแกรมเป็นค่าสัมประสิทธิ์สำเร็จรูป คอมไพเลอร์ Arduino จะไม่คำนวณพวกมันในขั้นตอนการคอมไพล์ ในกรณีของเราเราควรทำเช่นนี้:

#กำหนด ADC_U_COEFF 0.00004447756 // ปัจจัยการแปลงของรหัส ADC เป็นแรงดันไฟฟ้า

Serial.print((ลอย)avarageU1 * ADC_U_COEFF, 2);

ตัวเลือกที่ดีที่สุดสำหรับประสิทธิภาพคือการถ่ายโอนรหัส ADC ไปยังคอมพิวเตอร์และคำนวณจุดทศนิยมทั้งหมดด้วย ในกรณีนี้คอมพิวเตอร์จะต้องรับข้อมูล โปรแกรมพิเศษ- มอนิเตอร์พอร์ตจาก Arduino IDE จะไม่ทำงาน

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

มีบทเรียนอื่นปรากฏบนเว็บไซต์ (

อธิบายวิธีสร้างโวลต์มิเตอร์คู่แบบโฮมเมดโดยใช้แพลตฟอร์ม Arduino UNO โดยใช้จอ LCD 1602A ในบางกรณี จำเป็นต้องวัดแรงดันไฟฟ้าคงที่สองตัวพร้อมกันแล้วเปรียบเทียบ อาจจำเป็น เช่น เมื่อทำการซ่อมหรือปรับระบบกันโคลง แรงดันไฟฟ้ากระแสตรงเพื่อวัดแรงดันไฟฟ้าที่อินพุตและเอาต์พุตหรือในกรณีอื่น

แผนภาพ

การใช้ไมโครคอนโทรลเลอร์สากล โมดูล ARDUINO UNO และจอแสดงผล LCD สองบรรทัดประเภท 1602A (ขึ้นอยู่กับคอนโทรลเลอร์ HD44780) สามารถสร้างอุปกรณ์ดังกล่าวได้อย่างง่ายดาย ในบรรทัดหนึ่งจะแสดงแรงดันไฟฟ้า U1 ส่วนอีกบรรทัดจะแสดงแรงดันไฟฟ้า U2

ข้าว. 1. แผนภาพโวลต์มิเตอร์คู่พร้อมจอแสดงผล 1602A บน Arduino UNO

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

สำหรับผู้ที่ไม่คุ้นเคยกับ ARDUINO UNO ฉันแนะนำให้คุณอ่านบทความ L.1 และ L.2 ก่อน วงจรของโวลต์มิเตอร์แบบคู่แสดงไว้ในรูปที่ 1 1. ได้รับการออกแบบมาเพื่อวัดแรงดันไฟฟ้าสองตัวตั้งแต่ 0 ถึง 100V (ในทางปฏิบัติสูงถึง 90V)

ดังที่เห็นได้จากแผนภาพไปยังพอร์ตดิจิทัล D2-D7 บอร์ด ARDUINO UNO เชื่อมต่อกับโมดูลแสดงผลคริสตัลเหลว H1 ประเภท 1602A ไฟแสดงสถานะ LCD ใช้พลังงานจากตัวปรับแรงดันไฟฟ้า 5V ซึ่งอยู่บนบอร์ดควบคุมแรงดันไฟฟ้า 5V

แรงดันไฟฟ้าที่วัดได้จะจ่ายให้กับอินพุตอะนาล็อกสองตัว A1 และ A2 มีอินพุตแบบอะนาล็อกทั้งหมดหกช่อง A0-A5 คุณสามารถเลือกสองช่องใดก็ได้ ใน ในกรณีนี้, A1 และ A2 ถูกเลือก แรงดันไฟฟ้าบนพอร์ตอะนาล็อกสามารถเป็นค่าบวกได้เท่านั้นและอยู่ในช่วงตั้งแต่ศูนย์ถึงแรงดันไฟฟ้าของไมโครคอนโทรลเลอร์เท่านั้นนั่นคือในนามสูงถึง 5V

เอาต์พุตของพอร์ตอะนาล็อกจะถูกแปลงเป็นรูปแบบดิจิทัลโดย ADC ของไมโครคอนโทรลเลอร์ เพื่อให้ได้ผลลัพธ์เป็นหน่วยโวลต์ คุณต้องคูณด้วย 5 (ด้วยแรงดันอ้างอิงนั่นคือด้วยแรงดันไฟฟ้าของไมโครคอนโทรลเลอร์) แล้วหารด้วย 1,024

เพื่อให้สามารถวัดแรงดันไฟฟ้าที่มากกว่า 5V หรือมากกว่าแรงดันไฟฟ้าของไมโครคอนโทรลเลอร์ได้เนื่องจากแรงดันไฟฟ้าจริงที่เอาต์พุตของตัวกันโคลง 5 โวลต์บนบอร์ด ARDUINO UNO อาจแตกต่างจาก 5V และโดยปกติแล้ว ต่ำกว่าเล็กน้อย คุณต้องใช้ตัวแบ่งตัวต้านทานแบบธรรมดาที่อินพุต นี่คือตัวแบ่งแรงดันระหว่างตัวต้านทาน R1, R3 และ R2, R4

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

K = R3 / (R1+R3) หรือ K = R4 / (R2+R4)

ตามลำดับสำหรับ ทางเข้าที่แตกต่างกันโวลต์มิเตอร์คู่

น่าสนใจมากที่ตัวต้านทานในตัวแบ่งไม่จำเป็นต้องมีความแม่นยำสูงเสมอไป คุณสามารถใช้ตัวต้านทานธรรมดาจากนั้นวัดความต้านทานจริงด้วยโอห์มมิเตอร์ที่แม่นยำและแทนที่ค่าที่วัดได้เหล่านี้ลงในสูตร คุณจะได้ค่า “K” สำหรับตัวหารเฉพาะ ซึ่งจะต้องแทนที่ลงในสูตร

โปรแกรมโวลต์มิเตอร์

โปรแกรม C++ แสดงในรูปที่ 2

ข้าว. 2. แหล่งที่มาโปรแกรม

เพื่อควบคุมตัวบ่งชี้ LCD ได้มีการตัดสินใจใช้พอร์ต D2 ถึง D7 ของบอร์ด ARDUINO UNO โดยหลักการแล้ว พอร์ตอื่นๆ เป็นไปได้ แต่นี่คือวิธีที่ฉันตัดสินใจใช้พอร์ตเหล่านี้

เพื่อให้ตัวบ่งชี้โต้ตอบกับ ARDUINO UNO คุณจะต้องโหลดรูทีนย่อยลงในโปรแกรมเพื่อควบคุม รูทีนดังกล่าวเรียกว่า "ไลบรารี" และมี "ไลบรารี" ที่แตกต่างกันมากมายในแพ็คเกจซอฟต์แวร์ ARDUINO UNO หากต้องการทำงานกับตัวบ่งชี้ LCD ที่ใช้ HD44780 คุณต้องมีไลบรารี LiquidCrystal ดังนั้นโปรแกรม (ตารางที่ 1) จึงเริ่มต้นด้วยการโหลดไลบรารี่นี้:

บรรทัดนี้ให้คำสั่งโหลดเข้าสู่ ARDUINO UNO ห้องสมุดนี้- ถัดไปคุณต้องกำหนดพอร์ต ARDUINO UNO ที่จะทำงานร่วมกับไฟแสดงสถานะ LCD ฉันเลือกพอร์ต D2 ถึง D7 คุณสามารถเลือกคนอื่นได้ พอร์ตเหล่านี้ถูกกำหนดโดยบรรทัด:

นำ LiquidCrystal (2, 3, 4, 5, 6, 7);

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

อินพุทอนาล็อกอินพุท=1;

อินพุทอนาล็อกอินพุท1=2;

หากต้องการอ่านข้อมูลจากพอร์ตอะนาล็อก ให้ใช้ฟังก์ชัน analogRead การอ่านข้อมูลจากพอร์ตอะนาล็อกเกิดขึ้นในบรรทัด:

vout=analogRead(analogInput);

voutl=analogRead(analoglnput1);

จากนั้นคำนวณแรงดันไฟฟ้าจริงโดยคำนึงถึงอัตราส่วนการแบ่งตัวแบ่งแรงดันไฟฟ้าขาเข้า:

โวลต์=vout*5.0/1024.0/0.048 ;

โวลต์1=vout1*5.0/1024.0/0.048;

ในบรรทัดเหล่านี้ ตัวเลข 5.0 คือแรงดันไฟฟ้าที่เอาต์พุตของโคลงของบอร์ด ARDUINO UNO ตามหลักการแล้ว ควรเป็น 5V แต่เพื่อให้โวลต์มิเตอร์ทำงานได้อย่างแม่นยำ จะต้องวัดแรงดันไฟฟ้านี้ก่อน เชื่อมต่อแหล่งจ่ายไฟและวัดให้เพียงพอ โวลต์มิเตอร์ที่แม่นยำแรงดันไฟฟ้า +5V บนขั้วต่อ POWER ของบอร์ด เกิดอะไรขึ้นให้ป้อนบรรทัดเหล่านี้แทน 5.0 เช่น หากมี 4.85V เส้นจะมีลักษณะดังนี้:

โวลต์=vout*4.85/1024.0/0.048;

โวลต์1=vout1*4.85/1024.0/0.048;

ในขั้นต่อไป คุณจะต้องวัดความต้านทานที่แท้จริงของตัวต้านทาน R1-R4 และกำหนดค่าสัมประสิทธิ์ K (ระบุเป็น 0.048) สำหรับเส้นเหล่านี้โดยใช้สูตร:

K1 = R3 / (R1+R3) และ K2 = R4 / (R2+R4)

สมมติว่า K1 = 0.046 และ K2 = 0.051 ดังนั้นเราจึงเขียนว่า:

โวลต์=vout*4.85/1024.0/0.046 ;

โวลต์1=vout1*4.85/1024.0/0.051;

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

ด้วยการเปลี่ยนค่าสัมประสิทธิ์การหารของตัวหารตัวต้านทาน (และค่าสัมประสิทธิ์ "K") คุณสามารถสร้างขีดจำกัดการวัดอื่นๆ ได้ และไม่จำเป็นต้องเหมือนกันสำหรับอินพุตทั้งสอง

คาราฟคิน วี. RK-2017-01

วรรณกรรม:

1. Karavkin V. - ไฟกะพริบต้นคริสต์มาสบน ARDUINO เป็นวิธีการรักษาความกลัวไมโครคอนโทรลเลอร์ RK-11-2016.
2. Karavkin V. - เครื่องวัดความถี่บน ARDUINO RK-12-2016.

นำเสนอ แผนภาพที่มีประโยชน์สำหรับผู้ที่ชอบทดลองกับ Arduino นี่คือโวลต์มิเตอร์แบบดิจิตอลอย่างง่ายที่สามารถวัดแรงดันไฟฟ้ากระแสตรงในช่วง 0 - 30V ได้อย่างน่าเชื่อถือ ตามปกติบอร์ด Arduino สามารถใช้พลังงานจากแบตเตอรี่ 9V ได้

ดังที่คุณคงทราบแล้วว่าอินพุตแบบอะนาล็อกของ Arduino สามารถใช้วัดแรงดันไฟฟ้ากระแสตรงในช่วง 0 - 5V และช่วงนี้สามารถเพิ่มได้
โดยใช้ตัวต้านทานสองตัวเป็นตัวแบ่งแรงดันไฟฟ้า ตัวแบ่งจะลดแรงดันไฟฟ้าที่วัดได้ให้เหลือระดับอินพุตอะนาล็อก Arduino จากนั้นโปรแกรมจะคำนวณค่าแรงดันไฟฟ้าจริง

เซ็นเซอร์แอนะล็อกบนบอร์ด Arduino ตรวจจับแรงดันไฟฟ้าที่อินพุตแอนะล็อก และแปลงเป็นรูปแบบดิจิทัลเพื่อประมวลผลต่อไปโดยไมโครคอนโทรลเลอร์ ในรูป แรงดันไฟฟ้าจะจ่ายให้กับอินพุตแบบอะนาล็อก (A0) ผ่านตัวแบ่งแรงดันไฟฟ้าอย่างง่ายซึ่งประกอบด้วยตัวต้านทาน R1 (100 kOhm) และ R2 (10 kOhm)

ด้วยค่าตัวแบ่งเหล่านี้ บอร์ด Arduino จึงสามารถจ่ายแรงดันไฟฟ้าได้ตั้งแต่ 0 ถึง
55V. ที่อินพุต A0 เรามีแรงดันไฟฟ้าที่วัดได้หารด้วย 11 เช่น 55V / 11=5V กล่าวอีกนัยหนึ่ง เมื่อวัด 55V ที่อินพุต Arduino เราจะได้ค่าสูงสุด ค่าที่อนุญาต 5V. ในทางปฏิบัติควรเขียนช่วง "0 - 30V" บนโวลต์มิเตอร์นี้เพื่อให้คงอยู่จะดีกว่า
ขอบความปลอดภัย!

หมายเหตุ

หากการอ่านจอแสดงผลไม่ตรงกับการอ่านโวลต์มิเตอร์ทางอุตสาหกรรม (ห้องปฏิบัติการ) จำเป็นต้องวัดค่าความต้านทาน R1 และ R2 ด้วยเครื่องมือที่แม่นยำและใส่ค่าเหล่านี้แทน R1=100000.0 และ R2=10,000.0 ในโค้ดโปรแกรม จากนั้นคุณควรวัดแรงดันไฟฟ้าจริงระหว่างพิน 5V และ "กราวด์" ของบอร์ด Arduino ด้วยโวลต์มิเตอร์ในห้องปฏิบัติการ ผลลัพธ์ที่ได้จะเป็นค่าน้อยกว่า 5V เช่น จะเป็น 4.95V ควรใส่มูลค่าที่แท้จริงนี้ในบรรทัดของโค้ด
vout = (ค่า * 5.0) / 1,024.0 แทนที่จะเป็น 5.0
นอกจากนี้ ให้ลองใช้ตัวต้านทานที่มีความแม่นยำซึ่งมีความทนทาน 1%

ตัวต้านทาน R1 และ R2 ช่วยป้องกันแรงดันไฟฟ้าขาเข้าที่เพิ่มขึ้น อย่างไรก็ตาม โปรดจำไว้ว่าแรงดันไฟฟ้าที่สูงกว่า 55V อาจทำให้บอร์ด Arduino เสียหายได้ นอกจากนี้ การออกแบบนี้ไม่ได้ให้การป้องกันประเภทอื่น (จากแรงดันไฟกระชาก การกลับขั้ว หรือแรงดันไฟเกิน)

โปรแกรมโวลต์มิเตอร์แบบดิจิตอล

/*
ดีซีโวลท์มิเตอร์
Arduino DVM ตามแนวคิดตัวแบ่งแรงดันไฟฟ้า
ที.เค.หเรนทรัน
*/
#รวม
จอแอลซีดีลิควิดคริสตัล (7, 8, 9, 10, 11, 12);
อินพุทอนาล็อกอินพุท = 0;
ลอยตัว = 0.0;
ลอยวิน = 0.0;
ลอย R1 = 100,000.0; // แนวต้าน R1 (100K) -ดูข้อความ!
ลอย R2 = 10,000.0; // แนวต้าน R2 (10K) – ดูข้อความ!
ค่า int = 0;
การตั้งค่าเป็นโมฆะ())(
pinMode (อินพุตอะนาล็อก, อินพุต);
จอแอลซีดี. เริ่มต้น (16, 2);
lcd.print("DC โวลต์มิเตอร์");
}
เป็นโมฆะวน()
// อ่านค่าที่อินพุตแบบอะนาล็อก
ค่า = analogRead (analogInput);
vout = (ค่า * 5.0) / 1,024.0; //ดูข้อความ
vin = โวต์ / (R2/(R1+R2));
ถ้า (วิน<0.09) {
vin=0.0;//คำสั่งเพื่อยุติการอ่านที่ไม่ต้องการ !
}
จอแอลซีดี setCursor (0, 1);
lcd.print("อินพุต V= ");
จอแอลซีดีพิมพ์(วิน);
ล่าช้า (500);
}

แผนผังของ Arduino-voltmeter

รายการส่วนประกอบ

บอร์ด Arduino Uno
ตัวต้านทาน 100 โอห์ม
ตัวต้านทาน 10 kOhm
ตัวต้านทาน 100 โอห์ม
ตัวต้านทานทริมเมอร์ 10kOhm
จอ LCD 16?2 (ฮิตาชิ HD44780)

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

• ในบทเรียนเราใช้บอร์ดที่เข้ากันได้กับ Arduino - SunFounder Uno / Mars (http://bit.ly/2tkaMba)
• สายข้อมูล USB
• 2 โพเทนชิโอมิเตอร์ (50k)
• LCD1602 - http://bit.ly/2ubNEfi
• บอร์ดพัฒนา - http://bit.ly/2slvfrB
• จัมเปอร์หลายอัน

ก่อนที่จะเชื่อมต่อ เรามาทำความเข้าใจวิธีการทำงานกันก่อน

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

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

LCD1602 มีโหมดการทำงานสองโหมด: 4 บิตและ 8 บิต เมื่อ MCU IO ไม่เพียงพอ คุณสามารถเลือกโหมด 4 บิต ซึ่งใช้เฉพาะพิน D4~D7 เท่านั้น

ทำตามตารางเพื่อเชื่อมต่อ

ขั้นตอนที่ 4: เชื่อมต่อโพเทนชิออมิเตอร์กับ LCD1602

เชื่อมต่อพินกลางของโพเทนชิออมิเตอร์เข้ากับพิน Vo บน LCD1602 และพินอื่น ๆ เข้ากับ GND

เชื่อมต่อพินกลางของโพเทนชิออมิเตอร์เพื่อพิน A0 จาก SunFounder Uno และอีกอันหนึ่งเข้ากับ 5V ในขณะที่อีกอันเข้ากับ GND

ขั้นตอนที่ 6: อัปโหลดโค้ด

รหัสนี้:

หมุนโพเทนชิออมิเตอร์เพื่อตรวจสอบแรงดันไฟฟ้าบน LCD1602 แบบเรียลไทม์

นี่เป็นสิ่งที่ยุ่งยาก หลังจากที่ฉันรันโค้ดแล้ว หน้าจอ LCD จะแสดงตัวอักษร จากนั้นฉันปรับคอนทราสต์ของหน้าจอ (ค่อยๆ เปลี่ยนจากสีดำเป็นสีขาว) โดยการหมุนโพเทนชิออมิเตอร์ตามเข็มนาฬิกาหรือทวนเข็มนาฬิกาจนกระทั่งหน้าจอแสดงตัวอักษรอย่างชัดเจน

นำแบตเตอรี่สองก้อนมาวัดแรงดันไฟฟ้า: 1.5 V และ 3.7 V ปลดการเชื่อมต่อของโพเทนชิออมิเตอร์ตัวที่สองกับพิน A0 และ GND ซึ่งหมายถึงการถอดโพเทนชิออมิเตอร์ออกจากวงจร ยึดปลายสาย A0 เข้ากับขั้วบวกของแบตเตอรี่และยึดวงจร GND เข้ากับขั้วลบ อย่าเชื่อมต่อใหม่ ไม่เช่นนั้นแบตเตอรี่จะลัดวงจร ค่า 0V คือการเชื่อมต่อแบบย้อนกลับ

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

ป.ล.:หากคุณมีปัญหากับการแสดงผลบนจอแสดงผล - ดูคำถามที่พบบ่อยเกี่ยวกับจอแสดงผล LCD - http://wiki.sunfounder.cc/index.php?title=LCD1602/I2C_LCD1602_FAQ