diff --git a/internal/pkg/onuadaptercore/mib_download.go b/internal/pkg/onuadaptercore/mib_download.go
index e79abe2..b369766 100644
--- a/internal/pkg/onuadaptercore/mib_download.go
+++ b/internal/pkg/onuadaptercore/mib_download.go
@@ -45,17 +45,40 @@
 
 func (onuDeviceEntry *OnuDeviceEntry) enterCreatingGalState(ctx context.Context, e *fsm.Event) {
 	logger.Debugw(ctx, "MibDownload FSM", log.Fields{"Tx create::GAL Ethernet Profile in state": e.FSM.Current(), "device-id": onuDeviceEntry.deviceID})
-	meInstance := onuDeviceEntry.PDevOmciCC.sendCreateGalEthernetProfile(log.WithSpanFromContext(context.TODO(), ctx), onuDeviceEntry.pOpenOnuAc.omciTimeout, true)
+	meInstance, err := onuDeviceEntry.PDevOmciCC.sendCreateGalEthernetProfile(log.WithSpanFromContext(context.TODO(), ctx), onuDeviceEntry.pOpenOnuAc.omciTimeout, true)
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
+	if err != nil {
+		logger.Errorw(ctx, "GalEthernetProfile create failed, aborting MibDownload FSM!",
+			log.Fields{"device-id": onuDeviceEntry.deviceID})
+		pMibDlFsm := onuDeviceEntry.pMibDownloadFsm
+		if pMibDlFsm != nil {
+			go func(a_pAFsm *AdapterFsm) {
+				_ = a_pAFsm.pFsm.Event(dlEvReset)
+			}(pMibDlFsm)
+		}
+		return
+	}
 	onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
 }
 
 func (onuDeviceEntry *OnuDeviceEntry) enterSettingOnu2gState(ctx context.Context, e *fsm.Event) {
 	logger.Debugw(ctx, "MibDownload FSM", log.Fields{"Tx Set::ONU2-G in state": e.FSM.Current(), "device-id": onuDeviceEntry.deviceID})
-	meInstance := onuDeviceEntry.PDevOmciCC.sendSetOnu2g(log.WithSpanFromContext(context.TODO(), ctx), onuDeviceEntry.pOpenOnuAc.omciTimeout, true)
+	meInstance, err := onuDeviceEntry.PDevOmciCC.sendSetOnu2g(log.WithSpanFromContext(context.TODO(), ctx),
+		onuDeviceEntry.pOpenOnuAc.omciTimeout, true)
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
+	if err != nil {
+		logger.Errorw(ctx, "ONU2-G set failed, aborting MibDownload FSM!",
+			log.Fields{"device-id": onuDeviceEntry.deviceID})
+		pMibDlFsm := onuDeviceEntry.pMibDownloadFsm
+		if pMibDlFsm != nil {
+			go func(a_pAFsm *AdapterFsm) {
+				_ = a_pAFsm.pFsm.Event(dlEvReset)
+			}(pMibDlFsm)
+		}
+		return
+	}
 	onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
 }
 
@@ -243,11 +266,16 @@
 			"device-id": onuDeviceEntry.deviceID, "for PortNo": uniNo})
 
 		//create MBSP
-		meInstance := onuDeviceEntry.PDevOmciCC.sendCreateMBServiceProfile(
+		meInstance, err := onuDeviceEntry.PDevOmciCC.sendCreateMBServiceProfile(
 			log.WithSpanFromContext(context.TODO(), ctx), uniPort, onuDeviceEntry.pOpenOnuAc.omciTimeout, true)
+		if err != nil {
+			logger.Errorw(ctx, "MBServiceProfile create failed, aborting MibDownload FSM!", log.Fields{"device-id": onuDeviceEntry.deviceID})
+			_ = onuDeviceEntry.pMibDownloadFsm.pFsm.Event(dlEvReset)
+			return
+		}
 		onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
 		//verify response
-		err := onuDeviceEntry.waitforOmciResponse(ctx, meInstance)
+		err = onuDeviceEntry.waitforOmciResponse(ctx, meInstance)
 		if err != nil {
 			logger.Errorw(ctx, "InitialBridgeSetup failed at MBSP, aborting MIB Download!",
 				log.Fields{"device-id": onuDeviceEntry.deviceID})
@@ -256,8 +284,14 @@
 		}
 
 		//create MBPCD
-		meInstance = onuDeviceEntry.PDevOmciCC.sendCreateMBPConfigData(
+		meInstance, err = onuDeviceEntry.PDevOmciCC.sendCreateMBPConfigData(
 			log.WithSpanFromContext(context.TODO(), ctx), uniPort, onuDeviceEntry.pOpenOnuAc.omciTimeout, true)
+		if err != nil {
+			logger.Errorw(ctx, "MBPConfigData create failed, aborting MibDownload FSM!",
+				log.Fields{"device-id": onuDeviceEntry.deviceID})
+			_ = onuDeviceEntry.pMibDownloadFsm.pFsm.Event(dlEvReset)
+			return
+		}
 		onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
 		//verify response
 		err = onuDeviceEntry.waitforOmciResponse(ctx, meInstance)
@@ -269,8 +303,14 @@
 		}
 
 		//create EVTOCD
-		meInstance = onuDeviceEntry.PDevOmciCC.sendCreateEVTOConfigData(
+		meInstance, err = onuDeviceEntry.PDevOmciCC.sendCreateEVTOConfigData(
 			log.WithSpanFromContext(context.TODO(), ctx), uniPort, onuDeviceEntry.pOpenOnuAc.omciTimeout, true)
+		if err != nil {
+			logger.Errorw(ctx, "EVTOConfigData create failed, aborting MibDownload FSM!",
+				log.Fields{"device-id": onuDeviceEntry.deviceID})
+			_ = onuDeviceEntry.pMibDownloadFsm.pFsm.Event(dlEvReset)
+			return
+		}
 		onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
 		//verify response
 		err = onuDeviceEntry.waitforOmciResponse(ctx, meInstance)
diff --git a/internal/pkg/onuadaptercore/mib_sync.go b/internal/pkg/onuadaptercore/mib_sync.go
index 8ae5742..2191a75 100644
--- a/internal/pkg/onuadaptercore/mib_sync.go
+++ b/internal/pkg/onuadaptercore/mib_sync.go
@@ -97,9 +97,19 @@
 func (oo *OnuDeviceEntry) enterGettingVendorAndSerialState(ctx context.Context, e *fsm.Event) {
 	logger.Debugw(ctx, "MibSync FSM", log.Fields{"Start getting VendorId and SerialNumber in State": e.FSM.Current(), "device-id": oo.deviceID})
 	requestedAttributes := me.AttributeValueMap{"VendorId": "", "SerialNumber": 0}
-	meInstance := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.OnuGClassID, onugMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
+	meInstance, err := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.OnuGClassID, onugMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
+	if err != nil {
+		logger.Errorw(ctx, "ONU-G get failed, aborting MibSync FSM", log.Fields{"device-id": oo.deviceID})
+		pMibUlFsm := oo.pMibUploadFsm
+		if pMibUlFsm != nil {
+			go func(a_pAFsm *AdapterFsm) {
+				_ = oo.pMibUploadFsm.pFsm.Event(ulEvResetMib)
+			}(pMibUlFsm)
+		}
+		return
+	}
 	oo.lastTxParamStruct.lastTxMessageType = omci.GetRequestType
 	oo.lastTxParamStruct.pLastTxMeInstance = meInstance
 }
@@ -107,9 +117,19 @@
 func (oo *OnuDeviceEntry) enterGettingEquipmentIDState(ctx context.Context, e *fsm.Event) {
 	logger.Debugw(ctx, "MibSync FSM", log.Fields{"Start getting EquipmentId in State": e.FSM.Current(), "device-id": oo.deviceID})
 	requestedAttributes := me.AttributeValueMap{"EquipmentId": ""}
-	meInstance := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.Onu2GClassID, onu2gMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
+	meInstance, err := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.Onu2GClassID, onu2gMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
+	if err != nil {
+		logger.Errorw(ctx, "ONU2-G get failed, aborting MibSync FSM!", log.Fields{"device-id": oo.deviceID})
+		pMibUlFsm := oo.pMibUploadFsm
+		if pMibUlFsm != nil {
+			go func(a_pAFsm *AdapterFsm) {
+				_ = oo.pMibUploadFsm.pFsm.Event(ulEvResetMib)
+			}(pMibUlFsm)
+		}
+		return
+	}
 	oo.lastTxParamStruct.lastTxMessageType = omci.GetRequestType
 	oo.lastTxParamStruct.pLastTxMeInstance = meInstance
 }
@@ -117,9 +137,19 @@
 func (oo *OnuDeviceEntry) enterGettingFirstSwVersionState(ctx context.Context, e *fsm.Event) {
 	logger.Debugw(ctx, "MibSync FSM", log.Fields{"Start getting IsActive and Version of first SW-image in State": e.FSM.Current(), "device-id": oo.deviceID})
 	requestedAttributes := me.AttributeValueMap{"IsCommitted": 0, "IsActive": 0, "Version": ""}
-	meInstance := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.SoftwareImageClassID, firstSwImageMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
+	meInstance, err := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.SoftwareImageClassID, firstSwImageMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
+	if err != nil {
+		logger.Errorw(ctx, "SoftwareImage get failed, aborting MibSync FSM", log.Fields{"device-id": oo.deviceID})
+		pMibUlFsm := oo.pMibUploadFsm
+		if pMibUlFsm != nil {
+			go func(a_pAFsm *AdapterFsm) {
+				_ = oo.pMibUploadFsm.pFsm.Event(ulEvResetMib)
+			}(pMibUlFsm)
+		}
+		return
+	}
 	oo.lastTxParamStruct.lastTxMessageType = omci.GetRequestType
 	oo.lastTxParamStruct.pLastTxMeInstance = meInstance
 }
@@ -127,9 +157,19 @@
 func (oo *OnuDeviceEntry) enterGettingSecondSwVersionState(ctx context.Context, e *fsm.Event) {
 	logger.Debugw(ctx, "MibSync FSM", log.Fields{"Start getting IsActive and Version of second SW-image in State": e.FSM.Current(), "device-id": oo.deviceID})
 	requestedAttributes := me.AttributeValueMap{"IsCommitted": 0, "IsActive": 0, "Version": ""}
-	meInstance := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.SoftwareImageClassID, secondSwImageMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
+	meInstance, err := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.SoftwareImageClassID, secondSwImageMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
+	if err != nil {
+		logger.Errorw(ctx, "SoftwareImage get failed, aborting MibSync FSM", log.Fields{"device-id": oo.deviceID})
+		pMibUlFsm := oo.pMibUploadFsm
+		if pMibUlFsm != nil {
+			go func(a_pAFsm *AdapterFsm) {
+				_ = oo.pMibUploadFsm.pFsm.Event(ulEvResetMib)
+			}(pMibUlFsm)
+		}
+		return
+	}
 	oo.lastTxParamStruct.lastTxMessageType = omci.GetRequestType
 	oo.lastTxParamStruct.pLastTxMeInstance = meInstance
 }
@@ -137,9 +177,19 @@
 func (oo *OnuDeviceEntry) enterGettingMacAddressState(ctx context.Context, e *fsm.Event) {
 	logger.Debugw(ctx, "MibSync FSM", log.Fields{"Start getting MacAddress in State": e.FSM.Current(), "device-id": oo.deviceID})
 	requestedAttributes := me.AttributeValueMap{"MacAddress": ""}
-	meInstance := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.IpHostConfigDataClassID, ipHostConfigDataMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
+	meInstance, err := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx), me.IpHostConfigDataClassID, ipHostConfigDataMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
+	if err != nil {
+		logger.Errorw(ctx, "IpHostConfigData get failed, aborting MibSync FSM", log.Fields{"device-id": oo.deviceID})
+		pMibUlFsm := oo.pMibUploadFsm
+		if pMibUlFsm != nil {
+			go func(a_pAFsm *AdapterFsm) {
+				_ = oo.pMibUploadFsm.pFsm.Event(ulEvResetMib)
+			}(pMibUlFsm)
+		}
+		return
+	}
 	oo.lastTxParamStruct.lastTxMessageType = omci.GetRequestType
 	oo.lastTxParamStruct.pLastTxMeInstance = meInstance
 }
@@ -383,8 +433,13 @@
 		if oo.lastTxParamStruct.lastTxMessageType == omci.GetRequestType && oo.lastTxParamStruct.repeatCount == 0 {
 			logger.Debugw(ctx, "MibSync FSM - repeat MdsGetRequest (updated SequenceNumber)", log.Fields{"device-id": oo.deviceID})
 			requestedAttributes := me.AttributeValueMap{"MibDataSync": ""}
-			_ = oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx),
+			_, err := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx),
 				me.OnuDataClassID, onuDataMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
