URL https://opencores.org/ocsvn/btcminer/btcminer/trunk
Subversion Repositories btcminer

[/] [btcminer/] [trunk/] [BTCMiner.java] - Blame information for rev 2

Details | Compare with Previous | View Log

/*!
   BTCMiner -- BTCMiner for ZTEX USB-FPGA Modules
   Copyright (C) 2011-2012 ZTEX GmbH
   http://www.ztex.de
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 3 as
   published by the Free Software Foundation.
 
   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, see http://www.gnu.org/licenses/.
!*/
 
/* TODO:
 * HUP signal
 * rollntime / expire
 */
 
 
import java.io.*;
import java.util.*;
import java.net.*;
import java.security.*;
import java.text.*;
import java.util.zip.*;
 
import ch.ntb.usb.*;
 
import ztex.*;
 
// *****************************************************************************
// ******* ParameterException **************************************************
// *****************************************************************************
// Exception the prints a help message
class ParameterException extends Exception {
    public final static String helpMsg = new String (
                "Parameters:\n"+
                "    -host <string>    Host URL (default: http://127.0.0.1:8332)\n" +
                "    -u <string>       RPC User name\n" +
                "    -p <string>       RPC Password\n" +
                "    -b <url> <user name> <password> \n" +
                "                      URL, user name and password of a backup server. Can be specified multiple times. \n"+
                "    -lp <url> <user name> <password> \n" +
                "                      URL, user name and password of a long polling server (determined automatically by default) \n"+
                "    -l <log file>     Log file (default: BTCMiner.log) \n" +
                "    -l2 <log file>    Secondary log file, logs everything but statistics \n" +
                "    -bl <log file>    Log of submitted blocks file \n" +
                "    -c <file name>    Secondary command input file, can be a named pipe \n" +
                "    -m s|t|p|c        Set single mode, test mode, programming mode or cluster mode\n"+
                "                      Single mode: runs BTCMiner on a single board (default mode)\n" +
                "                      Test mode: tests a board using some test data\n" +
                "                      Programming mode: programs device with the given firmware\n" +
                "                      Cluster mode: runs BTCMiner on all programmed boards\n" +
                "    -ep0              Always use slow EP0 for Bitstream transfer\n" +
                "    -oh <number>      Overheat threshold: if the hash rate drops by that factor (but at least two frequency steps)\n"+
                "                      the overheat shutdown is triggered (default: 0.04, recommended: 0 to 0.08)\n"+
                "    -t <number>       Temperature limit (in �C, default 70�C)\n" +
                "    -ps <string>      Select devices with the given serial number,\n" +
                "                      in cluster mode: select devices which serial number starts with the given string\n" +
                "    -e <number>       Maximum error rate\n"+
                "    -tc               Enable target check (disabled by default)\n" +
                "    -v                Be verbose\n" +
                "    -h                This help\n" +
                "Parameters in single mode, test mode and programming mode\n"+
                "    -d <number>       Device Number, see -i\n" +
                "    -f <ihx file>     Firmware file (required in programming mode)\n" +
                "    -i                Print bus info\n" +
                "Parameters in cluster mode\n"+
                "    -n <number>       Maximum amount of devices per thread (default: 10)\n"+
                "Parameters in programming mode\n"+
                "    -pt <string>      Program devices of the given type\n" +
                "                      If neither -ps nor -ps is given, only unconfigured devices are programmed\n" +
                "    -s                Set serial number\n" +
                "    -rf               Erase firmware in EEPROM (overwrites -f, requires -pt or -ps)\n"
        );
 
 
    public ParameterException (String msg) {
        super( msg + "\n" + helpMsg );
    }
}
 
/* *****************************************************************************
   ******* ParserException *****************************************************
   ***************************************************************************** */
class ParserException extends Exception {
    public ParserException(String msg ) {
        super( msg );
    }
}
 
/* *****************************************************************************
   ******* FirmwareException ***************************************************
   ***************************************************************************** */
class FirmwareException extends Exception {
    public FirmwareException(String msg ) {
        super( msg );
    }
}
 
 
// *****************************************************************************
// ******* MsgObj *************************************************************
// *****************************************************************************
interface MsgObj {
    public void msg(String s);
}
 
 
// *****************************************************************************
// ******* NewBlockMonitor *****************************************************
// *****************************************************************************
class NewBlockMonitor extends Thread implements MsgObj {
    public int newCount = -1;
 
    public boolean running;
 
    private static final int minLongPollInterval = 250; // in ms
 
    private byte[] prevBlock = new byte[32];
    private byte[] dataBuf = new byte[128];
 
    private Vector<LogString> logBuf = new Vector<LogString>();
 
    public static boolean submitOld;
 
// ******* constructor *********************************************************
    public NewBlockMonitor( ) {
        start();
    }
 
// ******* checkNew ************************************************************
    synchronized public boolean checkNew ( byte[] data ) throws NumberFormatException {
        if ( data.length < 36 )
            throw new NumberFormatException("Invalid length of data");
 
        boolean n = false;
 
        for ( int i=0; i<32; i++ ) {
            n = n | ( data[i+4] != prevBlock[i] );
            prevBlock[i] = data[i+4];
        }
        if ( n ) {
            newCount += 1;
            submitOld = true;
            if ( newCount > 0 )
                msg("New block detected by block monitor");
        }
 
        return n;
    }
 
// ******* run *****************************************************************
    public void run () {
        running = true;
 
        boolean enableLP = true;
        boolean warnings = true;
        long enableLPTime = 0;
 
        submitOld = true;
 
        while ( running ) {
            long t = new Date().getTime();
 
            if ( BTCMiner.longPollURL!=null && enableLP && t>enableLPTime) {
                try {
//                  msg("info: LP");
                    String req = BTCMiner.bitcoinRequest(this, BTCMiner.longPollURL, BTCMiner.longPollUser, BTCMiner.longPollPassw, "getwork", "");
                    BTCMiner.hexStrToData(BTCMiner.jsonParse(req, "data"), dataBuf);
                    submitOld = true;
                    String so = null;
                    try {
                        so = BTCMiner.jsonParse(req, "submitold");
                        if ( so.equalsIgnoreCase("false") )
                            submitOld = false;
                    }
                    catch ( Exception e ) {
                    }
 
                    for ( int i=0; i<32; i++ ) {
                        prevBlock[i] = dataBuf[i+4];
                    }
                    newCount += 1;
                    msg( "New block detected by long polling" + ( so == null ? "" : " (submitold = " + so + ")" ) );
                }
                catch ( MalformedURLException e ) {
                    msg("Warning: " + e.getLocalizedMessage() + ": disabling long polling");
                    enableLP = false;
                }
                catch ( IOException e ) {
                    if ( new Date().getTime() < t+500 ) {
                        msg("Warning: " + e.getLocalizedMessage() + ": disabling long polling fo 60s");
                        enableLPTime = new Date().getTime() + 60000;
                    }
                }
                catch ( Exception e ) {
                    if ( warnings )
                        msg("Warning: " + e.getLocalizedMessage());
                    warnings = false;
                }
            }
 
            if ( BTCMiner.longPollURL==null )
                enableLPTime = new Date().getTime() + 2000;
 
            t += minLongPollInterval - new Date().getTime();
            if ( t > 5 ) {
                try {
                    Thread.sleep( t );
                }
                catch ( InterruptedException e) {
                }
            }
        }
 
//      System.out.println("Stopping block monitor"); 
    }
 
// ******* msg *****************************************************************
    public void msg(String s) {
        synchronized ( logBuf ) {
            logBuf.add( new LogString( s ) );
        }
    }
 
// ******* print ***************************************************************
    public void print () {
        synchronized ( logBuf ) {
            for ( int j=0; j<logBuf.size(); j++ ) {
                LogString ls = logBuf.elementAt(j);
                System.out.println( ls.msg );
                if ( BTCMiner.logFile != null ) {
                    BTCMiner.logFile.println( BTCMiner.dateFormat.format(ls.time) + ": " + ls.msg );
                }
                if ( BTCMiner.logFile2 != null && !ls.msg.substring(0,18).equals("New block detected") ) {
                    BTCMiner.logFile2.println( BTCMiner.dateFormat.format(ls.time) + ": " + ls.msg );
                }
            }
            logBuf.clear();
        }
    }
}
 
// *****************************************************************************
// ******* BTCMinerThread ******************************************************
// *****************************************************************************
class BTCMinerThread extends Thread {
    private Vector<BTCMiner> miners = new Vector<BTCMiner>();
    private String busName;
    private PollLoop pollLoop = null;
 
// ******* constructor *********************************************************
    public BTCMinerThread( String bn ) {
        busName = bn;
    }
 
// ******* add *****************************************************************
    public void add ( BTCMiner m ) {
        synchronized ( miners ) {
            miners.add ( m );
            m.name = busName + ": " + m.name;
        }
 
        if ( pollLoop==null ) {
            BTCMiner.printMsg2("Starting mining thread for bus " + busName);
            start();
        }
    }
 
// ******* size ****************************************************************
    public int size () {
        return miners.size();
    }
 
// ******* elementAt ***********************************************************
    public BTCMiner elementAt ( int i ) {
        return miners.elementAt(i);
    }
 
// ******* find ****************************************************************
    public BTCMiner find ( int dn ) {
        for (int i=0; i<miners.size(); i++ ) {
            if ( (miners.elementAt(i).ztex().dev().dev().getDevnum() == dn) )
                return miners.elementAt(i);
        }
        return null;
    }
 
// ******* busName *************************************************************
    public String busName () {
        return busName;
    }
 
// ******* running *************************************************************
    public boolean running () {
        return pollLoop != null;
    }
 
// ******* run *****************************************************************
    public void run () {
        pollLoop = new PollLoop(miners);
        pollLoop.run();
        pollLoop = null;
    }
 
// ******* printInfo ************************************************************
    public void printInfo ( ) {
        if ( pollLoop != null )
            pollLoop.printInfo( busName );
    }
 
// ******* disconnect ***********************************************************
    public int disconnect ( String ss, Vector<BTCMiner> allMiners ) {
        int i=0;
        synchronized ( miners ) {
            for (int j=miners.size()-1; j>=0; j-- ) {
                BTCMiner m = miners.elementAt(j);
                if ( ss.equals(m.ztex().dev().snString()) ) {
                    BTCMiner.printMsg("Disconnecting "+m.name);
                    if ( allMiners != null )
                        allMiners.removeElement(m);
                    m.suspend();
                    miners.removeElementAt(j);
                    i+=1;
                }
            }
        }
        return i;
    }
 
}
 
 
// *****************************************************************************
// ******* BTCMinerCluster *****************************************************
// *****************************************************************************
class BTCMinerCluster {
    public static int maxDevicesPerThread = 10;
 
