Arduino รองรับอินเทอร์เฟซการถ่ายโอนข้อมูลจำนวนมาก หนึ่งในนั้นคือ I2C ซึ่งค่อนข้างได้รับความนิยมในปัจจุบัน กาลครั้งหนึ่งโปรโตคอลการสื่อสารนี้ถูกคิดค้นโดย Philips และจดทะเบียนภายใต้ชื่อสิทธิบัตร "I2C" คุณสามารถค้นหาได้ภายใต้ชื่อ TWI อินเทอร์เฟซ 2 บรรทัด แต่ทั้งหมดทำงานบนหลักการเดียวกัน

จุดรวมของบัส I2C คือคุณสามารถแขวนอุปกรณ์ต่าง ๆ จำนวนมาก (128) บนสายไฟ 2 เส้นตั้งแต่เซ็นเซอร์อุณหภูมิไปจนถึงไมโครคอนโทรลเลอร์

แต่ในขณะเดียวกัน I2C ก็ยังมีความเร็วต่ำกว่า UART และ SPI เนื่องจากหลักการทำงานขั้นพื้นฐานเพราะว่า สองบรรทัดเชื่อมต่อกับตัวต้านทาน (Vcc) เสมอซึ่งหมายความว่าบนกราฟเราจะไม่ได้พัลส์สี่เหลี่ยม แต่เป็นพัลส์สี่เหลี่ยมคางหมูซึ่งแตกต่างจากที่กล่าวมาข้างต้น

SDA - รับผิดชอบในการส่งข้อมูล (จุดเริ่มต้นของการส่งข้อมูล ที่อยู่ ข้อมูล)
SCL - การตอกบัตรรถบัส

ใน I2C อุปกรณ์สามารถมีได้สองประเภท: Master และ Slave

ตอนนี้เรามาดูหลักการพื้นฐานของการเขียนโปรแกรมโดยใช้ไลบรารี Wire.h มาตรฐาน:

Wire.begin(uint8_t address) - ใช้เพื่อเริ่มต้นอุปกรณ์ในโหมดทาสคุณต้องป้อนที่อยู่ในโหมดหลัก Wire.begin() แทนที่จะใช้ Wire คุณสามารถใช้คำอื่นก็ได้

Wire.requestFrom(ที่อยู่ uint8_t, ปริมาณ uint8_t) - คำขอเพื่อรับจำนวนไบต์ที่แน่นอนจากอุปกรณ์เฉพาะ (ที่อยู่ 7 บิต) ส่งกลับจำนวนไบต์ที่อ่าน

Wire.beginTransmission(ที่อยู่ uint8_t) - เริ่มต้นการส่งสัญญาณ

Wire.endTransmission() - สิ้นสุดการส่ง ส่งกลับหมายเลขข้อผิดพลาดหรือสำเร็จ (0)

Wire.write(uint8_t data) - สามารถรับค่าของไบต์เดียว (ค่า), หลายไบต์ (สตริง), อาร์เรย์ที่มีความยาวที่แน่นอน (ข้อมูล, ความยาว) ตั้งอยู่ระหว่าง: startTransmission และ endTransmission ส่งกลับจำนวนไบต์ที่เขียน

Wire.available() – ส่งคืนจำนวนไบต์ที่พร้อมใช้งานสำหรับการประมวลผล อาจารย์เรียกหลังจากร้องขอจาก

Wire.read() - อ่านไบต์จากอุปกรณ์ทาส มันเขียนขึ้นหลังจากการร้องขอจาก

การเชื่อมต่อไลบรารีกับ Arduino IDE ไม่ใช่เรื่องยาก เนื่องจากมีมาพร้อมกับโปรแกรมแก้ไขมาตรฐาน

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

ตัวอย่างเช่น พิจารณาการเชื่อมต่อและการทำงานของมาตรความเร่งและไจโรสโคป Gy-521

เราเชื่อมต่อตามแผนภาพ (มีตัวต้านทานแบบดึงขึ้นอยู่ในโมดูล):

โมดูลสามารถทำงานได้ทั้ง 3.3 โวลต์และ 5 โวลต์

