Merge pull request #2425 from LinuxCNC/fix-elbpcom

Fix elbpcom

Author: andypugh

docs/man/man1/elbpcom.1

@@ -9,13 +9,14 @@ Common options:
 .BI [\-\-ip= IP ]
 .BI [\-\-port= PORT ]
 .BI [\-\-timeout= TIMEOUT ]
+.BI [\-\-space= MEMSPACE ]
+.BI [\-\-size= TRANSFER_SIZE ]
 .RE
 
 Reading data:
 .RS
 .SY elbpcom
 .BI [ common\ options ]
-.BI \-\-space= SPACE
 .B [\-\-info]
 .BI \-\-address= ADDRESS
 .BI \-\-read= LENGTH
@@ -25,11 +26,17 @@ Writing data:
 .RS
 .SY elbpcom
 .BI [ common\ options ]
-.BI \-\-space= SPACE
 .BI \-\-address= ADDRESS
 .BI \-\-write= HEXDATA
 .RE
 
+Read and decode memory space info area:
+.RS
+.SY elbpcom
+.BI [\-\-space= MEMSPACE ]
+.BI \-\-read-info
+.RE
+
 Sending arbitrary packets:
 .RS
 .SY elbpcom
@@ -54,13 +61,21 @@ If not specified, the default values are
 .BI \-\-ip= 192.168.1.121
 .BI \-\-port= 27181
 .BI \-\-timeout= .2
+.BI \-\-space= 0
+.BI \-\-size= 0
 .RE 
 
+If the
+.B --size
+argument
+.I TRANSFER_SIZE
+is 0, elbpcom will look up the preferred transfer size of the space in the space's info area.
+
 This example demonstrates reading the HOSTMOT2 identifying string from the
 IDROM in space 0:
 .RS
 .nf
-$ elbpcom \-\-space 0 \-\-address 0x104 \-\-read 8
+$ elbpcom \-\-address 0x104 \-\-read 8
 > 82420401
 < 484f53544d4f5432
       HOSTMOT2

src/hal/utils/elbpcom.py

@@ -26,30 +26,38 @@
 parser = optparse.OptionParser("%prog [options] [commands]",
     description="Communicate with Mesa ethernet cards using the LBP16 protocol")
 parser.add_option("-i", "--ip", dest="sip",
-    help="IP address of board",
+    help="IP address of board (default: 192.168.1.121)",
     metavar="X.Y.Z.W", default="192.168.1.121")
 parser.add_option("-p", "--port", dest="sport",
-    help="UDP port of board", type="int", default=27181)
+    help="UDP port of board (default: 27181)", type="int", default=27181)
 parser.add_option("-t", "--timeout", dest="timeout",
-    help="Response timeout in seconds", type="float", default=.2)
-parser.add_option("-s", "--space", dest="space", default=None,
+    help="Response timeout in seconds (default: 0.2)", type="float", default=.2)
+parser.add_option("-s", "--space", dest="space", default=0,
     choices = ["0", "1", "2", "3", "4", "5", "6", "7"],
-    help="Address space to read or write")
+    help="Address space to read or write (default: 0, the hm2 register file)")
 parser.add_option("--info", dest="info", action="store_true",
     default=False,
     help="Select info area for read operation (default: memory space)")
 parser.add_option("-a", "--address", type="int", dest="address", default=None,
     help="Base address to read or write")
 parser.add_option("-I", "--increment", dest="increment", action="store_true",
     default=True,
-    help="auto-increment address")
+    help="auto-increment address (enabled by default, use --no-increment to disable)")
 parser.add_option("-n", "--no-increment", dest="increment",
     action="store_false",
     help="do not auto-increment address")
+parser.add_option("--size", dest="size",
+    help="Transfer size in number of bytes (default: look up preferred transfer size in the space's info area)",
+    type="int", default=0)
 parser.add_option("-r", "--read", type="int", dest="read", default=None,
     help="Number of bytes to read")
 parser.add_option("-w", "--write", type="string", dest="write", default=None,
     help="Hex-coded Values to read")
+
+parser.add_option("--read-info", dest="read_info", default=False,
+    action="store_true",
+    help="Read and decode the info area of the selected memory space.")
+
 options, args = parser.parse_args()
 if options.space: options.space = int(options.space)
 
@@ -58,14 +66,13 @@
 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0)
 s.settimeout(options.timeout)
 
-def transact(sdata, quiet=False, response=True):
-    sdata = "".join(sdata.split()).decode("hex")
+def transact(sdata:bytes, quiet=False, response=True):
     s.sendto(sdata, (options.sip, options.sport))
     if not response: return
     try:
         data, daddr = s.recvfrom(1280)
-        if not quiet: print("<", data.encode("hex"))
-        if not quiet: print("     ", re.sub('[^ -~]', '.', data))
+        if not quiet: print("<", data.hex())
+        if not quiet: print("     ", re.sub('[^ -~]', '.', data.decode('utf-7', errors='replace')))
         return data
     except socket.timeout:
         if not quiet: print("! no response")
@@ -80,21 +87,21 @@ def interact():
     except KeyboardInterrupt:
         pass
 
