VIXEN‑32
User’s Guide

Setting up your VIXEN‑32

The hardware

VIXEN‑32 runs on the MEGA65 computer — its FPGA becomes the VIXEN chipset, and its keyboard, SD card slot, joystick ports and Ethernet socket become the VIXEN’s own.

What you need

Three things: a MEGA65 with the VIXEN‑32 core installed, a display, and an SD card carrying the machine’s software.

The display. The VIXEN outputs both HDMI (720p at 50 Hz) and 15 kHz analog RGB at the same time, so a modern television and a proper CRT are equally at home. The picture is true PAL: 384×224 pixels, 50 frames a second.

The SD card. Everything the machine is lives in one file: /VIXEN-32/BOOT.BIN. At power‑on the core reads it from the card and becomes the machine. Updating your VIXEN is a file copy — no flashing, no tools (Chapter 8 shows how to do it over the network without even removing the card).

Switching on

Turn the power on. The border flashes through a sequence of colours as the machine boots — on a healthy start they pass in under a second — and then:

If instead you get a red border and an error code, the machine could not load BOOT.BIN — nothing is broken, and nothing on the card has been changed. Appendix C lists every code and what to do about it.

Getting started

The keyboard

Every key types what is printed on it. Letters arrive in uppercase, which is what BASIC keywords require. A few keys are special:

The screen is the editor

The screen is 40 columns by 25 rows, and all of it is editable. Type anywhere. Move the cursor up onto an old line, change a character, press RETURN, and the changed line is entered as if you had typed it fresh. A logical line may be up to 80 characters — two screen rows — and RETURN enters the whole thing. This one idea — edit the screen, not a buffer — is how you will fix and re‑enter program lines all day.

Your first words

PRINT shows things; with quotes it shows text, without them it does the arithmetic first. The operators are + - * / and ^ for powers, with parentheses working as they did in school. The machine is also a fine calculator.

Variables remember values: A=10, then PRINT A*3 gives 30. A name ending in $ holds text: N$="FOX". To clear the screen, print the clear‑screen character: PRINT CHR$(147).

Colour, first taste

The border and background each have a colour register you can POKE (Chapter 4 explains POKE properly — for now, trust it):

Sixteen colours, numbered 0–15 — the full chart is Appendix B. Change them, break things, then remember RUN/STOP+RESTORE puts everything back.

Beginning BASIC programming

A program is lines with numbers. Numbered lines are stored, not executed; RUN executes them in order, LIST shows them, NEW throws them away. Number in tens, so there is room to insert lines later.

Loops and decisions

FOR…NEXT repeats; STEP changes the stride (FOR I=10 TO 0 STEP -1 counts down). GOTO jumps to a line. IF…THEN decides. GOSUB…RETURN calls a subroutine and comes back. INPUT asks the person at the keyboard. Those six ideas are most of BASIC; everything else is vocabulary.

A whole game, twenty lines shy

RND(1) gives a random fraction between 0 and 1; line 20 turns it into a whole number from 1 to 100. Type it in, RUN it, then change it — make the range bigger, count down the guesses, insult the player. Changing a working program is how programming is learned.

When a program is worth keeping, SAVE "GUESS" writes it to disk and LOAD "GUESS" brings it back — Chapter 7 has the whole story.

Advanced BASIC

PEEK and POKE: the machine’s control panel

POKE address,value writes a byte straight into the machine; PEEK(address) reads one. Most of the VIXEN’s hardware — colours, sprites, sound, joysticks, the copper — is a row of such addresses starting at 45056 ($B000), laid out exactly like a Commodore 64’s $D000 block: the border is at $B020 as it was at $D020, so a C64 routine ports by changing one digit. Appendix A is the full map.

READ and DATA

DATA lines hold numbers (or strings) inside the program; READ consumes them in order and RESTORE rewinds. This is how sprite shapes travel inside a listing, as Chapter 5 is about to show. DIM A(10) makes arrays when single variables run out.

Reading the joystick

PEEK(45152) is joystick port 1, PEEK(45153) port 2. Each direction is a bit, and the bits are not in a tidy order — test them with AND:

A mouse in the port reads through PEEK(45154)/PEEK(45155) (X and Y) and PEEK(45156) (buttons). The counters run freely and wrap at 256, so keep the previous reading and subtract to get the movement since last time.

Waiting for a key

GET A$ takes one keypress without stopping the program (empty string if none is waiting) — the difference between a form and a game.

Sprite graphics

A sprite is a picture the hardware moves over the screen for free — no redrawing, no flicker, no arithmetic. The VIXEN‑32 has sixteen of them, each up to 64×64 pixels, each in a single colour (1 bit per pixel) or full 256‑colour (8 bits per pixel). All sixteen can share a scanline; there is no per‑line limit to outwit.

Designing a sprite

A one‑colour sprite is a grid of on/off pixels, eight pixels to a byte, the leftmost pixel in the highest bit — the same order the Commodore 64 used, so classic sprite DATA pokes straight in. Here is ours: the hot‑air balloon, 24×21, with a V punched out of the canopy where the old machines wore a C:

Getting the picture into the machine

A C64 poked sprite shapes into its own RAM. The VIXEN keeps sprite images in chip RAM, in numbered 4096‑byte slots, reached through a little three‑register window:

A 1‑bit‑per‑pixel image is 8 bytes per row, 64 rows — 512 bytes. Our balloon is 24 pixels wide, so each row is its three data bytes and five blank ones, and after 21 rows the rest of the slot is padded with zeros.

Aiming a sprite

