CIO

All posts tagged CIO

6502, Printing Subroutines Again

Posted by Ripdubski on 2014.08.28
Posted in: Atari, Programming. Tagged: , , , , , , , . Leave a comment

I created routine for printing strings that terminate with EOS in the post “6502, Printing, Pointers and Subroutines“.  I also created one for printing strings that terminate with EOL.  The routine to print EOS terminated strings (PRTCH) loops through the string printing one character at a time via CIO until it reaches EOS.  Because there is no EOL the cursor retains its position on screen at the end of the text so a subsequent print will start at that position.  Useful for printing variables in sentence form such as :

Hello variable, Welcome!

The routine to print EOL terminated strings (PRTLN) prints the entire string with one CIO call.  The result is a slightly faster print but at the cost of EOL being printed as well, which causes the cursor to position on the next line.  Using the previous example, output of a variable in a sentence would result in:

Hello variable
, Welcome!

Not very desirable, which is why I created two routines.  The one to print an EOS terminated string (PRTCH) is working as designed but not as desired.  I found that it would overrun the end of the string if it was passed a string terminated with EOL instead.  Sounds like programmer error, but there are instances where it becomes useful to pass and EOL terminated string to the looped printing call.  One example is allowing string manipulation routines to always terminate with EOL which can make life easier for the programmer.

Print EOS (or EOL) Terminated String (PRTCH)

I updated the PRTCH routine so that it will also stop printing if EOL is encountered.  It has been incorporated into a library since it was originally written.  Here is the new code:

0100 ; Storage & Pointers
0110 PRINDX *= *+1
0120 PRSPTR = $CC
5000 ; ------------------------------
5001 ; Desc: Print String (EOS Term)
5002 ; Parm: A=H byte of string addr
5003 ;       X=L byte of string addr
5004 ; ------------------------------
5009 PRTCH
5010 ; Store Starting String Address
5015    STX PRSPTR
5020    STA PRSPTR+1
5025    LDA #$00
5030    STA PRINDX
5035 ; Set IOCB Command
5040    LDX #$00
5045    LDA #$0B
5050    STA ICCOM,X
5055 ; Set Max Buffer Length
5060    LDA #$00
5065    STA ICBLL,X
5070    STA ICBLH,X
5080 ; Call CIO to Print
5085 PRCHLP LDY PRINDX
5090    LDA (PRSPTR),Y
5095    BEQ PRCHDN
5096    CMP #EOL
5097    BEQ PRCHDN
5100    JSR CIOV
5105    INC PRINDX
5110    BNE PRCHLP
5115 PRCHDN RTS

Breakdown

I’ll only document the changed lines of this routine:

  • Line 110: Reserve space for the print index of the string.  This was previously declared in the test program but now resides in the library code.
  • Line 120: Page 0 storage space for the string to be printed address.  This was previously declared in the test program but now resides in the library code.
  • Line 5096: Compare the current string character (in the accumulator) with the value EOL
  • Line 5097: If the comparison was equal (current character = EOL) branch to PRCHDN (end of the routine).

 

Print EOL Terminated String (PRTLN)

It occurred to me that I have not posted about this library function.  As mentioned this routine prints the entire string in one CIO call.  That includes the EOL.

5200 ; ------------------------------
5201 ; Desc: Print Line (EOL Term)
5202 ; Parm: A=H byte of string addr
5203 ;       Y=L byte of string addr
5204 ; ------------------------------
5209 PRTLN
5210 ; Store Starting String Address
5215    LDX #$00
5220    STA ICBAH,X
5225    TYA 
5230    STA ICBAL,X
5235 ; Set IOCB Command
5240    LDA #$09
5245    STA ICCOM,X
5250 ; Set Max Buffer Length
5255    LDA #$00
5260    STA ICBLH,X
5262    LDA #$FF
5265    STA ICBLL,X
5270 ; Call CIO to Print
5275    JSR CIOV
5280 RTS

Breakdown of PRTLN

This is also now part of my library.  It does not need the PRSPTR or PRINDX variables like PRTCH does.

  • Line 5215: Load the X register with value 0.
  • Line 5220: Store the accumulator at the X offset of ICBAH (the high byte of the string address to be printed).
  • Line 5225: Transfer the Y register to the accumulator (Y is holding the low byte of the string address to be printed).
  • Line 5230: Store the accumulator at the X offset of ICBAL (the low byte of the string address to be printed).
  • Line 5240: Load the accumulator with value 9 (IOCB print text record).
  • Line 5245: Store the accumulator in ICCOM (IOCB command).
  • Line 5255: Load the accumulator with value 0.
  • Line 5260: Store the accumulator at the X offset of ICBLH (high byte of the max buffer length).  For my purposes the string will always be less then 256 characters so this byte should always be 0.
  • Line 5262: Load the accumulator with value 255 ($FF).
  • Line 5265: Store the accumulator at the X offset of ICBLL (low byte of the max buffer length).  For my purposes the string will always be 255 characters or less.
  • Line 5275: Call CIO to do the print.
  • Line 5280: Exit function.

Results

I tested the routines in a program I’m writing and they work as designed, and now, as desired.  I don’t have any output to show, and they are working right.  I will reveal it later as I progress.

In this screenshot you can see two strings input (both terminated with EOL) and then output, one with the print routine PRTCH (EOS) and one with the print routine PRTLN (EOL).  Both work as they should.

6502 Assembly Input String CIO

 

I’ve also squashed my last bug in the string to integer routine.  I’ll discuss that in the post.

 

6502, String Input Redux

Posted by Ripdubski on 2014.08.26
Posted in: Atari, Programming. Tagged: , , , , , . Leave a comment

I found the problem that is causing the string to integer routine to fail.  It’s actually two-fold. I’m addressing the first part here.

Problem

The conversion routine was overrunning the input string.  It was looking for EOL while the input string routine was terminating the string with EOS.

Earlier I wrote a string input routine, (6502, String Input), but at the time I wanted it terminated with EOS to prevent a carriage return from being output if the string is printed.  Fair enough.  For the same routine to be compatible with the string to integer routine a modification was needed.

New Code

I revised the string input routine.  It now accepts three parameters, the 3rd being which termination character to append.  This gets stored in the Y register before calling the string input routine.  The string input routine saves the Y register in the 2nd IOCB auxiliary byte (ICAX2, location $0351) since the Y register will be disturbed through the CIO call it executes.  At the end of the routine, it pulls the value from the auxiliary byte and tacks it onto the string.

Here is the new INPSTR function assembly code:

7000 ; ------------------------------
7001 ; Desc: Input String
7002 ; Parm: A=H byte of string addr
7003 ;       X=L byte of string addr
7004 ;       Y=String Term Char
7005 ; ------------------------------
7009 INPSTR
7010 ; Store Starting String Address
7012    STX ICBAL
7014    STA ICBAH
7016    STY ICAX2
7025 ; Store Str Address in P0 Ptr
7030    STX INSPTR
7035    STA INSPTR+1
7040 ; Set IOCB Command
7045    LDX #$00
7050    LDA #$05 ; Get Record
7055    STA ICCOM,X
7060 ; Set Max Buffer Length
7065    LDA #30
7070    STA ICBLL,X
7075    LDA #0
7080    STA ICBLH,X
7085 ; Call CIO to Print
7090    JSR CIOV
7095 ; Get # chars input
7100    LDY ICBLL
7105 ; Reduce char count by 1
7110    DEY 
7115 ; Store EOS at EOL position
7118    LDX #0
7120    LDA ICAX2,X
7125    STA (INSPTR),Y
7130    RTS

