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

Commit a9049a1

Browse files
DerAndereAndiDerAndereAndi
committed
Fix UCEVCC to use ACPowerTotal instead of phase A
1 parent a9f3fa0 commit a9049a1

File tree

3 files changed

+67
-128
lines changed

3 files changed

+67
-128
lines changed

‎ucevcc/api.go

+2-2
Original file line numberDiff line numberDiff line change
@@ -62,11 +62,11 @@ type UCEVCCInterface interface {
6262

6363
// Scenario 6
6464

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

7171
// Scenario 7
7272

‎ucevcc/public.go

+25-27
Original file line numberDiff line numberDiff line change
@@ -205,49 +205,47 @@ func (e *UCEVCC) ManufacturerData(
205205
return util.ManufacturerData(e.service, entity, e.validEntityTypes)
206206
}
207207

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

218218
evElectricalConnection, err := util.ElectricalConnection(e.service, entity)
219219
if err != nil {
220-
return nil, nil, nil, eebusapi.ErrDataNotAvailable
220+
return 0.0, 0.0, 0.0, eebusapi.ErrDataNotAvailable
221221
}
222222

223-
var resultMin, resultMax, resultDefault []float64
224-
225-
for _, phaseName := range util.PhaseNameMapping {
226-
// electricalParameterDescription contains the measured phase for each measurementId
227-
elParamDesc, err := evElectricalConnection.GetParameterDescriptionForMeasuredPhase(phaseName)
228-
if err != nil || elParamDesc.ParameterId == nil {
229-
continue
230-
}
231-
232-
dataMin, dataMax, dataDefault, err := evElectricalConnection.GetLimitsForParameterId(*elParamDesc.ParameterId)
233-
if err != nil {
234-
continue
235-
}
236-
237-
// Min current data should be derived from min power data
238-
// but as this value is only properly provided via VAS the
239-
// currrent min values can not be trusted.
223+
elParamDesc, err := evElectricalConnection.GetParameterDescriptionForScopeType(model.ScopeTypeTypeACPowerTotal)
224+
if err != nil || elParamDesc.ParameterId == nil {
225+
return 0.0, 0.0, 0.0, eebusapi.ErrDataNotAvailable
226+
}
240227

241-
resultMin = append(resultMin, dataMin)
242-
resultMax = append(resultMax, dataMax)
243-
resultDefault = append(resultDefault, dataDefault)
228+
dataSet, err := evElectricalConnection.GetPermittedValueSetForParameterId(*elParamDesc.ParameterId)
229+
if err != nil || dataSet == nil ||
230+
dataSet.PermittedValueSet == nil ||
231+
len(dataSet.PermittedValueSet) != 1 ||
232+
dataSet.PermittedValueSet[0].Range == nil ||
233+
len(dataSet.PermittedValueSet[0].Range) != 1 {
234+
return 0.0, 0.0, 0.0, eebusapi.ErrDataNotAvailable
244235
}
245236

246-
if len(resultMin) == 0 {
247-
return nil, nil, nil, eebusapi.ErrDataNotAvailable
237+
var minValue, maxValue, standByValue float64
238+
if dataSet.PermittedValueSet[0].Range[0].Min != nil {
239+
minValue = dataSet.PermittedValueSet[0].Range[0].Min.GetValue()
240+
}
241+
if dataSet.PermittedValueSet[0].Range[0].Max != nil {
242+
maxValue = dataSet.PermittedValueSet[0].Range[0].Max.GetValue()
243+
}
244+
if dataSet.PermittedValueSet[0].Value != nil && len(dataSet.PermittedValueSet[0].Value) > 0 {
245+
standByValue = dataSet.PermittedValueSet[0].Value[0].GetValue()
248246
}
249247

250-
return resultMin, resultMax, resultDefault, nil
248+
return minValue, maxValue, standByValue, nil
251249
}
252250

253251
// is the EV in sleep mode

‎ucevcc/public_test.go

+40-99
Original file line numberDiff line numberDiff line change
@@ -292,43 +292,24 @@ func (s *UCEVCCSuite) Test_EVManufacturerData() {
292292
}
293293

294294
func (s *UCEVCCSuite) Test_EVCurrentLimits() {
295-
minData, maxData, defaultData, err := s.sut.CurrentLimits(s.mockRemoteEntity)
295+
minData, maxData, standByData, err := s.sut.CurrentLimits(s.mockRemoteEntity)
296296
assert.NotNil(s.T(), err)
297-
assert.Nil(s.T(), minData)
298-
assert.Nil(s.T(), maxData)
299-
assert.Nil(s.T(), defaultData)
297+
assert.Equal(s.T(), 0.0, minData)
298+
assert.Equal(s.T(), 0.0, maxData)
299+
assert.Equal(s.T(), 0.0, standByData)
300300

301-
minData, maxData, defaultData, err = s.sut.CurrentLimits(s.evEntity)
301+
minData, maxData, standByData, err = s.sut.CurrentLimits(s.evEntity)
302302
assert.NotNil(s.T(), err)
303-
assert.Nil(s.T(), minData)
304-
assert.Nil(s.T(), maxData)
305-
assert.Nil(s.T(), defaultData)
306-
307-
minData, maxData, defaultData, err = s.sut.CurrentLimits(s.evEntity)
308-
assert.NotNil(s.T(), err)
309-
assert.Nil(s.T(), minData)
310-
assert.Nil(s.T(), maxData)
311-
assert.Nil(s.T(), defaultData)
303+
assert.Equal(s.T(), 0.0, minData)
304+
assert.Equal(s.T(), 0.0, maxData)
305+
assert.Equal(s.T(), 0.0, standByData)
312306

313307
paramData := &model.ElectricalConnectionParameterDescriptionListDataType{
314308
ElectricalConnectionParameterDescriptionData: []model.ElectricalConnectionParameterDescriptionDataType{
315309
{
316310
ElectricalConnectionId: util.Ptr(model.ElectricalConnectionIdType(0)),
317311
ParameterId: util.Ptr(model.ElectricalConnectionParameterIdType(0)),
318-
MeasurementId: util.Ptr(model.MeasurementIdType(0)),
319-
AcMeasuredPhases: util.Ptr(model.ElectricalConnectionPhaseNameTypeA),
320-
},
321-
{
322-
ElectricalConnectionId: util.Ptr(model.ElectricalConnectionIdType(0)),
323-
ParameterId: util.Ptr(model.ElectricalConnectionParameterIdType(1)),
324-
MeasurementId: util.Ptr(model.MeasurementIdType(1)),
325-
AcMeasuredPhases: util.Ptr(model.ElectricalConnectionPhaseNameTypeB),
326-
},
327-
{
328-
ElectricalConnectionId: util.Ptr(model.ElectricalConnectionIdType(0)),
329-
ParameterId: util.Ptr(model.ElectricalConnectionParameterIdType(2)),
330-
MeasurementId: util.Ptr(model.MeasurementIdType(2)),
331-
AcMeasuredPhases: util.Ptr(model.ElectricalConnectionPhaseNameTypeC),
312+
ScopeType: util.Ptr(model.ScopeTypeTypeACPowerTotal),
332313
},
333314
},
334315
}
@@ -337,92 +318,57 @@ func (s *UCEVCCSuite) Test_EVCurrentLimits() {
337318
fErr := rFeature.UpdateData(model.FunctionTypeElectricalConnectionParameterDescriptionListData, paramData, nil, nil)
338319
assert.Nil(s.T(), fErr)
339320

340-
minData, maxData, defaultData, err = s.sut.CurrentLimits(s.evEntity)
321+
minData, maxData, standByData, err = s.sut.CurrentLimits(s.evEntity)
341322
assert.NotNil(s.T(), err)
342-
assert.Nil(s.T(), minData)
343-
assert.Nil(s.T(), maxData)
344-
assert.Nil(s.T(), defaultData)
323+
assert.Equal(s.T(), 0.0, minData)
324+
assert.Equal(s.T(), 0.0, maxData)
325+
assert.Equal(s.T(), 0.0, standByData)
345326

346327
type permittedStruct struct {
347-
defaultExists bool
348-
defaultValue, expectedDefaultValue float64
328+
standByValue, expectedStandByValue float64
349329
minValue, expectedMinValue float64
350330
maxValue, expectedMaxValue float64
351331
}
352332

353333
tests := []struct {
354334
name string
355-
permitted []permittedStruct
335+
permitted permittedStruct
356336
}{
357337
{
358-
"1 Phase ISO15118",
359-
[]permittedStruct{
360-
{true, 0.1, 0.1, 2, 2, 16, 16},
361-
},
362-
},
363-
{
364-
"1 Phase IEC61851",
365-
[]permittedStruct{
366-
{true, 0.0, 0.0, 6, 6, 16, 16},
367-
},
368-
},
369-
{
370-
"1 Phase IEC61851 Elli",
371-
[]permittedStruct{
372-
{false, 0.0, 0.0, 6, 6, 16, 16},
373-
},
338+
"IEC 3 Phase",
339+
permittedStruct{0.1, 0.1, 4287600, 4287600, 11433600, 11433600},
374340
},
375341
{
376-
"3 Phase ISO15118",
377-
[]permittedStruct{
378-
{true, 0.1, 0.1, 2, 2, 16, 16},
379-
{true, 0.1, 0.1, 2, 2, 16, 16},
380-
{true, 0.1, 0.1, 2, 2, 16, 16},
381-
},
342+
"ISO15118 VW",
343+
permittedStruct{0.1, 0.1, 800, 800, 11433600, 11433600},
382344
},
383345
{
384-
"3 Phase IEC61851",
385-
[]permittedStruct{
386-
{true, 0.0, 0.0, 6, 6, 16, 16},
387-
{true, 0.0, 0.0, 6, 6, 16, 16},
388-
{true, 0.0, 0.0, 6, 6, 16, 16},
389-
},
390-
},
391-
{
392-
"3 Phase IEC61851 Elli",
393-
[]permittedStruct{
394-
{false, 0.0, 0.0, 6, 6, 16, 16},
395-
{false, 0.0, 0.0, 6, 6, 16, 16},
396-
{false, 0.0, 0.0, 6, 6, 16, 16},
397-
},
346+
"ISO15118 Taycan",
347+
permittedStruct{0.1, 0.1, 400, 400, 11433600, 11433600},
398348
},
399349
}
400350

401351
for _, tc := range tests {
402352
s.T().Run(tc.name, func(t *testing.T) {
403353
dataSet := []model.ElectricalConnectionPermittedValueSetDataType{}
404354
permittedData := []model.ScaledNumberSetType{}
405-
for index, data := range tc.permitted {
406-
item := model.ScaledNumberSetType{
407-
Range: []model.ScaledNumberRangeType{
408-
{
409-
Min: model.NewScaledNumberType(data.minValue),
410-
Max: model.NewScaledNumberType(data.maxValue),
411-
},
355+
item := model.ScaledNumberSetType{
356+
Range: []model.ScaledNumberRangeType{
357+
{
358+
Min: model.NewScaledNumberType(tc.permitted.minValue),
359+
Max: model.NewScaledNumberType(tc.permitted.maxValue),
412360
},
413-
}
414-
if data.defaultExists {
415-
item.Value = []model.ScaledNumberType{*model.NewScaledNumberType(data.defaultValue)}
416-
}
417-
permittedData = append(permittedData, item)
418-
419-
permittedItem := model.ElectricalConnectionPermittedValueSetDataType{
420-
ElectricalConnectionId: util.Ptr(model.ElectricalConnectionIdType(0)),
421-
ParameterId: util.Ptr(model.ElectricalConnectionParameterIdType(index)),
422-
PermittedValueSet: permittedData,
423-
}
424-
dataSet = append(dataSet, permittedItem)
361+
},
362+
Value: []model.ScaledNumberType{*model.NewScaledNumberType(tc.permitted.standByValue)},
363+
}
364+
permittedData = append(permittedData, item)
365+
366+
permittedItem := model.ElectricalConnectionPermittedValueSetDataType{
367+
ElectricalConnectionId: util.Ptr(model.ElectricalConnectionIdType(0)),
368+
ParameterId: util.Ptr(model.ElectricalConnectionParameterIdType(0)),
369+
PermittedValueSet: permittedData,
425370
}
371+
dataSet = append(dataSet, permittedItem)
426372

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

434-
minData, maxData, defaultData, err = s.sut.CurrentLimits(s.evEntity)
380+
minData, maxData, standByData, err = s.sut.CurrentLimits(s.evEntity)
435381
assert.Nil(s.T(), err)
436382

437383
assert.Nil(s.T(), err)
438-
assert.Equal(s.T(), len(tc.permitted), len(minData))
439-
assert.Equal(s.T(), len(tc.permitted), len(maxData))
440-
assert.Equal(s.T(), len(tc.permitted), len(defaultData))
441-
for index, item := range tc.permitted {
442-
assert.Equal(s.T(), item.expectedMinValue, minData[index])
443-
assert.Equal(s.T(), item.expectedMaxValue, maxData[index])
444-
assert.Equal(s.T(), item.expectedDefaultValue, defaultData[index])
445-
}
384+
assert.Equal(s.T(), tc.permitted.expectedMinValue, minData)
385+
assert.Equal(s.T(), tc.permitted.expectedMaxValue, maxData)
386+
assert.Equal(s.T(), tc.permitted.expectedStandByValue, standByData)
446387
})
447388
}
448389
}

0 commit comments

Comments
 (0)