GclibJava.java

Go to the documentation of this file.

 
package gclibjava;
 
import java.nio.charset.Charset; //Charset for string conversions
 
//JNA imports
import com.sun.jna.Library;
import com.sun.jna.Native;
import com.sun.jna.Pointer; //g
import com.sun.jna.ptr.PointerByReference; //for GCon* in GOpen()
import com.sun.jna.ptr.IntByReference; //for GSize* in GCommand()
import com.sun.jna.ptr.ByteByReference; //for GStatus* in GInterrupt()
import java.util.ArrayList;
import java.util.List; //List<Double>
 
public class GclibJava {
 
    Pointer gclibHandle; //handle for gclib's connection
    Boolean connected = false;  //we use a bool to indicate connection status
    byte[] trafficBuffer = new byte[524288]; //Most reads/writes to Galil hardware are small. This size will hold the largest array or program upload/download possible.
 
    public GclibJava()
    {
        System.setProperty("jna.library.path", "C:\\Program Files (x86)\\Galil\\gclib\\dll\\x64");
    }
 
    @Override
    protected void finalize() throws Throwable
    {
        try {
            if (connected)
                GClose();
        } finally {
            super.finalize();
        }
    }
 
    // -------------------------------------------------------------------------
    // JNA for gclib
    // -------------------------------------------------------------------------
    interface Gclib extends Library {
        Gclib INSTANCE = (Gclib)
                Native.loadLibrary("gclib",
                        Gclib.class);
        /*
        Limit calls to one at a time
        Warning: gclibo library calls gclib. Therefore, calls to Gclib and
        Gclibo interfaces should not be concurrent.
        */
        Gclib SYNC_INSTANCE = (Gclib)
                Native.synchronizedLibrary(INSTANCE);
 
        int GArrayDownload(Pointer g, String arrayName, int first, int last, String buffer);
        int GArrayUpload(Pointer g, String arrayName, int first, int last, int delim, byte[] response, int len);
        int GCommand(Pointer g, String command, byte[] response, int len, IntByReference bytesReturned);
        int GClose(Pointer g);
        int GFirmwareDownload(Pointer g, String filePath);
        int GInterrupt(Pointer g, ByteByReference statusByte);
        int GMessage(Pointer g, byte[] response, int len);
        int GOpen(String address, PointerByReference g);
        int GProgramDownload(Pointer g, String program, String preprocessor);
        int GProgramUpload(Pointer g, byte[] response, int len);
    }
 
    // -------------------------------------------------------------------------
    // gclib functions
    // -------------------------------------------------------------------------
 
    public void GArrayDownload(String arrayName, List<Double> data) throws GclibJavaException
    {
        String buf = new String();
        buf = data.stream().map((d) -> d.toString() + ",").reduce(buf, String::concat);
 
        ec(Gclib.SYNC_INSTANCE.GArrayDownload(gclibHandle, arrayName, -1, -1,
                buf.substring(0, buf.length() - 1)));//remove trailing comma
    }
 
    public List<Double> GArrayUpload(String arrayName) throws GclibJavaException
    {
        ec(Gclib.SYNC_INSTANCE.GArrayUpload(gclibHandle, arrayName, -1, -1, 1, trafficBuffer, trafficBuffer.length));
        String[] elements = cstringToString(trafficBuffer).split(", ");
        List<Double> doubleList = new ArrayList();
        for (String s : elements)
        {
            try
            {
                doubleList.add(Double.parseDouble(s));
            }
            catch (NumberFormatException e)
            {
                throw new GclibJavaException( -10002, e.getMessage()); //G_BAD_VALUE_RANGE
            }
        }
        return doubleList;
    }
 
    public void GClose()
    {
        Gclib.SYNC_INSTANCE.GClose(gclibHandle);
        connected = false;
    }
 
    public String GCommand(String command) throws GclibJavaException
    {
        IntByReference ptrInt = new IntByReference(); //for bytes read
        ec(Gclib.SYNC_INSTANCE.GCommand(gclibHandle, command, trafficBuffer, trafficBuffer.length, ptrInt));
        String response = cstringToString(trafficBuffer);
 
        int index = response.lastIndexOf("\r\n:");
        if (index > 0)
            response = response.substring(0, index); //trim trailing crlf:
 
        return response;
    }
 
    public void GFirmwareDownload(String filePath) throws GclibJavaException
    {
        ec(Gclib.SYNC_INSTANCE.GFirmwareDownload(gclibHandle, filePath));
    }
 
    public byte GInterrupt() throws GclibJavaException
    {
        ByteByReference statusByte = new ByteByReference();
        ec(Gclib.SYNC_INSTANCE.GInterrupt(gclibHandle, statusByte));
        return statusByte.getValue();
    }
 
    public String GMessage() throws GclibJavaException
    {
        ec(Gclib.SYNC_INSTANCE.GMessage(gclibHandle, trafficBuffer, trafficBuffer.length));
        return cstringToString(trafficBuffer);
    }
 
    public void GOpen(String address) throws GclibJavaException
    {
        if (connected)
            GClose();
 
        PointerByReference ptrRef = new PointerByReference();
        ec(Gclib.SYNC_INSTANCE.GOpen(address, ptrRef));
        gclibHandle = ptrRef.getValue();
        connected = true;
    }
 
    public void GProgramDownload(String program, String preprocessor) throws GclibJavaException
    {
        ec(Gclib.SYNC_INSTANCE.GProgramDownload(gclibHandle, program, preprocessor));
    }
 
