pwr_tStatus proc_Start ( proc_sProcess *p ) { pwr_tStatus sts = PROC__SUCCESS; char **argv; p->pid = fork(); if (p->pid) { if (p->pid == -1) { errh_Error("Could not start %s, %m\nfile: %s", p->name, errno_GetStatus(), p->file); } else { errh_Info("Started %s, prio: %d, pid: %d\nfile: %s", p->name, p->p_prio, (int)p->pid, p->file); } } else { sts = proc_SetPriority(p->p_prio); if (EVEN(sts)) errh_Warning("%s: error setprio, %m\nfile: %s", p->name, sts, p->file); argv = co_StrToArgv(p->file, p->arg); execvp(p->file, argv); errh_Error("%s: error execvp, %m\nfile: %s", p->name, errno_GetStatus(), p->file); exit(EXIT_FAILURE); } return sts; }
void cvols_Notify ( cvol_sNotify *nmp ) { pwr_tStatus lsts; pool_sQlink *nl; gdb_sNode *np; qcom_sQid tgt; qcom_sPut put; gdb_AssumeLocked; if (gdbroot->db->nethandler.qix == 0) return; tgt.qix = net_cProcHandler; gdb_Unlock; /* Send to all nodes that have mounted affected volume. NOTA BENE !!! In this version we send to all known nodes. */ for ( nl = pool_Qsucc(NULL, gdbroot->pool, &gdbroot->db->nod_lh); nl != &gdbroot->db->nod_lh; nl = pool_Qsucc(NULL, gdbroot->pool, nl) ) { np = pool_Qitem(nl, gdb_sNode, nod_ll); if (np == gdbroot->my_node || np == gdbroot->no_node) continue; if (!np->flags.b.active) continue; /* Todo !!! What happens with consistency ? */ tgt.nid = np->nid; if (!net_Put(&lsts, &tgt, &nmp->msg, nmp->subtype, 0, nmp->size, 0)) errh_Warning("Notify: error %x sending subtype %s to node %s", lsts, "Notify", np->name); } /* Submit to the NETH ACP to check if any subscriptions are affected. */ put.type.b = net_cMsgClass; put.type.s = nmp->subtype; put.reply = qcom_cNQid; put.data = (char *)&nmp->msg; put.size = nmp->size; nmp->msg.hdr.hdr.xdr = 0; nmp->msg.hdr.hdr.msn = 0; nmp->msg.hdr.hdr.nid = gdbroot->my_node->nid; qcom_Put(&lsts, &qcom_cQnacp, &put); gdb_Lock; }
static void bugError ( qcom_sGet *get ) { errh_Warning("Unexpected message type <%d:%d> received from %x @ %s", get->type.b, get->type.s, get->pid, cdh_NodeIdToString(NULL, get->sender.nid, 0, 0)); }
static pwr_tStatus IoCardWrite( io_tCtx ctx, io_sAgent *ap, io_sRack *rp, io_sCard *cp) { io_sLocalSPI_Slave *local = (io_sLocalSPI_Slave *)cp->Local; pwr_sClass_SPI_Slave *op = (pwr_sClass_SPI_Slave *)cp->op; int sts; int i; io_bus_card_write( ctx, cp, local->output_area, local->byte_ordering, pwr_eFloatRepEnum_FloatIEEE); // sts = write( local->fd, local->output_area, local->output_area_size); for ( i = 0; i < local->output_area_size; i++) { sts = write( local->fd, &local->output_area[i], 1); if ( sts != 1) break; } if ( sts < 0) { op->ErrorCount++; if ( !local->writeerror_logged) { errh_Error( "SPI write error errno %d, '%s'", errno, cp->Name); local->writeerror_logged = 1; } op->Status = IOM__SPI_WRITEERROR; } // else if ( sts != local->output_area_size) { else if ( sts == 0) { op->ErrorCount++; if ( !local->writeerror_logged) { errh_Error( "SPI write buffer unexpected size %d, '%s'", sts, cp->Name); local->writeerror_logged = 1; } op->Status = IOM__SPI_WRITEERROR; } else { local->writeerror_logged = 0; op->Status = IOM__SPI_NORMAL; } if ( op->ErrorSoftLimit && op->ErrorCount == op->ErrorSoftLimit && !local->softlimit_logged) { errh_Warning( "IO Card ErrorSoftLimit reached, '%s'", cp->Name); local->softlimit_logged = 1; } if ( op->ErrorHardLimit && op->ErrorCount >= op->ErrorHardLimit) { errh_Error( "IO Card ErrorHardLimit reached '%s', IO stopped", cp->Name); ctx->Node->EmergBreakTrue = 1; return IO__ERRDEVICE; } return IO__SUCCESS; }
JNIEXPORT void JNICALL Java_jpwr_rt_Errh_warning (JNIEnv *env, jobject object, jstring jmsg) { char *cstr; const char *msg; msg = (*env)->GetStringUTFChars( env, jmsg, 0); cstr = (char *)msg; errh_Warning( cstr); (*env)->ReleaseStringUTFChars( env, jmsg, cstr); }
static pwr_tStatus IoCardRead( io_tCtx ctx, io_sAgent *ap, io_sRack *rp, io_sCard *cp) { io_sLocalAiDevice *local = (io_sLocalAiDevice *)cp->Local; pwr_sClass_OneWire_AiDevice *op = (pwr_sClass_OneWire_AiDevice *)cp->op; char str[256]; char *s; pwr_tUInt32 error_count = op->Super.ErrorCount; if ( op->ScanInterval > 1) { if ( local->interval_cnt != 0) { local->interval_cnt++; if ( local->interval_cnt >= op->ScanInterval) local->interval_cnt = 0; return IO__SUCCESS; } local->interval_cnt++; } if ( cp->chanlist[0].cop && cp->chanlist[0].sop) { io_sChannel *chanp = &cp->chanlist[0]; pwr_sClass_ChanAi *cop = (pwr_sClass_ChanAi *)chanp->cop; pwr_sClass_Ai *sop = (pwr_sClass_Ai *)chanp->sop; pwr_tFloat32 actvalue; if ( cop->CalculateNewCoef) // Request to calculate new coefficients io_AiRangeToCoef( chanp); fflush( local->value_fp); fgets( str, sizeof(str), local->value_fp); fgets( str, sizeof(str), local->value_fp); rewind( local->value_fp); if ( strcmp( op->ValueSearchString, "") == 0) s = str; else s = strstr( str, op->ValueSearchString); if ( s) { switch ( op->ChAi.Representation) { case pwr_eDataRepEnum_Float32: case pwr_eDataRepEnum_Float64: { pwr_tFloat32 fvalue; sscanf( s+strlen(op->ValueSearchString), "%f", &fvalue); if ( op->ErrorValue != 0 && fabs( op->ErrorValue - fvalue) > FLT_EPSILON ) { /* TODO Check CRC Probably power loss... op->Super.ErrorCount++; */ } actvalue = cop->SensorPolyCoef0 + cop->SensorPolyCoef1 * fvalue; // Filter if ( sop->FilterType == 1 && sop->FilterAttribute[0] > 0 && sop->FilterAttribute[0] > ctx->ScanTime) { actvalue = *(pwr_tFloat32 *)chanp->vbp + ctx->ScanTime / sop->FilterAttribute[0] * (actvalue - *(pwr_tFloat32 *)chanp->vbp); } *(pwr_tFloat32 *)chanp->vbp = actvalue; sop->SigValue = cop->SigValPolyCoef1 * fvalue + cop->SigValPolyCoef0; sop->RawValue = fvalue; op->Status = IO__SUCCESS; break; } default: { pwr_tInt32 ivalue; sscanf( s+strlen(op->ValueSearchString), "%d", &ivalue); io_ConvertAi32( cop, ivalue, &actvalue); if ( op->ErrorValue != 0 && fabs( op->ErrorValue - ivalue) > FLT_EPSILON ) { /* TODO Check CRC Probably power loss... op->Super.ErrorCount++; */ } // Filter if ( sop->FilterType == 1 && sop->FilterAttribute[0] > 0 && sop->FilterAttribute[0] > ctx->ScanTime) { actvalue = *(pwr_tFloat32 *)chanp->vbp + ctx->ScanTime / sop->FilterAttribute[0] * (actvalue - *(pwr_tFloat32 *)chanp->vbp); } *(pwr_tFloat32 *)chanp->vbp = actvalue; sop->SigValue = cop->SigValPolyCoef1 * ivalue + cop->SigValPolyCoef0; sop->RawValue = ivalue; op->Status = IO__SUCCESS; } } } else { op->Super.ErrorCount++; op->Status = IO__SEARCHSTRING; } } if ( op->Super.ErrorCount >= op->Super.ErrorSoftLimit && error_count < op->Super.ErrorSoftLimit) { errh_Warning( "IO Card ErrorSoftLimit reached, '%s'", cp->Name); ctx->IOHandler->CardErrorSoftLimit = 1; ctx->IOHandler->ErrorSoftLimitObject = cdh_ObjidToAref( cp->Objid); } if ( op->Super.ErrorCount >= op->Super.ErrorHardLimit) { errh_Error( "IO Card ErrorHardLimit reached '%s', IO stopped", cp->Name); ctx->Node->EmergBreakTrue = 1; op->Status = IO__ERRDEVICE; ctx->IOHandler->CardErrorHardLimit = 1; ctx->IOHandler->ErrorHardLimitObject = cdh_ObjidToAref( cp->Objid); return IO__ERRDEVICE; } return IO__SUCCESS; }
int qini_ParseFile ( FILE *f, tree_sTable *ntp, int *warnings, int *errors, int *fatals ) { pwr_tStatus sts = 1; int n; char *s; char buffer[256]; int error = 0; char name[80]; char s_nid[80]; char s_naddr[80]; char s_port[80]; char s_connection[80]; char s_min_resend_time[80]; char s_max_resend_time[80]; pwr_tNodeId nid; struct in_addr naddr; qini_sNode *nep; struct arpreq arpreq; while ((s = fgets(buffer, sizeof(buffer) - 1, f)) != NULL) { if (*s == '#' || *s == '!') { s++; continue; } n = sscanf(s, "%s %s %s %s %s %s %s", name, s_nid, s_naddr, s_port, s_connection, s_min_resend_time, s_max_resend_time); if (n < 3) { errh_Error("error in line, <wrong number of arguments>, skip to next line.\n>> %s", s); (*errors)++; continue; } sts = cdh_StringToVolumeId(s_nid, (pwr_tVolumeId *)&nid); if (EVEN(sts)) { errh_Error("error in line, <node identity>, skip to next line.\n>> %s", s); (*errors)++; continue; } sts = net_StringToAddr( s_naddr, &naddr); if ( EVEN(sts)) { errh_Error("error in line, <network address>, skip to next line.\n>> %s", s); (*errors)++; continue; } #if 0 naddr.s_addr = inet_network(s_naddr); #if defined(OS_VMS) if (naddr.s_addr == (in_addr_t)-1) { #else if (naddr.s_addr == (unsigned int)-1) { #endif /* Try name instead */ struct addrinfo hints; struct addrinfo *res; int err; memset((void*)&hints, 0, sizeof(hints)); hints.ai_socktype = SOCK_STREAM; err = getaddrinfo(s_naddr, 0, &hints, &res); if ( err < 0) { errh_Error("error in line, <network address>, skip to next line.\n>> %s", s); (*errors)++; continue; } switch ( res->ai_family) { case AF_INET: // memcpy( &naddr.s_addr, (char *)&res->ai_addr->sa_data + 2, 4); memcpy( &naddr.s_addr, &((struct sock_addr_in *)res->ai_addr)->sin_addr, 4); naddr.s_addr = ntohl( naddr.s_addr); break; case AF_INET6: break; } freeaddrinfo( res); } #endif nep = tree_Find(&sts, ntp, &nid); if (nep != NULL) { errh_Warning("node is allready defined: %s, skip to next line", s); (*warnings)++; continue; } else { nep = tree_Insert(&sts, ntp, &nid); } strcpy(nep->name, name); nep->naddr.s_addr = htonl(naddr.s_addr); if (n > 3) nep->port = htons(atoi(s_port)); if (n > 4) nep->connection = atoi(s_connection); if (n > 5) nep->min_resend_time = atoi(s_min_resend_time); if (n > 6) nep->max_resend_time = atoi(s_max_resend_time); memset(&arpreq, 0, sizeof(arpreq)); memcpy(&arpreq.arp_pa.sa_data, &naddr, sizeof(naddr)); inet_GetArpEntry(&sts, 0, &arpreq); } return error; } pwr_tBoolean qini_BuildDb ( pwr_tStatus *sts, tree_sTable *nodes, qini_sNode *me, #if 0 /* change when new class NetConfig is deined */ pwr_sNetConfig *cp, #else void *cp, #endif qcom_tBus bus ) { qdb_sInit init; qdb_sNode *np; qini_sNode *nep; void *p; qdb_sAppl *ap; memset(&init, 0, sizeof(init)); init.nid = me->nid; init.bus = bus; init.nodes = nodes->nNode; #if 0 /* change when new class NetConfig is deined */ init.queues = cp->Queues; init.applications = cp->Applications; init.sbufs = cp->SmallCount; init.mbufs = cp->MediumCount; init.lbufs = cp->LargeCount; init.size_sbuf = cp->SmallSize; init.size_mbuf = cp->MediumSize; init.size_lbuf = cp->LargeSize; #endif p = qdb_CreateDb(sts, &init); if (p == NULL) return NO; qdb_ScopeLock { for (nep = tree_Minimum(sts, nodes); nep != NULL; nep = tree_Successor(sts, nodes, nep)) { np = addNode(nep); } ap = qdb_AddAppl(NULL, YES); qdb->exportque = addQueue(NULL, qdb_cIexport, "export", qdb_eQue_private, qdb_mQue_system); addQueue(ap, qcom_cInetEvent, "netEvent", qdb_eQue_forward, qdb_mQue_system); addQueue(ap, qcom_cIapplEvent, "applEvent", qdb_eQue_forward, qdb_mQue_system); addQueue(ap, qcom_cImhAllHandlers, "allHandlers", qdb_eQue_forward, qdb_mQue_broadcast); addQueue(ap, qcom_cImhAllOutunits, "allOutunits", qdb_eQue_forward, qdb_mQue_broadcast); addQueue(ap, qcom_cIhdServer, "hdServer", qdb_eQue_forward, qdb_mQue_broadcast); addQueue(ap, qcom_cIhdClient, "hdClient", qdb_eQue_forward, qdb_mQue_broadcast); #if !defined OS_CYGWIN addQueue(NULL, qcom_cInacp, "nacp", qdb_eQue_private, qdb_mQue_system); #endif addQueue(ap, qcom_cIini, "ini", qdb_eQue_forward, qdb_mQue_system | qdb_mQue_event); } qdb_ScopeUnlock; return (YES); }
gdb_sVolume * cvolcm_ConnectVolume ( pwr_tStatus *sts, gdb_sVolume *vp, net_sGvolume *gvp, gdb_sNode *np ) { gdb_sTouchQ *tqp; gdb_sVolume *ovp; gdb_AssumeLocked; if (vp->g.nid != pwr_cNNodeId && vp->g.nid != np->nid) { errh_Error("Volume %s (%s) is loaded from another node.\nCurrent: %s, new: %s", vp->g.name.orig, cdh_VolumeIdToString(NULL, vp->g.vid, 1, 0), cdh_NodeIdToString(NULL, vp->g.nid, 1, 0), cdh_NodeIdToString(NULL, np->nid, 1, 0)); return NULL; } vp->g = *gvp; pwr_Assert(vp->g.nid != pwr_cNNodeId); vp->l.nr = pool_Reference(NULL, gdbroot->pool, np); /* Add volume name to hash table. */ ovp = hash_Search(NULL, gdbroot->vn_ht, &vp->g.name); if (ovp != NULL) { if (ovp != vp) { errh_Warning("Volume name allready exist: %s, vid: %x\n", vp->g.name.orig, vp->g.vid); hash_Remove(NULL, gdbroot->vn_ht, ovp); ovp = hash_Insert(sts, gdbroot->vn_ht, vp); pwr_Assert(ovp == vp); } } else { ovp = hash_Insert(sts, gdbroot->vn_ht, vp); pwr_Assert(ovp == vp); } vp->l.flags.b.inVnTable = 1; pwr_Assert(!vp->l.flags.b.inOwnList); pool_QinsertPred(sts, gdbroot->pool, &vp->l.own_ll, &np->own_lh); vp->l.flags.b.inOwnList = 1; /* Initiate touch queues. */ tqp = &vp->u.c.cacheLock; pool_Qinit(NULL, gdbroot->pool, &tqp->lh); tqp->lc_max = 0; tqp->flags.b.cacheLock = 1; tqp->next = pool_cNRef; tqp = &vp->u.c.cacheVol; pool_Qinit(NULL, gdbroot->pool, &tqp->lh); #if defined OS_ELN tqp->lc_max = 100; #else tqp->lc_max = 200; #endif tqp->flags.b.cacheVol = 1; tqp->next = pool_Reference(NULL, gdbroot->pool, &np->cacheNode); vp->l.flags.b.isConnected = 1; vp->l.flags.b.isCached = 1; vp->l.flags.b.netCached = 1; vp->l.flags.b.remote = 1; return vp; }
static pwr_tStatus IoCardWrite( io_tCtx ctx, io_sAgent *ap, io_sRack *rp, io_sCard *cp) { io_sLocalAoDevice *local = (io_sLocalAoDevice *)cp->Local; pwr_sClass_OneWire_AoDevice *op = (pwr_sClass_OneWire_AoDevice *)cp->op; char str[80]; pwr_tUInt32 error_count = op->Super.ErrorCount; int num; if ( op->ScanInterval > 1) { if ( local->interval_cnt != 0) { local->interval_cnt++; if ( local->interval_cnt >= op->ScanInterval) local->interval_cnt = 0; return IO__SUCCESS; } local->interval_cnt++; } if ( cp->chanlist[0].cop && cp->chanlist[0].sop) { io_sChannel *chanp = &cp->chanlist[0]; pwr_sClass_ChanAo *cop = (pwr_sClass_ChanAo *)chanp->cop; pwr_sClass_Ao *sop = (pwr_sClass_Ao *)chanp->sop; if ( cop->CalculateNewCoef) // Request to calculate new coefficients io_AoRangeToCoef( chanp); switch ( op->ChAo.Representation) { case pwr_eDataRepEnum_Float32: case pwr_eDataRepEnum_Float64: { pwr_tFloat32 fvalue; fvalue = *(pwr_tFloat32 *)cp->chanlist[0].vbp * cop->OutPolyCoef1 + cop->OutPolyCoef0; if ( fvalue > cop->ActValRangeHigh) fvalue = cop->ActValRangeHigh; else if ( fvalue < cop->ActValRangeLow) fvalue = cop->ActValRangeLow; if ( fvalue > 0) sop->RawValue = fvalue + 0.5; else sop->RawValue = fvalue - 0.5; if ( strcmp( op->Format, "") == 0 ) num = snprintf( str, sizeof(str), "%f", fvalue); else num = snprintf( str, sizeof(str), op->Format, fvalue); if ( num == 0) op->Super.ErrorCount++; break; } default: { pwr_tInt32 ivalue; pwr_tFloat32 fvalue; fvalue = *(pwr_tFloat32 *)cp->chanlist[0].vbp * cop->OutPolyCoef1 + cop->OutPolyCoef0; if ( fvalue > cop->ActValRangeHigh) fvalue = cop->ActValRangeHigh; else if ( fvalue < cop->ActValRangeLow) fvalue = cop->ActValRangeLow; if ( fvalue > 0) ivalue = sop->RawValue = fvalue + 0.5; else ivalue = sop->RawValue = fvalue - 0.5; if ( strcmp( op->Format, "") == 0 ) num = snprintf( str, sizeof(str), "%d", ivalue); else num = snprintf( str, sizeof(str), op->Format, ivalue); if ( num == 0) op->Super.ErrorCount++; } } if ( num) { fprintf( local->value_fp, "%s", str); fflush( local->value_fp); rewind( local->value_fp); } } if ( op->Super.ErrorCount >= op->Super.ErrorSoftLimit && error_count < op->Super.ErrorSoftLimit) { errh_Warning( "IO Card ErrorSoftLimit reached, '%s'", cp->Name); } if ( op->Super.ErrorCount >= op->Super.ErrorHardLimit) { errh_Error( "IO Card ErrorHardLimit reached '%s', IO stopped", cp->Name); ctx->Node->EmergBreakTrue = 1; return IO__ERRDEVICE; } return IO__SUCCESS; }
static pwr_tStatus IoCardWrite( io_tCtx ctx, io_sAgent *ap, io_sRack *rp, io_sCard *cp) { io_sLocal_K8055 *local = (io_sLocal_K8055 *)cp->Local; pwr_sClass_Velleman_K8055_Board *op = (pwr_sClass_Velleman_K8055_Board *)cp->op; unsigned char data[9]; char endpoint = 0x1; int size = 8; int tsize; unsigned char m; int i; int sts; pwr_tUInt32 error_count = op->Super.ErrorCount; memset( data, 0, sizeof(data)); data[0] = 0x5; // Handle Do m = 1; unsigned char do_value = 0; for ( i = 0; i < 8; i++) { if ( cp->chanlist[i+9].sop) { if ( *(pwr_tBoolean *)cp->chanlist[i+9].vbp) do_value |= m; } m = m << 1; } data[1] = do_value; // Handle Ao for ( i = 0; i < 2; i++) { if ( cp->chanlist[i+7].sop) { io_sChannel *chanp = &cp->chanlist[i+7]; pwr_sClass_ChanAo *cop = (pwr_sClass_ChanAo *)chanp->cop; if ( cop->CalculateNewCoef) // Request to calculate new coefficients io_AoRangeToCoef( chanp); float fvalue = *(pwr_tFloat32 *)chanp->vbp * cop->OutPolyCoef1 + cop->OutPolyCoef0; int ivalue = (int)fvalue; if ( ivalue < 0) ivalue = 0; else if (ivalue > 255) ivalue = 255; data[i+2] = ivalue; } } sts = libusb_interrupt_transfer( local->libusb_device, endpoint, data, size, &tsize, 100); if ( sts != 0 || tsize != size) { op->Super.ErrorCount++; if ( sts != 0 && sts != last_usblib_sts) { errh_Error( "K8055 libusb transfer error %d", sts); last_usblib_sts = sts; } return IO__SUCCESS; } if ( op->Super.ErrorCount >= op->Super.ErrorSoftLimit && error_count < op->Super.ErrorSoftLimit) { errh_Warning( "IO Card ErrorSoftLimit reached, '%s'", cp->Name); } if ( op->Super.ErrorCount >= op->Super.ErrorHardLimit) { errh_Error( "IO Card ErrorHardLimit reached '%s', IO stopped", cp->Name); ctx->Node->EmergBreakTrue = 1; return IO__ERRDEVICE; } return IO__SUCCESS; }
static pwr_tStatus IoCardRead( io_tCtx ctx, io_sAgent *ap, io_sRack *rp, io_sCard *cp) { io_sLocal_K8055 *local = (io_sLocal_K8055 *)cp->Local; pwr_sClass_Velleman_K8055_Board *op = (pwr_sClass_Velleman_K8055_Board *)cp->op; unsigned char data[9]; char endpoint = 0x81; int size = 8; int tsize; unsigned char m; int sts; int i; pwr_tUInt32 error_count = op->Super.ErrorCount; // You have to read twice to get the latest ????? sts = libusb_interrupt_transfer( local->libusb_device, endpoint, data, 8, &tsize, 100); sts = libusb_interrupt_transfer( local->libusb_device, endpoint, data, 8, &tsize, 100); if ( sts != 0 || tsize != size) { op->Super.ErrorCount++; if ( sts != 0 && sts != last_usblib_sts) { errh_Error( "K8055 libusb transfer error %d", sts); last_usblib_sts = sts; } return IO__SUCCESS; } else { // Handle Ai for ( i = 0; i < 2; i++) { if ( cp->chanlist[i].sop) { io_sChannel *chanp = &cp->chanlist[i]; pwr_sClass_ChanAi *cop = (pwr_sClass_ChanAi *)chanp->cop; pwr_sClass_Ai *sop = (pwr_sClass_Ai *)chanp->sop; pwr_tFloat32 actvalue; int ivalue = data[i+2]; if ( cop->CalculateNewCoef) // Request to calculate new coefficients io_AiRangeToCoef( chanp); io_ConvertAi( cop, ivalue, &actvalue); // Filter if ( sop->FilterType == 1 && sop->FilterAttribute[0] > 0 && sop->FilterAttribute[0] > ctx->ScanTime) { actvalue = *(pwr_tFloat32 *)chanp->vbp + ctx->ScanTime / sop->FilterAttribute[0] * (actvalue - *(pwr_tFloat32 *)chanp->vbp); } *(pwr_tFloat32 *)chanp->vbp = actvalue; sop->SigValue = cop->SigValPolyCoef1 * ivalue + cop->SigValPolyCoef0; sop->RawValue = ivalue; } } // Handle Di for ( i = 0; i < 5; i++) { switch ( i) { case 0: m = 16; break; case 1: m = 32; break; case 2: m = 1; break; case 3: m = 64; break; case 4: m = 128; break; } if ( cp->chanlist[i+2].sop) *(pwr_tBoolean *)cp->chanlist[i+2].vbp = ((data[0] & m) != 0); } } if ( op->Super.ErrorCount >= op->Super.ErrorSoftLimit && error_count < op->Super.ErrorSoftLimit) { errh_Warning( "IO Card ErrorSoftLimit reached, '%s'", cp->Name); } if ( op->Super.ErrorCount >= op->Super.ErrorHardLimit) { errh_Error( "IO Card ErrorHardLimit reached '%s', IO stopped", cp->Name); ctx->Node->EmergBreakTrue = 1; return IO__ERRDEVICE; } return IO__SUCCESS; }
/*----------------------------------------------------------------------------*\ Read method for the Powerlink master \*----------------------------------------------------------------------------*/ static pwr_tStatus IoAgentRead( io_tCtx ctx, io_sAgent *ap) { io_sLocalEpl_MN *local = (io_sLocalEpl_MN *)ap->Local; io_sLocalEpl_CN *local1; pwr_sClass_Epl_MN *op = (pwr_sClass_Epl_MN *)ap->op; io_sRack *rp; io_sCard *cp; pwr_tUInt32 error_count = 0; int ret = IO__SUCCESS; if(!ap->Local) return ret; // Remeber the time when this functions was called the first time if( local->init == 0) { clock_gettime(CLOCK_REALTIME, &local->boot); local->init = 1; } // Time now (tps = time when bad state occurred) clock_gettime(CLOCK_REALTIME, &local->tpe); error_count = op->ErrorCount; // Add to error count if agent changed from good to bad state and setup is complete if( local->prevState == pwr_eEplNmtState_EplNmtMsOperational && op->NmtState != pwr_eEplNmtState_EplNmtMsOperational && ( (local->tpe).tv_sec - (local->boot).tv_sec) >= op->StartupTimeout) op->ErrorCount++; // Copy Powerlink process image to temp memory (only if stallaction=resetinputs else tmp_area=input_area) if( local->inputResetEnabled) memcpy( local->tmp_area , local->input_area, local->input_area_size); // If no bad state and were still in startup there can be no error (else remember when error occurred) if( op->NmtState == pwr_eEplNmtState_EplNmtMsOperational || ( (local->tpe).tv_sec - (local->boot).tv_sec) < op->StartupTimeout) { (local->tps).tv_sec = 0; local->timeoutStatus = 0; } else if( (local->tps).tv_sec == 0) { clock_gettime(CLOCK_REALTIME, &local->tps); } // Agent error soft limit reached, tell log (once) if ( op->ErrorCount >= op->ErrorSoftLimit && error_count < op->ErrorSoftLimit) { errh_Warning( "IO Agent ErrorSoftLimit reached, '%s'", ap->Name); } // Agent error hard limit reached, tell log (once) if ( op->ErrorCount >= op->ErrorHardLimit && error_count < op->ErrorHardLimit) { if( op->StallAction == pwr_eStallActionEnum_EmergencyBreak) { errh_Error( "IO Agent ErrorHardLimit reached '%s', IO stopped", ap->Name); } else errh_Error( "IO Agent ErrorHardLimit reached '%s'", ap->Name); } // Agent timeout has elapsed, tell log (once) if( ( (local->tpe).tv_sec - (local->tps).tv_sec) >= op->Timeout && local->timeoutStatus == 0 && (local->tps).tv_sec != 0) { local->timeoutStatus = 1; if( op->StallAction == pwr_eStallActionEnum_EmergencyBreak) { errh_Error( "IO Agent timeout time elapsed '%s', IO stopped", ap->Name); } else if( op->StallAction == pwr_eStallActionEnum_ResetInputs) { errh_Error( "IO Agent timeout time elapsed '%s', IO input area reset", ap->Name); } else errh_Error( "IO Agent timeout time elapsed '%s'", ap->Name); } // Agent error hard limit reached, take action (always) if ( op->ErrorCount >= op->ErrorHardLimit) { if( op->StallAction == pwr_eStallActionEnum_EmergencyBreak) { ctx->Node->EmergBreakTrue = 1; errh_SetStatus(PWR__SRVFATAL); IoAgentClose(ctx, ap); } ret = IO__ERRDEVICE; } // Agent timeout time elapsed, take action (always) if ( ( (local->tpe).tv_sec - (local->tps).tv_sec) >= op->Timeout && (local->tps).tv_sec != 0) { if( op->StallAction == pwr_eStallActionEnum_EmergencyBreak) { ctx->Node->EmergBreakTrue = 1; errh_SetStatus(PWR__SRVFATAL); IoAgentClose(ctx, ap); } else if( op->StallAction == pwr_eStallActionEnum_ResetInputs) { memset( local->tmp_area, 0, local->input_area_size); } ret = IO__ERRDEVICE; } // Remember agent state til next scan local->prevState = op->NmtState; // Loop through all slaves for ( rp = ap->racklist; rp; rp = rp->next) { ((pwr_sClass_Epl_CN *)rp->op)->Status = ((pwr_sClass_Epl_CN *)rp->op)->NmtState == pwr_eEplNmtState_EplNmtCsOperational ? IOM__EPL_OPER : IOM__EPL_NOOPER; local1 = (io_sLocalEpl_CN *)rp->Local; // Time now (tps = time when bad state occurred) clock_gettime(CLOCK_REALTIME, &local1->tpe); error_count = ((pwr_sClass_Epl_CN *)rp->op)->ErrorCount; // Add to error count if slave changed from good to bad state and setup is complete if( local1->prevState == pwr_eEplNmtState_EplNmtCsOperational && ((pwr_sClass_Epl_CN *)rp->op)->NmtState != pwr_eEplNmtState_EplNmtCsOperational && ( (local1->tpe).tv_sec - (local->boot).tv_sec) >= op->StartupTimeout) ((pwr_sClass_Epl_CN *)rp->op)->ErrorCount++; // Save time when bad state occurs if( ( (pwr_sClass_Epl_CN *)rp->op)->NmtState == pwr_eEplNmtState_EplNmtCsOperational || ( (local1->tpe).tv_sec - (local->boot).tv_sec) < op->StartupTimeout) { (local1->tps).tv_sec = 0; local1->timeoutStatus = 0; } else if( (local1->tps).tv_sec == 0) clock_gettime(CLOCK_REALTIME, &local1->tps); // Slave error soft limit reached, tell log (once) if ( ((pwr_sClass_Epl_CN *)rp->op)->ErrorCount >= ((pwr_sClass_Epl_CN *)rp->op)->ErrorSoftLimit && error_count < ((pwr_sClass_Epl_CN *)rp->op)->ErrorSoftLimit) { errh_Warning( "IO Rack ErrorSoftLimit reached, '%s'", rp->Name); } // Slave error hard limit reached, tell log (once) if ( ((pwr_sClass_Epl_CN *)rp->op)->ErrorCount >= ((pwr_sClass_Epl_CN *)rp->op)->ErrorHardLimit && error_count < ((pwr_sClass_Epl_CN *)rp->op)->ErrorHardLimit) { if( ((pwr_sClass_Epl_CN *)rp->op)->StallAction == pwr_eStallActionEnum_EmergencyBreak) { errh_Error( "IO Rack ErrorHardLimit reached '%s', IO stopped", rp->Name); } else errh_Error( "IO Rack ErrorHardLimit reached '%s'", rp->Name); } // Slave timeout has elapsed, tell log (once) if( ( (local1->tpe).tv_sec - (local1->tps).tv_sec) >= ((pwr_sClass_Epl_CN *)rp->op)->Timeout && local1->timeoutStatus == 0 && (local1->tps).tv_sec != 0) { local1->timeoutStatus = 1; if( ((pwr_sClass_Epl_CN *)rp->op)->StallAction == pwr_eStallActionEnum_EmergencyBreak) { errh_Error( "Rack timeout time elapsed '%s', IO stopped", rp->Name); } else if( ((pwr_sClass_Epl_CN *)rp->op)->StallAction == pwr_eStallActionEnum_ResetInputs) { errh_Error( "Rack timeout time elapsed '%s', IO input area reset", rp->Name); } else errh_Error( "Rack timeout time elapsed '%s'", rp->Name); } // Slave error hard limit reached, take action (always) if ( ((pwr_sClass_Epl_CN *)rp->op)->ErrorCount >= ((pwr_sClass_Epl_CN *)rp->op)->ErrorHardLimit) { if( ((pwr_sClass_Epl_CN *)rp->op)->StallAction == pwr_eStallActionEnum_EmergencyBreak) { ctx->Node->EmergBreakTrue = 1; errh_SetStatus(PWR__SRVFATAL); IoAgentClose(ctx, ap); } ret = IO__ERRDEVICE; } // Slave timeout elapsed, take action (always) if( ( (local1->tpe).tv_sec - (local1->tps).tv_sec) >= ((pwr_sClass_Epl_CN *)rp->op)->Timeout && (local1->tps).tv_sec != 0) { if( ((pwr_sClass_Epl_CN *)rp->op)->StallAction == pwr_eStallActionEnum_EmergencyBreak) { ctx->Node->EmergBreakTrue = 1; errh_SetStatus(PWR__SRVFATAL); IoAgentClose(ctx, ap); } else if( ((pwr_sClass_Epl_CN *)rp->op)->StallAction == pwr_eStallActionEnum_ResetInputs) { memset( local->tmp_area + ((pwr_sClass_Epl_CN *)rp->op)->InputAreaOffset, 0, ((pwr_sClass_Epl_CN *)rp->op)->InputAreaSize); } ret = IO__ERRDEVICE; } // Remeber slave state til next scan local1->prevState = ((pwr_sClass_Epl_CN *)rp->op)->NmtState; // Update Proview chan-objects with data from Powerlink process image for ( cp = rp->cardlist; cp; cp = cp->next) { io_bus_card_read( ctx, rp, cp, local->tmp_area, 0, ((io_sLocalEpl_CN *)rp->Local)->byte_ordering, pwr_eFloatRepEnum_FloatIEEE); } } return ret; }
static pwr_tStatus IoCardRead( io_tCtx ctx, io_sAgent *ap, io_sRack *rp, io_sCard *cp) { io_sLocalUSB_Joystick *local = (io_sLocalUSB_Joystick *)cp->Local; pwr_sClass_USB_Joystick *op = (pwr_sClass_USB_Joystick *)cp->op; struct js_event js; int idx; int value; while ( read( local->fd, &js, sizeof(struct js_event)) == sizeof(struct js_event)) { // printf("Event: type %d, time %d, number %d, value %d\n", js.type, js.time, js.number, js.value); switch ( js.type) { case 129: case 1: /* Buttons */ idx = js.number; if ( js.number < KEY_MAX - BTN_MISC) idx = local->button_map[js.number]; else break; *(pwr_tBoolean *)cp->chanlist[idx].vbp = (js.value != 0); break; case 130: case 2: { io_sChannel *chanp; pwr_sClass_ChanAi *cop; pwr_sClass_Ai *sop; pwr_tFloat32 actvalue; int ivalue; /* Axes */ idx = js.number; value = js.value; if ( js.number < ABS_MAX) { idx = local->axis_map[js.number]; ivalue = js.value; } else break; chanp = &cp->chanlist[idx]; cop = (pwr_sClass_ChanAi *)chanp->cop; sop = (pwr_sClass_Ai *)chanp->sop; if ( cop->CalculateNewCoef) // Request to calculate new coefficients io_AiRangeToCoef( chanp); io_ConvertAi( cop, ivalue, &actvalue); // Filter if ( sop->FilterType == 1 && sop->FilterAttribute[0] > 0 && sop->FilterAttribute[0] > ctx->ScanTime) { actvalue = *(pwr_tFloat32 *)chanp->vbp + ctx->ScanTime / sop->FilterAttribute[0] * (actvalue - *(pwr_tFloat32 *)chanp->vbp); } *(pwr_tFloat32 *)chanp->vbp = actvalue; sop->SigValue = cop->SigValPolyCoef1 * ivalue + cop->SigValPolyCoef0; sop->RawValue = ivalue; break; } } } if (errno != EAGAIN) { op->ErrorCount++; } if ( op->ErrorCount == op->ErrorSoftLimit) { errh_Warning( "IO Card ErrorSoftLimit reached, '%s'", cp->Name); ctx->IOHandler->CardErrorSoftLimit = 1; ctx->IOHandler->ErrorSoftLimitObject = cdh_ObjidToAref( cp->Objid); } if ( op->ErrorCount >= op->ErrorHardLimit) { errh_Error( "IO Card ErrorHardLimit reached '%s', IO stopped", cp->Name); ctx->Node->EmergBreakTrue = 1; ctx->IOHandler->CardErrorHardLimit = 1; ctx->IOHandler->ErrorHardLimitObject = cdh_ObjidToAref( cp->Objid); return IO__ERRDEVICE; } return IO__SUCCESS; }
void *handle_events(void *ptr) { agent_args *args; io_sAgentLocal *local; io_sAgent *ap; short sts; T_PROFI_DEVICE_HANDLE *hDevice; pwr_sClass_Pb_Profiboard *op; char s [128]; USIGN8 con_ind_buffer [256]; USIGN16 con_ind_buffer_len = 256; T_PROFI_SERVICE_DESCR con_ind_sdb; T_DP_GET_SLAVE_DIAG_CON *get_slave_diag_con_ptr; struct timespec rqtp = {0, 10000000}; // 10 ms args = (agent_args *) ptr; local = (io_sAgentLocal *) args->local; ap = args->ap; hDevice = (T_PROFI_DEVICE_HANDLE *) ap->Local; op = (pwr_sClass_Pb_Profiboard *) ap->op; /* If everything is fine we should be in state OPERATE Make a poll to see if there are diagnostics, the answer also tell us if there are any hardware faults. In that case, make a reset and a new init. */ while (1) { if (op->DisableBus) exit(0); pthread_mutex_lock(&local->mutex); con_ind_buffer_len = 256; sts = profi_rcv_con_ind ( hDevice, &con_ind_sdb, con_ind_buffer, &con_ind_buffer_len); if (sts == CON_IND_RECEIVED) { if (con_ind_sdb.primitive == CON) { if (con_ind_sdb.result == POS) { switch (con_ind_sdb.service) { /*--------------------------------------------------------------*/ case DP_ACT_PARAM_LOC: { if (op->Status == PB__NOTINIT) { op->Status = PB__STOPPED; errh_Info( "Profibus DP Master %s to state STOPPED", ap->Name); dp_act_param_loc(hDevice, DP_OP_MODE_CLEAR); } else if (op->Status == PB__STOPPED) { op->Status = PB__CLEARED; errh_Info( "Profibus DP Master %s to state CLEARED", ap->Name); dp_act_param_loc(hDevice, DP_OP_MODE_OPERATE); } else if (op->Status == PB__CLEARED) { errh_Info( "Profibus DP Master %s to state OPERATE", ap->Name); op->Status = PB__NORMAL; if (!local->slave_diag_requested && local->parallel_service) { if (dp_get_slave_diag(hDevice)) { local->slave_diag_requested = op->Diag[3] = PB_TRUE; local->parallel_service = PB_FALSE; } } } break; } /* case DP_ACT_PARAM_LOC */ /*--------------------------------------------------------------*/ case DP_GET_SLAVE_DIAG: { get_slave_diag_con_ptr = (T_DP_GET_SLAVE_DIAG_CON FAR*) con_ind_buffer; dp_get_slave_diag_con (get_slave_diag_con_ptr, ap->racklist, op->Diag[1]); op->Diag[2]++; local->slave_diag_requested = op->Diag[3] = PB_FALSE; if (get_slave_diag_con_ptr->diag_entries < 0) { errh_Warning( "Profibus - diagnostic circular buffer owerflow."); } if (get_slave_diag_con_ptr->diag_entries) { local->slave_diag_requested = op->Diag[3] = PB_TRUE; dp_get_slave_diag (hDevice); } break; } /* case DP_GET_SLAVE_DIAG */ /*--------------------------------------------------------------*/ default: { break; } /* deafult service */ } /* switch */ } /* if POS */ else { op->Status = PB__NOTINIT; errh_Error( "Profibus DP Master %s - %x neg con rec", ap->Name, *((unsigned short *) con_ind_buffer) ); } /* else POS */ } /* if CON */ else if (con_ind_sdb.primitive == IND) { if (con_ind_sdb.result == POS) { switch (con_ind_sdb.service) { case FMB_FM2_EVENT: { switch (((T_FMB_FM2_EVENT_IND FAR*) con_ind_buffer)->reason) { case FM2_FAULT_ADDRESS : sprintf (s, "Duplicate address recognized"); break; case FM2_FAULT_PHY : sprintf (s, "Phys.layer is malfunctioning"); break; case FM2_FAULT_TTO : sprintf (s, "Time out on bus detected "); break; case FM2_FAULT_SYN : sprintf (s, "No receiver synchronization "); break; case FM2_FAULT_OUT_OF_RING : sprintf (s, "Station out of ring "); break; case FM2_GAP_EVENT : sprintf (s, "New station in ring "); break; default : sprintf (s, "Unknown reason code received"); } /* switch reason */ errh_Info( "Profibus DP Master %s - %s", ap->Name, s ); break; } /* case FMB_FM2_EVENT */ /*--------------------------------------------------------------*/ case DP_ACT_PARAM_LOC: { USIGN8 usif_state; usif_state = ((T_DP_ACT_PARAM_IND FAR*) con_ind_buffer)->activate; switch (usif_state) { case DP_OP_MODE_STOP : { op->Status = PB__STOPPED; sprintf (s, "Mode changed to STOP"); break; } case DP_OP_MODE_CLEAR : { op->Status = PB__CLEARED; sprintf (s, "Mode changed to CLEAR"); break; } case DP_OP_MODE_OPERATE: { op->Status = PB__NORMAL; sprintf (s, "Mode changed to OPERATE"); break; } } errh_Info( "Profibus DP Master %s - %s", ap->Name, s ); if (usif_state == DP_OP_MODE_STOP) { usif_state = DP_OP_MODE_CLEAR; dp_act_param_loc(hDevice, DP_OP_MODE_CLEAR); } else if (usif_state == DP_OP_MODE_CLEAR) { usif_state = DP_OP_MODE_OPERATE; dp_act_param_loc (hDevice, DP_OP_MODE_OPERATE); } break; } /* case DP_ACT_PARAM_LOC */ /*--------------------------------------------------------------*/ case DP_GET_SLAVE_DIAG: { get_slave_diag_con_ptr = (T_DP_GET_SLAVE_DIAG_CON FAR*) con_ind_buffer; dp_get_slave_diag_con (get_slave_diag_con_ptr, ap->racklist, op->Diag[1]); op->Diag[0]++; if (get_slave_diag_con_ptr->diag_entries < 0) { errh_Warning( "Profibus - diagnostic circular buffer owerflow."); } if ( (get_slave_diag_con_ptr->diag_entries) && (! local->slave_diag_requested ) ) { if (op->Status == PB__NORMAL) { if (dp_get_slave_diag(hDevice)) { local->slave_diag_requested = op->Diag[3] = PB_TRUE; } else { errh_Warning( "Profibus - Request for diag failed."); } } else { local->parallel_service = PB_TRUE; } } break; } /* case DP_GET_SLAVE_DIAG */ /*--------------------------------------------------------------*/ default: { break; } /* deafult service */ } /* switch */ } /* if POS */ else { op->Status = PB__NOTINIT; errh_Error( "Profibus DP Master %s - %x neg ind rec", ap->Name, *((unsigned short *) con_ind_buffer) ); } /* else POS */ } /* if IND */ } else if (sts != NO_CON_IND_RECEIVED) { op->Status = PB__NOTINIT; } else { if (local->slave_diag_requested) { // errh_Info( "Profibus - Diag re-request"); // dp_get_slave_diag(hDevice); } } pthread_mutex_unlock(&local->mutex); nanosleep(&rqtp, NULL); } }