#รวม // เชื่อมต่อไลบรารีเพื่อทำงานกับอินเทอร์เฟซ i2c const int MPU_addr = 0x68; // ที่อยู่ I2C GY-521 int16_t AcX, AcY, AcZ, Tmp, GyX, GyY, GyZ; // ตัวแปรสำหรับการเขียนค่า void setup() ( Wire.begin(); // เริ่มต้นบัส i2c Wire.beginTransmission(MPU_addr); // เริ่มการส่งผ่าน Wire.write(0x6B); // เขียนรีจิสเตอร์บางตัวเพื่อเริ่มต้น โมดูล Wire.write (0); // ส่งศูนย์เพื่อปลุกโมดูลจากโหมดสลีป Wire.endTransmission (จริง); Serial.begin (9600); void loop () ( Wire.beginTransmission (MPU_addr); Wire.write (0x3B ); // เริ่มต้นด้วยการลงทะเบียนนี้ Wire.endTransmission(false); Wire.requestFrom(MPU_addr, 14, จริง); // อ่านการลงทะเบียนทั้งหมด AcX = Wire.read();<< 8 | Wire.read(); // 0x3B AcY = Wire.read() << 8 | Wire.read(); // 0x3D AcZ = Wire.read() << 8 | Wire.read(); // 0x3F Tmp = Wire.read() << 8 | Wire.read(); // 0x41 GyX = Wire.read() << 8 | Wire.read(); // 0x43 GyY = Wire.read() << 8 | Wire.read(); // 0x45 GyZ = Wire.read() << 8 | Wire.read(); // 0x47 Serial.print("AcX = "); Serial.print(AcX); // выводим данные в Serial Serial.print(" | AcY = "); Serial.print(AcY); Serial.print(" | AcZ = "); Serial.print(AcZ); Serial.print(" | Tmp = "); Serial.print(Tmp / 340.00 + 36.53); // выводим температуры по формуле Serial.print(" | GyX = "); Serial.print(GyX); Serial.print(" | GyY = "); Serial.print(GyY); Serial.print(" | GyZ = "); Serial.println(GyZ); delay(333); }

โปรโตคอลการแลกเปลี่ยนข้อมูล I2C ครั้งหนึ่งได้รับการพัฒนาโดย Philips ชื่อ I2C มาจากการควบคุม Iner-IC ภาษาอังกฤษหรือการควบคุมระหว่างชิป Inter-IC, IIC (I2C) เป็นชื่อของโปรโตคอลเดียวกัน

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

มีอะแดปเตอร์พิเศษที่ให้คุณเชื่อมต่ออุปกรณ์อื่น ๆ ได้เช่นด้วยอะแดปเตอร์คุณสามารถเชื่อมต่อจอแสดงผล Arduino 1602 (16x2) LCD โดยใช้โปรโตคอล i2c โดยใช้สายสองเส้น ตามคำขอ LCD i2c มีข้อมูลมากมายบนอินเทอร์เน็ตนี่คือตัวอย่างว่าอะแดปเตอร์สำหรับจอแสดงผลควรมีลักษณะอย่างไร http://www.ebay.com/itm/310565362720

เมื่อทำงานกับอินเทอร์เฟซนี้ อุปกรณ์ตัวหนึ่งจะเป็นอุปกรณ์หลักและอีกเครื่องหนึ่งจะเป็นอุปกรณ์รอง ต้นแบบเริ่มต้นการส่งสัญญาณและสร้างสัญญาณที่จำเป็นสำหรับการซิงโครไนซ์

ในทางกลับกันทาสจะขึ้นอยู่กับมาสเตอร์และเริ่มส่งข้อมูลหลังจากได้รับคำสั่งจากอุปกรณ์หลักเท่านั้น

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

ตัวอย่างการเชื่อมต่อเซ็นเซอร์โดยใช้โปรโตคอล I2C

การเชื่อมต่อทำได้โดยใช้สายสองเส้น: SCL - สัญญาณนาฬิกาหรือสัญญาณนาฬิกาและ SDA - สัญญาณข้อมูล ในเวลาเดียวกัน เซ็นเซอร์ต่างๆ (อุปกรณ์สเลฟ) จำนวนเท่าใดก็ได้ที่มี ID เฉพาะของตัวเองสามารถเชื่อมต่อกับบัส I2C ได้

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

ในการแลกเปลี่ยนข้อมูลกับอุปกรณ์ คุณต้องทราบรหัสของอุปกรณ์เหล่านั้น อุปกรณ์ที่แตกต่างกันอาจมีความยาวที่อยู่ (id) ที่แตกต่างกัน 8 หรือ 7 บิต ไลบรารี Wire ใช้การกำหนดแอดเดรส 7 บิต

อุปกรณ์ทาสเชื่อมต่อกับพินบนบอร์ด Arduino Arduino แต่ละเวอร์ชันมีพิน I2C ของตัวเอง

• UNO - A4(SDA), A5(SCL);
• เมกะ - 20(SDA), 21(SCL);
• เลโอนาร์โด- 2(SDA), 3(SCL);
• ครบกำหนด - 20(SDA), 21(SCL),SDA1,SCL1;

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

ตัวอย่างนี้แสดงวิธีการตั้งค่าความต้านทานเฉพาะในโพเทนชิออมิเตอร์แบบดิจิทัลโดยใช้ไลบรารี Wire การตั้งค่าเฉพาะทำได้โดยใช้ตัวแปร val

