/*** BeginHeader */
#ifndef __I2C_DEVICES_LIB
#define __I2C_DEVICES_LIB
/*** EndHeader */

/* START LIBRARY DESCRIPTION *********************************************
I2C_DEVICES.LIB

ZWorld, 2001

This library contains higher level functions for specific I2C devices

The library currently has routines for

serial EEPROM devices:
	I2CWrite
	I2CRead
	L24C08_put
	XL24C08_get
	WriteEEPROM
	ReadEEPROM

Serial IO Expander
	PCF8575
	PCF8574

I2C DAC chips(MAX517/518/519LTC2619):
	I2CSetDAC
I2C DAC chip(LTC2619)
	LTC2619_I2CSetDAC

Special devices

	MAX1669 Temperature and fan PWM controller
	DS1629 RTC & Temperature

	 Acknowledgement:
				 	This library contains code written for Rabbit Semiconductor
				 	 	by
               KENT JOHANSEN
               ANAKRON / ANAKRON CANADA INC
               www.anakron.com
               kent@anakron.com
Updated - 11/12/2006
					Richard W. Wall
               University of Idaho
               rwall@uidaho.edu

END DESCRIPTION *********************************************************/

/*** BeginHeader */

#use "I2C.LIB"

/*** EndHeader */

/*** BeginHeader I2CWrite */
int I2CWrite(unsigned char slave,
				 unsigned char index,
				 char *buf,
				 unsigned char len);
/*** EndHeader */


/* START FUNCTION DESCRIPTION ********************************************
I2CWrite            <I2C_DEVICES.LIB>
SYNTAX: int I2CWrite(unsigned char slave,
							unsigned char index,
							char *buf,
							unsigned char len);

DESCRIPTION: Uses the EEPROM scheme to write data to slave
          	 Sends START, slave address, index and then data, STOP
             Generic interface that may be used to communicate with another
				 processor
             Waits for slave to respond. EEPROM does not respond while
             internal write takes place.

PARAMETER1: unsigned char slave - slave address
PARAMETER2: unsigned char index - index in in EEPROM to write to
PARAMETER3: char *buf        - buffer with data
PARAMETER4: unsigned char len  - lengt of data to send

RETURN VALUE: 0 or error code (see code)
END DESCRIPTION **********************************************************/

nodebug int I2CWrite(unsigned char slave,
				  		   unsigned char index,
				 			char *buf,
				 			unsigned char len)
{
	auto unsigned char cnt;
	auto short int err;
	if (err=i2c_startw_tx())
	{
		i2c_stop_tx();
		return -10+err; // Return too long stretching
	}
	if (err=i2c_wr_wait(slave))
	{
		i2c_stop_tx();
		return -20+err; // Return no ack on slave (retried)
	}
	if (err=i2c_write_char(index))
	{
		i2c_stop_tx();
		return -30+err; // Return no ack on index
	}
	for (cnt=0;cnt<len;cnt++)
	{
		i2c_write_char(buf[cnt]);
   }
   i2c_stop_tx();
	return 0;
}

/*** BeginHeader I2CRead */
int I2CRead(unsigned char slave,
				unsigned char index,
				char *buf,
				unsigned char len);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
I2CRead            <I2C_DEVICES.LIB>
SYNTAX: int I2CRead(unsigned char slave,
						  unsigned char index,
						  char *buf,
						  unsigned char len);

DESCRIPTION: Uses the EEPROM scheme to read data from slave
             Sends  START, slave address, index START,
             slave address +1,
             reads data (sending ACKs and NAK on last data) STOP
             Generic interface that may be used to communicate with another
				 processor
             Waits for slave to respond. EEPROM does not respond while
             internal write takes place.

PARAMETER1: unsigned char slave - slave address
PARAMETER2: unsigned char index - index in in EEPROM to read from
PARAMETER3: char *buf          - buffer for data
PARAMETER4: unsigned char len   - size of data buffer

RETURN VALUE: 0 or error code (see code)
END DESCRIPTION **********************************************************/

