კოდირება და ტესტირება კომპიუტერის მანქანების ენაზე: 6 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:17

ამ ინსტრუქციაში, მე გაჩვენებთ, თუ როგორ ხდება კომპიუტერის პროგრამის კოდირება და ტესტირება მანქანების ენაზე. მანქანების ენა არის კომპიუტერების მშობლიური ენა. იმის გამო, რომ იგი შედგება 1s და 0s სტრიქონებისგან, ის ადვილად არ ესმის ადამიანებს. ამ საკითხის შესასრულებლად, ჩვენ ვაკოდირებთ პროგრამებს ჯერ მაღალი დონის ენაზე, როგორიცაა C ++ ან Java, შემდეგ ვიყენებთ სპეციალურ კომპიუტერულ პროგრამებს, რომ გადავიყვანოთ ისინი 1 -სა და 0 -ის კომპიუტერებისთვის. მაღალი დონის ენაზე კოდის სწავლა, რა თქმა უნდა, უაზროა, მაგრამ მანქანების ენაზე მოკლე შესავალმა შეიძლება მოგვცეს ღირებული ცოდნა კომპიუტერის მუშაობის შესახებ და გაზარდოს ამ ძალიან მნიშვნელოვანი ტექნოლოგიის დაფასება.

მანქანური ენის პროგრამის კოდირებისა და შესამოწმებლად, ჩვენ გვჭირდება წვდომა არაფრისმთქმელ კომპიუტერზე, რომლის მანქანების ენაც ადვილად გასაგებია. პერსონალური კომპიუტერები მეტისმეტად რთულადაა განსახილველი. გამოსავალი არის Logisim- ის გამოყენება, ლოგიკური სიმულატორი, რომელიც მუშაობს პერსონალურ კომპიუტერზე. Logisim– ით ჩვენ შეგვიძლია სიმულაცია გავუკეთოთ კომპიუტერს, რომელიც აკმაყოფილებს ჩვენს მოთხოვნებს. ზემოთ მოყვანილი ვიდეო წარმოგიდგენთ რისი მიღწევა შეგვიძლია Logisim– ით.

კომპიუტერის დიზაინისთვის, მე ავირჩიე ერთი ჩემი Kindle ელექტრონული წიგნიდან Build Your Own Computer - From Scratch. დავიწყე იქ აღწერილი BYOC კომპიუტერით და დავამცირე ის განსხვავებული ძირითადი BYOC-I (I for Instructable), რომელსაც ჩვენ გამოვიყენებთ ამ ინსტრუქციულში.

BYOC-I– ის მანქანური ენა მარტივი და გასაგებია. თქვენ არ დაგჭირდებათ კომპიუტერის ან პროგრამირების სპეციალური ცოდნა. ყველაფერი რაც საჭიროა არის ცნობისმოყვარე გონება და სწავლის სურვილი

შემდგომი კითხვა

შეიძლება გაგიკვირდეთ, რატომ ვიყენებთ "მანქანას" კომპიუტერის აღსაწერად, როდესაც ის არ არის მექანიკური მოწყობილობა. მიზეზი ისტორიულია; პირველი გამოთვლითი მოწყობილობები იყო მექანიკური, რომელიც შედგება გადაცემებისა და ბორბლებისგან. ალან შერმანის ლირიკა, "ეს იყო ყველა სიჩქარე clickety clack …" იყო მხოლოდ ერთი საუკუნის ან ორი. წაიკითხეთ მეტი ადრეული გამოთვლების შესახებ აქ.

ნაბიჯი 1: ნაწილების სია

ნაწილების სია მოკლეა. საჭიროა მხოლოდ ეს ორი ერთეული, ორივე უფასოდ გადმოსაწერი:

1. "Logisim-win-2.7.1.exe"-Logisim არის პოპულარული და ადვილად გამოსაყენებელი ლოგიკური სიმულატორი. ჩამოტვირთეთ Logisim შესრულებადი ფაილი აქედან და შექმენით მოკლე გზა მოსახერხებელ ადგილას, როგორც თქვენი სამუშაო მაგიდა. ორჯერ დააწკაპუნეთ Logisim ხატულაზე მის გასაშვებად. შენიშვნა: Logisim იყენებს Java Runtime პაკეტს, რომელიც მდებარეობს აქ. თქვენ შეიძლება მოგთხოვოთ მისი ჩამოტვირთვა.
2. BYOC-I-Full.cir "-ჩამოტვირთეთ Logisim წრიული ფაილი ქვემოთ.

