Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/* ***********************************************************
* This file was automatically generated on 2019-11-25. *
* *
* Java Bindings Version 2.1.25 *
* *
* If you have a bugfix for this file and want to commit it, *
* please fix the bug in the generator. You can find a link *
* to the generators git repository on tinkerforge.com *
*************************************************************/
package com.tinkerforge;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Two relays to switch AC/DC devices
*/
public class BrickletDualRelay extends Device {
public final static int DEVICE_IDENTIFIER = 26;
public final static String DEVICE_DISPLAY_NAME = "Dual Relay Bricklet";
public final static byte FUNCTION_SET_STATE = (byte)1;
public final static byte FUNCTION_GET_STATE = (byte)2;
public final static byte FUNCTION_SET_MONOFLOP = (byte)3;
public final static byte FUNCTION_GET_MONOFLOP = (byte)4;
public final static byte FUNCTION_SET_SELECTED_STATE = (byte)6;
public final static byte FUNCTION_GET_IDENTITY = (byte)255;
private final static int CALLBACK_MONOFLOP_DONE = 5;
private List listenerMonoflopDone = new CopyOnWriteArrayList();
public class State {
public boolean relay1;
public boolean relay2;
public String toString() {
return "[" + "relay1 = " + relay1 + ", " + "relay2 = " + relay2 + "]";
}
}
public class Monoflop {
public boolean state;
public long time;
public long timeRemaining;
public String toString() {
return "[" + "state = " + state + ", " + "time = " + time + ", " + "timeRemaining = " + timeRemaining + "]";
}
}
/**
* This listener is triggered whenever a monoflop timer reaches 0. The
* parameter contain the relay (1 or 2) and the current state of the relay
* (the state after the monoflop).
*/
public interface MonoflopDoneListener extends DeviceListener {
public void monoflopDone(short relay, boolean state);
}
/**
* Creates an object with the unique device ID \c uid. and adds it to
* the IP Connection \c ipcon.
*/
public BrickletDualRelay(String uid, IPConnection ipcon) {
super(uid, ipcon);
apiVersion[0] = 2;
apiVersion[1] = 0;
apiVersion[2] = 0;
responseExpected[IPConnection.unsignedByte(FUNCTION_SET_STATE)] = RESPONSE_EXPECTED_FLAG_FALSE;
responseExpected[IPConnection.unsignedByte(FUNCTION_GET_STATE)] = RESPONSE_EXPECTED_FLAG_ALWAYS_TRUE;
responseExpected[IPConnection.unsignedByte(FUNCTION_SET_MONOFLOP)] = RESPONSE_EXPECTED_FLAG_FALSE;
responseExpected[IPConnection.unsignedByte(FUNCTION_GET_MONOFLOP)] = RESPONSE_EXPECTED_FLAG_ALWAYS_TRUE;
responseExpected[IPConnection.unsignedByte(FUNCTION_SET_SELECTED_STATE)] = RESPONSE_EXPECTED_FLAG_FALSE;
responseExpected[IPConnection.unsignedByte(FUNCTION_GET_IDENTITY)] = RESPONSE_EXPECTED_FLAG_ALWAYS_TRUE;
callbacks[CALLBACK_MONOFLOP_DONE] = new IPConnection.DeviceCallbackListener() {
public void callback(byte[] packet) {
ByteBuffer bb = ByteBuffer.wrap(packet, 8, packet.length - 8);
bb.order(ByteOrder.LITTLE_ENDIAN);
short relay = IPConnection.unsignedByte(bb.get());
boolean state = (bb.get()) != 0;
for (MonoflopDoneListener listener: listenerMonoflopDone) {
listener.monoflopDone(relay, state);
}
}
};
}
/**
* Sets the state of the relays, *true* means on and *false* means off.
* For example: (true, false) turns relay 1 on and relay 2 off.
*
* If you just want to set one of the relays and don't know the current state
* of the other relay, you can get the state with {@link BrickletDualRelay#getState()} or you
* can use {@link BrickletDualRelay#setSelectedState(short, boolean)}.
*
* All running monoflop timers will be aborted if this function is called.
*/
public void setState(boolean relay1, boolean relay2) throws TinkerforgeException {
ByteBuffer bb = ipcon.createRequestPacket((byte)10, FUNCTION_SET_STATE, this);
bb.put((byte)(relay1 ? 1 : 0));
bb.put((byte)(relay2 ? 1 : 0));
sendRequest(bb.array());
}
/**
* Returns the state of the relays, *true* means on and *false* means off.
*/
public State getState() throws TinkerforgeException {
ByteBuffer bb = ipcon.createRequestPacket((byte)8, FUNCTION_GET_STATE, this);
byte[] response = sendRequest(bb.array());
bb = ByteBuffer.wrap(response, 8, response.length - 8);
bb.order(ByteOrder.LITTLE_ENDIAN);
State obj = new State();
obj.relay1 = (bb.get()) != 0;
obj.relay2 = (bb.get()) != 0;
return obj;
}
/**
* The first parameter can be 1 or 2 (relay 1 or relay 2). The second parameter
* is the desired state of the relay (*true* means on and *false* means off).
* The third parameter indicates the time that the relay should hold
* the state.
*
* If this function is called with the parameters (1, true, 1500):
* Relay 1 will turn on and in 1.5s it will turn off again.
*
* A monoflop can be used as a failsafe mechanism. For example: Lets assume you
* have a RS485 bus and a Dual Relay Bricklet connected to one of the slave
* stacks. You can now call this function every second, with a time parameter
* of two seconds. The relay will be on all the time. If now the RS485
* connection is lost, the relay will turn off in at most two seconds.
*/
public void setMonoflop(short relay, boolean state, long time) throws TinkerforgeException {
ByteBuffer bb = ipcon.createRequestPacket((byte)14, FUNCTION_SET_MONOFLOP, this);
bb.put((byte)relay);
bb.put((byte)(state ? 1 : 0));
bb.putInt((int)time);
sendRequest(bb.array());
}
/**
* Returns (for the given relay) the current state and the time as set by
* {@link BrickletDualRelay#setMonoflop(short, boolean, long)} as well as the remaining time until the state flips.
*
* If the timer is not running currently, the remaining time will be returned
* as 0.
*/
public Monoflop getMonoflop(short relay) throws TinkerforgeException {
ByteBuffer bb = ipcon.createRequestPacket((byte)9, FUNCTION_GET_MONOFLOP, this);
bb.put((byte)relay);
byte[] response = sendRequest(bb.array());
bb = ByteBuffer.wrap(response, 8, response.length - 8);
bb.order(ByteOrder.LITTLE_ENDIAN);
Monoflop obj = new Monoflop();
obj.state = (bb.get()) != 0;
obj.time = IPConnection.unsignedInt(bb.getInt());
obj.timeRemaining = IPConnection.unsignedInt(bb.getInt());
return obj;
}
/**
* Sets the state of the selected relay (1 or 2), *true* means on and *false* means off.
*
* A running monoflop timer for the selected relay will be aborted if this function is called.
*
* The other relay remains untouched.
*/
public void setSelectedState(short relay, boolean state) throws TinkerforgeException {
ByteBuffer bb = ipcon.createRequestPacket((byte)10, FUNCTION_SET_SELECTED_STATE, this);
bb.put((byte)relay);
bb.put((byte)(state ? 1 : 0));
sendRequest(bb.array());
}
/**
* Returns the UID, the UID where the Bricklet is connected to,
* the position, the hardware and firmware version as well as the
* device identifier.
*
* The position can be 'a', 'b', 'c' or 'd'.
*
* The device identifier numbers can be found :ref:`here <device_identifier>`.
* |device_identifier_constant|
*/
public Identity getIdentity() throws TinkerforgeException {
ByteBuffer bb = ipcon.createRequestPacket((byte)8, FUNCTION_GET_IDENTITY, this);
byte[] response = sendRequest(bb.array());
bb = ByteBuffer.wrap(response, 8, response.length - 8);
bb.order(ByteOrder.LITTLE_ENDIAN);
Identity obj = new Identity();
obj.uid = IPConnection.string(bb, 8);
obj.connectedUid = IPConnection.string(bb, 8);
obj.position = (char)(bb.get());
for (int i = 0; i < 3; i++) {
obj.hardwareVersion[i] = IPConnection.unsignedByte(bb.get());
}
for (int i = 0; i < 3; i++) {
obj.firmwareVersion[i] = IPConnection.unsignedByte(bb.get());
}
obj.deviceIdentifier = IPConnection.unsignedShort(bb.getShort());
return obj;
}
/**
* Adds a MonoflopDone listener.
*/
public void addMonoflopDoneListener(MonoflopDoneListener listener) {
listenerMonoflopDone.add(listener);
}
/**
* Removes a MonoflopDone listener.
*/
public void removeMonoflopDoneListener(MonoflopDoneListener listener) {
listenerMonoflopDone.remove(listener);
}
}
