Emulazione Sid Da Css64

[bennylaser]

 Salve, vorrei sapere perchè, quando provo a settare le note con i poke su css64, il dato inserito sui 3 Hy-Bytes della memoria deidicati al SID mi determinano un nota precisa, ma questa è indipendente dal dato scritto nel Low Byte corrispettivo: sò benissimo che non tutte le 65536 combinazioni sono associate ad una nota, ma la precisione del c64 originale era tale da darmi note differenti 8o forse ricordo male ed ho influenzato i miei ricordi...). Con l'emulatore css64 invece, posso fare solo 256 note, dipendenti dai soli Hy-bites (mi sembrano che siano i 54272+1 o +8, ecc., ecc., per i 3 canali sonori); il bello è che c'è differenza tra un canale e l'altro, nel senso che per il 1° il low byte conta come un monarca in un paese democratico, e nel 2° mi fa fare solo qualche nota.
Avete mai risontrato questo problema?!
Provate  a fare un doppio ciclo for in cui mandate da 0 a 255 i due byte di frequenza low & high, vorrei sapere che succede a voi! Speriamo bene !

[iAN CooG]

 Innanzitutto c'e' da dire che l'emulazione SID in CCS64 e' meno "perfetta" del motore reSID contenuto in Vice, che e' comunque inferiore a Hoxs64 se si considera il SID 8580 come riferimento. Prova con un altro emulatore.

Poi, riguardo le frequenze, leggendo All About Your 64 troviamo:

SID-Maths:

  Frequency:
  ----------

   To calculate the frequency corresponding to the 16-bit value in
   $D400+$D401, $D407+$D408, $D40E+$D40F use the following formula:

    Freq = 16Bit-Value * Phi2 / 16777216 Hz

   where Phi2 is the system-clock, 985248 Hz for PAL-systems,
   1022727 Hz for NTSC-systems.

   A good approximation for both systems is the formula:

    Freq = 16Bit-Value / 17.03

Si evince che non tutti i valori nei registri Frequency Control  low+hi generano frequenze diverse. Assumendo che le frequenze generate siano comunque gestite come numeri interi dal SID, con questo programma ho calcolato i possibili valori della frequenza e dei corrispondenti valori a 16 bit

Codice: [Seleziona]


#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
int freq,oldfreq=-1;
const double Phi2=985248.0;
const double Hz = 16777216.0;
int Value;
for(Value=0;Value<0x10000;Value++)
{
    freq=Value*Phi2/Hz;
    if(freq!=oldfreq)
    {
        oldfreq=freq;
        printf("Value 0x%04x Freq %5d\n",Value,freq);
    }
}
return 0;
}

che da' come risultati

Codice: [Seleziona]

Value 0x0000 Freq     0
Value 0x0012 Freq     1
Value 0x0023 Freq     2
Value 0x0034 Freq     3
Value 0x0045 Freq     4
Value 0x0056 Freq     5
[....]
Value 0x06a7 Freq   100
Value 0x06b8 Freq   101
Value 0x06c9 Freq   102
Value 0x06da Freq   103
Value 0x06eb Freq   104
Value 0x06fc Freq   105
Value 0x070e Freq   106
Value 0x071f Freq   107
Value 0x0730 Freq   108
Value 0x0741 Freq   109
Value 0x0752 Freq   110
[....]
Value 0xff90 Freq  3842
Value 0xffa1 Freq  3843
Value 0xffb2 Freq  3844
Value 0xffc3 Freq  3845
Value 0xffd4 Freq  3846
Value 0xffe5 Freq  3847
Value 0xfff6 Freq  3848

Ora vedi tu che conclusioni trarre, perche' io non e' che me ne intenda molto di SID. Posso solo consigliare di leggere il libro di Franco Fabbri che trovi tra le scansioni libri del sito se sei interessato alla materia

[MarC=ello]

 Dall'appendice E della C64 Programmer's Reference Guide risulta che la scala anglosassone è costituita da 124 note... per cui ad ogni valore a 16 bit della frequenza non e' univocamente associabile una nota (esistono cioè dei valori della frequenza troppo vicini fra loro che non danno luogo a note distinguibili dal nostro orecchio). Infatti, se diversamente fosse, dovrebbe essere possibile generare con il sid ben 2^16 = 65536 differenti note!

Di qui credo sia abbastanza chiaro che incrementando il solo byte basso non si ottengano differenze di frequenza ben distinguibili dal nostro orecchio... con particolare riferimento a quando si lavora con frequenze alte. Infatti, sempre osservando detta tabella:

