Timing Rasters E Badline

[Elder0010]

 colpa mia, mi è sfuggito. grazie!

[Freshness79]

 Bene... a conferma che l'argomento é di una certa complessità, sono qui a ritrattare le mie stesse dichiarazioni!
Ieri ti stavo per rispondere ma mi sono bloccato un attimo perché c'era qualcosa che non tornava: una delle affermazioni che avevo fatto non coincideva con la realtà.
Ho dovuto ravanare in rete e fare alcune prove prima di tornare a risponderti con ragionevole cognizione di causa, e ti ringrazio perché questo thread mi ha dato lo spunto per chiarire gli ultimi dubbi che avevo su questa tecnica.
Ho sbagliato a dirti che un IRQ richiamato tra un istruzione e l'altra sia immediatamente eseguito dalla cpu: non é assolutamente così.
La realtà é che perché un IRQ sia eseguito subito dopo una determinata istruzione, é necessario che sia segnalato almeno due cicli prima del termine della stessa (fonte: Stable Raster - Makela).
Questo comporta che il tempo minimo di ritardo con il quale viene eseguito un IRQ é esattamente di 2 cicli (e non di 0 come ti avevo detto).
Faccio un esempio:
posso scomporre il seguente codice:

NOP    ;2 cicli (prima nop)
NOP    ;2 cicli (seconda nop)

nei 4 cicli di cui si compone
0 - NOP1
1 - NOP1
2 - NOP2
3 - NOP2
4... (fine del 2° NOP)

Se l'irq capita in 0, all'inizio della prima NOP, verrà servito in 2: esattamente 2 cicli più tardi.
Se l'irq capita in 1, cioé in mezzo alla prima NOP, manca solo 1 ciclo alla fine della stessa perciò l'IRQ non può essere eseguito in 2 ma sarà necessario attendere la fine della seconda NOP: l'IRQ verrà eseguito in 4 per un ritardo totale di 3 cicli di ritardo.
Il discorso si può estendere anche alle istruzioni più lunghe, alla fine si ottiene che il campo di variabilità del ritardo di esecuzione di un interrupt dovuto all'istruzione correntemente eseguita va dai 2 ai 9 cicli.
Alla luce di questo cambiano i timing delle routine di cui abbiamo parlato nel thread: in particolare quella del primo interrupt dev'essere ulteriormente accorciata perché il massimo ritardo accumulabile é 9 (max ritardo di istruzione)+7 (istruzione IRQ) + 29 (routine del kernel) = 45. La routine quindi ha al massimo 18 cicli (45+18=63) per fare l'acknowledge dell'irq, l'aggiornamento di $D012 e l'aggiornamento di $0314.
Può sembrare poco tempo ma é ancora possibile farci stare tutto con un semplice accorgimento, questa volta per semplicità ti propongo il codice:

Codice: [Seleziona]

...
...
irqpre
lda #<secirq;2 (36+2/9)  
sta $0314;4
sta $d019;4
inc $d012  ;6
cli  ;2
nop  ;2 gli IRQ inizieranno qua ma questo nop verrà sempre eseguito
nop  ;2
nop  ;2
nop  ;2
nop  ;2
brk  ; Qua non ci si arriva mai!

align 2
*=*+1; Mi assicuro che l'indirizzo sia dispari
; così posso usare il valore per l'ack
secirq
....
....

Ora per il secondo interrupt tieni presente che la routine verrà eseguita con un ritardo di 2/3+7+29=38/39 cicli.
Dovrai fare in modo di posizionare una LDA $d012 o una CMP $d012 (a seconda di come preferisci strutturare la cosa) in modo tale che il suo ultimo ciclo, il 4°, venga ad essere il 63° della 2° riga/1° della 3° riga.
A quel punto, se risulti essere ancora nella 2° riga, un semplice branch all'istruzione successiva ti permetterà di eliminare l'ultimo ciclo di incertezza.
Se hai bisogno "fai un fischio"!

[Elder0010]

 

*=*+1; Mi assicuro che l'indirizzo sia dispari
; così posso usare il valore per l'ack