nodebug int I2CRead(unsigned char slave,
					     unsigned char index,
			   	 	  char *buf,
			   		  unsigned char len)
{
	auto unsigned char cnt;
	auto short int err;

	if (err=i2c_startw_tx())
	{
		i2c_stop_tx();
		return -10+err; // Return too long stretching
	}
	if (err=i2c_wr_wait(slave))
	{
		i2c_stop_tx();
		return -20+err; // Return no ack on slave
	}
	if (err=i2c_write_char(index))
	{
		i2c_stop_tx();
		return -30+err; // Return no ack on index
	}
	//i2c_Delay(10);
	if (err=i2c_startw_tx())
	{
		i2c_stop_tx();
		return -40+err; // Return too long stretch on read
	}
	if (err=i2c_wr_wait(slave+1))
	{
		i2c_stop_tx();
		return -50+err; // Send read to slave - no ack (retried) return -5
	}
	for (cnt=0;cnt<len;cnt++)
	{
		err=i2c_read_char(&buf[cnt]);
		if (err)
		{
			i2c_stop_tx();
			return -60+err;
		}
		if (cnt==(len-1))
		{
			i2c_send_nak();
		}
		else
      {
			i2c_send_ack();
		}
	}
	i2c_stop_tx();
	return 0;
}

/*** BeginHeader XL24C08_put */
void XL24C08_put(unsigned int index,char content);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
XL24C08_put            <I2C_DEVICES.LIB>

SYNTAX: void XL24C08_put(unsigned int index,char content);

KEYWORDS: i2c

DESCRIPTION: Writes a char to a 24C08 on the I2C bus

PARAMETER1: unsigned char index - index in in EEPROM to write to
PARAMETER2: char content         - char to write to EEPROM

RETURN VALUE: none
END DESCRIPTION **********************************************************/

nodebug void XL24C08_put(unsigned int index, char content)
{
	auto unsigned char res;
	//Send control word + page NUM
	res=(((unsigned char)(index>>7))&0x0E)|0xA0;
	I2CWrite(res,index&0x00FF,&content,1);
}

/*** BeginHeader XL24C08_get */
unsigned char XL24C08_get(unsigned int index);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
XL24C08_get            <I2C.LIB>
SYNTAX: unsigned char XL24C08_get(unsigned int index);

KEYWORDS: i2c

DESCRIPTION: Reads a char from 24C08 on the I2C bus

PARAMETER1: unsigned char index - index in in EEPROM to write to

RETURN VALUE: value read from EEPROM
END DESCRIPTION **********************************************************/

nodebug unsigned char XL24C08_get(unsigned int index)
{
	auto unsigned char res;
	//Send control word + page NUM
	res=(((unsigned char)(index>>7))&0x0E)|0xA0;
	I2CRead(res,index&0x00FF,&res,1);
	return res;
}

/*** BeginHeader WriteEEPROM */
void WriteEEPROM(unsigned int index,
					  unsigned char * data,
					  unsigned int length);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
WriteEEPROM           <I2C_DEVICES.LIB>

SYNTAX: void WriteEEPROM(unsigned int index,
								 unsigned char *data,
								 unsigned int length);

KEYWORDS: i2c

DESCRIPTION: Writes data to a 24C08 on the I2C bus one byte at a time

PARAMETER1: unsigned char index - index in in EEPROM to write to
PARAMETER2: unsigned char * data - data to write
PARAMETER3: unsigned int length - length of data

RETURN VALUE: none
END DESCRIPTION **********************************************************/

nodebug void WriteEEPROM(unsigned int index,
					  unsigned char *data,
					  unsigned int length)
{
	auto unsigned i;
	for (i=0;i<length;i++)
	{
		XL24C08_put(index,*data);
		index++;
		data++;
	}
}

/*** BeginHeader ReadEEPROM */
void ReadEEPROM(unsigned char * data,
					 unsigned int index,
					 unsigned int length);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
ReadEEPROM           <I2C.LIB>

SYNTAX: void ReadEEPROM(unsigned char *data,unsigned int index,unsigned
int length);


KEYWORDS: i2c


DESCRIPTION: Reads data from a 24C08 on the I2C bus one byte at a time


PARAMETER1: unsigned char * data - data to write
PARAMETER2: unsigned char index - index in in EEPROM to write to
PARAMETER3: unsigned int length - length of data

RETURN VALUE: none
END DESCRIPTION **********************************************************/


