GCodeInterpreter.java

Go to the documentation of this file.

package com.neuronrobotics.replicator.driver.interpreter;
 
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;
 
import com.neuronrobotics.sdk.common.Log;
 
// TODO: Auto-generated Javadoc
public class GCodeInterpreter {
 
 
    ArrayList<Integer> mcodes = new ArrayList<Integer>();
    ArrayList<Integer> gcodes = new ArrayList<Integer>(); // Keep this is an
                                                            // order that works
                                                            // properly. Code
                                                            // implementations
                                                            // are allowed to
                                                            // modify the line.
    
                                                            private CodeHandler errorHandler=null;
    List<CodeHandler> gHandlers[];
 
    List<Integer> gClearOnSet[];
 
    List<Integer> gOneShot;
 
    List<CodeHandler> mHandlers[];
 
    Comparator<Integer> gCodeOrdering;
    char motion_axes[] = { 'X', 'Y', 'Z' };
 
    GCodeLineData lastLine;
    GCodeLineData nextLine;
 
    Thread interpretingThread;
 
    ReentrantLock executingLock;
    
    private int lineNumber=0;
    @SuppressWarnings("unchecked")
    public GCodeInterpreter() {
        gHandlers = (List<CodeHandler>[]) new ArrayList<?>[310];
        mHandlers = (List<CodeHandler>[]) new ArrayList<?>[310];
        gClearOnSet = (List<Integer>[]) new List<?>[310]; // Maybe not the best
                                                            // storage
                                                            // mechanism. Good
                                                            // in C...
        nextLine = new GCodeLineData();
        lastLine = new GCodeLineData();
        addDefaultHandlers();
        executingLock = new ReentrantLock();
    }
    
    
    public void processSingleGCODELine(String line) throws Exception{
        String delims;
        String[] tokens;
        
        delims = "[ ]+";
        tokens = line.split(delims);
        nextLine.storeWord('G', 0);
        nextLine.storeWord('M', 0);
        nextLine.storeWord('P', lineNumber);
        System.out.println("GCODE: "+line);
        
        for(int i=0;i<tokens.length;i++){
            tokens[i] = tokens[i].trim();
            if(!tokens[i].isEmpty()){
                double val = Double.parseDouble(tokens[i].substring(1));
                char code = tokens[i].charAt(0);
                if(code == 'M'){
                    mcodes.add((int) val);
                }
                if(code == 'G'){
                    int theCode = (int) val;
                    if (gClearOnSet[theCode] != null)
                        gcodes.removeAll(gClearOnSet[theCode]);
                    gcodes.add(theCode);
                }
                Log.debug("Code Token: "+tokens[i]+" "+code+" "+val);
                nextLine.storeWord(code, val);
            }
        }
        //System.out.println(nextLine);
        executeLine(line);
    }
 
    private void parseLine(InputStream r) throws Exception { 
        BufferedReader br = new BufferedReader(new InputStreamReader(r));
        String line;
        boolean inCommentSection = false;
        lineNumber=0;
        while ((line = br.readLine()) != null) {
            lineNumber++;// lines in the file
            String delims;
            String[] tokens;
            if(line.indexOf(';')>-1){
                //this line contains a comment
                if(line.indexOf(';') ==0){
                    // this is just a comment
                    line = null;
                }else{
                    delims = "[;]+";
                    tokens = line.split(delims);
                    //strip the comment and place the rest of the line 
                    // in the to-be-parsed variable
                    line = tokens[0];
                }
            }else{
                // no comment on this line
            }
            //Check for the block comment case
            if(line != null){
                if(line.indexOf('(')>-1){
                    // block comment section
                    inCommentSection = true;
                    line = null;
                }
                
            }
            if(line != null){
                if(line.indexOf(')')>-1){
                    // end block comment section
                    inCommentSection = false;
                    line = null;
                }
            }
            if(inCommentSection)
                line = null;
            
            // Check for the empty line case
            if(line != null){
                if (line.trim().isEmpty()){
                    //empty line detect
                    line = null;
                }
            }
            // OK, now we have a valid line
            if(line !=null){
                
                
                processSingleGCODELine( line);
            }
            
        }
        br.close();
    }
 
 
    private void executeLine(String rawLine) throws Exception {
        
        Log.debug("Next Gcode Line " + nextLine);
        Log.debug("Active Gcodes: " + gcodes);
        Log.debug("Active Mcodes: " + mcodes);
        for (int m : mcodes)
            if (mHandlers[m] != null) {
                for (CodeHandler handler : mHandlers[m]) {
                    handler.execute(lastLine, nextLine);
                }
            } else {
                // Log.debug("No implementation found for M"+m);
                if(getErrorHandler() ==null)
                    throw new RuntimeException("No implementation found for M" + m);
                else{
                    getErrorHandler().execute(lastLine, nextLine);
                }
            }
        for (int g : gcodes)
            if (gHandlers[g] != null) {
                for (CodeHandler handler : gHandlers[g]) {
                    handler.execute(lastLine, nextLine);
                }
            } else {
                if(getErrorHandler() ==null)
                    throw new RuntimeException("No implementation found for G" + g);
                else{
                    getErrorHandler().execute(lastLine, nextLine);
                }
            }
 
        lastLine = nextLine;
        nextLine = new GCodeLineData(lastLine);
        gcodes.removeAll(gOneShot);
        mcodes.clear();
    }
 
