ฮาร์ดแวร์สไป SPI Arduino – เชื่อมต่ออุปกรณ์กับ Arduino คำอธิบายการทำงานของอุปกรณ์

อินเทอร์เฟซ SPI เป็นหนึ่งในอินเทอร์เฟซที่ได้รับความนิยมมากที่สุดในปัจจุบัน อินเทอร์เฟซแบบอนุกรม- มันถูกคิดค้นโดย Motorola และได้รับความนิยมอย่างรวดเร็วเนื่องจากความเรียบง่ายและความเร็วสูงเป็นพิเศษ ในเวลาเดียวกัน SPI อาจไม่สามารถเรียกอินเทอร์เฟซได้อย่างสมบูรณ์ แต่เป็นเพียงหลักการสื่อสาร เนื่องจาก SPI มีความหมายทั้งหมด ตรรกะการถ่ายโอนข้อมูลระหว่างอุปกรณ์ทั้งสอง (“Master” - “Slave”) ฟิสิกส์ไม่ค่อยสนใจนักมันถูกนำไปใช้แล้วใคร ๆ ก็พูดว่า "ตามสถานการณ์" แต่ไม่มีโปรโตคอลระดับต่ำกว่าเลยผู้ผลิตแต่ละรายจะคิดอะไรบางอย่างขึ้นมาเอง

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

อุปกรณ์ที่ควบคุมบัสนาฬิกา (นั่นคือสร้างพัลส์นาฬิกา) คือ "มาสเตอร์" หรือ "มาสเตอร์" ที่จริงแล้ว “ปรมาจารย์” จัดการการแลกเปลี่ยนข้อมูลทั้งหมด - เขาตัดสินใจว่าจะเริ่มการแลกเปลี่ยนเมื่อใด จะสิ้นสุดเมื่อใด จำนวนบิตที่จะถ่ายโอน ฯลฯ อุปกรณ์ตัวที่สองที่เข้าร่วมในการแลกเปลี่ยนคือ “Slave” หรือ “Slave” ใน SPI ซึ่งแตกต่างจาก I2C เดียวกัน "Slave" ไม่มีสิทธิ์อย่างแน่นอน ไม่สามารถมีอิทธิพลต่อบัสนาฬิกาได้เลย และไม่สามารถแจ้งอาจารย์ได้ว่าไม่ตรงเวลาหรือในทางกลับกัน ในทางใดทางหนึ่ง พร้อมสำหรับการแลกเปลี่ยนแล้ว นั่นคือ "อาจารย์" เองต้องรู้ว่าเมื่อใดควรถาม "ทาส" อะไรและความเร็วเท่าใดจึงจะสามารถตอบเขาได้

โดยรวมแล้ว สำหรับการแลกเปลี่ยนฟูลดูเพล็กซ์ (ทั้งสองทิศทางพร้อมกัน) อินเทอร์เฟซ SPI จะใช้ 4 บรรทัด (ดูรูป): SCLK, MOSI, MISO และ SS

1. เอสซีแอลเค— บัสนาฬิกา (บนบรรทัดนี้ต้นแบบจะสร้างพัลส์นาฬิกา)
2. โมซี่ (มดอกแอสเตอร์ โอ ut, สรัก ฉัน n) — เอาต์พุตหลัก, อินพุตทาส (ผ่านบรรทัดนี้ต้นแบบจะส่งข้อมูลไปยังทาส)
3. มิโซะ (มดอกแอสเตอร์ ฉันเอ็น, สรัก โอ ut) - อินพุตหลัก, เอาต์พุตทาส (ผ่านบรรทัดนี้ต้นแบบจะได้รับข้อมูลจากทาส)
4. เอสเอส (สรัก สเลือก) - การเลือกทาส (ใช้บรรทัดนี้เพื่อควบคุมเซสชันการแลกเปลี่ยน)

“1” และ “0” ถูกเข้ารหัสโดยระดับแรงดันไฟฟ้าบนบัสข้อมูล (MOSI, MISO) ในตรรกะเชิงบวกทั่วไป นั่นคือ ระดับแรงดันไฟฟ้าสูงบนบัสสอดคล้องกับ “หนึ่ง” และระดับต่ำสอดคล้องกับ “ ศูนย์". ในเวลาเดียวกันไม่ได้ระบุวิธีการจัดระเบียบการติดตั้งระดับเหล่านี้บนรถโดยสารทุกที่นั่นคือเอาต์พุตของเครื่องส่งสัญญาณอาจเป็น "แบบกดดึง" หรือ "ตัวสะสมแบบเปิด" ระดับสูงมักจะสอดคล้องกับแรงดันไฟฟ้าของวงจรไมโคร (นั่นคือถ้าเราจัดการกับวงจรไมโครห้าโวลต์ดังนั้นระดับสูงคือแรงดันไฟฟ้าใกล้กับห้าโวลต์ถ้าเรากำลังพูดถึงไมโครวงจรที่ขับเคลื่อนโดย 3.3V แล้ว ระดับสูงคือแรงดันไฟฟ้าใกล้กับ 3.3V)

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

