test2.bak

This is my code (with PIC 18F458) for Modbus RTU Network. I have written by Ccs laguage

//dung giao tiep voi Pc
#include <18f4580.h>
#include <board.h>
#include <MODBUS-RTU.c>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=40000000)
#use rs232(baud=9600 , parity=n , xmit=pin_C6 , rcv=pin_C7 )


int8   receiveMessage[8];//phai o ben nay


//*****************************************************************************
#int_rda     //gia tri bien trong nay ko xai duoc cho ben kia
void receive()
{  
   int8 i=0;
   receiveMessage[count]=getc();
   if ((receiveMessage[0]==Stage_ID))        //detemine address
   {
     
      count++;
      if(status==0)        //RDA wait querry message
      {
         if(count==2)      //determine command
         {
            Switch (receiveMessage[1])
            {
            case(0x01):                       //READ COIL STATUS
            {  
               functionCode_Receive=0x01;               
               lengthOfQueryMessage_input=8; 
               break;
            }
            case(0x02):                       //READ INPUT STATUS
            {
               functionCode_Receive=0x02;
               lengthOfResponseMessage_output=8; 
               lengthOfQueryMessage_input=8;
               break;
            }
            case(0x03):                       //READ HOLDING REGISTERS
            {
               functionCode_Receive=0x03;               
               lengthOfQueryMessage_input=8;
               break;
            }
            case(0x04):                       //READ INPUT REGISTERS
            {              
               lengthOfQueryMessage_input=8;
               functionCode_Receive=0x04;
               break;
            }
            case(0x05):                       //FORCE SINGLE COIL
            {
               functionCode_Receive=0x05;
               lengthOfResponseMessage_output=8; 
               lengthOfQueryMessage_input=8;                
               break;
            }
            case(0x06):                       //PRESET SINGLE REGISTER
            {
               lengthOfResponseMessage_output=8; 
               lengthOfQueryMessage_input=8;
               functionCode_Receive=0x06;
               break;                                               
            }
            case(0x07):                       //read exception Status
            {
               lengthOfResponseMessage_output=5; 
               lengthOfQueryMessage_input=4;
               functionCode_Receive=0x07;
               break;                        
            }
            case(0x0B):                       //Fetch Comm Event Counter
            {
               lengthOfResponseMessage_output=8; 
               lengthOfQueryMessage_input=4;
               functionCode_Receive=0x0B;
               break;
            }
            case(0x0C):
            {
               lengthOfResponseMessage_output=13; 
               lengthOfQueryMessage_input=4;
               functionCode_Receive=0x0C;
               break;
            }
            case(0x0F):                       //FORCE MULTIPLE COILS
            {
               lengthOfResponseMessage_output=8; 
               lengthOfQueryMessage_input=10;
               functionCode_Receive=0x0F;
               break;
            }
            case(0x10):                       //PRESET MULTIPLE REGS
            {
               lengthOfResponseMessage_output=8; 
               lengthOfQueryMessage_input=13;
               functionCode_Receive=0x10;
               break;
            }
            case(0x11):
            {           
               functionCode_Receive=0x11;
               break;
            }
            case(0x14):
            {
               functionCode_Receive=0x14;
               break;
            }
            case(0x15):
            {
               functionCode_Receive=0x15;
               break;
            }
            case(0x16):
            {
               functionCode_Receive=0x16;
               break;
            }
            case(0x17):
            {
               functionCode_Receive=0x17;
               break;
            }
            case(0x18):
            {
               functionCode_Receive=0x18;
               break;
            }
            default:
               break;
            }
         }
         if(count==lengthOfQueryMessage_input)
         {      
            count=0;
            value=1;
            Switch (receiveMessage[1])
            {
               case(0x01):                      //READ COIL STATUS
               {
               /*   StartingAddress=0;
                  StartingAddressHigh=0;
                  StartingAddressLow=0;
                  StartingAddressHigh=receiveMessage[2]& 0x00ff;
                  StartingAddressLow=receiveMessage[3]& 0x00ff;
                  StartingAddress=((StartingAddress | StartingAddressHigh) << 8) | (StartingAddressLow);   */
                  
                  StartingAddress=0;    
                  NumberPoint_bits=0;
                  
                  StartingAddress=((StartingAddress | receiveMessage[2]) << 8) | (receiveMessage[3]);
                  NumberPoint_bits=(receiveMessage[4]*256)+ receiveMessage[5];                 
                   
                  if (NumberPoint_bits % 8 == 0)
                  {
                     lengthOfResponseMessage_output = 5 + NumberPoint_bits / 8;
                     ByteCount= NumberPoint_bits / 8;
                  }
                  else
                  {
                     lengthOfResponseMessage_output = 6 + NumberPoint_bits / 8;
                     ByteCount= 1 + NumberPoint_bits / 8;
                  }
                     
                 //***********xu ly data truyen di******************************
                 responseMessage[0]=receiveMessage[0];   //Slave Address
                 responseMessage[1]=receiveMessage[1];   //function
                 responseMessage[2]=ByteCount;           //bytecount
                 responseMessage[3]=0x0f;                //value           Sau nay lam them,neu co nhieu byte
                 getCRC(responseMessage,(lengthOfResponseMessage_output-2),CRC);
                 responseMessage[4]=CRC[0];
                 responseMessage[5]=CRC[1];
                 //************************************************************* 
                  break;                   
               }  
               case(0x02):                      //READ INPUT STATUS
               {
               break;
               }
               case(0x03):                      //READ HOLDING REGISTERS
               {        
                  StartingAddress=0;    
                  NumberPoint_bytes=0;
                  
                  StartingAddress=((StartingAddress | receiveMessage[2]) << 8) | (receiveMessage[3]);
                  NumberPoint_bytes=(receiveMessage[4]*256)+ receiveMessage[5];
                  lengthOfResponseMessage_output=(receiveMessage[4]*256+receiveMessage[5])*2+5;
                  break;
               }   
               case(0x04):                      //READ INPUT REGISTERS
               {      
                  StartingAddress=0;    
                  NumberPoint_bytes=0;
                  
                  StartingAddress=((StartingAddress | receiveMessage[2]) << 8) | (receiveMessage[3]);
                  NumberPoint_bytes=(receiveMessage[4]*256)+ receiveMessage[5];
                  lengthOfResponseMessage_output=(receiveMessage[4]*256+receiveMessage[5])*2+5;;
                  break;
               }
               case(0x05):                      //FORCE SINGLE COIL
               {
                  CoilAddress=0;
                  
                  for (i=0;i<lengthOfResponseMessage_output;i++)
                     {
                        responseMessage[i]=receiveMessage[i];
                     }                  
                  CoilAddress=((CoilAddress | receiveMessage[2]) << 8) | (receiveMessage[3]);
                  
                  break;
               }
               case(0x06):                      //PRESET SINGLE REGISTER
               {
               break;
               }
               case(0x07):                      //read exception Status
               {
               break;
               }
               case(0x0B):                      //Fetch Comm Event Counter
               {
               break;
               }
               case(0x0F):                      //FORCE MULTIPLE COILS
               {
               break;
               }
               case(0x10):                      //PRESET MULTIPLE REGS
               {
               break;
               }
               
               default:
               break;      
            }
         }
      }
      else                 //RDA wait response message  
      {
      }
   //ETransmit  
   }
   else if (receiveMessage[0]!=Stage_ID)
   {      
      //count=0;
     // receiveMessage[0]=0;
   }
}

