Ich hänge euch mal den BASIC Code von Touchterm 3.5 dran. Da werden jedenfalls diverse POKE Befehle verwendet zum wählen.
Vielleicht hilft euch das weiter. Das komplette Diskimage gibt es Bitte melde dich an, um diesen Link zu sehen..
Es gibt 297 Antworten in diesem Thema, welches 53.978 mal aufgerufen wurde. Der letzte Beitrag (
Ich hänge euch mal den BASIC Code von Touchterm 3.5 dran. Da werden jedenfalls diverse POKE Befehle verwendet zum wählen.
Vielleicht hilft euch das weiter. Das komplette Diskimage gibt es Bitte melde dich an, um diesen Link zu sehen..
Letztlich ist es ein Bit am Userport, an dem das Relais hängt.
Ich hatte mir daaaamals™ einen War-Dialer selbst geschrieben, der zum einen mehr als 10 Impulse wählen konnte und zum anderen auf Speed getrimmt war. Den haben wir an die Vermittlungsstellen angepasst, so dass er bei flinken Vermittlungsstellen schneller und bei den lahmen gemächlicher gewählt hat. Also z.B. die 0131 schnell gewählt und die Ziffern danach langsamer.
Alles mühevoll von Hand ausgependelt, schade, dass ich da die alten Dokumente nicht mehr habe.
Hier ist mal das disassemblierte Rainbow Transferprotokoll von Deep Pan Software, plus der Kurzdoku die ich dazu gefunden habe.
Alle meine Kommentare darin sind mit Vorsicht zu genießen. Keine Garantie dass das so richtig ist, was ich mir dabei gedacht habe. Besonders ist mir noch nicht so ganz klar wie die Funktionsweise des Protokolls ist und wie ein Datenblock aufgebaut ist. Ich meine hier Handshaking, Blocknummern, Checksum und solche Dinge.
Vielleicht habt ihr ja den einen oder anderen Tip parat, vor allem welche Bedeutung die "Variablen"-Adressen am Anfang des Protokolls haben.
/*
R A I N B O W
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
P R O T O C O L
RAINBOW protocol is a
state-of-the-art modem
transfer program for
the Commodore 64.
All files can be sent
across the modem, even
relative files.
RAINBOW is intelligent
and easy to add to any
of your programs.
RAINBOW RESIDES: $c000 - $c941
49152 - 51521
SETTING MEMORY LOCATIONS:
DISPLAY.SWITCH..49197 - $c02d
DEVICE ..49198 - $c02e
BLOCK.SIZE ..49199 - $c02f
DRIVE ..49200 - $c030
COMMUNICATION ..49196 - $c02c
OPTIONAL QUERY LOCATIONS:
FILE TYPE ..49193 - $c029
LENGTH ..49194 - 49195 - $c02a - $c02b
ACTIVATING LOCATIONS:
TRANSMIT ..49152 - $c000
RECEIVE ..49155 - $c003
DISPLAY SWITCH: 49197
Poking a 1 in this location will turn
on the screen display. This mode is
used in terminal programs where the
progress of the transfer needs to be
monitored. If set to 0 only .disk
errors will be displayed. This mode
is used usually in a BBS program.
DEVICE SELECT: 49198
The number of the disk drive device
must be poked into this location. The
number must be between 8 and 11 and in
decimal (not ASCII).
BLOCK.SIZE: 49199
The number of bytes to send per each
iteration of the transfer is poked into
this location. This is only necessary
when transmitting. Receiving adjusts
automatically. Block size should be
between 30 and 255.
DRIVE: 49200
This location is used to select the
drive number on a dual disk drive
system. It should be poked with an
ASCII 0 or an ASCII 1, dec 48 or 49.
COMMUNICATION: 49196
RAINBOW is intelligent enough to report
several different errors after a
transfer. The number returned in this
location has the following meanings:
0)..Means no error, transfer complete.
1)..No response from other computer.
2)..There was a local disk error.
3)..If transmiting, this error
indicates a FILE NOT FOUND error.
If receiving, indicates a DISK FULL
error.
4)..Other computer sent a CANCEL
request.
5)..Multiple attempts to send a block
failed; transmission problems.
6)..Operator manualy canceled. This is
done by pressing the Commodore
logo key in the lower left hand
corner of the keyboard.
ACTIVATION: 49152 and 49155
RAINBOW is very automatic. After
setting block size, drive and device
put the file name to transmit or
receive in the BASIC variable NM$.
To transmit, SYS 49152. To receive
SYS 49155. RAINBOW will do all file
handling. You do not need to specify
file type, length or even open the
file first, like some protocols.
NOTE: RS-232 channel must be open
before activating RAINBOW.
e.x.: open 5,2,0,cH(6).
REMEMBER: Block size need only be set
when transmitting. Receiver will auto-
matically adjust to the proper block
size.
SPECIAL INTERNAL.ROUTINE:
A DIRECTORY look up routine can be
called from BASIC:
1] Put file name in NM$
2] SYS 49158 - $c006
3] Filetype returned in 49193 in ASCII - $c029
4] Length returned in 49194 -49195 $c02a lo-byte
$c02b hi-byte
5] Error returned in 49196 - $c02c:
1) OKAY
2) Disk error
3) File not found.
Speed up facts:
RAINBOW uses two different speed up
techniques.:
1] All rs-232 hold-off delays are set
set to a minimum. Both transmiting
and receiving drives will run at
the same time.
2] A block is divided into three parts
If one part is wrong, only the
necessary portion is re-sent.
RAINBOW PROTOCOL was written by:
David Whatley & Mike Dabbs, founders:
DEEP PAN software co.
If you find RAINBOW PROTOCOL useful
and wish to send a donation of $5
The address is:
DEEP PAN SOFTWARE
c/o David Whatley
#3 Fairway ct.
Florissant MO
. 63033
LICENSE TO SOFTWARE AUTHORS:
RAINBOW PROTOCOL is public domain.
Any person wishing to use RAINBOW
PROTOCOL in their own program or
programs, for sale or not, is granted
permission so long as credit is clearly
given to the authors of RAINBOW
PROTOCOL in the appropriate sections of
code.
DEEP PAN SOFTWARE is to be informed
prior to releasing a software package
containing RAINBOW PROTOCOL code.
No royalties or charge of any kind will
be incurred.
RAINBOW PROTOCOL and it's machine code
are copyrighted by Deep Pan Software
company, all rights are reserved.
*/
.cpu _6502
* = $c000 "RAINBOW"
//switched send and receive to match C*BASE Protocols Jumptable
jmp _c2db // recv
jmp _c191 // send
//init receive dummy
//init send dummy
//remember to keep _c02e and _c02f intact for C*BASE ACTPROT...
jmp _c938 // DIR lookup *special Routine*
_c009: .text"COPYRIGHT 1985 DEEP PAN SOFTWARE"
/*
c009 43 ???
c00a 4f ???
c00b 50 59 bvc $c066
c00d 52 ???
c00e 49 47 eor #$47
c010 48 pha
c011 54 ???
c012 20 31 39 jsr $3931
c015 38 sec
c016 35 20 and $20,x
c018 44 ???
c019 45
c01a 45
c01b 50 20 bvc $c03d
c01d 50 41 bvc $c060
c01f 4e 20 53 lsr $5320
c022 4f ???
c023 46 54 lsr $54
c025 57 ???
c026 41 52 eor ($52,x)
c028 45
*/
_c029: .byte $00 // Filetype
_c02a: .word $ffff // File length lo / hi byte
_c02c: .byte $00 // communication error code storage
_c02d: .byte $01 // display switch
_c02e: .byte $08 // device#
_c02f: .byte $ff // Blocksize
_c030: .byte $30 // drive# "0"
_c031: .byte $3a // not used ?!
_c032: .byte $01, $c9
_c034: .byte $8c, $d0, $07, $bd, $02, $01, $c9, $a4, $f0, $0f
.byte $ac, $44, $c6, $ae, $43, $c6, $ad, $42, $c6, $48
.byte $ad, $41, $c6
_c04b: .word $ffff // free blocks on disk ?!
_c04d: .byte $00 //
_c04e: .byte $00 // received char from modem
_c04f: .byte $00 //
_c050: .byte $00 //
_c051: .byte $00 //
_c052: .byte $00 //
_c053: .byte $00 //
_c054: .byte $00 //
_c055: .byte $00 //
_c056: .byte $00 //
_c057: .byte $00 //
_c058: .byte $00 // temp Bufferpointer ?
_c059: .byte $00 //
_c05a: .byte $00 //
_c05b: .byte $00 //
_c05c: .byte $00 //
_c05d: .byte $00 // checksum ?!
_c05e: .byte $f1 // retry counter ?!
_c05f: .byte $00 // ??
_c060: .byte $00 //
//buffer
_c061: .byte $00
_c062: .byte $00
_c063: .byte $00
_c064: .byte $00
_c065: .byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00
/*
.C:c061 A4 C5 LDY $C5
.C:c063 F0 14 BEQ $C079
.C:c065 C9 80 CMP #$80
.C:c067 F0 14 BEQ $C07D
.C:c069 EE 3F C6 INC $C63F
.C:c06c E8 INX
.C:c06d BD A3 C5 LDA $C5A3,X
.C:c070 10 FA BPL $C06C
.C:c072 BD A4 C5 LDA $C5A4,X
.C:c075 D0 E3 BNE $C05A
.C:c077 F0 C5 BEQ $C03E
.C:c079 E8 INX
.C:c07a C8 INY
.C:c07b D0 DF BNE $C05C
.C:c07d 84 7A STY $7A
.C:c07f AD 3F C6 LDA $C63F
.C:c082 0A ASL A
.C:c083 AA TAX
.C:c084 BD D4 C5 LDA $C5D4,X
.C:c087 48 PHA
.C:c088 BD D3 C5 LDA $C5D3,X
.C:c08b 48 PHA
.C:c08c 20 3E C0 JSR $C03E
.C:c08f 4C 73 00 JMP $0073
.C:c092 20 6B A9 JSR $A96B
.C:c095 A5 14 LDA $14
.C:c097 85 3B STA $3B
.C:c099 A5 15 LDA $15
.C:c09b 85 3C STA $3C
.C:c09d 4C 29 C3 JMP $C329
.C:c0a0 68 PLA
.C:c0a1 68 PLA
.C:c0a2 20 3E C0 JSR $C03E
.C:c0a5 20 6B A9 JSR $A96B
.C:c0a8 F0 37 BEQ $C0E1
.C:c0aa A5 3B LDA $3B
.C:c0ac 05 3C ORA $3C
.C:c0ae F0 31 BEQ $C0E1
.C:c0b0 A5 14 LDA $14
.C:c0b2 18 CLC
.C:c0b3 65 3B ADC $3B
.C:c0b5 85 63 STA $63
.C:c0b7 A5 15 LDA $15
.C:c0b9 65 3C ADC $3C
.C:c0bb 85 62 STA $62
.C:c0bd A2 90 LDX #$90
.C:c0bf 38 SEC
.C:c0c0 20 49 BC JSR $BC49
.C:c0c3 20 DD BD JSR $BDDD
.C:c0c6 A2 00 LDX #$00
.C:c0c8 A9 20 LDA #$20
.C:c0ca 9D 77 02 STA $0277,X
.C:c0cd E8 INX
.C:c0ce BD 00 01 LDA $0100,X
.C:c0d1 F0 06 BEQ $C0D9
.C:c0d3 9D 77 02 STA $0277,X
.C:c0d6 E8 INX
.C:c0d7 D0 F5 BNE $C0CE
.C:c0d9 A9 20 LDA #$20
.C:c0db 9D 77 02 STA $0277,X
.C:c0de E8 INX
.C:c0df 86 C6 STX $C6
.C:c0e1 20 0B C2 JSR $C20B
.C:c0e4 4C A2 A4 JMP $A4A2
.C:c0e7 F0 42 BEQ $C12B
.C:c0e9 20 6B A9 JSR $A96B
.C:c0ec 20 13 A6 JSR $A613
.C:c0ef 20 FD AE JSR $AEFD
.C:c0f2 20 6B A9 JSR $A96B
.C:c0f5 A5 14 LDA $14
.C:c0f7 85 BB STA $BB
.C:c0f9 A5 15 LDA $15
.C:c0fb 85 BC STA $BC
.C:c0fd 20 FD AE JSR $AEFD
.C:c100 20 6B A9 JSR $A96B
.C:c103 20 CA C2 JSR $C2CA
.C:c106 F0 20 BEQ $C128
.C:c108 20 C0 C2 JSR $C2C0
.C:c10b 18 CLC
.C:c10c A5 BB LDA $BB
.C:c10e 20 BC C2 JSR $C2BC
.C:c111 65 14 ADC $14
.C:c113 85 BB STA $BB
.C:c115 A5 BC LDA $BC
.C:c117 20 BC C2 JSR $C2BC
.C:c11a 65 15 ADC $15
.C:c11c 85 BC STA $BC
.C:c11e 20 CA C2 JSR $C2CA
.C:c121 D0 FB BNE $C11E
.C:c123 20 C0 C2 JSR $C2C0
.C:c126 D0 DB BNE $C103
.C:c128 4C 29 C3 JMP $C329
.C:c12b 20 D7 AA JSR $AAD7
.C:c12e 20 D2 C2 JSR $C2D2
.C:c131 A9 E8 LDA #$E8
.C:c133 85 BB STA $BB
.C:c135 A9 03 LDA #$03
.C:c137 85 BC STA $BC
.C:c139 A9 0A LDA #$0A
.C:c13b 85 14 STA $14
.C:c13d A9 00 LDA #$00
.C:c13f 85 15 STA $15
.C:c141 4C 03 C1 JMP $C103
.C:c144 20 9A C2 JSR $C29A
.C:c147 20 C6 FF JSR $FFC6
.C:c14a A5 90 LDA $90
.C:c14c F0 03 BEQ $C151
.C:c14e 4C 94 C5 JMP $C594
.C:c151 A9 01 LDA #$01
.C:c153 20 B6 C2 JSR $C2B6
.C:c156 20 CF FF JSR $FFCF
.C:c159 C9 0D CMP #$0D
.C:c15b F0 09 BEQ $C166
.C:c15d 20 BC C2 JSR $C2BC
.C:c160 A5
*/
//Floppy Errorchannel Output Buffer
_c161: .byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
.byte $00, $00, $00, $00, $00, $00, $00, $00
_c189: .byte $5f // temp char storage
_c18a: .byte $85
//Filetypes "d", "s", "p", "u", "l"
_c18b: .byte $44, $53, $50, $55, $4c
//----------------------------------------------------------------------------------
//temp stack save
_c190: .byte $00
//send
_c191: tsx // save
stx _c190 // stack
jsr _c6ed //
lda #$3e
ldx #$01
jsr _c5d1
ldy #$00 // init
sty _c05a
sty _c05b
sty _c051
iny
sty _c059
sty _c060
sty _c061
iny
sty _c052
lda #$05
sta _c053
lda _c02a // Filelength lo
sta _c062
lda _c02a+1 // Filelength hi
sta _c063
lda _c029 // Filetype
sta _c064
lda _c050
sta _c065
jsr _c6c5
lda #$dd
sta _c05f
lda _c02d
sta _c18a
lda #$00
sta _c02d
jsr _c684 // checksum
jmp _c23a
_c1ee: lda _c18a
sta _c02d // display switch
lda #$89
jsr _c621 // char to Modem
jsr _c638 // timeout check ?!
beq _c208 // returned good
inc _c05e // timeout,
bne _c1ee // loop
lda #$01 // no response from other computer
jmp _c4da
_c208: lda #$f1
sta _c05e
lda _c05b
jsr _c5e8 //
lda _c053
jsr _c5e8
ldy #$00
_c21b: lda _c061,y //
jsr _c621 // to modem
iny
cpy _c053
bne _c21b
_c227: lda #$91
jsr _c621 // to modem
jsr _c684 // checksum ?
lda _c05d
jsr _c5e8
lda #$f1
sta _c05e
_c23a: jsr _c638 // Jiffy and stuff ?!
beq _c249
inc _c05e
bne _c23a
lda #$01 // no response from other computer
jmp _c4da // store in $c02c ...
_c249: lda _c04e
cmp #$81 // Orange ??
bne _c253
jmp _c27f // ??
_c253: cmp #$85 // F1 ?
bne _c25a
jmp _c227 // ??
_c25a: cmp #$c1 // ??
beq _c275
cmp #$83
beq _c265
jmp _c23a
_c265: inc _c05f
beq _c27a
lda #$5f
ldx _c052
jsr _c5d1 // ??
jmp _c1ee
_c275: lda #$04
jmp _c4ed
_c27a: lda #$05 // failed to send Block after multiple retrys
jmp _c4da
_c27f: lda _c060
ora #$30
ldx _c052
jsr _c5d1 // rvs Textoutput
jsr _c696 //
jsr _c6a6 //
lda _c050
bne _c29a
lda _c051
bne _c2ae
_c29a: inc _c05b
jsr _c541 // ??
jsr _c684 // checksum ?!
lda #$f1 //
sta _c05e
sta _c05f
jmp _c1ee
_c2ae: lda #$f1
sta _c05e
_c2b3: lda #$a1 //
jsr _c621 // to modem
jsr _c638 // timing
beq _c2c7 // good
inc _c05e // bad
_c2c0: bne _c2b3
lda #$05 // failed to send Block after multiple retrys
jmp _c4da
_c2c7: lda _c04e // received char
_c2ca: cmp #$81 // looks like some #$a1 #$81 handshake
bne _c2b3
jsr _c50a // close #2 and #15
lda #$00 // transfer complete
sta _c02c // communication
lda #$3c // "<"
jmp _c4f5 // print if screen is on
//----------------------------------------------------------------------------------
//receive
_c2db: tsx // save stack
stx _c190 // temp old stack
lda #$01
sta _c060
lda #$02
sta _c052
jsr _c89a // get Free Blocks or # of Blocks from File into $c04b - $c04c
jsr _c6c5 // redirect to _c6b6 NMI ENABL
lda #$3e // ">"
ldx #$01 // {wht}
jsr _c5d1 // print stuff reverse
lda _c02d // display switch
sta _c18a // temp store
lda #$00 // turn of
sta _c02d // display
lda #$dd
sta _c05f
jsr _c47c // ???
dec _c061
beq _c313
lda #$01 // no response from sender
jmp _c4da
_c313: sec
lda _c04b
sbc _c062
sta _c04b
lda _c04b+1
sbc _c063
sta _c04b+1
cmp #$03
bcc _c32f
lda #$03 // disk full error
jmp _c4da
_c32f: lda _c04b
bne _c339
lda #$03 // disk full error
jmp _c4da
_c339: jsr _c90d // Filename from nm$
ldy _c04d
lda #$2c // ","
sta _c032,y
sta _c034,y
iny
lda _c064
sta _c032,y
lda _c065
sta _c050
bne _c358
lda #$57
_c358: sta _c034,y
tya
clc
adc #$05
sta _c02a // Filelength
jsr _c517 // init drive
lda #$02
ldx _c02e // device#
ldy #$02
jsr $ffba // SETLFS
lda _c02a // length
ldx #<_c030 // filename at
ldy #>_c030 // $c030
jsr $ffbd // SETNAM
jsr $ffc0 // OPEN 2,de,2
bcc _c383 // error ?
lda #$02 // error code #2 disk error
jmp _c4da
_c383: jsr _c80e // read errorchannel
jsr _c6c5 // enabl
lda #$00 // init
sta _c05c
sta _c05a
lda #$01
sta _c059
lda _c062 // Filelength lo
sta _c02a
lda _c063 // Filelength hi
sta _c02a+1
lda _c064 // Filetype
sta _c029
_c3a8: lda _c18a // temp storage
sta _c02d // display switch
lda _c060
ora #$30
ldx _c052
jsr _c5d1 // rvs Textoutput
jsr _c696 // ??
jsr _c6a6 // ??
_c3bf: lda #$f1
sta _c05e
sta _c05f
_c3c7: jsr _c638 // check User abort / Buffer / timing
beq _c3d6
inc _c05e
bne _c3c7
lda #$05
jmp _c4da // failed to send Block after multiple retrys
_c3d6: lda _c04e // received char
cmp #$c1
bne _c3e2 // no
lda #$04
jmp _c4ed //
_c3e2: cmp #$a1 // looks like some #$a1 #$81 handshake
bne _c3f8 // no
lda #$81 // answer with #$81
jsr _c621 // send to modem
jsr _c50a // close #2 and #15
lda #$00 // transfer complete
sta _c02c // communication
lda #$3c // "<"
jmp _c4f5 // print if screen is on
_c3f8: cmp #$89 //
bne _c3c7 // nope
jsr _c41b // yes, ???
ldy _c05b
cpy _c05c
beq _c3bf
dey
cpy _c05c
beq _c412
lda #$05 // failed to send Block after multiple retrys
jmp _c4da
_c412: inc _c05c
jsr _c593 // ??
jmp _c3a8
_c41b: lda #$81
jsr _c621 // send to modem
jsr _c65b // timing ? Block# ?
beq _c428
jmp _c47c //
_c428: lda _c04e // received char
sta _c05b
jsr _c65b // timing ? Block# ?
beq _c436
jmp _c47c //
_c436: lda _c04e // Char from Modem
sta _c053 // record length ?!
ldy #$00
_c43e: jsr _c638 // check User abort / Buffer / timing
beq _c446
jmp _c47c // User abort
_c446: lda _c04e
sta _c061,y
iny
cpy _c053
bne _c43e
_c452: jsr _c638 // check User abort / Buffer / timing
beq _c45a
jmp _c47c
_c45a: lda _c04e
cmp #$91
beq _c464
jmp _c47c
_c464: jsr _c65b
beq _c46c
jmp _c488
_c46c: jsr _c684
lda _c05d
cmp _c04e
bne _c47c
lda #$81
jmp _c621 // send to modem
_c47c: lda #$83
ldx #$5f
ldy #$89
jsr _c494
jmp _c41b //
_c488: lda #$85
ldx #$00
ldy #$91
jsr _c494 //
jmp _c452
_c494: sta _c054
stx _c055
sty _c056
_c49d: jsr _c638 // check User abort / Buffer / timing
beq _c49d
inc _c05f
bne _c4ac
lda #$05 // failed to send Block after multiple retrys
jmp _c4da
_c4ac: lda #$f1
sta _c05e
_c4b1: lda _c054
jsr _c621 // send to modem
_c4b7: lda _c055
beq _c4c2
ldx _c052
jsr _c5d1 // print
_c4c2: jsr _c638 // check User abort / Buffer / timing
beq _c4d1
inc _c05e
bne _c4b7
lda #$05 // failed to send Block after multiple retrys
jmp _c4da
_c4d1: lda _c04e
cmp _c056 // wait for char #$91
bne _c4b1
rts
_c4da: sta _c02c // communication
lda #$91 // set timeout / waitloop
sta $a2 // 1 Jiffy = 0.1667 seconds
_c4e1: lda $a2 // #$6f Jiffys = 18 seconds
bne _c4e1
lda #$c1 // EOT signal ?
jsr _c621 // send to modem
lda _c02c // communication
_c4ed: sta _c02c
jsr _c50a // close #2 and #15
lda #$d8 // print "Z"
_c4f5: ldx #$01 // {wht} Textcolor
jsr _c5d1 // display Text if Screen is on
lda #$0d // <CR>
jsr _c5d1 // print
jsr _c5d1 // print
_c502: pla
tsx
cpx _c190 // compare with saved stack
bne _c502 // loop if unequal
rts // return
_c50a: jsr $ffcc // clrchn
lda #$02 // close channel #2 and #15
jsr $ffc3 // close
lda #$0f //
jmp $ffc3 // close and return
_c517: lda #$49 // "i"
sta $64
lda _c030 // Drive#
sta $65 // "i0"
lda #$0f
ldx _c02e // device#
ldy #$0f //
jsr $ffba // SETLFS
lda #$02 // 2 chars
ldx #$64 // $0064
ldy #$00
jsr $ffbd // SETNAM
jsr $ffc0 // OPEN 15,de,15,"i0" -> init drive
bcc _c53d // Error ?
lda #$02 // error #2 disk error
jmp _c4da // store on _c02c
_c53d: jsr _c80e // read errorchannel
rts // return
_c541: lda _c050
beq _c56f
jsr _c8e2 // send "p" Command
jsr _c7ec // clear Channel and checkin #15
lda _c161 // Errorchannel Buffer, 1st digit of Floppy Error
cmp #$30 // "0" -> OK ?
beq _c564 // yes
cmp #$35 // "5x" record not present / overflow in record / file too large ?
bne _c561 // no
lda _c161+1 // 2nd digit
cmp #$30 // "0"
bne _c561 // no
jmp _c2ae // to modem, timing etc.
_c561: jmp _c819 // screen display, error etc.
_c564: jsr _c8e2 //send p... to channel #15
inc _c059
bne _c56f
inc _c05a
_c56f: ldx #$02 // channel #2
jsr $ffc6 // CHKIN
ldy #$00
_c576: jsr $ffcf // CHRIN loop
sta _c061,y // store in Buffer
iny
cpy _c02f // Block full ?
beq _c58a // yes
jsr $ffb7 // READST
beq _c576 // continue reading
sta _c051 // store ST
_c58a: sty _c053 // store buffer pointer
jsr _c80e // read errorchannel
jmp _c6c5 // NMI get Byte routine
//REL Files
_c593: lda _c050
beq _c5b0
jsr _c8e2 // send p... to channel #15
jsr _c7ec // clear channel #15 and set as input
lda _c161
cmp #$30 // "0x" OK
beq _c5b0
cmp #$35 // "5x" record not present / overflow in record / file too large
bne _c5ad
cmp #$30 // "0x" OK ?! double or dummy for something?!
beq _c5b0
_c5ad: jmp _c819 // error routine
_c5b0: inc _c059
bne _c5b8
inc _c05a
_c5b8: ldx #$02 // channel #2
jsr $ffc9 // CHKOUT
ldy #$00
_c5bf: lda _c061,y
jsr $ffd2 // write to disk
iny
cpy _c053
bne _c5bf
jsr _c80e // read errorchannel
jmp _c6c5 // NMI get Byte Routine
_c5d1: sta _c057
lda _c02d // display switch
beq _c5e7 // screen off
stx $0286 // screen on, set Textcolor
lda #$12 // {rvon}
jsr $ffd2 // print
lda _c057
jsr $ffd2
_c5e7: rts
_c5e8: sta _c057
jsr _c621 // send to modem
lda _c057
eor #$ff
jmp _c621 // send to modem
_c5f6: jsr _c6c8 // check User abort
sty _c058 // temp Bufferpointer ?
ldy $029c // RS-232: Pointer to Start of Inputbuffer (receive)
cpy $029b // RS-232: Pointer to End of Inputbuffer (receive)
beq _c615 // Buffer empty
lda ($f7),y // Pointer to Inputbuffer RS-232 Ringbuffer
sta _c04e
inc $029c // update pointer to next char
lda #$01
sta _c04f
ldy _c058
rts
_c615: ldy _c058
lda #$00
sta _c04e
sta _c04f
rts
_c621: sta _c189 // store char
jsr $ffcc // CLRCHN
jsr _c6c8 // check User abort
ldx #$05 // channel #5
jsr $ffc9 // chkout to Modem
lda _c189 // load char
jsr $ffd2 // chrout to modem
jmp $ffcc // CLRCHN
_c638: lda #$00 // init JiffyClock
sta $a1 // for timing
sta $a2 //
_c63e: jsr _c6c8 // check User abort
jsr _c5f6 // Buffer
lda _c04f
bne _c658
lda $a1 // timings $a1 changes after 256 Jiffys
cmp #$00
bcc _c63e
lda $a2 // 1 Jiffy = 0.1667 seconds
cmp #$3c // = 10 seconds
bcc _c63e
lda #$01 // timeout ?! bad
rts
_c658: lda #$00 // good
rts
_c65b: jsr _c638 // timing etc.
bne _c67e
lda _c04e // received char
sta _c057
jsr _c638 // timing
bne _c67e
lda _c04e // received char
eor #$ff
cmp _c057 // complement block# ?!
bne _c681
lda _c057
sta _c04e
lda #$00
rts
_c67e: lda #$01
rts
_c681: lda #$02
rts
_c684: ldy #$00
lda #$00
_c688: clc
adc _c061,y
iny
cpy _c053
bne _c688
sta _c05d // additive Checksum ?
rts
_c696: inc _c060
lda _c060
cmp #$0a
bne _c6a5
lda #$00
sta _c060
_c6a5: rts
_c6a6: inc _c052
lda _c052
cmp #$10
bne _c6b5
lda #$02
sta _c052
_c6b5: rts
_c6b6: jsr $ef7e // get Byte during NMI
lda $02a1 // RS232 NMI ENABL
cmp #$80 // %1000 0000
beq _c6b6
cmp #$92 // %1001 0010
beq _c6b6
rts
_c6c5: jmp _c6b6
_c6c8: lda $028d // shift / c= / ctrl pressed ?
/*
$28D 653 Keycodes der Steuertasten (addieren sich):
* Bit 0 - <SHIFT>
* Bit 1 - <COMMODORE>
* Bit 2 - <CTRL>
*/
cmp #$02 // c= key ?
bne _c6d4 // no
lda #$06 // yes, User abort Transfer
jmp _c4da //
_c6d4: rts // return
_c6d5: .byte $02, $22, $42, $62, $82, $a2, $c2, $e2
_c6dd: .byte $ff
_c6de: .byte $00 // temp ST
//not used ?!
//c6df ff ???
.byte $ff
//"u1:2,0,18,01"
_c6e0: .byte $55, $31, $3a, $32, $2c, $30, $2c, $31, $38, $2c, $30, $31, $0d
_c6ed: jsr _c7c6
ldy #$18 // Fill $c01a - $c032
lda #$a0 // with Shift - Space
_c6f4: sta _c032,y //
dey //
bpl _c6f4 //
jsr _c90d // Variable nm$ (filename)
lda #$12 //#18
jsr _c87b // ??
sty _c6e0+7 // Track first digit
sta _c6e0+8 // Track second digit
lda #$01 //#1
jsr _c87b
sty _c6e0+10 // Sector first digit
sta _c6e0+11 // Sector second digit
_c713: jsr _c84d // send U1 command to Drive
lda _c061
jsr _c87b
sty _c6e0+7 // next Track
sta _c6e0+8 //
lda _c062
jsr _c87b
sty _c6e0+10 // next Sector
sta _c6e0+11 //
ldy #$00
_c730: lda _c6d5,y // "index table"
sty _c6dd
tax
lda _c061,x // buffer
beq _c763
and #$3f
sta _c029 // Filetype
cmp #$05 // >=5 ?
bcs _c763
inx
inx
inx
ldy #$00
_c74a: lda _c061,x
cmp _c032,y
bne _c763
inx
iny
cpy #$10
bne _c74a
inx
inx
lda _c061,x
sta _c050
jmp _c77f
_c763: inc _c6dd
ldy _c6dd
cpy #$08
beq _c770
jmp _c730
_c770: lda _c6e0+7 // Track first digit
and #$0f
beq _c77a
jmp _c713
_c77a: lda #$03 // disk full / file not found error
jmp _c4da
_c77f: txa
clc
adc #$07
tax
lda _c061,x
sta _c02a
lda _c062,x
sta _c02a+1
jsr _c50a // close #2 and #15
jsr _c517 // init drive
lda _c029 // Filetype
cmp #$04 // "l" -> REL File
beq _c7a2
lda #$00
sta _c050
_c7a2: ldy _c029 // Filetype index ?! 0 - 4
lda _c18b,y // Filetype
sta _c029 // Filetype
jsr _c90d
lda #$02
ldx _c02e // device#
ldy #$02
jsr $ffba // SETLFS
lda _c04d
ldx #$32
ldy #$c0 // Filename at _c032
jsr $ffbd // SETNAM
jsr $ffc0 // OPEN
rts
_c7c6: jsr _c50a // close channel #2 and #15
jsr _c517 // init drive + ...
lda #$23 // "#"
sta $02
lda #$02
ldx _c02e // device#
ldy #$02 // 2,de,2
jsr $ffba // SETLFS
lda #$01 // 1 char
ldx #$02
ldy #$00 // $0002
jsr $ffbd // SETNAM
jsr $ffc0 // OPEN 2,de,2,"#"
bcs _c819 // error
jsr _c80e //
rts
_c7ec: jsr $ffcc // CLRCHN
ldx #$0f // #15
jsr $ffc6 // CHKIN
bcc _c7f9
jmp _c819
// read errorchannel ?!
_c7f9: ldy #$00
_c7fb: jsr $ffcf // CHRIN
sta _c161,y // ??
iny
jsr $ffb7 // READST
beq _c7fb
dey
sty _c6de // store pointer
jmp $ffcc // CLRCHN
_c80e: jsr _c7ec // checkin #15, read error channel
lda _c161 // error#
and #$0f // <15 ?
bne _c819
rts // OK
_c819: lda #$0d // <CR>
jsr $ffd2 // CHROUT
lda #$20 // SPACE
jsr $ffd2
lda #$5b // "["
jsr $ffd2
ldy #$00
_c82a: lda _c161,y
jsr $ffd2 // CHROUT
iny
cpy _c6de
bne _c82a
lda #$5d // "]"
jsr $ffd2
lda #$20 // SPACE
jsr $ffd2
lda #$0d // <CR>
jsr $ffd2
jsr _c50a // close channel #2 and #15
lda #$02 // error #2 disk error
jmp _c4da // store in $c02c
_c84d: jsr $ffcc // CLRCHN
ldx #$0f // channel #15
jsr $ffc9 // CHKOUT
ldy #$00
_c857: lda _c6e0,y // "u1:2,0,18,01"
jsr $ffd2 // CHROUT
iny
cpy #$0d
bne _c857
jsr _c80e // read errorchannel
ldx #$02 // channel #2
jsr $ffc6 // CHKIN
ldy #$00
_c86c: jsr $ffe4 // GETIN
sta _c061,y // read 256 chars into _c061 - _c160
iny
bne _c86c
jsr _c80e // read errorchannel
jmp $ffcc // CLRCHN
_c87b: ldy #$ff
sec
_c87e: iny
sbc #$0a
bcs _c87e
adc #$0a
tax
tya
ora #$30
tay
txa
ora #$30
rts
//"$0:......"
_c88e: .byte $24, $30, $3a, $45, $37, $21, $34, $4e, $58, $23, $4b, $5c
/*
c88e 24 30 bit $30
c890 3a ???
c891 45 37 eor $37
c893 21 34 and ($34,x)
c895 4e 58 23 lsr $2358
c898 4b ???
c899 5c ???
*/
_c89a: lda #$01
ldx #$08 // fixed to device #8 ?!
ldy #$00
jsr $ffba // SETLFS
lda #$0c // #12 chars
ldx #<_c88e
ldy #>_c88e // $c88e
jsr $ffbd // SETNAM
jsr $ffc0 // OPEN 1,8,0,"$0:..."
bcc _c8b6 // error ?
lda #$02 // error code 2 -> "disk error"
jmp _c4da
_c8b6: ldx #$01 // channel #1
jsr $ffc6 // CHKIN
ldy #$06 // read 6 chars
_c8bd: jsr $ffe4 // GETIN
dey
bne _c8bd
_c8c3: jsr $ffe4 // GETIN
bne _c8c3 // until chr$(0)
jsr $ffe4 // overread 2 chars
jsr $ffe4 //
jsr $ffe4 // read lo
sta _c04b // and hi byte
jsr $ffe4 // of Diskblocks
sta _c04b+1 // from File
jsr $ffcc // CLRCHN
lda #$01 // channel #1
jmp $ffc3 // CLOSE
_c8e2: jsr $ffcc // CLRCHN
ldx #$0f // #15
jsr $ffc9 // CHKOUT
lda #$50 // "p"
jsr $ffd2 //
lda #$02 //
jsr $ffd2 //
lda _c059 //
jsr $ffd2
lda _c05a //
jsr $ffd2
lda #$01 //
jsr $ffd2
lda #$0d // <CR>
jsr $ffd2
jmp $ffcc // CLRCHN
_c90d: lda #$4e // "n"
sta $45 // currently used Variablename in $45 + $46
lda #$4d // "M"
ora #$80 // String Variable
sta $46 //
jsr $b0e7 // search / set variable
ldy #$00
lda ($47),y // pointer on current Variable
sta _c04d // ??
iny //
lda ($47),y //
sta $49 // Variable Pointer for FOR-NEXT-Loop
iny //
lda ($47),y //
sta $4a //
ldy _c04d // ??
dey //
_c92f: lda ($49),y //
sta _c032,y // save pointer in $xxxx to $c023
dey //
_c935: bpl _c92f //
rts // done
_c938: tsx
stx _c190 // save stack
jsr _c6ed //
jmp _c50a // close channels #2 and #15 and return
Alles anzeigen
10 Tage später.
Inzwischen sind ca. 95% vom ML Code kommentiert, mit Labeln versehen und zu optimistischen 80% auch verstanden.
Das Rainbow Protocol funktioniert wohl Empfänger getrieben so wie X-Modem, bedeutet, der Empfänger sagt an wann es los geht mit einem "GO" Signal Byte $83, bzw. das der nächste Datenblock gesendet werden darf.
Danach werden im ersten Übertragungsblock 5 Bytes an den Empfänger gesendet:
<$01> <filelenlo> <filelenhi> <filetyp> <RELfileflag>
- eine 1 als Flag woran der Empfänger erkennt, dass hier der erste Datenblock mit File Informationen kommt
- die Dateigröße in Diskblocks hexadezimal als Lo und Hi Byte, wird vom Protokoll aus dem Directory ausgelesen
- der Filetyp (PRG, USR, SEQ, REL !!)
Danach werden die "normalen" Blöcke in folgendem Format übertragen:
<SOH> <blk#> <255-blk#> <blk-size> <255-blk-size> Data[blk-size] <EOD> <chksum> <255-chksum>
- SOH (Name von mir bei X-Modem entliehen, tatsächlich aber ein $89 Byte)
- Transferblock Nummer und Komplement wie bei X-Modem
- Transferblock Größe in Bytes (30 bis max. 255)
- noch einmal als Komplement
- Dann die eigentlichen Daten
- eine ich nenne sie mal "EOD" Kennung (End of Data) Byte $91
- dann eine Checksumme (additive Checksum) plus Komplement
Ist das sauber beim Empfänger angekommen, gibt es eine positive ACKnowledge ($81) oder eben eine Negative AcKnowledge ($85).
Wird der Transfer von einer Seite unterbrochen wird ein Cancel Signal ($c1) gesendet.
Ist der Transfer beendet, weil keine Daten mehr zur Übertragung übrig sind, wird ein (ich nenne es) EOT "End of Transmission" ($a1) gesendet und vom Empfänger per ACK ($81) bestätigt.
Einiges scheint hier bei den Protokollen X-Modem und Punter abgeschaut worden zu sein. Zum Beispiel die variable Transferblock Größe und der erste Datenblock mit Dateiinfos erinnert sehr an Punter.
Die additive Checksumme dann eher an das alte X-Modem mit 1 Byte Checksum.
Was mich wundert ist, dass das Protokoll Multitransfer tauglich sein soll, aber der Dateiname nicht übergeben wird. Der muss vorher vom Programm / User in der Variable nm$ vorgegeben werden, auf beiden Seiten.
Dafür werden auch REL Files übertragen, was so sonst kein anderes mir bekanntes Transferprotokoll kann.
Es wird da auf jeden Datensatz neu positioniert, die Daten ausgelesen, übertragen und beim Empfänger so wieder in ein REL File geschrieben.
An der Stelle fehlen mir aber noch die letzten paar Prozent Code Kommentare und Verständnis....
Leider konnte ich bisher das Protokoll noch nie live testen, da die 3 Terminal Programme, die das implementiert haben nur alte analog Modems am Userport unterstützen wie z.B. das CBM 1660.
Wenn ihr einen guten Tip parat habt, wie man mit VICE und tcpser diese Modems emulieren kann, dann immer her damit.
Das würde mir später beim debuggen und Datenstrom mitschneiden sehr helfen. Besonders wenn es dann mal daran geht das Protokoll C*BASE fähig zu machen.... Dafür muss dann noch so einiges umgebaut werden.
Ups, kleiner Fehler:
- Transferblock Größe in Bytes (30 bis max. 255)
Die Transferblock Größe ist frei von 1 bis 255 Bytes. Sie kann aber vor Transferbeginn vom sendenden Rechner begrenzt werden, d.h. als User kann man manuell vorgeben wie groß ein Transferblock maximal sein soll.
Gerade am Ende einer Datei ist man beim Rainbow Protocol, wie auch bei Punter nicht auf Filepadding angewiesen wie beim X-Modem Protokoll bedingt durch fixe Transferblock Größen.
Moin. Kannst Du nicht einfach ein Hayes-Modem anschließen und das Wählen selber per AT-Kommando übernehmen? Dann sollte das Terminalprogramm doch eigentlich mit jedem Modem zurecht kommen.
Wie wählen die Commodore-Modems eigentlich? Da kann doch eigentlich nur das OffHook-Relais zur Pulswahl verwendet werden. Weißt Du, welcher Pin das ist?
Junge, junge ist das nen Krampf. Endlich habe ich mal einen Transfer mit Rainbow Protocol von Terminal zu Terminal mitschneiden können. Damit habe ich nun seit Ewigkeiten endlich eine Einsicht, wie das Protokoll intern tatsächlich funktioniert. Meine Adaption an C*BASE hat tatsächlich auch fast im ersten Anlauf funktioniert. Fast weil das läuft bisher nur für Uploads zum BBS (also der Receive Part vom Protokoll) und auch nur wenn alles sauber läuft, sprich ohne Fehler. Bei Resends von Transferblöcken zickt es noch rum. Aber für einen ersten Wurf bin ich schon ziemlich zufrieden.
Das Senden, sprich download vom BBS, funktioniert noch nicht. Das stürzt leider noch ab. Da sind mit Sicherheit noch diverse Bugs drin. Das halbe Protokoll muss schließlich für C*BASE umgebaut werden.
Hier mal eine aktualisierte Übersicht, wie das Protokoll kommuniziert wenn kein Problem auftritt:
Version: 2024-02-03
//----------------------------------------------------------------------------------
Rainbow Transmission Session
wip!
SENDER
RECEIVER
[GOO]
83
[SOH]
89
[ACK]
81
Block #0
<blk#> <255-blk#> <blk-size> <255-blk-size> <01> <Filesizelo> <Filesizehi> <Filetype> <REL flag?> <EOD> <chksum> <255-chksum>
00 FF 05 FA 01 35 00 50 00 91 86 79
[ACK]
81
[SOH]
89
[ACK]
81
Block #1
<blk#> <255-blk#> <blk-size> <255-blk-size> Data[blk-size] <EOD> <chksum> <255-chksum>
01 FE FF 00 .... 91 ..
[ACK]
81
[SOH]
89
Block #2 etc.
[ACK]
81
[EOT]
a1
[ACK]
81
Alles anzeigen
Wie wählen die Commodore-Modems eigentlich? Da kann doch eigentlich nur das OffHook-Relais zur Pulswahl verwendet werden. Weißt Du, welcher Pin das ist?
Sorry, da kann ich Dir leider nicht weiter helfen. Ich habe nie ein Commodore Modem gehabt. Aber im Netz sollte sich dazu was finden lassen.
Ein Schritt vor, zwei Schritte zurück.
Gestern Abend hatte ich dann endlich auch den Send Part vom Protokoll, sprich download vom BBS zum Terminal funktionierend mit PRG und SEQ Files.
Nun funktionieren aber die Uploads also der receive Part, der vorher ging, nicht mehr ![]()
Fehlersuche läuft schon den ganzen Tag, finde den Grund aber bisher nicht. Echt frustrierend.
REL File Transfers, die das Protokoll eigentlich können sollte, funktionieren im BBS Betrieb gar nicht. Ebenso USR Files. Das liegt aber primär am C*BASE System. Das umzuprogrammieren wäre aktuell Overkill.
Aber auch von Terminal zu Terminal geht der REL File Transfer noch nicht. Aber das ist dann Faust 2. Teil...
Erst einmal muss der Download vom BBS wieder funktionieren.
Stay tuned.
Hurra es läuft wieder. Uploads und Downloads von PRG und SEQ Files funktionieren.
Lektion 1: Gehe nie davon aus, daß ein Programm was seit Mitte der 80er Jahre im Umlauf ist, auch funktioniert. Weder das Transferprotokoll noch die 3 Terminal Programme T-Term V2.0, Touchterm 3.2a und Touchterm 3.5 funktionieren fehlerfrei. Das hat mir jetzt eine Woche lang immer wieder den Tag versaut. Die beiden Terminals laufen nur halbwegs sauber unter NTSC. Bei PAL funktioniert eine 1200 Baud Verbindung nicht mehr, oder es funktioniert keine Verbindung von VICE zu tcpser sauber. 300 Baud oder eben NTSC Mode brachte wenigstens Verbindungen zum BBS zustande.
Dann hatte ich die Hoffnung, das wenigstens das Transferprotokoll sauber funktioniert. Aber auch da sind böse Bugs drin. Erst dachte ich, das liegt vielleicht an der Implementierung vom Rainbow Protocol in Touchterm (wo es nach 2 Versionen eh wieder rausgeflogen ist), aber auch T-Term von Mike Dabbs, einem der Macher vom Rainbow Protocol, läuft nicht sauber.
Das größte Problem war ein BNE an eine falsche Adresse, was zur Folge hatte, dass nachdem der Dateiname für den Filetransfer eingegeben wurde, exakt 1x ein "GOO" vom Empfänger gesendet wird. Verpasst der Sender diese Info, geht der komplette Transfer in die Hose. D.h. es wird nicht mit Transferblock #0 begonnen (der Block mit den Infos zu Dateityp und Größe) sondern mit dem BlockBitte melde dich an, um diesen Link zu sehen. und auf ein "ACK" wird auch nicht mehr gewartet, die Daten werden einfach rausgeblasen bis es einen Timeout gibt oder der Transfer manuell abgebrochen wird.
Super da musste beim Testen auch erst einmal drauf kommen, warum Datenblock #0 fehlt. Zum Glück kann das mittels Logfile von tcpser analysiert werden, und irgendwann erkennt man dann auch den Fehler....
Mit korrekt gesetztem BNE Sprung, werden mehrere Sekunden lang, jede Sekunde vom Empfänger ein "GOO" gesendet, bis vom Sender das "SOH" kommt und der Transfer beginnt, oder eben Abbruch durch Timeout.
Was mich jetzt noch stört sind eben diese Timeouts. Du hast beim Upload zum BBS knapp 20 Sekunden Zeit, den Terminal Modus zu verlassen, über das Menü auf Datei senden zu gehen und den Dateinamen einzugeben.
Das ist mir viel zu knapp, werde ja auch nicht mehr jünger / schneller. Das ist die nächste Baustelle. Danach ist noch der Code für das Timeing per JiffyClock anzupassen, da sonst die Werte (Online Zeit vom Anrufer) gekillt werden.
Bei den X-Modem Protokollen und Punter hatte ich das in der Vergangenheit schon erledigt.
Weiterer Ausblick: Was nutzt ein Transfer Protokoll was niemand nutzen wird ? Richtig, gar nichts. Ich gehe davon aus, das niemand der halbwegs klaren Restverstand hat, freiwillig eins der oben genannten Terminalprogramme nutzen wird, nur im mal das Rainbow Protocol auszuprobieren. Deswegen macht das nur Sinn wenn das auch von einem Terminalprogramm unterstützt wird, was weit verbreitet ist und allgemeine Akzeptanz genießt. Und da kommen eigentlich nur zwei Programme infrage: 1. CCGMS und 2. Novaterm respektive Striketerm.
Da Novaterm die Transferprotokolle als externe Files nachlädt, werde ich da wohl mal schauen, wie sich das Rainbow Protocol dort einbinden lässt. Also neue Baustelle...
Für alle Masochisten, die trotz Warnung mit Bitte melde dich an, um diesen Link zu sehen. oder Bitte melde dich an, um diesen Link zu sehen. / Bitte melde dich an, um diesen Link zu sehen. ihre Lebenszeit vergeuden wollen, werde ich ggf. über das Karneval Wocheende das Protokoll ins BBS einbinden.
Dann stehen dort folgende Transferprotokolle zur Verfügung:
- X-Modem
- X-Modem CRC (XYModem)
- X-Modem1K (XYModem)
-Y-Modem batch (XYModem)
- Y-Modem-G (mit Vorsicht zu genießen!!!)
- Multi- Punter
- Rainbow Protocol
Hier an der Stelle noch einmal mein Aufruf:
Ich suche den Sourcecode zu H-Modem Protocol (Handyterm8.x). Wenn jemand den irgendwo hat, bitte gebt mir bescheid. Alternativ dazu, wer es sich zutraut den H-Modem Protocol Code aus dem Terminal Programm Handyterm zu hacken, bitte melden ![]()
So fertig, geschafft. Tatsächlich ist jetzt 1 ganzer Monat vergangen von den ersten Anfängen bis nun endlich C*BASE auch Rainbow Protocol kann.
Natürlich immer noch mit der Einschränkung, daß das BBS keine REL und USR Files akzeptiert. Aber es geht. Auf den letzten Metern, also heute, sind mir noch Bugs aufgefallen, die ich zum Glück schnell beseitigen konnte.
Der Online Timer wird nicht mehr zerschossen, es werden auch Bad Blocks hochgezählt und bei Transferabbruch gibt's auch keinen Programmabsturz mehr. Bis jetzt jedenfalls nicht.
Das Rainbow Protocol kann jedenfalls jetzt live und in Farbe auf meinem BBS ausprobiert werden.
Wie gesagt, alle mir bisher bekannten Terminal Programme, die das Protokoll unterstützen laufen nur halbwegs sauber auf NTSC Rechnern / Emulation. Und bei VICE + tcpser Kombination, sollte auf jedenfalls vor Programmstart tcpser ein "OK" gemeldet haben. Falls nicht, klappt die Verbindung Terminal Programm / VICE / tcpser nicht und man kann nicht rauswählen oder irgendein AT Kommando eingeben.
Bitte melde dich an, um diesen Anhang zu sehen.
Bitte melde dich an, um diesen Anhang zu sehen.
Übrigens sucht man mal im Internet nach den Machern von diesem Transfer Protokoll, dann stolpert man z.B. über Bitte melde dich an, um diesen Link zu sehen. (Fantasy Roleplaying BBS), ein BBS Programm für den C64 was für Rollenspiele gemacht wurde.
Auf Bitte melde dich an, um diesen Link zu sehen. finden sich dann auch Infos zu David Whatley, dem ehemaligen CEO von Simutronics, unter anderem verantwortlich für Online Spiele wie Gem Stone, Cyber Strike und andere.
Mike Dabbs ist auch der Author vom T-Term, eins der Terminal Programme, die das Rainbow Protocol eingebaut haben.
Kurz nach Mitternacht war es soweit: Beim zweiten Anlauf habe ich Larry's Rainbow Protokoll in C*Term eingebaut bekommen und nen erfolgreichen Up- und Download gemacht! ![]()
Letzte Nacht habe ich dann auf die Schnelle noch versucht das originale Rainbow Protokoll mit Striketerm zu verwenden. Striketerm und Novaterm laden die Transferprotokolle nach $c000, wie das originale Protokoll File, und auch die Reihenfolge der Aufrufe in der Jumptable für Send / Receive sind in der richtigen Reihenfolge (bei C*BASE genau umgekehrt). Leider will Striketerm damit ohne Anpassungen Up- und Downloads nur in eine Ramdisk speichern, nicht auf Disk. Da sind also noch ein paar Anpassungen notwendig. Ich hoffe aber, das hält sich dann im Rahmen.
Weiter auf der To-Do Liste:
- Z-Modem (mal wieder)
- Kermit
- H-Modem (mal wieder)
- ggf. WXModem inkl. senden von Daten.
DAVIS Protocol (Big Gulp) macht wahrscheinlich keinen Sinn im BBS. Und TAG Protokoll (aus T-Term V2.0) ist wohl eher nur etwas für Forschungszwecke...
Und was evtl. noch interessant wäre ist ein Performance Test vom Rainbow Protocol, wie ich ihn damals mal für Punter, X-Modem etc. mit einem 200 Block großen Programm gemacht hatte.
Der Performance Test ist nicht 100% mit dem von damals zu vergleichen, da nun etwas andere Hardware verwendet wurde.
BBS Seite ist ein U64 mit Hyperspeed Kernal, gespeichert wird auf USB Stick.
Terminal Seite ist VICE mit SCPU und RamLink als Laufwerk und tcpser für die Verbindung nach draußen mit 38.400 Baud auf beiden Seiten.
Upload zum BBS von einer 200 Blocks großen Datei: 1min, 2 Sekunden.
Download vom BBS, dieselbe Datei: 17 Sekunden.
HyperSpeed ist eben nur beim lesen Hyper.... leider.
Trotzdem ist das schon recht flott. Da dürfte nur X-Modem1K schneller sein. Aber Rainbow Protocol hat eben kein File padding wie X-Modem, da keine fixen Transferblockgrößen vorgegeben sind.
Alles in allem bin ich positiv überrascht.
So ein "neues" Protokoll in Novaterm einzubinden ist dann doch nicht mal eben so gemacht. Zwar gibt es für Novaterm 9.6 die Quelltexte, auch zu den Transferprotokollen, aber nahezu keine Kommentare im Quellcode oder sonst irgendetwas an Doku dazu. D.h. wenn du da nicht komplett im Thema drin bist und dir verschiedene Quellcode Files nebeneinander legst um ansatzweise was interpretieren und anpassen zu können, bist du schnell lost.
Aus der "mach ich mal eben" Aktion sind nun wieder 2 Tage geworden und es funktioniert leider immer noch nicht.
So ein "neues" Protokoll in Novaterm einzubinden ist dann doch nicht mal eben so gemacht.
Oh.. das wäre aber echt cool.. und wenn man es jetzt nicht macht wo man gerade in Flow ist, macht man es nie, oder?
Jetzt weiß man noch alle Funktionen und Fallstricke, aber in ein paar Wochen ist das alles weg.
Also wenn ich da irgendwie was testen kann, melde dich gerne.
Ich bin ja großer Fan von Novaterm 9.6, bzw nutze das nur als Terminal Programm.
Leider hat es das Rainbow Protocol immer noch nicht in Novaterm geschafft. Das Problem mit den nicht erkannten oder ignorierten Signalen ist nach wie vor nicht gelöst.
Allerdings hat das das Interesse von Leuten geweckt, die zuvor noch nie etwas von diesem Transferprotokoll gehört hatten. Besser als nichts.
Y-ModemG musste zwischenzeitlich wieder aus dem BBS Code raus, weil das Main BBS File wohl zu groß geworden ist (über 100 Blocks auf Diskette) und wieder merkwürdige Fehler auftraten.
Y-ModemG nutzt eh niemand am C64 und so richtig gut lief das Protokoll bisher auch nicht mangels flow-control.
Probleme im wahren Leben, wie z.B. "wie zum Geier bekomme ich die Verkabelung von meinen BRABUS Seitenschweller Verkleidungen mit Beleuchtung durch den Schweller in den Innenraum gelegt, ohne Löcher bohren zu müssen" ,
fressen dann eben auch wieder Freizeit. Andererseits sagte einer meiner Lehrer in der Schule: "Wer schön sein will, muss leiden". Auch wenn das damals auf die fragwürdigen Haar-Färbe-Versuche einer Mitschülerin bezogen war, passt das auch beim "Verschönern" von KFZs.
Leider ist auch die Resonanz beim Thema "Novaterm" viel geringer ausgefallen als erwartet. Scheinbar nutzen BBS Caller eher CGTerm oder CCGMS ? Keine Ahnung.
Jedenfalls macht das wenig Mut für ein lange vor sich hin geschobenes Projekt: "SuperRes" für Novaterm.... auch so'n Nischen Dings was keiner kennt.
Aber prokrastinieren ist ja in Mode, oder nicht ?
Bourbon Blues Vibes hier im Posting... Vielleicht liegt es aber auch daran das heute Montag ist.
Kopf hoch, ich hab auch ein Händchen für Dinge die niemanden interessieren.
Eine coole Idee hätte ich, da würden alle vor Freude in die Luft springen, vieleicht hast Du da ja ein besseres Händchen für...
Eine coole Idee hätte ich, da würden alle vor Freude in die Luft springen, vieleicht hast Du da ja ein besseres Händchen für...
Was denn ?
Wir machen meinen allten Jetta fertig und machen mit Opel, Hausfrauen Porsche und Rucksack Golf einen Roadtrip zum nächsten VCC nach Österreich ?
Äh. Jein. Ja. Nein.
Ich komm die Tage mal rum.
Ich würde das wahnsinnig gerne testen und beobachte diesen Thread intensiv, aber mir fehlt momentan einfach die Zeit.
Ein wichtiger Mitarbeiter ausgeschieden, Sohn zieht aus, Schwiegereltern erkrankt usw.
Was war die Zeit früher doch unbeschwert.
Aber Modem steht bei mir nach wie vor ganz oben auf der Liste. Also: Weitermachen. 😅