Questo significa: prendi la locazione corrente di memoria e skip di 1 posizione? Se si, come fa a rendermi sicuro che l'indirizzo sia dispari? Se mi trovassi in un indirizzo pari + 1 = dispari. Se fossi in un dispari + 1 = di nuovo pari.

Perdona la mia (somma) ignoranza, non capisco che relazione ha con l'ack

Apparte questo, ho provato a sistemare il codice! Ora in teoria dovrebbe essere stabile. Ho pensato che al momento di eseguire il salto jsr rasterbars, il conto dei cicli si resetta, e mi trovo il raster allineato.

Però, per saltare, caricare l'accumulatore ecc ecc, servono altri cicli, e infatti la rasterline bianca non è allineata con il bordo sx dello schermo. Come fare? aspettare altri 63 cicli e eseguire gli sta $d020 / sta $d021 in modo da terminare esattamente al 63° ciclo successivo?

La situazione sarebbe quindi questa:

irqpre -> ci assicura il ritardo su irq
irq -> siamo sicuri sul ritardo, possiamo fare un conto sicuro: raster stabile.
raster stabile -> per avere una linea completa e allineata, bisogna fare in modo che l'ultimo sta $d021 termini esattamente al 63°esimo ciclo. Si tratta quindi di ritardare fino all'ultimo!

spero di averci capito qualcosa incollo solo la parte centrale del programma per non floodare

Codice: [Seleziona]

;FINO A QUI  X + 7 + 29 cicli.
;ricorda che 2<=X<=9 e X è la
;durata dell'ultima istruzione eseguita
;prima dell'interrupt
;quindi lsr $d019 viene seguita dopo 29+X+7
;caso peggiore 45 cicli, ne ho solo  18
irqpre  
   lda #<irq  ;2
   sta $0314  ;4
   sta $d019;4 rispetto ad una inc scendo di 2 cicli
   inc $d012  ;6    
   cli  ;2

;---FINO A QUI MAX 18 CICLI (cosiderato caso peggiore)

  
  ;Aggiungo una serie di nop per "non fare nulla" intanto che
                       ;l'altro interrupt viene eseguito
   nop
   nop
   nop
   nop
   nop;5 nop per totale di 10 cicli, sono sicuro in tutti i casi
   ;(considerando anche il caso migliore)

   brk


   *=*+1;
  ;la routine verrà eseguita con un ritardo di 2/3+7+29=38/39 cicli.
irq
   nop ;41
   nop ;43
   nop ;45
   nop ;47
   nop ;49
   nop ;51
  
   asl $d019;6 = 57
   lda #$35   ;2 = 59
   cmp $d012  ;4 =63
  
   beq start  ;con questo branch allineo l'ultimo
start                  ;ciclo di insicurezza

  ;In teoria qui il conto si resetta a 0 cicli
  ;perche ho stabilizzato il tutto
   jsr rasterbars;6 cicli
        
  ;Tolgo i 6 bytes inseriti nello stack
  ;facendo push nell'accumulatore 6 volte
   pla
   pla
   pla
   pla
   pla
   pla
  
   ldy #<irqpre;Punto di nuovo al primo interrupt
   sty $0314
  
  ;rimetto apposto anche il registro $d012
   lda $34
   sta $d012
  
   jmp $ea31
  

rasterbars  
                      ;TODO: ritardare in modo da avere gli sta $d020 / 21
                      ;allineati al 63esimo ciclo (?)
   lda colors;2
   sta $d020;4
   sta $d021;4
  
   ldx #$0a
   dex
   bne *-1
  
    
  
   lda #0    
   sta $d020  
   sta $d021  
      
   rts

 

[Freshness79]

 Rispondo per punti:
1)
*=*+1 significa in effetti "incrementa di uno l'attuale indirizzo". La garanzia che sia dispari ce l'ho perché ho fatto precedere un align 2 (allinea l'indirizzo a multipli di 2).
Perché serve dispari? Perché per effettuare l'acknowledge di interrupt generati dal raggiungimento di un raster é necessario scrivere un 1 nel bit 0 di $d019. Ti ricordo che $D019 é strutturato in questo modo:

