c++ 通過網絡模塊Socket連接三菱PLC

一、頭文件

//--------------------------------------------------------------------------- 
#ifndef PLCEthernetH 
#define PLCEthernetH 
//--------------------------------------------------------------------------- 
#include <Classes.hpp> 
#include <dstring.h> 
#include <stdio.h> 
// #include <SysUtils.h> 
//--------------------------------------------------------------------------- 
class TPLCEthernet 
{ 
private: 
        char __fastcall hexadecimal(int); 
        char __fastcall Uhexadecimal(int); 
        String __fastcall decimal2hexadecimal(int);      
        String __fastcall decimal2hexadecimal_2(int);   ? 
        int __fastcall decimal(char); 
 
 
        String BinaryToHex(String inputstr); 
        String HexToBinary(String inputstr); 
        String Int16ToHex(int inputvalue); 
        String Int32ToHex(int inputvalue); 
        int HexToInt(String inputstr); 
protected: 
 
public: 
        bool issendcommand;   
        int channelnumber;  
        int BaseAddress; 
        int arrayindex1; 
        int *array1; 
        int *array2; 
 
        int returnvalue; 
 
        
        FILE *stream; 
 
	__fastcall TPLCEthernet(int pctoplc[], int plctopc[], int adress); 
	__fastcall ~TPLCEthernet(void); 
 
        String __fastcall ReadCommand(int address, int channelnumber); 
        String __fastcall WriteCommand(int address, int channelnumber); 
        int __fastcall getresponse(String); 
 
        int ReadIntData(int adress); 
        double ReadFloatData(int adress,int unit); 
        String WriteIntData(int inputvalue, int adress); 
        String WriteFloatData(double inputvalue, int adress,int unit); 
 
        int ReadIntCommand(int adress); 
        double ReadFloatCommand(int adress,int unit); 
   
}; 
//--------------------------------------------------------------------------- 
extern TPLCEthernet *pPLCEthernet;; 
#endif 

二、實現文件

