auxio.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 LEN		P2_0
#define BEN		P2_1
#define DIR		P2_2
#define HBIT	P2_3
// To read DIP switch
#define ID1		P1_0
#define ID2		P1_1
#define ID3		P1_2
#define ID4		P1_3


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



idata unsigned char regbuff[4];
//idata unsigned char regbitbuff;	




#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 ST_WR_15 0x0 
//#define EN_WR_15 0x08
//#define FN15_SUP 0x00

#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 Hbitcnt;

//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 TransmitChar(unsigned char );
void Output(unsigned char out);
void Input(void);
/******************************************************************************/
/*                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
  Hbitcnt ++;
  if (Hbitcnt == 250)
  {
  HBIT = ~HBIT;	
  Hbitcnt = 0;
  }
  
  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;
	  }
  } 
}

/*------------------------------------------------
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 main(void)
{
unsigned char cnt;

for(cnt=0;cnt<9;cnt++)
 {dly(1000);}
init();
TransmitChar('V');
TransmitChar('E');
TransmitChar('R');
TransmitChar('1');

while(1)
{
//	 Output(0x00);
//	 TransmitChar(P1 & 0x0f);
//	 dly(60000);
//	 Output(0xff);
//	 dly(60000);
  	ModSlave1();
	if(ndata)
	{
	 ndata = 0;
	 Output();
	}

}
}
void init (void)
{
//idata unsigned char poip;
//  P1_5 = 0;           			//Power on LED
  LEN = 0;
  BEN = 1;
  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    
//   TXD = 0;
//   RXD = 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=5;
   com1_485dlystart=0;
   com1_485dlyend=0;
   com1_rxcnt=0;


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

void TransmitChar(unsigned char asc)
{
 
 	ES = 0;
  	SBUF=asc;
	while(!TI);
	TI=0;	
	ES=1;
}

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,regbuff);
                  }
                else
                  {
                   write_response(rxbuff,txbuff);
                  }
               }
               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;
   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)
{
	DIR=1;
	
}

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

void com1_rxmode(void)
{
	DIR=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;
Input();		//update data
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;
	}

}

void Output(unsigned char out)
{
  LEN = 1;
  dly(5);
  P0 = regbuff[2];
  LEN = 0;
}

void Input(void)
{
  BEN = 0;
  dly(5);
  regbuff[0] = P0;
  BEN = 1;

}