merged 200 lines from liquid crystal into Adafruit_CharLCD.py

code syntax is a good and most of the methods were tested to confirm they performed properly on a LCD

Adafruit_BMP085/Adafruit_I2C.py

@@ -0,0 +1,95 @@
+#!/usr/bin/python
+
+import smbus
+
+# ===========================================================================
+# Adafruit_I2C Base Class
+# ===========================================================================
+
+class Adafruit_I2C :
+
+  def __init__(self, address, bus=smbus.SMBus(0), debug=False):
+    self.address = address
+    self.bus = bus
+    self.debug = debug
+
+  def reverseByteOrder(self, data):
+    "Reverses the byte order of an int (16-bit) or long (32-bit) value"
+    # Courtesy Vishal Sapre
+    dstr = hex(data)[2:].replace('L','')
+    byteCount = len(dstr[::2])
+    val = 0
+    for i, n in enumerate(range(byteCount)):
+      d = data & 0xFF
+      val |= (d << (8 * (byteCount - i - 1)))
+      data >>= 8
+    return val
+
+  def write8(self, reg, value):
+    "Writes an 8-bit value to the specified register/address"
+    try:
+      self.bus.write_byte_data(self.address, reg, value)
+      if (self.debug):
+        print("I2C: Wrote 0x%02X to register 0x%02X" % (value, reg))
+    except IOError, err:
+      print "Error accessing 0x%02X: Check your I2C address" % self.address
+      return -1
+
+  def writeList(self, reg, list):
+    "Writes an array of bytes using I2C format"
+    try:
+      self.bus.write_i2c_block_data(self.address, reg, list)
+    except IOError, err:
+      print "Error accessing 0x%02X: Check your I2C address" % self.address
+      return -1
+
+  def readU8(self, reg):
+    "Read an unsigned byte from the I2C device"
+    try:
+      result = self.bus.read_byte_data(self.address, reg)
+      if (self.debug):
+        print "I2C: Device 0x%02X returned 0x%02X from reg 0x%02X" % (self.address, result & 0xFF, reg)
+      return result
+    except IOError, err:
+      print "Error accessing 0x%02X: Check your I2C address" % self.address
+      return -1
+
+  def readS8(self, reg):
+    "Reads a signed byte from the I2C device"
+    try:
+      result = self.bus.read_byte_data(self.address, reg)
+      if (self.debug):
+        print "I2C: Device 0x%02X returned 0x%02X from reg 0x%02X" % (self.address, result & 0xFF, reg)
+      if (result > 127):
+        return result - 256
+      else:
+        return result
+    except IOError, err:
+      print "Error accessing 0x%02X: Check your I2C address" % self.address
+      return -1
+
+  def readU16(self, reg):
+    "Reads an unsigned 16-bit value from the I2C device"
+    try:
+      hibyte = self.bus.read_byte_data(self.address, reg)
+      result = (hibyte << 8) + self.bus.read_byte_data(self.address, reg+1)
+      if (self.debug):
+        print "I2C: Device 0x%02X returned 0x%04X from reg 0x%02X" % (self.address, result & 0xFFFF, reg)
+      return result
+    except IOError, err:
+      print "Error accessing 0x%02X: Check your I2C address" % self.address
+      return -1
+
+  def readS16(self, reg):
+    "Reads a signed 16-bit value from the I2C device"
+    try:
+      hibyte = self.bus.read_byte_data(self.address, reg)
+      if (hibyte > 127):
+        hibyte -= 256
+      result = (hibyte << 8) + self.bus.read_byte_data(self.address, reg+1)
+      if (self.debug):
+        print "I2C: Device 0x%02X returned 0x%04X from reg 0x%02X" % (self.address, result & 0xFFFF, reg)
+      return result
+    except IOError, err:
+      print "Error accessing 0x%02X: Check your I2C address" % self.address
+      return -1

Adafruit_CharLCD/Adafruit_CharLCD.py

@@ -11,6 +11,50 @@
 
 class Adafruit_CharLCD:
 
+    # commands
+    LCD_CLEARDISPLAY 		= 0x01
+    LCD_RETURNHOME 		= 0x02
+    LCD_ENTRYMODESET 		= 0x04
+    LCD_DISPLAYCONTROL 		= 0x08
+    LCD_CURSORSHIFT 		= 0x10
+    LCD_FUNCTIONSET 		= 0x20
+    LCD_SETCGRAMADDR 		= 0x40
+    LCD_SETDDRAMADDR 		= 0x80
+
+    # flags for display entry mode
+    LCD_ENTRYRIGHT 		= 0x00
+    LCD_ENTRYLEFT 		= 0x02
+    LCD_ENTRYSHIFTINCREMENT 	= 0x01
+    LCD_ENTRYSHIFTDECREMENT 	= 0x00
+
+    # flags for display on/off control
+    LCD_DISPLAYON 		= 0x04
+    LCD_DISPLAYOFF 		= 0x00
+    LCD_CURSORON 		= 0x02
+    LCD_CURSOROFF 		= 0x00
+    LCD_BLINKON 		= 0x01
+    LCD_BLINKOFF 		= 0x00
+
+    # flags for display/cursor shift
+    LCD_DISPLAYMOVE 		= 0x08
+    LCD_CURSORMOVE 		= 0x00
+
+    # flags for display/cursor shift
+    LCD_DISPLAYMOVE 		= 0x08
+    LCD_CURSORMOVE 		= 0x00
+    LCD_MOVERIGHT 		= 0x04
+    LCD_MOVELEFT 		= 0x00
+
+    # flags for function set
+    LCD_8BITMODE 		= 0x10
+    LCD_4BITMODE 		= 0x00
+    LCD_2LINE 			= 0x08
+    LCD_1LINE 			= 0x00
+    LCD_5x10DOTS 		= 0x04
+    LCD_5x8DOTS 		= 0x00
+
+
+
     def __init__(self, pin_rs=25, pin_e=24, pins_db=[23, 17, 21, 22]):
 
         self.pin_rs = pin_rs