გაუშვით Logisim შემდეგ დააჭირეთ ღილაკს "File-Open" და ჩატვირთეთ BYOC-I-Full.cir ფაილი. ზემოთ მოყვანილი სურათი გვიჩვენებს Logisim სამუშაო გარემოს. BYOC-I წარმოდგენილია ქვეცირკულაციის ბლოკით. გარედან არის დაკავშირებული ორი შეყვანა, გადატვირთვა და გაშვება და თექვსმეტობითი ჩვენება BYOC-I- ის რეგისტრებისა და პროგრამის მეხსიერებისთვის.

BYOC-I– ის პროგრამული მეხსიერება წინასწარ არის დატვირთული მარტივი პროგრამით, რომელიც ითვლის 1 – დან 5 – მდე A რეგისტრში. პროგრამის შესასრულებლად (გაშვება), მიჰყევით ამ ნაბიჯებს.

ნაბიჯი 1 - დააწკაპუნეთ Poke Tool- ზე. კურსორი უნდა შეიცვალოს მბზინავ "თითზე". ნაბიჯი 2 - გაააქტიურეთ გადატვირთვის შეყვანა ორჯერ, ერთხელ შეცვალეთ იგი "1" და ისევ შეცვალეთ "0". ეს აღადგენს BYOC -I პროგრამას 0 -ზე დასაწყებად. ნაბიჯი 3 - Poke Run შეყვანის ერთხელ შეცვალოს იგი "1". რეგისტრმა უნდა აჩვენოს რიცხვი, რომელიც იცვლება 1 -დან 5 -მდე და შემდეგ მეორდება. ნაბიჯი 4 - თუ პროგრამა არ შესრულდება, დააჭირეთ კონტროლს -K და ის უნდა დაიწყოს.

თუ გსურთ Logisim- ის შესაძლებლობების შესწავლა, დააჭირეთ დახმარების ბმულს მენიუს ზოლში. იქიდან შეგიძლიათ შეისწავლოთ Logisim "Tutorial", "User Guide" და "Library Reference". აქ არის შესანიშნავი ვიდეო შესავალი.

ნაბიჯი 2: მანქანათა ენის იერარქია და კოდები

BYOC-I კომპიუტერი ასრულებს დავალებებს მანქანურ ენაზე დაწერილი პროგრამების საფუძველზე. BYOC-I პროგრამები, თავის მხრივ, შედგება ინსტრუქციებისაგან, რომლებიც შესრულებულია კარგად განსაზღვრული თანმიმდევრობით. თითოეული ინსტრუქცია დამზადებულია ფიქსირებული სიგრძის კოდებისგან, რომლებიც წარმოადგენს BYOC-I- ის სხვადასხვა ოპერატიულ კომპონენტს. დაბოლოს, ეს კოდები შედგება 1 და 0 სტრიქონებისგან, რომლებიც წარმოადგენენ მანქანების ენას, რომელსაც BYOC-I რეალურად ასრულებს.

ახსნის მიზნით, ჩვენ დავიწყებთ კოდებით და ვიმუშავებთ პროგრამის დონეზე. შემდეგ ჩვენ დავაკოპირებთ მარტივ პროგრამას, ჩავტვირთავთ BYOC-I მეხსიერებაში და შევასრულებთ მას.

კოდები შედგება ორობითი (1 და 0) ციფრების ან ბიტების ფიქსირებული რაოდენობისგან, მოკლედ. მაგალითად, ქვემოთ მოყვანილი ცხრილი აჩვენებს ყველა შესაძლო კოდს (სულ 16) 4 ბიტიანი სიგანის კოდისთვის. კოდის გვერდით ნაჩვენებია თექვსმეტობითი (ფუძე 16) და ათწილადის ექვივალენტი. თექვსმეტობითი გამოიყენება ორობითი მნიშვნელობების მითითებისას, რადგან ის უფრო კომპაქტურია ვიდრე ორობითი და უფრო ადვილია ორობითიდან ათწილადის გარდაქმნა. "0x" პრეფიქსი გეცოდინებათ, რომ მომდევნო რიცხვი არის თექვსმეტობითი ან მოკლედ "ჰექსა".

