แรงบันดาลใจจากเกมของคำถามชีวิตนี้

Wireworldจำลอง "อิเล็กตรอน" ที่ไหลผ่าน "สาย" การจัดเรียงอย่างง่าย ๆ ที่สร้างพฤติกรรมประตูตรรกะแบบทั่วไป

ฉันขอท้าให้คุณสร้างนาฬิกาดิจิตอลใน Automaton เซลลูลาร์ Wireworld นาฬิกาของคุณจะต้องนับตั้งแต่ 00:00 ถึง 23:59 ตามปกติหรือถึง 11:59 ด้วยตัวบ่งชี้ AM / PM จากนั้นรีเซ็ต

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

เวลาของพฤติกรรมนาฬิกาควรสอดคล้องกัน การจำลองควรใช้จำนวนเห็บเท่ากันสำหรับแต่ละช่วงการเปลี่ยนสถานะระหว่าง 1440 อิเล็กตรอนใด ๆ บนสาย 16 เส้นควรปล่อยออกจากส่วน A ในเวลาเดียวกันและเริ่มการเดินทางแบบขนาน

นี่คือการแข่งขันรหัส - กอล์ฟ คะแนนของคุณคือพื้นที่ของกล่องขอบชิดแกนโดยรอบส่วนที่ 1

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

ส่วน B ของคุณอาจใหญ่หรือเล็กก็ได้ตามต้องการ เป็นสิ่งจำเป็นเท่านั้นเพื่อให้สามารถเห็นผลลัพธ์ของการส่งของคุณโดยผู้ใช้เนื่องจากไม่มีวิธีง่ายๆเพียงแค่ "debug" เอาต์พุตจากวงจร wireworld มี BCD-> วงจรเซกเมนต์ 7 ส่วนหลายช่องทางออนไลน์ รู้สึกอิสระที่จะใช้สิ่งที่คุณต้องการหรือสร้างของคุณเองหากคุณต้องการสายสัญญาณนาฬิกาและแสดงตัวบ่งชี้ AM / PM ของคุณในระดับที่คล้ายกับตัวเลข

แก้ไข: ส่วน B เป็นตัวเลือกในขณะนี้ หากคุณเพิ่งมีเอาต์พุต BCD จากส่วน A ของคุณคุณสามารถส่งมันได้ มันจะน่าเบื่อมากขึ้นในการยืนยันการทำงานของนาฬิกา แต่ฉันสามารถอ่านแถวของบิตได้ดีในการจำลองหยุดชั่วคราว

นาฬิกาล็อค

คะแนน - 53,508 (ซึ่งมีเพียง 36,828 ใช้งานเนื่องจากการออกแบบรูปตัว L)

การบันทึกที่มีคุณภาพสูง - https://1drv.ms/u/s!ArQEzxH5nQLKhvt_HHfcqQKo2FODLQ
รูปแบบ Golly - https://1drv.ms/u/s!ArQEzxH5nQLKhvwAmwCY-IPBBBBBBBB

หลักการชี้นำ -

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

ส่วนที่ 1: ตัวนับนาที

คณิตศาสตร์

นับจาก 0 ถึง 9 ในไบนารี (สำหรับหลักนาทีที่สำคัญน้อยที่สุด) ไปดังนี้ -

0 - 0000
1 - 0001
2 - 0010
3 - 0011
4 - 0100
5 - 0101
6 - 0110
7 - 0111
8 - 1,000
9 - 1001

การอ่านว่าในฐานะคอลัมน์บิตที่มีนัยสำคัญน้อยที่สุด (2 ^ 0 หน่วยบิตสตรีม) ไปที่ 01010101 สตรีม 2 ^ 1 หน่วยไปที่ 0011001100, สตรีมหน่วยที่ 2 ^ 2 ไปที่ 0000111100 และสตรีม 2 ^ 3 หน่วยไป 0000000011

คนแรกที่ง่าย - เพียงแค่ flip-flip 01 ตลอดไป ที่สามคือกระแสของสี่ 1s, หก 0s, เฟสเลื่อนโดยศูนย์หก ที่สี่คือกระแสของแปด 0s และสอง 1s

ประการที่สองนั้นหนักขึ้นเล็กน้อยเนื่องจากมีความไม่สมดุลที่น่ารังเกียจ อย่างไรก็ตามฉันสังเกตเห็นว่า (ที่ไหนคือผู้ให้บริการ concat):

0011001100 0011001100 = 0011001100 NOT (1100110011) = 00110011001100110011 XOR 00000000001111111111 = 5 (0011) XOR 00000000001111111111 XOR