+			if err != nil {
+				logger.Errorw(ctx, "ONUData get failed, aborting MibSync", log.Fields{"device-id": oo.deviceID})
+				_ = oo.pMibUploadFsm.pFsm.Event(ulEvResetMib)
+				return
+			}
 			//TODO: needs extra handling of timeouts
 			oo.lastTxParamStruct.repeatCount = 1
 			return
@@ -788,10 +843,20 @@
 func (oo *OnuDeviceEntry) requestMdsValue(ctx context.Context) {
 	logger.Debugw(ctx, "Request MDS value", log.Fields{"device-id": oo.deviceID})
 	requestedAttributes := me.AttributeValueMap{"MibDataSync": ""}
-	meInstance := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx),
+	meInstance, err := oo.PDevOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx),
 		me.OnuDataClassID, onuDataMeID, requestedAttributes, oo.pOpenOnuAc.omciTimeout, true, oo.pMibUploadFsm.commChan)
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
+	if err != nil {
+		logger.Errorw(ctx, "ONUData get failed, aborting MibSync FSM!", log.Fields{"device-id": oo.deviceID})
+		pMibUlFsm := oo.pMibUploadFsm
+		if pMibUlFsm != nil {
+			go func(a_pAFsm *AdapterFsm) {
+				_ = oo.pMibUploadFsm.pFsm.Event(ulEvResetMib)
+			}(pMibUlFsm)
+		}
+		return
+	}
 	oo.lastTxParamStruct.lastTxMessageType = omci.GetRequestType
 	oo.lastTxParamStruct.pLastTxMeInstance = meInstance
 	oo.lastTxParamStruct.repeatCount = 0
diff --git a/internal/pkg/onuadaptercore/omci_ani_config.go b/internal/pkg/onuadaptercore/omci_ani_config.go
index 296977d..e03eb17 100644
--- a/internal/pkg/onuadaptercore/omci_ani_config.go
+++ b/internal/pkg/onuadaptercore/omci_ani_config.go
@@ -510,12 +510,28 @@
 		"device-id": oFsm.deviceID, "uni-id": oFsm.pOnuUniPort.uniID})
 	oFsm.requestEventOffset = 0 //0 offset for last config request activity
 	oFsm.mutexPLastTxMeInstance.Lock()
-	defer oFsm.mutexPLastTxMeInstance.Unlock()
-	meInstance := oFsm.pOmciCC.sendCreateDot1PMapper(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+	meInstance, err := oFsm.pOmciCC.sendCreateDot1PMapper(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 		oFsm.mapperSP0ID, oFsm.pAdaptFsm.commChan)
+	if err != nil {
+		logger.Errorw(ctx, "Dot1PMapper create failed, aborting uniPonAniConfigFsm!",
+			log.Fields{"device-id": oFsm.deviceID})
+		pConfigAniStateAFsm := oFsm.pAdaptFsm
+		if pConfigAniStateAFsm != nil {
+			oFsm.mutexPLastTxMeInstance.Unlock()
+			// obviously calling some FSM event here directly does not work - so trying to decouple it ...
+			go func(aPAFsm *AdapterFsm) {
+				if aPAFsm != nil && aPAFsm.pFsm != nil {
+					_ = aPAFsm.pFsm.Event(aniEvReset)
+				}
+			}(pConfigAniStateAFsm)
+			return
+		}
+	}
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
 	oFsm.pLastTxMeInstance = meInstance
+	oFsm.mutexPLastTxMeInstance.Unlock()
+
 }
 
 func (oFsm *uniPonAniConfigFsm) enterCreatingMBPCD(ctx context.Context, e *fsm.Event) {
@@ -534,12 +550,28 @@
 		},
 	}
 	oFsm.mutexPLastTxMeInstance.Lock()
-	defer oFsm.mutexPLastTxMeInstance.Unlock()
-	meInstance := oFsm.pOmciCC.sendCreateMBPConfigDataVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+	meInstance, err := oFsm.pOmciCC.sendCreateMBPConfigDataVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 		oFsm.pAdaptFsm.commChan, meParams)
+	if err != nil {
+		logger.Errorw(ctx, "MBPConfigDataVar create failed, aborting uniPonAniConfigFsm!",
+			log.Fields{"device-id": oFsm.deviceID})
+		pConfigAniStateAFsm := oFsm.pAdaptFsm
+		if pConfigAniStateAFsm != nil {
+			oFsm.mutexPLastTxMeInstance.Unlock()
+			// obviously calling some FSM event here directly does not work - so trying to decouple it ...
+			go func(aPAFsm *AdapterFsm) {
+				if aPAFsm != nil && aPAFsm.pFsm != nil {
+					_ = aPAFsm.pFsm.Event(aniEvReset)
+				}
+			}(pConfigAniStateAFsm)
+			return
+		}
+	}
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
 	oFsm.pLastTxMeInstance = meInstance
+	oFsm.mutexPLastTxMeInstance.Unlock()
+
 }
 
 func (oFsm *uniPonAniConfigFsm) enterSettingTconts(ctx context.Context, e *fsm.Event) {
@@ -554,12 +586,28 @@
 		},
 	}
 	oFsm.mutexPLastTxMeInstance.Lock()
-	defer oFsm.mutexPLastTxMeInstance.Unlock()
-	meInstance := oFsm.pOmciCC.sendSetTcontVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+	meInstance, err := oFsm.pOmciCC.sendSetTcontVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 		oFsm.pAdaptFsm.commChan, meParams)
+	if err != nil {
+		logger.Errorw(ctx, "TcontVar set failed, aborting uniPonAniConfigFsm!",
+			log.Fields{"device-id": oFsm.deviceID})
+		pConfigAniStateAFsm := oFsm.pAdaptFsm
+		if pConfigAniStateAFsm != nil {
+			oFsm.mutexPLastTxMeInstance.Unlock()
+			// obviously calling some FSM event here directly does not work - so trying to decouple it ...
+			go func(aPAFsm *AdapterFsm) {
+				if aPAFsm != nil && aPAFsm.pFsm != nil {
+					_ = aPAFsm.pFsm.Event(aniEvReset)
+				}
+			}(pConfigAniStateAFsm)
+			return
+		}
+	}
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
 	oFsm.pLastTxMeInstance = meInstance
+	oFsm.mutexPLastTxMeInstance.Unlock()
+
 }
 
 func (oFsm *uniPonAniConfigFsm) enterCreatingGemNCTPs(ctx context.Context, e *fsm.Event) {
@@ -674,18 +722,33 @@
 			// obviously calling some FSM event here directly does not work - so trying to decouple it ...
 			go func(aPAFsm *AdapterFsm) {
 				if aPAFsm != nil && aPAFsm.pFsm != nil {
-					_ = oFsm.pAdaptFsm.pFsm.Event(aniEvRxDot1pmapSResp)
+					_ = aPAFsm.pFsm.Event(aniEvRxDot1pmapSResp)
 				}
 			}(pConfigAniStateAFsm)
 		}
 	} else {
 		oFsm.mutexPLastTxMeInstance.Lock()
-		defer oFsm.mutexPLastTxMeInstance.Unlock()
-		meInstance := oFsm.pOmciCC.sendSetDot1PMapperVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+		meInstance, err := oFsm.pOmciCC.sendSetDot1PMapperVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 			oFsm.pAdaptFsm.commChan, meParams)
+		if err != nil {
+			logger.Errorw(ctx, "Dot1PMapperVar set failed, aborting uniPonAniConfigFsm!",
+				log.Fields{"device-id": oFsm.deviceID})
+			pConfigAniStateAFsm := oFsm.pAdaptFsm
+			if pConfigAniStateAFsm != nil {
+				oFsm.mutexPLastTxMeInstance.Unlock()
+				// obviously calling some FSM event here directly does not work - so trying to decouple it ...
+				go func(aPAFsm *AdapterFsm) {
+					if aPAFsm != nil && aPAFsm.pFsm != nil {
+						_ = aPAFsm.pFsm.Event(aniEvReset)
+					}
+				}(pConfigAniStateAFsm)
+				return
+			}
+		}
 		//accept also nil as (error) return value for writing to LastTx
 		//  - this avoids misinterpretation of new received OMCI messages
 		oFsm.pLastTxMeInstance = meInstance
+		oFsm.mutexPLastTxMeInstance.Unlock()
 	}
 }
 
@@ -734,7 +797,7 @@
 			// obviously calling some FSM event here directly does not work - so trying to decouple it ...
 			go func(aPAFsm *AdapterFsm) {
 				if aPAFsm != nil && aPAFsm.pFsm != nil {
-					_ = oFsm.pAdaptFsm.pFsm.Event(aniEvWaitFlowRem)
+					_ = aPAFsm.pFsm.Event(aniEvWaitFlowRem)
 				}
 			}(pConfigAniStateAFsm)
 		} else {
@@ -753,10 +816,25 @@
 
 	// this state entry is only expected in a suitable state (checked outside in onu_uni_tp)
 	oFsm.mutexPLastTxMeInstance.Lock()
-	defer oFsm.mutexPLastTxMeInstance.Unlock()
-	meInstance := oFsm.pOmciCC.sendDeleteGemIWTP(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+	meInstance, err := oFsm.pOmciCC.sendDeleteGemIWTP(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 		oFsm.pAdaptFsm.commChan, loGemPortID)
+	if err != nil {
+		logger.Errorw(ctx, "GemIWTP delete failed, aborting uniPonAniConfigFsm!",
+			log.Fields{"device-id": oFsm.deviceID})
+		pConfigAniStateAFsm := oFsm.pAdaptFsm
+		if pConfigAniStateAFsm != nil {
+			oFsm.mutexPLastTxMeInstance.Unlock()
+			// obviously calling some FSM event here directly does not work - so trying to decouple it ...
+			go func(aPAFsm *AdapterFsm) {
+				if aPAFsm != nil && aPAFsm.pFsm != nil {
+					_ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
+				}
+			}(pConfigAniStateAFsm)
+			return
+		}
+	}
 	oFsm.pLastTxMeInstance = meInstance
+	oFsm.mutexPLastTxMeInstance.Unlock()
 }
 
 func (oFsm *uniPonAniConfigFsm) enterWaitingFlowRem(ctx context.Context, e *fsm.Event) {
@@ -779,7 +857,7 @@
 			// obviously calling some FSM event here directly does not work - so trying to decouple it ...
 			go func(aPAFsm *AdapterFsm) {
 				if aPAFsm != nil && aPAFsm.pFsm != nil {
-					_ = oFsm.pAdaptFsm.pFsm.Event(aniEvFlowRemDone)
+					_ = aPAFsm.pFsm.Event(aniEvFlowRemDone)
 				}
 			}(pConfigAniStateAFsm)
 		} else {
@@ -800,7 +878,7 @@
 				// obviously calling some FSM event here directly does not work - so trying to decouple it ...
 				go func(aPAFsm *AdapterFsm) {
 					if aPAFsm != nil && aPAFsm.pFsm != nil {
-						_ = oFsm.pAdaptFsm.pFsm.Event(aniEvFlowRemDone)
+						_ = aPAFsm.pFsm.Event(aniEvFlowRemDone)
 					}
 				}(pConfigAniStateAFsm)
 			} else {
@@ -838,10 +916,26 @@
 		"GemNCTP-entity-id": loGemPortID})
 	// this state entry is only expected in a suitable state (checked outside in onu_uni_tp)
 	oFsm.mutexPLastTxMeInstance.Lock()
-	meInstance := oFsm.pOmciCC.sendDeleteGemNCTP(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+	meInstance, err := oFsm.pOmciCC.sendDeleteGemNCTP(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 		oFsm.pAdaptFsm.commChan, loGemPortID)
+	if err != nil {
+		logger.Errorw(ctx, "GemNCTP delete failed, aborting uniPonAniConfigFsm!",
+			log.Fields{"device-id": oFsm.deviceID})
+		pConfigAniStateAFsm := oFsm.pAdaptFsm
+		if pConfigAniStateAFsm != nil {
+			oFsm.mutexPLastTxMeInstance.Unlock()
+			// obviously calling some FSM event here directly does not work - so trying to decouple it ...
+			go func(aPAFsm *AdapterFsm) {
+				if aPAFsm != nil && aPAFsm.pFsm != nil {
+					_ = aPAFsm.pFsm.Event(aniEvReset)
+				}
+			}(pConfigAniStateAFsm)
+			return
+		}
+	}
 	oFsm.pLastTxMeInstance = meInstance
 	oFsm.mutexPLastTxMeInstance.Unlock()
+
 	// Mark the gem port to be removed for Performance History monitoring
 	if oFsm.pDeviceHandler.pOnuMetricsMgr != nil {
 		oFsm.pDeviceHandler.pOnuMetricsMgr.RemoveGemPortForPerfMonitoring(ctx, loGemPortID)
@@ -861,10 +955,26 @@
 		},
 	}
 	oFsm.mutexPLastTxMeInstance.Lock()