    public void interpretStream(InputStream in) throws Exception {
        executingLock.lock();
 
        interpretingThread = Thread.currentThread();
        
        parseLine(in);
 
        interpretingThread = null;
        executingLock.unlock();
        
    }
 
    public void tryInterpretStream(InputStream in) throws Exception {
        if (executingLock.tryLock()) {
            try {
                interpretStream(in);
            } finally {
                executingLock.unlock();
            }
        } else {
            throw(new RuntimeException("Printer not ready"));
        }
    }
 
    public boolean cancel() {
        if (interpretingThread != null) {
            interpretingThread.interrupt();
            return true;
        }
        return false;
    }
 
    public void addGHandler(int code, CodeHandler handler) { // Should really do
                                                                // boundschecking.
                                                                // New code
                                                                // happens
                                                                // before old.
        if (gHandlers[code] == null)
            gHandlers[code] = new ArrayList<CodeHandler>();
        gHandlers[code].add(handler);
    }
 
    public void setGHandler(int code, CodeHandler handler) { // For overriding
                                                                // all default
                                                                // behavior of a
                                                                // code.
        handler.setSubHandlers(gHandlers[code]);
        gHandlers[code] = new ArrayList<CodeHandler>();
        gHandlers[code].add(handler);
    }
 
    public void addMHandler(int code, CodeHandler handler) { // Should really do
                                                                // boundschecking.
                                                                // New code
                                                                // happens
                                                                // before old.
        if (mHandlers[code] == null)
            mHandlers[code] = new ArrayList<CodeHandler>();
        mHandlers[code].add(handler);
    }
 
    public void setMHandler(int code, CodeHandler handler) { // For overriding
                                                                // all default
                                                                // behavior of a
                                                                // code.
        handler.setSubHandlers(mHandlers[code]);
        mHandlers[code] = new ArrayList<CodeHandler>();
        mHandlers[code].add(handler);
    }
 
    public void addGSorting(final Comparator<Integer> c) {
        if (gCodeOrdering == null) {
            gCodeOrdering = c;
            return;
        }
        // ...perhaps I've had too much haskell to write java-style code easily.
        // I do believe this is a combinator.
        final Comparator<Integer> oldComparator = gCodeOrdering; // Make a
                                                                    // constant
                                                                    // reference
                                                                    // to the
                                                                    // old one,
                                                                    // for the
                                                                    // inner
                                                                    // class.
        gCodeOrdering = new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                int r1 = c.compare(o1, o2);
                if (r1 == 0)
                    return oldComparator.compare(o1, o2);
                return r1;
            }
 