Bit 0
RST (Interrupt generato dal raggiungimento di un raster)
Read: 1 se c'é un interrupt da servire
Write: 1 per dare l'ack
Bit 1
MBC (Interrupt generato da collisioni sprite/sfondo)
Read:  1 se c'é un interrupt da servire
Write: 1 per dare l'ack
Bit 2
MMC (Interrupt generato da collisioni sprite/sprite)
Read:  1 se c'é un interrupt da servire
Write: 1 per dare l'ack
Bit 3
LP (Interrupt triggerato da una lightpen)
Read:  1 se c'é un interrupt da servire
Write: 1 per dare l'ack

2)
Ho trovato una piccola svista nel tuo codice. Quando alla fine dell'interruzione vai a reimpostare il raster $34, l'istruzione giusta é LDA #$34!! L'hai indicato senza la "#" e quindi il processore va ad impostare l'accumulatore col valore letto nella posizione $34.

3)
Dal momento che nel secondo interrupt sei partito a contare usando il worst case, dovresti arrivare al cmp #$d012 con 64, cioé col primo ciclo della riga successiva: solo in questo modo puoi usare quell'istruzione come discriminante. Se infatti il secondo irq verrà eseguito con un ritardo base di 38 la cmp sara ancora nella riga $35, il confronto andrà a buon fine e ti troverai in start che sei nel 3° ciclo della riga $36 (beq con salto = 3 cicli); se invece il secondo irq partirà con ritardo 39 la cmp sarà già nella riga successiva, il confronto andrà male ma ti troverai in start con lo stesso ritardo di 3 (1 dovuto al ritardo di base + 2 della beq senza salto).

4)
Ti consiglio di usare costantemente i debug border di vice per avere il polso della situazione: solo con quelli puoi avere un feedback visivo sull'effettiva stabilità della routine che stai scrivendo. Prova a vedere il programma così com'é adesso e dopo gli aggiustamenti necessari.

5)
Per il resto é sostanzialmente corretta la tua osservazione: una volta raggiunta la sincronizzazione della cpu con i raster, devi organizzare il tuo codice in modo da "far capitare le cose nel momento giusto"! Puoi ad esempio cambiare il colore del bordo al ciclo 63 di tutte le righe per creare delle linee orizzontali. E' chiaro che per arrivare al ciclo 63 di ciascuna riga dovrai far fare qualcosa al processore... al limite fargli perdere tempo!
In realtà si può cambiare il colore di sfondo anche più volte in una riga creando i famosi raster split; o ancora provare ad aprire i bordi laterali (cosa che si può fare unicamente con un raster stabile).

6)
Comincia a pensare alla maledizione delle badline...  :doh:  non sono sparite eh!

[Elder0010]

Ok, grazie per l'ennesima spiegazione! é tutto chiaro. Ho aggiustato un po i timing, e ora mi sembra stabile!!

Ho visto il codice con il bordo in modalità debug, e ora è perfettamente fermo! è sparito anche il problema del flickering sui tasti premuti.

Ho contato i cicli in modo che il termine dell'istruzione sta $d021 (dentro la routine rasterbars) cada esattamente al 63°esimo ciclo.