nodebug void ReadEEPROM(unsigned char * data,
								unsigned int index,
								unsigned int length)
{
	auto unsigned i;
	for (i=0;i<length;i++)
	{
		*data=XL24C08_get(index);
		index++;
		data++;
	}
}


/*** BeginHeader I2CSetDAC */
int I2C_DAC_Set(char address, char channel, char setting);
/*** EndHeader */


/* START FUNCTION DESCRIPTION ********************************************
I2CSetDAC           <I2C_DEVICES.LIB>

SYNTAX: int I2CSetDAC(char address, char channel, char setting);

KEYWORDS: i2c

DESCRIPTION: Sends a set channel command to a Maxim MAX517/518/519
				 series ADC.


PARAMETER1: address - I2C address of slave device
PARAMETER2: channel - which DAC channel to set (0 or 1)
PARAMETER3: setting - new value for DAC channel

RETURN VALUE: 0 or error code
END DESCRIPTION **********************************************************/

nodebug int I2CSetDAC(char address, char channel, char setting)
{
	if(i2c_startw_tx())
	{
		return -1;
	}
	//7 bit address in shifted 1 bit
	if(i2c_write_char(address*2))
	{
		return -1;
	}
	if(i2c_write_char(channel))
	{
		return -1;
	}
	if(i2c_write_char(setting))
	{
		return -1;
	}
	i2c_stop_tx();
	return 0;
}

/*** BeginHeader LTC2619_I2CSetDAC */
int LTC2619_I2CSetDAC(char address, char channel, int setting);
/*** EndHeader */


/* START FUNCTION DESCRIPTION ********************************************
LTC2619_I2CSetDAC           <I2C_DEVICES.LIB>

SYNTAX: int LTC2619_I2CSetDAC(char address, char channel, int setting);

KEYWORDS: i2c, LTC2619, DAC

DESCRIPTION: Sends a set channel command to a Maxim MAX517/518/519
				 series ADC.


PARAMETER1: address - I2C address of slave device
PARAMETER2: channel - DAC channel to set (0, 1, 2, or 3)
PARAMETER3: setting - new value for DAC channel

RETURN VALUE: 0 or error code
END DESCRIPTION **********************************************************/

//nodebug
int LTC2619_I2CSetDAC(char address, char channel, int setting)
{
#define LTC2619_PWR_UP		0x10
#define LTC2619_WRITE		0x20
#define LTC2619_UPDATE		0x30

	if(i2c_startw_tx())
	{
		return -1;
	}
	//7 bit address already shifted 1 bit
	if(i2c_write_char(address))
	{
		return -1;
	}
	if(i2c_write_char(channel | LTC2619_UPDATE))
	{
		return -1;
	}
	if(i2c_write_char((unsigned char) (setting>>6))) // Send 8 MSB
	{
		return -1;
	}
	if(i2c_write_char((unsigned char) (setting<<2))) // Send 6 LSB
	{
		return -1;
	}
	i2c_stop_tx();
	return 0;
}

/*** BeginHeader PCF8575_IOX_Wr */
int PCF8575_IOX_Wr(char address, int setting);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
PCF8575_IOX_Wr          <I2C_DEVICES.LIB>

SYNTAX: int PCF8575_IOX_Wr(char address, int setting);

KEYWORDS: i2c, PCF8574

DESCRIPTION: Writes the 16 bit value to the IO expander specified by the address

PARAMETER1: address - I2C address of slave device
PARAMETER3: setting - new 16 bit value for IOX channel

RETURN VALUE: 0 or error code
END DESCRIPTION **********************************************************/

nodebug int PCF8575_IOX_Wr(char address, int setting)
{

	if(i2c_startw_tx())
	{
		return -1;
	}
	//7 bit address already shifted 1 bit
	if(i2c_write_char(address))
	{
		return -1;
	}
	if(i2c_write_char((unsigned char) (setting>>8))) // Send 8 MSB
	{
		return -1;
	}
	if(i2c_write_char((unsigned char) (setting))) // Send 8 LSB
	{
		return -1;
	}
	i2c_stop_tx();
	return 0;
}