-	defer oFsm.mutexPLastTxMeInstance.Unlock()
-	meInstance := oFsm.pOmciCC.sendSetTcontVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+	meInstance, err := oFsm.pOmciCC.sendSetTcontVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 		oFsm.pAdaptFsm.commChan, meParams)
+	if err != nil {
+		logger.Errorw(ctx, "TcontVar set failed, aborting uniPonAniConfigFsm!",
+			log.Fields{"device-id": oFsm.deviceID})
+		pConfigAniStateAFsm := oFsm.pAdaptFsm
+		if pConfigAniStateAFsm != nil {
+			oFsm.mutexPLastTxMeInstance.Unlock()
+			// obviously calling some FSM event here directly does not work - so trying to decouple it ...
+			go func(aPAFsm *AdapterFsm) {
+				if aPAFsm != nil && aPAFsm.pFsm != nil {
+					_ = aPAFsm.pFsm.Event(aniEvReset)
+				}
+			}(pConfigAniStateAFsm)
+			return
+		}
+	}
 	oFsm.pLastTxMeInstance = meInstance
+	oFsm.mutexPLastTxMeInstance.Unlock()
+
 }
 
 func (oFsm *uniPonAniConfigFsm) enterRemoving1pMapper(ctx context.Context, e *fsm.Event) {
@@ -872,10 +982,26 @@
 		"device-id": oFsm.deviceID, "uni-id": oFsm.pOnuUniPort.uniID})
 
 	oFsm.mutexPLastTxMeInstance.Lock()
-	defer oFsm.mutexPLastTxMeInstance.Unlock()
-	meInstance := oFsm.pOmciCC.sendDeleteDot1PMapper(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+	meInstance, err := oFsm.pOmciCC.sendDeleteDot1PMapper(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 		oFsm.pAdaptFsm.commChan, oFsm.mapperSP0ID)
+	if err != nil {
+		logger.Errorw(ctx, "Dot1Mapper delete failed, aborting uniPonAniConfigFsm!",
+			log.Fields{"device-id": oFsm.deviceID})
+		pConfigAniStateAFsm := oFsm.pAdaptFsm
+		if pConfigAniStateAFsm != nil {
+			oFsm.mutexPLastTxMeInstance.Unlock()
+			// obviously calling some FSM event here directly does not work - so trying to decouple it ...
+			go func(aPAFsm *AdapterFsm) {
+				if aPAFsm != nil && aPAFsm.pFsm != nil {
+					_ = aPAFsm.pFsm.Event(aniEvReset)
+				}
+			}(pConfigAniStateAFsm)
+			return
+		}
+	}
 	oFsm.pLastTxMeInstance = meInstance
+	oFsm.mutexPLastTxMeInstance.Unlock()
+
 }
 
 func (oFsm *uniPonAniConfigFsm) enterRemovingAniBPCD(ctx context.Context, e *fsm.Event) {
@@ -883,10 +1009,25 @@
 		"device-id": oFsm.deviceID, "uni-id": oFsm.pOnuUniPort.uniID})
 
 	oFsm.mutexPLastTxMeInstance.Lock()
-	defer oFsm.mutexPLastTxMeInstance.Unlock()
-	meInstance := oFsm.pOmciCC.sendDeleteMBPConfigData(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+	meInstance, err := oFsm.pOmciCC.sendDeleteMBPConfigData(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 		oFsm.pAdaptFsm.commChan, oFsm.macBPCD0ID)
+	if err != nil {
+		logger.Errorw(ctx, "MBPConfigData delete failed, aborting uniPonAniConfigFsm!",
+			log.Fields{"device-id": oFsm.deviceID})
+		pConfigAniStateAFsm := oFsm.pAdaptFsm
+		if pConfigAniStateAFsm != nil {
+			oFsm.mutexPLastTxMeInstance.Unlock()
+			// obviously calling some FSM event here directly does not work - so trying to decouple it ...
+			go func(aPAFsm *AdapterFsm) {
+				if aPAFsm != nil && aPAFsm.pFsm != nil {
+					_ = aPAFsm.pFsm.Event(aniEvReset)
+				}
+			}(pConfigAniStateAFsm)
+			return
+		}
+	}
 	oFsm.pLastTxMeInstance = meInstance
+	oFsm.mutexPLastTxMeInstance.Unlock()
 }
 
 func (oFsm *uniPonAniConfigFsm) enterAniRemoveDone(ctx context.Context, e *fsm.Event) {
@@ -1220,15 +1361,21 @@
 			},
 		}
 		oFsm.mutexPLastTxMeInstance.Lock()
-		meInstance := oFsm.pOmciCC.sendCreateGemNCTPVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+		meInstance, err := oFsm.pOmciCC.sendCreateGemNCTPVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 			oFsm.pAdaptFsm.commChan, meParams)
+		if err != nil {
+			oFsm.mutexPLastTxMeInstance.Unlock()
+			logger.Errorw(ctx, "GemNCTPVar create failed, aborting uniPonAniConfigFsm!",
+				log.Fields{"device-id": oFsm.deviceID})
+			_ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
+			return
+		}
 		//accept also nil as (error) return value for writing to LastTx
 		//  - this avoids misinterpretation of new received OMCI messages
 		oFsm.pLastTxMeInstance = meInstance
 		oFsm.mutexPLastTxMeInstance.Unlock()
-
 		//verify response
-		err := oFsm.waitforOmciResponse(ctx)
+		err = oFsm.waitforOmciResponse(ctx)
 		if err != nil {
 			logger.Errorw(ctx, "GemNWCtp create failed, aborting AniConfig FSM!",
 				log.Fields{"device-id": oFsm.deviceID, "GemIndex": gemIndex})
@@ -1267,14 +1414,22 @@
 				},
 			}
 			oFsm.mutexPLastTxMeInstance.Lock()
-			meInstance := oFsm.pOmciCC.sendCreateMulticastGemIWTPVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
+			meInstance, err := oFsm.pOmciCC.sendCreateMulticastGemIWTPVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
 				true, oFsm.pAdaptFsm.commChan, meParams)
+			if err != nil {
+				oFsm.mutexPLastTxMeInstance.Unlock()
+				logger.Errorw(ctx, "MulticastGemIWTPVar create failed, aborting uniPonAniConfigFsm!",
+					log.Fields{"device-id": oFsm.deviceID})
+				_ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
+				return
+
+			}
 			oFsm.pLastTxMeInstance = meInstance
 			oFsm.mutexPLastTxMeInstance.Unlock()
 			//verify response
-			err := oFsm.waitforOmciResponse(ctx)
+			err = oFsm.waitforOmciResponse(ctx)
 			if err != nil {
-				logger.Errorw(ctx, "GemTP IW multicast create failed, aborting AniConfig FSM!",
+				logger.Errorw(ctx, "MulticastGemIWTP create failed, aborting AniConfig FSM!",
 					log.Fields{"device-id": oFsm.deviceID, "GemIndex": gemIndex})
 				_ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
 				return
@@ -1296,8 +1451,15 @@
 				},
 			}
 			oFsm.mutexPLastTxMeInstance.Lock()
-			meIPV4MCTableInstance := oFsm.pOmciCC.sendSetMulticastGemIWTPVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
+			meIPV4MCTableInstance, err := oFsm.pOmciCC.sendSetMulticastGemIWTPVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
 				true, oFsm.pAdaptFsm.commChan, meIPV4MCTableParams)
+			if err != nil {
+				oFsm.mutexPLastTxMeInstance.Unlock()
+				logger.Errorw(ctx, "MulticastGemIWTPVar set failed, aborting uniPonAniConfigFsm!",
+					log.Fields{"device-id": oFsm.deviceID})
+				_ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
+				return
+			}
 			oFsm.pLastTxMeInstance = meIPV4MCTableInstance
 			oFsm.mutexPLastTxMeInstance.Unlock()
 
@@ -1313,8 +1475,15 @@
 				},
 			}
 			oFsm.mutexPLastTxMeInstance.Lock()
-			meInstance := oFsm.pOmciCC.sendCreateGemIWTPVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+			meInstance, err := oFsm.pOmciCC.sendCreateGemIWTPVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 				oFsm.pAdaptFsm.commChan, meParams)
+			if err != nil {
+				oFsm.mutexPLastTxMeInstance.Unlock()
+				logger.Errorw(ctx, "GEMIWTPVar create failed, aborting uniPonAniConfigFsm!",
+					log.Fields{"device-id": oFsm.deviceID})
+				_ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
+				return
+			}
 			//accept also nil as (error) return value for writing to LastTx
 			//  - this avoids misinterpretation of new received OMCI messages
 			oFsm.pLastTxMeInstance = meInstance
@@ -1389,15 +1558,22 @@
 			meParams.Attributes["Weight"] = uint8(kv.Value.(uint16))
 		}
 		oFsm.mutexPLastTxMeInstance.Lock()
-		meInstance := oFsm.pOmciCC.sendSetPrioQueueVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+		meInstance, err := oFsm.pOmciCC.sendSetPrioQueueVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 			oFsm.pAdaptFsm.commChan, meParams)
+		if err != nil {
+			oFsm.mutexPLastTxMeInstance.Unlock()
+			logger.Errorw(ctx, "PrioQueueVar set failed, aborting uniPonAniConfigFsm!",
+				log.Fields{"device-id": oFsm.deviceID})
+			_ = oFsm.pAdaptFsm.pFsm.Event(aniEvReset)
+			return
+		}
 		//accept also nil as (error) return value for writing to LastTx
 		//  - this avoids misinterpretation of new received OMCI messages
 		oFsm.pLastTxMeInstance = meInstance
 		oFsm.mutexPLastTxMeInstance.Unlock()
 
 		//verify response
-		err := oFsm.waitforOmciResponse(ctx)
+		err = oFsm.waitforOmciResponse(ctx)
 		if err != nil {
 			logger.Errorw(ctx, "PrioQueue set failed, aborting AniConfig FSM!",
 				log.Fields{"device-id": oFsm.deviceID, "QueueId": strconv.FormatInt(int64(queueIndex), 16)})
diff --git a/internal/pkg/onuadaptercore/omci_cc.go b/internal/pkg/onuadaptercore/omci_cc.go
index 58082a3..d66ca20 100644
--- a/internal/pkg/onuadaptercore/omci_cc.go
+++ b/internal/pkg/onuadaptercore/omci_cc.go
@@ -830,7 +830,7 @@
 	return oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 }
 