Cosi facendo si avrà una linea che partirà precisamente alla successiva linea raster (quindi la #$36!). Inoltre poi ho "perso tempo" in modo da far terminare la rts al 63°esimo ciclo della linea #$36.

Che te ne pare? se non vedi errori comincio a lavorare un po sulle badlines

Codice: [Seleziona]

;prova doppio interrupt nested

    *=$0801
    include basicline.s

   sei  
   tax
   stx $d020
   stx $d021

   lda #<irqpre
   ldx #>irqpre
   sta $0314
   stx $0315
  
   lda #$01
      sta $d01a  ; Turn on raster interrupts
  
   lda #$34    
   sta $d012
   lda #$1b    
   sta $d011
   lda #$7f
   sta $dc0d
   sta $dd0d
  
   LDA $DC0D; Acknowledge CIA IRQ
   LDA $DD0D; Acknowledge CIA NMI
   LSR $D019; Acknowledge VIC IRQ
   cli

hold
   jmp hold


;FINO A QUI  X + 7 + 29 cicli.
;ricorda che 2<=X<=9 e X è la
;durata dell'ultima istruzione eseguita
;prima dell'interrupt
;quindi lsr $d019 viene seguita dopo 29+X+7
;caso peggiore 45 cicli, ne ho solo  18
irqpre  
   lda #<irq  ;2
   sta $0314  ;4
   sta $d019;4 rispetto ad una inc scendo di 2 cicli
   inc $d012  ;6    
   cli  ;2

;---FINO A QUI MAX 18 CICLI (cosiderato caso peggiore)

  
  ;Aggiungo una serie di nop per "non fare nulla" intanto che
          ;l'altro interrupt viene eseguito
   nop
   nop
   nop
   nop
   nop;5 nop per totale di 10 cicli, sono sicuro in tutti i casi
  ;(considerando anche il caso migliore)

   brk

   align 2
   *=*+1;
  ;la routine verrà eseguita con un ritardo di 2/3+7+29=38/39 cicli.
irq
   nop;41
   nop;43
   nop;45
   nop;47
   nop;49
   bit $24;52
  
   asl $d019;6 = 58
   lda #$35  ;2 = 60
   cmp $d012  ;4 = 64 / 1° ciclo
  
   beq start  ;con questo branch allineo l'ultimo
start                  ;ciclo di insicurezza

  ;In teoria qui il conto si resetta a 0 cicli
  ;perche ho stabilizzato il tutto
   jsr rasterbars;6 cicli
        
  ;Tolgo i 6 bytes inseriti nello stack
  ;facendo push nell'accumulatore 6 volte
   pla
   pla
   pla
   pla
   pla
   pla
  
   ldy #<irqpre;Punto di nuovo al primo interrupt
   sty $0314
  
  ;rimetto apposto anche il registro $d012
   lda #$34
   sta $d012
  
   jmp $ea31
  

rasterbars  
   lda colors;2
  ;ora devo perdere tempo in modo da esaurire i 63-8 = 55 cicli
  
  ;**********************************
  ;*Questo blocco sono 4*12 + 2 = 50
  ;**********************************
   ldx #$0a;2
   dex;2
   bne *-1;2
  
   nop
   bit $24;55 !!
  
  ;Finisco di disegnare la riga proprio al 63°esimo ciclo
   sta $d020;4
   sta $d021;4
  
  ;Ora devo aspettare altri 63 cicli prima di
  ;resettare il colore del background
   ldx #$0a
   dex
   bne *-1
  
   nop
  
  ;e siamo a 47
    
   lda #$0;2    
   sta $d020;4
   sta $d021;4
      
   rts;6 - 63 tondi
  


dir       .byte $0
offs      .byte $90

colors
         .byte $01,$07,$05,$03,$07,$02
         .byte $09,$06,$03,$05,$03,$02
         .byte $0e,$03,$03,$0e,$03,$03
         .byte $03,$01,$03,$01,$01,$03
         .byte $01,$01,$01,$03,$01,$01
         .byte $03,$01,$03,$03,$03,$0e
         .byte $03,$03,$0e,$03,$0e,$0e
         .byte $0e,$06,$0e,$0e,$06,$0e
         .byte $06,$06,$06,$06,$06,$06


[Freshness79]

 Ok, hai realizzato la tua prima raster routine perfettamente stabile!
Puoi anche levare il jmp hold e mettere un semplice rts: la stabilità rimane anche se lavori in basic e fai altre cose. Solo se premi restore noterai del movimento, perché viene generato un nmi. Ci sarebbe il modo di eliminare pure quello ma per il momento sorvoliamo.
Il raster adesso é stabile comunque, senza ombra di dubbio.
I conti che hai fatto per i cicli di ritardo, invece, sono un po' meno giusti, ti propongo lo spezzone di codice corretto. Dai un'occhiata e regolati per le eventuali righe successive.

Codice: [Seleziona]


cmp $d012 ;Qua o siamo a 0 o a 1
beq start ;Qua aggiungiamo 3 oppure 2 cicli
start        ;3 QUA SIAMO SEMPRE NEL 3° CICLO DELLA 3° RIGA

 ;(In teoria qui il conto si resetta a 0 cicli) ?? :) IN PRATICA NO!
 ;ho (stabilizzato)-> SINCRONIZZATO il tutto
   jsr rasterbars;9
        
 ;Tolgo i 6 bytes inseriti nello stack
 ;facendo push nell'accumulatore 6 volte
   pla
   pla
   pla
   pla
   pla
   pla
  
   ldy #<irqpre;Punto di nuovo al primo interrupt
   sty $0314
  
 ;rimetto apposto anche il registro $d012
   lda #$34
   sta $d012
  
   jmp $ea31
  

