/* 
 **********************************************************************
 * File   GMBI2CE.C        -         Rel. 1.1  with  uC/51 V. 1.10.09 *
 * GRIFO(R)   via Dell'Artigiano 8/6   40016 S. Giorgio di Piano (BO) *
 *     Tel. +39 051 892052                      Fax. +39 051 893661   *
 *     http://www.grifo.com                     http://www.grifo.it   *
 *     sales@grifo.it         tech@grifo.it          grifo@grifo.it   *
 *     by Angelini Gianluca                           date 11.07.03   *
 **********************************************************************
11/07/03: GMBI2CE.C - Rel. 1.1 - By Angelini Gianluca
  These demo allow to communicate to I2C BUS devices connected to CN3.
  According to the Mini Module installed, it is possible to read or write
  bytes at any slave address and location address input by console. In
  detail, when reading the byte read is visualized and when writing the
  byte input is sent.

  Note
  To avoid problems do not use complex operations on a single source line,
  especially inside procedures by using their parameters or their local
  variables.
*/

/****************************************************************************
   Header, constant, data structure, etc.
****************************************************************************/
#include "canarye.h"
#include <stdio.h>
#include <ctype.h>

#define FALSE 0x00					     // Boolean value
#define TRUE 0xFF
#define	LF 0x0A						       // ASCII codes
#define	CRET 0x0D

// Global variables for I2C BUS management
near unsigned char	resi2c;			    // I2C BUS error variable
bit unsigned char	SDACAN  @ 0xA1;		   // SDA pin on CAN GMx=P2.1
bit unsigned char	SCLCAN  @ 0xA0;		   // SCL pin on CAN GMx=P2.0
bit unsigned char	SDA5115 @ 0xA0;		  // SDA pin on GMM 5115=P2.0
bit unsigned char	SCL5115 @ 0xA1;		  // SCL pin on GMM 5115=P2.1
// General purpose global variables used by main and procedures
near unsigned char	minmod,choice,dr,dw,hlp;
near unsigned int	val;
inear unsigned char	input[9];		      // Console input buffer


/****************************************************************************
 General purpose functions and card hw sections management functions 
****************************************************************************/
unsigned char divappr(unsigned long divid,unsigned long divis)
/* Procedure that calculates the 8 bit integer quotient, correctly approximated,
   between the dividend and the divisor passed as parameters, by using the
   successive subtractions tecnique. This function is used to reserve the 2K
   of code required by the same librari functions.   */
{
unsigned char d;
  d=0;						      // Set quotient to zero
  while (divid>=divis)
    {
    divid=divid-divis;
    d++;
    }
//endwhile
  divis=divis>>1;		     // Halves divisor to check the remainder
  if (divid>=divis)
    d++;
//endif
  return d;
}

void init_cpu(void)
/* Perform some specific initialization of CPU SFRs     */
{
  EA=0;						// Ensures interrupt disabled
  CKCON=0x00;				 // Set X1 clock mode = standard mode
  AUXR=0x0C;			        // Selects ERAM on external data area
  EECON=0x00;					  // Disables internal EEPROM
}

void iniser(unsigned long baud)
/* Initializes the serial line with:	Bit x chr   = 8
					Stop bit    = 1
					Parity	    = None
					Baud rate   = baud
   using timer 1 as baud rate generator.   */
{
  SCON=0x052;					  // Mode 1, enables receiver
  TMOD&=0x00F;				       // Timer 1 in auto-reload mode
  TMOD|=0x020;
  TR1=0;						     // Stops TIMER 1
  TH1=(unsigned char)(256-divappr((2*14745600),(384*baud)));   // 14.7456 MHz
  PCON=PCON|0x080;			   // Sets SMOD=1 for high baud rates
  TR1=1;						    // Starts TIMER 1
  TI=1;	    // Sets end of transmission bit for optimized console (SIOTYPE=k)
}

void clrscr(void)
/* Performs the clear screen function for a generic console */
{
unsigned char r;
  putc(CRET);
  for (r = 0 ; r < 25 ; r++)
    {
    putc(LF);					    // Transmit 25 Line Feeds
    }
//endfor
}

void waitkey(void)
/* Shows messages and wait a key pressed */
{
  printf("Press a key to continue..");
  getc();
  puts("");
}

void delay(unsigned int del)
/* Executes a software delay of del milliseconds, calibrated on a 14.7456
   MHz CPU Clock  */
{
unsigned int r,dt1ms;
  dt1ms=100;			      // Experimental value for 1 msec. delay
  do
    {
    for (r=0 ; r<dt1ms ; r++);
    del--;
    }
  while (del>0);
}

void setP1234inp(void)
/* Sets all the lines of all the ports (P1,P2,P3,P4) del modulo CAN GM1 in
   input.								   */
{
  ADCF=0x00;					     // Sets P1.x as I/O port
  P1=0xFF;					      // Sets Port 1 as INPUT
  dr=P1;
  P2=0xFF;					      // Sets Port 2 as INPUT
  dr=P2;
  P3=0xFF;					      // Sets Port 3 as INPUT
  dr=P3;
  P4=0xFF;					      // Sets Port 4 as INPUT
  dr=P4;
}

