Ready64 Forum
Commodore 64 => Programmazione, Grafica e Musica => Topic aperto da: Alberto - 19 Giugno 2004, 11:41:33
-
Ok,propongo anch'io qualcosa. :)
Questo è un programma Basic sullo scrolling verticale tratto dalla guida del Programmatore.
Provate a tradurlo in LM :)
10 poke53265,peek(53265)and247
20 printchr$(147)
30 forx=1to24:printchr$(17);:next
40 poke53265,(peek(53265)and248)+7:print
50 print" hello";
60 forp=6to0step-1
70 poke53265,(peek(53265)and248)+p
80 forx=1to50:next
90 next:goto40
-
Non vale se sbircio nel monitor del Vice, vero? :P
-
Il monitor del VICE non ti è di nessun aiuto,perchè se scrivi un programma in Basic il C64 non te lo converte in linguaggio macchina :D ;)
-
Prima o poi imparerò che esiste una "leggera" differenza tra interpretare e compilare! :D
-
Prima o poi imparerò che esiste una "leggera" differenza tra interpretare e compilare! :D
Anche compilando il basic del c64, non otterresti un granche' ;)
inizia col tradurre le poke con lda/sta
-
Prima o poi imparerò che esiste una "leggera" differenza tra interpretare e compilare! :D
Anche compilando il basic del c64, non otterresti un granche' ;)
inizia col tradurre le poke con lda/sta
Ci provo... Casomai busso da voi! :P
-
Non ce' nessuno che vuole farsi avanti?
POKE 53265,0 diventa
lda #$00
sta $d011
per fare un addizione in A
clc
adc #numero (A ora vale A+numero)
La routine per stampare un carattere e'
lda #carattere
jsr $ffd2
dai! o devo pensare che siete una manica di codardi? (vediamo se toccandogli l'amor proprio qualcuno si sveglia :D)
-
Diamogli una spinta ulteriore :)
Prima parte della soluzione
LDA $D011
AND #$F7
STA $D011 ; poke 53265,peek(53265)and247
LDA #$93
JSR $FFD2 ; print chr$(147)
LDX #$00
LDA #$11
LOOP JSR $FFD2
INX
CPX #$18
BNE LOOP ; for x=1 to 24:print chr$(17);:next
Et maintenant,à vous! :D
-
Anticipo, per chi ha difficoltà, che ho scritto un articolo di 14 pagine sulle prime nozioni del linguaggio macchina. Ancora devo parlarne con Rob e dobbiamo decidere l'eventuale collocazione... cmq spero che questo possa essere di aiuto per iniziare.
Gli argomenti trattati sono: basi numeriche, logica, archittettura di un computer, architettura del 650x e prime istruzioni, con un programma di esempio.
Sto anche lavorando al capitolo 5 della guida di riferimento, dedicato al l.m... ho fatto 44 pagine, mi mancano le routine del KERNAL e anche questo capitolo sarà disponibile - e mi auguro che tutto questo materiale sia di aiuto per chi è all'inizio.
Ciao
(dal che si deduce che sono tornato attivo nel sito...) ;) :c64:
-
Anticipo, per chi ha difficoltà
Il problema e' che non ci sta provando nessuno. La difficolta' e' nostra nel trovare degli alunni volenterosi :mellow:
(dal che si deduce che sono tornato attivo nel sito...)
Buon lavoro dunque ;)
-
Ragazzi, io credo di incarnare il livello medio dei visitatori del forum, ovvero.. ci capisco ben poco, anzi niente.
Chi è interessato alla programmazione, certamente si è già costruito una minima base di conoscenza grazie ai propri mezzi, ed esercizi come quello proposto da Alberto o gli altri di Marcello risultano troppo facili.
Chi invece è un potenziale studente, ma non ha ancora sentito la molla scattare dentro di sè, troverà gli esempi un pò troppo avanzati per cominciare.
Ad ogni modo, io mi sono trovato di fronte ad uno scoglio invalicabile, ci ho voluto provare lo stesso, e sono riuscito ad arrivare qui:
LDA $D011
AND #$F7
STA $D011
Cioè: 10 poke53265,peek(53265)and247
Con mooooolta fatica, e senza la possibilità di verificare che quanto scritto.
O meglio, la possibilità di verificare l'ho avuta quando, nello stesso momento ho scoperto che Alberto aveva postato la soluzione.
Ma purtroppo secondo me postare la soluzione nuda e cruda non ha molto significato se non la si spiega (parlo sempre da ignorante in materia, vi ricordo) per filo e per segno.
Secondo me sarebbe più opportuno verificare che [Primo] qualcuno degli utenti del forum sia interessato ( e qui do ragione ragione a Ian, credo che purtroppo non ci siano), e poi [Secondo]in base alle conoscenze e preparazione di tali utenti, impostare gli esempi e lezioncine.
Se dunque vi interessa il parere dell'utente medio, io vedrei meglio una serie di "pilloline" di Assembly, piuttosto che esempi così articolati. Sto parlando di argomenti veramente terra terra.
Ad esempio la prima pillolina potrebbe essere la spiegazione di LDA e STA, giusto per iniziare i principianti ai più elementari concetti del linguaggio assembly, che impone un modo di pensare diverso da quello dal più comunemente utilizzato basic.
Questo lo dico come potenziale studente (chissà se davvero avrei il tempo per andare a fondo).
Come webmaster del sito non posso che ammirarvi per il vostro entusiasmo e la vostra voglia di mantenere viva questa sezione che, proprio grazie a voi, sta avendo comunque un successo e una vitalità che non mi sarei aspettato quando ho creato questa sezione del forum.
Fatemi sapere i vostri commenti, ragazzacci. :stordita:
-
Secondo me sarebbe più opportuno verificare che [Primo] qualcuno degli utenti del forum sia interessato ( e qui do ragione ragione a Ian, credo che purtroppo non ci siano)
E questo il punto. Non c'e' nemmeno stata una domanda. non uno che abbia proposto uno straccio di riga di codice chiedendo se era giusto e poteva continuare o come continuare perche' si e' impantanato...
Quindi se non riceviamo almeno un "e' troppo difficile, spiega come!" non vedo nemmeno perche' continuare. Altro che "facciamo un gioco assieme"!
Cazzarola, ai miei tempi (LOL sembro un vecchio) non c'era nessuno a cui chiedere e si imparava cosi':
10 disassemblare
20 provare
30 goto 10
ora che si ha la possibilita' di interagire in tempo reale con chi ne sa qualcosa di piu', e soprattutto i dox in rete a gratis, dovrebbe essere tutto piu' facile. Ma forse e' piu' facile premere shift/runstop che scrivere
*=$0801
.word EndOfLine
.word 7102
.byte $9e
.asc "2061"
.byte 0
EndOfLine
.byte 0
.byte 0
;10 poke53265,peek(53265)and247
lda $d011
and #$f7
sta $d011
;20 printchr$(147)
lda #$93
jsr $ffd2; CHROUT, stampa un carattere
;30 forx=1to24:printchr$(17);:next
; da 0 a 23 anziche' da 1 a 24
ldx #$00
lda #$11
loop1
jsr $ffd2
inx
cpx #$18
bne loop1
;40 poke53265,(peek(53265)and248)+7:print
linea40
lda $d011
and #$f8
clc
adc #$07
sta $d011
;print da sola significa andare a capo: stampare un chr(13)
lda #$0d
jsr $ffd2
;50 print" hello";
lda #<stringa
ldy #>stringa
jsr $ab1e ; STROUT, stampa una stringa puntata da YA
;60 forp=6to0step-1
lda #$06
sta counter
innerloop
;70 poke53265,(peek(53265)and248)+p
lda $d011
and #$f8
clc
adc counter
sta $d011
;80 forx=1to50:next
;un ciclo di attesa sufficente
ldx #$08
d1 lda $d012
bne d1
dex
bne d1
;90 next:goto40
dec counter
lda counter
cmp #$ff ; negativo?
bne innerloop; no, fai la next
jmp linea40 ; si, ripeti il tutto
counter
.byte 0
stringa
.asc " HELLO"
.byte 0
; le stringhe sono terminate da un chr(0)
e perdere tutto sto tempo per un programma che non serve a niente...
Rant mode off.
-
Un piccolo consiglio: io ho imparato i primi rudimenti di Assembler del C64 sugli ultimi 3 numeri di Videobasic della Jackson. Lì venivano spiegati alcuni concetti fondamentali: i registri, LDA, STA, salti condizionati e incondizionati... Può servire come base. (Questo nopn vuol dire che sono un esperto: so leggere un po' il codice Assembler, non sono un programmatore)
Su Edicola C64 ci sono le cassette Videobasic, ma non le scansioni delle riviste. Forse è il caso di rispolverare lo scanner...
-
Fabrizio, se vuoi contribuire, sei più che benvenuto: http://ready64.altervista.org/italiano/oth...basic/index.php (http://ready64.altervista.org/italiano/other/videobasic/index.php)
Io ho i primi 6 numeri, per ora ho iniziato scansionando le prime 10 pagine del primo numero, poi ho preferito concentrarmi sulla scansione di CCC, che trovi sempre nel sito.
-
Per tradurre un programma simile in LM basta la Guida del programmatore,o anche l'ottimo libro di Jim Butterfield sull'assembly (ehp...sempre inglese permettendo,ma ad ogni modo garantisco che i concetti esposti,per chiunque abbia un minimo di interesse,sono molto semplici da capire).
Cmq,questi sono proprio I RUDIMENTI DEL LM (ecco perchè ho deciso di postare un programma Basic da tradurre,e non subito un bel listatone macchina che facesse uso dei registri del CIA1).
Comunque,commento le poche righe di soluzione scritte
LDA $D011; carica il reg.53265 in accumulatore
AND #$F7 ; mette l'accum.in AND con 247
STA $D011; mette il risultato in 53265
LDA #$93 ; carica l'accum.con il valore ASCII di CHR$(147)
JSR $FFD2 ; stampa il carattere
LDX #$00 ; inizializza contatore
LDA #$11 ; codice ASCII carattere da stampare
LOOP JSR $FFD2; stampa CHR$(17)
INX ; incrementa contatore
CPX #$18 ; contatore = 24?
BNE LOOP ; no,ripeti (ciclo eseguito 23 volte)
-
Ho riletto le regole del forum ed ho tolto l'articolo... non si può infatti postare un testo molto lungo (scusa Roberto, non l'ho fatto apposta... :overkiller: )
Ovviamente a chi interessa potrò rendere disponibile, attraverso il sito o in altro modo, tale articolo (ricordo, tratta basi numeriche, logica, struttura di un computer commodore e del 6502/10, primissime istruzioni).
-
Secondo me sarebbe più opportuno verificare che [Primo] qualcuno degli utenti del forum sia interessato ( e qui do ragione ragione a Ian, credo che purtroppo non ci siano)
E questo il punto. Non c'e' nemmeno stata una domanda. non uno che abbia proposto uno straccio di riga di codice chiedendo se era giusto e poteva continuare o come continuare perche' si e' impantanato...
Ian, ti propongo uno scambio, tu vieni a fare il webmaster sfigato e io vado a fare il programmatore di successo, poi vediamo chi esaurisce prima i nervi :)
-
ne sarei felice, ma non ho una posizione di "prorammatore di successo" da offrire in cambio ;)
-
ma non ho una posizione di "prorammatore di successo" da offrire in cambio
da quello che ho visto via via sul forum, sei troppo modesto... sei un grande! ciao ;)
-
Ok, per quanto riguarda il programma convertito, la cosa dell'effetto rimbalzante mi ha incuriosito, e ho notato che succede perche' impiega troppo tempo a muovere lo schermo in alto di un carattere. Ho tentato prima scrivendo la routine che trasferisce byte per byte con indicizzazione, ma anche cosi' ci sono alcuni movimenti brutali in cima allo schermo. Risolto "srotolando" completamente la routine, con grande perdita di memoria (si passa da 300bytes a quasi 6000!)
Ho usato DASM che permette l'uso di macro
;scroll verticale senza IRQ
; iAN CooG/HokutoForce
org $0801
offset = $fe
inout = $fd
counter = $fc
.word EndOfLine
.word 7102
.byte $9e
.byte "2061"
.byte 0
EndOfLine
.byte 0
.byte 0
;---------------------------------------------
lda $d011
and #$f7
sta $d011
lda #1
jsr $e536
lda #0
sta offset
sta inout
;---------------------------------------------
linea40
lda #$07
sta counter
jsr scroll
jsr hardscroll
jsr printstring; stampa la stringa spostata
jsr calcoffset ; per rendere piu' evidente
; l'effetto "rimbalzante"
dec counter
;---------------------------------------------
innerloop
lda $dc01 ; fire joy2
and $dc00 ; fire joy1/spazio
and #$10
beq getouttahere
jsr scroll
ldx #$0a
d1 lda $d012
bne d1
dex
bne d1
dec counter
lda counter
cmp #$ff ; negativo?
bne innerloop; no, fai la next
jmp linea40 ; si, ripeti il tutto
;---------------------------------------------
getouttahere
lda #$1b
sta $d011
rts
;---------------------------------------------
scroll
lda $d012
cmp #$fe
bne scroll ; ripeti finche' non leggi 0
lda $d011
and #$f8
ora counter
sta $d011
;sta $d020
rts
;---------------------------------------------
calcoffset
lda inout ; 0 all'indietro
beq jout ; 1 in avanti
dec offset
lda offset
;cmp #00
beq swap
rts
;---------------------------------------------
jout
inc offset
lda offset
cmp #40-(strend-stringa)
beq swap
rts
;---------------------------------------------
swap
lda inout
eor #01
sta inout
rts
;---------------------------------------------
stringa
; ecco perche' nonostante sia un ottimo x-asm, odio dasm :-/
.byte " ", "h"-$60,"e"-$60,"l"-$60,"l"-$60,"o"-$60," "
strend
;---------------------------------------------
printstring
lda offset
tax
ldy #0
str
lda stringa,y
sta $0400+24*40,x
inx
iny
cpy #(strend-stringa)
bne str
rts
;---------------------------------------------
hardscroll
;VERSIONE 1 : troppo lenta via kernal
;lda #$0d
;jmp $ffd2
;VERSIONE 2 : troppo lenta anche cosi'!!
; ldy #$27
; trrr
; R set 0
; repeat 24
; RR set R+1
; lda $0400+RR *40,y
; sta $0400+R *40,y
; R set R+1
; repend
; dey
; bmi outh
; jmp trrr
; outh
; rts
;VERSIONE 3 : completamente unrolled
R set 0
repeat 24
RR set R+1
C set 0
repeat 40
lda $0400+RR *40+C
sta $0400+R *40+C
C set C+1
repend
R set R+1
repend
rts
compilare con:
dasm b2l_2.asm -v2 -ob2l_2.prg -lb2l_2.lst
il file .lst serve per vedere il codice risultante, da tenere sempre d'occhio per eventuali errori.
NP: Anthrax - Persistence of Time
-
Ho riletto le regole del forum ed ho tolto l'articolo... non si può infatti postare un testo molto lungo
Obiezione: dato che il forum "programmazione" latita di cose interessanti, e il tuo articolo lo e' io suggerirei di dare carta bianca a chi posta sorgenti e tutorials. Credo che Rob non abbia problemi a lasciare carta bianca a me, MarC=ello, Alberto, Ice00 e a chiunque altro abbia qualcosa da proporre in questo forum, perche' stiamo solo cercando di acculturarci assieme. Fine leccata :P
-
A tal proposito io avrei migliorato il programma qui sopra, portandolo a meno di 256 bytes. Pero' attendo il nulla osta per postarlo.
-
Non ho niente in contrario alla pubblicazione degli articoli nel forum (Marcello ha rimosso l'articolo di suo, io non ho messo parola), anche se sinceramente preferirei vedere vedere gli articoli nella loro sede naturale, e soprattutto ritengo inutile avere contenuti doppi.
Questo è il mio parere, poi se gli autori degli articoli decidono comunque di postare qui i loro articoli mi adeguerò.
D'altra parte lo scambio di opinioni e pareri è un fondamentale e su questo siamo tutti d'accordo, quindi se vi sembra una soluzione soddisfacente, io propongo di pubblicare l'articolo normalmente come si è sempre fatto, e poi aprire un topic ufficiale di discussione dedicato. Attendo le vostre opinioni.
A tal proposito io avrei migliorato il programma qui sopra, portandolo a meno di 256 bytes. Pero' attendo il nulla osta per postarlo.
Portami l'autorizzazione in carta bollata del comune e il timbro dell'ufficio d'igiene. :mattsid:
-
Portami l'autorizzazione in carta bollata del comune e il timbro dell'ufficio d'igiene. :mattsid:
Ok, di portartela di persona non se ne parla ma l'ho appena spedita e la riceverai a giorni. Nell'attesa studiati questo
;scroll verticale senza IRQ v4
; + codice hardscroll autogenerante
; + gestione scroll mem.colore
; + prende la stringa direttamente in ROM :)
; + versione di soli 251 bytes !! (253-loadaddress)
; iAN CooG/HokutoForce
org $0801
offset = $fe
inout = $fd
counter = $fc
table1 = $9d
table2 = $9e
tabl1h = $9b
tabl2h = $9c
currp = $fb
flipflop = $fe
endloc = $07e8
stringa = $e47d
strend = $e489;e48b
.word EndOfLine
.word 7102
.byte $9e
.byte "2059"
.byte 0
EndOfLine
;.byte 0; lda #00 e' abbastanza (l'importante e' lo 00 per fermare il basic)
;.byte 0
;---------------------------------------------
lda #0
;asl $d021
sta currp
sta table2
sta flipflop
lda #$04
sta tabl1h
sta tabl2h
lda #$28
sta table1
ldy #<hardscroll
ldx #>hardscroll
stx currp+1
jsr gencode
;lda #0; gencode termina con x=0
stx offset
stx inout
;lda $d011
;and #$f7
lda #$17
sta $d011
jsr $e544; non serve + riempire di bianco
;---------------------------------------------
linea40
lda #$07
sta counter
jsr scroll
jsr hardscroll
;jsr printstring
lda offset
tax
ldy #0
str
lda stringa,y
cmp #$40
bcc okthis
and #$1f
okthis
sta $0400+24*40,x
;lda offset; coloriamo ogni riga con il valore di offset
; o meglio, ogni carattere con se stesso
sta $d800+24*40,x
inx
iny
cpy #(strend-stringa)
bne str
jsr calcoffset
dec counter
;---------------------------------------------
innerloop
lda $dc01
;brutalexit
and $dc00
and #$10
beq getouttahere
;beq brutalexit+1;usa BRK per uscire+getouttahere = -4 bytes
jsr scroll
ldx #$0a
d1 lda $d012
bne d1
dex
bne d1
dec counter
lda counter
bpl innerloop
jmp linea40
;---------------------------------------------
getouttahere
lda #$1b
sta counter
;---------------------------------------------
scroll
lda $d012
cmp #$fe
bne scroll
;lda $d011
;and #$f8
lda #$10
ora counter
sta $d011
rts
;---------------------------------------------
calcoffset
lda inout
and #01
beq jout
dec offset
beq swap
rts
;---------------------------------------------
jout
inc offset
lda offset
cmp #40-(strend-stringa-1)
bne swapext
;---------------------------------------------
swap
inc inout
swapext
rts
;---------------------------------------------
gencode
mainloop
jsr sub2;$0400 1a volta
jsr sub2;$d800 2a volta
inc table1
bne i1
inc tabl1h
i1
inc table2
bne i2
inc tabl2h
i2
lda tabl1h
cmp #>endloc
bne mainloop
lda table1
cmp #<endloc
bne mainloop
lda #$60; metti RTS con la prossima sub1
;---------------------------------------------
sub1
sta (currp),y
iny
bne lx
inc currp+1
lx
rts
;---------------------------------------------
sub2
inc flipflop
lda flipflop
and #$01
tax
lda patval,x
sta patch1
;lda $0428
lda #$AD
jsr sub1
lda table1
jsr sub1
lda tabl1h
jsr sub3
;sta $0400
lda #$8D
jsr sub1
lda table2
jsr sub1
lda tabl2h
;---------------------------------------------
sub3
patch1 byte $2c
adc #$d4
jmp sub1
;---------------------------------------------
patval byte $18,$2c; CLC / BIT
;---------------------------------------------
hardscroll
; generare il codice da qua
la routine di gencode e' ancora piu' incasinata ma fa bene il suo lavoro :)
-
Obiezione: dato che il forum "programmazione" latita di cose interessanti, e il tuo articolo lo e' io suggerirei di dare carta bianca a chi posta sorgenti e tutorials. Credo che Rob non abbia problemi a lasciare carta bianca a me, MarC=ello, Alberto, Ice00 e a chiunque altro abbia qualcosa da proporre in questo forum, perche' stiamo solo cercando di acculturarci assieme. Fine leccata
Mi ero confuso con le regole del forum di LEmon64... lì effettivamente è vietato postare lunghi testi. Direi che uno 'yuk!' alla Pippo ci sta bene... :overkiller:
Comunque stiamo cercando io e Rob di pubblicarlo nella sezione articoli, devo sistemarlo un po'... sai, devo togliere le smiles... devo cambiare l'esordio...
Ciao!
Dimenticavo: grazie per l'interessante...
-
Ciao!
L'articolo sull'assembler è stato pubblicato nella sezione "GUIDA".