public void start() { for(ListenerData ld: valueListeners) { ld.listener = new ResourceValueListener<SingleValueResource>() { @Override public void resourceChanged(SingleValueResource arg0) { Value val = getValue(arg0); advance(ld.index, new SampledValue(val, appMan.getFrameworkTime(), Quality.GOOD)); //only the third callback will lead to an evaluation step if(lastTime > 0) { SampledValueDataPoint dataPoint = new SampledValueDataPointImplBase( currentValues, previousValues, nextValues, size, lastTime, currentTime, nextTime); try { evaluationInstance.step(dataPoint); } catch (Exception e) { e.printStackTrace(); } } } }; ld.resource.addValueListener(ld.listener, true); } }
/** Interrupt data collection, but evaluation is maintained and can be restarted*/ public void interrupt() { for(ListenerData ld: valueListeners) { if(ld.listener != null) ld.resource.removeValueListener(ld.listener); } }
@Override public void stop() { active = false; m_timer.stop(); for (SingleValueResource input : m_config.inputs().getAllElements()) { input.removeStructureListener(this); input.removeValueListener(this); } }
if (value instanceof SingleValueResource && entry.getKey().dataType() == DataType.TIME_SERIES) { final ValueListener listener = new ValueListener(start, (SingleValueResource) value); ((SingleValueResource) value).addValueListener(listener, true); listeners.put(entry.getKey(), listener); listeners.forEach((dp, listener) -> { try { ((SingleValueResource) copy.get(dp)).removeValueListener(listener); } catch (Exception ignore) {} });
ResourceSimulation(ConfigPattern config, ReadOnlyTimeSeries input, ApplicationManager appMan) { this.config = config; this.resource = config.target.getLocationResource(); this.input = input; this.additive = config.additive.isActive() && config.additive.getValue(); if (!config.forecast.isActive()) { this.forecast = null; this.iterator = null; } else { final String scheduleName = config.forecast.getValue(); Schedule sched0 = resource.getSubResource(scheduleName); if (sched0 == null) sched0 = resource.getSubResource(scheduleName, AbsoluteSchedule.class).create(); this.forecast = sched0; sched0.activate(false); this.iterator = new CyclicIterator(input, appMan.getFrameworkTime()); } this.timer = appMan.createTimer(10000000, this); timerElapsed(timer); resource.activate(false); LoggingUtils.activateLogging(resource, -2); appMan.getLogger().debug("Simulation started for resource {}", resource); }
@Override public void start() { boolean callOnEveryUpdate = true; if (m_config.callOnEveryUpdate().isActive()) { callOnEveryUpdate = m_config.callOnEveryUpdate().getValue(); } for (SingleValueResource input : m_config.inputs().getAllElements()) { input.addStructureListener(this); input.addValueListener(this, callOnEveryUpdate); } active = true; evaluate(); }
@Override public boolean commit() { if (m_inputs == null || m_output == null) { return false; } // delete the old configuration if it exsited. if (m_config != null) m_config.delete(); m_config = m_base.createResource(SumModel.class); m_config.inputs().create(); for (SingleValueResource val : m_inputs) { if (!val.exists()) { val.create(); LoggerFactory.getLogger(ResourceManipulatorImpl.class).warn("Virtual resource passed to Sum configuration; creating it. {}",val); } m_config.inputs().add(val); } m_config.resultBase().setAsReference(m_output); m_config.delay().create(); m_config.delay().setValue(m_delay); m_config.deactivateEmptySum().create(); m_config.deactivateEmptySum().setValue(m_deactivateEmtpySum); m_config.activate(true); return true; }
configs.activate(false); resource.activate(false); final ScheduledSimulationConfig config = configs.add(); config.target().setAsReference(resource); config.typePrimary().<StringResource> create().setValue(type.primaryType); if (type.secondaryType != null)
public void storeEvent(HmEvent e, SingleValueResource res) { logger.debug("storing event data for {}@{} to {}", e.getValueKey(), e.getAddress(), res.getPath()); if (res instanceof FloatResource) { ((FloatResource) res).setValue(e.getValueFloat()); } else if (res instanceof IntegerResource) { ((IntegerResource) res).setValue(e.getValueInt()); } else if (res instanceof StringResource) { ((StringResource) res).setValue(e.getValueString()); } else if (res instanceof BooleanResource) { ((BooleanResource) res).setValue(e.getValueBoolean()); } else { logger.warn("HomeMatic parameter resource is of unsupported type: {}", res.getResourceType()); } }
@Override public void channelEvent(EventType type, List<SampledValueContainer> channels) { logger.trace("Channel event for {}", pattern.target); for (SampledValueContainer container: channels) { if (container.getChannelLocator().equals(channelConfiguration.getChannelLocator())) { float factor = 1; float offset = 0; if (pattern.scalingFactor.isActive()) factor = pattern.scalingFactor.getValue(); if (pattern.valueOffset.isActive()) offset = pattern.valueOffset.getValue(); Value value = transform(container.getSampledValue().getValue(), factor, offset); ValueResourceUtils.setValue(pattern.target, value); pattern.target.activate(false); } } }
private static RecordedData getHistoricalData(SingleValueResource resource) { RecordedData rd = null; if (resource instanceof FloatResource) rd = ((FloatResource) resource).getHistoricalData(); else if (resource instanceof IntegerResource) rd = ((IntegerResource) resource).getHistoricalData(); else if (resource instanceof TimeResource) rd = ((TimeResource) resource).getHistoricalData(); else if (resource instanceof BooleanResource) rd = ((BooleanResource) resource).getHistoricalData(); else throw new IllegalArgumentException("Logging not possible for resource of type " + resource.getResourceType().getName()); return rd; }
@Override public void unmapChannel(final ChannelLocator channel, final SingleValueResource target) { ChannelController cc = channelMappings.get(channel); if (cc == null) { logger.warn("Channel not found, cannot remove it: {}", channel); return; } if (target != null && !cc.pattern.target.equalsLocation(target)) return; cc.pattern.model.delete(); // will trigger a patternUnavailable callback }
private static void printChannelMapping(final ChannelController cc) { System.out.println(" Configuration " + cc.pattern.model.getLocation()); System.out.println(" Resource: " + cc.pattern.target.getLocationResource()); System.out.println(" Channel: " + cc.channelLocator); System.out.println(" Initialisation successful: " + (cc.pattern.registrationSuccessful.isActive() && cc.pattern.registrationSuccessful.getValue())); }
private static Value transformBack(SingleValueResource in, float factor, float offset) { final Object value = ValueResourceUtils.getValue((ValueResource) in); if (in instanceof FloatResource) return new FloatValue(((float) value - offset) / factor); else if (in instanceof IntegerResource) return new IntegerValue(((int) value - (int) offset) / ((int) factor)); else if (in instanceof TimeResource) return new LongValue(((long) value - (long) offset) / ((long) factor)); else if (in instanceof BooleanResource) return new BooleanValue((boolean) value && (factor >= 0)); else throw new IllegalArgumentException("Unsupported resource type " + in.getResourceType().getName()); }
@Override public void onGET(OgemaHttpRequest req) { final boolean existing = resSelectorCheckbox.getCheckboxList(req).get(0).isChecked(); if (!existing) { update(Collections.emptyList(), req); disable(req); return; } enable(req); final Class<? extends SingleValueResource> type = typeSelector.getSelectedItem(req); final List<ConfigPattern> configs = appMan.getResourcePatternAccess().getPatterns(ConfigPattern.class, AccessPriority.PRIO_LOWEST); final List<SingleValueResource> resources = appMan.getResourceAccess().getResources(type).stream() .filter(resource -> !configs.stream().filter(cfg -> cfg.target.equalsLocation(resource)).findAny().isPresent()) .collect(Collectors.toList()); update(resources, req); }
protected void setResourceValue(V resource, String value, OgemaHttpRequest req) { if(!(resource instanceof StringResource || resource instanceof BooleanResource)) { value = value.replaceAll("[^\\d.,-]", ""); } // may throw different kinds of exceptions boolean exists = resource.exists(); if(!exists) resource.create(); if (resource instanceof TemperatureResource) { ((TemperatureResource) resource).setValue(Float.parseFloat(value) + 273.15F); } else ValueResourceUtils.setValue(resource, value); if(!exists) resource.activate(false); }
public void close() { target.removeValueListener(this); }
public CorrectionListener(final ConnectionTask task) { this.task = task; this.target = task.getUpdateIntervalResource(); target.addValueListener(this); }
void close() { try{ pattern.target.removeValueListener(this); } catch (Exception e) { LoggerFactory.getLogger(ChannelMapperImpl.class).warn("Error closing channel controller",e); } if (channelConfiguration != null) { try{ ca.unregisterUpdateListener(Collections.singletonList(channelConfiguration), this); } catch (Exception e) { LoggerFactory.getLogger(ChannelMapperImpl.class).warn("Error closing channel controller",e); } try { ca.deleteChannel(channelConfiguration); } catch (Exception e) { LoggerFactory.getLogger(ChannelMapperImpl.class).warn("Error closing channel controller",e); } } ScheduledFuture<?> openTask = this.openTask; if (openTask != null) openTask.cancel(true); this.openTask = null; t = null; }