| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * https://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package model |
| |
| import ( |
| "context" |
| api "github.com/apache/plc4x/plc4go/pkg/api/values" |
| "github.com/apache/plc4x/plc4go/spi/utils" |
| "github.com/apache/plc4x/plc4go/spi/values" |
| "github.com/pkg/errors" |
| "github.com/rs/zerolog" |
| ) |
| |
| // Code generated by code-generation. DO NOT EDIT. |
| |
| func DataItemParse(ctx context.Context, theBytes []byte, dataProtocolId string, stringLength int32) (api.PlcValue, error) { |
| return DataItemParseWithBuffer(ctx, utils.NewReadBufferByteBased(theBytes), dataProtocolId, stringLength) |
| } |
| |
| func DataItemParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, dataProtocolId string, stringLength int32) (api.PlcValue, error) { |
| log := zerolog.Ctx(ctx) |
| _ = log |
| readBuffer.PullContext("DataItem") |
| switch { |
| case dataProtocolId == "IEC61131_BOOL": // BOOL |
| // Reserved Field (Just skip the bytes) |
| if _, _err := readBuffer.ReadUint8("reserved", 7); _err != nil { |
| return nil, errors.Wrap(_err, "Error parsing reserved field") |
| } |
| |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadBit("value") |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcBOOL(value), nil |
| case dataProtocolId == "IEC61131_BYTE": // BYTE |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadUint8("value", 8) |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcBYTE(value), nil |
| case dataProtocolId == "IEC61131_WORD": // WORD |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadUint16("value", 16) |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcWORD(value), nil |
| case dataProtocolId == "IEC61131_DWORD": // DWORD |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadUint32("value", 32) |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcDWORD(value), nil |
| case dataProtocolId == "IEC61131_LWORD": // LWORD |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadUint64("value", 64) |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcLWORD(value), nil |
| case dataProtocolId == "IEC61131_SINT": // SINT |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadInt8("value", 8) |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcSINT(value), nil |
| case dataProtocolId == "IEC61131_USINT": // USINT |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadUint8("value", 8) |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcUSINT(value), nil |
| case dataProtocolId == "IEC61131_INT": // INT |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadInt16("value", 16) |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcINT(value), nil |
| case dataProtocolId == "IEC61131_UINT": // UINT |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadUint16("value", 16) |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcUINT(value), nil |
| case dataProtocolId == "IEC61131_DINT": // DINT |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadInt32("value", 32) |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcDINT(value), nil |
| case dataProtocolId == "IEC61131_UDINT": // UDINT |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadUint32("value", 32) |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcUDINT(value), nil |
| case dataProtocolId == "IEC61131_LINT": // LINT |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadInt64("value", 64) |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcLINT(value), nil |
| case dataProtocolId == "IEC61131_ULINT": // ULINT |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadUint64("value", 64) |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcULINT(value), nil |
| case dataProtocolId == "IEC61131_REAL": // REAL |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadFloat32("value", 32) |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcREAL(value), nil |
| case dataProtocolId == "IEC61131_LREAL": // LREAL |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadFloat64("value", 64) |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcLREAL(value), nil |
| case dataProtocolId == "IEC61131_CHAR": // CHAR |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadString("value", uint32(8), "UTF-8") |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcCHAR(value), nil |
| case dataProtocolId == "IEC61131_WCHAR": // CHAR |
| // Simple Field (value) |
| value, _valueErr := readBuffer.ReadString("value", uint32(16), "UTF-16") |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcCHAR(value), nil |
| case dataProtocolId == "IEC61131_STRING": // STRING |
| // Manual Field (value) |
| value, _valueErr := ParseS7String(ctx, readBuffer, stringLength, "UTF-8") |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcSTRING(value), nil |
| case dataProtocolId == "IEC61131_WSTRING": // STRING |
| // Manual Field (value) |
| value, _valueErr := ParseS7String(ctx, readBuffer, stringLength, "UTF-16") |
| if _valueErr != nil { |
| return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcSTRING(value), nil |
| case dataProtocolId == "IEC61131_TIME": // TIME |
| // Simple Field (milliseconds) |
| milliseconds, _millisecondsErr := readBuffer.ReadUint32("milliseconds", 32) |
| if _millisecondsErr != nil { |
| return nil, errors.Wrap(_millisecondsErr, "Error parsing 'milliseconds' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcTIMEFromMilliseconds(int64(milliseconds)), nil |
| case dataProtocolId == "S7_S5TIME": // TIME |
| // Manual Field (milliseconds) |
| milliseconds, _millisecondsErr := ParseS5Time(ctx, readBuffer) |
| if _millisecondsErr != nil { |
| return nil, errors.Wrap(_millisecondsErr, "Error parsing 'milliseconds' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcTIMEFromMilliseconds(int64(milliseconds)), nil |
| case dataProtocolId == "IEC61131_LTIME": // LTIME |
| // Simple Field (nanoseconds) |
| nanoseconds, _nanosecondsErr := readBuffer.ReadUint64("nanoseconds", 64) |
| if _nanosecondsErr != nil { |
| return nil, errors.Wrap(_nanosecondsErr, "Error parsing 'nanoseconds' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcLTIMEFromNanoseconds(nanoseconds), nil |
| case dataProtocolId == "IEC61131_DATE": // DATE |
| // Manual Field (daysSinceEpoch) |
| daysSinceEpoch, _daysSinceEpochErr := ParseTiaDate(ctx, readBuffer) |
| if _daysSinceEpochErr != nil { |
| return nil, errors.Wrap(_daysSinceEpochErr, "Error parsing 'daysSinceEpoch' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcDATEFromDaysSinceEpoch(daysSinceEpoch), nil |
| case dataProtocolId == "IEC61131_TIME_OF_DAY": // TIME_OF_DAY |
| // Simple Field (millisecondsSinceMidnight) |
| millisecondsSinceMidnight, _millisecondsSinceMidnightErr := readBuffer.ReadUint32("millisecondsSinceMidnight", 32) |
| if _millisecondsSinceMidnightErr != nil { |
| return nil, errors.Wrap(_millisecondsSinceMidnightErr, "Error parsing 'millisecondsSinceMidnight' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcTIME_OF_DAYFromMillisecondsSinceMidnight(millisecondsSinceMidnight), nil |
| case dataProtocolId == "IEC61131_LTIME_OF_DAY": // LTIME_OF_DAY |
| // Simple Field (nanosecondsSinceMidnight) |
| nanosecondsSinceMidnight, _nanosecondsSinceMidnightErr := readBuffer.ReadUint64("nanosecondsSinceMidnight", 64) |
| if _nanosecondsSinceMidnightErr != nil { |
| return nil, errors.Wrap(_nanosecondsSinceMidnightErr, "Error parsing 'nanosecondsSinceMidnight' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcLTIME_OF_DAYFromNanosecondsSinceMidnight(nanosecondsSinceMidnight), nil |
| case dataProtocolId == "IEC61131_DATE_AND_TIME": // DATE_AND_TIME |
| // Manual Field (year) |
| year, _yearErr := ParseBcdToByte(ctx, readBuffer) |
| if _yearErr != nil { |
| return nil, errors.Wrap(_yearErr, "Error parsing 'year' field") |
| } |
| |
| // Manual Field (month) |
| month, _monthErr := ParseBcdToByte(ctx, readBuffer) |
| if _monthErr != nil { |
| return nil, errors.Wrap(_monthErr, "Error parsing 'month' field") |
| } |
| |
| // Manual Field (day) |
| day, _dayErr := ParseBcdToByte(ctx, readBuffer) |
| if _dayErr != nil { |
| return nil, errors.Wrap(_dayErr, "Error parsing 'day' field") |
| } |
| |
| // Manual Field (hour) |
| hour, _hourErr := ParseBcdToByte(ctx, readBuffer) |
| if _hourErr != nil { |
| return nil, errors.Wrap(_hourErr, "Error parsing 'hour' field") |
| } |
| |
| // Manual Field (minutes) |
| minutes, _minutesErr := ParseBcdToByte(ctx, readBuffer) |
| if _minutesErr != nil { |
| return nil, errors.Wrap(_minutesErr, "Error parsing 'minutes' field") |
| } |
| |
| // Manual Field (seconds) |
| seconds, _secondsErr := ParseBcdToByte(ctx, readBuffer) |
| if _secondsErr != nil { |
| return nil, errors.Wrap(_secondsErr, "Error parsing 'seconds' field") |
| } |
| |
| // Manual Field (nanoseconds) |
| nanoseconds, _nanosecondsErr := ParseS7MsecToNsec(ctx, readBuffer) |
| if _nanosecondsErr != nil { |
| return nil, errors.Wrap(_nanosecondsErr, "Error parsing 'nanoseconds' field") |
| } |
| |
| // Manual Field (dayOfWeek) |
| dayOfWeek, _dayOfWeekErr := ParseS7DayOfWeek(ctx, readBuffer) |
| if _dayOfWeekErr != nil { |
| return nil, errors.Wrap(_dayOfWeekErr, "Error parsing 'dayOfWeek' field") |
| } |
| readBuffer.CloseContext("DataItem") |
| return values.NewPlcDATA_AND_TIMEFromSegments(uint32(year), uint32(month), uint32(day), uint32(hour), uint32(minutes), uint32(seconds), uint32(nanoseconds)), nil |
| } |
| // TODO: add more info which type it is actually |
| return nil, errors.New("unsupported type") |
| } |
| |
| func DataItemSerialize(value api.PlcValue, dataProtocolId string, stringLength int32) ([]byte, error) { |
| wb := utils.NewWriteBufferByteBased() |
| if err := DataItemSerializeWithWriteBuffer(context.Background(), wb, value, dataProtocolId, stringLength); err != nil { |
| return nil, err |
| } |
| return wb.GetBytes(), nil |
| } |
| |
| func DataItemSerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer, value api.PlcValue, dataProtocolId string, stringLength int32) error { |
| log := zerolog.Ctx(ctx) |
| _ = log |
| m := struct { |
| DataProtocolId string |
| StringLength int32 |
| }{ |
| DataProtocolId: dataProtocolId, |
| StringLength: stringLength, |
| } |
| _ = m |
| writeBuffer.PushContext("DataItem") |
| switch { |
| case dataProtocolId == "IEC61131_BOOL": // BOOL |
| // Reserved Field (Just skip the bytes) |
| if _err := writeBuffer.WriteUint8("reserved", 7, uint8(uint8(0x00))); _err != nil { |
| return errors.Wrap(_err, "Error serializing reserved field") |
| } |
| |
| // Simple Field (value) |
| if _err := writeBuffer.WriteBit("value", value.GetBool()); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_BYTE": // BYTE |
| // Simple Field (value) |
| if _err := writeBuffer.WriteUint8("value", 8, uint8(value.GetUint8())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_WORD": // WORD |
| // Simple Field (value) |
| if _err := writeBuffer.WriteUint16("value", 16, uint16(value.GetUint16())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_DWORD": // DWORD |
| // Simple Field (value) |
| if _err := writeBuffer.WriteUint32("value", 32, uint32(value.GetUint32())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_LWORD": // LWORD |
| // Simple Field (value) |
| if _err := writeBuffer.WriteUint64("value", 64, uint64(value.GetUint64())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_SINT": // SINT |
| // Simple Field (value) |
| if _err := writeBuffer.WriteInt8("value", 8, int8(value.GetInt8())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_USINT": // USINT |
| // Simple Field (value) |
| if _err := writeBuffer.WriteUint8("value", 8, uint8(value.GetUint8())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_INT": // INT |
| // Simple Field (value) |
| if _err := writeBuffer.WriteInt16("value", 16, int16(value.GetInt16())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_UINT": // UINT |
| // Simple Field (value) |
| if _err := writeBuffer.WriteUint16("value", 16, uint16(value.GetUint16())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_DINT": // DINT |
| // Simple Field (value) |
| if _err := writeBuffer.WriteInt32("value", 32, int32(value.GetInt32())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_UDINT": // UDINT |
| // Simple Field (value) |
| if _err := writeBuffer.WriteUint32("value", 32, uint32(value.GetUint32())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_LINT": // LINT |
| // Simple Field (value) |
| if _err := writeBuffer.WriteInt64("value", 64, int64(value.GetInt64())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_ULINT": // ULINT |
| // Simple Field (value) |
| if _err := writeBuffer.WriteUint64("value", 64, uint64(value.GetUint64())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_REAL": // REAL |
| // Simple Field (value) |
| if _err := writeBuffer.WriteFloat32("value", 32, value.GetFloat32()); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_LREAL": // LREAL |
| // Simple Field (value) |
| if _err := writeBuffer.WriteFloat64("value", 64, value.GetFloat64()); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_CHAR": // CHAR |
| // Simple Field (value) |
| if _err := writeBuffer.WriteString("value", uint32(8), "UTF-8", value.GetString()); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_WCHAR": // CHAR |
| // Simple Field (value) |
| if _err := writeBuffer.WriteString("value", uint32(16), "UTF-16", value.GetString()); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_STRING": // STRING |
| // Manual Field (value) |
| _valueErr := SerializeS7String(ctx, writeBuffer, value, stringLength, "UTF-8") |
| if _valueErr != nil { |
| return errors.Wrap(_valueErr, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_WSTRING": // STRING |
| // Manual Field (value) |
| _valueErr := SerializeS7String(ctx, writeBuffer, value, stringLength, "UTF-16") |
| if _valueErr != nil { |
| return errors.Wrap(_valueErr, "Error serializing 'value' field") |
| } |
| case dataProtocolId == "IEC61131_TIME": // TIME |
| // Simple Field (milliseconds) |
| if _err := writeBuffer.WriteUint32("milliseconds", 32, uint32(value.(values.PlcTIME).GetMilliseconds())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'milliseconds' field") |
| } |
| case dataProtocolId == "S7_S5TIME": // TIME |
| // Manual Field (milliseconds) |
| _millisecondsErr := SerializeS5Time(ctx, writeBuffer, value) |
| if _millisecondsErr != nil { |
| return errors.Wrap(_millisecondsErr, "Error serializing 'milliseconds' field") |
| } |
| case dataProtocolId == "IEC61131_LTIME": // LTIME |
| // Simple Field (nanoseconds) |
| if _err := writeBuffer.WriteUint64("nanoseconds", 64, uint64(value.(values.PlcLTIME).GetNanoseconds())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'nanoseconds' field") |
| } |
| case dataProtocolId == "IEC61131_DATE": // DATE |
| // Manual Field (daysSinceEpoch) |
| _daysSinceEpochErr := SerializeTiaDate(ctx, writeBuffer, value) |
| if _daysSinceEpochErr != nil { |
| return errors.Wrap(_daysSinceEpochErr, "Error serializing 'daysSinceEpoch' field") |
| } |
| case dataProtocolId == "IEC61131_TIME_OF_DAY": // TIME_OF_DAY |
| // Simple Field (millisecondsSinceMidnight) |
| if _err := writeBuffer.WriteUint32("millisecondsSinceMidnight", 32, uint32(value.(values.PlcTIME_OF_DAY).GetMillisecondsSinceMidnight())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'millisecondsSinceMidnight' field") |
| } |
| case dataProtocolId == "IEC61131_LTIME_OF_DAY": // LTIME_OF_DAY |
| // Simple Field (nanosecondsSinceMidnight) |
| if _err := writeBuffer.WriteUint64("nanosecondsSinceMidnight", 64, uint64(value.(values.PlcLTIME_OF_DAY).GetNanosecondsSinceMidnight())); _err != nil { |
| return errors.Wrap(_err, "Error serializing 'nanosecondsSinceMidnight' field") |
| } |
| case dataProtocolId == "IEC61131_DATE_AND_TIME": // DATE_AND_TIME |
| // Manual Field (year) |
| _yearErr := ByteToBcd(ctx, writeBuffer, value.GetDateTime().GetYear()) |
| if _yearErr != nil { |
| return errors.Wrap(_yearErr, "Error serializing 'year' field") |
| } |
| |
| // Manual Field (month) |
| _monthErr := ByteToBcd(ctx, writeBuffer, value.GetDateTime().GetMonthValue()) |
| if _monthErr != nil { |
| return errors.Wrap(_monthErr, "Error serializing 'month' field") |
| } |
| |
| // Manual Field (day) |
| _dayErr := ByteToBcd(ctx, writeBuffer, value.GetDateTime().GetDayOfMonth()) |
| if _dayErr != nil { |
| return errors.Wrap(_dayErr, "Error serializing 'day' field") |
| } |
| |
| // Manual Field (hour) |
| _hourErr := ByteToBcd(ctx, writeBuffer, value.GetDateTime().GetHour()) |
| if _hourErr != nil { |
| return errors.Wrap(_hourErr, "Error serializing 'hour' field") |
| } |
| |
| // Manual Field (minutes) |
| _minutesErr := ByteToBcd(ctx, writeBuffer, value.GetDateTime().GetMinute()) |
| if _minutesErr != nil { |
| return errors.Wrap(_minutesErr, "Error serializing 'minutes' field") |
| } |
| |
| // Manual Field (seconds) |
| _secondsErr := ByteToBcd(ctx, writeBuffer, value.GetDateTime().GetSecond()) |
| if _secondsErr != nil { |
| return errors.Wrap(_secondsErr, "Error serializing 'seconds' field") |
| } |
| |
| // Manual Field (nanoseconds) |
| _nanosecondsErr := SerializeNsecToS7Msec(ctx, writeBuffer, value.GetDateTime().GetNano()) |
| if _nanosecondsErr != nil { |
| return errors.Wrap(_nanosecondsErr, "Error serializing 'nanoseconds' field") |
| } |
| |
| // Manual Field (dayOfWeek) |
| _dayOfWeekErr := SerializeS7DayOfWeek(ctx, writeBuffer, value.GetDateTime().GetDayOfWeek().GetValue()) |
| if _dayOfWeekErr != nil { |
| return errors.Wrap(_dayOfWeekErr, "Error serializing 'dayOfWeek' field") |
| } |
| default: |
| // TODO: add more info which type it is actually |
| return errors.New("unsupported type") |
| } |
| writeBuffer.PopContext("DataItem") |
| return nil |
| } |