The following lines are noteworthy, and are the extent of the changes to the original routine:

  • 7016: Stores the Y register in location ICAX2.
  • 7118: Loads the X register with 0.  The offset from ICAX2 that the Y register was stored in.
  • 7120: Load the accumulator from the X byte offset of address ICAX2.  Since x is 0, it will load from address ICAX2.

Since I wrote the original code I started using include files to manage definitions, functions, and macros.  If you look at the previous string input post, the code above replaces lines 7000 through 7160.  For the new input string test code, it is included from “A8FUNCS.LIB”.

Here is the new string input test code.  I apologize for the lack of inline comments but I break it down afterward:

10      *= $3600
20      .INCLUDE #D2:A8DEFS.LIB
0300 ; TEST PRINTING
0302 TEST
0310    LDA #SCLR/256
0312    LDX #SCLR&255
0314    JSR PRTCH
0320    LDX #0
0322    LDY #0
0324    JSR CURXY
0326    LDA #SRULE/256
0328    LDX #SRULE&255
0330    JSR PRTCH
0340    LDX #0
0342    LDY #2
0344    JSR CURXY
0350    LDA #SP1/256
0352    LDX #SP1&255
0354    JSR PRTCH
0360    LDA #VSNAME/256
0362    LDX #VSNAME&255
0364    LDY #EOS
0366    JSR INPSTR
0370    LDX #0
0372    LDY #3
0374    JSR CURXY
0380    LDA #SP2/256
0382    LDX #SP2&255
0384    JSR PRTCH
0390    LDA #VSNAM2/256
0392    LDX #VSNAM2&255
0394    LDY #EOL
0396    JSR INPSTR
0460    LDX #0
0470    LDY #5
0480    JSR CURXY
0490    LDA #SP3/256
0500    LDX #SP3&255
0510    JSR PRTCH
0520    LDA #VSNAME/256
0530    LDX #VSNAME&255
0540    JSR PRTCH
0550    LDA #SWELC/256
0560    LDX #SWELC&255
0570    JSR PRTCH
0700    LDX #0
0710    LDY #7
0720    JSR CURXY
0730    LDA #SP3/256
0732    LDX #SP3&255
0734    JSR PRTCH
0736    LDA #VSNAM2/256
0738    LDX #VSNAM2&255
0740    JSR PRTCH
0750    LDA #SWELC/256
0752    LDX #SWELC&255
0754    JSR PRTCH
0990    RTS 
010000 ; STRING DATA
010001 SCLR .BYTE CLS
010002 SRULE .BYTE "-|Input|--------------------------------",EOS
010005 SP1 .BYTE "Name (EOS)?",EOS
010007 SP2 .BYTE "Name (EOL)?",EOS
010010 SP3 .BYTE "Hello ",EOS
010020 SWELC .BYTE ", Welcome!",EOS
010050 VSNAME *= *+30
010060 VSNAM2 *= *+30
063500    .INCLUDE #D2:A8FUNCS.LIB
064000    .END

Breakdown

The highlighted lines the important differences between the new input test code and the original input test code.

  • Line 10: Set the program loading address to $3600.
  • Line 20: Include file to pull in standard definitions from the library “A8DEFS.LIB”.
  • Lines 310 to 316: Clears the screen
  • Lines 320 to 324: Moves the cursor to position 0,0 (upper left corner) of the screen.
  • Lines 326 to 330: Prints the screen header.
  • Lines 340 to 344: Moves the cursor to position 2,0 (column 0, row 2) of the screen.
  • Lines 350 to 354: Prints the “Name (EOS)?” prompt.
  • Lines 360 to 366: Gets the first string from the user.  Note in line 364 the Y register is loaded with EOS.  #EOS is specified so the value EOS is stored instead of the value of memory location designated by EOS (0).
  • Lines 370 to 374: Moves the cursor to position 3,0 (column 0, row 2) of the screen.
  • Lines 380 to 384: Prints the “Name (EOL)?” prompt.
  • Lines 390 to 396: Gets the second string from the user.  Note in line 394 the Y register is loaded with EOS.
  • Lines 460 to 480: Moves the cursor to position 5,0 (column 0, row 5) of the screen.
  • Lines 490 to 510: Prints the “Hello ” portion of the output message.
  • Lines 520 to 540: Prints the first input string.  Notice there is no positioning done as we want the string printed at the last position the cursor was at.
  • Lines 550 to 570: Prints the “, Welcome!” portion of the output message.  Again, there was no positioning done so the message would be printed at the last cursor position.
  • Lines 700 to 720: Moves the cursor to position 7,0 (column 0, row 7) of the screen.
  • Lines 730 to 734: Prints the “Hello ” portion of the output message.
  • Lines 736 to 740: Prints the second input string.  Notice there is no positioning.
  • Lines 750 to 754: Prints the “, Welcome!” portion of the output message. Again, no positioning.
  • Line 990: Exit
  • Lines 10001 to 10020: Definitions for the output messages.
  • Lines 10050 to 10060: Buffer space reservation for the input strings.
  • Lines 63500: Include file to pull in the INPSTR routine from the library “A8FUNCS.LIB”.

 

Output

The test code above asks for two names.  The first is terminated with EOS, the second is terminated with EOL.  It then prints both out in single line message form.  As you can see the first name is printed inline with the complete message, where the second is printed inline with part of the message after the name broken onto a second line.

6502 Assembly Input String

 

Success!  Now off to squash the other part of the string to integer conversion.

 

6502, Including Others

Posted by Ripdubski on 2014.06.26
Posted in: Atari, Programming. Tagged: , , , , , , . Leave a comment

While learning 6502 assembly I was trying to keep it simple and keep all the source for each program self contained, meaning no includes from external files.  In resolving the issues discussed in my last post it has become increasingly difficult to manage the source in this fashion.  Time to incorporate the Include files to make managing the source easier.  In this post I demonstrate how Mac/65 handles the includes, and some nuances I ran into.

To include source code in one file into another file, you use the “.INCLUDE” directive.  I set about changing the string input program I wrote a previous post here: String Input.  First I pulled all the defines from the source and placed them in their own file named “DEFINES.LIB”.  I used the extension LIB because include files must be in the tokenized SAVE format, not LIST atascii format; and because it’s a library of sorts.  I also renumbered it which will make it easier to manage going forward as I add and organize it.

The new “DEFINES.LIB” file contents.  I’ll show where it’s included in just a bit.

10 ; Defines
20 CIOV = $E456
30 ICHID = $0340 ;IOCB 0 S:
40 ICCOM = $0342 ;IOCB Command
50 ICBAL = $0344 ;Xfer Buffer Adr
60 ICBAH = $0345
70 ICBLL = $0348 ;Buffer Len
80 ICBLH = $0349
90 ROWCRS = 84
0100 COLCRS = 85
0110 EOL = $9B
0120 EOS = $00
0130 CLS = $7D

Next, I took all the routines I’ve been working on in the previous posts (such as printing strings, printing lines, positioning the cursor, and inputing a string), and placed them in their own file.  I named this one “A8FUNCS.LIB”.  Again in tokenized SAVE format.  This one also needed the storage and pointer definitions included in it.  Note using it means that memory locations $CC/$CD, $CD/$CE are reserved for use by the routines.

The new “A8FUNCS.LIB” file contents:

