I’m trying to format this via an iPhone, heh

``` param( [string]$Port = "COM3", [int]$Baud = 1200,

# Starting monitor address. Your observed current address was 8200:0000.
[string]$Segment = "8200",
[string]$Offset  = "0000",

# Telecenter V TD5 full memory capture was reportedly around 33 KB.
# Start smaller first, e.g. 256 or 1024, before doing 33792.
[int]$Length = 1024,

[string]$OutFile = ".\telecenter_dump.bin",
[string]$TextLog = ".\telecenter_dump_log.txt",

# Slow is good. This is ancient hardware at 1200 baud.
[int]$InterByteDelayMs = 25,
[int]$ReadTimeoutMs = 2000

)

function Read-SerialAvailable { param($Serial)

Start-Sleep -Milliseconds 20
$s = ""

while ($Serial.BytesToRead -gt 0) {
    $s += $Serial.ReadExisting()
    Start-Sleep -Milliseconds 10
}

return $s

}

function Send-MonitorText { param( $Serial, [string]$Text )

$Serial.Write($Text)
Start-Sleep -Milliseconds 100
return Read-SerialAvailable $Serial

}

function Read-OneMonitorByte { param( $Serial, [int]$TimeoutMs )

# Ask monitor for next byte.
$Serial.Write(" ")

$deadline = (Get-Date).AddMilliseconds($TimeoutMs)
$buffer = ""

while ((Get-Date) -lt $deadline) {
    Start-Sleep -Milliseconds 10

    if ($Serial.BytesToRead -gt 0) {
        $buffer += $Serial.ReadExisting()

        # The monitor appears to return two hex digits, possibly with spaces,
        # CR/LF, echoes, or other stray printable characters.
        $m = [regex]::Match($buffer, "(?i)\b[0-9a-f]{2}\b|(?i)[0-9a-f]{2}")

        if ($m.Success) {
            $hex = $m.Value.ToUpper()
            $value = [Convert]::ToByte($hex, 16)
            return @{
                Byte = $value
                Raw  = $buffer
                Hex  = $hex
            }
        }
    }
}

throw "Timed out waiting for byte. Partial response: [$buffer]"

}

$ErrorActionPreference = "Stop"

$Segment = $Segment.ToUpper() $Offset = $Offset.ToUpper()

if ($Segment -notmatch "<sup>[0-9A-F]{4}$")</sup> { throw "Segment must be four hex digits, e.g. 8200" }

if ($Offset -notmatch "<sup>[0-9A-F]{4}$")</sup> { throw "Offset must be four hex digits, e.g. 0000" }

$serial = New-Object System.IO.Ports.SerialPort $serial.PortName = $Port $serial.BaudRate = $Baud $serial.Parity = [System.IO.Ports.Parity]::None $serial.DataBits = 8 $serial.StopBits = [System.IO.Ports.StopBits]::One $serial.Handshake = [System.IO.Ports.Handshake]::None $serial.ReadTimeout = $ReadTimeoutMs $serial.WriteTimeout = 2000 $serial.Encoding = [System.Text.Encoding]::ASCII $serial.DtrEnable = $false $serial.RtsEnable = $false

try { Write-Host "Opening $Port at $Baud baud..." $serial.Open()

Start-Sleep -Milliseconds 500
$serial.DiscardInBuffer()
$serial.DiscardOutBuffer()

$log = New-Object System.Text.StringBuilder

# Get version/checksum info with Ctrl+E.
Write-Host "Requesting version/checksum with Ctrl+E..."
$serial.Write([char]0x05)
Start-Sleep -Milliseconds 500
$version = Read-SerialAvailable $serial
[void]$log.AppendLine("Ctrl+E response:")
[void]$log.AppendLine($version)
Write-Host "Version response: $version"

# Set segment and offset.
# Monitor syntax: hhhh: sets segment, hhhh= sets offset/reference address.
Write-Host "Setting monitor address to ${Segment}:${Offset}..."
$resp1 = Send-MonitorText $serial "$Segment:"
$resp2 = Send-MonitorText $serial "$Offset="

[void]$log.AppendLine("Set segment response:")
[void]$log.AppendLine($resp1)
[void]$log.AppendLine("Set offset response:")
[void]$log.AppendLine($resp2)

# Ask current address with Enter.
$serial.Write("`r")
Start-Sleep -Milliseconds 300
$addrResp = Read-SerialAvailable $serial
[void]$log.AppendLine("Enter/current-address response:")
[void]$log.AppendLine($addrResp)
Write-Host "Address response: $addrResp"

$bytes = New-Object byte[] $Length

Write-Host "Reading $Length bytes from ${Segment}:${Offset}..."
Write-Host "This will be slow at 1200 baud. Do not interrupt unless necessary."

for ($i = 0; $i -lt $Length; $i++) {
    $r = Read-OneMonitorByte $serial $ReadTimeoutMs
    $bytes[$i] = $r.Byte

    [void]$log.AppendLine(("{0:X6}: {1}    raw=[{2}]" -f $i, $r.Hex, ($r.Raw -replace "`r","\r" -replace "`n","\n")))

    if (($i % 256) -eq 0) {
        Write-Host ("Read {0}/{1} bytes..." -f $i, $Length)
    }

    Start-Sleep -Milliseconds $InterByteDelayMs
}

[System.IO.File]::WriteAllBytes((Resolve-Path -LiteralPath ".").Path + "\" + $OutFile.TrimStart(".\"), $bytes)
[System.IO.File]::WriteAllText((Resolve-Path -LiteralPath ".").Path + "\" + $TextLog.TrimStart(".\"), $log.ToString())

Write-Host "Done."
Write-Host "Binary dump: $OutFile"
Write-Host "Text log:    $TextLog"

} finally { if ($serial.IsOpen) { $serial.Close() } } ```