ชื่อของเส้นโดยทั่วไปไม่ใช่มาตรฐานและอาจแตกต่างกันไปขึ้นอยู่กับผู้ผลิต (เช่น แทนที่จะเป็น MOSI, MISO และ SCLK เส้นอาจเรียกว่า DI, DO และ SC หรือ SI, SO และ CLK สาย SS อาจเรียกว่า CS หรือ RESET)

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

ตามที่ฉันได้กล่าวไปแล้ว ข้อมูลจะถูกส่งทีละบิต และข้อมูลจะถูกติดตั้งและอ่านบนขอบด้านตรงข้ามของสัญญาณนาฬิกา ช่วงเวลาของการอ่านข้อมูลในวรรณคดีอังกฤษเรียกว่า สลัก(การตรึง การสแนป) และช่วงเวลาที่ข้อมูลถูกติดตั้งบนบัส - กะ(กะ). ช่วงเวลาการติดตั้งเรียกว่าการเปลี่ยนแปลงเนื่องจากลักษณะของอินเทอร์เฟซแบบอนุกรมส่วนใหญ่ โดยปกติแล้ว จะไม่มีใครส่งข้อมูลครั้งละหนึ่งบิต ตามกฎแล้ว ข้อมูลเหล่านั้นจะถูกส่งเป็นแพ็กตั้งแต่ 8 บิตขึ้นไป (ขนาดแพ็กส่วนใหญ่มักจะเป็นผลคูณของแปด) ในเรื่องนี้ shift register ถูกสร้างขึ้นที่เอาต์พุตของเครื่องส่งสัญญาณ โดยที่แพ็กเก็ตทั้งหมดของบิตที่ส่งจะถูกโหลดพร้อมกัน และค่าของบิตต่ำหรือสูงของ shift register นี้จะถูกตั้งค่าบนบัสข้อมูล (ขึ้นอยู่กับ วิธีที่เราส่ง - บิตไปข้างหน้าต่ำหรือสูง) และเพื่อตั้งค่าเป็นบัสของบิตที่ส่งถัดไป - เพียงแค่ "เปลี่ยน" รีจิสเตอร์นี้ นี่คือวิธีการจัดเรียงเครื่องส่งสัญญาณใน SPI และใน I2C และใน RS232 ปกติและที่อื่น ๆ อีกมากมาย (สะดวกกว่าในฮาร์ดแวร์) เอาล่ะ กลับไปที่ SPI ของเรากันดีกว่า

ระดับลอจิคัลของสัญญาณบนบัสนาฬิกาในสถานะไม่ใช้งาน (เมื่อไม่มีการส่งข้อมูล) เรียกว่าขั้วและกำหนด CPOL (นั่นคือถ้าในกรณีที่ไม่มีการส่งสัญญาณบัส SCLK จะต่ำ ดังนั้น CPOL = 0 และหากขณะนี้บัส SCLK สูง ดังนั้น CPOL=1) ลำดับการอ่านและการเลื่อนแบบสลับกันเรียกว่าเฟส และถูกกำหนดให้เป็น CPHA (หากการอ่านเกิดขึ้นที่ขอบแรกของ SCLK ดังนั้น CPHA = 0 และหากการเลื่อนเกิดขึ้นที่ขอบแรกของ SCLK ดังนั้น CPHA = 1)

ขึ้นอยู่กับการรวมกันของค่า CPOL และ CPHA มีโหมดการทำงานของอินเทอร์เฟซ SPI 4 โหมดซึ่งถูกกำหนดให้เป็น โหมด0, โหมด1, โหมด2และ โหมด3- ด้านล่างนี้เป็นรูปภาพที่แสดงวิธีการติดตั้งและอ่านข้อมูล ขึ้นอยู่กับโหมดที่เลือก

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

และสุดท้าย ฉันจะบอกว่าโหมดยอดนิยมคือ Mode0 และ Mode3

รายละเอียดเพิ่มเติมเกี่ยวกับวิธีการแลกเปลี่ยนเกิดขึ้น สิ่งที่ SPI master ควรสามารถทำได้ และวิธีการนำไปใช้ในซอฟต์แวร์บนไมโครคอนโทรลเลอร์ (โดยใช้ตัวอย่างของตัวควบคุม PIC และ AVR) สามารถอ่านได้ในบทความ

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

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

หมุด SPI และหมุด

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

• MOSI – ข้อมูลจะถูกส่งผ่านบรรทัดนี้ไปยัง Slave จาก Master
• มิโซะ – ใช้เพื่อถ่ายโอนข้อมูลไปยัง Master จาก Slave
• SCLK – การสร้างพัลส์นาฬิกาสำหรับการส่งข้อมูลแบบซิงโครนัส
• SS – การเลือกอุปกรณ์ทาส

