Hello World

All posts tagged Hello World

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.