Since it was too time-consuming for me to write all the data points into the elements manually, I wrote a script for this purpose.
The procedure is as follows:
First, all IO modules are created.
The page numbers must be assigned directly.
Then you can start the script and select the qet file. After that, the corresponding pages are entered and loaded.
My components must be used here, or rather the variables that I use in my components.
Then you can copy information such as function, address, etc. directly from the xlsx file into the manager. These are written to the QET file by clicking on Apply.

Translated with DeepL.com (free version)

ne prend en charge qui si les borne ont un nom en francais "continuité"

https://drive.google.com/drive/folders/ … 5E2zsUl-1L

Optional kann man aktivieren, dass man eine CSV als Debugausgabe sowie eine CSV bekommt, die angibt, welche Verbindungen rausgefiltert wurden, da diese als doppelt erkannt wurden.

Die ausgegebene Datei wird an dem Ort, an dem die QET Datei liegt gespeichert.

Sollte der Wunsch bestehen, diese Funktion direkt in QET zu implementieren, kann ich versuchen hieraus eine C++ Datei zu erstellen.

English:
I wrote a Python script that extracts the connection, port, and their properties from the .qet file.
This also works across pages.
You just have to make sure that the connections are drawn the way they will be connected in the control cabinet.
For example:
You come from a cross-reference. This goes to the first component. From the first component, you then go to the second component. From the second component, you then go to the third component and from the third component to the cross-reference to the next page. This is necessary so that the connections are written correctly in the .qet file.

Optionally, you can enable the option to receive a CSV as debug output and a CSV that specifies which connections have been filtered out because they were recognized as duplicates.

The output file is saved in the location where the QET file is located.

If you would like to implement this function directly in QET, I can try to create a C++ file from this.

Translated with DeepL.com (free version)

I work on such a workflow (to make a model of electrical installation in a house/apartment):
1. Prepare model of a house/apartment in FreeCAD
2. Make diagram of home electrical installation in QElectroTech as detailed as possible
3. Run an import script which will be able to create complete model of all elements, cables and connections in FreeCAD based on diagram from QElectroTech. Location of elements should be as close as possible to their final positions in the 3D space. At this stage, wires are just straight lines connecting elements.
4. Manually place all elements on their final positions in the 3D model of house (sockets, switches, light points, distribution boxes etc.)
5. Manually route base cable wires created in previous step on walls, ceillings etc. What helps in this step is that the starting and ending points of each cable are already attached to a specific element.
6. Run import script again to create all missing details: full cable shapes with all single wires and all interiors of distribution boxes with all connections inside
7. Final manual adjustment of cable routes and element placements

The result is a complete 3D model of electrical installation identical to the electrical diagram. The model can be exported as IFC file for further processing e.g. in a BIM workflow (e.g. create BOM list, rule checks, post-construction archiving etc.)
I know that there is commercial software doing all the above things pretty well, but I prefer FOSS solution and I didn't find any.

The core software component here is the import script I'm working on (working name: QET Import). It is not public yet, it still needs a lot of work to be usable for others.

Here come my questions to you professionals. Is it worth the effort?
I find it very useful for my own needs, but I would like to see your opinion about it.
E.g. Is it useless for electricians because they have to anyway route cables on real walls?
Is the electrical diagram itself sufficient in practice?
Are there other areas where such modelling would be useful?

Another question:
I had to use some tricks in QElectroTech diagram to achieve my goal (see apartment_example.qet below). Do you think it is practical to make such a diagram?
Does it break any established rules?

Here are some details about an example project of simple electrical installation in an apartment. This should help to clarify the whole idea.

The starting point:

1. Prepare model of a house/apartment in FreeCAD
The FreeCAD example apartment file (empty walls, before import): apartment_example_empty.FCStd

2. Make diagram of home electrical installation in QElectroTech as detailed as possible
The QElectroTech example project file: apartment_example.qet
Folio 1 image from above document: apartment folio 1

3. Run an import script which imports folios 1,2,3 from apartment_example.qet. At this stage, wires are just straight lines connecting elements.
The image from FreeCAD example apartment file after importing folios 1,2,3: base_wires.png