/*** BeginHeader PCF8575_IOX_Rd */
int PCF8575_IOX_Rd(char address, unsigned int *x);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
PCF8575_IOX_Rd          <I2C_DEVICES.LIB>

SYNTAX: int PCF8575_IOX_Rd(char address, unsigned int *x);

KEYWORDS: i2c, PCF8574

DESCRIPTION: Reads the 8 bit value from the IO expander specified by the address

PARAMETER1: address - I2C address of slave device
PARAMETER3: setting - new 8 bit value for IOX channel

RETURN VALUE: 0 to 255 for valid or 0xffff
END DESCRIPTION **********************************************************/

//nodebug
int PCF8575_IOX_Rd(char address, unsigned int *x)
{
#define I2CRdBit 1
char y;
	if(i2c_startw_tx())
	{
		return -1;
	}
	//7 bit address already shifted 1 bit
	if(i2c_write_char(address | I2CRdBit))
	{
		return -1;
	}
	if(i2c_read_char(&y)) // Get low ordwer byte
	{
		return -1;
	}
	i2c_send_ack();
	*x = ((unsigned int) y);

	if(i2c_read_char(&y)) // Get high order byte
	{
		return -1;
	}
	i2c_send_nak();
	i2c_stop_tx();
	*x |= ((unsigned int) y << 8);

	// *x |= ((unsigned int) y << 8);

	return 0;
}


/*** BeginHeader PCF8574_IOX_Wr */
int PCF8574_IOX_Wr(char address, int setting);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
PCF8574_IOX_Wr          <I2C_DEVICES.LIB>

SYNTAX: int PCF8574_IOX_Wr(char address, int setting);

KEYWORDS: i2c, PCF8574

DESCRIPTION: Writes the 8 bit value to the IO expander specified by the address

PARAMETER1: address - I2C address of slave device
PARAMETER3: setting - new 8 bit value for IOX channel

RETURN VALUE: 0 or error code
END DESCRIPTION **********************************************************/

nodebug int PCF8574_IOX_Wr(char address, int setting)
{

	if(i2c_startw_tx())
	{
		return -1;
	}
	//7 bit address already shifted 1 bit
	if(i2c_write_char(address))
	{
		return -1;
	}
	if(i2c_write_char((unsigned char) setting)) // Send byte
	{
		return -1;
	}
	i2c_stop_tx();
	return 0;
}

/*** BeginHeader PCF8574_IOX_Rd */
int PCF8574_IOX_Rd(char address);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
PCF8574_IOX_Rd          <I2C_DEVICES.LIB>

SYNTAX: int PCF8574_IOX_Rd(char address);

KEYWORDS: i2c, PCF8574

DESCRIPTION: Reads the 8 bit value from the IO expander specified by the address

PARAMETER1: address - I2C address of slave device
PARAMETER3: setting - new 8 bit value for IOX channel

RETURN VALUE: 0 to 255 for valid or 0xffff
END DESCRIPTION **********************************************************/

nodebug int PCF8574_IOX_Rd(char address)
{
#define I2CRdBit 1
char x;
	if(i2c_startw_tx())
	{
		return -1;
	}
	//7 bit address already shifted 1 bit
	if(i2c_write_char(address | I2CRdBit))
	{
		return -1;
	}
	if(i2c_read_char(&x)) // Send byte
	{
		return -1;
	}
	i2c_send_nak();
	i2c_stop_tx();
	return ((int) x) & 0xFF;
}
// MAX 1669 definitions
#define RTEMP 		0x01
#define RSTAT 		0x02
#define RHI			0x07
#define RLOW		0x08
#define WCFG		0x09
#define WHI			0x0d
#define WLOW		0x0e
#define OSHT		0x0f
#define RCRIT		0x10
#define RPROT		0x11
#define RFREQ     0x12
#define RDUTY		0x13
#define RGPIO		0x14
#define WCRIT		0x18
#define WPROT		0x19
#define WFREQ     0x1a
#define WDUTY		0x1b
#define WGPIO		0x1c
#define DS1669_ADDR	0x30