ปฏิสัมพันธ์ของอุปกรณ์ SPI

การโต้ตอบของอุปกรณ์จะเริ่มขึ้นเมื่อเอาต์พุต SS ต่ำ

ก่อนเริ่มงานคุณต้องพิจารณา:

• การเปลี่ยนแปลงควรเริ่มต้นจากบิตใด - สูงหรือต่ำ? ลำดับจะถูกปรับปรุงโดยใช้ฟังก์ชัน PI.setBitOrder()
• กำหนดระดับที่เส้น SCK ควรอยู่ในกรณีที่ไม่มีพัลส์นาฬิกา ปรับได้ด้วยฟังก์ชัน SPI.setDataMode()
• เลือกอัตราการถ่ายโอนข้อมูล กำหนดโดยฟังก์ชัน SPI.setClockDivider()

ขั้นตอนต่อไปคือการพิจารณาว่าข้อมูลจะถูกถ่ายโอนในโหมดใด การเลือกโหมดจะถูกกำหนดโดยตัวบ่งชี้เช่นขั้วและเฟสของพัลส์นาฬิกา หากระดับต่ำบันทึก 0 สูง - 1 มีทั้งหมด 4 โหมด:

• โหมด 0 - SPI_MODE0: ขั้ว (CPOL) 0, เฟส (CPHA) 0
• โหมด 1: ขั้ว 0, เฟส 1
• โหมด 2: ขั้ว 1 เฟส 0
• โหมด 3: ขั้ว 1 เฟส 1

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

การเชื่อมต่อที่เป็นไปได้ในอินเทอร์เฟซ SPI มีสองประเภท: แบบอิสระและแบบเรียงซ้อน ในกรณีแรก เมื่อทำการเชื่อมต่อ Master จะกล่าวถึง Slave แต่ละตัวแยกกัน ในกรณีที่สอง การเชื่อมต่อจะเกิดขึ้นทีละตัว เช่น น้ำตก.

การเชื่อมต่อ SPI กับ Arduino

Arduino แต่ละรุ่นมีพิน SPI ของตัวเอง ข้อสรุปเหล่านี้:

• Uno: MOSI สอดคล้องกับพิน 11 หรือ ICSP-4, MISO – 12 หรือ ICSP-1, SCK – 13 หรือ ICSP-3, SS (ทาส) – 10
• Mega1280 หรือ Mega2560: MOSI – 51 หรือ ICSP-4, MISO – 50 หรือ ICSP-1, SCK – 52 หรือ ICSP-3, SS (ทาส) – 53
• เลโอนาร์โด: MOSI – ICSP-4, MISO –ICSP-1, SCK –ICSP-3
• ครบกำหนด: MOSI – ICSP-4, MISO –ICSP-1, SCK –ICSP-3, SS (ต้นแบบ) – 4, 10, 52

คอนโทรลเลอร์ Arduino Due รุ่นล่าสุดขยายขีดความสามารถของผู้ใช้และช่วยให้คุณดำเนินงานได้มากกว่าไมโครคอนโทรลเลอร์อื่นๆ ตัวอย่างเช่น สามารถควบคุมอุปกรณ์ทาสได้โดยอัตโนมัติและเลือกการกำหนดค่าต่างๆ โดยอัตโนมัติ (ความเร็วสัญญาณนาฬิกา โหมด ฯลฯ)

ไลบรารี Arduino SPI

ในการทำงานกับ Arduino ได้มีการสร้างไลบรารีแยกต่างหากที่ใช้ SPI ก่อนที่จะเริ่มโค้ดคุณต้องเพิ่ม #include เพื่อเปิดใช้งานห้องสมุด

ฟังก์ชั่นหลัก:

• start() และ end() – เปิดและปิดการทำงาน ในระหว่างการกำหนดค่าเริ่มต้น บรรทัด SCLK, MOSI และ SS ได้รับการกำหนดค่าที่เอาต์พุต โดยส่งระดับต่ำไปยัง SCLK, MOSI และระดับสูงไปยัง SS ฟังก์ชัน end() ไม่เปลี่ยนระดับบรรทัด จำเป็นต้องปิดบล็อกที่เกี่ยวข้องกับอินเทอร์เฟซบนบอร์ด Arduino
• setBitOrder(คำสั่งซื้อ) – การตั้งค่าลำดับการส่งบิตข้อมูล (MSBFIRST – ลำดับความสำคัญของบิตที่สำคัญที่สุด, LSBFIRST – ลำดับความสำคัญของบิตที่มีนัยสำคัญน้อยที่สุด)
• setClockDivider(ตัวแบ่ง) - การตั้งค่าตัวแบ่งความถี่นาฬิกาหลัก คุณสามารถตั้งค่าตัวหารเป็น 2, 4, 8, 16, 32, 64 และ 128 โดยมีการเขียนดังนี้ - SPI_CLOCK_DIVn โดยที่ n คือตัวหารที่เลือก
• setDataMode(mode) – เลือกหนึ่งในสี่โหมดการทำงาน
• ถ่ายโอน (ค่า) - ถ่ายโอนไบต์จากอุปกรณ์หลักและส่งกลับไบต์ที่ได้รับจากอุปกรณ์สลาฟ
• shiftIn(miso_pin, sclk_pin, bit_order) และ shiftOut(mosi_pin, sclk_pin, order, value) – การรับและส่งข้อมูลสามารถเชื่อมต่อกับพินดิจิทัลใดก็ได้ แต่ก่อนหน้านั้นคุณต้องกำหนดค่าด้วยตนเอง