4. Manually place all elements on their final positions in the 3D model of house (sockets, switches, light points, distribution boxes etc.)
5. Manually route base cable wires created in previous step on walls, ceillings etc.
6. Run import script again to create all missing details: full cable shapes with all single wires and all interiors of distribution boxes with all connections inside

The image from FreeCAD example apartment file after steps 4,5,6 and after importing folios 4,5,6,7:
final_cables.png

The switchboard after automatic import: switchboard.png

7. Final manual adjustment of cable routes and element placements

The switchboard after manual routing: switchboard_final.png

NOTE: In order to correctly open the apartment_example_cables_final.FCStd file, the following are needed:
- FreeCAD version 1.0.0 or newer
- Cable Workbench Addon installed by AddonManager from within FreeCAD.

es ist schon ein Weilchen her, dass ich einen Versuch unternommen habe eine App zu programmieren, die einen Klemmenplan erstellt.
Ich war sehr frustriert, nachdem ich sie hier hochgeladen hatte, hat sie bei mir selber auch nicht mehr funktioniert…

Heute ein neuer Versuch.

Nur als AppImmage, sie ist noch nicht ausgereift:

- Jegliche Formeln werden nicht akzeptiert: AutoFoliennummern, AutoBauteilnummern…
- Die App gibt keine Fehlermeldungen aus.
- Nur in deutscher Sprache
- Keine Brücke über eine Seite hinweg möglich.

Ganz wichtig: Werden neue Bauteile, Klemmen oder Betriebsmittel erstellt immer neue Terminals einfügen, sonst wird keine neue Terminal-uuid vergeben.
QET verträgt das, die KlemmenplanApp wird einfach keinen Klemmenplan erstellen.

Voraussetzungen für einen Klemmenplan:

- Die Terminals an einer Klemme an die ein Betriebsmittel angeschlossen wird müssen benannt sein (a,b,c,….) und als intern oder extern gekennzeichnet.
- die Terminals an einer Klemme für Brücken sind generisch und ohne Namen.

-die Verbindungen die eine Brücke darstellen müssen im Diagram als solche bezeichnet werden:
Der Text des Leiters muss „Brücke i1“ sein. i1 steht dabei für Intern 1.
Der Klemmenplan kann jeweils 3 Brücken intern und extern darstellen z.B. „Brücke e3“

- Die Terminals der Betriebsmittel müssen einen Namen erhalten. Betriebsmittelkennzeichen, Anlage und Ort müssen ausgefüllt sein.

Zum Ausprobieren am besten die Elemente/Bauteile, vor allem Klemmen, aus meinen Diagrammen verwenden.

Anwendung: App starten, QET-Datei auswählen, Klemmenplan erstellen.
Die Originaldatei bleibt erhalten, eine neue Datei mit „-terminals.qet“ wird erstellt.

Viel Spaß beim Probieren.
Ich freue mich auf Rückmeldungen und Verbesserungsvorschläge/Tipps.

An example of the CSV loaded in to excel is provided.

The propose was to provide a list of wires for wiring a machine/panel so the correct size an color of wire can be selected and correctly labeled and it is very obvious which terminals it connects to

and thus the list contains,

Start location, part, designator, terminal ID
End location, part designator, terminal ID
conductor_section, conductor_function, conductor color, and conductor number

Clearly the more you fill in for conductor details, and if you edit the symbols to actually use the terminal names you will get more out but it works for my purpose and may be it is of use to others?

import zipfile
import xml.etree.ElementTree as ET
import os
import tempfile
import csv

def extract_content_qet(file_path):
    """Unzip .qetz or return .qet path"""
    if zipfile.is_zipfile(file_path):
        with zipfile.ZipFile(file_path, 'r') as zip_ref:
            temp_dir = tempfile.mkdtemp()
            zip_ref.extract('content.qet', temp_dir)
            return os.path.join(temp_dir, 'content.qet')
    return file_path

def build_terminal_uuid_map(root):
    """Builds a dict mapping terminal UUIDs to their names"""
    terminal_map = {}
    for terminal in root.iter('terminal'):
        uuid = terminal.get('uuid')
        name = terminal.get('name')
        if uuid and name:
            terminal_map[uuid] = name
    return terminal_map

