Implement the MPC and MGCP use case for Monitored Units

api/api.go

@@ -32,7 +32,7 @@ type ServiceInterface interface {
 	IsRunning() bool
 
 	// add a use case to the service
-	AddUseCase(useCase UseCaseInterface)
+	AddUseCase(useCase UseCaseInterface) error
 
 	// set logging interface
 	SetLogging(logger logging.LoggingInterface)

api/featuresserver.go

@@ -109,6 +109,13 @@ type ElectricalConnectionServerInterface interface {
 		deleteSelector *model.ElectricalConnectionPermittedValueSetListDataSelectorsType,
 		deleteElements *model.ElectricalConnectionPermittedValueSetDataElementsType,
 	) error
+
+	// either returns the given description id or creates a new one for the given description
+	//
+	// will return error if could not add the new description
+	GetOrAddIdForDescription(
+		electricalConnectionDescription model.ElectricalConnectionDescriptionDataType,
+	) (*model.ElectricalConnectionIdType, error)
 }
 
 type LoadControlLimitDataForID struct {

api/usecases.go

@@ -56,6 +56,15 @@ type UseCaseBaseInterface interface {
 type UseCaseInterface interface {
 	UseCaseBaseInterface
 
-	// add the features
-	AddFeatures()
+	// add the features described by the Use Case
+	//
+	// returns an error if any Feature could not be added
+	// - errors should not occur during normal usage of eebus-go, and should
+	//   generally be considered fatal implementation errors
+	// - if an error occurs while adding features to a new Entity, that Entity
+	//   will be in an incomplete state and should not be added to the service
+	//
+	// No cleanup occurs on error, some features may end up partially
+	// configured and unused
+	AddFeatures() error
 }

examples/ced/main.go

@@ -126,12 +126,18 @@ func (h *controlbox) run() {
 
 	localEntity := h.myService.LocalDevice().EntityForType(model.EntityTypeTypeHeatPumpAppliance)
 	h.uclpc = lpc.NewLPC(localEntity, h.OnLPCEvent)
-	h.myService.AddUseCase(h.uclpc)
+	err = h.myService.AddUseCase(h.uclpc)
+	if err != nil {
+		log.Fatal(err)
+	}
 	// h.uclpp = lpp.NewLPP(localEntity, h.OnLPPEvent)
 	// h.myService.AddUseCase(h.uclpp)
 
 	h.ucmpc = mpc.NewMPC(localEntity, h.OnMPCEvent)
-	h.myService.AddUseCase(h.ucmpc)
+	err = h.myService.AddUseCase(h.ucmpc)
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	if len(config.remoteSKI) == 0 && pairingConfig == nil {
 		os.Exit(0)

examples/controlbox/main.go

@@ -189,10 +189,16 @@ func (h *controlbox) run() {
 
 	localEntity := h.myService.LocalDevice().EntityForType(model.EntityTypeTypeGridGuard)
 	h.uclpc = lpc.NewLPC(localEntity, h.OnLPCEvent)
-	h.myService.AddUseCase(h.uclpc)
+	err = h.myService.AddUseCase(h.uclpc)
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	h.uclpp = lpp.NewLPP(localEntity, h.OnLPPEvent)
-	h.myService.AddUseCase(h.uclpp)
+	err = h.myService.AddUseCase(h.uclpp)
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	for _, remoteSki := range config.remoteSKIs {
 		h.myService.RegisterRemoteService(shipapi.NewServiceIdentity(remoteSki, "", ""))

examples/evse/main.go

@@ -119,7 +119,10 @@ func (h *evse) run() {
 
 	localEntity := h.myService.LocalDevice().EntityForType(model.EntityTypeTypeEVSE)
 	h.uclpc = lpc.NewLPC(localEntity, h.OnLPCEvent)
-	h.myService.AddUseCase(h.uclpc)
+	err = h.myService.AddUseCase(h.uclpc)
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	// Initialize local server data
 	_ = h.uclpc.SetConsumptionNominalMax(32000)

examples/hems/main.go

@@ -129,19 +129,46 @@ func (h *hems) run() {
 
 	localEntity := h.myService.LocalDevice().EntityForType(model.EntityTypeTypeCEM)
 	h.uccslpc = cslpc.NewLPC(localEntity, h.OnLPCEvent)
-	h.myService.AddUseCase(h.uccslpc)
+	err = h.myService.AddUseCase(h.uccslpc)
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	h.uccslpp = cslpp.NewLPP(localEntity, h.OnLPPEvent)
-	h.myService.AddUseCase(h.uccslpp)
+	err = h.myService.AddUseCase(h.uccslpp)
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	h.uceglpc = eglpc.NewLPC(localEntity, nil)
-	h.myService.AddUseCase(h.uceglpc)
+	err = h.myService.AddUseCase(h.uceglpc)
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	h.uceglpp = eglpp.NewLPP(localEntity, nil)
-	h.myService.AddUseCase(h.uceglpp)
+	err = h.myService.AddUseCase(h.uceglpp)
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	h.ucmamgcp = mgcp.NewMGCP(localEntity, h.OnMGCPEvent)
-	h.myService.AddUseCase(h.ucmamgcp)
+	err = h.myService.AddUseCase(h.ucmamgcp)
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	h.uccemvabd = vabd.NewVABD(localEntity, h.OnVABDEvent)
-	h.myService.AddUseCase(h.uccemvabd)
+	err = h.myService.AddUseCase(h.uccemvabd)
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	h.uccemvapd = vapd.NewVAPD(localEntity, h.OnVAPDEvent)
-	h.myService.AddUseCase(h.uccemvapd)
+	err = h.myService.AddUseCase(h.uccemvapd)
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	// Initialize local server data
 	_ = h.uccslpc.SetConsumptionNominalMax(32000)

examples/remote/ucs.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"fmt"
+	"log"
 
 	"github.com/enbility/eebus-go/api"
 	spineapi "github.com/enbility/spine-go/api"
@@ -31,7 +32,10 @@ func (r *Remote) RegisterUseCase(entityType model.EntityTypeType, usecaseId stri
 	) {
 		r.PropagateEvent(identifier, ski, device, entity, event)
 	})
-	r.service.AddUseCase(uc)
+	err := r.service.AddUseCase(uc)
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	return r.registerStaticReceiverProxy(usecaseId, uc)
 }

features/server/electricalconnection.go

@@ -31,6 +31,51 @@ func NewElectricalConnection(localEntity spineapi.EntityLocalInterface) (*Electr
 	return ec, nil
 }
 
+// Get or add the id for a electrical connection with a given electricalConnectionDescription
+//
+// NOTE: This can be used instead of AddDescription to be sure it exists only one id for the same description
+//
+// will return the id for the electrical connection with the given description
+func (e *ElectricalConnection) GetOrAddIdForDescription(
+	electricalConnectionDescription model.ElectricalConnectionDescriptionDataType,
+) (*model.ElectricalConnectionIdType, error) {
+	electricalConnectionId := (*model.ElectricalConnectionIdType)(nil)
+	highestExistingElectricalConnectionId := model.ElectricalConnectionIdType(0)
+
+	descriptionData := e.featureLocal.DataCopy(model.FunctionTypeElectricalConnectionDescriptionListData).(*model.ElectricalConnectionDescriptionListDataType)
+
+	if descriptionData != nil && descriptionData.ElectricalConnectionDescriptionData != nil {
+		for _, description := range descriptionData.ElectricalConnectionDescriptionData {
+			if description.ElectricalConnectionId != nil &&
+				description.PowerSupplyType == electricalConnectionDescription.PowerSupplyType &&
+				description.AcConnectedPhases == electricalConnectionDescription.AcConnectedPhases &&
+				description.AcRmsPeriodDuration == electricalConnectionDescription.AcRmsPeriodDuration &&
+				description.PositiveEnergyDirection == electricalConnectionDescription.PositiveEnergyDirection &&
+				description.ScopeType == electricalConnectionDescription.ScopeType &&
+				description.Label == electricalConnectionDescription.Label &&
+				description.Description == electricalConnectionDescription.Description {
+				electricalConnectionId = description.ElectricalConnectionId
+				return electricalConnectionId, nil
+			} else if description.ElectricalConnectionId != nil {
+				if *description.ElectricalConnectionId > highestExistingElectricalConnectionId {
+					highestExistingElectricalConnectionId = *description.ElectricalConnectionId
+				}
+			}
+		}
+	}
+
+	electricalConnectionId = util.Ptr(highestExistingElectricalConnectionId + 1)
+	description := electricalConnectionDescription
+	description.ElectricalConnectionId = electricalConnectionId
+	if errType := e.featureLocal.UpdateData(model.FunctionTypeElectricalConnectionDescriptionListData, &model.ElectricalConnectionDescriptionListDataType{
+		ElectricalConnectionDescriptionData: []model.ElectricalConnectionDescriptionDataType{description},
+	}, model.NewFilterTypePartial(), nil); errType != nil {
+		return nil, errors.New("could not add description data")
+	}
+
+	return electricalConnectionId, nil
+}
+
 // Add a new description data set
 //
 // NOTE: the electricalConnectionId has to be provided

features/server/electricalconnection_test.go

@@ -119,6 +119,40 @@ func (s *ElectricalConnectionSuite) Test_Description() {
 	assert.NotNil(s.T(), data)
 }
 
+func (s *ElectricalConnectionSuite) Test_GetOrAddIdForDescription() {
+	filter := model.ElectricalConnectionDescriptionDataType{}
+
+	data, err := s.sut.GetDescriptionsForFilter(filter)
+	assert.NotNil(s.T(), err)
+	assert.Nil(s.T(), data)
+
+	desc1 := model.ElectricalConnectionDescriptionDataType{
+		PowerSupplyType: util.Ptr(model.ElectricalConnectionVoltageTypeTypeDc),
+		ScopeType:       util.Ptr(model.ScopeTypeTypeACPowerTotal),
+	}
+
+	eConnectionId, err := s.sut.GetOrAddIdForDescription(desc1)
+	assert.Nil(s.T(), err)
+	assert.Equal(s.T(), model.ElectricalConnectionIdType(1), *eConnectionId)
+
+	eConnectionId, err = s.sut.GetOrAddIdForDescription(desc1)
+	assert.Nil(s.T(), err)
+	assert.Equal(s.T(), model.ElectricalConnectionIdType(1), *eConnectionId)
+
+	desc2 := model.ElectricalConnectionDescriptionDataType{
+		PowerSupplyType: util.Ptr(model.ElectricalConnectionVoltageTypeTypeAc),
+		ScopeType:       util.Ptr(model.ScopeTypeTypeACPowerTotal),
+	}
+
+	eConnectionId2, err := s.sut.GetOrAddIdForDescription(desc2)
+	assert.Nil(s.T(), err)
+	assert.Equal(s.T(), model.ElectricalConnectionIdType(2), *eConnectionId2)
+
+	eConnectionId, err = s.sut.GetOrAddIdForDescription(desc1)
+	assert.Nil(s.T(), err)
+	assert.Equal(s.T(), model.ElectricalConnectionIdType(1), *eConnectionId)
+}
+
 func (s *ElectricalConnectionSuite) Test_ParameterDescription() {
 	filter := model.ElectricalConnectionParameterDescriptionDataType{}