static void
set_values (
plc_sProcess *pp
)
{
int i;
for (i = 0; i < pp->IOHandler->AvCount; i++) {
pwr_tFloat32 *p = gdh_TranslateRtdbPointer(pp->base.av_i.p->Value[i]);
if (p != NULL)
pp->base.av_a.p->Value[i] = *p;
}
for (i = 0; i < pp->IOHandler->IvCount; i++) {
pwr_tInt32 *p = gdh_TranslateRtdbPointer(pp->base.iv_i.p->Value[i]);
if (p != NULL)
pp->base.iv_a.p->Value[i] = *p;
}
for (i = 0; i < pp->IOHandler->DvCount; i++) {
pwr_tBoolean *p = gdh_TranslateRtdbPointer(pp->base.dv_i.p->Value[i]);
if (p != NULL)
pp->base.dv_a.p->Value[i] = *p;
}
for (i = 0; i < pp->IOHandler->AiCount; i++) {
pwr_tFloat32 *p = gdh_TranslateRtdbPointer(pp->base.ai_i.p->Value[i]);
if (p != NULL)
pp->base.ai_a.p->Value[i] = *p;
}
for (i = 0; i < pp->IOHandler->AoCount; i++) {
pwr_tFloat32 *p = gdh_TranslateRtdbPointer(pp->base.ao_i.p->Value[i]);
if (p != NULL)
pp->base.ao_a.p->Value[i] = *p;
}
for (i = 0; i < pp->IOHandler->DiCount; i++) {
pwr_tBoolean *p = gdh_TranslateRtdbPointer(pp->base.di_i.p->Value[i]);
if (p != NULL)
pp->base.di_a.p->Value[i] = *p;
}
for (i = 0; i < pp->IOHandler->DoCount; i++) {
pwr_tBoolean *p = gdh_TranslateRtdbPointer(pp->base.do_i.p->Value[i]);
if (p != NULL)
pp->base.do_a.p->Value[i] = *p;
}
for (i = 0; i < pp->IOHandler->IiCount; i++) {
pwr_tInt32 *p = gdh_TranslateRtdbPointer(pp->base.ii_i.p->Value[i]);
if (p != NULL)
pp->base.ii_a.p->Value[i] = *p;
}
for (i = 0; i < pp->IOHandler->IoCount; i++) {
pwr_tInt32 *p = gdh_TranslateRtdbPointer(pp->base.io_i.p->Value[i]);
if (p != NULL)
pp->base.io_a.p->Value[i] = *p;
}
}
/*
* Name:
* io_InitFilterAi
*
*
* Function:
* Initialize filter for one Ai-object.
* Description:
*
*/
pwr_tStatus io_InitAiFilter
(
pwr_sClass_ChanAi *ChanObj,
pwr_sClass_Ai *SignalObj,
void **FilterData,
pwr_tFloat32 ScanTime
)
{
sFilterData_1 *Data_1;
if ( SignalObj == NULL ) return IO__SUCCESS;
switch (SignalObj->FilterType) {
case _FilterType_0:
break;
case _FilterType_1:
Data_1 = (sFilterData_1 *) malloc( sizeof(sFilterData_1) );
Data_1->ActualValue = gdh_TranslateRtdbPointer((unsigned long)SignalObj->ActualValue);
Data_1->ScanTime = (pwr_tFloat32) (ScanTime * ChanObj->ScanInterval); /* Scan time (seconds) */
*FilterData = Data_1;
break;
default:
break;
}
return IO__SUCCESS;
} /* END io_InitFilterAi */
/*
* Name:
* io_InitFilterPo
*
*
* Function:
* Initialize filter for max 16 Po ( one Do-card ).
* Description:
*
*/
pwr_tStatus io_InitPoFilter
(
pwr_sClass_Po *SignalObj[],
pwr_tBoolean *Filter,
void *FilterData[],
pwr_tFloat32 ScanTime
)
{
sFilterData *Data_1;
int Idx;
*Filter = FALSE; /* Supose no signals with filter */
for ( Idx = 0; Idx < _MaxNoOfPo; Idx++) {
if ( SignalObj[Idx] == NULL ) continue;
if ( ScanTime > 0 ) {
Data_1 = (sFilterData *) malloc( sizeof(sFilterData) );
Data_1->ScanTime = ScanTime;
Data_1->TimerPulse = SignalObj[Idx]->PulseLength/Data_1->ScanTime + 0.5;
Data_1->ActualValue = gdh_TranslateRtdbPointer((unsigned long)SignalObj[Idx]->ActualValue);
Data_1->OldValue = *Data_1->ActualValue;
Data_1->Type = _eState_Neutral;
FilterData[Idx] = Data_1;
*Filter = TRUE;
}
}
return IO__SUCCESS;
} /* END io_InitFilterPo */
void StoIpPtr_init( pwr_sClass_StoIpPtr *o)
{
pwr_tUInt32 p;
pwr_tAttrRef aref = o->IpPtrObject;
/* Reset the indirect bit to fetch the pointer, not the value */
aref.Flags.b.Indirect = 0;
if ( ODD( gdh_GetObjectInfoAttrref( &aref, &p, sizeof(p))))
o->Ptr = gdh_TranslateRtdbPointer( p);
}
static void
load_backup ()
{
pwr_tObjid oid;
pwr_sClass_AvArea *avp;
pwr_sClass_DvArea *dvp;
pwr_sClass_IvArea *ivp;
pwr_sClass_InitArea *iavp;
pwr_sClass_InitArea *idvp;
pwr_sClass_InitArea *iivp;
pwr_tStatus sts;
int i;
pwr_sClass_IOHandler *iop;
pwr_sAttrRef aref;
sts = io_get_iohandler_object(&iop, NULL);
if (EVEN(sts)) {
errh_Error("io_get_iohandler_object, %m", sts);
return;
}
sts = gdh_NameToObjid("pwrNode-active-io-av", &oid);
if (EVEN(sts)) {
errh_Error("gdh_NameToObjid(pwrNode-active-io-av, &oid), %m", sts);
return;
}
sts = gdh_ObjidToPointer(oid, (void *) &avp);
if (EVEN(sts)) {
errh_Error("gdh_ObjidToPointer(oid, (void *) &avp), %m", sts);
return;
}
sts = gdh_NameToObjid("pwrNode-active-io-av_init", &oid);
if (EVEN(sts)) {
errh_Error("gdh_NameToObjid(pwrNode-active-io-av_init, &oid), %m", sts);
return;
}
sts = gdh_ObjidToPointer(oid, (void *) &iavp);
if (EVEN(sts)) {
errh_Error("gdh_ObjidToPointer(oid, (void *) &iavp), %m", sts);
return;
}
sts = gdh_NameToObjid("pwrNode-active-io-dv", &oid);
if (EVEN(sts)) {
errh_Error("gdh_NameToObjid(pwrNode-active-io-dv, &oid), %m", sts);
return;
}
sts = gdh_ObjidToPointer(oid, (void *) &dvp);
if (EVEN(sts)) {
errh_Error("gdh_ObjidToPointer(oid, (void *) &dvp), %m", sts);
return;
}
sts = gdh_NameToObjid("pwrNode-active-io-dv_init", &oid);
if (EVEN(sts)) {
errh_Error("gdh_NameToObjid(pwrNode-active-io-dv_init, &oid), %m", sts);
return;
}
sts = gdh_ObjidToPointer(oid, (void *) &idvp);
if (EVEN(sts)) {
errh_Error("gdh_ObjidToPointer(oid, (void *) &idvp), %m", sts);
return;
}
sts = gdh_NameToObjid("pwrNode-active-io-iv", &oid);
if (EVEN(sts)) {
errh_Error("gdh_NameToObjid(pwrNode-active-io-iv, &oid), %m", sts);
return;
}
sts = gdh_ObjidToPointer(oid, (void *) &ivp);
if (EVEN(sts)) {
errh_Error("gdh_ObjidToPointer(oid, (void *) &ivp), %m", sts);
return;
}
sts = gdh_NameToObjid("pwrNode-active-io-iv_init", &oid);
if (EVEN(sts)) {
errh_Error("gdh_NameToObjid(pwrNode-active-io-iv_init, &oid), %m", sts);
return;
}
sts = gdh_ObjidToPointer(oid, (void *) &iivp);
if (EVEN(sts)) {
errh_Error("gdh_ObjidToPointer(oid, (void *) &iivp), %m", sts);
return;
}
for (i = 0; i < iop->AvCount; i++) {
pwr_tFloat32 *ifp = gdh_TranslateRtdbPointer(iavp->Value[i]);
avp->Value[i]= *ifp;
}
for (i = 0; i < iop->DvCount; i++) {
pwr_tBoolean *ibp = gdh_TranslateRtdbPointer(idvp->Value[i]);
dvp->Value[i] = *ibp;
}
for (i = 0; i < iop->IvCount; i++) {
pwr_tInt32 *iip = gdh_TranslateRtdbPointer(iivp->Value[i]);
ivp->Value[i] = *iip;
}
typedef struct {
union {
pwr_tFloat32 *f;
pwr_tInt32 *i;
pwr_tBoolean *b;
} actval_p;
pwr_tUInt32 validx;
union {
pwr_sClass_Av *av;
pwr_sClass_Iv *iv;
pwr_sClass_Dv *dv;
pwr_sClass_Ai *ai;
pwr_sClass_Ao *ao;
pwr_sClass_Ii *ii;
pwr_sClass_Io *io;
pwr_sClass_Di *di;
pwr_sClass_Do *dox;
pwr_sClass_Co *co;
} op;
} ini_sRestoreSig;
// Store ActualValue pointers
ini_sRestoreSig *rsav = calloc( sizeof(ini_sRestoreSig), iop->AvCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Av, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Av, &aref, &aref)) {
if ( i >= iop->AvCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsav[i].op.av);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsav[i].actval_p.f = rsav[i].op.av->ActualValue;
rsav[i].validx = rsav[i].op.av->ValueIndex;
i++;
}
ini_sRestoreSig *rsdv = calloc( sizeof(ini_sRestoreSig), iop->DvCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Dv, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Dv, &aref, &aref)) {
if ( i >= iop->DvCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsdv[i].op.dv);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsdv[i].actval_p.b = rsdv[i].op.dv->ActualValue;
rsdv[i].validx = rsdv[i].op.dv->ValueIndex;
i++;
}
ini_sRestoreSig *rsiv = calloc( sizeof(ini_sRestoreSig), iop->IvCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Iv, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Iv, &aref, &aref)) {
if ( i >= iop->IvCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsiv[i].op.iv);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsiv[i].actval_p.i = rsiv[i].op.iv->ActualValue;
rsiv[i].validx = rsiv[i].op.iv->ValueIndex;
i++;
}
ini_sRestoreSig *rsai = calloc( sizeof(ini_sRestoreSig), iop->AiCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Ai, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Ai, &aref, &aref)) {
if ( i >= iop->AiCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsai[i].op.ai);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsai[i].actval_p.f = rsai[i].op.ai->ActualValue;
rsai[i].validx = rsai[i].op.ai->ValueIndex;
i++;
}
ini_sRestoreSig *rsao = calloc( sizeof(ini_sRestoreSig), iop->AoCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Ao, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Ao, &aref, &aref)) {
if ( i >= iop->AoCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsao[i].op.ao);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsao[i].actval_p.f = rsao[i].op.ao->ActualValue;
rsao[i].validx = rsao[i].op.ao->ValueIndex;
i++;
}
ini_sRestoreSig *rsii = calloc( sizeof(ini_sRestoreSig), iop->IiCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Ii, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Ii, &aref, &aref)) {
if ( i >= iop->IiCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsii[i].op.ii);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsii[i].actval_p.i = rsii[i].op.ii->ActualValue;
rsii[i].validx = rsii[i].op.ii->ValueIndex;
i++;
}
ini_sRestoreSig *rsio = calloc( sizeof(ini_sRestoreSig), iop->IoCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Io, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Io, &aref, &aref)) {
if ( i >= iop->IoCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsio[i].op.io);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsio[i].actval_p.i = rsio[i].op.io->ActualValue;
rsio[i].validx = rsio[i].op.io->ValueIndex;
i++;
}
ini_sRestoreSig *rsdi = calloc( sizeof(ini_sRestoreSig), iop->DiCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Di, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Di, &aref, &aref)) {
if ( i >= iop->DiCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsdi[i].op.di);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsdi[i].actval_p.b = rsdi[i].op.di->ActualValue;
rsdi[i].validx = rsdi[i].op.di->ValueIndex;
i++;
}
ini_sRestoreSig *rsdo = calloc( sizeof(ini_sRestoreSig), iop->DoCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Do, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Do, &aref, &aref)) {
if ( i >= iop->DoCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsdo[i].op.dox);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsdo[i].actval_p.b = rsdo[i].op.dox->ActualValue;
rsdo[i].validx = rsdo[i].op.dox->ValueIndex;
i++;
}
ini_sRestoreSig *rsco = calloc( sizeof(ini_sRestoreSig), iop->CoCount);
pwr_tInt32 **rscoa = calloc( sizeof(pwr_tInt32*), iop->CoCount);
i = 0;
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_Co, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef(pwr_cClass_Co, &aref, &aref)) {
if ( i >= iop->CoCount) break;
sts = gdh_AttrRefToPointer( &aref, (pwr_tAddress *)&rsco[i].op.co);
if ( EVEN(sts)) {
errh_Error("gdh_AttrRefToPointer Iv, %m", sts);
return;
}
rsco[i].actval_p.i = rsco[i].op.co->RawValue;
rsco[i].validx = rsco[i].op.co->ValueIndex;
rscoa[i] = rsco[i].op.co->AbsValue;
i++;
}
sts = bck_LoadBackup();
if (EVEN(sts)) {
errh_Error("bck_LoadBackup, %m", sts);
return;
}
// Set stored ActualValue pointers
for ( i = 0; i < iop->AvCount; i++) {
rsav[i].op.av->ActualValue = rsav[i].actval_p.f;
rsav[i].op.av->ValueIndex = rsav[i].validx;
}
free( rsav);
for ( i = 0; i < iop->DvCount; i++) {
rsdv[i].op.dv->ActualValue = rsdv[i].actval_p.b;
rsdv[i].op.dv->ValueIndex = rsdv[i].validx;
}
free( rsdv);
for ( i = 0; i < iop->IvCount; i++) {
rsiv[i].op.iv->ActualValue = rsiv[i].actval_p.i;
rsiv[i].op.iv->ValueIndex = rsiv[i].validx;
}
free( rsiv);
for ( i = 0; i < iop->AiCount; i++) {
rsai[i].op.ai->ActualValue = rsai[i].actval_p.f;
rsai[i].op.ai->ValueIndex = rsai[i].validx;
}
free( rsai);
for ( i = 0; i < iop->AoCount; i++) {
rsao[i].op.ao->ActualValue = rsao[i].actval_p.f;
rsao[i].op.ao->ValueIndex = rsao[i].validx;
}
free( rsao);
for ( i = 0; i < iop->IiCount; i++) {
rsii[i].op.ii->ActualValue = rsii[i].actval_p.i;
rsii[i].op.ii->ValueIndex = rsii[i].validx;
}
free( rsii);
for ( i = 0; i < iop->IoCount; i++) {
rsio[i].op.io->ActualValue = rsio[i].actval_p.i;
rsio[i].op.io->ValueIndex = rsio[i].validx;
}
free( rsio);
for ( i = 0; i < iop->DiCount; i++) {
rsdi[i].op.di->ActualValue = rsdi[i].actval_p.b;
rsdi[i].op.di->ValueIndex = rsdi[i].validx;
}
free( rsdi);
for ( i = 0; i < iop->DoCount; i++) {
rsdo[i].op.dox->ActualValue = rsdo[i].actval_p.b;
rsdo[i].op.dox->ValueIndex = rsdo[i].validx;
}
free( rsdo);
for ( i = 0; i < iop->CoCount; i++) {
rsco[i].op.co->RawValue = rsco[i].actval_p.i;
rsco[i].op.co->AbsValue = rscoa[i];
rsco[i].op.co->ValueIndex = rsco[i].validx;
}
free( rsco);
free( rscoa);
for (i = 0; i < iop->AvCount; i++) {
pwr_tFloat32 *ifp = gdh_TranslateRtdbPointer(iavp->Value[i]);
*ifp = avp->Value[i];
}
for (i = 0; i < iop->DvCount; i++) {
pwr_tBoolean *ibp = gdh_TranslateRtdbPointer(idvp->Value[i]);
*ibp = dvp->Value[i];
}
for (i = 0; i < iop->IvCount; i++) {
pwr_tInt32 *iip = gdh_TranslateRtdbPointer(iivp->Value[i]);
*iip = ivp->Value[i];
}
}
/*
* Name:
* io_ConnectToDigSupLstSerial
*
*
* Function:
* Initialize list of DSup object for digitala in- och output signals.
* Description:
*
*/
pwr_tStatus io_ConnectToDigSupLstSerial (
pwr_tClassId Class,
pwr_tObjid ObjId,
pwr_tAddress ObjP /* Pointer to the object */
)
{
pwr_tStatus Sts;
pwr_sClass_DSup *DSupP;
pwr_sClass_Di *DiP;
pwr_sClass_Do *DoP;
pwr_sClass_Po *PoP;
pwr_tBoolean *BooleanP;
pwr_tObjid SupId;
pwr_tClassId ObjClass;
sDSupLstLink *DSupLstP;
sDSupLstLink *NextDSupLstP, *NextP;
switch (Class) {
case pwr_cClass_Di:
DiP = (pwr_sClass_Di *) ObjP;
BooleanP = gdh_TranslateRtdbPointer( (pwr_tUInt32)DiP->ActualValue );
break;
case pwr_cClass_Do:
DoP = (pwr_sClass_Do *) ObjP;
BooleanP = gdh_TranslateRtdbPointer( (pwr_tUInt32)DoP->ActualValue );
break;
case pwr_cClass_Po:
PoP = (pwr_sClass_Po *) ObjP;
BooleanP = gdh_TranslateRtdbPointer( (pwr_tUInt32)PoP->ActualValue );
break;
default:
return ( IO__SUCCESS );
break;
}
/* Get child with class DSup */
Sts = gdh_GetChild ( ObjId, &SupId);
while ( ODD(Sts)) {
Sts = gdh_GetObjectClass ( SupId, &ObjClass);
if ( EVEN(Sts)) return (Sts);
if ( ObjClass == pwr_cClass_DSup ) {
Sts = gdh_ObjidToPointer ( SupId, (pwr_tAddress *)&DSupP);
if (EVEN(Sts)) return ( Sts );
DSupLstP = (sDSupLstLink *) calloc( 1, sizeof(sDSupLstLink) );
DSupLstP->SupP = DSupP;
DSupLstP->ValueP = BooleanP;
if ( DSupDigSerialLstP == NULL ) {
DSupDigSerialLstP = DSupLstP;
}
else {
if ( DSupDigSerialLstP->NextP == NULL ) {
DSupDigSerialLstP->NextP = DSupLstP;
}
else {
NextP = DSupDigSerialLstP->NextP;
while ( NextP != NULL ) {
NextDSupLstP = NextP;
NextP = NextP->NextP;
}
NextDSupLstP->NextP = DSupLstP;
}
}
}
Sts = gdh_GetNextSibling ( SupId, &SupId);
}
return IO__SUCCESS;
} /* END io_ConnectToDigSupLstSerial */
/*
* Name:
* io_ConnectToAnaSupLstSerial
*
*
* Function:
* Initialize list of ASup object for serial connected analog in- och output
* signals.
* Description:
*
*/
pwr_tStatus io_ConnectToAnaSupLstSerial (
pwr_tClassId Class,
pwr_tObjid ObjId,
pwr_tAddress ObjP /* Pointer to the object */
)
{
pwr_tStatus Sts;
pwr_sClass_ASup *ASupP;
pwr_sClass_Ai *AiP;
pwr_sClass_Ao *AoP;
pwr_tFloat32 *Float32P;
pwr_tObjid SupId;
pwr_tClassId ObjClass;
sASupLstLink *ASupLstP;
sASupLstLink *NextASupLstP, *NextP;
switch (Class) {
case pwr_cClass_Ai:
AiP = (pwr_sClass_Ai *) ObjP;
Float32P = gdh_TranslateRtdbPointer( (pwr_tUInt32)AiP->ActualValue );
break;
case pwr_cClass_Ao:
AoP = (pwr_sClass_Ao *) ObjP;
Float32P = gdh_TranslateRtdbPointer( (pwr_tUInt32)AoP->ActualValue );
break;
default:
return ( IO__SUCCESS );
break;
}
/* Get child with class ASup */
Sts = gdh_GetChild ( ObjId, &SupId);
while ( ODD(Sts)) {
Sts = gdh_GetObjectClass ( SupId, &ObjClass);
if ( EVEN(Sts)) return (Sts);
if ( ObjClass == pwr_cClass_ASup ) {
Sts = gdh_ObjidToPointer ( SupId, (pwr_tAddress *)&ASupP);
if (EVEN(Sts)) return ( Sts );
ASupLstP = (sASupLstLink *) calloc( 1, sizeof(sASupLstLink) );
ASupLstP->SupP = ASupP;
ASupLstP->ValueP = Float32P;
if ( ASupAnaSerialLstP == NULL ) {
ASupAnaSerialLstP = ASupLstP;
}
else {
if ( ASupAnaSerialLstP->NextP == NULL ) {
ASupAnaSerialLstP->NextP = ASupLstP;
}
else {
NextP = ASupAnaSerialLstP->NextP;
while ( NextP != NULL ) {
NextASupLstP = NextP;
NextP = NextP->NextP;
}
NextASupLstP->NextP = ASupLstP;
}
}
}
Sts = gdh_GetNextSibling ( SupId, &SupId);
}
return IO__SUCCESS;
} /* END io_ConnectToAnaSupLstSerial */
