Apple2-IO-RPi/RaspberryPi/apple2driver/driver.go
2024-03-29 12:13:39 -04:00

149 lines
3.9 KiB
Go

// Copyright Terence J. Boldt (c)2020-2024
// Use of this source code is governed by an MIT
// license that can be found in the LICENSE file.
// This file contains the main driver code for the Raspberry Pi side of
// the Apple2-IO-RPi hardware. Commands are sent from the Apple II and
// responses are sent back from the Raspberry Pi.
package main
import (
"errors"
"flag"
"fmt"
"os"
"path/filepath"
"time"
"go.bug.st/serial"
"github.com/tjboldt/Apple2-IO-RPi/RaspberryPi/apple2driver/a2io"
"github.com/tjboldt/Apple2-IO-RPi/RaspberryPi/apple2driver/drive"
"github.com/tjboldt/Apple2-IO-RPi/RaspberryPi/apple2driver/handlers"
"github.com/tjboldt/Apple2-IO-RPi/RaspberryPi/apple2driver/info"
"github.com/tjboldt/ProDOS-Utilities/prodos"
)
const resetCommand = 0
const readBlockCommand = 1
const writeBlockCommand = 2
const getTimeCommand = 3
const changeDriveCommand = 4 // not currently used
const execCommand = 5
const loadFileCommand = 6
const saveFileCommand = 7 // not implemented yet
const menuCommand = 8
const shellCommand = 9
func main() {
drive1Name, drive2Name, cdc := getFlags()
drive1, drive2 := getDriveFiles(drive1Name, drive2Name)
driveImageDir, err := drive.GetDriveImageDirectory()
if err == nil {
os.Chdir(driveImageDir)
}
fmt.Printf("Starting Apple II RPi v%s...\n", info.Version)
var comm a2io.A2Io
if cdc {
comm = a2io.CDCio{}
fmt.Printf("Starting communications via serial port...\n")
} else {
comm = a2io.A2Gpio{}
fmt.Printf("Starting communications via GPIO ports...\n")
}
handlers.SetCommunication(comm)
comm.Init()
// In case Apple II is waiting, send 0 byte to start
comm.WriteByte(0)
for {
command, err := comm.ReadByte()
if err == nil {
switch command {
case resetCommand:
handlers.ResetCommand()
case readBlockCommand:
handlers.ReadBlockCommand(drive1, drive2)
case writeBlockCommand:
handlers.WriteBlockCommand(drive1, drive2)
case getTimeCommand:
handlers.GetTimeCommand()
case execCommand:
handlers.ExecCommand(&drive1, &drive2)
case loadFileCommand:
handlers.LoadFileCommand()
case menuCommand:
handlers.MenuCommand()
case shellCommand:
handlers.ShellCommand()
}
// the A2Io interface should be extended in one way or another
// to encapsulate this, e.g. by a ReadByte variant / parameter
} else if cdc {
var portErr *serial.PortError
if errors.As(err, &portErr) && portErr.Code() == serial.PortClosed {
comm.Init()
}
// temporary workaround for busy wait loop heating up the RPi
} else {
time.Sleep(time.Millisecond * 200)
}
}
}
func getFlags() (string, string, bool) {
var drive1Name string
var drive2Name string
var cdc bool
execName, _ := os.Executable()
path := filepath.Dir(execName)
path = filepath.Join(path, "..")
path, _ = filepath.EvalSymlinks(path)
flag.StringVar(&drive1Name, "d1", "", "A ProDOS format drive image for drive 1")
flag.StringVar(&drive2Name, "d2", "", "A ProDOS format drive image for drive 2 and will be used for drive 1 if drive 1 empty")
flag.BoolVar(&cdc, "cdc", false, "Use ACM CDC serial device")
flag.Parse()
return drive1Name, drive2Name, cdc
}
func getDriveFiles(drive1Name string, drive2Name string) (prodos.ReaderWriterAt, prodos.ReaderWriterAt) {
var drive1 prodos.ReaderWriterAt
var drive2 prodos.ReaderWriterAt
var err error
if len(drive1Name) > 0 {
fmt.Printf("Opening Drive 1 as: %s\n", drive1Name)
drive1, err = os.OpenFile(drive1Name, os.O_RDWR, 0755)
logAndExitOnErr(err)
} else {
directory, err := drive.GetDriveImageDirectory()
logAndExitOnErr(err)
drive1, err = drive.GenerateDriveFromDirectory("APPLE2.IO.RPI", directory)
logAndExitOnErr(err)
}
if len(drive2Name) > 0 {
fmt.Printf("Opening Drive 2 as: %s\n", drive2Name)
drive2, err = os.OpenFile(drive2Name, os.O_RDWR, 0755)
logAndExitOnErr(err)
}
return drive1, drive2
}
func logAndExitOnErr(err error) {
if err != nil {
fmt.Printf("ERROR: %s", err.Error())
os.Exit(1)
}
}