ორობითი - თექვსმეტობითი - ათწილადი 10000 0x0000 00001 0x0001 10010 0x0002 20011 0x0003 30100 0x0004 40101 0x0005 50111 0x0007 71000 0x0008 81001 0x0009 91010 0x000A 101011 0x000B 111100 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 101000 10x000C

კოდის სიგანე განსაზღვრავს რამდენი ერთეულის წარმოდგენა შეიძლება. როგორც აღინიშნა, 4-ბიტიანი ფართო კოდი შეიძლება წარმოადგენდეს 16-მდე ერთეულს (0-დან 15-მდე); ანუ 2 -ჯერ 2 ოთხჯერ აღებული ან 2 -დან მე -4 სიმძლავრე უდრის 16. ზოგადად, წარმოსადგენი ერთეულების რაოდენობა 2 გაიზარდა მე -3 ხარისხამდე. აქ არის n-bit კოდის შესაძლებლობების მოკლე ჩამონათვალი.

n - პუნქტების რაოდენობა 1 22 43 84 165 326 647 1288 256

BYOC-I კომპიუტერის კოდის სიგანე შეირჩევა კოდში წარმოდგენილი ელემენტების რაოდენობის გათვალისწინებით. მაგალითად, არსებობს ოთხი ტიპის ინსტრუქცია, ამიტომ შესაფერისია 2 ბიტიანი ფართო კოდი. აქ მოცემულია BYOC-I კოდები თითოეული მათგანის მოკლე ახსნით.

ინსტრუქციის ტიპი კოდი (tt) არსებობს ოთხი სახის ინსტრუქცია: (1) MVI - გადაიტანეთ მყისიერი 8 ბიტიანი მუდმივი მნიშვნელობა მეხსიერების რეგისტრში. მეხსიერების რეგისტრატორი არის მოწყობილობა, რომელიც ინახავს მონაცემებს გამოსაყენებლად, (2) MOV - მონაცემების გადატანა ერთი რეგისტრიდან მეორეზე, (3) RRC - რეგისტრაცია -რეგისტრაციის გაანგარიშება და (4) JMP - ხტომა სხვა ინსტრუქციის ნაცვლად გააგრძელოს შემდეგი ინსტრუქცია. მიღებული BYOC-I ინსტრუქციის ტიპის კოდები არის შემდეგი:

00 MVI01 MOV10 RRC11 JMP

რეგისტრაციის კოდი (დდ და სს) BYOC-I– ს აქვს ოთხი 8 ბიტიანი რეგისტრი, რომელთაც შეუძლიათ შეინახონ მნიშვნელობები 0 – დან 255 – მდე. 4 ბიტიანი კოდი საკმარისია ოთხი რეგისტრის დასახელებისთვის:

00 F რეგისტრი 01 E რეგისტრი 10 D რეგისტრი 11 რეგისტრი

გამოთვლის კოდი (ccc) BYOC-I მხარს უჭერს ოთხ არითმეტიკულ/ლოგიკურ ოპერაციას. რვა გამოთვლამდე მომავალი გაფართოების მიზნით, გამოიყენება 3 ბიტიანი კოდი:

000 ADD, დაამატეთ ორი 8 ბიტიანი მნიშვნელობა დანიშნულ რეგისტრებში და შეინახეთ შედეგი ერთ – ერთ რეგისტრში 001 SUB, გამოაკელით ორ 8 ბიტიან მნიშვნელობას დანიშნულ რეგისტრებში და შეინახეთ შედეგი ერთ – ერთ რეგისტრში 010-011 დაცულია მომავალი გამოყენებისთვის 100 და, ლოგიკურად და ორი 8 ბიტიანი მნიშვნელობა დანიშნულ რეგისტრებში და ინახავს შედეგს ერთ – ერთ რეესტრში 101 ან ლოგიკურად ან ორ 8 ბიტიან მნიშვნელობას დანიშნულ რეგისტრებში და ინახავს შედეგს ერთ – ერთ რეგისტრში 110 დან 111 – მდე, დაცულია მომავალი გამოყენებისთვის

Jump Code (j) 1 ბიტიანი კოდი, რომელიც მიუთითებს, არის თუ არა ნახტომი უპირობო (j = 1) თუ არა ნულოვანი გაანგარიშების შედეგით (j = 0).

