moar fun

README.md

@@ -1,3 +1,55 @@
-# trimtools
+# TrimTools
+TrimTools is an open source set of tools for managing the firmware on plastic box Trimble 4000 series GPS receivers.
 
-Tools to work with the Trimble 4000SE/SSE/SSi receivers' firmware upgrade mechanism.
+## Features
+* Fully Supported Receivers (Firmware read/write)
+	* 4000SE (Maxwell)
+	* 4000SSE
+	* 4000Si
+	* 4000SSi
+	* 4000RS
+	* 4000DS 
+* Partially Supported Receivers (interactive ROM Monitor only)
+	* 4000SE (Gauss)
+	* 4000RL2
+	* 4000DL2
+	* 4400
+	* 7400MSi
+* Cross Platform
+* Fast
+* Interactive ROM monitor
+
+
+## Command Line Tools
+`cmd/loader` - replacement for Trimble's loader.exe
+
+	Usage of loader:
+	  -b int
+	    	baud rate (default 38400)
+	  -d string
+	    	serial port device (default "/dev/tty.usbserial-AB0JS0VU")
+	  -dummy
+	    	dummy mode
+	  -f string
+	    	write firmware from file to receiver
+	  -m	start interactive monitor
+	  -p string
+	    	parity (none, even, lsodd) (default "none")
+	  -s string
+	    	save firmware from receiver to file
+	  -v	show version and exit
+	  -x	enable debug messages
+
+`cmd/convertx` - tool for converting to and from HP 64000 .X images as used by the loader tool.
+	
+	Usage convertx:
+	  -b string
+	    	binary image output filename
+	  -i	print image metadata
+	  -wnro
+	    	attempt to patch WNRO bug
+	  -x string
+	    	.X output filename
+
+## Known Issues
+* Firmware upload/download for the Gauss 4000SE and the 4400 is either missing or not tested.

cmd/convertx/main.go

@@ -36,25 +36,58 @@ import (
 	"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 binOut string
-	var xOut string
+	var inFile,outFile,  inFileFormat, outFileFormat string
 	var printInfo bool
-	var patchWNRO bool
 
-	flag.StringVar(&binOut, "b", "", "binary image output filename")
-	flag.StringVar(&xOut, "x", "", ".X output filename")
-	flag.BoolVar(&printInfo, "i", false, "print image metadata")
-	flag.BoolVar(&patchWNRO, "wnro", false, "attempt to patch WNRO bug")
+	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()
 
-	inFile := flag.Arg(0)
 	if inFile == "" {
-		fmt.Printf("Usage:\n%s [flags] <.X file>\n", os.Args[0])
+		fmt.Printf("Input file is required.")
+		os.Exit(1)
+	}
+	
+	if outFile == "" {
+		fmt.Printf("Input file is required.")
 		os.Exit(1)
 	}
 
@@ -70,37 +103,42 @@ func main() {
 		log.Fatal(err)
 	}
 
+	dotX.Blocks[2].ToRecords(memOpBlockSize)
+
+	mem := dotX.ToMemory()
+
 	if printInfo {
 		dotX.PrintInfo()
+		mem.PrintInfo()
 	}
 
-	if patchWNRO {
-
-		verMaj, verMin := dotX.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)
-		}
-		// 2. change partial-rollover check cmpi to 0
-		dotX.Memory[matches[0]-4] = 0
-		dotX.Memory[matches[0]-3] = 0
-
-		// 2. change $400 to $800
-		dotX.Memory[matches[0]+2] = 8
-
-		// 3. recalculate the block checksums
-		dotX.UpdateChecksums()
-	}
+	// 	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") {

cmd/loader/main.go

