Difference between revisions of "EPEVER 485"

From Public Wiki
Jump to navigation Jump to search
Line 273: Line 273:
 
#define BUFS 64  //Buffer size
 
#define BUFS 64  //Buffer size
 
short crc;
 
short crc;
 +
byte arry[6] = {0x00, 0x02, 0x02, 0x00, 0x02, 0x00};
 
byte Response[BUFS];
 
byte Response[BUFS];
 
byte Response_size;
 
byte Response_size;
Line 296: Line 297:
 
{
 
{
 
    
 
    
−
   Response_size = zeroone(Response, 0x0002, 0x0001);
+
   Response_size = onezero(Response, 0x903D, 0x0003, arry, LOW);
 
     if(Response_size==0) Serial.println("Received Error from 0x01");
 
     if(Response_size==0) Serial.println("Received Error from 0x01");
  
−
   Serial.print("Size is ");
+
   Serial.print("Size is : ");
 
   Serial.println(Response_size);
 
   Serial.println(Response_size);
−
    
+
 
 +
   Serial.print("Response string is : ");
 
   for(byte i=0;i<Response_size;i++)
 
   for(byte i=0;i<Response_size;i++)
 
   {
 
   {
Line 309: Line 311:
 
     Serial.print(" ");
 
     Serial.print(" ");
 
   }
 
   }
−
/*
 
−
  if(Response[1]!=0x83)
 
−
  { 
 
−
    Serial.print("0x");
 
−
    if(Response[4]<16) Serial.print("0");
 
−
    Serial.print(Response[4],HEX);
 
−
  }
 
−
  else
 
−
  {
 
−
    Serial.print("Error 0x0");
 
−
    Serial.print(Response[2]);
 
−
  }
 
−
*/
 
 
   Serial.println();
 
   Serial.println();
  
Line 545: Line 534:
 
   return sz;
 
   return sz;
 
}
 
}
 +
///////////////
 +
byte zerofive(byte rs[],int addr, bool set, bool confirmation)
 +
{
 +
  byte rq[8];  //Always 8 bytes
 +
  //int addr;
 +
  //int len;
 +
  short c; //CRC value
 +
  byte i, j,sz;  //Counters, size
 +
 +
 
 +
  rq[0]=DEVICE; //Global device IO
 +
  rq[1]=0x05;
 +
  rq[3]=byte(addr&0x00FF);
 +
  rq[2]=byte((addr&0xFF00)>>8);
 +
  rq[4]=0x00; 
 +
  if(set) rq[5]=0xFF;
 +
  else rq[5]=0x00;
 +
 +
 +
  c = CRC16(rq,6);
 +
  rq[7]=0x00FF & c;
 +
  rq[6]=c>>8;
 +
  if(confirmation)
 +
  {
 +
    for(i=0;i<8;i++)
 +
    {
 +
      Serial1.write(rq[i]);
 +
    }
 +
  }
 +
  sz = 6;
 +
  if(sz>BUFS)
 +
  {
 +
    Serial.println("Buffer overflow prevented in 0x03.  Recompile with BUFS to a higher value");
 +
    return 0;
 +
  }
 +
  if(confirmation)
 +
  {
 +
    for(i=0;i<sz;)
 +
    {
 +
      if (Serial1.available())            //Data from the Slave is available
 +
      {
 +
        rs[i]=Serial1.read();
 +
        if(i==1 && rs[i]==0x83) sz=5;
 +
        i++;
 +
      } 
 +
    }
 +
  }
 +
  else
 +
  {
 +
    for(i=0;i<sz;)
 +
    {
 +
        rs[i]=rq[i];
 +
        i++;
 +
    }
 +
  }
 +
  c=CRC16(rs,sz-2);
 +
  if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
 +
  {
 +
    Serial.println("CRC error in 0x03");
 +
    return 0;
 +
  }
 +
}
 +
///////////////
 +