void riti2c(void)
/* Performs a delay for syncronous I2CBUS communication. The delay is
   sufficient for a 22 MHz clock, X1 modality   */
{
#asm
  nop
  nop
  nop
  nop
  nop
  nop
  nop
  nop
  nop
  nop
  nop
  nop
  nop
  nop
  nop
#endasm
}

void starti2c(void)
/* Generates start sequence for I2C BUS    */
{
  if (minmod=='3')
    {
    SCL5115=0;				      // Start sequence with GMM 5115
    SDA5115=1;
    riti2c();
    SCL5115=1;
    SDA5115=0;
    riti2c();
    SCL5115=0;
    }
   else
    {
    SCLCAN=0;				       // Start sequence with CAN GMx
    SDACAN=1;
    riti2c();
    SCLCAN=1;
    SDACAN=0;
    riti2c();
    SCLCAN=0;
    }
//endif
}

void stopi2c(void)
/* Generates stop sequences for I2C BUS     */
{
  if (minmod=='3')
    {
    SCL5115=0;				       // Stop sequence with GMM 5115
    SDA5115=0;
    riti2c();
    SCL5115=1;
    SDA5115=1;
    riti2c();
    SCL5115=0;
    }
   else
    {
    SCLCAN=0;					// Stop sequence with CAN GMx
    SDACAN=0;
    riti2c();
    SCLCAN=1;
    SDACAN=1;
    riti2c();
    SCLCAN=0;
    }
//endif
}

void wri2c_bit(unsigned char i2cbit)
/* Serializes the D0 bit of i2cbit, on I2CBUS    */
{
  if (minmod=='3')
    {
    SCL5115=0;	// Sets SDA and generates positive pulse on SCL with GMM 5115
    SDA5115=i2cbit;
    riti2c();
    SCL5115=1;
    riti2c();
    SCL5115=0;
    }
   else
    {
    SCLCAN=0;	 // Sets SDA and generates positive pulse on SCL with CAN GMx
    SDACAN=i2cbit;
    riti2c();
    SCLCAN=1;
    riti2c();
    SCLCAN=0;
    }
//endif
}

unsigned char rdi2c_bit(void)
/* Deserializes one bit from I2CBUS and saves it on lsb of the returned value */
{
unsigned char biti2c;
  if (minmod=='3')
    {
    SDA5115=1;			       // Avoids conflicts in SDA acquisition
    SCL5115=0;						// Ensures SCL status
    riti2c();
    SCL5115=1;		     // Generates positive pulse on SCL and reads SDA
    biti2c=SDA5115;
    riti2c();
    SCL5115=0;
    }
   else
    {
    SDACAN=1;			       // Avoids conflicts in SDA acquisition
    SCLCAN=0;						// Ensures SCL status
    riti2c();
    SCLCAN=1;		     // Generates positive pulse on SCL and reads SDA
    biti2c=SDACAN;
    riti2c();
    SCLCAN=0;
    }
//endif
  return biti2c;
}

void wri2c_byte(unsigned char i2cbyte)
/* Serializes the i2cbyte byte on I2CBUS     */
{
unsigned char b;
  for (b = 1; b <= 8; b++)
    {
    if ((i2cbyte & 0x80) == 0)			 // Determines and sets b bit
      wri2c_bit(0);
     else
      wri2c_bit(1);
    i2cbyte = i2cbyte << 1;
    }
}

unsigned char rdi2c_byte(void)
/* Deserializes one byte from I2CBUS and saves it in the returned value */
{
unsigned char b,tmp;
  tmp = 0;
  for (b = 1; b <= 8; b++)
    {
    tmp = tmp << 1;
    tmp = tmp | rdi2c_bit();			      // Gets and saves b bit
    }
  return tmp;
}

unsigned char wr_i2c(unsigned char i2csla,unsigned char i2cadd,unsigned char i2cdat)
/* Writes the i2cdat byte to i2caddr address of the I2CBUS device that have
   the slave address i2csla. Returns a boolean flag that signals the operation
   result: 0=right,1=wrong     */
{
unsigned char i2cres;
  i2cres = 0;						 // Sets right result
  starti2c();					   // Supplies start sequence
  wri2c_byte(i2csla);				  // Supplies slave address+W
  i2cres = i2cres | rdi2c_bit();	     // Checks ACK on slave address+W
  wri2c_byte(i2cadd);					  // Supplies address
  i2cres = i2cres | rdi2c_bit();		      // Check ACK on address
  wri2c_byte(i2cdat);					     // Supplies data
  i2cres = i2cres | rdi2c_bit();			 // Check ACK on data
  stopi2c();					    // Supplies stop sequence
  return i2cres;				  // Returns operation result
}