ข้อดีและข้อเสียของ SPI

ข้อดีของอินเทอร์เฟซ SPI:

• ความสามารถในการส่งข้อมูลขนาดใหญ่ไม่จำกัดเพียง 8 บิต
• ง่ายต่อการใช้งานซอฟต์แวร์
• ความเรียบง่ายของการใช้งานฮาร์ดแวร์
• จำเป็นต้องใช้พินน้อยกว่าอินเทอร์เฟซแบบขนาน
• เฉพาะความเร็วของอุปกรณ์เท่านั้นที่จะจำกัดความถี่สัญญาณนาฬิกาสูงสุด

ข้อบกพร่อง:

• พินจำนวนมากเมื่อเทียบกับ I2C
• Slave ไม่สามารถควบคุมการไหลของข้อมูลได้
• ขาดโปรโตคอลการตรวจจับข้อผิดพลาดมาตรฐาน
• หลายวิธีในการใช้งานอินเทอร์เฟซ
• ขาดการยืนยันการรับข้อมูล

ตัวอย่างการใช้ Arduino SPI ในโปรเจ็กต์ที่มีเซ็นเซอร์ความดัน

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

การใช้เซ็นเซอร์ SCP1000 ทำให้สามารถจดจำพารามิเตอร์ต่างๆ เช่น ความดันและอุณหภูมิ และส่งค่าเหล่านี้ผ่าน SPI ได้

องค์ประกอบพื้นฐานของแบบร่างโปรแกรม

ประการแรก รีจิสเตอร์เซ็นเซอร์จะถูกลงทะเบียนในโค้ดโดยใช้ setup() อุปกรณ์ส่งคืนค่าหลายค่า - หนึ่งใน 19 บิตสำหรับความดันที่ได้รับและอีก 16 บิตสำหรับอุณหภูมิ หลังจากนั้น จะมีการอ่านไบต์อุณหภูมิสองไบต์ และอ่านความดันเป็นสองขั้นตอน ขั้นแรกโปรแกรมจะใช้บิตที่สำคัญที่สุดสามบิตจากนั้น 16 บิตถัดไปหลังจากนั้นโดยใช้การเปลี่ยนบิตค่าทั้งสองนี้จะรวมกันเป็นหนึ่งเดียว ความดันที่แท้จริงคือค่า 19 หลักหารด้วย 4

แรงดันคงที่ = 0x1F; // ขั้นตอนแรกของการกำหนดความดัน (ตรวจพบสามบิตที่สำคัญที่สุด)

ค่าคงที่ PRESSURE_LSB = 0x20; // ขั้นที่สอง ซึ่งกำหนดความดัน 16 บิต

ค่าคงที่ int อุณหภูมิ = 0x21; // 16 บิตสำหรับอุณหภูมิ

หากต้องการอ่านข้อมูลอุณหภูมิและแปลงเป็นเซลเซียส จะใช้องค์ประกอบรหัสต่อไปนี้:

int tempData = readRegister (0x21, 2);

ลอย realTemp = (ลอย) tempData / 20.0; // เพื่อกำหนดค่าอุณหภูมิจริงเป็นเซลเซียส คุณต้องหารตัวเลขผลลัพธ์ด้วย 20

