Differences

This shows you the differences between two versions of the page.

--- base:using_a_running_vice_session_for_development [2016-06-28 18:54] – [Setting up VICE] compyx
+++ base:using_a_running_vice_session_for_development [2016-06-30 14:44] – compyx
@@ Line 119: / Line 119: @@
                 > /dev/null 2>&1 &
 </code>
+==== Setting up the client side ====
+Now that we have a running VICE session, we can start with the client side of things, that is, assembling our binary and injecting it into VICE and start it. And if need be, loading labels into the monitor for debugging and/or attaching disk images to VICE.
+This is where netcat comes in, we can send commands to VICE with netcat. Let's assume we have a single source file 'demo.s' which we assemble into 'demo.prg'. We assemble this using 64tass:
+<code bash>
+tass -a -C -o demo.prg demo.s
+</code>
+We can now insert this into VICE and run it:
+<code bash>
+# first reset VICE
+echo 'reset 0' | netcat localhost 6510
+# insert binary into VICE
+echo 'l "demo.prg" 0' | netcat localhost 6510
+# run demo.prg
+echo 'g 080d' | netcat localhost 6510
+</code>
+Again, this becomes tedious, having to type this again and again, so we update our Makefile (just the new parts for now):
+<code make>
+ASM=64tass
+# Default make target: just assemble the program:
+all: demo.prg
+# Assemble program
+demo.prg: demo.s
+        $(ASM) -a -C -o demo.prg demo.s
+# Inject program into VICE session and run it
+run: demo.prg
+        # we need to wait one second for the reset to finish, so we use -q 1
+        echo 'reset 0' | netcat -q 1 localhost 6510
+        # load demo.prg from the virtual FS, our host OS
+        echo 'l "demo.prg 0"' | netcat localhost 6510
+        # this assumes demo.prg starts at $080d
+        echo 'g 080d' | netcat localhost 6510
+</code>
+The `-q 1` argument to netcat is required to allow the reset to properly finish. netcat does not wait for VICE to complete its task, it immediately exits on EOF, so we use `-q 1` to tell netcat to wait one second after EOF. You could also use `sleep 1` after issuing 'reset 0', it has the same effect (adjust to sleep 3 when using a non-patched KERNAL).
+Since the 'run' target depends on 'demo.prg', that file automatically gets (re)built whenever we issue `make run`, and when the building fails no data is inserted into VICE.
+=== Loading labels into VICE ===
+The same goes for loading labels into VICE: since we use a running instance, when we do 'load_labels', the old labels are still there, so when we've altered our binary, the labels might be different, but VICE keeps the old ones. So we do:
+<code bash>
+echo 'clear_labels' | netcat -q 1 localhost 6510
+echo 'load_labels "labels.txt"' | netcat localhost 6510
+</code>
+Again giving VICE time to process the 'clear_labels' command before sending the 'load_labels' command. Obviously not needed when issuing these commands from the shell, but using a Makefile, this is required.
+So, lets update our Makefile once again (full Makefile now):
+<code make>
+# x64 binary
+X64=/usr/local/bin/x64
+# Assembler
+ASM=64tass
+# Original KERNAL
+KERNAL=/usr/lib/vice/C64/kernal
+# Patched KERNAL
+KERNAL_PATCHED=kernal-quick-memtest
+# Generate patched KERNAL for faster reset (skip BASIC memtest)
+$(KERNAL_PATCHED): $(KERNAL)
+	cp $(KERNAL) $(KERNAL_PATCHED)
+	echo "1d69: 9f" | xxd -r - $(KERNAL_PATCHED)
+all: demo.prg
+# Assemble program and output VICE labels file
+demo.prg: demo.s
+        $(ASM) -a -C -o demo.prg demo.s --vice-labels -l labels.txt
+# Inject program into VICE session and run it
+run: demo.prg
+        # we need to wait one second for the reset to finish, so we use -q 1
+        echo 'reset 0' | netcat -q 1 localhost 6510
+        # clear and (re)load labels
+        echo 'clear_labels' | netcat -q 1 localhost 6510
+        echo 'load_labels "labels.txt"' | netcat localhost 6510
+        # load demo.prg from the virtual FS, our host OS
+        echo 'l "demo.prg 0"' | netcat localhost 6510
+        # this assumes demo.prg starts at $080d
+        echo 'g 080d' | netcat localhost 6510
+# Start VICE session with remote monitor and patched KERNAL in the background
+# redirecting VICE's output to a black hole
+session: $(KERNAL_PATCHED)
+        $(X64) -remotemonitor -kernal $(KERNAL_PATCHED) \
+                > /dev/null 2>&1 &
+# Clean up
+.PHONY: clean
+clean:
+        rm -f demo.prg
+        rm -f $(KERNAL_PATCHED)
+</code>
+There you have it, running and debugging code with a live VICE session, avoiding a lot of start up time. Unfortunately, when using this for code that **doesn't** set up IRQ's, we have a little problem.
+== Proper BASIC initialization ==
+Since we bypass the C64's OS (the BASIC interpreter), when we execute code using the above method, the C64 doesn't know we executed a program and keeps the IRQ of the interpreter running, resulting in a nice blinking cursor.
+So we need a way to do a proper 'RUN' after injecting our program. We can do this with a simple SYS line and some tweaking of the <del>BASIC end-of-program pointer and</del> keyboard buffer.
+Let's assume our demo.s looks like this:
+<code 64tass>
+        * = $0801
+        ; BASIC section: this becomes "2016 sys2061"
+        .word (+), 2016
+        .null $9e, ^start
++       .word 0
+start   ; this is $080d
+        lda #0
+        sta $d020
+        sta $d021
+        rts
+</code>
+When we run this using the Makefile shown, the border and background turn black, but we get a blinking cursor. So we need to somehow force BASIC to properly run this SYS line. This can be done with a little tweaking:
+(Thanks to Groepaz for coming up with the suggestion of simply putting 'RUN' into the keyboard buffer!)
+First we load the binary into VICE, then we set the end-of-basic pointer to $080d, fill the keyboard buffer with "RUN\r" and let the magic happen:
+<code bash>
+# reset, and wait, otherwise the BASIC start-of-basic pointer gets overwritten to $0000 while loading
+echo 'reset 0' | netcat -q 1 localhost 6510
+# load binary
+echo 'l "demo.prg" 0' localhost 6510
+# put 'RUN\r' into the keyboard buffer
+echo 'f 0277 027a 52 55 4e 0d' | netcat localhost 6510
+# set keyboard buffer size to $04 -> strlen("RUN\r")
+echo 'f 00c6 00c6 04' | netcat localhost 6510
+</code>
+Putting this in our Makefile, we end up with this:
+<code make>
+# x64 binary
+X64 = /usr/local/bin/x64
+# Assembler
+ASM=64tass
+# Original KERNAL
+KERNAL=/usr/lib/vice/C64/kernal
+# Patched KERNAL
+KERNAL_PATCHED=kernal-quick-memtest
+# Generate patched KERNAL for faster reset (skip BASIC memtest)
+$(KERNAL_PATCHED): $(KERNAL)
+	cp $(KERNAL) $(KERNAL_PATCHED)
+	echo "1d69: 9f" | xxd -r - $(KERNAL_PATCHED)
+all: demo.prg
+# Assemble program and output VICE labels file
+demo.prg: demo.s
+        $(ASM) -a -C -o demo.prg demo.s --vice-labels -l labels.txt
+# Inject program into VICE session and run it
+run: demo.prg
+        # we need to wait one second for the reset to finish, so we use -q 1
+        echo 'reset 0' | netcat -q 1 localhost 6510
+        # clear and (re)load labels
+        echo 'clear_labels' | netcat -q 1 localhost 6510
+        echo 'load_labels "labels.txt"' | netcat localhost 6510
+        # load demo.prg from the virtual FS, our host OS
+        echo 'l "demo.prg 0"' | netcat localhost 6510
+        # put 'RUN\r' into the keyboard buffer
+        echo 'f 0277 027a 52 55 4e 0d' | netcat localhost 6510
+        # set keyboard buffer size to $04 -> strlen("RUN\r")
+        echo 'f 00c6 00c6 04' | netcat localhost 6510
+# Start VICE session with remote monitor and patched KERNAL in the background
+# redirecting VICE's output to a black hole
+session: $(KERNAL_PATCHED)
+        $(X64) -remotemonitor -kernal $(KERNAL_PATCHED) \
+                > /dev/null 2>&1 &
+# Clean up
+.PHONY: clean
+clean:
+        rm -f demo.prg
+        rm -f $(KERNAL_PATCHED)
+</code>
+More later..
+TODO:
+  * attaching disk images
+  * debugging via telnet
+  * writing a proper Makefile (perhaps putting all those echo's into a file, updating it with sed)
+  * VIM integration