byte onezero(byte rs[],int start, int num, byte arr[], bool confirmation)
 +
{
 +
  byte rq[132];  //Always 8 bytes
 +
  //int addr;
 +
  //int len;
 +
  short c; //CRC value
 +
  byte i, j,sz;  //Counters, size
 +
 +
  if(num==0 || num>0x7B)
 +
  {
 +
    Serial.println("Invalid number of registers being written in 0x10.");
 +
    return 0;
 +
  }
 +
  rq[0]=DEVICE; //Global device IO
 +
  rq[1]=0x10;
 +
  rq[3]=byte(start&0x00FF);
 +
  rq[2]=byte((start&0xFF00)>>8);
 +
  rq[5]=byte(num&0x00FF);
 +
  rq[4]=byte((num&0xFF00)>>8);
 +
  rq[6]=num<<1;
 +
 +
  for(int i=0;i<(num<<1);i++)
 +
  {
 +
    rq[7+i]=arr[i];
 +
  }
 +
 +
  c = CRC16(rq,7+(num<<1));
 +
  rq[8+(num<<1)]=0x00FF & c;
 +
  rq[7+(num<<1)]=c>>8;
 +
 +
  if(confirmation)
 +
  {
 +
    for(i=0;i<9+(num<<1);i++)
 +
    {
 +
      Serial1.write(rq[i]);
 +
    }
 +
  }
 +
  else
 +
  {
 +
    for(i=0;i<9+(num<<1);i++)
 +
    {
 +
      rs[i]=rq[i];
 +
    }
 +
  }
 +
  sz = 9+(num<<1);
 +
  if(sz>BUFS)
 +
  {
 +
    Serial.println("Buffer overflow prevented in 0x04.  Recompile with BUFS to a higher value");
 +
    return 0;
 +
  }
 +
  if(confirmation)
 +
  {
 +
    sz=8;
 +
    for(i=0;i<8;)//always 8
 +
    {
 +
   
 +
      if (Serial1.available())            //Data from the Slave is available
 +
      {
 +
        rs[i]=Serial1.read();
 +
        i++;
 +
      }
 +
    }
 +
    c=CRC16(rs,sz-2);
 +
    if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
 +
    {
 +
      Serial.println("CRC error in 0x04");
 +
      return 0;
 +
    }
 +
  }
 +
  return sz;
 +
}
 +
  
 
short CRC16(byte array[],byte s)
 
short CRC16(byte array[],byte s)

Revision as of 19:31, 17 November 2020

Synopsis

Issues 485 request and display result

Notes

9000-9100 Registers