-func (oo *omciCC) sendCreateGalEthernetProfile(ctx context.Context, timeout int, highPrio bool) *me.ManagedEntity {
+func (oo *omciCC) sendCreateGalEthernetProfile(ctx context.Context, timeout int, highPrio bool) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send GalEnetProfile-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16)})
@@ -846,14 +846,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode GalEnetProfileInstance for create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize GalEnetProfile create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -864,18 +864,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send GalEnetProfile create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send GalEnetProfile-Create-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate GalEnetProfileInstance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 // might be needed to extend for parameter arguments, here just for setting the ConnectivityMode!!
-func (oo *omciCC) sendSetOnu2g(ctx context.Context, timeout int, highPrio bool) *me.ManagedEntity {
+func (oo *omciCC) sendSetOnu2g(ctx context.Context, timeout int, highPrio bool) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send ONU2-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16)})
@@ -894,14 +894,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode ONU2-G instance for set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize ONU2-G set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -912,18 +912,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send ONU2-G set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send ONU2-G-Set-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate ONU2-G", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateMBServiceProfile(ctx context.Context,
-	aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
+	aPUniPort *onuUniPort, timeout int, highPrio bool) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	instID := macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo)
 	logger.Debugw(ctx, "send MBSP-Create-msg:", log.Fields{"device-id": oo.deviceID,
@@ -948,14 +948,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode MBSP for create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize MBSP create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -966,18 +966,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send MBSP create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send MBSP-Create-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate MBSP Instance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateMBPConfigData(ctx context.Context,
-	aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
+	aPUniPort *onuUniPort, timeout int, highPrio bool) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	instID := macBridgePortAniEID + aPUniPort.entityID
 	logger.Debugw(ctx, "send MBPCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
@@ -1000,14 +1000,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode MBPCD for create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize MBPCD create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1018,18 +1018,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send MBPCD create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send MBPCD-Create-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate MBPCD Instance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateEVTOConfigData(ctx context.Context,
-	aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
+	aPUniPort *onuUniPort, timeout int, highPrio bool) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	//same entityId is used as for MBSP (see there), but just arbitrary ...
 	instID := macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo)
@@ -1057,14 +1057,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode EVTOCD for create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize EVTOCD create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1075,18 +1075,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send EVTOCD create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send EVTOCD-Create-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendSetOnuGLS(ctx context.Context, timeout int,
-	highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
+	highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send ONU-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16)})
@@ -1102,14 +1102,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode ONU-G instance for set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize ONU-G set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1120,18 +1120,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send ONU-G set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send ONU-G-Set-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate ONU-G", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendSetPptpEthUniLS(ctx context.Context, aInstNo uint16, timeout int,
-	highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
+	highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send PPTPEthUni-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16)})
@@ -1147,14 +1147,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode PPTPEthUni instance for set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize PPTPEthUni-Set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1165,14 +1165,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send PPTPEthUni-Set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send PPTPEthUni-Set-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate PPTPEthUni", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 /* UniG obsolete by now, left here in case it should be needed once again
@@ -1224,7 +1224,7 @@
 */
 
 func (oo *omciCC) sendSetVeipLS(ctx context.Context, aInstNo uint16, timeout int,
-	highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
+	highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send VEIP-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16)})
@@ -1240,14 +1240,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode VEIP instance for set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize VEIP-Set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1258,18 +1258,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send VEIP-Set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send VEIP-Set-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate VEIP", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendGetMe(ctx context.Context, classID me.ClassID, entityID uint16, requestedAttributes me.AttributeValueMap,
-	timeout int, highPrio bool, rxChan chan Message) *me.ManagedEntity {
+	timeout int, highPrio bool, rxChan chan Message) (*me.ManagedEntity, error) {
 
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send get-request-msg", log.Fields{"classID": classID, "device-id": oo.deviceID,
@@ -1285,12 +1285,12 @@
 		omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.GetRequestType, omci.TransactionID(tid))
 		if err != nil {
 			logger.Errorf(ctx, "Cannot encode instance for get-request", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize get-request", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
@@ -1299,17 +1299,17 @@
 		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send get-request-msg", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debugw(ctx, "send get-request-msg done", log.Fields{"meClassIDName": meClassIDName, "device-id": oo.deviceID})
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate meDefinition", log.Fields{"classID": classID, "Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateDot1PMapper(ctx context.Context, timeout int, highPrio bool,
-	aInstID uint16, rxChan chan Message) *me.ManagedEntity {
+	aInstID uint16, rxChan chan Message) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send .1pMapper-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(aInstID), 16)})
@@ -1337,14 +1337,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode .1pMapper for create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize .1pMapper create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1355,18 +1355,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send .1pMapper create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send .1pMapper-create-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate .1pMapper", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateMBPConfigDataVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send MBPCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1380,14 +1380,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode MBPCD for create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize MBPCD create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1398,18 +1398,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send MBPCD create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send MBPCD-Create-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate MBPCD Instance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateGemNCTPVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send GemNCTP-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1423,14 +1423,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode GemNCTP for create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize GemNCTP create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1441,18 +1441,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send GemNCTP create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send GemNCTP-Create-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate GemNCTP Instance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send GemIwTp-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1466,14 +1466,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode GemIwTp for create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize GemIwTp create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1484,18 +1484,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send GemIwTp create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send GemIwTp-Create-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate GemIwTp Instance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendSetTcontVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send TCont-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1507,14 +1507,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode TCont for set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize TCont set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1525,18 +1525,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send TCont set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send TCont-set msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate TCont Instance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendSetPrioQueueVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send PrioQueue-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1548,14 +1548,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode PrioQueue for set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize PrioQueue set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1566,18 +1566,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send PrioQueue set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send PrioQueue-set msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate PrioQueue Instance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendSetDot1PMapperVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send 1PMapper-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1589,14 +1589,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode 1PMapper for set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize 1PMapper set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1607,18 +1607,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send 1PMapper set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send 1PMapper-set msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate 1PMapper Instance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateVtfdVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send VTFD-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1635,14 +1635,14 @@
 			//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
 			//  return (dual format) error code that can be used at caller for immediate error treatment
 			//  (relevant to all used sendXX() methods and their error conditions)
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize VTFD create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1653,19 +1653,19 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send VTFD create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send VTFD-Create-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate VTFD Instance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 // nolint: unused
 func (oo *omciCC) sendSetVtfdVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send VTFD-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1681,14 +1681,14 @@
 			//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
 			//  return (dual format) error code that can be used at caller for immediate error treatment
 			//  (relevant to all used sendXX() methods and their error conditions)
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize VTFD set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1699,18 +1699,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send VTFD set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send VTFD-Set-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate VTFD Instance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateEvtocdVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send EVTOCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1722,14 +1722,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode EVTOCD for create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize EVTOCD create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1740,18 +1740,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send EVTOCD create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send EVTOCD-set msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendSetEvtocdVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send EVTOCD-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1763,14 +1763,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode EVTOCD for set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize EVTOCD set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1781,18 +1781,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send EVTOCD set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send EVTOCD-set msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendDeleteEvtocd(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send EVTOCD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1804,14 +1804,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode EVTOCD for delete", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize EVTOCD delete", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1822,18 +1822,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send EVTOCD delete", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send EVTOCD-delete msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate EVTOCD Instance", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendDeleteVtfd(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, aInstID uint16) *me.ManagedEntity {
+	rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send VTFD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1850,14 +1850,14 @@
 			//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
 			//  return (dual format) error code that can be used at caller for immediate error treatment
 			//  (relevant to all used sendXX() methods and their error conditions)
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize VTFD delete", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -1868,19 +1868,19 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send VTFD delete", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send VTFD-Delete-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate VTFD Instance for delete", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 // nolint: unused
 func (oo *omciCC) sendCreateTDVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send TD-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1890,12 +1890,12 @@
 		omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.CreateRequestType, omci.TransactionID(tid))
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode TD for create", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize TD create", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
@@ -1904,18 +1904,18 @@
 		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send TD create", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send TD-Create-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate TD Instance", log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 // nolint: unused
 func (oo *omciCC) sendSetTDVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send TD-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1926,12 +1926,12 @@
 		omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.SetRequestType, omci.TransactionID(tid))
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode TD for set", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize TD set", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
@@ -1940,19 +1940,19 @@
 		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send TD set", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send TD-Set-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate TD Instance", log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 
 }
 
 // nolint: unused
 func (oo *omciCC) sendDeleteTD(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, aInstID uint16) *me.ManagedEntity {
+	rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send TD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -1964,12 +1964,12 @@
 		omciLayer, msgLayer, err := omci.EncodeFrame(meInstance, omci.DeleteRequestType, omci.TransactionID(tid))
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode TD for delete", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize TD delete", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
@@ -1978,18 +1978,18 @@
 		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send TD delete", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send TD-Delete-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate TD Instance", log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 
 }
 
 func (oo *omciCC) sendDeleteGemIWTP(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, aInstID uint16) *me.ManagedEntity {
+	rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send GemIwTp-Delete-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2006,14 +2006,14 @@
 			//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
 			//  return (dual format) error code that can be used at caller for immediate error treatment
 			//  (relevant to all used sendXX() methods and their error conditions)
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize GemIwTp delete", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -2024,18 +2024,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send GemIwTp delete", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send GemIwTp-Delete-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate GemIwTp Instance for delete", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendDeleteGemNCTP(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, aInstID uint16) *me.ManagedEntity {
+	rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send GemNCtp-Delete-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2052,14 +2052,14 @@
 			//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
 			//  return (dual format) error code that can be used at caller for immediate error treatment
 			//  (relevant to all used sendXX() methods and their error conditions)
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize GemNCtp delete", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -2070,18 +2070,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send GemNCtp delete", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send GemNCtp-Delete-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate GemNCtp Instance for delete", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendDeleteDot1PMapper(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, aInstID uint16) *me.ManagedEntity {
+	rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send .1pMapper-Delete-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2098,14 +2098,14 @@
 			//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
 			//  return (dual format) error code that can be used at caller for immediate error treatment
 			//  (relevant to all used sendXX() methods and their error conditions)
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize .1pMapper delete", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -2116,18 +2116,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send .1pMapper delete", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send .1pMapper-Delete-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate .1pMapper Instance for delete", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendDeleteMBPConfigData(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, aInstID uint16) *me.ManagedEntity {
+	rxChan chan Message, aInstID uint16) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send MBPCD-Delete-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2144,14 +2144,14 @@
 			//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
 			//  return (dual format) error code that can be used at caller for immediate error treatment
 			//  (relevant to all used sendXX() methods and their error conditions)
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize MBPCD delete", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{
@@ -2162,18 +2162,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send MBPCD delete", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send MBPCD-Delete-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate MBPCD Instance for delete", log.Fields{
 		"Err": omciErr.GetError(), "device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateMulticastGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send MulticastGemIWTP-create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2185,13 +2185,13 @@
 			omci.AddDefaults(true))
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode MulticastGEMIWTP for create", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2200,18 +2200,18 @@
 		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send MulticastGEMIWTP-create-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate MulticastGEMIWTP Instance", log.Fields{"Err": omciErr.GetError(),
 		"device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendSetMulticastGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send MulticastGemIWTP-set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2223,13 +2223,13 @@
 			omci.AddDefaults(true))
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode MulticastGEMIWTP for set", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize MulticastGEMIWTP create", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2238,18 +2238,18 @@
 		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send MulticastGEMIWTP set", log.Fields{"Err": err, "device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send MulticastGEMIWTP-set-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate MulticastGEMIWTP Instance", log.Fields{"Err": omciErr.GetError(),
 		"device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateMulticastOperationProfileVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send MulticastOperationProfile-create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2262,14 +2262,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode MulticastOperationProfile for create", log.Fields{"Err": err,
 				"device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize MulticastOperationProfile create", log.Fields{"Err": err,
 				"device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2279,18 +2279,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send MulticastOperationProfile create", log.Fields{"Err": err,
 				"device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send MulticastOperationProfile-create-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate MulticastOperationProfile Instance", log.Fields{"Err": omciErr.GetError(),
 		"device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendSetMulticastOperationProfileVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send MulticastOperationProfile-create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2303,14 +2303,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode MulticastOperationProfile for create", log.Fields{"Err": err,
 				"device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize MulticastOperationProfile create", log.Fields{"Err": err,
 				"device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2320,18 +2320,18 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send MulticastOperationProfile create", log.Fields{"Err": err,
 				"device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send MulticastOperationProfile-create-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate MulticastOperationProfile Instance", log.Fields{"Err": omciErr.GetError(),
 		"device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateMulticastSubConfigInfoVar(ctx context.Context, timeout int, highPrio bool,
-	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
+	rxChan chan Message, params ...me.ParamData) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send MulticastSubConfigInfo-create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
@@ -2344,14 +2344,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode MulticastSubConfigInfo for create", log.Fields{"Err": err,
 				"device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize MulticastSubConfigInfo create", log.Fields{"Err": err,
 				"device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2361,14 +2361,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send MulticastSubConfigInfo create", log.Fields{"Err": err,
 				"device-id": oo.deviceID})
-			return nil
+			return nil, err
 		}
 		logger.Debug(ctx, "send MulticastSubConfigInfo-create-msg done")
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate MulticastSubConfigInfo Instance", log.Fields{"Err": omciErr.GetError(),
 		"device-id": oo.deviceID})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendSyncTime(ctx context.Context, timeout int, highPrio bool, rxChan chan Message) error {
@@ -2417,7 +2417,7 @@
 }
 
 func (oo *omciCC) sendCreateOrDeleteEthernetPerformanceMonitoringHistoryME(ctx context.Context, timeout int, highPrio bool,
-	upstream bool, create bool, rxChan chan Message, entityID uint16) *me.ManagedEntity {
+	upstream bool, create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send ethernet-performance-monitoring-history-me-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create, "upstream": upstream})
@@ -2443,14 +2443,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode ethernet frame performance monitoring history data ME",
 				log.Fields{"Err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize ethernet frame performance monitoring history data ME",
 				log.Fields{"Err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2460,19 +2460,19 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send ethernet frame performance monitoring history data ME",
 				log.Fields{"Err": err, "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-			return nil
+			return nil, err
 		}
 		logger.Debugw(ctx, "send ethernet frame performance monitoring history data ME done",
 			log.Fields{"device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate ethernet frame performance monitoring history data ME Instance",
 		log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "upstream": upstream, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateOrDeleteEthernetUniHistoryME(ctx context.Context, timeout int, highPrio bool,
-	create bool, rxChan chan Message, entityID uint16) *me.ManagedEntity {
+	create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send ethernet-uni-history-me-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create})
@@ -2495,14 +2495,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode ethernet uni history data ME",
 				log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize ethernet uni history data ME",
 				log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2512,19 +2512,19 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send ethernet uni history data ME",
 				log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-			return nil
+			return nil, err
 		}
 		logger.Debugw(ctx, "send ethernet uni history data ME done",
 			log.Fields{"device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate ethernet uni history data ME Instance",
 		log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateOrDeleteFecHistoryME(ctx context.Context, timeout int, highPrio bool,
-	create bool, rxChan chan Message, entityID uint16) *me.ManagedEntity {
+	create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send fec-history-me-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create})
@@ -2547,14 +2547,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode fec history data ME",
 				log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize fec history data ME",
 				log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2564,19 +2564,19 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send fec history data ME",
 				log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-			return nil
+			return nil, err
 		}
 		logger.Debugw(ctx, "send fec history data ME done",
 			log.Fields{"device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate fec history data ME Instance",
 		log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendCreateOrDeleteGemPortHistoryME(ctx context.Context, timeout int, highPrio bool,
-	create bool, rxChan chan Message, entityID uint16) *me.ManagedEntity {
+	create bool, rxChan chan Message, entityID uint16) (*me.ManagedEntity, error) {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send gemport-history-me-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(entityID), 16), "create": create})
@@ -2599,14 +2599,14 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot encode gemport history data ME",
 				log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-			return nil
+			return nil, err
 		}
 
 		pkt, err := serializeOmciLayer(ctx, omciLayer, msgLayer)
 		if err != nil {
 			logger.Errorw(ctx, "Cannot serialize gemport history data ME",
 				log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-			return nil
+			return nil, err
 		}
 
 		omciRxCallbackPair := callbackPair{cbKey: tid,
@@ -2616,15 +2616,15 @@
 		if err != nil {
 			logger.Errorw(ctx, "Cannot send gemport history data ME",
 				log.Fields{"Err": err, "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-			return nil
+			return nil, err
 		}
 		logger.Debugw(ctx, "send gemport history data ME done",
 			log.Fields{"device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-		return meInstance
+		return meInstance, nil
 	}
 	logger.Errorw(ctx, "Cannot generate gemport history data ME Instance",
 		log.Fields{"Err": omciErr.GetError(), "device-id": oo.deviceID, "create": create, "InstId": strconv.FormatInt(int64(entityID), 16)})
-	return nil
+	return nil, omciErr.GetError()
 }
 
 func (oo *omciCC) sendStartSoftwareDownload(ctx context.Context, timeout int, highPrio bool,
diff --git a/internal/pkg/onuadaptercore/omci_onu_upgrade.go b/internal/pkg/onuadaptercore/omci_onu_upgrade.go
index 0158977..58e78a4 100644
--- a/internal/pkg/onuadaptercore/omci_onu_upgrade.go
+++ b/internal/pkg/onuadaptercore/omci_onu_upgrade.go
@@ -536,10 +536,21 @@
 	logger.Infow(ctx, "OnuUpgradeFsm checking committed SW", log.Fields{
 		"device-id": oFsm.deviceID, "me-id": oFsm.inactiveImageMeID})
 	requestedAttributes := me.AttributeValueMap{"IsCommitted": 0, "IsActive": 0, "Version": ""}
-	meInstance := oFsm.pOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx),
+	meInstance, err := oFsm.pOmciCC.sendGetMe(log.WithSpanFromContext(context.TODO(), ctx),
 		me.SoftwareImageClassID, oFsm.inactiveImageMeID, requestedAttributes, oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, false, oFsm.pAdaptFsm.commChan)
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
+	if err != nil {
+		logger.Errorw(ctx, "OnuUpgradeFsm get Software Image ME result error",
+			log.Fields{"device-id": oFsm.deviceID, "Error": err})
+		pOnuUpgradeFsm := oFsm.pAdaptFsm
+		if pOnuUpgradeFsm != nil {
+			go func(a_pAFsm *AdapterFsm) {
+				_ = a_pAFsm.pFsm.Event(upgradeEvReset)
+			}(pOnuUpgradeFsm)
+		}
+		return
+	}
 	oFsm.pLastTxMeInstance = meInstance
 }
 
diff --git a/internal/pkg/onuadaptercore/omci_vlan_config.go b/internal/pkg/onuadaptercore/omci_vlan_config.go
index cb010c9..1fc9a5c 100644
--- a/internal/pkg/onuadaptercore/omci_vlan_config.go
+++ b/internal/pkg/onuadaptercore/omci_vlan_config.go
@@ -965,8 +965,19 @@
 		}
 		logger.Debugw(ctx, "UniVlanConfigFsm sendcreate VTFD", log.Fields{
 			"in state": e.FSM.Current(), "device-id": oFsm.deviceID})
-		meInstance := oFsm.pOmciCC.sendCreateVtfdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+		meInstance, err := oFsm.pOmciCC.sendCreateVtfdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 			oFsm.pAdaptFsm.commChan, meParams)
+		if err != nil {
+			logger.Errorw(ctx, "VTFD create failed, aborting UniVlanConfig FSM!",
+				log.Fields{"device-id": oFsm.deviceID})
+			pConfigVlanStateAFsm := oFsm.pAdaptFsm
+			if pConfigVlanStateAFsm != nil {
+				go func(a_pAFsm *AdapterFsm) {
+					_ = a_pAFsm.pFsm.Event(vlanEvReset)
+				}(pConfigVlanStateAFsm)
+			}
+			return
+		}
 		//accept also nil as (error) return value for writing to LastTx
 		//  - this avoids misinterpretation of new received OMCI messages
 		//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
@@ -1134,8 +1145,19 @@
 					"NumberOfEntries":  oFsm.numVlanFilterEntries,
 				},
 			}
-			meInstance := oFsm.pOmciCC.sendCreateVtfdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+			meInstance, err := oFsm.pOmciCC.sendCreateVtfdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 				oFsm.pAdaptFsm.commChan, meParams)
+			if err != nil {
+				logger.Errorw(ctx, "VTFD create failed, aborting UniVlanConfig FSM!",
+					log.Fields{"device-id": oFsm.deviceID})
+				pConfigVlanStateAFsm := oFsm.pAdaptFsm
+				if pConfigVlanStateAFsm != nil {
+					go func(a_pAFsm *AdapterFsm) {
+						_ = a_pAFsm.pFsm.Event(vlanEvReset)
+					}(pConfigVlanStateAFsm)
+				}
+				return
+			}
 			//accept also nil as (error) return value for writing to LastTx
 			//  - this avoids misinterpretation of new received OMCI messages
 			//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
@@ -1170,8 +1192,14 @@
 					"NumberOfEntries":  oFsm.numVlanFilterEntries,
 				},
 			}