მონაცემები/მისამართის კოდი (v… v)/(a… a) 8 ბიტიანი მონაცემები შეიძლება შეიტანოს გარკვეულ ინსტრუქციებში, რომლებიც წარმოადგენს მნიშვნელობებს 00000000-დან 11111111-მდე ან 0-დან 255 ათობითი. ეს მონაცემები არის 8 ბიტიანი სიგანის შესანახად BYOC-I– ის 8 ბიტიან რეგისტრებში. ათობითი არითმეტიკით ჩვენ არ ვაჩვენებთ წამყვან ნულებს. კომპიუტერული არითმეტიკით ჩვენ ვაჩვენებთ წამყვან ნულებს, მაგრამ ისინი გავლენას არ ახდენენ მნიშვნელობაზე. 00000101 რიცხობრივად იგივეა 101 ან 5 ათობითი.

შემოთავაზებული მითითებები

ორობითი აღნიშვნა - https://learn.sparkfun.com/tutorials/binary თექვსმეტობითი აღნიშვნა -

შემდგომი კითხვა

კოდების გამოყენების იდეა პროცესის გადასატანად შორს მიდის. ერთი მომხიბლავი მაგალითია ჟაკარდ ლუმი. ავტომატური ქსოვა კონტროლდებოდა ხის ბარათების ჯაჭვით, რომელშიც ხვრელები იყო გაბურღული, რომლებიც წარმოადგენენ კოდებს სხვადასხვა ფერის ძაფისთვის. მე დავინახე ჩემი პირველი შოტლანდია, სადაც მას იყენებდნენ ფერადი ტარტანის დასამზადებლად. წაიკითხეთ მეტი ჟაკარდ ლუმსის შესახებ აქ.

ნაბიჯი 3: BYOC-I ინსტრუქციების ანატომია

BYOC-I- ის კოდების გათვალისწინებით, ჩვენ გადავალთ შემდეგ საფეხურზე, ინსტრუქციებზე. BYOC-I– ის ინსტრუქციის შესაქმნელად, ჩვენ კოდებს ვათავსებთ მითითებული თანმიმდევრობით და მითითებულ ინსტრუქციებში. ყველა კოდი არ ჩანს ყველა ინსტრუქციაში, მაგრამ როდესაც გამოჩნდება, ისინი იკავებენ კონკრეტულ ადგილს.

MVI ინსტრუქციის ტიპი მოითხოვს ყველაზე მეტ ბიტს, სულ 12. ინსტრუქციის სიტყვის სიგრძით 12 ბიტი, ჩვენ ვიყენებთ ყველა ინსტრუქციას. გამოუყენებელ (ე.წ. "არ მაინტერესებს") ბიტებს ეძლევა მნიშვნელობა 0. აქ არის BYOC-I ინსტრუქციის ნაკრები.

