copy of display.c

The code is for Auxiliary IO module which supports 16 inputs and 16 outputs and Modbus protocol

#include<intrins.h>
#include <string.h>
#include <REG52.H>

#define DATA_PORT P0   
#define SEL_PORT  P2	
#define SCROLL_TIME 4
#define NO_OF_DIGITS 4  //5

idata unsigned char scr_time=0;   //For display scanning

code Disp_Code [10]=        // 7 seg code
{
0x3F,0x06,0x5B,0x4F,0x66,
0x6D,0x7D,0x07,0x7F,0x6F
};                 

idata char Disp_Data[5]={"0000"}; //display buffer
 
code sel_code[5]={0x8F,0x4F,0x2F,0x1F,0x00};

//idata char Dispstr[6];
//idata char *pDisp;

/* define I/O functions */
#define CBYTE ((unsigned char volatile code *)0)
#define DBYTE ((unsigned char volatile idata *) 0)
  
idata  char rxbuff[14];		//14
idata  char txbuff[12];		//11


//union

idata union  mod_data
{
  float fdata[1];
  unsigned char regbuff[5];
};

union mod_data a;


#define ST_RD_03 0x0
#define EN_RD_03 0x3 
#define FN03_SUP 0x01

#define ST_RD_04 0x0
#define EN_RD_04 0x3
#define FN04_SUP 0x01

#define ST_WR_16 0x0 
#define EN_WR_16 0x3
#define FN16_SUP 0x01

#define EOFTM        0x05

code unsigned char orl_data[8]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
code unsigned char anl_data[8]={0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F};
//--------------------------------------------------------------
//BITS
//-------------------------------------------------------------
//Com1 Related
idata bit com1_rec,com1_eof,com1_485dlystart,com1_485dlyend;

//General
idata bit ws,flag,dummy;
idata bit valid_ok,flg_read,flg_analog;
idata bit fun_sup,flg_single,flg_wrongfn,fun_support;


//Characters
//Com1
idata unsigned char com1_txchar,com1_rxchar,com1_rxcnt,com1_txcnt,com1_eofcnt,com1_eoftm;
idata unsigned char com1_offset,com1_dirdlycnt,com1_dirdlytm;

//General Modbus
idata unsigned char mod_fn,exc_code,crch,crcl;
idata unsigned char mod_txlen,mod_txcnt,rx_dbcnt;  // can be removed
idata unsigned char mod_srcaddr,mod_destaddr;
idata unsigned char start_addr,end_addr,rec_addr,rec_length,addr_offset;
idata unsigned int result,poly=40961;
//idata unsigned char remainder;

//ModDrv1
idata volatile unsigned char mod1_state,mod1_devid;
//
idata unsigned int indata;
idata bit ndata =0 ; // new data
idata char decnt =0;

void init(void);
void ModSlave1(void);
void validate(unsigned char,unsigned char);
void read_response(unsigned char,unsigned char,unsigned char);
void write_response(unsigned char,unsigned char);
void store_data(unsigned char,unsigned char,unsigned char);
void store16(unsigned char,unsigned char,unsigned char);
void com1_txmode(void);
void com1_tx(void);
void com1_rxmode(void);      
void cal_crc(unsigned char);
void read3_4(unsigned char,unsigned char,unsigned char);
void dly(unsigned int);
void Process_data();


/******************************************************************************/
/*                INTERRUPT0 interrupt service function                          */
/******************************************************************************/


/******************************************************************************/
/*                Timer 0 interrupt service function                          */
/*                executes each 250us @ 12 MHz Crystal Clock                  */
/******************************************************************************/
void timer0 (void) interrupt 1 using 1{   /* Int Vector at 000BH, Reg Bank 1 */
  static volatile char i=0;
  P1_5 = ~P1_5;									//power led
  TH0 = 0xFC;                                  /* set timer period            */
  TL0 = 0x65;
  TR0 = 1;                                     /* start timer 0               */

if(com1_rec==1)
  {
    com1_eofcnt--;
	if(com1_eofcnt==0)
	  {
	    com1_eof=1;
		com1_rec=0;
	  }
  } 

if(com1_485dlystart==1)
  {
    com1_dirdlycnt--;
	if(com1_dirdlycnt==0)
	  {
	    com1_485dlyend=1;
		com1_485dlystart=0;
	  }
  } 


	
if(scr_time)
{	
	scr_time--;
}
else
{
	scr_time=SCROLL_TIME;
	
	SEL_PORT = 0x00;
    DATA_PORT = 0x00; 
//    if((i == decnt))
	if((i == decnt)&&(decnt != 3))
	  	DATA_PORT=(Disp_Code[Disp_Data[i]&0x0f]| 0x80);
	else
		DATA_PORT= Disp_Code[Disp_Data[i]&0x0f];
	
	
	SEL_PORT=sel_code[i];
    i++;	

	if(i >= NO_OF_DIGITS)
	i=0;
}
}