            @SuppressWarnings("unused")
            public boolean equals(Integer o1, Integer o2) {
                return this.compare(o1, o2) == 0;
            }
        };
    }
 
    @SuppressWarnings("unchecked")
    public void setGSorting(@SuppressWarnings("rawtypes") Comparator c) {
        gCodeOrdering = c;
    }
 
    public void addDefaultHandlers() {
        final double curOffset[] = new double[26]; // Yes, we'll let them offset
                                                    // on any axis they feel
                                                    // like.
        // G0 - no handler.
        addGHandler(0, new CodeHandler() {
            public void execute(GCodeLineData prev, GCodeLineData next) {
                Log.debug("Rapid move to " + next.getWord('X') + ", "
                        + next.getWord('Y') + ", " + next.getWord('Z'));
            }
        });
        // G1 - no handler.
        addGHandler(1, new CodeHandler() {
            public void execute(GCodeLineData prev, GCodeLineData next) {
                if (next.getWord('F') == 0.0)
                    Log.error("Zero feedrate; action will never complete.");
                Log.debug("Feed move to " + next.getWord('X') + ", "
                        + next.getWord('Y') + ", " + next.getWord('Z')
                        + " at feed " + next.getWord('F'));
            }
        });
        // G21 - program in mm - present but nullary.
        addGHandler(21, new EmptyCodeHandler());
        // G22 - program in in - convert to mm. Only on xyz for now.
        addGHandler(22, new CodeHandler() {
            public void execute(GCodeLineData prev, GCodeLineData next) {
                char axes[] = { 'X', 'Y', 'Z' };
                for (char c : axes) {
                    next.storeWord(c, next.getWord(c) * 25.4);
                }
            }
        });
        // G90 - absolute positioning - default, so empty.
        addGHandler(90, new EmptyCodeHandler());
        // G91 - relative positioning - convert to absolute. Only do this for
        // xyz by default.
        addGHandler(91, new CodeHandler() {
            public void execute(GCodeLineData prev, GCodeLineData next) {
                char axes[] = { 'X', 'Y', 'Z' };
                for (char c : axes) {
                    next.storeWord(c, next.getWord(c) + prev.getWord(c));
                }
            }
        });
        // G92 - set position ( reprap usage ) - messy. This probably goes in
        // the printer class.
        addGHandler(92, new CodeHandler() {
            public void execute(GCodeLineData prev, GCodeLineData next) {
                Log.debug("G92 is not complete");
                char axes[] = { 'X', 'Y', 'Z' };
                for (char c : axes) {
                    next.storeWord(c, next.getWord(c) + curOffset[c - 'A']);
                }
                // And copy the last line to the current line, because we don't
                // want to change actual positions.
            }
        });
        // GROUPS:
        // 21,22 , 90,91, 0-5
        setGSorting(new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                int a = o1.intValue();
                int b = o2.intValue();
                if (a >= 21 && a <= 22)
                    return -1; // Unit conversions default to first.
                if (a >= 0 && a < 6)
                    return 1; // Movements are last.
                if (b >= 21 && b <= 22)
                    return 1;
                if (b >= 0 && b < 6)
                    return -1;
                if (a >= 90 && a <= 91)
                    return -1; // Relative/absolute are immediately after unit
                                // conversion unless otherwise specified.
                if (b >= 90 && b <= 91)
                    return 1;
                return 0;
            }
        });
 
        @SuppressWarnings("unchecked")
        List<Integer>[] exclGroups = (List<Integer>[]) new List<?>[] {
                Arrays.asList(0, 1, 4, 28), // All of these might need to change
                                            // to be mutable later.
                Arrays.asList(20, 21), Arrays.asList(90, 91) };
        for (List<Integer> group : exclGroups) {
            for (int code : group) {
                gClearOnSet[code] = group;
            }
        }
        gClearOnSet[91] = Arrays.asList(90, 91, 92); // Incremental and setting
                                                        // positions makes no
                                                        // sense.
        gOneShot = Arrays.asList(28, 92);
    }
 
    public static void main(String args[]) throws Exception {
        GCodeInterpreter interp = new GCodeInterpreter();
        interp.interpretStream(System.in);
    }
 
    public CodeHandler getErrorHandler() {
        return errorHandler;
    }
 
    public void setErrorHandler(CodeHandler errorHandler) {
        this.errorHandler = errorHandler;
    }
}