Serial.print("ชั่วคราว

Serial.พิมพ์(realTemp);

การอ่านบิตความดันและรวมเข้าด้วยกัน:

ไบต์ pressure_data_high = readRegister (0x1F, 1);

ความดัน_ข้อมูล_สูง &= 0b00000111;

int pressure_data_low ที่ไม่ได้ลงนาม = readRegister (0x20, 2);

ความดันยาว = ((pressure_data_high<< 16) | pressure_data_low) / 4; //определение давления в Паскалях.

บทสรุปโดยย่อเกี่ยวกับ SPI

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

วันนี้เรามาเริ่มทำความรู้จักกับยางกัน SPI (อินเทอร์เฟซอุปกรณ์ต่อพ่วงแบบอนุกรม).

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

ปัจจัยสำคัญอีกประการหนึ่งในความต้องการความคุ้นเคยของเราก็คือบัสนี้จัดอยู่ในฮาร์ดแวร์ในตัวควบคุม เอวีอาร์.

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

เลยอยากมาทำความรู้จักกับยางรุ่นนี้ให้มากขึ้น

มาเปิดเอกสารทางเทคนิคสำหรับคอนโทรลเลอร์ Atmega8 เปิดหน้าที่แสดง pinout ของคอนโทรลเลอร์นี้และดูว่าพิน 16 ถึง 19 เป็นที่ตั้งของพินบัส SPI

ตอนนี้เพิ่มเติมเล็กน้อยเกี่ยวกับการค้นพบเหล่านี้

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

MOSI (อินพุตทาสเอาต์พุตหลัก)- นี่คือพินเอาท์พุตของอุปกรณ์หลักและอินพุตของอุปกรณ์สลาฟ

มิโซะ (เอาต์พุตทาสอินพุตหลัก)- ในทางตรงกันข้าม เอาต์พุตของทาส อินพุตของมาสเตอร์

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

นี่คือแผนภาพการใช้งานบัส SPI ในคอนโทรลเลอร์ Atmega8

เช่นเดียวกับบัสอื่นๆ มีรีจิสเตอร์จำนวนหนึ่งที่จัดเก็บข้อมูลบางอย่างไว้

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

ทันทีที่มีการส่งข้อมูลทั้งหมด 8 บิตในหนึ่งไบต์ การลงทะเบียนบางอย่างจะส่งสัญญาณให้เราทราบว่ากระบวนการนี้เสร็จสมบูรณ์ หรือค่อนข้างจะเป็นการลงทะเบียนบางอย่าง

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

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

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

วิธีแรกคือรัศมี (คลิกที่ภาพเพื่อขยายภาพ)

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

มีอีกวิธีที่น่าสนใจ - วงแหวนหรือน้ำตก (คลิกที่ภาพเพื่อขยายภาพ)

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

เราจะศึกษารายละเอียดทั้งหมดนี้ในบทเรียนถัดไป เมื่อเราใช้อุปกรณ์บางอย่างในโครงการของเรา

ดูเหมือนว่าจะมีวงจรการส่งข้อมูลผ่านบัส เอสพีไอเราคิดออกแล้ว

ตอนนี้เรามาดูวิธีควบคุมกระบวนการนี้ที่ระดับการลงทะเบียนฮาร์ดแวร์ของคอนโทรลเลอร์ AVR

เราเห็นรีจิสเตอร์เหล่านี้ในแผนภาพบล็อกด้านบนบนหน้า

Atmega8 มีการลงทะเบียนต่อไปนี้สำหรับการให้บริการบัส SPI

SPDR (การลงทะเบียนข้อมูล SPI)- การลงทะเบียนข้อมูลในบล็อกไดอะแกรมคือ DATA BUFFER เราจะป้อนไบต์ลงในรีจิสเตอร์นี้สำหรับการส่งข้อมูลไปยังอุปกรณ์สลาฟในภายหลัง และจากนั้นเราจะอ่านไบต์ข้อมูลที่มาจากอุปกรณ์สลาฟ ไม่จำเป็นที่คอนโทรลเลอร์ของเราจะเป็นอุปกรณ์หลัก ต่อจากนั้นเราจะประกอบวงจรของตัวควบคุมสองตัว ซึ่งตัวหนึ่งจะเป็นทาส ดังนั้นจึงอยู่ในการลงทะเบียนนี้ว่าจะระบุไบต์สำหรับทั้งการส่งและรับ

SPCR (รีจิสเตอร์ควบคุม SPI)- ควบคุมการลงทะเบียน

รีจิสเตอร์นี้ประกอบด้วยบิตต่อไปนี้:

SPIE (เปิดใช้งานการขัดจังหวะ SPI)- บิตที่ทำให้เกิดการขัดจังหวะ

SPE (เปิดใช้งาน SPI)— บิตที่เปิดใช้งานบัส SPI

DORD (ลำดับข้อมูล)— บิตที่กำหนดลำดับบิตที่ถูกส่ง หากตั้งค่าเป็น 1 บิตที่มีนัยสำคัญน้อยที่สุดจะถูกส่งก่อน หากตั้งค่าเป็น 0 บิตที่สำคัญที่สุดจะถูกส่งไป

MSTR (เลือกหลัก/รอง)— บิตที่กำหนดอุปกรณ์ว่าเป็นอุปกรณ์หลักหรืออุปกรณ์รอง เมื่อบิตนี้ถูกตั้งค่าเป็น 1 อุปกรณ์จะเป็นอุปกรณ์หลัก

CPOL (ขั้วนาฬิกา)— ขั้วการซิงโครไนซ์กำหนดที่ขอบของพัลส์ซิงโครไนซ์ที่โหมดสแตนด์บายจะเริ่มขึ้น

หากบิตนี้เป็น 1 เราจะมีโหมดสแตนด์บายที่มีขอบจากน้อยไปมาก และถ้าเป็น 0 เราก็จะมีโหมดสแตนด์บายจากมากไปน้อย

CPHA (เฟสนาฬิกา)— มีความรับผิดชอบเล็กน้อยต่อเฟสสัญญาณนาฬิกา นั่นคือบิตจะถูกส่งไปที่ขอบใด

ลองดูแผนภาพการถ่ายโอนข้อมูลขึ้นอยู่กับการติดตั้ง CPOL และ CPHA

นี่เป็นการพึ่งพาที่น่าสนใจมาก บางครั้งเราเห็นในลักษณะทางเทคนิคของอุปกรณ์ เช่น สามารถทำงานในโหมด SPI 0:0 และ SPI 1:1 ได้ และนี่คือสิ่งที่ต้องคำนึงถึงในการตั้งค่าบิตเหล่านี้

SPR1, SPR0 (เลือกอัตรานาฬิกา SPI)- บิตเหล่านี้เป็นบิตที่รับผิดชอบค่าของตัวแบ่งความถี่การซิงโครไนซ์ซึ่งทำงานร่วมกับบิต SPI2Xอยู่ในทะเบียนสถานะ นอกจากนี้ยังเป็นตัวควบคุมด้วยเนื่องจากแปดบิตในรีจิสเตอร์ควบคุมไม่เพียงพอสำหรับการตั้งค่าทั้งหมด และยังมีบิตว่างมากมายในรีจิสเตอร์สถานะ

SPSR (การลงทะเบียนสถานะ SPI)- การลงทะเบียนสถานะ

SPI2X (บิตความเร็ว SPI สองเท่า)- บิตที่เพิ่มความเร็วเป็นสองเท่า โดยทำงานร่วมกับบิต SPR1 และ SPR0 ของรีจิสเตอร์ควบคุม

เรามาดูการพึ่งพาความถี่ของทั้งสามบิตนี้กัน

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

WCOL (เขียนธง COLlision)— ธงข้อขัดแย้งหรือการชนกันจะถูกตั้งค่าหากมีข้อขัดแย้งเล็กน้อยระหว่างการถ่ายโอนข้อมูล หากในระหว่างการถ่ายโอนข้อมูล มีความพยายามในการเขียนไปยังการลงทะเบียนข้อมูล

ตอนนี้เราสามารถพูดได้ว่าเราคุ้นเคยกับอินเทอร์เฟซ SPI เพียงเล็กน้อยแล้ว

ชมวิดีโอสอน(คลิกที่ภาพ)

ยอดดูโพสต์: 7,187

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

สามบรรทัดใช้ในการส่งข้อมูลไปยัง SPI:

มิโซะ (เอาต์พุตทาสอินพุตหลัก)– ผ่านบรรทัดนี้ Master (master) รับข้อมูลจาก Slave (slave)

MOSI (อินพุตทาสเอาต์พุตหลัก)– Master ส่งข้อมูลไปยัง Slave ผ่านทางบรรทัดนี้

SCK(นาฬิกาอนุกรม)– ทำหน้าที่ส่งสัญญาณนาฬิกาไปยังอุปกรณ์ทาส

มีการใช้ไลน์ด้วย SS(เลือกทาส)ซึ่งกำหนดอุปกรณ์ด้วย ผู้เชี่ยวชาญจะแลกเปลี่ยนข้อมูล

เนื่องจากผู้ผลิตหลายรายใช้ SPI ในอุปกรณ์ของตน ชื่อพินจึงอาจแตกต่างกันเล็กน้อย ด้านล่างนี้เป็นตารางที่มีชื่ออื่น

การใช้งานทางกายภาพ เอสพีไอแสดงถึงรีจิสเตอร์กะสองตัวที่เชื่อมต่อเข้าด้วยกัน

• CPOL = 0 - สัญญาณการซิงโครไนซ์เริ่มต้นที่ระดับต่ำ
• CPOL = 1 - สัญญาณการซิงโครไนซ์เริ่มต้นที่ระดับสูง
• CPHA = 0 - ข้อมูลถูกสุ่มตัวอย่างที่ขอบที่เพิ่มขึ้นของสัญญาณการซิงโครไนซ์
• CPHA = 1 - ข้อมูลถูกสุ่มตัวอย่างบนขอบตกของสัญญาณการซิงโครไนซ์

เอสพีไอ- อินเทอร์เฟซแบบซิงโครนัสนั่นคือเพื่อรับข้อมูลบางส่วนจาก ทาส, ผู้เชี่ยวชาญควรส่งอะไรบางอย่าง ทุกอย่างดูชัดเจน แต่ถ้าเป็นเช่นนั้น ผู้เชี่ยวชาญส่งหนึ่งไบต์และ ทาสฉันควรจะคืนให้เขาสองอันไหม? ในกรณีนี้ อาจารย์ควรส่งบางอย่างให้เขา 2 ครั้ง เช่น 0x00
//ส่งคำสั่ง การตอบสนองควรเป็นสองไบต์ Spi_Master_Transmit(chx); //ส่งบางสิ่งเพื่อรับไบต์แรก Spi_Master_Transmit(0X00);<<= 8; //отправляем что-нибудь для того чтобы принять второй байт Spi_Master_Transmit(0X00); touch_x |= SPDR; touch_x >>= 3;
touch_x = SPDR;

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

อุปกรณ์ต่อพ่วง (Slave) - อุปกรณ์หลักมักเป็นไมโครคอนโทรลเลอร์ การสื่อสารระหว่างอุปกรณ์เกิดขึ้นผ่านสายสี่เส้น ซึ่งเป็นเหตุให้บางครั้ง SPI ถูกเรียกว่า "อินเทอร์เฟซแบบสี่สาย" เหล่านี้คือยาง:) เกิดจากการรวมขั้วของพัลส์นาฬิกา (เราทำงานที่ระดับ HIGH หรือ LOW) ขั้วนาฬิกา, CPOLและเฟสของพัลส์นาฬิกา (การซิงโครไนซ์บนขอบที่เพิ่มขึ้นหรือลดลงของพัลส์นาฬิกา) เฟสนาฬิกา, สพป- คอลัมน์สุดท้ายของตารางมีภาพประกอบที่อธิบาย กับพวกเขา ตัวอย่างระบุช่วงเวลาที่ข้อมูลในสายต้องพร้อมและอ่านโดยอุปกรณ์ จดหมาย ซีมีข้อสังเกตว่าสถานะของข้อมูลในบรรทัดไม่เป็นที่รู้จักหรือไม่สำคัญ

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