/*------------------------------------------------
Received data interrupt.
------------------------------------------------*/

static void com_isr (void) interrupt 4 using 2
{
if (RI != 0)
  {
  	RI = 0;
	rxbuff[com1_rxcnt]=SBUF;
    com1_rec=1; 
    com1_rxcnt++;
    com1_eofcnt=com1_eoftm;                
  }
}

/*------------------------------------------------
Received data interrupt.
------------------------------------------------*/

void itoa (unsigned int val,char *str)
   {
	idata unsigned *p;
	idata char k=0;
	 p=&val;
	*(str+4)=0x00;
     for(k=0;k<4;k++)
           {
	         if(*p==0)
					 str[3-k]= '0';
				else
				{
				str[3-k]=(*p%10)+'0';  
	            *p/=10;
			 	}		 	
        //   if(i==4
		//	return &str[5-i];	
           }
   }

void main(void)
{
unsigned char cnt;


for(cnt=0;cnt<9;cnt++)
 {dly(1000);}
init();
a.fdata[0] =0;
while(1)
{
//P1_0=~P1_0;
  ModSlave1();
  if(ndata)
  {
//    ndata = 0;
    Process_data();
    //if not error
	itoa (indata,Disp_Data);
 }
}
}

void Process_data()
{
idata float tmdata;
if((a.fdata[0] <= 9999) && (a.fdata[0] >= 0))
{
tmdata = a.fdata[0];
	if(tmdata == 0)
	{
		decnt = 3 ;  //No decimal
	//	indata = (int)(tmdata);
	}
	else if ((tmdata > 0) && (tmdata < 10))
	{
//		if(tmdata < 1)
//			zerf = 1;
		decnt = 0;
		tmdata = tmdata * 1000;
//		indata = (int)(tmdata * 1000);
	}
	else if ((tmdata >= 10) && (tmdata < 100))
	{
		decnt = 1;
		tmdata = tmdata * 100;
		//indata = (int)(tmdata * 100);
	}
	else if ((tmdata >= 100) && (tmdata < 1000))
	{
		decnt =2;
		tmdata = tmdata * 10;
		//indata = (int)(tmdata * 10);
	}
	else if ((tmdata >= 1000) && (tmdata <= 9999))
	{
		decnt =3;
//		indata = (int)(tmdata);
	}
}
else
{
//	default
// Set error flag 
// 

//indata = 0;
tmdata = 0;
decnt = 3;
}
if(tmdata == 7777)
	indata = 7777;
else
	indata = tmdata ;
}

void init (void)
{
//idata unsigned char poip;
  P1_5 = 0;           			//Power on LED
  P0 = 0x00;					;
  P2 = 0x00;					;
//TIMER SETTINGS 	
	TMOD |= 0x21;			// timer0 = 16bit, timer1 = auto reload
	TH0	 = 0xFC;		// Timer 0 1ms
	TL0	 = 0x65;		// 		 				 			
	TR0 = 1;
	ET0  = 1;			// enable timer 0 int			

//SERIAL PORT 0
   SCON = 0x50;			// initilise serial port 0 
   ES = 1;            			//serial int 0    


//TIMER SETTINGS 	
	TMOD |= 0x21;			// timer0 = 16bit, timer1 = auto reload
	TH1	 = 0xFD;		//	Baud rate = 9600
	TL1	 = 0xFD;
	ET1  = 0;			//Disable timer 1 int
	TR1  = 1; 			//start timer 1


//ENABLE ALL INTSERRUPTS
	EA	 = 1;           	//enable all interrupt 

//ENABLE VARIABLES REQUIRED IN THE PRG
   com1_rec=0;
   com1_eofcnt=0;
   com1_eoftm=EOFTM;
   com1_eof=0;
   com1_dirdlytm=2;
   com1_485dlystart=0;
   com1_485dlyend=0;
   com1_rxcnt=0;


//   poip=   		// 25-3 2006    p1->p0  // Enter device ID
   mod1_devid=(~P1)&0x0f; 
   mod1_state=1;
  
   com1_rxmode();


}