    private Vector<BTCMinerThread> threads = new Vector<BTCMinerThread>();
    private Vector<BTCMiner> allMiners = new Vector<BTCMiner>();
 
// ******* constructor **************************************************************
    public BTCMinerCluster( boolean verbose ) {
        final long infoInterval = 300000;
 
        scan( verbose );
 
        long nextInfoTime = new Date().getTime() + 60000;
 
        boolean quit = false;
        while ( threads.size()>0 && !quit) {
 
            try {
                Thread.sleep( 300 );
            }
            catch ( InterruptedException e) {
            }
 
            BTCMiner.newBlockMonitor.print();
            for (int i=0; i<allMiners.size(); i++)
                allMiners.elementAt(i).print();
 
            if ( new Date().getTime() > nextInfoTime ) {
                double d = 0.0;
                double e = 0.0;
                for ( int i=0; i<allMiners.size(); i++ ) {
                    BTCMiner m = allMiners.elementAt(i);
                    m.printInfo( true );
                    d+=m.submittedHashRate();
                    e+=m.totalHashRate();
                }
                for ( int i=0; i<threads.size(); i++ )
                    threads.elementAt(i).printInfo();
 
                BTCMiner.printMsg2("Total hash rate: " + String.format("%.1f",  e ) + " MH/s");
                BTCMiner.printMsg2("Total submitted hash rate: " + String.format("%.1f",  d ) + " MH/s");
                BTCMiner.printMsg2(" -------- ");
                nextInfoTime = new Date().getTime() + infoInterval;
            }
 
            for (int i=threads.size()-1; i>=0; i--) {
                BTCMinerThread t = threads.elementAt(i);
                if ( !t.running() ) {
                    BTCMiner.printMsg2( "Stopped thread for bus " + t.busName() );
                    threads.removeElementAt(i);
                }
            }
 
            try {
                StringBuffer sb = new StringBuffer();
                while ( System.in.available() > 0 ) {
                    int j = System.in.read();
                    if (j>32)
                        sb.append((char) j);
                }
 
                if ( sb.length() == 0 && BTCMiner.in2 != null ) {
                    while ( BTCMiner.in2.available() > 0 ) {
                        int j = BTCMiner.in2.read();
                        if (j>32)
                            sb.append((char) j);
                    }
                }
 
                String cmd = sb.toString();
 
                if (cmd.length()<1) {}
                else if (cmd.equalsIgnoreCase("q") || cmd.equalsIgnoreCase("quit") ) {
                    for (int i=allMiners.size()-1; i>=0; i--) {
                        allMiners.elementAt(i).suspend();
                        try {
                            Thread.sleep( 10 );
                        }
                        catch ( InterruptedException e) {
                        }
                    }
                    quit=true;
                }
                else if (cmd.equalsIgnoreCase("r") || cmd.equalsIgnoreCase("rescan") ) {
                    scan( verbose );
                }
                else if (cmd.equalsIgnoreCase("s") || cmd.equalsIgnoreCase("suspend") ) {
                    long t = new Date().getTime();
                    int j=0;
                    for (int i=allMiners.size()-1; i>=0; i--) {
                        if ( allMiners.elementAt(i).suspend() ) j++;
                        allMiners.elementAt(i).startTimeAdjust = t;
                        try {
                            Thread.sleep( 10 );
                        }
                        catch ( InterruptedException e) {
                        }
                    }
                    BTCMiner.printMsg2("Suspended " + j + " of " + allMiners.size() + " miners. Enter `r' to resume.");
                }
                else if (cmd.equalsIgnoreCase("c") || cmd.equalsIgnoreCase("counter_reset") ) {
                    for (int i=allMiners.size()-1; i>=0; i--) {
                        allMiners.elementAt(i).resetCounters();
                    }
                    BTCMiner.printMsg2("Reset all performance end error counters.");
                }
                else if (cmd.equalsIgnoreCase("i") || cmd.equalsIgnoreCase("info") ) {
                    nextInfoTime = 0;
                }
                else if ( cmd.charAt(0) == 'd' || cmd.charAt(0) == 'D' ) {
                    int i = ( cmd.length()>=10 && cmd.substring(0,10).equalsIgnoreCase("disconnect") ) ? 10 : 1;
                    while ( i<cmd.length() && cmd.charAt(i)<=' ' ) i++;
                    int j = cmd.length()-1;
                    while ( j>=i && cmd.charAt(j)<=' ' ) j--;
                    if ( i<=j ) {
                        String ss=BTCMiner.checkSnString(cmd.substring(i,j+1));
                        j=0;
                        for ( i = threads.size()-1; i>=0; i-- )  {
                            j+=threads.elementAt(i).disconnect(ss, allMiners);
                        }
                        System.out.println("Disconnected "+j+" miners");
                    }
                    else {
                        System.out.println("No serial number specified");
                    }
                }
                else if (cmd.equalsIgnoreCase("h") || cmd.equalsIgnoreCase("help") ) {
                    System.out.println("q(uit)                         Exit BTCMiner");
                    System.out.println("r(escan)                       Rescan bus");
                    System.out.println("c(ounter_reset)                Reset performance and error counters");
                    System.out.println("s(uspend)                      Suspend cluster");
                    System.out.println("d(isconnect) <serial nunmber>  Disconnect device");
                    System.out.println("i(nfo)                         Print cluster informations");
                    System.out.println("h(elp)                         Print this help");
                }
                else System.out.println("Invalid command: `"+cmd+"', enter `h' for help");
 
            }
            catch ( Exception e ) {
            }
 
        }
 
//      BTCMiner.newBlockMonitor.running = false;
    }
 
// ******* add *****************************************************************
    private void add ( BTCMiner m ) {
        int i=0, j=0;
        String bn = m.ztex().dev().dev().getBus().getDirname() + "-" + j;
        while ( i<threads.size() ) {
            BTCMinerThread t = threads.elementAt(i);
            if ( bn.equalsIgnoreCase(threads.elementAt(i).busName()) ) {
                if ( t.size() < maxDevicesPerThread )
                    break;
                j++;
                i=0;
                bn = m.ztex().dev().dev().getBus().getDirname() + "-" + j;
            }
            else {
                i++;
            }
        }
 
        if ( i >= threads.size() )
            threads.add( new BTCMinerThread(bn) );
        threads.elementAt(i).add(m);
    }
 
// ******* find ****************************************************************
    private BTCMiner find ( ZtexDevice1 dev ) {
        int dn = dev.dev().getDevnum();
        String bn = dev.dev().getBus().getDirname();
        for ( int i=threads.size()-1; i>=0; i-- )  {
            BTCMiner m = threads.elementAt(i).find(dn);
            if (  m != null && bn.equals(m.ztex().dev().dev().getBus().getDirname()) )
                return m;
        }
        return null;
    }
 
// ******* insertIntoAllMiners *************************************************
    private void insertIntoAllMiners ( BTCMiner m ) {
        int j = 0;
        while ( j<allMiners.size() && m.name.compareTo(allMiners.elementAt(j).name)>=0 )
            j++;
        allMiners.insertElementAt(m, j);
    }
 
// ******* scan ****************************************************************
    private void scan ( boolean verbose ) {
        long t = new Date().getTime();
 
        allMiners.clear();
        for ( int i = threads.size()-1; i>=0; i-- )  {
            BTCMinerThread mt = threads.elementAt(i);
            for (int j=mt.size()-1; j>=0; j-- ) {
                BTCMiner m = mt.elementAt(j);
                insertIntoAllMiners(m);
                if ( m.suspended ) {
                    m.suspended = false;
                    m.isRunning = false;
                    try {
                        Thread.sleep( 20 );
                    }
                    catch ( InterruptedException e) {
                    }
                    BTCMiner.printMsg2(m.name + ": resuming");
                }
                else {
                    m.startTimeAdjust = t;
                    BTCMiner.printMsg2(m.name + ": already running");
                }
            }
        }
 
        BTCMiner.printMsg2("\n(Re)Scanning bus ... ");
 
        PollLoop.scanMode = true;
 
        ZtexScanBus1 bus = new ZtexScanBus1( ZtexDevice1.ztexVendorId, ZtexDevice1.ztexProductId, false, false, 1,  null, 10, 0, 1, 0 );
        int k = 0;
        int l = 0;
        for (int i=0; i<bus.numberOfDevices(); i++ ) {
            try {
                ZtexDevice1 dev = bus.device(i);
                if ( dev.productId(0)!=10 || dev.productId(2)>1 )
                    break;
 
                if ( BTCMiner.filterSN == null || dev.snString().substring(0,BTCMiner.filterSN.length()).equals(BTCMiner.filterSN) ) {
                    k += 1;
                    BTCMiner m = find( dev );
                    if ( m == null ) {
                        l += 1;
                        m = new BTCMiner ( dev, null, verbose );
                        m.clusterMode = true;
                        add( m );
                        BTCMiner.printMsg(m.name + ": added");
                        insertIntoAllMiners(m);
 
                        for ( int j=1; j<m.numberOfFpgas(); j++ ) {
                            BTCMiner n = new BTCMiner( m.ztex(), m.fpgaNum(j), verbose );
                            n.clusterMode = true;
                            add( n );
                            BTCMiner.printMsg(n.name + ": added");
                            insertIntoAllMiners(n);
                        }
                    }
                }
            }
            catch ( Exception e ) {
                BTCMiner.printMsg( "Error: "+e.getLocalizedMessage() );
            }
        }
 
        if ( k == 0 ) {
            System.err.println("No devices found. At least one device has to be connected.");
            System.exit(0);
        }
        BTCMiner.printMsg2("" + l + " new devices found.");
 
        t = new Date().getTime();
        for (int i=0; i<allMiners.size(); i++ )
            allMiners.elementAt(i).startTime+= t-allMiners.elementAt(i).startTimeAdjust;
 
        PollLoop.scanMode = false;
 
        BTCMiner.printMsg2("\nSummary: ");
        for (int i=0; i<threads.size(); i++ )
            BTCMiner.printMsg2("  Bus " + threads.elementAt(i).busName() + "\t: " + threads.elementAt(i).size() + " miners");
        BTCMiner.printMsg2("  Total  \t: " + allMiners.size() + " miners\n");
        BTCMiner.printMsg2("\nDisconnect all devices or enter `q' for exit. Enter `h' for help.\n");
 
        BTCMiner.connectionEffort = 1.0 + Math.exp( (1.0 - Math.sqrt(Math.min(allMiners.size(),maxDevicesPerThread)*allMiners.size())) / 13.0 );
//      System.out.println( BTCMiner.connectionEffort );
 
    }
}
 
 
// *****************************************************************************
// ******* LogString ***********************************************************
// *****************************************************************************
class LogString {
    public Date time;
    public String msg;
 
    public LogString(String s) {
        time = new Date();
        msg = s;
    }
}
 
 
// *****************************************************************************
// ******* PollLoop ************************************************************
// *****************************************************************************
class PollLoop {
    public static boolean scanMode = false;
 