1. გადატანა დაუყოვნებლივ (MVI) - 00 dd vvvvvvvv ფუნქცია: გადაიტანეთ მონაცემთა 8 ბიტიანი მნიშვნელობა V = vvvvvvvv dd დანიშნულების რეგისტრში. შესრულების შემდეგ, dd რეგისტრს ექნება მნიშვნელობა vvvvvvvv. აბრევიატურა: MVI R, V სადაც R არის A, D, E, ან F. მაგალითი: 00 10 00000101 - MVI D, 5 - გადაიტანეთ მნიშვნელობა 5 D რეგისტრში.
2. რეგისტრაციის გადატანა რეგისტრაციაზე (MOV) - 01 dd ss 000000 ფუნქცია: მონაცემების გადატანა საწყისი წყაროდან ss desination რეგისტრში dd. შესრულების შემდეგ, ორივე რეგისტრს აქვს იგივე მნიშვნელობა, რაც წყაროს რეგისტრს. აბრევიატურა: MOV Rd, Rs სადაც Rd არის დანიშნულების რეგისტრი A, D, E, ან F და Rs არის წყარო რეგისტრი A, D, E, ან F. მაგალითი: 01 11 01 000000 - MOV A, E - მნიშვნელობის გადატანა რეესტრში E დარეგისტრირდით A.
3. დარეგისტრირდით რეგისტრაციის გაანგარიშებაზე (RRC) - 10 dd ss ccc 000 ფუნქცია: შეასრულეთ დანიშნული გამოთვლა ccc წყაროს რეგისტრაციის ss და დანიშნულების რეგისტრის გამოყენებით dd შემდეგ შეინახეთ შედეგი დანიშნულების რეესტრში. აბრევიატურა: ADD Rd, Rs (ccc = 000 Rd + Rs შენახული რდ); SUB Rd, Rs (ccc = 001 Rd - Rs ინახება Rd– ში); AND Rd, Rs (ccc = 100 Rd AND Rs ინახება Rd); OR Rd, Rs (ccc = 101 Rd OR Rs ინახება Rd). მაგალითი: 10 00 11 001 000 - SUB F, A - გამოაკლეთ მნიშვნელობა A რეესტრში F რეგისტრიდან F შედეგში F რეგისტრში.
4. გადასვლა სხვადასხვა ინსტრუქციებზე (JMP) - 11 j 0 aaaaaaa ფუნქცია: შეცვალე შესრულება სხვა ინსტრუქციაზე, რომელიც მდებარეობს aaaaaaaa (a) უპირობოდ (j = 1) -11 1 0 aaaaaaaa აბრევიატურა: JMP L სადაც L არის მისამართი aaaaaaaaa მაგალითი: 11 1 0 00001000 - JMP 8 - შეცვალეთ შესრულება მისამართზე 8. (ბ) პირობითად (j = 0), როდესაც წინა გამოთვლამ გამოიწვია არა ნულოვანი შედეგი - 11 0 0 ააააააააა აბრევიატურა: JNZ L სადაც L არის მისამართი aaaa aaaa. მაგალითი: 11 0 0 00000100 JNZ 4 თუ ბოლო გამოთვლამ გამოიღო ნულოვანი მნიშვნელობა, შეცვალეთ შესრულება მისამართზე 4.

ინსტრუქციის სიტყვის ბიტები დანომრილია მარცხნიდან (ყველაზე მნიშვნელოვანი ბიტი MSB) მარჯვნივ (უმცირესი ბიტი LSB) 11 -დან 0. კოდების ფიქსირებული რიგი და ადგილები შემდეგია:

ბიტი-კოდი 11-10 ინსტრუქციის ტიპი 9-8 დანიშნულების რეესტრი 7-6 წყაროს რეგისტრაცია 5-3 გამოთვლა: 000-დამატება; 001 - გამოკლება; 100 - ლოგიკური და; 101 - ლოგიკური OR7-0 მუდმივი მნიშვნელობა v… v და a… a (0 -დან 255 -მდე)

ინსტრუქციის ნაკრები შეჯამებულია ზემოთ მოცემულ ფიგურაში. გაითვალისწინეთ თითოეული ინსტრუქციის კოდების სტრუქტურირებული და მოწესრიგებული გარეგნობა. შედეგი არის BYOC-I– ის უფრო მარტივი დიზაინი და ის ადამიანებს გაუადვილებს მითითებებს.

ნაბიჯი 4: კომპიუტერის ინსტრუქციის კოდირება

პროგრამის დონეზე გადასვლამდე, შევადგინოთ მაგალითების მაგალითი BYOC-I ინსტრუქციის ზემოთ.

1. გადაიტანეთ მნიშვნელობა 1 რეგისტრში A. BYOC-I რეგისტრებს შეუძლიათ შეინახონ მნიშვნელობები 0-დან 255-მდე. ამ შემთხვევაში, A რეგისტრს ექნება მნიშვნელობა 1 (00000001 ორობითი) ინსტრუქციის შესრულების შემდეგ.

აბრევიატურა: MVI A, 1 საჭირო კოდი: ტიპი MVI - 00; დანიშნულების რეესტრი A - 11; მნიშვნელობა - 00000001 ინსტრუქციის სიტყვა: 00 11 00000001

2. გადაიტანეთ A რეგისტრის შინაარსი D. რეგისტრირებაში შესრულების შემდეგ, ორივე რეგისტრს ექნება მნიშვნელობა თავდაპირველად A რეგისტრში.

აბრევიატურა: MOV D, A (გახსოვდეთ, დანიშნულების ადგილი პირველია და წყარო სიაში მეორე) საჭირო კოდები: აკრიფეთ MOV - 01; დანიშნულების რეესტრი D - 10; წყარო რეგისტრაცია A - 11 ინსტრუქციის სიტყვა: 01 10 11 000000