0xFFFF9000 : 0x00 0xFFFF9001 : 0x70 0xFFFF9002 : 0x00 0xFFFF9003 : 0x86 0xFFFF9004 : 0x68 0xFFFF9005 : 0x5E 0xFFFF9006 : 0x54 0xFFFF9007 : 0x54 0xFFFF9008 : 0xC8 0xFFFF9009 : 0x50 0xFFFF900A : 0x00 0xFFFF900B : 0x00 0xFFFF900C : 0x60 0xFFFF900D : 0xAC 0xFFFF900E : 0x48 0xFFFF900F : 0x00 0xFFFF9010 : 0x64 0xFFFF9011 : 0x00 0xFFFF9012 : Error 0x02 0xFFFF9013 : 0x27 0xFFFF9014 : 0x15 0xFFFF9015 : 0x0B 0xFFFF9016 : 0x1E 0xFFFF9017 : 0x4C 0xFFFF9018 : 0x00 0xFFFF9019 : 0x1C 0xFFFF901A : 0x40 0xFFFF901B : 0x34 0xFFFF901C : 0x4C 0xFFFF901D : 0x02 0xFFFF901E : 0xE8 0xFFFF901F : 0x0A 0xFFFF9020 : 0xB0 0xFFFF9021 : 0x0A 0xFFFF9022 : Error 0x02 0xFFFF9023 : Error 0x02 0xFFFF9024 : Error 0x02 0xFFFF9025 : Error 0x02 0xFFFF9026 : Error 0x02 0xFFFF9027 : Error 0x02 0xFFFF9028 : Error 0x02 0xFFFF9029 : Error 0x02 0xFFFF902A : Error 0x02 0xFFFF902B : Error 0x02 0xFFFF902C : Error 0x02 0xFFFF902D : Error 0x02 0xFFFF902E : Error 0x02 0xFFFF902F : Error 0x02 0xFFFF9030 : Error 0x02 0xFFFF9031 : Error 0x02 0xFFFF9032 : Error 0x02 0xFFFF9033 : Error 0x02 0xFFFF9034 : Error 0x02 0xFFFF9035 : Error 0x02 0xFFFF9036 : Error 0x02 0xFFFF9037 : Error 0x02 0xFFFF9038 : Error 0x02 0xFFFF9039 : Error 0x02 0xFFFF903A : Error 0x02 0xFFFF903B : Error 0x02 0xFFFF903C : Error 0x02 0xFFFF903D : 0x00 0xFFFF903E : 0x00 0xFFFF903F : 0x00 0xFFFF9040 : Error 0x02 0xFFFF9041 : Error 0x02 0xFFFF9042 : 0x00 0xFFFF9043 : 0x00 0xFFFF9044 : 0x13 0xFFFF9045 : 0x00 0xFFFF9046 : 0x00 0xFFFF9047 : 0x06 0xFFFF9048 : 0x00 0xFFFF9049 : 0x00 0xFFFF904A : 0x13 0xFFFF904B : 0x00 0xFFFF904C : 0x00 0xFFFF904D : 0x06 0xFFFF904E : Error 0x02 0xFFFF904F : Error 0x02 0xFFFF9050 : Error 0x02 0xFFFF9051 : Error 0x02 0xFFFF9052 : Error 0x02 0xFFFF9053 : Error 0x02 0xFFFF9054 : Error 0x02 0xFFFF9055 : Error 0x02 0xFFFF9056 : Error 0x02 0xFFFF9057 : Error 0x02 0xFFFF9058 : Error 0x02 0xFFFF9059 : Error 0x02 0xFFFF905A : Error 0x02 0xFFFF905B : Error 0x02 0xFFFF905C : Error 0x02 0xFFFF905D : Error 0x02 0xFFFF905E : Error 0x02 0xFFFF905F : Error 0x02 0xFFFF9060 : Error 0x02 0xFFFF9061 : Error 0x02 0xFFFF9062 : Error 0x02 0xFFFF9063 : 0x1E 0xFFFF9064 : 0x02 0xFFFF9065 : 0x00 0xFFFF9066 : Error 0x02 0xFFFF9067 : 0x02 0xFFFF9068 : Error 0x02 0xFFFF9069 : 0x00 0xFFFF906A : 0x00 0xFFFF906B : 0x78 0xFFFF906C : 0x50 0xFFFF906D : 0x1E 0xFFFF906E : 0x50 0xFFFF906F : 0x28 0xFFFF9070 : 0x00 0xFFFF9071 : Error 0x02 0xFFFF9072 : Error 0x02 0xFFFF9073 : Error 0x02 0xFFFF9074 : Error 0x02 0xFFFF9075 : Error 0x02 0xFFFF9076 : Error 0x02 0xFFFF9077 : Error 0x02 0xFFFF9078 : Error 0x02 0xFFFF9079 : Error 0x02 0xFFFF907A : Error 0x02 0xFFFF907B : Error 0x02 0xFFFF907C : Error 0x02 0xFFFF907D : Error 0x02 0xFFFF907E : Error 0x02 0xFFFF907F : Error 0x02 0xFFFF9080 : Error 0x02 0xFFFF9081 : Error 0x02 0xFFFF9082 : Error 0x02 0xFFFF9083 : Error 0x02 0xFFFF9084 : Error 0x02 0xFFFF9085 : Error 0x02 0xFFFF9086 : Error 0x02 0xFFFF9087 : Error 0x02 0xFFFF9088 : Error 0x02 0xFFFF9089 : Error 0x02 0xFFFF908A : Error 0x02 0xFFFF908B : Error 0x02 0xFFFF908C : Error 0x02 0xFFFF908D : Error 0x02 0xFFFF908E : Error 0x02 0xFFFF908F : Error 0x02 0xFFFF9090 : 0x00 0xFFFF9091 : 0x00 0xFFFF9092 : 0x00 0xFFFF9093 : 0x00 0xFFFF9094 : 0x57 0xFFFF9095 : 0x00 0xFFFF9096 : 0x00 0xFFFF9097 : 0x38 0xFFFF9098 : 0xEE 0xFFFF9099 : Error 0x02 0xFFFF909A : Error 0x02 0xFFFF909B : Error 0x02 0xFFFF909C : Error 0x02 0xFFFF909D : Error 0x02 0xFFFF909E : Error 0x02 0xFFFF909F : Error 0x02 0xFFFF90A0 : 0x00 0xFFFF90A1 : 0x00 0xFFFF90A2 : 0x00 0xFFFF90A3 : 0x00 0xFFFF90A4 : 0x00 0xFFFF90A5 : Error 0x02 0xFFFF90A6 : Error 0x02 0xFFFF90A7 : Error 0x02 0xFFFF90A8 : Error 0x02 0xFFFF90A9 : Error 0x02 0xFFFF90AA : Error 0x02 0xFFFF90AB : Error 0x02 0xFFFF90AC : Error 0x02 0xFFFF90AD : Error 0x02 0xFFFF90AE : Error 0x02 0xFFFF90AF : Error 0x02 0xFFFF90B0 : 0xD2 0xFFFF90B1 : 0x60 0xFFFF90B2 : 0x13 0xFFFF90B3 : 0x7A 0xFFFF90B4 : 0x00 0xFFFF90B5 : 0xA7 0xFFFF90B6 : 0x89 0xFFFF90B7 : 0x35 0xFFFF90B8 : 0x75 0xFFFF90B9 : 0x87 0xFFFF90BA : 0x00 0xFFFF90BB : 0x00 0xFFFF90BC : Error 0x02 0xFFFF90BD : 0x00 0xFFFF90BE : 0x00 0xFFFF90BF : 0xE0 0xFFFF90C0 : Error 0x02 0xFFFF90C1 : Error 0x02 0xFFFF90C2 : Error 0x02 0xFFFF90C3 : Error 0x02 0xFFFF90C4 : Error 0x02 0xFFFF90C5 : Error 0x02 0xFFFF90C6 : Error 0x02 0xFFFF90C7 : Error 0x02 0xFFFF90C8 : Error 0x02 0xFFFF90C9 : Error 0x02 0xFFFF90CA : Error 0x02 0xFFFF90CB : Error 0x02 0xFFFF90CC : Error 0x02 0xFFFF90CD : Error 0x02 0xFFFF90CE : Error 0x02 0xFFFF90CF : Error 0x02 0xFFFF90D0 : Error 0x02 0xFFFF90D1 : Error 0x02 0xFFFF90D2 : Error 0x02 0xFFFF90D3 : Error 0x02 0xFFFF90D4 : Error 0x02 0xFFFF90D5 : Error 0x02 0xFFFF90D6 : Error 0x02 0xFFFF90D7 : Error 0x02 0xFFFF90D8 : Error 0x02 0xFFFF90D9 : Error 0x02 0xFFFF90DA : Error 0x02 0xFFFF90DB : Error 0x02 0xFFFF90DC : Error 0x02 0xFFFF90DD : Error 0x02 0xFFFF90DE : Error 0x02 0xFFFF90DF : Error 0x02 0xFFFF90E0 : Error 0x02 0xFFFF90E1 : Error 0x02 0xFFFF90E2 : Error 0x02 0xFFFF90E3 : Error 0x02 0xFFFF90E4 : Error 0x02 0xFFFF90E5 : Error 0x02 0xFFFF90E6 : Error 0x02 0xFFFF90E7 : Error 0x02 0xFFFF90E8 : Error 0x02 0xFFFF90E9 : Error 0x02 0xFFFF90EA : Error 0x02 0xFFFF90EB : Error 0x02 0xFFFF90EC : Error 0x02 0xFFFF90ED : Error 0x02 0xFFFF90EE : Error 0x02 0xFFFF90EF : Error 0x02 0xFFFF90F0 : Error 0x02 0xFFFF90F1 : Error 0x02 0xFFFF90F2 : Error 0x02 0xFFFF90F3 : Error 0x02 0xFFFF90F4 : Error 0x02 0xFFFF90F5 : Error 0x02 0xFFFF90F6 : Error 0x02 0xFFFF90F7 : Error 0x02 0xFFFF90F8 : Error 0x02 0xFFFF90F9 : Error 0x02 0xFFFF90FA : Error 0x02 0xFFFF90FB : Error 0x02 0xFFFF90FC : Error 0x02 0xFFFF90FD : Error 0x02 0xFFFF90FE : Error 0x02 0xFFFF90FF : Error 0x02

