Skip to content
This repository has been archived by the owner on Jun 29, 2024. It is now read-only.

Commit

Permalink
Fix UCEVCC to use ACPowerTotal instead of phase A
Browse files Browse the repository at this point in the history
  • Loading branch information
@DerAndereAndi
DerAndereAndi committed Mar 27, 2024
1 parent a9f3fa0 commit a9049a1
Show file tree
Hide file tree
Showing 3 changed files with 67 additions and 128 deletions.
4 changes: 2 additions & 2 deletions ucevcc/api.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -62,11 +62,11 @@ type UCEVCCInterface interface {

// Scenario 6

// return the min, max, default limits for each phase of the connected EV
// return the minimum, maximum charging and, standby power of the connected EV
//
// parameters:
// - entity: the entity of the EV
CurrentLimits(entity spineapi.EntityRemoteInterface) ([]float64, []float64, []float64, error)
CurrentLimits(entity spineapi.EntityRemoteInterface) (float64, float64, float64, error)

// Scenario 7

Expand Down
52 changes: 25 additions & 27 deletions ucevcc/public.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -205,49 +205,47 @@ func (e *UCEVCC) ManufacturerData(
return util.ManufacturerData(e.service, entity, e.validEntityTypes)
}

// return the min, max, default limits for each phase of the connected EV
// return the minimum, maximum charging and, standby power of the connected EV
//
// possible errors:
// - ErrDataNotAvailable if no such measurement is (yet) available
// - and others
func (e *UCEVCC) CurrentLimits(entity spineapi.EntityRemoteInterface) ([]float64, []float64, []float64, error) {
func (e *UCEVCC) CurrentLimits(entity spineapi.EntityRemoteInterface) (float64, float64, float64, error) {
if !util.IsCompatibleEntity(entity, e.validEntityTypes) {
return nil, nil, nil, api.ErrNoCompatibleEntity
return 0.0, 0.0, 0.0, api.ErrNoCompatibleEntity
}

evElectricalConnection, err := util.ElectricalConnection(e.service, entity)
if err != nil {
return nil, nil, nil, eebusapi.ErrDataNotAvailable
return 0.0, 0.0, 0.0, eebusapi.ErrDataNotAvailable
}

var resultMin, resultMax, resultDefault []float64

for _, phaseName := range util.PhaseNameMapping {
// electricalParameterDescription contains the measured phase for each measurementId
elParamDesc, err := evElectricalConnection.GetParameterDescriptionForMeasuredPhase(phaseName)
if err != nil || elParamDesc.ParameterId == nil {
continue
}

dataMin, dataMax, dataDefault, err := evElectricalConnection.GetLimitsForParameterId(*elParamDesc.ParameterId)
if err != nil {
continue
}

// Min current data should be derived from min power data
// but as this value is only properly provided via VAS the
// currrent min values can not be trusted.
elParamDesc, err := evElectricalConnection.GetParameterDescriptionForScopeType(model.ScopeTypeTypeACPowerTotal)
if err != nil || elParamDesc.ParameterId == nil {
return 0.0, 0.0, 0.0, eebusapi.ErrDataNotAvailable
}

resultMin = append(resultMin, dataMin)
resultMax = append(resultMax, dataMax)
resultDefault = append(resultDefault, dataDefault)
dataSet, err := evElectricalConnection.GetPermittedValueSetForParameterId(*elParamDesc.ParameterId)
if err != nil || dataSet == nil ||
dataSet.PermittedValueSet == nil ||
len(dataSet.PermittedValueSet) != 1 ||
dataSet.PermittedValueSet[0].Range == nil ||
len(dataSet.PermittedValueSet[0].Range) != 1 {
return 0.0, 0.0, 0.0, eebusapi.ErrDataNotAvailable
}

if len(resultMin) == 0 {
return nil, nil, nil, eebusapi.ErrDataNotAvailable
var minValue, maxValue, standByValue float64
if dataSet.PermittedValueSet[0].Range[0].Min != nil {
minValue = dataSet.PermittedValueSet[0].Range[0].Min.GetValue()
}
if dataSet.PermittedValueSet[0].Range[0].Max != nil {
maxValue = dataSet.PermittedValueSet[0].Range[0].Max.GetValue()
}
if dataSet.PermittedValueSet[0].Value != nil && len(dataSet.PermittedValueSet[0].Value) > 0 {
standByValue = dataSet.PermittedValueSet[0].Value[0].GetValue()
}

return resultMin, resultMax, resultDefault, nil
return minValue, maxValue, standByValue, nil
}

// is the EV in sleep mode
Expand Down
139 changes: 40 additions & 99 deletions ucevcc/public_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -292,43 +292,24 @@ func (s *UCEVCCSuite) Test_EVManufacturerData() {
}

func (s *UCEVCCSuite) Test_EVCurrentLimits() {
minData, maxData, defaultData, err := s.sut.CurrentLimits(s.mockRemoteEntity)
minData, maxData, standByData, err := s.sut.CurrentLimits(s.mockRemoteEntity)
assert.NotNil(s.T(), err)
assert.Nil(s.T(), minData)
assert.Nil(s.T(), maxData)
assert.Nil(s.T(), defaultData)
assert.Equal(s.T(), 0.0, minData)
assert.Equal(s.T(), 0.0, maxData)
assert.Equal(s.T(), 0.0, standByData)

minData, maxData, defaultData, err = s.sut.CurrentLimits(s.evEntity)
minData, maxData, standByData, err = s.sut.CurrentLimits(s.evEntity)
assert.NotNil(s.T(), err)
assert.Nil(s.T(), minData)
assert.Nil(s.T(), maxData)
assert.Nil(s.T(), defaultData)

minData, maxData, defaultData, err = s.sut.CurrentLimits(s.evEntity)
assert.NotNil(s.T(), err)
assert.Nil(s.T(), minData)
assert.Nil(s.T(), maxData)
assert.Nil(s.T(), defaultData)
assert.Equal(s.T(), 0.0, minData)
assert.Equal(s.T(), 0.0, maxData)
assert.Equal(s.T(), 0.0, standByData)

paramData := &model.ElectricalConnectionParameterDescriptionListDataType{
ElectricalConnectionParameterDescriptionData: []model.ElectricalConnectionParameterDescriptionDataType{
{
ElectricalConnectionId: util.Ptr(model.ElectricalConnectionIdType(0)),
ParameterId: util.Ptr(model.ElectricalConnectionParameterIdType(0)),
MeasurementId: util.Ptr(model.MeasurementIdType(0)),
AcMeasuredPhases: util.Ptr(model.ElectricalConnectionPhaseNameTypeA),
},
{
ElectricalConnectionId: util.Ptr(model.ElectricalConnectionIdType(0)),
ParameterId: util.Ptr(model.ElectricalConnectionParameterIdType(1)),
MeasurementId: util.Ptr(model.MeasurementIdType(1)),
AcMeasuredPhases: util.Ptr(model.ElectricalConnectionPhaseNameTypeB),
},
{
ElectricalConnectionId: util.Ptr(model.ElectricalConnectionIdType(0)),
ParameterId: util.Ptr(model.ElectricalConnectionParameterIdType(2)),
MeasurementId: util.Ptr(model.MeasurementIdType(2)),
AcMeasuredPhases: util.Ptr(model.ElectricalConnectionPhaseNameTypeC),
ScopeType: util.Ptr(model.ScopeTypeTypeACPowerTotal),
},
},
}
Expand All @@ -337,92 +318,57 @@ func (s *UCEVCCSuite) Test_EVCurrentLimits() {
fErr := rFeature.UpdateData(model.FunctionTypeElectricalConnectionParameterDescriptionListData, paramData, nil, nil)
assert.Nil(s.T(), fErr)

minData, maxData, defaultData, err = s.sut.CurrentLimits(s.evEntity)
minData, maxData, standByData, err = s.sut.CurrentLimits(s.evEntity)
assert.NotNil(s.T(), err)
assert.Nil(s.T(), minData)
assert.Nil(s.T(), maxData)
assert.Nil(s.T(), defaultData)
assert.Equal(s.T(), 0.0, minData)
assert.Equal(s.T(), 0.0, maxData)
assert.Equal(s.T(), 0.0, standByData)

type permittedStruct struct {
defaultExists bool
defaultValue, expectedDefaultValue float64
standByValue, expectedStandByValue float64
minValue, expectedMinValue float64
maxValue, expectedMaxValue float64
}

tests := []struct {
name string
permitted []permittedStruct
permitted permittedStruct
}{
{
"1 Phase ISO15118",
[]permittedStruct{
{true, 0.1, 0.1, 2, 2, 16, 16},
},
},
{
"1 Phase IEC61851",
[]permittedStruct{
{true, 0.0, 0.0, 6, 6, 16, 16},
},
},
{
"1 Phase IEC61851 Elli",
[]permittedStruct{
{false, 0.0, 0.0, 6, 6, 16, 16},
},
"IEC 3 Phase",
permittedStruct{0.1, 0.1, 4287600, 4287600, 11433600, 11433600},
},
{
"3 Phase ISO15118",
[]permittedStruct{
{true, 0.1, 0.1, 2, 2, 16, 16},
{true, 0.1, 0.1, 2, 2, 16, 16},
{true, 0.1, 0.1, 2, 2, 16, 16},
},
"ISO15118 VW",
permittedStruct{0.1, 0.1, 800, 800, 11433600, 11433600},
},
{
"3 Phase IEC61851",
[]permittedStruct{
{true, 0.0, 0.0, 6, 6, 16, 16},
{true, 0.0, 0.0, 6, 6, 16, 16},
{true, 0.0, 0.0, 6, 6, 16, 16},
},
},
{
"3 Phase IEC61851 Elli",
[]permittedStruct{
{false, 0.0, 0.0, 6, 6, 16, 16},
{false, 0.0, 0.0, 6, 6, 16, 16},
{false, 0.0, 0.0, 6, 6, 16, 16},
},
"ISO15118 Taycan",
permittedStruct{0.1, 0.1, 400, 400, 11433600, 11433600},
},
}

for _, tc := range tests {
s.T().Run(tc.name, func(t *testing.T) {
dataSet := []model.ElectricalConnectionPermittedValueSetDataType{}
permittedData := []model.ScaledNumberSetType{}
for index, data := range tc.permitted {
item := model.ScaledNumberSetType{
Range: []model.ScaledNumberRangeType{
{
Min: model.NewScaledNumberType(data.minValue),
Max: model.NewScaledNumberType(data.maxValue),
},
item := model.ScaledNumberSetType{
Range: []model.ScaledNumberRangeType{
{
Min: model.NewScaledNumberType(tc.permitted.minValue),
Max: model.NewScaledNumberType(tc.permitted.maxValue),
},
}
if data.defaultExists {
item.Value = []model.ScaledNumberType{*model.NewScaledNumberType(data.defaultValue)}
}
permittedData = append(permittedData, item)

permittedItem := model.ElectricalConnectionPermittedValueSetDataType{
ElectricalConnectionId: util.Ptr(model.ElectricalConnectionIdType(0)),
ParameterId: util.Ptr(model.ElectricalConnectionParameterIdType(index)),
PermittedValueSet: permittedData,
}
dataSet = append(dataSet, permittedItem)
},
Value: []model.ScaledNumberType{*model.NewScaledNumberType(tc.permitted.standByValue)},
}
permittedData = append(permittedData, item)

permittedItem := model.ElectricalConnectionPermittedValueSetDataType{
ElectricalConnectionId: util.Ptr(model.ElectricalConnectionIdType(0)),
ParameterId: util.Ptr(model.ElectricalConnectionParameterIdType(0)),
PermittedValueSet: permittedData,
}
dataSet = append(dataSet, permittedItem)

permData := &model.ElectricalConnectionPermittedValueSetListDataType{
ElectricalConnectionPermittedValueSetData: dataSet,
Expand All @@ -431,18 +377,13 @@ func (s *UCEVCCSuite) Test_EVCurrentLimits() {
fErr := rFeature.UpdateData(model.FunctionTypeElectricalConnectionPermittedValueSetListData, permData, nil, nil)
assert.Nil(s.T(), fErr)

minData, maxData, defaultData, err = s.sut.CurrentLimits(s.evEntity)
minData, maxData, standByData, err = s.sut.CurrentLimits(s.evEntity)
assert.Nil(s.T(), err)

assert.Nil(s.T(), err)
assert.Equal(s.T(), len(tc.permitted), len(minData))
assert.Equal(s.T(), len(tc.permitted), len(maxData))
assert.Equal(s.T(), len(tc.permitted), len(defaultData))
for index, item := range tc.permitted {
assert.Equal(s.T(), item.expectedMinValue, minData[index])
assert.Equal(s.T(), item.expectedMaxValue, maxData[index])
assert.Equal(s.T(), item.expectedDefaultValue, defaultData[index])
}
assert.Equal(s.T(), tc.permitted.expectedMinValue, minData)
assert.Equal(s.T(), tc.permitted.expectedMaxValue, maxData)
assert.Equal(s.T(), tc.permitted.expectedStandByValue, standByData)
})
}
}
Expand Down

0 comments on commit a9049a1

Please sign in to comment.