#รวม การตั้งค่าเป็นโมฆะ() ( Wire.begin(); // เข้าร่วม i2c บัส (ที่อยู่เสริมสำหรับต้นแบบ) ) ไบต์ val = 0; void loop() ( Wire.beginTransmission(44); // ส่งไปยังอุปกรณ์ # 44 (0x2c) // ที่อยู่อุปกรณ์ระบุไว้ในแผ่นข้อมูล Wire.write(byte(0x00)); // ส่งคำสั่งไบต์ Wire.write(val // ส่งค่าโพเทนชิออมิเตอร์ไบต์ Wire.endTransmission(); // หยุดการส่ง val++; // เริ่มต้นใหม่จาก ค่าต่ำสุด ) ล่าช้า (500 )

วิดีโอแสดงการทำงานของ I2C และ Arduino ส่วนที่ 1

จอ LCD– แขกประจำในโครงการ Arduino แต่ในวงจรที่ซับซ้อน เราอาจประสบปัญหาการขาดพอร์ต Arduino เนื่องจากจำเป็นต้องเชื่อมต่อชิลด์ที่มีพินจำนวนมาก วิธีแก้ปัญหาในสถานการณ์นี้อาจเป็นได้ I2C/IICอะแดปเตอร์ที่เชื่อมต่อชิลด์ Arduino 1602 เกือบมาตรฐานกับบอร์ด Uno, Nano หรือ Mega โดยใช้พินเพียง 4 พิน ในบทความนี้เราจะมาดูกันว่าคุณสามารถเชื่อมต่อหน้าจอ LCD กับอินเทอร์เฟซ I2C ได้อย่างไร ไลบรารีใดที่คุณสามารถใช้ เขียนตัวอย่างแบบร่างสั้น ๆ และดูข้อผิดพลาดทั่วไป

จอแสดงผลคริสตัลเหลว จอแอลซีดี 1602เป็นตัวเลือกที่ดีสำหรับเอาต์พุตสตริงอักขระในโปรเจ็กต์ต่างๆ มีราคาไม่แพง มีการดัดแปลงต่างๆ ด้วยสีแบ็คไลท์ที่แตกต่างกัน คุณสามารถดาวน์โหลดไลบรารี่สำเร็จรูปสำหรับสเก็ตช์ Arduino ได้อย่างง่ายดาย แต่ข้อเสียเปรียบหลักของหน้าจอนี้คือจอแสดงผลมีพินดิจิทัล 16 ตัว ซึ่งต้องใช้อย่างน้อย 6 ตัว ดังนั้น การใช้หน้าจอ LCD นี้โดยไม่มี i2c จะเพิ่มข้อจำกัดที่ร้ายแรงสำหรับบอร์ด Arduino Uno หรือ Nano หากมีผู้ติดต่อไม่เพียงพอ คุณจะต้องซื้อบอร์ด Arduino Mega หรือบันทึกผู้ติดต่อ รวมถึงโดยการเชื่อมต่อจอแสดงผลผ่าน i2c

คำอธิบายโดยย่อของพิน LCD 1602

มาดูพิน LCD1602 กันดีกว่า:

หมุดแต่ละตัวมีจุดประสงค์ของตัวเอง:

1. กราวด์ GND;
2. แหล่งจ่ายไฟ 5 โวลต์;
3. การตั้งค่าความคมชัดของจอภาพ
4. คำสั่งข้อมูล;
5. การเขียนและการอ่านข้อมูล
6. เปิดใช้งาน;

7-14. สายข้อมูล

1. พร้อมแสงไฟหลัง;
2. ลบแสงไฟ

ข้อมูลจำเพาะของจอแสดงผล:

• ประเภทการแสดงตัวอักษร สามารถโหลดสัญลักษณ์ได้
• แสงไฟ LED;
• คอนโทรลเลอร์ HD44780;
• แรงดันไฟฟ้า 5V;
• จัดรูปแบบอักขระ 16x2;
• ช่วงอุณหภูมิในการทำงานตั้งแต่ -20C ถึง +70C อุณหภูมิการจัดเก็บตั้งแต่ -30C ถึง +80C;
• มุมมอง 180 องศา

แผนภาพการเชื่อมต่อของ LCD กับบอร์ด Arduino ที่ไม่มี i2C

แผนภาพมาตรฐานสำหรับการเชื่อมต่อจอภาพโดยตรงกับไมโครคอนโทรลเลอร์ Arduino ที่ไม่มี I2C มีดังนี้

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

หาซื้อได้ที่ไหน หน้าจอ i2c 1602 สำหรับ Arduino

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

• ความแตกต่างของจอแสดงผลปกติจากผู้ขาย Wavgat ที่มีชื่อเสียงในราคาต่ำกว่า 100 รูเบิล
• ชุดจอและอแดปเตอร์ i2c (ต้องบัดกรีเอง) ราคา – ต่ำกว่า 200 รูเบิล
• แผงป้องกันหน้าจอ i2c – โมดูล LCD 1602 พร้อมปุ่มควบคุมและบอร์ดขยาย