/*** BeginHeader MAX1669_Rd */
int MAX1669_Rd(char command, char *data);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
MAX1669_Rd          <I2C_DEVICES.LIB>
int MAX1669_Rd(char command, char *data);
KEYWORDS: i2c, MAX1669, Temperature, Fan COntroller
DESCRIPTION: Reads DS1629 register specified by command
PARAMETER1: command 	- I2C DS1629 register to read
RETURN VALUE: x = 0 to 255 for valid or 0xffff
END DESCRIPTION **********************************************************/

int MAX1669_Rd(char command, char *data)
{
#define DS1669_ADDR	0x30
int error;
	error = I2CRead(DS1669_ADDR, command, data, 1);
	return error;
}

/*** BeginHeader MAX1669_Wr */
int MAX1669_Wr(char command, char setting);
/*** EndHeader */
/* START FUNCTION DESCRIPTION ********************************************
MAX1669_Wr          <I2C_DEVICES.LIB>
SYNTAX: int int MAX1669_Wr(char command, char setting);
KEYWORDS: i2c, MAX1669, Temperature, Fan COntroller
DESCRIPTION: Writes DS1629 register specified by command
PARAMETER1: command 	- I2C DS1629 register to read
PARAMETER2: setting 	- data to be stored in register specified by "command"
RETURN VALUE: x = 0 if valid or 0xffff if error
END DESCRIPTION **********************************************************/

int MAX1669_Wr(char command, char setting)
{
#define DS1669_ADDR	0x30
int error;
	error = I2CWrite(DS1669_ADDR, command, &setting, 1);
	return error;
}

// DS1629 constant definitions
#define DS1629_ADDR 					0x9e
#define I2C_READ 						0x01
#define I2C_WRITE 					0x00
#define DS1629_CONFIG 				0xAC
#define DS1629_START_CONVERT_T 	0xEE
#define DS1629_STOP_CONVERT_T 	0x22
#define DS1629_READ_TEMP 			0xAA
#define DS1629_READ_CNTR 			0xA8
#define DS1629_READ_SLOPE 			0xA9
#define DS1629_ACCESS_CLOCK 		0xC0
#define DS1629_ACCESS_ALARM 		0xC7
#define DS1629_ACCESS_TH 			0xA1
#define DS1629_ACCESS_TL 			0xA2
#define DS1629_ACCESS_MEM 			0x17

#define RTC_TAL 0x10
#define RTC_CAL 0x20
#define RTC_TAF 0x40
#define RTC_CAF 0x80
#define RTC_1SH 0x100
#define RTC_POL 0x200
#define RTC_CNV 0x400
#define RTC_A0	 0x1000
#define RTC_A1  0x2000
#define RTC_OS0 0x4000
#define RTC_OS1 0x8000

#define RTC_CONFIG
#define E_ReadDS1629Time -10
#define E_ReadDS1629Temp -20

/*** BeginHeader MAX1629_Set_time */
int SetDS1629Time(struct tm rtc);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
SetDS1629Time          <I2C_DEVICES.LIB>
SYNTAX: 						int int SetDS1629Time(struct tm rtc_time);
KEYWORDS: 					i2c, MAX1629, RTC, time, Temperature
DESCRIPTION: 				Sets DS1629 RTC time
PARAMETER1: 				rtc: Rabbit RTC structure
RETURN VALUE: 				x = 0 if valid or 0xffff if error
END DESCRIPTION **********************************************************/
int SetDS1629Time(struct tm	rtc)
{
int loop, idx, err;
char time_buffer[7];
static const unsigned char RTCheader[3] = {DS1629_ADDR|I2C_WRITE, DS1629_ACCESS_CLOCK,0};
// Convert to BCD and store in DS1629 RTC chip
   time_buffer[5] = (rtc.tm_mon % 10) | ((rtc.tm_mon / 10)<< 4); // MM
   time_buffer[4] = (rtc.tm_mday % 10) | ((rtc.tm_mday / 10)<< 4); // DD
   time_buffer[6] = (rtc.tm_year % 10) | ((rtc.tm_year / 10)<< 4); // YY
   time_buffer[2] = (rtc.tm_hour % 10) | ((rtc.tm_hour / 10)<< 4); // hh
   time_buffer[1] = (rtc.tm_min % 10) | ((rtc.tm_min / 10)<< 4); // mm
   time_buffer[0] = (rtc.tm_sec % 10) | ((rtc.tm_sec / 10)<< 4); // sec
	time_buffer[3] = 0;
	if(err = send_DS1629_header(RTCheader, sizeof(RTCheader))) return err;

   for(loop = 0; loop<7; loop++)
   {
	// write data byte: minute
		if (err = i2c_write_char(time_buffer[loop]))
		{	i2c_stop_tx();	return err;	}
   }
}

