/*---------------------------------------------------------------------*
*  LCD_I2C.C		LCD interface over I2C
*
*  Designed for the Hitachi H44780 LCD display controller interface.
*
*  Copyright 2008-2020 Didier Juges
*  http://www.ko4bb.com
*
*   This driver uses an NXP PCF8574A I2C/parallel interface to drive the LCD
*   in 4 bit mode.
*
*   Pin-out:
*   PCF8574   LCD
*   4 (P0)    4 (RS)
*   5 (P1)    5 (R/W)
*   6 (P2)    6 (E)
*   7 (P3)    N/C (could be used for backlight ON)
*   9 (P4)    11 (DB4)
*   10 (P5)   12 (DB5)
*   11 (P6)   13 (DB6)
*   12 (P7)   14 (DB7, busy flag functionality not used)
*
*   Note:
*
*	For most applications when there really is no reason to read from the LCD,
*	tie "R/W" to ground and just wait the maximum amount of time
*	for each instruction (4.1 msecs for clearing the display or moving the
*	cursor/display to the "home position", 160 usecs for all other commands).
*	As well as making application software simpler, it also frees up a
*	pin for other uses. Different LCDs execute instructions at
*	different rates and to avoid problems later on (such as if the LCD is
*	changed to a slower unit), simply use the maximum delays given above.
*
*	Updated for Off-The-Shelf I2C adapters with PCF8574 at address 0x4E
*
*  This program is free software; you can redistribute it and/or
*  modify it under the terms of the GNU General Public License
*  as published by the Free Software Foundation; either version 2
*  of the License, or (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the
*  Free Software Foundation, Inc.,
*  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*----------------------------------------------------------------------*/
#include <string.h>

#include "general.h"
#include "timer.h"
#include "lcd_i2c.h"
#include "i2c_if.h"

// the following addresses are available with eBay I2C display adapters:
// PCF8574: 0x40
// PCF8574: 0x4E
// PCF8574A: 0x7E

// these addresses must be supported
#define PCF8574A_1_LCD_ADDR		0x70
#define PCF8574A_2_LCD_ADDR		0x78
#define PCF8574A_3_LCD_ADDR		0x7A
#define PCF8574_1_LCD_ADDR		0x40


#define LCD_MASK				0x0F
#define LCD_INIT_1				0x30
#define LCD_INIT_2				0x20


/* ----- local variables ----- */
static uchar bdata LCD_PORT;
sbit LCD_RS = LCD_PORT^0;
sbit LCD_RW = LCD_PORT^1;
sbit LCD_EN = LCD_PORT^2;
sbit LCD_BL = LCD_PORT^3;

uchar xdata I2CLCDAddr;


/*---------------------------------------------------------------------*
* Local function prototypes (public prototypes are in lcd_i2c.h)
*----------------------------------------------------------------------*/
void IRWriteLCD8( uchar);	// 8 bits mode
void IRWriteLCD( uchar );	// 4 bits mode
void DRWriteLCD( uchar);
bit WaitLCD( void );
void ClockEn( void );
bit WriteLCD( uchar reg, uchar out );

/*=====================================================================*
* Public Functions
*======================================================================*/

/*---------------------------------------------------------------------*
* FUNCTION: InitLCD()
*
*  initialize LCD module per specs
*
* NOTE: the Noritake display needs at least 260mS after Vcc rise > 4.75V
*----------------------------------------------------------------------*/
bit InitLCD( void ){

	// 1st part of initialization is in 8 bit mode, but only
	// the upper 4 bits matter.

	LCD_PORT = 0;
	LCD_BL = 1;

	// find which address the PCF8574 is at
	I2CLCDAddr = PCF8574A_1_LCD_ADDR;
	WriteLCD( I2CLCDAddr, LCD_PORT );
	if( I2CCheckError() ){
		I2CLCDAddr = PCF8574A_2_LCD_ADDR;
		WriteLCD( I2CLCDAddr, LCD_PORT );
		if( I2CCheckError() ){
			I2CLCDAddr = PCF8574A_3_LCD_ADDR;
			WriteLCD( I2CLCDAddr, LCD_PORT );
			if( I2CCheckError() ){
				I2CLCDAddr = PCF8574_1_LCD_ADDR;
				WriteLCD( I2CLCDAddr, LCD_PORT );
				if( I2CCheckError() )
					return( FALSE );
			}
		}
	}

	// normal start
	Wait( 15 );        	// Wait more than 15ms
	LCD_PORT = LCD_INIT_1;  // Startup Sequence
	ClockEn();		// apply data to port, raise E, wait >100uS, lower E
	Wait( 5 );         	// Wait more than 4.1ms
	ClockEn();		// clock again
	Wait( 1 );		// Wait more than 0.1ms
	ClockEn();		// clock again
	LCD_PORT = LCD_INIT_2;
	ClockEn();
	Wait( 1 );         	// Wait more than 0.1ms

	// LCD is now initialized, remainder of setup is in 4 bits mode

	IRWriteLCD( 0x28 );   	// Function Set
                            	// DL=0 4bit, N=1 2Line, F=0 5x7
	IRWriteLCD( 0x0C );   	// Display on/off control
                            	// D=1 Disp on, C=0 Curs off, B=0 Blink off
	IRWriteLCD( 0x06 );   	// Entry Mode Set
                            	// I/D=1 Increment, S=0 No shift
	IRWriteLCD( 0x01 );	// Clear Display
	Wait( 2 );         	// Wait more than 1.64ms
	return( TRUE );

} // InitLCD()

