Examples with SoulissGenericTypical org.openhab.binding.souliss.internal.network.typicals.SoulissGenericTypical used on opensource projects

Example 1 with SoulissGenericTypical

use of org.openhab.binding.souliss.internal.network.typicals.SoulissGenericTypical in project openhab1-addons by openhab.

the class UDPSoulissDecoder method decodeStateRequest.

private void decodeStateRequest(ArrayList<Short> mac) {
    boolean bDecoded_forLOG = false;
    int tgtnode = mac.get(3);
    // QUI. AGGIORNAMENTO DEL TIMESTAMP PER OGNI NODO. DA FARE USANDO NODI
    // FITTIZI
    SoulissTServiceUpdater.updateTIMESTAMP(soulissTypicalsRecipients, tgtnode);
    // leggo valore tipico in base allo slot
    synchronized (this) {
        Iterator<Entry<String, SoulissGenericTypical>> iteratorTypicals = soulissTypicalsRecipients.getIterator();
        while (iteratorTypicals.hasNext()) {
            SoulissGenericTypical typ = iteratorTypicals.next().getValue();
            // se il tipico estratto appartiene al nodo che il frame deve
            // aggiornare...
            bDecoded_forLOG = false;
            if (typ.getSoulissNodeID() == tgtnode) {
                // ...allora controllo lo slot
                int slot = typ.getSlot();
                // ...ed aggiorno lo stato in base al tipo
                int iNumBytes = 0;
                try {
                    String sHex = Integer.toHexString(typ.getType());
                    String sRes = SoulissNetworkParameter.getPropTypicalBytes(sHex.toUpperCase());
                    if (sRes != null)
                        iNumBytes = Integer.parseInt(sRes);
                } catch (NumberFormatException e) {
                    e.printStackTrace();
                    iNumBytes = 0;
                }
                float val = 0;
                // ***** T1A *****
                if (typ.getType() == 0x1A) {
                    short sVal = getByteAtSlot(mac, slot);
                    ((SoulissT1A) typ).setState(sVal);
                    bDecoded_forLOG = true;
                // ***** T19 *****
                } else if (typ.getType() == 0x19) {
                    // set value of T19 at number of second slot
                    short sVal = getByteAtSlot(mac, slot + 1);
                    typ.setState(sVal);
                    bDecoded_forLOG = true;
                } else if (iNumBytes == 1) {
                    // caso valori digitali
                    val = getByteAtSlot(mac, slot);
                    typ.setState(val);
                    bDecoded_forLOG = true;
                } else if (iNumBytes == 2) {
                    // caso valori float
                    val = getFloatAtSlot(mac, slot);
                    typ.setState(val);
                    bDecoded_forLOG = true;
                } else if (iNumBytes == 4) {
                    // ***** T16 RGB *****
                    val = getByteAtSlot(mac, slot);
                    typ.setState(val);
                    ((SoulissT16) typ).setStateRED(getByteAtSlot(mac, slot + 1));
                    ((SoulissT16) typ).setStateGREEN(getByteAtSlot(mac, slot + 2));
                    ((SoulissT16) typ).setStateBLU(getByteAtSlot(mac, slot + 3));
                    bDecoded_forLOG = true;
                } else if (iNumBytes == 5) {
                    // ***** T31 *****
                    // *******************
                    // SLOT 0: Control State
                    short sVal = getByteAtSlot(mac, slot);
                    ((SoulissT31) typ).setRawCommandState(sVal);
                    /*
						 * The control state bit meaning follow as: 
						 * BIT 0 Not used 
						 * BIT 1 (0 Heating OFF , 1 Heating ON) 
						 * BIT 2 (0 Cooling OFF , 1 Cooling ON) 
						 * BIT 3 (0 Fan 1 OFF , 1 Fan 1 ON) 
						 * BIT 4 (0 Fan 2 OFF , 1 Fan 2 ON) 
						 * BIT 5 (0	Fan 3 OFF , 1 Fan 3 ON) 
						 * BIT 6 (0 Manual Mode , 1 Automatic Mode for Fan) 
						 * BIT 7 (0 Heating Mode, 1 Cooling Mode)
						 */
                    ((SoulissT31) typ).power.setState(getBitState(sVal, 0));
                    ((SoulissT31) typ).heating.setState(getBitState(sVal, 1));
                    ((SoulissT31) typ).cooling.setState(getBitState(sVal, 2));
                    ((SoulissT31) typ).fanLow.setState(getBitState(sVal, 3));
                    ((SoulissT31) typ).fanMed.setState(getBitState(sVal, 4));
                    ((SoulissT31) typ).fanHigh.setState(getBitState(sVal, 5));
                    ((SoulissT31) typ).fanAutoMode.setState(getBitState(sVal, 6));
                    ((SoulissT31) typ).heatingCoolingModeValue.setState(getBitState(sVal, 7));
                    // SLOT 1-2: Temperature Measured Value
                    val = getFloatAtSlot(mac, slot + 1);
                    ((SoulissT31) typ).setMeasuredValue(val);
                    // SLOT 3-4: Temperature Setpoint Value
                    val = getFloatAtSlot(mac, slot + 3);
                    ((SoulissT31) typ).setSetpointValue(val);
                    bDecoded_forLOG = true;
                }
                // inserito in un altro punto del codice
                if (typ.getType() != 152 && typ.getType() != 153)
                    if (iNumBytes == 4)
                        // RGB Log
                        logger.debug("decodeStateRequest: {} ({}) = {}. RGB= {}, {}, {}", typ.getName(), Short.valueOf(typ.getType()), ((SoulissT16) typ).getState(), ((SoulissT16) typ).getStateRED(), ((SoulissT16) typ).getStateGREEN(), ((SoulissT16) typ).getStateBLU());
                    else if (iNumBytes == 5) {
                        // T31 Thermostat
                        logger.debug("decodeStateRequest: {} ({}). Thermostat= {}, Temp.Measured= {}, Temp.SetPoint= {}", typ.getName(), Short.valueOf(typ.getType()), ((SoulissT31) typ).getRawCommandState(), ((SoulissT31) typ).getTemperatureMeasuredValue(), ((SoulissT31) typ).getSetpointValue());
                    } else if (bDecoded_forLOG) {
                        if (typ.getType() == 0x1A) {
                            logger.debug("decodeStateRequest: {} (0x{}) = {}", typ.getName(), Integer.toHexString(typ.getType()), Integer.toBinaryString(((SoulissT1A) typ).getRawState()));
                        } else
                            logger.debug("decodeStateRequest: {} (0x{}) = {}", typ.getName(), Integer.toHexString(typ.getType()), Float.valueOf(val));
                    }
            }
        }
    }
}