คำอธิบายของโปรโตคอล I2C

ก่อนที่จะหารือเกี่ยวกับการเชื่อมต่อจอแสดงผลกับ Arduino ผ่านอะแดปเตอร์ i2c เรามาพูดคุยสั้น ๆ เกี่ยวกับโปรโตคอล i2C กันก่อน

I2C/IIC(Inter-Integrated Circuit) เป็นโปรโตคอลที่เดิมสร้างขึ้นเพื่อสื่อสารวงจรรวมภายในอุปกรณ์อิเล็กทรอนิกส์ การพัฒนาเป็นของฟิลิปส์ โปรโตคอล i2c ขึ้นอยู่กับการใช้บัส 8 บิตซึ่งจำเป็นสำหรับการสื่อสารบล็อกในอุปกรณ์อิเล็กทรอนิกส์ควบคุมและระบบการกำหนดที่อยู่ซึ่งคุณสามารถสื่อสารผ่านสายเดียวกันด้วยอุปกรณ์หลายตัว เราเพียงแค่ถ่ายโอนข้อมูลไปยังอุปกรณ์หนึ่งหรืออีกเครื่องหนึ่งโดยเพิ่มตัวระบุองค์ประกอบที่ต้องการลงในแพ็กเก็ตข้อมูล

วงจร I2C ที่ง่ายที่สุดอาจมีอุปกรณ์หลักหนึ่งตัว (ส่วนใหญ่มักจะเป็นไมโครคอนโทรลเลอร์ Arduino) และสเลฟหลายตัว (เช่น จอ LCD) อุปกรณ์แต่ละตัวมีที่อยู่อยู่ในช่วงตั้งแต่ 7 ถึง 127 ไม่ควรมีอุปกรณ์สองเครื่องที่มีที่อยู่เดียวกันในวงจรเดียวกัน

บอร์ด Arduino รองรับ i2c ในฮาร์ดแวร์ คุณสามารถใช้พิน A4 และ A5 เพื่อเชื่อมต่ออุปกรณ์โดยใช้โปรโตคอลนี้

มีข้อดีหลายประการสำหรับการทำงานของ I2C:

• การดำเนินการต้องการเพียง 2 บรรทัด - SDA (สายข้อมูล) และ SCL (สายซิงค์)
• เชื่อมต่ออุปกรณ์ชั้นนำมากมาย
• ลดเวลาในการพัฒนา
• ต้องใช้ไมโครคอนโทรลเลอร์เพียงตัวเดียวในการควบคุมอุปกรณ์ทั้งชุด
• จำนวนไมโครวงจรที่เป็นไปได้ที่เชื่อมต่อกับบัสหนึ่งถูกจำกัดด้วยความจุสูงสุดเท่านั้น
• ความปลอดภัยของข้อมูลระดับสูงเนื่องจากมีตัวกรองป้องกันไฟกระชากแบบพิเศษที่ติดตั้งอยู่ในวงจร
• ขั้นตอนง่ายๆ สำหรับการวินิจฉัยความล้มเหลวที่เกิดขึ้นและการแก้ไขข้อบกพร่องอย่างรวดเร็ว
• บัสได้รวมเข้ากับ Arduino แล้ว ดังนั้นจึงไม่จำเป็นต้องพัฒนาอินเทอร์เฟซบัสเพิ่มเติม

ข้อบกพร่อง:

• มีขีด จำกัด capacitive บนบรรทัด - 400 pF
• ยากต่อการตั้งโปรแกรมคอนโทรลเลอร์ I2C หากมีอุปกรณ์ที่แตกต่างกันหลายตัวบนบัส
• เนื่องจากมีอุปกรณ์จำนวนมาก จึงเป็นเรื่องยากที่จะแยกข้อผิดพลาดหากหนึ่งในนั้นเกิดข้อผิดพลาดในระดับต่ำ

โมดูล i2c สำหรับ LCD 1602 Arduino

วิธีที่เร็วและสะดวกที่สุดในการใช้จอแสดงผล i2c ใน Arduino คือการซื้อหน้าจอสำเร็จรูปที่รองรับโปรโตคอลในตัว แต่มีหน้าจอเหล่านี้ไม่มากนักและไม่ถูก แต่มีการผลิตหน้าจอมาตรฐานที่แตกต่างกันจำนวนมากแล้ว ดังนั้นตัวเลือกที่เหมาะสมและเป็นที่นิยมมากที่สุดในปัจจุบันคือการซื้อและใช้โมดูล I2C แยกต่างหาก - อะแดปเตอร์ซึ่งมีลักษณะดังนี้:

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

