Problemi e loro soluzioni
1) Scrivere un programma in linguaggio assembly che inizi da $0200 per 6502 µP e aggiunga i numeri senza segno di 2A94 H (aggiungere) a 2ABF H (augud). Lascia che gli input e l'output siano nella memoria. Inoltre, produrre manualmente il documento del programma assemblato.
Soluzione:
CLC
LDA $ 0213
ADC $ 0215
ST$0217
LDA $ 0214
ADC $ 0216
ST$0218
Programma assemblato:
2) Scrivere un programma in linguaggio assembly che inizi da $0200, per 6502 µP, e sottragga i numeri senza segno, 1569 H (sottraendo) da 2ABF H (minuendo). Lascia che gli input e l'output siano in memoria. Produrre manualmente anche il documento di programma assemblato.
Soluzione:
SEZ
LDA $ 0213
SBC $ 0215
ST$0217
LDA $ 0214
SBC $ 0216
ST$0218
Programma assemblato:
3) Scrivere un programma in linguaggio assembly per il 6502 µP che conti da $00 a $09 utilizzando un ciclo. Il programma dovrebbe iniziare a $ 0200. Inoltre, produrre manualmente il documento del programma assemblato.
Soluzione:
LDA #$09
ST$0220; per confrontare X e $09
LDX #$00
ciclo INX
CPX $ 0220
Ciclo BNE
Programma assemblato:
4) Scrivere un programma in linguaggio assembly che inizi da $ 0200 per il 6502 µP. Il programma ha due subroutine. La prima subroutine aggiunge i numeri senza segno di 0203 H (augud) e 0102 H (addendo). La seconda subroutine aggiunge la somma della prima subroutine che è 0305 H allo 0006 H (augud). Il risultato finale viene archiviato nella memoria. Chiama la prima subroutine che è FSTSUB e la seconda subroutine che è SECSUB. Lascia che gli input e gli output siano nella memoria. Inoltre, produrre manualmente il documento di programma assemblato per l'intero programma.
Soluzione:
SECSUB CLC
LDA$021A
ADC $ 0234
ST$0236
LDA $ 021 miliardi
ADC $ 0235
ST$0237
RTS
FSTSUB CLC
LDA $ 0216
ADC $ 0218
STA $021A
LDA $ 0217
ADC $ 0219
STA $ 021 miliardi
RTS
JSR FSTSUB
Programma assemblato:
5) Premesso che an ¯IRQ il gestore aggiunge $ 02 a $ 01 all'accumulatore come gestione principale mentre ¯NMI viene rilasciato e la gestione principale per ¯NMI aggiunge $ 05 a $ 04 all'accumulatore, scrivi un linguaggio assembly per entrambi i gestori comprese le loro chiamate. La chiamata al ¯IRQ il gestore dovrebbe trovarsi all'indirizzo $ 0200. IL ¯IRQ il gestore dovrebbe iniziare all'indirizzo $ 0300. IL ¯NMI il gestore dovrebbe iniziare all'indirizzo $ 0400. Il risultato del ¯IRQ handler dovrebbe essere inserito all'indirizzo $0500 e il risultato del file ¯NMI il gestore dovrebbe essere inserito all'indirizzo $ 0501.
Soluzione:
NMISRPHA; La routine NMI inizia qui all'indirizzo $ 0400
PHX
FIS
;
LDA #$04
ADC #$05
ST$0501
;
PLY
PLX
PLA
RTI
PHA ISR; questa istruzione è all'indirizzo $ 0300
PHX
FIS
;
LDA #$01
ADC #$02
; JMP NMISR: commentato perché non fa parte della routine
ST$0500; andrà in pila
;
PLY
PLX
PLA
RTI
;
JMPISR; questa istruzione è all'indirizzo $ 0200
6) Spiegare brevemente come viene utilizzata l'istruzione BRK per produrre l'interruzione software in un computer 65C02.
Soluzione:
Il modo principale per avere un interrupt software per il 65C02 µP è utilizzare l'istruzione di indirizzo implicito BRK. Supponiamo che il programma principale sia in esecuzione e incontri l'istruzione BRK. Da quel momento, l'indirizzo dell'istruzione successiva nel PC dovrebbe essere inviato allo stack man mano che l'istruzione corrente viene completata. Successivamente dovrebbe essere richiamata una subroutine per gestire l'istruzione del software. Questa subroutine di interrupt dovrebbe spingere i contenuti dei registri A, X e Y nello stack. Dopo che il nucleo della subroutine è stato eseguito, il contenuto dei registri A, X e Y dovrebbe essere riportato dallo stack ai rispettivi registri dal completamento della subroutine. L'ultima istruzione nella routine è RTI. Anche il contenuto del PC viene ritirato dallo stack al PC, automaticamente, grazie a RTI.
7) Produrre una tabella che confronti e contrasti una normale subroutine con una routine di servizio di interruzione.
Soluzione:
8) Spiegare brevemente le principali modalità di indirizzamento del 65C02 µP visti gli esempi di istruzioni in linguaggio assembly.
Soluzione:
Ogni istruzione per il 6502 è un byte, seguita da zero o più operandi.
Modalità di indirizzamento immediato
Con la modalità di indirizzamento immediato, dopo l'operando, c'è il valore e non un indirizzo di memoria. Il valore deve essere preceduto da #. Se il valore è in formato esadecimale, “#” deve essere seguito da “$”. Le istruzioni di indirizzamento immediate per il 65C02 sono: ADC, AND, BIT, CMP, CPX, CPY, EOR, LDA, LDX, LDY, ORA, SBC. Il lettore dovrebbe consultare la documentazione del 65C02 µP per sapere come utilizzare le istruzioni qui elencate che non sono state spiegate in questo capitolo. Un'istruzione di esempio è:
LDA #$77
Modalità di indirizzamento assoluto
Con la modalità di indirizzamento assoluto è presente un operando. Questo operando è l'indirizzo del valore in memoria (solitamente in formato esadecimale o etichetta). Ci sono 64K10 = 65,53610 indirizzi di memoria per il 6502 µP. In genere, il valore di un byte si trova in uno di questi indirizzi. Le istruzioni di indirizzamento assoluto per il 65C02 sono: ADC, AND, ASL, BIT, CMP, CPX, CPY, DEC, EOR, INC, JMP, JSR, LDA, LDX, LDY, LSR, ORA, ROL, ROR, SBC, STA , STX, STY, STZ, TRB, TSB. Il lettore dovrebbe consultare la documentazione del 65C02 µP per sapere come utilizzare le istruzioni qui elencate e per le altre modalità di indirizzamento che non sono state spiegate in questo capitolo. Un'istruzione di esempio è:
SONO $ 1234
Modalità di indirizzamento implicita
Con la modalità di indirizzamento implicita non è presente alcun operando. Qualsiasi registro µP coinvolto è implicito nell'istruzione. Le istruzioni di indirizzamento implicite per il 65C02 sono: BRK, CLC, CLD, CLI, CLV, DEX, DEY, INX, INY, NOP, PHA, PHP, PHX, PHY, PLA, PLP, PLX, PLY, RTI, RTS, SEC , SED, SEI, IMPOSTA, TAY, TSX, TXA, TXS, TYA. Un'istruzione di esempio è:
DEX: decrementa il registro X di un'unità.
Modalità di indirizzamento relativo
La modalità di indirizzamento relativo riguarda solo le istruzioni di salto. Con la modalità di indirizzamento relativo è presente un solo operando. È un valore compreso tra -12810 e +12710. Questo valore è chiamato offset. In base al segno, questo valore viene aggiunto o sottratto dall'istruzione successiva del Program Counter al risultato nell'indirizzo dell'istruzione successiva prevista. Le relative istruzioni di modalità indirizzo sono: BCC, BCS, BEQ, BMI, BNE, BPL, BRA, BVC, BVS. Gli esempi di istruzioni sono:
BNE $7F: (diramazione se Z = 0 nel registro di stato, P)
che aggiunge 127 al contatore del programma corrente (indirizzo da eseguire) e inizia l'esecuzione dell'istruzione a quell'indirizzo. Allo stesso modo:
BEQ $F9 : (diramazione se Z = : nel registro di stato, P)
che aggiunge un -7 al contatore del programma corrente e avvia l'esecuzione al nuovo indirizzo del contatore del programma. L’operando è un numero in complemento a due.
Indirizzamento dell'indice assoluto
Con l'indirizzamento assoluto dell'indice, il contenuto del registro X o Y viene aggiunto all'indirizzo assoluto fornito (da $0000 a $FFFF, cioè da 010 a 6553610) per ottenere l'indirizzo reale. Questo dato indirizzo assoluto è chiamato indirizzo di base. Se viene utilizzato il registro X, l'istruzione di assembly è simile a questa:
LDA$C453,X
Se viene utilizzato il registro Y, sarebbe qualcosa del genere:
LDA$C453,Y
Il valore per il registro X o Y è chiamato valore di conteggio o indice e può essere compreso tra $ 00 (010) e $ FF (25010). Non si chiama offset.
Le istruzioni di indirizzamento dell'indice assoluto sono: ADC, AND, ASL (solo X), BIT (con accumulatore e memoria, solo con X), CMP, DEC (solo memoria e X), EOR, INC (solo memoria e X), LDA , LDX, LDY, LSR (solo X), ORA, ROL (solo X), ROR (solo X), SBC, STA, STZ (solo X).
Indirizzamento indiretto assoluto
Viene utilizzato solo con l'istruzione di salto. In questo modo l'indirizzo assoluto indicato ha un indirizzo puntatore. L'indirizzo del puntatore è composto da due byte. Il puntatore a due byte punta al (è l'indirizzo del) valore del byte di destinazione nella memoria. Quindi, l'istruzione in linguaggio assembly è la seguente:
JMP ($3456)
Con le parentesi e $13 nell'indirizzo $3456 mentre $EB è nell'indirizzo $3457 (= $3456 + 1), l'indirizzo di destinazione è $13EB e $13EB è il puntatore. L'assoluto $ 3456 è tra parentesi nell'istruzione.
9) a) Scrivere un programma in linguaggio macchina 6502 per inserire la frase 'Ti amo!' stringa di codici ASCII presenti in memoria, a partire dall'indirizzo $0300 con la lunghezza della stringa. Il programma dovrebbe iniziare all'indirizzo $ 0200. Ottieni ciascun carattere dall'accumulatore, supponendo che vengano inviati lì uno per uno da qualche subroutine. Inoltre, assemblare il programma a mano. (Se hai bisogno di conoscere i codici ASCII per “Ti amo!”, eccoli: 'I':4916, spazio: 2016, 'l': 6C16, 'o':6F16, 'v':7616, ' e':65, 'y':7916, 'u':7516 e '!':2116. Nota: ogni codice occupa 1 byte).
b) Scrivere un programma in linguaggio macchina 6502 per inserire la frase 'Ti amo!' stringa di codici ASCII in memoria, iniziando dall'indirizzo $0300 senza la lunghezza della stringa ma terminando con 0016. Il programma dovrebbe iniziare dall'indirizzo $0200. Ottieni ciascun carattere dall'accumulatore, supponendo che vengano inviati lì uno per uno da qualche subroutine. Inoltre, assemblare il programma a mano.
Soluzione:
a) Strategia: ci sono 12 byte per la stringa: 1 byte per la lunghezza della stringa e 11 byte per la stringa letterale. Quindi, devono esserci 12 iterazioni (loop) contando da 0. Cioè: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11. Questi sono 12 numeri.
L'intero 0 viene inserito nel registro X e il numero 1110 = 1210 – 110 = B16 = $0B viene inserito in una posizione di indirizzo nella memoria, ad esempio l'indirizzo $0250. Per ogni iterazione, il valore nel registro X viene incrementato e il risultato viene confrontato con $0B nella posizione dell'indirizzo $0250. Subito dopo che il valore in X è uguale al valore di $ 0B, l'iterazione si interrompe. A questo punto, la lunghezza (numero di byte) della stringa e il valore letterale della stringa occupano le posizioni degli indirizzi da $ 0300 a $ 030B (inclusi). Per incrementare gli indirizzi di memoria da $ 0300, viene utilizzato il registro Y. Il codice è:
LDA #$0B
SONO $ 0250
LDX #$00
LDY #$00
ST$0300; la lunghezza di 11 viene inserita in A da una subroutine e arriva a $ 0300
ciclo INX
LÀ
CPY $ 0250
Ciclo BEQ
b) Strategia: ci sono 12 byte per la stringa: 1 byte per il terminatore Null $00 e 11 byte per la stringa letterale. Quindi, devono esserci 12 iterazioni (loop) contando da 0. Cioè: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11. Questi sono 12 numeri.
L'intero 0 viene inserito nel registro X e il numero 1110 = 1210 – 110 = B16 = $0B viene inserito in una posizione di indirizzo nella memoria, ad esempio l'indirizzo $0250. Per ogni iterazione, il valore nel registro X viene incrementato e il risultato viene confrontato con $0B nella posizione dell'indirizzo $0250. Subito dopo che il valore in X è uguale al valore di $ 0B, l'iterazione si interrompe. A questo punto, il numero di byte della stringa letterale più il carattere Null occupano le posizioni degli indirizzi da $ 0300 a $ 030B (inclusi). Per incrementare gli indirizzi di memoria da $ 0300, viene utilizzato il registro Y. Il codice è:
LDA #$0B
SONO $ 0250
LDX #$00
LDY #$00
ST$0300; 'I' viene inserito in A da una subroutine e va a $ 0300
ciclo INX
LÀ
CPY $ 0250
Ciclo BEQ
