Why post it at all at this point?

it look very ugly, when complete can you give better look?

Well I'll be damned.

Weird stuff.

A google search query of the device ID's ("idVendor=0x1234" "idProduct=0x1010") yields many links to z.download.csdn.net where such information is referenced almost exactly, some kind of chinese internet forum. Apparently this has something to do with "STM32", which is a model of ARM Cortex MCUs. It seems to me the device id's referenced might be the ones of those devices.

Or maybe it's a generic idVendor and idProduct, but those were the only matches I could find.

Otherwise I could not find any correlation between what he posted and anything currently findable by google.

I have to say, it's a mystery. Maybe he does have an fpga miner, but it's single-threaded and does not resolve any of the scrypt fpga-mining issues that makes it so unprofitable so is more or less exactly worthless.

Post the source to test_miner.py, since all it is is a mining client and would not release any confidential information. If it shows legitimate USB or serial port interfacing code of some sort then I'll believe you.

import usb.core
import usb.util
import time
from threading import Thread, Event, RLock
import sys
import re
import struct

# find our device
dev = usb.core.find(idVendor=0x1234, idProduct=0x1010)

# was it found?
if dev is None:
    raise ValueError('Device not found')

# set the active configuration. With no arguments, the first
# configuration will be the active one
dev.set_configuration()

run_app = 1

def get_time_str():
   lt = time.localtime(time.time())
   return "%d:%d:%d" %(lt.tm_hour, lt.tm_min, lt.tm_sec)

#######################################################################################      
#######################################################################################      
class   EP2_listener(Thread):
   def   __init__(self):
      Thread.__init__(self)
      self.count = [0, 0]
      self.starttime = time.time()
      self.daemon = True
   def run(self):
      global run_app
      print "[%s]EP2_listener started" % get_time_str()
      while run_app:
         ret = ''
         try:
            ret = dev.read(0x82, 64, 0, 100)
            log_msg = ''.join([chr(x) for x in ret])
            sys.stdout.write(log_msg)
         except Exception as e:
            pass      
         if len(ret) == 0:
            time.sleep(0.01)

############ startez thread #########
listener = EP2_listener()            
listener.start()
#####################################

def wr_dev_ok_err(msg):

   try:
      dev.write(1, msg, 0, 3100)
      tick = time.time()   
      while time.time() < tick + 1.0:
         try:
            ret = dev.read(0x81, 64, 0, 3100)
            retbuf = ''.join([chr(x) for x in ret])
            if re.search("OK", retbuf):
               print retbuf
               return 1
            if re.search("ERR", retbuf):
               print retbuf
               return -1
            if re.search("BUSY", retbuf):
               print retbuf
               return -2
            print "retbuf="+retbuf
         except Exception as e:
            print e
            pass
   except Exception as e:
      print e
      pass
   return 0


def get_ok():
   tick = time.time()   
   while time.time() < tick + 1.0:
      try:
         ret = dev.read(0x81, 256, 0, 3100)
         retbuf = ''.join([chr(x) for x in ret])
         if re.search("OK", retbuf):
            print "got OK:" + retbuf
            return 1
         if re.search("ERR", retbuf):
            print retbuf
            return -1
         if re.search("BUSY", retbuf):
            print retbuf
            return -2
         print "retbuf="+retbuf
      except Exception as e:
         print e
         pass
   

def wr_dev(msg):

   try:
      dev.write(1, msg, 0, 3100)
      tick = time.time()   
      while time.time() < tick + 1.0:
         try:
            ret = dev.read(0x81, 64, 0, 3100)
            retbuf = ''.join([chr(x) for x in ret])
            if len(retbuf):
               #print "retbuf="+retbuf
               return retbuf
         except Exception as e:
            #print e
            pass
   except Exception as e:
      #print e
      pass
   return 0   

def ask_op(op):
   wr_dev("Z7X,00000000%02x"% (op &0xff))
   retcode = wr_dev("Z7X,0100000200")
   return retcode
   