3. დაამატეთ D რეგისტრის შინაარსი A რეგისტრში და შეინახეთ რეესტრში A. შესრულების შემდეგ, რეგისტრირებული A მნიშვნელობა იქნება A რეგისტრის ორიგინალური ღირებულების ჯამი და რეგისტრი D.

აბრევიატურა: ADD A, D (შედეგი ინახება დანიშნულების რეესტრში) საჭირო კოდები: ტიპი RRC - 10; დანიშნულების რეესტრი A - 11; წყაროს რეგისტრაცია D - 10; გაანგარიშების დამატება - 000 ინსტრუქციის სიტყვა: 10 11 10 000 000 (ccc არის პირველი 000 - დამატება)

4. გადახვიდეთ არა ნულზე მისამართზე 3. თუ ბოლო გაანგარიშების შედეგი არ იყო ნული, შესრულება შეიცვლება მითითებით მოცემულ მისამართზე. თუ ნულოვანია, შესრულება განახლდება შემდეგი ინსტრუქციით.

აბრევიატურა: JNZ 3 საჭირო კოდი: ტიპი JMP - 11; გადახტომის ტიპი - 0; მისამართი - 00000003 ინსტრუქციის სიტყვა: 11 0 0 00000003 (გადახტომის ტიპი არის პირველი 0)

5. უპირობოდ გადახტომა მისამართზე 0. შესრულების შემდეგ, შესრულება იცვლება მითითებით მოცემულ მისამართზე.

აბრევიატურა: JMP 0 კოდი აუცილებელია: ტიპი JMP - 11; გადახტომის ტიპი - 1; მისამართი - 00000000 ინსტრუქციის სიტყვა; 11 1 0 00000000

მიუხედავად იმისა, რომ მანქანების კოდირება გარკვეულწილად დამღლელია, თქვენ ხედავთ, რომ ეს არ არის ძნელი. თუ თქვენ ნამდვილად დაშიფრავდით მანქანას, თქვენ გამოიყენებდით კომპიუტერულ პროგრამას სახელწოდებით ასამბლერი, რათა გადათარგმნათ აბრევიატურადან (რომელსაც შეკრების კოდი ეწოდება) მანქანურ კოდზე.

ნაბიჯი 5: კომპიუტერული პროგრამის ანატომია

კომპიუტერული პროგრამა არის ინსტრუქციების ჩამონათვალი, რომელსაც კომპიუტერი ასრულებს სიის დასაწყისში დაწყებული სიის ბოლომდე. JNZ და JMP ინსტრუქციებს შეუძლიათ შეცვალონ რომელი ინსტრუქცია შესრულდება შემდეგში. სიის თითოეული ინსტრუქცია იკავებს კომპიუტერის მეხსიერებაში არსებულ ერთ მისამართს 0-დან. BYOC-I მეხსიერებას შეუძლია შეინახოს 256 ინსტრუქციის სია, რაც საკმარისზე მეტია ჩვენი მიზნებისათვის.

კომპიუტერული პროგრამები შექმნილია მოცემული დავალების შესასრულებლად. ჩვენი პროგრამისთვის, ჩვენ ვირჩევთ მარტივ ამოცანას, 1-დან 5-მდე ჩათვლით. ცხადია, არ არსებობს "დათვლის" ინსტრუქცია, ამიტომ პირველი ნაბიჯი არის დავალების დაშლა იმ საფეხურებად, რომელთა დამუშავებაც შესაძლებელია BYOC-I– ის მიერ შეზღუდული ინსტრუქციის ნაკრები.

ნაბიჯი 1 გადატანა 1 რეგისტრაციისათვის ნაბიჯი 2 გადატანა რეგისტრი A რეგისტრაციაში D ნაბიჯი 3 დაამატეთ რეგისტრი D რეგისტრაციაში A და შეინახეთ შედეგი რეესტრში ნაბიჯი 4 გადატანა 5 რეგისტრაციაში EStep 5 გამოაკლეთ რეგისტრი E რეგისტრიდან E და შეინახეთ შედეგი რეესტრში ნაბიჯი 6 თუ გამოკლების შედეგი არ იყო ნული, დაბრუნდით მე –4 ნაბიჯზე და განაგრძეთ დათვლა ნაბიჯი 7 თუ გამოკლების შედეგი იყო ნული, დაბრუნდით და დაიწყეთ თავიდან

