def main():
    # Open file descriptor for 
    # spi device 0 using the CE0 pin for chip select
    device_0 =  spi.openSPI(device="/dev/spidev0.0",
                            mode=0,
                            speed=1000000)

    # Open file descriptor for
    # spi device 0 using the CE1 pin for chip select
    device_1 = spi.openSPI(device="/dev/spidev0.1",
                        mode=0,
                        speed=1000000)

    # Transact data
    data_out = (0xFF, 0x00, 0xFF)

    # This is not necessary, not just demonstrate loop-back
    data_in = (0x00, 0x00, 0x00)
    data_in = spi.transfer(device_0, data_out)
    print("Received from device 0:")
    print(data_in)

    data_in = (0x00, 0x00, 0x00)
    data_in = spi.transfer(device_1, data_out)
    print("Received from device 1:")
    print(data_in)

    # Close file descriptors
    spi.closeSPI(device_0)
    spi.closeSPI(device_1)

 def adc(self, cmd, osr):
     # osr: 0 = 256, 1 = 512, 2 = 1024, 3 = 2048, 4 = 4096
     assert 0 <= osr <= 4
     spi.transfer((cmd | (2 * osr),))
     time.sleep(.01) # conversion time for osr=4096 is 8.22ms
     h, m, l = spi.transfer((0, 0, 0, 0))[1:]
     return (h << 16) | (m << 8) | l

 def send(self, dc, data):
     gpio(self.dc, dc)
     if hasattr(data, "__iter__"):
         data = tuple(data)
     else:
         data = (data,)
     spi.transfer(data)

	def write(self, addr, vals, inc):
		transfer_tuple = ()
		cmd = (addr << 2) + write_cmd + (inc << 1)
		transfer_tuple = transfer_tuple + ((cmd >> 8),)
		transfer_tuple = transfer_tuple + ((cmd & 0x00FF),)
		for v in vals:
			transfer_tuple = transfer_tuple + (v,)
		spi.transfer(transfer_tuple)

 def _send_spi_string(self):
     self._job = None
     send_str = "0:%d:1:%d:\n" % (self.slider_horiz.get(), self.slider_vert.get())
     print send_str
     
     l = tuple(map(ord, send_str))
     print l
     spi.transfer((l))

def setLaserPower(lines):
	zchar_loc=lines.index('Z');
    	i=zchar_loc+1;
    	while (47<ord(lines[i])<58)|(lines[i]=='.')|(lines[i]=='-'):
        	i+=1;
    	lpowr=float(lines[zchar_loc+1:i]);
	lpow=int(lpowr*255);
	print 'Laser Pow= ', lpow;
   	spi.transfer((0xB0000, 255-lpow))

def lcd_cmd(cmd):
	stat = spi.openSPI(SPI_DEVICE,speed=SPI_SPEED,bits=8)
#	print "LCD CMD(1)=%X, SPI_open=" % (cmd) , stat
	spi.transfer((0,cmd>>8,0x00ff&cmd,0x11)) # 0x11 - CMD_BE const from ili9341.c 
	spi.closeSPI()
#	time.sleep(0.0001) # 100us
	stat = spi.openSPI(SPI_DEVICE,speed=SPI_SPEED,bits=8)
#	print "LCD CMD(2)=%X, SPI_open=" % (cmd) , stat
	spi.transfer((0,cmd>>8,0x00ff&cmd,0x1B)) # x01B - CMD_AF const from ili9341.c 
	spi.closeSPI()
	return

def lcd_data(data):
	stat = spi.openSPI(SPI_DEVICE,speed=SPI_SPEED,bits=8)
#	print "LCD DATA(1)=%X, SPI_open=" % (data) , stat
	spi.transfer((0,data>>8,0x00ff&data,0x15))	# 0x15 - DATA_BE const from ili9341.c (BE is short form "before")
	spi.closeSPI()
#	time.sleep(0.00001) # 10us
	stat = spi.openSPI(SPI_DEVICE,speed=SPI_SPEED,bits=8)
#	print "LCD DATA(2)=%X, SPI_open=" % (data) , stat
	spi.transfer((0,data>>8,0x00ff&data,0x1F)) # 0x1F - DATA_AF const from ili9341.c (AF is short form "after")
	spi.closeSPI()
	return

def setTLCvalue(data,DCMode):

	# put the chip into DC mode	
	GPIO.output(VPRG, DCMode)
	#print tuple(data)
	spi.transfer(tuple(data))

	# latch data
	GPIO.output(XLAT, GPIO.HIGH)
	#time.sleep(0.25)
	GPIO.output(XLAT, GPIO.LOW)

	GPIO.output(VPRG, GPIO.LOW)

def lcd_reset():
	# for reset I use slow clock - just my habit
	stat = spi.openSPI(SPI_DEVICE,speed=1000000,bits=8)