def build_link_uuid_map(root):
    """Builds a dict mapping link UUIDs to their associated element UUIDs"""
    link_map = {}

    for element in root.iter('element'):
        element_uuid = element.get('uuid')
        links_node = element.find('links_uuids')
        if links_node is not None:
            for link in links_node.findall('link_uuid'):
                link_uuid = link.get('uuid')
                if link_uuid:
                    print(f"{element_uuid} -> {link_uuid}")
                    link_map[link_uuid] = element_uuid  # You can also store the full element if needed
    return link_map


def find_element_by_uuid(root, target_uuid):
    """Finds the <element> with the given UUID"""
    for element in root.iter('element'):
        if element.get('uuid') == target_uuid:
            return element
    return None


def find_parent_by_uuid(root, target_uuid):
    """Finds the parent of the <element> with the given UUID"""
    for parent in root.iter('diagram'):
        
        for child in parent.iter('element'):
            if child.get("uuid") == target_uuid:
                return parent
    return None

def extract_conductors_with_terminal_names(root, terminal_map,link_map):
    """Extracts conductor data and resolves terminal UUIDs to names"""
    conductors = []

    seenlinks = []
    
    for conductor in root.iter('conductor'):
        start_uuid = conductor.get('terminal1')
        end_uuid = conductor.get('terminal2')


        element1_name = conductor.get('element1_name')
        element1_label = conductor.get('element1_label')
        element1_uuid =conductor.get('element1')
        
        element2_name = conductor.get('element2_name')
        element2_label = conductor.get('element2_label')
        element2_uuid =conductor.get('element2')

        seen = False

        
        if(conductor.get('element1_name') == "Going arrow" or conductor.get('element1_name') == "Coming arrow"):
            element1_name = "*****";
            print("Element 1 is a reference")
            print(f"Element 1 uuid = {element1_uuid}")
            ele = find_element_by_uuid(root,element1_uuid )
            if ele is not None:
                links_node = ele.find('links_uuids')
                if links_node is not None:
                    for link in links_node.findall('link_uuid'):
                        link_uuid = link.get('uuid')
                        if link_uuid:

                            if link_uuid in seenlinks:
                                print(f"link uuuid {link_uuid} already seen")
                                seen=True
                            else:
                                print(f"Element 1 link uuuid {link_uuid}")
                                for conductor2 in root.iter('conductor'):
                                    if conductor2.get('element2') == link_uuid:
                                        print(f"adding {element1_uuid}")
                                        seenlinks.append(element1_uuid)
                                        element1_name = conductor2.get('element1_name')
                                        element1_label = conductor2.get('element1_label')
                                        element1_uuid = conductor2.get('element1')
                                        start_uuid = conductor2.get('terminal1')
                                    if conductor2.get('element1') == link_uuid:
                                        print(f"adding {element2_uuid}")
                                        seenlinks.append(element2_uuid)
                                        element1_name = conductor2.get('element2_name')
                                        element1_label = conductor2.get('element2_label')
                                        element1_uuid = conductor2.get('element2')
                                        start_uuid = conductor2.get('terminal2')
                                      
             
        if(conductor.get('element2_name') == "Going arrow" or conductor.get('element2_name') == "Coming arrow"):
            print("Element 2 is a reference")
            print(f"Element 2 uuid = {element2_uuid}")
            ele = find_element_by_uuid(root,element2_uuid )
            if ele is not None:
                links_node = ele.find('links_uuids')
                if links_node is not None:
                    for link in links_node.findall('link_uuid'):
                        link_uuid = link.get('uuid')
                        if link_uuid:
                            if link_uuid in seenlinks:
                                print(f"link uuuid {link_uuid} already seen")
                                seen=True
                            else: 
                                print(f"Element 2 link uuuid {link_uuid}")
                                for conductor2 in root.iter('conductor'):
                                    if conductor2.get('element1') == link_uuid:
                                        print(f"adding {element2_uuid}")
                                        seenlinks.append(element2_uuid)
                                        element2_name = conductor2.get('element2_name')
                                        element2_label = conductor2.get('element2_label')
                                        element2_uuid = conductor2.get('element2')
                                        end_uuid = conductor2.get('terminal2')
                                    if conductor2.get('element2') == link_uuid:
                                        print(f"adding {element1_uuid}")
                                        seenlinks.append(element1_uuid)
                                        element2_name = conductor2.get('element1_name')
                                        element2_label = conductor2.get('element1_label')
                                        element2_uuid = conductor2.get('element1')
                                        end_uuid = conductor2.get('terminal1')
                                       
            

        ele1 = find_element_by_uuid(root,element1_uuid )
        ele2 = find_element_by_uuid(root,element2_uuid )

        element1_loc = ""
        element2_loc = ""
        
        info_container = ele1.find('elementInformations')
        if info_container is not None:
            for elem in info_container.findall('elementInformation'):
                if elem.attrib.get('name') == 'location':
                    element1_loc = elem.text

        info_container = ele2.find('elementInformations')
        if info_container is not None:
            for elem in info_container.findall('elementInformation'):
                if elem.attrib.get('name') == 'location':
                    element2_loc = elem.text

        
        if seen == False :


            if not element1_loc:
                print(f"Element1 loc is empty")
                parent = find_parent_by_uuid(root,element1_uuid)
                if parent:
                    element1_loc = "+"+parent.get('locmach')

            if not element2_loc:
                print(f"Element2 loc is empty")
                parent = find_parent_by_uuid(root,element2_uuid)
                if parent:
                    element2_loc = "+"+parent.get('locmach')
                
                
            conductors.append({
                'S LOC': element1_loc,
                'S PART': element1_name,
                'S DESIGNATOR': element1_label,
                'S TERMINAL': terminal_map.get(start_uuid),
                'E LOC': element2_loc,
                'E PART': element2_name,
                'E DESIGNATOR': element2_label,
                'E TERMINAL': terminal_map.get(end_uuid),
                'Conductor Section': conductor.get('conductor_section'),
                'Conductor Function': conductor.get('function'),
                'Color': conductor.get('conductor_color'),
                'Designator': conductor.get('num')
        })
    return conductors

