EPEVER 485 - Revision history

Falgsc-al at 06:05, 19 November 2020

2020-11-19T06:05:40Z

Legg: /* Code */

2020-11-19T04:36:14Z

Code

Show changes

Legg: /* Code */

2020-11-19T04:00:52Z

Code

Show changes

Legg: /* Code */

2020-11-18T00:22:52Z

Code

Legg: /* Code */ comments

2020-11-18T00:17:42Z

Code: comments

Legg: /* Code */

2020-11-17T19:31:05Z

Code

Legg at 03:57, 17 November 2020

2020-11-17T03:57:40Z

Legg at 03:37, 17 November 2020

2020-11-17T03:37:33Z

Show changes

Legg: /* Code */

2020-11-16T23:53:21Z

Code

Legg: Created page with "==Synopsis== Issues 485 request and display result ==Notes== ==Code== //#include //const int SSERIAL_RX_PIN = 10;..."

2020-11-16T22:14:01Z

Created page with "==Synopsis== Issues 485 request and display result ==Notes== ==Code== <syntaxhighlight lang="C++" line='line'> //#include <SoftwareSerial.h> //const int SSERIAL_RX_PIN = 10;..."

New page

==Synopsis==
Issues 485 request and display result
==Notes==

==Code==
<syntaxhighlight lang="C++" line='line'>

//#include <SoftwareSerial.h>
//const int SSERIAL_RX_PIN = 10; //Soft Serial Receive pin
//const int SSERIAL_TX_PIN = 11; //Soft Serial Transmit pin

// Create Soft Serial Port object and define pins to use
//SoftwareSerial RS485Serial(SSERIAL_RX_PIN, SSERIAL_TX_PIN); // RX, TX

#define DEVICE 0x01
#define BUFS 64 //Buffer size
short crc;
byte Response[BUFS];
byte Response_size;

//===============================================================================
// Initialization
//===============================================================================
void setup()
{
Serial.begin(115200); // Start the built-in serial port
Serial1.begin(115200); // Start the RS485 soft serial port
delay(1000);
Serial.println();

Response_size = zerofour(Response, 0x3302, 0x0012);
if(Response_size==0) Serial.println("Received Error from 0x04");

//Print result
for(byte i=0;i<Response_size;i++)
{
Serial.print("0x");
Serial.print(Response[i],HEX);
Serial.print(" ");
}
Serial.println();
}

//===============================================================================
// Main
//===============================================================================
void loop()
{

}

//Assigns rs[] array, returns size or zero for CRC error
//This does NOT detect broadcast CRC errors, or any exception
//handling at all
//
// rs : Response[] array
// start : Starting address
// num : Number of registers requested
byte zerofour(byte rs[],int start, int num)
{
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]=0x04;
rq[3]=byte(start&0x00FF);
rq[2]=byte((start&0xFF00)>>8);
rq[5]=byte(num&0x00FF);
rq[4]=byte((num&0xFF00)>>8);

c = CRC16(rq,6);
rq[7]=0x00FF & c;
rq[6]=c>>8;

for(i=0;i<8;i++)
{
Serial1.write(rq[i]);
}
sz = 5+rq[5]*2;
if(sz>BUFS)
{
Serial.println("Buffer overflow prevented in 0x04. Recompile with BUFS to a higher value");
return 0;
}
for(i=0;i<sz;)
{

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)
{
static const byte auchCRCHi[] = {
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40} ;

static const byte auchCRCLo[] = {
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2,
0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04,
0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E,
0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8,
0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC,
0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6,
0xD2, 0x12, 0x13, 0xD3, 0x11, 0xD1, 0xD0, 0x10,
0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32,
0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE,
0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38,
0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA,
0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C,
0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0,
0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62,
0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4,
0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE,
0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA,
0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C,
0xB4, 0x74, 0x75, 0xB5, 0x77, 0xB7, 0xB6, 0x76,
0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0,
0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54,
0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E,
0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98,
0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A,
0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86,
0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, 0x40} ;

byte uchCRCHi = 0xFF;
byte uchCRCLo = 0xFF;
byte uIndex;

while(s--)
{
uIndex = uchCRCHi ^ *array++ ;
uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex] ;
uchCRCLo = auchCRCLo[uIndex] ;
}
return short(uchCRCHi << 8 | uchCRCLo);
}
</syntaxhighlight>

@@ Line 287: / Line 287: @@
    delay(1000);
    Serial.println();
-−
-//===============================================================================
+   Response_size=zeroone(Response,0x0002,0x0001 ); //number must be [1-0x07d0]
-   Serial.print("Size is  : ");
+   Serial.print("Size  Redad Respponse  is  : ");
    Serial.println(Response_size);
-   Serial.print("Response string is : ");
+   Serial.print("Response Read Response string is : ");
    for(byte i=0;i<Response_size;i++)
+   {
@@ Line 310: / Line 303: @@
+   }
    Serial.println();
-   while(1)
+    Serial.print("Response string is : ");
-  {}
+    for(byte i=0;i<Response_size;i++)
+}
 // Read coils zeroone - Read up to 2000 coils in a call.
@@ Line 607: / Line 651: @@
    rq[3]=byte(addr&0x00FF);
    rq[2]=byte((addr&0xFF00)>>8);
-   rq[4]=0x00;  //Always zero
+   rq[5]=0x00;  //Always zero
-   if(set) rq[5]=0xFF;
+   if(set) rq[4]=0xFF;
-   else rq[5]=0x00;
+   else rq[4]=0x00;
@@ Line 621: / Line 665: @@
      Serial1.write(rq[i]);
