COP8

From alpha
Jump to navigation Jump to search
This article is about COP8 microcontroller. For 8th Climate Change Conference of the Parties, see 2002 United Nations Climate Change Conference.

राष्ट्रीय अर्धचालक COP8 एक 8-बिट जटिल अनुदेश सेट कंप्यूटर कोर microcontroller है। COP8 पहले के COP400 4-बिट माइक्रोकंट्रोलर परिवार का विस्तार है। COP8 की मुख्य विशेषताएं हैं:

इसमें प्रति सेकंड 2M चक्र तक का मशीन चक्र है, लेकिन अधिकांश संस्करण 2.8M चक्र प्रति सेकंड (28 मेगाहर्ट्ज घड़ी) तक ओवरक्लॉक करने योग्य प्रतीत होते हैं।[citation needed]

रजिस्टर और मेमोरी मैप

COP8 अलग निर्देश और डेटा स्पेस (हार्वर्ड वास्तुकला ) का उपयोग करता है।[1]: 2-1 [2]: 2-4  निर्देश पता स्थान 15-बिट (अधिकतम 32 KiB) है, जबकि डेटा पते 8-बिट (256 बाइट्स अधिकतम, बैंक-स्विचिंग के माध्यम से विस्तारित) हैं।

सॉफ़्टवेयर बग को पकड़ने की अनुमति देने के लिए, सभी अमान्य निर्देश पते शून्य के रूप में पढ़े जाते हैं, जो एक जाल निर्देश है। स्टैक के ऊपर अमान्य रैम को ऑल-वन के रूप में पढ़ा जाता है, जो एक अमान्य पता है।

सीपीयू में 8-बिट संचायक और 15-बिट कार्यक्रम गणक है। 16 अतिरिक्त 8-बिट रजिस्टर (R0-R15) और एक 8-बिट कार्यक्रम स्थिति शब्द मेमोरी मैप किए गए हैं। उन तक पहुंचने के लिए विशेष निर्देश हैं, लेकिन सामान्य रैम एक्सेस निर्देशों का भी उपयोग किया जा सकता है।

मेमोरी मैप को आधे रैम और आधे नियंत्रण रजिस्टरों में निम्नानुसार विभाजित किया गया है:

COP8 data address space
Addresses Use
0x00–6F General purpose RAM, used for stack
0x70–7F Unused, reads as all-ones (0xFF) to trap stack underflows
0x80–8F Unused, reads undefined
0x90–BF Additional peripheral control registers
0xC0–CF Peripheral control registers.
0xD0–DF General purpose I/O ports L, G, I, C and D
0xE0–E8 Reserved
0xE9 Microwire shift register
0xEA–ED Timer 1 registers
0xEE CNTRL register, control bits for Microwire & Timer 1
0xEF PSW, CPU program status word
0xF0–FB R0–R11, general purpose registers (additional RAM)
0xFC R12, a.k.a. X, secondary indirect pointer register
0xFD R13, a.k.a. SP, stack pointer register
0xFE R14, a.k.a. B, primary indirect pointer register
0xFF R15, a.k.a. S, data segment extension register

यदि RAM बैंक में नहीं है, तो R15 (S) केवल एक अन्य सामान्य प्रयोजन रजिस्टर है। यदि रैम को बैंक किया गया है, तो डेटा एड्रेस स्पेस का निचला आधा हिस्सा (पता 0x00–7F) एस द्वारा चयनित रैम बैंक को निर्देशित किया जाता है। डेटा एड्रेस स्पेस के ऊपरी आधे हिस्से में विशेष प्रयोजन रजिस्टर हमेशा दिखाई देते हैं। 0xFx पर डेटा रजिस्टर का उपयोग बैंकों के बीच डेटा कॉपी करने के लिए किया जा सकता है।

बैंक 0 के अलावा अन्य रैम बैंकों में सभी 128 बाइट्स उपलब्ध हैं। स्टैक (स्टैक पॉइंटर के माध्यम से संबोधित) हमेशा बैंक 0 पर होता है, चाहे एस रजिस्टर कैसे भी सेट किया गया हो।