-			meInstance := oFsm.pOmciCC.sendCreateVtfdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+			meInstance, err := oFsm.pOmciCC.sendCreateVtfdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 				oFsm.pAdaptFsm.commChan, meParams)
+			if err != nil {
+				logger.Errorw(ctx, "UniVlanFsm create Vlan Tagging Filter ME result error",
+					log.Fields{"device-id": oFsm.deviceID, "Error": err})
+				_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+				return
+			}
 			//accept also nil as (error) return value for writing to LastTx
 			//  - this avoids misinterpretation of new received OMCI messages
 			//TODO!!: refactoring improvement requested, here as an example for [VOL-3457]:
@@ -1257,8 +1285,14 @@
 					"in state": e.FSM.Current(), "device-id": oFsm.deviceID})
 			loVlanEntryClear = 1           //full VlanFilter clear request
 			if loAllowSpecificOmciConfig { //specific OMCI config is expected to work acc. to the device state
-				meInstance := oFsm.pOmciCC.sendDeleteVtfd(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+				meInstance, err := oFsm.pOmciCC.sendDeleteVtfd(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 					oFsm.pAdaptFsm.commChan, vtfdID)
+				if err != nil {
+					logger.Errorw(ctx, "UniVlanFsm delete Vlan Tagging Filter ME result error",
+						log.Fields{"device-id": oFsm.deviceID, "Error": err})
+					_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+					return
+				}
 				oFsm.pLastTxMeInstance = meInstance
 			} else {
 				logger.Debugw(ctx, "UniVlanConfigFsm delete VTFD OMCI handling skipped based on device state", log.Fields{
@@ -1295,8 +1329,14 @@
 
 				if loAllowSpecificOmciConfig { //specific OMCI config is expected to work acc. to the device state
 					// FIXME: VOL-3685: Issues with resetting a table entry in EVTOCD ME
-					meInstance := oFsm.pOmciCC.sendDeleteVtfd(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+					meInstance, err := oFsm.pOmciCC.sendDeleteVtfd(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 						oFsm.pAdaptFsm.commChan, vtfdID)
+					if err != nil {
+						logger.Errorw(ctx, "UniVlanFsm delete Vlan Tagging Filter ME result error",
+							log.Fields{"device-id": oFsm.deviceID, "Error": err})
+						_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+						return
+					}
 					oFsm.pLastTxMeInstance = meInstance
 				} else {
 					logger.Debugw(ctx, "UniVlanConfigFsm set VTFD OMCI handling skipped based on device state", log.Fields{
@@ -1660,14 +1700,20 @@
 				"AssociatedMePointer": oFsm.pOnuUniPort.entityID,
 			},
 		}
-		meInstance := oFsm.pOmciCC.sendCreateEvtocdVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
-			oFsm.pAdaptFsm.commChan, meParams)
+		meInstance, err := oFsm.pOmciCC.sendCreateEvtocdVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
+			true, oFsm.pAdaptFsm.commChan, meParams)
+		if err != nil {
+			logger.Errorw(ctx, "CreateEvtocdVar create failed, aborting UniVlanConfigFsm!",
+				log.Fields{"device-id": oFsm.deviceID})
+			_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+			return fmt.Errorf("evtocd instance create failed %s, error %s", oFsm.deviceID, err)
+		}
 		//accept also nil as (error) return value for writing to LastTx
 		//  - this avoids misinterpretation of new received OMCI messages
 		oFsm.pLastTxMeInstance = meInstance
 
 		//verify response
-		err := oFsm.waitforOmciResponse(ctx)
+		err = oFsm.waitforOmciResponse(ctx)
 		if err != nil {
 			logger.Errorw(ctx, "Evtocd create failed, aborting VlanConfig FSM!",
 				log.Fields{"device-id": oFsm.deviceID})
@@ -1684,8 +1730,15 @@
 				"DownstreamMode": uint8(cDefaultDownstreamMode),
 			},
 		}
-		meInstance = oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+		meInstance, err = oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+			oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 			oFsm.pAdaptFsm.commChan, meParams)
+		if err != nil {
+			logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+				log.Fields{"device-id": oFsm.deviceID})
+			_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+			return fmt.Errorf("evtocd instance set failed %s, error %s", oFsm.deviceID, err)
+		}
 		//accept also nil as (error) return value for writing to LastTx
 		//  - this avoids misinterpretation of new received OMCI messages
 		oFsm.pLastTxMeInstance = meInstance
@@ -1736,14 +1789,21 @@
 				"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
 			},
 		}
-		meInstance := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+		meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+			oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 			oFsm.pAdaptFsm.commChan, meParams)
+		if err != nil {
+			logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+				log.Fields{"device-id": oFsm.deviceID})
+			_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+			return fmt.Errorf("evtocd instance set failed %s, error %s", oFsm.deviceID, err)
+		}
 		//accept also nil as (error) return value for writing to LastTx
 		//  - this avoids misinterpretation of new received OMCI messages
 		oFsm.pLastTxMeInstance = meInstance
 
 		//verify response
-		err := oFsm.waitforOmciResponse(ctx)
+		err = oFsm.waitforOmciResponse(ctx)
 		if err != nil {
 			logger.Errorw(ctx, "Evtocd set transparent singletagged rule failed, aborting VlanConfig FSM!",
 				log.Fields{"device-id": oFsm.deviceID})
@@ -1792,14 +1852,21 @@
 					"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
 				},
 			}
-			meInstance := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+			meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+				oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 				oFsm.pAdaptFsm.commChan, meParams)
+			if err != nil {
+				logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+					log.Fields{"device-id": oFsm.deviceID})
+				_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+				return fmt.Errorf("evtocd instance set failed %s, error %s", oFsm.deviceID, err)
+			}
 			//accept also nil as (error) return value for writing to LastTx
 			//  - this avoids misinterpretation of new received OMCI messages
 			oFsm.pLastTxMeInstance = meInstance
 
 			//verify response
-			err := oFsm.waitforOmciResponse(ctx)
+			err = oFsm.waitforOmciResponse(ctx)
 			if err != nil {
 				logger.Errorw(ctx, "Evtocd set singletagged translation rule failed, aborting VlanConfig FSM!",
 					log.Fields{"device-id": oFsm.deviceID})
@@ -1844,14 +1911,21 @@
 						"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
 					},
 				}
-				meInstance := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+				meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+					oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 					oFsm.pAdaptFsm.commChan, meParams)
+				if err != nil {
+					logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+						log.Fields{"device-id": oFsm.deviceID})
+					_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+					return fmt.Errorf("evtocd instance set failed %s, error %s", oFsm.deviceID, err)
+				}
 				//accept also nil as (error) return value for writing to LastTx
 				//  - this avoids misinterpretation of new received OMCI messages
 				oFsm.pLastTxMeInstance = meInstance
 
 				//verify response
-				err := oFsm.waitforOmciResponse(ctx)
+				err = oFsm.waitforOmciResponse(ctx)
 				if err != nil {
 					logger.Errorw(ctx, "Evtocd set untagged->singletagged rule failed, aborting VlanConfig FSM!",
 						log.Fields{"device-id": oFsm.deviceID})
@@ -1897,14 +1971,21 @@
 						"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
 					},
 				}