(โดยบังเอิญตามที่กล่าวถึงในภายหลังนาฬิกาส่วนใหญ่ของฉันจะทำงานบนทิกเกอร์ 60 จังหวะคลื่น 00000000001111111111 คู่ยาวเป็นที่ต้องการของทิกเกอร์ 120 จังหวะเข้ามา)

ออกแบบ

กระแสเอาต์พุตจากบนลงล่างไปยังหน่วยของนาที (2 ^ 0, 2 ^ 1, 2 ^ 2, 2 ^ 3) จากนั้นนับสิบนาที (2 ^ 0, 2 ^ 2, 2 ^ 1) โปรดทราบว่าสายสองเส้นด้านล่างไขว้กัน

1. นาฬิกาหลัก 120 จังหวะ
2. จะวางอิเล็กตรอนไว้ที่จุดเริ่มต้นที่เย็น โดยไม่มีหางอิเลคตรอนใดแยกออกเป็นสองทิศทาง แต่ไดโอดด้านบนจะจับหนึ่งในนั้นให้อิเล็กตรอนที่ดีขี่จักรยานไปรอบ ๆ และวนรอบ 120 จังหวะ
3. นาฬิกาสำรอง 12 จังหวะ
4. คอยล์ของตัวนำ + ไดโอดเริ่มต้นด้วยนาฬิกา 12 จังหวะที่สอง คำพูดไม่สามารถอธิบายได้ว่าชิ้นส่วนชิ้นเล็กชิ้นน้อยชิ้นนี้จะซิงค์กันอย่างไร คุณต้องทำการซิงค์นาฬิกาบีท 120 และ 60 จากนั้นซิงก์ใน 12-beat และ frequency halver 24-pseudo clock ตามด้วยการย้อนกลับนาฬิกา 24-beat ไปที่นาฬิกา 120-beat มิฉะนั้นประตู XOR จะไม่ทำงาน .
5. กะระยะ
6. รองเท้าแตะ. อิเล็กตรอนหนึ่งตัวบนอินพุตจะเข้าสู่เส้นที่กำหนดก่อนจากนั้นตามระยะเวลาที่กำหนดมาก ๆ จะกระทบกับสายรีเซ็ตที่ให้การพัลส์หนึ่งครั้งอย่างแม่นยำและออกหนึ่งพัลส์
7. การเพิ่ม humps ที่นี่ - บนบรรทัดรีเซ็ตเพิ่มความล่าช้าระหว่างการตั้งค่าและการรีเซ็ตบน flip-flop แต่ละโคกพิเศษให้ชีพจรเพิ่ม flip-flop ด้านล่างมี humps พิเศษเก้าตัวดังนั้นจึงมีสิบพัลส์ระหว่างการตั้งค่าและการรีเซ็ต
8. ประตู XOR สำหรับสาย 2 นาที 1 หากินของฉัน
9. และ - ไม่เกทและความยาวส่วนที่เฉพาะเจาะจงมากหมายถึงพัลส์อิเล็กตรอนแต่ละอันที่ผ่านมากลับมาเป็นสองเท่าในตัวมันเองและทำลายอิเลคตรอนด้านหลัง ลดความถี่ สร้างนาฬิกา 24 จังหวะจากแหล่งข้อมูลรอง 12 จังหวะ
10. นาฬิการอง 60 จังหวะซึ่งใช้งานได้จริง มันง่ายกว่าที่จะเริ่มต้นนาฬิกาอย่างรวดเร็วจากนาฬิกาที่ช้ากว่าดังนั้นนาฬิกาที่ช้าที่สุด (120 ครั้ง) จะเป็นมาสเตอร์แม้ว่ามันจะแทบจะไม่ได้ใช้ก็ตาม นาฬิกา 60 จังหวะคือหัวใจของสิ่งนี้
11. สายป้อนกลับซึ่งมีอิเลคตรอนเฉพาะเมื่อนาฬิกา 60-ติ๊กถูกฟ้อง มันถูกใช้ร่วมกับประตู AND-NOT เพื่อหยุดนาฬิกาที่จะเริ่มต้นใหม่จากต้นแบบ 120 จังหวะ มิฉะนั้นสิ่งที่น่ากลัวมากมายเกิดขึ้น & Ctrl-Z เป็นผู้ช่วยให้รอด
12. ไดโอดที่นาฬิกาเริ่มต้น 60 จังหวะ
13. อุปกรณ์ทั้งหมดนี้เป็นฟลิปฟล็อปและเกทและเกท AND-NOT รวมกัน มันให้สลัก หนึ่งชีพจรในการเริ่มต้นมันหนึ่งชีพจรในการหยุดมัน
14. ห่วงลวดเพื่อปรับเทียบสลักให้เป็น 10 พัลส์ใน, 10 พัลส์สำหรับหนึ่งในสิบพัลส์อินพุต หากไม่มีมันเราจะได้รับ 12 พัลส์เมื่อ, 8 พัลส์ปิด สลักแบบสิบต่อสิบเหล่านี้เป็นองค์ประกอบพื้นฐานของบล็อกสิบนาทีในลักษณะเดียวกับรองเท้าแตะขนาด 6 ไมครอน (1 พัลส์) ที่เป็นส่วนประกอบพื้นฐานของหน่วยนาที
15. ชีพจรเริ่มต้นเริ่มต้นเย็นก่อให้เกิดปัญหาทุกประเภทรวมถึงการเต้นสองครั้งนอกเฟสเมื่อนาฬิกาเริ่มทำงาน สิ่งนี้จะทำให้สลักหลุด เกทและเกทนี้จับและปลดพัลส์การซิงค์โดยเฉพาะอย่างยิ่งพัลส์เริ่มต้น
16. นี่เป็นส่วนหนึ่งของการออกแบบที่ฉันเสียใจในการหวนกลับ ใช้อิเล็กตรอนแบ่งออกเป็นห้าและทำลายอิเลคตรอนทั้งห้าที่อยู่ข้างหลังโดยใช้ 111111 ถึง 100,000
17. สิ่งนี้จะใช้อิเล็กตรอนและเย็บด้านหน้า สองขั้นตอนข้างหน้ามีความแม่นยำ ใช้เวลา 100,000 และทำให้ 101,000 รวมกับส่วนที่ 16 เราได้ 111111 -> 100000 -> 101000 ในการหวนกลับฉันต้องการ 111111 -> 101010 -> 101000; มันจะได้รับผลเช่นเดียวกันในพื้นที่น้อย
18. รูปแบบข้างต้นจะถูกผลักเข้าไปในสลักด้านล่างเพื่อให้ได้ 20 ใน, 40 นี่คือการแยกครึ่งคือเฟสขยับจาก 20 หน่วยแล้วรูปแบบเหล่านี้ทั้งสองกระแสบิตคำสั่งสูงของสิบนาที

