Ready64 Forum
Commodore 64 => Programmazione, Grafica e Musica => Topic aperto da: 6526_CIA - 07 Ottobre 2005, 17:23:58
-
Salve a tutti,
Vorrei dire che una competenza cosi come ho visto nei forum mi fa sentire una schiappa totale,forse questo mio sentirmi cosi mi spinge a chiere aiuto,per me e per tutti quelli che vorrebbero ma non osano chiedere.
Il mio problema è l'assembler :huh:
Ho sempre programmato in basic,molto piu facile da autoapprendere,spaziando dal c16 al c64 al c128 e ho scritto diversi bei gioiellini (mi sono diplomato con una minitesi su un programma che simulava la fase di decollo di un aereo fatto con il c128).
Il problema è che vagando per internet sono inciampato su quei "pazzi" "geni" della :hail: PROTOVISION.
Ma avete visto cosa fanno fare ad un C64?SuperCPU a parte.....
Tutto assembler.....col basic non ci faccio niente di quello che vorrei aiutatemi
sennò :doh: .
-
Qual e' la domanda?
-
La domanda è:l'assembler potete spiegarlo dalle basi?magari con esempi pratici,tutte le volte che hanno provato mi hanno propinato:
LDA......
LDY.....
STO.....
nel senso,si puo capire l'assembler con esempi pratici?Il programma della mongolfiera sul manuale del c64 spiegava un po di cose....
L'assembler fatto cosi....un programma dei commenti.....
-
magari con esempi pratici,tutte le volte che hanno provato mi hanno propinato:
LDA......
LDY.....
STO.....
Scusa,ma se vuoi gli esempi pratici le LDA,LDY ecc. te le devi sorbire per forza...
Comunque,su Internet non mi risulta che ci siano guide in Italiano,a parte il corso introduttivo dell'ex-membro MarC=ello,che adesso si trova sul sito degli HF.
Comincia da lì:è un buon inizio.
Ciao
-
Ciao... da un mese a questa parte grazie a Marcello ho capito che col basic si può fare molto ;)
Comunque anche l'esempio della mongolfiera, o quello delle "bouncing balls" possono essere paragonate all'assembler perchè sempre di programmazione si tratta, e la programmazione è tutto fuorchè discorsiva. In base a questo, credo, che è sempre relativo dire il basic è facile, il c è difficile, l'asm impossibile.
Anche io sono nelle tue stesse condizioni e, se accetti un consiglio, ti dico di seguire gli esempi che ogni tanto vengono postati in programmazione e provare a modificarli. Credo che gli utenti qui presenti, che di lm commodorense ne capiscono eccome, sono ben felici di chiarirti alcuni dubbi ma, come dire, il grosso lo devi fare tu.
Finisco quotando Alberto: la guida di Marcello è un ottimo testo su cui studiare..
:ciauz:
-
L'assembler è una gran brutta bestia, di qualsiasi "famiglia" di CPU parliamo. Nel caso del 65xx (e del 6510 del C64 in particolare), però, quantomeno all'epoca sono uscite tantissime pubblicazioni che aiutavano a capirne i meandri. Una su tutte CCC e il suo "fratello minore" Commodore.
Io, pur NON ritenendomi pratico di assembler, tutto quello che so l'ho imparato da lì.
Visto che a quanto pare una parte di numeri di CCC sono ormai disponibili in rete, penso che se sei interessato all'argomento non sarebbe una cattiva idea partire da lì. Cominciare a vedere i disassemblati commentati delle routine più semplici, iniziare a tenere a mente i puntatori e cercare di capire cosa vogliono dire quelle sigle (LDA, STA, LDY, RTS ecc.) che non sono, in fondo, molto diverse come concetto dalle tante sigle che oggi si usano su Internet per dire LOL, ROTFL e via dicendo. Insomma sono acronimi (più o meno) di termini e frasi in inglese.
E' ovvio che un'infarinatura di base aiuta, ma penso che guardando i disassemblati di CCC se ne possa fare anche a meno, perché niente è meglio di un esempio pratico per imparare qualcosa.
Se ti dicessi che LDA sta per LoaD Accumulator, tu giustamente mi chiederesti cos'è e a cosa serve l'accumulatore.
Se invece io ti scrivessi:
LDA $0F ; Carica il numero decimale 15 nell'accumulatore...
STA $C000 ; ... e piazzalo nella locazione decimale 49152
RTI ; Torna da interrupt
Già capisci che tutto questo è l'equivalente di una POKE49152,15 da BASIC.
Inoltre, e questo è molto più importante, ti spiega a cosa serve l'accumulatore: è una sorta di "contenitore" di numeri transitori. E in più hai imparato anche a che servono STA (STore Accumulator) e RTI (ReTurn from Interrupt).
Chiaro, no? :D
-
RTI ; Torna da interrupt
RTS. A questi livelli e' piu' che sufficiente. ;)
-
RTI ; Torna da interrupt
RTS. A questi livelli e' piu' che sufficiente. ;)
Per un attimo temevo che l'RTS non tornasse al BASIC (ovvio che la routine andasse lanciata tramite SYS). ;)
Ho sempre creduto che JMP e JSR fossero l'equivalente di GOTO e GOSUB rispettivamente, e che RTS fosse l'equivalente del comando RETURN del BASIC. Sbaglio? (Devo studiare, lo so :D)
-
Devo dire che l'esempio che hai fatto è il più chiaro che mi sia stato fatto.
Penso comunque di essere in condizioni DISASTROSE perchè se vedo scritto:
10 PRINT" pippo"
20 GOTO 10
non ho problemi hacapire come risponderà il computer a questi comandi,ma non so scriverlo il ASM.
Pensa che sia proprio una carenza concettuale la mia.
Come posso ottenere lo stesso risultato delle due righe di cui sopra solamente caricando valori negli accumulatori?
-
Per un attimo temevo che l'RTS non tornasse al BASIC
:confused:
Ho sempre creduto che JMP e JSR fossero l'equivalente di GOTO e GOSUB rispettivamente e che RTS fosse l'equivalente del comando RETURN del BASIC
Anch'io :D
Penso comunque di essere in condizioni DISASTROSE
Chiunque all'inizio è in condizioni disastrose:nessuno nasce con la scienza infusa. ;)
10 PRINT" pippo"
20 GOTO 10
non ho problemi hacapire come risponderà il computer a questi comandi,ma non so scriverlo il ASM.
Beh,per uno che parte da zero con l'assembler non è semplicissimo tradurre un programma simile. ;)
Inizia con qualcosa di più semplice,per esempio togliendo quel 20 GOTO 10.
La routine per stampare il carattere ASCII nell'accumulatore è locata all'indirizzo 65490 ($ffd2 in esadecimale).Quindi dovrai dare in pasto al tuo programma tutti i caratteri della stringa e chiamare la routine a $ffd2 per ogni carattere,fino a quando non arrivi alla fine della stringa.
Io ti ho dato l'algoritmo;adesso tocca a te trovare gli "ingredienti" giusti. ;)
Ciao
-
Per un attimo temevo che l'RTS non tornasse al BASIC
:confused:
Sì hai capito bene. Ho invece poi ovviamente verificato la routine e funziona perfettamente con RTS. :D
-
10 PRINT" pippo"
20 GOTO 10
Inizia con qualcosa di più semplice,per esempio togliendo quel 20 GOTO 10.
La routine per stampare il carattere ASCII nell'accumulatore è locata all'indirizzo 65490 ($ffd2 in esadecimale).Quindi dovrai dare in pasto al tuo programma tutti i caratteri della stringa e chiamare la routine a $ffd2 per ogni carattere,fino a quando non arrivi alla fine della stringa.
Io ci ho provato, ma non funziona:
LDA $10 ; Carattere "P" nell'accumulatore
JSR $FFD2 ; Salto a $FFD2
LDA $09 ; Carattere "I" nell'accumulatore
JSR $FFD2 ; Salto a $FFD2
LDA $10 ; Carattere "P" nell'accumulatore
JSR $FFD2 ; Salto a $FFD2
LDA $10 ; Carattere "P" nell'accumulatore
JSR $FFD2 ; Salto a $FFD2
LDA $0F ; Carattere "O" nell'accumulatore
JSR $FFD2 ; Salto a $FFD2
RTS ; Torna al BASIC
L'ho immessa a partire da $C000 (49152) ma con un SYS49152 mi dice READY. e basta. Avendo il dubbio della colorazione della cella sono andato col cursore su tutto lo schermo ma nulla, non ho trovato la stringa PIPPO da nessuna parte.
Dov'è che sbaglio?
P.S. Ho usato il monitor del VICE 1.17
EDIT: Non è che dovevo usare LDX? :D Oppure che il READY. del BASIC m'è venuto scritto SOPRA alla stringa?
-
Occhio alla differenza tra GOSUB e SYS:la prima chiama da Basic una routine Basic,la seconda chiama da Basic una routine assembler.
Io ci ho provato, ma non funziona:
LDA $10 ; Carattere "P" nell'accumulatore
JSR $FFD2 ; Salto a $FFD2
LDA $09 ; Carattere "I" nell'accumulatore
JSR $FFD2 ; Salto a $FFD2
LDA $10 ; Carattere "P" nell'accumulatore
JSR $FFD2 ; Salto a $FFD2
LDA $10 ; Carattere "P" nell'accumulatore
JSR $FFD2 ; Salto a $FFD2
LDA $0F ; Carattere "O" nell'accumulatore
JSR $FFD2 ; Salto a $FFD2
RTS ; Torna al BASIC
L'ho immessa a partire da $C000 (49152) ma con un SYS49152 mi dice READY. e basta. Avendo il dubbio della colorazione della cella sono andato col cursore su tutto lo schermo ma nulla, non ho trovato la stringa PIPPO da nessuna parte.
Dov'è che sbaglio?
Allora,andiamo con ordine.
1.Innanzitutto,la routine $ffd2 prende i caratteri ASCII di una stringa,mentre tu le hai passato delle locazioni di memoria (che forse volevano essere i codici schermo dei caratteri).
Se non erro,i codici ASCII dei caratteri A-Z vanno da 65 a 90 ($41-$5A in esadecimale).
2.Ti conviene creare un ciclo per non scrivere la stessa istruzione 5 volte.
Ovviamente,ti servirà un "cursore" (ossia,un indice) per poterti spostare lungo la stringa,in modo da stamparne un carattere alla volta.
P.S.:per ora lascia perdere il GOTO 10;un concetto alla volta. ;)
Bye
-
2.Ti conviene creare un ciclo per non scrivere la stessa istruzione 5 volte.
Ovviamente,ti servirà un "cursore" (ossia,un indice) per poterti spostare lungo la stringa,in modo da stamparne un carattere alla volta.
Per cursore intendi una immissione sequenziale dei careatteri come si otterrebbe in basic creando un ciclo che opera con MID$?
-
Per cursore intendi una immissione sequenziale dei careatteri come si otterrebbe in basic creando un ciclo che opera con MID$?
Diciamo qualcosa di simile :)
-
Allora,andiamo con ordine.
1.Innanzitutto,la routine $ffd2 prende i caratteri ASCII di una stringa,mentre tu le hai passato delle locazioni di memoria (che forse volevano essere i codici schermo dei caratteri).
Sì nella fretta mi basavo sulla memoria video e non i codici ASCII.
Se non erro,i codici ASCII dei caratteri A-Z vanno da 65 a 90 ($41-$5A in esadecimale).
Sì, o almeno 65 è A, di questo sono sicuro.
E i codici ASCII come glieli passo? Devo "pokargli" (tradotto: LDA... STA)i caratteri della stringa in delle locazioni e poi dargli i puntatori? O devo fare come prima passandoglieli nell'accumulatore? O devo usare un altro comando simile a LDA che a quanto sto capendo può essere usato solo per le locazioni di memoria (ma non era STA ad essere usato per quello e LDA per contenere il *valore*)?
2.Ti conviene creare un ciclo per non scrivere la stessa istruzione 5 volte.
Devo ripassare le istruzioni per i cicli in Assembly. Finché è in BASIC è intuitivo con un bel FOR...NEXT, qui mi perdo ;)
Ovviamente,ti servirà un "cursore" (ossia,un indice) per poterti spostare lungo la stringa,in modo da stamparne un carattere alla volta.
No, qui proprio mi perdo del tutto e non ti seguo più. Se non va bene passargli un carattere alla volta io ho capito che devo dargli tutta la stringa insieme, ma se gli passo la stringa insieme perché dovrei far spostare il cursore? Perché, forse vorrebbe stampare la stringa senza muovere il cursore col risultato di una bella "O" (ultima lettera della stringa).
Senza contare che ancora non ho capito DOVE questa stringa andrebbe stampata, io avevo capito nel posto dove si trova il cursore e cioè (dato che abbiamo dato una SYS da BASIC) immediatamente sotto la SYS.
P.S.:per ora lascia perdere il GOTO 10;un concetto alla volta. ;)
Quello è semplice (un JMP all'inizio della routine e tanti saluti, anche se non la rende più rilocabile ma pazienza), il problema semmai è come uscire dal ciclo SENZA andare a scomodare il vettore NMI usando RUN/STOP + RESTORE. Quello sì che è complicato (no, reset o power off non vanno bene :P).
-
Ho scaricato il corso di assembler dal sito degli HF
Devo dire che è fatto veramente bene....ma ho un problema.
In primis da dire che non faccio girare l'esempio su un c64 reale ma su ccs64
secondo uso un software cross development chiamato 6502sdk.
Il fatto che non funzioni niente è dovuto all'emulatore o al 6502sdk?
E' frustrante avere come risposta sempre e comunque READY. e non succede niente..... :angry:
:hail: Aiutatemi......gia non ci capisco niente se poi anche i programmi che uso mi complicano la vita... :doh: confiso in voi per essere consigliato al meglio
Grazie
-
Il fatto che non funzioni niente è dovuto all'emulatore o al 6502sdk?
Potrebbe essere anche nel tuo codice, non pensi?
Posta e vediamo che c'e' che non va.
non ho mai visto questo 6502sdk, ora lo provo
-
In primis da dire che non faccio girare l'esempio su un c64 reale ma su ccs64
secondo uso un software cross development chiamato 6502sdk.
Ti consiglio il monitor del VICE, è molto più immediato e ricorda quello del C16/+4/C128.
-
Ti consiglio il monitor del VICE
Il monitor di vice va bene per debuggare, ma per scrivere programmi via monitor (che gia' e' un assurdita' di questi tempi) e' la cosa piu' orribile da usare. Molto meglio quello di CCS o un qualsiasi altro monitor (smon o quello delle varie cartucce)
Ad ogni modo scrivere da monitor andava bene quando non c'era altro, mi permetto di dirlo perche' l'ho fatto per TROPPO tempo; per fare le cose come si deve meglio un assembler.
Turbo assembler, Zeus, merlin, etc se si vuole fare da c64. C64asm, DASM, ca65, anche quel 6502sdk (anche se non mi sembra molto orientato al c64) etc se si vuole usare un crossassembler. Io consiglio caldamente DASM.
-
(un JMP all'inizio della routine e tanti saluti, anche se non la rende più rilocabile ma pazienza), il problema semmai è come uscire dal ciclo SENZA andare a scomodare il vettore NMI usando RUN/STOP + RESTORE. Quello sì che è complicato (no, reset o power off non vanno bene ).
???
devo fare come prima passandoglieli nell'accumulatore?
Sì.
QUOTE
Ovviamente,ti servirà un "cursore" (ossia,un indice) per poterti spostare lungo la stringa,in modo da stamparne un carattere alla volta.
No, qui proprio mi perdo del tutto e non ti seguo più. Se non va bene passargli un carattere alla volta io ho capito che devo dargli tutta la stringa insieme, ma se gli passo la stringa insieme perché dovrei far spostare il cursore? Perché, forse vorrebbe stampare la stringa senza muovere il cursore col risultato di una bella "O" (ultima lettera della stringa).
Senza contare che ancora non ho capito DOVE questa stringa andrebbe stampata, io avevo capito nel posto dove si trova il cursore e cioè (dato che abbiamo dato una SYS da BASIC) immediatamente sotto la SYS.
Stai facendo un pò di confusione... :)
Se usi un ciclo ti serve un cursore,cioè un indice che ti permetta di stampare prima la P,poi la I,poi l'altra P etc...;ovviamente dovrai prima memorizzare la stringa da qualche parte.
Cmq,per adesso dimenticati del ciclo.
Suggerimento:il tuo listato va bene,solo che carichi nell'accumulatore i valori sbagliati.
Ciao
-
Ian....DASM dove lo trovo?
Sul tuo sito?
-
un cursore,cioè un indice
Chiamiamo le cose con il loro nome altrimenti si' che si fa confusione.
Cursore e indice sono forse sinonimi ma universalmente si usa cursore per l'aggeggio lampeggiante che indica la posizione attuale a video, e con indice si indica uno dei 2 registri atti all'indirizzamento indicizzato (appunto)
Quello che vuole fare Massicadenti si puo' riassumere BREVEMENDE
; versione con controllo di terminatore stringa (0)
* = $1000
ldy #$00 ; init indice Y
loop
lda scritta,y ; carica A con il byte a scritta+Y
; in A abbiamo uno 0?
beq esci ; se si esci
jsr $ffd2 ; chiama la CHROUT, output di A
iny ; incrementa Y
bne loop ; limitiamo a 256 chars la stringa
esci
rts
scritta
BYTE "CHE SCRIVIAMO OGGI?"
BYTE 0
O magari sapendo quanto e' lunga la stringa
; versione con conteggio caratteri
* = $1000
ldy #0; init indice Y
loop
lda scritta,y ; carica A con il byte a scritta+Y
jsr $ffd2 ; chiama la CHROUT, output di A
iny ; incrementa Y
cpy #(fine-scritta)
bne loop ; se Y=numero di char abbiamo finito
esci
rts
scritta
BYTE "CHE SCRIVIAMO OGGI?"
fine
BYTE 0
Ma se vogliamo usare la routine di stampa del BASIC si puo' far prima
; versione con routine di print
* = $1000
lda #<scritta ; Byte basso indirizzo di stringa
ldy #>scritta ; Byte alto indirizzo di stringa
jsr $ab1e ; routine di print, stampa la stringa
rts
scritta
BYTE "CHE SCRIVIAMO OGGI?"
byte 0
-
Quello che vuole fare Massicadenti si puo' riassumere BREVEMENDE
; versione con controllo di terminatore stringa (0)
* = $1000
ldy #$00 ; init indice Y
loop
lda scritta,y ; carica A con il byte a scritta+Y
; in A abbiamo uno 0?
beq esci ; se si esci
jsr $ffd2 ; chiama la CHROUT, output di A
iny ; incrementa Y
bne loop ; limitiamo a 256 chars la stringa
esci
rts
scritta
BYTE "CHE SCRIVIAMO OGGI?"
BYTE 0
Così però non ci si può lamentare se nessuno impara niente,caro iAN CooG...
-
Così però non ci si può lamentare se nessuno impara niente,caro iAN CooG...
Almeno ora ha un idea di come vadano fatte le cose, studiarsi i sorgenti altrui (e disassemblati) aiuta sempre.
-
E' vero,ma è importante che chi vuole imparare qualcosa di assy si studi le basi (per questo richiamo più volte la guida di MarC=ello) e soprattutto impari a ragionare,specie per programmi così semplici.
Ragazzi,al solito fateci sapere il vostro pensiero altrimenti qui parliamo sempre in tre e si finisce sempre per chiedersi se uno è interessato oppure se a nessuno gliene frega niente...insomma,parlate pure liberamente,nessuno si offende qua dentro!
Ciao
:)
-
Ragazzi,al solito fateci sapere il vostro pensiero altrimenti qui parliamo sempre in tre e si finisce sempre per chiedersi se uno è interessato oppure se a nessuno gliene frega niente...insomma,parlate pure liberamente,nessuno si offende qua dentro!
Ciao Alberto,
io sarei anche interessato all'argomento, ma ci sono due grossi problemi all'assimilazione dell'assembrel per il C=64 per quanto mi riguarda, il primo è che ho poco tempo da dedicare allo studio e il secondo è che sono "piombo", nel senso che non ne capisco nulla di programmazione in linguaggio macchina (che andando in "goto" con il primo problema crea un loop infinito... ;) )...
A presto amici.
:ciauz:
-
Vi prego non fermate questa discussione!!!!! Forse l'unico modo per chi con buone conoscenze di basic del C64 ma NESSUNA conoscenza di assembler vuole iniziare...
1° dove trovo la guida di Marcello?
2° ho deciso di iniziare usando il monitor di CCS64: siccome parto davvero da zero, come si usa il monitor? cioè il listato in assembler, per esempio quello indicato all'inizio della discussione per "pokare" il valore decimale 15 nella locazione 49152
LDA $0F ; Carica il numero decimale 15 nell'accumulatore...
STA $C000 ; ... e piazzalo nella locazione decimale 49152
RTI ; Torna da interrupt
va' realmente digitato usando il monitor, cioè scrivendo ogni riga e premendo invio alla fine della stessa? Purtroppo le catene del Basic sono pesanti e nella mia mente c'e' ancora il concetto di programma come insieme sequenziale di istruzioni, con la possibilità di listarlo e memorizzarlo.... oltre che scriverlo cosa devo fare per poterlo lanciare con una bella SYS da basic? Cioè come si fa ad assemblare il listato trasformandolo in codice macchina? e soprattutto come decido a prtire da quale locazione andrà a finire in memoria?
Grazie e speriamo che nessuno si spazientisca per il livello basso delle domande....
-
1° dove trovo la guida di Marcello?
http://ready64.org/smf/index.php?topic=1132.0 (http://ready64.org/smf/index.php?topic=1132.0)
Leggi con attenzione questo thread poi, erano stati segnalati degli errori nel disassemblato che hai ripostato. Lo correggo visto che è talmente semplice che ci riesco anch'io: :fagiano:
LDA #$0F ; Carica il numero decimale 15 nell'accumulatore...
STA $C000 ; ... e piazzalo nella locazione decimale 49152
RTS ; Esci dalla subroutine
RTI non si usa a meno che non stia programmando appunto routine di interrupt, normalmente si usa RTS. In secondo luogo per caricare il numero decimale 15 l'istruzione è LDA #$0F: senza diesis carica il contenuto della locazione 15 in pagina zero.
Per quanto riguarda la digitazione nel monitor di CSS, purtroppo non ce l'ho presente e non so dirti se tale monitor supporti l'inserimento di assembly con il comando A. Quello che ti posso dire è che sicuramente non devi digitare direttamente LDA #$0F eccetera nella riga di comando del monitor.
Alcuni monitor (non so se anche quello di CSS) ti permettono di inserire del codice assembly così:
1) digiti A xxxx istruzione assembly
dove xxxx è un indirizzo esadecimale, ad esempio
A 1000 LDA #$0F
inserisce l'istruzione all'indirizzo 4096 ($1000). A questo punto compare da solo l'indirizzo dell'istruzione successiva, 1002 (perché la prima istruzione occupa due byte, quindi la seconda sarà due byte più avanti) e tu dietro digiti STA $C000; e così vai avanti finché non hai finito e allora premi Return invece di inserire un'istruzione.
Quando hai finito usi il comando X per uscire dal monitor e a quel punto in questo caso puoi provare la SYS di partenza del semplice programmino (nell'esempio SYS 4096)...
Prova, tanto non danneggi nulla ;)
-
Grandioso! Funziona! si, il monitor del CCS 64 usa A per caricare le istruzioni , esattamente come dicevi... e io ho potuto scrivere le mie PRIME righe di assembler funzionanti, osservate che meraviglia :-)
LDA #$00
STA D020
LDA #$01
STA D020
ho messo tutto a partireda $1000 ho concluso con
JMP $1000
Spettacolo !!!!! Grazie!!
E adesso le domande
1) l'accumulatore che carica i valori con LDA è unico? cioè mi devo dimenticare il concetto delle variabili, caselle potenzialmente infinite dove stoccare i miei dati numerici e alfanumerici a piacimento? se ho bisogno di mettere da parte un valore che faccio? lo scarico (STA) in una locazione di memoria e poi melo vado a riprendere quando mi serve?
2) come salvo il mio listato? e il programma assemblato? cioè io lo digito nel monitor, poi esco digitando X, e lancio il mio programma, ma se prima di lanciarlo voglio salvarlo su floppy, per poi caricarlo con il classico load "xyz",8,1 come faccio?
e ora mi metto a studiare seriamente ! ciao:-)
-
2) come salvo il mio listato? e il programma assemblato? cioè io lo digito nel monitor, poi esco digitando X, e lancio il mio programma, ma se prima di lanciarlo voglio salvarlo su floppy, per poi caricarlo con il classico load "xyz",8,1 come faccio?
Per questa sono sicuro: hai due modi, principalmente.
Il primo, e più comodo: lo salvi da monitor con (esempio)
S "nome" 08 C000 C031
che salva su floppy (08) la memoria da C000 a C030. Per la cassetta usa 01 invece di 08. [edit: devi aumentare di 1 la locazione, come ha corretto eregil]
Il secondo metodo è salvare da BASIC: ponendo sempre il caso dell'area tra C000 e C030 (decimale 49152-49200) devi settare i puntatori di inizio e fine BASIC (43-44 e 45-46) in questo modo:
A=INT(49152/256):B=(49152-(256*A)):C=INT(49200/256):D=(49152-(256*C))
(READY.)
POKE 43,B:POKE44,A:POKE45,D+1:POKE46,C
[edit: a D va aggiunto 1 per lo stesso motivo di prima, vedi msg sotto di eregil]
(READY.)
[edit: se dovesse spararti un illegal quantity error scrivigli D=0:C=C+1 e ripetigli l'istruzione di sopra]
SAVE "nome",8
oppure
SAVE "nome"
per la cassetta.
Il caricamento dovrà avvenire, naturalmente, con
LOAD "nome",8,1
oppure
LOAD "nome",1,1
rispettivamente per floppy e cassetta.
Come hai già detto ma che è bene ribadire, omettendo il ",1" ci troveremmo un caricamento a partire da 2049 (hex $0801), che nel caso in cui il programma L/M abbia dei "salti" risulterebbe ben poco funzionante. Col ",1" finale diciamo al sistema operativo di caricare il programma dalla locazione in cui l'abbiamo salvato.
Tecnicamente i puntatori sono:
43 --> byte basso dell'inizio dell'area usata dal BASIC.
44 --> byte alto dell'inizio dell'area usata dal BASIC.
ossia la locazione data da (PEEK(44)*256)+PEEK(43)
45 --> byte basso della fine del BASIC e solitamente inizio delle variabili
46 --> byte alto della fine del BASIC e solitamente inizio delle variabili
ossia la locazione data da (PEEK(46)*256)+PEEK(45)
C'è in realtà un metodo migliore che sarebbe quello di iniziare il programma in L/M in una zona vicina all'inizio del BASIC (tipo da 2061 o giù di lì), fare un programma BASIC che abbia una SYS come avviene per il 99% dei giochi.
L'alternativa al rilocare la routine c'è ed è usare un caricamento in due parti. Oppure salvare tutta l'area di memoria da 2049 fino alla fine della routine (ma sarebbe un enorme spreco di spazio).
Ricorda di pokare tre zeri dopo la fine del BASIC "vero" (ossia il programma dopo-run con le eventuali variabili usate) prima di cominciare la routine in L/M.
Esiste in verità un ultimo metodo che consiste nell'usare una cartuccia, ma non differisce molto come concetto dal salvataggio del monitor, inoltre è molto più "sporco" come metodo ;)
-
Attenzione che l'indirizzo finale deve sempre essere aumentato di 1 quando salvi! Cioè per esempio se vuoi salvare da 49152 ($C000) a 49576 ($C1A8) come indirizzo finale devi dare 49577 ($C1A9).
Per quanto riguarda l'altra domanda (sull'accumulatore), hai a disposizione altri due registri, X e Y, con le relative istruzioni LDX, LDY, STX, STY. Però questi registri hanno anche funzioni particolari, ad esempio quelle di essere utilizzati come indici in alcuni modi di indirizzamento. Se ti è capitato per esempio di trovare un'istruzione tipo
STA $0400,X
magari ti sarai chiesto: cosa significa? il significato è: memorizza il contenuto di A nella locazione ottenuta incrementando $0400 del valore di X. Se per esempio X è $1A, il valore di A sarà memorizzato in $041A. Questo tipo di indirizzamento si chiama indicizzato.
In soldoni, ci sono limitazioni ai tipi di indirizzamento che puoi utilizzare con ogni istruzione, e a quali indici puoi utilizzare, motivo per il quale la scelta di utilizzare l'accumulatore oppure X o Y non è mai casuale, bensì dettata dalle istruzioni che hai a disposizione, secondo quello che devi fare.
Ad esempio (sebbene stiamo già facendo dei salti in avanti...) esistono le istruzioni LDA ($xx,X) e LDA ($xx),Y ma non LDA ($xx,Y) e LDA ($xx),X.
Il grosso del lavoro lo farai con l'accumulatore, perché X e Y prima o poi ti serviranno come indici, e in quei casi non vorrai metterci dei valori temporanei, per così dire.
-
Grazie a tutti per le dritte.... adesso ho materiale per sperimentare 2 o 3 giorni!
Appena mi impratichisco un po' con questi nuovi concetti torno a tediarvi con nuove domande....
-
Allora... il monitor del CCS64 sembra non gradire il comando S "XYZ" 8 XXXX XXXX o meglio lo accetta e risponde con "OK" ma il mio file su floppy non celo trovo... potrebbe pero' essere un problema dell'emulatore, per cui appena ho un po' di tempo in piu' lo provo sul C64 vero
Nessun problema invece a settare i p untatori dell'area basic, l'operazione esemplice e rapida. Mi sorge pero' un dubbio; tornando al mio listatino per cambiare ciclicamente i colori del bordo che sto allocando da 49152.. io lo digito nel monitor
A C000 LDA #$00
A C002 STA D020
A C005 LDA #$01
A C007 STA D020
A C00A JMP C000
A C00D X
ora io vedo che l'ultima locazione propostami dal monitor è C00D cioè decimale 49165, quindi so che il mio codice occupa sino a 49164 e mi regolo di conseguenza settando i puntatori dell'area basic di conseguenza; mettiamo pero' che sco dal monitor, lancio il mio gioiello, resetto (non ho previsto una fine programma!), e ora voglio sapere fino a dove arriva il mio codice in memoria... cioè io so che parte da 49152, perchè e di li' che ho iniziato ma esiste un modo per trovare la fine? Dei bytes particolari che identifichino l'END del codice? oppure una volta assemblato termina esattamente con il codice dell'ultima istruzione e ciccia?
-
Allora... il monitor del CCS64 sembra non gradire il comando S "XYZ" 8 XXXX XXXX o meglio lo accetta e risponde con "OK"
:doh:
I programmi di solito sono forniti di manualistica, o quantomeno di file testo da leggere, usiamoli ogni tanto.
Da ccs64.html, capitolo MC Monitor:
S "<filename>" <xxxx> <yyyy>
Saves memory to binary file (not .prg). Example:
S "Picture" 2000 3F40
SP "<filename>" <xxxx> <yyyy>
Saves memory to binary program file (.prg). Example:
SP "Demo.prg" 2000 3F40
ma il mio file su floppy non celo trovo...
CCSmon salva e carica dalla directory in cui risiede ccs.exe
cambiare ciclicamente i colori del bordo
Se l'intenzione era quella, a occhio, il prg non fa quello che ti aspetti :)
oppure una volta assemblato termina esattamente con il codice dell'ultima istruzione e ciccia?
si, non viene generato nulla di piu' dei bytes che scrivi come istruzioni.
-
E' vero, faccio ammenda, il manuale di CCS 64 non l'ho mai consultato :-) , davo per scontato che S lavorasse sull'immagine .D64 attiva in quel momento....
Comunque devo dire che da ieri ho iniziato a leggere la famosa guida di Marcello, e ci sto trovando la risposta alla maggior parte dei dubbi, per cui cerchero' di non postare piu' domande prima di aver finito di leggere il corso, cosi' da non generare traffico inutile sul forum...
Chissa', se avessi avuto un simile materiale quando avevo 12-13 anni, quando nel mio paese non c'era nulla di nulla, una libreria specializzata, un amico che utilizzasse il C64 per qualcosa di diverso dal farci girare le cassette legal-pirata delle edicole, magari sarei andato oltre il basic... vabbè cerchero' di prendermi la rivincita adesso! :-)
Per quanto riguarda il mio piccolo programmino mi sembra che funzioni a dovere...
LDA #$00 ; carico 0 sull'accumulatore
STA D020 ; lo scarico su D020 (53280)
LDA #$01 ; ora carico 1
STA D020 ; ancora su D020
JMP C000 ; torno a C000 e riparto
a parte l'inutilità completa e l'impossibilità di uscirne funziona, lo giuro!
-
ehmmmmm.... scusate...... qualcuno mi dice da dove scarico ASM? io non riesco a trovarlo.....
:huh:
-
Google non trova niente? :D
Su questo forum sono stati segnalati piu' e piu' volte mi pare, basta rileggersi i vecchi post (e dato che sei un neofita del linguaggio dovresti aver gia' letto per lo meno per imparare qualcosa)
I piu' usati sono C64ASM di Balinth Toth e DASM di Mattew Dillon, quest'ultimo e' comprensivo di sorgenti e quindi, nonostante sia abbandonato da molti anni dall'autore, ne sono nate diverse versioni.
Se vai sul mio sito trovi la mia versione, ho aggiornato anche i docs con le mie modifiche.
-
Si torna all'assembler del 6510? Mitico! :metallica:
Io al tempo avevo avuto la fortuna di recuperare un paio di libri sull'argomento, che soddisfarono abbastanza la mia curiosita'... anche se oramai sono arrugginito con la memoria, un mio consiglio a chi vuole riesplorare oggi questo mondo...
Nonostante sembri il contrario, l'Assembler e' semplice da imparare cosi' com'e', in quanto le funzioni sono elementari. PERO' bisogna conoscere ANCHE come funziona l'hardware e software della macchina: ossia sapere dove stanno i vari puntatori, dove inizia e finisce la RAM, dove sta' la ROM, gli indirizzi delle locazioni del SID, VIC... avere una "mappatura" e una descrizione accurata del funzionamento interno della macchina e' essenziale per lavorare in L/M. Quando saprete cosa combina un certo byte in una certa locazione allora vi risultera' tutto MOLTO piu' chiaro. :)
Per le guide e corsi in italiano hanno gia' risposto, tuttavia inviterei a dare un'occhiata anche a guide in inglese: a quel tempo ho trovato che i migliori e piu' precisi libri sull'argomento fossero quelli Inglesi (Americani/Inglesi/Australiani). La mia "bibbia" sull'Assembly e' un libro pubblicato in Australia, accurato quanto compatto, a cui taglierei ancora le mani tutt'oggi a chi oserebbe toccarlo :hail:
Dite che l'assembly del Commodore e' difficile? Eppure e' una CPU con ancora poche e basilari istruzioni, confrontato con lo Z80 montato sulle macchine concorrenti (lo ZX-Spectrum e Amstrad CPC), quello di istruzioni ne ha almeno 600 e si rumoreggia che non si sa' bene neppure l'effetto completo di alcune di esse... :dotto:
-
PERO' bisogna conoscere ANCHE come funziona l'hardware e software della macchina: ossia sapere dove stanno i vari puntatori, dove inizia e finisce la RAM, dove sta' la ROM, gli indirizzi delle locazioni del SID, VIC... avere una "mappatura" e una descrizione accurata del funzionamento interno della macchina e' essenziale per lavorare in L/M.
E' fondamentale per combinare qualcosa di buono con l'assy.
-
PERO' bisogna conoscere ANCHE come funziona l'hardware e software della macchina: ossia sapere dove stanno i vari puntatori, dove inizia e finisce la RAM, dove sta' la ROM, gli indirizzi delle locazioni del SID, VIC... avere una "mappatura" e una descrizione accurata del funzionamento interno della macchina e' essenziale per lavorare in L/M.
E' fondamentale per combinare qualcosa di buono con l'assy.
Assolutamente vero. Così come è importantissimo avere il disassemblato completo del sistema operativo (Basic e Kernal) per poterne sfruttare le routines. Lo trovate qui:
http://www.tkk.fi/Misc/cbm/docs/c64-diss.html (http://www.tkk.fi/Misc/cbm/docs/c64-diss.html)
Se interessa, posso mettere a disposizione lo stesso disassemblato convertito in PDF, sono ca. 700 k e gli hyperlink vengono mantenuti.
-
Se interessa, posso mettere a disposizione lo stesso disassemblato convertito in PDF
Perdita di tempo, la versione in txt e' piu' che sufficiente.