/*** BeginHeader ReadDS1629TTC */
int ReadDS1629TTC(unsigned char *tt_data);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
SetDS1629Time          <I2C_DEVICES.LIB>
SYNTAX: 				int SetDS1629Time(tm	rtc_time);
KEYWORDS: 			i2c, MAX1629, RTC, time, Temperature
DESCRIPTION: 		Sets DS1629 RTC time
PARAMETER1: 		rtc: Rabbit RTC structure
RETURN VALUE: 		x = 0 if valid or 0xffff if error
END DESCRIPTION **********************************************************/
int ReadDS1629TTC(tm *rtc, int *temp)
{
   unsigned char time[7];
   int err, ret_err, i;
   ret_err = 0;

   if (err = ReadDS1629Time(time)) ret_err = err + E_ReadDS1629Time;
   printf("%x/%x/%x; %x:%x:%x  ",  time[5], time[4], time[6],
	      time[2], time[1], time[0]);

   if (err = ReadDS1629Temp(&temp)) ret_err = err + E_ReadDS1629Temp;
	printf("C deg: %d Deg. F\n", temp);

   rtc->tm_sec = time[0]&0x0f + ((time[0] & 0x70)>>4)*10; // Seconds
   rtc->tm_min = time[1] + ((time[1] & 0x70)>>4)*10;		// Minutes
   rtc->tm_hour = time[2] + ((time[2] & 0x30)>>4)*10;
   rtc->tm_mday = time[4] + ((time[4] & 0x30)>>4)*10;
	rtc->tm_mon = time[5] + ((time[5] & 0x10)>>4)*10;
	rtc->tm_year = time[6] + ((time[6] & 0xf0)>>4)*10;
   return ret_err;
}

/*** BeginHeader ReadDS1629Time */
int ReadDS1629Time(unsigned char *time);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
ReadDS1629Time
SYNTAX:        int ReadDS1629Time(unsigned char *time);
KEYWORDS:		RTC Time
DESCRIPTION:	Reads the Real Time Time registers
Parameter 1:	pointer to temperature variable
RETURN VALUE:  Error code: 0 --> operation sucessful
END DESCRIPTION **********************************************************/
int ReadDS1629Time(unsigned char *time)
{
int err, loop;
static const unsigned char RTCheader[3] = {DS1629_ADDR|I2C_WRITE, DS1629_ACCESS_CLOCK,0};

	if(err = send_DS1629_rtc_header(RTCheader, sizeof(RTCheader))) return err;
	// repeated start
	if (err = i2c_start_tx())
	{	i2c_stop_tx();	return err;	}
	// write control byte: read from DS1629
	if (err = i2c_write_char(DS1629_ADDR|I2C_READ))
	{	i2c_stop_tx(); return err;	}
   for (loop = 0; loop < 6; loop++)
   {
   	// read data byte
	   if (err = i2c_read_char(&time[loop]))
	   {  i2c_stop_tx(); return err; }

	   // master ACK
	   if (err = i2c_send_ack())
	   {  i2c_stop_tx(); return err; }
   }
   if(err = i2c_read_char(&time[loop]))    // read data byte
   {  i2c_stop_tx(); return err; }
		if (err = i2c_send_nak()) 					// master NACK
		{ i2c_stop_tx(); return err; }
		i2c_stop_tx();             	// stop condition
   }
	return 0;
}

/*** BeginHeader ReadDS1629Temp */
int ReadDS1629Temp(int *temp);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
ReadDS1629Temp
SYNTAX:        int ReadDS1629Temp(unsigned char *temp);
KEYWORDS:		RTC Temperature
DESCRIPTION:	Reads the Real Time Temperature registers
Parameter 1:	pointer to temperature variable
RETURN VALUE:  Error code: 0 --> operation sucessful
END DESCRIPTION **********************************************************/