ส่วนที่สอง: ตัวนับชั่วโมง

คำอธิบาย

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

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

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

ต่อจากนั้นโยงสอง "latch & catch" เป็นอนุกรมและคุณมีอิเล็กตรอนเพียงหนึ่งในสี่เท่านั้นที่ผ่าน

ถัดไปใช้สลัก "อันที่สาม" แต่คราวนี้ฝังสลักที่สี่ทั้งหมดแล้วจับบนสาย SET flip-flop ระหว่างประตู AND-NOT และ SET flip-flop ฉันจะปล่อยให้คุณคิดเกี่ยวกับวิธีการทำงานนี้ แต่เวลานี้มีเพียงหนึ่งในสามของอิเล็กตรอนผ่านไปโดยไม่คำนึงถึงว่าระยะเวลาที่ล่าช้าอยู่ระหว่างอิเล็กตรอนเหล่านั้น

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

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

ใช้อิเล็กตรอนเหล่านี้ - หนึ่งชั่วโมงลงตัวนำที่แตกต่างกันและกดบรรทัด SET flip-flop จากนั้นสาย RESET บนฟลิปฟล็อปเดียวกันนั้นจะถูกตีโดยตัวนำของชั่วโมงถัดไป

สุดท้าย - ใช้พัลส์เหล่านี้และส่งไปยัง ROM ขนาดเจ็ดและครึ่งไบต์ (หน่วยความจำแบบอ่านอย่างเดียว) เพื่อส่งออก BCD bitstreams ที่ถูกต้อง ดูที่นี่สำหรับคำอธิบายโดยละเอียดเพิ่มเติมเกี่ยวกับ WireWorld ROM: http://www.quinapalus.com/wires6.html

ออกแบบ

1. อินพุตหนึ่งอิเล็กตรอนต่อชั่วโมง
2. สลักแรก
3. จับครั้งแรก
4. "Latch & catch" ที่ฝังอยู่ในบรรทัด "latch & catch" SET ภายนอก
5. และประตู
6. สลัก AM / PM (เปิด / ปิดหนึ่งครั้งทุกสิบสองชั่วโมง)
7. เส้นลวดแต่ละเส้นมีความยาว 6x60 = 360 หน่วย
8. Flip / Flop เปิดด้านข้างเพื่อสร้างโปรไฟล์ขนาดเล็ก
9. ROM เจ็ดไบต์ครึ่ง

หมายเหตุ