Select a sprite channel, then set what it shows and how:

Coordinates count from the top‑left of the border, C64‑style: the visible 320×200 window runs from X=32 to 351 and Y=12 to 211. X can exceed 255, which is why it has a high bit — the listing below shows the classic idiom for splitting it.

The familiar C64 register layout is also mirrored for the first eight sprites — POKE 45056+2*n for X, 45057+2*n for Y, 45095+n for colour — so old fingers find everything where it was.

Up, up and away

Everything above, in one program. Type it in exactly, then RUN:

What each part does:

Lines 110–160 pour the picture into slot 1: three DATA bytes per row, five blanks to fill the 8‑byte row, then zeros to the end of the 64‑row image. Line 210 points sprite 0 at slot 1, colours it cyan, and sets the on‑top flag. Line 220 switches it on. Lines 310–340 fly it: X AND 255 is the low byte and -(X>255) is a neat BASIC trick — the comparison is −1 when true, and the minus sign turns it into the 1 the high‑bit register wants.

Collisions, and further

PEEK(45086) tells you which sprites touched each other this frame, PEEK(45087) which touched the background — pixel‑perfect, one bit per sprite, just like $D01E/$D01F. When you outgrow one balloon: the machine’s own demonstration, test_hw.bas, flies this same balloon twice — the second copy scaled up 3× in BASIC into a second slot — and is worth reading line by line.

Creating sound

The VIXEN’s classic voice is a SID — the famous three‑voice synthesizer chip, cycle‑modelled, with its filters and its character intact. Its 29 registers live at POKE 46080+r ($B400, the C64’s $D400 block relocated whole). A value stays set until you change it.

The beeper: one POKE makes sound

Before the SID, meet the machine’s simplest instrument: a single square wave — the same thing a PC speaker is. Two registers take the pitch in hertz, low byte and high byte; either write sets the tone, and 0 Hz is silence:

440 is 1×256 + 184, hence the two POKEs; a pitch under 256 Hz needs only the low byte once the high byte is cleared. There is no envelope — the tone starts and stops instantly — which makes the beeper the right tool for key clicks, alarms, and this:

(After breaking out, POKE 45229,0 : POKE 45230,0 by hand — or press RUN/STOP+RESTORE, which silences everything.) A PEEK of either register reads back the pitch you asked for.

First SID sound

The shape of every SID sound is here: set the volume (register 24), a pitch (registers 0 and 1, low and high), an envelope — how the note attacks, decays, sustains, releases (registers 5 and 6) — then open the gate with a waveform (register 4: 17 triangle, 33 sawtooth, 65 pulse, 129 noise; subtract 1 to close the gate and let the note release).

Voices 2 and 3 are the same seven registers at offsets +7 and +14. Try noise (129) with a fast envelope for drums, or two voices a fifth apart — and when the SID feels tame, the machine also carries a four‑voice digital sample player that games and demos use for real recorded sound.

Disks and files

Drives A: and B:

The VIXEN mounts disk images as drive A: and drive B: (pick them in the platform menu). BASIC speaks fluent disk:

Command arguments are separated by spaces, DOS‑style. Long filenames, mixed case and subdirectories all work. Programs are stored in the classic .PRG form — two bytes of load address, then the program — so files move freely between BASIC and the machine’s file menu.

Loading from the menu

The platform menu’s file browser loads three kinds of file: a .BAS types itself into the editor (you RUN it), a .PRG loads as if typed, and a .RVK is a native machine‑code application — a game, a demo, a terminal — that takes over the whole machine and hands it back when it exits.

Files as data: READF and WRITEF

Unit 0 is BASIC’s own memory, unit 1 is the 16 MB chip RAM (sprite sheets, level maps, samples), and unit −1 asks a file’s size without reading it. The result lands where a program can see it: PEEK(45247) is the status (0 means success) and 45244–45246 hold the byte count. Always check the status — a missing file does not stop the program, it just says so there.

Bootable disks

A disk whose first sector carries the V32B signature boots when mounted in A: at the Ready prompt — no key to hold; the disk decides. It stays an ordinary disk otherwise: it lists, copies, and holds files as usual. Only drive A: boots, so any disk can be examined safely from B:.

The network

The VIXEN‑32 has real Ethernet — and boots with it off. A retro machine should not join a network just because someone switched it on. When you want it:

Out of the box the machine uses DHCP. A plain text file on the SD card, /VIXEN-32/NETWORK.TXT, sets a fixed address, gateway, DNS or MAC when you want one — edit it on any PC. While the machine sits at Ready it answers pings, even while a BASIC program runs.

TFTP: files over the wire

…and the machine becomes a file server. From a PC on the same network:

Files named plainly land on the SD card under /VIXEN-32/; prefix A: or B: to write to a mounted disk. About 64 KB/s in either direction — twice an Amiga floppy. This is also how the machine itself is updated: upload a new BOOT.BIN, read it back to compare, power cycle.

Calling the board

The terminal program (TERMINAL_BNN.RVK, in /VIXEN-32/network/) dials the VIXEN‑32 bulletin board — complete with the handshake sound and CONNECT 1200, the logon art painting in at 1200 baud the way it really felt. On the board: multi‑user chat, who‑is‑on, message bases, a file area you can download from straight to the SD card, and updates for the machine itself. Bring the network up first (SHIFT+£); RUN/STOP hangs up.

There is an IRC client beside it for the real chat networks, and Network Pong — press 1 to play the machine, 2 to be matched against whoever else is out there, your mouse as the paddle. First to 9.