firestarter 1.3.2__tar.gz → 1.3.4__tar.gz

{firestarter-1.3.2 → firestarter-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: firestarter
-Version: 1.3.2
+Version: 1.3.4
 Summary: EPROM burner software for the Relatively Universal ROM Programmer
 Author-email: Henrik Olsson <henols@gmail.com>
 Description-Content-Type: text/markdown

firestarter-1.3.4/firestarter/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.3.4"

{firestarter-1.3.2 → firestarter-1.3.4}/firestarter/eprom_operations.py

@@ -11,13 +11,13 @@ import os
 import time
 
 try:
-    from .serial_comm import find_programmer, wait_for_response
-    from .database import get_eprom
-    from .utils import extract_hex_to_decimal, print_progress, print_progress_bar
+    from .serial_comm import find_programmer, wait_for_response, consume_response
+    from .database import get_eprom, search_chip_id
+    from .utils import extract_hex_to_decimal, print_progress_bar
 except ImportError:
-    from serial_comm import find_programmer, wait_for_response
-    from database import get_eprom
-    from utils import extract_hex_to_decimal, print_progress, print_progress_bar
+    from serial_comm import find_programmer, wait_for_response, consume_response
+    from database import get_eprom, search_chip_id
+    from utils import extract_hex_to_decimal, print_progress_bar
 
 # Constants
 BUFFER_SIZE = 512
@@ -48,7 +48,7 @@ def read(eprom_name, output_file=None, force=False):
         eprom["force"] = True
 
     if not output_file:
-        output_file = f"{eprom_name}.bin"
+        output_file = f"{eprom_name.upper()}.bin"
     print(f"Reading EPROM {eprom_name}, saving to {output_file}")
 
     ser = find_programmer(eprom)
@@ -62,6 +62,8 @@ def read(eprom_name, output_file=None, force=False):
             bytes_read = 0
             mem_size = eprom["memory-size"]
             total_iterations = mem_size / BUFFER_SIZE
+            print_progress_bar(0, total_iterations, prefix=f"Address: 0x0000 -       ")
+
             while True:
                 resp, info = wait_for_response(ser)
                 if resp == "DATA":
@@ -75,26 +77,29 @@ def read(eprom_name, output_file=None, force=False):
                     print_progress_bar(
                         bytes_read / BUFFER_SIZE,
                         total_iterations,
-                        prefix=f"Address: 0x{from_address:X} - 0x{to_address:X}",
+                        prefix=f"Address: 0x{from_address:04X} - 0x{to_address:04X}",
                         suffix=f"- {time.time() - start_time:.2f}s",
                     )
+
                     ser.write("OK".encode("ascii"))
                     ser.flush()
                 elif resp == "OK":
                     break
                 elif resp == "ERROR":
-                    print(f"\nError: {info}")
-                    return 1
-                else:
-                    print(f"\nUnexpected response: {info}")
+                    # print(f"\nError: {info}")
                     return 1
+                # else:
+                #     print(f"\nUnexpected response: {info}")
+                #     return 1
 
             print(f"\nRead complete in: {time.time() - start_time:.2f} seconds")
             print(f"Data saved to {output_file}")
     except Exception as e:
         print(f"Error while reading: {e}")
     finally:
+        consume_response(ser)
         ser.close()
+    return 0
 
 
 def write(eprom_name, input_file, address=None, ignore_blank_check=False, force=False):
@@ -142,50 +147,49 @@ def write(eprom_name, input_file, address=None, ignore_blank_check=False, force=
             bytes_written = 0
 
             print(f"Writing {input_file} to {eprom_name}")
+            print_progress_bar(0, total_iterations, prefix=f"Address: 0x0000 -       ")
 
             while True:
                 data = file.read(BUFFER_SIZE)
                 if not data:
+                    print("\nEnd of file reached")
                     ser.write(int(0).to_bytes(2, byteorder="big"))
                     ser.flush()
                     resp, info = wait_for_response(ser)
-                    print("\nEnd of file reached")
-                    print(info)
+                    while resp != "OK":
+                        if resp == "ERROR":
+                            return 1
+                        resp, info = wait_for_response(ser)
                     break
 
                 ser.write(len(data).to_bytes(2, byteorder="big"))
                 ser.flush()
                 resp, info = wait_for_response(ser)
-                if resp == "ERROR":
-                    print(f"\nError writing: {info}")
-                    return 1
+                while resp != "OK":
+                    if resp == "ERROR":
+                        return 1
+                    resp, info = wait_for_response(ser)
+
                 nr_bytes = ser.write(data)
                 bytes_written += nr_bytes
                 ser.flush()
-
-                while True:
-                    resp, info = wait_for_response(ser)
-                    if resp == "OK":
-                        # percent = int(bytes_written / file_size * 100)
-                        # print_progress(
-                        #     percent,
-                        #     bytes_written - nr_bytes + write_address,
-                        #     bytes_written + write_address,
-                        # )
-                        from_address = bytes_written - nr_bytes + write_address
-                        to_address = bytes_written + write_address
-                        print_progress_bar(
-                            bytes_written / BUFFER_SIZE,
-                            total_iterations,
-                            prefix=f"Address: 0x{from_address:X} - 0x{to_address:X}",
-                            suffix=f"- {time.time() - start_time:.2f}s",
-                        )
-                        break
-                    elif resp == "ERROR":
-                        print(f"\nError: {info}")
+                # print(f"Bytes written: {bytes_written}")
+                resp, info = wait_for_response(ser)
+                while resp != "OK":
+                    if resp == "ERROR":
                         return 1
-                    else:
+                    elif resp == "WARN":
                         print(f"Warning: {info}")
+                    resp, info = wait_for_response(ser)
+
+                from_address = bytes_written - nr_bytes + write_address
+                to_address = bytes_written + write_address
+                print_progress_bar(
+                    bytes_written / BUFFER_SIZE,
+                    total_iterations,
+                    prefix=f"Address: 0x{from_address:04X} - 0x{to_address:04X}",
+                    suffix=f"- {time.time() - start_time:.2f}s",
+                )
                 if bytes_written == mem_size:
                     break
 
@@ -194,6 +198,7 @@ def write(eprom_name, input_file, address=None, ignore_blank_check=False, force=
         print(f"Error while writing: {e}")
         return 1
     finally:
+        consume_response(ser)
         ser.close()
     return 0
 
@@ -211,15 +216,21 @@ def erase(eprom_name):
         return 1
 
     eprom["state"] = STATE_ERASE
-    ser = find_programmer(eprom)
-    if not ser:
-        return 1
-
-    resp, info = wait_for_response(ser)
-    if resp == "OK":
-        print(f"EPROM {eprom_name} erased successfully.")
-    elif resp == "ERROR":
-        print(f"Error erasing EPROM {eprom_name}: {info}")
+    try:
+        ser = find_programmer(eprom)
+        if not ser:
+            return 1
+
+        resp, info = wait_for_response(ser)
+        if resp == "OK":
+            print(f"EPROM {eprom_name} erased successfully.")
+            return 0
+        elif resp == "ERROR":
+            print(f"Error erasing EPROM {eprom_name}")
+            return 1
+    finally:
+        consume_response(ser)
+        ser.close()
 
 
 def check_chip_id(eprom_name):
@@ -238,16 +249,26 @@ def check_chip_id(eprom_name):
     ser = find_programmer(eprom)
     if not ser:
         return 1
-
-    resp, info = wait_for_response(ser)
-    if resp == "OK":
-        print(f"Chip ID check passed for {eprom_name}: {info}")
-    elif resp == "ERROR":
-        print(f"Chip ID check failed for {eprom_name}: {info}")
+    try:
+        resp, info = wait_for_response(ser)
+        if resp == "OK":
+            print(f"Chip ID check passed for {eprom_name}: {info}")
+            return 0
         chip_id = extract_hex_to_decimal(info)
-        print(
-            f"Extracted chip ID: {chip_id}" if chip_id else "Failed to extract chip ID."
-        )
+        if not chip_id:
+            print(f"Failed to extract chip ID.")
+        else:
+            eproms = search_chip_id(chip_id)
+            if not eproms:
+                print(f"Chip ID 0x{chip_id:x} not found in the database.")
+            else:
+                print(f"Chip ID 0x{chip_id:x} found in the database:")
+            for eprom in eproms:
+                print(eprom)
+        return 1
+    finally:
+        consume_response(ser)
+        ser.close()
 
 
 def blank_check(eprom_name):
@@ -263,12 +284,16 @@ def blank_check(eprom_name):
         return 1
 
     eprom["state"] = STATE_CHECK_BLANK
-    ser = find_programmer(eprom)
-    if not ser:
-        return 1
-
-    resp, info = wait_for_response(ser)
-    if resp == "OK":
-        print(f"EPROM {eprom_name} is blank.")
-    elif resp == "ERROR":
-        print(f"Blank check failed for {eprom_name}: {info}")
+    try:
+        ser = find_programmer(eprom)
+        if not ser:
+            return 1
+
+        resp, info = wait_for_response(ser)
+        if resp == "OK":
+            print(f"EPROM {eprom_name} is blank.")
+        elif resp == "ERROR":
+            print(f"Blank check failed for {eprom_name}")
+    finally:
+        consume_response(ser)
+        ser.close()

{firestarter-1.3.2 → firestarter-1.3.4}/firestarter/firmware.py

@@ -11,12 +11,12 @@ import os
 import requests
 
 try:
-    from .serial_comm import find_programmer, wait_for_response, find_comports
+    from .serial_comm import find_programmer, wait_for_response, find_comports, consume_response
     from .config import get_config_value, set_config_value
     from .avr_tool import Avrdude
     from .utils import verbose
 except ImportError:
-    from serial_comm import find_programmer, wait_for_response, find_comports
+    from serial_comm import find_programmer, wait_for_response, find_comports, consume_response
     from config import get_config_value, set_config_value
     from avr_tool import Avrdude
     from utils import verbose
@@ -78,7 +78,6 @@ def firmware_check(port=None):
         return False, None, None
 
     try:
-        ser.write("OK".encode("ascii"))
         resp, version = wait_for_response(ser)
 
         if not resp == "OK":
@@ -103,6 +102,7 @@ def firmware_check(port=None):
         )
         return False, ser.portstr, url
     finally:
+        consume_response(ser)
         ser.close()
 
 

{firestarter-1.3.2 → firestarter-1.3.4}/firestarter/hardware.py

@@ -1,8 +1,9 @@
 import time
+
 try:
-    from .serial_comm import find_programmer, wait_for_response
+    from .serial_comm import find_programmer, wait_for_response, consume_response
 except ImportError:
-    from serial_comm import find_programmer, wait_for_response
+    from serial_comm import find_programmer, wait_for_response, consume_response
 
 STATE_READ_VPP = 11
 STATE_READ_VPE = 12
@@ -32,6 +33,7 @@ def hardware():
             print(f"Failed to read hardware revision. {resp}: {version}")
             return 1
     finally:
+        consume_response(ser)
         ser.close()
     return 0
 
@@ -53,15 +55,20 @@ def config(rev=None, r1=None, r2=None):
     ser = find_programmer(data)
     if not ser:
         return 1
-    ser.write("OK".encode("ascii"))
-    r, version = wait_for_response(ser)
-    if r == "OK":
-        print(f"Config: {version}")
-    else:
-        print(r)
-        return 1
+    try:
+        # ser.write("OK".encode("ascii"))
+        r, version = wait_for_response(ser)
+        if r == "OK":
+            print(f"Config: {version}")
+        else:
+            # print(r)
+            return 1
+    finally:
+        consume_response(ser)
+        ser.close()
     return 0
 
+
 def read_vpp(timeout=None):
     """
     Reads the VPP voltage from the programmer.
@@ -94,6 +101,7 @@ def read_voltage(state, timeout=None):
             print(f"Error reading {type} voltage: {info}")
             return 1
         ser.write("OK".encode("ascii"))
+        ser.flush()
 
         if timeout:
             start = time.time()
@@ -104,5 +112,10 @@ def read_voltage(state, timeout=None):
                 print()
                 return 0
             ser.write("OK".encode("ascii"))
+            ser.flush()
+    except Exception as e:
+        print(f"Error while reading {type} voltage: {e}")
     finally:
+        consume_response(ser)
         ser.close()
+    return 1

{firestarter-1.3.2 → firestarter-1.3.4}/firestarter/main.py

@@ -35,6 +35,8 @@ except ImportError:
 
 
 def main():
+    signal.signal(signal.SIGINT, exit_gracefully)
+
     parser = argparse.ArgumentParser(
         description="EPROM programmer for Arduino UNO and Relatively-Universal-ROM-Programmer shield."
     )
@@ -174,6 +176,7 @@ def main():
     init_db()
     open_config()
     set_verbose(args.verbose)
+
     # Command dispatch
     if args.command == "list":
         return list_eproms(args.verified)
@@ -211,9 +214,10 @@ def main():
 
 
 def exit_gracefully(signum, frame):
+    print("\n")
+    print("Prosess interrupted.")
     sys.exit(1)
 
 
 if __name__ == "__main__":
-    signal.signal(signal.SIGINT, exit_gracefully)
-    sys.exit(main())
+    sys.exit(main())

{firestarter-1.3.2 → firestarter-1.3.4}/firestarter/serial_comm.py

@@ -54,10 +54,8 @@ def check_port(port, data, baud_rate=BAUD_RATE):
         res, msg = wait_for_response(ser)
         while res != "OK":
             if res == "ERROR":
-                raise Exception(msg)
-            if res == "TIMEOUT_ERROR":
                 return None
-            print(f"{res} - {msg}")
+            res, msg = wait_for_response(ser)
 
         if verbose():
             print(f"Programmer: {msg}")
@@ -143,6 +141,54 @@ def find_programmer(data, port=None):
     return None
 
 
+def read_response(ser):
+    while ser.in_waiting > 0:
+        byte_array = ser.readline()
+        res = read_filtered_bytes(byte_array)
+        type = None
+        msg = None
+        try:
+            if res:
+                if "OK:" in res:
+                    msg = res.split("OK:")[-1].strip()
+                    type = "OK"
+                    return
+                elif "INFO:" in res:
+                    msg = res.split("INFO:")[-1].strip()
+                    type = "INFO"
+                    return
+                elif "DEBUG:" in res:
+                    msg = res.split("DEBUG:")[-1].strip()
+                    type = "DEBUG"
+                    return
+                elif "ERROR:" in res:
+                    msg = res.split("ERROR:")[-1].strip()
+                    type = "ERROR"
+                    return
+                elif "WARN:" in res:
+                    msg = res.split("WARN:")[-1].strip()
+                    type = "WARN"
+                    return
+                elif "DATA:" in res:
+                    msg = res.split("DATA:")[-1].strip()
+                    type = "DATA"
+                    return
+                else:
+                    return
+        finally:
+            write_feedback(type, msg)
+            # if type == "ERROR":
+            #     raise Exception(msg)
+            return type, msg
+    return None, None
+
+
+def consume_response(ser):
+    time.sleep(0.1)
+    while read_response(ser)[0] != None:
+        time.sleep(0.3)
+
+
 def wait_for_response(ser):
     """
     Waits for a response from the serial connection.
@@ -155,41 +201,13 @@ def wait_for_response(ser):
     """
     timeout = time.time() + 2  # Set timeout period
     while time.time() < timeout:
-        if ser.in_waiting > 0:
-            byte_array = ser.readline()
-            res = read_filtered_bytes(byte_array)
-            msg = None
-            type = None
-            try:
-                if res:
-                    if "OK:" in res:
-                        msg = res.split("OK:")[-1].strip()
-                        type = "OK"
-                        return
-                    elif "INFO:" in res:
-                        msg = res.split("INFO:")[-1].strip()
-                        write_feedback("INFO", msg)
-                        # return "INFO", msg
-                    elif "ERROR:" in res:
-                        msg = res.split("ERROR:")[-1].strip()
-                        type = "ERROR"
-                        return
-                    elif "WARN:" in res:
-                        msg = res.split("WARN:")[-1].strip()
-                        type = "WARN"
-                        return
-                    elif "DATA:" in res:
-                        msg = res.split("DATA:")[-1].strip()
-                        type = "DATA"
-                        return
-                    timeout = time.time() + 2  # Reset timeout
-            finally:
-                write_feedback(type, msg)
-                if type:
-                    return type, msg
+        type, msg = read_response(ser)
+        if type and type != "INFO" and type != "DEBUG":
+            return type, msg
+        # time.sleep(0.1)
     msg = f"Timeout, no response on {ser.portstr}"
-    write_feedback("ERROR", msg)
-    return "TIMEOUT_ERROR", msg
+    write_feedback("Error", msg)
+    raise Exception(msg)
 
 
 def write_feedback(type, msg):
@@ -199,7 +217,7 @@ def write_feedback(type, msg):
     Args:
         msg (str): The feedback message.
     """
-    if msg and (verbose() or type == "ERROR" or type == "WARN"):
+    if msg and (verbose() or (type.upper() == "ERROR" or type == "WARN")):
         print(f"{type}: {msg}")
 
 

{firestarter-1.3.2 → firestarter-1.3.4}/firestarter.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: firestarter
-Version: 1.3.2
+Version: 1.3.4
 Summary: EPROM burner software for the Relatively Universal ROM Programmer
 Author-email: Henrik Olsson <henols@gmail.com>
 Description-Content-Type: text/markdown

{firestarter-1.3.2 → firestarter-1.3.4}/firestarter_test.sh

@@ -46,36 +46,15 @@ dd if=/dev/urandom of="$TEMP_DIR/high_data.bin" bs=1 count=$HALF_SIZE status=non
 # Concatenate the two files into one file
 cat "$TEMP_DIR/low_data.bin" "$TEMP_DIR/high_data.bin" > "$TEMP_DIR/full_data.bin"
 
-# ------------------------------ EPROM INFO TESTS -------------------------
-echo "---------------------------------"
-echo "Listing all EPROMs"
-echo "---------------------------------"
-firestarter list
-if test $? -gt 0
-then
-	echo "Search failed"
-    exit 1
-fi
-echo
-sleep 0.5
-echo "---------------------------------"
-echo "Searching for $EPROM_NAME"
-echo "---------------------------------"
-firestarter search $EPROM_NAME
-if test $? -gt 0
-then
-	echo "Search failed"
-    exit 1
-fi
-echo
-sleep 0.5
+# ------------------------------ FIRMWARE TESTS ------------------------------
+
 echo "---------------------------------"
-echo "Info for $EPROM_NAME"
+echo "Firmware Version"
 echo "---------------------------------"
-firestarter info $EPROM_NAME
+firestarter fw
 if test $? -gt 0
 then
-	echo "Info failed"
+	echo "Firmware version failed"
     exit 1
 fi
 echo
@@ -104,7 +83,7 @@ then
     exit 1
 fi
 echo
-sleep 0.5
+sleep 1
 echo "---------------------------------"
 echo "VPP"
 echo "---------------------------------"
@@ -115,7 +94,7 @@ then
     exit 1
 fi
 echo
-sleep 0.5
+sleep 1
 echo "---------------------------------"
 echo "VPE"
 echo "---------------------------------"
@@ -126,21 +105,7 @@ then
     exit 1
 fi
 echo
-sleep 0.5
-
-# ------------------------------ FIRMWARE TESTS ------------------------------
-
-echo "---------------------------------"
-echo "Firmware Version"
-echo "---------------------------------"
-firestarter fw
-if test $? -gt 0
-then
-	echo "Firmware version failed"
-    exit 1
-fi
-echo
-sleep 0.5
+sleep 1
 
 # ------------------------------ EPROM TESTS ------------------------------
 
@@ -206,4 +171,37 @@ then
     exit 1
 fi
 echo
+# ------------------------------ EPROM INFO TESTS -------------------------
+echo "---------------------------------"
+echo "Listing all EPROMs"
+echo "---------------------------------"
+firestarter list
+if test $? -gt 0
+then
+	echo "Search failed"
+    exit 1
+fi
+echo
+sleep 0.5
+echo "---------------------------------"
+echo "Searching for $EPROM_NAME"
+echo "---------------------------------"
+firestarter search $EPROM_NAME
+if test $? -gt 0
+then
+	echo "Search failed"
+    exit 1
+fi
+echo
+sleep 0.5
+echo "---------------------------------"
+echo "Info for $EPROM_NAME"
+echo "---------------------------------"
+firestarter info $EPROM_NAME
+if test $? -gt 0
+then
+	echo "Info failed"
+    exit 1
+fi
+echo
 echo "All tests passed"

{firestarter-1.3.2 → firestarter-1.3.4}/write_test.sh

@@ -15,7 +15,7 @@ fi
 rm -f "$TEMP_DIR"/*
 
 # Trap to clean up the temporary files on exit or interrupt
-trap "rm -rf $TEMP_DIR; echo 'Cleaned up temp files'; exit" EXIT
+# trap "rm -rf $TEMP_DIR; echo 'Cleaned up temp files'; exit" EXIT
 
 # Convert TARGET_NAME to uppercase
 EPROM_NAME=$(echo "$EPROM_NAME" | tr '[:lower:]' '[:upper:]')

firestarter-1.3.2/firestarter/__init__.py

@@ -1 +0,0 @@
-__version__ = "1.3.2"