code reorg, cleanup, turd polishing

cmd/convertfw/convertfw.go

@@ -0,0 +1,198 @@
+package main
+
+import (
+	"code.beefchicken.com/trimtools/stfw"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+)
+
+func main() {
+
+	flag.Parse()
+
+	if len(flag.Args()) != 2 {
+		fmt.Printf("Usage:\n")
+		fmt.Printf("    convertfw <input>.FW{1,2,3} <output prefix>\n")
+		fmt.Printf("    convertfw <input>.bin{1,2,3} <output prefix>\n")
+		os.Exit(1)
+	}
+
+	in := flag.Arg(0)
+	out := flag.Arg(1)
+
+	switch filepath.Ext(in) {
+	case ".FW1", ".FW2", ".FW3":
+		fw2bin(in, out)
+	case ".bin1", ".bin2", ".bin3":
+		bin2fw(in, out)
+	default:
+		die("Input file must have .bin{1,2,3} or .FW{1,2,3} extension. Aborting.")
+	}
+}
+
+func bin2fw(binPath, fwPath string) {
+
+	var area int
+	var baseAddr uint32
+	var startOffset uint32
+
+	switch filepath.Ext(binPath) {
+	case ".bin1":
+		area = 1
+		baseAddr = 0x24300000
+		startOffset = 0x200
+	case ".bin2":
+		area = 2
+		baseAddr = 0x24340000
+	case ".bin3":
+		area = 3
+		baseAddr = 0x24380000
+	default:
+		die("Input file must have .bin1, .bin2 or .bin3 extension. Aborting.")
+	}
+
+	fwPathExt := fmt.Sprintf("%s.FW%d", fwPath, area)
+
+	fmt.Printf("Loading binary data from '%s'...\n", filepath.Base(binPath))
+
+	mem, err := os.ReadFile(binPath)
+	if err != nil {
+		die("Unable to read binary file '%s': %v. Aborting.\n", os.Args[1], err)
+	}
+
+	if len(mem)%32 != 0 {
+		die("Binary must be a multiple of 32 bytes long. Aborting.")
+	}
+
+	fmt.Printf("Loaded successfully.\n")
+
+	fmt.Printf("Verifying checksums...\n")
+
+	scsl, scsh := stfw.GetChecksums(mem)
+	ccsl, ccsh := stfw.CalcChecksums(mem, int(startOffset>>1))
+
+	if scsl != ccsl {
+		fmt.Printf("Low ROM Checksum mismatch: Expected 0x%02X, Found 0x%02X. Updating.", scsl, ccsl)
+		stfw.UpdateChecksum(mem, stfw.MemoryModeCombinedLow, ccsl)
+	}
+
+	if scsh != ccsh {
+		fmt.Printf("High ROM Checksum mismatch: Expected 0x%02X, Found 0x%02X. Updating.", scsh, ccsh)
+		stfw.UpdateChecksum(mem, stfw.MemoryModeCombinedHigh, ccsh)
+	}
+
+	fmt.Printf("Writing image to '%s'...\n", filepath.Base(fwPathExt))
+
+	f, err := os.Create(fwPathExt)
+	if err != nil {
+		die("Unable to create fw file '%s': %v. Aborting.\n", fwPathExt, err)
+	}
+
+	if area == 1 {
+		fmt.Printf("Writing header for area 1 image...\n")
+
+		// write an empty serial number table. It appears TFUPD.EXE doesn't check
+		// this.
+		if _, err := f.Write(make([]byte, 0x100)); err != nil {
+			die("Error writing header: %v. Aborting.\n", err)
+		}
+	}
+
+	fmt.Printf("Writing records...\n")
+
+	for i := startOffset; i < uint32(len(mem)); i += 32 {
+		err := stfw.WriteRecord(f, &stfw.Record{
+			Addr: baseAddr + i,
+			Data: mem[i : i+32],
+		})
+		if err != nil {
+			die("Error writing record to file: %v. Aborting.\n", err)
+		}
+	}
+
+	fmt.Printf("Write complete.\n")
+	fmt.Printf("Records: %d\n", (len(mem)-int(startOffset))/32)
+	fmt.Printf("Bytes: %d\n", len(mem)-int(startOffset))
+
+	fmt.Printf("Address Range: 0x%08x - 0x%08x\n", baseAddr+startOffset, baseAddr+uint32(len(mem))-1)
+}
+
+func fw2bin(fwPath, binPath string) {
+
+	var area int
+
+	switch filepath.Ext(fwPath) {
+	case ".FW1":
+		area = 1
+	case ".FW2":
+		area = 2
+	case ".FW3":
+		area = 3
+	default:
+		die("Input file must have .FW1, .FW2 or .FW3 extension. Aborting.")
+	}
+
+	fmt.Printf("Loading image from '%s'...\n", filepath.Base(fwPath))
+
+	f, err := os.Open(fwPath)
+	if err != nil {
+		die("Unable to open input file '%s': %v. Aborting.\n", fwPath, err)
+	}
+
+	if area == 1 {
+		_, err = f.Seek(0x100, io.SeekStart)
+		if err != nil {
+			die("Unable seek past header: %v. Aborting.\n", err)
+		}
+	}
+
+	mem := make([]byte, 0x20000)
+
+	records := 0
+
+	lowAddr := uint32(0xffffffff)
+	highAddr := uint32(0)
+
+	for {
+		rec, err := stfw.ReadRecord(f)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			die("Unexpected error reading input file '%s': %v. Aborting.\n", fwPath, err)
+		}
+		if !rec.Good {
+			die("Bad checksum in record %d (Address 0x%08x). Aborting.\n", records, rec.Addr)
+		}
+		copy(mem[rec.Addr&0x1ffff:], rec.Data)
+		records++
+		if rec.Addr < lowAddr {
+			lowAddr = rec.Addr
+		}
+		if rec.Addr > highAddr {
+			highAddr = rec.Addr + 31
+		}
+
+	}
+	fmt.Printf("Loaded successfully.\n")
+	fmt.Printf("Records: %d\n", records)
+	fmt.Printf("Bytes: %d\n", records*32)
+
+	fmt.Printf("Address Range: 0x%08x-0x%08x\n", lowAddr, highAddr)
+
+	binPathExt := fmt.Sprintf("%s.bin%d", binPath, area)
+	fmt.Printf("Writing binary to '%s'...\n", filepath.Base(binPathExt))
+	err = os.WriteFile(binPathExt, mem, 0644)
+	if err != nil {
+		die("Unable write binary file: %v. Aborting.\n", err)
+	}
+
+}
+
+func die(format string, a ...interface{}) {
+	fmt.Fprintf(os.Stderr, format, a...)
+	os.Exit(1)
+}

cmd/convertx/convertx.go