Example 2 with SoulissGenericTypical

use of org.openhab.binding.souliss.internal.network.typicals.SoulissGenericTypical in project openhab1-addons by openhab.

the class SoulissBinding method receiveCommand.

@Override
public /**
     * Get the souliss's typical from the hash table and send a command
     *
     * @author Tonino Fazio
     * @since 1.7.0
     */
void receiveCommand(String itemName, Command command) {
    // Get the typical defined in the hash table
    SoulissGenericTypical T = SoulissGenericBindingProvider.SoulissTypicalsRecipients.getTypicalFromItem(itemName);
    logger.info("receiveCommand - {} = {} - Typical: 0x{}", itemName, command, Integer.toHexString(T.getType()));
    switch(T.getType()) {
        case Constants.Souliss_T11:
            SoulissT11 T11 = (SoulissT11) T;
            T11.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), command.toString()));
            break;
        case Constants.Souliss_T12:
            SoulissT12 T12 = (SoulissT12) T;
            if (itemName.equals(T12.getsItemNameAutoModeValue())) {
                T12.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), Constants.Souliss_T12_Use_Of_Slot_AUTOMODE + "_" + command.toString()));
            } else if (itemName.equals(T12.getsItemNameSwitchValue())) {
                T12.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), Constants.Souliss_T12_Use_Of_Slot_SWITCH + "_" + command.toString()));
            }
            break;
        case Constants.Souliss_T14:
            SoulissT14 T14 = (SoulissT14) T;
            T14.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), command.toString()));
            break;
        case Constants.Souliss_T18:
            SoulissT18 T18 = (SoulissT18) T;
            T18.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), command.toString()));
            break;
        case Constants.Souliss_T16:
            SoulissT16 T16 = (SoulissT16) T;
            String cmd = command.getClass().getSimpleName();
            if (cmd.equals(Constants.Openhab_RGB_TYPE)) {
                String[] HSB = command.toString().split(",");
                short[] RGB = HSBtoRGB(Float.parseFloat(HSB[0]), Float.parseFloat(HSB[1]), Float.parseFloat(HSB[2]));
                T16.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), command.getClass().getSimpleName()), RGB[0], RGB[1], RGB[2]);
            } else {
                T16.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), command.toString()));
            }
            break;
        case Constants.Souliss_T19:
            SoulissT19 T19 = (SoulissT19) T;
            if (command instanceof PercentType) {
                int percentToShort = (((PercentType) command).shortValue() * 254 / 100);
                T19.commandSEND(Constants.Souliss_T1n_Set, Short.parseShort(String.valueOf(percentToShort)));
            } else if (command instanceof DecimalType) {
                int decimalToShort = (((DecimalType) command).shortValue() * 254 / 100);
                T19.commandSEND(Constants.Souliss_T1n_Set, Short.parseShort(String.valueOf(decimalToShort)));
            } else {
                T19.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), command.toString()));
            }
            break;
        case Constants.Souliss_T21:
            SoulissT21 T21 = (SoulissT21) T;
            T21.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), command.toString()));
            break;
        case Constants.Souliss_T22:
            SoulissT22 T22 = (SoulissT22) T;
            T22.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), command.toString()));
            break;
        case Constants.Souliss_T31:
            SoulissT31 T31 = (SoulissT31) T;
            // Setpoint
            if (itemName.equals(T31.getsItemNameSetpointValue())) {
                if (command instanceof DecimalType) {
                    int uu = HalfFloatUtils.fromFloat(((DecimalType) command).floatValue());
                    byte B2 = (byte) (uu >> 8);
                    byte B1 = (byte) uu;
                    // setpoint command
                    T31.CommandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), Constants.Souliss_T31_Use_Of_Slot_SETPOINT_COMMAND), B1, B2);
                }
            } else // Set As Measured
            if (itemName.equals(T31.setAsMeasured.getName())) {
                T31.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), Constants.Souliss_T31_Use_Of_Slot_SETASMEASURED + "_" + command.toString()));
            } else if (itemName.equals(T31.heatingCoolingModeValue.getName())) {
                T31.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), Constants.Souliss_T31_Use_Of_Slot_HEATING_COOLING + "_" + command.toString()));
            } else if (itemName.equals(T31.fanAutoMode.getName())) {
                T31.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), Constants.Souliss_T31_Use_Of_Slot_FANAUTOMODE + "_" + command.toString()));
            } else if (itemName.equals(T31.fanOff.getName())) {
                T31.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), Constants.Souliss_T31_Use_Of_Slot_FANOFF + "_" + command.toString()));
            } else if (itemName.equals(T31.fanLow.getName())) {
                T31.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), Constants.Souliss_T31_Use_Of_Slot_FANLOW + "_" + command.toString()));
            } else if (itemName.equals(T31.fanMed.getName())) {
                T31.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), Constants.Souliss_T31_Use_Of_Slot_FANMED + "_" + command.toString()));
            } else if (itemName.equals(T31.fanHigh.getName())) {
                T31.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), Constants.Souliss_T31_Use_Of_Slot_FANHIGH + "_" + command.toString()));
            } else if (itemName.equals(T31.power.getName())) {
                T31.commandSEND(StateTraslator.commandsOHtoSOULISS(T.getType(), Constants.Souliss_T31_Use_Of_Slot_POWER + "_" + command.toString()));
            }
            break;
        default:
            logger.debug("Typical Unknown");
    }
}

