lif80utils 0.0.1__py3-none-any.whl

lif80utils/amigo.py

@@ -0,0 +1,271 @@
+#
+# This file is part of the lif80utils distribution (https://codeberg.org/Boeingflieger/lif80utils).
+# Copyright (c) 2026 Christian Grosz.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, version 3.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+import gpib
+import time # sleep
+
+class Amigo:
+    """This class implements the amigo command set."""
+
+    # https://linux-gpib.sourceforge.io/doc_html/reference-function-ibeot.html
+    # If send_eoi is non-zero, then the EOI line will be asserted with
+    # the last byte sent by calls to ibwrt() and related functions.
+    EOT = 1
+
+    # https://linux-gpib.sourceforge.io/doc_html/reference-function-ibeos.html
+    # The least significant 8 bits of eosmode specify the eos character. You may
+    # also bitwise-or one or more of the following bits to set the eos mode:
+    REOS = 0x400 # Enable termination of reads when eos character is received.
+    XEOS = 0x800 # Assert the EOI line whenever the eos character is sent during writes.
+    BIN = 0x1000 # Match eos character using all 8 bits (instead of only looking at the 7 least significant bits).
+
+    def __init__ ( self, board, pad):
+        self.ppmask = 0x80 >> pad
+
+        self.con_00 = gpib.dev( board, pad, 0x60 + 0x00, gpib.T1s,   0) # Receive Data
+        self.con_08 = gpib.dev( board, pad, 0x60 + 0x08, gpib.T10s, self.EOT) # Unbuffered
+        self.con_09 = gpib.dev( board, pad, 0x60 + 0x09, gpib.T10s, self.EOT) # Buffered Write
+        self.con_0A = gpib.dev( board, pad, 0x60 + 0x0A, gpib.T1s, self.EOT) # Buffered Read
+        self.con_0C = gpib.dev( board, pad, 0x60 + 0x0C, gpib.T10s, self.EOT) # REQU PHY, FORMAT
+        self.con_10 = gpib.dev( board, pad, 0x60 + 0x10, gpib.T1s, self.EOT) # DSJ (Device Specified Jump)
+        self.con_1E = gpib.dev( board, pad, 0x60 + 0x1E, gpib.T1s, self.EOT) # Write/Read Loopback
+
+        self.con_1F = gpib.dev( board, pad, 0x60 + 0x1F, gpib.T1s, self.EOT,    0) # Write/Read Loopback # 10011
+
+    def __del__(self):
+        self.end( )
+
+        gpib.close( self.con_00)
+        gpib.close( self.con_08)
+        gpib.close( self.con_09)
+        gpib.close( self.con_0A)
+        gpib.close( self.con_0C)
+        gpib.close( self.con_10)
+        gpib.close( self.con_1E)
+        gpib.close( self.con_1F)
+
+    def dsj ( self):
+        return gpib.read( self.con_10, 1)
+
+    # Request Status
+    def request_status ( self, unit = 0):
+        gpib.write \
+            ( self.con_08
+            ,   b'\x03'
+              + unit    .to_bytes( 1, 'big')
+            )
+
+        dsj = self.dsj( )
+
+        if b'\x00' != dsj:
+            print( f"{dsj} REQUEST STATUS")
+            return
+
+        return gpib.read( self.con_08, 4)
+
+    # Read Self-Test
+    def read_self_test ( self):
+        return gpib.read( self.con_1F, 2)
+
+    # Write Loopback
+    def write_loopback ( self, data):
+        gpib.write( self.con_1E, data)
+
+    # Read Loopback
+    def read_loopback ( self):
+        return gpib.read( self.con_1E, 255)
+
+    # Seek
+    def seek ( self, unit = 0, cylinder = 0, head = 0, sector = 0):
+        # Seek can need more then 1s timeout.
+        gpib.write \
+            ( self.con_08
+            ,   b'\x02'
+              + unit    .to_bytes( 1, 'big')
+              + cylinder.to_bytes( 2, 'big')
+              + head    .to_bytes( 1, 'big')
+              + sector  .to_bytes( 1, 'big')
+            )
+
+        dsj = self.dsj( )
+
+        if b'\x00' != dsj:
+            print( f"{dsj} SEEK")
+
+        return dsj
+
+    # Buffered Read
+    def buffered_read ( self, unit = 0):
+        gpib.write \
+            ( self.con_0A
+            ,   b'\x05'
+              + unit    .to_bytes( 1, 'big')
+            )
+
+        dsj = self.dsj( )
+
+        if b'\x00' != dsj:
+            print( f"{dsj} READ")
+
+        return dsj
+
+    #
+    def receive ( self, size = 256):
+        res = gpib.read( self.con_00, size)
+        return res
+
+    # Request (Logical) Disc Address
+    def request_logical ( self):
+        gpib.write \
+            ( self.con_08
+            ,   b'\x14\x00'
+            )
+
+        dsj = self.dsj( )
+
+        if b'\x00' != dsj:
+            print( f"{dsj} REQU LOG")
+            return
+
+        return gpib.read( self.con_08, 4)
+
+    # Request (Physical) Disc Address
+    def request_physical ( self):
+        gpib.write \
+            ( self.con_0C
+            ,   b'\x14\x00'
+            )
+
+        dsj = self.dsj( )
+
+        if b'\x00' != dsj:
+            print( f"{dsj} REQU PHY")
+            return
+
+        return gpib.read( self.con_08, 4)
+
+    # End
+    def end ( self):
+        gpib.write \
+            ( self.con_08
+            ,   b'\x15\x00'
+            )
+
+        dsj = self.dsj( )
+
+        if b'\x00' != dsj:
+            print( f"{dsj} END")
+
+        return
+
+    # Buffered Write
+    def buffered_write ( self, unit = 0):
+        gpib.write \
+            ( self.con_09
+            ,   b'\x08'
+              + unit    .to_bytes( 1, 'big')
+            )
+
+        dsj = self.dsj( )
+
+        if b'\x00' != dsj:
+            print( f"{dsj} WRITE")
+
+        return dsj
+
+    #
+    def send ( self, buf):
+        gpib.write \
+            ( self.con_00
+            , buf
+            )
+
+        dsj = self.dsj( )
+
+        if b'\x00' != dsj:
+            print( f"{dsj} send")
+
+        return dsj
+
+    # Format
+    def request_format ( self, unit, option, interleave, databyte):
+        gpib.write \
+            ( self.con_0C
+            ,   b'\x18'
+              + unit    .to_bytes( 1, 'big')
+              + option  .to_bytes( 1, 'big')
+              + interleave.to_bytes( 1, 'big')
+              + databyte.to_bytes( 1, 'big')
+            )
+
+        # Formatting needs around 18 sec on my 9121D and around 90 sec on my 9123D.
+        # (The manual states that the 9123D is doing verification as well)
+        time.sleep( 18)
+
+        # DSJ (QSTAT) will timeout regardless of the timeout settings.
+        # Added my own ibrpp call to python.
+        # TODO: Check if I made a mistake with timout or wait.
+
+
+        # Execution
+        # Reporting
+        while True:
+            # ppres = gpib.parallel_poll( 0) # board
+            ppres = gpib.parallel_poll( self.con_0C) # device
+            print( f"{ppres:08b} {ppres:02x} {self.ppmask:02x}")
+            if self.ppmask & ppres:
+                break
+            time.sleep( 1)
+
+        dsj = self.dsj( )
+
+        if b'\x00' != dsj:
+            print( f"{dsj} REQUEST FORMAT")
+
+        return
+
+
+    # Initiate Selftest
+    def initiate_selftest ( self):
+        gpib.write \
+            ( self.con_1F
+            ,   b'\x00' # Ignored by the 9121D/S
+                b'\x00' # 0000W000, 0 = no format test, 1 = format test
+            #     b'\x08' # 0000W000, 0 = no format test, 1 = format test
+            )
+
+        time.sleep( 8)
+
+        # Execution
+        # Reporting
+        while True:
+            # ppres = gpib.parallel_poll( 0) # board
+            ppres = gpib.parallel_poll( self.con_1F) # device
+            print( f"{ppres:08b} {ppres:02x} {self.ppmask:02x}")
+            if self.ppmask & ppres:
+                break
+            time.sleep( 1)
+
+
+
+
+        dsj = self.dsj( )
+
+        if b'\x00' != dsj:
+            print( f"{dsj} INITIATE SELFTEST")
+
+        return