+   }
+   sz = 8;  //Always 8 for this function
    if(sz>BUFS)
+   {
@@ Line 639: / Line 682: @@
+     }
+   }
    if (rs[1]==0x83)
+   {

@@ Line 539: / Line 539: @@
+}
 ///////////////
 byte zerofive(byte rs[],int addr, bool set, bool confirmation)
+{

@@ Line 296: / Line 296: @@
 void loop()
+{
+   int start_register = 0x903D //binary value of register starting location
-   Response_size = onezero(Response, 0x903D, 0x0003, arry, LOW);
+  int num_registers = 0x0003  //Number of registers, only 16-bit for consistency
      if(Response_size==0) Serial.println("Received Error from 0x01");
@@ Line 599: / Line 603: @@
 byte onezero(byte rs[],int start, int num, byte arr[], bool confirmation)
+{
-   byte rq[132];  //Always 8 bytes
+   byte rq[132];  //This is the size of the maximum possible buffer
    short c; //CRC value
    byte i, j,sz;  //Counters, size
@@ Line 615: / Line 617: @@
    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++)
+   {
@@ Line 623: / Line 629: @@
+   }
    c = CRC16(rq,7+(num<<1));
-   rq[8+(num<<1)]=0x00FF & c;
+  //copies the CRC 16 bits into two bytes in the array using bit masking
-   rq[7+(num<<1)]=c>>8;
+  //High byte is stored into [8+2*num]
-   if(confirmation)
+   if(confirmation)  //If true, issue the command
+   {
      for(i=0;i<9+(num<<1);i++)
@@ Line 634: / Line 644: @@
+     }
+   }
-   else
+   else  //else do nothing but give the coder access to the Request.
+   {
      for(i=0;i<9+(num<<1);i++)
+     {
-       rs[i]=rq[i];
+       rs[i]=rq[i];  //Request is copied into Response
+     }
+   }
-   sz = 9+(num<<1);
+   sz = 9+(num<<1);  //Size of the Request
    if(sz>BUFS)
+   {
@@ Line 647: / Line 657: @@
      return 0;
+   }
-   if(confirmation)
+   if(confirmation)  //We are writing to the device
+   {
-     sz=8;
+     sz=8;  //The Response of 0x10 is always 8 bytes (64 bits long)
-     for(i=0;i<8;)//always 8
+     for(i=0;i<sz;)  //always 8
+     {
@@ Line 659: / Line 669: @@
+       }
+     }
-     c=CRC16(rs,sz-2);
+    //Test the CRC values of response on the buffer (sparing the given CRC codes)
-     if(c!=short((rs[sz-2]<<8 | rs[sz-1])))
+     c=CRC16(rs,sz-2);  //Test everything except last two bytes.
+     {
        Serial.println("CRC error in 0x04");

@@ Line 273: / Line 273: @@
 #define BUFS 64   //Buffer size
 short crc;
 byte Response[BUFS];
 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");
-   Serial.print("Size is ");
+   Serial.print("Size is  : ");
    Serial.println(Response_size);
-−
    for(byte i=0;i<Response_size;i++)
+   {
@@ Line 309: / Line 311: @@
      Serial.print(" ");
+   }
    Serial.println();
@@ Line 545: / Line 534: @@
    return sz;
+}
 short CRC16(byte array[],byte s)

@@ Line 295: / Line 295: @@
 void loop()
+{
-if(countdown>0)
+   Serial.print("Size is ");
+  Serial.println(Response_size);
-   Response_size = zerofour(Response, 0x3302, 0x0012);
    for(byte i=0;i<Response_size;i++)
+   {
      Serial.print("0x");
      Serial.print(Response[i],HEX);
      Serial.print(" ");
+   }
-   Serial.println("Finished 0x04");
+/*
-   Response_size = zerotwo(Response, 0x2000, 0x0001);
+   rq[0]=DEVICE; //Global device IO
-   if(Response_size==0) Serial.println("Received Error from 0x04");
+  rq[1]=0x01;
+  rq[3]=byte(start&0x00FF);
-   //Print result
+  rq[2]=byte((start&0xFF00)>>8);
-   for(byte i=0;i<Response_size;i++)
+  rq[5]=byte(num&0x00FF);
+   {
-     Serial.print("0x");
+     Serial.println("CRC error in 0x01");
-     Serial.print(Response[i],HEX);
+     return 0;
+   }
-  Serial.println();
-  delay(1000);
+   return sz;
+}
 byte zerotwo(byte rs[], int start, int num)
@@ Line 374: / Line 432: @@
    return sz;
+}
 //Assigns rs[] array, returns size or zero for CRC error

@@ Line 5: / Line 5: @@
 ==Code==
 <syntaxhighlight lang="C++" line='line'>
 //#include <SoftwareSerial.h>
 //const int SSERIAL_RX_PIN = 10;  //Soft Serial Receive pin
@@ Line 18: / Line 17: @@
 byte Response[BUFS];
 byte Response_size;
+byte countdown = 2;
 //===============================================================================
 //  Initialization
@@ Line 29: / Line 28: @@
    Serial.println();
    Response_size = zerofour(Response, 0x3302, 0x0012);
      if(Response_size==0) Serial.println("Received Error from 0x04");
    //Print result
    for(byte i=0;i<Response_size;i++)
@@ Line 40: / Line 65: @@
+   }
    Serial.println();
+}
-//===============================================================================
+  c = CRC16(rq,6);
-//  Main
+  rq[7]=0x00FF & c;
-//===============================================================================
+  rq[6]=c>>8;
+}