@@ -29,23 +73,134 @@ def __init__(self, pin_rs=25, pin_e=24, pins_db=[23, 17, 21, 22]):
 	self.write4bits(0x28) # 2 line 5x7 matrix
 	self.write4bits(0x0C) # turn cursor off 0x0E to enable cursor
 	self.write4bits(0x06) # shift cursor right
+
+	self.displaycontrol = self.LCD_DISPLAYON | self.LCD_CURSOROFF | self.LCD_BLINKOFF
+
+	self.displayfunction = self.LCD_4BITMODE | self.LCD_1LINE | self.LCD_5x8DOTS
+	self.displayfunction |= self.LCD_2LINE
+
+	""" Initialize to default text direction (for romance languages) """
+	self.displaymode =  self.LCD_ENTRYLEFT | self.LCD_ENTRYSHIFTDECREMENT
+	self.write4bits(self.LCD_ENTRYMODESET | self.displaymode) #  set the entry mode
+
         self.clear()
+
+
+    def begin(self, cols, lines):
+
+	if (lines > 1):
+		self.numlines = lines
+    		self.displayfunction |= self.LCD_2LINE
+		self.currline = 0
+
+
+    def home(self):
+
+	self.write4bits(self.LCD_RETURNHOME) # set cursor position to zero
+	self.delayMicroseconds(2000) # this command takes a long time!
 
 
     def clear(self):
 
-	self.write4bits(0x01) # command to clear display
+	self.write4bits(self.LCD_CLEARDISPLAY) # command to clear display
+	self.delayMicroseconds(2000)	# 2000 microsecond sleep, clearing the display takes a long time
+
+
+    def setCursor(self, col, row):
+
+	self.row_offsets = [ 0x00, 0x40, 0x14, 0x54 ]
+
+	if ( row > self.numlines ): 
+		row = self.numlines - 1 # we count rows starting w/0
+
+	self.write4bits(self.LCD_SETDDRAMADDR | (col + self.row_offsets[row]))
+
+
+    def noDisplay(self): 
+	""" Turn the display off (quickly) """
+
+	self.displaycontrol &= ~self.LCD_DISPLAYON
+	self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)
+
+
+    def display(self):
+	""" Turn the display on (quickly) """
+
+	self.displaycontrol |= self.LCD_DISPLAYON
+	self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)
+
+
+    def noCursor(self):
+	""" Turns the underline cursor on/off """
+
+	self.displaycontrol &= ~self.LCD_CURSORON
+	self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)
+
+
+    def cursor(self):
+	""" Cursor On """
+
+	self.displaycontrol |= self.LCD_CURSORON
+	self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)
+
+
+    def noBlink(self):
+	""" Turn on and off the blinking cursor """
+
+	self.displaycontrol &= ~self.LCD_BLINKON
+	self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)
+
+
+    def noBlink(self):
+	""" Turn on and off the blinking cursor """
+
+	self.displaycontrol &= ~self.LCD_BLINKON
+	self.write4bits(self.LCD_DISPLAYCONTROL | self.displaycontrol)
+
+
+    def DisplayLeft(self):
+	""" These commands scroll the display without changing the RAM """
+
+	self.write4bits(self.LCD_CURSORSHIFT | self.LCD_DISPLAYMOVE | self.LCD_MOVELEFT)
+
+
+    def scrollDisplayRight(self):
+	""" These commands scroll the display without changing the RAM """
+
+	self.write4bits(self.LCD_CURSORSHIFT | self.LCD_DISPLAYMOVE | self.LCD_MOVERIGHT);
+
+
+    def leftToRight(self):
+	""" This is for text that flows Left to Right """
+
+	self.displaymode |= self.LCD_ENTRYLEFT
+	self.write4bits(self.LCD_ENTRYMODESET | self.displaymode);
+
+
+    def rightToLeft(self):
+	""" This is for text that flows Right to Left """
+	self.displaymode &= ~self.LCD_ENTRYLEFT
+	self.write4bits(self.LCD_ENTRYMODESET | self.displaymode)
+
+
+    def autoscroll(self):
+	""" This will 'right justify' text from the cursor """
+
+	self.displaymode |= self.LCD_ENTRYSHIFTINCREMENT
+	self.write4bits(self.LCD_ENTRYMODESET | self.displaymode)
+
+
+    def noAutoscroll(self): 
+	""" This will 'left justify' text from the cursor """
+
+	self.displaymode &= ~self.LCD_ENTRYSHIFTINCREMENT
+	self.write4bits(self.LCD_ENTRYMODESET | self.displaymode)
 
