Examples with IncreaseDecreaseType org.openhab.core.library.types.IncreaseDecreaseType used on opensource projects

Example 11 with IncreaseDecreaseType

use of org.openhab.core.library.types.IncreaseDecreaseType in project openhab1-addons by openhab.

the class TinkerforgeBinding method internalReceiveCommand.

/**
     * {@inheritDoc}
     *
     * Searches the item with the given {@code itemName} in the {@link TinkerforgeBindingProvider}
     * collection and gets the uid and subid of the device. The appropriate device is searched in the
     * ecosystem and the command is executed on the device.
     *
     * {@code OnOffType} commands are executed on {@link MInSwitchActor} objects. {@code StringType}
     * commands are executed on {@link MTextActor} objects.
     *
     */
@Override
protected void internalReceiveCommand(String itemName, Command command) {
    logger.debug("received command {} for item {}", command, itemName);
    for (TinkerforgeBindingProvider provider : providers) {
        for (String itemNameP : provider.getItemNames()) {
            if (itemNameP.equals(itemName)) {
                String deviceUid = provider.getUid(itemName);
                String deviceSubId = provider.getSubId(itemName);
                String deviceName = provider.getName(itemName);
                if (deviceName != null) {
                    String[] ids = getDeviceIdsForDeviceName(deviceName);
                    deviceUid = ids[0];
                    deviceSubId = ids[1];
                }
                logger.trace("{} found item for command: uid: {}, subid: {}", LoggerConstants.COMMAND, deviceUid, deviceSubId);
                MBaseDevice mDevice = tinkerforgeEcosystem.getDevice(deviceUid, deviceSubId);
                if (mDevice != null && mDevice.getEnabledA().get()) {
                    if (command instanceof OnOffType) {
                        logger.trace("{} found onoff command", LoggerConstants.COMMAND);
                        OnOffType cmd = (OnOffType) command;
                        if (mDevice instanceof MSwitchActor) {
                            OnOffValue state = cmd == OnOffType.OFF ? OnOffValue.OFF : OnOffValue.ON;
                            ((MSwitchActor) mDevice).turnSwitch(state);
                        } else if (mDevice instanceof DigitalActor) {
                            HighLowValue state = cmd == OnOffType.OFF ? HighLowValue.LOW : HighLowValue.HIGH;
                            ((DigitalActor) mDevice).turnDigital(state);
                        } else if (mDevice instanceof ProgrammableSwitchActor) {
                            OnOffValue state = cmd == OnOffType.OFF ? OnOffValue.OFF : OnOffValue.ON;
                            ((ProgrammableSwitchActor) mDevice).turnSwitch(state, provider.getDeviceOptions(itemName));
                        } else {
                            logger.error("{} received OnOff command for non-SwitchActor", LoggerConstants.COMMAND);
                        }
                    } else if (command instanceof StringType) {
                        logger.trace("{} found string command", LoggerConstants.COMMAND);
                        if (mDevice instanceof MTextActor) {
                            ((MTextActor) mDevice).write(command.toString());
                        }
                    } else if (command instanceof DecimalType) {
                        logger.debug("{} found number command", LoggerConstants.COMMAND);
                        if (command instanceof HSBType) {
                            logger.debug("{} found HSBType command", LoggerConstants.COMMAND);
                            if (mDevice instanceof ProgrammableColorActor) {
                                logger.debug("{} found ProgrammableColorActor {}", itemName);
                                ((ProgrammableColorActor) mDevice).setSelectedColor((HSBType) command, provider.getDeviceOptions(itemName));
                            } else if (mDevice instanceof SimpleColorActor) {
                                logger.debug("{} found SimpleColorActor {}", itemName);
                                ((SimpleColorActor) mDevice).setSelectedColor((HSBType) command);
                            }
                        } else if (command instanceof PercentType) {
                            if (mDevice instanceof SetPointActor) {
                                ((SetPointActor<?>) mDevice).setValue(((PercentType) command), provider.getDeviceOptions(itemName));
                                logger.debug("found SetpointActor");
                            } else if (mDevice instanceof PercentTypeActor) {
                                ((PercentTypeActor) mDevice).setValue(((PercentType) command), provider.getDeviceOptions(itemName));
                                logger.debug("found PercentType actor");
                            } else {
                                logger.error("found no percenttype actor");
                            }
                        } else {
                            if (mDevice instanceof NumberActor) {
                                ((NumberActor) mDevice).setNumber(((DecimalType) command).toBigDecimal());
                            } else if (mDevice instanceof SetPointActor) {
                                ((SetPointActor<?>) mDevice).setValue(((DecimalType) command).toBigDecimal(), provider.getDeviceOptions(itemName));
                            } else {
                                logger.error("found no number actor");
                            }
                        }
                    } else if (command instanceof UpDownType) {
                        UpDownType cmd = (UpDownType) command;
                        logger.debug("{} UpDownType command {}", itemName, cmd);
                        if (mDevice instanceof MoveActor) {
                            ((MoveActor) mDevice).move((UpDownType) command, provider.getDeviceOptions(itemName));
                        }
                    } else if (command instanceof StopMoveType) {
                        StopMoveType cmd = (StopMoveType) command;
                        if (mDevice instanceof MoveActor) {
                            if (cmd == StopMoveType.STOP) {
                                ((MoveActor) mDevice).stop();
                            } else {
                                ((MoveActor) mDevice).moveon(provider.getDeviceOptions(itemName));
                            }
                        }
                        logger.debug("{} StopMoveType command {}", itemName, cmd);
                    } else if (command instanceof IncreaseDecreaseType) {
                        IncreaseDecreaseType cmd = (IncreaseDecreaseType) command;
                        if (mDevice instanceof DimmableActor) {
                            ((DimmableActor<?>) mDevice).dimm((IncreaseDecreaseType) command, provider.getDeviceOptions(itemName));
                        }
                        logger.debug("{} IncreaseDecreaseType command {}", itemName, cmd);
                    } else {
                        logger.error("{} got unknown command type: {}", LoggerConstants.COMMAND, command.toString());
                    }
                } else {
                    logger.error("{} no tinkerforge device found for command for item uid: {} subId: {}", LoggerConstants.COMMAND, deviceUid, deviceSubId);
                }
            }
        }
    }
}