2 การใช้งานอินเทอร์เฟซ SPIบนบอร์ดตระกูล Arduino

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

รูปนี้แสดงความสอดคล้องมาตรฐานของพินกับบัส SPI สำหรับ Arduino UNO และ Nano

3 ห้องสมุดมาตรฐานสำหรับการใช้งานผ่านอินเตอร์เฟส SPI

มีการเขียนไลบรารีพิเศษสำหรับ Arduino ที่ใช้โปรโตคอล SPI มีการติดตั้งพร้อมกับสภาพแวดล้อมการพัฒนา อาร์ดูโน่ IDE- มันเชื่อมต่อกันแบบนี้: ในตอนต้นของโปรแกรมที่เราเพิ่ม #รวมSPI.h.

ในการเริ่มต้นใช้โปรโตคอล SPI คุณต้องตั้งค่าการตั้งค่า จากนั้นเริ่มต้นโปรโตคอลโดยใช้ขั้นตอน SPI.beginธุรกรรม()- คุณสามารถทำได้ด้วยคำสั่งเดียว: SPI.beginTransaction (การตั้งค่า SPIS (14000000, MSBFIRST, SPI_MODE0))

ซึ่งหมายความว่าเราเริ่มต้นโปรโตคอล SPI ที่ความถี่ 14 MHz การถ่ายโอนข้อมูลเกิดขึ้นโดยเริ่มจาก MSB (บิตที่สำคัญที่สุด) ในโหมด SPI_MODE0.