-	# 2000 microsecond sleep, clearing the display takes a long time
-	sleep(.002)
-	#self.delayMicroseconds(2000)
 
     def write4bits(self, bits, char_mode=False):
         """ Send command to LCD """
 
-	# 1000 microseconds sleep
-	# sleep(.001)
-	self.delayMicroseconds(1000)
+	self.delayMicroseconds(1000) # 1000 microsecond sleep
 
         bits=bin(bits)[2:].zfill(8)
 

Adafruit_CharLCD/Adafruit_CharLCD_IPclock_example.py

@@ -9,6 +9,8 @@
 
 cmd = "ip addr show eth0 | grep inet | awk '{print $2}' | cut -d/ -f1"
 
+lcd.begin(16,1)
+
 def run_cmd(cmd):
         p = Popen(cmd, shell=True, stdout=PIPE)
         output = p.communicate()[0]

Adafruit_MCP4725/Adafruit_I2C.py

@@ -0,0 +1,95 @@
+#!/usr/bin/python
+
+import smbus
+
+# ===========================================================================
+# Adafruit_I2C Base Class
+# ===========================================================================
+
+class Adafruit_I2C :
+
+  def __init__(self, address, bus=smbus.SMBus(0), debug=False):
+    self.address = address
+    self.bus = bus
+    self.debug = debug
+
+  def reverseByteOrder(self, data):
+    "Reverses the byte order of an int (16-bit) or long (32-bit) value"
+    # Courtesy Vishal Sapre
+    dstr = hex(data)[2:].replace('L','')
+    byteCount = len(dstr[::2])
+    val = 0
+    for i, n in enumerate(range(byteCount)):
+      d = data & 0xFF
+      val |= (d << (8 * (byteCount - i - 1)))
+      data >>= 8
+    return val
+
+  def write8(self, reg, value):
+    "Writes an 8-bit value to the specified register/address"
+    try:
+      self.bus.write_byte_data(self.address, reg, value)
+      if (self.debug):
+        print("I2C: Wrote 0x%02X to register 0x%02X" % (value, reg))
+    except IOError, err:
+      print "Error accessing 0x%02X: Check your I2C address" % self.address
+      return -1
+
+  def writeList(self, reg, list):
+    "Writes an array of bytes using I2C format"
+    try:
+      self.bus.write_i2c_block_data(self.address, reg, list)
+    except IOError, err:
+      print "Error accessing 0x%02X: Check your I2C address" % self.address
+      return -1
+
+  def readU8(self, reg):
+    "Read an unsigned byte from the I2C device"
+    try:
+      result = self.bus.read_byte_data(self.address, reg)
+      if (self.debug):
+        print "I2C: Device 0x%02X returned 0x%02X from reg 0x%02X" % (self.address, result & 0xFF, reg)
+      return result
+    except IOError, err:
+      print "Error accessing 0x%02X: Check your I2C address" % self.address
+      return -1
+
+  def readS8(self, reg):
+    "Reads a signed byte from the I2C device"
+    try:
+      result = self.bus.read_byte_data(self.address, reg)
+      if (self.debug):
+        print "I2C: Device 0x%02X returned 0x%02X from reg 0x%02X" % (self.address, result & 0xFF, reg)
+      if (result > 127):
+        return result - 256
+      else:
+        return result
+    except IOError, err:
+      print "Error accessing 0x%02X: Check your I2C address" % self.address
+      return -1
+
+  def readU16(self, reg):
+    "Reads an unsigned 16-bit value from the I2C device"
+    try:
+      hibyte = self.bus.read_byte_data(self.address, reg)
+      result = (hibyte << 8) + self.bus.read_byte_data(self.address, reg+1)
+      if (self.debug):
+        print "I2C: Device 0x%02X returned 0x%04X from reg 0x%02X" % (self.address, result & 0xFFFF, reg)
+      return result
+    except IOError, err:
+      print "Error accessing 0x%02X: Check your I2C address" % self.address
+      return -1
+
+  def readS16(self, reg):
+    "Reads a signed 16-bit value from the I2C device"
+    try:
+      hibyte = self.bus.read_byte_data(self.address, reg)
+      if (hibyte > 127):
+        hibyte -= 256
+      result = (hibyte << 8) + self.bus.read_byte_data(self.address, reg+1)
+      if (self.debug):
+        print "I2C: Device 0x%02X returned 0x%04X from reg 0x%02X" % (self.address, result & 0xFFFF, reg)
+      return result
+    except IOError, err:
+      print "Error accessing 0x%02X: Check your I2C address" % self.address
+      return -1