नियंत्रण स्थानान्तरण

3-बाइट के अलावा JMP और JSR निर्देश जो संपूर्ण पता स्थान को संबोधित कर सकते हैं, इन निर्देशों के 2-बाइट संस्करण 4K पृष्ठ के भीतर जा सकते हैं। निर्देश निम्न 12 बिट्स निर्दिष्ट करता है, और पीसी के उच्च 3 बिट्स संरक्षित हैं। (ये मुख्य रूप से 4K ROM तक वाले मॉडल के लिए हैं।)

जंप इनडायरेक्ट और लोड संचायक अप्रत्यक्ष निर्देश भी हैं जो संचायक सामग्री को पते के निम्न 8 बिट्स के रूप में उपयोग करते हैं; वर्तमान पीसी के उच्च 7 बिट संरक्षित हैं।

कम दूरी की शाखाओं के लिए, 63 1-बाइट निर्देश हैं जो पीसी-सापेक्ष शाखाएं पीसी−32 से पीसी+31 तक निष्पादित करते हैं। यह एक 15-बिट जोड़ है, और कोई पृष्ठ सीमा आवश्यकताएँ लागू नहीं होती हैं।

सशर्त शाखाएँ मौजूद नहीं हैं, न ही प्रोसेसर स्टेटस रजिस्टर#कॉमन फ़्लैग प्रदान करता है, हालाँकि प्रोग्राम स्टेटस वर्ड में मल्टी-बाइट अंकगणित के लिए कैरी और हाफ-कैरी फ़्लैग शामिल हैं। बल्कि, तुलना करने और छोड़ने के कई निर्देश हैं। उदाहरण के लिए, IFEQ अपने दो ऑपरेंड की तुलना करता है, और यदि वे असमान हैं तो निम्नलिखित निर्देश को छोड़ देता है। किसी भी निर्देश को छोड़ा जा सकता है; यह शाखाओं तक सीमित नहीं है.

COP8 आर्किटेक्चर की एक अनूठी विशेषता है IFBNE अनुदेश. यह बी (मेमोरी पॉइंटर) रजिस्टर के निम्न 4 बिट्स की तुलना 4-बिट तत्काल स्थिरांक के साथ करता है, और इसे तब तक लूप करने के लिए उपयोग किया जा सकता है जब तक कि बी एक छोटे (16 बाइट तक) बफर के अंत तक नहीं पहुंच जाता।

इस तंत्र का एक दिलचस्प विस्तार है RETSK रिटर्न-एंड-स्किप निर्देश, जो किसी भी सबरूटीन कॉल को सशर्त रूप से निम्नलिखित निर्देश को छोड़ने देता है। यह सबरूटीन से बूलियन डेटा प्रकार को वापस करने का एक बहुत ही कॉम्पैक्ट तरीका प्रदान करता है।

निर्देश सेट

COP8 ऑपरेंड गंतव्य, स्रोत क्रम में सूचीबद्ध हैं। अधिकांश निर्देशों में संचायक ए एक ऑपरेंड के रूप में होता है। अन्य ऑपरेंड को आम तौर पर 8-बिट तत्काल मान, 8-बिट रैम एड्रेस या से चुना जाता है [B], बी रजिस्टर द्वारा चयनित रैम पता। कुछ निर्देश एक्स रजिस्टर द्वारा रैम एड्रेसिंग का भी समर्थन करते हैं ([X]), और पोस्ट-इंक/डिक्रीमेंट वेरिएंट ([B+], [B−], [X+], [X−]).

बी के माध्यम से अप्रत्यक्ष संबोधन विशेष रूप से तेज़ है, और उसी चक्र में किया जा सकता है जिसमें निर्देश निष्पादित होता है।