- nella ottava 1, tra il si e il la vi è una differenza di frequenza di 1012 - 902 =  110Hz;
- nella ottava 5, tra il si e il la vi è una differenza di frequenza di 16203-14435 = 1768 Hz.

Quindi, alle alte frequenze modificando il solo byte basso non si ottiene di sicuro alcuna differenza... mentre alle bassissime frequenze si'.



 

[bennylaser]

 iAN CooG/HF, sei un mito, pure il codice C!!! Grande!!!! Grazie per l'aiuto, veramente.
MarC=ello, ringrazio anche te, ma vorrei dirti che la tua teoria non regge, perchè è vero che non abbiamo l'udito fine come quello dei pipistrelli, ma è anche vero che se non sono capace di sentire variazioni di nota troppo basse, allora passando da HI=X & LO=255 a HI=X+1 & LO=0 non dovrei sentire tanta diferenza, ovvero nel cambiare valori ad entrambi si dovrebbero avere variazioni continue, ma si sente bene il cambio di nota per differrenti valori di High, per qualunque, dico qualunque, valore di Low.
 

[MarC=ello]

 In tutta franchezza, mi sembra che tu non abbia ben chiaro il concetto di byte alto e byte basso...

allora passando da HI=X & LO=255 a HI=X+1 & LO=0 non dovrei sentire tanta diferenza

ovvero nel cambiare valori ad entrambi si dovrebbero avere variazioni continue

Ehm... io non ho affermato questo, ne' queste frasi possono essere conseguenza di quanto ho affermato.

ma si sente bene il cambio di nota per differrenti valori di High, per qualunque, dico qualunque, valore di Low.

E per forza, visto che ogni volta che incrementi il byte alto praticamente aggiungi la quantita' $ff (255 decimale) al valore a 16 bit che stabilisce la frequenza della nota.

Prova a tenere fisso il byte alto e ad incrementare il byte basso di uno in uno... non potrai notare differenze. Invece prova a variare il byte alto di uno in uno tenendo fisso il byte basso... e noterai grandi differenze. Questo e' l'esperimento significativo da fare, diversamente non ha gran che senso.
 

[MarC=ello]

 

allora passando da HI=X & LO=255 a HI=X+1 & LO=0 non dovrei sentire tanta diferenza

Effettivamente ho provato, e proprio su CCS64, e non si sente proprio alcuna differenza... era impossibile che il problema dipendesse dall'emulatore, comunque per scrupolo ho fatto la prova lo stesso:

Codice: [Seleziona]


5 s=54272
10 forl=stos+24:pokel,0:next
20 pokes+5,88:pokes+6,195
30 pokes+24,15
40 pokes+1,29:pokes,255
50 pokes+4,33
60 fort=1to1000:next
70 pokes+4,32


Ascoltiamo la nota generata da questo programma. Il valore a 16 bit che determina la frequenza è 255+29*256 = 7679. Quindi, modifichiamo la linea 40 con:

40 pokes+1,30:pokes,0

Ascoltiamo di nuovo. Nessuna differenza tra le due note! Infatti, ora il valore a 16 bit che determina la frequenza e' 30*256 = 7680. Essendo i due valori differenti tra loro solo di una unita', e' IMPOSSIBILE udire alcuna differenza tra le due note... ed e' implausibile che CCS64 dia risultati differenti (come del resto ho facilmente verificato), altrimenti questo emulatore dovrebbe essere stonato come una campana... ma fortunatamente non e' assolutamente cosi' e ci si sentono bene maree di musiche sid, fin dalle sue prime versioni. Ancora, secondo me hai confuso tra loro byte alto e byte basso... Oppure c'e' probabilmente un errore nel tuo programma che hai scritto per fare gli esperimenti.