void ModSlave1(void)
{
idata  unsigned char temp1;
  switch (mod1_state)
  {
   case 1:
           if(com1_eof==1)
             {
               com1_eof=0;
               com1_rxcnt=0;
               temp1=rxbuff[0];
               if(temp1==((~P1)&0x0f))
                 {
                   mod1_state=2;
                 }
               else
                 {
                   mod1_state=1;
				   	 ES=1;
                 } 
              }
        
   break;

   case 2:
             validate(rxbuff,txbuff);
             if(valid_ok==1)
               {
                if(flg_read==1)
                  {
                   read_response(rxbuff,txbuff,a.regbuff);
                  }
                else
                  {
                   
						write_response(rxbuff,txbuff);
                  
						if(mod_fn==16)
				   	{
                   		store_data(rxbuff,txbuff,a.regbuff);
      				    
					   }
						}
               }
               mod1_state=3;
               com1_offset=0;
			   ES=0;
			   com1_txcnt=mod_txcnt;
               com1_txmode();
   break;

   case 3:
               com1_txchar=txbuff[com1_offset];
               mod1_state=4;
               com1_tx();  
   break;

   case 4:
		      if(TI==1)
              {
			    TI=0;
                mod1_state=3;
                com1_offset++;
                com1_txcnt--;
                if(com1_txcnt==0)
                   {
				     com1_dirdlycnt=com1_dirdlytm; 
                     com1_485dlystart=1;
                     mod1_state=5;
                     com1_offset=0;                      
                   } 
              }
   break;

   case 5:
            if(com1_485dlyend==1)
              {
               com1_rxmode();
               com1_485dlystart=0;
	       com1_485dlyend=0;
               mod1_state=1;
	       ES=1;
              }  
   break;

   default:
   break;
 }
}






void validate(unsigned char rx_buff,unsigned char tx_buff)
{
unsigned char temp1;
valid_ok=0;
flg_read=0;
flg_analog=0;
flg_single=0;
flg_wrongfn=0;
//mod_devid=DBYTE[rx_buff];
mod_fn=DBYTE[rx_buff+1];

switch(mod_fn)
  {
   case 3:
          fun_support=FN03_SUP;
          if(fun_support==1)
            {
             	start_addr=ST_RD_03;
          		end_addr=EN_RD_03;
	            flg_read=1;                 
    	        flg_analog=1;
        	    flg_single=0;
            }
          else
            {
             	flg_wrongfn=1;
            }

   break;

   case 4:
          fun_support=FN04_SUP;
          if(fun_support==1)
            {
             	start_addr=ST_RD_03;
          		end_addr=EN_RD_03;
	            flg_read=1;                 
    	        flg_analog=1;
        	    flg_single=0;
            }
          else
            {
             	flg_wrongfn=1;
            }
   break;

   break;

   
	case 16:
          fun_support=FN16_SUP;
          if(fun_support==1)
            {
             start_addr=ST_WR_16;
             end_addr=EN_WR_16;
             flg_read=0;                 
             flg_analog=1;
             flg_single=0;
            }
          else
            {
             flg_wrongfn=1;
            }
   break;

   default:
		flg_wrongfn=1;
   break;
  }  
if(flg_wrongfn==0)
  {
   rec_addr=DBYTE[rx_buff+2];
   rec_addr=256*rec_addr;
   temp1=DBYTE[rx_buff+3];
   rec_addr=rec_addr+temp1;

   if(flg_single==1)
     {
      rec_length=1;
     }
   else
     {
      rec_length=DBYTE[rx_buff+4];
      rec_length=256*rec_length;
      rec_length=rec_length+DBYTE[rx_buff+5];
     }

   if((rec_addr>=start_addr) && ((rec_addr+rec_length)<end_addr))
     {
      addr_offset = rec_addr - start_addr;
      valid_ok=1;
     }
   else
     {
      exc_code=2;  
     }  
   }
else
  {
   exc_code=1;
  }
if(valid_ok==0)
  {
   result=65535;
   mod_txcnt=0;

   DBYTE[tx_buff]=mod1_devid;
   cal_crc(mod1_devid);
   mod_txcnt++;

   temp1=mod_fn+0x80;
   DBYTE[tx_buff+1]=temp1;
   cal_crc(temp1);
   mod_txcnt++;
   
   DBYTE[tx_buff+2]=exc_code;
   cal_crc(exc_code);
   mod_txcnt++;

   crch=result & 0x00FF;
   result=result & 0xFF00;
   crcl=result>>8;
   
   DBYTE[tx_buff+3]=crch;
   mod_txcnt++;

   DBYTE[tx_buff+4]=crcl;
   mod_txcnt++;

  }
}


void read_response(unsigned char rx_buff,unsigned char tx_buff,unsigned char data_buff)
{
 switch(mod_fn)
   {
    case 3:
           read3_4(rx_buff,tx_buff,data_buff);
    break;
 
    case 4:
           read3_4(rx_buff,tx_buff,data_buff);
    break;

    default:

    break;
   }
}



