From fa6b7573c742f22eaa77d778ff911c0a42df6a05 Mon Sep 17 00:00:00 2001 From: Miguel Date: Sun, 21 Apr 2024 10:22:36 +0200 Subject: [PATCH] new file: CopyPaste.py new file: DB SIPA Supervision.db new file: DB_SIPA_Supervision_Excel.xlsx new file: DB_Structure.csv new file: DB_Structure.xlsx new file: DB_Structure.xml new file: DB_to_Excel.py new file: ExpandDB.py new file: ExportData.py new file: __pycache__/ExpandDB.cpython-310.pyc new file: __pycache__/ExportData.cpython-310.pyc new file: db_definitions.json new file: udt_definitions.json --- CopyPaste.py | 28 + DB SIPA Supervision.db | 250 +++++++ DB_SIPA_Supervision_Excel.xlsx | Bin 0 -> 9180 bytes DB_Structure.csv | 176 +++++ DB_Structure.xlsx | Bin 0 -> 10125 bytes DB_Structure.xml | 924 +++++++++++++++++++++++++ DB_to_Excel.py | 172 +++++ ExpandDB.py | 125 ++++ ExportData.py | 74 ++ __pycache__/ExpandDB.cpython-310.pyc | Bin 0 -> 2846 bytes __pycache__/ExportData.cpython-310.pyc | Bin 0 -> 2244 bytes db_definitions.json | 30 + udt_definitions.json | 194 ++++++ 13 files changed, 1973 insertions(+) create mode 100644 CopyPaste.py create mode 100644 DB SIPA Supervision.db create mode 100644 DB_SIPA_Supervision_Excel.xlsx create mode 100644 DB_Structure.csv create mode 100644 DB_Structure.xlsx create mode 100644 DB_Structure.xml create mode 100644 DB_to_Excel.py create mode 100644 ExpandDB.py create mode 100644 ExportData.py create mode 100644 __pycache__/ExpandDB.cpython-310.pyc create mode 100644 __pycache__/ExportData.cpython-310.pyc create mode 100644 db_definitions.json create mode 100644 udt_definitions.json diff --git a/CopyPaste.py b/CopyPaste.py new file mode 100644 index 0000000..9265593 --- /dev/null +++ b/CopyPaste.py @@ -0,0 +1,28 @@ +def calculate_offsets(db_struct, current_offset=0): + """ + Recursively calculate byte offsets for each field in the DB structure, + applying general alignment rules except inside arrays. + """ + if isinstance(db_struct, dict): + for key, value in db_struct.items(): + if isinstance(value, dict) and 'type' in value: + is_array_element = value.get('is_array_element', False) + type_name = value['type'] + size = type_sizes.get(type_name, 1) + + if 'String' in type_name: + match = re.match(r'String\[(\d+)\]', type_name) + if match: + size = int(match.group(1)) + 2 # String length + 2 for the null terminator and length prefix + + if not is_array_element and current_offset % 2 != 0: + current_offset += 1 # Align to the next even offset if it's not an array element + + value['offset'] = current_offset + current_offset += size + + # Recursively handle nested structures + if isinstance(value, dict): + current_offset = calculate_offsets(value, current_offset) + + return current_offset diff --git a/DB SIPA Supervision.db b/DB SIPA Supervision.db new file mode 100644 index 0000000..9c8a32b --- /dev/null +++ b/DB SIPA Supervision.db @@ -0,0 +1,250 @@ +TYPE "UDT SIPA SV Main" +VERSION : 0.1 + STRUCT + N1 : DInt; // .DB_IOT.USERLEVEL + N2 : String[81]; // .DB_IOT.USERNAME + N3 : String[81]; // .DB_IOT.NOME_RICETTA + N4 : Int; // .DB_IOT.NEXT_MAINT_CYCLES + N5 : Struct // .DB_IOT.NEXT_MAINT_ITEM + V1 : String[254]; + V2 : String[254]; + V3 : String[254]; + V4 : String[254]; + V5 : String[8]; + END_STRUCT; + N6 : Array[1..3] of Real; // .DB_IOT.ELECTRIC_VOLTAGE_PHASE_D + N7 : Array[1..3] of Real; // .DB_IOT.ELECTRIC_CURRENT_PHASE_D + N8 : Real; // .DB_IOT.ELECTRIC_POWER_D + N9 : Real; // .DB_IOT.ELECTRIC_POWER_FACTOR_D + N10 : Real; // .DB_IOT.ELECTRIC_POWER_HOUR_D + N11 : Real; // .DB_IOT.ELECTRIC_POWER_WH + END_STRUCT; + +END_TYPE + +TYPE "UDT SIPA SV Section" +VERSION : 0.1 + STRUCT + N1 : DInt; // .DB_IOT.STATO_MACCHINA + N2 : DInt; // .DB_IOT.ALLARME_FERMO + N3 : DInt; // .DB_IOT.WARNING_ATTIVO (che compromette produzione) + N4 : Int; // .DB_IOT.STATO_OPERATIVO (Semaforo) + N5 : Int; // .DB_IOT.MODO_OPERATIVO (Prod,Simula,Man, ecc) + N6 : DInt; // .DB_IOT.ALARM_STOP_NO + N7 : Struct // .DB_IOT.COUNTER + V1 : DInt; // PIECES_TOT + V2 : DInt; // PIECES_OK + V3 : DInt; // PIECES_KO_1 + V4 : DInt; // PIECES_KO_2 + V5 : DInt; // PIECES_KO_3 + V6 : DInt; // PIECES_KO_4 + V7 : DInt; // PIECES_KO_5 + V8 : DInt; // PIECES_KO_6 + V9 : DInt; // PIECES_KO_7 + V10 : DInt; // PIECES_KO_8 + V11 : DInt; // PIECES_KO_9 + V12 : DInt; // PIECES_KO_10 + V13 : DInt; // T_ALARM_HOURS + V14 : DInt; // T_DRY_CYCLE_HOURS + V15 : DInt; // T_POWERED_HOURS + V16 : DInt; // T_PRODUCT_100_HOURS + V17 : DInt; // T_PRODUCT_0_HOURS + V18 : DInt; // T_STOP_HOURS + V19 : Int; // T_ALARM_MINUTES + V20 : Int; // T_DRY_CYCLE_MINUTES + V21 : Int; // T_POWERED_MINUTES + V22 : Int; // T_PRODUCT_100_MINUTES + V23 : Int; // T_PRODUCT_0_MINUTES + V24 : Int; // T_STOP_MINUTES + END_STRUCT; + END_STRUCT; + +END_TYPE + +DATA_BLOCK "DB SIPA Supervision" +{ S7_Optimized_Access := 'FALSE' } +VERSION : 0.1 +NON_RETAIN + STRUCT + MAIN : "UDT SIPA SV Main"; + SECT1 : "UDT SIPA SV Section"; + SECT2 : "UDT SIPA SV Section"; + SECT3 : "UDT SIPA SV Section"; + SECT4 : "UDT SIPA SV Section"; + SECT5 : "UDT SIPA SV Section"; + END_STRUCT; + + +BEGIN + MAIN.N1 := 9; + MAIN.N2 := 'superuser '; + MAIN.N3 := '0,4 L Petaloid Base'; + MAIN.N4 := 0; + MAIN.N5.V1 := 'testo da inserire'; + MAIN.N5.V2 := ''; + MAIN.N5.V3 := ''; + MAIN.N5.V4 := ''; + MAIN.N5.V5 := ''; + MAIN.N6[1] := 0.0; + MAIN.N6[2] := 0.0; + MAIN.N6[3] := 0.0; + MAIN.N7[1] := 0.0; + MAIN.N7[2] := 0.0; + MAIN.N7[3] := 0.0; + MAIN.N8 := 0.0; + MAIN.N9 := 0.0; + MAIN.N10 := 0.0; + MAIN.N11 := 0.0; + SECT1.N1 := 2; + SECT1.N2 := 0; + SECT1.N3 := 0; + SECT1.N4 := 3; + SECT1.N5 := 2; + SECT1.N6 := 0; + SECT1.N7.V1 := 0; + SECT1.N7.V2 := 0; + SECT1.N7.V3 := 0; + SECT1.N7.V4 := 0; + SECT1.N7.V5 := 0; + SECT1.N7.V6 := 0; + SECT1.N7.V7 := 0; + SECT1.N7.V8 := 0; + SECT1.N7.V9 := 0; + SECT1.N7.V10 := 0; + SECT1.N7.V11 := 0; + SECT1.N7.V12 := 0; + SECT1.N7.V13 := 0; + SECT1.N7.V14 := 0; + SECT1.N7.V15 := 0; + SECT1.N7.V16 := 0; + SECT1.N7.V17 := 0; + SECT1.N7.V18 := 0; + SECT1.N7.V19 := 0; + SECT1.N7.V20 := 0; + SECT1.N7.V21 := 0; + SECT1.N7.V22 := 0; + SECT1.N7.V23 := 0; + SECT1.N7.V24 := 0; + SECT2.N1 := 0; + SECT2.N2 := 0; + SECT2.N3 := 0; + SECT2.N4 := 0; + SECT2.N5 := 0; + SECT2.N6 := 0; + SECT2.N7.V1 := 0; + SECT2.N7.V2 := 0; + SECT2.N7.V3 := 0; + SECT2.N7.V4 := 0; + SECT2.N7.V5 := 0; + SECT2.N7.V6 := 0; + SECT2.N7.V7 := 0; + SECT2.N7.V8 := 0; + SECT2.N7.V9 := 0; + SECT2.N7.V10 := 0; + SECT2.N7.V11 := 0; + SECT2.N7.V12 := 0; + SECT2.N7.V13 := 0; + SECT2.N7.V14 := 0; + SECT2.N7.V15 := 0; + SECT2.N7.V16 := 0; + SECT2.N7.V17 := 0; + SECT2.N7.V18 := 0; + SECT2.N7.V19 := 0; + SECT2.N7.V20 := 0; + SECT2.N7.V21 := 0; + SECT2.N7.V22 := 0; + SECT2.N7.V23 := 0; + SECT2.N7.V24 := 0; + SECT3.N1 := 0; + SECT3.N2 := 0; + SECT3.N3 := 0; + SECT3.N4 := 0; + SECT3.N5 := 0; + SECT3.N6 := 0; + SECT3.N7.V1 := 0; + SECT3.N7.V2 := 0; + SECT3.N7.V3 := 0; + SECT3.N7.V4 := 0; + SECT3.N7.V5 := 0; + SECT3.N7.V6 := 0; + SECT3.N7.V7 := 0; + SECT3.N7.V8 := 0; + SECT3.N7.V9 := 0; + SECT3.N7.V10 := 0; + SECT3.N7.V11 := 0; + SECT3.N7.V12 := 0; + SECT3.N7.V13 := 0; + SECT3.N7.V14 := 0; + SECT3.N7.V15 := 0; + SECT3.N7.V16 := 0; + SECT3.N7.V17 := 0; + SECT3.N7.V18 := 0; + SECT3.N7.V19 := 0; + SECT3.N7.V20 := 0; + SECT3.N7.V21 := 0; + SECT3.N7.V22 := 0; + SECT3.N7.V23 := 0; + SECT3.N7.V24 := 0; + SECT4.N1 := 0; + SECT4.N2 := 0; + SECT4.N3 := 0; + SECT4.N4 := 0; + SECT4.N5 := 0; + SECT4.N6 := 0; + SECT4.N7.V1 := 0; + SECT4.N7.V2 := 0; + SECT4.N7.V3 := 0; + SECT4.N7.V4 := 0; + SECT4.N7.V5 := 0; + SECT4.N7.V6 := 0; + SECT4.N7.V7 := 0; + SECT4.N7.V8 := 0; + SECT4.N7.V9 := 0; + SECT4.N7.V10 := 0; + SECT4.N7.V11 := 0; + SECT4.N7.V12 := 0; + SECT4.N7.V13 := 0; + SECT4.N7.V14 := 0; + SECT4.N7.V15 := 0; + SECT4.N7.V16 := 0; + SECT4.N7.V17 := 0; + SECT4.N7.V18 := 0; + SECT4.N7.V19 := 0; + SECT4.N7.V20 := 0; + SECT4.N7.V21 := 0; + SECT4.N7.V22 := 0; + SECT4.N7.V23 := 0; + SECT4.N7.V24 := 0; + SECT5.N1 := 0; + SECT5.N2 := 0; + SECT5.N3 := 0; + SECT5.N4 := 0; + SECT5.N5 := 0; + SECT5.N6 := 0; + SECT5.N7.V1 := 0; + SECT5.N7.V2 := 0; + SECT5.N7.V3 := 0; + SECT5.N7.V4 := 0; + SECT5.N7.V5 := 0; + SECT5.N7.V6 := 0; + SECT5.N7.V7 := 0; + SECT5.N7.V8 := 0; + SECT5.N7.V9 := 0; + SECT5.N7.V10 := 0; + SECT5.N7.V11 := 0; + SECT5.N7.V12 := 0; + SECT5.N7.V13 := 0; + SECT5.N7.V14 := 0; + SECT5.N7.V15 := 0; + SECT5.N7.V16 := 0; + SECT5.N7.V17 := 0; + SECT5.N7.V18 := 0; + SECT5.N7.V19 := 0; + SECT5.N7.V20 := 0; + SECT5.N7.V21 := 0; + SECT5.N7.V22 := 0; + SECT5.N7.V23 := 0; + SECT5.N7.V24 := 0; + +END_DATA_BLOCK + diff --git a/DB_SIPA_Supervision_Excel.xlsx b/DB_SIPA_Supervision_Excel.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..48e46d637fab00c463b03cbb90b1e5000078a87a GIT binary patch literal 9180 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 literal 0 HcmV?d00001 diff --git a/DB_Structure.xml b/DB_Structure.xml new file mode 100644 index 0000000..a842c56 --- /dev/null +++ b/DB_Structure.xml @@ -0,0 +1,924 @@ + + + + +
+ "UDT SIPA SV Main" + + + + + DInt + .DB_IOT.USERLEVEL + 0 + + + String[81] + .DB_IOT.USERNAME + 4 + + + String[81] + .DB_IOT.NOME_RICETTA + 88 + + + Int + .DB_IOT.NEXT_MAINT_CYCLES + 172 + + + + String[254] + + 174 + + + String[254] + + 430 + + + String[254] + + 686 + + + String[254] + + 942 + + + String[8] + + 1198 + + + + .DB_IOT.ELECTRIC_VOLTAGE_PHASE_D + + Real + true + 1208 + + + Real + true + 1212 + + + Real + true + 1216 + + + + .DB_IOT.ELECTRIC_CURRENT_PHASE_D + + Real + true + 1220 + + + Real + true + 1224 + + + Real + true + 1228 + + + + Real + .DB_IOT.ELECTRIC_POWER_D + 1232 + + + Real + .DB_IOT.ELECTRIC_POWER_FACTOR_D + 1236 + + + Real + .DB_IOT.ELECTRIC_POWER_HOUR_D + 1240 + + + Real + .DB_IOT.ELECTRIC_POWER_WH + 1244 + + + + 0 +
+ + "UDT SIPA SV Section" + + + + + DInt + .DB_IOT.STATO_MACCHINA + 1664 + + + DInt + .DB_IOT.ALLARME_FERMO + 1668 + + + DInt + .DB_IOT.WARNING_ATTIVO (che compromette produzione) + 1672 + + + Int + .DB_IOT.STATO_OPERATIVO (Semaforo) + 1676 + + + Int + .DB_IOT.MODO_OPERATIVO (Prod,Simula,Man, ecc) + 1678 + + + DInt + .DB_IOT.ALARM_STOP_NO + 1680 + + + + DInt + PIECES_TOT + 1684 + + + DInt + PIECES_OK + 1688 + + + DInt + PIECES_KO_1 + 1692 + + + DInt + PIECES_KO_2 + 1696 + + + DInt + PIECES_KO_3 + 1700 + + + DInt + PIECES_KO_4 + 1704 + + + DInt + PIECES_KO_5 + 1708 + + + DInt + PIECES_KO_6 + 1712 + + + DInt + PIECES_KO_7 + 1716 + + + DInt + PIECES_KO_8 + 1720 + + + DInt + PIECES_KO_9 + 1724 + + + DInt + PIECES_KO_10 + 1728 + + + DInt + T_ALARM_HOURS + 1732 + + + DInt + T_DRY_CYCLE_HOURS + 1736 + + + DInt + T_POWERED_HOURS + 1740 + + + DInt + T_PRODUCT_100_HOURS + 1744 + + + DInt + T_PRODUCT_0_HOURS + 1748 + + + DInt + T_STOP_HOURS + 1752 + + + Int + T_ALARM_MINUTES + 1756 + + + Int + T_DRY_CYCLE_MINUTES + 1758 + + + Int + T_POWERED_MINUTES + 1760 + + + Int + T_PRODUCT_100_MINUTES + 1762 + + + Int + T_PRODUCT_0_MINUTES + 1764 + + + Int + T_STOP_MINUTES + 1766 + + + + + 1248 + + + "UDT SIPA SV Section" + + + + + DInt + .DB_IOT.STATO_MACCHINA + 1664 + + + DInt + .DB_IOT.ALLARME_FERMO + 1668 + + + DInt + .DB_IOT.WARNING_ATTIVO (che compromette produzione) + 1672 + + + Int + .DB_IOT.STATO_OPERATIVO (Semaforo) + 1676 + + + Int + .DB_IOT.MODO_OPERATIVO (Prod,Simula,Man, ecc) + 1678 + + + DInt + .DB_IOT.ALARM_STOP_NO + 1680 + + + + DInt + PIECES_TOT + 1684 + + + DInt + PIECES_OK + 1688 + + + DInt + PIECES_KO_1 + 1692 + + + DInt + PIECES_KO_2 + 1696 + + + DInt + PIECES_KO_3 + 1700 + + + DInt + PIECES_KO_4 + 1704 + + + DInt + PIECES_KO_5 + 1708 + + + DInt + PIECES_KO_6 + 1712 + + + DInt + PIECES_KO_7 + 1716 + + + DInt + PIECES_KO_8 + 1720 + + + DInt + PIECES_KO_9 + 1724 + + + DInt + PIECES_KO_10 + 1728 + + + DInt + T_ALARM_HOURS + 1732 + + + DInt + T_DRY_CYCLE_HOURS + 1736 + + + DInt + T_POWERED_HOURS + 1740 + + + DInt + T_PRODUCT_100_HOURS + 1744 + + + DInt + T_PRODUCT_0_HOURS + 1748 + + + DInt + T_STOP_HOURS + 1752 + + + Int + T_ALARM_MINUTES + 1756 + + + Int + T_DRY_CYCLE_MINUTES + 1758 + + + Int + T_POWERED_MINUTES + 1760 + + + Int + T_PRODUCT_100_MINUTES + 1762 + + + Int + T_PRODUCT_0_MINUTES + 1764 + + + Int + T_STOP_MINUTES + 1766 + + + + + 1352 + + + "UDT SIPA SV Section" + + + + + DInt + .DB_IOT.STATO_MACCHINA + 1664 + + + DInt + .DB_IOT.ALLARME_FERMO + 1668 + + + DInt + .DB_IOT.WARNING_ATTIVO (che compromette produzione) + 1672 + + + Int + .DB_IOT.STATO_OPERATIVO (Semaforo) + 1676 + + + Int + .DB_IOT.MODO_OPERATIVO (Prod,Simula,Man, ecc) + 1678 + + + DInt + .DB_IOT.ALARM_STOP_NO + 1680 + + + + DInt + PIECES_TOT + 1684 + + + DInt + PIECES_OK + 1688 + + + DInt + PIECES_KO_1 + 1692 + + + DInt + PIECES_KO_2 + 1696 + + + DInt + PIECES_KO_3 + 1700 + + + DInt + PIECES_KO_4 + 1704 + + + DInt + PIECES_KO_5 + 1708 + + + DInt + PIECES_KO_6 + 1712 + + + DInt + PIECES_KO_7 + 1716 + + + DInt + PIECES_KO_8 + 1720 + + + DInt + PIECES_KO_9 + 1724 + + + DInt + PIECES_KO_10 + 1728 + + + DInt + T_ALARM_HOURS + 1732 + + + DInt + T_DRY_CYCLE_HOURS + 1736 + + + DInt + T_POWERED_HOURS + 1740 + + + DInt + T_PRODUCT_100_HOURS + 1744 + + + DInt + T_PRODUCT_0_HOURS + 1748 + + + DInt + T_STOP_HOURS + 1752 + + + Int + T_ALARM_MINUTES + 1756 + + + Int + T_DRY_CYCLE_MINUTES + 1758 + + + Int + T_POWERED_MINUTES + 1760 + + + Int + T_PRODUCT_100_MINUTES + 1762 + + + Int + T_PRODUCT_0_MINUTES + 1764 + + + Int + T_STOP_MINUTES + 1766 + + + + + 1456 + + + "UDT SIPA SV Section" + + + + + DInt + .DB_IOT.STATO_MACCHINA + 1664 + + + DInt + .DB_IOT.ALLARME_FERMO + 1668 + + + DInt + .DB_IOT.WARNING_ATTIVO (che compromette produzione) + 1672 + + + Int + .DB_IOT.STATO_OPERATIVO (Semaforo) + 1676 + + + Int + .DB_IOT.MODO_OPERATIVO (Prod,Simula,Man, ecc) + 1678 + + + DInt + .DB_IOT.ALARM_STOP_NO + 1680 + + + + DInt + PIECES_TOT + 1684 + + + DInt + PIECES_OK + 1688 + + + DInt + PIECES_KO_1 + 1692 + + + DInt + PIECES_KO_2 + 1696 + + + DInt + PIECES_KO_3 + 1700 + + + DInt + PIECES_KO_4 + 1704 + + + DInt + PIECES_KO_5 + 1708 + + + DInt + PIECES_KO_6 + 1712 + + + DInt + PIECES_KO_7 + 1716 + + + DInt + PIECES_KO_8 + 1720 + + + DInt + PIECES_KO_9 + 1724 + + + DInt + PIECES_KO_10 + 1728 + + + DInt + T_ALARM_HOURS + 1732 + + + DInt + T_DRY_CYCLE_HOURS + 1736 + + + DInt + T_POWERED_HOURS + 1740 + + + DInt + T_PRODUCT_100_HOURS + 1744 + + + DInt + T_PRODUCT_0_HOURS + 1748 + + + DInt + T_STOP_HOURS + 1752 + + + Int + T_ALARM_MINUTES + 1756 + + + Int + T_DRY_CYCLE_MINUTES + 1758 + + + Int + T_POWERED_MINUTES + 1760 + + + Int + T_PRODUCT_100_MINUTES + 1762 + + + Int + T_PRODUCT_0_MINUTES + 1764 + + + Int + T_STOP_MINUTES + 1766 + + + + + 1560 + + + "UDT SIPA SV Section" + + + + + DInt + .DB_IOT.STATO_MACCHINA + 1664 + + + DInt + .DB_IOT.ALLARME_FERMO + 1668 + + + DInt + .DB_IOT.WARNING_ATTIVO (che compromette produzione) + 1672 + + + Int + .DB_IOT.STATO_OPERATIVO (Semaforo) + 1676 + + + Int + .DB_IOT.MODO_OPERATIVO (Prod,Simula,Man, ecc) + 1678 + + + DInt + .DB_IOT.ALARM_STOP_NO + 1680 + + + + DInt + PIECES_TOT + 1684 + + + DInt + PIECES_OK + 1688 + + + DInt + PIECES_KO_1 + 1692 + + + DInt + PIECES_KO_2 + 1696 + + + DInt + PIECES_KO_3 + 1700 + + + DInt + PIECES_KO_4 + 1704 + + + DInt + PIECES_KO_5 + 1708 + + + DInt + PIECES_KO_6 + 1712 + + + DInt + PIECES_KO_7 + 1716 + + + DInt + PIECES_KO_8 + 1720 + + + DInt + PIECES_KO_9 + 1724 + + + DInt + PIECES_KO_10 + 1728 + + + DInt + T_ALARM_HOURS + 1732 + + + DInt + T_DRY_CYCLE_HOURS + 1736 + + + DInt + T_POWERED_HOURS + 1740 + + + DInt + T_PRODUCT_100_HOURS + 1744 + + + DInt + T_PRODUCT_0_HOURS + 1748 + + + DInt + T_STOP_HOURS + 1752 + + + Int + T_ALARM_MINUTES + 1756 + + + Int + T_DRY_CYCLE_MINUTES + 1758 + + + Int + T_POWERED_MINUTES + 1760 + + + Int + T_PRODUCT_100_MINUTES + 1762 + + + Int + T_PRODUCT_0_MINUTES + 1764 + + + Int + T_STOP_MINUTES + 1766 + + + + + 1664 + + + + \ No newline at end of file diff --git a/DB_to_Excel.py b/DB_to_Excel.py new file mode 100644 index 0000000..334865a --- /dev/null +++ b/DB_to_Excel.py @@ -0,0 +1,172 @@ +import re +import json +import pandas as pd +from ExportData import * +from ExpandDB import * + + +def clean_line(line): + """Clean line from BOM and extra spaces or quotes.""" + # Remove UTF-8 BOM if exists and strip trailing/leading whitespace + line = line.replace("\ufeff", "").strip() + # Standardize TYPE and DATA_BLOCK definitions to ensure they're properly captured + line = re.sub(r'\s*TYPE\s+"?', 'TYPE "', line) + line = re.sub(r'\s*DATA_BLOCK\s+"?', 'DATA_BLOCK "', line) + return line + + +def extract_name(line): + """Extract the name from TYPE or DATA_BLOCK definition line.""" + # Attempt to find a quoted name first + match = re.search(r'(TYPE|DATA_BLOCK)\s+"([^"]+)"', line) + if match: + return match.group(2).strip() # The name is within quotes + + # If no quoted name, find an unquoted name + match = re.search(r"(TYPE|DATA_BLOCK)\s+(\S+)", line) + if match: + return match.group(2).strip() # The name is without quotes + + +def parse_udts(lines): + udt_json = {} + udt_name = None + nested_structs = [] + current_struct = None + is_within_struct = False + + for line in lines: + line = clean_line(line) + if "TYPE" in line and "END_TYPE" not in line: + udt_name = extract_name(line) + udt_json[udt_name] = {} + current_struct = udt_json[udt_name] + print(f"Created UDT: {udt_name}") + elif "END_TYPE" in line: + print(f"Completed UDT: {udt_name}") + udt_name = None + nested_structs = [] + current_struct = None + is_within_struct = False + elif "STRUCT" in line and "END_STRUCT" not in line and udt_name is not None: + struct_name = ( + "Struct" if "STRUCT" == line.strip() else line.split(":")[0].strip() + ) + new_struct = {} + current_struct[struct_name] = new_struct + nested_structs.append(current_struct) + current_struct = new_struct + is_within_struct = True + print(f"Created STRUCT: {struct_name}") + elif "END_STRUCT" in line and udt_name is not None: + current_struct = nested_structs.pop() if nested_structs else None + is_within_struct = bool(nested_structs) + print(f"Closed STRUCT in UDT '{udt_name}'") + elif udt_name and ":" in line and is_within_struct: + parts = line.split(":") + field_name = parts[0].strip() + field_details = parts[1].strip().split("//") + field_type = ( + field_details[0].replace(";", "").strip() + ) # Removing ';' from field type + field_comment = parts[1].split("//")[1].strip() if "//" in parts[1] else "" + if "Struct" in field_type: + new_struct = {} + current_struct[field_name] = new_struct + nested_structs.append(current_struct) + current_struct = new_struct + print(f"Opened inline STRUCT at field '{field_name}'") + else: + current_struct[field_name] = { + "type": field_type, + "comment": field_comment, + } + print( + f"Added field '{field_name}' to STRUCT: Type={field_type}, Comment={field_comment}" + ) + + return udt_json + + +def parse_dbs(lines, udts): + db_json = {} + db_name = None + nested_structs = [] + current_struct = None + is_within_struct = False + + for line in lines: + line = clean_line(line) + if "DATA_BLOCK" in line and "END_DATA_BLOCK" not in line: + db_name = extract_name(line) + db_json[db_name] = {} + current_struct = db_json[db_name] + print(f"Created DATA_BLOCK: {db_name}") + elif "END_DATA_BLOCK" in line: + print(f"Completed DATA_BLOCK: {db_name}") + db_name = None + nested_structs = [] + current_struct = None + is_within_struct = False + elif "STRUCT" in line and "END_STRUCT" not in line and db_name is not None: + struct_name = ( + "Struct" if "STRUCT" == line.strip() else line.split(":")[0].strip() + ) + new_struct = {} + current_struct[struct_name] = new_struct + nested_structs.append(current_struct) + current_struct = new_struct + is_within_struct = True + print(f"Created STRUCT in DB '{db_name}': {struct_name}") + elif "END_STRUCT" in line and db_name is not None: + current_struct = nested_structs.pop() if nested_structs else None + is_within_struct = bool(nested_structs) + print(f"Closed STRUCT in DB '{db_name}'") + elif db_name and ":" in line and is_within_struct: + parts = line.split(":") + field_name = parts[0].strip() + field_details = parts[1].strip().split("//") + field_type = ( + field_details[0].replace(";", "").strip() + ) # Removing ';' from field type + field_comment = parts[1].split("//")[1].strip() if "//" in parts[1] else "" + if "Struct" in field_type: + new_struct = {} + current_struct[field_name] = new_struct + nested_structs.append(current_struct) + current_struct = new_struct + print(f"Opened inline STRUCT at field '{field_name}' in DB '{db_name}'") + else: + current_struct[field_name] = { + "type": field_type, + "comment": field_comment, + } + print( + f"Added field '{field_name}' to STRUCT in DB '{db_name}': Type={field_type}, Comment={field_comment}" + ) + + return db_json + + +if __name__ == "__main__": + file_path = "DB SIPA Supervision.db" + with open(file_path, "r", encoding="utf-8-sig") as file: + lines = file.readlines() + + udt_json = parse_udts(lines) + db_json = parse_dbs(lines, udt_json) + + expand_dbs(udt_json, db_json) # Expand DBs with UDT definitions + + for db_name, db_content in db_json.items(): + calculate_offsets( + db_content + ) # Calculate offsets including special handling for Bool and String + + # Display the expanded DBs as a table + df = display_as_table(db_json) + save_dataframe_to_file(df) # Save the DataFrame to a CSV file + save_dataframe_to_excel(df) # Optionally, save the DataFrame to an Excel file + + # Save JSON data to an XML file + save_json_to_xml(db_json) diff --git a/ExpandDB.py b/ExpandDB.py new file mode 100644 index 0000000..9f4e7e4 --- /dev/null +++ b/ExpandDB.py @@ -0,0 +1,125 @@ +import re +import json +import pandas as pd + +def expand_udt_references(db_struct, udts): + """ + Recursively expand UDT references in the given DB structure using the UDT definitions. + This function specifically expands fields designated as 'type' which reference UDTs. + """ + if isinstance(db_struct, dict): + for key, value in list(db_struct.items()): + if isinstance(value, dict): + # Recurse into dictionaries + expand_udt_references(value, udts) + elif isinstance(value, str) and key == "type": # Only expand 'type' fields + type_name = value.strip( + '"' + ) # Remove quotes which may wrap UDT names with spaces + if type_name in udts: + # Replace the UDT reference with its definition, if it exists + db_struct["fields"] = udts[ + type_name + ].copy() # Assume structure to insert is under 'fields' + print(f"Expanded UDT '{type_name}' at field '{key}' ") + elif isinstance(db_struct, list): + for item in db_struct: + expand_udt_references(item, udts) + + +def handle_array_types(db_struct): + """ + Handle array types once all UDTs are expanded. + This function modifies the structure in place. + """ + if isinstance(db_struct, dict): + for key, value in list(db_struct.items()): + if isinstance(value, dict): + handle_array_types(value) + elif isinstance(value, str): + # Parsing array definitions, e.g., "Array[1..3] of Real" + match = re.match(r"Array\[(\d+)\.\.(\d+)\] of (\w+)", value) + if match: + lower_bound, upper_bound, base_type = ( + int(match.group(1)), + int(match.group(2)), + match.group(3), + ) + # Expand this field into multiple fields + db_struct.pop(key) # Remove the original field + for i in range(lower_bound, upper_bound + 1): + db_struct[f"{key}_{i}"] = {"type": base_type, 'is_array_element': True} + print( + f"Expanded field '{key}' into array fields: {key}_{lower_bound} to {key}_{upper_bound} of type {base_type}" + ) + + +type_sizes = { + "Int": 2, + "DInt": 4, + "Word": 2, + "Real": 4, + "Bool": 2, # We'll adjust this dynamically based on context (1 byte if alone, 1 bit if grouped) + "String": 1, # This will be multiplied by the specified size in brackets [n] +} + + +def calculate_offsets(db_struct, current_offset=0, parent=None): + """ + Recursively calculate byte offsets for each field in the DB structure considering special types. + """ + last_key_was_bool = False + if isinstance(db_struct, dict): + for key, value in list(db_struct.items()): + if isinstance(value, dict): + if "type" in value: + type_name = value["type"] + is_array_element = value.get('is_array_element', False) + size = type_sizes.get( + type_name, 0 + ) # Default to 1 byte if type is not recognized + + if not is_array_element and current_offset % 2 != 0: + current_offset += 1 # Align to the next even offset if it's not an array element + + # Special handling for String types + if "String" in type_name: + match = re.match(r"String\[(\d+)\]", type_name) + if match: + length = int(match.group(1)) + size = length + 2 # Account for null-termination and string length prefix + else: + size = type_sizes.get(type_name, 1) # Default to generic size if not an array + + # Adjusting Bool sizes based on grouping + if type_name == "Bool": + if last_key_was_bool: # This is a grouped bool + size = 0.125 # One bit per Bool if grouped + else: + size = 2 # Bools use a full byte if not grouped + last_key_was_bool = True + else: + last_key_was_bool = False + + value["offset"] = current_offset + current_offset += size + + current_offset = calculate_offsets( + value, current_offset, value + ) # Recurse into nested structs + elif isinstance(db_struct, list): + for item in db_struct: + current_offset = calculate_offsets(item, current_offset, parent) + return current_offset + + +def expand_dbs(udts, dbs): + """ + Expand all UDT references in all DBs and then handle array types. + """ + for db_name, db_content in dbs.items(): + print(f"Expanding DB: {db_name}") + expand_udt_references(db_content, udts) + handle_array_types(db_content) + calculate_offsets(db_content) + print(f"Completed expansion for DB: {db_name}") diff --git a/ExportData.py b/ExportData.py new file mode 100644 index 0000000..a178f54 --- /dev/null +++ b/ExportData.py @@ -0,0 +1,74 @@ +import xmltodict +import pandas as pd + +def save_json_to_xml(json_data, filename="DB_Structure.xml"): + """ + Convert JSON data to XML and save it to a file. + """ + xml_data = xmltodict.unparse({"root": json_data}, pretty=True) + with open(filename, "w") as xml_file: + xml_file.write(xml_data) + print(f"XML data saved to {filename}") + + +def save_dataframe_to_excel(df, filename="DB_Structure.xlsx"): + """ + Save the provided DataFrame to an Excel file. + """ + df.to_excel(filename, index=False) + print(f"Data saved to {filename}") + + +def save_dataframe_to_file(df, filename="DB_Structure.csv"): + """ + Save the provided DataFrame to a CSV file. + """ + df.to_csv(filename, index=False) + print(f"Data saved to {filename}") + + +def collect_data_for_table(db_struct, parent_prefix="", collected_data=[]): + """ + Recursively collect data from the DB structure to display in a tabular format, + omitting 'fields' and 'Struct' in the names. + """ + if isinstance(db_struct, dict): + for key, value in db_struct.items(): + # Skip 'fields' and 'Struct' keys in the name path + if key == 'fields' or key == 'Struct': + next_prefix = parent_prefix # Continue with the current prefix + else: + next_prefix = f"{parent_prefix}.{key}" if parent_prefix else key + + if isinstance(value, dict) and 'type' in value: # Directly a field with 'type' + field_data = { + "Nombre": next_prefix, + "Tipo": value.get('type', 'N/A'), + "Offset": value.get('offset', 'N/A'), + "Comentario": value.get('comment', 'N/A') + } + collected_data.append(field_data) + + # Recursively handle nested dictionaries and lists + if isinstance(value, dict) or isinstance(value, list): + collect_data_for_table(value, next_prefix, collected_data) + elif isinstance(db_struct, list): + for index, item in enumerate(db_struct): + item_prefix = f"{parent_prefix}[{index}]" if parent_prefix else f"[{index}]" + collect_data_for_table(item, item_prefix, collected_data) + + return collected_data + + +def display_as_table(dbs): + """ + Convert collected DB data into a pandas DataFrame and display it. + """ + all_data = [] + for db_name, db_content in dbs.items(): + print(f"Processing DB: {db_name}") + db_data = collect_data_for_table(db_content) + all_data.extend(db_data) + + df = pd.DataFrame(all_data) + return df diff --git a/__pycache__/ExpandDB.cpython-310.pyc b/__pycache__/ExpandDB.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3d88268966987ebe93990d488915d896ca599c6a GIT binary patch literal 2846 zcmZuzL2ul~73K_wTrPJd%WiB#soM}mP=*>mqd~djxEf>Y?!q6!RgB3?!?9z3$2Om~ZpFP;wc57VHTrWQ1oVW7%7k zME1Xk_hPv&Q#tsI?e*kPuE8gf?0zu1a*kPpdj+S*>WcBCsPCefzrxs{4JeE?X%k1Nw-At-XU6JzVdq+9b5qt+ z-$_HHIww?~8W~Perpe*w0A`*H_RY`-PrkvKfRWi#>wq=iJ zYAbtkSQdvb7DCHfP3#1DJY_#{aW}zY{XM^QjHi`sErwfJZoAph;#=9hQQxH{)@y8z zT{$7k!a7lv#=5Aq>d3h3-S#JQX(unX??UX?MKI;eiK3YuyJ)7%+Kyt^m;00MYdC>X z#)S_Rx*zA&T)952aZ=|;2u1<^66jX|k*9a%+v5*)bF2#6nDPAr^IAMhb);%D-q|); zp1t>Jp{lIFSHpJ3-QIS#@63*MA5%mGw;#cz(JL%vLw=13#+i7Qgq(B6p9vm+eIw+5 z6#q%r6EAMpbX<5lTZjzr7JZ6Bdjt5_G=WBwU};h;O^5HU9s19(isV0oCXIDmD;FK* zwm5Vl0=Q_ZoB7Ozvu5TZo!3*P*WfowGyzC&khx0cdoX*0s(GUHWWSl$(hcUb*+rwj zpBpuyK#rB34xNFV2l~4(-$yaGVLE819^L{FAF_m{U#0Oi_9~$MLx3Id{x@Jvqx4Of zb3wHmFkoi*L2dWMj<>&Wv~=Pll~+z|H%;Z@`yg{YE$E9szlNyLC-P)i$Eir>1-p~; z`AdXQAOxTb@JF5yTJko6OjiWn%>a;&PK6950~vZ2b--Alp0qvlR?B2`Baq@@sHq@L&N6LN8Qlz)Ngc1|BtLk|K9a^hNcTXd=;bn6 zCUUS0QNtdPIwCo|3j(zX#j+_SgEl$|m+aA6i`3?6PYL5sK4B!w0elAV;oheu9}wr0 z|4SE;@?u^=wX^+WnC9TXC<{$*bf$7hcZbqd`gkdEK-o+w6`ewt7xJoOVaJ>IJqh$C z&O;MH{Q3H$)gv?)SGogy&Z`HS5Hm%=_4jvnUED2YH27B3hf`%;N+6t=a-odAg<&4K zn&78jgK<|cHaA)AYc%v=ck9TP$c%RN-o-O$1<-c2%8i{M0Zg9c2H9P1eDng`;ls>@?HK+U8hCnN%*19K25(*YGC_hTV z6UM1VB#G0n68L~BH0MkIFT@xsKG1JbY1wITMt=>jt^QaTX*zV&>pe&iw$NrMH8h@- zmHuP=lYs&kevbftKt?Qn;~~?j)^llnkg?sivAgV;x_b?LD-|-d!xupoR=w|`Z}SYPcRbt3LY+$`^NQjK7{X{0P&^#&CclL=zq;e6X*&GLH&1iUMF0Q* literal 0 HcmV?d00001 diff --git a/__pycache__/ExportData.cpython-310.pyc b/__pycache__/ExportData.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3b9b39873c2f4845abdbab6ea9d2d0fe82d29585 GIT binary patch literal 2244 zcma)7&2QX96!(nBUaymEwrQJ|4^^&&6fK}21X4wX3N+gaQP?69XjxJ%j%PNw_1fE+ z*)&k5MP;sYJN{;MPBN!k&7@0tle?TfBwd%E;y$kd#rP7h^AISH&uu$>%IEn4 ztbE?!iw~V{jgxh!b^3RZ=5&sl?W?_YEk}tSNwK;+$P$V_rVoQTfNu>xbsGll+$Efp zPD(iC?jt&(nwEsKefrbF#4X(ex1@)JIJX?`F^4((E^+eUZAV>r0K52p4WDM*FUe!) z3EhWX?twnF@q1we&svf12&tn_)^Bzq9_u*LMRfbKPop^Jk&1Ujlxp0Hqkfu+Rm)?T zEDF8R0vm@?XuW61gU)yfxvT_a&aa@QqTZhf9l4fx0P*PjyOr8yV7M-4n{Lu7s3X;Bk^Ap%X7bx`9eHI(-yT4X&| z4GXX|=dA7M>pouAoAIH!&(M|zTO#rt5HBQbqIUk%cG-mUVB5R@%eH83{i_o>bzPnU zZh0C8w8RIE;4W*2Jd1xY<|iyz{s0-EP=A?8d9!OzUN}IEi z?KrYsdL=smoZ#LewUmEM)sW)BFKptM^njHR8GHjW)DjGLS>DqVLyBx?X9E z|Gw9?(%C1V?aQETZ4!W9xz(#))WCtlBa5z#d}ejLxJgdYm~(@>KAel>o={)VvuT` z=G)OqKNT5QD;7&uD%4v+K1_KmZ#BgezdC6A>Wm?)hUvYb7`vUfJ~DpM?<)cLkrV@{ zZNv({Qw+AG=(3G;SakiH_CPmWEAW3T)54H%47t+^Oqi-PS31rUz#R)i9-z)Z8Fw2* z`tcB;h#QurN}J`W11#Y5z@#3SmkCoB`Dh?ytVJvA*7;Vi@<(?8;0*5T0SNZf-EL#b zE_j7v?me+*yq!23iSAr3c4r4oXw9{U;v1z_APPsn=l$y(Vc= zpDfcQN@+;&_5Te0GwwX0KQKT1qe&vtAdFhRgaFU%@qw6um1@Ic+nGRrIdE+DpMiXW z{0GP)C7tyP=s4~^ftn!DZ5Zb3eP6Q!uOx?16(x2PI=*2;KkFvPo`@iO5N06iwuua( zt;FgC%wd~3&L~~w!*~&JJrN2bw+#X=M=f8jfT|T5peu|I?!>^+Avg77&}{k8m$y_m zh_k9|m>NXOHj)qs=mWr{p(Afq&bMgs0p&>BL@h`a<_ zEg}*9VOp%Fmv9QC2b1wDW92)ru#Ln5ss$z+7c1dJpsgYno`d%X1s`SN3P#S}9XJ8p M8irxe2<9*T4Ug1IYXATM literal 0 HcmV?d00001 diff --git a/db_definitions.json b/db_definitions.json new file mode 100644 index 0000000..9273b31 --- /dev/null +++ b/db_definitions.json @@ -0,0 +1,30 @@ +{ + "DB SIPA Supervision": { + "root": { + "MAIN": { + "type": "\"UDT SIPA SV Main\";", + "comment": "" + }, + "SECT1": { + "type": "\"UDT SIPA SV Section\";", + "comment": "" + }, + "SECT2": { + "type": "\"UDT SIPA SV Section\";", + "comment": "" + }, + "SECT3": { + "type": "\"UDT SIPA SV Section\";", + "comment": "" + }, + "SECT4": { + "type": "\"UDT SIPA SV Section\";", + "comment": "" + }, + "SECT5": { + "type": "\"UDT SIPA SV Section\";", + "comment": "" + } + } + } +} \ No newline at end of file diff --git a/udt_definitions.json b/udt_definitions.json new file mode 100644 index 0000000..27c3c5c --- /dev/null +++ b/udt_definitions.json @@ -0,0 +1,194 @@ +{ + "UDT SIPA SV Main": { + "root": { + "N1": { + "type": "DInt;", + "comment": ".DB_IOT.USERLEVEL" + }, + "N2": { + "type": "String[81];", + "comment": ".DB_IOT.USERNAME" + }, + "N3": { + "type": "String[81];", + "comment": ".DB_IOT.NOME_RICETTA" + }, + "N4": { + "type": "Int;", + "comment": ".DB_IOT.NEXT_MAINT_CYCLES" + }, + "N5": { + "V1": { + "type": "String[254];", + "comment": "" + }, + "V2": { + "type": "String[254];", + "comment": "" + }, + "V3": { + "type": "String[254];", + "comment": "" + }, + "V4": { + "type": "String[254];", + "comment": "" + }, + "V5": { + "type": "String[8];", + "comment": "" + } + }, + "N6": { + "type": "Array[1..3] of Real;", + "comment": ".DB_IOT.ELECTRIC_VOLTAGE_PHASE_D" + }, + "N7": { + "type": "Array[1..3] of Real;", + "comment": ".DB_IOT.ELECTRIC_CURRENT_PHASE_D" + }, + "N8": { + "type": "Real;", + "comment": ".DB_IOT.ELECTRIC_POWER_D" + }, + "N9": { + "type": "Real;", + "comment": ".DB_IOT.ELECTRIC_POWER_FACTOR_D" + }, + "N10": { + "type": "Real;", + "comment": ".DB_IOT.ELECTRIC_POWER_HOUR_D" + }, + "N11": { + "type": "Real;", + "comment": ".DB_IOT.ELECTRIC_POWER_WH" + } + } + }, + "UDT SIPA SV Section": { + "root": { + "N1": { + "type": "DInt;", + "comment": ".DB_IOT.STATO_MACCHINA" + }, + "N2": { + "type": "DInt;", + "comment": ".DB_IOT.ALLARME_FERMO" + }, + "N3": { + "type": "DInt;", + "comment": ".DB_IOT.WARNING_ATTIVO (che compromette produzione)" + }, + "N4": { + "type": "Int;", + "comment": ".DB_IOT.STATO_OPERATIVO (Semaforo)" + }, + "N5": { + "type": "Int;", + "comment": ".DB_IOT.MODO_OPERATIVO (Prod,Simula,Man, ecc)" + }, + "N6": { + "type": "DInt;", + "comment": ".DB_IOT.ALARM_STOP_NO" + }, + "N7": { + "V1": { + "type": "DInt;", + "comment": "PIECES_TOT" + }, + "V2": { + "type": "DInt;", + "comment": "PIECES_OK" + }, + "V3": { + "type": "DInt;", + "comment": "PIECES_KO_1" + }, + "V4": { + "type": "DInt;", + "comment": "PIECES_KO_2" + }, + "V5": { + "type": "DInt;", + "comment": "PIECES_KO_3" + }, + "V6": { + "type": "DInt;", + "comment": "PIECES_KO_4" + }, + "V7": { + "type": "DInt;", + "comment": "PIECES_KO_5" + }, + "V8": { + "type": "DInt;", + "comment": "PIECES_KO_6" + }, + "V9": { + "type": "DInt;", + "comment": "PIECES_KO_7" + }, + "V10": { + "type": "DInt;", + "comment": "PIECES_KO_8" + }, + "V11": { + "type": "DInt;", + "comment": "PIECES_KO_9" + }, + "V12": { + "type": "DInt;", + "comment": "PIECES_KO_10" + }, + "V13": { + "type": "DInt;", + "comment": "T_ALARM_HOURS" + }, + "V14": { + "type": "DInt;", + "comment": "T_DRY_CYCLE_HOURS" + }, + "V15": { + "type": "DInt;", + "comment": "T_POWERED_HOURS" + }, + "V16": { + "type": "DInt;", + "comment": "T_PRODUCT_100_HOURS" + }, + "V17": { + "type": "DInt;", + "comment": "T_PRODUCT_0_HOURS" + }, + "V18": { + "type": "DInt;", + "comment": "T_STOP_HOURS" + }, + "V19": { + "type": "Int;", + "comment": "T_ALARM_MINUTES" + }, + "V20": { + "type": "Int;", + "comment": "T_DRY_CYCLE_MINUTES" + }, + "V21": { + "type": "Int;", + "comment": "T_POWERED_MINUTES" + }, + "V22": { + "type": "Int;", + "comment": "T_PRODUCT_100_MINUTES" + }, + "V23": { + "type": "Int;", + "comment": "T_PRODUCT_0_MINUTES" + }, + "V24": { + "type": "Int;", + "comment": "T_STOP_MINUTES" + } + } + } + } +} \ No newline at end of file