Enviar un valor booleano a un PLC desde Android

Question

Pude establecer una conexión con un PLC para leer datos de él. Ahora hay un problema y es que tengo que escribir un método para modificar los datos del PLC. Para lograr esto, debo enviar dos valores al PLC: un valor int y un valor booleano. Obtuve el valor int resuelto a través de las clases del paquete net.wimpi.modbus. Pero cuando se trata del valor booleano no tengo idea de qué hacer.

Si alguien tuviera el mismo problema que yo tengo ahora, ¿podría enviarme una referencia donde pueda encontrar una solución o un enlace de un buen tutorial para resolver mi problema? Alguien publicó un par de enlaces en this question pero me envía a tutoriales que no tienen mucho que ver con la comunicación con los PLC y cómo tratar los datos del PLC.

EDITAR

que realiza la conexión con un PLC Modicon M340, y por la conexión que utilice las clases del paquete net.wimpi.modbus. Hice la conexión en mi código a través de las clases ModbusTCPTransaction y TCPMasterConnection, y leí los valores a través de las clases ReadMultipleRegistersRequest y ReadMultipleRegistersResponse.

El código que hice para la conexión:

private InetAddress m_Address; 
private ModbusTCPTransaction m_Transaction = null; 
private TCPMasterConnection m_Connection = null; 

int port = Modbus.DEFAULT_PORT; 
private Activity activity; 


public ModbusConnection(Activity activity, String ip) 
{ 
    this.activity = activity; 

    try { 
     m_Address = InetAddress.getByName(ip); 
    } catch (UnknownHostException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } // the slave'saddress 
} 

public void getTransaction(InetAddress inet) throws Exception 
{ 
    /*Variables for the reading of the PLC data*/ 
    int port = Modbus.DEFAULT_PORT; 

    /*Data initialization for the reading of the PLC data*/ 
    m_Connection = new TCPMasterConnection(inet); 
    m_Connection.setPort(port); 
    m_Connection.connect(); 
    m_Transaction = new ModbusTCPTransaction(m_Connection); 
} 

Y para leer los valores, que llame a la siguiente código todo el tiempo. Hecho yo solamente leer y escribir int, String y flotar valores a través de las palabras que he leído de un desplazamiento declarado en el PLC:

private ReadMultipleRegistersResponse readValues(int offset, int count) 
{ 
    ReadMultipleRegistersRequest rReq = null; // the request 
    ReadMultipleRegistersResponse rRes = null; // the response 

    try { 

     rReq = new ReadMultipleRegistersRequest(offset, count); 
     m_Transaction.setRequest(rReq); 
     m_Transaction.execute(); 
     rRes = (ReadMultipleRegistersResponse) m_Transaction.getResponse(); 

    } catch (Exception e) { 
     e.printStackTrace(); 
     Log.i("AsyncTask", "doInBackground: Exception"); 
    } 
    return rRes;  
} 

EDIT 2

creo que he logrado lo que quería. Hay 4 clases que utilizo para leer las bobinas:

ReadCoilsRequest ReadCoilsResponse WriteMultipleCoilsRequest WriteMultileCoilsResponse

Lo que hice es dos métodos para leer y escribir bobinas en el PLC:

private ReadCoilsResponse readBytes(int offset, int count) 
{ 
    ReadCoilsRequest rReq = null; // the request 
    ReadCoilsResponse rRes = null; // the response 

    try { 

     rReq = new ReadCoilsRequest(offset, count); 
     m_Transaction.setRequest(rReq); 
     m_Transaction.execute(); 
     rRes = (ReadCoilsResponse) m_Transaction.getResponse(); 

    } catch (Exception e) { 
     e.printStackTrace(); 
     Log.i("AsyncTask", "doInBackground: Exception"); 
    } 
    return rRes;  
} 

    public void writeBytes(int wordNumber, BitVector b) { 
    try {    
     WriteMultipleCoilsRequest wReq = null; // 
     WriteMultipleCoilsResponse wRes = null; // 

     wReq = new WriteMultipleCoilsRequest(211, b); 
     m_Transaction.setRequest(wReq); 
     m_Transaction.execute();  
    } catch (Exception e) { 
     e.printStackTrace(); 
     Log.i("AsyncTask", "doInBackground: Exception"); 
    } 
} 

también , Hice un método para leer las variables de BitVector usando las clases de Bobinas:

public BitVector readBitVector(int offset, int count) 
{ 
    BitVector myBitVector; 

    ReadCoilsResponse rRes = readBytes(offset, count); 
    rRes = (ReadCoilsResponse) m_Transaction.getResponse(); 
    myBitVector = rRes.getCoils(); 

    return myBitVector; 
} 

Después de esto, lo que he utilizado para establecer el bit a 1 o 0 es el uso de una función nativa de la clase BitVector del paquete net.wimpi.modbus.util en mi código:

test.setBit(2, true); 

NOTA: Es importante recordar que cada vez que quiera leer o escribir valores en el plc, la mejor manera de hacerlo es abriendo una conexión al PLC.

Answer 1

Mi respuesta definitiva es: tienes que tratar los registros como bits. Así que si desea escribir el segundo bit de un registro representado en un valor entero en su código, tendrá que hacer algo como esto:

intValue = m_Data[1].getValue(); 
intValue = intValue | 2; 
m_Data[1].setValue(intValue); 

La segunda línea modifica el bit quiero escribir en mi PLC .