วนรอบด้วยซีพียูสมัยใหม่ (เช่น ARM)

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

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

สมมติว่าลูปต่อไปนี้เริ่มต้นในขอบเขตของคำหนึ่งจะพิจารณาจากข้อมูลจำเพาะได้อย่างแม่นยำว่าจะใช้เวลานานแค่ไหน (สมมติว่า Cortex-M3 กับหน่วยความจำ zero-wait-state;

myloop:
  mov r0, r0; คำแนะนำง่ายๆสั้น ๆ เพื่อให้คำแนะนำเพิ่มเติมสามารถดึงข้อมูลล่วงหน้าได้
  mov r0, r0; คำแนะนำง่ายๆสั้น ๆ เพื่อให้คำแนะนำเพิ่มเติมสามารถดึงข้อมูลล่วงหน้าได้
  mov r0, r0; คำแนะนำง่ายๆสั้น ๆ เพื่อให้คำแนะนำเพิ่มเติมสามารถดึงข้อมูลล่วงหน้าได้
  mov r0, r0; คำแนะนำง่ายๆสั้น ๆ เพื่อให้คำแนะนำเพิ่มเติมสามารถดึงข้อมูลล่วงหน้าได้
  mov r0, r0; คำแนะนำง่ายๆสั้น ๆ เพื่อให้คำแนะนำเพิ่มเติมสามารถดึงข้อมูลล่วงหน้าได้
  mov r0, r0; คำแนะนำง่ายๆสั้น ๆ เพื่อให้คำแนะนำเพิ่มเติมสามารถดึงข้อมูลล่วงหน้าได้
  เพิ่ม r2, r1, # 0x12000000; การเรียนการสอน 2 คำ
  ; ทำซ้ำต่อไปนี้อาจมีตัวถูกดำเนินการแตกต่างกัน
  ; จะเพิ่มค่าไปเรื่อย ๆ จนกว่าจะเกิดขึ้น
  itcc
  addcc r2, r2, # 0x12000000; การเรียนการสอน 2 คำรวมทั้ง "word" พิเศษสำหรับ itcc
  itcc
  addcc r2, r2, # 0x12000000; การเรียนการสอน 2 คำรวมทั้ง "word" พิเศษสำหรับ itcc
  itcc
  addcc r2, r2, # 0x12000000; การเรียนการสอน 2 คำรวมทั้ง "word" พิเศษสำหรับ itcc
  itcc
  addcc r2, r2, # 0x12000000; การเรียนการสอน 2 คำรวมทั้ง "word" พิเศษสำหรับ itcc
; ... ฯลฯ พร้อมกับคำแนะนำสองคำที่มีเงื่อนไขเพิ่มเติม
  sub r8, r8, # 1
  bpl myloop

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

มันจะดีถ้า ARM สามารถระบุเงื่อนไขบางอย่างภายใต้เวลาการเรียนการสอน "มัน" จะกำหนดขึ้น (เช่นถ้าไม่มีการรอคอยหรือการแย่งรหัสรถบัสและสองคำสั่งก่อนหน้านี้คือคำแนะนำการลงทะเบียนแบบ 16 บิตเป็นต้น) แต่ฉันไม่เห็นสเป็คดังกล่าว

แอปพลิเคชันตัวอย่าง

สมมติว่ามีใครพยายามออกแบบบอร์ดลูกเล่นสำหรับ Atari 2600 เพื่อสร้างเอาต์พุตวิดีโอคอมโพเนนต์ที่ 480P 2,600 มีนาฬิกาพิกเซล 3.579MHz และนาฬิกา CPU 1.19MHz (นาฬิกาจุด / 3) สำหรับวิดีโอคอมโพเนนต์ 480P แต่ละบรรทัดจะต้องส่งออกสองครั้งโดยมีเอาต์พุตนาฬิกา 7.158MHz จุด เนื่องจากชิปวิดีโอของ Atari (TIA) แสดงผลหนึ่งใน 128 สีโดยใช้เป็นสัญญาณ luma 3 บิตบวกสัญญาณเฟสที่มีความละเอียดประมาณ 18ns จึงยากที่จะกำหนดสีได้อย่างแม่นยำเพียงแค่ดูที่เอาต์พุต วิธีที่ดีกว่าคือการสกัดกั้นการเขียนลงทะเบียนสีสังเกตค่าที่เขียนและป้อนแต่ละการลงทะเบียนในค่าความส่องสว่าง TIA ที่สอดคล้องกับหมายเลขการลงทะเบียน

ทั้งหมดนี้สามารถทำได้ด้วย FPGA แต่อุปกรณ์ ARM ที่รวดเร็วบางรุ่นอาจมีราคาถูกกว่า FPGA ที่มี RAM มากพอที่จะรองรับการบัฟเฟอร์ที่จำเป็น (ใช่ฉันรู้ว่าสำหรับไดรฟ์ข้อมูลดังกล่าวอาจทำให้เกิดต้นทุนได้ ' ปัจจัยที่แท้จริง) การกำหนดให้ ARM ดูสัญญาณนาฬิกาที่เข้ามาจะเพิ่มความเร็วของ CPU ที่ต้องการอย่างมาก การนับจำนวนรอบที่คาดการณ์ได้อาจทำให้สิ่งต่าง ๆ สะอาดขึ้น

วิธีการออกแบบที่ค่อนข้างง่ายคือให้ CPLD ดู CPU และ TIA และสร้างสัญญาณซิงค์ RGB + 13 บิตจากนั้นให้ ARM DMA จับค่า 16 บิตจากพอร์ตหนึ่งและเขียนลงในอีกช่วงเวลาที่เหมาะสม มันจะเป็นความท้าทายด้านการออกแบบที่น่าสนใจเพื่อดูว่า ARM ราคาถูกสามารถทำทุกอย่างได้หรือไม่ DMA อาจเป็นประโยชน์ในแง่มุมหนึ่งของวิธีการแบบ all-in-one หากผลกระทบต่อจำนวนรอบของ CPU สามารถคาดการณ์ได้ (โดยเฉพาะอย่างยิ่งหากวงจร DMA สามารถเกิดขึ้นได้ในรอบเมื่อหน่วยความจำบัสไม่ได้ทำงาน) แต่ในบางจุด ARM จะต้องทำการค้นหาตารางและฟังก์ชั่นตรวจสอบบัส โปรดทราบว่าแตกต่างจากสถาปัตยกรรมวิดีโอจำนวนมากที่มีการลงทะเบียนสีในช่วงเวลาว่างอาตาริ 2600 มักเขียนไปยังการลงทะเบียนสีระหว่างส่วนที่แสดงของเฟรม

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

ฉันลงคะแนนให้ DMA มีความยืดหยุ่นอย่างมากใน Cortex-M3 ขึ้นไป - และคุณสามารถทำสิ่งที่บ้าคลั่งเช่นรับข้อมูลโดยอัตโนมัติจากที่เดียวและส่งออกไปที่อื่นด้วยอัตราที่กำหนดหรือในบางเหตุการณ์โดยไม่ต้องใช้วงจร CPU ใด ๆ DMA น่าเชื่อถือมากขึ้น

แต่มันอาจจะยากที่จะเข้าใจในรายละเอียด

อีกตัวเลือกหนึ่งคือแกนประมวลผลนุ่มนวลบน FPGA พร้อมการติดตั้งฮาร์ดแวร์ในสิ่งที่แน่นหนาเหล่านี้

มีข้อมูลเวลา แต่ตามที่คุณชี้ให้เห็นอาจเป็นบางครั้งคลุมเครือ มีข้อมูลเวลาจำนวนมากในส่วนที่ 18.2 และตารางที่ 18.1 ของคู่มืออ้างอิงด้านเทคนิคสำหรับ Cortex-M3 เช่น ( pdf ที่นี่ ) และข้อความที่ตัดตอนมาที่นี่:

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

[1] สาขาใช้เวลาหนึ่งรอบสำหรับการเรียนการสอนและจากนั้นโหลดใหม่สำหรับการเรียนการสอนเป้าหมาย สาขาที่ไม่ได้ถือรวม 1 รอบ สาขาที่ถ่ายโดยทันทีคือปกติ 1 รอบของการโหลดไปป์ไลน์ (รวม 2 รอบ) สาขาที่มีตัวถูกดำเนินการลงทะเบียนโดยปกติแล้วจะมีการโหลดไปป์ไลน์ 2 รอบ (รวม 3 รอบ) การโหลดไปป์ไลน์นั้นมีความยาวมากกว่า [ นานเท่าไหร่?] เมื่อทำการแยกคำสั่งไปยังคำสั่งแบบ 32 บิตที่ไม่ได้จัดแนวนอกเหนือจากการเข้าถึงหน่วยความจำที่ช้าลง คำใบ้สาขาจะถูกส่งไปยังโค้ดบัสที่อนุญาตให้ระบบช้าลง [โหลดช้าลงเท่าใด] โหลดล่วงหน้า สิ่งนี้สามารถ [เป็นตัวเลือกหรือไม่?] ลด [โดยเท่าไหร่?] การลงโทษเป้าหมายสาขาสำหรับหน่วยความจำช้าลง แต่ไม่น้อยกว่าที่แสดงที่นี่

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

[3] UMULL / SMULL / UMLAL / SMLAL ใช้การยุติก่อนกำหนดโดยขึ้นอยู่กับขนาดของค่าต้นทาง [ขนาดใด?] สิ่งเหล่านี้ขัดจังหวะ (ยกเลิก / รีสตาร์ท) ด้วยเวลาแฝงตัวที่เลวร้ายที่สุดของหนึ่งรอบ รุ่น MLAL ใช้เวลา4-7 รอบและรุ่นครุ่นคิดใช้เวลา3-5 รอบ สำหรับ MLAL เวอร์ชันที่เซ็นชื่อจะยาวกว่ารอบที่ไม่ได้ลงชื่อหนึ่งรอบ

[4] คำแนะนำด้านไอทีสามารถพับเก็บได้ [เมื่อไหร่? ดูความคิดเห็น]

[5] การกำหนดเวลา DIV ขึ้นอยู่กับเงินปันผลและหาร [ปัญหาเดียวกับ MUL] DIV สามารถอินเตอร์รัปต์ได้ (ละทิ้ง / รีสตาร์ท) โดยมีเวลาแฝงตัวที่แย่ที่สุดของหนึ่งรอบ เมื่อเงินปันผลและตัวหารมีขนาดใกล้เคียงกัน [การคล้ายกันอย่างไร?] การหารจะยุติลงอย่างรวดเร็ว เวลาขั้นต่ำสำหรับกรณีของตัวหารที่ใหญ่กว่าเงินปันผลและตัวหารของศูนย์ ตัวหารของศูนย์ส่งกลับศูนย์ (ไม่ใช่ความผิด) แม้ว่าตัวดักจับการดีบักจะพร้อมใช้งานในการตรวจจับกรณีนี้ [มีช่วงไหนบ้างที่มอบให้ MUL?]

[6] การนอนหลับเป็นหนึ่งรอบสำหรับการเรียนการสอนและเพิ่มรอบการนอนหลับได้มากที่สุด WFE ใช้หนึ่งรอบเมื่อเหตุการณ์ผ่านไป ปกติแล้ว WFI จะมีมากกว่าหนึ่งรอบยกเว้นว่าการขัดจังหวะจะเกิดขึ้นเมื่อเข้าสู่ WFI

[7] ISB ใช้เวลาหนึ่งรอบ (ทำหน้าที่เป็นสาขา) DMB และ DSB ใช้เวลาหนึ่งรอบยกเว้นว่าข้อมูลค้างอยู่ในบัฟเฟอร์การเขียนหรือ LSU หากการขัดจังหวะเข้ามาในระหว่างสิ่งกีดขวางสิ่งนั้นจะถูกยกเลิก / รีสตาร์ท

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

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

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

วิธีหนึ่งในการแก้ไขปัญหานี้คือการใช้อุปกรณ์ที่มีการกำหนดเวลาที่กำหนดได้หรือคาดการณ์ได้เช่นชิป Parallax Propeller และ XMOS:

http://www.parallaxsemiconductor.com/multicoreconcept

http://www.xmos.com/

การนับรอบทำงานได้ดีมากกับ Propeller (ต้องใช้ภาษาแอสเซมบลี) ในขณะที่อุปกรณ์ XMOS มียูทิลิตี้ซอฟต์แวร์ที่ทรงพลังมาก XMOS Timing Analyzer ซึ่งทำงานกับแอปพลิเคชันที่เขียนด้วยภาษาโปรแกรม XC:

https://www.xmos.com/download/public/XMOS-Timing-Analyzer-Whitepaper%281%29.pdf

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

ตัวอย่างที่ดีของเรื่องนี้คือ Microchip PICs ส่วนใหญ่ ซีรี่ส์ 10, 12, 16 และ 18 มีจังหวะการสอนที่ดีและคาดการณ์ได้ดีมาก นี่เป็นคุณสมบัติที่มีประโยชน์ในประเภทการควบคุมขนาดเล็กที่ชิปเหล่านี้มีจุดประสงค์เพื่อ

เมื่อคุณหลีกหนีจากต้นทุนที่ต่ำมากนักออกแบบจึงสามารถใช้พื้นที่ชิปเพิ่มขึ้นเพื่อให้ได้ความเร็วที่สูงขึ้นจากสถาปัตยกรรมที่แปลกใหม่กว่าเดิมคุณยังสามารถหลีกเลี่ยงการคาดเดาได้ ลองดูตัวแปร x86 ที่ทันสมัยเป็นตัวอย่างที่ยอดเยี่ยมของสิ่งนี้ มีหลายระดับของแคช, การทำให้มีชีวิตชีวาของหน่วยความจำ, lookahead fetch, pipelining, และอื่น ๆ ที่ทำให้วงจรการนับคำสั่งแทบเป็นไปไม่ได้ ในแอปพลิเคชันนี้ไม่สำคัญว่าเนื่องจากลูกค้าสนใจความเร็วสูงไม่ใช่การคาดการณ์เวลาการเรียนการสอน

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

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

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

ไม่มันไม่ง่ายเหมือน PIC แต่ก็ยังสามารถทำได้โดยเฉพาะถ้าความล่าช้า / เวลาเข้าใกล้อัตรานาฬิกาของโปรเซสเซอร์ จำนวนผู้จำหน่าย ARM ที่ให้คุณคูณอัตรานาฬิกาและพูด 60MHz จากการอ้างอิง 8 mhz ดังนั้นถ้าคุณต้องการอินเทอร์เฟซ 2mhz แทนที่จะทำทุก ๆ 4 คำสั่งคุณสามารถเพิ่มนาฬิกา (ถ้าคุณมี งบประมาณพลังงาน) จากนั้นใช้ตัวจับเวลาและมอบนาฬิกาให้ตัวเองเพื่อทำสิ่งอื่นเช่นกัน