Enviar un valor booleano a un PLC desde Android

Pude hacer 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, tengo que enviar dos valores al PLC: un valor int y un valor booleano. Tengo 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 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 esta pregunta, 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

Hice la conexión con un PLC Modicon M340, y para la conexión uso 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, llamo el siguiente código todo el tiempo. Logré solo lectura y escritura int, String y valores de flotador a través de palabras que leo desde un offset 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 logré lo que quería. Hay 4 clases que utilizo para leer las bobinas:

ReadCoilsRequest ReadCoilsResponse WriteMultipleCoilsRequest WriteMultileCoilsResponse

Lo que hice fue 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"); } } 

Además, hice un método para leer variables 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 está utilizando una función nativa de la clase BitVector desde el 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 abrir un cierre de la conexión al PLC.

Mi respuesta definitiva es: hay que tratar los registros como bits. Así que si quieres escribir el segundo bit de un registro representado en un valor int en tu código, tendrás 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 que quiero escribir en mi PLC.

FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.