int ReadDS1629Temp(int *temp)
{
#define DS1629_READ_TEMP 			0xAA
#define I2C_WRITE 					0x00
#define I2C_READ 						0x01
#define DS1629_ADDR 					0x9E
int err, loop;
unsigned char tempvar[2];
static const unsigned char RTCheader[2] = {DS1629_ADDR|I2C_WRITE, DS1629_READ_TEMP};

	if(err = send_DS1629_rtc_header(RTCheader, sizeof(RTCheader))) return err;

	// repeated start
	if (err = i2c_start_tx())
	{	i2c_stop_tx(); return err; }

	// write control byte: read from DS1629
	if (err = i2c_write_char(DS1629_ADDR|I2C_READ))
	{	i2c_stop_tx(); return err; }

	for(loop = 0; loop<2; loop++)
   {
		if (err = i2c_read_char(&tempvar[loop])) 	// read MSB first
		{	i2c_stop_tx(); return err; }

      if(loop == 0)		// Continue read if first read (MSB)
      {
			if (err = i2c_send_ack())
			{ 	i2c_stop_tx(); return err; }
		}
      else              // Stop data transfer after second byte
      {
			if (err = i2c_send_nak())
			{ 	i2c_stop_tx(); return err; }
      }
	}
	// stop condition
	i2c_stop_tx();

   *temp = ((int) tempvar[0]) << 8;	// Convert to Degrees F
   *temp |= (int) tempvar[1];
   *temp = *temp >> 7;
   *temp = ((*temp*9)/10) + 32;
	return 0;
}

/*** BeginHeader WriteDS1629Status */
int WriteDS1629Status(unsigned int config);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
WriteConfiguration
SYNTAX:        int WriteConfiguration(unsigned int config);
KEYWORDS:		RTC atatus / status configuration
DESCRIPTION:	Writes the Real Time Clock configuration register
Parameter 1:	pointer to status variable
RETURN VALUE:  Error code: 0 --> operation sucessful
END DESCRIPTION **********************************************************/
int WriteDS1629Status(unsigned int config)
{
int err, loop;
static const unsigned char RTCheader[2] = {DS1629_ADDR|I2C_WRITE, DS1629_CONFIG};

	if(err = send_DS1629_rtc_header(RTCheader, sizeof(RTCheader))) return err;

   // write data byte
   if (err = i2c_write_char((unsigned char) (config >> 8)))
   {
      i2c_stop_tx();
      return err;
   }
   if (err = i2c_write_char((unsigned char) config))
   {
      i2c_stop_tx();
      return err;
   }
   printf("write status: 0x%x\n", config);

	// stop condition
	i2c_stop_tx();

	return 0;
}

/*** BeginHeader WriteDS1629SRAM */
int WriteDS1629SRAM(unsigned int status);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
WriteDS1629SRAM
SYNTAX:        int WriteDS1629SRAM(unsigned char *data);
KEYWORDS:		RTC atatus / configuration
DESCRIPTION:	Reads the Real Time Clock Status /configuration RAM
Parameter 1:	pointer to status variable
RETURN VALUE:  Error code: 0 --> operation sucessful
END DESCRIPTION **********************************************************/
int WriteDS1629SRAM(unsigned char *data)
{
int err, loop;
static const unsigned char RTCheader[3] = {DS1629_ADDR|I2C_WRITE, DS1629_ACCESS_MEM, 0x00};

	printf("Write: ");
	if(err = send_DS1629_rtc_header(RTCheader, sizeof(RTCheader))) return err;

     for (loop = 0; loop < 9; loop++)
   {
   	// write data byte
   	if (err = i2c_write_char(data[loop]))
	   {
	      i2c_stop_tx();
	      return err;
	   }

      printf("0x%x ", data[loop]);
   }
	printf("\n");
	// stop condition
	i2c_stop_tx();

	return 0;
}