100 ; Storage & Pointers
0110 PRINDX *= *+1
0120 PRSPTR = $CB
0130 INSPTR = $CD
5000 ; Print Subroutine
5005 PRTCH
5010 ; Store Starting String Address
5015    STX PRSPTR
5020    STA PRSPTR+1
5030    LDA #$00
5040    STA PRINDX
5050 ; Set IOCB Command
5052    LDX #$00
5055    LDA #$0B
5060    STA ICCOM,X
5070 ; Set Max Buffer Length
5072    LDA #$00
5080    STA ICBLL,X
5090    STA ICBLH,X
5100 ; Call CIO to Print
5105 PRCHLP LDY PRINDX
5108    LDA (PRSPTR),Y
5115    BEQ PRCHDN
5116    JSR CIOV
5120    INC PRINDX
5130    BNE PRCHLP
5140 PRCHDN RTS 
6000 ; Position Subroutine
6005 CURXY
6010    STX COLCRS
6020    STY ROWCRS
6030    RTS 
7000 ; Input String
7005 INPSTR
7010 ; Store Starting String Address
7015    STX ICBAL
7020    STA ICBAH
7030 ; Store Str Address in P0 Ptr
7035    STX INSPTR
7040    STA INSPTR+1
7050 ; Set IOCB Command
7052    LDX #$00
7055    LDA #$05 ; Get Record
7060    STA ICCOM,X
7070 ; Set Max Buffer Length
7072    LDA #30
7080    STA ICBLL,X
7085    LDA #0
7090    STA ICBLH,X
7100 ; Call CIO to Print
7110    JSR CIOV
7115 ; Get # chars input
7120    LDY ICBLL
7130 ; Reduce char count by 1
7135    DEY 
7140 ; Store EOS at EOL position
7145    LDA #EOS
7150    STA (INSPTR),Y
7160    RTS

A quick note about lines 100 to 130.  These were previously at the head of the program.  Since they are specific to the functions I’ve placed them inside the function library source.  The downside to this is that my library source now requires that memory locations $CB through $CE not be used by any program the library is included in – because the library uses them.  I have actually byte aligned these pairs to $CC/$CD, $CE/$CF in current source, but they were still starting at $CB when I documented this.

Now there are two files to be included in the main source.  The defines come at the beginning, and the functions come at the end.  The functions should come AFTER the programs main code since the assembler will set the default run address to be the beginning of the code.  You don’t want the first instruction of the first function in the file to be the first line executed.  This is different than other languages like C where includes typically come first.  The updated “INPUTSTR.M65” file is:

10    *= $3600
20    .INCLUDE #D2:DEFINES.LIB
0300 ; Test printing
0302 TEST
0310    LDA #SCLR/256
0312    LDX #SCLR&255
0314    JSR PRTCH
0320    LDX #0
0322    LDY #0
0324    JSR CURXY
0326    LDA #SRULE/256
0328    LDX #SRULE&255
0330    JSR PRTCH
0340    LDX #0
0350    LDY #2
0360    JSR CURXY
0370    LDA #SP1/256
0380    LDX #SP1&255
0390    JSR PRTCH
0430    LDA #VSNAME/256
0440    LDX #VSNAME&255
0450    JSR INPSTR
0460    LDX #0
0470    LDY #4
0480    JSR CURXY
0490    LDA #SP2/256
0500    LDX #SP2&255
0510    JSR PRTCH
0520    LDA #VSNAME/256
0530    LDX #VSNAME&255
0540    JSR PRTCH
0550    LDA #SWELC/256
0560    LDX #SWELC&255
0570    JSR PRTCH
0580    RTS 
010000 ; String Data
010001 SCLR .BYTE CLS
010002 SRULE .BYTE "-| Hello |------------------------",EOS
010005 SP1 .BYTE "Name? ",EOS
010010 SP2 .BYTE "Hello ",EOS
010020 SWELC .BYTE ", Welcome!",EOS
010050 VSNAME *= *+30
063500    .INCLUDE #D2:A8FUNCS.LIB
064000    .END

 

Breakdown

Now let’s break down the changes.

  • Line 20: This single include replaced lines 20 through 82 in the previous source.  The include pulls the file “DEFINES.LIB” into the source during assembly.
  • Line 63500: This single include replaced lines 5000 through 7160 in the previous source.  The include pulls the file “A8FUNCS.LIB” into the source during assembly.  Remember we don’t want these executing unless called by the main program, so we pull them in last.
  • Line 64000: Previously line 15000.  I moved it to one of the last acceptable line numbers.  This just tells the assembler there is nothing more to build.

 

Assembly and Testing

By using the assemblers ability to dump the object listing to a printer (or file), I see that it is assembled correctly.

0000 10 *= $3600
 20 .INCLUDE #D2:DEFINES.LIB
 10 ; Defines
 =E456 20 CIOV = $E456
 =0340 30 ICHID = $0340 ;IOCB 0 S:
 =0342 40 ICCOM = $0342 ;IOCB Command
 =0344 50 ICBAL = $0344 ;Xfer Buffer Adr
 =0345 60 ICBAH = $0345
 =0348 70 ICBLL = $0348 ;Buffer Len
 =0349 80 ICBLH = $0349
 =0054 90 ROWCRS = 84
 =0055 0100 COLCRS = 85
 =009B 0110 EOL = $9B
 =0000 0120 EOS = $00
 =007D 0130 CLS = $7D
 0300 ; Test printing
3600 0302 TEST
3600 A936 0310 LDA #SCLR/256
3602 A247 0312 LDX #SCLR&255
3604 20A636 0314 JSR PRTCH
3607 A200 0320 LDX #0
3609 A000 0322 LDY #0
360B 20CE36 0324 JSR CURXY
360E A936 0326 LDA #SRULE/256
3610 A248 0328 LDX #SRULE&255
3612 20A636 0330 JSR PRTCH
3615 A200 0340 LDX #0
3617 A002 0350 LDY #2
3619 20CE36 0360 JSR CURXY
361C A936 0370 LDA #SP1/256
361E A26E 0380 LDX #SP1&255
3620 20A636 0390 JSR PRTCH
3623 A936 0430 LDA #VSNAME/256
3625 A287 0440 LDX #VSNAME&255
3627 20D336 0450 JSR INPSTR
362A A200 0460 LDX #0
362C A004 0470 LDY #4
362E 20CE36 0480 JSR CURXY
3631 A936 0490 LDA #SP2/256
3633 A275 0500 LDX #SP2&255
3635 20A636 0510 JSR PRTCH
3638 A936 0520 LDA #VSNAME/256
363A A287 0530 LDX #VSNAME&255
363C 20A636 0540 JSR PRTCH
363F A936 0550 LDA #SWELC/256
3641 A27C 0560 LDX #SWELC&255
3643 20A636 0570 JSR PRTCH
3646 60 0580 RTS 
 010000 ; String Data
3647 7D 010001 SCLR .BYTE CLS
3648 1204A0C8 010002 SRULE .BYTE "-| Hello |------------------------",EOS
364C E5ECECEF
3650 A0011212
3654 12121212
3658 12121212
365C 12121212
3660 12121212
3664 12121212
3668 12121212
366C 1200
366E 4E616D65 010005 SP1 .BYTE "Name? ",EOS
3672 3F2000
3675 48656C6C 010010 SP2 .BYTE "Hello ",EOS
3679 6F2000
367C 2C205765 010020 SWELC .BYTE ", Welcome!",EOS
3680 6C636F6D
3684 652100
3687 010050 VSNAME *= *+30
 063500 .INCLUDE #D2:A8FUNCS.LIB
 0100 ; Storage & Pointers
36A5 0110 PRINDX *= *+1
 =00CB 0120 PRSPTR = $CB
 =00CD 0130 INSPTR = $CD
 5000 ; Print Subroutine
36A6 5005 PRTCH
 5010 ; Store Starting String Address
36A6 86CB 5015 STX PRSPTR
36A8 85CC 5020 STA PRSPTR+1
36AA A900 5030 LDA #$00
36AC 8DA536 5040 STA PRINDX
 5050 ; Set IOCB Command
36AF A200 5052 LDX #$00
36B1 A90B 5055 LDA #$0B
36B3 9D4203 5060 STA ICCOM,X
 5070 ; Set Max Buffer Length