rasterbars  
   lda colors;13
 ;ora devo perdere tempo in modo da esaurire i 63-(13-4) = 46 cicli
    
   ldx #$09;2  2+2+(x-1)*5+2 => 4+8*5+2 = 46
   dex  ;2
   bne *-1 ;2/3
      
 ;Finisco di disegnare la riga proprio al 63°esimo ciclo
   sta $d020;(63) Fine riga
   sta $d021;4° ciclo riga successiva
  
 ;Ora devo aspettare altri 63-4 cicli prima di
 ;resettare il colore del background

   ldx #$0a;51 stessa formula di sopra
   dex
   bne *-1
  
   nop; 51+4+2=57
  
 ;e siamo a... 57
    
   lda #$0 ;59
   sta $d020;(63) fine riga
   sta $d021;4° ciclo nuova riga
      
   rts;6 - 10... comunque tondi ma non 63!;)


[Elder0010]

 Ecco qua: chiedo scusa per la rozzezza del codice (sarebbe stato meglio mettere tutto in un loop e fare riferimento a una timing table per i delays..) però cosi' è stato piu' facile fare le prove. sono andato avanti finchè non ho incontrato una badline, e ho cambiato il timing value. poi ho disegnato un ulteriore riga "standard".

Codice: [Seleziona]

;prova doppio interrupt nested

    *=$0801
    include basicline.s

   sei  
   jsr $e544;screen clear

   lda #<irqpre
   ldx #>irqpre
   sta $0314
   stx $0315
  
   lda #$01
      sta $d01a   ; Turn on raster interrupts
  
   lda #$34    
   sta $d012
   lda #$1b    
   sta $d011
   lda #$7f
   sta $dc0d
   sta $dd0d
  
   LDA $DC0D; Acknowledge CIA IRQ
   LDA $DD0D; Acknowledge CIA NMI
   LSR $D019; Acknowledge VIC IRQ
   cli

hold
   jmp hold


;FINO A QUI  X + 7 + 29 cicli.
;ricorda che 2<=X<=9 e X è la
;durata dell'ultima istruzione eseguita
;prima dell'interrupt
;quindi lsr $d019 viene seguita dopo 29+X+7
;caso peggiore 45 cicli, ne ho solo  18
irqpre  
   lda #<irq  ;2
   sta $0314  ;4
   sta $d019;4 rispetto ad una inc scendo di 2 cicli
   inc $d012  ;6    
   cli  ;2

;---FINO A QUI MAX 18 CICLI (cosiderato caso peggiore)

  
  ;Aggiungo una serie di nop per "non fare nulla" intanto che
           ;l'altro interrupt viene eseguito
   nop
   nop
   nop
   nop
   nop;5 nop per totale di 10 cicli, sono sicuro in tutti i casi
   ;(considerando anche il caso migliore)

   brk

   align 2
   *=*+1;
  ;la routine verrà eseguita con un ritardo di 2/3+7+29=38/39 cicli.
irq
   nop ;41
   nop ;43
   nop ;45
   nop ;47
   nop ;49
   bit $24;52
  
   asl $d019;6 = 58
   lda #$35   ;2 = 60
   cmp $d012  ;4 =  64 - siamo a 0 o 1 cicli
  
   beq start  ;3 con questo branch allineo l'ultimo