-				meInstance := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+				meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+					oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 					oFsm.pAdaptFsm.commChan, meParams)
+				if err != nil {
+					logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+						log.Fields{"device-id": oFsm.deviceID})
+					_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+					return fmt.Errorf("evtocd instance set failed %s, error %s", oFsm.deviceID, err)
+				}
 				//accept also nil as (error) return value for writing to LastTx
 				//  - this avoids misinterpretation of new received OMCI messages
 				oFsm.pLastTxMeInstance = meInstance
 
 				//verify response
-				err := oFsm.waitforOmciResponse(ctx)
+				err = oFsm.waitforOmciResponse(ctx)
 				if err != nil {
 					logger.Errorw(ctx, "Evtocd set priotagged->singletagged rule failed, aborting VlanConfig FSM!",
 						log.Fields{"device-id": oFsm.deviceID})
@@ -1960,14 +2041,21 @@
 				"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
 			},
 		}
-		meInstance := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+		meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+			oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 			oFsm.pAdaptFsm.commChan, meParams)
+		if err != nil {
+			logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+				log.Fields{"device-id": oFsm.deviceID})
+			_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+			return
+		}
 		//accept also nil as (error) return value for writing to LastTx
 		//  - this avoids misinterpretation of new received OMCI messages
 		oFsm.pLastTxMeInstance = meInstance
 
 		//verify response
-		err := oFsm.waitforOmciResponse(ctx)
+		err = oFsm.waitforOmciResponse(ctx)
 		if err != nil {
 			logger.Errorw(ctx, "Evtocd reset singletagged rule failed, aborting VlanConfig FSM!",
 				log.Fields{"device-id": oFsm.deviceID})
@@ -2003,14 +2091,21 @@
 					"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
 				},
 			}
-			meInstance := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+			meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+				oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 				oFsm.pAdaptFsm.commChan, meParams)
+			if err != nil {
+				logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+					log.Fields{"device-id": oFsm.deviceID})
+				_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+				return
+			}
 			//accept also nil as (error) return value for writing to LastTx
 			//  - this avoids misinterpretation of new received OMCI messages
 			oFsm.pLastTxMeInstance = meInstance
 
 			//verify response
-			err := oFsm.waitforOmciResponse(ctx)
+			err = oFsm.waitforOmciResponse(ctx)
 			if err != nil {
 				logger.Errorw(ctx, "Evtocd clear singletagged translation rule failed, aborting VlanConfig FSM!",
 					log.Fields{"device-id": oFsm.deviceID, "match-vlan": aRuleParams.MatchVid})
@@ -2035,14 +2130,21 @@
 				meParams := me.ParamData{
 					EntityID: oFsm.evtocdID,
 				}
-				meInstance := oFsm.pOmciCC.sendDeleteEvtocd(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+				meInstance, err := oFsm.pOmciCC.sendDeleteEvtocd(log.WithSpanFromContext(context.TODO(), ctx),
+					oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 					oFsm.pAdaptFsm.commChan, meParams)
+				if err != nil {
+					logger.Errorw(ctx, "DeleteEvtocdVar delete failed, aborting UniVlanConfigFsm!",
+						log.Fields{"device-id": oFsm.deviceID})
+					_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+					return
+				}
 				//accept also nil as (error) return value for writing to LastTx
 				//  - this avoids misinterpretation of new received OMCI messages
 				oFsm.pLastTxMeInstance = meInstance
 
 				//verify response
-				err := oFsm.waitforOmciResponse(ctx)
+				err = oFsm.waitforOmciResponse(ctx)
 				if err != nil {
 					logger.Errorw(ctx, "Evtocd delete rule failed, aborting VlanConfig FSM!",
 						log.Fields{"device-id": oFsm.deviceID})
@@ -2093,14 +2195,21 @@
 							"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
 						},
 					}
-					meInstance := oFsm.pOmciCC.sendSetEvtocdVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+					meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(context.TODO(),
+						oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 						oFsm.pAdaptFsm.commChan, meParams)
+					if err != nil {
+						logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+							log.Fields{"device-id": oFsm.deviceID})
+						_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+						return
+					}
 					//accept also nil as (error) return value for writing to LastTx
 					//  - this avoids misinterpretation of new received OMCI messages
 					oFsm.pLastTxMeInstance = meInstance
 
 					//verify response
-					err := oFsm.waitforOmciResponse(ctx)
+					err = oFsm.waitforOmciResponse(ctx)
 					if err != nil {
 						logger.Errorw(ctx, "Evtocd reset untagged rule to default failed, aborting VlanConfig FSM!",
 							log.Fields{"device-id": oFsm.deviceID})
@@ -2135,14 +2244,21 @@
 							"ReceivedFrameVlanTaggingOperationTable": sliceEvtocdRule,
 						},
 					}
-					meInstance := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+					meInstance, err := oFsm.pOmciCC.sendSetEvtocdVar(log.WithSpanFromContext(context.TODO(), ctx),
+						oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 						oFsm.pAdaptFsm.commChan, meParams)
+					if err != nil {
+						logger.Errorw(ctx, "SetEvtocdVar set failed, aborting UniVlanConfigFsm!",
+							log.Fields{"device-id": oFsm.deviceID})
+						_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+						return
+					}
 					//accept also nil as (error) return value for writing to LastTx
 					//  - this avoids misinterpretation of new received OMCI messages
 					oFsm.pLastTxMeInstance = meInstance
 
 					//verify response
-					err := oFsm.waitforOmciResponse(ctx)
+					err = oFsm.waitforOmciResponse(ctx)
 					if err != nil {
 						logger.Errorw(ctx, "Evtocd delete priotagged rule failed, aborting VlanConfig FSM!",
 							log.Fields{"device-id": oFsm.deviceID})
@@ -2232,12 +2348,18 @@
 			"TpPointer":       multicastGemPortID,
 		},
 	}
-	meInstance := oFsm.pOmciCC.sendCreateMBPConfigDataVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
-		oFsm.pAdaptFsm.commChan, meParams)
+	meInstance, err := oFsm.pOmciCC.sendCreateMBPConfigDataVar(context.TODO(),
+		oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, oFsm.pAdaptFsm.commChan, meParams)
+	if err != nil {
+		logger.Errorw(ctx, "MBPConfigDataVar create failed, aborting AniConfig FSM!",
+			log.Fields{"device-id": oFsm.deviceID})
+		_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+		return fmt.Errorf("creatingMulticastSubscriberConfigInfo createError #{oFsm.deviceID}, error #{err}")
+	}
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
 	oFsm.pLastTxMeInstance = meInstance
-	err := oFsm.waitforOmciResponse(ctx)
+	err = oFsm.waitforOmciResponse(ctx)
 	if err != nil {
 		logger.Errorw(ctx, "CreateMBPConfigData failed, aborting AniConfig FSM!",
 			log.Fields{"device-id": oFsm.deviceID, "MBPConfigDataID": macBridgeServiceProfileEID})
@@ -2269,8 +2391,14 @@
 			"NumberOfEntries":  oFsm.numVlanFilterEntries,
 		},
 	}
-	meInstance = oFsm.pOmciCC.sendCreateVtfdVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
-		oFsm.pAdaptFsm.commChan, meParams)
+	meInstance, err = oFsm.pOmciCC.sendCreateVtfdVar(context.TODO(),
+		oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, oFsm.pAdaptFsm.commChan, meParams)
+	if err != nil {
+		logger.Errorw(ctx, "CreateVtfdVar create failed, aborting UniVlanConfigFsm!",
+			log.Fields{"device-id": oFsm.deviceID})
+		_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+		return fmt.Errorf("createMcastVlanFilterData creationError %s, error %s", oFsm.deviceID, err)
+	}
 	oFsm.pLastTxMeInstance = meInstance
 	err = oFsm.waitforOmciResponse(ctx)
 	if err != nil {
@@ -2300,8 +2428,16 @@
 			"MulticastOperationsProfilePointer": instID,
 		},
 	}
-	meInstance := oFsm.pOmciCC.sendCreateMulticastSubConfigInfoVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+	meInstance, err := oFsm.pOmciCC.sendCreateMulticastSubConfigInfoVar(context.TODO(),
+		oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 		oFsm.pAdaptFsm.commChan, meParams)
+	if err != nil {
+		logger.Errorw(ctx, "CreateMulticastSubConfigInfoVar create failed, aborting UniVlanConfigFSM!",
+			log.Fields{"device-id": oFsm.deviceID})
+		_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+		return fmt.Errorf("creatingMulticastSubscriberConfigInfo interface creationError %s, error %s",
+			oFsm.deviceID, err)
+	}
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
 	oFsm.pLastTxMeInstance = meInstance
@@ -2339,8 +2475,15 @@
 			"UnauthorizedJoinBehaviour": 0,
 		},
 	}
-	meInstance := oFsm.pOmciCC.sendCreateMulticastOperationProfileVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+	meInstance, err := oFsm.pOmciCC.sendCreateMulticastOperationProfileVar(context.TODO(),
+		oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 		oFsm.pAdaptFsm.commChan, meParams)
+	if err != nil {
+		logger.Errorw(ctx, "CreateMulticastOperationProfileVar create failed, aborting UniVlanConfigFsm!",
+			log.Fields{"device-id": oFsm.deviceID})
+		_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+		return fmt.Errorf("createMulticastOperationProfileVar responseError %s, error %s", oFsm.deviceID, err)
+	}
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
 	oFsm.pLastTxMeInstance = meInstance
@@ -2349,7 +2492,7 @@
 	if err != nil {
 		logger.Errorw(ctx, "CreateMulticastOperationProfile create failed, aborting AniConfig FSM!",
 			log.Fields{"device-id": oFsm.deviceID, "MulticastOperationProfileID": instID})
-		return fmt.Errorf("createMulticastOperationProfile responseError %s", oFsm.deviceID)
+		return fmt.Errorf("createMulticastOperationProfile responseError %s, error %s", oFsm.deviceID, err)
 	}
 	return nil
 }
@@ -2393,8 +2536,15 @@
 			"DynamicAccessControlListTable": dynamicAccessCL,
 		},
 	}
-	meInstance := oFsm.pOmciCC.sendSetMulticastOperationProfileVar(context.TODO(), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+	meInstance, err := oFsm.pOmciCC.sendSetMulticastOperationProfileVar(context.TODO(),
+		oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 		oFsm.pAdaptFsm.commChan, meParams)
+	if err != nil {
+		logger.Errorw(ctx, "SetMulticastOperationProfileVar set failed, aborting UniVlanConfigFsm!",
+			log.Fields{"device-id": oFsm.deviceID})
+		_ = oFsm.pAdaptFsm.pFsm.Event(vlanEvReset)
+		return fmt.Errorf("setMulticastOperationProfile responseError %s, error %s", oFsm.deviceID, err)
+	}
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
 	oFsm.pLastTxMeInstance = meInstance
@@ -2403,7 +2553,7 @@
 	if err != nil {
 		logger.Errorw(ctx, "CreateMulticastOperationProfile create failed, aborting AniConfig FSM!",
 			log.Fields{"device-id": oFsm.deviceID, "MulticastOperationProfileID": instID})
-		return fmt.Errorf("createMulticastOperationProfile responseError %s", oFsm.deviceID)
+		return fmt.Errorf("createMulticastOperationProfile responseError %s, error %s", oFsm.deviceID, err)
 	}
 	return nil
 }
