Stop command doesn't work properly on raspberry pi- java implementation

[Hardin22]

Hello everyone,

I'm developing a software application designed to run on a Raspberry Pi as part of a smart chessboard project. The board will feature a touchscreen display. While my code is still a work in progress and somewhat poorly written (I apologize for that), it functions perfectly on my Mac, particularly in the Game Review section. This section is where multiple calculation commands are sent to Stockfish, depending on how quickly the user scrolls through the positions.

The main issue arises when I try to scroll quickly through the positions during Game Review. On my MacBook, the Stop Calculating function works flawlessly. No matter how quickly I click the forward and backward buttons to review the game, the software never crashes or freezes, and I consistently receive the log message "Stockfish has stopped calculating" as expected.

However, when I run the same software on a Raspberry Pi, the stop message frequently fails to appear, regardless of the maximum depth I set for calculations. I've tried various configurations, but nothing has worked so far.

My primary question is: at a high, production-ready level, how can I ensure that the stop command is sent reliably without errors, regardless of how quickly the commands are being issued?

Any insights or suggestions would be really really appreciated, I care a lot about this project and would like to complete it.

Thank you!

link to repo: https://github.com/Hardin22/JavaChessBoard.git

code for the stockfish class:

package org.example.javachess.Oggetti;
import com.github.bhlangonijr.chesslib.Board;
import com.github.bhlangonijr.chesslib.Square;
import com.github.bhlangonijr.chesslib.move.Move;
import com.github.bhlangonijr.chesslib.move.MoveException;
import javafx.application.Platform;
import javafx.scene.control.Label;
import java.io.*;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javafx.scene.paint.Color;
import org.example.javachess.Utils.ChessMoveConverter;