Example 3 with SoulissGenericTypical

use of org.openhab.binding.souliss.internal.network.typicals.SoulissGenericTypical in project openhab1-addons by openhab.

the class SoulissGenericBindingProvider method processBindingConfiguration.

/**
     * This method create typicals and add it to hastable
     * 
     * @author Tonino Fazio
     * @since 1.7.0
     */
@Override
public void processBindingConfiguration(String context, Item item, String bindingConfig) throws BindingConfigParseException {
    // Create Souliss Typicals
    //
    // ...from wiki of Dario De Maio
    // In Souliss the logics that drive your lights, curtains, LED, and
    // others are pre-configured into so called Typicals. A Typical is a
    // logic with a predefined set of inputs and outputs and a know
    // behavior, are used to standardize the user interface and have a
    // configuration-less behavior.
    final String itemName = item.getName();
    logger.trace("Starting to load Souliss config for item {}", itemName);
    super.processBindingConfiguration(context, item, bindingConfig);
    String[] sNameArray = bindingConfig.split("\\:");
    String sTypical = sNameArray[0];
    int iNodeID = Integer.parseInt(sNameArray[1]);
    int iSlot = Integer.parseInt(sNameArray[2]);
    byte iBit = 0;
    String sUseSlot = "";
    // parametro
    if (sNameArray.length > 3) {
        if ((StateTraslator.stringToSOULISSTypicalCode(sTypical) == Constants.Souliss_T31) || (StateTraslator.stringToSOULISSTypicalCode(sTypical) == Constants.Souliss_T12)) {
            sUseSlot = sNameArray[3];
        } else {
            iBit = Byte.parseByte(sNameArray[3]);
        }
    }
    String sNote = item.getClass().getSimpleName();
    SoulissGenericTypical soulissTypicalNew = null;
    // Tipico Souliss
    if ((StateTraslator.stringToSOULISSTypicalCode(sTypical) == Constants.Souliss_T31) || (StateTraslator.stringToSOULISSTypicalCode(sTypical) == Constants.Souliss_T12)) {
        soulissTypicalNew = SoulissTypicalsRecipients.getTypicalFromAddress(iNodeID, iSlot, 0);
        // creazione tipico, solo se non si tratta di un T31 al quale è stato aggiunto un parametro
        if (soulissTypicalNew == null) {
            soulissTypicalNew = TypicalFactory.getClass(StateTraslator.stringToSOULISSTypicalCode(sTypical), SoulissNetworkParameter.datagramsocket, SoulissNetworkParameter.IPAddressOnLAN, iNodeID, iSlot, sNote, iBit, sUseSlot);
        }
        if (soulissTypicalNew != null) {
            // in base al campo use slot inserisco nel tipico il nome item di riferimento
            switch(sUseSlot) {
                case Constants.Souliss_T12_Use_Of_Slot_AUTOMODE:
                    ((SoulissT12) soulissTypicalNew).setsItemNameAutoModeValue(item.getName());
                    ((SoulissT12) soulissTypicalNew).setsItemTypeAutoModeValue(sNote);
                    break;
                case Constants.Souliss_T12_Use_Of_Slot_SWITCH:
                    ((SoulissT12) soulissTypicalNew).setsItemNameSwitchValue(item.getName());
                    ((SoulissT12) soulissTypicalNew).setsItemTypeSwitchValue(sNote);
                    break;
                case Constants.Souliss_T31_Use_Of_Slot_SETPOINT:
                    ((SoulissT31) soulissTypicalNew).setsItemNameSetpointValue(item.getName());
                    ((SoulissT31) soulissTypicalNew).setsItemTypeSetpointValue(sNote);
                    break;
                case Constants.Souliss_T31_Use_Of_Slot_MEASURED:
                    ((SoulissT31) soulissTypicalNew).setsItemNameMeasuredValue(item.getName());
                    ((SoulissT31) soulissTypicalNew).setsItemTypeMeasuredValue(sNote);
                    break;
                case Constants.Souliss_T31_Use_Of_Slot_SETASMEASURED:
                    ((SoulissT31) soulissTypicalNew).setAsMeasured.setName(item.getName());
                    ((SoulissT31) soulissTypicalNew).setAsMeasured.setNote(sNote);
                    break;
                case Constants.Souliss_T31_Use_Of_Slot_HEATING:
                    ((SoulissT31) soulissTypicalNew).heating.setName(item.getName());
                    ((SoulissT31) soulissTypicalNew).heating.setNote(sNote);
                    break;
                case Constants.Souliss_T31_Use_Of_Slot_COOLING:
                    ((SoulissT31) soulissTypicalNew).cooling.setName(item.getName());
                    ((SoulissT31) soulissTypicalNew).cooling.setNote(sNote);
                    break;
                case Constants.Souliss_T31_Use_Of_Slot_FANOFF:
                    ((SoulissT31) soulissTypicalNew).fanOff.setName(item.getName());
                    ((SoulissT31) soulissTypicalNew).fanOff.setNote(sNote);
                    break;
                case Constants.Souliss_T31_Use_Of_Slot_FANLOW:
                    ((SoulissT31) soulissTypicalNew).fanLow.setName(item.getName());
                    ((SoulissT31) soulissTypicalNew).fanLow.setNote(sNote);
                    break;
                case Constants.Souliss_T31_Use_Of_Slot_FANMED:
                    ((SoulissT31) soulissTypicalNew).fanMed.setName(item.getName());
                    ((SoulissT31) soulissTypicalNew).fanMed.setNote(sNote);
                    break;
                case Constants.Souliss_T31_Use_Of_Slot_FANHIGH:
                    ((SoulissT31) soulissTypicalNew).fanHigh.setName(item.getName());
                    ((SoulissT31) soulissTypicalNew).fanHigh.setNote(sNote);
                    break;
                case Constants.Souliss_T31_Use_Of_Slot_HEATING_COOLING:
                    ((SoulissT31) soulissTypicalNew).heatingCoolingModeValue.setName(item.getName());
                    ((SoulissT31) soulissTypicalNew).heatingCoolingModeValue.setNote(sNote);
                    break;
                case Constants.Souliss_T31_Use_Of_Slot_FANAUTOMODE:
                    ((SoulissT31) soulissTypicalNew).fanAutoMode.setName(item.getName());
                    ((SoulissT31) soulissTypicalNew).fanAutoMode.setNote(sNote);
                    break;
                case Constants.Souliss_T31_Use_Of_Slot_POWER:
                    ((SoulissT31) soulissTypicalNew).power.setName(item.getName());
                    ((SoulissT31) soulissTypicalNew).power.setNote(sNote);
                    break;
            }
            logger.info("Add parameter to T31/T12 : " + sUseSlot);
        }
    }
    // creazione tipico, solo se non si tratta di un T31 / T12 al quale è stato aggiunto un parametro
    if (soulissTypicalNew == null) {
        soulissTypicalNew = TypicalFactory.getClass(StateTraslator.stringToSOULISSTypicalCode(sTypical), SoulissNetworkParameter.datagramsocket, SoulissNetworkParameter.IPAddressOnLAN, iNodeID, iSlot, sNote, iBit, sUseSlot);
    }
    if (soulissTypicalNew != null) {
        SoulissTypicalsRecipients.addTypical(item.getName(), soulissTypicalNew);
        SoulissNetworkParameter.nodes = SoulissTypicalsRecipients.getNodeNumbers();
    }
}