#	print "LCD RESET(1), SPI_open=",stat
	spi.transfer((0,0,0,0)) # set 0 on U1-Q2
	spi.closeSPI()
	time.sleep(0.05) # 50ms reset
	# unreset
	stat = spi.openSPI(SPI_DEVICE,speed=1000000,bits=8)
#	print "LCD RESET(2), SPI_open=",stat
	spi.transfer((0,0,0,2)) # set 1 on U1-Q2
	spi.closeSPI()
	time.sleep(0.1) # 100ms after reset
	return

 def _write_register(self, reg, value):
     """Writes the entire register, identified by its name  (datasheet)."""
     if reg in short_addr_registers:
         reg_addr = short_addr_registers[reg]
         bytes = [((reg_addr << 1) + self.short_write_mask), value]
     else:
         if reg in long_addr_registers:
             reg_addr = long_addr_registers[reg]
         else:
             reg_addr = reg
         bytes = []
         bytes.append((reg_addr >> 3) + self.long_addr_bit)
         bytes.append(((reg_addr << 5) & 0xE0) + self.long_write_mask)
         bytes.append(value)
     spi.transfer(tuple(bytes))

    def drive(self, dev, value):
        if self.devMaxX or self.devMinX or self.devMaxY or self.devMinY is None:
            raise Exception("Must override X min and max values")
        try:
            try:
                dev = int(dev)
            except ValueError,e:
                print "need numeric device ID"

            if dev == 1:
                newVal = self.__convertValueX(value)
            if dev == 2:
                newVal = self.__convertValueY(value)
            else:
                newVal = value
            spi.transfer((dev, self.__getBits(newVal)))

 def transfer(self, data=[]):
     if isinstance(data,str):
         data = [ord(x) for x in data]
     data = tuple(data)
     data = spi.transfer(data)
     dataout = "".join([chr(x) for x in data])
     return dataout

 def spi_transfer(self, data):
     if self.pin_ce != 0:
         GPIO.output(self.pin_ce, 0)
     r = SPI.transfer(data)
     if self.pin_ce != 0:
         GPIO.output(self.pin_ce, 1)
     return r

	def read(self, addr, nb, inc):
		transfer_tuple = ()
		cmd = (addr << 2) + read_cmd + + (inc << 1)
		transfer_tuple = transfer_tuple + ((cmd >> 8),)
		transfer_tuple = transfer_tuple + ((cmd & 0x00FF),)
		transfer_tuple = transfer_tuple + tuple([0]*nb)
		data = spi.transfer(transfer_tuple)
		return list(data)[2:]

def LEDspit(COLOR):
  #data = ["0000000000001" + COLOR * (8 * 50 + 8) ]
  # data = (0, ) * 50 + 0099991
  # Start bits for LEDs
  basedata = 0, 0, 0, 1, 
  # 62 * 4 bytes + 4 bytes works- 63 craps out, as PyArg_ParseTupleAndKeywords function only seems to support ints of 32 bits.
  data = basedata + (50, 0, 255, 1) * 408
  # data = tuple(data)
  #Calculates the length, and devides by 2 for two bytes of data sent.
  # length_data = len(data[0])/2
  #transfers data string
  #print 'Value transfered to C spimodule:',data
  #for i, printdata in enumerate(data):
  spi.transfer((data))
  #sleep(SLEEPTIME)
  data = basedata + (0, 255, 0, 1) * 408
  spi.transfer((data))

 def writecmd(self, app, verb, count=0, data=[]):
     if verb: # ignore all but R/W cmd
         return
     if isinstance(data,str):
         data = [ord(x) for x in data]
     data = tuple(data)
     data = spi.transfer(data)
     self.data = "".join([chr(x) for x in data])

 def prom(self):
     words = []
     for i in range(8):
         h, l = spi.transfer((0xa0 | (2*i), 0, 0))[1:]
         words.append(h << 8 | l)
     assert any(words)
     verify_crc4(words)
     self.C = words
     assert len(self.C) == 8

 def _read_register(self, reg):
     """Reads the entire register, identified by its name (datasheet)."""
     if reg in short_addr_registers:
         reg_addr = short_addr_registers[reg]
         bytes = [(reg_addr << 1), 0]
         result = spi.transfer(tuple(bytes))
         return result[1]
     else:
         if reg in long_addr_registers:
             reg_addr = long_addr_registers[reg]
         else:
             reg_addr = reg
         bytes = []
         bytes.append((reg_addr >> 3) + self.long_addr_bit)
         bytes.append((reg_addr << 5) & 0xE0)
         bytes.append(0)
         result = spi.transfer(tuple(bytes))
         return result[2]

    def issue_write(self, data):
        """
            Emulate the facedancer's write command, which blasts data
            directly over to the SPI bus.
        """
        if isinstance(data,str):
            data = [ord(x) for x in data]

        data = tuple(data)
        data = spi.transfer(data)

        return bytearray(data)