36B6 A900 5072 LDA #$00
36B8 9D4803 5080 STA ICBLL,X
36BB 9D4903 5090 STA ICBLH,X
 5100 ; Call CIO to Print
36BE ACA536 5105 PRCHLP LDY PRINDX
36C1 B1CB 5108 LDA (PRSPTR),Y
36C3 F008 5115 BEQ PRCHDN
36C5 2056E4 5116 JSR CIOV
36C8 EEA536 5120 INC PRINDX
36CB D0F1 5130 BNE PRCHLP
36CD 60 5140 PRCHDN RTS 
 6000 ; Position Subroutine
36CE 6005 CURXY
36CE 8655 6010 STX COLCRS
36D0 8454 6020 STY ROWCRS
36D2 60 6030 RTS 
 7000 ; Input String
36D3 7005 INPSTR
 7010 ; Store Starting String Address
36D3 8E4403 7015 STX ICBAL
36D6 8D4503 7020 STA ICBAH
 7030 ; Store Str Address in P0 Ptr
36D9 86CD 7035 STX INSPTR
36DB 85CE 7040 STA INSPTR+1
 7050 ; Set IOCB Command
36DD A200 7052 LDX #$00
36DF A905 7055 LDA #$05 ; Get Record
36E1 9D4203 7060 STA ICCOM,X
 7070 ; Set Max Buffer Length
36E4 A91E 7072 LDA #30
36E6 9D4803 7080 STA ICBLL,X
36E9 A900 7085 LDA #0
36EB 9D4903 7090 STA ICBLH,X
 7100 ; Call CIO to Print
36EE 2056E4 7110 JSR CIOV
 7115 ; Get # chars input
36F1 AC4803 7120 LDY ICBLL
 7130 ; Reduce char count by 1
36F4 88 7135 DEY 
 7140 ; Store EOS at EOL position
36F5 A900 7145 LDA #EOS
36F7 91CD 7150 STA (INSPTR),Y
36F9 60 7160 RTS 
36FA 064000 .END
ASSEMBLY ERRORS: 0 28950 BYTES FREE

SYMBOLS
=E456 CIOV =007D CLS =0055 COLCRS 36CE CURXY
=009B EOL =0000 EOS 
=0345 ICBAH =0344 ICBAL =0349 ICBLH =0348 ICBLL 
=0342 ICCOM =0340 ICHID 36D3 INPSTR =00CD INSPTR 
 36CD PRCHDN 36BE PRCHLP 36A5 PRINDX =00CB PRSPTR 
 36A6 PRTCH 
=0054 ROWCRS 
 3647 SCLR 366E SP1 3675 SP2 3648 SRULE 
 367C SWELC 
 3600 TEST 
 3687 VSNAME

And jumping back out to DOS and testing it reveals it worked properly just like the last time:

6502 Assembly Input String Test

Now back to solving my other code problems…

 

6502, String Input

Posted by Ripdubski on 2014.05.27
Posted in: Atari, Programming. Tagged: , , , , , . 2 Comments

Now that I’ve been successful in printing strings in whole and character by character, I thought the next logical step would be to get a string from the user.  This post deals specifically with that.  I use the CIO routine Get Record ($05) to accomplish it.  I also introduce a new instruction.  Let’s get to it.

 

Instructions

I only introduce one new instruction this time.  It is:

  • DEY – DEcrement the Y register.  This reduces the value in the Y register by 1.

 

Source Code

10     *= $3600
20   PRSPTR = $CB
21   INSPTR = $CD
39 ; Defines
70   CIOV = $E456
71   ICHID = $0340 ;IOCB 0 S:
72   ICCOM = $0342 ;IOCB Command
73   ICBAL = $0344 ;Xfer Buffer Adr
74   ICBAH = $0345
75   ICBLL = $0348 ;Buffer Len
76   ICBLH = $0349
77   ROWCRS = 84
78   COLCRS = 85
80   EOL = $9B
81   EOS = $00
82   CLS = $7D
300 ; Test printing
302 TEST
310   LDA #SCLR/256
312   LDX #SCLR&255
314   JSR PRTCH
320   LDX #0
322   LDY #0
324   JSR CURXY
326   LDA #SRULE/256
328   LDX #SRULE&255
330   JSR PRTCH
340   LDX #0
350   LDY #2
360   JSR CURXY
370   LDA #SP1/256
380   LDX #SP1&255
390   JSR PRTCH
430   LDA #VSNAME/256
440   LDX #VSNAME&255
450   JSR INPSTR
460   LDX #0
470   LDY #4
480   JSR CURXY
490   LDA #SP2/256
500   LDX #SP2&255
510   JSR PRTCH
520   LDA #VSNAME/256
530   LDX #VSNAME&255
540   JSR PRTCH
550   LDA #SWELC/256
560   LDX #SWELC&255
570   JSR PRTCH
580   RTS 
5000 ; Print Subroutine
5005 PRTCH
5010 ; Store Starting String Address
5015   STX PRSPTR
5020   STA PRSPTR+1
5030   LDA #$00
5040   STA PRINDX
5050 ; Set IOCB Command
5052   LDX #$00
5055   LDA #$0B
5060   STA ICCOM,X
5070 ; Set Max Buffer Length
5072   LDA #$00
5080   STA ICBLL,X
5090   STA ICBLH,X
5100 ; Call CIO to Print
5105 PRCHLP LDY PRINDX
5108   LDA (PRSPTR),Y
5115   BEQ PRCHDN
5116   JSR CIOV
5120   INC PRINDX
5130   BNE PRCHLP
5140 PRCHDN RTS 
6000 ; Position Subroutine
6005 CURXY
6010   STX COLCRS
6020   STY ROWCRS
6030   RTS 
7000 ; Input String
7005 INPSTR
7010 ; Store Starting String Address
7015   STX ICBAL
7020   STA ICBAH
7050 ; Set IOCB Command
7052   LDX #$00
7055   LDA #$05 ; Get Record
7060   STA ICCOM,X
7070 ; Set Max Buffer Length
7072   LDA #30
7080   STA ICBLL,X
7085   LDA #0
7090   STA ICBLH,X
7100 ; Call CIO to Input
7110   JSR CIOV
7160   RTS 
10000 ; String Data
10001 SCLR .BYTE CLS
10002 SRULE .BYTE "012345678901234567890123456789012345",EOS
10005 SP1 .BYTE "Name? ",EOS
10010 SP2 .BYTE "Hello ",EOS
10020 SWELC .BYTE ", Welcome!",EOS
10050 VSNAME *= *+30
10060 PRINDX *= *+1
15000   .END

 

Breakdown

As usual I am only going to document what is different.

  • Lines 310 to 390: Clear the screen, print the ruler, print the input prompt “Name? “.
  • Lines 430 to 450: Load the Accumulator and X register with the high and low bytes of the input string address, then call the input subroutine identified by label INPSTR.
  • Lines 460 to 570: Print the “Hello ” message, followed by the input string, followed by “, Welcome!”.
  • Line 580: Return (end of program)
  • Lines 5000 to 5140: The print string routine that prints character by character rather than the whole string as previously written about.
  • Lines 6000 to 6030: The cursor positioning routine as previously written about.
  • Line 7005: Start of the input string sub routine, labelled with INPSTR.
  • Line 7015 to 7020: Store the string address high and lowe bytes into ICBAL and ICBAH (the IOCB string address).
  • Line 7052: Load the X register with 0 to reflect IOCB 0.
  • Line 7055: Load the Accumulator with 5, the IOCB command for get record.
  • Line 7060: Store the Accumulator in the IOCB’s command address.
  • Line 7072: Load the Accumulator with 30.  This is the maximum number of characters that will be accepted.
  • Line 7080: Store the Accumulator in the IOCB’s buffer length low byte address (ICBLL).
  • Line 7085: Load the Accumulator with 0.  This only needs to be defined if the maximum string length is greater than 255.
  • Line 7090: Store the Accumulator in the IOCB’s buffer length high byte address (ICBLH).
  • Line 7110: Call the CIO routine to get the input.
  • Line 7160: Return from the subroutine.
  • Line 10050: This is the input string address.  Reserving 30 bytes.
  • Line 10060:  This is the print character index.  Reserving 1 byte.  I moved it from the beginning of the code to the end.

 

