#!/usr/bin/python

import smbus
import time
from lcdConstants import *
import _strptime
#from threading import Timer, Lock
from compiler.ast import Function


#sleep for x micro seconds
__usleep__ = lambda x: time.sleep(x/1000000.0)

#maske fuer lcd pins, alle anderen pins so lassen, wie sind sind
#die 4 oled-datenleitungen sind immer die ersten 4 pins des ports: 0b1111
OLED_PIN_MASK = lambda: 0b1111 | (1<<PIN_E()) | (1<<PIN_RS())

bus = smbus.SMBus(1)	#raspi version 2

#get byte from lcd port
__getPort__ = lambda: bus.read_byte_data(LCD_I2C_ADDRESS(), LCD_I2C_OLAT())
#write byte to lcd port
__setPort__ = lambda aByte: bus.write_byte_data(LCD_I2C_ADDRESS(), LCD_I2C_OLAT(), aByte)

#nur die pins setzen, die oled gehoeren. alle anderen so lassen, wie sie sind
#bsp: oled hat die ersten 6 pins, pin 7 und 8 des ports werden fuer was anderes verwendet.
#oled 0b110101, andere ports 0b01000000 soll ergeben: 0b01110101

#setPortMasked = lambda aByte: __setPort__((__getPort__() & ~OLED_PIN_MASK()) | (OLED_PIN_MASK() & aByte))
#set OLED port bits to aByte mask. Only set Oled pins, leave others as they are
def setPortMasked(aByte):
	portOther = __getPort__() & ~OLED_PIN_MASK()	#lcd pins=0, alle anderen wie vorher
	lcdNew = OLED_PIN_MASK() & aByte
	__setPort__(portOther | lcdNew) 


class Lcd:
	

	def __init__(self):
		self.blockShift = False	#true: shift ist blockiert wegen anderer schreibaktionen
		self.shiftRuns	= False #==true, wenn shiftLeft laeuft
		#self.blockShifting()
		#self.lcdWriteLock = threading.Lock()	#sync Schreibfunktionen und shiftLeft()
		
		print "init lcd.."
		self.__lcdInit__()
		print "init lcd completed."
		self.shiftCounter = 0	#counts shifting from 0 to end of line. buff for line is 40.
		self.rowStrLen = [0,0]	#laenge des strings in zeile 1 und 2
		self.mStopShiftCountdown = 0
		#self.shiftTimer = RepeatedTimer(DisplayStatus.DISPLAY_REFRESH_INTERRUPT, ISR_timer, [self])
		#self.shiftTimer = RepeatedTimer(DISPSHIFT_INTERRUPT(), self.ISR_timer)
		#self.unblockShifting()


		
	#set e pin high and down to write nibble to the lcd
	def __eToggle__(self):
		p = __getPort__()
		setPortMasked(p | 1<<PIN_E())
		__usleep__(10.0)
		setPortMasked(p & ~(1<<PIN_E()))
		__usleep__(10.0)



	#aDaten: 0=Befehl, 1=Daten
	#aByte: 8 bit Code to be sent
	def writeDataByte(self, aDaten, aByte):
		# output high nibble first
		databits = aByte;
		p = (databits>>4) & 0x0f #high nibble
		if aDaten == 1:
			#send daten, set RS to 1
			p |= 1<<PIN_RS()
		else:
			#text: PIN_RS auf 0 lassen
			pass
		setPortMasked(p)	#high nibble
		self.__eToggle__()
	
		# output low nibble */
		databits = aByte;
		p = databits & 0x0f
		if aDaten == 1:
			p |= 1<<PIN_RS()
		setPortMasked(p)
		self.__eToggle__()
	


	#lcd loeschen, cursor auf anfang
	def clearScreen(self):
		self.writeDataByte(0, 0x01);	#clrscr
		self.writeDataByte(0, 0x02);	#return home
		self.rowStrLen = [0,0]	#zeilen leer
		shiftCounter=0


	def __lcdInit__(self):
		#time.sleep(0.02)#delay 16ms or more
		
		#set all used pins to output
		# pin_e, pin_rs, 4 data wires starting at pin 0 of register
		#lcd_pins = (1<<PIN_E()) | (1<<PIN_RS()) | 0x0f
		#lcd_pins = OLED_PIN_MASK()
		print "lcdInit OLED_PIN_MASK=" + bin(OLED_PIN_MASK())
		
		#lcd pins auf output=0 setzen (1=input)
		#bus.write_byte_data(LCD_I2C_ADDRESS(), LCD_I2C_IODIR(), 0x00)
		bus.write_byte_data(LCD_I2C_ADDRESS(), LCD_I2C_IODIR(), __getPort__() & ~OLED_PIN_MASK())
	
	
		#display ports angeschlossen an PD0..PD3
	
		setPortMasked(0x03)
		self.__eToggle__();
		setPortMasked(0x03)
		self.__eToggle__();
		setPortMasked(0x03)
		self.__eToggle__();
		setPortMasked(0x02)	#4bit
		self.__eToggle__();
		__usleep__(50.0)
		
		self.writeDataByte(0, 0x28)	#4 bit mode, N=1
		self.writeDataByte(0, 0x08)	#display off
		self.writeDataByte(0, 0x06)	#entry mode set inc cursor by 1 not shifting display
		self.writeDataByte(0, 0x17)	#character mode and internal power on
		self.writeDataByte(0, 0x01)	#clear display
		#self.writeDataByte(0, 0x02)	#return home
		self.returnHome()
		self.writeDataByte(0, 0x0c)	#display on
	

	def returnHome(self):
		self.writeDataByte(0, 0x02)	#return home

	def writeStr(self, str):
		for c in str:
			self.writeDataByte(1, ord(c))

	#write a string to line number 1,2,..
	def writeRow(self, rowNr, str):
