Another assembler for the µKenbak-1
238 views
Skip to first unread message
Tom C
Jun 9, 2019, 1:26:59 PM6/9/19
to uken...@googlegroups.com
I see there is another assembler for the µKenbak here, but frankly I never did like the original mnemonics. So I decided to
write my own patterned after the 6800, although I used shr/shl instead of asr and asl. And I used variations of call for Jump
and Mark instead of the 6800 jsr, since the conditional jumps and subroutine calls would have the same names. Here's the
listing output for my test program for the assembler, just to show the syntax, it doesn't do anything useful:
004: 001 # Test program for uKenbak-1 assembler version 1.3 or later (6/15/19).
004: 002 # Program doesm't do anything useful, just testing syntax.
004: 003 # By default, PC will start at 4.
004: 004 # arithmetic, load/store and logical ops and addressing modes
004: 003 010 005 lbl adda #8 immediate value in decimal
006: 103 010 006 addb #010 same thing in octal
010: 024 001 007 lda b memory reference (using predefined reg b for reg transfer)
012: 235 220 008 stx (ptr) indirect reference
014: 306 204 009 ora data,x indexed
016: 337 220 010 lnega (ptr),x indirect/indexed
020: 011 # jumps and calls
020: 344 004 012 jmp lbl unconditional jump
022: 043 030 013 jane lbl2-2 jump if a not equal 0, , using arithmetic with label
024: 257 221 014 jxgt (ptr+one) jump indirect if x gt 0, using arithmetic inside ()
026: 364 041 015 call sub call to subroutine
030: 174 220 016 cbeq (ptr) call indirect to subroutine if b equal 0
032: 017 # set and skips
032: 018 lbl2
032: 122 204 019 set1 fox,2 set bit 2 of data to 1
034: 272 205 020 skp0 data+1,7 skip if bit 7 of data is 0
036: 021 # shifts and rotates
036: 001 022 shra 1+SHIFT shift a right 4 places
037: 361 023 rolb 2 rotate b left 2 places
040: 000 024 hlt halt
041: 000 025 sub db 0 leave room for return address
042: 200 026 nop no op
043: 023 222 027 lda #0222
045: 123 144 028 ldb #100
047: 360 029 sys system call (uKenbak-1 extension)
050: 023 222 030 sysp 0222,100 system call using parameters
052: 123 144
054: 360
055: 354 041 031 jmp (sub) return
057: 032
204: 033 fox org 0204 placing data after overflow/carry regs
204: 123 034 data db 0123 data in octal
205: 067 035 db 55 data in decimal
206: 124 145 040 036 ds "Te st" string with embedded space
211: 163 164
213: 124 145 042 037 ds 'Te"st' string with embedded apostrophe
216: 163 164
001: 038 one equ 1
003: 039 SHIFT equ 3
220: 000 040 ptr db 0 placehold for indirect
221: 000 041 db 0
Input can be in upper or lower case, case ignored. Syntax is: label opcode operands comment # global comment All fields delimited by one or more spaces or tabs. All fields optional except opcode, although a completely blank line is okay,
and a label by itself is okay. Global comments (no opcode) must begin with # in column 1. A label on a line by itself cannot
have a comment (since the first word would be taken as an opcode). Opcodes in table below. All should be obvious. Variations of "call" used for jump and mark.
adda,addb,addx,suba,subb,subx,lda,ldb,ldx,sta,stb,stx,ora,anda,lnega,
jmp,jane,jaeq,jalt,jage,jagt,jbne,jbeq,jblt,jbge,jbgt,jxne,jxeq,jxlt,jxge,jxgt,
call,cane,caeq,calt,cage,cagt,cbne,cbeq,cblt,cbge,cbgt,cxne,cxeq,cxlt,cxge,cxgt,
set0,set1,skp0,skp1
shra,rora,shla,rola,shrb,rorb,shlb,rolb,
hlt,nop
Pseudo-ops (discussed below):
sys,sysp,org,db,ds,equ
Immediate addressing uses # prefix, indirect addressing denoted using (), indexing by ,x and bit fields for set/skip by ,n
where n=0-7. Only decimal and octal supported; octal constants denoted by leading 0, e.g. 077 (not Python syntax of 0o).
Simple arithmetic in operands e.g. data+2 or lbl-lb2 is now allowed. See examples above, such as lbl-2, (ptr+one), 1+SHIFT
etc. Operands (except strings) cannot have embedded spaces.
Strings (ds pseudo-op) can be delimited by quotes "test" or apostrophes 'test'. Spaces okay.
Default origin is 4, changeable using org opcode. Data can be defined using db opcode (data byte).
In addition to the sys pseudo-op, which generates an octal 360 opcode, there is also a sysp macro that takes one or two
parameters (separated by a comma). The first parameter is loaded into the A accumulator before the call, and the second
(if present) into the B accumulator. Immediate addressing is implied (don't use #'s). Equated symbols can be used however.
So:
SYS_DELAY equ 0222
sysp SYS_DELAY,100 delay for 100 ms
is the same as:
lda #0222
ldb #100
sys delay for 100 ms
Predefined registers/locations are a, b, c, x, pc, out, in, oca, ocb, ocx, in where the latter three are the overflow/carry registers.
Tabs are converted to blanks in the output listing file. Default tab width is 8, but this can be changed with the tab pseudo-op:
e.g. tab 4 Setting tab 0 turns off the tab expansion.
Run on command line using: kenbak_asm filename.asm (standalone) or: python kenbak_asm.py filename.asm (from Python source) Listing output will go to standard out. Save it using >filename.lst is desired. Octal output will go to filename.out. Errors denoted
using asterisks in the listing file instead of numbers in the address, opcode and operand fields.
The Python 3 script, the test program above, as well as a stand-alone executable for those that don't have Python installed, are
available from one of my websites:
http://www.softwest.com/kenbak_asm/kenbak_asm.exe
http://www.softwest.com/kenbak_asm/kenbak_asm.py
http://www.softwest.com/kenbak_asm/test.asm
Run the test source file using the standalone exe simply by typing: kenbak_asm test.asm in a Command Prompt.
I'm releasing all of this into the public domain, so feel free to distribute if you wish.
Frank P.
Jun 9, 2019, 1:42:07 PM6/9/19
to uken...@googlegroups.com
Does this support assemble-time expressions in the operand field, (e.g.: sta lbl+1)?
On Sunday, June 9, 2019 at 1:26:59 PM UTC-4, Tom C wrote:
On Sunday, June 9, 2019 at 1:26:59 PM UTC-4, Tom C wrote:
I see there is another aseembler for the µKenbak here, but frankly I never did like the original mnemonics. So I decided to write my own patterned after the 6800, although I used shr/shl instead of asr and asl. And I used variations of call for Jump and Mark instead of the 6800 jsr, since the conditional jumps and subroutine calls would have the same names. Here's the listing output for my test program for the assembler, just to show the syntax, it doesn't do anything useful:
004: # test program for µKenbak-1 assembler. By default, will start at 4 004: # arithmetic, load/store and logical ops and addressing modes 004: 003 010 lbl adda #8 immediate value in decimal 006: 103 010 addb #010 same thing in octal 010: 024 001 lda b memory reference (using predefined reg b for reg transfer) 012: 235 206 stx (ptr) indirect reference 014: 306 204 ora data,x indexed 016: 337 206 lnega (ptr),x indirect/indexed 020: #jumps and calls 020: 344 004 jmp lbl unconditional jump 022: 043 032 jane lbl2 jump if a not equal 0 024: 257 206 jxgt (ptr) jump indirect if x gt 0 026: 364 041 call sub call to subroutine 030: 174 206 cbeq (ptr) call indirect to subroutine if b equal 0 032: # set and skips 032: lbl2 032: 122 204 set1 data,2 set bit 2 of data to 1 034: 272 204 skp0 data,7 skip if bit 7 of data is 0 036: # shifts and rotates 036: 001 shra 4 shift a right 4 places 037: 361 rolb 2 rotate b left 2 places 040: 000 hlt halt 041: 000 sub db 0 leave room for return address 042: 200 nop no op 043: 360 sys system call (µKenbak-1 extension) 044: 354 041 jmp (sub) return 046: 204: org 0204 placing data after overflow/carry regs 204: 123 data db 0123 data in octal 205: 067 db 55 data in decimal 206: 000 ptr db 0 placehold for indirect
Input can be in upper or lower case, case ignored. Syntax is: label opcode operands comment # global comment All fields delimited by one or more spaces or tabs. All fields optional except opcode, although a completely blank line is okay, and a label by itself is okay. Global comments (no opcode) must begin with # in column 1. A label on a line by itself cannot have a comment (since the first word would be taken as an opcode). Opcodes in table below. All should be obvious. Variations of "call" used for jump and mark.
adda,addb,addx,suba,subb,subx,
lda,ldb,,ldx,,sta,stb,stx,
ora,anda,lnega,
jmp,
jane,jaeq,jalt,jage,jagt,
jbne,jbeq,jblt,jbge,jbgt,
jxne,jxeq,jxlt,jxge,jxgt,
call,
cane,caeq,calt,cage,cagt,
cbne,cbeq,cblt,cbge,cbgt,
cxne,cxeq,cxlt,cxge,cxgt,
set0,set1,skp0,skp1
shra,rora,shla,rola,
shrb,rorb,shlb,rolb,
hlt,nop,sys,
org,db
Immediate addressing uses # prefix, indirect addressing denoted using (), indexing by ,x and bit fields for set/skip by ,n where n=0-7. Only decimal and octal supported; octal constants denoted by leading 0, e.g. 077 (not Python syntax of 0o). Arithmetic in operands e.g. data+2 is not allowed. Default origin is 4, changeable using org opcode. Data can be defined using db opcode (data byte). Predefined registers/locations are a, b, c, x, pc, out, in, oca, ocb, ocx, in where the latter three are the overflow/carry registers. Run on command line using: kenbak_asm filename.asm (standalone) or: python kenbak_asm.py filename.asm (from Python source) Listing output will go to standard out. Save it using >filename.lst is desired. Octal output will go to filename.out. Errors denoted using asterisks in the listing file instead of numbers in the address, opcode and operand fields.
The Python 3 script, the test program above, as well as a stand-alone executable for those that don't have Python installed, are available from one my website:
Run the standalone simply by typing: kenbak_asm test.asm in a Command Prompt.
I'm releasing all of this into the public domain, so feel free to distribute if you wish. Let me know if you find any bugs or have suggestions or other comments, at tcro...@softwest.com
Charley Jones
Jun 9, 2019, 3:13:01 PM6/9/19
to Frank P., Altair-Duino
I see from his docs:
Arithmetic in operands e.g. data+2 is not allowed.
But not something that can’t be figured out.
Sent from my iPhone 7!
Does this support compile-time expressions in the operand field, (e.g.: sta lbl+1)?
--
You received this message because you are subscribed to the Google Groups "Altair-Duino" group.
To unsubscribe from this group and stop receiving emails from it, send an email to altair-duino...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/altair-duino/53193abf-02ed-4d5a-8d10-a56f44c675bc%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
Tom Lake
Jun 9, 2019, 3:30:04 PM6/9/19
to Altair-Duino
Nice! I've always been partial to Motorola mnemonics even though most of my systems have had Intel or Intel-compatible CPUs.
Thanks!
Tom L
On Sunday, June 9, 2019 at 1:26:59 PM UTC-4, Tom C wrote:
I see there is another aseembler for the µKenbak here, but frankly I never did like the original mnemonics. So I decided to write my own patterned after the 6800, although I used shr/shl instead of asr and asl. And I used variations of call for Jump and Mark instead of the 6800 jsr, since the conditional jumps and subroutine calls would have the same names. Here's the listing output for my test program for the assembler, just to show the syntax, it doesn't do anything useful:
004: # test program for µKenbak-1 assembler. By default, will start at 4 004: # arithmetic, load/store and logical ops and addressing modes 004: 003 010 lbl adda #8 immediate value in decimal 006: 103 010 addb #010 same thing in octal 010: 024 001 lda b memory reference (using predefined reg b for reg transfer) 012: 235 206 stx (ptr) indirect reference 014: 306 204 ora data,x indexed 016: 337 206 lnega (ptr),x indirect/indexed 020: #jumps and calls 020: 344 004 jmp lbl unconditional jump 022: 043 032 jane lbl2 jump if a not equal 0 024: 257 206 jxgt (ptr) jump indirect if x gt 0 026: 364 041 call sub call to subroutine 030: 174 206 cbeq (ptr) call indirect to subroutine if b equal 0 032: # set and skips 032: lbl2 032: 122 204 set1 data,2 set bit 2 of data to 1 034: 272 204 skp0 data,7 skip if bit 7 of data is 0 036: # shifts and rotates 036: 001 shra 4 shift a right 4 places 037: 361 rolb 2 rotate b left 2 places 040: 000 hlt halt 041: 000 sub db 0 leave room for return address 042: 200 nop no op 043: 360 sys system call (µKenbak-1 extension) 044: 354 041 jmp (sub) return 046: 204: org 0204 placing data after overflow/carry regs 204: 123 data db 0123 data in octal 205: 067 db 55 data in decimal 206: 000 ptr db 0 placehold for indirect
Input can be in upper or lower case, case ignored. Syntax is: label opcode operands comment # global comment All fields delimited by one or more spaces or tabs. All fields optional except opcode, although a completely blank line is okay, and a label by itself is okay. Global comments (no opcode) must begin with # in column 1. A label on a line by itself cannot have a comment (since the first word would be taken as an opcode). Opcodes in table below. All should be obvious. Variations of "call" used for jump and mark.
adda,addb,addx,suba,subb,subx,
lda,ldb,,ldx,,sta,stb,stx,
ora,anda,lnega,
jmp,
jane,jaeq,jalt,jage,jagt,
jbne,jbeq,jblt,jbge,jbgt,
jxne,jxeq,jxlt,jxge,jxgt,
call,
cane,caeq,calt,cage,cagt,
cbne,cbeq,cblt,cbge,cbgt,
cxne,cxeq,cxlt,cxge,cxgt,
set0,set1,skp0,skp1
shra,rora,shla,rola,
shrb,rorb,shlb,rolb,
hlt,nop,sys,
org,db
Immediate addressing uses # prefix, indirect addressing denoted using (), indexing by ,x and bit fields for set/skip by ,n where n=0-7. Only decimal and octal supported; octal constants denoted by leading 0, e.g. 077 (not Python syntax of 0o). Arithmetic in operands e.g. data+2 is not allowed. Default origin is 4, changeable using org opcode. Data can be defined using db opcode (data byte). Predefined registers/locations are a, b, c, x, pc, out, in, oca, ocb, ocx, in where the latter three are the overflow/carry registers. Run on command line using: kenbak_asm filename.asm (standalone) or: python kenbak_asm.py filename.asm (from Python source) Listing output will go to standard out. Save it using >filename.lst is desired. Octal output will go to filename.out. Errors denoted using asterisks in the listing file instead of numbers in the address, opcode and operand fields.
The Python 3 script, the test program above, as well as a stand-alone executable for those that don't have Python installed, are available from one my website:
Tom C
Jun 9, 2019, 4:56:13 PM6/9/19
to uken...@googlegroups.com
Does this support assemble-time expressions in the operand field, (e.g.: sta lbl+1)?
Not currently, but I could add that pretty easily. Will try to do so tonight. Probably should also add an EQU pseudo-op.
John Kennedy
Jun 9, 2019, 5:41:54 PM6/9/19
to Altair-Duino
Looks neat! But at the risk of proving my ignorance, how can I get the code into the uKenBak?
Frank P.
Jun 9, 2019, 5:50:46 PM6/9/19
to Altair-Duino
That would be good. With only 248 program bytes to work with, super tight code is a must, and storing data in the immediate byte(s) of an instruction and/or other use of self-modifying code is (was) de rigueur. Adding EQU could make the code more readable too, e.g.:
saveda equ restorea+1
...
sta saveda
...
restorea lda #0Frank P.
Jun 9, 2019, 5:54:48 PM6/9/19
to uken...@googlegroups.com
Push the pretty buttons :), or if you've added a serial port, use Mark's serial port loader (see his docs, Extension 8 Send/Receive Memory, and serial.txt).
Tom C
Jun 9, 2019, 7:21:45 PM6/9/19
to Altair-Duino
The output file is in a format designed to be loaded directly via the serial loader (extension #8). I haven't tried that yet. Otherwise, you have to key in the octal values that are on the left side of the listing file. e.g. for the line:
004: 003 010 lbl adda #8 immediate value in decimal
you would set the address to 004, and then start keying in values, 003, 010 etc from the listing.
Frank P.
Jun 9, 2019, 7:25:39 PM6/9/19
to Altair-Duino
Adding a serial port is shown...
here for an RS-232 port: https://groups.google.com/forum/#!topic/altair-duino/94Q0w191vKw
and here for a USB port: https://groups.google.com/forum/#!topic/altair-duino/qnlitWFNmzw
In either case, adding a capacitor and resistor to the ATMega328 pin 1 also permits the firmware to be uploaded via the serial port (see topics above), so the chip never needs to be removed from the board again.
Mark Wilson
Jun 9, 2019, 7:38:33 PM6/9/19
to Altair-Duino
Note also that if you're working on something reasonably involved, and you are set up to be able to reprogram the uKenbak in place, there's a more streamlined way than edit, assemble, upload, run, rinse, repeat.
You can bake your program into the sketch, replacing one of the built-in programs, for example the Sieve of Eratosthenes (program #6).
See Programs.cpp. It includes a simple assembler. That would let you develop your Kenbak program in the Arduino IDE. You could also configure the uKenbak to auto-run it. Make a change, upload, and it's running.
Sketch space is very tight, you might need to comment-out other built-ins to make space. In fact you'll see I've already done this with the Sieve, replaced the asm code with PROGMEM bytes.
Tom C
Jun 9, 2019, 9:00:14 PM6/9/19
to uken...@googlegroups.com
It does now, just updated (V1.1). operand+operand, operand-operand with or without parens. Also added equ pseudo op. Files updated on my server.
Original posting edited to show changes.
Frank P.
Jun 9, 2019, 9:31:17 PM6/9/19
to uken...@googlegroups.com
Thanks Tom... I'll give it a try on my adding machine program tomorrow.
Dave's assembler is great too.
Message has been deleted
Message has been deleted
Frank P.
Jun 9, 2019, 10:25:43 PM6/9/19
to Altair-Duino
Whoops, just noticed no support for string literals, e.g.:
INPUT DS "00000000000000000000" # Input text string (up to 20 digits)
Could use 20 DBs:
INPUT DB 060
DB 060
...
but that seems inconvenient and doesn't reflect its stringish nature.
Tom C
Jun 10, 2019, 1:01:59 AM6/10/19
to Altair-Duino
Frank,
Just for you, I added a string pseudo-op, DS. See new example code. Does not support control chars however, still need db for those.
Tom
Frank P.
Jun 10, 2019, 9:51:15 AM6/10/19
to uken...@googlegroups.com
So I tried it on my serial port Adding Machine program and it almost worked. See attached AddingMachineV11a.* files.
The two errors were:
At address 242, the negative operand is not represented properly in octal (should be 354, not -24).
At address 376, the last instruction is repeated twice in the listing, but not output at all in the .out file.
I also noticed a difference (but not an error per-se) between your assembler and Dave Hunter's assembler:
You use the "=0" condition (4) for UNC jumps/calls
Dave uses the "!=0" condition (3) for UNC jumps/calls
Both instructions are equivalent in function (as would they be if any of the other 3 conditions were used).
I used the .exe file because I couldn't get the Python file to work...
It complained about the µ character (and the strange character before it) in the comments
It complained about the end= in the prints
I'm not familiar enough with Python to decipher these errors.
Lastly, might I suggest you output 3-digit octal numbers (like Dave's assembler) instead of 4-digits because a file with 3-digits can be sent to the uKenbak-1 at 38400 baud without loss, while 4-digits causes problems.
Tom C
Jun 10, 2019, 11:15:16 AM6/10/19
to Altair-Duino
Thanks, your program was a nice test for the assembler. Will look at the issues tonight. I use 344 for jumps because I belive that was what Kenbak's examples used.
Tom
Lastly, might I suggest you output 3-digit octal numbers (like Dave's assembler) instead of 4-digits because a file with 3-digits can be sent to the uKenbak-1 at 9600 baud without loss, while 4-digits causes problems.
Frank P.
Jun 10, 2019, 11:31:51 AM6/10/19
to uken...@googlegroups.com
Tom, here's another problem:
Address 3 in the .out file is incorrect (it's 0, should be 310).
There is yet another problem (because the program doesn't run properly) but I haven't found it yet.
EDIT: No, there isn't another problem, it was just pilot error.
Frank P.
Jun 10, 2019, 12:40:47 PM6/10/19
to Altair-Duino
One more thing (utters Lieutenant Columbo just as he's about to leave)...
I found that even if you output 3-digit octal numbers in the output file, the uKenbak-1 will have trouble loading it at 38400 baud with the two carriage returns and one linefeed after each 16 values. Without those carriage returns and line feed (i.e. a single line with all 256 values, or fewer than 256 values with an "e" after the last comma), the file will load fine at 38400 baud. The reason that it is desirable to be able to load at that baud rate is it is inconvenient to change the baud rate in the terminal program to a lower rate to load the program, and then back to 38400 to run the program.
The .oct file produced by Dave's assembler does produce a single line with comma-separated 3-digit octal values and a terminating "e", and that seems to be the ideal format for loading into the uKenbak-1.
Tom C
Jun 10, 2019, 1:07:49 PM6/10/19
to Altair-Duino
Yeah I saw that too. I hadn't expected people to set the PC using a DB op. Will fix.
Tom C
Jun 10, 2019, 1:13:37 PM6/10/19
to Altair-Duino
Frank,
could you post the files from Dave's assembler for the same program so I can compare them? thx.
Tom
Tom C
Jun 11, 2019, 1:27:13 AM6/11/19
to Altair-Duino
Frank,
Program updated. Should have all fixes. My octal output now matches Dave's, except for the difference in unconditional JMP opcodes which I discussed.
The problem you ran into with the end="" is because this is written for Python 3.6 and later, as mentioned in the program. I assume you are using Python 2.
Tom
Frank P.
Jun 11, 2019, 7:28:32 AM6/11/19
to uken...@googlegroups.com
Excellent Tom! Now all I have to do is decide which assembly format I like better. I think this one is easier to remember, and the .exe file will make it more widely usable.
Yes, Python 2.7.6 is what comes installed by default in Windows 10 "Ubuntu on Windows", so I installed 2.7.15 on Windows itself - it actually has a pretty recent date (April 30, 2018), and it's a 64-bit program, so I had assumed it was fairly current. Is Python 3.x.x backward compatible with 2.*.*?
Tom C
Jun 11, 2019, 10:07:46 AM6/11/19
to Altair-Duino
I never liked the original Kenbak mnemonics. I actually had one of the original Kenbak-1s -- I bought mine in 1971 for $750. I was just starting grad school for my MSCS degree and wanted something to practice assembly language on that was simpler than the school's UNIVAC 1108. I bought a used ASR-33 Teletype that I used for input and output, writing a bit-banged RS-232 interface using one of the input switches and output LEDs. Because the CPU was discrete 7400 logic, I actually modified the CPU to add an interrupt capability on the input bit. So I just had to key in a small bootloader, and then load programs from paper tape.
Then four years later, still in school (I was going to night school, one class at a time), I bought a Sphere-1 kit with a 6800 and 20 KB of static RAM. It came out at the same time as the Altair 8800, but I liked the Motorola instruction set better. No surprise, it had two accumulators A and B and an index register X. It felt right at home. I wrote a word processor for the Sphere, plus a PL/M compiler, which were both being sold. My publisher gave me an Apple ][ when it first came out, and I ported the word processor to it. More about my Sphere here.
So my Kenbak sat on a shelf in our garage for the next 30 years. I sold mine to a vintage computer collector fifteen years ago for way more than I paid for it. Would be worth a lot more now, but I needed the money at the time. I donated my Sphere-1 to a computer museum about the same time I sold the Kenbak-1 (we were moving and I didn't want to take all this stuff with me).
Python 3.x is highly compatible with 2.x. One of the changes though was they made the print statement a function rather than a built-in. So you always have to use parentheses. And the way of handling end of lines changed, as you discovered. I highly recommend you switch, as 2.x will not be supported past 2020.
Tom
John Kennedy
Jun 11, 2019, 10:25:22 AM6/11/19
to Altair-Duino
Wow, a real pioneer! There is a KenBak-1 at the Living Computers Museum in Seattle where I spend too much time, but it's one of the few behind glass. Looks way bigger than you might expect.
The Sphere sounds like it was ahead of its time.I wonder if they had picked an 8080 CPU would it be more well-known today?
Tom C
Jun 12, 2019, 12:36:05 AM6/12/19
to Altair-Duino
New version (1.22) uploaded with a minor enhancement; if there are any errors detected during assembly, it prints the total at the bottom of the listing output and the output file is nulled.
Tom C
Jun 15, 2019, 10:55:13 PM6/15/19
to uken...@googlegroups.com
New version 1.32, as of 6/16/19. See original post for download locations. New features:
1. Are you tired of setting up operands for sys calls? In addition to the sys pseudo-op, which generates an octal 360 opcode, there is now also a sysp macro that takes one or two parameters (separated by a comma). The first parameter is loaded into the A accumulator before the call, and the second (if present) into the B accumulator. Immediate addressing is implied (don't use #'s). Equated symbols can be used however.
So:
SYS_DELAY equ 0222
So:
SYS_DELAY equ 0222
sysp SYS_DELAY,100 delay for 100 ms
is the same as:
lda #0222
ldb #100
sys delay for 100 ms
is the same as:
lda #0222
ldb #100
sys delay for 100 ms
More examples:
SYS_GETSECONDS equ 0000
SYS_SETSECONDS equ 0200
SYS_GETMINUTES equ 0001
SYS_GETMINUTES equ 0001
SYS_SETMINUTES equ 0201
SYS_GETRANDOM equ 0021
SYS_SETSEED equ 0221
SYS_DELAY equ 0222
SYS_READSERIAL equ 0023
SYS_WRITESERIAL equ 0223
sysp SYS_SETMINUTES,0125 set RTC minutes to 55 (0125 in BCD)
sysp SYS_SETSEED,0 seed random number generator from RTC
sysp SYS_GETRANDOM get a random number in B
ldb char
sysp SYS_WRITESERIAL send value in char to serial port (note can't use the two-operand form here, because not immediate)
sysp SYS_WRITESERIAL,015 send new line to serial port
sysp SYS_READSERIAL return value in serial port in B
2. Tabs in the source file are now converted to blanks in the output listing file. Default tab width is 8, but this can be change with the tab pseudo-op: e.g. tab 4 Setting tab 0 turns off the tab expansion.
3. Duplicate labels now properly generate an error, unless the symbol is a predefined register and the value isn't being changed. So:
org 0
A db 0
no longer generates an error like it did in version 1.22.
4. Command line option -e added to uses spaces instead of commas in output file, to make it compatible with Kenbak-1 JS emulator found here:
e.g. kenbak_asm -e test.asm
then copy and paste contents of the .out file into the Memory Loader window of the JS emualtor and press Load.
Note: programs run fine on the JS emulator, except of course the emulator doesn't support any of the uKenbak-1 extensions; they are just treated as no-ops.
Frank P.
Jul 4, 2019, 10:45:07 AM7/4/19
to Altair-Duino
Tom, I ran into what I think is a little bug... if I try to assemble a program with a DS pseudo-op in it with a string operand that contains any commas, the assembler silently refuses to assemble the line (just leaves *s in the listing and doesn't advance the PC). What do you think?
Tom C
Jul 4, 2019, 4:07:49 PM7/4/19
to Altair-Duino
Yep, sounds like a bug. I search for the comma, looking for ,x or,n (indexed addressing, or bit shift), and that is apparently happening before I process the quotes for the string.
I'm out of town for the July 4th weekend, but will fix this when I come back on Sunday. Meanwhile you'll have to use two strings with a db in th middle for the comma.
I also just finally got my serial board from China, so I'll be testing that with my Kenbak-1K extensions on Sunday too.
Thanks for using my assembler and creating lots of good test cases for it!
Tom
Tom C
Jul 8, 2019, 12:50:58 AM7/8/19
to Altair-Duino
Fixed. Version 1.41, 7/7/19
links:
Frank P.
Jul 8, 2019, 7:59:58 AM7/8/19
to Altair-Duino
Great Tom... tested and works fine now.
Tom C
Jul 21, 2019, 8:17:01 PM7/21/19