/*---------------------------------------------------------------------*
* FUNCTION: ClearLCD()
*
* 	to clear line i: ClearLCD( i );
*	to clear all lines: ClearLCD( 0 );
*---------------------------------------------------------------------*/
void ClearLCD( uchar line ){

	uchar i=0, addr;

	// Position the cursor
	switch( line ){
		case 0:
			// clear by instruction (fast)
			IRWriteLCD( 0x01 );
			// wait at least 4.1 mS
			WaitTicks( 5 );
			return;
			break;
		case 1:
			addr = 0x80;
			break;
		case 2:
			addr = 0xC0;
			break;
		case 3:
			addr = 0x94;
			break;
		case 4:
			addr = 0xD4;
			break;
	}
	IRWriteLCD( addr );
	for( i=0; i<LCD_SIZE; i++ ){
		WaitLCD();
		DRWriteLCD( ' ' );
	}
} // ClearLCD()


/*---------------------------------------------------------------------*
* FUNCTION: printLCD()
*
*	line: 1, 2, 3 or 4 (for up to 4 lines display)
*	*chr_ptr: pointer to string to print in data space, NULL terminated
*	offset: offset from left of display where to print string
*			(characters skipped are not blanked, allowing to refresh
*			a portion of a line without affecting the rest)
*	This routine takes about 2mS per character (with 1mS wait time)
*---------------------------------------------------------------------*/
void printLCD( uchar line, uchar *chr_ptr, uchar offset ){

	// position the cursor
	switch( line ){
		case 1:
			IRWriteLCD( 0x80 + offset );	// address of left-most character to print
			break;
		case 2:
			IRWriteLCD( 0xC0 + offset );
			break;
		case 3:
			IRWriteLCD( 0x94 + offset );
			break;
		case 4:
			IRWriteLCD( 0xD4 + offset );
			break;
	}
	// check that data does not overflow on the next line
	*(chr_ptr - offset + 20) = '\0';

	// Write out the data
	chr_ptr--;
	while( *(++chr_ptr) != '\0' ){
		WaitLCD();
		DRWriteLCD( *chr_ptr );
	}

} // printLCD()


/*======================================================================*
* Private Functions
*======================================================================*/


/*---------------------------------------------------------------------*
* FUNCTION: IRWriteLCD()
*
*	Writes 1 byte to LCD Instruction Register ( 4-bits mode, MSB first )
*	This routine takes 1.35mS when running the I2C bus at 100KHz
*---------------------------------------------------------------------*/
void IRWriteLCD( uchar outbyte){

	uchar i;

	i = outbyte;                // save for later

	i = i & 0xf0;               // Strip low nibble
	LCD_PORT = i;               // Write high nibble
	LCD_RS = 0;                 // Instruction
	LCD_RW = 0;                 // Write
	ClockEn();                  // Trigger

	i = outbyte;                // Later is now!

	i = (i & 0x0f);             // Strip high nibble
	i = i*16;					// Shift low nibble to high
	LCD_PORT = i;               // Write low nibble
	LCD_RS = 0;                 // Instruction
	LCD_RW = 0;                 // Write
	ClockEn();

} // IRWriteLCD()

/*---------------------------------------------------------------------*
* FUNCTION: DRWriteLCD()
*
*	Writes 1 byte to LCD Data Register ( 4-bits mode, MSB first )
*	This routine takes 1.35mS when running the I2C bus at 100KHz
*---------------------------------------------------------------------*/
void DRWriteLCD( uchar outbyte){

	uchar i;

	i = outbyte;                // preserve outbyte for later

	i = i & 0xf0;               // Strip low nibble
	LCD_PORT = i;               // Write high nibble
	LCD_RS = 1;                 // Data
	LCD_RW = 0;                 // Write
	ClockEn();

	i = outbyte;                // Later is now!

	i = (i & 0x0f);             // Strip high nibble
	i = i*16;					// Shift low to high
	LCD_PORT = i;               // Write high nibble
	LCD_RS = 1;                 // Data
	LCD_RW = 0;                 // Write
	ClockEn();

} // DRWriteLCD()


/*---------------------------------------------------------------------*
* FUNCTION: WaitLCD()
*
*	Wait for Display to be 'not-busy'
*	Not used
*   (there is enough delay in the I2C transactions)
*---------------------------------------------------------------------*/
bit WaitLCD( void ){

	return( TRUE );

} // WaitLCD()

/*---------------------------------------------------------------------*
* FUNCTION: ClockEn()
*
*	Apply content of LCD_PORT to PCF8574
*	Send clock pulse to LCD
*---------------------------------------------------------------------*/
void ClockEn( void ){

	LCD_BL = 1;	// 1 for LCD, 0 for VFD
	I2CSendAddr( I2CLCDAddr, WRITE );
	if( I2CCheckError() ){
		I2CSendStop();			// device not found
		return;
	}
	I2CSendByte( LCD_PORT );
	LCD_EN = 1;
	I2CSendByte( LCD_PORT );
	LCD_EN = 0;
	I2CSendByte( LCD_PORT );
	I2CSendStop();

} // ClockEn()

/*-----------------------------------------------------------------------------
* FUNCTION: WriteLCD()
*
* 	load a data byte to the LCD via the I2C extender
*
*-----------------------------------------------------------------------------*/
bit WriteLCD( uchar addr, uchar val ){

	I2CSendAddr( addr, WRITE );
	if( I2CCheckError() ){
		I2CSendStop();			// device not found
		return( FALSE );
	}
	I2CSendByte( val );
	I2CSendStop();

	return( TRUE );

} // WriteLCD()