    public void GProgramDownload(String program) throws GclibJavaException
    {
        GProgramDownload(program, "");
    }
 
    public String GProgramUpload() throws GclibJavaException
    {
        ec(Gclib.SYNC_INSTANCE.GProgramUpload(gclibHandle, trafficBuffer, trafficBuffer.length));
        return cstringToString(trafficBuffer);
    }
 
    // -------------------------------------------------------------------------
    // JNA for gclibo
    // -------------------------------------------------------------------------
 
    interface Gclibo extends Library {
        Gclibo INSTANCE = (Gclibo)
            Native.loadLibrary("gclibo",
                               Gclibo.class);
       /*
        Limit calls to one at a time
        Warning: gclibo library calls gclib. Therefore, calls to Gclib and
        Gclibo interfaces should not be concurrent.
        */
        Gclibo SYNC_INSTANCE = (Gclibo)
                Native.synchronizedLibrary(INSTANCE);
 
        int GAddresses(byte[] response, int len);
        int GArrayDownloadFile(Pointer g, String filePath);
        int GArrayUploadFile(Pointer g, String filePath, String names);
        int GAssign(String ip, String mac);
        void GError(int rc, byte[] response, int len);
        int GInfo(Pointer g, byte[] response, int len);
        int GIpRequests(byte[] response, int len);
        int GProgramDownloadFile(Pointer g, String filePath, String preprocessor);
        int GProgramUploadFile(Pointer g, String filePath);
        void GSleep(int timeout_ms);
        int GTimeout(Pointer g, short timeout_ms);
        int GVersion(byte[] response, int len);
        int GSetServer(String server_name);
        int GServerStatus(byte[] response, int len);
        int GListServers(byte[] response, int len);
        int GPublishServer(String server_name, int publish, int save);
        int GRemoteConnections(byte[] response, int len);
    }
 
    // -------------------------------------------------------------------------
    // gclibo functions
    // -------------------------------------------------------------------------
 
    public String GAddresses() throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GAddresses(trafficBuffer, trafficBuffer.length));
        return cstringToString(trafficBuffer);
    }
 
    public void GArrayDownloadFile(String filePath) throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GArrayDownloadFile(gclibHandle, filePath));
    }
 
    public void GArrayUploadFile(String filePath, String names) throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GArrayUploadFile(gclibHandle, filePath, names));
    }
 
    public void GArrayUploadFile(String filePath) throws GclibJavaException
    {
        GArrayUploadFile(filePath, "");
    }
 
    public void GAssign(String ipAddress, String macAddress) throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GAssign(ipAddress, macAddress));
    }
 
    public String GInfo() throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GInfo(gclibHandle, trafficBuffer, trafficBuffer.length));
        return cstringToString(trafficBuffer);
    }
 
    public String GIpRequests() throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GIpRequests(trafficBuffer, trafficBuffer.length));
        return cstringToString(trafficBuffer);
    }
 
    public void GProgramDownloadFile(String filePath, String preprocessor) throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GProgramDownloadFile(gclibHandle, filePath, preprocessor));
    }
 
    public void GProgramDownloadFile(String filePath) throws GclibJavaException
    {
        GProgramDownloadFile(filePath, "");
    }
 
    public void GProgramUploadFile(String filePath) throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GProgramUploadFile(gclibHandle, filePath));
    }
 
    public void GSleep(int timeout_ms)
    {
        Gclibo.SYNC_INSTANCE.GSleep(timeout_ms);
    }
 
    public void GTimeout(short timeout_ms) throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GTimeout(gclibHandle, timeout_ms));
    }
 
    public String GVersion() throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GVersion(trafficBuffer, trafficBuffer.length));
        return cstringToString(trafficBuffer);
    }
 
    public void GSetServer(String server_name) throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GSetServer(server_name));
    }
 
    public String GServerStatus() throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GServerStatus(trafficBuffer, trafficBuffer.length));
        return cstringToString(trafficBuffer);
    }
 
    public String GListServers() throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GListServers(trafficBuffer, trafficBuffer.length));
        return cstringToString(trafficBuffer);
    }
 
    public void GPublishServer(String server_name, int publish, int save) throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GPublishServer(server_name, publish, save));
    }
 
    public String GRemoteConnections() throws GclibJavaException
    {
        ec(Gclibo.SYNC_INSTANCE.GRemoteConnections(trafficBuffer, trafficBuffer.length));
        return cstringToString(trafficBuffer);
    }
 
    // -------------------------------------------------------------------------
    // Helper functions
    // -------------------------------------------------------------------------
 
    //convert gclib's C strings to Java strings.
    String cstringToString(byte[] cbuf)
    {
        Charset charset = Charset.forName("UTF-8");
        int i;
        for (i = 0; i < cbuf.length && cbuf[i] != 0; i++){}//search for gclib's null terminator
        return new String(cbuf, 0, i, charset);
    }
 
    //Error checker for gclib return code
    void ec(int returnCode) throws GclibJavaException
    {
        if (returnCode != 0)
        {
            //lookup human-readable string
            Gclibo.SYNC_INSTANCE.GError(returnCode, trafficBuffer, trafficBuffer.length);
            throw new GclibJavaException(returnCode, cstringToString(trafficBuffer));
        }
    }
 
}