หลังจากการกำหนดค่าเริ่มต้น ให้เลือกอุปกรณ์สเลฟโดยย้ายพิน SS ที่เกี่ยวข้องไปที่สถานะ ต่ำ- จากนั้นเราถ่ายโอนข้อมูลไปยังอุปกรณ์ทาสด้วยคำสั่ง SPI.โอน()- หลังจากการโอนเราจะคืน SS ให้กับรัฐ สูง.

การทำงานกับโปรโตคอลเสร็จสิ้นด้วยคำสั่ง SPI.endธุรกรรม().

ขอแนะนำให้ลดเวลาการถ่ายโอนระหว่างคำสั่ง SPI.beginTransaction() และ SPI.endTransaction() เพื่อหลีกเลี่ยงปัญหาหากอุปกรณ์อื่นพยายามเริ่มการถ่ายโอนข้อมูลโดยใช้การตั้งค่าที่แตกต่างกัน

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

#กำหนด PIN_SPI_SS (10) #กำหนด PIN_SPI_MOSI (11) #กำหนด PIN_SPI_MISO (12) #กำหนด PIN_SPI_SCK (13)

หมุดเหล่านี้ถูกกำหนดไว้ในไฟล์ pins_arduino.hซึ่งอยู่ระหว่างทาง %programfiles%\arduino-(เวอร์ชั่น)\hardware\arduino\avr\variants\(หากคุณติดตั้งโปรแกรมในตำแหน่งมาตรฐาน) ตัวอย่างเช่น หากต้องการลดพินการเลือกทาสลงเป็นสถานะ "0" คุณสามารถเขียนได้:

ดิจิตอลเขียน(PIN_SPI_SS, ต่ำ);

