Le istruzioni dell’Atari 2600

Una panoramica delle 56 istruzioni ufficiali del MOS 6507 per gli sviluppatori retro.

Il set di istruzioni del MOS 6507 (Atari 2600)

L’Atari 2600 usa il MOS 6507, una versione semplificata del MOS 6502 con un bus degli indirizzi più stretto e senza ingressi esterni IRQ e NMI per gli interrupt hardware. Il set di istruzioni resta però identico: comprende 56 istruzioni ufficiali. In assembly si scrivono usando mnemonici di tre lettere, come LDA o JMP.

L’articolo Da zero alla cartuccia racconta come questo codice veniva scritto, collaudato e infine inserito in una cartuccia di gioco.

Trasferimento dei dati: caricamento, scrittura e copia

Queste istruzioni spostano i dati tra la memoria e i registri del processore. A è l’accumulatore; X e Y sono i registri indice.
  • LDA – Carica un valore nell’accumulatore (Load Accumulator)
  • LDX – Carica un valore nel registro X (Load X Register)
  • LDY – Carica un valore nel registro Y (Load Y Register)
  • STA – Scrive il contenuto dell’accumulatore in memoria (Store Accumulator)
  • STX – Scrive il contenuto di X in memoria (Store X Register)
  • STY – Scrive il contenuto di Y in memoria (Store Y Register)
  • TAX – Copia A in X (Transfer A to X)
  • TAY – Copia A in Y (Transfer A to Y)
  • TSX – Copia il puntatore dello stack in X (Transfer Stack Pointer to X)
  • TXA – Copia X in A (Transfer X to A)
  • TXS – Copia X nel puntatore dello stack (Transfer X to Stack Pointer)
  • TYA – Copia Y in A (Transfer Y to A)

Operazioni sullo stack

Lo stack è un’area di memoria riservata alla conservazione temporanea di dati e indirizzi di ritorno. L’ultimo valore inserito è il primo a essere estratto.
  • PHA – Inserisce il contenuto dell’accumulatore nello stack (Push Accumulator)
  • PHP – Inserisce il registro di stato del processore nello stack (Push Processor Status)
  • PLA – Estrae un valore dallo stack e lo carica nell’accumulatore (Pull Accumulator)
  • PLP – Ripristina il registro di stato dallo stack (Pull Processor Status)

Operazioni aritmetiche

Il processore supporta direttamente addizione e sottrazione. Moltiplicazione e divisione vanno realizzate con sequenze di istruzioni.
  • ADC – Somma all’accumulatore un valore e il riporto corrente C (Add with Carry)
  • SBC – Sottrae un valore dall’accumulatore tenendo conto del prestito; C = 0 indica un prestito (Subtract with Carry)
  • INC – Incrementa di 1 un valore in memoria (Increment Memory)
  • INX – Incrementa X di 1 (Increment X)
  • INY – Incrementa Y di 1 (Increment Y)
  • DEC – Decrementa di 1 un valore in memoria (Decrement Memory)
  • DEX – Decrementa X di 1 (Decrement X)
  • DEY – Decrementa Y di 1 (Decrement Y)

Operazioni logiche e scorrimenti di bit

Queste istruzioni manipolano i singoli bit, un’attività importante anche per disegnare la grafica sull’Atari.
  • AND – Esegue un AND bit a bit tra un valore e l’accumulatore, salvando il risultato in A (Logical AND)
  • ORA – Esegue un OR inclusivo bit a bit tra un valore e l’accumulatore, salvando il risultato in A (Logical Inclusive OR)
  • EOR – Esegue un OR esclusivo bit a bit tra un valore e l’accumulatore, salvando il risultato in A (Exclusive OR)
  • ASL – Sposta i bit a sinistra, inserisce uno zero a destra e trasferisce il bit più significativo in C (Arithmetic Shift Left)
  • LSR – Sposta i bit a destra, inserisce uno zero a sinistra e trasferisce il bit meno significativo in C (Logical Shift Right)
  • ROL – Ruota i bit a sinistra attraverso il flag di riporto C (Rotate Left)
  • ROR – Ruota i bit a destra attraverso il flag di riporto C (Rotate Right)
  • BIT – Verifica i bit di un valore in memoria e aggiorna Z, N e V senza modificare A (Bit Test)

Confronti e salti condizionati