เอาต์พุต i2c ใช้เชื่อมต่อกับบอร์ด Arduino หากจำเป็นให้เชื่อมต่อพลังงานภายนอกสำหรับไฟแบ็คไลท์ ด้วยทริมเมอร์ในตัว เราสามารถตั้งค่าคอนทราสต์แบบกำหนดเอง J ได้

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

การเชื่อมต่อหน้าจอ LCD เข้ากับ Arduino ผ่าน I2C

ในการเชื่อมต่อ คุณต้องมีบอร์ด Arduino, จอแสดงผล, เขียงหั่นขนม, สายเชื่อมต่อ และโพเทนชิออมิเตอร์

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

จอภาพ LCD ที่รองรับ i2c เชื่อมต่อกับบอร์ดโดยใช้สายไฟสี่เส้น - สองสายสำหรับข้อมูล, สายไฟสองเส้น

• พิน GND เชื่อมต่อกับ GND บนบอร์ด
• พิน VCC อยู่ที่ 5V
• SCL เชื่อมต่อกับขา A5
• SDA เชื่อมต่อกับขา A

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

ไลบรารีสำหรับการทำงานกับจอแสดงผล LCD i2c

ในการโต้ตอบกับ Arduino และ LCD 1602 ผ่านบัส I2C คุณจะต้องมีไลบรารีอย่างน้อยสองไลบรารี:

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

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

#รวม #รวม // รวมถึงห้องสมุด //#include // การเชื่อมต่อไลบรารีสำรอง LiquidCrystal_I2C lcd (0x27,16,2); // ระบุที่อยู่ I2C (ค่าที่พบบ่อยที่สุด) รวมถึงพารามิเตอร์หน้าจอ (ในกรณีของ LCD 1602 - 2 บรรทัดละ 16 ตัวอักษร //LiquidCrystal_PCF8574 lcd(0x27); // ตัวเลือกสำหรับการตั้งค่าโมฆะไลบรารี PCF8574 ( ) ( lcd.init (); // เริ่มต้นการแสดงผล lcd.backlight(); // เชื่อมต่อแบ็คไลท์ lcd.setCursor(0,0); // ตั้งเคอร์เซอร์ไปที่จุดเริ่มต้นของบรรทัดแรก lcd.print(" สวัสดี"); lcd.setCursor(0,1); // ตั้งเคอร์เซอร์ไปที่จุดเริ่มต้นของบรรทัดที่สอง lcd.print("ArduinoMaster"); // พิมพ์ข้อความในบรรทัดที่สอง ) void loop() ( )

คำอธิบายฟังก์ชันและวิธีการของไลบรารี LiquidCrystal_I2C:

• home() และ clear() - ฟังก์ชั่นแรกช่วยให้คุณสามารถคืนเคอร์เซอร์ไปที่จุดเริ่มต้นของหน้าจอส่วนที่สองก็ทำเช่นเดียวกัน แต่ในขณะเดียวกันก็ลบทุกอย่างที่อยู่บนหน้าจอก่อนหน้านี้
• write(ch) - อนุญาตให้คุณพิมพ์อักขระตัวเดียว ch ไปที่หน้าจอ
• cursor() และ noCursor() – แสดง/ซ่อนเคอร์เซอร์บนหน้าจอ
• กะพริบ() และ noBlink() - เคอร์เซอร์กะพริบ/ไม่กะพริบ (หากเปิดใช้งานจอแสดงผลก่อนหน้านี้)
• display() และ noDisplay() – ให้คุณเชื่อมต่อ/ปิดการใช้งานจอแสดงผล
• scrollDisplayLeft() และ scrollDisplayRight() – เลื่อนหน้าจอไปทางซ้าย/ขวาหนึ่งอักขระ
• autoscroll() และ noAutoscroll() - ช่วยให้คุณสามารถเปิด/ปิดโหมดเลื่อนอัตโนมัติได้ ในโหมดนี้ ตัวละครใหม่แต่ละตัวจะถูกเขียนในตำแหน่งเดียวกัน โดยแทนที่สิ่งที่เขียนไว้ก่อนหน้านี้บนหน้าจอ
• leftToRight() และ rightToLeft() – การตั้งค่าทิศทางของข้อความที่แสดง – ซ้ายไปขวา หรือ ขวาไปซ้าย
• createChar(ch, บิตแมป) – สร้างอักขระด้วยโค้ด ch (0 – 7) โดยใช้อาร์เรย์บิตแมปบิตแมปเพื่อสร้างจุดขาวดำ

ไลบรารีทางเลือกสำหรับการทำงานกับจอแสดงผล i2c

ในบางกรณีอาจเกิดข้อผิดพลาดเมื่อใช้ไลบรารีที่ระบุกับอุปกรณ์ที่ติดตั้งคอนโทรลเลอร์ PCF8574 ในกรณีนี้ สามารถแนะนำไลบรารี LiquidCrystal_PCF8574.h เป็นทางเลือกได้ มันขยาย LiquidCrystal_I2C ดังนั้นจึงไม่น่าจะมีปัญหาในการใช้งาน