1. เนื่องจากอิเล็กตรอนหนึ่งตัวต่อนาทีการออกแบบขนาด 6 ไมครอนจึงทำการจำลองที่หกชั่วคนต่อนาที (หนึ่งรุ่นทุกๆ 10 วินาที) สำหรับนาฬิกาเรียลไทม์
2. บรรทัด AM / PM สูง (1) สำหรับ AM, ต่ำ (0) สำหรับ PM นี่อาจเป็นวิธีที่ผิดปกติเล็กน้อยในการเลือก แต่มีเหตุผล ในช่วงเริ่มเย็นของนาฬิกาบรรทัด AM / PM ต่ำตามธรรมชาติ (0) เริ่มแรก ทันทีที่สาย AM / PM ถูกดึงสูง (1) สิ่งนี้บ่งชี้ว่าการนับได้เริ่มต้นที่ 12:00 AM เอาต์พุตทั้งหมดก่อนจุดนี้ควรถูกมองข้ามเอาต์พุตทั้งหมดหลังจากจุดนี้ถือว่ามีความหมาย

ลิงค์ที่มีประโยชน์

• ผมได้เรียนรู้พื้นฐานของ WireWorld จากhttp://www.quinapalus.com/wi-index.html ทรัพยากรที่ยอดเยี่ยม

• ในการสร้างและจำลองหุ่นยนต์อัตโนมัติฉันใช้ Golly: http://golly.sourceforge.net/

• ฉันใช้การออกแบบเกทและจากhttp://mathworld.wolfram.com/WireWorld.html

• และฉันเพิ่งพบเว็บเพจนี้ดังนั้นไม่ได้ใช้ แต่มันดูดี: http://karlscherer.com/Wireworld.html

หน่วยความจำสายหน่วง - 51 x 2880 = 146880

ย่อ:

เอาท์พุทออกมาด้านบนของแต่ละวง

ฉันวางสถานะทั้งหมดลงบนเส้นลวดโดยตรงด้วย lua นี้ปล่อยให้gollyอิเล็กตรอนก้าวไปข้างหน้าระหว่างบิตดังนั้นเราจึงไม่ต้องติดตามลวดด้วยเคอร์เซอร์

ฉันใช้วิธีการที่ไร้เดียงสานี้เพื่อตั้งค่าแถบและชนหลักสูตร wireworld, golly และ lua

local g = golly()

local minutes_in_day = 1440 -- 60x24
local interval = 4 -- how often to send electrons

local function bcd4(num)
    num=math.floor(num)
    local t={}
    for b=4,1,-1 do
        t[b]=math.floor(math.fmod(num,2))
        num=(num-t[b])/2
    end
    return table.concat(t)
end

local function makewire(x,y1,y2)
    for y1=1,y2 do g.setcell(x,y1,3) end
end

local function makeloop(x,y,size)
    local len = size/2 - 1
    makewire(x,y+1,len); makewire(x+2,y+1,len) -- main wires
    g.setcell(x+1,y,3); g.setcell(x+1,y+len,3) -- endcape
end

local function paint(x,y,pattern)
    for v in string.gmatch(pattern,".") do
        if v=="1" then g.setcell(x, y, 1); g.setcell(x, y-1, 2) end
        x = x + 4
    end
    g.show(pattern);g.update() -- slows things down but more interesting to watch
    for i=1,interval do g.step() end
end

for x=0,63,4 do makeloop(x,0,minutes_in_day * interval) end

for hour = 0,23 do
      for minute = 0,59 do
         paint( 0, 2, bcd4(hour/10) .. bcd4(hour%10) .. bcd4(minute/10) .. bcd4(minute%10) )
      end
end

สำหรับการทดสอบฉันเพิ่มสายไฟด้านบนเหล่านี้และดูเคล็ดลับของพวกเขา

นี่คือสคริปต์ในการรวบรวม 4 ชุด BCD 4 สายเข้าที่ลูกตา

-- watches 16 wires spaced 4 apart starting at (0,-4)
local ticks = 1440 -- set to match the length of your 24 hour loop
local g = golly()
local output = ""
local nums = {  ["0000"] = "0", ["0001"] = "1", ["0010"] = "2", ["0011"] = "3", ["0100"] = "4",
                ["0101"] = "5", ["0110"] = "6", ["0111"] = "7", ["1000"] = "8", ["1001"] = "9",
                ["1010"] = "A", ["1011"] = "B", ["1100"] = "C", ["1101"] = "D", ["1110"] = "E",
                ["1111"] = "F" } -- full set in case we have errors (i did)

for i=0,ticks,1 do
   local text = ""
   for i=0,48,16 do -- set your X here, change the 0 and 48
       local word = ""
       for j=0,15,4 do
            local bit = g.getcell(i+j,-4) -- set your Y here, change -4
            if bit == 0 or bit == 3 then word = word .. "0" else word = word .. "1" end
       end
       text = text .. nums[word]
   end
   g.show(text); output = output..' '..text
   g.update(); g.step();g.step();g.step();g.step()
end
g.note(output)

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