unsigned char rd_i2c(unsigned char i2csla,unsigned char i2cadd,unsigned char *i2cdat)
/* Reads the i2cdat byte from i2caddr address of I2CBUS device that have
   the slave address i2csla. Returns a boolean flag that signals the operation
   result: 0=right,1=wrong     */
{
unsigned char i2cres;
  i2cres = 0;						 // Sets right result
  starti2c();					   // Supplies start sequence
  wri2c_byte(i2csla);				  // Supplies slave address+W
  i2cres = i2cres | rdi2c_bit();	      // Check ACK on slave address+W
  wri2c_byte(i2cadd);					  // Supplies address
  i2cres = i2cres | rdi2c_bit();		      // Check ACK on address
  starti2c();					   // Supplies start sequence
  wri2c_byte(i2csla | 0x01);			  // Supplies slave address+R
  i2cres = i2cres | rdi2c_bit();	      // Check ACK on slave address+R
  *i2cdat = rdi2c_byte();					// Reads data
  stopi2c();					    // Supplies stop sequence
  return i2cres;				  // Returns operation result
}

unsigned char peekb(unsigned int addr)
/* Reads the byte from addr address of external data area and returns it */
{
  return *(xdata unsigned char *)addr;		   // Gets byte from location
}

void rd_ee(unsigned int eeaddr,unsigned char *eedat)
/* Reads the eedat byte from eeaddr address of internal EEPROM   */
{
  AUXR=0x2E;			 // Deselects ERAM and increase MOVX duration
  EECON=0x02;	       // Selects microprocessor EEPROM on external data area
  *eedat=peekb(eeaddr);				   // Performs EEPROM reading
  AUXR=0x0C;			        // Selects ERAM on external data area
  EECON=0x00;				    // Disables microprocessor EEPROM
}


/****************************************************************************
   Main program
****************************************************************************/
void main(void)
{
unsigned char sladd;				 // Variables for I2CBUS demo
  init_cpu();					  // Initializes the used CPU
  iniser(19200);	  // Initializes serial line for console with timer 1
  setP1234inp();			        // Sets Port 1,2,3,4 as INPUT
  clrscr();					  // Selects used Mini Module
  puts("1->CAN GM1 , 2->CAN GM2 , 3->GMM 5115");
  printf("Select Mini Module mounted on ZC1 socket (1,2,3):");
  do
    minmod=toupper(getc());
  while ((minmod<'1') || (minmod>'3'));
  clrscr();					  // Shows demo program menu`
  printf("Demo I2CBUS line on GMB HR84 in uC/51 - Rel. 1.1 with ");
  switch (minmod)
    {
    case '1': puts("CAN GM1");
	      break;
    case '2': puts("CAN GM2");
	      break;
    case '3': puts("GMM 5115");
	      break;
    }
//endswitch
  if (minmod=='3')			       // Cycle that waits card ready
    {							       // On GMM 5115
    do
      rd_ee(0x07F8,&dr);
    while (dr!=0);
    }
   else
    {						       // On CAN GM1, CAN GM2
    do
      {
      dr=P2_1;
      starti2c();
      wri2c_byte(0xA0);
      dw=rdi2c_bit();
      }
    while ((dr==0) || (dw==1));
    }
//endif
  puts("");						      // Clear screen
  puts("Read and write on I2CBUS external devices, connected to CN3.");
  if (minmod!='3')
    puts("The slave address 160=A0H is used by RTC+SRAM mounted on Mini Module.");
//endif
  for (;;)						      // Endless loop
    {
    puts("");						    // Erases console
    puts("R->Read byte");
    puts("W->Write byte");
    printf("Select:");
    do
      choice=toupper(getc());
    while ((choice != 'R') && (choice != 'W'));
    putc(choice);
    puts("");
    if (choice=='R')
      {
      printf("Read I2CBUS, insert slave address (0..255):");
      inputse(input, 8);			        // Gets unsigned char
      sladd=(unsigned char)atoi(input);	      // Obtain slave address
      printf("\r\n address (0..255):");
      inputse(input, 8);				// Gets unsigned char
      dw=(unsigned char)atoi(input);			   // Obtains address
      resi2c=rd_i2c(sladd,dw,&dr);		   // Performs I2CBUS reading
      printf("\r\nOperation executed ");	// Shows read data and errors
      if (resi2c==0)
	printf("correctly. Read data=%3d\r\n",dr);
       else
	puts("with errors");
//    endif
      }
     else
      {
      printf("Write I2CBUS, insert slave address (0..255):");
      inputse(input, 8);				// Gets unsigned char
      sladd=(unsigned char)atoi(input);	     // Obtains slave address
      printf("\r\n address (0..255):");
      inputse(input, 8);			       // Gets unsigned chars
      dw=(unsigned char)atoi(input);			   // Obtains address
      printf("\r\n data (0..255):");
      inputse(input, 8);				 // Get unsigned char
      dr=(unsigned char)atoi(input);		      // Obtain data to write
      resi2c=wr_i2c(sladd,dw,dr);		   // Performs I2CBUS writing
      printf("\r\nOperation executed ");		      // Shows errors
      if (resi2c==0)
	puts("correctly");
       else
	puts("with errors");
//    endif
      }
//  endif
    waitkey();
    }
//endfor (;;)					       // End of endless loop
}