ปัญหาการเชื่อมต่อจอแสดงผล LCD i2c

หากหลังจากอัปโหลดภาพสเก็ตช์แล้ว คุณไม่เห็นข้อความใด ๆ บนจอแสดงผล ให้ลองทำตามขั้นตอนต่อไปนี้

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

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

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

หากหน้าจอยังคงใช้งานไม่ได้ ให้ลองถอดอะแดปเตอร์ออกแล้วเชื่อมต่อ LCD ตามปกติ

บทสรุป

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

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

บัส I2C สามารถรองรับอุปกรณ์ได้สูงสุด 128 เครื่อง ที่อยู่ตั้งแต่ 0 ถึง 127

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

ไม่มีข้อมูลเกี่ยวกับความเร็วในการส่งข้อมูลบนเว็บไซต์ของผู้ผลิต แต่ตามเอกสารทั่วไปของโปรโตคอล ควรมีความเร็วอย่างน้อย 100 kbit/s

ตอนนี้ฉันต้องการทดสอบว่าบัส I2C ดีแค่ไหน และการแลกเปลี่ยนข้อมูลระหว่างคอนโทรลเลอร์ Arduino หลายตัวที่ใช้งานนั้นยากเพียงใด

ฉันจะนำคอนโทรลเลอร์สามตัวมาเชื่อมต่อกับบัส I2C และหาวิธีแลกเปลี่ยนข้อมูลกับคอนโทรลเลอร์นั้น ตัวควบคุมตัวแรกจะทำหน้าที่เป็นนาย และอีกสองคนที่เหลือจะทำหน้าที่เป็นทาส

ในการแสดงข้อมูล ฉันจะใช้ตัวบ่งชี้ LCD 1602 กับโมดูล I2C ซึ่งจะเชื่อมต่อกับบัสสื่อสารเดียวกัน

ตัวควบคุมหลักจะสำรวจตัวควบคุมตัวที่สองและสามตามลำดับ คอนโทรลเลอร์ตัวแรกจะต้องแสดงข้อมูลที่ได้รับบนตัวบ่งชี้ Arduino Nano Slave จะถูกสำรวจด้วยความถี่ 1 ครั้ง/วินาที

แผนภาพการเชื่อมต่อ

สายไฟสี่เส้นจากอุปกรณ์ทั้ง 4 ตัวจะต้องเชื่อมต่อแบบขนาน Pin A4 ของบอร์ด Arduino Nano คือบัส SDA ของโปรโตคอล I2C และ A5 คือ SCL

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

พลังงานจะจ่ายให้กับคอนโทรลเลอร์ตัวใดตัวหนึ่งผ่านอินพุต mini USB

LCD มีที่อยู่เริ่มต้นในเครือข่าย I2C ที่ 27 สำหรับคอนโทรลเลอร์ตัวที่สอง เราจะตั้งค่าที่อยู่เป็น 2 และสำหรับตัวควบคุมตัวที่สามเป็น 3 ไม่จำเป็นต้องมีที่อยู่ของคอนโทรลเลอร์ตัวแรกที่นำหน้า

โปรแกรมคอนโทรลเลอร์ - ปริญญาโท

#รวม // ตั้งค่าที่อยู่ LCD เป็น 0x27 สำหรับ 16 ตัวอักษรและจอแสดงผล 2 บรรทัด LiquidCrystal_I2C lcd (0x27, 16, 2); อินท์นาโน1=0; อินท์นาโน2; อินท์นาโน3; การตั้งค่าเป็นโมฆะ () ( Serial.begin (9600); // เริ่มต้น LCD lcd.begin (); // เปิดแบล็กไลท์และพิมพ์ข้อความ lcd.backlight (); ) void loop () ( lcd.setCursor ( 0, 0); lcd.print(nano1); Wire.requestFrom(2, 2); // ขอ 6 ไบต์จากอุปกรณ์ทาส #8 int i=0;nano2=0; / สเลฟอาจส่งไบต์น้อยกว่าที่ร้องขอ c = Wire.read(); // รับไบต์เป็นอักขระ Serial.print(c); if (i==0) nano2 = ((c & 0xff)<< 8); else nano2 = nano2 | c; i++; } Serial.println(""); Serial.println(nano2); lcd.setCursor(9, 0); lcd.print(nano2); delay(100); Wire.requestFrom(3, 2); // request 6 bytes from slave device #8 i=0;nano3=0; while (Wire.available()) { // slave may send less than requested byte c = Wire.read(); // receive a byte as character Serial.print(c); if (i==0) nano3 = ((c & 0xff) << 8); else nano3 = nano3 | c; i++; } lcd.setCursor(0, 1); lcd.print(nano3); delay(100); nano1++; delay(800); }

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