lif80utils/amigofile.py

@@ -0,0 +1,160 @@
+#
+# This file is part of the lif80utils distribution (https://codeberg.org/Boeingflieger/lif80utils).
+# Copyright (c) 2026 Christian Grosz.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, version 3.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+from .amigo import Amigo
+import os
+
+class AmigoFile:
+    """This class is an [informal] interface providing needed "file" functions."""
+
+    # Actually this information should come from the volume header.
+    # But all is set to 0 there.
+    # tracks_per_surface
+    # surfaces
+    # sectors_per_track
+    SECTOR_SIZE = 256
+
+    def __init__ ( self, board, pad, unit, verbose = False):
+        self.verbose = verbose
+
+        self.amigo = Amigo( board, pad)
+        self.unit = unit
+
+        self.protocol = self.amigo
+
+        dsj = self.amigo.dsj( )
+
+        # if b'\x00' != dsj:
+        if self.verbose:
+            print( f"{dsj} HOLDOFF STATE")
+
+        # Request status
+        res = self.amigo.request_status( unit)
+
+        if self.verbose:
+            print( f"{res[0]:08b} {res[1]:08b} {res[2]:08b} {res[3]:08b}")
+
+        tttt = (res[2] & 0x1E) >> 1
+        r    = (res[2] & 0x01) >> 0
+        w    = (res[3] & 0x40) >> 6
+        ss   = (res[3] & 0x03) >> 0
+
+        if self.verbose:
+            print( f" TTTT {tttt:04b}")
+            print( f"    R {r}")
+            print( f"    W {w}")
+            print( f"   SS {ss:02b}")
+
+        if 0 != ss:
+            print( "Error 130 : DISC")
+            exit( -1)
+
+        # TTTT 0110
+        self.cylinders = 33
+        self.heads = 2
+        self.sectors = 16
+
+        # self.offset = self.SECTOR_SIZE
+        # self.buf = None
+        self.seek( 0)
+
+    def seek ( self, offset, whence = os.SEEK_SET):
+        # We only support SEEK_SET for now.
+
+        # Only allow sector aligned seek.
+        if 0 != offset % self.SECTOR_SIZE:
+            exit( -1)
+
+        # Invalidate buffer.
+        self.offset = self.SECTOR_SIZE
+        self.buf = None
+
+        # capacity = cylinders * heads * sectors * SECTOR_SIZE
+        # 270336   = 33        * 2     * 16      * 256
+
+        sector = offset // self.SECTOR_SIZE
+
+        cylinder = sector // self.sectors
+        cylinder = cylinder // self.heads
+
+        head = (sector % (self.sectors * self.heads)) // self.sectors
+        sector = sector % self.sectors
+
+        self.amigo.seek( self.unit, cylinder, head, sector)
+
+        return offset
+
+
+    def tell ( self):
+        offset = 0
+
+        log = self.amigo.request_logical( )
+
+        cylinder = int.from_bytes( log[0:2], byteorder='big')
+        head = log[2]
+        sector = log[3]
+
+        offset += cylinder * self.sectors * self.heads
+        offset +=            self.sectors * head
+        offset +=            sector
+
+        offset *= self.SECTOR_SIZE
+
+        if self.verbose:
+            print( f"LOG C {cylinder:02} H {head} S {sector:02} {offset:06x}")
+
+        return offset
+
+
+    def read ( self, size = 256):
+        res = b''
+
+        while size:
+            # Remaining bytes in buffer.
+            avail = self.SECTOR_SIZE - self.offset
+
+            # If there are none, read the next sector.
+            if 0 == avail:
+                dsj = self.amigo.buffered_read( self.unit)
+
+                if b'\x00' == dsj:
+                    self.buf = self.amigo.receive( self.SECTOR_SIZE)
+                    self.offset = 0
+                    avail = self.SECTOR_SIZE # - self.offset
+                else:
+                    return res
+
+            n = size if avail > size else avail
+
+            res = res + self.buf[self.offset:self.offset+n]
+            size -= n
+            self.offset += n
+
+        return res
+
+    def write ( self, buf):
+        size = len( buf)
+
+        for n in range( 0, size, self.SECTOR_SIZE):
+            dsj = self.amigo.buffered_write( self.unit)
+
+            if b'\x00' == dsj:
+                dsj = self.amigo.send( buf[n:n + self.SECTOR_SIZE])
+            else:
+                return  None
+
+        return size

