A cross-platform G-Code sender for GRBL, Smoothieware, TinyG and G2core.
A cross-platform G-Code sender for GRBL, Smoothieware, TinyG and G2core.
For development we use [Maven](http://maven.apache.org) and [Java 25](https://adoptium.net/) for compiling. On Windows you might need to install `zip`: ``` winget install -e --id GnuWin32.Zip ``` #### Compiling and starting the application UGS Classic: ```bash ./mvnw install ./mvnw exec:java -Dexec.mainClass="com.willwinder.universalgcodesender.MainWindow" -pl ugs-core ``` UGS Platform: ```bash ./mvnw install ./mvnw nbm:run-platform -pl ugs-platform/application ``` #### Execute all tests ```bash ./mvnw test ``` #### Building the self-executing JAR ```bash ./mvnw install ./mvnw package -pl ugs-classic ``` #### Build a UniversalGcodeSender.zip release file ```bash ./mvnw package -pl ugs-classic assembly:assembly ``` #### Develop via IntelliJ If you are more used to IntelliJ, you can also build, run and debug it there. - Run `./mvnw nbm:run-platform -pl ugs-platform/application` once via terminal to build everything - Import the Source, `File` -> `New` -> `Project from existing Sources` - Setup a new "Run Configuration", `Java Application`, with following settings: - Main Class: `org.netbeans.Main` - VM Options: ``` … ``` - Program arguments: `--branding ugsplatform` - Working dir: `$ProjectFileDir$` - Use classpath of module: `ugs-platform-app` - There is a [runConfiguration](.idea/runConfigurations/UGS_Platform.xml) in the repository, which should be available after importing the project
Show code documentation.### High-Level Architecture 1. **Core Module (`ugs-core`)**: This is the heart of UGS. It contains: * **Communication Layer**: Handles serial communication (or other protocols like TCP/IP for some controllers) with the CNC machine's firmware (e.g., GRBL). It translates G-code commands into signals the controller understands and interprets responses from the controller. * **G-code Parser and Interpreter**: Processes G-code files, breaks them down into individual commands, and manages the sending sequence. * **Machine State Management**: Keeps track of the machine's current position (X, Y, Z coordinates), feed rate, spindle speed, and other relevant operational parameters. This is the data that populates the "Controller State (DRO)" panel. * **Toolpath Generation/Visualization Logic**: While UGS isn't primarily a CAM (Computer-Aided Manufacturing) software, it contains logic to interpret G-code and generate a visual representation of the toolpath for the user. * **Settings and Configuration Management**: Handles loading and saving user preferences, machine settings, and connection parameters. 2. **Platform/Application Layer (`ugs-platform/application` and other modules)**: This layer builds upon the core functionality and provides the graphical user interface (GUI) and specific features. * **NetBeans Platform**: UGS Platform leverages the NetBeans Platform, which provides a robust framework for building desktop applications. This means the UI is composed of "modules" or "plugins," each responsible for a specific set of functionalities (e.g., a module for the visualizer, a module for the console, a module for the DRO). * **User Interface (UI) Components**: These are the visual elements the user interacts with, such as buttons, text fields, tables, and the visualizer. These components are typically Swing-based (Java's GUI toolkit) or, less commonly, JavaFX. * **Event Handling**: Manages user interactions (button clicks, keyboard input, mouse movements) and translates them into calls to the core module or other platform services. * **Plugin System**: The modular nature allows for easy addition of new features or customization through plugins. 3. **Third-Party Libraries**: UGS relies on various external libraries for tasks like: * Serial communication (e.g., JSSC - Java Simple Serial Connector). * 3D visualization (e.g., JOGL for OpenGL integration). * Logging. * JSON parsing (for settings). ### UI elements The user-interface elements of ugs-platform can be found in the `ugs-platform` folder. Each window in the platform-application is a Panel object. We list differnt ui elements together with their location below: - Controller State (DRO): This is the window to see the current state of the machine (connected/disconnected) and its current position. The code is located under `ugs-platform/ugs-platform-plugin-dro/src/main/java/.../panels/MachineStatusPanel.java`. - Jog Controller: This window contains buttons to jog the machine. The code is located under `ugs-platform/ugs-platform-plugin-jog/src/main/java/.../jog/JogPannel.java`. In the resources folder, you will find svg images which are displayed inside the jog buttons. - Overrides pannel: `ugs-core/src/com/.../uielements/panels/OverridesPanel.java`. - language-specific text: In the folder `ugs-core/src/com/.../resources/`, you will find a lot of `.properties` files. These contain language-specific text that is shown to the user, such as label text, button text etc. ### Logs Application logs, including detailed debug messages and error reports, are primarily written to the messages.log file. This file is located within the application's user directory at `ugs-platform/application/target/userdir/var/log/messages.log` when running from the build target. In the event of an unexpected application crash or erratic behavior, reviewing this log file is the first recommended step, as it often contains stack traces and error messages that can pinpoint the root cause of the problem. Additionally, for severe JVM crashes, a `hs_err_pid.log` file might be generated in the application's working directory, offering further low-level diagnostic information.
## Supported byNo open issues yet, or sync has not completed.