void com1_txmode(void)
{
	P1_4=1;
	
}


void com1_tx(void)
{
SBUF=com1_txchar;
P1_5=1;
}

void com1_rxmode(void)
{
	P1_4=0;

}

void cal_crc(unsigned char ch)
{
idata unsigned char i;
 result=result^ch;
 for (i=0;i<8;i++)
	{
	 flag=result & 1;
	 result=result>>1;
	 if (flag==1)
		{
		  result=result^poly;
		}
	}
}



void read3_4(unsigned char rx_buff,unsigned char tx_buff,unsigned char data_buff)
{
unsigned char temp1,temp2;
result=65535;
//mod_destaddr=MOD_TXBUFF;
mod_destaddr=tx_buff;
mod_txcnt=0;

DBYTE[mod_destaddr]=mod1_devid;
cal_crc(mod1_devid);
mod_txcnt++;
mod_destaddr++;

DBYTE[mod_destaddr]=mod_fn;
cal_crc(mod_fn);
mod_txcnt++;
mod_destaddr++;

mod_txlen=rec_length*2;
DBYTE[mod_destaddr]=mod_txlen;
cal_crc(mod_txlen);
mod_txcnt++;
mod_destaddr++;

//mod_srcaddr=MOD_DATABUFF;
mod_srcaddr=data_buff;
mod_srcaddr=mod_srcaddr+(addr_offset*2);
for(temp1=0;temp1<mod_txlen;temp1++)
   {
    temp2=DBYTE[mod_srcaddr];
    mod_srcaddr++;
    DBYTE[mod_destaddr]=temp2;
    cal_crc(temp2);
    mod_txcnt++;
    mod_destaddr++;
   }

crch=result & 0x00FF;
result=result & 0xFF00;
crcl=result>>8;


DBYTE[mod_destaddr]=crch;
mod_txcnt++;
mod_destaddr++;
   
DBYTE[mod_destaddr]=crcl;
mod_txcnt++;
mod_destaddr++;

}


void store_data(unsigned char rx_buff,unsigned char tx_buff,unsigned char data_buff)
{
 switch(mod_fn)
   {
    case 16:
	 //clear error flag	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 
	 			ndata = 1;
            store16(rx_buff,tx_buff,data_buff);
    break;
		
    default:
    break;
   }

}

void store16(unsigned char rx_buff,unsigned char tx_buff,unsigned char data_buff)
{
unsigned char temp1,temp2;
mod_srcaddr=rx_buff+6;
rx_dbcnt=DBYTE[mod_srcaddr];//count
mod_srcaddr++;

mod_destaddr=data_buff;//data buf
//mod_destaddr=mod_destaddr+(addr_offset*2);

for(temp1=0; temp1<rx_dbcnt; temp1++)
  {
   temp2=DBYTE[mod_srcaddr];
   mod_srcaddr++;
   DBYTE[mod_destaddr]=temp2;
   mod_destaddr++;
  }
}



void write_response(unsigned char rx_buff,unsigned char tx_buff)
{
unsigned char temp1;
result=65535;
mod_destaddr=tx_buff;
mod_srcaddr=rx_buff;

mod_txcnt=0;

DBYTE[mod_destaddr]=mod1_devid;
cal_crc(mod1_devid);
mod_txcnt++;
mod_destaddr++;

DBYTE[mod_destaddr]=mod_fn;
cal_crc(mod_fn);
mod_txcnt++;
mod_destaddr++;

temp1=DBYTE[mod_srcaddr+2];
DBYTE[mod_destaddr]=temp1;
cal_crc(temp1);
mod_txcnt++;
mod_destaddr++;

temp1=DBYTE[mod_srcaddr+3];
DBYTE[mod_destaddr]=temp1;
cal_crc(temp1);
mod_txcnt++;
mod_destaddr++;

temp1=DBYTE[mod_srcaddr+4];
DBYTE[mod_destaddr]=temp1;
cal_crc(temp1);
mod_txcnt++;
mod_destaddr++;

temp1=DBYTE[mod_srcaddr+5];
DBYTE[mod_destaddr]=temp1;
cal_crc(temp1);
mod_txcnt++;
mod_destaddr++;

crch=result & 0x00FF;
result=result & 0xFF00;
crcl=result>>8;


DBYTE[mod_destaddr]=crch;
mod_txcnt++;
mod_destaddr++;
   
DBYTE[mod_destaddr]=crcl;
mod_txcnt++;
mod_destaddr++;

}

void dly(unsigned int delay)
{
unsigned int dlycnt;
for(dlycnt=0;dlycnt<=delay;dlycnt++)
	{
		dummy=0;
	}

}