import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的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.process.ProcessEvent; //导入依赖的package包/类
public void notifyListeners(ProcessEvent p_evt) {
	Iterator<Entry<String, Datapoint>> l_it = m_Listening.entrySet()
			.iterator();
	while (l_it.hasNext()) {
		Map.Entry<String, Datapoint> l_entry = l_it.next();
		if (l_entry.getValue().getMainAddress().getRawAddress() == p_evt
				.getDestination().getRawAddress()) {
			DPTXlator l_translator;
			try {
				l_translator = TranslatorTypes.createTranslator(l_entry
						.getValue().getMainNumber(), l_entry.getValue()
						.getDPT());
				l_translator.setData(p_evt.getASDU());

				setChanged();
				notifyObservers(new DatapointEvent(l_entry.getValue(),
						l_translator.getValue(), l_entry.getKey()));
				break;
			} catch (KNXException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
public final void groupWrite(ProcessEvent e) {
    try {

        GroupAddress source=new GroupAddress(e.getSourceAddr().toString());
        GroupAddress destination=e.getDestination();
        GroupAddress currentDevice=new GroupAddress(getGroupaddr());

        if(destination.equals(currentDevice)){
            messageReceived(e);
        }else if(source.equals(currentDevice)){
            messageSent(e);
        }

    } catch (KNXFormatException e1) {
        LOG.warn("Invalid group address {}",getGroupaddr(),e1);
    }
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
/**
 * If <code>knx:ignorelocalevents=true</code> is set in configuration, it prevents internal events 
 * coming from 'openHAB event bus' a second time to be sent back to the 'openHAB event bus'.
 *  
 * @param e the {@link ProcessEvent} to handle.
 */
@Override
public void groupWrite(ProcessEvent e) {
	logger.debug("Received groupWrite Event.");
	if (!(KNXConnection.getIgnoreLocalSourceEvents() && e.getSourceAddr().toString().equalsIgnoreCase(KNXConnection.getLocalSourceAddr()))) {
		readFromKNX(e);
	}else logger.warn("Ignoring local Event, received from my local Source address {} for Group address {}.", e.getSourceAddr().toString(), e.getDestination().toString());
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
@Override
public void groupReadRequest(ProcessEvent arg0)
{
    /*
    System.out.println("groupReadReq " + arg0.getSourceAddr().toString() + " - " + 
            arg0.getDestination().toString() + " : " +
            arg0.getASDU());
            */
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
@Override
public void groupReadResponse(ProcessEvent arg0)
{
    /*System.out.println("groupReadResp " + arg0.getSourceAddr().toString() + " - " + 
            arg0.getDestination().toString() + " : " +
            arg0.getASDU());*/
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
/**
 * If <code>knx:ignorelocalevents=true</code> is set in configuration, it prevents internal events
 * coming from 'openHAB event bus' a second time to be sent back to the 'openHAB event bus'.
 *
 * @param e the {@link ProcessEvent} to handle.
 */
@Override
public void groupWrite(ProcessEvent e) {
    logger.debug("Received groupWrite Event.");
    if (!(KNXConnection.getIgnoreLocalSourceEvents()
            && e.getSourceAddr().toString().equalsIgnoreCase(KNXConnection.getLocalSourceAddr()))) {
        readFromKNX(e);
    } else {
        logger.debug("Ignoring local Event, received from my local Source address {} for Group address {}.",
                e.getSourceAddr().toString(), e.getDestination().toString());
    }
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
@Override
public void groupReadRequest(ProcessEvent e) {
    convertAndForward(e);
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
@Override
public void groupReadResponse(ProcessEvent e) {
    convertAndForward(e);
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
@Override
public void groupWrite(ProcessEvent e) {
    convertAndForward(e);
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
public void notifyListeners(ProcessEvent p_evt){
	setChanged();
	notifyObservers(p_evt);
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
/**
 * Handles the given {@link ProcessEvent}. After finding the corresponding
 * Item (by iterating through all known group addresses) this Item is updated.
 * Each item is added to a special list to identify and avoid echo's in
 * the <code>receiveUpdate</code> and <code>receiveCommand</code> methods.  
 *  
 * @param e the {@link ProcessEvent} to handle.
 */
private void readFromKNX(ProcessEvent e) {
	try {
		GroupAddress destination = e.getDestination();
		byte[] asdu = e.getASDU();
		if (asdu.length==0) {
			return;
		}
		String [] itemList = getItemNames(destination);
		if (itemList.length == 0) {
			logger.debug("Received telegram for unknown group address {}", destination.toString());
		}
		for (String itemName : itemList) {
			Iterable<Datapoint> datapoints = getDatapoints(itemName, destination);
			if (datapoints != null) {
				for (Datapoint datapoint : datapoints) {
					Type type = getType(datapoint, asdu);					
					if (type!=null) {
						// 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());
					}
					else {
						final char[] hexCode = "0123456789ABCDEF".toCharArray();
						StringBuilder sb = new StringBuilder(2+asdu.length * 2);
						sb.append("0x");
						for (byte b : asdu) {
							sb.append(hexCode[(b >> 4) & 0xF]);
							sb.append(hexCode[(b & 0xF)]);
						}

						logger.debug("Ignoring KNX bus data: couldn't transform to an openHAB type (not supported). Destination='{}', datapoint='{}', data='{}'",
								new Object[] {destination.toString(), datapoint.toString(), sb.toString() });
					}
				}
			}
		}
	} catch(RuntimeException re) {
		logger.error("Error while receiving event from KNX bus: " + re.toString());
	}
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
@Override
public void groupReadRequest(final ProcessEvent e)
{
    add(model.get(e.getDestination()), "read request", e);
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
@Override
public void groupReadResponse(final ProcessEvent e)
{
    add(model.get(e.getDestination()), "read response", e);
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
public void groupWrite(final ProcessEvent e)
{
    add(model.get(e.getDestination()), "write", e);
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
@Override
public void groupWrite(ProcessEvent evt)
{
    final String source = evt.getSource().toString();
    final String destination = evt.getDestination().toString();
    final String devName = KNXDevice.addrMap.get(destination);
    final KNXDevice dev = (KNXDevice) DeviceManager.instance().getDevice(devName);
    
    if(dev != null){
        /*try {
            dev.readValue();
        } catch (Throwable e) {
            Log.log("Error reading from device "+devName);
        }*/
        Event e = new Event(DeviceChangeEvent.TOPIC);

        Value deviceName = new Value(),
              deviceValue = new Value();
        
        deviceName.setString(devName);

        try {
            switch(dev.getValue().type){
            case Value.BOOLEAN_TYPE:
                final boolean b = asBool(evt);
                deviceValue.setBoolean(b);
                dev.setValue(deviceValue);
                Log.log("New boolean value for "+devName+": "+b);
                break;
            case Value.INTEGER_TYPE:
                final int i = asUnsigned(evt, "5.001");
                deviceValue.setInteger(i);
                Log.log("New integer value for "+devName+": "+i);
                break;
            }
            
            e.setMember("name", deviceName);
            e.setMember("value", deviceValue);
            
            org.ugr.bluerose.events.EventHandler.publish(e, false);
        } catch (KNXFormatException e1) {
            Log.log("KNXFormatException: "+e1.getMessage());
        } catch (Exception e2) {
            Log.log("KNXException: "+e2.getMessage());
        }
    }
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
/**
 * Handles the given {@link ProcessEvent}. After finding the corresponding
 * Item (by iterating through all known group addresses) this Item is updated.
 * Each item is added to a special list to identify and avoid echo's in
 * the <code>receiveUpdate</code> and <code>receiveCommand</code> methods.
 *
 * @param e the {@link ProcessEvent} to handle.
 */
private void readFromKNX(ProcessEvent e) {
    try {
        GroupAddress destination = e.getDestination();
        byte[] asdu = e.getASDU();
        if (asdu.length == 0) {
            return;
        }
        String[] itemList = getItemNames(destination);
        if (itemList.length == 0) {
            logger.debug("Received telegram for unknown group address {}", destination.toString());
        }
        for (String itemName : itemList) {
            Iterable<Datapoint> datapoints = getDatapoints(itemName, destination);
            if (datapoints != null) {
                for (Datapoint datapoint : datapoints) {
                    Type type = getType(datapoint, asdu);
                    if (type != null) {
                        if (type instanceof Command && isStartStopEnabled(itemName, destination, datapoint)) {
                            if (isDimmerThreadRunning(itemName) && type == IncreaseDecreaseType.INCREASE) {
                                stopDimmerThread(itemName);
                            } else {
                                startDimmerThread(destination, itemName, (Command) type);
                            }
                        } else {
                            sendTypeToItemButNotToKnx(destination, itemName, type);
                        }
                    } else {
                        final char[] hexCode = "0123456789ABCDEF".toCharArray();
                        StringBuilder sb = new StringBuilder(2 + asdu.length * 2);
                        sb.append("0x");
                        for (byte b : asdu) {
                            sb.append(hexCode[(b >> 4) & 0xF]);
                            sb.append(hexCode[(b & 0xF)]);
                        }

                        logger.debug(
                                "Ignoring KNX bus data: couldn't transform to an openHAB type (not supported). Destination='{}', datapoint='{}', data='{}'",
                                new Object[] { destination.toString(), datapoint.toString(), sb.toString() });
                    }
                }
            }
        }
    } catch (RuntimeException re) {
        logger.error("Error while receiving event from KNX bus: " + re.toString());
    }
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
public void messageReceived(ProcessEvent e) {
    LOG.info("Device {} received message from {}",e.getDestination(),e.getSourceAddr());
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
public void messageSent(ProcessEvent e){
    LOG.info("Device {} sent message to {}",e.getSourceAddr(),e.getDestination());
}
 

import tuwien.auto.calimero.process.ProcessEvent; //导入依赖的package包/类
@Override
public void groupWrite(ProcessEvent ev) {

	if (m_Logger != null)
		m_Logger.notifyListeners(ev);

	if (m_Management != null)
		m_Management.notifyListeners(ev);

}