import usb.core
import usb.util
import time
import numpy
import sys
from erle import encode

def convlen(a,1):           ##숫자를 원하는 길이의 이진수로 변환하고 빈자리를 0으로 채움.
    b=bin(a)[2:]
    padding=1-len(b)
    b='0'*padding+b

    return b

def bitstobytes(a):         ##이진수 데이터를 바이트로 변환
    bytelist=[]
    if len(a)%8!=0:
        padding=8-len(a)%8
        a='0'*padding+a
    for i in range(len(a)//8):
        bytelist.append(int(a[8*i:8*(i+1)],2))

    bytelist.reverse()

    return bytelist

class dmd():
    def __init__(self):             ##초기화 함수, DMD 연결 확인
        self.dev=usb.core.find(idVendor=0x0451 ,idProduct=0xc900)

        self.dev.set_configuration()

        self.ans=[]

    def command(self,mode,sequencebyte,com1,com2,data=None):
        buffer = []

        flagstring=''
        if mode=='r':
            flagstring+='1'
        else:
            flagstring+='0'
        flagstring+='1000000'
        buffer.append(bitstobytes(flagstring)[0])
        buffer.append(sequencebyte)
        temp=bitstobytes(convlen(len(data)+2,16))
        buffer.append(temp[0])
        buffer.append(temp[1])
        buffer.append(com2)
        buffer.append(com1)

        if len(buffer)+len(data)<65:

            for i in range(len(data)):
                buffer.append(data[i])
            
            for i in range(64-len(buffer)):
                buffer.append(0x00)
            
            self.dev.write(1,buffer)

        else:
            for i in range(64-len(buffer)):
                buffer.append(data[i])
            
            self.dev.write(1,buffer)

            buffer = []

            j=0
            while j<len(data)-58:
                buffer.append(data[j+58])
                j=j+1
                if j%64==0:
                    self.dev.write(1, buffer)

                    buffer = []
            if j%64!=0:
                while j%64!=0:
                    buffer.append(0x00)
                    j=j+1
                
                self.dev.write(1, buffer)

        self.ans=self.dev.read(0x81,64)

    def checkforerrors(self):               ##에러코드 표시 (숫자)
        self.command('r',0x22,0x01,0x00,[])
        if self.ans[6]!=0:
            print (self.ans[6])   
    
    def readreply(self):                    ##에러 확인 코드
        for i in self.ans:
            print (hex(i))

    def idle_on(self):                      ##화면 켜기
        self.command('w',0x00,0x02,0x01,[int('00000001',2)])
        self.checkforerrors()

    def idle_off(self):                     ##화면 끄기
        self.command('w',0x00,0x02,0x01,[int('00000000',2)])
        self.checkforerrors()

    def standby(self):                      ##절전 모드
        self.command('w',0x00,0x02,0x00,[int('00000001',2)])
        self.checkforerrors()

    def wakeup(self):                       ##작동 모드
        self.command('w',0x00,0x02,0x00,[int('00000000',2)])
        self.checkforerrors()

    def reset(self):                        ##소프트웨어 재부팅
        self.command('w',0x00,0x02,0x00,[int('00000010',2)])
        self.checkforerrors()

    def testwrite(self):                    ##test code, 더미데이터 전송
        self.command('w',0x22,0x11,0x00,[0xff,0x01,0xff,0x01,0xff,0x01])
        self.checkforerrors()

    def testread(self):                     ##test code, 더미데이터 확인
        self.command('r',0xff,0x11,0x00,[])
        self.readreply()

    def changemode(self,mode):              ##mode 변환, 0=video mode, 3=pre-stored pattern mode
        self.command('w',0x00,0x1a,0x1b,[mode])
        self.checkforerrors()

    def startsequence(self):                ##시퀀스 play 버튼
        self.command('w',0x00,0x1a,0x24,[2])
        self.checkforerrors()

    def pausesequence(self):                ##시퀀스 pause 버튼
        self.command('w',0x00,0x1a,0x24,[1])
        self.checkforerrors()

    def stopsequence(self):                 ##시퀀스 stop 버튼
        self.command('w',0x00,0x1a,0x24,[0])
        self.checkforerrors()

    def configurelut(self,imgnum,repeatnum):    ##LUT 설정 함수
        img=convlen(imgnum,11)
        repeat=convlen(repeatnum,32)            ##반복 횟수

        string=repeat+'00000'+img

        bytes=bitstobytes(string)

        self.command('w',0x00,0x1a,0x31,bytes)
        self.checkforerrors()

    def definepattern(self,index,exposure,bitdepth,color,triggerin,darktime,triggerout,patind,bitpos): ##파라미터 설정
        payload=[]
        index=convlen(index,16)                         ##전체 재생 목록 중 몇 번째인지 순서를 알려주는 코드
        index=bitstobytes(index)
        for i in range(len(index)):
            payload.append(index[i])

        exposure=convlen(exposure,24)                   ##노출시간 설정 코드 (마이크로초)
        exposure=bitstobytes(exposure)
        for i in range(len(exposure)):
            payload.append(exposure[i])
        optionsbyte=''                                  ##옵션 압축
        optionsbyte+='1'
        bitdepth=convlen(bitdepth-1,3)
        optionsbyte=bitdepth+optionsbyte
        optionsbyte=color+optionsbyte
        if triggerin:
            optionsbyte='1'+optionsbyte
        else:
            optionsbyte='0'+optionsbyte

        payload.append(bitstobytes(optionsbyte)[0])

        darktime=convlen(darktime,24)                   ##패턴 노출 후 다음 패턴 띄우기 전까지 darktime 설정 코드
        darktime=bitstobytes(darktime)
        for i in range(len(darktime)):
            payload.append(darktime[i])

        triggerout=convlen(triggerout,8)                ##큐 사인/ 패턴 띄웠을때 전기 신호 전달
        triggerout=bitstobytes(triggerout)
        payload.append(triggerout[0])

        patind=convlen(patind,11)                       ##24개의 이미지중 몇 번째 이미지를 띄울것인지
        bitpos=convlen(bitpos,5)
        lastbits=bitpos+patind
        lastbits=bitstobytes(lastbits)
        for i in range(len(lastbits)):
            payload.append(lastbits[i])



        self.command('w',0x00,0x1a,0x34,payload)        ##실행 명령어
        self.checkforerrors()

    def setbmp(self,index,size):                        ##메모리 할당 코드
        payload=[]

        index=convlen(index,5)
        index='0'*11+index
        index=bitstobytes(index)
        for i in range(len(index)):
            payload.append(index[i]) 


        total=convlen(size,32)
        total=bitstobytes(total)
        for i in range(len(total)):
            payload.append(total[i])         
        
        self.command('w',0x00,0x1a,0x2a,payload)
        self.checkforerrors()

    def bmpload(self,image,size):                       ##bmp 파일 보내는 함수

        packnum=size//504+1

        counter=0

        for i in range(packnum):
            if i %100==0:
                print (i,packnum)
            payload=[]
            if i<packnum-1:
                leng=convlen(504,16)
                bits=504
            else:
                leng=convlen(size%504,16)
                bits=size%504
            leng=bitstobytes(leng)
            for j in range(2):
                payload.append(leng[j])
            for j in range(bits):
                payload.append(image[counter])
                counter+=1
            self.command('w',0x11,0x1a,0x2b,payload)


            self.checkforerrors()

    def defsequence(self,images,exp,ti,dt,to,rep):          ## 최종 실행 함수

        self.stopsequence()

        arr=[]

        for i in images:
            arr.append(i)

        ## arr.append(numpy.ones((1080,1920),dtype='uint8'))  ##alignment용 마이크로미러 전부 on 시키는 명령어

        num=len(arr)

        encodedimages=[]
        sizes=[]

        for i in range((num-1)//24+1):
            print ('merging...')
            if i<((num-1)//24):
                imagedata=arr[i*24:(i+1)*24]
            else:
                imagedata=arr[i*24:]
            print ('encoding...')
            imagedata,size=encode(imagedata)

            encodedimages.append(imagedata)
            sizes.append(size)

            if i<((num-1)//24):
                for j in range(i*24,(i+1)*24):
                    self.definepattern(j,exp[j],1,'111',ti[j],dt[j],to[j],i,j-i*24)
            else:
                for j in range(i*24,num):
                    self.definepattern(j,exp[j],1,'111',ti[j],dt[j],to[j],i,j-i*24)

        self.configurelut(num,rep)

        for i in range((num-1)//24+1):
        
            self.setbmp((num-1)//24-i,sizes[(num-1)//24-i])

            print ('uploading...')
            self.bmpload(encodedimages[(num-1)//24-i],sizes[(num-1)//24-i])