Assembly

After it is assembled and run, the program asks for your name.  Enter a name and it is echo’d back with a welcome message:

6502 Input String Prompt

Output and EOL Problem

As you can see from the output below there is a slight problem.  When the user terminates the input with the Return key, EOL (155 / $9B) is added to the end of the string.  So when it prints, an unexpected result is the cursor is moved to left most column on next row causing the next thing printed to be in the wrong location:

6502 Input String EOL added

Since this is not desirable I had to revise the input routine slightly.  After the input call, I load the Y register with the value in ICBLL, which is the number of characters actually input.  Because the count includes the Return key, I decrement the value, then store and EOS (0) at the string address offset by the Y register value.  This is a pointer operation so I needed another 2 bytes in page zero to store the address.  I chose $CD.

 

Source Code – Revised

In the above listing, the highlighted lines reflect updates to the first source code listing.

10   *= $3600
20 PRSPTR = $CB
21 INSPTR = $CD
39 ; Defines
70 CIOV = $E456
71 ICHID = $0340 ;IOCB 0 S:
72 ICCOM = $0342 ;IOCB Command
73 ICBAL = $0344 ;Xfer Buffer Adr
74 ICBAH = $0345
75 ICBLL = $0348 ;Buffer Len
76 ICBLH = $0349
77 ROWCRS = 84
78 COLCRS = 85
80 EOL = $9B
81 EOS = $00
82 CLS = $7D
300 ; Test printing
302 TEST
310   LDA #SCLR/256
312   LDX #SCLR&255
314   JSR PRTCH
320   LDX #0
322   LDY #0
324   JSR CURXY
326   LDA #SRULE/256
328   LDX #SRULE&255
330   JSR PRTCH
340   LDX #0
350   LDY #2
360   JSR CURXY
370   LDA #SP1/256
380   LDX #SP1&255
390   JSR PRTCH
430   LDA #VSNAME/256
440   LDX #VSNAME&255
450   JSR INPSTR
460   LDX #0
470   LDY #4
480   JSR CURXY
490   LDA #SP2/256
500   LDX #SP2&255
510   JSR PRTCH
520   LDA #VSNAME/256
530   LDX #VSNAME&255
540   JSR PRTCH
550   LDA #SWELC/256
560   LDX #SWELC&255
570   JSR PRTCH
580   RTS 
5000 ; Print Subroutine
5005 PRTCH
5010 ; Store Starting String Address
5015   STX PRSPTR
5020   STA PRSPTR+1
5030   LDA #$00
5040   STA PRINDX
5050 ; Set IOCB Command
5052   LDX #$00
5055   LDA #$0B
5060   STA ICCOM,X
5070 ; Set Max Buffer Length
5072   LDA #$00
5080   STA ICBLL,X
5090   STA ICBLH,X
5100 ; Call CIO to Print
5105 PRCHLP LDY PRINDX
5108   LDA (PRSPTR),Y
5115   BEQ PRCHDN
5116   JSR CIOV
5120   INC PRINDX
5130   BNE PRCHLP
5140 PRCHDN RTS 
6000 ; Position Subroutine
6005 CURXY
6010   STX COLCRS
6020   STY ROWCRS
6030   RTS 
7000 ; Input String
7005 INPSTR
7010 ; Store Starting String Address
7015   STX ICBAL
7020   STA ICBAH
7030 ; Store Str Address in P0 Ptr
7035   STX INSPTR
7040   STA INSPTR+1
7050 ; Set IOCB Command
7052   LDX #$00
7055   LDA #$05 ; Get Record
7060   STA ICCOM,X
7070 ; Set Max Buffer Length
7072   LDA #30
7080   STA ICBLL,X
7085   LDA #0
7090   STA ICBLH,X
7100 ; Call CIO to Input
7110   JSR CIOV
7115 ; Get # chars input
7120   LDY ICBLL
7130 ; Reduce char count by 1
7135   DEY 
7140 ; Store EOS at EOL position
7145   LDA #EOS
7150   STA (INSPTR),Y
7160   RTS 
10000 ; String Data
10001 SCLR .BYTE CLS
10002 SRULE .BYTE "012345678901234567890123456789012345",EOS
10005 SP1 .BYTE "Name? ",EOS
10010 SP2 .BYTE "Hello ",EOS
10020 SWELC .BYTE ", Welcome!",EOS
10050 VSNAME *= *+30
10060 PRINDX *= *+1
15000   .END

 

Breakdown

  • Line 21: Sets the location for the INput String PoinTeR labelled as INSPTR to page zero address $CD.
  • Line 7035 to 7040: Store the string address in the pointer location INSPTR.
  • Line 7120: Load the Y register with the value in ICBLL.  ICBLL holds the actual number of characters input after the CIO call completes.
  • Line 7135: Decrement the Y register.  The number of characters input includes the return key which I don’t want.
  • Line 7145: Load the Accumulator with EOS (0).
  • Line 7150: Store the value in the Accumulator in the input string address offset by the Y register.  This will be the location of the Return (EOL / $9B).  This basically turns the EOL into EOS.  It uses indirect indexed addressing to get the actual string address stored in the location referenced (a pointer).

 

Final Assembly

After assembling the program with the changes above, running it produces the correct results.

First input your name, then it prints its back with a welcome message – correctly:

6502 Input String Printed

 

 

Another success!  Hrm, what to do next…

6502, Printing, Pointers, and Subroutines

Posted by Ripdubski on 2014.05.23
Posted in: Atari, Programming. Tagged: , , , , , , . 1 Comment

Previously I created a subroutine to print a string (6502, Print via Subroutine) that works just fine.  It prints an entire string in one CIO call.  However, it always puts an end of line (EOL) character at the end, thus moving the cursor to the next row and left-most column.  Thats fine most of time, but there are times when you want to display something right after something else – like “Score: xxx”.  You could build the string then print it out, or you could just print each component separately.  Or maybe you want to print something and have the cursor remain at the next print position – like an input form “Name? “.