start                  ;ciclo di insicurezza

  ;QUI SIAMO SICURAMENTE a 3.
   jsr rasterbars;9
        
  ;Tolgo i 6 bytes inseriti nello stack
  ;facendo push nell'accumulatore 6 volte
   pla
   pla
   pla
   pla
   pla
   pla
  
   ldy #<irqpre;Punto di nuovo al primo interrupt
   sty $0314
  
  ;rimetto apposto anche il registro $d012
   lda #$34
   sta $d012
  
   jmp $ea31
  

rasterbars  

    lda colors;13
;ora devo perdere tempo in modo da esaurire i 63-(13-4) = 46 cicli
    
    ldx #$09;2  2+2+(x-1)*5+2 => 4+8*5+2 = 46
    dex ;2
    bne *-1;2/3
      
   ;Finisco di disegnare la riga proprio al 63°esimo ciclo
    sta $d020;(63) Fine riga
    sta $d021;4° ciclo riga successiva
;NUOVA LINEA!  
   ;Ora devo aspettare altri 63-4 cicli prima di
   ;resettare il colore del background

    ldx #$0a;51 stessa formula di sopra
    dex
    bne *-1
  
   ; 51+4=55
  
   ;e siamo a... 55
    lda colors+2;59
    sta $d020;(63) fine riga
    sta $d021;4° ciclo nuova riga
;NUOVA LINEA!  - mancano 59 cicli
    ldx #$0a;51 stessa formula di sopra
    dex
    bne *-1
    
    lda colors+3
    sta $d020
    sta $d021
;NUOVA LINEA!  - mancano 59 cicli    
    
    ldx #$0a;51 stessa formula di sopra
    dex
    bne *-1
  
    lda colors+4;59
    sta $d020;(63) fine riga
    sta $d021;4° ciclo nuova riga
;NUOVA LINEA!  - mancano 59 cicli    
    
    ldx #$0a;51 stessa formula di sopra
    dex
    bne *-1
    
    lda colors+5
    sta $d020;
    sta $d021;4° ciclo nuova riga BADLINE
    
;NUOVA LINEA! BADLINE!! siccome l'ultima istruzione eseguita è una STA allora
; ho solo 22 cicli, di cui 4 ne ho gia consumati. ne restano 18      
    ldx #$01;6
    dex
    bne *-1
    nop
    lda colors+6;10
    sta $d020;14
    sta $d021;22
  
;NUOVA LINEA!  (non badline)  
    
    ldx #$0a
    dex
    bne *-1
    
    lda colors+5
    sta $d020
    sta $d021
    
    nop;allineo timings!
    
    ldx #$0a;51 stessa formula di sopra
    dex
    bne *-1
  
    lda #$0
    sta $d020
    sta $d021
  
    rts
  

colors
         .byte $06,$02,$03,$04,$05,$08
         .byte $07,$08,$04,$01,$00,$06
         .byte $0e,$03,$03,$0e,$03,$03
         .byte $03,$01,$03,$01,$01,$03
         .byte $01,$01,$01,$03,$01,$01
         .byte $03,$01,$03,$03,$03,$0e
         .byte $03,$03,$0e,$03,$0e,$0e
         .byte $0e,$06,$0e,$0e,$06,$0e
         .byte $06,$06,$06,$06,$06,$06


[antoniomauro]

 Complimenti per il sorgente e per come ci sei arrivato!
Leggere la discussione è stato illuminante!
 

[Elder0010]

 il merito è tutto di freshness e delle sue spiegazioni!

[antoniomauro]

 E' veramente preparatissimo!

[Freshness79]

 Vi ringrazio molto ma i meriti vanno tutti alle persone che, con notevole dovizia di particolari, hanno documentato l'hardware.
Io, come molti altri, mi sono limitato a leggere, ad applicare e a riportare.
Vi ricordo le due bibbie del 64:
- VIC-article
- 64DOC
Non metto i link ma basta una "googolata"... Il primo dei due in particolare consente di capire a fondo il comparto grafico del 64.
Non so se esistano documenti altrettanto dettagliati sul SID: magari iAN potrebbe conoscerne.
Ed ho sempre trovato informazioni spezzettate anche sui 2 CIA.
Forza Elder, attendo un raster più alto: almeno una 40ina di righe!