public class Stockfish {

private Process process1; // Per la valutazione della posizione
private Process process3; // Per ottenere le prime tre mosse migliori
private BufferedReader reader1;
private BufferedReader reader3;
private OutputStreamWriter writer1;
private OutputStreamWriter writer3;
private ChessMoveConverter ChessMoveConverter = new ChessMoveConverter();

// Aggiungi questa variabile per il livello di abilità
private int skillLevel;
public Stockfish(String stockfishPath) {
    try {
        String line;

        ProcessBuilder pb3 = new ProcessBuilder(stockfishPath);
        process3 = pb3.start();
        reader3 = new BufferedReader(new InputStreamReader(process3.getInputStream()));
        writer3 = new OutputStreamWriter(process3.getOutputStream());

        writer3.write("uci\n");
        writer3.flush();

        while ((line = reader3.readLine()) != null) {
            System.out.println("Stockfish output: " + line); // Print each line for debugging
            if (line.equals("uciok")) {
                break;
            }
        }

        // Set the number of threads
        writer3.write("setoption name Threads value 2\n");
        writer3.flush();
        System.out.println("Set Stockfish to use 2 threads.");

        // Set the hash size (e.g., 64 MB)
        writer3.write("setoption name Hash value 64\n");
        writer3.flush();
        System.out.println("Set Stockfish hash value to 64 MB.");

        // Confirm options are set
        writer3.write("isready\n");
        writer3.flush();

        while ((line = reader3.readLine()) != null) {
            System.out.println("Stockfish output: " + line); // Print confirmation output
            if (line.equals("readyok")) {
                System.out.println("Stockfish is ready.");
                break;
            }
        }

    } catch (Exception e) {
        e.printStackTrace();
    }
}




// Funzione per impostare il livello di abilità
public void setSkillLevel(int skillLevel) {
    this.skillLevel = skillLevel;
    try {
        writer1.write("setoption name Skill Level value " + skillLevel + "\n");
        writer1.flush();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

// Funzione per ottenere la migliore mossa a seconda del livello di abilità

public String getBestMove(String fen) {
    try {
        writer1.write("position fen " + fen + "\n");
        writer1.flush();

        writer1.write("go depth 10\n");
        writer1.flush();

        String line;
        while ((line = reader1.readLine()) != null) {
            if (line.startsWith("bestmove")) {
                return line.split(" ")[1];
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

private volatile boolean isCalculating = false;
// Funzione per valutare la posizione


Color LIGHT_ORANGE = Color.rgb(242, 198, 126);
Color LIGHT_GREEN = Color.rgb(175, 199, 119);





    // ... (altri metodi esistenti)

public Map<Square, Double> evaluateMovesForPiece(Board board, Square pieceSquare, double currentEvaluation) {
    Map<Square, Double> moveEvaluations = new HashMap<>();
    ChessHelper chessHelper = new ChessHelper();

    try {
        // Ottieni tutte le mosse legali per il pezzo selezionato
        List<Square> legalMoves = chessHelper.getLegalMovesForPiece(board, pieceSquare);

        // Valuta ciascuna mossa
        for (Square toSquare : legalMoves) {
            Board tempBoard = new Board();
            tempBoard.loadFromFen(board.getFen());
            Move move = new Move(pieceSquare, toSquare);
            tempBoard.doMove(move);

            // Utilizza il writer1 per valutare rapidamente la posizione
            writer1.write("position fen " + tempBoard.getFen() + "\n");
            writer1.flush();

            writer1.write("go depth 7\n"); // Profondità bassa per velocità
            writer1.flush();

            String line;
            double evaluation = 0.0;
            boolean isMate = false;

            while ((line = reader1.readLine()) != null) {
                if (line.startsWith("info depth 7")) {
                    String[] parts = line.split(" ");
                    int scoreIndex = Arrays.asList(parts).indexOf("score");
                    if (scoreIndex != -1) {
                        String scoreType = parts[scoreIndex + 1];
                        if (scoreType.equals("cp")) {
                            evaluation = Integer.parseInt(parts[scoreIndex + 2]) / 100.0;
                        } else if (scoreType.equals("mate")) {
                            int mateIn = Integer.parseInt(parts[scoreIndex + 2]);
                            evaluation = mateIn > 0 ? 100.0 : -100.0;  // Usa 100 per rappresentare il matto
                            isMate = true; // Indica che si tratta di un matto
                        }
                    }
                } else if (line.startsWith("bestmove")) {
                    break;
                }
            }

            System.out.println("Evaluation for " + toSquare + ": " + evaluation);

            // Calcola la differenza tra la valutazione attuale e quella della nuova posizione
            double evaluationDifference;
            if (isMate) {
                // Per i matti, usa la differenza diretta
                evaluationDifference =currentEvaluation-evaluation;
            } else {
                // Negazione della valutazione per confrontarla correttamente
                evaluationDifference = currentEvaluation - evaluation;
            }

            System.out.println("Evaluation difference: " + evaluationDifference);
            moveEvaluations.put(toSquare, isMate && evaluation == 0.0 ? 0.00 : evaluationDifference);                }
    } catch (Exception e) {
        e.printStackTrace();
    }
        return moveEvaluations;
    }
    //UTILIZZA I VALORI ASSOLUTIIIIIII PORCODIO


// Nuova funzione per valutare le mosse legali di un pezzo

public void highlightLegalMovesWithEvaluation(Board board, Square pieceSquare, ChessBoardUI chessBoard, double currentEvaluation) {
    Map<Square, Double> evaluations = evaluateMovesForPiece(board, pieceSquare, currentEvaluation);

    for (Map.Entry<Square, Double> entry : evaluations.entrySet()) {
        Square toSquare = entry.getKey();
        double evalDifference = entry.getValue();

        Color color;
        if (evalDifference > -0.5) {
            color = Color.GREEN; // Buona mossa
        } else if (evalDifference < 0.5 && evalDifference > -1.0) {
            color = Color.YELLOW; // Mossa neutra o imprecisione
        } else if (evalDifference < -1.0 && evalDifference > -2.0) {
            color = Color.ORANGE; // Errore o mossa sbagliata
        } else {
            color = Color.RED; // Blunder o mossa cattiva
        }

        int col = toSquare.ordinal() % 8;
        int row = 7 - (toSquare.ordinal() / 8);
        chessBoard.highlightSquare(col, row, color);
    }
}








// Funzione per convertire la mossa UCI in coordinate e disegnare la freccia
private void drawArrowFromMove(String moveInUci, ChessBoardUI chessBoard, Color color) {
    // Converti la mossa in coordinate
    int fromCol = moveInUci.charAt(0) - 'a';
    int fromRow = '8' - moveInUci.charAt(1);
    int toCol = moveInUci.charAt(2) - 'a';
    int toRow = '8' - moveInUci.charAt(3);

    // Disegna la freccia sulla scacchiera
    chessBoard.drawArrowOnBoard(fromCol, fromRow, toCol, toRow, color);
}



// Funzione per ottenere le prime tre mosse migliori



// Funzione per chiudere Stockfish
public void close() {
    try {
        if (process1 != null) {
            writer1.write("quit\n");
            writer1.flush();
            writer1.close();
            reader1.close();
            process1.destroy();
        }

        if (process3 != null) {
            writer3.write("quit\n");
            writer3.flush();
            writer3.close();
            reader3.close();
            process3.destroy();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

//test per le linee principali//


public void getTopThreeMoves(String fen, Label move1Label, Label move2Label, Label move3Label, ChessBoardUI chessBoard, Label evaluationLabel, EvalBar evalBar) {
    new Thread(() -> {
        if (isCalculating) {
            stopCalculating(writer3, reader3, process3);
            isCalculating = false;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

        isCalculating = true;
        try {
            writer3.write("setoption name MultiPV value 3\n");
            writer3.flush();

            writer3.write("position fen " + fen + "\n");
            writer3.flush();

            writer3.write("go depth 22\n");
            writer3.flush();

            String line;
            String[] topMoves = new String[3];
            String[] moveEvaluations = new String[3]; // Array per memorizzare le valutazioni
            String[] fullLines = new String[3]; // Array per memorizzare le linee di mosse complete

            while ((line = reader3.readLine()) != null) {
                if (line.startsWith("info depth ")) {
                    processStockfishOutput(line, fen, topMoves, moveEvaluations, fullLines, chessBoard, move1Label, move2Label, move3Label, evaluationLabel, evalBar);
                } else if (line.startsWith("bestmove")) {
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            isCalculating = false;
            System.out.println("calcoli finiti");
        }
    }).start();
}


private void stopCalculating(OutputStreamWriter writer, BufferedReader reader, Process process) {
    try {
        if (process != null) {
            System.out.println("Sending stop command to Stockfish...");
            writer.write("stop\n");
            writer.flush();

            // Wait for confirmation from Stockfish
            String line;
            boolean stopped = false;
            while ((line = reader.readLine()) != null) {
                System.out.println("Received from Stockfish: " + line);
                if (line.startsWith("info") && line.contains("nodes") || line.startsWith("bestmove")) {
                    stopped = true;
                    System.out.println("Stockfish has stopped calculating.");
                    break;
                }
            }
            if (!stopped) {
                System.out.println("Did not receive stop confirmation, waiting a bit longer...");
                Thread.sleep(100);  // Aspetta un po' e riprova
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("isCalculating set to false.");
}


private void processStockfishOutput(String line, String fen, String[] topMoves, String[] moveEvaluations, String[] fullLines,
                                    ChessBoardUI chessBoard, Label move1Label, Label move2Label, Label move3Label, Label evaluationLabel, EvalBar evalBar) {
    String[] parts = line.split(" ");
    int multiPVIndex = Arrays.asList(parts).indexOf("multipv");
    if (multiPVIndex != -1) {
        int pv = Integer.parseInt(parts[multiPVIndex + 1]) - 1;
        if (pv < 3) {
            int pvIndex = Arrays.asList(parts).indexOf("pv");
            if (pvIndex == -1 || pvIndex + 1 >= parts.length) {
                return; // Linea PV malformata
            }
            int moveIndex = pvIndex + 1;
            int scoreIndex = Arrays.asList(parts).indexOf("score");

            if (scoreIndex == -1 || scoreIndex + 2 >= parts.length) {
                return; // Linea score malformata
            }

            double adjustedScore = calculateAdjustedScore(parts, scoreIndex, fen);
            String moveEvaluation = formatMoveEvaluation(parts, scoreIndex, adjustedScore);
            fullLines[pv] = buildFullLine(moveIndex, parts, fen, moveEvaluation);

            topMoves[pv] = parts[moveIndex];
            moveEvaluations[pv] = moveEvaluation;

            updateUI(pv, topMoves[pv], fullLines[pv], adjustedScore, chessBoard, move1Label, move2Label, move3Label, evaluationLabel, evalBar, moveEvaluations);
        }
    }
}

private double calculateAdjustedScore(String[] parts, int scoreIndex, String fen) {
    String scoreType = parts[scoreIndex + 1];
    String[] fenParts = fen.split(" ");
    String sideToMove = fenParts.length > 1 ? fenParts[1] : "w"; // Default a "w" se il parsing fallisce

    if (scoreType.equals("cp")) {
        double score = Double.parseDouble(parts[scoreIndex + 2].replace(",", ".")) / 100.0;
        return sideToMove.equals("b") ? -score : score;
    } else if (scoreType.equals("mate")) {
        int mateIn = Integer.parseInt(parts[scoreIndex + 2]);

        if (mateIn > 0) {
            if (sideToMove.equals("w")) {
                // Bianco può fare scacco matto in mateIn mosse
                return mateIn;
            } else {
                // Nero può fare scacco matto in mateIn mosse, quindi è negativo per bianco
                return -mateIn;
            }
        } else { // mateIn < 0
            if (sideToMove.equals("w")) {
                // Bianco sarà messo sotto scacco matto in abs(mateIn) mosse, quindi negativo
                return mateIn;
            } else {
                // Nero sarà messo sotto scacco matto in abs(mateIn) mosse, quindi positivo per bianco
                return -mateIn;
            }
        }
    }
    return 0.0; // Valore di default in caso di errore
}

private String formatMoveEvaluation(String[] parts, int scoreIndex, double adjustedScore) {
    String scoreType = parts[scoreIndex + 1];
    if (scoreType.equals("cp")) {
        return String.format("%.2f", adjustedScore);
    } else if (scoreType.equals("mate")) {
        int mateIn = (int) Math.abs(adjustedScore);
        if (adjustedScore > 0) {
            return "#" + mateIn;
        } else {
            return "#-" + mateIn;
        }
    }
    return "N/A";
}

private String buildFullLine(int moveIndex, String[] parts, String fen, String moveEvaluation) {
    StringBuilder fullLine = new StringBuilder();
    fullLine.append("[").append(moveEvaluation).append("] ");
    int moveNumber = 1;
    boolean isWhiteMove = true;

    Board board = new Board();
    board.loadFromFen(fen);  // Carica il FEN iniziale

    for (int i = moveIndex; i < parts.length; i++) {
        if (isWhiteMove) {
            fullLine.append(moveNumber).append(")");
            moveNumber++;
        }

        String uciMove = parts[i];
        String algebraicMove = ChessMoveConverter.convertToAlgebraicNotation(uciMove, board.getFen());
        fullLine.append(algebraicMove).append(" ");

        // Esegui la mossa sulla scacchiera per aggiornare il FEN
        try {
            Move move = new Move(Square.valueOf(uciMove.substring(0, 2).toUpperCase()),
                    Square.valueOf(uciMove.substring(2, 4).toUpperCase()));
            board.doMove(move);
        } catch (MoveException e) {
            e.printStackTrace();
        }

        isWhiteMove = !isWhiteMove;
    }
    return fullLine.toString().trim();
}


private void updateUI(int pv, String move, String fullLine, double adjustedScore, ChessBoardUI chessBoard, Label move1Label, Label move2Label, Label move3Label, Label evaluationLabel, EvalBar evalBar, String[] moveEvaluations) {
    Platform.runLater(() -> {
        if (pv == 0) {
            chessBoard.clearArrows();
        }

        switch (pv) {
            case 0 -> {
                move1Label.setText(fullLine);
                drawArrowFromMove(move, chessBoard, LIGHT_GREEN);
            }
            case 1 -> {
                move2Label.setText(fullLine);
                drawArrowFromMove(move, chessBoard, LIGHT_ORANGE);
            }
            case 2 -> {
                move3Label.setText(fullLine);
                drawArrowFromMove(move, chessBoard, LIGHT_ORANGE);
            }
        }

        if (pv == 0) {
            evaluationLabel.setText("Evaluation: " + moveEvaluations[0]);
            if (moveEvaluations[0].startsWith("#")) {
                // Se si tratta di uno scacco matto, passiamo un valore estremo per indicarlo
                int mateIn = Integer.parseInt(moveEvaluations[0].replace("#", "").replace("-", ""));
                double evalScore = moveEvaluations[0].contains("-") ? -1000.0 + mateIn : 1000.0 - mateIn;
                evalBar.updateEvaluation(evalScore);
            } else {
                evalBar.updateEvaluation(adjustedScore);
            }
        }
    });
}

}

[Disservin]

Stockfish doesn’t respond to stop. What you implemented is a hack, stockfish just prints the info a final time after the stop. If search never starts there is no answer, which could be the case if the search startup takes more time on your raspberry pi than on your mac. If you want to know if stockfish is responsive again you send “stop” followed by an “isready” and wait for “readyok”

[Disservin]

This all gets much easier to understand once you properly highlight your code and preferably share a link to your github branch with this code, just reading all this is already too much for 99% of the people.
I also wanted a pure log of not filled with any logs from your app, makes it easier to see what is going wrong.

info string Available processors: 0-31
info string Using 1 thread
info string NNUE evaluation using nn-1111cefa1111.nnue (133MiB, (22528, 3072, 15, 32, 1))
info string NNUE evaluation using nn-37f18f62d772.nnue (6MiB, (22528, 128, 15, 32, 1))

gets send on every go.

Your earlier log already doesn't make sense.

Sending stop command to Stockfish...
Received from Stockfish: info depth 17 seldepth 21 multipv 2 score cp 26 nodes 383650 nps 496313 hashfull 17 tbhits 0 time 773 pv e2e4 c7c5 g1f3 d7d6 b1c3 a7a6 d2d4 c5d4 f3d4 g8f6 c1e3 e7e5 d4b3 f8e7 f1c4 e8g8 c3d5 f6d5 c4d5
Stockfish is ready for the next command.
Stockfish has successfully stopped calculating and is now ready.
isCalculating set to false.
calculation completed.
Sending stop command to Stockfish...
Received from Stockfish: info depth 11 seldepth 18 multipv 2 score cp -28 nodes 21463 nps 613228 hashfull 0 tbhits 0 time 35 pv g8f6 c2c4 c7c5 g2g3 g7g6 f1g2 f8g7 d2d4 c5d4 f3d4 d7d5 d4c2
Stockfish is ready for the next command.
Stockfish has successfully stopped calculating and is now ready.
isCalculating set to false.
calculation completed.

The second "Received from Stockfish" has a newer time than the first "Received from Stockfish".

[Hardin22]

I completely understand that it's nearly impossible to read through something as disorganized as what I've presented, and I apologize for that. I'm still very new to both programming and using GitHub, so I haven't created separate branches for my code. The best I can do at the moment is to share a direct link to the code with some highlights, or you could try downloading the JAR file from the releases section.

That said, my main concern is understanding how production-ready applications handle fast user input when scrolling through positions in a game review. Is it common practice to use the stop command in these scenarios, or are there better methods that are typically implemented? I’m not asking for a complete solution to my problem—that would be too much to ask—but rather just some advice on the best practices to follow.

here's the complete class link, with an highlight to the main function.
https://github.com/Hardin22/JavaChessBoard/blob/master/src/main/java/org/example/javachess/Oggetti/Stockfish.java#L473-L514

stopcalculating function from line 197-224.

in the meanwhile i'll proceed to refactor the code. i'll inform you if i manage to push the changes.

Sorry for the hassle, and thanks again for taking the time to help.

[Disservin]

, or are there better methods that are typically implemented

i dont think this is typically a problem, but you might want to implement something like a debounce, where you only call the function a few ms after the last user interaction (in your case scrolling through the positions)

[Hardin22]

Thanks for the quick reply—this will be my last question, I promise, and then I’ll leave you in peace!

When you say, "I don't think this is typically a problem," do you mean that this issue isn’t usually encountered by other developers? If it’s not a common problem, could you point me towards the pattern that’s typically followed? I’m assuming there has to be some method to stop previous calculations or a workaround of some sort. Otherwise, even with a debounce, the engine might take several seconds to finish a deep calculation (e.g., depth 18), leaving those previous calculations queued up, which doesn’t seem efficient.

What I’m really trying to understand is the overall structure or pattern that’s used to handle these events. Lichess, for instance, allows users to scroll through positions with the mouse wheel, and the calculations start immediately for each position, all in a super fluid manner. I can’t wrap my head around how they achieve this level of responsiveness.

[Disservin]

There's no "pattern", stop is pretty much instantaneous, and it will never wait to finish specific depth calculation, it just stops immediately and outputs the last full info. It might make more sense if you first play around with stockfish over the commmand line directly, instead of through your program.

[joergoster]

@Hardin22 What you want to do is this:

Send the position to analyze to the engine.
Send the 'go' command ( I assume you're sending 'go infinite' here)
If you want to stop the search, send the 'stop' command.
Important: wait for the 'bestmove' response from the engine.
Now you can send the next position and start a new search with another 'go infinite'.
And so on.

Important: If you send something like 'go nodes xxx' or 'go depth x' to start the search, check that the engine hasn't already finished its search and sent a bestmove response before sending a 'stop' command. Because if the engine has already finished its search there will be no response to the 'stop' command.