შემდეგი ნაბიჯი არის ამ ნაბიჯების თარგმნა BYOC-I ინსტრუქციებში. BYOC-I პროგრამები იწყება 0-ზე და ზედიზედ ნომერზე. გადასვლა სამიზნე მისამართები ემატება ბოლოს ყველა ინსტრუქციის ადგილზე..

მისამართი: ინსტრუქცია - აბრევიატურა; აღწერა 0: 00 11 00000001 - MVI A, 1; გადაადგილება 1 რეგისტრაციისათვის A1: 01 10 11 000000 - MOV D, A; გადაადგილება რეგისტრი A რეგისტრაციისათვის D2: 10 11 10 000 000 000 - ADD A, D დაამატეთ რეგისტრი D რეგისტრაციისთვის და შეინახეთ შედეგი რეესტრში A3: 00 01 00 00000101 - MVI E, 5; გადაადგილება 5 შედეგი რეესტრში E5: 11 0 0 00000010 - JNZ 2; თუ გამოკლების შედეგი არ იყო ნული, დაუბრუნდით მე –3 მისამართს და განაგრძეთ დათვლა 6: 11 1 0 00000000 - JMP 0; თუ გამოკლების შედეგი იყო ნული, დაბრუნდით და დაიწყეთ თავიდან

პროგრამის მეხსიერებაში გადატანამდე, ორობითი ინსტრუქციის კოდი უნდა შეიცვალოს თექვსმეტობით, Logisim Hex რედაქტორთან გამოსაყენებლად. პირველი, გაყავით ინსტრუქცია სამ ჯგუფად, თითოეულში 4 ბიტიანი. შემდეგ გადათარგმნეთ ჯგუფები თექვსმეტობით, ცხრილის გამოყენებით ნაბიჯი 2. გამოყენებული იქნება მხოლოდ ბოლო სამი თექვსმეტობითი ციფრი (ქვემოთ თამამად).

მისამართი - ინსტრუქცია ორობითი - Instruction ორობითი Split - ინსტრუქცია (Hex) 0 001100000001 0011 0000 0001 - 0x03011 011011000000 0110 1100 0000 - 0x06C02 101110000000 1011 1000 0000 - 0x0B803 000100000101 0001 0000 0101 - 0x01054 100111001000 1001 1100 1000 - 0x09C85 110000000100 1100 0000 0010 - 0x0C026 111000000010 1110 0000 0000 - 0x0E00

დროა გადავიტანოთ პროგრამა BYOC-I მეხსიერებაში შესამოწმებლად.

ნაბიჯი 6: პროგრამის გადატანა მეხსიერებაზე და ტესტირებაზე

Logisim- ის "მთავარი" სქემის დათვალიერებისას, ნაჩვენები BYOC-I ბლოკი არის სიმბოლო კომპიუტერის ნამდვილი წრედისთვის, რომელსაც ეწოდება "BYOC-I" Explorer- ის პანელში. BYOC-I მეხსიერებაში პროგრამის შესასვლელად:

1. დააწკაპუნეთ მარჯვენა ღილაკით BYOC-I ბლოკზე (რომელსაც ეწოდება "ქვეცირკულაცია") და აირჩიეთ (გადაიტანეთ ზემოთ და მარცხენა დაწკაპუნებით) "View BYOC-I".
2. BYOC-I წრე გამოჩნდება სამუშაო ზონაში. დააწკაპუნეთ მარჯვენა ღილაკით "პროგრამის მეხსიერება" სიმბოლოზე და აირჩიეთ "შინაარსის რედაქტირება..".
3. Logisim Hex Editor– ის გამოყენებით, შეიყვანეთ თექვსმეტობითი კოდი (მხოლოდ თამამი), როგორც ეს ნაჩვენებია ზემოთ.