Code

  1 //#include <SoftwareSerial.h>
  2 //const int SSERIAL_RX_PIN = 10;  //Soft Serial Receive pin
  3 //const int SSERIAL_TX_PIN = 11;  //Soft Serial Transmit pin
  4 
  5 // Create Soft Serial Port object and define pins to use
  6 //SoftwareSerial RS485Serial(SSERIAL_RX_PIN, SSERIAL_TX_PIN); // RX, TX
  7 
  8 #define DEVICE 0x01
  9 #define BUFS 64   //Buffer size
 10 short crc;
 11 byte arry[6] = {0x00, 0x02, 0x02, 0x00, 0x02, 0x00};
 12 byte Response[BUFS];
 13 byte Response_size;
 14 byte countdown = 2;
 15 //===============================================================================
 16 //  Initialization
 17 //===============================================================================
 18 void setup()
 19 {
 20   Serial.begin(115200);           // Start the built-in serial port   
 21   Serial1.begin(115200);   // Start the RS485 soft serial port 
 22   delay(1000);
 23   Serial.println();
 24 
 25 
 26 }
 27 
 28 
 29 //===============================================================================
 30 //  Main
 31 //===============================================================================
 32 void loop() 
 33 {
 34   
 35   Response_size = onezero(Response, 0x903D, 0x0003, arry, LOW);
 36     if(Response_size==0) Serial.println("Received Error from 0x01");
 37 
 38   Serial.print("Size is  : ");
 39   Serial.println(Response_size);
 40 
 41   Serial.print("Response string is : ");
 42   for(byte i=0;i<Response_size;i++)
 43   {
 44     Serial.print("0x");
 45     if(Response[i]<16) Serial.print("0");
 46     Serial.print(Response[i],HEX);
 47     Serial.print(" ");
 48   }
 49   Serial.println();
 50 
 51   while(1)
 52   {}
 53 }
 54 
 55 byte zeroone(byte rs[],int start, int num)
 56 {
 57   byte rq[8];  //Always 8 bytes
 58   //int addr;
 59   //int len;
 60   short c; //CRC value
 61   byte i, j,sz;  //Counters, size
 62 
 63   if(num==0 || num>0x7d0)
 64   {
 65     Serial.println("Illegal quantity of inputs");
 66     return 0;  
 67   }
 68 
 69   
 70   rq[0]=DEVICE; //Global device IO
 71   rq[1]=0x01;
 72   rq[3]=byte(start&0x00FF);
 73   rq[2]=byte((start&0xFF00)>>8);
 74   rq[5]=byte(num&0x00FF);
 75   rq[4]=byte((num&0xFF00)>>8);
 76 
 77   c = CRC16(rq,6);
 78   rq[7]=0x00FF & c;
 79   rq[6]=c>>8;
 80 
 81   for(i=0;i<8;i++)
 82   {
 83     Serial1.write(rq[i]);
 84   }
 85   sz = 5+rq[5];
 86   //if((rq[5]%8)!=0 && rq[5]>8) sz++;  //Refer to *N at top of Page 12
 87   if(sz>BUFS)
 88   {
 89     Serial.println("Buffer overflow prevented in 0x01.  Recompile with BUFS to a higher value");
 90     return 0;
 91   }
 92   for(i=0;i<sz;)
 93   {
 94     if (Serial1.available())            //Data from the Slave is available
 95     {
 96       rs[i]=Serial1.read();
 97       if(i==1 && rs[i]==0x83) sz=5;
 98       i++;
 99     }
100    
101   }
102   c=CRC16(rs,sz-2);
103   if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
104   {
105     Serial.println("CRC error in 0x01");
106     return 0;
107   }
108 
109   return sz;
110 }
111 
112 
113 byte zerotwo(byte rs[], int start, int num)
114 {
115   byte rq[8];  //Always 8 bytes
116   //int addr;
117   //int len;
118   short c; //CRC value
119   byte i, j,sz;  //Counters, size
120   
121   rq[0]=DEVICE; //Global device IO
122   rq[1]=0x02;
123   rq[3]=byte(start&0x00FF);
124   rq[2]=byte((start&0xFF00)>>8);
125   rq[5]=byte(num&0x00FF);
126   rq[4]=byte((num&0xFF00)>>8);
127 
128   c = CRC16(rq,6);
129   rq[7]=0x00FF & c;
130   rq[6]=c>>8;
131 
132   for(i=0;i<8;i++)
133   {
134     Serial1.write(rq[i]);
135   }
136   sz = 5+rq[5];
137   if(sz>BUFS)
138   {
139     Serial.println("Buffer overflow prevented in 0x02.  Recompile with BUFS to a higher value");
140     return 0;
141   }
142   for(i=0;i<sz;)
143   {
144     
145     if (Serial1.available())            //Data from the Slave is available
146     {
147       rs[i]=Serial1.read();
148       i++;
149     }
150   }
151   c=CRC16(rs,sz-2);
152   if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
153   {
154     Serial.println("CRC error in 0x02");
155     return 0;
156   }
157   return sz;
158 }
159 
160 byte zerothree(byte rs[],int start, int num)
161 {
162   byte rq[8];  //Always 8 bytes
163   //int addr;
164   //int len;
165   short c; //CRC value
166   byte i, j,sz;  //Counters, size
167 
168   if(num==0 || num>0x7d)
169   {
170     Serial.println("Illegal quantity of inputs");
171     return 0;  
172   }
173 
174   
175   rq[0]=DEVICE; //Global device IO
176   rq[1]=0x03;
177   rq[3]=byte(start&0x00FF);
178   rq[2]=byte((start&0xFF00)>>8);
179   rq[5]=byte(num&0x00FF);
180   rq[4]=byte((num&0xFF00)>>8);
181 
182   c = CRC16(rq,6);
183   rq[7]=0x00FF & c;
184   rq[6]=c>>8;
185 
186   for(i=0;i<8;i++)
187   {
188     Serial1.write(rq[i]);
189   }
190   sz = 5+rq[5]*2;
191   if(sz>BUFS)
192   {
193     Serial.println("Buffer overflow prevented in 0x03.  Recompile with BUFS to a higher value");
194     return 0;
195   }
196   for(i=0;i<sz;)
197   {
198     if (Serial1.available())            //Data from the Slave is available
199     {
200       rs[i]=Serial1.read();
201       if(i==1 && rs[i]==0x83) sz=5;
202       i++;
203     }
204    
205   }
206   c=CRC16(rs,sz-2);
207   if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
208   {
209     Serial.println("CRC error in 0x03");
210     return 0;
211   }
212 
213   return sz;
214 }
215 
216 
217 
218 //Assigns rs[] array, returns size or zero for CRC error
219 //This does NOT detect broadcast CRC errors, or any exception
220 //handling at all
221 //
222 //     rs : Response[] array
223 //  start : Starting address
224 //    num : Number of registers requested
225 byte zerofour(byte rs[],int start, int num)
226 {
227   byte rq[8];  //Always 8 bytes
228   //int addr;
229   //int len;
230   short c; //CRC value
231   byte i, j,sz;  //Counters, size
232   
233   rq[0]=DEVICE; //Global device IO
234   rq[1]=0x04;
235   rq[3]=byte(start&0x00FF);
236   rq[2]=byte((start&0xFF00)>>8);
237   rq[5]=byte(num&0x00FF);
238   rq[4]=byte((num&0xFF00)>>8);
239 
240   c = CRC16(rq,6);
241   rq[7]=0x00FF & c;
242   rq[6]=c>>8;
243 
244   for(i=0;i<8;i++)
245   {
246     Serial1.write(rq[i]);
247   }
248   sz = 5+rq[5]*2;
249   if(sz>BUFS)
250   {
251     Serial.println("Buffer overflow prevented in 0x04.  Recompile with BUFS to a higher value");
252     return 0;
253   }
254   for(i=0;i<sz;)
255   {
256     
257     if (Serial1.available())            //Data from the Slave is available
258     {
259       rs[i]=Serial1.read();
260       i++;
261     }
262   }
263   c=CRC16(rs,sz-2);
264   if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
265   {
266     Serial.println("CRC error in 0x04");
267     return 0;
268   }
269 
270   return sz;
271 }
272 ///////////////
273 byte zerofive(byte rs[],int addr, bool set, bool confirmation)
274 {
275   byte rq[8];  //Always 8 bytes
276   //int addr;
277   //int len;
278   short c; //CRC value
279   byte i, j,sz;  //Counters, size
280 
281   
282   rq[0]=DEVICE; //Global device IO
283   rq[1]=0x05;
284   rq[3]=byte(addr&0x00FF);
285   rq[2]=byte((addr&0xFF00)>>8);
286   rq[4]=0x00;  
287   if(set) rq[5]=0xFF;
288   else rq[5]=0x00;
289 
290 
291   c = CRC16(rq,6);
292   rq[7]=0x00FF & c;
293   rq[6]=c>>8;
294   if(confirmation)
295   {
296     for(i=0;i<8;i++)
297     {
298       Serial1.write(rq[i]);
299     }
300   }
301   sz = 6;
302   if(sz>BUFS)
303   {
304     Serial.println("Buffer overflow prevented in 0x03.  Recompile with BUFS to a higher value");
305     return 0;
306   }
307   if(confirmation)
308   {
309     for(i=0;i<sz;)
310     {
311       if (Serial1.available())            //Data from the Slave is available
312       {
313         rs[i]=Serial1.read();
314         if(i==1 && rs[i]==0x83) sz=5;
315         i++;
316       }  
317     }
318   }
319   else
320   {
321     for(i=0;i<sz;)
322     {
323         rs[i]=rq[i];
324         i++;
325     }
326   }
327   c=CRC16(rs,sz-2);
328   if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
329   {
330     Serial.println("CRC error in 0x03");
331     return 0;
332   }
333 }
334 ///////////////
335 byte onezero(byte rs[],int start, int num, byte arr[], bool confirmation)
336 {
337   byte rq[132];  //Always 8 bytes
338   //int addr;
339   //int len;
340   short c; //CRC value
341   byte i, j,sz;  //Counters, size
342 
343   if(num==0 || num>0x7B)
344   {
345     Serial.println("Invalid number of registers being written in 0x10.");
346     return 0;
347   }
348   rq[0]=DEVICE; //Global device IO
349   rq[1]=0x10;
350   rq[3]=byte(start&0x00FF);
351   rq[2]=byte((start&0xFF00)>>8);
352   rq[5]=byte(num&0x00FF);
353   rq[4]=byte((num&0xFF00)>>8);
354   rq[6]=num<<1;
355 
356   for(int i=0;i<(num<<1);i++)
357   {
358     rq[7+i]=arr[i];
359   }
360 
361   c = CRC16(rq,7+(num<<1));
362   rq[8+(num<<1)]=0x00FF & c;
363   rq[7+(num<<1)]=c>>8;
364 
365   if(confirmation)
366   {
367     for(i=0;i<9+(num<<1);i++)
368     {
369       Serial1.write(rq[i]);
370     }
371   }
372   else
373   {
374     for(i=0;i<9+(num<<1);i++)
375     {
376       rs[i]=rq[i];
377     }
378   }
379   sz = 9+(num<<1);
380   if(sz>BUFS)
381   {
382     Serial.println("Buffer overflow prevented in 0x04.  Recompile with BUFS to a higher value");
383     return 0;
384   }
385   if(confirmation)
386   {
387     sz=8;
388     for(i=0;i<8;)//always 8
389     {
390     
391       if (Serial1.available())            //Data from the Slave is available
392       {
393         rs[i]=Serial1.read();
394         i++;
395       }
396     }
397     c=CRC16(rs,sz-2);
398     if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
399     {
400       Serial.println("CRC error in 0x04");
401       return 0;
402     }
403   }
404   return sz;
405 }
406 
407 
408 short CRC16(byte array[],byte s)
409 {
410   static const byte auchCRCHi[] = {
411         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
412         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
413         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
414         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
415         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
416         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
417         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
418         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
419         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
420         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
421         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
422         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
423         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
424         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
425         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
426         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
427         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
428         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
429         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
430         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
431         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
432         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
433         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
434         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
435         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
436         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
437         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
438         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
439         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
440         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
441         0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
442         0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40} ; 
443 
444   static const byte auchCRCLo[] = {
445         0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2,
446         0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04,
447         0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E,
448         0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8,
449         0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
450         0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC,
451         0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6,
452         0xD2, 0x12, 0x13, 0xD3, 0x11, 0xD1, 0xD0, 0x10,
453         0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32,
454         0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
455         0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE,
456         0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38,
457         0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA,
458         0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C,
459         0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
460         0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0,
461         0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62,
462         0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4,
463         0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE,
464         0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
465         0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA,
466         0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C,
467         0xB4, 0x74, 0x75, 0xB5, 0x77, 0xB7, 0xB6, 0x76,
468         0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0,
469         0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
470         0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54,
471         0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E,
472         0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98,
473         0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A,
474         0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
475         0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86,
476         0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, 0x40} ;
477 
478   byte uchCRCHi = 0xFF;
479   byte uchCRCLo = 0xFF;
480   byte uIndex;
481 
482   while(s--)
483   {
484     uIndex = uchCRCHi ^ *array++ ;
485     uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex] ;
486     uchCRCLo = auchCRCLo[uIndex] ;
487   }
488   return short(uchCRCHi << 8 | uchCRCLo);
489 }
Retrieved from "http://calebneedscollege.com/wiki/index.php?title=EPEVER_485&oldid=64"