.
by Rick Kephart 5/21/88
This shows how to take whatever is in the memory area 8192-16191 (the
normal HIRES screen on the 128), such as a DOODLE picture (which can be
loaded with LOAD "DDfilename",B0,p7168), or a picture made by 128-BASIC,
and put it up on the RGB screen.
The first part of this file shows to do it with a C-128 with only 16K
video memory (unenhanced). The picture will be in black-and-white. The
second part of this file shows how to do the same thing with 64K video
memory (as in a C-128D), to produce a color picture.
To run the program, simply BLOAD"HIRES80",B15,P4864, make sure something
is in the HIRES bitmap at 8192, switch to 80-columns, and type SYS4864, or
whatever start address you load the program in at (it is completely
relocatable: you can BLOAD"HIRES80",B15,P5000, the SYS5000, or use any
available starting address, but you Must remain in Bank 15!). Then you can
switch back to the Text screen simply by pressing the RUN/STOP key.
This was written using only the 128's built-in ML monitor. I will
explain each step.
The first thing we will want to do is switch to FAST mode. This is a
simple process. (This is actually simply BASIC's FAST routine). First we
set Bit 4 in the Control Register at 53265 (HEX=$D011) to 0, by reading
the value there with LDA and then ANDing the value there with Binary
11101111 (HEX=$6F), which turns off Bit 4 but does not affect anything
else. This is the Bit which blanks the 40-column screen.
1300 AD 11 D0 LDA $D011
1303 29 6F AND #$6F
1305 8D 11 D0 STA $D011
Then we go to the Clock Rate Register at 53296 (HEX=$D030) and turn on
Bit 0. This changes the Clock Rate from 1 MHz (SLOW) to 2 MHz (FAST). The
other bits are unimportant and need not be retained, so we can simply put
a 1 in that register.
1308 A9 01 LDA #$01
130A 8D 30 D0 STA $D030
The next step is to set up the 8563 to Bitmap display. This is
controlled by Register #25 (HEX=$19). The Register will also turn off
Attribute memory, which we must also do. Attribute memory controls
individual character colors, as well as Reverse and Blink. Since we will
not have any room available for any attributes, they must be turned off.
To read or write to the 8563, we use the doorway at memory locations
54784 and 54785 (HEX=$D600 and $D601). It is only at these two memory
locations that we can communicate with the 8563 Video Chip. This is done
by storing the Register we want to read or write to $D600, then waiting
for Bit 7 at $D600 to be set to 1 (BPL will branch while Bit 7 is off),
indicating that $D601 is ready for action. As soon as that happens, we go
to work on $D601, reading or writing our value.
Register $19 will contain a different value depending on the particular
8563 chip in the particular 128 being used (there are two versions).
Therefore, we cannot simply put a value there with Attributes-Off and
Bitmap-On. Instead, we must first read the value that is there.
130D A2 19 LDX #$19
130F 8E 00 D6 STX $D600
1312 2C 00 D6 BIT $D600
1315 10 FB BPL $1312
1317 AD 01 D6 LDA $D601
Then we will put this normal value for Register $19 away. Let's use
location $16, a Zero-page location normally used by BASIC, but available
to us now since we're not using BASIC.
131A 85 16 STA $16
Now we must turn off Attributes and turn on Bitmap. Bits 6 and 7 of the
register control these two 8563 things. To turn on the Bitmap, we must set
Bit 7 to 1. We'll do this by ORing it with Binary 10000000 (HEX=$80) to
turn on Bit 7 without affecting any other bit. To turn off the Attributes,
we've got to get Bit 6 to 0. Let's do that by ANDing it with Binary
10111111 (HEX=$BF), which will turn Bit 6 off without affecting any other
bit.
131C 09 80 ORA #$80
131E 29 BF AND #$BF
Now we will use BASIC's built-in routine to write a vaue to a register,
which is at 52684 (HEX=$CDCC). To do this, the register must be in the
X-register, and the value to write must be in the Accumulator. The routine
writes the register in X to $D600, waits for Bit 7 of $D600 to be on, then
writes the value in the Accumulator to $D601. (The X-register still
contains $19.)
1320 20 CC CD JSR $CDCC
The next thing we must do is set up the 8563 to start reading data, and
storing it at location $0000 in the 8563's RAM memory. We have to start at
$0000 because we need every byte from $0000 to the highest location,
$3FFF. The Screen Memory's location, which is controlled by Registers 12
and 13 (HEX=$0C and $0D) are already set to 0 to start the screen at
$0000, so we don't have to worry about them. But we do need to set the
Current Memory Address registers 18 and 19 (HEX=$12 and $13) to $0000, so
when we start writing to the 8563's RAM, the data will start at $0000.
Once these have been set for the address at which we want to start
writing, it is updated automatically for each byte we write (nice of it to
do that for us, isn't it?). (Unlike all other addresses with the 6502 or
6510 or 8510 microprocessors, addresses in the 8563 are written high-byte
First, then low-byte, the opposite order. In this case, though, since the
high- and low-bytes of the address are the same, this peculiarity is not
visible here.) To do this, we will again use our built-in write-to-the-
8563-chip routine at $CDCC. We will set the Accumulator to 0 and the
X-register to $12. Then we will simply use INX to increase the X-register
to write the low-byte to $13.
1323 A9 00 LDA #$00
1325 A2 12 LDX #$12
1327 20 CC CD JSR $CDCC
132A E8 INX
132B 20 CC CD JSR $CDCC
The next byte in the program is just an NOP, separating the
preliminaries from the actual main routine to write the one memory into
the other.
132E EA NOP
Now the real work begins! The hardest part of this project is reading
the VIC HIRES screen, because the VIC stores Bitmap memory in vertical
blocks of 8 bytes in horizontal rows of 40 blocks across, whereas the 8563
uses 80 sequential bytes across each row. What we must do is read bytes
from the VIC Bitmap in horizontal rows, and not sequentially. Here is a
BASIC way to do this: FOR A = 8192 TO 16191 STEP 320: FOR B = 0 TO 7: FOR
C = 0 TO 312 STEP 40: X = PEEK(A+B+C): NEXT C,B,A
That's what we have to do in Machine Language! Not an easy task. It is
worth it, though, Because this BASIC routine is very slow. I decided to
convert this exact routine into machine language. Here's how I did it:
I picked a couple of BASIC's Zero-page locations for a counter for 8192
to 16191. I chose locations $10 and $11, and stored 8192 (HEX=$2000) there
to begin.
132F A9 20 LDA #$20
1331 85 11 STA $11
1333 A9 00 LDA #$00
1335 85 10 STA $10
Here is where the biggest loop begins! We're going to copy the address
stored in $10 & $11 to a couple more of BASIC's Zero-page locations (I'm
sure BASIC won't mind), $12 and $13. This way, we can update the address
in groups of 8 until we get to the end of a 40-byte row, and then update
the address by 320 to go on to the next row.
1337 A5 10 LDA $10
1339 85 12 STA $12
133B A5 11 LDA $11
133D 85 13 STA $13
I'm going to use another Zero-page location, $14, to count from 0 to 7.
This will be used as a Y-index. We have to have a memory location to store
it, because we'll be needing the Y-register later on.
133F A9 00 LDA #$00
1341 85 14 STA $14
One more of BASIC's Zero-page locations, $15, we'll use to count from 1
to 40, to tell us when we've reached the end of a HIRES row. But let's use
it as a countdown, starting by putting 40 (HEX=$28) and wait 'till we
reach zero.
1343 A9 28 LDA #$28
1345 85 15 STA $15
Now let's get started, at last! We'll put the value in $14 (something
between 0-7) into the Y-register, and read a byte from the VIC HIRES
screen at 8192-16191.
1347 A4 14 LDY $14
1349 B1 12 LDA ($12),Y
Now comes the really interesting part. Since the 8563 Bitmap display is
640X199 bits and the VIC Bitmap is only 320X199 bits, every bit of the VIC
display must be doubled to fill the entire 8563 Bitmap. This is one of
those rare cases of numerical manipulations which are actually much easier
to do in Machine Language than in BASIC! What will happen is each byte
will be doubled into two byte, one with each of the first 4 bits doubled,
and the other with the other 4 bits of the original number doubled (8 bits
doubled = 16 bits, or 2 bytes).
The first thing we'll do is set up the X-register as a counter for the
high 4 bits and then the low 4 bits of each byte (that is, we must run
through this routine twice: once for each set of 4 bits). This will also
serve as a Zero-page Index!
134B A2 01 LDX #$01
Now, we'll copy the byte into two Zero-page locations. Let's give BASIC
a break and use $FD and $FE.
134D 85 FD STA $FD
134F 85 FE STA $FE
Now we'll put a 4 in the Y-register to count down the 4 bits to double
at a time.
1351 A0 04 LDY #$04
Now is the time to start doubling! We'll use the ML instruction ROL. The
Carry will hold whether the bit is 0 or 1. We don't have to worry about
CLC or ASL, because we'll be using all 8 bits, and it won't matter what
ends up in $FD and $FE when we're done! As each bit is rolled out into the
carry, we'll roll it into a Zero-page location. The 2 bytes which will
hold the final two bytes will be $FB and $FC, pointed to by the
X-register! We have the byte in two memory locations, so it will be a
simple matter to double the bit simply by rolling each bit out twice.
1353 26 FD ROL $FD
1355 36 FB ROL $FB,X
1357 26 FE ROL $FE
1359 36 FB ROL $FB,X
135B 88 DEY
135C D0 F5 BNE $1353
Now the top four bits of $FD and $FE contain what used to be the low 4
bits. It makes no difference what's now in the 4 low bits of $FD and $FE,
we'll never see them.
135E CA DEX
135F F0 F0 BEQ $1351
Now $FC and $FB contain the value from the VIC screen with each bit
doubled. So now we're ready to write two bytes to the 8563 Bitmap. The
Memory read/write gateway to the 8563 is Register 31 (HEX=$1F). Again,
we'll use the routine at $CDCC to write the two bytes to the 8563 RAM
memory, and thereby put them up on the Bitmap display.
1361 A2 1F LDX #$1F
1363 A5 FC LDA $FC
1365 20 CC CD JSR $CDCC
1368 A5 FB LDA $FB
136A 20 CC CD JSR $CDCC
Time now to go to the next horizontal byte of the VIC Bitmap. This byte
is 8 away from the previous byte. We'll do this with a simple addition
routine, adding 8 to the base address in $12 & $13.
136D 18 CLC
136E A9 08 LDA #$08
1370 65 12 ADC $12
1372 85 12 STA $12
1374 A9 00 LDA #$00
1376 65 13 ADC $13
1378 85 13 STA $13
Now we'll use our countdown counter we've set up in $15 to see if we've
reached the end of a row yet, and look back if we haven't.
137A C6 15 DEC $15
137C D0 C9 BNE $1347
Now we've got one line of bytes. We have 8 more lines of 40 bytes each
to get. Remember, we use location $14 to store our Y-index offset. Each
byte of each row will be 1 byte higher than the previous row. First, we're
getting the first byte of each 8-byte block, so we have one horizontal
row. The next horizontal row will consist of the second byte of each
8-byte block. The third row will be the third byte of each block, and so
on until we've reached all 8 bytes. As we go to each byte of the block, we
must maintain the base address as the first byte of the first block, so
our offset will point to the right byte.
137E E6 14 INC $14
1380 A5 10 LDA $10
1382 85 12 STA $12
1384 A5 11 LDA $11
1386 85 13 STA $13
Now we check to see if we've finished the 8-byte block.
1388 A5 14 LDA $14
138A C9 08 CMP #$08
138C D0 B5 BNE $1343
Now the time has come to jump to the next row of 8-byte blocks. We do
this by adding 320 (HEX=$0140) to the base address. This is a simple
addition routine.
138E 18 CLC
138F A9 40 LDA #$40
1391 65 10 ADC $10
1393 85 10 STA $10
1395 A9 01 LDA #$01
1397 65 11 ADC $11
1399 85 11 STA $11
Now we check to see if we're finished. We'll be finished when we have
worked our way up to location 16191 (HEX=$3F3F). We already have the high
byte in the accumulator, so we'll check and see if that's $3F yet. If it
is, then we'll check to see if the low byte is higher than $3F.
139B C9 3F CMP #$3F
139D D0 98 BNE $1337
139F A5 10 LDA $10
13A1 C9 3F CMP #$3F
13A3 90 92 BCC $1337
Hurrah! The VIC Bitmap is now on display on the 8563 RGB screen! Now
we'll keep this on the screen, until the STOP key has been pressed.
Location 145 (HEX=$91) is constantly updated by the Kernal to contain the
value of the column of the Keyboard scan which has the STOP key. Bit 7 is
cleared to 0 whenever the STOP key is pressed. BMI loops as long as Bit 7
is 1, so it will loop until the STOP key is being pressed.
13A5 A5 91 LDA $91
13A7 30 FC BMI $13A5
The Bitmap is nice to look at, but eventually we'll want to be able to
see characters on the screen again! Remember when we stored the original
value of Register $19 in location $16? Well, here's where we finally use
it! This will turn the Bitmap off and turn the Attributes back on again.
13A9 A2 19 LDX #$19
13AB A5 16 LDA $16
13AD 20 CC CD JSR $CDCC
But we've still got us a problem here! Since we used the entire 16K to
display our Bitmap, we have overwritten the entire 8563 character-set. We
know have the text screen set up, but no character data to be able to
print characters to print to it! The Kernal will come to our rescue here.
When the 8563 is first initialized, VIC's character set is copied into the
8563 RAM, in the character memory storage area (which, by the way, is
located at 8192 to 16383 (HEX=$2000 to $3FFF) in the 8563's RAM memory).
The 128 Kernal's Jump Table has a entry called INIT80, which carries out
this copying procedure, at 65378 (HEX=$FF62). It jumps to the actual
routine which is in in the Screen Editor ROM at 49191 (HEX=$C027).
13B0 20 62 FF JSR $FF62
Now the Text screen is being displayed by the 8563, and we have all our
characters in memory so we can display them. But there's still one thing
wrong. Attribute memory is turned on, but is filled with strange data,
whatever was in the Bitmap display from 2048 to 4096 (HEX=$0800 to $1000)
which is where the 8563 stores the Attributes in its memory. That's why
you see that bizarre display for an instant after the Bitmap is switched
out. Attribute memory is easiest to clear by simply clearing the screen,
by printing the CLR/HOME character of CHR$(147) (HEX=$93) through the
Kernal output routine at $FFD2.
13B3 A9 93 LDA #$93
13B5 20 D2 FF JSR $FFD2
And now we're finished! Back to BASIC. Bye bye!
13B8 60 RTS
Switch to FAST mode
1300 AD 11 D0 LDA $D011
1303 29 6F AND #$6F
1305 8D 11 D0 STA $D011
1308 A9 01 LDA #$01
130A 8D 30 D0 STA $D030
Now we set up the VDC for BITMAP display, but do NOT turn off
attributes!
130D A2 19 LDX #$19
130F 8E 00 D6 STX $D600
1312 2C 00 D6 BIT $D600
1315 10 FB BPL $1312
1317 AD 01 D6 LDA $D601
131A 85 16 STA $16
131C 09 80 ORA #$80
131E 20 CC CD JSR $CDCC
Now, change the screen memory from $0000-$4000 up to $8000€$C000. The
screen memory is determined by the values in registers 12 and 13 ($0C &
$0D) in high-byte/low-byte format:
1321 A9 80 LDA #$80
1323 A2 0C LDX #$0C
1325 20 CC CD JSR $CDCC
1328 E8 INX
1329 A9 00 LDA #$00
132B 20 CC CD JSR $CDCC
Now we set the current write-address to $8000 by putting that value into
registers 18 & 19:
132E A9 80 LDA #$80
1330 A2 12 LDX #$12
1332 20 CC CD JSR $CDCC
1335 A9 00 LDA #$00
1337 E8 INX
1338 20 CC CD JSR $CDCC
No we convert the VIC bitmap to the VDC bitmap, just like in the 128
version
133B A9 20 LDA #$20
133D 85 11 STA $11
133F A9 00 LDA #$00
1341 85 10 STA $10
1343 A5 10 LDA $10
1345 85 12 STA $12
1347 A5 11 LDA $11
1349 85 13 STA $13
134B A9 00 LDA #$00
134D 85 14 STA $14
134F A9 28 LDA #$28
1351 85 15 STA $15
1353 A4 14 LDY $14
1355 B1 12 LDA ($12),Y
1357 A2 01 LDX #$01
1359 85 FD STA $FD
135B 85 FE STA $FE
135D A0 04 LDY #$04
135F 26 FD ROL $FD
1361 36 FB ROL $FB,X
1363 26 FE ROL $FE
1365 36 FB ROL $FB,X
1367 88 DEY
1368 D0 F5 BNE $135F
136A CA DEX
136B F0 F0 BEQ $135D
136D A2 1F LDX #$1F
136F A5 FC LDA $FC
1371 20 CC CD JSR $CDCC
1374 A5 FB LDA $FB
1376 20 CC CD JSR $CDCC
1379 18 CLC
137A A9 08 LDA #$08
137C 65 12 ADC $12
137E 85 12 STA $12
1380 A9 00 LDA #$00
1382 65 13 ADC $13
1384 85 13 STA $13
1386 C6 15 DEC $15
1388 D0 C9 BNE $1353
138A E6 14 INC $14
138C A5 10 LDA $10
138E 85 12 STA $12
1390 A5 11 LDA $11
1392 85 13 STA $13
1394 A5 14 LDA $14
1396 C9 08 CMP #$08
1398 D0 B5 BNE $134F
139A 18 CLC
139B A9 40 LDA #$40
139D 65 10 ADC $10
139F 85 10 STA $10
13A1 A9 01 LDA #$01
13A3 65 11 ADC $11
13A5 85 11 STA $11
13A7 C9 3F CMP #$3F
13A9 D0 98 BNE $1343
13AB A5 10 LDA $10
13AD C9 3F CMP #$3F
13AF 90 92 BCC $1343
Now here is where the color is added. First we move Attribute memory
from its normal location at $0800 up to the unused area at $1000. This
move is done so that the old attributes will be preserved when we switch
back to the text display. The location of Attribute memory is determined
by the values in registers 20 & 21 ($14 & $15)
13B1 A9 10 LDA #$10
13B3 A2 14 LDX #$14
13B5 20 CC CD JSR $CDCC
13B8 A9 00 LDA #$00
13BA E8 INX
13BB 20 CC CD JSR $CDCC
Reset the current write to memory location
13BE A9 10 LDA #$10
13C0 A2 12 LDX #$1213C2 20 CC CD JSR $CDCC
13C5 A9 00 LDA #$00
13C7 E8 INX
13C8 20 CC CD JSR $CDCC
40-column color memory is stored starting at location $1C00 (7168).
Let's use a dynamic routine to read the colors, by storing the address
within the program
13CB A9 1C LDA #$1C
13CD 8D D7 13 STA $13D7
13D0 A9 00 LDA #$00
13D2 8D D6 13 STA $13D6
Now we get the value, then convert it to 2 4-bit nibbles
13D5 AD 00 1C LDA $1C00
13D8 48 PHA
13D9 4A LSR
13DA 4A LSR
13DB 4A LSR
13DC 4A LSR
13DD A8 TAY
There is a table of color translation
between 40-column and 80-column stored in ROM starting at $CEC5. We'll
put each nibble in the Y-register to use as an offset to get the
equivalent 80-column color
13DE B9 5C CE LDA $CE5C,Y
13E1 85 FE STA $FE
13E3 68 PLA
13E4 29 0F AND #$0F
13E6 A8 TAY
13E7 B9 5C CE LDA $CE5C,Y
The two halves of the byte (foreground and background colors) are
combined
13EA 0A ASL
13EB 0A ASL
13EC 0A ASL
13ED 0A ASL
13EE 05 FE ORA $FE
13F0 A2 1F LDX #$1F
Each color must be stored in the 80-column bitmap twice, since the
entire display is expanded twice as wide
13F2 20 CC CD JSR $CDCC
13F5 20 CC CD JSR $CDCC
Loop back if not done (at $2000)
13F8 EE D6 13 INC $13D6
13FB D0 D8 BNE $13D5
13FD EE D7 13 INC $13D7
1400 AD D7 13 LDA $13D7
1403 C9 20 CMP #$20
1405 D0 CE BNE $13D5
Check for STOP key
1407 A5 91 LDA $91
1409 30 FC BMI $1407
Turn off bitmap and restore test screen
140B A5 16 LDA $16
140D A2 19 LDX #$19
140F 20 CC CD JSR $CDCC
Put Attribute memory back at $0800
1412 A9 08 LDA #$08
1414 A2 14 LDX #$14
1416 20 CC CD JSR $CDCC
1419 E8 INX
141A A9 00 LDA #$00
141C 20 CC CD JSR $CDCC
Put screen memory back at $0000
141F A9 00 LDA #$00
1421 A2 0C LDX #$0C
1423 20 CC CD JSR $CDCC
1426 E8 INX
1427 20 CC CD JSR $CDCC
142A 60 RTS
And return
End of file.
You can write to me at .
| HOME | Religion | Latin Mass | Denton | Prayer Requests | 
Homeschooling |
| Stories | Art | ******* | Commodore | Miniatures | |
| England | Italy | Florida | Musical | Gregorian Chant | LPH Resource Center |