lif80utils/decode_0001.py

@@ -0,0 +1,144 @@
+#
+# This file is part of the lif80utils distribution (https://codeberg.org/Boeingflieger/lif80utils).
+# Copyright (c) 2026 Christian Grosz.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, version 3.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+import sys
+
+def decode_0001 ( infile, codepage = 'focal', linenumber = True):
+    # Always ascii. Overwrite for now.
+    # codepage = 'ascii'
+    # codepage = 'cp1252'
+    # codepage = 'utf-8'
+    # codepage = 'focal'
+
+# MAIN.. .................
+# 4D 41 49 4E 00 00 20 1B 06 00 00 00 00 00 00 00 00 00 00 00 00 80 00 00
+
+# HP 85 Assembler ROM source code internal format
+# https://groups.io/g/hpseries80/wiki/20863
+# MAIN NUL NUL    Program name
+    program_name = infile.read( 6)
+# 20              Program type (MAIN, BASIC, ALLOCATED)
+    program_type = int.from_bytes( infile.read( 1), byteorder='little')
+# 1B 06       Program length (061B = 1563 bytes total)
+    program_length = int.from_bytes( infile.read( 2), byteorder='little')
+# 00...       12 decimal bytes of NUL (unused)
+    infile.read( 12)
+# 80          Security bits
+    security_bits = int.from_bytes( infile.read( 1), byteorder='little')
+# 00 00       No security code
+    security_code = infile.read( 2)
+
+    # print( f"{program_name} {program_type:x} {program_length} {security_bits:x} {security_code}")
+
+    program_length = program_length - 24
+    length = 24
+
+    while True:
+# 01 00 | 1E | FE | 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A 2A | 0E
+# 01 00       BCD line# = 0001 = 1
+        line_number = int( infile.read( 2)[::-1].hex( ))
+# 1E          len of this line of 'code'
+        line_length = int.from_bytes( infile.read( 1), byteorder='little')
+
+        line = infile.read( line_length)
+        # print( f"{line_number} {line_length:x} {line}")
+
+        # program_length = program_length - line_length - 3
+        program_length -= line_length + 3
+        length += line_length + 3
+
+# FE          Assembler ROM's COMMENT 'token'
+# 2A 2A...    ASCII comment (line of *'s) term'd by 0E
+# 0E          octal 16, END-OF-LINE token
+
+# 20 00 | 0C | 47 4C 4F | FF | 47 4C 4F 42 41 4C 20 | 0E
+# FF          Assembler ROM's LABEL 'token'
+# ..GLOÿGLOBAL.
+
+        label = ""
+        comment = ""
+        opcode = ""
+        arguments = ""
+
+        if 0xFF == line[0]:
+            label = line[1:7].decode( codepage)
+            line = line[7:]
+
+        comment_pos = line.find( b'\xFE')
+
+        if 0 <= comment_pos:
+            comment = f"!{line[comment_pos+1:-1].decode( codepage)}"
+            line = line[:comment_pos] + line[-1:]
+
+        if 0 == comment_pos:
+            if linenumber:
+                yield f"{line_number} {comment}\n"
+            else:
+                yield f"{comment}\n"
+
+            continue
+
+        # print( f" {label} {line} {comment}")
+
+        if 0x0E != line[0]:
+            opcode = line[0:3].decode( codepage)
+            line = line[3:]
+
+        if 0xFF == line[0]:
+            arguments = line[1:7].decode( codepage)
+            line = line[7:]
+        elif b'=\xFF' == line[0:2]:
+            arguments = (line[0:1] + line[2:-1]).decode( codepage)
+            line = line[-1:]
+        else:
+            arguments = line[:-1].decode( codepage)
+            line = line[-1:]
+
+        if linenumber:
+            yield f"{line_number} {label:6s} {opcode:3s} {arguments:15s} {comment}\n"
+        else:
+            yield f"{label:6s} {opcode:3s} {arguments:15s} {comment}\n"
+
+# Another 5 bytes in the file.
+# 99 A9 02 19 0E
+# Constant, same also for all PGM files.
+# Rest of block filled with garbage.
+
+# https://groups.io/g/hpseries80/wiki/1893
+# HP 85 System ROMs [Memory Layout (and Tokens and Allocation and...)]
+# 231 251 002 031 016             (A999 len=2 STOP EOL)
+
+# HP LIF/assets/attachments/parse_hp85.c.txt
+# case 0031:
+#     printf("<\\031 END>\n");
+#     break;
+
+# This is simple the tokenized END statement from Basic.
+# Probably it is also used by the editor to detect the end of the program.
+
+# https://archived.hpcalc.org/greendyk/hp85/83.html
+# The END statement should be the highest numbered statement in a program. It
+# not only tells the computer where a program ends, but also terminates program
+# execution. (You may also use the STOP statement; on the HP-85 both END and
+# STOP perform exactly the same function. END is provided on the HP-85 for
+# compatibility with other BASIC systems.)
+
+        # print( f"{program_length} {length}")
+
+        if 5 == program_length:
+            break
+

