/* 
 **********************************************************************
 * File   GMBIOTE.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: GMBIOTE.C - Rel. 1.1 - By Angelini Gianluca
  This demo allows to use immediatly TTL I/O digital lines available on CN4.
  According to Mini Module used, the list of available lines is printed. When
  the required line is selected it can be managed as input (its status is
  shown continuously on console) or as output (setting it high or low).
  Should the line selected be associated to Real Time Clock, this peripheral
  manages it.

  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
#define	RTCSLA 0xA0			        // RTC PCF 8583 slave address

// 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 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);
}

unsigned char bintobcd(unsigned char d)
/* Procedure that converts the binary coded byte d (0-99) into relative
   bcd code   */
{
  d=((d/10)<<4)|(d%10);
  return d;
}

unsigned char bcdtobin(unsigned char d)
/* Procedure that converts the bcd coded byte d into relative binary
   code (0-99)  */
{
  d=((d>>4)*10)+(d&0x0F);
  return d;
}

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 demoiopin(void)
/* Asks for test direction of the bit specified in choice and manages its
   setting or acquisition, according with user selection through console  */
{
  do
    {
    printf("\r\nTest in Input,Output,End?");
    do
      hlp=toupper(getc());
    while ((hlp!='I') && (hlp!='O') && (hlp!='E'));
    putc(hlp);
    switch (hlp)
      {
      case 'I': puts("\r\nPin Acquisition in execution. Press a key to exit");
		setP1234inp();			// Sets Port 1,2,3,4 as INPUT
		do
		  {
		  switch (choice)	     // Gets status from selected pin
		    {
		    case '2': dr=P2_2;
			      break;
		    case '3': dr=P4_0;
			      break;
		    case '5': dr=P4_1;
			      break;
		    case '6': dr=P1_3;
			      break;
		    case '8': dr=P1_0;
			      break;
		    }
//		  endswitch
		  printf("%X\r",dr);			  // Shows pin status
		  delay(50);			   // Avoids console overflow
		  }
		while (! kbhit());			  // Wait key pressed
		getc();
		break;
      case 'O':	puts("\r\nSetting selected pin.");
		do
		  {			       // Acquisisce stato da settare
		  printf("\rInsert line status (0,1,>1 to exit):");
		  inputse(input, 8);		    // Acquires unsigned char
		  dw=(uchar)atoi(input);
		  switch (choice)		  // Sets selected pin status
		    {
		    case '2': P2_2=dw;
			      break;
		    case '3': P4_0=dw;
			      break;
		    case '5': P4_1=dw;
			      break;
		    case '6': P1_3=dw;
			      break;
		    case '8': P1_0=dw;
			      break;
		    }
//		  endswitch
		  }
		while (dw<2);
		break;
      }
//  endswitch
    }
  while (hlp!='E');
}

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
}

void setrtc(unsigned char wee,unsigned char yea,unsigned char mon,unsigned char day,unsigned char hou,unsigned char min,unsigned char sec)
/* Sets current date and time on Mini Module RTC with data passed in
   parameters, selecting 24 hours format and interrupt each second   */
{
  resi2c=wr_i2c(RTCSLA,0x00,0x84);				 // Sets stop
  resi2c=wr_i2c(RTCSLA,0x01,0x00);		  // Sets hundreds of seconds
  resi2c=wr_i2c(RTCSLA,0x02,bintobcd(sec));		      // Sets seconds
  resi2c=wr_i2c(RTCSLA,0x03,bintobcd(min));		      // Sets minutes
  resi2c=wr_i2c(RTCSLA,0x04,bintobcd(hou));	    // Sets hours, 24h format
  resi2c=wr_i2c(RTCSLA,0x05,(bintobcd(day)|(yea<<6)));	 // Sets day and year
  resi2c=wr_i2c(RTCSLA,0x06,(bintobcd(mon)|(wee<<5)));// Sets month, week day
  resi2c=wr_i2c(RTCSLA,0x07,0x00);				// Sets timer
  resi2c=wr_i2c(RTCSLA,0x00,0x00);				// Sets start
}

void disrtcint(void)
/* Disables /INT generation from PCF 8583 Real Time Clock    */
{
  resi2c=wr_i2c(RTCSLA,0x00,0x04);			 // Disables RTC /INT
  resi2c=wr_i2c(RTCSLA,0x08,0x00);
}

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)
{
  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'));
  if (minmod!='3')				    // If Mini Module has RTC
    disrtcint();      // Disables RTC interrupt and LD6 that shows its status
  for(;;)						      // Endless loop
    {
    clrscr();					  // Shows demo program menu`
    printf("Demo program for TTL I/O lines 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
    ADCF=0x00;				       // Sets all P1 as I/O, not A/D
    puts("");
    puts("On CN4 are available the following digital I/O pins:");
    puts("6=MM PIN 24");		// I/O available on each Mini Modules
    puts("8=MM PIN 27");
    switch (minmod)
      {
      case '1': puts("4=MM PIN 5");	       // Other I/O of CAN GM1 module
		puts("2=MM PIN 12");
		break;
      case '2': puts("4=MM PIN 5");	       // Other I/O of CAN GM2 module
		break;
      case '3': puts("3=MM PIN 8");	      // Other I/O of GMM 5115 module
		puts("5=MM PIN 9");
		break;
      }
//  endswitch
    printf("Select pin:");
    choice=getc();
    putc(choice);
    switch (choice)
      {
      case '2': demoiopin();			 // Pin 2 CN4 management demo
		break;
      case '3': demoiopin();			 // Pin 3 CN4 management demo
		break;
      case '4': puts("");			 // Pin 4 CN4 management demo
		puts("Pin 4 of CN4 is connected to /INTRTC of Mini Module that offers interesting");
		puts("autonomous functionalities, and it is displayed by LD6 LED.");
		puts("The demo generates an 1 Hz square waveform until a key is pressed.");
		setrtc(0,0,1,1,0,0,0);// Resets RTC and enables /INT each sec
		choice=getc();				 // Waits key pressed
		disrtcint();			    // Disables /INT from RTC
		break;
      case '5': demoiopin();			 // Pin 5 CN4 management demo
		break;
      case '6': demoiopin();			 // Pin 6 CN4 management demo
		break;
      case '8': printf("\r\nOn pin 8 of CN4 is connected a 4,7K pulldown resistor.");
		demoiopin();			 // Pin 8 CN4 management demo
		break;
      }
//  endswitch
    }
//endfor (;;)					       // End of endless loop
}