    private double usbTime = 0.0;
    private double networkTime = 0.0;
    private double timeW = 1e-6;
    private Vector<BTCMiner> v;
    public static final long minQueryInterval = 250;
 
// ******* constructor *********************************************************
    public PollLoop ( Vector<BTCMiner> pv ) {
        v = pv;
    }
 
// ******* run *****************************************************************
    public void run ( ) {
        int maxIoErrorCount = (int) Math.round( (BTCMiner.rpcCount > 1 ? 2 : 4)*BTCMiner.connectionEffort );
        int ioDisableTime = BTCMiner.rpcCount > 1 ? 60 : 30;
 
        while ( v.size()>0 ) {
            long t0 = new Date().getTime();
            long tu = 0;
 
            if ( ! scanMode ) {
                synchronized ( v ) {
                    for ( int i=v.size()-1; i>=0; i-- ) {
                        BTCMiner m = v.elementAt(i);
 
                        m.usbTime = 0;
 
                        try {
                            if ( ! m.suspended ) {
                                if ( m.checkUpdate() && m.getWork() ) { // getwork calls getNonces
                                    m.dmsg("Got new work");
                                    m.sendData();
                                }
                                else {
                                    m.getNonces();
                                }
                                m.updateFreq();
                                m.printInfo(false);
                            }
                        }
                        catch ( IOException e ) {
                            m.ioErrorCount[m.rpcNum]++;
                            if ( m.ioErrorCount[m.rpcNum] >= maxIoErrorCount ) {
                                m.msg("Error: "+e.getLocalizedMessage() +": Disabling URL " + m.rpcurl[m.rpcNum] + " for " + ioDisableTime + "s");
                                m.disableTime[m.rpcNum] = new Date().getTime() + ioDisableTime*1000;
                                m.ioErrorCount[m.rpcNum] = 0;
                            }
                        }
                        catch ( ParserException e ) {
                            m.msg("Error: "+e.getLocalizedMessage() +": Disabling URL " + m.rpcurl[m.rpcNum] + " for 60s");
                            m.disableTime[m.rpcNum] = new Date().getTime() + 60000;
                        }
                        catch ( NumberFormatException e ) {
                            m.msg("Error: "+e.getLocalizedMessage() +": Disabling URL " + m.rpcurl[m.rpcNum] + " for 60s");
                            m.disableTime[m.rpcNum] = new Date().getTime() + 60000;
                        }
                        catch ( IndexOutOfBoundsException e ) {
                            m.msg("Error: "+e.getLocalizedMessage() +": Disabling URL " + m.rpcurl[m.rpcNum] + " for 60s");
                            m.disableTime[m.rpcNum] = new Date().getTime() + 60000;
                        }
                        catch ( Exception e ) {
                            m.msg("Error: "+e.getLocalizedMessage()+": Disabling device");
                            m.fatalError = "Error: "+e.getLocalizedMessage()+": Device disabled since " + BTCMiner.dateFormat.format( new Date() );
                            v.removeElementAt(i);
                        }
 
                        tu += m.usbTime;
 
                        if ( ! m.clusterMode ) {
                            BTCMiner.newBlockMonitor.print();
                        }
                    }
                }
 
                t0 = new Date().getTime() - t0;
                usbTime = usbTime * 0.9998 + tu;
                networkTime = networkTime * 0.9998 + t0 - tu;
                timeW = timeW * 0.9998 + 1;
            }
            else {
                t0 = 0;
            }
 
            t0 = minQueryInterval - t0;
            if ( t0 > 5 ) {
                try {
                    Thread.sleep( t0 );
                }
                catch ( InterruptedException e) {
                }
            }
        }
    }
 
// ******* printInfo ***********************************************************
    public void printInfo( String name ) {
        int oc = 0;
        double gt=0.0, gtw=0.0, st=0.0, stw=0.0;
        for ( int i=v.size()-1; i>=0; i-- ) {
            BTCMiner m = v.elementAt(i);
            oc += m.overflowCount;
            m.overflowCount = 0;
 
            st += m.submitTime;
            stw += m.submitTimeW;
 
            gt += m.getTime;
            gtw += m.getTimeW;
        }
 
        BTCMiner.printMsg2(name + ": poll loop time: " + Math.round((usbTime+networkTime)/timeW) + "ms (USB: " + Math.round(usbTime/timeW) + "ms network: " + Math.round(networkTime/timeW) + "ms)   getwork time: "
                +  Math.round(gt/gtw) + "ms  submit time: " +  Math.round(st/stw) + "ms" );
        if ( oc > 0 )
            BTCMiner.printMsg( name + ": Warning: " + oc + " overflows occured. This is usually caused by a slow network connection." );
    }
}
 
 
// *****************************************************************************
// *****************************************************************************
// ******* BTCMiner ************************************************************
// *****************************************************************************
// *****************************************************************************
class BTCMiner implements MsgObj  {
 
// *****************************************************************************
// ******* static methods ******************************************************
// *****************************************************************************
    static final int maxRpcCount = 32;
    static String[] rpcurl = new String[maxRpcCount];
    static String[] rpcuser = new String[maxRpcCount];
    static String[] rpcpassw = new String[maxRpcCount];
    static int rpcCount = 1;
 
    static String longPollURL = null;
    static String longPollUser = "";
    static String longPollPassw = "";
 
    static int bcid = -1;
 
    static String firmwareFile = null;
    static boolean printBus = false;
 
    public final static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
 
    static PrintStream logFile = null;
    static PrintStream logFile2 = null;
    static PrintStream blkLogFile = null;
 
    static InputStream in2 = null;
    static String in2FileName = null;
 
    static double connectionEffort = 2.0;
 
    static NewBlockMonitor newBlockMonitor = null;
 
    static boolean forceEP0Config = false;
 
    static double overheatThreshold = 0.04;
 
    static double maxMaxErrorRate = 0.05;
 
    static double tempLimit = 65;  // in �C
 
    static boolean targetCheck = false;
 
    static String filterSN = null;
 
    public static final String[] dummyFirmwareNames = {
        "USB-FPGA Module 1.15d (default)" ,
        "USB-FPGA Module 1.15x (default)" ,
        "USB-FPGA Module 1.15y (default)"
    };
 
    public static final int[] defaultFirmwarePID1 = {
        13 ,
        13 ,
        15
    };
 
    public static final String[] firmwareFiles = {
        "ztex_ufm1_15d4.ihx" ,
        "ztex_ufm1_15d4.ihx" ,
        "ztex_ufm1_15y1.ihx"
    };
 
    public static final byte[] sha256_init_state = hexStrToData("67e6096a85ae67bb72f36e3c3af54fa57f520e518c68059babd9831f19cde05b");
    public static final byte[] sha256_pad1 = hexStrToData("000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000");
 
// ******* printMsg *************************************************************
    public static void printMsg ( String msg ) {
        System.out.println( msg );
        if ( logFile != null )
            logFile.println( dateFormat.format( new Date() ) + ": " + msg );
        if ( logFile2 != null )
            logFile2.println( dateFormat.format( new Date() ) + ": " + msg );
    }
 
// ******* printMsg2 ************************************************************
    public static void printMsg2 ( String msg ) {
        System.out.println( msg );
        if ( logFile != null )
            logFile.println( dateFormat.format( new Date() ) + ": " + msg );
    }
 
// ******* encodeBase64 *********************************************************
    public static String encodeBase64(String s) {
        return encodeBase64(s.getBytes());
    }
 
    public static String encodeBase64(byte[] src) {
        return encodeBase64(src, 0, src.length);
    }
 
    public static String encodeBase64(byte[] src, int start, int length) {
        final String charSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        byte[] encodeData = new byte[64];
        byte[] dst = new byte[(length+2)/3 * 4 + length/72];
        int x = 0;
        int dstIndex = 0;
        int state = 0;
        int old = 0;
        int len = 0;
        int max = length + start;
 
        for (int i = 0; i<64; i++) {
            byte c = (byte) charSet.charAt(i);
            encodeData[i] = c;
        }
 
        for (int srcIndex = start; srcIndex<max; srcIndex++) {
            x = src[srcIndex];
            switch (++state) {
            case 1:
                dst[dstIndex++] = encodeData[(x>>2) & 0x3f];
                break;
            case 2:
                dst[dstIndex++] = encodeData[((old<<4)&0x30)
                    | ((x>>4)&0xf)];
                break;
            case 3:
                dst[dstIndex++] = encodeData[((old<<2)&0x3C)
                    | ((x>>6)&0x3)];
                dst[dstIndex++] = encodeData[x&0x3F];
                state = 0;
                break;
            }
            old = x;
            if (++len >= 72) {
                dst[dstIndex++] = (byte) '\n';
                len = 0;
            }
        }
 
        switch (state) {
        case 1: dst[dstIndex++] = encodeData[(old<<4) & 0x30];
           dst[dstIndex++] = (byte) '=';
           dst[dstIndex++] = (byte) '=';
           break;
        case 2: dst[dstIndex++] = encodeData[(old<<2) & 0x3c];
           dst[dstIndex++] = (byte) '=';
           break;
        }
        return new String(dst);
    }
 
// ******* hexStrToData ********************************************************
    public static byte[] hexStrToData( String str ) throws NumberFormatException {
        if ( str.length() % 2 != 0 )
            throw new NumberFormatException("Invalid length of string");
        byte[] buf = new byte[str.length() >> 1];
        for ( int i=0; i<buf.length; i++) {
            buf[i] = (byte) Integer.parseInt( str.substring(i*2,i*2+2), 16);
        }
        return buf;
    }
 
    public static void hexStrToData( String str, byte[] buf ) throws NumberFormatException {
        if ( str.length()<buf.length*2 )
            throw new NumberFormatException("Invalid length of string");
        for ( int i=0; i<buf.length; i++) {
            buf[i] = (byte) Integer.parseInt( str.substring(i*2,i*2+2), 16);
        }
    }
 
// ******* hexStrToData2 ********************************************************
    public static void hexStrToData2( String str, byte[] buf ) throws NumberFormatException {
        if ( str.length()<buf.length*2 )
            throw new NumberFormatException("Invalid length of string");
        for ( int i=0; i<buf.length; i++) {
            buf[i] = (byte) (Integer.parseInt( str.substring(i*2,i*2+1), 16) + Integer.parseInt( str.substring(i*2+1,i*2+2), 16)*16);
        }
    }
 
// ******* dataToHexStr ********************************************************
    public static String dataToHexStr (byte[] data)  {
        final char hexchars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
        char[] buf = new char[data.length*2];
        for ( int i=0; i<data.length; i++) {
            buf[i*2+0] = hexchars[(data[i] & 255) >> 4];
            buf[i*2+1] = hexchars[(data[i] & 15)];
        }
        return new String(buf);
    }
 
// ******* dataToInt **********************************************************
    public static int dataToInt (byte[] buf, int offs)  {
        if ( offs + 4 > buf.length )
            throw new NumberFormatException("Invalid length of data");
        return (buf[offs+0] & 255) | ((buf[offs+1] & 255)<<8) | ((buf[offs+2] & 255)<<16) | ((buf[offs+3] & 255)<<24);
    }
 
// ******* intToData **********************************************************
    public static byte[] intToData (int n)  {
        byte[] buf = new byte[4];
        buf[0] = (byte) (n & 255);
        buf[1] = (byte) ((n >> 8) & 255);
        buf[2] = (byte) ((n >> 16) & 255);
        buf[3] = (byte) ((n >> 24) & 255);
        return buf;
    }
 