lif80utils/decode_E010.py

@@ -0,0 +1,127 @@
+#
+# This file is part of the lif80utils distribution (https://codeberg.org/Boeingflieger/lif80utils).
+# Copyright (c) 2026 Christian Grosz.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, version 3.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+# My notes on decoding E010 format LIF images for HP-85
+# https://github.com/magore/hp85disk/blob/master/lif/lif-notes.txt
+#
+# ef [ff]* = end of data in this sector (no size) , pad with ff's optionally if there is room
+# df size = string
+# cf size = split accross sector end "6f size" at start of next sector
+#        but the 6f size bytes are not included in cf size! (yuck!)
+# 6f size = split continue (always starts at sector boundry)
+# df 00 00 ef [ff]* = EOF (df size = 0) ef send of sector and optional padding
+#
+# cf 29 00 (19 is to sector end) (new sector start with 6F 10 00 (10 is remainder)
+# So 29 = 19 and 10 (yuck!)
+
+import sys
+import re
+
+#
+#
+#
+
+SECTOR_SIZE = 256
+
+
+def decode_E010 ( infile, codepage = 'focal', linenumber = True):
+
+    n = SECTOR_SIZE
+
+    while True:
+        b = infile.read( 1)
+        n -= 1
+
+        # if not b:
+        #     print( "End of file")
+        #     break
+
+        if b == b'\xdf': # Start of line.
+            l = infile.read( 2)
+            n -= 2
+
+            # Length of line including CR.
+            len = int.from_bytes( l, "little")
+            # print( f'DF {l} {len}')
+
+            if 0 == len:
+                # print( "End of program")
+                break
+
+            s = infile.read( len)
+            n -= len
+            # print( s.translate(trantab).decode( codepage), end = '')
+            if linenumber:
+                yield s.decode( codepage, 'combined')
+            else:
+                yield re.sub( r'^\d+ ', '', s.decode( codepage, 'combined'))
+
+            # yield s[:-1].decode( codepage, 'combined')
+
+            if 0 == n:
+                n = SECTOR_SIZE
+
+        elif b == b'\xcf': # Split accross sector end.
+            l = infile.read( 2)
+            n -= 2
+
+            # Length of line including CR.
+            len = int.from_bytes( l, "little")
+            # print( f'CF {l} {len}')
+
+            if len > n:
+                len = n
+
+            s = infile.read( len)
+            n -= len
+            # print( s.translate(trantab).decode( codepage), end = '')
+            # yield s.decode( codepage, 'combined')
+            n = SECTOR_SIZE
+
+        elif b == b'\x6f': # Split continue.
+            l = infile.read( 2)
+            n -= 2
+
+            # Length of line including CR.
+            len = int.from_bytes( l, "little")
+            # print( f'6F {l} {len}')
+
+            # s = infile.read( len)
+            s += infile.read( len)
+            n -= len
+
+            if linenumber:
+                yield s.decode( codepage, 'combined')
+            else:
+                yield re.sub( r'^\d+ ', '', s.decode( codepage, 'combined'))
+
+        elif b == b'\xef': # Pad sector.
+            while True:
+                b = infile.read( 1)
+
+                # TODO: Is that smart? Actually I know the size of the sector.
+                if b != b'\xff':
+                    # print( f'EF {n}')
+                    infile.seek(-1, 1) # goes back by one relative to current position
+                    n = SECTOR_SIZE
+                    break
+
+                n -= 1
+        else:
+            print( "Unexpected")
+            break
+