import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
private void fireGroupReadWrite(final CEMILData f, final byte[] asdu, final int svc,
        final boolean optimized) {
    final ProcessEvent e = new ProcessEvent(SlicKnxProcessCommunicatorImpl.this, f.getSource(),
            (GroupAddress) f.getDestination(), svc, asdu, optimized);
    final EventListener[] el = listeners.listeners();
    for (EventListener l : el) {
        try {
            if (svc == GROUP_READ && l instanceof ProcessListenerEx) {
                ((ProcessListenerEx) l).groupReadRequest(e);
            } else if (svc == GROUP_RESPONSE && l instanceof ProcessListenerEx) {
                ((ProcessListenerEx) l).groupReadResponse(e);
            } else {
                ((ProcessListener) l).groupWrite(e);
            }
        } catch (final RuntimeException rte) {
            removeProcessListener((ProcessListener) l);
            logger.error("removed event listener", rte);
        }
    }
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
private synchronized byte[] readFromGroup(final GroupAddress dst, final Priority p,
        final int minASDULen, final int maxASDULen) throws KNXTimeoutException,
        KNXInvalidResponseException, KNXLinkClosedException, InterruptedException {
    if (detached) {
        throw new KNXIllegalStateException("process communicator detached");
    }
    try {
        wait = true;

        // before sending a request and waiting for response, clear previous indications
        // that could be sitting there from previous timed-out commands or by another request
        // for the same group
        synchronized (indications) {
            indications.clear();
        }
        lnk.sendRequestWait(dst, p, DataUnitBuilder.createLengthOptimizedAPDU(GROUP_READ, null));
        if (logger.isLoggable(LogLevel.TRACE)) {
            logger.trace("sent group read request to " + dst);
        }
        return waitForResponse(dst, minASDULen + 2, maxASDULen + 2);
    } finally {
        wait = false;
    }
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
/**
 * DPT 5.003
 *
 * @param isResponse
 * @param ga
 * @param angle value [0..360], i.e. °C
 * @throws de.root1.slicknx.KnxException
 * @throws IllegalArgumentException in case of wrong value
 */
public void writeAngle(boolean isResponse, String ga, int angle) throws KnxException {
    if (angle < 0 || angle > 360) {
        throw new IllegalArgumentException("Angle must be between 0..360, but was: " + angle);
    }
    checkGa(ga);
    try {
        if (isResponse) {
            pc.writeResponse(new GroupAddress(ga), angle, ProcessCommunicationBase.ANGLE);
        } else {
            pc.write(new GroupAddress(ga), angle, ProcessCommunicationBase.ANGLE);
        }
    } catch (KNXTimeoutException | KNXLinkClosedException | KNXFormatException ex) {
        throw new KnxException("Error writing angle", ex);
    }
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
/**
 * DPT 5.005 DPT 5.010
 *
 * @param isResponse
 * @param ga
 * @param value value [0..255]
 * @throws de.root1.slicknx.KnxException
 * @throws IllegalArgumentException in case of wrong value
 */
public void writeUnscaled(boolean isResponse, String ga, int value) throws KnxException {
    if (value < 0 || value > 255) {
        throw new IllegalArgumentException("value must be between 0..255, but was: " + value);
    }
    checkGa(ga);
    try {
        if (isResponse) {
            pc.writeResponse(new GroupAddress(ga), value, ProcessCommunicationBase.UNSCALED);
        } else {
            pc.write(new GroupAddress(ga), value, ProcessCommunicationBase.UNSCALED);
        }
    } catch (KNXTimeoutException | KNXLinkClosedException | KNXFormatException ex) {
        throw new KnxException("Error writing unscaled", ex);
    }
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
/**
 * DPT 6 8-bit signed value
 *
 * @param isResponse
 * @param ga
 * @param value value [-128..127] ^= 8bit signed
 * @throws de.root1.slicknx.KnxException
 */
public void writeDpt6(boolean isResponse, String ga, int value) throws KnxException {
    if (value < -128 || value > 127) {
        throw new IllegalArgumentException("value must be between -128..127, but was: " + value);
    }
    checkGa(ga);
    try {
        StateDP dp = new StateDP(new GroupAddress(ga), "6.001", 6, "6.001");
        if (isResponse) {
            pc.writeResponse(dp, Integer.toString(value));
        } else {
            pc.write(dp, Integer.toString(value));
        }

    } catch (KNXException ex) {
        throw new KnxException("Error writing dpt7", ex);
    }
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
/**
 * DPT 7 16-bit unsigned value
 *
 * @param isResponse
 * @param ga
 * @param value value [0..65535] ^= 16bit unsigned
 * @throws de.root1.slicknx.KnxException
 * @throws IllegalArgumentException in case of wrong value
 */
public void writeDpt7(boolean isResponse, String ga, int value) throws KnxException {
    if (value < 0 || value > 65535) {
        throw new IllegalArgumentException("value must be between 0..65535, but was: " + value);
    }
    checkGa(ga);
    try {

        StateDP dp = new StateDP(new GroupAddress(ga), "7.001", 7, "7.001");
        if (isResponse) {
            pc.writeResponse(dp, Integer.toString(value));
        } else {
            pc.write(dp, Integer.toString(value));
        }

    } catch (KNXException ex) {
        throw new KnxException("Error writing dpt7", ex);
    }
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
/**
 * DPT 8 16-bit signed value
 *
 * @param isResponse
 * @param ga
 * @param value value [-32768..32767] ^= 16bit signed
 * @throws de.root1.slicknx.KnxException
 * @throws IllegalArgumentException in case of wrong value
 */
public void writeDpt8(boolean isResponse, String ga, int value) throws KnxException {
    if (value < -32768 || value > 32767) {
        throw new IllegalArgumentException("value must be between -32768..32767, but was: " + value);
    }
    checkGa(ga);
    try {

        StateDP dp = new StateDP(new GroupAddress(ga), "8.001", 7, "8.001");
        if (isResponse) {
            pc.writeResponse(dp, Integer.toString(value));
        } else {
            pc.write(dp, Integer.toString(value));
        }

    } catch (KNXException ex) {
        throw new KnxException("Error writing dpt8", ex);
    }
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
/**
 *
 * @param ga
 * @param dpt
 * @return
 */
public String read(String ga, String dpt) throws KnxException {
    checkGa(ga);

    String[] dptSplit = dpt.split("\\.");
    int mainDpt = Integer.parseInt(dptSplit[0]);
    String subDpt = dptSplit[1];

    try {
        String value = pc.read(new StateDP(new GroupAddress(ga), "", mainDpt, dpt));

        return value;
    } catch (KNXException | InterruptedException ex) {
        throw new KnxException("Error reading DPT" + dpt + " from " + ga, ex);
    }
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@SuppressWarnings("unchecked")
public Iterable<String> getListeningItemNames(final GroupAddress groupAddress) {
	synchronized(bindingConfigs) {
		Iterable<KNXBindingConfig> configList = Iterables.filter(Iterables.concat(bindingConfigs.values()), KNXBindingConfig.class);
		Iterable<KNXBindingConfigItem> configItemList = Iterables.filter(Iterables.concat(configList), KNXBindingConfigItem.class);
		Iterable<KNXBindingConfigItem> filteredBindingConfigs = Iterables.filter(configItemList,
				new Predicate<KNXBindingConfigItem>() {
					public boolean apply(KNXBindingConfigItem input) {
						if(input==null) {
							return false;
						}
						return input.allDataPoints.contains(groupAddress);
					}
				});
		return Iterables.transform(filteredBindingConfigs, new Function<KNXBindingConfigItem, String>() {
			public String apply(KNXBindingConfigItem from) {
				if(from==null) {
					return null;
				}
				return from.itemName;
			}
		});
	}
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
@Override
public boolean isCommandGA(final GroupAddress groupAddress) {
	synchronized(bindingConfigs) {
		for (BindingConfig config : bindingConfigs.values()) {
			KNXBindingConfig knxConfig = (KNXBindingConfig) config;
			for (KNXBindingConfigItem configItem : knxConfig) {
				if (configItem.allDataPoints.contains(groupAddress)) {
					if(configItem.mainDataPoint instanceof CommandDP) {
						if(configItem.mainDataPoint.getMainAddress().equals(groupAddress)) {
							// the first GA in a CommandDP is always a command GA
							return true;
						} else {
							return false;
						}
					} else {
						// it is a StateDP, so the GA cannot be a command GA
						return false;
					}
				}
			}
		}
	}
	return false;
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
private void readWrite() throws KNXException
{
	// check if we are doing a read or write operation
	final boolean read = options.containsKey("read");
	final GroupAddress main = (GroupAddress) options.get(read ? "read" : "write");
	// encapsulate information into a datapoint
	// this is a convenient way to let the process communicator
	// handle the DPT stuff, so an already formatted string will be returned
	final Datapoint dp = new StateDP(main, "", 0, getDPT());
	if (read)
		System.out.println("read value: " + pc.read(dp));
	else {
		// note, a write to a non existing datapoint might finish successfully,
		// too.. no check for existence or read back of a written value is done
		pc.write(dp, (String) options.get("value"));
		System.out.println("write successful");
	}
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
@Override
public boolean isCommandGA(final GroupAddress groupAddress) {
    synchronized (bindingConfigs) {
        for (BindingConfig config : bindingConfigs.values()) {
            KNXBindingConfig knxConfig = (KNXBindingConfig) config;
            for (KNXBindingConfigItem configItem : knxConfig) {
                if (configItem.allDataPoints.contains(groupAddress)) {
                    if (configItem.mainDataPoint instanceof CommandDP) {
                        if (configItem.mainDataPoint.getMainAddress().equals(groupAddress)) {
                            // the first GA in a CommandDP is always a command GA
                            return true;
                        } else {
                            return false;
                        }
                    } else {
                        // it is a StateDP, so the GA cannot be a command GA
                        return false;
                    }
                }
            }
        }
    }
    return false;
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
/**
 * Determines if the given group address is marked for start-stop dimming.
 *
 * @param groupAddress the group address to check start-stop dimming for
 * @returns true, if the given group address is marked for start-stop dimming, false otherwise.
 */
@Override
public boolean isStartStopGA(GroupAddress groupAddress) {
    synchronized (bindingConfigs) {
        for (BindingConfig config : bindingConfigs.values()) {
            KNXBindingConfig knxConfig = (KNXBindingConfig) config;
            for (KNXBindingConfigItem configItem : knxConfig) {
                Boolean startStopBehavior = configItem.startStopMap.get(groupAddress);
                if (startStopBehavior != null) {
                    return startStopBehavior;
                }
            }
        }
    }
    return false;
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
private void sendTypeToItemButNotToKnx(GroupAddress destination, String itemName, Type type) {
    // we need to make sure that we won't send out this event to
    // the knx bus again, when receiving it on the openHAB bus
    ignoreEventList.add(itemName + type.toString());
    logger.trace("Added event (item='{}', type='{}') to the ignore event list", itemName, type.toString());

    if (type instanceof Command && isCommandGA(destination)) {
        eventPublisher.postCommand(itemName, (Command) type);
    } else if (type instanceof State) {
        eventPublisher.postUpdate(itemName, (State) type);
    } else {
        throw new IllegalClassException("Cannot process datapoint of type " + type.toString());
    }

    logger.trace("Processed event (item='{}', type='{}', destination='{}')", itemName, type.toString(),
            destination.toString());
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
private void send(KNXAddress dst, Priority p, byte[] nsdu, boolean confirm)
	throws KNXTimeoutException, KNXLinkClosedException
{
	final CEMILData f;
	final short mc = mode == TUNNEL ? CEMILData.MC_LDATA_REQ : CEMILData.MC_LDATA_IND;
	final IndividualAddress src = medium.getDeviceAddress();
	// use default address 0 in system broadcast
	final KNXAddress d = dst == null ? new GroupAddress(0) : dst;
	final boolean tp = medium.getMedium() == KNXMediumSettings.MEDIUM_TP0
		|| medium.getMedium() == KNXMediumSettings.MEDIUM_TP1;
	if (nsdu.length <= 16 && tp)
		f = new CEMILData(mc, src, d, nsdu, p, true, hopCount);
	else
		f = new CEMILDataEx(mc, src, d, nsdu, p, true, dst != null, false, hopCount);
	doSend(f, confirm);
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
private byte[] createEMI(int mc, KNXAddress dst, Priority p, byte[] nsdu)
{
	if (nsdu.length > 16)
		throw new KNXIllegalArgumentException(
			"maximum TPDU length is 16 in standard frame");
	// TP1, standard frames only
	final byte[] buf = new byte[nsdu.length + 7];
	buf[0] = (byte) mc;
	// ack don't care
	buf[1] = (byte) (p.value << 2);
	// on dst null, default address 0 is used
	// (null indicates system broadcast in link API)
	final int d = dst != null ? dst.getRawAddress() : 0;
	buf[4] = (byte) (d >> 8);
	buf[5] = (byte) d;
	buf[6] = (byte) (hopCount << 4 | (nsdu.length - 1));
	if (dst instanceof GroupAddress)
		buf[6] |= 0x80;
	for (int i = 0; i < nsdu.length; ++i)
		buf[7 + i] = nsdu[i];
	return buf;
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
void doSave(XMLWriter w) throws KNXMLException
{
	// <expiration timeout=int />
	w.writeEmptyElement(TAG_EXPIRATION, Arrays
		.asList(new Attribute[] { new Attribute(ATTR_TIMEOUT, Integer
			.toString(timeout)) }));
	w.writeElement(TAG_UPDATING, Collections.EMPTY_LIST, null);
	synchronized (updating) {
		for (final Iterator i = updating.iterator(); i.hasNext();)
			((GroupAddress) i.next()).save(w);
	}
	w.endElement();
	w.writeElement(TAG_INVALIDATING, Collections.EMPTY_LIST, null);
	synchronized (invalidating) {
		for (final Iterator i = invalidating.iterator(); i.hasNext();)
			((GroupAddress) i.next()).save(w);
	}
	w.endElement();
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
private void fireGroupReadWrite(CEMILData f, byte[] asdu, int svc)
{
	final ProcessEvent e =
		new ProcessEvent(ProcessCommunicatorImpl.this, f.getSource(),
			(GroupAddress) f.getDestination(), asdu);
	for (final Iterator i = listeners.iterator(); i.hasNext();) {
		final Object l = i.next();
		try {
			if (svc == GROUP_READ && l instanceof ProcessListenerEx)
				((ProcessListenerEx) l).groupReadRequest(e);
			else if (svc == GROUP_RESPONSE
				&& l instanceof ProcessListenerEx)
				((ProcessListenerEx) l).groupReadResponse(e);
			else
				((ProcessListener) l).groupWrite(e);
		}
		catch (final RuntimeException rte) {
			removeProcessListener((ProcessListener) l);
			logger.error("removed event listener", rte);
		}
	}
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
private synchronized byte[] readFromGroup(GroupAddress dst, Priority p,
	int minASDULen, int maxASDULen) throws KNXTimeoutException,
	KNXInvalidResponseException, KNXLinkClosedException
{
	if (detached)
		throw new KNXIllegalStateException("process communicator detached");
	try {
		wait = true;
		lnk.sendRequestWait(dst, p, DataUnitBuilder.createCompactAPDU(
			GROUP_READ, null));
		logger.trace("sent group read request to " + dst);
		return waitForResponse(minASDULen + 2, maxASDULen + 2);
	}
	finally {
		wait = false;
	}
}
 

import tuwien.auto.calimero.GroupAddress; //导入依赖的package包/类
public CEMILData request(KNXAddress dst, Configuration c)
{
	final Cache cache = c.getCache();
	if (cache == null || !(dst instanceof GroupAddress))
		return null;
	final LDataObject o = (LDataObject) cache.get(dst);
	if (o == null)
		return null;
	// check if there is an expiration timeout for a state based value
	final Datapoint dp;
	final DatapointModel m = c.getDatapointModel();
	if (m != null && (dp = m.get((GroupAddress) dst)) != null && dp.isStateBased()) {
		final int t = ((StateDP) dp).getExpirationTimeout() * 1000;
		if (t != 0 && System.currentTimeMillis() > o.getTimestamp() + t)
			return null;
	}
	return o.getFrame();
}