[MarC=ello]

 Per completezza, ho scritto un semplice programma in basic (non ottimizzato per avere una migliore leggibilita') che varia con continuita' la frequenza di una nota mentre questa viene riprodotta:

Codice: [Seleziona]

start tok64 prova.prg
10 s=54272
12 FORl=sTOs+24:POKEl,0:NEXT
15 POKEs+5,88:POKEs+6,195
20 POKEs+24,15
25 POKEs+4,33
30 FOR h = 0 TO 40
40 FOR l = 0 TO 255
50 POKEs+1,h:POKEs,l
60 NEXT l
70 NEXT h
80 POKEs+4,32
stop tok64
(bastext 1.04)
Come si puo' udire, la frequenza della nota varia con continuita' e la sua altezza non subisce bruschi sbalzi. Cio' e' facilmente verificabile con qualunque emulatore, CCS64 compreso. Ho limitato il valore finale del byte alto per non riprodurre suoni troppo acuti e quindi fastidiosi... comunque il programma e' facilmente modificabile in modo da provare intervalli di frequenza piu' ampi.

Inoltre, questo programma dimostra anche che alle basse frequenze l'altezza del suono varia molto velocemente con la frequenza, mentre spostandosi verso le ottave piu' alte l'altezza del suono tende a variare sempre piu' lentamente (come si puo' udire), nonostante la frequenza vari con legge lineare. Cio' dimostra che la relazione fra altezza del suono  e sua frequenza non e' lineare, e che quindi spostandosi verso ottave sempre piu' alte il valore della minima variazione di frequenza percettibile diventa sempre piu' grande (come del resto si vede al volo leggendo le gia' citata appendice E della C64 PRG).




 

[bennylaser]

 Marc=ello, io l'ho eseguito su CSS64 (non ancora su Hoxs64) con l'aggiunta della riga
55 PRINT "HIGH=";H;", LOW=";L;"."
e tiposso dire che sento uno 'scatto', una variazione di frequenza, solo quando H cambia valore. Non lo sò, avrò una versione di CSS64 troppo vecchia (è la 3.4)?
Messo sempre delle print, così anche se ritardano l'esecuzione del programma (qualunqe sia l'ambiente di programmazione, interpretato come questo o compilato come nel c) mi mostrano dove sono: ripeto, la variazione di frequenza la sento solo al cambio di H.
Sul vecchio manuale (che ho ancora) c'era scritto ben in chiaro che si dovevano sentire 65000 diverse tonalità, ma non mi pare. Certo, se funzionasse come dici il manuale direbbe la verità, ma a me i conti (o meglio i suoni) non tornano).
 

[iAN CooG]

 E ridalli: CCS non CSS (!)
Perche' non provi su vice? Hai letto le altre documentazioni che ti abbiamo suggerito?
Ti sono stati dati diversi esempi e consigli, se vuoi accettarli bene, altrimenti fai come ti pare.

[MarC=ello]

 Bah, a questo punto non so cosa altro aggiungere...

Ah, si', una cosa mi e' venuta in mente... E' ovvio che l'interprete basic tutto sommato e' lento, quindi ci possono essere degli istanti in cui il suono viene riprodotto quando ancora soltanto uno dei due byte della frequenza e' settato (si parla di un brevissimo istante che puo' sporcare il suono di tanto in tanto per una piccola frazione di secondo). Quindi, se quello che tu chiami "variazione di frequenza" e' questo, forse ho inteso quello che vuoi dire... Prova a convertire l'ultimo programma che ho postato in asm e vedrai che non sentirai alcuno scatto, ne' con CCS64 ne' con altro emulatore. E' una questione di lentezza dell'interprete basic, e non certo di emulatore. Probabilmente era questo il tuo dubbio...




 

[iAN CooG]

 

Codice: [Seleziona]

MAC POKE
    lda #{2}
    sta {1}
ENDM
    *=$0801
    word eop
    word 7102
    byte $9e
    byte "2061",0
eop word 0

s=$d400

    ldx #$18
    lda #0
zd  sta s,x
    dex
    bpl zd

    POKE s+5,88
    POKE s+6,195
    POKE s+24,15
    POKE s+4,33

    ldx #0
    ldy #0
sts
    stx s+1
    sty s
    stx $0401
    sty $0400

    lda $d012
    bne *-3

    iny
    bne sts
    inx
    bne sts
    POKE s+4,32
    rts



[bennylaser]

 Ragazzi, siete grandi. Vi ringrazio per il vostro pronto aiuto, e scusatemi per la testardaggine.
Solo una cosa, io romai sono abituato con vari assembly, tra cui quello dei processori 80x86 e quello dei microcontrollori RISC PIC16Fx, ma quello del C64 non mi è così pratico, tempo fà lo convertii con tanti POKE addr,val e poi lo eseguii con un SYS, ma non ci sarebbe un modo più diretto, che sò, un aplicazione java che te lo converta e salvi in file txt? Ditemi voi, sono nele vostre mani esperte!
iAN CooG/HF, grazie comunque per il listato, e MArC=ello, seguirò il to consiglio.

P.S.: scusate per il CSS.......

[iAN CooG]

 per i sorgenti basic, bastext
per i sorgenti asm, dasm
entrambi sul mio sito, ma no, java non entrera' mai in casa mia. Solo C