    public static void intToData (int n, byte[] buf, int offs) {
        buf[offs+0] = (byte) (n & 255);
        buf[offs+1] = (byte) ((n >> 8) & 255);
        buf[offs+2] = (byte) ((n >> 16) & 255);
        buf[offs+3] = (byte) ((n >> 24) & 255);
    }
 
// ******* intToHexStr ********************************************************
    public static String intToHexStr (int n)  {
        return dataToHexStr( reverse( intToData ( n ) ) );
    }
 
// ******* reverse ************************************************************
    public static byte[] reverse (byte[] data)  {
        byte[] buf = new byte[data.length];
        for ( int i=0; i<data.length; i++)
            buf[data.length-i-1] = data[i];
        return buf;
    }
 
// ******* jsonParse ***********************************************************
// does not work if parameter name is a part of a parameter value
    public static String jsonParse (String response, String parameter) throws ParserException {
        int lp = parameter.length();
        int i = 0;
        while ( i+lp<response.length() && !parameter.equalsIgnoreCase(response.substring(i,i+lp)) )
            i++;
        i+=lp;
        if ( i>=response.length() )
            throw new ParserException( "jsonParse: Parameter `"+parameter+"' not found" );
        while ( i<response.length() && response.charAt(i) != ':' )
            i++;
        i+=1;
        while ( i<response.length() && (byte)response.charAt(i) <= 32 )
            i++;
        if ( i>=response.length() )
            throw new ParserException( "jsonParse: Value expected after `"+parameter+"'" );
        int j=i;
        if ( i<response.length() && response.charAt(i)=='"' ) {
            i+=1;
            j=i;
            while ( j<response.length() && response.charAt(j) != '"' )
                j++;
            if ( j>=response.length() )
                throw new ParserException( "jsonParse: No closing `\"' found for value of paramter `"+parameter+"'" );
        }
        else {
            while ( j<response.length() && response.charAt(j) != ',' && response.charAt(j) != /*{*/'}'  )
                j++;
        }
        return response.substring(i,j);
    }
 
 
// ******* checkSnString *******************************************************
// make sure that snString is 10 chars long
    public static String checkSnString ( String snString ) {
        if ( snString.length()>10 ) {
            snString = snString.substring(0,10);
            System.err.println( "Serial number too long (max. 10 characters), truncated to `" + snString + "'" );
        }
        while ( snString.length()<10 )
            snString = '0' + snString;
        return snString;
    }
 
 
// ******* getType *************************************************************
    private static String getType ( ZtexDevice1 pDev ) {
        byte[] buf = new byte[64];
        try {
            Ztex1v1 ztex = new Ztex1v1 ( pDev );
            ztex.vendorRequest2( 0x82, "Read descriptor", 0, 0, buf, 64 );
            if ( buf[0] < 1 || buf[0] > 5 )
                throw new FirmwareException("Invalid BTCMiner descriptor version");
 
            int i0 = buf[0] > 4 ? 11 : ( buf[0] > 2 ? 10 : 8 );
            int i = i0;
            while ( i<64 && buf[i]!=0 )
                i++;
            if ( i < i0+1 )
                throw new FirmwareException("Invalid bitstream file name");
 
            return new String(buf, i0, i-i0);
        }
        catch ( Exception e ) {
            System.out.println("Warning: "+e.getLocalizedMessage() );
        }
        return null;
    }
 
 
// ******* sha256_transform ****************************************************
    public static void sha256_transform(byte[] state, int state_offs, byte[] data, int data_offs, byte[] out, int out_offs) throws NumberFormatException {
        if ( state.length < state_offs+32 )
            throw new NumberFormatException("Invalid length of state");
        if ( data.length < data_offs+64 )
            throw new NumberFormatException("Invalid length of data");
        if ( out.length < out_offs+32 )
            throw new NumberFormatException("Invalid length of out");
 
      final int[] k = {
         0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
         0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
         0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
         0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
         0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
         0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
         0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
         0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
         0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
         0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
         0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
         0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
         0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
         0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
         0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
         0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
     };
 
      int A = dataToInt(state,state_offs+0);
      int B = dataToInt(state,state_offs+4);
      int C = dataToInt(state,state_offs+8);
      int D = dataToInt(state,state_offs+12);
      int E = dataToInt(state,state_offs+16);
      int F = dataToInt(state,state_offs+20);
      int G = dataToInt(state,state_offs+24);
      int H = dataToInt(state,state_offs+28);
      int T, T2;
      int[] wBuf = new int[64];
 
      for (int i = 0; i < 16; i++)
         wBuf[i] = dataToInt(data, data_offs+4*i);
 
      for (int i = 16; i < 64; i++) {
         T = wBuf[i - 2];
         T2 = wBuf[i - 15];
         wBuf[i] = (((T >>> 17) | (T << 15)) ^ ((T >>> 19) | (T << 13)) ^ (T >>> 10)) + wBuf[i - 7] + (((T2 >>> 7) | (T2 << 25)) ^ ((T2 >>> 18) | (T2 << 14)) ^ (T2 >>> 3)) + wBuf[i - 16];
      }
 
      for (int i=0; i < 64; i++) {
         T = H + (((E >>> 6) | (E << 26)) ^ ((E >>> 11) | (E << 21)) ^ ((E >>> 25) | (E << 7))) + ((E & F) ^ (~E & G)) + k[i] + wBuf[i];
         T2 = (((A >>> 2) | (A << 30)) ^ ((A >>> 13) | (A << 19)) ^ ((A >>> 22) | (A << 10))) + ((A & B) ^ (A & C) ^ (B & C));
         H = G;
         G = F;
         F = E;
         E = D + T;
         D = C;
         C = B;
         B = A;
         A = T + T2;
      }
 
      intToData( A+dataToInt(state,state_offs+0), out, out_offs+0 );
      intToData( B+dataToInt(state,state_offs+4), out, out_offs+4 );
      intToData( C+dataToInt(state,state_offs+8), out, out_offs+8 );
      intToData( D+dataToInt(state,state_offs+12), out, out_offs+12 );
      intToData( E+dataToInt(state,state_offs+16), out, out_offs+16 );
      intToData( F+dataToInt(state,state_offs+20), out, out_offs+20 );
      intToData( G+dataToInt(state,state_offs+24), out, out_offs+24 );
      intToData( H+dataToInt(state,state_offs+28), out, out_offs+28 );
   }
 
    public static void printBus ( ZtexScanBus1 bus ) {
        for (int i=0; i<bus.numberOfDevices(); i++ ) {
            ZtexDevice1 dev = bus.device(i);
            System.out.println( i + ": " + dev.toString() );
            try {
                byte buf[] = new byte[6];
                new Ztex1v1(dev).macRead(buf);
                System.out.println("   MAC address: " + dataToHexStr(buf));
            }
            catch (Exception e) {
            }
        }
    }
 
// *****************************************************************************
// ******* non-static methods **************************************************
// *****************************************************************************
    private Ztex1v1 ztex = null;
    private int fpgaNum = 0;
 
    public int numNonces, offsNonces, freqM, freqMDefault, freqMaxM, extraSolutions;
    public double freqM1;
    public double hashesPerClock;
    private String bitFileName = null;
    public String name;
    public String fatalError = null;
    private boolean suspendSupported = false;
 
    public int ioErrorCount[] = new int[maxRpcCount];
    public long disableTime[] = new long[maxRpcCount];
 
    public int rpcNum = 0;
    private int prevRpcNum = 0;
 
    public boolean verbose = false;
    public boolean clusterMode = false;
 
    public Vector<LogString> logBuf = new Vector<LogString>();
 
    private byte[] dataBuf = new byte[128];
    private byte[] dataBuf2 = new byte[128];
    private byte[] midstateBuf = new byte[32];
    private byte[] sendBuf = new byte[44];
    private byte[] hashBuf = hexStrToData("00000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000010000");
    private byte[] targetBuf = hexStrToData("ffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000");
    private double difficulity = 1.0;
 
    private int newCount = 0;
 
    public boolean isRunning = false;
    public boolean suspended = false;
 
    MessageDigest digest = null;
 
    public int[] lastGoldenNonces = { 0, 0, 0, 0, 0, 0, 0, 0 };
    public int[] goldenNonce, nonce, hash7;
    public int submittedCount = 0;
    public double totalSubmittedCount = 0.0;
    public long startTime, startTimeAdjust;
 
    public int overflowCount = 0;
    public long usbTime = 0;
    public double getTime = 0.0;
    public double getTimeW = 1e-6;
    public double submitTime = 0.0;
    public double submitTimeW = 1e-6;
 
    public long maxPollInterval = 20000;
    public long infoInterval = 15000;
 
    public long lastGetWorkTime = 0;
    public long ignoreErrorTime = 0;
    public long lastInfoTime = 0;
 
    public double[] errorCount = new double[256];
    public double[] errorWeight = new double[256];
    public double[] errorRate = new double[256];
    public double[] maxErrorRate = new double[256];
    public final double errorHysteresis = 0.1; // in frequency steps
 
    private double maxHashRate = 0;
 