/*** BeginHeader ReadDS1629Status */
int ReadDS1629Status(unsigned int status);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
int ReadDS1629Status
SYNTAX:        int ReadDS1629Status(unsigned char *data);
KEYWORDS:		RTC atatus / configuration
DESCRIPTION:	Reads the Real Time Clock Status /configuration RAM
Parameter 1:	pointer to status variable
RETURN VALUE:  Error code: 0 --> operation sucessful
END DESCRIPTION **********************************************************/
int ReadDS1629Status(unsigned int status)
{
int loop, err;
unsigned char ch;
static const unsigned char RTCheader[2] = {DS1629_ADDR|I2C_WRITE, DS1629_CONFIG};

	if(err = send_DS1629_rtc_header(RTCheader, sizeof(RTCheader))) return err;

	// repeated start
	if (err = i2c_start_tx())
	{
		i2c_stop_tx();
		return err;
	}

	// write control byte: read from DS1629
	if (err = i2c_write_char(DS1629_ADDR|I2C_READ))
	{
		i2c_stop_tx();
		return err;
	}

   // read MSB Status data byte
   if (err = i2c_read_char(&ch))
   {
      i2c_stop_tx();
      return err;
   }

   status = ((unsigned int) ch) << 8;

   // read LSB Status data byte
   if (err = i2c_read_char(&ch))
   {
      i2c_stop_tx();
      return err;
   }

   status |= ((unsigned int) ch);

   printf("read status: 0x%x\n", status);

	// master NACK
	if (err = i2c_send_nak())
	{
		i2c_stop_tx();
		return err;
	}

	// stop condition
	i2c_stop_tx();

	return 0;
}

/*** BeginHeader ReadDS1629SRAM */
int ReadDS1629SRAM(unsigned char *data);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
ReadDS1629SRAM
SYNTAX:        int ReadDS1629SRAM(unsigned char *data);
KEYWORDS:		RTC SRAM
DESCRIPTION:	Reads the Real Time Clock Static RAM
Parameter 1:	array to hold RTC SRAM data
RETURN VALUE:  none
END DESCRIPTION **********************************************************/
int ReadDS1629SRAM(unsigned char *data)
{
int loop, err;
static const unsigned char RTCheader[3] = {DS1629_ADDR|I2C_WRITE, DS1629_ACCESS_MEM, 0x00};

	printf("Read:  ");

	if(err = send_DS1629_rtc_header(RTCheader, sizeof(RTCheader))) return err;

	// repeated start
	if (err = i2c_start_tx())
	{
		i2c_stop_tx();
		return err;
	}

	// write control byte: read from DS1629
	if (err = i2c_write_char(DS1629_ADDR|I2C_READ))
	{
		i2c_stop_tx();
		return err;
	}

   for (loop = 0; loop < 8; loop++)
   {
   	// read data byte
	   if (err = i2c_read_char(&data[loop]))
	   {
	      i2c_stop_tx();
	      return err;
	   }

      printf("0x%x ", data[loop]);

	   // master ACK
	   if (err = i2c_send_ack())
	   {
	      i2c_stop_tx();
	      return err;
	   }
   }

   // read data byte
   if (err = i2c_read_char(&data[loop]))
   {
      i2c_stop_tx();
      return err;
   }

   printf("0x%x ", data[loop]);

	// master NACK
	if (err = i2c_send_nak())
	{
		i2c_stop_tx();
		return err;
	}

	// stop condition
	i2c_stop_tx();
	printf("\n");
	return 0;
}

/*** BeginHeader send_DS1629_rtc_header */
int send_DS1629_rtc_header(unsigned char *header, int num);
/*** EndHeader */

/* START FUNCTION DESCRIPTION ********************************************
send_DS1629_rtc_header
SYNTAX:        int send_DS1629_rtc_header(unsigned char *header, int num);
KEYWORDS:		RTC I2C
DESCRIPTION:	Sends common header for RTC functions
Parameter 1:	array to hold header data
parameter 2:	length of header (in bytes)
RETURN VALUE:  error code:  No errors --> return 0
notes:			i2c stop commnad issued if error is detected.
END DESCRIPTION **********************************************************/
int send_DS1629_rtc_header(unsigned char *header, int num)
{
int err, loop;
	// start condition
	if (err = i2c_start_tx())
	{
		i2c_stop_tx();
		return err;
	}
   for(loop = 0; loop<num; loop++)
   {
		if (err = i2c_write_char(*header++))
		{
			i2c_stop_tx();
			return err;
		}
   }
	return 0;
}

/*** BeginHeader */
#endif
/*** EndHeader */