โปรแกรมควบคุมที่สอง

#รวม อินท์นาโน2=0; ไบต์สูง การตั้งค่าเป็นโมฆะ () ( Wire.begin (2); // เข้าร่วมบัส i2c ด้วยที่อยู่ # 8 Wire.onRequest (requestEvent); // ลงทะเบียนเหตุการณ์ ) void loop () ( ล่าช้า (1,000); nano2--; ) // ฟังก์ชั่นที่ดำเนินการทุกครั้งที่มาสเตอร์ร้องขอข้อมูล // ฟังก์ชั่นนี้ถูกลงทะเบียนเป็นเหตุการณ์ โปรดดูที่ setup() void requestEvent() ( high = (nano2 >>

โปรแกรม Arduino Nano ตัวที่สาม

#รวม อินท์นาโน2=0; ไบต์สูง การตั้งค่าเป็นโมฆะ () ( Wire.begin (3); // เข้าร่วมบัส i2c ด้วยที่อยู่ # 8 Wire.onRequest (requestEvent); // ลงทะเบียนเหตุการณ์ ) void loop () ( ล่าช้า (1500); nano2--; ) // ฟังก์ชั่นที่ดำเนินการทุกครั้งที่มาสเตอร์ร้องขอข้อมูล // ฟังก์ชั่นนี้ถูกลงทะเบียนเป็นเหตุการณ์ โปรดดูที่ setup() void requestEvent() ( high = (nano2 >> 8); high = (nano2 & 0xff); Wire.write(high ); // ตอบกลับด้วยข้อความ Wire.write ขนาด 2 ไบต์ (สูง);

สองโปรแกรมสุดท้ายต่างกันแค่ที่อยู่ในฟังก์ชัน Wire.begin(3) และความถี่ของการเปลี่ยนแปลงของตัวแปร

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

ดังนั้นการทำงานของการสื่อสาร I2C จึงสามารถตรวจสอบได้ด้วยค่าที่เปลี่ยนแปลงของตัวแปร 3 ตัวบนจอแสดงผลคริสตัลเหลว

ข้อสรุป

ทุกอย่างใช้งานได้ดี - ตัวเลขบนจอแสดงผลเปลี่ยนไป ฉันพยายามยืดสายเคเบิลระหว่างคอนโทรลเลอร์ Arduino ตัวที่สองและสามให้ยาวขึ้น ฉันตรวจสอบการทำงานของบัสสื่อสารที่มีความยาว 3 ม. - ไม่มีข้อตำหนิ ฉันไม่ได้ลองอีกต่อไป แต่หลายคนบอกฉันว่า I2C ใช้งานไม่ได้เกิน 0.5 ... 2 ม. และฉันได้แรงบันดาลใจจากความยาว 3 ม.

สำหรับตัวฉันเอง ฉันรู้แล้วว่าจะใช้การเชื่อมต่อระหว่างนาโนทั้งสามตัวที่ไหน

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

ข้อเสียในระยะทางสั้นๆ นี้น้อยกว่าข้อดีอย่างมาก

ด้วยพิกัดตั้งแต่ 10 โอห์มถึง 1 MOhm)

ตัวต้านทาน 2 ตัว 4.7 kOhm (จากชุดเดียวกัน)

สายเชื่อมต่อ (เช่นนี่คือชุดที่ดี)

คอมพิวเตอร์ที่มี Arduino IDE

1 คำอธิบายอินเทอร์เฟซ I2C

Serial IIC (หรือที่เรียกว่า I2C - Inter-Integrated Circuits) ใช้สายสื่อสารสองทิศทางสองสายที่เรียกว่าบัสข้อมูลอนุกรมในการส่งข้อมูล SDA (ข้อมูลอนุกรม)และรถบัสนาฬิกา SCL (นาฬิกาอนุกรม)- นอกจากนี้ยังมีสายไฟสองเส้น บัส SDA และ SCL ถูกดึงขึ้นไปที่บัสกำลังผ่านตัวต้านทาน

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

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

เจ้านายเริ่มการแลกเปลี่ยน เมื่อต้องการทำเช่นนี้ ระบบจะเริ่มสร้างพัลส์นาฬิกาและส่งไปตามเส้น SCL ในชุดละ 9 ชิ้น ในเวลาเดียวกัน บนบรรทัดข้อมูล SDA ที่ตั้งค่าไว้ ที่อยู่อุปกรณ์ซึ่งจำเป็นต้องสร้างการสื่อสารซึ่งโอเวอร์คล็อกด้วยพัลส์นาฬิกา 7 ตัวแรก (ดังนั้นข้อจำกัดของช่วงที่อยู่: 2 7 = 128 ลบที่อยู่ศูนย์) ข้อความต่อมาก็คือ รหัสการดำเนินงาน(อ่านหรือเขียน) และอีกสักหน่อย - บิตการรับทราบ(ACK) ว่าอุปกรณ์ทาสได้ยอมรับคำขอแล้ว หากบิตยืนยันไม่ถึง การแลกเปลี่ยนจะสิ้นสุดลง หรืออาจารย์ยังคงส่งคำขอซ้ำ ๆ