@@ -1,15 +1,15 @@
 package main
 
 import (
-	"bufio"
 	"code.beefchicken.com/trimtools/dotx"
 	"code.beefchicken.com/trimtools/monitor"
+	"github.com/chzyer/readline"
+
 	"encoding/binary"
 	"flag"
 	"fmt"
-	"io"
-	"io/ioutil"
 	"log"
+	"math"
 	"os"
 	"strconv"
 	"strings"
@@ -17,42 +17,30 @@ import (
 
 func main() {
 
-	var baud, dataBits, stopBits int
-	var debug, startMonitor, dummy bool
+	var baud int
+	var debug, interactiveMonitor, showVersion, dummy bool
 	var device, parity string
+	var inFile, outFile string
 
-	flag.IntVar(&baud, "baud", 38400, "baud rate")
-	flag.IntVar(&dataBits, "databits", 8, "data bits")
-	flag.IntVar(&stopBits, "stopbits", 1, "stop bits")
-	flag.BoolVar(&debug, "debug", false, "enable debug messages")
-	flag.BoolVar(&startMonitor, "M", false, "start monitor")
-	flag.BoolVar(&dummy, "dummy", false, "dummy mode")
-	flag.StringVar(&device, "device", "/dev/tty.usbserial-AB0JS0VU", "serial port device")
-	flag.StringVar(&parity, "parity", "n", "parity (n,e,o)")
+	flag.IntVar(&baud, "b", 38400, "baud rate")
+	flag.StringVar(&parity, "p", "none", "parity (none, even, lsodd)")
 
+	flag.BoolVar(&debug, "x", false, "enable debug messages")
+	flag.BoolVar(&interactiveMonitor, "m", false, "start interactive monitor")
+	flag.BoolVar(&showVersion, "v", false, "show version and exit")
+	flag.BoolVar(&dummy, "dummy", false, "dummy mode")
+	flag.StringVar(&device, "d", "/dev/tty.usbserial-AB0JS0VU", "serial port device")
+	flag.StringVar(&outFile, "s", "", "save firmware from receiver to file")
+	flag.StringVar(&inFile, "f", "", "write firmware from file to receiver")
 	flag.Parse()
 
-	inFile := flag.Arg(0)
-	// if inFile == "" {
-	// 		fmt.Printf("Usage:\n%s [flags] <.X file>\n", os.Args[0])
-	// 		os.Exit(1)
-	// 	}
+	if showVersion {
+		fmt.Println("loader(.exe) Trimble 4000 Firmware Loader")
+		fmt.Println("Written by Keelan Lightfoot - http://beefchicken.com")
+		return
+	}
 
 	var fw *dotx.DotXFile
-	if inFile != "" {
-		// load file
-		f, err := os.Open(inFile)
-		if err != nil {
-			log.Fatal(err)
-		}
-		defer f.Close()
-		fw, err = dotx.ReadDotX(f)
-		if err != nil {
-			log.Fatal(err)
-		}
-		fmt.Println(fw.FirmwareDate())
-
-	}
 
 	var mon *monitor.Monitor
 	var err error
@@ -60,9 +48,12 @@ func main() {
 	if dummy {
 		mon = &monitor.Monitor{
 			Debug: debug,
+			Dummy: dummy,
 		}
+		fmt.Println("Monitor dummy mode active.")
+
 	} else {
-		mon, err = monitor.Connect(device, baud, dataBits, stopBits, parity, debug)
+		mon, err = monitor.Connect(device, baud, 8, 1, parity, debug)
 		if err != nil {
 			log.Fatal(err)
 		}
@@ -74,147 +65,194 @@ func main() {
 		log.Fatal(err)
 	}
 
-	if fw != nil {
-		mon.WriteFirmware(fw)
+	if interactiveMonitor {
+		runMonitor(mon)
+		return
 	}
 
-	if startMonitor {
-		reader := bufio.NewReader(os.Stdin)
-		running := true
-		for running {
-			fmt.Print("\nenter command: ")
-			b, err := reader.ReadBytes('\n')
-			if err == io.EOF {
-				fmt.Println("bye")
-				break
-			}
-			cmd := strings.Fields(string(b))
-			if len(cmd) == 0 {
-				continue
-			}
-			switch strings.ToLower(cmd[0]) {
-			case "?":
-				fmt.Println("Manual help mode:")
-				fmt.Println("  Q or X       : Exit program.")
-				fmt.Println("  R            : Reset target and exit program.")
-				fmt.Println("  U addr count : hex/ascii dump of count bytes starting at addr")
-				fmt.Println("                 (UD command works with doubles)")
-				fmt.Println("  D addr count data... : download data bytes to target address")
-				fmt.Println("                 (DD command works with doubles)")
-				fmt.Println("  F addr count char : fill target memory block")
-				fmt.Println("  V            : Display firmware versions and code segment ranges.")
-				fmt.Println("  O            : Display options data.")
-				fmt.Println(" ")
-				fmt.Println("  Addresses and data default to hex.  Counts default to decimal.")
-				fmt.Println("  $xxxx or !dddd force hex or decimal.")
-				fmt.Println("  CoMmAnDs ArE CaSe InSeNsITiVe.")
-			case "q":
-				fallthrough
-			case "x":
-				running = false
-			case "r":
-				mon.Stop()
-				running = false
-			case "u":
-				handleUCommand(mon, cmd)
-			case "ul":
-				handleULCommand(mon, cmd)
-			case "uf": // dump to file
-				handleUFCommand(mon, cmd)
-			case "ud":
-				fmt.Println("unimplemented")
-			case "d":
-				handleDCommand(mon, cmd)
-			case "dd":
-				fmt.Println("unimplemented")
-			case "f":
-
-				b2, _ := mon.ReadMemory(0x80600+62, 10)
-				fmt.Printf("% 02x\n", b2)
-				fmt.Printf("%s\n", string(b2))
-
-				b3, _ := mon.ReadMemory(0x80600+72, 10)
-				fmt.Printf("% 02x\n", b3)
-				fmt.Printf("%s\n", string(b3))
-
-				fmt.Println("unimplemented")
-			case "v":
-				info, err := mon.GetReceiverInfo()
-				if err != nil {
-					log.Fatal(err)
-				}
-				info.PrintVersions()
-			case "o":
-				info, err := mon.GetReceiverInfo()
-				if err != nil {
-					log.Fatal(err)
-				}
-				info.PrintOptions()
-			}
+	if outFile != "" {
+		fmt.Printf("Saving .X format firmware to '%s'...\n", outFile)
+		fw, err = mon.CaptureReceiverFirmware()
+		if err != nil {
+			log.Fatal(err)
+		}
+		f, err := os.Create(outFile)
+		if err != nil {
+			log.Fatal(err)
+		}
+		err = fw.WriteDotX(f)
+		if err != nil {
+			log.Fatal(err)
+		}
+		f.Close()
+	}
 
+	if inFile != "" {
+		fmt.Printf("Loading .X format firmware from '%s'...\n", inFile)
+		f, err := os.Open(inFile)
+		if err != nil {
+			log.Fatal(err)
+		}
+		fw, err = dotx.ReadDotX(f)
+		if err != nil {
+			log.Fatal(err)
+		}
+		f.Close()
+		err = mon.ProgramReceiver(fw)
+		if err != nil {
+			log.Fatal(err)
 		}
 	}
-	//
-	// 	b, err := mon.ReadMemory(0x712804, 4)
-	// 	if err != nil {
-	// 		log.Fatal(err)
-	// 	}
-	// 	fmt.Printf("% 02x\n", b)
 
 }
 
-func handleDCommand(mon *monitor.Monitor, cmd []string) {
-	if len(cmd) < 3 {
-		fmt.Println("d address d1 d2 d3 dn...")
-		return
+func runMonitor(mon *monitor.Monitor) {
+	commands := map[string]func(*monitor.Monitor, []string) bool{
+		"?":  handleHelpCommand,
+		"q":  handleQuitCommand,
+		"x":  handleQuitCommand,
+		"r":  handleResetCommand,
+		"u":  handleUCommand,
+		"uw": handleUWCommand,
+		"ul": handleULCommand,
+		"ud": handleUDCommand,
+		"d":  handleDCommand,
+		"dw": handleDWCommand,
+		"dl": handleDLCommand,
+		"dd": handleDDCommand,
+		"f":  handleFCommand,
+		"v":  handleVersionCommand,
+		"o":  handleOptionsCommand,
+		"j":  handleJCommand,
 	}
-	addr, ok := parseNum(cmd[1], 16)
-	if !ok {
-		fmt.Println("invalid address")
-		return
+
+	rl, err := readline.New("enter command: ")
+	if err != nil {
+		panic(err)
 	}
-	v := make([]byte, 0)
-	for _, s := range cmd[2:] {
-		b, ok := parseNum(s, 16)
-		if !ok {
-			fmt.Printf("invalid byte: %s\n", s)
-			return
+	defer rl.Close()
+
+	for {
+		fmt.Println("")
+		s, err := rl.Readline()
+		fmt.Println("")
+
+		if err != nil {
+			fmt.Println("bye")
+			break
+		}
+		cmd := strings.Fields(s)
+		if len(cmd) == 0 {
+			continue
+		}
+		verb := strings.ToLower(cmd[0])
+
+		if f := commands[verb]; f != nil {
+			if f(mon, cmd) {
+				break
+			}
+		} else {
+			fmt.Printf("unrecognized command: %s\n", verb)
 		}
-		v = append(v, byte(b))
-	}
-	err := mon.WriteMemory(addr, v)
-	if err != nil {
-		fmt.Println("failed: %v\n", err)
 	}
+
+}
+
+func handleQuitCommand(mon *monitor.Monitor, cmd []string) bool {
+	return true
+}
+
+func handleHelpCommand(mon *monitor.Monitor, cmd []string) bool {
+	fmt.Print(
+		"Manual help mode:\n",
+		"  Q or X       : Exit program.\n",
+		"  R            : Reset target and exit program.\n",
+		"  U addr count : hex/ascii dump of count bytes starting at addr\n",
+		"                 (UD command works with doubles)\n",
+		"                 (UW command works with words)\n",
+		"                 (UL command works with longs)\n",
+		"  D addr count data... : download data bytes to target address\n",
+		"                 (DD command works with doubles)\n",
+		"                 (DW command works with words)\n",
+		"                 (DL command works with longs)\n",
+		"  F addr count byte : fill target memory block\n",
+		"  V            : Display firmware versions and code segment ranges.\n",
+		"  O            : Display options data.\n",
+		"  J addr       : Jump to address.\n",
+		" \n",
+		"  Addresses and data default to hex.  Counts default to decimal.\n",
+		"  $xxxx or !dddd force hex or decimal.\n",
+		"  CoMmAnDs ArE CaSe InSeNsITiVe.\n",
+	)
+
+	return false
 }
 
-func handleUCommand(mon *monitor.Monitor, cmd []string) {
+func handleResetCommand(mon *monitor.Monitor, cmd []string) bool {
+	mon.Stop()
+	return false
+}
+
+func handleUCommand(mon *monitor.Monitor, cmd []string) bool {
+	return ulCmd(mon, cmd, 1)
+}
+
+func handleUWCommand(mon *monitor.Monitor, cmd []string) bool {
+	return ulCmd(mon, cmd, 2)
+}
+
+func handleULCommand(mon *monitor.Monitor, cmd []string) bool {
+	return ulCmd(mon, cmd, 4)
+}
+
+func ulCmd(mon *monitor.Monitor, cmd []string, chunk int) bool {
 	if len(cmd) < 3 {
-		fmt.Println("u address count")
-		return
+		fmt.Printf("%s address count\n", cmd[0])
+		return false
 	}
 	addr, ok := parseNum(cmd[1], 16)
 	if !ok {
-		fmt.Println("invalid address")
-		return
+		fmt.Printf("invalid address: '%s'\n", cmd[1])
+		return false
 	}
 	count, ok := parseNum(cmd[2], 10)
 	if !ok {
-		fmt.Println("invalid count")
-		return
+		fmt.Printf("invalid count: '%s'\n", cmd[2])
+		return false
 	}
-	b, err := mon.ReadMemory(addr, int(count))
+
+	b, err := mon.ReadMemory(addr, int(count)*chunk)
 	if err != nil {
 		log.Fatal(err)
 	}
-	fmt.Printf("upload data from target memory\n")
-	fmt.Printf("start address: %08x number of bytes: %d\n", addr, count)
-	for i := 0; i < int(count); i += 16 {
+
+	var dataType string
+
+	if chunk == 1 {
+		dataType = "byte"
+	} else if chunk == 2 {
+		dataType = "word"
+	} else if chunk == 4 {
+		dataType = "long"
+	}
+	fmt.Printf("upload %s data from target memory\n", dataType)
+	fmt.Printf("start address: %08x number of %ss: %d\n", addr, dataType, count)
+	for i := 0; i < int(count)*chunk; i += 16 {
 		e := i + 16
 		if e > len(b) {
 			e = len(b)
 		}
-		line := fmt.Sprintf("%08x  % 02x", addr+uint32(i), b[i:e])
+		line := fmt.Sprintf("%08x ", addr+uint32(i))
+		for q := 0; q < (e - i); q += chunk {
+			if chunk == 1 {
+				line = fmt.Sprintf("%s %02x", line, b[i+q])
+			} else if chunk == 2 {
+				line = fmt.Sprintf("%s %04x", line, binary.BigEndian.Uint16(b[i+q:]))
+			} else if chunk == 4 {
+				line = fmt.Sprintf("%s %08x", line, binary.BigEndian.Uint32(b[i+q:]))
+			}
+		}
+
 		fmt.Printf("% -60s", line)
 		for j := i; j < e; j++ {
 			if b[j] >= 32 && b[j] <= 126 {
@@ -225,79 +263,190 @@ func handleUCommand(mon *monitor.Monitor, cmd []string) {
 		}
 		fmt.Printf("\n")
 	}
+	return false
 }
 
-func handleULCommand(mon *monitor.Monitor, cmd []string) {
+func handleUDCommand(mon *monitor.Monitor, cmd []string) bool {
 	if len(cmd) < 3 {
 		fmt.Println("u address count")
-		return
+		return false
 	}
 	addr, ok := parseNum(cmd[1], 16)
 	if !ok {
-		fmt.Println("invalid address")
-		return
+		fmt.Printf("invalid address: '%s'\n", cmd[1])
+		return false
 	}
 	count, ok := parseNum(cmd[2], 10)
 	if !ok {
-		fmt.Println("invalid count")
-		return
+		fmt.Printf("invalid count: '%s'\n", cmd[2])
+		return false
 	}
-	count *= 4
-	b, err := mon.ReadMemory(addr, int(count))
+	b, err := mon.ReadMemory(addr, int(count)*8)
 	if err != nil {
-		log.Fatal(err)
+		fmt.Printf("read failed: %v\n", err)
 	}
-	fmt.Printf("upload long data from target memory\n")
-	fmt.Printf("start address: %08x number of bytes: %d\n", addr, count)
-	for i := 0; i < int(count); i += 16 {
-		e := i + 16
-		if e > len(b) {
-			e = len(b)
+	fmt.Printf("upload doubles from target memory\n")
+	fmt.Printf("start address: %08x number of doubles: %d\n", addr, count)
+
+	for i := 0; i < int(count); i++ {
+		fmt.Printf("%08x  %23.13e\n", int(addr)+i*8, math.Float64frombits(binary.BigEndian.Uint64(b[i*8:])))
+	}
+	return false
+}
+
+func handleDCommand(mon *monitor.Monitor, cmd []string) bool {
+	return dlCmd(mon, cmd, 1)
+}
+
+func handleDWCommand(mon *monitor.Monitor, cmd []string) bool {
+	return dlCmd(mon, cmd, 2)
+}
+
+func handleDLCommand(mon *monitor.Monitor, cmd []string) bool {
+	return dlCmd(mon, cmd, 4)
+}
+
+func dlCmd(mon *monitor.Monitor, cmd []string, chunk int) bool {
+	if len(cmd) < 3 {
+		fmt.Printf("%s address v1 v2 v3 vn...\n", cmd[0])
+		return false
+	}
+	addr, ok := parseNum(cmd[1], 16)
+	if !ok {
+		fmt.Printf("invalid address: '%s'\n", cmd[1])
+		return false
+	}
+
+	var dataType string
+
+	if chunk == 1 {
+		dataType = "byte"
+	} else if chunk == 2 {
+		dataType = "word"
+	} else if chunk == 4 {
+		dataType = "long"
+	}
+	fmt.Printf("download %s data to target memory\n", dataType)
+	fmt.Printf("start address: %08x number of %ss: %d\n", addr, dataType, len(cmd[2:]))
+
+	v := make([]byte, len(cmd[2:])*chunk)
+	i := 0
+	for _, s := range cmd[2:] {
+		l, ok := parseNum(s, 16)
+		if !ok {
+			fmt.Printf("invalid value: %s\n", s)
+			return false
 		}
-		line := fmt.Sprintf("%08x    ", addr+uint32(i))
-		for q := 0; q < (e - i); q += 4 {
-			line = fmt.Sprintf("%s %08x", line, binary.BigEndian.Uint32(b[i+q:]))
+
+		if chunk == 1 {
+			v[i] = byte(l)
+		} else if chunk == 2 {
+			binary.BigEndian.PutUint16(v[i:], uint16(l))
+		} else if chunk == 4 {
+			binary.BigEndian.PutUint32(v[i:], l)
 		}
 
-		fmt.Printf("% -60s", line)
-		for j := i; j < e; j++ {
-			if b[j] >= 32 && b[j] <= 126 {
-				fmt.Print(string(b[j]))
-			} else {
-				fmt.Print(".")
-			}
+		i += chunk
+	}
+	err := mon.WriteMemory(addr, v)
+	if err != nil {
+		fmt.Println("failed: %v\n", err)
+	}
+	return false
+}
+
+func handleDDCommand(mon *monitor.Monitor, cmd []string) bool {
+	if len(cmd) < 3 {
+		fmt.Println("dd address d1 d2 d3 dn...")
+		return false
+	}
+	addr, ok := parseNum(cmd[1], 16)
+	if !ok {
+		fmt.Printf("invalid address: '%s'\n", cmd[1])
+		return false
+	}
+	v := make([]byte, len(cmd[2:])*8)
+	i := 0
+	for _, s := range cmd[2:] {
+		f, err := strconv.ParseFloat(s, 64)
+		if err != nil {
+			fmt.Printf("invalid float: %s\n", s)
+			return false
 		}
-		fmt.Printf("\n")
+
+		binary.BigEndian.PutUint64(v[i:], math.Float64bits(f))
+		i += 8
+	}
+	err := mon.WriteMemory(addr, v)
+	if err != nil {
+		fmt.Println("failed: %v\n", err)
 	}
+	return false
 }
 
-func handleUFCommand(mon *monitor.Monitor, cmd []string) {
+func handleFCommand(mon *monitor.Monitor, cmd []string) bool {
 	if len(cmd) < 4 {
-		fmt.Println("u file address count")
-		return
+		fmt.Println("f address count byte")
+		return false
 	}
-	fileName := cmd[1]
-
-	addr, ok := parseNum(cmd[2], 16)
+	addr, ok := parseNum(cmd[1], 16)
 	if !ok {
-		fmt.Println("invalid address")
-		return
+		fmt.Printf("invalid address: '%s'\n", cmd[1])
+		return false
 	}
-	count, ok := parseNum(cmd[3], 10)
+	count, ok := parseNum(cmd[2], 10)
 	if !ok {
-		fmt.Println("invalid count")
-		return
+		fmt.Printf("invalid count: '%s'\n", cmd[2])
+		return false
+	}
+	b, ok := parseNum(cmd[3], 16)
+	if !ok {
+		fmt.Printf("invalid byte: '%s'\n", cmd[3])
+		return false
+	}
+	v := make([]byte, count)
+	for i := 0; i < len(v); i++ {
+		v[i] = byte(b)
 	}
-	b, err := mon.ReadMemory(addr, int(count))
+	err := mon.WriteMemory(addr, v)
 	if err != nil {
-		fmt.Printf("read failed: %v\n", err)
+		fmt.Println("failed: %v\n", err)
 	}
-	err = ioutil.WriteFile(fileName, b, 0644)
+	return false
+}
+
+func handleVersionCommand(mon *monitor.Monitor, cmd []string) bool {
+	info, err := mon.GetReceiverInfo()
 	if err != nil {
-		fmt.Printf("write to file failed: %v\n", err)
+		fmt.Printf("GetReceiverInfo failed: %v\n", err)
+		return false
 	}
-	fmt.Printf("wrote %d bytes to %s\n", len(b), fileName)
+	info.PrintVersions()
+	return false
+}
+
+func handleOptionsCommand(mon *monitor.Monitor, cmd []string) bool {
+	info, err := mon.GetReceiverInfo()
+	if err != nil {
+		fmt.Printf("GetReceiverInfo failed: %v\n", err)
+		return false
+	}
+	info.PrintOptions()
+	return false
+}
 
+func handleJCommand(mon *monitor.Monitor, cmd []string) bool {
+	if len(cmd) < 2 {
+		fmt.Println("j address")
+		return false
+	}
+	addr, ok := parseNum(cmd[1], 16)
+	if !ok {
+		fmt.Printf("invalid address: '%s'\n", cmd[1])
+		return false
+	}
+	mon.Jump(addr)
+	return false
 }
 
 func parseNum(s string, base int) (uint32, bool) {
@@ -315,25 +464,3 @@ func parseNum(s string, base int) (uint32, bool) {
 	}
 	return uint32(v), true
 }
-
-// enter command: ud 0 100
-// upload doubles from target memory
-// start address: number of doubles: 00000000     1.1125369292673e-308
-// 00000008     6.8043917048940e-310
-// 00000010     6.8086356964769e-310
-// 00000018     6.8128796880598e-310
-// 00000020     6.8171236796428e-310
-// 00000028     6.8213676712257e-310
-// 00000030     0.0000000000000e+000
-// 00000038     0.0000000000000e+000
-// 00000040     0.0000000000000e+000
-// 00000048     0.0000000000000e+000
-// 00000050     0.0000000000000e+000
-// 00000058     0.0000000000000e+000
-// 00000060     6.8298556544112e-310
-// 00000068     7.5076211100665e-310
-// 00000070     8.9157775173783e-310
-// 00000078     6.8298556544421e-310
-// 00000080     6.8302800535493e-310
-// 00000088     7.0492700191769e-310
-// 00000090     6.8302800537515e-310

dotx/dotx.go

@@ -21,7 +21,7 @@ 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 is in the public domain.
 
 This program was written by Keelan Lightfoot
 http://www.beefchicken.com/
@@ -44,16 +44,19 @@ import (
 type DotXFile struct {
 	ProductionFlag  uint8
 	HeaderText      string
-	ProcessorRecord *ProcessorRecord
-	DataRecords     []*DataRecord
-	Memory          []uint8
-	Blocks          []Block
-
-	minAddr    uint32
-	maxAddr    uint32
-	memSize    uint32
-	unused     uint32
-	totalBytes uint32
+	TransferAddress uint32
+	DataBusWidth    uint16
+	DataWidthBase   uint16
+
+	// 	Memory          []byte
+	Blocks []*Block
+	//	Records			[]*DataRecord
+}
+
+type Memory struct {
+	Memory      []byte
+	LowestAddr  uint32
+	HighestAddr uint32
 }
 
 // The .X file format is a HP 64000 Absolute format file. Documentation of this
@@ -90,12 +93,7 @@ func ReadDotX(f *os.File) (*DotXFile, error) {
 		return nil, fmt.Errorf("bad header magic")
 	}
 
-	dotX := &DotXFile{
-		ProcessorRecord: &ProcessorRecord{},
-		DataRecords:     make([]*DataRecord, 0),
-	}
-
-	dotX.ProductionFlag = header[17]
+	dotX := &DotXFile{}
 
 	rawHeader := string(header[3:13])
 
@@ -104,18 +102,24 @@ func ReadDotX(f *os.File) (*DotXFile, error) {
 		dotX.HeaderText = rawHeader[:nullIndex]
 	}
 
-	pr := dotX.ProcessorRecord
+	pr := &processorRecord{}
 	err = binary.Read(f, binary.BigEndian, pr)
 	if err != nil {
 		return nil, err
 	}
 
+	dotX.TransferAddress = uint32(pr.TransferAddressLS) + uint32(pr.TransferAddressMS)<<16
+	dotX.ProductionFlag = header[17]
+	dotX.DataBusWidth = pr.DataBusWidth
+	dotX.DataWidthBase = pr.DataWidthBase
 	// The HP docs say that if TransferAddressMS == 0, then the transfer address field is
 	// to be ignored, so I don't actually do anything useful with the processor record.
+	// Trimble native firmware seems to have the reset vector address (0x6BF0) in
+	// TransferAddressLS, but in a .X generated by a firmware save, the field is all zeros.
 
-	dotX.DataRecords = make([]*DataRecord, 0)
+	records := make([]*DataRecord, 0)
 	for {
-		dr := DataRecordHeader{}
+		dr := dataRecordHeader{}
 		err = binary.Read(f, binary.BigEndian, &dr)
 		if err != nil {
 			if err == io.EOF {
@@ -123,81 +127,106 @@ func ReadDotX(f *os.File) (*DotXFile, error) {
 			}
 			return nil, err
 		}
+		rec := &DataRecord{
+			Addr:  uint32(dr.LoadAddressMS)<<16 + uint32(dr.LoadAddressLS),
+			Bytes: make([]byte, dr.DataBytes),
+		}
 
-		db := make([]byte, dr.DataBytes)
-		_, err = f.Read(db)
+		_, err = f.Read(rec.Bytes)
 		if err != nil {
 			return nil, err
 		}
 
-		dotX.DataRecords = append(dotX.DataRecords, &DataRecord{
-			Header: dr,
-			Bytes:  db,
-		})
-
+		records = append(records, rec)
 	}
 
 	// figure out how big the target memory needs to be
-	dotX.minAddr = dotX.DataRecords[0].LoadAddr()
-	dotX.maxAddr = dotX.DataRecords[0].MaxAddr()
 
-	for _, r := range dotX.DataRecords {
-		if r.MaxAddr() > dotX.maxAddr {
-			dotX.maxAddr = r.MaxAddr()
-		}
-		if r.LoadAddr() < dotX.minAddr {
-			dotX.minAddr = r.LoadAddr()
-		}
-		dotX.totalBytes += uint32(len(r.Bytes))
-	}
+	dotX.Blocks = []*Block{}
 
-	dotX.memSize = dotX.maxAddr - dotX.minAddr
-	dotX.unused = dotX.maxAddr - dotX.minAddr - dotX.totalBytes
+	var block *Block
 
-	// create memory and a map of which bytes have been modified
-	dotX.Memory = make([]uint8, dotX.maxAddr)
-	dirtyBytes := make([]bool, dotX.maxAddr)
+	for _, r := range records {
+		start := r.Addr
+		end := r.Addr + uint32(len(r.Bytes)) - 1
 
-	for _, r := range dotX.DataRecords {
-		a := r.LoadAddr()
-		for i, b := range r.Bytes {
-			dotX.Memory[a+uint32(i)] = b
-			dirtyBytes[a+uint32(i)] = true
+		if block != nil {
+			if start == block.EndAddr+1 { // continuing block
+				block.EndAddr = end
+				block.Bytes = append(block.Bytes, r.Bytes...)
+			} else {
+				dotX.Blocks = append(dotX.Blocks, block)
+				block = nil
+			}
+		}
+		if block == nil {
+			block = &Block{
+				StartAddr: start,
+				EndAddr:   end,
+				Bytes:     r.Bytes,
+			}
 		}
-		r.Bytes = dotX.Memory[a : a+uint32(len(r.Bytes))] // this makes each data record a reference to memory
 
 	}
+	if block != nil {
+		dotX.Blocks = append(dotX.Blocks, block)
+	}
 
-	dotX.Blocks = []Block{}
+	return dotX, nil
+}
 
-	inBlock := false
-	var blockStart int
+func (dotX *DotXFile) ToMemory() *Memory {
+	m := &Memory{}
 
-	for i, d := range dirtyBytes {
-		if d && !inBlock {
-			inBlock = true
-			blockStart = i
+	m.HighestAddr = uint32(0)
+	m.LowestAddr = uint32(0xFFFFFFFF)
 
+	// find memory bounds
+	for _, block := range dotX.Blocks {
+		if block.Checksummable() {
+			if block.EndAddr > m.HighestAddr {
+				m.HighestAddr = block.EndAddr
+			}
+			if block.StartAddr < m.LowestAddr {
+				m.LowestAddr = block.StartAddr
+			}
 		}
-		if !d && inBlock {
-			inBlock = false
-			dotX.Blocks = append(dotX.Blocks, Block{
-				StartAddr: uint32(blockStart),
-				EndAddr:   uint32(i - 1),
-				Bytes:     dotX.Memory[blockStart:i],
-			})
+	}
+
+	m.Memory = make([]byte, m.HighestAddr+1)
+
+	for _, block := range dotX.Blocks {
+		if block.Checksummable() {
+			copy(m.Memory[block.StartAddr:block.EndAddr+1], block.Bytes)
 		}
+	}
 
+	return m
+}
+
+func NewDotX() *DotXFile {
+	return &DotXFile{
+		DataBusWidth:  16,
+		DataWidthBase: 8,
+		Blocks:        make([]*Block, 0),
 	}
+}
 
-	if inBlock {
-		dotX.Blocks = append(dotX.Blocks, Block{
-			StartAddr: uint32(blockStart),
-			EndAddr:   uint32(len(dirtyBytes) - 1),
-			Bytes:     dotX.Memory[blockStart:len(dirtyBytes)],
-		})
+func (dotX *DotXFile) AddBlock(addr uint32, b []byte) {
+	block := &Block{
+		StartAddr: addr,
+		EndAddr:   addr + uint32(len(b)),
+		Bytes:     b,
 	}
-	return dotX, nil
+	dotX.Blocks = append(dotX.Blocks, block)
+}
+
+func (dotX *DotXFile) TotalBytes() int {
+	t := 0
+	for _, block := range dotX.Blocks {
+		t += len(block.Bytes)
+	}
+	return t
 }
 
 func (dotX *DotXFile) WriteDotX(f *os.File) error {
@@ -206,28 +235,52 @@ func (dotX *DotXFile) WriteDotX(f *os.File) error {
 	trimbleHeader := make([]byte, 18)
 	trimbleHeader[0] = 0x82 // ?
 	trimbleHeader[1] = 0x04 // magic number
-	trimbleHeader[2] = 0x38 // ?
+	trimbleHeader[2] = 0x00 // ?
 	copy(trimbleHeader[3:17], dotX.HeaderText)
 	trimbleHeader[17] = dotX.ProductionFlag // Production Version
 	f.Write(trimbleHeader)
 
 	// Write Processor Record
-	err := binary.Write(f, binary.BigEndian, dotX.ProcessorRecord)
+	pr := &processorRecord{
+		Length:            7,
+		DataBusWidth:      dotX.DataBusWidth,
+		DataWidthBase:     dotX.DataWidthBase,
+		TransferAddressLS: uint16(dotX.TransferAddress & 0xFFFF),
+		TransferAddressMS: uint16(dotX.TransferAddress >> 16 & 0xFFFF),
+	}
+	err := binary.Write(f, binary.BigEndian, pr)
+	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
 	}
 
-	// Write Data Records
-	for _, dr := range dotX.DataRecords {
-		err = binary.Write(f, binary.BigEndian, dr.Header)
-		if err != nil {
-			return err
+	for _, block := range dotX.Blocks {
+		if !block.Checksummable() {
+			continue
 		}
-		err = binary.Write(f, binary.BigEndian, dr.Bytes)
-		if err != nil {
-			return err
+		for _, rec := range block.ToRecords(244) {
+			err = rec.Write(f)
+			if err != nil {
+				return err
+			}
 		}
 	}
+
 	return nil
 }
 
@@ -237,13 +290,13 @@ func WriteBinary(memory []byte, outfile string) error {
 }
 
 func (dotX *DotXFile) SaveBinary(outfile string) error {
-	err := ioutil.WriteFile(outfile, []byte(dotX.Memory), 0644)
-	return err
+	//err := ioutil.WriteFile(outfile, []byte(dotX.Memory), 0644)
+	return nil //err
 }
 
-func (dotX *DotXFile) ExtractSigCode(baseAddr uint32) []uint8 {
+func (m *Memory) ExtractSigCode(baseAddr uint32) []byte {
 
-	tmsRAM := make([]uint8, 0x8000)
+	tmsRAM := make([]byte, 0x8000)
 
 	inAddr := baseAddr + 0x1C
 
@@ -252,17 +305,17 @@ func (dotX *DotXFile) ExtractSigCode(baseAddr uint32) []uint8 {
 	// 4-5		destination offset
 	// 6...n	data
 	for {
-		if binary.BigEndian.Uint16(dotX.Memory[inAddr:inAddr+3]) == 0 {
+		if binary.BigEndian.Uint16(m.Memory[inAddr:inAddr+3]) == 0 {
 			break
 		}
-		i := binary.BigEndian.Uint16(dotX.Memory[inAddr+2:inAddr+5]) >> 1
-		outAddr := uint32(binary.BigEndian.Uint16(dotX.Memory[inAddr+4:inAddr+7])) << 1
+		i := binary.BigEndian.Uint16(m.Memory[inAddr+2:inAddr+5]) >> 1
+		outAddr := uint32(binary.BigEndian.Uint16(m.Memory[inAddr+4:inAddr+7])) << 1
 		inAddr += 8
 		for ; i > 0; i-- {
 			// TMS320C25 is little endian
 			// MC68332 is big endian
-			tmsRAM[outAddr] = dotX.Memory[inAddr+1]
-			tmsRAM[outAddr+1] = dotX.Memory[inAddr]
+			tmsRAM[outAddr] = m.Memory[inAddr+1]
+			tmsRAM[outAddr+1] = m.Memory[inAddr]
 			inAddr += 2
 			outAddr += 2
 
@@ -275,45 +328,41 @@ func (dotX *DotXFile) ExtractSigCode(baseAddr uint32) []uint8 {
 func (dotX *DotXFile) PrintInfo() {
 
 	fmt.Println("----------------- Header Record -----------------")
-	fmt.Printf("                    Version: %d\n", dotX.ProductionFlag)
+	fmt.Printf("        Production firmware: %v\n", dotX.ProductionFlag == 'P')
 	fmt.Printf("        HP64000 header name: %s\n", dotX.HeaderText)
 
 	fmt.Println("------------ Processor Record ------------")
-	fmt.Printf("              Record Length: %d\n", dotX.ProcessorRecord.Length+1)
-	fmt.Printf("             Data Bus Width: %d\n", dotX.ProcessorRecord.DataBusWidth)
-	fmt.Printf("            Data Width Base: %d\n", dotX.ProcessorRecord.DataWidthBase)
-	fmt.Printf("        Transfer Address LS: 0x%04X\n", dotX.ProcessorRecord.TransferAddressLS)
-	fmt.Printf("        Transfer Address MS: 0x%04X\n", dotX.ProcessorRecord.TransferAddressMS)
-	fmt.Printf("  Transfer Address Combined: 0x%08X\n", dotX.ProcessorRecord.TransferAddress())
+	fmt.Printf("             Data Bus Width: %d\n", dotX.DataBusWidth)
+	fmt.Printf("            Data Width Base: %d\n", dotX.DataWidthBase)
+	fmt.Printf("           Transfer Address: 0x%08X\n", dotX.TransferAddress)
+
+	dotX.PrintBlocks()
+}
+
+func (m *Memory) PrintInfo() {
 
 	fmt.Println("-------------- Data Records --------------")
-	fmt.Printf("          Number of Records: %d\n", len(dotX.DataRecords))
-	fmt.Printf("             Lowest Address: 0x%08X\n", dotX.minAddr)
-	fmt.Printf("            Highest Address: 0x%08X\n", dotX.maxAddr)
-	fmt.Printf("                Memory Size: %d\n", dotX.memSize)
-	fmt.Printf("            Populated Space: %d (%0.2f%%)\n", dotX.totalBytes, float64(dotX.totalBytes)/float64(dotX.memSize)*100)
-	fmt.Printf("               Unused Space: %d (%0.2f%%)\n", dotX.unused, float64(dotX.unused)/float64(dotX.memSize)*100)
+	fmt.Printf("             Lowest Address: 0x%08X\n", m.LowestAddr)
+	fmt.Printf("            Highest Address: 0x%08X\n", m.HighestAddr)
 
 	fmt.Println("-------------- Firmware Metadata --------------")
-	verMaj, verMin := dotX.FirmwareVersion()
+	verMaj, verMin := m.FirmwareVersion()
 	fmt.Printf("           Firmware Version: %d.%d\n", verMaj, verMin)
-	fmt.Printf("              Test firmware: %v\n", dotX.Memory[0x229] != 0)
-	fmt.Printf("        Production firmware: %v\n", dotX.ProductionFlag == 'P')
-	fmt.Printf("              Firmware Date: %v\n", dotX.FirmwareDate().Format("02-Jan-2006"))
+	fmt.Printf("              Test firmware: %v\n", m.Memory[0x229] != 0)
+	fmt.Printf("              Firmware Date: %v\n", m.FirmwareDate().Format("02-Jan-2006"))
 
-	dotX.PrintBlocks()
 }
 
-func (dotX *DotXFile) FirmwareVersion() (int, int) {
-	ver := int(binary.BigEndian.Uint16(dotX.Memory[0x204 : 0x205+1]))
+func (m *Memory) FirmwareVersion() (int, int) {
+	ver := int(binary.BigEndian.Uint16(m.Memory[0x204 : 0x205+1]))
 	major := ver / 100
 	minor := ver % 100
 	return major, minor
 }
 
-func (dotX *DotXFile) FirmwareDate() time.Time {
+func (m *Memory) FirmwareDate() time.Time {
 
-	date := int(binary.BigEndian.Uint32(dotX.Memory[0x222 : 0x222+5]))
+	date := int(binary.BigEndian.Uint32(m.Memory[0x222 : 0x222+5]))
 	month := date / 10000
 	day := date / 100 % 100
 	year := date % 100
@@ -341,32 +390,34 @@ func (dotX *DotXFile) PrintBlocks() {
 			fmt.Printf("                   Checksum: %08X\n", cs)
 			ccs, _ := block.CalculateChecksum()
 			fmt.Printf("                 Calculated: %08X\n", ccs)
+		} else {
+			fmt.Printf("                      Bytes: % 02X\n", block.Bytes)
 		}
 	}
 
 }
 
-func (dotX *DotXFile) FindSequence(seq []uint8) []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
-
-}
+// 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
+//
+// }
 
-func (dotX *DotXFile) UpdateChecksums() {
-	for _, block := range dotX.Blocks {
-		block.UpdateChecksum()
-	}
-}
+// func (dotX *DotXFile) UpdateChecksums() {
+// 	for _, block := range dotX.Blocks {
+// 		block.UpdateChecksum()
+// 	}
+// }
 
-type ProcessorRecord struct {
+type processorRecord struct {
 	Length            uint16
 	DataBusWidth      uint16
 	DataWidthBase     uint16
@@ -374,11 +425,11 @@ type ProcessorRecord struct {
 	TransferAddressMS uint16
 }
 
-func (p *ProcessorRecord) TransferAddress() int {
-	return int(p.TransferAddressLS) + int(p.TransferAddressMS)<<16
-}
+// func (p *processorRecord) TransferAddress() int {
+// 	return int(p.TransferAddressLS) + int(p.TransferAddressMS)<<16
+// }
 
-type DataRecordHeader struct {
+type dataRecordHeader struct {
 	Length        uint16
 	DataBytes     uint16
 	LoadAddressLS uint16
@@ -386,22 +437,57 @@ type DataRecordHeader struct {
 }
 
 type DataRecord struct {
-	Header DataRecordHeader
-	Bytes  []uint8
+	Addr  uint32
+	Bytes []byte
+	//Header  dataRecordHeader
 }
 
-func (d *DataRecord) LoadAddr() uint32 {
-	return uint32(d.Header.LoadAddressLS) + uint32(d.Header.LoadAddressMS)<<16
+func (d *DataRecord) LastAddr() uint32 {
+	return d.Addr + uint32(len(d.Bytes)) - 1
 }
 
-func (d *DataRecord) MaxAddr() uint32 {
-	return d.LoadAddr() + uint32(d.Header.DataBytes)
+func (d *DataRecord) Write(f *os.File) error {
+	header := dataRecordHeader{
+		Length:        uint16(len(d.Bytes) + 5),
+		DataBytes:     uint16(len(d.Bytes)),
+		LoadAddressMS: uint16(d.Addr >> 16 & 0xFFFF),
+		LoadAddressLS: uint16(d.Addr & 0xFFFF),
+	}
+	err := binary.Write(f, binary.BigEndian, header)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(f, binary.BigEndian, d.Bytes)
+	if err != nil {
+		return err
+	}
+	return nil
 }
 
 type Block struct {
 	StartAddr uint32
 	EndAddr   uint32
-	Bytes     []uint8
+	Bytes     []byte
+}
+
+func (b *Block) Len() int {
+	return int(b.EndAddr - b.StartAddr)
+}
+
+func (b *Block) ToRecords(blockSize int) []*DataRecord {
+	recs := make([]*DataRecord, 0)
+	length := len(b.Bytes)
+	for i := 0; i < length; i += blockSize {
+		l := blockSize
+		if i+l > length {
+			l = length - i
+		}
+		recs = append(recs, &DataRecord{
+			Addr:  uint32(i) + b.StartAddr,
+			Bytes: b.Bytes[i : i+l],
+		})
+	}
+	return recs
 }
 
 func (b *Block) Checksummable() bool {

monitor/monitor.go

@@ -14,6 +14,20 @@ import (
 
 const (
 	readWriteBlockSize = 244
+
+	NrmCmdGetSerial  = 0x06
+	NrmCmdRSerial    = 0x07
+	NrmCmdGetOpt     = 0x4A
+	NrmCmdRetOpt     = 0x4B
+	NrmCmdModeChange = 0x87
+
+	MonCmdWriteMem = 0x80
+	MonCmdReadMem  = 0x82
+	MonCmdBaudRate = 0x86
+	MonCmdReset    = 0x88
+	MonCmdJmp      = 0x89
+
+	MonCmdReadMemAck = 0x92
 )
 
 type Monitor struct {
@@ -31,6 +45,8 @@ type Monitor struct {
 	Dummy bool
 
 	inMonitor bool
+	
+	seekPos uint32
 }
 
 type RecieverState int
@@ -52,7 +68,6 @@ const (
 func (m *Monitor) StartMonitor() error {
 	if m.Dummy {
 		m.inMonitor = true
-		fmt.Println("Monitor dummy mode active.")
 		return nil
 	}
 	fmt.Println("Starting monitor mode...")
@@ -167,9 +182,10 @@ func (m *Monitor) setupChipSelects() error {
 	// back to the CPU? Hmmm.
 
 	err := m.WriteMemory(0x00FFFA58, []uint16{
-		0x1004, // CSBAR3
-		0x7B71, // CSOR3
+		0x1004, // CSBAR3 128k @ 0x100000
+		0x7B71, // CSOR3 Change DSACK to 13 wait
 	})
+
 	if err != nil {
 		return err
 	}
@@ -256,13 +272,17 @@ func (m *Monitor) waitForMonitor() error {
 func (m *Monitor) Stop() error {
 
 	// send the reboot command
-	err := m.SendStxEtxRequest(0x88, []byte{})
+	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 {
@@ -277,12 +297,19 @@ func (m *Monitor) Close() {
 	m.port.Close()
 }
 
-// ReadMemory reads the device memory
+// 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)
+	//fmt.Printf("ReadMemory: addr=%08X length=%d\n", addr, length)
 
 	maxRetries := 3
 
@@ -300,7 +327,7 @@ func (m *Monitor) ReadMemory(addr uint32, length int) ([]byte, error) {
 		binary.BigEndian.PutUint32(b[0:4], blockAddr)
 		b[4] = byte(l)
 
-		fmt.Printf("ReadMemory LOOP: addr=%08X length=%d\n", blockAddr, l)
+		//fmt.Printf("ReadMemory LOOP: addr=%08X length=%d\n", blockAddr, l)
 
 		var err error
 
@@ -326,11 +353,15 @@ func (m *Monitor) ReadMemory(addr uint32, length int) ([]byte, error) {
 		if err != nil {
 			return nil, err
 		}
+		if progressFunc != nil {
+			progressFunc(blockAddr)
+		}
 	}
 	return out, nil
 }
 
-// WriteMemory writes the device memory
+// WriteMemory writes the device memory, breaking the write up into multiple
+// commands as needed.
 func (m *Monitor) WriteMemory(addr uint32, data interface{}) error {
 	if !m.inMonitor {
 		return fmt.Errorf("receiver not in monitor")
@@ -367,6 +398,7 @@ func (m *Monitor) WriteMemory(addr uint32, data interface{}) error {
 				break
 			}
 		}
+
 		if err != nil {
 			return err
 		}
@@ -374,6 +406,30 @@ func (m *Monitor) WriteMemory(addr uint32, data interface{}) error {
 	return nil
 }
 
+// Jump calls the monitor's jump command.
+func (m *Monitor) Jump(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)
+}
+
+// ResetReceiver calls the monitor's reset command.
+func (m *Monitor) ResetReceiver() error {
+	if !m.inMonitor {
+		return fmt.Errorf("receiver not in monitor")
+	}
+	err := m.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
@@ -401,17 +457,6 @@ func (m *Monitor) checkMonitorMode() (RecieverState, error) {
 	return ReceiverNormal, nil
 }
 
-func (m *Monitor) ResetReceiver() error {
-	fmt.Println("Resetting receiver...")
-
-	err := m.SendStxEtxRequest(MonCmdReset, []byte{})
-	if err != nil {
-		return err
-	}
-	m.inMonitor = false
-	return nil
-}
-
 // ReceiverInfo holds all the information we can glean from the receiver by
 // probing its memory.
 type ReceiverInfo struct {
@@ -438,7 +483,7 @@ type ReceiverInfo struct {
 func (info *ReceiverInfo) PrintOptions() {
 
 	// Print receiver identity information
-	fmt.Printf("\n   name1:%s\n", info.Name1)
+	fmt.Printf("   name1:%s\n", info.Name1)
 	fmt.Printf("   name2:%s\n", info.Name2)
 	fmt.Printf("ASCII serial #:%14s\n", info.SerialNumberString)
 	fmt.Printf("  int serial #:%14d\n", info.SerialNumber)
@@ -468,10 +513,9 @@ func (info *ReceiverInfo) PrintOptions() {
 
 func (info *ReceiverInfo) PrintVersions() {
 	// TODO: empty string in param 3 should say '(TEST)' when in test mode
-	fmt.Printf("\n")
-	fmt.Printf("  code version=%1d.%02d %s    Date: %s\n", info.FirmwareVersionMajor, info.FirmwareVersionMinor, "", info.FirmwareDate.Format("02-Jan-06"))
+	fmt.Printf("  Code Version: %1d.%02d %s    Date: %s\n", info.FirmwareVersionMajor, info.FirmwareVersionMinor, "", info.FirmwareDate.Format("02-Jan-06"))
 	fmt.Printf("    Code1: %06X-%06X   Code2: %06X-%06X\n", info.Code1Start, info.Code1End-1, info.Code2Start, info.Code2End-1)
-	fmt.Printf("checksums:    %06X               %06X\n", info.Code1Checksum, info.Code2Checksum)
+	fmt.Printf("Checksums:    %06X               %06X\n", info.Code1Checksum, info.Code2Checksum)
 }
 
 // GetReceiverInfo reads receiver information out of the receiver. Unlike GetOptions
@@ -563,6 +607,67 @@ type RuntimeConfig struct {
 	ChannelsL1        string
 }
 
+func progressBar(width, progress, total int) string {
+	progressBlocks := []rune{'▏', '▎', '▍', '▌', '▋', '▊', '▉', '█'}
+	p := float64(progress) / float64(total)
+	blocks := int(float64(width) * p)
+	eighths := int(float64(width)*p*8) % 8
+	bar := strings.Repeat("█", blocks)
+	blankWidth := width - blocks - 1
+	if blankWidth < 0 {
+		blankWidth = 0
+	}
+	blank := strings.Repeat("-", blankWidth)
+	return fmt.Sprintf("(%0.2f%%) %s%c%s\n", p*100, bar, progressBlocks[eighths], blank)
+}
+
+type codeBlock struct {
+	start uint32
+	end   uint32
+}
+
+func (m *Monitor) CaptureReceiverFirmware() (*dotx.DotXFile, error) {
+
+	info, err := m.GetReceiverInfo()
+	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 := m.ReadMemoryWithProgress(block.StartAddr, blockLen, func(i uint32) {
+			fmt.Printf("$%08X  %s\r", i, progressBar(50, int(i-block.StartAddr)+bytesWriten, totalBytes))
+		})
+		if err != nil {
+			return nil, err
+		}
+		block.Bytes = b
+		dotX.Blocks = append(dotX.Blocks, block)
+		bytesWriten += blockLen
+	}
+
+	return dotX, nil
+}
+
 func (m *Monitor) GetRuntimeConfig() (*RuntimeConfig, error) {
 	if m.inMonitor {
 		return nil, fmt.Errorf("receiver not in normal mode")
@@ -686,28 +791,103 @@ func (m *Monitor) GetOptions() (*Options, error) {
 	return opts, nil
 }
 
-func (m *Monitor) WriteFirmware(fw *dotx.DotXFile) {
+func (m *Monitor) ProgramReceiver(fw *dotx.DotXFile) error {
 	fmt.Printf("Writing receiver program...\n")
 	save := make([]byte, 8)
-	numRecs := float64(len(fw.DataRecords))
+	totalBytes := fw.TotalBytes()
 	t := 0
-	for i, rec := range fw.DataRecords {
-		fmt.Printf("%08X  (%0.2f%%)\r", rec.LoadAddr(), float64(i)/numRecs*100)
-		//fmt.Printf("----%02X\n",rec.Bytes)
-		// 	fmt.Printf("LoadAddr: %08X\n",rec.LoadAddr())
-		t += len(rec.Bytes)
-		if rec.LoadAddr() == 0 {
-			b2 := make([]byte, len(rec.Bytes))
-			copy(b2, rec.Bytes)
-			copy(save[0:8], rec.Bytes[0:8])
-			binary.BigEndian.PutUint32(b2[0:], 0x4E722700)
-			binary.BigEndian.PutUint32(b2[4:], 0x00000000)
-			m.WriteMemory(rec.LoadAddr(), b2)
-		} else {
-			m.WriteMemory(rec.LoadAddr(), rec.Bytes)
+	var err error
+	progressBarWidth := 50
+	progressBlocks := []rune{'▏', '▎', '▍', '▌', '▋', '▊', '▉', '█'}
+
+	// set fixFailedWrite to true to have the code just correct the first 8
+	// bytes of memory. This is basically a kludge for testing.
+	fixFailedWrite := false
+
+	for i, block := range fw.Blocks {
+		if fixFailedWrite && i > 2 {
+			// all we want are the chip selects and CODE1
+			continue
 		}
-		time.Sleep(1 * time.Millisecond)
+		recs := block.ToRecords(244)
+		fmt.Printf("Writing block %d ($%08X - $%08X)...\n", i, block.StartAddr, block.EndAddr)
+		for _, rec := range recs {
+			t += len(rec.Bytes)
+			p := float64(t) / float64(totalBytes)
+			blocks := int(float64(progressBarWidth) * p)
+			eighths := int(float64(progressBarWidth)*p*8) % 8
+			bar := strings.Repeat("█", blocks)
+			blankWidth := progressBarWidth - blocks - 1
+			if blankWidth < 0 {
+				blankWidth = 0
+			}
+			blank := strings.Repeat("-", blankWidth)
+
+			progressBar := fmt.Sprintf("%s%c%s", bar, progressBlocks[eighths], blank)
+			fmt.Printf("$%08X  (%0.2f%%) %s\r", rec.Addr, p*100, progressBar)
+
+			if rec.Addr == 0x00000000 {
+				// This replaces the first 8 bytes of the firmware image with
+				// 4E72270000000000. The first 8 bytes are the stack pointer and
+				// reset vector. The first value is actually a STOP #$2700
+				// instruction, and the 0x00000000 reset vector means that STOP
+				// is the only thing that will be executed. This saves the intended
+				// value to write to memory at the end of the firmware upgrade
+				// process, guaranteeing that the receiver will not function
+				// with a half-baked firmware. Crafty, Trimble.
+				b2 := make([]byte, len(rec.Bytes))
+				copy(b2, rec.Bytes)
+				copy(save[0:8], rec.Bytes[0:8])
+				binary.BigEndian.PutUint32(b2[0:], 0x4E722700)
+				binary.BigEndian.PutUint32(b2[4:], 0x00000000)
+				err = m.WriteMemory(rec.Addr, b2)
+
+				if fixFailedWrite {
+					// for a fixFailedWrite all I care about is the first record.
+					break
+				}
+			} else {
+				err = m.WriteMemory(rec.Addr, rec.Bytes)
+			}
+			if err != nil {
+				return err
+			}
+			if m.Dummy {
+				time.Sleep(1 * time.Millisecond)
+			}
+		}
+		fmt.Printf("% 80s\r", "")
 	}
-	fmt.Printf("\nDone. %d bytes written.\n", t)
-	m.WriteMemory(0x00000000, save)
+	fmt.Printf("\rDone. %d bytes written.\n", t)
+	err = m.WriteMemory(0x00000000, save)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Rebooting receiver.\n")
+	return m.ResetReceiver()
+}
+
+// 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)
+	return len(p), err
+}
+
+// Seek implements the io.Seeker interface
+func (m *Monitor) xSeek(offset int64, whence int) (int64, error) { 
+	var abs int64
+	switch whence {
+	case io.SeekStart:
+		abs = offset
+	case io.SeekCurrent:
+		abs = int64(m.seekPos) + offset
+	default:
+		return 0, fmt.Errorf("Seek: invalid whence")
+	}
+	if abs < 0 {
+		return 0, fmt.Errorf("Seek: negative position")
+	}
+	m.seekPos = uint32(abs)
+	return abs, nil
 }

monitor/protocol.go

@@ -7,22 +7,6 @@ import (
 
 const (
 	MAXPACKETLLEN = 255 + 6
-	// 	STX           = 0x02
-	// 	ETX           = 0x03
-	// 	ENQ           = 0x05
-	// 	ACK           = 0x06
-
-	NrmCmdGetSerial = 0x06
-	NrmCmdRSerial   = 0x07
-	NrmCmdGetOpt    = 0x4A
-	NrmCmdRetOpt    = 0x4B
-
-	NrmCmdModeChange = 0x87
-	MonCmdBaudRate   = 0x86
-	MonCmdWriteMem   = 0x80
-	MonCmdReadMem    = 0x82
-	MonCmdReadMemAck = 0x92
-	MonCmdReset      = 0x88
 )
 
 type ProtocolError struct {

monitor/serial.go

@@ -26,13 +26,13 @@ func Connect(device string, baud int, dataBits int, stopBits int, parity string,
 	}
 
 	switch parity {
-	case "n":
+	case "none":
 		m.parity = serial.PARITY_NONE
 		m.portConfig.ParityMode = serial.PARITY_NONE
-	case "e":
+	case "even":
 		m.parity = serial.PARITY_EVEN
 		m.portConfig.ParityMode = serial.PARITY_EVEN
-	case "o":
+	case "odd":
 		m.parity = serial.PARITY_ODD
 		m.portConfig.ParityMode = serial.PARITY_ODD
 	default:
@@ -117,7 +117,7 @@ func (m *Monitor) useUserBaudRate() error {
 }
 
 func parityToString(p serial.ParityMode) string {
-	s := []string{"n", "o", "e"}
+	s := []string{"none", "odd", "even"}
 	return s[p]
 }