    private int numberOfFpgas = 0;
    private int[] fpgaMap;
 
// ******* BTCMiner ************************************************************
// constructor
    public BTCMiner ( Ztex1v1 pZtex, String firmwareFile, boolean v ) throws UsbException, FirmwareException, NoSuchAlgorithmException {
 
        digest = MessageDigest.getInstance("SHA-256");
        verbose = v;
 
        ztex = pZtex;
        ztex.tempSensorUpdateInterval = 1000;
        ztex.enableExtraFpgaConfigurationChecks = true;
 
        String snString=null;
        if ( ( ztex.dev().productId(2)==0) && (firmwareFile==null) ) {
            for ( int j=0; j<defaultFirmwarePID1.length; j++ )
                if ( defaultFirmwarePID1[j]==ztex.dev().productId(1) && ztex.dev().productString().equals(dummyFirmwareNames[j]) )
                    firmwareFile = firmwareFiles[j];
            if ( firmwareFile != null ) {
                msg("Using firmware `" + firmwareFile + "'" + " for `" + ztex.dev().productString() +"'" );
                snString = ztex.dev().snString();
            }
        }
 
        if ( firmwareFile != null ) {
            try {
                ZtexIhxFile1 ihxFile = new ZtexIhxFile1( firmwareFile );
                if ( snString != null )
                    ihxFile.setSnString( snString );
                ztex.uploadFirmware( ihxFile, false );
            }
            catch ( Exception e ) {
                throw new FirmwareException ( e.getLocalizedMessage() );
            }
        }
 
        if ( ! ztex.valid() || ztex.dev().productId(0)!=10 || ztex.dev().productId(2)!=1 )
            throw new FirmwareException("Wrong or no firmware");
 
        getDescriptor();
 
        goldenNonce = new int[numNonces*(1+extraSolutions)];
        nonce = new int[numNonces];
        hash7 = new int[numNonces];
 
        name = bitFileName+"-"+ztex.dev().snString();
        msg( "New device: "+ descriptorInfo() );
        try {
            byte buf[] = new byte[6];
            ztex.macRead(buf);
            msg("MAC address: " + dataToHexStr(buf));
        }
        catch (Exception e) {
            msg("No mac address support");
        }
 
 
//      long d = Math.round( 2500.0 / (freqM1 * (freqMaxM+1) * numNonces) * 1000.0 );
//      if ( d < maxPollInterval ) maxPollInterval=d;
 
        numberOfFpgas = 0;
        try {
            fpgaMap = new int[ztex.numberOfFpgas()];
            for (int i=0; i<ztex.numberOfFpgas(); i++ ) {
                try {
                    ztex.selectFpga(i);
                    msg("FPGA "+ (i+1) + ": configuration time: " + ( forceEP0Config ? ztex.configureFpgaLS( "fpga/"+bitFileName+".bit" , true, 2 ) : ztex.configureFpga( "fpga/"+bitFileName+".bit" , true, 2 ) ) + " ms");
                    try {
                        Thread.sleep( 100 );
                    }
                    catch ( InterruptedException e) {
                    }
                    fpgaMap[numberOfFpgas] = i;
                    numberOfFpgas += 1;
                }
                catch ( Exception e ) {
                    msg( "Error configuring FPGA " + i + ": " + e.getLocalizedMessage() );
                }
            }
        }
        catch ( InvalidFirmwareException e ) {
            throw new FirmwareException( e.getLocalizedMessage() );
        }
 
        if ( numberOfFpgas < 1 )
            throw new FirmwareException("No FPGA's found");
 
        fpgaNum = fpgaMap[0];
        name += "-" + (fpgaNum+1);
        msg( "New FPGA" );
        freqM = -1;
        updateFreq();
 
        lastInfoTime = new Date().getTime();
 
        for (int i=0; i<255; i++) {
            errorCount[i] = 0;
            errorWeight[i] = 0;
            errorRate[i] = 0;
            maxErrorRate[i] = 0;
        }
        maxHashRate = freqMDefault + 1.0;
 
        startTime = new Date().getTime();
        startTimeAdjust = startTime;
 
        for (int i=0; i<rpcCount; i++) {
            disableTime[i] = 0;
            ioErrorCount[i] = 0;
        }
 
        if ( newBlockMonitor == null ) {
            newBlockMonitor = new NewBlockMonitor();
        }
 
    }
 
 
    public BTCMiner ( ZtexDevice1 pDev, String firmwareFile, boolean v ) throws UsbException, FirmwareException, NoSuchAlgorithmException {
        this ( new Ztex1v1 ( pDev ), firmwareFile, v );
    }
 
 
    public BTCMiner ( Ztex1v1 pZtex, int pFpgaNum, boolean v ) throws UsbException, FirmwareException, NoSuchAlgorithmException {
        digest = MessageDigest.getInstance("SHA-256");
        verbose = v;
 
        ztex  = pZtex;
        fpgaNum = pFpgaNum;
 
        if ( ! ztex.valid() || ztex.dev().productId(0)!=10 || ztex.dev().productId(2)!=1 || ( ztex.dev().productId(3)<1 && ztex.dev().productId(3)>2 ) )
            throw new FirmwareException("Wrong or no firmware");
 
        getDescriptor();
 
        goldenNonce = new int[numNonces*(1+extraSolutions)];
        nonce = new int[numNonces];
        hash7 = new int[numNonces];
 
        name = bitFileName+"-"+ztex.dev().snString()+"-"+(fpgaNum+1);
 
        try {
            msg( "New FPGA" );
            freqM = -1;
            updateFreq();
 
            lastInfoTime = new Date().getTime();
        }
        catch ( Exception e ) {
            throw new FirmwareException ( e.getLocalizedMessage() );
        }
 
 
        for (int i=0; i<255; i++) {
            errorCount[i] = 0;
            errorWeight[i] = 0;
            errorRate[i] = 0;
            maxErrorRate[i] = 0;
        }
        maxHashRate = freqMDefault + 1.0;
 
        startTime = new Date().getTime();
        startTimeAdjust = startTime;
 
        for (int i=0; i<rpcCount; i++) {
            disableTime[i] = 0;
            ioErrorCount[i] = 0;
        }
 
    }
 
// ******* ztex ****************************************************************
    public Ztex1v1 ztex() {
        return ztex;
    }
 
// ******* numberofFpgas *******************************************************
    public int numberOfFpgas() {
        return numberOfFpgas;
    }
 
// ******* selectFpga **********************************************************
    public void selectFpga() throws UsbException, InvalidFirmwareException, IndexOutOfBoundsException {
        ztex.selectFpga(fpgaNum);
    }
 
// ******* fpgaNum *************************************************************
    public int fpgaNum() {
        return fpgaNum;
    }
 
    public int fpgaNum(int n) throws IndexOutOfBoundsException { // only valid for root miner
        if ( n<0 || n>=numberOfFpgas )
            throw new IndexOutOfBoundsException( "fpgaNum: Invalid FPGA number" );
        return fpgaMap[n];
    }
 
// ******* msg *****************************************************************
    public void msg(String s) {
        if ( clusterMode ) {
            synchronized ( logBuf ) {
                logBuf.add( new LogString( s ) );
            }
        }
        else {
            printMsg( ( name!=null ? name + ": " : "" ) + s );
        }
    }
 
// ******* dmsg *****************************************************************
    void dmsg(String s) {
        if ( verbose )
            msg(s);
    }
 
// ******* print ***************************************************************
    public void print () {
        synchronized ( logBuf ) {
            for ( int j=0; j<logBuf.size(); j++ ) {
                LogString ls = logBuf.elementAt(j);
                System.out.println( name + ": " + ls.msg );
                if ( logFile != null ) {
                    logFile.println( dateFormat.format(ls.time) + ": " + name + ": " + ls.msg );
                }
                if ( logFile2 != null ) {
                    logFile2.println( dateFormat.format(ls.time) + ": " + name + ": " + ls.msg );
                }
            }
            logBuf.clear();
        }
    }
 
// ******* httpGet *************************************************************
    public static String httpGet(MsgObj msgObj, String url, String user, String passw, String request) throws MalformedURLException, IOException {
        HttpURLConnection con = (HttpURLConnection) new URL(url).openConnection();
        con.setRequestMethod("POST");
        con.setConnectTimeout((int) Math.round(2000.0*BTCMiner.connectionEffort));
        con.setReadTimeout(url == longPollURL ? 1000000 : (int) Math.round(2000.0*BTCMiner.connectionEffort));
        con.setRequestProperty("Authorization", "Basic " + encodeBase64(user + ":" + passw));
        con.setRequestProperty("Accept-Encoding", "gzip,deflate");
        con.setRequestProperty("Content-Type", "application/json");
        con.setRequestProperty("Cache-Control", "no-cache");
        con.setRequestProperty("User-Agent", "ztexBTCMiner");
        con.setRequestProperty("X-Mining-Extensions", "longpoll midstate submitold");
        con.setRequestProperty("Content-Length", "" + request.length());
        con.setUseCaches(false);
        con.setDoInput(true);
        con.setDoOutput(true);
 
        // Send request
        OutputStreamWriter wr = new OutputStreamWriter ( con.getOutputStream ());
        wr.write(request);
        wr.flush();
        wr.close();
 
        // read response header
        String str = con.getHeaderField("X-Reject-Reason");
        if( str != null && ! str.equals("") && ! str.equals("high-hash") && ! str.equals("stale-prevblk") && ! str.equals("duplicate") ) {
            msgObj.msg("Warning: Rejected block: " + str);
        }
 
        // read response header
        str = con.getHeaderField("X-Long-Polling");
        if ( str != null && ! str.equals("") && longPollURL==null ) {
            synchronized ( BTCMiner.newBlockMonitor ) {
                if ( longPollURL==null ) {
                    longPollURL = (str.length()>7 && str.substring(0,4).equalsIgnoreCase("http") ) ? str : url+str;
                    msgObj.msg("Using LongPolling URL " + longPollURL);
                    longPollUser = user;
                    longPollPassw = passw;
                }
            }
        }
 
        // read response        
        InputStream is;
        if ( con.getContentEncoding() == null )
            is = con.getInputStream();
        else if ( con.getContentEncoding().equalsIgnoreCase("gzip") )
            is = new GZIPInputStream(con.getInputStream());
        else if (con.getContentEncoding().equalsIgnoreCase("deflate") )
            is = new InflaterInputStream(con.getInputStream());
        else
            throw new IOException( "httpGet: Unknown encoding: " + con.getContentEncoding() );
 
        byte[] buf = new byte[1024];
        StringBuffer response = new StringBuffer();
        int len;
        while ( (len = is.read(buf)) > 0 ) {
            response.append(new String(buf,0,len));
        }
        is.close();
        con.disconnect();
 
        return response.toString();
    }
 
/*    String httpGet(String request) throws MalformedURLException, IOException {
        return httpGet(rpcurl[rpcNum], rpcuser[rpcNum], rpcpassw[rpcNum], request )
    } */
 
// ******* bitcoinRequest ******************************************************
    public static String bitcoinRequest( MsgObj msgObj, String url, String user, String passw, String request, String params) throws MalformedURLException, IOException {
        bcid += 1;
        return httpGet( msgObj, url, user, passw, "{\"jsonrpc\":\"1.0\",\"id\":" + bcid + ",\"method\":\""+ request + "\",\"params\":["+ (params.equals("") ? "" : ("\""+params+"\"")) + "]}" );
    }
 