दूसरी ओर, अधिकांश मामलों में पूर्ण रैम एड्रेसिंग सीधे एन्कोड नहीं किया जाता है। बल्कि, एक विशेष प्रत्यक्ष संबोधन उपसर्ग ऑपकोड, जिसके बाद 1-बाइट पता होता है, किसी भी निर्देश से पहले हो सकता है [B] ऑपरेंड, और इसे मेमोरी डायरेक्ट ऑपरेंड में बदल देता है। यह निर्देश में दो बाइट्स और तीन चक्र जोड़ता है। (सशर्त-छोड़ें निर्देश उपसर्ग और अनुवर्ती निर्देश को एक जोड़ी के रूप में छोड़ें।)

सभी स्थानांतरण निर्देश बुलाए गए हैं LD (लोड) भले ही गंतव्य एक मेमोरी एड्रेस हो। असामान्य रूप से, वहाँ नहीं हैं LD स्रोत के रूप में संचायक के साथ निर्देश; भंडारों का काम पूरा हो गया है X निर्देश जो मेमोरी ऑपरेंड के साथ संचायक का आदान-प्रदान करता है, ए को संग्रहीत करता है और पिछली मेमोरी सामग्री को लोड करता है। (इसमें कोई अतिरिक्त समय नहीं लगता; X A,[B] एक-चक्र निर्देश है।)

ROM में तालिकाओं से लाने के निर्देश हैं। ये प्रोग्राम काउंटर (पीसीयू) के उच्च 7 बिट्स को संचायक के साथ जोड़ते हैं, उस पते से एक बाइट लाते हैं, और इसे संचायक में रखते हैं (LAID निर्देश) या प्रोग्राम काउंटर पीसीएल के निम्न 8 बिट्स (JID निर्देश). चूँकि निष्पादित अगला निर्देश ROM के उसी 256-बाइट पृष्ठ में होना चाहिए, जिसमें तालिका है, 256-प्रविष्टि तालिका संभव नहीं है।