def process_qet_file(file_path, output_csv='conductors_named.csv'):
    qet_path = extract_content_qet(file_path)
    tree = ET.parse(qet_path)
    root = tree.getroot()

    terminal_map = build_terminal_uuid_map(root)
    link_map = build_link_uuid_map(root)
    conductors = extract_conductors_with_terminal_names(root, terminal_map,link_map)

    # Output to CSV
    if conductors:
        with open(output_csv, 'w', newline='') as f:
            writer = csv.DictWriter(f, fieldnames=conductors[0].keys())
            writer.writeheader()
            writer.writerows(conductors)
        print(f"Exported {len(conductors)} conductors to {output_csv}")
    else:
        print("No conductors found.")

# Example usage
if __name__ == "__main__":
    process_qet_file("c:\\yourfile.qet")
        

Input: Starting number, Increment, Y increment in pixels, Max height in pixels. It will generate code to copy to the clipboard which you can then paste into your folio in QElectroTech.

Die Datei ist zu groß zum hochladen im Forum und auf Github. Nur der Quellcode liegt unter:
https://github.com/Kellermorph/qet-seiten-editor
Der ganze Ordner inkl. der virtuellen Umgebung und das Appimage können 3 Tage lange über folgenden Link heruntergeladen werden:

https://we.tl/t-W9rk4KDexC

Die Datei ist ein Erst-Entwurf. Über Feedback würde ich mich freuen.

Hello everyone
I have built a new function that may also be helpful to you.
It's about creating your own templates, which you can then integrate into a .qet file.
There are 3 buttons at the top. Select qet file, import components, load page library
First you have to select the .qet file. Then you have to add all the components you want to use (your own and, if you use them, those provided by QElectrotech) to the .qet file so that the templates can find them.
The page library must then be loaded.
Here the files must be saved as .txt. Subfolders are possible in the library, creating tabs in the GUI.
The respective .txt files are now listed in these tabs. These can now be imported after entering the page title and these are written to the next higher page.
You can create the .txt file yourself by opening the .qet file with a text editor and then copying and saving the entire page.

The file is too large to upload to the forum and Github. Only the source code can be found at:
https://github.com/Kellermorph/qet-seiten-editor
The whole folder including the virtual environment and the app image can be downloaded for 3 days via the following link:

https://we.tl/t-W9rk4KDexC

The file is a first draft. I would be pleased to receive feedback.