-def make_read_request(space, info, size, increment, address, nbytes):
+def make_read_request(space:int, info:bool, size:int, increment:bool, address:int, nbytes:int) -> bytes:
     return struct.pack("<HH",
         (1<<14) | (space << 10) | (info << 13)
-        | (sizemap[size] << 8) | (increment << 7) | (nbytes/size),
+        | (sizemap[size] << 8) | (increment << 7) | int(nbytes/size),
         address)
 
-def make_write_request(space, info, size, increment, address, bytes):
+def make_write_request(space:int, info:bool, size:int, increment:bool, address:int, data:bytes) -> bytes:
     return struct.pack("<HH",
         (1<<15) | (1<<14) | (space << 10) | (info << 13)
-        | (sizemap[size] << 8) | (increment << 7) | (len(bytes) / size),
-        address) + bytes
+        | (sizemap[size] << 8) | (increment << 7) | int(len(data) / size),
+        address) + data
 
-def optimal_size(space, info, address, nbytes):
+def optimal_size(space:int, info:bool, address:int, nbytes:int):
     if info: return 2
-    info = transact(make_read_request(space, True, 2, True, 2, 4).encode("hex"), quiet=True)
+    info = transact(make_read_request(space, True, 2, True, 2, 4), quiet=True)
     if info is None:
         raise RuntimeError("Failed to get information about memory space %d" % space)
     memsizes, memranges = struct.unpack("<HH", info)
@@ -108,25 +115,86 @@ def optimal_size(space, info, address, nbytes):
         return b
     raise ValueError("Access size incompatible with address or length (address=%d nbytes=%d memsizes=%d)" % (address, nbytes, memsizes))
 
+def get_uint16(data:bytes, offset:int):
+    return (data[offset+1] << 8) | data[offset]
+
+def print_info(data:bytes):
+    print(f"info area for memory space {options.space}:")
+
+    cookie = get_uint16(data, 0)
+    print(f"    cookie: 0x{cookie:04x}")
+
+    memsize = get_uint16(data, 2)
+    memsize_writable = memsize & 0x8000
+    memsize_type = (memsize & 0x7f00) >> 8
+    memsize_access = memsize & 0x000f
+    print(f"    memsize: 0x{memsize:04x}")
+
+    print("        Writable" if memsize_writable else "        Read-Only")
+
+    if (memsize_type == 0x01):
+        print("        type=01 (Register)")
+    elif (memsize_type == 0x02):
+        print("        type=02 (Memory)")
+    elif (memsize_type == 0x0e):
+        print("        type=0e (EEPROM)")
+    elif (memsize_type == 0x0f):
+        print("        type=0f (Flash)")
+    else:
+        print(f"        type={memsize_type:02x}(unknown)")
+
+    print(f"        access=0x{memsize_access:01x}", end='')
+    if memsize_access & 0x1:
+        print(" 8-bit", end='')
+    if memsize_access & 0x2:
+        print(" 16-bit", end='')
+    if memsize_access & 0x4:
+        print(" 32-bit", end='')
+    if memsize_access & 0x8:
+        print(" 64-bit", end='')
+    print()
+
+    memranges = get_uint16(data, 4)
+    e = (memranges & 0xf800) >> 11
+    p = (memranges & 0x07c0) >> 6
+    s = memranges & 0x003f
+    print(f"    memranges: 0x{memranges:04x}")
+    print(f"        erase block size: {e} ({2**e} bytes)")
+    print(f"        page size: {p} ({2**p} bytes)")
+    print(f"        Ps address range: {s} ({2**s} bytes)")
+
+    addr_ptr = get_uint16(data, 6)
+    print(f"    addr ptr: 0x{addr_ptr:04x}")
+
+    name = str(data[8:], encoding='utf-7')
+    print(f"    name: {name}")
+
+
 if options.read:
-    if options.space is None: raise SystemExit("--read must specify --space")
     if options.address is None: raise SystemExit("--read must specify --address")
-    size = optimal_size(options.space, options.info, options.address, options.read if options.increment else 0)
-    command = make_read_request(options.space, options.info, size, options.increment, options.address, options.read)
-    command = command.encode("hex")
-    print(">", command)
+    if options.size == 0:
+        options.size = optimal_size(options.space, options.info, options.address, options.read if options.increment else 0)
+    command = make_read_request(options.space, options.info, options.size, options.increment, options.address, options.read)
+    print(">", command.hex())
     transact(command)
 
 elif options.write:
-    if options.space is None: raise SystemExit("--write must specify --space")
     if options.address is None: raise SystemExit("--write must specify --address")
-    write = options.write.decode("hex")
-    size = optimal_size(options.space, options.info, options.address, len(write) if options.increment else 0)
-    command = make_write_request(options.space, options.info, size, options.increment, options.address, write)
-    command = command.encode("hex")
-    print(">", command)
+    write = bytes.fromhex(options.write)
+    if options.size == 0:
+        options.size = optimal_size(options.space, options.info, options.address, len(write) if options.increment else 0)
+    command = make_write_request(options.space, options.info, options.size, options.increment, options.address, write)
+    print(">", command.hex())
     transact(command, response=False)
 
+elif options.read_info:
+    if options.size == 0:
+        options.size = optimal_size(options.space, True, 0x0000, 16)
+    command = make_read_request(options.space, True, options.size, options.increment, 0x00, 0x10)
+    print(">", command.hex())
+    data = transact(command)
+    print_info(data)
+
 elif args:
     for a in args:
         transact(a)