I am looking help on defining the POM for my plugin.

[mikeoverbay]

I designed this and it works well. I can easily send commands to UGS but grabbing data and keeping my jogbox in sync has be an issue.
Currently. I am getting these errors from POM
`this is getting old!
The build could not read 1 project -> [Help 1]

The project com.willwinder:ugs-platform-plugin-serialcommand:2.0-SNAPSHOT (C:\Universal-G-Code-Sender\ugs-platform\ugs-platform-plugin-SerialCommand\pom.xml) has 1 error
Non-resolvable parent POM for com.willwinder:ugs-platform-plugin-serialcommand:2.0-SNAPSHOT: The following artifacts could not be resolved: com.willwinder:ugs-platform:pom:2.0-SNAPSHOT (absent): Could not find artifact com.willwinder:ugs-platform:pom:2.0-SNAPSHOT and 'parent.relativePath' points at wrong local POM @ line 8, column 9 -> [Help 2]
Any help with this would be great!
Here's the pom
`

<modelVersion>4.0.0</modelVersion>

<parent>
    <groupId>com.willwinder</groupId>
    <artifactId>ugs-platform</artifactId>
    <version>2.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
</parent>

<groupId>com.willwinder</groupId>
<artifactId>ugs-platform-plugin-serialcommand</artifactId>
<version>2.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>SerialCommand Plugin</name>

<dependencies>
    <!-- Serial communication -->
    <dependency>
        <groupId>com.fazecast</groupId>
        <artifactId>jSerialComm</artifactId>
        <version>2.9.3</version>
    </dependency>

    <!-- UGS Core backend API -->
    <dependency>
        <groupId>com.willwinder</groupId>
        <artifactId>ugs-core</artifactId>
        <version>${project.version}</version>
        <scope>provided</scope>
    </dependency>

    <!-- UGS Platform API -->
    <dependency>
        <groupId>com.willwinder</groupId>
        <artifactId>ugs-platform-api</artifactId>
        <version>${project.version}</version>
        <scope>provided</scope>
    </dependency>

    <!-- CentralLookup and NetBeans bindings -->
    <dependency>
        <groupId>com.willwinder</groupId>
        <artifactId>ugs-platform-lib</artifactId>
        <version>${project.version}</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>nbm-maven-plugin</artifactId>
            <version>4.5</version>
            <extensions>true</extensions>
        </plugin>
    </plugins>
</build>