Il programma prende decisioni esaminando i flag modificati dalle operazioni precedenti. I confronti aggiornano questi flag senza cambiare il registro confrontato.
  • CMP – Confronta l’accumulatore con un valore (Compare Accumulator)
  • CPX – Confronta X con un valore (Compare X Register)
  • CPY – Confronta Y con un valore (Compare Y Register)
  • BCC – Esegue il salto se il flag di riporto è azzerato (C = 0) (Branch if Carry Clear)
  • BCS – Esegue il salto se il flag di riporto è impostato (C = 1) (Branch if Carry Set)
  • BEQ – Esegue il salto se il flag di zero è impostato (Z = 1); dopo un confronto indica uguaglianza (Branch if Equal)
  • BNE – Esegue il salto se il flag di zero è azzerato (Z = 0); dopo un confronto indica disuguaglianza (Branch if Not Equal)
  • BMI – Esegue il salto se il flag di segno negativo è impostato (N = 1) (Branch if Minus)
  • BPL – Esegue il salto se il flag di segno negativo è azzerato (N = 0), anche dopo un risultato pari a zero (Branch if Plus)
  • BVC – Esegue il salto se il flag di overflow è azzerato (V = 0) (Branch if Overflow Clear)
  • BVS – Esegue il salto se il flag di overflow è impostato (V = 1) (Branch if Overflow Set)

Salti e sottoprogrammi

Istruzioni per passare a un’altra parte del codice e tornare da un sottoprogramma o da una routine di interrupt.
  • JMP – Salta a un indirizzo senza condizioni (Jump)
  • JSR – Chiama un sottoprogramma e inserisce l’indirizzo di ritorno nello stack (Jump to Subroutine)
  • RTS – Torna da un sottoprogramma (Return from Subroutine)
  • RTI – Torna da una routine di interrupt e ripristina i flag di stato (Return from Interrupt)

Flag di stato e istruzioni di sistema

Queste istruzioni controllano i flag di stato o l’esecuzione del processore.
  • CLC – Azzera il flag di riporto C (Clear Carry)
  • CLD – Disattiva la modalità decimale (D = 0) (Clear Decimal Mode)
  • CLI – Azzera il flag di disabilitazione degli interrupt I (Clear Interrupt Disable)
  • CLV – Azzera il flag di overflow V (Clear Overflow)
  • SEC – Imposta il flag di riporto C (Set Carry)
  • SED – Attiva la modalità decimale (D = 1) (Set Decimal Mode)
  • SEI – Imposta il flag di disabilitazione degli interrupt I (Set Interrupt Disable)
  • BRK – Genera un interrupt software (Force Break)
  • NOP – Non esegue operazioni sui dati; il NOP ufficiale occupa 2 cicli della CPU (No Operation)
Una particolarità dell’Atari 2600: il MOS 6507 non dispone di ingressi esterni IRQ e NMI. CLI e SEI modificano comunque il flag I, ma non possono abilitare o disabilitare interrupt esterni che il chip non può ricevere. L’istruzione di interrupt software BRK e quella di ritorno RTI fanno però ancora parte del suo set di istruzioni.

Perché può servire un’istruzione che «non fa niente»

L’Atari 2600 non ha un framebuffer in cui conservare un’immagine completa. Il chip TIA genera la grafica al volo, e il programma deve aggiornarne i registri al momento giusto mentre le righe vengono tracciate sul televisore a tubo catodico.

L’istruzione NOP aiuta a regolare con precisione i tempi perché occupa due cicli della CPU. Anche istruzioni BIT o LDA scelte con cura possono servire a occupare tempo, ma «non fanno niente» soltanto rispetto al risultato che il programma vuole ottenere: modificano i flag, e LDA cambia anche l’accumulatore. Il programmatore deve tenere conto di questi effetti. Tutto sta nel distribuire i cicli in modo che una scrittura in un registro del TIA avvenga esattamente quando serve.

Per approfondire il ruolo del TIA, la scarsità di memoria e lo sfarfallio degli oggetti, prosegui con Le sfide estreme dello sviluppo per Atari 2600.

Documentazione e approfondimenti

Condividi
Condividi Facebook WhatsApp X Telegram Reddit E-mail

Accedi per aggiungere un post.

Herbert Sobel

È visualizzato il testo originale.Mostra traduzione
Já už se hrozně těším, až budu mít jednou čas si k tomu sednout a zkusit si něco naprogramovat. Tyhle starý počítače nabízejí tolik výzev.. Díky za přínosný článek 👍 Tohle mě opravdu zajímá.