ดังแสดงในรูปด้านล่าง ในกรณีแรก ให้ลองถอดอุปกรณ์สเลฟออกจากบัส จะเห็นได้ว่าต้นแบบกำลังพยายามสร้างการสื่อสารกับอุปกรณ์ด้วยที่อยู่ 0x27 แต่ไม่ได้รับการยืนยัน (NAK) การแลกเปลี่ยนสิ้นสุดลง

ตอนนี้เชื่อมต่ออุปกรณ์ทาสเข้ากับบัส I2C แล้วทำซ้ำการดำเนินการ สถานการณ์มีการเปลี่ยนแปลง แพ็กเก็ตแรกที่มีที่อยู่ได้รับการตอบรับ (ACK) จากทาส การแลกเปลี่ยนดำเนินต่อไป ข้อมูลจะถูกส่งในรูปแบบแพ็คเกจ 9 บิต แต่ตอนนี้ 8 บิตถูกครอบครอง ข้อมูลและ 1 บิต - บิตการรับทราบสเลฟได้รับข้อมูลแต่ละไบต์ หากการเชื่อมต่อขาดหายและบิตการตอบรับมาไม่ถึง มาสเตอร์จะหยุดส่งสัญญาณ

2 การใช้งาน I2Cในอาดูโน่

Arduino ใช้สองพอร์ตเพื่อทำงานผ่านอินเทอร์เฟซ I2C ตัวอย่างเช่น ใน Arduino UNO และ Arduino Nano พอร์ตอะนาล็อก A4 สอดคล้องกับ SDA พอร์ตอะนาล็อก A5 สอดคล้องกับ SCL

สำหรับบอร์ดรุ่นอื่นๆ ความสอดคล้องของพินจะเป็นดังนี้:

3 ห้องสมุด "ลวด"สำหรับการทำงานร่วมกับ IIC

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

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

4 การเชื่อมต่ออุปกรณ์ I2Cถึง Arduino

มาดูวิธีการทำงานกับบัส I2C โดยใช้ Arduino กัน

ขั้นแรกให้ประกอบวงจรดังรูป เราจะควบคุมความสว่างของ LED โดยใช้โพเทนชิออมิเตอร์ AD5171 แบบดิจิตอล 64 ตำแหน่ง (ดูคำอธิบายทางเทคนิค) ซึ่งเชื่อมต่อกับบัส I2C ที่อยู่ที่เราจะเข้าถึงโพเทนชิออมิเตอร์คือ 0x2c (44 เป็นทศนิยม)

5 การจัดการอุปกรณ์ผ่านรถบัส IIC

ลองดูแผนภาพการแลกเปลี่ยนข้อมูลกับโพเทนชิออมิเตอร์แบบดิจิตอล AD5171 ซึ่งนำเสนอในคำอธิบายทางเทคนิค:

เราสนใจแผนภาพการเขียนข้อมูลลงรีจิสเตอร์ ร.ด- รีจิสเตอร์นี้ใช้เพื่อควบคุมความต้านทานของโพเทนชิออมิเตอร์

มาเปิดภาพร่างจากตัวอย่างของไลบรารี "Wire": ไฟล์ตัวอย่างลวด digital_potentiometer- มาโหลดมันลงในหน่วยความจำ Arduino กัน

#รวม // เชื่อมต่อไลบรารี "Wire" ไบต์ val = 0; // ค่าที่จะถ่ายโอนไปยังโพเทนชิออมิเตอร์ การตั้งค่าเป็นโมฆะ () ( Wire.begin(); // เชื่อมต่อกับบัส I2C ในฐานะมาสเตอร์ } เป็นโมฆะวน() ( Wire.beginTransmission (44); // เริ่มการแลกเปลี่ยนกับอุปกรณ์ที่มีที่อยู่ I2C "44" (0x2C) Wire.write(byte(0x00)); // ส่งคำสั่งการเขียนไปยังการลงทะเบียน RDAC Wire.write(val); // กำหนดตำแหน่งของโพเทนชิออมิเตอร์ 64 ตำแหน่ง Wire.endTransmission(); // เสร็จสิ้นการถ่ายโอน I2C val++; // เพิ่มค่า val 1 if (val == 63) ( // เมื่อโพเทนชิออมิเตอร์ถึงค่าสูงสุด val = 0; // รีเซ็ต val ) ล่าช้า (500); }

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