4 การเชื่อมต่อกะลงทะเบียนถึง Arduino

พิจารณาการใช้งานอินเทอร์เฟซ SPI ในทางปฏิบัติ เราจะให้ไฟ LED สว่างขึ้นโดยการควบคุมรีจิสเตอร์กะ 8 บิตผ่านบัส SPI มาเชื่อมต่อกับ Arduino กันเถอะ กะทะเบียน 74HC595- เราจะเชื่อมต่อ LED ที่มีค่าระบุ 220 โอห์มกับแต่ละเอาต์พุตรีจิสเตอร์ 8 ตัวผ่านตัวต้านทานแบบจำกัด แผนภาพแสดงในรูป

5 ร่างสำหรับควบคุมการลงทะเบียนกะผ่านอินเทอร์เฟซ SPI

มาเขียนแบบร่างที่ใช้ "คลื่นเคลื่อนที่" โดยการส่องสว่าง LED ที่เชื่อมต่อกับเอาต์พุตของ shift register ตามลำดับ

#รวม const int pinSelect = 8; // ลงทะเบียนเลือกพิน การตั้งค่าเป็นโมฆะ () ( SPI.เริ่มต้น(); // การเริ่มต้นอินเทอร์เฟซ SPI pinMode (pinSelect, OUTPUT); // digitalWrite (พินเลือก, ต่ำ); // เลือกอุปกรณ์ทาส (ลงทะเบียน) SPI.transfer (0); // ล้างเนื้อหาของการลงทะเบียน digitalWrite (pinSelect, HIGH); // สิ้นสุดการส่ง Serial.begin (9600); } เป็นโมฆะวน() (สำหรับ (int i=0; i )

ขั้นแรก มาเชื่อมต่อไลบรารี SPI และเริ่มต้นอินเทอร์เฟซ SPI ลองกำหนดพิน 8 เป็นพินการเลือกทาส SS มาล้าง shift register โดยส่งค่า "0" ไปให้ เริ่มต้นพอร์ตอนุกรม

หากต้องการให้ไฟ LED เฉพาะเจาะจงสว่างขึ้นโดยใช้ shift register คุณจะต้องใส่ตัวเลข 8 บิตกับอินพุต ตัวอย่างเช่นเพื่อให้ LED ตัวแรกสว่างขึ้นเราจะระบุเลขฐานสอง 00000001 สำหรับอันที่สอง - 00000010 สำหรับอันที่สาม - 00000100 เป็นต้น เมื่อแปลงเลขฐานสองเหล่านี้เป็นระบบเลขฐานสิบ จะเกิดลำดับต่อไปนี้: 1, 2, 4, 8, 16, 32, 64, 128 และเป็นเลขยกกำลังสองตั้งแต่ 0 ถึง 7

ตามวัฏจักรนั้น วนซ้ำ()ขึ้นอยู่กับจำนวน LED เราคำนวณใหม่ตั้งแต่ 0 ถึง 7 ฟังก์ชั่น ธาร(ฐาน, องศา)ยกกำลัง 2 ให้กับตัวนับลูป ไมโครคอนโทรลเลอร์ทำงานไม่ถูกต้องนักกับตัวเลขประเภท "สองเท่า" ดังนั้นเราจึงใช้ฟังก์ชันการปัดเศษเพื่อแปลงผลลัพธ์เป็นจำนวนเต็ม กลม()- และเราโอนหมายเลขผลลัพธ์ไปยังทะเบียนกะ เพื่อความชัดเจน ค่าที่ได้รับระหว่างการดำเนินการนี้จะแสดงในมอนิเตอร์พอร์ตอนุกรม: หน่วย "ทำงาน" ผ่านการคายประจุ - ไฟ LED จะสว่างขึ้นเป็นคลื่น

6 “รันนิ่งเวฟ”จากไฟ LED

ไฟ LED จะสว่างขึ้นทีละดวง และเราสังเกตเห็น "คลื่น" ของไฟที่กำลังวิ่งอยู่ LED ถูกควบคุมโดยใช้ shift register ซึ่งเราเชื่อมต่อผ่านอินเทอร์เฟซ SPI ด้วยเหตุนี้จึงใช้พิน Arduino เพียง 3 พินเพื่อควบคุม LED 8 ดวงหากเราเชื่อมต่อ LED เข้ากับพอร์ตดิจิทัลของ Arduino โดยตรง เราจะต้องใช้พอร์ตแยกต่างหากสำหรับ LED แต่ละตัว

เราศึกษาตัวอย่างที่ง่ายที่สุดของ Arduino ที่ทำงานกับบัส SPI เราจะพิจารณารายละเอียดเพิ่มเติมเกี่ยวกับการทำงานของการลงทะเบียนกะหลาย ๆ อันที่มีการเชื่อมต่อแบบอิสระและแบบเรียงซ้อนในบทความแยกต่างหาก