You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2021/11/30 12:38:11 UTC

[plc4x] 02/02: feat(bacnet): implement BACnetTagApplicationDate and BACnetTagApplicationTime

This is an automated email from the ASF dual-hosted git repository.

sruehl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git

commit f19d8f79f77ff18d356e858974396c785aa4042e
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Tue Nov 30 13:38:00 2021 +0100

    feat(bacnet): implement BACnetTagApplicationDate and BACnetTagApplicationTime
    
    + fixed golang not propagating virtual fields
    + fixed virtual field assignment with field indirection
---
 .../language/go/GoLanguageTemplateHelper.java      |  24 +--
 .../resources/templates/go/model-template.go.ftlh  |   6 +-
 .../bacnetip/readwrite/model/BACnetComplexTag.go   |   9 +-
 .../readwrite/model/BACnetComplexTagBitString.go   |  10 +-
 .../model/BACnetComplexTagCharacterString.go       |  10 +-
 .../readwrite/model/BACnetComplexTagDate.go        | 165 +++++++++++++++++++-
 .../readwrite/model/BACnetComplexTagEnumerated.go  |   8 +-
 .../readwrite/model/BACnetComplexTagOctetString.go |   8 +-
 .../model/BACnetComplexTagSignedInteger.go         |  16 +-
 .../readwrite/model/BACnetComplexTagTime.go        | 125 ++++++++++++++-
 .../model/BACnetComplexTagUnsignedInteger.go       |  16 +-
 .../plc4go/bacnetip/readwrite/model/BACnetTag.go   |   9 +-
 .../model/BACnetTagApplicationCharacterString.go   |  10 +-
 .../readwrite/model/BACnetTagApplicationDate.go    | 173 ++++++++++++++++++++-
 .../model/BACnetTagApplicationOctetString.go       |   8 +-
 .../model/BACnetTagApplicationSignedInteger.go     |  16 +-
 .../readwrite/model/BACnetTagApplicationTime.go    | 125 ++++++++++++++-
 .../model/BACnetTagApplicationUnsignedInteger.go   |  16 +-
 ...UnconfirmedServiceRequestTimeSynchronization.go |  69 +++++++-
 .../resources/protocols/bacnetip/bacnetip.mspec    |  49 ++++++
 20 files changed, 797 insertions(+), 75 deletions(-)

diff --git a/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java b/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
index 9a294ad..492fb35 100644
--- a/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
+++ b/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
@@ -360,16 +360,16 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
     }
 
     public String getWriteBufferWriteMethodCall(String logicalName, SimpleTypeReference simpleTypeReference, Term valueTerm, TypedField field, String... writerArgs) {
-        if(valueTerm instanceof BooleanLiteral) {
+        if (valueTerm instanceof BooleanLiteral) {
             return getWriteBufferWriteMethodCall(logicalName, simpleTypeReference, Boolean.toString(((BooleanLiteral) valueTerm).getValue()), field, writerArgs);
         }
-        if(valueTerm instanceof NumericLiteral) {
+        if (valueTerm instanceof NumericLiteral) {
             return getWriteBufferWriteMethodCall(logicalName, simpleTypeReference, ((NumericLiteral) valueTerm).getNumber().toString(), field, writerArgs);
         }
-        if(valueTerm instanceof HexadecimalLiteral) {
+        if (valueTerm instanceof HexadecimalLiteral) {
             return getWriteBufferWriteMethodCall(logicalName, simpleTypeReference, ((HexadecimalLiteral) valueTerm).getHexString(), field, writerArgs);
         }
-        if(valueTerm instanceof StringLiteral) {
+        if (valueTerm instanceof StringLiteral) {
             return getWriteBufferWriteMethodCall(logicalName, simpleTypeReference, "\"" + ((StringLiteral) valueTerm).getValue() + "\"", field, writerArgs);
         }
         throw new RuntimeException("Outputting " + valueTerm.toString() + " not implemented yet. Please continue defining other types in the GoLanguageHelper.getWriteBufferWriteMethodCall.");
@@ -558,13 +558,14 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
         Term a = binaryTerm.getA();
         Term b = binaryTerm.getB();
         String operation = binaryTerm.getOperation();
+        String castExpressionForTypeReference = getCastExpressionForTypeReference(fieldType);
         switch (operation) {
             case "^":
                 tracer = tracer.dive("^");
                 emitRequiredImport("math");
                 return tracer + "Math.pow(" +
-                    getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) + "), " +
-                    getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false) + "))";
+                    castExpressionForTypeReference + "(" + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) + "), " +
+                    castExpressionForTypeReference + "(" + toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false) + "))";
             // If we start casting for comparisons, equals or non equals, really messy things happen.
             case "==":
             case "!=":
@@ -577,9 +578,9 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
                 // Except for doing a nil or not-nil check :-(
                 // So in case of such a check, we need to suppress the pointer-access.
                 boolean suppressPointerAccessOverride = (operation.equals("==") || operation.equals("!=")) && ((a instanceof NullLiteral) || (b instanceof NullLiteral));
-                return tracer + "bool((" + toExpression(field, null, a, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride) + ") " +
-                    operation +
-                    " (" + toExpression(field, null, b, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride) + "))";
+                String aExpression = toExpression(field, null, a, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride);
+                String bExpression = toExpression(field, null, b, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride);
+                return tracer + "bool((" + aExpression + ") " + operation + " (" + bExpression + "))";
             default:
                 tracer = tracer.dive("default");
                 if (fieldType instanceof StringTypeReference) {
@@ -588,9 +589,10 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
                         operation + " " +
                         toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false);
                 }
-                return tracer + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) + ") " +
+                return tracer +
+                    castExpressionForTypeReference + "(" + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) + ") " +
                     operation + " " +
-                    getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false) + ")";
+                    castExpressionForTypeReference + "(" + toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false) + ")";
         }
     }
 
diff --git a/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh b/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh
index a5981b2..356592b 100644
--- a/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh
+++ b/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh
@@ -1085,7 +1085,8 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa
 				<#assign virtualField = field.asVirtualField().orElseThrow()>
 
 	// Virtual field
-	${virtualField.name} := ${helper.toParseExpression(virtualField, virtualField.type, virtualField.valueExpression, parserArguments)}
+	_${virtualField.name} := ${helper.toParseExpression(virtualField, virtualField.type, virtualField.valueExpression, parserArguments)}
+	${virtualField.name} := ${helper.getLanguageTypeNameForTypeReference(virtualField.type)}(_${virtualField.name})
 				<#break>
 		</#switch>
 	</#list>
@@ -1104,6 +1105,9 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa
 		<#list type.propertyFields as field>
 		${field.name?cap_first}: <#if helper.isComplex(field) && !helper.isEnumField(field) && !field.isArrayField()>Cast${helper.getLanguageTypeNameForField(field)}(</#if>${field.name}<#if helper.isComplex(field) && !helper.isEnumField(field) && !field.isArrayField()>)</#if>,
 		</#list>
+        <#list type.virtualFields as field>
+            ${field.name?cap_first}: <#if helper.isComplex(field) && !helper.isEnumField(field) && !field.isArrayField()>Cast${helper.getLanguageTypeNameForField(field)}(</#if>${field.name}<#if helper.isComplex(field) && !helper.isEnumField(field) && !field.isArrayField()>)</#if>,
+        </#list>
 		Parent: &${type.parentType.name}{},
 	}
 	_child.Parent.Child = _child
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTag.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTag.go
index 112b8b9..6068e88 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTag.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTag.go
@@ -169,10 +169,12 @@ func BACnetComplexTagParse(readBuffer utils.ReadBuffer, tagNumberArgument uint8,
 	}
 
 	// Virtual field
-	actualTagNumber := utils.InlineIf(bool((tagNumber) < (15)), func() interface{} { return uint8(tagNumber) }, func() interface{} { return uint8((*extTagNumber)) }).(uint8)
+	_actualTagNumber := utils.InlineIf(bool((tagNumber) < (15)), func() interface{} { return uint8(tagNumber) }, func() interface{} { return uint8((*extTagNumber)) }).(uint8)
+	actualTagNumber := uint8(_actualTagNumber)
 
 	// Virtual field
-	isPrimitiveAndNotBoolean := bool(!(bool(bool((lengthValueType) == (6))))) && bool(bool((tagNumber) != (1)))
+	_isPrimitiveAndNotBoolean := bool(!(bool(bool((lengthValueType) == (6))))) && bool(bool((tagNumber) != (1)))
+	isPrimitiveAndNotBoolean := bool(_isPrimitiveAndNotBoolean)
 
 	// Optional Field (extLength) (Can be skipped, if a given expression evaluates to false)
 	var extLength *uint8 = nil