თქვენ ახლა მზად ხართ პროგრამის შესასრულებლად. დაუბრუნდით მთავარ წრეს ორჯერ დაწკაპუნებით "BYOC-I" Explorer Pane- ში. Run და Reset შეყვანის უნდა იყოს "0" დასაწყებად. Poke Tool- ის გამოყენებით, ჯერ შეცვალეთ Reset "1" და შემდეგ "0". ეს ხდის საწყის მისამართს 0x0000 და ამზადებს BYOC-I სქემას შესასრულებლად. ახლა ჩაწერეთ Run შეყვანის "1" და პროგრამა შესრულდება. (შენიშვნა: თქვენ უნდა დააჭიროთ ერთხელ Control-K- ს Logisim საათის დასაწყებად. ეს არის ფუნქცია, რომელიც საშუალებას გაძლევთ შეაჩეროთ Logisim საათი და გადადგათ პროგრამაში Control-T არაერთხელ შეხებით. სცადეთ ოდესმე!)

Logisim საათის რეგულირება შესაძლებელია სიხშირეების ფართო სპექტრზე. გადმოტვირთვისას არის 8 Hz (8 ციკლი წამში). როგორც BYOC-I კომპიუტერია შემუშავებული, თითოეული ინსტრუქციის მისაღებად ოთხი საათის ციკლი სრულდება. ამრიგად, BYOC-I სიჩქარის გამოსათვლელად, საათის სიხშირე გაყავით 4.-ზე 8 ჰც-ზე, მისი სიჩქარე არის 2 ინსტრუქცია წამში. თქვენ შეგიძლიათ შეცვალოთ საათი ინსტრუმენტის ზოლზე "სიმულაციის" დაჭერით და "ტკიპის სიხშირის" არჩევით. შესაძლო დიაპაზონი არის 0.25 ჰერციდან 4100 ჰერცამდე. ნელი სიჩქარე 8 ჰც -ზე შეირჩა, ასე რომ თქვენ შეგიძლიათ უყუროთ დათვლას A რეგისტრში.

BYOC-I სიმულაციის მაქსიმალური სიჩქარე (~ 1000 ინსტრუქცია წამში) ძალიან ნელია თანამედროვე კომპიუტერებთან შედარებით. ჩემს წიგნში აღწერილი BYOC კომპიუტერის აპარატურის ვერსია წამში 12 მილიონზე მეტ ინსტრუქციას ასრულებს!

ვიმედოვნებ, რომ ამ ინსტრუქციულმა პროგრამის დემისტიფიცირება მოახდინა მანქანების ენის პროგრამირებამ და მოგანიჭათ ინფორმაცია იმის შესახებ, თუ როგორ მუშაობს კომპიუტერები მათ ძირითად დონეზე. იმისათვის, რომ მიაღწიოთ თქვენს გაგებას, სცადეთ დააკოპიროთ ქვემოთ მოცემული ორი პროგრამა.

1. დაწერეთ პროგრამა, რომელიც იწყება 5 – დან და ითვლის 0. – მდე (ANS. Count5to0.txt ქვემოთ)
2. 2 -დან დაწყებული, დაითვალეთ 3 -ით, სანამ რიცხვი არ გადააჭარბებს 7 -ს. თქვენ შეგიძლიათ გააკეთოთ მცირე გონებრივი არითმეტიკა, შეამოწმეთ 8 -ისთვის, იცოდეთ რომ იქ დაეშვება, შემდეგ გადატვირთეთ. დაწერეთ თქვენი პროგრამა უფრო ზოგადი გზით, რომელიც ნამდვილად ამოწმებს, არის თუ არა რიცხვი "აღემატება" კონკრეტულ რიცხვს. მინიშნება: გამოიკვლიეთ რა ხდება, როდესაც გამოკლება იძლევა უარყოფით მნიშვნელობას, მაგალითად 8 - 9 = -1. შემდეგ ექსპერიმენტი ჩაატარეთ ლოგიკურ და შესამოწმებლად არის თუ არა MSB რვა ბიტიან ნომერში "1". (ANS. ExceedsCount.txt)

შეგიძლიათ იფიქროთ სხვა რთულ პრობლემებზე BYOC-I კომპიუტერისთვის? შეზღუდვების გათვალისწინებით, მეტი რა შეუძლია მას? გამიზიარეთ თქვენი გამოცდილება [email protected]. თუ თქვენ დაინტერესებული ხართ მიკროპროცესორების კოდირებით, გადახედეთ ჩემს ვებ გვერდს www.whippleway.com.იქ ვატარებ აპარატის კოდირებას თანამედროვე პროცესორებზე, როგორიცაა არდუინოსში გამოყენებული ATMEL Mega სერია.