COP8 family instruction set[1][3][2][4]
Opcode Operands Mnemonic Cycles Description
7 6 5 4 3 2 1 0 b2 b3
0 0 0 0 0 0 0 0 — — INTR 7 Software interrupt (push PC, PC ← 0x00ff)
0 0 0 offset — — JP +disp5 3 PC ← PC + offset; jump 1–31 bytes forward (offset=0 reserved)
0 0 1 0 addrhi addrlo — JMP addr12 3 PC[11:0] ← address. Top 3 bits of PC preserved.
0 0 1 1 addrhi addrlo — JSR addr12 5 Jump to subroutine: push PC, proceed as JMP.
0 1 0 0 k — — IFBNE #imm4 1 Execute next instruction if (B & 15) ≠ k; skip if (B & 15) = k.
0 1 0 1 k — — LD B,#imm4 1 B ← 15 − k (zero-extended)
0 1 1 0 0 0 0 0 k — ANDSZ A,#imm8* 2 Skip if A & k = 0 (=IFBIT #bit,A)
0 1 1 0 0 0 0 1 addrlo — JSRB addr8† 5 Push PC, jump to boot ROM subroutine at address[5]
0 1 1 0 0 0 1 – — — (reserved for boot ROM†)[5]
0 1 1 0 0 1 0 0 — — CLR A 1 A ← 0
0 1 1 0 0 1 0 1 — — SWAP A 1 A ← A<<4 | A>>4; swap nibbles
0 1 1 0 0 1 1 0 — — DCOR A 1 Decimal correct after BCD addition
0 1 1 0 0 1 1 1 — — PUSH A* 3 [SP] ← A, SP ← SP−1
0 1 1 0 1 bit — — RBIT #bit,[B] 1 Reset (clear to 0) given bit of RAM
0 1 1 1 0 bit — — IFBIT #bit,[B] 1 Test given bit of RAM, skip if zero
0 1 1 1 1 bit — — SBIT #bit,[B] 1 Set (to 1) given bit of RAM
1 0 0 m 0 opcode operand — ALU operations, A ← A op operand
1 0 0 0 0 opcode — — OP A,[B] 1 ALU operation with A and [B] (with [address] using DIR prefix)
1 0 0 1 0 opcode k — OP A,#imm8 2 ALU operation with A and immediate k
1 0 0 m 0 0 0 0 operand — ADC A,operand C,A ← A + operand + C; add with carry
1 0 0 m 0 0 0 1 operand — SUBC A,operand C,A ← A + ~operand + C (A − operand − ~C)
1 0 0 m 0 0 1 0 operand — IFEQ A,operand Skip if A ≠ operand
1 0 0 m 0 0 1 1 operand — IFGT A,operand Skip if A ≤ operand
1 0 0 m 0 1 0 0 operand — ADD A,operand A ← A + operand (carry unchanged!)
1 0 0 m 0 1 0 1 operand — AND A,operand A ← A & operand
1 0 0 m 0 1 1 0 operand — XOR A,operand A ← A ^ operand
1 0 0 m 0 1 1 1 operand — OR A,operand A ← A | operand
1 0 0 0 1 0 0 0 — — IFC 1 Skip if carry clear
1 0 0 0 1 0 0 1 — — IFNC 1 Skip if carry set
1 0 0 0 1 0 1 0 — — INC A 1 A ← A + 1 (carry unchanged)
1 0 0 0 1 0 1 1 — — DEC A 1 A ← A − 1 (carry unchanged)
1 0 0 0 1 1 0 0 — — POP A* 3 SP ← SP+1, A ← [SP]
1 0 0 0 1 1 0 1 — — RETSK 5 Pop PC, skip one instruction
1 0 0 0 1 1 1 0 — — RET 5 Pop PC high, pop PC low
1 0 0 0 1 1 1 1 — — RETI 5 Return and enable interrupts
1 0 0 1 1 0 0 0 k — LD A,#imm8 2 A ← k
1 0 0 1 1 0 0 1 k — IFNE A,#imm8* 2 Skip if A = k
1 0 0 1 1 0 1 0 k — LD [B+],#imm8 3 [B] ← k, B ← B + 1
1 0 0 1 1 0 1 1 k — LD [B−],#imm8 3 [B] ← k, B ← B − 1
1 0 0 1 1 1 0 0 address — X A,addr8 3 A ↔ [address], exchange
1 0 0 1 1 1 0 1 address — LD A,addr8 3 A ← [address]
1 0 0 1 1 1 1 0 k — LD [B],#imm8 2 [B] ← k
1 0 0 1 1 1 1 1 k — LD B,#imm8* 2 B ← k (one cycle faster than LD R14,#k)
1 0 1 0 0 0 0 0 — — RC 1 C ← 0; reset carry to 0
1 0 1 0 0 0 0 1 — — SC 1 C ← 1; set carry to 1
1 0 1 0 0 0 1 0 — — X A,[B+] 2 A ↔ [B], B ← B+1
1 0 1 0 0 0 1 1 — — X A,[B−] 2 A ↔ [B], B ← B−1
1 0 1 0 0 1 0 0 — — LAID 3 A ← ROM[PCU:A]; load from ROM
1 0 1 0 0 1 0 1 — — JID 3 PCL ← ROM[PCU:A]; jump via ROM table
1 0 1 0 0 1 1 0 — — X A,[B] 1 A ↔ [B]
1 0 1 0 0 1 1 1 — — (reserved)
1 0 1 0 1 0 0 0 — — RLC A* 1 C,A ← A,C; rotate left through carry (=ADC A,A)
1 0 1 0 1 0 0 1 address k IFEQ addr8,#imm8* 3 Skip if [address] ≠ k
1 0 1 0 1 0 1 0 — — LD A,[B+] 2 A ← [B], B ← B+1
1 0 1 0 1 0 1 1 — — LD A,[B−] 2 A ← [B], B ← B−1
1 0 1 0 1 1 0 0 addrhi addrlo JMPL addr15 4 PC ← address
1 0 1 0 1 1 0 1 addrhi addrlo JSRL addr15 5 Push PC, PC ← address
1 0 1 0 1 1 1 0 — — LD A,[B] 1 A ← [B]
1 0 1 0 1 1 1 1 — — (reserved)
1 0 1 1 0 0 0 0 — — RRC A 1 A,C ← C,A; rotate right through carry
1 0 1 1 0 0 0 1 — — (reserved)
1 0 1 1 0 0 1 0 — — X A,[X+] 3 A ↔ [X], X ← X+1
1 0 1 1 0 0 1 1 — — X A,[X−] 3 A ↔ [X], X ← X−1
1 0 1 1 0 1 0 0 — — VIS* 5 PC ← ROM[vector table]; Vector Interrupt Select
1 0 1 1 0 1 0 1 — — RPND* 1 Reset pending interrupt flag
1 0 1 1 0 1 1 0 — — X A,[X] 3 A ↔ [X]
1 0 1 1 0 1 1 1 — — (reserved)
1 0 1 1 1 0 0 0 — — NOP 1 No operation
1 0 1 1 1 0 0 1 — — IFNE A,[B]* 1 Skip if A = [B]
1 0 1 1 1 0 1 0 — — LD A,[X+] 3 A ← [X], X ← X+1
1 0 1 1 1 0 1 1 — — LD A,[X−] 3 A ← [X], X ← X−1
1 0 1 1 1 1 0 0 address k LD addr8,#imm8 3 [address] ← k
1 0 1 1 1 1 0 1 address — DIR addr8 3 Change next instruction's operand from [B] to [address]
1 0 1 1 1 1 1 0 — — LD A,[X] 3 A ← [X]
1 0 1 1 1 1 1 1 — — (reserved)
1 1 0 0 register — — DRSZ register 3 register ← register − 1, skip if result is zero
1 1 0 1 register k — LD register,#imm8 3 register ← k (=LD 0xf0+register,#k, one byte shorter)
1 1 1 offset — — JP −disp5 3 PC ← PC − 32 + offset; jump 1–32 bytes backward
7 6 5 4 3 2 1 0 b2 b3 Mnemonic Cycles Description