diff --git a/internal/pkg/onuadaptercore/onu_metrics_manager.go b/internal/pkg/onuadaptercore/onu_metrics_manager.go
index 80882f6..59118ce 100644
--- a/internal/pkg/onuadaptercore/onu_metrics_manager.go
+++ b/internal/pkg/onuadaptercore/onu_metrics_manager.go
@@ -579,7 +579,12 @@
 func (mm *onuMetricsManager) collectAllGroupMetrics(ctx context.Context) {
 	go func() {
 		logger.Debug(ctx, "startCollector before collecting optical metrics")
-		metricInfo := mm.collectOpticalMetrics(ctx)
+		metricInfo, err := mm.collectOpticalMetrics(ctx)
+		if err != nil {
+			logger.Errorw(ctx, "collectOpticalMetrics failed",
+				log.Fields{"device-id": mm.pAdaptFsm.deviceID, "Error": err})
+			return
+		}
 		if metricInfo != nil {
 			mm.publishMetrics(ctx, metricInfo)
 		}
@@ -587,7 +592,12 @@
 
 	go func() {
 		logger.Debug(ctx, "startCollector before collecting uni metrics")
-		metricInfo := mm.collectUniStatusMetrics(ctx)
+		metricInfo, err := mm.collectUniStatusMetrics(ctx)
+		if err != nil {
+			logger.Errorw(ctx, "collectOpticalMetrics failed",
+				log.Fields{"device-id": mm.pAdaptFsm.deviceID, "Error": err})
+			return
+		}
 		if metricInfo != nil {
 			mm.publishMetrics(ctx, metricInfo)
 		}
@@ -604,13 +614,13 @@
 	switch groupName {
 	case OpticalPowerGroupMetricName:
 		go func() {
-			if mi := mm.collectOpticalMetrics(ctx); mm != nil {
+			if mi, _ := mm.collectOpticalMetrics(ctx); mi != nil {
 				mm.publishMetrics(ctx, mi)
 			}
 		}()
 	case UniStatusGroupMetricName:
 		go func() {
-			if mi := mm.collectUniStatusMetrics(ctx); mm != nil {
+			if mi, _ := mm.collectUniStatusMetrics(ctx); mi != nil {
 				mm.publishMetrics(ctx, mi)
 			}
 		}()
@@ -628,14 +638,14 @@
 }
 
 // collectOpticalMetrics collects groups metrics related to optical power from ani-g ME.
-func (mm *onuMetricsManager) collectOpticalMetrics(ctx context.Context) []*voltha.MetricInformation {
+func (mm *onuMetricsManager) collectOpticalMetrics(ctx context.Context) ([]*voltha.MetricInformation, error) {
 	logger.Debugw(ctx, "collectOpticalMetrics", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
 
 	mm.onuMetricsManagerLock.RLock()
 	if !mm.groupMetricMap[OpticalPowerGroupMetricName].enabled {
 		mm.onuMetricsManagerLock.RUnlock()
 		logger.Debugw(ctx, "optical power group metric is not enabled", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
-		return nil
+		return nil, nil
 	}
 	mm.onuMetricsManagerLock.RUnlock()
 
@@ -663,7 +673,14 @@
 		opticalMetrics := make(map[string]float32)
 		// Get the ANI-G instance optical power attributes
 		requestedAttributes := me.AttributeValueMap{"OpticalSignalLevel": 0, "TransmitOpticalLevel": 0}
-		if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.AniGClassID, anigInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+		meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.AniGClassID, anigInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+		if err != nil {
+			logger.Errorw(ctx, "GetMe failed, failure PM FSM!", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+			_ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+			return nil, err
+		}
+
+		if meInstance != nil {
 			select {
 			case meAttributes = <-mm.opticalMetricsChan:
 				logger.Debugw(ctx, "received optical metrics", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
@@ -698,18 +715,18 @@
 		metricInfoSlice = append(metricInfoSlice, &metricInfo)
 	}
 
-	return metricInfoSlice
+	return metricInfoSlice, nil
 }
 
 // collectUniStatusMetrics collects UNI status group metric from various MEs (uni-g, pptp and veip).
 // nolint: gocyclo
-func (mm *onuMetricsManager) collectUniStatusMetrics(ctx context.Context) []*voltha.MetricInformation {
+func (mm *onuMetricsManager) collectUniStatusMetrics(ctx context.Context) ([]*voltha.MetricInformation, error) {
 	logger.Debugw(ctx, "collectUniStatusMetrics", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
 	mm.onuMetricsManagerLock.RLock()
 	if !mm.groupMetricMap[UniStatusGroupMetricName].enabled {
 		mm.onuMetricsManagerLock.RUnlock()
 		logger.Debugw(ctx, "uni status group metric is not enabled", log.Fields{"device-id": mm.pDeviceHandler.deviceID})
-		return nil
+		return nil, nil
 	}
 	mm.onuMetricsManagerLock.RUnlock()
 
@@ -739,7 +756,13 @@
 		var meAttributes me.AttributeValueMap
 		// Get the UNI-G instance optical power attributes
 		requestedAttributes := me.AttributeValueMap{"AdministrativeState": 0}
-		if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.UniGClassID, unigInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+		meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.UniGClassID, unigInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+		if err != nil {
+			logger.Errorw(ctx, "UNI-G failed, failure PM FSM!", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+			_ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+			return nil, err
+		}
+		if meInstance != nil {
 			// Wait for metrics or timeout
 			select {
 			case meAttributes = <-mm.uniStatusMetricsChan:
@@ -789,7 +812,13 @@
 		pptpMetrics := make(map[string]float32)
 
 		requestedAttributes := me.AttributeValueMap{"SensedType": 0, "OperationalState": 0, "AdministrativeState": 0}
-		if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.PhysicalPathTerminationPointEthernetUniClassID, pptpInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+		meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.PhysicalPathTerminationPointEthernetUniClassID, pptpInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+		if err != nil {
+			logger.Errorw(ctx, "GetMe failed, failure PM FSM!", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+			_ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+			return nil, err
+		}
+		if meInstance != nil {
 			// Wait for metrics or timeout
 			select {
 			case meAttributes = <-mm.uniStatusMetricsChan:
@@ -848,7 +877,13 @@
 		veipMetrics := make(map[string]float32)
 
 		requestedAttributes := me.AttributeValueMap{"OperationalState": 0, "AdministrativeState": 0}
-		if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.VirtualEthernetInterfacePointClassID, veipInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+		meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, me.VirtualEthernetInterfacePointClassID, veipInstID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+		if err != nil {
+			logger.Errorw(ctx, "GetMe failed, failure PM FSM!", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+			_ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+			return nil, err
+		}
+		if meInstance != nil {
 			// Wait for metrics or timeout
 			select {
 			case meAttributes = <-mm.uniStatusMetricsChan:
@@ -894,7 +929,7 @@
 		metricInfoSlice = append(metricInfoSlice, &metricInfo)
 	}
 
-	return metricInfoSlice
+	return metricInfoSlice, nil
 }
 
 // publishMetrics publishes the metrics on kafka
@@ -1260,7 +1295,7 @@
 }
 
 // nolint: gocyclo
-func (mm *onuMetricsManager) l2PmFsmCreatePM(ctx context.Context, e *fsm.Event) {
+func (mm *onuMetricsManager) l2PmFsmCreatePM(ctx context.Context, e *fsm.Event) error {
 	// Copy the l2PmToAdd for which we want to collect the metrics since l2PmToAdd can change dynamically
 	mm.onuMetricsManagerLock.RLock()
 	copyOfL2PmToAdd := make([]string, len(mm.l2PmToAdd))
@@ -1285,8 +1320,20 @@
 				inner1:
 					// retry L2PmCreateAttempts times to create the instance of PM
 					for cnt = 0; cnt < L2PmCreateAttempts; cnt++ {
-						mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetPerformanceMonitoringHistoryME(
+						_, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetPerformanceMonitoringHistoryME(
 							ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, direction, true, mm.pAdaptFsm.commChan, entityID)
+						if err != nil {
+							logger.Errorw(ctx, "EthernetPerformanceMonitoringHistoryME create or delete failed, failure PM FSM!",
+								log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+							pPMFsm := mm.pAdaptFsm
+							if pPMFsm != nil {
+								go func(p_pmFsm *AdapterFsm) {
+									_ = p_pmFsm.pFsm.Event(l2PmEventFailure)
+								}(pPMFsm)
+							}
+							return fmt.Errorf(fmt.Sprintf("CreateOrDeleteEthernetPerformanceMonitoringHistoryMe-failed-%s-%s",
+								mm.pDeviceHandler.deviceID, err))
+						}
 						if resp = mm.waitForResponseOrTimeout(ctx, true, entityID, "EthernetFramePerformanceMonitoringHistoryData"); resp {
 							atLeastOneSuccess = true
 							_ = mm.updatePmData(ctx, n, entityID, cPmAdded) // TODO: ignore error for now
@@ -1307,8 +1354,15 @@
 				inner2:
 					// retry L2PmCreateAttempts times to create the instance of PM
 					for cnt = 0; cnt < L2PmCreateAttempts; cnt++ {
-						mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetUniHistoryME(
+						_, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetUniHistoryME(
 							ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, true, mm.pAdaptFsm.commChan, entityID)
+						if err != nil {
+							logger.Errorw(ctx, "CreateOrDeleteEthernetUNIHistoryME failed, failure PM FSM!",
+								log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+							_ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+							return fmt.Errorf(fmt.Sprintf("CreateOrDeleteEthernetUniHistoryMe-failed-%s-%s",
+								mm.pDeviceHandler.deviceID, err))
+						}
 						if resp = mm.waitForResponseOrTimeout(ctx, true, entityID, "EthernetPerformanceMonitoringHistoryData"); resp {
 							atLeastOneSuccess = true
 							_ = mm.updatePmData(ctx, n, entityID, cPmAdded) // TODO: ignore error for now
@@ -1323,8 +1377,15 @@
 		case FecHistoryName:
 			for _, anigInstID := range mm.pDeviceHandler.pOnuOmciDevice.pOnuDB.getSortedInstKeys(ctx, me.AniGClassID) {
 				// Attach the FecPerformanceMonitoringHistoryData ME to the ANI-G ME instance
-				mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteFecHistoryME(
+				_, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteFecHistoryME(
 					ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, true, mm.pAdaptFsm.commChan, anigInstID)
+				if err != nil {
+					logger.Errorw(ctx, "CreateOrDeleteFecHistoryME failed, failure PM FSM!",
+						log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+					_ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+					return fmt.Errorf(fmt.Sprintf("CreateOrDeleteFecHistoryMe-failed-%s-%s",
+						mm.pDeviceHandler.deviceID, err))
+				}
 				_ = mm.updatePmData(ctx, n, anigInstID, cPmAdd) // TODO: ignore error for now
 			inner3:
 				// retry L2PmCreateAttempts times to create the instance of PM
@@ -1357,8 +1418,15 @@
 			}
 
 			for _, v := range copyOfGemPortInstIDsToAdd {
-				mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteGemPortHistoryME(
+				_, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteGemPortHistoryME(
 					ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, true, mm.pAdaptFsm.commChan, v)
+				if err != nil {
+					logger.Errorw(ctx, "CreateOrDeleteGemPortHistoryME failed, failure PM FSM!",
+						log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+					_ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+					return fmt.Errorf(fmt.Sprintf("CreateOrDeleteGemPortHistoryMe-failed-%s-%s",
+						mm.pDeviceHandler.deviceID, err))
+				}
 				_ = mm.updatePmData(ctx, n, v, cPmAdd) // TODO: ignore error for now
 			inner4:
 				// retry L2PmCreateAttempts times to create the instance of PM
@@ -1411,10 +1479,11 @@
 			logger.Errorw(ctx, "error calling event", log.Fields{"device-id": mm.pDeviceHandler.deviceID, "err": err})
 		}
 	}()
+	return nil
 }
 
 // nolint: gocyclo
-func (mm *onuMetricsManager) l2PmFsmDeletePM(ctx context.Context, e *fsm.Event) {
+func (mm *onuMetricsManager) l2PmFsmDeletePM(ctx context.Context, e *fsm.Event) error {
 	// Copy the l2PmToDelete for which we want to collect the metrics since l2PmToDelete can change dynamically
 	mm.onuMetricsManagerLock.RLock()
 	copyOfL2PmToDelete := make([]string, len(mm.l2PmToDelete))
@@ -1453,8 +1522,20 @@
 				inner1:
 					// retry L2PmDeleteAttempts times to delete the instance of PM
 					for cnt = 0; cnt < L2PmDeleteAttempts; cnt++ {
-						mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetPerformanceMonitoringHistoryME(
+						_, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetPerformanceMonitoringHistoryME(
 							ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, direction, false, mm.pAdaptFsm.commChan, entityID)
+						if err != nil {
+							logger.Errorw(ctx, "CreateOrDeleteEthernetPerformanceMonitoringHistoryME failed, failure PM FSM!",
+								log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+							pPMFsm := mm.pAdaptFsm
+							if pPMFsm != nil {
+								go func(p_pmFsm *AdapterFsm) {
+									_ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+								}(pPMFsm)
+							}
+							return fmt.Errorf(fmt.Sprintf("CreateOrDeleteEthernetPerformanceMonitoringHistoryMe-failed-%s-%s",
+								mm.pDeviceHandler.deviceID, err))
+						}
 						_ = mm.updatePmData(ctx, n, entityID, cPmRemove) // TODO: ignore error for now
 						if resp = mm.waitForResponseOrTimeout(ctx, false, entityID, "EthernetFramePerformanceMonitoringHistoryData"); !resp {
 							atLeastOneDeleteFailure = true
@@ -1473,8 +1554,21 @@
 			inner2:
 				// retry L2PmDeleteAttempts times to delete the instance of PM
 				for cnt = 0; cnt < L2PmDeleteAttempts; cnt++ {
-					mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetUniHistoryME(
+					_, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteEthernetUniHistoryME(
 						ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, false, mm.pAdaptFsm.commChan, entityID)
+					if err != nil {
+						logger.Errorw(ctx, "CreateOrDeleteEthernetUniHistoryME failed, failure PM FSM!",
+							log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+						pmFsm := mm.pAdaptFsm
+						if pmFsm != nil {
+							go func(p_pmFsm *AdapterFsm) {
+								_ = p_pmFsm.pFsm.Event(l2PmEventFailure)
+							}(pmFsm)
+							return err
+						}
+						return fmt.Errorf(fmt.Sprintf("CreateOrDeleteEthernetUniHistoryMe-failed-%s-%s",
+							mm.pDeviceHandler.deviceID, err))
+					}
 					if resp = mm.waitForResponseOrTimeout(ctx, false, entityID, "EthernetPerformanceMonitoringHistoryData"); !resp {
 						atLeastOneDeleteFailure = true
 					} else {
@@ -1491,8 +1585,15 @@
 			inner3:
 				// retry L2PmDeleteAttempts times to delete the instance of PM
 				for cnt = 0; cnt < L2PmDeleteAttempts; cnt++ {
-					mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteFecHistoryME(
+					_, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteFecHistoryME(
 						ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, false, mm.pAdaptFsm.commChan, entityID)
+					if err != nil {
+						logger.Errorw(ctx, "CreateOrDeleteFecHistoryME failed, failure PM FSM!",
+							log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+						_ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+						return fmt.Errorf(fmt.Sprintf("CreateOrDeleteFecHistoryMe-failed-%s-%s",
+							mm.pDeviceHandler.deviceID, err))
+					}
 					if resp := mm.waitForResponseOrTimeout(ctx, false, entityID, "FecPerformanceMonitoringHistoryData"); !resp {
 						atLeastOneDeleteFailure = true
 					} else {
@@ -1509,8 +1610,15 @@
 			inner4:
 				// retry L2PmDeleteAttempts times to delete the instance of PM
 				for cnt = 0; cnt < L2PmDeleteAttempts; cnt++ {
-					mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteGemPortHistoryME(
+					_, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendCreateOrDeleteGemPortHistoryME(
 						ctx, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, false, mm.pAdaptFsm.commChan, entityID)
+					if err != nil {
+						logger.Errorw(ctx, "CreateOrDeleteGemPortHistoryME failed, failure PM FSM!",
+							log.Fields{"device-id": mm.pDeviceHandler.deviceID})
+						_ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+						return fmt.Errorf(fmt.Sprintf("CreateOrDeleteGemPortHistoryMe-failed-%s-%s",
+							mm.pDeviceHandler.deviceID, err))
+					}
 					if resp = mm.waitForResponseOrTimeout(ctx, false, entityID, "GemPortNetworkCtpPerformanceMonitoringHistoryData"); !resp {
 						atLeastOneDeleteFailure = true
 					} else {
@@ -1556,6 +1664,7 @@
 			logger.Errorw(ctx, "error calling event", log.Fields{"device-id": mm.pDeviceHandler.deviceID, "err": err})
 		}
 	}()
+	return nil
 }
 
 // ** L2 PM FSM Handlers end **
@@ -1724,7 +1833,19 @@
 	}
 	// Insert "IntervalEndTime" as part of the requested attributes as we need this to compare the get responses when get request is multipart
 	requestedAttributes["IntervalEndTime"] = 0
-	if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+	meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+	if err != nil {
+		logger.Errorw(ctx, "GetME failed, failure PM FSM!", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+		pmFsm := mm.pAdaptFsm
+		if pmFsm != nil {
+			go func(p_pmFsm *AdapterFsm) {
+				_ = p_pmFsm.pFsm.Event(l2PmEventFailure)
+			}(pmFsm)
+			return err
+		}
+		return fmt.Errorf(fmt.Sprintf("GetME-failed-%s-%s", mm.pDeviceHandler.deviceID, err))
+	}
+	if meInstance != nil {
 		select {
 		case meAttributes = <-mm.l2PmChan:
 			logger.Debugw(ctx, "received ethernet pm history data metrics",
@@ -1817,8 +1938,16 @@
 func (mm *onuMetricsManager) populateEthernetUniHistoryMetrics(ctx context.Context, classID me.ClassID, entityID uint16,
 	meAttributes me.AttributeValueMap, requestedAttributes me.AttributeValueMap, ethPMUniHistData map[string]float32, intervalEndTime *int) error {
 	// Insert "IntervalEndTime" as part of the requested attributes as we need this to compare the get responses when get request is multipart
-	requestedAttributes["IntervalEndTime"] = 0
-	if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+	if _, ok := requestedAttributes["IntervalEndTime"]; !ok {
+		requestedAttributes["IntervalEndTime"] = 0
+	}
+	meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+	if err != nil {
+		logger.Errorw(ctx, "GetMe failed, failure PM FSM!", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+		_ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+		return fmt.Errorf(fmt.Sprintf("GetME-failed-%s-%s", mm.pDeviceHandler.deviceID, err))
+	}
+	if meInstance != nil {
 		select {
 		case meAttributes = <-mm.l2PmChan:
 			logger.Debugw(ctx, "received ethernet uni history data metrics",
@@ -1911,8 +2040,16 @@
 func (mm *onuMetricsManager) populateFecHistoryMetrics(ctx context.Context, classID me.ClassID, entityID uint16,
 	meAttributes me.AttributeValueMap, requestedAttributes me.AttributeValueMap, fecHistData map[string]float32, intervalEndTime *int) error {
 	// Insert "IntervalEndTime" as part of the requested attributes as we need this to compare the get responses when get request is multipart
-	requestedAttributes["IntervalEndTime"] = 0
-	if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+	if _, ok := requestedAttributes["IntervalEndTime"]; !ok {
+		requestedAttributes["IntervalEndTime"] = 0
+	}
+	meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+	if err != nil {
+		logger.Errorw(ctx, "GetMe failed, failure PM FSM!", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+		_ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+		return fmt.Errorf(fmt.Sprintf("GetME-failed-%s-%s", mm.pDeviceHandler.deviceID, err))
+	}
+	if meInstance != nil {
 		select {
 		case meAttributes = <-mm.l2PmChan:
 			logger.Debugw(ctx, "received fec history data metrics",
@@ -1969,8 +2106,16 @@
 func (mm *onuMetricsManager) populateGemPortMetrics(ctx context.Context, classID me.ClassID, entityID uint16,
 	meAttributes me.AttributeValueMap, requestedAttributes me.AttributeValueMap, gemPortHistData map[string]float32, intervalEndTime *int) error {
 	// Insert "IntervalEndTime" is part of the requested attributes as we need this to compare the get responses when get request is multipart
-	requestedAttributes["IntervalEndTime"] = 0
-	if meInstance := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan); meInstance != nil {
+	if _, ok := requestedAttributes["IntervalEndTime"]; !ok {
+		requestedAttributes["IntervalEndTime"] = 0
+	}
+	meInstance, err := mm.pDeviceHandler.pOnuOmciDevice.PDevOmciCC.sendGetMe(ctx, classID, entityID, requestedAttributes, mm.pDeviceHandler.pOpenOnuAc.omciTimeout, true, mm.pAdaptFsm.commChan)
+	if err != nil {
+		logger.Errorw(ctx, "GetMe failed", log.Fields{"device-id": mm.pAdaptFsm.deviceID})
+		_ = mm.pAdaptFsm.pFsm.Event(l2PmEventFailure)
+		return fmt.Errorf(fmt.Sprintf("GetME-failed-%s-%s", mm.pDeviceHandler.deviceID, err))
+	}
+	if meInstance != nil {
 		select {
 		case meAttributes = <-mm.l2PmChan:
 			logger.Debugw(ctx, "received gem port history data metrics",
@@ -2281,8 +2426,8 @@
 			"enter_" + l2PmStStarting:    func(e *fsm.Event) { mm.l2PMFsmStarting(ctx, e) },
 			"enter_" + l2PmStSyncTime:    func(e *fsm.Event) { mm.l2PMFsmSyncTime(ctx, e) },
 			"enter_" + l2PmStCollectData: func(e *fsm.Event) { mm.l2PmFsmCollectData(ctx, e) },
-			"enter_" + l2PmStCreatePmMe:  func(e *fsm.Event) { mm.l2PmFsmCreatePM(ctx, e) },
-			"enter_" + l2PmStDeletePmMe:  func(e *fsm.Event) { mm.l2PmFsmDeletePM(ctx, e) },
+			"enter_" + l2PmStCreatePmMe:  func(e *fsm.Event) { _ = mm.l2PmFsmCreatePM(ctx, e) },
+			"enter_" + l2PmStDeletePmMe:  func(e *fsm.Event) { _ = mm.l2PmFsmDeletePM(ctx, e) },
 		},
 	)
 	return nil
diff --git a/internal/pkg/onuadaptercore/uniportadmin.go b/internal/pkg/onuadaptercore/uniportadmin.go
index 75e76b2..1fe0230 100644
--- a/internal/pkg/onuadaptercore/uniportadmin.go
+++ b/internal/pkg/onuadaptercore/uniportadmin.go
@@ -205,8 +205,20 @@
 	logger.Debugw(ctx, "LockStateFSM Tx Set::ONU-G:admin", log.Fields{
 		"omciAdmin": omciAdminState, "in state": e.FSM.Current(), "device-id": oFsm.deviceID})
 	requestedAttributes := me.AttributeValueMap{"AdministrativeState": omciAdminState}
-	meInstance := oFsm.pOmciCC.sendSetOnuGLS(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
+	meInstance, err := oFsm.pOmciCC.sendSetOnuGLS(log.WithSpanFromContext(context.TODO(), ctx), oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout, true,
 		requestedAttributes, oFsm.pAdaptFsm.commChan)
+	if err != nil {
+		logger.Errorw(ctx, "OnuGLS set failed, aborting LockStateFSM", log.Fields{"device-id": oFsm.deviceID})
+		pLockStateAFsm := oFsm.pAdaptFsm
+		if pLockStateAFsm != nil {
+			go func(a_pAFsm *AdapterFsm) {
+				if a_pAFsm != nil && a_pAFsm.pFsm != nil {
+					_ = a_pAFsm.pFsm.Event(uniEvReset)
+				}
+			}(pLockStateAFsm)
+		}
+		return
+	}
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
 	oFsm.pLastTxMeInstance = meInstance
@@ -381,14 +393,28 @@
 			if uniPort.portType == uniPPTP {
 				logger.Debugw(ctx, "Setting PPTP admin state", log.Fields{
 					"device-id": oFsm.deviceID, "for PortNo": uniNo, "state (0-unlock)": omciAdminState})
-				meInstance = oFsm.pOmciCC.sendSetPptpEthUniLS(log.WithSpanFromContext(context.TODO(), ctx), uniPort.entityID, oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
+				meInstance, err := oFsm.pOmciCC.sendSetPptpEthUniLS(log.WithSpanFromContext(context.TODO(), ctx),
+					uniPort.entityID, oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
 					true, requestedAttributes, oFsm.pAdaptFsm.commChan)
+				if err != nil {
+					logger.Errorw(ctx, "SetPptpEthUniLS set failed, aborting LockStateFsm!",
+						log.Fields{"device-id": oFsm.deviceID})
+					_ = oFsm.pAdaptFsm.pFsm.Event(uniEvReset)
+					return
+				}
 				oFsm.pLastTxMeInstance = meInstance
 			} else if uniPort.portType == uniVEIP {
 				logger.Debugw(ctx, "Setting VEIP admin state", log.Fields{
 					"device-id": oFsm.deviceID, "for PortNo": uniNo, "state (0-unlock)": omciAdminState})
-				meInstance = oFsm.pOmciCC.sendSetVeipLS(log.WithSpanFromContext(context.TODO(), ctx), uniPort.entityID, oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
+				meInstance, err := oFsm.pOmciCC.sendSetVeipLS(log.WithSpanFromContext(context.TODO(), ctx),
+					uniPort.entityID, oFsm.pDeviceHandler.pOpenOnuAc.omciTimeout,
 					true, requestedAttributes, oFsm.pAdaptFsm.commChan)
+				if err != nil {
+					logger.Errorw(ctx, "SetVeipLS set failed, aborting LockStateFsm!",
+						log.Fields{"device-id": oFsm.deviceID})
+					_ = oFsm.pAdaptFsm.pFsm.Event(uniEvReset)
+					return
+				}
 				oFsm.pLastTxMeInstance = meInstance
 			} else {
 				logger.Warnw(ctx, "Unsupported UniTP type - skip",
diff --git a/internal/pkg/onuadaptercore/uniportstatus.go b/internal/pkg/onuadaptercore/uniportstatus.go
index 8378073..1674b52 100644
--- a/internal/pkg/onuadaptercore/uniportstatus.go
+++ b/internal/pkg/onuadaptercore/uniportstatus.go
@@ -56,7 +56,11 @@
 
 			requestedAttributes := me.AttributeValueMap{adminState: 0, operationalState: 0, configInd: 0}
 			// Note: No reference to fetch the OMCI timeout configuration value, so hard code it to 10s
-			if meInstance := portStatus.pOmiCC.sendGetMe(ctx, me.PhysicalPathTerminationPointEthernetUniClassID, uniPort.entityID, requestedAttributes, 10, true, portStatus.omciRespChn); meInstance != nil {
+			meInstance, err := portStatus.pOmiCC.sendGetMe(ctx, me.PhysicalPathTerminationPointEthernetUniClassID, uniPort.entityID, requestedAttributes, 10, true, portStatus.omciRespChn)
+			if err != nil {
+				return postUniStatusErrResponse(extension.GetValueResponse_INTERNAL_ERROR)
+			}
+			if meInstance != nil {
 				portStatus.pLastTxMeInstance = meInstance
 
 				//verify response