#		self.blockShifting()
		self.setCursor(LCD_ROW_STARTADDRESS()[rowNr], 0)
		self.rowStrLen[rowNr] = len(str)
		self.writeStr(str)
#		self.unblockShifting()

	
	#parm:
	#aLine: start position for line. use constants
	#column: simply number of column, starting with 0
	def setCursor(self, aLine, aColumn):
		add = aLine + aColumn
		add &= 0b1111111	#only use first 6 bits
		self.writeDataByte(0, (1<<7) | add)

	def shiftLeft(self):
		self.shiftCounter += 1
		maxLen = max(self.rowStrLen)	#der laengste string in der zeilen liste
		maxLen -= LCD_ROW_LEN()	#zeilenlaenge des displays abziehen
		if(maxLen<0):		#string kuerzer oder gleich display zeilenlaenge
			maxLen=0
		if(maxLen>LCD_ROWBUF_LEN()):	#string kann nicht laenger als zeilenpuffer sein.
			maxLen = LCD_ROWBUF_LEN()
			
		if(self.shiftCounter > maxLen):
			self.shiftCounter = 0
			self.returnHome()
			self.retardShifting()
		else:			
			self.writeDataByte(0, (1<<4) | (1<<3))	#shift left

	#semaphore, block shifting for other write actions
	def blockShifting(self):	
#		while(self.shiftRuns):
#			pass	#warte, bis shifting ist fertig
		self.blockShift = True
		
	#shifting wieder zulassen.
	def unblockShifting(self):
		self.retardShifting()	#kleine Pause, bis shifting wieder anfaengt
		self.blockShift = False
				
		# stop the display left shift for a period
	def retardShifting(self):
		#stop zeitraum berechnen als Anzahl der ISR Aufrufe
		self.mStopShiftCountdown = DISPSHIFT_SYS_DELAY() / DISPSHIFT_INTERRUPT()
		pass
	
	#shift timer ISR
#	def ISR_timer(self):
#	 	if self.mStopShiftCountdown > 0:
#	 		self.mStopShiftCountdown -= 1	#wenn shift gestoppt, nur stopp countdown runter zaehlen
#	 	else:
#	 		#if not self.blockShift:
#	 		if True:	#tmp
#				self.shiftRuns = True
#				self.shiftLeft()	#args[0] ist die Lcd instanz
#				self.shiftRuns = False

#class RepeatedTimer(object):
#	def __init__(self, interval, function):
#		self._timer     = None
#		self.function   = function
#		self.interval   = interval
#		self.is_running = False
#		self.start()
#
#	def _run(self):
#		self.is_running = False
#		self.start()
#		#self.function(*self.args, **self.kwargs)
#		self.function()
#
#	def start(self):
#		if not self.is_running:
#			self._timer = Timer(self.interval, self._run)
#			self._timer.start()
#			self.is_running = True
#
#	def stop(self):
#		self._timer.cancel()
#		self.is_running = False