CYCLES_OF_EEPROM("Speicherzyklen im EEPROM"),
    UNKNOWN_0X21(),
    UNKNOWN_0X22(),
    UNKNOWN_0X23(),
    UNKNOWN_0X24(),
    UNKNOWN_0X25(),
    UNKNOWN_0X26(),
    UNKNOWN_0X27(),
    UNKNOWN_0X28(),
    UNKNOWN_0X29(),
    UNKNOWN_0X2A(),
    UNKNOWN_0X2B(),
    UNKNOWN_0X2C(),
    UNKNOWN_0X2D(),
    UNKNOWN_0X2E(),
    UNKNOWN_0X2F(),
    UNKNOWN_0X30(),
    UNKNOWN_0X31(),
    UNKNOWN_0X32(),
    UNKNOWN_0X33(),
    UNKNOWN_0X34(),
    UNKNOWN_0X35(),
    UNKNOWN_0X36(),
    UNKNOWN_0X37(),
    UNKNOWN_0X38(),
    UNKNOWN_0X39(),
    UNKNOWN_0X3A(),
    UNKNOWN_0X3B(),
    UNKNOWN_0X3C(),
    UNKNOWN_0X3D(),
    UNKNOWN_0X3E(),
    UNKNOWN_0X3F(),
    UNKNOWN_0X40(),
    UNKNOWN_0X41(),
    UNKNOWN_0X42(),
    UNKNOWN_0X43(),
    UNKNOWN_0X44(),
    UNKNOWN_0X45(),
    UNKNOWN_0X46(),
    UNKNOWN_0X47(),
    UNKNOWN_0X48(),
    UNKNOWN_0X49(),
    UNKNOWN_0X4A(),
    UNKNOWN_0X4B(),
    UNKNOWN_0X4C(),
    UNKNOWN_0X4D(),
    UNKNOWN_0X4E(),
    UNKNOWN_0X4F(),
    UNKNOWN_0X50(),
    UNKNOWN_0X51(),
    UNKNOWN_0X52(),
    UNKNOWN_0X53(),
    UNKNOWN_0X54(),
    UNKNOWN_0X55(),
    UNKNOWN_0X56(),
    UNKNOWN_0X57(),
    UNKNOWN_0X58(),
    UNKNOWN_0X59(),
    UNKNOWN_0X5A(),
    UNKNOWN_0X5B(),
    UNKNOWN_0X5C(),
    UNKNOWN_0X5D(),
    UNKNOWN_0X5E(),
    UNKNOWN_0X5F(),
    UNKNOWN_0X60(),
    UNKNOWN_0X61(),
    UNKNOWN_0X62(),
    UNKNOWN_0X63(),
    UNKNOWN_0X64(),
    UNKNOWN_0X65(),
    UNKNOWN_0X66(),
    UNKNOWN_0X67(),
    UNKNOWN_0X68(),
    UNKNOWN_0X69(),
    UNKNOWN_0X6A(),
    UNKNOWN_0X6B(),
    UNKNOWN_0X6C(),
    UNKNOWN_0X6D(),
    UNKNOWN_0X6E(),
    UNKNOWN_0X6F(),
    UNKNOWN_0X70(),
    UNKNOWN_0X71(),
    UNKNOWN_0X72(),
    UNKNOWN_0X73(),
    UNKNOWN_0X74(),
    UNKNOWN_0X75(),
    UNKNOWN_0X76(),
    UNKNOWN_0X77(),
    UNKNOWN_0X78(),
    UNKNOWN_0X79(),
    UNKNOWN_0X7A(),
    UNKNOWN_0X7B(),
    UNKNOWN_0X7C(),
    UNKNOWN_0X7D(),
    UNKNOWN_0X7E(),
    UNKNOWN_0X7F();
    
    public final static VifFC valueOfTableIndex(byte ordinal) {

    public void setValue(int value) {
        this.value = value;
        this.bcdError = null;
    }

    @Override
    protected void accumulateDatatoJSON(JSONObject json) {
        if (!isBcdError()) {
            json.accumulate("data", getValue());
        } else {
            JSONObject jsonBcdError = new JSONObject();
            jsonBcdError.accumulate("bcdErrorCode", getBcdError());
            json.accumulate("data", jsonBcdError);
        }
    }

    @Override
    public void fromJSON(JSONObject json) {
        super.fromJSON(json);
        if (json.get("data") instanceof JSONObject) {
            JSONObject data = json.getJSONObject("data");
            if (data.containsKey("bcdErrorCode")) {
                bcdError = data.getString("bcdErrorCode");
            } else {
                throw new IllegalArgumentException("Unknown value at data: " + data.toString(1));
            }
        } else {
            setValue(json.getInt("data"));

    public void setValue(byte value) {
        this.value = value;
        this.bcdError = null;
    }

    @Override
    protected void accumulateDatatoJSON(JSONObject json) {
        if (!isBcdError()) {
            json.accumulate("data", getValue());
        } else {
            JSONObject jsonBcdError = new JSONObject();
            jsonBcdError.accumulate("bcdErrorCode", getBcdError());
            json.accumulate("data", jsonBcdError);
        }
    }

    @Override
    public void fromJSON(JSONObject json) {
        super.fromJSON(json);
        if (json.get("data") instanceof JSONObject) {
            JSONObject data = json.getJSONObject("data");
            if (data.containsKey("bcdErrorCode")) {
                bcdError = data.getString("bcdErrorCode");
            } else {
                throw new IllegalArgumentException("Unknown value at data: " + data.toString(1));
            }
        } else {
            setValue((byte) json.getInt("data"));

    public void setValue(byte value) {
        this.value = value;
        this.bcdError = null;
    }

    @Override
    protected void accumulateDatatoJSON(JSONObject json) {
        if (!isBcdError()) {
            json.accumulate("data", getValue());
        } else {
            JSONObject jsonBcdError = new JSONObject();
            jsonBcdError.accumulate("bcdErrorCode", getBcdError());
            json.accumulate("data", jsonBcdError);
        }
    }

    @Override
    public void fromJSON(JSONObject json) {
        super.fromJSON(json);
        if (json.get("data") instanceof JSONObject) {
            JSONObject data = json.getJSONObject("data");
            if (data.containsKey("bcdErrorCode")) {
                bcdError = data.getString("bcdErrorCode");
            } else {
                throw new IllegalArgumentException("Unknown value at data: " + data.toString(1));
            }
        } else {
            setValue((byte) json.getInt("data"));

    }

    public void setFcb(boolean fcb) {
        this.fcb = fcb;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("control code = ").append(getControlCode()).append('\n');
        sb.append("isFcb = ").append(isFcb()).append('\n');
        sb.append(String.format("address = 0x%02X\n", address));

    }

    /**
     * @return the exponent
     */
    @Override
    public Integer getExponent() {
        return exponent;
    }

    @Override
    public String getLabel() {
        return label;
    }

    /**
     * @return the siPrefix
     */
    @Override
    public SiPrefix getSiPrefix() {
        return siPrefix;
    }

    public byte getTableIndex() {
        return (byte) ordinal();
    }

    /**
     * @return the unit
     */
    @Override
    public UnitOfMeasurement getUnitOfMeasurement() {
        return unit;
    }

    @Override
    public String toString() {
        return VifToString.vifToString(this);
    }

    public static VifFB assemble(String label, UnitOfMeasurement unitOfMeasurement, SiPrefix siPrefix, Integer exponent) {

        return sb.toString();
    }

    @Override
    public JSONObject toJSON(JsonSerializeType jsonSerializeType) {
        JSONObject result = new JSONObject();
        result.accumulate("controlCode",
                getControlCode());
        result.accumulate("subType", SEND_USER_DATA_SUBTYPE);

        if (JsonSerializeType.ALL == jsonSerializeType) {
            result.accumulate("fcb",
                    isFcb());
            result.accumulate("address", address & 0xFF);
        }

    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("control code = ").append(getControlCode()).append('\n');
        sb.append("isFcb = ").append(isFcb()).append('\n');
        sb.append(String.format("address = 0x%02X\n", address));
        sb.append("telegramType = ").append(getTelegramType()).append('\n');

            setValue((byte) json.getInt("data"));
        }
    }

    /**
     * @return the bcdError
     */
    @Override
    public String getBcdError() {
        return bcdError;
    }

    /**
     * @param bcdError the bcdError to set
     */
    @Override
    public void setBcdError(String bcdError) {
        this.bcdError = formatBcdError(bcdError);
        this.value = 0;
    }

    @Override
    public void setValue(String text) {
        try {
            value = Byte.parseByte(text);

    public byte getValue() {
        if (isBcdError()) {
            throw new IllegalArgumentException("No value BCD Error: " + bcdError);
        } else {
            return value;
        }
    }

    @Override
    public String getValueAsString() {
        if (bcdError != null) {
            return bcdError;
        }
        switch (getDataFieldCode()) {
            case _8_BIT_INTEGER:

        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final SerialPortConnection other = (SerialPortConnection) obj;

    private VifFC(String label) {
        this.label = label;
    }

    @Override
    public String getLabel() {
        return label;
    }

    public byte getTableIndex() {
        return (byte) ordinal();
    }

    @Override
    public String toString() {
        return label;
    }

    public static VifFC assemble(String label) {

                }

                sb.append(" [");
                if (getSiPrefix() != null) {
                    sb.append(getSiPrefix());
                }
                sb.append(getUnitOfMeasurement()).append("]\n");
            } else {
                sb.append("\n");
            }

    }

    /**
     * @param acd the acd to set
     */
    public void setAcd(boolean acd) {
        this.acd = acd;
    }

    /**
     * @param address the address to set
     */
    @Override
    public void setAddress(byte address) {
        this.address = address;
    }

    /**
     * @param dcf the dfc to set
     */
    public void setDfc(boolean dfc) {
        this.dfc = dfc;
    }

    public void setError(byte b) {

        sb.append(String.format("baudrate = %d\n", baudrate));

        return sb.toString();
    }

    @Override
    public JSONObject toJSON(JsonSerializeType jsonSerializeType) {
        JSONObject result = new JSONObject();
        result.accumulate("controlCode",
                getControlCode());
        result.accumulate("subType", SEND_USER_DATA_SUBTYPE);

        if (jsonSerializeType.ALL == jsonSerializeType) {

        out.writeInt(responseTimeOutOffset);
    }

    private void readObject(ObjectInputStream in) throws IOException {
        int ver = in.readInt();
        switch (ver) {
            case 1:
                readObjectVer1(in);
                break;
        }
    }

    private void readObjectVer1(ObjectInputStream in) throws IOException {

        TelegramType(int id, String label) {
            this.id = (byte) id;
            this.label = label;
        }

        @Override
        public String toString() {
            return label;
        }

        public String getLabel() {
            return label;
        }

        public static TelegramType fromLabel(String label) {

    }

    @Override
    public Iterator<DataBlock> iterator() {
        return dataBlocks.iterator();
    }

    @Override
    public void replaceDataBlock(DataBlock oldDataBlock, DataBlock newDataBlock) {
        final int pos = dataBlocks.indexOf(oldDataBlock);
        dataBlocks.remove(pos);

        return sb.toString();
    }

    @Override
    public JSONObject toJSON(JsonSerializeType jsonSerializeType) {
        JSONObject result = new JSONObject();
        result.accumulate("controlCode",
                getControlCode());
        result.accumulate("subType", SEND_USER_DATA_SUBTYPE);

        if (JsonSerializeType.ALL == jsonSerializeType) {

        int result = 0;

        for (int i = stackPos - 1; i >= (stackPos - bytes); i--) {
            result <<= 8;
            result += (data[i] & 0xFF);
        }

        stackPos -= bytes;

        return result;
    }

    public long popLong() {

                if (((IntegerDataBlock) db).isBcdError()) {
                    pushBcdError(((BcdValue) db).getBcdError());
                } else {
                    pushBcd(((IntegerDataBlock) db).getValue(), 6);

    public byte getValue() {
        if (isBcdError()) {
            throw new IllegalArgumentException("No value BCD Error: " + bcdError);
        } else {
            return value;
        }
    }

    @Override
    public String getValueAsString() {
        if (bcdError != null) {
            return bcdError;

                Vife vife = new VifeManufacturerSpecific(b);

                if (vifes == null) {
                    vifes = new Vife[1];
                } else {
                    vifes = Arrays.copyOf(vifes, vifes.length + 1);
                }
                vifes[vifes.length - 1] = vife;

                if (vifes == null) {
                    vifes = new Vife[1];
                } else {
                    vifes = Arrays.copyOf(vifes, vifes.length + 1);
                }
                vifes[vifes.length - 1] = vife;

    }

    @Override
    public JSONObject toJSON(JsonSerializeType jsonSerializeType) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void fromJSON(JSONObject json) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
}

        super(DataFieldCode._32_BIT_INTEGER, vif, vifes);
    }

    /**
     * @return the value
     */
    public Date getValue() {
        return value;
    }

    @Override
    public String getValueAsString() {
        return ISO_8601.get().format(value);
    }

    /**
     * @return the res1
     */
    public boolean isRes1() {

        for (VifTypes value : values()) {
            if (value.getLabel().equals(label)) {
                return value;
            }
        }
        return valueOf(label);
    }

    private final String label;

    private VifTypes(String label) {

        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public byte getAddress() {
        return address;
    }

    @Override
    public ControlCode getControlCode() {
        return ControlCode.SND_UD;
    }

    @Override
    public DataBlock getLastDataBlock() {

            result.accumulate("baudrate", baudrate);
        }

        return result;
    }

    @Override
    public void fromJSON(JSONObject json) {
        fcb = json.getBoolean("fcb");
        address = (byte) json.getInt("address");

    private VifFB(String label, SiPrefix siPrefix, UnitOfMeasurement unit, int exponent) {
        this.label = label;
        this.siPrefix = siPrefix;
        this.unit = unit;
        this.exponent = exponent;

    private VifPrimary(int vifCode, String label) {
        if (this.ordinal() != vifCode) {
            throw new IllegalArgumentException("ordinal and vifCode mismatch!");
        }
        this.label = label;
        this.siPrefix = null;
        this.unit = null;

    public static double getVifeCorrectionFactor(Vife[] vifes) {
        for (Vife vife : vifes) {
            if (vife instanceof VifePrimary) {
                switch ((VifePrimary)vife) {
                    case FACTOR_E__6: return 0.000001;

    @Override
    public JSONObject toJSON(JsonSerializeType jsonSerializeType) {
        JSONObject result = new JSONObject();
        result.accumulate("controlCode",
                getControlCode());
        result.accumulate("subType", SEND_USER_DATA_SUBTYPE);

        return sb.toString();
    }

    @Override
    public JSONObject toJSON(JsonSerializeType jsonSerializeType) {
        JSONObject result = new JSONObject();
        result.accumulate("controlCode", getControlCode().getLabel());

        for (MBusAddressing value : values()) {
            if (value.getLabel().equals(label)) {
                return value;
            }
        }
        return valueOf(label);
    }
}

        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void setAddress(byte address) {
        this.address = address;
    }

    public void setFcb(boolean fcb) {
        this.fcb = fcb;
    }

    public static double getVifeCorrectionFactor(Vife[] vifes) {
        for (Vife vife : vifes) {
            if (vife instanceof VifePrimary) {
                switch ((VifePrimary)vife) {
                    case FACTOR_E__6: return 0.000001;

                objectAction = ObjectAction.valueOf(b);

                break;

            default:
                setState(DecodeState.ERROR);
                throw new NotSupportedException(String.format(
                        "Dont know how to handele Control code %s ",
                        frame.getControlCode()));
        }