`

Here's my code for my plugin.

// CNC Controller Plugin
package com.willwinder.ugs.nbp.serialcommand;

import com.fazecast.jSerialComm.SerialPort;
import com.willwinder.universalgcodesender.model.Axis;
import com.willwinder.universalgcodesender.model.BackendAPI;
import com.willwinder.universalgcodesender.model.BackendAPIReadOnly;
import com.willwinder.universalgcodesender.model.Position;
import com.willwinder.universalgcodesender.model.UGSEvent;
import com.willwinder.universalgcodesender.model.UnitUtils.Units;
import com.willwinder.universalgcodesender.services.JogService;
import com.willwinder.ugs.nbp.lib.lookup.CentralLookup;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Scanner;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.openide.modules.OnStart;
import org.openide.util.lookup.ServiceProvider;
import org.openide.windows.IOProvider;
import org.openide.windows.InputOutput;

@OnStart
@ServiceProvider(service = Runnable.class)
public class SerialCommand implements Runnable {

    private static final int BAUD_RATE = 9600;

    private SerialPort activePort;
    private OutputStream serialOut;
    private boolean connected = false;
    private volatile boolean dirty = false;
    private long lastUpdateTime = 0;
    private final ExecutorService updateExecutor = Executors.newSingleThreadExecutor();
    private JogService jogService;
    private BackendAPIReadOnly apiReadOnly;
    private Timer heartbeatTimer;
    private volatile boolean ackReceived = false;
    private volatile long lastAckSent = 0;
    private final ByteBuffer buffer = ByteBuffer.allocate(38);

    static class MachineStatus {
        float x, y, z, a;
        byte status;
        float feedRate, line, total;
        float stepXY;
    }

    public SerialCommand() {
        this.jogService = null;
    }

    @Override
    public void run() {
        jogService = CentralLookup.getDefault().lookup(JogService.class);
        new Thread(this::startSerialConnection).start();
    }

    private void startSerialConnection() {
        InputOutput io = IOProvider.getDefault().getIO("SerialCommand", true);
        io.select();

        try {
            SerialPort selected = null;
            for (SerialPort port : SerialPort.getCommPorts()) {
                port.setBaudRate(BAUD_RATE);
                port.setComPortTimeouts(SerialPort.TIMEOUT_NONBLOCKING, 0, 0);
                if (!port.openPort()) {
                    continue;
                }

                Scanner scanner = new Scanner(port.getInputStream());
                Thread.sleep(100);
                boolean found = false;

                while (scanner.hasNextLine()) {
                    String line = scanner.nextLine().trim();
                    if ("CONREQ".equals(line)) {
                        serialOut = port.getOutputStream();
                        serialOut.write("CONACK\n".getBytes());
                        serialOut.flush();
                        lastAckSent = System.currentTimeMillis();
                        selected = port;
                        found = true;
                        break;
                    }
                }

                if (!found) {
                    port.closePort();
                } else {
                    break;
                }
            }

            if (selected == null) {
                return;
            }

            activePort = selected;
            serialOut = activePort.getOutputStream();

            apiReadOnly = CentralLookup.getDefault().lookup(BackendAPIReadOnly.class);
            if (apiReadOnly != null) {
                apiReadOnly.addUGSEventListener(e -> {
                    InputOutput debugIO = IOProvider.getDefault().getIO("SerialCommand", false);
                    debugIO.getOut().println("[UGS Event] Received: " + e + " (class: " + e.getClass().getSimpleName() + ")");
                    scheduleUpdate(false);
                });
                dirty = false;
                lastUpdateTime = 0;
                scheduleUpdate(false);
            }

            connected = true;
            startHeartbeat(io);

        } catch (Exception ex) {
        }
    }

    private void startHeartbeat(InputOutput io) {
        heartbeatTimer = new Timer();
        heartbeatTimer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                if (!connected) {
                    startSerialConnection();
                    return;
                } else {

                    try {
                        long now = System.currentTimeMillis();
                        if (serialOut != null) {
                            serialOut.write("ACK\n".getBytes());
                            serialOut.flush();
                            lastAckSent = now;
                        }

                        if (!ackReceived && (now - lastAckSent > 10000)) {
                            connected = false;
                            heartbeatTimer.cancel();
                            if (activePort != null) {
                                activePort.closePort();
                            }
                            return;
                        }
                        ackReceived = false;

                        InputStream in = activePort.getInputStream();
                        Scanner scanner = new Scanner(in);
                        scanner.useDelimiter("\\r?\\n");

                        while (activePort.bytesAvailable() > 0 && scanner.hasNext()) {
                            String line = scanner.next().trim();
                            if (line.startsWith("KEY:")) {
                                int code = Integer.parseInt(line.substring(4));
                                handleCode(code, io);
                                scheduleUpdate(true);
                            } else if ("ACK".equals(line)) {
                                ackReceived = true;
                            } else if ("REQ".equals(line)) {
                                scheduleUpdate(true);
                            }
                        }

                    } catch (Exception e) {
                        connected = false;
                    }
                }
            }
        }, 0, 20);
    }

    private void scheduleUpdate() {
        scheduleUpdate(false);
    }

    private void scheduleUpdate(boolean force) {
        CollectStatus();
        long now = System.currentTimeMillis();
        if (force || (!dirty && (now - lastUpdateTime >= 300))) {
            dirty = true;
            lastUpdateTime = now;
            updateExecutor.submit(this::PushBuffer);
        }
    }

    private void PushBuffer() {
        if (!connected || apiReadOnly == null || !dirty) {
            return;
        }

        try {
            if (activePort != null && activePort.bytesAwaitingWrite() > 0) {
                return;
            }

            serialOut.write(buffer.array());
            serialOut.flush();
            dirty = false;

        } catch (Exception e) {
        }
    }

    private void CollectStatus() {
        Position p = apiReadOnly.getWorkPosition();
        boolean metric = (jogService.getUnits() == Units.MM);

        double x = p.getX(), y = p.getY(), z = p.getZ(), a = Double.isNaN(p.getA()) ? 0 : p.getA();
        if (!metric) {
            x /= 25.4;
            y /= 25.4;
            z /= 25.4;
            a /= 25.4;
        }

        long total = apiReadOnly.getNumRows();
        long sent = apiReadOnly.getNumSentRows();
        int feedRate = CentralLookup.getDefault().lookup(JogService.class).getFeedRate();
        float stepXY = (float) jogService.getStepSizeXY();
        byte status = (byte) (apiReadOnly.isPaused() ? 1 : apiReadOnly.isSendingFile() ? 2 : apiReadOnly.isIdle() ? 0 : 3);

        MachineStatus m = new MachineStatus();
        m.x = (float) x;
        m.y = (float) y;
        m.z = (float) z;
        m.a = (float) a;
        m.status = status;
        m.feedRate = (float) feedRate;
        m.line = (float) sent;
        m.total = (float) total;
        m.stepXY = stepXY;

        buffer.clear();
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        buffer.put("SYNC\n".getBytes());
        buffer.putFloat(Float.intBitsToFloat(Integer.reverseBytes(Float.floatToIntBits(m.x))));
        buffer.putFloat(Float.intBitsToFloat(Integer.reverseBytes(Float.floatToIntBits(m.y))));
        buffer.putFloat(Float.intBitsToFloat(Integer.reverseBytes(Float.floatToIntBits(m.z))));
        buffer.putFloat(Float.intBitsToFloat(Integer.reverseBytes(Float.floatToIntBits(m.a))));
        buffer.put(m.status);
        buffer.putFloat(Float.intBitsToFloat(Integer.reverseBytes(Float.floatToIntBits(m.feedRate))));
        buffer.putFloat(Float.intBitsToFloat(Integer.reverseBytes(Float.floatToIntBits(m.line))));
        buffer.putFloat(Float.intBitsToFloat(Integer.reverseBytes(Float.floatToIntBits(m.total))));
        buffer.putFloat(Float.intBitsToFloat(Integer.reverseBytes(Float.floatToIntBits(m.stepXY))));
    }

    private void handleCode(int code, InputOutput io) {
        BackendAPI backend = CentralLookup.getDefault().lookup(BackendAPI.class);
        JogService jog = CentralLookup.getDefault().lookup(JogService.class);
        if (backend == null || jog == null) {
            return;
        }
        try {
            switch (code) {
                case 0: jog.adjustManualLocationZ(-1); break;
                case 1: jog.adjustManualLocationABC(-1, 0, 0); break;
                case 2: jog.adjustManualLocationABC(1, 0, 0); break;
                case 3: jog.adjustManualLocationZ(1); break;
                case 4: jog.adjustManualLocationXY(0, -1); break;
                case 5: jog.adjustManualLocationXY(1, 0); break;
                case 6: jog.adjustManualLocationXY(0, 1); break;
                case 7: jog.adjustManualLocationXY(-1, 0); break;
                case 8: setStep(jog, 0.001); break;
                case 9: setStep(jog, 0.010); break;
                case 10: setStep(jog, 0.100); break;
                case 11: setStep(jog, 1.000); break;
                case 12: backend.resetCoordinateToZero(Axis.A); break;
                case 13: backend.resetCoordinateToZero(Axis.Z); break;
                case 14: backend.resetCoordinateToZero(Axis.Y); break;
                case 15: backend.resetCoordinateToZero(Axis.X); break;
                case 16: backend.sendGcodeCommand("G53 G0 A0"); break;
                case 17: backend.sendGcodeCommand("G53 G0 Z0"); break;
                case 18: backend.sendGcodeCommand("G53 G0 Y0"); break;
                case 19: backend.sendGcodeCommand("G53 G0 X0"); break;
                case 22: backend.returnToZero(); break;
                case 23: backend.performHomingCycle(); break;
                case 25: backend.send(); break;
                case 26: backend.pauseResume(); break;
                case 27: backend.cancel(); break;
            }
        } catch (Exception ex) {
        }
    }

    private static void setStep(JogService j, double v) {
        j.setStepSizeZ(v);
        j.setStepSizeXY(v);
        j.setStepSizeABC(v);
    }
}

And the nano ESP32 which is wired to HC-05 because I was wrong ESP32 on a nano doing classic Bluetooth. I do want to use the wifi laster once this is running.

// CNC Jog Controller
// keyID | Action
// ------|------------------
//   0   | Z-
//   1   | A-
//   2   | Z+
//   3   | Z+
//   4   | Y-
//   5   | X+
//   6   | Y+
//   7   | X-
//   8   | INC 0.001
//   9   | INC 0.010
//  10   | INC 0.100
//  11   | INC 1.000
//  12   | Zero A
//  13   | Zero Z
//  14   | Zero Y
//  15   | Zero X
//  16   | Home A
//  17   | Home Z
//  18   | Home Y
//  19   | Home X
//  22   | Return to Zero
//  23   | Home All
//  25   | Run
//  26   | Pause
//  27   | Stop

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Arduino.h>
#include <HardwareSerial.h>
#include <esp_bt.h>
#include <esp_wifi.h>
#include <stdio.h>
#include <string.h>

// Core data structures
union FloatUnion {
  float f;
  uint8_t b[4];
};

struct PendantStatus {
  float x, y, z, a;
  byte status;
  float feedRate, line, total, stepSize;
};

// LCD abstraction layer
static LiquidCrystal_I2C lcd(0x27, 20, 4);

inline void lcdInitScreen() {
  lcd.init();
  lcd.backlight();
}

inline void lcdClearScreen() {
  lcd.clear();
}

inline void lcdGoTo(uint8_t col, uint8_t row) {
  lcd.setCursor(col, row);
}

inline void lcdPrint(const String &s) {
  lcd.print(s);
}

inline void lcdPrint(const char *s) {
  lcd.print(s);
}

// Serial over Bluetooth
HardwareSerial BTSerial(1);

// Keypad matrix pins
const uint8_t rowPins[] = { D3, D4, D5, D6, D7, D8, A0 };
const uint8_t colPins[] = { D9, D10, D11, D12 };
const uint8_t NUM_ROWS = sizeof(rowPins) / sizeof(rowPins[0]);
const uint8_t NUM_COLS = sizeof(colPins) / sizeof(colPins[0]);
const uint16_t DEBOUNCE_DELAY = 40;
const unsigned long REPEAT_INTERVAL = 600;

// Timing and state
unsigned long lastCounter = 0;
unsigned long lastAckTime = 0;
const unsigned long ACK_TIMEOUT = 10000;
bool connected = false;
bool waitingForSync = false;
String buffer;

// Read a big-endian float from a stream
bool readFloat(Stream &s, float &outVal) {
  uint8_t raw[4];
  for (int i = 0; i < 4; ++i) {
    int c = s.read();
    if (c < 0) return false;
    raw[3 - i] = (uint8_t)c;
  }
  FloatUnion u;
  memcpy(u.b, raw, 4);
  outVal = u.f;
  return true;
}

// Parse the PendantStatus packet
bool readPendantStatus(Stream &s, PendantStatus &p) {
  delay(30);
  if (!readFloat(s, p.x)) return false;
  if (!readFloat(s, p.y)) return false;
  if (!readFloat(s, p.z)) return false;
  if (!readFloat(s, p.a)) return false;
  int st = s.read();
  if (st < 0) return false;
  p.status = (byte)st;
  if (!readFloat(s, p.feedRate)) return false;
  if (!readFloat(s, p.line)) return false;
  if (!readFloat(s, p.total)) return false;
  if (!readFloat(s, p.stepSize)) return false;
  return true;
}

// Convert status code to text
const char *getState(byte status) {
  switch (status) {
    case 0: return "IDLE";
    case 1: return "HALT";
    case 2: return "RUN";
    default: return "BUSY";
  }
}

// Right-pad a string to length
String padRight(const String &input, size_t width = 10) {
  String s = input;
  while (s.length() < width) s += ' ';
  return s;
}

String padRight20(const String &input) {
  return padRight(input, 20);
}

// Display the pendant status on the LCD
void printPendantStatus(const PendantStatus &p) {
  lcdGoTo(0, 0);
  lcdPrint(padRight("X" + String(p.x, 3)) + padRight("Y" + String(p.y, 3)));

  lcdGoTo(0, 1);
  lcdPrint(padRight("Z" + String(p.z, 3)) + padRight("Step:" + String(p.stepSize, 3)));

  lcdGoTo(0, 2);
  lcdPrint(padRight("F" + String(p.feedRate, 1)) + padRight(getState(p.status)));

  lcdGoTo(0, 3);
  lcdPrint(padRight20("L" + String(p.line, 0) + "/" + String(p.total, 0)));
}

// Send a key command and immediately request new data
void Send_To_Keyout(int keyID) {
  if (keyID == 99 || keyID == -1) return;

  // Flush pending incoming data
  while (BTSerial.available()) {
    String garbage = BTSerial.readStringUntil('\n');
    garbage.trim();
    if (garbage == "UGS") lastAckTime = millis();
  }

  // Send keypress and then data request
  BTSerial.print("KEY:");
  BTSerial.println(keyID);
  delay(30);  // allow host to process
  BTSerial.println("REQ");
  waitingForSync = true;
}

// Scan the button matrix for a pressed key
int scanMatrix() {
  for (uint8_t r = 0; r < NUM_ROWS; ++r) {
    digitalWrite(rowPins[r], HIGH);
    delayMicroseconds(300);
    for (uint8_t c = 0; c < NUM_COLS; ++c) {
      if (digitalRead(colPins[c]) == HIGH) {
        delay(DEBOUNCE_DELAY);
        if (digitalRead(colPins[c]) == HIGH) {
          digitalWrite(rowPins[r], LOW);
          return r * NUM_COLS + c;
        }
      }
    }
    digitalWrite(rowPins[r], LOW);
  }
  return -1;
}

// Handle key action logic (including double-tap for modifiers)
void handleCommand(int keyID) {
  static int prevCmd = -1;
  static bool running = false, paused = false;

  switch (keyID) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
      Send_To_Keyout(keyID);
      break;

    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 22:
    case 23:
      if (prevCmd == keyID) {
        Send_To_Keyout(keyID);
        prevCmd = -1;
      } else {
        prevCmd = keyID;
      }
      break;

    case 25:
      if (!running) {
        running = true;
        Send_To_Keyout(keyID);
      }
      break;

    case 26:
      if (running) {
        paused = !paused;
        Send_To_Keyout(keyID);
      }
      break;

    case 27:
      if (running || paused) {
        running = paused = false;
        Send_To_Keyout(keyID);
      }
      break;

    default:
      prevCmd = -1;
      break;
  }
}

// Visual indicator during reconnect
int pos = 0;
void Indicator() {
  lcdGoTo(0, 3);
  lcdPrint("                    ");
  lcdGoTo(pos, 3);
  lcdPrint("*");
  if (++pos > 19) pos = 0;
}

// Attempt to establish connection with host
void reconnect() {
  lcdClearScreen();
  lcdGoTo(0, 0);
  lcdPrint(" - CNC Controller - ");
  lcdGoTo(0, 1);
  lcdPrint("UGS Disconnected");
  lcdGoTo(0, 2);
  lcdPrint("Reconnecting...");

  while (true) {
    BTSerial.println("CONREQ");
    if (BTSerial.available()) {
      String resp = BTSerial.readStringUntil('\n');
      if (resp == "CONACK") {
        lcdClearScreen();
        lcdGoTo(0, 0);
        lcdPrint(" - CNC Controller - ");
        lcdGoTo(0, 1);
        lcdPrint("UGS Connected");

        connected = true;
        BTSerial.println("REQ");
        BTSerial.flush();
        delay(100);
        waitingForSync = true;
        lastAckTime = millis();
        break;
      }
    }
    Indicator();
    delay(500);
  }
}

void setup() {
  esp_bt_controller_disable();
  esp_wifi_stop();
  delay(2000);

  Serial.begin(115200);
  BTSerial.begin(9600, SERIAL_8N1, A3, A2);
  Wire.begin(21, 22);

  lcdInitScreen();

  for (uint8_t i = 0; i < NUM_ROWS; i++) {
    pinMode(rowPins[i], OUTPUT);
    digitalWrite(rowPins[i], LOW);
  }
  for (uint8_t i = 0; i < NUM_COLS; i++) {
    pinMode(colPins[i], INPUT_PULLDOWN);
  }

  reconnect();
}

void loop() {
  unsigned long now = millis();
  static int holdKey = -1;
  static unsigned long lastRepeat = 0;

  if (connected) {
    int keyID = scanMatrix();
    if (keyID >= 0 && keyID != holdKey) {
      holdKey = keyID;
      lastRepeat = now;
      handleCommand(keyID);
    } else if (keyID == holdKey && keyID <= 7 && now - lastRepeat >= REPEAT_INTERVAL) {
      Send_To_Keyout(keyID);
      lastRepeat = now;
    } else if (keyID != holdKey) {
      holdKey = -1;
    }

    if (now - lastCounter >= 1000) {
      lastCounter = now;
      BTSerial.println("NANO");
    }
  }

  if (connected && !waitingForSync) {
    BTSerial.println("REQ");
    waitingForSync = true;
  }

while (connected && BTSerial.available()) {
  char c = BTSerial.read();
  if (c == '\r') continue; // Skip CR if any
  buffer += c;
  if (c == '\n') {
    buffer.trim();  // remove \r or space
    Serial.print("BUFFER: [");
    Serial.print(buffer);
    Serial.println("]");

    if (buffer.startsWith("SYNC")) {
      delay(10);
      PendantStatus p;
      if (readPendantStatus(BTSerial, p)) {
        printPendantStatus(p);
      }
      waitingForSync = false;
    } else if (buffer == "UGS") {
      lastAckTime = now;
    }
    buffer.clear();
  }
}


  if (connected && (millis() - lastAckTime > ACK_TIMEOUT)) {
    connected = false;
    reconnect();
  }
}

[breiler]

Have a look at:
https://github.com/winder/Universal-G-Code-Sender/blob/master/ugs-platform/ugs-platform-plugin-jog/pom.xml

Fix your parent so that it looks more like this:

    <parent>
        <groupId>com.willwinder</groupId>
        <artifactId>ugs-platform-parent</artifactId>
        <version>${revision}${changelist}</version>
    </parent>

Your packaging needs to be nbm:

    <packaging>nbm</packaging>

[mikeoverbay]

<packaging>nbm</packaging>
Throws a unknown packaging :(

TY for helping!

[breiler]

You will have to fork the github project and push a branch that I can have a look at.

[mikeoverbay]

I have have forked and pushed my changes to it
ugs-platform-plugin-serialcommand is a new project.
Fork https://github.com/mikeoverbay/Universal-G-Code-Sender/tree/mikeschanges
Thank you!

[mikeoverbay]

I sorted most of this out.
Now, I just need to sort out getting the data in and out and not missing anything.