    public String bitcoinRequest( String request, String params) throws MalformedURLException, IOException {
        String s = bitcoinRequest( this, rpcurl[rpcNum], rpcuser[rpcNum], rpcpassw[rpcNum], request, params );
        ioErrorCount[rpcNum] = 0;
        return s;
    }
 
 
// ******* getWork *************************************************************
    public boolean getWork() throws UsbException, MalformedURLException, IOException, ParserException {
 
        long t = new Date().getTime();
 
        int i = 0;
        while ( i<rpcCount && (disableTime[i]>t) )
            i++;
        if ( i >= rpcCount )
            return false;
 
        rpcNum = i;
        String response = bitcoinRequest("getwork","" );
        t = new Date().getTime() - t;
        getTime = getTime * 0.99 + t;
        getTimeW = getTimeW * 0.99 + 1;
 
        try {
            hexStrToData(jsonParse(response,"data"), dataBuf2);
            newBlockMonitor.checkNew( dataBuf2 );
        }
        catch ( NumberFormatException e ) {
        }
 
        if ( newCount >= newBlockMonitor.newCount || newBlockMonitor.submitOld ) {
            while ( getNonces() ) {}
        }
 
        newCount = newBlockMonitor.newCount;
 
        try {
            hexStrToData(jsonParse(response,"data"), dataBuf);
        }
        catch ( NumberFormatException e ) {
            throw new ParserException( e.getLocalizedMessage() );
        }
 
 
 
        try {
            if ( targetCheck ) {
                hexStrToData(jsonParse(response,"target"), targetBuf);
            }
            else {
                hexStrToData("ffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000", targetBuf);
            }
        }
        catch ( Exception e ) {
            hexStrToData("ffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000", targetBuf);
        }
 
        double d = 1.0;
        difficulity = 0;
        for (int j=0; j<28; j++) {
            difficulity += (targetBuf[j] & 255) * d;
            d*=256;
        }
        difficulity = d / difficulity;
 
        boolean b = false;
        int k = dataBuf.length - sha256_pad1.length;
        for ( int j=0; j<sha256_pad1.length; j++ )
            if ( sha256_pad1[j] != dataBuf[k+j] ) {
                b=true;
                dataBuf[k+j] = sha256_pad1[j];
            }
        if ( b )
            msg("Warning: Invalid data from " + rpcurl[rpcNum]);
 
 
        sha256_transform( sha256_init_state,0, dataBuf,0, midstateBuf,0);
 
        lastGetWorkTime = new Date().getTime();
        prevRpcNum = i;
        return true;
    }
 
// ******* submitWork **********************************************************
    public void submitWork( int n ) throws MalformedURLException, IOException {
        long t = new Date().getTime();
 
        intToData(n, dataBuf, 76);
 
        dmsg( "Submitting new nonce " + intToHexStr(n) );
        if ( blkLogFile != null )
            blkLogFile.println( dateFormat.format( new Date() ) + ": " + name + ": submitted " + dataToHexStr(dataBuf) + " to " + rpcurl[rpcNum]);
        String response = bitcoinRequest( "getwork", dataToHexStr(dataBuf) );
        String err = null;
        try {
            err = jsonParse(response,"error");
        }
        catch ( ParserException e ) {
        }
        if ( err!=null && !err.equals("null") && !err.equals("") )
            msg( "Error attempting to submit new nonce: " + err );
 
        for (int i=lastGoldenNonces.length-1; i>0; i-- )
            lastGoldenNonces[i]=lastGoldenNonces[i-1];
        lastGoldenNonces[0] = n;
 
        t = new Date().getTime() - t;
        submitTime = submitTime * 0.99 + t;
        submitTimeW = submitTimeW * 0.99 + 1;
    }
 
// ******* initWork **********************************************************
    public void initWork (byte[] data, byte[] midstate) {
        if ( data.length != 128 )
            throw new NumberFormatException("Invalid length of data");
        if ( midstate.length != 32 )
            throw new NumberFormatException("Invalid length of midstate");
        for (int i=0; i<128; i++)
            dataBuf[i] = data[i];
        for (int i=0; i<32; i++)
            midstateBuf[i] = midstate[i];
    }
 
// ******* getHash ***********************************************************
    public int getHash(int n) throws NumberFormatException {
        intToData(n, dataBuf, 76);
        sha256_transform( midstateBuf,0, dataBuf,64, hashBuf,0 );
        sha256_transform( sha256_init_state,0, hashBuf,0, hashBuf,0 );
        return dataToInt( hashBuf,28 );
    }
 
// ******* compareWithTarget ***************************************************
    // returns true if smaller than or equal to target
    public boolean compareWithTarget(int n) throws NumberFormatException {
        intToData(n, dataBuf, 76);
        sha256_transform( midstateBuf,0, dataBuf,64, hashBuf,0 );
        sha256_transform( sha256_init_state,0, hashBuf,0, hashBuf,0 );
        for ( int i=0; i<32; i++ ) {
            int j=i+3-2*(i%4);
            if ( (hashBuf[31-j] & 255) < (targetBuf[31-i] & 255) )
                return true;
            if ( (hashBuf[31-j] & 255) > (targetBuf[31-i] & 255) )
                return false;
        }
        return true;
    }
 
// ******* getMidstate *********************************************************
    public byte[] getMidstate() {
        sha256_transform( sha256_init_state,0, dataBuf,0, hashBuf,0);
        return hashBuf;
    }
 
// ******* sendData ***********************************************************
    public void sendData () throws UsbException {
        for ( int i=0; i<12; i++ )
            sendBuf[i] = dataBuf[i+64];
        for ( int i=0; i<32; i++ )
            sendBuf[i+12] = midstateBuf[i];
 
        long t = new Date().getTime();
        synchronized (ztex) {
            try {
                selectFpga();
            }
            catch ( InvalidFirmwareException e )  {
                // shouldn't occur
            }
            ztex.vendorCommand2( 0x80, "Send hash data", 0, 0, sendBuf, 44 );
        }
        usbTime += new Date().getTime() - t;
 
        ignoreErrorTime = new Date().getTime() + 500; // ignore errors for next 1s
        for ( int i=0; i<numNonces; i++ )
            nonce[i] = 0;
        isRunning = true;
    }
 
// ******* setFreq *************************************************************
    public void setFreq (int m) throws UsbException {
        if ( m > freqMaxM ) m = freqMaxM;
 
        long t = new Date().getTime();
        synchronized (ztex) {
            try {
                selectFpga();
            }
            catch ( InvalidFirmwareException e )  {
                // shouldn't occur
            }
            ztex.vendorCommand( 0x83, "Send hash data", m, 0 );
        }
        usbTime += new Date().getTime() - t;
 
        ignoreErrorTime = new Date().getTime() + 2000; // ignore errors for next 2s
    }
 
// ******* suspend *************************************************************
    public boolean suspend ( )  {
        suspended = true;
        if ( suspendSupported ) {
            try {
                synchronized (ztex) {
                    selectFpga();
                    ztex.vendorCommand( 0x84, "Suspend" );
                }
            }
            catch ( Exception e )  {
                msg( "Suspend command failed: " + e.getLocalizedMessage() );
                return false;
            }
        }
        else {
            msg( "Suspend command not supported. Update Firmware." );
            return false;
        }
        return true;
    }
 
// ******* updateFreq **********************************************************
    public void updateFreq() throws UsbException {
 
        for ( int i=0; i<freqMaxM; i++ )  {
            if ( maxErrorRate[i+1]*i < maxErrorRate[i]*(i+20) )
                maxErrorRate[i+1] = maxErrorRate[i]*(1.0+20.0/i);
        }
 
        int maxM = 0;
        while ( maxM<freqMDefault && maxErrorRate[maxM+1]<maxMaxErrorRate )
            maxM++;
        while ( maxM<freqMaxM && errorWeight[maxM]>150 && maxErrorRate[maxM+1]<maxMaxErrorRate )
            maxM++;
 
        int bestM=0;
        double bestR=0;
        for ( int i=0; i<=maxM; i++ )  {
            double r = (i + 1 + ( i == freqM ? errorHysteresis : 0))*(1-maxErrorRate[i]);
            if ( r > bestR ) {
                bestM = i;
                bestR = r;
            }
        }
 
        if ( bestM != freqM ) {
            msg ( "Set frequency " + ( freqM<0 ? "" : "from " + String.format("%.2f",(freqM+1)*(freqM1)) + "MHz ") + "to " + String.format("%.2f",(bestM+1)*(freqM1)) +"MHz" );
            freqM = bestM;
            setFreq( freqM );
        }
 
        maxM = freqMDefault;
        while ( maxM<freqMaxM && errorWeight[maxM+1]>100 )
            maxM++;
        if ( ( bestM+1 < (1.0-overheatThreshold )*maxHashRate ) && bestM < maxM-1 )  {
            try {
                synchronized (ztex) {
                    selectFpga();
                    ztex.resetFpga();
                }
            }
            catch ( Exception e ) {
            }
            throw new UsbException("Hash rate drop of " + String.format("%.1f",(1.0-1.0*(bestM+1)/maxHashRate)*100) + "% detect. This may be caused by overheating. FPGA is shut down to prevent damage." );
        }
 
        double temp;
        try {
            temp = ztex.tempSensorRead(fpgaNum);
        }
        catch ( Exception e ) {
            temp = tempLimit - 1e12;
        }
        if ( temp > tempLimit ) {
            try {
                synchronized (ztex) {
                    selectFpga();
                    ztex.resetFpga();
                }
            }
            catch ( Exception e ) {
            }
            throw new UsbException("Overheating detected: T=" + String.format("%.1f",temp) + "�C. FPGA is shut down to prevent damage." );
        }
 
    }
 
// ******* getNonces ***********************************************************
    public boolean getNonces() throws UsbException, MalformedURLException, IOException {
        if ( !isRunning || disableTime[prevRpcNum] > new Date().getTime() ) return false;
 
        rpcNum = prevRpcNum;
 
        getNoncesInt();
 
        if ( ignoreErrorTime < new Date().getTime() ) {
            errorCount[freqM] *= 0.995;
            errorWeight[freqM] = errorWeight[freqM]*0.995 + 1.0;
            for ( int i=0; i<numNonces; i++ ) {
                if ( ! checkNonce( nonce[i], hash7[i] ) )
                    errorCount[freqM] +=1.0/numNonces;
            }
 
            errorRate[freqM] = errorCount[freqM] / errorWeight[freqM] * Math.min(1.0, errorWeight[freqM]*0.01) ;
            if ( errorRate[freqM] > maxErrorRate[freqM] )
                maxErrorRate[freqM] = errorRate[freqM];
            if ( errorWeight[freqM] > 120 )
                maxHashRate = Math.max(maxHashRate, (freqM+1.0)*(1-errorRate[freqM]));
        }
 
        boolean submitted = false;
        for ( int i=0; i<numNonces*(1+extraSolutions); i++ ) {
            int n = goldenNonce[i];
            if ( n != -offsNonces ) {
                if ( compareWithTarget(n) ) {
                    int j=0;
                    while ( j<lastGoldenNonces.length && lastGoldenNonces[j]!=n )
                        j++;
                    if  (j>=lastGoldenNonces.length) {
                        submitWork( n );
                        submittedCount+=1;
                        totalSubmittedCount+=difficulity;
                        submitted = true;
                    }
                }
            }
        }
        return submitted;
    }
 
// ******* getNoncesInt ********************************************************
    public void getNoncesInt() throws UsbException {
        int bs = 12+extraSolutions*4;
        byte[] buf = new byte[numNonces*bs];
        boolean overflow = false;
 
        long t = new Date().getTime();
        synchronized (ztex) {
            try {
                selectFpga();
            }
            catch ( InvalidFirmwareException e )  {
            // shouldn't occur
            }
            ztex.vendorRequest2( 0x81, "Read hash data", 0, 0, buf, numNonces*bs );
        }
        usbTime += new Date().getTime() - t;
 
//      System.out.print(dataToHexStr(buf)+"            ");
        for ( int i=0; i<numNonces; i++ ) {
            goldenNonce[i*(1+extraSolutions)] = dataToInt(buf,i*bs+0) - offsNonces;
            int j = dataToInt(buf,i*bs+4) - offsNonces;
            overflow |= ((j >> 4) & 0xfffffff) < ((nonce[i]>>4) & 0xfffffff);
            nonce[i] = j;
            hash7[i] = dataToInt(buf,i*bs+8);
            for ( j=0; j<extraSolutions; j++ )
                goldenNonce[i*(1+extraSolutions)+1+j] = dataToInt(buf,i*bs+12+j*4) - offsNonces;
        }
        if ( overflow && ! PollLoop.scanMode )
            overflowCount += 1;
    }
 
// ******* checkNonce *******************************************************
    public boolean checkNonce( int n, int h ) throws UsbException {
        int offs[] = { 0, 1, -1, 2, -2 };
//      int offs[] = { 0 };
        for (int i=0; i<offs.length; i++ ) {
            if ( getHash(n + offs[i]) == h + 0x5be0cd19 )
                return true;
        }
        return false;
    }
 
// ******* totalHashRate *******************************************************
    public double totalHashRate () {
        return fatalError == null ? (freqM+1)*freqM1*(1-errorRate[freqM])*hashesPerClock : 0;
    }
 
// ******* submittedHashRate ***************************************************
    public double submittedHashRate () {
        return fatalError == null ? 4.294967296e6 * totalSubmittedCount / (new Date().getTime()-startTime) : 0;
    }
 
// ******* printInfo ***********************************************************
    public void printInfo( boolean force ) {
        long t = new Date().getTime();
        if ( !force && (clusterMode || lastInfoTime+infoInterval > t || !isRunning) )
            return;
 
        if ( fatalError != null ) {
            printMsg2(name + ": " + fatalError);
            return;
        }
 
        if ( suspended ) {
            printMsg2(name + ": Suspended");
            return;
        }
 
        StringBuffer sb = new StringBuffer( "f=" + String.format("%.2f",(freqM+1)*freqM1)+"MHz" );
 
        if ( errorWeight[freqM]>20 )
            sb.append(",  errorRate="+ String.format("%.2f",errorRate[freqM]*100)+"%");
 
        if ( errorWeight[freqM]>100 )
            sb.append(",  maxErrorRate="+ String.format("%.2f",maxErrorRate[freqM]*100)+"%");
 
/*      if ( freqM<255 && (errorWeight[freqM+1]>100.1 || maxErrorRate[freqM+1]>0.001 ) )
            sb.append(",  nextMaxErrorRate="+ String.format("%.2f",maxErrorRate[freqM+1]*100)+"%"); */
 
        double hr = (freqM+1)*freqM1*(1-errorRate[freqM])*hashesPerClock;
 
        if ( errorWeight[freqM]>20 )
            sb.append(",  hashRate=" + String.format("%.1f", hr )+"MH/s" );
 
        try {
            sb.append(", T=" + String.format("%.1f",ztex.tempSensorRead(fpgaNum)) + "�C");
        }
        catch ( Exception e ) {
        }
 
        sb.append(",  submitted " +submittedCount+" new nonces,  luckFactor=" + String.format("%.2f", submittedHashRate()/hr+0.0049 ));
        submittedCount = 0;
 
        printMsg2(name + ": " + sb.toString());
 
        lastInfoTime = t;
    }
 
// ******* getDescriptor *******************************************************
    private void getDescriptor () throws UsbException, FirmwareException {
        byte[] buf = new byte[64];
 
        ztex.vendorRequest2( 0x82, "Read descriptor", 0, 0, buf, 64 );
        if ( buf[0] != 5 ) {
            if ( ( buf[0] != 2 ) && ( buf[0] != 4 ) ) {
                throw new FirmwareException("Invalid BTCMiner descriptor version. Firmware must be updated.");
            }
            msg("Warning: Firmware out of date");
        }
        numNonces = (buf[1] & 255) + 1;
        offsNonces = ((buf[2] & 255) | ((buf[3] & 255) << 8)) - 10000;
        freqM1 = ( (buf[4] & 255) | ((buf[5] & 255) << 8) ) * 0.01;
        freqM = (buf[6] & 255);
        freqMaxM = (buf[7] & 255);
        if ( freqM > freqMaxM )
            freqM = freqMaxM;
        freqMDefault = freqM;
 
        suspendSupported = buf[0] == 5;
 
        hashesPerClock = buf[0] > 2 ? ( ( (buf[8] & 255) | ((buf[9] & 255) << 8) ) +1 )/128.0 : 1.0;
        extraSolutions = buf[0] > 4 ? buf[10] : 0;
 
        int i0 = buf[0] > 4 ? 11 : ( buf[0] == 4 ? 10 : 8 );
        int i = i0;
        while ( i<64 && buf[i]!=0 )
            i++;
        if ( i < i0+1)
            throw new FirmwareException("Invalid bitstream file name");
        bitFileName = new String(buf, i0, i-i0);
 
        if ( buf[0] < 4 ) {
            if ( bitFileName.substring(0,13).equals("ztex_ufm1_15b") )
                hashesPerClock = 0.5;
            msg( "Warning: HASHES_PER_CLOCK not defined, assuming " + hashesPerClock );
        }
    }
 
// ******* checkUpdate **********************************************************
    public boolean checkUpdate() {
        long t = new Date().getTime();
        if ( !isRunning ) return true;
        if ( ignoreErrorTime > t ) return false;
        if ( newCount < newBlockMonitor.newCount) return true;
        if ( disableTime[prevRpcNum] > t ) return true;
        if ( lastGetWorkTime + maxPollInterval < t ) return true;
        for ( int i=0; i<numNonces ; i++ )
            if ( ((nonce[i]>>1) & 0x7fffffff) > (0x38000000 + Math.round(Math.random()*0x10000000)) ) return true;
        return false;
    }
 
// ******* descriptorInfo ******************************************************
    public String descriptorInfo () {
        return "bitfile=" + bitFileName + "   f_default=" + String.format("%.2f",freqM1 * (freqMDefault+1)) + "MHz  f_max=" + String.format("%.2f",freqM1 * (freqMaxM+1))+ "MHz  HpC="+hashesPerClock+"H";
    }
 
// ******* resetCounters ******************************************************�
    public void resetCounters () {
        while ( freqMDefault<freqM && errorWeight[freqMDefault+1]>100 )
            freqMDefault++;
 
        for ( int i=0; i<255; i++ ) {
            errorCount[i] *= 0.05;
            errorWeight[i] *= 0.05;
            errorRate[i]=0;
            maxErrorRate[i]=0;
        }
        startTime = new Date().getTime();
        totalSubmittedCount = 0;
    }
 
// *****************************************************************************
// ******* main ****************************************************************
// *****************************************************************************
    public static void main (String args[]) {
 
        int devNum = -1;
        boolean workarounds = false;
 
        String firmwareFile = null, snString = null;
        boolean printBus = false;
        boolean verbose = false;
        boolean eraseFirmware = false;
 
        String filterType = null;
        String logFileName = "BTCMiner.log";
 
        char mode = 's';
 
        rpcCount = 1;
        rpcurl[0] = "http://127.0.0.1:8332";
        rpcuser[0] = null;
        rpcpassw[0] = null;
 
        try {
// init USB stuff
            LibusbJava.usb_init();
 
 
// scan the command line arguments
            for (int i=0; i<args.length; i++ ) {
                if ( args[i].equals("-d") ) {
                    i++;
                    try {
                        if (i>=args.length) throw new Exception();
                        devNum = Integer.parseInt( args[i] );
                    }
                    catch (Exception e) {
                        throw new ParameterException("Device number expected after -d");
                    }
                }
                else if ( args[i].equals("-l") ) {
                    i++;
                    if (i>=args.length) {
                        throw new ParameterException("Error: File name expected after `-l'");
                    }
                    try {
                        logFileName = args[i];
                    }
                    catch (Exception e) {
                        throw new ParameterException("Error: File name expected after `-l': "+e.getLocalizedMessage() );
                    }
                }
                else if ( args[i].equals("-l2") ) {
                    i++;
                    if (i>=args.length) {
                        throw new ParameterException("Error: File name expected after `-l2'");
                    }
                    try {
                        logFile2 = new PrintStream ( new FileOutputStream ( args[i], true ), true );
                    }
                    catch (Exception e) {
                        throw new ParameterException("Error: File name expected after `-l2': "+e.getLocalizedMessage() );
                    }
                }
                else if ( args[i].equals("-bl") ) {
                    i++;
                    if (i>=args.length) {
                        throw new ParameterException("Error: File name expected after `-dl'");
                    }
                    try {
                        blkLogFile = new PrintStream ( new FileOutputStream ( args[i], true ), true );
                    }
                    catch (Exception e) {
                        throw new ParameterException("Error: File name expected after `-bl': "+e.getLocalizedMessage() );
                    }
                }
                else if ( args[i].equals("-c") ) {
                    i++;
                    if (i>=args.length) {
                        throw new ParameterException("Error: File name expected after `-c'");
                    }
                    try {
                        in2FileName = args[i];
                        new Thread() {
                            public void run () {
                                try {
                                    in2 = new FileInputStream ( in2FileName );
                                }
                                catch (Exception e) {
                                    System.err.println("Error: File name expected after `-c': "+e.getLocalizedMessage() );
                                }
                            }
                        }.start();
                    }
                    catch (Exception e) {
                        throw new ParameterException("Error: File name expected after `-c': "+e.getLocalizedMessage() );
                    }
                }
                else if ( args[i].equals("-host") ) {
                    i++;
                    try {
                        if (i>=args.length) throw new Exception();
                        rpcurl[0] = args[i];
                    }
                    catch (Exception e) {
                        throw new ParameterException("URL expected after -host");
                    }
                }
                else if ( args[i].equals("-u") ) {
                    i++;
                    try {
                        if (i>=args.length) throw new Exception();
                        rpcuser[0] = args[i];
                    }
                    catch (Exception e) {
                        throw new ParameterException("User expected after -u");
                    }
                }
                else if ( args[i].equals("-p") ) {
                    i++;
                    try {
                        if (i>=args.length) throw new Exception();
                        rpcpassw[0] = args[i];
                    }
                    catch (Exception e) {
                        throw new ParameterException("Password expected after -p");
                    }
                }
                else if ( args[i].equals("-b") ) {
                    i+=3;
                    try {
                        if (i>=args.length) throw new Exception();
                        if ( rpcCount >= maxRpcCount )
                            throw new IndexOutOfBoundsException("Maximum amount of backup servers reached");
                        rpcurl[rpcCount] = args[i-2];
                        rpcuser[rpcCount] = args[i-1];
                        rpcpassw[rpcCount] = args[i];
                        rpcCount+=1;
                    }
                    catch (Exception e) {
                        throw new ParameterException("<URL> <user name> <password> expected after -b");
                    }
                }
                else if ( args[i].equals("-lp") ) {
                    i+=3;
                    try {
                        if (i>=args.length) throw new Exception();
                        longPollURL = args[i-2];
                        longPollUser = args[i-1];
                        longPollPassw = args[i];
                    }
                    catch (Exception e) {
                        throw new ParameterException("<URL> <user name> <password> expected after -lp");
                    }
                }
                else if ( args[i].equals("-f") ) {
                    i++;
                    try {
                        if (i>=args.length) throw new Exception();
                        firmwareFile = args[i];
                    }
                    catch (Exception e) {
                        throw new ParameterException("ihx file name expected after -f");
                    }
                }
                else if ( args[i].equals("-pt") ) {
                    i++;
                    try {
                        if (i>=args.length) throw new Exception();
                        filterType = args[i];
                    }
                    catch (Exception e) {
                        throw new ParameterException("<string> after -pt");
                    }
                }
                else if ( args[i].equals("-ps") ) {
                    i++;
                    try {
                        if (i>=args.length) throw new Exception();
                        filterSN = args[i];
                    }
                    catch (Exception e) {
                        throw new ParameterException("<string> after -ps");
                    }
                }
                else if ( args[i].equals("-m") ) {
                    i++;
                    try {
                        if (i>=args.length) throw new Exception();
                        if ( args[i].length() < 1 ) throw new Exception();
                        mode = Character.toLowerCase( args[i].charAt(0) );
                        if ( mode != 's' && mode != 't'  && mode != 'p' && mode != 'c' ) throw new Exception();
                    }
                    catch (Exception e) {
                        throw new ParameterException("s|t|p|c expected after -m");
                    }
                }
                else if ( args[i].equals("-s") ) {
                    i++;
                    if ( i >= args.length ) {
                        throw new ParameterException("Error: String expected after -s");
                    }
                    snString = checkSnString(args[i]);
                }
                else if ( args[i].equals("-i") ) {
                    printBus = true;
                }
                else if ( args[i].equals("-v") ) {
                    verbose = true;
                }
                else if ( args[i].equals("-rf") ) {
                    eraseFirmware = true;
                }
                else if ( args[i].equals("-ep0") ) {
                    forceEP0Config = true;
                }
                else if ( args[i].equals("-tc") ) {
                    targetCheck = true;
                }
                else if ( args[i].equals("-h") ) {
                        System.err.println(ParameterException.helpMsg);
                        System.exit(0);
                }
                else if ( args[i].equals("-n") ) {
                    i++;
                    try {
                        if (i>=args.length) throw new Exception();
                         BTCMinerCluster.maxDevicesPerThread = Integer.parseInt( args[i] );
                    }
                    catch (Exception e) {
                        throw new ParameterException("Number expected after -n");
                    }
                }
                else if ( args[i].equals("-oh") ) {
                    i++;
                    try {
                        if (i>=args.length) throw new Exception();
                        overheatThreshold = Double.parseDouble( args[i] );
                    }
                    catch (Exception e) {
                        throw new ParameterException("Number expected after -oh");
                    }
                }
                else if ( args[i].equals("-t") ) {
                    i++;
                    try {
                        if (i>=args.length) throw new Exception();
                        tempLimit = Double.parseDouble( args[i] );
                    }
                    catch (Exception e) {
                        throw new ParameterException("Number expected after -t");
                    }
                }
                else if ( args[i].equals("-e") ) {
                    i++;
                    try {
                        if (i>=args.length) throw new Exception();
                        double d = Double.parseDouble( args[i] );
                        if ( d < 0.0001 ) d = 0.0001;
                        if ( d < maxMaxErrorRate ) maxMaxErrorRate = d;
                    }
                    catch (Exception e) {
                        throw new ParameterException("Number expected after -e");
                    }
                }
                else throw new ParameterException("Invalid Parameter: "+args[i]);
            }
 
            logFile = new PrintStream ( new FileOutputStream ( logFileName, true ), true );
 
            if ( overheatThreshold > 0.1001 ) System.err.println("Warning: overheat threshold set to " + overheatThreshold +": overheat shutdown may be triggered too late, recommended values: 0..0.1");
 
            if ( BTCMinerCluster.maxDevicesPerThread < 1 )
                BTCMinerCluster.maxDevicesPerThread = 127;
 
            if ( mode != 'c' && filterSN != null)
                filterSN = checkSnString(filterSN);
 
            if ( mode != 't' && mode != 'p' ) {
                if ( rpcuser[0] == null ) {
                    System.out.print("Enter RPC user name: ");
                    rpcuser[0] = new BufferedReader(new InputStreamReader( System.in) ).readLine();
                }
 
                if ( rpcpassw[0] == null ) {
                    System.out.print("Enter RPC password: ");
                    rpcpassw[0] = new BufferedReader(new InputStreamReader(System.in) ).readLine();
                }
            }
 
/*          Authenticator.setDefault(new Authenticator() {
                protected PasswordAuthentication getPasswordAuthentication() {
                    return new PasswordAuthentication (BTCMiner.rpcuser, BTCMiner.rpcpassw.toCharArray());
                }
            }); */
 
 
            if ( mode == 's' || mode == 't' ) {
                if ( devNum < 0 )
                    devNum = 0;
 
                ZtexScanBus1 bus = new ZtexScanBus1( ZtexDevice1.ztexVendorId, ZtexDevice1.ztexProductId, filterSN==null, false, 1,  filterSN, 10, 0, 1, 0 );
                if ( bus.numberOfDevices() <= 0) {
                    System.err.println("No devices found");
                    System.exit(0);
                }
                if ( printBus ) {
                    printBus(bus);
                    System.exit(0);
                }
 
                BTCMiner miner = new BTCMiner ( bus.device(devNum), firmwareFile, verbose );
                if ( mode == 't' ) { // single mode
                    miner.initWork(
                        hexStrToData( "0000000122f3e795bb7a55b2b4a580e0dbba9f2a5aedbfc566632984000008de00000000e951667fbba0cfae7719ab2fb4ab8d291a20d387782f4610297f5899cc58b7d64e4056801a08e1e500000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000" ),
                        hexStrToData( "28b81bd40a0e1b75d18362cb9a2faa61669d42913f26194f776c349e97559190" )
                    );
 
                    miner.sendData ( );
                    for (int i=0; i<200; i++ ) {
                        try {
                            Thread.sleep( 250 );
                        }
                        catch ( InterruptedException e) {
                        }
                        miner.getNoncesInt();
 
                        for ( int j=0; j<miner.numNonces; j++ ) {
                            System.out.println( i +"-" + j + ":  " + intToHexStr(miner.nonce[j]) + "    " + miner.checkNonce(miner.nonce[j],miner.hash7[j])  + "   " +  miner.overflowCount + "    " + intToHexStr(miner.goldenNonce[j*(1+miner.extraSolutions)]) + "      "  + intToHexStr( miner.getHash( miner.goldenNonce[j]) ) );
                        }
                    }
                }
                else { // single mode
                    Vector<BTCMiner> v = new Vector<BTCMiner>();
                    v.add ( miner );
                    for ( int i=1; i<miner.numberOfFpgas(); i++ )
                        v.add(new BTCMiner(miner.ztex(), miner.fpgaNum(i), verbose) );
                    System.out.println("");
                    if ( miner.ztex().numberOfFpgas()>1 )
                        System.out.println("A multi-FPGA board is detected. Use the cluster mode for additional statistics.");
                    System.out.println("Disconnect device or press Ctrl-C for exit\n");
                    new PollLoop(v).run();
                }
            }
            else if ( mode == 'p' ) {
                if ( eraseFirmware && filterType == null && filterSN == null )
                    throw new ParameterException("-rf requires -pt or -ps");
 
/*              ZtexScanBus1 bus = ( filterType == null && filterSN == null )
                        ? new ZtexScanBus1( ZtexDevice1.cypressVendorId, ZtexDevice1.cypressProductId, true, false, 1)
                        : new ZtexScanBus1( ZtexDevice1.ztexVendorId, ZtexDevice1.ztexProductId, false, false, 1, null, 10, 0, 1, 0 ); */
                ZtexScanBus1 bus = new ZtexScanBus1( ZtexDevice1.ztexVendorId, ZtexDevice1.ztexProductId, filterType==null && filterSN==null, false, 1, null, 10, 0, 0, 0 );
 
                if ( bus.numberOfDevices() <= 0) {
                    System.err.println("No devices found");
                    System.exit(0);
                }
                if ( printBus ) {
                    printBus(bus);
                    System.exit(0);
                }
                if ( firmwareFile == null && !eraseFirmware )
                    throw new Exception("Parameter -f or -rf required in programming mode");
 
                int imin=0, imax=bus.numberOfDevices()-1;
                if ( devNum >= 0 ) {
                    imin=devNum;
                    imax=devNum;
                }
 
                ZtexIhxFile1 ihxFile = eraseFirmware ? null : new ZtexIhxFile1( firmwareFile );
 
                int j = 0;
                for (int i=imin; i<=imax; i++ ) {
                    ZtexDevice1 dev = bus.device(i);
                    if ( ( filterSN == null || filterSN.equals(dev.snString()) ) &&
                         ( filterType == null || ( (dev.productId(2) == 1) && filterType.equals(getType(dev))) ) &&
                         ( filterType != null || filterSN != null || dev.productId(2) == 0) ) {
                        Ztex1v1 ztex = new Ztex1v1 ( dev );
                        if ( snString != null && ihxFile != null )
                            ihxFile.setSnString( snString );
                        else if ( ztex.valid() && ihxFile != null )
                            ihxFile.setSnString( dev.snString() );
                        if ( eraseFirmware ) {
                            ztex.eepromDisable();
                            System.out.println("EEPROM erased: " + ztex.toString());
                        }
                        else {
                            System.out.println("\nold: "+ztex.toString());
                            System.out.println("Firmware upload time: " + ztex.uploadFirmware( ihxFile, false ) + " ms");
                            System.out.println("EEPROM programming time: " + ztex.eepromUpload( ihxFile, false ) + " ms");
                            System.out.println("new: " + ztex.toString());
                        }
                    j+=1;
                    }
                }
                System.out.println("\ntotal amount of (re-)programmed devices: " + j);
            }
            else if ( mode == 'c' ) {
                new BTCMinerCluster( verbose );
            }
 
 
        }
        catch (Exception e) {
            System.out.println("Error: "+e.getLocalizedMessage() );
        }
 
        if ( BTCMiner.newBlockMonitor != null ) {
            BTCMiner.newBlockMonitor.running = false;
            BTCMiner.newBlockMonitor.interrupt();
        }
 
        System.exit(0);
 
   }
 
}
Browse