I set out to print a string one character at a time and not end up with the EOL.  Printing one character at a time means calling CIO over and over which is much slower than the previous print method I used.  But it does have an one advantage in that it allows you to do something with each character such as make a sound (click click click).  I thought it would be easy to convert the print string subroutine to do it character by character; it was not.  In completing this task I learned about assembly pointers and the importance of page zero (first 256 bytes of memory) addresses.  I had to read a lot and got some helpful explanations from members of AtariAge (http://www.atariage.com).

 

Instructions

This involves the following instructions; some new, and some recent that I didn’t document before:

  • LDX – LoaD the X register with a value.
  • LDY – LoaD the Y register with a value.
  • STX – STore the X register value in a location.
  • STY – STore the Y register value in a location.
  • BEQ – Branch if EQual.  Alters run location if the processors zero flag is set, otherwise nothing happens.
  • BNE – Branch if Not Equal.  Alters run location if the processors zero flag is clear, otherwise nothing happens.
  • .BYTE – Directive telling the Assembler a data byte (or more) is coming.

In this exercise I also created a subroutine to position the cursor.  It adds a few bytes of code to the overall size for this example.  I examined code size after adding successive calls.  Having it in a subroutine starts paying off at the fifth call.

 

The Code

10 *= $3600
15 PRINDX = *+1
20 PRSPTR = $CB
39 ; Defines
70 CIOV = $E456
71 ICHID = $0340 ;IOCB 0 S:
72 ICCOM = $0342 ;IOCB Command
73 ICBAL = $0344 ;Xfer Buffer Adr
74 ICBAH = $0345
75 ICBLL = $0348 ;Buffer Len
76 ICBLH = $0349
77 ROWCRS = 84
78 COLCRS = 85
80 EOL = $9B
81 EOS = $00
82 CLS = $7D
0300 ; Test printing
0302 TEST
0310   LDA #SCLR/256
0312   LDX #SCLR&255
0314   JSR PRTCH
0320   LDX #0
0322   LDY #0
0324   JSR CURXY
0326   LDA #SRULE/256
0328   LDX #SRULE&255
0330   JSR PRTCH
0340   LDX #0
0350   LDY #2
0360   JSR CURXY
0370   LDA #SHI/256
0380   LDX #SHI&255
0390   JSR PRTCH
0430   LDA #SBYE/256
0440   LDX #SBYE&255
0450   JSR PRTCH
0460   RTS 
5000 ; Print Subroutine
5005 PRTCH
5010 ; Store Starting String Address
5015   STX PRSPTR
5020   STA PRSPTR+1
5030   LDA #$00
5040   STA PRINDX
5050 ; Set IOCB Command
5052   LDX #$00
5055   LDA #$0B
5060   STA ICCOM,X
5070 ; Set Max Buffer Length
5072   LDA #$00
5080   STA ICBLL,X
5090   STA ICBLH,X
5100 ; Call CIO to Print
5105 PRCHLP LDY PRINDX
5108   LDA (PRSPTR),Y
5115   BEQ PRCHDN
5116   JSR CIOV
5120   INC PRINDX
5130   BNE PRCHLP
5140   PRCHDN RTS 
6000 ; Position Subroutine
6005 CURXY
6010   STX COLCRS
6020   STY ROWCRS
6030   RTS 
010000 ; String Data
010001 SCLR .BYTE CLS
010002 SRULE .BYTE "012345678901234567890123456789",EOS
010005 SHI .BYTE "Hello World: ",EOS
010010 SBYE .BYTE "Goodbye!",EOS

 

Breakdown

Again I won’t break down every line, just the ones that are new concepts.  Line 5108 is the magic of the print routine.  It requires the page zero address to work, which is noted by line 20.

  • Line 15:  Reserves one byte of memory in a location named PRINDX.  Because the program origin is set to $3600 in line 10, the address of PRINDX will be $3601.
  • Line 20: Assigns $CB to PRSPTR.  This is the page zero address I use to store the string address to be printed.  A pointer – it points to the real string address in memory.  A page zero address is needed for the “LDA (addr),Y” command which uses Indexed Indirect addressing.
  • Lines 70 to 76: Definitions for CIO and IOCB addresses.
  • Lines 77 and 78: Definitions for cursor ROW and COLumn memory addresses.
  • Lines 80 to 82: Definitions related to printing strings.
  • Lines 310 to 314: Loads the Accumulator and X register with the address of the string to be printed (SCLR) and calls the print subroutine (PRTCH).
  • Lines 320 to 324: Loads the X and Y registers with the desired screen coordinates, then calls the cursor position subroutine (CURXY).
  • Lines 326 to 330: Loads the Accumulator and X register with the address of the string to be printed (SRULE) and calls the print subroutine (PRTCH).
  • Lines 340 to 360: Loads the X and Y registers with the desired screen coordinates, then calls the cursor position subroutine (CURXY).
  • Lines 370 to 390: Loads the Accumulator and X register with the address of the string to be printed (SHI) and calls the print subroutine (PRTCH).
  • Lines 430 to 450: Loads the Accumulator and X register with the address of the string to be printed (SBYE) and calls the print subroutine (PRTCH).
  • Line 5005: Start of the print char string routine.  This prints the string one character at a time up to the end of string (0).
  • Lines 5015 and 5025: Store the address bytes of the string to be printed (from the Accumulator and X register) in the page zero pointer location ($CB).
  • Lines 5030 and 5040: Load the accumulator with 0 and store it in the PRINDX location.  This will be the value of the current character position within the string.
  • Lines 5052 to 5060: Load the X register with 0 and Accumulator with 11 ($0B).  $0B is the IOCB command to print a buffer.  Store $0B in the IOCB command address.
  • Lines 5072 to 5090: Load the Accumulator with 0 and store it in the IOCB buffer length addresses.  If the value is 0 only 1 character is printed.  The character to be printed must be loaded into the Accumulator prior to calling CIO.
  • Line 5105: This is the start of the print loop.  Each character to be printed will pass through this loop.  First the Y register is loaded with the current index that was stored in PRINDX.
  • Line 5108: Load the Accumulator with the value of the address pointed to by the contents of location PRSPTR, but offset by the current print index (the value in the Y register).
  • Line 5115: If the value loaded was 0 the string is done, so branch to the end of the print subroutine (location PRCHDN).
  • Line 5116: Everything is setup to print, call CIO to make it happen.
  • Line 5120: Increment the current print index position (value in location PRINDX) by one.
  • Line 5130: Jump back to the top of the loop to print the next character.
  • Line 5140: End of the print subroutine, labeled with PRCHDN.  Issue RTS and control returns to line following the JSR that initiated the PRTCH subroutine.
  • Line 6005: Start of the cursor position subroutine.
  • Line 6010: Store the value in the X register into the cursor column address.
  • Line 6020: Store the value in the Y register into the cursor row address.
  • Line 6030: End of the cursor position subroutine.  Issue RTS and control returns to the line following the JSR that initiated the PRTCH subroutine.
  • Line 10001 to 10010: String data used for output.

 

Assembly

After assembly with Mac/65, I drop back to DOS (SpartaDOS), then execute the program (assembled as “PRINTCH.COM”).  As you can see in this screen shot, it works.  The screen is cleared, then the ruler line is printed at 0,0 (upper left).  Then 2 lines down “Hello World: ” is printed, followed by “Goodbye!”.

6502 Print Char

 

What to tackle next?  Hrm…

 

6502, Atari Preference Utility, Version 1.0.0

Posted by Ripdubski on 2014.05.14
Posted in: Atari, Programming. Tagged: , , , , , . Leave a comment

Now that I have a working print subroutine I wanted to incorporate it into the preferences program I created in the “6502, Branching Out” post.  This new listing updates my PREFS program to print out some useful messages during runtime, and of course uses the new print subroutine.

Code

10 .OPT OBJ
20 *= $3600
39 ; Defines
40 NOISE = 65
50 RMARG = 82
51 CFORE = 709
52 CBACK = 710
53 KDELY = 729
54 KRATE = 730
55 CLICK = 731
60 OSNEW = $FFF7
61 OSOLD = $FFF8
70 CIOV = $E456
71 ICHID = $0340 ; IOCB 0 S:
72 ICCOM = $0342 ; IOCB Command
73 ICBAL = $0344 ; Xfer Buffer Adr
74 ICBAH = $0345
75 ICBLL = $0348 ; Buffer Len
76 ICBLH = $0349
80 EOL = $9B
82 CLS = $7D
98 ;
99 ; Identify Self
110 LDA #STITLE/256
112 LDY #STITLE&255
114 JSR PRINT
297 ;
298 ; Set universal OS stuff
299 ;
300 ; Print activity
302 LDA #SSETU/256
304 LDY #SSETU&255
306 JSR PRINT
310 ; Set left margin to 0
312 LDA #0
314 STA RMARG
320 ; Set background color
322 LDA #4
324 STA CBACK
330 ; Set text color
332 LDA #$0C
334 STA CFORE
340 ; Noisy I/O Off
342 LDA #0
344 STA NOISE
498 ;
499 ; Do XL/XE section?
500 ; XLXE OS R1,R2,R3,R4
502 LDA OSNEW
504 CMP #5
506 BCC XLXE
510 ; XLXE OS R10
512 LDA OSNEW
514 CMP #10
516 BEQ XLXE
520 ; XLXE OS R11
522 LDA OSNEW
524 CMP #11
526 BEQ XLXE
530 ; No Match
532 JMP DONE
999 ;
1000 XLXE
1010 ; Print XLXE Message
1012 LDA #SXLXE/256
1014 LDY #SXLXE&255
1016 JSR PRINT
1020 ; Set key repeat rate
1022 LDA #2
1024 STA KRATE
1030 ; Set key delay
1032 LDA #14
1034 STA KDELY
1040 ; No key click
1042 LDA #1
1044 STA CLICK
1898 ;
1899 ; Program Done
1900 DONE
1910 ; Print Done Message
1912 LDA #SDONE/256
1914 LDY #SDONE&255
1916 JSR PRINT
1920 ; Exit
1922 RTS
4999 ;
5000 ; Print Subroutine
5005 PRINT
5010 ; Store Starting String Address
5015 LDX #$00
5020 STA ICBAH,X
5030 TYA 
5040 STA ICBAL,X
5050 ; Set IOCB Command
5055 LDA #$09
5060 STA ICCOM,X
5070 ; Set Max Buffer Length
5072 LDA #$FF
5080 STA ICBLH,X
5090 STA ICBLL,X
5100 ; Call CIO to Print
5105 JSR CIOV
5120 RTS 
9999 ;
10000 ; String Data
10005 STITLE .BYTE CLS,"Atari 8 Preference Setter",EOL
10010 SSETU .BYTE "Setting universal preferences...",EOL
10020 SXLXE .BYTE "Setting XL/XE preferences...",EOL
10030 SDONE .BYTE "Done!",EOL

 

Breakdown

I’m not going to break down every line since they have all been covered at some point already.  I will detail what sections of code are doing though.

Line 10 tells Mac/65 to produce object code.

Lines 20 tells the assembler where to place the code in memory.

Lines 40 to 82 setup various definitions for the assembler which make coding easier.

Lines 100 to 114 are used to display the title of the program which is the string pointed to by STITLE at line 10005 (“Atari 8 Preference Setter”).

Lines 300 to 344 are the universal settings sections.  The settings here apply to all flavors of the Atari OS and are applied regardless of which machine the program is running on.

Lines 500 to 526 are the OS detection routine.  If any of the checks succeed, control is passed to the XL/XE settings section of code which handles setting XL/XE specific settings.

Lines 530 to 532 pass control to the DONE section of code, which handles the program exit.

Lines 1000 to 1044 are the XL/XE settings section.  It only gets executed if an XL or XE machine is detected.

Lines 1900 to 1922 are the last section of code to execute before the program stops.  It prints the word “Done!” and exits.

Lines 5000 to 5120 are the screen print subroutine.

Lines 10000 to 10030 are the string data that gets printed to the screen.

 

Assembly

I saved it as “A8PREFS.M65”, and assembled it as “A8PREFS.COM”.  I then set about testing it on 400/800 OS revision A, 400/800 OS revision B,  Atari 800 XL OS, and Atari 130 XE OS.  Since I’m using SpartaDOS with Mac/65 I had to copy A8PREFS.COM to another normal (90K) disk and boot the 400/800 machines with OSS DOS XL v2.2 since SpartaDOS v3.2g will not run on them.

Screen grab from it running on a 400/800 machine with OS revision A:

6502 Atari 400/800 OSA Prefs

Screen grab from it running on a 400/800 machine with OS revision B:

6502 Atari 400/800 OSB Prefs

Screen grab from it running on an 800 XL machine:

6502 Atari 800 XL Prefs

Screen grab from it running on an 130 XE machine:

6502 Atari 130 XE Prefs

 

Summary

It works exactly as I want – almost.  Notice the output when running on an XL/XE machine.  The word “Done” is printed at column 0 while the other text remains in column 2.  Next I need to write a subroutine to position the cursor and spruce up the output a bit.

 

6502, Print via Subroutine

Posted by Ripdubski on 2014.05.13
Posted in: Atari, Programming. Tagged: , , , , , , , , , . Leave a comment

Getting screen output using Assembly was plenty hard enough.  Getting a printing subroutine was even tougher.  I don’t want to litter my programs with the same code over and over every time I want to print.  So I looked for a way to set the printing commands into a useful re-usable routine.  If your program prints more than one time to the screen, it becomes beneficial to have a printing subroutine.  It saves memory, both source and assembled.  And, with these old 48K to 128K (8 bit) machines, every byte counts.

In BASIC and many other languages printing is very simple and there generally isn’t a need to make it into a subroutine unless you are doing something else along with the printing.

 

Instructions

To accomplish this milestone I had to read, a lot!  I had to learn about using JSR and RTS, the assembly equivalents of GOSUB and RETURN, and how the 6502 manages the stack.  Ultimately the most valuable resource were the Boot Camp articles by Tom Hudson published in A.N.A.L.O.G magazine, specially the late 1985 and early 1986 issues.

The JSR and RTS instructions are defined below:

  • JSR : Jump to SubRoutine.   Causes program execution to continue at the address specified as the operand of the JSR instruction.  The routine pointed to should be terminated with an RTS so the instruction following the JSR will be executed when the subroutine is complete.
  • RTS : ReTurn from Subroutine.  Causes program execution to resume at the first instruction that follows the calling JSR.

 

Sample Code

This is the small program I wrote that uses a subroutine to accomplish the printing.  Following the code, I detail what it does.  Again, I am using the OSS Mac/65 assembler.

05 .OPT OBJ
10 *= $3600
39 ; Defines
70 CIOV = $E456
71 ICHID = $0340 ;IOCB 0 S:
72 ICCOM = $0342 ;IOCB Command
73 ICBAL = $0344 ;Xfer Buffer Adr
74 ICBAH = $0345
75 ICBLL = $0348 ;Buffer Len
76 ICBLH = $0349
77 PRTREC = $09 ; Print Record Cmd
78 MAXLEN = $FF ; Max String Len
80 EOL = $9B
82 CLS = $7D
0300 ; Test printing
0305 ; Print clear screen followed by "Hello World!"
0310  LDA #SHI/256
0320  LDY #SHI&255
0330  JSR PRINT
0335 ; Print "Goodbye World!"
0340  LDA #SBYE/256
0350  LDY #SBYE&255
0360  JSR PRINT
0370  RTS
5000 ; Print Subroutine
5005 PRINT
5010 ; Store Starting String Address
5015  LDX #$00
5020  STA ICBAH,X
5030  TYA
5040  STA ICBAL,X
5050 ; Set IOCB Command
5055  LDA #PRTREC
5060  STA ICCOM,X
5070 ; Set Max Buffer Length
5075  LDA #MAXLEN
5080  STA ICBLH,X
5090  STA ICBLL,X
5100 ; Call CIO to Print
5105  JSR CIOV
5110  RTS
10000 ; String Data
10005 SHI .BYTE CLS,"Hello World!",EOL
10010 SBYE .BYTE "Goodbye World!",EOL

 

Breakdown

Lines 5 and 10: Tell Mac/65 to generate code, and define the location in memory to assemble to ($3600).

Lines 70 to 76: Definitions for the CIO and IOCB addresses used by the print routine.

Lines 77, 78: IOCB value definitions.

Lines 80 to 82: Definitions used in the strings to be printed.

Lines 310, 320: Load the Accumulator with the high byte of the string (to be printed) address.  Load the Y register with the low byte of the string address.

Line 330: Call the print subroutine.

Lines 340, 350: Load the Accumulator with the high byte of the string (to be printed) address.  Load the Y register with the low byte of the string address.

Line 360: Call the print subroutine.

Line 370: Leave the program

Line 5005: Label the starting address of the print subroutine.

Line 5015: Load X register with 0.

Line 5020: Store the Accumulator value (which holds the strings address high byte) into the IOCB string buffer address high byte.

Line 5030: Transfer the Y register (which holds the strings address low byte) to the Accumulator.

Line 5040: Store the Accumulator value into the IOCB string buffer address low byte.

Line 5055: Load the Accumulator with 9, the IOCB print record command value.

Line 5060: Store the Accumulator value into the IOCB command address.

Line 5075: Load the Accumulator with value $FF (255).  This will be the max size for the string to be printed.

Line 5080,5090: Store the Accumulator value into the IOCB buffer length address high and low bytes.

Line 5105: Call the CIO routine.  It will use the IOCB information that was just setup, causing the string the be printed until either 255 characters are reached or EOL ($9B) (155) is encountered.

Line 5110: Return from the print subroutine.

Lines 10005, 10010: The strings to be printed, with labels, both terminated with EOL ($9B) (155).

 

Assembling and Running

After the code has been entered and ready to assemble:

6502 Print Subroutine Code

 

I assembled the code using “ASM ,,#D2:PRINTSUB.COM” to generate the compiled version.  Look ma, no errors!

6502 Print Subroutine Assembled

 

Now, I’ve exited to DOS (SpartaDOS) and about to run the assembled program:

6502 Print Subroutine Run

And the results.  Notice the screen was cleared as well due to the inclusion of the CLS ($7D) (125) character in the first string:

6502 Print Subroutine Output

 

Accomplishing the Same Thing in BASIC

With BASIC, the same outcome can be accomplished with this.  It’s a lot simpler, but not nearly as efficient in machine cycles.

10 PRINT CHR$(125);"Hello World!"
20 PRINT "Goodbye World!"

 

Next

Now to incorporate the subroutine into my preferences program!

 

 

 

 

6502, Displaying Text – Finally!

Posted by Ripdubski on 2014.04.25
Posted in: Atari, Programming. Tagged: , , , , , , , , . Leave a comment

I’ve been eager to get something displayed on the screen using 6502 assembly language.  The task has been quite difficult, but I finally got it.  I ended reading  large sections of the following books before getting a handle on the task:

  • Atari Roots by Mark Andrews (1984)
  • Assembly Language Programming for the Atari Computers by Mark Chasin (1984)

And, although I read this one many times almost 30 years ago, I re-read the entire thing with special focus on the IOCB vectors:

  • Mapping The Atari (Revised) by Ian Chadwick (1985)

I found the most benefit from “Assembly Language Programming for the Atari Computers”, and “Mapping The Atari”.  I managed to get a single character on the screen using OS vectors documented in the latter.  Full strings of text were elusive until I started reading sections of the former.  I highly recommend both of these for the beginning Atari Assembly language programmer.

 

From BASIC

Printing to the screen in Assembly is not as easy as it is with BASIC.  In BASIC, printing “Hello World!” is accomplished in one line of code:

10 PRINT "Hello World!"

The BASIC PRINT command handles most of the work for you such as: opening the screen, copying the string buffer to the screen, and closing the screen.  In listed form this program takes up 24 bytes of disk space.  Since BASIC is interpreted and not compiled I do not have a “compiled” size, however it’s 56 bytes in tokenized form (on disk).

Atari BASIC Hello World

 

To Assembly

In Assembly you have to do it all.  To accomplish the task I learned about the CIO (central input/output) routines and using the IOCB (input/output control block) for the screen device.  The same Hello World program in Assembly increases from one line to fifteen lines.  The listed size is 878 bytes on disk and only 50 bytes in assembled form (on disk).

Code

Here is my Hello World assembly listing:

05     .OPT OBJ
10     *= $0600
0100 ; CIO
0110 ICHID = $0340 ;IOCB 0 S:
0120 ICCOM = $0342 ;IOCB Command
0130 ICBAL = $0344 ;Xfer Buffer Adr
0140 ICBAH = $0345
0150 ICPTL = $0346 ;PutByte Adr
0160 ICPTH = $0347
0170 ICBLL = $0348 ;Buffer Len
0180 ICBLH = $0349
0190 CIOV = $E456 ; CIO Vector
0500 ; Setup CIO Call
0510     LDX #0 ;IOCB 0
0520     LDA #9 ;Put Cmd Val
0530     STA ICCOM,X ;Set it as the cmd
0540     LDA #HELLO&255 ;Str low byte
0550     STA ICBAL,X
0560     LDA #HELLO/256 ;Str high byte
0570     STA ICBAH,X
0580     LDA #0 ;Str Len low byte
0590     STA ICBLL,X
0600     LDA #$FF ;Str Len high byte
0610     STA ICBLH,X
0620 ; Call CIO
0630     JSR CIOV
0640     RTS 
1000 HELLO .BYTE "Hello World!",$9B

 

Breakdown

So what is all that doing?  I’ll break it down by line:

  • 5: Assembler directive for Mac/65 telling it to create object output
  • 10: The memory address where the program will be assembled.  Page 6, this program is small.
  • 110-190: Assembler equates to make coding easier.
  • 510: Load the X register with 0. This is the offset reference to dictate which IOCB we want to use.  S: is already open by the OS on IOCB 0, so I use it.
  • 520: Load the accumulator with 9 which is the value of the IOCB “put record” command.
  • 530: Store the IOCB command held in the accumulator in the IOCB command byte address which is ICCOM + the value of the X register (0).
  • 540: Load the low byte of the Hello World string into the accumulator.
  • 550: Store the accumulator into the IOCB buffer address low byte.
  • 560: Load the high byte of the Hello World string into the accumulator.
  • 570: Store the accumulator into the IOCB buffer address high byte.
  • 580: Load the accumulator with 0.
  • 590: Store the accumulator into the IOCB buffer length low byte.
  • 600: Load the accumulator with 255 (FF).
  • 610: Store the accumulator into the IOCB buffer length high byte.  Buffer length will be 255 characters max.
  • 630: Call the CIO routine now that all the IOCB parameters are filled out.  The “put record” command will stop output at either the max length (in this case 255) or at the string EOL (end of line / return; 155 ($9B)).
  • 640: Return from program
  • 1000: String we want to print (Hello World!) and an EOL.

6502 Assembly Hello World

 

What did I learn?

It might be easiest to state by starting with an analogy.  Say you want start a car.  In BASIC you might do it with an easy to understand command, like:

START CAR

but in Assembly you have to explicitly give all the process steps for starting the car, like:

FIND LOCATION OF KEYS
SELECT CAR KEY
INSERT CAR KEY INTO IGNITION
APPLY BRAKE
TURN IGNITION 180 DEGREES
HOLD IGNITION UNTIL ENGINE STARTS
RELEASE IGNITION

The difference being the instructions are executed much more efficiently, and you have much more control over the starting process.  What if you needed to apply a choke, it might not be so easy in BASIC, but in Assembly you just add that step.  Assembly isn’t as hard as it looks once you understand the need to break down each task into very specific steps.

 

And with that I have officially surpassed the Assembly knowledge I had long ago and completed a task I was never before able to do!  Now its time to put screen display to work.  I’m going to add some messages to my PREFS program.