@@ -205,13 +207,14 @@ func BACnetComplexTagParse(readBuffer utils.ReadBuffer, tagNumberArgument uint8,
 	}
 
 	// Virtual field
-	actualLength := utils.InlineIf(bool(bool((lengthValueType) == (5))) && bool(bool((*extLength) == (255))), func() interface{} { return uint32((*extExtExtLength)) }, func() interface{} {
+	_actualLength := utils.InlineIf(bool(bool((lengthValueType) == (5))) && bool(bool((*extLength) == (255))), func() interface{} { return uint32((*extExtExtLength)) }, func() interface{} {
 		return uint32(uint32(utils.InlineIf(bool(bool((lengthValueType) == (5))) && bool(bool((*extLength) == (254))), func() interface{} { return uint32((*extExtLength)) }, func() interface{} {
 			return uint32(uint32(utils.InlineIf(bool((lengthValueType) == (5)), func() interface{} { return uint32((*extLength)) }, func() interface{} {
 				return uint32(uint32(utils.InlineIf(isPrimitiveAndNotBoolean, func() interface{} { return uint32(lengthValueType) }, func() interface{} { return uint32(uint32(0)) }).(uint32)))
 			}).(uint32)))
 		}).(uint32)))
 	}).(uint32)
+	actualLength := uint32(_actualLength)
 
 	// Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
 	var _parent *BACnetComplexTag
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagBitString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagBitString.go
index fb68445..7922d9a 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagBitString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagBitString.go
@@ -121,7 +121,8 @@ func BACnetComplexTagBitStringParse(readBuffer utils.ReadBuffer, tagNumberArgume
 	}
 
 	// Virtual field
-	actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+	_actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+	actualLengthInBit := uint16(_actualLengthInBit)
 
 	// Simple Field (unusedBits)
 	unusedBits, _unusedBitsErr := readBuffer.ReadUint8("unusedBits", 8)
@@ -154,9 +155,10 @@ func BACnetComplexTagBitStringParse(readBuffer utils.ReadBuffer, tagNumberArgume
 
 	// Create a partially initialized instance
 	_child := &BACnetComplexTagBitString{
-		UnusedBits: unusedBits,
-		Data:       data,
-		Parent:     &BACnetComplexTag{},
+		UnusedBits:        unusedBits,
+		Data:              data,
+		ActualLengthInBit: actualLengthInBit,
+		Parent:            &BACnetComplexTag{},
 	}
 	_child.Parent.Child = _child
 	return _child.Parent, nil
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagCharacterString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagCharacterString.go
index c074ead..e727618 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagCharacterString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagCharacterString.go
@@ -131,7 +131,8 @@ func BACnetComplexTagCharacterStringParse(readBuffer utils.ReadBuffer, tagNumber
 	}
 
 	// Virtual field
-	actualLengthInBit := uint16(uint16(actualLength)*uint16(uint16(8))) - uint16(uint16(8))
+	_actualLengthInBit := uint16(uint16(actualLength)*uint16(uint16(8))) - uint16(uint16(8))
+	actualLengthInBit := uint16(_actualLengthInBit)
 
 	// Simple Field (value)
 	value, _valueErr := readBuffer.ReadString("value", uint32(actualLengthInBit))
@@ -145,9 +146,10 @@ func BACnetComplexTagCharacterStringParse(readBuffer utils.ReadBuffer, tagNumber
 
 	// Create a partially initialized instance
 	_child := &BACnetComplexTagCharacterString{
-		Encoding: encoding,
-		Value:    value,
-		Parent:   &BACnetComplexTag{},
+		Encoding:          encoding,
+		Value:             value,
+		ActualLengthInBit: actualLengthInBit,
+		Parent:            &BACnetComplexTag{},
 	}
 	_child.Parent.Child = _child
 	return _child.Parent, nil
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagDate.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagDate.go
index a586d3f..9153b9d 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagDate.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagDate.go
@@ -21,13 +21,28 @@ package model
 
 import (
 	"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+	"github.com/pkg/errors"
 )
 
 // Code generated by code-generation. DO NOT EDIT.
 
 // The data-structure of this message
 type BACnetComplexTagDate struct {
-	Parent *BACnetComplexTag
+	YearMinus1900          int8
+	Month                  int8
+	DayOfMonth             int8
+	DayOfWeek              int8
+	Wildcard               int8
+	YearIsWildcard         bool
+	MonthIsWildcard        bool
+	OddMonthWildcard       bool
+	EvenMonthWildcard      bool
+	DayOfMonthIsWildcard   bool
+	LastDayOfMonthWildcard bool
+	OddDayOfMonthWildcard  bool
+	EvenDayOfMonthWildcard bool
+	DayOfWeekIsWildcard    bool
+	Parent                 *BACnetComplexTag
 }
 
 // The corresponding interface
@@ -54,9 +69,13 @@ func (m *BACnetComplexTagDate) InitializeParent(parent *BACnetComplexTag, tagNum
 	m.Parent.ExtExtExtLength = extExtExtLength
 }
 
-func NewBACnetComplexTagDate(tagNumber uint8, tagClass TagClass, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetComplexTag {
+func NewBACnetComplexTagDate(yearMinus1900 int8, month int8, dayOfMonth int8, dayOfWeek int8, tagNumber uint8, tagClass TagClass, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetComplexTag {
 	child := &BACnetComplexTagDate{
-		Parent: NewBACnetComplexTag(tagNumber, tagClass, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
+		YearMinus1900: yearMinus1900,
+		Month:         month,
+		DayOfMonth:    dayOfMonth,
+		DayOfWeek:     dayOfWeek,
+		Parent:        NewBACnetComplexTag(tagNumber, tagClass, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
 	}
 	child.Parent.Child = child
 	return child.Parent
@@ -92,6 +111,38 @@ func (m *BACnetComplexTagDate) LengthInBits() uint16 {
 func (m *BACnetComplexTagDate) LengthInBitsConditional(lastItem bool) uint16 {
 	lengthInBits := uint16(m.Parent.ParentLengthInBits())
 
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (yearMinus1900)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (month)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
+	// A virtual field doesn't have any in- or output.
+
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (dayOfMonth)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
+	// A virtual field doesn't have any in- or output.
+
+	// A virtual field doesn't have any in- or output.
+
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (dayOfWeek)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
 	return lengthInBits
 }
 
@@ -104,13 +155,91 @@ func BACnetComplexTagDateParse(readBuffer utils.ReadBuffer, tagNumberArgument ui
 		return nil, pullErr
 	}
 
+	// Virtual field
+	_wildcard := 0xFF
+	wildcard := int8(_wildcard)
+
+	// Simple Field (yearMinus1900)
+	yearMinus1900, _yearMinus1900Err := readBuffer.ReadInt8("yearMinus1900", 8)
+	if _yearMinus1900Err != nil {
+		return nil, errors.Wrap(_yearMinus1900Err, "Error parsing 'yearMinus1900' field")
+	}
+
+	// Virtual field
+	_yearIsWildcard := bool((yearMinus1900) == (wildcard))
+	yearIsWildcard := bool(_yearIsWildcard)
+
+	// Simple Field (month)
+	month, _monthErr := readBuffer.ReadInt8("month", 8)
+	if _monthErr != nil {
+		return nil, errors.Wrap(_monthErr, "Error parsing 'month' field")
+	}
+
+	// Virtual field
+	_monthIsWildcard := bool((month) == (wildcard))
+	monthIsWildcard := bool(_monthIsWildcard)
+
+	// Virtual field
+	_oddMonthWildcard := bool((month) == (13))
+	oddMonthWildcard := bool(_oddMonthWildcard)
+
+	// Virtual field
+	_evenMonthWildcard := bool((month) == (14))
+	evenMonthWildcard := bool(_evenMonthWildcard)
+
+	// Simple Field (dayOfMonth)
+	dayOfMonth, _dayOfMonthErr := readBuffer.ReadInt8("dayOfMonth", 8)
+	if _dayOfMonthErr != nil {
+		return nil, errors.Wrap(_dayOfMonthErr, "Error parsing 'dayOfMonth' field")
+	}
+
+	// Virtual field
+	_dayOfMonthIsWildcard := bool((dayOfMonth) == (wildcard))
+	dayOfMonthIsWildcard := bool(_dayOfMonthIsWildcard)
+
+	// Virtual field
+	_lastDayOfMonthWildcard := bool((dayOfMonth) == (32))
+	lastDayOfMonthWildcard := bool(_lastDayOfMonthWildcard)
+
+	// Virtual field
+	_oddDayOfMonthWildcard := bool((dayOfMonth) == (33))
+	oddDayOfMonthWildcard := bool(_oddDayOfMonthWildcard)
+
+	// Virtual field
+	_evenDayOfMonthWildcard := bool((dayOfMonth) == (34))
+	evenDayOfMonthWildcard := bool(_evenDayOfMonthWildcard)
+
+	// Simple Field (dayOfWeek)
+	dayOfWeek, _dayOfWeekErr := readBuffer.ReadInt8("dayOfWeek", 8)
+	if _dayOfWeekErr != nil {
+		return nil, errors.Wrap(_dayOfWeekErr, "Error parsing 'dayOfWeek' field")
+	}
+
+	// Virtual field
+	_dayOfWeekIsWildcard := bool((dayOfWeek) == (wildcard))
+	dayOfWeekIsWildcard := bool(_dayOfWeekIsWildcard)
+
 	if closeErr := readBuffer.CloseContext("BACnetComplexTagDate"); closeErr != nil {
 		return nil, closeErr
 	}
 
 	// Create a partially initialized instance
 	_child := &BACnetComplexTagDate{
-		Parent: &BACnetComplexTag{},
+		YearMinus1900:          yearMinus1900,
+		Month:                  month,
+		DayOfMonth:             dayOfMonth,
+		DayOfWeek:              dayOfWeek,
+		Wildcard:               wildcard,
+		YearIsWildcard:         yearIsWildcard,
+		MonthIsWildcard:        monthIsWildcard,
+		OddMonthWildcard:       oddMonthWildcard,
+		EvenMonthWildcard:      evenMonthWildcard,
+		DayOfMonthIsWildcard:   dayOfMonthIsWildcard,
+		LastDayOfMonthWildcard: lastDayOfMonthWildcard,
+		OddDayOfMonthWildcard:  oddDayOfMonthWildcard,
+		EvenDayOfMonthWildcard: evenDayOfMonthWildcard,
+		DayOfWeekIsWildcard:    dayOfWeekIsWildcard,
+		Parent:                 &BACnetComplexTag{},
 	}
 	_child.Parent.Child = _child
 	return _child.Parent, nil
@@ -122,6 +251,34 @@ func (m *BACnetComplexTagDate) Serialize(writeBuffer utils.WriteBuffer) error {
 			return pushErr
 		}
 
+		// Simple Field (yearMinus1900)
+		yearMinus1900 := int8(m.YearMinus1900)
+		_yearMinus1900Err := writeBuffer.WriteInt8("yearMinus1900", 8, (yearMinus1900))
+		if _yearMinus1900Err != nil {
+			return errors.Wrap(_yearMinus1900Err, "Error serializing 'yearMinus1900' field")
+		}
+
+		// Simple Field (month)
+		month := int8(m.Month)
+		_monthErr := writeBuffer.WriteInt8("month", 8, (month))
+		if _monthErr != nil {
+			return errors.Wrap(_monthErr, "Error serializing 'month' field")
+		}
+
+		// Simple Field (dayOfMonth)
+		dayOfMonth := int8(m.DayOfMonth)
+		_dayOfMonthErr := writeBuffer.WriteInt8("dayOfMonth", 8, (dayOfMonth))
+		if _dayOfMonthErr != nil {
+			return errors.Wrap(_dayOfMonthErr, "Error serializing 'dayOfMonth' field")
+		}
+
+		// Simple Field (dayOfWeek)
+		dayOfWeek := int8(m.DayOfWeek)
+		_dayOfWeekErr := writeBuffer.WriteInt8("dayOfWeek", 8, (dayOfWeek))
+		if _dayOfWeekErr != nil {
+			return errors.Wrap(_dayOfWeekErr, "Error serializing 'dayOfWeek' field")
+		}
+
 		if popErr := writeBuffer.PopContext("BACnetComplexTagDate"); popErr != nil {
 			return popErr
 		}
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagEnumerated.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagEnumerated.go
index 856de93..f76b168 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagEnumerated.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagEnumerated.go
@@ -116,7 +116,8 @@ func BACnetComplexTagEnumeratedParse(readBuffer utils.ReadBuffer, tagNumberArgum
 	}
 
 	// Virtual field
-	actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+	_actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+	actualLengthInBit := uint16(_actualLengthInBit)
 
 	// Array field (data)
 	if pullErr := readBuffer.PullContext("data", utils.WithRenderAsList(true)); pullErr != nil {
@@ -143,8 +144,9 @@ func BACnetComplexTagEnumeratedParse(readBuffer utils.ReadBuffer, tagNumberArgum
 
 	// Create a partially initialized instance
 	_child := &BACnetComplexTagEnumerated{
-		Data:   data,
-		Parent: &BACnetComplexTag{},
+		Data:              data,
+		ActualLengthInBit: actualLengthInBit,
+		Parent:            &BACnetComplexTag{},
 	}
 	_child.Parent.Child = _child
 	return _child.Parent, nil
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagOctetString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagOctetString.go
index 418936f..3ba1409 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagOctetString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagOctetString.go
@@ -114,7 +114,8 @@ func BACnetComplexTagOctetStringParse(readBuffer utils.ReadBuffer, tagNumberArgu
 	}
 
 	// Virtual field
-	actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+	_actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+	actualLengthInBit := uint16(_actualLengthInBit)
 
 	// Simple Field (value)
 	value, _valueErr := readBuffer.ReadString("value", uint32(actualLengthInBit))
@@ -128,8 +129,9 @@ func BACnetComplexTagOctetStringParse(readBuffer utils.ReadBuffer, tagNumberArgu
 
 	// Create a partially initialized instance
 	_child := &BACnetComplexTagOctetString{
-		Value:  value,
-		Parent: &BACnetComplexTag{},
+		Value:             value,
+		ActualLengthInBit: actualLengthInBit,
+		Parent:            &BACnetComplexTag{},
 	}
 	_child.Parent.Child = _child
 	return _child.Parent, nil
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagSignedInteger.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagSignedInteger.go
index 42f51c3..db7cc8d 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagSignedInteger.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagSignedInteger.go
@@ -146,7 +146,8 @@ func BACnetComplexTagSignedIntegerParse(readBuffer utils.ReadBuffer, tagNumberAr
 	}
 
 	// Virtual field
-	isInt8 := bool((actualLength) == (1))
+	_isInt8 := bool((actualLength) == (1))
+	isInt8 := bool(_isInt8)
 
 	// Optional Field (valueInt8) (Can be skipped, if a given expression evaluates to false)
 	var valueInt8 *int8 = nil
@@ -159,7 +160,8 @@ func BACnetComplexTagSignedIntegerParse(readBuffer utils.ReadBuffer, tagNumberAr
 	}
 
 	// Virtual field
-	isInt16 := bool((actualLength) == (2))
+	_isInt16 := bool((actualLength) == (2))
+	isInt16 := bool(_isInt16)
 
 	// Optional Field (valueInt16) (Can be skipped, if a given expression evaluates to false)
 	var valueInt16 *int16 = nil
@@ -172,7 +174,8 @@ func BACnetComplexTagSignedIntegerParse(readBuffer utils.ReadBuffer, tagNumberAr
 	}
 
 	// Virtual field
-	isInt32 := bool((actualLength) == (3))
+	_isInt32 := bool((actualLength) == (3))
+	isInt32 := bool(_isInt32)
 
 	// Optional Field (valueInt32) (Can be skipped, if a given expression evaluates to false)
 	var valueInt32 *int32 = nil
@@ -185,7 +188,8 @@ func BACnetComplexTagSignedIntegerParse(readBuffer utils.ReadBuffer, tagNumberAr
 	}
 
 	// Virtual field
-	isInt64 := bool((actualLength) == (4))
+	_isInt64 := bool((actualLength) == (4))
+	isInt64 := bool(_isInt64)
 
 	// Optional Field (valueInt64) (Can be skipped, if a given expression evaluates to false)
 	var valueInt64 *int64 = nil
@@ -207,6 +211,10 @@ func BACnetComplexTagSignedIntegerParse(readBuffer utils.ReadBuffer, tagNumberAr
 		ValueInt16: valueInt16,
 		ValueInt32: valueInt32,
 		ValueInt64: valueInt64,
+		IsInt8:     isInt8,
+		IsInt16:    isInt16,
+		IsInt32:    isInt32,
+		IsInt64:    isInt64,
 		Parent:     &BACnetComplexTag{},
 	}
 	_child.Parent.Child = _child
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagTime.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagTime.go
index b6ba3b2..e8dcc69 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagTime.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagTime.go
@@ -21,13 +21,23 @@ package model
 
 import (
 	"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+	"github.com/pkg/errors"
 )
 
 // Code generated by code-generation. DO NOT EDIT.
 
 // The data-structure of this message
 type BACnetComplexTagTime struct {
-	Parent *BACnetComplexTag
+	Hour                 int8
+	Minute               int8
+	Second               int8
+	Fractional           int8
+	Wildcard             int8
+	HourIsWildcard       bool
+	MinuteIsWildcard     bool
+	SecondIsWildcard     bool
+	FractionalIsWildcard bool
+	Parent               *BACnetComplexTag
 }
 
 // The corresponding interface
@@ -54,9 +64,13 @@ func (m *BACnetComplexTagTime) InitializeParent(parent *BACnetComplexTag, tagNum
 	m.Parent.ExtExtExtLength = extExtExtLength
 }
 
-func NewBACnetComplexTagTime(tagNumber uint8, tagClass TagClass, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetComplexTag {
+func NewBACnetComplexTagTime(hour int8, minute int8, second int8, fractional int8, tagNumber uint8, tagClass TagClass, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetComplexTag {
 	child := &BACnetComplexTagTime{
-		Parent: NewBACnetComplexTag(tagNumber, tagClass, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
+		Hour:       hour,
+		Minute:     minute,
+		Second:     second,
+		Fractional: fractional,
+		Parent:     NewBACnetComplexTag(tagNumber, tagClass, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
 	}
 	child.Parent.Child = child
 	return child.Parent
@@ -92,6 +106,28 @@ func (m *BACnetComplexTagTime) LengthInBits() uint16 {
 func (m *BACnetComplexTagTime) LengthInBitsConditional(lastItem bool) uint16 {
 	lengthInBits := uint16(m.Parent.ParentLengthInBits())
 
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (hour)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (minute)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (second)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (fractional)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
 	return lengthInBits
 }
 
@@ -104,13 +140,66 @@ func BACnetComplexTagTimeParse(readBuffer utils.ReadBuffer, tagNumberArgument ui
 		return nil, pullErr
 	}
 
+	// Virtual field
+	_wildcard := 0xFF
+	wildcard := int8(_wildcard)
+
+	// Simple Field (hour)
+	hour, _hourErr := readBuffer.ReadInt8("hour", 8)
+	if _hourErr != nil {
+		return nil, errors.Wrap(_hourErr, "Error parsing 'hour' field")
+	}
+
+	// Virtual field
+	_hourIsWildcard := bool((hour) == (wildcard))
+	hourIsWildcard := bool(_hourIsWildcard)
+
+	// Simple Field (minute)
+	minute, _minuteErr := readBuffer.ReadInt8("minute", 8)
+	if _minuteErr != nil {
+		return nil, errors.Wrap(_minuteErr, "Error parsing 'minute' field")
+	}
+
+	// Virtual field
+	_minuteIsWildcard := bool((minute) == (wildcard))
+	minuteIsWildcard := bool(_minuteIsWildcard)
+
+	// Simple Field (second)
+	second, _secondErr := readBuffer.ReadInt8("second", 8)
+	if _secondErr != nil {
+		return nil, errors.Wrap(_secondErr, "Error parsing 'second' field")
+	}
+
+	// Virtual field
+	_secondIsWildcard := bool((second) == (wildcard))
+	secondIsWildcard := bool(_secondIsWildcard)
+
+	// Simple Field (fractional)
+	fractional, _fractionalErr := readBuffer.ReadInt8("fractional", 8)
+	if _fractionalErr != nil {
+		return nil, errors.Wrap(_fractionalErr, "Error parsing 'fractional' field")
+	}
+
+	// Virtual field
+	_fractionalIsWildcard := bool((fractional) == (wildcard))
+	fractionalIsWildcard := bool(_fractionalIsWildcard)
+
 	if closeErr := readBuffer.CloseContext("BACnetComplexTagTime"); closeErr != nil {
 		return nil, closeErr
 	}
 
 	// Create a partially initialized instance
 	_child := &BACnetComplexTagTime{
-		Parent: &BACnetComplexTag{},
+		Hour:                 hour,
+		Minute:               minute,
+		Second:               second,
+		Fractional:           fractional,
+		Wildcard:             wildcard,
+		HourIsWildcard:       hourIsWildcard,
+		MinuteIsWildcard:     minuteIsWildcard,
+		SecondIsWildcard:     secondIsWildcard,
+		FractionalIsWildcard: fractionalIsWildcard,
+		Parent:               &BACnetComplexTag{},
 	}
 	_child.Parent.Child = _child
 	return _child.Parent, nil
@@ -122,6 +211,34 @@ func (m *BACnetComplexTagTime) Serialize(writeBuffer utils.WriteBuffer) error {
 			return pushErr
 		}
 
+		// Simple Field (hour)
+		hour := int8(m.Hour)
+		_hourErr := writeBuffer.WriteInt8("hour", 8, (hour))
+		if _hourErr != nil {
+			return errors.Wrap(_hourErr, "Error serializing 'hour' field")
+		}
+
+		// Simple Field (minute)
+		minute := int8(m.Minute)
+		_minuteErr := writeBuffer.WriteInt8("minute", 8, (minute))
+		if _minuteErr != nil {
+			return errors.Wrap(_minuteErr, "Error serializing 'minute' field")
+		}
+
+		// Simple Field (second)
+		second := int8(m.Second)
+		_secondErr := writeBuffer.WriteInt8("second", 8, (second))
+		if _secondErr != nil {
+			return errors.Wrap(_secondErr, "Error serializing 'second' field")
+		}
+
+		// Simple Field (fractional)
+		fractional := int8(m.Fractional)
+		_fractionalErr := writeBuffer.WriteInt8("fractional", 8, (fractional))
+		if _fractionalErr != nil {
+			return errors.Wrap(_fractionalErr, "Error serializing 'fractional' field")
+		}
+
 		if popErr := writeBuffer.PopContext("BACnetComplexTagTime"); popErr != nil {
 			return popErr
 		}
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagUnsignedInteger.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagUnsignedInteger.go
index 1151d9b..bd2bab1 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagUnsignedInteger.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagUnsignedInteger.go
@@ -146,7 +146,8 @@ func BACnetComplexTagUnsignedIntegerParse(readBuffer utils.ReadBuffer, tagNumber
 	}
 
 	// Virtual field
-	isUint8 := bool((actualLength) == (1))
+	_isUint8 := bool((actualLength) == (1))
+	isUint8 := bool(_isUint8)
 
 	// Optional Field (valueUint8) (Can be skipped, if a given expression evaluates to false)
 	var valueUint8 *uint8 = nil
@@ -159,7 +160,8 @@ func BACnetComplexTagUnsignedIntegerParse(readBuffer utils.ReadBuffer, tagNumber
 	}
 
 	// Virtual field
-	isUint16 := bool((actualLength) == (2))
+	_isUint16 := bool((actualLength) == (2))
+	isUint16 := bool(_isUint16)
 
 	// Optional Field (valueUint16) (Can be skipped, if a given expression evaluates to false)
 	var valueUint16 *uint16 = nil
@@ -172,7 +174,8 @@ func BACnetComplexTagUnsignedIntegerParse(readBuffer utils.ReadBuffer, tagNumber
 	}
 
 	// Virtual field
-	isUint32 := bool((actualLength) == (3))
+	_isUint32 := bool((actualLength) == (3))
+	isUint32 := bool(_isUint32)
 
 	// Optional Field (valueUint32) (Can be skipped, if a given expression evaluates to false)
 	var valueUint32 *uint32 = nil
@@ -185,7 +188,8 @@ func BACnetComplexTagUnsignedIntegerParse(readBuffer utils.ReadBuffer, tagNumber
 	}
 
 	// Virtual field
-	isUint64 := bool((actualLength) == (4))
+	_isUint64 := bool((actualLength) == (4))
+	isUint64 := bool(_isUint64)
 
 	// Optional Field (valueUint64) (Can be skipped, if a given expression evaluates to false)
 	var valueUint64 *uint64 = nil
@@ -207,6 +211,10 @@ func BACnetComplexTagUnsignedIntegerParse(readBuffer utils.ReadBuffer, tagNumber
 		ValueUint16: valueUint16,
 		ValueUint32: valueUint32,
 		ValueUint64: valueUint64,
+		IsUint8:     isUint8,
+		IsUint16:    isUint16,
+		IsUint32:    isUint32,
+		IsUint64:    isUint64,
 		Parent:      &BACnetComplexTag{},
 	}
 	_child.Parent.Child = _child
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTag.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTag.go
index 89a1e3b..db4529b 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTag.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTag.go
@@ -168,10 +168,12 @@ func BACnetTagParse(readBuffer utils.ReadBuffer) (*BACnetTag, error) {
 	}
 
 	// Virtual field
-	actualTagNumber := utils.InlineIf(bool((tagNumber) < (15)), func() interface{} { return uint8(tagNumber) }, func() interface{} { return uint8((*extTagNumber)) }).(uint8)
+	_actualTagNumber := utils.InlineIf(bool((tagNumber) < (15)), func() interface{} { return uint8(tagNumber) }, func() interface{} { return uint8((*extTagNumber)) }).(uint8)
+	actualTagNumber := uint8(_actualTagNumber)
 
 	// Virtual field
-	isPrimitiveAndNotBoolean := bool(!(bool(bool(bool((tagClass) == (TagClass_CONTEXT_SPECIFIC_TAGS))) && bool(bool((lengthValueType) == (6)))))) && bool(bool((tagNumber) != (1)))
+	_isPrimitiveAndNotBoolean := bool(!(bool(bool(bool((tagClass) == (TagClass_CONTEXT_SPECIFIC_TAGS))) && bool(bool((lengthValueType) == (6)))))) && bool(bool((tagNumber) != (1)))
+	isPrimitiveAndNotBoolean := bool(_isPrimitiveAndNotBoolean)
 
 	// Optional Field (extLength) (Can be skipped, if a given expression evaluates to false)
 	var extLength *uint8 = nil
@@ -204,13 +206,14 @@ func BACnetTagParse(readBuffer utils.ReadBuffer) (*BACnetTag, error) {
 	}
 
 	// Virtual field
-	actualLength := utils.InlineIf(bool(bool((lengthValueType) == (5))) && bool(bool((*extLength) == (255))), func() interface{} { return uint32((*extExtExtLength)) }, func() interface{} {
+	_actualLength := utils.InlineIf(bool(bool((lengthValueType) == (5))) && bool(bool((*extLength) == (255))), func() interface{} { return uint32((*extExtExtLength)) }, func() interface{} {
 		return uint32(uint32(utils.InlineIf(bool(bool((lengthValueType) == (5))) && bool(bool((*extLength) == (254))), func() interface{} { return uint32((*extExtLength)) }, func() interface{} {
 			return uint32(uint32(utils.InlineIf(bool((lengthValueType) == (5)), func() interface{} { return uint32((*extLength)) }, func() interface{} {
 				return uint32(uint32(utils.InlineIf(isPrimitiveAndNotBoolean, func() interface{} { return uint32(lengthValueType) }, func() interface{} { return uint32(uint32(0)) }).(uint32)))
 			}).(uint32)))
 		}).(uint32)))
 	}).(uint32)
+	actualLength := uint32(_actualLength)
 
 	// Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
 	var _parent *BACnetTag
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationCharacterString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationCharacterString.go
index bbd4c9b..6ca4d8f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationCharacterString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationCharacterString.go
@@ -130,7 +130,8 @@ func BACnetTagApplicationCharacterStringParse(readBuffer utils.ReadBuffer, actua
 	}
 
 	// Virtual field
-	actualLengthInBit := uint16(uint16(actualLength)*uint16(uint16(8))) - uint16(uint16(8))
+	_actualLengthInBit := uint16(uint16(actualLength)*uint16(uint16(8))) - uint16(uint16(8))
+	actualLengthInBit := uint16(_actualLengthInBit)
 
 	// Simple Field (value)
 	value, _valueErr := readBuffer.ReadString("value", uint32(actualLengthInBit))
@@ -144,9 +145,10 @@ func BACnetTagApplicationCharacterStringParse(readBuffer utils.ReadBuffer, actua
 
 	// Create a partially initialized instance
 	_child := &BACnetTagApplicationCharacterString{
-		Encoding: encoding,
-		Value:    value,
-		Parent:   &BACnetTag{},
+		Encoding:          encoding,
+		Value:             value,
+		ActualLengthInBit: actualLengthInBit,
+		Parent:            &BACnetTag{},
 	}
 	_child.Parent.Child = _child
 	return _child.Parent, nil
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationDate.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationDate.go
index e8a0406..366bf95 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationDate.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationDate.go
@@ -21,13 +21,29 @@ package model
 
 import (
 	"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+	"github.com/pkg/errors"
 )
 
 // Code generated by code-generation. DO NOT EDIT.
 
 // The data-structure of this message
 type BACnetTagApplicationDate struct {
-	Parent *BACnetTag
+	YearMinus1900          int8
+	Month                  int8
+	DayOfMonth             int8
+	DayOfWeek              int8
+	Wildcard               int8
+	YearIsWildcard         bool
+	Year                   int16
+	MonthIsWildcard        bool
+	OddMonthWildcard       bool
+	EvenMonthWildcard      bool
+	DayOfMonthIsWildcard   bool
+	LastDayOfMonthWildcard bool
+	OddDayOfMonthWildcard  bool
+	EvenDayOfMonthWildcard bool
+	DayOfWeekIsWildcard    bool
+	Parent                 *BACnetTag
 }
 
 // The corresponding interface
@@ -53,9 +69,13 @@ func (m *BACnetTagApplicationDate) InitializeParent(parent *BACnetTag, tagNumber
 	m.Parent.ExtExtExtLength = extExtExtLength
 }
 
-func NewBACnetTagApplicationDate(tagNumber uint8, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetTag {
+func NewBACnetTagApplicationDate(yearMinus1900 int8, month int8, dayOfMonth int8, dayOfWeek int8, tagNumber uint8, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetTag {
 	child := &BACnetTagApplicationDate{
-		Parent: NewBACnetTag(tagNumber, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
+		YearMinus1900: yearMinus1900,
+		Month:         month,
+		DayOfMonth:    dayOfMonth,
+		DayOfWeek:     dayOfWeek,
+		Parent:        NewBACnetTag(tagNumber, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
 	}
 	child.Parent.Child = child
 	return child.Parent
@@ -91,6 +111,40 @@ func (m *BACnetTagApplicationDate) LengthInBits() uint16 {
 func (m *BACnetTagApplicationDate) LengthInBitsConditional(lastItem bool) uint16 {
 	lengthInBits := uint16(m.Parent.ParentLengthInBits())
 
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (yearMinus1900)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (month)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
+	// A virtual field doesn't have any in- or output.
+
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (dayOfMonth)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
+	// A virtual field doesn't have any in- or output.
+
+	// A virtual field doesn't have any in- or output.
+
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (dayOfWeek)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
 	return lengthInBits
 }
 
@@ -103,13 +157,96 @@ func BACnetTagApplicationDateParse(readBuffer utils.ReadBuffer) (*BACnetTag, err
 		return nil, pullErr
 	}
 
+	// Virtual field
+	_wildcard := 0xFF
+	wildcard := int8(_wildcard)
+
+	// Simple Field (yearMinus1900)
+	yearMinus1900, _yearMinus1900Err := readBuffer.ReadInt8("yearMinus1900", 8)
+	if _yearMinus1900Err != nil {
+		return nil, errors.Wrap(_yearMinus1900Err, "Error parsing 'yearMinus1900' field")
+	}
+
+	// Virtual field
+	_yearIsWildcard := bool((yearMinus1900) == (wildcard))
+	yearIsWildcard := bool(_yearIsWildcard)
+
+	// Virtual field
+	_year := int16(yearMinus1900) + int16(int16(1900))
+	year := int16(_year)
+
+	// Simple Field (month)
+	month, _monthErr := readBuffer.ReadInt8("month", 8)
+	if _monthErr != nil {
+		return nil, errors.Wrap(_monthErr, "Error parsing 'month' field")
+	}
+
+	// Virtual field
+	_monthIsWildcard := bool((month) == (wildcard))
+	monthIsWildcard := bool(_monthIsWildcard)
+
+	// Virtual field
+	_oddMonthWildcard := bool((month) == (13))
+	oddMonthWildcard := bool(_oddMonthWildcard)
+
+	// Virtual field
+	_evenMonthWildcard := bool((month) == (14))
+	evenMonthWildcard := bool(_evenMonthWildcard)
+
+	// Simple Field (dayOfMonth)
+	dayOfMonth, _dayOfMonthErr := readBuffer.ReadInt8("dayOfMonth", 8)
+	if _dayOfMonthErr != nil {
+		return nil, errors.Wrap(_dayOfMonthErr, "Error parsing 'dayOfMonth' field")
+	}
+
+	// Virtual field
+	_dayOfMonthIsWildcard := bool((dayOfMonth) == (wildcard))
+	dayOfMonthIsWildcard := bool(_dayOfMonthIsWildcard)
+
+	// Virtual field
+	_lastDayOfMonthWildcard := bool((dayOfMonth) == (32))
+	lastDayOfMonthWildcard := bool(_lastDayOfMonthWildcard)
+
+	// Virtual field
+	_oddDayOfMonthWildcard := bool((dayOfMonth) == (33))
+	oddDayOfMonthWildcard := bool(_oddDayOfMonthWildcard)
+
+	// Virtual field
+	_evenDayOfMonthWildcard := bool((dayOfMonth) == (34))
+	evenDayOfMonthWildcard := bool(_evenDayOfMonthWildcard)
+
+	// Simple Field (dayOfWeek)
+	dayOfWeek, _dayOfWeekErr := readBuffer.ReadInt8("dayOfWeek", 8)
+	if _dayOfWeekErr != nil {
+		return nil, errors.Wrap(_dayOfWeekErr, "Error parsing 'dayOfWeek' field")
+	}
+
+	// Virtual field
+	_dayOfWeekIsWildcard := bool((dayOfWeek) == (wildcard))
+	dayOfWeekIsWildcard := bool(_dayOfWeekIsWildcard)
+
 	if closeErr := readBuffer.CloseContext("BACnetTagApplicationDate"); closeErr != nil {
 		return nil, closeErr
 	}
 
 	// Create a partially initialized instance
 	_child := &BACnetTagApplicationDate{
-		Parent: &BACnetTag{},
+		YearMinus1900:          yearMinus1900,
+		Month:                  month,
+		DayOfMonth:             dayOfMonth,
+		DayOfWeek:              dayOfWeek,
+		Wildcard:               wildcard,
+		YearIsWildcard:         yearIsWildcard,
+		Year:                   year,
+		MonthIsWildcard:        monthIsWildcard,
+		OddMonthWildcard:       oddMonthWildcard,
+		EvenMonthWildcard:      evenMonthWildcard,
+		DayOfMonthIsWildcard:   dayOfMonthIsWildcard,
+		LastDayOfMonthWildcard: lastDayOfMonthWildcard,
+		OddDayOfMonthWildcard:  oddDayOfMonthWildcard,
+		EvenDayOfMonthWildcard: evenDayOfMonthWildcard,
+		DayOfWeekIsWildcard:    dayOfWeekIsWildcard,
+		Parent:                 &BACnetTag{},
 	}
 	_child.Parent.Child = _child
 	return _child.Parent, nil
@@ -121,6 +258,34 @@ func (m *BACnetTagApplicationDate) Serialize(writeBuffer utils.WriteBuffer) erro
 			return pushErr
 		}
 
+		// Simple Field (yearMinus1900)
+		yearMinus1900 := int8(m.YearMinus1900)
+		_yearMinus1900Err := writeBuffer.WriteInt8("yearMinus1900", 8, (yearMinus1900))
+		if _yearMinus1900Err != nil {
+			return errors.Wrap(_yearMinus1900Err, "Error serializing 'yearMinus1900' field")
+		}
+
+		// Simple Field (month)
+		month := int8(m.Month)
+		_monthErr := writeBuffer.WriteInt8("month", 8, (month))
+		if _monthErr != nil {
+			return errors.Wrap(_monthErr, "Error serializing 'month' field")
+		}
+
+		// Simple Field (dayOfMonth)
+		dayOfMonth := int8(m.DayOfMonth)
+		_dayOfMonthErr := writeBuffer.WriteInt8("dayOfMonth", 8, (dayOfMonth))
+		if _dayOfMonthErr != nil {
+			return errors.Wrap(_dayOfMonthErr, "Error serializing 'dayOfMonth' field")
+		}
+
+		// Simple Field (dayOfWeek)
+		dayOfWeek := int8(m.DayOfWeek)
+		_dayOfWeekErr := writeBuffer.WriteInt8("dayOfWeek", 8, (dayOfWeek))
+		if _dayOfWeekErr != nil {
+			return errors.Wrap(_dayOfWeekErr, "Error serializing 'dayOfWeek' field")
+		}
+
 		if popErr := writeBuffer.PopContext("BACnetTagApplicationDate"); popErr != nil {
 			return popErr
 		}
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationOctetString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationOctetString.go
index a2195a3..7a83010 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationOctetString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationOctetString.go
@@ -113,7 +113,8 @@ func BACnetTagApplicationOctetStringParse(readBuffer utils.ReadBuffer, actualLen
 	}
 
 	// Virtual field
-	actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+	_actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+	actualLengthInBit := uint16(_actualLengthInBit)
 
 	// Simple Field (value)
 	value, _valueErr := readBuffer.ReadString("value", uint32(actualLengthInBit))
@@ -127,8 +128,9 @@ func BACnetTagApplicationOctetStringParse(readBuffer utils.ReadBuffer, actualLen
 
 	// Create a partially initialized instance
 	_child := &BACnetTagApplicationOctetString{
-		Value:  value,
-		Parent: &BACnetTag{},
+		Value:             value,
+		ActualLengthInBit: actualLengthInBit,
+		Parent:            &BACnetTag{},
 	}
 	_child.Parent.Child = _child
 	return _child.Parent, nil
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationSignedInteger.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationSignedInteger.go
index 29dcf69..1c49cf0 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationSignedInteger.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationSignedInteger.go
@@ -145,7 +145,8 @@ func BACnetTagApplicationSignedIntegerParse(readBuffer utils.ReadBuffer, actualL
 	}
 
 	// Virtual field
-	isInt8 := bool((actualLength) == (1))
+	_isInt8 := bool((actualLength) == (1))
+	isInt8 := bool(_isInt8)
 
 	// Optional Field (valueInt8) (Can be skipped, if a given expression evaluates to false)
 	var valueInt8 *int8 = nil
@@ -158,7 +159,8 @@ func BACnetTagApplicationSignedIntegerParse(readBuffer utils.ReadBuffer, actualL
 	}
 
 	// Virtual field
-	isInt16 := bool((actualLength) == (2))
+	_isInt16 := bool((actualLength) == (2))
+	isInt16 := bool(_isInt16)
 
 	// Optional Field (valueInt16) (Can be skipped, if a given expression evaluates to false)
 	var valueInt16 *int16 = nil
@@ -171,7 +173,8 @@ func BACnetTagApplicationSignedIntegerParse(readBuffer utils.ReadBuffer, actualL
 	}
 
 	// Virtual field
-	isInt32 := bool((actualLength) == (3))
+	_isInt32 := bool((actualLength) == (3))
+	isInt32 := bool(_isInt32)
 
 	// Optional Field (valueInt32) (Can be skipped, if a given expression evaluates to false)
 	var valueInt32 *int32 = nil
@@ -184,7 +187,8 @@ func BACnetTagApplicationSignedIntegerParse(readBuffer utils.ReadBuffer, actualL
 	}
 
 	// Virtual field
-	isInt64 := bool((actualLength) == (4))
+	_isInt64 := bool((actualLength) == (4))
+	isInt64 := bool(_isInt64)
 
 	// Optional Field (valueInt64) (Can be skipped, if a given expression evaluates to false)
 	var valueInt64 *int64 = nil
@@ -206,6 +210,10 @@ func BACnetTagApplicationSignedIntegerParse(readBuffer utils.ReadBuffer, actualL
 		ValueInt16: valueInt16,
 		ValueInt32: valueInt32,
 		ValueInt64: valueInt64,
+		IsInt8:     isInt8,
+		IsInt16:    isInt16,
+		IsInt32:    isInt32,
+		IsInt64:    isInt64,
 		Parent:     &BACnetTag{},
 	}
 	_child.Parent.Child = _child
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationTime.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationTime.go
index b515287..77b14ab 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationTime.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationTime.go
@@ -21,13 +21,23 @@ package model
 
 import (
 	"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+	"github.com/pkg/errors"
 )
 
 // Code generated by code-generation. DO NOT EDIT.
 
 // The data-structure of this message
 type BACnetTagApplicationTime struct {
-	Parent *BACnetTag
+	Hour                 int8
+	Minute               int8
+	Second               int8
+	Fractional           int8
+	Wildcard             int8
+	HourIsWildcard       bool
+	MinuteIsWildcard     bool
+	SecondIsWildcard     bool
+	FractionalIsWildcard bool
+	Parent               *BACnetTag
 }
 
 // The corresponding interface
@@ -53,9 +63,13 @@ func (m *BACnetTagApplicationTime) InitializeParent(parent *BACnetTag, tagNumber
 	m.Parent.ExtExtExtLength = extExtExtLength
 }
 
-func NewBACnetTagApplicationTime(tagNumber uint8, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetTag {
+func NewBACnetTagApplicationTime(hour int8, minute int8, second int8, fractional int8, tagNumber uint8, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetTag {
 	child := &BACnetTagApplicationTime{
-		Parent: NewBACnetTag(tagNumber, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
+		Hour:       hour,
+		Minute:     minute,
+		Second:     second,
+		Fractional: fractional,
+		Parent:     NewBACnetTag(tagNumber, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
 	}
 	child.Parent.Child = child
 	return child.Parent
@@ -91,6 +105,28 @@ func (m *BACnetTagApplicationTime) LengthInBits() uint16 {
 func (m *BACnetTagApplicationTime) LengthInBitsConditional(lastItem bool) uint16 {
 	lengthInBits := uint16(m.Parent.ParentLengthInBits())
 
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (hour)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (minute)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (second)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
+	// Simple field (fractional)
+	lengthInBits += 8
+
+	// A virtual field doesn't have any in- or output.
+
 	return lengthInBits
 }
 
@@ -103,13 +139,66 @@ func BACnetTagApplicationTimeParse(readBuffer utils.ReadBuffer) (*BACnetTag, err
 		return nil, pullErr
 	}
 
+	// Virtual field
+	_wildcard := 0xFF
+	wildcard := int8(_wildcard)
+
+	// Simple Field (hour)
+	hour, _hourErr := readBuffer.ReadInt8("hour", 8)
+	if _hourErr != nil {
+		return nil, errors.Wrap(_hourErr, "Error parsing 'hour' field")
+	}
+
+	// Virtual field
+	_hourIsWildcard := bool((hour) == (wildcard))
+	hourIsWildcard := bool(_hourIsWildcard)
+
+	// Simple Field (minute)
+	minute, _minuteErr := readBuffer.ReadInt8("minute", 8)
+	if _minuteErr != nil {
+		return nil, errors.Wrap(_minuteErr, "Error parsing 'minute' field")
+	}
+
+	// Virtual field
+	_minuteIsWildcard := bool((minute) == (wildcard))
+	minuteIsWildcard := bool(_minuteIsWildcard)
+
+	// Simple Field (second)
+	second, _secondErr := readBuffer.ReadInt8("second", 8)
+	if _secondErr != nil {
+		return nil, errors.Wrap(_secondErr, "Error parsing 'second' field")
+	}
+
+	// Virtual field
+	_secondIsWildcard := bool((second) == (wildcard))
+	secondIsWildcard := bool(_secondIsWildcard)
+
+	// Simple Field (fractional)
+	fractional, _fractionalErr := readBuffer.ReadInt8("fractional", 8)
+	if _fractionalErr != nil {
+		return nil, errors.Wrap(_fractionalErr, "Error parsing 'fractional' field")
+	}
+
+	// Virtual field
+	_fractionalIsWildcard := bool((fractional) == (wildcard))
+	fractionalIsWildcard := bool(_fractionalIsWildcard)
+
 	if closeErr := readBuffer.CloseContext("BACnetTagApplicationTime"); closeErr != nil {
 		return nil, closeErr
 	}
 
 	// Create a partially initialized instance
 	_child := &BACnetTagApplicationTime{
-		Parent: &BACnetTag{},
+		Hour:                 hour,
+		Minute:               minute,
+		Second:               second,
+		Fractional:           fractional,
+		Wildcard:             wildcard,
+		HourIsWildcard:       hourIsWildcard,
+		MinuteIsWildcard:     minuteIsWildcard,
+		SecondIsWildcard:     secondIsWildcard,
+		FractionalIsWildcard: fractionalIsWildcard,
+		Parent:               &BACnetTag{},
 	}
 	_child.Parent.Child = _child
 	return _child.Parent, nil
@@ -121,6 +210,34 @@ func (m *BACnetTagApplicationTime) Serialize(writeBuffer utils.WriteBuffer) erro
 			return pushErr
 		}
 
+		// Simple Field (hour)
+		hour := int8(m.Hour)
+		_hourErr := writeBuffer.WriteInt8("hour", 8, (hour))
+		if _hourErr != nil {
+			return errors.Wrap(_hourErr, "Error serializing 'hour' field")
+		}
+
+		// Simple Field (minute)
+		minute := int8(m.Minute)
+		_minuteErr := writeBuffer.WriteInt8("minute", 8, (minute))
+		if _minuteErr != nil {
+			return errors.Wrap(_minuteErr, "Error serializing 'minute' field")
+		}
+
+		// Simple Field (second)
+		second := int8(m.Second)
+		_secondErr := writeBuffer.WriteInt8("second", 8, (second))
+		if _secondErr != nil {
+			return errors.Wrap(_secondErr, "Error serializing 'second' field")
+		}
+
+		// Simple Field (fractional)
+		fractional := int8(m.Fractional)
+		_fractionalErr := writeBuffer.WriteInt8("fractional", 8, (fractional))
+		if _fractionalErr != nil {
+			return errors.Wrap(_fractionalErr, "Error serializing 'fractional' field")
+		}
+
 		if popErr := writeBuffer.PopContext("BACnetTagApplicationTime"); popErr != nil {
 			return popErr
 		}
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationUnsignedInteger.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationUnsignedInteger.go
index 47c8fe4..4099231 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationUnsignedInteger.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationUnsignedInteger.go
@@ -145,7 +145,8 @@ func BACnetTagApplicationUnsignedIntegerParse(readBuffer utils.ReadBuffer, actua
 	}
 
 	// Virtual field
-	isUint8 := bool((actualLength) == (1))
+	_isUint8 := bool((actualLength) == (1))
+	isUint8 := bool(_isUint8)
 
 	// Optional Field (valueUint8) (Can be skipped, if a given expression evaluates to false)
 	var valueUint8 *uint8 = nil
@@ -158,7 +159,8 @@ func BACnetTagApplicationUnsignedIntegerParse(readBuffer utils.ReadBuffer, actua
 	}
 
 	// Virtual field
-	isUint16 := bool((actualLength) == (2))
+	_isUint16 := bool((actualLength) == (2))
+	isUint16 := bool(_isUint16)
 
 	// Optional Field (valueUint16) (Can be skipped, if a given expression evaluates to false)
 	var valueUint16 *uint16 = nil
@@ -171,7 +173,8 @@ func BACnetTagApplicationUnsignedIntegerParse(readBuffer utils.ReadBuffer, actua
 	}
 
 	// Virtual field
-	isUint32 := bool((actualLength) == (3))
+	_isUint32 := bool((actualLength) == (3))
+	isUint32 := bool(_isUint32)
 
 	// Optional Field (valueUint32) (Can be skipped, if a given expression evaluates to false)
 	var valueUint32 *uint32 = nil
@@ -184,7 +187,8 @@ func BACnetTagApplicationUnsignedIntegerParse(readBuffer utils.ReadBuffer, actua
 	}
 
 	// Virtual field
-	isUint64 := bool((actualLength) == (4))
+	_isUint64 := bool((actualLength) == (4))
+	isUint64 := bool(_isUint64)
 
 	// Optional Field (valueUint64) (Can be skipped, if a given expression evaluates to false)
 	var valueUint64 *uint64 = nil
@@ -206,6 +210,10 @@ func BACnetTagApplicationUnsignedIntegerParse(readBuffer utils.ReadBuffer, actua
 		ValueUint16: valueUint16,
 		ValueUint32: valueUint32,
 		ValueUint64: valueUint64,
+		IsUint8:     isUint8,
+		IsUint16:    isUint16,
+		IsUint32:    isUint32,
+		IsUint64:    isUint64,
 		Parent:      &BACnetTag{},
 	}
 	_child.Parent.Child = _child
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestTimeSynchronization.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestTimeSynchronization.go
index 21c6508..cbe5031 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestTimeSynchronization.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestTimeSynchronization.go
@@ -21,13 +21,16 @@ package model
 
 import (
 	"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+	"github.com/pkg/errors"
 )
 
 // Code generated by code-generation. DO NOT EDIT.
 
 // The data-structure of this message
 type BACnetUnconfirmedServiceRequestTimeSynchronization struct {
-	Parent *BACnetUnconfirmedServiceRequest
+	SynchronizedDate *BACnetTagApplicationDate
+	SynchronizedTime *BACnetTagApplicationTime
+	Parent           *BACnetUnconfirmedServiceRequest
 }
 
 // The corresponding interface
@@ -47,9 +50,11 @@ func (m *BACnetUnconfirmedServiceRequestTimeSynchronization) ServiceChoice() uin
 func (m *BACnetUnconfirmedServiceRequestTimeSynchronization) InitializeParent(parent *BACnetUnconfirmedServiceRequest) {
 }
 
-func NewBACnetUnconfirmedServiceRequestTimeSynchronization() *BACnetUnconfirmedServiceRequest {
+func NewBACnetUnconfirmedServiceRequestTimeSynchronization(synchronizedDate *BACnetTagApplicationDate, synchronizedTime *BACnetTagApplicationTime) *BACnetUnconfirmedServiceRequest {
 	child := &BACnetUnconfirmedServiceRequestTimeSynchronization{
-		Parent: NewBACnetUnconfirmedServiceRequest(),
+		SynchronizedDate: synchronizedDate,
+		SynchronizedTime: synchronizedTime,
+		Parent:           NewBACnetUnconfirmedServiceRequest(),
 	}
 	child.Parent.Child = child
 	return child.Parent
@@ -85,6 +90,12 @@ func (m *BACnetUnconfirmedServiceRequestTimeSynchronization) LengthInBits() uint
 func (m *BACnetUnconfirmedServiceRequestTimeSynchronization) LengthInBitsConditional(lastItem bool) uint16 {
 	lengthInBits := uint16(m.Parent.ParentLengthInBits())
 
+	// Simple field (synchronizedDate)
+	lengthInBits += m.SynchronizedDate.LengthInBits()
+
+	// Simple field (synchronizedTime)
+	lengthInBits += m.SynchronizedTime.LengthInBits()
+
 	return lengthInBits
 }
 
@@ -97,13 +108,39 @@ func BACnetUnconfirmedServiceRequestTimeSynchronizationParse(readBuffer utils.Re
 		return nil, pullErr
 	}
 
+	// Simple Field (synchronizedDate)
+	if pullErr := readBuffer.PullContext("synchronizedDate"); pullErr != nil {
+		return nil, pullErr
+	}
+	synchronizedDate, _synchronizedDateErr := BACnetTagParse(readBuffer)
+	if _synchronizedDateErr != nil {
+		return nil, errors.Wrap(_synchronizedDateErr, "Error parsing 'synchronizedDate' field")
+	}
+	if closeErr := readBuffer.CloseContext("synchronizedDate"); closeErr != nil {
+		return nil, closeErr
+	}
+
+	// Simple Field (synchronizedTime)
+	if pullErr := readBuffer.PullContext("synchronizedTime"); pullErr != nil {
+		return nil, pullErr
+	}
+	synchronizedTime, _synchronizedTimeErr := BACnetTagParse(readBuffer)
+	if _synchronizedTimeErr != nil {
+		return nil, errors.Wrap(_synchronizedTimeErr, "Error parsing 'synchronizedTime' field")
+	}
+	if closeErr := readBuffer.CloseContext("synchronizedTime"); closeErr != nil {
+		return nil, closeErr
+	}
+
 	if closeErr := readBuffer.CloseContext("BACnetUnconfirmedServiceRequestTimeSynchronization"); closeErr != nil {
 		return nil, closeErr
 	}
 
 	// Create a partially initialized instance
 	_child := &BACnetUnconfirmedServiceRequestTimeSynchronization{
-		Parent: &BACnetUnconfirmedServiceRequest{},
+		SynchronizedDate: CastBACnetTagApplicationDate(synchronizedDate),
+		SynchronizedTime: CastBACnetTagApplicationTime(synchronizedTime),
+		Parent:           &BACnetUnconfirmedServiceRequest{},
 	}
 	_child.Parent.Child = _child
 	return _child.Parent, nil
@@ -115,6 +152,30 @@ func (m *BACnetUnconfirmedServiceRequestTimeSynchronization) Serialize(writeBuff
 			return pushErr
 		}
 
+		// Simple Field (synchronizedDate)
+		if pushErr := writeBuffer.PushContext("synchronizedDate"); pushErr != nil {
+			return pushErr
+		}
+		_synchronizedDateErr := m.SynchronizedDate.Serialize(writeBuffer)
+		if popErr := writeBuffer.PopContext("synchronizedDate"); popErr != nil {
+			return popErr
+		}
+		if _synchronizedDateErr != nil {
+			return errors.Wrap(_synchronizedDateErr, "Error serializing 'synchronizedDate' field")
+		}
+
+		// Simple Field (synchronizedTime)
+		if pushErr := writeBuffer.PushContext("synchronizedTime"); pushErr != nil {
+			return pushErr
+		}
+		_synchronizedTimeErr := m.SynchronizedTime.Serialize(writeBuffer)
+		if popErr := writeBuffer.PopContext("synchronizedTime"); popErr != nil {
+			return popErr
+		}
+		if _synchronizedTimeErr != nil {
+			return errors.Wrap(_synchronizedTimeErr, "Error serializing 'synchronizedTime' field")
+		}
+
 		if popErr := writeBuffer.PopContext("BACnetUnconfirmedServiceRequestTimeSynchronization"); popErr != nil {
 			return popErr
 		}
diff --git a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
index 5b11715..2e89881 100644
--- a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
+++ b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
@@ -303,6 +303,8 @@
         ['0x05' BACnetUnconfirmedServiceRequestUnconfirmedTextMessage
         ]
         ['0x06' BACnetUnconfirmedServiceRequestTimeSynchronization
+            [simple BACnetTagApplicationDate synchronizedDate]
+            [simple BACnetTagApplicationTime synchronizedTime]
         ]
         ['0x07' BACnetUnconfirmedServiceRequestWhoHas
             [optional BACnetComplexTagUnsignedInteger('0', 'BACnetDataType.UNSIGNED_INTEGER')   deviceInstanceRangeLowLimit                                         ]
@@ -547,8 +549,32 @@
             [array int 8 data length 'actualLength']
         ]
         ['APPLICATION_TAGS','0xA' BACnetTagApplicationDate
+            [virtual int  8 wildcard '0xFF']
+            [simple  int  8 yearMinus1900]
+            [virtual bit    yearIsWildcard 'yearMinus1900 == wildcard']
+            [virtual int 16 year 'yearMinus1900 + 1900']
+            [simple  int  8 month]
+            [virtual bit    monthIsWildcard 'month == wildcard']
+            [virtual bit    oddMonthWildcard 'month == 13']
+            [virtual bit    evenMonthWildcard 'month == 14']
+            [simple  int  8 dayOfMonth]
+            [virtual bit    dayOfMonthIsWildcard 'dayOfMonth == wildcard']
+            [virtual bit    lastDayOfMonthWildcard 'dayOfMonth == 32']
+            [virtual bit    oddDayOfMonthWildcard 'dayOfMonth == 33']
+            [virtual bit    evenDayOfMonthWildcard 'dayOfMonth == 34']
+            [simple  int  8 dayOfWeek]
+            [virtual bit    dayOfWeekIsWildcard 'dayOfWeek == wildcard']
         ]
         ['APPLICATION_TAGS','0xB' BACnetTagApplicationTime
+            [virtual int  8 wildcard '0xFF']
+            [simple  int  8 hour]
+            [virtual bit    hourIsWildcard 'hour == wildcard']
+            [simple  int  8 minute]
+            [virtual bit    minuteIsWildcard 'minute == wildcard']
+            [simple  int  8 second]
+            [virtual bit    secondIsWildcard 'second == wildcard']
+            [simple  int  8 fractional]
+            [virtual bit    fractionalIsWildcard 'fractional == wildcard']
         ]
         ['APPLICATION_TAGS','0xC' BACnetTagApplicationObjectIdentifier
             [simple     uint    10  objectType]
@@ -626,8 +652,31 @@
             [array int 8 data length 'actualLengthInBit']
         ]
         ['DATE' BACnetComplexTagDate
+            [virtual int  8 wildcard '0xFF']
+            [simple  int  8 yearMinus1900]
+            [virtual bit    yearIsWildcard 'yearMinus1900 == wildcard']
+            [simple  int  8 month]
+            [virtual bit    monthIsWildcard 'month == wildcard']
+            [virtual bit    oddMonthWildcard 'month == 13']
+            [virtual bit    evenMonthWildcard 'month == 14']
+            [simple  int  8 dayOfMonth]
+            [virtual bit    dayOfMonthIsWildcard 'dayOfMonth == wildcard']
+            [virtual bit    lastDayOfMonthWildcard 'dayOfMonth == 32']
+            [virtual bit    oddDayOfMonthWildcard 'dayOfMonth == 33']
+            [virtual bit    evenDayOfMonthWildcard 'dayOfMonth == 34']
+            [simple  int  8 dayOfWeek]
+            [virtual bit    dayOfWeekIsWildcard 'dayOfWeek == wildcard']
         ]
         ['TIME' BACnetComplexTagTime
+            [virtual int  8 wildcard '0xFF']
+            [simple  int  8 hour]
+            [virtual bit    hourIsWildcard 'hour == wildcard']
+            [simple  int  8 minute]
+            [virtual bit    minuteIsWildcard 'minute == wildcard']
+            [simple  int  8 second]
+            [virtual bit    secondIsWildcard 'second == wildcard']
+            [simple  int  8 fractional]
+            [virtual bit    fractionalIsWildcard 'fractional == wildcard']
         ]
         ['BACNET_OBJECT_IDENTIFIER' BACnetComplexTagObjectIdentifier
             [simple     uint    10  objectType]