In the company where I work, Faramax, we have created (with the help of AI, because we are not code programmers), this program in Phyton to create links between references in a .pdf file
This is a stopgap while the integrated function in QET is being developed, which would be great. Wish we could help with this, but as I said we are not programmers.
We have based it on this, but I prefer to create a new topic so we don't mix up the posts: https://qelectrotech.org/forum/viewtopic.php?id=2915

This program have calibration and adjustment options. It does not acquire the positions of the QET elements, but creates a virtual grid that must be adjusted with the row, column and px values that it adjusts in the QET sheets.
Alse, the program have additional offset settings for fine tuning.

When the program finds a relation to the selected structure, it creates a link to the target page and grid position, with the selected settings and zoom.

Attached you can find the programme in .py and in a ready for windows .exe inside the .rar

Hopefully this tool will be useful to many people, until QET integrates the function to include the links in the exported pdf.

I would also like to thank the developers of this fantastic tool that helps a lot of people.

BR,
Alfonso.

ich habe mir 3 extra Funktionen per externen Programm geschrieben.
Die erste Funktion ist die Klemmen aus der .qet Datei auszulesen und neu durch zu nummerieren.
Hierbei werden die Klemmen nach BMK sortiert. Also alles vor dem Doppelpunkt. Dort wird die Sortierung / Nummerierung von vorne Seitenweise vorgenommen und dann erst entlang der X-Achse. Sollten 2 Klemmen die gleiche X-Achse haben, wird die höhere (niedriger Y-Wert) zuerst genommen. Daraus wird dann im Verzeichnis eine neue .qet Datei erstellt.

Die 2. Funktion ist eine Kabelliste erstellen. Hierbei müssen Kabel wie in meiner mit hochgeladenen Datei definiert sein. Hier wird nun jedes Einzelbauteil (simple) mit einem BMK das W drin hat gesucht. Dann werden die Conductor Einträge abgesucht und dort wird nach Y-Wert der Startpunkt und der Zielpunkt festgelegt. Die Ausgabe erfolgt per .csv

Die 3. Funktion ist eine Klemmenliste. Die Vorgehensweise ist ähnlich wie die der Kabelliste, nur dass die Funktionen der Leitungen überprüft werden und wenn es die gleiche ist, wird in einer Spalte bei Brücken ein Punkt gesetzt. Die nächste Funktion wird dementsprechend in die nächste Spalte gesetzt. Auch hier erfolgt die Ausgabe per CSV.

Ich habe 2 Tabellen angehangen, in die man die .csv dann einfach reinkopieren kann. Dann kann man eine PDF erstellen und diese zu einer PNG umwandeln um die in QElectrotech zu integrieren. Die Optik ist nahe der Tabelle von QElectrotech. Eine Beispiel .qet Datei ist auch dabei

Translation:
Hello everyone,

I have written 3 extra functions using an external program.
The first function is to read the terminals from the .qet file and renumber them.
The terminals are sorted according to BMK. So everything before the colon. There the sorting / numbering is done page by page from the front and then along the X-axis. If 2 terminals have the same X-axis, the higher one (lower Y-value) is taken first. A new .qet file is then created from this in the directory.

The 2nd function is to create a cable list. Cables must be defined as in my uploaded file. Each individual component (simple) with a BMK that has W in it is now searched for here. Then the conductor entries are searched and the start point and the target point are defined according to the Y value. The output is via .csv

The 3rd function is a terminal list. The procedure is similar to that of the cable list, except that the functions of the lines are checked and if it is the same, a point is set in a column for bridges. The next function is placed in the next column accordingly. Here too, the output is via CSV.

I have attached 2 tables into which you can simply copy the .csv. Then you can create a PDF and convert it to a PNG to integrate it into QElectrotech. The look is similar to the QElectrotech table. An example .qet file is also included

Translated with DeepL.com (free version)

ich habe mich mal an einem Klemmenplan versucht. Das ist tatsächlich mein erstes Programm. In Python, C++ bin ich nicht durchgestiegen.

Die angehängten QET-Files können zum Ausprobieren verwendet werden, weil die Klemmentabelle nur mit bestimmtem Klemmenaufbau funktioniert.

Viele Grüße
         Xander