<नोविकी/>*: केवल फीचर परिवार (COP888/COP8SA) कोर पर; बुनियादी परिवार (COP800) कोर पर मौजूद नहीं है।
†: इन-सिस्टम प्रोग्रामिंग के लिए बूट ROM के साथ केवल फ़्लैश परिवार (COP8TA/COP8C) मॉडल पर

संदर्भ

  1. ↑ 1.0 1.1 COP8 Basic Family User's Manual (PDF). Revision 002. National Semiconductor. June 1996. Literature Number 620895-002. Retrieved 2021-01-02.
  2. ↑ 2.0 2.1 Aleaf, Abdul (July 1996). "Comparison of COP878x to the Enhanced COP8SAx7 Family - Hardware/Software Considerations" (PDF). National Semiconductor. Application Note 1043.
  3. ↑ COP8 Feature Family User's Manual. Revision 005. National Semiconductor. March 1999. Literature Number 620897-005. Extracted from zipped ISO image 530094-003_COP8_Tools_Docs_Aug1999.zip, retrieved 2020-01-07.
  4. ↑ "COP8SAx Designer's Guide" (PDF). National Semiconductor. January 1997. Literature Number 620894-001.
  5. ↑ 5.0 5.1 "COP8SBR9/COP8SCR9/COP8SDR98-Bit CMOS Flash Based Microcontroller with 32k Memory, Virtual EEPROM and Brownout" (PDF) (data sheet). National Semiconductor. April 2002. Retrieved 2021-01-06.


बाहरी संबंध


Stub icon

This microcomputer- or microprocessor-related article is a stub. You can help Wikipedia by expanding it.

Retrieved from "https://alpha.indicwiki.in/index.php?title=COP8&oldid=278873"