Example 4 with SoulissGenericTypical

use of org.openhab.binding.souliss.internal.network.typicals.SoulissGenericTypical in project openhab1-addons by openhab.

the class SendDispatcher method safeSendCheck.

/**
     * check frame updates with packetList, where flag "sent" is true. If all
     * commands was executed there delete packet in list. confronta gli
     * aggiornamenti ricevuti con i frame inviati. Se corrispondono cancella il
     * frame nella lista inviati .
     */
public static void safeSendCheck() {
    // scansione lista paccetti inviati
    for (int i = 0; i < packetsList.size(); i++) {
        if (packetsList.get(i).isSent()) {
            int node = getNode(packetsList.get(i).packet);
            int iSlot = 0;
            for (int j = 12; j < packetsList.get(i).packet.getData().length; j++) {
                // controllo lo slot solo se il comando è diverso da ZERO
                if (packetsList.get(i).packet.getData()[j] != 0) {
                    // recupero tipico dalla memoria
                    SoulissGenericTypical typ = soulissTypicalsRecipients.getTypicalFromAddress(node, iSlot, 0);
                    // poi fa il confronto con lo stato attuale
                    if (logger.isDebugEnabled() && typ != null) {
                        String s1 = Integer.toHexString((int) typ.getState());
                        String sStateMemoria = s1.length() < 2 ? "0x0" + s1.toUpperCase() : "0x" + s1.toUpperCase();
                        String sCmd = Integer.toHexString(packetsList.get(i).packet.getData()[j]);
                        sCmd = sCmd.length() < 2 ? "0x0" + sCmd.toUpperCase() : "0x" + sCmd.toUpperCase();
                        logger.debug("Compare. Node: {} Slot: {} Typical: {} Command: {} EXPECTED: {} - IN MEMORY: {}", node, iSlot, Integer.toHexString(typ.getType()), sCmd, expectedState(typ.getType(), packetsList.get(i).packet.getData()[j]), sStateMemoria);
                    }
                    if (typ != null && checkExpectedState((int) typ.getState(), expectedState(typ.getType(), packetsList.get(i).packet.getData()[j]))) {
                        // se il valore del tipico coincide con il valore
                        // trasmesso allora pongo il byte a zero.
                        // quando tutti i byte saranno uguale a zero allora
                        // si
                        // cancella il frame
                        packetsList.get(i).packet.getData()[j] = 0;
                        logger.debug("T{} Node: {} Slot: {} - OK Expected State", Integer.toHexString(typ.getType()), node, iSlot);
                    } else if (typ == null) {
                        // allora se lo slot j-1=0 allora anche j può essere messo a 0
                        if (packetsList.get(i).packet.getData()[j - 1] == 0) {
                            packetsList.get(i).packet.getData()[j] = 0;
                        }
                    }
                }
                iSlot++;
            }
            if (checkAllsSlotZero(packetsList.get(i).packet)) {
                logger.debug("Command packet executed - Removed");
                packetsList.remove(i);
            } else {
                // se il frame non è uguale a zero controllo il TIMEOUT e se
                // è scaduto allora pongo il flag SENT a false
                long t = System.currentTimeMillis();
                if (SoulissNetworkParameter.SECURE_SEND_TIMEOUT_TO_REQUEUE < t - packetsList.get(i).getTime()) {
                    if (SoulissNetworkParameter.SECURE_SEND_TIMEOUT_TO_REMOVE_PACKET < t - packetsList.get(i).getTime()) {
                        logger.info("Packet Execution timeout - Removed");
                        packetsList.remove(i);
                    } else {
                        logger.info("Packet Execution timeout - Requeued");
                        packetsList.get(i).setSent(false);
                    }
                }
            }
        }
    }
}