#!/usr/bin/python
import sys
import socket
import struct
import time
import sys,getopt
import os
import random
import numpy
import datetime

class EtherIO:
    " Ethernet IO class for PSPEPS local bus access through mem_gateway "
    def __init__(self, ip, port):

    def __del__(self):

    def get_lbnl_rom(self):
        " read lbnl config_romx"
        return self.read_mem_gate(range(0x100,0x100+48))

    def decode_lbnl_rom(self, dat):
        " decode content of config_romx "
        d = numpy.bitwise_and(dat, 0xff)
        if (d[0] == 85):
            board={1:"mebt",2:"interim",3:"fcm",4:"avnet",5:"uxo",6:"llrf4",7:"av5t",8:"sp601",9:"sp605",10:"ml505",11:"ml506",12:"fllrf",13:"spec",14:"lx150t",15:"cute_wr",17:"ac701",99:"test"}
            user={1:"ldoolitt",2:"cswanson",3:"kasemir",4:"hengjie",5:"crofford",6:"meddeler",7:"baptiste",8:"llrf_oper",9:"hyaver",10:"dim",11:"begcbp",12:"ghuang",13:"luser",14:"kstefan",15:"cserrano",16:"asalom",17:"du"}
            dtime = datetime.datetime(d[2]+2000,d[3],d[4],d[5],d[6])
            rom={}
            rom['DSP flavor'] = '{:d}'.format(d[1])
            rom['Build date'] = '{:%Y-%m-%d}'.format(dtime)
            rom['Build time'] = '{:%H:%M:%S} UTC'.format(dtime)
            rom['Tool rev']   = '{0:d}.{1:d}'.format(d[8]/16,d[8]%16)
            rom['User']       = '{0:d} ({1})'.format(d[9],user[d[9]])
            rom['Board type'] = '{0:d} ({1})'.format(d[10],board[d[10]])
            gs=""
            for ix in range(0,20):
                gs+=chr(d[12+ix])
            rom['git commit'] = gs.encode('hex')[:6]
            if d[32] == 170:
                rom['circle_aw'] = '{:d}'.format(d[33])
                rom['mode_count'] = '{:d}'.format(d[34])
                rom['mode_shift'] = '{:d}'.format(d[35])
                rom['n_mech_modes'] = '{:d}'.format(d[36])
                rom['df_scale'] = '{:d}'.format(d[37])
                rom['simple_demo'] = '{:d}'.format(d[38])

            return rom
        else:
            print "no magic found %d"%d[0]
            return {}

    def print_lbnl_rom(self, rom_dict):
        for key in rom_dict.keys():
            print key, rom_dict[key]

    def read_mem_buf(self, reg_address, reg_size):
        """
            A valid Ethernet packet has a minimum size of 64 octets, or 18 bytes of UDP payload.
            Each inquiry of read_mem_gate has 8 bytes of preamble, with each address reading cmd
            of 8 bytes payload (0x10 + three_bytes_ad + 4' '). So min operation of read_mem_gate
            should have at least 2 addresses to read.
        """
        print reg_address,reg_size
        res=[]
#        while (not self.read_mem_gate(range(0,32))[0]>>8&1):
#            print 'circular buffer not ready yet'
#            time.sleep(0.02)
        #for index in range(0x4000,0x6000,0x40):
        for index in range(reg_address,reg_address+reg_size,0x40):
            res.extend(self.read_mem_gate(range(index,index+0x40)))
        # assume 8 bits selected in ch_keep
        return res

    def get_init_reg(self, f_name):
        reg_addr = []
        reg_darray = []
        with open(f_name, 'r') as f:
            addr_darray = f.read().split('\n')
        for line in addr_darray:
        #if line:
        #    (ad, vd) = map(int, line.split())
        #    addr.append(ad)
        #    value.append(vd)
            aa = line.split()
            if aa:
                reg_addr.append(int(aa[0]))
                v=int(aa[1])
                if (v<0): v += 2**32
                reg_darray.append(v)
        return (reg_addr, reg_darray)

def cmoc_main(argv):
    from matplotlib import pyplot as plt
    target = EtherIO('rflab1.lbl.gov', 3000)
    rom = target.get_lbnl_rom()
    target.print_lbnl_rom(target.decode_lbnl_rom(rom))

    fig=plt.figure(1)
    fig.show()

    # send the address/value pairs created by param.py to the hardware
    (addr, value) = target.get_init_reg('larger_in.dat')
    target.write_mem_gate(addr,value);

    #fcnt=0;
    while (1):
        target.write_mem_gate(addr,value);
        res = target.read_mem_buf()
        varray=numpy.array([x-65536 if x>32767 else x for x in res]).reshape([-1,8])
        #varray=numpy.array([x-65536 if x>32767 else x for x in res]).reshape([1024,8])
#        numpy.savetxt("live%d.dat"%fcnt,res,'%6.0f')
        #fcnt += 1
        plt.plot(varray)
        fig.canvas.draw()
        fig.clf()

def main(argv):
	from time import gmtime, strftime
	if len(argv)==0:
		usage()
		sys.exit()
	try:
		opts, args = getopt.getopt(argv, 'hoa:t:s:',['help','target=','address=','size='])
	except getopt.GetoptError as err:
		print str(err)
		sys.exit(2)

	ip_addr = '192.168.21.21'
	port = 3000
	reg_address = 0x100
	reg_size = 0x100

	for opt,arg in opts:
		if opt in ('-h', '--help'):
			usage()
			sys.exit()
		elif opt in ('-t', '--target'):
			ip_addr = arg
		elif opt in ('-a', '--address'):
			reg_address = arg
		elif opt in ('-s', '--size'):
			reg_size = arg

	target = EtherIO(ip_addr, port)
	rom = target.get_lbnl_rom()
	target.print_lbnl_rom(target.decode_lbnl_rom(rom))

	fcnt = 0;
	while (1):
		res = target.read_mem_buf(reg_address, reg_size)
		print strftime("%Y-%m-%d %H:%M:%S", gmtime())
		print len(res),res,numpy.array(res)-res[0]
		print fcnt;
		fcnt = fcnt+1;
		time.sleep(1);

def usage():
    print 'usage: mbtest.py [commands]'
    print '-t, --target <ip address>'
    print '-h, --help'
    print '-a, --address <address in hex>'

if __name__ == "__main__":
    main(sys.argv[1:])