def memvar_dump(ram_off, len, name):

   wr_dev("Z7X,%08lx05" % ram_off)
   
   ar = []
   for j in xrange(len):
      retcode = ask_op(0x07)
      val = 0
      try:
         val = int(retcode, 16)
      except:
         pass
      ar.append(val)
   return ar   
tick = time.time()
run_once = 1
time.sleep(0.5)
print "GET_ID=%s" % ask_op(1)


########################################################
#### dll result ####
########################################################
#######################################################################################      
#######################################################################################      

def uint32(x):
   return x & 0xffffffffL

def bytereverse(x):
   return uint32(( ((x) << 24) | (((x) << & 0x00ff0000) |
         (((x) >> & 0x0000ff00) | ((x) >> 24) ))

def bufreverse(in_buf):
   out_words = []
   for i in range(0, len(in_buf), 4):
      word = struct.unpack('@I', in_buf[i:i+4])[0]
      out_words.append(struct.pack('@I', bytereverse(word)))
   return ''.join(out_words)

#######################################################################################      
host = "127.0.0.1"
http_port = 8337
#host = "mine.pool-x.eu"
#http_port = 8337
#host = "pool1.us.multipool.us"
#http_port = 17777
host = "mining.eu.hypernova.pw"
http_port = 9332
host = "pooledbits.com"
http_port = 8332
user = "xxxx"
password = "x"
#######################################################################################      



import json
import base64

from ctypes import cdll, byref
lib = cdll.LoadLibrary('./scrypt.dll')
#print lib
import ctypes
class Scrypt(object):
   def __init__(self):
      #self.obj = lib.say_hello()
      none = 0
   def scanhash(self, pdata, ptarget, max_nonce, c_long_last_nonce, n):
      return lib.scanhash_scrypt(pdata, ptarget, max_nonce, c_long_last_nonce, n)


scr = Scrypt()
long_polling_path = ''

import time

while 1:
   #try:
   if 1:
      #print "getwork->con_init()"
      import httplib
      conn = httplib.HTTPConnection(host, http_port, True, 10)
      #print "getwork->con_established"
      
      req = json.dumps({"method": "getwork", "params": [], "id": 'json'})
      auth = "Basic " + base64.b64encode(user+ ":" + password)
      headers = {"User-Agent": "lt_miner", "Content-type": "application/json", "Content-Length": len(req), "Authorization": auth}
      #print "getwork->req_sent"
      conn.request("POST", '/', req, headers)
      #print "getwork->req_answered"
      http_response = conn.getresponse()
      buf = http_response.read()
      #print "http_response=%s" % buf
      response = json.loads(buf)
      #print "getwork->got_data"
      if response["error"] != None:
         print "error [%s]" % response["error"]
         sys.exit(1)
      if response["result"]:
            #print("getwork() ok\n")
            work = response['result']   
            #print work
            if long_polling_path == '':
               headers = http_response.getheaders()                                 
               for (key,val) in headers:
                  if key == "x-long-polling":
                     long_polling_path = val
            if long_polling_path != '':
               do_long_poll = True
               
            ######################################################
            stime = time.time()
            last_nonce = ctypes.c_long(0)
            #n = 0
            #data = work['data'].decode('hex')
            data_orig = work['data']
            data_pt_c = work['data'].decode('hex')
            #target = work['target'].decode('hex')
            target_pt_c = work['target'].decode('hex')
            target = work['target']
            #print "data_orig=%s" % data_orig
            #print "target(full, bytereversed)=%s" % target
            print "data=%s." % data_orig[:73]
            # sys.exit(1)
            #res = scr.scanhash(data, target, 0xffff, byref(last_nonce), n )
            
            
            ######################################################
            target_short = 0xffffffff
            if len(target) > 8:
               #target_short = bufreverse(target[56:].decode('hex'))
               target_short = bytereverse(int(target[56:], 16)) ^ 0xffffffff
            target_short = 0xffff0000   #wired diff 1
            #print "target(bit_complemented)=%08lx" % target_short
            data = data_orig.decode('hex')
            data = bufreverse(data)
            #print data.encode('hex')
            
            ram_off = 4262
            wr_dev("Z7X,%08lx05" % ram_off)
            for i in xrange(19):
               word = struct.unpack('@I', data[i*4:i*4+4])[0]
               wr_dev("Z7X,%08lx06" % word)
            wr_dev("Z7X,0000000006")   #### nonce
            wr_dev("Z7X,0000ffff06")   #### range
            wr_dev("Z7X,%08lx06" % target_short)
            wr_dev("Z7X,000000000e")   
            start = time.time()
            tick = time.time() + 1.0
            while 1:
               time.sleep(0.1)
               retcode = wr_dev("Z7X,0000000000")
               if re.search("515151", retcode):
                  time.sleep(0.01)
               else:
                  retcode = wr_dev("Z7X,0000000000")
                  if not re.search("515151", retcode):
                     time.sleep(0.01)
                     delta_time = (time.time() - start) * 1000
                     print "Scanhash took %d ms" % (delta_time),
                     rram = memvar_dump(4281, 1, "nonce")
                     print "/ Approximate speed = %.2f kHash" %((float(rram[0])) / (delta_time))
                     break
               if time.time() > tick:
                  tick = time.time() + 1.0
                  print ".",

            rram = memvar_dump(4281, 1, "nonce")
            nonce = rram[0]
            res = 0
            if nonce < 0x10000:
               res = 1
            ###########################################################################
            nonce_str = "%08lx" %(nonce & 0xffffffff)
            data_new = data_orig[:156] + nonce_str[4:] + data_orig[160:]
            n = nonce - 1   
            res2 = scr.scanhash(data_pt_c, target_pt_c, nonce + 1, byref(last_nonce), n )
            if res != 0 and res2 != 0:
               f = open("succ.txt", "a")
               f.write("----NEW BLOCK----\n")
               f.write("data_orig:\n%s\n" % data_orig)
               f.write("data_new:\n%s\n" % data_new)
               f.write("nonce=%08lx\n" % nonce)
               try:
                  sconn = httplib.HTTPConnection(host, http_port, True, 10)
                  req = json.dumps({"method": "getwork", "params": [data_new], "id": 0})
                  auth = "Basic " + base64.b64encode(user+ ":" + password)
                  headers = {"User-Agent": "lt_miner", "Content-type": "application/json", "Content-Length": len(req), "Authorization": auth}
                  sconn.request("POST", '/', req, headers)
                  response = json.loads(sconn.getresponse().read())
                  if response["error"] != None:
                     print ("Server reported error: %s\n" % response["error"])
                     f.write("Server reported error: %s\n" % response["error"]);
                     time.sleep(1.0)
                  if response["result"]:
                     print "%04x accepted"  % (nonce)
                     f.write("accepted nonce=%04x %s\n"  % (nonce, response["result"]));
                  else:
                     f.write("rejected share [%s]\n" % response["result"]);
                     
               except Exception as e:
                  print("Error while uploading share e=%s\n" % e)
                  f.write("Error while uploading share e=%s\n" % e);
                  time.sleep(1.0)            
               f.write("----END BLOCK----\n\n")
               f.close()

   # except Exception as e:
      # print e
      # sys.exit(1)
   time.sleep(1.0)

Invidia  ...man tu fa treaba mai departe si loveste piata la timpul potrivit 

Will you be releasing the vhdl sources? Have you overcome the problem of mass parallelization that is required to get high performance? What is the model/make is your FPGA and how much did it cost?

I do not quite understand why you are being so informal about something that would be so significant? Is this a joke or real?

Aw, asa faci mereu, dai cu teaser-u´ si fugi.
Stai asa, arunca-ne si noua o firimitura...ce faci acolo, cresti barzauni acum?

Super tare. deci vei fi printre primii romani care va avea BFL

Weekend-ul acesta dam drumul si la bitcoinromania.info unde de asemeni vom lansa podcast Bitcoin ROmania.

Esti invitatul nostru pentru primul episod unde cred ca te vei mandri cu noua achizitie, facand un Unboxing & Demo.

Sa il stapanesti sanatos si sa produci cat mai multi betecei:P