@@ -0,0 +1,208 @@
+/*
+
+convertx - tools for mangling Trimble 4000 ROMs
+
+Release 1.0
+
+This is a collection of tools for working with fourth generation Trimble 4000
+GPS receiver firmware images in the .X format as included with Trimble's
+firmware update tool.
+
+Because this code was written to solve a single instance of a single problem, it
+is my tradition to write it as disposable code. This is code that is good enough
+to get the job done, and not so terrible that I can't stand to look at it. But
+no effort has been made to optimize it for memory or speed.
+
+Another consequence of this style of development is that when I write tools such
+as this, they are not stand-alone programs. I have made no effort to create a
+command line interface to this code. I have structured it in a modular manner,
+and I've used the Go paradigm of exported-functions-have-capital-letters to
+identify the useful building blocks. I then use these building blocks in the
+main() function to write a short program to accomplish the task at hand. If I
+like it, it gets spun off into its own function to save it, which then frees up
+my main() for the next project.
+
+This program is in the public domain.
+
+This program was written by Keelan Lightfoot
+http://www.beefchicken.com/
+*/
+
+package main
+
+import (
+	"code.beefchicken.com/trimtools/dotx"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+const (
+	memOpBlockSize = 244
+)
+
+func guessFileType(fn string) string {
+	switch filepath.Ext(fn) {
+	case ".X":
+		return "x"
+	case ".bin":
+		return "bin"
+	}
+	return ""
+}
+
+func main() {
+
+	var metaPath string
+
+	var printInfo bool
+	flag.BoolVar(&printInfo, "i", false, "Print image metadata")
+
+	flag.Parse()
+
+	if len(flag.Args()) != 2 {
+		fmt.Printf("Usage:\n")
+		fmt.Printf("    convertx <input>.X <output prefix>\n")
+		fmt.Printf("    convertx <input>.bin <output prefix>\n")
+		os.Exit(1)
+	}
+
+	inFile := flag.Arg(0)
+	outFile := flag.Arg(1)
+
+	fromBin := false
+	switch filepath.Ext(inFile) {
+	case ".X":
+		metaPath = outFile + ".blocks"
+		outFile = outFile + ".bin"
+	case ".bin":
+		fromBin = true
+		outFile = outFile + ".X"
+		metaPath = strings.TrimSuffix(inFile, filepath.Ext(inFile)) + ".blocks"
+	default:
+		die("Input file must have .bin or .X extension. Aborting.")
+	}
+
+	var dotX *dotx.DotXFile
+
+	if fromBin {
+		fmt.Printf("Loading block info from '%s'...\n", metaPath)
+
+		meta, err := dotx.LoadMeta(metaPath)
+		if err != nil {
+			die("Unable to read block info from '%s': %v. Aborting.\n", metaPath, err)
+		}
+
+		fmt.Printf("Loading binary image from '%s'...\n", inFile)
+
+		b, err := ioutil.ReadFile(inFile)
+		if err != nil {
+			die("Unable to read binary image from '%s': %v. Aborting.\n", inFile, err)
+		}
+		fmt.Printf("Combining block info and binary image...\n")
+
+		dotX, err = dotx.NewDotXFromMetaAndMem(meta, b)
+		if err != nil {
+			die("Unable to combine block info and binary image: %v. Aborting.\n", err)
+		}
+	} else {
+		fmt.Printf("Loading .X image from '%s'...\n", inFile)
+
+		f, err := os.Open(inFile)
+		if err != nil {
+			die("Unable to open '%s': %v. Aborting.\n", inFile, err)
+		}
+		defer f.Close()
+		dotX, err = dotx.ReadDotX(f)
+		if err != nil {
+			die("Unable to read .X image from '%s': %v. Aborting.\n", inFile, err)
+
+		}
+	}
+
+	fmt.Printf("Loaded successfully.\n")
+
+	mem := dotX.ToMemory()
+
+	if printInfo {
+		dotX.PrintInfo()
+		mem.PrintInfo()
+	}
+
+	if false {
+		// patch WNRO
+		verMaj, verMin := mem.FirmwareVersion()
+		ver := float64(verMaj) + float64(verMin)/100
+
+		if ver < 7.19 {
+			fmt.Printf("Warning: WRNO auto-patching has only been tested for firmware versions >= 7.19, use on other versions may produce unpredictable results.")
+		}
+		// Because the memory slice backs both blocks and records, the data can be modified
+		// in any of the three records types simultaneously.
+		// This will apply the WRNO patch to 732.X and 719.X
+		// 1. find the matching instructions (addi.w  #$400,d2)
+		matches := dotX.FindSequence([]uint8{0x06, 0x42, 0x04, 0x00})
+		if len(matches) == 0 {
+			fmt.Printf("Could not find ADDI.W  #$400,D2 instruction. Aborting WRNO patch attempt")
+			os.Exit(1)
+		}
+
+		mem := matches[0].Block.Bytes
+		match := matches[0].Matches[0]
+
+		fmt.Printf("Found WNRO ADDI.W at %08X\n", matches[0].Block.StartAddr+match)
+
+		// 2. change partial-rollover check cmpi to 0
+		mem[match-4] = 0
+		mem[match-3] = 0
+
+		// 2. change $400 to $800
+		mem[match+2] = 8
+
+		// 3. recalculate the block checksums
+		dotX.UpdateChecksums()
+	}
+	//
+	// 	// Example 2: extracting and saving DSP firmware
+	// 	if !strings.HasSuffix(os.Args[1], "732.X") {
+	// 		log.Fatal("Example 2 only works with 732.X")
+	// 	}
+	//dotX.ExtractSigCode(0x7201C8),
+
+	if fromBin {
+		fmt.Printf("Updating checksums...")
+
+		dotX.UpdateChecksums()
+
+		fmt.Printf("Saving .X to '%s'...\n", outFile)
+		out, err := os.Create(outFile)
+		if err != nil {
+			die("Unable write create .X file: %v. Aborting.\n", err)
+		}
+		defer out.Close()
+		err = dotX.WriteDotX(out)
+		if err != nil {
+			die("Unable write .X file: %v. Aborting.\n", err)
+		}
+	} else {
+		fmt.Printf("Saving block info to '%s'...\n", metaPath)
+		err := dotX.SaveMeta(metaPath)
+		if err != nil {
+			die("Unable write block info file: %v. Aborting.\n", err)
+		}
+		fmt.Printf("Saving binary to '%s'...\n", outFile)
+		err = dotX.SaveBinary(outFile)
+		if err != nil {
+			die("Unable write binary file: %v. Aborting.\n", err)
+		}
+	}
+
+}
+
+func die(format string, a ...interface{}) {
+	fmt.Printf(format, a...)
+	os.Exit(1)
+}

cmd/convertx/main.go

@@ -1,168 +0,0 @@
-/*
-
-convertx - tools for mangling Trimble 4000 ROMs
-
-Release 1.0
-
-This is a collection of tools for working with fourth generation Trimble 4000
-GPS receiver firmware images in the .X format as included with Trimble's
-firmware update tool.
-
-Because this code was written to solve a single instance of a single problem, it
-is my tradition to write it as disposable code. This is code that is good enough
-to get the job done, and not so terrible that I can't stand to look at it. But
-no effort has been made to optimize it for memory or speed.
-
-Another consequence of this style of development is that when I write tools such
-as this, they are not stand-alone programs. I have made no effort to create a
-command line interface to this code. I have structured it in a modular manner,
-and I've used the Go paradigm of exported-functions-have-capital-letters to
-identify the useful building blocks. I then use these building blocks in the
-main() function to write a short program to accomplish the task at hand. If I
-like it, it gets spun off into its own function to save it, which then frees up
-my main() for the next project.
-
-This program is in the public domain.
-
-This program was written by Keelan Lightfoot
-http://www.beefchicken.com/
-*/
-
-package main
-
-import (
-	"code.beefchicken.com/trimtools/dotx"
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"strings"
-)
-
-const (
-	memOpBlockSize = 244
-)
-
-
-func guessFileType(fn string) string {
-	switch filepath.Ext(fn) {
-	case ".X":
-		return "x"
-	case ".bin":
-		return "bin"
-	} 
-	return ""	
-}
-
-func main() {
-
-	var inFile,outFile,  inFileFormat, outFileFormat string
-	var printInfo bool
-
-	flag.StringVar(&inFile, "in", "", "input file")
-	flag.StringVar(&outFile, "out", "", "output file")
-	flag.StringVar(&inFileFormat, "infmt", "", "input file format (x or bin)")
-	flag.StringVar(&outFileFormat, "outfmt", "", "input file format (x or bin)")
-	flag.BoolVar(&printInfo, "i", false, "Print image metadata")
-
-	if inFileFormat == "" {
-		if inFileFormat = guessFileType(inFile, "x"); inFileFormat == "" {
-			fmt.Println("Input file format not specified and extension unrecognized. Assuming HP64000.")
-			inFileFormat = "x"
-		}
-	}
-	
-	if outFileFormat == "" {
-		if outFileFormat = guessFileType(inFile, "x"); outFileFormat == "" {
-			fmt.Println("Output file format not specified and extension unrecognized.  Assuming binary.")
-			outFileFormat = "bin"
-		}
-	}
-
-	flag.Parse()
-
-	if inFile == "" {
-		fmt.Printf("Input file is required.")
-		os.Exit(1)
-	}
-	
-	if outFile == "" {
-		fmt.Printf("Input file is required.")
-		os.Exit(1)
-	}
-
-	// load file
-	f, err := os.Open(inFile)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer f.Close()
-
-	dotX, err := dotx.ReadDotX(f)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	dotX.Blocks[2].ToRecords(memOpBlockSize)
-
-	mem := dotX.ToMemory()
-
-	if printInfo {
-		dotX.PrintInfo()
-		mem.PrintInfo()
-	}
-
-	// 	if patchWNRO {
-	//
-	// 		verMaj, verMin := mem.FirmwareVersion()
-	// 		ver := float64(verMaj) + float64(verMin)/100
-	//
-	// 		if ver < 7.19 {
-	// 			fmt.Printf("Warning: WRNO auto-patching has only been tested for firmware versions >= 7.19, use on other versions may produce unpredictable results.")
-	// 		}
-	// 		// Because the memory slice backs both blocks and records, the data can be modified
-	// 		// in any of the three records types simultaneously.
-	// 		// This will apply the WRNO patch to 732.X and 719.X
-	// 		// 1. find the matching instructions (addi.w  #$400,d2)
-	// 		matches := mem.FindSequence([]uint8{0x06, 0x42, 0x04, 0x00})
-	// 		if len(matches) == 0 {
-	// 			fmt.Printf("Could not find ADDI.W  #$400,D2 instruction. Aborting WRNO patch attempt")
-	// 			os.Exit(1)
-	// 		}
-	// 		// 2. change partial-rollover check cmpi to 0
-	// 		mem.Memory[matches[0]-4] = 0
-	// 		mem.Memory[matches[0]-3] = 0
-	//
-	// 		// 2. change $400 to $800
-	// 		mem.Memory[matches[0]+2] = 8
-	//
-	// 		// 3. recalculate the block checksums
-	// 		mem.UpdateChecksums()
-	// 	}
-	//
-	// 	// Example 2: extracting and saving DSP firmware
-	// 	if !strings.HasSuffix(os.Args[1], "732.X") {
-	// 		log.Fatal("Example 2 only works with 732.X")
-	// 	}
-	//dotX.ExtractSigCode(0x7201C8),
-
-	if binOut != "" {
-		err := dotX.SaveBinary(binOut)
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-
-	if xOut != "" {
-		out, err := os.Create(xOut)
-		if err != nil {
-			log.Fatal(err)
-		}
-		defer out.Close()
-		err = dotX.WriteDotX(out)
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-
-}

cmd/loader/main.go → cmd/loader/loader.go

@@ -43,20 +43,24 @@ func main() {
 	var fw *dotx.DotXFile
 
 	var mon *monitor.Monitor
+	var rec *monitor.Receiver
+
 	var err error
 
 	if dummy {
 		mon = &monitor.Monitor{
-			Debug: debug,
+			//			Debug: debug,
 			Dummy: dummy,
 		}
 		fmt.Println("Monitor dummy mode active.")
 
 	} else {
-		mon, err = monitor.Connect(device, baud, 8, 1, parity, debug)
+
+		rec, err = monitor.Connect(device, baud, 8, 1, parity, debug)
 		if err != nil {
 			log.Fatal(err)
 		}
+		mon = monitor.NewMonitor(rec)
 		defer mon.Close()
 	}
 
@@ -445,7 +449,7 @@ func handleJCommand(mon *monitor.Monitor, cmd []string) bool {
 		fmt.Printf("invalid address: '%s'\n", cmd[1])
 		return false
 	}
-	mon.Jump(addr)
+	mon.CmdJump(addr)
 	return false
 }
 

cmd/romknife/romknife.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"code.beefchicken.com/trimtools/stfw"
+	"flag"
+	"fmt"
+	"os"
+)
+
+func main() {
+
+	var combine, split bool
+	flag.BoolVar(&combine, "c", false, "combine ROM images")
+	flag.BoolVar(&split, "s", false, "split ROM images")
+
+	flag.Parse()
+
+	if len(flag.Args()) != 3 || !(combine || split) || combine && split {
+		fmt.Printf("Usage:\n")
+		fmt.Printf("    romknife -c <low> <high> <combined>\n")
+		fmt.Printf("    romknife -s <combined> <low> <high>\n")
+		os.Exit(1)
+	}
+
+	if combine {
+		low, err := os.ReadFile(flag.Arg(0))
+		if err != nil {
+			die("Unable to read '%s': %v. Aborting.\n", flag.Arg(0), err)
+		}
+
+		high, err := os.ReadFile(flag.Arg(1))
+		if err != nil {
+			die("Unable to read '%s': %v. Aborting.\n", flag.Arg(1), err)
+		}
+
+		if len(low) != len(high) {
+			die("Low and High file sizes must match. Aborting.\n")
+		}
+
+		combined := stfw.MergeBin(low, high)
+
+		err = os.WriteFile(flag.Arg(2), combined, 0644)
+		if err != nil {
+			die("Unable to write output to '%s': %v. Aborting.\n", flag.Arg(2), err)
+		}
+	}
+
+	if split {
+		combined, err := os.ReadFile(flag.Arg(0))
+		if err != nil {
+			die("Unable to read '%s': %v. Aborting.\n", flag.Arg(0), err)
+		}
+
+		if len(combined)%2 != 0 {
+			die("Combined must have even size. Aborting.\n")
+		}
+
+		low, high := stfw.SplitBin(combined)
+
+		err = os.WriteFile(flag.Arg(1), low, 0644)
+		if err != nil {
+			die("Unable to write file '%s': %v. Aborting.\n", flag.Arg(1), err)
+		}
+
+		err = os.WriteFile(flag.Arg(2), high, 0644)
+		if err != nil {
+			die("Unable to write file '%s': %v. Aborting.\n", flag.Arg(2), err)
+		}
+
+	}
+
+}
+
+func die(format string, a ...interface{}) {
+	fmt.Fprintf(os.Stderr, format, a...)
+	os.Exit(1)
+}

dotx/dotx.go

@@ -32,6 +32,8 @@ package dotx
 import (
 	"bytes"
 	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -42,14 +44,13 @@ import (
 )
 
 type DotXFile struct {
-	ProductionFlag  uint8
-	HeaderText      string
-	TransferAddress uint32
-	DataBusWidth    uint16
-	DataWidthBase   uint16
-
+	ProductionFlag  uint8  `json:"productionFlag"`
+	HeaderText      string `json:"headerText"`
+	TransferAddress uint32 `json:"transferAddress"`
+	DataBusWidth    uint16 `json:"dataBusWidth"`
+	DataWidthBase   uint16 `json:"dataWidthBase"`
 	// 	Memory          []byte
-	Blocks []*Block
+	Blocks []*Block `json:"blocks"`
 	//	Records			[]*DataRecord
 }
 
@@ -204,6 +205,32 @@ func (dotX *DotXFile) ToMemory() *Memory {
 	return m
 }
 
+func LoadMeta(metaFN string) (*DotXFile, error) {
+	b, err := ioutil.ReadFile(metaFN)
+	if err != nil {
+		return nil, err
+	}
+	dotX := &DotXFile{}
+	if err = json.Unmarshal(b, dotX); err != nil {
+		return nil, err
+	}
+
+	return dotX, nil
+}
+
+func NewDotXFromMetaAndMem(dotX *DotXFile, mem []byte) (*DotXFile, error) {
+
+	for _, block := range dotX.Blocks {
+		if block.Bytes == nil {
+			block.Bytes = make([]byte, block.Len()+1)
+			copy(block.Bytes, mem[block.StartAddr:block.EndAddr+1])
+		}
+	}
+	dotX.UpdateChecksums()
+	return dotX, nil
+
+}
+
 func NewDotX() *DotXFile {
 	return &DotXFile{
 		DataBusWidth:  16,
@@ -235,7 +262,7 @@ func (dotX *DotXFile) WriteDotX(f *os.File) error {
 	trimbleHeader := make([]byte, 18)
 	trimbleHeader[0] = 0x82 // ?
 	trimbleHeader[1] = 0x04 // magic number
-	trimbleHeader[2] = 0x00 // ?
+	trimbleHeader[2] = 0x38 // 0x00 for 4000, 0x38 for 4400?
 	copy(trimbleHeader[3:17], dotX.HeaderText)
 	trimbleHeader[17] = dotX.ProductionFlag // Production Version
 	f.Write(trimbleHeader)
@@ -252,32 +279,27 @@ func (dotX *DotXFile) WriteDotX(f *os.File) error {
 	if err != nil {
 		return err
 	}
-	cs1 := &DataRecord{
-		Addr:  0x00FFFA54,
-		Bytes: []byte{0x70, 0x07, 0x78, 0x71},
-	}
-	err = cs1.Write(f)
-	if err != nil {
-		return err
-	}
-	cs2 := &DataRecord{
-		Addr:  0x00FFFA46,
-		Bytes: []byte{0x03, 0xF5},
-	}
-	err = cs2.Write(f)
-	if err != nil {
-		return err
-	}
+	// cs1 := &DataRecord{
+	// 		Addr:  0x00FFFA54,
+	// 		Bytes: []byte{0x70, 0x07, 0x78, 0x71},
+	// 	}
+	// 	err = cs1.Write(f)
+	// 	if err != nil {
+	// 		return err
+	// 	}
+	// 	cs2 := &DataRecord{
+	// 		Addr:  0x00FFFA46,
+	// 		Bytes: []byte{0x03, 0xF5},
+	// 	}
+	// 	err = cs2.Write(f)
+	// 	if err != nil {
+	// 		return err
+	// 	}
 
 	for _, block := range dotX.Blocks {
-		if !block.Checksummable() {
-			continue
-		}
-		for _, rec := range block.ToRecords(244) {
-			err = rec.Write(f)
-			if err != nil {
-				return err
-			}
+		err = block.Write(f)
+		if err != nil {
+			return err
 		}
 	}
 
@@ -290,8 +312,37 @@ func WriteBinary(memory []byte, outfile string) error {
 }
 
 func (dotX *DotXFile) SaveBinary(outfile string) error {
-	//err := ioutil.WriteFile(outfile, []byte(dotX.Memory), 0644)
-	return nil //err
+	memory := dotX.ToMemory()
+	err := ioutil.WriteFile(outfile, []byte(memory.Memory), 0644)
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+func (dotX *DotXFile) SaveMeta(outfile string) error {
+
+	clone := *dotX
+	clone.Blocks = make([]*Block, len(dotX.Blocks))
+
+	for i, block := range dotX.Blocks {
+		b := *block
+		if block.Checksummable() {
+			b.Bytes = nil
+		}
+		clone.Blocks[i] = &b
+	}
+
+	b, err := json.MarshalIndent(clone, "", "  ")
+	if err != nil {
+		return err
+	}
+	err = ioutil.WriteFile(outfile, b, 0644)
+
+	return err
+
 }
 
 func (m *Memory) ExtractSigCode(baseAddr uint32) []byte {
@@ -397,25 +448,37 @@ func (dotX *DotXFile) PrintBlocks() {
 
 }
 
-// func (m *Memory) FindSequence(seq []byte) []uint32 {
-//
-// 	matches := make([]uint32, 0)
-// 	for _, block := range dotX.Blocks {
-// 		for i := 0; i <= len(block.Bytes)-len(seq); i++ {
-// 			if bytes.Compare(block.Bytes[i:i+len(seq)], seq) == 0 {
-// 				matches = append(matches, uint32(i)+block.StartAddr)
-// 			}
-// 		}
-// 	}
-// 	return matches
-//
-// }
+type SequenceMatch struct {
+	Block   *Block
+	Matches []uint32
+}
 
-// func (dotX *DotXFile) UpdateChecksums() {
-// 	for _, block := range dotX.Blocks {
-// 		block.UpdateChecksum()
-// 	}
-// }
+func (dotX *DotXFile) FindSequence(seq []byte) []SequenceMatch {
+
+	matches := make([]SequenceMatch, 0)
+	for _, block := range dotX.Blocks {
+		blockMatches := make([]uint32, 0)
+		for i := 0; i <= len(block.Bytes)-len(seq); i++ {
+			if bytes.Compare(block.Bytes[i:i+len(seq)], seq) == 0 {
+				blockMatches = append(blockMatches, uint32(i)+block.StartAddr)
+			}
+		}
+		if len(blockMatches) > 0 {
+			matches = append(matches, SequenceMatch{
+				Block:   block,
+				Matches: blockMatches,
+			})
+		}
+	}
+	return matches
+
+}
+
+func (dotX *DotXFile) UpdateChecksums() {
+	for _, block := range dotX.Blocks {
+		block.UpdateChecksum()
+	}
+}
 
 type processorRecord struct {
 	Length            uint16
@@ -464,10 +527,41 @@ func (d *DataRecord) Write(f *os.File) error {
 	return nil
 }
 
+type hexByte []byte
+
+func (w *hexByte) MarshalJSON() ([]byte, error) {
+	return []byte(`"` + hex.EncodeToString(*w) + `"`), nil
+}
+
+func (w *hexByte) UnmarshalJSON(b []byte) error {
+	b, err := hex.DecodeString(string(b[1 : len(b)-1]))
+	if err != nil {
+		return err
+	}
+	*w = b
+	return nil
+}
+
 type Block struct {
-	StartAddr uint32
-	EndAddr   uint32
-	Bytes     []byte
+	StartAddr uint32  `json:"startAddr"`
+	EndAddr   uint32  `json:"endAddr"`
+	Bytes     hexByte `json:"data,omitempty"`
+}
+
+func (b *Block) Write(f *os.File) error {
+	if b.Checksummable() {
+		err := b.UpdateChecksum()
+		if err != nil {
+			return err
+		}
+	}
+	for _, rec := range b.ToRecords(244) {
+		err := rec.Write(f)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 func (b *Block) Len() int {
@@ -529,8 +623,14 @@ func (b *Block) CalculateChecksum() (uint32, error) {
 	return checksum, nil
 }
 
+//func (b *Block) UpdateChecksum() error {
+
 func (b *Block) UpdateChecksum() error {
 
+	if !b.Checksummable() {
+		return fmt.Errorf("block too small for checksum")
+	}
+
 	checksum, err := b.CalculateChecksum()
 	if err != nil {
 		return err

monitor/monitor.go

@@ -5,7 +5,7 @@ import (
 	"code.beefchicken.com/trimtools/dotx"
 	"encoding/binary"
 	"fmt"
-	"github.com/jacobsa/go-serial/serial"
+	//	"github.com/jacobsa/go-serial/serial"
 	"io"
 	"strconv"
 	"strings"
@@ -31,28 +31,17 @@ const (
 )
 
 type Monitor struct {
-	port       io.ReadWriteCloser
-	device     string
-	baud       uint
-	dataBits   uint
-	stopBits   uint
-	parity     serial.ParityMode
-	portConfig serial.OpenOptions
-
 	receiverType ReceiverType
-
-	Debug bool
-	Dummy bool
-
-	inMonitor bool
-	
-	seekPos uint32
+	Dummy        bool
+	inMonitor    bool
+	receiver     *Receiver
+	seekPos      uint32
 }
 
-type RecieverState int
+type ReceiverState int
 
 const (
-	ReceiverUnexpected RecieverState = iota
+	ReceiverUnexpected ReceiverState = iota
 	ReceiverUnresponsive
 	ReceiverNormal
 	ReceiverInMonitor
@@ -65,24 +54,21 @@ const (
 	ReceiverType4400
 )
 
+func NewMonitor(receiver *Receiver) *Monitor {
+	return &Monitor{receiver: receiver}
+}
+
 func (m *Monitor) StartMonitor() error {
+
 	if m.Dummy {
 		m.inMonitor = true
 		return nil
 	}
 	fmt.Println("Starting monitor mode...")
 
-	//	m.FlushInput()
-
-	// figure out baud and parity
-	err := m.DeterminePortConfig()
-	if err != nil {
-		return err
-	}
-
 	// once we have something that looks like a receiver on the line, figure
 	// out what mode it's in.
-	state, err := m.checkMonitorMode()
+	state, err := m.receiver.ProbeReceiverState()
 	if err != nil {
 		return err
 	}
@@ -93,72 +79,72 @@ func (m *Monitor) StartMonitor() error {
 
 	if state == ReceiverNormal {
 		// get config
-		conf, err := m.GetRuntimeConfig()
+		conf, err := m.CmdGetRuntimeConfig()
 		if err != nil {
 			return err
 		}
 		fmt.Printf("PPU Version = %.2f\n", conf.BootRomVersion)
 
-		opts, err := m.GetOptions()
+		opts, err := m.CmdGetOptions()
 		if opts.ReceiverType == 3 { // gauss
 
 		}
 		// switch to monitor mode
-		err = m.DoAckCommand(NrmCmdModeChange, []byte{0x57}) // I don't know what 0x57 means, it's straight from the port monitor
+		err = m.receiver.DoAckCommand(NrmCmdModeChange, []byte{0x57}) // 0x57 is what an ack at 38400 looks like at 9600 baud.
 		if err != nil {
 			return err
 		}
 
 		// When the monitor starts, it reverts back to 9600-N-8-1, so we have to
 		// re-configure the serial port.
-		err = m.useSlowBaudRate()
+		err = m.receiver.useSlowBaudRate()
 		if err != nil {
 			return err
 		}
 
 		// It can take a while to boot into monitor mode
-		err = m.waitForMonitor()
+		err = m.receiver.waitForMonitor()
 		if err != nil {
 			return err
 		}
-
-		// reconfigure monitor to speak at 38400-N-8-1
-		// 0x6D = 4800
-		// 0x37 = 9600
-		// 0x1B = 19200
-		// 0x0E = 38400
-		// This appears to respond with 0xFE, but that is just is what a 38400
-		// baud ACK (0x06) looks like when received at 9600 baud, and depending
-		// on where in the bit the UART samples, different UARTs might see
-		// different values, so we just ignore any no-ack error.
-
-		err = m.DoAckCommand(MonCmdBaudRate, []byte{0x00, 0x0E})
-		if err != nil {
-			if _, ok := err.(*ProtocolError); !ok {
-				return err
-			}
-		}
-
-		// re-configure port for 38400 baud
-		err = m.useFastBaudRate()
-		if err != nil {
+	}
+	// reconfigure monitor to speak at 38400-N-8-1
+	// 0x6D = 4800
+	// 0x37 = 9600
+	// 0x1B = 19200
+	// 0x0E = 38400
+	// This appears to respond with 0xFE, but that is just is what a 38400
+	// baud ACK (0x06) looks like when received at 9600 baud, and depending
+	// on where in the bit the UART samples, different UARTs might see
+	// different values, so we just ignore any no-ack error.
+
+	err = m.receiver.DoAckCommand(MonCmdBaudRate, []byte{0x00, 0x0E})
+	if err != nil {
+		if _, ok := err.(*ProtocolError); !ok {
 			return err
 		}
+	}
 
-		// Make sure baud switch was successful
-		err = m.waitForMonitor()
-		if err != nil {
-			return err
-		}
+	// re-configure port for 38400 baud
+	err = m.receiver.useFastBaudRate()
+	if err != nil {
+		return err
+	}
 
+	// Make sure baud switch was successful
+	err = m.receiver.waitForMonitor()
+	if err != nil {
+		return err
 	}
+
+	//	}
 	m.inMonitor = true
 
 	// we should be in monitor mode now.
 
 	fmt.Printf("Setting chip selects...\n")
 
-	err = m.setupChipSelects()
+	err = m.setChipSelects()
 	if err != nil {
 		return err
 	}
@@ -170,7 +156,7 @@ func (m *Monitor) StartMonitor() error {
 	return nil
 }
 
-func (m *Monitor) setupChipSelects() error {
+func (m *Monitor) setChipSelects() error {
 
 	// I don't understand the mechanism the PPU uses to communicate to the
 	// system memory. The chip select registers only apply to signals originating
@@ -251,68 +237,25 @@ func (m *Monitor) setupChipSelects() error {
 	return nil
 }
 
-// waitForMonitor blocks until the receiver has entered monitor mode.
-// It can take a while for the receiver to boot into monitor mode, this
-// function tests the state of the receiver by repeatedly sending an ENQ
-// command. When the monitor is ready, it will send an ACK.
-func (m *Monitor) waitForMonitor() error {
-	fmt.Println("Waiting for monitor to become ready...")
-	for i := 0; i < 30; i++ {
-		if ok, err := m.EnqAckTest(); ok {
-			return nil
-		} else if err != nil {
-			return err
-		}
-	}
-	return fmt.Errorf("timed out waiting for monitor")
-}
-
 // Stop sends a reboot, which disconnects the monitor, and reconfigures the port back
 // to the user configuration.
 func (m *Monitor) Stop() error {
-
-	// send the reboot command
-	err := m.SendStxEtxRequest(MonCmdReset, []byte{})
-	if err != nil {
-		return err
-	}
-
-	m.inMonitor = false
-
-	// it seems that if I switch the baud rate too soon, the UART will still
-	// be transmitting the above data, which will corrupt the command.
-	time.Sleep(2 * time.Second)
-
-	// revert the serial port
-	err = m.useUserBaudRate()
-	if err != nil {
-		return err
-	}
-
-	return nil
+	return m.CmdResetReceiver()
 }
 
 // Close closes the serial port associated with the monitor
 func (m *Monitor) Close() {
-	m.port.Close()
+	m.receiver.port.Close()
 }
 
 // ReadMemory reads the device memory, breaking the read up into multiple
 // commands as needed.
 func (m *Monitor) ReadMemory(addr uint32, length int) ([]byte, error) {
-	return m.ReadMemoryWithProgress(addr, length, nil)
-}
-
-// ReadMemory reads the device memory, breaking the read up into multiple
-// commands as needed.
-func (m *Monitor) ReadMemoryWithProgress(addr uint32, length int, progressFunc func(uint32)) ([]byte, error) {
 	if !m.inMonitor {
 		return nil, fmt.Errorf("receiver not in monitor")
 	}
 	//fmt.Printf("ReadMemory: addr=%08X length=%d\n", addr, length)
 
-	maxRetries := 3
-
 	out := make([]byte, 0)
 	for i := 0; i < length; i += readWriteBlockSize {
 		l := readWriteBlockSize
@@ -320,44 +263,46 @@ func (m *Monitor) ReadMemoryWithProgress(addr uint32, length int, progressFunc f
 			l = length - i
 		}
 
-		b := make([]byte, 5)
-
 		blockAddr := addr + uint32(i)
 
-		binary.BigEndian.PutUint32(b[0:4], blockAddr)
-		b[4] = byte(l)
+		b, err := m.CmdReadMemory(blockAddr, uint8(l))
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, b...)
+	}
+	return out, nil
+}
 
-		//fmt.Printf("ReadMemory LOOP: addr=%08X length=%d\n", blockAddr, l)
+func (m *Monitor) CmdReadMemory(addr uint32, length uint8) ([]byte, error) {
+	b := make([]byte, 5)
+	binary.BigEndian.PutUint32(b[0:4], addr)
+	b[4] = byte(length)
 
-		var err error
+	//fmt.Printf("CmdReadMemory: addr=%08X length=%d\n", blockAddr, l)
 
-		for r := 0; r < maxRetries; r++ {
-			if r > 0 {
-				fmt.Printf("ReadMemory: read failed: %v. Retrying.\n", err)
-			}
-			var reply *CommandReply
-			if reply, err = m.DoStxEtxCommand(MonCmdReadMem, b); err != nil {
-				continue
-			}
-			if reply.Command != MonCmdReadMemAck || reply.Status != 0 {
-				err = newProtocolError("unexpected response from read memory")
-				continue
-			}
-			if replyAddr := binary.BigEndian.Uint32(reply.Data[0:4]); replyAddr != blockAddr {
-				err = newProtocolError("address mismatch in read reply. expected 0x%06X, received 0x%06X", addr, replyAddr)
-				continue
-			}
-			out = append(out, reply.Data[4:]...)
-			break
+	var err error
+	const maxRetries = 3
+
+	for r := 0; r < maxRetries; r++ {
+		if r > 0 {
+			fmt.Printf("CmdReadMemory: read failed: %v. Retrying.\n", err)
 		}
-		if err != nil {
-			return nil, err
+		var reply *CommandReply
+		if reply, err = m.receiver.DoStxEtxCommand(MonCmdReadMem, b); err != nil {
+			continue
+		}
+		if reply.Command != MonCmdReadMemAck || reply.Status != 0 {
+			err = newProtocolError("unexpected response from read memory")
+			continue
 		}
-		if progressFunc != nil {
-			progressFunc(blockAddr)
+		if replyAddr := binary.BigEndian.Uint32(reply.Data[0:4]); replyAddr != addr {
+			err = newProtocolError("address mismatch in read reply. expected 0x%06X, received 0x%06X", addr, replyAddr)
+			continue
 		}
+		return reply.Data[4:], nil
 	}
-	return out, nil
+	return nil, err
 }
 
 // WriteMemory writes the device memory, breaking the write up into multiple
@@ -372,33 +317,15 @@ func (m *Monitor) WriteMemory(addr uint32, data interface{}) error {
 	b := buf.Bytes()
 	length := len(b)
 
-	maxRetries := 3
-
 	for i := 0; i < length; i += readWriteBlockSize {
 		l := readWriteBlockSize
 		if i+l > length {
 			l = length - i
 		}
 
-		buf := make([]byte, 4)
 		blockAddr := addr + uint32(i)
-		// for writes the address words are in little endian order, but the bytes
-		// within the words are in big endian order
-		binary.BigEndian.PutUint16(buf[0:2], uint16(blockAddr&0xFFFF))
-		binary.BigEndian.PutUint16(buf[2:4], uint16(blockAddr>>16&0xFFFF))
-		buf = append(buf, b[i:i+l]...)
-
-		var err error
-		for r := 0; r < maxRetries; r++ {
-			if r > 0 {
-				fmt.Printf("WriteMemory: write failed: %v. Retrying.\n", err)
-			}
-			err = m.DoAckCommand(MonCmdWriteMem, buf)
-			if err == nil {
-				break
-			}
-		}
 
+		err := m.CmdWriteMemory(blockAddr, b[i:i+l])
 		if err != nil {
 			return err
 		}
@@ -406,55 +333,66 @@ func (m *Monitor) WriteMemory(addr uint32, data interface{}) error {
 	return nil
 }
 
+func (m *Monitor) CmdWriteMemory(addr uint32, data []byte) error {
+	const maxRetries = 3
+	buf := make([]byte, 4)
+	// for writes the address words are in little endian order, but the bytes
+	// within the words are in big endian order
+	binary.BigEndian.PutUint16(buf[0:2], uint16(addr&0xFFFF))
+	binary.BigEndian.PutUint16(buf[2:4], uint16(addr>>16&0xFFFF))
+	buf = append(buf, data...)
+
+	var err error
+	for r := 0; r < maxRetries; r++ {
+		if r > 0 {
+			fmt.Printf("CmdWriteMemory: write failed: %v. Retrying.\n", err)
+		}
+		err = m.receiver.DoAckCommand(MonCmdWriteMem, buf)
+		if err == nil {
+			break
+		}
+
+	}
+
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
 // Jump calls the monitor's jump command.
-func (m *Monitor) Jump(addr uint32) error {
+func (m *Monitor) CmdJump(addr uint32) error {
 	if !m.inMonitor {
 		return fmt.Errorf("receiver not in monitor")
 	}
 	b := make([]byte, 4)
 	binary.BigEndian.PutUint32(b[0:4], addr)
 
-	return m.DoAckCommand(MonCmdJmp, b)
+	return m.receiver.DoAckCommand(MonCmdJmp, b)
 }
 
 // ResetReceiver calls the monitor's reset command.
-func (m *Monitor) ResetReceiver() error {
+func (m *Monitor) CmdResetReceiver() error {
 	if !m.inMonitor {
 		return fmt.Errorf("receiver not in monitor")
 	}
-	err := m.SendStxEtxRequest(MonCmdReset, []byte{})
+	err := m.receiver.SendStxEtxRequest(MonCmdReset, []byte{})
 	if err != nil {
 		return err
 	}
 	m.inMonitor = false
-	return nil
-}
 
-// checkMonitorMode checks if the receiver is in normal mode or monitor mode.
-// this is done by running command 0x82, which in normal mode is the screen dump
-// command, which replies with a packet of type 0x82. In monitor mode, the
-// command replies with a packet of type 0x92. If the receiver responds with
-// a 0x92 packet, we know it's in monitor mode.
-func (m *Monitor) checkMonitorMode() (RecieverState, error) {
-	fmt.Println("Preforming dummy read to determine monitor state...")
-
-	b := make([]byte, 5)
-
-	binary.BigEndian.PutUint32(b[0:], 0x80000) // 'safe' dummy location to read from, I think it's the RAM base address
-	b[4] = 2                                   // read 2 bytes
+	// it seems that if I switch the baud rate too soon, the UART will still
+	// be transmitting the above data, which will corrupt the command.
+	time.Sleep(2 * time.Second)
 
-	r, err := m.DoStxEtxCommand(MonCmdReadMem, b)
+	// revert the serial port
+	err = m.receiver.useUserBaudRate()
 	if err != nil {
-		return ReceiverUnresponsive, err
-	}
-
-	if r.Command == MonCmdReadMemAck && r.Status == 0 {
-		fmt.Println("Receiver appears to be in monitor mode.")
-		return ReceiverInMonitor, nil
+		return err
 	}
 
-	fmt.Println("Receiver appears to be in normal mode.")
-	return ReceiverNormal, nil
+	return nil
 }
 
 // ReceiverInfo holds all the information we can glean from the receiver by
@@ -654,9 +592,7 @@ func (m *Monitor) CaptureReceiverFirmware() (*dotx.DotXFile, error) {
 
 	for _, block := range codeBlocks {
 		blockLen := block.Len()
-		b, err := m.ReadMemoryWithProgress(block.StartAddr, blockLen, func(i uint32) {
-			fmt.Printf("$%08X  %s\r", i, progressBar(50, int(i-block.StartAddr)+bytesWriten, totalBytes))
-		})
+		b, err := m.ReadMemory(block.StartAddr, blockLen)
 		if err != nil {
 			return nil, err
 		}
@@ -665,14 +601,18 @@ func (m *Monitor) CaptureReceiverFirmware() (*dotx.DotXFile, error) {
 		bytesWriten += blockLen
 	}
 
+	// func(i uint32) {
+	// 	fmt.Printf("$%08X  %s\r", i, progressBar(50, int(i-block.StartAddr)+bytesWriten, totalBytes))
+	// }
+
 	return dotX, nil
 }
 
-func (m *Monitor) GetRuntimeConfig() (*RuntimeConfig, error) {
+func (m *Monitor) CmdGetRuntimeConfig() (*RuntimeConfig, error) {
 	if m.inMonitor {
 		return nil, fmt.Errorf("receiver not in normal mode")
 	}
-	r, err := m.DoStxEtxCommand(NrmCmdGetSerial, []byte{})
+	r, err := m.receiver.DoStxEtxCommand(NrmCmdGetSerial, []byte{})
 	if err != nil {
 		return nil, err
 	}
@@ -738,11 +678,11 @@ type Options struct {
 	ReceiverType       int
 }
 
-func (m *Monitor) GetOptions() (*Options, error) {
+func (m *Monitor) CmdGetOptions() (*Options, error) {
 	if m.inMonitor {
 		return nil, fmt.Errorf("receiver not in normal mode")
 	}
-	r, err := m.DoStxEtxCommand(NrmCmdGetOpt, []byte{})
+	r, err := m.receiver.DoStxEtxCommand(NrmCmdGetOpt, []byte{})
 	if err != nil {
 		return nil, err
 	}
@@ -865,17 +805,18 @@ func (m *Monitor) ProgramReceiver(fw *dotx.DotXFile) error {
 	}
 
 	fmt.Printf("Rebooting receiver.\n")
-	return m.ResetReceiver()
+	return m.CmdResetReceiver()
 }
 
-// Reader implements the io.Reader interface
-func (m *Monitor) xRead(p []byte) (n int, err error) {
-	p, err = m.ReadMemoryWithProgress(m.seekPos, len(p), nil)
+// Read implements the io.ReadSeeker interface
+func (m *Monitor) Read(p []byte) (n int, err error) {
+	p, err = m.ReadMemory(m.seekPos, len(p))
+	m.seekPos += uint32(len(p))
 	return len(p), err
 }
 
-// Seek implements the io.Seeker interface
-func (m *Monitor) xSeek(offset int64, whence int) (int64, error) { 
+// Seek implements the io.ReadSeeker interface
+func (m *Monitor) Seek(offset int64, whence int) (int64, error) {
 	var abs int64
 	switch whence {
 	case io.SeekStart:
@@ -891,3 +832,130 @@ func (m *Monitor) xSeek(offset int64, whence int) (int64, error) {
 	m.seekPos = uint32(abs)
 	return abs, nil
 }
+
+func ReadMemory(f io.ReadSeeker, addr uint32, length int) ([]byte, error) {
+	_, err := f.Seek(int64(addr), io.SeekStart)
+	if err != nil {
+		return nil, err
+	}
+	b := make([]byte, length)
+	_, err = f.Read(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
+
+type RawReceiverInfo struct {
+	Options            [60]byte
+	Name1              [36]byte
+	Name2              [36]byte
+	SerialNumberString [15]byte
+	SerialNumber       uint32
+}
+
+// GetReceiverInfo reads receiver information out of the receiver. Unlike GetOptions
+// and GetRuntimeConfig, this reads the values straight out of memory.
+func GetReceiverInfo(f io.ReadSeeker) (*ReceiverInfo, error) {
+
+	info := &ReceiverInfo{}
+
+	// Read the receiver-specific configuration.
+	// 0x80600 and 0x22d both contain the same data, but for some reason some
+	// code reads from one area and some from the other.
+	b, err := ReadMemory(f, 0x80600, 0x97)
+	if err != nil {
+		return nil, err
+	}
+	info.OptionMemory = b[0:60]
+	info.Name1 = cStrtoGoStr(b[60:96])
+	info.Name2 = cStrtoGoStr(b[96:132])
+	info.SerialNumberString = cStrtoGoStr(b[132:147])
+	info.SerialNumber = int(binary.BigEndian.Uint32(b[147:151]))
+
+	configBase := uint32(0x000001F0)
+
+	// read the configuration memory
+	b, err = ReadMemory(f, configBase, 0x3A)
+	if err != nil {
+		return nil, err
+	}
+	info.ConfigMemory = b
+
+	date := int(binary.BigEndian.Uint32(info.ConfigMemory[0x222-configBase:]))
+	month := date / 10000
+	day := date / 100 % 100
+	year := date % 100
+	if year >= 80 {
+		year += 1900
+	} else {
+		year += 2000
+	}
+	info.FirmwareDate = time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC)
+
+	ver := int(binary.BigEndian.Uint16(info.ConfigMemory[0x204-configBase:]))
+	info.FirmwareVersionMajor = ver / 100
+	info.FirmwareVersionMinor = ver % 100
+	info.FirmwareVersion = float64(ver) / 100
+
+	info.Code1Start = binary.BigEndian.Uint32(info.ConfigMemory[0x1f0-configBase:])
+	info.Code1End = binary.BigEndian.Uint32(info.ConfigMemory[0x1f4-configBase:])
+	info.Code2Start = binary.BigEndian.Uint32(info.ConfigMemory[0x1f8-configBase:])
+	info.Code2End = binary.BigEndian.Uint32(info.ConfigMemory[0x1fc-configBase:])
+
+	// read checksums
+	b, err = ReadMemory(f, info.Code1End-12, 4)
+	if err != nil {
+		return nil, err
+	}
+	info.Code1Checksum = binary.BigEndian.Uint32(b)
+	b, err = ReadMemory(f, info.Code2End-12, 4)
+	if err != nil {
+		return nil, err
+	}
+	info.Code2Checksum = binary.BigEndian.Uint32(b)
+
+	if info.FirmwareVersion > 5.60 {
+	}
+	return info, nil
+}
+
+func CaptureReceiverFirmware(f io.ReadSeeker) (*dotx.DotXFile, error) {
+
+	info, err := GetReceiverInfo(f)
+	if err != nil {
+		return nil, err
+	}
+	dotX := dotx.NewDotX()
+
+	// these chip selects are hard-coded into the first two records in the file
+	dotX.AddBlock(0x00FFFA54, []byte{0x70, 0x07, 0x78, 0x71})
+	dotX.AddBlock(0x00FFFA46, []byte{0x03, 0xF5})
+
+	// then the code blocks
+	codeBlocks := []*dotx.Block{
+		{StartAddr: info.Code1Start, EndAddr: info.Code1End},
+		{StartAddr: info.Code2Start, EndAddr: info.Code2End},
+	}
+
+	totalBytes := 0
+
+	for _, cb := range codeBlocks {
+		totalBytes += cb.Len()
+	}
+
+	bytesWriten := 0
+
+	for _, block := range codeBlocks {
+		blockLen := block.Len()
+		b, err := ReadMemory(f, block.StartAddr, blockLen)
+		if err != nil {
+			return nil, err
+		}
+		block.Bytes = b
+		dotX.Blocks = append(dotX.Blocks, block)
+		bytesWriten += blockLen
+	}
+
+	return dotX, nil
+}

monitor/protocol.go

@@ -1,153 +0,0 @@
-package monitor
-
-import (
-	"fmt"
-	"io"
-)
-
-const (
-	MAXPACKETLLEN = 255 + 6
-)
-
-type ProtocolError struct {
-	err string
-}
-
-func newProtocolError(format string, a ...interface{}) error {
-	return &ProtocolError{err: fmt.Sprintf(format, a...)}
-}
-
-func (e *ProtocolError) Error() string {
-	return e.err
-}
-
-func (m *Monitor) EnqAckTest() (bool, error) {
-	buf := make([]byte, 1)
-	m.Write([]byte{0x05}) // enq
-	n, err := m.Read(buf)
-	if err == nil && n > 0 && buf[0] == 0x06 { // ack
-		return true, nil
-	} else {
-		if err != io.EOF {
-			return false, err
-		}
-	}
-	return false, nil
-}
-
-// DoAckCommand sends an STX/ETX framed command that expects a single byte reply. Sometimes
-// it's not an ACK that's sent, so it's up to the caller to tell this function what it
-// response it expects.
-func (m *Monitor) DoAckCommand(command byte, data []byte) error {
-	err := m.SendStxEtxRequest(command, data)
-	if err != nil {
-		return err
-	}
-
-	if m.Dummy {
-		return nil
-	}
-
-	return m.ReadAckReply()
-}
-
-// ReadAckReply reads a single byte reply
-func (m *Monitor) ReadAckReply() error {
-	r := make([]byte, 1)
-	n, err := m.Read(r)
-	if err != nil {
-		return err
-	}
-
-	if n != 1 || r[0] != 0x06 { // ack
-		return newProtocolError("ack not received")
-	}
-
-	return nil
-}
-
-type CommandReply struct {
-	Status  byte
-	Command byte
-	Data    []byte
-}
-
-// DoStxEtxCommand sends an STX/ETX framed command that expects an STX/ETX framed reply
-func (m *Monitor) DoStxEtxCommand(command byte, data []byte) (*CommandReply, error) {
-
-	err := m.SendStxEtxRequest(command, data)
-	if err != nil {
-		return nil, err
-	}
-
-	r, err := m.ReadStxEtxReply()
-	if err != nil {
-		return nil, err
-	}
-
-	return r, nil
-}
-
-// SendStxEtxRequest sends an STX/ETX framed request
-func (m *Monitor) SendStxEtxRequest(command byte, data []byte) error {
-
-	payload := []byte{0, command, byte(len(data))}
-	payload = append(payload, data...)
-
-	var checksum byte
-	for _, b := range payload {
-		checksum += b
-	}
-
-	packet := append([]byte{0x02}, payload...)         // stx
-	packet = append(packet, []byte{checksum, 0x03}...) // etx
-
-	_, err := m.Write(packet)
-
-	return err
-}
-
-//  ReadStxEtxReply reads a STX/ETX framed reply
-func (m *Monitor) ReadStxEtxReply() (*CommandReply, error) {
-	packet := make([]byte, MAXPACKETLLEN) // maximum packet length
-
-	_, err := m.ReadFull(packet[:4])
-	if err != nil {
-		return nil, err
-	}
-
-	if packet[0] != 0x02 { // stx
-		fmt.Printf("expected STX received: %02X\n", packet[0])
-		return nil, newProtocolError("expected STX received: %02X", packet[0])
-	}
-
-	status := packet[1]
-	command := packet[2]
-	length := int(packet[3])
-
-	_, err = m.ReadFull(packet[4 : length+6]) // also read checksum and ETX
-
-	packet = packet[:length+6] // trim to length
-
-	checksum := packet[len(packet)-2]
-
-	var computedChecksum byte
-	for _, b := range packet[1 : len(packet)-2] {
-		computedChecksum += b
-	}
-
-	if checksum != computedChecksum {
-		return nil, newProtocolError("bad checksum. received: %02X expected: %02X", checksum, computedChecksum)
-	}
-
-	if packet[len(packet)-1] != 0x03 { // etx
-		return nil, newProtocolError("expected ETX received: %02X", packet[len(packet)-1])
-	}
-
-	return &CommandReply{
-		Status:  status,
-		Command: command,
-		Data:    packet[4 : len(packet)-2],
-	}, nil
-
-}

monitor/receiver.go

@@ -0,0 +1,402 @@
+package monitor
+
+import (
+	"encoding/binary"
+	"fmt"
+	"github.com/jacobsa/go-serial/serial"
+	"io"
+	"os"
+)
+
+const (
+	MAXPACKETLLEN = 255 + 6
+)
+
+type Receiver struct {
+	port       io.ReadWriteCloser
+	device     string
+	baud       uint
+	dataBits   uint
+	stopBits   uint
+	parity     serial.ParityMode
+	portConfig serial.OpenOptions
+
+	receiverType ReceiverType
+
+	Debug bool
+	Dummy bool
+
+	inMonitor bool
+
+	seekPos uint32
+}
+
+func Connect(device string, baud int, dataBits int, stopBits int, parity string, debug bool) (*Receiver, error) {
+	r := &Receiver{
+		device:   device,
+		baud:     uint(baud),
+		dataBits: uint(dataBits),
+		stopBits: uint(stopBits),
+		Debug:    debug,
+	}
+
+	r.portConfig = serial.OpenOptions{
+		PortName:              r.device,
+		BaudRate:              r.baud,
+		DataBits:              r.dataBits,
+		StopBits:              r.stopBits,
+		MinimumReadSize:       0,
+		InterCharacterTimeout: 1000, // a non-zero timeout is required for waitForMonitor to work
+	}
+
+	switch parity {
+	case "none":
+		r.parity = serial.PARITY_NONE
+		r.portConfig.ParityMode = serial.PARITY_NONE
+	case "even":
+		r.parity = serial.PARITY_EVEN
+		r.portConfig.ParityMode = serial.PARITY_EVEN
+	case "odd":
+		r.parity = serial.PARITY_ODD
+		r.portConfig.ParityMode = serial.PARITY_ODD
+	default:
+		return nil, fmt.Errorf("unrecognized parity setting")
+	}
+	var err error
+	r.port, err = serial.Open(r.portConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	// figure out baud and parity
+	err = r.ProbePortConfig()
+	if err != nil {
+		return nil, err
+	}
+
+	return r, nil
+}
+
+// ProbePortConfig probes different serial port settings to find a responding receiver
+func (r *Receiver) ProbePortConfig() error {
+
+	var err error
+
+	// First figure out what baud rate the receiver is currently set up for
+	// easiest way to test this is by sending an ENQ
+	for attempts := 0; attempts < 3; attempts++ {
+
+		switch attempts {
+		case 0:
+			err = r.useUserBaudRate()
+		case 1:
+			err = r.useFastBaudRate()
+		case 2:
+			err = r.useSlowBaudRate()
+		}
+		if err != nil {
+			return err
+		}
+
+		err = r.ClearComm()
+		if err != nil {
+			return err
+		}
+
+		ok, err := r.EnqAckTest()
+		if err != nil {
+			return err
+		}
+
+		if !ok {
+			continue
+		}
+
+		if ok {
+			return nil
+		}
+	}
+	return fmt.Errorf("can't find receiver")
+
+}
+
+func (r *Receiver) reconfigurePort(baudRate uint, dataBits uint, stopBits uint, parity serial.ParityMode) error {
+	var err error
+	r.port.Close()
+	r.portConfig.BaudRate = baudRate
+	r.portConfig.DataBits = dataBits
+	r.portConfig.StopBits = stopBits
+	r.portConfig.ParityMode = parity
+	r.port, err = serial.Open(r.portConfig)
+	return err
+}
+
+func (r *Receiver) useSlowBaudRate() error {
+	fmt.Println("Reconfiguring port to slow monitor baud rate: 9600 n-8-1")
+	return r.reconfigurePort(9600, 8, 1, serial.PARITY_NONE)
+}
+
+func (r *Receiver) useFastBaudRate() error {
+	fmt.Println("Reconfiguring port to fast baud rate: 38400 n-8-1")
+	//	return r.reconfigurePort(38400, 8, 1, serial.PARITY_NONE)
+	return r.reconfigurePort(38400, 8, 1, serial.PARITY_ODD)
+}
+
+func (r *Receiver) useUserBaudRate() error {
+	fmt.Printf("Reconfiguring port to user baud rate: %d %s-%d-%d\n", r.baud, parityToString(r.parity), r.dataBits, r.stopBits)
+	return r.reconfigurePort(r.baud, r.dataBits, r.stopBits, r.parity)
+}
+
+func parityToString(p serial.ParityMode) string {
+	s := []string{"none", "odd", "even"}
+	return s[p]
+}
+
+// ClearComm sents 249 nulls on the serial port, which is something trimble likes to
+// do when starting the monitor. I think the point of this was to flush out the FIFO
+// buffers.
+func (r *Receiver) ClearComm() error {
+	nulls := make([]byte, 249)
+	_, err := r.Write(nulls)
+	if err != nil {
+		return err
+	}
+	// 	b := make([]byte, 12000)
+	// 	n, _ := m.Read(b)
+	// 	fmt.Printf("%d %02X \n",n,b)
+	x := r.port.(*os.File) // TODO: verify if this is actually needed
+	x.Sync()
+	return nil
+}
+
+func (r *Receiver) FlushInput() {
+	b := make([]byte, 12000)
+	for {
+		n, _ := r.Read(b)
+		fmt.Printf("FLUSH read %d bytes: % 02X\n", n, b[:n])
+		if n == 0 {
+			return
+		}
+	}
+}
+
+// Write is wrapped so that debug messages can be printed
+func (r *Receiver) Write(b []byte) (int, error) {
+	r.debugLog("Port Write: % 02X", b)
+	//fmt.Printf("%02X••\n",b)
+	if r.Dummy {
+		return len(b), nil
+	}
+	n, err := r.port.Write(b)
+	return n, err
+}
+
+// Read is wrapped so that debug messages can be printed
+func (r *Receiver) Read(b []byte) (int, error) {
+	n, err := r.port.Read(b)
+	if err == nil {
+		r.debugLog("Port Read: % 02X", b)
+	}
+	return n, err
+}
+
+// ReadFull is wrapped so that debug messages can be printed
+func (r *Receiver) ReadFull(b []byte) (int, error) {
+	n, err := io.ReadFull(r.port, b)
+	if err == nil {
+		r.debugLog("Port ReadFull: % 02X", b)
+	}
+	return n, err
+}
+
+func (r *Receiver) debugLog(format string, a ...interface{}) {
+	if r.Debug {
+		fmt.Printf("    "+format+"\n", a...)
+	}
+}
+
+// waitForMonitor blocks until the receiver has entered monitor mode.
+// It can take a while for the receiver to boot into monitor mode, this
+// function tests the state of the receiver by repeatedly sending an ENQ
+// command. When the monitor is ready, it will send an ACK.
+func (r *Receiver) waitForMonitor() error {
+	fmt.Println("Waiting for monitor to become ready...")
+	for i := 0; i < 30; i++ {
+		if ok, err := r.EnqAckTest(); ok {
+			return nil
+		} else if err != nil {
+			return err
+		}
+	}
+	return fmt.Errorf("timed out waiting for monitor")
+}
+
+// ProbeReceiverState checks if the receiver is in normal mode or monitor mode.
+// this is done by running command 0x82, which in normal mode is the screen dump
+// command, which replies with a packet of type 0x82. In monitor mode, the
+// command replies with a packet of type 0x92. If the receiver responds with
+// a 0x92 packet, we know it's in monitor mode.
+func (r *Receiver) ProbeReceiverState() (ReceiverState, error) {
+	fmt.Println("Preforming dummy read to determine monitor state...")
+
+	b := make([]byte, 5)
+
+	binary.BigEndian.PutUint32(b[0:], 0x80000) // 'safe' dummy location to read from, I think it's the RAM base address
+	b[4] = 2                                   // read 2 bytes
+
+	reply, err := r.DoStxEtxCommand(MonCmdReadMem, b)
+	if err != nil {
+		return ReceiverUnresponsive, err
+	}
+
+	if reply.Command == MonCmdReadMemAck && reply.Status == 0 {
+		fmt.Println("Receiver appears to be in monitor mode.")
+		return ReceiverInMonitor, nil
+	}
+
+	fmt.Println("Receiver appears to be in normal mode.")
+	return ReceiverNormal, nil
+}
+
+type ProtocolError struct {
+	err string
+}
+
+func newProtocolError(format string, a ...interface{}) error {
+	return &ProtocolError{err: fmt.Sprintf(format, a...)}
+}
+
+func (e *ProtocolError) Error() string {
+	return e.err
+}
+
+func (r *Receiver) EnqAckTest() (bool, error) {
+	buf := make([]byte, 1)
+	r.Write([]byte{0x05}) // enq
+	n, err := r.Read(buf)
+	if err == nil && n > 0 && buf[0] == 0x06 { // ack
+		return true, nil
+	} else {
+		if err != io.EOF {
+			return false, err
+		}
+	}
+	return false, nil
+}
+
+// DoAckCommand sends an STX/ETX framed command that expects a single byte reply. Sometimes
+// it's not an ACK that's sent, so it's up to the caller to tell this function what it
+// response it expects.
+func (r *Receiver) DoAckCommand(command byte, data []byte) error {
+	err := r.SendStxEtxRequest(command, data)
+	if err != nil {
+		return err
+	}
+
+	if r.Dummy {
+		return nil
+	}
+
+	return r.ReadAckReply()
+}
+
+// ReadAckReply reads a single byte reply
+func (r *Receiver) ReadAckReply() error {
+	reply := make([]byte, 1)
+	n, err := r.Read(reply)
+	if err != nil {
+		return err
+	}
+
+	if n != 1 || reply[0] != 0x06 { // ack
+		return newProtocolError("ack not received")
+	}
+
+	return nil
+}
+
+type CommandReply struct {
+	Status  byte
+	Command byte
+	Data    []byte
+}
+
+// DoStxEtxCommand sends an STX/ETX framed command that expects an STX/ETX framed reply
+func (r *Receiver) DoStxEtxCommand(command byte, data []byte) (*CommandReply, error) {
+
+	err := r.SendStxEtxRequest(command, data)
+	if err != nil {
+		return nil, err
+	}
+
+	reply, err := r.ReadStxEtxReply()
+	if err != nil {
+		return nil, err
+	}
+
+	return reply, nil
+}
+
+// SendStxEtxRequest sends an STX/ETX framed request
+func (r *Receiver) SendStxEtxRequest(command byte, data []byte) error {
+
+	payload := []byte{0, command, byte(len(data))}
+	payload = append(payload, data...)
+
+	var checksum byte
+	for _, b := range payload {
+		checksum += b
+	}
+
+	packet := append([]byte{0x02}, payload...)         // stx
+	packet = append(packet, []byte{checksum, 0x03}...) // etx
+
+	_, err := r.Write(packet)
+
+	return err
+}
+
+// ReadStxEtxReply reads a STX/ETX framed reply
+func (r *Receiver) ReadStxEtxReply() (*CommandReply, error) {
+	packet := make([]byte, MAXPACKETLLEN) // maximum packet length
+
+	_, err := r.ReadFull(packet[:4])
+	if err != nil {
+		return nil, err
+	}
+
+	if packet[0] != 0x02 { // stx
+		fmt.Printf("expected STX received: %02X\n", packet[0])
+		return nil, newProtocolError("expected STX received: %02X", packet[0])
+	}
+
+	status := packet[1]
+	command := packet[2]
+	length := int(packet[3])
+
+	_, err = r.ReadFull(packet[4 : length+6]) // also read checksum and ETX
+
+	packet = packet[:length+6] // trim to length
+
+	checksum := packet[len(packet)-2]
+
+	var computedChecksum byte
+	for _, b := range packet[1 : len(packet)-2] {
+		computedChecksum += b
+	}
+
+	if checksum != computedChecksum {
+		return nil, newProtocolError("bad checksum. received: %02X expected: %02X", checksum, computedChecksum)
+	}
+
+	if packet[len(packet)-1] != 0x03 { // etx
+		return nil, newProtocolError("expected ETX received: %02X", packet[len(packet)-1])
+	}
+
+	return &CommandReply{
+		Status:  status,
+		Command: command,
+		Data:    packet[4 : len(packet)-2],
+	}, nil
+
+}

monitor/serial.go

@@ -1,185 +0,0 @@
-package monitor
-
-import (
-	"fmt"
-	"github.com/jacobsa/go-serial/serial"
-	"io"
-	"os"
-)
-
-func Connect(device string, baud int, dataBits int, stopBits int, parity string, debug bool) (*Monitor, error) {
-	m := &Monitor{
-		device:   device,
-		baud:     uint(baud),
-		dataBits: uint(dataBits),
-		stopBits: uint(stopBits),
-		Debug:    debug,
-	}
-
-	m.portConfig = serial.OpenOptions{
-		PortName:              m.device,
-		BaudRate:              m.baud,
-		DataBits:              m.dataBits,
-		StopBits:              m.stopBits,
-		MinimumReadSize:       0,
-		InterCharacterTimeout: 1000, // a non-zero timeout is required for waitForMonitor to work
-	}
-
-	switch parity {
-	case "none":
-		m.parity = serial.PARITY_NONE
-		m.portConfig.ParityMode = serial.PARITY_NONE
-	case "even":
-		m.parity = serial.PARITY_EVEN
-		m.portConfig.ParityMode = serial.PARITY_EVEN
-	case "odd":
-		m.parity = serial.PARITY_ODD
-		m.portConfig.ParityMode = serial.PARITY_ODD
-	default:
-		return nil, fmt.Errorf("unrecognized parity setting")
-	}
-	var err error
-	m.port, err = serial.Open(m.portConfig)
-	if err != nil {
-		return nil, err
-	}
-
-	return m, nil
-}
-
-// DeterminePortConfig probes different serial port settings to find a responding receiver
-func (m *Monitor) DeterminePortConfig() error {
-
-	var err error
-
-	// First figure out what baud rate the receiver is currently set up for
-	// easiest way to test this is by sending an ENQ
-	for attempts := 0; attempts < 3; attempts++ {
-
-		switch attempts {
-		case 0:
-			err = m.useUserBaudRate()
-		case 1:
-			err = m.useFastBaudRate()
-		case 2:
-			err = m.useSlowBaudRate()
-		}
-		if err != nil {
-			return err
-		}
-
-		err = m.ClearComm()
-		if err != nil {
-			return err
-		}
-
-		ok, err := m.EnqAckTest()
-		if err != nil {
-			return err
-		}
-
-		if !ok {
-			continue
-		}
-
-		if ok {
-			return nil
-		}
-	}
-	return fmt.Errorf("can't find receiver")
-
-}
-
-func (m *Monitor) reconfigurePort(baudRate uint, dataBits uint, stopBits uint, parity serial.ParityMode) error {
-	var err error
-	m.port.Close()
-	m.portConfig.BaudRate = baudRate
-	m.portConfig.DataBits = dataBits
-	m.portConfig.StopBits = stopBits
-	m.portConfig.ParityMode = parity
-	m.port, err = serial.Open(m.portConfig)
-	return err
-}
-
-func (m *Monitor) useSlowBaudRate() error {
-	fmt.Println("Reconfiguring port to slow monitor baud rate: 9600 n-8-1")
-	return m.reconfigurePort(9600, 8, 1, serial.PARITY_NONE)
-}
-
-func (m *Monitor) useFastBaudRate() error {
-	fmt.Println("Reconfiguring port to fast baud rate: 38400 n-8-1")
-	return m.reconfigurePort(38400, 8, 1, serial.PARITY_NONE)
-}
-
-func (m *Monitor) useUserBaudRate() error {
-	fmt.Printf("Reconfiguring port to user baud rate: %d %s-%d-%d\n", m.baud, parityToString(m.parity), m.dataBits, m.stopBits)
-	return m.reconfigurePort(m.baud, m.dataBits, m.stopBits, m.parity)
-}
-
-func parityToString(p serial.ParityMode) string {
-	s := []string{"none", "odd", "even"}
-	return s[p]
-}
-
-// ClearComm sents 249 nulls on the serial port, which is something trimble likes to
-// do when starting the monitor. I think the point of this was to flush out the FIFO
-// buffers.
-func (m *Monitor) ClearComm() error {
-	nulls := make([]byte, 249)
-	_, err := m.Write(nulls)
-	if err != nil {
-		return err
-	}
-	// 	b := make([]byte, 12000)
-	// 	n, _ := m.Read(b)
-	// 	fmt.Printf("%d %02X \n",n,b)
-	x := m.port.(*os.File)
-	x.Sync()
-	return nil
-}
-
-func (m *Monitor) FlushInput() {
-	b := make([]byte, 12000)
-	for {
-		n, _ := m.Read(b)
-		fmt.Printf("FLUSH read %d bytes: % 02X\n", n, b[:n])
-		if n == 0 {
-			return
-		}
-	}
-}
-
-// Write is wrapped so that debug messages can be printed
-func (m *Monitor) Write(b []byte) (int, error) {
-	m.debugLog("Port Write: % 02X", b)
-	//fmt.Printf("%02X••\n",b)
-	if m.Dummy {
-		return len(b), nil
-	}
-	n, err := m.port.Write(b)
-	return n, err
-}
-
-// Read is wrapped so that debug messages can be printed
-func (m *Monitor) Read(b []byte) (int, error) {
-	n, err := m.port.Read(b)
-	if err == nil {
-		m.debugLog("Port Read: % 02X", b)
-	}
-	return n, err
-}
-
-// ReadFull is wrapped so that debug messages can be printed
-func (m *Monitor) ReadFull(b []byte) (int, error) {
-	n, err := io.ReadFull(m.port, b)
-	if err == nil {
-		m.debugLog("Port ReadFull: % 02X", b)
-	}
-	return n, err
-}
-
-func (m *Monitor) debugLog(format string, a ...interface{}) {
-	if m.Debug {
-		fmt.Printf("    "+format+"\n", a...)
-	}
-}

stfw/stfw.go

@@ -0,0 +1,148 @@
+package stfw
+
+import (
+	"encoding/binary"
+	//"fmt"
+	"os"
+)
+
+type Record struct {
+	Addr        uint32
+	Data        []byte
+	Sum         uint8
+	ComputedSum uint8
+	Good        bool
+}
+
+func ReadRecord(f *os.File) (*Record, error) {
+
+	r := struct {
+		Data [36]byte
+		Sum  uint8
+	}{}
+
+	err := binary.Read(f, binary.BigEndian, &r)
+	if err != nil {
+		return nil, err
+	}
+
+	var t uint8
+	for _, b := range r.Data {
+		t += uint8(b)
+	}
+	t = ^t
+
+	record := &Record{
+		Addr:        uint32(r.Data[0])<<24 | uint32(r.Data[1])<<16 | uint32(r.Data[2])<<8 | uint32(r.Data[3]),
+		Data:        r.Data[4:],
+		Sum:         r.Sum,
+		ComputedSum: t,
+		Good:        r.Sum == t,
+	}
+
+	return record, nil
+}
+
+func WriteRecord(f *os.File, rec *Record) error {
+
+	r := struct {
+		Data [36]byte
+		Sum  uint8
+	}{}
+
+	r.Data[0] = byte(rec.Addr >> 24)
+	r.Data[1] = byte(rec.Addr >> 16)
+	r.Data[2] = byte(rec.Addr >> 8)
+	r.Data[3] = byte(rec.Addr)
+
+	copy(r.Data[4:], rec.Data[:])
+
+	for _, b := range r.Data {
+		r.Sum += uint8(b)
+	}
+	r.Sum = ^r.Sum
+
+	err := binary.Write(f, binary.BigEndian, r)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func SplitBin(mem []byte) ([]byte, []byte) {
+	low := make([]byte, len(mem)>>1)
+	high := make([]byte, len(mem)>>1)
+	for i := 0; i < len(mem); i += 2 {
+		low[i/2] = mem[i]
+		high[i/2] = mem[i+1]
+	}
+	return low, high
+}
+
+func MergeBin(low []byte, high []byte) []byte {
+	mem := make([]byte, len(low)*2)
+	for i := 0; i < len(low); i++ {
+		mem[i*2] = low[i]
+		mem[i*2+1] = high[i]
+	}
+	return mem
+}
+
+type MemoryMode int
+
+func (m MemoryMode) physAddr(addr int) int {
+	switch m {
+	case MemoryModeCombinedLow:
+		return addr * 2
+	case MemoryModeCombinedHigh:
+		return addr*2 + 1
+	}
+	return addr
+}
+
+const (
+	MemoryModeLinear MemoryMode = iota
+	MemoryModeCombinedLow
+	MemoryModeCombinedHigh
+)
+
+func GetChecksum(mem []byte, mm MemoryMode) uint16 {
+	return uint16(mem[mm.physAddr(0xfffe)])*256 + uint16(mem[mm.physAddr(0xffff)])
+}
+
+func GetChecksums(mem []byte) (uint16, uint16) {
+	return GetChecksum(mem, MemoryModeCombinedLow), GetChecksum(mem, MemoryModeCombinedHigh)
+}
+
+func CalcChecksum(mem []byte, mm MemoryMode, start int) uint16 {
+	var cs uint16
+	for i := 0; i <= 0xFFFB; i++ {
+		cs = addx(uint16(mem[mm.physAddr(i)]), cs)
+	}
+	cs = ^cs
+	return cs
+}
+
+func CalcChecksums(mem []byte, start int) (uint16, uint16) {
+	return CalcChecksum(mem, MemoryModeCombinedLow, start), CalcChecksum(mem, MemoryModeCombinedHigh, start)
+}
+
+func UpdateChecksum(mem []byte, mm MemoryMode, cs uint16) {
+	mem[mm.physAddr(0xfffe)] = byte(cs >> 8)
+	mem[mm.physAddr(0xffff)] = byte(cs)
+}
+
+var xFlag bool
+
+func addx(x, y uint16) uint16 {
+	if x+y < y {
+		xFlag = true
+		return x + y
+	}
+	if xFlag {
+		xFlag = false
+		return x + y + 1
+	}
+	return x + y
+}