//---------------------------------------------------------------------------   
    #pragma hdrstop          
    #include "PLCEthernet.h"   
    //---------------------------------------------------------------------------   
    #pragma package(smart_init)   
    #include <math.h>   
    TPLCEthernet *pPLCEthernet;   
    //---------------------------------------------------------------------------   
    __fastcall TPLCEthernet::TPLCEthernet(int pctoplc[], int plctopc[], int Address)   
    {   
     issendcommand = false;   
     BaseAddress = Address;   
     arrayindex1 = 0;   
     array1 = pctoplc;   
     array2 = plctopc;   
     returnvalue = 0;   
    }   
    //---------------------------------------------------------------------------   
    __fastcall TPLCEthernet::~TPLCEthernet(void)   
    {   
    }   
    //---------------------------------------------------------------------------   
    // decimal to hexadecimal   
    char __fastcall TPLCEthernet::hexadecimal(int value)   
    {   
        char hex_value;   
        switch (value)   
        {   
            case 1:   
                hex_value = '1';   
                break;   
            case 2:   
                hex_value = '2';   
                break;   
            case 3:   
                hex_value = '3';   
                break;   
            case 4:   
                hex_value = '4';   
                break;   
            case 5:   
                hex_value = '5';   
                break;   
            case 6:   
                hex_value = '6';   
                break;   
            case 7:   
                hex_value = '7';   
                break;   
            case 8:   
                hex_value = '8';   
                break;   
            case 9:   
                hex_value = '9';   
                break;   
            case 10:   
                hex_value = 'A';   
                break;   
            case 11:   
                hex_value = 'B';   
                break;   
            case 12:   
                hex_value = 'C';   
                break;   
            case 13:   
                hex_value = 'D';   
                break;   
            case 14:   
                hex_value = 'E';   
                break;   
            case 15:   
                hex_value = 'F';   
                break;   
            default :   
                hex_value = '0';   
                break;   
        }   
        return hex_value;   
    }   
       
    // decimal to hexadecimal   
    char __fastcall TPLCEthernet::Uhexadecimal(int value)   
    {   
        char hex_value;   
        switch (value)   
        {   
            case 1:   
                hex_value = '1';   
                break;   
            case 2:   
                hex_value = '2';   
                break;   
            case 3:   
                hex_value = '3';   
                break;   
            case 4:   
                hex_value = '4';   
                break;   
            case 5:   
                hex_value = '5';   
                break;   
            case 6:   
                hex_value = '6';   
                break;   
            case 7:   
                hex_value = '7';   
                break;   
            case 8:   
                hex_value = '8';   
                break;   
            case 9:   
                hex_value = '9';   
                break;   
            default :   
                hex_value = '0';   
                break;   
        }   
        return hex_value;   
    }   
    //---------------------------------------------------------------------------   
    String __fastcall TPLCEthernet::decimal2hexadecimal(int value)   
    {   
        int first = value/4096;   
        int fourth = value%4096;   
        int second = fourth/256;   
        fourth = fourth%256;   
        int third = fourth/16;   
        fourth = fourth%16;   
        String hex_value = hexadecimal(first);   
        hex_value = hex_value + hexadecimal(second);   
        hex_value = hex_value + hexadecimal(third);   
        hex_value = hex_value + hexadecimal(fourth);   
        return hex_value;   
    }   
    //---------------------------------------------------------------------------   
    String __fastcall TPLCEthernet::decimal2hexadecimal_2(int value)   
    {   
        int first = value/1000000;        // 16     256    4096   65536       1048576   
        int sixth = value%1000000;   
        int second = sixth/10000;   
        sixth = sixth%10000;   
        int third = sixth/1000;   
        sixth = sixth%1000;   
        int fourth = sixth/100;   
        sixth = sixth%100;   
        int fifth = sixth/10;   
        sixth = sixth%10;   
       
        String hex_value = hexadecimal(first);   
        hex_value = hex_value + Uhexadecimal(second);   
        hex_value = hex_value + Uhexadecimal(third);   
        hex_value = hex_value + Uhexadecimal(fourth);   
        hex_value = hex_value + Uhexadecimal(fifth);   
        hex_value = hex_value + Uhexadecimal(sixth);   
        return hex_value;   
        /*  
        int first = value/1048576;        // 16     256    4096   65536       1048576  
        int sixth = value%1048576;  
        int second = sixth/65536;  
        sixth = sixth%65536;  
        int third = sixth/4096;  
        sixth = sixth%4096;  
        int fourth = sixth/256;  
        sixth = sixth%256;  
        int fifth = sixth/16;  
        sixth = sixth%16;  
      
        String hex_value = hexadecimal(first);  
        hex_value = hex_value + hexadecimal(second);  
        hex_value = hex_value + hexadecimal(third);  
        hex_value = hex_value + hexadecimal(fourth);  
        hex_value = hex_value + hexadecimal(fifth);  
        hex_value = hex_value + hexadecimal(sixth);  
        return hex_value;  
        */   
    }   
    //---------------------------------------------------------------------------   
    // hexadecimal to decimal   
    int __fastcall TPLCEthernet::decimal(char value)   
    {   
        int decimal_value;   
        switch (value)   
        {   
            case '1':   
                decimal_value = 1;   
                break;   
            case '2':   
                decimal_value = 2;   
                break;   
            case '3':   
                decimal_value = 3;   
                break;   
            case '4':   
                decimal_value = 4;   
                break;   
            case '5':   
                decimal_value = 5;   
                break;   
            case '6':   
                decimal_value = 6;   
                break;   
            case '7':   
                decimal_value = 7;   
                break;   
            case '8':   
                decimal_value = 8;   
                break;   
            case '9':   
                decimal_value = 9;   
                break;   
            case 'A':   
                decimal_value = 10;   
                break;   
            case 'B':   
                decimal_value = 11;   
                break;   
            case 'C':   
                decimal_value = 12;   
                break;   
            case 'D':   
                decimal_value = 13;   
                break;   
            case 'E':   
                decimal_value = 14;   
                break;   
            case 'F':   
                decimal_value = 15;   
                break;   
            default :   
                decimal_value = 0;   
                break;   
        }   
        return decimal_value;   
    }   
    //---------------------------------------------------------------------------   
    String __fastcall TPLCEthernet::ReadCommand(int address, int channelnumber)   
    {   
        int i;   
        String command;   
       
        command = "500000FF03FF000018000004010000D*" + decimal2hexadecimal_2(BaseAddress+address) + decimal2hexadecimal(channelnumber);   
       
        issendcommand = true;   
        arrayindex1 = address;   
       
        return command;   
    }   
    //---------------------------------------------------------------------------   
    String __fastcall TPLCEthernet::WriteCommand(int address, int channelnumber)   
    {   
        int i;   
        String command;   
        int charnumber = channelnumber*4 + 24;   
       
        command = "500000FF03FF00" + decimal2hexadecimal(charnumber) + "000014010000D*" + decimal2hexadecimal_2(BaseAddress+address) + decimal2hexadecimal(channelnumber);   
        for (i=0 ; i<(channelnumber) ; i++)   
            command += Int16ToHex(array1[address+i]);   
       
        issendcommand = true;   
       
        return command;   
    }   
    //---------------------------------------------------------------------------   
    int __fastcall TPLCEthernet::getresponse(String receive)   
    {   
       
        int i;   
        int Responsenumber = receive.Length();   
        int responsevalue=0, count=0;   
        String Response = "";   
        String substr = "";   
       
        returnvalue = returnvalue*10;   
        int returnvalue1;   
       
        // ?a¨ú|^??-è   
        if (receive[1]=='6' && receive[2]=='0' && receive[3]=='0' && receive[4]=='0')   
        {   
            if (((Responsenumber-8)/4)<10)   
            {   
                returnvalue1 = returnvalue+5;   
                returnvalue = 0;   
                return returnvalue1;   
            }   
            for (i=9; i=Responsenumber ; i+=4)   
            {   
                responsevalue = HexToInt((String)receive[i]+(String)receive[i+1]+(String)receive[i+2]+(String)receive[i+3]);   
                array2[count] = responsevalue;   
                if (Response=="")   
                    Response = IntToStr(responsevalue);   
                else   
                    Response = Response + "," +IntToStr(responsevalue);   
                count++;   
                if (count==10)   
                {   
                    returnvalue = returnvalue+1;   
                    break;   
                }   
            }   
            if (Responsenumber>48)   
            {   
                for (i=49 ; i=Responsenumber ; i++)   
                    substr += (String)receive[i];   
                if (substr[1]=='6' && substr[2]=='0' && substr[3]=='0' && substr[4]=='0')   
                    issendcommand = false;   
                else   
                    issendcommand = true;   
                returnvalue = getresponse(substr);   
            }   
            returnvalue1 = returnvalue;   
            returnvalue = 0;   
            return returnvalue1;   
        } else {   
            issendcommand = false;   
       
            String completecode = "";   
            // §P?_|^???X?O§_￥??T   
            for (i=19; i=22; i++)   
                completecode += receive[i];   
            // ??¤J?X?ù?~?é   
            if (Responsenumber<22)   
            {   
                returnvalue1 = returnvalue + 2;   
                returnvalue = 0;   
                return returnvalue1;   
            }   
       
            // à??ddata length   
            int datalength = 0;   
            datalength = decimal(receive[15])*4096 + decimal(receive[16])*256 + decimal(receive[17])*16 + decimal(receive[18]);   
       
            // ??1L?ù?~?X   
            if ((completecode!="0000"))   
            {   
                if ((datalength+18)==Responsenumber)   
                {   
                    returnvalue1 = returnvalue + 2;   
                    returnvalue = 0;   
                    return returnvalue1;   
                } else {   
                    // ·ídata length?P|r|êa??פ￡¤@???é   
                    for (i=(datalength+18) ; i=Responsenumber ; i++)   
                        substr += (String)receive[i];   
                    if (substr[1]=='6' && substr[2]=='0' && substr[3]=='0' && substr[4]=='0')   
                        issendcommand = false;   
                    else   
                        issendcommand = true;   
                    returnvalue = getresponse(substr);   
                }   
                returnvalue1 = returnvalue;   
                returnvalue = 0;   
                return returnvalue1;   
            }   
       
            // ??¤J?g¤J?X￥??T?é   
            if (datalength==4)   
            {   
                returnvalue = returnvalue+3;   
                if (Responsenumber==22)   
                {   
                    returnvalue1 = returnvalue;   
                    returnvalue = 0;   
                    return returnvalue1;   
                } else {   
                // ·ídata length?P|r|êa??פ￡¤@???é   
                    for (i=23 ; i=Responsenumber ; i++)   
                        substr += (String)receive[i];   
                    if (substr[1]=='6' && substr[2]=='0' && substr[3]=='0' && substr[4]=='0')   
                        issendcommand = false;   
                    else   
                        issendcommand = true;   
                    returnvalue = getresponse(substr);   
                }   
                returnvalue1 = returnvalue;   
                returnvalue = 0;   
                return returnvalue1;   
            }   
       
            // ?a¨ú|^??-è   
            substr = "";   
            datalength = datalength + 18;   
            for (i=23; i=datalength ; i+=4)   
            {   
                responsevalue = HexToInt((String)receive[i]+(String)receive[i+1]+(String)receive[i+2]+(String)receive[i+3]);   
                array1[arrayindex1] = responsevalue;   
                if (Response=="")   
                    Response = IntToStr(responsevalue);   
                else   
                    Response = Response + "," +IntToStr(responsevalue);   
                arrayindex1++;   
            }   
       
            if (Responsenumber==datalength)   
            {   
                returnvalue1 = returnvalue+4;   
                returnvalue = 0;   
                return returnvalue1;   
            } else {   
                // ·ídata length?P|r|êa??פ￡¤@???é   
                for (i=(datalength+1) ; i=Responsenumber ; i++)   
                    substr += (String)receive[i];   
                if (substr[1]=='6' && substr[2]=='0' && substr[3]=='0' && substr[4]=='0')   
                    issendcommand = false;   
                else   
                    issendcommand = true;   
                returnvalue = returnvalue+4;   
                returnvalue = getresponse(substr);   
            }   
            returnvalue1 = returnvalue;   
            returnvalue = 0;   
            return returnvalue1;   
        }   
    }   
    //---------------------------------------------------------------------------   
    String TPLCEthernet::BinaryToHex(String inputstr)   
    {   
        int length = inputstr.Length();   
        int value = 0;   
        char c;   
        String outputstr="";   
       
        for (int i=1 ; i=length ; i+=4)   
        {   
            value = 0;   
            if (inputstr[i+3]=='1')   
                value = 1;   
            if (inputstr[i+2]=='1')   
                value += 2;   
            if (inputstr[i+1]=='1')   
                value += 4;   
            if (inputstr[i]=='1')   
                value += 8;   
            c = hexadecimal(value);   
            outputstr += c;   
        }   
        /*  
        for (int i=length ; i>=1 ; i-=8)  
        {  
            value = 0;  
            if (inputstr[i-4]=='1')  
                value = 1;  
            if (inputstr[i-5]=='1')  
                value += 2;  
            if (inputstr[i-6]=='1')  
                value += 4;  
            if (inputstr[i-7]=='1')  
                value += 8;  
            c = hexadecimal(value);  
            outputstr += c;  
      
            value = 0;  
            if (inputstr[i]=='1')  
                value = 1;  
            if (inputstr[i-1]=='1')  
                value += 2;  
            if (inputstr[i-2]=='1')  
                value += 4;  
            if (inputstr[i-3]=='1')  
                value += 8;  
            c = hexadecimal(value);  
            outputstr += c;  
        }  
        */   
        return outputstr;   
    }   
    //---------------------------------------------------------------------------   
    String TPLCEthernet::HexToBinary(String inputstr)   
    {   
        int value, valuetemp;   
        int length = inputstr.Length();   
        String outputstr="", strtemp1="";   
        /*  
        outputstr = inputstr;  
        for (int i=1 ; i=length ; i+=2)  
        {  
            outputstr[i] = inputstr[length-i];  
            outputstr[i+1] = inputstr[length-i+1];  
        }  
        inputstr = outputstr;  
        */   
        for (int i=1 ; i=length ; i++)   
        {   
            value = decimal(inputstr[i]);   
            valuetemp = value/8;   
            value = value%8;   
            if (valuetemp==1)   
                strtemp1 += "1";   
            else   
                strtemp1 += "0";   
            valuetemp = value/4;   
            value = value%4;   
            if (valuetemp==1)   
                strtemp1 += "1";   
            else   
                strtemp1 += "0";   
            valuetemp = value/2;   
            value = value%2;   
            if (valuetemp==1)   
                strtemp1 += "1";   
            else   
                strtemp1 += "0";   
            if (value==1)   
                strtemp1 += "1";   
            else   
                strtemp1 += "0";   
        }   
        return strtemp1;   
    }   
    //---------------------------------------------------------------------------   
    String TPLCEthernet::Int16ToHex(int inputvalue)   
    {   
        int valuetemp1;   
        int valuetemp2;   
        String outputstr="";   
       
        if (inputvalue<0)   
            valuetemp1 = abs(inputvalue + 1);   
        else   
            valuetemp1 = inputvalue;   
       
        for (int i=1 ; i=16 ; i++)   
        {   
            valuetemp2 = valuetemp1%2;   
            valuetemp1 = valuetemp1/2;   
            if (valuetemp2==1)   
                outputstr = "1" + outputstr;   
            else   
                outputstr = "0" + outputstr;   
        }   
        if (inputvalue<0)   
        {   
            for (int i=1 ; i=outputstr.Length() ; i++)   
            {   
                if (outputstr[i]=='1')   
                    outputstr[i] = '0';   
                else   
                    outputstr[i] = '1';   
            }   
        }   
        outputstr = BinaryToHex(outputstr);   
        return outputstr;   
    }   
    String TPLCEthernet::Int32ToHex(int inputvalue)   
    {   
        int valuetemp1;   
        int valuetemp2;   
        String outputstr="";   
       
        if (inputvalue<0)   
            valuetemp1 = abs(inputvalue + 1);   
        else   
            valuetemp1 = inputvalue;   
       
        for (int i=1 ; i=32 ; i++)   
        {   
            valuetemp2 = valuetemp1%2;   
            valuetemp1 = valuetemp1/2;   
            if (valuetemp2==1)   
                outputstr = "1" + outputstr;   
            else   
                outputstr = "0" + outputstr;   
        }   
        if (inputvalue<0)   
        {   
            for (int i=1 ; i=outputstr.Length() ; i++)   
            {   
                if (outputstr[i]=='1')   
                    outputstr[i] = '0';   
                else   
                    outputstr[i] = '1';   
            }   
        }   
        outputstr = BinaryToHex(outputstr);   
        return outputstr;   
    }   
    //---------------------------------------------------------------------------   
    int TPLCEthernet::HexToInt(String inputstr)   
    {   
        String outputstr = HexToBinary(inputstr);   
        int lenght = outputstr.Length();   
        int m = 2;   
        int e = 0;   
        int output = 0;   
        if (outputstr[1]=='1')   
        {   
            for (int i=lenght ; i>=1 ; i--)   
            {   
                if (outputstr[i]=='0')   
                    output += pow(m, e);   
                e++;   
            }   
            output = (output+1)*(-1);   
        } else {   
            for (int i=lenght ; i>=1 ; i--)   
            {   
                if (outputstr[i]=='1')   
                    output += pow(m, e);   
                e++;   
            }   
        }   
        return output;   
    }   
    //---------------------------------------------------------------------------   
    int TPLCEthernet::ReadIntData(int adress)   
    {   
        // array1   
        return array1[adress];   
    }   
       
    double TPLCEthernet::ReadFloatData(int adress,int unit)   
    {   
        String str1 = Int16ToHex(array1[adress+1]);   
        str1 += Int16ToHex(array1[adress]);   
        int value1 = HexToInt(str1);   
        double result = (double)value1/(double)unit;   
       
        return result;   
    }   
       
    String TPLCEthernet::WriteIntData(int inputvalue, int adress)   
    {   
        array1[adress] = inputvalue;   
        return "OK";   
    }   
       
    String TPLCEthernet::WriteFloatData(double inputvalue, int adress,int unit)   
    {   
        int value1 = (int)(inputvalue*unit);   
        String str1 = Int32ToHex(value1);   
        String str2="", str3="";   
        for (int i=1 ; i=4 ; i++)   
        {   
            str2 += str1[i];   
            str3 += str1[i+4];   
        }   
        int value2 = HexToInt(str2);   
        int value3 = HexToInt(str3);   
        array1[adress+1] = value2;   
        array1[adress] = value3;   
        return "OK";   
    }   
       
    int TPLCEthernet::ReadIntCommand(int adress)   
    {   
        // array1   
        return array2[adress];   
    }   
       
    double TPLCEthernet::ReadFloatCommand(int adress,int unit)   
    {   
        String str1 = Int16ToHex(array2[adress+1]);   
        str1 += Int16ToHex(array2[adress]);   
        int value1 = HexToInt(str1);   
        double result = (double)value1/(double)unit;   
       
        return result;   
    }