Example 12 with IncreaseDecreaseType

use of org.openhab.core.library.types.IncreaseDecreaseType in project openhab1-addons by openhab.

the class YamahaReceiverBinding method internalReceiveCommand.

@Override
protected void internalReceiveCommand(String itemName, Command command) {
    YamahaReceiverBindingConfig config = getConfigForItemName(itemName);
    if (config == null) {
        logger.error("Received command for unknown item '" + itemName + "'");
        return;
    }
    YamahaReceiverProxy proxy = proxies.get(config.getDeviceUid());
    if (proxy == null) {
        logger.error("Received command for unknown device uid '" + config.getDeviceUid() + "'");
        return;
    }
    if (logger.isDebugEnabled()) {
        logger.debug(BINDING_NAME + " processing command '" + command + "' of type '" + command.getClass().getSimpleName() + "' for item '" + itemName + "'");
    }
    try {
        Zone zone = config.getZone();
        BindingType type = config.getBindingType();
        if (type == BindingType.power) {
            if (command instanceof OnOffType) {
                proxy.setPower(zone, command == OnOffType.ON);
            }
        } else if (type == BindingType.volumePercent || type == BindingType.volumeDb) {
            if (command instanceof IncreaseDecreaseType || command instanceof UpDownType) {
                // increase/decrease dB by .5 dB
                float db = proxy.getState(zone).getVolume();
                float adjAmt;
                if (command == IncreaseDecreaseType.INCREASE || command == UpDownType.UP) {
                    adjAmt = .5f;
                } else {
                    adjAmt = -.5f;
                }
                float newDb = db + adjAmt;
                proxy.setVolume(zone, newDb);
                // send new value as update
                State newState = new DecimalType(newDb);
                eventPublisher.postUpdate(itemName, newState);
            } else if (command instanceof PercentType) {
                // set dB from percent
                byte percent = ((PercentType) command).byteValue();
                int db = percentToDB(percent);
                proxy.setVolume(zone, db);
            } else {
                // set dB from value
                float db = Float.parseFloat(command.toString());
                proxy.setVolume(zone, db);
            }
            // Volume updates multiple values => send update now
            sendUpdates(proxy, config.getDeviceUid());
        } else if (type == BindingType.mute) {
            if (command instanceof OnOffType) {
                proxy.setMute(zone, command == OnOffType.ON);
            }
        } else if (type == BindingType.input) {
            proxy.setInput(zone, parseString(command.toString()));
        } else if (type == BindingType.surroundProgram) {
            proxy.setSurroundProgram(zone, parseString(command.toString()));
        } else if (type == BindingType.netRadio) {
            if (command instanceof DecimalType) {
                proxy.setNetRadio(((DecimalType) command).intValue());
            }
        }
    } catch (IOException e) {
        logger.warn("Cannot communicate with " + proxy.getHost() + " (uid: " + config.getDeviceUid() + ")");
    } catch (Throwable t) {
        logger.error("Error processing command '" + command + "' for item '" + itemName + "'", t);
    }
}