Tools

Subversion Repositories btcminer

[/] [btcminer/] [trunk/] [BTCMiner.java] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	ZTEX	`/*!`
2			`BTCMiner -- BTCMiner for ZTEX USB-FPGA Modules`
3			`Copyright (C) 2011-2012 ZTEX GmbH`
4			`http://www.ztex.de`
5
6			`This program is free software; you can redistribute it and/or modify`
7			`it under the terms of the GNU General Public License version 3 as`
8			`published by the Free Software Foundation.`
9
10			`This program is distributed in the hope that it will be useful, but`
11			`WITHOUT ANY WARRANTY; without even the implied warranty of`
12			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
13			`General Public License for more details.`
14
15			`You should have received a copy of the GNU General Public License`
16			`along with this program; if not, see http://www.gnu.org/licenses/.`
17			`!*/`
18
19			`/* TODO:`
20			`* HUP signal`
21			`* rollntime / expire`
22			`*/`
23
24
25			`import java.io.*;`
26			`import java.util.*;`
27			`import java.net.*;`
28			`import java.security.*;`
29			`import java.text.*;`
30			`import java.util.zip.*;`
31
32			`import ch.ntb.usb.*;`
33
34			`import ztex.*;`
35
36			`// *****************************************************************************`
37			`// ***** ParameterException ************************************************`
38			`// *****************************************************************************`
39			`// Exception the prints a help message`
40			`class ParameterException extends Exception {`