//******************************************************************************
void setup()
{
   delay_ms(100);
   enable_interrupts(global);
   enable_interrupts(int_rda);
   TrisD =0x00;
   TrisA =0xff;
   PortA =0x00;
   PortD =0xf0;
  // output_high(pin_c0);  
   output_low(pin_c2);  //RX
   
}
//******************************************************************************
void main()
{   

   setup();  
                  
   while(true)
     { 
     
       if(value==1)                                   //finish RDA message
       {
        value=0;                             
        if ((functionCode_Receive!=0)&&(status==0))   //RDA wait querry message   
         {
            getCRC(receiveMessage,(lengthOfQueryMessage_input-2),CRC);
            if((CRC[1]==receiveMessage[7]) && (CRC[0]==receiveMessage[6]))
            {
               
               PortD =receiveMessage[7];
               output_high(pin_c2);  //TX
               switch (functionCode_Receive)
               {
                  case(0x01):                   //READ COIL STATUS
                  {                    
                     functionCode_Receive=0;
                     response(responseMessage);
                     
                     break;
                  }
                  case(0x05):                   //FORCE SINGLE COIL
                  {                     
                     functionCode_Receive=0;                     
                     response(responseMessage);  //responseMessage
                    
                     break;
                  }
                  default:
                     break;
               }
            }
            else
            {
               functionCode_Receive=0;
            }
            delay_ms (5);   //phai co thoi gian tre
            output_low(pin_c2);  //RX
         }
        if ((functionCode_Receive!=0)&&(status==1)) //RDA wait response message
         {
            status=0;    
         }     
         
       }    
     }  
}