Example 13 with IncreaseDecreaseType

use of org.openhab.core.library.types.IncreaseDecreaseType in project openhab1-addons by openhab.

the class FatekColorItem method command.

@Override
public void command(FatekPLC fatekPLC, Command command) throws CommandException {
    try {
        final HSBType val;
        if (command instanceof OnOffType) {
            val = valueForOnOff(fatekPLC, command);
        } else if (command instanceof IncreaseDecreaseType) {
            val = valueForIncreaseDecrease(fatekPLC, command);
        } else if (command instanceof HSBType) {
            val = (HSBType) command;
        } else {
            throw new UnsupportedCommandException(this, command);
        }
        if (val != null) {
            int v1;
            int v2;
            int v3;
            if (isColorRGB) {
                Color c = val.toColor();
                v1 = c.getRed();
                v2 = c.getGreen();
                v3 = c.getBlue();
            } else {
                v1 = val.getHue().intValue();
                v2 = val.getSaturation().intValue();
                v3 = val.getBrightness().intValue();
            }
            FatekWriteMixDataCmd cmd = new FatekWriteMixDataCmd(fatekPLC);
            cmd.addReg(reg1, v1);
            cmd.addReg(reg2, v2);
            cmd.addReg(reg3, v3);
            cmd.send();
        }
    } catch (FatekIOException | FatekException e) {
        throw new CommandException(this, command, e);
    }
}

Example 14 with IncreaseDecreaseType

use of org.openhab.core.library.types.IncreaseDecreaseType in project openhab1-addons by openhab.

the class BticinoDevice method receiveCommand.

public void receiveCommand(String itemName, Command command, BticinoBindingConfig itemBindingConfig) {
    try {
        synchronized (m_lock) {
            // A command is received from the openHab system;
            // analyse it and execute it
            logger.debug("Gateway [" + m_gateway_id + "], Command '{}' received for item {}", (Object[]) new String[] { command.toString(), itemName });
            ProtocolRead l_pr = new ProtocolRead(itemBindingConfig.who + "*" + itemBindingConfig.where);
            l_pr.addProperty("who", itemBindingConfig.who);
            l_pr.addProperty("address", itemBindingConfig.where);
            int l_who = Integer.parseInt(itemBindingConfig.who);
            switch(l_who) {
                // Lights
                case 1:
                    {
                        if (command instanceof IncreaseDecreaseType) {
                            if (IncreaseDecreaseType.INCREASE.equals(command)) {
                                logger.debug("Light received INCREASE command.");
                                l_pr.addProperty("what", "30");
                            } else {
                                logger.debug("Light received DECREASE command.");
                                l_pr.addProperty("what", "31");
                            }
                        } else if (command instanceof PercentType) {
                            PercentType pType = (PercentType) command;
                            //take percentage and divide by 10, round 1 (ie 0 to 10 is the result, nothing else)
                            int percentValue = (int) (Math.floor(pType.intValue() / 10F));
                            logger.debug("Set light value to {}", percentValue);
                            l_pr.addProperty("what", String.valueOf(percentValue));
                        } else if (command instanceof OnOffType) {
                            if (OnOffType.ON.equals(command)) {
                                l_pr.addProperty("what", "1");
                            } else {
                                l_pr.addProperty("what", "0");
                            }
                        } else {
                            logger.warn("Received unknown command type for lighting: '{}'", command.getClass().getName());
                        }
                        break;
                    }
                // Shutter
                case 2:
                    {
                        if (UpDownType.UP.equals(command)) {
                            l_pr.addProperty("what", "1");
                        } else if (UpDownType.DOWN.equals(command)) {
                            l_pr.addProperty("what", "2");
                        } else if (StopMoveType.STOP.equals(command)) {
                            l_pr.addProperty("what", "0");
                        }
                        break;
                    }
                // CEN Basic & Evolved
                case 15:
                    {
                        // device
                        if (OnOffType.ON.equals(command)) {
                            l_pr.addProperty("what", itemBindingConfig.what);
                        }
                        break;
                    }
            }
            m_open_web_net.onCommand(l_pr);
        }
    } catch (Exception e) {
        logger.error("Gateway [" + m_gateway_id + "], Error processing receiveCommand '{}'", (Object[]) new String[] { e.getMessage() });
    }
}